brainscore-vision 2.1__py3-none-any.whl

brainscore_vision/benchmarks/marques2020/benchmarks/freemanZiemba2013_benchmark.py

@@ -0,0 +1,138 @@
+import numpy as np
+from result_caching import store
+
+from brainio.assemblies import DataAssembly
+from brainscore_vision import load_dataset, load_metric
+from brainscore_vision.benchmark_helpers.properties_common import PropertiesBenchmark, _assert_texture_activations
+from brainscore_vision.benchmark_helpers.properties_common import calc_texture_modulation, calc_sparseness, \
+    calc_variance_ratio
+from brainscore_vision.data.freemanziemba2013 import BIBTEX
+from brainscore_vision.metrics.distribution_similarity import NeuronalPropertyCeiling
+
+ASSEMBLY_NAME = 'FreemanZiemba2013_V1_properties'
+REGION = 'V1'
+TIMEBINS = [(70, 170)]
+PARENT_TEXTURE_MODULATION = 'V1-texture_modulation'
+PARENT_SELECTIVITY = 'V1-response_selectivity'
+PARENT_MAGNITUDE = 'V1-response_magnitude'
+
+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']
+
+RESPONSE_THRESHOLD = 5
+
+
+def _MarquesFreemanZiemba2013V1Property(property_name, parent, property_identifier=None):
+    assembly = load_dataset(ASSEMBLY_NAME)
+    similarity_metric = load_metric('ks_similarity', property_name=property_name)
+    ceil_func = NeuronalPropertyCeiling(similarity_metric)
+    
+    if not property_identifier:
+        property_identifier = property_name
+    return PropertiesBenchmark(identifier=f'Marques2020_FreemanZiemba2013-{property_identifier}', assembly=assembly,
+                               neuronal_property=freemanziemba2013_properties, similarity_metric=similarity_metric,
+                               timebins=TIMEBINS,
+                               parent=parent, ceiling_func=ceil_func, bibtex=BIBTEX, version=1)
+
+
+def MarquesFreemanZiemba2013V1TextureModulationIndex():
+    property_name = 'texture_modulation_index'
+    parent = PARENT_TEXTURE_MODULATION
+    return _MarquesFreemanZiemba2013V1Property(property_name=property_name, parent=parent)
+
+
+def MarquesFreemanZiemba2013V1AbsoluteTextureModulationIndex():
+    property_name = 'absolute_texture_modulation_index'
+    property_identifier = 'abs_texture_modulation_index'
+    parent = PARENT_TEXTURE_MODULATION
+    return _MarquesFreemanZiemba2013V1Property(property_name=property_name, parent=parent, property_identifier=property_identifier)
+
+
+def MarquesFreemanZiemba2013V1TextureSelectivity():
+    property_name = 'texture_selectivity'
+    parent = PARENT_SELECTIVITY
+    return _MarquesFreemanZiemba2013V1Property(property_name=property_name, parent=parent)
+
+
+def MarquesFreemanZiemba2013V1TextureSparseness():
+    property_name = 'texture_sparseness'
+    parent = PARENT_SELECTIVITY
+    return _MarquesFreemanZiemba2013V1Property(property_name=property_name, parent=parent)
+
+
+def MarquesFreemanZiemba2013V1VarianceRatio():
+    property_name = 'variance_ratio'
+    property_identifier = 'texture_variance_ratio'
+    parent = PARENT_SELECTIVITY
+    return _MarquesFreemanZiemba2013V1Property(property_name=property_name, parent=parent, property_identifier=property_identifier)
+
+
+def MarquesFreemanZiemba2013V1MaxTexture():
+    property_name = 'max_texture'
+    parent = PARENT_MAGNITUDE
+    return _MarquesFreemanZiemba2013V1Property(property_name=property_name, parent=parent)
+
+
+def MarquesFreemanZiemba2013V1MaxNoise():
+    property_name = 'max_noise'
+    parent = PARENT_MAGNITUDE
+    return _MarquesFreemanZiemba2013V1Property(property_name=property_name, parent=parent)
+
+
+@store(identifier_ignore=['responses', 'baseline'])
+def freemanziemba2013_properties(model_identifier, responses, baseline):
+    _assert_texture_activations(responses)
+    responses = responses.sortby(['type', 'family', 'sample'])
+    type = np.array(sorted(set(responses.type.values)))
+    family = np.array(sorted(set(responses.family.values)))
+    sample = np.array(sorted(set(responses.sample.values)))
+
+    responses = responses.values
+    baseline = baseline.values
+    assert responses.shape[0] == baseline.shape[0]
+    n_neuroids = responses.shape[0]
+
+    responses = responses.reshape(n_neuroids, len(type), len(family), len(sample))
+    responses_spikes = responses / 10
+    responses_spikes = np.sqrt(responses_spikes) + np.sqrt(responses_spikes + 1)
+    responses -= baseline.reshape((-1, 1, 1, 1))
+
+    max_texture = np.max((responses.reshape((n_neuroids, 2, -1)))[:, 1, :], axis=1, keepdims=True)
+    max_noise = np.max((responses.reshape((n_neuroids, 2, -1)))[:, 0, :], axis=1, keepdims=True)
+    max_response = np.max(responses.reshape((n_neuroids, -1)), axis=1, keepdims=True)
+
+    responses_family = responses.mean(axis=3)
+
+    texture_modulation_index = np.zeros((n_neuroids, 1))
+    texture_selectivity = np.zeros((n_neuroids, 1))
+    noise_selectivity = np.zeros((n_neuroids, 1))
+    texture_sparseness = np.zeros((n_neuroids, 1))
+    noise_sparseness = np.zeros((n_neuroids, 1))
+    variance_ratio = np.zeros((n_neuroids, 1))
+    sample_variance = np.zeros((n_neuroids, 1))
+    family_variance = np.zeros((n_neuroids, 1))
+
+    for neur in range(n_neuroids):
+        texture_modulation_index[neur] = calc_texture_modulation(responses_family[neur])[0]
+        texture_selectivity[neur] = calc_sparseness(responses_family[neur, 1])
+        noise_selectivity[neur] = calc_sparseness(responses_family[neur, 0])
+        texture_sparseness[neur] = calc_sparseness(responses[neur, 1])
+        noise_sparseness[neur] = calc_sparseness(responses[neur, 0])
+        variance_ratio[neur], sample_variance[neur], family_variance[neur] = \
+            calc_variance_ratio(responses_spikes[neur, 1])
+
+    absolute_texture_modulation_index = np.abs(texture_modulation_index)
+
+    properties_data = 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)
+
+    good_neuroids = max_response > RESPONSE_THRESHOLD
+    properties_data = properties_data[np.argwhere(good_neuroids)[:, 0], :]
+
+    properties_data = DataAssembly(properties_data, coords={'neuroid_id': ('neuroid', range(properties_data.shape[0])),
+                                                            'region': ('neuroid', ['V1'] * properties_data.shape[0]),
+                                                            'neuronal_property': PROPERTY_NAMES},
+                                   dims=['neuroid', 'neuronal_property'])
+    return properties_data

