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)
