def test_x_more_dim(self): """ Test incorrect x_vec dimension """ qkclass = QuantumKernel(feature_map=self.feature_map, quantum_instance=self.qasm_simulator) with self.assertRaises(ValueError): _ = qkclass.evaluate(x_vec=self.sample_more_dim)
def test_constructor(self): """Tests properties of PegasosQSVC""" with self.subTest("Default parameters"): pegasos_qsvc = PegasosQSVC() self.assertIsInstance(pegasos_qsvc.quantum_kernel, QuantumKernel) self.assertFalse(pegasos_qsvc.precomputed) self.assertEqual(pegasos_qsvc.num_steps, 1000) with self.subTest("PegasosQSVC with QuantumKernel"): qkernel = QuantumKernel( feature_map=self.feature_map, quantum_instance=self.statevector_simulator) pegasos_qsvc = PegasosQSVC(quantum_kernel=qkernel) self.assertIsInstance(pegasos_qsvc.quantum_kernel, QuantumKernel) self.assertFalse(pegasos_qsvc.precomputed) with self.subTest("PegasosQSVC with precomputed kernel"): pegasos_qsvc = PegasosQSVC(precomputed=True) self.assertIsNone(pegasos_qsvc.quantum_kernel) self.assertTrue(pegasos_qsvc.precomputed) with self.subTest("PegasosQSVC with wrong parameters"): qkernel = QuantumKernel( feature_map=self.feature_map, quantum_instance=self.statevector_simulator) with self.assertRaises(ValueError): _ = PegasosQSVC(quantum_kernel=qkernel, precomputed=True) with self.subTest("PegasosQSVC with wrong type of kernel"): with self.assertRaises(TypeError): _ = PegasosQSVC(quantum_kernel=object())
def test_statevector(self): """Test state vector simulator""" qkclass = QuantumKernel(feature_map=self.feature_map) qc = qkclass.construct_circuit(self.x, is_statevector_sim=True) self.assertEqual(qc.num_qubits, self.feature_map.num_qubits) # check that there's a feature map in the circuit self.assertTrue(qc.data[0][0].name.startswith(self.feature_map.name))
def test_sv_symmetric(self): """ Test symmetric matrix evaluation using state vector simulator """ qkclass = QuantumKernel(feature_map=self.feature_map, quantum_instance=self.statevector_simulator) kernel = qkclass.evaluate(x_vec=self.sample_train) np.testing.assert_allclose(kernel, self.ref_kernel_train['statevector'], rtol=1e-4)
def test_x_one_dim(self): """ Test one x_vec dimension """ qkclass = QuantumKernel(feature_map=self.feature_map, quantum_instance=self.statevector_simulator) kernel = qkclass.evaluate(x_vec=self.sample_train[0]) np.testing.assert_allclose(kernel, self.ref_kernel_train['one_dim'], rtol=1e-4)
def test_qasm_psd(self): """ Test symmetric matrix positive semi-definite enforcement qasm sample """ qkclass = QuantumKernel(feature_map=self.feature_map, quantum_instance=self.qasm_sample) kernel = qkclass.evaluate(x_vec=self.sample_train) np.testing.assert_allclose(kernel, self.ref_kernel_train['qasm_sample_psd'], rtol=1e-4)
def test_qasm_unsymmetric(self): """ Test unsymmetric matrix evaluation using qasm simulator """ qkclass = QuantumKernel(feature_map=self.feature_map, quantum_instance=self.qasm_simulator) kernel = qkclass.evaluate(x_vec=self.sample_train, y_vec=self.sample_test) np.testing.assert_allclose(kernel, self.ref_kernel_test['qasm'], rtol=1e-4)
def test_precomputed(self): """ Test precomputed kernel in sklearn """ kernel = QuantumKernel(feature_map=self.feature_map, quantum_instance=self.statevector_simulator) kernel_train = kernel.evaluate(x_vec=self.sample_train) kernel_test = kernel.evaluate(x_vec=self.sample_test, y_vec=self.sample_train) svc = SVC(kernel='precomputed') svc.fit(kernel_train, self.label_train) score = svc.score(kernel_test, self.label_test) self.assertEqual(score, 0.5)
def test_empty_kernel(self): """Test PegasosQSVC with empty QuantumKernel""" qkernel = QuantumKernel() pegasos_qsvc = PegasosQSVC(quantum_kernel=qkernel) with self.assertRaises(QiskitMachineLearningError): pegasos_qsvc.fit(self.sample_train, self.label_train)
def test_empty_kernel(self): """ Test QSVR with empty QuantumKernel """ qkernel = QuantumKernel() qsvr = QSVR(quantum_kernel=qkernel) with self.assertRaises(QiskitMachineLearningError): _ = qsvr.fit(self.sample_train, self.label_train)
def setUp(self): super().setUp() algorithm_globals.random_seed = 10598 self.optimizer = COBYLA(maxiter=25) # pylint: disable=no-member self.backend = qiskit.providers.aer.AerSimulator(method="statevector") data_block = ZZFeatureMap(2) trainable_block = ZZFeatureMap(2) training_parameters = trainable_block.parameters for i, _ in enumerate(training_parameters): training_parameters[i]._name = f"θ[{i}]" self.feature_map = data_block.compose(trainable_block).compose( data_block) self.training_parameters = training_parameters self.sample_train = np.asarray([ [3.07876080, 1.75929189], [6.03185789, 5.27787566], [6.22035345, 2.70176968], [0.18849556, 2.82743339], ]) self.label_train = np.asarray([0, 0, 1, 1]) self.sample_test = np.asarray([[2.199114860, 5.15221195], [0.50265482, 0.06283185]]) self.label_test = np.asarray([1, 0]) self.quantum_kernel = QuantumKernel( feature_map=self.feature_map, training_parameters=self.training_parameters, quantum_instance=self.backend, )
def test_qsvc(self): """ Test QSVC """ qkernel = QuantumKernel(feature_map=self.feature_map, quantum_instance=self.statevector_simulator) qsvc = QSVC(quantum_kernel=qkernel) qsvc.fit(self.sample_train, self.label_train) score = qsvc.score(self.sample_test, self.label_test) self.assertEqual(score, 0.5)
def test_qsvc_parameters(self): """ Test QSVC with extra constructor parameters """ qkernel = QuantumKernel(feature_map=self.feature_map, quantum_instance=self.statevector_simulator) qsvc = QSVC(quantum_kernel=qkernel, tol=1e-4, C=0.5) qsvc.fit(self.sample_train, self.label_train) score = qsvc.score(self.sample_test, self.label_test) self.assertEqual(score, 0.5)
def test_qsvr(self): """ Test QSVR """ qkernel = QuantumKernel(feature_map=self.feature_map, quantum_instance=self.statevector_simulator) qsvr = QSVR(quantum_kernel=qkernel) qsvr.fit(self.sample_train, self.label_train) score = qsvr.score(self.sample_test, self.label_test) self.assertAlmostEqual(score, 0.38365, places=4)
def test_callable(self): """ Test callable kernel in sklearn """ kernel = QuantumKernel(feature_map=self.feature_map, quantum_instance=self.statevector_simulator) svc = SVC(kernel=kernel.evaluate) svc.fit(self.sample_train, self.label_train) score = svc.score(self.sample_test, self.label_test) self.assertEqual(score, 0.5)
def test_change_kernel(self): """Test QSVC with QuantumKernel later""" qkernel = QuantumKernel(feature_map=self.feature_map, quantum_instance=self.statevector_simulator) pegasos_qsvc = PegasosQSVC(C=1000, num_steps=self.tau) pegasos_qsvc.quantum_kernel = qkernel pegasos_qsvc.fit(self.sample_train, self.label_train) score = pegasos_qsvc.score(self.sample_test, self.label_test) self.assertEqual(score, 1)
def test_precomputed_kernel(self): """Test PegasosQSVC with a precomputed kernel matrix""" qkernel = QuantumKernel(feature_map=self.feature_map, quantum_instance=self.statevector_simulator) pegasos_qsvc = PegasosQSVC(C=1000, num_steps=self.tau, precomputed=True) # training kernel_matrix_train = qkernel.evaluate(self.sample_train, self.sample_train) pegasos_qsvc.fit(kernel_matrix_train, self.label_train) # testing kernel_matrix_test = qkernel.evaluate(self.sample_test, self.sample_train) score = pegasos_qsvc.score(kernel_matrix_test, self.label_test) self.assertEqual(score, 1.0)
def test_qsvc_4d(self): """Test PegasosQSVC with 4-dimensional input data""" qkernel = QuantumKernel(feature_map=self.feature_map_4d, quantum_instance=self.statevector_simulator) pegasos_qsvc = PegasosQSVC(quantum_kernel=qkernel, C=1000, num_steps=self.tau) pegasos_qsvc.fit(self.sample_train_4d, self.label_train_4d) score = pegasos_qsvc.score(self.sample_test_4d, self.label_test_4d) self.assertEqual(score, 1.0)
def test_wrong_parameters(self): """Tests PegasosQSVC with incorrect constructor parameter values.""" qkernel = QuantumKernel(feature_map=self.feature_map, quantum_instance=self.statevector_simulator) with self.subTest("Both kernel and precomputed are passed"): self.assertRaises(ValueError, PegasosQSVC, quantum_kernel=qkernel, precomputed=True) with self.subTest("Incorrect quantum kernel value is passed"): self.assertRaises(TypeError, PegasosQSVC, quantum_kernel=1)
def test_decision_function(self): """Test PegasosQSVC.""" qkernel = QuantumKernel(feature_map=self.feature_map, quantum_instance=self.statevector_simulator) pegasos_qsvc = PegasosQSVC(quantum_kernel=qkernel, C=1000, num_steps=self.tau) pegasos_qsvc.fit(self.sample_train, self.label_train) decision_function = pegasos_qsvc.decision_function(self.sample_test) self.assertTrue( np.all((decision_function > 0) == (self.label_test == 0)))
def test_positional_user_parameters(self): """Test assigning user parameters with positional argument""" with self.subTest("check positional argument"): # Ensure we can instantiate a QuantumKernel with positional user parameters qkclass = QuantumKernel( self.feature_map, True, 900, None, self.user_parameters, ) with warnings.catch_warnings(): warnings.simplefilter("ignore") self.assertEqual(qkclass.user_parameters, self.user_parameters)
def test_statevector_batching(self): """Test batching when using the statevector simulator""" self.circuit_counts = [] kernel = QuantumKernel( feature_map=self.feature_map, batch_size=self.batch_size, quantum_instance=self.statevector_simulator, ) svc = SVC(kernel=kernel.evaluate) svc.fit(self.sample_train, self.label_train) for circuit_count in self.circuit_counts: self.assertLessEqual(circuit_count, self.batch_size) self.assertEqual(sum(self.circuit_counts), len(self.sample_train))
def test_labels(self): """Test PegasosQSVC with different integer labels than {0, 1}""" qkernel = QuantumKernel(feature_map=self.feature_map, quantum_instance=self.statevector_simulator) pegasos_qsvc = PegasosQSVC(quantum_kernel=qkernel, C=1000, num_steps=self.tau) label_train_temp = self.label_train.copy() label_train_temp[self.label_train == 0] = 2 label_train_temp[self.label_train == 1] = 3 label_test_temp = self.label_test.copy() label_test_temp[self.label_test == 0] = 2 label_test_temp[self.label_test == 1] = 3 pegasos_qsvc.fit(self.sample_train, label_train_temp) score = pegasos_qsvc.score(self.sample_test, label_test_temp) self.assertEqual(score, 1.0)
def test_qasm_batching(self): """Test batching when using the QASM simulator""" self.circuit_counts = [] kernel = QuantumKernel( feature_map=self.feature_map, batch_size=self.batch_size, quantum_instance=self.qasm_simulator, ) svc = SVC(kernel=kernel.evaluate) svc.fit(self.sample_train, self.label_train) for circuit_count in self.circuit_counts: self.assertLessEqual(circuit_count, self.batch_size) num_train = len(self.sample_train) num_circuits = num_train * (num_train - 1) / 2 self.assertEqual(sum(self.circuit_counts), num_circuits)
def test_custom_pass_manager(self, backend): """Test quantum kernel with a custom pass manager.""" quantum_instance = QuantumInstance( backend, shots=100, seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed, pass_manager=level_1_pass_manager( PassManagerConfig(basis_gates=["u3", "cx"])), bound_pass_manager=level_1_pass_manager( PassManagerConfig(basis_gates=["u3", "cx"])), ) kernel = QuantumKernel(feature_map=self.feature_map, quantum_instance=quantum_instance) svc = SVC(kernel=kernel.evaluate) svc.fit(self.sample_train, self.label_train) score = svc.score(self.sample_test, self.label_test) self.assertEqual(score, 0.5)
def test_save_load(self): """Tests save and load models.""" features = np.array([[0, 0], [0.1, 0.2], [1, 1], [0.9, 0.8]]) labels = np.array([0, 0, 1, 1]) qkernel = QuantumKernel(feature_map=self.feature_map, quantum_instance=self.statevector_simulator) regressor = PegasosQSVC(quantum_kernel=qkernel, C=1000, num_steps=self.tau) regressor.fit(features, labels) # predicted labels from the newly trained model test_features = np.array([[0.5, 0.5]]) original_predicts = regressor.predict(test_features) # save/load, change the quantum instance and check if predicted values are the same file_name = os.path.join(tempfile.gettempdir(), "pegasos.model") regressor.save(file_name) try: regressor_load = PegasosQSVC.load(file_name) loaded_model_predicts = regressor_load.predict(test_features) np.testing.assert_array_almost_equal(original_predicts, loaded_model_predicts) # test loading warning class FakeModel(SerializableModelMixin): """Fake model class for test purposes.""" pass with self.assertRaises(TypeError): FakeModel.load(file_name) finally: os.remove(file_name)
def test_ydim(self): """ Test incorrect y dimension """ qkclass = QuantumKernel(feature_map=self.feature_map) with self.assertRaises(ValueError): _ = qkclass.construct_circuit(self.x, self.z)
def test_user_parameters(self): """Test assigning/re-assigning user parameters""" with self.subTest("check basic instantiation"): # Ensure we can instantiate a QuantumKernel with user parameters qkclass = QuantumKernel(feature_map=self.feature_map, training_parameters=self.user_parameters) with warnings.catch_warnings(): warnings.simplefilter("ignore") self.assertEqual(qkclass.user_parameters, self.user_parameters) with self.subTest("test invalid parameter assignment"): # Instantiate a QuantumKernel qkclass = QuantumKernel(feature_map=self.feature_map, training_parameters=self.user_parameters) # Try to set the user parameters using an incorrect number of values user_param_values = [2.0, 4.0, 6.0, 8.0] with warnings.catch_warnings(): warnings.simplefilter("ignore") with self.assertRaises(ValueError): qkclass.assign_user_parameters(user_param_values) self.assertEqual(qkclass.get_unbound_user_parameters(), qkclass.user_parameters) with self.subTest("test parameter assignment"): # Assign params to some new values, and also test the bind_user_parameters interface param_binds = { self.user_parameters[0]: 0.1, self.user_parameters[1]: 0.2, self.user_parameters[2]: 0.3, } with warnings.catch_warnings(): warnings.simplefilter("ignore") qkclass.bind_user_parameters(param_binds) # Ensure the values are properly bound self.assertEqual(list(qkclass.user_param_binds.values()), list(param_binds.values())) self.assertEqual(qkclass.get_unbound_user_parameters(), []) self.assertEqual(list(qkclass.user_param_binds.keys()), qkclass.user_parameters) with self.subTest("test partial parameter assignment"): # Assign params to some new values, and also test the bind_user_parameters interface param_binds = { self.user_parameters[0]: 0.5, self.user_parameters[1]: 0.4 } with warnings.catch_warnings(): warnings.simplefilter("ignore") qkclass.bind_user_parameters(param_binds) # Ensure values were properly bound and param 2 was unchanged self.assertEqual(list(qkclass.user_param_binds.values()), [0.5, 0.4, 0.3]) self.assertEqual(qkclass.get_unbound_user_parameters(), []) self.assertEqual(list(qkclass.user_param_binds.keys()), qkclass.user_parameters) with self.subTest("test unassign and assign to parameter expression"): param_binds = { self.user_parameters[0]: self.user_parameters[0], self.user_parameters[1]: self.user_parameters[0] + self.user_parameters[2], self.user_parameters[2]: self.user_parameters[2], } qkclass.assign_user_parameters(param_binds) # Ensure quantum kernel forgets unused param 1 and unbinds param 0 and 2 self.assertEqual( list(qkclass.user_param_binds.keys()), [self.user_parameters[0], self.user_parameters[2]], ) self.assertEqual( list(qkclass.user_param_binds.keys()), list(qkclass.user_param_binds.values()), ) self.assertEqual(list(qkclass.user_param_binds.keys()), qkclass.user_parameters) with self.subTest( "test immediate reassignment to parameter expression"): # Create a new quantum kernel qkclass = QuantumKernel(feature_map=self.feature_map, training_parameters=self.user_parameters) # Create a new parameter new_param = Parameter("0[n]") # Create partial param binds with immediate reassignments to param expressions param_binds = { self.user_parameters[0]: new_param, self.user_parameters[1]: self.user_parameters[0] + self.user_parameters[2], } qkclass.assign_user_parameters(param_binds) self.assertEqual( list(qkclass.user_param_binds.keys()), [new_param, self.user_parameters[0], self.user_parameters[2]], ) self.assertEqual( list(qkclass.user_param_binds.keys()), list(qkclass.user_param_binds.values()), ) self.assertEqual(list(qkclass.user_param_binds.keys()), qkclass.user_parameters) with self.subTest("test bringing back old parameters"): param_binds = { new_param: self.user_parameters[1] * self.user_parameters[0] + self.user_parameters[2] } qkclass.assign_user_parameters(param_binds) self.assertEqual( list(qkclass.user_param_binds.keys()), [ self.user_parameters[0], self.user_parameters[1], self.user_parameters[2], ], ) self.assertEqual( list(qkclass.user_param_binds.keys()), list(qkclass.user_param_binds.values()), ) self.assertEqual(list(qkclass.user_param_binds.keys()), qkclass.user_parameters) with self.subTest("test assign with immediate reassign"): # Create a new quantum kernel qkclass = QuantumKernel(feature_map=self.feature_map, training_parameters=self.user_parameters) param_binds = { self.user_parameters[0]: 0.9, self.user_parameters[1]: self.user_parameters[0], self.user_parameters[2]: self.user_parameters[1], } qkclass.assign_user_parameters(param_binds) self.assertEqual( list(qkclass.user_param_binds.keys()), [self.user_parameters[0], self.user_parameters[1]], ) self.assertEqual(list(qkclass.user_param_binds.values()), [0.9, self.user_parameters[1]]) self.assertEqual(list(qkclass.user_param_binds.keys()), qkclass.user_parameters) with self.subTest("test unordered assigns"): # Create a new quantum kernel qkclass = QuantumKernel(feature_map=self.feature_map, training_parameters=self.user_parameters) param_binds = { self.user_parameters[2]: self.user_parameters[1], self.user_parameters[1]: self.user_parameters[0], self.user_parameters[0]: 1.7, } qkclass.assign_user_parameters(param_binds) self.assertEqual(list(qkclass.user_param_binds.keys()), [self.user_parameters[0]]) self.assertEqual(list(qkclass.user_param_binds.values()), [1.7]) self.assertEqual(list(qkclass.user_param_binds.keys()), qkclass.user_parameters)
def test_selfinnerprodect_nomeasurement(self): """ Test self inner product no measurement """ qkclass = QuantumKernel(feature_map=self.feature_map) qc = qkclass.construct_circuit(self.x, measurement=False) self.assertEqual(qc.decompose().size(), 14)
def test_statevector(self): """ Test state vector simulator """ qkclass = QuantumKernel(feature_map=self.feature_map) qc = qkclass.construct_circuit(self.x, is_statevector_sim=True) self.assertEqual(qc.decompose().size(), 7)