Types de résultats

AmazonBraket peut renvoyer différents types de résultats lorsqu'un circuit est mesuré à l'aide ResultType de. 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 n'est disponible que sur les simulateurs locaux SV1 et sur les simulateurs.

• 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ée pour mesurer l'observable doit être spécifiée, et le nombre de cibles spécifiées doit être égal au nombre de cibles qubits sur lesquelles l'observable agit. Si aucune cible n'est spécifiée, l'observable ne doit fonctionner que sur 1 qubit et il est appliqué à 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 cibles spécifiées qubits sont renvoyées.

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

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

• Samplerenvoie le nombre de mesures d'un qubit ensemble cible spécifié et observable. Si aucune cible n'est spécifiée, l'observable ne doit fonctionner que sur 1 qubit et il est appliqué à 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 cibles qubits sur lesquelles l'observable agit.

• Variancerenvoie la variance (mean([x-mean(x)]2)) de l'qubitensemble de cibles spécifié 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 il est appliqué à tous qubits en parallèle. Sinon, le nombre de cibles spécifiées doit être égal qubits au nombre auquel 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	OQC
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'à 40qubits.

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/Aspen-M-3")

# print the result types supported by this device
for iter in device.properties.action['braket.ir.jaqcd.program'].supportedResultTypes:
    print(iter)

name='Sample' observables=['x', 'y', 'z', 'h', 'i'] minShots=10 maxShots=100000
name='Expectation' observables=['x', 'y', 'z', 'h', 'i'] minShots=10 maxShots=100000
name='Variance' observables=['x', 'y', 'z', 'h', 'i'] minShots=10 maxShots=100000
name='Probability' observables=None minShots=10 maxShots=100000

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 exempleRigetti) sous forme de résultats, tandis que d'autres fournissent des probabilités sous forme de résultats (par exemple IonQ etOQC). Le SDK fournit une propriété de mesure sur les résultats, mais pour les appareils qui renvoient des probabilités, elle est post-calculée. Ainsi, les appareils tels que ceux fournis par IonQ et dont les résultats de mesure OQC 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

AmazonBraket 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 chosequbit, une erreur s'affiche. À cette fin, chaque facteur d'un produit tensoriel compte comme une observable individuelle, il est donc permis d'avoir plusieurs produits tensoriels agissant sur le mêmequbit, à condition que le facteur agissant sur celui-ci qubit soit le même.

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