OSCR

Learning regularities in noise engages both neural predictive activity and representational changes.

Code ↔ Paper

10 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 10 matches · 2 of them tie a paragraph to a whole file, not to given lines: weak matches, whose lines are not tinted
  1. [1] § Methods › Representational similarity analysis ↔ base.py, lines 114–170 · score 0.81 · Ledoit Wolf, covariance matrix, Mahalanobis distance, OLS, shrinkage, residuals
  2. [2] § Methods › MEG recordings and preprocessing ↔ 02_preprocessing/save_epochs.py, lines 56–115 · score 0.74 · filtered raw, unfiltered, component, ECG, preprocessing, EOG
  3. [3] § Methods › MEG recordings and preprocessing ↔ 02_preprocessing/save_reordered_epochs_practice.py, lines 74–154 · score 0.74 · filtered raw, artifacts, unfiltered, component, ECG, preprocessing
  4. [4] § Methods › Decoding ↔ 04_source/time_gen/decode_htc.py, lines 42–171 · score 0.68 · standard scaler, logistic regression, source space, pipeline, decoding, classifier
  5. [5] § Methods › Decoding ↔ base.py, lines 193–208 · score 0.64 · standard scaler, logistic regression, stratified, folding, pipeline, classifier
  6. [6] § Methods › Representational similarity analysis ↔ base.py, lines 446–526 · score 0.62 · Ledoit Wolf, Cross validation, class, covariance, distance, training
  7. [7] § Methods › Source reconstruction ↔ config.py, the whole file · a weak match · score 0.58 · central executive, dorsal attention, limbic, salience, Freesurfer, thalamus
  8. [8] § Results › Distributed predictive activity in the sensorimotor, dorsal attention, central executive, and default mode networks ↔ config.py, the whole file · a weak match · score 0.57 · central executive, dorsal attention, limbic, salience, thalamus, sensorimotor
  9. [9] § Methods › Source reconstruction ↔ 04_source/schaefer_to_destrieux.py, lines 1–22 · score 0.57 · FreeSurfer, Schaefer, parcellate, atlas, brain, networks
  10. [10] § Methods › Non-linear temporal modeling ↔ 05_gam/rsa_tables.qmd, lines 199–240 · score 0.54 · random intercept, random smooth, linear, models, block

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 · 924 lines · 35 KB · no license · 3 matches

  1. import os
  2. import os.path as op
  3. import numpy as np
  4. from mne.stats import permutation_cluster_1samp_test
  5. from sklearn.pipeline import make_pipeline
  6. from mne.decoding import SlidingEstimator
  7. from sklearn.model_selection import StratifiedKFold
  8. from sklearn.preprocessing import StandardScaler
  9. from sklearn.linear_model import LogisticRegressionCV
  11. def ensure_dir(path):
  12. if not os.path.exists(path):
  13. os.makedirs(path, exist_ok=True)
  15. def ensured(path):
  16. if not os.path.exists(path):
  17. os.makedirs(path, exist_ok=True)
  18. return path
  20. def decod_stats(X, jobs):
  21. """Statistical test applied across subjects for Decoding"""
  22. # check input
  23. if not isinstance(X, np.ndarray):
  24. X = np.array(X)
  26. X = X.astype(np.float64)
  28. # stats function report p_value for each cluster
  29. T_obs_, clusters, p_values, _ = permutation_cluster_1samp_test(
  30. X, out_type='mask', n_permutations=2**12, n_jobs=jobs,
  31. verbose=False)
  33. # format p_values to get same dimensionality as X
  34. p_values_ = np.ones_like(X[0]).T
  35. for cluster, pval in zip(clusters, p_values):
  36. p_values_[cluster] = pval
  38. return np.squeeze(p_values_)
  40. def gat_stats(X, jobs):
  41. """Statistical test applied across subjects for Temporal Generalization"""
  42. from mne.stats import spatio_temporal_cluster_1samp_test
  43. # check input
  44. X = np.array(X)
  45. X = X[:, :, None] if X.ndim == 2 else X
  47. # stats function report p_value for each cluster
  48. T_obs_, clusters, p_values, _ = spatio_temporal_cluster_1samp_test(
  49. X, out_type='mask',
  50. n_permutations=2**10, n_jobs=jobs, verbose=True)
  52. # format p_values to get same dimensionality as X
  53. p_values_ = np.ones_like(X[0]).T
  54. for cluster, pval in zip(clusters, p_values):
  55. p_values_[cluster.T] = pval
  57. return np.squeeze(p_values_).T
  59. def gat_t1samp(X):
  60. from scipy.stats import ttest_1samp
  61. X = np.array(X)
  62. X = X[:, :, None] if X.ndim == 2 else X
  63. t_values = np.zeros_like(X[0])
  64. for itime in range(X.shape[1]):
  65. t_values[itime] = ttest_1samp(X[:, itime], 0)[0]
  66. return t_values
  68. def do_pca(epochs):
  69. import mne
  70. from mne.decoding import UnsupervisedSpatialFilter
  71. from sklearn.decomposition import PCA
  72. n_component = 30
  73. pca = UnsupervisedSpatialFilter(PCA(n_component), average=False)
  74. pca_data = pca.fit_transform(epochs.get_data())
  75. sampling_freq = epochs.info['sfreq']
  76. info = mne.create_info(n_component, ch_types='mag', sfreq=sampling_freq)
  77. all_epochs = mne.EpochsArray(pca_data, info = info, events=epochs.events, event_id=epochs.event_id)
  78. return all_epochs
  80. def get_sequence(behav_dir):
  81. """Get the sequence of a subject from the behavioral file."""
  82. behav_files = [f for f in os.listdir(behav_dir) if (not f.startswith('.') and ('_eASRT_Epoch_' in f))]
  83. behav = open(op.join(behav_dir, behav_files[0]), 'r')
  84. lines = behav.readlines()
  85. column_names = lines[0].split()
  86. sequence = list()
  87. for line in lines[1:]:
  88. trialtype = int(line.split()[column_names.index('trialtype')])
  89. if trialtype == 1:
  90. sequence.append(int(line.split()[column_names.index('position')]))
  91. if len(sequence) == 4:
  92. break
  93. return sequence
  95. def get_random_low(behav_dir):
  96. behav_files = [f for f in os.listdir(behav_dir) if (not f.startswith('.') and ('_eASRT_Epoch_' in f))]
  97. behav = open(op.join(behav_dir, behav_files[0]), 'r')
  98. lines = behav.readlines()
  99. column_names = lines[0].split()
  100. rdm_low = list()
  101. for iline, line in enumerate(lines[1:]):
  102. triplet = int(line.split()[column_names.index('triplet')])
  103. if triplet == 34:
  104. first = line.split()[column_names.index('position')]
  105. second = lines[iline-2].split()[column_names.index('position')]
  106. pair = first + second
  107. if pair not in rdm_low:
  108. # print(pair)
  109. rdm_low.append(pair)
  110. # if len(rdm_low) == 3:
  111. # break
  112. return rdm_low
  114. def get_rdm(epoch, behav):
  115. from scipy.spatial.distance import pdist, squareform
  116. import scipy.stats
  117. import statsmodels.api as sm
  118. # from tqdm.auto import tqdm
  119. from sklearn.covariance import LedoitWolf
  120. import pandas as pd
  121. # Prepare the design matrix
  122. ntrials = len(epoch)
  123. nconditions = 4
  124. design_matrix = np.zeros((ntrials, nconditions))
  126. if type(behav) == pd.core.frame.DataFrame:
  127. y = behav["positions"]
  128. else:
  129. y = behav
  131. for icondi, condi in enumerate(y):
  132. # assert isinstance(condi, np.int64)
  133. design_matrix[icondi, condi-1] = 1
  134. assert np.sum(design_matrix.sum(axis=1) == 1) == len(epoch)
  136. meg_data_V = epoch
  137. _, nchs, ntimes = meg_data_V.shape
  138. meg_data_V = scipy.stats.zscore(meg_data_V, axis=0)
  140. coefs = np.zeros((nconditions, nchs, ntimes))
  141. resids = np.zeros_like(meg_data_V)
  142. # for ich in tqdm(range(nchs)):
  143. for ich in range(nchs):
  144. for itime in range(ntimes):
  145. y = meg_data_V[:, ich, itime]
  147. model = sm.OLS(endog=y, exog=design_matrix, missing="raise")
  148. results = model.fit()
  150. coefs[:, ich, itime] = results.params # (4, 248, 163)
  151. resids[:, ich, itime] = results.resid # (ntrials, 248, 163)
  153. # Calculate pairwise mahalanobis distance between regression coefficients
  154. rdm_times = np.zeros((nconditions, nconditions, ntimes))
  155. for itime in range(ntimes):
  156. response = coefs[:, :, itime] # (4, 248)
  157. residuals = resids[:, :, itime] # (51, 248)
  159. # Estimate covariance from residuals
  160. lw_shrinkage = LedoitWolf(assume_centered=True)
  161. cov = lw_shrinkage.fit(residuals)
  163. # Compute pairwise mahalanobis distances
  164. VI = np.linalg.inv(cov.covariance_) # inverse of covariance matrix needed for mahalonobis
  165. rdm = squareform(pdist(response, metric="mahalanobis", VI=VI))
  166. # rdm = squareform(pdist(response, metric="cosine"))
  167. assert ~np.isnan(rdm).any()
  168. rdm_times[:, :, itime] = rdm # rdm_times (4, 4, 163), rdm (4, 4)
  170. return rdm_times
  173. def get_inseq(sequence):
  174. """Get the pairs in the sequence."""
  175. # create list of possible pairs
  176. pairs_in_sequence = list()
  177. pairs_in_sequence.append(str(sequence[0]) + str(sequence[1]))
  178. pairs_in_sequence.append(str(sequence[1]) + str(sequence[2]))
  179. pairs_in_sequence.append(str(sequence[2]) + str(sequence[3]))
  180. pairs_in_sequence.append(str(sequence[3]) + str(sequence[0]))
  182. return pairs_in_sequence
  184. def print_proportions(subject, all_beh):
  185. #### get stimuli proportions
  186. print(f"############### {subject}")
  187. for i, sess in zip(range(5), ['prac', 'b1', 'b2', 'b3', 'b4']):
  188. print(f"{sess} ----------------------")
  189. unique, values = np.unique(all_beh[i].positions, return_counts=True)
  190. for un, val in zip(unique, values):
  191. print(un, round((val/np.sum(values)*100), 2))
  193. def make_predictions(X, y, folds, jobs, scoring, verbose):
  194. # set-up the classifier and cv structure
  195. clf = make_pipeline(StandardScaler(), LogisticRegressionCV(multi_class="ovr", max_iter=100000, solver='saga', random_state=42)) # use JAX maybe
  196. # clf = make_pipeline(StandardScaler(), SGDRegressor(loss="squared_error", max_iter=100000, random_state=42)) # use JAX maybe
  197. clf = SlidingEstimator(clf, scoring=scoring, n_jobs=jobs, verbose=verbose) # get time of one sample (slide), try with less jobs maybe ?
  198. cv = StratifiedKFold(folds, shuffle=True)
  200. pred = np.zeros((len(y), X.shape[-1]))
  201. pred_rock = np.zeros((len(y), X.shape[-1], len(set(y))))
  202. # there is only randoms in practice sessions
  203. for train, test in cv.split(X, y):
  204. clf.fit(X[train], y[train])
  205. pred[test] = np.array(clf.predict(X[test]))
  206. pred_rock[test] = np.array(clf.predict_proba(X[test]))
  208. return test, pred, pred_rock
  210. def get_volume_estimate_time_course(stcs, fwd, subject, subjects_dir):
  211. """Extracts time courses for each label from volume source estimates.
  212. Args:
  213. stcs (list of mne.VolSourceEstimate): List of volume source estimates.
  214. fwd (dict): Forward solution.
  215. subject (str): Subject name.
  216. subjects_dir (str): Path to SUBJECTS_DIR.
  218. Returns:
  219. dict: A dictionary with label names as keys and arrays of shape
  220. (n_epochs, n_vertices_in_label, n_times) as values.
  221. """
  222. import numpy as np
  223. from mne import get_volume_labels_from_src
  224. from tqdm.auto import tqdm
  226. labels = get_volume_labels_from_src(fwd['src'], subject, subjects_dir)
  227. vertices_info = dict()
  228. for label in labels:
  229. vertices_info[label.name] = len(label.vertices)
  230. # Initialize a dictionary to hold time courses for each label
  231. label_time_courses = {}
  232. # Loop through each STC (source time course) for each epoch
  233. for stc in tqdm(stcs):
  234. # Extract data from the STC
  235. stc_data = stc.data # shape: (n_vertices, n_times)
  236. # Loop through each label to extract the time course
  237. for ilabel, label in enumerate(labels):
  238. if ilabel >= len(stc.vertices):
  239. # If ilabel exceeds the number of vertex arrays, break the loop
  240. break
  241. # Get the vertices in the label
  242. label_vertices = np.intersect1d(stc.vertices[ilabel+2], label.vertices)
  243. if label_vertices.size == 0:
  244. continue
  245. # Get indices of these vertices in the STC data
  246. indices = np.searchsorted(stc.vertices[ilabel+2], label_vertices)
  247. # Extract the time courses for these vertices
  248. vertices_time_courses = stc_data[indices, :]
  249. # Store the time courses in the dictionary
  250. if label.name not in label_time_courses:
  251. label_time_courses[label.name] = []
  252. label_time_courses[label.name].append(vertices_time_courses)
  253. # Convert to numpy arrays
  254. for label in label_time_courses:
  255. label_time_courses[label] = np.array(label_time_courses[label]) # shape: (n_trials, n_vertices_in_label, n_times)
  256. return label_time_courses, vertices_info
  258. def get_labels_from_vol_src(src, subject, subjects_dir):
  259. from mne import Label
  260. from mne import get_volume_labels_from_aseg
  261. """Return a list of Label of segmented volumes included in the src space.
  263. Parameters
  264. ----------
  265. src : instance of SourceSpaces
  266. The source space containing the volume regions.
  267. %(subject)s
  268. subjects_dir : str
  269. Freesurfer folder of the subjects.
  271. Returns
  272. -------
  273. labels_aseg : list of Label
  274. List of Label of segmented volumes included in src space.
  275. """
  276. # from ..label import Label
  278. # Read the aseg file
  279. aseg_fname = op.join(subjects_dir, subject, "mri", "aseg.mgz")
  280. all_labels_aseg = get_volume_labels_from_aseg(aseg_fname, return_colors=True)
  282. if any(np.any(s["type"] != "vol") for s in src):
  283. raise ValueError("source spaces have to be of vol type")
  285. labels_aseg = list()
  286. for nr in range(len(src)):
  287. vertices = src[nr]["vertno"]
  289. pos = src[nr]["rr"][src[nr]["vertno"], :]
  290. roi_str = src[nr]["seg_name"]
  291. try:
  292. ind = all_labels_aseg[0].index(roi_str)
  293. color = np.array(all_labels_aseg[1][ind]) / 255
  294. except ValueError:
  295. pass
  297. if "left" in roi_str.lower():
  298. hemi = "lh"
  299. roi_str = roi_str.replace("Left-", "") + "-lh"
  300. elif "right" in roi_str.lower():
  301. hemi = "rh"
  302. roi_str = roi_str.replace("Right-", "") + "-rh"
  303. else:
  304. hemi = "both"
  306. label = Label(
  307. vertices=vertices,
  308. pos=pos,
  309. hemi=hemi,
  310. name=roi_str,
  311. color=color,
  312. subject=subject,
  313. )
  314. labels_aseg.append(label)
  316. return labels_aseg
  318. def get_volume_estimate_tc(stcs, fwd, offsets, subject, subjects_dir):
  319. """Extracts time courses for each label from volume source estimates."""
  320. import numpy as np
  321. from mne import get_volume_labels_from_src
  322. labels = get_volume_labels_from_src(fwd['src'], subject, subjects_dir)
  323. vertices_info = dict()
  324. for label in labels:
  325. vertices_info[label.name] = len(label.vertices)
  326. # Initialize a dictionary to hold time courses for each label
  327. label_time_courses = {}
  328. for stc in stcs:
  329. stc_data = stc.data # shape: (n_vertices, n_times)
  330. for ilabel, label in enumerate(labels):
  331. tc = stc_data[offsets[ilabel]:offsets[ilabel+1]]
  332. if label.name not in label_time_courses:
  333. label_time_courses[label.name] = []
  334. label_time_courses[label.name].append(tc)
  335. # Convert to numpy arrays
  336. for label in label_time_courses:
  337. label_time_courses[label] = np.array(label_time_courses[label]) # shape: (n_trials, n_vertices_in_label, n_times)
  338. return label_time_courses, vertices_info
  340. def rsync_files(source, destination, options=""):
  341. """Rsync files from source to destination with given options."""
  342. import subprocess
  343. try:
  344. # Construct the rsync command
  345. command = f"rsync {options} --progress --ignore-existing {source} {destination}"
  347. # Execute the command
  348. result = subprocess.run(command, shell=True, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
  350. # Decode and print the output and errors (if any)
  351. stdout = result.stdout.decode()
  352. stderr = result.stderr.decode()
  354. print(stdout)
  355. if stderr:
  356. print(f"Errors during rsync: {stderr}")
  358. print("Rsync operation completed successfully.")
  359. return stdout
  360. except subprocess.CalledProcessError as e:
  361. print(f"An error occurred: {e.stderr.decode()}")
  362. return None
  364. def get_in_out_seq(sequence, similarities, random_lows, analysis):
  365. """Get in-sequence and out-sequence similarity values based on the analysis type."""
  366. import numpy as np
  367. # create list of possible pairs
  368. pairs_in_sequence = list()
  369. pairs_in_sequence.append(str(sequence[0]) + str(sequence[1]))
  370. pairs_in_sequence.append(str(sequence[1]) + str(sequence[2]))
  371. pairs_in_sequence.append(str(sequence[2]) + str(sequence[3]))
  372. pairs_in_sequence.append(str(sequence[3]) + str(sequence[0]))
  373. in_seq, out_seq = [], []
  374. pairs = ['12', '13', '14', '23', '24', '34']
  375. rev_pairs = ['21', '31', '41', '32', '42', '43']
  376. if analysis == 'pat_high_rdm_high':
  377. for pair, rev_pair, pat_sim, rand_sim in zip(pairs, rev_pairs, similarities, random_lows):
  378. if ((pair in pairs_in_sequence) or (rev_pair in pairs_in_sequence)):
  379. in_seq.append(pat_sim)
  380. out_seq.append(rand_sim)
  381. elif analysis == 'pat_high_rdm_low':
  382. for pair, rev_pair, pat_sim, rand_sim in zip(pairs, rev_pairs, similarities, random_lows):
  383. if ((pair in pairs_in_sequence) or (rev_pair in pairs_in_sequence)):
  384. in_seq.append(pat_sim)
  385. else:
  386. out_seq.append(rand_sim)
  387. else:
  388. for pair, rev_pair, pat_sim, rand_sim in zip(pairs, rev_pairs, similarities, random_lows):
  389. if ((pair in pairs_in_sequence) or (rev_pair in pairs_in_sequence)):
  390. in_seq.append(pat_sim)
  391. else:
  392. out_seq.append(pat_sim)
  393. return np.array(in_seq), np.array(out_seq)
  395. def get_all_high_low(pattern_data, random_data, sequence, block=True, step=1):
  396. """
  397. Extracts high and low similarity sets from RDMs based on a stimulus sequence.
  399. Parameters:
  400. pattern_data: np.ndarray
  401. RDM for patterned stimuli:
  402. - block=True: (n_blocks, n_timepoints, n_items, n_items)
  403. - block=False: (n_epochs, n_timepoints, n_items, n_items)
  405. random_data: np.ndarray
  406. RDM for random stimuli (same shape as pattern_data).
  408. sequence: list[int]
  409. A list of 4 stimulus identifiers, e.g., [1, 2, 3, 4].
  411. block: bool (default=True)
  412. If True, treats data as block-based; else session-based (cv-style).
  414. Returns:
  415. high: np.ndarray
  416. Similarity values for pairs in the input sequence.
  418. low: np.ndarray
  419. Corresponding values from the random data (used as "low" set).
  420. """
  421. pair_indices = [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]
  422. pair_labels = ['12', '13', '14', '23', '24', '34']
  424. # Generate forward and reverse sequence-based pairs
  425. limit = 4 if step == 1 else 4 - step
  426. sequence_pairs = {f"{sequence[i]}{sequence[(i+step)%4]}" for i in range(limit)}
  427. sequence_pairs |= {p[::-1] for p in sequence_pairs}
  429. high, low = [], []
  431. for (i, j), label in zip(pair_indices, pair_labels):
  432. if block:
  433. pat_vals = pattern_data[:, :, i, j]
  434. rand_vals = random_data[:, :, i, j]
  435. else:
  436. pat_vals = np.array([pattern_data[epoch, :, i, j] for epoch in range(pattern_data.shape[0])])
  437. rand_vals = np.array([random_data[epoch, :, i, j] for epoch in range(random_data.shape[0])])
  439. if label in sequence_pairs:
  440. high.append(pat_vals)
  441. low.append(rand_vals)
  443. return np.array(high), np.array(low)
  446. def cv_mahalanobis_parallel(X, y, n_jobs=-1, n_splits=10, verbose=True, shuffle=True):
  447. """
  448. Parallelized Cross-validated Mahalanobis distances with tqdm_joblib and NaN safety.
  450. Parameters:
  451. X: ndarray (n_trials, n_channels, n_times)
  452. y: array-like (n_trials,) condition labels
  453. n_splits: int, number of cross-validation folds
  454. n_jobs: int, number of parallel jobs (default: -1 = all CPUs)
  455. verbose: bool, show progress bars
  457. Returns:
  458. distances: ndarray (n_times, n_conditions, n_conditions)
  459. """
  460. import numpy as np
  461. from sklearn.model_selection import StratifiedKFold, KFold
  462. from sklearn.covariance import LedoitWolf
  463. from scipy.linalg import solve
  464. from joblib import Parallel, delayed
  465. from tqdm.auto import tqdm
  466. from tqdm_joblib import tqdm_joblib
  468. n_trials, n_channels, n_times = X.shape
  469. conditions = np.unique(y)
  470. n_conditions = len(conditions)
  472. if shuffle:
  473. skf = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=42)
  474. else:
  475. skf = KFold(n_splits=n_splits, shuffle=False)
  477. def compute_timepoint(t):
  478. X_t = X[:, :, t]
  479. dist_folds = np.zeros((n_conditions, n_conditions, n_splits))
  481. fold_iterator = skf.split(X_t, y)
  482. if verbose:
  483. fold_iterator = tqdm(fold_iterator, total=n_splits, desc=f"Time {t:03}", leave=False, position=t % 8)
  485. for fold, (train_idx, test_idx) in enumerate(fold_iterator):
  486. X_train, X_test = X_t[train_idx], X_t[test_idx]
  487. y_train, y_test = y[train_idx], y[test_idx]
  489. try:
  490. lw = LedoitWolf()
  491. lw.fit(X_train)
  492. cov = lw.covariance_
  494. train_means = {c: X_train[y_train == c].mean(axis=0) for c in conditions}
  495. test_means = {c: X_test[y_test == c].mean(axis=0) for c in conditions}
  497. for i, ci in enumerate(conditions):
  498. for j, cj in enumerate(conditions):
  499. if j <= i:
  500. continue
  502. diff_train = train_means[ci] - train_means[cj]
  503. diff_test = test_means[ci] - test_means[cj]
  505. dist = diff_train.T @ solve(cov, diff_test, assume_a='pos')
  506. dist_folds[i, j, fold] = dist
  507. dist_folds[j, i, fold] = dist
  508. except (ValueError, np.linalg.LinAlgError, KeyError, ZeroDivisionError):
  509. # Catch common issues: singular covariances, missing classes, empty slices
  510. dist_folds[:, :, fold] = np.nan
  512. return np.nanmean(dist_folds, axis=2) # <- safely ignore folds with NaNs
  514. time_iterator = range(n_times)
  516. if verbose:
  517. with tqdm_joblib(tqdm(desc="Overall Timepoints", total=n_times)) as progress_bar:
  518. distances = Parallel(n_jobs=n_jobs)(
  519. delayed(compute_timepoint)(t) for t in time_iterator
  520. )
  521. else:
  522. distances = Parallel(n_jobs=n_jobs)(
  523. delayed(compute_timepoint)(t) for t in time_iterator
  524. )
  526. return np.stack(distances, axis=0)
  528. def train_test_mahalanobis_fast(X_train, X_test, y_train, y_test, n_jobs=-1, verbose=True):
  529. """
  530. Computes Mahalanobis distances between class means in training and testing sets.
  531. Handles missing conditions by filling with NaNs.
  533. Returns:
  534. distances: ndarray (n_times, n_conditions, n_conditions)
  535. """
  536. import numpy as np
  537. from sklearn.covariance import LedoitWolf
  538. from scipy.linalg import solve
  539. from joblib import Parallel, delayed
  540. from tqdm.auto import tqdm
  541. from tqdm_joblib import tqdm_joblib
  543. n_trials_train, n_channels, n_times = X_train.shape
  544. n_trials_test, _, _ = X_test.shape
  545. conditions = [1, 2, 3, 4]
  546. n_conditions = len(conditions)
  547. cond_idx = {c: i for i, c in enumerate(conditions)} # for indexing
  549. def compute_timepoint(t):
  550. try:
  551. Xtr = X_train[:, :, t]
  552. Xte = X_test[:, :, t]
  554. # Skip timepoints with too few trials
  555. if Xtr.shape[0] < 2 or Xte.shape[0] < 2:
  556. return np.full((n_conditions, n_conditions), np.nan)
  558. lw = LedoitWolf().fit(Xtr)
  559. cov = lw.covariance_
  561. # Only keep conditions present in both train and test
  562. present_train = set(y_train)
  563. present_test = set(y_test)
  564. valid_conditions = list(present_train & present_test)
  566. train_means = {}
  567. test_means = {}
  569. for c in valid_conditions:
  570. train_means[c] = Xtr[y_train == c].mean(0)
  571. test_means[c] = Xte[y_test == c].mean(0)
  573. dist = np.full((n_conditions, n_conditions), np.nan)
  575. for i, ci in enumerate(conditions):
  576. for j, cj in enumerate(conditions):
  577. if j <= i:
  578. continue
  579. if ci in train_means and cj in train_means and ci in test_means and cj in test_means:
  580. diff_train = train_means[ci] - train_means[cj]
  581. diff_test = test_means[ci] - test_means[cj]
  582. try:
  583. mahal = diff_train.T @ solve(cov, diff_test, assume_a='pos')
  584. except np.linalg.LinAlgError:
  585. mahal = np.nan
  586. dist[cond_idx[ci], cond_idx[cj]] = mahal
  587. dist[cond_idx[cj], cond_idx[ci]] = mahal
  589. return dist
  591. except Exception as e:
  592. print(f"Error at time {t}: {e}")
  593. return np.full((n_conditions, n_conditions), np.nan)
  595. time_iterator = range(n_times)
  597. if verbose:
  598. with tqdm_joblib(tqdm(desc="Computing Mahalanobis", total=n_times)):
  599. distances = Parallel(n_jobs=n_jobs)(
  600. delayed(compute_timepoint)(t) for t in time_iterator
  601. )
  602. else:
  603. distances = Parallel(n_jobs=n_jobs)(
  604. delayed(compute_timepoint)(t) for t in time_iterator
  605. )
  607. return np.stack(distances, axis=0) # shape: (n_times, n_conditions, n_conditions)
  609. def loocv_mahalanobis_parallel(X, y, n_jobs=-1, verbose=True):
  610. """
  611. Parallel cross-validated Mahalanobis distances using LOOCV,
  612. with per-fold progress bars for each timepoint.
  614. Parameters:
  615. X: ndarray (n_trials, n_channels, n_times)
  616. y: array-like (n_trials,) condition labels
  617. n_jobs: int, number of parallel jobs (default: -1 = all cores)
  618. verbose: bool, whether to show progress bars
  620. Returns:
  621. distances: ndarray (n_times, n_conditions, n_conditions)
  622. """
  623. import numpy as np
  624. from sklearn.model_selection import LeaveOneOut
  625. from sklearn.covariance import LedoitWolf
  626. from scipy.linalg import solve
  627. from joblib import Parallel, delayed
  628. from tqdm.auto import tqdm
  630. n_trials, n_channels, n_times = X.shape
  631. conditions = np.unique(y)
  632. n_conditions = len(conditions)
  633. loo = LeaveOneOut()
  635. def compute_timepoint(t):
  636. X_t = X[:, :, t]
  637. dist_folds = np.full((n_conditions, n_conditions, n_trials), np.nan)
  639. iterator = loo.split(X_t)
  640. if verbose:
  641. iterator = tqdm(iterator, total=n_trials, desc=f"Time {t:03}", leave=False, position=t % 8)
  643. for fold, (train_idx, test_idx) in enumerate(iterator):
  644. X_train, X_test = X_t[train_idx], X_t[test_idx]
  645. y_train, y_test = y[train_idx], y[test_idx]
  647. if len(np.unique(y_train)) < len(conditions):
  648. continue
  650. lw = LedoitWolf()
  651. lw.fit(X_train)
  652. cov = lw.covariance_
  654. train_means = {c: X_train[y_train == c].mean(axis=0) for c in conditions}
  655. test_means = {c: X_test[y_test == c].mean(axis=0) for c in conditions if np.any(y_test == c)}
  657. for i, ci in enumerate(conditions):
  658. for j, cj in enumerate(conditions):
  659. if j <= i or ci not in test_means or cj not in test_means:
  660. continue
  662. diff_train = train_means[ci] - train_means[cj]
  663. diff_test = test_means[ci] - test_means[cj]
  665. if np.isnan(diff_test).any() or np.isnan(diff_train).any():
  666. continue
  668. dist = diff_train.T @ solve(cov, diff_test, assume_a='pos')
  669. dist_folds[i, j, fold] = dist
  670. dist_folds[j, i, fold] = dist
  672. return np.nanmean(dist_folds, axis=2)
  674. if verbose:
  675. time_iterator = tqdm(range(n_times), desc="Timepoints")
  676. else:
  677. time_iterator = range(n_times)
  679. distances = Parallel(n_jobs=n_jobs)(
  680. delayed(compute_timepoint)(t) for t in time_iterator
  681. )
  683. return np.stack(distances, axis=0)
  685. def interpolate_rdm_nan(rdm):
  686. """Interpolate nan values in a RDM matrix by computing the mean of previous and subsequent block.
  688. Args:
  689. rdm: ndarray of shape (n_blocks, n_times, n_conditions, n_conditions)
  690. LOOCV Mahalanobis distances between conditions at each time point.
  692. Returns:
  693. rdm: ndarray of shape (n_blocks, n_times, n_conditions, n_conditions)
  694. LOOCV Mahalanobis distances between conditions at each time point.
  695. present_nan: bool
  696. True if nan values were present in the RDM, False otherwise
  697. """
  698. present_nan = False
  699. n_blocks, n_times, n_conditions, _ = rdm.shape
  700. for i in range(n_blocks):
  701. for j in range(n_times):
  702. if np.isnan(np.sum(rdm[i, j])):
  703. present_nan = True
  704. if i == 0:
  705. rdm[i, j] = rdm[i + 1, j]
  706. elif i == n_blocks - 1:
  707. rdm[i, j] = rdm[i - 1, j]
  708. else:
  709. rdm[i, j] = (rdm[i - 1, j] + rdm[i + 1, j]) / 2
  710. return rdm, present_nan
  712. def contiguous_regions(condition):
  713. """Find contiguous True regions in a boolean array."""
  714. import numpy as np
  715. d = np.diff(condition.astype(int))
  716. starts = np.where(d == 1)[0] + 1
  717. ends = np.where(d == -1)[0] + 1
  719. if condition[0]:
  720. starts = np.r_[0, starts]
  721. if condition[-1]:
  722. ends = np.r_[ends, condition.size]
  724. return zip(starts, ends)
  726. def svd(vector_data):
  727. """Reduce 3 orientations to dominant orientation using Singular Value Decomposition."""
  728. # Initialize an array for storing the dominant orientation time series
  729. dominant_data = np.zeros((vector_data.shape[0], vector_data.shape[1], vector_data.shape[-1])) # (294, 8196, 82)
  730. for trial in range(vector_data.shape[0]): # Loop over trials
  731. for source in range(vector_data.shape[1]): # Loop over sources
  732. u, s, vh = np.linalg.svd(vector_data[trial, source, :, :], full_matrices=False) # SVD over orientation axis (3)
  733. dominant_time_series = vh[0, :] * s[0] # First right singular vector weighted by singular value
  734. dominant_data[trial, source, :] = dominant_time_series # Store in new array
  735. return dominant_data
  737. def svd_fast(vector_data):
  738. """Vectorized equivalent of `svd` using NumPy batched SVD."""
  739. _, s, vh = np.linalg.svd(vector_data, full_matrices=False)
  740. return vh[..., 0, :] * s[..., [0]]
  742. def get_train_test_blocks_net(data, fwd, behav, pick_ori, trial_type, block, blocks, rsa=False, verbose=False):
  743. """Helper function to get source data for training and testing."""
  745. from mne import compute_covariance, compute_rank
  746. from mne.beamformer import make_lcmv, apply_lcmv_epochs
  747. import numpy as np
  749. weight_norm = "unit-noise-gain-invariant" if pick_ori == 'vector' else "unit-noise-gain"
  751. this_block = behav.blocks == block
  752. if not rsa:
  753. if block in blocks[:3]:
  754. rand_blocks = np.random.choice(blocks[3:], size=19, replace=False)
  755. out_blocks = behav.blocks.isin(rand_blocks)
  756. else:
  757. out_blocks = (behav.blocks != block) & (behav.sessions != 0)
  758. else:
  759. out_blocks = behav.blocks != block
  761. tt = behav.trialtypes == 2 if trial_type == 'random' else behav.trialtypes == 1
  763. # compute training data
  764. tt_out_blocks = tt & out_blocks
  765. train_blocks = behav[tt_out_blocks]
  766. train_epochs = data[train_blocks.trials.values]
  767. assert len(train_blocks) == len(train_epochs), "Length mismatch in training epochs"
  768. ytrain = train_blocks.positions
  769. # compute testing data
  770. tt_this_block = tt & this_block
  771. test_blocks = behav[tt_this_block]
  772. test_epochs = data[test_blocks.trials.values]
  773. ytest = test_blocks.positions
  775. # compute noise covariance
  776. random = behav.trialtypes == 2
  777. noise_epochs = data[random & out_blocks]
  778. noise_cov = compute_covariance(noise_epochs, tmin=-0.2, tmax=0, method="empirical", rank="info", verbose=verbose)
  779. data_cov = compute_covariance(train_epochs, method="empirical", rank="info", verbose=verbose)
  780. rank = compute_rank(data_cov, info=train_epochs.info, rank=None, tol_kind='relative', verbose=verbose)
  781. filters = make_lcmv(train_epochs.info, fwd, data_cov, reg=0.05, noise_cov=noise_cov,
  782. pick_ori=pick_ori, weight_norm=weight_norm,
  783. rank=rank, reduce_rank=True, verbose=verbose)
  784. # apply LCMV beamformer to epochs
  785. stcs_train = apply_lcmv_epochs(train_epochs, filters=filters, verbose=verbose)
  786. stcs_test = apply_lcmv_epochs(test_epochs, filters=filters, verbose=verbose)
  788. return stcs_train, stcs_test, ytrain, ytest
  790. def get_train_test_blocks_htc(data, fwd, behav, pick_ori, trial_type, block, blocks, rsa=False, verbose=False):
  791. """Helper function to get source data for training and testing."""
  793. from mne import compute_covariance, compute_rank
  794. from mne.beamformer import make_lcmv, apply_lcmv_epochs
  796. weight_norm = "unit-noise-gain-invariant" if pick_ori == 'vector' else "unit-noise-gain"
  798. this_block = behav.blocks == block
  799. if not rsa:
  800. if block in blocks[:3]:
  801. rand_blocks = np.random.choice(blocks[3:], size=19, replace=False)
  802. out_blocks = behav.blocks.isin(rand_blocks)
  803. else:
  804. out_blocks = (behav.blocks != block) & (behav.sessions != 0)
  805. else:
  806. out_blocks = behav.blocks != block
  808. tt = behav.trialtypes == 2 if trial_type == 'random' else behav.trialtypes == 1
  809. tt_out_blocks = tt & out_blocks
  810. tt_this_block = tt & this_block
  812. # compute training data
  813. train_blocks = behav[tt_out_blocks]
  814. train_epochs = data[train_blocks.trials.values]
  815. random = behav.trialtypes == 2
  816. noise_epochs = data[random & out_blocks]
  817. noise_cov = compute_covariance(noise_epochs, tmin=-0.2, tmax=0, method="empirical", rank="info", verbose=verbose)
  818. data_cov = compute_covariance(train_epochs, method="empirical", rank="info", verbose=verbose)
  819. rank = compute_rank(data_cov, info=train_epochs.info, rank=None, tol_kind='relative', verbose=verbose)
  820. filters = make_lcmv(train_epochs.info, fwd, data_cov, reg=0.05, noise_cov=noise_cov,
  821. pick_ori=pick_ori, weight_norm=weight_norm,
  822. rank=rank, reduce_rank=True, verbose=verbose)
  823. stcs_train = apply_lcmv_epochs(train_epochs, filters=filters, verbose=verbose)
  824. ytrain = train_blocks.positions
  825. assert len(stcs_train) == len(ytrain), "Length mismatch in training data"
  827. # compute testing data
  828. test_blocks = behav[tt_this_block]
  829. test_epochs = data[test_blocks.trials.values]
  830. stcs_test = apply_lcmv_epochs(test_epochs, filters=filters, verbose=verbose)
  831. ytest = test_blocks.positions
  832. assert len(stcs_test) == len(ytest), "Length mismatch in testing data"
  834. return stcs_train, ytrain, stcs_test, ytest
  836. def fisher_z_and_ttest(rho_matrix):
  837. import numpy as np
  838. from scipy.stats import ttest_1samp
  839. """
  840. Applies Fisher z-transform and performs a one-sample t-test against 0 at each timepoint.
  842. Parameters:
  843. rho_matrix (np.ndarray): Array of shape (n_subjects, n_timepoints) with rho values.
  845. Returns:
  846. z_matrix (np.ndarray): Fisher z-transformed correlations, same shape as input.
  847. t_stats (np.ndarray): T-statistics at each timepoint, shape (n_timepoints,).
  848. p_vals (np.ndarray): P-values at each timepoint, shape (n_timepoints,).
  849. """
  850. # Clip rho values to avoid infinite z
  851. rho_matrix = np.clip(rho_matrix, -0.999999, 0.999999)
  853. # Fisher z-transform
  854. z_matrix = 0.5 * np.log((1 + rho_matrix) / (1 - rho_matrix))
  856. # One-sample t-test at each timepoint
  857. t_stats, p_vals = ttest_1samp(z_matrix, popmean=0, axis=0)
  859. return z_matrix, t_stats, p_vals
  861. def fisher_z_transform_3d(rho_3d):
  862. """
  863. Apply Fisher's z-transformation to a 3D array of correlation coefficients.
  865. Parameters:
  866. rho_3d (np.ndarray): Array of shape (n_subjects, n_timepoints, n_timepoints)
  868. Returns:
  869. z_3d (np.ndarray): Fisher z-transformed array, same shape as input.
  870. """
  871. import numpy as np
  872. rho_3d = np.clip(rho_3d, -0.999999, 0.999999)
  873. z_3d = 0.5 * np.log((1 + rho_3d) / (1 - rho_3d))
  874. return z_3d
  876. def reorder(random_events, events, raw_rd, dur=200, nsamples=33):
  877. import mne
  878. """
  879. Reorder random events to match the given sequence.
  881. Parameters:
  882. random_events -- array of random events
  883. events -- target sequence of events
  884. raw_rd -- raw data corresponding to random events
  885. dur -- duration (in samples) of pre-task and post-task data
  886. nsamples -- window duration in samples
  888. Returns:
  889. Reordered raw data, original random event indices, and reordered events.
  890. """
  891. events = list(events)
  892. orig_nums = []
  893. events_reord = []
  894. raw_Xrd = raw_rd.get_data()
  895. raw_reord = []
  896. new_sample = 0
  897. first_samp = raw_rd.first_samp
  899. # Start reordered random with the first seconds of random raw
  900. raw_reord.append(raw_Xrd[:, :dur])
  901. new_sample += dur
  903. random_events_numbers = np.arange(len(random_events))
  904. for event in events:
  905. if event[2] in random_events[:, 2]:
  906. index = random_events[:, 2].tolist().index(event[2])
  907. orig_nums.append(random_events_numbers[index])
  908. samp = random_events[index, 0] - first_samp
  909. raw_reord.append(raw_Xrd[:, samp:samp + nsamples])
  910. random_events = np.delete(random_events, index, axis=0)
  911. random_events_numbers = np.delete(random_events_numbers, index, axis=0)
  912. events_reord.append([new_sample, 0, event[2]])
  913. new_sample += nsamples
  914. else:
  915. break
  917. # End reordered random with the last seconds of random raw
  918. raw_reord.append(raw_Xrd[:, -dur:])
  919. orig_nums_reord = np.array(orig_nums)
  920. events_reord = np.array(events_reord)
  921. raw_reord = np.concatenate(raw_reord, axis=1)
  922. raw_reord = mne.io.RawArray(raw_reord, raw_rd.info)
  924. return raw_reord, orig_nums_reord, events_reord

