brainscore-vision 2.1__py3-none-any.whl

brainscore_vision/data/malania2007/data_packaging/malania_data_assembly.py

@@ -0,0 +1,79 @@
+from pathlib import Path
+import numpy as np
+import xarray as xr
+
+from brainio.assemblies import PropertyAssembly
+from brainio.packaging import package_data_assembly
+import pandas as pd
+
+
+DATASETS = ['short-2', 'short-4', 'short-6', 'short-8', 'short-16', 'equal-2',
+            'long-2', 'equal-16', 'long-16', 'vernier-only']
+NUM_SUBJECTS = {'short-2': 6,
+                'short-4': 5,
+                'short-6': 5,
+                'short-8': 5,
+                'short-16': 6,
+                'equal-2': 5,
+                'long-2': 5,
+                'equal-16': 5,
+                'long-16': 5,
+                'vernier-only': 6}
+
+
+def collect_malania_data_assembly(root_directory, dataset):
+    """
+    Experiment Information:
+        - 5-6 observers per condition (for exact value, see NUM_SUBJECTS)
+        - 2AFC left/right offset discrimination task
+        - PEST staircase to 75% correct responses
+        - thresholds measured with a cumulative gaussian psychometric function with a likelihood fit
+    """
+    # construct the assembly
+    metadata_directory = Path(f'{root_directory}/{dataset}/metadata_human.xlsx')
+    metadata = pd.read_excel(metadata_directory)
+    # Since subjects are uniquely held using 'unique_subject_id', drop the rows with a subject
+    #  without measurement
+    assembly = PropertyAssembly(metadata['threshold'],
+                                  coords={
+                                      'subject': ('subject', metadata['subject_unique_id']),
+                                  },
+                                  dims=['subject']
+                                  )
+
+    # give the assembly an identifier name
+    assembly.name = f'Malania2007_{dataset}'
+
+    # test subject numbers after removing the NaN subject
+    metadata = metadata.dropna(subset=['threshold'], axis=0)
+    assert len(metadata) == NUM_SUBJECTS[dataset]
+
+    return assembly
+
+
+def remove_subjects_with_nans(assembly1, assembly2):
+    # Find the indices of the subjects with NaN values in the first PropertyAssembly
+    nan_subjects = np.isnan(assembly1.values)
+
+    # Convert the boolean array to a DataArray with the same coordinates as the input assemblies
+    nan_subjects_da = xr.DataArray(nan_subjects, coords=assembly1.coords, dims=assembly1.dims)
+
+    # Filter out the subjects with NaN values from both PropertyAssemblies
+    filtered_assembly1 = assembly1.where(~nan_subjects_da, drop=True)
+    filtered_assembly2 = assembly2.where(~nan_subjects_da, drop=True)
+
+    return filtered_assembly1, filtered_assembly2
+
+
+if __name__ == '__main__':
+    root_directory = Path(r'.')
+    for dataset in DATASETS:
+        assembly = collect_malania_data_assembly(root_directory, dataset)
+        # upload to S3
+        prints = package_data_assembly(catalog_identifier=None,
+                                       proto_data_assembly=assembly,
+                                       assembly_identifier=assembly.name,
+                                       stimulus_set_identifier=assembly.name,
+                                       assembly_class_name="PropertyAssembly",
+                                       bucket_name="brainio-brainscore")
+        print(prints)

brainscore_vision/data/malania2007/data_packaging/malania_stimulus_set.py

