brainscore-vision 2.1__py3-none-any.whl

brainscore_vision/data/rajalingham2018/rajalingham2018objectome.py

@@ -0,0 +1,193 @@
+import os
+import zipfile
+from glob import glob
+from pathlib import Path
+
+import boto3
+import pandas as pd
+import xarray as xr
+
+import mkgu_packaging
+from brainio_base.assemblies import BehavioralAssembly
+from brainio_base.stimuli import StimulusSet
+from brainio_collection.lookup import pwdb
+from brainio_collection.knownfile import KnownFile as kf
+from brainio_collection.assemblies import AssemblyModel, AssemblyStoreMap, AssemblyStoreModel
+from brainio_collection.stimuli import ImageModel, AttributeModel, ImageMetaModel, StimulusSetModel, ImageStoreModel, \
+    StimulusSetImageMap, ImageStoreMap
+
+
+def get_objectome(source_data_path):
+    objectome = pd.read_pickle(os.path.join(source_data_path, 'objectome24s100_humanpool.pkl'))
+    # objectome['correct'] = objectome['choice'] == objectome['sample_obj']
+    objectome['truth'] = objectome['sample_obj']
+
+    subsample = pd.read_pickle(os.path.join(source_data_path, 'objectome24s100_imgsubsampled240_pandas.pkl'))
+    objectome['enough_human_data'] = objectome['id'].isin(subsample.values[:, 0])
+    objectome = to_xarray(objectome)
+    return objectome
+
+
+def to_xarray(objectome):
+    columns = objectome.columns
+    objectome = xr.DataArray(objectome['choice'],
+                             coords={column: ('presentation', objectome[column]) for column in columns},
+                             dims=['presentation'])
+    objectome = objectome.rename({'id': 'image_id'})
+    objectome = objectome.set_index(presentation=[col if col != 'id' else 'image_id' for col in columns])
+    objectome = BehavioralAssembly(objectome)
+    return objectome
+
+
+def load_stimuli(meta_assembly, source_stim_path):
+    stimuli_paths = list(glob(os.path.join(source_stim_path, '*.png')))
+    stimuli_paths.sort()
+    stimuli = StimulusSet({'image_current_local_file_path': stimuli_paths,
+                           'image_id': [os.path.splitext(os.path.basename(filepath))[0] for filepath in stimuli_paths],
+                           'image_path_within_store': [os.path.basename(filepath) for filepath in stimuli_paths]})
+
+    assert all(meta_assembly['sample_obj'].values == meta_assembly['truth'].values)
+    image_meta = {image_id: coord_value for image_id, coord_value in
+                  zip(meta_assembly['image_id'].values, meta_assembly['sample_obj'].values)}
+    meta_values = [image_meta[image_id] for image_id in stimuli['image_id'].values]
+    stimuli['image_sample_obj'] = meta_values
+    stimuli['image_label'] = stimuli['image_sample_obj']
+    return stimuli
+
+
+def load_responses(source_data_path):
+    objectome = get_objectome(source_data_path)
+    fitting_objectome, testing_objectome = objectome.sel(enough_human_data=False), objectome.sel(enough_human_data=True)
+    return objectome, fitting_objectome, testing_objectome
+
+
+def create_image_zip(stimuli, target_zip_path):
+    os.makedirs(os.path.dirname(target_zip_path), exist_ok=True)
+    with zipfile.ZipFile(target_zip_path, 'w') as target_zip:
+        for image in stimuli.itertuples():
+            target_zip.write(image.image_current_local_file_path, arcname=image.image_path_within_store)
+    zip_kf = kf(target_zip_path)
+    return zip_kf.sha1
+
+
+def write_netcdf(assembly, target_netcdf_file):
+    assembly.reset_index(assembly.indexes.keys(), inplace=True)
+    assembly.to_netcdf(target_netcdf_file)
+
+
+def add_stimulus_set_metadata_and_lookup_to_db(stimuli, stimulus_set_name, bucket_name, zip_file_name,
+                                               image_store_unique_name, zip_sha1):
+    pwdb.connect(reuse_if_open=True)
+    stim_set_model, created = StimulusSetModel.get_or_create(name=stimulus_set_name)
+    image_store, created = ImageStoreModel.get_or_create(location_type="S3", store_type="zip",
+                                                         location=f"https://{bucket_name}.s3.amazonaws.com/{zip_file_name}",
+                                                         unique_name=image_store_unique_name,
+                                                         sha1=zip_sha1)
+    add_image_metadata_to_db(stimuli, stim_set_model, image_store)
+    return stim_set_model
+
+
+def add_image_metadata_to_db(stimuli, stim_set_model, image_store):
+    pwdb.connect(reuse_if_open=True)
+    eav_image_sample_obj, created = AttributeModel.get_or_create(name="image_sample_obj", type="str")
+    eav_image_label, created = AttributeModel.get_or_create(name="image_label", type="str")
+
+    for image in stimuli.itertuples():
+        pw_image, created = ImageModel.get_or_create(image_id=image.image_id)
+        pw_stimulus_set_image_map, created = StimulusSetImageMap.get_or_create(stimulus_set=stim_set_model, image=pw_image)
+        pw_image_image_store_map, created = ImageStoreMap.get_or_create(image=pw_image, image_store=image_store,
+                                                                        path=image.image_path_within_store)
+        ImageMetaModel.get_or_create(image=pw_image, attribute=eav_image_sample_obj, value=str(image.image_sample_obj))
+        ImageMetaModel.get_or_create(image=pw_image, attribute=eav_image_label, value=str(image.image_label))
+
+
+def add_assembly_lookup(assembly_name, stim_set_model, bucket_name, target_netcdf_file, assembly_store_unique_name):
+    kf_netcdf = kf(target_netcdf_file)
+    assy, created = AssemblyModel.get_or_create(name=assembly_name, assembly_class="BehavioralAssembly",
+                                                stimulus_set=stim_set_model)
+    store, created = AssemblyStoreModel.get_or_create(assembly_type="netCDF",
+                                                      location_type="S3",
+                                                      location=f"https://{bucket_name}.s3.amazonaws.com/{assembly_store_unique_name }.nc",
+                                                      unique_name=assembly_store_unique_name,
+                                                      sha1=kf_netcdf.sha1)
+    assy_store_map, created = AssemblyStoreMap.get_or_create(assembly_model=assy, assembly_store_model=store, role=assembly_name)
+
+
+def upload_to_s3(source_file_path, bucket_name, target_s3_key):
+    client = boto3.client('s3')
+    client.upload_file(source_file_path, bucket_name, target_s3_key)
+
+
+def main():
+    pkg_path = Path(mkgu_packaging.__file__).parent
+    source_path = Path("/braintree/home/msch/share/objectome")
+    source_data_path = source_path / 'data'
+    source_stim_path = source_path / 'stim'
+    target_path = pkg_path.parent / "objectome" / "out"
+    target_bucket_name = "brainio-dicarlo"
+    assembly_name = "dicarlo.Rajalingham2018"
+
+    public_stimulus_set_unique_name = "objectome.public"
+    public_image_store_unique_name = "stimulus_objectome_public"
+    public_assembly_unique_name = "dicarlo.Rajalingham2018.public"
+    public_assembly_store_unique_name = "assy_dicarlo_Rajalingham2018_public"
+    public_target_zip_basename = public_image_store_unique_name + ".zip"
+    public_target_zip_path = target_path / public_target_zip_basename
+    public_target_netcdf_basename = public_assembly_store_unique_name + ".nc"
+    public_target_netcdf_path = target_path / public_target_netcdf_basename
+    public_target_zip_s3_key = public_target_zip_basename
+    public_target_netcdf_s3_key = public_target_netcdf_basename
+
+    private_stimulus_set_unique_name = "objectome.private"
+    private_image_store_unique_name = "stimulus_objectome_private"
+    private_assembly_unique_name = "dicarlo.Rajalingham2018.private"
+    private_assembly_store_unique_name = "assy_dicarlo_Rajalingham2018_private"
+    private_target_zip_basename = private_image_store_unique_name + ".zip"
+    private_target_zip_path = target_path / private_target_zip_basename
+    private_target_netcdf_basename = private_assembly_store_unique_name + ".nc"
+    private_target_netcdf_path = target_path / private_target_netcdf_basename
+    private_target_zip_s3_key = private_target_zip_basename
+    private_target_netcdf_s3_key = private_target_netcdf_basename
+
+    [all_assembly, public_assembly, private_assembly] = load_responses(source_data_path)
+    all_assembly.name = assembly_name
+    public_assembly.name = public_assembly_unique_name
+    private_assembly.name = private_assembly_unique_name
+    all_stimuli = load_stimuli(all_assembly, source_stim_path)
+    public_stimuli = all_stimuli[all_stimuli['image_id'].isin(public_assembly['image_id'].values)]
+    private_stimuli = all_stimuli[all_stimuli['image_id'].isin(private_assembly['image_id'].values)]
+    public_stimuli.name = public_stimulus_set_unique_name
+    private_stimuli.name = private_stimulus_set_unique_name
+
+    assert len(public_assembly) + len(private_assembly) == len(all_assembly) == 927296
+    assert len(private_assembly) == 341785
+    assert len(set(public_assembly['image_id'].values)) == len(public_stimuli) == 2160
+    assert len(set(private_assembly['image_id'].values)) == len(private_stimuli) == 240
+    assert set(all_stimuli['image_id'].values) == set(all_assembly['image_id'].values)
+    assert set(public_stimuli['image_id'].values) == set(public_assembly['image_id'].values)
+    assert set(private_stimuli['image_id'].values) == set(private_assembly['image_id'].values)
+    assert len(set(private_assembly['choice'].values)) == len(set(public_assembly['choice'].values)) == 24
+
+    print([assembly.name for assembly in [all_assembly, public_assembly, private_assembly]])
+
+    public_zip_sha1 = create_image_zip(public_stimuli, public_target_zip_path)
+    public_stimulus_set_model = add_stimulus_set_metadata_and_lookup_to_db(public_stimuli, public_stimulus_set_unique_name, target_bucket_name, public_target_zip_basename, public_image_store_unique_name, public_zip_sha1)
+    write_netcdf(public_assembly, public_target_netcdf_path)
+    add_assembly_lookup(public_assembly_unique_name,public_stimulus_set_model,target_bucket_name,public_target_netcdf_path, public_assembly_store_unique_name)
+
+    private_zip_sha1 = create_image_zip(private_stimuli, private_target_zip_path)
+    private_stimulus_set_model = add_stimulus_set_metadata_and_lookup_to_db(private_stimuli, private_stimulus_set_unique_name, target_bucket_name, private_target_zip_basename, private_image_store_unique_name, private_zip_sha1)
+    write_netcdf(private_assembly, private_target_netcdf_path)
+    add_assembly_lookup(private_assembly_unique_name,private_stimulus_set_model,target_bucket_name,private_target_netcdf_path, private_assembly_store_unique_name)
+
+    print("uploading to S3")
+    upload_to_s3(str(public_target_zip_path), target_bucket_name, public_target_zip_s3_key)
+    upload_to_s3(str(public_target_netcdf_path), target_bucket_name, public_target_netcdf_s3_key)
+    upload_to_s3(str(private_target_zip_path), target_bucket_name, private_target_zip_s3_key)
+    upload_to_s3(str(private_target_netcdf_path), target_bucket_name, private_target_netcdf_s3_key)
+
+    return [(public_assembly, public_stimuli), (private_assembly, private_stimuli)]
+
+
+if __name__ == '__main__':
+    main()

