brainscore-vision 2.1__py3-none-any.whl

brainscore_vision/model_helpers/s3.py

@@ -0,0 +1,62 @@
+"""
+Contain functions for loading model contents such as weights from s3.
+"""
+import os
+from pathlib import Path
+from os.path import expanduser
+import logging
+from typing import Tuple, List, Union
+
+from brainio.fetch import BotoFetcher, verify_sha1
+from brainio.lookup import sha1_hash  # so that users can easily import and get the hash of their file(s)
+
+_logger = logging.getLogger(__name__)
+
+
+def load_folder_from_s3(bucket: str, folder_path: str, filename_version_sha: List[Tuple[str, str, str]],
+                        save_directory: Union[Path, str]):
+    for filename, version_id, sha1 in filename_version_sha:
+        load_file_from_s3(bucket=bucket, path=f"{folder_path}/{filename}", version_id=version_id, sha1=sha1,
+                          local_filepath=Path(save_directory) / filename)
+
+
+def load_file_from_s3(bucket: str, path: str, local_filepath: Union[Path, str],
+                      sha1: str, version_id: Union[str, None] = None):
+    """
+    Load a file from AWS S3 and validate its contents.
+    :param bucket: The name of the S3 bucket
+    :param path: The path of the file inside the S3 bucket
+    :param local_filepath: The local path of the file to be saved to
+    :param sha1: The SHA1 hash of the file. If you are not sure of this, use the `sha1_hash` function in this same file
+    :param version_id: Which version of the file on S3 to use.
+        Optional but strongly encouraged to avoid accidental overwrites.
+        If you use Brain-Score functionality to upload files to S3, the version id will be printed to the console.
+        You can also find this on the S3 user interface by opening the file and then clicking on the versions tab.
+    """
+    fetcher = BotoFetcher(location=f"https://{bucket}.s3.amazonaws.com/{path}", version_id=version_id,
+                          # this is a bit hacky: don't tell BotoFetcher the full path because it will make a directory
+                          # where there should be a file
+                          local_filename=Path(local_filepath).parent)
+    fetcher.output_filename = str(local_filepath)  # force using this local path instead of folder structure
+    fetcher.fetch()
+    verify_sha1(local_filepath, sha1)
+
+
+def load_weight_file(bucket: str, relative_path: str, version_id: str, sha1: str, folder_name: str = None) -> Path:
+    """
+    :param bucket: main bucket to add file to. Usually is 'brainscore_vision' for vision model weights.
+    :param relative_path: The path of the file inside the S3 bucket, relative to the `{folder_name}/` directory.
+        The local path will be the same, relative to the local cache's `{folder_name}/` directory (inside `BRAINSCORE_HOME`).
+        Example: `alexnet/weights.pth` will download from brain-score S3:models/alexnet/weights.pth and
+        and store into local ~/.brain-score/models/alexnet/weights.pth.
+    :param version_id: version_id of the object to download, found in AWS under object properties
+    :param sha1: sha1 hash of the object
+    :param folder_name: name of the folder inside the bucket to download from, i.e. 'models'
+    """
+    brainscore_cache = os.getenv("BRAINSCORE_HOME", expanduser("~/.brain-score"))
+    s3_weight_folder = folder_name if folder_name is not None else os.getenv("BRAINSCORE_S3_WEIGHT_FOLDER", "models")
+    local_path = Path(brainscore_cache) / s3_weight_folder / relative_path
+    local_path.parent.mkdir(parents=True, exist_ok=True)
+    load_file_from_s3(bucket=bucket, path=f"{s3_weight_folder}/{relative_path}", version_id=version_id, sha1=sha1,
+                          local_filepath=local_path)
+    return local_path

brainscore_vision/model_helpers/utils/__init__.py

@@ -0,0 +1,15 @@
+import inspect
+
+from result_caching import is_iterable
+
+
+def fullname(obj):
+    module = obj.__module__
+    name = obj.__name__ if inspect.isfunction(obj) else obj.__class__.__name__
+    return module + "." + name
+
+
+def make_list(element):
+    if not is_iterable(element) or isinstance(element, (str, bytes)):
+        return [element]
+    return element

brainscore_vision/model_helpers/utils/s3.py