@@ -0,0 +1,79 @@
+import csv
+from pathlib import Path
+from brainio.stimuli import StimulusSet
+from brainio.packaging import package_stimulus_set
+
+
+# every stimulus set is separate, incl. baseline condition
+STIMULUS_SETS = ['short-2', 'short-4', 'short-6', 'short-8', 'short-16', 'equal-2',
+                 'long-2', 'equal-16', 'long-16', 'vernier-only', 'short-2_fit',
+                 'short-4_fit', 'short-6_fit', 'short-8_fit', 'short-16_fit',
+                 'equal-2_fit', 'long-2_fit', 'equal-16_fit', 'long-16_fit']
+DATASET_LENGTHS = {'test': 50, 'fit': 500}
+
+
+def collect_malania_stimulus_set(root_directory, dataset):
+    """
+    Dataset Meta Info
+
+    Reported in pixels:
+        - image_size_x; image_size_y
+        - vernier_position_x; vernier_position_y
+
+    Reported in arcsec:
+        - vernier_height (height of the vernier elements combined, - middle gap)
+        - vernier_offset (horizontal offset between flankers)
+        - flanker_height (height of the flanker elements)
+        - flanker_spacing (distance between a flanker element and another flanker element)
+        - line_width (width of all the lines in all elements)
+        - flanker_distance (distance between a flanker and a vernier)
+    """
+    stimuli = []
+    stimulus_paths = {}
+
+    dataset_type = 'fit' if dataset[-3:] == 'fit' else 'test'
+    metadata_directory = Path(f'{root_directory}/{dataset}/metadata.csv')
+    image_directory = Path(f'{root_directory}/{dataset}/images')
+    with open(metadata_directory, 'r') as metadata:
+        reader = csv.DictReader(metadata)
+        for row in reader:
+            stimuli.append({
+                'image_size_x_pix': int(row['image_size_x_pix']),
+                'image_size_y_pix': int(row['image_size_y_pix']),
+                'image_size_c': int(row['image_size_c']),
+                'image_size_degrees': float(row['image_size_degrees']),
+                'vernier_height_arcsec': float(row['vernier_height_arcsec']),
+                'vernier_offset_arcsec': float(row['vernier_offset_arcsec']),
+                'image_label': row['image_label'],
+                'flanker_height_arcsec': float(row['flanker_height_arcsec']),
+                'flanker_spacing_arcsec': float(row['flanker_spacing_arcsec']),
+                'line_width_arcsec': float(row['line_width_arcsec']),
+                'flanker_distance_arcsec': float(row['flanker_distance_arcsec']),
+                'num_flankers': int(row['num_flankers']),
+                'vernier_position_x_pix': int(row['vernier_position_x_pix']),
+                'vernier_position_y_pix': int(row['vernier_position_y_pix']),
+                'stimulus_id': str(row['stimulus_id']),
+            })
+            stimulus_paths[row['stimulus_id']] = Path(f'{image_directory}/{row["filename"]}')
+
+    stimuli = StimulusSet(stimuli)
+    stimuli.stimulus_paths = stimulus_paths
+    stimuli.name = f'Malania2007_{dataset}'  # give the StimulusSet an identifier name
+    stimuli.identifier = f'Malania2007_{dataset}'
+
+    # Ensure expected number of stimuli in datasets
+    assert len(stimuli) == DATASET_LENGTHS[dataset_type]
+    return stimuli
+
+
+if __name__ == '__main__':
+    root_directory = Path(r'../data/malania2007/data_packaging/')
+    for stimulus_set in STIMULUS_SETS:
+        stimuli = collect_malania_stimulus_set(root_directory, stimulus_set)
+
+        # upload to S3
+        prints = package_stimulus_set(catalog_name=None,
+                                      proto_stimulus_set=stimuli,
+                                      stimulus_set_identifier=stimuli.name,
+                                      bucket_name="brainio-brainscore")
+        print(prints)

brainscore_vision/data/malania2007/test.py

