OSCR

Gamer in the scanner: Event-related analysis of fMRI activity during retro videogame play guided by automated annotations of game content.

Code ↔ Paper

23 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 23 matches
  1. [1] § Methods › Annotation of task events › Sensory and motor features ↔ shinobi_fmri/glm/utils.py, lines 565–621 · score 0.87 · canonical HRF, Optical flow, Audio envelope, task regressors, Button press, downsampled
  2. [2] § Methods › Statistical analyses › First-level (session) general linear model ↔ shinobi_fmri/glm/compute_session_level.py, lines 1–59 · score 0.85 · minimum cluster extent, noise model, fMRIPrep, AR, design matrix, FWHM
  3. [3] § Methods › Statistical analyses › Brain activation maps derived from HCP test-retest dataset ↔ shinobi_fmri/visualization/hcp_tasks.py, lines 35–44 · score 0.82 · left_foot, left_hand, right_foot, right_hand, cues, tongue
  4. [4] § Methods › Statistical analyses › Brain activation maps derived from HCP test-retest dataset ↔ notebooks/NB5_beta_correlations.ipynb, lines 117–128 · score 0.81 · left_foot, left_hand, right_foot, right_hand, cues, tongue
  5. [5] § Methods › Statistical analyses › First-level (session) general linear model ↔ shinobi_fmri/glm/utils.py, lines 721–793 · score 0.78 · global signal, fMRIPrep, design matrix, convolved, CSF, SPM
  6. [6] § Methods › Neuroimaging acquisitions › The shinobi dataset › At-home training ↔ shinobi_fmri/visualization/viz_training_comparison.py, lines 1–72 · score 0.73 · shinobi_training, home training, scanner sessions, weeks, metrics, behavioral
  7. [7] § Methods › Annotation of task events › Memory (RAM) mining ↔ notebooks/NB2_replay_visualizations.ipynb, lines 172–214 · score 0.66 · Replay bk2, gym retro, game variables
  8. [8] § Results › Within- and between-participant variability of brain maps compared to classical functional localizer tasks ↔ shinobi_fmri/visualization/viz_beta_correlations.py, lines 349–414 · score 0.64 · Optical flow, Audio envelope, Button press, HealthLoss, SD, Inter
  9. [9] § Results › Within- and between-participant variability of brain maps compared to classical functional localizer tasks ↔ shinobi_fmri/visualization/viz_beta_correlations.py, lines 349–414 · score 0.64 · Optical flow, Audio envelope, Button press, HealthLoss, SD, inter
  10. [10] § Methods › Statistical analyses › Second-level (participant) general linear model ↔ shinobi_fmri/glm/compute_session_level.py, lines 1–59 · score 0.62 · minimum cluster extent, nilearn, smoothing, uncorrected, FDR, voxel
  11. [11] § Results › GLM regressors had low to moderate correlations for most game events ↔ shinobi_fmri/visualization/viz_regressor_correlations.py, lines 465–517 · score 0.60 · optical flow, Audio envelope, button press, HealthLoss, luminance, regressors
  12. [12] § Results › Within- and between-participant variability of brain maps compared to classical functional localizer tasks ↔ shinobi_fmri/visualization/viz_regressor_correlations.py, lines 465–517 · score 0.60 · Optical flow, Audio envelope, Button press, HealthLoss, Luminance, regressors
  13. [13] § Methods › Statistical analyses › Second-level (participant) general linear model ↔ shinobi_fmri/glm/compute_subject_level.py, lines 1–66 · score 0.60 · minimum cluster extent, intercept, smoothing, uncorrected, FDR, voxel
  14. [14] § Methods › Annotation of task events › Data structure for events ↔ shinobi_fmri/visualization/viz_regressor_correlations.py, lines 93–235 · score 0.60 · annotated_events.tsv, button press, HealthLoss, onset, desc, Rows
  15. [15] § Results › Game events activation maps are discriminable ↔ tasks.py, lines 23–40 · score 0.60 · optical flow, audio envelope, button press, HealthLoss, luminance, errors
  16. [16] § Methods › Neuroimaging acquisitions › MRI preprocessing ↔ shinobi_fmri/glm/utils.py, lines 721–793 · score 0.56 · wm_csf, high_pass, motion, preprocessing, MRI
  17. [17] § Methods › Neuroimaging acquisitions › MRI preprocessing ↔ shinobi_fmri/visualization/viz_regressor_correlations.py, lines 93–235 · score 0.55 · wm_csf, high_pass, motion, preprocessing
  18. [18] § Methods › Neuroimaging acquisitions › The shinobi dataset › At-home training ↔ tasks.py, lines 1240–1275 · score 0.55 · home training, scanner sessions, metrics, behavioral, shinobi
  19. [19] § Methods › Annotation of task events › Data structure for events ↔ shinobi_fmri/descriptive/dataset_summary.py, lines 42–186 · score 0.55 · annotated_events.tsv, HealthLoss, fMRI, bk2, desc, Rows
  20. [20] § Methods › Behavioral acquisitions › Videogame interface ↔ shinobi_fmri/annotations/generate_train_json.py, lines 125–135 · score 0.55 · Ninja Master, Shinobi III, replays, variables, player, game
  21. [21] § Methods › Statistical analyses › MVPA classification ↔ shinobi_fmri/mvpa/compute_mvpa.py, lines 131–229 · score 0.54 · dummy classifier, confusion matrix, MVPA, Model
  22. [22] § Methods › Statistical analyses › MVPA classification ↔ shinobi_fmri/mvpa/compute_mvpa.py, lines 398–454 · score 0.52 · dummy classifier, confusion matrix, MVPA
  23. [23] § Methods › Statistical analyses › Beta maps correlations ↔ notebooks/NB5_beta_correlations.ipynb, lines 11–87 · score 0.52 · inter annotation, beta maps, ICC, correlations

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 · 854 lines · 32 KB · MIT · 4 matches

  1. """
  2. Generate design matrices and correlation visualization for GLM regressors.
  4. This script computes and visualizes design matrices and correlations between
  5. key regressors in the GLM. It produces:
  6. 1. Design matrices (one per run) showing all regressors
  7. 2. 2x2 correlation grid showing subject-averaged correlations
  9. The 2x2 grid focuses on Shinobi task conditions and low-level confounds
  10. (psychophysics: luminance, optical_flow, audio_envelope; and button press:
  11. button_presses_count) to identify multicollinearity between task events and
  12. low-level visual/audio features and motor activity.
  13. """
  15. import os
  16. import os.path as op
  17. import argparse
  18. import pickle
  19. import logging
  20. import re
  21. import warnings
  22. from typing import Any, Dict, List, Optional
  24. import numpy as np
  25. import pandas as pd
  26. import matplotlib.pyplot as plt
  27. import seaborn as sns
  28. from tqdm import tqdm
  30. from nilearn.glm.first_level import make_first_level_design_matrix
  31. from nilearn.signal import clean
  32. import nilearn.interfaces.fmriprep
  34. import shinobi_fmri.config as config
  35. from shinobi_fmri.utils.logger import AnalysisLogger
  36. from shinobi_fmri.glm.utils import add_psychophysics_confounds, add_button_press_confounds
  37. from shinobi_fmri.visualization.hcp_tasks import SHINOBI_COLOR
  39. # Suppress specific warnings
  40. warnings.filterwarnings('ignore', category=UserWarning, module='nilearn')
  41. warnings.filterwarnings('ignore', category=UserWarning, module='sklearn')
  42. warnings.filterwarnings('ignore', category=DeprecationWarning)
  45. def setup_argparse():
  46. """Set up command-line argument parser."""
  47. parser = argparse.ArgumentParser(
  48. description="Generate correlation matrices for design matrix regressors"
  49. )
  50. parser.add_argument(
  51. "-s", "--subject",
  52. default=None,
  53. type=str,
  54. help="Specific subject to process (default: all subjects)",
  55. )
  56. parser.add_argument(
  57. "--data-path",
  58. default=config.path_to_data,
  59. type=str,
  60. help=f"Path to data directory (default: {config.path_to_data})",
  61. )
  62. parser.add_argument(
  63. "--figures-path",
  64. default=config.figures_path,
  65. type=str,
  66. help=f"Path to figures output directory (default: {config.figures_path})",
  67. )
  68. parser.add_argument(
  69. "--skip-generation",
  70. action="store_true",
  71. help="Skip design matrix generation, only plot from existing pickle file",
  72. )
  73. parser.add_argument(
  74. "--exclude-low-level",
  75. action="store_true",
  76. default=False,
  77. help="Exclude low-level confounds (psychophysics and button presses) from design matrix (default: False, confounds are included)",
  78. )
  79. parser.add_argument(
  80. "-v", "--verbose",
  81. action="count",
  82. default=0,
  83. help="Increase verbosity level (e.g. -v for INFO, -vv for DEBUG)",
  84. )
  85. parser.add_argument(
  86. "--log-dir",
  87. default=None,
  88. help="Directory for log files",
  89. )
  90. return parser
  93. def process_single_run(sub, ses, run, path_to_data, figures_path, exclude_low_level=False):
  94. """Helper function to process a single run."""
  95. t_r = 1.49
  96. hrf_model = 'spm'
  98. try:
  99. # Zero-pad run number for events filename (run-01 format)
  100. run_padded = run.zfill(2)
  102. # Build file paths
  103. # Build file paths
  104. events_base_path = op.join(path_to_data, "shinobi", sub, ses, "func")
  105. annotated_events = op.join(
  106. events_base_path,
  107. f"{sub}_{ses}_task-shinobi_run-{run_padded}_desc-annotated_events.tsv"
  108. )
  109. standard_events = op.join(
  110. events_base_path,
  111. f"{sub}_{ses}_task-shinobi_run-{run_padded}_events.tsv"
  112. )
  114. if op.exists(annotated_events):
  115. events_fname = annotated_events
  116. elif op.exists(standard_events):
  117. events_fname = standard_events
  118. else:
  119. events_fname = annotated_events # Default for error reporting
  120. fmri_fname = op.join(
  121. path_to_data, "shinobi.fmriprep",
  122. sub, ses, "func",
  123. f"{sub}_{ses}_task-shinobi_run-{run}_space-MNI152NLin2009cAsym_desc-preproc_bold.nii.gz",
  124. )
  126. # Check if events file exists
  127. if not op.exists(events_fname):
  128. return {
  129. 'success': False,
  130. 'subject': sub,
  131. 'session': ses,
  132. 'run': run,
  133. 'error': f"Events file not found: {events_fname}"
  134. }
  136. # Load events
  137. run_events = pd.read_csv(events_fname, sep='\t', low_memory=False)
  139. # Load confounds using nilearn interface (returns tuple)
  140. try:
  141. confounds = nilearn.interfaces.fmriprep.load_confounds(
  142. fmri_fname,
  143. strategy=("motion", "high_pass", "wm_csf"),
  144. motion="full",
  145. wm_csf="basic",
  146. global_signal="full",
  147. )
  148. except Exception as e:
  149. return {
  150. 'success': False,
  151. 'subject': sub,
  152. 'session': ses,
  153. 'run': run,
  154. 'error': f"Could not load confounds (broken link or missing file): {str(e)}"
  155. }
  157. # Add low-level confounds unless excluded
  158. if not exclude_low_level:
  159. confounds = add_psychophysics_confounds(confounds, run_events, path_to_data, t_r=t_r)
  160. confounds = add_button_press_confounds(confounds, run_events, t_r=t_r)
  162. # Extract DataFrame from tuple
  163. confounds = confounds[0]
  165. # Generate design matrix
  166. n_slices = confounds.shape[0]
  167. frame_times = np.arange(n_slices) * t_r
  169. # Filter events to keep only conditions from config (excludes gym-retro_game, etc.)
  170. events_cols = ['onset', 'duration', 'trial_type']
  171. if 'modulation' in run_events.columns:
  172. events_cols.append('modulation')
  173. events_df_clean = run_events[events_cols].copy()
  175. # Keep only conditions defined in config.CONDITIONS
  176. events_df_clean = events_df_clean[events_df_clean['trial_type'].isin(config.CONDITIONS)]
  178. # Drop rows with NaN onset (can't model events without onset time)
  179. events_df_clean = events_df_clean.dropna(subset=['onset'])
  181. # Suppress nilearn warning about zero-duration events (Kill, HealthLoss are impulse events)
  182. with warnings.catch_warnings():
  183. warnings.filterwarnings('ignore', message='.*null duration.*')
  184. design_matrix_raw = make_first_level_design_matrix(
  185. frame_times,
  186. events=events_df_clean,
  187. drift_model=None,
  188. hrf_model=hrf_model,
  189. add_regs=confounds,
  190. add_reg_names=None
  191. )
  193. # Clean design matrix
  194. regressors_clean = clean(
  195. design_matrix_raw.to_numpy(),
  196. detrend=True,
  197. standardize='zscore_sample',
  198. high_pass=None,
  199. t_r=t_r,
  200. ensure_finite=True,
  201. confounds=None,
  202. )
  203. design_matrix_clean = pd.DataFrame(
  204. regressors_clean,
  205. columns=design_matrix_raw.columns.to_list()
  206. )
  208. # Save design matrix plot
  209. from nilearn import plotting as nlplot
  210. design_matrix_clean_fname = op.join(
  211. figures_path, "design_matrices",
  212. f"design_matrix_clean_{sub}_{ses}_run-{run_padded}.png",
  213. )
  214. os.makedirs(op.dirname(design_matrix_clean_fname), exist_ok=True)
  215. nlplot.plot_design_matrix(
  216. design_matrix_clean,
  217. output_file=design_matrix_clean_fname
  218. )
  220. return {
  221. 'success': True,
  222. 'regressors': design_matrix_clean,
  223. 'subject': sub,
  224. 'session': ses,
  225. 'run': run
  226. }
  228. except Exception as e:
  229. return {
  230. 'success': False,
  231. 'subject': sub,
  232. 'session': ses,
  233. 'run': run,
  234. 'error': str(e)
  235. }
  238. def build_design_matrices(subjects, path_to_data, figures_path, exclude_low_level=False, logger=None):
  239. """
  240. Build design matrices for all runs across specified subjects.
  242. Args:
  243. subjects: List of subject IDs to process
  244. path_to_data: Path to data directory
  245. figures_path: Path to figures directory
  246. exclude_low_level: Exclude low-level confounds (psychophysics and button presses)
  247. logger: AnalysisLogger instance
  249. Returns:
  250. dict: Dictionary containing design matrices, subjects, sessions, and runs
  251. """
  252. regressors_dict = {
  253. 'regressors': [],
  254. 'subject': [],
  255. 'session': [],
  256. 'run': []
  257. }
  259. # Collect all tasks to run
  260. tasks = []
  262. # Pre-scan for tasks
  263. for sub in subjects:
  264. fmriprep_sub_path = op.join(path_to_data, "shinobi.fmriprep", sub)
  265. if not op.exists(fmriprep_sub_path):
  266. if logger:
  267. logger.warning(f"Subject directory not found: {fmriprep_sub_path}")
  268. continue
  270. sessions = [d for d in os.listdir(fmriprep_sub_path)
  271. if d.startswith('ses-') and op.isdir(op.join(fmriprep_sub_path, d))]
  273. for ses in sorted(sessions):
  274. ses_fpath = op.join(path_to_data, "shinobi.fmriprep", sub, ses, "func")
  275. if not op.exists(ses_fpath):
  276. if logger:
  277. logger.warning(f"Func directory not found: {ses_fpath}")
  278. continue
  280. ses_files = os.listdir(ses_fpath)
  281. run_files = [
  282. x for x in ses_files
  283. if "space-MNI152NLin2009cAsym_desc-preproc_bold.nii.gz" in x
  284. ]
  286. # Extract run numbers
  287. run_list = []
  288. for fname in run_files:
  289. match = re.search(r'run-(\d+)', fname)
  290. if match:
  291. run_list.append(match.group(1))
  293. for run in sorted(run_list):
  294. tasks.append((sub, ses, run))
  296. # Process sequentially
  297. if logger:
  298. logger.info(f"Processing {len(tasks)} runs...")
  300. for sub, ses, run in tqdm(tasks, desc="Building design matrices"):
  301. res = process_single_run(
  302. sub, ses, run, path_to_data, figures_path, exclude_low_level
  303. )
  304. if res['success']:
  305. regressors_dict['regressors'].append(res['regressors'])
  306. regressors_dict['subject'].append(res['subject'])
  307. regressors_dict['session'].append(res['session'])
  308. regressors_dict['run'].append(res['run'])
  310. if logger:
  311. logger.summary.add_computed(f"Design matrix: {res['subject']} {res['session']} run {res['run']}")
  312. else:
  313. if logger:
  314. logger.error(f"Error processing {res['subject']} {res['session']} run {res['run']}: {res['error']}")
  315. logger.summary.add_error(f"{res['subject']} {res['session']} run {res['run']}", res['error'])
  316. else:
  317. print(f"Error processing {res['subject']} {res['session']} run {res['run']}: {res['error']}")
  319. return regressors_dict
  322. def plot_run_correlations(regressors_dict, figures_path, logger=None):
  323. """
  324. Plot correlation matrices for each run.
  326. Args:
  327. regressors_dict: Dictionary containing design matrices
  328. figures_path: Path to save figures
  329. logger: AnalysisLogger instance
  330. """
  331. output_dir = op.join(figures_path, 'design_matrices')
  332. os.makedirs(output_dir, exist_ok=True)
  334. regressors_dict['corr_mat'] = []
  336. pbar = tqdm(enumerate(regressors_dict['regressors']),
  337. total=len(regressors_dict['regressors']),
  338. desc="Plotting run correlations")
  340. for run_idx, run in pbar:
  341. sub = regressors_dict['subject'][run_idx]
  342. ses = regressors_dict['session'][run_idx]
  343. run_num = regressors_dict['run'][run_idx]
  345. if logger:
  346. logger.info(f"Plotting correlations for {sub} {ses} run {run_num}")
  348. # Compute correlation matrix (excluding constant)
  349. corr = regressors_dict['regressors'][run_idx].corr()
  350. if 'constant' in corr.index:
  351. corr = corr.drop(index='constant').drop(columns='constant')
  352. regressors_dict['corr_mat'].append(corr)
  354. mask = np.triu(np.ones_like(corr, dtype=bool))
  356. # Heatmap
  357. f, ax = plt.subplots(figsize=(30, 25))
  358. sns.heatmap(
  359. corr, mask=mask, center=0,
  360. square=True, linewidths=.5, annot=False,
  361. cbar_kws={"shrink": .5}
  362. ).set_title(f'{sub} {ses} run {run_num}')
  363. fig_fname = op.join(
  364. output_dir,
  365. f'regressor_correlations_{sub}_{ses}_run-{run_num}.png'
  366. )
  367. plt.savefig(fig_fname, dpi=100, bbox_inches='tight')
  368. plt.close()
  370. # Cluster map (only if no NaN/inf values)
  371. if np.all(np.isfinite(corr.values)):
  372. try:
  373. f = sns.clustermap(
  374. corr, mask=mask, figsize=(30, 25),
  375. cbar_kws={"shrink": .5}
  376. )
  377. fig_fname = op.join(
  378. output_dir,
  379. f'regressor_correlations_{sub}_{ses}_run-{run_num}_cluster.png'
  380. )
  381. f.savefig(fig_fname, dpi=100, bbox_inches='tight')
  382. plt.close()
  383. except ValueError as e:
  384. if logger:
  385. logger.warning(f"Could not create clustermap for {sub} {ses} run {run_num}: {str(e)}")
  387. if logger:
  388. logger.summary.add_computed(f"Run correlations: {sub} {ses} run {run_num}")
  390. pbar.set_postfix({"Subject": sub, "Session": ses, "Run": run_num})
  393. def plot_subject_averaged_correlations(regressors_dict, subjects, figures_path, exclude_low_level=False, logger=None):
  394. """
  395. Plot subject-averaged correlation matrices.
  397. Args:
  398. regressors_dict: Dictionary containing correlation matrices
  399. subjects: List of subjects to process
  400. figures_path: Path to save figures
  401. exclude_low_level: Exclude low-level confounds from design matrix
  402. logger: AnalysisLogger instance
  403. """
  404. output_dir = op.join(figures_path, 'design_matrices')
  405. os.makedirs(output_dir, exist_ok=True)
  407. # Add suffix to filename if low-level confounds are included
  408. suffix = "" if exclude_low_level else "_low-level"
  410. for sub in tqdm(subjects, desc="Plotting subject-averaged correlations"):
  411. if logger:
  412. logger.info(f"Plotting averaged correlations for {sub}")
  414. # Collect all correlation matrices for this subject
  415. subj_corrs = []
  416. for idx, corr_mat in enumerate(regressors_dict['corr_mat']):
  417. if regressors_dict['subject'][idx] == sub:
  418. subj_corrs.append(corr_mat)
  420. if not subj_corrs:
  421. if logger:
  422. logger.warning(f"No correlation matrices found for {sub}")
  423. continue
  425. # Average across runs
  426. averaged_corr_mat = pd.concat(subj_corrs, axis=0).groupby(level=0).mean()
  427. mask = np.triu(np.ones_like(averaged_corr_mat, dtype=bool))
  429. # Heatmap with annotations
  430. f, ax = plt.subplots(figsize=(30, 25))
  431. title = f'{sub} - Averaged across runs'
  432. if not exclude_low_level:
  433. title += ' (with low-level confounds)'
  434. sns.heatmap(
  435. averaged_corr_mat, mask=mask, center=0,
  436. square=True, linewidths=.5, annot=True,
  437. cbar_kws={"shrink": .5}, fmt='.2f'
  438. ).set_title(title)
  439. fig_fname = op.join(output_dir, f'regressor_correlations_{sub}{suffix}.png')
  440. plt.savefig(fig_fname, dpi=100, bbox_inches='tight')
  441. plt.close()
  443. # Cluster map (only if no NaN/inf values)
  444. if np.all(np.isfinite(averaged_corr_mat.values)):
  445. try:
  446. f = sns.clustermap(
  447. averaged_corr_mat, mask=mask, figsize=(30, 25),
  448. center=0, square=True, linewidths=.5, annot=True,
  449. cbar_kws={"shrink": .5}, fmt='.2f'
  450. )
  451. fig_fname = op.join(output_dir, f'regressor_correlations_{sub}_cluster{suffix}.png')
  452. f.savefig(fig_fname, dpi=100, bbox_inches='tight')
  453. plt.close()
  454. except ValueError as e:
  455. if logger:
  456. logger.warning(f"Could not create clustermap for {sub}: {str(e)}")
  457. else:
  458. if logger:
  459. logger.warning(f"Skipping clustermap for {sub} due to non-finite correlation values")
  461. if logger:
  462. logger.summary.add_computed(f"Subject-averaged correlations: {sub}")
  465. def plot_2x2_subject_correlations(regressors_dict, subjects, figures_path, exclude_low_level=False, logger=None):
  466. """
  467. Plot a 2x2 grid of subject-averaged correlation matrices.
  469. Creates a compact visualization showing the lower triangle of each subject's
  470. averaged correlation matrix in a 2x2 layout with a shared red-white-blue colorbar.
  472. Only includes 8 Shinobi task conditions (DOWN, HIT, HealthGain, HealthLoss,
  473. JUMP, Kill, LEFT, RIGHT), 3 psychophysics confounds (luminance,
  474. optical_flow, audio_envelope), and button press confounds (button_presses_count).
  475. Correlation values are displayed in each cell with 2 decimal places.
  477. Args:
  478. regressors_dict: Dictionary containing correlation matrices
  479. subjects: List of subjects to process (should be 4 subjects for 2x2 grid)
  480. figures_path: Path to save figures
  481. exclude_low_level: Exclude low-level confounds from design matrix
  482. logger: AnalysisLogger instance
  483. """
  484. output_dir = op.join(figures_path, 'design_matrices')
  485. os.makedirs(output_dir, exist_ok=True)
  487. # Add suffix to filename if low-level confounds are included
  488. suffix = "" if exclude_low_level else "_low-level"
  490. if logger:
  491. logger.info(f"Plotting 2x2 grid for {len(subjects)} subjects")
  493. # Define which regressors to include and their order
  494. # Match order from descriptive_annotations: RIGHT, LEFT, DOWN, HIT, JUMP, Kill, HealthLoss
  495. # Then add low-level features
  496. shinobi_conditions = ['RIGHT', 'LEFT', 'DOWN', 'HIT', 'JUMP', 'Kill', 'HealthLoss']
  497. # Psychophysics confounds (internal names)
  498. psychophysics_confounds = ['luminance', 'optical_flow', 'audio_envelope']
  499. # Button press confounds
  500. button_confounds = ['button_presses_count']
  501. # Combined list in desired order
  502. regressors_to_include = shinobi_conditions + psychophysics_confounds + button_confounds
  504. # Display names for cleaner labels (all should be displayed)
  505. display_names = {
  506. 'RIGHT': 'RIGHT',
  507. 'LEFT': 'LEFT',
  508. 'DOWN': 'DOWN',
  509. 'HIT': 'HIT',
  510. 'JUMP': 'JUMP',
  511. 'Kill': 'Kill',
  512. 'HealthLoss': 'HealthLoss',
  513. 'luminance': 'Luminance',
  514. 'optical_flow': 'Optical flow',
  515. 'audio_envelope': 'Audio envelope',
  516. 'button_presses_count': 'Button press'
  517. }
  519. # Prepare averaged correlation matrices for each subject
  520. subject_corr_mats = {}
  521. all_values = [] # To compute global vmin/vmax
  523. for sub in subjects:
  524. # Collect all correlation matrices for this subject
  525. subj_corrs = []
  526. for idx, corr_mat in enumerate(regressors_dict['corr_mat']):
  527. if regressors_dict['subject'][idx] == sub:
  528. subj_corrs.append(corr_mat)
  530. if not subj_corrs:
  531. if logger:
  532. logger.warning(f"No correlation matrices found for {sub}")
  533. continue
  535. # Average across runs
  536. averaged_corr_mat = pd.concat(subj_corrs, axis=0).groupby(level=0).mean()
  538. # Filter to keep only specified regressors (in the specified order)
  539. available_regressors = [r for r in regressors_to_include if r in averaged_corr_mat.index]
  540. if len(available_regressors) == 0:
  541. if logger:
  542. logger.warning(f"No target regressors found for {sub}")
  543. logger.warning(f"Available columns: {list(averaged_corr_mat.columns)}")
  544. continue
  546. # Reorder to match desired order
  547. averaged_corr_mat = averaged_corr_mat.loc[available_regressors, available_regressors]
  548. subject_corr_mats[sub] = averaged_corr_mat
  550. if logger:
  551. logger.info(f"{sub}: Found {len(available_regressors)} regressors: {available_regressors}")
  553. # Collect values from lower triangle for global color scale
  554. mask_lower = np.tril(np.ones_like(averaged_corr_mat, dtype=bool), k=-1)
  555. all_values.extend(averaged_corr_mat.values[mask_lower])
  557. if not subject_corr_mats:
  558. if logger:
  559. logger.error("No correlation matrices to plot")
  560. return
  562. # Compute and save pairwise correlation statistics table (all regressors including low-level)
  563. stats_df = compute_pairwise_correlation_stats(subject_corr_mats, regressors_to_include)
  564. save_correlation_stats_table(stats_df, config.TABLE_PATH, suffix, logger)
  566. # Print key pairs to console for quick manuscript reference
  567. key_pairs = [
  568. ('HIT', 'Kill'), ('DOWN', 'HIT'), ('DOWN', 'Kill'),
  569. ('JUMP', 'HIT'), ('RIGHT', 'LEFT'),
  570. ]
  571. print("\nFig 5 – Pairwise Pearson r between Shinobi conditions (mean across runs, per subject):")
  572. header = f"{'Pair':<25}" + "".join(f"{s:>12}" for s in subject_corr_mats.keys())
  573. header += f"{'mean_r':>10} {'range':>16}"
  574. print(header)
  575. for pair in stats_df.index:
  576. if pair in stats_df.index:
  577. row = stats_df.loc[pair]
  578. subj_vals = "".join(f"{row.get(s, float('nan')):>12.3f}" for s in subject_corr_mats.keys())
  579. label = f"{pair[0]}–{pair[1]}"
  580. print(f"{label:<25}{subj_vals}{row['mean_r']:>10.3f} [{row['min_r']:.3f}, {row['max_r']:.3f}]")
  582. # Compute global color scale
  583. vmin = np.min(all_values)
  584. vmax = np.max(all_values)
  585. abs_max = max(abs(vmin), abs(vmax))
  587. # Create 2x2 figure - compact layout
  588. # Top row x-labels will extend into empty upper triangle of bottom row
  589. fig, axes = plt.subplots(2, 2, figsize=(28, 26))
  590. fig.subplots_adjust(hspace=0.10, wspace=0.15)
  591. axes = axes.flatten()
  593. # Plot bottom row first (indices 2, 3), then top row (indices 0, 1)
  594. # This ensures top row x-labels are drawn on top of bottom row's empty space
  595. plot_order = [2, 3, 0, 1]
  597. # Plot each subject in a subplot
  598. for plot_idx in plot_order:
  599. sub_idx = plot_idx
  600. if sub_idx >= len(subjects[:4]):
  601. axes[plot_idx].set_visible(False)
  602. continue
  604. sub = subjects[sub_idx]
  605. ax = axes[plot_idx]
  607. # Set higher zorder for top row so their labels appear on top
  608. if plot_idx in [0, 1]:
  609. ax.set_zorder(10)
  611. if sub not in subject_corr_mats:
  612. ax.set_visible(False)
  613. continue
  615. corr_mat = subject_corr_mats[sub]
  617. # Create mask for upper triangle (including diagonal)
  618. mask = np.triu(np.ones_like(corr_mat, dtype=bool))
  620. # Plot heatmap with RdBu_r colormap (red-white-blue)
  621. sns.heatmap(
  622. corr_mat,
  623. mask=mask,
  624. center=0,
  625. vmin=-abs_max,
  626. vmax=abs_max,
  627. cmap='RdBu_r',
  628. square=True,
  629. linewidths=0.5,
  630. cbar=False, # We'll add a shared colorbar later
  631. ax=ax,
  632. xticklabels=True,
  633. yticklabels=True,
  634. annot=True, # Show correlation values in squares
  635. fmt='.2f', # Two decimal places
  636. annot_kws={'fontsize': 16} # Font size for annotations (doubled from 8)
  637. )
  639. # Make axes background transparent so top row x-labels show through
  640. # bottom row's masked (empty) upper triangle
  641. ax.set_facecolor('none')
  642. ax.patch.set_alpha(0)
  644. # Subtitle (subject name) - not bold, positioned near top of matrix
  645. ax.text(0.5, 0.87, f'{sub}', transform=ax.transAxes,
  646. fontsize=32, fontweight='normal', ha='center', va='top')
  648. # Get current tick labels and create display names list
  649. current_labels = [t.get_text() for t in ax.get_xticklabels()]
  650. display_labels = [display_names.get(lbl, lbl) for lbl in current_labels]
  652. # For lower triangle heatmap: hide first y-label and last x-label (diagonal cells)
  653. x_display = display_labels.copy()
  654. y_display = display_labels.copy()
  655. if len(x_display) > 0:
  656. x_display[-1] = '' # Last column has no visible data
  657. if len(y_display) > 0:
  658. y_display[0] = '' # First row has no visible data
  660. # Apply orange bold styling to all tick labels
  661. # ha='center' aligns rotated x-labels with their ticks
  662. ax.set_xticklabels(x_display, rotation=90, ha='center', va='top', fontsize=18,
  663. fontweight='bold', color=SHINOBI_COLOR)
  664. ax.set_yticklabels(y_display, rotation=0, ha='right', va='center', fontsize=18,
  665. fontweight='bold', color=SHINOBI_COLOR)
  667. # Ensure tick labels are not clipped by subplot boundaries
  668. ax.tick_params(axis='x', which='both', pad=2)
  669. ax.tick_params(axis='y', which='both', pad=2)
  670. for label in ax.get_xticklabels() + ax.get_yticklabels():
  671. label.set_clip_on(False)
  673. # Hide unused subplots if less than 4 subjects
  674. for idx in range(len(subjects[:4]), 4):
  675. axes[idx].set_visible(False)
  677. # Add shared colorbar on the right (size of one subplot, vertically centered)
  678. fig.subplots_adjust(right=0.92)
  679. # Calculate vertical center and height to match one subplot
  680. subplot_height = 0.35 # Approximate height of one subplot in figure coordinates
  681. vertical_center = 0.5 # Center of figure
  682. cbar_bottom = vertical_center - (subplot_height / 2)
  683. cbar_ax = fig.add_axes([0.94, cbar_bottom, 0.02, subplot_height])
  684. sm = plt.cm.ScalarMappable(
  685. cmap='RdBu_r',
  686. norm=plt.Normalize(vmin=-abs_max, vmax=abs_max)
  687. )
  688. sm.set_array([])
  689. cbar = fig.colorbar(sm, cax=cbar_ax)
  691. # Set colorbar tick label size (doubled from default)
  692. cbar.ax.tick_params(labelsize=20)
  694. # Add "Mean Pearson r" label on the right side of the colorbar (vertical)
  695. cbar.set_label('Mean Pearson r', fontsize=24, rotation=270, labelpad=30)
  697. # Save main panel directly to figures_path (not subdirectory)
  698. fig_fname = op.join(figures_path, f'regressor_correlations_panel{suffix}.png')
  699. plt.savefig(fig_fname, dpi=150, bbox_inches='tight')
  700. plt.close()
  702. if logger:
  703. logger.info(f"Saved 2x2 correlation plot to {fig_fname}")
  704. logger.summary.add_computed("2x2 subject correlation grid")
  707. def compute_pairwise_correlation_stats(
  708. subject_corr_mats: Dict[str, pd.DataFrame],
  709. conditions: List[str],
  710. ) -> pd.DataFrame:
  711. """
  712. Compute per-subject and summary statistics for all pairwise correlations
  713. between Shinobi conditions.
  715. For each unique condition pair (lower triangle), reports the per-subject
  716. mean Pearson r (already averaged across runs) and the range across subjects.
  718. Args:
  719. subject_corr_mats: Dict mapping subject ID -> run-averaged correlation DataFrame.
  720. conditions: Ordered list of condition names to include.
  722. Returns:
  723. DataFrame with rows = (condition_A, condition_B) pairs and
  724. columns = one column per subject + mean_r, min_r, max_r.
  725. """
  726. subjects = list(subject_corr_mats.keys())
  727. rows = []
  729. for i, cond_a in enumerate(conditions):
  730. for cond_b in conditions[i + 1:]:
  731. row: Dict[str, Any] = {'condition_A': cond_a, 'condition_B': cond_b}
  732. values = []
  733. for sub in subjects:
  734. mat = subject_corr_mats[sub]
  735. r = mat.loc[cond_a, cond_b] if (cond_a in mat.index and cond_b in mat.index) else np.nan
  736. row[sub] = round(float(r), 3) if not np.isnan(r) else np.nan
  737. if not np.isnan(r):
  738. values.append(r)
  739. row['mean_r'] = round(np.mean(values), 3) if values else np.nan
  740. row['min_r'] = round(np.min(values), 3) if values else np.nan
  741. row['max_r'] = round(np.max(values), 3) if values else np.nan
  742. rows.append(row)
  744. df = pd.DataFrame(rows).set_index(['condition_A', 'condition_B'])
  745. return df
  748. def save_correlation_stats_table(
  749. stats_df: pd.DataFrame,
  750. output_dir: str,
  751. suffix: str,
  752. logger: Optional[Any] = None,
  753. ) -> List[str]:
  754. """
  755. Save pairwise correlation statistics as CSV and LaTeX.
  757. Files written:
  758. - fig5_pairwise_correlation_stats{suffix}.csv
  759. - fig5_pairwise_correlation_stats{suffix}.tex
  761. Args:
  762. stats_df: Output of compute_pairwise_correlation_stats().
  763. output_dir: Directory to save tables.
  764. suffix: Filename suffix (e.g. '' or '_low-level').
  765. logger: AnalysisLogger instance.
  767. Returns:
  768. List of saved file paths.
  769. """
  770. os.makedirs(output_dir, exist_ok=True)
  771. stem = f"fig5_pairwise_correlation_stats{suffix}"
  772. csv_path = op.join(output_dir, f"{stem}.csv")
  773. tex_path = op.join(output_dir, f"{stem}.tex")
  775. stats_df.to_csv(csv_path)
  776. stats_df.to_latex(tex_path, float_format="%.3f", na_rep="—")
  778. if logger:
  779. logger.info(f"Pairwise correlation stats saved to {csv_path}")
  781. return [csv_path, tex_path]
  784. def main():
  785. """Main execution function."""
  786. parser = setup_argparse()
  787. args = parser.parse_args()
  789. # Setup logging
  790. verbosity_map = {0: logging.WARNING, 1: logging.INFO, 2: logging.DEBUG}
  791. verbosity_level = verbosity_map.get(args.verbose, logging.DEBUG)
  792. logger = AnalysisLogger(
  793. log_name="regressor_correlations",
  794. verbosity=verbosity_level,
  795. log_dir=args.log_dir
  796. )
  798. # Configuration
  799. figures_path = args.figures_path
  801. path_to_data = args.data_path
  802. subjects = [args.subject] if args.subject else config.subjects
  804. logger.info(f"Processing subjects: {subjects}")
  805. logger.info(f"Data path: {path_to_data}")
  806. logger.info(f"Figures path: {figures_path}")
  808. # Path for pickle file
  809. regressors_dict_fname = op.join(
  810. path_to_data, "processed", "regressors_dict.pkl"
  811. )
  813. # Build or load design matrices
  814. if args.skip_generation and op.exists(regressors_dict_fname):
  815. logger.info(f"Loading existing regressors from {regressors_dict_fname}")
  816. with open(regressors_dict_fname, "rb") as f:
  817. regressors_dict = pickle.load(f)
  818. logger.summary.add_skipped("Design matrix generation (loaded from pickle)")
  819. else:
  820. logger.info("Building design matrices...")
  821. if not args.exclude_low_level:
  822. logger.info("Including low-level confounds (psychophysics and button presses)")
  823. regressors_dict = build_design_matrices(
  824. subjects, path_to_data, figures_path,
  825. exclude_low_level=args.exclude_low_level,
  826. logger=logger
  827. )
  829. # Save to pickle
  830. os.makedirs(op.dirname(regressors_dict_fname), exist_ok=True)
  831. logger.info(f"Saving regressors to {regressors_dict_fname}")
  832. with open(regressors_dict_fname, "wb") as f:
  833. pickle.dump(regressors_dict, f)
  835. # Compute correlation matrices (needed for 2x2 plot)
  836. logger.info("Computing correlation matrices...")
  837. regressors_dict['corr_mat'] = []
  838. for run_idx, run in enumerate(regressors_dict['regressors']):
  839. # Compute correlation matrix (excluding constant)
  840. corr = run.corr()
  841. if 'constant' in corr.index:
  842. corr = corr.drop(index='constant').drop(columns='constant')
  843. regressors_dict['corr_mat'].append(corr)
  845. # Generate 2x2 subject correlation grid (Shinobi conditions + 3 psychophysics confounds only)
  846. logger.info("Plotting 2x2 subject correlation grid...")
  847. plot_2x2_subject_correlations(regressors_dict, subjects, figures_path, exclude_low_level=args.exclude_low_level, logger=logger)
  849. logger.info("Done!")
  850. logger.close()
  853. if __name__ == "__main__":
  854. main()

