From a3384b1c602fd2dded0d8cb35ab4aa83ef89fa49 Mon Sep 17 00:00:00 2001
From: William de Vazelhes <william.de-vazelhes@inria.fr>
Date: Wed, 9 Jan 2019 14:54:07 +0100
Subject: [PATCH 01/25] MAINT Rename metric() into get_mahalanobis_matrix()

---
 metric_learn/base_metric.py                |  2 +-
 test/metric_learn_test.py                  |  6 +++---
 test/test_transformer_metric_conversion.py | 18 +++++++++---------
 3 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/metric_learn/base_metric.py b/metric_learn/base_metric.py
index 9af79ecc..675a4663 100644
--- a/metric_learn/base_metric.py
+++ b/metric_learn/base_metric.py
@@ -178,7 +178,7 @@ def transform(self, X):
                              accept_sparse=True)
     return X_checked.dot(self.transformer_.T)
 
-  def metric(self):
+  def get_mahalanobis_matrix(self):
     return self.transformer_.T.dot(self.transformer_)
 
   def transformer_from_metric(self, metric):
diff --git a/test/metric_learn_test.py b/test/metric_learn_test.py
index eebce1f9..996bda30 100644
--- a/test/metric_learn_test.py
+++ b/test/metric_learn_test.py
@@ -273,7 +273,7 @@ def test_iris(self):
     self.assertLess(csep, 0.15)
 
     # Sanity checks for learned matrices.
-    self.assertEqual(lfda.metric().shape, (4, 4))
+    self.assertEqual(lfda.get_mahalanobis_matrix().shape, (4, 4))
     self.assertEqual(lfda.transformer_.shape, (2, 4))
 
 
@@ -348,13 +348,13 @@ def test_iris(self):
                 [+0.000868, +0.001468, -0.002021, -0.002879],
                 [-0.001195, -0.002021, +0.002782, +0.003964],
                 [-0.001703, -0.002879, +0.003964, +0.005648]]
-    assert_array_almost_equal(expected, mmc.metric(), decimal=6)
+    assert_array_almost_equal(expected, mmc.get_mahalanobis_matrix(), decimal=6)
 
     # Diagonal metric
     mmc = MMC(diagonal=True)
     mmc.fit(*wrap_pairs(self.iris_points, [a,b,c,d]))
     expected = [0, 0, 1.210220, 1.228596]
-    assert_array_almost_equal(np.diag(expected), mmc.metric(), decimal=6)
+    assert_array_almost_equal(np.diag(expected), mmc.get_mahalanobis_matrix(), decimal=6)
     
     # Supervised Full
     mmc = MMC_Supervised()
diff --git a/test/test_transformer_metric_conversion.py b/test/test_transformer_metric_conversion.py
index ab38d65e..59986011 100644
--- a/test/test_transformer_metric_conversion.py
+++ b/test/test_transformer_metric_conversion.py
@@ -20,60 +20,60 @@ def test_cov(self):
     cov = Covariance()
     cov.fit(self.X)
     L = cov.transformer_
-    assert_array_almost_equal(L.T.dot(L), cov.metric())
+    assert_array_almost_equal(L.T.dot(L), cov.get_mahalanobis_matrix())
 
   def test_lsml_supervised(self):
     seed = np.random.RandomState(1234)
     lsml = LSML_Supervised(num_constraints=200)
     lsml.fit(self.X, self.y, random_state=seed)
     L = lsml.transformer_
-    assert_array_almost_equal(L.T.dot(L), lsml.metric())
+    assert_array_almost_equal(L.T.dot(L), lsml.get_mahalanobis_matrix())
 
   def test_itml_supervised(self):
     seed = np.random.RandomState(1234)
     itml = ITML_Supervised(num_constraints=200)
     itml.fit(self.X, self.y, random_state=seed)
     L = itml.transformer_
-    assert_array_almost_equal(L.T.dot(L), itml.metric())
+    assert_array_almost_equal(L.T.dot(L), itml.get_mahalanobis_matrix())
 
   def test_lmnn(self):
     lmnn = LMNN(k=5, learn_rate=1e-6, verbose=False)
     lmnn.fit(self.X, self.y)
     L = lmnn.transformer_
-    assert_array_almost_equal(L.T.dot(L), lmnn.metric())
+    assert_array_almost_equal(L.T.dot(L), lmnn.get_mahalanobis_matrix())
 
   def test_sdml_supervised(self):
     seed = np.random.RandomState(1234)
     sdml = SDML_Supervised(num_constraints=1500)
     sdml.fit(self.X, self.y, random_state=seed)
     L = sdml.transformer_
