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

brainscore_vision/models/alexnet_training_seed_08/test.py

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

brainscore_vision/models/alexnet_training_seed_09/__init__.py

@@ -0,0 +1,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['alexnet_training_seed_09'] = lambda: ModelCommitment(identifier='alexnet_training_seed_09', activations_model=get_model('alexnet_training_seed_09'), layers=get_layers('alexnet_training_seed_09'))
+    

brainscore_vision/models/alexnet_training_seed_09/model.py

@@ -0,0 +1,140 @@
+import torch
+import torch.nn as nn
+import numpy as np
+from brainscore_vision.model_helpers.s3 import load_weight_file, sha1_hash
+from brainscore_vision.model_helpers.check_submission import check_models
+import functools
+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.brain_transformation import ModelCommitment
+
+def alexnet_v2_pytorch(num_classes=1000, dropout_keep_prob=0.5, global_pool=False):
+    """
+    Instantiate the AlexNetV2 model in PyTorch.
+    """
+    class AlexNetV2(nn.Module):
+        def __init__(self, num_classes, dropout_keep_prob, global_pool):
+            super(AlexNetV2, self).__init__()
+            self.global_pool = global_pool
+
+            # Convolutional layers
+            self.features = nn.Sequential(
+                #conv1
+                nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=0),
+                nn.ReLU(inplace=True),
+                nn.MaxPool2d(kernel_size=3, stride=2),
+
+                #conv2
+                nn.Conv2d(64, 192, kernel_size=5, stride=1, padding=2),
+                nn.ReLU(inplace=True),
+                nn.MaxPool2d(kernel_size=3, stride=2),
+
+                #conv3
+                nn.Conv2d(192, 384, kernel_size=3, stride=1, padding=1),
+                nn.ReLU(inplace=True),
+
+                #conv4
+                nn.Conv2d(384, 384, kernel_size=3, stride=1, padding=1),
+                nn.ReLU(inplace=True),
+
+                #conv5
+                nn.Conv2d(384, 256, kernel_size=3, stride=1, padding=1),
+                nn.ReLU(inplace=True),
+                nn.MaxPool2d(kernel_size=3, stride=2)
+            )
+
+            # Fully connected layers
+            self.classifier = nn.Sequential(
+                #fc6
+                nn.Conv2d(256, 4096, kernel_size=5, stride=1, padding=0),
+                nn.ReLU(inplace=True),
+                nn.Dropout(p=1 - dropout_keep_prob),
+
+                #fc7
+                nn.Conv2d(4096, 4096, kernel_size=1, stride=1, padding=0),
+                nn.ReLU(inplace=True),
+                nn.Dropout(p=1 - dropout_keep_prob),
+
+                #fc8
+                nn.Conv2d(4096, num_classes, kernel_size=1, stride=1, padding=0)
+            )
+
+        def forward(self, x):
+            x = self.features(x)
+            if self.global_pool:
+                x = nn.functional.adaptive_avg_pool2d(x, (1, 1))
+            x = self.classifier(x)
+            x = torch.flatten(x, start_dim=1)
+            return x
+
+  # Instantiate and return the AlexNetV2 model
+    return AlexNetV2(num_classes, dropout_keep_prob, global_pool)
+
+def get_model_list():
+    return ['alexnet_training_seed_09']
+
+def get_model(name):
+    assert name == 'alexnet_training_seed_09'
+    
+
+    model = alexnet_v2_pytorch()
+
+  
+    weights_path = load_weight_file(bucket = "brainscorevariability", relative_path = "model_weights/training_seed_09.pth", version_id = None, sha1 = "99da889e537c56df9984862d73751e23ecbdef82" )
+    state_dict = torch.load(weights_path, map_location='cpu') 
+    model_weights = state_dict  
+    model.load_state_dict(model_weights)
+
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    
+    def layer_output_hook(layer):
+        def hook_function(module, input, output):
+            if isinstance(output, tuple):  
+                return output[0]
+            return output
+        return hook_function
+
+    layer_mapping = {
+    'features.0': model.features[0],     # conv1
+    'features.3': model.features[3],     # conv2
+    'features.6': model.features[6],     # conv3
+    'features.8': model.features[8],     # conv4
+    'features.10': model.features[10],  # conv5
+    'classifier.0': model.classifier[0],  # fc6
+    'classifier.3': model.classifier[3],  # fc7
+    }
+
+    for layer_name, layer in layer_mapping.items():
+        layer.register_forward_hook(layer_output_hook(layer))
+
+  
+    wrapper = PytorchWrapper(identifier='alexnet_training_seed_09', model=model, preprocessing=preprocessing)
+   
+    return wrapper
+
+def get_layers(name):
+    assert name == 'alexnet_training_seed_09'
+    return ['features.0',  # conv1
+        'features.3',  # conv2
+        'features.6',  # conv3
+        'features.8',  # conv4
+        'features.10',  # conv5
+        'classifier.0',  # fc6
+        'classifier.3',  # fc7
+           ]
+
+def get_bibtex(model_identifier):
+    return """  
+                Model introduced in:
+                @misc{Mehrer_2020,
+                title={Individual differences among deep neural network models},
+                url={osf.io/3xupm},
+                DOI={10.17605/OSF.IO/3XUPM},
+                publisher={OSF},
+                author={Mehrer, Johannes},
+                year={2020},
+                month={Oct}
+}"""
+
+if __name__ == '__main__':
+    check_models.check_base_models(__name__)

