brainscore-vision 2.1__py3-none-any.whl

brainscore_vision/models/antialias_resnet152/model.py

@@ -0,0 +1,35 @@
+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 antialiased_cnns
+from brainscore_vision.model_helpers.check_submission import check_models
+
+ssl._create_default_https_context = ssl._create_unverified_context
+
+
+def get_model(name):
+    assert name == 'antialias-resnet152'
+    model = antialiased_cnns.resnet152(pretrained=True)
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    wrapper = PytorchWrapper(identifier='antialiased-resnet-152', model=model, preprocessing=preprocessing)
+    wrapper.image_size = 224
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'antialias-resnet152'
+    return ['layer1.1', 'layer1.2', 'layer2.1', 'layer2.2', 'layer2.3', 'layer2.4',
+            'layer2.5', 'layer2.6', 'layer2.7', 'layer3.0'] + ['layer3.' + str(i) for i in range(1, 36, 6)] + [
+               'layer3.35', 'layer4.1', 'layer4.2', 'avgpool', 'fc']
+
+
+def get_bibtex(model_identifier):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return """"""
+
+
+if __name__ == '__main__':
+    check_models.check_base_models(__name__)

brainscore_vision/models/antialias_resnet152/requirements.txt

@@ -0,0 +1,3 @@
+torchvision
+torch
+antialiased-cnns

brainscore_vision/models/antialias_resnet152/test.py

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

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

brainscore_vision/models/antialiased_rnext101_32x8d/model.py

@@ -0,0 +1,35 @@
+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 antialiased_cnns
+from brainscore_vision.model_helpers.check_submission import check_models
+
+ssl._create_default_https_context = ssl._create_unverified_context
+
+def get_model(name):
+    assert name == 'antialiased-rnext101_32x8d'
+    model = antialiased_cnns.resnext101_32x8d(pretrained=True)
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    wrapper = PytorchWrapper(identifier='antialiased-rnext101_32x8d', model=model, preprocessing=preprocessing)
+    wrapper.image_size = 224
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'antialiased-rnext101_32x8d'
+    return ['maxpool', 'layer1.0', 'layer1.1', 'layer1.2',
+            'layer2.0', 'layer2.1', 'layer2.2', 'layer2.3'] + ['layer3.' + str(i) for i in range(23)] + ['layer4.0',
+                                                                                                         'layer4.1',
+                                                                                                         'layer4.2',
+                                                                                                         'avgpool',
+                                                                                                         'fc']
+
+def get_bibtex(model_identifier):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return """"""
+
+if __name__ == '__main__':
+    check_models.check_base_models(__name__)

brainscore_vision/models/antialiased_rnext101_32x8d/requirements.txt

@@ -0,0 +1 @@
+antialiased-cnns

brainscore_vision/models/antialiased_rnext101_32x8d/test.py

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

brainscore_vision/models/bp_resnet50_julios/__init__.py

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

brainscore_vision/models/bp_resnet50_julios/model.py

@@ -0,0 +1,52 @@
+from brainscore_vision.model_helpers.check_submission import check_models
+import functools
+import os
+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
+
+# 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 ['bp_resnet50_julios']
+
+
+def get_model(name):
+    assert name == 'bp_resnet50_julios'
+    ckpt_name = 'bp_export.pt'
+    download_weights(
+        bucket='brainscore-vision',
+        folder_path='models/bp_resnet50_julios',
+        filename_version_sha=[(ckpt_name, 'PAH2BMGhcw9tWUH6RwTIADHodw.fyG4G', 'e504fc533aaec453f24e73a86e47ca6df3394c53')],
+        save_directory=Path(__file__).parent
+    )
+    ckpt_path = Path(__file__).parent / ckpt_name
+    model = torch.load(ckpt_path)
+    preprocessing = functools.partial(load_preprocess_images, image_size=224)
+    print(preprocessing)
+    wrapper = PytorchWrapper(identifier='bp_resnet50_julios', model=model, preprocessing=preprocessing)
+    wrapper.image_size = 224
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'bp_resnet50_julios'
+    return ['layer1', 'layer2', 'layer3', 'layer4']  
+
+
+def get_bibtex(model_identifier):
+    return """xx"""
+
+
+if __name__ == '__main__':
+    check_models.check_base_models(__name__)

brainscore_vision/models/bp_resnet50_julios/setup.py

@@ -0,0 +1,24 @@
+#!/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',
+    ],
+    test_suite='tests',
+)

brainscore_vision/models/bp_resnet50_julios/test.py

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

brainscore_vision/models/clip/__init__.py

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

brainscore_vision/models/clip/model.py

