brainscore-vision 2.1__py3-none-any.whl

brainscore_vision/data/marques2020/data_packaging/marques_schiller1976c.py

@@ -0,0 +1,60 @@
+
+import numpy as np
+import xarray
+from marques_utils import gen_sample
+from brainio_collection.packaging import package_data_assembly
+from brainio_base.assemblies import DataAssembly
+
+ASSEMBLY_NAME = 'schiller.Schiller1976c'
+SPATIAL_FREQUENCY_STIM_NAME = 'Marques2020_spatial_frequency'
+
+
+def collect_data():
+    n_neurons = 87
+    # Spatial frequency selective data
+    spatial_frequency_selective_bins = np.linspace(0, 1, num=3)
+    spatial_frequency_selective_hist = np.array([14, 73])
+    spatial_frequency_selective = np.concatenate((np.zeros(spatial_frequency_selective_hist[0]),
+                                                  np.ones(spatial_frequency_selective_hist[1]))).reshape((-1,1))
+
+    # Spatial frequency bandwidth data
+    spatial_frequency_bandwidth_bins = np.linspace(0, 100, num=11)
+    spatial_frequency_bandwidth_simple_hist = np.array([0, 0, 0, 6, 5, 10, 7, 2, 0, 0])
+    spatial_frequency_bandwidth_complex_hist = np.array([0, 3, 4, 10, 17, 6, 2, 1, 0, 0])
+    spatial_frequency_bandwidth_hist = (spatial_frequency_bandwidth_simple_hist +
+                                        spatial_frequency_bandwidth_complex_hist)
+    spatial_frequency_bandwidth = gen_sample(spatial_frequency_bandwidth_hist, spatial_frequency_bandwidth_bins,
+                                             scale='linear')
+    filler = np.zeros((n_neurons - spatial_frequency_bandwidth_hist.sum(), 1))
+    filler[:] = np.nan
+    spatial_frequency_bandwidth = np.concatenate((filler, spatial_frequency_bandwidth))
+
+    # Create DataAssembly with single neuronal properties and bin information
+    assembly = np.concatenate((spatial_frequency_selective, spatial_frequency_bandwidth), axis=1)
+
+    assembly = DataAssembly(assembly, coords={'neuroid_id': ('neuroid', range(assembly.shape[0])),
+                                              'region': ('neuroid', ['V1'] * assembly.shape[0]),
+                                              'neuronal_property': ['spatial_frequency_selective',
+                                                                    'spatial_frequency_bandwidth']},
+                            dims=['neuroid', 'neuronal_property'])
+
+    assembly.attrs['number_of_trials'] = 20
+
+    for p in assembly.coords['neuronal_property'].values:
+        assembly.attrs[p+'_bins'] = eval(p+'_bins')
+
+    return assembly
+
+
+def main():
+    assembly = collect_data()
+    assembly.name = ASSEMBLY_NAME
+    print('Packaging assembly')
+    package_data_assembly(xarray.DataArray(assembly), assembly_identifier=assembly.name,
+                          stimulus_set_identifier=SPATIAL_FREQUENCY_STIM_NAME, assembly_class='PropertyAssembly',
+                          bucket_name='brainio.contrib')
+
+
+if __name__ == '__main__':
+    main()
+

brainscore_vision/data/marques2020/data_packaging/marques_stim_common.py