@@ -0,0 +1,42 @@
+import logging
+import os
+import sys
+
+import boto3
+from botocore import UNSIGNED
+from botocore.config import Config
+from tqdm import tqdm
+
+_logger = logging.getLogger(__name__)
+
+_DEFAULT_BUCKET = 'brain-score-models'
+_DEFAULT_REGION = 'us-east-1'
+_NO_SIGNATURE = Config(signature_version=UNSIGNED)
+
+
+def download_folder(folder_key, target_directory, bucket=_DEFAULT_BUCKET, region=_DEFAULT_REGION):
+    if not folder_key.endswith('/'):
+        folder_key = folder_key + '/'
+    s3 = boto3.resource('s3', region_name=region, config=_NO_SIGNATURE)
+    bucket = s3.Bucket(bucket)
+    bucket_contents = list(bucket.objects.all())
+    files = [obj.key for obj in bucket_contents if obj.key.startswith(folder_key)]
+    _logger.debug(f"Found {len(files)} files")
+    for file in tqdm(files):
+        # get part of file after given folder_key
+        filename = file[len(folder_key):]
+        target_path = os.path.join(target_directory, filename)
+        temp_path = target_path + '.filepart'
+        bucket.download_file(file, temp_path)
+        os.rename(temp_path, target_path)
+
+
+def download_file(key, target_path, bucket=_DEFAULT_BUCKET, region=_DEFAULT_REGION):
+    s3 = boto3.resource('s3', region_name=region, config=_NO_SIGNATURE)
+    obj = s3.Object(bucket, key)
+    # show progress. see https://gist.github.com/wy193777/e7607d12fad13459e8992d4f69b53586
+    with tqdm(total=obj.content_length, unit='B', unit_scale=True, desc=key, file=sys.stdout) as progress_bar:
+        def progress_hook(bytes_amount):
+            progress_bar.update(bytes_amount)
+
+        obj.download_file(target_path, Callback=progress_hook)

brainscore_vision/model_interface.py