brainscore_vision/benchmarks/marques2020/benchmarks/ringach2002_benchmark.py

@@ -0,0 +1,167 @@
+import numpy as np
+from result_caching import store
+
+from brainio.assemblies import DataAssembly
+from brainscore_vision import load_dataset, load_metric
+from brainscore_vision.benchmark_helpers.properties_common import PropertiesBenchmark, _assert_grating_activations
+from brainscore_vision.benchmark_helpers.properties_common import calc_circular_variance, calc_bandwidth, \
+    calc_orthogonal_preferred_ratio
+from brainscore_vision.metrics.distribution_similarity import NeuronalPropertyCeiling
+
+ASSEMBLY_NAME = 'Ringach2002'
+REGION = 'V1'
+TIMEBINS = [(70, 170)]
+PARENT_ORIENTATION = 'V1-orientation'
+PARENT_MAGNITUDE = 'V1-response_magnitude'
+PARENT_SELECTIVITY = 'V1-response_selectivity'
+
+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']
+
+BIBTEX = """@article{Ringach2002,
+            author = {Ringach, Dario L and Shapley, Robert M and Hawken, Michael J},
+            doi = {20026567},
+            issn = {1529-2401},
+            journal = {The Journal of Neuroscience},
+            number = {13},
+            pages = {5639--5651},
+            pmid = {12097515},
+            title = {{Orientation selectivity in macaque V1: diversity and laminar dependence.}},
+            volume = {22},
+            year = {2002}
+            }"""
+
+RESPONSE_THRESHOLD = 5
+
+
+def _MarquesRingach2002V1Property(property_name, parent, property_identifier=None):
+    assembly = load_dataset(ASSEMBLY_NAME)
+    similarity_metric = load_metric('ks_similarity', property_name=property_name)
+    ceil_func = NeuronalPropertyCeiling(similarity_metric)
+    
+    if not property_identifier:
+        property_identifier = property_name
+    return PropertiesBenchmark(identifier=f'Marques2020_Ringach2002-{property_identifier}', assembly=assembly,
+                               neuronal_property=ringach2002_properties, similarity_metric=similarity_metric,
+                               timebins=TIMEBINS,
+                               parent=parent, ceiling_func=ceil_func, bibtex=BIBTEX, version=1)
+
+
+def MarquesRingach2002V1CircularVariance():
+    property_name = 'circular_variance'
+    parent = PARENT_ORIENTATION
+    return _MarquesRingach2002V1Property(property_name=property_name, parent=parent)
+
+
+def MarquesRingach2002V1Bandwidth():
+    property_name = 'bandwidth'
+    property_identifier = 'or_bandwidth'
+    parent = PARENT_ORIENTATION
+    return _MarquesRingach2002V1Property(property_name=property_name, parent=parent, property_identifier=property_identifier)
+
+
+def MarquesRingach2002V1OrthogonalPreferredRatio():
+    property_name = 'orthogonal_preferred_ratio'
+    property_identifier = 'orth_pref_ratio'
+    parent = PARENT_ORIENTATION
+    return _MarquesRingach2002V1Property(property_name=property_name, parent=parent, property_identifier=property_identifier)
+
+
+def MarquesRingach2002V1OrientationSelective():
+    property_name = 'orientation_selective'
+    property_identifier = 'or_selective'
+    parent = PARENT_ORIENTATION
+    return _MarquesRingach2002V1Property(property_name=property_name, parent=parent, property_identifier=property_identifier)
+
+
+def MarquesRingach2002V1CircularVarianceBandwidthRatio():
+    property_name = 'circular_variance_bandwidth_ratio'
+    property_identifier = 'cv_bandwidth_ratio'
+    parent = PARENT_ORIENTATION
+    return _MarquesRingach2002V1Property(property_name=property_name, parent=parent, property_identifier=property_identifier)
+
+
+def MarquesRingach2002V1OrthogonalPrefferredRatioCircularVarianceDifference():
+    property_name = 'orthogonal_preferred_ratio_circular_variance_difference'
+    property_identifier = 'opr_cv_diff'
+    parent = PARENT_ORIENTATION
+    return _MarquesRingach2002V1Property(property_name=property_name, parent=parent, property_identifier=property_identifier)
+
+
+def MarquesRingach2002V1MaxDC():
+    property_name = 'max_dc'
+    parent = PARENT_MAGNITUDE
+    return _MarquesRingach2002V1Property(property_name=property_name, parent=parent)
+
+
+def MarquesRingach2002V1ModulationRatio():
+    property_name = 'modulation_ratio'
+    parent = PARENT_SELECTIVITY
+    return _MarquesRingach2002V1Property(property_name=property_name, parent=parent)
+
+
+@store(identifier_ignore=['responses', 'baseline'])
+def ringach2002_properties(model_identifier, responses, baseline):
+    _assert_grating_activations(responses)
+    spatial_frequency = np.array(sorted(set(responses.spatial_frequency.values)))
+    orientation = np.array(sorted(set(responses.orientation.values)))
+    phase = np.array(sorted(set(responses.phase.values)))
+    nStim = responses.values.shape[1]
+    n_cycles = nStim // (len(phase) * len(orientation) * len(spatial_frequency))
+
+    responses = responses.values
+    baseline = baseline.values
+    assert responses.shape[0] == baseline.shape[0]
+    n_neuroids = responses.shape[0]
+
+    responses = responses.reshape((n_neuroids, n_cycles, len(spatial_frequency), len(orientation), len(phase)))
+    responses_dc = responses.mean(axis=4)
+    responses_ac = np.absolute(np.fft.fft(responses)) / len(phase)
+    responses_ac = responses_ac[:, :, :, :, 1] * 2
+    del responses
+
+    max_dc = np.zeros((n_neuroids, 1))
+    max_ac = np.zeros((n_neuroids, 1))
+    min_dc = np.zeros((n_neuroids, 1))
+    circular_variance = np.zeros((n_neuroids, 1))
+    bandwidth = np.zeros((n_neuroids, 1))
+    orthogonal_preferred_ratio = np.zeros((n_neuroids, 1))
+    orientation_selective = np.ones((n_neuroids, 1))
+
+    for neur in range(n_neuroids):
+        pref_cycle, pref_spatial_frequency, pref_orientation = np.unravel_index(np.argmax(responses_dc[neur]),
+                                                                                (n_cycles, len(spatial_frequency),
+                                                                                 len(orientation)))
+
+        max_dc[neur] = responses_dc[neur, pref_cycle, pref_spatial_frequency, pref_orientation]
+        max_ac[neur] = responses_ac[neur, pref_cycle, pref_spatial_frequency, pref_orientation]
+
+        orientation_curve = responses_dc[neur, pref_cycle, pref_spatial_frequency, :]
+        min_dc[neur] = orientation_curve.min()
+
+        circular_variance[neur] = calc_circular_variance(orientation_curve, orientation)
+        bandwidth[neur] = \
+            calc_bandwidth(orientation_curve, orientation, filt_type='hanning', thrsh=0.707, mode='half')[0]
+        orthogonal_preferred_ratio[neur] = calc_orthogonal_preferred_ratio(orientation_curve, orientation)
+
+    orientation_selective[np.isnan(bandwidth)] = 0
+    modulation_ratio = max_ac / max_dc
+    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
+
+    properties_data = 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)
+
+    good_neuroids = max_dc > baseline + RESPONSE_THRESHOLD
+    properties_data = properties_data[np.argwhere(good_neuroids)[:, 0], :]
+
+    properties_data = DataAssembly(properties_data, coords={'neuroid_id': ('neuroid', range(properties_data.shape[0])),
+                                                            'region': ('neuroid', ['V1'] * properties_data.shape[0]),
+                                                            'neuronal_property': PROPERTY_NAMES},
+                                   dims=['neuroid', 'neuronal_property'])
+    return properties_data