@@ -0,0 +1,389 @@
+
+import numpy as np
+import imageio
+import os
+import pandas as pd
+from glob import glob
+
+import matplotlib.pyplot as plt
+from brainio_base.stimuli import StimulusSet
+
+
+class Stimulus:
+    def __init__(self, size_px=[448, 448], bit_depth=8,
+                 stim_id=1000, save_dir='images', type_name='stimulus',
+                 format_id='{0:04d}'):
+        self.save_dir = save_dir
+        self.stim_id = stim_id
+        self.format_id = format_id
+        self.type_name = type_name
+
+        self.white = np.uint8(2**bit_depth-1)
+        self.black = np.uint8(0)
+        self.gray = np.uint8(self.white/2+1)
+        self.size_px = size_px
+        self.objects = []
+        self.stimulus = np.ones(self.size_px, dtype=np.uint8) * self.gray
+
+    def add_object(self, stim_object):
+        self.objects.append(stim_object)
+
+    def build_stimulus(self):
+        for obj in self.objects:
+            self.stimulus[obj.mask] = obj.stimulus[obj.mask]
+
+    def clear_stimulus(self):
+        self.stimulus = np.ones(self.size, dtype=np.uint8) * self.gray
+
+    def show_stimulus(self):
+        my_dpi = 192
+        fig = plt.figure()
+        fig.set_size_inches(self.size_px[1] / my_dpi, self.size_px[0] / my_dpi, forward=False)
+        ax = plt.axes([0, 0, 1, 1])
+        ax.set_axis_off()
+        fig.add_axes(ax)
+        ax.imshow(self.stimulus, cmap='gray')
+        plt.show()
+
+    def save_stimulus(self):
+        file_name= self.type_name + '_' + self.format_id.format(self.stim_id) + '.png'
+        imageio.imwrite(self.save_dir + os.sep + file_name, self.stimulus)
+        return file_name
+
+
+class Grating:
+    def __init__(self, orientation=0, phase=0, sf=2, size_px=[448, 448], width=8,
+                 contrast=1, bit_depth=8, pos=[0, 0], rad=5, sig=0,
+                 stim_id=1000, format_id='{0:04d}', save_dir='images', type_name='grating'):
+
+        # save directory
+        self.save_dir = save_dir
+        self.stim_id = stim_id
+        self.format_id = format_id
+        # label for type of stimulus
+        self.type_name = type_name
+
+        # 1 channel colors, white, black, grey
+        self.white = np.uint8(2**bit_depth-1)
+        self.black = np.uint8(0)
+        self.gray = np.uint8(self.white/2+1)
+
+        # pixel dimensions of the image
+        self.size_px = np.array(size_px)
+        # position of image in field of view
+        self.pos = np.array(pos)
+        # pixel to visual field degree conversion
+        self.px_to_deg = self.size_px[1] / width
+        # size of stimulus in visual field in degrees
+        self.size = self.size_px / self.px_to_deg
+
+        # orientation in radians
+        self.orientation = orientation / 180 * np.pi
+        # phase of the grating
+        self.phase = phase / 180 * np.pi
+        # spatial frequency of the grating
+        self.sf = sf
+        # contrast of the grating
+        self.contrast = contrast
+
+        # make self.xv and self.yv store the degree positions of all pixels in the image
+        self.xv = np.zeros(size_px)
+        self.yv = np.zeros(size_px)
+        self.update_frame()
+
+        self.mask = np.ones(size_px, dtype=bool)
+        self.set_circ_mask(rad=rad)
+
+        self.tex = np.zeros(size_px)
+        self.stimulus = np.ones(size_px, dtype=np.uint8) * self.gray
+
+        self.envelope = np.ones(size_px)
+        if sig is 0:
+            self.update_tex()
+        else:
+            self.set_gaussian_envelope(sig)
+
+    def update_frame(self):
+        x = (np.arange(self.size_px[1]) - self.size_px[1]/2) / self.px_to_deg - self.pos[1]
+        y = (np.arange(self.size_px[0]) - self.size_px[0]/2) / self.px_to_deg - self.pos[0]
+
+        # all possible degree coordinates in matrices of points
+        self.xv, self.yv = np.meshgrid(x, y)
+
+    def update_tex(self):
+        # make the grating pattern
+        self.tex = (np.sin((self.xv * np.cos(self.orientation) + self.yv * np.sin(self.orientation)) *
+                           self.sf * 2 * np.pi + self.phase) * self.contrast * self.envelope)
+
+    def update_stimulus(self):
+        self.stimulus[self.mask] = np.uint8(((self.tex[self.mask]+1)/2)*self.white)
+        self.stimulus[np.logical_not(self.mask)] = self.gray
+
+    def set_circ_mask(self, rad):
+        # apply operation to put a 1 for all points inclusively within the degree radius and a 0 outside it
+        self.mask = self.xv**2 + self.yv**2 <= rad ** 2
+
+    # same as circular mask but for an annulus
+    def set_annular_mask(self, inner_rad, outer_rad):
+        self.mask = (self.xv ** 2 + self.yv ** 2 <= outer_rad ** 2) * \
+                    (self.xv ** 2 + self.yv ** 2 > inner_rad ** 2)
+
+    def set_gaussian_envelope(self, sig):
+        d = np.sqrt(self.xv**2 + self.yv**2)
+        self.envelope = np.exp(-d**2/(2 * sig**2))
+        self.update_tex()
+
+    def show_stimulus(self):
+        # pyplot stuff
+        self.update_stimulus()
+        my_dpi = 192
+        fig = plt.figure()
+        fig.set_size_inches(self.size_px[1] / my_dpi, self.size_px[0] / my_dpi, forward=False)
+        ax = plt.axes([0, 0, 1, 1])
+        ax.set_axis_off()
+        fig.add_axes(ax)
+        ax.imshow(self.stimulus, cmap='gray')
+        plt.show()
+
+    def save_stimulus(self):
+        # save to correct (previously specified) directory
+        self.update_stimulus()
+        file_name = self.type_name + '_' + self.format_id.format(self.stim_id) + '.png'
+        imageio.imwrite(self.save_dir + os.sep + file_name, self.stimulus)
+        return file_name
+
+
+def load_stim_info(stim_name, data_dir):
+    stim = pd.read_csv(os.path.join(data_dir, 'stimulus_set'), dtype={'image_id': str})
+    image_paths = dict((key, value) for (key, value) in zip(stim['image_id'].values,
+                                                            [os.path.join(data_dir, image_name) for image_name
+                                                             in stim['image_file_name'].values]))
+    stim_set = StimulusSet(stim[stim.columns[:-1]])
+    stim_set.image_paths = image_paths
+    stim_set.identifier = stim_name
+
+    return stim_set
+
+
+def gen_blank_stim(degrees, size_px, save_dir):
+    if not (os.path.isdir(save_dir)):
+        os.mkdir(save_dir)
+
+    stim = Stimulus(size_px=[size_px, size_px], type_name='blank_stim', save_dir=save_dir, stim_id=0)
+
+    stimuli = pd.DataFrame({'image_id': str(0), 'degrees': [degrees]})
+    image_names = (stim.save_stimulus())
+
+    stimuli['image_file_name'] = pd.Series(image_names)
+    stimuli['image_current_local_file_path'] = pd.Series(save_dir + os.sep + image_names)
+
+    stimuli.to_csv(save_dir + os.sep + 'stimulus_set', index=False)
+
+
+def gen_grating_stim(degrees, size_px, stim_name, grat_params, save_dir):
+    if not (os.path.isdir(save_dir)):
+        os.mkdir(save_dir)
+
+    width = degrees
+
+    nStim = grat_params.shape[0]
+
+    print('Generating stimulus: #', nStim)
+
+    stimuli = pd.DataFrame({'image_id': [str(n) for n in range(nStim)], 'degrees': [width] * nStim})
+
+    image_names = nStim * [None]
+    image_local_file_path = nStim * [None]
+    all_y = nStim * [None]
+    all_x = nStim * [None]
+    all_c = nStim * [None]
+    all_r = nStim * [None]
+    all_s = nStim * [None]
+    all_o = nStim * [None]
+    all_p = nStim * [None]
+
+    for i in np.arange(nStim):
+        stim_id = np.uint64(grat_params[i, 0] * 10e9 + grat_params[i, 1] * 10e7 + grat_params[i, 3] * 10e5 +
+                            grat_params[i, 4] * 10e3 + grat_params[i, 5] * 10e1 + grat_params[i, 6])
+        grat = Grating(width=width, pos=[grat_params[i, 0], grat_params[i, 1]], contrast=grat_params[i, 2],
+                       rad=grat_params[i, 3], sf=grat_params[i, 4], orientation=grat_params[i, 5],
+                       phase=grat_params[i, 6], stim_id= stim_id, format_id='{0:012d}', save_dir=save_dir,
+                       size_px=[size_px, size_px], type_name=stim_name)
+        image_names[i] = (grat.save_stimulus())
+        image_local_file_path[i] = save_dir + os.sep + image_names[i]
+        all_y[i] = grat_params[i, 0]
+        all_x[i] = grat_params[i, 1]
+        all_c[i] = grat_params[i, 2]
+        all_r[i] = grat_params[i, 3]
+        all_s[i] = grat_params[i, 4]
+        all_o[i] = grat_params[i, 5]
+        all_p[i] = grat_params[i, 6]
+
+    stimuli['position_y'] = pd.Series(all_y)
+    stimuli['position_x'] = pd.Series(all_x)
+    stimuli['contrast'] = pd.Series(all_c)
+    stimuli['radius'] = pd.Series(all_r)
+    stimuli['spatial_frequency'] = pd.Series(all_s)
+    stimuli['orientation'] = pd.Series(all_o)
+    stimuli['phase'] = pd.Series(all_p)
+    stimuli['image_file_name'] = pd.Series(image_names)
+    stimuli['image_current_local_file_path'] = pd.Series(image_local_file_path)
+
+    stimuli.to_csv(save_dir + os.sep + 'stimulus_set', index=False)
+
+
+def gen_grating_stim_old(degrees, size_px, stim_name, grat_contrast, grat_pos, grat_rad, grat_sf, grat_orientation,
+                     grat_phase, save_dir):
+    if not (os.path.isdir(save_dir)):
+        os.mkdir(save_dir)
+
+    width = degrees
+
+    nStim = len(grat_pos) * len(grat_pos) * len(grat_contrast) * len(grat_rad) * len(grat_sf) * len(grat_orientation) \
+            * len(grat_phase)
+
+    print('Generating stimulus: #', nStim)
+
+    stimuli = pd.DataFrame({'image_id': [str(n) for n in range(nStim)], 'degrees': [width] * nStim})
+
+    image_names = nStim * [None]
+    image_local_file_path = nStim * [None]
+    all_y = nStim * [None]
+    all_x = nStim * [None]
+    all_c = nStim * [None]
+    all_r = nStim * [None]
+    all_s = nStim * [None]
+    all_o = nStim * [None]
+    all_p = nStim * [None]
+
+    i = 0
+    for y in np.arange(len(grat_pos)):
+        for x in np.arange(len(grat_pos)):
+            for c in np.arange(len(grat_contrast)):
+                for r in np.arange(len(grat_rad)):
+                    for s in np.arange(len(grat_sf)):
+                        for o in np.arange(len(grat_orientation)):
+                            for p in np.arange(len(grat_phase)):
+                                grat = Grating(width=width, pos=[grat_pos[y], grat_pos[x]],
+                                               contrast=grat_contrast[c], rad=grat_rad[r],
+                                               sf=grat_sf[s], orientation=grat_orientation[o],
+                                               phase=grat_phase[p],
+                                               stim_id=np.uint64(
+                                                   y * 10e9 + x * 10e7 + r * 10e5 + s * 10e3 + o * 10e1 + p),
+                                               format_id='{0:012d}', save_dir=save_dir, size_px=[size_px, size_px],
+                                               type_name=stim_name)
+                                image_names[i] = (grat.save_stimulus())
+                                image_local_file_path[i] = save_dir + os.sep + image_names[i]
+                                all_y[i] = grat_pos[y]
+                                all_x[i] = grat_pos[x]
+                                all_c[i] = grat_contrast[c]
+                                all_r[i] = grat_rad[r]
+                                all_s[i] = grat_sf[s]
+                                all_o[i] = grat_orientation[o]
+                                all_p[i] = grat_phase[p]
+                                i += 1
+
+    stimuli['position_y'] = pd.Series(all_y)
+    stimuli['position_x'] = pd.Series(all_x)
+    stimuli['contrast'] = pd.Series(all_c)
+    stimuli['radius'] = pd.Series(all_r)
+    stimuli['spatial_frequency'] = pd.Series(all_s)
+    stimuli['orientation'] = pd.Series(all_o)
+    stimuli['phase'] = pd.Series(all_p)
+    stimuli['image_file_name'] = pd.Series(image_names)
+    stimuli['image_current_local_file_path'] = pd.Series(image_local_file_path)
+
+    stimuli.to_csv(save_dir + os.sep + 'stimulus_set', index=False)
+
+
+def gen_texture_stim(degrees, stim_pos, save_dir):
+    if not (os.path.isdir(save_dir)):
+        os.mkdir(save_dir)
+
+    original_dir = '/braintree/home/tmarques/.brainio/image_movshon_stimuli/movshon_stimuli'
+
+    gray_c = 128
+
+    input_degrees = 4
+    aperture_degrees = 4
+
+    original_filenames = []
+    for image_file_path in glob(f"{original_dir}/*.png"):
+        original_filenames.append(image_file_path)
+
+    nStim = len(original_filenames)
+
+    im_temp = imageio.imread(original_filenames[0])
+
+    # Image size
+    size_px = np.array(im_temp.shape).astype(int)
+    px_deg = size_px[0] / input_degrees
+
+    size_px_out = (size_px * (degrees / input_degrees)).astype(int)
+    cnt_px = (stim_pos * px_deg).astype(int)
+
+    size_px_disp = ((size_px_out - size_px) / 2).astype(int)
+
+    fill_ind = [[(size_px_disp[0] + cnt_px[0]), (size_px_disp[0] + cnt_px[0] + size_px[0])],
+                [(size_px_disp[1] + cnt_px[1]), (size_px_disp[1] + cnt_px[1] + size_px[1])]]
+
+    # Image aperture
+    a = aperture_degrees * px_deg / 2
+    # Meshgrid with pixel coordinates
+    x = (np.arange(size_px_out[1]) - size_px_out[1] / 2)
+    y = (np.arange(size_px_out[0]) - size_px_out[0] / 2)
+    xv, yv = np.meshgrid(x, y)
+    # Raised cosine aperture
+    inner_mask = (xv - cnt_px[1]) ** 2 + (yv - cnt_px[0]) ** 2 < a ** 2
+    cos_mask = 1 / 2 * (1 + np.cos(np.sqrt((xv - cnt_px[1]) ** 2 + (yv - cnt_px[0]) ** 2) / a * np.pi))
+    cos_mask[np.logical_not(inner_mask)] = 0
+
+    familyNumOrder = np.array([60, 56, 13, 48, 71, 18, 327, 336, 402, 38, 23, 52, 99, 393, 30])
+
+    type = []
+    sample = []
+    family = []
+    position_x = []
+    position_y = []
+    image_names = nStim * [None]
+    image_local_file_path = nStim * [None]
+
+    for n in range(nStim):
+        im = imageio.imread(original_filenames[n])
+        im = im - gray_c * np.ones(size_px)
+        im_template = np.zeros(size_px_out)
+        im_template[fill_ind[0][0]:fill_ind[0][1], fill_ind[1][0]:fill_ind[1][1]] = im
+        im_masked = (im_template * cos_mask) + gray_c * np.ones(size_px_out)
+
+        file_name = original_filenames[n].split(os.sep)[-1]
+
+        file_parts = file_name.split(os.sep)[-1].split('.')[0].split('-')
+        if file_parts[0].find('tex') == -1:
+            type.append(1)
+        else:
+            type.append(2)
+
+        position_y.append(stim_pos[0])
+        position_x.append(stim_pos[1])
+        sample.append(int(file_parts[3][file_parts[3].find('smp')+3:]))
+        family_temp = int(file_parts[2][file_parts[2].find('im')+2:])
+        family.append(np.where(familyNumOrder == family_temp)[0][0]+1)
+
+        image_names[n] = 'aperture_' + file_name
+        image_local_file_path[n] = save_dir + os.sep + image_names[n]
+
+        imageio.imwrite(image_local_file_path[n], np.uint8(im_masked))
+
+    stimuli = pd.DataFrame({'image_id': [str(n) for n in range(nStim)], 'degrees': [degrees] * nStim})
+
+    stimuli['position_y'] = pd.Series(position_y)
+    stimuli['position_x'] = pd.Series(position_x)
+    stimuli['family'] = pd.Series(family)
+    stimuli['sample'] = pd.Series(sample)
+    stimuli['type'] = pd.Series(type)
+    stimuli['image_file_name'] = pd.Series(image_names)
+    stimuli['image_current_local_file_path'] = pd.Series(image_local_file_path)
+
+    stimuli.to_csv(save_dir + os.sep + 'stimulus_set', index=False)
+
+

