brainscore-vision 2.1__py3-none-any.whl → 2.1.0__py3-none-any.whl

brainscore_vision/benchmarks/imagenet_c/benchmark.py

@@ -15,7 +15,7 @@ from brainscore_vision.benchmarks.imagenet.benchmark import NUMBER_OF_TRIALS
 from brainscore_vision.model_interface import BrainModel
 
 _logger = logging.getLogger(__name__)
-LOCAL_STIMULUS_DIRECTORY = '/braintree/data2/active/common/imagenet-c-brainscore-stimuli/'
+LOCAL_STIMULUS_DIRECTORY = '/mnt/brainscore-ami/imagenet-c-brainscore-stimuli/'
 
 BIBTEX = """@ARTICLE{Hendrycks2019-di,
    title         = "Benchmarking Neural Network Robustness to Common Corruptions

brainscore_vision/benchmarks/lonnqvist2024/__init__.py

@@ -0,0 +1,8 @@
+from brainscore_vision import benchmark_registry
+from . import benchmark
+
+benchmark_registry['Lonnqvist2024_InlabInstructionsBehavioralAccuracyDistance'] = lambda: benchmark._Lonnqvist2024BehavioralAccuracyDistanceInlabInstructions()
+benchmark_registry['Lonnqvist2024_InlabNoInstructionsBehavioralAccuracyDistance'] = lambda: benchmark._Lonnqvist2024BehavioralAccuracyDistanceInlabNoInstructions()
+benchmark_registry['Lonnqvist2024_OnlineNoInstructionsBehavioralAccuracyDistance'] = lambda: benchmark._Lonnqvist2024BehavioralAccuracyDistanceOnlineNoInstructions()
+
+benchmark_registry['Lonnqvist2024_EngineeringAccuracy'] = lambda: benchmark._Lonnqvist2024EngineeringAccuracy()

brainscore_vision/benchmarks/lonnqvist2024/benchmark.py

@@ -0,0 +1,125 @@
+from pathlib import Path
+
+import numpy as np
+
+from brainio.assemblies import BehavioralAssembly
+from brainscore_vision import load_metric, load_stimulus_set, load_dataset
+from brainscore_vision.benchmark_helpers.screen import place_on_screen
+from brainscore_vision.benchmarks import BenchmarkBase
+from brainscore_vision.metrics import Score
+from brainscore_vision.model_interface import BrainModel
+
+BIBTEX = ""  # to appear in a future article
+
+
+class _Lonnqvist2024Base(BenchmarkBase):
+    def __init__(self, identifier, dataset, ceiling_func, metric):
+        self._metric = metric
+        self._stimulus_set = load_stimulus_set('Lonnqvist2024_test')
+        self._fitting_stimuli = load_stimulus_set('Lonnqvist2024_train')
+        self._visual_degrees = 17.70753
+        self.assembly = load_dataset(f'Lonnqvist2024_{dataset}')
+
+        super(_Lonnqvist2024Base, self).__init__(
+            identifier=identifier, version=1,
+            ceiling_func=ceiling_func,
+            parent='Lonnqvist2024',
+            bibtex=BIBTEX)
+
+    def __call__(self, candidate: BrainModel, return_raw_responses: bool = False):
+        fitting_stimulus_set = 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=fitting_stimulus_set, number_of_trials=1)
+        stimulus_set = place_on_screen(
+            self._stimulus_set,
+            target_visual_degrees=candidate.visual_degrees(),
+            source_visual_degrees=self._visual_degrees
+        )
+        model_response = candidate.look_at(stimulus_set, number_of_trials=1)
+        model_response = convert_proba_to_choices(model_response)
+        raw_score = self._metric(model_response, self.assembly)
+        # Adjust score to ceiling
+        ceiling = self.ceiling
+        score = raw_score / ceiling
+        # ensure score <= 1.0
+        if score.values > 1:
+            score = Score(np.array(1.))
+        score.attrs['raw'] = raw_score
+        score.attrs['ceiling'] = ceiling
+        if return_raw_responses:
+            return score, model_response
+        return score
+
+
+class _Lonnqvist2024BehavioralAccuracyDistanceInlabInstructions(_Lonnqvist2024Base):
+    def __init__(self):
+        metric = load_metric('accuracy_distance')
+        ceiling_func = lambda: metric.ceiling(self.assembly)
+        super(_Lonnqvist2024BehavioralAccuracyDistanceInlabInstructions, self).__init__(
+            identifier='Lonnqvist2024-inlab-instructions_behavioral_accuracy_distance', dataset='inlab-instructions',
+            ceiling_func=ceiling_func,
+            metric=metric)
+
+
+class _Lonnqvist2024BehavioralAccuracyDistanceInlabNoInstructions(_Lonnqvist2024Base):
+    def __init__(self):
+        metric = load_metric('accuracy_distance')
+        ceiling_func = lambda: metric.ceiling(self.assembly)
+        super(_Lonnqvist2024BehavioralAccuracyDistanceInlabNoInstructions, self).__init__(
+            identifier='Lonnqvist2024-inlab-no-instructions_behavioral_accuracy_distance', dataset='inlab-no-instructions',
+            ceiling_func=ceiling_func,
+            metric=metric)
+
+
+class _Lonnqvist2024BehavioralAccuracyDistanceOnlineNoInstructions(_Lonnqvist2024Base):
+    def __init__(self):
+        metric = load_metric('accuracy_distance')
+        ceiling_func = lambda: metric.ceiling(self.assembly)
+        super(_Lonnqvist2024BehavioralAccuracyDistanceOnlineNoInstructions, self).__init__(
+            identifier='Lonnqvist2024-online-no-instructions_behavioral_accuracy_distance', dataset='online-no-instructions',
+            ceiling_func=ceiling_func,
+            metric=metric)
+
+
+class _Lonnqvist2024EngineeringAccuracy(_Lonnqvist2024Base):
+    def __init__(self):
+        metric = load_metric('accuracy')
+        ceiling_func = lambda: Score(1)
+        super(_Lonnqvist2024EngineeringAccuracy, self).__init__(
+            identifier='Lonnqvist2024-engineering_accuracy', dataset='inlab-instructions',
+            ceiling_func=ceiling_func,
+            metric=metric)
+
+    def __call__(self, candidate: BrainModel, return_raw_responses: bool = False):
+        fitting_stimulus_set = 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=fitting_stimulus_set, number_of_trials=1)
+        stimulus_set = place_on_screen(
+            self._stimulus_set,
+            target_visual_degrees=candidate.visual_degrees(),
+            source_visual_degrees=self._visual_degrees
+        )
+        model_response = candidate.look_at(stimulus_set, number_of_trials=1)
+        model_response = convert_proba_to_choices(model_response)
+        raw_score = self._metric(model_response, stimulus_set['truth'])
+        # Adjust score to ceiling
+        ceiling = self.ceiling
+        score = raw_score / ceiling
+        score.attrs['raw'] = raw_score
+        score.attrs['ceiling'] = ceiling
+        if return_raw_responses:
+            return score, model_response
+        return score
+
+
+def convert_proba_to_choices(source: BehavioralAssembly) -> np.array:
+    """Converts the probability values returned by models doing probability tasks to behavioral choices."""
+    decisions = np.argmax(source.values, axis=1)
+    choices = [source['choice'].values[decision] for decision in decisions]
+    return BehavioralAssembly(choices, coords={'presentation': source['presentation']})

brainscore_vision/benchmarks/lonnqvist2024/test.py

@@ -0,0 +1,61 @@
+import pytest
+from pytest import approx
+
+from brainscore_vision import benchmark_registry, load_benchmark, load_model
+
+
+@pytest.mark.parametrize('benchmark', [
+    'Lonnqvist2024_InlabInstructionsBehavioralAccuracyDistance',
+    'Lonnqvist2024_InlabNoInstructionsBehavioralAccuracyDistance',
+    'Lonnqvist2024_InlabInstructionsBehavioralAccuracyDistance',
+    'Lonnqvist2024_EngineeringAccuracy',
+])
+def test_benchmark_registry(benchmark):
+    assert benchmark in benchmark_registry
+
+
+class TestBehavioral:
+    @pytest.mark.private_access
+    @pytest.mark.parametrize('dataset, expected_ceiling', [
+        ('InlabInstructionsBehavioralAccuracyDistance', approx(0.95646366, abs=0.001)),
+        ('InlabNoInstructionsBehavioralAccuracyDistance', approx(0.84258475, abs=0.001)),
+        ('OnlineNoInstructionsBehavioralAccuracyDistance', approx(0.79752907, abs=0.001)),
+    ])
+    def test_dataset_ceiling(self, dataset, expected_ceiling):
+        benchmark = f"Lonnqvist2024_{dataset}"
+        benchmark = load_benchmark(benchmark)
+        ceiling = benchmark.ceiling
+        assert ceiling == expected_ceiling
+
+    @pytest.mark.private_access
+    @pytest.mark.parametrize('dataset, expected_raw_score', [
+        ('InlabInstructionsBehavioralAccuracyDistance', approx(0.58568247, abs=0.001)),
+        ('InlabNoInstructionsBehavioralAccuracyDistance', approx(0.62883828, abs=0.001)),
+        ('OnlineNoInstructionsBehavioralAccuracyDistance', approx(0.78192183, abs=0.001)),
+    ])
+    def test_model(self, dataset, expected_raw_score):
+        if 'all' in dataset:
+            benchmark = f"Lonnqvist2024_{dataset}"
+        else:
+            benchmark = f"Lonnqvist2024_{dataset}"
+        benchmark = load_benchmark(benchmark)
+        model = load_model('alexnet')
+        score = benchmark(model)
+        raw_score = score.raw
+        # division by ceiling <= 1 should result in higher score
+        assert score >= raw_score
+        assert raw_score == expected_raw_score
+
+
+class TestEngineering:
+    @pytest.mark.parametrize('dataset, expected_accuracy', [
+        ('EngineeringAccuracy', approx(0.45, abs=0.001)),
+    ])
+    def test_accuracy(self, dataset, expected_accuracy):
+        benchmark = load_benchmark(f"Lonnqvist2024_{dataset}")
+        model = load_model('alexnet')
+        score = benchmark(model)
+        raw_score = score.raw
+        # division by ceiling <= 1 should result in higher score
+        assert score >= raw_score
+        assert raw_score == expected_accuracy

brainscore_vision/benchmarks/malania2007/benchmark.py

@@ -186,6 +186,9 @@ class _Malania2007VernierAcuity(BenchmarkBase):
             # Adjust score to ceiling
             ceiling = self.ceiling
             score = raw_score / ceiling
+            # ensure score <= 1.0
+            if score.values > 1:
+                score = Score(np.array(1.))
             score.attrs['error'] = raw_score.error
 
             score.attrs['raw'] = raw_score

brainscore_vision/benchmarks/maniquet2024/benchmark.py

@@ -63,7 +63,7 @@ class _Maniquet2024ConfusionSimilarity(BenchmarkBase):
 
         # Call the parent class constructor to complete initialization
         super(_Maniquet2024ConfusionSimilarity, self).__init__(
-            identifier="Maniquet2024-confusion_similarity'",
+            identifier="Maniquet2024-confusion_similarity",
             version=1,
             ceiling_func=lambda: Score(0.53526),  # use pre-computed from `self._metric._ceiling(self._human_assembly)`
             parent="Maniquet2024",

brainscore_vision/data/lonnqvist2024/__init__.py

@@ -0,0 +1,47 @@
+from brainio.assemblies import BehavioralAssembly
+
+from brainscore_vision import data_registry, stimulus_set_registry, load_stimulus_set
+from brainscore_vision.data_helpers.s3 import load_assembly_from_s3, load_stimulus_set_from_s3
+
+
+data_registry['Lonnqvist2024_inlab-instructions'] = lambda: load_assembly_from_s3(
+    identifier='Lonnqvist2024_inlab-instructions',
+    version_id='nTcvZkZedprOMYKkZ8kONUxy4M.__F_C',
+    sha1='64ec603ebc852d193e7437980eaabe8fc482d88b',
+    bucket="brainio-brainscore",
+    cls=BehavioralAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('Lonnqvist2024_test'))
+
+data_registry['Lonnqvist2024_inlab-no-instructions'] = lambda: load_assembly_from_s3(
+    identifier='Lonnqvist2024_inlab-no-instructions',
+    version_id='XtRi6xl6cJJ_71mAzfqqm3fSKujI8O4C',
+    sha1='ff248ca2058d4e36eee44dbc6f8ea6a79c70b715',
+    bucket="brainio-brainscore",
+    cls=BehavioralAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('Lonnqvist2024_test'))
+
+data_registry['Lonnqvist2024_online-no-instructions'] = lambda: load_assembly_from_s3(
+    identifier='Lonnqvist2024_online-no-instructions',
+    version_id='VRMgNb4mYSf_S6S81LGK2LFVVrfnCI26',
+    sha1='04240330eaf371d160ab418fd5560a72ed42cecb',
+    bucket="brainio-brainscore",
+    cls=BehavioralAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('Lonnqvist2024_test'))
+
+stimulus_set_registry['Lonnqvist2024_train'] = lambda: load_stimulus_set_from_s3(
+    identifier='Lonnqvist2024_train',
+    bucket="brainio-brainscore",
+    csv_sha1='2d6a95a8239aa647ddc6aedd449eabcebdf882cf',
+    zip_sha1='8adbf4de94524892042d3e43629a4be2beeedcaf',
+    csv_version_id='92o14bqbYd5Xut2zoTADmT4S_FEPmuW6',
+    zip_version_id='oZM7Fe446bq15A1fpoatEsvWHZrstdXJ',
+    filename_prefix='stimulus_')
+
+stimulus_set_registry['Lonnqvist2024_test'] = lambda: load_stimulus_set_from_s3(
+    identifier='Lonnqvist2024_test',
+    bucket="brainio-brainscore",
+    csv_sha1='8bc98dfc9f334e5c21b68f6787b3255da0d8644a',
+    zip_sha1='cf94b5341d956d250e7f7798044cf71bbd100721',
+    csv_version_id='VCzpiY0ZMySfDTPIT8zauLZuV0QJmgwZ',
+    zip_version_id='ZjEM4Es91H1aGyGo73VcVoL1id6FdWiO',
+    filename_prefix='stimulus_')

brainscore_vision/data/lonnqvist2024/data_packaging/lonnqvist_data_assembly.py

@@ -0,0 +1,53 @@
+from pathlib import Path
+import numpy as np
+import xarray as xr
+
+from brainio.assemblies import BehavioralAssembly
+from brainio.packaging import package_data_assembly
+import pandas as pd
+
+
+DATASETS = ['inlab-instructions', 'inlab-no-instructions', 'online-no-instructions']
+
+
+def collect_lonnqvist_data_assembly(root_directory, dataset):
+    """
+    Experiment Information:
+    """
+    data = pd.read_csv(Path(rf'{root_directory}/{dataset}.csv'))
+
+    assembly = BehavioralAssembly(data['subject_answer'],
+                                  coords={
+                                      'subject': ('presentation', data['subject_id']),
+                                      'visual_degrees': ('presentation', data['visual_degrees']),
+                                      'image_duration': ('presentation', data['image_duration']),
+                                      'is_correct': ('presentation', data['is_correct']),
+                                      'subject_answer': ('presentation', data['subject_answer']),
+                                      'curve_length': ('presentation', data['curve_length']),
+                                      'n_cross': ('presentation', data['n_cross']),
+                                      'image_path': ('presentation', data['image_path']),
+                                      'stimulus_id': ('presentation', data['stimulus_id']),
+                                      'truth': ('presentation', data['truth']),
+                                      'image_label': ('presentation', data['truth'])
+                                  },
+                                  dims=['presentation']
+                                  )
+
+    # give the assembly an identifier name
+    assembly.name = f'Lonnqvist2024_{dataset}'
+
+    return assembly
+
+
+if __name__ == '__main__':
+    root_directory = Path(r'./local')
+    for dataset in DATASETS:
+        assembly = collect_lonnqvist_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="BehavioralAssembly",
+                                       bucket_name="brainio-brainscore")
+        print(prints)

brainscore_vision/data/lonnqvist2024/data_packaging/lonnqvist_stimulus_set.py

@@ -0,0 +1,61 @@
+from pathlib import Path
+import csv
+
+from brainio.stimuli import StimulusSet
+from brainio.packaging import package_stimulus_set
+
+'''
+dataset Meta Info
+
+- curve length: values from 20-200 in steps of 10 
+- n_cross: number of times the lines intercept, range from 1-7
+- condition: same or diff
+'''
+
+
+def collect_lonnqvist_stimulus_set(dataset, stimuli_directory, metadata_filepath):
+    stimuli = []
+    stimulus_paths = {}
+
+    with open(metadata_filepath, 'r') as metadata:
+        reader = csv.DictReader(metadata)
+        for row in reader:
+            stimulus_meta = {
+                'curve_length': int(row['curve_length']),
+                'n_cross': int(row['n_cross']),
+                'image_path': str(row['path']),
+                'stimulus_id': str(row['idx']),
+                'truth': str(row['correct_response_key']),
+                'image_label': str(row['correct_response_key'])
+            }
+
+            stimuli.append(stimulus_meta)
+            stimulus_paths[str(row['idx'])] = Path(f'{row["path"]}')
+
+    stimuli = StimulusSet(stimuli)
+    stimuli.stimulus_paths = stimulus_paths
+
+    stimuli.name = f'Lonnqvist2024_{dataset}'
+    stimuli.identifier = f'Lonnqvist2024_{dataset}'
+    return stimuli
+
+
+if __name__ == '__main__':
+    datasets = ['train', 'test']
+    stimulus_directories = {'train': Path(r'stimuli/images_examples'),
+                           'test': Path(r'stimuli/images')}
+    metadata_filepaths = {'train': Path('stimuli/metadata_examples.csv'),
+                            'test': Path('stimuli/metadata.csv')}
+    for dataset in datasets:
+        stimulus_set = collect_lonnqvist_stimulus_set(dataset,
+                                                      stimulus_directories[dataset],
+                                                      metadata_filepaths[dataset])
+        if dataset == 'train':
+            assert len(stimulus_set) == 185
+        else:
+            assert len(stimulus_set) == 380
+        prints = package_stimulus_set(catalog_name=None,
+                                      proto_stimulus_set=stimulus_set,
+                                      stimulus_set_identifier=stimulus_set.name,
+                                      bucket_name="brainio-brainscore")
+        print(prints)

brainscore_vision/data/lonnqvist2024/test.py

@@ -0,0 +1,127 @@
+import numpy as np
+import pytest
+
+from brainscore_vision import load_stimulus_set, load_dataset
+
+
+@pytest.mark.private_access
+@pytest.mark.parametrize('assembly_identifier', [
+    'Lonnqvist2024_inlab-instructions',
+    'Lonnqvist2024_inlab-no-instructions',
+    'Lonnqvist2024_online-no-instructions'
+])
+def test_existence(assembly_identifier):
+    assert load_dataset(assembly_identifier) is not None
+
+
+@pytest.mark.private_access
+class TestAssemblies:
+    @pytest.mark.parametrize('assembly', [
+        'Lonnqvist2024_inlab-instructions',
+        'Lonnqvist2024_inlab-no-instructions',
+        'Lonnqvist2024_online-no-instructions'
+    ])
+    @pytest.mark.parametrize('identifier', [
+        'Lonnqvist2024_test'
+    ])
+    @pytest.mark.parametrize('field', [
+        'stimulus_id',
+        'truth'
+    ])
+    def test_stimulus_set_assembly_alignment(self, assembly, identifier, field):
+        assembly = load_dataset(assembly)
+        assert assembly.stimulus_set is not None
+        assert assembly.stimulus_set.identifier == identifier
+        assert set(assembly.stimulus_set[field]) == set(assembly[field].values)
+
+    # test the number of subjects
+    @pytest.mark.parametrize('identifier, num_subjects', [
+        ('Lonnqvist2024_inlab-instructions', 10),
+        ('Lonnqvist2024_inlab-no-instructions', 10),
+        ('Lonnqvist2024_online-no-instructions', 92),
+    ])
+    def test_num_subjects(self, identifier, num_subjects):
+        assembly = load_dataset(identifier)
+        assert len(np.unique(assembly['subject'].values)) == num_subjects
+
+    # test number of unique images
+    @pytest.mark.parametrize('identifier, num_unique_images', [
+        ('Lonnqvist2024_inlab-instructions', 380),
+        ('Lonnqvist2024_inlab-no-instructions', 380),
+        ('Lonnqvist2024_online-no-instructions', 380),
+    ])
+    def test_num_unique_images(self, identifier, num_unique_images):
+        assembly = load_dataset(identifier)
+        assert len(np.unique(assembly['stimulus_id'].values)) == num_unique_images
+
+    # tests assembly dim for ALL datasets
+    @pytest.mark.parametrize('identifier, length', [
+        ('Lonnqvist2024_inlab-instructions', 3800),
+        ('Lonnqvist2024_inlab-no-instructions', 3800),
+        ('Lonnqvist2024_online-no-instructions', 34960),
+    ])
+    def test_length(self, identifier, length):
+        assembly = load_dataset(identifier)
+        assert len(assembly['presentation']) == length
+
+    # test assembly coords present in ALL 17 sets:
+    @pytest.mark.parametrize('identifier', [
+        'Lonnqvist2024_inlab-instructions',
+        'Lonnqvist2024_inlab-no-instructions',
+        'Lonnqvist2024_online-no-instructions'
+    ])
+    @pytest.mark.parametrize('field', [
+        'subject',
+        'visual_degrees',
+        'image_duration',
+        'is_correct',
+        'subject_answer',
+        'curve_length',
+        'n_cross',
+        'image_path',
+        'stimulus_id',
+        'truth',
+        'image_label'
+    ])
+    def test_fields_present(self, identifier, field):
+        assembly = load_dataset(identifier)
+        assert hasattr(assembly, field)
+
+
+@pytest.mark.private_access
+@pytest.mark.slow
+class TestStimulusSets:
+    # test stimulus_set data:
+    @pytest.mark.parametrize('identifier', [
+        'Lonnqvist2024_train',
+        'Lonnqvist2024_test',
+    ])
+    def test_stimulus_set_exists(self, identifier):
+        stimulus_set = load_stimulus_set(identifier)
+        assert stimulus_set is not None
+        assert stimulus_set.identifier == identifier
+
+    @pytest.mark.parametrize('identifier, num_images', [
+        ('Lonnqvist2024_train', 185),
+        ('Lonnqvist2024_test', 380),
+    ])
+    def test_number_of_images(self, identifier, num_images):
+        stimulus_set = load_stimulus_set(identifier)
+        assert len(np.unique(stimulus_set['stimulus_id'].values)) == num_images
+
+    # test assembly coords present in ALL 17 sets:
+    @pytest.mark.parametrize('identifier', [
+        'Lonnqvist2024_train',
+        'Lonnqvist2024_test',
+    ])
+    @pytest.mark.parametrize('field', [
+        'curve_length',
+        'n_cross',
+        'image_path',
+        'stimulus_id',
+        'truth',
+        'image_label'
+    ])
+    def test_fields_present(self, identifier, field):
+        stimulus_set = load_stimulus_set(identifier)
+        assert hasattr(stimulus_set, field)

brainscore_vision/model_helpers/brain_transformation/__init__.py

@@ -1,3 +1,8 @@
+import json
+from pathlib import Path
+import logging
+from brainscore_vision.utils import fullname
+from brainscore_core.plugin_management import import_plugin
 from brainscore_vision import load_benchmark
 from brainscore_vision.model_helpers.brain_transformation.temporal import TemporalAligned
 from brainscore_vision.model_interface import BrainModel
@@ -22,6 +27,7 @@ class ModelCommitment(BrainModel):
     def __init__(self, identifier,
                  activations_model, layers, behavioral_readout_layer=None, region_layer_map=None,
                  visual_degrees=8):
+        self._logger = logging.getLogger(fullname(self))
         self.layers = layers
         self.activations_model = activations_model
         # We set the visual degrees of the ActivationsExtractorHelper here to avoid changing its signature.
@@ -30,12 +36,18 @@ class ModelCommitment(BrainModel):
         self.activations_model._extractor.set_visual_degrees(visual_degrees)  # for microsaccades
         self._visual_degrees = visual_degrees
         # region-layer mapping
+
+        # Attempt to load region_layer_map from JSON, if available
+        region_layer_map = self.load_region_layer_map_json(identifier) if region_layer_map is None else region_layer_map
+
+        # If region_layer_map is unavailable
         if region_layer_map is None:
             layer_selection = LayerSelection(model_identifier=identifier,
                                              activations_model=activations_model, layers=layers,
                                              visual_degrees=visual_degrees)
             region_layer_map = RegionLayerMap(layer_selection=layer_selection,
                                               region_benchmarks=STANDARD_REGION_BENCHMARKS)
+
         # neural
         layer_model = LayerMappedModel(identifier=identifier, activations_model=activations_model,
                                        region_layer_map=region_layer_map)
@@ -52,6 +64,27 @@ class ModelCommitment(BrainModel):
                                                })
         self.do_behavior = False
 
+    def load_region_layer_map_json(self, identifier):
+        '''
+        Attempts to load the region_layer_map from a JSON file in the model's directory
+        If file exists, load JSON. Otherwise, return None and proceed with legacy layer mapping
+        '''
+        try:
+            importer = import_plugin.ImportPlugin(library_root='brainscore_vision', plugin_type='models', identifier=identifier)
+            model_dir = importer.locate_plugin()
+            project_root = Path(__file__).resolve().parent.parent
+            region_layer_map_path = project_root / 'vision' / 'models' / model_dir / 'region_layer_map' / f'{identifier}.json'
+            if region_layer_map_path.exists():
+                with region_layer_map_path.open('r') as region_layer_map_file:
+                    self._logger.info(f"Successfully loaded region_layer_map for {identifier}")
+                    return json.load(region_layer_map_file)
+            else:
+                self._logger.info(f"No region_layer_map file found for {identifier}, proceeding with default layer mapping")
+                return None
+        except Exception as e:
+            self._logger.error(f"Error importing model to search for region_layer_map: {e}")
+            return None
+
     def visual_degrees(self) -> int:
         return self._visual_degrees
 

brainscore_vision/models/alexnet/region_layer_map/alexnet.json

@@ -0,0 +1 @@
+{"IT": "features.12", "V4": "features.7", "V2": "features.7", "V1": "features.2"}

brainscore_vision/models/alexnet_7be5be79/setup.py

@@ -3,10 +3,10 @@
 
 from setuptools import setup, find_packages
 
-requirements = ["torchvision",
-                "torch",
-                "fire"
-                ]
+requirements = [ "torchvision",
+                 "torch",  
+                 "fire"
+]
 
 setup(
     packages=find_packages(exclude=['tests']),

brainscore_vision/models/alexnet_random/__init__.py

@@ -0,0 +1,7 @@
+from brainscore_vision import model_registry
+from brainscore_vision.model_helpers.brain_transformation import ModelCommitment
+from .model import get_model, get_layers
+
+model_registry['alexnet_random'] = lambda: ModelCommitment(identifier='alexnet_random',
+                                                              activations_model=get_model('alexnet_random'), 
+                                                              layers=get_layers('alexnet_random'))

brainscore_vision/models/alexnet_random/model.py

@@ -0,0 +1,46 @@
+from brainscore_vision.model_helpers.check_submission import check_models
+import functools
+import os
+import torchvision.models
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+from pathlib import Path
+from brainscore_vision.model_helpers import download_weights
+import torch
+
+# This is an example implementation for submitting resnet-50 as a pytorch model
+
+# Attention: It is important, that the wrapper identifier is unique per model!
+# The results will otherwise be the same due to brain-scores internal result caching mechanism.
+# Please load your pytorch model for usage in CPU. There won't be GPUs available for scoring your model.
+# If the model requires a GPU, contact the brain-score team directly.
+from brainscore_vision.model_helpers.check_submission import check_models
+
+
+def get_model_list():
+    return ['alexnet_random']
+
+
+def get_model(name):
+    assert name == 'alexnet_random'
+    model = torchvision.models.alexnet(pretrained=False)
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    wrapper = PytorchWrapper(identifier='alexnet_random',
+                              model=model, 
+                              preprocessing=preprocessing)
+    wrapper.image_size = 224
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'alexnet_random'
+    return ['features.0','features.3', 'features.6', 'features.8', 'features.10', 'classifier.1',
+            'classifier.4', 'classifier.6']
+
+
+def get_bibtex(model_identifier):
+    return """xx"""
+
+
+if __name__ == '__main__':
+    check_models.check_base_models(__name__)