brainscore-vision 2.1__py3-none-any.whl

brainscore_vision/data/seibert2019/data_packaging/juvenile.py

@@ -0,0 +1,103 @@
+import os
+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
+
+
+animals = ['Chabo_IT_A', 'Chabo_IT_M', 'Tito_IT_A','Tito_IT_M','TitoR_IT_A','TitoR_IT_M','Nano_IT_A',
+           'Nano_IT_M', 'Nano_IT_P','Magneto_IT_A', 'Magneto_IT_M', 'Magneto_IT_P', 'Chabo_V4',
+           'Tito_V4','TitoR_V4','B6_IT', 'B8_IT', 'I2_IT', 'B6_V4', 'B8_V4','I2_V4', 'Magneto_V4',
+           'B6_IT_170_270', 'B8_IT_170_270', 'I2_IT_170_270', 'I2_IT_latency_adjusted',
+           'NanoR_V4', 'NanoR_IT_P', 'NanoR_IT_M', 'HU_IT', 'HT_IT', 'HU_IT_latency_adjusted', 'HT_IT_latency_adjusted']
+
+
+juve = [17, 20, 29, 30]
+
+
+var = ["0", "3", "6"]
+
+
+def get_image_ids(variation, data, df_hvm):
+    ids = df_hvm[df_hvm["var"]==f"V{variation}"]["id"]
+    assert data.shape[0] == len(ids)
+    return ids
+
+
+def coords_from_darren(animal_region, variation, data, df_hvm):
+    coords = {}
+    coords["image_id"] = ("stimulus", get_image_ids(variation, data, df_hvm))
+    coords["repetition"] = ("repetition", range(data.shape[1]))
+    coords["animal"] = ("neuroid", [animal_region.split("_")[0]]*data.shape[2])
+    coords["region"] = ("neuroid", [animal_region.split("_")[1]]*data.shape[2])
+    coords["electrode"] = ("neuroid", range(data.shape[2]))
+    coords["neuroid_id"] = ("neuroid", [f"{animal_region}_{i:02}" for i in range(data.shape[2])])
+    return coords
+
+
+def xr_from_darren(animal_region, variation, data, df_hvm):
+    xr_data = xr.DataArray(
+        data=data,
+        coords=coords_from_darren(animal_region, variation, data, df_hvm),
+        dims=["stimulus", "repetition", "neuroid"]
+    )
+    return xr_data
+
+
+def load_responses(metric_bins_path, csv_path):
+    assert metric_bins_path.exists()
+    metric_bins_np = np.load(metric_bins_path, allow_pickle=True, encoding='latin1')
+    df_hvm = pd.read_csv(csv_path)
+    relevant_arrays = [{
+        "animals_index": i,
+        "animal_region": animals[i],
+        "variation": k,
+        "data": metric_bins_np[()]["data"]["bins"][k][i]
+    } for i in juve for k in var]
+    for ra in relevant_arrays:
+        ra["xr_data"] = xr_from_darren(
+            animal_region=ra["animal_region"],
+            variation=ra["variation"],
+            data=ra["data"],
+            df_hvm=df_hvm
+        )
+    concatted_per_var = {}
+    for v in var:
+        aligned = xr.align(*[x["xr_data"] for x in relevant_arrays if x["variation"] == v],
+                           join="outer",
+                           exclude=["neuroid"],
+                           fill_value=np.nan
+                           )
+        concatted_per_var[v] = xr.concat(aligned, dim="neuroid")
+    stacked_per_var = {}
+    for v in concatted_per_var:
+        stacked_per_var[v] = concatted_per_var[v].stack(presentation=["repetition", "stimulus"])
+    final = xr.concat(stacked_per_var.values(), dim="presentation")#.transpose()
+    final = final.expand_dims('time_bin', 2)
+    final['time_bin_start'] = ('time_bin', [70])
+    final['time_bin_end'] = ('time_bin', [170])
+    print(final.dims)
+    assert final.dims == ("neuroid", "presentation", "time_bin")
+    return final
+
+
+def main():
+    metric_bins_path = Path("/braintree/home/darren/work/metric_bins.npy")
+    csv_path = Path(__file__).parents[2] / "notebooks" / "2020-11-22_hvm_from_dldata.csv"
+
+    stimuli = brainio_collection.get_stimulus_set('hvm')
+    assembly = load_responses(metric_bins_path, csv_path)
+    assembly.name = 'dicarlo.Seibert2019'
+
+    print('Packaging assembly')
+    package_data_assembly(assembly, assembly_identifier=assembly.name, stimulus_set_identifier=stimuli.identifier,
+                          bucket_name='brainio.dicarlo')
+
+
+if __name__ == '__main__':
+    main()

