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

brainscore_vision/models/blt-vs/pretrained.py

@@ -0,0 +1,219 @@
+
+import hashlib
+import requests
+from pathlib import Path
+import zipfile
+from collections import OrderedDict
+from warnings import warn
+import json
+import torch
+import zipfile
+_MODELS = {}
+_ALIASES = {}
+
+
+def get_file(fname, origin, file_hash=None, cache_dir=".cache", cache_subdir="datasets", extract=True):
+    """
+    Download a file from a URL, cache it locally, and optionally verify its hash and extract it.
+
+    Args:
+        fname (str): The name of the file to save locally.
+        origin (str): The URL to download the file from.
+        file_hash (str, optional): The expected hash of the file to verify integrity. Defaults to None.
+        cache_dir (str): The root cache directory. Defaults to ".cache".
+        cache_subdir (str): The subdirectory within the cache directory. Defaults to "datasets".
+        extract (bool): Whether to extract the file if it's a ZIP archive. Defaults to False.
+
+    Returns:
+        str: The path to the cached (and optionally extracted) file.
+    """
+    cache_path = Path(cache_dir) / cache_subdir
+    cache_path.mkdir(parents=True, exist_ok=True)
+
+    file_path = cache_path / fname
+
+    if not file_path.exists():
+        print(f"Downloading {origin} to {file_path}...")
+        response = requests.get(origin, stream=True)
+        response.raise_for_status()  
+        with open(file_path, "wb") as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                f.write(chunk)
+        print(f"Download complete: {file_path}")
+
+    if file_hash:
+        print("Verifying file hash...")
+        sha256 = hashlib.sha256()
+        with open(file_path, "rb") as f:
+            for chunk in iter(lambda: f.read(4096), b""):
+                sha256.update(chunk)
+        downloaded_file_hash = sha256.hexdigest()
+        if downloaded_file_hash != file_hash:
+            raise ValueError(f"File hash does not match! Expected {file_hash}, got {downloaded_file_hash}")
+        print("File hash verified.")
+
+    if extract and zipfile.is_zipfile(file_path):
+        extract_path = cache_path 
+        json_file = extract_path / f"{fname.replace('.zip', '')}.json"
+        weight_file = extract_path / f"{fname.replace('.zip', '')}.pth"
+        if not json_file.exists() and not weight_file.exists():
+            print(f"Extracting {file_path} to {extract_path}")
+            with zipfile.ZipFile(file_path, "r") as zip_ref:
+                    zip_ref.extractall(extract_path)  
+            print(f"Extraction complete: {extract_path}")
+        
+        return str(extract_path)
+
+    return str(file_path)
+
+
+def clear_models_and_aliases(*cls):
+    if len(cls) == 0:
+        _MODELS.clear()
+        _ALIASES.clear()
+    else:
+        for c in cls:
+            if c in _MODELS:
+                del _MODELS[c]
+            if c in _ALIASES:
+                del _ALIASES[c]
+                
+def register_model(cls, key, url, hash):
+    # key must be a valid file/folder name in the file system
+    models = _MODELS.setdefault(cls, OrderedDict())
+    key not in models or warn(
+        "re-registering model '{}' (was already registered for '{}')".format(
+            key, cls.__name__
+        )
+    )
+    models[key] = dict(url=url, hash=hash)
+
+
+def register_aliases(cls, key, *names):
+    # aliases can be arbitrary strings
+    if len(names) == 0:
+        return
+    models = _MODELS.get(cls, {})
+    key in models or ValueError(f"model '{key}' is not registered for '{cls.__name__}'")
+    
+    aliases = _ALIASES.setdefault(cls, OrderedDict())
+    for name in names:
+        aliases.get(name, key) == key or warn(
+            "alias '{}' was previously registered with model '{}' for '{}'".format(
+                name, aliases[name], cls.__name__
+            )
+        )
+        aliases[name] = key
+
+
+def get_registered_models(cls, return_aliases=True, verbose=False):
+    models = _MODELS.get(cls, {})
+    aliases = _ALIASES.get(cls, {})
+    model_keys = tuple(models.keys())
+    model_aliases = {
+        key: tuple(name for name in aliases if aliases[name] == key) for key in models
+    }
+    if verbose:
+        # this code is very messy and should be refactored...
+        _n = len(models)
+        _str_model = "model" if _n == 1 else "models"
+        _str_is_are = "is" if _n == 1 else "are"
+        _str_colon = ":" if _n > 0 else ""
+        print(
+            "There {is_are} {n} registered {model_s} for '{clazz}'{c}".format(
+                n=_n,
+                clazz=cls.__name__,
+                is_are=_str_is_are,
+                model_s=_str_model,
+                c=_str_colon,
+            )
+        )
+        if _n > 0:
+            print()
+            _maxkeylen = 2 + max(len(key) for key in models)
+            print("Name{s}Alias(es)".format(s=" " * (_maxkeylen - 4 + 3)))
+            print("────{s}─────────".format(s=" " * (_maxkeylen - 4 + 3)))
+            for key in models:
+                _aliases = "   "
+                _m = len(model_aliases[key])
+                if _m > 0:
+                    _aliases += "'%s'" % "', '".join(model_aliases[key])
+                else:
+                    _aliases += "None"
+                _key = ("{s:%d}" % _maxkeylen).format(s="'%s'" % key)
+                print(f"{_key}{_aliases}")
+    return (model_keys, model_aliases) if return_aliases else model_keys
+
+
+def get_model_details(cls, key_or_alias, verbose=True):
+    models = _MODELS.get(cls, {})
+   
+    if key_or_alias in models:
+        key = key_or_alias
+        alias = None
+    else:
+        aliases = _ALIASES.get(cls, {})
+        alias = key_or_alias
+        alias in aliases or ValueError(f"'{alias}' is neither a key or alias for '{cls.__name__}'")
+        key = aliases[alias]
+    if verbose:
+        print(
+            "Found model '{model}'{alias_str} for '{clazz}'.".format(
+                model=key,
+                clazz=cls.__name__,
+                alias_str=("" if alias is None else " with alias '%s'" % alias),
+            )
+        )
+    return key, alias, models[key]
+
+
+        
+def get_model_folder(cls, key_or_alias):
+    key, alias, m = get_model_details(cls, key_or_alias)
+    target = Path("models") / cls.__name__ / key
+    path = Path(
+        get_file(
+            fname=key + ".zip",
+            origin=m["url"],
+            file_hash=m["hash"],
+            cache_subdir=target,
+            extract=True,
+        )
+    )
+  
+    assert path.exists() and path.parent.exists()
+    return path.parent
+               
+
+
+def get_model_instance(cls, key_or_alias):
+    path = get_model_folder(cls, key_or_alias)
+    json_file = path /key_or_alias /f"{key_or_alias}.json"  
+    weight_file = path / key_or_alias/f"{key_or_alias}.pth"
+
+    if not json_file or not weight_file:
+        raise FileNotFoundError("Required .json or .pth file not found in the model folder.")
+
+    with open(json_file, "r") as f:
+        config = json.load(f)
+
+    timesteps = config.get("timesteps", 1) 
+    hook_type = config.get("hook_type", None)
+    bio_unroll = config.get("bio_unroll", False)
+    num_classes = config.get("num_classes", 1)
+
+    model = cls(timesteps=timesteps, hook_type=hook_type, bio_unroll=bio_unroll, num_classes=num_classes)
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    state_dict = torch.load(weight_file, map_location=device)
+
+    filtered_state_dict = {
+        k: v if not (isinstance(v, torch.Tensor) and v.dtype != torch.float64) else v.float()
+        for k, v in state_dict.items()
+        if not any(x in k for x in ["total_ops", "total_params"])
+    }
+    
+    model.load_state_dict(filtered_state_dict)
+
+   
+    return model

