brainscore-vision 2.1__py3-none-any.whl

brainscore_vision/metrics/rdm/metric.py

@@ -0,0 +1,101 @@
+import numpy as np
+from scipy.stats import spearmanr
+
+from brainio.assemblies import DataAssembly, walk_coords, NeuroidAssembly
+from brainscore_core.metrics import Metric, Score
+from brainscore_vision.metric_helpers import Defaults as XarrayDefaults
+from brainscore_vision.metric_helpers.transformations import TestOnlyCrossValidation
+
+
+class RDMCrossValidated(Metric):
+    """
+    Computes a coefficient for the similarity between two `RDM`s, using the upper triangular regions
+
+    Kriegeskorte et al., 2008 https://doi.org/10.3389/neuro.06.004.2008
+    """
+
+    def __init__(self, neuroid_dim=XarrayDefaults.neuroid_dim, comparison_coord=XarrayDefaults.stimulus_coord,
+                 crossvalidation_kwargs=None):
+        self._metric = RDMMetric(neuroid_dim=neuroid_dim, comparison_coord=comparison_coord)
+        crossvalidation_defaults = dict(test_size=.9)  # leave 10% out
+        crossvalidation_kwargs = {**crossvalidation_defaults, **(crossvalidation_kwargs or {})}
+        self._cross_validation = TestOnlyCrossValidation(**crossvalidation_kwargs)
+
+    def __call__(self, assembly1: NeuroidAssembly, assembly2: NeuroidAssembly) -> Score:
+        return self._cross_validation(assembly1, assembly2, apply=self._metric)
+
+
+class RDMMetric(Metric):
+    """
+    Computes a coefficient for the similarity between two `RDM`s, using the upper triangular regions
+
+    Kriegeskorte et al., 2008 https://doi.org/10.3389/neuro.06.004.2008
+    """
+
+    def __init__(self, neuroid_dim=XarrayDefaults.neuroid_dim, comparison_coord=XarrayDefaults.stimulus_coord):
+        self._neuroid_dim = neuroid_dim
+        self._rdm = RDM(neuroid_dim=neuroid_dim)
+        self._similarity = RDMSimilarity(comparison_coord=comparison_coord)
+
+    def __call__(self, assembly1: NeuroidAssembly, assembly2: NeuroidAssembly) -> Score:
+        rdm1 = self._rdm(assembly1)
+        rdm2 = self._rdm(assembly2)
+        similarity = self._similarity(rdm1, rdm2)
+        return Score(similarity)
+
+
+class RDM:
+    """
+    Representational Dissimilarity Matrix.
+    Converts an assembly of `presentation x neuroid` into a `neuroid x neuroid` RDM.
+
+    Kriegeskorte et al., 2008 https://doi.org/10.3389/neuro.06.004.2008
+    """
+
+    def __init__(self, neuroid_dim=XarrayDefaults.neuroid_dim):
+        self._neuroid_dim = neuroid_dim
+
+    def __call__(self, assembly):
+        assert len(assembly.dims) == 2
+        correlations = np.corrcoef(assembly) if assembly.dims[-1] == self._neuroid_dim else np.corrcoef(assembly.T).T
+        coords = {coord: coord_value for coord, coord_value in assembly.coords.items() if coord != self._neuroid_dim}
+        dims = [dim if dim != self._neuroid_dim else assembly.dims[(i - 1) % len(assembly.dims)]
+                for i, dim in enumerate(assembly.dims)]
+        similarities = DataAssembly(correlations, coords=coords, dims=dims)
+        return 1 - similarities
+
+
+class RDMSimilarity:
+    def __init__(self, comparison_coord=XarrayDefaults.stimulus_coord):
+        self._comparison_coord = comparison_coord
+
+    def __call__(self, rdm_assembly1, rdm_assembly2):
+        # align
+        rdm_assembly1 = self.multishape_preserved_sort(rdm_assembly1)
+        rdm_assembly2 = self.multishape_preserved_sort(rdm_assembly2)
+        assert (rdm_assembly1[self._comparison_coord].values == rdm_assembly2[self._comparison_coord].values).all()
+
+        triu1 = self._triangulars(rdm_assembly1.values)
+        triu2 = self._triangulars(rdm_assembly2.values)
+        corr, p = spearmanr(triu1, triu2)
+        return corr
+
+    def _triangulars(self, values):
+        assert len(values.shape) == 2 and values.shape[0] == values.shape[1]
+        # ensure diagonal is zero
+        diag = np.diag(values)
+        diag = np.nan_to_num(diag, nan=0, copy=True)  # we also accept nans in the diagonal from correlating zeros
+        np.testing.assert_almost_equal(diag, 0)
+        # index and retrieve upper triangular
+        triangular_indices = np.triu_indices(values.shape[0], k=1)
+        return values[triangular_indices]
+
+    def multishape_preserved_sort(self, assembly):
+        comparison_dims = assembly[self._comparison_coord].dims
+        assert set(assembly.dims) == set(comparison_dims), "multi-dimensional case not implemented"
+        indices = np.argsort(assembly[self._comparison_coord].values)
+        assembly = type(assembly)(assembly.values[np.ix_(indices, indices)],
+                                  coords={coord: (dims, values[indices] if dims == comparison_dims else values)
+                                          for coord, dims, values in walk_coords(assembly)},
+                                  dims=assembly.dims)
+        return assembly