@@ -0,0 +1,214 @@
+"""
+The :class:`~brainscore_vision.model_interface.BrainModel` interface is the central communication point
+between benchmarks and models.
+"""
+
+from typing import List, Tuple, Union
+
+from brainio.assemblies import BehavioralAssembly, NeuroidAssembly
+from brainio.stimuli import StimulusSet
+
+
+class BrainModel:
+    """
+    The BrainModel interface defines an API for models to follow.
+    Benchmarks will use this interface to treat models as an experimental subject
+    without needing to know about the details of the model implementation.
+    """
+
+    @property
+    def identifier(self) -> str:
+        """
+        The unique identifier for this model.
+
+        :return: e.g. `'CORnet-S'`, or `'alexnet'`
+        """
+        raise NotImplementedError()
+
+    def visual_degrees(self) -> int:
+        """
+        The visual degrees this model covers as a single scalar.
+
+        :return: e.g. `8`, or `10`
+        """
+        raise NotImplementedError()
+
+    class Task:
+        """ task to perform """
+
+        passive = 'passive'
+        """
+        Passive fixation, i.e. do not perform any task, but fixate on the center of the screen.
+        Does not output anything, but can be useful to fully specify the experimental setup.
+
+        Example:
+
+        Setting up passive fixation with `start_task(BrainModel.Task.passive)` and calling `look_at(...)` could output
+
+        .. code-block:: python
+
+           None
+        """
+
+        label = 'label'
+        """ 
+        Predict the label for each stimulus. 
+        Output a :class:`~brainio.assemblies.BehavioralAssembly` with labels as the values.
+
+        The labeling domain can be specified in the second argument, e.g. `'imagenet'` for 1,000 ImageNet synsets, 
+        or an explicit list of label strings. The model choices must be part of the labeling domain.
+
+        Example:
+
+        Setting up a labeling task for ImageNet synsets with `start_task(BrainModel.Task.label, 'imagenet')` 
+        and calling `look_at(...)` could output 
+
+        .. code-block:: python
+
+           <xarray.BehavioralAssembly (presentation: 3, choice: 1)>
+                array([['n02107574'], ['n02123045'], ['n02804414']]), # the ImageNet synsets
+                Coordinates:
+                  * presentation  (presentation) MultiIndex
+                  - stimulus_id   (presentation) object 'hash1' 'hash2' 'hash3'
+                  - stimulus_path (presentation) object '/home/me/.brainio/demo_stimuli/image1.png' ...
+                  - logit         (presentation) int64 239 282 432
+                  - synset        (presentation) object 'n02107574' 'n02123045' 'n02804414'
+
+        Example:
+
+        Setting up a labeling task for 2 custom labels with `start_task(BrainModel.Task.label, ['dog', 'cat'])` 
+        and calling `look_at(...)` could output 
+
+        .. code-block:: python
+
+           <xarray.BehavioralAssembly (presentation: 3, choice: 1)>
+                array([['dog'], ['cat'], ['cat']]), # the labels
+                Coordinates:
+                  * presentation  (presentation) MultiIndex
+                  - stimulus_id   (presentation) object 'hash1' 'hash2' 'hash3'
+                  - stimulus_path (presentation) object '/home/me/.brainio/demo_stimuli/image1.png' ...
+        """
+
+        probabilities = 'probabilities'
+        """ 
+        Predict the per-label probabilities for each stimulus. 
+        Output a :class:`~brainio.assemblies.BehavioralAssembly` with probabilities as the values.
+
+        The model must be supplied with `fitting_stimuli` in the second argument which allow it to train a readout 
+        for a particular set of labels and image distribution. 
+        The `fitting_stimuli` are a :class:`~brainio.stimuli.StimulusSet` and must include an `image_label` column 
+        which is used as the labels to fit to.
+
+        Example:
+
+        Setting up a probabilities task `start_task(BrainModel.Task.probabilities, <fitting_stimuli>)` 
+        (where `fitting_stimuli` includes 5 distinct labels)
+        and calling `look_at(<test_stimuli>)` could output 
+
+        .. code-block:: python
+
+           <xarray.BehavioralAssembly (presentation: 3, choice: 5)>
+                array([[0.9 0.1 0.0 0.0 0.0]
+                       [0.0 0.0 0.8 0.0 0.2]
+                       [0.0 0.0 0.0 1.0 0.0]]), # the probabilities
+                Coordinates:
+                  * presentation  (presentation) MultiIndex
+                  - stimulus_id   (presentation) object 'hash1' 'hash2' 'hash3'
+                  - stimulus_path (presentation) object '/home/me/.brainio/demo_stimuli/image1.png' ...
+                  - choice        (choice) object 'dog' 'cat' 'chair' 'flower' 'plane'
+        """
+
+        odd_one_out = 'odd_one_out'
+        """
+        Predict the odd-one-out elements for a list of triplets of stimuli. 
+
+        The model must be supplied with a list of stimuli where every three consecutive stimuli 
+        are considered to form a triplet. The model is expected to output a one-dimensional 
+        assembly with each value corresponding to the index (`0`, `1`, or `2`) of the triplet 
+        element that is different from the other two.
+        
+        Output a :class:`~brainio.assemblies.BehavioralAssembly` with the choices as the values.
+        
+        Example:
+
+        Setting up an odd-one-out task for a list of triplets with `start_task(BrainModel.Task.odd_one_out)` and calling
+
+        .. code-block:: python
+        
+            look_at(['image1.png', 'image2.png', 'image3.png',    #triplet 1 
+                     'image1.png', 'image2.png', 'image4.png',    #triplet 2 
+                     'image2.png', 'image3.png', 'image4.png',    #triplet 3
+                     ...
+                     'image4.png', 'image8.png', 'image10.png'])  #triplet 50 
+
+        with 50 triplet trials and 10 unique stimuli could output 
+
+        .. code-block:: python
+
+           <xarray.BehavioralAssembly (presentation: 50, choice: 1)>
+                array([[0], [2], [2], ..., [1]])  #  index of the odd-one-out per trial, i.e. 0, 1, or 2. (Each trial is one triplet of images.)
+                Coordinates:
+                  * presentation  (presentation) MultiIndex
+                  - stimulus_id   (presentation) ['image1', 'image2', 'image3'], ..., , ['image4', 'image8', 'image10']
+                  - stimulus_path (presentation) object '/home/me/.brainio/demo_stimuli/image1.png' ...
+        """
+
+    def start_task(self, task: Task, fitting_stimuli) -> None:
+        """
+        Instructs the model to begin one of the tasks specified in
+        :data:`~brainscore_vision.model_interface.BrainModel.Task`.
+        For all followings call of :meth:`~brainscore_vision.model_interface.BrainModel.look_at`,
+        the model returns the expected outputs for the specified task.
+
+        :param task: The task the model should perform, and thus which outputs it should return
+        :param fitting_stimuli: A set of stimuli for the model to learn on, e.g. image-label pairs
+        """
+        raise NotImplementedError()
+
+    class RecordingTarget:
+        """ location to record from """
+        V1 = 'V1'
+        V2 = 'V2'
+        V4 = 'V4'
+        IT = 'IT'
+
+    def start_recording(self, recording_target: RecordingTarget, time_bins: List[Tuple[int, int]]) -> None:
+        """
+        Instructs the model to begin recording in a specified
+        :data:`~brainscore_vision.model_interface.BrainModel.RecordingTarget` and return the specified `time_bins`.
+        For all followings call of :meth:`~brainscore_vision.model_interface.BrainModel.look_at`, the model returns the
+        corresponding recordings. These recordings are a :class:`~brainio.assemblies.NeuroidAssembly` with exactly
+        3 dimensions:
+
+        - `presentation`: the presented stimuli (cf. stimuli argument of
+          :meth:`~brainscore_vision.model_interface.BrainModel.look_at`). If a :class:`~brainio.stimuli.StimulusSet`
+          was passed, the recordings should contain all of the :class:`~brainio.stimuli.StimulusSet` columns as
+          coordinates on this dimension. The `stimulus_id` coordinate is required in either case.
+        - `neuroid`: the recorded neuroids (neurons or mixtures thereof). They should all be part of the
+          specified :data:`~brainscore_vision.model_interface.BrainModel.RecordingTarget`. The coordinates of this
+          dimension should again include as much information as is available, at the very least a `neuroid_id`.
+        - `time_bins`: the time bins of each recording slice. This dimension should contain at least 2 coordinates:
+          `time_bin_start` and `time_bin_end`, where one `time_bin` is the bin between start and end.
+          For instance, a 70-170ms time_bin would be marked as `time_bin_start=70` and `time_bin_end=170`.
+          If only one time_bin is requested, the model may choose to omit this dimension.
+
+        :param recording_target: which location to record from
+        :param time_bins: which time_bins to record as a list of integer tuples,
+            e.g. `[(50, 100), (100, 150), (150, 200)]` or `[(70, 170)]`
+        """
+        raise NotImplementedError()
+
+    def look_at(self, stimuli: Union[StimulusSet, List[str]], number_of_trials=1) \
+            -> Union[BehavioralAssembly, NeuroidAssembly]:
+        """
+        Digest a set of stimuli and return requested outputs. Which outputs to return is instructed by the
+        :meth:`~brainscore_vision.model_interface.BrainMode.start_task` and
+        :meth:`~brainscore_vision.model_interface.BrainModel.start_recording` methods.
+
+        :param stimuli: A set of stimuli, passed as either a :class:`~brainio.stimuli.StimulusSet`
+            or a list of image file paths
+        :param number_of_trials: The number of repeated trials of the stimuli that the model should average over.
+            E.g. 10 or 35. Non-stochastic models can likely ignore this parameter.
+        :return: task behaviors or recordings as instructed
+        """
+        raise NotImplementedError()

