def run(self, M):
""" Performs the optimization.
Args:
M: number of measurements per iteration
Returns:
(best_params, cost_history)
where
best_params: calculated values for ["θ_y", "θ_x"] (as list)
cost_history: costs for each iteration (as list)
"""
# Clear costs log
self.cost_history = []
# Use SPSA as our classical optimizer
optimizer = SPSA()
# Define cost function
def cost_(params):
return self.cost(params, M)
# Randomize initial point
initial_point = [np.random.rand() * np.pi for _ in range(2)]
# Perform optimization
best_params, _, _ = optimizer.optimize(
num_vars=2,
objective_function=cost_,
variable_bounds=[(0, 2 * np.pi)] * 2,
initial_point=initial_point)
return best_params, self.cost_history
def __init__(
self,
max_iter=200, # Minimizer iterations.
n_g=1, # Averaging number
):
from qiskit.aqua.components.optimizers import SPSA
self.optimizer = SPSA(max_trials=max_iter, last_avg=n_g)
def optimize(self, maxiter=500):
thetas = np.array(self.qri.generate(self.num_qubits)) / 32
spsa = SPSA(maxiter=maxiter)
minima, _, _ = spsa.optimize(self.num_qubits,
self._objective_fn,
initial_point=thetas)
self.minima = list(minima)
def minimize(self, cost_function, initial_params=None):
"""
Minimizes given cost function using optimizers from Qiskit Aqua.
Args:
cost_function(): python method which takes numpy.ndarray as input
initial_params(np.ndarray): initial parameters to be used for optimization
Returns:
optimization_results(scipy.optimize.OptimizeResults): results of the optimization.
"""
history = []
if self.method == "SPSA":
optimizer = SPSA(**self.options)
elif self.method == "ADAM" or self.method == "AMSGRAD":
if self.method == "AMSGRAD":
self.options["amsgrad"] = True
optimizer = ADAM(**self.options)
number_of_variables = len(initial_params)
if self.keep_value_history:
cost_function_wrapper = recorder(cost_function)
else:
cost_function_wrapper = _CostFunctionWrapper(cost_function)
gradient_function = None
if hasattr(cost_function, "gradient") and callable(
getattr(cost_function, "gradient")):
gradient_function = cost_function.gradient
solution, value, nit = optimizer.optimize(
num_vars=number_of_variables,
objective_function=cost_function_wrapper,
initial_point=initial_params,
gradient_function=gradient_function,
)
if self.keep_value_history:
nfev = len(cost_function_wrapper.history)
history = cost_function_wrapper.history
else:
nfev = cost_function_wrapper.number_of_calls
history = []
return optimization_result(
opt_value=value,
opt_params=solution,
nit=nit,
history=history,
nfev=nfev,
)
def test_vqc_with_max_evals_grouped(self):
""" vqc with max evals grouped test """
aqua_globals.random_seed = self.seed
optimizer = SPSA(max_trials=10,
save_steps=1,
c0=4.0,
c1=0.1,
c2=0.602,
c3=0.101,
c4=0.0,
skip_calibration=True)
feature_map = SecondOrderExpansion(
feature_dimension=get_feature_dimension(self.training_data),
depth=2)
var_form = RYRZ(num_qubits=feature_map.num_qubits, depth=3)
vqc = VQC(optimizer,
feature_map,
var_form,
self.training_data,
self.testing_data,
max_evals_grouped=2)
quantum_instance = QuantumInstance(
BasicAer.get_backend('qasm_simulator'),
shots=1024,
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
result = vqc.run(quantum_instance)
np.testing.assert_array_almost_equal(result['opt_params'],
self.ref_opt_params,
decimal=8)
np.testing.assert_array_almost_equal(result['training_loss'],
self.ref_train_loss,
decimal=8)
self.assertEqual(1.0, result['testing_accuracy'])
def test_set_packing_vqe(self):
""" set packing vqe test """
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
except Exception as ex: # pylint: disable=broad-except
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
aqua_globals.random_seed = 50
result = VQE(self.qubit_op,
RY(self.qubit_op.num_qubits,
depth=5,
entanglement='linear'),
SPSA(max_trials=200),
max_evals_grouped=2).run(
QuantumInstance(
Aer.get_backend('qasm_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
x = sample_most_likely(result['eigvecs'][0])
ising_sol = set_packing.get_solution(x)
oracle = self._brute_force()
self.assertEqual(np.count_nonzero(ising_sol), oracle)
def test_with_aer_qasm(self):
"""Test VQE with Aer's qasm_simulator."""
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
except Exception as ex: # pylint: disable=broad-except
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
backend = Aer.get_backend('qasm_simulator')
optimizer = SPSA(maxiter=200, last_avg=5)
wavefunction = self.ry_wavefunction
vqe = VQE(self.h2_op,
wavefunction,
optimizer,
expectation=PauliExpectation())
quantum_instance = QuantumInstance(
backend,
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
result = vqe.run(quantum_instance)
self.assertAlmostEqual(result.eigenvalue.real, -1.86305, places=2)
def test_h2_one_qubit_qasm(self):
"""Test H2 with tapering and qasm backend"""
two_qubit_reduction = True
qubit_mapping = 'parity'
core = Hamiltonian(transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.PARITY,
two_qubit_reduction=two_qubit_reduction,
freeze_core=False,
orbital_reduction=[])
qubit_op, _ = core.run(self.molecule)
num_orbitals = core.molecule_info['num_orbitals']
num_particles = core.molecule_info['num_particles']
# tapering
z2_symmetries = Z2Symmetries.find_Z2_symmetries(qubit_op)
# know the sector
tapered_op = z2_symmetries.taper(qubit_op)[1]
var_form = RY(tapered_op.num_qubits, depth=1)
optimizer = SPSA(max_trials=50)
eom_vqe = QEomVQE(tapered_op, var_form, optimizer, num_orbitals=num_orbitals,
num_particles=num_particles, qubit_mapping=qubit_mapping,
two_qubit_reduction=two_qubit_reduction,
z2_symmetries=tapered_op.z2_symmetries, untapered_op=qubit_op)
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=65536)
result = eom_vqe.run(quantum_instance)
np.testing.assert_array_almost_equal(self.reference, result['energies'], decimal=2)
def test_vqe_2_iqpe(self):
""" vqe to iqpe test """
backend = BasicAer.get_backend('qasm_simulator')
num_qbits = self.qubit_op.num_qubits
wavefunction = TwoLocal(num_qbits, ['ry', 'rz'],
'cz',
reps=3,
insert_barriers=True)
optimizer = SPSA(maxiter=10)
algo = VQE(self.qubit_op, wavefunction, optimizer)
quantum_instance = QuantumInstance(backend,
seed_simulator=self.seed,
seed_transpiler=self.seed)
result = algo.run(quantum_instance)
self.log.debug('VQE result: %s.', result)
ref_eigenval = -1.85727503 # Known reference value
num_time_slices = 1
num_iterations = 6
param_dict = result.optimal_parameters
state_in = VarFormBased(wavefunction, param_dict)
iqpe = IQPE(self.qubit_op,
state_in,
num_time_slices,
num_iterations,
expansion_mode='suzuki',
expansion_order=2,
shallow_circuit_concat=True)
quantum_instance = QuantumInstance(backend,
shots=100,
seed_transpiler=self.seed,
seed_simulator=self.seed)
result = iqpe.run(quantum_instance)
self.log.debug('top result str label: %s',
result.top_measurement_label)
self.log.debug('top result in decimal: %s',
result.top_measurement_decimal)
self.log.debug('stretch: %s', result.stretch)
self.log.debug('translation: %s', result.translation)
self.log.debug('final eigenvalue from QPE: %s', result.eigenvalue)
self.log.debug('reference eigenvalue: %s', ref_eigenval)
self.log.debug('ref eigenvalue (transformed): %s',
(ref_eigenval + result.translation) * result.stretch)
self.log.debug(
'reference binary str label: %s',
decimal_to_binary(
(ref_eigenval.real + result.translation) * result.stretch,
max_num_digits=num_iterations + 3,
fractional_part_only=True))
self.assertAlmostEqual(result.eigenvalue.real,
ref_eigenval.real,
delta=1e-2)
def test_uccsd_hf_aer_qasm(self):
""" uccsd hf test with Aer qasm_simulator. """
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
except Exception as ex: # pylint: disable=broad-except
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
backend = Aer.get_backend('qasm_simulator')
optimizer = SPSA(maxiter=200, last_avg=5)
solver = VQE(var_form=self.var_form,
optimizer=optimizer,
expectation=PauliExpectation(),
quantum_instance=QuantumInstance(
backend=backend,
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
gsc = GroundStateEigensolver(self.fermionic_transformation, solver)
result = gsc.solve(self.driver)
self.assertAlmostEqual(result.energy, -1.138, places=2)
def test_vqc_statevector(self, mode):
""" vqc statevector test """
aqua_globals.random_seed = 2752
optimizer = SPSA(max_trials=100,
save_steps=1,
c0=4.0,
c1=0.1,
c2=0.602,
c3=0.101,
c4=0.0,
skip_calibration=True)
data_preparation = self.data_preparation[mode]
wavefunction = self.ryrz_wavefunction[mode]
if mode == 'wrapped':
warnings.filterwarnings('ignore', category=DeprecationWarning)
# set up algorithm
vqc = VQC(optimizer, data_preparation, wavefunction,
self.training_data, self.testing_data)
if mode == 'wrapped':
warnings.filterwarnings('always', category=DeprecationWarning)
quantum_instance = QuantumInstance(
BasicAer.get_backend('statevector_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
result = vqc.run(quantum_instance)
with self.subTest('training loss'):
self.assertGreater(result['training_loss'], 0.10, 2)
with self.subTest('accuracy'):
self.assertEqual(result['testing_accuracy'],
0.0 if mode == 'wrapped' else 0.5)
def test_set_packing_vqe(self):
""" set packing vqe test """
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
except Exception as ex: # pylint: disable=broad-except
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
wavefunction = TwoLocal(rotation_blocks='ry',
entanglement_blocks='cz',
reps=3,
entanglement='linear')
result = VQE(self.qubit_op,
wavefunction,
SPSA(maxiter=200),
max_evals_grouped=2).run(
QuantumInstance(
Aer.get_backend('qasm_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
x = sample_most_likely(result.eigenstate)
ising_sol = set_packing.get_solution(x)
oracle = self._brute_force()
self.assertEqual(np.count_nonzero(ising_sol), oracle)
def run_IBM(H=None,
backend=None,
num_samples=100,
qaoa_steps=3,
variables=None):
num_vars = len(list(H.linear))
qubit_op, offset = get_ising_opt_qubitops(H, variables)
if backend == None:
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend)
spsa = SPSA(max_trials=10)
qaoa = QAOA(qubit_op, spsa, qaoa_steps)
result = qaoa.run(quantum_instance)
circ = qaoa.get_optimal_circuit()
q = circ.qregs[0]
c = ClassicalRegister(num_vars, 'c')
circ.cregs.append(c)
circ.measure(q, c)
job = execute(circ, backend, shots=num_samples, memory=True)
return job.result().get_counts(circ)
def _test_readme_sample(self):
""" readme sample test """
# pylint: disable=import-outside-toplevel,redefined-builtin
def print(*args):
""" overloads print to log values """
if args:
self.log.debug(args[0], *args[1:])
# Fix the random seed of SPSA (Optional)
from qiskit.aqua import aqua_globals
aqua_globals.random_seed = 123
# --- Exact copy of sample code ----------------------------------------
import networkx as nx
import numpy as np
from qiskit.optimization import QuadraticProgram
from qiskit.optimization.algorithms import MinimumEigenOptimizer
from qiskit import BasicAer
from qiskit.aqua.algorithms import QAOA
from qiskit.aqua.components.optimizers import SPSA
# Generate a graph of 4 nodes
n = 4
graph = nx.Graph()
graph.add_nodes_from(np.arange(0, n, 1))
elist = [(0, 1, 1.0), (0, 2, 1.0), (0, 3, 1.0), (1, 2, 1.0),
(2, 3, 1.0)]
graph.add_weighted_edges_from(elist)
# Compute the weight matrix from the graph
w = nx.adjacency_matrix(graph)
# Formulate the problem as quadratic program
problem = QuadraticProgram()
_ = [problem.binary_var('x{}'.format(i))
for i in range(n)] # create n binary variables
linear = w.dot(np.ones(n))
quadratic = -w
problem.maximize(linear=linear, quadratic=quadratic)
# Fix node 0 to be 1 to break the symmetry of the max-cut solution
problem.linear_constraint([1, 0, 0, 0], '==', 1)
# Run quantum algorithm QAOA on qasm simulator
spsa = SPSA(maxiter=250)
backend = BasicAer.get_backend('qasm_simulator')
qaoa = QAOA(optimizer=spsa, p=5, quantum_instance=backend)
algorithm = MinimumEigenOptimizer(qaoa)
result = algorithm.solve(problem)
print(result) # prints solution, x=[1, 0, 1, 0], the cost, fval=4
# ----------------------------------------------------------------------
np.testing.assert_array_almost_equal(result.x, [1, 0, 1, 0])
self.assertAlmostEqual(result.fval, 4.0)
def setUp(self):
super().setUp()
self.seed = 50
aqua_globals.random_seed = self.seed
self.training_data = {
'A': np.asarray([[2.95309709, 2.51327412],
[3.14159265, 4.08407045]]),
'B': np.asarray([[4.08407045, 2.26194671],
[4.46106157, 2.38761042]])
}
self.testing_data = {
'A': np.asarray([[3.83274304, 2.45044227]]),
'B': np.asarray([[3.89557489, 0.31415927]])
}
self.ref_opt_params = np.array([
0.47352206, -3.75934473, 1.72605939, -4.17669389, 1.28937435,
-0.05841719, -0.29853266, -2.04139334, 1.00271775, -1.48133882,
-1.18769138, 1.17885493, 7.58873883, -5.27078091, 2.5306601,
-4.67393152
])
self.ref_opt_params = np.array([
4.40301812e-01, 2.10844304, -2.10118578, -5.25903194, 2.07617769,
-9.25865371, -5.33834788, 8.59005180, 3.39886480, 6.33839643,
1.24425033, -1.39701513e+01, -7.16008545e-03, 3.36206032,
4.38001391, -3.47098082
])
self.ref_train_loss = 0.5869304
self.ref_prediction_a_probs = [[0.8984375, 0.1015625]]
self.ref_prediction_a_label = [0]
self.ryrz_wavefunction = TwoLocal(2, ['ry', 'rz'],
'cz',
reps=3,
insert_barriers=True)
self.data_preparation = ZZFeatureMap(2, reps=2)
self.statevector_simulator = QuantumInstance(
BasicAer.get_backend('statevector_simulator'),
shots=1,
seed_simulator=self.seed,
seed_transpiler=self.seed)
self.qasm_simulator = QuantumInstance(
BasicAer.get_backend('qasm_simulator'),
shots=1024,
seed_simulator=self.seed,
seed_transpiler=self.seed)
self.spsa = SPSA(maxiter=10,
save_steps=1,
c0=4.0,
c1=0.1,
c2=0.602,
c3=0.101,
c4=0.0,
skip_calibration=True)
def test_feature_map_without_parameters_warns(self):
"""Test that specifying a feature map with 0 parameters raises a warning."""
aqua_globals.random_seed = self.seed
var_form = QuantumCircuit(1)
var_form.ry(Parameter('a'), 0)
feature_map = QuantumCircuit(1)
optimizer = SPSA()
with self.assertWarns(UserWarning):
_ = VQC(optimizer, feature_map, var_form, self.training_data, self.testing_data)
def test_vqe_qasm(self):
backend = BasicAer.get_backend('qasm_simulator')
num_qubits = self.algo_input.qubit_op.num_qubits
var_form = RY(num_qubits, 3)
optimizer = SPSA(max_trials=300, last_avg=5)
algo = VQE(self.algo_input.qubit_op, var_form, optimizer, max_evals_grouped=1)
quantum_instance = QuantumInstance(backend, shots=10000, optimization_level=0)
result = algo.run(quantum_instance)
self.assertAlmostEqual(result['energy'], -1.85727503, places=2)
def test_save_and_load_model(self):
""" save and load model test """
np.random.seed(self.random_seed)
aqua_globals.random_seed = self.random_seed
backend = BasicAer.get_backend('qasm_simulator')
num_qubits = 2
optimizer = SPSA(max_trials=10, save_steps=1, c0=4.0, skip_calibration=True)
feature_map = SecondOrderExpansion(feature_dimension=num_qubits, depth=2)
var_form = RYRZ(num_qubits=num_qubits, depth=3)
vqc = VQC(optimizer, feature_map, var_form, self.training_data, self.testing_data)
quantum_instance = QuantumInstance(backend,
shots=1024,
seed_simulator=self.random_seed,
seed_transpiler=self.random_seed)
result = vqc.run(quantum_instance)
np.testing.assert_array_almost_equal(result['opt_params'],
self.ref_opt_params, decimal=4)
np.testing.assert_array_almost_equal(result['training_loss'],
self.ref_train_loss, decimal=8)
self.assertEqual(1.0, result['testing_accuracy'])
file_path = self._get_resource_path('vqc_test.npz')
vqc.save_model(file_path)
self.assertTrue(os.path.exists(file_path))
loaded_vqc = VQC(optimizer, feature_map, var_form, self.training_data, None)
loaded_vqc.load_model(file_path)
np.testing.assert_array_almost_equal(
loaded_vqc.ret['opt_params'], self.ref_opt_params, decimal=4)
loaded_test_acc = loaded_vqc.test(vqc.test_dataset[0],
vqc.test_dataset[1],
quantum_instance)
self.assertEqual(result['testing_accuracy'], loaded_test_acc)
predicted_probs, predicted_labels = loaded_vqc.predict(self.testing_data['A'],
quantum_instance)
np.testing.assert_array_almost_equal(predicted_probs,
self.ref_prediction_a_probs,
decimal=8)
np.testing.assert_array_equal(predicted_labels, self.ref_prediction_a_label)
if quantum_instance.has_circuit_caching:
self.assertLess(quantum_instance._circuit_cache.misses, 3)
if os.path.exists(file_path):
try:
os.remove(file_path)
except Exception: # pylint: disable=broad-except
pass
def test_vqe_2_iqpe(self):
""" vqe to iqpe test """
backend = BasicAer.get_backend('qasm_simulator')
num_qbits = self.algo_input.qubit_op.num_qubits
var_form = RYRZ(num_qbits, 3)
optimizer = SPSA(max_trials=10)
# optimizer.set_options(**{'max_trials': 500})
algo = VQE(self.algo_input.qubit_op, var_form, optimizer)
quantum_instance = QuantumInstance(backend,
seed_simulator=self.seed,
seed_transpiler=self.seed)
result = algo.run(quantum_instance)
self.log.debug('VQE result: %s.', result)
ref_eigenval = -1.85727503
num_time_slices = 1
num_iterations = 6
state_in = VarFormBased(var_form, result['opt_params'])
iqpe = IQPE(self.algo_input.qubit_op,
state_in,
num_time_slices,
num_iterations,
expansion_mode='suzuki',
expansion_order=2,
shallow_circuit_concat=True)
quantum_instance = QuantumInstance(backend,
shots=100,
seed_transpiler=self.seed,
seed_simulator=self.seed)
result = iqpe.run(quantum_instance)
self.log.debug('top result str label: %s',
result['top_measurement_label'])
self.log.debug('top result in decimal: %s',
result['top_measurement_decimal'])
self.log.debug('stretch: %s', result['stretch'])
self.log.debug('translation: %s',
result['translation'])
self.log.debug('final eigenvalue from QPE: %s', result['energy'])
self.log.debug('reference eigenvalue: %s', ref_eigenval)
self.log.debug('ref eigenvalue (transformed): %s',
(ref_eigenval + result['translation']) *
result['stretch'])
self.log.debug(
'reference binary str label: %s',
decimal_to_binary(
(ref_eigenval + result['translation']) * result['stretch'],
max_num_digits=num_iterations + 3,
fractional_part_only=True))
np.testing.assert_approx_equal(result['energy'],
ref_eigenval,
significant=2)
def test_basic_aer_qasm(self):
"""Test the VQE on BasicAer's QASM simulator."""
optimizer = SPSA(max_trials=300, last_avg=5)
wavefunction = self.ry_wavefunction
vqe = VQE(self.h2_op, wavefunction, optimizer, max_evals_grouped=1)
# TODO benchmark this later.
result = vqe.run(self.qasm_simulator)
self.assertAlmostEqual(result.eigenvalue.real, -1.86823, places=2)
def run_simulation(self, backend):
seed = int(os.environ.get("SEED", "40598"))
n = int(os.environ.get("N", "4"))
#
# Random 3-regular graph with 12 nodes
#
graph = nx.random_regular_graph(3, n, seed=seed)
for e in graph.edges():
graph[e[0]][e[1]]["weight"] = 1.0
# Compute the weight matrix from the graph
w = np.zeros([n, n])
for i in range(n):
for j in range(n):
temp = graph.get_edge_data(i, j, default=0)
if temp != 0:
w[i, j] = temp["weight"]
# Create an Ising Hamiltonian with docplex.
mdl = Model(name="max_cut")
mdl.node_vars = mdl.binary_var_list(list(range(n)), name="node")
maxcut_func = mdl.sum(w[i, j] * mdl.node_vars[i] *
(1 - mdl.node_vars[j]) for i in range(n)
for j in range(n))
mdl.maximize(maxcut_func)
qubit_op, offset = docplex.get_operator(mdl)
aqua_globals.random_seed = seed
# Run quantum algorithm QAOA on qasm simulator
spsa = SPSA(max_trials=250)
qaoa = QAOA(qubit_op, spsa, p=5, max_evals_grouped=4)
quantum_instance = QuantumInstance(
backend,
shots=1024,
seed_simulator=seed,
seed_transpiler=seed,
optimization_level=0,
)
result = qaoa.run(quantum_instance)
x = sample_most_likely(result["eigvecs"][0])
result["solution"] = max_cut.get_graph_solution(x)
result["solution_objective"] = max_cut.max_cut_value(x, w)
result["maxcut_objective"] = result["energy"] + offset
"""
print("energy:", result["energy"])
print("time:", result["eval_time"])
print("max-cut objective:", result["energy"] + offset)
print("solution:", max_cut.get_graph_solution(x))
print("solution objective:", max_cut.max_cut_value(x, w))
"""
return result
def make_opt(opt_str):
if opt_str == "spsa":
optimizer = SPSA(max_trials=100, save_steps=1, c0=4.0, skip_calibration=True)
elif opt_str == "cobyla":
optimizer = COBYLA(maxiter=1000, disp=False, rhobeg=1.0, tol=None)
elif opt_str == "adam":
optimizer = ADAM(maxiter=10000, tol=1e-6, lr=1e-3, beta_1=0.9, beta_2=0.99, noise_factor=1e-8, eps=1e-10)
else:
print('error in building OPTIMIZER: {} IT DOES NOT EXIST'.format(opt_str))
sys.exit(1)
return optimizer
def test_vqe_2_iqpe(self):
backend = get_aer_backend('qasm_simulator')
num_qbits = self.algo_input.qubit_op.num_qubits
var_form = RYRZ(num_qbits, 3)
optimizer = SPSA(max_trials=10)
# optimizer.set_options(**{'max_trials': 500})
algo = VQE(self.algo_input.qubit_op, var_form, optimizer, 'paulis')
quantum_instance = QuantumInstance(backend)
result = algo.run(quantum_instance)
self.log.debug('VQE result: {}.'.format(result))
self.ref_eigenval = -1.85727503
num_time_slices = 50
num_iterations = 11
state_in = VarFormBased(var_form, result['opt_params'])
iqpe = IQPE(self.algo_input.qubit_op,
state_in,
num_time_slices,
num_iterations,
expansion_mode='suzuki',
expansion_order=2,
shallow_circuit_concat=True)
quantum_instance = QuantumInstance(backend,
shots=100,
pass_manager=PassManager(),
seed_mapper=self.random_seed)
result = iqpe.run(quantum_instance)
self.log.debug('top result str label: {}'.format(
result['top_measurement_label']))
self.log.debug('top result in decimal: {}'.format(
result['top_measurement_decimal']))
self.log.debug('stretch: {}'.format(
result['stretch']))
self.log.debug('translation: {}'.format(
result['translation']))
self.log.debug('final eigenvalue from QPE: {}'.format(
result['energy']))
self.log.debug('reference eigenvalue: {}'.format(
self.ref_eigenval))
self.log.debug('ref eigenvalue (transformed): {}'.format(
(self.ref_eigenval + result['translation']) * result['stretch']))
self.log.debug('reference binary str label: {}'.format(
decimal_to_binary((self.ref_eigenval + result['translation']) *
result['stretch'],
max_num_digits=num_iterations + 3,
fractional_part_only=True)))
np.testing.assert_approx_equal(self.ref_eigenval,
result['energy'],
significant=2)
def test_same_parameter_names_raises(self):
"""Test that the varform and feature map can have parameters with the same name."""
var_form = QuantumCircuit(1)
var_form.ry(Parameter('a'), 0)
feature_map = QuantumCircuit(1)
feature_map.rz(Parameter('a'), 0)
optimizer = SPSA()
vqc = VQC(optimizer, feature_map, var_form, self.training_data,
self.testing_data)
with self.assertRaises(AquaError):
_ = vqc.run(BasicAer.get_backend('statevector_simulator'))
def test_vqe_qasm(self):
""" VQE QASM test """
backend = BasicAer.get_backend('qasm_simulator')
num_qubits = self.qubit_op.num_qubits
var_form = RY(num_qubits, 3)
optimizer = SPSA(max_trials=300, last_avg=5)
algo = VQE(self.qubit_op, var_form, optimizer, max_evals_grouped=1)
quantum_instance = QuantumInstance(backend, shots=10000,
seed_simulator=self.seed,
seed_transpiler=self.seed)
result = algo.run(quantum_instance)
self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=2)
def getOptimiser(name="SPSA", params={}):
optimiser = None
if 'SPSA' in name:
#max_trials (int) – Maximum number of iterations to perform.
#save_steps (int) – Save intermeditate info every save_steps step.
#last_avg (int) – Averged parameters over the last_avg iterations. If last_avg = 1, only the last iteration is considered.
#c0 (float) – The initial a. Step size to update paramters.
#c1 (float) – The initial c. The step size used to approximate gradient.
#c2 (float) – The alpha in the paper, and it is used to adjust a (c0) at each iteration.
#c3 (float) – The gamma in the paper, and it is used to adjust c (c1) at each iteration.
#c4 (float) – The parameter used to control a as well.
#skip_calibration (bool) – skip calibration and use provided c(s) as is.
optimiser = SPSA(
max_trials=params["max_trials"],
save_steps=params["save_steps"],
)
elif 'COBYLA' in name:
#maxiter (int) – Maximum number of function evaluations.
#disp (bool) – Set to True to print convergence messages.
#rhobeg (float) – Reasonable initial changes to the variables.
#tol (float) – Final accuracy in the optimization (not precisely guaranteed). This is a lower bound on the size of the trust region.
optimiser = COBYLA(maxiter=params["maxiter"], disp=True)
elif 'L_BFGS_B' in name:
#maxfun (int) – Maximum number of function evaluations.
#maxiter (int) – Maximum number of iterations.
#factr (float) – The iteration stops when (f^k - f^{k+1})/max{|f^k|, |f^{k+1}|,1} <= factr * eps, where eps is the machine precision, which is automatically generated by the code. Typical values for factr are: 1e12 for low accuracy; 1e7 for moderate accuracy; 10.0 for extremely high accuracy. See Notes for relationship to ftol, which is exposed (instead of factr) by the scipy.optimize.minimize interface to L-BFGS-B.
#iprint (int) – Controls the frequency of output. iprint < 0 means no output; iprint = 0 print only one line at the last iteration; 0 < iprint < 99 print also f and |proj g| every iprint iterations; iprint = 99 print details of every iteration except n-vectors; iprint = 100 print also the changes of active set and final x; iprint > 100 print details of every iteration including x and g.
#epsilon (float) – Step size used when approx_grad is True, for numerically calculating the gradient
optimiser = L_BFGS_B(
#maxfun=params["maxfun"],
maxiter=params["maxiter"])
elif 'P_BFGS' in name:
optimiser = P_BFGS(maxfun=params["maxfun"])
elif 'NELDER_MEAD' in name:
#maxiter (int) – Maximum allowed number of iterations. If both maxiter and maxfev are set, minimization will stop at the first reached.
#maxfev (int) – Maximum allowed number of function evaluations. If both maxiter and maxfev are set, minimization will stop at the first reached.
#disp (bool) – Set to True to print convergence messages.
#xatol (float) – Absolute error in xopt between iterations that is acceptable for convergence.
#tol (float or None) – Tolerance for termination.
#adaptive (bool) – Adapt algorithm parameters to dimensionality of problem.
optimiser = NELDER_MEAD(maxiter=params["maxiter"], disp=True)
elif 'SLSQP' in name:
#maxiter (int) – Maximum number of iterations.
#disp (bool) – Set to True to print convergence messages.
#ftol (float) – Precision goal for the value of f in the stopping criterion.
#tol (float or None) – Tolerance for termination.
#eps (float) – Step size used for numerical approximation of the Jacobian.
optimiser = SLSQP(maxiter=params["maxiter"])
print("Optimising with {0} - {1}".format(name, optimiser))
return optimiser
def test_partition_vqe(self):
""" Partition VQE test """
aqua_globals.random_seed = 100
result = VQE(self.qubit_op,
RY(self.qubit_op.num_qubits, depth=5, entanglement='linear'),
SPSA(max_trials=200),
max_evals_grouped=2).run(
QuantumInstance(BasicAer.get_backend('qasm_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
x = sample_most_likely(result['eigvecs'][0])
self.assertNotEqual(x[0], x[1])
self.assertNotEqual(x[2], x[1]) # hardcoded oracle
def test_end2end_h2(self, name, optimizer, backend, shots):
""" end to end h2 """
del name # unused
if optimizer == 'COBYLA':
optimizer = COBYLA()
optimizer.set_options(maxiter=1000)
elif optimizer == 'SPSA':
optimizer = SPSA(max_trials=2000)
ryrz = RYRZ(self.qubit_op.num_qubits, depth=3, entanglement='full')
vqe = VQE(self.qubit_op, ryrz, optimizer, aux_operators=self.aux_ops)
quantum_instance = QuantumInstance(backend, shots=shots)
results = vqe.run(quantum_instance)
self.assertAlmostEqual(results['energy'], self.reference_energy, places=4)
def test_uccsd_hf_qasm(self):
""" uccsd hf test with qasm_simulator. """
backend = BasicAer.get_backend('qasm_simulator')
optimizer = SPSA(maxiter=200, last_avg=5)
solver = VQE(var_form=self.var_form, optimizer=optimizer,
expectation=PauliExpectation(),
quantum_instance=QuantumInstance(backend=backend,
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
gsc = GroundStateEigensolver(self.fermionic_transformation, solver)
result = gsc.solve(self.driver)
self.assertAlmostEqual(result.total_energies[0], -1.138, places=2)
def test_end2end_h2(self, name, optimizer, backend, mode, shots):
if optimizer == 'COBYLA':
optimizer = COBYLA()
optimizer.set_options(maxiter=1000)
elif optimizer == 'SPSA':
optimizer = SPSA(max_trials=2000)
ryrz = RYRZ(self.algo_input.qubit_op.num_qubits, depth=3, entanglement='full')
vqe = VQE(self.algo_input.qubit_op, ryrz, optimizer, mode, aux_operators=self.algo_input.aux_ops)
run_config = RunConfig(shots=shots, max_credits=10, memory=False)
quantum_instance = QuantumInstance(backend, run_config)
results = vqe.run(quantum_instance)
self.assertAlmostEqual(results['energy'], self.reference_energy, places=4)