brainscore-vision 2.1__py3-none-any.whl

brainscore_vision/benchmarks/maniquet2024/benchmark.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Jun 21 23:15:17 2024
+
+@author: costantino_ai
+"""
+from brainscore_core import Score
+from brainscore_vision.benchmarks import BenchmarkBase
+from brainscore_vision.benchmark_helpers.screen import place_on_screen
+from brainscore_vision.model_interface import BrainModel
+from brainscore_vision import load_stimulus_set, load_metric, load_dataset
+from brainscore_vision.utils import LazyLoad
+
+BIBTEX = """@article {Maniquet2024.04.02.587669,
+	author = {Maniquet, Tim and de Beeck, Hans Op and Costantino, Andrea Ivan},
+	title = {Recurrent issues with deep neural network models of visual recognition},
+	elocation-id = {2024.04.02.587669},
+	year = {2024},
+	doi = {10.1101/2024.04.02.587669},
+	publisher = {Cold Spring Harbor Laboratory},
+	URL = {https://www.biorxiv.org/content/early/2024/04/10/2024.04.02.587669},
+	eprint = {https://www.biorxiv.org/content/early/2024/04/10/2024.04.02.587669.full.pdf},
+	journal = {bioRxiv}
+}"""
+
+
+class _Maniquet2024ConfusionSimilarity(BenchmarkBase):
+    """
+    A benchmark class to measure the similarity between model-generated confusion probabilities
+    and human confusion data in visual tasks, specifically designed for the Maniquet2024 dataset.
+
+    Attributes:
+        _metric (ConfusionSimilarity): The metric used to compare model outputs with human data.
+        _fitting_stimuli (StimulusSet): Stimulus set used for training or fitting the model.
+        _stimulus_set (StimulusSet): Stimulus set used for testing the model.
+        _human_assembly (DataAssembly): Human behavioral data for comparison.
+        _visual_degrees (int): The size of stimuli in visual degrees as presented to humans.
+        _number_of_trials (int): Number of trials to average over for the model predictions.
+    """
+
+    def __init__(self):
+        """
+        Initializes the benchmark by setting up the necessary parameters.
+        """
+        # Initialize the metric for evaluating confusion similarity
+        self._metric = load_metric('confusion_similarity')
+
+        # Load training stimuli from the stimulus set registry
+        self._fitting_stimuli = load_stimulus_set('Maniquet2024-train')
+
+        # Load testing stimuli from the stimulus set registry
+        self._stimulus_set = load_stimulus_set('Maniquet2024-test')
+
+        # Load human behavioral data from the data registry
+        self._human_assembly = load_dataset('Maniquet2024')
+
+        # Set the visual degrees to which the human data was exposed
+        self._visual_degrees = 8
+
+        # Set the number of trials to perform
+        self._number_of_trials = 1
+
+        # Call the parent class constructor to complete initialization
+        super(_Maniquet2024ConfusionSimilarity, self).__init__(
+            identifier="Maniquet2024-confusion_similarity'",
+            version=1,
+            ceiling_func=lambda: Score(0.53526),  # use pre-computed from `self._metric._ceiling(self._human_assembly)`
+            parent="Maniquet2024",
+            bibtex=BIBTEX,
+        )
+
+    def __call__(self, candidate: BrainModel):
+        """
+        Executes the benchmark by comparing the candidate model's confusion probabilities against human data.
+
+        Args:
+            candidate (BrainModel): The model being evaluated.
+
+        Returns:
+            float: The similarity score between the model and human data.
+        """
+        # Start the model on the task of predicting confusion probabilities
+        fitting_stimuli = place_on_screen(self._fitting_stimuli,
+                                          target_visual_degrees=candidate.visual_degrees(),
+                                          source_visual_degrees=self._visual_degrees)
+        candidate.start_task(BrainModel.Task.probabilities, fitting_stimuli)
+
+        # Prepare the stimulus set by placing it on a virtual screen at a scale appropriate for the model
+        stimulus_set = place_on_screen(self._stimulus_set,
+                                       target_visual_degrees=candidate.visual_degrees(),
+                                       source_visual_degrees=self._visual_degrees)
+
+        # Model looks at the stimulus set and returns confusion probabilities
+        probabilities = candidate.look_at(stimulus_set, number_of_trials=self._number_of_trials)
+
+        # Compute the confusion similarity score between model probabilities and human assembly data
+        raw_score = self._metric(probabilities, self._human_assembly)
+        # Normalize by ceiling
+        ceiling = self.ceiling
+        score = raw_score / ceiling
+        score.attrs["raw"] = raw_score
+        score.attrs["ceiling"] = ceiling
+        return score
+
+
+class _Maniquet2024TasksConsistency(BenchmarkBase):
+    """
+    A benchmarking class designed to evaluate the consistency of the human accuracy profiles across
+    all tasks with the model's accuracy profiles across the same tasks.
+
+    Attributes:
+        _metric (TasksConsistency): The metric for evaluating task consistency between the model and human data.
+        _fitting_stimuli (StimulusSet): The set of stimuli used for model training or calibration.
+        _stimulus_set (StimulusSet): The set of stimuli used for testing the model's predictions.
+        _human_assembly (DataAssembly): The dataset containing human response data for comparison.
+        _visual_degrees (int): The visual size of the stimuli as perceived by human subjects.
+        _number_of_trials (int): The number of trials over which model predictions are averaged.
+    """
+
+    def __init__(self):
+        """
+        Initializes the benchmark setup, including loading necessary datasets, defining the metric, and setting
+        up the parameters for the evaluation.
+        """
+        # Metric for evaluating the consistency of task performance
+        self._metric = load_metric('tasks_consistency')
+
+        # Load training stimuli from the stimulus set registry
+        self._fitting_stimuli = load_stimulus_set('Maniquet2024-train')
+
+        # Load testing stimuli from the stimulus set registry
+        self._stimulus_set = load_stimulus_set('Maniquet2024-test')
+
+        # Load human behavioral data from the data registry
+        self._human_assembly = load_dataset('Maniquet2024')
+
+        # Set the visual context to match human study conditions
+        self._visual_degrees = 8
+
+        # Define the number of trials for model evaluation
+        self._number_of_trials = 1
+
+        # Initialize parent class with benchmark-specific metadata
+        super(_Maniquet2024TasksConsistency, self).__init__(
+            identifier="Maniquet2024-tasks_consistency",
+            version=1,
+            ceiling_func=lambda: Score(0.99810),  # use pre-computed from `self._metric.ceiling(self._human_assembly)`
+            parent="Maniquet2024",
+            bibtex=BIBTEX,
+        )
+
+    def __call__(self, candidate: BrainModel):
+        """
+        Executes the benchmark by comparing the candidate model's task performance probabilities
+        against human data, and returns a similarity score.
+
+        Args:
+            candidate (BrainModel): The neural model being evaluated.
+
+        Returns:
+            float: A similarity score indicating how closely the model's responses match human responses.
+        """
+        # Task the model with generating predictions based on the fitting stimuli
+        fitting_stimuli = place_on_screen(
+            self._fitting_stimuli,
+            target_visual_degrees=candidate.visual_degrees(),
+            source_visual_degrees=self._visual_degrees,
+        )
+        candidate.start_task(BrainModel.Task.probabilities, fitting_stimuli)
+
+        # Adjust the stimulus presentation to match the model's expected input scale
+        stimulus_set = place_on_screen(
+            self._stimulus_set,
+            target_visual_degrees=candidate.visual_degrees(),
+            source_visual_degrees=self._visual_degrees,
+        )
+
+        # Obtain the model's predictions as confusion probabilities
+        probabilities = candidate.look_at(
+            stimulus_set, number_of_trials=self._number_of_trials
+        )
+
+        # Evaluate the consistency of model predictions with human data
+        raw_score = self._metric(probabilities, self._human_assembly)
+        # Normalize by ceiling
+        ceiling = self.ceiling
+        score = raw_score / ceiling
+        score.attrs["raw"] = raw_score
+        score.attrs["ceiling"] = ceiling
+        return score
+
+
+def Maniquet2024ConfusionSimilarity():
+    return _Maniquet2024ConfusionSimilarity()
+
+
+def Maniquet2024TasksConsistency():
+    return _Maniquet2024TasksConsistency()

brainscore_vision/benchmarks/maniquet2024/test.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Jun 24 17:22:59 2024
+
+@author: costantino_ai
+"""
+
+import pytest
+from brainscore_vision import load_benchmark
+
+@pytest.mark.parametrize('benchmark', [
+    'Maniquet2024-confusion_similarity',
+    'Maniquet2024-tasks_consistency',
+])
+def test_benchmark_registry(benchmark):
+    assert load_benchmark(benchmark) is not None

brainscore_vision/benchmarks/marques2020/__init__.py

@@ -0,0 +1,76 @@
+from brainscore_vision import benchmark_registry
+from .benchmarks.cavanaugh2002a_benchmark import MarquesCavanaugh2002V1SurroundSuppressionIndex, \
+    MarquesCavanaugh2002V1GratingSummationField, MarquesCavanaugh2002V1SurroundDiameter
+
+benchmark_registry['Marques2020_Cavanaugh2002-grating_summation_field'] = \
+    MarquesCavanaugh2002V1GratingSummationField
+benchmark_registry['Marques2020_Cavanaugh2002-surround_diameter'] = \
+    MarquesCavanaugh2002V1SurroundDiameter
+benchmark_registry['Marques2020_Cavanaugh2002-surround_suppression_index'] = \
+    MarquesCavanaugh2002V1SurroundSuppressionIndex
+
+
+from .benchmarks.devalois1982a_benchmark import MarquesDeValois1982V1PreferredOrientation
+
+benchmark_registry['Marques2020_DeValois1982-pref_or'] = \
+    MarquesDeValois1982V1PreferredOrientation
+
+
+from .benchmarks.devalois1982b_benchmark import MarquesDeValois1982V1PeakSpatialFrequency
+
+benchmark_registry['Marques2020_DeValois1982-peak_sf'] = \
+    MarquesDeValois1982V1PeakSpatialFrequency
+
+
+from .benchmarks.freemanZiemba2013_benchmark import MarquesFreemanZiemba2013V1TextureModulationIndex, \
+    MarquesFreemanZiemba2013V1AbsoluteTextureModulationIndex, MarquesFreemanZiemba2013V1TextureSelectivity, \
+    MarquesFreemanZiemba2013V1TextureSparseness, MarquesFreemanZiemba2013V1VarianceRatio, \
+    MarquesFreemanZiemba2013V1MaxTexture, MarquesFreemanZiemba2013V1MaxNoise
+
+# V1 properties benchmarks: texture modulation
+benchmark_registry['Marques2020_FreemanZiemba2013-texture_modulation_index'] = \
+    MarquesFreemanZiemba2013V1TextureModulationIndex
+benchmark_registry['Marques2020_FreemanZiemba2013-abs_texture_modulation_index'] = \
+    MarquesFreemanZiemba2013V1AbsoluteTextureModulationIndex
+
+# V1 properties benchmarks: selectivity
+benchmark_registry['Marques2020_FreemanZiemba2013-texture_selectivity'] = \
+    MarquesFreemanZiemba2013V1TextureSelectivity
+benchmark_registry['Marques2020_FreemanZiemba2013-texture_sparseness'] = \
+    MarquesFreemanZiemba2013V1TextureSparseness
+benchmark_registry['Marques2020_FreemanZiemba2013-texture_variance_ratio'] = \
+    MarquesFreemanZiemba2013V1VarianceRatio
+
+# V1 properties benchmarks: magnitude
+benchmark_registry['Marques2020_FreemanZiemba2013-max_texture'] = MarquesFreemanZiemba2013V1MaxTexture
+benchmark_registry['Marques2020_FreemanZiemba2013-max_noise'] = MarquesFreemanZiemba2013V1MaxNoise
+
+
+from .benchmarks.ringach2002_benchmark import MarquesRingach2002V1CircularVariance, MarquesRingach2002V1Bandwidth, \
+        MarquesRingach2002V1OrthogonalPreferredRatio, MarquesRingach2002V1OrientationSelective, \
+        MarquesRingach2002V1CircularVarianceBandwidthRatio, \
+        MarquesRingach2002V1OrthogonalPrefferredRatioCircularVarianceDifference, MarquesRingach2002V1MaxDC, \
+        MarquesRingach2002V1ModulationRatio
+
+# V1 properties benchmarks: orientation
+benchmark_registry['Marques2020_Ringach2002-circular_variance'] = MarquesRingach2002V1CircularVariance
+benchmark_registry['Marques2020_Ringach2002-or_bandwidth'] = MarquesRingach2002V1Bandwidth
+benchmark_registry['Marques2020_Ringach2002-orth_pref_ratio'] = MarquesRingach2002V1OrthogonalPreferredRatio
+benchmark_registry['Marques2020_Ringach2002-or_selective'] = MarquesRingach2002V1OrientationSelective
+benchmark_registry['Marques2020_Ringach2002-cv_bandwidth_ratio'] = \
+        MarquesRingach2002V1CircularVarianceBandwidthRatio
+benchmark_registry['Marques2020_Ringach2002-opr_cv_diff'] = \
+        MarquesRingach2002V1OrthogonalPrefferredRatioCircularVarianceDifference
+
+# V1 properties benchmarks: magnitude
+benchmark_registry['Marques2020_Ringach2002-max_dc'] = MarquesRingach2002V1MaxDC
+benchmark_registry['Marques2020_Ringach2002-modulation_ratio'] = MarquesRingach2002V1ModulationRatio
+
+
+from .benchmarks.schiller1976_benchmark import MarquesSchiller1976V1SpatialFrequencyBandwidth, \
+        MarquesSchiller1976V1SpatialFrequencySelective
+
+# V1 properties benchmarks: spatial frequency
+benchmark_registry['Marques2020_Schiller1976-sf_selective'] = MarquesSchiller1976V1SpatialFrequencySelective
+benchmark_registry['Marques2020_Schiller1976-sf_bandwidth'] = MarquesSchiller1976V1SpatialFrequencyBandwidth
+

brainscore_vision/benchmarks/marques2020/benchmarks/cavanaugh2002a_benchmark.py

@@ -0,0 +1,119 @@
+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, \
+    calc_size_tuning
+from brainscore_vision.metrics.distribution_similarity import NeuronalPropertyCeiling
+
+ASSEMBLY_NAME = 'Cavanaugh2002a'
+REGION = 'V1'
+TIMEBINS = [(70, 170)]
+PARENT_SURROUND = 'V1-surround_modulation'
+PARENT_RECEPTIVE_FIELD = 'V1-receptive_field_size'
+
+PROPERTY_NAMES = ['surround_suppression_index', 'strongly_suppressed', 'grating_summation_field', 'surround_diameter',
+                  'surround_grating_summation_field_ratio']
+
+BIBTEX = """@article{Cavanaugh2002,
+            author = {Cavanaugh, James R. and Bair, Wyeth and Movshon, J. A.},
+            doi = {10.1152/jn.00692.2001},
+            isbn = {0022-3077 (Print) 0022-3077 (Linking)},
+            issn = {0022-3077},
+            journal = {Journal of Neurophysiology},
+            mendeley-groups = {Benchmark effects/Done,Benchmark effects/*Surround Suppression},
+            number = {5},
+            pages = {2530--2546},
+            pmid = {12424292},
+            title = {{Nature and Interaction of Signals From the Receptive Field Center and Surround in Macaque V1 Neurons}},
+            url = {http://www.physiology.org/doi/10.1152/jn.00692.2001},
+            volume = {88},
+            year = {2002}
+            }
+            """
+
+RESPONSE_THRESHOLD = 5
+
+
+def _MarquesCavanaugh2002V1Property(property_name, parent):
+    assembly = load_dataset(ASSEMBLY_NAME)
+    similarity_metric = load_metric('ks_similarity', property_name=property_name)
+    ceil_func = NeuronalPropertyCeiling(similarity_metric)
+    return PropertiesBenchmark(identifier=f'Marques2020_Cavanaugh2002-{property_name}', assembly=assembly,
+                               neuronal_property=cavanaugh2002_properties, similarity_metric=similarity_metric,
+                               timebins=TIMEBINS,
+                               parent=parent, ceiling_func=ceil_func, bibtex=BIBTEX, version=1)
+
+
+def MarquesCavanaugh2002V1SurroundSuppressionIndex():
+    property_name = 'surround_suppression_index'
+    parent = PARENT_SURROUND
+    return _MarquesCavanaugh2002V1Property(property_name=property_name, parent=parent)
+
+
+def MarquesCavanaugh2002V1GratingSummationField():
+    property_name = 'grating_summation_field'
+    parent = PARENT_RECEPTIVE_FIELD
+    return _MarquesCavanaugh2002V1Property(property_name=property_name, parent=parent)
+
+
+def MarquesCavanaugh2002V1SurroundDiameter():
+    property_name = 'surround_diameter'
+    parent = PARENT_RECEPTIVE_FIELD
+    return _MarquesCavanaugh2002V1Property(property_name=property_name, parent=parent)
+
+
+@store(identifier_ignore=['responses', 'baseline'])
+def cavanaugh2002_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_dc = responses.mean(axis=4) - baseline.reshape((-1, 1, 1, 1))
+    responses_ac = np.absolute(np.fft.fft(responses)) / len(phase)
+    responses_ac = responses_ac[:, :, :, :, 1] * 2
+    responses = np.zeros((n_neuroids, len(radius), len(spatial_frequency), len(orientation), 2))
+    responses[:, :, :, :, 0] = responses_dc
+    responses[:, :, :, :, 1] = responses_ac
+    del responses_ac, responses_dc
+
+    max_response = responses.reshape((n_neuroids, -1)).max(axis=1, keepdims=True)
+
+    surround_suppression_index = np.zeros((n_neuroids, 1))
+    strongly_suppressed = np.zeros((n_neuroids, 1))
+    grating_summation_field = np.zeros((n_neuroids, 1))
+    surround_diameter = np.zeros((n_neuroids, 1))
+    surround_grating_summation_field_ratio = np.zeros((n_neuroids, 1))
+
+    for neur in range(n_neuroids):
+        pref_radius, pref_spatial_frequency, pref_orientation, pref_component = \
+            np.unravel_index(np.argmax(responses[neur, :, :, :, :]),
+                             (len(radius), len(spatial_frequency), len(orientation), 2))
+
+        size_curve = responses[neur, :, pref_spatial_frequency, pref_orientation, pref_component]
+
+        grating_summation_field[neur], surround_diameter[neur], surround_grating_summation_field_ratio[neur], \
+            surround_suppression_index[neur] = calc_size_tuning(size_curve, radius)
+
+    strongly_suppressed[surround_suppression_index >= 0.1] = 1
+
+    properties_data = np.concatenate((surround_suppression_index, strongly_suppressed, grating_summation_field,
+                                      surround_diameter, surround_grating_summation_field_ratio), 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/devalois1982a_benchmark.py

@@ -0,0 +1,84 @@
+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_bandwidth
+from brainscore_vision.metrics.distribution_similarity import NeuronalPropertyCeiling
+
+ASSEMBLY_NAME = 'DeValois1982a'
+REGION = 'V1'
+TIMEBINS = [(70, 170)]
+PARENT = 'V1-orientation'
+
+PROPERTY_NAMES = ['preferred_orientation']
+
+BIBTEX = """@article{DeValois1982,
+            author = {{De Valois}, Russell L. and Yund, E. W. and Hepler, Norva},
+            journal = {Vision Research},
+            pages = {531--544},
+            title = {{The orientation and direction selectivity of cells in macaque visual cortex}},
+            volume = {22},
+            year = {1982}
+            }
+            """
+
+RESPONSE_THRESHOLD = 5
+ORIENTATION_BIN_LIM = 157.5
+
+
+def MarquesDeValois1982V1PreferredOrientation():
+    assembly = load_dataset(ASSEMBLY_NAME)
+    property_name = 'preferred_orientation'
+    parent = PARENT
+    similarity_metric = load_metric('ks_similarity', property_name=property_name)
+    ceil_func = NeuronalPropertyCeiling(similarity_metric)
+    return PropertiesBenchmark(identifier=f'Marques2020_DeValois1982-pref_or', assembly=assembly,
+                               neuronal_property=devalois1982a_properties, similarity_metric=similarity_metric,
+                               timebins=TIMEBINS,
+                               parent=parent, ceiling_func=ceil_func, bibtex=BIBTEX, version=1)
+
+
+@store(identifier_ignore=['responses', 'baseline'])
+def devalois1982a_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 = responses.mean(axis=4)
+
+    preferred_orientation = np.zeros((n_neuroids, 1))
+    max_response = responses.reshape((n_neuroids, -1)).max(axis=1, keepdims=True)
+
+    for neur in range(n_neuroids):
+        pref_cycle, pref_spatial_frequency, pref_orientation = np.unravel_index(np.argmax(responses[neur]),
+                                                                                (n_cycles, len(spatial_frequency),
+                                                                                 len(orientation)))
+
+        orientation_curve = responses[neur, pref_cycle, pref_spatial_frequency, :]
+
+        preferred_orientation[neur] = \
+            calc_bandwidth(orientation_curve, orientation, filt_type='smooth', thrsh=0.5, mode='full')[1]
+
+    preferred_orientation[preferred_orientation >= ORIENTATION_BIN_LIM] = \
+        preferred_orientation[preferred_orientation >= ORIENTATION_BIN_LIM] - 180
+    properties_data = preferred_orientation
+
+    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/benchmarks/devalois1982b_benchmark.py

@@ -0,0 +1,88 @@
+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_spatial_frequency_tuning
+from brainscore_vision.metrics.distribution_similarity import NeuronalPropertyCeiling
+
+ASSEMBLY_NAME = 'DeValois1982b'
+REGION = 'V1'
+TIMEBINS = [(70, 170)]
+PARENT = 'V1-spatial_frequency'
+
+PROPERTY_NAMES = ['peak_spatial_frequency']
+
+BIBTEX = """@article{DeValois1982,
+            author = {{De Valois}, Russell L. and Albrecht, Duane G. and Thorell, Lisa G.},
+            journal = {Vision Research},
+            pages = {545--559},
+            title = {{Spatial Frequency Selectivity of Cells in Macaque Visual Cortex}},
+            volume = {22},
+            year = {1982}
+            }
+            """
+
+RESPONSE_THRESHOLD = 5
+
+
+def MarquesDeValois1982V1PeakSpatialFrequency():
+    assembly = load_dataset(ASSEMBLY_NAME)
+    property_name = 'peak_spatial_frequency'
+    parent = PARENT
+    similarity_metric = load_metric('ks_similarity', property_name=property_name)
+    ceil_func = NeuronalPropertyCeiling(similarity_metric)
+    return PropertiesBenchmark(identifier=f'Marques2020_DeValois1982-peak_sf', assembly=assembly,
+                               neuronal_property=devalois1982b_properties, similarity_metric=similarity_metric,
+                               timebins=TIMEBINS,
+                               parent=parent, ceiling_func=ceil_func, bibtex=BIBTEX, version=1)
+
+
+@store(identifier_ignore=['responses', 'baseline'])
+def devalois1982b_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_dc = responses.mean(axis=4) - baseline.reshape((-1, 1, 1, 1))
+    responses_ac = np.absolute(np.fft.fft(responses)) / len(phase)
+    responses_ac = responses_ac[:, :, :, :, 1] * 2
+    responses = np.zeros((n_neuroids, len(radius), len(spatial_frequency), len(orientation), 2))
+    responses[:, :, :, :, 0] = responses_dc
+    responses[:, :, :, :, 1] = responses_ac
+    del responses_ac, responses_dc
+
+    max_response = responses.reshape((n_neuroids, -1)).max(axis=1, keepdims=True)
+
+    peak_spatial_frequency = np.zeros((n_neuroids, 1))
+
+    for neur in range(n_neuroids):
+        pref_radius, pref_spatial_frequency, pref_orientation, pref_component = \
+            np.unravel_index(np.argmax(responses[neur, :, :, :, :]),
+                             (len(radius), len(spatial_frequency), len(orientation), 2))
+
+        spatial_frequency_curve = responses[neur, pref_radius, :, pref_orientation, pref_component]
+
+        peak_spatial_frequency[neur] = \
+            calc_spatial_frequency_tuning(spatial_frequency_curve, spatial_frequency, thrsh=0.707, filt_type='smooth',
+                                          mode='ratio')[1]
+
+    properties_data = peak_spatial_frequency
+
+    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