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 }