brainscore_vision/benchmarks/marques2020/benchmarks/schiller1976_benchmark.py

@@ -0,0 +1,100 @@
+import numpy as np
+from result_caching import store
+
+from brainio.assemblies import DataAssembly
+from brainscore_vision import load_metric, load_dataset
+from brainscore_vision.benchmark_helpers.properties_common import PropertiesBenchmark, _assert_grating_activations
+from brainscore_vision.benchmark_helpers.properties_common import calc_spatial_frequency_tuning
+from brainscore_vision.metrics.distribution_similarity import NeuronalPropertyCeiling
+
+ASSEMBLY_NAME = 'Schiller1976c'
+REGION = 'V1'
+TIMEBINS = [(70, 170)]
+PARENT = 'V1-spatial_frequency'
+
+PROPERTY_NAMES = ['spatial_frequency_selective', 'spatial_frequency_bandwidth']
+
+BIBTEX = """@article{Schiller1976,
+            author = {Schiller, P. H. and Finlay, B. L. and Volman, S. F.},
+            doi = {10.1152/jn.1976.39.6.1352},
+            issn = {0022-3077},
+            journal = {Journal of neurophysiology},
+            number = {6},
+            pages = {1334--1351},
+            pmid = {825624},
+            title = {{Quantitative studies of single-cell properties in monkey striate cortex. III. Spatial Frequency}},
+            url = {http://www.ncbi.nlm.nih.gov/pubmed/825624},
+            volume = {39},
+            year = {1976}
+            }
+            """
+
+RESPONSE_THRESHOLD = 5
+
+
+def _MarquesSchiller1976V1Property(property_name):
+    assembly = load_dataset(ASSEMBLY_NAME)
+    similarity_metric = load_metric('ks_similarity', property_name=property_name)
+    ceil_func = NeuronalPropertyCeiling(similarity_metric)
+    parent = PARENT
+    property_identifier = property_name.replace("spatial_frequency", "sf")
+    return PropertiesBenchmark(identifier=f'Marques2020_Schiller1976-{property_identifier}', assembly=assembly,
+                               neuronal_property=schiller1976_properties, similarity_metric=similarity_metric,
+                               timebins=TIMEBINS,
+                               parent=parent, ceiling_func=ceil_func, bibtex=BIBTEX, version=1)
+
+
+def MarquesSchiller1976V1SpatialFrequencySelective():
+    property_name = 'spatial_frequency_selective'
+    return _MarquesSchiller1976V1Property(property_name=property_name)
+
+
+def MarquesSchiller1976V1SpatialFrequencyBandwidth():
+    property_name = 'spatial_frequency_bandwidth'
+    return _MarquesSchiller1976V1Property(property_name=property_name)
+
+
+@store(identifier_ignore=['responses', 'baseline'])
+def schiller1976_properties(model_identifier, responses, baseline):
+    _assert_grating_activations(responses)
+    radius = np.array(sorted(set(responses.radius.values)))
+    spatial_frequency = np.array(sorted(set(responses.spatial_frequency.values)))
+    orientation = np.array(sorted(set(responses.orientation.values)))
+    phase = np.array(sorted(set(responses.phase.values)))
+
+    responses = responses.values
+    baseline = baseline.values
+    assert responses.shape[0] == baseline.shape[0]
+    n_neuroids = responses.shape[0]
+
+    responses = responses.reshape((n_neuroids, len(radius), len(spatial_frequency), len(orientation), len(phase)))
+    responses = responses.mean(axis=4)
+
+    max_response = responses.reshape((n_neuroids, -1)).max(axis=1, keepdims=True)
+
+    spatial_frequency_bandwidth = np.zeros((n_neuroids, 1))
+    spatial_frequency_selective = np.ones((n_neuroids, 1))
+
+    for neur in range(n_neuroids):
+        pref_radius, pref_spatial_frequency, pref_orientation = \
+            np.unravel_index(np.argmax(responses[neur, :, :, :]),
+                             (len(radius), len(spatial_frequency), len(orientation)))
+
+        spatial_frequency_curve = responses[neur, pref_radius, :, pref_orientation]
+
+        spatial_frequency_bandwidth[neur] = \
+            calc_spatial_frequency_tuning(spatial_frequency_curve, spatial_frequency, thrsh=0.707, filt_type='smooth',
+                                          mode='ratio')[0]
+
+    spatial_frequency_selective[np.isnan(spatial_frequency_bandwidth)] = 0
+
+    properties_data = np.concatenate((spatial_frequency_selective, spatial_frequency_bandwidth), axis=1)
+
+    good_neuroids = max_response > baseline + RESPONSE_THRESHOLD
+    properties_data = properties_data[np.argwhere(good_neuroids)[:, 0], :]
+
+    properties_data = DataAssembly(properties_data, coords={'neuroid_id': ('neuroid', range(properties_data.shape[0])),
+                                                            'region': ('neuroid', ['V1'] * properties_data.shape[0]),
+                                                            'neuronal_property': PROPERTY_NAMES},
+                                   dims=['neuroid', 'neuronal_property'])
+    return properties_data

