def test_vqc_minibatching_no_gradient_support(self, mode):
""" vqc minibatching with no gradient support test """
n_dim = 2 # dimension of each data point
seed = 1024
aqua_globals.random_seed = seed
_, training_input, test_input, _ = ad_hoc_data(training_size=6,
test_size=3,
n=n_dim,
gap=0.3,
plot_data=False)
backend = BasicAer.get_backend('statevector_simulator')
optimizer = COBYLA(maxiter=40)
data_preparation = self.data_preparation[mode]
wavefunction = self.ryrz_wavefunction[mode]
if mode == 'wrapped':
warnings.filterwarnings('ignore', category=DeprecationWarning)
# set up algorithm
vqc = VQC(optimizer,
data_preparation,
wavefunction,
training_input,
test_input,
minibatch_size=2)
if mode == 'wrapped':
warnings.filterwarnings('always', category=DeprecationWarning)
quantum_instance = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed,
optimization_level=0)
result = vqc.run(quantum_instance)
self.assertGreaterEqual(result['testing_accuracy'], 0.5)
def test_vqc_minibatching_no_gradient_support(self):
""" vqc minibatching with no gradient support test """
n_dim = 2 # dimension of each data point
seed = 1024
aqua_globals.random_seed = seed
_, training_input, test_input, _ = ad_hoc_data(training_size=6,
test_size=3,
n=n_dim,
gap=0.3,
plot_data=False)
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = n_dim
optimizer = COBYLA(maxiter=40)
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,
training_input,
test_input,
minibatch_size=2)
quantum_instance = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed,
optimization_level=0)
result = vqc.run(quantum_instance)
self.log.debug(result['testing_accuracy'])
self.assertGreaterEqual(result['testing_accuracy'], 0.5)
def test_minibatching_gradient_based(self):
"""Test the minibatching option with a gradient-based optimizer."""
n_dim = 2 # dimension of each data point
_, training_input, test_input, _ = ad_hoc_data(training_size=4,
test_size=2,
n=n_dim,
gap=0.3,
plot_data=False)
optimizer = L_BFGS_B(maxfun=30)
data_preparation = self.data_preparation
wavefunction = TwoLocal(2, ['ry', 'rz'],
'cz',
reps=1,
insert_barriers=True)
vqc = VQC(optimizer,
data_preparation,
wavefunction,
training_input,
test_input,
minibatch_size=2)
result = vqc.run(self.statevector_simulator)
self.log.debug(result['testing_accuracy'])
self.assertAlmostEqual(result['testing_accuracy'], 0.75, places=3)
def test_vqc_minibatching_with_gradient_support(self):
""" vqc minibatching with gradient support test """
n_dim = 2 # dimension of each data point
seed = 1024
aqua_globals.random_seed = seed
_, training_input, test_input, _ = ad_hoc_data(training_size=4,
test_size=2,
n=n_dim,
gap=0.3,
plot_data=False)
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = n_dim
optimizer = L_BFGS_B(maxfun=30)
feature_map = SecondOrderExpansion(feature_dimension=num_qubits,
depth=2)
var_form = RYRZ(num_qubits=num_qubits, depth=1)
vqc = VQC(optimizer,
feature_map,
var_form,
training_input,
test_input,
minibatch_size=2)
quantum_instance = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
result = vqc.run(quantum_instance)
vqc_accuracy = 0.5
self.log.debug(result['testing_accuracy'])
self.assertAlmostEqual(result['testing_accuracy'],
vqc_accuracy,
places=3)
def test_vqc_minibatching_with_gradient_support(self, mode):
""" vqc minibatching with gradient support test """
n_dim = 2 # dimension of each data point
seed = 1024
aqua_globals.random_seed = seed
_, training_input, test_input, _ = ad_hoc_data(training_size=4,
test_size=2,
n=n_dim,
gap=0.3,
plot_data=False)
backend = BasicAer.get_backend('statevector_simulator')
optimizer = L_BFGS_B(maxfun=30)
# set up data encoding circuit
data_preparation = self.data_preparation[mode]
# set up wavefunction
if mode == 'wrapped':
warnings.filterwarnings('ignore', category=DeprecationWarning)
wavefunction = RYRZ(2, depth=1)
else:
wavefunction = TwoLocal(2, ['ry', 'rz'],
'cz',
reps=1,
insert_barriers=True)
theta = ParameterVector('theta', wavefunction.num_parameters)
resorted = []
for i in range(4):
layer = wavefunction.ordered_parameters[4 * i:4 * (i + 1)]
resorted += layer[::2]
resorted += layer[1::2]
wavefunction.assign_parameters(dict(zip(resorted, theta)),
inplace=True)
if mode == 'circuit':
wavefunction = QuantumCircuit(2).compose(wavefunction)
# set up algorithm
vqc = VQC(optimizer,
data_preparation,
wavefunction,
training_input,
test_input,
minibatch_size=2)
if mode in ['circuit', 'library']:
vqc._feature_map_params = self._sorted_data_params
vqc._var_form_params = list(theta)
else:
warnings.filterwarnings('always', category=DeprecationWarning)
quantum_instance = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
result = vqc.run(quantum_instance)
vqc_accuracy = 0.5
self.log.debug(result['testing_accuracy'])
self.assertAlmostEqual(result['testing_accuracy'],
vqc_accuracy,
places=3)
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 test_ad_hoc_data(self):
"""Ad Hoc Data test."""
_, _, test_input, class_labels = ad_hoc_data(training_size=20,
test_size=10,
n=2,
gap=0.3,
plot_data=False)
np.testing.assert_array_equal(class_labels, ['A', 'B'])
datapoints, class_to_label = split_dataset_to_data_and_labels(test_input)
np.testing.assert_array_equal(datapoints[1].tolist(),
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
self.assertDictEqual(class_to_label, {'A': 0, 'B': 1})
def test_vqc_minibatching_with_gradient_support(self, use_circuits):
""" vqc minibatching with gradient support test """
n_dim = 2 # dimension of each data point
seed = 1024
aqua_globals.random_seed = seed
_, training_input, test_input, _ = ad_hoc_data(training_size=4,
test_size=2,
n=n_dim,
gap=0.3,
plot_data=False)
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = n_dim
optimizer = L_BFGS_B(maxfun=30)
feature_map = SecondOrderExpansion(feature_dimension=num_qubits,
depth=2)
var_form = RYRZ(num_qubits=num_qubits, depth=1)
# 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,
training_input,
test_input,
minibatch_size=2)
# sort parameters for reproducibility
if use_circuits:
vqc._feature_map_params = list(x)
vqc._var_form_params = list(theta)
quantum_instance = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
result = vqc.run(quantum_instance)
vqc_accuracy = 0.5
self.log.debug(result['testing_accuracy'])
self.assertAlmostEqual(result['testing_accuracy'],
vqc_accuracy,
places=3)
def test_minibatching_gradient_free(self):
"""Test the minibatching option with a gradient-free optimizer."""
n_dim = 2 # dimension of each data point
_, training_input, test_input, _ = ad_hoc_data(training_size=6,
test_size=3,
n=n_dim,
gap=0.3,
plot_data=False)
optimizer = COBYLA(maxiter=40)
data_preparation = self.data_preparation
wavefunction = self.ryrz_wavefunction
vqc = VQC(optimizer, data_preparation, wavefunction, training_input, test_input,
minibatch_size=2)
result = vqc.run(self.qasm_simulator)
self.log.debug(result['testing_accuracy'])
self.assertAlmostEqual(result['testing_accuracy'], 0.3333333333333333)
def test_vqc_minibatching_with_gradient_support(self, mode):
""" vqc minibatching with gradient support test """
n_dim = 2 # dimension of each data point
seed = 1024
aqua_globals.random_seed = seed
_, training_input, test_input, _ = ad_hoc_data(training_size=4,
test_size=2,
n=n_dim,
gap=0.3,
plot_data=False)
backend = BasicAer.get_backend('statevector_simulator')
optimizer = L_BFGS_B(maxfun=30)
# set up data encoding circuit
data_preparation = self.data_preparation[mode]
# set up wavefunction
if mode == 'wrapped':
warnings.filterwarnings('ignore', category=DeprecationWarning)
wavefunction = RYRZ(2, depth=1)
else:
wavefunction = TwoLocal(2, ['ry', 'rz'],
'cz',
reps=1,
insert_barriers=True)
if mode == 'circuit':
wavefunction = QuantumCircuit(2).compose(wavefunction)
# set up algorithm
vqc = VQC(optimizer,
data_preparation,
wavefunction,
training_input,
test_input,
minibatch_size=2)
if mode == 'wrapped':
warnings.filterwarnings('always', category=DeprecationWarning)
quantum_instance = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
result = vqc.run(quantum_instance)
self.assertGreater(result['testing_accuracy'], 0.2)
from qiskit import BasicAer
from qiskit.aqua import QuantumInstance
from qiskit.aqua.algorithms import VQC
from qiskit.aqua.components.optimizers import SPSA
from qiskit.circuit.library import TwoLocal, ZZFeatureMap
from qiskit.aqua.utils import split_dataset_to_data_and_labels, map_label_to_class_name
feature_dim = 2 # dimension of each data point
training_dataset_size = 20
testing_dataset_size = 10
random_seed = 10598
shots = 1024
sample_Total, training_input, test_input, class_labels = ad_hoc_data(
training_size=training_dataset_size,
test_size=testing_dataset_size,
n=feature_dim,
gap=0.3,
plot_data=True)
datapoints, class_to_label = split_dataset_to_data_and_labels(test_input)
print(class_to_label)
backend = BasicAer.get_backend('qasm_simulator')
optimizer = SPSA(max_trials=100, c0=4.0, skip_calibration=True)
optimizer.set_options(save_steps=1)
feature_map = ZZFeatureMap(feature_dimension=feature_dim, reps=2)
var_form = TwoLocal(feature_dim, ['ry', 'rz'], 'cz', reps=3)
vqc = VQC(optimizer, feature_map, var_form, training_input, test_input)
quantum_instance = QuantumInstance(backend,
shots=shots,
seed_simulator=random_seed,
seed_transpiler=random_seed)
# Get column names of categorical and numerical variables
cat_names = df_enc.select_dtypes(include='object').columns
num_names = df_enc.select_dtypes(include=np.number).columns
# Encode categorical variables
enc_columns = pd.get_dummies(df_cleaned[cat_names], drop_first=True)
# Concatenate encoded columns to numerical columns
df_enc = pd.concat([df_enc[num_names], enc_columns], axis=1)
feature_dim = 2
sample_total, training_input, test_input, class_labels = ad_hoc_data(
training_size=50,
test_size=10,
n=feature_dim,
gap=0.3,
# plot_data=True
plot_data=False)
extra_test_data = sample_ad_hoc_data(sample_total, 10, n=feature_dim)
datapoints, class_to_label = split_dataset_to_data_and_labels(extra_test_data)
print(class_to_label)
feature_map = ZZFeatureMap(feature_dimension=feature_dim,
reps=2,
entanglement='linear')
qsvm = QSVM(feature_map, training_input, test_input, datapoints[0])
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend,
shots=1024,
import numpy as np
import matplotlib.pyplot as plt
import functools
from qiskit import BasicAer
from qiskit.circuit.library import ZFeatureMap, ZZFeatureMap, PauliFeatureMap
from qiskit.aqua import QuantumInstance
from qiskit.aqua.components.feature_maps import self_product
from qiskit.aqua.algorithms import QSVM
from qiskit.ml.datasets import ad_hoc_data
# Generate synthetic training and test sets from the SecondOrderExpansion quantum feature map
feature_dim = 2
sample_Total, training_dataset, test_dataset, class_labels = ad_hoc_data(
training_size=20, test_size=10, n=feature_dim, gap=0.3, plot_data=False)
# Using the statevector simulator
backend = BasicAer.get_backend('statevector_simulator')
random_seed = 10598
quantum_instance = QuantumInstance(backend,
seed_simulator=random_seed,
seed_transpiler=random_seed)
# Generate the feature map
feature_map = ZFeatureMap(feature_dimension=feature_dim, reps=2)
# Run the Quantum Kernel Estimator and classify the test data
qsvm = QSVM(feature_map=feature_map,
training_dataset=training_dataset,
test_dataset=test_dataset)