brainscore_vision/models/AdvProp_efficientne_b6/__init__.py

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

brainscore_vision/models/AdvProp_efficientne_b6/model.py

@@ -0,0 +1,75 @@
+import functools
+
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.check_submission import check_models
+from efficientnet_pytorch import EfficientNet
+
+"""
+Template module for a base model submission to brain-score
+"""
+
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
+
+def get_model(name):
+    """
+    This method fetches an instance of a base model. The instance has to be callable and return a xarray object,
+    containing activations. There exist standard wrapper implementations for common libraries, like pytorch and
+    keras. Checkout the examples folder, to see more. For custom implementations check out the implementation of the
+    wrappers.
+    :param name: the name of the model to fetch
+    :return: the model instance
+    """
+    model = name
+    AT = False
+    if 'AdvProp_' in name:
+        AT = True
+        model = model.split('AdvProp_')[-1]
+
+    model = EfficientNet.from_pretrained(model, advprop=AT)
+    model.set_swish(memory_efficient=False)
+
+    if AT:
+        preprocessing = functools.partial(load_preprocess_images, image_size=224, normalize_mean=(0.5, 0.5, 0.5), normalize_std=(0.5, 0.5, 0.5))
+    else:
+        preprocessing = functools.partial(load_preprocess_images, image_size=224)
+
+    wrapper = PytorchWrapper(identifier=name, model=model, preprocessing=preprocessing)
+    from types import MethodType
+    def _output_layer(self):
+        return self._model._fc
+
+    wrapper._output_layer = MethodType(_output_layer, wrapper)
+    wrapper.image_size = 224
+    return wrapper
+
+def get_layers(name):
+    """
+    This method returns a list of string layer names to consider per model. The benchmarks maps brain regions to
+    layers and uses this list as a set of possible layers. The lists doesn't have to contain all layers, the less the
+    faster the benchmark process works. Additionally the given layers have to produce an activations vector of at least
+    size 25! The layer names are delivered back to the model instance and have to be resolved in there. For a pytorch
+    model, the layer name are for instance dot concatenated per module, e.g. "features.2".
+    :param name: the name of the model, to return the layers for
+    :return: a list of strings containing all layers, that should be considered as brain area.
+    """
+    lmap = {
+        'efficientnet-b6' : [f'_blocks.{i}' for i in range(45)]
+    }
+    name = name.split('AdvProp_')[-1]
+    assert name in lmap
+    return lmap[name]
+
+
+def get_bibtex(model_identifier):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return ''
+
+
+if __name__ == '__main__':
+    # Use this method to ensure the correctness of the BaseModel implementations.
+    # It executes a mock run of brain-score benchmarks.
+    check_models.check_base_models(__name__)