@@ -0,0 +1,147 @@
+import numpy as np
+import pytest
+
+from brainscore_vision import load_stimulus_set, load_dataset
+from brainscore_vision.benchmarks.malania2007.benchmark import DATASETS
+
+
+@pytest.mark.private_access
+class TestAssemblies:
+    # test the number of subjects:
+    @pytest.mark.parametrize('identifier, num_subjects', [
+        ('short2', 6),
+        ('short4', 5),
+        ('short6', 5),
+        ('short8', 5),
+        ('short16', 6),
+        ('equal2', 5),
+        ('long2', 5),
+        ('equal16', 5),
+        ('long16', 5),
+        ('vernier_only', 6)
+    ])
+    def test_num_subjects(self, identifier, num_subjects):
+        assembly = load_dataset(f"Malania2007.{identifier}")
+        assembly = assembly.dropna(dim='subject')
+        assert len(np.unique(assembly['subject'].values)) == num_subjects
+
+    # test assembly coords present in ALL 17 sets:
+    @pytest.mark.parametrize('identifier', [
+        'short2',
+        'short4',
+        'short6',
+        'short8',
+        'short16',
+        'equal2',
+        'long2',
+        'equal16',
+        'long16',
+        'vernier_only',
+    ])
+    @pytest.mark.parametrize('field', [
+        'subject'
+    ])
+    def test_fields_present(self, identifier, field):
+        assembly = load_dataset(f"Malania2007.{identifier}")
+        assert hasattr(assembly, field)
+
+
+@pytest.mark.private_access
+class TestStimulusSets:
+    # test stimulus_set data:
+    @pytest.mark.parametrize('identifier', [
+        'short2',
+        'short4',
+        'short6',
+        'short8',
+        'short16',
+        'equal2',
+        'long2',
+        'equal16',
+        'long16',
+        'short2_fit',
+        'short4_fit',
+        'short6_fit',
+        'short8_fit',
+        'short16_fit',
+        'equal2_fit',
+        'long2_fit',
+        'equal16_fit',
+        'long16_fit',
+        'vernier_only'
+    ])
+    def test_stimulus_set_exist(self, identifier):
+        full_name = f"Malania2007.{identifier}"
+        stimulus_set = load_stimulus_set(full_name)
+        assert stimulus_set is not None
+        stripped_actual_identifier = stimulus_set.identifier.replace('.', '').replace('_', '').replace('-', '')
+        stripped_expected_identifier = full_name.replace('.', '').replace('_', '').replace('-', '')
+        assert stripped_actual_identifier == stripped_expected_identifier
+
+    @pytest.mark.parametrize('identifier, num_images', [
+        ('short2', 50),
+        ('short4', 50),
+        ('short6', 50),
+        ('short8', 50),
+        ('short16', 50),
+        ('equal2', 50),
+        ('long2', 50),
+        ('equal16', 50),
+        ('long16', 50),
+        ('short2_fit', 500),
+        ('short4_fit', 500),
+        ('short6_fit', 500),
+        ('short8_fit', 500),
+        ('short16_fit', 500),
+        ('equal2_fit', 500),
+        ('long2_fit', 500),
+        ('equal16_fit', 500),
+        ('long16_fit', 500),
+        ('vernier_only', 50)
+    ])
+    def test_number_of_images(self, identifier, num_images):
+        stimulus_set = load_stimulus_set(f"Malania2007.{identifier}")
+        assert len(np.unique(stimulus_set['stimulus_id'].values)) == num_images
+
+    # tests stimulus_set coords for the 14 "normal" sets:
+    @pytest.mark.parametrize('identifier', [
+        'short2',
+        'short4',
+        'short6',
+        'short8',
+        'short16',
+        'equal2',
+        'long2',
+        'equal16',
+        'long16',
+        'short2_fit',
+        'short4_fit',
+        'short6_fit',
+        'short8_fit',
+        'short16_fit',
+        'equal2_fit',
+        'long2_fit',
+        'equal16_fit',
+        'long16_fit',
+        'vernier_only'
+    ])
+    @pytest.mark.parametrize('field', [
+        'image_size_x_pix',
+        'image_size_y_pix',
+        'image_size_c',
+        'image_size_degrees',
+        'vernier_height_arcsec',
+        'vernier_offset_arcsec',
+        'image_label',
+        'flanker_height_arcsec',
+        'flanker_spacing_arcsec',
+        'line_width_arcsec',
+        'flanker_distance_arcsec',
+        'num_flankers',
+        'vernier_position_x_pix',
+        'vernier_position_y_pix',
+        'stimulus_id',
+    ])
+    def test_fields_present(self, identifier, field):
+        stimulus_set = load_stimulus_set(f"Malania2007.{identifier}")
+        assert hasattr(stimulus_set, field)

brainscore_vision/data/maniquet2024/__init__.py

