Revert "[MRG] Move transformer_from_metric to util (scikit-learn-contrib#151)"

This reverts commit 8ffd998.

Author: William de Vazelhes

metric_learn/_util.py

@@ -322,30 +322,3 @@ def check_collapsed_pairs(pairs):
       raise ValueError("{} collapsed pairs found (where the left element is "
                        "the same as the right element), out of {} pairs "
                        "in total.".format(num_ident, pairs.shape[0]))
-
-
-def transformer_from_metric(metric):
-  """Computes the transformation matrix from the Mahalanobis matrix.
-
-  Since by definition the metric `M` is positive semi-definite (PSD), it
-  admits a Cholesky decomposition: L = cholesky(M).T. However, currently the
-  computation of the Cholesky decomposition used does not support
-  non-definite matrices. If the metric is not definite, this method will
-  return L = V.T w^( -1/2), with M = V*w*V.T being the eigenvector
-  decomposition of M with the eigenvalues in the diagonal matrix w and the
-  columns of V being the eigenvectors. If M is diagonal, this method will
-  just return its elementwise square root (since the diagonalization of
-  the matrix is itself).
-
-  Returns
-  -------
-  L : (d x d) matrix
-  """
-
-  if np.allclose(metric, np.diag(np.diag(metric))):
-    return np.sqrt(metric)
-  elif not np.isclose(np.linalg.det(metric), 0):
-    return np.linalg.cholesky(metric).T
-  else:
-    w, V = np.linalg.eigh(metric)
-    return V.T * np.sqrt(np.maximum(0, w[:, None]))

metric_learn/base_metric.py

@@ -1,3 +1,4 @@
+from numpy.linalg import cholesky
 from sklearn.base import BaseEstimator
 from sklearn.utils.validation import _is_arraylike
 from sklearn.metrics import roc_auc_score
@@ -180,6 +181,32 @@ def transform(self, X):
   def metric(self):
     return self.transformer_.T.dot(self.transformer_)
 
+  def transformer_from_metric(self, metric):
+    """Computes the transformation matrix from the Mahalanobis matrix.
+
+    Since by definition the metric `M` is positive semi-definite (PSD), it
+    admits a Cholesky decomposition: L = cholesky(M).T. However, currently the
+    computation of the Cholesky decomposition used does not support
+    non-definite matrices. If the metric is not definite, this method will
+    return L = V.T w^( -1/2), with M = V*w*V.T being the eigenvector
+    decomposition of M with the eigenvalues in the diagonal matrix w and the
+    columns of V being the eigenvectors. If M is diagonal, this method will
+    just return its elementwise square root (since the diagonalization of
+    the matrix is itself).
+
+    Returns
+    -------
+    L : (d x d) matrix
+    """
+
+    if np.allclose(metric, np.diag(np.diag(metric))):
+      return np.sqrt(metric)
+    elif not np.isclose(np.linalg.det(metric), 0):
+      return cholesky(metric).T
+    else:
+      w, V = np.linalg.eigh(metric)
+      return V.T * np.sqrt(np.maximum(0, w[:, None]))
+
 
 class _PairsClassifierMixin(BaseMetricLearner):
 

metric_learn/covariance.py

@@ -13,7 +13,6 @@
 from sklearn.base import TransformerMixin
 
 from .base_metric import MahalanobisMixin
-from ._util import transformer_from_metric
 
 
 class Covariance(MahalanobisMixin, TransformerMixin):
@@ -23,7 +22,7 @@ class Covariance(MahalanobisMixin, TransformerMixin):
   ----------
   transformer_ : `numpy.ndarray`, shape=(num_dims, n_features)
       The linear transformation ``L`` deduced from the learned Mahalanobis
-      metric (See function `transformer_from_metric`.)
+      metric (See :meth:`transformer_from_metric`.)
   """
 
   def __init__(self, preprocessor=None):
@@ -41,5 +40,5 @@ def fit(self, X, y=None):
     else:
       M = np.linalg.inv(M)
 
-    self.transformer_ = transformer_from_metric(np.atleast_2d(M))
+    self.transformer_ = self.transformer_from_metric(np.atleast_2d(M))
     return self

metric_learn/itml.py

@@ -22,7 +22,7 @@
 from sklearn.base import TransformerMixin
 from .base_metric import _PairsClassifierMixin, MahalanobisMixin
 from .constraints import Constraints, wrap_pairs
-from ._util import vector_norm, transformer_from_metric
+from ._util import vector_norm
 
 
 class _BaseITML(MahalanobisMixin):
@@ -125,7 +125,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(self.A_)
+    self.transformer_ = self.transformer_from_metric(self.A_)
     return self
 
 
@@ -136,7 +136,7 @@ class ITML(_BaseITML, _PairsClassifierMixin):
   ----------
   transformer_ : `numpy.ndarray`, shape=(num_dims, n_features)
       The linear transformation ``L`` deduced from the learned Mahalanobis
-      metric (See function `transformer_from_metric`.)
+      metric (See :meth:`transformer_from_metric`.)
   """
 
   def fit(self, pairs, y, bounds=None):
@@ -169,7 +169,7 @@ class ITML_Supervised(_BaseITML, TransformerMixin):
   ----------
   transformer_ : `numpy.ndarray`, shape=(num_dims, n_features)
       The linear transformation ``L`` deduced from the learned Mahalanobis
