def test_raw_feature_vector_on_wine(self, mode): """Test VQE on the wine dataset using the ``RawFeatureVector`` as data preparation.""" feature_dim = 4 # dimension of each data point training_dataset_size = 8 testing_dataset_size = 4 _, training_input, test_input, _ = wine( training_size=training_dataset_size, test_size=testing_dataset_size, n=feature_dim, plot_data=False) if mode == 'component': warnings.filterwarnings('ignore', category=DeprecationWarning) feature_map = LegacyRawFeatureVector(feature_dimension=feature_dim) else: feature_map = RawFeatureVector(feature_dimension=feature_dim) vqc = VQC(COBYLA(maxiter=100), feature_map, TwoLocal(feature_map.num_qubits, ['ry', 'rz'], 'cz', reps=3), training_input, test_input) result = vqc.run(self.statevector_simulator) if mode == 'component': warnings.filterwarnings('always', category=DeprecationWarning) self.log.debug(result['testing_accuracy']) self.assertGreater(result['testing_accuracy'], 0.7)
def test_vqc_on_wine(self, mode): """Test VQE on the wine test using circuits as feature map and variational form.""" feature_dim = 4 # dimension of each data point training_dataset_size = 6 testing_dataset_size = 3 _, training_input, test_input, _ = wine( training_size=training_dataset_size, test_size=testing_dataset_size, n=feature_dim, plot_data=False) aqua_globals.random_seed = self.seed if mode == 'wrapped': warnings.filterwarnings('ignore', category=DeprecationWarning) data_preparation = SecondOrderExpansion(feature_dim) wavefunction = RYRZ(feature_dim, depth=1) else: data_preparation = ZZFeatureMap(feature_dim) x = data_preparation.ordered_parameters wavefunction = TwoLocal(feature_dim, ['ry', 'rz'], 'cz', reps=1, insert_barriers=True) theta = ParameterVector('theta', wavefunction.num_parameters) resorted = [] for i in range(2 * feature_dim): layer = wavefunction.ordered_parameters[2 * feature_dim * i:2 * feature_dim * (i + 1)] resorted += layer[::2] resorted += layer[1::2] wavefunction.assign_parameters(dict(zip(resorted, theta)), inplace=True) if mode == 'circuit': data_preparation = QuantumCircuit(feature_dim).compose( data_preparation) wavefunction = QuantumCircuit(feature_dim).compose(wavefunction) vqc = VQC(COBYLA(maxiter=100), data_preparation, wavefunction, training_input, test_input) # sort parameters for reproducibility if mode in ['circuit', 'library']: vqc._feature_map_params = list(x) vqc._var_form_params = list(theta) else: warnings.filterwarnings('always', category=DeprecationWarning) result = vqc.run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), shots=1024, seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) self.log.debug(result['testing_accuracy']) self.assertLess(result['testing_accuracy'], 0.6)
def test_usage_in_vqc(self): """Test using the circuit the a single VQC iteration works.""" feature_dim = 4 _, training_input, test_input, _ = wine(training_size=1, test_size=1, n=feature_dim, plot_data=False) feature_map = RawFeatureVector(feature_dimension=feature_dim) vqc = VQC(COBYLA(maxiter=1), feature_map, EfficientSU2(feature_map.num_qubits, reps=1), training_input, test_input) backend = Aer.get_backend('qasm_simulator') result = vqc.run(backend) self.assertTrue(result['eval_count'] > 0)
def test_readme_sample(self): """ readme sample test """ # pylint: disable=import-outside-toplevel,redefined-builtin def print(*args): """ overloads print to log values """ if args: self.log.debug(args[0], *args[1:]) # --- Exact copy of sample code ---------------------------------------- from qiskit import BasicAer from qiskit.aqua import QuantumInstance, aqua_globals from qiskit.aqua.algorithms import VQC from qiskit.aqua.components.optimizers import COBYLA from qiskit.aqua.components.feature_maps import RawFeatureVector from qiskit.ml.datasets import wine from qiskit.circuit.library import TwoLocal seed = 1376 aqua_globals.random_seed = seed # Use Wine data set for training and test data feature_dim = 4 # dimension of each data point _, training_input, test_input, _ = wine(training_size=12, test_size=4, n=feature_dim) feature_map = RawFeatureVector(feature_dimension=feature_dim) vqc = VQC(COBYLA(maxiter=100), feature_map, TwoLocal(feature_map.num_qubits, ['ry', 'rz'], 'cz', reps=3), training_input, test_input) result = vqc.run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), shots=1024, seed_simulator=seed, seed_transpiler=seed)) print('Testing accuracy: {:0.2f}'.format(result['testing_accuracy'])) # ---------------------------------------------------------------------- self.assertGreater(result['testing_accuracy'], 0.8)
def test_wine(self): """Test VQE on the wine dataset.""" feature_dim = 4 # dimension of each data point training_dataset_size = 6 testing_dataset_size = 3 _, training_input, test_input, _ = wine(training_size=training_dataset_size, test_size=testing_dataset_size, n=feature_dim, plot_data=False) aqua_globals.random_seed = self.seed data_preparation = ZZFeatureMap(feature_dim) wavefunction = TwoLocal(feature_dim, ['ry', 'rz'], 'cz', reps=2) vqc = VQC(COBYLA(maxiter=100), data_preparation, wavefunction, training_input, test_input) result = vqc.run(self.statevector_simulator) self.log.debug(result['testing_accuracy']) self.assertGreater(result['testing_accuracy'], 0.3)
def test_raw_feature_vector_on_wine(self): """Test VQE on the wine dataset using the ``RawFeatureVector`` as data preparation.""" feature_dim = 4 # dimension of each data point training_dataset_size = 8 testing_dataset_size = 4 _, training_input, test_input, _ = wine( training_size=training_dataset_size, test_size=testing_dataset_size, n=feature_dim, plot_data=False) feature_map = RawFeatureVector(feature_dimension=feature_dim) vqc = VQC(COBYLA(maxiter=100), feature_map, TwoLocal(feature_map.num_qubits, ['ry', 'rz'], 'cz', reps=3), training_input, test_input) result = vqc.run(self.statevector_simulator) self.log.debug(result['testing_accuracy']) self.assertGreater(result['testing_accuracy'], 0.8)
def test_vqc_on_wine(self, mode): """Test VQE on the wine test using circuits as feature map and variational form.""" aqua_globals.random_seed = 27521 if mode == 'wrapped' else 2752 feature_dim = 4 # dimension of each data point training_dataset_size = 6 testing_dataset_size = 3 _, training_input, test_input, _ = wine( training_size=training_dataset_size, test_size=testing_dataset_size, n=feature_dim, plot_data=False) ref_accuracy = 0.2 if mode == 'wrapped': warnings.filterwarnings('ignore', category=DeprecationWarning) data_preparation = SecondOrderExpansion(feature_dim) wavefunction = RYRZ(feature_dim, depth=1) else: data_preparation = ZZFeatureMap(feature_dim) wavefunction = TwoLocal(feature_dim, ['ry', 'rz'], 'cz', reps=1, insert_barriers=True) if mode == 'circuit': data_preparation = QuantumCircuit(feature_dim).compose( data_preparation) wavefunction = QuantumCircuit(feature_dim).compose( wavefunction) vqc = VQC(COBYLA(maxiter=100), data_preparation, wavefunction, training_input, test_input) if mode == 'wrapped': warnings.filterwarnings('always', category=DeprecationWarning) result = vqc.run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), shots=1024, seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) self.assertGreater(result['testing_accuracy'], ref_accuracy)
def test_vqc_with_raw_feature_vector_on_wine(self): """ vqc with raw features vector on wine test """ aqua_globals.random_seed = self.seed feature_dim = 4 # dimension of each data point training_dataset_size = 8 testing_dataset_size = 4 _, training_input, test_input, _ = wine( training_size=training_dataset_size, test_size=testing_dataset_size, n=feature_dim, plot_data=False) feature_map = RawFeatureVector(feature_dimension=feature_dim) vqc = VQC(COBYLA(maxiter=100), feature_map, TwoLocal(feature_map.num_qubits, ['ry', 'rz'], 'cz', reps=3), training_input, test_input) result = vqc.run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), shots=1024, seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) self.assertGreater(result['testing_accuracy'], 0.8)
def test_vqc_on_wine(self, use_circuits): """Test VQE on the wine test using circuits as feature map and variational form.""" feature_dim = 4 # dimension of each data point training_dataset_size = 6 testing_dataset_size = 3 _, training_input, test_input, _ = wine( training_size=training_dataset_size, test_size=testing_dataset_size, n=feature_dim, plot_data=False) aqua_globals.random_seed = self.seed feature_map = SecondOrderExpansion(feature_dimension=feature_dim) var_form = RYRZ(feature_map.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) vqc = VQC(COBYLA(maxiter=100), feature_map, var_form, training_input, test_input) # sort parameters for reproducibility if use_circuits: vqc._feature_map_params = list(x) vqc._var_form_params = list(theta) result = vqc.run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), shots=1024, seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) self.log.debug(result['testing_accuracy']) self.assertLess(result['testing_accuracy'], 0.6)
def test_wine(self): """Wine test.""" input_file = self.get_resource_path('sample_train.wine') with open(input_file) as file: sample_train_ref = json.load(file) input_file = self.get_resource_path('training_input.wine') with open(input_file) as file: training_input_ref = json.load(file) input_file = self.get_resource_path('test_input.wine') with open(input_file) as file: test_input_ref = json.load(file) sample_train, training_input, test_input, class_labels = wine( training_size=20, test_size=10, n=2, plot_data=False) np.testing.assert_allclose(sample_train.tolist(), sample_train_ref, rtol=1e-04) for key, _ in training_input.items(): np.testing.assert_allclose(training_input[key].tolist(), training_input_ref[key], rtol=1e-04) for key, _ in test_input.items(): np.testing.assert_allclose(test_input[key].tolist(), test_input_ref[key], rtol=1e-04) np.testing.assert_array_equal(class_labels, list(training_input.keys())) datapoints, class_to_label = split_dataset_to_data_and_labels( test_input) np.testing.assert_array_equal(datapoints[1], [0, 0, 1, 1, 1, 2, 2, 2, 2, 2]) self.assertDictEqual(class_to_label, {'A': 0, 'B': 1, 'C': 2})
def test_vqc_on_wine(self): """ vqc on wine test """ feature_dim = 4 # dimension of each data point training_dataset_size = 6 testing_dataset_size = 3 _, training_input, test_input, _ = wine( training_size=training_dataset_size, test_size=testing_dataset_size, n=feature_dim, plot_data=False) aqua_globals.random_seed = self.seed feature_map = SecondOrderExpansion(feature_dimension=feature_dim) vqc = VQC(COBYLA(maxiter=100), feature_map, RYRZ(feature_map.num_qubits, depth=1), training_input, test_input) result = vqc.run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), shots=1024, seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) self.log.debug(result['testing_accuracy']) self.assertLess(result['testing_accuracy'], 0.6)
print(f'Testing success ratio: {result["testing_accuracy"]}') print() print('Prediction from datapoints set:') print( f' ground truth: {map_label_to_class_name(datapoints[1], qsvm.label_to_class)}' ) print(f' prediction: {result["predicted_classes"]}') predicted_labels = result["predicted_labels"] print( f' success rate: {100 * np.count_nonzero(predicted_labels == datapoints[1]) / len(predicted_labels)}%' ) n = 2 # dimension of each data point sample_Total, training_input, test_input, class_labels = wine(training_size=50, test_size=6, n=n, plot_data=False) temp = [test_input[k] for k in test_input] total_array = np.concatenate(temp) try: aqua_globals.random_seed = 10598 backend = BasicAer.get_backend('qasm_simulator') feature_map = ZZFeatureMap( feature_dimension=get_feature_dimension(training_input), reps=2, entanglement='linear') svm = QSVM(feature_map, training_input, test_input,
from qiskit.circuit.library import TwoLocal, ZZFeatureMap from qiskit.aqua import QuantumInstance, aqua_globals from qiskit.aqua.algorithms import VQC from qiskit.aqua.components.optimizers import COBYLA from qiskit.aqua.components.feature_maps import RawFeatureVector from qiskit.aqua.utils import get_feature_dimension feature_dim = 4 # dimension of each data point training_dataset_size = 20 testing_dataset_size = 10 random_seed = 10598 aqua_globals.random_seed = random_seed sample_Total, training_input, test_input, class_labels = wine( training_size=training_dataset_size, test_size=testing_dataset_size, n=feature_dim, plot_data=False) feature_map = RawFeatureVector( feature_dimension=get_feature_dimension(training_input)) vqc = VQC(COBYLA(maxiter=200), feature_map, TwoLocal(feature_map.num_qubits, ['ry', 'rz'], 'cz', reps=3), training_input, test_input) result = vqc.run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) print("VQC accuracy with RawFeatureVector: ", result['testing_accuracy']) feature_map = ZZFeatureMap(get_feature_dimension(training_input))
import numpy as np from qiskit.ml.datasets import wine from qiskit.aqua.utils import split_dataset_to_data_and_labels from qiskit.aqua.algorithms import SklearnSVM from qiskit.aqua.components.multiclass_extensions import (OneAgainstRest, AllPairs, ErrorCorrectingCode) feature_dim = 2 # dimension of each data point sample_Total, training_input, test_input, class_labels = wine(training_size=20, test_size=10, n=feature_dim, plot_data=True) temp = [test_input[k] for k in test_input] total_array = np.concatenate(temp) extensions = [ OneAgainstRest(), AllPairs(), ErrorCorrectingCode(code_size=5) ] for extension in extensions: result = SklearnSVM(training_input, test_input, total_array, multiclass_extension=extension).run() print("\n----- Using multiclass extension: '{}' -----\n".format(extension.__class__.__name__)) for k,v in result.items(): print("'{}' : {}".format(k, v)) # 'testing_accuracy' : 1.0
from qiskit import BasicAer from qiskit.aqua import QuantumInstance, aqua_globals from qiskit.aqua.algorithms import VQC from qiskit.aqua.components.optimizers import COBYLA from qiskit.aqua.components.feature_maps import RawFeatureVector from qiskit.ml.datasets import wine from qiskit.circuit.library import TwoLocal seed = 1376 aqua_globals.random_seed = seed # Use Wine data set for training and test data feature_dim = 4 # dimension of each data point _, training_input, test_input, _ = wine(training_size=12, test_size=4, n=feature_dim) feature_map = RawFeatureVector(feature_dimension=feature_dim) vqc = VQC(COBYLA(maxiter=100), feature_map, TwoLocal(feature_map.num_qubits, ['ry', 'rz'], 'cz', reps=3), training_input, test_input) result = vqc.run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), shots=1024, seed_simulator=seed, seed_transpiler=seed)) print('Testing accuracy: {:0.2f}'.format(result['testing_accuracy'])) # Testing accuracy: 1.00
import numpy as np from qiskit.ml.datasets import wine from qiskit import BasicAer from qiskit.aqua import QuantumInstance, aqua_globals from qiskit.aqua.components.feature_maps import SecondOrderExpansion from qiskit.aqua.algorithms import QSVM from qiskit.aqua.components.multiclass_extensions import AllPairs from qiskit.aqua.utils.dataset_helper import get_feature_dimension n = 2 # dimension of each data point sample_Total, training_input, test_input, class_labels = wine(training_size=40, test_size=10, n=n, plot_data=True) temp = [test_input[k] for k in test_input] total_array = np.concatenate(temp) aqua_globals.random_seed = 10598 backend = BasicAer.get_backend('qasm_simulator') feature_map = SecondOrderExpansion( feature_dimension=get_feature_dimension(training_input), depth=2, entangler_map=[[0, 1]]) svm = QSVM(feature_map, training_input, test_input, total_array, multiclass_extension=AllPairs()) quantum_instance = QuantumInstance(backend, shots=1024,