brainscore-vision 2.1__py3-none-any.whl

brainscore_vision/models/hmax/model.py

@@ -0,0 +1,69 @@
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.check_submission import check_models
+import functools
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+import ssl
+from .helpers.hmax import HMAX
+from .helpers.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.s3 import load_weight_file
+
+
+ssl._create_default_https_context = ssl._create_unverified_context
+model = None
+
+
+def get_model(name):
+    assert name == 'hmax'
+    return get_hmax(name, 224)
+
+
+def get_hmax(identifier, image_size):
+    weights_path = load_weight_file(bucket="brainscore-vision", folder_name="models",
+                                    relative_path="hmax/universal_patch_set.mat",
+                                    version_id="fIX.lsvnc8qqjDr_sG_Dl9RyqWuG0OGC",
+                                    sha1="acc7316fcb0d1797486bb62753b71e158216a92a")
+    global model 
+    model = HMAX(str(weights_path))
+    
+    preprocessing = functools.partial(load_preprocess_images, image_size=image_size)
+    wrapper = PytorchWrapper(identifier=identifier, model=model,
+                             preprocessing=preprocessing)
+    wrapper.image_size = image_size
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'hmax'
+    global model 
+    layer_names = []
+    for name, module in model.named_modules():
+        print(name)
+        layer_names.append(name)
+
+    return layer_names[-8:]
+
+
+def get_bibtex(model_identifier):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return """@ARTICLE {,
+                author = {G. Cortelazzo and M. Balanza},
+                journal = {IEEE Transactions on Pattern Analysis & Machine Intelligence},
+                title = {Frequency Domain Analysis of Translations with Piecewise Cubic Trajectories},
+                year = {1993},
+                volume = {29},
+                number = {04},
+                issn = {1939-3539},
+                pages = {411-416},
+                keywords = {frequency domain motion analysis; motion estimation; translations; piecewise cubic trajectories; cubic spline trajectories; finite-duration effects; constant velocity motion; first-order model; frequency-domain analysis; motion estimation; splines (mathematics)},
+                doi = {10.1109/34.206960},
+                publisher = {IEEE Computer Society},
+                address = {Los Alamitos, CA, USA},
+                month = {apr}
+                }
+            """
+
+
+if __name__ == '__main__':
+    check_models.check_base_models(__name__)

brainscore_vision/models/hmax/requirements.txt

@@ -0,0 +1,5 @@
+pillow
+torch
+torchvision
+scipy
+numpy

brainscore_vision/models/hmax/test.py

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

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

brainscore_vision/models/inception_v3_pytorch/model.py

@@ -0,0 +1,68 @@
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+import ssl
+import functools
+import timm
+from brainscore_vision.model_helpers.check_submission import check_models
+
+ssl._create_default_https_context = ssl._create_unverified_context
+
+'''
+This is a Pytorch implementation of inception_v3.
+
+Previously on Brain-Score, this model existed as a Tensorflow model, and was converted via:
+    https://huggingface.co/docs/timm/en/models/inception-v3
+    
+Disclaimer: This (pytorch) implementation's Brain-Score scores might not align identically with Tensorflow 
+implementation. 
+
+'''
+
+MODEL = timm.create_model('inception_v3', pretrained=True)
+
+def get_model(name):
+    assert name == 'inception_v3_pytorch'
+    preprocessing = functools.partial(load_preprocess_images, image_size=299)
+    wrapper = PytorchWrapper(identifier='inception_v3_pytorch', model=MODEL,
+                             preprocessing=preprocessing,
+                             batch_size=4)  # doesn't fit into 12 GB GPU memory otherwise
+    wrapper.image_size = 299
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'inception_v3_pytorch'
+    layer_names = []
+
+    for name, module in MODEL.named_modules():
+        layer_names.append(name)
+
+    return layer_names[2:]
+
+
+def get_bibtex(model_identifier):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return """@article{DBLP:journals/corr/SzegedyVISW15,
+              author    = {Christian Szegedy and
+                           Vincent Vanhoucke and
+                           Sergey Ioffe and
+                           Jonathon Shlens and
+                           Zbigniew Wojna},
+              title     = {Rethinking the Inception Architecture for Computer Vision},
+              journal   = {CoRR},
+              volume    = {abs/1512.00567},
+              year      = {2015},
+              url       = {http://arxiv.org/abs/1512.00567},
+              archivePrefix = {arXiv},
+              eprint    = {1512.00567},
+              timestamp = {Mon, 13 Aug 2018 16:49:07 +0200},
+              biburl    = {https://dblp.org/rec/journals/corr/SzegedyVISW15.bib},
+              bibsource = {dblp computer science bibliography, https://dblp.org}
+            }
+            """
+
+
+if __name__ == '__main__':
+    check_models.check_base_models(__name__)