-    assert_array_almost_equal(L.T.dot(L), sdml.metric())
+    assert_array_almost_equal(L.T.dot(L), sdml.get_mahalanobis_matrix())
 
   def test_nca(self):
     n = self.X.shape[0]
     nca = NCA(max_iter=(100000//n))
     nca.fit(self.X, self.y)
     L = nca.transformer_
-    assert_array_almost_equal(L.T.dot(L), nca.metric())
+    assert_array_almost_equal(L.T.dot(L), nca.get_mahalanobis_matrix())
 
   def test_lfda(self):
     lfda = LFDA(k=2, num_dims=2)
     lfda.fit(self.X, self.y)
     L = lfda.transformer_
-    assert_array_almost_equal(L.T.dot(L), lfda.metric())
+    assert_array_almost_equal(L.T.dot(L), lfda.get_mahalanobis_matrix())
 
   def test_rca_supervised(self):
     seed = np.random.RandomState(1234)
     rca = RCA_Supervised(num_dims=2, num_chunks=30, chunk_size=2)
     rca.fit(self.X, self.y, random_state=seed)
     L = rca.transformer_
-    assert_array_almost_equal(L.T.dot(L), rca.metric())
+    assert_array_almost_equal(L.T.dot(L), rca.get_mahalanobis_matrix())
 
   def test_mlkr(self):
     mlkr = MLKR(num_dims=2)
     mlkr.fit(self.X, self.y)
     L = mlkr.transformer_
-    assert_array_almost_equal(L.T.dot(L), mlkr.metric())
+    assert_array_almost_equal(L.T.dot(L), mlkr.get_mahalanobis_matrix())
 
 
 if __name__ == '__main__':

From 8e0d1974b78903c3ca8e4fd2cf8ac653a5d949f2 Mon Sep 17 00:00:00 2001
From: William de Vazelhes <william.de-vazelhes@inria.fr>
Date: Wed, 9 Jan 2019 15:06:43 +0100
Subject: [PATCH 02/25] ENH: refactor methods to get the metric

---
 metric_learn/base_metric.py | 51 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 50 insertions(+), 1 deletion(-)

diff --git a/metric_learn/base_metric.py b/metric_learn/base_metric.py
index 675a4663..2352e785 100644
--- a/metric_learn/base_metric.py
+++ b/metric_learn/base_metric.py
@@ -86,6 +86,17 @@ def _prepare_inputs(self, X, y=None, type_of_inputs='classic',
                        tuple_size=getattr(self, '_tuple_size', None),
                        **kwargs)
 
+  def get_metric(self):
+    """Returns a function that gives the distance between two points, according
+    to the learned metric. This function will be independent from the metric
+    learner that learned it (it will not be modified if the initial metric
+    learner is modified).
+
+    Returns
+    -------
+    metric_fun : function
+      The function described above.
+    """
 
 class MetricTransformer(six.with_metaclass(ABCMeta)):
 
@@ -178,8 +189,46 @@ def transform(self, X):
                              accept_sparse=True)
     return X_checked.dot(self.transformer_.T)
 
+  def get_metric(self):
+    """Returns a function that gives the distance between two points, according
+    to the learned metric. See `score_pairs` for more details on the properties
+    of this distance for Mahalanobis metric learners. This function will be
+    independent from the metric learner that learned it (it will not be
+    modified if the initial metric learner is modified).
+
+    Returns
+    -------
+    metric_fun : function
+      The function described above.
+    """
+    mahalanobis_matrix = self.get_mahalanobis_matrix()
+    def metric_fun(point_1, point_2):
+      """This function computes the euclidean distance between point 1 and
+      point 2, according to some learned metric.
+
+      Parameters
+      ----------
+      point_1 : `numpy.ndarray`, shape=(n_features)
+        The first point involved in the distances computation.
+      point_2 : `numpy.ndarray`, shape=(n_features)
+        The second point involved in the distances computation.
+      Returns
+      -------
+      distance: float
+        The distance between point 1 and point 2 according to the new metric.
+      """
+      return np.sqrt(point_1.dot(mahalanobis_matrix).dot(point_2.T))
+    return metric_fun
+
   def get_mahalanobis_matrix(self):
-    return self.transformer_.T.dot(self.transformer_)
+    """Returns a copy of the Mahalanobis matrix learned by the metric learner.
+
+    Returns
+    -------
+    M : `numpy.ndarray`, shape=(n_components, n_features)
+      The copy of the learned Mahalanobis matrix.
+    """
+    return self.transformer_.T.dot(self.transformer_).copy()
 
   def transformer_from_metric(self, metric):
     """Computes the transformation matrix from the Mahalanobis matrix.

From 6dd118e62b04d3e5ce452f55db935e5ffb4330db Mon Sep 17 00:00:00 2001
From: William de Vazelhes <william.de-vazelhes@inria.fr>
Date: Wed, 9 Jan 2019 15:54:19 +0100
Subject: [PATCH 03/25] DOC: change description of distance into pseudo-metric

---
 metric_learn/base_metric.py | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/metric_learn/base_metric.py b/metric_learn/base_metric.py
index 2352e785..2caba5c1 100644
--- a/metric_learn/base_metric.py
+++ b/metric_learn/base_metric.py
@@ -87,10 +87,10 @@ def _prepare_inputs(self, X, y=None, type_of_inputs='classic',
                        **kwargs)
 
   def get_metric(self):
-    """Returns a function that gives the distance between two points, according
-    to the learned metric. This function will be independent from the metric
-    learner that learned it (it will not be modified if the initial metric
-    learner is modified).
+    """Returns a function that gives the (pseudo) metric between two points,
+    according to the learned metric. This function will be independent from the
+    metric learner that learned it (it will not be modified if the initial
+    metric learner is modified).
 
     Returns
     -------
@@ -190,11 +190,11 @@ def transform(self, X):
     return X_checked.dot(self.transformer_.T)
 
   def get_metric(self):
-    """Returns a function that gives the distance between two points, according
-    to the learned metric. See `score_pairs` for more details on the properties
-    of this distance for Mahalanobis metric learners. This function will be
-    independent from the metric learner that learned it (it will not be
-    modified if the initial metric learner is modified).
+    """Returns a function that gives the pseudo-metric between two points,
+    according to the learned metric. See `score_pairs` for more details on the
+    properties of this pseudo-metric for Mahalanobis metric learners. This
+    function will be independent from the metric learner that learned it (it
+    will not be modified if the initial metric learner is modified).
 
     Returns
     -------
@@ -203,8 +203,8 @@ def get_metric(self):
     """
     mahalanobis_matrix = self.get_mahalanobis_matrix()
     def metric_fun(point_1, point_2):
-      """This function computes the euclidean distance between point 1 and
-      point 2, according to some learned metric.
+      """This function computes the peudo-metric between point 1 and
+      point 2, according to the previously learned metric.
 
       Parameters
       ----------

From c7e40f697e03995a3c565031cf4c3bb353fa7d82 Mon Sep 17 00:00:00 2001
From: William de Vazelhes <william.de-vazelhes@inria.fr>
Date: Wed, 9 Jan 2019 16:01:20 +0100
Subject: [PATCH 04/25] MAINT: make description clearer

---
 metric_learn/base_metric.py | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/metric_learn/base_metric.py b/metric_learn/base_metric.py
index 2caba5c1..ba7a716c 100644
--- a/metric_learn/base_metric.py
+++ b/metric_learn/base_metric.py
@@ -87,10 +87,9 @@ def _prepare_inputs(self, X, y=None, type_of_inputs='classic',
                        **kwargs)
 
   def get_metric(self):
-    """Returns a function that gives the (pseudo) metric between two points,
-    according to the learned metric. This function will be independent from the
-    metric learner that learned it (it will not be modified if the initial
-    metric learner is modified).
+    """Returns a function that returns the learned metric between two points.
+    This function will be independent from the metric learner that learned it
+    (it will not be modified if the initial metric learner is modified).
 
     Returns
     -------
@@ -190,11 +189,11 @@ def transform(self, X):
     return X_checked.dot(self.transformer_.T)
 
   def get_metric(self):
-    """Returns a function that gives the pseudo-metric between two points,
-    according to the learned metric. See `score_pairs` for more details on the
-    properties of this pseudo-metric for Mahalanobis metric learners. This
-    function will be independent from the metric learner that learned it (it
-    will not be modified if the initial metric learner is modified).
+    """Returns a function that returns the learned metric between two points.
+    See `score_pairs` for more details on the properties of this pseudo-metric
+    for Mahalanobis metric learners. This function will be independent from the
+    metric learner that learned it (it will not be modified if the initial
+    metric learner is modified).
 
     Returns
     -------
@@ -203,8 +202,8 @@ def get_metric(self):
     """
     mahalanobis_matrix = self.get_mahalanobis_matrix()
     def metric_fun(point_1, point_2):
-      """This function computes the peudo-metric between point 1 and
-      point 2, according to the previously learned metric.
+      """This function computes the metric between point 1 and point 2,
+      according to the previously learned metric.
 
       Parameters
       ----------

From 1947ea5c520e728cbe7759f93d8c195bd961b79a Mon Sep 17 00:00:00 2001
From: William de Vazelhes <william.de-vazelhes@inria.fr>
Date: Wed, 9 Jan 2019 17:07:35 +0100
Subject: [PATCH 05/25] ENH: enhance description

---
 doc/introduction.rst        |  2 ++
 metric_learn/base_metric.py | 41 +++++++++++++++++++++++++++++++++----
 2 files changed, 39 insertions(+), 4 deletions(-)

diff --git a/doc/introduction.rst b/doc/introduction.rst
index f0195c83..f290f850 100644
--- a/doc/introduction.rst
+++ b/doc/introduction.rst
@@ -38,6 +38,8 @@ generally formulated as an optimization problem where one seeks to find the
 parameters of a distance function that optimize some objective function
 measuring the agreement with the training data.
 
+.. _mahalanobis_distances:
+
 Mahalanobis Distances
 =====================
 
diff --git a/metric_learn/base_metric.py b/metric_learn/base_metric.py
index ba7a716c..90c2b934 100644
--- a/metric_learn/base_metric.py
+++ b/metric_learn/base_metric.py
@@ -35,6 +35,13 @@ def score_pairs(self, pairs):
     -------
     scores: `numpy.ndarray` of shape=(n_pairs,)
       The score of every pair.
+
+    See Also
+    --------
+    get_metric : a method that returns a function to compute the metric between
+      two points. The difference 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.
     """
 
   def check_preprocessor(self):
@@ -86,6 +93,7 @@ def _prepare_inputs(self, X, y=None, type_of_inputs='classic',
                        tuple_size=getattr(self, '_tuple_size', None),
                        **kwargs)
 
+  @abstractmethod
   def get_metric(self):
     """Returns a function that returns the learned metric between two points.
     This function will be independent from the metric learner that learned it
@@ -95,6 +103,13 @@ def get_metric(self):
     -------
     metric_fun : function
       The function described above.
+
+    See Also
+    --------
+    score_pairs : a method that returns the metric between several pairs of
+      points. But 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.
     """
 
 class MetricTransformer(six.with_metaclass(ABCMeta)):
@@ -157,6 +172,16 @@ def score_pairs(self, pairs):
     -------
     scores: `numpy.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 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.
+
+    :ref:`mahalanobis_distances` : The section of the project documentation
+      that describes Mahalanobis Distances.
     """
     pairs = check_input(pairs, type_of_inputs='tuples',
                         preprocessor=self.preprocessor_,
@@ -190,15 +215,23 @@ def transform(self, X):
 
   def get_metric(self):
     """Returns a function that returns the learned metric between two points.
-    See `score_pairs` for more details on the properties of this pseudo-metric
-    for Mahalanobis metric learners. This function will be independent from the
-    metric learner that learned it (it will not be modified if the initial
-    metric learner is modified).
+    This function will be independent from the metric learner that learned it
+    (it will not be modified if the initial metric learner is modified).
 
     Returns
     -------
     metric_fun : function
       The function described above.
+
+    See Also
+    --------
+    score_pairs : a method that returns the metric between several pairs of
+      points. But 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.
+
+    :ref:`mahalanobis_distances` : The section of the project documentation
+      that describes Mahalanobis Distances.
     """
     mahalanobis_matrix = self.get_mahalanobis_matrix()
     def metric_fun(point_1, point_2):

From bee690293fd7e9f68a947c275fc9ced792749d47 Mon Sep 17 00:00:00 2001
From: William de Vazelhes <william.de-vazelhes@inria.fr>
Date: Wed, 9 Jan 2019 17:12:36 +0100
Subject: [PATCH 06/25] MAINT: remove the 1D part in case we allow 2D

---
 metric_learn/base_metric.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/metric_learn/base_metric.py b/metric_learn/base_metric.py
index 90c2b934..309b1246 100644
--- a/metric_learn/base_metric.py
+++ b/metric_learn/base_metric.py
@@ -39,7 +39,7 @@ def score_pairs(self, pairs):
     See Also
     --------
     get_metric : a method that returns a function to compute the metric between
-      two points. The difference is that it works on two 1D arrays and cannot
+      two points. The difference is that it works on two 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.
     """
@@ -176,7 +176,7 @@ def score_pairs(self, pairs):
     See Also
     --------
     get_metric : a method that returns a function to compute the metric between
-      two points. The difference is that it works on two 1D arrays and cannot
+      two points. The difference is that it works on two 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.
 

From 646cf97eb43ea73c7c75d1625ac3b061059a668c Mon Sep 17 00:00:00 2001
From: William de Vazelhes <william.de-vazelhes@inria.fr>
Date: Thu, 10 Jan 2019 09:35:14 +0100
Subject: [PATCH 07/25] FIX: fix expression for mahalanobis distance

---
 metric_learn/base_metric.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/metric_learn/base_metric.py b/metric_learn/base_metric.py
index 309b1246..3dd99200 100644
--- a/metric_learn/base_metric.py
+++ b/metric_learn/base_metric.py
@@ -233,7 +233,7 @@ def get_metric(self):
     :ref:`mahalanobis_distances` : The section of the project documentation
       that describes Mahalanobis Distances.
     """
-    mahalanobis_matrix = self.get_mahalanobis_matrix()
+    transformer_T = self.transformer_.T.copy()
     def metric_fun(point_1, point_2):
       """This function computes the metric between point 1 and point 2,
       according to the previously learned metric.
@@ -249,7 +249,8 @@ def metric_fun(point_1, point_2):
       distance: float
         The distance between point 1 and point 2 according to the new metric.
       """
-      return np.sqrt(point_1.dot(mahalanobis_matrix).dot(point_2.T))
+      embeddings_diff = (point_1 - point_2).dot(transformer_T)
+      return np.sqrt(np.sum(embeddings_diff**2))
     return metric_fun
 
   def get_mahalanobis_matrix(self):

From 00d37c9c2d2e45743ddb57e399994f9928e1233d Mon Sep 17 00:00:00 2001
From: William de Vazelhes <william.de-vazelhes@inria.fr>
Date: Thu, 10 Jan 2019 10:12:34 +0100
Subject: [PATCH 08/25] TST: Add tests

---
 test/test_base_metric.py       | 29 +++++++++++++++++++++
 test/test_mahalanobis_mixin.py | 46 +++++++++++++++++++++++++++++++++-
 2 files changed, 74 insertions(+), 1 deletion(-)

diff --git a/test/test_base_metric.py b/test/test_base_metric.py
index fdea2949..d818f82d 100644
--- a/test/test_base_metric.py
+++ b/test/test_base_metric.py
@@ -1,5 +1,10 @@
+import pytest
 import unittest
 import metric_learn
+import numpy as np
+from sklearn import clone
+from sklearn.utils.testing import set_random_state
+from test.test_utils import ids_metric_learners, metric_learners
 
 
 class TestStringRepr(unittest.TestCase):
@@ -81,5 +86,29 @@ def test_mmc(self):
         num_labeled='deprecated', preprocessor=None, verbose=False)
 """.strip('\n'))
 
+
+@pytest.mark.parametrize('estimator, build_dataset', metric_learners,
+                         ids=ids_metric_learners)
+def test_get_metric_is_independent_from_metric_learner(estimator,
+                                                       build_dataset):
+  """Tests that the get_metric method returns a function that is independent
+  from the original metric learner"""
+  input_data, labels, _, X = build_dataset()
+  model = clone(estimator)
+  set_random_state(model)
+
+  # we fit the metric learner on it and then we compute the metric on some
+  # points
+  model.fit(input_data, labels)
+  metric = model.get_metric()
+  score = metric(X[0], X[1])
+
+  # then we refit the estimator on another dataset
+  model.fit(np.sin(input_data), labels)
+
+  # we recompute the distance between the two points: it should be the same
+  score_bis = metric(X[0], X[1])
+  assert score_bis == score
+
 if __name__ == '__main__':
   unittest.main()
diff --git a/test/test_mahalanobis_mixin.py b/test/test_mahalanobis_mixin.py
index 0d834f10..bc32af27 100644
--- a/test/test_mahalanobis_mixin.py
+++ b/test/test_mahalanobis_mixin.py
@@ -3,7 +3,7 @@
 import pytest
 import numpy as np
 from numpy.testing import assert_array_almost_equal
-from scipy.spatial.distance import pdist, squareform
+from scipy.spatial.distance import pdist, squareform, euclidean
 from sklearn import clone
 from sklearn.utils import check_random_state
 from sklearn.utils.testing import set_random_state
@@ -167,3 +167,47 @@ def test_embed_is_linear(estimator, build_dataset):
                             model.transform(X[10:20]))
   assert_array_almost_equal(model.transform(5 * X[:10]),
                             5 * model.transform(X[:10]))
+
+
+@pytest.mark.parametrize('estimator, build_dataset', metric_learners,
+                         ids=ids_metric_learners)
+def test_get_metric_equivalent_to_transform_and_euclidean(estimator,
+                                                          build_dataset):
+  """Tests that the get_metric method of mahalanobis metric learners is the
+  euclidean distance in the transformed space
+  """
+  rng = np.random.RandomState(42)
+  input_data, labels, _, X = build_dataset()
+  model = clone(estimator)
+  set_random_state(model)
+  model.fit(input_data, labels)
+  metric = model.get_metric()
+  n_features = X.shape[1]
+  a, b = (rng.randn(n_features), rng.randn(n_features))
+  euc_dist = euclidean(model.transform(a[None]), model.transform(b[None]))
+  assert (euc_dist - metric(a, b)) / euc_dist < 1e-15
+
+
+@pytest.mark.parametrize('estimator, build_dataset', metric_learners,
+                         ids=ids_metric_learners)
+def test_get_metric_is_pseudo_metric(estimator, build_dataset):
+  """Tests that the get_metric method of mahalanobis metric learners returns a
+  pseudo-metric (metric but without one side of the equivalence of
+  the identity of indiscernables property)
+  """
+  rng = np.random.RandomState(42)
+  input_data, labels, _, X = build_dataset()
+  model = clone(estimator)
+  set_random_state(model)
+  model.fit(input_data, labels)
+  metric = model.get_metric()
+
+  n_features = X.shape[1]
+  a, b, c = (rng.randn(n_features) for _ in range(3))
+  assert metric(a, b) >= 0  # positivity
+  assert metric(a, b) == metric(b, a)  # symmetry
+  # one side of identity indiscernables: x == y => d(x, y) == 0. The other
+  # side is not always true for Mahalanobis distances.
+  assert metric(a, a) == 0
+  # triangular inequality
+  assert metric(a, c) <= metric(a, b) + metric(b, c)

From c9eefb4d3700a52e617a17fc9b1f01744991511d Mon Sep 17 00:00:00 2001
From: William de Vazelhes <william.de-vazelhes@inria.fr>
Date: Thu, 10 Jan 2019 11:56:34 +0100
Subject: [PATCH 09/25] ENH: deal with the 1D case

---
 metric_learn/base_metric.py | 17 +++++++-----
 test/test_base_metric.py    | 53 +++++++++++++++++++++++++++++++++++++
 2 files changed, 63 insertions(+), 7 deletions(-)

diff --git a/metric_learn/base_metric.py b/metric_learn/base_metric.py
index 3dd99200..50956d62 100644
--- a/metric_learn/base_metric.py
+++ b/metric_learn/base_metric.py
@@ -1,4 +1,5 @@
 from numpy.linalg import cholesky
+from scipy.spatial.distance import euclidean, _validate_vector
 from sklearn.base import BaseEstimator
 from sklearn.utils.validation import _is_arraylike
 from sklearn.metrics import roc_auc_score
@@ -39,7 +40,7 @@ def score_pairs(self, pairs):
     See Also
     --------
     get_metric : a method that returns a function to compute the metric between
-      two points. The difference is that it works on two arrays and cannot
+      two points. The difference 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.
     """
@@ -176,7 +177,7 @@ def score_pairs(self, pairs):
     See Also
     --------
     get_metric : a method that returns a function to compute the metric between
-      two points. The difference is that it works on two arrays and cannot
+      two points. The difference 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.
 
@@ -234,23 +235,25 @@ def get_metric(self):
       that describes Mahalanobis Distances.
     """
     transformer_T = self.transformer_.T.copy()
-    def metric_fun(point_1, point_2):
+
+    def metric_fun(u, v):
       """This function computes the metric between point 1 and point 2,
       according to the previously learned metric.
 
       Parameters
       ----------
-      point_1 : `numpy.ndarray`, shape=(n_features)
+      u : array-like, shape=(n_features,)
         The first point involved in the distances computation.
-      point_2 : `numpy.ndarray`, shape=(n_features)
+      v : array-like, shape=(n_features,)
         The second point involved in the distances computation.
       Returns
       -------
       distance: float
         The distance between point 1 and point 2 according to the new metric.
       """
-      embeddings_diff = (point_1 - point_2).dot(transformer_T)
-      return np.sqrt(np.sum(embeddings_diff**2))
+      u = _validate_vector(u)
+      v = _validate_vector(v)
+      return euclidean(u.dot(transformer_T), v.dot(transformer_T))
     return metric_fun
 
   def get_mahalanobis_matrix(self):
diff --git a/test/test_base_metric.py b/test/test_base_metric.py
index d818f82d..09718c29 100644
--- a/test/test_base_metric.py
+++ b/test/test_base_metric.py
@@ -110,5 +110,58 @@ def test_get_metric_is_independent_from_metric_learner(estimator,
   score_bis = metric(X[0], X[1])
   assert score_bis == score
 
+
+@pytest.mark.parametrize('estimator, build_dataset', metric_learners,
+                         ids=ids_metric_learners)
+def test_get_metric_raises_error(estimator, build_dataset):
+  """Tests that the metric returned by get_metric raises errors similar to
+  the distance functions in scipy.spatial.distance"""
+  input_data, labels, _, X = build_dataset()
+  model = clone(estimator)
+  set_random_state(model)
+  model.fit(input_data, labels)
+  metric = model.get_metric()
+
+  list_test_get_metric_raises = [(X[0].tolist() + [5.2], X[1]),  # vectors with
+                                 # different dimensions
+                                 (X[0:4], X[1:5]),  # 2D vectors
+                                 (X[0].tolist() + [5.2], X[1] + [7.2])]
+  # vectors of same dimension but incompatible with what the metric learner
+  # was trained on
+
+  for u, v in list_test_get_metric_raises:
+    with pytest.raises(ValueError):
+      metric(u, v)
+
+
+@pytest.mark.parametrize('estimator, build_dataset', metric_learners,
+                         ids=ids_metric_learners)
+def test_get_metric_works_does_not_raise(estimator, build_dataset):
+  """Tests that the metric returned by get_metric does not raise errors (or
+  warnings) similarly to the distance functions in scipy.spatial.distance"""
+  input_data, labels, _, X = build_dataset()
+  model = clone(estimator)
+  set_random_state(model)
+  model.fit(input_data, labels)
+  metric = model.get_metric()
+
+  list_test_get_metric_doesnt_raise = [(X[0], X[1]),
+                                       (X[0].tolist(), X[1].tolist()),
+                                       (X[0][None], X[1][None])]
+
+  for u, v in list_test_get_metric_doesnt_raise:
+    with pytest.warns(None) as record:
+      metric(u, v)
+    assert len(record) == 0
+
+  # Test that the scalar case works
+  model.transformer_ = np.array([3.1])
+  metric = model.get_metric()
+  for u, v in [(5, 6.7), ([5], [6.7]), ([[5]], [[6.7]])]:
+    with pytest.warns(None) as record:
+      metric(u, v)
+    assert len(record) == 0
+
+
 if __name__ == '__main__':
   unittest.main()

From bd6aac0dd4b17c2d7d686076a7a66aaaf55e6f9f Mon Sep 17 00:00:00 2001
From: William de Vazelhes <william.de-vazelhes@inria.fr>
Date: Thu, 10 Jan 2019 12:00:11 +0100
Subject: [PATCH 10/25] Rename forgotten point 1 and point 2 to u and v

---
 metric_learn/base_metric.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/metric_learn/base_metric.py b/metric_learn/base_metric.py
index 50956d62..fa832ff6 100644
--- a/metric_learn/base_metric.py
+++ b/metric_learn/base_metric.py
@@ -237,8 +237,8 @@ def get_metric(self):
     transformer_T = self.transformer_.T.copy()
 
     def metric_fun(u, v):
-      """This function computes the metric between point 1 and point 2,
-      according to the previously learned metric.
+      """This function computes the metric between u and v, according to the
+      previously learned metric.
 
       Parameters
       ----------
@@ -249,7 +249,7 @@ def metric_fun(u, v):
       Returns
       -------
       distance: float
-        The distance between point 1 and point 2 according to the new metric.
+        The distance between u and v according to the new metric.
       """
       u = _validate_vector(u)
       v = _validate_vector(v)

From 9e447f68f6102bbd8c0b1b7b207734750fedd52c Mon Sep 17 00:00:00 2001
From: William de Vazelhes <william.de-vazelhes@inria.fr>
Date: Thu, 10 Jan 2019 12:08:04 +0100
Subject: [PATCH 11/25] STY: Fix PEP8 errors

---
 test/metric_learn_test.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/test/metric_learn_test.py b/test/metric_learn_test.py
index 996bda30..e4ce8cef 100644
--- a/test/metric_learn_test.py
+++ b/test/metric_learn_test.py
@@ -348,14 +348,16 @@ def test_iris(self):
                 [+0.000868, +0.001468, -0.002021, -0.002879],
                 [-0.001195, -0.002021, +0.002782, +0.003964],
                 [-0.001703, -0.002879, +0.003964, +0.005648]]
-    assert_array_almost_equal(expected, mmc.get_mahalanobis_matrix(), decimal=6)
+    assert_array_almost_equal(expected, mmc.get_mahalanobis_matrix(),
+                              decimal=6)
 
     # Diagonal metric
     mmc = MMC(diagonal=True)
     mmc.fit(*wrap_pairs(self.iris_points, [a,b,c,d]))
     expected = [0, 0, 1.210220, 1.228596]
-    assert_array_almost_equal(np.diag(expected), mmc.get_mahalanobis_matrix(), decimal=6)
-    
+    assert_array_almost_equal(np.diag(expected), mmc.get_mahalanobis_matrix(),
+                              decimal=6)
+
     # Supervised Full
     mmc = MMC_Supervised()
     mmc.fit(self.iris_points, self.iris_labels)

From 201320bb09e073cb28ff4d9a79cc68aa633681da Mon Sep 17 00:00:00 2001
From: William de Vazelhes <william.de-vazelhes@inria.fr>
Date: Tue, 15 Jan 2019 11:41:35 +0100
Subject: [PATCH 12/25] Address all comments

---
 doc/conf.py                    |   6 +-
 examples/metric_plotting.ipynb | 196 ++++++++++++++++-----------------
 metric_learn/_util.py          |  11 ++
 metric_learn/base_metric.py    |  95 ++++++++++++----
 test/test_mahalanobis_mixin.py |  55 +++++++--
 test/test_utils.py             |  32 +++++-
 6 files changed, 260 insertions(+), 135 deletions(-)

diff --git a/doc/conf.py b/doc/conf.py
index ed476edd..f0faa2f8 100644
--- a/doc/conf.py
+++ b/doc/conf.py
@@ -7,7 +7,8 @@
     'sphinx.ext.viewcode',
     'sphinx.ext.mathjax',
     'numpydoc',
-    'sphinx_gallery.gen_gallery'
+    'sphinx_gallery.gen_gallery',
+    'sphinx.ext.doctest'
 ]
 
 templates_path = ['_templates']
@@ -35,3 +36,6 @@
 # Option to only need single backticks to refer to symbols
 default_role = 'any'
 
+# Option to hide doctests comments in the documentation (like # doctest:
+# +NORMALIZE_WHITESPACE for instance)
+trim_doctest_flags = True
diff --git a/examples/metric_plotting.ipynb b/examples/metric_plotting.ipynb
index f8661181..5b23ee69 100644
--- a/examples/metric_plotting.ipynb
+++ b/examples/metric_plotting.ipynb
@@ -2,9 +2,7 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "source": [
     "### Metric Learning and Plotting\n",
     "\n",
@@ -23,9 +21,7 @@
   {
    "cell_type": "code",
    "execution_count": 1,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "%matplotlib inline\n",
@@ -53,9 +49,7 @@
   {
    "cell_type": "code",
    "execution_count": 2,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# loading our dataset\n",
@@ -90,15 +84,13 @@
   {
    "cell_type": "code",
    "execution_count": 3,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdsAAAFsCAYAAACEtRP5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAOAZZQsAgGf/AckQihPvOEbCAAAAAElFTkSuQmCC\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<matplotlib.figure.Figure at 0x10abb1510>"
+       "<Figure size 576x432 with 1 Axes>"
       ]
      },
      "metadata": {},
@@ -150,11 +142,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/will/Code/metric-learn/metric_learn/lmnn.py:68: UserWarning: use_pca does nothing for the python_LMNN implementation\n",
+      "  warnings.warn('use_pca does nothing for the python_LMNN implementation')\n"
+     ]
+    }
+   ],
    "source": [
     "# setting up LMNN\n",
     "lmnn = metric_learn.LMNN(k=5, learn_rate=1e-6)\n",
@@ -163,7 +162,7 @@
     "lmnn.fit(X, Y)\n",
     "\n",
     "# transform our input space\n",
-    "X_lmnn = lmnn.transform()"
+    "X_lmnn = lmnn.transform(X)"
    ]
   },
   {
@@ -176,21 +175,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 6,
+   "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([[ 2.49193844,  0.35638993, -0.39984418, -0.77608969],\n",
-       "       [ 0.35638993,  1.68815388, -0.90376817, -0.07406329],\n",
-       "       [-0.39984418, -0.90376817,  2.37468946,  2.18784107],\n",
-       "       [-0.77608969, -0.07406329,  2.18784107,  2.94523937]])"
+       "array([[ 2.48658894,  0.37659753, -0.39994851, -0.81121869],\n",
+       "       [ 0.37659753,  1.65446423, -0.91445505, -0.04840952],\n",
+       "       [-0.39994851, -0.91445505,  2.35565062,  2.2607159 ],\n",
+       "       [-0.81121869, -0.04840952,  2.2607159 ,  2.86731654]])"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -208,16 +205,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 7,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdsAAAFsCAYAAACEtRP5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAAAElFTkSuQmCC\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<matplotlib.figure.Figure at 0x10abf1250>"
+       "<Figure size 576x432 with 1 Axes>"
       ]
      },
      "metadata": {},
@@ -251,11 +246,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/will/anaconda3/envs/metric_bis/lib/python3.7/site-packages/sklearn/utils/validation.py:761: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
+      "  y = column_or_1d(y, warn=True)\n"
+     ]
+    }
+   ],
    "source": [
     "itml = metric_learn.ITML_Supervised(num_constraints=200)\n",
     "X_itml = itml.fit_transform(X, Y)"
@@ -263,16 +265,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 9,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdsAAAFsCAYAAACEtRP5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRNxMxVZERMTNVGxFRETc7P8AXsVpWPQcdcQAAAAASUVORK5CYII=\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<matplotlib.figure.Figure at 0x10ac1e410>"
+       "<Figure size 576x432 with 1 Axes>"
       ]
      },
      "metadata": {},
@@ -299,18 +299,40 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 10,
+   "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/Users/bhargavvader/Open_Source/metric-learn/venv/lib/python2.7/site-packages/sklearn/covariance/graph_lasso_.py:252: ConvergenceWarning: graph_lasso: did not converge after 100 iteration: dual gap: 2.377e-04\n",
-      "  ConvergenceWarning)\n"
+      "/home/will/anaconda3/envs/metric_bis/lib/python3.7/site-packages/sklearn/utils/validation.py:761: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
+      "  y = column_or_1d(y, warn=True)\n",
+      "/home/will/anaconda3/envs/metric_bis/lib/python3.7/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function pinvh is deprecated; sklearn.utils.extmath.pinvh was deprecated in version 0.19 and will be removed in 0.21. Use scipy.linalg.pinvh instead.\n",
+      "  warnings.warn(msg, category=DeprecationWarning)\n",
+      "/home/will/anaconda3/envs/metric_bis/lib/python3.7/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function pinvh is deprecated; sklearn.utils.extmath.pinvh was deprecated in version 0.19 and will be removed in 0.21. Use scipy.linalg.pinvh instead.\n",
+      "  warnings.warn(msg, category=DeprecationWarning)\n",
+      "/home/will/anaconda3/envs/metric_bis/lib/python3.7/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function graph_lasso is deprecated; The 'graph_lasso' was renamed to 'graphical_lasso' in version 0.20 and will be removed in 0.22.\n",
+      "  warnings.warn(msg, category=DeprecationWarning)\n"
      ]
+    },
+    {
+     "ename": "FloatingPointError",
+     "evalue": "Non SPD result: the system is too ill-conditioned for this solver. The system is too ill-conditioned for this solver",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mFloatingPointError\u001b[0m                        Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-10-756c8e726699>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0msdml\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmetric_learn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mSDML_Supervised\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnum_constraints\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m200\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mX_sdml\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msdml\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrandom_state\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRandomState\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1234\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;32m~/anaconda3/envs/metric_bis/lib/python3.7/site-packages/sklearn/base.py\u001b[0m in \u001b[0;36mfit_transform\u001b[0;34m(self, X, y, **fit_params)\u001b[0m\n\u001b[1;32m    463\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    464\u001b[0m             \u001b[0;31m# fit method of arity 2 (supervised transformation)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 465\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mfit_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    466\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    467\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/Code/metric-learn/metric_learn/sdml.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, random_state)\u001b[0m\n\u001b[1;32m    181\u001b[0m                                         random_state=random_state)\n\u001b[1;32m    182\u001b[0m     \u001b[0mpairs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mwrap_pairs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpos_neg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 183\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0m_BaseSDML\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_fit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpairs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;32m~/Code/metric-learn/metric_learn/sdml.py\u001b[0m in \u001b[0;36m_fit\u001b[0;34m(self, pairs, y)\u001b[0m\n\u001b[1;32m     68\u001b[0m     \u001b[0;31m# hack: ensure positive semidefinite\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m     \u001b[0memp_cov\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0memp_cov\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0memp_cov\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m     \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mM_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgraph_lasso\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0memp_cov\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msparsity_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mverbose\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransformer_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtransformer_from_metric\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mM_\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/anaconda3/envs/metric_bis/lib/python3.7/site-packages/sklearn/utils/deprecation.py\u001b[0m in \u001b[0;36mwrapped\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     76\u001b[0m         \u001b[0;32mdef\u001b[0m \u001b[0mwrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     77\u001b[0m             \u001b[0mwarnings\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwarn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmsg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcategory\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mDeprecationWarning\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 78\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     79\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     80\u001b[0m         \u001b[0mwrapped\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__doc__\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_update_doc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__doc__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/anaconda3/envs/metric_bis/lib/python3.7/site-packages/sklearn/covariance/graph_lasso_.py\u001b[0m in \u001b[0;36mgraph_lasso\u001b[0;34m(emp_cov, alpha, cov_init, mode, tol, enet_tol, max_iter, verbose, return_costs, eps, return_n_iter)\u001b[0m\n\u001b[1;32m    815\u001b[0m     return graphical_lasso(emp_cov, alpha, cov_init, mode, tol,\n\u001b[1;32m    816\u001b[0m                            \u001b[0menet_tol\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreturn_costs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 817\u001b[0;31m                            eps, return_n_iter)\n\u001b[0m\u001b[1;32m    818\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    819\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/anaconda3/envs/metric_bis/lib/python3.7/site-packages/sklearn/covariance/graph_lasso_.py\u001b[0m in \u001b[0;36mgraphical_lasso\u001b[0;34m(emp_cov, alpha, cov_init, mode, tol, enet_tol, max_iter, verbose, return_costs, eps, return_n_iter)\u001b[0m\n\u001b[1;32m    267\u001b[0m         e.args = (e.args[0]\n\u001b[1;32m    268\u001b[0m                   + '. The system is too ill-conditioned for this solver',)\n\u001b[0;32m--> 269\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    270\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    271\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mreturn_costs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/anaconda3/envs/metric_bis/lib/python3.7/site-packages/sklearn/covariance/graph_lasso_.py\u001b[0m in \u001b[0;36mgraphical_lasso\u001b[0;34m(emp_cov, alpha, cov_init, mode, tol, enet_tol, max_iter, verbose, return_costs, eps, return_n_iter)\u001b[0m\n\u001b[1;32m    258\u001b[0m                 \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    259\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0misfinite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcost\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mi\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 260\u001b[0;31m                 raise FloatingPointError('Non SPD result: the system is '\n\u001b[0m\u001b[1;32m    261\u001b[0m                                          'too ill-conditioned for this solver')\n\u001b[1;32m    262\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mFloatingPointError\u001b[0m: Non SPD result: the system is too ill-conditioned for this solver. The system is too ill-conditioned for this solver"
+     ],
+     "output_type": "error"
     }
    ],
    "source": [
@@ -321,9 +343,7 @@
   {
    "cell_type": "code",
    "execution_count": 10,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
@@ -354,9 +374,7 @@
   {
    "cell_type": "code",
    "execution_count": 11,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "lsml = metric_learn.LSML_Supervised(num_constraints=200)\n",
@@ -366,9 +384,7 @@
   {
    "cell_type": "code",
    "execution_count": 12,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
@@ -401,9 +417,7 @@
   {
    "cell_type": "code",
    "execution_count": 13,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "nca = metric_learn.NCA(max_iter=1000, learning_rate=0.01)\n",
@@ -413,9 +427,7 @@
   {
    "cell_type": "code",
    "execution_count": 14,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
@@ -446,9 +458,7 @@
   {
    "cell_type": "code",
    "execution_count": 15,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "lfda = metric_learn.LFDA(k=2, dim=2)\n",
@@ -458,9 +468,7 @@
   {
    "cell_type": "code",
    "execution_count": 16,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
@@ -492,9 +500,7 @@
   {
    "cell_type": "code",
    "execution_count": 17,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "rca = metric_learn.RCA_Supervised(num_chunks=30, chunk_size=2)\n",
@@ -504,9 +510,7 @@
   {
    "cell_type": "code",
    "execution_count": 18,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
@@ -546,9 +550,7 @@
   {
    "cell_type": "code",
    "execution_count": 19,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "def create_constraints(labels):\n",
@@ -587,9 +589,7 @@
   {
    "cell_type": "code",
    "execution_count": 20,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "constraint = create_constraints(Y)"
@@ -605,9 +605,7 @@
   {
    "cell_type": "code",
    "execution_count": 21,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
@@ -629,9 +627,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "source": [
     "Using our constraints, let's now train ITML again.\n",
     "We should keep in mind that internally, ITML_Supervised does pretty much the same thing we are doing; I was just giving an example to better explain how the constraints are structured. "
@@ -640,9 +636,7 @@
   {
    "cell_type": "code",
    "execution_count": 22,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "itml = metric_learn.ITML()\n",
@@ -652,9 +646,7 @@
   {
    "cell_type": "code",
    "execution_count": 23,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
@@ -686,21 +678,21 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 2",
+   "display_name": "Python 3",
    "language": "python",
-   "name": "python2"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
-    "version": 2
+    "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython2",
-   "version": "2.7.12"
+   "pygments_lexer": "ipython3",
+   "version": "3.7.0"
   }
  },
  "nbformat": 4,
diff --git a/metric_learn/_util.py b/metric_learn/_util.py
index 3bc303f9..bd57fd5f 100644
--- a/metric_learn/_util.py
+++ b/metric_learn/_util.py
@@ -349,3 +349,14 @@ def transformer_from_metric(metric):
   else:
     w, V = np.linalg.eigh(metric)
     return V.T * np.sqrt(np.maximum(0, w[:, None]))
+
+
+def validate_vector(u, dtype=None):
+  # replica of scipy.spatial.distance._validate_vector, for making scipy
+  # compatible functions on vectors (such as distances computations)
+  u = np.asarray(u, dtype=dtype, order='c').squeeze()
+  # Ensure values such as u=1 and u=[1] still return 1-D arrays.
+  u = np.atleast_1d(u)
+  if u.ndim > 1:
+    raise ValueError("Input vector should be 1-D.")
+  return u
diff --git a/metric_learn/base_metric.py b/metric_learn/base_metric.py
index f5d8b927..fd5f9c79 100644
--- a/metric_learn/base_metric.py
+++ b/metric_learn/base_metric.py
@@ -7,6 +7,7 @@
 from abc import ABCMeta, abstractmethod
 import six
 from ._util import ArrayIndexer, check_input
+import warnings
 
 
 class BaseMetricLearner(six.with_metaclass(ABCMeta, BaseEstimator)):
@@ -40,9 +41,10 @@ def score_pairs(self, pairs):
     See Also
     --------
     get_metric : a method that returns a function to compute the metric between
-      two points. The difference 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.
+      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.
     """
 
   def check_preprocessor(self):
@@ -96,21 +98,44 @@ def _prepare_inputs(self, X, y=None, type_of_inputs='classic',
 
   @abstractmethod
   def get_metric(self):
-    """Returns a function that returns the learned metric between two points.
+    """Returns a function that takes as input two 1D arrays and outputs the
+    learned metric score on these two points.
+
     This function will be independent from the metric learner that learned it
-    (it will not be modified if the initial metric learner is modified).
+    (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_fun : function
       The function described above.
 
+
+    Examples
+    --------
+    .. doctest::
+
+      >>> 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) # doctest: +NORMALIZE_WHITESPACE
+      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')
+
     See Also
     --------
-    score_pairs : a method that returns the metric between several pairs of
-      points. But 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.
+    score_pairs : a method that returns the metric 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.
     """
 
 class MetricTransformer(six.with_metaclass(ABCMeta)):
@@ -177,9 +202,10 @@ def score_pairs(self, pairs):
     See Also
     --------
     get_metric : a method that returns a function to compute the metric between
-      two points. The difference 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.
+      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.
 
     :ref:`mahalanobis_distances` : The section of the project documentation
       that describes Mahalanobis Distances.
@@ -215,21 +241,43 @@ def transform(self, X):
     return X_checked.dot(self.transformer_.T)
 
   def get_metric(self):
-    """Returns a function that returns the learned metric between two points.
+    """Returns a function that takes as input two 1D arrays and outputs the
+    learned metric score on these two points.
+
     This function will be independent from the metric learner that learned it
-    (it will not be modified if the initial metric learner is modified).
+    (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_fun : function
       The function described above.
 
+    Examples
+    --------
+    .. doctest::
+
+      >>> 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) # doctest: +NORMALIZE_WHITESPACE
+      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')
+
     See Also
     --------
-    score_pairs : a method that returns the metric between several pairs of
-      points. But 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.
+    score_pairs : a method that returns the metric 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.
 
     :ref:`mahalanobis_distances` : The section of the project documentation
       that describes Mahalanobis Distances.
@@ -243,9 +291,9 @@ def metric_fun(u, v):
       Parameters
       ----------
       u : array-like, shape=(n_features,)
-        The first point involved in the distances computation.
+        The first point involved in the distance computation.
       v : array-like, shape=(n_features,)
-        The second point involved in the distances computation.
+        The second point involved in the distance computation.
       Returns
       -------
       distance: float
@@ -256,6 +304,13 @@ def metric_fun(u, v):
       return euclidean(u.dot(transformer_T), v.dot(transformer_T))
     return metric_fun
 
+  def metric(self):
+    # TODO: remove this method in version 0.6.0
+    warnings.warn(("`metric` is deprecated since version 0.5.0 and will be "
+                   "removed in 0.6.0. Use `get_mahalanobis_matrix` instead."),
+                  DeprecationWarning)
+    return self.transformer_.T.dot(self.transformer_)
+
   def get_mahalanobis_matrix(self):
     """Returns a copy of the Mahalanobis matrix learned by the metric learner.
 
diff --git a/test/test_mahalanobis_mixin.py b/test/test_mahalanobis_mixin.py
index bc32af27..235e796b 100644
--- a/test/test_mahalanobis_mixin.py
+++ b/test/test_mahalanobis_mixin.py
@@ -2,9 +2,10 @@
 
 import pytest
 import numpy as np
-from numpy.testing import assert_array_almost_equal
+from numpy.testing import assert_array_almost_equal, assert_allclose
 from scipy.spatial.distance import pdist, squareform, euclidean
 from sklearn import clone
+from sklearn.cluster import DBSCAN
 from sklearn.utils import check_random_state
 from sklearn.utils.testing import set_random_state
 
@@ -185,7 +186,7 @@ def test_get_metric_equivalent_to_transform_and_euclidean(estimator,
   n_features = X.shape[1]
   a, b = (rng.randn(n_features), rng.randn(n_features))
   euc_dist = euclidean(model.transform(a[None]), model.transform(b[None]))
-  assert (euc_dist - metric(a, b)) / euc_dist < 1e-15
+  assert assert_allclose(euc_dist, metric(a, b), rtol=1e-15)
 
 
 @pytest.mark.parametrize('estimator, build_dataset', metric_learners,
@@ -195,7 +196,6 @@ def test_get_metric_is_pseudo_metric(estimator, build_dataset):
   pseudo-metric (metric but without one side of the equivalence of
   the identity of indiscernables property)
   """
-  rng = np.random.RandomState(42)
   input_data, labels, _, X = build_dataset()
   model = clone(estimator)
   set_random_state(model)
@@ -203,11 +203,44 @@ def test_get_metric_is_pseudo_metric(estimator, build_dataset):
   metric = model.get_metric()
 
   n_features = X.shape[1]
-  a, b, c = (rng.randn(n_features) for _ in range(3))
-  assert metric(a, b) >= 0  # positivity
-  assert metric(a, b) == metric(b, a)  # symmetry
-  # one side of identity indiscernables: x == y => d(x, y) == 0. The other
-  # side is not always true for Mahalanobis distances.
-  assert metric(a, a) == 0
-  # triangular inequality
-  assert metric(a, c) <= metric(a, b) + metric(b, c)
+  for seed in range(10):
+    rng = np.random.RandomState(seed)
+    a, b, c = (rng.randn(n_features) for _ in range(3))
+    assert metric(a, b) >= 0  # positivity
+    assert metric(a, b) == metric(b, a)  # symmetry
+    # one side of identity indiscernables: x == y => d(x, y) == 0. The other
+    # side of the equivalence is not always true for Mahalanobis distances.
+    assert metric(a, a) == 0
+    # triangular inequality
+    assert metric(a, c) <= metric(a, b) + metric(b, c)
+
+
+@pytest.mark.parametrize('estimator, build_dataset', metric_learners,
+                         ids=ids_metric_learners)
+def test_metric_raises_deprecation_warning(estimator, build_dataset):
+  """assert that a deprecation warning is raised if someones wants to call
+  the `metric` function"""
+  # TODO: remove this method in version 0.6.0
+  input_data, labels, _, X = build_dataset()
+  model = clone(estimator)
+  set_random_state(model)
+  model.fit(input_data, labels)
+
+  with pytest.warns(DeprecationWarning) as raised_warning:
+    model.metric()
+  assert (str(raised_warning[0].message) ==
+          ("`metric` is deprecated since version 0.5.0 and will be removed "
+           "in 0.6.0. Use `get_mahalanobis_matrix` instead."))
+
+
+@pytest.mark.parametrize('estimator, build_dataset', metric_learners,
+                         ids=ids_metric_learners)
+def test_get_metric_compatible_with_scikit_learn(estimator, build_dataset):
+  """Check that the metric returned by get_metric is compatible with
+  scikit-learn's algorithms using a custom metric, DBSCAN for instance"""
+  input_data, labels, _, X = build_dataset()
+  model = clone(estimator)
+  set_random_state(model)
+  model.fit(input_data, labels)
+  clustering = DBSCAN(metric=model.get_metric())
+  clustering.fit(X)
\ No newline at end of file
diff --git a/test/test_utils.py b/test/test_utils.py
index 39c718ac..5e640dbc 100644
--- a/test/test_utils.py
+++ b/test/test_utils.py
@@ -1,6 +1,7 @@
 import pytest
 from collections import namedtuple
 import numpy as np
+from numpy.testing import assert_array_equal, assert_equal
 from sklearn.model_selection import train_test_split
 from sklearn.exceptions import DataConversionWarning
 from sklearn.utils import check_random_state, shuffle
@@ -8,7 +9,7 @@
 from sklearn.base import clone
 from metric_learn._util import (check_input, make_context, preprocess_tuples,
                                 make_name, preprocess_points,
-                                check_collapsed_pairs)
+                                check_collapsed_pairs, validate_vector)
 from metric_learn import (ITML, LSML, MMC, RCA, SDML, Covariance, LFDA,
                           LMNN, MLKR, NCA, ITML_Supervised, LSML_Supervised,
                           MMC_Supervised, RCA_Supervised, SDML_Supervised,
@@ -1010,3 +1011,32 @@ def test_check_collapsed_pairs_raises_error():
   assert str(e.value) == ("2 collapsed pairs found (where the left element is "
                           "the same as the right element), out of 3 pairs in"
                           " total.")
+
+def test__validate_vector():
+  """Replica of scipy.spatial.tests.test_distance.test__validate_vector"""
+  x = [1, 2, 3]
+  y = validate_vector(x)
+  assert_array_equal(y, x)
+
+  y = validate_vector(x, dtype=np.float64)
+  assert_array_equal(y, x)
+  assert_equal(y.dtype, np.float64)
+
+  x = [1]
+  y = validate_vector(x)
+  assert_equal(y.ndim, 1)
+  assert_equal(y, x)
+
+  x = 1
+  y = validate_vector(x)
+  assert_equal(y.ndim, 1)
+  assert_equal(y, [x])
+
+  x = np.arange(5).reshape(1, -1, 1)
+  y = validate_vector(x)
+  assert_equal(y.ndim, 1)
+  assert_array_equal(y, x[0, :, 0])
+
+  x = [[1, 2], [3, 4]]
+  with pytest.raises(ValueError):
+    validate_vector(x)

From 4b660fa332fdaadf2d07cae1f7501a898d91c602 Mon Sep 17 00:00:00 2001
From: William de Vazelhes <william.de-vazelhes@inria.fr>
Date: Tue, 15 Jan 2019 11:45:18 +0100
Subject: [PATCH 13/25] Revert changes in metric_plotting included by mistake

---
 examples/metric_plotting.ipynb | 196 +++++++++++++++++----------------
 1 file changed, 102 insertions(+), 94 deletions(-)

diff --git a/examples/metric_plotting.ipynb b/examples/metric_plotting.ipynb
index 5b23ee69..f8661181 100644
--- a/examples/metric_plotting.ipynb
+++ b/examples/metric_plotting.ipynb
@@ -2,7 +2,9 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "source": [
     "### Metric Learning and Plotting\n",
     "\n",
@@ -21,7 +23,9 @@
   {
    "cell_type": "code",
    "execution_count": 1,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "%matplotlib inline\n",
@@ -49,7 +53,9 @@
   {
    "cell_type": "code",
    "execution_count": 2,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "# loading our dataset\n",
@@ -84,13 +90,15 @@
   {
    "cell_type": "code",
    "execution_count": 3,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdsAAAFsCAYAAACEtRP5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAOAZZQsAgGf/AckQihPvOEbCAAAAAElFTkSuQmCC\n",
       "text/plain": [
-       "<Figure size 576x432 with 1 Axes>"
+       "<matplotlib.figure.Figure at 0x10abb1510>"
       ]
      },
      "metadata": {},
@@ -142,18 +150,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/will/Code/metric-learn/metric_learn/lmnn.py:68: UserWarning: use_pca does nothing for the python_LMNN implementation\n",
-      "  warnings.warn('use_pca does nothing for the python_LMNN implementation')\n"
-     ]
-    }
-   ],
+   "execution_count": 4,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
    "source": [
     "# setting up LMNN\n",
     "lmnn = metric_learn.LMNN(k=5, learn_rate=1e-6)\n",
@@ -162,7 +163,7 @@
     "lmnn.fit(X, Y)\n",
     "\n",
     "# transform our input space\n",
-    "X_lmnn = lmnn.transform(X)"
+    "X_lmnn = lmnn.transform()"
    ]
   },
   {
@@ -175,19 +176,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
+   "execution_count": 5,
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([[ 2.48658894,  0.37659753, -0.39994851, -0.81121869],\n",
-       "       [ 0.37659753,  1.65446423, -0.91445505, -0.04840952],\n",
-       "       [-0.39994851, -0.91445505,  2.35565062,  2.2607159 ],\n",
-       "       [-0.81121869, -0.04840952,  2.2607159 ,  2.86731654]])"
+       "array([[ 2.49193844,  0.35638993, -0.39984418, -0.77608969],\n",
+       "       [ 0.35638993,  1.68815388, -0.90376817, -0.07406329],\n",
+       "       [-0.39984418, -0.90376817,  2.37468946,  2.18784107],\n",
+       "       [-0.77608969, -0.07406329,  2.18784107,  2.94523937]])"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -205,14 +208,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
+   "execution_count": 6,
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAd4AAAFmCAYAAADDB/vbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3XecXFd58PHfuXf6zvYurVa9N8uSLTdsyzYGl1AMJm9IIcBLCcRAyvuSQBKSQIAklIQUahJeAgECOAbiUG2De5Fk9d52JW3vOzv93vP+cUcrzc6d1a52d2Z39Xw/H32kvTvljLSaZ845z3kepbVGCCGEEIVhFHsAQgghxNVEAq8QQghRQBJ4hRBCiAKSwCuEEEIUkAReIYQQooAk8AohhBAFJIFXCCGEKCAJvEIIIUQBSeAVQgghCkgCrxBCCFFAnpl40JqaGr1kyZKZeGghhBBiVtq1a1eP1rr2crebkcC7ZMkSdu7cORMPLYQQQsxKSqmWidxOlpqFEEKIApLAK4QQQhSQBF4hhBCigCTwCiGEEAUkgVcIIYQoIAm8QgghRAFJ4BVCCCEKSAKvEEIIUUASeIUQQogCksArhBBCFJAEXiGEEKKAJPAKIYQQBSSBVwghhCggCbxCCCFEAUngFUIIIQpIAq8QQghRQBJ4hRBCiAKSwCuEEEIUkAReIYQQooAk8AohhBAFJIFXCCGEKCAJvEIIIUQBSeAVQgghCkgCrxBCCFFAEniFEEKIApLAK4QQQhSQBF4hZgFba4YTaRJpu9hDEULMME+xByDE1e503wi7zw1gadBa01gW4MbFVXhN+VwsxHwk/7OFKKKuSIKXWgdIWhrL1tga2ofiPHOmr9hDE0LMEAm8QhTRoc5hLK2zrtkaOofjRFNWkUYlhJhJEniFKKKRZNr1uqkUcQm8QsxLEniFKKL6sB/lct3WUOaXFAwh5iMJvEIU0br6Ujymygq+plJsaCzFI8lVQsxL8pFaiCIK+Tzcs6ae/e1DdA4nCHgN1tWXsqgiVOyhCSFmiAReIYqsxOfhhsVVxR6GEKJAZC1LCCGEKCAJvEIIIUQBSeAVQgghCkgCrxBCCFFAEniFEEKIApLAK4QQQhSQBF4hhBCigCTwCiGEEAUkBTSEmARba9qG4pwbiOEzDZZVl1AR9BZ7WEKIOUQCrxATZGvNL0/20DOSJG1rFHCiJ8K1TRWsqAkXe3hCiDlClpqFmKBzA7HRoAugAUvD7nMDJC27uIMTQswZEniFmKCW/uho0L2UoRRdw4kijEgIMRdJ4BVigjyG+38XDZiGW1ddIYTIJYFXiAlaUVOCqXIDrKGgvtRfhBEJIeYiCbxCTFBt2M+6hlIMBR5D4TEUXlNx2/IaDJeAPJO01qQtG61zl76FELObZDULMQkbGspYXl1Cx3Acr2HQWBYo6DKz1prjPRH2tw+Tsmy8psHGxjJW1UpWtRBzhQReISYp6DVZWlVSlOc+0TvCnvNDWJmZbtKy2dM2iKGQI01CzBGy1CzEHHKg/WLQvcCyNQc6hos0IiHEZEngFWKO0FoTT7ufF46lrAKPRghxpSTwCjFHKKUo8Zmu3wv73a8LIWYfCbxCzCHXLCjPOdJkKsWWBRVFGpEQYrIkuUqIOaS5MoRpKPa2DRJJWIT9JpsXlLOwPFjsoQkhJkgCrxBzzMLyoARaIeYwCbxiTrBszeHOYU70jmDZmqbyAJsWlBP0yt6mEGJukcAr5oSnT/fSORzHypykOd0XpX04wX1r6/GakqoghJg75B1LzHoDsRSdw4nRoAtOY4Jk2uJMX7Ro4xJCiCshgVfMen3RJG6lkC0NPSPJwg9ICCGmQJaaxawX9rv/mBoKSgMT+xGOJNKj/XQXlgeoDvlQBW5sIIQQIIFXzAG1JT5CXpPhRJpLiyUaSrG8+vI1k0/3jfBSaz8asDUc7Y6wuCLI9c2VEnyFEAUnS81i1lNKcefKWhpK/RjKmemWBzzcubL2slnNybTNS639WNoJuuBkSLcMxOgcThRg9EIIkU1mvGJOCHhNbl9RS8qysTX4PRP7zNgxHHdmtS6NBVr6ozSUBWZiuEIIkZcEXjGnTPbo0HgrybLMLIQoBllqFvNaQ2kA7XLdNBRLq0IFH48QQkjgFfOa1zS4eUkVplKYhsJQYCpYVVNCbdhf7OEJIa5CstQs5r2F5UFeu6GBswMx0rZmQVmAsoC32MMSQlylJPCKq4LfY7KiJlzsYQghhCw1CyGEEIUkgVcIIYQoIAm8QgghRAHJHq+Y90aSaU72jhBL2TSW+mmqCGLIGV4hRJFI4BXzWvtQnKdO9aLR2Bpa+6Mc6hzmrlV1eAwJvkKIwpOlZjFv2Vrz3Jk+LK1H6zSnbc1QPMXx7khxByeEuGpJ4BXz1kAshaVz61ZZGlr6o0UYkRBCSOAV85iplGu5SHBKRgohRDFI4BXzVlnA49o20GMoVkoxDSFEkUhylZgxWmtO90U52hUhZdssLAuwvqGMwGV66E4XpRS3LqvmsePdWLbOdAbULKoIsrgyWJAxjBVPWRztjtAxHKfE52FtXSnVJb6ijEUIURwSeMWM2XVugFN9UaxMZtOJnhHODsa4d00Dvgn2052q8oCX121opH0oTjxlUxv2Fa1OczRl8eMjnaM9hfuiKdoG42xfXMniSumUJMTVQpaaxYyIpixO9o6MBl0AG0imNSd6C5tRbCjFwvIgy2tKitoc4WDHEMm0zSV/JVhas/PsALZLEpgQYn6SwCtmRH80ielSpMLSms7hRBFGVHztQ3HXZC9bayKJdMHHI4QoDgm8YkYEvSZ2nu+lLDtrJny18OdZXre1xmfKf0Uhrhbyv13MiMqgl1K/ewpBfyzFEye60VfZ8urautKcY0yGgrqwv2AJZ0KI4pPkqiKLJNL0RpOEvCY1JT7UPKkhHE1ZbF9UwQutfQzErazv2doJvh3DCRrLAlN+rgsB/HJ/d22DMV4+P8hwIk3Aa7C+oYwV1SUF+ztfVBFkMJbicNcwhlLYGqpCXm5aUl2Q5xdCzA4SeItEa80Lrf209EdHC/YHvSZ3rKwlNIdnP4OxFM+c6WU4kUah8BgKBTl7m2lb0xWZWuBNWja7zg7QOhBFa6gv9bNtUaXrTLt9KM7Tp/tGK1nFUjYvnx/EsjVr6kqveAyToZRi44JyVteVMhBPEfSaeVcFhBDzlyw1F8mJnhFaB2LY2glCadtJsHn2dG+xh3bF0rbNz493MxhPY2snkSph2a4JRaZSU/qAobXm8ePdtA5EsbUT2DuGE/zsaBfJdO7u8t72wZzykZatOdAxVPCMYp/HoC7sl6ArxFVKAm+RHO+J5CQYaaA3miSestzvNMudHYhNOIgpBc1TOLvaM5JkOJFmbI5W2tac7hvJuf1w3D1r2LI1aevq2msWQhSXBN4iSeXJ6lUo0nM04zeWsvJmK3tNhakUpuHMdHesqMmb5TsRQ/E0bjHe0pqBWCrner7ZpWkoPOb82FcXQswNstZVJE3lQY73RHKCh99jUOKbm3u8NSE/hnK6/1zKVHBjcyWlAS8aKPN7ppzQVBbwoFw2j01DURnMLZKxqbEsa4/XGZdifX3Z6B67EEIUgsx4i2RDQylBj8mFyZbCCRrbF1fO2czm2rDPtRSkpSHs91AW8FIe8E7L66sp8VEW8HDp6RyF0wBhaXVJzu0XlAe5cUkl4cyHmoDH4JqFZaypk2YJQojCkhlvkfg9Jveured03widwwnCfg8ra8KE53DCTcrSJFwSmxRwqDPCjUuqpu25lFLcsaKWl88PcqY/itaahtIAW5sq8OYpRrGoIsSiihBa6zn74UYIMffN3Xf5ecBrGqyqLWVVbWGOs0yXeMqiZySJ32NknT0eTqYxlcpJsNJAXyw57ePwmgbXN1dyfXPlpO53uaCbsmzODsRIpJ2mCtWh+XO+WghRfBJ4xaTsaxscLQABzpLtjhW1hP0eSrxmzpGdC8qL2JxgMnqjSZ443o3GyXg2DEVjqZ+bl1bLXrAQYlrIHq/I0h9L0j4UJ5HOPdJ0fjDGke5I9tnjpMUvT/WgtSbgNWmuCDE2SdhUinX1s39Wr7XmqVO9pDKv7ULwbR9OcKYvWuzhCSHmCZnxCsA5CvTLkz0MJdIYOMdyVteG2bygfHSZ9Vh37tljgJGExVAiTXnAy/XNlfg9BicyLQHL/B62LqqgKjT7m70PxFKkrNw9asvWnOwdYZlL0pYQQkyWBF4BwDOnexmIpZxZXubasZ4RqkI+FpYHOTsQoy/qvk9rKEYDlmkorm2qYMvCcmxNTlOA2Wy809NXWT8HIcQMksAriCYteqPJnMBj2ZrDncMc6YowGE/lLeyhgcpg9oxWKZWz5DzbVQa9eIzcAiamoVhadeVVtoQQ4lKyxytIWXbexKGRZJqBWP6gayrFdYsqsma23ZEEL7b289yZPtoGY3Om/Z9SiluWVuMxnCpb4JwLrgn5WF4jy8xCiOkhM15BacCTCbzZAdJQzmwv4bLvqYCGsgCbG8uovGT/dl/bIEe6IqPZzS0DUcI+k21NFdSXBmb9sZzasJ/XrG+gpT9GPGVRV+qnPuyf9eMWQswdMuMVGBdmrcpp4QdOmUe/x8x7DMg0FBsaSrOCbiSR5nDXcNaRIq1hOGHx5KlenmvpmxOzX7/HZFVtmE0LymmYAx8WhBBzi8x4BeB0Cgr7PRzrjjCSTNNQGmBlTZjeaJKukWRONrPXNKgek6ncPhQnX4iyNJwbjNMx7N6DN5G2OdM3wnAiTU2Jn0UVwTmVmCWEEBMlgVcATi/d84NxuiMJwFl0Ng1FY1mANbXhrKIZpqG4fXlNzkzQYyjnWp5ZrWVrWvujOYG3P5bksWPdoz18T/dFOdAxxN2r6lxrPwshxFwmgVdkmsr3MBBLjnYWOtQxRPtQnLtW1rJpQTkra8N0RRL4TIP6Ur9rMtbCiiAvnRsY97ncZrHPnenLapOYtjUjyTT72wfZumhy5SCFEGK2k+mEoH04wWA8ldXOz9JOQYnOzAw46DVZXBmisSyQNwPaZxq8IpMV7MZUiqVV2dnBibTFcCK3Sb2toXUgdoWvSAghZi+Z8Qr6RpKux4XStqZ3JElDae6ebD6NZQFev7GRQ53DHO4czuz5KjSa9Q2lVJeMOe+bd1eYSddGtrXmUMcwJ3tHSNuaheUBNi8oJ+idm/2NhRDzkwReQdBnuhaO8BiKkG/yQctjGGxqLGdtXSnnB+OkbZvGsgAlvtwfN5/HoMzvYSCePes1FZMu0fjM6V7ah+KjM/czfVHah+Lcv64hb6tAIYQoNHk3EjRXBHFbHTaUYlFF8Iof12saLKkKsaIm7Bp0ATqH465LzaUB76QaKwzGU1lBF5wEsZStOdU7MtmhCyHEjJHAK/CaBneurKM84MFQTuGM8oCHu1bW4jFm9kdk17mBrGB5gWJydZ77oynX87aWrekemf5ewEIIcaVkqVkAUBH0cu/aBqJJp0XClSwxT5bWmsF47mwXnMSuyQj73cdrKCjzy4+5EGL2kHekAtNaz+pKSNMRcKMpiwPtQ7QNxfCZBqtrwyyrLsl53UopvKYi5TLlnez53eqQj7DPZDCezip8aSjFiprwlbwMIYSYERJ4C6Slb4S97UOMJC2CXpONjaUsr57dAeHS8o4t/TEOdQ4RT9vUlvjZvKCMMpdykom0xY+PdJJM22gglrLZdW6QgXiarU0VObdfXVvK4c6hrOVm01CsqZvc341SijtW1vJ8Sz8dw3E0zkx3e3NVQWbvQggxURJ4C6C1P8oLrQOjNYxjKYtdZwdBw/JZOBuLpSx2nu3nfKYEZKnfw3A8zYVWCecGY3QMx3n1mnpKxyzjHuuOkLLsrFmnpTUneiKsqy/NOdqzvqGUZNrmZG8EpRRaa1bWlLC2buKJVRf4PSa3La8hbdnYevKzZiGEKAQJvAWwt20wq3EAOMFoX/vQrAu8lq356dEuYikLjZMZ7LYPa9magx1D3LC4Kut653ACtw6CplIMxFI5gddQiq2LKti0oIxo0iLkM6d89MeTuX8ibXGoY5hzgzG8psHqujBLKkOzeqlfCDH/SeAtgJGU5Xo9nraxtZ50oYiZdG4wRnLMjNWNBnpGEjnXS/0eekaSOfe39fj7x17ToDw4fTPUpGXz4yNdxNJWpnS0xUtnB+iLplyXvIUQolBkLa4AwnnOsAY9xqwKugCD4zS9H8vtbO7qutKc12TgZE3nazE4E072jJBI21n9GizbWfKO5fkgJIQQhSCBtwA2NZZhjglGpqHYuKBs2p7DsjV72wZ5eH8b3917nmdO9xJNuh/VGU950Ju31vKlTKVY35A7/oqgl1uWVhH0GJhKYSioLwtw2/KaSY9lKjqH4znL++CMuy8q53qFEMUjS80F0FwZAmBP2yAjSYuQ12RTYxlLJ1kScTxPnuqhO5IYzQ4+OxCjK5LgvnUN+CaxZ9pUHmSPOYhlW+MuNy+vDlEX9rt+b0F5kNduCBBNWXgMA38RkpxKfB4UiZzXoEFqNwshikoCb4E0V4ZGA/B0648l6Y4kXcslnu4dYfUkMoRNQ3H36jp2nRvg7DjdgS50LcpHKZW3TGQhrKoNc7ovmjXrVUCJz6QyWLglbyGEGEuWmueBgVgKt61iy9b0XEG5xKDX5Jal1WwbJwkpOsv3ScuDXm5eWoXfY2AazpJ3TYmPHStqJatZCFFUMuOdB8aepb3AUM6e65U63Ze/uUCZ30PHcBzb1tSG/bOy+8/C8iCv2xAgkkjjMQ1CssQshJgFJPDOA9UhH2G/h6FYarTIBTiJRJNtrXcpt+YFFwzEUjx1qheFc1To+uYKllRN3571dDGUcq2wJYQQxTL7pili0pRS3LGilgXlQZRy9jKrQl7uXFk7pUSi5oogZp5VWUtD2takbI2lNS+29jMUn1xjAyGEuBrJjHeWiqcszg3G0BoWlLs3kb+U32PwimXVWLZGo6elnd+q2jAt/VEiSQvL1igY3Usee9TX1nCqN8o1C8un/LxCCDGfSeCdhVr6Rnihtd+Jclqz+zxsbixnzQQawzs9bKcnechrGrxqdT0t/VHah+KEfCY+0+Bg5zCMOSOrcapFCSGEGJ8E3lkmnrJ4obXf2V+9JLjtax+ksTyQt/pTS98I+zLdj0r8Jpsby6fl+JJpOPvEF/aKR5JpDnQM5dzOYyiaygNTfj4hhJjvZI/3ErbWnBuIsb99kFO9I6SLMIM7NxjD7WyQraGlP+p6nzN9I7zQOkAk6RS9iCQsnm/ppzXP7aeixOdhdW04M7N2eAxFbYmPxjIJvEIIcTky481IWTY/O9bFSNIibWs8hmLP+UFeuaqW0mnIik3bNmcHYkSTFtUlPurDftfzpHrMTHf0uvtlAPa2Dbl2P9rbNjgjRTuuWVhBQ1mAkz0jWLZmcVWIRRVBOR8rhBATIIE3Y1/7EMOJ9GjSUNrWpNE819LH3avrp/TYg/EUPz/Wja01lq0xDUVF0MsdK2qzZo7gJFK9fD73MUylWFQRzLmutc5bzGIkOXNFLhpKAzSUygxXCCEmS5aaM1r7o659ZPtjqSknDT17uo+kZZO2NRonqPdHkxzuHM65bYnPw6YF5ZjqYoqUqRQra0uoCvlybq+UIuh1/2ccrw2fEEKI4pAZ72VMrEFefrGUxVAi93yrpZ3KUBsaczv8rKkrZUFZgDP9UbSGRRVB16B7wYaGMnafG8xabjaVYqPLYwshhCiuywZepZQfeAOw5NLba63/cuaGVXhLKkMc64lkzXoVUBPyTaq7z1jjBe7xvlcW8LKpcWJnYlfUhAHY3z5EPG0T9Bpsbixn6SysJCWEEFe7icx4vw8MAruA8VvSzGEbGsvojCQYTqRHk6s8huKGxVVTetyQ16TU72Ewnt0b11CwtMo98cmyNWcHYowk01QGvTSUBXKay4+1oibMipowWmtJchJCiFlsIoG3SWv96hkfSZE5xSLq6BhO0B9NUuL30FQezEl+uhI3LanmseNdWNoJqh5DURbwsNalIEYkkeZnx7qc5K7MbcM+D3etqp1QIwIJukIIMbtNJPA+q5TaqLXeP+OjKTKlFI1lgWk/j1oR9PKa9Y20DsSIJtNUh5wzr25B8vmWPhJpe3QZOm1rhhIp9rUPsrWpclrHJYQQovDyBl6l1H6cbUgP8Fal1CmcpWYFaK31psIMcX7wmgbLL9MpKGXZ9Iwkc/Z+neIZsSkH3kgizdHuCAOxJFVBH6vqwkVtVi+EEFej8d517y/YKMTlTTG9ui+a5LHj3ZkmCtAVSXK0O8Ky6hAbG8un1MVICCHExOXdNNRat2itW4CPXfjzpdcKN8Srh9c0qCnJPTZkKFhcmVs8YzJ2nu0fPUd8gQZO9kZ59FAHAzFp6SeEEIUwkXXG9Zd+oZQyga0zM5zppbXmWHeEQ53DJNI25QEPW5oqClpxydaa031RTvWOoLVmSVWI5dXhvElbNyyu4qfHurAuSa4q8ZlsXHDl7fa01vRG8wfWlK158Ww/d6+qu+LnEEIIMTHj7fH+MfAhIKiUutCORgFJ4EsFGNuUHegY4nBnZLSwxEA8zZMne9mxoobasH/Gn19rzTOne2kfTmDZF8YwxLmBODtW1LgmV4X9Hl6zvpGzA1FGEhaVIS+NLseJbK1JWTYne0c4NxAn4DFYVRfO+6HCNNToGNz0jiSxtb7ssSUhhBBTkzfwaq0/AXxCKfUJrfUfF3BM08KyNYe7Iq7NA/a3D3HHytoZH0NfNJUVdC+MqzeapGM4kTd72mOovMUvYimLnWf7OT8Yz9n27Ygk2NhQlnNMSSlFQ9jP+aF43rEaarq6+AohhBjPeDPeazN//M4lfx6ltd49Y6OaBvF0/gYBg/HcZVetNZbGqZE8TbO+rkgC22WWmbY1XZH8gTcfW2t+numg5DZ3tWzN/vZBlteUZFXb6hyO036ZoNtcEZIzwEIIUQDj7fF+OvN7ANgG7MWZFG0CdgI3zuzQpibgyZ+lWxa4+LK11hzoGOJIVwTL1gS9JtcuLGfRNLTTC3gMTEORHhN8TcUVZRG3D8WJX3LG142toW0wxpJLZsx72wbJ1+bBVIrKkJdtiyomPR4hhBCTN15W8w6t9Q6gHbhWa71Na70V2AK4NK6bXUxDsaY2jDlmFuc0D7iYqLS3bZDDnZHRjN9oyuK5ln46xpkhTlRTRdB1+VYpdUVZyk7bwvHPFWlg57kBkumLoXZoTLnK0XEAty2v4ZWr6iZUFUsIIcTUTeTddvWlVau01geAtTM3pOmzsbGMDY2lo8uupX4Ptyyrpi6TWGXZmmPdI+77wB1DOY83WV7T4I6VtQS95mjt54DH4LblNfjHmZHnUx7wTij5ybI0J3ojo1+X+N0XNjyGojacv+uREEKI6TeR40T7lFJfAb6e+frXgX0zN6Tpo5RiXX0Z6+rLXJsHjLcPPJxwnyVOVlXIx2vXNzAQT6E1VAa9V7yX2lDqJ+wzGUqkXXsHX2ADPSPJ0a83NZbxzOm+7LaBhmJNfalrIO+KJHj5/AADsRR+j8m6+lJW1pTIHrAQQkyDicx43wocBN6f+XUoc21OcQsaAY9JvlhSEfBO63NXBn1UhXxTCl5KKe5cVcfSqhI8hsLM81CGcmbHFywsD7K9uYJQZl/ZZyo2NJSx3qVJQ+9Ikl+c6KEvmsLWThb1nrZBDk7DCoAQQogJzHi11nHgs5lf84ppKNY3lHGgYyjryI+pFJsWzM4m8j7T4PrmSq5vrkRrzU+PdTEQS2XNgA2lWFmTfRxpcVUJi6tKsGztHB3K8wFgX/tg7tK7rTnUFWFtfdm0dGsSQoir2XjHif5Ta/2mS5olZJkvTRLW1oXxm4qDncPEUxYVQS9bFlZQUzLzBTamSinFjuW1vNjaz/mhGFpDecDD9YurCOVpfnC5wDk4TunIWMoinGe/WAghxMSM9y76/szv87pZglKK5TVhlteEiz2UK+LzGNyyrBrL1thaTzk7uTTgIRZJ5n5DQ8Armc9CCDFV4x0nas/88S7A59IoQcwipqGm5UjQxsZy1yNYK2tL8BgSeIUQYqom8k7aDHxRKXVKKfUdpdRDSqlrZnpgojjqwn5uWVpF2OckYnkNxdr6Uq6ZQpMGIYQQF00kueojAEqpIPAO4P8AfwfMiwauVqZ8o6019WE/HikkwYLyIAvKg9hao5i+EppCCCEmEHiVUn8C3AyEgZeBPwSemuFxFUTncJynTvWOZo5p4IbmSpqnoVzkfCCdioQQYvpNJEX1ASANPAr8EnhOa52Y0VEVQNKyefJUb04d5edb+qgu8VGSJytYCCGEmIrLrqtqra/FSbB6EXglsF8p9fRMD2ymnRuIuV7XwJm+aGEHI4QQ4qoxkaXmDcArgNtwuhSdZR4sNaczx2/GsjWkrHy9fIQQQoipmch66ieBJ4HPAS9prfNXWJhDGkr9rp2DTEOxoHzynYOEEEKIiZhIVvO8LKBRFvCyvCbMyd6R0XKRHkPRWBagtkQ69gghhJgZV3UG0bULy1lQFuBU7wi21iytKmFheUCOzwghhJgxV3XgVcqZ4TaWBYo9FCGEEFcJqRYhhBBCFNB43Yl+iEtXogu01q+ZkREJIYQQ89h4S82fKtgohBBCiKtE3sCrtf5lIQcihBBCXA0mUkBjJfAJYB0wmoWktV42g+MSQggh5qWJJFf9G/B5nHrNO4CvAV+fyUEJIYQQ89VEAm9Qa/0YoLTWLVrrPwfum9lhCSGEEPPTRM7xJpRSBnBcKfW7wHmcFoFCCCGEmKSJzHjfD4SA9wFbgd8E3jKTgxJCCCHmq4nUan4JIDPrfZ/WenjGRyWEEELMU5ed8Sqltiml9gP7cHrx7lVKbZ35oQkhhBDzz0T2eP8VeI/W+ikApdQtOJnOm2ZyYEIIIcR8NJE9XutC0AXQWj+Nc7RICCGEEJM0kRnvL5VSXwS+iVO7+VeBXyilrgXQWu+ewfEJIYQQ88pEAu/mzO8fGXN9C04gvmNaRySEEELMYxPJat5RiIEIMV9pK4lu+Rl0vgRaQ/1W1OK7UR7pAy3E1WgiWc31Sql/UUr9KPP1OqXU22d+aELMfVoUCqZVAAAgAElEQVRr9N5/hrNPQGIAkoNw7kn0y59D21axhyeEKIKJJFd9FfgJsCDz9THgAzM1ICHmlYHjMNIG+pJ8RJ2GWC/0HSreuIQQRTORwFujtf5PwAbQWqcB+aguxEQMnwXL5RCAnUAPtRZ+PELMYR27n+CXH3qAH73jBp75y9+k79jLxR7SFZlI4B1RSlXjJFKhlLoBGJzRUQkxXwQqwfTmXjd8qEBV4ccjxBx17ukfsutzv8/gmcOkRgbpPbKT5z7+NnqP7Cr20CZtIoH394EfAMuVUs/gtAV8aEZHJcR8Ub0RDC+gsq8bHqjbUpQhCTHXaK05+B9/i5WMZ123knEOffNTRRrVlZtIVvNupdRtwGqcd4+jWuvUjI9MiHlAmV649gPoQ/8OkXPOxZIG1NrflKxmISYoHRshOdzv+r2h1mMFHs3U5Q28SqnrgLNa6w6tdTpTn/kNQItS6s+11n0FG6UQc5gK1qC2/h46NQJao3zSVVOIyfAEgpheP2mXfIlAVX0RRjQ14y01fxFIAiilbgU+ibPMPAh8aeaHJsT8orwlEnSFuALKMFl271sw/cGs66YvyOo3vLdIo7py4y01m5fMan8V+JLW+nvA95RSe2Z+aEIIIYRj9QPvRdsWp370NbRtYfoCrHnTB2i66b5iD23Sxg28SilP5vjQncA7J3g/IcQspZMRUAbKGyr2UISYFGUYrH3TB1j9wHtIRSP4wuUowyz2sK7IeAH0mzgNEnqAGHChLeAK5DiREHOKjrShD38dop3O12WLnQSvQGWRRzZ3aa0598wPOfWjr5GODlO/9Q5Wvuad+Muurr9TrTXJ4QE8gRCmzz/jz2d4fPjL5vZRPKW1zv9N58xuI/BTrfVI5toqIDxeV6Jt27bpnTt3TvdYhRBXQKei6Of/EqxLj2Io8JWhbvizcWcNOp2A4VbwBCG8EKVU3ttebQ587RO0PPEdrEQMAMPjxVdWzY6/+QHeUGmRR1cYHbufYN+//gXJoX5QsPCm+9n01j/F9F2dGftKqV1a622Xu924S8Za6+ddrs293G0hrmK6cyfoscXmtBOI+w5DzQbX+9nnn4aT3wdlgrbBXwGb3oUKVs/8oGe5eH8XZx77FnYqOXrNTqdIRgZoeeK7rLjvrUUcXWH0n9jHrs/9ftbZ2vPPPko6NsJ1H/i7Io5s9ptIAQ0hxFwW6wHb5ei9bUG81/UuevC0E3TtlBOg7STEutH7Ps94q2RXA22n6X/qCxhOFd0sdjJO9/5nijCqwjv+gy9hJRNZ1+xUgs6XnyA+0F2kUc0NEniFmOdU2RIwfC7fMKC02fU++tyTLsFaQ2LoYiGQAtPaRvcdRbc9ix4+W5QxAOij3yKQOuf6AUQZJqHahUUYVeGNdLSQqSScxfD4iPd1Fn5Ac4hkJwsx39VugjM/dma3F5acDQ+ULoKyJe73SUXcrysDUiMzMszx6MQges8/QHLYWfZGocuXoDa+E2UU7m1Mp6LQtYeyqiChsiDD/ZGs2GN4vCx91W8UbDzFVLnyGiJtp3PaW9rpFCUNS4ozqDlCZrxCFFm0p43zz/0PPYdeRNu5y5dTpQwP6toPwIJbwFfm7NUuuhO16d35k6VqNmRqTI+hLShbPO1jvBx95BsQ6wMr4czE7SQMnka3/LywA0kOg2GilGL7vduorK/AMA1Mj4kv6GfrQ5+hrGllYcdUJCtf+y4nieqSnyHTH2TZPb+FNySFYsYjM96MRNpmz/kBWgecDMWm8iDXNpXj98zNc2JXC631nM201Vqz/6sfpfUX33NqOgO+0gpu/pP/N+3LlcobQq18Pax8/cRu33gDuu0ZiPdfXHI2fLD0HpQnOP6dp5lOx2HgJIzdU7VT0PE8LH114QYTqOLCFDcQ8nPza7YTjyZIJ9OUrLgZc8OOwo2lyErqmnjFR/+Tw9/+DL2Hd+IrrWTFr7yd5tvfUOyhzXoSeAFba35+rItIMo2dWTZq6Y/SM5LgvnUNGHP0jX0+0z0H0ScfcRJ+vGFofiWq6dY5FYTPP/soZ598xMmMzWTHxhIxXvz0e7n9k48UdWzK9MO1f4Bufw569oE3jFr4ClRlEWZzepxVANul1/EMUqYXveQeOP0jZ9YNBEIBKPWhlt1T0LHMBqULl3H97/9jsYcx50jgBdqH4kRT1mjQBeczbTxtc24gRnOlVPmZTXTfUfShr16ciaUicPpRtJ1ELX5lUcc2Gad/+o3RM6CjtE2ko4WRzrOU1C8qzsAylMePWnQ7LLq9uOPwhtChehhpG/MNA2o2Fnw8xqIdaH8FuuVnkByC8qWopfehQnOvWL8oDgm8wEAshWXnZuelbc1gXDogzjb69KO5Gbd2ElofQy+6Y86UkUvH3JOUlGGSTkSzrg2dO07fkV34y2uo33IrhsclS3keU2vejN7zj84es51ylr19YdTS4tTpVXVbUNJPWVwhCbxAWcCDaSjSY4Kvx1CU+l0STERxxfKcEdRpSEfBNzeqBi244VUc/35LVhEGANPrpaxpBQDattn9+Q/S/pKTRGQYJobPz81/+jVKFy4v+JiLRZU2wfY/QXe8CLEuVNlSqNuCMq+uDyBifpCsZmBheRCfaXDp7qDCCbyLKgqbSCImIN+SnvKAZ/q2BbSVwG57FvvIN7HPPuH0051Gy+/5bUI1C0dbnSnTg+kLcM27Pj46az/75CN07HwMOxnHTsZJx0dIDvXz4md+96ooZKG1RvcfQ5/5MfTsQzXegLH6f6Eat0vQFXOWzHgBQyleubqOl1r7aR9yyp81lPq5rrkS05g7yTpXC7X0PvT+L2UvNxs+WPzKaVtm1okh9K5PQzrmLGMbXvSZn6DXvxU6dzmlFr1BaLod1XjjFSV1eYIl3PaJhzn3zA/p2vs0wepGltz1q4Qbl47e5sxj387dB0YT7+1gpP0M4QVLmSl2Oknb8z+hc+9TBKvqad7xRsIN03OUSFtJZ/bavQ+8JU7iVsWy7NvYafS+L8JwC1hJ59/45Pdh83tQRTjSJMR0kcCbEfKa3La8Bjszi5BM5tlLVa6E9W9zspqjXc7ScvPdqIU3T9tz6FM/dM5sXjjCYqeAFOz/YuY0iQ2pYTjxCHqkHbXyyo5QmL4Ai3c8yOIdD7p+304nXa9jGFj5vjcN0okYT//5mxnpaMFKxFCmh9M/+TpbH/oMDVundmRGW0n07r/LlLJ0XoPuPYBedj9G020Xb9f2DAydufgBK3Nb+8C/cTa+nuP/9XniAz2ULlzG+l//v9RuvGlK4xKiUGSpeQxDKQm6c0Gozqm6FKyGUD2qpG56jxL1HiDn3ChkjrZcct1OQttz6OTw9D33JZpuvh/DpdOLxxec0UINZ37+LSLtZ0Zn29pKYyXjvPyFP8JOTy3h0Nmn7R4NpIATXE/9Nzp9yey+4yXXGtOndu3n4Nc+Tqy3HW2lGGo9youffi89h1+c0riEKBQJvGLO0bEe9M6/dd6YYz0wcBy9/8vYHdP4xqsmsWRteCDSdvnbXYGld/86pU0rMP2hzFP5MP1Brn3oUyhj5v77nn/2UexkPOe6ti0GW47kvd9g61H2fOXPeP5v3sWpn3yddDyae6Oefe5NG5QJg6fHHZdt2xzfdSyrIw6AlYxz+Nt/P+59x9KpKLrtOXTLz9CDp66KPXMxO8hSs5hz9OkfOaUDLy2Sa6ecZd+6rdOzz9uwHc790smUvuyALAhUTP05XZi+AK/4i2/Ssetxug88R7CqnkW3vp5gVf4zo5GOFo5+75/oO7qLQGU9q173Tuq33D6p5/UE3JPUtG3j8bsnHJ5//kfs+cKHsNNJtG3Te+hFTv/k69z6se9mlxD05isnqLOT4xq2w6nOrCCdSqSwLfeCGpHzJ8Z9TVnPNHgave8LoHXmeJIXMlsYc+U4mpi7ZMYr5p6BE7h1RcFOQ6I/7920baHbn8fe/ffYL/8DuuMldJ6qSGrJq5ylbMPn/DL9TrlANeazqjKhdNGMFk8wTA8Lrr+bzW/7CKte9+5xg+5IZytPfviNtD33KLGeNvqPv8zOv/89Tv/sm5N6ziWv/LXRbOtRShGorCfscozJTifZ++U/w0rGR+tNW8k4sd4OTv/k37MfZuEtLnWgFXhLsupAqwU3QfmyTGclBYYPb7AU5fG7jrmkfmIJV1rb6AP/mqn7nAS083v/cejcOaHHEGIqZMYr5h5/OSQHc69r23nzdqG1Rh/4MgycupjQM3wWeg+g1uc2LVemD655Lwy3OsvIwWqoWAH9R9FHv+1Uy9Iaqtah1vzatL68qTj6vX/ESkSzmi1YyTiHv/UZFu94w4QLbyzY/mr6juyk5YnvoUwThcIMhNj+h//supc+1HoMtw9DdipB24s/ZdXrf2f0mipfhl72Gjj1g8ySvnYymzf9TtZjK8OETe+GwVPOL18pZu01rOhbwokffiUr29v0BVjzpvdP6LUROZ+9vzw62CS6/XlU4/aJPY4QV0gCr5hzVPNd6MNfz37zNDxQvTF/Af+B41lBF3D+3HsIPdSKKsvtS6uUcmZglx5dqVoLN3zECfxmAOXJTXwqpt4ju1w7HGnbJtp9Puuo0niUUmz87T9l+X1vo/fITvxl1dRsuAHDdH/L8ATDaMty/Z63pOyScVh07XuGSPtpwg33ULuoHuUrgdLFrgFdKQUVy51fGate/zsYXj8nfvhlUpEhQrULWPcbH6Ru0/RltQsxkyTwijlH1W5Cx++FM/8DKLCty848df9x91mOtp2la5fAm/f5lXJa681CwaoGYj25iV7aTuMrrZr841VUsLAuDt2PwnOPYtdtQS29H+XN3gMONy6hpGExQ2ePZzU1MP1BlmX60yaH+3n6L36DWF8HOp1GeTyEahZw8599Hd8kMtKVUqz8lbez8lfejm2l834YyCu80Fm+thLZ1w2fzHZFQcger5iTjEW3o276GGrLB1A3/jnGhreNW8lI+cLu/WWVmXd5upi01uhIO3r4XN59aDcrX/tOp0fqJQyvn4atd+ILl09uDLaF3v330PGiU0gkHYP2F9Avf851TNf/wT9RUteEGQjhCYYxvD6Wvuo3aNh2FwD7v/oxRjpbseJR7HQSKx4l0tHCgX//5KTGlfXaJht0AaUM1Ia3gunL/Ew4+8dUrID66654LEJMlJqJFPpt27bpnTslSUHMHjoZQT//l7mzXtOPuvEvZtWSsY60oQ98BZIRp8m44UWte0velnw6NYI+8V/QvReAlpYUh3/xDNq20Xaaxm13sfmdH8ubjZx3HN37nAb0Y2eGph+17rdQ1etz76M1/Sf2khjspXLlZgLlNaPXH33LZtczwIYvwP1ffXlSY5sOOhWF7pchOeIsZZcvm1NtJcXso5TapbXedrnbyVKzuDoYHlj/Njjy7xd7uJp+1Ia3zaqgaycjsOsz2ceYrAR6/5dh+4dR/uxZq9a2UwUq3ju6xLt4kcGit91LbOlv4S+rmfRMd/SxI+dzgy445RsjbeASeJVSVK28xv3xXPaeAch3fRwdu5/g5KNfJTncR901t7Hi/rfjL6uc1GMobwgWyL6wKDwJvGLW04OnnRld5JxzzrPpdlTzHSh1+Z0SPXgaffRbmY5GCmo3Q+NNzpGU8MIJPUahaNuC3WOC7gW2he7ciWq+M/t67yGnJ2zW0q+NYccJe4ZQ4SvvYKSCtWjT7zLj9UGwdnKPpRR1m2+hc89T2WM1TOq33Jb/ji6Of//LHHvk86NZzZH2Fk7/9BuYPj+mP8iSO3+VFfe/HcMjncXE7DR73nXEvKC1Pa0VgHSkDb33n51jPdp2jvG0/AR98vuXv2+sB7338xDtdO6rLaco/5kfo0oXTVvQ1VqTGOojHZ9i96K+Q5AYyvNNCxIuR6hGOsByqQJlJdCR9qmNp3aTE2Sz+nYZYAagZsO4d9W2Re/R3XTvf5Z0JkBuettH8JdXjVbhMv0hAuXVbHjLhyc8pFR0mKMP/1PWUSJtpbCTcVKRQeK9HRx75Ivs/PsPTPgxhSg0mfGKaaEHTqKPfxdG2sH0oxfcglp675SrAOmWn1xcGr7ATkHbM+gl94y7TKzPPZl7X52G4Rb0SAeqpGFKYwPn+M6eL36IWG8HGk3dxpvZ8jufwBeefNazHjydv1KWMlGVq3Ovh+rA9Lpk6PpRJVMr6qFMH2z5gLNiMHDSuVi5ErX6f6GM/G8dA6cP8sLfvNsJjkqhbYvN7/gYTTfdy52f/Sltz/2IoXPHKWtezcIbXo3pC6Dj/c6Hqb4jTsLTghtRi+/OeZ7BlsMYHi92ymUJPMNOxuna/yzD505QmulrLMRsIoF3HtLpuPMm1rnLmeVVrkKtfCMqWD0zzxdpc9q3XUhcshJw/kl0chi19s1Te/DIeVyrVCkPxPsgvCD/fUc6cG10oExnT3SKgXek6xzP//U7smZfXfue4blPvoPbPvYdtJWAxAD4KrKqLaVjI9hWKic4K38l2vC61zEOVEP12tzr1eudEoxWiouv1QBPwFlWnyIVrEZd81505gPMeAEXwEolee4TbycVyZ6d7/nSh6lYspbwgqU03/6Ak7Xd9gzs+mtnXxvLKUiCBisOZ59AR9pQG/931uMEymvR1uXLeCrDYPDMYQm8YlaSwDvPaK3R+z4Pw+cvzp76jqB3fwau/3DO+ctpec6Wn+UGCzsFXbvRy1/jHOW5UiWNTiOEnCdNX/4sbfmSzExtTGEHO+087hSd/snXc7J0tZUicv4k/U99kXJ9ApQB2kYvuIlE9U3s+cKH6Tn0AqAIL1jKlnd/nIqlmSSl+mvh9H8Ti8Q5secUPed7CZQEWL5lJXW/+knXpXFlmHDtB9DHvpPpqARUrUWtevCyQXIyJvpY3fuexk7nBkZtpWn95cOs+7U/cL4+8yM4+wv3s9Xg/Pz0H81ZmQgvWEpp00oGWw6PH4A1hOqaJjRmIQpN9njnm+EWiLSPWbLUcKHx+EwYacd1Vmp4nJnlFKjFd+eevzW80LD98h8ivKXkBF1lQuVK9NlfYB/5Jrr30KTOyV4q0n7a9c1foYmeetoJHlYC7BT6/DM8+5EH6Tn4PNpKo60Uw2eP8exH30Ji0Pk7Ut4S4s1v4smHn6P18DlGBqP0tvWx62d7aXniv/KOQ/lKnXPMt34adeunMTa+A1WEAh/pRIxj3/8Slstet7bSJIZ6M39OwNkn8gfdC5SR+dnKtv3/fJ7K5ZswvP7cetKAMj2E6hZSmSe7WohikxnvfDPS6X7dTmWWbWdAaZOTwDQ2+Oo0BGum9NCqdBFsfCf6xMOZ/eMANN2GWvKqce+no51OLeDc70DfMeAIoNHdL0Plalj/VpQynMSwoRanmpW3BGo35w3w1Wu20XPwhZz9RjudpLwyOyD0nu8kPtjvZC5felsrTcsvvseq174TgBOP/w/pVHaCmpWMc+ibn6L5tgcwfe4NAoBpPYOaHO4nOTxAqK5pwtnBe77wIQbPHHb9nukP0XDtDueLeJ8TVC/R2dLFiZdPEY8mqGqoZNW2FZRU+Jwl9jH85dXc8uffINrTRioyQDoRZ9+/fIRIewugqdt0M9e86+NyJlfMWhJ455tQnft1wzv+fugUqOZXorv3jamd7IWG61HTUBVKVa5EXfdBtLYnnImsO15ySknmfGPM7NZKQt9R6DuMrlqLPvhVJ8HHTjsz9pOPwKZ3ocqX5TzU4jvexKkf/T+Sw+nRgGr4AjQ2VxEqyw7W0aFY7nPjNBEYab/Yg7b7wHN5ZtGKSPtpyhevmcCrv3Lp2Ai7//mDdO19CuXxoAyTDb/xRzTf/sC490sM9dOx+3F02mUWqwwqlq6n/kLg9ZVn/ducOdjK4ReOYqWdv5/zJ9rpbOnmFb/1AOHSRXmfM1SzAGqcn+kdf/NDkpEBDI8XT2D2VSIT4lKy1DzflC1xkoayGrlnqh81zEwdWlVSj7rmd6FsaaYEYxgW341a+YbpfZ7JHP9JRXFNrHJjJ9Fde51ktL4jmQ8QtvO7lUAf+FfX5WhfuJxb/+p7NN3yGnxlVYTqmljz4Pu45v7c2XhFbRma3BmY6Q9SuXLL6Nf5Wv7ZVgp/+cwkx11q1z/+IV17nxot6ZiODrP/qx+l++Dz494vMdiNYbrPjH2lFdz4oX8ZLe+ovCFouA4ML5Zlc+TFY6NB94J02uL4keikZq2+cIUEXTEnyIx3nlFKweb3oI8/DN27nZlF5UrUygdnJLFq9HnLmlHXTrAtWwGomvXozp2X30d0bg2mD93xQp52cSkYPpvdpSgjWFXPlnd/POuaHjjpNFm/JOGsrLaa6lWb6T1xCDsZd57V9OALV9B08/2jt1t+/1vpP74HK3MbAOXxUrNuO4GKyRWtmKz4QDfdB57FHjNrtZJxTvzgy9SuvyHruo71wPA5CFQRqlvkfn7bMKi/5rac5Wq18o1oM0Ds4I/dsgNAa3qPFb6MpBCFIIF3HlKegHOMZ+2b0VqPzhp0OoY+/zT0HgRfOarpNlRF7hLqvFC11qm/O3DyYjA1vBcLaVzK8KAat6NPPDLOA068KIiqWA5b3oc+82OntGJJA2rJq9h+0wKO/+ArtDzxHexUksZtd7HmwffhCTgfiOz2F6gd/jFrr1/B4RcOgzLRGmrWbWfrQ5+e3Ou/AonBXgzTi53K/fAR6+0Y/bPWNvrwN6Bnr7PCoTVGsJbVr38nRx/+IlYyc7xKGXj8oaxevBcow0SteC3++legv7eDnCQ4IFg99czz2SIdj9L24k9J9HdRueoaqtdcJ3vQVzEJvPPcaNBNRdG7PuWUF8ycydR9h9DLX4+x8KZiDnFGKGXAxndA91505y4wfajGG0AZTt1jyJwbtWHpvU4SV+N29PBZ7HSc6FAUX8CHL+Bz9npLJ942EJykMLXxHdnXgNUPvIfVD7wn5/a65yAc/y7YKZasW8iiVQ2MDCfxNW8ntPVtV/i3kF/Xvmc4+vA/Ee0+T+Wyjax58H2EG5e4Lqkr00PNuusvjvXck9CzL/NzlNmPjnawbEkZofd8kuPf/xLxgW5q1mxj9RsfoqQ+/z6tv7SKhm130LHr8ayAb3j9LLz5PrRto4y5vSM22HqUZz/6W9hWGiuZwPT5qVi2gRs++GVMb/6OWmL+ku5EVwn7zI+h5ee5lZEMH+rmj43bUm++0VYS+g47RSeqVqN8pc51bdP6H7/HwZ89jrY12tbUNtey5aF/wNe4cUbHZO/6jFMWcyzDi7r5r6b13+fs0z9g31c+cnE5WylMX4BbPvINeg69wJHvfO5iURDDxBss4fZPPjI6A7Wf/6j7MTFlOmOdZNOJdCLGni9+mI5dj6GUgZVKoAzTSZQKlbLtoU9TveayDV9mJa01j//hvYy0n8m6bvgCrHnwfay4761FGZeYGRPtTjS3P0qKies56F6OUBkzd8xollKmD1W7GdWwbTToAvQeeokDP3uSdDKNlbawbZuuc33s/vd/nPlBxfvzfy81xRrQl9C2zcGv/3XWHjJaYyXiHP72Z1l+72+z9Xc/ReWqLYRqF9J86+u47eMPZy/7Wvn2zZV71a3L8PiDbHvfZ7jr736O4fWB1mgrjZWIkejv4vm/fifxQZciKmNfWzqOHjiFjnZPegwzJdp9PmuZ/gI7Gaf1F98rwojEbCBLzVeLfNWjtDUrG8EXw/Effjk7IAE6naLnwHPEDv8PgYXroHTxzOzNlTU7e+9jKQ/4yqbtaRLDfaRjEZfvaPpP7gegYesdNGy9I/+DVK+HjhfJyRoPVDgZ7Veo79hutJW716ttm3NP/YAV9+dfcrdbfg4tP8nsOVvocBNqw9unVjVtOmi3XHZxtZMZ71VCNd0OxpjlSmVAqB6V7+zvVcZtZgJgKE380CPoPf+M3vMPzlL1NFNL7xv990mn0pw51MqeXxzkRItJMpKvY9HkeYOlkOeDw0SzptXSe5wPchcqiinT2bJY/eYpfShJDPRgu5xhtlMJYn3u/zYAuucAtPw0UyksnslCb0Uf+uoVj2W6hOqaCFTm/v8yfH4WveJ1RRiRmA0k8F4lVNVqWHqP82ZpBpw3+VBDThH62UwPncE++m3sw19H9xy4bKlHnU6gu/agO3ehJ7BcW7NuO8rMXQTSWhMu9zvZ0UOtTp3haabCC1DXvp+4bzG/+M9nOfz8cc4dO8exn/83j/3+qxhqPTYtz2P6/DTf9gYMX/Y+rOkPsuqB3Oxj17H6y1HX/REsvdeZ/Tbdirrug1POkK9avcU1cJv+EDXr8p9B12cfzz0Gpi0YOoNODExpTFOllGLb+z+LJ1Q6Wt7SDISoWLKeZa/+zaKOTRSPLDVfRYxFO9CNNzpnUr1hVHjuHNcYXUq00zilHvdB1RpY/9uuhTV07yGnCtWFN3JtoVe8AWPBjXmfY8Wd93P+qYdJ2Rc65YDpMVm1bQWmJ1OQRKeh/UVY/tppfoWgwgs5sreLRDw1Wr3KTiawkwle/uKHuO2vvjstz7PhN/8Ibac5++T3UYaBMkzWPPgQC2+4x/X2WmuSw/2Y/iCeTPBQ3hBq0Q5YtGNaxgRQvmQdddfcStfep0aTuwxfgNKmFdRvuS3/HZNuS+c4M/FU9PLNNGZY+ZJ1vPJzj9P2wo+I9znHiWrX3zjns7XFlZPAe5VRngBUriz2MCZFJwah5cfZvXXtpFNlqu9oTrs8nYqiD/5bbqLPiYfRFStQodwlVd13lMCZ/+DWB7ZzbPdJpzNQ0Mfya5bRsGTMUmG+nrnToHP3464lI4dajpCOj0xLZSbD42Xz2/+C9b/+f0kM9ROsqsPwuGdNd+1/hr1f/jMSA05yU+N1d7H5f/8lnuDM5AVse99naPnFw7Q+/p/Y6RRNt7yGpXe/ebTqlavqdXC+N/d8Nip/CdUC84bCLN7xYLGHMSlaayJtp9C2RenCFfJBYRpJ4BWzX/9RXHdF7CS6Zx9qbJ/anknoGpQAAB0OSURBVP3gltKibXTnTmeP8tLLWqOPfwfsFMFwgM23rh9nMAZUb5jsK5iwvA0JlJrWNn8AnkDJuIF8qPUYL336d7MSztpf+jnJyCA3/vFXpnUsFyjDZMkdD7LkjokHKdV8p3NWOx29GHwNL6x8YNr/zq4Wgy1HeOmzD2U6Zyk8oTDb3vdZqldfW+yhzQvyEUbMfoYvT0KQ4exXj2WncK00pS33kpBW0umYk/f5vRfH4Qujlr9mIqO+Is23vwHDm92BSClF7eKFGMaVtS+8Uice/VesMVWs7HSS3iM7Gek8W9CxjEf5SlHXfRAW3QHhRVCzCbX5dzAarr/8ncdhJeMMthyZ0FGm+SSdiPHsx95CtOscViKGlYg6x7o++Q4SQ+McexMTJh8HxeyXmdFqrbHSFoZpYBgGGCbK7c21aq3TVWgsw4eqdimEYXgyx1BcApu/HJpuh5EOKG1G1W9DefK35puqVa9/D/0Hn6L/TCaZSkGwJMDmW1agj/wHasPbZ+y5xxppP+P6d2J4vMR628etSFVoyhdGLbsPlt03LY934tF/4+h3/wFlGNjpFLUbb2bre/92xpbYZ5OOnY+5Zpdr2+L8s/8tSWHTQAJvkelYD8R6nAzjQHGTQAqhY9cTHHvkC8T7OqhadS2r3/gQpQvHz4ZVpp9ONrP/W58iHoljmAbN65pZ++YP4nFJEFPBanTzXdD6+MXZr+GD2mugfGnu7Q0T3XA9dLyQvY9s+GDRHRhN4yT2TDPT5+eG+69jsLWCwZ4hQmUhqhsrnWzf3kPodHzSlaHGk4wM0H3gOQyPj7pNN2Neku1ctfpaBs78//buOz6u6krg+O/MjGZGxWpWcZOrbBn3bmzjQpywgUDWpm9YAoRkFwJkswkQyuJAgGUXAmEDCSYEEpYk1GBCWaqDDcbgjnvFxkVusi3JKh5pZt7dP94gq4xslWmSzvfz4QN6M+/NkZF13r3v3nM2YQINn5Vb/lq69R4UsRgSzYGVC9n6ymMnq3cBJes/Yc3825n4779u17XLd29h84u/ouyL9Xiz8ym68If0nPiN9oYcUTXlR7ACTQuhWP4afKXN9PtWraKJN05MsAaz4Q9Q/oU92rICmLyxSNHliMN5+gt0QLvef55Nf36w7pnh/uXvcXjtx0y/96VTJt+jW1ez8umH6rr6BANB9mw5QPDdhYz5Qfik6Oj/TUz20Lq+vJI3FrKGNLvPVArnYvzVcHS9XbTCBKDXFKT39HZ+120QqCYjJ52MnEaFM0TsfaoRSrxf/v1lNjx7P+J02X8uxjDxp4/XdSEadN7V7Fn0V/zBYN3I1+n2UjDropi0KIyXHa8/1SDpgn2zcWjNYmory3Cnte0GuXzPVpbc/R2CNT7AXim++je3MuyKWxnwjX+KQOSRkV00HofTRbBR8nV6U+h+Rvum75VNn/HGidn+KpTtOLnp3wSg5HPM3oXxDi0qrICfzS880qhUoUWg5gRb//rYKc/d9toTdUn3K8FaH/uWvI6/uqLZ8yS9P44hl+AYejmSXXTK4g7icOEYfhUyeR4y+jpkyi9wFM5tXQ/gSMkqIuziMFeq3UQ+AiqKv2DD/96P5a8h6KsicKKSgK+K5Q/fQMBn73n2ZuUx475X6DX5HJLSMknJ78uwK25l5HfviEgMicpXFr7kpDhd1Fa0/RnnlhcfrUu6XwnW2qU6w40w4yVr0EhyR06t23cM9g1XRr8zyBt1Vhwj6zx0xBsHxgraTdcbb0ux/FC8BPqdE5/AoujE0QP2992YsTi27fNTnlu1/8uwx4UA1R/cQbcxc5GCsyNSylE86eCJXInGNsUw4FuYo5vsRV8mAIjdurDosgbfY3VJMVteeYySDZ/i6ZZF4fnX0nva+S36c9j70d8wgXDbooRDqxfRe6r9rDQ1v4AJP/pVhL6zjiFn+GT2fvy63cu6HnE6Scnt0+brlu3cQLhFfybgx1dWQkpOrzZfO9Im/Nuj7Fn0Kns+fBnLClIwfQ79v365bimKEE288WCCYfYchgR84Y93cO5u2eETL5Dcvccpz80cOILqI/ubLvQxhuRkA1++gwnWIgO+Galw40q8WTDxNsy+xfajiORc+8Yi7eQv5hNHD7L4jgvxn6gEy6Km9DBrn/45lQd2MfSSH2GM4eim5ZTv3kxKXgH5Y2Y02KoUqKlq9kYo0GiataspuvAGDq5cSMBXXben2unxMuLK25rf7tUCyd17UhNmhbQxBne3rDZfNxocThf9Z19K/9mXxjuUTkkTbxyI041J7QFVBxq/ApmFcYkp2pJS0uh15rnsX/YOVm1N3XGny0nhqD6Y2ooGnYLqG3Lh9Rz6fHGD525Ol5OBo/rhSnLZW4T2/R3T7+udZt+meNKRQRc0+/qON58h4KsG6+TNSLDmBDvefIZ+X7+cFY/cSEXxF1gBP06Xm6TUdM66+y91Nzk9x89m7+IFTZ5lGitI3qhp0fmmOoiU3N7MfGAB2//2O45sWkZKTi8Kv/2DumffbTXkwutZ9eufNHjc4nB76Ttzbl1FMNU16LxBnMiQS0NF8UP/C8QJTg9S2HkLp4++9h56jZ+Fw+nA6XLicrsYNqWI/O5BzNr5diELfxXm+J4GtZXTC4Ywbd5z5AybjDPJSXK3ZIZNKWLI+Ho3KcaAv5nSgZ3Q0S0rwla4criS2PTnhzi+ZytBXzUm4Cfgq8JXepg182+ve1/OiCnkjZmB05NiHwj15B0y57qGLQC7qJScXoy+9m5mP/w2U25/ut1JF6DHuLMZefVdJKVl4kjy4HB76DvzQkZcefvpT1adihgTptBAO02YMMGsXLky4tftbEx1CWbfInvkm94f6TMDCVNX1hgD5Tsxx7aAKxnJHxf2fR2BtfUlAruXUOvz4U3z2vtxwb4JyR4KxzadXFWcPxEZfHGDVd7Wmsfs6dfGnB67CXsnGfGezopf3cSBFQtp/MzQkeTB5U0JuwhInC7OfWoZLq+dbI1lcXjtRxR/+ra9WnnmXLIHj4lF+F2asYLUlB8lKTW9wfYt1fGJyCpjzITTva9r/JZKUJKSiww5dWk8YyzMxmfh2GZ7SlVcdnecYVchOdErXRg1vqO43A5c7pSGx00QjmzA7vEaGskdWolxpzco8SgDzsOsm9+wDrPDDX1nd5mkC1B4wfc5vHZJg2lLcbrofsZEyneF6ev7lXo32uJwkD92FvljZ0UxUtWYOJxhWwWqrkOnmhNdybqTSRfskaDlx2x+Lip9YaMuc/DJEoz1mSBNGqtbfij+qMEhyRyEjPg+pPYEHHaT+IEXIH0TqwhBtGUVjmbkNXc1mA0wxqKm/Aj5476GNF4EJELGgOFdovKSUomu6wwROihzaGX4+sIIlO+0p2c7EOk1FVP8sf08trmV3fWFWeUt2UVI9s+iEF3Hcnjtxw0nmi2LyuIvSO9bREr3XvjKSgjWVOP0JONIcjPuugfiFapSqh5NvInuVAUc4lHcoZ0kKQUm3IzZ/T7sX3r6Fnvd2r5vsjMzxnBgxQdN9ppaAT/7lrzOuBseQkQo27WR1Px+9Jn6LR3tKpUgOt5v7i5GekwOrX5u8gpknLrGcaISdzek11TCdhCqz+FGCi9s9fVrK48TqO2c+6HrGIMJ19Qh9Nrqx29h4/MPkz1kHP1nX6pJV6kEoiPeRNd9GOSPh0Mr7YUxoVGujPhex15MVLkPHE4INjPdnNobOeOfkTBNEJqzd8kbrP39vLryksm5vZk270+knKZAR0ckDgc5wyZzZOOy8F2VMPiO7GfFoz/G5fFiBfxkDhjO8CtvI2tQmA5NSqmY0e1EHYSpPGA3hHd5IXc04urYG+5N+U7MuichWNP0RVcKcua8VnXhKd2xlo/nXd70UslpnPf0ivaEekomWIPZ86F9YyQCPSYjBbNiclNUdWgvH8+7rFX1g52eZKbf8wLpfYdEMTLVEQR81VQd3os3Mw9PemJVzuqoWrqdSKeaOwhJ62n/Qu95ZodPugCkDwBPFk1+BMUJY3/c6tZ36//3P8MeD5yopHjZu20M8tSMsTBrHoM9H4DvCJwogd3vYtY9STRuaBtLzS9g9q/eIzmnd4vPCdbWsG3BE1GMSiU6YwxbX/0t7143jU/uuYL3b5rFqsdvJlgb5iZYRYUmXhUXIoKMuQGyhtjJVpyQko+MvQlHauv3OFYf3tfsa2VfrGtPqM07uslOtvUXiFl+OL4byndF5zMbSUpJY9Q1d7W8EIOxKDvVPl/V6e396DV2vPF7grU+AieqsPy1HFjxAeufvS/eoXUZmnhV3Ii7G47R19kVp6bcg2PS7Uh6/zZdK72g+anT3BFT2xjhqZnyXeGnyk0QKnZH5TPDyR87k1Hf+zmulPC1rhsS0jpxE3t1ejve+H2YfsM17Fvyho56Y0QTr4o7cXkRd1q7rjHy6v8gXA9bT2ZO1Ir+izcrfDEQhws8kemb21IFM+Zw7u8+Y/iVt+FMTrN7qYqjyZYzp9tD0dzrYhqbSiw1x4+Gf8EYAie6Tr3zeNLEqzqFbr0HMfXOP+LJzLUPiJBdNJ7Zj7wTvQ/NG2dPkTcgdjLuHvuVw+JwMOjcqzj3yaXMfGAB5zzxEYXnf89uhCBCan5fJv77Y2QVjo55bOrU/NUVHFqzmKNbVmKspqvUAzUn2P3hK3z+1F3seOsPrVpQ11j24LGEu0lNSsvAnZ7d5uuqltNVzSpmTG2FXbWqfBek5CF9ZiEpufEOq11MxT7MpmehpgwwkJyHDL8KScmP+GcFTlSxf8X71FaUknPGJDIHDm9ZjJaFFQzgTAq3H1zF2673/sLGPz9o9/o1BldyKmfe9lTd4xNf+RE+uvMS/FXlBGtO4HB7cbiSOOvnfzrlI5bmHN+3nY/nXW7X+Q4leafby9gfPkivSV2r9GqktXRVsybedgjW1rB/2Tsc27qa1PwCCmbMxZPRPd5hJSRz4ihm1cMQrA0tRnKAw4WM+lcks2M/czTG2IlXJGpdo0p3rOXTB67FWAYr4MfhdJI/7mzG3/hLxHFy4soEfFB9ENwZ9lS4SmilO9ax9L6rGjS7APBk5nLO4x8iDidr5t/Bvk/eaNIGMnPgSGbc91KbPrfywJdse20+pdvXkppfwOB//Fe6Dx3f1m9DhWh3oiirrSzn43mX4Su16+E6kjxsWzCfqf/xRzIHdsCuQVFmdr4JgROcrFZlgVWL2foiMvmOeIbWbiICUUxyxrJY/vCNBE6c7FEcDPo5tGYRxUvfos9ZFwBg7X4fdr9nT3+bACZ9ADL8GrtMp0pIuxe+SNDftBZ70FfN0S2ryBk2iYOrFobtvVy+exMBXxUub+urkqX17M+46/+rTTGr9tNnvG20bcETVB/ZT7CmGrBXBQZ8Vaz+7a1xjixBlW4hbIlI39EGTe9VU+VfbiIQ+jmrLxh67gdgStbC7vft7UxBH1gBKN+F2fxcrMNVrVBbWRa+8pgI/uoK+z+dYRbw2a907Op1XZgm3jbav+wdTMDf5Hh1STG+0sNxiCjBOU+xzzTcymBVx1hBJMximK9eAzB7/t60i5UJwLEtWLvextTqatVE1GPiN+wV6I1YAX/d1G/fmXNxJHkavC5OF3mjpuF0e5qcqxKfJt42criaWahijL1IQjXUe3rTBCtOyBmFOE/+WVYUf8H6P97P8kdu5MuFLxJotN+wK8oYMDzsz5TTk0zfmXPtL/wVzZxtYM9CzLJ7MRXNFxlR8dFn6nl06zO4XvIVnG4vQy/9N9xp9nqBootuIKtwFE5PMk6PF5c3lZS8Poz5l/vjF7hqF11c1Ubb//Y7ti54oq4gP9jbOTILRzP97r/EMbLEZIyF2fIClKwGcdlFJrr1RUb+oK485IGVC1n9+M1YAT/GCuL0JJOc3YPp975EUkr79vnGkzEGjm3GHPgMrACSPwHyxiCtaOt4ZOMylv3yenuFsr8GpyeZ7KLxTL7lCRxOF9bWF+HAMqCZjkUAKT1wTLqt/d+Qiqigv5biT95k/7J3SErLoP/sy5ssdDLGULZzA8d3byYlr4CcYZMbLKpTiUFXNUeZFahl+SM3cXTTcgzgcDhJSstg2rznSMnpFe/wEpbxlULVAfBmI6knuwZZAT/vXn8W/qrjDd7vSHIzZM51DJl7faxDjRhr21/h4LKTU8EON2QORkZ+316Y1UI15UcpXvoWNRWl5AyfbP/yDZ1vfGWYlQ/Zz3dNMx2fxIlMuafdxUqUUuHpquYoc7jcnHnrk5Tt2kjZzg0kd+9J3qhpiKNxQQVVn3izwq4Arti3HStMi0DLX8v+Ze902MRrqg/Bwc/sRU9fsWqhbDuUboPsohZfy5PRnYHnfjfsa+LNhIm3YvZ+CMUfnyL56ihJqXjTxNtOmQOGkzmgZYUMVPOc3tS6hUKNuZJbUoM4QZVuD7uYG6sWc2wz0orEezriyUAK52C5ku2OSfWTPQ5I769bi5RKAHr7qxJCWo9+pPXo17S2sCeZAf9wRZyiigCXN/woU5zgik4SlL6zIWOgPaXtSAKnB7yZyBlXRuXzlFKtoyNelTAm/fQ3LL3vamoqjiEiWAE//c6+hF6Tvxnv0Nqu+0iQl5seFwfS47SPgtpEHC5k9PWY43ugci94siG7qFWLuZRS0aOLq1RCMZbFsW2rqSk7QtbgMSR373H6kxKcKd+JWf/70HNXAQwM/Q6OXG1WoFRnoourVIckDgfdh0ZnJBgvkjEQpt4L5Tvt5JsxsMHeZaUSWcBXxZ7FCzi8dgkpOT0ZcM4VdOtTGO+wOjRNvErFgDickDW4Re815Tsx21+FymJwJUOfmUi/b+hUsYo5f9VxFt95MTVlJXYjB4eTvR+9xvibHqbH+K/FO7wOS/8mK5VATGUxZu0TULkPMBCohj0f2IlYqRjb8eYz+EoPneyeZAUJ1vpY8+QdWGEaN6iW0cSboEywFlOyDnP4c4y/aYF81TmZ3e/ZDQ7qs/xw8DP9OVAxd2DlB1hhuidZAT+VxTvjEFHnoFPNCcgc24zZ8Af4qqqRsTBDLsHRY1J8A1MRZSyLoL8Gp9t7soJV5X7CbvwVF/iOge7DVTGUlBy+ypkJBnElt74dobLpiDfBGH81ZsMzdnWjYI39j+WHbS9jThyJd3gqAoxlsfXV3/D2Dybxf9dO4IMfzWb/8vfsF9N6QbhORCYA3uyYxqnUgG9e2aR7kjicdOszmJTc3nGKquPTxJtojqwn/C9eC3NoVczDUZG3+aVH2fHG03Zje8vixNEDrPntzzi8/hOk3zlNuzg5kqDHmVp1SsVc7ynn0e9rl+JIcuNKTsPpTSElr4BJP3ks3qF1aDrVnGisWgi3t9oE7dGv6tCC/lp2vfsngo3aHQZrfWx95XHy7nkeRl8XdlWzUrEmIoy48jYKz/8epTvW4snMJatwdKuae6imNPEmmqyhIH9r+pjP4Ua6j4hLSCpyaitKw99YAVUH9wD2vl+ZcHMsw4oqYwxHNi2jYu920nr2J3fkVG0m0sF4s/LoOVFv/iJFE2+CkZRcTJ9ZsG/xySL3DjfkjoKMAXGNTbWfJz0bcYb/a5de0LJ9vh2Jv7qST+77LlUHd2OCAcSZhDczh7Pu/guedH1mrbomfcabgBwDz0dGXQ89z4T8iciIa5ChV+j0TifgcCUx5MIfNlmw4nR7GXrZj+MUVfRsev6XVOzbQdBXjeWvJeirorqkmHVP3x3v0JSKGx3xJijJHIhkDox3GCoKBp13Ne7UdLa9Nh9faQnp/YoY/p1byB48Jt6hRVzx0rcwAX+DYyYY4ODqDzFWUKecVZekiVepGBMR+s66iL6zLop3KFHXXI9lY1kYY8Kt31eq09OpZqVU1PQY/7Wmo1pxkDNsMo5mnnUr1dlp4lVKRc3wf/4ZnsxcnB57D7LTk4w7LYPR378nzpEpFT96y6mUihpvZi6zH3mb4s/e4fiXm+nWZxC9p34Ll1fLDaquSxOvUiqqnG4vfWfMgRlz4h2KUglBp5qVagNjWfhKD59sl6aUUi2kI16lWmnfJ2+y4bkH7FrLQJ+zLmDk1XfhTHLHOTKlWs9XepjD65fidHvIHzNDHwPEgCZepVqhZMOnrH3qrgYj3X2fvIkJBBh7/QNxjEyp1tvx1h/Y8tKjiMOFiGAwTPrJ4+SOmBLv0Do1nWpWqhW2LZjfZHrZqvVR/Nn/4a86HqeolGq98i83sfXlX9sVxWqqCfiqCPqqWf7IjQR81fEOr1PTxKtUK1SX7At7XJwufGXaL1l1HHsWLyDor21yXBAOr1sSh4i6Dk28SrVCVuFokDB/bQzaGFx1KMEaHxiryXGD0UWDUaaJV6lWKLroRpweL9RrWOH0JFN08Y043Z44RqZU6/Sa/A91hU3qM8EgeSOnxSGirkMTr1Kt0K33QKb/4gXyx87C3S2b9IIhjPmX+yj81jXxDk2pVskdNY38sTNPdspyOHC4vQz7p5/iyege3+A6OTHNNOVujwkTJpiVK1dG/LpKKaUixxhDyfqlHFjxPk5PMgUz5pDRtyjeYXVYIrLKGDPhdO/T7URKKdVFiQh5o6aRN0qnlmNJp5qVUkqpGNLEq5RSSsWQJl6llFIqhjTxKqWUUjGkiVcppZSKIU28SimlVAxp4lVKKaViSBOvUkopFUOaeJVSSqkY0sSrlFJKxZAmXqWUUiqGNPEqpZRSMaSJVymllIohTbxKKaVUDGniVUoppWJIE69SSikVQ5p4lVJKqRjSxKuUUkrFkCZepZRSKoY08SqllFIxpIlXKaWUiiFNvEoppVQMaeJVSimlYkgTr1JKKRVDmniVUkqpGNLEq5RSSsWQJl6llFIqhjTxKqWUUjEkxpjIX1SkBNgd8QsrpZRSiaufMSb3dG+KSuJVSimlVHg61ayUUkrFkCZepZRSKoY08SoVBSJyp4hsFJF1IvK5iEyO8PVnicibLT0egc+bIyLD6n29SEQmRPpzlOoKXPEOQKnORkSmAOcD44wxNSKSA7jjHFZ7zQHeBDbFOxClOjod8SoVeT2BI8aYGgBjzBFjzH4AERkvIotFZJWIvCsiPUPHF4nI/4RGxxtEZFLo+CQR+VRE1ojIUhEpamkQIpIqIs+IyPLQ+f8YOn61iLwqIu+IyHYRebDeOdeKyLbQOU+JyOMiMhX4NvBQKL5BobdfEnrfNhGZHok/OKW6Ak28SkXee0BBKCH9VkRmAohIEvAYcLExZjzwDHB/vfNSjDFjgB+GXgPYAkw3xowF5gH/2Yo47gT+boyZBJyNnThTQ6+NAS4DRgKXiUiBiPQC7gLOBKYBQwGMMUuB14FbjDFjjDFfhK7hCl37x8DPWxGXUl2aTjUrFWHGmEoRGQ9Mx054L4rIbcBKYATwvogAOIED9U59PnT+RyKSLiKZQDfgWREZDBggqRWhnAN8W0RuDn3tBfqG/nuhMaYcQEQ2Af2AHGCxMeZY6PjLwJBTXP/V0L9XAf1bEZdSXZomXqWiwBgTBBYBi0RkPXAVdoLaaIyZ0txpYb6+F/jQGDNXRPqHrtlSAlxkjNna4KC90Kum3qEgbftd8NU12nq+Ul2STjUrFWEiUhQaoX5lDHYlt61AbmjxFSKSJCLD673vstDxs4Dy0Ig0AygOvX51K0N5F7hJQsNrERl7mvevAGaKSJaIuICL6r1WgT36Vkq1kyZepSIvDXt6eJOIrAOGAXcbY2qBi4H/FpG1wOfA1Hrn+URkDTAfuDZ07EHggdDx1o4q78Weml4nIhtDXzfLGFOM/Qx5OfAJ8CVQHnr5BeCW0CKtQeGvoJRqCS0ZqVQCEJFFwM3GmJVxjiMt9IzaBSwAnjHGLIhnTEp1NjriVUrVd7eIfA5sAHYBr8U5HqU6HR3xKqWUUjGkI16llFIqhjTxKqWUUjGkiVcppZSKIU28SimlVAxp4lVKKaViSBOvUkopFUP/DwCixnXP4oWvAAAAAElFTkSuQmCC\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdsAAAFsCAYAAACEtRP5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAAAElFTkSuQmCC\n",
       "text/plain": [
-       "<Figure size 576x432 with 1 Axes>"
+       "<matplotlib.figure.Figure at 0x10abf1250>"
       ]
      },
      "metadata": {},
@@ -246,18 +251,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/will/anaconda3/envs/metric_bis/lib/python3.7/site-packages/sklearn/utils/validation.py:761: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
-      "  y = column_or_1d(y, warn=True)\n"
-     ]
-    }
-   ],
+   "execution_count": 7,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
    "source": [
     "itml = metric_learn.ITML_Supervised(num_constraints=200)\n",
     "X_itml = itml.fit_transform(X, Y)"
@@ -265,14 +263,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
+   "execution_count": 8,
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdsAAAFsCAYAAACEtRP5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRNxMxVZERMTNVGxFRETc7P8AXsVpWPQcdcQAAAAASUVORK5CYII=\n",
       "text/plain": [
-       "<Figure size 576x432 with 1 Axes>"
+       "<matplotlib.figure.Figure at 0x10ac1e410>"
       ]
      },
      "metadata": {},
@@ -299,40 +299,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
+   "execution_count": 9,
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/will/anaconda3/envs/metric_bis/lib/python3.7/site-packages/sklearn/utils/validation.py:761: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
-      "  y = column_or_1d(y, warn=True)\n",
-      "/home/will/anaconda3/envs/metric_bis/lib/python3.7/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function pinvh is deprecated; sklearn.utils.extmath.pinvh was deprecated in version 0.19 and will be removed in 0.21. Use scipy.linalg.pinvh instead.\n",
-      "  warnings.warn(msg, category=DeprecationWarning)\n",
-      "/home/will/anaconda3/envs/metric_bis/lib/python3.7/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function pinvh is deprecated; sklearn.utils.extmath.pinvh was deprecated in version 0.19 and will be removed in 0.21. Use scipy.linalg.pinvh instead.\n",
-      "  warnings.warn(msg, category=DeprecationWarning)\n",
-      "/home/will/anaconda3/envs/metric_bis/lib/python3.7/site-packages/sklearn/utils/deprecation.py:77: DeprecationWarning: Function graph_lasso is deprecated; The 'graph_lasso' was renamed to 'graphical_lasso' in version 0.20 and will be removed in 0.22.\n",
-      "  warnings.warn(msg, category=DeprecationWarning)\n"
+      "/Users/bhargavvader/Open_Source/metric-learn/venv/lib/python2.7/site-packages/sklearn/covariance/graph_lasso_.py:252: ConvergenceWarning: graph_lasso: did not converge after 100 iteration: dual gap: 2.377e-04\n",
+      "  ConvergenceWarning)\n"
      ]
-    },
-    {
-     "ename": "FloatingPointError",
-     "evalue": "Non SPD result: the system is too ill-conditioned for this solver. The system is too ill-conditioned for this solver",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mFloatingPointError\u001b[0m                        Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-10-756c8e726699>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0msdml\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmetric_learn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mSDML_Supervised\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnum_constraints\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m200\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mX_sdml\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msdml\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrandom_state\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRandomState\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1234\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-      "\u001b[0;32m~/anaconda3/envs/metric_bis/lib/python3.7/site-packages/sklearn/base.py\u001b[0m in \u001b[0;36mfit_transform\u001b[0;34m(self, X, y, **fit_params)\u001b[0m\n\u001b[1;32m    463\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    464\u001b[0m             \u001b[0;31m# fit method of arity 2 (supervised transformation)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 465\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mfit_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    466\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    467\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/Code/metric-learn/metric_learn/sdml.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, random_state)\u001b[0m\n\u001b[1;32m    181\u001b[0m                                         random_state=random_state)\n\u001b[1;32m    182\u001b[0m     \u001b[0mpairs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mwrap_pairs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpos_neg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 183\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0m_BaseSDML\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_fit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpairs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-      "\u001b[0;32m~/Code/metric-learn/metric_learn/sdml.py\u001b[0m in \u001b[0;36m_fit\u001b[0;34m(self, pairs, y)\u001b[0m\n\u001b[1;32m     68\u001b[0m     \u001b[0;31m# hack: ensure positive semidefinite\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m     \u001b[0memp_cov\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0memp_cov\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0memp_cov\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m     \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mM_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgraph_lasso\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0memp_cov\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msparsity_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mverbose\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransformer_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtransformer_from_metric\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mM_\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/anaconda3/envs/metric_bis/lib/python3.7/site-packages/sklearn/utils/deprecation.py\u001b[0m in \u001b[0;36mwrapped\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     76\u001b[0m         \u001b[0;32mdef\u001b[0m \u001b[0mwrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     77\u001b[0m             \u001b[0mwarnings\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwarn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmsg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcategory\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mDeprecationWarning\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 78\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mfun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     79\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     80\u001b[0m         \u001b[0mwrapped\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__doc__\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_update_doc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrapped\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__doc__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/anaconda3/envs/metric_bis/lib/python3.7/site-packages/sklearn/covariance/graph_lasso_.py\u001b[0m in \u001b[0;36mgraph_lasso\u001b[0;34m(emp_cov, alpha, cov_init, mode, tol, enet_tol, max_iter, verbose, return_costs, eps, return_n_iter)\u001b[0m\n\u001b[1;32m    815\u001b[0m     return graphical_lasso(emp_cov, alpha, cov_init, mode, tol,\n\u001b[1;32m    816\u001b[0m                            \u001b[0menet_tol\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmax_iter\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreturn_costs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 817\u001b[0;31m                            eps, return_n_iter)\n\u001b[0m\u001b[1;32m    818\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    819\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/anaconda3/envs/metric_bis/lib/python3.7/site-packages/sklearn/covariance/graph_lasso_.py\u001b[0m in \u001b[0;36mgraphical_lasso\u001b[0;34m(emp_cov, alpha, cov_init, mode, tol, enet_tol, max_iter, verbose, return_costs, eps, return_n_iter)\u001b[0m\n\u001b[1;32m    267\u001b[0m         e.args = (e.args[0]\n\u001b[1;32m    268\u001b[0m                   + '. The system is too ill-conditioned for this solver',)\n\u001b[0;32m--> 269\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    270\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    271\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mreturn_costs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/anaconda3/envs/metric_bis/lib/python3.7/site-packages/sklearn/covariance/graph_lasso_.py\u001b[0m in \u001b[0;36mgraphical_lasso\u001b[0;34m(emp_cov, alpha, cov_init, mode, tol, enet_tol, max_iter, verbose, return_costs, eps, return_n_iter)\u001b[0m\n\u001b[1;32m    258\u001b[0m                 \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    259\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0misfinite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcost\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mi\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 260\u001b[0;31m                 raise FloatingPointError('Non SPD result: the system is '\n\u001b[0m\u001b[1;32m    261\u001b[0m                                          'too ill-conditioned for this solver')\n\u001b[1;32m    262\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mFloatingPointError\u001b[0m: Non SPD result: the system is too ill-conditioned for this solver. The system is too ill-conditioned for this solver"
-     ],
-     "output_type": "error"
     }
    ],
    "source": [
@@ -343,7 +321,9 @@
   {
    "cell_type": "code",
    "execution_count": 10,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [
     {
      "data": {
@@ -374,7 +354,9 @@
   {
    "cell_type": "code",
    "execution_count": 11,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "lsml = metric_learn.LSML_Supervised(num_constraints=200)\n",
@@ -384,7 +366,9 @@
   {
    "cell_type": "code",
    "execution_count": 12,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [
     {
      "data": {
@@ -417,7 +401,9 @@
   {
    "cell_type": "code",
    "execution_count": 13,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "nca = metric_learn.NCA(max_iter=1000, learning_rate=0.01)\n",
@@ -427,7 +413,9 @@
   {
    "cell_type": "code",
    "execution_count": 14,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [
     {
      "data": {
@@ -458,7 +446,9 @@
   {
    "cell_type": "code",
    "execution_count": 15,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "lfda = metric_learn.LFDA(k=2, dim=2)\n",
@@ -468,7 +458,9 @@
   {
    "cell_type": "code",
    "execution_count": 16,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [
     {
      "data": {
@@ -500,7 +492,9 @@
   {
    "cell_type": "code",
    "execution_count": 17,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "rca = metric_learn.RCA_Supervised(num_chunks=30, chunk_size=2)\n",
@@ -510,7 +504,9 @@
   {
    "cell_type": "code",
    "execution_count": 18,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [
     {
      "data": {
@@ -550,7 +546,9 @@
   {
    "cell_type": "code",
    "execution_count": 19,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "def create_constraints(labels):\n",
@@ -589,7 +587,9 @@
   {
    "cell_type": "code",
    "execution_count": 20,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "constraint = create_constraints(Y)"
@@ -605,7 +605,9 @@
   {
    "cell_type": "code",
    "execution_count": 21,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [
     {
      "data": {
@@ -627,7 +629,9 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "source": [
     "Using our constraints, let's now train ITML again.\n",
     "We should keep in mind that internally, ITML_Supervised does pretty much the same thing we are doing; I was just giving an example to better explain how the constraints are structured. "
@@ -636,7 +640,9 @@
   {
    "cell_type": "code",
    "execution_count": 22,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "itml = metric_learn.ITML()\n",
@@ -646,7 +652,9 @@
   {
    "cell_type": "code",
    "execution_count": 23,
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [
     {
      "data": {
@@ -678,21 +686,21 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 2",
    "language": "python",
-   "name": "python3"
+   "name": "python2"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
-    "version": 3
+    "version": 2
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.0"
+   "pygments_lexer": "ipython2",
+   "version": "2.7.12"
   }
  },
  "nbformat": 4,

From 61a33ccb0f16a3b2080593254a6c63d8b04a890d Mon Sep 17 00:00:00 2001
From: William de Vazelhes <william.de-vazelhes@inria.fr>
Date: Tue, 15 Jan 2019 11:49:02 +0100
Subject: [PATCH 14/25] FIX: use custom validate_vector

---
 metric_learn/base_metric.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/metric_learn/base_metric.py b/metric_learn/base_metric.py
index fd5f9c79..d970fbc2 100644
--- a/metric_learn/base_metric.py
+++ b/metric_learn/base_metric.py
@@ -1,12 +1,12 @@
 from numpy.linalg import cholesky
-from scipy.spatial.distance import euclidean, _validate_vector
+from scipy.spatial.distance import euclidean
 from sklearn.base import BaseEstimator
 from sklearn.utils.validation import _is_arraylike
 from sklearn.metrics import roc_auc_score
 import numpy as np
 from abc import ABCMeta, abstractmethod
 import six
-from ._util import ArrayIndexer, check_input
+from ._util import ArrayIndexer, check_input, validate_vector
 import warnings
 
 
@@ -299,8 +299,8 @@ def metric_fun(u, v):
       distance: float
         The distance between u and v according to the new metric.
       """
-      u = _validate_vector(u)
-      v = _validate_vector(v)
+      u = validate_vector(u)
+      v = validate_vector(v)
       return euclidean(u.dot(transformer_T), v.dot(transformer_T))
     return metric_fun
 

From 72153ed83492a614e407b788438b5a29b4f1a3e8 Mon Sep 17 00:00:00 2001
From: William de Vazelhes <william.de-vazelhes@inria.fr>
Date: Tue, 15 Jan 2019 13:23:25 +0100
Subject: [PATCH 15/25] TST: fix syntax error for assert in test

---
 test/test_mahalanobis_mixin.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/test_mahalanobis_mixin.py b/test/test_mahalanobis_mixin.py
index 235e796b..ea04402e 100644
--- a/test/test_mahalanobis_mixin.py
+++ b/test/test_mahalanobis_mixin.py
@@ -186,7 +186,7 @@ def test_get_metric_equivalent_to_transform_and_euclidean(estimator,
   n_features = X.shape[1]
   a, b = (rng.randn(n_features), rng.randn(n_features))
   euc_dist = euclidean(model.transform(a[None]), model.transform(b[None]))
-  assert assert_allclose(euc_dist, metric(a, b), rtol=1e-15)
+  assert_allclose(metric(a, b), euc_dist, rtol=1e-15)
 
 
 @pytest.mark.parametrize('estimator, build_dataset', metric_learners,

From d943406b23a43794e7add233a2798691548e9934 Mon Sep 17 00:00:00 2001
From: William de Vazelhes <william.de-vazelhes@inria.fr>
Date: Wed, 16 Jan 2019 09:57:02 +0100
Subject: [PATCH 16/25] Add tolerance for triangular inequality because MMC
 probably projected onto a line

---
 test/test_mahalanobis_mixin.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/test_mahalanobis_mixin.py b/test/test_mahalanobis_mixin.py
index ea04402e..4dbf5272 100644
--- a/test/test_mahalanobis_mixin.py
+++ b/test/test_mahalanobis_mixin.py
@@ -212,7 +212,8 @@ def test_get_metric_is_pseudo_metric(estimator, build_dataset):
     # side of the equivalence is not always true for Mahalanobis distances.
     assert metric(a, a) == 0
     # triangular inequality
-    assert metric(a, c) <= metric(a, b) + metric(b, c)
+    assert (metric(a, c) < metric(a, b) + metric(b, c) or
+            np.isclose(metric(a, c), metric(a, b) + metric(b, c), rtol=1e-20))
 
 
 @pytest.mark.parametrize('estimator, build_dataset', metric_learners,

From d2c0614e12ac8987179f15f00a2587e48563a46b Mon Sep 17 00:00:00 2001
From: William de Vazelhes <william.de-vazelhes@inria.fr>
Date: Tue, 22 Jan 2019 15:55:56 +0100
Subject: [PATCH 17/25] MAINT: address comments from review
 https://github.com/metric-learn/metric-learn/pull/152#pullrequestreview-194754318

---
 metric_learn/base_metric.py    | 47 +++-------------------------------
 test/test_mahalanobis_mixin.py | 15 ++++++-----
 2 files changed, 12 insertions(+), 50 deletions(-)

diff --git a/metric_learn/base_metric.py b/metric_learn/base_metric.py
index d970fbc2..e68b3aa6 100644
--- a/metric_learn/base_metric.py
+++ b/metric_learn/base_metric.py
@@ -241,47 +241,6 @@ def transform(self, X):
     return X_checked.dot(self.transformer_.T)
 
   def get_metric(self):
-    """Returns a function that takes as input two 1D arrays and outputs the
-    learned metric score on these two points.
-
-    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_fun : function
-      The function described above.
-
-    Examples
-    --------
-    .. doctest::
-
-      >>> 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) # doctest: +NORMALIZE_WHITESPACE
-      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')
-
-    See Also
-    --------
-    score_pairs : a method that returns the metric 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.
-
-    :ref:`mahalanobis_distances` : The section of the project documentation
-      that describes Mahalanobis Distances.
-    """
     transformer_T = self.transformer_.T.copy()
 
     def metric_fun(u, v):
@@ -304,12 +263,14 @@ def metric_fun(u, v):
       return euclidean(u.dot(transformer_T), v.dot(transformer_T))
     return metric_fun
 
+  get_metric.__doc__ = BaseMetricLearner.get_metric.__doc__
+
   def metric(self):
     # TODO: remove this method in version 0.6.0
     warnings.warn(("`metric` is deprecated since version 0.5.0 and will be "
                    "removed in 0.6.0. Use `get_mahalanobis_matrix` instead."),
                   DeprecationWarning)
-    return self.transformer_.T.dot(self.transformer_)
+    return self.get_mahalanobis_matrix()
 
   def get_mahalanobis_matrix(self):
     """Returns a copy of the Mahalanobis matrix learned by the metric learner.
@@ -319,7 +280,7 @@ def get_mahalanobis_matrix(self):
     M : `numpy.ndarray`, shape=(n_components, n_features)
       The copy of the learned Mahalanobis matrix.
     """
-    return self.transformer_.T.dot(self.transformer_).copy()
+    return self.transformer_.T.dot(self.transformer_)
 
 
 class _PairsClassifierMixin(BaseMetricLearner):
diff --git a/test/test_mahalanobis_mixin.py b/test/test_mahalanobis_mixin.py
index 4dbf5272..6702429e 100644
--- a/test/test_mahalanobis_mixin.py
+++ b/test/test_mahalanobis_mixin.py
@@ -3,7 +3,7 @@
 import pytest
 import numpy as np
 from numpy.testing import assert_array_almost_equal, assert_allclose
-from scipy.spatial.distance import pdist, squareform, euclidean
+from scipy.spatial.distance import pdist, squareform, mahalanobis
 from sklearn import clone
 from sklearn.cluster import DBSCAN
 from sklearn.utils import check_random_state
@@ -172,10 +172,10 @@ def test_embed_is_linear(estimator, build_dataset):
 
 @pytest.mark.parametrize('estimator, build_dataset', metric_learners,
                          ids=ids_metric_learners)
-def test_get_metric_equivalent_to_transform_and_euclidean(estimator,
-                                                          build_dataset):
-  """Tests that the get_metric method of mahalanobis metric learners is the
-  euclidean distance in the transformed space
+def test_get_metric_equivalent_to_explicit_mahalanobis(estimator,
+                                                       build_dataset):
+  """Tests that using the get_metric method of mahalanobis metric learners is
+  equivalent to explicitely calling scipy's mahalanobis metric
   """
   rng = np.random.RandomState(42)
   input_data, labels, _, X = build_dataset()
@@ -185,8 +185,9 @@ def test_get_metric_equivalent_to_transform_and_euclidean(estimator,
   metric = model.get_metric()
   n_features = X.shape[1]
   a, b = (rng.randn(n_features), rng.randn(n_features))
-  euc_dist = euclidean(model.transform(a[None]), model.transform(b[None]))
-  assert_allclose(metric(a, b), euc_dist, rtol=1e-15)
+  expected_dist = mahalanobis(a[None], b[None],
+                              VI=model.get_mahalanobis_matrix())
+  assert_allclose(metric(a, b), expected_dist, rtol=1e-15)
 
 
 @pytest.mark.parametrize('estimator, build_dataset', metric_learners,

From 5e29295efab1a524497c61c57e58519bc9e3feff Mon Sep 17 00:00:00 2001
From: William de Vazelhes <william.de-vazelhes@inria.fr>
Date: Tue, 22 Jan 2019 16:39:11 +0100
Subject: [PATCH 18/25] ENH: add squared option

---
 metric_learn/base_metric.py    | 15 +++++++++++++--
 test/test_mahalanobis_mixin.py | 22 +++++++++++++++++++++-
 2 files changed, 34 insertions(+), 3 deletions(-)

diff --git a/metric_learn/base_metric.py b/metric_learn/base_metric.py
index e68b3aa6..e11f80b9 100644
--- a/metric_learn/base_metric.py
+++ b/metric_learn/base_metric.py
@@ -243,7 +243,7 @@ def transform(self, X):
   def get_metric(self):
     transformer_T = self.transformer_.T.copy()
 
-    def metric_fun(u, v):
+    def metric_fun(u, v, squared=False):
       """This function computes the metric between u and v, according to the
       previously learned metric.
 
@@ -251,8 +251,14 @@ def metric_fun(u, v):
       ----------
       u : array-like, shape=(n_features,)
         The first point involved in the distance computation.
+
       v : array-like, shape=(n_features,)
         The second point involved in the distance computation.
+
+      squared : `bool`
+        If True, the function will return the squared metric between u and
+        v, which is faster to compute.
+
       Returns
       -------
       distance: float
@@ -260,7 +266,12 @@ def metric_fun(u, v):
       """
       u = validate_vector(u)
       v = validate_vector(v)
-      return euclidean(u.dot(transformer_T), v.dot(transformer_T))
+      transformed_diff = (u - v).dot(transformer_T)
+      dist = transformed_diff.dot(transformed_diff.T)
+      if not squared:
+        dist = np.sqrt(dist)
+      return dist
+
     return metric_fun
 
   get_metric.__doc__ = BaseMetricLearner.get_metric.__doc__
diff --git a/test/test_mahalanobis_mixin.py b/test/test_mahalanobis_mixin.py
index 6702429e..62e1b941 100644
--- a/test/test_mahalanobis_mixin.py
+++ b/test/test_mahalanobis_mixin.py
@@ -245,4 +245,24 @@ def test_get_metric_compatible_with_scikit_learn(estimator, build_dataset):
   set_random_state(model)
   model.fit(input_data, labels)
   clustering = DBSCAN(metric=model.get_metric())
-  clustering.fit(X)
\ No newline at end of file
+  clustering.fit(X)
+
+
+@pytest.mark.parametrize('estimator, build_dataset', metric_learners,
+                         ids=ids_metric_learners)
+def test_get_squared_metric(estimator, build_dataset):
+  """Test that the squared metric returned is indeed the square of the
+  metric"""
+  input_data, labels, _, X = build_dataset()
+  model = clone(estimator)
+  set_random_state(model)
+  model.fit(input_data, labels)
+  metric = model.get_metric()
+
+  n_features = X.shape[1]
+  for seed in range(10):
+    rng = np.random.RandomState(seed)
+    a, b = (rng.randn(n_features) for _ in range(2))
+    assert_allclose(metric(a, b, squared=True),
+                    metric(a, b, squared=False)**2,
+                    rtol=1e-15)

From 92669ae9f4abd931213329ffbd816ad0cfc6d13c Mon Sep 17 00:00:00 2001
From: William de Vazelhes <william.de-vazelhes@inria.fr>
Date: Wed, 23 Jan 2019 17:31:18 +0100
Subject: [PATCH 19/25] FIX fix test that was failing du to a non 2D
 transformer: - ensure that the transformer_ fitted is always 2D:   - in the
 result returned from transformer_from_metric   - in the code of metric
 learners, for metric learners that don't call transformer_from_metric - for
 metric learners that cannot work on 1 feature, ensure it when checking the
 input - add a test to check this behaviour

---
 metric_learn/_util.py          |  7 ++++---
 metric_learn/base_metric.py    |  2 +-
 metric_learn/lfda.py           |  2 +-
 metric_learn/lmnn.py           |  2 +-
 metric_learn/mlkr.py           |  2 +-
 metric_learn/nca.py            |  2 +-
 metric_learn/rca.py            |  4 ++--
 metric_learn/sdml.py           |  3 ++-
 test/test_mahalanobis_mixin.py | 22 ++++++++++++++++++++++
 9 files changed, 35 insertions(+), 11 deletions(-)

diff --git a/metric_learn/_util.py b/metric_learn/_util.py
index bd57fd5f..37c71337 100644
--- a/metric_learn/_util.py
+++ b/metric_learn/_util.py
@@ -343,12 +343,13 @@ def transformer_from_metric(metric):
   """
 
   if np.allclose(metric, np.diag(np.diag(metric))):
-    return np.sqrt(metric)
+    transformer = np.sqrt(metric)
   elif not np.isclose(np.linalg.det(metric), 0):
-    return np.linalg.cholesky(metric).T
+    transformer = np.linalg.cholesky(metric).T
   else:
     w, V = np.linalg.eigh(metric)
-    return V.T * np.sqrt(np.maximum(0, w[:, None]))
+    transformer = V.T * np.sqrt(np.maximum(0, w[:, None]))
+  return np.atleast_2d(transformer)
 
 
 def validate_vector(u, dtype=None):
diff --git a/metric_learn/base_metric.py b/metric_learn/base_metric.py
index e11f80b9..58b8cc5d 100644
--- a/metric_learn/base_metric.py
+++ b/metric_learn/base_metric.py
@@ -267,7 +267,7 @@ def metric_fun(u, v, squared=False):
       u = validate_vector(u)
       v = validate_vector(v)
       transformed_diff = (u - v).dot(transformer_T)
-      dist = transformed_diff.dot(transformed_diff.T)
+      dist = np.dot(transformed_diff, transformed_diff.T)
       if not squared:
         dist = np.sqrt(dist)
       return dist
diff --git a/metric_learn/lfda.py b/metric_learn/lfda.py
index 2feff211..1ae3b529 100644
--- a/metric_learn/lfda.py
+++ b/metric_learn/lfda.py
@@ -130,7 +130,7 @@ def fit(self, X, y):
     elif self.embedding_type == 'orthonormalized':
        vecs, _ = np.linalg.qr(vecs)
 
-    self.transformer_ = vecs.T
+    self.transformer_ = np.atleast_2d(vecs.T)
     return self
 
 
diff --git a/metric_learn/lmnn.py b/metric_learn/lmnn.py
index 1d7ddf2a..02156395 100644
--- a/metric_learn/lmnn.py
+++ b/metric_learn/lmnn.py
@@ -144,7 +144,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.transformer_ = np.atleast_2d(L)
     self.n_iter_ = it
     return self
 
diff --git a/metric_learn/mlkr.py b/metric_learn/mlkr.py
index 6b79638e..3f6620e2 100644
--- a/metric_learn/mlkr.py
+++ b/metric_learn/mlkr.py
@@ -102,7 +102,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.transformer_ = np.atleast_2d(res.x.reshape(A.shape))
 
       # Stop timer
       train_time = time.time() - train_time
diff --git a/metric_learn/nca.py b/metric_learn/nca.py
index 81045287..04fb5b0a 100644
--- a/metric_learn/nca.py
+++ b/metric_learn/nca.py
@@ -86,7 +86,7 @@ def fit(self, X, y):
     self.n_iter_ = 0
     opt_result = minimize(**optimizer_params)
 
-    self.transformer_ = opt_result.x.reshape(-1, X.shape[1])
+    self.transformer_ = np.atleast_2d(opt_result.x.reshape(-1, X.shape[1]))
     self.n_iter_ = opt_result.nit
 
     # Stop timer
diff --git a/metric_learn/rca.py b/metric_learn/rca.py
index 3380f4c9..da471c56 100644
--- a/metric_learn/rca.py
+++ b/metric_learn/rca.py
@@ -98,7 +98,7 @@ def fit(self, X, chunks):
         When ``chunks[i] == -1``, point i doesn't belong to any chunklet.
         When ``chunks[i] == j``, point i belongs to chunklet j.
     """
-    X = self._prepare_inputs(X, ensure_min_samples=2)
+    X = self._prepare_inputs(X, ensure_min_samples=2, ensure_min_features=2)
 
     # PCA projection to remove noise and redundant information.
     if self.pca_comps is not None:
@@ -128,7 +128,7 @@ def fit(self, X, chunks):
       self.transformer_ = _inv_sqrtm(inner_cov).T
 
     if M_pca is not None:
-        self.transformer_ = self.transformer_.dot(M_pca)
+        self.transformer_ = np.atleast_2d(self.transformer_.dot(M_pca))
 
     return self
 
diff --git a/metric_learn/sdml.py b/metric_learn/sdml.py
index 40fd5727..800af56e 100644
--- a/metric_learn/sdml.py
+++ b/metric_learn/sdml.py
@@ -53,7 +53,8 @@ def __init__(self, balance_param=0.5, sparsity_param=0.01, use_cov=True,
 
   def _fit(self, pairs, y):
     pairs, y = self._prepare_inputs(pairs, y,
-                                    type_of_inputs='tuples')
+                                    type_of_inputs='tuples',
+                                    ensure_min_features=2)
 
     # set up prior M
     if self.use_cov:
diff --git a/test/test_mahalanobis_mixin.py b/test/test_mahalanobis_mixin.py
index 62e1b941..072a1983 100644
--- a/test/test_mahalanobis_mixin.py
+++ b/test/test_mahalanobis_mixin.py
@@ -266,3 +266,25 @@ def test_get_squared_metric(estimator, build_dataset):
     assert_allclose(metric(a, b, squared=True),
                     metric(a, b, squared=False)**2,
                     rtol=1e-15)
+
+
+@pytest.mark.parametrize('estimator, build_dataset', metric_learners,
+                         ids=ids_metric_learners)
+def test_transformer_is_2D(estimator, build_dataset):
+  """Tests that the transformer of metric learners is 2D"""
+  input_data, labels, _, X = build_dataset()
+  model = clone(estimator)
+  set_random_state(model)
+  # test that it works for X.shape[1] features
+  model.fit(input_data, labels)
+  assert model.transformer_.ndim == 2
+
+  # test that it works for 1 feature, or it returns an error
+  trunc_data = input_data[..., :1]
+  try:
+    model.fit(trunc_data, labels)
+    assert model.transformer_.ndim == 2  # the transformer must be 2D
+  except Exception as e:
+    # we allow it not to work as long as the error message is clear
+    assert isinstance(e, ValueError)
+    assert "Found array with 1 feature" in e.message

From a2955e01adcb0099a3a39d1e3a2e9a175c90a34c Mon Sep 17 00:00:00 2001
From: William de Vazelhes <william.de-vazelhes@inria.fr>
Date: Thu, 24 Jan 2019 10:29:12 +0100
Subject: [PATCH 20/25] FIX: remove message that is not supported anymore by
 python newer versions and replace it by str

---
 test/test_mahalanobis_mixin.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/test_mahalanobis_mixin.py b/test/test_mahalanobis_mixin.py
index 072a1983..35fe6dfa 100644
--- a/test/test_mahalanobis_mixin.py
+++ b/test/test_mahalanobis_mixin.py
@@ -287,4 +287,4 @@ def test_transformer_is_2D(estimator, build_dataset):
   except Exception as e:
     # we allow it not to work as long as the error message is clear
     assert isinstance(e, ValueError)
-    assert "Found array with 1 feature" in e.message
+    assert "Found array with 1 feature" in str(e)

From c8708b25e717bef371a5011022da97f164a65908 Mon Sep 17 00:00:00 2001
From: William de Vazelhes <william.de-vazelhes@inria.fr>
Date: Mon, 28 Jan 2019 16:36:26 +0100
Subject: [PATCH 21/25] TST: make shape testing more precise

---
 test/test_mahalanobis_mixin.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/test/test_mahalanobis_mixin.py b/test/test_mahalanobis_mixin.py
index 35fe6dfa..32310c82 100644
--- a/test/test_mahalanobis_mixin.py
+++ b/test/test_mahalanobis_mixin.py
@@ -277,13 +277,14 @@ def test_transformer_is_2D(estimator, build_dataset):
   set_random_state(model)
   # test that it works for X.shape[1] features
   model.fit(input_data, labels)
-  assert model.transformer_.ndim == 2
+  assert model.transformer_.shape == (X.shape[1], X.shape[1])
 
   # test that it works for 1 feature, or it returns an error
   trunc_data = input_data[..., :1]
   try:
     model.fit(trunc_data, labels)
-    assert model.transformer_.ndim == 2  # the transformer must be 2D
+    assert model.transformer_.shape == (1, 1)
+    # the transformer must be 2D
   except Exception as e:
     # we allow it not to work as long as the error message is clear
     assert isinstance(e, ValueError)

From 7d4efd92dba0c18a0cd945478750598ad0662eac Mon Sep 17 00:00:00 2001
From: William de Vazelhes <william.de-vazelhes@inria.fr>
Date: Mon, 28 Jan 2019 17:26:27 +0100
Subject: [PATCH 22/25] TST: enforce the 2d transformer test for everyone, and
 make it pass for RCA and SDML

---
 metric_learn/rca.py            |  6 +++---
 metric_learn/sdml.py           |  5 ++---
 test/test_mahalanobis_mixin.py | 10 ++--------
 3 files changed, 7 insertions(+), 14 deletions(-)

diff --git a/metric_learn/rca.py b/metric_learn/rca.py
index da471c56..c9fedd59 100644
--- a/metric_learn/rca.py
+++ b/metric_learn/rca.py
@@ -98,7 +98,7 @@ def fit(self, X, chunks):
         When ``chunks[i] == -1``, point i doesn't belong to any chunklet.
         When ``chunks[i] == j``, point i belongs to chunklet j.
     """
-    X = self._prepare_inputs(X, ensure_min_samples=2, ensure_min_features=2)
+    X = self._prepare_inputs(X, ensure_min_samples=2)
 
     # PCA projection to remove noise and redundant information.
     if self.pca_comps is not None:
@@ -112,7 +112,7 @@ def fit(self, X, chunks):
     chunks = np.asanyarray(chunks, dtype=int)
     chunk_mask, chunked_data = _chunk_mean_centering(X_t, chunks)
 
-    inner_cov = np.cov(chunked_data, rowvar=0, bias=1)
+    inner_cov = np.atleast_2d(np.cov(chunked_data, rowvar=0, bias=1))
     dim = self._check_dimension(np.linalg.matrix_rank(inner_cov), X_t)
 
     # Fisher Linear Discriminant projection
@@ -122,7 +122,7 @@ def fit(self, X, chunks):
       vals, vecs = np.linalg.eig(tmp)
       inds = np.argsort(vals)[:dim]
       A = vecs[:, inds]
-      inner_cov = A.T.dot(inner_cov).dot(A)
+      inner_cov = np.atleast_2d(A.T.dot(inner_cov).dot(A))
       self.transformer_ = _inv_sqrtm(inner_cov).dot(A.T)
     else:
       self.transformer_ = _inv_sqrtm(inner_cov).T
diff --git a/metric_learn/sdml.py b/metric_learn/sdml.py
index 800af56e..be45d3a3 100644
--- a/metric_learn/sdml.py
+++ b/metric_learn/sdml.py
@@ -53,13 +53,12 @@ def __init__(self, balance_param=0.5, sparsity_param=0.01, use_cov=True,
 
   def _fit(self, pairs, y):
     pairs, y = self._prepare_inputs(pairs, y,
-                                    type_of_inputs='tuples',
-                                    ensure_min_features=2)
+                                    type_of_inputs='tuples')
 
     # set up prior M
     if self.use_cov:
       X = np.vstack({tuple(row) for row in pairs.reshape(-1, pairs.shape[2])})
-      self.M_ = pinvh(np.cov(X, rowvar = False))
+      self.M_ = pinvh(np.atleast_2d(np.cov(X, rowvar = False)))
     else:
       self.M_ = np.identity(pairs.shape[2])
     diff = pairs[:, 0] - pairs[:, 1]
diff --git a/test/test_mahalanobis_mixin.py b/test/test_mahalanobis_mixin.py
index 32310c82..46a5536d 100644
--- a/test/test_mahalanobis_mixin.py
+++ b/test/test_mahalanobis_mixin.py
@@ -281,11 +281,5 @@ def test_transformer_is_2D(estimator, build_dataset):
 
   # test that it works for 1 feature, or it returns an error
   trunc_data = input_data[..., :1]
-  try:
-    model.fit(trunc_data, labels)
-    assert model.transformer_.shape == (1, 1)
-    # the transformer must be 2D
-  except Exception as e:
-    # we allow it not to work as long as the error message is clear
-    assert isinstance(e, ValueError)
-    assert "Found array with 1 feature" in str(e)
+  model.fit(trunc_data, labels)
+  assert model.transformer_.shape == (1, 1)  # the transformer must be 2D

From 0c7c5dc84574aef4d56362bc4287bca86cc55d0e Mon Sep 17 00:00:00 2001
From: William de Vazelhes <william.de-vazelhes@inria.fr>
Date: Mon, 28 Jan 2019 17:27:33 +0100
Subject: [PATCH 23/25] TST: fix typo in removing

---
 test/test_mahalanobis_mixin.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/test_mahalanobis_mixin.py b/test/test_mahalanobis_mixin.py
index 46a5536d..1e555e73 100644
--- a/test/test_mahalanobis_mixin.py
+++ b/test/test_mahalanobis_mixin.py
@@ -279,7 +279,7 @@ def test_transformer_is_2D(estimator, build_dataset):
   model.fit(input_data, labels)
   assert model.transformer_.shape == (X.shape[1], X.shape[1])
 
-  # test that it works for 1 feature, or it returns an error
+  # test that it works for 1 feature
   trunc_data = input_data[..., :1]
   model.fit(trunc_data, labels)
   assert model.transformer_.shape == (1, 1)  # the transformer must be 2D

From 7dfd8740562befe973d054b4e15cca02a263908e Mon Sep 17 00:00:00 2001
From: William de Vazelhes <william.de-vazelhes@inria.fr>
Date: Tue, 29 Jan 2019 11:07:31 +0100
Subject: [PATCH 24/25] Remove unnecessary calls of np.atleast2d

---
 metric_learn/_util.py | 7 +++----
 metric_learn/lfda.py  | 2 +-
 metric_learn/lmnn.py  | 2 +-
 metric_learn/mlkr.py  | 2 +-
 metric_learn/nca.py   | 2 +-
 5 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/metric_learn/_util.py b/metric_learn/_util.py
index 37c71337..bd57fd5f 100644
--- a/metric_learn/_util.py
+++ b/metric_learn/_util.py
@@ -343,13 +343,12 @@ def transformer_from_metric(metric):
   """
 
   if np.allclose(metric, np.diag(np.diag(metric))):
-    transformer = np.sqrt(metric)
+    return np.sqrt(metric)
   elif not np.isclose(np.linalg.det(metric), 0):
-    transformer = np.linalg.cholesky(metric).T
+    return np.linalg.cholesky(metric).T
   else:
     w, V = np.linalg.eigh(metric)
-    transformer = V.T * np.sqrt(np.maximum(0, w[:, None]))
-  return np.atleast_2d(transformer)
+    return V.T * np.sqrt(np.maximum(0, w[:, None]))
 
 
 def validate_vector(u, dtype=None):
diff --git a/metric_learn/lfda.py b/metric_learn/lfda.py
index 1ae3b529..2feff211 100644
--- a/metric_learn/lfda.py
+++ b/metric_learn/lfda.py
@@ -130,7 +130,7 @@ def fit(self, X, y):
     elif self.embedding_type == 'orthonormalized':
        vecs, _ = np.linalg.qr(vecs)
 
-    self.transformer_ = np.atleast_2d(vecs.T)
+    self.transformer_ = vecs.T
     return self
 
 
diff --git a/metric_learn/lmnn.py b/metric_learn/lmnn.py
index 02156395..1d7ddf2a 100644
--- a/metric_learn/lmnn.py
+++ b/metric_learn/lmnn.py
@@ -144,7 +144,7 @@ def fit(self, X, y):
         print("LMNN didn't converge in %d steps." % self.max_iter)
 
     # store the last L
-    self.transformer_ = np.atleast_2d(L)
+    self.transformer_ = L
     self.n_iter_ = it
     return self
 
diff --git a/metric_learn/mlkr.py b/metric_learn/mlkr.py
index 3f6620e2..6b79638e 100644
--- a/metric_learn/mlkr.py
+++ b/metric_learn/mlkr.py
@@ -102,7 +102,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_ = np.atleast_2d(res.x.reshape(A.shape))
+      self.transformer_ = res.x.reshape(A.shape)
 
       # Stop timer
       train_time = time.time() - train_time
diff --git a/metric_learn/nca.py b/metric_learn/nca.py
index 04fb5b0a..81045287 100644
--- a/metric_learn/nca.py
+++ b/metric_learn/nca.py
@@ -86,7 +86,7 @@ def fit(self, X, y):
     self.n_iter_ = 0
     opt_result = minimize(**optimizer_params)
 
-    self.transformer_ = np.atleast_2d(opt_result.x.reshape(-1, X.shape[1]))
+    self.transformer_ = opt_result.x.reshape(-1, X.shape[1])
     self.n_iter_ = opt_result.nit
 
     # Stop timer

From 80c2943802835d693a4476d4f2f00216af36b1bb Mon Sep 17 00:00:00 2001
From: William de Vazelhes <william.de-vazelhes@inria.fr>
Date: Tue, 29 Jan 2019 13:20:42 +0100
Subject: [PATCH 25/25] Add functions to commented doc

---
 doc/introduction.rst | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/doc/introduction.rst b/doc/introduction.rst
index f290f850..dad530b3 100644
--- a/doc/introduction.rst
+++ b/doc/introduction.rst
@@ -126,7 +126,9 @@ to the following resources:
 .. Currently, each metric learning algorithm supports the following methods:
 
 .. -  ``fit(...)``, which learns the model.
-.. -  ``metric()``, which returns a Mahalanobis matrix
+.. -  ``get_mahalanobis_matrix()``, which returns a Mahalanobis matrix
+.. -  ``get_metric()``, which returns a function that takes as input two 1D
+      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