Note
Cette page a été générée à partir de tutorials/operators/02_gradients_framework.ipynb.
Exécuter en mode interactif dans le IBM Quantum lab.
Structure Gradient de Qiskit¶
La structure gradient permet d’évaluer les gradients quantiques ainsi que leurs fonctions. En plus des gradients standard du premier ordre des valeurs d’espérance de la forme
La structure gradient soutient également l’évaluation des gradients du second ordre (Hessians), et le Quantum Fisher Information (QFI) des états quantiques \(|\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
Gradients de premier ordre¶
Etant donné un état quantique paramétré \(|\psi\left(\theta\right)\rangle = V\left(\theta\right)|\psi\rangle\) avec l’état d’entrée \(|\psi\rangle\), l’Ansatz de paramètre \(V\left(\theta\right)\), et l’observable \(\hat{O}\left(\omega\right)=\sum_{i}\omega_i\hat{O}_i\), nous voulons calculer…
Gradients relatifs aux Paramètres de l’opérateur de mesure¶
Gradient d’une espérance relative à un opérateur de mesure correspondant à l’observable a coefficient of the measurement operator respective observable :math:` hat{O}left (omegaright)`, c’est à dire
Tout d’abord, nous définissons un état quantique \(|\psi\left (\theta\right)\rangle\) et un Hamiltonien \(H\) agissant comme observable. Ensuite, l’état et l’Hamiltonien sont intégrés dans un objet définissant la valeur de l’attente
[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) ├
└───┘└───────┘└───────┘
)
])
Nous construisons une liste des paramètres pour lesquels nous cherchons à évaluer le gradient. Dans ce cas, les paramètres sont donnés comme les coefficients de \(H\). Maintenant, cette liste et la valeur de l’espérance de l’opérateur sont utilisés pour générer l’opérateur qui représente le dégradé.
[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]
Gradients relatifs aux paramètres d’état¶
Gradient of an expectation value w.r.t. a state \(|\psi\left(\theta\right)\rangle\) parameter, i.e.
respectively of sampling probabilities w.r.t. a state \(|\psi\left(\theta\right)\rangle\) parameter, i.e.
A gradient w.r.t. a state parameter may be evaluated with different methods. Each method has advantages and disadvantages.
[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) ├
└───┘└───────┘└───────┘
)
])
Parameter Shift Gradients¶
Given a Hermitian operator \(g\) with two unique eigenvalues \(\pm r\) which acts as generator for a parameterized quantum gate
Then, quantum gradients can be computed by using eigenvalue \(r\) dependent shifts to parameters. All standard, parameterized Qiskit gates can be shifted with \(\pi/2\), i.e.,
Probability gradients are computed equivalently.
[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)]
Linear Combination of Unitaries Gradients¶
Unitaries can be written as \(U\left(\omega\right) = e^{iM\left(\omega\right)}\), where \(M\left(\omega\right)\) denotes a parameterized Hermitian matrix. Further, Hermitian matrices can be decomposed into weighted sums of Pauli terms, i.e., \(M\left(\omega\right) = \sum_pm_p\left(\omega\right)h_p\) with \(m_p\left(\omega\right)\in\mathbb{R}\) and \(h_p=\bigotimes\limits_{j=0}^{n-1}\sigma_{j, p}\) for \(\sigma_{j, p}\in\left\{I, X, Y, Z\right\}\) acting on the \(j^{\text{th}}\) qubit. Thus, the gradients of \(U_k\left(\omega_k\right)\) are given by \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)h_{k_p}. \end{equation*}
Combining this observation with a circuit structure presented in Simulating physical phenomena by quantum networks allows us to compute the gradient with the evaluation of a single quantum circuit.
[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)]
Finite Difference Gradients¶
Unlike the other methods, finite difference gradients are numerical estimations rather than analytical values. This implementation employs a central difference approach with \(\epsilon \ll 1\)
Probability gradients are computed equivalently.
[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)]
Gradient naturel¶
A special type of first order gradient is the natural gradient which has proven itself useful in classical machine learning and is already being studied in the quantum context. This quantity represents a gradient that is ‘rescaled’ with the inverse Quantum Fisher Information matrix (QFI)
Instead of inverting the QFI, one can also use a least-square solver with or without regularization to solve
The implementation supports ridge and lasso regularization with automatic search for a good parameter using L-curve corner search as well as two types of perturbations of the diagonal elements of the QFI.
The natural gradient can be used instead of the standard gradient with any gradient-based optimizer and/or ODE solver.
[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]
Hessiens (Gradients d’ordre deux)¶
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.
Hessians w.r.t. Measurement Operator Parameters¶
Again, we define a quantum state \(|\psi\left(\theta\right)\rangle\) and a Hamiltonian \(H\) acting as observable. Then, the state and the Hamiltonian are wrapped into an object defining the expectation value
[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.)
Next, we can choose the parameters for which we want to compute second order gradients. - Given a tuple, the Hessian will evaluate the second order gradient for the two parameters. - Given a list, the Hessian will evaluate the second order gradient for all possible combinations of tuples of these parameters.
After binding parameter values to the parameters, the Hessian can be evaluated.
[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]]
Hessiens relatifs aux Paramètres d’état¶
[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]]
Quantum Fisher Information (QFI)¶
The Quantum Fisher Information is a metric tensor which is representative for the representation capacity of a parameterized quantum state \(|\psi\left(\theta\right)\rangle = V\left(\theta\right)|\psi\rangle\) with input state \(|\psi\rangle\), parametrized Ansatz \(V\left(\theta\right)\).
The entries of the QFI for a pure state reads
Circuit QFI¶
The evaluation of the QFI corresponding to a quantum state that is generated by a parameterized quantum circuit can be conducted in different ways.
Linear Combination Full QFI¶
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]]
Block-diagonal and Diagonal Approximation¶
A block-diagonal resp. diagonal approximation of the QFI can be computed without additional working qubits. This implementation requires the unrolling into Pauli rotations and unparameterized Gates.
[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]]
Application Example: VQE with gradient-based optimization¶
Importations supplémentaires¶
[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
Le framework Gradient peut également être utilisé pour un VQE basé sur un gradient. Tout d’abord, l’ansatz Hamiltonian et la fonction d’onde sont initialisés.
[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)
Now, we can choose whether the VQE should use a Gradient or NaturalGradient, define a QuantumInstance to execute the quantum circuits and run the algorithm.
[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.
[ ]: