def test_vqc_minibatching_with_gradient_support(self, mode):
""" vqc minibatching with gradient support test """
n_dim = 2 # dimension of each data point
seed = 1024
aqua_globals.random_seed = seed
_, training_input, test_input, _ = ad_hoc_data(training_size=4,
test_size=2,
n=n_dim,
gap=0.3,
plot_data=False)
backend = BasicAer.get_backend('statevector_simulator')
optimizer = L_BFGS_B(maxfun=30)
# set up data encoding circuit
data_preparation = self.data_preparation[mode]
# set up wavefunction
if mode == 'wrapped':
warnings.filterwarnings('ignore', category=DeprecationWarning)
wavefunction = RYRZ(2, depth=1)
else:
wavefunction = TwoLocal(2, ['ry', 'rz'],
'cz',
reps=1,
insert_barriers=True)
theta = ParameterVector('theta', wavefunction.num_parameters)
resorted = []
for i in range(4):
layer = wavefunction.ordered_parameters[4 * i:4 * (i + 1)]
resorted += layer[::2]
resorted += layer[1::2]
wavefunction.assign_parameters(dict(zip(resorted, theta)),
inplace=True)
if mode == 'circuit':
wavefunction = QuantumCircuit(2).compose(wavefunction)
# set up algorithm
vqc = VQC(optimizer,
data_preparation,
wavefunction,
training_input,
test_input,
minibatch_size=2)
if mode in ['circuit', 'library']:
vqc._feature_map_params = self._sorted_data_params
vqc._var_form_params = list(theta)
else:
warnings.filterwarnings('always', category=DeprecationWarning)
quantum_instance = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
result = vqc.run(quantum_instance)
vqc_accuracy = 0.5
self.log.debug(result['testing_accuracy'])
self.assertAlmostEqual(result['testing_accuracy'],
vqc_accuracy,
places=3)
def test_saving_and_loading(self):
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = self.algo_input.qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = RY(num_qubits, 3, initial_state=init_state)
optimizer = L_BFGS_B()
algo = VQE(self.algo_input.qubit_op, var_form, optimizer, 'matrix')
fd, cache_tmp_file = tempfile.mkstemp(suffix='.inp')
os.close(fd)
quantum_instance_caching = QuantumInstance(backend,
circuit_caching=True,
cache_file=cache_tmp_file,
skip_qobj_deepcopy=True,
skip_qobj_validation=True)
algo.run(quantum_instance_caching)
self.assertLessEqual(quantum_instance_caching.circuit_cache.misses, 0)
is_file_exist = os.path.exists(cache_tmp_file)
self.assertTrue(is_file_exist, "Does not store content successfully.")
circuit_cache_new = CircuitCache(skip_qobj_deepcopy=True,
cache_file=cache_tmp_file)
self.assertEqual(quantum_instance_caching.circuit_cache.mappings,
circuit_cache_new.mappings)
self.assertLessEqual(circuit_cache_new.misses, 0)
if is_file_exist:
os.remove(cache_tmp_file)
def test_vqc_minibatching_with_gradient_support(self):
n_dim = 2 # dimension of each data point
seed = 1024
np.random.seed(seed)
sample_Total, training_input, test_input, class_labels = ad_hoc_data(
training_size=8, test_size=4, n=n_dim, gap=0.3)
aqua_globals.random_seed = seed
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = n_dim
optimizer = L_BFGS_B(maxfun=100)
feature_map = SecondOrderExpansion(feature_dimension=num_qubits,
depth=2)
var_form = RYRZ(num_qubits=num_qubits, depth=2)
vqc = VQC(optimizer,
feature_map,
var_form,
training_input,
test_input,
minibatch_size=2)
# TODO: cache only work with optimization_level 0
quantum_instance = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed,
optimization_level=0)
result = vqc.run(quantum_instance)
vqc_accuracy_threshold = 0.8
self.log.debug(result['testing_accuracy'])
self.assertGreater(result['testing_accuracy'], vqc_accuracy_threshold)
def test_vqe_caching_direct(self, max_evals_grouped):
self._build_refrence_result(backends=['statevector_simulator'])
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = self.algo_input.qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = RY(num_qubits, 3, initial_state=init_state)
optimizer = L_BFGS_B()
algo = VQE(self.algo_input.qubit_op,
var_form,
optimizer,
max_evals_grouped=max_evals_grouped)
quantum_instance_caching = QuantumInstance(
backend,
circuit_caching=True,
skip_qobj_deepcopy=True,
skip_qobj_validation=True,
optimization_level=self.optimization_level)
result_caching = algo.run(quantum_instance_caching)
self.assertLessEqual(quantum_instance_caching.circuit_cache.misses, 0)
self.assertAlmostEqual(
self.reference_vqe_result['statevector_simulator']['energy'],
result_caching['energy'])
speedup_min = 3
speedup = result_caching['eval_time'] / self.reference_vqe_result[
'statevector_simulator']['eval_time']
self.assertLess(speedup, speedup_min)
def test_qasm_snapshot_mode(self):
"""Test the VQE using Aer's qasm_simulator snapshot mode."""
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 = L_BFGS_B()
wavefunction = self.ry_wavefunction
vqe = VQE(self.h2_op,
wavefunction,
optimizer,
expectation=AerPauliExpectation(),
max_evals_grouped=1)
quantum_instance = QuantumInstance(
backend,
shots=1,
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
result = vqe.run(quantum_instance)
self.assertAlmostEqual(result.eigenvalue.real,
self.h2_energy,
places=6)
def test_vqc_minibatching_with_gradient_support(self):
""" vqc minibatching with gradient support test """
n_dim = 2 # dimension of each data point
seed = 1024
aqua_globals.random_seed = seed
_, training_input, test_input, _ = ad_hoc_data(training_size=4,
test_size=2,
n=n_dim,
gap=0.3,
plot_data=False)
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = n_dim
optimizer = L_BFGS_B(maxfun=30)
feature_map = SecondOrderExpansion(feature_dimension=num_qubits,
depth=2)
var_form = RYRZ(num_qubits=num_qubits, depth=1)
vqc = VQC(optimizer,
feature_map,
var_form,
training_input,
test_input,
minibatch_size=2)
quantum_instance = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
result = vqc.run(quantum_instance)
vqc_accuracy = 0.5
self.log.debug(result['testing_accuracy'])
self.assertAlmostEqual(result['testing_accuracy'],
vqc_accuracy,
places=3)
def test_minibatching_gradient_based(self):
"""Test the minibatching option with a gradient-based optimizer."""
n_dim = 2 # dimension of each data point
_, training_input, test_input, _ = ad_hoc_data(training_size=4,
test_size=2,
n=n_dim,
gap=0.3,
plot_data=False)
optimizer = L_BFGS_B(maxfun=30)
data_preparation = self.data_preparation
wavefunction = TwoLocal(2, ['ry', 'rz'],
'cz',
reps=1,
insert_barriers=True)
vqc = VQC(optimizer,
data_preparation,
wavefunction,
training_input,
test_input,
minibatch_size=2)
result = vqc.run(self.statevector_simulator)
self.log.debug(result['testing_accuracy'])
self.assertAlmostEqual(result['testing_accuracy'], 0.75, places=3)
def test_vqe_qasm_snapshot_mode(self, mode):
""" VQE Aer qasm_simulator snapshot mode 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
backend = Aer.get_backend('qasm_simulator')
optimizer = L_BFGS_B()
wavefunction = self.ry_wavefunction[mode]
if mode == 'wrapped':
warnings.filterwarnings('ignore', category=DeprecationWarning)
vqe = VQE(self.qubit_op, wavefunction, optimizer, max_evals_grouped=1)
if mode == 'wrapped':
warnings.filterwarnings('always', category=DeprecationWarning)
quantum_instance = QuantumInstance(
backend,
shots=1,
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
result = vqe.run(quantum_instance)
self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=6)
def test_vqe_adapt(self):
""" VQEAdapt 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
self.var_form_base = UCCSD(self.num_qubits,
1,
self.num_spin_orbitals,
self.num_particles,
initial_state=self.init_state)
backend = Aer.get_backend('statevector_simulator')
optimizer = L_BFGS_B()
algorithm = VQEAdapt(self.qubit_op,
self.var_form_base,
optimizer,
threshold=0.00001,
delta=0.1)
result = algorithm.run(backend)
self.assertAlmostEqual(result['energy'], -1.85727503, places=2)
self.assertIn('num_iterations', result)
self.assertIn('final_max_grad', result)
self.assertIn('finishing_criterion', result)
def test_saving_and_loading_e2e(self):
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = self.algo_input.qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = RY(num_qubits, 1, initial_state=init_state)
optimizer = L_BFGS_B(maxiter=10)
algo = VQE(self.algo_input.qubit_op, var_form, optimizer)
with tempfile.NamedTemporaryFile(suffix='.inp',
delete=True) as cache_tmp_file:
cache_tmp_file_name = cache_tmp_file.name
quantum_instance_caching = QuantumInstance(
backend,
circuit_caching=True,
cache_file=cache_tmp_file_name,
skip_qobj_deepcopy=True,
skip_qobj_validation=True,
optimization_level=self.optimization_level)
algo.run(quantum_instance_caching)
self.assertLessEqual(quantum_instance_caching.circuit_cache.misses,
0)
is_file_exist = os.path.exists(cache_tmp_file_name)
self.assertTrue(is_file_exist,
"Does not store content successfully.")
circuit_cache_new = CircuitCache(skip_qobj_deepcopy=True,
cache_file=cache_tmp_file_name)
self.assertEqual(quantum_instance_caching.circuit_cache.mappings,
circuit_cache_new.mappings)
self.assertLessEqual(circuit_cache_new.misses, 0)
def test_vqe_caching_direct(self, batch_mode=True):
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = self.algo_input.qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = RY(num_qubits, 3, initial_state=init_state)
optimizer = L_BFGS_B()
algo = VQE(self.algo_input.qubit_op,
var_form,
optimizer,
'matrix',
batch_mode=batch_mode)
quantum_instance_caching = QuantumInstance(backend,
circuit_caching=True,
skip_qobj_deepcopy=True,
skip_qobj_validation=True)
result_caching = algo.run(quantum_instance_caching)
self.assertLessEqual(quantum_instance_caching.circuit_cache.misses, 0)
self.assertAlmostEqual(
self.reference_vqe_result['statevector_simulator']['energy'],
result_caching['energy'])
speedup_check = 3
self.log.info(
result_caching['eval_time'],
self.reference_vqe_result['statevector_simulator']['eval_time'] /
speedup_check)
def test_deprecated_variational_forms(self):
"""Test running the VQE on a deprecated VariationalForm object."""
warnings.filterwarnings('ignore', category=DeprecationWarning)
wavefunction = RYRZ(2)
vqe = VQE(self.h2_op, wavefunction, L_BFGS_B())
warnings.filterwarnings('always', category=DeprecationWarning)
result = vqe.run(self.statevector_simulator)
self.assertAlmostEqual(result.eigenvalue.real, self.h2_energy)
def test_vqe_var_forms(self, var_form_cls, places):
""" VQE Var Forms test """
result = VQE(self.qubit_op,
var_form_cls(self.qubit_op.num_qubits),
L_BFGS_B()).run(
QuantumInstance(BasicAer.get_backend('statevector_simulator'), shots=1,
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=places)
def solve_maxcut_vqe(graph, solve_type):
backend = get_compute_backend(solve_type)
operator, offset = get_operator(graph)
vqe = VQE(
operator,
RYRZ(graph.number_of_nodes(), depth=3, entanglement="linear"),
L_BFGS_B(maxfun=6000),
)
result = vqe.run(QuantumInstance(backend))
return result
def test_readme_sample(self):
""" readme sample test """
# pylint: disable=import-outside-toplevel
# --- Exact copy of sample code ----------------------------------------
from qiskit.chemistry import FermionicOperator
from qiskit.chemistry.drivers import PySCFDriver, UnitsType
from qiskit.aqua.operators import Z2Symmetries
# Use PySCF, a classical computational chemistry software
# package, to compute the one-body and two-body integrals in
# molecular-orbital basis, necessary to form the Fermionic operator
driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.735',
unit=UnitsType.ANGSTROM,
basis='sto3g')
molecule = driver.run()
num_particles = molecule.num_alpha + molecule.num_beta
num_spin_orbitals = molecule.num_orbitals * 2
# Build the qubit operator, which is the input to the VQE algorithm in Aqua
ferm_op = FermionicOperator(h1=molecule.one_body_integrals,
h2=molecule.two_body_integrals)
map_type = 'PARITY'
qubit_op = ferm_op.mapping(map_type)
qubit_op = Z2Symmetries.two_qubit_reduction(qubit_op, num_particles)
num_qubits = qubit_op.num_qubits
# setup a classical optimizer for VQE
from qiskit.aqua.components.optimizers import L_BFGS_B
optimizer = L_BFGS_B()
# setup the initial state for the variational form
from qiskit.chemistry.components.initial_states import HartreeFock
init_state = HartreeFock(num_qubits, num_spin_orbitals, num_particles)
# setup the variational form for VQE
from qiskit.aqua.components.variational_forms import RYRZ
var_form = RYRZ(num_qubits, initial_state=init_state)
# setup and run VQE
from qiskit.aqua.algorithms import VQE
algorithm = VQE(qubit_op, var_form, optimizer)
# set the backend for the quantum computation
from qiskit import Aer
backend = Aer.get_backend('statevector_simulator')
result = algorithm.run(backend)
print(result['energy'])
# ----------------------------------------------------------------------
self.assertAlmostEqual(result['energy'], -1.8572750301938803, places=6)
def test_vqe_var_forms(self, var_form_cls, places, var_form_type):
""" VQE Var Forms test """
var_form = var_form_cls(self.qubit_op.num_qubits)
if var_form_type is QuantumCircuit:
params = ParameterVector('θ', var_form.num_parameters)
var_form = var_form.construct_circuit(params)
vqe = VQE(self.qubit_op, var_form, L_BFGS_B())
result = vqe.run(QuantumInstance(BasicAer.get_backend('statevector_simulator'), shots=1,
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=places)
def test_vqe_direct(self, max_evals_grouped):
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = self.algo_input.qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = RY(num_qubits, 3, initial_state=init_state)
optimizer = L_BFGS_B()
algo = VQE(self.algo_input.qubit_op, var_form, optimizer, 'paulis', max_evals_grouped=max_evals_grouped)
quantum_instance = QuantumInstance(backend)
result = algo.run(quantum_instance)
self.assertAlmostEqual(result['energy'], -1.85727503)
if quantum_instance.has_circuit_caching:
self.assertLess(quantum_instance._circuit_cache.misses, 3)
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_vqe(self):
""" VQE test """
quantum_instance = QuantumInstance(BasicAer.get_backend('statevector_simulator'),
basis_gates=['u1', 'u2', 'u3', 'cx', 'id'],
coupling_map=[[0, 1]],
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
vqe = VQE(var_form=RYRZ(self.qubit_op.num_qubits),
optimizer=L_BFGS_B(),
quantum_instance=quantum_instance)
output = vqe.compute_minimum_eigenvalue(self.qubit_op)
self.assertAlmostEqual(output.eigenvalue, -1.85727503)
def test_stable_set_vqe(self):
""" VQE Stable set test """
result = VQE(self.qubit_op, EfficientSU2(
reps=3, entanglement='linear'), L_BFGS_B(maxfun=6000)).run(
QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
x = sample_most_likely(result.eigenstate)
self.assertAlmostEqual(result.eigenvalue, -39.5)
self.assertAlmostEqual(result.eigenvalue + self.offset, -38.0)
ising_sol = stable_set.get_graph_solution(x)
np.testing.assert_array_equal(ising_sol, [1, 1, 0, 1, 1])
self.assertEqual(stable_set.stable_set_value(x, self.w), (4.0, False))
def test_statevector(self):
"""Test running the VQC on BasicAer's Statevector simulator."""
optimizer = L_BFGS_B(maxfun=200)
data_preparation = self.data_preparation
wavefunction = self.ryrz_wavefunction
vqc = VQC(optimizer, data_preparation, wavefunction, self.training_data, self.testing_data)
result = vqc.run(self.statevector_simulator)
with self.subTest(msg='check training loss'):
self.assertLess(result['training_loss'], 0.12)
with self.subTest(msg='check testing accuracy'):
self.assertEqual(result['testing_accuracy'], 0.5)
def test_stable_set_vqe(self):
""" VQE Stable set test """
result = VQE(self.qubit_op,
RYRZ(self.qubit_op.num_qubits, depth=3, entanglement='linear'),
L_BFGS_B(maxfun=6000)).run(
QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
x = sample_most_likely(result['eigvecs'][0])
self.assertAlmostEqual(result['energy'], -29.5)
self.assertAlmostEqual(result['energy'] + self.offset, -25.0)
ising_sol = stable_set.get_graph_solution(x)
np.testing.assert_array_equal(ising_sol, [0, 0, 1, 1, 1])
self.assertEqual(stable_set.stable_set_value(x, self.w), (3.0, False))
def test_vqe_direct(self, batch_mode):
backend = get_aer_backend('statevector_simulator')
num_qubits = self.algo_input.qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = RY(num_qubits, 3, initial_state=init_state)
optimizer = L_BFGS_B()
algo = VQE(self.algo_input.qubit_op,
var_form,
optimizer,
'paulis',
batch_mode=batch_mode)
quantum_instance = QuantumInstance(backend)
result = algo.run(quantum_instance)
self.assertAlmostEqual(result['energy'], -1.85727503)
def test_vqe_aer_mode(self):
try:
from qiskit import Aer
except Exception as e:
self.skipTest("Aer doesn't appear to be installed. Error: '{}'".format(str(e)))
return
backend = Aer.get_backend('statevector_simulator')
num_qubits = self.algo_input.qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = RY(num_qubits, 3, initial_state=init_state)
optimizer = L_BFGS_B()
algo = VQE(self.algo_input.qubit_op, var_form, optimizer, max_evals_grouped=1)
quantum_instance = QuantumInstance(backend)
result = algo.run(quantum_instance)
self.assertAlmostEqual(result['energy'], -1.85727503, places=6)
def test_vqe_var_forms(self, depth, places):
""" VQE Var Forms test """
aqua_globals.random_seed = self.seed
result = VQE(
self.qubit_op,
RY(self.qubit_op.num_qubits,
depth=depth,
entanglement='sca',
entanglement_gate='crx',
skip_final_ry=True),
L_BFGS_B()).run(
QuantumInstance(BasicAer.get_backend('statevector_simulator'),
shots=1,
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
self.assertAlmostEqual(result['energy'], -1.85727503, places=places)
def test_vqc_minibatching_with_gradient_support(self, use_circuits):
""" vqc minibatching with gradient support test """
n_dim = 2 # dimension of each data point
seed = 1024
aqua_globals.random_seed = seed
_, training_input, test_input, _ = ad_hoc_data(training_size=4,
test_size=2,
n=n_dim,
gap=0.3,
plot_data=False)
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = n_dim
optimizer = L_BFGS_B(maxfun=30)
feature_map = SecondOrderExpansion(feature_dimension=num_qubits,
depth=2)
var_form = RYRZ(num_qubits=num_qubits, depth=1)
# convert to circuit if circuits should be used
if use_circuits:
x = ParameterVector('x', feature_map.feature_dimension)
feature_map = feature_map.construct_circuit(x)
theta = ParameterVector('theta', var_form.num_parameters)
var_form = var_form.construct_circuit(theta)
# set up algorithm
vqc = VQC(optimizer,
feature_map,
var_form,
training_input,
test_input,
minibatch_size=2)
# sort parameters for reproducibility
if use_circuits:
vqc._feature_map_params = list(x)
vqc._var_form_params = list(theta)
quantum_instance = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
result = vqc.run(quantum_instance)
vqc_accuracy = 0.5
self.log.debug(result['testing_accuracy'])
self.assertAlmostEqual(result['testing_accuracy'],
vqc_accuracy,
places=3)
def get_solver(self, transformation):
num_orbitals = transformation.molecule_info['num_orbitals']
num_particles = transformation.molecule_info['num_particles']
qubit_mapping = transformation.qubit_mapping
two_qubit_reduction = transformation.molecule_info['two_qubit_reduction']
z2_symmetries = transformation.molecule_info['z2_symmetries']
initial_state = HartreeFock(num_orbitals, num_particles, qubit_mapping,
two_qubit_reduction, z2_symmetries.sq_list)
var_form = UCCSD(num_orbitals=num_orbitals,
num_particles=num_particles,
initial_state=initial_state,
qubit_mapping=qubit_mapping,
two_qubit_reduction=two_qubit_reduction,
z2_symmetries=z2_symmetries)
vqe = VQE(var_form=var_form, quantum_instance=self._quantum_instance,
optimizer=L_BFGS_B())
return vqe
def test_vqe_qasm_snapshot_mode(self):
""" VQE Aer qasm_simulator snapshot mode 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
backend = Aer.get_backend('qasm_simulator')
num_qubits = self.algo_input.qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = RY(num_qubits, 3, initial_state=init_state)
optimizer = L_BFGS_B()
algo = VQE(self.algo_input.qubit_op, var_form, optimizer, max_evals_grouped=1)
quantum_instance = QuantumInstance(backend, shots=1)
result = algo.run(quantum_instance)
self.assertAlmostEqual(result['energy'], -1.85727503, places=6)
def test_vqe(self, var_form_type):
""" VQE test """
var_form = RYRZ(self.qubit_op.num_qubits)
if var_form_type is QuantumCircuit:
params = ParameterVector('θ', var_form.num_parameters)
var_form = var_form.construct_circuit(params)
vqe = VQE(self.qubit_op, var_form, L_BFGS_B())
result = vqe.run(QuantumInstance(BasicAer.get_backend('statevector_simulator'),
basis_gates=['u1', 'u2', 'u3', 'cx', 'id'],
coupling_map=[[0, 1]],
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
self.assertAlmostEqual(result.eigenvalue.real, -1.85727503)
np.testing.assert_array_almost_equal(result.eigenvalue.real, -1.85727503, 5)
self.assertEqual(len(result.optimal_point), 16)
self.assertIsNotNone(result.cost_function_evals)
self.assertIsNotNone(result.optimizer_time)
def test_vqc_minibatching_with_gradient_support(self, mode):
""" vqc minibatching with gradient support test """
n_dim = 2 # dimension of each data point
seed = 1024
aqua_globals.random_seed = seed
_, training_input, test_input, _ = ad_hoc_data(training_size=4,
test_size=2,
n=n_dim,
gap=0.3,
plot_data=False)
backend = BasicAer.get_backend('statevector_simulator')
optimizer = L_BFGS_B(maxfun=30)
# set up data encoding circuit
data_preparation = self.data_preparation[mode]
# set up wavefunction
if mode == 'wrapped':
warnings.filterwarnings('ignore', category=DeprecationWarning)
wavefunction = RYRZ(2, depth=1)
else:
wavefunction = TwoLocal(2, ['ry', 'rz'],
'cz',
reps=1,
insert_barriers=True)
if mode == 'circuit':
wavefunction = QuantumCircuit(2).compose(wavefunction)
# set up algorithm
vqc = VQC(optimizer,
data_preparation,
wavefunction,
training_input,
test_input,
minibatch_size=2)
if mode == 'wrapped':
warnings.filterwarnings('always', category=DeprecationWarning)
quantum_instance = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
result = vqc.run(quantum_instance)
self.assertGreater(result['testing_accuracy'], 0.2)