brainscore_vision/benchmarks/marques2020/test.py

@@ -0,0 +1,135 @@
+import pytest
+from pytest import approx
+
+from brainscore_vision import benchmark_registry
+from brainscore_vision.benchmark_helpers.test_helper import StandardizedTests, PrecomputedTests, NumberOfTrialsTests
+
+standardized_tests = StandardizedTests()
+precomputed_test = PrecomputedTests()
+num_trials_test = NumberOfTrialsTests()
+
+
+@pytest.mark.parametrize('benchmark', [
+    'Marques2020_Cavanaugh2002-grating_summation_field',
+    'Marques2020_Cavanaugh2002-surround_diameter',
+    'Marques2020_Cavanaugh2002-surround_suppression_index',
+    'Marques2020_DeValois1982-pref_or',
+    'Marques2020_DeValois1982-peak_sf',
+    'Marques2020_FreemanZiemba2013-texture_sparseness',
+    'Marques2020_FreemanZiemba2013-texture_selectivity',
+    'Marques2020_FreemanZiemba2013-texture_variance_ratio',
+    'Marques2020_FreemanZiemba2013-texture_modulation_index',
+    'Marques2020_FreemanZiemba2013-abs_texture_modulation_index',
+    'Marques2020_FreemanZiemba2013-max_noise',
+    'Marques2020_FreemanZiemba2013-max_texture',
+    'Marques2020_Ringach2002-or_bandwidth',
+    'Marques2020_Ringach2002-or_selective',
+    'Marques2020_Ringach2002-circular_variance',
+    'Marques2020_Ringach2002-orth_pref_ratio',
+    'Marques2020_Ringach2002-cv_bandwidth_ratio',
+    'Marques2020_Ringach2002-opr_cv_diff',
+    'Marques2020_Ringach2002-modulation_ratio',
+    'Marques2020_Ringach2002-max_dc',
+    'Marques2020_Schiller1976-sf_bandwidth',
+    'Marques2020_Schiller1976-sf_selective',
+])
+def test_benchmark_registry(benchmark):
+    assert benchmark in benchmark_registry
+
+
+@pytest.mark.private_access
+@pytest.mark.parametrize('benchmark, expected', [
+    ('Marques2020_Cavanaugh2002-grating_summation_field', approx(0.956, abs=.005)),
+    ('Marques2020_Cavanaugh2002-surround_diameter', approx(0.955, abs=.005)),
+    ('Marques2020_Cavanaugh2002-surround_suppression_index', approx(0.958, abs=.005)),
+    ('Marques2020_DeValois1982-pref_or', approx(0.962, abs=.005)),
+    ('Marques2020_DeValois1982-peak_sf', approx(0.967, abs=.005)),
+    ('Marques2020_FreemanZiemba2013-texture_modulation_index', approx(0.948, abs=.005)),
+    ('Marques2020_FreemanZiemba2013-abs_texture_modulation_index', approx(0.958, abs=.005)),
+    ('Marques2020_FreemanZiemba2013-texture_selectivity', approx(0.940, abs=.005)),
+    ('Marques2020_FreemanZiemba2013-texture_sparseness', approx(0.935, abs=.005)),
+    ('Marques2020_FreemanZiemba2013-texture_variance_ratio', approx(0.939, abs=.005)),
+    ('Marques2020_FreemanZiemba2013-max_texture', approx(0.946, abs=.005)),
+    ('Marques2020_FreemanZiemba2013-max_noise', approx(0.945, abs=.005)),
+    ('Marques2020_Ringach2002-circular_variance', approx(0.959, abs=.005)),
+    ('Marques2020_Ringach2002-or_bandwidth', approx(0.964, abs=.005)),
+    ('Marques2020_Ringach2002-orth_pref_ratio', approx(0.962, abs=.005)),
+    ('Marques2020_Ringach2002-or_selective', approx(0.994, abs=.005)),
+    ('Marques2020_Ringach2002-cv_bandwidth_ratio', approx(0.968, abs=.005)),
+    ('Marques2020_Ringach2002-opr_cv_diff', approx(0.967, abs=.005)),
+    ('Marques2020_Ringach2002-modulation_ratio', approx(0.959, abs=.005)),
+    ('Marques2020_Ringach2002-max_dc', approx(0.968, abs=.005)),
+    ('Marques2020_Schiller1976-sf_selective', approx(0.963, abs=.005)),
+    ('Marques2020_Schiller1976-sf_bandwidth', approx(0.933, abs=.005)),
+])
+def test_ceilings(benchmark, expected):
+    standardized_tests.ceilings_test(benchmark, expected)
+
+
+@pytest.mark.private_access
+@pytest.mark.memory_intense
+@pytest.mark.slow
+@pytest.mark.parametrize('benchmark, expected', [
+    ('Marques2020_Cavanaugh2002-grating_summation_field', approx(.599, abs=.01)),
+    ('Marques2020_Cavanaugh2002-surround_diameter', approx(.367, abs=.01)),
+    ('Marques2020_Cavanaugh2002-surround_suppression_index', approx(.365, abs=.01)),
+    ('Marques2020_DeValois1982-pref_or', approx(.895, abs=.01)),
+    ('Marques2020_DeValois1982-peak_sf', approx(.775, abs=.01)),
+    ('Marques2020_FreemanZiemba2013-texture_modulation_index', approx(.636, abs=.01)),
+    ('Marques2020_FreemanZiemba2013-abs_texture_modulation_index', approx(.861, abs=.01)),
+    ('Marques2020_FreemanZiemba2013-texture_selectivity', approx(.646, abs=.01)),
+    ('Marques2020_FreemanZiemba2013-texture_sparseness', approx(.508, abs=.01)),
+    ('Marques2020_FreemanZiemba2013-texture_variance_ratio', approx(.827, abs=.01)),
+    ('Marques2020_FreemanZiemba2013-max_texture', approx(.823, abs=.01)),
+    ('Marques2020_FreemanZiemba2013-max_noise', approx(.684, abs=.01)),
+    ('Marques2020_Ringach2002-circular_variance', approx(.830, abs=.01)),
+    ('Marques2020_Ringach2002-or_bandwidth', approx(.844, abs=.01)),
+    ('Marques2020_Ringach2002-orth_pref_ratio', approx(.876, abs=.01)),
+    ('Marques2020_Ringach2002-or_selective', approx(.895, abs=.01)),
+    ('Marques2020_Ringach2002-cv_bandwidth_ratio', approx(.841, abs=.01)),
+    ('Marques2020_Ringach2002-opr_cv_diff', approx(.909, abs=.01)),
+    ('Marques2020_Ringach2002-modulation_ratio', approx(.371, abs=.01)),
+    ('Marques2020_Ringach2002-max_dc', approx(.904, abs=.01)),
+    ('Marques2020_Schiller1976-sf_selective', approx(.808, abs=.01)),
+    ('Marques2020_Schiller1976-sf_bandwidth', approx(.869, abs=.01)),
+])
+def test_Marques2020(benchmark, expected):
+    precomputed_test.run_test_properties(
+        benchmark=benchmark,
+        files={'Marques2020_blank': 'alexnet-dicarlo.Marques2020_blank.nc',
+               'Marques2020_receptive_field': 'alexnet-dicarlo.Marques2020_receptive_field.nc',
+               'Marques2020_orientation': 'alexnet-dicarlo.Marques2020_orientation.nc',
+               'Marques2020_spatial_frequency': 'alexnet-dicarlo.Marques2020_spatial_frequency.nc',
+               'Marques2020_size': 'alexnet-dicarlo.Marques2020_size.nc',
+               'FreemanZiemba2013_properties': 'alexnet-movshon.FreemanZiemba2013_properties.nc',
+               },
+        expected=expected)
+
+
+@pytest.mark.private_access
+@pytest.mark.parametrize('benchmark_identifier', [
+    'Marques2020_Cavanaugh2002-grating_summation_field',
+    'Marques2020_Cavanaugh2002-surround_diameter',
+    'Marques2020_Cavanaugh2002-surround_suppression_index',
+    'Marques2020_DeValois1982-pref_or',
+    'Marques2020_DeValois1982-peak_sf',
+    'Marques2020_FreemanZiemba2013-texture_sparseness',
+    'Marques2020_FreemanZiemba2013-texture_selectivity',
+    'Marques2020_FreemanZiemba2013-texture_variance_ratio',
+    'Marques2020_FreemanZiemba2013-texture_modulation_index',
+    'Marques2020_FreemanZiemba2013-abs_texture_modulation_index',
+    'Marques2020_FreemanZiemba2013-max_noise',
+    'Marques2020_FreemanZiemba2013-max_texture',
+    'Marques2020_Ringach2002-or_bandwidth',
+    'Marques2020_Ringach2002-or_selective',
+    'Marques2020_Ringach2002-circular_variance',
+    'Marques2020_Ringach2002-orth_pref_ratio',
+    'Marques2020_Ringach2002-cv_bandwidth_ratio',
+    'Marques2020_Ringach2002-opr_cv_diff',
+    'Marques2020_Ringach2002-modulation_ratio',
+    'Marques2020_Ringach2002-max_dc',
+    'Marques2020_Schiller1976-sf_bandwidth',
+    'Marques2020_Schiller1976-sf_selective',
+])
+def test_repetitions(benchmark_identifier):
+    num_trials_test.repetitions_test(benchmark_identifier)

