def run_with_lmnn(label, n_neighbors, n_train_lmnn, train_lmnn_vectors, train_lmnn_labels, train_vectors, train_labels, test_vectors, test_labels): t = time.time() print('Fitting ' + label + ' lmnn (n = %d) + kNN (k = %d)... [' % (n_train_lmnn, n_neighbors) + time.strftime('%H:%M:%S') + ']') lmnn = metric_learn.LMNN(k=n_neighbors, max_iter=n_max_iter) lmnn.fit(train_lmnn_vectors, train_lmnn_labels) path_name = path_strategy + 'metrix/' #no relationship with day if not os.path.exists(path_name): os.mkdir(path_name) pandas.DataFrame(lmnn.metric()).to_csv( path_name + 'kNN_with_Lmnn(k=%d,n=%d)_' % (n_neighbors, n_train_lmnn) + label + '_Matric.csv', header=False, index=False) print('\tdone in %.fs [' % (time.time() - t) + time.strftime('%H:%M:%S') + '].') filename_partdata = 'kNN_with_Lmnn_Partdata(k=%d,n=%d)_' % ( n_neighbors, n_train_lmnn) + label lmnn_train_vectors = lmnn.transform(train_lmnn_vectors) lmnn_test_vectors = lmnn.transform(test_vectors) (dic_day_test_labels_partdata, dic_day_estimated_label_partdata, dic_day_accuracy_partdata) \ = classify_and_test(filename_partdata, n_neighbors, lmnn_train_vectors, train_lmnn_labels, lmnn_test_vectors, test_labels) filename_alldata = 'kNN_with_Lmnn_Alldata(k=%d,n=%d)_' % ( n_neighbors, n_train_lmnn) + label lmnn_all_train_vectors = lmnn.transform(train_vectors) (dic_day_test_labels_alldata, dic_day_estimated_label_alldata, dic_day_accuracy_alldata) \ = classify_and_test(filename_alldata, n_neighbors, lmnn_all_train_vectors, train_labels, lmnn_test_vectors, test_labels) return (filename_partdata, dic_day_test_labels_partdata, dic_day_estimated_label_partdata, dic_day_accuracy_partdata, \ filename_alldata, dic_day_test_labels_alldata, dic_day_estimated_label_alldata, dic_day_accuracy_alldata)
def test_lmnn(self): self.assertEqual( remove_spaces(str(metric_learn.LMNN())), remove_spaces( "LMNN(convergence_tol=0.001, init=None, k=3, " "learn_rate=1e-07, " "max_iter=1000, min_iter=50, n_components=None, " "num_dims='deprecated', preprocessor=None, random_state=None, " "regularization=0.5, use_pca='deprecated', verbose=False)"))
def test_lmnn(self): def_kwargs = {'convergence_tol': 0.001, 'init': 'auto', 'k': 3, 'learn_rate': 1e-07, 'max_iter': 1000, 'min_iter': 50, 'n_components': None, 'preprocessor': None, 'random_state': None, 'regularization': 0.5, 'verbose': False} nndef_kwargs = {'convergence_tol': 0.01, 'k': 6} merged_kwargs = sk_repr_kwargs(def_kwargs, nndef_kwargs) self.assertEqual( remove_spaces(str(metric_learn.LMNN(convergence_tol=0.01, k=6))), remove_spaces(f"LMNN({merged_kwargs})"))
def __init__(self, embedding_method): self.embedding_method = embedding_method if embedding_method == "MLKR": learn_metric = mkl.MLKR(n_components=2, init="auto") elif embedding_method == "LFDA": learn_metric = mkl.LFDA(n_components=2, k=10, embedding_type="orthonormalized") # weighted, orthonormalized elif embedding_method == "LMNN": learn_metric = mkl.LMNN(k=10, learn_rate=0.1, n_components=3) # k: number of neighbors self.learn_metric = learn_metric
def __matrix_m(self): X = self.emb_train[:, :-1] Y = self.emb_train[:, -1] # setting up LMNN lmnn = metric_learn.LMNN(k=self.metric_k, learn_rate=1e-2, verbose=True) # fit the data lmnn.fit(X, Y) # transform our input space X_lmnn = lmnn.transform() matrix_m = lmnn.metric() np.save('pickled_files/matrix_m_{}'.format(metric_k), matrix_m) self.__lmnn_knn(matrix_m)
# You'll notice that the points from the same labels are closer together, # but they are not necessary in a same cluster. This is particular to LMNN # and we'll see that some other algorithms implicitly enforce points from # the same class to cluster together. # # - See more in the :ref:`User Guide <lmnn>` # - See more in the documentation of the class :py:class:`LMNN # <metric_learn.LMNN>` ###################################################################### # Fit and then transform! # ----------------------- # # setting up LMNN lmnn = metric_learn.LMNN(n_neighbors=5, learn_rate=1e-6) # fit the data! lmnn.fit(X, y) # transform our input space X_lmnn = lmnn.transform(X) ###################################################################### # So what have we learned? The matrix :math:`M` we talked about before. ###################################################################### # Now let us plot the transformed space - this tells us what the original # space looks like after being transformed with the new learned metric. #
def test_lmnn(self): self.assertRegexpMatches( str(metric_learn.LMNN()), r"(python_)?LMNN\(convergence_tol=0.001, k=3, learn_rate=1e-07, " r"max_iter=1000,\n min_iter=50, preprocessor=None, " r"regularization=0.5, use_pca=True,\n verbose=False\)")
# but they are not necessary in a same cluster. This is particular to LMNN # and we'll see that some other algorithms implicitly enforce points from # the same class to cluster together. # # - See more in the :ref:`User Guide <lmnn>` # - See more in the documentation of the class :py:class:`LMNN # <metric_learn.LMNN>` ###################################################################### # Fit and then transform! # ----------------------- # # setting up LMNN lmnn = metric_learn.LMNN(k=5, learn_rate=1e-6) # fit the data! lmnn.fit(X, y) # transform our input space X_lmnn = lmnn.transform(X) ###################################################################### # So what have we learned? The matrix :math:`M` we talked about before. ###################################################################### # Now let us plot the transformed space - this tells us what the original # space looks like after being transformed with the new learned metric.
# ------------------------------------------------------------------------------ # Initialise tr = start() # Trainers pca = PCA(n_components=M_PCA) kernel = RBFSampler(gamma=1.0, n_components=230, random_state=None) tsne = TSNE(n_components=2, perplexity=30.0, early_exaggeration=12.0, learning_rate=200.0, n_iter=250, n_iter_without_progress=100, min_grad_norm=1e-07, metric='euclidean', init='random', verbose=2, random_state=None, method='barnes_hut', angle=0.5) lmnn = metric_learn.LMNN(k=3, min_iter=1, max_iter=10, learn_rate=1e-6, convergence_tol=1e-3, use_pca=False, verbose=True) mmc = metric_learn.mmc.MMC_Supervised(max_iter=10, convergence_threshold=1e-04, num_labeled=np.inf, num_constraints=100, verbose=True) rca = metric_learn.rca.RCA(num_dims=None, pca_comps=None) chuncky = np.repeat(list(range(1, 25)), 307) mlkr = metric_learn.mlkr.MLKR(num_dims=200, A0=None, tol=1e-6, max_iter=10, verbose=True) itml = metric_learn.itml.ITML_Supervised(gamma=1.0, max_iter=10, convergence_threshold=0.001, num_labeled=np.inf, num_constraints=100, bounds=None,
import numpy as np from sklearn.datasets import load_iris import metric_learn CLASSES = { 'Covariance': metric_learn.Covariance(), 'ITML_Supervised': metric_learn.ITML_Supervised(num_constraints=200), 'LFDA': metric_learn.LFDA(k=2, dim=2), 'LMNN': metric_learn.LMNN(k=5, learn_rate=1e-6, verbose=False), 'LSML_Supervised': metric_learn.LSML_Supervised(num_constraints=200), 'MLKR': metric_learn.MLKR(), 'NCA': metric_learn.NCA(max_iter=700, n_components=2), 'RCA_Supervised': metric_learn.RCA_Supervised(dim=2, num_chunks=30, chunk_size=2), 'SDML_Supervised': metric_learn.SDML_Supervised(num_constraints=1500) } class IrisDataset(object): params = [sorted(CLASSES)] param_names = ['alg']
dic_test_data['knn_svd'] = result[1] dic_test_labels['knn_svd'] = result[2] output_step('\t\tresult: %d/%d, %ds\n' % (result[0], result[3], time.time() - startTime)) del startTime #knn_svd_lmnn startTime = time.time() output_step('\tknn_svd_lmnn (rest: %d): \n' % len(dic_test_labels['knn_svd_lmnn'])) test_vectors = vectorizer.fit_transform( dic_test_data['knn_svd_lmnn']) (train_vectors_svd, test_vectors_svd) = svd_transform(train_vectors, test_vectors) del test_vectors lmnn = metric_learn.LMNN(k=n_neighbors, max_iter=max_iter) lmnn.fit(train_vectors_svd, numpy.asarray(train_binary_labels)) train_vectors_svd_lmnn = lmnn.transform(train_vectors_svd) del train_vectors_svd test_vectors_svd_lmnn = lmnn.transform(test_vectors_svd) del test_vectors_svd result = step_classification(n_neighbors, cur_label, train_vectors_svd_lmnn, train_binary_labels, dic_test_data['knn_svd_lmnn'], test_vectors_svd_lmnn, dic_test_labels['knn_svd_lmnn']) del train_vectors_svd_lmnn, test_vectors_svd_lmnn dic_n_right['knn_svd_lmnn'] += result[0] dic_test_data['knn_svd_lmnn'] = result[1] dic_test_labels['knn_svd_lmnn'] = result[2]
import numpy as np from sklearn.datasets import load_iris import metric_learn CLASSES = { 'Covariance': metric_learn.Covariance(), 'ITML_Supervised': metric_learn.ITML_Supervised(n_constraints=200), 'LFDA': metric_learn.LFDA(k=2, dim=2), 'LMNN': metric_learn.LMNN(n_neighbors=5, learn_rate=1e-6, verbose=False), 'LSML_Supervised': metric_learn.LSML_Supervised(n_constraints=200), 'MLKR': metric_learn.MLKR(), 'NCA': metric_learn.NCA(max_iter=700, n_components=2), 'RCA_Supervised': metric_learn.RCA_Supervised(dim=2, n_chunks=30, chunk_size=2), 'SDML_Supervised': metric_learn.SDML_Supervised(n_constraints=1500) } class IrisDataset(object): params = [sorted(CLASSES)] param_names = ['alg'] def setup(self, alg): iris_data = load_iris() self.iris_points = iris_data['data'] self.iris_labels = iris_data['target'] def time_fit(self, alg): np.random.seed(5555) CLASSES[alg].fit(self.iris_points, self.iris_labels)
# rank_accuracies, mAP = evaluate_metric(X_test_pca.T, y_test, # X_test_pca.T, y_test, # metric ='mahalanobis', # parameters = M) # # # rank_accuracies_l_2.append(rank_accuracies) # mAP_l_2.append(mAP) # metric_l_2.append('Learnt Mahalanobis (Red. Set)') # # # # # import metric_learn # lmnn = metric_learn.LMNN(k=3, learn_rate=1e-6, max_iter=50) lmnn.fit(X_train_pca, y_train.T) M = lmnn.metric() print('Metric learnt-LMNN') rank_accuracies, mAP = evaluate_metric(X_test_pca.T, y_test, X_test_pca.T, y_test, metric='mahalanobis', parameters=M) rank_accuracies_l_2.append(rank_accuracies) mAP_l_2.append(mAP) metric_l_2.append('Learnt LMNN')
def lmnn(self, train_X, train_y, test_X, k): learner = ml.LMNN(k=k) train_X = learner.fit_transform(train_X, train_y) test_X = learner.transform(test_X) return train_X, test_X
def test_lmnn(self): self.assertEqual( remove_spaces(str(metric_learn.LMNN(convergence_tol=0.01, k=6))), remove_spaces("LMNN(convergence_tol=0.01, k=6)"))