brainscore_vision/metrics/rdm/requirements.txt

@@ -0,0 +1,2 @@
+numpy
+scipy

brainscore_vision/metrics/rdm/test.py

@@ -0,0 +1,63 @@
+import numpy as np
+from pytest import approx
+
+from brainio.assemblies import NeuroidAssembly, DataAssembly
+from brainscore_vision import load_metric
+from .metric import RDM
+
+
+class TestCharacterization:
+    def test_alignment(self):
+        assembly = NeuroidAssembly([[1, 2], [1, 2], [4, 3], [4, 3]],
+                                   coords={'stimulus_id': ('presentation', list(range(4))),
+                                           'image_meta': ('presentation', list(range(4))),
+                                           'neuroid_id': ('neuroid', list(range(2))),
+                                           'neuroid_meta': ('neuroid', list(range(2)))},
+                                   dims=['presentation', 'neuroid'])
+        matrix = RDM()(assembly)
+        assert np.all(np.diag(matrix) == approx(0, abs=.001))
+        assert all(matrix.values[np.triu_indices(matrix.shape[0], k=1)] ==
+                   matrix.values[np.tril_indices(matrix.shape[0], k=-1)]), "upper and lower triangular need to be equal"
+        expected = DataAssembly([[0, 0, 2, 2],
+                                 [0, 0, 2, 2],
+                                 [2, 2, 0, 0],
+                                 [2, 2, 0, 0]],
+                                coords={'stimulus_id': ('presentation', list(range(4))),
+                                        'image_meta': ('presentation', list(range(4)))},
+                                dims=['presentation', 'presentation'])
+        np.testing.assert_array_almost_equal(matrix.values, expected.values)  # does not take ordering into account
+
+
+class TestRDMCrossValidated:
+    def test_small(self):
+        assembly = NeuroidAssembly((np.arange(30 * 25) + np.random.standard_normal(30 * 25)).reshape((30, 25)),
+                                   coords={'stimulus_id': ('presentation', np.arange(30)),
+                                           'object_name': ('presentation', ['a', 'b', 'c'] * 10),
+                                           'neuroid_id': ('neuroid', np.arange(25)),
+                                           'region': ('neuroid', [None] * 25)},
+                                   dims=['presentation', 'neuroid'])
+        metric = load_metric('rdm_cv')
+        score = metric(assembly1=assembly, assembly2=assembly)
+        assert score == approx(1)
+
+
+class TestRDMSimilarity:
+    def test_2d_equal20(self):
+        rdm = np.random.rand(20, 20)  # not mirrored across diagonal, but fine for unit test
+        np.fill_diagonal(rdm, 0)
+        rdm = NeuroidAssembly(rdm, coords={'stimulus_id': ('presentation', list(range(20))),
+                                           'object_name': ('presentation', ['A', 'B'] * 10)},
+                              dims=['presentation', 'presentation'])
+        similarity = load_metric('rdm')
+        score = similarity(rdm, rdm)
+        assert score == approx(1.)
+
+    def test_2d_equal100(self):
+        rdm = np.random.rand(100, 100)  # not mirrored across diagonal, but fine for unit test
+        np.fill_diagonal(rdm, 0)
+        rdm = NeuroidAssembly(rdm, coords={'stimulus_id': ('presentation', list(range(100))),
+                                           'object_name': ('presentation', ['A', 'B'] * 50)},
+                              dims=['presentation', 'presentation'])
+        similarity = load_metric('rdm')
+        score = similarity(rdm, rdm)
+        assert score == approx(1.)

