def decision_function(self, X): """ predicted values for the points which account for both the labels and the confidence Args: X (numpy.ndarray): input points """ alphas = self._ret['svm']['alphas'] bias = self._ret['svm']['bias'] SVMs = self._ret['svm']['support_vectors'] yin = self._ret['svm']['yin'] kernel_matrix = kernel_join(X, SVMs, self.entangler_map, self.coupling_map, self.initial_layout, self.shots, self._random_seed, self.num_of_qubits, self._backend) total_num_points = len(X) Lsign = np.zeros(total_num_points) for tin in range(total_num_points): Ltot = 0 for sin in range(len(SVMs)): L = yin[sin] * alphas[sin] * kernel_matrix[tin][sin] Ltot += L Lsign[tin] = Ltot + bias return Lsign
def predict(self, test_points): """ predict using the svm Args: test_points (numpy.ndarray): the points """ alphas = self.ret['svm']['alphas'] bias = self.ret['svm']['bias'] SVMs = self.ret['svm']['support_vectors'] yin = self.ret['svm']['yin'] kernel_matrix = kernel_join(test_points, SVMs, self.entangler_map, self.coupling_map, self.initial_layout, self.shots, self._random_seed, self.num_of_qubits, self._backend) self.ret['kernel_matrix_prediction'] = kernel_matrix total_num_points = len(test_points) Lsign = np.zeros(total_num_points) for tin in range(total_num_points): Ltot = 0 for sin in range(len(SVMs)): L = yin[sin] * alphas[sin] * kernel_matrix[tin][sin] Ltot += L Lsign[tin] = np.int(np.sign(Ltot + bias)) return Lsign
def train(self, training_input, class_labels): """ train the svm Args: training_input (dict): dictionary which maps each class to the points in the class class_labels (list): list of classes. For example: ['A', 'B'] """ training_points, training_points_labels, label_to_class = get_points_and_labels(training_input, class_labels) kernel_matrix = kernel_join(training_points, training_points, self.entangler_map, self.coupling_map, self.initial_layout, self.shots, self._random_seed, self.num_of_qubits, self._backend) self.ret['kernel_matrix_training'] = kernel_matrix [alpha, b, support] = optimize_SVM(kernel_matrix, training_points_labels) alphas = np.array([]) SVMs = np.array([]) yin = np.array([]) for alphindex in range(len(support)): if support[alphindex]: alphas = np.vstack([alphas, alpha[alphindex]]) if alphas.size else alpha[alphindex] SVMs = np.vstack([SVMs, training_points[alphindex]]) if SVMs.size else training_points[alphindex] yin = np.vstack([yin, training_points_labels[alphindex]] ) if yin.size else training_points_labels[alphindex] self.ret['svm'] = {} self.ret['svm']['alphas'] = alphas self.ret['svm']['bias'] = b self.ret['svm']['support_vectors'] = SVMs self.ret['svm']['yin'] = yin
def test(self, test_input, class_labels): """ test the svm Args: test_input (dict): dictionary which maps each class to the points in the class class_labels (list): list of classes. For example: ['A', 'B'] """ test_points, test_points_labels, label_to_labelclass = get_points_and_labels(test_input, class_labels) alphas = self.ret['svm']['alphas'] bias = self.ret['svm']['bias'] SVMs = self.ret['svm']['support_vectors'] yin = self.ret['svm']['yin'] kernel_matrix = kernel_join(test_points, SVMs, self.entangler_map, self.coupling_map, self.initial_layout, self.shots, self._random_seed, self.num_of_qubits, self._backend) self.ret['kernel_matrix_testing'] = kernel_matrix success_ratio = 0 L = 0 total_num_points = len(test_points) Lsign = np.zeros(total_num_points) for tin in range(total_num_points): Ltot = 0 for sin in range(len(SVMs)): L = yin[sin] * alphas[sin] * kernel_matrix[tin][sin] Ltot += L Lsign[tin] = np.sign(Ltot + bias) logger.debug("\n=============================================") logger.debug('classifying' + str(test_points[tin])) logger.debug('Label should be ' + str(label_to_labelclass[np.int(test_points_labels[tin])])) logger.debug('Predicted label is ' + str(label_to_labelclass[np.int(Lsign[tin])])) if np.int(test_points_labels[tin]) == np.int(Lsign[tin]): logger.debug('CORRECT') else: logger.debug('INCORRECT') if Lsign[tin] == test_points_labels[tin]: success_ratio += 1 final_success_ratio = success_ratio / total_num_points logger.debug('Classification success for this set is %s %% \n' % (100 * final_success_ratio)) return final_success_ratio
def fit(self, X, y): """ fit values for the points and the labels Args: X (numpy.ndarray): input points y (numpy.ndarray): input labels """ y = y.astype(float) self.class_labels = np.unique(y) if len(self.class_labels) == 1: raise ValueError(" can not be fit when only one" " class is present.") self.num_of_qubits = X.shape[1] self.entangler_map = entangler_map_creator(self.num_of_qubits) self.coupling_map = None self.initial_layout = None if self._backend is None: self._backend = 'local_qasm_simulator' if self.shots is None: self.shots = 1000 kernel_matrix = kernel_join(X, X, self.entangler_map, self.coupling_map, self.initial_layout, self.shots, self._random_seed, self.num_of_qubits, self._backend) [alpha, b, support] = optimize_SVM(kernel_matrix, y) alphas = np.array([]) SVMs = np.array([]) yin = np.array([]) for alphindex in range(len(support)): if support[alphindex]: alphas = np.vstack([alphas, alpha[alphindex] ]) if alphas.size else alpha[alphindex] SVMs = np.vstack([SVMs, X[alphindex] ]) if SVMs.size else X[alphindex] yin = np.vstack([yin, y[alphindex] ]) if yin.size else y[alphindex] self._ret['svm'] = {} self._ret['svm']['alphas'] = alphas self._ret['svm']['bias'] = b self._ret['svm']['support_vectors'] = SVMs self._ret['svm']['yin'] = yin