OSCR

Investigating the temporal dynamics and modeling of mid-level feature representations in humans.

Code ↔ Paper

21 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 21 matches
  1. [1] § Materials and Methods › EEG recording and preprocessing ↔ EEG/Preprocessing/preprocessing_eeg.py, lines 398–457 · score 0.89 · notch filter, low pass filtering, baseline corrected, epochs starting, MNE, raw
  2. [2] § Materials and Methods › Encoding › Predicting CNN activations from ground-truth annotations ↔ CNN/Encoding/encoding_cnn.py, lines 32–111 · score 0.74 · ridge regression models, explained variance, weighted correlations, CNN activations, predicted, layers
  3. [3] § Materials and Methods › Encoding › Predicting CNN activations from ground-truth annotations ↔ CNN/Encoding/hyperparameter_optimization_cnn.py, lines 30–101 · score 0.74 · ridge regression models, explained variance, weighted correlations, CNN activations, layers, mid
  4. [4] § Materials and Methods › Encoding › Extracting and preparing the CNN activations ↔ CNN/Activation_extraction_and_prep/activation_extraction_cnn_images.py, lines 32–74 · score 0.70 · pre trained, preprocessed images, extracted activations, Places365, crop, layers
  5. [5] § Materials and Methods › Stimuli and ground-truth annotations ↔ EEG/Encoding/annotation_prep_videos.py, lines 33–97 · score 0.69 · openCV, skeleton position, action identity, meta, Canny, engine
  6. [6] § Materials and Methods › Stimuli and ground-truth annotations ↔ EEG/Encoding/annotation_prep_images.py, lines 33–95 · score 0.66 · openCV, skeleton position, action identity, Canny, engine, matrix
  7. [7] § Materials and Methods › Encoding › Extracting and preparing the CNN activations ↔ CNN/Activation_extraction_and_prep/activation_extraction_cnn_videos.py, lines 127–167 · score 0.62 · flattened activations, feature map, extracted CNN, dimensions, layer, training
  8. [8] § Materials and Methods › EEG recording and preprocessing ↔ EEG/Encoding/mvnn_encoding.py, lines 24–70 · score 0.62 · Ledoit Wolf, covariance matrix, MVNN, channels, preprocessing, EEG
  9. [9] § Materials and Methods › Encoding › Preparing the ground-truth annotations ↔ EEG/Encoding/annotation_prep_images.py, lines 33–95 · score 0.62 · skeleton position, Action identity, scene depth, kernel, fitted, linear
  10. [10] § Materials and Methods › Encoding › Preparing the ground-truth annotations ↔ EEG/Encoding/annotation_prep_videos.py, lines 33–97 · score 0.62 · skeleton position, Action identity, scene depth, kernel, fitted, linear
  11. [11] § Materials and Methods › Encoding › EEG noise ceiling ↔ EEG/Encoding/noise_ceiling.py, lines 15–58 · score 0.61 · noise ceiling, lower bound, preprocessed, channel, EEG, encoding
  12. [12] § Materials and Methods › Encoding › Extracting and preparing the CNN activations ↔ CNN/Activation_extraction_and_prep/activation_extraction_cnn_videos.py, lines 31–72 · score 0.61 · pre trained, extracted activations, PyTorch, preprocessed, layers, CNN
  13. [13] § Materials and Methods › EEG recording and preprocessing ↔ EEG/Decoding/decoding.py, lines 97–135 · score 0.60 · Ledoit Wolf, covariance matrix, MVNN, channels, EEG
  14. [14] § Materials and Methods › Decoding ↔ EEG/Decoding/decoding.py, lines 309–359 · score 0.57 · cross validation, stratified, fold, SVM, split, decoding
  15. [15] § Results › Candidate mid-level features are most strongly encoded in the brain between ~100 and ~250 ms after stimulus onset ↔ Controls/control_analysis_3/encoding_c3.py, lines 31–96 · score 0.57 · predicted EEG, skeleton position, action identity, scene depth, edges, trained
  16. [16] § Results › Candidate mid-level features are most strongly encoded in the brain between ~100 and ~250 ms after stimulus onset ↔ Controls/control_analysis_3/hyperparameter_optimization_c3.py, lines 31–104 · score 0.56 · predicted EEG, skeleton position, action identity, scene depth, edges, trained
  17. [17] § Materials and Methods › Encoding › Extracting and preparing the CNN activations ↔ CNN/Activation_extraction_and_prep/activation_extraction_cnn_images.py, lines 32–74 · score 0.56 · pre trained, extracted activations, crop, preprocessed, frame, layers
  18. [18] § Materials and Methods › Encoding › Predicting the EEG responses from ground-truth annotations ↔ CNN/Encoding/hyperparameter_optimization_cnn.py, lines 30–101 · score 0.54 · ridge regression models, strength, hyperparameter, variance, weights, mid
  19. [19] § Materials and Methods › Encoding › Correlation between EEG peak latencies and CNN peak layers ↔ CNN/Plotting/eeg_vs_cnn_corr_peak_latencies.py, lines 583–640 · score 0.53 · EEG peak latencies, peak layers, Spearman, correlated, CNNs
  20. [20] § Materials and Methods › Statistical analysis ↔ CNN/Plotting/eeg_vs_cnn_corr_peak_latencies.py, lines 692–757 · score 0.53 · EEG peak latencies, CNN peak, shuffled, correlation, layer
  21. [21] § Materials and Methods › Encoding ↔ CNN/Encoding/encoding_cnn.py, lines 32–111 · score 0.52 · ridge regression, CNN activations, networks, models, predict, correlating

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 294 lines · 9.3 KB · MIT · 2 matches

  1. #!/usr/bin/env python3
  2. # -*- coding: utf-8 -*-
  3. """
  4. ENCODING - DEEP NETS
  6. This script implements the multivariate linear ridge regression for the unit
  7. activations in deep nets.
  9. @author: Alexander Lenders, Agnessa Karapetian
  10. """
  11. import os
  12. import numpy as np
  13. import torch
  14. import pickle
  15. import argparse
  16. from utils import load_activation, load_alpha
  18. import sys
  19. from pathlib import Path
  21. project_root = Path(__file__).resolve().parents[2]
  22. sys.path.append(str(project_root))
  24. from EEG.Encoding.utils import (
  25. load_config,
  26. load_features,
  27. OLS_pytorch,
  28. vectorized_correlation,
  29. )
  32. def encoding(
  33. input_type: str,
  34. feat_dir: str,
  35. cnn_dir: str,
  36. save_dir: str,
  37. frame: int,
  38. alpha_tp: bool = False,
  39. ):
  40. """
  41. Performs encoding using ridge regression to predict unit activations in deep neural networks
  42. (e.g., ResNet) from mid-level features extracted from images or video clips. For each feature
  43. and each specified layer, fits a regression model to predict activations, evaluates performance
  44. metrics (RMSE, correlation, weighted correlation), and saves results.
  46. Input:
  47. ----------
  48. Feature and activation directories containing precomputed features and CNN activations for
  49. images or video clips. Features are loaded from .pkl files, and activations are loaded per layer.
  50. The function supports both weighted and unweighted regression based on explained variance.
  52. Returns:
  53. ----------
  54. Saves a dictionary of regression results for each feature in a .pkl file in the specified
  55. save directory. The results include RMSE scores, correlation scores, weighted correlations,
  56. and their averages for each layer.
  58. Parameters
  59. ----------
  60. input_type : str
  61. Type of input data ("images" or "miniclips").
  62. feat_dir : str
  63. Directory containing feature .pkl files.
  64. cnn_dir : str
  65. Directory containing CNN activations and explained variance files.
  66. save_dir : str
  67. Directory to save regression results.
  68. frame : int
  69. Frame index for selecting image features (used if input_type is "images").
  70. alpha_tp : bool, optional
  71. If True, loads alpha hyperparameter per layer; otherwise loads a single alpha per feature (default: True).
  72. """
  73. # -------------------------------------------------------------------------
  74. # STEP 1 Define Variables
  75. # -------------------------------------------------------------------------
  76. layers_names = (
  77. "layer1.0.relu_1",
  78. "layer1.1.relu_1",
  79. "layer2.0.relu_1",
  80. "layer2.1.relu_1",
  81. "layer3.0.relu_1",
  82. "layer3.1.relu_1",
  83. "layer4.0.relu_1",
  84. "layer4.1.relu_1",
  85. )
  86. feature_names = (
  87. "edges",
  88. "world_normal",
  89. "lighting",
  90. "scene_depth",
  91. "reflectance",
  92. "action",
  93. "skeleton",
  94. )
  96. if input_type == "images":
  97. featuresDir = os.path.join(
  98. feat_dir,
  99. f"img_features_frame_{frame}_redone_{len(feature_names)}_features_onehot.pkl",
  100. )
  101. elif input_type == "miniclips":
  102. featuresDir = os.path.join(
  103. feat_dir,
  104. f"video_features_avg_frame_redone_{len(feature_names)}.pkl",
  105. )
  107. explained_var_dir = os.path.join(cnn_dir, "pca")
  108. save_dir = os.path.join(save_dir, input_type)
  109. act_dir = os.path.join(cnn_dir, "prepared")
  111. features_dict = dict.fromkeys(feature_names)
  113. # Device agnostic code: Use gpu if possible, otherwise cpu
  114. device = "cuda" if torch.cuda.is_available() else "cpu"
  115. print(f"Using device: {device}")
  117. # -------------------------------------------------------------------------
  118. # STEP 2 Loop over all features and save best alpha hyperparameter
  119. # -------------------------------------------------------------------------
  120. output_names = (
  121. "rmse_score",
  122. "correlation",
  123. "rmse_average",
  124. "correlation_average",
  125. "weighted_correlation",
  126. )
  128. # define matrix where to save the values
  129. regression_features = dict.fromkeys(feature_names)
  131. num_layers = len(layers_names)
  133. for feature in features_dict.keys():
  134. X_train, _, X_test = load_features(feature, featuresDir)
  136. if explained_var_dir:
  137. alpha_dir_final = os.path.join(save_dir, "weighted")
  138. else:
  139. alpha_dir_final = os.path.join(save_dir, "unweighted")
  141. if alpha_tp is False:
  142. alpha = load_alpha(feature=feature, feat_dir=alpha_dir_final)
  144. output = dict.fromkeys(output_names)
  146. rmse_scores = {}
  147. corr_scores = {}
  148. weighted_corr_scores = {}
  150. for tp, l in enumerate(layers_names):
  151. if alpha_tp is True:
  152. alpha = load_alpha(feature, alpha_dir_final, tp)
  154. y_train_tp = load_activation("training", l, act_dir)
  155. y_test_tp = load_activation("test", l, act_dir)
  157. regression = OLS_pytorch(alpha=alpha)
  158. try:
  159. regression.fit(X_train, y_train_tp, solver="cholesky")
  160. except Exception as error:
  161. print("Attention. Cholesky solver did not work: ", error)
  162. print("Trying the standard linalg.solver...")
  163. regression.fit(X_train, y_train_tp, solver="solve")
  164. prediction = regression.predict(X_test)
  165. rmse_score = regression.score(entry=X_test, y=y_test_tp)
  166. correlation = vectorized_correlation(prediction, y_test_tp)
  168. rmse_scores[l] = rmse_score
  169. corr_scores[l] = correlation
  171. if explained_var_dir:
  172. # Load the explained variance for the current layer
  173. explained_var_layer = os.path.join(
  174. explained_var_dir, l, "explained_variance.pkl"
  175. )
  177. with open(explained_var_layer, "rb") as file:
  178. explained_var = pickle.load(file)
  180. explained_var = np.array(explained_var["explained_variance"])
  181. total_variance = np.sum(explained_var)
  183. # Weighted correlation
  184. weighted_corr_scores[l] = (
  185. correlation * explained_var / total_variance
  186. )
  188. if explained_var_dir:
  189. rmse_avg_chan = np.zeros((num_layers))
  190. corr_avg_chan = np.zeros((num_layers))
  192. for i, layer in enumerate(layers_names):
  194. explained_var_dir_layer = os.path.join(
  195. explained_var_dir, layer, "explained_variance.pkl"
  196. )
  198. with open(explained_var_dir_layer, "rb") as file:
  199. explained_var = pickle.load(file)
  201. explained_var = np.array(explained_var["explained_variance"])
  202. total_variance = np.sum(explained_var)
  204. rmse_it = rmse_scores[layer]
  205. corr_it = corr_scores[layer]
  207. rmse_avg_chan[i] = (
  208. np.sum(rmse_it * explained_var) / total_variance
  209. )
  210. corr_avg_chan[i] = (
  211. np.sum(corr_it * explained_var) / total_variance
  212. )
  214. output["rmse_score"] = rmse_scores
  215. output["correlation"] = corr_scores
  216. output["rmse_average"] = rmse_avg_chan
  217. output["correlation_average"] = corr_avg_chan
  218. output["weighted_correlation"] = weighted_corr_scores
  220. regression_features[feature] = output
  222. # -------------------------------------------------------------------------
  223. # STEP 3 Save results
  224. # -------------------------------------------------------------------------
  225. # Save the dictionary
  226. fileDir = "encoding_layers_resnet.pkl"
  228. if explained_var_dir:
  229. resultsDir = os.path.join(save_dir, "weighted")
  230. else:
  231. resultsDir = os.path.join(save_dir, "unweighted")
  233. if not os.path.exists(resultsDir):
  234. os.makedirs(resultsDir)
  236. savefileDir = os.path.join(resultsDir, fileDir)
  238. with open(savefileDir, "wb") as f:
  239. pickle.dump(regression_features, f)
  241. return regression_features
  244. if __name__ == "__main__":
  245. parser = argparse.ArgumentParser()
  247. # add arguments / inputs
  248. parser.add_argument(
  249. "--config_dir",
  250. type=str,
  251. help="Directory to the configuration file.",
  252. required=True,
  253. )
  254. parser.add_argument(
  255. "--config",
  256. type=str,
  257. help="Configuration.",
  258. required=True,
  259. )
  260. parser.add_argument(
  261. "--input_type",
  262. default="images",
  263. type=str,
  264. help="Images or miniclips",
  265. required=True,
  266. )
  268. args = parser.parse_args() # to get values for the arguments
  270. config = load_config(args.config_dir, args.config)
  272. args = parser.parse_args()
  274. input_type = args.input_type
  275. frame = config.getint(args.config, "img_frame")
  276. save_dir = config.get(args.config, "save_dir_cnn")
  278. # Hardcoded for now
  279. if args.config == "control_12":
  280. ALPHA_PER_TP = True
  281. print("Using alpha per timepoint for control_12")
  282. else:
  283. ALPHA_PER_TP = False
  285. if input_type == "images":
  286. feat_dir = config.get(args.config, "save_dir_feat_img")
  287. cnn_dir = config.get(args.config, "save_dir_cnn_img")
  288. else:
  289. feat_dir = config.get(args.config, "save_dir_feat_video")
  290. cnn_dir = config.get(args.config, "save_dir_cnn_video")
  292. encoding(
  293. input_type, feat_dir, cnn_dir, save_dir, frame, alpha_tp=ALPHA_PER_TP
  294. )