brainscore_vision/data/seibert2019/test.py

@@ -0,0 +1,35 @@
+import numpy as np
+import pytest
+
+from brainscore_vision import load_dataset
+
+
+@pytest.mark.private_access
+def test_existence():
+    assert load_dataset('Seibert2019') is not None
+
+
+@pytest.mark.private_access
+class TestSeibert:
+    def test_dims(self):
+        assembly = load_dataset('Seibert2019')
+        # neuroid: 258 presentation: 286080 time_bin: 1
+        assert assembly.dims == ("neuroid", "presentation", "time_bin")
+        assert len(assembly['neuroid']) == 258
+        assert len(assembly['presentation']) == 286080
+        assert len(assembly['time_bin']) == 1
+
+    def test_coords(self):
+        assembly = load_dataset('Seibert2019')
+        assert len(set(assembly['stimulus_id'].values)) == 5760
+        assert len(set(assembly['neuroid_id'].values)) == 258
+        assert len(set(assembly['animal'].values)) == 3
+        assert len(set(assembly['region'].values)) == 2
+        assert len(set(assembly['variation'].values)) == 3
+
+    def test_content(self):
+        assembly = load_dataset('Seibert2019')
+        assert np.count_nonzero(np.isnan(assembly)) == 19118720
+        assert assembly.stimulus_set_identifier == "hvm"
+        hvm = assembly.stimulus_set
+        assert hvm.shape == (5760, 19)

brainscore_vision/data/zhang2018/__init__.py

@@ -0,0 +1,38 @@
+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
+
+BIBTEX = """@article{zhang2018finding,
+  title={Finding any Waldo with zero-shot invariant and efficient visual search},
+  author={Zhang, Mengmi and Feng, Jiashi and Ma, Keng Teck and Lim, Joo Hwee and Zhao, Qi and Kreiman, Gabriel},
+  journal={Nature communications},
+  volume={9},
+  number={1},
+  pages={3730},
+  year={2018},
+  publisher={Nature Publishing Group UK London}
+}"""
+
+PACKAGING_FIXED = False  # There is an issue with the packaging where the zip filenames do not match the csv filenames
+
+if PACKAGING_FIXED:
+    # assembly: klab.Zhang2018search_obj_array
+    data_registry['Zhang2018search_obj_array'] = lambda: load_assembly_from_s3(
+        identifier="klab.Zhang2018search_obj_array",
+        version_id="EDRblSpQTmoaKRdiY4JEoQ.1UO8mo0Tk",
+        sha1="9357581c4082de3ed5031c914468fd24c57ac9cf",
+        bucket="brainio-brainscore",
+        cls=BehavioralAssembly,
+        stimulus_set_loader=lambda: load_stimulus_set('Zhang2018.search_obj_array'),
+    )
+
+    # stimulus set: Zhang2018.search_obj_array
+    stimulus_set_registry['Zhang2018.search_obj_array'] = lambda: load_stimulus_set_from_s3(
+        identifier="Zhang2018.search_obj_array",
+        bucket="brainio-brainscore",
+        csv_sha1="e9c2f6b35b84256242d257e8d36261aa26d3ed4a",
+        zip_sha1="eab5e52730cc236e71e583a2c401208380dc8628",
+        csv_version_id="blzrCsI0j_5flYuPR_8wGBlYKo87y.l_",
+        zip_version_id="OJOY911yqSuKzpfJP0uxOszdGePx0aCc",
+    )

