Add more tests. Fix 4 to 2 identation

Author: mvargas33

metric_learn/base_metric.py

@@ -178,82 +178,82 @@ class BilinearMixin(BaseMetricLearner, metaclass=ABCMeta):
   """
 
   def score_pairs(self, pairs):
-      r"""Returns the learned Bilinear similarity between pairs.
+    r"""Returns the learned Bilinear similarity between pairs.
 
-      This similarity is defined as: :math:`s_M(x, x') =  x M x'`
-      where ``M`` is the learned Bilinear matrix, for every pair of points
-      ``x`` and ``x'``.
+    This similarity is defined as: :math:`s_M(x, x') =  x M x'`
+    where ``M`` is the learned Bilinear matrix, for every pair of points
+    ``x`` and ``x'``.
 
-      Parameters
-      ----------
-      pairs : array-like, shape=(n_pairs, 2, n_features) or (n_pairs, 2)
-        3D Array of pairs to score, with each row corresponding to two points,
-        for 2D array of indices of pairs if the similarity learner uses a
-        preprocessor.
+    Parameters
+    ----------
+    pairs : array-like, shape=(n_pairs, 2, n_features) or (n_pairs, 2)
+      3D Array of pairs to score, with each row corresponding to two points,
+      for 2D array of indices of pairs if the similarity learner uses a
+      preprocessor.
 
-      Returns
-      -------
-      scores : `numpy.ndarray` of shape=(n_pairs,)
-        The learned Bilinear similarity for every pair.
-
-      See Also
-      --------
-      get_metric : a method that returns a function to compute the similarity
-        between two points. The difference with `score_pairs` is that it works
-        on two 1D arrays and cannot use a preprocessor. Besides, the returned
-        function is independent of the similarity learner and hence is not
-        modified if the similarity learner is.
-
-      :ref:`Bilinear_similarity` : The section of the project documentation
-        that describes Bilinear similarity.
-      """
-      check_is_fitted(self, ['preprocessor_', 'components_'])
-      pairs = check_input(pairs, type_of_inputs='tuples',
-                          preprocessor=self.preprocessor_,
-                          estimator=self, tuple_size=2)
-      # Note: For bilinear order matters, dist(a,b) != dist(b,a)
-      # We always choose first pair first, then second pair
-      # (In contrast with Mahalanobis implementation)
-      return np.sum(np.dot(pairs[:, 0, :], self.components_) * pairs[:, 1, :],
-                    axis=-1)
+    Returns
+    -------
+    scores : `numpy.ndarray` of shape=(n_pairs,)
+      The learned Bilinear similarity for every pair.
+
+    See Also
+    --------
+    get_metric : a method that returns a function to compute the similarity
+      between two points. The difference with `score_pairs` is that it works
+      on two 1D arrays and cannot use a preprocessor. Besides, the returned
+      function is independent of the similarity learner and hence is not
+      modified if the similarity learner is.
+
+    :ref:`Bilinear_similarity` : The section of the project documentation
+      that describes Bilinear similarity.
+    """
+    check_is_fitted(self, ['preprocessor_', 'components_'])
+    pairs = check_input(pairs, type_of_inputs='tuples',
+                        preprocessor=self.preprocessor_,
+                        estimator=self, tuple_size=2)
+    # Note: For bilinear order matters, dist(a,b) != dist(b,a)
+    # We always choose first pair first, then second pair
+    # (In contrast with Mahalanobis implementation)
+    return np.sum(np.dot(pairs[:, 0, :], self.components_) * pairs[:, 1, :],
+                  axis=-1)
 
   def get_metric(self):
-      check_is_fitted(self, 'components_')
-      components = self.components_.copy()
+    check_is_fitted(self, 'components_')
+    components = self.components_.copy()
 
-      def similarity_fun(u, v):
-          """This function computes the similarity between u and v, according to the
-          previously learned similarity.
+    def similarity_fun(u, v):
+      """This function computes the similarity between u and v, according to the
+      previously learned similarity.
 
-          Parameters
-          ----------
-          u : array-like, shape=(n_features,)
-            The first point involved in the similarity computation.
+      Parameters
+      ----------
+      u : array-like, shape=(n_features,)
+        The first point involved in the similarity computation.
 
-          v : array-like, shape=(n_features,)
-            The second point involved in the similarity computation.
+      v : array-like, shape=(n_features,)
+        The second point involved in the similarity computation.
 
-          Returns
-          -------
-          similarity : float
-            The similarity between u and v according to the new similarity.
-          """
-          u = validate_vector(u)
-          v = validate_vector(v)
-          return np.dot(np.dot(u.T, components), v)
+      Returns
+      -------
+      similarity : float
+        The similarity between u and v according to the new similarity.
+      """
+      u = validate_vector(u)
+      v = validate_vector(v)
+      return np.dot(np.dot(u.T, components), v)
 
-      return similarity_fun
+    return similarity_fun
 
   def get_bilinear_matrix(self):
-      """Returns a copy of the Bilinear matrix learned by the similarity learner.
+    """Returns a copy of the Bilinear matrix learned by the similarity learner.
 
-      Returns
-      -------
-      M : `numpy.ndarray`, shape=(n_features, n_features)
-        The copy of the learned Bilinear matrix.
-      """
-      check_is_fitted(self, 'components_')
-      return self.components_
+    Returns
+    -------
+    M : `numpy.ndarray`, shape=(n_features, n_features)
+      The copy of the learned Bilinear matrix.
+    """
+    check_is_fitted(self, 'components_')
+    return self.components_
 
 
 class MahalanobisMixin(BaseMetricLearner, MetricTransformer,

test/test_bilinear_mixin.py

@@ -1,69 +1,125 @@
+from itertools import product
 from metric_learn.base_metric import BilinearMixin
 import numpy as np
 from numpy.testing import assert_array_almost_equal
-
+import pytest
+from metric_learn._util import make_context
+from sklearn import clone
+from sklearn.cluster import DBSCAN
 
 class IdentityBilinearMixin(BilinearMixin):
-    """A simple Identity bilinear mixin that returns an identity matrix
-    M as learned. Can change M for a random matrix calling random_M.
-    Class for testing purposes.
-    """
-    def __init__(self, preprocessor=None):
-        super().__init__(preprocessor=preprocessor)
+  """A simple Identity bilinear mixin that returns an identity matrix
+  M as learned. Can change M for a random matrix calling random_M.
+  Class for testing purposes.
+  """
+  def __init__(self, preprocessor=None):
+    super().__init__(preprocessor=preprocessor)
 
-    def fit(self, X, y):
-        X, y = self._prepare_inputs(X, y, ensure_min_samples=2)
-        self.d = np.shape(X[0])[-1]
-        self.components_ = np.identity(self.d)
-        return self
+  def fit(self, X, y):
+    X, y = self._prepare_inputs(X, y, ensure_min_samples=2)
+    self.d = np.shape(X[0])[-1]
+    self.components_ = np.identity(self.d)
+    return self
 
-    def random_M(self):
-        self.components_ = np.random.rand(self.d, self.d)
+  def random_M(self):
+    self.components_ = np.random.rand(self.d, self.d)
 
 
 def test_same_similarity_with_two_methods():
-    d = 100
-    u = np.random.rand(d)
-    v = np.random.rand(d)
-    mixin = IdentityBilinearMixin()
-    mixin.fit([u, v], [0, 0])
-    mixin.random_M()  # Dummy fit
+  d = 100
+  u = np.random.rand(d)
+  v = np.random.rand(d)
+  mixin = IdentityBilinearMixin()
+  mixin.fit([u, v], [0, 0])
+  mixin.random_M()  # Dummy fit
 
-    # The distances must match, whether calc with get_metric() or score_pairs()
-    dist1 = mixin.score_pairs([[u, v], [v, u]])
-    dist2 = [mixin.get_metric()(u, v), mixin.get_metric()(v, u)]
+  # The distances must match, whether calc with get_metric() or score_pairs()
+  dist1 = mixin.score_pairs([[u, v], [v, u]])
+  dist2 = [mixin.get_metric()(u, v), mixin.get_metric()(v, u)]
 
-    assert_array_almost_equal(dist1, dist2)
+  assert_array_almost_equal(dist1, dist2)
 
 
 def test_check_correctness_similarity():
-    d = 100
-    u = np.random.rand(d)
-    v = np.random.rand(d)
-    mixin = IdentityBilinearMixin()
-    mixin.fit([u, v], [0, 0])  # Identity fit
-    dist1 = mixin.score_pairs([[u, v], [v, u]])
-    u_v = np.dot(np.dot(u.T, np.identity(d)), v)
-    v_u = np.dot(np.dot(v.T, np.identity(d)), u)
-    desired = [u_v, v_u]
-    assert_array_almost_equal(dist1, desired)
+  d = 100
+  u = np.random.rand(d)
+  v = np.random.rand(d)
+  mixin = IdentityBilinearMixin()
+  mixin.fit([u, v], [0, 0])  # Identity fit
+  dist1 = mixin.score_pairs([[u, v], [v, u]])
+  dist2 = [mixin.get_metric()(u, v), mixin.get_metric()(v, u)]
 
+  u_v = np.dot(np.dot(u.T, np.identity(d)), v)
+  v_u = np.dot(np.dot(v.T, np.identity(d)), u)
+  desired = [u_v, v_u]
+  assert_array_almost_equal(dist1, desired)  # score_pairs
+  assert_array_almost_equal(dist2, desired)  # get_metric
 
 def test_check_handmade_example():
-    u = np.array([0, 1, 2])
-    v = np.array([3, 4, 5])
-    mixin = IdentityBilinearMixin()
-    mixin.fit([u, v], [0, 0])  # Identity fit
-    c = np.array([[2, 4, 6], [6, 4, 2], [1, 2, 3]])
-    mixin.components_ = c  # Force components_
-    dists = mixin.score_pairs([[u, v], [v, u]])
-    assert_array_almost_equal(dists, [96, 120])
+  u = np.array([0, 1, 2])
+  v = np.array([3, 4, 5])
+  mixin = IdentityBilinearMixin()
+  mixin.fit([u, v], [0, 0])  # Identity fit
+  c = np.array([[2, 4, 6], [6, 4, 2], [1, 2, 3]])
+  mixin.components_ = c  # Force components_
+  dists = mixin.score_pairs([[u, v], [v, u]])
+  assert_array_almost_equal(dists, [96, 120])
 
 
 def test_check_handmade_symmetric_example():
-    u = np.array([0, 1, 2])
-    v = np.array([3, 4, 5])
-    mixin = IdentityBilinearMixin()
-    mixin.fit([u, v], [0, 0])   # Identity fit
-    dists = mixin.score_pairs([[u, v], [v, u]])
-    assert_array_almost_equal(dists, [14, 14])
+  u = np.array([0, 1, 2])
+  v = np.array([3, 4, 5])
+  mixin = IdentityBilinearMixin()
+  mixin.fit([u, v], [0, 0])   # Identity fit
+  dists = mixin.score_pairs([[u, v], [v, u]])
+  assert_array_almost_equal(dists, [14, 14])
+
+
+def test_score_pairs_finite():
+  d = 100
+  u = np.random.rand(d)
+  v = np.random.rand(d)
+  mixin = IdentityBilinearMixin()
+  mixin.fit([u, v], [0, 0])
+  mixin.random_M()  # Dummy fit
+  n = 100
+  X = np.array([np.random.rand(d) for i in range(n)])
+  pairs = np.array(list(product(X, X)))
+  assert np.isfinite(mixin.score_pairs(pairs)).all()
+
+
+def test_score_pairs_dim():
+  # scoring of 3D arrays should return 1D array (several tuples),
+  # and scoring of 2D arrays (one tuple) should return an error (like
+  # scikit-learn's error when scoring 1D arrays)
+  d = 100
+  u = np.random.rand(d)
+  v = np.random.rand(d)
+  mixin = IdentityBilinearMixin()
+  mixin.fit([u, v], [0, 0])
+  mixin.random_M()  # Dummy fit
+  n = 100
+  X = np.array([np.random.rand(d) for i in range(n)])
+  tuples = np.array(list(product(X, X)))
+  assert mixin.score_pairs(tuples).shape == (tuples.shape[0],)
+  context = make_context(mixin)
+  msg = ("3D array of formed tuples expected{}. Found 2D array "
+      "instead:\ninput={}. Reshape your data and/or use a preprocessor.\n"
+      .format(context, tuples[1]))
+  with pytest.raises(ValueError) as raised_error:
+    mixin.score_pairs(tuples[1])
+  assert str(raised_error.value) == msg
+
+
+def test_check_scikitlearn_compatibility():
+  d = 100
+  u = np.random.rand(d)
+  v = np.random.rand(d)
+  mixin = IdentityBilinearMixin()
+  mixin.fit([u, v], [0, 0])
+  mixin.random_M()  # Dummy fit
+
+  n = 100
+  X = np.array([np.random.rand(d) for i in range(n)])
+  clustering = DBSCAN(metric=mixin.get_metric())
+  clustering.fit(X)