@@ -0,0 +1,57 @@
+from brainio.assemblies import BehavioralAssembly
+from brainscore_vision import stimulus_set_registry, data_registry
+from brainscore_vision.data_helpers.s3 import (
+    load_assembly_from_s3,
+    load_stimulus_set_from_s3,
+)
+
+BIBTEX = """@article {Maniquet2024.04.02.587669,
+        author = {Maniquet, Tim and de Beeck, Hans Op and Costantino, Andrea Ivan},
+        title = {Recurrent issues with deep neural network models of visual recognition},
+        elocation-id = {2024.04.02.587669},
+        year = {2024},
+        doi = {10.1101/2024.04.02.587669},
+        publisher = {Cold Spring Harbor Laboratory},
+        URL = {https://www.biorxiv.org/content/early/2024/04/10/2024.04.02.587669},
+        eprint = {https://www.biorxiv.org/content/early/2024/04/10/2024.04.02.587669.full.pdf},
+        journal = {bioRxiv}
+}"""
+
+# Human Stimulus Set
+stimulus_set_registry["Maniquet2024"] = lambda: load_stimulus_set_from_s3(
+    identifier="Maniquet2024",
+    bucket="brainio-brainscore",
+    csv_sha1="ec61e1d7776a6c3b467fee862302edac8d4a156e",
+    zip_sha1="bbdaf09528974c4ca3ee4cddbc91e0e03351291f",
+    csv_version_id="HwA7hBw0KVt6O.S_eDTXCHjOxfXlK_N3",
+    zip_version_id="lDUmFncDxloQp_9.S3VcpiOIPa1sCr7N",
+)
+
+# DNN test Stimulus Set
+stimulus_set_registry["Maniquet2024-test"] = lambda: load_stimulus_set_from_s3(
+    identifier="Maniquet2024-test",
+    bucket="brainio-brainscore",
+    csv_sha1="993089ba4aaeffbc61303acb2a5171a5fa271ea5",
+    zip_sha1="39f9aaf13fdd66d284bcea99f187bb0c065144e4",
+    csv_version_id="G8mwsgXbuaodl_icHRzA9_LK1LeF1mco",
+    zip_version_id="O05BqRf79q78oQJXcN.iPeeEwNSOF2iS",
+)
+
+#  DNN train Stimulus Set
+stimulus_set_registry["Maniquet2024-train"] = lambda: load_stimulus_set_from_s3(
+    identifier="Maniquet2024-train",
+    bucket="brainio-brainscore",
+    csv_sha1="da965af3ae5ab6e49d46c28f682ef4b75d0a2045",
+    zip_sha1="6685effb52f6870175988c47892b3f9a916a0375",
+    csv_version_id="1y.4Een3cC_ju8lqOZcSeLTXxsoPq5Wg",
+    zip_version_id="WUCsCnvwUWVSLaioFsKXrxpOGdIMt8ij",
+)
+
+# Human Data Assembly (behavioural)
+data_registry["Maniquet2024"] = lambda: load_assembly_from_s3(
+    identifier="Maniquet2024",
+    version_id="ppAs1vv02btHmfmUMtLejawBuA96Iv2j",
+    sha1="39b8b7b29fad080ebba6df8a46ac4426261342d5",
+    bucket="brainio-brainscore",
+    cls=BehavioralAssembly,
+)

