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']))