Tipos de resultados

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

• AdjointGradientretorna o gradiente (derivada vetorial) do valor esperado de um observável fornecido. Esse observável está agindo em um alvo fornecido em relação aos parâmetros especificados usando o método de diferenciação adjunta. Você só pode usar esse método quando tiros = 0.

• Amplituderetorna a amplitude dos estados quânticos especificados na função de onda de saída. Ele está disponível somente nos simuladores locais SV1 e nos simuladores.

• Expectationretorna o valor esperado de um determinado observável, que pode ser especificado com a Observable classe apresentada posteriormente neste capítulo. O alvo qubits usado para medir o observável deve ser especificado e o número de alvos especificados deve ser igual ao número qubits sobre o qual o observável atua. Se nenhum alvo for especificado, o observável deve operar somente em 1 qubit e é aplicado a todos qubits em paralelo.

• Probabilityretorna as probabilidades de medir estados de base computacional. Se nenhuma meta for especificada, Probability retorna a probabilidade de medir todos os estados básicos. Se os alvos forem especificados, somente as probabilidades marginais dos vetores básicos nos especificados serão retornadas. qubits

• Reduced density matrixretorna uma matriz de densidade para um subsistema de destino especificado qubits de um sistema dequbits. Para limitar o tamanho desse tipo de resultado, Braket limita o número de alvos qubits a um máximo de 8.

• StateVectorretorna o vetor de estado completo. Ele está disponível no simulador local.

• Sampleretorna as contagens de medição de um alvo especificado qubit definido e observável. Se nenhum alvo for especificado, o observável deve operar somente em 1 qubit e é aplicado a todos qubits em paralelo. Se os alvos forem especificados, o número de alvos especificados deverá ser igual ao número qubits sobre os quais o observável atua.

• Varianceretorna a variância (mean([x-mean(x)]2)) do qubit conjunto de destino especificado e observável como o tipo de resultado solicitado. Se nenhum alvo for especificado, o observável deve operar somente em 1 qubit e é aplicado a todos qubits em paralelo. Caso contrário, o número de alvos especificados deve ser igual ao número qubits ao qual o observável pode ser aplicado.

Os tipos de resultados suportados para diferentes dispositivos:

	Sim local	SV1	DM1	TN1	Rigetti	IonQ	OQC
Gradiente adjunto	N	Y	N	N	N	N	N
Amplitude	Y	Y	N	N	N	N	N
Expectativa	Y	Y	Y	Y	Y	Y	Y
Probabilidade	Y	Y	Y	N	Y*	Y	Y
Matriz de densidade reduzida	Y	N	Y	N	N	N	N
Vetor de estado	Y	N	N	N	N	N	N
Amostra	Y	Y	Y	Y	Y	Y	Y
Variação	Y	Y	Y	Y	Y	Y	Y

nota

* suporta Rigetti apenas tipos de resultados de probabilidade de até 40qubits.

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

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

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

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

nota

Alguns dispositivos fornecem medições (por exemploRigetti) como resultados e outros fornecem probabilidades como resultados (por exemplo IonQ eOQC). O SDK fornece uma propriedade de medição nos resultados, mas para os dispositivos que retornam probabilidades, ela é pós-computada. Assim, dispositivos como os fornecidos por IonQ e OQC têm resultados de medição determinados pela probabilidade, uma vez que as medições por disparo não são retornadas. Você pode verificar se um resultado foi pós-computado visualizando o measurements_copied_from_device no objeto resultante, conforme mostrado neste arquivo.

Observáveis

AmazonBraket inclui uma Observable classe, que pode ser usada para especificar um observável a ser medido.

Você pode aplicar no máximo uma única não identidade observável a cada um. qubit Se você especificar dois ou mais observáveis sem identidade diferentes para o mesmoqubit, verá um erro. Para tanto, cada fator de um produto tensorial conta como um indivíduo observável, portanto, é permitido ter vários produtos tensoriais atuando sobre o mesmoqubit, desde que o fator que atua sobre ele seja o mesmo. qubit

Você também pode escalar um observável e adicionar 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.

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

Parâmetros

Os circuitos podem incluir parâmetros livres, que você pode usar de forma “construir uma vez - executar várias vezes” e para calcular gradientes. Os parâmetros livres têm um nome codificado por string que você pode usar para especificar seus valores ou determinar se deve ser diferenciado em relação a eles.

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]

Para os parâmetros que você deseja diferenciar, especifique-os usando seu nome (como uma string) ou por referência direta. Observe que o cálculo do gradiente usando o tipo de AdjointGradient resultado é feito com relação ao valor esperado do observável.

Nota: Se você fixou os valores dos parâmetros livres passando-os como argumentos para o circuito parametrizado, executar um circuito com o tipo de AdjointGradient resultado e os parâmetros especificados produzirá um erro. Isso ocorre porque os parâmetros que estamos usando para diferenciar não estão mais presentes. Veja o exemplo a seguir.

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