Skip to main contentIBM Quantum Documentation
You are viewing the API reference for an old version of Qiskit SDK. Switch to latest version

SamplingVQE

qiskit.algorithms.minimum_eigensolvers.SamplingVQE(sampler, ansatz, optimizer, *, initial_point=None, aggregation=None, callback=None)

GitHub(opens in a new tab)

Bases: VariationalAlgorithm, SamplingMinimumEigensolver

The Variational Quantum Eigensolver algorithm, optimized for diagonal Hamiltonians.

VQE is a hybrid quantum-classical algorithm that uses a variational technique to find the minimum eigenvalue of a given diagonal Hamiltonian operator HdiagH_{\text{diag}}.

In contrast to the VQE class, the SamplingVQE algorithm is executed using a sampler primitive.

An instance of SamplingVQE also requires an ansatz, a parameterized QuantumCircuit, to prepare the trial state ψ(θ)|\psi(\vec\theta)\rangle. It also needs a classical optimizer which varies the circuit parameters θ\vec\theta to minimize the objective function, which depends on the chosen aggregation.

The optimizer can either be one of Qiskit’s optimizers, such as SPSA or a callable with the following signature:

from qiskit.algorithms.optimizers import OptimizerResult
 
def my_minimizer(fun, x0, jac=None, bounds=None) -> OptimizerResult:
    # Note that the callable *must* have these argument names!
    # Args:
    #     fun (callable): the function to minimize
    #     x0 (np.ndarray): the initial point for the optimization
    #     jac (callable, optional): the gradient of the objective function
    #     bounds (list, optional): a list of tuples specifying the parameter bounds
 
    result = OptimizerResult()
    result.x = # optimal parameters
    result.fun = # optimal function value
    return result

The above signature also allows one to use any SciPy minimizer, for instance as

from functools import partial
from scipy.optimize import minimize
 
optimizer = partial(minimize, method="L-BFGS-B")

The following attributes can be set via the initializer but can also be read and updated once the SamplingVQE object has been constructed.

sampler

The sampler primitive to sample the circuits.

Type

BaseSampler

ansatz

A parameterized quantum circuit to prepare the trial state.

Type

QuantumCircuit

optimizer

A classical optimizer to find the minimum energy. This can either be a Qiskit Optimizer or a callable implementing the Minimizer protocol.

Type

Optimizer | Minimizer

aggregation

A float or callable to specify how the objective function evaluated on the basis states should be aggregated. If a float, this specifies the α[0,1]\alpha \in [0,1] parameter for a CVaR expectation value [1]. If a callable, it takes a list of basis state measurements specified as [(probability, objective_value)] and return an objective value as float. If None, all an ordinary expectation value is calculated.

Type

float(opens in a new tab) | Callable[[list(opens in a new tab)[tuple(opens in a new tab)[float(opens in a new tab), complex(opens in a new tab)]], float(opens in a new tab)] | None

callback

A callback that can access the intermediate data at each optimization step. These data are: the evaluation count, the optimizer parameters for the ansatz, the evaluated value, and the metadata dictionary.

Type

Callable[[int(opens in a new tab), np.ndarray, float(opens in a new tab), dict(opens in a new tab)[str(opens in a new tab), Any]], None] | None

References

[1]: Barkoutsos, P. K., Nannicini, G., Robert, A., Tavernelli, I., and Woerner, S.,

“Improving Variational Quantum Optimization using CVaR” arXiv:1907.04769(opens in a new tab)

Parameters


Attributes

initial_point

Return the initial point.


Methods

compute_minimum_eigenvalue

compute_minimum_eigenvalue(operator, aux_operators=None)

Compute the minimum eigenvalue of a diagonal operator.

Parameters

  • operator (BaseOperator | PauliSumOp) – Diagonal qubit operator.
  • aux_operators (ListOrDict[BaseOperator | PauliSumOp] | None) – Optional list of auxiliary operators to be evaluated with the final state.

Returns

A SamplingMinimumEigensolverResult containing the optimization result.

Return type

SamplingMinimumEigensolverResult

supports_aux_operators

classmethod supports_aux_operators()

Whether computing the expectation value of auxiliary operators is supported.

If the minimum eigensolver computes an eigenstate of the main operator then it can compute the expectation value of the aux_operators for that state. Otherwise they will be ignored.

Returns

True if aux_operator expectations can be evaluated, False otherwise

Return type

bool(opens in a new tab)

Was this page helpful?
Report a bug or request content on GitHub.