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

brainscore_vision/models/cvt_cvt_21_224_in1k_4/model.py

@@ -0,0 +1,142 @@
+from brainscore_vision.model_helpers.check_submission import check_models
+import functools
+from transformers import AutoFeatureExtractor, CvtForImageClassification
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from PIL import Image
+import numpy as np
+import torch
+
+"""
+Template module for a base model submission to brain-score
+"""
+
+
+def get_model(name):
+    assert name == 'cvt_cvt-21-224-in1k_4_LucyV4'
+    # https://huggingface.co/models?sort=downloads&search=cvt
+    image_size = 224
+    processor = AutoFeatureExtractor.from_pretrained('microsoft/cvt-21')
+    model = CvtForImageClassification.from_pretrained('microsoft/cvt-21')
+    preprocessing = functools.partial(load_preprocess_images, processor=processor, image_size=image_size)
+    wrapper = PytorchWrapper(identifier=name, model=model, preprocessing=preprocessing)
+    wrapper.image_size = image_size
+
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'cvt_cvt-21-224-in1k_4_LucyV4'
+    layers = []
+    layers += [f'cvt.encoder.stages.0.layers.{i}' for i in range(1)]
+    layers += [f'cvt.encoder.stages.1.layers.{i}' for i in range(4)]
+    layers += [f'cvt.encoder.stages.2.layers.{i}' for i in range(16)]
+    layers += ['layernorm']
+    return layers
+
+
+def get_bibtex(model_identifier):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return """@misc{wu2021cvtintroducingconvolutionsvision,
+                    title={CvT: Introducing Convolutions to Vision Transformers}, 
+                    author={Haiping Wu and Bin Xiao and Noel Codella and Mengchen Liu and Xiyang Dai and Lu Yuan and Lei Zhang},
+                    year={2021},
+                    eprint={2103.15808},
+                    archivePrefix={arXiv},
+                    primaryClass={cs.CV},
+                    url={https://arxiv.org/abs/2103.15808}, 
+              }"""
+
+
+def load_preprocess_images(image_filepaths, image_size, processor=None, **kwargs):
+    images = load_images(image_filepaths)
+    # images = [<PIL.Image.Image image mode=RGB size=400x400 at 0x7F8654B2AC10>, ...]
+    images = [image.resize((image_size, image_size)) for image in images]
+    if processor is not None:
+        images = [processor(images=image, return_tensors="pt", **kwargs) for image in images]
+        if len(images[0].keys()) != 1:
+            raise NotImplementedError(f'unknown processor for getting model {processor}')
+        assert list(images[0].keys())[0] == 'pixel_values'
+        images = [image['pixel_values'] for image in images]
+        images = torch.cat(images)
+        images = images.cpu().numpy()
+    else:
+        images = preprocess_images(images, image_size=image_size, **kwargs)
+    return images
+
+
+def load_images(image_filepaths):
+    return [load_image(image_filepath) for image_filepath in image_filepaths]
+
+
+def load_image(image_filepath):
+    with Image.open(image_filepath) as pil_image:
+        if 'L' not in pil_image.mode.upper() and 'A' not in pil_image.mode.upper() \
+                and 'P' not in pil_image.mode.upper():  # not binary and not alpha and not palletized
+            # work around to https://github.com/python-pillow/Pillow/issues/1144,
+            # see https://stackoverflow.com/a/30376272/2225200
+            return pil_image.copy()
+        else:  # make sure potential binary images are in RGB
+            rgb_image = Image.new("RGB", pil_image.size)
+            rgb_image.paste(pil_image)
+            return rgb_image
+
+
+def preprocess_images(images, image_size, **kwargs):
+    preprocess = torchvision_preprocess_input(image_size, **kwargs)
+    images = [preprocess(image) for image in images]
+    images = np.concatenate(images)
+    return images
+
+
+def torchvision_preprocess_input(image_size, **kwargs):
+    from torchvision import transforms
+    return transforms.Compose([
+        transforms.Resize((image_size, image_size)),
+        torchvision_preprocess(**kwargs),
+    ])
+
+
+def torchvision_preprocess(normalize_mean=(0.485, 0.456, 0.406), normalize_std=(0.229, 0.224, 0.225)):
+    from torchvision import transforms
+    return transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize(mean=normalize_mean, std=normalize_std),
+        lambda img: img.unsqueeze(0)
+    ])
+
+
+def create_static_video(image, num_frames, normalize_0to1=False, channel_dim=3):
+    '''
+    Create a static video with the same image in all frames.
+    Args:
+        image (PIL.Image.Image): Input image.
+        num_frames (int): Number of frames in the video.
+    Returns:
+        result (np.ndarray): np array of frames of shape (num_frames, height, width, 3).
+    '''
+    frames = []
+    for _ in range(num_frames):
+        frame = np.array(image)
+        if normalize_0to1:
+            frame = frame / 255.
+        if channel_dim == 1:
+            frame = frame.transpose(2, 0, 1)
+        frames.append(frame)
+    return np.stack(frames)
+
+
+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__)
+
+"""
+Notes on the error:
+
+- 'channel_x' key error: 
+# 'embeddings.patch_embeddings.projection',
+https://github.com/search?q=repo%3Abrain-score%2Fmodel-tools%20channel_x&type=code
+
+"""