brainscore_vision/models/blt-vs/region_layer_map/blt_vs.json

@@ -0,0 +1,6 @@
+{
+    "V1": "V1_5",
+    "V2": "V3_5",
+    "V4": "V1_5",
+    "IT": "V4_5"
+}

brainscore_vision/models/blt-vs/setup.py

@@ -0,0 +1,22 @@
+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/cifar_resnet18_1/__init__.py

@@ -0,0 +1,5 @@
+from brainscore_vision import model_registry
+from .model import get_model
+
+# Register the Barlow Twins model with custom weights
+model_registry['cifar_resnet18_1'] = lambda: get_model('cifar_resnet18_1')

brainscore_vision/models/cifar_resnet18_1/model.py

@@ -0,0 +1,68 @@
+import torch
+from pathlib import Path
+from torchvision.models import resnet18
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.brain_transformation import ModelCommitment
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+from collections import OrderedDict
+from urllib.request import urlretrieve
+import functools
+import os
+
+
+# Custom model loader
+def get_model(name):
+    assert name == 'cifar_resnet18_1'
+    url = " https://www.dropbox.com/scl/fi/maqzcf3j87m7tp4sm1pab/barlow-cifar10-otu5cw89-ep-999.ckpt?rlkey=ou425fqbxxy6pe9lc4mz400mp&st=va93bqox&dl=1"
+    fh, _ = urlretrieve(url)
+    print(f"Downloaded weights file: {fh}, Size: {os.path.getsize(fh)} bytes")
+    
+    checkpoint = torch.load(fh, map_location="cpu")
+    state_dict = checkpoint['state_dict']  # Adjust key if necessary
+    # Filter out projector layers
+    backbone_state_dict = {k.replace("backbone.", ""): v for k, v in state_dict.items() if not k.startswith("projector.")}
+    # Initialize ResNet18 backbone
+    
+    model = resnet18(pretrained=False)
+    model.conv1 = torch.nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)
+    # print("First conv layer weights AFTER loading:")
+    # print(model.conv1.weight[0, 0, 0])
+    model.load_state_dict(backbone_state_dict, strict=False)
+    # print(f"Missing keys: {missing_keys}")
+    # print(f"Unexpected keys: {unexpected_keys}")
+    # print("First conv layer weights AFTER loading:")
+    # print(model.conv1.weight[0, 0, 0])
+    # print(model)
+
+
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+
+    activations_model = PytorchWrapper(identifier='cifar_resnet18_1', model=model, preprocessing=preprocessing)
+
+    
+    return ModelCommitment(
+        identifier='cifar_resnet18_1',
+        activations_model=activations_model,
+        layers=['layer1', 'layer2', 'layer3', 'layer4', 'avgpool']
+    )
+
+def get_model_list():
+    return ['cifar_resnet18_1']
+
+# Specify layers to test
+def get_layers(name):
+    assert name == 'cifar_resnet18_1'
+    return ['layer1', 'layer2', 'layer3', 'layer4', 'avgpool']
+
+def get_bibtex(model_identifier):
+    return """
+    @misc{resnet18_test_consistency,
+    title={ArtResNet18 Barlow Twins},
+    author={Claudia Noche},
+    year={2024},
+    }
+    """
+
+if __name__ == '__main__':
+    from brainscore_vision.model_helpers.check_submission import check_models
+    check_models.check_base_models(__name__)

