brainscore-vision 2.1__py3-none-any.whl

brainscore_vision/data/igustibagus2024/test.py

@@ -0,0 +1,26 @@
+import pytest
+
+from brainscore_vision import load_dataset, load_stimulus_set
+from brainscore_vision.benchmark_helpers import check_standard_format
+
+
+@pytest.mark.memory_intense
+@pytest.mark.private_access
+def test_assembly():
+    assembly = load_dataset('Igustibagus2024')
+    check_standard_format(assembly, nans_expected=True)
+    assert assembly.attrs['stimulus_set_identifier'] == 'Igustibagus2024'
+    assert set(assembly['region'].values) == {'IT'}
+    assert len(assembly['presentation']) == 197_694
+    assert set(assembly['object_style'].values) == {'silhouette', 'sketch', 'cartoon', 'original', 'painting',
+                                                    'line_drawing', 'outline', 'convex_hull', 'mosaic',
+                                                    'textures', 'skeleton', 'grayscale', 'nan', 'silhouettes', 'edges'}
+    assert len(assembly['neuroid']) == 181
+    assert set(assembly['animal'].values) == {'Pico', 'Oleo'}
+    assert len(set(assembly['background_id'].values)) == 121
+
+
+@pytest.mark.private_access
+def test_stimulus_set():
+    stimulus_set = load_stimulus_set('Igustibagus2024')
+    assert len(stimulus_set) == 3138

brainscore_vision/data/imagenetslim15000/ImageNetSlim15000.py

@@ -0,0 +1,30 @@
+import os
+import numpy as np
+import pandas as pd
+from brainio_base.stimuli import StimulusSet
+from brainio_collection.packaging import package_stimulus_set
+
+
+def collect_stimuli(data_path):
+    assert os.path.isdir(data_path)
+    stimulus_df = pd.read_pickle(os.path.join(data_path,'info.pkl'))
+    stimulus_set = StimulusSet(stimulus_df)
+    stimulus_set.image_paths = {
+        stimulus_set.at[idx, 'image_id']: os.path.join(data_path,'data',stimulus_set.at[idx, 'image_name']) for idx in range(len(stimulus_set))}
+    return stimulus_set
+
+
+def main():
+    stimulus_path = os.path.normpath('/Users/chongguo/Dropbox (MIT)/CG@DiCarlo/Datasets/ImageNetSlim15000')
+    stimulus_set = collect_stimuli(stimulus_path)
+    stimulus_set.identifier = 'ImageNetSlim15000'
+    package(stimulus_set)
+
+
+def package(stimulus_set):
+    print("Packaging stimuli")
+    package_stimulus_set(stimulus_set, stimulus_set_identifier=stimulus_set.identifier, bucket_name= 'brainio.requested')
+
+
+if __name__ == '__main__':
+    main()

brainscore_vision/data/imagenetslim15000/__init__.py

@@ -0,0 +1,11 @@
+from brainscore_vision import stimulus_set_registry
+from brainscore_vision.data_helpers.s3 import load_stimulus_set_from_s3
+
+# stimulus set
+stimulus_set_registry['ImageNetSlim15000'] = lambda: load_stimulus_set_from_s3(
+    identifier="ImageNetSlim15000",
+    bucket="brainio-brainscore",
+    csv_sha1="56f79de36060147bc43ae89778e26d50f73c3a63",
+    zip_sha1="633d08474e3067add834f4ddf552642c538db112",
+    csv_version_id="iDLAbolZkyQ5c0Znj2mk0pirw.nhCW5j",
+    zip_version_id="xqkshnRACHpOqp1sSRBmHI9PeCAcTCAg")

brainscore_vision/data/imagenetslim15000/test.py

@@ -0,0 +1,8 @@
+import pytest
+
+from brainscore_vision import load_stimulus_set
+
+
+@pytest.mark.private_access
+def test_existence():
+    assert load_stimulus_set('ImageNetSlim15000') is not None

brainscore_vision/data/islam2021/__init__.py