brainscore_vision/metrics/regression_correlation/__init__.py

@@ -0,0 +1,48 @@
+from brainscore_vision import metric_registry
+from .metric import CrossRegressedCorrelation, pls_regression, ridge_regression, single_regression, linear_regression,\
+    pearsonr_correlation
+
+metric_registry['pls'] = lambda *args, **kwargs: CrossRegressedCorrelation(
+    regression=pls_regression(), correlation=pearsonr_correlation(), *args, **kwargs)
+metric_registry['ridge'] = lambda *args, **kwargs: CrossRegressedCorrelation(
+    regression=ridge_regression(), correlation=pearsonr_correlation(), *args, **kwargs)
+metric_registry['neuron_to_neuron'] = lambda *args, **kwargs: CrossRegressedCorrelation(
+    regression=single_regression(), correlation=pearsonr_correlation(), *args, **kwargs)
+metric_registry['linear_predictivity'] = lambda *args, **kwargs: CrossRegressedCorrelation(
+    regression=linear_regression(), correlation=pearsonr_correlation(), *args, **kwargs)
+
+# temporal metrics
+from .metric import SpanTimeCrossRegressedCorrelation
+
+metric_registry['spantime_pls'] = lambda *args, **kwargs: SpanTimeCrossRegressedCorrelation(
+  regression=pls_regression(), correlation=pearsonr_correlation(), *args, **kwargs)
+metric_registry['spantime_ridge'] = lambda *args, **kwargs: SpanTimeCrossRegressedCorrelation(
+  regression=ridge_regression(), correlation=pearsonr_correlation(), *args, **kwargs)
+
+
+BIBTEX = """@article{schrimpf2018brain,
+  title={Brain-score: Which artificial neural network for object recognition is most brain-like?},
+  author={Schrimpf, Martin and Kubilius, Jonas and Hong, Ha and Majaj, Najib J and Rajalingham, Rishi and Issa, Elias B and Kar, Kohitij and Bashivan, Pouya and Prescott-Roy, Jonathan and Geiger, Franziska and others},
+  journal={BioRxiv},
+  pages={407007},
+  year={2018},
+  publisher={Cold Spring Harbor Laboratory}
+}"""
+
+BIBTEX_PLS = """@article{yamins2014performance,
+  title={Performance-optimized hierarchical models predict neural responses in higher visual cortex},
+  author={Yamins, Daniel LK and Hong, Ha and Cadieu, Charles F and Solomon, Ethan A and Seibert, Darren and DiCarlo, James J},
+  journal={Proceedings of the national academy of sciences},
+  volume={111},
+  number={23},
+  pages={8619--8624},
+  year={2014},
+  publisher={National Acad Sciences}
+}"""
+
+BIBTEX_NEURONTONEURON = """@techreport{arend2018single,
+  title={Single units in a deep neural network functionally correspond with neurons in the brain: preliminary results},
+  author={Arend, Luke and Han, Yena and Schrimpf, Martin and Bashivan, Pouya and Kar, Kohitij and Poggio, Tomaso and DiCarlo, James J and Boix, Xavier},
+  year={2018},
+  institution={Center for Brains, Minds and Machines (CBMM)}
+}"""

brainscore_vision/metrics/regression_correlation/mask_regression.py

