def init_params(cls, params, algo_input):
algo_params = params.get(QuantumAlgorithm.SECTION_KEY_ALGORITHM)
override_spsa_params = algo_params.get('override_SPSA_params')
batch_mode = algo_params.get('batch_mode')
minibatch_size = algo_params.get('minibatch_size')
# Set up optimizer
opt_params = params.get(QuantumAlgorithm.SECTION_KEY_OPTIMIZER)
# If SPSA then override SPSA params as reqd to our predetermined values
if opt_params['name'] == 'SPSA' and override_spsa_params:
opt_params['c0'] = 4.0
opt_params['c1'] = 0.1
opt_params['c2'] = 0.602
opt_params['c3'] = 0.101
opt_params['c4'] = 0.0
opt_params['skip_calibration'] = True
optimizer = get_pluggable_class(PluggableType.OPTIMIZER,
opt_params['name']).init_params(opt_params)
# Set up feature map
fea_map_params = params.get(QuantumAlgorithm.SECTION_KEY_FEATURE_MAP)
num_qubits = get_feature_dimension(algo_input.training_dataset)
fea_map_params['num_qubits'] = num_qubits
feature_map = get_pluggable_class(PluggableType.FEATURE_MAP,
fea_map_params['name']).init_params(fea_map_params)
# Set up variational form
var_form_params = params.get(QuantumAlgorithm.SECTION_KEY_VAR_FORM)
var_form_params['num_qubits'] = num_qubits
var_form = get_pluggable_class(PluggableType.VARIATIONAL_FORM,
var_form_params['name']).init_params(var_form_params)
return cls(optimizer, feature_map, var_form, algo_input.training_dataset,
algo_input.test_dataset, algo_input.datapoints, batch_mode,
minibatch_size)
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]])
svm = QSVM(feature_map, training_input, test_input, total_array,
multiclass_extension=ErrorCorrectingCode(_QSVM_Estimator,
[feature_map], 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'])
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_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_qsvm_multiclass_all_pairs(self, use_circuits):
""" QSVM Multiclass All Pairs 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]])
if use_circuits:
x = ParameterVector('x', feature_map.feature_dimension)
feature_map = feature_map.construct_circuit(x)
feature_map.ordered_parameters = list(x)
try:
svm = QSVM(feature_map, training_input, test_input, total_array,
multiclass_extension=AllPairs())
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_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 init_params(cls, params, algo_input):
""" init params """
algo_params = params.get(Pluggable.SECTION_KEY_ALGORITHM)
override_spsa_params = algo_params.get('override_SPSA_params')
max_evals_grouped = algo_params.get('max_evals_grouped')
minibatch_size = algo_params.get('minibatch_size')
# Set up optimizer
opt_params = params.get(Pluggable.SECTION_KEY_OPTIMIZER)
# If SPSA then override SPSA params as reqd to our predetermined values
if opt_params['name'] == 'SPSA' and override_spsa_params:
opt_params['c0'] = 4.0
opt_params['c1'] = 0.1
opt_params['c2'] = 0.602
opt_params['c3'] = 0.101
opt_params['c4'] = 0.0
opt_params['skip_calibration'] = True
optimizer = get_pluggable_class(PluggableType.OPTIMIZER,
opt_params['name']).init_params(params)
# Set up feature map
fea_map_params = params.get(Pluggable.SECTION_KEY_FEATURE_MAP)
feature_dimension = get_feature_dimension(algo_input.training_dataset)
fea_map_params['feature_dimension'] = feature_dimension
feature_map = get_pluggable_class(
PluggableType.FEATURE_MAP,
fea_map_params['name']).init_params(params)
# Set up variational form, we need to add computed num qubits
# Pass all parameters so that Variational Form can create its dependents
var_form_params = params.get(Pluggable.SECTION_KEY_VAR_FORM)
var_form_params['num_qubits'] = feature_map.num_qubits
var_form = get_pluggable_class(
PluggableType.VARIATIONAL_FORM,
var_form_params['name']).init_params(params)
return cls(optimizer, feature_map, var_form,
algo_input.training_dataset, algo_input.test_dataset,
algo_input.datapoints, max_evals_grouped, minibatch_size)
def test_vqc_statevector(self, use_circuits):
""" 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)
# 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(
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)
from qiskit.aqua.utils import get_feature_dimension
feature_dim = 4 # dimension of each data point
training_dataset_size = 20
testing_dataset_size = 10
random_seed = 10598
aqua_globals.random_seed = random_seed
sample_Total, training_input, test_input, class_labels = wine(
training_size=training_dataset_size,
test_size=testing_dataset_size,
n=feature_dim,
plot_data=False)
feature_map = RawFeatureVector(
feature_dimension=get_feature_dimension(training_input))
vqc = VQC(COBYLA(maxiter=200), 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'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
print("VQC accuracy with RawFeatureVector: ", result['testing_accuracy'])
feature_map = ZZFeatureMap(get_feature_dimension(training_input))
vqc = VQC(COBYLA(maxiter=200), 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'),
