brainscore-vision 2.1__py3-none-any.whl

brainscore_vision/data/baker2022/test.py

@@ -0,0 +1,135 @@
+import pytest
+from brainscore_vision import load_dataset, load_stimulus_set
+import numpy as np
+
+
+@pytest.mark.private_access
+class TestBaker2022Stimuli:
+
+    # general tests
+    @pytest.mark.parametrize('identifier', [
+        'normal',
+        'inverted'
+    ])
+    def test_stimulus_set_exist(self, identifier):
+        full_name = f'Baker2022_{identifier}_distortion'
+        stimulus_set = load_stimulus_set(full_name)
+        assert stimulus_set is not None
+        assert stimulus_set.identifier == full_name
+
+    # tests number of images
+    @pytest.mark.parametrize('identifier, num_images', [
+        ('normal', 716),
+        ('inverted', 360),
+    ])
+    def test_num_stimuli(self, identifier, num_images):
+        stimulus_set = load_stimulus_set(f'Baker2022_{identifier}_distortion')
+        assert len(stimulus_set) == num_images
+        assert len(np.unique(stimulus_set["stimulus_id"])) == num_images
+
+    # tests stimulus_set coords. Ensure normal/inverted only have their respective stimuli
+    @pytest.mark.parametrize('field', [
+        'stimulus_id',
+        'animal',
+        'image_type',
+        'image_number',
+        "orientation",
+    ])
+    @pytest.mark.parametrize('identifier', [
+        'normal',
+        'inverted',
+    ])
+    def test_fields_present(self, identifier, field):
+        stimulus_set = load_stimulus_set(f'Baker2022_{identifier}_distortion')
+        assert hasattr(stimulus_set, field)
+
+    # make sure there are at least whole, frankenstein in each stimulus_set. Inverted does not have fragmented stimuli.
+    @pytest.mark.parametrize('identifier, count', [
+        ('normal', 3),
+        ('inverted', 2),
+    ])
+    def test_distortion_counts(self, identifier, count):
+        stimulus_set = load_stimulus_set(f'Baker2022_{identifier}_distortion')
+        assert len(np.unique(stimulus_set["image_type"])) == count
+        assert "w" in set(stimulus_set["image_type"])
+        assert "f" in set(stimulus_set["image_type"])
+
+    # make sure there are 9 possible animals in each stimulus_set -> 9 way AFC
+    @pytest.mark.parametrize('identifier', [
+        'normal',
+        'inverted',
+    ])
+    def test_ground_truth_types(self, identifier):
+        stimulus_set = load_stimulus_set(f'Baker2022_{identifier}_distortion')
+        assert len(np.unique(stimulus_set["animal"])) == 9
+
+    # make sure there are 40 unique image numbers
+    @pytest.mark.parametrize('identifier', [
+        'normal',
+        'inverted',
+    ])
+    def test_image_types(self, identifier):
+        stimulus_set = load_stimulus_set(f'Baker2022_{identifier}_distortion')
+        assert len(np.unique(stimulus_set["image_number"])) == 40
+
+
+
+@pytest.mark.private_access
+class TestBaker2022Assemblies:
+
+    # tests alignments that are the same across normal and inverted assemblies
+    @pytest.mark.parametrize('identifier, length', [
+        ('normal', 3702),
+        ('inverted', 4320),
+    ])
+    def test_stimulus_set_assembly_alignment(self, identifier, length):
+        full_name = f'Baker2022_{identifier}_distortion'
+        assembly = load_dataset(full_name)
+        assert assembly.stimulus_set is not None
+        assert assembly.stimulus_set.identifier == f'Baker2022_{identifier}_distortion'
+        assert set(assembly.stimulus_set["animal"]) == set(assembly["truth"].values)
+        assert set(assembly.stimulus_set["stimulus_id"]) == set(assembly["stimulus_id"].values)
+        assert len(assembly.presentation) == length
+
+    # tests counts that are the same across normal and inverted assemblies
+    @pytest.mark.parametrize('identifier', [
+        'normal',
+        'inverted',
+    ])
+    def test_same_counts(self, identifier):
+        full_name = f'Baker2022_{identifier}_distortion'
+        assembly = load_dataset(full_name)
+        assert len(set((assembly["truth"]).values)) == 9
+        assert set((assembly["correct"]).values) == {0, 1}
+
+    # tests number of subjects
+    @pytest.mark.parametrize('identifier, num_subjects', [
+        ('normal', 32),
+        ('inverted', 12),
+    ])
+    def test_subjects(self, identifier, num_subjects):
+        full_name = f'Baker2022_{identifier}_distortion'
+        assembly = load_dataset(full_name)
+        assert len(set((assembly["subject"]).values)) == num_subjects
+
+    # tests number of configurations in {whole, fragmented, frankenstein} Inverted does not have fragmented)
+    @pytest.mark.parametrize('identifier, conditions', [
+        ('normal', {'whole', 'fragmented', 'Frankenstein'}),
+        ('inverted', {'whole', 'Frankenstein'}),
+    ])
+    def test_conditions(self, identifier, conditions):
+        full_name = f'Baker2022_{identifier}_distortion'
+        assembly = load_dataset(full_name)
+        assert set((assembly["condition"]).values) == conditions
+
+    # tests number of unique images
+    @pytest.mark.parametrize('identifier, num_images', [
+        ('normal', 716),
+        ('inverted', 360),
+    ])
+    def test_subjects(self, identifier, num_images):
+        full_name = f'Baker2022_{identifier}_distortion'
+        assembly = load_dataset(full_name)
+        assert len(set((assembly["stimulus_id"]).values)) == num_images
+
+