@@ -0,0 +1,18 @@
+from brainscore_vision import stimulus_set_registry
+from brainscore_vision.data_helpers.s3 import load_stimulus_set_from_s3
+
+BIBTEX = """@article{islam2021shape,
+  title={Shape or texture: Understanding discriminative features in cnns},
+  author={Islam, Md Amirul and Kowal, Matthew and Esser, Patrick and Jia, Sen and Ommer, Bjorn and Derpanis, Konstantinos G and Bruce, Neil},
+  journal={arXiv preprint arXiv:2101.11604},
+  year={2021}
+}"""
+
+stimulus_set_registry['Islam2021'] = lambda: load_stimulus_set_from_s3(
+    identifier="Islam2021",
+    bucket="brainio-brainscore",
+    filename_prefix='stimulus_',
+    csv_sha1="93ab0f6386d8d5fb56640da45980a819c7dd6efc",
+    zip_sha1="e55b673117a472f463e0705ac3e330ef8dfd938b",
+    csv_version_id="_HABybRKD6XaqqyO4oEehXhG6ah1wW.G",
+    zip_version_id="B30p0DM9KNuAgT1d.U9iT6DNYawriYoK")

brainscore_vision/data/islam2021/data_packaging.py

@@ -0,0 +1,64 @@
+from fileinput import filename
+from matplotlib.hatch import Shapes
+import numpy as np
+import os
+import pandas as pd
+from pathlib import Path
+from brainio.stimuli import StimulusSet
+from brainio.packaging import package_stimulus_set
+
+#
+# Code to generate the stylized voc 2012:
+# https://github.com/islamamirul/shape_texture_neuron
+#
+
+shapes = ["aeroplane","bicycle","bird","boat","bottle","bus","car",
+          "cat","chair","cow","diningtable","dog","horse","motorbike",
+          "person","pottedplant","sheep","sofa","train","tvmonitor"]
+
+textures = ["cracked","marbled","pleated","potholed","woven"]
+
+#filename: t_s_y_id.jpg 
+# t is texture in {0,1,2,3,4}
+# s is shape in  {1,..,20}
+# y is year
+# i is a sequence of digits
+# y_id identifies the original voc image
+def collect_stylizedvoc_stimuli(data_dir):
+    stimuli = []
+    stimulus_paths = {}
+    assert os.path.exists(data_dir)
+    for filepath in Path(data_dir).glob('*.jpg'):
+        assert len(filepath.stem.split('_')) == 4
+        image_id = filepath.stem
+        original_image_id = filepath.stem.split('_')[2] + "_" + filepath.stem.split('_')[3]  #corresponds to the original voc dataset
+        texture_class = int(filepath.stem.split('_')[0])
+        texture = textures[texture_class]
+        shape_class = int(filepath.stem.split('_')[1]) - 1  #shape_class is the label in the original voc dataset.
+        shape = shapes[shape_class]        
+              
+        stimulus_paths[image_id] = filepath
+        stimuli.append({
+            'stimulus_id': image_id,
+            'original_image_id': original_image_id,
+            'texture_class': texture_class,
+            'texture': texture,
+            'shape_class': shape_class, 
+            'shape': shape
+        })
+            
+    stimuli = StimulusSet(stimuli)
+    stimuli.stimulus_paths = stimulus_paths
+    stimuli.identifier = 'Islam2021'
+    assert len(stimuli) == 4369 * 5 
+    return stimuli
+    
+    
+if __name__ == '__main__':
+    dir = "./packaging/stylizedvoc2012"
+    stimuli = collect_stylizedvoc_stimuli(dir)
+    #upload to S3
+    #package_stimulus_set("brainio_brainscore", stimuli, stimulus_set_identifier=stimuli.identifier,bucket_name="brainio-brainscore")
+
+
+

brainscore_vision/data/islam2021/test.py

@@ -0,0 +1,11 @@
+import pytest
+
+from brainscore_vision import load_stimulus_set
+
+
+@pytest.mark.private_access
+def test_stimuli():
+    stimulus_set = load_stimulus_set('Islam2021')
+    assert len(set(stimulus_set["texture"])) == 5
+    assert len(set(stimulus_set["shape"])) == 20
+    assert len(stimulus_set) == 4369 * 5

