OSCR

Low-dimensional and optimised representations of high-level information in the expert brain.

Code ↔ Paper

40 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 40 matches · 1 of them tie a paragraph to a whole file, not to given lines: a weak match, whose lines are not tinted
  1. [1] § Methods › Regions of Interest (ROIs) ↔ chess-supplementary/subcortical-rois/01_prepare_atlas.py, lines 1–55 · score 0.93 · volumetric MNI space, CAB NP atlas, glasser hcp, bilateral masks, subcortical structures, parcels
  2. [2] § Results › What is represented: perceptual to relational content › Behavioural representational geometry ↔ chess-supplementary/task-engagement/13_quantify_preference_drivers.py, lines 1–81 · score 0.92 · edge density, image entropy, uniquely predicted, board preferences, explained variance, checkmate status
  3. [3] § Results › Skill-gradient analysis ↔ chess-supplementary/skill-gradient/11_skill_gradient_group.py, lines 1–53 · score 0.88 · chess skill, RSA model fit, neural metrics, Elo rating, move accuracy, fMRI
  4. [4] § Results › Where information is encoded: domain-general networks › Univariate networks involvement › Multivariate representational shift ↔ common/neuro_utils.py, lines 1032–1177 · score 0.87 · temporo parieto occipital, posterior cingulate, superior parietal, dLPFC, right hemisphere, VVS
  5. [5] § Results › Where information is encoded: domain-general networks › Univariate networks involvement › Multivariate representational shift ↔ common/neuro_utils.py, lines 1031–1176 · score 0.87 · temporo parieto occipital, posterior cingulate, superior parietal, dLPFC, right hemisphere, VVS
  6. [6] § Methods › Participation ratio ↔ analyses/manifold/models.py, lines 262–376 · score 0.86 · cross validated accuracy, training fold, logistic regression, Classification accuracy, shuffled, stratified
  7. [7] § Results › Where information is encoded: domain-general networks › Univariate networks involvement ↔ common/neuro_utils.py, lines 1032–1177 · score 0.84 · temporo parieto occipital, posterior cingulate, superior parietal, dLPFC, VVS, PCC
  8. [8] § Results › Where information is encoded: domain-general networks › Univariate networks involvement ↔ common/neuro_utils.py, lines 1031–1176 · score 0.84 · temporo parieto occipital, posterior cingulate, superior parietal, dLPFC, VVS, PCC
  9. [9] § Results › What is represented: perceptual to relational content › Neural representational geometry ↔ chess-supplementary/rsa-rois/81_table_rsa_rois.py, lines 1–78 · score 0.80 · scipy.stats.ttest_ind, theoretical model RDMs, equal_var, Benjamini Hochberg, neural RDMs, confidence intervals
  10. [10] § Results › What is represented: perceptual to relational content › Neural representational geometry ↔ chess-supplementary/mvpa-finer/81_table_mvpa_finer_rsa.py, lines 1–79 · score 0.79 · scipy.stats.ttest_ind, theoretical model RDMs, equal_var, Benjamini Hochberg, neural RDMs, confidence intervals
  11. [11] § Methods › Representational similarity analysis (RSA) › Behavioural representational similarity analysis ↔ chess-behavioral/81_table_behavioral_correlations.py, lines 1–63 · score 0.77 · correlation coefficient, Benjamini Hochberg, discovery rate, behavioural RDM, confidence intervals, model RDM
  12. [12] § Methods › Meta-analytic correlation analysis › RSA maps preparation ↔ chess-neurosynth/12_rsa_neurosynth.py, lines 200–274 · score 0.77 · general linear model, correlation maps, RSA model, arctanh, intercept, Fisher
  13. [13] § Methods › Meta-analytic correlation analysis › Neurosynth term maps ↔ common/constants.py, lines 207–264 · score 0.77 · Memory retrieval, language network, fine grained, Working memory, Navigation, configurations
  14. [14] § Results › How representations are structured: compressed geometry › Participant classification based on dimensionality profiles ↔ chess-manifold/91_plot_manifold_panels.py, lines 1–58 · score 0.76 · ROI PR matrix, logistic regression, decision boundary, PCA projection, ROI space, Heatmap
  15. [15] § Results › How representations are structured: compressed geometry › Participant classification based on dimensionality profiles ↔ chess-manifold/91_plot_manifold_panels.py, lines 1–58 · score 0.76 · ROI PR matrix, logistic regression, decision boundary, PCA projection, ROI space, Heatmap
  16. [16] § Methods › Representational similarity analysis (RSA) › Behavioural representational similarity analysis ↔ common/rsa_utils.py, lines 81–151 · score 0.76 · lower triangles, correlation coefficient, Pearson correlations, confidence intervals, behavioural RDM, model RDM
  17. [17] § Results › What is represented: perceptual to relational content › Behavioural representational geometry ↔ chess-behavioral/81_table_behavioral_correlations.py, lines 1–63 · score 0.75 · behavioural Representational Dissimilari, Benjamini Hochberg, checkmate status, behavioural RSA, behavioural RDM, confidence intervals
  18. [18] § Methods › Participation ratio ↔ chess-supplementary/run-matching/11_pr_run_matched.py, lines 64–149 · score 0.72 · permuted, exceeding, shuffled, recomputed, stratified, logistic
  19. [19] § Results › What is represented: perceptual to relational content › Behavioural representational geometry ↔ chess-behavioral/91_plot_behavioral_panels.py, lines 1–59 · score 0.71 · Expert directional preference, MDS embedding, selection frequencies, behavioural RDMs, matrices
  20. [20] § Results › What is represented: perceptual to relational content › Behavioural representational geometry ↔ chess-behavioral/91_plot_behavioral_panels.py, lines 1–59 · score 0.71 · Expert directional preference, MDS embedding, selection frequencies, behavioural RDMs, matrices
  21. [21] § Methods › Representational similarity analysis (RSA) › Behavioural representational similarity analysis ↔ chess-behavioral/91_plot_behavioral_panels.py, lines 1–59 · score 0.71 · directional preference matrix, pairwise preference, pairwise comparisons, behavioural RDM, symmetric, raw
  22. [22] § Methods › Representational similarity analysis (RSA) › Behavioural representational similarity analysis ↔ chess-behavioral/91_plot_behavioral_panels.py, lines 1–59 · score 0.71 · directional preference matrix, pairwise preference, pairwise comparisons, behavioural RDM, symmetric, raw
  23. [23] § Methods › Participation ratio ↔ analyses/manifold/models.py, lines 27–89 · score 0.70 · logistic regression classifier, distinguishing Experts, cross validation, trained, weight, PR
  24. [24] § Results › Where information is encoded: domain-general networks ↔ chess-supplementary/neurosynth-terms/91_plot_neurosynth_terms.py, lines 221–275 · score 0.70 · Language Network, Memory Retrieval, Neurosynth term, Working Memory, Navigation, maps
  25. [25] § Results › Where information is encoded: domain-general networks ↔ common/constants.py, lines 207–264 · score 0.69 · Language Network, Memory Retrieval, Working Memory, Neurosynth term, Navigation, chess
  26. [26] § Methods › Regions of Interest (ROIs) ↔ chess-supplementary/subcortical-rois/11_subcortical_group_rsa.py, lines 1–68 · score 0.69 · CAB NP atlas, subcortical structures, exploratory, parcellation, bilateral, Glasser
  27. [27] § Methods › Meta-analytic correlation analysis › Neurosynth term maps ↔ chess-supplementary/neurosynth-terms/91_plot_neurosynth_terms.py, lines 221–275 · score 0.69 · Memory retrieval, language network, Working memory, Navigation, Neurosynth, maps
  28. [28] § Methods › Representational similarity analysis (RSA) › fMRI representational similarity analysis › RSA on Regions of Interest ↔ chess-supplementary/run-matching/01_roi_rsa_run_matched.m, lines 72–210 · score 0.68 · cosmo target dsm, neural RDM, model RDM, corr, Pearson, regressor
  29. [29] § Results › What is represented: perceptual to relational content › Behavioural representational geometry ↔ common/rsa_utils.py, lines 81–151 · score 0.68 · lower triangle, Pearson correlations, behavioural RSA, confidence intervals, behavioural RDM, model RDM
  30. [30] § Methods › Participation ratio ↔ analyses/manifold/pr_computation.py, lines 26–108 · score 0.65 · evenly distributed, effective dimensionality, Participation Ratio, components, PR, variance
  31. [31] § Methods › Representational similarity analysis (RSA) › fMRI representational similarity analysis ↔ chess-supplementary/rdm-intercorrelation/81_table_rdm_intercorr.py, lines 1–78 · score 0.64 · pairwise correlation, dissimilarity matrices, checkmate status, Model RDMs, variables, Theoretical
  32. [32] § Methods › Representational similarity analysis (RSA) › fMRI representational similarity analysis › Whole-brain Searchlight RSA ↔ chess-mvpa/04_searchlight_rsa.m, lines 204–261 · score 0.64 · searchlight RSA, correlation distance, model RDM, neighbourhoods, Pearson, voxel
  33. [33] § Results › Where information is encoded: domain-general networks › Univariate networks involvement › Multivariate representational shift ↔ chess-neurosynth/81_table_neurosynth_univariate.py, lines 1–57 · score 0.63 · bootstrap confidence intervals, activation patterns, Meta Analytic, FDR corrected, univariate, Neurosynth
  34. [34] § Results › What is represented: perceptual to relational content › Behavioural representational geometry ↔ chess-supplementary/behavioral-reliability/12_marginal_split_half.py, lines 1–80 · score 0.63 · split half reliability, pairwise comparison, marginal, status, behavioural, preferences
  35. [35] § Methods › fMRI univariate analysis ↔ chess-neurosynth/12_rsa_neurosynth.py, lines 200–274 · score 0.62 · General Linear Model, map correlations, smoothed, mm, neurosynth, GLM
  36. [36] § Results › How representations are structured: compressed geometry › Participant classification based on dimensionality profiles ↔ analyses/manifold/models.py, lines 262–376 · score 0.62 · cross validated accuracy, fold CV, stratified, permutation, PCA, classifier
  37. [37] § Results › Where information is encoded: domain-general networks › Univariate networks involvement › Multivariate representational shift ↔ chess-neurosynth/82_table_neurosynth_rsa.py, lines 1–48 · score 0.62 · bootstrap confidence intervals, RSA searchlight, Meta Analytic, FDR corrected, Neurosynth, cognitive
  38. [38] § Methods › Representational similarity analysis (RSA) › fMRI representational similarity analysis › RSA on Regions of Interest ↔ chess-supplementary/mvpa-finer/01_roi_decoding_fine.m, lines 84–217 · score 0.62 · cosmo target dsm, corresponding model RDM, regressor, RSA, ROI, correlated
  39. [39] § Methods › Representational similarity analysis (RSA) › fMRI representational similarity analysis › Whole-brain Searchlight RSA ↔ common/constants.py, lines 162–205 · score 0.61 · brain searchlight RSA, Neurosynth term maps, model RDM, matched, ROIs
  40. [40] § Methods › Software ↔ common/chess_config.m, the whole file · a weak match · score 0.61 · Eye tracking, fMRIPrep, MATLAB, preprocessing, manifold, GLM

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 · 379 lines · 13 KB · MIT · 3 matches

  1. """
  2. Machine learning utilities for expert vs novice classification.
  4. This module provides functions for training classifiers to distinguish between
  5. expert and novice chess players based on their neural participation ratios,
  6. and for visualizing the results using PCA.
  8. Functions
  9. ---------
  10. train_logreg_on_pr : Train logistic regression on PR features
  11. compute_pca_2d : Compute 2D PCA projection for visualization
  12. compute_2d_decision_boundary : Precompute decision boundary grid for plotting
  13. """
  15. import logging
  16. import numpy as np
  17. import pandas as pd
  18. from typing import Tuple, Dict, Any
  19. from sklearn.linear_model import LogisticRegression
  20. from sklearn.preprocessing import StandardScaler
  21. from sklearn.decomposition import PCA
  22. from sklearn.model_selection import StratifiedKFold, cross_val_score, permutation_test_score
  24. logger = logging.getLogger(__name__)
  27. def train_logreg_on_pr(
  28. pr_df: pd.DataFrame,
  29. participants: pd.DataFrame,
  30. roi_labels: np.ndarray,
  31. random_seed: int = 42
  32. ) -> Tuple[LogisticRegression, StandardScaler, np.ndarray, np.ndarray]:
  33. """
  34. Train a logistic regression classifier to distinguish experts from novices.
  36. The classifier uses PR values across all ROIs as features. Feature weights
  37. indicate which ROIs are most discriminative between groups.
  39. Parameters
  40. ----------
  41. pr_df : pd.DataFrame
  42. Long-format PR results (columns: subject_id, ROI_Label, PR, n_voxels)
  43. participants : pd.DataFrame
  44. Participant metadata (columns: participant_id, group)
  45. roi_labels : np.ndarray
  46. ROI labels defining feature order
  47. random_seed : int, default=42
  48. Random seed for reproducibility
  50. Returns
  51. -------
  52. clf : LogisticRegression
  53. Trained classifier (clf.coef_ contains feature importance weights)
  54. scaler : StandardScaler
  55. Fitted scaler for transforming new data
  56. all_pr_scaled : np.ndarray
  57. Standardized PR data (shape: n_subjects × n_rois)
  58. labels : np.ndarray
  59. Binary labels (1=expert, 0=novice)
  61. Notes
  62. -----
  63. Data is standardized before training because different ROIs have different
  64. PR scales. Without standardization, high-variance ROIs would dominate.
  66. The classifier is trained on ALL data (no cross-validation) because the goal
  67. is feature importance analysis, not generalization performance.
  68. """
  69. logger.info("Training logistic regression on PR features (expert vs novice)...")
  71. all_pr, labels, n_expert, n_novice = build_feature_matrix(
  72. pr_df,
  73. participants,
  74. roi_labels,
  75. )
  77. # Standardize features
  78. scaler = StandardScaler()
  79. all_pr_scaled = scaler.fit_transform(all_pr)
  81. # Train classifier
  82. clf = LogisticRegression(random_state=random_seed, max_iter=1000)
  83. clf.fit(all_pr_scaled, labels)
  85. logger.info(f" Trained on {len(all_pr)} subjects "
  86. f"({n_expert} experts, {n_novice} novices)")
  87. logger.info(f" Using {len(roi_labels)} ROI features")
  89. return clf, scaler, all_pr_scaled, labels
  92. def compute_pca_2d(
  93. data_scaled: np.ndarray,
  94. n_components: int = 2,
  95. random_seed: int = 42
  96. ) -> Tuple[PCA, np.ndarray, np.ndarray]:
  97. """
  98. Compute PCA embedding for 2D visualization.
  100. PCA finds directions of maximum variance and projects the high-dimensional
  101. PR data into 2D for visualization.
  103. Parameters
  104. ----------
  105. data_scaled : np.ndarray
  106. Standardized data (shape: n_subjects × n_features)
  107. n_components : int, default=2
  108. Number of components (2 for 2D visualization)
  109. random_seed : int, default=42
  110. Random seed for reproducibility
  112. Returns
  113. -------
  114. pca : PCA
  115. Fitted PCA object (pca.components_ shows ROI loadings on each PC)
  116. coords_2d : np.ndarray
  117. 2D coordinates (shape: n_subjects × 2)
  118. explained_variance_pct : np.ndarray
  119. Percentage of variance explained by each PC
  121. Notes
  122. -----
  123. PC1 captures the direction of maximum variance, PC2 captures the second-
  124. maximum variance orthogonal to PC1. Together they often capture major
  125. group differences.
  126. """
  127. logger.info("Computing 2D PCA embedding...")
  129. # Fit PCA and transform data
  130. pca = PCA(n_components=n_components, random_state=random_seed)
  131. coords_2d = pca.fit_transform(data_scaled)
  133. # Get variance explained
  134. explained_variance_pct = (pca.explained_variance_ratio_ * 100).astype(float)
  136. logger.info(f" PC1 explains {explained_variance_pct[0]:.1f}% variance")
  137. logger.info(f" PC2 explains {explained_variance_pct[1]:.1f}% variance")
  139. return pca, coords_2d, explained_variance_pct
  142. def compute_2d_decision_boundary(
  143. coords_2d: np.ndarray,
  144. labels: np.ndarray,
  145. random_seed: int = 42,
  146. grid_resolution: int = 200
  147. ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
  148. """
  149. Precompute decision boundary grid for 2D visualization.
  151. Trains a simple classifier in 2D space and evaluates it on a dense grid,
  152. creating a smooth decision boundary for plotting.
  154. Parameters
  155. ----------
  156. coords_2d : np.ndarray
  157. 2D coordinates from PCA (shape: n_subjects × 2)
  158. labels : np.ndarray
  159. Binary labels (1=expert, 0=novice)
  160. random_seed : int, default=42
  161. Random seed for reproducibility
  162. grid_resolution : int, default=200
  163. Grid points per axis (higher = smoother boundary)
  165. Returns
  166. -------
  167. xx : np.ndarray
  168. X-coordinates of grid (shape: grid_resolution × grid_resolution)
  169. yy : np.ndarray
  170. Y-coordinates of grid (shape: grid_resolution × grid_resolution)
  171. Z : np.ndarray
  172. Predicted class at each grid point (for contour plotting)
  174. Notes
  175. -----
  176. The boundary shows how well groups separate in the 2D PCA space. It's for
  177. visualization only - actual group discrimination happens in full-dimensional
  178. space (see train_logreg_on_pr).
  179. """
  180. logger.info("Computing 2D decision boundary for visualization...")
  182. # Train simple classifier in 2D
  183. clf_2d = LogisticRegression(random_state=random_seed, max_iter=1000)
  184. clf_2d.fit(coords_2d, labels)
  186. # Create grid with 1-unit margins
  187. x_min, x_max = coords_2d[:, 0].min() - 1, coords_2d[:, 0].max() + 1
  188. y_min, y_max = coords_2d[:, 1].min() - 1, coords_2d[:, 1].max() + 1
  190. xx, yy = np.meshgrid(
  191. np.linspace(x_min, x_max, grid_resolution),
  192. np.linspace(y_min, y_max, grid_resolution)
  193. )
  195. # Predict at each grid point
  196. Z = clf_2d.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)
  198. logger.info(f" Computed {grid_resolution}×{grid_resolution} grid")
  200. return xx, yy, Z
  203. __all__ = [
  204. 'train_logreg_on_pr',
  205. 'compute_pca_2d',
  206. 'compute_2d_decision_boundary',
  207. ]
  210. def build_feature_matrix(
  211. pr_df: pd.DataFrame,
  212. participants: pd.DataFrame,
  213. roi_labels: np.ndarray,
  214. ) -> Tuple[np.ndarray, np.ndarray, int, int]:
  215. """
  216. Public API to construct feature matrix X (subjects × ROIs) and labels y.
  218. Parameters
  219. ----------
  220. pr_df : pd.DataFrame
  221. Long-format PR results (columns: subject_id, ROI_Label, PR)
  222. participants : pd.DataFrame
  223. Participant metadata (columns: participant_id, group)
  224. roi_labels : np.ndarray
  225. ROI labels defining column order
  227. Returns
  228. -------
  229. X : np.ndarray
  230. Feature matrix ordered by [experts, novices]
  231. y : np.ndarray
  232. Binary labels (1=expert, 0=novice)
  233. n_expert : int
  234. Number of expert subjects
  235. n_novice : int
  236. Number of novice subjects
  237. """
  238. from common.bids_utils import merge_group_labels
  239. from .utils import ensure_roi_order
  241. pr_with_group = merge_group_labels(pr_df, participants, subject_col='subject_id')
  243. expert_pr = pr_with_group[pr_with_group['group'] == 'expert'].pivot(
  244. index='subject_id',
  245. columns='ROI_Label',
  246. values='PR'
  247. )
  248. expert_pr = ensure_roi_order(expert_pr, roi_labels)[roi_labels].values
  250. novice_pr = pr_with_group[pr_with_group['group'] == 'novice'].pivot(
  251. index='subject_id',
  252. columns='ROI_Label',
  253. values='PR'
  254. )
  255. novice_pr = ensure_roi_order(novice_pr, roi_labels)[roi_labels].values
  257. X = np.vstack([expert_pr, novice_pr])
  258. y = np.array([1] * len(expert_pr) + [0] * len(novice_pr))
  259. return X, y, len(expert_pr), len(novice_pr)
  262. def evaluate_classification_significance(
  263. pr_df: pd.DataFrame,
  264. participants: pd.DataFrame,
  265. roi_labels: np.ndarray,
  266. space: str = 'roi',
  267. random_seed: int = 42,
  268. n_splits: int = None,
  269. n_permutations: int = 1000,
  270. ) -> Dict[str, Any]:
  271. """
  272. Evaluate whether classification accuracy exceeds chance using CV and permutations.
  274. Methods (for papers)
  275. --------------------
  276. Feature construction: For each subject we build a feature vector from PR
  277. values across ROIs with a binary label (1=expert, 0=novice). We use a
  278. scikit‑learn Pipeline with StandardScaler, and for the 2D analysis we add
  279. PCA(n_components=2) inside the pipeline so PCA is fit only on training folds.
  281. Cross‑validation: We estimate performance with stratified K‑fold CV (K is
  282. the largest feasible up to 5 given class sizes). The classifier is logistic
  283. regression (max_iter=1000). We report the mean accuracy across folds and
  284. the standard deviation across folds as a descriptive spread.
  286. Inference via permutation: Statistical significance for above‑chance
  287. performance is assessed with a label‑permutation test using
  288. `permutation_test_score`, run with the same CV and full pipeline. This
  289. yields an assumption‑light p‑value for the null that accuracy equals chance
  290. (0.5 for balanced classes).
  292. Parameters
  293. ----------
  294. pr_df : pd.DataFrame
  295. Long-format PR results.
  296. participants : pd.DataFrame
  297. Participant metadata with group labels.
  298. roi_labels : np.ndarray
  299. ROI labels defining feature order.
  300. space : {'roi', 'pca2d'}, default='roi'
  301. Feature space to evaluate. 'roi' uses all ROIs as features; 'pca2d'
  302. uses a pipeline with PCA(2) fit within each CV fold.
  303. random_seed : int, default=42
  304. Random seed for reproducibility.
  305. n_splits : int or None, default=None
  306. Number of CV folds (StratifiedKFold). If None, chooses the maximum
  307. feasible up to 5 given class counts.
  308. n_permutations : int, default=1000
  309. Number of permutations for permutation test.
  311. Returns
  312. -------
  313. dict
  314. Dictionary with keys:
  315. - 'space': 'roi' or 'pca2d'
  316. - 'cv_accuracy_mean', 'cv_accuracy_std'
  317. - 'n_splits', 'n_subjects', 'n_experts', 'n_novices'
  318. - 'perm_pvalue', 'perm_null_mean', 'perm_null_std', 'n_permutations'
  319. """
  320. from sklearn.pipeline import Pipeline
  322. logger.info(f"Evaluating classification significance in '{space}' space...")
  324. X, y, n_expert, n_novice = build_feature_matrix(pr_df, participants, roi_labels)
  325. n_subjects = X.shape[0]
  327. # Determine feasible number of splits
  328. if n_splits is None:
  329. max_splits = max(2, min(5, n_expert, n_novice))
  330. n_splits = max_splits
  331. if n_splits < 2 or n_splits > min(n_expert, n_novice):
  332. n_splits = min(max(2, n_splits), n_expert, n_novice)
  334. cv = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=random_seed)
  336. steps = [('scaler', StandardScaler())]
  337. if space.lower() in ['pca2d', 'pca_2d', '2d', 'pca']:
  338. steps.append(('pca', PCA(n_components=2, random_state=random_seed)))
  339. steps.append(('clf', LogisticRegression(random_state=random_seed, max_iter=1000)))
  340. estimator = Pipeline(steps)
  342. # Cross-validated accuracy (mean ± std across folds)
  343. cv_scores = cross_val_score(estimator, X, y, cv=cv, scoring='accuracy')
  344. cv_acc_mean = float(np.mean(cv_scores))
  345. cv_acc_std = float(np.std(cv_scores, ddof=1)) if len(cv_scores) > 1 else 0.0
  347. # Permutation test (scikit-learn handles CV internally)
  348. score, perm_scores, pvalue = permutation_test_score(
  349. estimator, X, y,
  350. scoring='accuracy',
  351. cv=cv,
  352. n_permutations=n_permutations,
  353. random_state=random_seed,
  354. n_jobs=None,
  355. )
  357. results = {
  358. 'space': 'pca2d' if ('pca' in [name for name, _ in steps]) else 'roi',
  359. 'cv_accuracy_mean': cv_acc_mean,
  360. 'cv_accuracy_std': cv_acc_std,
  361. 'n_splits': int(n_splits),
  362. 'n_subjects': int(n_subjects),
  363. 'n_experts': int(n_expert),
  364. 'n_novices': int(n_novice),
  365. 'perm_pvalue': float(pvalue),
  366. 'perm_null_mean': float(np.mean(perm_scores)),
  367. 'perm_null_std': float(np.std(perm_scores, ddof=1)) if len(perm_scores) > 1 else 0.0,
  368. 'n_permutations': int(n_permutations),
  369. }
  371. logger.info(
  372. f" CV accuracy: {cv_acc_mean:.3f} ± {cv_acc_std:.3f} (n_splits={n_splits})\n"
  373. f" Permutation p={pvalue:.4g} (null mean={np.mean(perm_scores):.3f})"
  374. )
  376. return results
  379. __all__.extend(['evaluate_classification_significance', 'build_feature_matrix'])

