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,