brainscore_vision/data/kar2018/__init__.py

@@ -0,0 +1,58 @@
+from brainio.assemblies import NeuronRecordingAssembly
+
+from brainscore_vision import data_registry, stimulus_set_registry, load_stimulus_set
+from brainscore_vision.metrics.internal_consistency.ceiling import InternalConsistency
+from brainscore_vision.metric_helpers.transformations import CrossValidation
+from brainscore_vision.data_helpers.s3 import load_assembly_from_s3, load_stimulus_set_from_s3
+
+BIBTEX = """@article {19,
+    title = {Evidence that recurrent circuits are critical to the ventral stream{\textquoteright}s execution of core object recognition behavior},
+    journal = {bioRxiv},
+    year = {2018},
+    month = {06/2018},
+    type = {preprint},
+    abstract = {<p>Non-recurrent deep convolutional neural networks (DCNNs) are currently the best models of core object recognition; a behavior supported by the densely recurrent primate ventral stream, culminating in the inferior temporal (IT) cortex. Are these recurrent circuits critical to ventral stream\&$\#$39;s execution of this behavior? We reasoned that, if recurrence is critical, then primates should outperform feedforward-only DCNNs for some images, and that these images should require additional processing time beyond the feedforward IT response. Here we first used behavioral methods to discover hundreds of these \&quot;challenge\&quot; images. Second, using large-scale IT electrophysiology in animals performing core recognition tasks, we observed that behaviorally-sufficient, linearly-decodable object identity solutions emerged ~30ms (on average) later in IT for challenge images compared to DCNN and primate performance-matched \&quot;control\&quot; images. We observed these same late solutions even during passive viewing. Third, consistent with a failure of feedforward computations, the behaviorally-critical late-phase IT population response patterns evoked by the challenge images were poorly predicted by DCNN activations. Interestingly, deeper CNNs better predicted these late IT responses, suggesting a functional equivalence between recurrence and additional nonlinear transformations. Our results argue that automatically-evoked recurrent circuits are critical even for rapid object identification. By precisely comparing current DCNNs, primate behavior and IT population dynamics, we provide guidance for future recurrent model development.</p>
+},
+    doi = {https://doi.org/10.1101/354753},
+    url = {https://www.biorxiv.org/content/10.1101/354753v1.full.pdf},
+    author = {Kar, Kohitij and Kubilius, Jonas and Schmidt, Kailyn and Issa, Elias B and DiCarlo, James J.}
+}"""
+
+# assemblies: hvm
+data_registry['Kar2018hvm'] = lambda: load_assembly_from_s3(
+    identifier="dicarlo.Kar2018hvm",
+    version_id="4sytUtSGiyB.G0oBmPCVnnQ6l4FChj8z",
+    sha1="96ccacc76c5fa30ee68bdc8736d1d43ace93f3e7",
+    bucket="brainio-brainscore",
+    cls=NeuronRecordingAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('hvm'),
+)
+
+# assemblies: cocogray
+data_registry['Kar2018cocogray'] = lambda: load_assembly_from_s3(
+    identifier="dicarlo.Kar2018cocogray",
+    version_id="RxiK296HHAe2ql_STmZ2K..uEsfCuHtF",
+    sha1="4202cb3992a5d71f71a7ca9e28ba3f8b27937b43",
+    bucket="brainio-brainscore",
+    cls=NeuronRecordingAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('Kar2018cocogray'),
+)
+
+# stimulus set: cocogray
+stimulus_set_registry['Kar2018cocogray'] = lambda: load_stimulus_set_from_s3(
+    identifier="Kar2018cocogray",
+    bucket="brainio-brainscore",
+    csv_sha1="be9bb267b80fd7ee36a88d025b73ae8a849165da",
+    zip_sha1="1457003ee9b27ed51c018237009fe148c6e71fd3",
+    csv_version_id="A6XtlkCYhgUp.Bw1fSxRAc53DU.RVEgC",
+    zip_version_id="e_YJ7G2C.wsGSN4qCw0WQvLc4DECI8eG")
+
+
+def filter_neuroids(assembly, threshold):
+    ceiler = InternalConsistency()
+    ceiling = ceiler(assembly)
+    ceiling = ceiling.raw
+    ceiling = CrossValidation().aggregate(ceiling)
+    pass_threshold = ceiling >= threshold
+    assembly = assembly[{'neuroid': pass_threshold}]
+    return assembly