brainscore_vision/data/maniquet2024/data_packaging.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Sat Jun 22 00:24:30 2024
+
+@author: costantino_ai
+"""
+
+import os
+import logging
+from pathlib import Path
+import pandas as pd
+from brainio.assemblies import BehavioralAssembly
+from brainio.stimuli import StimulusSet
+from brainio.packaging import package_data_assembly, package_stimulus_set
+
+# Setup logging
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+)
+
+# Constants
+ROOT_DIRECTORY = "./maniquet2024/private"
+TAG = "Maniquet2024"
+
+
+def load_stimulus_set(stimuli_directory, tag):
+    """
+    Load and package stimuli from the specified directory.
+
+    Args:
+        stimuli_directory (str): Directory containing stimulus files.
+        tag (str): Tag to assign to the stimulus set.
+
+    Returns:
+        StimulusSet: Packaged set of stimuli with metadata.
+    """
+    logging.info("Loading stimuli from directory: %s", stimuli_directory)
+    stimuli = []
+    stimulus_paths = {}
+
+    for filepath in Path(stimuli_directory).glob("*.png"):
+        stimulus_id = filepath.stem
+        parts = filepath.stem.split("_")
+        exemplar_number, manipulation, manipulation_details, category = (
+            parts[0],
+            parts[1],
+            parts[2],
+            parts[3],
+        )
+
+        stimulus_paths[stimulus_id] = filepath
+        stimuli.append(
+            {
+                "stimulus_id": stimulus_id,
+                "manipulation": manipulation,
+                "manipulation_details": manipulation_details,
+                "image_label": category,
+                "exemplar_number": exemplar_number,
+            }
+        )
+
+    stimulus_set = StimulusSet(stimuli)
+    stimulus_set.stimulus_paths = stimulus_paths
+    stimulus_set.name = tag
+    logging.info("Total stimuli loaded: %d", len(stimulus_set))
+    return stimulus_set
+
+
+def load_behavioral_data(data_file, tag):
+    """
+    Load and package experimental data from a CSV file.
+
+    Args:
+        data_file (str): Path to the CSV file containing experimental data.
+        tag (str): Tag to assign to the behavioral data assembly.
+
+    Returns:
+        BehavioralAssembly: Data assembly of behavioral responses.
+    """
+    logging.info("Loading behavioral data from file: %s", data_file)
+    df = pd.read_csv(data_file)
+    assembly = BehavioralAssembly(
+        df["acc"],
+        dims=["presentation"],
+        coords={
+            "stimulus_id": ("presentation", df["stimulus_id"].values),
+            "manipulation": ("presentation", df["condition"].values),
+            "manipulation_details": ("presentation", df["task_details"].values),
+            "mask": ("presentation", df["mask"].values),
+            "image_label": ("presentation", df["category"].values),
+            "prediction": ("presentation", df["prediction"].values),
+            "response": ("presentation", df["response"].values),
+            "reaction_time": ("presentation", df["rt"].values),
+            "subject_id": ("presentation", df["subj"].values),
+            "task": ("presentation", df["task_long"].values),
+        },
+    )
+    assembly.name = tag
+    logging.info(
+        "Data assembly loaded with %d presentations", len(assembly["presentation"])
+    )
+    return assembly
+
+
+def main():
+    """
+    Main function to package stimulus set and experimental data, and upload to S3.
+    """
+    logging.info("Starting the data packaging process.")
+
+    # Load stimuli from directories
+    human_stimuli_directory = os.path.join(ROOT_DIRECTORY, "human_stimuli")
+    dnntest_stimuli_directory = os.path.join(ROOT_DIRECTORY, "dnn_stimuli/test")
+    dnntrain_stimuli_directory = os.path.join(ROOT_DIRECTORY, "dnn_stimuli/train")
+
+    human_stimulus_set = load_stimulus_set(human_stimuli_directory, TAG)
+    dnntest_stimulus_set = load_stimulus_set(dnntest_stimuli_directory, f"{TAG}-test")
+    dnntrain_stimulus_set = load_stimulus_set(dnntrain_stimuli_directory, f"{TAG}-train")
+
+    # Upload stimuli
+    human_stimulus_meta = package_stimulus_set(
+        None, human_stimulus_set, human_stimulus_set.name, "brainio-brainscore"
+    )
+    dnntest_stimulus_meta = package_stimulus_set(
+        None, dnntest_stimulus_set, dnntest_stimulus_set.name, "brainio-brainscore"
+    )
+    dnntrain_stimulus_meta = package_stimulus_set(
+        None, dnntrain_stimulus_set, dnntrain_stimulus_set.name, "brainio-brainscore"
+    )
+
+    # Load human data assembly
+    data_file = os.path.join(ROOT_DIRECTORY, "data/human_data_andrea.csv")
+    data_assembly = load_behavioral_data(data_file, TAG)
+    assembly_meta = package_data_assembly(
+        None,
+        data_assembly,
+        data_assembly.name,
+        human_stimulus_set.name,
+        "BehavioralAssembly",
+        "brainio-brainscore",
+    )
+
+    # print(human_stimulus_meta)
+    # print(dnntest_stimulus_meta)
+    # print(dnntrain_stimulus_meta)
+    # print(assembly_meta)
+
+
+if __name__ == "__main__":
+    main()

brainscore_vision/data/maniquet2024/test.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Jun 20 17:32:25 2024
+
+@author: costantino_ai
+"""
+import pytest
+from brainscore_vision import load_dataset, load_stimulus_set
+
+@pytest.mark.private_access
+def test_existence():
+    assert load_stimulus_set('Maniquet2024') is not None
+    assert load_dataset('Maniquet2024') is not None
+    
+    