viz_regressor_correlations.py at commit 0f205fc, under MIT · at the source

Overview

Authors: Yann Harel1,2, Basile Pinsard2, Julie Boyle2, Valentina Borghesani3, Maximilien Le Clei2, Paul-Henri Mignot4, Marie St-Laurent2, Karim Jerbi1,5,6, Lune Bellec1,2,5
ORCID iDs: Yann Harel, Basile Pinsard, Julie Boyle, Valentina Borghesani, Maximilien Le Clei, Marie St-Laurent, Karim Jerbi, Lune Bellec
  1. Department of Psychology, University of Montréal, Montréal, Canada
  2. Centre de Recherche de l’Institut Universitaire de Gériatrie de Montréal (CRIUGM), Montréal, Canada
  3. Swiss National Centre of Competence in Research, University of Geneva, Geneva, Switzerland
  4. IMT Atlantique, Brest, France
  5. Mila – Quebec AI Institute, Montréal, Canada
  6. UNIQUE – Union Neurosciences et Intelligence Artificielle – Québec, Québec, Canada
Institutions: Institut Universitaire de Gériatrie de Montréal (Canada); Université de Montréal (Canada); University of Geneva (Switzerland); IMT Atlantique (France); Mila - Quebec Artificial Intelligence Institute (Canada)
Journal: Imaging neuroscience (Cambridge, Mass.), volume 4, article IMAG.a.1256
Dates: received 11 June 2025; accepted 24 April 2026; published online 1 June 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1162/imag.a.1256 · PMID 42238756 · PMCID PMC13228873 · OpenAlex W4388002190
Open access: diamond, a free copy (OpenAlex)
Preprint: doi:10.31234/osf.io/uakq9
Status: code verified
Categories: fMRI (modality), human (organism)
Methods: Connectivity, Statistics, Machine learning, Preprocessing, fMRI & imaging
Keywords: naturalistic neuroimaging, video games, automated annotation, fMRI, cognitive neuroscience
Topic: Educational Games and Gamification (Developmental and Educational Psychology, Psychology), according to OpenAlex
Funding: Fonds de Recherche du Québec - Santé; Natural Sciences and Engineering Research Council of Canada; Canada Research Chairs; Courtois Foundation
Citations: cited by 1 paper (Europe PMC); 101 references in the paper