brainscore_vision/data/barbumayo2019/BarbuMayo2019.py

@@ -0,0 +1,26 @@
+from pathlib import Path
+from brainio.stimuli import StimulusSet
+from brainio.packaging import package_stimulus_set
+
+import csv
+import pandas as pd
+stimuli = []  # collect meta
+image_paths = {}  # collect mapping of image_id to filepath
+stimuli_directory = "images_no_border"
+
+with open('mappings/objectnet.csv' ,'r') as f:
+    df = pd.read_csv(f)
+    df = df.reset_index(False)
+    df = df.rename(columns={"index":"image_id", "imagenet_label":"synset", "file_name":"filepath"})
+    df = df.astype({'image_id':'str'})
+    df['filepath'] = 'images_no_border/'+df['filepath']
+    #print(df)
+print(df.dtypes)
+stimuli = StimulusSet(df)
+stimuli.image_paths = {row.image_id: row.filepath for row in stimuli.itertuples()}
+
+stimuli.name = 'BarbuMayo2019'  # give the StimulusSet an identifier name
+
+assert len(stimuli) == 17261  # make sure the StimulusSet is what you would expect
+
+package_stimulus_set(catalog_name="brainio_brainscore", proto_stimulus_set=stimuli, stimulus_set_identifier=stimuli.name, bucket_name="brainio-brainscore")  # upload to S3

brainscore_vision/data/barbumayo2019/__init__.py

@@ -0,0 +1,23 @@
+from brainscore_vision import stimulus_set_registry
+from brainscore_vision.data_helpers.s3 import load_stimulus_set_from_s3
+
+BIBTEX = """@inproceedings{NEURIPS2019_97af07a1,
+ author = {Barbu, Andrei and Mayo, David and Alverio, Julian and Luo, William and Wang, Christopher and Gutfreund, Dan and Tenenbaum, Josh and Katz, Boris},
+ booktitle = {Advances in Neural Information Processing Systems},
+ editor = {H. Wallach and H. Larochelle and A. Beygelzimer and F. d\textquotesingle Alch\'{e}-Buc and E. Fox and R. Garnett},
+ pages = {},
+ publisher = {Curran Associates, Inc.},
+ title = {ObjectNet: A large-scale bias-controlled dataset for pushing the limits of object recognition models},
+ url = {https://proceedings.neurips.cc/paper/2019/file/97af07a14cacba681feacf3012730892-Paper.pdf},
+ volume = {32},
+ year = {2019}
+}"""
+
+# stimulus set
+stimulus_set_registry['BarbuMayo2019'] = lambda: load_stimulus_set_from_s3(
+    identifier="BarbuMayo2019",
+    bucket="brainio-brainscore",
+    csv_sha1="e4d8888ccb6beca28636e6698e7beb130e278e12",
+    zip_sha1="1365eb2a7231516806127a7d2a908343a7ac9464",
+    csv_version_id="3H1nicJcmKZgqfPV.ouH5jZln3GlZ3Lr",
+    zip_version_id="sx9cN3NFBBnQCnUCa85ziyWJxTUaPJGf")

