Nota
Esta página foi gerada, a partir do tutorials/operators/02_gradients_framework.ipynb.
Execute interativamente no IBM Quantum lab.
Framework de Gradientes Qiskit¶
O framework de gradientes permite a avaliação dos gradientes quânticos bem como das suas funções. Além de gradientes de primeira ordem padrões de valores esperados da forma
O framework de gradientes também suporta o cálculo de gradientes de segunda ordem (Hessianas), e a Informação de Fisher Quântica (QFI) de estados quânticos \(|\psi\left(\theta\right)\rangle\).
Imports¶
[1]:
#General imports
import numpy as np
#Operator Imports
from qiskit.aqua.operators import Z, X, I, StateFn, CircuitStateFn, SummedOp
from qiskit.aqua.operators.gradients import Gradient, NaturalGradient, QFI, Hessian
#Circuit imports
from qiskit.circuit import QuantumCircuit, QuantumRegister, Parameter, ParameterVector, ParameterExpression
from qiskit.circuit.library import EfficientSU2
Gradientes de Primeira Ordem¶
Dado um estado quântico parametrizado \(|\psi\left(\theta\right)\rangle = V\left(\theta\right)|\psi\rangle\) com estado de entrada \(|\psi\rangle\), Ansatz parametrizado \(V\left(\theta\right)\), e observável \(\hat{O}\left(\omega\right)=\sum_{i}\omega_i\hat{O}_i\), queremos calcular…
Gradientes com respeito aos Parâmetros do Operador de Medição¶
Gradiente do valor esperado com respeito a um coeficiente do operador de medição respectivamente observável \(\hat{O}\left(\omega\right)\), ou seja,
Primeiramente, nós definimos um estado quântico \(|\psi\left(\theta\right)\rangle\) e um Hamiltoniano \(H\) agindo como observável. Em seguida, o estado e o Hamiltoniano são envolvidos em um objeto que define o valor esperado
[2]:
# Instantiate the quantum state
a = Parameter('a')
b = Parameter('b')
q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.h(q)
qc.rz(a, q[0])
qc.rx(b, q[0])
# Instantiate the Hamiltonian observable
coeff_0 = Parameter('c_0')
coeff_1 = Parameter('c_1')
H = (coeff_0*coeff_0*2)*X + coeff_1 * Z
# Combine the Hamiltonian observable and the state
op = ~StateFn(H) @ CircuitStateFn(primitive=qc, coeff=1.)
# Print the operator corresponding to the expectation value
print(op)
ComposedOp([
OperatorMeasurement(SummedOp([
2.0*c_0**2 * X,
1.0*c_1 * Z
])),
CircuitStateFn(
┌───┐┌───────┐┌───────┐
q0_0: ┤ H ├┤ RZ(a) ├┤ RX(b) ├
└───┘└───────┘└───────┘
)
])
Construímos uma lista dos parâmetros para os quais pretendemos avaliar o gradiente. Neste caso, os parâmetros são dados como os coeficientes de \(H\). Agora, esta lista e o operador de valor esperado são utilizados para gerar o operador que representa o gradiente.
[3]:
# Define the coefficients w.r.t. we want to compute the gradient
obs_coeffs = [coeff_0, coeff_1]
# Define the values to be assigned to the parameters
value_dict = {coeff_0: 0.5, coeff_1: -1, a: np.pi / 4, b: np.pi}
# Convert the operator and the gradient target coefficients into the respective operator
grad = Gradient().convert(operator = op, params = obs_coeffs)
# Print the operator corresponding to the Gradient
print(grad)
ListOp([
4.0*c_0 * ComposedOp([
OperatorMeasurement(1.00000000000000 * Z),
CircuitStateFn(
┌───┐┌───────┐┌───────┐┌───┐
q0_0: ┤ H ├┤ RZ(a) ├┤ RX(b) ├┤ H ├
└───┘└───────┘└───────┘└───┘
)
]),
1.00000000000000 * ComposedOp([
OperatorMeasurement(1.00000000000000 * Z),
CircuitStateFn(
┌───┐┌───────┐┌───────┐
q0_0: ┤ H ├┤ RZ(a) ├┤ RX(b) ├
└───┘└───────┘└───────┘
)
])
])
All that is left to do is to assign values to the parameters and to evaluate the gradient operators.
[4]:
# Assign the parameters and evaluate the gradient
grad_result = grad.assign_parameters(value_dict).eval()
print('Gradient', grad_result)
Gradient [(1.414213562373095+1.12e-16j), 0j]
Gradientes com respeito aos Parâmetros de Estado¶
Gradiente de um valor esperado com respeito a um parâmetro do estado \(|\psi\left(\theta\right)\rangle\), ou seja,
respectivamente às probabilidades amostradas com respeito a um parâmetro do estado \(|\psi\left(\theta\right)\rangle\), ou seja,
Um gradiente com respeito a um parâmetro de estado pode ser avaliado com métodos diferentes. Cada método tem vantagens e desvantagens.
[5]:
# Define the Hamiltonian with fixed coefficients
H = 0.5 * X - 1 * Z
# Define the parameters w.r.t. we want to compute the gradients
params = [a, b]
# Define the values to be assigned to the parameters
value_dict = { a: np.pi / 4, b: np.pi}
# Combine the Hamiltonian observable and the state into an expectation value operator
op = ~StateFn(H) @ CircuitStateFn(primitive=qc, coeff=1.)
print(op)
ComposedOp([
OperatorMeasurement(SummedOp([
0.5 * X,
-1.0 * Z
])),
CircuitStateFn(
┌───┐┌───────┐┌───────┐
q0_0: ┤ H ├┤ RZ(a) ├┤ RX(b) ├
└───┘└───────┘└───────┘
)
])
Gradientes de Deslocamento de Parâmetro¶
Dado um operador Hermitiano \(g\) com dois autovalores únicos \(\pm r\) que atua como gerador para uma porta quântica parametrizada
Então, gradientes quânticos podem ser calculados usando deslocamentos dependentes do autovalor \(r\) para os parâmetros. Todas as portas padrões e parametrizadas do Qiskit podem ser deslocadas com \(\pi/2\), isto é,
Os gradientes da probabilidade são computados equivalentemente.
[6]:
# Convert the expectation value into an operator corresponding to the gradient w.r.t. the state parameters using
# the parameter shift method.
state_grad = Gradient(grad_method='param_shift').convert(operator=op, params=params)
# Print the operator corresponding to the gradient
print(state_grad)
# Assign the parameters and evaluate the gradient
state_grad_result = state_grad.assign_parameters(value_dict).eval()
print('State gradient computed with parameter shift', state_grad_result)
ListOp([
SummedOp([
0.25 * ComposedOp([
OperatorMeasurement(Z),
CircuitStateFn(
┌───┐┌─────────────────────────┐┌───────┐┌───┐
q0_0: ┤ H ├┤ RZ(a + 1.5707963267949) ├┤ RX(b) ├┤ H ├
└───┘└─────────────────────────┘└───────┘└───┘
)
]),
-0.25 * ComposedOp([
OperatorMeasurement(Z),
CircuitStateFn(
┌───┐┌─────────────────────────┐┌───────┐┌───┐
q0_0: ┤ H ├┤ RZ(a - 1.5707963267949) ├┤ RX(b) ├┤ H ├
└───┘└─────────────────────────┘└───────┘└───┘
)
]),
-0.5 * ComposedOp([
OperatorMeasurement(Z),
CircuitStateFn(
┌───┐┌─────────────────────────┐┌───────┐
q0_0: ┤ H ├┤ RZ(a + 1.5707963267949) ├┤ RX(b) ├
└───┘└─────────────────────────┘└───────┘
)
]),
0.5 * ComposedOp([
OperatorMeasurement(Z),
CircuitStateFn(
┌───┐┌─────────────────────────┐┌───────┐
q0_0: ┤ H ├┤ RZ(a - 1.5707963267949) ├┤ RX(b) ├
└───┘└─────────────────────────┘└───────┘
)
])
]),
SummedOp([
0.25 * ComposedOp([
OperatorMeasurement(Z),
CircuitStateFn(
┌───┐┌───────┐┌─────────────────────────┐┌───┐
q0_0: ┤ H ├┤ RZ(a) ├┤ RX(b + 1.5707963267949) ├┤ H ├
└───┘└───────┘└─────────────────────────┘└───┘
)
]),
-0.25 * ComposedOp([
OperatorMeasurement(Z),
CircuitStateFn(
┌───┐┌───────┐┌─────────────────────────┐┌───┐
q0_0: ┤ H ├┤ RZ(a) ├┤ RX(b - 1.5707963267949) ├┤ H ├
└───┘└───────┘└─────────────────────────┘└───┘
)
]),
-0.5 * ComposedOp([
OperatorMeasurement(Z),
CircuitStateFn(
┌───┐┌───────┐┌─────────────────────────┐
q0_0: ┤ H ├┤ RZ(a) ├┤ RX(b + 1.5707963267949) ├
└───┘└───────┘└─────────────────────────┘
)
]),
0.5 * ComposedOp([
OperatorMeasurement(Z),
CircuitStateFn(
┌───┐┌───────┐┌─────────────────────────┐
q0_0: ┤ H ├┤ RZ(a) ├┤ RX(b - 1.5707963267949) ├
└───┘└───────┘└─────────────────────────┘
)
])
])
])
State gradient computed with parameter shift [(-0.35355339059327373-4.175e-17j), (0.7071067811865475+4.15e-17j)]
Combinação Linear de Gradientes Unitários¶
Unitários podem ser escritos como \(U\left(\omega\right) = e^{iM\left(\omega\right)}\), onde \(M\left(\omega\right)\) denota uma matriz Hermitiana parametrizada. Além disso, as matrizes Hermitianas podem ser decompostas em somas ponderadas de termos Pauli, ou seja, \(M\left(\omega\right) = \sum_pm_p\left(\omega\right)h_p\) com \(m_p\left(\omega\right)\in\mathbb{R}\) e \(h_p=\bigotimes\limits_{j=0}^{n-1}\sigma_{j, p}\) para \(\sigma_{j, p}\left\{I, X, Y, Z\right\}\) atuando no valor \(j^{\text{th}}\). Assim, os gradientes de \(U_k\left(\omega_k\right)\) são dados por \begin{equation*} \frac{\partial U_k\left(\omega_k\right)}{\partial\omega_k} = \sum\limits_pi \frac{\partial m_{k,p}\left(\omega_k\right)}{\partial\omega_k}U_k\left(\omega_k\right)_{k_p}. \end{equation*}
Combinando esta observação com a estrutura de circuito apresentada em Simulating physical phenomena by quantum networks nos permite calcular o gradiente com a avaliação de um único circuito quântico.
[7]:
# Convert the expectation value into an operator corresponding to the gradient w.r.t. the state parameter using
# the linear combination of unitaries method.
state_grad = Gradient(grad_method='lin_comb').convert(operator=op, params=params)
# Print the operator corresponding to the gradient
print(state_grad)
# Assign the parameters and evaluate the gradient
state_grad_result = state_grad.assign_parameters(value_dict).eval()
print('State gradient computed with the linear combination method', state_grad_result)
ListOp([
SummedOp([
0.5 * ComposedOp([
OperatorMeasurement(ZZ) * 2.0,
CircuitStateFn(
┌───┐ ┌───────┐┌───────┐┌───┐
q0_0: ┤ H ├────────■─┤ RZ(a) ├┤ RX(b) ├┤ H ├
├───┤┌─────┐ │ └─┬───┬─┘└───────┘└───┘
work_qubit_lin_comb_grad_0: ┤ H ├┤ SDG ├─■───┤ H ├────────────────
└───┘└─────┘ └───┘
) * 0.7071067811865476
]),
-1.0 * ComposedOp([
OperatorMeasurement(ZZ) * 2.0,
CircuitStateFn(
┌───┐ ┌───────┐┌───────┐
q0_0: ┤ H ├────────■─┤ RZ(a) ├┤ RX(b) ├
├───┤┌─────┐ │ └─┬───┬─┘└───────┘
work_qubit_lin_comb_grad_0: ┤ H ├┤ SDG ├─■───┤ H ├───────────
└───┘└─────┘ └───┘
) * 0.7071067811865476
])
]),
SummedOp([
0.5 * ComposedOp([
OperatorMeasurement(ZZ) * 2.0,
CircuitStateFn(
┌───┐┌───────┐┌───┐┌───────┐┌───┐
q0_0: ┤ H ├┤ RZ(a) ├┤ X ├┤ RX(b) ├┤ H ├
├───┤└┬─────┬┘└─┬─┘└─┬───┬─┘└───┘
work_qubit_lin_comb_grad_0: ┤ H ├─┤ SDG ├───■────┤ H ├───────
└───┘ └─────┘ └───┘
) * 0.7071067811865476
]),
-1.0 * ComposedOp([
OperatorMeasurement(ZZ) * 2.0,
CircuitStateFn(
┌───┐┌───────┐┌───┐┌───────┐
q0_0: ┤ H ├┤ RZ(a) ├┤ X ├┤ RX(b) ├
├───┤└┬─────┬┘└─┬─┘└─┬───┬─┘
work_qubit_lin_comb_grad_0: ┤ H ├─┤ SDG ├───■────┤ H ├──
└───┘ └─────┘ └───┘
) * 0.7071067811865476
])
])
])
State gradient computed with the linear combination method [(-0.3535533905932738-2.39e-16j), (0.7071067811865476+1.64e-16j)]
Gradientes da Diferença Finita¶
Ao contrário dos outros métodos, os gradientes finitos da diferença são estimativas numéricas em vez de valores analíticos. Esta implementação emprega uma abordagem central de diferença com o \(\epsilon \ll 1\)
Os gradientes da probabilidade são computados equivalentemente.
[8]:
# Convert the expectation value into an operator corresponding to the gradient w.r.t. the state parameter using
# the finite difference method.
state_grad = Gradient(grad_method='fin_diff').convert(operator=op, params=params)
# Print the operator corresponding to the gradient
print(state_grad)
# Assign the parameters and evaluate the gradient
state_grad_result = state_grad.assign_parameters(value_dict).eval()
print('State gradient computed with finite difference', state_grad_result)
ListOp([
SummedOp([
250000.0 * ComposedOp([
OperatorMeasurement(Z),
CircuitStateFn(
┌───┐┌────────────────┐┌───────┐┌───┐
q0_0: ┤ H ├┤ RZ(a + 1.0e-6) ├┤ RX(b) ├┤ H ├
└───┘└────────────────┘└───────┘└───┘
)
]),
-250000.0 * ComposedOp([
OperatorMeasurement(Z),
CircuitStateFn(
┌───┐┌────────────────┐┌───────┐┌───┐
q0_0: ┤ H ├┤ RZ(a - 1.0e-6) ├┤ RX(b) ├┤ H ├
└───┘└────────────────┘└───────┘└───┘
)
]),
-500000.0 * ComposedOp([
OperatorMeasurement(Z),
CircuitStateFn(
┌───┐┌────────────────┐┌───────┐
q0_0: ┤ H ├┤ RZ(a + 1.0e-6) ├┤ RX(b) ├
└───┘└────────────────┘└───────┘
)
]),
500000.0 * ComposedOp([
OperatorMeasurement(Z),
CircuitStateFn(
┌───┐┌────────────────┐┌───────┐
q0_0: ┤ H ├┤ RZ(a - 1.0e-6) ├┤ RX(b) ├
└───┘└────────────────┘└───────┘
)
])
]),
SummedOp([
250000.0 * ComposedOp([
OperatorMeasurement(Z),
CircuitStateFn(
┌───┐┌───────┐┌────────────────┐┌───┐
q0_0: ┤ H ├┤ RZ(a) ├┤ RX(b + 1.0e-6) ├┤ H ├
└───┘└───────┘└────────────────┘└───┘
)
]),
-250000.0 * ComposedOp([
OperatorMeasurement(Z),
CircuitStateFn(
┌───┐┌───────┐┌────────────────┐┌───┐
q0_0: ┤ H ├┤ RZ(a) ├┤ RX(b - 1.0e-6) ├┤ H ├
└───┘└───────┘└────────────────┘└───┘
)
]),
-500000.0 * ComposedOp([
OperatorMeasurement(Z),
CircuitStateFn(
┌───┐┌───────┐┌────────────────┐
q0_0: ┤ H ├┤ RZ(a) ├┤ RX(b + 1.0e-6) ├
└───┘└───────┘└────────────────┘
)
]),
500000.0 * ComposedOp([
OperatorMeasurement(Z),
CircuitStateFn(
┌───┐┌───────┐┌────────────────┐
q0_0: ┤ H ├┤ RZ(a) ├┤ RX(b - 1.0e-6) ├
└───┘└───────┘└────────────────┘
)
])
])
])
State gradient computed with finite difference [(-0.3535533905669581+0j), (0.7071067812098961+2.7749999999999998e-11j)]
Gradiente Natural¶
Um tipo especial de gradiente de primeira ordem é o gradiente natural que se revelou útil no aprendizado de máquina clássico e já está sendo estudado no contexto quântico. Esta quantidade representa um gradiente que é ‘redimensionado’ com a matriz de Informação Quântica de Fisher (QFI) inversa
Em vez de inverter a QFI, pode-se também usar um solucionador de mínimos quadrados com ou sem regularização para resolver
A implementação suporta regularização de lasso com busca automática por um bom parâmetro usando L-curve corner search bem como dois tipos de perturbações dos elementos diagonais da QFI.
O gradiente natural pode ser usado em vez do gradiente padrão com qualquer solucionador ODE e/ou otimizador baseado em gradientes.
[9]:
# Besides the method to compute the circuit gradients resp. QFI, a regularization method can be chosen:
# `ridge` or `lasso` with automatic parameter search or `perturb_diag_elements` or `perturb_diag`
# which perturb the diagonal elements of the QFI.
nat_grad = NaturalGradient(grad_method='lin_comb', qfi_method='lin_comb_full', regularization='ridge').convert(
operator=op, params=params)
# Assign the parameters and evaluate the gradient
nat_grad_result = nat_grad.assign_parameters(value_dict).eval()
print('Natural gradient computed with linear combination of unitaries', nat_grad_result)
Natural gradient computed with linear combination of unitaries [-2.17412662 1.90236079]
Hessianas (Gradientes de Segunda Ordem)¶
Four types of second order gradients are supported by the gradient framework.
Gradient of an expectation value w.r.t. a coefficient of the measurement operator respectively observable \(\hat{O}\left(\omega\right)\), i.e. \(\frac{\partial^2\langle\psi\left(\theta\right)|\hat{O}\left(\omega\right)|\psi\left(\theta\right)\rangle}{\partial\omega^2}\)
Gradient of an expectation value w.r.t. a state \(|\psi\left(\theta\right)\rangle\) parameter, i.e. \(\frac{\partial^2\langle\psi\left(\theta\right)|\hat{O}\left(\omega\right)|\psi\left(\theta\right)\rangle}{\partial\theta^2}\)
Gradient of sampling probabilities w.r.t. a state \(|\psi\left(\theta\right)\rangle\) parameter, i.e. \(\frac{\partial^2 p_i}{\partial\theta^2} = \frac{\partial^2\langle\psi\left(\theta\right)|i\rangle\langle i|\psi\left(\theta\right)\rangle}{\partial\theta^2}\)
Gradient of an expectation value w.r.t. a state \(|\psi\left(\theta\right)\rangle\) parameter and a coefficient of the measurement operator respectively observable \(\hat{O}\left(\omega\right)\), i.e. \(\frac{\partial^2\langle\psi\left(\theta\right)|\hat{O}\left(\omega\right)|\psi\left(\theta\right)\rangle}{\partial\theta\partial\omega}\)
In the following examples are given for the first two Hessian types. The remaining Hessians are evaluated analogously.
`Hessianas com respeito aos Parâmetros do Operador de Medição¶
Novamente, nós definimos um estado quântico \(|\psi\left(\theta\right)\rangle\) e um Hamiltoniano \(H\) agindo como observável. Em seguida, o estado e o Hamiltoniano são envolvidos em um objeto que define o valor esperado
[10]:
# Instantiate the Hamiltonian observable
coeff_0 = Parameter('c_0')
coeff_1 = Parameter('c_1')
H = coeff_0*coeff_1*coeff_1*X
# Instantiate the quantum state with two parameters
a = Parameter('a')
b = Parameter('b')
q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.h(q)
qc.rz(a, q[0])
qc.rx(b, q[0])
# Combine the Hamiltonian observable and the state
op = ~StateFn(H) @ CircuitStateFn(primitive=qc, coeff=1.)
Em seguida, podemos escolher os parâmetros para os quais queremos calcular os gradientes de segunda ordem. - Dada uma tupla, o Hessian irá avaliar o gradiente de segunda ordem para os dois parâmetros. - Dada uma lista, o Hessian irá avaliar o gradiente de segunda ordem para todas as combinações possíveis de tuplas destes parâmetros.
Depois de vincular valores de parâmetro aos parâmetros, a Hessiana pode ser calculada.
[11]:
# Convert the operator and the hessian target coefficients into the respective operator
hessian = Hessian().convert(operator = op, params = [coeff_0, coeff_1])
# Define the values to be assigned to the parameters
value_dict = {coeff_0: 0.5, coeff_1: -1, a: np.pi / 4, b: np.pi/4}
# Assign the parameters and evaluate the Hessian w.r.t. the Hamiltonian coefficients
hessian_result = hessian.assign_parameters(value_dict).eval()
print('Hessian \n', np.real(np.array(hessian_result)))
Hessian
[[ 0. -1.41421356]
[-1.41421356 0.70710678]]
Hessianas com respeito aos Parâmetros de Estado¶
[12]:
# Define parameters
params = [a, b]
# Get the operator object representing the Hessian
state_hess = Hessian(hess_method='param_shift').convert(operator=op, params=params)
# Assign the parameters and evaluate the Hessian
hessian_result = state_hess.assign_parameters(value_dict).eval()
print('Hessian computed using the parameter shift method\n', (np.array(hessian_result)))
# Get the operator object representing the Hessian
state_hess = Hessian(hess_method='lin_comb').convert(operator=op, params=params)
# Assign the parameters and evaluate the Hessian
hessian_result = state_hess.assign_parameters(value_dict).eval()
print('Hessian computed using the linear combination of unitaries method\n', (np.array(hessian_result)))
# Get the operator object representing the Hessian using finite difference
state_hess = Hessian(hess_method='fin_diff').convert(operator=op, params=params)
# Assign the parameters and evaluate the Hessian
hessian_result = state_hess.assign_parameters(value_dict).eval()
print('Hessian computed with finite difference\n', (np.array(hessian_result)))
Hessian computed using the parameter shift method
[[-3.53553391e-01-7.6375e-17j 6.93889390e-17-1.4000e-17j]
[ 8.32667268e-17-1.4000e-17j 0.00000000e+00+2.7750e-17j]]
Hessian computed using the linear combination of unitaries method
[[-0.35355339-4.82e-16j 0. +0.00e+00j]
[ 0. +0.00e+00j 0. +0.00e+00j]]
Hessian computed with finite difference
[[-3.53546143e-01-6.8750e-06j 0.00000000e+00-1.3875e-05j]
[ 0.00000000e+00-1.3875e-05j 4.57763672e-05+2.0875e-05j]]
Informação Quântica de Fisher (QFI)¶
A Informação Quântica de Fisher é um tensor métrico que é representativo da capacidade de representação de um estado quântico parametrizado \(|\psi\left(\theta\right)\rangle = V\left(\theta\right)|\psi\rangle\) com estado de entrada \(|\psi\rangle\), Ansatz parametrizado \(V\left(\theta\right)\).
As entradas da QFI para um estado puro mostram
QFIs de circuito¶
A avaliação da QFI correspondente a um estado quântico gerado por um circuito quântico parametrizado pode ser realizada de diferentes maneiras.
Combinação Linear QFI Completa¶
To compute the full QFI, we use a working qubit as well as intercepting controlled gates. See e.g. Variational ansatz-based quantum simulation of imaginary time evolution.
[13]:
# Wrap the quantum circuit into a CircuitStateFn
state = CircuitStateFn(primitive=qc, coeff=1.)
# Convert the state and the parameters into the operator object that represents the QFI
qfi = QFI(qfi_method='lin_comb_full').convert(operator=state, params=params)
# Define the values for which the QFI is to be computed
values_dict = {a: np.pi / 4, b: 0.1}
# Assign the parameters and evaluate the QFI
qfi_result = qfi.assign_parameters(values_dict).eval()
print('full QFI \n', np.real(np.array(qfi_result)))
full QFI
[[ 1.00000000e+00 -1.97989899e-17]
[-1.97989899e-17 5.00000000e-01]]
Aproximação Diagonal e Bloco-Diagonal¶
Uma aproximação diagonal ou bloco-diagonal da QFI pode ser calculada sem qubits funcionais adicionais. Essa implementação requer a decomposição em rotações de Pauli e Portas não parametrizadas.
[14]:
# Convert the state and the parameters into the operator object that represents the QFI
# and set the approximation to 'block_diagonal'
qfi = QFI('overlap_block_diag').convert(operator=state, params=params)
# Assign the parameters and evaluate the QFI
qfi_result = qfi.assign_parameters(values_dict).eval()
print('Block-diagonal QFI \n', np.real(np.array(qfi_result)))
# Convert the state and the parameters into the operator object that represents the QFI
# and set the approximation to 'diagonal'
qfi = QFI('overlap_diag').convert(operator=state, params=params)
# Assign the parameters and evaluate the QFI
qfi_result = qfi.assign_parameters(values_dict).eval()
print('Diagonal QFI \n', np.real(np.array(qfi_result)))
Block-diagonal QFI
[[1. 0. ]
[0. 0.5]]
Diagonal QFI
[[1. 0. ]
[0. 0.5]]
Exemplo de Aplicação: VQE com otimização baseada em gradiente¶
Imports Adicionais¶
[15]:
# Execution Imports
from qiskit import Aer
from qiskit.aqua import QuantumInstance
# Algorithm Imports
from qiskit.aqua.algorithms import VQE
from qiskit.aqua.components.optimizers import CG
O Framework Gradient também pode ser usado para um VQE baseado no gradiente. Primeiro, o Hamiltoniano e o ansatz da função de onda são inicializados.
[16]:
from qiskit.aqua.operators import I, X, Z
from qiskit.circuit import QuantumCircuit, ParameterVector
from scipy.optimize import minimize
# Instantiate the system Hamiltonian
h2_hamiltonian = -1.05 * (I ^ I) + 0.39 * (I ^ Z) - 0.39 * (Z ^ I) - 0.01 * (Z ^ Z) + 0.18 * (X ^ X)
# This is the target energy
h2_energy = -1.85727503
# Define the Ansatz
wavefunction = QuantumCircuit(2)
params = ParameterVector('theta', length=8)
it = iter(params)
wavefunction.ry(next(it), 0)
wavefunction.ry(next(it), 1)
wavefunction.rz(next(it), 0)
wavefunction.rz(next(it), 1)
wavefunction.cx(0, 1)
wavefunction.ry(next(it), 0)
wavefunction.ry(next(it), 1)
wavefunction.rz(next(it), 0)
wavefunction.rz(next(it), 1)
# Define the expectation value corresponding to the energy
op = ~StateFn(h2_hamiltonian) @ StateFn(wavefunction)
Agora, podemos escolher se o VQE deve usar um Gradient ou um NaturalGradient, defina uma QuantumInstance para executar os circuitos quânticos e executar o algoritmo.
[17]:
grad = Gradient(grad_method='lin_comb')
qi_sv = QuantumInstance(Aer.get_backend('statevector_simulator'),
shots=1,
seed_simulator=2,
seed_transpiler=2)
#Conjugate Gradient algorithm
optimizer = CG(maxiter=50)
# Gradient callable
vqe = VQE(h2_hamiltonian, wavefunction, optimizer=optimizer, gradient=grad)
result = vqe.run(qi_sv)
print('Result:', result['optimal_value'], 'Reference:', h2_energy)
Result: -1.8404998438455793 Reference: -1.85727503
[18]:
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
Version Information
| Qiskit Software | Version |
|---|---|
| Qiskit | 0.24.0 |
| Terra | 0.16.4 |
| Aer | 0.7.6 |
| Ignis | 0.5.2 |
| Aqua | 0.8.2 |
| IBM Q Provider | 0.12.1 |
| System information | |
| Python | 3.8.8 | packaged by conda-forge | (default, Feb 20 2021, 16:22:27) [GCC 9.3.0] |
| OS | Linux |
| CPUs | 8 |
| Memory (Gb) | 31.409000396728516 |
| Mon Mar 29 07:51:07 2021 UTC | |
This code is a part of Qiskit
© Copyright IBM 2017, 2021.
This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.
[ ]: