As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Lista de tipos de resultados

O Amazon Braket pode retornar diferentes tipos de resultados quando um circuito é medido usando. ResultType Um circuito pode retornar os seguintes tipos de resultados.

Os tipos de resultados suportados para diferentes dispositivos:

Você pode verificar os tipos de resultados suportados examinando as propriedades do dispositivo, conforme mostrado no exemplo a seguir.

from braket.aws import AwsDevice

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

# 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

Para chamar aResultType, anexe-a a um circuito, conforme mostrado no exemplo a seguir.

from braket.circuits import Circuit, 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])

Observáveis

A Observable classe do Amazon Braket permite medir um observável específico.

Você pode aplicar somente uma única não identidade observável a cada um. qubit Ocorre um erro se você especificar dois ou mais observáveis sem identidade diferentes para o mesmo. qubit Para isso, cada fator de um produto tensorial conta como um indivíduo observável. Isso significa que você pode ter vários produtos tensoriais no mesmoqubit, desde que os fatores que atuam sobre eles qubit permaneçam os mesmos.

Um observável pode ser escalado e adicionar outros observáveis (escalonados ou não). Isso cria um Sum que pode ser usado no tipo de AdjointGradient resultado.

A Observable classe inclui os seguintes observáveis.

import numpy as np

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

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

# Get the tensor product of the 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())

# 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)))

Parâmetros

Os circuitos podem incorporar parâmetros livres. Esses parâmetros livres só precisam ser construídos uma vez para serem executados várias vezes e podem ser usados para calcular gradientes.

Cada parâmetro livre usa um nome codificado em string que é usado para:

from braket.circuits import Circuit, FreeParameter, observables
from braket.parametric import FreeParameter

theta = FreeParameter("theta")
phi = FreeParameter("phi")
circ = Circuit().h(0).rx(0, phi).ry(0, phi).cnot(0, 1).xx(0, 1, theta)

Gradiente adjunto

O SV1 dispositivo calcula o gradiente adjunto de um valor esperado observável, incluindo hamiltoniano de vários termos. Para diferenciar os parâmetros, especifique seu nome (em formato de string) ou por referência direta.

from braket.aws import AwsDevice
from braket.devices import Devices

device = AwsDevice(Devices.Amazon.SV1)

circ.adjoint_gradient(observable=3 * Observable.Z(0) @ Observable.Z(1) - 0.5 * observables.X(0), parameters = ["phi", theta])

Passar valores de parâmetros fixos como argumentos para um circuito parametrizado removerá os parâmetros livres. Executar esse circuito com AdjointGradient produz um erro, porque os parâmetros livres não existem mais. O exemplo de código a seguir demonstra o uso correto e incorreto:

# Will error, as no free parameters will be present
#device.run(circ(0.2), shots=0)

# Will succeed
device.run(circ, shots=0, inputs={'phi': 0.2, 'theta': 0.2})