brainscore_vision/models/AdvProp_efficientne_b6/requirements.txt

@@ -0,0 +1 @@
+efficientnet_pytorch

brainscore_vision/models/AdvProp_efficientne_b6/test.py

@@ -0,0 +1,9 @@
+# Left empty as part of 2023 models migration
+
+import pytest
+import brainscore_vision
+
+@pytest.mark.travis_slow
+def test_has_identifier():
+    model = brainscore_vision.load_model('AdvProp_efficientnet-b6')
+    assert model.identifier == 'AdvProp_efficientnet-b6'

brainscore_vision/models/AlexNet_SIN/__init__.py

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

brainscore_vision/models/AlexNet_SIN/model.py

@@ -0,0 +1,29 @@
+import functools
+
+import torchvision.models
+import torch 
+
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+
+BIBTEX = """@article{geirhos2018imagenet,
+  title={ImageNet-trained CNNs are biased towards texture; increasing shape bias improves accuracy and robustness},
+  author={Geirhos, Robert and Rubisch, Patricia and Michaelis, Claudio and Bethge, Matthias and Wichmann, Felix A and Brendel, Wieland},
+  journal={arXiv preprint arXiv:1811.12231},
+  year={2018}
+}"""
+
+LAYERS = ['features.module.2', 'features.module.5', 'features.module.7', 'features.module.9', 'features.module.12',
+          'classifier.2', 'classifier.5']
+
+model_url =  'https://bitbucket.org/robert_geirhos/texture-vs-shape-pretrained-models/raw/0008049cd10f74a944c6d5e90d4639927f8620ae/alexnet_train_60_epochs_lr0.001-b4aa5238.pth.tar'
+
+def get_model():
+    model = torchvision.models.alexnet(pretrained=False)
+    model.features = torch.nn.DataParallel(model.features)
+    checkpoint = torch.utils.model_zoo.load_url(model_url, map_location="cpu")
+    model.load_state_dict(checkpoint["state_dict"])
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    wrapper = PytorchWrapper(identifier='AlexNet_SIN', model=model, preprocessing=preprocessing)
+    wrapper.image_size = 224
+    return wrapper

brainscore_vision/models/AlexNet_SIN/requirements.txt

@@ -0,0 +1,2 @@
+torch
+torchvision

brainscore_vision/models/AlexNet_SIN/test.py

@@ -0,0 +1 @@
+# Left empty as part of 2023 models migration

brainscore_vision/models/Soumyadeep_inf_1/__init__.py

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

brainscore_vision/models/Soumyadeep_inf_1/model.py