brainscore_vision/models/cvt_cvt_21_224_in1k_4/region_layer_map/cvt_cvt-21-224-in1k_4_LucyV4.json

@@ -0,0 +1,6 @@
+{
+    "V1": "cvt.encoder.stages.1.layers.0",
+    "V2": "cvt.encoder.stages.2.layers.0",
+    "V4": "cvt.encoder.stages.2.layers.0",
+    "IT": "cvt.encoder.stages.2.layers.0"
+}

brainscore_vision/models/cvt_cvt_21_224_in1k_4/requirements.txt

@@ -0,0 +1,4 @@
+numpy
+torch
+transformers==4.30.2
+pillow

brainscore_vision/models/cvt_cvt_21_224_in1k_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('cvt_cvt-21-224-in1k_4_LucyV4')
+    assert model.identifier == 'cvt_cvt-21-224-in1k_4_LucyV4'

brainscore_vision/models/cvt_cvt_21_384_in1k_4/__init__.py

@@ -0,0 +1,9 @@
+from brainscore_vision import model_registry
+from brainscore_vision.model_helpers.brain_transformation import ModelCommitment
+from .model import get_model, get_layers
+
+
+model_registry['cvt_cvt-21-384-in1k_4_LucyV4'] = \
+    lambda: ModelCommitment(identifier='cvt_cvt-21-384-in1k_4_LucyV4',
+                            activations_model=get_model('cvt_cvt-21-384-in1k_4_LucyV4'),
+                            layers=get_layers('cvt_cvt-21-384-in1k_4_LucyV4'))

brainscore_vision/models/cvt_cvt_21_384_in1k_4/model.py