brainscore_vision/data/barbumayo2019/test.py

@@ -0,0 +1,10 @@
+import pytest
+
+from brainscore_vision import load_stimulus_set
+
+
+@pytest.mark.private_access
+def test_num_elements():
+    stimulus_set = load_stimulus_set('BarbuMayo2019')
+    assert len(stimulus_set) == 17261
+    assert len(set(stimulus_set['synset'])) == 104

brainscore_vision/data/bashivankar2019/__init__.py

@@ -0,0 +1,52 @@
+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
+
+BIBTEX = """@article{bashivan2019neural,
+  title={Neural population control via deep image synthesis},
+  author={Bashivan, Pouya and Kar, Kohitij and DiCarlo, James J},
+  journal={Science},
+  volume={364},
+  number={6439},
+  pages={eaav9436},
+  year={2019},
+  publisher={American Association for the Advancement of Science}
+}"""
+
+# assemblies
+data_registry['BashivanKar2019.naturalistic'] = lambda: load_assembly_from_s3(
+    identifier="dicarlo.BashivanKar2019.naturalistic",
+    version_id="jDlQnpuhORCtzITHfOFcJiogR7jg8ihJ",
+    sha1="1ec2f32ef800f0c6e15879d883be1d55b51b8b67",
+    bucket="brainio-brainscore",
+    cls=NeuronRecordingAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('BashivanKar2019.naturalistic'),
+)
+
+data_registry['BashivanKar2019.synthetic'] = lambda: load_assembly_from_s3(
+    identifier="dicarlo.BashivanKar2019.synthetic",
+    version_id="30CNHSBYS_HN5tEuM1aa5hDFlFKq6gbI",
+    sha1="f687c8d26f8943dc379dbcbe94d3feb148400c6b",
+    bucket="brainio-brainscore",
+    cls=NeuronRecordingAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('BashivanKar2019.synthetic'),
+)
+
+# stimulus sets
+# naturalistic
+stimulus_set_registry['BashivanKar2019.naturalistic'] = lambda: load_stimulus_set_from_s3(
+    identifier="BashivanKar2019.naturalistic",
+    bucket="brainio-brainscore",
+    csv_sha1="48ef84282552b8796142ffe7d0d2c632f8ef061a",
+    zip_sha1="d7b71b431cf23d435395205f1e38036a9e10acca",
+    csv_version_id="oPBzXglOBfXhFIDiNYJ8veuPTGYRvThW",
+    zip_version_id="YaEhNEoCIMD.NCO6DN29U.BB.x.8_Qzl")
+
+# synthetic
+stimulus_set_registry['BashivanKar2019.synthetic'] = lambda: load_stimulus_set_from_s3(
+    identifier="BashivanKar2019.synthetic",
+    bucket="brainio-brainscore",
+    csv_sha1="81da195e9b2a128b228fc4867e23ae6b21bd7abd",
+    zip_sha1="e2de33f25c5c19bcfb400055c1db399d553487e5",
+    csv_version_id="D6rXwY6tL76Dqb1MkNKxW_8j2DaSRT7M",
+    zip_version_id="LmHolJMPFb42uq9B8sOZui_LiWZdIpTA")

brainscore_vision/data/bashivankar2019/data_packaging/requirements.txt

@@ -0,0 +1,4 @@
+brainio-base @ git+https://github.com/brain-score/brainio_base.git
+brainio-collection @ git+https://github.com/brain-score/brainio_collection.git
+Pillow
+tables

brainscore_vision/data/bashivankar2019/data_packaging/synthetic.py