brainscore_vision/data/kar2018/data_packaging/kar_coco.py

@@ -0,0 +1,97 @@
+import os
+from glob import glob
+
+import h5py
+import numpy as np
+import pandas as pd
+import re
+import xarray as xr
+from pathlib import Path
+from tqdm import tqdm
+
+from brainio_base.assemblies import NeuronRecordingAssembly
+from brainio_collection.knownfile import KnownFile as kf
+from brainio_contrib.packaging import package_stimulus_set, package_data_assembly
+from mkgu_packaging.dicarlo.kar2018 import filter_neuroids
+
+
+def collect_stimuli(stimuli_directory):
+    meta = os.path.join(stimuli_directory, 'cocogray_labels.mat')
+    meta = h5py.File(meta, 'r')
+    labels = [''.join(chr(c) for c in meta[meta['lb'].value[0, i]]) for i in range(meta['lb'].value[0].size)]
+    stimuli = []
+    for image_file_path in tqdm(glob(os.path.join(stimuli_directory, '*.png'))):
+        image_file_name = os.path.basename(image_file_path)
+        image_number = re.match('im([0-9]+).png', image_file_name)
+        image_number = int(image_number.group(1))
+        im_kf = kf(image_file_path)
+        stimuli.append({
+            'image_id': im_kf.sha1,
+            'image_file_name': image_file_name,
+            'image_current_local_file_path': image_file_path,
+            'image_file_sha1': im_kf.sha1,
+            'image_number': image_number,
+            'image_path_within_store': image_file_name,
+            'label': labels[image_number],
+        })
+    stimuli = pd.DataFrame(stimuli)
+    assert len(stimuli) == 1600
+    assert len(np.unique(stimuli['image_id'])) == len(stimuli)
+    return stimuli
+
+
+def load_responses(response_file, stimuli):
+    responses = h5py.File(response_file, 'r')
+    assemblies = []
+    neuroid_id_offset = 0
+    for monkey in responses.keys():
+        spike_rates = responses[monkey]['rates']
+        assembly = xr.DataArray(spike_rates.value,
+                                coords={
+                                    'image_num': ('image_id', list(range(spike_rates.shape[0]))),
+                                    'image_id': ('image_id', [
+                                        stimuli['image_id'][stimuli['image_number'] == num].values[0]
+                                        for num in range(spike_rates.shape[0])]),
+                                    'neuroid_id': ('neuroid', list(
+                                        range(neuroid_id_offset, neuroid_id_offset + spike_rates.shape[1]))),
+                                    'region': ('neuroid', ['IT'] * spike_rates.shape[1]),
+                                    'monkey': ('neuroid', [monkey] * spike_rates.shape[1]),
+                                    'repetition': list(range(spike_rates.shape[2])),
+                                },
+                                dims=['image_id', 'neuroid', 'repetition'])
+        assemblies.append(assembly)
+        neuroid_id_offset += spike_rates.shape[1]
+    assembly = xr.concat(assemblies, 'neuroid')
+    assembly = assembly.stack(presentation=['image_id', 'repetition'])
+    assembly = NeuronRecordingAssembly(assembly)
+    assert len(assembly['presentation']) == 1600 * 45
+    assert len(np.unique(assembly['image_id'])) == 1600
+    assert len(assembly.sel(monkey='nano')['neuroid']) == len(assembly.sel(monkey='magneto')['neuroid']) == 288
+    assert len(assembly['neuroid']) == len(np.unique(assembly['neuroid_id'])) == 288 * 2
+    # filter noisy electrodes
+    assembly = filter_neuroids(assembly, threshold=.7)
+    # add time info
+    assembly = assembly.expand_dims('time_bin')
+    assembly['time_bin_start'] = 'time_bin', [70]
+    assembly['time_bin_end'] = 'time_bin', [170]
+    assembly = assembly.transpose('presentation', 'neuroid', 'time_bin')
+    return assembly
+
+
+def main():
+    data_dir = Path(__file__).parent / 'coco'
+    stimuli = collect_stimuli(data_dir / 'stimuli')
+    stimuli.name = 'Kar2018cocogray'
+    assembly = load_responses(data_dir / 'cocoGray_neural.h5', stimuli)
+    assembly.name = 'dicarlo.Kar2018cocogray'
+
+    print("Packaging stimuli")
+    package_stimulus_set(stimuli, stimulus_set_name=stimuli.name,
+                         bucket_name="brainio-dicarlo")
+    print("Packaging assembly")
+    package_data_assembly(assembly, data_assembly_name=assembly.name, stimulus_set_name=stimuli.name,
+                          bucket_name="brainio-dicarlo")
+
+
+if __name__ == '__main__':
+    main()

