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_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_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_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_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)
Пример #7
0
    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_no_backend(self):
        """ Test no backend provided """
        qkclass = QuantumKernel(feature_map=self.feature_map)

        with self.assertRaises(QiskitMachineLearningError):
            _ = qkclass.evaluate(x_vec=self.sample_train)