models.py at commit 58ad401, under MIT · at the source

Overview

Authors: Andrea I Costantino1,2, Artem Platonov1, Felipe Fontana Vieira1,3, Emily Van Hove1,2, Merim Bilalić4, Hans Op de Beeck1,2
ORCID iDs: Andrea I Costantino, Artem Platonov, Hans Op de Beeck
  1. Department of Brain and Cognition, Faculty of Psychology and Educational Sciences, KU Leuven, Leuven, Belgium
  2. Leuven Brain Institute, KU Leuven, Leuven, Belgium
  3. Department of Data Analysis, Faculty of Psychology and Educational Sciences, Ghent University, Ghent, Belgium
  4. School of Psychology, Northumbria University, Newcastle upon Tyne, UK
Institutions: KU Leuven (Belgium); Ghent University (Belgium); Northumbria University (United Kingdom)
Journal: Nature communications, volume 17, issue 1, article 8024
Dates: received 14 November 2025; accepted 8 June 2026; published online 26 June 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41467-026-74566-z · PMID 42362539 · PMCID PMC13454291 · OpenAlex W4416220635
Open access: gold, a free copy (OpenAlex)
Preprint: doi:10.1101/2025.11.12.688012
Status: code verified
Categories: human (organism), cognitive (subfield)
Methods: Connectivity, Spectral & time-frequency, Statistics, Smoothing, state filtering, decompositions, Machine learning, Preprocessing, fMRI & imaging, Physiology & signal measures
Keywords: Computational neuroscience, Learning and memory, Cognitive neuroscience, Human behaviour
MeSH: Brain*, Brain Mapping, Humans, Magnetic Resonance Imaging, Models, Neurological, Neuroimaging (* major topic)
Topic: Face Recognition and Perception (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Fonds Wetenschappelijk Onderzoek (G0D3322N); Flemish Government
Citations: cited by 1 paper (Europe PMC); 77 references in the paper
Research resources: which is based on Nipype 1.8.6 RRID:SCR_002502, scikit-learn 1.7.1 RRID:SCR_002577, MA) with Psychtoolbox-3 RRID:SCR_002881, SPM12 RRID:SCR_007037, CoSMoMVPA RRID:SCR_014519, RRID:SCR_016216