base.py at commit fbfceb6, no license · at the source

Overview

Authors: Coumarane Tirou1, Oussama Abdoun1, Teodóra Vékony2, Laure Tosatto3,4, Andrea Brovelli5, Marine Vernet6, Dezső Németh1,2,7, Romain Quentin1
ORCID iDs: Coumarane Tirou, Oussama Abdoun, Laure Tosatto, Andrea Brovelli, Marine Vernet, Romain Quentin
  1. Université Claude Bernard Lyon 1, INSERM U1028, CNRS UMR5292, Lyon Neuroscience Research Center (CRNL), EDUWELL team, Lyon, France
  2. Gran Canaria Cognitive Research Center, Atlántico Medio University, Las Palmas de Gran Canaria, Spain
  3. School of Biological Sciences, Monash University, Melbourne, VIC 3800 Australia
  4. Normandie University, UNICAEN, CNRS, EthoS, UMR 6552, Caen, 14000 France
  5. Institut de Neurosciences de la Timone UMR 7289, Aix Marseille Université, CNRS, Marseille, 13005 France
  6. Université Claude Bernard Lyon 1, INSERM U1028, CNRS UMR5292, Lyon Neuroscience Research Center (CRNL), IMPACT team, Lyon, France
  7. BML-NAP Research Group, ELTE Eötvös Loránd University & HUN-REN Research Centre for Natural Sciences, Budapest, Hungary