brainscore_vision/benchmarks/objectnet/__init__.py

@@ -0,0 +1,4 @@
+from brainscore_vision import benchmark_registry
+from .benchmark import Objectnet
+
+benchmark_registry['ObjectNet-top1'] = Objectnet

brainscore_vision/benchmarks/objectnet/benchmark.py

@@ -0,0 +1,52 @@
+import logging
+
+from brainscore_core import Score
+from brainscore_vision import load_stimulus_set, load_metric
+from brainscore_vision.benchmarks import BenchmarkBase
+from brainscore_vision.model_interface import BrainModel
+
+BIBTEX = """@inproceedings{DBLP:conf/nips/BarbuMALWGTK19,
+                author    = {Andrei Barbu and
+                            David Mayo and
+                            Julian Alverio and
+                            William Luo and
+                            Christopher Wang and
+                            Dan Gutfreund and
+                            Josh Tenenbaum and
+                            Boris Katz},
+                title     = {ObjectNet: {A} large-scale bias-controlled dataset for pushing the
+                            limits of object recognition models},
+                booktitle = {NeurIPS 2019},
+                pages     = {9448--9458},
+                year      = {2019},
+                url       = {https://proceedings.neurips.cc/paper/2019/hash/97af07a14cacba681feacf3012730892-Abstract.html},
+                }"""
+
+NUMBER_OF_TRIALS = 10
+
+_logger = logging.getLogger(__name__)
+
+
+class Objectnet(BenchmarkBase):
+    def __init__(self):
+        self._stimulus_set = load_stimulus_set('BarbuMayo2019')
+        self._similarity_metric = load_metric('accuracy')
+        ceiling = Score(1)
+
+        super(Objectnet, self).__init__(identifier='BarbuMayo2019-top1', version=1,
+                                        ceiling_func=lambda: ceiling,
+                                        parent='engineering',
+                                        bibtex=BIBTEX)
+
+    def __call__(self, candidate):
+        # The proper `fitting_stimuli` to pass to the candidate would be the imagenet training set.
+        # For now, since almost all models in our hands were trained with imagenet, we'll just short-cut this
+        # by telling the candidate to use its pre-trained imagenet weights.
+        candidate.start_task(BrainModel.Task.label, 'imagenet')
+        stimulus_set = self._stimulus_set[list(set(self._stimulus_set.columns) - {'synset'})]  # do not show label
+        predictions = candidate.look_at(stimulus_set, number_of_trials=NUMBER_OF_TRIALS)
+        score = self._similarity_metric(
+            predictions.sortby('filename'),
+            self._stimulus_set.sort_values('filename')['synset'].values
+        )
+        return score

