Liste des types de résultats - Amazon Braket

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Liste des types de résultats

Amazon Braket peut renvoyer différents types de résultats lorsqu'un circuit est mesuré à l'aide de. ResultType Un circuit peut renvoyer les types de résultats suivants.

  • AdjointGradientrenvoie le gradient (dérivé vectoriel) de la valeur attendue d'un observable fourni. Cet observable agit sur une cible donnée par rapport à des paramètres spécifiés en utilisant la méthode de différenciation adjointe. Vous ne pouvez utiliser cette méthode que lorsque shots=0.

  • Amplituderenvoie l'amplitude des états quantiques spécifiés dans la fonction d'onde de sortie. Il est disponible sur le SV1 et simulateurs locaux uniquement.

  • Expectationrenvoie la valeur attendue d'un observable donné, qui peut être spécifiée avec la Observable classe présentée plus loin dans ce chapitre. La cible qubits utilisé pour mesurer l'observable doit être spécifié, et le nombre de cibles spécifiées doit être égal au nombre de qubits sur lequel l'observable agit. Si aucune cible n'est spécifiée, l'observable ne doit fonctionner que sur 1 qubit et elle s'applique à tous qubits en parallèle.

  • Probabilityrenvoie les probabilités de mesure des états de base de calcul. Si aucune cible n'est spécifiée, Probability renvoie la probabilité de mesurer tous les états de base. Si des cibles sont spécifiées, seules les probabilités marginales des vecteurs de base sur les valeurs spécifiées qubits sont renvoyés.

  • Reduced density matrixrenvoie une matrice de densité pour un sous-système de la cible spécifiée qubits à partir d'un système de qubits. Pour limiter la taille de ce type de résultat, Braket limite le nombre de cibles qubits jusqu'à un maximum de 8.

  • StateVectorrenvoie le vecteur d'état complet. Il est disponible sur le simulateur local.

  • Samplerenvoie le nombre de mesures d'une cible spécifiée qubit défini et observable. Si aucune cible n'est spécifiée, l'observable ne doit fonctionner que sur 1 qubit et elle s'applique à tous qubits en parallèle. Si des cibles sont spécifiées, le nombre de cibles spécifiées doit être égal au nombre de qubits sur lequel l'observable agit.

  • Variancerenvoie la variance (mean([x-mean(x)]2)) de la cible spécifiée qubit défini et observable en tant que type de résultat demandé. Si aucune cible n'est spécifiée, l'observable ne doit fonctionner que sur 1 qubit et elle s'applique à tous qubits en parallèle. Sinon, le nombre de cibles spécifiées doit être égal au nombre de qubits auxquels l'observable peut être appliqué.

Les types de résultats pris en charge pour les différents appareils :

SIM locale

SV1

DM1

TN1

Rigetti

IonQ

IQM

Gradient Adjoint

N

Y

N

N

N

N

N

Amplitude

Y

Y

N

N

N

N

N

Espérance

Y

Y

Y

Y

Y

Y

Y

Probability

Y

Y

Y

N

Y*

Y

Y

Matrice à densité réduite

Y

N

Y

N

N

N

N

Vecteur d'état

Y

N

N

N

N

N

N

Exemple

Y

Y

Y

Y

Y

Y

Y

Variance

Y

Y

Y

Y

Y

Y

Y
Note

* Rigetti ne prend en charge que les types de résultats probabilistes allant jusqu'à 40 qubits.

Vous pouvez vérifier les types de résultats pris en charge en examinant les propriétés de l'appareil, comme indiqué dans l'exemple suivant.

device = AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-2")

# print the result types supported by this device
for iter in device.properties.action['braket.ir.openqasm.program'].supportedResultTypes:
    print(iter)
name='Sample' observables=['x', 'y', 'z', 'h', 'i'] minShots=10 maxShots=50000
name='Expectation' observables=['x', 'y', 'z', 'h', 'i'] minShots=10 maxShots=50000
name='Variance' observables=['x', 'y', 'z', 'h', 'i'] minShots=10 maxShots=50000
name='Probability' observables=None minShots=10 maxShots=50000

Pour appeler aResultType, ajoutez-le à un circuit, comme indiqué dans l'exemple suivant.

from braket.circuits import Observable

circ = Circuit().h(0).cnot(0, 1).amplitude(state=["01", "10"])
circ.probability(target=[0, 1])
circ.probability(target=0)
circ.expectation(observable=Observable.Z(), target=0)
circ.sample(observable=Observable.X(), target=0)
circ.state_vector()
circ.variance(observable=Observable.Z(), target=0)

# print one of the result types assigned to the circuit
print(circ.result_types[0])
Note