@@ -0,0 +1,179 @@
+from brainscore_vision.model_helpers.check_submission import check_models
+import functools
+import numpy as np
+import torch
+from transformers import AutoFeatureExtractor, CvtForImageClassification, CLIPVisionModel, CLIPProcessor, CLIPModel
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from PIL import Image
+
+
+"""
+Template module for a base model submission to brain-score
+"""
+
+class PytorchWrapperFixed(PytorchWrapper):
+    @staticmethod
+    def _tensor_to_numpy(output):
+        # Verificar si la salida es un tuple y tomar solo el primer elemento
+        if isinstance(output, tuple):
+            output = output[0]
+        return output.cpu().data.numpy()
+
+    def register_hook(self, layer, layer_name, target_dict):
+        def hook_function(_layer, _input, output, name=layer_name):
+            if isinstance(output, tuple):
+                output = output[0]
+            target_dict[name] = PytorchWrapperFixed._tensor_to_numpy(output)
+        hook = layer.register_forward_hook(hook_function)
+        return hook
+
+def get_model_list():
+  return ['model-lecs-v1.0.1']
+
+def get_model(name):
+    assert name == 'model-lecs-v1.0.1'
+    # https://huggingface.co/models?sort=downloads&search=cvt
+    image_size = 224
+    processor = CLIPProcessor.from_pretrained('openai/clip-vit-base-patch32')
+    model = CLIPVisionModel.from_pretrained('openai/clip-vit-base-patch32')
+    preprocessing = functools.partial(load_preprocess_images, processor=processor, image_size=image_size)
+    wrapper = PytorchWrapperFixed(identifier=name, model=model, preprocessing=preprocessing)
+    #wrapper = PytorchWrapper(identifier='model-lecs', model=model, preprocessing=preprocessing)
+    wrapper.image_size = 224
+
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'model-lecs-v1.0.1'
+    layers = []
+    
+    # Añadir las capas del modelo CLIPVisionModel
+    layers += [f'vision_model.encoder.layers.{i}' for i in [2, 3, 6, 8]]
+    # Ejemplo: puedes elegir algunas capas específicas si lo deseas
+    # layers = ['vision_model.encoder.layers.3', 'vision_model.post_layernorm']
+    
+    return layers
+
+
+def get_bibtex(model_identifier):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return """@article{DBLP:journals/corr/abs-2103-15808,
+  author       = {Haiping Wu and
+                  Bin Xiao and
+                  Noel Codella and
+                  Mengchen Liu and
+                  Xiyang Dai and
+                  Lu Yuan and
+                  Lei Zhang},
+  title        = {CvT: Introducing Convolutions to Vision Transformers},
+  journal      = {CoRR},
+  volume       = {abs/2103.15808},
+  year         = {2021},
+  url          = {https://arxiv.org/abs/2103.15808},
+  eprinttype    = {arXiv},
+  eprint       = {2103.15808},
+  timestamp    = {Tue, 18 Oct 2022 08:35:30 +0200},
+  biburl       = {https://dblp.org/rec/journals/corr/abs-2103-15808.bib},
+  bibsource    = {dblp computer science bibliography, https://dblp.org}
+}"""
+
+
+def load_preprocess_images(image_filepaths, image_size, processor=None, **kwargs):
+    images = load_images(image_filepaths)
+    # images = [<PIL.Image.Image image mode=RGB size=400x400 at 0x7F8654B2AC10>, ...]
+    images = [image.resize((image_size, image_size)) for image in images]
+    if processor is not None:
+        images = [processor(images=image, return_tensors="pt", **kwargs) for image in images]
+        if len(images[0].keys()) != 1:
+            raise NotImplementedError(f'unknown processor for getting model {processor}')
+        assert list(images[0].keys())[0] == 'pixel_values'
+        images = [image['pixel_values'] for image in images]
+        images = torch.cat(images)
+        images = images.cpu().numpy()
+    else:
+        images = preprocess_images(images, image_size=image_size, **kwargs)
+    return images
+
+
+def load_images(image_filepaths):
+    return [load_image(image_filepath) for image_filepath in image_filepaths]
+
+
+def load_image(image_filepath):
+    with Image.open(image_filepath) as pil_image:
+        if 'L' not in pil_image.mode.upper() and 'A' not in pil_image.mode.upper() \
+                and 'P' not in pil_image.mode.upper():  # not binary and not alpha and not palletized
+            # work around to https://github.com/python-pillow/Pillow/issues/1144,
+            # see https://stackoverflow.com/a/30376272/2225200
+            return pil_image.copy()
+        else:  # make sure potential binary images are in RGB
+            rgb_image = Image.new("RGB", pil_image.size)
+            rgb_image.paste(pil_image)
+            return rgb_image
+
+
+def preprocess_images(images, image_size, **kwargs):
+    preprocess = torchvision_preprocess_input(image_size, **kwargs)
+    images = [preprocess(image) for image in images]
+    images = np.concatenate(images)
+    return images
+
+
+def torchvision_preprocess_input(image_size, **kwargs):
+    from torchvision import transforms
+    return transforms.Compose([
+        transforms.Resize((image_size, image_size)),
+        torchvision_preprocess(**kwargs),
+    ])
+
+
+def torchvision_preprocess(normalize_mean=(0.485, 0.456, 0.406), normalize_std=(0.229, 0.224, 0.225)):
+    from torchvision import transforms
+    return transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize(mean=normalize_mean, std=normalize_std),
+        lambda img: img.unsqueeze(0)
+    ])
+
+
+def create_static_video(image, num_frames, normalize_0to1=False, channel_dim=3):
+    '''
+    Create a static video with the same image in all frames.
+    Args:
+        image (PIL.Image.Image): Input image.
+        num_frames (int): Number of frames in the video.
+    Returns:
+        result (np.ndarray): np array of frames of shape (num_frames, height, width, 3).
+    '''
+    frames = []
+    for _ in range(num_frames):
+        frame = np.array(image)
+        if normalize_0to1:
+            frame = frame / 255.
+        if channel_dim == 1:
+            frame = frame.transpose(2, 0, 1)
+        frames.append(frame)
+    return np.stack(frames)
+
+
+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__)
+
+
+'''
+Below Notes are from the original model file from Brain-Score 1.0, and 
+kept in this file for posterity. 
+'''
+
+
+"""
+Notes on the error:
+- 'channel_x' key error: 
+# 'embeddings.patch_embeddings.projection',
+https://github.com/search?q=repo%3Abrain-score%2Fmodel-tools%20channel_x&type=code
+"""