@@ -0,0 +1,232 @@
+import logging
+
+import numpy as np
+from tqdm import tqdm
+from typing import Union
+
+from brainscore_vision.utils import fullname
+
+
+# do not import tensorflow at top level to avoid forcing users to install it if they don't use this metric
+
+
+class MaskRegression:
+    """
+    Klindt et. al, NIPS 2017
+    https://papers.nips.cc/paper/6942-neural-system-identification-for-large-populations-separating-what-and-where
+
+    TF implementation of Receptive Field factorized regression
+    """
+
+    def __init__(self, init_lr=0.01,
+                 max_epochs=40, tol=0.1, batch_size=50, ls=.1, ld=.1, decay_rate=25,
+                 inits: Union[None, dict] = None, log_rate=10, gpu_options=None):
+        """
+        mapping function class.
+        :param batch_size: batch size
+        :param init_lr: initial learning rate
+        :param ls: regularization coefficient for spatial parameters (spatial convolution)
+        :param ld: regularization coefficient for depth parameters (depth convolution)
+        :param tol: tolerance - stops the optimization if reaches below tol
+        :param max_epochs: maximum number of epochs to train
+        :param inits: initial values for the mapping function parameters. A dictionary containing
+                      any of the following keys ['s_w', 'd_w', 'bias']
+        :param log_rate: rate of logging the loss values
+        :param decay_rate: rate of decay for learning rate (#epochs)
+        """
+        self._ld = ld
+        self._ls = ls
+        self._tol = tol
+        self._batch_size = batch_size
+        self._lr = init_lr
+        self._max_epochs = max_epochs
+        self._inits = inits
+        self._log_rate = log_rate
+        self._decay_rate = decay_rate
+        self._gpu_options = gpu_options
+
+        self._graph = None
+        self._lr_ph = None
+        self._opt = None
+        self._logger = logging.getLogger(fullname(self))
+
+    def _iterate_minibatches(self, inputs, targets=None, batchsize=128, shuffle=False):
+        """
+        Iterates over inputs with minibatches
+        :param inputs: input dataset, first dimension should be examples
+        :param targets: [n_examples, n_neurons] response values, first dimension should be examples
+        :param batchsize: batch size
+        :param shuffle: flag indicating whether to shuffle the data while making minibatches
+        :return: minibatch of (X, Y)
+        """
+        input_len = inputs.shape[0]
+        if shuffle:
+            indices = np.arange(input_len)
+            np.random.shuffle(indices)
+        for start_idx in range(0, input_len, batchsize):
+            if shuffle:
+                excerpt = indices[start_idx:start_idx + batchsize]
+            else:
+                excerpt = slice(start_idx, start_idx + batchsize)
+            if targets is None:
+                yield inputs[excerpt]
+            else:
+                yield inputs[excerpt], targets[excerpt]
+
+    def fit(self, X, Y):
+        """
+        Fits the parameters to the data
+        :param X: Source data, first dimension is examples
+        :param Y: Target data, first dimension is examples
+        """
+        assert not np.isnan(X).any() and not np.isnan(Y).any()
+        self.setup()
+        X = self.reindex(X)
+        assert X.ndim == 4, 'Input matrix rank should be 4.'
+        with self._graph.as_default():
+            self._init_mapper(X, Y)
+            lr = self._lr
+            for epoch in tqdm(range(self._max_epochs), desc='mask epochs'):
+                for counter, batch in enumerate(
+                        self._iterate_minibatches(X, Y, batchsize=self._batch_size, shuffle=True)):
+                    feed_dict = {self._input_placeholder: batch[0],
+                                 self._target_placeholder: batch[1],
+                                 self._lr_ph: lr}
+                    _, loss_value, reg_loss_value = self._sess.run([self.train_op, self.l2_error, self.reg_loss],
+                                                                   feed_dict=feed_dict)
+                if epoch % self._log_rate == 0:
+                    self._logger.debug(f'Epoch: {epoch}, Err Loss: {loss_value:.2f}, Reg Loss: {reg_loss_value:.2f}')
+                if epoch % self._decay_rate == 0 and epoch != 0:
+                    lr /= 10.
+                if loss_value < self._tol:
+                    self._logger.debug('Converged.')
+                    break
+
+    def predict(self, X):
+        """
+        Predicts the responses to the give input X
+        :param X: Input data, first dimension is examples
+        :return: predictions
+        """
+        assert not np.isnan(X).any()
+        X = self.reindex(X)
+        with self._graph.as_default():
+            preds = []
+            for batch in self._iterate_minibatches(X, batchsize=self._batch_size, shuffle=False):
+                feed_dict = {self._input_placeholder: batch}
+                preds.append(np.squeeze(self._sess.run([self._predictions], feed_dict=feed_dict)))
+            return np.concatenate(preds, axis=0)
+
+    def setup(self):
+        import tensorflow as tf
+        self._graph = tf.Graph()
+        with self._graph.as_default():
+            self._lr_ph = tf.compat.v1.placeholder(dtype=tf.float32)
+            self._opt = tf.compat.v1.train.AdamOptimizer(learning_rate=self._lr_ph)
+
+    def reindex(self, X):
+        channel_names = ['channel', 'channel_x', 'channel_y']
+        assert all(hasattr(X, coord) for coord in channel_names)
+        shapes = [len(set(X[channel].values)) for channel in channel_names]
+        X = np.reshape(X.values, [X.shape[0]] + shapes)
+        X = np.transpose(X, axes=[0, 2, 3, 1])
+        return X
+
+    def _make_separable_map(self):
+        """
+        Makes the mapping function computational graph
+        """
+        import tensorflow as tf
+        with self._graph.as_default():
+            with tf.compat.v1.variable_scope('mapping'):
+                input_shape = self._input_placeholder.shape
+                preds = []
+                for n in range(self._target_placeholder.shape[1]):
+                    with tf.compat.v1.variable_scope('N_{}'.format(n)):
+                        # for all variables, either use pre-defined initial value or initialize randomly
+                        if self._inits is not None and 's_w' in self._inits:
+                            s_w = tf.Variable(initial_value=
+                                              self._inits['s_w'][n].reshape((1, input_shape[1], input_shape[2], 1)),
+                                              dtype=tf.float32)
+                        else:
+                            s_w = tf.Variable(initial_value=np.random.randn(1, input_shape[1], input_shape[2], 1),
+                                              dtype=tf.float32)
+                        if self._inits is not None and 'd_w' in self._inits:
+                            d_w = tf.Variable(initial_value=self._inits['d_w'][n].reshape(1, 1, input_shape[-1], 1),
+                                              dtype=tf.float32)
+                        else:
+                            d_w = tf.Variable(initial_value=np.random.randn(1, 1, input_shape[-1], 1),
+                                              dtype=tf.float32)
+                        if self._inits is not None and 'bias' in self._inits:
+                            bias = tf.Variable(initial_value=self._inits['bias'][n].reshape(1, 1, 1, 1),
+                                               dtype=tf.float32)
+                        else:
+                            bias = tf.Variable(initial_value=np.zeros((1, 1, 1, 1)), dtype=tf.float32)
+
+                        tf.compat.v1.add_to_collection('s_w', s_w)
+                        out = s_w * self._input_placeholder
+
+                        tf.compat.v1.add_to_collection('d_w', d_w)
+                        out = tf.reduce_sum(input_tensor=out, axis=[1, 2], keepdims=True)
+                        out = tf.nn.conv2d(input=out, filters=d_w, strides=[1, 1, 1, 1], padding='SAME')
+
+                        tf.compat.v1.add_to_collection('bias', bias)
+                        preds.append(tf.squeeze(out, axis=[1, 2]) + bias)
+
+                self._predictions = tf.concat(preds, -1)
+
+    def _make_loss(self):
+        """
+        Makes the loss computational graph
+        """
+        import tensorflow as tf
+        with self._graph.as_default():
+            with tf.compat.v1.variable_scope('loss'):
+                self.l2_error = tf.norm(tensor=self._predictions - self._target_placeholder, ord=2)
+                # For separable mapping
+                self._s_vars = tf.compat.v1.get_collection('s_w')
+                self._d_vars = tf.compat.v1.get_collection('d_w')
+                self._biases = tf.compat.v1.get_collection('bias')
+
+                # Laplacian loss
+                laplace_filter = tf.constant(np.array([0, -1, 0, -1, 4, -1, 0, -1, 0]).reshape((3, 3, 1, 1)),
+                                             dtype=tf.float32)
+                laplace_loss = tf.reduce_sum(
+                    input_tensor=[tf.norm(tensor=tf.nn.conv2d(input=t, filters=laplace_filter, strides=[1, 1, 1, 1], padding='SAME')) for t in self._s_vars])
+                l2_loss = tf.reduce_sum(input_tensor=[tf.reduce_sum(input_tensor=tf.pow(t, 2)) for t in self._s_vars])
+                self.reg_loss = self._ls * (l2_loss + laplace_loss) + \
+                                self._ld * tf.reduce_sum(input_tensor=[tf.reduce_sum(input_tensor=tf.pow(t, 2)) for t in self._d_vars])
+
+                self.total_loss = self.l2_error + self.reg_loss
+                self.tvars = tf.compat.v1.get_collection(tf.compat.v1.GraphKeys.TRAINABLE_VARIABLES)
+                self.train_op = self._opt.minimize(self.total_loss, var_list=self.tvars,
+                                                   global_step=tf.compat.v1.train.get_or_create_global_step())
+
+    def _init_mapper(self, X, Y):
+        """
+        Initializes the mapping function graph
+        :param X: input data
+        """
+        import tensorflow as tf
+        assert len(Y.shape) == 2
+        with self._graph.as_default():
+            self._input_placeholder = tf.compat.v1.placeholder(dtype=tf.float32, shape=[None] + list(X.shape[1:]))
+            self._target_placeholder = tf.compat.v1.placeholder(dtype=tf.float32, shape=[None, Y.shape[1]])
+            # Build the model graph
+            self._make_separable_map()
+            self._make_loss()
+
+            # initialize graph
+            self._logger.debug('Initializing mapper')
+            init_op = tf.compat.v1.variables_initializer(tf.compat.v1.get_collection(tf.compat.v1.GraphKeys.GLOBAL_VARIABLES))
+            self._sess = tf.compat.v1.Session(
+                config=tf.compat.v1.ConfigProto(gpu_options=self._gpu_options) if self._gpu_options is not None else None)
+            self._sess.run(init_op)
+
+    def close(self):
+        """
+        Closes occupied resources
+        """
+        import tensorflow as tf
+        tf.compat.v1.reset_default_graph()
+        self._sess.close()

