brainscore-vision 2.2.4__py3-none-any.whl → 2.2.5__py3-none-any.whl

brainscore_vision/models/imagenet_l2_3_0/model.py

@@ -0,0 +1,101 @@
+import functools
+import dill
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+from robustness.model_utils import DummyModel
+from robustness.attacker import AttackerModel
+from robustness.datasets import DATASETS
+from brainscore_vision.model_helpers.s3 import load_weight_file
+from brainscore_vision.model_helpers.check_submission import check_models
+import torch as ch
+import os
+
+def make_and_restore_model(*_, arch, dataset, resume_path=None,
+         parallel=False, pytorch_pretrained=False, add_custom_forward=False):
+    """
+    Makes a model and (optionally) restores it from a checkpoint.
+
+    Args:
+        arch (str|nn.Module): Model architecture identifier or otherwise a
+            torch.nn.Module instance with the classifier
+        dataset (Dataset class [see datasets.py])
+        resume_path (str): optional path to checkpoint saved with the 
+            robustness library (ignored if ``arch`` is not a string)
+        not a string
+        parallel (bool): if True, wrap the model in a DataParallel 
+            (defaults to False)
+        pytorch_pretrained (bool): if True, try to load a standard-trained 
+            checkpoint from the torchvision library (throw error if failed)
+        add_custom_forward (bool): ignored unless arch is an instance of
+            nn.Module (and not a string). Normally, architectures should have a
+            forward() function which accepts arguments ``with_latent``,
+            ``fake_relu``, and ``no_relu`` to allow for adversarial manipulation
+            (see `here`<https://robustness.readthedocs.io/en/latest/example_usage/training_lib_part_2.html#training-with-custom-architectures>
+            for more info). If this argument is True, then these options will
+            not be passed to forward(). (Useful if you just want to train a
+            model and don't care about these arguments, and are passing in an
+            arch that you don't want to edit forward() for, e.g.  a pretrained model)
+    Returns: 
+        A tuple consisting of the model (possibly loaded with checkpoint), and the checkpoint itself
+    """
+    if (not isinstance(arch, str)) and add_custom_forward:
+        arch = DummyModel(arch)
+
+    classifier_model = dataset.get_model(arch, pytorch_pretrained) if \
+                            isinstance(arch, str) else arch
+
+    model = AttackerModel(classifier_model, dataset)
+
+    # optionally resume from a checkpoint
+    checkpoint = None
+    if resume_path and os.path.isfile(resume_path):
+        print("=> loading checkpoint '{}'".format(resume_path))
+        checkpoint = ch.load(resume_path, pickle_module=dill,map_location="cpu")
+        
+        # Makes us able to load models saved with legacy versions
+        state_dict_path = 'model'
+        if not ('model' in checkpoint):
+            state_dict_path = 'state_dict'
+
+        sd = checkpoint[state_dict_path]
+        sd = {k[len('module.'):]:v for k,v in sd.items()}
+        model.load_state_dict(sd)
+        print("=> loaded checkpoint '{}' (epoch {})".format(resume_path, checkpoint['epoch']))
+    elif resume_path:
+        error_msg = "=> no checkpoint found at '{}'".format(resume_path)
+        raise ValueError(error_msg)
+
+    if parallel:
+        model = ch.nn.DataParallel(model)
+        
+    return model, checkpoint
+
+def get_model(name):
+    assert name == "imagenet_l2_3_0"
+    data_path = "" #os.path.expandvars(args.data)
+    dataset = DATASETS['imagenet'](data_path)
+    weights_path = load_weight_file(bucket="brainscore-storage", folder_name="brainscore-vision/models",
+                                   relative_path="imagenet_l2_3_0/imagenet_l2_3_0.pt",
+                                   version_id="null",
+                                   sha1="cc6e4441abc8ad6d2f4da5db84836e544bfb53fd")
+    model, _ = make_and_restore_model(arch='resnet50', dataset=dataset, 
+                                      resume_path=weights_path)
+    model = model.model.eval()
+    # print(model)
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    wrapper = PytorchWrapper(identifier=name, model=model, preprocessing=preprocessing)
+    wrapper.image_size = 224
+    return wrapper
+
+
+def get_layers(name):
+    assert name == "imagenet_l2_3_0"
+    return ['conv1', 'bn1', 'relu', 'maxpool', 'layer1', 'layer2', 'layer3', 'layer4', 'avgpool', 'fc']
+
+
+def get_bibtex(name):
+    return """ """
+
+
+if __name__ == '__main__':
+    check_models.check_base_models(__name__)