@@ -0,0 +1,142 @@
+from brainscore_vision.model_helpers.check_submission import check_models
+import functools
+from transformers import AutoFeatureExtractor, CvtForImageClassification
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from PIL import Image
+import numpy as np
+import torch
+
+"""
+Template module for a base model submission to brain-score
+"""
+
+
+def get_model(name):
+    assert name == 'cvt_cvt-21-384-in1k_4_LucyV4'
+    # https://huggingface.co/models?sort=downloads&search=cvt
+    image_size = 384
+    processor = AutoFeatureExtractor.from_pretrained('microsoft/cvt-21-384-1k')
+    model = CvtForImageClassification.from_pretrained('microsoft/cvt-21-384-1k')
+    preprocessing = functools.partial(load_preprocess_images, processor=processor, image_size=image_size)
+    wrapper = PytorchWrapper(identifier=name, model=model, preprocessing=preprocessing)
+    wrapper.image_size = image_size
+
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'cvt_cvt-21-384-in1k_4_LucyV4'
+    layers = []
+    layers += [f'cvt.encoder.stages.0.layers.{i}' for i in range(1)]
+    layers += [f'cvt.encoder.stages.1.layers.{i}' for i in range(4)]
+    layers += [f'cvt.encoder.stages.2.layers.{i}' for i in range(16)]
+    layers += ['layernorm']
+    return layers
+
+
+def get_bibtex(model_identifier):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return """@misc{wu2021cvtintroducingconvolutionsvision,
+                    title={CvT: Introducing Convolutions to Vision Transformers}, 
+                    author={Haiping Wu and Bin Xiao and Noel Codella and Mengchen Liu and Xiyang Dai and Lu Yuan and Lei Zhang},
+                    year={2021},
+                    eprint={2103.15808},
+                    archivePrefix={arXiv},
+                    primaryClass={cs.CV},
+                    url={https://arxiv.org/abs/2103.15808}, 
+              }"""
+
+
+def load_preprocess_images(image_filepaths, image_size, processor=None, **kwargs):
+    images = load_images(image_filepaths)
+    # images = [<PIL.Image.Image image mode=RGB size=400x400 at 0x7F8654B2AC10>, ...]
+    images = [image.resize((image_size, image_size)) for image in images]
+    if processor is not None:
+        images = [processor(images=image, return_tensors="pt", **kwargs) for image in images]
+        if len(images[0].keys()) != 1:
+            raise NotImplementedError(f'unknown processor for getting model {processor}')
+        assert list(images[0].keys())[0] == 'pixel_values'
+        images = [image['pixel_values'] for image in images]
+        images = torch.cat(images)
+        images = images.cpu().numpy()
+    else:
+        images = preprocess_images(images, image_size=image_size, **kwargs)
+    return images
+
+
+def load_images(image_filepaths):
+    return [load_image(image_filepath) for image_filepath in image_filepaths]
+
+
+def load_image(image_filepath):
+    with Image.open(image_filepath) as pil_image:
+        if 'L' not in pil_image.mode.upper() and 'A' not in pil_image.mode.upper() \
+                and 'P' not in pil_image.mode.upper():  # not binary and not alpha and not palletized
+            # work around to https://github.com/python-pillow/Pillow/issues/1144,
+            # see https://stackoverflow.com/a/30376272/2225200
+            return pil_image.copy()
+        else:  # make sure potential binary images are in RGB
+            rgb_image = Image.new("RGB", pil_image.size)
+            rgb_image.paste(pil_image)
+            return rgb_image
+
+
+def preprocess_images(images, image_size, **kwargs):
+    preprocess = torchvision_preprocess_input(image_size, **kwargs)
+    images = [preprocess(image) for image in images]
+    images = np.concatenate(images)
+    return images
+
+
+def torchvision_preprocess_input(image_size, **kwargs):
+    from torchvision import transforms
+    return transforms.Compose([
+        transforms.Resize((image_size, image_size)),
+        torchvision_preprocess(**kwargs),
+    ])
+
+
+def torchvision_preprocess(normalize_mean=(0.485, 0.456, 0.406), normalize_std=(0.229, 0.224, 0.225)):
+    from torchvision import transforms
+    return transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize(mean=normalize_mean, std=normalize_std),
+        lambda img: img.unsqueeze(0)
+    ])
+
+
+def create_static_video(image, num_frames, normalize_0to1=False, channel_dim=3):
+    '''
+    Create a static video with the same image in all frames.
+    Args:
+        image (PIL.Image.Image): Input image.
+        num_frames (int): Number of frames in the video.
+    Returns:
+        result (np.ndarray): np array of frames of shape (num_frames, height, width, 3).
+    '''
+    frames = []
+    for _ in range(num_frames):
+        frame = np.array(image)
+        if normalize_0to1:
+            frame = frame / 255.
+        if channel_dim == 1:
+            frame = frame.transpose(2, 0, 1)
+        frames.append(frame)
+    return np.stack(frames)
+
+
+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__)
+
+"""
+Notes on the error:
+
+- 'channel_x' key error: 
+# 'embeddings.patch_embeddings.projection',
+https://github.com/search?q=repo%3Abrain-score%2Fmodel-tools%20channel_x&type=code
+
+"""

brainscore_vision/models/cvt_cvt_21_384_in1k_4/region_layer_map/cvt_cvt-21-384-in1k_4_LucyV4.json

@@ -0,0 +1,6 @@
+{
+    "V1": "cvt.encoder.stages.1.layers.0",
+    "V2": "cvt.encoder.stages.1.layers.3",
+    "V4": "cvt.encoder.stages.2.layers.0",
+    "IT": "cvt.encoder.stages.2.layers.1"
+}

brainscore_vision/models/cvt_cvt_21_384_in1k_4/requirements.txt

@@ -0,0 +1,4 @@
+numpy
+torch
+transformers==4.30.2
+pillow

