def test_matrix_psd(self):
""" Test kernel matrix positive semi-definite enforcement. """
try:
from cvxpy.error import DQCPError
except ImportError:
self.skipTest('cvxpy does not appeat to be installed')
seed = 10598
feature_dim = 2
_, training_input, _, _ = ad_hoc_data(
training_size=10,
test_size=5,
n=feature_dim,
gap=0.3
)
training_input, _ = split_dataset_to_data_and_labels(training_input)
training_data = training_input[0]
training_labels = training_input[1]
labels = training_labels * 2 - 1 # map label from 0 --> -1 and 1 --> 1
labels = labels.astype(float)
feature_map = ZZFeatureMap(feature_dimension=feature_dim, reps=2, entanglement='linear')
try:
with self.assertRaises(DQCPError):
# Sampling noise means that the kernel matrix will not quite be positive
# semi-definite which will cause the optimize svm to fail
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=seed,
seed_transpiler=seed)
kernel_matrix = QSVM.get_kernel_matrix(quantum_instance, feature_map=feature_map,
x1_vec=training_data, enforce_psd=False)
_ = optimize_svm(kernel_matrix, labels, lambda2=0)
except MissingOptionalLibraryError as ex:
self.skipTest(str(ex))
return
# This time we enforce that the matrix be positive semi-definite which runs logic to
# make it so.
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=seed,
seed_transpiler=seed)
kernel_matrix = QSVM.get_kernel_matrix(quantum_instance, feature_map=feature_map,
x1_vec=training_data, enforce_psd=True)
alpha, b, support = optimize_svm(kernel_matrix, labels, lambda2=0)
expected_alpha = [0.855861781, 2.59807482, 0, 0.962959215,
1.08141696, 0.217172547, 0, 0,
0.786462904, 0, 0.969727949, 1.98066946,
0, 0, 1.62049430, 0,
0.394212728, 0, 0.507740935, 1.02910286]
expected_b = [-0.17543365]
expected_support = [True, True, False, True, True, True, False, False, True, False,
True, True, False, False, True, False, True, False, True, True]
np.testing.assert_array_almost_equal(alpha, expected_alpha)
np.testing.assert_array_almost_equal(b, expected_b)
np.testing.assert_array_equal(support, expected_support)
def train(self, data, labels):
"""
train the svm
Args:
data (dict): dictionary which maps each class to the points in the class
class_labels (list): list of classes. For example: ['A', 'B']
"""
labels = labels.astype(np.float)
labels = labels * 2. - 1.
kernel_matrix = self.construct_kernel_matrix(data, data, self.gamma)
self._ret['kernel_matrix_training'] = kernel_matrix
[alpha, b, support] = optimize_svm(kernel_matrix, labels)
alphas = np.array([])
svms = np.array([])
yin = np.array([])
for alphindex in range(len(support)):
if support[alphindex]:
alphas = np.vstack([alphas, alpha[alphindex]
]) if alphas.size else alpha[alphindex]
svms = np.vstack([svms, data[alphindex]
]) if svms.size else data[alphindex]
yin = np.vstack([yin, labels[alphindex]
]) if yin.size else labels[alphindex]
self._ret['svm'] = {}
self._ret['svm']['alphas'] = alphas
self._ret['svm']['bias'] = b
self._ret['svm']['support_vectors'] = svms
self._ret['svm']['yin'] = yin
def train(self, data, labels):
"""
Train the svm.
Args:
data (numpy.ndarray): NxD array, where N is the number of data,
D is the feature dimension.
labels (numpy.ndarray): Nx1 array, where N is the number of data
"""
scaling = 1.0 if self._qalgo.quantum_instance.is_statevector else None
kernel_matrix = self._qalgo.construct_kernel_matrix(data)
labels = labels * 2 - 1 # map label from 0 --> -1 and 1 --> 1
labels = labels.astype(np.float)
[alpha, b, support] = optimize_svm(kernel_matrix,
labels,
scaling=scaling)
support_index = np.where(support)
alphas = alpha[support_index]
svms = data[support_index]
yin = labels[support_index]
self._ret['kernel_matrix_training'] = kernel_matrix
self._ret['svm'] = {}
self._ret['svm']['alphas'] = alphas
self._ret['svm']['bias'] = b
self._ret['svm']['support_vectors'] = svms
self._ret['svm']['yin'] = yin