brainscore_vision/models/clip/requirements.txt

@@ -0,0 +1,4 @@
+numpy
+torch
+transformers
+Pillow

brainscore_vision/models/clip/test.py

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

brainscore_vision/models/clipvision/__init__.py

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

brainscore_vision/models/clipvision/model.py

@@ -0,0 +1,179 @@
+from brainscore_vision.model_helpers.check_submission import check_models
+import functools
+import numpy as np
+import torch
+from transformers import AutoFeatureExtractor, CvtForImageClassification, CLIPVisionModel, CLIPProcessor, CLIPModel
+from brainscore_vision.model_helpers.activations.pytorch import PytorchWrapper
+from PIL import Image
+
+
+"""
+Template module for a base model submission to brain-score
+"""
+
+class PytorchWrapperFixed(PytorchWrapper):
+    @staticmethod
+    def _tensor_to_numpy(output):
+        # Verificar si la salida es un tuple y tomar solo el primer elemento
+        if isinstance(output, tuple):
+            output = output[0]
+        return output.cpu().data.numpy()
+
+    def register_hook(self, layer, layer_name, target_dict):
+        def hook_function(_layer, _input, output, name=layer_name):
+            if isinstance(output, tuple):
+                output = output[0]
+            target_dict[name] = PytorchWrapperFixed._tensor_to_numpy(output)
+        hook = layer.register_forward_hook(hook_function)
+        return hook
+
+def get_model_list():
+  return ['model-lecs']
+
+def get_model(name):
+    assert name == 'model-lecs'
+    # https://huggingface.co/models?sort=downloads&search=cvt
+    image_size = 224
+    processor = CLIPProcessor.from_pretrained('openai/clip-vit-base-patch32')
+    model = CLIPVisionModel.from_pretrained('openai/clip-vit-base-patch32')
+    preprocessing = functools.partial(load_preprocess_images, processor=processor, image_size=image_size)
+    wrapper = PytorchWrapperFixed(identifier=name, model=model, preprocessing=preprocessing)
+    #wrapper = PytorchWrapper(identifier='model-lecs', model=model, preprocessing=preprocessing)
+    wrapper.image_size = 224
+
+    return wrapper
+
+
+def get_layers(name):
+    assert name == 'model-lecs'
+    layers = []
+    
+    # Añadir las capas del modelo CLIPVisionModel
+    layers += [f'vision_model.encoder.layers.{i}' for i in range(1)]
+    # Ejemplo: puedes elegir algunas capas específicas si lo deseas
+    # layers = ['vision_model.encoder.layers.3', 'vision_model.post_layernorm']
+    
+    return layers
+
+
+def get_bibtex(model_identifier):
+    """
+    A method returning the bibtex reference of the requested model as a string.
+    """
+    return """@article{DBLP:journals/corr/abs-2103-15808,
+  author       = {Haiping Wu and
+                  Bin Xiao and
+                  Noel Codella and
+                  Mengchen Liu and
+                  Xiyang Dai and
+                  Lu Yuan and
+                  Lei Zhang},
+  title        = {CvT: Introducing Convolutions to Vision Transformers},
+  journal      = {CoRR},
+  volume       = {abs/2103.15808},
+  year         = {2021},
+  url          = {https://arxiv.org/abs/2103.15808},
+  eprinttype    = {arXiv},
+  eprint       = {2103.15808},
+  timestamp    = {Tue, 18 Oct 2022 08:35:30 +0200},
+  biburl       = {https://dblp.org/rec/journals/corr/abs-2103-15808.bib},
+  bibsource    = {dblp computer science bibliography, https://dblp.org}
+}"""
+
+
+def load_preprocess_images(image_filepaths, image_size, processor=None, **kwargs):
+    images = load_images(image_filepaths)
+    # images = [<PIL.Image.Image image mode=RGB size=400x400 at 0x7F8654B2AC10>, ...]
+    images = [image.resize((image_size, image_size)) for image in images]
+    if processor is not None:
+        images = [processor(images=image, return_tensors="pt", **kwargs) for image in images]
+        if len(images[0].keys()) != 1:
+            raise NotImplementedError(f'unknown processor for getting model {processor}')
+        assert list(images[0].keys())[0] == 'pixel_values'
+        images = [image['pixel_values'] for image in images]
+        images = torch.cat(images)
+        images = images.cpu().numpy()
+    else:
+        images = preprocess_images(images, image_size=image_size, **kwargs)
+    return images
+
+
+def load_images(image_filepaths):
+    return [load_image(image_filepath) for image_filepath in image_filepaths]
+
+
+def load_image(image_filepath):
+    with Image.open(image_filepath) as pil_image:
+        if 'L' not in pil_image.mode.upper() and 'A' not in pil_image.mode.upper() \
+                and 'P' not in pil_image.mode.upper():  # not binary and not alpha and not palletized
+            # work around to https://github.com/python-pillow/Pillow/issues/1144,
+            # see https://stackoverflow.com/a/30376272/2225200
+            return pil_image.copy()
+        else:  # make sure potential binary images are in RGB
+            rgb_image = Image.new("RGB", pil_image.size)
+            rgb_image.paste(pil_image)
+            return rgb_image
+
+
+def preprocess_images(images, image_size, **kwargs):
+    preprocess = torchvision_preprocess_input(image_size, **kwargs)
+    images = [preprocess(image) for image in images]
+    images = np.concatenate(images)
+    return images
+
+
+def torchvision_preprocess_input(image_size, **kwargs):
+    from torchvision import transforms
+    return transforms.Compose([
+        transforms.Resize((image_size, image_size)),
+        torchvision_preprocess(**kwargs),
+    ])
+
+
+def torchvision_preprocess(normalize_mean=(0.485, 0.456, 0.406), normalize_std=(0.229, 0.224, 0.225)):
+    from torchvision import transforms
+    return transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize(mean=normalize_mean, std=normalize_std),
+        lambda img: img.unsqueeze(0)
+    ])
+
+
+def create_static_video(image, num_frames, normalize_0to1=False, channel_dim=3):
+    '''
+    Create a static video with the same image in all frames.
+    Args:
+        image (PIL.Image.Image): Input image.
+        num_frames (int): Number of frames in the video.
+    Returns:
+        result (np.ndarray): np array of frames of shape (num_frames, height, width, 3).
+    '''
+    frames = []
+    for _ in range(num_frames):
+        frame = np.array(image)
+        if normalize_0to1:
+            frame = frame / 255.
+        if channel_dim == 1:
+            frame = frame.transpose(2, 0, 1)
+        frames.append(frame)
+    return np.stack(frames)
+
+
+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__)
+
+
+'''
+Below Notes are from the original model file from Brain-Score 1.0, and 
+kept in this file for posterity. 
+'''
+
+
+"""
+Notes on the error:
+- 'channel_x' key error: 
+# 'embeddings.patch_embeddings.projection',
+https://github.com/search?q=repo%3Abrain-score%2Fmodel-tools%20channel_x&type=code
+"""

brainscore_vision/models/clipvision/requirements.txt

@@ -0,0 +1,4 @@
+numpy
+torch
+transformers
+Pillow

brainscore_vision/models/clipvision/test.py

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

brainscore_vision/models/cornet_s/__init__.py

@@ -0,0 +1,8 @@
+from brainscore_vision import model_registry
+from .helpers.helpers import CORnetCommitment, _build_time_mappings
+from .model import get_model, get_layers, TIME_MAPPINGS
+
+
+model_registry['CORnet-S'] = lambda: CORnetCommitment(identifier='CORnet-S', activations_model=get_model('CORnet-S'),
+                                                      layers=get_layers('CORnet-S'),
+                                                      time_mapping=_build_time_mappings(TIME_MAPPINGS))