brainscore_vision/models/alexnet_training_seed_09/region_layer_map/alexnet_training_seed_09.json

@@ -0,0 +1,6 @@
+{
+    "V1": "features.6",
+    "V2": "classifier.0",
+    "V4": "features.3",
+    "IT": "features.6"
+}

brainscore_vision/models/alexnet_training_seed_09/requirements.txt

@@ -0,0 +1,3 @@
+torch
+torchvision
+numpy

brainscore_vision/models/alexnet_training_seed_09/test.py

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

brainscore_vision/models/alexnet_training_seed_10/__init__.py

@@ -0,0 +1,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['alexnet_training_seed_10'] = lambda: ModelCommitment(identifier='alexnet_training_seed_10', activations_model=get_model('alexnet_training_seed_10'), layers=get_layers('alexnet_training_seed_10'))
+    

brainscore_vision/models/alexnet_training_seed_10/model.py

@@ -0,0 +1,140 @@
+import torch
+import torch.nn as nn
+import numpy as np
+from brainscore_vision.model_helpers.s3 import load_weight_file, sha1_hash
+from brainscore_vision.model_helpers.check_submission import check_models
+import functools
+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.brain_transformation import ModelCommitment
+
+def alexnet_v2_pytorch(num_classes=1000, dropout_keep_prob=0.5, global_pool=False):
+    """
+    Instantiate the AlexNetV2 model in PyTorch.
+    """
+    class AlexNetV2(nn.Module):
+        def __init__(self, num_classes, dropout_keep_prob, global_pool):
+            super(AlexNetV2, self).__init__()
+            self.global_pool = global_pool
+
+            # Convolutional layers
+            self.features = nn.Sequential(
+                #conv1
+                nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=0),
+                nn.ReLU(inplace=True),
+                nn.MaxPool2d(kernel_size=3, stride=2),
+
+                #conv2
+                nn.Conv2d(64, 192, kernel_size=5, stride=1, padding=2),
+                nn.ReLU(inplace=True),
+                nn.MaxPool2d(kernel_size=3, stride=2),
+
+                #conv3
+                nn.Conv2d(192, 384, kernel_size=3, stride=1, padding=1),
+                nn.ReLU(inplace=True),
+
+                #conv4
+                nn.Conv2d(384, 384, kernel_size=3, stride=1, padding=1),
+                nn.ReLU(inplace=True),
+
+                #conv5
+                nn.Conv2d(384, 256, kernel_size=3, stride=1, padding=1),
+                nn.ReLU(inplace=True),
+                nn.MaxPool2d(kernel_size=3, stride=2)
+            )
+
+            # Fully connected layers
+            self.classifier = nn.Sequential(
+                #fc6
+                nn.Conv2d(256, 4096, kernel_size=5, stride=1, padding=0),
+                nn.ReLU(inplace=True),
+                nn.Dropout(p=1 - dropout_keep_prob),
+
+                #fc7
+                nn.Conv2d(4096, 4096, kernel_size=1, stride=1, padding=0),
+                nn.ReLU(inplace=True),
+                nn.Dropout(p=1 - dropout_keep_prob),
+
+                #fc8
+                nn.Conv2d(4096, num_classes, kernel_size=1, stride=1, padding=0)
+            )
+
+        def forward(self, x):
+            x = self.features(x)
+            if self.global_pool:
+                x = nn.functional.adaptive_avg_pool2d(x, (1, 1))
+            x = self.classifier(x)
+            x = torch.flatten(x, start_dim=1)
+            return x
+
+  # Instantiate and return the AlexNetV2 model
+    return AlexNetV2(num_classes, dropout_keep_prob, global_pool)
+
+def get_model_list():
+    return ['alexnet_training_seed_10']
+
+def get_model(name):
+    assert name == 'alexnet_training_seed_10'
+    
+
+    model = alexnet_v2_pytorch()
+
+  
+    weights_path = load_weight_file(bucket = "brainscorevariability", relative_path = "model_weights/training_seed_10.pth", version_id = None, sha1 = "c7cb4182b978d1667716bd0e0dc930e2412fb483" )
+    state_dict = torch.load(weights_path, map_location='cpu') 
+    model_weights = state_dict  
+    model.load_state_dict(model_weights)
+
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    
+    def layer_output_hook(layer):
+        def hook_function(module, input, output):
+            if isinstance(output, tuple):  
+                return output[0]
+            return output
+        return hook_function
+
+    layer_mapping = {
+    'features.0': model.features[0],     # conv1
+    'features.3': model.features[3],     # conv2
+    'features.6': model.features[6],     # conv3
+    'features.8': model.features[8],     # conv4
+    'features.10': model.features[10],  # conv5
+    'classifier.0': model.classifier[0],  # fc6
+    'classifier.3': model.classifier[3],  # fc7
+    }
+
+    for layer_name, layer in layer_mapping.items():
+        layer.register_forward_hook(layer_output_hook(layer))
+
+  
+    wrapper = PytorchWrapper(identifier='alexnet_training_seed_10', model=model, preprocessing=preprocessing)
+   
+    return wrapper
+
+def get_layers(name):
+    assert name == 'alexnet_training_seed_10'
+    return ['features.0',  # conv1
+        'features.3',  # conv2
+        'features.6',  # conv3
+        'features.8',  # conv4
+        'features.10',  # conv5
+        'classifier.0',  # fc6
+        'classifier.3',  # fc7
+           ]
+
+def get_bibtex(model_identifier):
+    return """  
+                Model introduced in:
+                @misc{Mehrer_2020,
+                title={Individual differences among deep neural network models},
+                url={osf.io/3xupm},
+                DOI={10.17605/OSF.IO/3XUPM},
+                publisher={OSF},
+                author={Mehrer, Johannes},
+                year={2020},
+                month={Oct}
+}"""
+
+if __name__ == '__main__':
+    check_models.check_base_models(__name__)