Abstract

In recent years, videogames have gathered interest in cognitive neuroscience for their potential to study cognition in dynamical and naturalistic contexts. Yet, the complexity of game environments often challenges traditional modeling approaches, and current annotation methods—typically manual or based on modified games—remain labor-intensive and limited in scope. Here, we introduce a flexible and scalable framework using the gym-retro Python library to emulate a classic action-platformer, Shinobi III: Return of the Ninja Master, and automatically annotate gameplay events directly from the game’s memory states. This setup enables the identification of both player actions (e.g., jumping, hitting) and feedback events (e.g., killing an enemy, being hit), without modifying the game. Four individuals played the videogame for a combined total of 32 h (>7 h each) while undergoing functional magnetic resonance imaging (fMRI). Resulting activation maps revealed distributed engagement of visual, motor, executive, and limbic systems, consistent with the cognitive demands of gameplay. Within-participant reproducibility of brain responses across sessions was robust across event types (r ≈ .25–.55), with some consistency observed even for rarer events like HealthLoss. Between-participant correlations were notably lower, reflecting participant-specific neural signatures. Multivoxel pattern analysis showed that brain responses to different in-game events were highly discriminable, with classification accuracy typically around or above 90%, though occasionally dropping to ~40% for less frequent events. These findings demonstrate that automated emulator-based annotations enable robust, interpretable, and scalable mapping of naturalistic cognitive processes using commercial videogames.

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

