Rename transformer_ to components_ (#230)

Author: bellet

doc/introduction.rst

@@ -135,7 +135,7 @@ to the following resources:
       arrays and outputs the learned metric score on these two points
 ..    :math:`M = L^{\top}L` such that distance between vectors ``x`` and
 ..    ``y`` can be computed as :math:`\sqrt{\left(x-y\right)M\left(x-y\right)}`.
-.. -  ``transformer_from_metric(metric)``, which returns a transformation matrix
+.. -  ``components_from_metric(metric)``, which returns a transformation matrix
 ..    :math:`L \in \mathbb{R}^{D \times d}`, which can be used to convert a
 ..    data matrix :math:`X \in \mathbb{R}^{n \times d}` to the
 ..    :math:`D`-dimensional learned metric space :math:`X L^{\top}`,

metric_learn/_util.py

@@ -375,7 +375,7 @@ def _check_sdp_from_eigen(w, tol=None):
   return True
 
 
-def transformer_from_metric(metric, tol=None):
+def components_from_metric(metric, tol=None):
   """Returns the transformation matrix from the Mahalanobis matrix.
 
   Returns the transformation matrix from the Mahalanobis matrix, i.e. the
@@ -429,10 +429,10 @@ def validate_vector(u, dtype=None):
   return u
 
 
-def _initialize_transformer(n_components, input, y=None, init='auto',
-                            verbose=False, random_state=None,
-                            has_classes=True):
-  """Returns the initial transformer to be used depending on the arguments.
+def _initialize_components(n_components, input, y=None, init='auto',
+                           verbose=False, random_state=None,
+                           has_classes=True):
+  """Returns the initial transformation to be used depending on the arguments.
 
   Parameters
   ----------
@@ -503,8 +503,8 @@ def _initialize_transformer(n_components, input, y=None, init='auto',
 
   Returns
   -------
-  init_transformer : `numpy.ndarray`
-    The initial transformer to use.
+  init_components : `numpy.ndarray`
+    The initial transformation to use.
   """
   # if we are doing a regression we cannot use lda:
   n_features = input.shape[-1]

metric_learn/base_metric.py

@@ -177,7 +177,7 @@ class MahalanobisMixin(six.with_metaclass(ABCMeta, BaseMetricLearner,
 
   Attributes
   ----------
-  transformer_ : `numpy.ndarray`, shape=(n_components, n_features)
+  components_ : `numpy.ndarray`, shape=(n_components, n_features)
       The learned linear transformation ``L``.
   """
 
@@ -243,10 +243,10 @@ def transform(self, X):
     X_checked = check_input(X, type_of_inputs='classic', estimator=self,
                              preprocessor=self.preprocessor_,
                              accept_sparse=True)
-    return X_checked.dot(self.transformer_.T)
+    return X_checked.dot(self.components_.T)
 
   def get_metric(self):
-    transformer_T = self.transformer_.T.copy()
+    components_T = self.components_.T.copy()
 
     def metric_fun(u, v, squared=False):
       """This function computes the metric between u and v, according to the
@@ -271,7 +271,7 @@ def metric_fun(u, v, squared=False):
       """
       u = validate_vector(u)
       v = validate_vector(v)
-      transformed_diff = (u - v).dot(transformer_T)
+      transformed_diff = (u - v).dot(components_T)
       dist = np.dot(transformed_diff, transformed_diff.T)
       if not squared:
         dist = np.sqrt(dist)
@@ -298,7 +298,7 @@ def get_mahalanobis_matrix(self):
     M : `numpy.ndarray`, shape=(n_features, n_features)
       The copy of the learned Mahalanobis matrix.
     """
-    return self.transformer_.T.dot(self.transformer_)
+    return self.components_.T.dot(self.components_)
 
 
 class _PairsClassifierMixin(BaseMetricLearner):
@@ -333,7 +333,7 @@ def predict(self, pairs):
     y_predicted : `numpy.ndarray` of floats, shape=(n_constraints,)
       The predicted learned metric value between samples in every pair.
     """
-    check_is_fitted(self, ['threshold_', 'transformer_'])
+    check_is_fitted(self, ['threshold_', 'components_'])
     return 2 * (- self.decision_function(pairs) <= self.threshold_) - 1
 
   def decision_function(self, pairs):
@@ -599,7 +599,7 @@ def predict(self, quadruplets):
     prediction : `numpy.ndarray` of floats, shape=(n_constraints,)
       Predictions of the ordering of pairs, for each quadruplet.
     """
-    check_is_fitted(self, 'transformer_')
+    check_is_fitted(self, 'components_')
     quadruplets = check_input(quadruplets, type_of_inputs='tuples',
                               preprocessor=self.preprocessor_,
                               estimator=self, tuple_size=self._tuple_size)

metric_learn/covariance.py

@@ -8,7 +8,7 @@
 from sklearn.base import TransformerMixin
 
 from .base_metric import MahalanobisMixin
-from ._util import transformer_from_metric
+from ._util import components_from_metric
 
 
 class Covariance(MahalanobisMixin, TransformerMixin):
@@ -24,9 +24,9 @@ class Covariance(MahalanobisMixin, TransformerMixin):
 
   Attributes
   ----------
-  transformer_ : `numpy.ndarray`, shape=(n_features, n_features)
+  components_ : `numpy.ndarray`, shape=(n_features, n_features)
       The linear transformation ``L`` deduced from the learned Mahalanobis
-      metric (See function `transformer_from_metric`.)
+      metric (See function `components_from_metric`.)
 
   Examples
   --------
@@ -53,5 +53,5 @@ def fit(self, X, y=None):
     else:
       M = scipy.linalg.pinvh(M)
 
-    self.transformer_ = transformer_from_metric(np.atleast_2d(M))
+    self.components_ = components_from_metric(np.atleast_2d(M))
     return self

metric_learn/itml.py

@@ -12,7 +12,7 @@
 from sklearn.base import TransformerMixin
 from .base_metric import _PairsClassifierMixin, MahalanobisMixin
 from .constraints import Constraints, wrap_pairs
-from ._util import transformer_from_metric, _initialize_metric_mahalanobis
+from ._util import components_from_metric, _initialize_metric_mahalanobis
 
 
 class _BaseITML(MahalanobisMixin):
@@ -105,7 +105,7 @@ def _fit(self, pairs, y, bounds=None):
       print('itml converged at iter: %d, conv = %f' % (it, conv))
     self.n_iter_ = it
 
-    self.transformer_ = transformer_from_metric(A)
+    self.components_ = components_from_metric(A)
     return self
 
 
@@ -186,9 +186,9 @@ class ITML(_BaseITML, _PairsClassifierMixin):
   n_iter_ : `int`
       The number of iterations the solver has run.
 
-  transformer_ : `numpy.ndarray`, shape=(n_features, n_features)
+  components_ : `numpy.ndarray`, shape=(n_features, n_features)
       The linear transformation ``L`` deduced from the learned Mahalanobis
-      metric (See function `transformer_from_metric`.)
+      metric (See function `components_from_metric`.)
 
   threshold_ : `float`
       If the distance metric between two points is lower than this threshold,
@@ -329,9 +329,9 @@ class ITML_Supervised(_BaseITML, TransformerMixin):
   n_iter_ : `int`
       The number of iterations the solver has run.
 
-  transformer_ : `numpy.ndarray`, shape=(n_features, n_features)
+  components_ : `numpy.ndarray`, shape=(n_features, n_features)
       The linear transformation ``L`` deduced from the learned Mahalanobis
-      metric (See function `transformer_from_metric`.)
+      metric (See function `components_from_metric`.)
 
   See Also
   --------

metric_learn/lfda.py

@@ -51,7 +51,7 @@ class LFDA(MahalanobisMixin, TransformerMixin):
 
   Attributes
   ----------
-  transformer_ : `numpy.ndarray`, shape=(n_components, n_features)
+  components_ : `numpy.ndarray`, shape=(n_components, n_features)
       The learned linear transformation ``L``.
 
   Examples
@@ -155,7 +155,7 @@ def fit(self, X, y):
     elif self.embedding_type == 'orthonormalized':
        vecs, _ = np.linalg.qr(vecs)
 
-    self.transformer_ = vecs.T
+    self.components_ = vecs.T
     return self
 
 

metric_learn/lmnn.py

@@ -12,7 +12,7 @@
 from sklearn.metrics import euclidean_distances
 from sklearn.base import TransformerMixin
 
-from ._util import _initialize_transformer, _check_n_components
+from ._util import _initialize_components, _check_n_components
 from .base_metric import MahalanobisMixin
 
 
@@ -117,7 +117,7 @@ class LMNN(MahalanobisMixin, TransformerMixin):
   n_iter_ : `int`
       The number of iterations the solver has run.
 
-  transformer_ : `numpy.ndarray`, shape=(n_components, n_features)
+  components_ : `numpy.ndarray`, shape=(n_components, n_features)
       The learned linear transformation ``L``.
 
   Examples
@@ -199,9 +199,9 @@ def fit(self, X, y):
       init = 'auto'
     else:
       init = self.init
-    self.transformer_ = _initialize_transformer(output_dim, X, y, init,
-                                                self.verbose,
-                                                self.random_state)
+    self.components_ = _initialize_components(output_dim, X, y, init,
+                                              self.verbose,
+                                              self.random_state)
     required_k = np.bincount(label_inds).min()
     if self.k > required_k:
       raise ValueError('not enough class labels for specified k'
@@ -226,7 +226,7 @@ def fit(self, X, y):
       a2[nn_idx] = np.array([])
 
     # initialize L
-    L = self.transformer_
+    L = self.components_
 
     # first iteration: we compute variables (including objective and gradient)
     #  at initialization point
@@ -281,7 +281,7 @@ def fit(self, X, y):
         print("LMNN didn't converge in %d steps." % self.max_iter)
 
     # store the last L
-    self.transformer_ = L
+    self.components_ = L
     self.n_iter_ = it
     return self
 

metric_learn/lsml.py

@@ -12,7 +12,7 @@
 
 from .base_metric import _QuadrupletsClassifierMixin, MahalanobisMixin
 from .constraints import Constraints
-from ._util import transformer_from_metric, _initialize_metric_mahalanobis
+from ._util import components_from_metric, _initialize_metric_mahalanobis
 
 
 class _BaseLSML(MahalanobisMixin):
@@ -94,7 +94,7 @@ def _fit(self, quadruplets, weights=None):
         print("Didn't converge after", it, "iterations. Final loss:", s_best)
     self.n_iter_ = it
 
-    self.transformer_ = transformer_from_metric(M)
+    self.components_ = components_from_metric(M)
     return self
 
   def _comparison_loss(self, metric, vab, vcd):
@@ -180,9 +180,9 @@ class LSML(_BaseLSML, _QuadrupletsClassifierMixin):
   n_iter_ : `int`
       The number of iterations the solver has run.
 
-  transformer_ : `numpy.ndarray`, shape=(n_features, n_features)
+  components_ : `numpy.ndarray`, shape=(n_features, n_features)
       The linear transformation ``L`` deduced from the learned Mahalanobis
-      metric (See function `transformer_from_metric`.)
+      metric (See function `components_from_metric`.)
 
   Examples
   --------
@@ -294,9 +294,9 @@ class LSML_Supervised(_BaseLSML, TransformerMixin):
   n_iter_ : `int`
       The number of iterations the solver has run.
 
-  transformer_ : `numpy.ndarray`, shape=(n_features, n_features)
+  components_ : `numpy.ndarray`, shape=(n_features, n_features)
       The linear transformation ``L`` deduced from the learned Mahalanobis
-      metric (See function `transformer_from_metric`.)
+      metric (See function `components_from_metric`.)
   """
 
   def __init__(self, tol=1e-3, max_iter=1000, prior=None,

metric_learn/mlkr.py

@@ -15,7 +15,7 @@
 
 from metric_learn._util import _check_n_components
 from .base_metric import MahalanobisMixin
-from ._util import _initialize_transformer
+from ._util import _initialize_components
 
 EPS = np.finfo(float).eps
 
@@ -103,7 +103,7 @@ class MLKR(MahalanobisMixin, TransformerMixin):
   n_iter_ : `int`
       The number of iterations the solver has run.
 
-  transformer_ : `numpy.ndarray`, shape=(n_components, n_features)
+  components_ : `numpy.ndarray`, shape=(n_components, n_features)
       The learned linear transformation ``L``.
 
   Examples
@@ -182,10 +182,10 @@ def fit(self, X, y):
         init = 'auto'
       else:
         init = self.init
-      A = _initialize_transformer(m, X, y, init=init,
-                                  random_state=self.random_state,
-                                  # MLKR works on regression targets:
-                                  has_classes=False)
+      A = _initialize_components(m, X, y, init=init,
+                                 random_state=self.random_state,
+                                 # MLKR works on regression targets:
+                                 has_classes=False)
 
       # Measure the total training time
       train_time = time.time()
@@ -194,7 +194,7 @@ def fit(self, X, y):
       res = minimize(self._loss, A.ravel(), (X, y), method='L-BFGS-B',
                      jac=True, tol=self.tol,
                      options=dict(maxiter=self.max_iter))
-      self.transformer_ = res.x.reshape(A.shape)
+      self.components_ = res.x.reshape(A.shape)
 
       # Stop timer
       train_time = time.time() - train_time

metric_learn/mmc.py

@@ -9,7 +9,7 @@
 
 from .base_metric import _PairsClassifierMixin, MahalanobisMixin
 from .constraints import Constraints, wrap_pairs
-from ._util import transformer_from_metric, _initialize_metric_mahalanobis
+from ._util import components_from_metric, _initialize_metric_mahalanobis
 
 
 class _BaseMMC(MahalanobisMixin):
@@ -185,7 +185,7 @@ def _fit_full(self, pairs, y):
     self.A_[:] = A_old
     self.n_iter_ = cycle
 
-    self.transformer_ = transformer_from_metric(self.A_)
+    self.components_ = components_from_metric(self.A_)
     return self
 
   def _fit_diag(self, pairs, y):
@@ -246,7 +246,7 @@ def _fit_diag(self, pairs, y):
 
     self.A_ = np.diag(w)
 
-    self.transformer_ = transformer_from_metric(self.A_)
+    self.components_ = components_from_metric(self.A_)
     return self
 
   def _fD(self, neg_pairs, A):
@@ -409,9 +409,9 @@ class MMC(_BaseMMC, _PairsClassifierMixin):
   n_iter_ : `int`
       The number of iterations the solver has run.
 
-  transformer_ : `numpy.ndarray`, shape=(n_features, n_features)
+  components_ : `numpy.ndarray`, shape=(n_features, n_features)
       The linear transformation ``L`` deduced from the learned Mahalanobis
-      metric (See function `transformer_from_metric`.)
+      metric (See function `components_from_metric`.)
 
   threshold_ : `float`
       If the distance metric between two points is lower than this threshold,
@@ -550,9 +550,9 @@ class MMC_Supervised(_BaseMMC, TransformerMixin):
   n_iter_ : `int`
       The number of iterations the solver has run.
 
-  transformer_ : `numpy.ndarray`, shape=(n_features, n_features)
+  components_ : `numpy.ndarray`, shape=(n_features, n_features)
       The linear transformation ``L`` deduced from the learned Mahalanobis
-      metric (See function `transformer_from_metric`.)
+      metric (See function `components_from_metric`.)
   """
 
   def __init__(self, max_iter=100, max_proj=10000, convergence_threshold=1e-6,