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

brainscore_vision/models/alexnet_training_seed_01/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_01']
+
+def get_model(name):
+    assert name == 'alexnet_training_seed_01'
+    
+
+    model = alexnet_v2_pytorch()
+
+  
+    weights_path = load_weight_file(bucket = "brainscorevariability", relative_path = "model_weights/training_seed_01.pth", version_id = None, sha1 = "4b1bb7810d5288631c04cf4cde882540d6ebee77" )
+    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_01', model=model, preprocessing=preprocessing)
+   
+    return wrapper
+
+def get_layers(name):
+    assert name == 'alexnet_training_seed_01'
+    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_01/region_layer_map/alexnet_training_seed_01.json

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

brainscore_vision/models/alexnet_training_seed_01/requirements.txt

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

brainscore_vision/models/alexnet_training_seed_01/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_01')
+    assert model.identifier == 'alexnet_training_seed_01'
+    

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

brainscore_vision/models/alexnet_training_seed_02/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_02']
+
+def get_model(name):
+    assert name == 'alexnet_training_seed_02'
+    
+
+    model = alexnet_v2_pytorch()
+
+  
+    weights_path = load_weight_file(bucket = "brainscorevariability", relative_path = "model_weights/training_seed_02.pth", version_id = None, sha1 = "4dd6fa8ed3edf7f505473e5006748781e47d5f37" )
+    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_02', model=model, preprocessing=preprocessing)
+   
+    return wrapper
+
+def get_layers(name):
+    assert name == 'alexnet_training_seed_02'
+    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_02/region_layer_map/alexnet_training_seed_02.json

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

brainscore_vision/models/alexnet_training_seed_02/requirements.txt

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

brainscore_vision/models/alexnet_training_seed_02/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_02')
+    assert model.identifier == 'alexnet_training_seed_02'
+    

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

brainscore_vision/models/alexnet_training_seed_03/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_03']
+
+def get_model(name):
+    assert name == 'alexnet_training_seed_03'
+    
+
+    model = alexnet_v2_pytorch()
+
+  
+    weights_path = load_weight_file(bucket = "brainscorevariability", relative_path = "model_weights/training_seed_03.pth", version_id = None, sha1 = "6c5a1fdadc70e5007c66866400bfcd7c17280fa8" )
+    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_03', model=model, preprocessing=preprocessing)
+   
+    return wrapper
+
+def get_layers(name):
+    assert name == 'alexnet_training_seed_03'
+    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_03/region_layer_map/alexnet_training_seed_03.json

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

brainscore_vision/models/alexnet_training_seed_03/requirements.txt

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

brainscore_vision/models/alexnet_training_seed_03/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_03')
+    assert model.identifier == 'alexnet_training_seed_03'
+    

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

brainscore_vision/models/alexnet_training_seed_04/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_04']
+
+def get_model(name):
+    assert name == 'alexnet_training_seed_04'
+    
+
+    model = alexnet_v2_pytorch()
+
+  
+    weights_path = load_weight_file(bucket = "brainscorevariability", relative_path = "model_weights/training_seed_04.pth", version_id = None, sha1 = "1659290229b7712ee450e6805f4a8a880ecb2a97" )
+    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_04', model=model, preprocessing=preprocessing)
+   
+    return wrapper
+
+def get_layers(name):
+    assert name == 'alexnet_training_seed_04'
+    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_04/region_layer_map/alexnet_training_seed_04.json

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

brainscore_vision/models/alexnet_training_seed_04/requirements.txt

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

brainscore_vision/models/alexnet_training_seed_04/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_04')
+    assert model.identifier == 'alexnet_training_seed_04'
+