def iris_LFDA(x_data, y_data):
x_shuffle, y_shuffle = shuffle_data(x_data, y_data)
x_fold = []
y_fold = []
for i in range(4):
x_fold.append(x_shuffle[30 * i:30 * (i + 1), :])
y_fold.append(y_shuffle[30 * i:30 * (i + 1)])
x_fold.append(x_shuffle[120:, :])
y_fold.append(y_shuffle[120:])
accuracy = []
for i in range(5):
temp = range(5)
temp.remove(i)
x_train = np.concatenate([x_fold[j] for j in temp], axis=0)
y_train = np.concatenate([y_fold[j] for j in temp], axis=0)
x_test = x_fold[i]
y_test = y_fold[i]
class_result = []
lfda = ml.LFDA(k=2, dim=3)
lfda.fit(x_train, y_train)
result_y = result_y = lfda.transform(x_test)
class_result = []
for k in range(len(result_y)):
class_result.append(k_NN_classifier(result_y[k], result_y, y_test))
accuracy.append(class_accuracy(class_result, y_test))
return accuracy
def test_lfda(self):
def_kwargs = {'embedding_type': 'weighted', 'k': None,
'n_components': None, 'preprocessor': None}
nndef_kwargs = {'k': 2}
merged_kwargs = sk_repr_kwargs(def_kwargs, nndef_kwargs)
self.assertEqual(remove_spaces(str(metric_learn.LFDA(k=2))),
remove_spaces(f"LFDA({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 test_string_repr(self):
# we don't test LMNN here because it could be python_LMNN
self.assertEqual(str(metric_learn.Covariance()), "Covariance()")
self.assertEqual(str(metric_learn.NCA()),
"NCA(learning_rate=0.01, max_iter=100, num_dims=None)")
self.assertEqual(str(metric_learn.LFDA()),
"LFDA(dim=None, k=7, metric='weighted')")
self.assertEqual(str(metric_learn.ITML()), """
ITML(convergence_threshold=0.001, gamma=1.0, max_iters=1000, verbose=False)
""".strip('\n'))
self.assertEqual(str(metric_learn.ITML_Supervised()), """
ITML_Supervised(A0=None, bounds=None, convergence_threshold=0.001, gamma=1.0,
max_iters=1000, num_constraints=None, num_labeled=inf,
verbose=False)
""".strip('\n'))
self.assertEqual(str(metric_learn.LSML()),
"LSML(max_iter=1000, tol=0.001, verbose=False)")
self.assertEqual(str(metric_learn.LSML_Supervised()), """
LSML_Supervised(max_iter=1000, num_constraints=None, num_labeled=inf,
prior=None, tol=0.001, verbose=False, weights=None)
""".strip('\n'))
self.assertEqual(str(metric_learn.SDML()), """
SDML(balance_param=0.5, sparsity_param=0.01, use_cov=True, verbose=False)
""".strip('\n'))
self.assertEqual(str(metric_learn.SDML_Supervised()), """
SDML_Supervised(balance_param=0.5, num_constraints=None, num_labeled=inf,
sparsity_param=0.01, use_cov=True, verbose=False)
""".strip('\n'))
self.assertEqual(str(metric_learn.RCA()), "RCA(dim=None)")
self.assertEqual(str(metric_learn.RCA_Supervised()),
"RCA_Supervised(chunk_size=2, dim=None, num_chunks=100)")
self.assertEqual(str(metric_learn.MLKR()), """
MLKR(A0=None, alpha=0.0001, epsilon=0.01, max_iter=1000, num_dims=None)
""".strip('\n'))
###################################################################### # Local Fisher Discriminant Analysis # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ # # LFDA is a linear supervised dimensionality reduction method. It is # particularly useful when dealing with multimodality, where one ore more # classes consist of separate clusters in input space. The core # optimization problem of LFDA is solved as a generalized eigenvalue # problem. Like LMNN, and NCA, this algorithm does not try to cluster points # from the same class in a unique cluster. # # - See more in the :ref:`User Guide <lfda>` # - See more in the documentation of the class :py:class:`LFDA # <metric_learn.LFDA>` lfda = metric_learn.LFDA(k=2, n_components=2) X_lfda = lfda.fit_transform(X, y) plot_tsne(X_lfda, y) ###################################################################### # Relative Components Analysis # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ # # RCA is another one of the older algorithms. It learns a full rank # Mahalanobis distance metric based on a weighted sum of in-class # covariance matrices. It applies a global linear transformation to assign # large weights to relevant dimensions and low weights to irrelevant # dimensions. Those relevant dimensions are estimated using "chunklets", # subsets of points that are known to belong to the same class. #
def test_lfda(self):
self.assertEqual(str(metric_learn.LFDA()),
"LFDA(embedding_type='weighted', k=None, num_dims=None, "
"preprocessor=None)")
def test_lfda(self):
self.assertEqual(
remove_spaces(str(metric_learn.LFDA())),
remove_spaces("LFDA(embedding_type='weighted', k=None, "
"n_components=None, num_dims='deprecated',"
"preprocessor=None)"))
###################################################################### # Local Fisher Discriminant Analysis # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ # # LFDA is a linear supervised dimensionality reduction method. It is # particularly useful when dealing with multimodality, where one ore more # classes consist of separate clusters in input space. The core # optimization problem of LFDA is solved as a generalized eigenvalue # problem. Like LMNN, and NCA, this algorithm does not try to cluster points # from the same class in a unique cluster. # # - See more in the :ref:`User Guide <lfda>` # - See more in the documentation of the class :py:class:`LFDA # <metric_learn.LFDA>` lfda = metric_learn.LFDA(k=2, num_dims=2) X_lfda = lfda.fit_transform(X, y) plot_tsne(X_lfda, y) ###################################################################### # Relative Components Analysis # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ # # RCA is another one of the older algorithms. It learns a full rank # Mahalanobis distance metric based on a weighted sum of in-class # covariance matrices. It applies a global linear transformation to assign # large weights to relevant dimensions and low weights to irrelevant # dimensions. Those relevant dimensions are estimated using "chunklets", # subsets of points that are known to belong to the same class.
def test_lfda(self):
self.assertEqual(str(metric_learn.LFDA()),
"LFDA(k=None, metric='weighted', num_dims=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']
def lfda(self, train_X, train_y, test_X, k, dims):
learner = ml.LFDA(num_dims=dims, k=k)
train_X = learner.fit_transform(train_X, train_y)
test_X = learner.transform(test_X)
return train_X, test_X
def test_lfda(self):
self.assertEqual(remove_spaces(str(metric_learn.LFDA(k=2))),
remove_spaces("LFDA(k=2)"))