-      metric (See function `transformer_from_metric`.)
+      metric (See `transformer_from_metric`.)
   """
 
   def __init__(self, gamma=1., max_iter=1000, convergence_threshold=1e-3,

metric_learn/lsml.py

@@ -16,7 +16,6 @@
 
 from .base_metric import _QuadrupletsClassifierMixin, MahalanobisMixin
 from .constraints import Constraints
-from ._util import transformer_from_metric
 
 
 class _BaseLSML(MahalanobisMixin):
@@ -102,7 +101,7 @@ def _fit(self, quadruplets, y=None, weights=None):
         print("Didn't converge after", it, "iterations. Final loss:", s_best)
     self.n_iter_ = it
 
-    self.transformer_ = transformer_from_metric(self.M_)
+    self.transformer_ = self.transformer_from_metric(self.M_)
     return self
 
   def _comparison_loss(self, metric):
@@ -138,7 +137,7 @@ class LSML(_BaseLSML, _QuadrupletsClassifierMixin):
   ----------
   transformer_ : `numpy.ndarray`, shape=(num_dims, n_features)
       The linear transformation ``L`` deduced from the learned Mahalanobis
-      metric (See function `transformer_from_metric`.)
+      metric (See :meth:`transformer_from_metric`.)
   """
 
   def fit(self, quadruplets, weights=None):
@@ -171,7 +170,7 @@ class LSML_Supervised(_BaseLSML, TransformerMixin):
   ----------
   transformer_ : `numpy.ndarray`, shape=(num_dims, n_features)
       The linear transformation ``L`` deduced from the learned Mahalanobis
-      metric (See function `transformer_from_metric`.)
+      metric (See :meth:`transformer_from_metric`.)
   """
 
   def __init__(self, tol=1e-3, max_iter=1000, prior=None,

metric_learn/mmc.py

@@ -25,7 +25,7 @@
 
 from .base_metric import _PairsClassifierMixin, MahalanobisMixin
 from .constraints import Constraints, wrap_pairs
-from ._util import vector_norm, transformer_from_metric
+from ._util import vector_norm
 
 
 class _BaseMMC(MahalanobisMixin):
@@ -206,7 +206,7 @@ def _fit_full(self, pairs, y):
     self.A_[:] = A_old
     self.n_iter_ = cycle
 
-    self.transformer_ = transformer_from_metric(self.A_)
+    self.transformer_ = self.transformer_from_metric(self.A_)
     return self
 
   def _fit_diag(self, pairs, y):
@@ -267,7 +267,7 @@ def _fit_diag(self, pairs, y):
 
     self.A_ = np.diag(w)
 
-    self.transformer_ = transformer_from_metric(self.A_)
+    self.transformer_ = self.transformer_from_metric(self.A_)
     return self
 
   def _fD(self, neg_pairs, A):
@@ -355,7 +355,7 @@ class MMC(_BaseMMC, _PairsClassifierMixin):
   ----------
   transformer_ : `numpy.ndarray`, shape=(num_dims, n_features)
       The linear transformation ``L`` deduced from the learned Mahalanobis
-      metric (See function `transformer_from_metric`.)
+      metric (See :meth:`transformer_from_metric`.)
   """
 
   def fit(self, pairs, y):
@@ -386,7 +386,7 @@ class MMC_Supervised(_BaseMMC, TransformerMixin):
   ----------
   transformer_ : `numpy.ndarray`, shape=(num_dims, n_features)
       The linear transformation ``L`` deduced from the learned Mahalanobis
-      metric (See function `transformer_from_metric`.)
+      metric (See :meth:`transformer_from_metric`.)
   """
 
   def __init__(self, max_iter=100, max_proj=10000, convergence_threshold=1e-6,

metric_learn/sdml.py

@@ -17,7 +17,6 @@
 
 from .base_metric import MahalanobisMixin, _PairsClassifierMixin
 from .constraints import Constraints, wrap_pairs
-from ._util import transformer_from_metric
 
 
 class _BaseSDML(MahalanobisMixin):
@@ -66,7 +65,7 @@ def _fit(self, pairs, y):
     emp_cov = self.M_ + self.balance_param * loss_matrix
     _, self.M_ = graph_lasso(emp_cov, self.sparsity_param, verbose=self.verbose)
 
-    self.transformer_ = transformer_from_metric(self.M_)
+    self.transformer_ = self.transformer_from_metric(self.M_)
     return self
 
 
@@ -77,7 +76,7 @@ class SDML(_BaseSDML, _PairsClassifierMixin):
   ----------
   transformer_ : `numpy.ndarray`, shape=(num_dims, n_features)
       The linear transformation ``L`` deduced from the learned Mahalanobis
-      metric (See function `transformer_from_metric`.)
+      metric (See :meth:`transformer_from_metric`.)
   """
 
   def fit(self, pairs, y):
@@ -108,7 +107,7 @@ class SDML_Supervised(_BaseSDML, TransformerMixin):
   ----------
   transformer_ : `numpy.ndarray`, shape=(num_dims, n_features)
       The linear transformation ``L`` deduced from the learned Mahalanobis
-      metric (See function `transformer_from_metric`.)
+      metric (See :meth:`transformer_from_metric`.)
   """
 
   def __init__(self, balance_param=0.5, sparsity_param=0.01, use_cov=True,