brainscore_vision/data/kar2018/data_packaging/kar_hvm.py

@@ -0,0 +1,77 @@
+import h5py
+import numpy as np
+import xarray as xr
+from pathlib import Path
+
+import brainio_collection
+from brainio_base.assemblies import NeuronRecordingAssembly
+from brainio_contrib.packaging import package_data_assembly
+from mkgu_packaging.dicarlo.kar2018 import filter_neuroids
+
+
+def load_responses(response_file, additional_coords):
+    responses = h5py.File(response_file, 'r')
+    assemblies = []
+    neuroid_id_offset = 0
+    for monkey in responses.keys():
+        spike_rates = responses[monkey]['rates']
+        assembly = xr.DataArray(spike_rates.value,
+                                coords={**{
+                                    'image_num': ('image_id', list(range(spike_rates.shape[0]))),
+                                    'neuroid_id': ('neuroid', list(
+                                        range(neuroid_id_offset, neuroid_id_offset + spike_rates.shape[1]))),
+                                    'region': ('neuroid', ['IT'] * spike_rates.shape[1]),
+                                    'monkey': ('neuroid', [monkey] * spike_rates.shape[1]),
+                                    'repetition': list(range(spike_rates.shape[2])),
+                                }, **additional_coords},
+                                dims=['image_id', 'neuroid', 'repetition'])
+        assemblies.append(assembly)
+        neuroid_id_offset += spike_rates.shape[1]
+    assembly = xr.concat(assemblies, 'neuroid')
+    assembly = assembly.stack(presentation=['image_id', 'repetition'])
+    assembly = NeuronRecordingAssembly(assembly)
+    assert len(assembly['presentation']) == 640 * 63
+    assert len(np.unique(assembly['image_id'])) == 640
+    assert len(assembly.sel(monkey='nano')['neuroid']) == len(assembly.sel(monkey='magneto')['neuroid']) == 288
+    assert len(assembly['neuroid']) == len(np.unique(assembly['neuroid_id'])) == 288 * 2
+    # filter noisy electrodes
+    assembly = filter_neuroids(assembly, threshold=.7)
+    # add time info
+    assembly = assembly.expand_dims('time_bin')
+    assembly['time_bin_start'] = 'time_bin', [70]
+    assembly['time_bin_end'] = 'time_bin', [170]
+    assembly = assembly.transpose('presentation', 'neuroid', 'time_bin')
+    return assembly
+
+
+def load_stimuli_ids(data_dir):
+    # these stimuli_ids are SHA1 hashes on generative parameters
+    stimuli_ids = h5py.File(data_dir / 'hvm640_ids.mat', 'r')
+    stimuli_ids = [''.join(chr(c) for c in stimuli_ids[stimuli_ids['hvm640_ids'].value[0, i]])
+                   for i in range(stimuli_ids['hvm640_ids'].value[0].size)]
+    # we use the filenames to reference into our packaged StimulusSet ids
+    stimuli_filenames = h5py.File(data_dir / 'hvm640_names.mat', 'r')
+    stimuli_filenames = [''.join(chr(c) for c in stimuli_filenames[stimuli_filenames['hvm640_img_names'].value[0, i]])
+                         for i in range(stimuli_filenames['hvm640_img_names'].value[0].size)]
+    # the stimuli_ids in our packaged StimulusSets are SHA1 hashes on pixels.
+    # we thus need to reference between those two ids.
+    packaged_stimuli = brainio_collection.get_stimulus_set('hvm')
+    reference_table = {row.image_file_name: row.image_id for row in packaged_stimuli.itertuples()}
+    referenced_ids = [reference_table[filename] for filename in stimuli_filenames]
+    return {'image_id': ('image_id', referenced_ids),
+            'image_generative_id': ('image_id', stimuli_ids)}
+
+
+def main():
+    data_dir = Path(__file__).parent / 'hvm'
+    stimuli_ids = load_stimuli_ids(data_dir)
+
+    assembly = load_responses(data_dir / 'hvm640_neural.h5', additional_coords=stimuli_ids)
+    assembly.name = 'dicarlo.Kar2018hvm'
+
+    package_data_assembly(assembly, data_assembly_name=assembly.name, stimulus_set_name='hvm',
+                          bucket_name='brainio-dicarlo')
+
+
+if __name__ == '__main__':
+    main()