@@ -0,0 +1,162 @@
+import os
+from pathlib import Path
+import logging
+
+import numpy as np
+import xarray as xr
+import pandas as pd
+import tables
+from PIL import Image
+
+
+from brainio_collection.lookup import sha1_hash
+from brainio_base.assemblies import NeuronRecordingAssembly
+from brainio_base.stimuli import StimulusSet
+from brainio_collection.packaging import package_data_assembly, package_stimulus_set
+
+_logger = logging.getLogger(__name__)
+
+
+def np_to_png(img_array, img_temp_path):
+    meta = []
+    for i, img_np in enumerate(img_array):
+        img_pil = Image.fromarray((img_np).astype('uint8'))
+        img_path = img_temp_path / f"img{i}.png"
+        img_pil.save(img_path)
+        sha1 = sha1_hash(img_path)
+        img_path_sha1 = img_temp_path / f"{sha1}.png"
+        img_path.rename(img_path_sha1)
+        meta.append({
+            "image_id": sha1,
+            "image_index": i,
+            "image_current_local_file_path": img_path_sha1
+        })
+        _logger.debug(f"{img_path} -> {img_path_sha1}")
+    return pd.DataFrame(meta)
+
+
+def np_to_xr(monkey, setting, session_neural, stimuli, session_target_inds, stage):
+    identifier = f"dicarlo.BashivanKar2019.{monkey._v_name[-1]}_{setting._v_name}_{session_neural._v_name}_{stage}"
+    _logger.debug(identifier)
+    dims = ("repetition", "image", "neuroid")
+    neuroid_id = [f"{monkey._v_name[-1]}_{setting._v_name}_{session_neural._v_name[-1]}_{str(i)}" for i in
+                  range(session_neural.shape[2])]
+    is_target = [int(i in session_target_inds) for i in range(session_neural.shape[2])]
+    coords = {
+        "repetition_index": ("repetition", range(session_neural.shape[0])),
+        "image_id": ("image", stimuli["image_id"]),
+        "neuroid_id": ("neuroid", neuroid_id),
+        "animal": ("neuroid", [monkey._v_name]*session_neural.shape[2]),
+        "setting": ("neuroid", [setting._v_name]*session_neural.shape[2]),
+        "session": ("neuroid", [session_neural._v_name]*session_neural.shape[2]),
+        "neuroid_index": ("neuroid", range(session_neural.shape[2])),
+        "is_target": ("neuroid", is_target)
+    }
+    assert all(stimuli["image_index"] == range(session_neural.shape[1]))
+    proto = xr.DataArray(session_neural.read(), coords=coords, dims=dims)
+    proto = proto.stack(presentation=('image', 'repetition')).reset_index('presentation')
+    proto = proto.drop('image')
+    proto = proto.expand_dims('time_bin')
+    proto['time_bin_start'] = 'time_bin', [70]
+    proto['time_bin_end'] = 'time_bin', [170]
+    proto = proto.transpose('presentation', 'neuroid', 'time_bin')
+
+    proto.name = identifier
+    return proto
+
+
+def collect_stimuli_nat(h5, data_dir):
+    img_array = h5.root.images.naturalistic
+    img_temp_path = data_dir / "images_temp" / "naturalistic"
+    img_temp_path.mkdir(parents=True, exist_ok=True)
+    proto = np_to_png(img_array, img_temp_path)
+    assert len(np.unique(proto['image_id'])) == len(proto)
+    stimuli = StimulusSet(proto)
+    stimuli.image_paths = {row.image_id: row.image_current_local_file_path for row in stimuli.itertuples()}
+    return stimuli
+
+
+def collect_responses_nat(h5, stimuli):
+    responses_nat_d = {}
+    for monkey in h5.root.neural.naturalistic:
+        for setting in monkey:
+            for session in setting:
+                target_inds_session = h5.root.target_inds[monkey._v_name][setting._v_name][session._v_name]
+                proto = np_to_xr(monkey, setting, session, stimuli, target_inds_session, "nat")
+                proto = NeuronRecordingAssembly(proto)
+                responses_nat_d[proto.name] = proto
+    return responses_nat_d
+
+
+def collect_synth(h5, data_dir):
+    protos_stimuli = []
+    responses_synth_d = {}
+    for monkey in h5.root.images.synthetic:
+        for setting in monkey:
+            for session_images in setting:
+                session_neural = h5.root.neural.synthetic[monkey._v_name][setting._v_name][session_images._v_name]
+                session_target_inds = h5.root.target_inds[monkey._v_name][setting._v_name][session_images._v_name]
+
+                identifier = f"{monkey._v_name[-1]}_{setting._v_name}_{session_images._v_name}"
+                img_temp_path = data_dir / "images_temp" / "synthetic" / identifier
+                img_temp_path.mkdir(parents=True, exist_ok=True)
+                proto_stimuli = np_to_png(session_images, img_temp_path)
+                proto_stimuli["animal"] = monkey._v_name
+                proto_stimuli["setting"] = setting._v_name
+                proto_stimuli["session"] = session_images._v_name
+                protos_stimuli.append(proto_stimuli)
+
+                proto_neural = np_to_xr(monkey, setting, session_neural, proto_stimuli, session_target_inds, "synth")
+                proto_neural = NeuronRecordingAssembly(proto_neural)
+                responses_synth_d[proto_neural.name] = proto_neural
+
+    proto_stimuli_all = pd.concat(protos_stimuli, axis=0)
+    assert len(np.unique(proto_stimuli_all['image_id'])) == len(proto_stimuli_all)
+    stimuli = StimulusSet(proto_stimuli_all)
+    stimuli.image_paths = {row.image_id: row.image_current_local_file_path for row in stimuli.itertuples()}
+    return stimuli, responses_synth_d
+
+
+def main():
+    data_dir = Path("/Users/jjpr/dev/brainio_contrib/mkgu_packaging/dicarlo/BashivanKar2019")
+    assert os.path.isdir(data_dir)
+    h5_path = data_dir / "from_pouya" / "npc_v4_data.h5"
+    h5 = tables.open_file(h5_path)
+
+    stimuli_nat = collect_stimuli_nat(h5, data_dir)
+    stimuli_nat.identifier = "BashivanKar2019.naturalistic"
+
+    responses_nat_d = collect_responses_nat(h5, stimuli_nat)
+
+    stimuli_synth, responses_synth_d = collect_synth(h5, data_dir)
+    stimuli_synth.identifier = "BashivanKar2019.synthetic"
+
+    _logger.debug('Packaging naturalistic stimuli')
+    package_stimulus_set(stimuli_nat, stimulus_set_identifier=stimuli_nat.identifier, bucket_name='brainio-brainscore')
+
+    _logger.debug('Packaging naturalistic assembly')
+    responses_nat_concat = xr.concat(responses_nat_d.values(), dim="neuroid")
+    assert responses_nat_concat.shape == (24320, 233, 1)
+    package_data_assembly(
+        responses_nat_concat,
+        assembly_identifier="dicarlo.BashivanKar2019.naturalistic",
+        stimulus_set_identifier=stimuli_nat.identifier,
+        bucket_name='brainio-dicarlo'
+    )
+
+    _logger.debug('Packaging synthetic stimuli')
+    package_stimulus_set(stimuli_synth, stimulus_set_identifier=stimuli_synth.identifier, bucket_name='brainio-dicarlo')
+
+    _logger.debug('Packaging synthetic assembly')
+    responses_synth_concat = xr.concat(responses_synth_d.values(), dim="presentation")
+    assert responses_synth_concat.shape ==(21360, 233, 1)
+    package_data_assembly(
+        responses_synth_concat,
+        assembly_identifier="dicarlo.BashivanKar2019.synthetic",
+        stimulus_set_identifier=stimuli_synth.identifier,
+        bucket_name='brainio-dicarlo'
+    )
+
+
+if __name__ == '__main__':
+    main()

