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

brainscore_vision/models/nasnet_mobile/region_layer_map/nasnet_mobile.json

@@ -0,0 +1,6 @@
+{
+    "V1": "cell_3",
+    "V2": "cell_6",
+    "V4": "cell_3",
+    "IT": "reduction_cell_1"
+}

brainscore_vision/models/nasnet_mobile/requirements.txt

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

brainscore_vision/models/nasnet_mobile/test.py

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

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

brainscore_vision/models/omnivore_swinB/model.py

@@ -0,0 +1,79 @@
+import functools
+from brainscore_vision.model_helpers.activations.pytorch import load_images, preprocess_images
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.check_submission import check_models
+import torch
+import torchvision.transforms as T
+from PIL import Image
+import numpy as np
+
+def load_preprocess_images(image_filepaths, image_size, **kwargs):
+    images = load_images(image_filepaths)
+    images = preprocess_images(images, image_size=image_size, **kwargs)
+    images = images[:, :, None, ...]
+    return images
+
+
+def preprocessing(stimuli_paths):
+    # following https://github.com/facebookresearch/omnivore/blob/main/inference_tutorial.ipynb
+    stimuli = [Image.open(image_path).convert("RGB") for image_path in stimuli_paths]
+    image_transform = T.Compose([
+        T.Resize(224),
+        T.CenterCrop(224),
+        T.ToTensor(),
+        T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    ])
+    stimuli = [image_transform(image) for image in stimuli]
+    # The model expects inputs of shape: B x C x T x H x W
+    stimuli = [image[:, None, ...] for image in stimuli]
+    return stimuli
+
+model = torch.hub.load("facebookresearch/omnivore:main", model="omnivore_swinB", force_reload=True)
+
+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 == 'omnivore_swinB'
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    wrapper = PytorchWrapper(identifier='name', model=model, preprocessing=preprocessing,forward_kwargs={"input_type":"image"})
+    wrapper.image_size = 224
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'omnivore_swinB'
+    model_blocks = {
+        "omnivore_swinT": [2, 2, 6, 2],
+        "omnivore_swinS": [2, 2, 18, 2],
+        "omnivore_swinB": [2, 2, 18, 2],
+        "omnivore_swinB_imagenet21k": [2, 2, 18, 2],
+        "omnivore_swinL_imagenet21k": [2, 2, 18, 2],
+    }
+    blocks = model_blocks[name]
+    return ['trunk.pos_drop'] + [f'trunk.layers.{layer}.blocks.{block}'
+                                 for layer, num_blocks in enumerate(blocks) for block in range(num_blocks)]
+
+
+def get_bibtex(name):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return """@inproceedings{girdhar2022omnivore,
+                 title={{Omnivore: A Single Model for Many Visual Modalities}},
+                 author={Girdhar, Rohit and Singh, Mannat and Ravi, Nikhila and van der Maaten, Laurens and Joulin, Armand and Misra, Ishan},
+                 booktitle={CVPR},
+                 year={2022},
+                 url={https://doi.org/10.48550/arXiv.2201.08377}
+               }"""
+
+
+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/omnivore_swinB/region_layer_map/omnivore_swinB.json

@@ -0,0 +1 @@
+{"V4": "trunk.layers.2.blocks.1", "IT": "trunk.layers.2.blocks.4", "V1": "trunk.layers.1.blocks.1", "V2": "trunk.layers.2.blocks.3"}

brainscore_vision/models/omnivore_swinB/requirements.txt

@@ -0,0 +1,5 @@
+torch
+einops
+iopath
+hydra-core
+timm

brainscore_vision/models/omnivore_swinB/test.py

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

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

brainscore_vision/models/omnivore_swinS/model.py

