def __init__(
self,
operator: Optional[Union[OperatorBase, LegacyBaseOperator]] = None,
var_form: Optional[Union[QuantumCircuit, VariationalForm]] = None,
optimizer: Optional[Optimizer] = None,
initial_point: Optional[np.ndarray] = None,
expectation: Optional[ExpectationBase] = None,
max_evals_grouped: int = 1,
aux_operators: Optional[List[Optional[Union[
OperatorBase, LegacyBaseOperator]]]] = None,
callback: Optional[Callable[[int, np.ndarray, float, float],
None]] = None,
quantum_instance: Optional[Union[QuantumInstance, BaseBackend]] = None
) -> None:
"""
Args:
operator: Qubit operator of the Observable
var_form: A parameterized circuit used as Ansatz for the wave function.
optimizer: A classical optimizer.
initial_point: An optional initial point (i.e. initial parameter values)
for the optimizer. If ``None`` then VQE will look to the variational form for a
preferred point and if not will simply compute a random one.
expectation: The Expectation converter for taking the average value of the
Observable over the var_form state function.
max_evals_grouped: Max number of evaluations performed simultaneously. Signals the
given optimizer that more than one set of parameters can be supplied so that
potentially the expectation values can be computed in parallel. Typically this is
possible when a finite difference gradient is used by the optimizer such that
multiple points to compute the gradient can be passed and if computed in parallel
improve overall execution time.
aux_operators: Optional list of auxiliary operators to be evaluated with the
eigenstate of the minimum eigenvalue main result and their expectation values
returned. For instance in chemistry these can be dipole operators, total particle
count operators so we can get values for these at the ground state.
callback: a callback that can access the intermediate data during the optimization.
Four parameter values are passed to the callback as follows during each evaluation
by the optimizer for its current set of parameters as it works towards the minimum.
These are: the evaluation count, the optimizer parameters for the
variational form, the evaluated mean and the evaluated standard deviation.`
quantum_instance: Quantum Instance or Backend
"""
validate_min('max_evals_grouped', max_evals_grouped, 1)
if var_form is None:
if operator is not None:
var_form = RealAmplitudes()
if optimizer is None:
optimizer = SLSQP()
# set the initial point to the preferred parameters of the variational form
if initial_point is None and hasattr(var_form,
'preferred_init_points'):
initial_point = var_form.preferred_init_points
self._max_evals_grouped = max_evals_grouped
self._circuit_sampler = None
self._expectation = expectation
self._expect_op = None
self._operator = None
super().__init__(var_form=var_form,
optimizer=optimizer,
cost_fn=self._energy_evaluation,
initial_point=initial_point,
quantum_instance=quantum_instance)
self._ret = None
self._eval_time = None
self._optimizer.set_max_evals_grouped(max_evals_grouped)
self._callback = callback
if operator is not None:
self.operator = operator
self.aux_operators = aux_operators
self._eval_count = 0
logger.info(self.print_settings())
# dimension of data sets
n = 4
from sklearn import datasets
from sklearn import preprocessing
iris = datasets.load_iris()
# load iris and normalise
x = preprocessing.normalize(iris.data)
x1_train = x[0:49, :] # class A
x2_train = x[50:99, :] # class B
training_input = {'A': x1_train, 'B': x2_train}
class_labels = ['A', 'B']
blocks = 1
sv = Statevector.from_label('0' * n)
circuit = QuantumCircuit(n)
feature_map = ZFeatureMap(n, reps=1)
var_form = RealAmplitudes(n, reps=blocks)
circuit = feature_map.combine(var_form)
def get_data_dict(params, x):
"""Get the parameters dict for the circuit"""
parameters = {}
for i, p in enumerate(feature_map.ordered_parameters):
parameters[p] = x[i]
for i, p in enumerate(var_form.ordered_parameters):
parameters[p] = params[i]
return parameters
def assign_label(bit_string, class_labels):
hamming_weight = sum([int(k) for k in list(bit_string)])
def test_parameterized_qobj(self):
""" grouped pauli expectation test """
two_qubit_h2 = (-1.052373245772859 * I ^ I) + \
(0.39793742484318045 * I ^ Z) + \
(-0.39793742484318045 * Z ^ I) + \
(-0.01128010425623538 * Z ^ Z) + \
(0.18093119978423156 * X ^ X)
aer_sampler = CircuitSampler(self.sampler.quantum_instance,
param_qobj=True,
attach_results=True)
ansatz = RealAmplitudes()
ansatz.num_qubits = 2
observable_meas = self.expect.convert(
StateFn(two_qubit_h2, is_measurement=True))
ansatz_circuit_op = CircuitStateFn(ansatz)
expect_op = observable_meas.compose(ansatz_circuit_op).reduce()
def generate_parameters(num):
param_bindings = {}
for param in ansatz.parameters:
values = []
for _ in range(num):
values.append(np.random.rand())
param_bindings[param] = values
return param_bindings
def validate_sampler(ideal, sut, param_bindings):
expect_sampled = ideal.convert(expect_op,
params=param_bindings).eval()
actual_sampled = sut.convert(expect_op,
params=param_bindings).eval()
self.assertAlmostEqual(actual_sampled, expect_sampled, delta=.1)
def get_circuit_templates(sampler):
return sampler._transpiled_circ_templates
def validate_aer_binding_used(templates):
self.assertIsNotNone(templates)
def validate_aer_templates_reused(prev_templates, cur_templates):
self.assertIs(prev_templates, cur_templates)
validate_sampler(self.sampler, aer_sampler, generate_parameters(1))
cur_templates = get_circuit_templates(aer_sampler)
validate_aer_binding_used(cur_templates)
prev_templates = cur_templates
validate_sampler(self.sampler, aer_sampler, generate_parameters(2))
cur_templates = get_circuit_templates(aer_sampler)
validate_aer_templates_reused(prev_templates, cur_templates)
prev_templates = cur_templates
validate_sampler(self.sampler, aer_sampler,
generate_parameters(2)) # same num of params
cur_templates = get_circuit_templates(aer_sampler)
validate_aer_templates_reused(prev_templates, cur_templates)
def setUp(self):
super().setUp()
algorithm_globals.random_seed = 1234
qi_sv = QuantumInstance(
Aer.get_backend("aer_simulator_statevector"),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
)
# set up quantum neural networks
num_qubits = 3
feature_map = ZFeatureMap(feature_dimension=num_qubits, reps=1)
ansatz = RealAmplitudes(num_qubits, reps=1)
# CircuitQNNs
qc = QuantumCircuit(num_qubits)
qc.append(feature_map, range(num_qubits))
qc.append(ansatz, range(num_qubits))
def parity(x):
return f"{x:b}".count("1") % 2
circuit_qnn_1 = CircuitQNN(
qc,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
interpret=parity,
output_shape=2,
sparse=False,
quantum_instance=qi_sv,
)
# qnn2 for checking result without parity
circuit_qnn_2 = CircuitQNN(
qc,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
sparse=False,
quantum_instance=qi_sv,
)
# OpflowQNN
observable = PauliSumOp.from_list([("Z" * num_qubits, 1)])
opflow_qnn = TwoLayerQNN(
num_qubits,
feature_map=feature_map,
ansatz=ansatz,
observable=observable,
quantum_instance=qi_sv,
)
self.qnns = {
"circuit1": circuit_qnn_1,
"circuit2": circuit_qnn_2,
"opflow": opflow_qnn
}
# define sample numbers
self.n_list = [
5000, 8000, 10000, 40000, 60000, 100000, 150000, 200000, 500000,
1000000
]
self.n = 5000
def __init__(
self,
operator: Optional[Union[OperatorBase, LegacyBaseOperator]] = None,
var_form: Optional[Union[QuantumCircuit, VariationalForm]] = None,
optimizer: Optional[Optimizer] = None,
initial_point: Optional[np.ndarray] = None,
expectation: Optional[ExpectationBase] = None,
include_custom: bool = False,
max_evals_grouped: int = 1,
aux_operators: Optional[List[Optional[Union[
OperatorBase, LegacyBaseOperator]]]] = None,
callback: Optional[Callable[[int, np.ndarray, float, float],
None]] = None,
quantum_instance: Optional[Union[QuantumInstance, BaseBackend]] = None
) -> None:
"""
Args:
operator: Qubit operator of the Observable
var_form: A parameterized circuit used as Ansatz for the wave function.
optimizer: A classical optimizer.
initial_point: An optional initial point (i.e. initial parameter values)
for the optimizer. If ``None`` then VQE will look to the variational form for a
preferred point and if not will simply compute a random one.
expectation: The Expectation converter for taking the average value of the
Observable over the var_form state function. When ``None`` (the default) an
:class:`~qiskit.aqua.operators.expectations.ExpectationFactory` is used to select
an appropriate expectation based on the operator and backend. When using Aer
qasm_simulator backend, with paulis, it is however much faster to leverage custom
Aer function for the computation but, although VQE performs much faster
with it, the outcome is ideal, with no shot noise, like using a state vector
simulator. If you are just looking for the quickest performance when choosing Aer
qasm_simulator and the lack of shot noise is not an issue then set `include_custom`
parameter here to ``True`` (defaults to ``False``).
include_custom: When `expectation` parameter here is None setting this to ``True`` will
allow the factory to include the custom Aer pauli expectation.
max_evals_grouped: Max number of evaluations performed simultaneously. Signals the
given optimizer that more than one set of parameters can be supplied so that
potentially the expectation values can be computed in parallel. Typically this is
possible when a finite difference gradient is used by the optimizer such that
multiple points to compute the gradient can be passed and if computed in parallel
improve overall execution time.
aux_operators: Optional list of auxiliary operators to be evaluated with the
eigenstate of the minimum eigenvalue main result and their expectation values
returned. For instance in chemistry these can be dipole operators, total particle
count operators so we can get values for these at the ground state.
callback: a callback that can access the intermediate data during the optimization.
Four parameter values are passed to the callback as follows during each evaluation
by the optimizer for its current set of parameters as it works towards the minimum.
These are: the evaluation count, the optimizer parameters for the
variational form, the evaluated mean and the evaluated standard deviation.`
quantum_instance: Quantum Instance or Backend
"""
validate_min('max_evals_grouped', max_evals_grouped, 1)
if var_form is None:
var_form = RealAmplitudes()
if optimizer is None:
optimizer = SLSQP()
# set the initial point to the preferred parameters of the variational form
if initial_point is None and hasattr(var_form,
'preferred_init_points'):
initial_point = var_form.preferred_init_points
self._max_evals_grouped = max_evals_grouped
self._circuit_sampler = None # type: Optional[CircuitSampler]
self._expectation = expectation
self._user_valid_expectation = self._expectation is not None
self._include_custom = include_custom
self._expect_op = None
self._operator = None
super().__init__(var_form=var_form,
optimizer=optimizer,
cost_fn=self._energy_evaluation,
initial_point=initial_point,
quantum_instance=quantum_instance)
self._ret = None # type: Dict[str, Any]
self._eval_time = None
self._optimizer.set_max_evals_grouped(max_evals_grouped)
self._callback = callback
if operator is not None:
self.operator = operator
self.aux_operators = aux_operators
self._eval_count = 0
logger.info(self.print_settings())
TOKEN = 'insert token here'
IBMQ.save_account(TOKEN, overwrite=True)
provider = IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q-internal', group='deployed', project='default')
backend_name = 'ibmq_montreal'
backend_ibmq = provider.get_backend(backend_name)
properties = backend_ibmq.properties()
coupling_map = backend_ibmq.configuration().coupling_map
noise_model = NoiseModel.from_backend(properties)
# layout = [0, 1, 2, 3]
layout = [3, 5, 8, 11, 14, 13] # might need to change
qi_ibmq_noise_model = QuantumInstance(backend=Aer.get_backend('qasm_simulator'),
noise_model=noise_model, optimization_level=0, shots=8000,
seed_transpiler=2, initial_layout=layout)
qi = qi_ibmq_noise_model
compile_config = {'initial_layout': layout,
'seed_transpiler': 2,
'optimization_level': 3
}
n = [1000, 2000, 8000, 10000, 40000, 60000, 100000, 150000, 200000, 500000, 1000000, 10000000, 10000000000, 10000000000000]
qubits = 6
fm = ZFeatureMap(qubits, reps=1)
varform = RealAmplitudes(qubits, reps=9, entanglement='full')
qnet = QuantumNeuralNetwork(fm, varform)
ed = EffectiveDimension(qnet, 100, 100)
fhat, _ = ed.get_fhat()
effdim = ed.eff_dim(fhat, n)
np.save('6qubits_fhats_noise_linearZ_full.npy', fhat)
np.save('6qubits_effective_dimension_noise_linearZ_full.npy', effdim)
def __init__(
self,
ansatz: Optional[QuantumCircuit] = None,
optimizer: Optional[Optimizer] = None,
initial_point: Optional[np.ndarray] = None,
gradient: Optional[Union[GradientBase, Callable]] = None,
expectation: Optional[ExpectationBase] = None,
include_custom: bool = False,
max_evals_grouped: int = 1,
callback: Optional[Callable[[int, np.ndarray, float, float],
None]] = None,
quantum_instance: Optional[Union[QuantumInstance, BaseBackend,
Backend]] = None,
) -> None:
"""
Args:
ansatz: A parameterized circuit used as Ansatz for the wave function.
optimizer: A classical optimizer.
initial_point: An optional initial point (i.e. initial parameter values)
for the optimizer. If ``None`` then VQE will look to the ansatz for a preferred
point and if not will simply compute a random one.
gradient: An optional gradient function or operator for optimizer.
expectation: The Expectation converter for taking the average value of the
Observable over the ansatz state function. When ``None`` (the default) an
:class:`~qiskit.opflow.expectations.ExpectationFactory` is used to select
an appropriate expectation based on the operator and backend. When using Aer
qasm_simulator backend, with paulis, it is however much faster to leverage custom
Aer function for the computation but, although VQE performs much faster
with it, the outcome is ideal, with no shot noise, like using a state vector
simulator. If you are just looking for the quickest performance when choosing Aer
qasm_simulator and the lack of shot noise is not an issue then set `include_custom`
parameter here to ``True`` (defaults to ``False``).
include_custom: When `expectation` parameter here is None setting this to ``True`` will
allow the factory to include the custom Aer pauli expectation.
max_evals_grouped: Max number of evaluations performed simultaneously. Signals the
given optimizer that more than one set of parameters can be supplied so that
potentially the expectation values can be computed in parallel. Typically this is
possible when a finite difference gradient is used by the optimizer such that
multiple points to compute the gradient can be passed and if computed in parallel
improve overall execution time. Deprecated if a gradient operator or function is
given.
callback: a callback that can access the intermediate data during the optimization.
Four parameter values are passed to the callback as follows during each evaluation
by the optimizer for its current set of parameters as it works towards the minimum.
These are: the evaluation count, the optimizer parameters for the
ansatz, the evaluated mean and the evaluated standard deviation.`
quantum_instance: Quantum Instance or Backend
"""
validate_min("max_evals_grouped", max_evals_grouped, 1)
if ansatz is None:
ansatz = RealAmplitudes()
if optimizer is None:
optimizer = SLSQP()
# set the initial point to the preferred parameters of the ansatz
if initial_point is None and hasattr(ansatz, "preferred_init_points"):
initial_point = ansatz.preferred_init_points
self._max_evals_grouped = max_evals_grouped
self._circuit_sampler = None # type: Optional[CircuitSampler]
self._expectation = expectation
self._user_valid_expectation = self._expectation is not None
self._include_custom = include_custom
self._expect_op = None
super().__init__(
ansatz=ansatz,
optimizer=optimizer,
cost_fn=self._energy_evaluation,
gradient=gradient,
initial_point=initial_point,
quantum_instance=quantum_instance,
)
self._ret = VQEResult()
self._eval_time = None
self._optimizer.set_max_evals_grouped(max_evals_grouped)
self._callback = callback
self._eval_count = 0
logger.info(self.print_settings())
def setUp(self):
super().setUp()
self.seed = 7
aqua_globals.random_seed = self.seed
# Number training data samples
n_v = 5000
# Load data samples from log-normal distribution with mean=1 and standard deviation=1
m_u = 1
sigma = 1
self._real_data = aqua_globals.random.lognormal(mean=m_u,
sigma=sigma,
size=n_v)
# Set upper and lower data values as list of k
# min/max data values [[min_0,max_0],...,[min_k-1,max_k-1]]
self._bounds = [0., 3.]
# Set number of qubits per data dimension as list of k qubit values[#q_0,...,#q_k-1]
num_qubits = [2]
# Batch size
batch_size = 100
# Set number of training epochs
# num_epochs = 10
num_epochs = 5
# Initialize qGAN
self.qgan = QGAN(self._real_data,
self._bounds,
num_qubits,
batch_size,
num_epochs,
snapshot_dir=None)
self.qgan.seed = 7
# Set quantum instance to run the quantum generator
self.qi_statevector = QuantumInstance(
backend=BasicAer.get_backend('statevector_simulator'),
seed_simulator=2,
seed_transpiler=2)
self.qi_qasm = QuantumInstance(
backend=BasicAer.get_backend('qasm_simulator'),
shots=1000,
seed_simulator=2,
seed_transpiler=2)
# Set entangler map
entangler_map = [[0, 1]]
# Set an initial state for the generator circuit
init_dist = UniformDistribution(sum(num_qubits),
low=self._bounds[0],
high=self._bounds[1])
q = QuantumRegister(sum(num_qubits), name='q')
qc = QuantumCircuit(q)
init_dist.build(qc, q)
init_distribution = Custom(num_qubits=sum(num_qubits), circuit=qc)
# Set generator's initial parameters
init_params = aqua_globals.random.random(
2 * sum(num_qubits)) * 2 * 1e-2
# Set variational form
var_form = RealAmplitudes(sum(num_qubits),
reps=1,
initial_state=init_distribution,
entanglement=entangler_map)
self.generator_circuit = var_form
warnings.filterwarnings('ignore', category=DeprecationWarning)
self.generator_factory = UnivariateVariationalDistribution(
sum(num_qubits),
var_form,
init_params,
low=self._bounds[0],
high=self._bounds[1])
warnings.filterwarnings('always', category=DeprecationWarning)
# Set entangler map
entangler_map = []
for i in range(sum(num_qubits)):
entangler_map.append([i, int(np.mod(i+1, sum(num_qubits)))])
# Load the trained circuit parameters
g_params = [0.29399714, 0.38853322, 0.9557694, 0.07245791, 6.02626428, 0.13537225]
# Set an initial state for the generator circuit
init_dist = NormalDistribution(sum(num_qubits), mu=1., sigma=1., low=bounds[0], high=bounds[1])
init_distribution = np.sqrt(init_dist.probabilities)
init_distribution = Custom(num_qubits=sum(num_qubits), state_vector=init_distribution)
# construct the variational form
var_form = RealAmplitudes(sum(num_qubits), entanglement=entangler_map, reps=1, initial_state=init_distribution)
var_form.entanglement_blocks = 'cz'
theta = ParameterVector('θ', var_form.num_parameters)
var_form = var_form.assign_parameters(theta)
# Set generator circuit
g_circuit = UnivariateVariationalDistribution(sum(num_qubits), var_form, g_params,
low=bounds[0], high=bounds[1])
g_circuit._var_form_params = theta
# construct circuit factory for uncertainty model
uncertainty_model = g_circuit
# set the strike price (should be within the low and the high value of the uncertainty)
strike_price = 2
def test_multiclass(self, config):
"""Test multiclass VQC."""
opt, q_i = config
if q_i == "statevector":
quantum_instance = self.sv_quantum_instance
elif q_i == "qasm":
quantum_instance = self.qasm_quantum_instance
else:
quantum_instance = None
if opt == "bfgs":
optimizer = L_BFGS_B(maxiter=5)
elif opt == "cobyla":
optimizer = COBYLA(maxiter=25)
else:
optimizer = None
num_inputs = 2
feature_map = ZZFeatureMap(num_inputs)
ansatz = RealAmplitudes(num_inputs, reps=1)
# fix the initial point
initial_point = np.array([0.5] * ansatz.num_parameters)
# construct classifier - note: CrossEntropy requires eval_probabilities=True!
classifier = VQC(
feature_map=feature_map,
ansatz=ansatz,
optimizer=optimizer,
quantum_instance=quantum_instance,
initial_point=initial_point,
)
# construct data
num_samples = 5
num_classes = 5
# pylint: disable=invalid-name
# We create a dataset that is random, but has some training signal, as follows:
# First, we create a random feature matrix X, but sort it by the row-wise sum in ascending
# order.
X = algorithm_globals.random.random((num_samples, num_inputs))
X = X[X.sum(1).argsort()]
# Next we create an array which contains all class labels, multiple times if num_samples <
# num_classes, and in ascending order (e.g. [0, 0, 1, 1, 2]). So now we have a dataset
# where the row-sum of X is correlated with the class label (i.e. smaller row-sum is more
# likely to belong to class 0, and big row-sum is more likely to belong to class >0)
y_indices = (np.digitize(np.arange(0, 1, 1 / num_samples),
np.arange(0, 1, 1 / num_classes)) - 1)
# Third, we random shuffle both X and y_indices
permutation = np.random.permutation(np.arange(num_samples))
X = X[permutation]
y_indices = y_indices[permutation]
# Lastly we create a 1-hot label matrix y
y = np.zeros((num_samples, num_classes))
for e, index in enumerate(y_indices):
y[e, index] = 1
# fit to data
classifier.fit(X, y)
# score
score = classifier.score(X, y)
self.assertGreater(score, 1 / num_classes)
def test_h2_bopes_sampler(self):
"""Test BOPES Sampler on H2"""
seed = 50
algorithm_globals.random_seed = seed
# Molecule
dof = partial(Molecule.absolute_distance, atom_pair=(1, 0))
m = Molecule(geometry=[['H', [0., 0., 1.]],
['H', [0., 0.45, 1.]]],
degrees_of_freedom=[dof])
f_t = FermionicTransformation()
driver = PySCFDriver(molecule=m)
qubitop, _ = f_t.transform(driver)
# Quantum Instance:
shots = 1
backend = 'statevector_simulator'
quantum_instance = QuantumInstance(BasicAer.get_backend(backend), shots=shots)
quantum_instance.run_config.seed_simulator = seed
quantum_instance.compile_config['seed_transpiler'] = seed
# Variational form
i_state = HartreeFock(num_orbitals=f_t._molecule_info['num_orbitals'],
qubit_mapping=f_t._qubit_mapping,
two_qubit_reduction=f_t._two_qubit_reduction,
num_particles=f_t._molecule_info['num_particles'],
sq_list=f_t._molecule_info['z2_symmetries'].sq_list
)
var_form = RealAmplitudes(qubitop.num_qubits, reps=1, entanglement='full',
skip_unentangled_qubits=False)
var_form.compose(i_state, front=True)
# Classical optimizer:
# Analytic Quantum Gradient Descent (AQGD) (with Epochs)
aqgd_max_iter = [10] + [1] * 100
aqgd_eta = [1e0] + [1.0 / k for k in range(1, 101)]
aqgd_momentum = [0.5] + [0.5] * 100
optimizer = AQGD(maxiter=aqgd_max_iter,
eta=aqgd_eta,
momentum=aqgd_momentum,
tol=1e-6,
averaging=4)
# Min Eigensolver: VQE
solver = VQE(var_form=var_form,
optimizer=optimizer,
quantum_instance=quantum_instance,
expectation=PauliExpectation())
me_gss = GroundStateEigensolver(f_t, solver)
# BOPES sampler
sampler = BOPESSampler(gss=me_gss)
# absolute internuclear distance in Angstrom
points = [0.7, 1.0, 1.3]
results = sampler.sample(driver, points)
points_run = results.points
energies = results.energies
np.testing.assert_array_almost_equal(points_run, [0.7, 1.0, 1.3])
np.testing.assert_array_almost_equal(energies,
[-1.13618945, -1.10115033, -1.03518627], decimal=2)
def __init__(
self,
ansatz: Optional[QuantumCircuit] = None,
optimizer: Optional[Optimizer] = None,
initial_point: Optional[np.ndarray] = None,
gradient: Optional[Union[GradientBase, Callable]] = None,
expectation: Optional[ExpectationBase] = None,
include_custom: bool = False,
max_evals_grouped: int = 1,
callback: Optional[Callable[[int, np.ndarray, float, float],
None]] = None,
quantum_instance: Optional[Union[QuantumInstance, BaseBackend,
Backend]] = None,
sort_parameters_by_name: Optional[bool] = None,
) -> None:
"""
Args:
ansatz: A parameterized circuit used as Ansatz for the wave function.
optimizer: A classical optimizer.
initial_point: An optional initial point (i.e. initial parameter values)
for the optimizer. If ``None`` then VQE will look to the ansatz for a preferred
point and if not will simply compute a random one.
gradient: An optional gradient function or operator for optimizer.
expectation: The Expectation converter for taking the average value of the
Observable over the ansatz state function. When ``None`` (the default) an
:class:`~qiskit.opflow.expectations.ExpectationFactory` is used to select
an appropriate expectation based on the operator and backend. When using Aer
qasm_simulator backend, with paulis, it is however much faster to leverage custom
Aer function for the computation but, although VQE performs much faster
with it, the outcome is ideal, with no shot noise, like using a state vector
simulator. If you are just looking for the quickest performance when choosing Aer
qasm_simulator and the lack of shot noise is not an issue then set `include_custom`
parameter here to ``True`` (defaults to ``False``).
include_custom: When `expectation` parameter here is None setting this to ``True`` will
allow the factory to include the custom Aer pauli expectation.
max_evals_grouped: Max number of evaluations performed simultaneously. Signals the
given optimizer that more than one set of parameters can be supplied so that
potentially the expectation values can be computed in parallel. Typically this is
possible when a finite difference gradient is used by the optimizer such that
multiple points to compute the gradient can be passed and if computed in parallel
improve overall execution time. Deprecated if a gradient operator or function is
given.
callback: a callback that can access the intermediate data during the optimization.
Four parameter values are passed to the callback as follows during each evaluation
by the optimizer for its current set of parameters as it works towards the minimum.
These are: the evaluation count, the optimizer parameters for the
ansatz, the evaluated mean and the evaluated standard deviation.`
quantum_instance: Quantum Instance or Backend
sort_parameters_by_name: Deprecated. If True, the initial point is bound to the ansatz
parameters strictly sorted by name instead of the default circuit order. That means
that the ansatz parameters are e.g. sorted as ``x[0] x[1] x[10] x[2] ...`` instead
of ``x[0] x[1] x[2] ... x[10]``. Set this to ``True`` to obtain the behavior prior
to Qiskit Terra 0.18.0.
"""
validate_min("max_evals_grouped", max_evals_grouped, 1)
if sort_parameters_by_name is not None:
warnings.warn(
"The ``sort_parameters_by_name`` attribute is deprecated and will be "
"removed no sooner than 3 months after the release date of Qiskit Terra "
"0.18.0.",
DeprecationWarning,
stacklevel=2,
)
if ansatz is None:
ansatz = RealAmplitudes()
if optimizer is None:
optimizer = SLSQP()
if quantum_instance is not None:
if not isinstance(quantum_instance, QuantumInstance):
quantum_instance = QuantumInstance(quantum_instance)
super().__init__()
self._max_evals_grouped = max_evals_grouped
self._circuit_sampler = None # type: Optional[CircuitSampler]
self._expectation = expectation
self._include_custom = include_custom
# set ansatz -- still supporting pre 0.18.0 sorting
self._sort_parameters_by_name = sort_parameters_by_name
self._ansatz_params = None
self._ansatz = None
self.ansatz = ansatz
self._optimizer = optimizer
self._initial_point = initial_point
self._gradient = gradient
self._quantum_instance = None
if quantum_instance is not None:
self.quantum_instance = quantum_instance
self._eval_time = None
self._eval_count = 0
self._optimizer.set_max_evals_grouped(max_evals_grouped)
self._callback = callback
logger.info(self.print_settings())
# TODO remove this once the stateful methods are deleted
self._ret = None