brainscore_vision/models/inception_v3_pytorch/requirements.txt

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

brainscore_vision/models/inception_v3_pytorch/test.py

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

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

brainscore_vision/models/mobilenet_v2_1_4_224_pytorch/model.py

@@ -0,0 +1,60 @@
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.activations.pytorch import load_images, load_preprocess_images
+from brainscore_vision.model_helpers.check_submission import check_models
+import ssl
+from transformers import MobileNetV2ForImageClassification
+import functools
+
+ssl._create_default_https_context = ssl._create_unverified_context
+
+'''
+This is a Pytorch implementation of mobilenet_v2_1.0_224.
+
+Previously on Brain-Score, this model existed as a Tensorflow model, and was converted via:
+    https://huggingface.co/Matthijs/mobilenet_v2_1.4_224
+    
+Disclaimer: This (pytorch) implementation's Brain-Score scores might not align identically with Tensorflow 
+implementation. 
+'''
+
+
+def get_model(name):
+    assert name == 'mobilenet_v2_1-4_224_pytorch'
+    model = MobileNetV2ForImageClassification.from_pretrained("Matthijs/mobilenet_v2_1.4_224")
+
+    # this mobilenet was trained with 1001 classes where index 0 is the background class
+    # (https://huggingface.co/docs/transformers/en/model_doc/mobilenet_v2)
+    classifier_layer = model.classifier
+    classifier_layer.register_forward_hook(lambda _layer, _input, logits: logits[:, 1:])
+
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    wrapper = PytorchWrapper(identifier='mobilenet_v2_1-4_224_pytorch', model=model,
+                             preprocessing=preprocessing,
+                             batch_size=4)  # doesn't fit into 12 GB GPU memory otherwise
+    wrapper.image_size = 224
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'mobilenet_v2_1-4_224_pytorch'
+    layer_names = (['mobilenet_v2.conv_stem'] +
+                   [f'mobilenet_v2.layer.{i}' for i in range(16)] +
+                   ['mobilenet_v2.pooler', 'classifier'])
+    return layer_names
+
+
+def get_bibtex(model_identifier):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return """@inproceedings{mobilenetv22018,
+                title={MobileNetV2: Inverted Residuals and Linear Bottlenecks},
+                author={Mark Sandler and Andrew Howard and Menglong Zhu and Andrey Zhmoginov and Liang-Chieh Chen},
+                booktitle={CVPR},
+                year={2018}
+                }
+            """
+
+
+if __name__ == '__main__':
+    check_models.check_base_models(__name__)

brainscore_vision/models/mobilenet_v2_1_4_224_pytorch/requirements.txt

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

brainscore_vision/models/mobilenet_v2_1_4_224_pytorch/test.py

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

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

brainscore_vision/models/mobilevit_small/model.py