brainscore_vision/metrics/regression_correlation/metric.py

@@ -0,0 +1,125 @@
+import numpy as np
+import scipy.stats
+from sklearn.cross_decomposition import PLSRegression
+from sklearn.linear_model import LinearRegression, Ridge
+from sklearn.preprocessing import scale
+
+from brainio.assemblies import walk_coords, DataAssembly
+from brainscore_core.metrics import Metric, Score
+from brainscore_vision.metric_helpers.transformations import CrossValidation
+from brainscore_vision.metric_helpers.xarray_utils import XarrayRegression, XarrayCorrelation
+from brainscore_vision.metric_helpers.temporal import SpanTimeRegression, PerTime
+
+
+class CrossRegressedCorrelation(Metric):
+    def __init__(self, regression, correlation, crossvalidation_kwargs=None):
+        regression = regression or pls_regression()
+        crossvalidation_defaults = dict(train_size=.9, test_size=None)
+        crossvalidation_kwargs = {**crossvalidation_defaults, **(crossvalidation_kwargs or {})}
+
+        self.cross_validation = CrossValidation(**crossvalidation_kwargs)
+        self.regression = regression
+        self.correlation = correlation
+
+    def __call__(self, source: DataAssembly, target: DataAssembly) -> Score:
+        return self.cross_validation(source, target, apply=self.apply, aggregate=self.aggregate)
+
+    def apply(self, source_train, target_train, source_test, target_test):
+        self.regression.fit(source_train, target_train)
+        prediction = self.regression.predict(source_test)
+        score = self.correlation(prediction, target_test)
+        return score
+
+    def aggregate(self, scores):
+        return scores.median(dim='neuroid')
+
+
+class ScaledCrossRegressedCorrelation(Metric):
+    def __init__(self, *args, **kwargs):
+        self.cross_regressed_correlation = CrossRegressedCorrelation(*args, **kwargs)
+        self.aggregate = self.cross_regressed_correlation.aggregate
+
+    def __call__(self, source: DataAssembly, target: DataAssembly) -> Score:
+        scaled_values = scale(target, copy=True)
+        target = target.__class__(scaled_values, coords={
+            coord: (dims, value) for coord, dims, value in walk_coords(target)}, dims=target.dims)
+        return self.cross_regressed_correlation(source, target)
+
+
+class SingleRegression:
+    def __init__(self):
+        self.mapping = []
+
+    def fit(self, X, Y):
+        X = X.values
+        Y = Y.values
+        n_stim, n_neuroid = X.shape
+        _, n_neuron = Y.shape
+        r = np.zeros((n_neuron, n_neuroid))
+        for neuron in range(n_neuron):
+            r[neuron, :] = pearsonr(X, Y[:, neuron:neuron + 1])
+        self.mapping = np.nanargmax(r, axis=1)
+
+    def predict(self, X):
+        X = X.values
+        Ypred = X[:, self.mapping]
+        return Ypred
+
+
+# make the crc to consider time as a sample dimension
+def SpanTimeCrossRegressedCorrelation(regression, correlation, *args, **kwargs):
+    return CrossRegressedCorrelation(
+                regression=SpanTimeRegression(regression), 
+                correlation=PerTime(correlation), 
+                *args, **kwargs
+            )    
+
+
+def pls_regression(regression_kwargs=None, xarray_kwargs=None):
+    regression_defaults = dict(n_components=25, scale=False)
+    regression_kwargs = {**regression_defaults, **(regression_kwargs or {})}
+    regression = PLSRegression(**regression_kwargs)
+    xarray_kwargs = xarray_kwargs or {}
+    regression = XarrayRegression(regression, **xarray_kwargs)
+    return regression
+
+
+def linear_regression(xarray_kwargs=None):
+    regression = LinearRegression()
+    xarray_kwargs = xarray_kwargs or {}
+    regression = XarrayRegression(regression, **xarray_kwargs)
+    return regression
+
+
+def ridge_regression(xarray_kwargs=None):
+    regression = Ridge()
+    xarray_kwargs = xarray_kwargs or {}
+    regression = XarrayRegression(regression, **xarray_kwargs)
+    return regression
+
+
+def single_regression(xarray_kwargs=None):
+    regression = SingleRegression()
+    xarray_kwargs = xarray_kwargs or {}
+    regression = XarrayRegression(regression, **xarray_kwargs)
+    return regression
+
+
+def pearsonr_correlation(xarray_kwargs=None):
+    xarray_kwargs = xarray_kwargs or {}
+    return XarrayCorrelation(scipy.stats.pearsonr, **xarray_kwargs)
+
+
+def pearsonr(x, y):
+    xmean = x.mean(axis=0, keepdims=True)
+    ymean = y.mean(axis=0, keepdims=True)
+
+    xm = x - xmean
+    ym = y - ymean
+
+    normxm = scipy.linalg.norm(xm, axis=0, keepdims=True)
+    normym = scipy.linalg.norm(ym, axis=0, keepdims=True)
+
+    r = ((xm / normxm) * (ym / normym)).sum(axis=0)
+
+    return r

