125 lines
7.2 KiB
Plaintext
125 lines
7.2 KiB
Plaintext
---
|
||
title: gradients (v0.26)
|
||
description: API reference for qiskit.aqua.operators.gradients in qiskit v0.26
|
||
in_page_toc_min_heading_level: 2
|
||
python_api_type: module
|
||
python_api_name: qiskit.aqua.operators.gradients
|
||
---
|
||
|
||
<span id="module-qiskit.aqua.operators.gradients" />
|
||
|
||
<span id="qiskit-aqua-operators-gradients" />
|
||
|
||
<span id="gradients-qiskit-aqua-operators-gradients" />
|
||
|
||
# Gradients
|
||
|
||
`qiskit.aqua.operators.gradients`
|
||
|
||
Given an operator that represents either a quantum state resp. an expectation value, the gradient framework enables the evaluation of gradients, natural gradients, Hessians, as well as the Quantum Fisher Information.
|
||
|
||
Suppose a parameterized quantum state |ψ(θ)〉 = V(θ)|ψ〉 with input state |ψ〉 and parametrized Ansatz V(θ), and an Operator O(ω).
|
||
|
||
**Gradients**
|
||
|
||
We want to compute one of: \* $d⟨ψ(θ)|O(ω)|ψ(θ)〉/ dω$ \* $d⟨ψ(θ)|O(ω)|ψ(θ)〉/ dθ$ \* $d⟨ψ(θ)|i〉⟨i|ψ(θ)〉/ dθ$
|
||
|
||
The last case corresponds to the gradient w\.r.t. the sampling probabilities of |ψ(θ). These gradients can be computed with different methods, i.e. a parameter shift, a linear combination of unitaries and a finite difference method.
|
||
|
||
**Examples**
|
||
|
||
```python
|
||
x = Parameter('x')
|
||
ham = x * X
|
||
a = Parameter('a')
|
||
|
||
q = QuantumRegister(1)
|
||
qc = QuantumCircuit(q)
|
||
qc.h(q)
|
||
qc.p(params[0], q[0])
|
||
op = ~StateFn(ham) @ CircuitStateFn(primitive=qc, coeff=1.)
|
||
|
||
value_dict = {x: 0.1, a: np.pi / 4}
|
||
|
||
ham_grad = Gradient(grad_method='param_shift').convert(operator=op, params=[x])
|
||
ham_grad.assign_parameters(value_dict).eval()
|
||
|
||
state_grad = Gradient(grad_method='lin_comb').convert(operator=op, params=[a])
|
||
state_grad.assign_parameters(value_dict).eval()
|
||
|
||
prob_grad = Gradient(grad_method='fin_diff').convert(
|
||
operator=CircuitStateFn(primitive=qc, coeff=1.), params=[a]
|
||
)
|
||
prob_grad.assign_parameters(value_dict).eval()
|
||
```
|
||
|
||
**Hessians**
|
||
|
||
We want to compute one of: \* $d^2⟨ψ(θ)|O(ω)|ψ(θ)〉/ dω^2$ \* $d^2⟨ψ(θ)|O(ω)|ψ(θ)〉/ dθ^2$ \* $d^2⟨ψ(θ)|O(ω)|ψ(θ)〉/ dθ dω$ \* $d^2⟨ψ(θ)|i〉⟨i|ψ(θ)〉/ dθ^2$
|
||
|
||
The last case corresponds to the Hessian w\.r.t. the sampling probabilities of |ψ(θ)〉. Just as the first order gradients, the Hessians can be evaluated with different methods, i.e. a parameter shift, a linear combination of unitaries and a finite difference method. Given a tuple of parameters `Hessian().convert(op, param_tuple)` returns the value for the second order derivative. If a list of parameters is given `Hessian().convert(op, param_list)` returns the full Hessian for all the given parameters according to the given parameter order.
|
||
|
||
**QFI**
|
||
|
||
The Quantum Fisher Information QFI is a metric tensor which is representative for the representation capacity of a parameterized quantum state |ψ(θ)〉 = V(θ)|ψ〉 generated by an input state |ψ〉 and a parametrized Ansatz V(θ). The entries of the QFI for a pure state read $\mathrm{QFI}_{kl} = 4 \mathrm{Re}[〈∂kψ|∂lψ〉−〈∂kψ|ψ〉〈ψ|∂lψ〉]$.
|
||
|
||
Just as for the previous derivative types, the QFI can be computed using different methods: a full representation based on a linear combination of unitaries implementation, a block-diagonal and a diagonal representation based on an overlap method.
|
||
|
||
**Examples**
|
||
|
||
```python
|
||
q = QuantumRegister(1)
|
||
qc = QuantumCircuit(q)
|
||
qc.h(q)
|
||
qc.p(params[0], q[0])
|
||
op = ~StateFn(ham) @ CircuitStateFn(primitive=qc, coeff=1.)
|
||
|
||
value_dict = {x: 0.1, a: np.pi / 4}
|
||
|
||
qfi = QFI('lin_comb_full').convert(
|
||
operator=CircuitStateFn(primitive=qc, coeff=1.), params=[a]
|
||
)
|
||
qfi.assign_parameters(value_dict).eval()
|
||
```
|
||
|
||
**NaturalGradients**
|
||
|
||
The natural gradient is a special gradient method which re-scales a gradient w\.r.t. a state parameter with the inverse of the corresponding Quantum Fisher Information (QFI) $\mathrm{QFI}^{-1} d⟨ψ(θ)|O(ω)|ψ(θ)〉/ dθ$. Hereby, we can choose a gradient as well as a QFI method and a regularization method which is used together with a least square solver instead of exact inversion of the QFI:
|
||
|
||
**Examples**
|
||
|
||
```python
|
||
op = ~StateFn(ham) @ CircuitStateFn(primitive=qc, coeff=1.)
|
||
nat_grad = NaturalGradient(grad_method='lin_comb,
|
||
qfi_method='lin_comb_full',
|
||
regularization='ridge').convert(operator=op, params=params)
|
||
```
|
||
|
||
The derivative classes come with a gradient\_wrapper() function which returns the corresponding callable and are thus compatible with the optimizers from qiskit.aqua.components.optimizers.
|
||
|
||
# Base Classes
|
||
|
||
| | |
|
||
| ------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------ |
|
||
| [`DerivativeBase`](qiskit.aqua.operators.gradients.DerivativeBase "qiskit.aqua.operators.gradients.DerivativeBase") | Base class for differentiating opflow objects. |
|
||
| [`GradientBase`](qiskit.aqua.operators.gradients.GradientBase "qiskit.aqua.operators.gradients.GradientBase") | Base class for first-order operator gradient. |
|
||
| [`HessianBase`](qiskit.aqua.operators.gradients.HessianBase "qiskit.aqua.operators.gradients.HessianBase") | Base class for the Hessian of an expected value. |
|
||
| [`QFIBase`](qiskit.aqua.operators.gradients.QFIBase "qiskit.aqua.operators.gradients.QFIBase") | Base class for Quantum Fisher Information (QFI). |
|
||
|
||
# Converters
|
||
|
||
| | |
|
||
| ---------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------- |
|
||
| [`CircuitGradient`](qiskit.aqua.operators.gradients.CircuitGradient "qiskit.aqua.operators.gradients.CircuitGradient") | Circuit to gradient operator converter. |
|
||
| [`CircuitQFI`](qiskit.aqua.operators.gradients.CircuitQFI "qiskit.aqua.operators.gradients.CircuitQFI") | Circuit to Quantum Fisher Information operator converter. |
|
||
|
||
# Derivatives
|
||
|
||
| | |
|
||
| ---------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------- |
|
||
| [`Gradient`](qiskit.aqua.operators.gradients.Gradient "qiskit.aqua.operators.gradients.Gradient") | Convert an operator expression to the first-order gradient. |
|
||
| [`Hessian`](qiskit.aqua.operators.gradients.Hessian "qiskit.aqua.operators.gradients.Hessian") | Compute the Hessian of an expected value. |
|
||
| [`NaturalGradient`](qiskit.aqua.operators.gradients.NaturalGradient "qiskit.aqua.operators.gradients.NaturalGradient") | Convert an operator expression to the first-order gradient. |
|
||
| [`QFI`](qiskit.aqua.operators.gradients.QFI "qiskit.aqua.operators.gradients.QFI") | Compute the Quantum Fisher Information (QFI). |
|
||
|