brainscore_vision/data/kar2018/data_packaging/requirements.txt

@@ -0,0 +1 @@
+git+git://github.com/brain-score/brain-score@c9e8c1e#egg=brain-score

brainscore_vision/data/kar2018/test.py

@@ -0,0 +1,10 @@
+import brainscore_vision
+import pytest
+
+
+@pytest.mark.parametrize('assembly_identifier', [
+    pytest.param('Kar2018hvm', marks=[pytest.mark.private_access]),
+    pytest.param('Kar2018cocogray', marks=[pytest.mark.private_access]),
+])
+def test_existence(assembly_identifier):
+    assert brainscore_vision.load_dataset(assembly_identifier) is not None

brainscore_vision/data/kar2019/__init__.py

@@ -0,0 +1,43 @@
+from brainio.assemblies import DataAssembly
+
+from brainscore_vision import data_registry, stimulus_set_registry, load_stimulus_set
+from brainscore_vision.data_helpers.s3 import load_assembly_from_s3, load_stimulus_set_from_s3
+
+BIBTEX = """@Article{Kar2019,
+            author={Kar, Kohitij
+            and Kubilius, Jonas
+            and Schmidt, Kailyn
+            and Issa, Elias B.
+            and DiCarlo, James J.},
+            title={Evidence that recurrent circuits are critical to the ventral stream's execution of core object recognition behavior},
+            journal={Nature Neuroscience},
+            year={2019},
+            month={Jun},
+            day={01},
+            volume={22},
+            number={6},
+            pages={974-983},
+            abstract={Non-recurrent deep convolutional neural networks (CNNs) are currently the best at modeling core object recognition, a behavior that is supported by the densely recurrent primate ventral stream, culminating in the inferior temporal (IT) cortex. If recurrence is critical to this behavior, then primates should outperform feedforward-only deep CNNs for images that require additional recurrent processing beyond the feedforward IT response. Here we first used behavioral methods to discover hundreds of these `challenge' images. Second, using large-scale electrophysiology, we observed that behaviorally sufficient object identity solutions emerged {\textasciitilde}30{\thinspace}ms later in the IT cortex for challenge images compared with primate performance-matched `control' images. Third, these behaviorally critical late-phase IT response patterns were poorly predicted by feedforward deep CNN activations. Notably, very-deep CNNs and shallower recurrent CNNs better predicted these late IT responses, suggesting that there is a functional equivalence between additional nonlinear transformations and recurrence. Beyond arguing that recurrent circuits are critical for rapid object identification, our results provide strong constraints for future recurrent model development.},
+            issn={1546-1726},
+            doi={10.1038/s41593-019-0392-5},
+            url={https://doi.org/10.1038/s41593-019-0392-5}
+            }"""
+
+# assembly
+data_registry['Kar2019'] = lambda: load_assembly_from_s3(
+    identifier="dicarlo.Kar2019",
+    version_id="mQZ1nNRfE_m_IjFbox.xvlJvbudFwsWo",
+    sha1="147717ce397e11d56164d472063a84a83bbcbb94",
+    bucket="brainio-brainscore",
+    cls=DataAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('Kar2019'),
+)
+
+# stimulus set
+stimulus_set_registry['Kar2019'] = lambda: load_stimulus_set_from_s3(
+    identifier="Kar2019",
+    bucket="brainio-brainscore",
+    csv_sha1="7f705bdea02c0a72a76d7f5e7b6963531df818a6",
+    zip_sha1="75ab7b8b499fc8e86c813f717b79d268bcb986be",
+    csv_version_id="RxErKK258xYBuO6.ThuQU0IACEWkZ20o",
+    zip_version_id="3ArjwRwvdMgjwA2VP63zQ4rhF5WIbr.L")

