ENH: Basic implementation of cross-validation rsm using learner and CV.

mvpa2/measures/rsa.py

@@ -10,19 +10,63 @@
 
 __docformat__ = 'restructuredtext'
 
-from itertools import combinations
+from itertools import combinations, product
 import numpy as np
 from mvpa2.measures.base import Measure
 from mvpa2.datasets.base import Dataset
 from mvpa2.base import externals
 from mvpa2.base.param import Parameter
 from mvpa2.base.constraints import EnsureChoice
+from mvpa2.mappers.fx import mean_group_sample
 
 if externals.exists('scipy', raise_=True):
-    from scipy.spatial.distance import pdist, squareform
+    from scipy.spatial.distance import pdist, squareform, cdist
     from scipy.stats import rankdata, pearsonr
 
 
+class CDist(Measure):
+    """Compute dissimiliarity matrix for samples in a dataset
+
+    This `Measure` can be trained on part of the dataset (for example,
+    a partition) and called on another partition. It can be used in
+    cross-validation to generate cross-validated RSA.
+    """
+    pairwise_metric = Parameter('correlation', constraints='str', doc="""
+          Distance metric to use for calculating pairwise vector distances for
+          dissimilarity matrix (DSM).  See scipy.spatial.distance.pdist for
+          all possible metrics.""")
+
+    sattr = Parameter(['targets'], doc="""
+        List of sample attributes whose unique values will be used to identify the
+        samples groups. Typically your category labels or targets.""")
+
+    def __init__(self, **kwargs):
+        Measure.__init__(self, **kwargs)
+        self._train_ds = None
+
+    def _prepare_ds(self, ds):
+        if self.params.sattr is not None:
+            mgs = mean_group_sample(attrs=self.params.sattr)
+            ds_ = mgs(ds)
+        else:
+            ds_ = ds.copy(deep=True)
+        return ds_
+
+    def _train(self, ds):
+        self._train_ds = self._prepare_ds(ds)
+        self.is_trained = True
+
+    def _call(self, ds):
+        test_ds = self._prepare_ds(ds)
+        # Call actual distance metric
+        distds = cdist(self._train_ds.samples, test_ds,
+                       metric=self.params.pairwise_metric)
+        # Make target pairs
+        distds = Dataset(samples=distds.ravel()[None, ],
+                         fa={'pairs': list(product(test_ds.UT, test_ds.UT))})
+        return distds
+
+
 class PDist(Measure):
     """Compute dissimiliarity matrix for samples in a dataset
 

mvpa2/tests/test_rsa.py

@@ -73,6 +73,24 @@ def test_PDistConsistency():
     assert_array_almost_equal(res4.samples,cres2)
 
 
+def test_CDist():
+    targets = np.tile(range(3), 2)
+    chunks = np.repeat(np.array((0,1)), 3)
+    ds = dataset_wizard(samples=data, targets=targets, chunks=chunks)
+    # Some distance metrics
+    metrics = ['euclidean', 'correlation', 'cityblock']
+    for metric in metrics:
+        pd_ = pdist(data, metric)
+        cd_ = CDist(pairwise_metric=metric)
+
+        assert_true(not cd_.is_trained)
+        cd_.train(ds[ds.sa.chunks == 0, ])
+        assert_true(cd_.is_trained)
+        res = cd_(ds[ds.sa.chunks == 1, ])
+        # Check to make sure the pdist results are close to CDist results
+        assert_array_almost_equal(res.samples.ravel(),
+                                  squareform(pd_)[:3, 3:].ravel())
+
 
 def test_PDist():
     targets = np.tile(xrange(3),2)