Certains appareils fournissent des mesures (par exemple Rigetti) car les résultats et d'autres fournissent des probabilités sous forme de résultats (par exemple IonQ). SDKfournit une propriété de mesure sur les résultats, mais pour les appareils qui renvoient des probabilités, elle est post-calculée. Ainsi, des appareils tels que ceux fournis par IonQ les résultats des mesures sont déterminés par probabilité, car les mesures par tir ne sont pas renvoyées. Vous pouvez vérifier si un résultat est post-calculé en visualisant measurements_copied_from_device l'objet du résultat comme indiqué dans ce fichier.

Observables

Amazon Braket inclut une Observable classe, qui peut être utilisée pour spécifier un observable à mesurer.

Vous pouvez appliquer au plus une non-identité unique observable à chacun qubit. Si vous spécifiez deux ou plusieurs observables non identitaires différents pour la même qubit, un message d'erreur s'affiche. À cette fin, chaque facteur d'un produit tensoriel est considéré comme un observable individuel, il est donc permis d'avoir plusieurs produits tensoriels agissant sur le même qubit, à condition que le facteur agissant en conséquence qubit c'est pareil.

Vous pouvez également redimensionner un observable et ajouter des observables (mis à l'échelle ou non). Cela crée un Sum qui peut être utilisé dans le type de AdjointGradient résultat.

La Observable classe inclut les observables suivants.

Observable.I()
Observable.H()
Observable.X()
Observable.Y()
Observable.Z()

# get the eigenvalues of the observable
print("Eigenvalue:", Observable.H().eigenvalues)
# or whether to rotate the basis to be computational basis
print("Basis rotation gates:",Observable.H().basis_rotation_gates)

# get the tensor product of observable for the multi-qubit case
tensor_product = Observable.Y() @ Observable.Z()
# view the matrix form of an observable by using
print("The matrix form of the observable:\n",Observable.Z().to_matrix())
print("The matrix form of the tensor product:\n",tensor_product.to_matrix())

# also factorize an observable in the tensor form
print("Factorize an observable:",tensor_product.factors)

# self-define observables given it is a Hermitian
print("Self-defined Hermitian:",Observable.Hermitian(matrix=np.array([[0, 1],[1, 0]])))

print("Sum of other (scaled) observables:", 2.0 * Observable.X() @ Observable.X() + 4.0 * Observable.Z() @ Observable.Z())
Eigenvalue: [ 1 -1]
Basis rotation gates: (Ry('angle': -0.7853981633974483, 'qubit_count': 1),)
The matrix form of the observable:
 [[ 1.+0.j  0.+0.j]
 [ 0.+0.j -1.+0.j]]
The matrix form of the tensor product:
 [[ 0.+0.j  0.+0.j  0.-1.j  0.-0.j]
 [ 0.+0.j -0.+0.j  0.-0.j  0.+1.j]
 [ 0.+1.j  0.+0.j  0.+0.j  0.+0.j]
 [ 0.+0.j -0.-1.j  0.+0.j -0.+0.j]]
Factorize an observable: (Y('qubit_count': 1), Z('qubit_count': 1))
Self-defined Hermitian: Hermitian('qubit_count': 1, 'matrix': [[0.+0.j 1.+0.j], [1.+0.j 0.+0.j]])
Sum of other (scaled) observables: Sum(TensorProduct(X('qubit_count': 1), X('qubit_count': 1)), TensorProduct(Z('qubit_count': 1), Z('qubit_count': 1)))

Paramètres

Les circuits peuvent inclure des paramètres libres, que vous pouvez utiliser d'une manière « construite une fois, exécuter plusieurs fois » et pour calculer des gradients. Les paramètres libres ont un nom codé sous forme de chaîne que vous pouvez utiliser pour spécifier leurs valeurs ou pour déterminer s'il convient de les différencier.

from braket.circuits import Circuit, FreeParameter, Observable
theta = FreeParameter("theta")
phi = FreeParameter("phi")
circ = Circuit().h(0).rx(0, phi).ry(0, phi).cnot(0, 1).xx(0, 1, theta)
circ.adjoint_gradient(observable=Observable.Z() @ Observable.Z(), target=[0, 1], parameters = ["phi", theta]

Pour les paramètres que vous souhaitez différencier, spécifiez-les soit en utilisant leur nom (sous forme de chaîne), soit par référence directe. Notez que le calcul du gradient à l'aide du type de AdjointGradient résultat est effectué par rapport à la valeur attendue de l'observable.

Remarque : Si vous avez fixé les valeurs des paramètres libres en les transmettant comme arguments au circuit paramétré, l'exécution d'un circuit avec AdjointGradient comme résultat le type et les paramètres spécifiés produira une erreur. Cela est dû au fait que les paramètres que nous utilisons pour nous différencier ne sont plus présents. Consultez l'exemple suivant.

device.run(circ(0.2), shots=0) # will error, as no free parameters will be present
device.run(circ, shots=0, inputs={'phi'=0.2, 'theta'=0.2) # will succeed