brainscore_vision/data/zhang2018/test.py

@@ -0,0 +1,29 @@
+import pytest
+
+from brainscore_vision import load_dataset, load_stimulus_set
+
+
+@pytest.mark.skip(reason='There is an issue with the packaging where the zip filenames do not match the csv filenames')
+@pytest.mark.private_access
+def test_assembly():
+    assembly = load_dataset('Zhang2018search_obj_array')
+    assert set(assembly.dims) == {'presentation', 'fixation', 'position'}
+    assert len(assembly['presentation']) == 4500
+    assert len(set(assembly['stimulus_id'].values)) == 300
+    assert len(set(assembly['subjects'].values)) == 15
+    assert len(assembly['fixation']) == 8
+    assert len(assembly['position']) == 2
+    assert assembly.stimulus_set is not None
+
+
+@pytest.mark.skip(reason='There is an issue with the packaging where the zip filenames do not match the csv filenames')
+@pytest.mark.private_access
+def test_stimulus_set():
+    stimulus_set = load_stimulus_set('Zhang2018.search_obj_array')
+    # There are 300 presentation images in the assembly but 606 in the StimulusSet (explanation from @shashikg follows).
+    # For each of the visual search task out of total 300, you need two images (one - the target image,
+    # second - the search space image) plus there are 6 different mask images to mask objects
+    # present at 6 different locations in a specified search image.
+    # Therefore, a total of 300 * 2 + 6 images are there in the stimulus set.
+    assert len(stimulus_set) == 606
+    assert len(set(stimulus_set['stimulus_id'])) == 606

brainscore_vision/data_helpers/lookup_legacy.py

@@ -0,0 +1,15 @@
+import pandas as pd
+from pathlib import Path
+
+version_id_path = Path(__file__).parent / 'version_ids.csv'
+version_id_df = pd.read_csv(version_id_path, index_col='Unnamed: 0')
+
+
+def build_filename(identifier: str, file_type: str):
+    if file_type == '.nc':
+        filename = f'assy_{identifier.replace(".", "_")}.nc'
+    elif file_type == '.csv':
+        filename = f'image_{identifier.replace(".", "_")}.csv'
+    else:
+        filename = f'image_{identifier.replace(".", "_")}.zip'
+    return filename

brainscore_vision/data_helpers/s3.py

