FIrst draft of bilinear mixin

Author: mvargas33

metric_learn/base_metric.py

@@ -160,6 +160,58 @@ def transform(self, X):
       Input data transformed to the metric space by :math:`XL^{\\top}`
     """
 
+class BilinearMixin(BaseMetricLearner, metaclass=ABCMeta):
+
+  def score_pairs(self, pairs):
+      r"""
+      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 metric learner uses a
+        preprocessor.
+
+      Returns
+      -------
+      scores : `numpy.ndarray` of shape=(n_pairs,)
+        The learned Mahalanobis distance for every pair.
+      """
+      check_is_fitted(self, ['preprocessor_', 'components_'])
+      pairs = check_input(pairs, type_of_inputs='tuples',
+                          preprocessor=self.preprocessor_,
+                          estimator=self, tuple_size=2)
+      return np.dot(np.dot(pairs[:, 1, :], self.components_), pairs[:, 0, :].T)
+
+  def get_metric(self):
+      check_is_fitted(self, 'components_')
+      components = self.components_.copy()
+
+      def metric_fun(u, v):
+          """This function computes the metric between u and v, according to the
+          previously learned metric.
+
+          Parameters
+          ----------
+          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.
+
+          Returns
+          -------
+          distance : float
+            The distance between u and v according to the new metric.
+          """
+          u = validate_vector(u)
+          v = validate_vector(v)
+          return np.dot(np.dot(u, components), v.T)
+
+      return metric_fun
+
+  def get_bilinear_matrix(self):
+      check_is_fitted(self, 'components_')
+      return self.components_
 
 class MahalanobisMixin(BaseMetricLearner, MetricTransformer,
                        metaclass=ABCMeta):

metric_learn/oasis.py

@@ -0,0 +1,20 @@
+from .base_metric import BilinearMixin
+import numpy as np
+
+class OASIS(BilinearMixin):
+
+    def __init__(self, preprocessor=None):
+        super().__init__(preprocessor=preprocessor)
+
+    def fit(self, X, y):
+        """
+        Fit OASIS model
+
+        Parameters
+        ----------
+        X : (n x d) array of samples
+        y : (n) data labels
+        """
+        X = self._prepare_inputs(X, y, ensure_min_samples=2)
+        self.components_ = np.identity(np.shape(X[0])[-1]) # Identity matrix
+        return self

test_bilinear.py

@@ -0,0 +1,15 @@
+from metric_learn.oasis import OASIS
+import numpy as np
+
+def test_toy_distance():
+    u = np.array([0, 1, 2])
+    v = np.array([3, 4, 5])
+
+    mixin = OASIS()
+    mixin.fit([u, v], [0, 0])
+    #mixin.components_ = np.array([[1, 0, 0],[0, 1, 0],[0, 0, 1]])
+
+    dist = mixin.score_pairs([[u, v]])
+    print(dist)
+
+test_toy_distance()