brainscore_vision/models/alexnet_training_seed_10/region_layer_map/alexnet_training_seed_10.json

@@ -0,0 +1,6 @@
+{
+    "V1": "features.6",
+    "V2": "features.8",
+    "V4": "features.3",
+    "IT": "classifier.0"
+}

brainscore_vision/models/alexnet_training_seed_10/requirements.txt

@@ -0,0 +1,3 @@
+torch
+torchvision
+numpy

brainscore_vision/models/alexnet_training_seed_10/test.py

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

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

brainscore_vision/models/antialiased-r50/model.py

@@ -0,0 +1,62 @@
+from brainscore_vision.model_helpers.check_submission import check_models
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+import torchvision
+import antialiased_cnns
+import functools
+import torch
+import os
+dir_path = os.path.dirname(os.path.realpath(__file__))
+
+"""
+Template module for a base model submission to brain-score
+"""
+
+
+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 == 'antialiased-r50'
+
+    model = antialiased_cnns.resnet50(pretrained=True) 
+
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    wrapper = PytorchWrapper(identifier='antialiased-r50', model=model, preprocessing=preprocessing)
+    wrapper.image_size = 224
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'antialiased-r50'
+    """
+    This method returns a list of string layer names to consider per model. The benchmarks maps brain regions to
+    layers and uses this list as a set of possible layers. The lists doesn't have to contain all layers, the less the
+    faster the benchmark process works. Additionally the given layers have to produce an activations vector of at least
+    size 25! The layer names are delivered back to the model instance and have to be resolved in there. For a pytorch
+    model, the layer name are for instance dot concatenated per module, e.g. "features.2".
+    :param name: the name of the model, to return the layers for
+    :return: a list of strings containing all layers, that should be considered as brain area.
+    """
+    return ['maxpool', 'layer1.0', 'layer1.1', 'layer1.2', 
+        'layer2.0', 'layer2.1', 'layer2.2', 'layer2.3',
+        'layer3.0', 'layer3.1', 'layer3.2', 'layer3.3',
+         'layer3.4', 'layer3.5', 'layer4.0', 'layer4.1', 'layer4.2','avgpool']
+
+
+def get_bibtex(model_identifier):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return ''
+
+
+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/antialiased-r50/region_layer_map/antialiased-r50.json

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

brainscore_vision/models/antialiased-r50/requirements.txt

@@ -0,0 +1,3 @@
+torchvision
+antialiased_cnns
+torch

