brainscore-vision 2.1__py3-none-any.whl

brainscore_vision/data/marques2020/data_packaging/marques_cavanaugh2002a.py

@@ -0,0 +1,84 @@
+
+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 = 'movshon.Cavanaugh2002a'
+SIZE_STIM_NAME = 'Marques2020_size'
+
+PROPERTY_NAMES = ['surround_suppression_index', 'strongly_suppressed', 'grating_summation_field', 'surround_diameter',
+                  'surround_grating_summation_field_ratio']
+
+
+def collect_data():
+    n_neurons = 190
+
+    # Surround suppression index (n=190 neurons, foveal eccentricity, response > 5spk/s)
+    surround_suppression_index_bins = np.linspace(0, 2, num=11)
+    surround_suppression_index_hist = np.array([66, 44, 38, 23, 16, 3, 0, 0, 0, 0])
+    surround_suppression_index = gen_sample(surround_suppression_index_hist, surround_suppression_index_bins,
+                                            scale='linear')
+
+    # Strongly suppressed (n=190 neurons, foveal eccentricity, response > 5spk/s)
+    strongly_suppressed_bins = np.linspace(0, 1, num=3)
+    strongly_suppressed_hist = np.array([42, 148])
+    strongly_suppressed = np.concatenate((np.zeros(strongly_suppressed_hist[0]),
+                                          np.ones(strongly_suppressed_hist[1]))).reshape((-1, 1))
+
+    # Grating summation field (n=148 neurons & suppression > 10%)
+    grating_summation_field_bins = np.array([0.0625, 0.125, 0.25, 0.5, 1.0, 2.0, 4.0, 8.0, 16.0])
+    grating_summation_field_hist = np.array([0, 9, 30, 55, 42, 10, 2, 0])
+    grating_summation_field = gen_sample(grating_summation_field_hist, grating_summation_field_bins, scale='log2')
+    filler = np.zeros((n_neurons - grating_summation_field_hist.sum(), 1))
+    filler[:] = np.nan
+    grating_summation_field = np.concatenate((filler, grating_summation_field))
+
+    # Surround diameter (n=148 neurons & suppression > 10%)
+    surround_diameter_bins = np.array([0.0625, 0.125, 0.25, 0.5, 1.0, 2.0, 4.0, 8.0, 16.0])
+    surround_diameter_hist = np.array([0, 0, 2, 20, 33, 49, 40, 4])
+    surround_diameter = gen_sample(surround_diameter_hist, surround_diameter_bins, scale='log2')
+    filler = np.zeros((n_neurons - surround_diameter_hist.sum(), 1))
+    filler[:] = np.nan
+    surround_diameter = np.concatenate((filler, surround_diameter))
+
+    # Surround diameter / Grating summation field (n=148 neurons, foveal eccentricity & suppression > 10%)
+    surround_grating_summation_field_ratio_bins = np.array([1, 2, 4, 8, 16, 32])
+    surround_grating_summation_field_ratio_hist = np.array([69, 38, 31, 10, 0])
+    surround_grating_summation_field_ratio = gen_sample(surround_grating_summation_field_ratio_hist,
+                                                        surround_grating_summation_field_ratio_bins, scale='log2')
+    filler = np.zeros((n_neurons - surround_grating_summation_field_ratio_hist.sum(), 1))
+    filler[:] = np.nan
+    surround_grating_summation_field_ratio = np.concatenate((filler, surround_grating_summation_field_ratio))
+
+    # Create DataAssembly with single neuronal properties and bin information
+    assembly = np.concatenate((surround_suppression_index, strongly_suppressed, grating_summation_field,
+                               surround_diameter, surround_grating_summation_field_ratio), axis=1)
+
+    assembly = DataAssembly(assembly, coords={'neuroid_id': ('neuroid', range(assembly.shape[0])),
+                                              'region': ('neuroid', ['V1'] * assembly.shape[0]),
+                                              'neuronal_property': PROPERTY_NAMES},
+                            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=SIZE_STIM_NAME, assembly_class='PropertyAssembly',
+                          bucket_name='brainio.contrib')
+
+
+if __name__ == '__main__':
+    main()
+

brainscore_vision/data/marques2020/data_packaging/marques_devalois1982a.py

