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

brainscore_vision/models/densenet_169/model.py

@@ -0,0 +1,63 @@
+import functools
+from torchvision.models import densenet169
+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 == 'densenet-169'
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    model = densenet169(weights='DEFAULT')
+    wrapper = PytorchWrapper(identifier='densenet-169', model=model, preprocessing=preprocessing)
+    wrapper.image_size = 224
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'densenet-169'
+    layer_names = (['norm0'] + ['pool0'] +
+                   [f'denseblock1.denselayer{i}' for i in range(1, 7)] + ['transition1.pool'] +
+                   [f'denseblock2.denselayer{i}' for i in range(1, 13)] + ['transition2.pool'] +
+                   [f'denseblock3.denselayer{i}' for i in range(1, 33)] + ['transition3.pool'] +
+                   [f'denseblock4.denselayer{i}' for i in range(1, 33)])
+    layer_names = [f"features.{name}" for name in layer_names]
+    layer_names += ['features.norm5']
+    return layer_names
+
+
+def get_bibtex(model_identifier):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return '''
+@article{DBLP:journals/corr/HuangLW16a,
+  author       = {Gao Huang and
+                  Zhuang Liu and
+                  Kilian Q. Weinberger},
+  title        = {Densely Connected Convolutional Networks},
+  journal      = {CoRR},
+  volume       = {abs/1608.06993},
+  year         = {2016},
+  url          = {http://arxiv.org/abs/1608.06993},
+  eprinttype    = {arXiv},
+  eprint       = {1608.06993},
+  timestamp    = {Mon, 10 Sep 2018 15:49:32 +0200},
+  biburl       = {https://dblp.org/rec/journals/corr/HuangLW16a.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/densenet_169/region_layer_map/densenet-169.json

@@ -0,0 +1 @@
+{"V4": "features.transition2.pool", "IT": "features.transition3.pool", "V2": "features.transition2.pool", "V1": "features.transition1.pool"}

brainscore_vision/models/densenet_169/requirements.txt

@@ -0,0 +1 @@
+torchvision

brainscore_vision/models/densenet_169/test.py

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

brainscore_vision/models/{densenet_201_pytorch → densenet_201}/__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['densenet_201_pytorch'] = lambda: ModelCommitment(identifier='densenet_201_pytorch',
-                                                               activations_model=get_model('densenet_201_pytorch'),
-                                                               layers=get_layers('densenet_201_pytorch'))
+model_registry['densenet-201'] = lambda: ModelCommitment(identifier='densenet-201',
+                                                               activations_model=get_model('densenet-201'),
+                                                               layers=get_layers('densenet-201'))

brainscore_vision/models/{densenet_201_pytorch → densenet_201}/model.py

@@ -8,7 +8,7 @@ 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 densenet_201.
+This is a Pytorch implementation of densenet-201.
 
 Previously on Brain-Score, this model existed as a Tensorflow model, and was converted via:
     https://huggingface.co/timm/densenet201.tv_in1k
@@ -23,9 +23,9 @@ MODEL = timm.create_model('densenet201.tv_in1k', pretrained=True)
 
 
 def get_model(name):
-    assert name == 'densenet_201_pytorch'
+    assert name == 'densenet-201'
     preprocessing = functools.partial(load_preprocess_images, image_size=224)
-    wrapper = PytorchWrapper(identifier='densenet_201_pytorch', model=MODEL,
+    wrapper = PytorchWrapper(identifier='densenet-201', model=MODEL,
                              preprocessing=preprocessing,
                              batch_size=4)  # doesn't fit into 12 GB GPU memory otherwise
     wrapper.image_size = 224
@@ -33,13 +33,15 @@ def get_model(name):
 
 
 def get_layers(name):
-    assert name == 'densenet_201_pytorch'
-    layer_names = []
-
-    for name, module in MODEL.named_modules():
-        layer_names.append(name)
-
-    return layer_names[2:]
+    assert name == 'densenet-201'
+    layer_names = (['norm0.act'] + ['pool0'] +
+                   [f'denseblock1.denselayer{i}' for i in range(1, 7)] + ['transition1.pool'] +
+                   [f'denseblock2.denselayer{i}' for i in range(1, 13)] + ['transition2.pool'] +
+                   [f'denseblock3.denselayer{i}' for i in range(1, 49)] + ['transition3.pool'] +
+                   [f'denseblock4.denselayer{i}' for i in range(1, 33)])
+    layer_names = [f"features.{name}" for name in layer_names]
+    layer_names += ['global_pool']
+    return layer_names
 
 
 def get_bibtex(model_identifier):

brainscore_vision/models/densenet_201/region_layer_map/densenet-201.json

@@ -0,0 +1,6 @@
+{
+    "V1": "features.transition1.pool",
+    "V2": "features.transition2.pool",
+    "V4": "features.transition2.pool",
+    "IT": "features.transition3.pool"
+}

brainscore_vision/models/densenet_201/test.py

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

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

brainscore_vision/models/efficientnet_b0/model.py

@@ -0,0 +1,45 @@
+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
+import torchvision.models
+
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
+
+def get_model(name):
+    assert name == 'efficientnet_b0'
+    model = torchvision.models.efficientnet_b0(pretrained=True)
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    wrapper = PytorchWrapper(identifier='efficientnet_b0', model=model, preprocessing=preprocessing)
+    wrapper.image_size = 224
+    return wrapper
+
+def get_layers(name):
+    assert name == 'efficientnet_b0'
+    return ['features.0.2',
+             'features.2.1.stochastic_depth',
+             'features.3.1.stochastic_depth',
+             'features.4.1.stochastic_depth',
+             'features.4.2.stochastic_depth',
+             'features.5.1.stochastic_depth',
+             'features.5.2.stochastic_depth',
+             'features.6.1.stochastic_depth',
+             'features.6.2.stochastic_depth',
+             'features.8.2','classifier.0','classifier.1',
+             ]
+
+
+def get_bibtex(model_identifier):
+    return """@misc{tan2020efficientnet,
+      title={EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks}, 
+      author={Mingxing Tan and Quoc V. Le},
+      year={2020},
+      eprint={1905.11946},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG}
+}"""
+
+
+if __name__ == '__main__':
+    check_models.check_base_models(__name__)

brainscore_vision/models/efficientnet_b0/region_layer_map/efficientnet_b0.json

@@ -0,0 +1 @@
+{"IT": "features.6.1.stochastic_depth", "V4": "features.4.1.stochastic_depth", "V1": "features.3.1.stochastic_depth", "V2": "features.6.1.stochastic_depth"}

brainscore_vision/models/efficientnet_b0/requirements.txt

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

brainscore_vision/models/efficientnet_b0/test.py

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

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

brainscore_vision/models/efficientnet_b7/model.py

@@ -0,0 +1,61 @@
+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 types import MethodType
+from transformers import AutoModelForImageClassification
+
+
+model = AutoModelForImageClassification.from_pretrained("google/efficientnet-b7")
+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 == 'efficientnet-b7'
+
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    wrapper = PytorchWrapper(identifier=name, model=model, preprocessing=preprocessing)
+    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):
+    assert name == 'efficientnet-b7'
+    layers = [f'efficientnet.encoder.blocks.{i}' for i in range(55)]
+    return layers
+
+
+def get_bibtex(name):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return '''
+@article{DBLP:journals/corr/abs-1905-11946,
+  author       = {Mingxing Tan and
+                  Quoc V. Le},
+  title        = {EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks},
+  journal      = {CoRR},
+  volume       = {abs/1905.11946},
+  year         = {2019},
+  url          = {http://arxiv.org/abs/1905.11946},
+  eprinttype    = {arXiv},
+  eprint       = {1905.11946},
+  timestamp    = {Mon, 03 Jun 2019 13:42:33 +0200},
+  biburl       = {https://dblp.org/rec/journals/corr/abs-1905-11946.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/efficientnet_b7/region_layer_map/efficientnet-b7.json

@@ -0,0 +1 @@
+{"IT": "_blocks.38", "V1": "_blocks.11", "V4": "_blocks.28", "V2": "_blocks.18"}

brainscore_vision/models/efficientnet_b7/requirements.txt

@@ -0,0 +1 @@
+transformers

brainscore_vision/models/efficientnet_b7/test.py

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

brainscore_vision/models/effnetb1_cutmix_augmix_sam_e1_5avg_424x377/model.py

@@ -65,9 +65,9 @@ def get_model(name):
     assert name == 'effnetb1_cutmix_augmix_sam_e1_5avg_424x377'
     model_tf_efficientnet_b1_ns = EffNetBX()
 
-    weights_path = load_weight_file(bucket="brainscore-vision", folder_name="models",
+    weights_path = load_weight_file(bucket="brainscore-storage", folder_name="brainscore-vision/models",
                                     relative_path="effnetb1_cutmix_augmix_sam_e1_5avg_424x377/weights1_5_avg.pth",
-                                    version_id="EqB6P7BittVdkgRd3oMncq_j9AAdiYvz",
+                                    version_id="null",
                                     sha1="871bd10e6ce164bfe8f3ce10bb77a69d326d7b65")
     model_tf_efficientnet_b1_ns.load_state_dict(torch.load(weights_path, map_location=torch.device('cpu'))["model"])
     model = model_tf_efficientnet_b1_ns.efnet_model

brainscore_vision/models/effnetb1_cutmixpatch_SAM_robust32_avge6e8e9e10_manylayers_324x288/model.py

@@ -1,142 +1,142 @@
-import functools
-
-import torch
-from brainscore_vision.model_helpers.activations import PytorchWrapper
-from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
-from brainscore_vision.model_helpers.s3 import load_weight_file
-from PIL import Image
-import numpy as np
-import timm
-from timm.data import resolve_data_config
-from timm.data.transforms_factory import create_transform
-import torch.nn as nn
-from albumentations import (
-    Compose, Normalize, Resize,CenterCrop
-    )
-from albumentations.pytorch import ToTensorV2
-# This is an example implementation for submitting alexnet as a pytorch model
-# If you use pytorch, don't forget to add it to the setup.py
-
-# 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
-
-import os 
-
-image_resize = 324
-image_crop = 288
-norm_mean = [0.485, 0.456, 0.406] 
-norm_std = [0.229, 0.224, 0.225]
-freeze_layers = ['blocks.0.0', 'blocks.0.1', 'blocks.1.0', 
-                'blocks.1.1', 'blocks.1.2', 'blocks.2.0', 
-                'blocks.2.1', 'blocks.2.2', 'blocks.3.0', 'blocks.3.1', 'blocks.3.2']
-
-def custom_image_preprocess(images, **kwargs):
-    
-    transforms_val = Compose([
-        Resize(image_resize, image_resize),
-        CenterCrop(image_crop, image_crop),
-        Normalize(mean=norm_mean,std=norm_std,),
-        ToTensorV2()])
-    
-    images = [np.array(pillow_image) for pillow_image in images]
-    images = [transforms_val(image=image)["image"] for image in images]
-    images = np.stack(images)
-
-    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 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
-
-class EffNetBX(nn.Module):
-    def __init__(self,):
-        super().__init__ ()
-        self.efnet_model = timm.create_model('tf_efficientnet_b1_ns', pretrained=True)
-
-    def forward(self, x):
-        x = self.efnet_model(x)
-        return x
-
-def get_model(name):
-    assert name == 'effnetb1_cutmixpatch_SAM_robust32_avge6e8e9e10_manylayers_324x288'
-    model_tf_efficientnet_b1_ns= EffNetBX()
-    
-    weights_path = load_weight_file(bucket="brainscore-vision", folder_name="models",
-                                    relative_path="effnetb1_cutmixpatch_SAM_robust32_avge6e8e9e10_manylayers_324x288/tf_efficientnet_b1_ns_robust_cutmixpatchresize_SAM_e6e8e9e10.pth",
-                                    version_id="prSgvyJFh_c7OKQODIEqU_c_hg_YXh5M",
-                                    sha1="9d60e49043b2d5354447c46cd011764cc6cf094e")
-    model_tf_efficientnet_b1_ns.load_state_dict(torch.load(weights_path, map_location=torch.device('cpu'))["model"])
-    model = model_tf_efficientnet_b1_ns.efnet_model
-    filter_elems = set(["se", "act", "bn", "conv"])
-    layer_list = [layer for layer, _ in model.named_modules() if not any(i in layer for i in filter_elems)]
-    print(layer_list)
-    print(len(layer_list))
-    
-    for n, m in model.named_modules():
-      if isinstance(m, nn.BatchNorm2d) and any(x in n for x in ["conv_stem" ] + freeze_layers) or n =="bn1":
-        print(f"Freeze {n, m}")
-        m.eval()
-    
-    
-    preprocessing = functools.partial(load_preprocess_images_custom, 
-                                        preprocess_images=custom_image_preprocess,
-                                        )
-
-
-    wrapper = PytorchWrapper(identifier='my-model', model=model, preprocessing=preprocessing, batch_size=8)
-
-    wrapper.image_size = image_crop
-    return wrapper
-
-
-def get_layers(name):
-    assert name == 'effnetb1_cutmixpatch_SAM_robust32_avge6e8e9e10_manylayers_324x288'
-    return ['blocks', 'blocks.0', 'blocks.0.0', 'blocks.0.1', 
-    'blocks.1', 'blocks.1.0', 'blocks.1.1', 'blocks.1.2', 
-    'blocks.2', 'blocks.2.0', 'blocks.2.1', 'blocks.2.2', 
-    'blocks.3', 'blocks.3.0', 'blocks.3.1', 'blocks.3.2', 'blocks.3.3',
-    'blocks.4', 'blocks.4.0', 
-    'blocks.4.0.conv_pw', 'blocks.4.0.conv_dw', 'blocks.4.0.conv_pwl', 'blocks.4.1', 'blocks.4.1.conv_pw', 'blocks.4.1.conv_dw', 'blocks.4.1.conv_pwl', 'blocks.4.2', 
-    'blocks.4.2.conv_pw', 'blocks.4.2.conv_dw', 'blocks.4.2.conv_pwl', 'blocks.4.3', 'blocks.4.3.conv_pw', 'blocks.4.3.conv_dw', 'blocks.4.3.conv_pwl', 'blocks.5', 
-    'blocks.5.0', 'blocks.5.0.conv_pw', 'blocks.5.0.conv_dw', 'blocks.5.0.conv_pwl', 'blocks.5.1', 'blocks.5.1.conv_pw', 'blocks.5.1.conv_dw', 'blocks.5.1.conv_pwl', 
-    'blocks.5.2', 'blocks.5.2.conv_pw', 'blocks.5.2.conv_dw', 'blocks.5.2.conv_pwl', 'blocks.5.3', 'blocks.5.3.conv_pw', 'blocks.5.3.conv_dw', 'blocks.5.3.conv_pwl', 
-    'blocks.5.4', 'blocks.5.4.conv_pw', 'blocks.5.4.conv_dw', 'blocks.5.4.conv_pwl', 'blocks.6', 'blocks.6.0', 'blocks.6.0.conv_pw', 'blocks.6.0.conv_dw', 
-    'blocks.6.0.conv_pwl', 'blocks.6.1', 'blocks.6.1.conv_pw', 'blocks.6.1.conv_dw', 'blocks.6.1.conv_pwl',
-    'global_pool', 'global_pool.flatten', 'global_pool.pool']
-
-def get_bibtex(model_identifier):
-    return """@InProceedings{pmlr-v97-tan19a,
-                title = 	 {{E}fficient{N}et: Rethinking Model Scaling for Convolutional Neural Networks},
-                author =       {Tan, Mingxing and Le, Quoc},
-                booktitle = 	 {Proceedings of the 36th International Conference on Machine Learning},
-                pages = 	 {6105--6114},
-                year = 	 {2019},
-                editor = 	 {Chaudhuri, Kamalika and Salakhutdinov, Ruslan},
-                volume = 	 {97},
-                series = 	 {Proceedings of Machine Learning Research},
-                month = 	 {09--15 Jun},
-                publisher =    {PMLR},
-                pdf = 	 {http://proceedings.mlr.press/v97/tan19a/tan19a.pdf},
-                url = 	 {https://proceedings.mlr.press/v97/tan19a.html},
-                abstract = 	 {Convolutional Neural Networks (ConvNets) are commonly developed at a fixed resource budget, and then scaled up for better accuracy if more resources are given. In this paper, we systematically study model scaling and identify that carefully balancing network depth, width, and resolution can lead to better performance. Based on this observation, we propose a new scaling method that uniformly scales all dimensions of depth/width/resolution using a simple yet highly effective compound coefficient. We demonstrate the effectiveness of this method on MobileNets and ResNet. To go even further, we use neural architecture search to design a new baseline network and scale it up to obtain a family of models, called EfficientNets, which achieve much better accuracy and efficiency than previous ConvNets. In particular, our EfficientNet-B7 achieves stateof-the-art 84.4% top-1 / 97.1% top-5 accuracy on ImageNet, while being 8.4x smaller and 6.1x faster on inference than the best existing ConvNet (Huang et al., 2018). Our EfficientNets also transfer well and achieve state-of-the-art accuracy on CIFAR-100 (91.7%), Flower (98.8%), and 3 other transfer learning datasets, with an order of magnitude fewer parameters.}
-                }"""
-
-
-if __name__ == '__main__':
-    check_models.check_base_models(__name__)
+import functools
+
+import torch
+from brainscore_vision.model_helpers.activations import PytorchWrapper
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+from brainscore_vision.model_helpers.s3 import load_weight_file
+from PIL import Image
+import numpy as np
+import timm
+from timm.data import resolve_data_config
+from timm.data.transforms_factory import create_transform
+import torch.nn as nn
+from albumentations import (
+    Compose, Normalize, Resize,CenterCrop
+    )
+from albumentations.pytorch import ToTensorV2
+# This is an example implementation for submitting alexnet as a pytorch model
+# If you use pytorch, don't forget to add it to the setup.py
+
+# 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
+
+import os 
+
+image_resize = 324
+image_crop = 288
+norm_mean = [0.485, 0.456, 0.406] 
+norm_std = [0.229, 0.224, 0.225]
+freeze_layers = ['blocks.0.0', 'blocks.0.1', 'blocks.1.0', 
+                'blocks.1.1', 'blocks.1.2', 'blocks.2.0', 
+                'blocks.2.1', 'blocks.2.2', 'blocks.3.0', 'blocks.3.1', 'blocks.3.2']
+
+def custom_image_preprocess(images, **kwargs):
+    
+    transforms_val = Compose([
+        Resize(image_resize, image_resize),
+        CenterCrop(image_crop, image_crop),
+        Normalize(mean=norm_mean,std=norm_std,),
+        ToTensorV2()])
+    
+    images = [np.array(pillow_image) for pillow_image in images]
+    images = [transforms_val(image=image)["image"] for image in images]
+    images = np.stack(images)
+
+    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 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
+
+class EffNetBX(nn.Module):
+    def __init__(self,):
+        super().__init__ ()
+        self.efnet_model = timm.create_model('tf_efficientnet_b1_ns', pretrained=True)
+
+    def forward(self, x):
+        x = self.efnet_model(x)
+        return x
+
+def get_model(name):
+    assert name == 'effnetb1_cutmixpatch_SAM_robust32_avge6e8e9e10_manylayers_324x288'
+    model_tf_efficientnet_b1_ns= EffNetBX()
+    
+    weights_path = load_weight_file(bucket="brainscore-storage", folder_name="brainscore-vision/models",
+                                    relative_path="effnetb1_cutmixpatch_SAM_robust32_avge6e8e9e10_manylayers_324x288/tf_efficientnet_b1_ns_robust_cutmixpatchresize_SAM_e6e8e9e10.pth",
+                                    version_id="null",
+                                    sha1="9d60e49043b2d5354447c46cd011764cc6cf094e")
+    model_tf_efficientnet_b1_ns.load_state_dict(torch.load(weights_path, map_location=torch.device('cpu'))["model"])
+    model = model_tf_efficientnet_b1_ns.efnet_model
+    filter_elems = set(["se", "act", "bn", "conv"])
+    layer_list = [layer for layer, _ in model.named_modules() if not any(i in layer for i in filter_elems)]
+    print(layer_list)
+    print(len(layer_list))
+    
+    for n, m in model.named_modules():
+      if isinstance(m, nn.BatchNorm2d) and any(x in n for x in ["conv_stem" ] + freeze_layers) or n =="bn1":
+        print(f"Freeze {n, m}")
+        m.eval()
+    
+    
+    preprocessing = functools.partial(load_preprocess_images_custom, 
+                                        preprocess_images=custom_image_preprocess,
+                                        )
+
+
+    wrapper = PytorchWrapper(identifier='my-model', model=model, preprocessing=preprocessing, batch_size=8)
+
+    wrapper.image_size = image_crop
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'effnetb1_cutmixpatch_SAM_robust32_avge6e8e9e10_manylayers_324x288'
+    return ['blocks', 'blocks.0', 'blocks.0.0', 'blocks.0.1', 
+    'blocks.1', 'blocks.1.0', 'blocks.1.1', 'blocks.1.2', 
+    'blocks.2', 'blocks.2.0', 'blocks.2.1', 'blocks.2.2', 
+    'blocks.3', 'blocks.3.0', 'blocks.3.1', 'blocks.3.2', 'blocks.3.3',
+    'blocks.4', 'blocks.4.0', 
+    'blocks.4.0.conv_pw', 'blocks.4.0.conv_dw', 'blocks.4.0.conv_pwl', 'blocks.4.1', 'blocks.4.1.conv_pw', 'blocks.4.1.conv_dw', 'blocks.4.1.conv_pwl', 'blocks.4.2', 
+    'blocks.4.2.conv_pw', 'blocks.4.2.conv_dw', 'blocks.4.2.conv_pwl', 'blocks.4.3', 'blocks.4.3.conv_pw', 'blocks.4.3.conv_dw', 'blocks.4.3.conv_pwl', 'blocks.5', 
+    'blocks.5.0', 'blocks.5.0.conv_pw', 'blocks.5.0.conv_dw', 'blocks.5.0.conv_pwl', 'blocks.5.1', 'blocks.5.1.conv_pw', 'blocks.5.1.conv_dw', 'blocks.5.1.conv_pwl', 
+    'blocks.5.2', 'blocks.5.2.conv_pw', 'blocks.5.2.conv_dw', 'blocks.5.2.conv_pwl', 'blocks.5.3', 'blocks.5.3.conv_pw', 'blocks.5.3.conv_dw', 'blocks.5.3.conv_pwl', 
+    'blocks.5.4', 'blocks.5.4.conv_pw', 'blocks.5.4.conv_dw', 'blocks.5.4.conv_pwl', 'blocks.6', 'blocks.6.0', 'blocks.6.0.conv_pw', 'blocks.6.0.conv_dw', 
+    'blocks.6.0.conv_pwl', 'blocks.6.1', 'blocks.6.1.conv_pw', 'blocks.6.1.conv_dw', 'blocks.6.1.conv_pwl',
+    'global_pool', 'global_pool.flatten', 'global_pool.pool']
+
+def get_bibtex(model_identifier):
+    return """@InProceedings{pmlr-v97-tan19a,
+                title = 	 {{E}fficient{N}et: Rethinking Model Scaling for Convolutional Neural Networks},
+                author =       {Tan, Mingxing and Le, Quoc},
+                booktitle = 	 {Proceedings of the 36th International Conference on Machine Learning},
+                pages = 	 {6105--6114},
+                year = 	 {2019},
+                editor = 	 {Chaudhuri, Kamalika and Salakhutdinov, Ruslan},
+                volume = 	 {97},
+                series = 	 {Proceedings of Machine Learning Research},
+                month = 	 {09--15 Jun},
+                publisher =    {PMLR},
+                pdf = 	 {http://proceedings.mlr.press/v97/tan19a/tan19a.pdf},
+                url = 	 {https://proceedings.mlr.press/v97/tan19a.html},
+                abstract = 	 {Convolutional Neural Networks (ConvNets) are commonly developed at a fixed resource budget, and then scaled up for better accuracy if more resources are given. In this paper, we systematically study model scaling and identify that carefully balancing network depth, width, and resolution can lead to better performance. Based on this observation, we propose a new scaling method that uniformly scales all dimensions of depth/width/resolution using a simple yet highly effective compound coefficient. We demonstrate the effectiveness of this method on MobileNets and ResNet. To go even further, we use neural architecture search to design a new baseline network and scale it up to obtain a family of models, called EfficientNets, which achieve much better accuracy and efficiency than previous ConvNets. In particular, our EfficientNet-B7 achieves stateof-the-art 84.4% top-1 / 97.1% top-5 accuracy on ImageNet, while being 8.4x smaller and 6.1x faster on inference than the best existing ConvNet (Huang et al., 2018). Our EfficientNets also transfer well and achieve state-of-the-art accuracy on CIFAR-100 (91.7%), Flower (98.8%), and 3 other transfer learning datasets, with an order of magnitude fewer parameters.}
+                }"""
+
+
+if __name__ == '__main__':
+    check_models.check_base_models(__name__)

brainscore_vision/models/effnetb1_cutmixpatch_augmix_robust32_avge4e7_manylayers_324x288/model.py

@@ -70,9 +70,9 @@ class EffNetBX(nn.Module):
 def get_model(name):
     assert name == 'effnetb1_cutmixpatch_augmix_robust32_avge4e7_manylayers_324x288'
     model_tf_efficientnet_b1_ns = EffNetBX()
-    weights_path = load_weight_file(bucket="brainscore-vision", folder_name="models",
+    weights_path = load_weight_file(bucket="brainscore-storage", folder_name="brainscore-vision/models",
                                     relative_path="effnetb1_cutmixpatch_augmix_robust32_avge4e7_manylayers_324x288/tf_efficientnet_b1_ns_robust_cutmixpatchresize_augmix_e4toe7.pth",
-                                    version_id="iB0UqbguDpYHD0HRbMt1F1er3c414yWr",
+                                    version_id="null",
                                     sha1="37f3ac1b14e80cfaa99fa5f412c1e132480ed5b6")
 
     model_tf_efficientnet_b1_ns.load_state_dict(torch.load(weights_path,map_location=torch.device('cpu'))["model"])