brainscore_vision/models/antialiased-r50/test.py

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

brainscore_vision/models/convnext_tiny_sup/__init__.py

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

brainscore_vision/models/convnext_tiny_sup/model.py

@@ -0,0 +1,56 @@
+from brainscore_vision.model_helpers.check_submission import check_models
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+from torchvision.models import convnext_tiny
+import functools
+import os
+dir_path = os.path.dirname(os.path.realpath(__file__))
+
+"""
+Template module for a base model submission to brain-score
+"""
+
+
+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 == 'convnext_tiny_sup'
+
+    model = convnext_tiny(weights='IMAGENET1K_V1').eval()
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    wrapper = PytorchWrapper(identifier='convnext_tiny_sup', model=model, preprocessing=preprocessing)
+    wrapper.image_size = 224
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'convnext_tiny_sup'
+    """
+    This method returns a list of string layer names to consider per model. The benchmarks maps brain regions to
+    layers and uses this list as a set of possible layers. The lists doesn't have to contain all layers, the less the
+    faster the benchmark process works. Additionally the given layers have to produce an activations vector of at least
+    size 25! The layer names are delivered back to the model instance and have to be resolved in there. For a pytorch
+    model, the layer name are for instance dot concatenated per module, e.g. "features.2".
+    :param name: the name of the model, to return the layers for
+    :return: a list of strings containing all layers, that should be considered as brain area.
+    """
+    return ['features.0.0', 'features.0.1', 'features.1.0', 'features.1.1', 'features.1.2', 'features.2.0', 'features.2.1','features.3.0', 'features.3.1', 'features.3.2',  'features.4.0', 'features.4.1', 'features.5.0', 'features.5.1', 'features.5.2', 'features.5.3', 'features.5.4', 'features.5.5', 'features.5.6', 'features.5.7', 'features.5.8','features.6.0', 'features.6.1', 'features.7.0', 'features.7.1', 'features.7.2', 'avgpool', 'classifier.0', 'classifier.1', 'classifier.2']
+
+
+def get_bibtex(model_identifier):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return ''
+
+
+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/convnext_tiny_sup/region_layer_map/convnext_tiny_sup.json

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

brainscore_vision/models/convnext_tiny_sup/requirements.txt

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

brainscore_vision/models/convnext_tiny_sup/test.py

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

brainscore_vision/models/cornet_s/model.py

@@ -33,9 +33,9 @@ def get_model(name):
     model_ctr = getattr(mod, 'CORnet_S')
     model = model_ctr()
     model = Wrapper(model)  # model was wrapped with DataParallel, so weights require `module.` prefix
-    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="cornet_s/cornet_s_epoch43.pth.tar",
-                                    version_id="4EAQnCqTy.2MCKiXTJ4l02iG8l3e.yfQ",
+                                    version_id="null",
                                     sha1="a4bfd8eda33b45fd945da1b972ab0b7cad38d60f")
     checkpoint = torch.load(weights_path, map_location=lambda storage, loc: storage)  # map onto cpu
     model.load_state_dict(checkpoint['state_dict'])

brainscore_vision/models/custom_model_cv_18_dagger_408/model.py

@@ -47,9 +47,9 @@ def load_preprocess_custom_model(image_filepaths, image_size, **kwargs):
 def get_model(name):
     assert name == 'custom_model_cv_18_dagger_408'
     model = create_model('crossvit_18_dagger_408', pretrained=False)
-    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="custom_model_cv_18_dagger_408/crossvit_18_dagger_408_adv_finetuned_epoch5.pt",
-                                    version_id="pQVPFC_iiWpRRr7P54qxQfRzjNSn2uYB",
+                                    version_id="null",
                                     sha1="c769518485e352d5a2e6f3e588d6208cbad71b69")
     checkpoint = torch.load(weights_path, map_location=torch.device('cpu'))
     model.load_state_dict(checkpoint['state_dict'], strict=True)

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

brainscore_vision/models/densenet_121/model.py

@@ -0,0 +1,63 @@
+import functools
+from torchvision.models import densenet121
+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-121'
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    model = densenet121(weights='DEFAULT')
+    wrapper = PytorchWrapper(identifier='densenet-121', model=model, preprocessing=preprocessing)
+    wrapper.image_size = 224
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'densenet-121'
+    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, 25)] + ['transition3.pool'] +
+                   [f'denseblock4.denselayer{i}' for i in range(1, 17)])
+    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_121/region_layer_map/densenet-121.json

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

brainscore_vision/models/densenet_121/requirements.txt

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

brainscore_vision/models/densenet_121/test.py

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

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