def test_callback(self):
"""Test the callback function of the VQC."""
history = {'eval_count': [], 'parameters': [], 'cost': [], 'batch_index': []}
def store_intermediate_result(eval_count, parameters, cost, batch_index):
history['eval_count'].append(eval_count)
history['parameters'].append(parameters)
history['cost'].append(cost)
history['batch_index'].append(batch_index)
optimizer = COBYLA(maxiter=3)
data_preparation = self.data_preparation
wavefunction = self.ryrz_wavefunction
# set up algorithm
vqc = VQC(optimizer, data_preparation, wavefunction, self.training_data, self.testing_data,
callback=store_intermediate_result)
vqc.run(self.qasm_simulator)
with self.subTest('eval count'):
self.assertTrue(all(isinstance(count, int) for count in history['eval_count']))
with self.subTest('cost'):
self.assertTrue(all(isinstance(cost, float) for cost in history['cost']))
with self.subTest('batch index'):
self.assertTrue(all(isinstance(index, int) for index in history['batch_index']))
for params in history['parameters']:
with self.subTest('params'):
self.assertTrue(all(isinstance(param, float) for param in params))
def test_vqc_callback(self, mode):
""" vqc callback test """
history = {
'eval_count': [],
'parameters': [],
'cost': [],
'batch_index': []
}
def store_intermediate_result(eval_count, parameters, cost,
batch_index):
history['eval_count'].append(eval_count)
history['parameters'].append(parameters)
history['cost'].append(cost)
history['batch_index'].append(batch_index)
aqua_globals.random_seed = self.seed
backend = BasicAer.get_backend('qasm_simulator')
optimizer = COBYLA(maxiter=3)
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,
callback=store_intermediate_result)
if mode == 'wrapped':
warnings.filterwarnings('always', category=DeprecationWarning)
quantum_instance = QuantumInstance(backend,
shots=1024,
seed_simulator=self.seed,
seed_transpiler=self.seed)
vqc.run(quantum_instance)
with self.subTest('eval count'):
self.assertTrue(
all(isinstance(count, int) for count in history['eval_count']))
with self.subTest('cost'):
self.assertTrue(
all(isinstance(cost, float) for cost in history['cost']))
with self.subTest('batch index'):
self.assertTrue(
all(
isinstance(index, int)
for index in history['batch_index']))
for params in history['parameters']:
with self.subTest('params'):
self.assertTrue(
all(isinstance(param, float) for param in params))
def test_vqc_callback(self, use_circuits):
""" vqc callback test """
history = {
'eval_count': [],
'parameters': [],
'cost': [],
'batch_index': []
}
def store_intermediate_result(eval_count, parameters, cost,
batch_index):
history['eval_count'].append(eval_count)
history['parameters'].append(parameters)
history['cost'].append(cost)
history['batch_index'].append(batch_index)
aqua_globals.random_seed = self.seed
backend = BasicAer.get_backend('qasm_simulator')
num_qubits = 2
optimizer = COBYLA(maxiter=3)
feature_map = SecondOrderExpansion(feature_dimension=num_qubits,
depth=2)
var_form = RY(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)
vqc = VQC(optimizer,
feature_map,
var_form,
self.training_data,
self.testing_data,
callback=store_intermediate_result)
quantum_instance = QuantumInstance(backend,
shots=1024,
seed_simulator=self.seed,
seed_transpiler=self.seed)
vqc.run(quantum_instance)
self.assertTrue(
all(isinstance(count, int) for count in history['eval_count']))
self.assertTrue(
all(isinstance(cost, float) for cost in history['cost']))
self.assertTrue(
all(isinstance(index, int) for index in history['batch_index']))
for params in history['parameters']:
self.assertTrue(all(isinstance(param, float) for param in params))
def test_vqc_callback(self):
""" vqc callback test """
tmp_filename = 'qvqc_callback_test.csv'
is_file_exist = os.path.exists(self._get_resource_path(tmp_filename))
if is_file_exist:
os.remove(self._get_resource_path(tmp_filename))
def store_intermediate_result(eval_count, parameters, cost, batch_index):
with open(self._get_resource_path(tmp_filename), 'a') as file:
content = "{},{},{:.5f},{}".format(eval_count, parameters, cost, batch_index)
print(content, file=file, flush=True)
np.random.seed(self.random_seed)
aqua_globals.random_seed = self.random_seed
backend = BasicAer.get_backend('qasm_simulator')
num_qubits = 2
optimizer = COBYLA(maxiter=3)
feature_map = SecondOrderExpansion(feature_dimension=num_qubits, depth=2)
var_form = RY(num_qubits=num_qubits, depth=1)
vqc = VQC(optimizer, feature_map, var_form, self.training_data,
self.testing_data, callback=store_intermediate_result)
quantum_instance = QuantumInstance(backend,
shots=1024,
seed_simulator=self.random_seed,
seed_transpiler=self.random_seed)
vqc.run(quantum_instance)
is_file_exist = os.path.exists(self._get_resource_path(tmp_filename))
self.assertTrue(is_file_exist, "Does not store content successfully.")
# check the content
ref_content = [
['0', '[-0.58205563 -2.97987177 -0.73153057 1.06577518]', '0.46841', '0'],
['1', '[ 0.41794437 -2.97987177 -0.73153057 1.06577518]', '0.31861', '1'],
['2', '[ 0.41794437 -1.97987177 -0.73153057 1.06577518]', '0.45975', '2'],
]
try:
with open(self._get_resource_path(tmp_filename)) as file:
idx = 0
for record in file.readlines():
eval_count, parameters, cost, batch_index = record.split(",")
self.assertEqual(eval_count.strip(), ref_content[idx][0])
self.assertEqual(parameters, ref_content[idx][1])
self.assertEqual(cost.strip(), ref_content[idx][2])
self.assertEqual(batch_index.strip(), ref_content[idx][3])
idx += 1
finally:
if is_file_exist:
os.remove(self._get_resource_path(tmp_filename))
def test_vqc_minibatching_no_gradient_support(self):
""" vqc minibatching with no 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=6,
test_size=3,
n=n_dim,
gap=0.3,
plot_data=False)
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = n_dim
optimizer = COBYLA(maxiter=40)
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,
training_input,
test_input,
minibatch_size=2)
quantum_instance = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed,
optimization_level=0)
result = vqc.run(quantum_instance)
self.log.debug(result['testing_accuracy'])
self.assertGreaterEqual(result['testing_accuracy'], 0.5)
def test_vqc_minibatching_no_gradient_support(self):
""" vqc minibatching with no gradient support test """
n_dim = 2 # dimension of each data point
seed = 1024
np.random.seed(seed)
_, training_input, test_input, _ = _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 = COBYLA()
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,
training_input,
test_input,
minibatch_size=2)
quantum_instance = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
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_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_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_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_vqc_statevector(self, mode):
""" vqc statevector test """
aqua_globals.random_seed = 10598
optimizer = COBYLA()
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 in ['circuit', 'library']:
vqc._feature_map_params = self._sorted_data_params
vqc._var_form_params = self._sorted_wavefunction_params
else:
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)
ref_train_loss = 0.1059404
np.testing.assert_array_almost_equal(result['training_loss'],
ref_train_loss,
decimal=4)
self.assertEqual(result['testing_accuracy'], 0.5)
def test_raw_feature_vector_on_wine(self, mode):
"""Test VQE on the wine dataset using the ``RawFeatureVector`` as data preparation."""
feature_dim = 4 # dimension of each data point
training_dataset_size = 8
testing_dataset_size = 4
_, training_input, test_input, _ = wine(
training_size=training_dataset_size,
test_size=testing_dataset_size,
n=feature_dim,
plot_data=False)
if mode == 'component':
warnings.filterwarnings('ignore', category=DeprecationWarning)
feature_map = LegacyRawFeatureVector(feature_dimension=feature_dim)
else:
feature_map = RawFeatureVector(feature_dimension=feature_dim)
vqc = VQC(COBYLA(maxiter=100), feature_map,
TwoLocal(feature_map.num_qubits, ['ry', 'rz'], 'cz', reps=3),
training_input, test_input)
result = vqc.run(self.statevector_simulator)
if mode == 'component':
warnings.filterwarnings('always', category=DeprecationWarning)
self.log.debug(result['testing_accuracy'])
self.assertGreater(result['testing_accuracy'], 0.7)
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_vqc_with_raw_feature_vector_on_wine(self):
""" vqc with raw features vector on wine test """
feature_dim = 4 # dimension of each data point
training_dataset_size = 8
testing_dataset_size = 4
_, training_input, test_input, _ = _wine_data(
training_size=training_dataset_size,
test_size=testing_dataset_size,
n=feature_dim
)
aqua_globals.random_seed = self.seed
feature_map = RawFeatureVector(feature_dimension=feature_dim)
vqc = VQC(COBYLA(maxiter=100),
feature_map,
RYRZ(feature_map.num_qubits, depth=3),
training_input,
test_input)
result = vqc.run(QuantumInstance(BasicAer.get_backend('statevector_simulator'),
shots=1024,
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
self.log.debug(result['testing_accuracy'])
self.assertGreater(result['testing_accuracy'], 0.8)
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_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_vqc_minibatching_no_gradient_support(self, mode):
""" vqc minibatching with no 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=6,
test_size=3,
n=n_dim,
gap=0.3,
plot_data=False)
backend = BasicAer.get_backend('statevector_simulator')
optimizer = COBYLA(maxiter=40)
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,
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,
optimization_level=0)
result = vqc.run(quantum_instance)
self.assertGreaterEqual(result['testing_accuracy'], 0.5)
def test_save_and_load_model(self):
"""Test saving and loading a model with the VQC."""
data_preparation = self.data_preparation
wavefunction = self.ryrz_wavefunction
vqc = VQC(self.spsa, data_preparation, wavefunction,
self.training_data, self.testing_data)
result = vqc.run(self.qasm_simulator)
with self.subTest(
msg='check optimal params, training loss and testing accuracy'
):
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(0.5, result['testing_accuracy'])
file_path = self.get_resource_path('vqc_test.npz')
vqc.save_model(file_path)
with self.subTest(msg='assert saved file exists'):
self.assertTrue(os.path.exists(file_path))
loaded_vqc = VQC(self.spsa, data_preparation, wavefunction,
self.training_data, None)
loaded_vqc.load_model(file_path)
loaded_test_acc = loaded_vqc.test(vqc.test_dataset[0],
vqc.test_dataset[1],
self.qasm_simulator)
with self.subTest(
msg=
'check optimal parameters and testing accuracy of loaded model'
):
np.testing.assert_array_almost_equal(loaded_vqc.ret['opt_params'],
self.ref_opt_params,
decimal=4)
self.assertEqual(result['testing_accuracy'], loaded_test_acc)
predicted_probs, predicted_labels = loaded_vqc.predict(
self.testing_data['A'], self.qasm_simulator)
with self.subTest(msg='check probs and labels of predicted labels'):
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 os.path.exists(file_path):
try:
os.remove(file_path)
except Exception: # pylint: disable=broad-except
pass
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_vqc_on_wine(self, mode):
"""Test VQE on the wine test using circuits as feature map and variational form."""
feature_dim = 4 # dimension of each data point
training_dataset_size = 6
testing_dataset_size = 3
_, training_input, test_input, _ = wine(
training_size=training_dataset_size,
test_size=testing_dataset_size,
n=feature_dim,
plot_data=False)
aqua_globals.random_seed = self.seed
if mode == 'wrapped':
warnings.filterwarnings('ignore', category=DeprecationWarning)
data_preparation = SecondOrderExpansion(feature_dim)
wavefunction = RYRZ(feature_dim, depth=1)
else:
data_preparation = ZZFeatureMap(feature_dim)
x = data_preparation.ordered_parameters
wavefunction = TwoLocal(feature_dim, ['ry', 'rz'],
'cz',
reps=1,
insert_barriers=True)
theta = ParameterVector('theta', wavefunction.num_parameters)
resorted = []
for i in range(2 * feature_dim):
layer = wavefunction.ordered_parameters[2 * feature_dim * i:2 *
feature_dim * (i + 1)]
resorted += layer[::2]
resorted += layer[1::2]
wavefunction.assign_parameters(dict(zip(resorted, theta)),
inplace=True)
if mode == 'circuit':
data_preparation = QuantumCircuit(feature_dim).compose(
data_preparation)
wavefunction = QuantumCircuit(feature_dim).compose(wavefunction)
vqc = VQC(COBYLA(maxiter=100), data_preparation, wavefunction,
training_input, test_input)
# sort parameters for reproducibility
if mode in ['circuit', 'library']:
vqc._feature_map_params = list(x)
vqc._var_form_params = list(theta)
else:
warnings.filterwarnings('always', category=DeprecationWarning)
result = vqc.run(
QuantumInstance(BasicAer.get_backend('statevector_simulator'),
shots=1024,
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
self.log.debug(result['testing_accuracy'])
self.assertLess(result['testing_accuracy'], 0.6)
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_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_vqc_with_max_evals_grouped(self, use_circuits):
""" 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)
# 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,
self.training_data,
self.testing_data,
max_evals_grouped=2)
# sort parameters for reproducibility
if use_circuits:
vqc._feature_map_params = list(x)
vqc._var_form_params = list(theta)
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_usage_in_vqc(self):
"""Test using the circuit the a single VQC iteration works."""
feature_dim = 4
_, training_input, test_input, _ = wine(training_size=1,
test_size=1,
n=feature_dim,
plot_data=False)
feature_map = RawFeatureVector(feature_dimension=feature_dim)
vqc = VQC(COBYLA(maxiter=1), feature_map,
EfficientSU2(feature_map.num_qubits, reps=1), training_input,
test_input)
backend = Aer.get_backend('qasm_simulator')
result = vqc.run(backend)
self.assertTrue(result['eval_count'] > 0)
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 test_minibatching_gradient_free(self):
"""Test the minibatching option with a gradient-free optimizer."""
n_dim = 2 # dimension of each data point
_, training_input, test_input, _ = ad_hoc_data(training_size=6,
test_size=3,
n=n_dim,
gap=0.3,
plot_data=False)
optimizer = COBYLA(maxiter=40)
data_preparation = self.data_preparation
wavefunction = self.ryrz_wavefunction
vqc = VQC(optimizer, data_preparation, wavefunction, training_input, test_input,
minibatch_size=2)
result = vqc.run(self.qasm_simulator)
self.log.debug(result['testing_accuracy'])
self.assertAlmostEqual(result['testing_accuracy'], 0.3333333333333333)
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)
def test_vqc_with_max_evals_grouped(self, mode):
""" 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)
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,
max_evals_grouped=2)
if mode == 'wrapped':
warnings.filterwarnings('always', category=DeprecationWarning)
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)
with self.subTest('opt params'):
np.testing.assert_array_almost_equal(result['opt_params'],
self.ref_opt_params[mode],
decimal=8)
with self.subTest('training loss'):
np.testing.assert_array_almost_equal(result['training_loss'],
self.ref_train_loss[mode],
decimal=8)
with self.subTest('accuracy'):
self.assertEqual(1.0 if mode == 'wrapped' else 0.5,
result['testing_accuracy'])
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:])
# --- Exact copy of sample code ----------------------------------------
from qiskit import BasicAer
from qiskit.aqua import QuantumInstance, aqua_globals
from qiskit.aqua.algorithms import VQC
from qiskit.aqua.components.optimizers import COBYLA
from qiskit.aqua.components.feature_maps import RawFeatureVector
from qiskit.ml.datasets import wine
from qiskit.circuit.library import TwoLocal
seed = 1376
aqua_globals.random_seed = seed
# Use Wine data set for training and test data
feature_dim = 4 # dimension of each data point
_, training_input, test_input, _ = wine(training_size=12,
test_size=4,
n=feature_dim)
feature_map = RawFeatureVector(feature_dimension=feature_dim)
vqc = VQC(COBYLA(maxiter=100), feature_map,
TwoLocal(feature_map.num_qubits, ['ry', 'rz'], 'cz', reps=3),
training_input, test_input)
result = vqc.run(
QuantumInstance(BasicAer.get_backend('statevector_simulator'),
shots=1024,
seed_simulator=seed,
seed_transpiler=seed))
print('Testing accuracy: {:0.2f}'.format(result['testing_accuracy']))
# ----------------------------------------------------------------------
self.assertGreater(result['testing_accuracy'], 0.8)
def test_wine(self):
"""Test VQE on the wine dataset."""
feature_dim = 4 # dimension of each data point
training_dataset_size = 6
testing_dataset_size = 3
_, training_input, test_input, _ = wine(training_size=training_dataset_size,
test_size=testing_dataset_size,
n=feature_dim,
plot_data=False)
aqua_globals.random_seed = self.seed
data_preparation = ZZFeatureMap(feature_dim)
wavefunction = TwoLocal(feature_dim, ['ry', 'rz'], 'cz', reps=2)
vqc = VQC(COBYLA(maxiter=100), data_preparation, wavefunction, training_input, test_input)
result = vqc.run(self.statevector_simulator)
self.log.debug(result['testing_accuracy'])
self.assertGreater(result['testing_accuracy'], 0.3)
def test_vqc(self, mode):
""" vqc 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)
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 in ['circuit', 'library']:
vqc._feature_map_params = self._sorted_data_params
vqc._var_form_params = self._sorted_wavefunction_params
else:
warnings.filterwarnings('always', category=DeprecationWarning)
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'])
