def init_args(self, training_dataset, test_dataset, datapoints, optimizer,
feature_map, var_form):
"""Initialize the object
Args:
training_dataset (dict): {'A': numpy.ndarray, 'B': numpy.ndarray, ...}
test_dataset (dict): the same format as `training_dataset`
datapoints (numpy.ndarray): NxD array, N is the number of data and D is data dimension
optimizer (Optimizer): Optimizer instance
feature_map (FeatureMap): FeatureMap instance
var_form (VariationalForm): VariationalForm instance
Notes:
We used `label` denotes numeric results and `class` means the name of that class (str).
"""
if 'statevector' in self._backend:
raise ValueError('Selected backend "{}" is not supported.'.format(
self._backend))
self._training_dataset, self._class_to_label = split_dataset_to_data_and_labels(
training_dataset)
if test_dataset is not None:
self._test_dataset = split_dataset_to_data_and_labels(
test_dataset, self._class_to_label)
self._label_to_class = {
label: class_name
for class_name, label in self._class_to_label.items()
}
self._num_classes = len(list(self._class_to_label.keys()))
self._datapoints = datapoints
self._optimizer = optimizer
self._feature_map = feature_map
self._var_form = var_form
self._num_qubits = self._feature_map.num_qubits
def __init__(self, feature_map, qalgo, training_dataset, test_dataset,
datapoints):
if training_dataset is None:
raise ValueError('training dataset is missing! please provide it')
self.training_dataset, self.class_to_label = split_dataset_to_data_and_labels(
training_dataset)
if test_dataset is not None:
self.test_dataset = split_dataset_to_data_and_labels(
test_dataset, self.class_to_label)
else:
self.test_dataset = None
self.label_to_class = {
label: class_name
for class_name, label in self.class_to_label.items()
}
self.num_classes = len(list(self.class_to_label.keys()))
self.datapoints = datapoints
self.feature_map = feature_map
self.num_qubits = self.feature_map.num_qubits
self.qalgo = qalgo
self._ret = {}
def __init__(self,
feature_map,
training_dataset,
test_dataset=None,
datapoints=None,
multiclass_extension=None):
"""Constructor.
Args:
feature_map (FeatureMap): feature map module, used to transform data
training_dataset (dict): training dataset.
test_dataset (dict): testing dataset.
datapoints (numpy.ndarray): prediction dataset.
multiclass_extension (MultiExtension): if number of classes > 2, a multiclass scheme is
is needed.
Raises:
ValueError: if training_dataset is None
AquaError: use binary classifer for classes > 3
"""
super().__init__()
if training_dataset is None:
raise ValueError('Training dataset must be provided')
is_multiclass = get_num_classes(training_dataset) > 2
if is_multiclass:
if multiclass_extension is None:
raise AquaError('Dataset has more than two classes. '
'A multiclass extension must be provided.')
else:
if multiclass_extension is not None:
logger.warning("Dataset has just two classes. "
"Supplied multiclass extension will be ignored")
self.training_dataset, self.class_to_label = split_dataset_to_data_and_labels(
training_dataset)
if test_dataset is not None:
self.test_dataset = split_dataset_to_data_and_labels(
test_dataset, self.class_to_label)
else:
self.test_dataset = None
self.label_to_class = {
label: class_name
for class_name, label in self.class_to_label.items()
}
self.num_classes = len(list(self.class_to_label.keys()))
self.datapoints = datapoints
self.feature_map = feature_map
self.num_qubits = self.feature_map.num_qubits
if multiclass_extension is None:
qsvm_instance = _QSVM_Kernel_Binary(self)
else:
qsvm_instance = _QSVM_Kernel_Multiclass(self, multiclass_extension)
self.instance = qsvm_instance
def __init__(self, training_dataset, test_dataset=None, datapoints=None, gamma=None):
if training_dataset is None:
raise ValueError('training dataset is missing! please provide it')
self.training_dataset, self.class_to_label = split_dataset_to_data_and_labels(
training_dataset)
if test_dataset is not None:
self.test_dataset = split_dataset_to_data_and_labels(test_dataset,
self.class_to_label)
self.label_to_class = {label: class_name for class_name, label
in self.class_to_label.items()}
self.num_classes = len(list(self.class_to_label.keys()))
self.datapoints = datapoints
self.gamma = gamma
self._ret = {}
def __init__(self, optimizer, feature_map, var_form, training_dataset,
test_dataset=None, datapoints=None, batch_mode=False):
"""Initialize the object
Args:
training_dataset (dict): {'A': numpy.ndarray, 'B': numpy.ndarray, ...}
test_dataset (dict): the same format as `training_dataset`
datapoints (numpy.ndarray): NxD array, N is the number of data and D is data dimension
optimizer (Optimizer): Optimizer instance
feature_map (FeatureMap): FeatureMap instance
var_form (VariationalForm): VariationalForm instance
batch_mode (boolean): Batch mode for circuit compilation and execution
Notes:
We used `label` denotes numeric results and `class` means the name of that class (str).
"""
self.validate(locals())
super().__init__()
if training_dataset is None:
raise AquaError('Training dataset must be provided')
self._training_dataset, self._class_to_label = split_dataset_to_data_and_labels(
training_dataset)
self._label_to_class = {label: class_name for class_name, label
in self._class_to_label.items()}
self._num_classes = len(list(self._class_to_label.keys()))
if test_dataset is not None:
self._test_dataset = split_dataset_to_data_and_labels(test_dataset,
self._class_to_label)
else:
self._test_dataset = test_dataset
self._datapoints = datapoints
self._optimizer = optimizer
self._feature_map = feature_map
self._var_form = var_form
self._num_qubits = self._feature_map.num_qubits
self._optimizer.set_batch_mode(batch_mode)
self._ret = {}
def init_args(self, training_dataset, test_dataset, datapoints, optimizer,
feature_map, var_form, batch_mode=False):
"""Initialize the object
Args:
training_dataset (dict): {'A': numpy.ndarray, 'B': numpy.ndarray, ...}
test_dataset (dict): the same format as `training_dataset`
datapoints (numpy.ndarray): NxD array, N is the number of data and D is data dimension
optimizer (Optimizer): Optimizer instance
feature_map (FeatureMap): FeatureMap instance
var_form (VariationalForm): VariationalForm instance
batch_mode (boolean): Batch mode for circuit compilation and execution
Notes:
We used `label` denotes numeric results and `class` means the name of that class (str).
"""
if QuantumAlgorithm.is_statevector_backend(self.backend):
raise ValueError('Selected backend "{}" is not supported.'.format(QuantumAlgorithm.backend_name(self.backend)))
if training_dataset is None:
raise AlgorithmError('Training dataset must be provided')
self._training_dataset, self._class_to_label = split_dataset_to_data_and_labels(
training_dataset)
if test_dataset is not None:
self._test_dataset = split_dataset_to_data_and_labels(test_dataset,
self._class_to_label)
self._label_to_class = {label: class_name for class_name, label
in self._class_to_label.items()}
self._num_classes = len(list(self._class_to_label.keys()))
self._datapoints = datapoints
self._optimizer = optimizer
self._feature_map = feature_map
self._var_form = var_form
self._num_qubits = self._feature_map.num_qubits
self._optimizer.set_batch_mode(batch_mode)
from qiskit_aqua.utils import split_dataset_to_data_and_labels
from qiskit_aqua.input import SVMInput
from qiskit_qcgpu_provider import QCGPUProvider
from qiskit_aqua import run_algorithm
n = 2 # How many features to use (dimensionality)
training_dataset_size = 20
testing_dataset_size = 10
sample_Total, training_input, test_input, class_labels = breast_cancer(training_dataset_size, testing_dataset_size, n)
datapoints, class_to_label = split_dataset_to_data_and_labels(test_input)
print(class_to_label)
params = {
'problem': {'name': 'svm_classification', 'random_seed': 10598},
'algorithm': { 'name': 'QSVM.Kernel' },
'backend': {'name': 'qasm_simulator', 'shots': 1024},
'feature_map': {'name': 'SecondOrderExpansion', 'depth': 2, 'entanglement': 'linear'}
}
backend = QCGPUProvider().get_backend('qasm_simulator')
algo_input = SVMInput(training_input, test_input, datapoints[0])
%time result = run_algorithm(params, algo_input)
%time result = run_algorithm(params, algo_input, backend=backend)
print("ground truth: {}".format(datapoints[1]))
print("prediction: {}".format(result['predicted_labels']))
def classify(location='',file='testClassify.csv',class_labels=[r'A', r'B'], train_size=100, test_size=50) :
# Title is defined in usedDefinedData function - can edit if needed but that file is from the
# tutorial
sample_Total, training_input, test_input, class_labels = datasets.userDefinedData(location,
file,
[r'1', r'61'], #class_labels,
training_size=train_size,
test_size=test_size,
n=2, # normally n = 2, but can be bigger - timed out with n = 3
PLOT_DATA=True)
# n = 2 is the dimension of each data point
# replaced get_points with split_dataset_to_data_and_labels
datapoints, class_to_label = split_dataset_to_data_and_labels(test_input)
label_to_class = {label: class_name for class_name, label in class_to_label.items()}
print(class_to_label)
params = {
'problem': {'name': 'svm_classification', 'random_seed': 10598},
'algorithm': {
'name': 'QSVM.Kernel'
},
'backend': {'name': 'qasm_simulator', 'shots': 1024},
'feature_map': {'name': 'SecondOrderExpansion', 'depth': 2, 'entanglement': 'linear'}
}
algo_input = get_input_instance('SVMInput')
algo_input.training_dataset = training_input
algo_input.test_dataset = test_input
algo_input.datapoints = datapoints[0]
import time
start_time = time.time()
print("Running algorithm")
result = run_algorithm(params, algo_input)
time_taken_secs = (time.time() - start_time)
time_taken_format = str(int(time_taken_secs / 60)) + ":" + str((time_taken_secs % 60))
print("--- %s ---" % time_taken_format)
print(result)
print("kernel matrix during the training:")
kernel_matrix = result['kernel_matrix_training']
img = plt.imshow(np.asmatrix(kernel_matrix), interpolation='nearest', origin='upper', cmap='bone_r')
plt.show()
print("testing success ratio: ", result['testing_accuracy'])
# from new notebook
print("testing success ratio: ", result['testing_accuracy'])
print("predicted classes:", result['predicted_classes'])
print("ground truth: {}".format(map_label_to_class_name(datapoints[1], label_to_class)))
print("predicted: {}".format(result['predicted_classes']))
