adding RCA method

Author: perimosocordiae

README.rst

@@ -13,6 +13,7 @@ Metric Learning algorithms in Python.
 -  Least Squares Metric Learning (LSML)
 -  Neighborhood Components Analysis (NCA)
 -  Local Fisher Discriminant Analysis (LFDA)
+-  Relative Components Analysis (RCA)
 
 **Dependencies**
 

metric_learn/__init__.py

@@ -4,3 +4,4 @@
 from sdml import SDML
 from nca import NCA
 from lfda import LFDA
+from rca import RCA

metric_learn/rca.py

@@ -0,0 +1,73 @@
+import numpy as np
+from base_metric import BaseMetricLearner
+
+
+class RCA(BaseMetricLearner):
+  '''Relevant Components Analysis (RCA)
+  'Learning distance functions using equivalence relations', ICML 2003
+  '''
+
+  def __init__(self, dim=None):
+    '''
+    dim : embedding dimension (default: original dimension of data)
+    '''
+    self.dim = dim
+
+  def transformer(self):
+    return self._transformer
+
+  def _process_inputs(self, X, Y):
+    X = np.asanyarray(X)
+    self.X = X
+    n, d = X.shape
+
+    if self.dim is None:
+      self.dim = d
+    elif not 0 < self.dim <= d:
+      raise ValueError('Invalid embedding dimension, must be in [1,%d]' % d)
+
+    Y = np.asanyarray(Y)
+    num_chunks = Y.max() + 1
+
+    return X, Y, num_chunks, d
+
+  def fit(self, data, chunks):
+    '''
+    data : (n,d) array-like, input data
+    chunks : (n,) array-like
+      chunks[i] == -1  -> point i doesn't belong to any chunklet
+      chunks[i] == j   -> point i belongs to chunklet j
+    '''
+    data, chunks, num_chunks, d = self._process_inputs(data, chunks)
+
+    # mean center
+    data -= data.mean(axis=0)
+
+    # mean center each chunklet separately
+    chunk_mask = chunks != -1
+    chunk_data = data[chunk_mask]
+    chunk_labels = chunks[chunk_mask]
+    for c in xrange(num_chunks):
+      mask = chunk_labels == c
+      chunk_data[mask] -= chunk_data[mask].mean(axis=0)
+
+    # "inner" covariance of chunk deviations
+    inner_cov = np.cov(chunk_data, rowvar=0, bias=1)
+
+    # Fisher Linear Discriminant projection
+    if self.dim < d:
+      total_cov = np.cov(data[chunk_mask], rowvar=0)
+      tmp = np.linalg.lstsq(total_cov, inner_cov)[0]
+      vals, vecs = np.linalg.eig(tmp)
+      inds = np.argsort(vals)[:self.dim]
+      A = vecs[:,inds]
+      inner_cov = A.T.dot(inner_cov).dot(A)
+      self._transformer = _inv_sqrtm(inner_cov).dot(A.T)
+    else:
+      self._transformer = _inv_sqrtm(inner_cov).T
+
+
+def _inv_sqrtm(x):
+  '''Computes x^(-1/2)'''
+  vals, vecs = np.linalg.eigh(x)
+  return (vecs / np.sqrt(vals)).dot(vecs.T)

test/metric_learn_test.py

@@ -5,7 +5,7 @@
 from sklearn.datasets import load_iris
 from numpy.testing import assert_array_almost_equal
 
-from metric_learn import LSML, ITML, LMNN, SDML, NCA, LFDA
+from metric_learn import LSML, ITML, LMNN, SDML, NCA, LFDA, RCA
 # Import this specially for testing.
 from metric_learn.lmnn import python_LMNN
 
@@ -103,5 +103,22 @@ def test_iris(self):
     csep = class_separation(lfda.transform(), self.iris_labels)
     self.assertLess(csep, 0.15)
 
+
+class TestRCA(MetricTestCase):
+  def test_iris(self):
+    rca = RCA(dim=2)
+    chunks = self.iris_labels.copy()
+    a, = np.where(chunks==0)
+    b, = np.where(chunks==1)
+    c, = np.where(chunks==2)
+    chunks[:] = -1
+    chunks[a[:20]] = np.repeat(np.arange(10), 2)
+    chunks[b[:20]] = np.repeat(np.arange(10, 20), 2)
+    chunks[c[:20]] = np.repeat(np.arange(20, 30), 2)
+    rca.fit(self.iris_points, chunks)
+    csep = class_separation(rca.transform(), self.iris_labels)
+    self.assertLess(csep, 0.25)
+
+
 if __name__ == '__main__':
   unittest.main()