brainscore_vision/data/bashivankar2019/test.py

@@ -0,0 +1,15 @@
+import numpy as np
+import pytest
+
+import brainscore_vision
+
+
+@pytest.mark.private_access
+@pytest.mark.parametrize('identifier,shape,nans', [
+    ('BashivanKar2019.naturalistic', (24320, 233, 1), 309760),
+    ('BashivanKar2019.synthetic', (21360, 233, 1), 4319940),
+])
+def test_assembly_shape(identifier, shape, nans):
+    assy = brainscore_vision.load_dataset(identifier)
+    assert assy.shape == shape
+    assert np.count_nonzero(np.isnan(assy)) == nans

brainscore_vision/data/bmd2024/__init__.py

@@ -0,0 +1,69 @@
+from brainio.assemblies import BehavioralAssembly
+
+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
+
+data_registry['BMD2024.texture_1'] = lambda: load_assembly_from_s3(
+    identifier='BMD_2024_texture_1',
+    version_id='0WF1iCvgHZGDrCrkigGCfUy3iGTGS69M',
+    sha1='050cef2bd38fe0e0c6d55c9a4ba0b1c57550a072',
+    bucket="brainio-brainscore",
+    cls=BehavioralAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('BMD2024.texture_1'))
+
+data_registry['BMD2024.texture_2'] = lambda: load_assembly_from_s3(
+    identifier='BMD_2024_texture_2',
+    version_id='Exn4klT3qUYC6aQIanUox7MSjgHLn.t_',
+    sha1='1f9f4ee938df509c0cbeaec7fdfe0f40997da331',
+    bucket="brainio-brainscore",
+    cls=BehavioralAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('BMD2024.texture_2'))
+
+data_registry['BMD2024.dotted_1'] = lambda: load_assembly_from_s3(
+    identifier='BMD_2024_dotted_1',
+    version_id='tMtSvkgphUn_C9a1WtoAWHmcgrA9oH5o',
+    sha1='eb16feffe392087b4c40ef249850825f702e7911',
+    bucket="brainio-brainscore",
+    cls=BehavioralAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('BMD2024.dotted_1'))
+
+data_registry['BMD2024.dotted_2'] = lambda: load_assembly_from_s3(
+    identifier='BMD_2024_dotted_2',
+    version_id='JF_vla60eynLMfgqCyjjkn_u8Bb.HQOV',
+    sha1='297833a094513b99ae434e581df09ac64cd6582f',
+    bucket="brainio-brainscore",
+    cls=BehavioralAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('BMD2024.dotted_2'))
+
+
+stimulus_set_registry['BMD2024.texture_1'] = lambda: load_stimulus_set_from_s3(
+    identifier='BMD_2024_texture_1',
+    bucket="brainio-brainscore",
+    csv_sha1='395911b2933d675b98dda7bae422f11648d8e86d',
+    zip_sha1='cfde36c93dc9070ef5dfaa0a992c9d2420af3460',
+    csv_version_id='2815L7UhBfYYCyZ7MgNdPsOXXcRLT1YZ',
+    zip_version_id='EelSX0uvmm.B6LzTPtQgWbrauUmPHmjl')
+
+stimulus_set_registry['BMD2024.texture_2'] = lambda: load_stimulus_set_from_s3(
+    identifier='BMD_2024_texture_2',
+    bucket="brainio-brainscore",
+    csv_sha1='98ff8e3a1ca6f632ebc2daa909804314bc1b7e31',
+    zip_sha1='31c9d8449b25da8ad3cb034eee04db9193027fcb',
+    csv_version_id='gFqcLlA6xcmv1rpUoADKNsgyNYSV.G6T',
+    zip_version_id='c6B88cKdrD7YmUA1BXJoUeCMmAUbFzZw')
+
+stimulus_set_registry['BMD2024.dotted_1'] = lambda: load_stimulus_set_from_s3(
+    identifier='BMD_2024_dotted_1',
+    bucket="brainio-brainscore",
+    csv_sha1='de4214666237a0be39810ec4fefd6ec8d2a2e881',
+    zip_sha1='b4ab1355665b5bf3bf81b7aa6eccfd396c96bda2',
+    csv_version_id='8OuzqjMhNuFDu41iEjGPeNBz4I1kxlCV',
+    zip_version_id='ue19A9hVTDzTKaXkfnJCrKaes.JLTLtv')
+
+stimulus_set_registry['BMD2024.dotted_2'] = lambda: load_stimulus_set_from_s3(
+    identifier='BMD_2024_dotted_2',
+    bucket="brainio-brainscore",
+    csv_sha1='4555daa5257dee10c6c6a5625d3bb2d94452e294',
+    zip_sha1='20337c1fac66ed0eec16410c6801cca830e6c20c',
+    csv_version_id='l4E.CZVizNrwprRZHIjHEppBQK8LpBHM',
+    zip_version_id='.a1HOsF9Q3uwfxY5NHZf2XNuj6brdiTK')