brainscore_vision/models/cifar_resnet18_1/requirements.txt

@@ -0,0 +1,4 @@
+torch
+torchvision
+requests
+pathlib

brainscore_vision/models/cifar_resnet18_1/test.py

@@ -0,0 +1,10 @@
+import pytest
+import brainscore_vision
+
+@pytest.mark.travis_slow
+def test_cifar_resnet18_1():
+    model = brainscore_vision.load_model('cifar_resnet18_1')
+    assert model.identifier == 'cifar_resnet18_1'
+
+
+

brainscore_vision/models/resnet18_random/__init__.py

@@ -0,0 +1,5 @@
+from brainscore_vision import model_registry
+from .model import get_model
+
+# Register the model with the identifier 'resnet18_random'
+model_registry['resnet18_random'] = lambda: get_model('resnet18_random')

brainscore_vision/models/resnet18_random/model.py

@@ -0,0 +1,42 @@
+import torch
+from torchvision.models import resnet18
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from brainscore_vision.model_helpers.brain_transformation import ModelCommitment
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+import functools
+
+# Define preprocessing (resize to 224x224 as required by ResNet)
+preprocessing = functools.partial(load_preprocess_images, image_size=224)
+
+# Define ResNet18 with random weights
+def get_model(name):
+    assert name == 'resnet18_random'
+    # Load ResNet18 without pre-trained weights
+    model = resnet18(pretrained=False)
+    # Wrap the model with Brain-Score's PytorchWrapper
+    activations_model = PytorchWrapper(identifier='resnet18_random', model=model, preprocessing=preprocessing)
+    return ModelCommitment(
+        identifier='resnet18_random',
+        activations_model=activations_model,
+        # Specify layers for evaluation
+        layers=['layer1', 'layer2', 'layer3', 'layer4', 'avgpool']
+    )
+
+# Specify layers to test
+def get_layers(name):
+    assert name == 'resnet18_random'
+    return ['layer1', 'layer2', 'layer3', 'layer4', 'avgpool']
+
+# Optional: Provide a BibTeX reference for the model
+def get_bibtex(model_identifier):
+    return """
+    @misc{resnet18_test_consistency,
+    title={ResNet18 with Random Weights},
+    author={Clear Glue},
+    year={2024},
+    }
+    """
+
+if __name__ == '__main__':
+    from brainscore_vision.model_helpers.check_submission import check_models
+    check_models.check_base_models(__name__)

brainscore_vision/models/resnet18_random/requirements.txt

@@ -0,0 +1,2 @@
+torch
+torchvision

brainscore_vision/models/resnet18_random/test.py

