metric_learn
.MLKR
- class metric_learn.MLKR(n_components=None, init='auto', tol=None, max_iter=1000, verbose=False, preprocessor=None, random_state=None)[source]
Metric Learning for Kernel Regression (MLKR)
MLKR is an algorithm for supervised metric learning, which learns a distance function by directly minimizing the leave-one-out regression error. This algorithm can also be viewed as a supervised variation of PCA and can be used for dimensionality reduction and high dimensional data visualization.
Read more in the User Guide.
- Parameters:
- n_componentsint or None, optional (default=None)
Dimensionality of reduced space (if None, defaults to dimension of X).
- initstring or numpy array, optional (default=’auto’)
Initialization of the linear transformation. Possible options are ‘auto’, ‘pca’, ‘identity’, ‘random’, and a numpy array of shape (n_features_a, n_features_b).
- ‘auto’
Depending on
n_components
, the most reasonable initialization will be chosen. Ifn_components < min(n_features, n_samples)
, we use ‘pca’, as it projects data in meaningful directions (those of higher variance). Otherwise, we just use ‘identity’.- ‘pca’
n_components
principal components of the inputs passed tofit()
will be used to initialize the transformation. (See sklearn.decomposition.PCA)- ‘identity’
If
n_components
is strictly smaller than the dimensionality of the inputs passed tofit()
, the identity matrix will be truncated to the firstn_components
rows.- ‘random’
The initial transformation will be a random array of shape (n_components, n_features). Each value is sampled from the standard normal distribution.
- numpy array
n_features_b must match the dimensionality of the inputs passed to
fit()
and n_features_a must be less than or equal to that. Ifn_components
is not None, n_features_a must match it.
- tolfloat, optional (default=None)
Convergence tolerance for the optimization.
- max_iterint, optional (default=1000)
Cap on number of conjugate gradient iterations.
- verbosebool, optional (default=False)
Whether to print progress messages or not.
- preprocessorarray-like, shape=(n_samples, n_features) or callable
The preprocessor to call to get tuples from indices. If array-like, tuples will be formed like this: X[indices].
- random_stateint or numpy.RandomState or None, optional (default=None)
A pseudo random number generator object or a seed for it if int. If
init='random'
,random_state
is used to initialize the random transformation. Ifinit='pca'
,random_state
is passed as an argument to PCA when initializing the transformation.
References
[1]K.Q. Weinberger and G. Tesauto. Metric Learning for Kernel Regression. AISTATS 2007.
Examples
>>> from metric_learn import MLKR >>> from sklearn.datasets import load_iris >>> iris_data = load_iris() >>> X = iris_data['data'] >>> Y = iris_data['target'] >>> mlkr = MLKR() >>> mlkr.fit(X, Y)
- Attributes:
- n_iter_int
The number of iterations the solver has run.
- components_numpy.ndarray, shape=(n_components, n_features)
The learned linear transformation
L
.
Methods
fit
(X, y)Fit MLKR model
fit_transform
(X[, y])Fit to data, then transform it.
Returns a copy of the Mahalanobis matrix learned by the metric learner.
Get metadata routing of this object.
Returns a function that takes as input two 1D arrays and outputs the value of the learned metric on these two points.
get_params
([deep])Get parameters for this estimator.
pair_distance
(pairs)Returns the learned Mahalanobis distance between pairs.
pair_score
(pairs)Returns the opposite of the learned Mahalanobis distance between pairs.
score_pairs
(pairs)Returns the learned Mahalanobis distance between pairs.
set_output
(*[, transform])Set output container.
set_params
(**params)Set the parameters of this estimator.
transform
(X)Embeds data points in the learned linear embedding space.
- __init__(n_components=None, init='auto', tol=None, max_iter=1000, verbose=False, preprocessor=None, random_state=None)[source]
- fit_transform(X, y=None, **fit_params)
Fit to data, then transform it.
Fits transformer to X and y with optional parameters fit_params and returns a transformed version of X.
- Parameters:
- Xarray-like of shape (n_samples, n_features)
Input samples.
- yarray-like of shape (n_samples,) or (n_samples, n_outputs), default=None
Target values (None for unsupervised transformations).
- **fit_paramsdict
Additional fit parameters.
- Returns:
- X_newndarray array of shape (n_samples, n_features_new)
Transformed array.
- get_mahalanobis_matrix()
Returns a copy of the Mahalanobis matrix learned by the metric learner.
- Returns:
- Mnumpy.ndarray, shape=(n_features, n_features)
The copy of the learned Mahalanobis matrix.
- get_metadata_routing()
Get metadata routing of this object.
Please check User Guide on how the routing mechanism works.
- Returns:
- routingMetadataRequest
A
MetadataRequest
encapsulating routing information.
- get_metric()
Returns a function that takes as input two 1D arrays and outputs the value of the learned metric on these two points. Depending on the algorithm, it can return a distance or a similarity function between pairs.
This function will be independent from the metric learner that learned it (it will not be modified if the initial metric learner is modified), and it can be directly plugged into the metric argument of scikit-learn’s estimators.
- Returns:
- metric_funfunction
The function described above.
See also
pair_distance
a method that returns the distance between several pairs of points. Unlike get_metric, this is a method of the metric learner and therefore can change if the metric learner changes. Besides, it can use the metric learner’s preprocessor, and works on concatenated arrays.
pair_score
a method that returns the similarity score between several pairs of points. Unlike get_metric, this is a method of the metric learner and therefore can change if the metric learner changes. Besides, it can use the metric learner’s preprocessor, and works on concatenated arrays.
Examples
>>> from metric_learn import NCA >>> from sklearn.datasets import make_classification >>> from sklearn.neighbors import KNeighborsClassifier >>> nca = NCA() >>> X, y = make_classification() >>> nca.fit(X, y) >>> knn = KNeighborsClassifier(metric=nca.get_metric()) >>> knn.fit(X, y) KNeighborsClassifier(algorithm='auto', leaf_size=30, metric=<function MahalanobisMixin.get_metric.<locals>.metric_fun at 0x...>, metric_params=None, n_jobs=None, n_neighbors=5, p=2, weights='uniform')
- get_params(deep=True)
Get parameters for this estimator.
- Parameters:
- deepbool, default=True
If True, will return the parameters for this estimator and contained subobjects that are estimators.
- Returns:
- paramsdict
Parameter names mapped to their values.
- pair_distance(pairs)
Returns the learned Mahalanobis distance between pairs.
This distance is defined as: \(d_M(x, x') = \sqrt{(x-x')^T M (x-x')}\) where
M
is the learned Mahalanobis matrix, for every pair of pointsx
andx'
. This corresponds to the euclidean distance between embeddings of the points in a new space, obtained through a linear transformation. Indeed, we have also: \(d_M(x, x') = \sqrt{(x_e - x_e')^T (x_e- x_e')}\), with \(x_e = L x\) (SeeMahalanobisMixin
).- Parameters:
- pairsarray-like, shape=(n_pairs, 2, n_features) or (n_pairs, 2)
3D Array of pairs to score, with each row corresponding to two points, for 2D array of indices of pairs if the metric learner uses a preprocessor.
- Returns:
- scoresnumpy.ndarray of shape=(n_pairs,)
The learned Mahalanobis distance for every pair.
See also
get_metric
a method that returns a function to compute the metric between two points. The difference with pair_distance is that it works on two 1D arrays and cannot use a preprocessor. Besides, the returned function is independent of the metric learner and hence is not modified if the metric learner is.
- Mahalanobis Distances
The section of the project documentation that describes Mahalanobis Distances.
- pair_score(pairs)
Returns the opposite of the learned Mahalanobis distance between pairs.
- Parameters:
- pairsarray-like, shape=(n_pairs, 2, n_features) or (n_pairs, 2)
3D Array of pairs to score, with each row corresponding to two points, for 2D array of indices of pairs if the metric learner uses a preprocessor.
- Returns:
- scoresnumpy.ndarray of shape=(n_pairs,)
The opposite of the learned Mahalanobis distance for every pair.
See also
get_metric
a method that returns a function to compute the metric between two points. The difference with pair_score is that it works on two 1D arrays and cannot use a preprocessor. Besides, the returned function is independent of the metric learner and hence is not modified if the metric learner is.
- Mahalanobis Distances
The section of the project documentation that describes Mahalanobis Distances.
- score_pairs(pairs)
Returns the learned Mahalanobis distance between pairs.
This distance is defined as: \(d_M(x, x') = \\sqrt{(x-x')^T M (x-x')}\) where
M
is the learned Mahalanobis matrix, for every pair of pointsx
andx'
. This corresponds to the euclidean distance between embeddings of the points in a new space, obtained through a linear transformation. Indeed, we have also: \(d_M(x, x') = \\sqrt{(x_e - x_e')^T (x_e- x_e')}\), with \(x_e = L x\) (SeeMahalanobisMixin
).Deprecated since version 0.7.0: Please use pair_distance instead.
Warning
This method will be removed in 0.8.0. Please refer to pair_distance or pair_score. This change will occur in order to add learners that don’t necessarily learn a Mahalanobis distance.
- Parameters:
- pairsarray-like, shape=(n_pairs, 2, n_features) or (n_pairs, 2)
3D Array of pairs to score, with each row corresponding to two points, for 2D array of indices of pairs if the metric learner uses a preprocessor.
- Returns:
- scoresnumpy.ndarray of shape=(n_pairs,)
The learned Mahalanobis distance for every pair.
See also
get_metric
a method that returns a function to compute the metric between two points. The difference with score_pairs is that it works on two 1D arrays and cannot use a preprocessor. Besides, the returned function is independent of the metric learner and hence is not modified if the metric learner is.
- Mahalanobis Distances
The section of the project documentation that describes Mahalanobis Distances.
- set_output(*, transform=None)
Set output container.
See Introducing the set_output API for an example on how to use the API.
- Parameters:
- transform{“default”, “pandas”}, default=None
Configure output of transform and fit_transform.
“default”: Default output format of a transformer
“pandas”: DataFrame output
None: Transform configuration is unchanged
- Returns:
- selfestimator instance
Estimator instance.
- set_params(**params)
Set the parameters of this estimator.
The method works on simple estimators as well as on nested objects (such as
Pipeline
). The latter have parameters of the form<component>__<parameter>
so that it’s possible to update each component of a nested object.- Parameters:
- **paramsdict
Estimator parameters.
- Returns:
- selfestimator instance
Estimator instance.
- transform(X)
Embeds data points in the learned linear embedding space.
Transforms samples in
X
intoX_embedded
, samples inside a new embedding space such that:X_embedded = X.dot(L.T)
, whereL
is the learned linear transformation (SeeMahalanobisMixin
).- Parameters:
- Xnumpy.ndarray, shape=(n_samples, n_features)
The data points to embed.
- Returns:
- X_embeddednumpy.ndarray, shape=(n_samples, n_components)
The embedded data points.