brainscore_vision/metrics/regression_correlation/requirements.txt

@@ -0,0 +1,3 @@
+numpy
+scipy
+scikit-learn

brainscore_vision/metrics/regression_correlation/test.py

@@ -0,0 +1,36 @@
+import numpy as np
+import pytest
+from pytest import approx
+
+from brainio.assemblies import NeuroidAssembly
+from brainscore_vision import load_metric
+from .metric import pls_regression, linear_regression, ridge_regression
+
+
+class TestCrossRegressedCorrelation:
+    def test_small(self):
+        assembly = NeuroidAssembly((np.arange(30 * 25) + np.random.standard_normal(30 * 25)).reshape((30, 25)),
+                                   coords={'stimulus_id': ('presentation', np.arange(30)),
+                                           'object_name': ('presentation', ['a', 'b', 'c'] * 10),
+                                           'neuroid_id': ('neuroid', np.arange(25)),
+                                           'region': ('neuroid', ['some_region'] * 25)},
+                                   dims=['presentation', 'neuroid'])
+        metric = load_metric('pls')
+        score = metric(source=assembly, target=assembly)
+        assert score == approx(1, abs=.00001)
+
+
+class TestRegression:
+    @pytest.mark.parametrize('regression_ctr', [pls_regression, linear_regression, ridge_regression])
+    def test_small(self, regression_ctr):
+        assembly = NeuroidAssembly((np.arange(30 * 25) + np.random.standard_normal(30 * 25)).reshape((30, 25)),
+                                   coords={'stimulus_id': ('presentation', np.arange(30)),
+                                           'object_name': ('presentation', ['a', 'b', 'c'] * 10),
+                                           'neuroid_id': ('neuroid', np.arange(25)),
+                                           'region': ('neuroid', [None] * 25)},
+                                   dims=['presentation', 'neuroid'])
+        regression = regression_ctr()
+        regression.fit(source=assembly, target=assembly)
+        prediction = regression.predict(source=assembly)
+        assert all(prediction['stimulus_id'] == assembly['stimulus_id'])
+        assert all(prediction['neuroid_id'] == assembly['neuroid_id'])

brainscore_vision/metrics/threshold/__init__.py

@@ -0,0 +1,5 @@
+from brainscore_vision import metric_registry
+from .metric import Threshold, ThresholdElevation
+
+metric_registry['threshold'] = Threshold
+metric_registry['threshold_elevation'] = ThresholdElevation