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

brainscore_vision/models/mvimgnet_ss_05/model.py

@@ -0,0 +1,64 @@
+from brainscore_vision.model_helpers.check_submission import check_models
+import functools
+import os
+from urllib.request import urlretrieve
+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
+from collections import OrderedDict
+
+# 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 ["mvimgnet_ss_05"]
+
+
+def get_model(name):
+    assert name == "mvimgnet_ss_05"
+    url = "https://users.flatironinstitute.org/~tyerxa/slow_steady/training_checkpoints/slow_steady/r2/LARS/lmda_0.5/latest-rank0.pt"
+    fh = urlretrieve(url)
+    state_dict = torch.load(fh[0], map_location=torch.device("cpu"))["state"]["model"]
+    model = load_composer_classifier(state_dict)
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    wrapper = PytorchWrapper(identifier=name, model=model, preprocessing=preprocessing)
+    wrapper.image_size = 224
+    return wrapper
+
+def load_composer_classifier(sd):
+    model = torchvision.models.resnet.resnet50()
+    new_sd = OrderedDict()
+    for k, v in sd.items():
+        if 'lin_cls' in k:
+            new_sd['fc.' + k.split('.')[-1]] = v
+        if ".f." not in k:
+            continue
+        parts = k.split(".")
+        idx = parts.index("f")
+        new_k = ".".join(parts[idx + 1 :])
+        new_sd[new_k] = v
+    model.load_state_dict(new_sd, strict=True)
+    return model
+
+def get_layers(name):
+    assert name == "mvimgnet_ss_05"
+
+    outs = ["layer1", "layer2", "layer3", "layer4"]
+    return outs
+
+
+def get_bibtex(model_identifier):
+    return """xx"""
+
+
+if __name__ == "__main__":
+    check_models.check_base_models(__name__)

brainscore_vision/models/mvimgnet_ss_05/setup.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from setuptools import setup, find_packages
+
+requirements = [ "torchvision",
+                 "torch"
+]
+
+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/mvimgnet_ss_05/test.py

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

brainscore_vision/models/resnet50_tutorial/region_layer_map/resnet50_tutorial.json

@@ -0,0 +1 @@
+{"IT": "layer3", "V2": "layer2", "V1": "layer2", "V4": "layer2"}

brainscore_vision/models/sam_test_resnet/__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['sam_test_resnet'] = lambda: ModelCommitment(identifier='sam_test_resnet', activations_model=get_model('sam_test_resnet'), layers=get_layers('sam_test_resnet'))

brainscore_vision/models/sam_test_resnet/model.py

@@ -0,0 +1,26 @@
+from brainscore_vision.model_helpers.check_submission import check_models
+import functools
+import torchvision.models
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+
+def get_model(name):
+    assert name == 'sam_test_resnet'
+    model = torchvision.models.resnet50(pretrained=True)
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    wrapper = PytorchWrapper(identifier='sam_test_resnet', model=model, preprocessing=preprocessing)
+    wrapper.image_size = 224
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'sam_test_resnet'
+    return ['conv1','layer1', 'layer2', 'layer3', 'layer4', 'fc']
+
+
+def get_bibtex(model_identifier):
+    return """"""
+
+
+if __name__ == '__main__':
+    check_models.check_base_models(__name__)

brainscore_vision/models/sam_test_resnet/requirements.txt

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

brainscore_vision/models/sam_test_resnet/test.py

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

brainscore_vision/models/sam_test_resnet_4/__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['sam_test_resnet_4'] = lambda: ModelCommitment(identifier='sam_test_resnet_4', activations_model=get_model('sam_test_resnet_4'), layers=get_layers('sam_test_resnet_4'))

brainscore_vision/models/sam_test_resnet_4/model.py

@@ -0,0 +1,26 @@
+from brainscore_vision.model_helpers.check_submission import check_models
+import functools
+import torchvision.models
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+
+def get_model(name):
+    assert name == 'sam_test_resnet_4'
+    model = torchvision.models.resnet50(pretrained=True)
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    wrapper = PytorchWrapper(identifier='sam_test_resnet', model=model, preprocessing=preprocessing)
+    wrapper.image_size = 224
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'sam_test_resnet_4'
+    return ['conv1','layer1', 'layer2', 'layer3', 'layer4', 'fc']
+
+
+def get_bibtex(model_identifier):
+    return """"""
+
+
+if __name__ == '__main__':
+    check_models.check_base_models(__name__)