brainscore_vision/models/cvt_cvt_21_384_in1k_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('cvt_cvt-21-384-in1k_4_LucyV4')
+    assert model.identifier == 'cvt_cvt-21-384-in1k_4_LucyV4'

brainscore_vision/models/cvt_cvt_21_384_in22k_finetuned_in1k_4/__init__.py

@@ -0,0 +1,9 @@
+from brainscore_vision import model_registry
+from brainscore_vision.model_helpers.brain_transformation import ModelCommitment
+from .model import get_model, get_layers
+
+
+model_registry['cvt_cvt-21-384-in22k_finetuned-in1k_4_LucyV4'] = \
+    lambda: ModelCommitment(identifier='cvt_cvt-21-384-in22k_finetuned-in1k_4_LucyV4',
+                            activations_model=get_model('cvt_cvt-21-384-in22k_finetuned-in1k_4_LucyV4'),
+                            layers=get_layers('cvt_cvt-21-384-in22k_finetuned-in1k_4_LucyV4'))

brainscore_vision/models/cvt_cvt_21_384_in22k_finetuned_in1k_4/model.py

@@ -0,0 +1,142 @@
+from brainscore_vision.model_helpers.check_submission import check_models
+import functools
+from transformers import AutoFeatureExtractor, CvtForImageClassification
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from PIL import Image
+import numpy as np
+import torch
+
+"""
+Template module for a base model submission to brain-score
+"""
+
+
+def get_model(name):
+    assert name == 'cvt_cvt-21-384-in22k_finetuned-in1k_4_LucyV4'
+    # https://huggingface.co/models?sort=downloads&search=cvt
+    image_size = 384
+    processor = AutoFeatureExtractor.from_pretrained('microsoft/cvt-21-384-22k')
+    model = CvtForImageClassification.from_pretrained('microsoft/cvt-21-384-22k')
+    preprocessing = functools.partial(load_preprocess_images, processor=processor, image_size=image_size)
+    wrapper = PytorchWrapper(identifier=name, model=model, preprocessing=preprocessing)
+    wrapper.image_size = image_size
+
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'cvt_cvt-21-384-in22k_finetuned-in1k_4_LucyV4'
+    layers = []
+    layers += [f'cvt.encoder.stages.0.layers.{i}' for i in range(1)]
+    layers += [f'cvt.encoder.stages.1.layers.{i}' for i in range(4)]
+    layers += [f'cvt.encoder.stages.2.layers.{i}' for i in range(16)]
+    layers += ['layernorm']
+    return layers
+
+
+def get_bibtex(model_identifier):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return """@misc{wu2021cvtintroducingconvolutionsvision,
+                    title={CvT: Introducing Convolutions to Vision Transformers}, 
+                    author={Haiping Wu and Bin Xiao and Noel Codella and Mengchen Liu and Xiyang Dai and Lu Yuan and Lei Zhang},
+                    year={2021},
+                    eprint={2103.15808},
+                    archivePrefix={arXiv},
+                    primaryClass={cs.CV},
+                    url={https://arxiv.org/abs/2103.15808}, 
+              }"""
+
+
+def load_preprocess_images(image_filepaths, image_size, processor=None, **kwargs):
+    images = load_images(image_filepaths)
+    # images = [<PIL.Image.Image image mode=RGB size=400x400 at 0x7F8654B2AC10>, ...]
+    images = [image.resize((image_size, image_size)) for image in images]
+    if processor is not None:
+        images = [processor(images=image, return_tensors="pt", **kwargs) for image in images]
+        if len(images[0].keys()) != 1:
+            raise NotImplementedError(f'unknown processor for getting model {processor}')
+        assert list(images[0].keys())[0] == 'pixel_values'
+        images = [image['pixel_values'] for image in images]
+        images = torch.cat(images)
+        images = images.cpu().numpy()
+    else:
+        images = preprocess_images(images, image_size=image_size, **kwargs)
+    return images
+
+
+def load_images(image_filepaths):
+    return [load_image(image_filepath) for image_filepath in image_filepaths]
+
+
+def load_image(image_filepath):
+    with Image.open(image_filepath) as pil_image:
+        if 'L' not in pil_image.mode.upper() and 'A' not in pil_image.mode.upper() \
+                and 'P' not in pil_image.mode.upper():  # not binary and not alpha and not palletized
+            # work around to https://github.com/python-pillow/Pillow/issues/1144,
+            # see https://stackoverflow.com/a/30376272/2225200
+            return pil_image.copy()
+        else:  # make sure potential binary images are in RGB
+            rgb_image = Image.new("RGB", pil_image.size)
+            rgb_image.paste(pil_image)
+            return rgb_image
+
+
+def preprocess_images(images, image_size, **kwargs):
+    preprocess = torchvision_preprocess_input(image_size, **kwargs)
+    images = [preprocess(image) for image in images]
+    images = np.concatenate(images)
+    return images
+
+
+def torchvision_preprocess_input(image_size, **kwargs):
+    from torchvision import transforms
+    return transforms.Compose([
+        transforms.Resize((image_size, image_size)),
+        torchvision_preprocess(**kwargs),
+    ])
+
+
+def torchvision_preprocess(normalize_mean=(0.485, 0.456, 0.406), normalize_std=(0.229, 0.224, 0.225)):
+    from torchvision import transforms
+    return transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize(mean=normalize_mean, std=normalize_std),
+        lambda img: img.unsqueeze(0)
+    ])
+
+
+def create_static_video(image, num_frames, normalize_0to1=False, channel_dim=3):
+    '''
+    Create a static video with the same image in all frames.
+    Args:
+        image (PIL.Image.Image): Input image.
+        num_frames (int): Number of frames in the video.
+    Returns:
+        result (np.ndarray): np array of frames of shape (num_frames, height, width, 3).
+    '''
+    frames = []
+    for _ in range(num_frames):
+        frame = np.array(image)
+        if normalize_0to1:
+            frame = frame / 255.
+        if channel_dim == 1:
+            frame = frame.transpose(2, 0, 1)
+        frames.append(frame)
+    return np.stack(frames)
+
+
+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__)
+
+"""
+Notes on the error:
+
+- 'channel_x' key error: 
+# 'embeddings.patch_embeddings.projection',
+https://github.com/search?q=repo%3Abrain-score%2Fmodel-tools%20channel_x&type=code
+
+"""