@@ -0,0 +1,79 @@
+import functools
+from brainscore_vision.model_helpers.activations.pytorch import load_images, preprocess_images
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.check_submission import check_models
+import torch
+import torchvision.transforms as T
+from PIL import Image
+import numpy as np
+
+
+def load_preprocess_images(image_filepaths, image_size, **kwargs):
+    images = load_images(image_filepaths)
+    images = preprocess_images(images, image_size=image_size, **kwargs)
+    images = images[:, :, None, ...]
+    return images
+
+
+def preprocessing(stimuli_paths):
+    # following https://github.com/facebookresearch/omnivore/blob/main/inference_tutorial.ipynb
+    stimuli = [Image.open(image_path).convert("RGB") for image_path in stimuli_paths]
+    image_transform = T.Compose([
+        T.Resize(224),
+        T.CenterCrop(224),
+        T.ToTensor(),
+        T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    ])
+    stimuli = [image_transform(image) for image in stimuli]
+    # The model expects inputs of shape: B x C x T x H x W
+    stimuli = [image[:, None, ...] for image in stimuli]
+    return stimuli
+
+
+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
+    """
+    model = torch.hub.load("facebookresearch/omnivore", model=name)
+    model.eval()
+    wrapper = PytorchWrapper(identifier=name, model=model, preprocessing=preprocessing,
+                             forward_kwargs={'input_type': 'image'})
+    wrapper.image_size = 224
+    return wrapper
+
+
+def get_layers(name):
+    model_blocks = {
+        "omnivore_swinT": [2, 2, 6, 2],
+        "omnivore_swinS": [2, 2, 18, 2],
+        "omnivore_swinB": [2, 2, 18, 2],
+        "omnivore_swinB_imagenet21k": [2, 2, 18, 2],
+        "omnivore_swinL_imagenet21k": [2, 2, 18, 2],
+    }
+    blocks = model_blocks[name]
+    return ['trunk.pos_drop'] + [f'trunk.layers.{layer}.blocks.{block}'
+                                 for layer, num_blocks in enumerate(blocks) for block in range(num_blocks)]
+
+
+def get_bibtex(name):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return """@inproceedings{girdhar2022omnivore,
+                 title={{Omnivore: A Single Model for Many Visual Modalities}},
+                 author={Girdhar, Rohit and Singh, Mannat and Ravi, Nikhila and van der Maaten, Laurens and Joulin, Armand and Misra, Ishan},
+                 booktitle={CVPR},
+                 year={2022},
+                 url={https://doi.org/10.48550/arXiv.2201.08377}
+               }"""
+
+
+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/omnivore_swinS/region_layer_map/omnivore_swinS.json

@@ -0,0 +1 @@
+{"IT": "trunk.layers.2.blocks.6", "V4": "trunk.layers.2.blocks.1", "V1": "trunk.layers.1.blocks.1", "V2": "trunk.layers.2.blocks.7"}

brainscore_vision/models/omnivore_swinS/requirements.txt

@@ -0,0 +1,7 @@
+torch
+hydra-core
+einops
+iopath
+timm
+Pillow
+pytorchvideo

brainscore_vision/models/omnivore_swinS/test.py

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

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

brainscore_vision/models/{pnasnet_large_pytorch → pnasnet_large}/model.py

@@ -21,9 +21,9 @@ implementation.
 MODEL = timm.create_model('pnasnet5large.tf_in1k', pretrained=True)
 
 def get_model(name):
-    assert name == 'pnasnet_large_pytorch'
-    preprocessing = functools.partial(load_preprocess_images, image_size=331)
-    wrapper = PytorchWrapper(identifier='pnasnet_large_pytorch', model=MODEL,
+    assert name == 'pnasnet_large'
+    preprocessing = functools.partial(load_preprocess_images, image_size=331, preprocess_type='inception')
+    wrapper = PytorchWrapper(identifier='pnasnet_large', model=MODEL,
                              preprocessing=preprocessing,
                              batch_size=4)  # doesn't fit into 12 GB GPU memory otherwise
     wrapper.image_size = 331
@@ -31,13 +31,9 @@ def get_model(name):
 
 
 def get_layers(name):
-    assert name == 'pnasnet_large_pytorch'
-    layer_names = []
-
-    for name, module in MODEL.named_modules():
-        layer_names.append(name)
-
-    return layer_names[2:]
+    assert name == 'pnasnet_large'
+    layer_names = [f'cell_{i + 1}' for i in range(-1, 11)] + ['global_pool']
+    return layer_names
 
 
 def get_bibtex(model_identifier):

brainscore_vision/models/pnasnet_large/region_layer_map/pnasnet_large.json

@@ -0,0 +1,6 @@
+{
+    "V1": "cell_0",
+    "V2": "cell_4",
+    "V4": "cell_2",
+    "IT": "cell_8"
+}

brainscore_vision/models/pnasnet_large/requirements.txt

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

brainscore_vision/models/pnasnet_large/test.py

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

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

brainscore_vision/models/resnet50_SIN/model.py

@@ -0,0 +1,63 @@
+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 texture_vs_shape.models.load_pretrained_models import load_model
+
+
+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 == 'resnet50-SIN'
+    model = load_model("resnet50_trained_on_SIN")
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    wrapper = PytorchWrapper(identifier='name', model=model, preprocessing=preprocessing)
+    wrapper.image_size = 224
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'resnet50-SIN'
+    model_layers = ['module.conv1'] + \
+        [f'module.layer{seq}.{bottleneck}.relu'
+         for seq, bottlenecks in enumerate([3, 4, 6, 3], start=1)
+         for bottleneck in range(bottlenecks)] + \
+        ['module.avgpool']
+
+    return model_layers
+
+
+def get_bibtex(name):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return '''
+@article{DBLP:journals/corr/HeZRS15,
+  author       = {Kaiming He and
+                  Xiangyu Zhang and
+                  Shaoqing Ren and
+                  Jian Sun},
+  title        = {Deep Residual Learning for Image Recognition},
+  journal      = {CoRR},
+  volume       = {abs/1512.03385},
+  year         = {2015},
+  url          = {http://arxiv.org/abs/1512.03385},
+  eprinttype    = {arXiv},
+  eprint       = {1512.03385},
+  timestamp    = {Wed, 25 Jan 2023 11:01:16 +0100},
+  biburl       = {https://dblp.org/rec/journals/corr/HeZRS15.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/resnet50_SIN/region_layer_map/resnet50-SIN.json

@@ -0,0 +1,6 @@
+{
+    "V1": "module.layer2.3.relu",
+    "V2": "module.layer3.1.relu",
+    "V4": "module.layer3.0.relu",
+    "IT": "module.layer4.0.relu"
+}

brainscore_vision/models/resnet50_SIN/requirements.txt

@@ -0,0 +1 @@
+texture-vs-shape @ git+https://github.com/KartikP/texture-vs-shape.git

brainscore_vision/models/resnet50_SIN/test.py

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

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

brainscore_vision/models/resnet50_SIN_IN/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 texture_vs_shape.models import load_model
+
+
+
+
+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 == 'resnet50-SIN_IN'
+    model = load_model("resnet50_trained_on_SIN_and_IN")
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    wrapper = PytorchWrapper(identifier='name', model=model, preprocessing=preprocessing)
+    wrapper.image_size = 224
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'resnet50-SIN_IN'
+    layers = \
+        ['module.conv1'] + \
+        [f'module.layer{seq}.{bottleneck}.relu'
+         for seq, bottlenecks in enumerate([3, 4, 6, 3], start=1)
+         for bottleneck in range(bottlenecks)] + \
+        ['module.avgpool']
+    return layers
+
+
+def get_bibtex(name):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return '''
+@article{DBLP:journals/corr/HeZRS15,
+  author       = {Kaiming He and
+                  Xiangyu Zhang and
+                  Shaoqing Ren and
+                  Jian Sun},
+  title        = {Deep Residual Learning for Image Recognition},
+  journal      = {CoRR},
+  volume       = {abs/1512.03385},
+  year         = {2015},
+  url          = {http://arxiv.org/abs/1512.03385},
+  eprinttype    = {arXiv},
+  eprint       = {1512.03385},
+  timestamp    = {Wed, 25 Jan 2023 11:01:16 +0100},
+  biburl       = {https://dblp.org/rec/journals/corr/HeZRS15.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/resnet50_SIN_IN/region_layer_map/resnet50-SIN_IN.json

@@ -0,0 +1,6 @@
+{
+    "V1": "module.layer1.0.relu",
+    "V2": "module.layer3.0.relu",
+    "V4": "module.layer2.3.relu",
+    "IT": "module.layer4.0.relu"
+}

brainscore_vision/models/resnet50_SIN_IN/requirements.txt

@@ -0,0 +1,2 @@
+texture-vs-shape @ git+https://github.com/KartikP/texture-vs-shape.git
+

brainscore_vision/models/resnet50_SIN_IN/test.py

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

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

brainscore_vision/models/resnet50_SIN_IN_IN/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 texture_vs_shape.models import load_model
+
+
+
+
+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 == 'resnet50-SIN_IN_IN'
+    model = load_model("resnet50_trained_on_SIN_and_IN_then_finetuned_on_IN")
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    wrapper = PytorchWrapper(identifier='name', model=model, preprocessing=preprocessing)
+    wrapper.image_size = 224
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'resnet50-SIN_IN_IN'
+    layers = \
+        ['module.conv1'] + \
+        [f'module.layer{seq}.{bottleneck}.relu'
+         for seq, bottlenecks in enumerate([3, 4, 6, 3], start=1)
+         for bottleneck in range(bottlenecks)] + \
+        ['module.avgpool']
+    return layers
+
+
+def get_bibtex(name):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return '''
+@article{DBLP:journals/corr/HeZRS15,
+  author       = {Kaiming He and
+                  Xiangyu Zhang and
+                  Shaoqing Ren and
+                  Jian Sun},
+  title        = {Deep Residual Learning for Image Recognition},
+  journal      = {CoRR},
+  volume       = {abs/1512.03385},
+  year         = {2015},
+  url          = {http://arxiv.org/abs/1512.03385},
+  eprinttype    = {arXiv},
+  eprint       = {1512.03385},
+  timestamp    = {Wed, 25 Jan 2023 11:01:16 +0100},
+  biburl       = {https://dblp.org/rec/journals/corr/HeZRS15.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/resnet50_SIN_IN_IN/region_layer_map/resnet50-SIN_IN_IN.json

@@ -0,0 +1,6 @@
+{
+    "V1": "module.layer2.3.relu",
+    "V2": "module.layer3.1.relu",
+    "V4": "module.layer2.3.relu",
+    "IT": "module.layer4.0.relu"
+}

brainscore_vision/models/resnet50_SIN_IN_IN/requirements.txt

@@ -0,0 +1,2 @@
+texture-vs-shape @ git+https://github.com/KartikP/texture-vs-shape.git
+

brainscore_vision/models/resnet50_SIN_IN_IN/test.py

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

brainscore_vision/models/resnet50_VITO_8deg_cc/__init__.py

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