brainscore_vision/models/sam_test_resnet_4/requirements.txt

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

brainscore_vision/models/sam_test_resnet_4/test.py

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

brainscore_vision/models/scaling_models/__init__.py

@@ -0,0 +1,265 @@
+from brainscore_vision import model_registry
+from brainscore_vision.model_helpers.brain_transformation import ModelCommitment
+from .model import get_model, MODEL_CONFIGS
+
+model_registry["resnet18_imagenet_full"] = lambda: ModelCommitment(
+    identifier="resnet18_imagenet_full",
+    activations_model=get_model("resnet18_imagenet_full"),
+    layers=MODEL_CONFIGS["resnet18_imagenet_full"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["resnet18_imagenet_full"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["resnet18_imagenet_full"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["resnet34_imagenet_full"] = lambda: ModelCommitment(
+    identifier="resnet34_imagenet_full",
+    activations_model=get_model("resnet34_imagenet_full"),
+    layers=MODEL_CONFIGS["resnet34_imagenet_full"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["resnet34_imagenet_full"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["resnet34_imagenet_full"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["resnet50_imagenet_full"] = lambda: ModelCommitment(
+    identifier="resnet50_imagenet_full",
+    activations_model=get_model("resnet50_imagenet_full"),
+    layers=MODEL_CONFIGS["resnet50_imagenet_full"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["resnet50_imagenet_full"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["resnet50_imagenet_full"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["resnet101_imagenet_full"] = lambda: ModelCommitment(
+    identifier="resnet101_imagenet_full",
+    activations_model=get_model("resnet101_imagenet_full"),
+    layers=MODEL_CONFIGS["resnet101_imagenet_full"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["resnet101_imagenet_full"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["resnet101_imagenet_full"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["resnet152_imagenet_full"] = lambda: ModelCommitment(
+    identifier="resnet152_imagenet_full",
+    activations_model=get_model("resnet152_imagenet_full"),
+    layers=MODEL_CONFIGS["resnet152_imagenet_full"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["resnet152_imagenet_full"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["resnet152_imagenet_full"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["resnet18_ecoset_full"] = lambda: ModelCommitment(
+    identifier="resnet18_ecoset_full",
+    activations_model=get_model("resnet18_ecoset_full"),
+    layers=MODEL_CONFIGS["resnet18_ecoset_full"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["resnet18_ecoset_full"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["resnet18_ecoset_full"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["resnet34_ecoset_full"] = lambda: ModelCommitment(
+    identifier="resnet34_ecoset_full",
+    activations_model=get_model("resnet34_ecoset_full"),
+    layers=MODEL_CONFIGS["resnet34_ecoset_full"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["resnet34_ecoset_full"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["resnet34_ecoset_full"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["resnet50_ecoset_full"] = lambda: ModelCommitment(
+    identifier="resnet50_ecoset_full",
+    activations_model=get_model("resnet50_ecoset_full"),
+    layers=MODEL_CONFIGS["resnet50_ecoset_full"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["resnet50_ecoset_full"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["resnet50_ecoset_full"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["resnet101_ecoset_full"] = lambda: ModelCommitment(
+    identifier="resnet101_ecoset_full",
+    activations_model=get_model("resnet101_ecoset_full"),
+    layers=MODEL_CONFIGS["resnet101_ecoset_full"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["resnet101_ecoset_full"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["resnet101_ecoset_full"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["resnet152_ecoset_full"] = lambda: ModelCommitment(
+    identifier="resnet152_ecoset_full",
+    activations_model=get_model("resnet152_ecoset_full"),
+    layers=MODEL_CONFIGS["resnet152_ecoset_full"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["resnet152_ecoset_full"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["resnet152_ecoset_full"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["resnet50_imagenet_1_seed-0"] = lambda: ModelCommitment(
+    identifier="resnet50_imagenet_1_seed-0",
+    activations_model=get_model("resnet50_imagenet_1_seed-0"),
+    layers=MODEL_CONFIGS["resnet50_imagenet_1_seed-0"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["resnet50_imagenet_1_seed-0"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["resnet50_imagenet_1_seed-0"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["resnet50_imagenet_10_seed-0"] = lambda: ModelCommitment(
+    identifier="resnet50_imagenet_10_seed-0",
+    activations_model=get_model("resnet50_imagenet_10_seed-0"),
+    layers=MODEL_CONFIGS["resnet50_imagenet_10_seed-0"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["resnet50_imagenet_10_seed-0"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["resnet50_imagenet_10_seed-0"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["resnet50_imagenet_100_seed-0"] = lambda: ModelCommitment(
+    identifier="resnet50_imagenet_100_seed-0",
+    activations_model=get_model("resnet50_imagenet_100_seed-0"),
+    layers=MODEL_CONFIGS["resnet50_imagenet_100_seed-0"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["resnet50_imagenet_100_seed-0"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["resnet50_imagenet_100_seed-0"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["efficientnet_b0_imagenet_full"] = lambda: ModelCommitment(
+    identifier="efficientnet_b0_imagenet_full",
+    activations_model=get_model("efficientnet_b0_imagenet_full"),
+    layers=MODEL_CONFIGS["efficientnet_b0_imagenet_full"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["efficientnet_b0_imagenet_full"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["efficientnet_b0_imagenet_full"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["efficientnet_b1_imagenet_full"] = lambda: ModelCommitment(
+    identifier="efficientnet_b1_imagenet_full",
+    activations_model=get_model("efficientnet_b1_imagenet_full"),
+    layers=MODEL_CONFIGS["efficientnet_b1_imagenet_full"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["efficientnet_b1_imagenet_full"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["efficientnet_b1_imagenet_full"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["efficientnet_b2_imagenet_full"] = lambda: ModelCommitment(
+    identifier="efficientnet_b2_imagenet_full",
+    activations_model=get_model("efficientnet_b2_imagenet_full"),
+    layers=MODEL_CONFIGS["efficientnet_b2_imagenet_full"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["efficientnet_b2_imagenet_full"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["efficientnet_b2_imagenet_full"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["deit_small_imagenet_full_seed-0"] = lambda: ModelCommitment(
+    identifier="deit_small_imagenet_full_seed-0",
+    activations_model=get_model("deit_small_imagenet_full_seed-0"),
+    layers=MODEL_CONFIGS["deit_small_imagenet_full_seed-0"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["deit_small_imagenet_full_seed-0"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["deit_small_imagenet_full_seed-0"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["deit_base_imagenet_full_seed-0"] = lambda: ModelCommitment(
+    identifier="deit_base_imagenet_full_seed-0",
+    activations_model=get_model("deit_base_imagenet_full_seed-0"),
+    layers=MODEL_CONFIGS["deit_base_imagenet_full_seed-0"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["deit_base_imagenet_full_seed-0"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["deit_base_imagenet_full_seed-0"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["deit_large_imagenet_full_seed-0"] = lambda: ModelCommitment(
+    identifier="deit_large_imagenet_full_seed-0",
+    activations_model=get_model("deit_large_imagenet_full_seed-0"),
+    layers=MODEL_CONFIGS["deit_large_imagenet_full_seed-0"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["deit_large_imagenet_full_seed-0"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["deit_large_imagenet_full_seed-0"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["deit_small_imagenet_1_seed-0"] = lambda: ModelCommitment(
+    identifier="deit_small_imagenet_1_seed-0",
+    activations_model=get_model("deit_small_imagenet_1_seed-0"),
+    layers=MODEL_CONFIGS["deit_small_imagenet_1_seed-0"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["deit_small_imagenet_1_seed-0"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["deit_small_imagenet_1_seed-0"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["deit_small_imagenet_10_seed-0"] = lambda: ModelCommitment(
+    identifier="deit_small_imagenet_10_seed-0",
+    activations_model=get_model("deit_small_imagenet_10_seed-0"),
+    layers=MODEL_CONFIGS["deit_small_imagenet_10_seed-0"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["deit_small_imagenet_10_seed-0"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["deit_small_imagenet_10_seed-0"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["deit_small_imagenet_100_seed-0"] = lambda: ModelCommitment(
+    identifier="deit_small_imagenet_100_seed-0",
+    activations_model=get_model("deit_small_imagenet_100_seed-0"),
+    layers=MODEL_CONFIGS["deit_small_imagenet_100_seed-0"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["deit_small_imagenet_100_seed-0"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["deit_small_imagenet_100_seed-0"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["convnext_tiny_imagenet_full_seed-0"] = lambda: ModelCommitment(
+    identifier="convnext_tiny_imagenet_full_seed-0",
+    activations_model=get_model("convnext_tiny_imagenet_full_seed-0"),
+    layers=MODEL_CONFIGS["convnext_tiny_imagenet_full_seed-0"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["convnext_tiny_imagenet_full_seed-0"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["convnext_tiny_imagenet_full_seed-0"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["convnext_small_imagenet_full_seed-0"] = lambda: ModelCommitment(
+    identifier="convnext_small_imagenet_full_seed-0",
+    activations_model=get_model("convnext_small_imagenet_full_seed-0"),
+    layers=MODEL_CONFIGS["convnext_small_imagenet_full_seed-0"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["convnext_small_imagenet_full_seed-0"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["convnext_small_imagenet_full_seed-0"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["convnext_base_imagenet_full_seed-0"] = lambda: ModelCommitment(
+    identifier="convnext_base_imagenet_full_seed-0",
+    activations_model=get_model("convnext_base_imagenet_full_seed-0"),
+    layers=MODEL_CONFIGS["convnext_base_imagenet_full_seed-0"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["convnext_base_imagenet_full_seed-0"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["convnext_base_imagenet_full_seed-0"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["convnext_large_imagenet_full_seed-0"] = lambda: ModelCommitment(
+    identifier="convnext_large_imagenet_full_seed-0",
+    activations_model=get_model("convnext_large_imagenet_full_seed-0"),
+    layers=MODEL_CONFIGS["convnext_large_imagenet_full_seed-0"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["convnext_large_imagenet_full_seed-0"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["convnext_large_imagenet_full_seed-0"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["convnext_small_imagenet_1_seed-0"] = lambda: ModelCommitment(
+    identifier="convnext_small_imagenet_1_seed-0",
+    activations_model=get_model("convnext_small_imagenet_1_seed-0"),
+    layers=MODEL_CONFIGS["convnext_small_imagenet_1_seed-0"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["convnext_small_imagenet_1_seed-0"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["convnext_small_imagenet_1_seed-0"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["convnext_small_imagenet_10_seed-0"] = lambda: ModelCommitment(
+    identifier="convnext_small_imagenet_10_seed-0",
+    activations_model=get_model("convnext_small_imagenet_10_seed-0"),
+    layers=MODEL_CONFIGS["convnext_small_imagenet_10_seed-0"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["convnext_small_imagenet_10_seed-0"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["convnext_small_imagenet_10_seed-0"]["model_commitment"]["region_layer_map"]
+)
+
+
+model_registry["convnext_small_imagenet_100_seed-0"] = lambda: ModelCommitment(
+    identifier="convnext_small_imagenet_100_seed-0",
+    activations_model=get_model("convnext_small_imagenet_100_seed-0"),
+    layers=MODEL_CONFIGS["convnext_small_imagenet_100_seed-0"]["model_commitment"]["layers"],
+    behavioral_readout_layer=MODEL_CONFIGS["convnext_small_imagenet_100_seed-0"]["model_commitment"]["behavioral_readout_layer"],
+    region_layer_map=MODEL_CONFIGS["convnext_small_imagenet_100_seed-0"]["model_commitment"]["region_layer_map"]
+)
+
+

brainscore_vision/models/scaling_models/model.py

@@ -0,0 +1,148 @@
+import os
+import functools
+import json
+from pathlib import Path
+import ssl
+
+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
+
+import timm
+import numpy as np
+import torchvision.transforms as T
+from PIL import Image
+
+import albumentations as A
+from albumentations.pytorch import ToTensorV2
+
+# Disable SSL verification 
+ssl._create_default_https_context = ssl._create_unverified_context
+
+BIBTEX = """"""
+
+
+with open(Path(__file__).parent / "model_configs.json", "r") as f:
+    MODEL_CONFIGS = json.load(f)
+
+
+def load_image(image_filepath):
+    return Image.open(image_filepath).convert("RGB")
+
+
+def get_interpolation_mode(interpolation: str) -> int:
+    """Returns the interpolation mode for albumentations"""
+    if "linear" or "bilinear" in interpolation:
+        return 1
+    elif "cubic" or "bicubic" in interpolation:
+        return 2
+    else:
+        raise NotImplementedError(f"Interpolation mode {interpolation} not implemented")
+
+
+def custom_image_preprocess(
+    images,
+    resize_size: int,
+    crop_size: int,
+    interpolation: str,
+    transforms=None,
+):
+    if transforms is None:
+        interpolation = get_interpolation_mode(interpolation)
+        transforms = A.Compose(
+            [
+                A.Resize(resize_size, resize_size, p=1.0, interpolation=interpolation),
+                A.CenterCrop(crop_size, crop_size, p=1.0),
+                A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+                ToTensorV2(),
+            ]
+        )
+    if isinstance(transforms, T.Compose):
+        images = [transforms(image) for image in images]
+        images = [np.array(image) for image in images]
+        images = np.stack(images)
+    elif isinstance(transforms, A.Compose):
+        images = [transforms(image=np.array(image))["image"] for image in images]
+        images = np.stack(images)
+    else:
+        raise NotImplementedError(
+            f"Transform of type {type(transforms)} is not implemented"
+        )
+
+    return images
+
+
+def load_preprocess_images_custom(
+    image_filepaths, preprocess_images=custom_image_preprocess, **kwargs
+):
+    images = [load_image(image_filepath) for image_filepath in image_filepaths]
+    images = preprocess_images(images, **kwargs)
+    return images
+
+
+def get_model(model_id:str):
+    
+    # Unpack model config
+    config = MODEL_CONFIGS[model_id]
+    model_name = config["model_name"]
+    model_id = config["model_id"]
+    resize_size = config["resize_size"]
+    crop_size = config["crop_size"]
+    interpolation = config["interpolation"]
+    num_classes = config["num_classes"]
+    ckpt_url = config["checkpoint_url"]
+    use_timm = config["use_timm"]
+    timm_model_name = config["timm_model_name"]
+    epoch = config["epoch"]
+    load_model_ema = config["load_model_ema"]
+    output_head = config["output_head"]
+    is_vit = config["is_vit"]
+    
+    # Temporary fix for vit models
+    # See https://github.com/brain-score/vision/pull/1232
+    if is_vit:
+        os.environ['RESULTCACHING_DISABLE'] = 'brainscore_vision.model_helpers.activations.core.ActivationsExtractorHelper._from_paths_stored'
+
+    
+    # Initialize model
+    if use_timm:
+        model = timm.create_model(timm_model_name, pretrained=False, num_classes=num_classes)
+    else:
+        model = eval(f"torchvision.models.{model_name}(weights=None)")
+        if num_classes != 1000:
+            exec(f'''{output_head} = torch.nn.Linear(
+                in_features={output_head}.in_features,
+                out_features=num_classes,
+                bias={output_head}.bias is not None,
+                )'''
+            )
+
+    # Load model weights
+    state_dict = torch.hub.load_state_dict_from_url(
+        ckpt_url,
+        check_hash=True,
+        file_name=f"{model_id}_ep{epoch}.pt",
+        map_location="cpu",
+    )
+    if load_model_ema:
+        state_dict = state_dict["state"]["model_ema_state_dict"]
+    else:
+        state_dict = state_dict["state"]["model"]
+    state_dict = {k.replace("module.", ""): v for k, v in state_dict.items()}
+    model.load_state_dict(state_dict, strict=True)
+    print(f"Model loaded from {ckpt_url}")
+
+    # Wrap model
+    preprocessing = functools.partial(
+        load_preprocess_images_custom,
+        resize_size=resize_size,
+        crop_size=crop_size,
+        interpolation=interpolation,
+        transforms=None
+    )
+    wrapper = PytorchWrapper(
+        identifier=model_id, model=model, preprocessing=preprocessing
+    )
+    return wrapper