brainscore_vision/data/kar2019/data_packaging.py

@@ -0,0 +1,116 @@
+import os
+
+import h5py
+import numpy as np
+import pandas as pd
+import scipy.misc
+import scipy.misc
+import scipy.misc
+import xarray as xr
+from result_caching import store
+from tqdm import tqdm
+
+from brainio_base.assemblies import DataAssembly
+from brainio_base.stimuli import StimulusSet
+from brainio_collection.knownfile import KnownFile
+from brainio_contrib.packaging import package_stimulus_set, package_data_assembly
+from brainscore_vision.data_helpers.lookup_legacy import version_id_df, build_filename
+
+# extract version ids from version_ids csv
+assembly_version = version_id_df.at[build_filename('dicarlo.Kar2019', '.nc'), 'version_id']
+csv_version = version_id_df.at[build_filename('Kar2019', '.csv'), 'version_id']
+zip_version = version_id_df.at[build_filename('Kar2019', '.zip'), 'version_id']
+
+object_lookup = {
+    1: 'bear',
+    2: 'elephant',
+    3: 'person',
+    4: 'car',
+    5: 'dog',
+    6: 'apple',
+    7: 'chair',
+    8: 'plane',
+    9: 'bird',
+    10: 'zebra',
+}
+
+
+@store(identifier_ignore=['stimuli_dir'])
+def collect_stimuli(data_path, stimuli_dir):
+    stimuli = []
+    with h5py.File(data_path, 'r') as f:
+        images, objects = f['images'], f['obj']
+        os.makedirs(stimuli_dir, exist_ok=True)
+        for image_num, (image, obj) in tqdm(enumerate(zip(images, objects[0])), desc='stimuli', total=len(images)):
+            image = image.transpose([1, 2, 0])
+            obj = object_lookup[obj]
+            filename = f"image_{image_num:04d}.jpg"
+            target_path = os.path.join(stimuli_dir, filename)
+            scipy.misc.imsave(target_path, np.rot90(np.fliplr(image)))
+            im_kf = KnownFile(target_path)
+            stimuli.append({
+                'image_current_local_file_path': target_path,
+                'image_path_within_store': filename,
+                "image_file_sha1": im_kf.sha1,
+                "image_id": im_kf.sha1,
+                'image_num': image_num,
+                'image_label': obj,
+            })
+    stimuli = StimulusSet(stimuli)
+    return stimuli
+
+
+@store(identifier_ignore=['stimuli'])
+def collect_data(data_folder, stimuli):
+    data = []
+    with h5py.File(os.path.join(data_folder, 'dataset.h5'), 'r') as svm_f, \
+            h5py.File(os.path.join(data_folder, 'ost_on_logistic.mat'), 'r') as logistic_f:
+        svm_osts, logistic_osts, i1s = svm_f['ost'], logistic_f['ost'], svm_f['i1']
+        for svm_ost, logistic_ost, i1, stimuli_row in tqdm(zip(
+                svm_osts[0], logistic_osts[0], i1s[0], stimuli.itertuples()), total=len(svm_osts), desc='trials'):
+            row = {'ost-svm': svm_ost, 'ost-logistic': logistic_ost, 'i1': i1,
+                   'image_id': stimuli_row.image_id, 'image_label': stimuli_row.image_label}
+            data.append(row)
+    data = pd.DataFrame(data)
+    data = to_xarray(data)
+    return data
+
+
+def to_xarray(data):
+    presentation_columns = [column for column in data.columns if column not in ['ost-svm', 'ost-logistic']]
+    data = xr.DataArray(np.stack((data['ost-svm'], data['ost-logistic'])),
+                        coords={**{column: ('presentation', data[column]) for column in presentation_columns},
+                                **{'decoder': ['svm', 'logistic']}},
+                        dims=['decoder', 'presentation'])
+    data = data.set_index(presentation=presentation_columns)
+    data = DataAssembly(data)
+    return data
+
+
+def main():
+    data_path = os.path.join(os.path.dirname(__file__), 'Kar2019OST')
+    target_dir = os.path.join(os.path.dirname(__file__), 'Kar2019OST')
+    target_stimuli_dir = os.path.join(target_dir, 'stimuli')
+    stimuli = collect_stimuli(os.path.join(data_path, 'dataset.h5'), target_stimuli_dir)
+    assembly = collect_data(data_path, stimuli)
+
+    assert len(stimuli) == len(assembly['presentation']) == 1320
+    assert len(set(assembly['image_id'].values)) == 1318
+    assert set(assembly['image_id'].values) == set(stimuli['image_id'])
+    assert len(set(assembly['image_label'].values)) == 10
+
+    assembly.name = 'dicarlo.Kar2019'
+    stimuli.name = 'Kar2019'
+    package(assembly, stimuli)
+
+
+def package(assembly, stimuli):
+    print("Packaging stimuli")
+    package_stimulus_set(stimuli, stimulus_set_name=stimuli.name)
+
+    print("Packaging assembly")
+    package_data_assembly(assembly, data_assembly_name=assembly.name, stimulus_set_name=stimuli.name)
+
+
+if __name__ == '__main__':
+    main()