brainscore_vision/data/rajalingham2018/test.py

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

brainscore_vision/data/rajalingham2020/__init__.py

@@ -0,0 +1,39 @@
+import logging
+
+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_assembly_from_s3, load_stimulus_set_from_s3
+
+_logger = logging.getLogger(__name__)
+
+BIBTEX = """@article{rajalingham2020inferior,
+  title={The inferior temporal cortex is a potential cortical precursor of orthographic processing in untrained monkeys},
+  author={Rajalingham, Rishi and Kar, Kohitij and Sanghavi, Sachi and Dehaene, Stanislas and DiCarlo, James J},
+  journal={Nature communications},
+  volume={11},
+  number={1},
+  pages={1--13},
+  year={2020},
+  publisher={Nature Publishing Group}
+}"""
+
+# assembly: uses below stimulus set
+data_registry['Rajalingham2020'] = lambda: load_assembly_from_s3(
+    identifier="dicarlo.Rajalingham2020",
+    version_id="L4YlA5o2gToDj4sbXE0Utn362sPyy_GW",
+    sha1="ab95ae6c9907438f87b9b13b238244049f588680",
+    bucket="brainio-brainscore",
+    cls=NeuronRecordingAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('Rajalingham2020'),
+)
+
+# stimulus set
+stimulus_set_registry['Rajalingham2020'] = lambda: load_stimulus_set_from_s3(
+    identifier="Rajalingham2020",
+    bucket="brainio-brainscore",
+    csv_sha1="9a9a6b3115d2d8ce5d54ec2522093d8a87ed13a0",
+    zip_sha1="6097086901032e20f8ae764e9cc06e0a891a3e18",
+    csv_version_id="WR2Y5uv39CDSRj.c3Doec1CxzrvAMX2Y",
+    zip_version_id="l6liA374xHCunPq__HcouAqEKavc_XmY")
+