brainscore_vision/data/bmd2024/data_packaging/BMD_2024_data_assembly.py

@@ -0,0 +1,91 @@
+from pathlib import Path
+
+import pandas as pd
+
+from brainio.assemblies import BehavioralAssembly
+from brainio.packaging import package_data_assembly
+
+'''
+Experiment information
+
+- 4 experimental conditions
+    - Texturized stimuli 1 --> 'texture_1'
+    - Texturized stimuli 2 --> 'texture_2'
+    - Dotted outlines 1 --> 'dotted_1'
+    - Dotted outlines 2 --> 'dotted_2'
+
+Texture stimuli are silhouettes filled with a repeating character that produces the texture.
+texture_1 --> character is "3"
+texture_2 --> character is "%"
+
+Dotted outlines can have dots at various distances and the two conditions correspond to a smaller
+and larger distance.
+
+There were 10 images per condition per eahch of the 10 categories
+- 'airplane'
+- 'bear'
+- 'bicycle'
+- 'bird'
+- 'bottle'
+- 'car'
+- 'cat'
+- 'chair'
+- 'elephant'
+- 'knife'
+
+Between 51 and 54 partticipants completed each of the conditions (a total of 211 participants).
+'''
+
+CONDITIONS = ['texture_1', 'texture_2', 'dotted_1', 'dotted_2']
+
+def collect_BMD2024_behavioral_assembly(data_path,condition):
+    data = pd.read_csv(data_path)
+    filtered_data = data[data['condition'] == condition]
+    
+    assembly = BehavioralAssembly(filtered_data['subject_answer'],
+                                          coords={
+                                              'subject': ('presentation', filtered_data['subject']),
+                                              'subject_answer': ('presentation', filtered_data['subject_answer']),
+                                              'stimulus_id': ('presentation', filtered_data['stimulus_id']),
+                                              'truth': ('presentation', filtered_data['truth']),
+                                              'condition': ('presentation', filtered_data['condition'])
+                                          },
+                                          dims=['presentation']
+                                          )
+    
+    assembly.name = f'BMD_2024_{condition}'
+    return assembly
+    
+
+if __name__ == '__main__':
+    data_path = Path('Data/BDM_2024_behavioral_data.csv')
+    for condition in CONDITIONS:
+        if condition == 'texture_1':
+            num_dims = 5100
+            num_subjects = 51
+            num_stimuli = 100
+        elif condition == 'texture_2':
+            num_dims = 5200
+            num_subjects = 52
+            num_stimuli = 100
+        elif condition == ('dotted_1' or 'dotted_2'):
+            num_dims = 5400
+            num_subjects = 54
+        num_categories = 10
+        
+        assembly = collect_BMD2024_behavioral_assembly(data_path, condition)
+
+        # make sure assembly dims are correct length
+        assert len(assembly['presentation']) == num_dims    
+        assert len(set(assembly['subject'].values)) == num_subjects
+        assert len(set(assembly['stimulus_id'].values)) == num_stimuli
+        assert len(set(assembly['truth'].values)) == num_categories
+
+        prints = package_data_assembly(catalog_identifier=None,
+                              proto_data_assembly=assembly,
+                              assembly_identifier=assembly.name,
+                              stimulus_set_identifier=assembly.name,
+                              assembly_class_name="BehavioralAssembly",
+                              bucket_name="brainio-brainscore")
+
+        print(prints)