@@ -0,0 +1,79 @@
+"""
+Loading data assemblies and stimuli sets from s3.
+"""
+import functools
+import logging
+import os
+from pathlib import Path
+from typing import Callable, Union
+
+import boto3
+from botocore import UNSIGNED
+from botocore.config import Config
+
+from brainio.assemblies import DataAssembly, AssemblyLoader, StimulusMergeAssemblyLoader, \
+    StimulusReferenceAssemblyLoader
+from brainio.fetch import fetch_file, unzip, resolve_stimulus_set_class
+from brainio.stimuli import StimulusSetLoader, StimulusSet
+
+_logger = logging.getLogger(__name__)
+
+
+def get_path(identifier: str, file_type: str, bucket: str, version_id: str, sha1: str, filename_prefix: str = None):
+    """
+    Finds path of desired file (for .csvs, .zips, and .ncs).
+    """
+    if filename_prefix is None:
+        filename_prefix = 'stimulus_' if file_type in ('csv', 'zip') else 'assy_'
+
+    filename = f"{filename_prefix}{identifier.replace('.', '_')}.{file_type}"
+    file_path = fetch_file(location_type="S3",
+                           location=f"https://{bucket}.s3.amazonaws.com/{filename}",
+                           version_id=version_id,
+                           sha1=sha1)
+    return file_path
+
+
+def load_assembly_from_s3(identifier: str, version_id: str, sha1: str, bucket: str, cls: type,
+                          stimulus_set_loader: Callable[[], StimulusSet] = None,
+                          merge_stimulus_set_meta: bool = True) -> DataAssembly:
+    file_path = get_path(identifier, 'nc', bucket, version_id, sha1)
+    if stimulus_set_loader:  # merge stimulus set meta into assembly if `stimulus_set_loader` is passed
+        stimulus_set = stimulus_set_loader()
+        loader_base_class = StimulusMergeAssemblyLoader if merge_stimulus_set_meta else StimulusReferenceAssemblyLoader
+        loader_class = functools.partial(loader_base_class,
+                                         stimulus_set_identifier=stimulus_set.identifier, stimulus_set=stimulus_set)
+    else:  # if no `stimulus_set_loader` passed, just load assembly
+        loader_class = AssemblyLoader
+    loader = loader_class(cls=cls, file_path=file_path)
+    assembly = loader.load()
+    assembly.attrs['identifier'] = identifier
+    return assembly
+
+
+def load_stimulus_set_from_s3(identifier: str, bucket: str, csv_sha1: str, zip_sha1: str,
+                              csv_version_id: str, zip_version_id: str, filename_prefix: str = None):
+    csv_path = get_path(identifier, 'csv', bucket, csv_version_id, csv_sha1, filename_prefix=filename_prefix)
+    zip_path = get_path(identifier, 'zip', bucket, zip_version_id, zip_sha1, filename_prefix=filename_prefix)
+    stimuli_directory = unzip(zip_path)
+    loader = StimulusSetLoader(
+        csv_path=csv_path,
+        stimuli_directory=stimuli_directory,
+        cls=resolve_stimulus_set_class('StimulusSet')
+    )
+    stimulus_set = loader.load()
+    stimulus_set.identifier = identifier
+    # ensure perfect overlap
+    stimuli_paths = [Path(stimuli_directory) / local_path for local_path in os.listdir(stimuli_directory)
+                     if not local_path.endswith('.zip') and not local_path.endswith('.csv')]
+    assert set(stimulus_set.stimulus_paths.values()) == set(stimuli_paths), \
+        "Inconsistency: unzipped stimuli paths do not match csv paths"
+    return stimulus_set
+
+
+def download_file_if_not_exists(local_path: Union[str, Path], bucket: str, remote_filepath: str):
+    if local_path.is_file():
+        return  # nothing to do, file already exists
+    unsigned_config = Config(signature_version=UNSIGNED)  # do not attempt to look up credentials
+    s3 = boto3.client('s3', config=unsigned_config)
+    s3.download_file(bucket, remote_filepath, str(local_path))

brainscore_vision/metric_helpers/__init__.py

@@ -0,0 +1,5 @@
+class Defaults:
+    expected_dims = ('presentation', 'neuroid')
+    stimulus_coord = 'stimulus_id'
+    neuroid_dim = 'neuroid'
+    neuroid_coord = 'neuroid_id'

brainscore_vision/metric_helpers/temporal.py