brainscore_vision/data/marques2020/data_packaging/marques_utils.py

@@ -0,0 +1,21 @@
+
+import numpy as np
+
+
+def gen_sample(hist, bins, scale='linear'):
+    random_sample = np.empty([0,1])
+
+    if scale == 'log2':
+        bins = np.log2(bins)
+    if scale == 'log10':
+        bins = np.log10(bins)
+
+    for b_ind, b in enumerate(bins[:-1]):
+        random_sample = np.concatenate((random_sample, (np.random.random_sample(hist[b_ind]) *
+                                        (bins[b_ind+1]-bins[b_ind]) + bins[b_ind]).reshape((-1, 1))), axis=0)
+    if scale == 'log2':
+        random_sample = 2 ** random_sample
+    if scale == 'log10':
+        random_sample = 10 ** random_sample
+
+    return random_sample

brainscore_vision/data/marques2020/data_packaging/setup.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from setuptools import setup
+
+requirements = [
+    "pandas",
+    "imageio",
+]
+
+setup(
+    install_requires=requirements,
+)

brainscore_vision/data/marques2020/test.py

@@ -0,0 +1,54 @@
+import pytest
+import brainscore_vision
+from brainscore_vision import load_stimulus_set
+
+
+@pytest.mark.private_access
+class TestMarques2020V1Properties:
+    @pytest.mark.parametrize('identifier,num_neuroids,properties,stimulus_set_identifier', [
+        ('Cavanaugh2002a', 190, [
+            'surround_suppression_index', 'strongly_suppressed', 'grating_summation_field', 'surround_diameter',
+            'surround_grating_summation_field_ratio'],
+         'Marques2020_size'),
+        ('DeValois1982a', 385, [
+            'preferred_orientation'],
+         'Marques2020_orientation'),
+        ('DeValois1982b', 363, [
+            'peak_spatial_frequency'],
+         'Marques2020_spatial_frequency'),
+        ('FreemanZiemba2013_V1_properties', 102, [
+            'absolute_texture_modulation_index', 'family_variance', 'max_noise', 'max_texture', 'noise_selectivity',
+            'noise_sparseness', 'sample_variance', 'texture_modulation_index', 'texture_selectivity',
+            'texture_sparseness', 'variance_ratio'],
+         'FreemanZiemba2013_properties'),
+        ('Ringach2002', 304, [
+            'bandwidth', 'baseline', 'circular_variance', 'circular_variance_bandwidth_ratio', 'max_ac', 'max_dc',
+            'min_dc', 'modulation_ratio', 'orientation_selective', 'orthogonal_preferred_ratio',
+            'orthogonal_preferred_ratio_bandwidth_ratio', 'orthogonal_preferred_ratio_circular_variance_difference'],
+         'Marques2020_orientation'),
+        ('Schiller1976c', 87, [
+            'spatial_frequency_selective', 'spatial_frequency_bandwidth'],
+         'Marques2020_spatial_frequency'),
+    ])
+    def test_assembly(self, identifier, num_neuroids, properties, stimulus_set_identifier):
+        assembly = brainscore_vision.load_dataset(identifier)
+        assert set(assembly.dims) == {'neuroid', 'neuronal_property'}
+        assert len(assembly['neuroid']) == num_neuroids
+        assert set(assembly['neuronal_property'].values) == set(properties)
+        assert assembly.stimulus_set is not None
+        assert assembly.stimulus_set.identifier == stimulus_set_identifier
+
+
+@pytest.mark.private_access
+class TestMarques2020V1Properties:
+    @pytest.mark.parametrize('identifier,num_stimuli', [
+        ('Marques2020_blank', 1),
+        ('Marques2020_receptive_field', 3528),
+        ('Marques2020_orientation', 1152),
+        ('Marques2020_spatial_frequency', 2112),
+        ('Marques2020_size', 2304),
+        ('FreemanZiemba2013_properties', 450),
+    ])
+    def test_num_stimuli(self, identifier, num_stimuli):
+        stimulus_set = load_stimulus_set(identifier)
+        assert len(stimulus_set) == num_stimuli