Repositories

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

courtois-neuromod/shinobi_fmri

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 0f205fc994d0625c45e9d38c518fea009a589f5f, 15 April 2026
Languages: Python (48), Shell (11), Jupyter (8)
Size: 89 files, 67 scripts
Software Heritage: not archived
Found in: “Data and Code Availability”
Holds: README, license file, environment (requirements.txt, setup.py), tests, documentation, 8 notebooks
Not found: CITATION.cff, continuous integration
Tools: NumPy (34 files), Matplotlib (25 files), pandas (25 files), seaborn (18 files), NiBabel (15 files), Nilearn (15 files), SciPy (9 files), Pillow (4 files), scikit-learn (3 files), PyTorch (1 file), statannotations (1 file), statsmodels (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
69 files
At the source: github.com/courtois-neuromod/shinobi_fmri

Zenodo 15628556

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Data and Code Availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: Matplotlib (21 files), NumPy (20 files), pandas (17 files), Nilearn (14 files), NiBabel (13 files), seaborn (9 files), SciPy (4 files), Pillow (2 files), scikit-learn (2 files), DataLad (1 file), PyTorch (1 file), statannotations (1 file), statsmodels (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers (HTTP 200)
  • 27 September 2026: the link answers (HTTP 200)
55 files
At the source: doi.org/10.5281/zenodo.15628556

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:

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

All datasets used in this study are part of the CNeuroMod dataset (https://www.cneuromod.ca/). The code developed for this research is publicly available on GitHub (https://github.com/courtois-neuromod/shinobi_fmri) and archived on Zenodo for long-term preservation (https://doi.org/10.5281/zenodo.15628556). Processed datasets used to generate the tables and figures in this manuscript are provided as Supplementary Material (https://doi.org/10.1162/IMAG.a.1256#supplementary-data) accompanying the paper.

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

Recorded: type, language, journal, volume, pages, dates, 9 authors, 5 keywords, 4 funders, 84 references.

Cite

This paper

Harel, Y., Pinsard, B., Boyle, J., Borghesani, V., Le Clei, M., Mignot, P.-H., St-Laurent, M., Jerbi, K., & Bellec, L. (2026). Gamer in the scanner: Event-related analysis of fMRI activity during retro videogame play guided by automated annotations of game content. Imaging neuroscience (Cambridge, Mass.), 4, IMAG.a.1256. https://doi.org/10.1162/imag.a.1256

BibTeX

@article{harel2026gamer,
author = {Harel, Yann and Pinsard, Basile and Boyle, Julie and Borghesani, Valentina and Le Clei, Maximilien and Mignot, Paul-Henri and St-Laurent, Marie and Jerbi, Karim and Bellec, Lune},
title = {{Gamer in the scanner: Event-related analysis of fMRI activity during retro videogame play guided by automated annotations of game content}},
journal = {Imaging neuroscience (Cambridge, Mass.)},
year = {2026},
month = jun,
volume = {4},
pages = {IMAG.a.1256},
publisher = {MIT Press},
issn = {2837-6056},
doi = {10.1162/imag.a.1256},
url = {https://doi.org/10.1162/imag.a.1256},
pmid = {42238756},
pmcid = {PMC13228873}
}

RIS

TY - JOUR
AU - Harel, Yann
AU - Pinsard, Basile
AU - Boyle, Julie
AU - Borghesani, Valentina
AU - Le Clei, Maximilien
AU - Mignot, Paul-Henri
AU - St-Laurent, Marie
AU - Jerbi, Karim
AU - Bellec, Lune
TI - Gamer in the scanner: Event-related analysis of fMRI activity during retro videogame play guided by automated annotations of game content
T2 - Imaging neuroscience (Cambridge, Mass.)
J2 - Imaging Neurosci (Camb)
PY - 2026
DA - 2026/06/01
VL - 4
SP - IMAG.a.1256
SN - 2837-6056
PB - MIT Press
DO - 10.1162/imag.a.1256
UR - https://doi.org/10.1162/imag.a.1256
LA - en
ER -

CSL-JSON

{
"id": "10.1162/imag.a.1256",
"type": "article-journal",
"title": "Gamer in the scanner: Event-related analysis of fMRI activity during retro videogame play guided by automated annotations of game content",
"container-title": "Imaging neuroscience (Cambridge, Mass.)",
"author": [
{
"family": "Harel",
"given": "Yann"
},
{
"family": "Pinsard",
"given": "Basile"
},
{
"family": "Boyle",
"given": "Julie"
},
{
"family": "Borghesani",
"given": "Valentina"
},
{
"family": "Le Clei",
"given": "Maximilien"
},
{
"family": "Mignot",
"given": "Paul-Henri"
},
{
"family": "St-Laurent",
"given": "Marie"
},
{
"family": "Jerbi",
"given": "Karim"
},
{
"family": "Bellec",
"given": "Lune"
}
],
"container-title-short": "Imaging Neurosci (Camb)",
"volume": "4",
"page": "IMAG.a.1256",
"DOI": "10.1162/imag.a.1256",
"PMID": "42238756",
"PMCID": "PMC13228873",
"ISSN": "2837-6056",
"publisher": "MIT Press",
"URL": "https://doi.org/10.1162/imag.a.1256",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
1
]
]
}
}

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.1162/imag.a.1286 [code]
Behavioral imitation with artificial neural networks leads to personalized models of brain dynamics during videogame play.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Nilearn, Pillow, statsmodels, 8 other tools, fMRI, 14 references
[2] doi:10.21203/rs.3.rs-9326213/v1 [code]
Multi-task fMRI outperforms resting-state fMRI for revealing task-invariant organization of the human brain
Journal: Research Square (preprint)
In common: statannotations, Nilearn, Pillow, 8 other tools, fMRI, 2 references
[3] 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, NiBabel, 7 other tools, 4 references
[4] doi:10.1162/imag.a.1309 [code]
Probing the content of semantic representations in body-selective regions.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Pillow, statsmodels, NiBabel, 7 other tools, 4 references
[5] doi:10.1162/nol.a.271 [code]
Compositional Complexity in Text and Images.
Journal: Neurobiology of language (Cambridge, Mass.)
In common: Nilearn, Pillow, NiBabel, 7 other tools, fMRI, 4 references
[6] doi:10.7554/elife.107933 [code]
Modality-agnostic decoding of vision and language from fMRI.
Journal: eLife
In common: Nilearn, Pillow, statsmodels, 8 other tools, fMRI, 2 references
[7] doi:10.64898/2026.08.18.26360725 [code]
Temporal pole blurring in hippocampal sclerosis reflects seizure-disrupted myelination
Journal: medRxiv (preprint)
In common: statannotations, Nilearn, Pillow, 9 other tools
[8] doi:10.1007/s00234-026-04103-8 [code]
Enhanced detection of subtle cortical abnormalities in focal epilepsy using 7 T MRI surface-based models and graph neural networks.
Journal: Neuroradiology
In common: statannotations, Nilearn, Pillow, 9 other tools
[9] doi:10.1038/s41597-026-07248-6 [code]
A large-scale fMRI dataset for vision-language semantic association.
Journal: Scientific data
In common: Nilearn, Pillow, NiBabel, 6 other tools, fMRI, 3 references
[10] 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: statannotations, Nilearn, statsmodels, 6 other tools, fMRI, 2 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.