Institutions: Lyon 1 Université (France); Centre National de la Recherche Scientifique (France); Inserm (France); Centre de Recherche en Neurosciences de Lyon (France); Universidad del Atlántico Medio (Spain); Normandie Université (France); Centre d'Etude en Ethologie et Cognition (France); Monash University (Australia); Université de Caen Normandie (France); Aix-Marseille Université (France); Institut de Neurosciences de la Timone (France); Eötvös Loránd University (Hungary); HUN-REN Research Centre for Natural Sciences (Hungary)
Journal: Nature communications, volume 17, issue 1, article 8372
Dates: received 27 October 2025; accepted 12 June 2026; published online 7 July 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41467-026-74824-0 · PMID 42409831 · PMCID PMC13473593 · OpenAlex W7167509062
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: MEG (modality), human (organism), cognitive (subfield)
Methods: Spectral & time-frequency, Statistics, Smoothing, state filtering, decompositions, Machine learning, Connectivity, fMRI & imaging, Physiology & signal measures
Keywords: Cognitive neuroscience, Learning and memory
MeSH: Brain*, Learning*, Noise*, Attention, Female, Humans, Magnetoencephalography, Male, Nerve Net, Photic Stimulation, Psychomotor Performance (* major topic)
Topic: Neural dynamics and brain function (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Aix-Marseille Université (ANR-11-INBS-0006, MICIU/AEI/10.13039/501100011033, ANR-16-CONV-0002); Ministerio de Ciencia, Innovación y Universidades (10.13039.501100011033, 10.13039/501100011033/FEDER, AEI/10.13039/501100011033/ FEDER, MICIU /AEI /10.13039/501100011033 / FEDER, / AEI10.13039/501100011033, 13039, MICIU/AEI/ 10.13039/501,100,011,033 /, PID2024, MICIU/AEI/10.13039, 10.13039, 13039/501100011033, 501100011033, MICIU/AEI/10); Agence Nationale de la Recherche (2019-ANR-LABX-02, MICIU/AEI/10.13039/501100011033, ANR-24-CE37-5807, ANR-16-CONV-0002, ANR-22-CPJ1-0042-01, ANR-16, ANR-11-INBS, ANR-11-INBS-0006, ANR-11-LABX-0042); Hungarian Scientific Research Fund (NKFIH ADVANCED153150); Centre National de la Recherche Scientifique (ANR-11-LABX-0042, CNRS-IN2P3, MICIU/AEI/10.13039/501100011033, ANR-11-INBS-0006); Université Claude Bernard Lyon 1 (ED476, ANR-11-LABX-0042, 2019-ANR-LABX-02); Nemzeti Kutatási Fejlesztési és Innovációs Hivatal; LabEx BRAIN; European Regional Development Fund (10.13039/501100011033, 13039/501100011033, MICIU/ AEI /10.13039/501100011033, AEI/10.13039/501100011033, MICIU/AEI/ 10.13039/501100011033 FEDER, 501100011033, MICIU/AEI/10); Agencia Estatal de Investigación (AEI//10.13039/501100011033/, 501100011033, MICIU/AEI /10.13039/501100011033, 10.13039/501100011033, 13039, 13039/501100011033, 10.13039, 501100011033/FEDER, AEI/10); Institut National de Physique Nucléaire et de Physique des Particules (CNRS/IN2P3)
Citations: not cited yet (Europe PMC); 74 references in the paper

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.

Repository

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

MEL-Eduwell-lab/asrt_analyses

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: fbfceb6a5b64fdab69a14aa2fefeb11ff1a251e3, 8 June 2026
Languages: Python (55), Shell (19), Quarto (2)
Size: 105 files, 76 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, environment (environment.yml), 2 notebooks
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (50 files), pandas (49 files), MNE-Python (35 files), Matplotlib (24 files), SciPy (18 files), scikit-learn (13 files), autoreject (3 files), easystats (2 files), emmeans (2 files), mgcv (2 files), Plotly (2 files), tidyverse (2 files), FreeSurfer (1 file), imageio (1 file), MNE-BIDS (1 file), NiBabel (1 file), Pingouin (1 file), reticulate (1 file), statsmodels (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
77 files
At the source: github.com/MEL-Eduwell-lab/asrt_analyses

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-74824-0.

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;
  • 76 scripts, each with its path and the digest of its content;
  • 10 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 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:

Read it in the paper: doi.org/10.1038/s41467-026-74824-0.

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 2, 28 September 2026

  • Funding: added Aix-Marseille Université: ANR-11-INBS-0006, MICIU/AEI/10.13039/501100011033, ANR-16-CONV-0002; Ministerio de Ciencia, Innovación y Universidades: 10.13039.501100011033, 10.13039/501100011033/FEDER, AEI/10.13039/501100011033/ FEDER, MICIU /AEI /10.13039/501100011033 / FEDER, / AEI10.13039/501100011033, 13039, MICIU/AEI/ 10.13039/501,100,011,033 /, PID2024, MICIU/AEI/10.13039, 10.13039, 13039/501100011033, 501100011033, MICIU/AEI/10; Agence Nationale de la Recherche: 2019-ANR-LABX-02, MICIU/AEI/10.13039/501100011033, ANR-24-CE37-5807, ANR-16-CONV-0002, ANR-22-CPJ1-0042-01, ANR-16, ANR-11-INBS, ANR-11-INBS-0006, ANR-11-LABX-0042; Hungarian Scientific Research Fund: NKFIH ADVANCED153150; Centre National de la Recherche Scientifique: ANR-11-LABX-0042, CNRS-IN2P3, MICIU/AEI/10.13039/501100011033, ANR-11-INBS-0006; Université Claude Bernard Lyon 1: ED476, ANR-11-LABX-0042, 2019-ANR-LABX-02; Nemzeti Kutatási Fejlesztési és Innovációs Hivatal; LabEx BRAIN; European Regional Development Fund: 10.13039/501100011033, 13039/501100011033, MICIU/ AEI /10.13039/501100011033, AEI/10.13039/501100011033, MICIU/AEI/ 10.13039/501100011033 FEDER, 501100011033, MICIU/AEI/10; Agencia Estatal de Investigación: AEI//10.13039/501100011033/, 501100011033, MICIU/AEI /10.13039/501100011033, 10.13039/501100011033, 13039, 13039/501100011033, 10.13039, 501100011033/FEDER, AEI/10; Institut National de Physique Nucléaire et de Physique des Particules: CNRS/IN2P3

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 8 authors, 2 keywords, 11 MeSH terms, 68 references.

Cite

This paper

Tirou, C., Abdoun, O., Vékony, T., Tosatto, L., Brovelli, A., Vernet, M., Németh, D., & Quentin, R. (2026). Learning regularities in noise engages both neural predictive activity and representational changes. Nature communications, 17(1), 8372. https://doi.org/10.1038/s41467-026-74824-0

BibTeX

@article{tirou2026learning,
author = {Tirou, Coumarane and Abdoun, Oussama and Vékony, Teodóra and Tosatto, Laure and Brovelli, Andrea and Vernet, Marine and Németh, Dezső and Quentin, Romain},
title = {{Learning regularities in noise engages both neural predictive activity and representational changes}},
journal = {Nature communications},
year = {2026},
month = jul,
volume = {17},
number = {1},
pages = {8372},
publisher = {Nature Publishing Group},
issn = {2041-1723},
doi = {10.1038/s41467-026-74824-0},
url = {https://doi.org/10.1038/s41467-026-74824-0},
pmid = {42409831},
pmcid = {PMC13473593}
}

RIS

TY - JOUR
AU - Tirou, Coumarane
AU - Abdoun, Oussama
AU - Vékony, Teodóra
AU - Tosatto, Laure
AU - Brovelli, Andrea
AU - Vernet, Marine
AU - Németh, Dezső
AU - Quentin, Romain
TI - Learning regularities in noise engages both neural predictive activity and representational changes
T2 - Nature communications
J2 - Nat Commun
PY - 2026
DA - 2026/07/07
VL - 17
IS - 1
SP - 8372
SN - 2041-1723
PB - Nature Publishing Group
DO - 10.1038/s41467-026-74824-0
UR - https://doi.org/10.1038/s41467-026-74824-0
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41467-026-74824-0",
"type": "article-journal",
"title": "Learning regularities in noise engages both neural predictive activity and representational changes",
"container-title": "Nature communications",
"author": [
{
"family": "Tirou",
"given": "Coumarane"
},
{
"family": "Abdoun",
"given": "Oussama"
},
{
"family": "Vékony",
"given": "Teodóra"
},
{
"family": "Tosatto",
"given": "Laure"
},
{
"family": "Brovelli",
"given": "Andrea"
},
{
"family": "Vernet",
"given": "Marine"
},
{
"family": "Németh",
"given": "Dezső"
},
{
"family": "Quentin",
"given": "Romain"
}
],
"container-title-short": "Nat Commun",
"volume": "17",
"issue": "1",
"page": "8372",
"DOI": "10.1038/s41467-026-74824-0",
"PMID": "42409831",
"PMCID": "PMC13473593",
"ISSN": "2041-1723",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41467-026-74824-0",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
7
]
]
}
}

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-73568-1 [code]
No evidence of neural feature-specific pre-activation during the prediction of an upcoming stimulus.
Journal: Nature communications
In common: reticulate, easystats, MNE-Python, 4 other tools, cognitive, 4 references, 3 authors
[2] doi:10.1093/nc/niag029 [code]
A data-driven approach to identifying and evaluating connectivity-based neural correlates of conscious visual perception.
Journal: Neuroscience of consciousness
In common: autoreject, MNE-BIDS, Pingouin, 12 other tools, MEG, cognitive, 3 references
[3] 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: autoreject, MNE-BIDS, Pingouin, 12 other tools, MEG, 2 references
[4] 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: autoreject, MNE-BIDS, Pingouin, 12 other tools, 1 reference
[5] doi:10.1162/imag.a.1321 [code]
Phase similarity between similar objects indicates representational merging across retrieval training but not sleep.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: autoreject, Pingouin, easystats, 10 other tools, cognitive, 2 references
[6] 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: autoreject, Pingouin, FreeSurfer, 9 other tools, MEG, 2 references
[7] doi:10.7554/elife.103097 [code]
Canonical neurodevelopmental trajectories of structural and functional manifolds.
Journal: eLife
In common: mgcv, reticulate, Pingouin, 8 other tools, 3 references
[8] doi:10.34133/csbj.0042 [code]
Using Steady-State Visual Evoked Potentials to Characterize Wide-Ranging Retinopathy Linked to &lt;i&gt;CRB1&lt;/i&gt;: Implications for Clinical Trials.
Journal: Computational and structural biotechnology journal
In common: MNE-BIDS, Pingouin, easystats, 10 other tools
[9] doi:10.1162/imag.a.1245 [code]
Towards precision EEG connectomics: Evaluating the benefits of dense sampling.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: autoreject, Pingouin, FreeSurfer, 8 other tools, 3 references
[10] doi:10.1038/s41467-026-75662-w [code]
Distinct Roles of Deep and Superficial Cortical Layers in Tone Prediction, Comparison, and Adaptation in Human Auditory Cortices.
Journal: Nature communications
In common: imageio, Pingouin, MNE-Python, 8 other tools, cognitive, 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.