brainscore_vision/models/cvt_cvt_21_384_in22k_finetuned_in1k_4/region_layer_map/cvt_cvt-21-384-in22k_finetuned-in1k_4_LucyV4.json

@@ -0,0 +1,6 @@
+{
+    "V1": "cvt.encoder.stages.2.layers.1",
+    "V2": "cvt.encoder.stages.1.layers.2",
+    "V4": "cvt.encoder.stages.2.layers.0",
+    "IT": "cvt.encoder.stages.2.layers.1"
+}

brainscore_vision/models/cvt_cvt_21_384_in22k_finetuned_in1k_4/requirements.txt

@@ -0,0 +1,4 @@
+numpy
+torch
+transformers==4.30.2
+pillow

brainscore_vision/models/cvt_cvt_21_384_in22k_finetuned_in1k_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('cvt_cvt-21-384-in22k_finetuned-in1k_4_LucyV4')
+    assert model.identifier == 'cvt_cvt-21-384-in22k_finetuned-in1k_4_LucyV4'

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

brainscore_vision/models/fixres_resnext101_32x48d_wsl/model.py

@@ -0,0 +1,57 @@
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from fixres.hubconf import load_state_dict_from_url
+from fixres.transforms_v2 import get_transforms
+from brainscore_vision.model_helpers.activations.pytorch import load_images
+import numpy as np
+from importlib import import_module
+import ssl
+
+
+ssl._create_default_https_context = ssl._create_unverified_context
+
+
+def get_model():
+    module = import_module('fixres.imnet_evaluate.resnext_wsl')
+    model_ctr = getattr(module, 'resnext101_32x48d_wsl')
+    model = model_ctr(pretrained=False)  # the pretrained flag here corresponds to standard resnext weights
+    pretrained_dict = load_state_dict_from_url('https://dl.fbaipublicfiles.com/FixRes_data/FixRes_Pretrained_Models/ResNeXt_101_32x48d.pth',
+                                               map_location=lambda storage, loc: storage)['model']
+    model_dict = model.state_dict()
+    for k in model_dict.keys():
+        assert ('module.' + k) in pretrained_dict.keys()
+        model_dict[k] = pretrained_dict.get(('module.' + k))
+    model.load_state_dict(model_dict)
+
+    # preprocessing
+    # 320 for ResNeXt:
+    # https://github.com/mschrimpf/FixRes/tree/4ddcf11b29c118dfb8a48686f75f572450f67e5d#example-evaluation-procedure
+    input_size = 320
+    # https://github.com/mschrimpf/FixRes/blob/0dc15ab509b9cb9d7002ca47826dab4d66033668/fixres/imnet_evaluate/train.py#L159-L160
+    transformation = get_transforms(input_size=input_size, test_size=input_size,
+                                    kind='full', need=('val',),
+                                    # this is different from standard ImageNet evaluation to show the whole image
+                                    crop=False,
+                                    # no backbone parameter for ResNeXt following
+                                    # https://github.com/mschrimpf/FixRes/blob/0dc15ab509b9cb9d7002ca47826dab4d66033668/fixres/imnet_evaluate/train.py#L154-L156
+                                    backbone=None)
+    transform = transformation['val']
+
+    def load_preprocess_images(image_filepaths):
+        images = load_images(image_filepaths)
+        images = [transform(image) for image in images]
+        images = [image.unsqueeze(0) for image in images]
+        images = np.concatenate(images)
+        return images
+
+    wrapper = PytorchWrapper(identifier='resnext101_32x48d_wsl', model=model, preprocessing=load_preprocess_images,
+                             batch_size=4)  # doesn't fit into 12 GB GPU memory otherwise
+    wrapper.image_size = input_size
+    return wrapper
+
+
+def get_layers(name):
+    return (['conv1'] +
+            # note that while relu is used multiple times, by default the last one will overwrite all previous ones
+            [f"layer{block + 1}.{unit}.relu"
+             for block, block_units in enumerate([3, 4, 23, 3]) for unit in range(block_units)] +
+            ['avgpool'])

