def test_copy(self):
"""Test copy operation for ``RawFeatureVector``."""
circuit = RawFeatureVector(8)
circuit_copy = circuit.copy()
# make sure that the copied circuit has the same number of qubits as the original one
self.assertEqual(circuit.num_qubits, circuit_copy.num_qubits)
self.assertEqual(circuit.feature_dimension,
circuit_copy.feature_dimension)
def test_fully_bound(self):
"""Test fully binding the circuit works."""
circuit = RawFeatureVector(8)
params = np.random.random(8) + 1j * np.random.random(8)
params /= np.linalg.norm(params)
bound = circuit.bind_parameters(params)
ref = QuantumCircuit(3)
ref.initialize(params, ref.qubits)
self.assertEqual(bound.decompose(), ref)
def test_usage_in_vqc(self):
"""Test using the circuit the a single VQC iteration works."""
# specify quantum instance and random seed
random_seed = 12345
quantum_instance = QuantumInstance(
Aer.get_backend('statevector_simulator'),
seed_simulator=random_seed,
seed_transpiler=random_seed)
np.random.seed(random_seed)
# construct data
num_samples = 10
num_inputs = 4
X = np.random.rand(num_samples, num_inputs) # pylint: disable=invalid-name
y = 1.0 * (np.sum(X, axis=1) <= 2)
while len(np.unique(y, axis=0)) == 1:
y = 1.0 * (np.sum(X, axis=1) <= 2)
y = np.array([y, 1 - y]).transpose()
feature_map = RawFeatureVector(feature_dimension=num_inputs)
vqc = VQC(feature_map=feature_map,
ansatz=RealAmplitudes(feature_map.num_qubits, reps=1),
optimizer=COBYLA(maxiter=10),
quantum_instance=quantum_instance)
vqc.fit(X, y)
score = vqc.score(X, y)
self.assertGreater(score, 0.5)
def test_fully_bound(self):
"""Test fully binding the circuit works."""
circuit = RawFeatureVector(8)
params = np.random.random(8) + 1j * np.random.random(8)
params /= np.linalg.norm(params)
bound = circuit.bind_parameters(params)
ref = QuantumCircuit(3)
ref.initialize(params, ref.qubits)
self.assertEqual(bound.decompose(), ref)
# make sure that the bound circuit is a successful copy of the original circuit
self.assertEqual(circuit.num_qubits, bound.num_qubits)
self.assertEqual(circuit.feature_dimension, bound.feature_dimension)
def test_bind_after_composition(self):
"""Test binding the parameters after the circuit was composed onto a larger one."""
circuit = QuantumCircuit(2)
circuit.h([0, 1])
raw = RawFeatureVector(4)
circuit.append(raw, [0, 1])
bound = circuit.bind_parameters([1, 0, 0, 0])
self.assertTrue(Statevector.from_label('00').equiv(bound))
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.utils import QuantumInstance, algorithm_globals
from qiskit.algorithms.optimizers import COBYLA
from qiskit.circuit.library import TwoLocal
from qiskit_machine_learning.algorithms import VQC
from qiskit_machine_learning.datasets import wine
from qiskit_machine_learning.circuit.library import RawFeatureVector
seed = 1376
algorithm_globals.random_seed = seed
# Use Wine data set for training and test data
feature_dim = 4 # dimension of each data point
training_size = 12
test_size = 4
# training features, training labels, test features, test labels as np.array,
# one hot encoding for labels
training_features, training_labels, test_features, test_labels = \
wine(training_size=training_size, test_size=test_size, n=feature_dim)
feature_map = RawFeatureVector(feature_dimension=feature_dim)
ansatz = TwoLocal(feature_map.num_qubits, ['ry', 'rz'], 'cz', reps=3)
vqc = VQC(feature_map=feature_map,
ansatz=ansatz,
optimizer=COBYLA(maxiter=100),
quantum_instance=QuantumInstance(
BasicAer.get_backend('statevector_simulator'),
shots=1024,
seed_simulator=seed,
seed_transpiler=seed))
vqc.fit(training_features, training_labels)
score = vqc.score(test_features, test_labels)
print('Testing accuracy: {:0.2f}'.format(score))
# ----------------------------------------------------------------------
self.assertGreater(score, 0.8)
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_construction(self):
"""Test creating the circuit works."""
circuit = RawFeatureVector(4)
with self.subTest('check number of qubits'):
self.assertEqual(circuit.num_qubits, 2)
with self.subTest('check parameters'):
self.assertEqual(len(circuit.parameters), 4)
with self.subTest('check unrolling fails'):
with self.assertRaises(QiskitError):
_ = transpile(circuit,
basis_gates=['u', 'cx'],
optimization_level=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.utils import QuantumInstance, algorithm_globals
from qiskit.algorithms.optimizers import COBYLA
from qiskit.circuit.library import TwoLocal
from qiskit_machine_learning.algorithms import VQC
from qiskit_machine_learning.datasets import wine
from qiskit_machine_learning.circuit.library import RawFeatureVector
seed = 1376
algorithm_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_partially_bound(self):
"""Test partially binding the circuit works."""
circuit = RawFeatureVector(4)
params = circuit.parameters
with self.subTest('single numeric value'):
circuit.assign_parameters({params[0]: 0.2}, inplace=True)
self.assertEqual(len(circuit.parameters), 3)
with self.subTest('bound to another parameter'):
circuit.assign_parameters({params[1]: params[2]}, inplace=True)
self.assertEqual(len(circuit.parameters), 2)
with self.subTest('test now fully bound circuit'):
bound = circuit.assign_parameters({params[2]: 0.4, params[3]: 0.8})
ref = QuantumCircuit(2)
ref.initialize([0.2, 0.4, 0.4, 0.8], ref.qubits)
self.assertEqual(bound.decompose(), ref)
def test_raw_feature_vector_on_wine(self, ):
"""Test VQC 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.7)
def test_usage_in_vqc(self):
"""Test using the circuit the a single VQC iteration works."""
# specify quantum instance and random seed
algorithm_globals.random_seed = 12345
quantum_instance = QuantumInstance(
Aer.get_backend("aer_simulator_statevector"),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
)
# construct data
num_samples = 10
num_inputs = 4
X = algorithm_globals.random.random( # pylint: disable=invalid-name
(num_samples, num_inputs))
y = 1.0 * (np.sum(X, axis=1) <= 2)
while len(np.unique(y, axis=0)) == 1:
y = 1.0 * (np.sum(X, axis=1) <= 2)
y = np.array([y, 1 - y]).transpose()
feature_map = RawFeatureVector(feature_dimension=num_inputs)
ansatz = RealAmplitudes(feature_map.num_qubits, reps=1)
# classification may fail sometimes, so let's fix initial point
initial_point = np.array([0.5] * ansatz.num_parameters)
vqc = VQC(
feature_map=feature_map,
ansatz=ansatz,
optimizer=COBYLA(maxiter=10),
quantum_instance=quantum_instance,
initial_point=initial_point,
)
vqc.fit(X, y)
score = vqc.score(X, y)
self.assertGreater(score, 0.5)
def test_partially_bound(self):
"""Test partially binding the circuit works."""
circuit = RawFeatureVector(4)
params = circuit.parameters
with self.subTest("single numeric value"):
circuit.assign_parameters({params[0]: 0.2}, inplace=True)
self.assertEqual(len(circuit.parameters), 3)
with self.subTest("bound to another parameter"):
circuit.assign_parameters({params[1]: params[2]}, inplace=True)
self.assertEqual(len(circuit.parameters), 2)
with self.subTest("test now fully bound circuit"):
bound = circuit.assign_parameters({params[2]: 0.4, params[3]: 0.8})
ref = QuantumCircuit(2)
ref.initialize([0.2, 0.4, 0.4, 0.8], ref.qubits)
self.assertEqual(bound.decompose(), ref)
# make sure that the bound circuit is a successful copy of the original circuit
self.assertEqual(circuit.num_qubits, bound.num_qubits)
self.assertEqual(circuit.feature_dimension,
bound.feature_dimension)