@@ -0,0 +1,44 @@
+
+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 = 'devalois.DeValois1982a'
+ORIENTATION_STIM_NAME = 'Marques2020_orientation'
+
+
+def collect_data():
+    # Preferred orientation data
+    preferred_orientation_hist = np.array([110, 83, 100, 92])
+    preferred_orientation_bins = np.linspace(-22.5, 157.5, 5)
+
+    preferred_orientation = gen_sample(preferred_orientation_hist, preferred_orientation_bins, scale='linear')
+
+    # Create DataAssembly with single neuronal properties and bin information
+    assembly = DataAssembly(preferred_orientation, coords={'neuroid_id': ('neuroid',
+                                                                          range(preferred_orientation.shape[0])),
+                                                           'region': ('neuroid', ['V1'] * preferred_orientation.shape[0]),
+                                                           'neuronal_property': ['preferred_orientation']},
+                            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=ORIENTATION_STIM_NAME,
+                          assembly_class='PropertyAssembly', bucket_name='brainio.contrib')
+
+
+if __name__ == '__main__':
+    main()
+

brainscore_vision/data/marques2020/data_packaging/marques_devalois1982b.py

@@ -0,0 +1,54 @@
+
+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 = 'devalois.DeValois1982b'
+SPATIAL_FREQUENCY_STIM_NAME = 'Marques2020_spatial_frequency'
+
+
+def collect_data():
+    # Peak spatial frequency data
+    peak_spatial_frequency_bins = np.array([0.35, 0.5, 0.7, 1.0, 1.4, 2.0, 2.8, 4.0, 5.6, 8.0, 11.2, 16.0, 22.4])
+
+    peak_spatial_frequency_simple_foveal_hist = np.array([0, 4, 4, 8, 25, 33, 26, 28, 12, 5, 2, 1])
+    peak_spatial_frequency_complex_foveal_hist = np.array([0, 0, 0, 9, 9, 7, 10, 23, 12, 8, 3, 3])
+    peak_spatial_frequency_simple_parafoveal_hist = np.array([2, 4, 10, 12, 18, 7, 18, 3, 4, 0, 0, 0])
+    peak_spatial_frequency_complex_parafoveal_hist = np.array([1, 2, 1, 2, 5, 15, 13, 9, 3, 2, 0, 0])
+
+    peak_spatial_frequency_hist = (
+                peak_spatial_frequency_simple_foveal_hist + peak_spatial_frequency_complex_foveal_hist +
+                peak_spatial_frequency_simple_parafoveal_hist + peak_spatial_frequency_complex_parafoveal_hist)
+
+    peak_spatial_frequency = gen_sample(peak_spatial_frequency_hist, peak_spatial_frequency_bins, scale='log2')
+
+    # Create DataAssembly with single neuronal properties and bin information
+    assembly = DataAssembly(peak_spatial_frequency, coords={'neuroid_id': ('neuroid',
+                                                                           range(peak_spatial_frequency.shape[0])),
+                                                            'region': ('neuroid', ['V1'] *
+                                                                       peak_spatial_frequency.shape[0]),
+                                                            'neuronal_property': ['peak_spatial_frequency']},
+                            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_freemanZiemba2013.py

@@ -0,0 +1,252 @@
+
+import numpy as np
+import xarray
+from brainio_collection.packaging import package_data_assembly
+import h5py
+from brainio_base.assemblies import DataAssembly
+
+DATA_DIR = '/braintree/data2/active/users/tmarques/bs_datasets/FreemanZiemba2013_V1V2data.mat'
+ASSEMBLY_NAME = 'movshon.FreemanZiemba2013_V1_properties'
+TEXTURE_STIM_NAME = 'FreemanZiemba2013_properties'
+
+PROPERTY_NAMES = ['texture_modulation_index', 'absolute_texture_modulation_index', 'texture_selectivity',
+                  'noise_selectivity', 'texture_sparseness', 'noise_sparseness', 'variance_ratio', 'sample_variance',
+                  'family_variance', 'max_texture', 'max_noise', ]
+
+
+def collect_data(data_dir):
+    response_file = h5py.File(data_dir, 'r')
+
+    texture_modulation_index, absolute_texture_modulation_index, texture_selectivity, noise_selectivity, \
+    texture_sparseness, noise_sparseness, variance_ratio, sample_variance, family_variance, max_texture, max_noise = \
+        calculate_texture_properties(response_file, area='v1')
+
+    # Bins
+    max_texture_bins = np.logspace(-1, 3, 13, base=10)
+    max_noise_bins = np.logspace(-1, 3, 13, base=10)
+    texture_modulation_index_bins = np.linspace(-1, 1, num=25)
+    absolute_texture_modulation_index_bins = np.linspace(0, 1, num=13)
+    texture_selectivity_bins = np.linspace(0, 1, num=11)
+    noise_selectivity_bins = np.linspace(0, 1, num=11)
+    texture_sparseness_bins = np.linspace(0, 1, num=11)
+    noise_sparseness_bins = np.linspace(0, 1, num=11)
+    variance_ratio_bins = np.logspace(-2, 1, num=13)
+    sample_variance_bins = np.linspace(0, 1, num=11)
+    family_variance_bins = np.linspace(0, 1, num=11)
+
+    # Create DataAssembly with single neuronal properties and bin information
+    assembly = np.concatenate((texture_modulation_index, absolute_texture_modulation_index, texture_selectivity,
+                               noise_selectivity, texture_sparseness, noise_sparseness, variance_ratio, sample_variance,
+                               family_variance, max_texture, max_noise), axis=1)
+
+    assembly = DataAssembly(assembly, coords={'neuroid_id': ('neuroid', range(assembly.shape[0])),
+                                              'region': ('neuroid', ['V1'] * assembly.shape[0]),
+                                              'neuronal_property': PROPERTY_NAMES},
+                            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(DATA_DIR)
+    assembly.name = ASSEMBLY_NAME
+    print('Packaging assembly')
+    package_data_assembly(xarray.DataArray(assembly), assembly_identifier=assembly.name, stimulus_set_identifier=TEXTURE_STIM_NAME,
+                          assembly_class='PropertyAssembly', bucket_name='brainio.contrib')
+
+
+def calculate_texture_properties(response_file, area='v1'):
+    textureNumOrder = np.array([327, 336, 393, 402, 13, 18, 23, 30, 38, 48, 52, 56, 60, 71, 99])
+    familyNumOrder = np.array([60, 56, 13, 48, 71, 18, 327, 336, 402, 38, 23, 52, 99, 393, 30])
+    textureSorted = [np.argwhere(textureNumOrder == familyNumOrder[i])[0][0] for i in range(len(familyNumOrder))]
+
+    responses = response_file[area].value
+    # (cellNum) x (timeBin) x (rep) x (sample) x (texType) x (texFamily)
+    # (102+)    x (300)     x (20)  x (15)     x (2)       x (15)
+
+    responses = responses[:, :, :, :, :, textureSorted]
+    responses = np.moveaxis(responses, 4, 2)  # texType to position 2
+    responses = np.moveaxis(responses, 5, 3)  # family to position 3
+    responses = np.moveaxis(responses, 5, 4)  # sample to position 4
+    # (cellNum) x (timeBin) x (texType) x (texFamily) x (sample) x (rep)
+
+    n_neurons, n_tb, n_type, n_fam, n_smp, n_rep = responses.shape
+
+    responses_stabilized = np.copy(responses)  # copies data for treating as stabilized spike counts
+
+    # Calculates average responses in 10ms timebins (in spike/s)
+    responses = responses.reshape(n_neurons, 30, 10, n_type, n_fam, n_smp, n_rep).mean(axis=2) * 1000
+
+    n_tb = responses.shape[1]
+    sample_responses = responses.mean(axis=5)  # average across repetitions
+    family_responses = sample_responses.mean(axis=4)  # average across samples
+    type_responses = family_responses.mean(axis=3)  # average across types
+    mean_responses = type_responses.mean(axis=2)  # average across all
+    baseline = mean_responses.min(axis=1, keepdims=True)  # baseline response
+
+    latency = calculate_latency(family_responses)  # gets latency using sample averages
+    sample_responses = calculate_mean_response(sample_responses, lat=latency)  # mean response during 100ms
+    sample_responses = sample_responses - baseline.reshape(-1, 1, 1, 1) # subtracts baseline response and rectifies
+    sample_responses[sample_responses < 0] = 0
+    family_responses = sample_responses.mean(axis=3)
+    max_response = sample_responses.reshape((n_neurons, n_type, -1)).max(axis=2)
+
+    # Sums spikes in 10ms timebins
+    responses_stabilized = responses_stabilized.reshape(n_neurons, 30, 10, n_type, n_fam, n_smp, n_rep).sum(axis=2)
+    responses_stabilized = calculate_mean_response(responses_stabilized, lat=latency) * 10
+    responses_stabilized = np.sqrt(responses_stabilized) + np.sqrt(responses_stabilized + 1)
+    responses_stabilized = responses_stabilized.mean(axis=4)
+
+    # Maximum texture response
+    max_texture = max_response[:, 1].reshape((-1, 1))
+
+    # Maximum noise response
+    max_noise = max_response[:, 0].reshape((-1, 1))
+
+    texture_modulation_index = np.zeros((n_neurons, 1))
+    texture_selectivity = np.zeros((n_neurons, 1))
+    noise_selectivity = np.zeros((n_neurons, 1))
+    texture_sparseness = np.zeros((n_neurons, 1))
+    noise_sparseness = np.zeros((n_neurons, 1))
+    variance_ratio = np.zeros((n_neurons, 1))
+    sample_variance = np.zeros((n_neurons, 1))
+    family_variance = np.zeros((n_neurons, 1))
+
+    for n in range(n_neurons):
+        # Texture modulation
+        texture_modulation_index[n] = calculate_texture_modulation(family_responses[n])[0]
+        # Texture selectivity (sparseness over texture families)
+        texture_selectivity[n] = calculate_sparseness(family_responses[n, 1])
+        # Noise selectivity (sparseness over noise families)
+        noise_selectivity[n] = calculate_sparseness(family_responses[n, 0])
+        # Texture sparseness (sparseness over texture samples)
+        texture_sparseness[n] = calculate_sparseness(sample_responses[n, 1])
+        # Noise sparseness (sparseness over noise samples)
+        noise_sparseness[n] = calculate_sparseness(sample_responses[n, 0])
+        variance_ratio[n], sample_variance[n], family_variance[n] = calculate_variance_ratio(responses_stabilized[n, 1])
+
+    absolute_texture_modulation_index = np.abs(texture_modulation_index)
+
+    return texture_modulation_index, absolute_texture_modulation_index, texture_selectivity, noise_selectivity,\
+           texture_sparseness, noise_sparseness, variance_ratio, sample_variance, family_variance, max_texture, \
+           max_noise
+
+
+def calculate_mean_response(response, lat, resp_nbin=10):
+
+    response_shape = response.shape
+    n_neur = response_shape[0]
+    mean_response = np.zeros(np.concatenate((np.array([n_neur]), np.array(response_shape[2:]))))
+
+    for n in range(n_neur):
+        mean_response[n] = response[n, lat[n]:(lat[n] + resp_nbin + 1)].mean(axis=0)
+
+    return mean_response
+
+
+def calculate_latency(response, t_pk=[7, 22], t_lat_min=2, max_d_lat=10, thrsh=0.15):
+
+    # n_neur, n_tb, n_type, n_fam = meanByFam.shape
+
+    response_shape = response.shape
+    n_neur = response_shape[0]
+
+    lat = np.zeros(n_neur).astype(int)
+    for n in range(n_neur):
+        pref_stim = np.unravel_index(np.argmax(response[n, t_pk[0]:t_pk[1]]), response_shape[1:])
+        pk_lat = pref_stim[0]
+        if len(pref_stim)==2:
+            pref_response = response[n, :, pref_stim[1]]
+        elif len(pref_stim)==3:
+            pref_response = response[n, :, pref_stim[1], pref_stim[2]]
+        elif len(pref_stim) == 4:
+            pref_response = response[n, :, pref_stim[1], pref_stim[2], pref_stim[3]]
+
+        pref_response_pk = np.max(pref_response)
+        pk_lat = pk_lat + t_pk[0]
+
+        min_lat = np.max([t_lat_min, pk_lat-max_d_lat])
+        min_val = np.min(pref_response[min_lat:pk_lat])
+
+        lat_min = np.argmin(pref_response[min_lat:pk_lat]) + min_lat
+        range_val = pref_response_pk - min_val
+
+        lat[n] = np.argwhere(pref_response[lat_min:(pk_lat + 1)] <= (min_val + thrsh * range_val))[-1][0] \
+                 + lat_min + 1
+    return lat
+
+
+def calculate_texture_modulation(response):
+    texMod_fam = (response[1, :] - response[0, :]) / (response[1, :] + response[0, :])
+    texMod = np.nanmean(texMod_fam)
+
+    return texMod, texMod_fam
+
+
+def calculate_sparseness(response):
+
+    response = response.reshape(-1)
+    n_stim = response.shape[0]
+
+    spars = (1 - ((response.sum() / n_stim) ** 2) / ((response ** 2).sum() / n_stim)) / (1 - 1 / n_stim)
+
+    return spars
+
+
+def calculate_variance_ratio(response):
+
+    residual_ms, sample_ms, family_ms = calculate_variance(response)
+    response_shape = response.shape
+
+    if len(response_shape) == 3:
+        residual_variance = residual_ms
+        sample_variance = (sample_ms - residual_ms) / response_shape[2]
+        family_variance = (family_ms - sample_ms) / (response_shape[2]*response_shape[1])
+
+    else:
+        residual_variance = 0
+        sample_variance = sample_ms
+        family_variance = (family_ms - sample_ms) / response_shape[1]
+
+    total_variance = residual_variance + sample_variance + family_variance
+
+    variance_ratio = (family_variance / total_variance + 0.02) / (sample_variance / total_variance + 0.02)
+
+    return variance_ratio, sample_variance / total_variance, family_variance / total_variance
+
+
+def calculate_variance(response):
+
+    response_shape = response.shape
+
+    if len(response_shape) == 3:
+        a, b, n = response_shape
+
+        sample_mean = response.mean(axis=2)
+        family_mean = sample_mean.mean(axis=1)
+        all_mean = family_mean.mean()
+
+        residual_ms = np.sum((response - sample_mean.reshape(a, b, 1)) ** 2) / (a * b * (n - 1))
+        sample_ms = n * np.sum((sample_mean - family_mean.reshape(a, 1)) ** 2) / (a * (b - 1))
+        family_ms = b*n*np.sum((family_mean - all_mean) ** 2) / (a - 1)
+    else:
+        a, b = response_shape
+
+        sample_mean = response
+        family_mean = sample_mean.mean(axis=1)
+        all_mean = family_mean.mean()
+
+        residual_ms = np.nan
+        sample_ms = np.sum((sample_mean - family_mean.reshape(a, 1)) ** 2) / (a * (b - 1))
+        family_ms = b * np.sum((family_mean - all_mean) ** 2) / (a - 1)
+
+    return residual_ms, sample_ms, family_ms
+
+
+if __name__ == '__main__':
+    main()

brainscore_vision/data/marques2020/data_packaging/marques_gen_stim.py

@@ -0,0 +1,95 @@
+import os
+import numpy as np
+from marques_stim_common import gen_grating_stim, gen_blank_stim, gen_texture_stim, \
+    load_stim_info
+from brainio_collection.packaging import package_stimulus_set
+
+BLANK_STIM_NAME = 'Marques2020_blank'
+RF_STIM_NAME = 'Marques2020_receptive_field'
+ORIENTATION_STIM_NAME = 'Marques2020_orientation'
+SF_STIM_NAME = 'Marques2020_spatial_frequency'
+SIZE_STIM_NAME = 'Marques2020_size'
+TEXTURE_STIM_NAME = 'FreemanZiemba2013_properties'
+
+DATA_DIR = '/braintree/data2/active/users/tmarques/bs_stimuli'
+DEGREES = 12
+SIZE_PX = 672
+TEXTURE_DEGREES = 8
+
+## All parameters
+POS = np.array([0.5])
+RADIUS = np.logspace(-3 + 0.75, 4 - 0.75, 12, endpoint=True, base=2) / 2
+SF = np.logspace(-1.5 + 0.125, 4 - 0.125, 22, endpoint=True, base=2)
+ORIENTATION = np.linspace(0, 165, 12, endpoint=True)
+PHASE = np.linspace(0, 315, 8, endpoint=True)
+CONTRAST = [1]
+
+## Stimulus specific
+POS_rf = np.linspace(-2.5, 2.5, 21, endpoint=True)
+RADIUS_rf = [1/6]
+SF_rf = [3]
+ORIENTATION_rf = ORIENTATION[[0, 3, 6, 9]]
+PHASE_rf = PHASE[[0, 4]]
+RF_PARAMS = np.array(np.meshgrid(POS_rf, POS_rf, CONTRAST, PHASE_rf, ORIENTATION_rf, SF_rf,
+                                 RADIUS_rf)).T.reshape(-1, 7)[:,[0,1,2,6,5,4,3]]
+
+RADIUS_sf = np.array([0.75, 2.25])
+ORIENTATION_sf = ORIENTATION[[0, 2, 4, 6, 8, 10]]
+SF_PARAMS = np.array(np.meshgrid(POS, POS, CONTRAST, PHASE, ORIENTATION_sf, SF,
+                                 RADIUS_sf)).T.reshape(-1, 7)[:,[0,1,2,6,5,4,3]]
+
+SF_size = SF[[4, 8, 12, 16]]
+ORIENTATION_size = ORIENTATION[[0, 2, 4, 6, 8, 10]]
+SIZE_PARAMS = np.array(np.meshgrid(POS, POS, CONTRAST, PHASE, ORIENTATION_size, SF_size,
+                                   RADIUS)).T.reshape(-1, 7)[:,[0,1,2,6,5,4,3]]
+
+SF_or = SF[[4,8,12,16]]
+MULT_RADIUS_or = [2, 3, 4]
+SF_RADIUS_or = np.zeros((len(SF_or)*len(MULT_RADIUS_or), 2))
+ind = 0
+for mr in MULT_RADIUS_or:
+    for sf in SF_or:
+        SF_RADIUS_or[ind] = [mr/2/sf, sf]
+        ind += 1
+ORIENTATION_PHASE_or = np.array(np.meshgrid(ORIENTATION, PHASE)).T.reshape(-1, 2)
+ORIENTATION_PARAMS = np.zeros((len(SF_RADIUS_or) * len(ORIENTATION_PHASE_or), 7))
+ind = 0
+for sf_rad in SF_RADIUS_or:
+    for or_phase in ORIENTATION_PHASE_or:
+        ORIENTATION_PARAMS[ind] = np.concatenate((POS, POS, CONTRAST, sf_rad, or_phase))
+        ind += 1
+
+STIM_NAMES = [RF_STIM_NAME, ORIENTATION_STIM_NAME, SF_STIM_NAME, SIZE_STIM_NAME]
+
+GRAT_PARAMS = {RF_STIM_NAME: RF_PARAMS, ORIENTATION_STIM_NAME: ORIENTATION_PARAMS, SF_STIM_NAME: SF_PARAMS,
+               SIZE_STIM_NAME: SIZE_PARAMS}
+
+
+def main():
+    blank_dir = DATA_DIR + os.sep + BLANK_STIM_NAME
+    if not (os.path.isdir(blank_dir)):
+        gen_blank_stim(degrees=DEGREES, size_px=448, save_dir=blank_dir)
+    stimuli = load_stim_info(BLANK_STIM_NAME, blank_dir)
+    print('Packaging stimuli:' + stimuli.identifier)
+    package_stimulus_set(stimuli, stimulus_set_identifier=stimuli.identifier, bucket_name='brainio.dicarlo')
+
+    for stim_name in STIM_NAMES:
+        stim_dir = DATA_DIR + os.sep + stim_name
+        if not (os.path.isdir(stim_dir)):
+            gen_grating_stim(degrees=DEGREES, size_px=SIZE_PX, stim_name=stim_name, grat_params=GRAT_PARAMS[stim_name],
+                             save_dir=stim_dir)
+        stimuli = load_stim_info(stim_name, stim_dir)
+        print('Packaging stimuli:' + stimuli.identifier)
+        package_stimulus_set(stimuli, stimulus_set_identifier=stimuli.identifier, bucket_name='brainio.dicarlo')
+
+    texture_dir = DATA_DIR + os.sep + TEXTURE_STIM_NAME
+    if not (os.path.isdir(texture_dir)):
+        gen_texture_stim(degrees=TEXTURE_DEGREES, stim_pos=np.array([POS[0], POS[0]]), save_dir=texture_dir)
+    stimuli = load_stim_info(TEXTURE_STIM_NAME, texture_dir)
+    print('Packaging stimuli:' + stimuli.identifier)
+    package_stimulus_set(stimuli, stimulus_set_identifier=stimuli.identifier, bucket_name='brainio.contrib')
+    return
+
+
+if __name__ == '__main__':
+    main()

brainscore_vision/data/marques2020/data_packaging/marques_ringach2002.py

@@ -0,0 +1,95 @@
+
+import numpy as np
+import xarray
+from brainio_collection.packaging import package_data_assembly
+import scipy.io as sio
+from brainio_base.assemblies import DataAssembly
+
+DATA_DIR = '/braintree/data2/active/users/tmarques/bs_datasets/Ringach2002.mat'
+ASSEMBLY_NAME = 'shapley.Ringach2002'
+ORIENTATION_STIM_NAME = 'Marques2020_orientation'
+
+PROPERTY_NAMES = ['baseline', 'max_dc', 'min_dc', 'max_ac', 'modulation_ratio', 'circular_variance', 'bandwidth',
+                  'orthogonal_preferred_ratio', 'orientation_selective', 'circular_variance_bandwidth_ratio',
+                  'orthogonal_preferred_ratio_circular_variance_difference',
+                  'orthogonal_preferred_ratio_bandwidth_ratio']
+
+
+def collect_data(data_dir):
+    ringach2002 = sio.loadmat(data_dir)
+    or_data = ringach2002['db']
+
+    # Response magnitudes
+    baseline = or_data['spont'][0, 0].T
+    n_neuroids = baseline.shape[0]
+
+    max_dc = or_data['maxdc'][0, 0].T
+    min_dc = or_data['mindc'][0, 0].T
+    max_ac = or_data['maxfirst'][0, 0].T
+    modulation_ratio = max_ac / max_dc
+
+    # Orientation tuning properties
+    circular_variance = or_data['orivar'][0, 0].T
+    bandwidth = or_data['bw'][0, 0].T
+    bandwidth[bandwidth > 90] = np.nan
+    orthogonal_preferred_ratio = or_data['po'][0, 0].T
+
+    orientation_selective = np.ones((n_neuroids, 1))
+    orientation_selective[np.isnan(bandwidth)] = 0
+
+    # Orientation tuning properties covariances
+    circular_variance_bandwidth_ratio = circular_variance / bandwidth
+    orthogonal_preferred_ratio_circular_variance_difference = orthogonal_preferred_ratio - circular_variance
+    orthogonal_preferred_ratio_bandwidth_ratio = orthogonal_preferred_ratio/bandwidth
+
+    # Bins
+    max_dc_bins = np.logspace(0, 3, 10, base=10)
+    max_ac_bins = np.logspace(0, 3, 10, base=10)
+    min_dc_bins = np.logspace(-1-1/3, 2, 11, base=10)
+    baseline_bins = np.logspace(-1-1/3, 2, 11, base=10)
+    modulation_ratio_bins = np.linspace(0, 2, 11)
+
+    circular_variance_bins = np.linspace(0, 1, num=14)
+    bandwidth_bins = np.linspace(0, 90, num=18)
+    orthogonal_preferred_ratio_bins = np.linspace(0, 1, num=14)
+    orientation_selective_bins = np.linspace(0, 1, num=3)
+
+    circular_variance_bandwidth_ratio_bins = np.logspace(-3, 0, num=16, base=10)
+    orthogonal_preferred_ratio_bandwidth_ratio_bins = np.logspace(-3, 0, num=16, base=10)
+    orthogonal_preferred_ratio_circular_variance_difference_bins = np.linspace(-1, 1, num=20)
+
+    # Create DataAssembly with single neuronal properties and bin information
+    assembly = np.concatenate((baseline, max_dc, min_dc, max_ac, modulation_ratio, circular_variance, bandwidth,
+                               orthogonal_preferred_ratio, orientation_selective,
+                               circular_variance_bandwidth_ratio,
+                               orthogonal_preferred_ratio_circular_variance_difference,
+                               orthogonal_preferred_ratio_bandwidth_ratio), axis=1)
+
+    # Filters neurons with weak responses
+    good_neuroids = max_dc > baseline + 5
+    assembly = assembly[np.argwhere(good_neuroids)[:, 0], :]
+
+    assembly = DataAssembly(assembly, coords={'neuroid_id': ('neuroid', range(assembly.shape[0])),
+                                              'region': ('neuroid', ['V1'] * assembly.shape[0]),
+                                              'neuronal_property': PROPERTY_NAMES},
+                            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(DATA_DIR)
+    assembly.name = ASSEMBLY_NAME
+    print('Packaging assembly')
+    package_data_assembly(xarray.DataArray(assembly), assembly_identifier=assembly.name, stimulus_set_identifier=ORIENTATION_STIM_NAME,
+                          assembly_class='PropertyAssembly', bucket_name='brainio.contrib')
+
+
+if __name__ == '__main__':
+    main()
+