brainscore_vision/data/bmd2024/data_packaging/BMD_2024_simulus_set.py

@@ -0,0 +1,48 @@
+import csv
+
+from brainio.stimuli import StimulusSet
+from brainio.packaging import package_stimulus_set
+
+CONDITIONS = ['texture_1', 'texture_2', 'dotted_1', 'dotted_2']
+
+
+def collect_BMD_2024_stimulus_set(condition, stimuli_directory, meta_filepath):
+    stimuli = []
+    stimulus_paths = {}
+    
+    with open(meta_filepath, 'r') as metadata:
+        reader = csv.DictReader(metadata)
+        for row in reader:
+            stimulus_meta = {
+                'stimulus_id' : row['stimulus_id'],
+                'condition' : row['condition'],
+                'truth' : row['truth']
+                }
+            if row['condition'] == condition:
+                stimuli.append(stimulus_meta)
+                stimulus_paths[row['stimulus_id']] = f'{stimuli_directory}/{row["stimulus_id"]}.png'
+        
+        stimuli_assembly = StimulusSet(stimuli)
+        stimuli_assembly.stimulus_paths = stimulus_paths
+        stimuli_assembly.name = f'BMD_2024_{condition}'
+        stimuli_assembly.identifier = f'BMD_2024_{condition}'
+    
+    return stimuli_assembly
+
+
+if __name__ == '__main__':
+    stimuli_directory = 'Stimuli_set'
+    meta_filepath = 'stim_meta.csv'
+    
+    for condition in CONDITIONS:
+        assembly = collect_BMD_2024_stimulus_set(condition, stimuli_directory, meta_filepath)
+        
+        assert len(assembly) == 100
+        
+        prints = package_stimulus_set(catalog_name=None,
+                             proto_stimulus_set=assembly,
+                             stimulus_set_identifier=assembly.name,
+                             bucket_name="brainio-brainscore")
+        print(prints)
+
+