brainscore_vision/data/marques2020/__init__.py

@@ -0,0 +1,123 @@
+from brainio.assemblies import PropertyAssembly
+
+from brainscore_vision import data_registry, stimulus_set_registry, load_stimulus_set
+from brainscore_vision.data_helpers.s3 import load_stimulus_set_from_s3, load_assembly_from_s3
+
+BIBTEX = """@article{dapello2020simulating,
+  title={Simulating a primary visual cortex at the front of CNNs improves robustness to image perturbations},
+  author={Dapello, Joel and Marques, Tiago and Schrimpf, Martin and Geiger, Franziska and Cox, David and DiCarlo, James J},
+  journal={Advances in Neural Information Processing Systems},
+  volume={33},
+  pages={13073--13087},
+  year={2020}
+}"""
+
+# --- datasets ---
+data_registry['Cavanaugh2002a'] = lambda: load_assembly_from_s3(
+    identifier="movshon.Cavanaugh2002a",
+    version_id="2vAgf8I9mx0dAZ6E.v9_wQ1qjqXlBIlG",
+    sha1="d4b24f4bbf8a14138a8e98391ab03796c2c05e7d",
+    bucket="brainio-brainscore",
+    cls=PropertyAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('Marques2020_size'),
+    merge_stimulus_set_meta=False,
+)
+
+data_registry['FreemanZiemba2013_V1_properties'] = lambda: load_assembly_from_s3(
+    identifier="movshon.FreemanZiemba2013_V1_properties",
+    version_id="fmhJH37ozlGbGPW16B0NSgdm2fz17aEc",
+    sha1="e665522d9a32e6cd6c3ebc61ff65fd3899c8d3e6",
+    bucket="brainio-brainscore",
+    cls=PropertyAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('FreemanZiemba2013_properties'),
+    merge_stimulus_set_meta=False,
+)
+
+data_registry['DeValois1982a'] = lambda: load_assembly_from_s3(
+    identifier="devalois.DeValois1982a",
+    version_id="d_IU4t6LbkvxsaEEsu9VzhTm9jX3AhSI",
+    sha1="8f4fd70e987c3c566b5b6c6bf15ef27637618b2c",
+    bucket="brainio-brainscore",
+    cls=PropertyAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('Marques2020_orientation'),
+    merge_stimulus_set_meta=False,
+)
+
+data_registry['DeValois1982b'] = lambda: load_assembly_from_s3(
+    identifier="devalois.DeValois1982b",
+    version_id="jG7loVtkn3vsH0hT6wl4Qv24EsJJJSDt",
+    sha1="611176eefdac09feaa4c07f081784c24067629e1",
+    bucket="brainio-brainscore",
+    cls=PropertyAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('Marques2020_spatial_frequency'),
+    merge_stimulus_set_meta=False,
+)
+
+data_registry['Ringach2002'] = lambda: load_assembly_from_s3(
+    identifier="shapley.Ringach2002",
+    version_id="aMkWQinb7JEhJCJb0RhfGJegTwbya6Yw",
+    sha1="0f3e19140bd9f930109879a38e574471d9576cf5",
+    bucket="brainio-brainscore",
+    cls=PropertyAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('Marques2020_orientation'),
+    merge_stimulus_set_meta=False,
+)
+
+data_registry['Schiller1976c'] = lambda: load_assembly_from_s3(
+    identifier="schiller.Schiller1976c",
+    version_id="tJUZfDfz5G1E3UtEjptQeI7Esbg2aArD",
+    sha1="58daa02ba2680e75dcb11b37eb6085c4afb6576e",
+    bucket="brainio-brainscore",
+    cls=PropertyAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('Marques2020_spatial_frequency'),
+    merge_stimulus_set_meta=False,
+)
+
+# --- stimulus sets ---
+stimulus_set_registry['Marques2020_blank'] = lambda: load_stimulus_set_from_s3(
+    identifier="Marques2020_blank",
+    bucket="brainio-brainscore",
+    csv_sha1="c02d44b0d3e157b29c6b96c5c5a478a8b37dc70b",
+    zip_sha1="5c4eef94691d6d63f8b1610918728b8531fc861e",
+    csv_version_id="DFf6cT85oVHnn.sVjeSwRGKyn2fgafVh",
+    zip_version_id="s_q1EehLR0tl3qNb7J4ryOXskYPA0p0w")
+
+stimulus_set_registry['Marques2020_receptive_field'] = lambda: load_stimulus_set_from_s3(
+    identifier="Marques2020_receptive_field",
+    bucket="brainio-brainscore",
+    csv_sha1="e3681c69122b20ff3dd22486f546a26b3a97e057",
+    zip_sha1="fc21a9302bb0fca85350049ab740af80f2307ece",
+    csv_version_id="tpIibDdmc5BMuzFCBYol8dbsfZ27jsv3",
+    zip_version_id="XmBi05s_Fc2IIrATxs8d3hLFXbk2RsXg")
+
+stimulus_set_registry['Marques2020_orientation'] = lambda: load_stimulus_set_from_s3(
+    identifier="Marques2020_orientation",
+    bucket="brainio-brainscore",
+    csv_sha1="b316c6d9c6ddb58f8f21e79ae2b59b03933c0068",
+    zip_sha1="6a02466e221ac314da2db2969c89688dff64ab1b",
+    csv_version_id="G6m1JpCXhlt7K6WSKkJxr1ZEBZd.lwxK",
+    zip_version_id="TOKD_m3hr_ipt7s_Kjst4e5BRyrlBDzM")
+
+stimulus_set_registry['Marques2020_spatial_frequency'] = lambda: load_stimulus_set_from_s3(
+    identifier="Marques2020_spatial_frequency",
+    bucket="brainio-brainscore",
+    csv_sha1="31d0293c8aa1590f4680bb8a9446f56135b8d646",
+    zip_sha1="6fdeee4366514b9a0ff9c52e52c13762a62ceaab",
+    csv_version_id="9agd9hLik0snAVzY9HVL4B5Pc6n48js6",
+    zip_version_id="ZRFAMvscpHH9rGaviqnmIifrl328zkMx")
+
+stimulus_set_registry['Marques2020_size'] = lambda: load_stimulus_set_from_s3(
+    identifier="Marques2020_size",
+    bucket="brainio-brainscore",
+    csv_sha1="0fd0aeea8fa6ff2b30ee9a6a684d4600590d631f",
+    zip_sha1="11122de2784218b7dd4cd0b557e62583ca7ee283",
+    csv_version_id="F2TGTYZ1Mxe3ojl5ZZxwZAVItNAGUa.0",
+    zip_version_id="kAMLBJIilOH6.ZyOmqAeqkyrllxkHEtl")
+
+stimulus_set_registry['FreemanZiemba2013_properties'] = lambda: load_stimulus_set_from_s3(
+    identifier="FreemanZiemba2013_properties",
+    bucket="brainio-brainscore",
+    csv_sha1="6f7bcb5d0c01e81c9fbdcec9bf586cbb579a9b02",
+    zip_sha1="c64a0d6b447676a6d5cff3d3625a5f294e62ff97",
+    csv_version_id="8yCRYPY.IyBJ5mwlkuYlV4VZEokg8Tke",
+    zip_version_id="pdzZwABgR1dxUL2Pfpj4TuBMCWND51_z")