brainscore-vision 2.1__py3-none-any.whl

brainscore_vision/benchmarks/bracci2019/benchmark.py

@@ -0,0 +1,286 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Jun 21 22:18:07 2024
+
+@author: costantino_ai
+"""
+
+import xarray as xr
+import numpy as np
+from scipy.stats import spearmanr
+from brainscore_vision.benchmarks import BenchmarkBase
+from brainscore_vision.benchmark_helpers.screen import place_on_screen
+from brainscore_vision.model_interface import BrainModel
+from brainscore_vision import load_stimulus_set, load_metric, load_dataset
+from brainscore_vision.utils import LazyLoad
+from brainio.assemblies import NeuroidAssembly
+from brainscore_core.metrics import Score
+
+
+BIBTEX = """@article{bracci2019ventral,
+  title={The ventral visual pathway represents animal appearance over animacy, unlike human behavior and deep neural networks},
+  author={Bracci, Stefania and Ritchie, J Brendan and Kalfas, Ioannis and de Beeck, Hans P Op},
+  journal={Journal of Neuroscience},
+  volume={39},
+  number={33},
+  pages={6513--6525},
+  year={2019},
+  publisher={Soc Neuroscience}
+}"""
+
+TIME_BIN_ST, TIME_BIN_END = (
+    70,
+    170,
+)  # standard core object recognition response, following Majaj*, Hong*, et al. 2015
+
+
+class _Bracci2019RSA(BenchmarkBase):
+    """
+    A benchmark class to measure the similarity between model-generated confusion probabilities
+    and human confusion data in visual tasks, specifically designed for the Maniquet2024 dataset.
+
+    Attributes:
+        _metric (ConfusionSimilarity): The metric used to compare model outputs with human data.
+        _fitting_stimuli (StimulusSet): Stimulus set used for training or fitting the model.
+        _stimulus_set (StimulusSet): Stimulus set used for testing the model.
+        _human_assembly (DataAssembly): Human behavioral data for comparison.
+        _visual_degrees (int): The size of stimuli in visual degrees as presented to humans.
+        _number_of_trials (int): Number of trials to average over for the model predictions.
+    """
+
+    def __init__(self, region):
+        """
+        Initializes the benchmark by setting up the necessary parameters.
+        """
+
+        # Initialize the metric for evaluating confusion similarity
+        self._metric = load_metric("rdm")
+
+        # # Load testing stimuli from the stimulus set registry
+        # self._stimulus_set = stimulus_set_registry["Bracci2019"]()
+
+        # # Load human behavioral data from the data registry
+        # self._human_assembly = data_registry["Bracci2019"]()
+
+        # Load testing stimuli from the stimulus set registry
+        self._stimulus_set = load_stimulus_set('Bracci2019')
+
+        # Load human behavioral data from the data registry
+        self._human_assembly = load_dataset('Bracci2019')
+
+        # Set the visual degrees to which the human data was exposed
+        self._visual_degrees = 8
+
+        # Set the number of trials to perform
+        self._number_of_trials = 1
+
+        # Set the region to record from
+        self._region = region
+
+        # Define a mapping
+        self._roi_map = {
+            "V1": (0, "V1"),
+            "posteriorVTC": (1, "IT"),
+            "anteriorVTC": (2, "IT"),
+        }
+
+        assert (
+            self._region in self._roi_map
+        ), "The ROI to compare must either ['V1', 'posteriorVTC', or 'anteriorVTC']"
+
+        # Call the parent class constructor to complete initialization
+        super(_Bracci2019RSA, self).__init__(
+            identifier=f"Bracci2019.{region}-rdm",
+            version=1,
+            # ceiling_func=lambda: self._metric._ceiling(self._assembly),
+            ceiling_func=lambda: 1,
+            parent="Bracci2019",
+            bibtex=BIBTEX,
+        )
+
+    def _center_data_by_subject(self, roi_assembly):
+        """
+        Center the data by subject by subtracting the mean across all conditions for each voxel.
+
+        Args:
+            roi_assembly (DataArray): The input data array with regions of interest and subject identifiers.
+
+        Returns:
+            DataArray: The ROI data array with centered data by subject.
+        """
+        # Get unique list of subjects in the data
+        subjects = np.unique(roi_assembly["subject"])
+        centered_data_list = []
+
+        for subject in subjects:
+            # Select data for the current subject
+            subject_data = roi_assembly.sel(neuroid=roi_assembly["subject"] == subject)
+            # Center the data by subtracting the mean across presentations
+            subject_centered_data = subject_data - subject_data.mean(dim="presentation")
+            # Append the centered data for this subject to the list
+            centered_data_list.append(subject_centered_data)
+
+        # Concatenate all the subject-centered data back into a single assembly
+        full_centered_assembly = xr.concat(centered_data_list, dim="neuroid")
+
+        return full_centered_assembly
+
+    def _get_human_ceiling(self, roi_centered_assembly):
+        """
+        Calculate the "lower bound" ceiling for human performance based on inter-subject correlations of RDMs.
+
+        Args:
+            roi_centered_assembly (DataArray): The ROI data array with subject-centered data.
+
+        Returns:
+            float: The average inter-subject correlation, representing the human performance ceiling.
+        """
+        # Get unique list of subjects in the data
+        subjects = np.unique(roi_centered_assembly["subject"])
+        correlations = []
+
+        for subject in subjects:
+            # Generate RDM for the current subject
+            subject_rdm = self._metric._rdm(
+                roi_centered_assembly.sel(
+                    neuroid=roi_centered_assembly["subject"] == subject
+                )
+            ).values
+
+            # Generate RDMs for other subjects
+            other_rdms = [
+                self._metric._rdm(
+                    roi_centered_assembly.sel(
+                        neuroid=roi_centered_assembly["subject"] == other_subject
+                    )
+                ).values
+                for other_subject in subjects
+                if other_subject != subject
+            ]
+
+            # Compute the average RDM from other subjects
+            average_rdm = np.mean(other_rdms, axis=0)
+
+            # Extract the lower triangle of the RDM matrix
+            mask = np.tril(np.ones_like(subject_rdm), -1).astype(bool)
+            vector_lt_subject = subject_rdm[mask]
+            vector_lt_average = average_rdm[mask]
+
+            # Compute the Spearman correlation
+            correlation, _ = spearmanr(vector_lt_subject, vector_lt_average)
+
+            # Append the correlation result
+            correlations.append(correlation)
+
+        # Compute the average correlation across all subjects
+        human_ceiling = np.mean(correlations)
+
+        return float(human_ceiling)
+
+    def _average_voxels_across_subjects(self, roi_centered_assembly):
+        """
+        Compute the mean across the 'voxels' dimension to create a new NeuroidAssembly with averaged neuroid data.
+
+        This function averages voxel data within the input neuroid assembly across all subjects and retains important metadata
+        about presentations and neuroids.
+
+        Args:
+            roi_centered_assembly (xarray.DataArray): The input data array with regions of interest, voxels, and subject data.
+
+        Returns:
+            NeuroidAssembly: A new assembly object with averaged neuroid data and associated coordinates.
+        """
+        # Average voxel data across subjects to simplify the neuroid representation
+        averaged_assy = roi_centered_assembly.groupby("voxels").mean()
+        averaged_data = averaged_assy.values
+
+        # Construct the NeuroidAssembly with the averaged data and maintain the presentation metadata
+        assembly = NeuroidAssembly(
+            averaged_data,
+            dims=["presentation", "neuroid"],
+            coords={
+                "stimulus_id": (
+                    "presentation",
+                    roi_centered_assembly["stimulus_id"].values,
+                ),
+                "stimulus_name": (
+                    "presentation",
+                    roi_centered_assembly["stimulus_name"].values,
+                ),
+                "exemplar_number": (
+                    "presentation",
+                    roi_centered_assembly["exemplar_number"].values,
+                ),
+                "image_label": (
+                    "presentation",
+                    roi_centered_assembly["image_label"].values,
+                ),
+                "image_group": (
+                    "presentation",
+                    roi_centered_assembly["image_group"].values,
+                ),
+                "voxels": ("neuroid", list(range(averaged_data.shape[-1]))),
+            },
+        )
+        return assembly
+
+    def __call__(self, candidate: BrainModel):
+        """
+
+        Args:
+            candidate (BrainModel): The model being evaluated.
+
+        Returns:
+            float: The similarity score between the model and human data.
+        """
+        # Start the model on the task of predicting confusion probabilities
+        candidate.start_recording(
+            self._roi_map[self._region][1], [(TIME_BIN_ST, TIME_BIN_END)]
+        )
+
+        # Prepare the stimulus set by placing it on a virtual screen at a scale appropriate for the model
+        stimulus_set = place_on_screen(
+            self._stimulus_set,
+            target_visual_degrees=candidate.visual_degrees(),
+            source_visual_degrees=self._visual_degrees,
+        )
+
+        # Model looks at the stimulus set
+        dnn_assembly = candidate.look_at(
+            stimulus_set, number_of_trials=self._number_of_trials
+        )
+        if 'time_bin' in dnn_assembly.dims and dnn_assembly.sizes['time_bin'] == 1:
+            dnn_assembly = dnn_assembly.squeeze('time_bin')  # static case for these benchmarks
+
+        # Get the human data
+        human_data = self._human_assembly
+
+        # Select only the data for the current ROI
+        roi_idx = self._roi_map[self._region][0]
+        roi_assembly = human_data.sel(neuroid=human_data["roi"] == roi_idx)
+
+        # Center data (by subject, across all conditions)
+        roi_centered_assembly = self._center_data_by_subject(roi_assembly)
+
+        # Average voxels across subjects
+        human_averaged_assembly = self._average_voxels_across_subjects(
+            roi_centered_assembly
+        )
+
+        # Calculate the human ceiling
+        ceiling = self._get_human_ceiling(roi_centered_assembly)
+
+        # Compare (corr) the two RDMs to get the score
+        similarity = self._metric(dnn_assembly, human_averaged_assembly)
+
+        # Normalize by ceiling
+        score = Score(similarity / ceiling)
+        score.attrs["raw"] = similarity
+        score.attrs["ceiling"] = ceiling
+
+        return score
+
+
+def Bracci2019RSA(region):
+    return _Bracci2019RSA(region)

brainscore_vision/benchmarks/bracci2019/requirements.txt

@@ -0,0 +1,3 @@
+scipy
+xarray
+numpy

brainscore_vision/benchmarks/cadena2017/__init__.py

@@ -0,0 +1,5 @@
+from brainscore_vision import benchmark_registry
+from .benchmark import ToliasCadena2017PLS, ToliasCadena2017Mask
+
+benchmark_registry['Cadena2017-pls'] = ToliasCadena2017PLS
+benchmark_registry['Cadena2017-mask'] = ToliasCadena2017Mask

brainscore_vision/benchmarks/cadena2017/benchmark.py

@@ -0,0 +1,91 @@
+import brainscore_vision
+from brainscore_vision import load_metric, load_ceiling
+from brainio.assemblies import walk_coords, array_is_element
+from brainscore_vision.benchmark_helpers.neural_common import NeuralBenchmark
+
+VISUAL_DEGREES = 2
+NUMBER_OF_TRIALS = 2
+BIBTEX = """@article{cadena2019deep,
+  title={Deep convolutional models improve predictions of macaque V1 responses to natural images},
+  author={Cadena, Santiago A and Denfield, George H and Walker, Edgar Y and Gatys, Leon A and Tolias, Andreas S and Bethge, Matthias and Ecker, Alexander S},
+  journal={PLoS computational biology},
+  volume={15},
+  number={4},
+  pages={e1006897},
+  year={2019},
+  url={https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1006897},
+  publisher={Public Library of Science San Francisco, CA USA}
+}"""
+
+
+def ToliasCadena2017PLS():
+    loader = AssemblyLoader()
+    assembly_repetition = loader(average_repetition=False)
+    assembly = loader(average_repetition=True)
+    assembly.stimulus_set.identifier = assembly.stimulus_set_identifier
+
+    similarity_metric = load_metric('pls', crossvalidation_kwargs={'stratification_coord': None})
+    ceiler = load_ceiling('internal_consistency', split_coord='repetition_id')
+
+    def ceiling():
+        # This assembly has many stimuli that are only shown to a subset of the neurons.
+        # When the loader runs with `average_repetition=True`, it automatically drops nan cells,
+        # but for the `assembly_repetition`, it keeps all the rows.
+        # If we now use the usual ceiling approach, the two halves will end up with NaN values
+        # due to stimuli not being shown to neurons, which doesn't let us correlate.
+        # Instead, we here drop all NaN cells and their corresponding stimuli,
+        # which keeps only 43% of the original presentation rows, but lets us correlate again.
+        assembly_nonan, stimuli = loader.dropna(assembly_repetition, assembly_repetition.attrs['stimulus_set'])
+        return ceiler(assembly_nonan)
+
+    return NeuralBenchmark(identifier='Cadena2017-pls', version=1,
+                           assembly=assembly, similarity_metric=similarity_metric,
+                           visual_degrees=VISUAL_DEGREES, number_of_trials=NUMBER_OF_TRIALS,
+                           parent='V1', bibtex=BIBTEX,
+                           ceiling_func=ceiling)
+
+
+def ToliasCadena2017Mask():
+    loader = AssemblyLoader()
+    assembly_repetition = loader(average_repetition=False)
+    assembly = loader(average_repetition=True)
+    assembly.stimulus_set.identifier = assembly.stimulus_set_identifier
+
+    similarity_metric = load_metric('mask_regression',
+                                    crossvalidation_kwargs={'splits': 4, 'stratification_coord': None})
+    ceiler = load_ceiling('internal_consistency', split_coord='repetition_id')
+    return NeuralBenchmark(identifier='tolias.Cadena2017-mask', version=1,
+                           assembly=assembly, similarity_metric=similarity_metric,
+                           visual_degrees=VISUAL_DEGREES, number_of_trials=NUMBER_OF_TRIALS,
+                           parent='V1', bibtex=BIBTEX,
+                           ceiling_func=lambda: ceiler(assembly_repetition))
+
+
+class AssemblyLoader:
+    def __call__(self, average_repetition=True):
+        assembly = brainscore_vision.load_dataset(identifier='Cadena2017')
+        assembly = assembly.squeeze("time_bin")
+        assembly = assembly.transpose('presentation', 'neuroid')
+        if average_repetition:
+            assembly = self.average_repetition(assembly)
+        return assembly
+
+    def _align_stimuli(self, stimulus_set, image_ids):
+        stimulus_set = stimulus_set.loc[stimulus_set['stimulus_id'].isin(image_ids)]
+        return stimulus_set
+
+    def average_repetition(self, assembly):
+        attrs = assembly.attrs  # workaround to keeping attrs
+        presentation_coords = [coord for coord, dims, values in walk_coords(assembly)
+                               if array_is_element(dims, 'presentation')]
+        presentation_coords = set(presentation_coords) - {'repetition_id', 'id'}
+        assembly = assembly.multi_groupby(presentation_coords).mean(dim='presentation', skipna=True)
+        assembly, stimulus_set = self.dropna(assembly, stimulus_set=attrs['stimulus_set'])
+        attrs['stimulus_set'] = stimulus_set
+        assembly.attrs = attrs
+        return assembly
+
+    def dropna(self, assembly, stimulus_set):
+        assembly = assembly.dropna('presentation')  # discard any images with NaNs (~14%)
+        stimulus_set = self._align_stimuli(stimulus_set, assembly.stimulus_id.values)
+        return assembly, stimulus_set

brainscore_vision/benchmarks/cadena2017/test.py

@@ -0,0 +1,35 @@
+import pytest
+from pytest import approx
+
+from brainscore_vision.benchmark_helpers import check_standard_format
+from brainscore_vision.benchmark_helpers.test_helper import StandardizedTests, VisualDegreesTests
+from brainscore_vision.benchmarks.cadena2017.benchmark import AssemblyLoader
+
+standardized_tests = StandardizedTests()
+visual_degrees_test = VisualDegreesTests()
+
+
+@pytest.mark.private_access
+class TestAssembly:
+    def test(self):
+        loader = AssemblyLoader()
+        assembly = loader()
+        check_standard_format(assembly)
+        assert assembly.attrs['stimulus_set_identifier'] == 'Cadena2017'
+        assert len(assembly['presentation']) == 6249
+        assert len(assembly['neuroid']) == 166
+
+
+@pytest.mark.private_access
+def test_self_regression():
+    standardized_tests.self_regression_test(
+        benchmark='Cadena2017-pls', visual_degrees=2, expected=approx(.577474, abs=.005))
+
+
+@pytest.mark.private_access
+@pytest.mark.parametrize('candidate_degrees, image_id, expected', [
+    (14, '0fe27ddd5b9ea701e380063dc09b91234eba3551', approx(.32655, abs=.0001)),
+    (6, '0fe27ddd5b9ea701e380063dc09b91234eba3551', approx(.29641, abs=.0001)),
+])
+def test_amount_gray(candidate_degrees: int, image_id: str, expected: float):
+    visual_degrees_test.amount_gray_test('Cadena2017-pls', candidate_degrees, image_id, expected)

brainscore_vision/benchmarks/coggan2024_behavior/__init__.py

@@ -0,0 +1,8 @@
+# Created by David Coggan on 2024 06 25
+
+from brainscore_vision import benchmark_registry
+from .benchmark import (
+    Coggan2024_behavior_ConditionWiseAccuracySimilarity)
+
+benchmark_registry['Coggan2024_behavior-ConditionWiseAccuracySimilarity'] = (
+    Coggan2024_behavior_ConditionWiseAccuracySimilarity)

brainscore_vision/benchmarks/coggan2024_behavior/benchmark.py

@@ -0,0 +1,133 @@
+# Created by David Coggan on 2024 06 25
+
+import numpy as np
+from brainio.assemblies import DataAssembly, BehavioralAssembly
+from brainscore_vision import load_stimulus_set, load_dataset
+from brainscore_vision.benchmarks import BenchmarkBase
+from brainscore_vision.benchmark_helpers.screen import place_on_screen
+from brainscore_core.metrics import Score
+from brainscore_vision.metric_helpers import Defaults as XarrayDefaults
+from brainscore_vision.model_interface import BrainModel
+from brainscore_vision.utils import LazyLoad
+from scipy.stats import sem
+import pandas as pd
+
+# the BIBTEX will be used to link to the publication from the benchmark for further details
+BIBTEX = """@article {
+    Tong.Coggan2024.behavior,
+    author = {David D. Coggan and Frank Tong},
+    title = {Modeling human visual recognition of occluded objects}},
+    year = {2024},
+    url = {},
+    journal = {in prep}}"""
+
+class Coggan2024_behavior_ConditionWiseAccuracySimilarity(BenchmarkBase):
+
+    """
+    This benchmark measures classification accuracy for a set of occluded object images, then attains the mean accuracy
+    for each of the 18 occlusion conditions. This is then correlated with the corresponding accuracies for each of the
+    30 human subjects in the behavioral experiment to obtain the brain score.
+    Note: Because the object-occluder pairings were randomized for each subject, image-level metrics (e.g., error
+    consistency) have limited utility here as a ceiling cannot be calculated.
+    """
+
+    def __init__(self):
+        self._fitting_stimuli = load_stimulus_set('Coggan2024_behavior_fitting')  # this fails is wrapped by LazyLoad
+        self._assembly = LazyLoad(lambda: load_dataset('Coggan2024_behavior'))
+        self._visual_degrees = 10
+        self._number_of_trials = 1
+        self._ceiling_func = lambda assembly: get_noise_ceiling(assembly)
+        super(Coggan2024_behavior_ConditionWiseAccuracySimilarity, self).__init__(
+            identifier='tong.Coggan2024_behavior-ConditionWiseAccuracySimilarity',
+            version=1,
+            ceiling_func=lambda df: get_noise_ceiling(df),
+            parent='behavior',
+            bibtex=BIBTEX,
+        )
+
+    def __call__(self, candidate: BrainModel) -> Score:
+
+        fitting_stimuli = place_on_screen(
+            self._fitting_stimuli,
+            target_visual_degrees=candidate.visual_degrees(),
+            source_visual_degrees=self._visual_degrees)
+        candidate.start_task(BrainModel.Task.probabilities, fitting_stimuli)
+        stimulus_set = place_on_screen(
+            self._assembly.stimulus_set,
+            target_visual_degrees=candidate.visual_degrees(),
+            source_visual_degrees=self._visual_degrees)
+        probabilities = candidate.look_at(
+            stimulus_set, number_of_trials=self._number_of_trials)
+        model_predictions = [
+            probabilities.choice[c].values for c in probabilities.argmax(axis=1)]
+
+        data = pd.DataFrame(dict(
+            subject=self._assembly.subject,
+            object_class=self._assembly.object_class,
+            occluder_type=self._assembly.occluder_type,
+            occluder_color=self._assembly.occluder_color,
+            visibility=self._assembly.visibility,
+            human_prediction=self._assembly.values,
+            human_accuracy=self._assembly.human_accuracy,
+            model_prediction=model_predictions
+        ))
+        data['model_accuracy'] = pd.Series(
+            data.model_prediction == data.object_class, dtype=int)
+
+        # get correlation between model and human performance across conditions
+        performance = (
+            data[data.visibility < 1]
+            .groupby(['subject', 'occluder_type', 'occluder_color'])
+            .mean(numeric_only=True)
+            .reset_index()
+        )
+        scores = performance.groupby('subject').apply(
+            lambda df: np.corrcoef(df.human_accuracy, df.model_accuracy)[0, 1])
+        score = Score(np.mean(scores))
+        score.attrs['raw'] = scores
+
+        # get ceiled score
+        ceiled_score = ceiler(score, self._ceiling_func(performance))
+        ceiled_score.attrs['raw'] = score
+
+        return ceiled_score
+
+
+def get_noise_ceiling(performance: pd.DataFrame) -> Score:
+    """
+    Returns the noise ceiling for human similarity estimates. This is the lower bound of typical noise-ceiling range
+    (e.g. Nili et al., 2014), i.e., the correlation of condition-wise accuracies between each individual subject and
+    the mean of the remaining subjects in the sample. This matches how the model is scored, if the group values are
+    substituted for model values.
+    """
+    nc = []
+    for subject in performance.subject.unique():
+        performance_ind = performance[performance.subject == subject]
+        performance_grp = performance[performance.subject != subject]
+        numeric_cols = performance_grp.select_dtypes(include=np.number).columns
+        performance_grp = performance_grp.groupby(['occluder_type', 'occluder_color'])[numeric_cols].mean()
+        merged_df = performance_ind.merge(
+            performance_grp, on=['occluder_type', 'occluder_color'])
+        nc.append(np.corrcoef(merged_df.human_accuracy_x, merged_df.human_accuracy_y)[0, 1])
+    ceiling = Score(np.mean(nc))
+    ceiling.attrs['raw'] = nc
+    ceiling.attrs['error'] = sem(nc)
+    return ceiling
+
+
+def ceiler(score: Score, ceiling: Score) -> Score:
+    # ro(X, Y)
+    # = (r(X, Y) / sqrt(r(X, X) * r(Y, Y)))^2
+    # = (r(X, Y) / sqrt(r(Y, Y) * r(Y, Y)))^2  # assuming that r(Y, Y) ~ r(X, X) following Yamins 2014
+    # = (r(X, Y) / r(Y, Y))^2
+    r_square = np.power(score.values / ceiling.values, 2)
+    ceiled_score = Score(r_square)
+    if 'error' in score.attrs:
+        ceiled_score.attrs['error'] = score.attrs['error']
+    ceiled_score.attrs[Score.RAW_VALUES_KEY] = score
+    ceiled_score.attrs['ceiling'] = ceiling
+    return ceiled_score
+
+
+
+

brainscore_vision/benchmarks/coggan2024_behavior/test.py

@@ -0,0 +1,21 @@
+# Created by David Coggan on 2024 06 26
+
+import pytest
+from pytest import approx
+from brainscore_vision import benchmark_registry, load_benchmark
+from brainscore_vision import load_model
+
+
+def test_benchmark_registry():
+    assert ('Coggan2024_behavior-ConditionWiseAccuracySimilarity' in
+            benchmark_registry)
+
+@pytest.mark.private_access
+def test_benchmarks():
+    benchmark = load_benchmark(
+        'Coggan2024_behavior-ConditionWiseAccuracySimilarity')
+    model = load_model('alexnet')
+    result = benchmark(model)
+    assert result.values == approx(0.1318, abs=.001)
+
+

brainscore_vision/benchmarks/coggan2024_fMRI/__init__.py

@@ -0,0 +1,15 @@
+# Created by David Coggan on 2024 06 25
+
+from brainscore_vision import benchmark_registry
+from .benchmark import (
+    Coggan2024_V1,
+    Coggan2024_V2,
+    Coggan2024_V4,
+    Coggan2024_IT,
+)
+
+benchmark_registry['Coggan2024_fMRI.V1-rdm'] = Coggan2024_V1
+benchmark_registry['Coggan2024_fMRI.V2-rdm'] = Coggan2024_V2
+benchmark_registry['Coggan2024_fMRI.V4-rdm'] = Coggan2024_V4
+benchmark_registry['Coggan2024_fMRI.IT-rdm'] = Coggan2024_IT
+