brainscore_vision/data/rajalingham2018/__init__.py

@@ -0,0 +1,56 @@
+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{rajalingham2018large,
+  title={Large-scale, high-resolution comparison of the core visual object recognition behavior of humans, monkeys, and state-of-the-art deep artificial neural networks},
+  author={Rajalingham, Rishi and Issa, Elias B and Bashivan, Pouya and Kar, Kohitij and Schmidt, Kailyn and DiCarlo, James J},
+  journal={Journal of Neuroscience},
+  volume={38},
+  number={33},
+  pages={7255--7269},
+  year={2018},
+  publisher={Soc Neuroscience}
+}"""
+
+
+# public assembly: uses objectome.public stimuli
+data_registry['Rajalingham2018.public'] = lambda: load_assembly_from_s3(
+    identifier="dicarlo.Rajalingham2018.public",
+    version_id="WEBNb7Azz4CWpzO25JanNjdPSLArltS2",
+    sha1="34c6a8b6f7c523589c1861e4123232e5f7c7df4c",
+    bucket="brainio-brainscore",
+    cls=BehavioralAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('objectome.public'),
+)
+
+# private assembly: uses objectome.private stimuli
+data_registry['Rajalingham2018.private'] = lambda: load_assembly_from_s3(
+    identifier="dicarlo.Rajalingham2018.private",
+    version_id="gwBpHTT2al4FN35Yje7MU2d_ByA_HphX",
+    sha1="516f13793d1c5b72bb445bb4008448ce97a02d23",
+    bucket="brainio-brainscore",
+    cls=BehavioralAssembly,
+    stimulus_set_loader=lambda: load_stimulus_set('objectome.private'),
+)
+
+
+# stimulus set: objectome.public - rajalingham2018
+stimulus_set_registry['objectome.public'] = lambda: load_stimulus_set_from_s3(
+    identifier="objectome.public",
+    bucket="brainio-brainscore",
+    csv_sha1="47884e17106a3be471d6481279cab33889b80850",
+    zip_sha1="064f2955f98e63867755fee2e3ead8cddf6bfab8",
+    csv_version_id="CwFzXLOclwodJZpInD6hc15yeTOywg6J",
+    zip_version_id="g.vVSa77K84jjeto5KAryLESzxJz0yUB")
+
+# stimulus set: objectome.private - same
+stimulus_set_registry['objectome.private'] = lambda: load_stimulus_set_from_s3(
+    identifier="objectome.private",
+    bucket="brainio-brainscore",
+    csv_sha1="ac38e8f7c08fa8294ed25a3bf84a6adb108bf3fc",
+    zip_sha1="ccd39f7f9b8b4a92da06e3960d06225e46208593",
+    csv_version_id=".c_qSre8xH31QWCHU_0bExY4YgWVyxXY",
+    zip_version_id="TKj6DP8Aesj8IH8WDTtPVtdMCKUtAvJK")