encoding_cnn.py at commit d069bb4, under MIT · at the source

Overview

Authors: Agnessa Karapetian1,2,3, Alexander Lenders1, Vanshika Bawa4, Martin Pflaum5, Raphael Leuner6, Gemma Roig7, Kshitij Dwivedi7, Radoslaw M Cichy1,2,3,8
ORCID iDs: Agnessa Karapetian, Gemma Roig, Radoslaw M Cichy
  1. Department of Education and Psychology, Freie Universität Berlin, Berlin, Germany
  2. Charité – Universitätsmedizin Berlin, Einstein Center for Neurosciences Berlin, Berlin, Germany
  3. Bernstein Centre for Computational Neuroscience Berlin, Berlin, Germany
  4. Faculty of Biology, Albert-Ludwigs-Universität Freiburg, Freiburg, Germany
  5. Fraunhofer Institute for Laser Technology ILT, Aachen, Germany
  6. Department of Mathematics and Computer Science, Freie Universität Berlin, Berlin, Germany
  7. Department of Computer Science, Goethe Universität Frankfurt, Frankfurt am Main, Germany
  8. Berlin School of Mind and Brain, Faculty of Philosophy, Humboldt-Universität zu Berlin, Berlin, Germany
Institutions: Bernstein Center for Computational Neuroscience Berlin (Germany); Einstein Center for Neurosciences Berlin (Germany); Freie Universität Berlin (Germany); Charité - Universitätsmedizin Berlin (Germany); University of Freiburg (Germany); Fraunhofer Institute for Laser Technology (Germany); Goethe University Frankfurt (Germany); Humboldt-Universität zu Berlin (Germany)
Journal: Imaging neuroscience (Cambridge, Mass.), volume 4, article IMAG.a.1207
Dates: received 17 March 2025; accepted 20 March 2026; published online 27 April 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1162/imag.a.1207 · PMID 42065116 · PMCID PMC13125056 · OpenAlex W7140851929
Open access: diamond, a free copy (OpenAlex)
Status: code verified
Categories: EEG (modality), human (organism), cognitive (subfield)
Methods: Preprocessing, Connectivity, Statistics, Smoothing, state filtering, decompositions, Machine learning, Evoked potentials, Physiology & signal measures
Keywords: mid-level features, visual perception, scene processing, encoding, EEG, CNN
Topic: Face Recognition and Perception (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: European Research Council (803370)
Citations: not cited yet (Europe PMC); 72 references in the paper

Abstract

Visual perception unfolds through a hierarchy of transformations, beginning with the extraction of low-level features, such as edges, and culminating in the representation of high-level features such as object categories. While the processing of low- and high-level features is well studied, the intermediate transformations, that is, mid-level features, remain poorly understood. Here, we introduce a stimulus set of naturalistic 3D-rendered images and videos with ground-truth annotations for five candidate mid-level features (reflectance, scene depth, world normals, lighting, and skeleton position) alongside for one low-level feature (edges) and for one high-level feature (action identity). To determine when these features are processed in the brain, we collected electroencephalography (EEG) responses during stimulus presentation and trained linearized encoding models to predict EEG responses from the annotations. We first showed that candidate mid-level features were best represented between ~100 and 250 ms post-stimulus, between low- and high-level features, and consistent with a bridging role linking sensory and semantic processing. We then assessed convolutional neural networks (CNNs) as models of mid-level feature processing in humans and observed that although their hierarchies were shallower, they exhibited a comparable processing order for mid-level but not low- or high-level features, only for videos. Together, our results support the view that mid-level features are tied to surface- and shape-related processing and establish 3D-rendered stimuli with annotations as a valuable tool for investigating mid-level vision in biological and artificial neural networks.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repository

Its files are read in the Code ↔ Paper reader above, with 21 matches between paragraphs and lines of code.

Agnessa14/Mid-level-features

License: MIT
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: d069bb4b3e5eef22d9487fc0e6fedf485b778322, 19 February 2026
Languages: Shell (64), Python (62)
Size: 130 files, 126 scripts
Software Heritage: not archived
Found in: “Data and Code Availability”
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (48 files), SciPy (23 files), PyTorch (14 files), Matplotlib (13 files), statsmodels (11 files), pandas (6 files), scikit-learn (6 files), PyTorch Lightning (4 files), seaborn (3 files), Pillow (2 files), MNE-Python (1 file), OpenCV (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
128 files
At the source: github.com/Agnessa14/Mid-level-features

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 126 scripts, each with its path and the digest of its content;
  • 21 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

Datasets cited

Data and Code Availability

The neural data, stimuli, and ground-truth annotations are uploaded on https://osf.io/7c9bz/. The code used for this project is under https://github.com/Agnessa14/Mid-level-features.

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 30 September 2026: the first record

Recorded: type, language, journal, volume, pages, dates, 8 authors, 6 keywords, 1 funder, 69 references.

Cite

This paper

Karapetian, A., Lenders, A., Bawa, V., Pflaum, M., Leuner, R., Roig, G., Dwivedi, K., & Cichy, R. M. (2026). Investigating the temporal dynamics and modeling of mid-level feature representations in humans. Imaging neuroscience (Cambridge, Mass.), 4, IMAG.a.1207. https://doi.org/10.1162/imag.a.1207

BibTeX

@article{karapetian2026investigating,
author = {Karapetian, Agnessa and Lenders, Alexander and Bawa, Vanshika and Pflaum, Martin and Leuner, Raphael and Roig, Gemma and Dwivedi, Kshitij and Cichy, Radoslaw M},
title = {{Investigating the temporal dynamics and modeling of mid-level feature representations in humans}},
journal = {Imaging neuroscience (Cambridge, Mass.)},
year = {2026},
month = apr,
volume = {4},
pages = {IMAG.a.1207},
publisher = {MIT Press},
issn = {2837-6056},
doi = {10.1162/imag.a.1207},
url = {https://doi.org/10.1162/imag.a.1207},
pmid = {42065116},
pmcid = {PMC13125056}
}

RIS

TY - JOUR
AU - Karapetian, Agnessa
AU - Lenders, Alexander
AU - Bawa, Vanshika
AU - Pflaum, Martin
AU - Leuner, Raphael
AU - Roig, Gemma
AU - Dwivedi, Kshitij
AU - Cichy, Radoslaw M
TI - Investigating the temporal dynamics and modeling of mid-level feature representations in humans
T2 - Imaging neuroscience (Cambridge, Mass.)
J2 - Imaging Neurosci (Camb)
PY - 2026
DA - 2026/04/27
VL - 4
SP - IMAG.a.1207
SN - 2837-6056
PB - MIT Press
DO - 10.1162/imag.a.1207
UR - https://doi.org/10.1162/imag.a.1207
LA - en
ER -

CSL-JSON

{
"id": "10.1162/imag.a.1207",
"type": "article-journal",
"title": "Investigating the temporal dynamics and modeling of mid-level feature representations in humans",
"container-title": "Imaging neuroscience (Cambridge, Mass.)",
"author": [
{
"family": "Karapetian",
"given": "Agnessa"
},
{
"family": "Lenders",
"given": "Alexander"
},
{
"family": "Bawa",
"given": "Vanshika"
},
{
"family": "Pflaum",
"given": "Martin"
},
{
"family": "Leuner",
"given": "Raphael"
},
{
"family": "Roig",
"given": "Gemma"
},
{
"family": "Dwivedi",
"given": "Kshitij"
},
{
"family": "Cichy",
"given": "Radoslaw M"
}
],
"container-title-short": "Imaging Neurosci (Camb)",
"volume": "4",
"page": "IMAG.a.1207",
"DOI": "10.1162/imag.a.1207",
"PMID": "42065116",
"PMCID": "PMC13125056",
"ISSN": "2837-6056",
"publisher": "MIT Press",
"URL": "https://doi.org/10.1162/imag.a.1207",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
27
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1038/s42003-026-10169-0 [code]
Shared representations in brains and models reveal a two-route cortical organization during scene perception.
Journal: Communications biology
In common: Pillow, statsmodels, PyTorch, 6 other tools, cognitive, 8 references
[2] doi:10.1038/s42003-026-10843-3 [code]
Self-supervised learning yields representational signatures of category-selective cortex.
Journal: Communications biology
In common: 9 references, author Radoslaw Cichy
[3] doi:10.1093/cercor/bhag075 [code]
Cortical dynamics of icon perception: effects of concreteness and attractiveness.
Journal: Cerebral cortex (New York, N.Y. : 1991)
In common: MNE-Python, Pillow, statsmodels, 5 other tools, cognitive, 7 references
[4] doi:10.1167/jov.26.8.4 [code]
The neural processes of illusory occlusion in object recognition.
Journal: Journal of vision
In common: MNE-Python, seaborn, scikit-learn, 4 other tools, EEG, cognitive, 8 references
[5] doi:10.1523/eneuro.0344-25.2026 [code]
Long-Term Variability in Visual Processing versus Perceptual Stability.
Journal: eNeuro
In common: MNE-Python, statsmodels, seaborn, 5 other tools, cognitive, 7 references
[6] doi:10.1038/s41597-025-05174-7 [code]
A large-scale MEG and EEG dataset for object recognition in naturalistic scenes
Journal: n/a
In common: MNE-Python, OpenCV, Pillow, 7 other tools, EEG, 4 references
[7] doi:10.1038/s41467-026-76098-y [code]
A single computational objective can produce specialization of streams in visual cortex.
Journal: Nature communications
In common: Pillow, statsmodels, PyTorch, 6 other tools, 5 references
[8] doi:10.1523/jneurosci.0038-26.2026 [code]
Multidimensional Feature Tuning in Category Selective Areas of Human Visual Cortex.
Journal: The Journal of neuroscience : the official journal of the Society for Neuroscience
In common: Pillow, statsmodels, PyTorch, 6 other tools, 3 references
[9] doi:10.1167/jov.26.8.1 [code]
MAME: Multidimensional adaptive metamer exploration with human perceptual feedback.
Journal: Journal of vision
In common: OpenCV, Pillow, PyTorch, 5 other tools, cognitive, 3 references
[10] doi:10.1038/s41593-026-02207-1 [code]
Neuronal tuning aligns dynamically with object and texture manifolds across the visual hierarchy.
Journal: Nature neuroscience
In common: Pillow, statsmodels, PyTorch, 6 other tools, 3 references

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.