Define distance consistently as (x-y)^T*M*(x-y)

Fixes the transformes returned by ITML and LSML.

The following now holds also for ITML, LSML, SDML and the covariance method:

    learner.transformer().T.dot(learner.transformer()) == learner.metric()

Author: Björn Barz

README.rst

@@ -42,9 +42,9 @@ default implementations for the methods ``metric``, ``transformer``, and
 For an instance of a metric learner named ``foo`` learning from a set of
 ``d``-dimensional points, ``foo.metric()`` returns a ``d x d``
 matrix ``M`` such that the distance between vectors ``x`` and ``y`` is
-expressed ``sqrt((x-y).dot(inv(M)).dot(x-y))``.
+expressed ``sqrt((x-y).dot(M).dot(x-y))``.
 Using scipy's ``pdist`` function, this would look like
-``pdist(X, metric='mahalanobis', VI=inv(foo.metric()))``.
+``pdist(X, metric='mahalanobis', VI=foo.metric())``.
 
 In the same scenario, ``foo.transformer()`` returns a ``d x d``
 matrix ``L`` such that a vector ``x`` can be represented in the learned

metric_learn/base_metric.py

@@ -22,13 +22,13 @@ def metric(self):
   def transformer(self):
     """Computes the transformation matrix from the Mahalanobis matrix.
 
-    L = inv(cholesky(M))
+    L = cholesky(M).T
 
     Returns
     -------
-    L : (d x d) matrix
+    L : upper triangular (d x d) matrix
     """
-    return inv(cholesky(self.metric()))
+    return cholesky(self.metric()).T
 
   def transform(self, X=None):
     """Applies the metric transformation.

metric_learn/covariance.py

@@ -28,5 +28,9 @@ def fit(self, X, y=None):
     y : unused
     """
     self.X_ = check_array(X, ensure_min_samples=2)
-    self.M_ = np.cov(self.X_.T)
+    self.M_ = np.cov(self.X_, rowvar = False)
+    if self.M_.ndim == 0:
+      self.M_ = 1./self.M_
+    else:
+      self.M_ = np.linalg.inv(self.M_)
     return self

metric_learn/lsml.py

@@ -26,7 +26,7 @@ def __init__(self, tol=1e-3, max_iter=1000, prior=None, verbose=False):
     tol : float, optional
     max_iter : int, optional
     prior : (d x d) matrix, optional
-        guess at a metric [default: covariance(X)]
+        guess at a metric [default: inv(covariance(X))]
     verbose : bool, optional
         if True, prints information while learning
     """
@@ -48,7 +48,11 @@ def _prepare_inputs(self, X, constraints, weights):
       self.w_ = weights
     self.w_ /= self.w_.sum()  # weights must sum to 1
     if self.prior is None:
-      self.M_ = np.cov(X.T)
+      self.M_ = np.cov(X, rowvar = False)
+      if self.M_.ndim == 0:
+        self.M_ = 1./self.M_
+      else:
+        self.M_ = np.linalg.inv(self.M_)
     else:
       self.M_ = self.prior
 

metric_learn/sdml.py

@@ -47,7 +47,7 @@ def _prepare_inputs(self, X, W):
     W = check_array(W, accept_sparse=True)
     # set up prior M
     if self.use_cov:
-      self.M_ = np.cov(X.T)
+      self.M_ = pinvh(np.cov(X, rowvar = False))
     else:
       self.M_ = np.identity(X.shape[1])
     L = laplacian(W, normed=False)
@@ -72,11 +72,11 @@ def fit(self, X, W):
         Returns the instance.
     """
     loss_matrix = self._prepare_inputs(X, W)
-    P = pinvh(self.M_) + self.balance_param * loss_matrix
+    P = self.M_ + self.balance_param * loss_matrix
     emp_cov = pinvh(P)
     # hack: ensure positive semidefinite
     emp_cov = emp_cov.T.dot(emp_cov)
-    self.M_, _ = graph_lasso(emp_cov, self.sparsity_param, verbose=self.verbose)
+    _, self.M_ = graph_lasso(emp_cov, self.sparsity_param, verbose=self.verbose)
     return self
 
 

test/metric_learn_test.py

@@ -57,7 +57,7 @@ def test_iris(self):
     itml.fit(self.iris_points, self.iris_labels)
 
     csep = class_separation(itml.transform(), self.iris_labels)
-    self.assertLess(csep, 0.4)  # it's not great
+    self.assertLess(csep, 0.2)
 
 
 class TestLMNN(MetricTestCase):