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)