Exemplo n.º 1
0
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
Exemplo n.º 2
0
        def RunAllKnnShogun(q):
            totalTimer = Timer()

            # Load input dataset.
            # If the dataset contains two files then the second file is the query
            # file.
            try:
                Log.Info("Loading dataset", self.verbose)
                if len(self.dataset) == 2:
                    referenceData = np.genfromtxt(self.dataset[0],
                                                  delimiter=',')
                    queryData = np.genfromtxt(self.dataset[1], delimiter=',')
                    queryFeat = RealFeatures(queryFeat.T)
                else:
                    referenceData = np.genfromtxt(self.dataset, delimiter=',')

                # Labels are the last row of the dataset.
                labels = MulticlassLabels(
                    referenceData[:, (referenceData.shape[1] - 1)])
                referenceData = referenceData[:, :-1]

                with totalTimer:
                    # Get all the parameters.
                    k = re.search("-k (\d+)", options)
                    if not k:
                        Log.Fatal(
                            "Required option: Number of furthest neighbors to find."
                        )
                        q.put(-1)
                        return -1
                    else:
                        k = int(k.group(1))
                        if (k < 1 or k > referenceData.shape[0]):
                            Log.Fatal("Invalid k: " + k.group(1) +
                                      "; must be greater than 0" +
                                      " and less or equal than " +
                                      str(referenceData.shape[0]))
                            q.put(-1)
                            return -1

                    referenceFeat = RealFeatures(referenceData.T)
                    distance = EuclideanDistance(referenceFeat, referenceFeat)

                    # Perform All K-Nearest-Neighbors.
                    model = SKNN(k, distance, labels)
                    model.train()

                    if len(self.dataset) == 2:
                        out = model.apply(queryFeat).get_labels()
                    else:
                        out = model.apply(referenceFeat).get_labels()
            except Exception as e:
                q.put(-1)
                return -1

            time = totalTimer.ElapsedTime()
            q.put(time)
            return time
    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)
Exemplo n.º 4
0
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)
Exemplo n.º 5
0
    def RunAllKnnShogun(q):
      totalTimer = Timer()

      # Load input dataset.
      # If the dataset contains two files then the second file is the query
      # file.
      try:
        Log.Info("Loading dataset", self.verbose)
        if len(self.dataset) == 2:
          referenceData = np.genfromtxt(self.dataset[0], delimiter=',')
          queryData = np.genfromtxt(self.dataset[1], delimiter=',')
          queryFeat = RealFeatures(queryFeat.T)
        else:
          referenceData = np.genfromtxt(self.dataset, delimiter=',')

        # Labels are the last row of the dataset.
        labels = MulticlassLabels(referenceData[:, (referenceData.shape[1] - 1)])
        referenceData = referenceData[:,:-1]

        with totalTimer:
          # Get all the parameters.
          k = re.search("-k (\d+)", options)
          if not k:
            Log.Fatal("Required option: Number of furthest neighbors to find.")
            q.put(-1)
            return -1
          else:
            k = int(k.group(1))
            if (k < 1 or k > referenceData.shape[0]):
              Log.Fatal("Invalid k: " + k.group(1) + "; must be greater than 0"
                + " and less or equal than " + str(referenceData.shape[0]))
              q.put(-1)
              return -1

          referenceFeat = RealFeatures(referenceData.T)
          distance = EuclideanDistance(referenceFeat, referenceFeat)

          # Perform All K-Nearest-Neighbors.
          model = SKNN(k, distance, labels)
          model.train()

          if len(self.dataset) == 2:
            out = model.apply(queryFeat).get_labels()
          else:
            out = model.apply(referenceFeat).get_labels()
      except Exception as e:
        q.put(-1)
        return -1

      time = totalTimer.ElapsedTime()
      q.put(time)
      return time
class Number_recognition:
    def __init__(self, test_images, test_labels, k):
        self.test_images = test_images;
        self.test_labels = test_labels;
        self.k = k;

    def load(self, path_img, path_lbl):
        with open(path_lbl, 'rb') as file:
            magic, size = struct.unpack(">II", file.read(8))
            if magic != 2049:
                raise ValueError('Magic number mismatch, expected 2049,'
                    'got %d' % magic)

            labels = array("B", file.read())

        labels_result = np.zeros(shape=(size))


        for i in xrange(size):
            labels_result[i] = labels[i]

        with open(path_img, 'rb') as file:
            magic, size, rows, cols = struct.unpack(">IIII", file.read(16))
            print "rows: " + str(rows) + "  cols: " + str(cols)
            if magic != 2051:
                raise ValueError('Magic number mismatch, expected 2051,'
                        'got %d' % magic)
            image_data = array("B", file.read())

        images = np.zeros(shape=(size,rows*cols))

        for i in xrange(size):
            images[i][:] = image_data[i*rows*cols : (i+1)*rows*cols]


        return images, labels_result

    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 predict(self, image):
        feats_test  = RealFeatures(image. T)
        pred = self.knn.apply_multiclass(feats_test)
        return pred[:]