Abstract

The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repositories

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

costantinoai/chess-expertise-2025

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 58ad401c241ec28a6327882f490b29a026ab2e74, 5 June 2026
Languages: Python (135), MATLAB (17), Shell (1)
Size: 175 files, 153 scripts
Software Heritage: archived
Found in: “Code availability”
Holds: README, license file, environment (environment.yml, pyproject.toml, requirements.txt)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: pandas (80 files), NumPy (67 files), Matplotlib (33 files), SciPy (18 files), Nilearn (13 files), SPM (9 files), NiBabel (7 files), scikit-learn (6 files), CoSMoMVPA (5 files), seaborn (5 files), Plotly (2 files), statsmodels (2 files), fMRIPrep (1 file), Pingouin (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
155 files
At the source: github.com/costantinoai/chess-expertise-2025

Zenodo 19392282

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Code availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: pandas (79 files), NumPy (66 files), Matplotlib (32 files), SciPy (18 files), Nilearn (13 files), SPM (9 files), NiBabel (7 files), scikit-learn (6 files), CoSMoMVPA (5 files), seaborn (5 files), Plotly (2 files), statsmodels (2 files), fMRIPrep (1 file), Pingouin (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers (HTTP 200)
  • 27 September 2026: the link answers (HTTP 200)
154 files
At the source:

Code availability statement

The paper has a code availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1038/s41467-026-74566-z.

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:

  • 2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 305 scripts, each with its path and the digest of its content;
  • 40 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

No dataset and no data link were found in the paper.

Data availability statement

The paper has a data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

  • no repository, dataset or request procedure was recognized in it

Read it in the paper: doi.org/10.1038/s41467-026-74566-z.

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, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 6 authors, 4 keywords, 6 MeSH terms, 2 funders, 59 references, 6 RRIDs.

Cite

This paper

Costantino, A. I., Platonov, A., Fontana Vieira, F., Van Hove, E., Bilalić, M., & Op de Beeck, H. (2026). Low-dimensional and optimised representations of high-level information in the expert brain. Nature communications, 17(1), 8024. https://doi.org/10.1038/s41467-026-74566-z

BibTeX

@article{costantino2026low,
author = {Costantino, Andrea I and Platonov, Artem and Fontana Vieira, Felipe and Van Hove, Emily and Bilalić, Merim and Op de Beeck, Hans},
title = {{Low-dimensional and optimised representations of high-level information in the expert brain}},
journal = {Nature communications},
year = {2026},
month = jun,
volume = {17},
number = {1},
pages = {8024},
publisher = {Nature Publishing Group},
issn = {2041-1723},
doi = {10.1038/s41467-026-74566-z},
url = {https://doi.org/10.1038/s41467-026-74566-z},
pmid = {42362539},
pmcid = {PMC13454291}
}

RIS

TY - JOUR
AU - Costantino, Andrea I
AU - Platonov, Artem
AU - Fontana Vieira, Felipe
AU - Van Hove, Emily
AU - Bilalić, Merim
AU - Op de Beeck, Hans
TI - Low-dimensional and optimised representations of high-level information in the expert brain
T2 - Nature communications
J2 - Nat Commun
PY - 2026
DA - 2026/06/26
VL - 17
IS - 1
SP - 8024
SN - 2041-1723
PB - Nature Publishing Group
DO - 10.1038/s41467-026-74566-z
UR - https://doi.org/10.1038/s41467-026-74566-z
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41467-026-74566-z",
"type": "article-journal",
"title": "Low-dimensional and optimised representations of high-level information in the expert brain",
"container-title": "Nature communications",
"author": [
{
"family": "Costantino",
"given": "Andrea I"
},
{
"family": "Platonov",
"given": "Artem"
},
{
"family": "Fontana Vieira",
"given": "Felipe"
},
{
"family": "Van Hove",
"given": "Emily"
},
{
"family": "Bilalić",
"given": "Merim"
},
{
"family": "Op de Beeck",
"given": "Hans"
}
],
"container-title-short": "Nat Commun",
"volume": "17",
"issue": "1",
"page": "8024",
"DOI": "10.1038/s41467-026-74566-z",
"PMID": "42362539",
"PMCID": "PMC13454291",
"ISSN": "2041-1723",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41467-026-74566-z",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
26
]
]
}
}

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/s41467-026-71151-2 [code]
Common and distinct neural correlates of social interaction processing and theory of mind in narratives.
Journal: Nature communications
In common: fMRIPrep, Nilearn, SPM, 8 other tools, cognitive, 4 references
[2] doi:10.1162/imag.a.105 [code]
Right posterior theta reflects human parahippocampal phase resetting by salient cues during goal-directed navigation
Journal: n/a
In common: Pingouin, Nilearn, SPM, 7 other tools, cognitive, 3 references
[3] doi:10.1038/s41467-026-71568-9 [code]
Convergent and selective representations of pain, appetitive processes, aversive processes, and cognitive control in the insula.
Journal: Nature communications
In common: fMRIPrep, Nilearn, SPM, 7 other tools, cognitive, 3 references
[4] doi:10.1038/s41467-026-71428-6 [code]
Binding items to contexts through conjunctive neural representations with the method of loci.
Journal: Nature communications
In common: fMRIPrep, Nilearn, Plotly, 8 other tools, 2 references
[5] doi:10.1038/s41467-026-73153-6 [code]
Latent neural architecture organising shared aesthetic evaluations of visual artworks.
Journal: Nature communications
In common: CoSMoMVPA, Pingouin, seaborn, 5 other tools, cognitive, 4 references
[6] doi:10.7554/elife.107933 [code]
Modality-agnostic decoding of vision and language from fMRI.
Journal: eLife
In common: Nilearn, SPM, NiBabel, 7 other tools, cognitive, 3 references
[7] doi:10.1371/journal.pbio.3003684 [code]
The retrieval of previously learned motor memories is facilitated by the reinstatement of default mode network manifold structures.
Journal: PLoS biology
In common: Pingouin, Nilearn, NiBabel, 6 other tools, cognitive, 3 references
[8] doi:10.1038/s41597-026-07377-y [code]
An open-access multi-site fMRI dataset for investigating conscious visual perception.
Journal: Scientific data
In common: Pingouin, Nilearn, SPM, 8 other tools, 1 reference
[9] doi:10.1038/s41597-026-07350-9 [code]
An open multi-center MEG-EEG dataset for studying conscious visual perception.
Journal: Scientific data
In common: Pingouin, Nilearn, SPM, 8 other tools, 1 reference
[10] doi:10.1162/imag.a.1269 [code]
From early to contemporary normative modeling: Mapping individual differences in neurophysiological signals.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Pingouin, Nilearn, Plotly, 8 other tools, 1 reference

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.