@@ -0,0 +1,60 @@
+from brainscore_vision.model_helpers.check_submission import check_models
+import functools
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+import torch
+import numpy as np
+from brainscore_vision.model_helpers.brain_transformation import ModelCommitment
+import torchvision.models as models
+import gdown
+
+# This is an example implementation for submitting custom model named my_custom_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.
+
+
+def get_model_list():
+    return ['Soumyadeep_inf_1']
+
+
+def get_model(name):
+    trained_model = models.__dict__['resnet50']()
+    trained_model = torch.nn.DataParallel(trained_model)
+
+    #url = "https://drive.google.com/uc?id=1kNgOmtSrCQnyINVGw_l9vishwaNeqGN4"  
+    # fast_2px_step2_eps2_repeat1_trial1_model_best.pth.tar
+
+    url = "https://drive.google.com/uc?id=1uSpR1uVQkyW6wUY9DM6XbXNbhdW89cOc"
+    output = "Soumyadeep_inf_1.pth.tar"
+    gdown.download(url, output)
+
+    checkpoint = torch.load("Soumyadeep_inf_1.pth.tar", map_location=torch.device('cpu'))
+    trained_model.load_state_dict(checkpoint['state_dict'])
+
+    trained_model = trained_model.module
+
+    assert name == 'Soumyadeep_inf_1'
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    # Wrap the model in PytorchWrapper directly
+    activations_model = PytorchWrapper(identifier='Soumyadeep_inf_1', model=trained_model, preprocessing=preprocessing)
+    return activations_model
+
+
+def get_layers(name):
+    assert name == 'Soumyadeep_inf_1'
+    return ['layer1.0.conv3', 'layer1.1.conv3', 'layer1.2.conv3', 
+            'layer2.0.conv3', 'layer2.1.conv3', 'layer2.2.conv3', 'layer2.3.conv3',
+            'layer3.0.conv3', 'layer3.1.conv3', 'layer3.2.conv3', 'layer3.3.conv3', 'layer3.4.conv3', 'layer3.5.conv3',
+            'layer4.0.conv3', 'layer4.1.conv3', 'layer4.2.conv3']
+
+
+def get_bibtex(model_identifier):
+    return """xx"""
+
+
+if __name__ == '__main__':
+    check_models.check_base_models(__name__)
+

brainscore_vision/models/Soumyadeep_inf_1/setup.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from setuptools import setup, find_packages
+
+requirements = [ "torchvision",
+                 "torch",
+		 "gdown"
+]
+
+setup(
+    packages=find_packages(exclude=['tests']),
+    include_package_data=True,
+    install_requires=requirements,
+    license="MIT license",
+    zip_safe=False,
+    keywords='brain-score template',
+    classifiers=[
+        'Development Status :: 2 - Pre-Alpha',
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: MIT License',
+        'Natural Language :: English',
+        'Programming Language :: Python :: 3.7',
+    ],
+    test_suite='tests',
+)

brainscore_vision/models/Soumyadeep_inf_1/test.py

@@ -0,0 +1 @@
+# Left empty as part of 2023 models migration

brainscore_vision/models/ViT_L_32_imagenet1k/__init__.py

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

brainscore_vision/models/ViT_L_32_imagenet1k/model.py

@@ -0,0 +1,43 @@
+import functools
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+from brainscore_vision.model_helpers.check_submission import check_models
+from pytorch_pretrained_vit import ViT
+import ssl
+
+
+ssl._create_default_https_context = ssl._create_unverified_context
+
+
+# Visual Transformer (ViT)
+# Using PyTorch implementation and converted weights from https://github.com/lukemelas/PyTorch-Pretrained-ViT
+
+def get_model(name):
+    assert name == 'ViT_L_32_imagenet1k'
+    model = ViT(name[4:], pretrained=True)
+    preprocessing = functools.partial(load_preprocess_images, image_size=model.image_size[0])
+    wrapper = PytorchWrapper(identifier=name, model=model, preprocessing=preprocessing)
+    wrapper.image_size = model.image_size[0]
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'ViT_L_32_imagenet1k'
+    name = name[4:]
+    number_of_blocks = 12 if name.startswith('B') else 24
+    return [f'transformer.blocks.{i}.pwff.fc2' for i in range(number_of_blocks)]
+
+
+def get_bibtex(model_identifier):
+    return """@inproceedings{
+                dosovitskiy2021an,
+                title={An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale},
+                author={Alexey Dosovitskiy and Lucas Beyer and Alexander Kolesnikov and Dirk Weissenborn and Xiaohua Zhai and Thomas Unterthiner and Mostafa Dehghani and Matthias Minderer and Georg Heigold and Sylvain Gelly and Jakob Uszkoreit and Neil Houlsby},
+                booktitle={International Conference on Learning Representations},
+                year={2021},
+                url={https://openreview.net/forum?id=YicbFdNTTy}
+                }"""
+
+
+if __name__ == '__main__':
+    check_models.check_base_models(__name__)

brainscore_vision/models/ViT_L_32_imagenet1k/requirements.txt

@@ -0,0 +1,4 @@
+numpy
+torch
+torchvision
+pytorch_pretrained_vit

brainscore_vision/models/ViT_L_32_imagenet1k/test.py

@@ -0,0 +1,8 @@
+import pytest
+import brainscore_vision
+
+
+@pytest.mark.travis_slow
+def test_has_identifier():
+    model = brainscore_vision.load_model('ViT_L_32_imagenet1k')
+    assert model.identifier == 'ViT_L_32_imagenet1k'

brainscore_vision/models/alexnet/__init__.py

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