brainscore-vision 2.1__py3-none-any.whl

brainscore_vision/data/rust2012/__init__.py

@@ -0,0 +1,45 @@
+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{rust2012balanced,
+  title={Balanced increases in selectivity and tolerance produce constant sparseness along the ventral visual stream},
+  author={Rust, Nicole C and DiCarlo, James J},
+  journal={Journal of Neuroscience},
+  volume={32},
+  number={30},
+  pages={10170--10182},
+  year={2012},
+  publisher={Soc Neuroscience}
+}"""
+
+# dicarlo.Rust2012.single assembly
+data_registry['Rust2012.single'] = lambda: load_assembly_from_s3(
+    identifier="dicarlo.Rust2012.single",
+    version_id="8T7Pt1LwHPRoxCC9c9xBfMNGDSJ0b3e4",
+    sha1="4ef420e70fbd0de3745df5be7c83dfc0a8f2e528",
+    bucket="brainio-brainscore",
+    cls=NeuronRecordingAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('Rust2012'),
+)
+
+# dicarlo.Rust2012.array assembly
+data_registry['Rust2012.array'] = lambda: load_assembly_from_s3(
+    identifier="dicarlo.Rust2012.array",
+    version_id="O_8qaKqFhzRNOIvVx8djTQDUE0a6g.w9",
+    sha1="6709b641751370acfccd9567e3d75b71865a71ab",
+    bucket="brainio-brainscore",
+    cls=NeuronRecordingAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('Rust2012'),
+)
+
+
+# stimulus set
+stimulus_set_registry['Rust2012'] = lambda: load_stimulus_set_from_s3(
+    identifier="Rust2012",
+    bucket="brainio-brainscore",
+    csv_sha1="482da1f9f4a0ab5433c3b7b57073ad30e45c2bf1",
+    zip_sha1="7cbf5dcec235f7705eaad1cfae202eda77e261a2",
+    csv_version_id="Rke9xnpOob26SiZOm6KAeHZ48ppvtkA8",
+    zip_version_id="Nd1aGb9bloW3HRYene6ogiAnA6PVc_5I")

brainscore_vision/data/rust2012/rust305.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+
+import numpy as np
+import xarray as xr
+import pandas as pd
+
+import brainio_collection
+from brainio_base.assemblies import NeuronRecordingAssembly
+from brainio_collection.packaging import package_data_assembly
+
+
+def main():
+    stimuli = brainio_collection.get_stimulus_set('Rust2012')
+
+    single_nc_path = Path("/Users/jjpr/dev/dldata/scripts/rust_single.nc")
+    da_single = xr.open_dataarray(single_nc_path)
+    da_single.name = 'dicarlo.Rust2012.single'
+
+    print('Packaging assembly for single-unit')
+    package_data_assembly(da_single, assembly_identifier=da_single.name, stimulus_set_identifier=stimuli.identifier,
+                          bucket_name='brainio.dicarlo')
+
+    array_nc_path = Path("/Users/jjpr/dev/dldata/scripts/rust_array.nc")
+    da_array = xr.open_dataarray(array_nc_path)
+    da_array.name = 'dicarlo.Rust2012.array'
+
+    print('Packaging assembly for array')
+    package_data_assembly(da_array, assembly_identifier=da_array.name, stimulus_set_identifier=stimuli.identifier,
+                          bucket_name='brainio.dicarlo')
+
+
+if __name__ == '__main__':
+    main()
+
+

brainscore_vision/data/rust2012/test.py

@@ -0,0 +1,47 @@
+import pytest
+from brainscore_vision import load_dataset
+
+
+@pytest.mark.private_access
+@pytest.mark.parametrize('assembly_identifier', [
+    'Rust2012.single',
+    'Rust2012.array'])
+def test_existence(assembly_identifier):
+    assert load_dataset(assembly_identifier) is not None
+
+
+class TestRustSingle:
+    @pytest.mark.private_access
+    def test_dims(self):
+        assembly = load_dataset('Rust2012.single')
+        # (neuroid: 285, presentation: 1500, time_bin: 1)
+        assert assembly.dims == ("neuroid", "presentation", "time_bin")
+        assert len(assembly['neuroid']) == 285
+        assert len(assembly['presentation']) == 1500
+        assert len(assembly['time_bin']) == 1
+
+    @pytest.mark.private_access
+    def test_coords(self):
+        assembly = load_dataset('Rust2012.single')
+        assert len(set(assembly['stimulus_id'].values)) == 300
+        assert len(set(assembly['neuroid_id'].values)) == 285
+        assert len(set(assembly['region'].values)) == 2
+
+
+class TestRustArray:
+    @pytest.mark.private_access
+    def test_dims(self):
+        assembly = load_dataset('Rust2012.array')
+        # (neuroid: 296, presentation: 53700, time_bin: 6)
+        assert assembly.dims == ("neuroid", "presentation", "time_bin")
+        assert len(assembly['neuroid']) == 296
+        assert len(assembly['presentation']) == 53700
+        assert len(assembly['time_bin']) == 6
+
+    @pytest.mark.private_access
+    def test_coords(self):
+        assembly = load_dataset('Rust2012.array')
+        assert len(set(assembly['stimulus_id'].values)) == 300
+        assert len(set(assembly['neuroid_id'].values)) == 296
+        assert len(set(assembly['animal'].values)) == 2
+        assert len(set(assembly['region'].values)) == 2

brainscore_vision/data/sanghavi2020/__init__.py

@@ -0,0 +1,119 @@
+from brainio.assemblies import NeuronRecordingAssembly
+from brainscore_vision import data_registry, stimulus_set_registry, load_stimulus_set, load_ceiling
+from brainscore_vision.data_helpers.s3 import load_stimulus_set_from_s3, load_assembly_from_s3
+from brainscore_vision.metric_helpers.transformations import CrossValidation
+
+BIBTEX_SANGHAVI = """  @misc{Sanghavi2020,
+  title={SanghaviMurty2020},
+  url={osf.io/CHWDK},
+  DOI={10.17605/OSF.IO/CHWDK},
+  publisher={OSF},
+  author={Sanghavi, Sachi and DiCarlo, James J},
+  year={2020},
+  month={Nov}
+}"""  # 'HvM' images from (Majaj et al., 2015)
+BIBTEX_SANGHAVIMURTY = """  @misc{SanghaviMurty2020,
+  title={SanghaviMurty2020},
+  url={osf.io/fchme},
+  DOI={10.17605/OSF.IO/FCHME},
+  publisher={OSF},
+  author={Sanghavi, Sachi and Murty, N A R and DiCarlo, James J},
+  year={2020},
+  month={Nov}
+}"""  # BOLD5000 images
+BIBTEX_SANGHAVIJOZWIK = """  @misc{SanghaviJozwik2020,
+  title={SanghaviJozwik2020},
+  url={osf.io/FHY36},
+  DOI={10.17605/OSF.IO/FHY36},
+  publisher={OSF},
+  author={Sanghavi, Sachi and Jozwik, K M and DiCarlo, James J},
+  year={2020},
+  month={Nov}
+}"""  # images from (Rust & DiCarlo, 2012)
+
+# assemblies: dicarlo.Sanghavi2020 uses hvm
+data_registry['Sanghavi2020'] = lambda: load_assembly_from_s3(
+    identifier="dicarlo.Sanghavi2020",
+    version_id="RZz2m5wUm.wgYyMEDY9UCMuyYjZKDuzw",
+    sha1="12e94e9dcda797c851021dfe818b64615c785866",
+    bucket="brainio-brainscore",
+    cls=NeuronRecordingAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('hvm'),
+)
+
+# assemblies: dicarlo.SanghaviJozwik2020 uses dicarlo.BOLD5000
+data_registry['SanghaviJozwik2020'] = lambda: load_assembly_from_s3(
+    identifier="dicarlo.SanghaviJozwik2020",
+    version_id="j5AiLVh8xbchFP2CxVxFoifAeJy1vwHA",
+    sha1="c5841f1e7d2cf0544a6ee010e56e4e2eb0994ee0",
+    bucket="brainio-brainscore",
+    cls=NeuronRecordingAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('BOLD5000'),
+)
+
+# assemblies: dicarlo.SanghaviMurty2020 uses dicarlo.Rust2012
+data_registry['SanghaviMurty2020'] = lambda: load_assembly_from_s3(
+    identifier="dicarlo.SanghaviMurty2020",
+    version_id="yvyTo2fM8kLsa7h7WMWC8jcqC2uAx.kp",
+    sha1="6cb8e054688066d1d86d4944e1385efc6a69ebd4",
+    bucket="brainio-brainscore",
+    cls=NeuronRecordingAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('Rust2012'),
+)
+
+# assemblies: dicarlo.SanghaviMurty2020THINGS1 uses THINGS1
+data_registry['SanghaviMurty2020THINGS1'] = lambda: load_assembly_from_s3(
+    identifier="dicarlo.SanghaviMurty2020THINGS1",
+    version_id=".n3o2r4SKG4fO829jJPl9zz1UaSM7okH",
+    sha1="718def227d38c8425f449512e47a2df81c04de62",
+    bucket="brainio-brainscore",
+    cls=NeuronRecordingAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('THINGS1'),
+)
+
+# assemblies: dicarlo.SanghaviMurty2020THINGS2 uses THINGS2
+data_registry['SanghaviMurty2020THINGS2'] = lambda: load_assembly_from_s3(
+    identifier="dicarlo.SanghaviMurty2020THINGS2",
+    version_id="z_MWZd12fk.AIcQzwRh6.vOIHhxInWRl",
+    sha1="80962139823cb145e2385c344e3945e99ed97fa2",
+    bucket="brainio-brainscore",
+    cls=NeuronRecordingAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('THINGS2'),
+)
+
+# stimulus set: BOLD5000 - can put in sanghavi
+stimulus_set_registry['BOLD5000'] = lambda: load_stimulus_set_from_s3(
+    identifier="BOLD5000",
+    bucket="brainio-brainscore",
+    csv_sha1="51ac47ea03ed2e72864a95065494c2fabe779f6e",
+    zip_sha1="1a2e6d782dcd21bbe60460d85d83b13fa76a9543",
+    csv_version_id="N9Z4t92mjMy5263NS7RR5aBdYO9dYfwk",
+    zip_version_id="jvMlEMa1EgRZkfH32gIFO4GcNpqktbgf")
+
+# stimulus set: THINGS1
+stimulus_set_registry['THINGS1'] = lambda: load_stimulus_set_from_s3(
+    identifier="THINGS1",
+    bucket="brainio-brainscore",
+    csv_sha1="e02469d805e1b9c1a18403e9b0b8a37ee6da5130",
+    zip_sha1="fb716eb58c303157dd577a70caad5c8079e74e9b",
+    csv_version_id="78G61z8fE5W7rTR9ciBzrFYfmGCPTxlK",
+    zip_version_id="fuYRTLrKs2PwHkobkh0DNK7MvfKJjGGa")
+
+# stimulus set: THINGS2
+stimulus_set_registry['THINGS2'] = lambda: load_stimulus_set_from_s3(
+    identifier="THINGS2",
+    bucket="brainio-brainscore",
+    csv_sha1="86c8beda8f495cd69ed047d3457902dd98e4904c",
+    zip_sha1="e7918dd10102b67464bc652fdb3ced25ee1fbe7a",
+    csv_version_id="47dAhleyD_t8OsmsxUBLGu8zjXX8lgCY",
+    zip_version_id="uBlltL4vYjXyMv5bt_9HNoARpjuke2wQ")
+
+
+def filter_neuroids(assembly, threshold):
+    ceiler = load_ceiling('internal_consistency')
+    ceiling = ceiler(assembly)
+    ceiling = ceiling.raw
+    ceiling = CrossValidation().aggregate(ceiling)
+    pass_threshold = ceiling >= threshold
+    assembly = assembly[{'neuroid': pass_threshold}]
+    return assembly

brainscore_vision/data/sanghavi2020/data_packaging/environment.yml

@@ -0,0 +1,36 @@
+name: packaging_sanghavi
+channels:
+  - defaults
+dependencies:
+  - bokeh=2.1.1
+  - curl=7.69.1
+  - h5py=2.10.0
+  - hdf5=1.10.4
+  - jupyter=1.0.0
+  - matplotlib=3.2.2
+  - netcdf4=1.5.3
+  - numpy=1.18.5
+  - pillow=7.1.2
+  - pip=20.1.1
+  - plotly=4.7.1
+  - pyqt=5.9.2
+  - pytables=3.6.1
+  - pytest=5.4.3
+  - python=3.6.10
+  - qt=5.9.7
+  - requests=2.24.0
+  - scipy=1.5.0
+  - sqlalchemy=1.3.18
+  - widgetsnbextension=3.5.1
+  - xlrd=1.2.0
+  - pip:
+    - boto3==1.14.16
+    - git+https://github.com/brain-score/brain-score
+    - git+https://github.com/brain-score/brainio_base.git
+    - git+https://github.com/brain-score/brainio_collection.git
+    - pandas==0.25.3
+    - xarray==0.12.0
+    - dataset
+    - ipyvolume
+prefix: /Users/etotheipiplusone/miniconda3/envs/packaging_sanghavi
+

brainscore_vision/data/sanghavi2020/data_packaging/requirements.txt

@@ -0,0 +1,4 @@
+brain-score @ git+https://github.com/brain-score/brain-score@1e4eacb8e1a2c98e55083218ee68a1fc7680d0b0
+brainio-base @ git+https://github.com/brain-score/brainio_base@f6553fad46f3451ce51b8916386de1235630de72
+brainio-collection @ git+https://github.com/brain-score/brainio_collection@dad8991adb0def87e496553cfce9d0ee33b53c21
+tqdm==4.66.3

brainscore_vision/data/sanghavi2020/data_packaging/sanghavi2020.py

@@ -0,0 +1,101 @@
+import os
+from pathlib import Path
+import json
+
+import numpy as np
+import xarray as xr
+import pandas as pd
+
+import brainio_collection
+from brainio_base.assemblies import NeuronRecordingAssembly
+from brainio_collection.packaging import package_data_assembly
+from mkgu_packaging.dicarlo.sanghavi import filter_neuroids
+
+
+def load_responses(data_dir, stimuli):
+    psth = np.load(data_dir / 'solo.rsvp.hvm.experiment_psth.npy')  # Shaped images x repetitions x time_bins x channels
+
+    # Drop first (index 0) and second last session (index 25) since they had only one repetition each
+    # Actually not, since we're sticking to older protocol re: data cleaning for now
+    # psth = np.delete(psth, (0, 25), axis=1)
+
+    # Compute firing rate for given time bins
+    timebins = [[70, 170], [170, 270], [50, 100], [100, 150], [150, 200], [200, 250], [70, 270]]
+    photodiode_delay = 30  # Delay recorded on photodiode is ~30ms
+    timebase = np.arange(-100, 381, 10)  # PSTH from -100ms to 380ms relative to stimulus onset
+    assert len(timebase) == psth.shape[2]
+    rate = np.empty((len(timebins), psth.shape[0], psth.shape[1], psth.shape[3]))
+    for idx, tb in enumerate(timebins):
+        t_cols = np.where((timebase >= (tb[0] + photodiode_delay)) & (timebase < (tb[1] + photodiode_delay)))[0]
+        rate[idx] = np.mean(psth[:, :, t_cols, :], axis=2)  # Shaped time bins x images x repetitions x channels
+
+    # Load image related meta data (id ordering differs from dicarlo.hvm)
+    image_id = [x.split()[0][:-4] for x in open(data_dir.parent / 'image-metadata' / 'hvm_map.txt').readlines()]
+    # Load neuroid related meta data
+    neuroid_meta = pd.DataFrame(json.load(open(data_dir.parent / 'array-metadata' / 'mapping.json')))
+
+    assembly = xr.DataArray(rate,
+                            coords={'repetition': ('repetition', list(range(rate.shape[2]))),
+                                    'time_bin_id': ('time_bin', list(range(rate.shape[0]))),
+                                    'time_bin_start': ('time_bin', [x[0] for x in timebins]),
+                                    'time_bin_stop': ('time_bin', [x[1] for x in timebins]),
+                                    'image_id': ('image', image_id)},
+                            dims=['time_bin', 'image', 'repetition', 'neuroid'])
+
+    for column_name, column_data in neuroid_meta.iteritems():
+        assembly = assembly.assign_coords(**{f'{column_name}': ('neuroid', list(column_data.values))})
+
+    assembly = assembly.sortby(assembly.image_id)
+    stimuli = stimuli.sort_values(by='image_id').reset_index(drop=True)
+    for column_name, column_data in stimuli.iteritems():
+        assembly = assembly.assign_coords(**{f'{column_name}': ('image', list(column_data.values))})
+    assembly = assembly.sortby(assembly.id)  # Re-order by id to match dicarlo.hvm ordering
+
+    # Collapse dimensions 'image' and 'repetitions' into a single 'presentation' dimension
+    assembly = assembly.stack(presentation=('image', 'repetition')).reset_index('presentation')
+    assembly = NeuronRecordingAssembly(assembly)
+
+    # Filter noisy electrodes
+    psth = np.load(data_dir / 'solo.rsvp.hvm.normalizer_psth.npy')
+    t_cols = np.where((timebase >= (70 + photodiode_delay)) & (timebase < (170 + photodiode_delay)))[0]
+    rate = np.mean(psth[:, :, t_cols, :], axis=2)
+    normalizer_assembly = xr.DataArray(rate,
+                                       coords={'repetition': ('repetition', list(range(rate.shape[1]))),
+                                               'image_id': ('image', list(range(rate.shape[0]))),
+                                               'id': ('image', list(range(rate.shape[0])))},
+                                       dims=['image', 'repetition', 'neuroid'])
+    for column_name, column_data in neuroid_meta.iteritems():
+        normalizer_assembly = normalizer_assembly.assign_coords(
+            **{f'{column_name}': ('neuroid', list(column_data.values))})
+    normalizer_assembly = normalizer_assembly.stack(presentation=('image', 'repetition')).reset_index('presentation')
+    normalizer_assembly = normalizer_assembly.drop('image')
+    normalizer_assembly = normalizer_assembly.transpose('presentation', 'neuroid')
+    normalizer_assembly = NeuronRecordingAssembly(normalizer_assembly)
+
+    filtered_assembly = filter_neuroids(normalizer_assembly, 0.7)
+    assembly = assembly.sel(neuroid=np.isin(assembly.neuroid_id, filtered_assembly.neuroid_id))
+    assembly = assembly.transpose('presentation', 'neuroid', 'time_bin')
+
+    # Add other experiment related info
+    assembly.attrs['image_size_degree'] = 8
+    assembly.attrs['stim_on_time_ms'] = 100
+
+    return assembly
+
+
+def main():
+    data_dir = Path(__file__).parents[6] / 'data2' / 'active' / 'users' / 'sachis' / 'database'
+    assert os.path.isdir(data_dir)
+
+    stimuli = brainio_collection.get_stimulus_set('hvm')
+    assembly = load_responses(data_dir, stimuli)
+    assembly.name = 'dicarlo.Sanghavi2020'
+
+    print('Packaging assembly')
+    package_data_assembly(assembly, assembly_identifier=assembly.name, stimulus_set_identifier=stimuli.identifier,
+                          bucket_name='brainio.dicarlo')
+    return
+
+
+if __name__ == '__main__':
+    main()

brainscore_vision/data/sanghavi2020/data_packaging/sanghavijozwik2020.py

@@ -0,0 +1,148 @@
+import os
+from pathlib import Path
+import pickle
+import json
+
+import numpy as np
+import xarray as xr
+import pandas as pd
+
+from brainio_base.assemblies import NeuronRecordingAssembly
+from brainio_base.stimuli import StimulusSet
+from brainio_collection.packaging import package_data_assembly, package_stimulus_set
+from mkgu_packaging.dicarlo.sanghavi import filter_neuroids
+
+
+def collect_stimuli(data_dir):
+    image_dir = data_dir / 'images' / 'bold5000'
+    assert os.path.isdir(image_dir)
+    files = sorted(os.listdir(image_dir), key=lambda x: int(os.path.splitext(x)[0].split('_')[-1]))
+    files = files[:-30]  # Discard last 30 images (5 grey and 25 normalizer images)
+
+    assert os.path.isdir(data_dir / 'image-metadata')
+    stimuli = pickle.load(open(data_dir / 'image-metadata' / 'bold5000_metadata.pkl', 'rb'))
+    # Rename columns
+    stimuli = stimuli.rename(columns={'image_id': 'id', 'original_dataset': 'source_dataset',
+                                      'image_file_name': 'image_id', 'wordnet_id': 'imagenet_synset',
+                                      'category': 'coco_category', 'category_id': 'coco_category_id',
+                                      'flickr_url': 'coco_flickr_url', 'area': 'coco_area',
+                                      'bbox': 'coco_bbox', 'supercategory': 'coco_supercategory',
+                                      'label_id': 'coco_label_id', 'segmentation': 'coco_segmentation'})
+    # Replace all NaNs with None
+    stimuli = stimuli.where(pd.notnull(stimuli), None)
+
+    # Stringify lists and ndarrays
+    stimuli['label'] = stimuli['label'].apply(lambda x: str(list(x)).strip('[]') if type(x) is np.ndarray else x)
+    stimuli['coco_label_id'] = stimuli['coco_label_id'].apply(lambda x: str(list(x)) if type(x) is np.ndarray else x)
+    stimuli['coco_area'] = stimuli['coco_area'].apply(lambda x: str(list(x)) if type(x) is np.ndarray else x)
+    stimuli['coco_bbox'] = stimuli['coco_bbox'].apply(lambda x: str(list(x)) if type(x) is np.ndarray else x)
+    stimuli['coco_category_id'] = stimuli['coco_category_id'].apply(lambda x: str(list(x)) if type(x) is np.ndarray else x)
+    stimuli['coco_category'] = stimuli['coco_category'].apply(lambda x: str(x) if type(x) is list else x)
+    stimuli['coco_segmentation'] = stimuli['coco_segmentation'].apply(lambda x: str(list(x)) if type(x) is np.ndarray else x)
+    stimuli['coco_supercategory'] = stimuli['coco_supercategory'].apply(lambda x: str(x) if type(x) is list else x)
+
+    # Temporarily drop columns unique to a single source dataset, since filtering method breaks down
+    # (with NaN/None?), and so does pandas read when fetching assembly from S3
+    stimuli = stimuli.drop(['coco_url', 'coco_flickr_url', 'coco_category_id', 'coco_category', 'coco_supercategory',
+                            'coco_segmentation', 'coco_label_id', 'coco_area', 'coco_bbox', 'coco_id',
+                            'imagenet_synset'], axis=1)
+
+    stimuli['image_file_name'] = ''
+    stimuli['image_current_local_file_path'] = ''
+
+    for idx, image_file_name in enumerate(files):
+        image_file_path = os.path.join(image_dir, image_file_name)
+
+        stimuli.at[idx, 'image_file_name'] = image_file_name
+        stimuli.at[idx, 'image_current_local_file_path'] = image_file_path
+
+    assert len(np.unique(stimuli['image_id'])) == len(stimuli)
+    stimuli = StimulusSet(stimuli)
+    stimuli.image_paths = \
+        {stimuli.at[idx, 'image_id']: stimuli.at[idx, 'image_current_local_file_path'] for idx in range(len(stimuli))}
+    return stimuli
+
+
+def load_responses(data_dir, stimuli):
+    data_dir = data_dir / 'database'
+    assert os.path.isdir(data_dir)
+    psth = np.load(data_dir / 'solo.rsvp.bold5000.experiment_psth.npy')  # Shaped images x repetitions x time_bins x channels
+
+    # Compute firing rate for given time bins
+    timebins = [[70, 170], [170, 270], [50, 100], [100, 150], [150, 200], [200, 250], [70, 270]]
+    photodiode_delay = 30  # Delay recorded on photodiode is ~30ms
+    timebase = np.arange(-100, 381, 10)  # PSTH from -100ms to 380ms relative to stimulus onset
+    assert len(timebase) == psth.shape[2]
+    rate = np.empty((len(timebins), psth.shape[0], psth.shape[1], psth.shape[3]))
+    for idx, tb in enumerate(timebins):
+        t_cols = np.where((timebase >= (tb[0] + photodiode_delay)) & (timebase < (tb[1] + photodiode_delay)))[0]
+        rate[idx] = np.mean(psth[:, :, t_cols, :], axis=2)  # Shaped time bins x images x repetitions x channels
+
+    assembly = xr.DataArray(rate,
+                            coords={'repetition': ('repetition', list(range(rate.shape[2]))),
+                                    'time_bin_id': ('time_bin', list(range(rate.shape[0]))),
+                                    'time_bin_start': ('time_bin', [x[0] for x in timebins]),
+                                    'time_bin_stop': ('time_bin', [x[1] for x in timebins])},
+                            dims=['time_bin', 'image', 'repetition', 'neuroid'])
+
+    # Add neuroid related meta data
+    neuroid_meta = pd.DataFrame(json.load(open(data_dir.parent / 'array-metadata' / 'mapping.json')))
+    for column_name, column_data in neuroid_meta.iteritems():
+        assembly = assembly.assign_coords(**{f'{column_name}': ('neuroid', list(column_data.values))})
+
+    # Add stimulus related meta data
+    for column_name, column_data in stimuli.iteritems():
+        assembly = assembly.assign_coords(**{f'{column_name}': ('image', list(column_data.values))})
+
+    # Collapse dimensions 'image' and 'repetitions' into a single 'presentation' dimension
+    assembly = assembly.stack(presentation=('image', 'repetition')).reset_index('presentation')
+    assembly = assembly.drop('image')
+    assembly = NeuronRecordingAssembly(assembly)
+
+    # Filter noisy electrodes
+    psth = np.load(data_dir / 'solo.rsvp.bold5000.normalizer_psth.npy')
+    t_cols = np.where((timebase >= (70 + photodiode_delay)) & (timebase < (170 + photodiode_delay)))[0]
+    rate = np.mean(psth[:, :, t_cols, :], axis=2)
+    normalizer_assembly = xr.DataArray(rate,
+                                       coords={'repetition': ('repetition', list(range(rate.shape[1]))),
+                                               'image_id': ('image', list(range(rate.shape[0]))),
+                                               'id': ('image', list(range(rate.shape[0])))},
+                                       dims=['image', 'repetition', 'neuroid'])
+    for column_name, column_data in neuroid_meta.iteritems():
+        normalizer_assembly = normalizer_assembly.assign_coords(
+            **{f'{column_name}': ('neuroid', list(column_data.values))})
+    normalizer_assembly = normalizer_assembly.stack(presentation=('image', 'repetition')).reset_index('presentation')
+    normalizer_assembly = normalizer_assembly.drop('image')
+    normalizer_assembly = normalizer_assembly.transpose('presentation', 'neuroid')
+    normalizer_assembly = NeuronRecordingAssembly(normalizer_assembly)
+
+    filtered_assembly = filter_neuroids(normalizer_assembly, 0.7)
+    assembly = assembly.sel(neuroid=np.isin(assembly.neuroid_id, filtered_assembly.neuroid_id))
+    assembly = assembly.transpose('presentation', 'neuroid', 'time_bin')
+
+    # Add other experiment and data processing related info
+    assembly.attrs['image_size_degree'] = 8
+    assembly.attrs['stim_on_time_ms'] = 100
+
+    return assembly
+
+
+def main():
+    data_dir = Path(__file__).parents[6] / 'data2' / 'active' / 'users' / 'sachis'
+    assert os.path.isdir(data_dir)
+
+    stimuli = collect_stimuli(data_dir)
+    stimuli.identifier = 'BOLD5000'
+    assembly = load_responses(data_dir, stimuli)
+    assembly.name = 'dicarlo.SanghaviJozwik2020'
+
+    print('Packaging stimuli')
+    package_stimulus_set(stimuli, stimulus_set_identifier=stimuli.identifier, bucket_name='brainio.dicarlo')
+    print('Packaging assembly')
+    package_data_assembly(assembly, assembly_identifier=assembly.name, stimulus_set_identifier=stimuli.identifier,
+                          bucket_name='brainio.dicarlo')
+    return
+
+
+if __name__ == '__main__':
+    main()

brainscore_vision/data/sanghavi2020/data_packaging/sanghavikar2020.py

@@ -0,0 +1,131 @@
+import os
+from pathlib import Path
+import json
+
+import numpy as np
+import xarray as xr
+import pandas as pd
+import scipy.io as sio
+
+from brainio_base.assemblies import NeuronRecordingAssembly
+from brainio_base.stimuli import StimulusSet
+from brainio_collection.packaging import package_data_assembly, package_stimulus_set
+from mkgu_packaging.dicarlo.sanghavi import filter_neuroids
+
+
+pd.set_option('display.max_columns', None)
+
+
+def collect_stimuli(data_dir):
+    data = sio.loadmat(data_dir / 'image-metadata' / 'objectome_metadata.mat', squeeze_me=True)
+    column_names = [x for x in list(data.keys()) if not x.startswith('__')]
+    stimuli = pd.DataFrame()
+    for col in column_names:
+        stimuli[col] = data[col]
+    stimuli = stimuli.rename(columns={'id': 'image_id', 'obj': 'image_label'})
+    stimuli = stimuli.sort_values(by='image_id').reset_index(drop=True)
+    print(stimuli)
+
+
+    # data_dir = data_dir / 'images' / 'nat300'
+    # assert os.path.isdir(data_dir)
+    # files = sorted(os.listdir(data_dir), key=lambda x: int(os.path.splitext(x)[0].split('_')[-1]))
+
+    # stimuli['image_id'] = ''
+    # stimuli['image_file_name'] = ''
+    # stimuli['image_current_local_file_path'] = ''
+    # stimuli['image_path_within_store'] = ''
+    # stimuli['image_file_sha1'] = ''
+    # stimuli['id'] = ''
+    #
+    # for idx, image_file_name in enumerate(files):
+    #     image_file_path = os.path.join(data_dir, image_file_name)
+    #     im_kf = kf(image_file_path)
+    #
+    #     stimuli.at[idx, 'image_id'] = im_kf.sha1
+    #     stimuli.at[idx, 'image_file_name'] = image_file_name
+    #     stimuli.at[idx, 'image_current_local_file_path'] = image_file_path
+    #     stimuli.at[idx, 'image_path_within_store'] = image_file_name
+    #     stimuli.at[idx, 'image_file_sha1'] = im_kf.sha1
+    #     stimuli.at[idx, 'id'] = int(os.path.splitext(image_file_name)[0].split('_')[-1])
+    #
+    # assert len(np.unique(stimuli['image_id'])) == len(stimuli)
+    # stimuli = StimulusSet(stimuli)
+    # stimuli.image_paths = \
+    #     {stimuli.at[idx, 'image_id']: stimuli.at[idx, 'image_current_local_file_path'] for idx in range(len(stimuli))}
+    return stimuli
+
+
+def load_responses(data_dir, stimuli):
+    data_dir = data_dir / 'database'
+    assert os.path.isdir(data_dir)
+    psth = np.load(data_dir / 'solo.rsvp.nat300.experiment_psth.npy')  # Shaped images x repetitions x time_bins x channels
+
+    # Compute firing rate for given time bins
+    timebins = [[70, 170], [50, 100], [100, 150], [150, 200], [200, 250], [70, 270]]
+    photodiode_delay = 30  # Delay recorded on photodiode is ~30ms
+    timebase = np.arange(-100, 381, 10)  # PSTH from -100ms to 380ms relative to stimulus onset
+    assert len(timebase) == psth.shape[2]
+    rate = np.empty((len(timebins), psth.shape[0], psth.shape[1], psth.shape[3]))
+    for idx, tb in enumerate(timebins):
+        t_cols = np.where((timebase >= (tb[0] + photodiode_delay)) & (timebase < (tb[1] + photodiode_delay)))[0]
+        rate[idx] = np.mean(psth[:, :, t_cols, :], axis=2)  # Shaped images x repetitions x channels
+
+    assembly = xr.DataArray(rate,
+                            coords={'repetition': ('repetition', list(range(rate.shape[2]))),
+                                    'time_bin_id': ('time_bin', list(range(rate.shape[0]))),
+                                    'time_bin_start': ('time_bin', [x[0] for x in timebins]),
+                                    'time_bin_stop': ('time_bin', [x[1] for x in timebins])},
+                            dims=['time_bin', 'image', 'repetition', 'neuroid'])
+
+    # Add neuroid related meta data
+    neuroid_meta = pd.DataFrame(json.load(open(data_dir.parent / 'array-metadata' / 'mapping.json')))
+    for column_name, column_data in neuroid_meta.iteritems():
+        assembly = assembly.assign_coords(**{f'{column_name}': ('neuroid', list(column_data.values))})
+
+    # Add stimulus related meta data
+    for column_name, column_data in stimuli.iteritems():
+        assembly = assembly.assign_coords(**{f'{column_name}': ('image', list(column_data.values))})
+
+    # Collapse dimensions 'image' and 'repetitions' into a single 'presentation' dimension
+    assembly = assembly.stack(presentation=('image', 'repetition')).reset_index('presentation')
+    assembly = assembly.drop('image')
+    assembly = NeuronRecordingAssembly(assembly)
+
+    # Filter noisy electrodes
+    filtered_assembly = filter_neuroids(assembly.sel(time_bin_id=0).squeeze(dim='time_bin'), 0.7)
+    assembly = assembly.sel(neuroid=np.isin(assembly.neuroid_id, filtered_assembly.neuroid_id))
+    assembly = assembly.transpose('presentation', 'neuroid', 'time_bin')
+
+    # Add other experiment and data processing related info
+    assembly.attrs['image_size_degree'] = 8
+    assembly.attrs['stim_on_time_ms'] = 100
+
+    return assembly
+
+
+def main():
+    data_dir = Path(__file__).parents[6] / 'data2' / 'active' / 'users' / 'sachis'
+    assert os.path.isdir(data_dir)
+
+    import brainio_collection
+    print(brainio_collection.list_stimulus_sets())
+    print(brainio_collection.list_assemblies())
+    stimuli = brainio_collection.get_stimulus_set('objectome.public').sort_values(by='image_id')
+    print(stimuli)
+    # print(stimuli.columns)
+    stimuli = collect_stimuli(data_dir)
+    # stimuli.name = 'Rust2012'
+    # assembly = load_responses(data_dir, stimuli)
+    # assembly.name = 'dicarlo.SanghaviKar2020'
+
+    # 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')
+    return
+
+
+if __name__ == '__main__':
+    main()