brainscore_vision/benchmarks/objectnet/test.py

@@ -0,0 +1,33 @@
+import numpy as np
+import pytest
+
+from brainio.assemblies import BehavioralAssembly
+from brainscore_vision.benchmarks.objectnet import Objectnet
+from brainscore_vision.model_interface import BrainModel
+
+
+@pytest.mark.private_access
+class TestObjectnet:
+    def test_groundtruth(self):
+        benchmark = Objectnet()
+        source = benchmark._stimulus_set
+
+        class GroundTruth(BrainModel):
+            def start_task(self, task, fitting_stimuli):
+                assert task == BrainModel.Task.label
+                assert fitting_stimuli == 'imagenet'  # shortcut
+
+            def look_at(self, stimuli, number_of_trials=1):
+                source_image_ids = source['stimulus_id'].values
+                stimuli_image_ids = stimuli['stimulus_id'].values
+                sorted_x = source_image_ids[np.argsort(source_image_ids)]
+                sorted_index = np.searchsorted(sorted_x, stimuli_image_ids)
+                aligned_source = source.loc[sorted_index]
+                labels = aligned_source['synset'].values
+                return BehavioralAssembly([labels], coords={
+                    **{column: ('presentation', aligned_source[column].values) for column in aligned_source.columns},
+                    **{'choice': ('choice', ['dummy'])}}, dims=['choice', 'presentation'])
+
+        candidate = GroundTruth()
+        score = benchmark(candidate)
+        assert score == pytest.approx(1)

brainscore_vision/benchmarks/rajalingham2018/__init__.py

@@ -0,0 +1,10 @@
+from brainscore_vision import benchmark_registry
+from .benchmarks.benchmark import DicarloRajalingham2018I2n
+
+benchmark_registry['Rajalingham2018-i2n'] = DicarloRajalingham2018I2n
+
+
+# public benchmark
+from.benchmarks.public_benchmark import RajalinghamMatchtosamplePublicBenchmark
+
+benchmark_registry['Rajalingham2018public-i2n'] = RajalinghamMatchtosamplePublicBenchmark