@@ -0,0 +1,119 @@
+import xarray as xr
+import numpy as np
+
+from brainscore_vision.benchmark_helpers.neural_common import Score
+from brainscore_vision.metric_helpers.transformations import standard_error_of_the_mean
+
+from .xarray_utils import apply_over_dims, recursive_op
+
+
+# take the mean of scores (medians of single neuron scores) over time
+
+
+def average_over_presentation(score: Score) -> Score:
+    raw = score
+    score = raw.mean('presentation')
+    score.attrs['raw'] = raw
+    return score
+
+
+# PerOps is applied to every slice/chunk of the xarray along the specified dimensions
+class PerOps:
+    def __init__(self, callable, dims, check_coords=[]):
+        # for coordinate checking, they are supposed to be the same across assemblies
+        self.dims = dims
+        self.callable = callable
+        self.check_coords = check_coords
+
+    def __call__(self, *asms):
+        for check_coord in self.check_coords:
+            asms = [asm.sortby(check_coord) for asm in asms]
+            for asm in asms[1:]:
+                assert (asm[check_coord].values == asms[0][check_coord].values).all()
+        ret = apply_over_dims(self.callable, *asms, dims=self.dims)
+        return ret
+
+
+# SpanOps aggregates specified dimensions to one dimension
+class SpanOps:
+    def __init__(self, callable, source_dims, aggregated_dim, resample=False):
+        # if resample, randomly choose samples from the aggregated dimension,
+        # whose size is the same as the assembly.sizes[aggregated_dim]
+        self.source_dims = source_dims
+        self.aggregated_dim = aggregated_dim
+        self.callable = callable
+        self.resample = resample
+
+    def __call__(self, *asms):
+        asms = [self._stack(asm) for asm in asms]
+        return self.callable(*asms)
+
+    def _stack(self, assembly):
+        assembly_type = type(assembly)
+        size = assembly.sizes[self.aggregated_dim]
+        assembly = xr.DataArray(assembly)  # xarray cannot deal with stacking MultiIndex (pydata/xarray#1554)
+        assembly = assembly.reset_index(self.source_dims)
+        assembly = assembly.rename({dim:dim+"_" for dim in self.source_dims})  # we'll call stacked timebins "presentation"
+        assembly = assembly.stack({self.aggregated_dim : [dim+"_" for dim in self.source_dims]})
+        if self.resample:
+            indices = np.random.randint(0, assembly.sizes[self.aggregated_dim], size)
+            assembly = assembly.isel({self.aggregated_dim: indices})
+        return assembly_type(assembly)
+
+class PerTime(PerOps):
+    def __init__(self, callable, time_dim="time_bin", check_coord="time_bin_start", **kwargs):
+        self.time_bin = time_dim
+        super().__init__(callable, dims=[time_dim], check_coords=[check_coord], **kwargs)
+ 
+class PerPresentation(PerOps):
+    def __init__(self, callable, presentation_dim="presentation", check_coord="stimulus_id", **kwargs):
+        self.presentation_dim = presentation_dim
+        super().__init__(callable, dims=[presentation_dim], check_coords=[check_coord], **kwargs)
+
+class PerNeuroid(PerOps):
+    def __init__(self, callable, neuroid_dim="neuroid", check_coord="neuroid_id", **kwargs):
+        self.neuroid_dim = neuroid_dim
+        super().__init__(callable, dims=[neuroid_dim], check_coords=[check_coord], **kwargs)
+
+class SpanTime(SpanOps):
+    def __init__(self, callable, time_dim="time_bin", presentation_dim="presentation", resample=False):
+        self.time_dim = time_dim
+        self.presentation_dim = presentation_dim
+        source_dims = [self.time_dim, self.presentation_dim]
+        aggregated_dim = self.presentation_dim
+        super().__init__(callable, source_dims, aggregated_dim, resample=resample)
+
+class SpanTimeRegression:
+    """
+    Fits a regression with weights shared across the time bins.
+    """
+
+    def __init__(self, regression):
+        self._regression = regression
+
+    def fit(self, source, target):
+        assert (source['time_bin'].values == target['time_bin'].values).all()
+        SpanTime(self._regression.fit)(source, target)
+
+    def predict(self, source):
+        return PerTime(self._regression.predict)(source)
+
+class PerTimeRegression:
+    """
+    Fits a regression with different weights for each time bins.
+    """
+
+    def __init__(self, regression):
+        self._regression = regression
+
+    def fit(self, source, target):
+        # Lazy fit until predict
+        assert (source['time_bin'].values == target['time_bin'].values).all()
+        self._train_source = source
+        self._train_target = target
+
+    def predict(self, source):
+        def fit_predict(train_source, train_target, test_source):
+            self._regression.fit(train_source, train_target)
+            return self._regression.predict(test_source)
+        return PerTime(fit_predict)(self._train_source, self._train_target, source)