@@ -0,0 +1,12 @@
+import pytest
+import brainscore_vision
+
+@pytest.mark.travis_slow
+def test_resnet18_random():
+    model = brainscore_vision.load_model('resnet18_random')
+    assert model.identifier == 'resnet18_random'
+
+
+
+# AssertionError: No registrations found for resnet18_random
+# ⚡ master ~/vision python -m brainscore_vision score --model_identifier='resnet50_tutorial' --benchmark_identifier='MajajHong2015public.IT-pls'

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

brainscore_vision/models/resnet50_less_variation_1/model.py

@@ -0,0 +1,200 @@
+
+from brainscore_vision.model_helpers.check_submission import check_models
+import functools
+import numpy as np
+import torch
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from PIL import Image
+from torch import nn
+import pytorch_lightning as pl
+import torchvision.models as models
+import gdown
+import glob
+import os
+from brainscore_vision.model_helpers.activations.pytorch import load_preprocess_images
+
+def get_bibtex(model_identifier):
+    return 'VGG16'
+
+def get_model_list():
+    return ['resnet50_less_variation_iteration=1']
+
+def get_model(name):
+    keyword = 'less_variation'
+    iteration = 1
+    network = 'resnet50'
+    url = 'https://eggerbernhard.ch/shreya/latest_resnet50/less_variation_1.ckpt'
+    output = 'resnet50_less_variation_iteration=1.ckpt'
+    gdown.download(url, output)
+
+
+    if keyword != 'imagenet_trained' and keyword != 'no_training':
+        lx_whole = [f"resnet50_less_variation_iteration=1.ckpt"]
+        if len(lx_whole) > 1:
+            lx_whole = [lx_whole[-1]]
+    elif keyword == 'imagenet_trained' or keyword == 'no_training':
+        print('keyword is imagenet')
+        lx_whole = ['x']
+
+    for model_ckpt in lx_whole:
+        print(model_ckpt)
+        last_module_name = None
+        last_module = None
+        layers = []
+        if keyword == 'imagenet_trained' and network != 'clip':
+            model = torch.hub.load('pytorch/vision', network, pretrained=True)
+            for name, module in model.named_modules():
+                last_module_name = name
+                last_module = module
+                layers.append(name)
+        else:
+            model = torch.hub.load('pytorch/vision', network, pretrained=False)
+        if model_ckpt != 'x':
+            ckpt = torch.load(model_ckpt, map_location='cpu')
+        if model_ckpt != 'x' and network == 'alexnet' and keyword != 'imagenet_trained':
+            ckpt2 = {}
+            for keys in ckpt['state_dict']:
+                print(keys)
+                print(ckpt['state_dict'][keys].shape)
+                print('---')
+                k2 = keys.split('model.')[1]
+                ckpt2[k2] = ckpt['state_dict'][keys]
+            model.load_state_dict(ckpt2)
+        if model_ckpt != 'x' and network == 'vgg16' and keyword != 'imagenet_trained':
+            ckpt2 = {}
+            for keys in ckpt['state_dict']:
+                print(keys)
+                print(ckpt['state_dict'][keys].shape)
+                print('---')
+                k2 = keys.split('model.')[1]
+                ckpt2[k2] = ckpt['state_dict'][keys]
+            model.load_state_dict(ckpt2)
+        # Add more cases for other networks as needed
+    assert name == 'resnet50_less_variation_iteration=1'
+    url = 'https://eggerbernhard.ch/shreya/latest_resnet50/less_variation_1.ckpt'
+    output = 'resnet50_less_variation_iteration=1.ckpt'
+    gdown.download(url, output)
+    layers = []
+    for name, module in model._modules.items():
+        print(name, "->", module)
+        layers.append(name)
+
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    activations_model = PytorchWrapper(identifier=name, model=model, preprocessing=preprocessing)
+
+    return activations_model
+
+def get_layers(name):
+    keyword = 'less_variation'
+    iteration = 1
+    network = 'resnet50'
+    url = 'https://eggerbernhard.ch/shreya/latest_resnet50/less_variation_1.ckpt'
+    output = 'resnet50_less_variation_iteration=1.ckpt'
+    gdown.download(url, output)
+
+
+    if keyword != 'imagenet_trained' and keyword != 'no_training':
+        lx_whole = [f"resnet50_less_variation_iteration=1.ckpt"]
+        if len(lx_whole) > 1:
+            lx_whole = [lx_whole[-1]]
+    elif keyword == 'imagenet_trained' or keyword == 'no_training':
+        print('keyword is imagenet')
+        lx_whole = ['x']
+
+
+    for model_ckpt in lx_whole:
+        print(model_ckpt)
+        last_module_name = None
+        last_module = None
+        if keyword == 'imagenet_trained' and network != 'clip':
+            model = torch.hub.load('pytorch/vision', network, pretrained=True)
+            for name, module in model.named_modules():
+                last_module_name = name
+                last_module = module
+                layers.append(name)
+        else:
+            model = torch.hub.load('pytorch/vision', network, pretrained=False)
+        if model_ckpt != 'x':
+            ckpt = torch.load(model_ckpt, map_location='cpu')
+        if model_ckpt != 'x' and network == 'alexnet' and keyword != 'imagenet_trained':
+            ckpt2 = {}
+            for keys in ckpt['state_dict']:
+                print(keys)
+                print(ckpt['state_dict'][keys].shape)
+                print('---')
+                k2 = keys.split('model.')[1]
+                ckpt2[k2] = ckpt['state_dict'][keys]
+            model.load_state_dict(ckpt2)
+        if model_ckpt != 'x' and network == 'vgg16' and keyword != 'imagenet_trained':
+            ckpt2 = {}
+            for keys in ckpt['state_dict']:
+                print(keys)
+                print(ckpt['state_dict'][keys].shape)
+                print('---')
+                k2 = keys.split('model.')[1]
+                ckpt2[k2] = ckpt['state_dict'][keys]
+            model.load_state_dict(ckpt2)
+        # Add more cases for other networks as needed
+    layers = []
+    for name, module in model._modules.items():
+            print(name, "->", module)
+            layers.append(name)
+    return layers
+
+if __name__ == '__main__':
+    device = "cpu"
+    global model
+    global keyword
+    global network
+    global iteration
+    keyword = 'less_variation'
+    iteration = 1
+    network = 'resnet50'
+    url = 'https://eggerbernhard.ch/shreya/latest_resnet50/less_variation_1.ckpt'
+    output = 'resnet50_less_variation_iteration=1.ckpt'
+    gdown.download(url, output)
+
+
+    if keyword != 'imagenet_trained' and keyword != 'no_training':
+        lx_whole = [f"resnet50_less_variation_iteration=1.ckpt"]
+        if len(lx_whole) > 1:
+            lx_whole = [lx_whole[-1]]
+    elif keyword == 'imagenet_trained' or keyword == 'no_training':
+        print('keyword is imagenet')
+        lx_whole = ['x']
+
+    for model_ckpt in lx_whole:
+        print(model_ckpt)
+        last_module_name = None
+        last_module = None
+        layers = []
+        if keyword == 'imagenet_trained' and network != 'clip':
+            model = torch.hub.load('pytorch/vision', network, pretrained=True)
+            for name, module in model.named_modules():
+                last_module_name = name
+                last_module = module
+                layers.append(name)
+        else:
+            model = torch.hub.load('pytorch/vision', network, pretrained=False)
+        if model_ckpt != 'x':
+            ckpt = torch.load(model_ckpt, map_location='cpu')
+        if model_ckpt != 'x' and network == 'alexnet' and keyword != 'imagenet_trained':
+            ckpt2 = {}
+            for keys in ckpt['state_dict']:
+                print(keys)
+                print(ckpt['state_dict'][keys].shape)
+                print('---')
+                k2 = keys.split('model.')[1]
+                ckpt2[k2] = ckpt['state_dict'][keys]
+            model.load_state_dict(ckpt2)
+        if model_ckpt != 'x' and network == 'vgg16' and keyword != 'imagenet_trained':
+            ckpt2 = {}
+            for keys in ckpt['state_dict']:
+                print(keys)
+                print(ckpt['state_dict'][keys].shape)
+                print('---')
+                k2 = keys.split('model.')[1]
+                ckpt2[k2] = ckpt['state_dict'][keys]
+            model.load_state_dict(ckpt2)
+        # Add more cases for other networks as needed
+    check_models.check_base_models(__name__)

brainscore_vision/models/resnet50_less_variation_1/region_layer_map/resnet50_less_variation_iteration=1.json

@@ -0,0 +1,6 @@
+{
+    "V1": "maxpool",
+    "V2": "layer1",
+    "V4": "maxpool",
+    "IT": "layer1"
+}

brainscore_vision/models/resnet50_less_variation_1/setup.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from setuptools import setup, find_packages
+
+requirements = [
+    "torchvision",
+    "torch",
+    "gdown",
+    "pytorch_lightning",
+    "brainscore_vision"
+]
+
+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/resnet50_less_variation_1/test.py

@@ -0,0 +1,3 @@
+
+import pytest
+

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