def callback_collector(step, model_params, loss, _):
# Save the temp model
temp_model_filename = os.path.join(model_directory,
f'step{step+1}.npz')
np.savez(temp_model_filename, opt_params=model_params)
# Load the temp model
# vqc_val = VQC(optimizer, feature_map, var_form, training_input, test_input, quantum_instance=quantum_instance)
if vqc_gen is None:
vqc_val = VQC(optimizer,
feature_map,
var_form,
training_input,
test_input,
quantum_instance=quantum_instance)
else:
vqc_val = vqc_gen(optimizer,
feature_map,
var_form,
training_input,
test_input,
quantum_instance=quantum_instance)
vqc_val.load_model(temp_model_filename)
# Collect training loss and accuracy
training_loss_list.append(loss)
y_train_pred = vqc_val.predict(X_train)[1]
training_acc_list.append(np.mean(y_train_pred == y_train))
training_f1_list.append(f1_score(y_train, y_train_pred))
# Collect validation loss and accuracy
y_test_prob, y_test_pred = vqc_val.predict(X_test)
val_loss = -np.mean(y_test * np.log(y_test_prob[:, 1]) +
(1 - y_test) * np.log(y_test_prob[:, 0]))
validation_loss_list.append(val_loss)
validation_acc_list.append(np.mean(y_test_pred == y_test))
validation_f1_list.append(f1_score(y_test, y_test_pred))
def callback_collector(step, model_params, loss, _, *args):
# Save the temp model
temp_model_filename = os.path.join(model_directory, f'step{step}.npz')
np.savez(temp_model_filename, opt_params=model_params)
if step % 20 != 0:
return
# Load the temp model
# vqc_val = VQC(optimizer, feature_map, var_form, training_input, test_input, quantum_instance=quantum_instance)
if vqc_gen is None:
vqc_val = VQC(optimizer,
feature_map,
var_form,
training_input,
test_input,
quantum_instance=quantum_instance)
else:
vqc_val = vqc_gen(optimizer,
feature_map,
var_form,
training_input,
test_input,
quantum_instance=quantum_instance)
vqc_val.load_model(temp_model_filename)
# Collect training loss and accuracy
y_train_prob, y_train_pred = vqc_val.predict(X_train)
train_loss = -np.mean(y_train * np.log(y_train_prob[:, 1]) +
(1 - y_train) * np.log(y_train_prob[:, 0]))
training_loss_list.append(train_loss)
training_acc_list.append(np.mean(y_train_pred == y_train))
training_f1_list.append(f1_score(y_train, y_train_pred))
# Collect validation loss and accuracy
y_test_prob, y_test_pred = vqc_val.predict(X_test)
val_loss = -np.mean(y_test * np.log(y_test_prob[:, 1]) +
(1 - y_test) * np.log(y_test_prob[:, 0]))
validation_loss_list.append(val_loss)
validation_acc_list.append(np.mean(y_test_pred == y_test))
validation_f1_list.append(f1_score(y_test, y_test_pred))
mid_result = {
'Training losses': train_loss,
'Training accuracies': np.mean(y_train_pred == y_train),
'Training F1 scores': f1_score(y_train, y_train_pred),
'Validation losses': val_loss,
'Test accuracies': np.mean(y_test_pred == y_test),
'Test F1 scores': f1_score(y_test, y_test_pred),
}
with open(os.path.join(result_directory, f'step_{step}'), 'wb') as f:
pickle.dump(mid_result, f)
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_save_and_load_model(self, mode):
""" save and load model test """
aqua_globals.random_seed = self.seed
backend = BasicAer.get_backend('qasm_simulator')
optimizer = SPSA(max_trials=10,
save_steps=1,
c0=4.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)
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[mode],
decimal=4)
np.testing.assert_array_almost_equal(result['training_loss'],
self.ref_train_loss[mode],
decimal=8)
self.assertEqual(1.0 if mode == 'wrapped' else 0.5,
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, data_preparation, wavefunction,
self.training_data, None)
if mode == 'wrapped':
warnings.filterwarnings('always', category=DeprecationWarning)
loaded_vqc.load_model(file_path)
np.testing.assert_array_almost_equal(loaded_vqc.ret['opt_params'],
self.ref_opt_params[mode],
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[mode],
decimal=8)
np.testing.assert_array_equal(predicted_labels,
self.ref_prediction_a_label[mode])
if os.path.exists(file_path):
try:
os.remove(file_path)
except Exception: # pylint: disable=broad-except
pass
training_size=training_dataset_size,
test_size=testing_dataset_size,
n=feature_dim,
gap=0.3,
plot_data=True)
datapoints, class_to_label = split_dataset_to_data_and_labels(test_input)
print(class_to_label)
backend = BasicAer.get_backend('qasm_simulator')
optimizer = SPSA(max_trials=100, c0=4.0, skip_calibration=True)
optimizer.set_options(save_steps=1)
feature_map = ZZFeatureMap(feature_dimension=feature_dim, reps=2)
var_form = TwoLocal(feature_dim, ['ry', 'rz'], 'cz', reps=3)
vqc = VQC(optimizer, feature_map, var_form, training_input, test_input)
quantum_instance = QuantumInstance(backend,
shots=shots,
seed_simulator=random_seed,
seed_transpiler=random_seed)
result = vqc.run(quantum_instance)
print("testing success ratio: ", result['testing_accuracy'])
predicted_probs, predicted_labels = vqc.predict(datapoints[0])
predicted_classes = map_label_to_class_name(predicted_labels,
vqc.label_to_class)
print("prediction: {}".format(predicted_labels))
# testing success ratio: 1.0
# sumber = https://github.com/qiskit-community/qiskit-community-tutorials/blob/master/machine_learning/vqc.ipynb
feature_map = qc # + tmp1 + tmp2
else:
raise NameError("Unknown feature map.")
qsvm = VQC(OPTIMIZER(ITER), feature_map, var_form, training_input)
if BACKEND == "simulator":
backend = BasicAer.get_backend('qasm_simulator')
elif BACKEND == "real":
provider = IBMQ.get_provider()
backend = provider.get_backend('ibmq_london')
else:
raise NameError("Plz choose simulator/real")
quantum_instance = QuantumInstance(backend,
shots=1024,
seed_simulator=seed,
seed_transpiler=seed,
optimization_level=3)
result = qsvm.run(quantum_instance)
y_pred = qsvm.predict(df_train_q)[1]
print("Final train acc: %f\nFinal train F1:%f" %
(np.mean(y_pred == y_train), f1_score(y_pred, y_train)))
y_pred = qsvm.predict(df_test_q)[1]
print(y_pred)
record_test_result_for_kaggle(y_pred,
submission_file="quantum_submission.csv")
optimizer = COBYLA(maxiter=niter, disp=True)
feature_map = FEATMAPExpansion(feature_dimension=feature_dim, depth=uin_depth)
var_form = RYRZ(num_qubits=feature_dim, depth=uvar_depth)
vqc = VQC(optimizer, feature_map, var_form, training_input, test_input)
quantum_instance = QuantumInstance(simulator, shots=shots, seed_simulator=random_seed, seed_transpiler=random_seed, skip_qobj_validation=True)
result = vqc.run(quantum_instance)
counts = vqc.get_optimal_vector()
print("Counts (w/o noise) =",counts)
plot = plot_histogram(counts, title='Bit counts (w/o noise)')
plot.savefig('BitCounts_sim_'+backend_name+'_'+str(feature_dim)+'d_'+str(training_size*2)+'evt_iter'+str(niter)+'_FMAPuin-depth'+str(uin_depth)+'_uvar-depth'+str(uvar_depth)+'_'+option+'.pdf')
plot.clf()
predicted_probs, predicted_labels = vqc.predict(datapoints[0])
predicted_classes = map_label_to_class_name(predicted_labels, vqc.label_to_class)
n_sig = np.sum(datapoints[1]==1)
n_bg = np.sum(datapoints[1]==0)
n_sig_match = np.sum(datapoints[1]+predicted_labels==2)
n_bg_match = np.sum(datapoints[1]+predicted_labels==0)
print(" --- Testing success ratio: ",result['testing_accuracy'],"(w/o noise)")
print(" --- Signal eff =",n_sig_match/n_sig, ", Background eff =",(n_bg-n_bg_match)/n_bg, " (w/o noise)")
from sklearn.metrics import roc_curve, auc, roc_auc_score
prob_test_signal = predicted_probs[:,1]
fpr, tpr, thresholds = roc_curve(datapoints[1], prob_test_signal, drop_intermediate=False)
roc_auc = auc(fpr, tpr)
neg_label = np.argwhere(y_train == 0).reshape([-1])
chosen_neg_label_idx = neg_label[np.random.permutation(len(neg_label))[:neg_sample]]
print("Postive sample num: %d" % len(pos_label))
print("Negative sample num: %d" % len(neg_label))
# Construct dict to feed QSVM
training_input = {
0: df_train_q[y_train == 0],
1: np.concatenate([df_train_q[y_train == 1], df_train_q[y_train == 1]], axis=1)
}
test_input = {
0: df_test_q[y_test == 0],
1: df_test_q[y_test == 1]
}
###### data prepared
print("data prepared.")
###### building quantum dude
seed = 10598
# seed = 1024
var_form = variational_forms.RYRZ(2)
feature_map = ZZFeatureMap(feature_dimension=len(mvp_col), reps=2, entanglement='linear')
qsvm = VQC(ADAM(100), feature_map, var_form, training_input)
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=seed, seed_transpiler=seed, optimization_level=3)
result = qsvm.run(quantum_instance)
y_pred = qsvm.predict(df_test_q)[1]
print("Test acc: %f\nTest F1:%f" % (np.mean(y_pred == y_test), f1_score(y_test, y_pred)))
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 grade(test_data,
test_labels,
feature_map,
variational_form,
optimal_params,
find_circuit_cost=True,
verbose=True):
seed = 10598
model_accuracy = None
circuit_cost = None
ans = None
unrolled_circuit = None
result_msg = ''
data_dim = np.array(test_data).shape[1]
dataset_size = np.array(test_data).shape[0]
dummy_training_dataset = training_input = {
'A': np.ones((2, data_dim)),
'B': np.ones((2, data_dim))
}
# converting 4's to 0's and 9's to 1's for checking
test_labels_transformed = np.where(test_labels == 4, 0., 1.)
max_qubit_count = 6
max_circuit_cost = 2000
# Section 1
if feature_map is None:
result_msg += 'feature_map variable is None. Please submit a valid entry' if verbose else ''
elif variational_form is None:
result_msg += 'variational_form variable is None. Please submit a valid entry' if verbose else ''
elif optimal_params is None:
result_msg += 'optimal_params variable is None. Please submit a valid entry' if verbose else ''
elif test_data is None:
result_msg += 'test_data variable is None. Please submit a valid entry' if verbose else ''
elif test_labels is None:
result_msg += 'test_labels variable is None. Please submit a valid entry' if verbose else ''
elif not isinstance(feature_map, (QuantumCircuit, FeatureMap)):
result_msg += 'feature_map variable should be a QuantumCircuit or a FeatureMap not (%s)' % type(
feature_map) if verbose else ''
elif not isinstance(variational_form, (QuantumCircuit, VariationalForm)):
result_msg += 'variational_form variable should be a QuantumCircuit or a VariationalForm not (%s)' % type(
variational_form) if verbose else ''
elif not isinstance(test_data, np.ndarray):
result_msg += 'test_data variable should be a numpy.ndarray not (%s)' % type(
test_data) if verbose else ''
elif not isinstance(test_labels, np.ndarray):
result_msg += 'test_labels variable should be a numpy.ndarray not (%s)' % type(
test_labels) if verbose else ''
elif not isinstance(optimal_params, np.ndarray):
result_msg += 'optimal_params variable should be a numpy.ndarray not (%s)' % type(
optimal_params) if verbose else ''
elif not dataset_size == test_labels_transformed.shape[0]:
result_msg += 'Dataset size and label array size must be equal'
# Section 2
else:
# setting up COBYLA optimizer as a dummy optimizer
from qiskit.aqua.components.optimizers import COBYLA
dummy_optimizer = COBYLA()
# setting up the backend and creating a quantum instance
backend = Aer.get_backend('qasm_simulator')
backend_options = {"method": "statevector"}
quantum_instance = QuantumInstance(backend,
shots=2000,
seed_simulator=seed,
seed_transpiler=seed,
backend_options=backend_options)
# creating a VQC instance and running the VQC.predict method to get the accuracy of the model
vqc = VQC(optimizer=dummy_optimizer,
feature_map=feature_map,
var_form=variational_form,
training_dataset=dummy_training_dataset)
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import Unroller
pass_ = Unroller(['u3', 'cx'])
pm = PassManager(pass_)
# construct circuit with first datapoint
circuit = vqc.construct_circuit(data[0], optimal_params)
unrolled_circuit = pm.run(circuit)
gates = unrolled_circuit.count_ops()
if 'u3' in gates:
circuit_cost = gates['u3']
if 'cx' in gates:
circuit_cost += 10 * gates['cx']
if circuit.num_qubits > max_qubit_count:
result_msg += 'Your quantum circuit is using more than 6 qubits. Reduce the number of qubits used and try again.'
elif circuit_cost > max_circuit_cost:
result_msg += 'The cost of your circuit is exceeding the maximum accpetable cost of 2000. Reduce the circuit cost and try again.'
else:
ans = vqc.predict(test_data,
quantum_instance=quantum_instance,
params=np.array(optimal_params))
model_accuracy = np.sum(np.equal(test_labels_transformed,
ans[1])) / len(ans[1])
result_msg += 'Accuracy of the model is {}'.format(
model_accuracy) if verbose else ''
result_msg += ' and circuit cost is {}'.format(
circuit_cost) if verbose else ''
return model_accuracy, circuit_cost, ans, result_msg, unrolled_circuit