def metric_lmnn_modular(train_fname=traindat, test_fname=testdat, label_train_fname=label_traindat, k=3): try: from modshogun import RealFeatures, MulticlassLabels, LMNN, KNN, CSVFile except ImportError: return # wrap features and labels into Shogun objects feats_train = RealFeatures(CSVFile(train_fname)) feats_test = RealFeatures(CSVFile(test_fname)) labels = MulticlassLabels(CSVFile(label_train_fname)) # LMNN lmnn = LMNN(feats_train, labels, k) lmnn.train() lmnn_distance = lmnn.get_distance() # perform classification with KNN knn = KNN(k, lmnn_distance, labels) knn.train() output = knn.apply(feats_test).get_labels() return lmnn, output
def load_train(self): ims, labels = self.load( self.test_images, self.test_labels) self.test_images = ims self.test_labels = labels labels_numbers = MulticlassLabels(self.test_labels) feats = RealFeatures(self.test_images.T) dist = EuclideanDistance() self.knn = KNN(self.k, dist, labels_numbers) self.knn.train(feats)
def assign_labels(data, centroids, ncenters): from modshogun import EuclideanDistance from modshogun import RealFeatures, MulticlassLabels from modshogun import KNN from numpy import arange labels = MulticlassLabels(arange(0., ncenters)) fea = RealFeatures(data) fea_centroids = RealFeatures(centroids) distance = EuclideanDistance(fea_centroids, fea_centroids) knn = KNN(1, distance, labels) knn.train() return knn.apply(fea)
def knn(train_features, train_labels, test_features, test_labels, k=1): from modshogun import KNN, MulticlassAccuracy, EuclideanDistance distance = EuclideanDistance(train_features, train_features) knn = KNN(k, distance, train_labels) knn.train() train_output = knn.apply() test_output = knn.apply(test_features) evaluator = MulticlassAccuracy() print 'KNN training error is %.4f' % ( (1 - evaluator.evaluate(train_output, train_labels)) * 100) print 'KNN test error is %.4f' % ( (1 - evaluator.evaluate(test_output, test_labels)) * 100)
def BuildModel(self, data, labels, options): # Get all the parameters. n = re.search("-n (\d+)", options) self.n_neighbors = 5 if not n else int(n.group(1)) distance = EuclideanDistance(data, data) from modshogun import KNN_KDTREE knc = KNN(self.n_neighbors, distance, labels, KNN_KDTREE) knc.set_leaf_size(30) knc.train() return knc
def BuildModel(self, data, labels, options): # Get all the parameters. n = re.search("-n (\d+)", options) self.n_neighbors = 5 if not n else int(n.group(1)) distance = EuclidianDistance(data, data) knc = KNN(self.n_neighbors, distance, labels) knc.train() # Create and train the classifier. knc = LibSvm(self.C, self.kernel, labels) knc.train() return knc
def knn_classify(traindat, testdat, k=3): from modshogun import KNN, MulticlassAccuracy, EuclideanDistance train_features, train_labels = traindat.features, traindat.labels distance = EuclideanDistance(train_features, train_features) knn = KNN(k, distance, train_labels) knn.train() test_features, test_labels = testdat.features, testdat.labels predicted_labels = knn.apply(test_features) evaluator = MulticlassAccuracy() acc = evaluator.evaluate(predicted_labels, test_labels) err = 1 - acc return err
def BuildModel(self, data, labels, options): # Get all the parameters. if "k" in options: n_neighbors = int(options.pop("k")) else: Log.Fatal("Required parameter 'k' not specified!") raise Exception("missing parameter") if len(options) > 0: Log.Fatal("Unknown parameters: " + str(options)) raise Exception("unknown parameters") distance = EuclideanDistance(data, data) knc = KNN(self.n_neighbors, distance, labels, KNN_KDTREE) knc.train() return knc
def classifier_knn_modular(train_fname=traindat, test_fname=testdat, label_train_fname=label_traindat, k=3): from modshogun import RealFeatures, MulticlassLabels, KNN, EuclideanDistance, CSVFile feats_train = RealFeatures(CSVFile(train_fname)) feats_test = RealFeatures(CSVFile(test_fname)) distance = EuclideanDistance(feats_train, feats_train) labels = MulticlassLabels(CSVFile(label_train_fname)) knn = KNN(k, distance, labels) knn_train = knn.train() output = knn.apply(feats_test).get_labels() multiple_k = knn.classify_for_multiple_k() return knn, knn_train, output, multiple_k
def lmnn(train_features, train_labels, test_features, test_labels, k=1): from modshogun import LMNN, KNN, MSG_DEBUG, MulticlassAccuracy import numpy # dummy = LMNN() # dummy.io.set_loglevel(MSG_DEBUG) lmnn = LMNN(train_features, train_labels, k) lmnn.train() distance = lmnn.get_distance() knn = KNN(k, distance, train_labels) knn.train() train_output = knn.apply() test_output = knn.apply(test_features) evaluator = MulticlassAccuracy() print 'LMNN training error is %.4f' % ( (1 - evaluator.evaluate(train_output, train_labels)) * 100) print 'LMNN test error is %.4f' % ( (1 - evaluator.evaluate(test_output, test_labels)) * 100)
def lmnn_classify(traindat, testdat, k=3): from modshogun import LMNN, KNN, MulticlassAccuracy, MSG_DEBUG train_features, train_labels = traindat.features, traindat.labels lmnn = LMNN(train_features, train_labels, k) lmnn.set_maxiter(1200) lmnn.io.set_loglevel(MSG_DEBUG) lmnn.train() distance = lmnn.get_distance() knn = KNN(k, distance, train_labels) knn.train() test_features, test_labels = testdat.features, testdat.labels predicted_labels = knn.apply(test_features) evaluator = MulticlassAccuracy() acc = evaluator.evaluate(predicted_labels, test_labels) err = 1 - acc return err
def KNNAccuracy(distance, data, k, flag): transformedData = np.dot(data[0], distance.T) feat = RealFeatures(transformedData.T) labels = MulticlassLabels(data[1].astype(np.float64)) dist = EuclideanDistance(feat, feat) knn = KNN(k + 1, dist, labels) knn.train(feat) # Get nearest neighbors. nn = knn.nearest_neighbors() nn = np.delete(nn, 0, 0) # Compute unique labels. uniqueLabels = np.unique(labels) # Keep count correct predictions. count = 0 # Normalize labels for i in range(data[0].shape[0]): for j in range(len(uniqueLabels)): if (labels[i] == uniqueLabels[j]): labels[i] = j break for i in range(nn.shape[1]): mapLabels = [0 for x in range(len(uniqueLabels))] for j in range(nn.shape[0]): if (flag): distPoints = np.linalg.norm(data[0][nn[j][i], :] - data[0][i, :]) # Add constant factor of 1 incase two points overlap mapLabels[int(labels[nn[j, i]])] += 1 / (distPoints + 1)**2 else: # Subtract a variable factor to avoid draw condition without # affecting actual result. mapLabels[int(labels[nn[j, i]])] += 1 - j * 1e-8 maxInd = np.argmax(mapLabels) if (maxInd == labels[i]): count += 1 accuracy = (count / nn.shape[1]) * 100 return accuracy
def lmnn_diagonal(train_features, train_labels, test_features, test_labels, k=1): from modshogun import LMNN, KNN, MSG_DEBUG, MulticlassAccuracy import numpy lmnn = LMNN(train_features, train_labels, k) lmnn.set_diagonal(True) lmnn.train() distance = lmnn.get_distance() knn = KNN(k, distance, train_labels) knn.train() train_output = knn.apply() test_output = knn.apply(test_features) evaluator = MulticlassAccuracy() print 'LMNN-diagonal training error is %.4f' % ( (1 - evaluator.evaluate(train_output, train_labels)) * 100) print 'LMNN-diagonal test error is %.4f' % ( (1 - evaluator.evaluate(test_output, test_labels)) * 100)
axis.plot(xs, ys, COLS[int(y[i])]) figure, axarr = pyplot.subplots(3, 1) x, y = sandwich_data() features = RealFeatures(x.T) labels = MulticlassLabels(y) print('%d vectors with %d features' % (features.get_num_vectors(), features.get_num_features())) assert (features.get_num_vectors() == labels.get_num_labels()) distance = EuclideanDistance(features, features) k = 2 knn = KNN(k, distance, labels) plot_data(x, y, axarr[0]) plot_neighborhood_graph(x, knn.nearest_neighbors(), axarr[0]) axarr[0].set_aspect('equal') axarr[0].set_xlim(-6, 4) axarr[0].set_ylim(-3, 2) lmnn = LMNN(features, labels, k) lmnn.set_maxiter(10000) lmnn.train() L = lmnn.get_linear_transform() knn.set_distance(lmnn.get_distance()) plot_data(x, y, axarr[1]) plot_neighborhood_graph(x, knn.nearest_neighbors(), axarr[1])
def evaluate(labels, feats, params={ 'n_neighbors': 2, 'use_cover_tree': 'True', 'dist': 'Manhattan' }, Nsplit=2): """ Run Cross-validation to evaluate the KNN. Parameters ---------- labels: 2d array Data set labels. feats: array Data set feats. params: dictionary Search scope parameters. Nsplit: int, default = 2 The n for n-fold cross validation. all_ks: range of int, default = range(1, 21) Numbers of neighbors. """ k = params.get('n_neighbors') use_cover_tree = params.get('use_cover_tree') == 'True' if params.get('dist' == 'Euclidean'): func_dist = EuclideanDistance else: func_dist = ManhattanMetric split = CrossValidationSplitting(labels, Nsplit) split.build_subsets() accuracy = np.zeros(Nsplit) acc_train = np.zeros(accuracy.shape) time_test = np.zeros(accuracy.shape) for i in range(Nsplit): idx_train = split.generate_subset_inverse(i) idx_test = split.generate_subset_indices(i) feats.add_subset(idx_train) labels.add_subset(idx_train) dist = func_dist(feats, feats) knn = KNN(k, dist, labels) knn.set_store_model_features(True) if use_cover_tree: knn.set_knn_solver_type(KNN_COVER_TREE) else: knn.set_knn_solver_type(KNN_BRUTE) knn.train() evaluator = MulticlassAccuracy() pred = knn.apply_multiclass() acc_train[i] = evaluator.evaluate(pred, labels) feats.remove_subset() labels.remove_subset() feats.add_subset(idx_test) labels.add_subset(idx_test) t_start = time.clock() pred = knn.apply_multiclass(feats) time_test[i] = (time.clock() - t_start) / labels.get_num_labels() accuracy[i] = evaluator.evaluate(pred, labels) feats.remove_subset() labels.remove_subset() print accuracy.mean() return accuracy