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