@@ -0,0 +1,49 @@
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.activations.pytorch import load_images, load_preprocess_images
+from brainscore_vision.model_helpers.check_submission import check_models
+import ssl
+from transformers import MobileViTForImageClassification
+import functools
+
+ssl._create_default_https_context = ssl._create_unverified_context
+
+'''
+Can be found on huggingface: https://huggingface.co/apple/mobilevit-small
+'''
+
+def get_model(name):
+    assert name == 'mobilevit_small'
+    model = MobileViTForImageClassification.from_pretrained("apple/mobilevit-small")
+    preprocessing = functools.partial(load_preprocess_images, image_size=256)
+    wrapper = PytorchWrapper(identifier='mobilevit_small', model=model,
+                             preprocessing=preprocessing,
+                             batch_size=4)
+    wrapper.image_size = 256
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'mobilevit_small'
+    layer_names = ["mobilevit.encoder.layer.0", "mobilevit.encoder.layer.1", "mobilevit.encoder.layer.2",
+                   "mobilevit.encoder.layer.2.fusion.activation",
+                   "mobilevit.encoder.layer.3", "mobilevit.encoder.layer.3.fusion.activation",
+                   "mobilevit.encoder.layer.4", "mobilevit.encoder.layer.4.fusion.activation"]
+
+    return layer_names
+
+
+def get_bibtex(model_identifier):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return """@inproceedings{vision-transformer,
+                title = {MobileViT: Light-weight, General-purpose, and Mobile-friendly Vision Transformer},
+                author = {Sachin Mehta and Mohammad Rastegari},
+                year = {2022},
+                URL = {https://arxiv.org/abs/2110.02178}
+                }
+             """
+
+
+if __name__ == '__main__':
+    check_models.check_base_models(__name__)

brainscore_vision/models/mobilevit_small/requirements.txt

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

brainscore_vision/models/mobilevit_small/test.py

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

brainscore_vision/models/pixels/__init__.py

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

brainscore_vision/models/pixels/model.py

@@ -0,0 +1,35 @@
+from collections import OrderedDict
+
+import numpy as np
+from PIL import Image
+
+from brainscore_vision.model_helpers.activations.core import ActivationsExtractorHelper
+
+
+class PixelModel:
+    def __init__(self):
+        self._extractor = ActivationsExtractorHelper(identifier='pixels', preprocessing=None,
+                                                     get_activations=self._pixels_from_paths)
+        self._extractor.insert_attrs(self)
+
+    @property
+    def identifier(self):
+        return self._extractor.identifier
+
+    @identifier.setter
+    def identifier(self, value):
+        self._extractor.identifier = value
+
+    def __call__(self, *args, **kwargs):  # cannot assign __call__ as attribute due to Python convention
+        return self._extractor(*args, **kwargs)
+
+    def _pixels_from_paths(self, paths, layer_names):
+        np.testing.assert_array_equal(layer_names, ['pixels'])
+        pixels = [self._parse_image(path) for path in paths]
+        return OrderedDict([('pixels', np.array(pixels))])
+
+    def _parse_image(self, path):
+        image = Image.open(path)
+        image = image.convert('RGB')  # make sure everything is in RGB and not grayscale L
+        image = image.resize((256, 256))  # resize all images to same size
+        return np.array(image)

brainscore_vision/models/pixels/test.py

@@ -0,0 +1,15 @@
+import pytest
+from pytest import approx
+
+from brainscore_vision import score
+
+
+@pytest.mark.private_access
+@pytest.mark.memory_intense
+@pytest.mark.parametrize("model_identifier, benchmark_identifier, expected_score", [
+    ("pixels", "MajajHong2015.IT-pls", approx(0.0153, abs=0.0005)),
+])
+def test_score(model_identifier, benchmark_identifier, expected_score):
+    actual_score = score(model_identifier=model_identifier, benchmark_identifier=benchmark_identifier,
+                         conda_active=True)
+    assert actual_score == expected_score

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

brainscore_vision/models/pnasnet_large_pytorch/model.py