brainscore_vision/models/imagenet_l2_3_0/region_layer_map/imagenet_l2_3_0.json

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

brainscore_vision/models/imagenet_l2_3_0/requirements.txt

@@ -0,0 +1,2 @@
+robustness @ git+https://github.com/MadryLab/robustness
+dill

brainscore_vision/models/imagenet_l2_3_0/test.py

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

brainscore_vision/models/inception_v1/__init__.py

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

brainscore_vision/models/inception_v1/model.py

@@ -0,0 +1,67 @@
+import functools
+import torch
+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
+
+
+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
+    """
+    assert name == 'inception_v1'
+    preprocessing = functools.partial(load_preprocess_images, image_size=224, preprocess_type='inception')
+    model = torch.hub.load('pytorch/vision:v0.10.0', 'googlenet', pretrained=True)
+    wrapper = PytorchWrapper(identifier='inception_v1', model=model, preprocessing=preprocessing)
+    wrapper.image_size = 224
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'inception_v1'
+    layer_names = (['maxpool2'] +
+                   [f'inception3{i}' for i in ['a', 'b']] +
+                   [f'inception4{i}' for i in ['a', 'b', 'c', 'd', 'e']] +
+                   [f'inception5{i}' for i in ['a', 'b']] +
+                   ['avgpool'])
+    return layer_names
+
+
+def get_bibtex(name):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return '''
+@article{DBLP:journals/corr/SzegedyLJSRAEVR14,
+  author       = {Christian Szegedy and
+                  Wei Liu and
+                  Yangqing Jia and
+                  Pierre Sermanet and
+                  Scott E. Reed and
+                  Dragomir Anguelov and
+                  Dumitru Erhan and
+                  Vincent Vanhoucke and
+                  Andrew Rabinovich},
+  title        = {Going Deeper with Convolutions},
+  journal      = {CoRR},
+  volume       = {abs/1409.4842},
+  year         = {2014},
+  url          = {http://arxiv.org/abs/1409.4842},
+  eprinttype    = {arXiv},
+  eprint       = {1409.4842},
+  timestamp    = {Mon, 13 Aug 2018 16:48:52 +0200},
+  biburl       = {https://dblp.org/rec/journals/corr/SzegedyLJSRAEVR14.bib},
+  bibsource    = {dblp computer science bibliography, https://dblp.org}
+}
+'''
+
+
+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/inception_v1/requirements.txt

@@ -0,0 +1 @@
+torch

brainscore_vision/models/inception_v1/test.py

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

brainscore_vision/models/{inception_v3_pytorch → inception_v3}/__init__.py

@@ -2,6 +2,6 @@ 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_v3_pytorch'] = lambda: ModelCommitment(identifier='inception_v3_pytorch',
-                                                               activations_model=get_model('inception_v3_pytorch'),
-                                                               layers=get_layers('inception_v3_pytorch'))
+model_registry['inception_v3'] = lambda: ModelCommitment(identifier='inception_v3',
+                                                               activations_model=get_model('inception_v3'),
+                                                               layers=get_layers('inception_v3'))

brainscore_vision/models/{inception_v3_pytorch → inception_v3}/model.py

@@ -21,9 +21,9 @@ implementation.
 MODEL = timm.create_model('inception_v3', pretrained=True)
 
 def get_model(name):
-    assert name == 'inception_v3_pytorch'
-    preprocessing = functools.partial(load_preprocess_images, image_size=299)
-    wrapper = PytorchWrapper(identifier='inception_v3_pytorch', model=MODEL,
+    assert name == 'inception_v3'
+    preprocessing = functools.partial(load_preprocess_images, image_size=299, preprocess_type='inception')
+    wrapper = PytorchWrapper(identifier='inception_v3', model=MODEL,
                              preprocessing=preprocessing,
                              batch_size=4)  # doesn't fit into 12 GB GPU memory otherwise
     wrapper.image_size = 299
@@ -31,13 +31,13 @@ def get_model(name):
 
 
 def get_layers(name):
-    assert name == 'inception_v3_pytorch'
-    layer_names = []
-
-    for name, module in MODEL.named_modules():
-        layer_names.append(name)
-
-    return layer_names[2:]
+    assert name == 'inception_v3'
+    layer_names = (['Conv2d_1a_3x3', 'Pool1', 'Pool2'] +
+                   [f'Mixed_5{i}' for i in ['b', 'c', 'd']] +
+                   [f'Mixed_6{i}' for i in ['a', 'b', 'c', 'd', 'e']] +
+                   [f'Mixed_7{i}' for i in ['a', 'b', 'c']] +
+                   ['global_pool'])
+    return layer_names
 
 
 def get_bibtex(model_identifier):

brainscore_vision/models/inception_v3/region_layer_map/inception_v3.json

@@ -0,0 +1,6 @@
+{
+    "V1": "Mixed_6a",
+    "V2": "Mixed_6b",
+    "V4": "Mixed_5b",
+    "IT": "Mixed_7a"
+}

brainscore_vision/models/inception_v3/test.py

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

brainscore_vision/models/{inception_v4_pytorch → inception_v4}/__init__.py

@@ -2,6 +2,6 @@ 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'))
+model_registry['inception_v4'] = lambda: ModelCommitment(identifier='inception_v4',
+                                                               activations_model=get_model('inception_v4'),
+                                                               layers=get_layers('inception_v4'))

brainscore_vision/models/{inception_v4_pytorch → inception_v4}/model.py

@@ -12,6 +12,7 @@ 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
+    https://huggingface.co/timm/inception_v4.tf_in1k
     
 Disclaimer: This (pytorch) implementation's Brain-Score scores might not align identically with Tensorflow 
 implementation. 
@@ -19,12 +20,12 @@ implementation.
 '''
 
 
-MODEL = timm.create_model('inception_v4', pretrained=True)
+MODEL = timm.create_model('inception_v4.tf_in1k', 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,
+    assert name == 'inception_v4'
+    preprocessing = functools.partial(load_preprocess_images, image_size=299, preprocess_type='inception')
+    wrapper = PytorchWrapper(identifier='inception_v4', model=MODEL,
                              preprocessing=preprocessing,
                              batch_size=4)  # doesn't fit into 12 GB GPU memory otherwise
     wrapper.image_size = 299
@@ -32,17 +33,9 @@ def get_model(name):
 
 
 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
+    assert name == 'inception_v4'
+    layer_names = ['features.0.conv'] + [f'features.{i}' for i in range(1, 22)] + ['global_pool']
+    return layer_names
 
 
 def get_bibtex(model_identifier):

brainscore_vision/models/inception_v4/region_layer_map/inception_v4.json

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

brainscore_vision/models/inception_v4/test.py

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

brainscore_vision/models/mobilenet_v2_0_5_192/__init__.py

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

brainscore_vision/models/mobilenet_v2_0_5_192/model.py

@@ -0,0 +1,83 @@
+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 brainscore_vision.model_helpers.s3 import load_weight_file
+import torch
+import imp
+
+model_path = load_weight_file(bucket="brainscore-storage", folder_name="brainscore-vision/models",
+                                    relative_path="mobilenet_v2_0.5_192/mobilenet_v2_0.py",
+                                    version_id="null",
+                                    sha1="d5c7af8768f9f2475367ac1e48e204cc5cf004a0")
+model_weight_path = load_weight_file(bucket="brainscore-storage", folder_name="brainscore-vision/models",
+                                    relative_path="mobilenet_v2_0.5_192/mobilenet_v2_0.5_192_frozen.pth",
+                                    version_id="null",
+                                    sha1="e5aa083caa4833fccd48af0c578a45064824dd7f")
+MainModel = imp.load_source('MainModel',model_path.as_posix())
+
+
+# This custom wrapper handles background class removal, and is used in related mobilenets
+class MobilenetPytorchWrapper(PytorchWrapper):
+    def __call__(self, *args, **kwargs):
+        result = super().__call__(*args, **kwargs)  # retrieve original output
+        if 'logits' in kwargs.get('layers', []):
+            result = result.isel(neuroid=slice(1, None))  # remove background class in last layer
+        return result
+
+
+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
+    """
+    assert name == 'mobilenet_v2_0_5_192'
+    model = torch.load(model_weight_path.as_posix(), weights_only=False)
+    preprocessing = functools.partial(load_preprocess_images, image_size=192, preprocess_type='inception')
+    wrapper = MobilenetPytorchWrapper(identifier=name, model=model, preprocessing=preprocessing)
+    wrapper.image_size = 192
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'mobilenet_v2_0_5_192'
+    layer_names = (['MobilenetV2_Conv_Conv2D'] +
+                   [f'MobilenetV2_expanded_conv_{i}_expand_Conv2D' for i in range(1, 17)] +
+                   ['MobilenetV2_Conv_1_Conv2D'])
+    return layer_names
+
+
+def get_bibtex(name):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return '''
+@article{DBLP:journals/corr/abs-1801-04381,
+  author       = {Mark Sandler and
+                  Andrew G. Howard and
+                  Menglong Zhu and
+                  Andrey Zhmoginov and
+                  Liang{-}Chieh Chen},
+  title        = {Inverted Residuals and Linear Bottlenecks: Mobile Networks for Classification,
+                  Detection and Segmentation},
+  journal      = {CoRR},
+  volume       = {abs/1801.04381},
+  year         = {2018},
+  url          = {http://arxiv.org/abs/1801.04381},
+  eprinttype    = {arXiv},
+  eprint       = {1801.04381},
+  timestamp    = {Tue, 12 Jan 2021 15:30:06 +0100},
+  biburl       = {https://dblp.org/rec/journals/corr/abs-1801-04381.bib},
+  bibsource    = {dblp computer science bibliography, https://dblp.org}
+}
+'''
+
+
+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/mobilenet_v2_0_5_192/region_layer_map/mobilenet_v2_0_5_192.json