Exemplo n.º 7
0
  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
Exemplo n.º 8
0
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 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)
Exemplo n.º 10
0
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
Exemplo n.º 11
0
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
Exemplo n.º 12
0
    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
Exemplo n.º 13
0
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)
Exemplo n.º 14
0
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
Exemplo n.º 15
0
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)
Exemplo n.º 16
0
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
Exemplo n.º 17
0
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
Exemplo n.º 18
0
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
Exemplo n.º 19
0
    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
Exemplo n.º 20
0
def run_knn(Xtrain,Ytrain,Xtest,Ytest):
    prod_features = RealFeatures(Xtrain)
    prod_labels = MulticlassLabels(Ytrain)
    test_features = RealFeatures(Xtest)
    test_labels = MulticlassLabels(Ytest)

    if os.path.exists(".lmnn_model30000_5_reg05_cor20"):
        print "Using LMNN distance"
        lmnn = LMNN()
        sf = SerializableAsciiFile(".lmnn_model30000_5_reg05_cor20", 'r')
        lmnn.load_serializable(sf)

        diagonal = np.diag(lmnn.get_linear_transform())
        #print('%d out of %d elements are non-zero.' % (np.sum(diagonal != 0), diagonal.size))
        #diagonal = lmnn.get_linear_transform()
        np.set_printoptions(precision=1,threshold=1e10,linewidth=500)

        #lmnn.set_diagonal(True)
        dist = lmnn.get_distance()
    else:
        dist = EuclideanDistance()

    # classifier
    knn = KNN(K, dist, prod_labels)
    #knn.set_use_covertree(True)
    parallel = knn.get_global_parallel()
    parallel.set_num_threads(4)
    knn.set_global_parallel(parallel)
    knn.train(prod_features)

    print "Classifying test set..."
    pred = knn.apply_multiclass(test_features)

    print "Accuracy = %2.2f%%" % (100*np.mean(pred == Ytest))

    cm = build_confusion_matrix(Ytest, pred, NCLASSES)
    #save_confusion_matrix(cm)
    #cm = load_confusion_matrix()
    print "Confusion matrix: "
    print cm
    #plot_confusion_matrix(cm)

    #results = predict_class_prob(pred, cm)
    
    #nn = build_neighbours_matrix(knn, prod_labels)
    #results = predict_class_from_neighbours(nn)

    #print "Log loss: " + str(calculate_log_loss(results, Ytest))

    #print_prediction_output(results)
    return cm
Exemplo n.º 21
0
    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
Exemplo n.º 22
0
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)
Exemplo n.º 23
0
    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
Exemplo n.º 24
0
  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
Exemplo n.º 25
0
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)
Exemplo n.º 26
0
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)
Exemplo n.º 27
0
		xs = [x[i,0], x[nn[1,i], 0]]
		ys = [x[i,1], x[nn[1,i], 1]]
		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])
Exemplo n.º 28
0
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
Exemplo n.º 29
0
        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])
Exemplo n.º 30
0
from modshogun import EuclideanDistance, KNN, MulticlassLabels, CSVFile, RealFeatures

#![begin]
#![load_data]
trainf = CSVFile("../data/fm_train_real.dat")
feats_train = RealFeatures(trainf)
testf = CSVFile("../data/fm_test_real.dat")
feats_test = RealFeatures(testf)
train_labels = CSVFile("../data/label_train_multiclass.dat")
labels = MulticlassLabels(train_labels)
#![load_data]

#![choose_distance]
distance = EuclideanDistance(feats_train, feats_test)
#![choose_distance]

#![create_instance]
knn = KNN(3, distance, labels)
#![create_instance]

#![train_and_apply]
knn.train()
test_labels = knn.apply(feats_test)
output = test_labels.get_values()
print output
#![train_and_apply]
#![end]
Exemplo n.º 31
0
# load LMNN
if os.path.exists(".lmnn_model30000_5_reg05_cor20"):
    sf = SerializableAsciiFile(".lmnn_model30000_5_reg05_cor20", 'r')
    lmnn = LMNN()
    lmnn.load_serializable(sf)

    diagonal = np.diag(lmnn.get_linear_transform())
    print('%d out of %d elements are non-zero.' % (np.sum(diagonal != 0), diagonal.size))
    #print diagonal
    dist = lmnn.get_distance()
else:
    dist = EuclideanDistance()

cm = load_confusion_matrix()
print cm

# classifier
knn = KNN(k, dist, prod_labels)
parallel = knn.get_global_parallel()
parallel.set_num_threads(4)
knn.set_global_parallel(parallel)
knn.train(prod_features)

print "Classifying test set..."
pred = knn.apply_multiclass(test_features)

results = predict_class_prob(pred, cm)
print_prediction_output(results)