brainscore_vision/data/rajalingham2020/rajalingham2020orthographic_IT.py

@@ -0,0 +1,97 @@
+import os
+from pathlib import Path
+import pickle
+
+import numpy as np
+import xarray as xr
+
+from brainio_base.stimuli import StimulusSet
+from brainio_base.assemblies import NeuronRecordingAssembly
+from brainio_collection.packaging import package_stimulus_set, package_data_assembly
+
+
+def collect_stimuli(data_dir):
+    IT_base616 = pickle.load(open(os.path.join(data_dir, 'data_IT_base616.pkl'), 'rb'))
+    stimuli = IT_base616['meta']
+
+    stimuli = stimuli.rename(columns={'id': 'image_id'})
+
+    stimuli['image_file_name'] = ''
+    stimuli['image_current_local_file_path'] = ''
+
+    for idx, row in stimuli.iterrows():
+        image_file_name = f'{row.image_id}.png'
+        image_file_path = os.path.join(data_dir, 'stimuli', image_file_name)
+
+        stimuli.at[idx, 'image_file_name'] = image_file_name
+        stimuli.at[idx, 'image_current_local_file_path'] = image_file_path
+
+    stimuli['grp5_bigram_freq'] = stimuli['grp5_bigram_freq'].astype(str)  # IntervalIndex not supported by netCDF4
+    stimuli = stimuli.astype({column_name: 'int32' for column_name
+                              in stimuli.select_dtypes(include=['bool']).keys()})  # Bool not supported by netCDF4
+    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):
+    IT_base616 = pickle.load(open(os.path.join(data_dir, 'data_IT_base616.pkl'), 'rb'))
+    features = IT_base616['IT_features']  # Shaped images x neuroids x repetitions x time_bins
+
+    # Drop all time_bins except the fifth, which corresponds to 70-170ms
+    # For future reference the time-bins are as follows:
+    # 70-120ms, 120-170ms, 170-220ms, 220-270ms, 70-170ms, 170-270ms, 70-270ms
+    features = features[:, :, :, 4]
+    features = features[:, :, :, np.newaxis]
+    # Drop all repetitions beyond 33rd (all neuroids have at least 27, but none have greater than 33)
+    features = features[:, :, :33, :]
+
+    neuroid_meta = pickle._Unpickler(open(os.path.join(data_dir, 'IT_neural_meta_full.pkl'), 'rb'))
+    neuroid_meta.encoding = 'latin1'
+    neuroid_meta = neuroid_meta.load()
+
+    assembly = xr.DataArray(features,
+                            coords={'region': ('neuroid', ['IT'] * len(neuroid_meta)),
+                                    'neuroid_id': ('neuroid', list(range(features.shape[1]))),
+                                    'time_bin_start': ('time_bin', [70]),
+                                    'time_bin_stop': ('time_bin', [170]),
+                                    'repetition': ('repetition', list(range(features.shape[2])))},
+                            dims=['image', 'neuroid', 'repetition', 'time_bin'])
+
+    for column_name, column_data in neuroid_meta.iteritems():
+        assembly = assembly.assign_coords(**{f'{column_name}': ('neuroid', list(column_data.values))})
+
+    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)
+    assembly = assembly.transpose('presentation', 'neuroid', 'time_bin')
+
+    return assembly
+
+
+def main():
+    data_dir = Path(__file__).parents[5] / 'data2' / 'active' / 'users' / 'sachis' / 'database' / 'Rajalingham2020'
+    assert os.path.isdir(data_dir)
+    stimuli = collect_stimuli(data_dir)
+    stimuli.identifier = 'Rajalingham2020'
+    assembly = load_responses(data_dir, stimuli)
+    assembly.name = 'dicarlo.Rajalingham2020'
+
+    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/rajalingham2020/test.py

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