code: def score_pairs(self, pairs):
      
      pairs = check_input(pairs, type_of_inputs='tuples',
                          preprocessor=self.preprocessor_,
                          estimator=self, tuple_size=2)
      pairwise_diffs = self.transform(pairs[:, 1, :] - pairs[:, 0, :])
      # (for MahalanobisMixin, the embedding is linear so we can just embed the
      # difference)
      return np.sqrt(np.sum(pairwise_diffs**2, axis=-1))
docs: Returns the learned Mahalanobis distance between pairs.
  
      This distance is defined as: :math:`d_M(x, x') = \sqrt{(x-x')^T M (x-x')}`
      where ``M`` is the learned Mahalanobis matrix, for every pair of points
      ``x`` and ``x'``. This corresponds to the euclidean distance between
      embeddings of the points in a new space, obtained through a linear
      transformation. Indeed, we have also: :math:`d_M(x, x') = \sqrt{(x_e -
      x_e')^T (x_e- x_e')}`, with :math:`x_e = L x` (See
      :class:`MahalanobisMixin`).
  
      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.
  
      See Also
      --------
      get_metric : a method that returns a function to compute the metric 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 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.