def test_vqc_statevector(self):
""" vqc statevector test """
aqua_globals.random_seed = 10598
optimizer = COBYLA()
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)
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_qsvm_binary_directly(self):
ref_kernel_training = np.array([[1., 0.85366667, 0.12341667, 0.36408333],
[0.85366667, 1., 0.11141667, 0.45491667],
[0.12341667, 0.11141667, 1., 0.667],
[0.36408333, 0.45491667, 0.667, 1.]])
ref_kernel_testing = np.array([[0.14316667, 0.18208333, 0.4785, 0.14441667],
[0.33608333, 0.3765, 0.02316667, 0.15858333]])
# ref_alpha = np.array([0.36064489, 1.49204209, 0.0264953, 1.82619169])
ref_alpha = np.array([0.34903335, 1.48325498, 0.03074852, 1.80153981])
# ref_bias = np.array([-0.03380763])
ref_bias = np.array([-0.03059226])
ref_support_vectors = np.array([[2.95309709, 2.51327412], [3.14159265, 4.08407045],
[4.08407045, 2.26194671], [4.46106157, 2.38761042]])
aqua_globals.random_seed = self.random_seed
backend = BasicAer.get_backend('qasm_simulator')
num_qubits = 2
feature_map = SecondOrderExpansion(feature_dimension=num_qubits, depth=2, entangler_map=[[0, 1]])
svm = QSVM(feature_map, self.training_data, self.testing_data, None)
quantum_instance = QuantumInstance(backend, shots=self.shots, seed=self.random_seed,
seed_transpiler=self.random_seed)
result = svm.run(quantum_instance)
np.testing.assert_array_almost_equal(
result['kernel_matrix_training'], ref_kernel_training, decimal=1)
np.testing.assert_array_almost_equal(
result['kernel_matrix_testing'], ref_kernel_testing, decimal=1)
self.assertEqual(len(result['svm']['support_vectors']), 4)
np.testing.assert_array_almost_equal(
result['svm']['support_vectors'], ref_support_vectors, decimal=4)
np.testing.assert_array_almost_equal(result['svm']['alphas'], ref_alpha, decimal=8)
np.testing.assert_array_almost_equal(result['svm']['bias'], ref_bias, decimal=8)
self.assertEqual(result['testing_accuracy'], 0.5)
def test_deprecated_components(self):
"""Test running the VQC on FeatureMap and VariationalForm objects."""
ref_opt_params = np.array([
3.76378585, -8.48815464, 11.78685004, -9.96768202, 2.65749365,
-4.25581973, -9.37524845, -4.41052704, -0.44151694, 15.19155236,
-9.35234735, -6.07004197, -0.03613872, 3.41111794, -1.0030384,
-4.14612403
])
ref_train_loss = 0.99014958
# ignore warnings from creating VariationalForm and FeatureMap objects
warnings.filterwarnings('ignore', category=DeprecationWarning)
data_preparation = SecondOrderExpansion(2, depth=2)
wavefunction = RYRZ(2)
vqc = VQC(self.spsa, data_preparation, wavefunction,
self.training_data, self.testing_data)
warnings.filterwarnings('always', category=DeprecationWarning)
self.assertSimpleClassificationIsCorrect(vqc,
ref_opt_params=ref_opt_params,
ref_train_loss=ref_train_loss,
ref_test_accuracy=1)
def test_qsvm_setup_data(self):
""" QSVM Setup Data test """
ref_kernel_testing = np.array(
[[0.1443953, 0.18170069, 0.47479649, 0.14691763],
[0.33041779, 0.37663733, 0.02115561, 0.16106199]])
ref_support_vectors = np.array([[2.95309709, 2.51327412],
[3.14159265, 4.08407045],
[4.08407045, 2.26194671],
[4.46106157, 2.38761042]])
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = 2
feature_map = SecondOrderExpansion(feature_dimension=num_qubits,
depth=2,
entangler_map=[[0, 1]])
try:
svm = QSVM(feature_map)
svm.setup_training_data(self.training_data)
svm.setup_test_data(self.testing_data)
quantum_instance = QuantumInstance(
backend,
seed_transpiler=self.random_seed,
seed_simulator=self.random_seed)
result = svm.run(quantum_instance)
np.testing.assert_array_almost_equal(
result['kernel_matrix_testing'], ref_kernel_testing, decimal=4)
self.assertEqual(len(result['svm']['support_vectors']), 4)
np.testing.assert_array_almost_equal(
result['svm']['support_vectors'],
ref_support_vectors,
decimal=4)
self.assertEqual(result['testing_accuracy'], 0.5)
except NameError as ex:
self.skipTest(str(ex))
def test_qsvm_kernel_binary_directly(self):
ref_kernel_training = np.array([[1., 0.85366667, 0.12341667, 0.36408333],
[0.85366667, 1., 0.11141667, 0.45491667],
[0.12341667, 0.11141667, 1., 0.667],
[0.36408333, 0.45491667, 0.667, 1.]])
ref_kernel_testing = np.array([[0.14316667, 0.18208333, 0.4785, 0.14441667],
[0.33608333, 0.3765, 0.02316667, 0.15858333]])
ref_alpha = np.array([0.36064489, 1.49204209, 0.0264953, 1.82619169])
ref_bias = np.array([-0.03380763])
ref_support_vectors = np.array([[2.95309709, 2.51327412], [3.14159265, 4.08407045],
[4.08407045, 2.26194671], [4.46106157, 2.38761042]])
backend = get_aer_backend('qasm_simulator')
num_qubits = 2
feature_map = SecondOrderExpansion(num_qubits=num_qubits, depth=2, entangler_map=[[0, 1]])
svm = QSVMKernel(feature_map, self.training_data, self.testing_data, None)
svm.random_seed = self.random_seed
run_config = RunConfig(shots=self.shots, max_credits=10, memory=False, seed=self.random_seed)
quantum_instance = QuantumInstance(backend, run_config, seed_mapper=self.random_seed)
result = svm.run(quantum_instance)
np.testing.assert_array_almost_equal(
result['kernel_matrix_training'], ref_kernel_training, decimal=1)
np.testing.assert_array_almost_equal(
result['kernel_matrix_testing'], ref_kernel_testing, decimal=1)
self.assertEqual(len(result['svm']['support_vectors']), 4)
np.testing.assert_array_almost_equal(
result['svm']['support_vectors'], ref_support_vectors, decimal=4)
np.testing.assert_array_almost_equal(result['svm']['alphas'], ref_alpha, decimal=4)
np.testing.assert_array_almost_equal(result['svm']['bias'], ref_bias, decimal=4)
self.assertEqual(result['testing_accuracy'], 0.5)
def test_vqc_on_wine(self):
""" vqc on wine test """
feature_dim = 4 # dimension of each data point
training_dataset_size = 6
testing_dataset_size = 3
_, 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 = SecondOrderExpansion(feature_dimension=feature_dim)
vqc = VQC(COBYLA(maxiter=100), feature_map,
RYRZ(feature_map.num_qubits, depth=1), 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.assertLess(result['testing_accuracy'], 0.6)
def test_qsvm_variational_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=20, test_size=10, n=n_dim, gap=0.3)
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = n_dim
optimizer = L_BFGS_B(maxfun=1000)
feature_map = SecondOrderExpansion(num_qubits=num_qubits, depth=2)
var_form = RYRZ(num_qubits=num_qubits, depth=3)
svm = QSVMVariational(optimizer,
feature_map,
var_form,
training_input,
test_input,
minibatch_size=2)
aqua_globals.random_seed = seed
quantum_instance = QuantumInstance(backend, seed=seed)
result = svm.run(quantum_instance)
svm_accuracy_threshold = 0.85
print(result['testing_accuracy'])
self.assertGreater(result['testing_accuracy'], svm_accuracy_threshold)
def setUp(self):
super().setUp()
self.random_seed = 10598
self.shots = 12000
aqua_globals.random_seed = self.random_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]])
}
num_qubits = 2
warnings.filterwarnings('ignore', category=DeprecationWarning)
# data encoding using a FeatureMap type
feature_map = SecondOrderExpansion(feature_dimension=num_qubits,
depth=2,
entangler_map=[[0, 1]])
warnings.filterwarnings('always', category=DeprecationWarning)
# data encoding using a circuit library object
library_circuit = ZZFeatureMap(feature_dimension=num_qubits, reps=2)
# data encoding using a plain QuantumCircuit
circuit = QuantumCircuit(num_qubits).compose(library_circuit)
circuit.ordered_parameters = library_circuit.ordered_parameters
self.data_preparation = {
'wrapped': feature_map,
'circuit': circuit,
'library': library_circuit
}
def test_qsvm_multiclass_error_correcting_code(self):
""" QSVM Multiclass error Correcting Code test """
training_input = {'A': np.asarray([[0.6560706, 0.17605998], [0.25776033, 0.47628296],
[0.8690704, 0.70847635]]),
'B': np.asarray([[0.38857596, -0.33775802], [0.49946978, -0.48727951],
[0.49156185, -0.3660534]]),
'C': np.asarray([[-0.68088231, 0.46824423], [-0.56167659, 0.65270294],
[-0.82139073, 0.29941512]])}
test_input = {'A': np.asarray([[0.57483139, 0.47120732], [0.48372348, 0.25438544],
[0.48142649, 0.15931707]]),
'B': np.asarray([[-0.06048935, -0.48345293], [-0.01065613, -0.33910828],
[0.06183066, -0.53376975]]),
'C': np.asarray([[-0.74561108, 0.27047295], [-0.69942965, 0.11885162],
[-0.66489165, 0.1181712]])}
total_array = np.concatenate((test_input['A'], test_input['B'], test_input['C']))
aqua_globals.random_seed = self.random_seed
feature_map = SecondOrderExpansion(feature_dimension=get_feature_dimension(training_input),
depth=2,
entangler_map=[[0, 1]])
try:
svm = QSVM(feature_map, training_input, test_input, total_array,
multiclass_extension=ErrorCorrectingCode(code_size=5))
quantum_instance = QuantumInstance(BasicAer.get_backend('qasm_simulator'),
shots=self.shots,
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
result = svm.run(quantum_instance)
self.assertAlmostEqual(result['testing_accuracy'], 0.444444444, places=4)
self.assertEqual(result['predicted_classes'], ['A', 'A', 'C', 'A',
'A', 'A', 'A', 'C', 'C'])
except NameError as ex:
self.skipTest(str(ex))
def test_vqc_callback(self):
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 f:
content = "{},{},{:.5f},{}".format(eval_count, parameters,
cost, batch_index)
print(content, file=f, 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 f:
idx = 0
for record in f.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 setUp(self):
super().setUp()
self.seed = 50
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]])
}
ref_opt_p_w = np.array([
3.76378585, -8.48815464, 11.78685004, -9.96768202, 2.65749365,
-4.25581973, -9.37524845, -4.41052704, -0.44151694, 15.19155236,
-9.35234735, -6.07004197, -0.03613872, 3.41111794, -1.0030384,
-4.14612403
])
ref_opt_p_c = np.array([
4.40301812e-01, 2.10844304e+00, -2.10118578e+00, -5.25903194e+00,
2.07617769e+00, -9.25865371e+00, -5.33834788e+00, 8.59005180e+00,
3.39886480e+00, 6.33839643e+00, 1.24425033e+00, -1.39701513e+01,
-7.16008545e-03, 3.36206032e+00, 4.38001391e+00, -3.47098082e+00
])
self.ref_opt_params = {
'wrapped': ref_opt_p_w,
'circuit': ref_opt_p_c,
'library': ref_opt_p_c
}
self.ref_train_loss = {
'wrapped': 0.99014958,
'circuit': 0.5869304,
'library': 0.5869304
}
self.ref_prediction_a_probs = {
'wrapped': [[0.58398438, 0.41601562]],
'circuit': [[0.8984375, 0.1015625]],
'library': [[0.8984375, 0.1015625]]
}
self.ref_prediction_a_label = {
'wrapped': [0],
'circuit': [0],
'library': [0]
}
# ignore warnings from creating VariationalForm and FeatureMap objects
warnings.filterwarnings('ignore', category=DeprecationWarning)
var_form_ryrz = RYRZ(2, depth=3)
feature_map = SecondOrderExpansion(2, depth=2)
warnings.filterwarnings('always', category=DeprecationWarning)
library_ryrz = TwoLocal(2, ['ry', 'rz'],
'cz',
reps=3,
insert_barriers=True)
circuit_ryrz = QuantumCircuit(2).compose(library_ryrz)
self.ryrz_wavefunction = {
'wrapped': var_form_ryrz,
'circuit': circuit_ryrz,
'library': library_ryrz
}
library_circuit = ZZFeatureMap(2, reps=2)
circuit = QuantumCircuit(2).compose(library_circuit)
self.data_preparation = {
'wrapped': feature_map,
'circuit': circuit,
'library': library_circuit
}
def test_qsvm_binary_directly_statevector(self):
""" QSVM Binary Directly Statevector test """
ref_kernel_testing = np.array(
[[0.1443953, 0.18170069, 0.47479649, 0.14691763],
[0.33041779, 0.37663733, 0.02115561, 0.16106199]])
ref_support_vectors = np.array([[2.95309709, 2.51327412],
[3.14159265, 4.08407045],
[4.08407045, 2.26194671],
[4.46106157, 2.38761042]])
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = 2
feature_map = SecondOrderExpansion(feature_dimension=num_qubits,
depth=2,
entangler_map=[[0, 1]])
svm = QSVM(feature_map, self.training_data, self.testing_data, None)
quantum_instance = QuantumInstance(backend,
seed_transpiler=self.random_seed,
seed_simulator=self.random_seed)
result = svm.run(quantum_instance)
ori_alphas = result['svm']['alphas']
np.testing.assert_array_almost_equal(result['kernel_matrix_testing'],
ref_kernel_testing,
decimal=4)
self.assertEqual(len(result['svm']['support_vectors']), 4)
np.testing.assert_array_almost_equal(result['svm']['support_vectors'],
ref_support_vectors,
decimal=4)
self.assertEqual(result['testing_accuracy'], 0.5)
file_path = self._get_resource_path('qsvm_test.npz')
svm.save_model(file_path)
self.assertTrue(os.path.exists(file_path))
loaded_svm = QSVM(feature_map)
loaded_svm.load_model(file_path)
np.testing.assert_array_almost_equal(
loaded_svm.ret['svm']['support_vectors'],
ref_support_vectors,
decimal=4)
np.testing.assert_array_almost_equal(loaded_svm.ret['svm']['alphas'],
ori_alphas,
decimal=4)
loaded_test_acc = loaded_svm.test(svm.test_dataset[0],
svm.test_dataset[1],
quantum_instance)
self.assertEqual(result['testing_accuracy'], loaded_test_acc)
np.testing.assert_array_almost_equal(
loaded_svm.ret['kernel_matrix_testing'],
ref_kernel_testing,
decimal=4)
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):
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:
pass
'qbits': 5,
'records': 10
}
if config['local']:
config['server'] = 'qasm_simulator'
else:
config['qbits'] = servers[config['server']]
data = json.load(open('data' + str(config['qbits']) + '.json', 'r'))
IBMQ.save_account(config['token'])
if config['local']:
IBMQ.load_accounts(hub=None)
feature_map = SecondOrderExpansion(feature_dimension=config['qbits'],
depth=config['depth'],
entanglement=config['entanglement'])
qsvm = QSVM(feature_map, data["train"], data["test"])
backend = BasicAer.get_backend(config['server'])
quantum_instance = QuantumInstance(backend,
shots=config['shots'],
seed_transpiler=config['seed'])
result = qsvm.run(quantum_instance)
print(result)
else:
IBMQ.load_accounts(hub=None)
feature_map = SecondOrderExpansion(feature_dimension=config['qbits'],
depth=config['depth'],
entanglement=config['entanglement'])
qsvm = QSVM(feature_map, data["train"], data["test"])
provider = IBMQ.get_provider()
}
testing_data = {
'A': np.asarray([[0.024], [0.456], [0.065], [0.044], [0.324]]),
'B': np.asarray([[1.777], [1.341], [1.514], [1.204], [1.135]])
}
IBMQ.enable_account('ENTER API KEY HERE')
provider = IBMQ.get_provider(hub='ibm-q')
backend = provider.get_backend(
'ibmq_qasm_simulator') # Specifying Quantum device
num_qubits = 1
feature_map = SecondOrderExpansion(feature_dimension=num_qubits,
depth=2,
entanglement='full')
svm = QSVM(feature_map, training_data, testing_data) # Creation of QSVM
quantum_instance = QuantumInstance(backend,
shots=shots,
skip_qobj_validation=False)
print('Running....\n')
result = svm.run(quantum_instance) # Running the QSVM and getting the accuracy
data = np.array([[1.453], [1.023], [0.135], [0.266]]) #Unlabelled data
prediction = svm.predict(data,
def test_qsvm_variational_directly(self):
np.random.seed(self.random_seed)
backend = get_aer_backend('qasm_simulator')
num_qubits = 2
optimizer = SPSA(max_trials=10,
save_steps=1,
c0=4.0,
skip_calibration=True)
feature_map = SecondOrderExpansion(num_qubits=num_qubits, depth=2)
var_form = RYRZ(num_qubits=num_qubits, depth=3)
svm = QSVMVariational(optimizer, feature_map, var_form,
self.training_data, self.testing_data)
svm.random_seed = self.random_seed
run_config = RunConfig(shots=1024,
max_credits=10,
memory=False,
seed=self.random_seed)
quantum_instance = QuantumInstance(backend,
run_config,
seed_mapper=self.random_seed)
result = svm.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(result['testing_accuracy'], 1.0)
file_path = self._get_resource_path('qsvm_variational_test.npz')
svm.save_model(file_path)
self.assertTrue(os.path.exists(file_path))
loaded_svm = QSVMVariational(optimizer, feature_map, var_form,
self.training_data, None)
loaded_svm.load_model(file_path)
np.testing.assert_array_almost_equal(loaded_svm.ret['opt_params'],
self.ref_opt_params,
decimal=4)
loaded_test_acc = loaded_svm.test(svm.test_dataset[0],
svm.test_dataset[1],
quantum_instance)
self.assertEqual(result['testing_accuracy'], loaded_test_acc)
predicted_probs, predicted_labels = loaded_svm.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 os.path.exists(file_path):
try:
os.remove(file_path)
except:
pass
from qiskit.aqua.algorithms import QSVM
from qiskit.aqua.components.multiclass_extensions import one_against_rest, all_pairs
from qiskit.aqua.components.feature_maps import SecondOrderExpansion
from qiskit.aqua.input import ClassificationInput
from qiskit.aqua import run_algorithm
backend = BasicAer.get_backend('qasm_simulator')
iris = load_iris()
X, Y = iris.data, iris.target
print(X.shape)
print(len(set(Y)))
train_x, test_x, train_y, test_y = train_test_split(X, Y, test_size=0.2)
num_features = 4
training_size = 120
test_size = 30
feature_map = SecondOrderExpansion(feature_dimension=num_features, depth=2)
X, Y = iris.data, iris.target
print(X.shape)
print(len(set(Y)))
train_x, test_x, train_y, test_y = train_test_split(X, Y, test_size=0.2)
feature_map = SecondOrderExpansion(feature_dimension=num_features, depth=2)
params = {
'problem': {
'name': 'classification'
},
'algorithm': {
'name': 'QSVM',
},
'multiclass_extension': {
#depth=2,
#entangler_map=None,
#entanglement='full',
#data_map_func=<function self_product>
#Args:
# feature_dimension (int): number of features
# depth (int): the number of repeated circuits
# entangler_map (list[list]): describe the connectivity of qubits, each list describes
# [source, target], or None for full entanglement.
# Note that the order is the list is the order of
# applying the two-qubit gate.
# entanglement (str): ['full', 'linear'], generate the qubit connectivity by predefined
# topology
# data_map_func (Callable): a mapping function for data x
feature_map = SecondOrderExpansion(feature_dimension=3,
depth=int(args.featMapDepth),
entanglement='full')
#variational form to take
# Args:
# num_qubits (int) : number of qubits
# depth (int) : number of rotation layers
# entangler_map (list[list]): describe the connectivity of qubits, each list describes
# [source, target], or None for full entanglement.
# Note that the order is the list is the order of
# applying the two-qubit gate.
# entanglement (str): 'full' or 'linear'
# initial_state (InitialState): an initial state object
# entanglement_gate (str): cz or cx
# skip_unentangled_qubits (bool): skip the qubits not in the entangler_map
var_form = RYRZ(
def test_qsvm_variational_callback(self):
tmp_filename = 'qsvm_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 f:
content = "{},{},{:.5f},{}".format(eval_count, parameters,
cost, batch_index)
print(content, file=f, flush=True)
np.random.seed(self.random_seed)
backend = BasicAer.get_backend('qasm_simulator')
num_qubits = 2
optimizer = COBYLA(maxiter=3)
feature_map = SecondOrderExpansion(num_qubits=num_qubits, depth=2)
var_form = RY(num_qubits=num_qubits, depth=1)
svm = QSVMVariational(optimizer,
feature_map,
var_form,
self.training_data,
self.testing_data,
callback=store_intermediate_result)
svm.random_seed = self.random_seed
quantum_instance = QuantumInstance(backend,
shots=1024,
seed=self.random_seed,
seed_mapper=self.random_seed)
svm.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.18863864 -1.08197582 1.74432295 1.29765602]',
'0.54802', '0'
],
[
'1', '[ 1.18863864 -1.08197582 1.74432295 1.29765602]',
'0.53862', '1'
],
[
'2', '[ 1.18863864 -0.08197582 1.74432295 1.29765602]',
'0.47278', '2'
],
]
try:
with open(self._get_resource_path(tmp_filename)) as f:
idx = 0
for record in f.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))
from qiskit.aqua.components.multiclass_extensions import AllPairs
from qiskit.aqua.utils.dataset_helper import get_feature_dimension
n = 2 # dimension of each data point
sample_Total, training_input, test_input, class_labels = wine(training_size=40,
test_size=10,
n=n,
plot_data=True)
temp = [test_input[k] for k in test_input]
total_array = np.concatenate(temp)
aqua_globals.random_seed = 10598
backend = BasicAer.get_backend('qasm_simulator')
feature_map = SecondOrderExpansion(
feature_dimension=get_feature_dimension(training_input),
depth=2,
entangler_map=[[0, 1]])
svm = QSVM(feature_map,
training_input,
test_input,
total_array,
multiclass_extension=AllPairs())
quantum_instance = QuantumInstance(backend,
shots=1024,
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
result = svm.run(quantum_instance)
for k, v in result.items():
print("'{}' : {}".format(k, v))
def test_save_and_load_model(self, use_circuits):
""" save and load model test """
aqua_globals.random_seed = self.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)
# 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)
# sort parameters for reproducibility
if use_circuits:
vqc._feature_map_params = list(x)
vqc._var_form_params = list(theta)
quantum_instance = QuantumInstance(backend,
shots=1024,
seed_simulator=self.seed,
seed_transpiler=self.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)
# sort parameters for reproducibility
if use_circuits:
loaded_vqc._feature_map_params = list(x)
loaded_vqc._var_form_params = list(theta)
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 os.path.exists(file_path):
try:
os.remove(file_path)
except Exception: # pylint: disable=broad-except
pass
def setUp(self):
super().setUp()
self.seed = 1376
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([
10.03814083, -12.22048954, -7.58026833, -2.42392954, 12.91555293,
13.44064652, -2.89951454, -10.20639406, 0.81414546, -1.00551752,
-4.7988307, 14.00831419, 8.26008064, -7.07543736, 11.43368677,
-5.74857438
])
self.ref_train_loss = 0.69366523
self.ref_prediction_a_probs = [[0.79882812, 0.20117188]]
self.ref_prediction_a_label = [0]
# ignore warnings from creating VariationalForm and FeatureMap objects
warnings.filterwarnings('ignore', category=DeprecationWarning)
var_form_ryrz = RYRZ(2, depth=3)
feature_map = SecondOrderExpansion(2, depth=2)
warnings.filterwarnings('always', category=DeprecationWarning)
library_ryrz = TwoLocal(2, ['ry', 'rz'],
'cz',
reps=3,
insert_barriers=True)
theta = ParameterVector('theta', var_form_ryrz.num_parameters)
circuit_ryrz = var_form_ryrz.construct_circuit(theta)
resorted = []
for i in range(4):
layer = library_ryrz.ordered_parameters[4 * i:4 * (i + 1)]
resorted += layer[::2]
resorted += layer[1::2]
library_ryrz.assign_parameters(dict(zip(resorted, theta)),
inplace=True)
self._sorted_wavefunction_params = list(theta)
self.ryrz_wavefunction = {
'wrapped': var_form_ryrz,
'circuit': circuit_ryrz,
'library': library_ryrz
}
library_circuit = ZZFeatureMap(2, reps=2)
x = ParameterVector('x', 2)
circuit = feature_map.construct_circuit(x)
self._sorted_data_params = list(x)
library_circuit.assign_parameters(x, inplace=True)
self.data_preparation = {
'wrapped': feature_map,
'circuit': circuit,
'library': library_circuit
}