brainscore_vision/models/fixres_resnext101_32x48d_wsl/requirements.txt

@@ -0,0 +1,5 @@
+torchvision
+torch
+numpy
+importlib
+Fixing-the-train-test-resolution-discrepancy-scripts@ git+https://github.com/mschrimpf/FixRes.git

brainscore_vision/models/fixres_resnext101_32x48d_wsl/test.py

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

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

brainscore_vision/models/inception_v4_pytorch/model.py

@@ -0,0 +1,64 @@
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+import ssl
+import functools
+import timm
+from brainscore_vision.model_helpers.check_submission import check_models
+
+ssl._create_default_https_context = ssl._create_unverified_context
+
+'''
+This is a Pytorch implementation of inception_v4.
+
+Previously on Brain-Score, this model existed as a Tensorflow model, and was converted via:
+    https://huggingface.co/docs/timm/en/models/inception-v4
+    
+Disclaimer: This (pytorch) implementation's Brain-Score scores might not align identically with Tensorflow 
+implementation. 
+
+'''
+
+
+MODEL = timm.create_model('inception_v4', pretrained=True)
+
+def get_model(name):
+    assert name == 'inception_v4_pytorch'
+    preprocessing = functools.partial(load_preprocess_images, image_size=299)
+    wrapper = PytorchWrapper(identifier='inception_v4_pytorch', model=MODEL,
+                             preprocessing=preprocessing,
+                             batch_size=4)  # doesn't fit into 12 GB GPU memory otherwise
+    wrapper.image_size = 299
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'inception_v4_pytorch'
+    layers = [] 
+    layers += ['Conv2d_1a_3x3']
+    layers += ['Mixed_3a']
+    layers += ['Mixed_4a']
+    layers += [f'Mixed_5{i}' for i in ['a', 'b', 'c', 'd', 'e']]
+    layers += [f'Mixed_6{i}' for i in ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']]
+    layers += [f'Mixed_7{i}' for i in ['a', 'b', 'c', 'd']]
+    layers += ['global_pool']
+    
+    return layers
+
+
+def get_bibtex(model_identifier):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return """@misc{szegedy2016inceptionv4,
+              title={Inception-v4, Inception-ResNet and the Impact of Residual Connections on Learning}, 
+              author={Christian Szegedy and Sergey Ioffe and Vincent Vanhoucke and Alex Alemi},
+              year={2016},
+              eprint={1602.07261},
+              archivePrefix={arXiv},
+              primaryClass={cs.CV}
+        }
+            """
+
+
+if __name__ == '__main__':
+    check_models.check_base_models(__name__)