@@ -0,0 +1,59 @@
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.check_submission import check_models
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+import ssl
+import functools
+import timm
+
+ssl._create_default_https_context = ssl._create_unverified_context
+
+'''
+This is a Pytorch implementation of pnasnet_large.
+
+Previously on Brain-Score, this model existed as a Tensorflow model, and was converted via:
+    https://huggingface.co/timm/pnasnet5large.tf_in1k
+    
+Disclaimer: This (pytorch) implementation's Brain-Score scores might not align identically with Tensorflow 
+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,
+                             preprocessing=preprocessing,
+                             batch_size=4)  # doesn't fit into 12 GB GPU memory otherwise
+    wrapper.image_size = 331
+    return wrapper
+
+
+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:]
+
+
+def get_bibtex(model_identifier):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return """@misc{liu2018progressive,
+              title={Progressive Neural Architecture Search}, 
+              author={Chenxi Liu and Barret Zoph and Maxim Neumann and Jonathon Shlens and Wei Hua and Li-Jia Li and Li Fei-Fei and Alan Yuille and Jonathan Huang and Kevin Murphy},
+              year={2018},
+              eprint={1712.00559},
+              archivePrefix={arXiv},
+              primaryClass={cs.CV}
+            }
+            """
+
+
+if __name__ == '__main__':
+    check_models.check_base_models(__name__)

brainscore_vision/models/pnasnet_large_pytorch/requirements.txt

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

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

brainscore_vision/models/r101_eBarlow_Vanilla_1/__init__.py

@@ -0,0 +1,9 @@
+from brainscore_vision import model_registry
+from brainscore_vision.model_helpers.brain_transformation import ModelCommitment
+from .model import get_model, get_layers
+
+model_registry["r101_eBarlow_Vanilla_1"] = lambda: ModelCommitment(
+    identifier="r101_eBarlow_Vanilla_1",
+    activations_model=get_model("r101_eBarlow_Vanilla_1"),
+    layers=get_layers("r101_eBarlow_Vanilla_1"),
+)

brainscore_vision/models/r101_eBarlow_Vanilla_1/model.py

@@ -0,0 +1,64 @@
+from brainscore_vision.model_helpers.check_submission import check_models
+import functools
+import os
+from urllib.request import urlretrieve
+import torchvision.models
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+from pathlib import Path
+from brainscore_vision.model_helpers import download_weights
+import torch
+from collections import OrderedDict
+
+# This is an example implementation for submitting resnet-50 as a pytorch model
+
+# Attention: It is important, that the wrapper identifier is unique per model!
+# The results will otherwise be the same due to brain-scores internal result caching mechanism.
+# Please load your pytorch model for usage in CPU. There won't be GPUs available for scoring your model.
+# If the model requires a GPU, contact the brain-score team directly.
+from brainscore_vision.model_helpers.check_submission import check_models
+
+
+def get_model_list():
+    return ["r101_eBarlow_Vanilla_1"]
+
+
+def get_model(name):
+    assert name == "r101_eBarlow_Vanilla_1"
+    url = "https://users.flatironinstitute.org/~tyerxa/equi_proj/training_checkpoints/resnet101/imagenet_1k/vanilla/Barlow_1/latest-rank0"
+    fh = urlretrieve(url)
+    state_dict = torch.load(fh[0], map_location=torch.device("cpu"))["state"]["model"]
+    model = load_composer_classifier(state_dict)
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    wrapper = PytorchWrapper(identifier=name, model=model, preprocessing=preprocessing)
+    wrapper.image_size = 224
+    return wrapper
+
+def load_composer_classifier(sd):
+    model = torchvision.models.resnet.resnet101()
+    new_sd = OrderedDict()
+    for k, v in sd.items():
+        if 'lin_cls' in k:
+            new_sd['fc.' + k.split('.')[-1]] = v
+        if ".f." not in k:
+            continue
+        parts = k.split(".")
+        idx = parts.index("f")
+        new_k = ".".join(parts[idx + 1 :])
+        new_sd[new_k] = v
+    model.load_state_dict(new_sd, strict=True)
+    return model
+
+def get_layers(name):
+    assert name == "r101_eBarlow_Vanilla_1"
+
+    outs = ["layer4"]
+    return outs
+
+
+def get_bibtex(model_identifier):
+    return """xx"""
+
+
+if __name__ == "__main__":
+    check_models.check_base_models(__name__)

brainscore_vision/models/r101_eBarlow_Vanilla_1/setup.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from setuptools import setup, find_packages
+
+requirements = [ "torchvision",
+                 "torch"
+]
+
+setup(
+    packages=find_packages(exclude=['tests']),
+    include_package_data=True,
+    install_requires=requirements,
+    license="MIT license",
+    zip_safe=False,
+    keywords='brain-score template',
+    classifiers=[
+        'Development Status :: 2 - Pre-Alpha',
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: MIT License',
+        'Natural Language :: English',
+        'Programming Language :: Python :: 3.7',
+    ],
+    test_suite='tests',
+)

brainscore_vision/models/r101_eBarlow_Vanilla_1/test.py

@@ -0,0 +1 @@
+# Left empty as part of 2023 models migration

brainscore_vision/models/r101_eBarlow_lmda_01_1/__init__.py

@@ -0,0 +1,9 @@
+from brainscore_vision import model_registry
+from brainscore_vision.model_helpers.brain_transformation import ModelCommitment
+from .model import get_model, get_layers
+
+model_registry["r101_eBarlow_lmda_01_1"] = lambda: ModelCommitment(
+    identifier="r101_eBarlow_lmda_01_1",
+    activations_model=get_model("r101_eBarlow_lmda_01_1"),
+    layers=get_layers("r101_eBarlow_lmda_01_1"),
+)

brainscore_vision/models/r101_eBarlow_lmda_01_1/model.py

@@ -0,0 +1,65 @@
+from brainscore_vision.model_helpers.check_submission import check_models
+import functools
+import os
+from urllib.request import urlretrieve
+import torchvision.models
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+from pathlib import Path
+from brainscore_vision.model_helpers import download_weights
+import torch
+from collections import OrderedDict
+
+# This is an example implementation for submitting resnet-50 as a pytorch model
+
+# Attention: It is important, that the wrapper identifier is unique per model!
+# The results will otherwise be the same due to brain-scores internal result caching mechanism.
+# Please load your pytorch model for usage in CPU. There won't be GPUs available for scoring your model.
+# If the model requires a GPU, contact the brain-score team directly.
+from brainscore_vision.model_helpers.check_submission import check_models
+
+
+def get_model_list():
+    return ["r101_eBarlow_lmda_01_1"]
+
+
+def get_model(name):
+    assert name == "r101_eBarlow_lmda_01_1"
+    url = "https://users.flatironinstitute.org/~tyerxa/equi_proj/training_checkpoints/resnet101/imagenet_1k/paired/lmda_0.1/Barlow_1/latest-rank0"
+    fh = urlretrieve(url)
+    state_dict = torch.load(fh[0], map_location=torch.device("cpu"))["state"]["model"]
+    model = load_composer_classifier(state_dict)
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    wrapper = PytorchWrapper(identifier=name, model=model, preprocessing=preprocessing)
+    wrapper.image_size = 224
+    return wrapper
+
+def load_composer_classifier(sd):
+    model = torchvision.models.resnet.resnet101()
+    new_sd = OrderedDict()
+    for k, v in sd.items():
+        if 'lin_cls' in k:
+            new_sd['fc.' + k.split('.')[-1]] = v
+        if ".f." not in k:
+            continue
+        parts = k.split(".")
+        idx = parts.index("f")
+        new_k = ".".join(parts[idx + 1 :])
+        new_sd[new_k] = v
+    model.load_state_dict(new_sd, strict=True)
+    return model
+
+def get_layers(name):
+    assert name == "r101_eBarlow_lmda_01_1"
+
+    outs = ["conv1", "layer1", "layer2", "layer3", "layer4", "avgpool", "fc"]
+    outs = ["layer4"]
+    return outs
+
+
+def get_bibtex(model_identifier):
+    return """xx"""
+
+
+if __name__ == "__main__":
+    check_models.check_base_models(__name__)