def test_mlkr(self):
self.assertEqual(
remove_spaces(str(metric_learn.MLKR())),
remove_spaces("MLKR(A0='deprecated', init=None,"
"max_iter=1000, n_components=None,"
"num_dims='deprecated', preprocessor=None,"
"random_state=None, tol=None, "
"verbose=False)"))
def test_mlkr(self):
def_kwargs = {'init': 'auto', 'max_iter': 1000,
'n_components': None, 'preprocessor': None,
'random_state': None, 'tol': None, 'verbose': False}
nndef_kwargs = {'max_iter': 777}
merged_kwargs = sk_repr_kwargs(def_kwargs, nndef_kwargs)
self.assertEqual(remove_spaces(str(metric_learn.MLKR(max_iter=777))),
remove_spaces(f"MLKR({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'))
# regression target from a linear model), and two are random noise with the
# same magnitude.
X_reg, y_reg = make_regression(n_samples=100,
n_informative=3,
n_features=5,
shuffle=True)
######################################################################
# Let's plot the dataset as is
plot_tsne(X_reg, y_reg, plt.cm.Oranges)
######################################################################
# And let's plot the dataset after transformation by MLKR:
mlkr = metric_learn.MLKR()
X_mlkr = mlkr.fit_transform(X_reg, y_reg)
plot_tsne(X_mlkr, y_reg, plt.cm.Oranges)
######################################################################
# Points that have the same value to regress are now closer to each
# other ! This would improve the performance of
# `sklearn.neighbors.KNeighborsRegressor` for instance.
######################################################################
# Metric Learning from Weaker Supervision
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
#
# To learn the metric, so far we have always given the labels of the
# data to supervise the algorithms. However, in many applications,
# it is easier to obtain information about whether two samples are
def test_mlkr(self):
self.assertEqual(str(metric_learn.MLKR()),
"MLKR(A0=None, max_iter=1000, num_dims=None, "
"preprocessor=None, tol=None,\n verbose=False)")
def test_mlkr(self):
self.assertEqual(
str(metric_learn.MLKR()),
"MLKR(A0=None, alpha=0.0001, epsilon=0.01, "
"max_iter=1000, num_dims=None)")
def metricLearnRegression(xVals, yVals):
model = metric_learn.MLKR()
#model = metric_learn.MLKR(num_dims=xVals.shape[1])
model.fit(xVals, yVals.ravel())
return model
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 setup(self, alg):
iris_data = load_iris()
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)
def mlkr(self, train_X, train_y, test_X, dims):
learner = ml.MLKR(num_dims=dims)
train_X = learner.fit_transform(train_X, train_y)
test_X = learner.transform(test_X)
return train_X, test_X
def test_mlkr(self):
self.assertEqual(remove_spaces(str(metric_learn.MLKR(max_iter=777))),
remove_spaces("MLKR(max_iter=777)"))