@@ -0,0 +1,6 @@
+{
+    "V1": "MobilenetV2_expanded_conv_9_expand_Conv2D",
+    "V2": "MobilenetV2_expanded_conv_8_expand_Conv2D",
+    "V4": "MobilenetV2_expanded_conv_7_expand_Conv2D",
+    "IT": "MobilenetV2_expanded_conv_14_expand_Conv2D"
+}

brainscore_vision/models/mobilenet_v2_0_5_192/requirements.txt

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

brainscore_vision/models/mobilenet_v2_0_5_192/test.py

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

brainscore_vision/models/mobilenet_v2_0_5_224/__init__.py

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

brainscore_vision/models/mobilenet_v2_0_5_224/model.py

@@ -0,0 +1,73 @@
+import functools
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+from brainscore_vision.model_helpers.check_submission import check_models
+from brainscore_vision.model_helpers.s3 import load_weight_file
+from brainscore_vision.models.mobilenet_v2_0_5_192.model import MobilenetPytorchWrapper
+import torch
+import imp
+
+model_path = load_weight_file(bucket="brainscore-storage", folder_name="brainscore-vision/models",
+                                    relative_path="mobilenet_v2_0.5_224/mobilenet_v2_0.py",
+                                    version_id="null",
+                                    sha1="51ead4ba3605cdc9b5adc117e14def601288dd94")
+model_weight_path = load_weight_file(bucket="brainscore-storage", folder_name="brainscore-vision/models",
+                                    relative_path="mobilenet_v2_0.5_224/mobilenet_v2_0.5_224_frozen.pth",
+                                    version_id="null",
+                                    sha1="649501eadcf01f871bdb2265aa7dcac80594160a")
+MainModel = imp.load_source('MainModel',model_path.as_posix())
+
+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
+    """
+    assert name == 'mobilenet_v2_0_5_224'
+    model = torch.load(model_weight_path.as_posix(), weights_only=False)
+    preprocessing = functools.partial(load_preprocess_images, image_size=224, preprocess_type='inception')
+    wrapper = MobilenetPytorchWrapper(identifier=name, model=model, preprocessing=preprocessing)
+    wrapper.image_size = 224
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'mobilenet_v2_0_5_224'
+    layer_names = (['MobilenetV2_Conv_Conv2D'] +
+                   [f'MobilenetV2_expanded_conv_{i}_expand_Conv2D' for i in range(1, 17)] +
+                   ['MobilenetV2_Conv_1_Conv2D'])
+    return layer_names
+
+
+def get_bibtex(name):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return '''
+@article{DBLP:journals/corr/abs-1801-04381,
+  author       = {Mark Sandler and
+                  Andrew G. Howard and
+                  Menglong Zhu and
+                  Andrey Zhmoginov and
+                  Liang{-}Chieh Chen},
+  title        = {Inverted Residuals and Linear Bottlenecks: Mobile Networks for Classification,
+                  Detection and Segmentation},
+  journal      = {CoRR},
+  volume       = {abs/1801.04381},
+  year         = {2018},
+  url          = {http://arxiv.org/abs/1801.04381},
+  eprinttype    = {arXiv},
+  eprint       = {1801.04381},
+  timestamp    = {Tue, 12 Jan 2021 15:30:06 +0100},
+  biburl       = {https://dblp.org/rec/journals/corr/abs-1801-04381.bib},
+  bibsource    = {dblp computer science bibliography, https://dblp.org}
+}
+'''
+
+
+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/mobilenet_v2_0_5_224/region_layer_map/mobilenet_v2_0_5_224.json

@@ -0,0 +1,6 @@
+{
+    "V1": "MobilenetV2_expanded_conv_9_expand_Conv2D",
+    "V2": "MobilenetV2_expanded_conv_8_expand_Conv2D",
+    "V4": "MobilenetV2_expanded_conv_7_expand_Conv2D",
+    "IT": "MobilenetV2_Conv_1_Conv2D"
+}

brainscore_vision/models/mobilenet_v2_0_5_224/requirements.txt

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

brainscore_vision/models/mobilenet_v2_0_5_224/test.py

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

brainscore_vision/models/mobilenet_v2_0_75_160/__init__.py

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

brainscore_vision/models/mobilenet_v2_0_75_160/model.py

@@ -0,0 +1,74 @@
+import functools
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+from brainscore_vision.model_helpers.check_submission import check_models
+from brainscore_vision.model_helpers.s3 import load_weight_file
+from brainscore_vision.models.mobilenet_v2_0_5_192.model import MobilenetPytorchWrapper
+import torch
+import imp
+
+model_path = load_weight_file(bucket="brainscore-storage", folder_name="brainscore-vision/models",
+                                    relative_path="mobilenet_v2_0.75_160/mobilenet_v2_0.py",
+                                    version_id="null",
+                                    sha1="11bd61b5e71962073072c0dadb252a262ae68579")
+model_weight_path = load_weight_file(bucket="brainscore-storage", folder_name="brainscore-vision/models",
+                                    relative_path="mobilenet_v2_0.75_160/mobilenet_v2_0.75_160_frozen.pth",
+                                    version_id="null",
+                                    sha1="9fc6f5e9864d524760c6e1dc8aa5702415457df4")
+MainModel = imp.load_source('MainModel',model_path.as_posix())
+
+
+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
+    """
+    assert name == 'mobilenet_v2_0_75_160'
+    model = torch.load(model_weight_path.as_posix(), weights_only=False)
+    preprocessing = functools.partial(load_preprocess_images, image_size=160, preprocess_type='inception')
+    wrapper = MobilenetPytorchWrapper(identifier=name, model=model, preprocessing=preprocessing)
+    wrapper.image_size = 160
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'mobilenet_v2_0_75_160'
+    layer_names = (['MobilenetV2_Conv_Conv2D'] +
+                   [f'MobilenetV2_expanded_conv_{i}_expand_Conv2D' for i in range(1, 17)] +
+                   ['MobilenetV2_Conv_1_Conv2D'])
+    return layer_names
+
+
+def get_bibtex(name):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return '''
+@article{DBLP:journals/corr/abs-1801-04381,
+  author       = {Mark Sandler and
+                  Andrew G. Howard and
+                  Menglong Zhu and
+                  Andrey Zhmoginov and
+                  Liang{-}Chieh Chen},
+  title        = {Inverted Residuals and Linear Bottlenecks: Mobile Networks for Classification,
+                  Detection and Segmentation},
+  journal      = {CoRR},
+  volume       = {abs/1801.04381},
+  year         = {2018},
+  url          = {http://arxiv.org/abs/1801.04381},
+  eprinttype    = {arXiv},
+  eprint       = {1801.04381},
+  timestamp    = {Tue, 12 Jan 2021 15:30:06 +0100},
+  biburl       = {https://dblp.org/rec/journals/corr/abs-1801-04381.bib},
+  bibsource    = {dblp computer science bibliography, https://dblp.org}
+}
+'''
+
+
+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__)