brainscore_vision/data/kar2019/test.py

@@ -0,0 +1,8 @@
+import pytest
+
+import brainscore_vision
+
+
+@pytest.mark.private_access
+def test_existence():
+    assert brainscore_vision.load_dataset('Kar2019') is not None

brainscore_vision/data/kuzovkin2018/__init__.py

@@ -0,0 +1,36 @@
+from brainio.assemblies import NeuronRecordingAssembly
+
+from brainscore_vision import data_registry, stimulus_set_registry, load_stimulus_set
+from brainscore_vision.data_helpers.s3 import load_stimulus_set_from_s3, load_assembly_from_s3
+
+BIBTEX = """@article{kuzovkin2018activations,
+  title={Activations of deep convolutional neural networks are aligned with gamma band activity of human visual cortex},
+  author={Kuzovkin, Ilya and Vicente, Raul and Petton, Mathilde and Lachaux, Jean-Philippe and Baciu, Monica and Kahane, Philippe and Rheims, Sylvain and Vidal, Juan R and Aru, Jaan},
+  journal={Communications biology},
+  volume={1},
+  number={1},
+  pages={1--12},
+  year={2018},
+  publisher={Nature Publishing Group}
+}"""
+
+
+# assembly
+data_registry['Kuzovkin2018'] = lambda: load_assembly_from_s3(
+    identifier="aru.Kuzovkin2018",
+    version_id="nk5w.m3N1D4fWg2PeY9_AJb5yY6UtPeM",
+    sha1="c3787b30ffdc6816e245a8f8d8f2096d8bf85569",
+    bucket="brainio-brainscore",
+    cls=NeuronRecordingAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('Kuzovkin2018'),
+)
+
+# stimulus set
+stimulus_set_registry['Kuzovkin2018'] = lambda: load_stimulus_set_from_s3(
+    identifier="Kuzovkin2018",
+    bucket="brainio-brainscore",
+    csv_sha1="f40cbe9f385c2f391952bcc91cec3878a18f0bc4",
+    zip_sha1="9698c22f30b19d68bbb72195eaefbdf4a5899f57",
+    csv_version_id="OGF_grA_sVBC6J5famXr0HXIpyww64Q1",
+    zip_version_id="Bi88nsPyg3Es5CbMTPQykR.Z3yABIksy",
+)