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

brainscore_vision/data_helpers/s3.py

@@ -19,16 +19,20 @@ from brainio.stimuli import StimulusSetLoader, StimulusSet
 _logger = logging.getLogger(__name__)
 
 
-def get_path(identifier: str, file_type: str, bucket: str, version_id: str, sha1: str, filename_prefix: str = None):
+def get_path(identifier: str, file_type: str, bucket: str, version_id: str, sha1: str, filename_prefix: str = None, folder_name: str = None):
     """
     Finds path of desired file (for .csvs, .zips, and .ncs).
     """
     if filename_prefix is None:
         filename_prefix = 'stimulus_' if file_type in ('csv', 'zip') else 'assy_'
-
+    
     filename = f"{filename_prefix}{identifier.replace('.', '_')}.{file_type}"
+    if folder_name:
+        remote_path = f"{folder_name}/{filename}"
+    else:
+        remote_path = filename
     file_path = fetch_file(location_type="S3",
-                           location=f"https://{bucket}.s3.amazonaws.com/{filename}",
+                           location=f"https://{bucket}.s3.amazonaws.com/{remote_path}",
                            version_id=version_id,
                            sha1=sha1)
     return file_path
@@ -37,7 +41,16 @@ def get_path(identifier: str, file_type: str, bucket: str, version_id: str, sha1
 def load_assembly_from_s3(identifier: str, version_id: str, sha1: str, bucket: str, cls: type,
                           stimulus_set_loader: Callable[[], StimulusSet] = None,
                           merge_stimulus_set_meta: bool = True) -> DataAssembly:
-    file_path = get_path(identifier, 'nc', bucket, version_id, sha1)
+    """
+    Load a data assembly from S3, optionally within a specific folder.
+    """
+    # Parse bucket name and folder name
+    if '/' in bucket:
+        folder_name = bucket.split('/')[1]
+        bucket = bucket.split('/')[0]
+    else:
+        folder_name = None
+    file_path = get_path(identifier, 'nc', bucket, version_id, sha1, folder_name=folder_name)
     if stimulus_set_loader:  # merge stimulus set meta into assembly if `stimulus_set_loader` is passed
         stimulus_set = stimulus_set_loader()
         loader_base_class = StimulusMergeAssemblyLoader if merge_stimulus_set_meta else StimulusReferenceAssemblyLoader
@@ -53,8 +66,14 @@ def load_assembly_from_s3(identifier: str, version_id: str, sha1: str, bucket: s
 
 def load_stimulus_set_from_s3(identifier: str, bucket: str, csv_sha1: str, zip_sha1: str,
                               csv_version_id: str, zip_version_id: str, filename_prefix: str = None):
-    csv_path = get_path(identifier, 'csv', bucket, csv_version_id, csv_sha1, filename_prefix=filename_prefix)
-    zip_path = get_path(identifier, 'zip', bucket, zip_version_id, zip_sha1, filename_prefix=filename_prefix)
+    # Parse bucket name and folder name
+    if '/' in bucket:
+        folder_name = bucket.split('/')[1]
+        bucket = bucket.split('/')[0]
+    else:
+        folder_name = None
+    csv_path = get_path(identifier, 'csv', bucket, csv_version_id, csv_sha1, filename_prefix=filename_prefix, folder_name=folder_name)
+    zip_path = get_path(identifier, 'zip', bucket, zip_version_id, zip_sha1, filename_prefix=filename_prefix, folder_name=folder_name)
     stimuli_directory = unzip(zip_path)
     loader = StimulusSetLoader(
         csv_path=csv_path,

brainscore_vision/model_helpers/activations/pytorch.py

@@ -137,16 +137,38 @@ def preprocess_images(images, image_size, **kwargs):
 
 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)):
+    preprocess_type = kwargs.get('preprocess_type', 'imagenet').lower()
+    if preprocess_type == 'imagenet':
+        return transforms.Compose([
+            transforms.Resize((image_size, image_size)),
+            torchvision_preprocess(**kwargs),
+        ])
+    elif preprocess_type == 'inception':  # inception-style resize
+        resize_size = int(image_size * 256 / 224)
+        return transforms.Compose([
+            transforms.Resize(resize_size),
+            transforms.CenterCrop(image_size),
+            torchvision_preprocess(preprocess_type='inception')
+        ])
+    else:
+        raise ValueError(f"Unknown preprocess_type '{preprocess_type}'")
+
+
+def torchvision_preprocess(preprocess_type="imagenet", **kwargs):
     from torchvision import transforms
-    return transforms.Compose([
-        transforms.ToTensor(),
-        transforms.Normalize(mean=normalize_mean, std=normalize_std),
-        lambda img: img.unsqueeze(0)
-    ])
+    if preprocess_type == "imagenet":
+        normalize_mean = kwargs.get('normalize_mean', (0.485, 0.456, 0.406))
+        normalize_std = kwargs.get('normalize_std', (0.229, 0.224, 0.225))
+        return transforms.Compose([
+            transforms.ToTensor(),
+            transforms.Normalize(mean=normalize_mean, std=normalize_std),
+            lambda img: img.unsqueeze(0)
+        ])
+    elif preprocess_type == "inception":
+        return transforms.Compose([
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
+            lambda img: img.unsqueeze(0)
+        ])
+    else:
+        raise ValueError(f"Unknown preprocess_type '{preprocess_type}'")

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

brainscore_vision/models/AT_efficientnet_b2/model.py

@@ -0,0 +1,58 @@
+import functools
+from efficientnet_pytorch import EfficientNet
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+from brainscore_vision.model_helpers.check_submission import check_models
+
+
+def get_model(name):
+    assert name == 'AT_efficientnet-b2'
+    model = EfficientNet.from_pretrained("efficientnet-b2", advprop=True)
+    model.set_swish(memory_efficient=False)
+    preprocessing = functools.partial(load_preprocess_images, image_size=224, normalize_mean=(0.5, 0.5, 0.5), normalize_std=(0.5, 0.5, 0.5))
+    wrapper = PytorchWrapper(identifier=name, model=model, preprocessing=preprocessing)
+    from types import MethodType
+    def _output_layer(self):
+        return self._model._fc
+
+    wrapper._output_layer = MethodType(_output_layer, wrapper)
+    wrapper.image_size = 224
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'AT_efficientnet-b2'
+    return [
+        '_blocks.0',
+        '_blocks.1',
+        '_blocks.2',
+        '_blocks.3',
+        '_blocks.4',
+        '_blocks.5',
+        '_blocks.6',
+        '_blocks.7',
+        '_blocks.8',
+        '_blocks.9',
+        '_blocks.10',
+        '_blocks.11',
+        '_blocks.12',
+        '_blocks.13',
+        '_blocks.14',
+        '_blocks.15',
+        '_blocks.16',
+        '_blocks.17',
+        '_blocks.18',
+        '_blocks.19',
+        '_blocks.20',
+        '_blocks.21',
+        '_blocks.22',
+    ]
+
+def get_bibtex(model_identifier):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return ''
+
+if __name__ == '__main__':
+    check_models.check_base_models(__name__)

brainscore_vision/models/AT_efficientnet_b2/region_layer_map/AT_efficientnet-b2.json

@@ -0,0 +1,6 @@
+{
+    "V1": "_blocks.12",
+    "V2": "_blocks.17",
+    "V4": "_blocks.12",
+    "IT": "_blocks.16"
+}

brainscore_vision/models/AT_efficientnet_b2/requirements.txt

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

brainscore_vision/models/AT_efficientnet_b2/test.py

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

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

brainscore_vision/models/AdvProp_efficientnet_b2/model.py

@@ -0,0 +1,64 @@
+import functools
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.check_submission import check_models
+from efficientnet_pytorch import EfficientNet
+from types import MethodType
+
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
+
+def get_model(name):
+    """
+    This method fetches an instance of a base model. The instance has to be callable and return a xarray object,
+    containing activations. There exist standard wrapper implementations for common libraries, like pytorch and
+    keras. Checkout the examples folder, to see more. For custom implementations check out the implementation of the
+    wrappers.
+    :param name: the name of the model to fetch
+    :return: the model instance
+    """
+    assert name == 'AdvProp_efficientnet-b2'
+    model = EfficientNet.from_pretrained('efficientnet-b2', advprop=True)
+    model.set_swish(memory_efficient=False)
+    preprocessing = functools.partial(load_preprocess_images, image_size=224, normalize_mean=(0.5, 0.5, 0.5), normalize_std=(0.5, 0.5, 0.5))
+    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 == 'AdvProp_efficientnet-b2'
+    return [f'_blocks.{i}' for i in range(23)]
+
+
+def get_bibtex(model_identifier):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    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__':
+    # Use this method to ensure the correctness of the BaseModel implementations.
+    # It executes a mock run of brain-score benchmarks.
+    check_models.check_base_models(__name__)

brainscore_vision/models/AdvProp_efficientnet_b2/region_layer_map/AdvProp_efficientnet-b2.json

@@ -0,0 +1 @@
+{"IT": "_blocks.16", "V1": "_blocks.12", "V4": "_blocks.12", "V2": "_blocks.17"}

brainscore_vision/models/AdvProp_efficientnet_b2/requirements.txt

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

brainscore_vision/models/AdvProp_efficientnet_b2/test.py

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

brainscore_vision/models/AdvProp_efficientnet_b4/__init__.py

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

brainscore_vision/models/AdvProp_efficientnet_b4/model.py

@@ -0,0 +1,65 @@
+import functools
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.check_submission import check_models
+from efficientnet_pytorch import EfficientNet
+from types import MethodType
+
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
+
+def get_model(name):
+    """
+    This method fetches an instance of a base model. The instance has to be callable and return a xarray object,
+    containing activations. There exist standard wrapper implementations for common libraries, like pytorch and
+    keras. Checkout the examples folder, to see more. For custom implementations check out the implementation of the
+    wrappers.
+    :param name: the name of the model to fetch
+    :return: the model instance
+    """
+    assert name == 'AdvProp_efficientnet-b4'
+    model = EfficientNet.from_pretrained('efficientnet-b4', advprop=True)
+    model.set_swish(memory_efficient=False)
+
+    preprocessing = functools.partial(load_preprocess_images, image_size=224, normalize_mean=(0.5, 0.5, 0.5), normalize_std=(0.5, 0.5, 0.5))
+    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 == 'AdvProp_efficientnet-b4'
+    return [f'_blocks.{i}' for i in range(32)]
+
+
+def get_bibtex(model_identifier):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    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__':
+    # Use this method to ensure the correctness of the BaseModel implementations.
+    # It executes a mock run of brain-score benchmarks.
+    check_models.check_base_models(__name__)

brainscore_vision/models/AdvProp_efficientnet_b4/region_layer_map/AdvProp_efficientnet-b4.json

@@ -0,0 +1 @@
+{"IT": "_blocks.22", "V1": "_blocks.10", "V4": "_blocks.10", "V2": "_blocks.10"}

brainscore_vision/models/AdvProp_efficientnet_b4/requirements.txt

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

brainscore_vision/models/AdvProp_efficientnet_b4/test.py

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

brainscore_vision/models/AdvProp_efficientnet_b7/__init__.py

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

brainscore_vision/models/AdvProp_efficientnet_b7/model.py

@@ -0,0 +1,65 @@
+import functools
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.check_submission import check_models
+from efficientnet_pytorch import EfficientNet
+from types import MethodType
+
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
+
+def get_model(name):
+    """
+    This method fetches an instance of a base model. The instance has to be callable and return a xarray object,
+    containing activations. There exist standard wrapper implementations for common libraries, like pytorch and
+    keras. Checkout the examples folder, to see more. For custom implementations check out the implementation of the
+    wrappers.
+    :param name: the name of the model to fetch
+    :return: the model instance
+    """
+    assert name == 'AdvProp_efficientnet-b7'
+    model = EfficientNet.from_pretrained('efficientnet-b7', advprop=True)
+    model.set_swish(memory_efficient=False)
+
+    preprocessing = functools.partial(load_preprocess_images, image_size=224, normalize_mean=(0.5, 0.5, 0.5), normalize_std=(0.5, 0.5, 0.5))
+    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 == 'AdvProp_efficientnet-b7'
+    return [f'_blocks.{i}' for i in range(55)]
+
+
+def get_bibtex(model_identifier):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    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__':
+    # Use this method to ensure the correctness of the BaseModel implementations.
+    # It executes a mock run of brain-score benchmarks.
+    check_models.check_base_models(__name__)

brainscore_vision/models/AdvProp_efficientnet_b7/region_layer_map/AdvProp_efficientnet-b7.json

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

brainscore_vision/models/AdvProp_efficientnet_b7/requirements.txt

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

brainscore_vision/models/AdvProp_efficientnet_b7/test.py

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

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

brainscore_vision/models/AdvProp_efficientnet_b8/model.py

@@ -0,0 +1,65 @@
+import functools
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.check_submission import check_models
+from efficientnet_pytorch import EfficientNet
+from types import MethodType
+
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
+
+def get_model(name):
+    """
+    This method fetches an instance of a base model. The instance has to be callable and return a xarray object,
+    containing activations. There exist standard wrapper implementations for common libraries, like pytorch and
+    keras. Checkout the examples folder, to see more. For custom implementations check out the implementation of the
+    wrappers.
+    :param name: the name of the model to fetch
+    :return: the model instance
+    """
+    assert name == 'AdvProp_efficientnet-b8'
+    model = EfficientNet.from_pretrained('efficientnet-b8', advprop=True)
+    model.set_swish(memory_efficient=False)
+
+    preprocessing = functools.partial(load_preprocess_images, image_size=224, normalize_mean=(0.5, 0.5, 0.5), normalize_std=(0.5, 0.5, 0.5))
+    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 == 'AdvProp_efficientnet-b8'
+    return [f'_blocks.{i}' for i in range(61)]
+
+
+def get_bibtex(model_identifier):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    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__':
+    # Use this method to ensure the correctness of the BaseModel implementations.
+    # It executes a mock run of brain-score benchmarks.
+    check_models.check_base_models(__name__)

brainscore_vision/models/AdvProp_efficientnet_b8/region_layer_map/AdvProp_efficientnet-b8.json

@@ -0,0 +1 @@
+{"IT": "_blocks.42", "V1": "_blocks.14", "V2": "_blocks.21", "V4": "_blocks.20"}

brainscore_vision/models/AdvProp_efficientnet_b8/requirements.txt

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

brainscore_vision/models/AdvProp_efficientnet_b8/test.py

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

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