OSCR

Neuronal avalanches as a predictive biomarker for guiding tailored BCI training programs.

Code ↔ Paper

8 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 8 matches
  1. [1] § Materials and Methods › Predictive models ↔ LSVR_model.py, lines 37–114 · score 0.92 · temporal weight vector, Gram matrix, dual variables, Longitudinal Support Vector, temporal trends, insensitive
  2. [2] § Materials and Methods › Predictive models ↔ LSVR_model.py, lines 37–114 · score 0.81 · temporal trend vector, dual coefficients, dual variables, support vectors, QP, linear
  3. [3] § Materials and Methods › Predictive models ↔ LSVC_model.py, lines 95–176 · score 0.74 · temporal trend vector, dual coefficients, support vectors, QP, linear, iterative
  4. [4] § Materials and Methods › Predictive models ↔ LSVC_model.py, lines 27–93 · score 0.73 · Gram matrix, Longitudinal Support Vector, temporal trends, QP, dual, model
  5. [5] § Results › Prediction results › BCI performance prediction ↔ LSVR_model.py, lines 567–648 · score 0.70 · Square Error, LSVR model, continuous predicted, BCI score, RMSE, shuffled
  6. [6] § Materials and Methods › Predictive models ↔ LSVC_model.py, lines 27–93 · score 0.63 · Longitudinal Support Vector, temporal trend, LSVC, Classifier, model, matrix
  7. [7] § Materials and Methods › Predictive models ↔ LSVC_model.py, lines 95–176 · score 0.56 · dual coefficients, LSVC, linear, iterative, temporal, matrix
  8. [8] § Results › Prediction results ↔ LSVC_model.py, lines 528–573 · score 0.53 · Support Vector Classifier, classification model, BCI score, LSVC, longitudinal, predictive

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 · 754 lines · 34 KB · no license · 5 matches

  1. # %%
  2. """
  3. ==============================================================
  4. Neuronal avalanches as a predictive biomarker for guiding tailored BCI training programs
  5. Longitudinal Support Vector Classification (LSVC) model
  6. ================================================================
  7. """
  9. # Authors: Camilla Mannino <[email hidden]>
  10. # License: BSD (3-clause)
  12. from qpsolvers import solve_qp
  13. import pickle
  14. from sklearn.metrics import confusion_matrix
  15. import matplotlib.pyplot as plt
  16. from matplotlib.lines import Line2D
  17. from sklearn.model_selection import LeaveOneOut
  18. from sklearn.svm import SVC
  19. from sklearn.linear_model import LogisticRegression
  20. from sklearn.ensemble import RandomForestClassifier
  21. from sklearn.metrics import balanced_accuracy_score
  22. import numpy as np
  23. import random
  25. #%% Functions
  27. def longitudinal_svc(X_list, y_list, C=1.0):
  28. """
  29. Trains a Longitudinal Support Vector Classifier (LSVC) model.
  31. Parameters:
  32. X_list : list of np.ndarray
  33. List of T x p feature matrices per subject.
  34. y_list : list of np.ndarray
  35. List of T-dimensional binary target vectors (0 or 1) per subject.
  36. C : float
  37. Regularization parameter.
  39. Returns:
  40. alpha : np.ndarray
  41. Dual coefficients.
  42. beta : np.ndarray
  43. Temporal trend vector of shape (T,).
  44. """
  45. N = len(X_list)
  46. T = X_list[0].shape[0]
  47. beta = np.ones(T)
  49. # Compute Gram matrix G where G[i,j] = beta^T X_i X_j^T beta
  50. G = np.zeros((N, N))
  51. for i in range(N):
  52. Xi = X_list[i]
  53. for j in range(N):
  54. Xj = X_list[j]
  55. G[i, j] = beta @ Xi @ Xj.T @ beta
  57. # Convert targets to +1/-1
  58. y_bin = np.array([2 * int(np.mean(y_list[i])) - 1 for i in range(N)]) # mean in case T > 1
  60. # Create QP matrices
  61. P = np.outer(y_bin, y_bin) * G
  62. P = (P + P.T) / 2 + 1e-6 * np.eye(N)
  63. q = -np.ones(N)
  65. # Constraints: 0 <= alpha_i <= C
  66. G_qp = np.vstack([np.eye(N), -np.eye(N)])
  67. h_qp = np.hstack([C * np.ones(N), np.zeros(N)])
  69. # Equality constraint: sum alpha_i * y_i = 0
  70. A_qp = y_bin.reshape(1, -1)
  71. b_qp = np.array([0.0])
  73. # Solve QP
  74. alpha = solve_qp(P, q, G_qp, h_qp, A_qp, b_qp, solver='quadprog')
  75. if alpha is None:
  76. raise ValueError("QP solver failed to find a solution!")
  78. # Compute beta from duals
  79. numerator = np.zeros(T)
  80. denominator = np.zeros((T, T))
  81. for i in range(N):
  82. yi = y_bin[i]
  83. Xi = X_list[i]
  84. coeff_i = alpha[i] * yi
  85. numerator += coeff_i * np.mean(y_list[i]) # again averaging if T > 1
  86. for j in range(N):
  87. yj = y_bin[j]
  88. Xj = X_list[j]
  89. coeff_j = alpha[j] * yj
  90. denominator += coeff_i * coeff_j * (Xi @ Xj.T)
  92. beta = np.linalg.solve(denominator + 1e-6 * np.eye(T), numerator)
  93. return alpha, beta, y_bin
  95. def longitudinal_svc_iterative(X_list, y_list, C=1.0, max_iter=200, tol=1e-4):
  96. """
  97. Iterative Longitudinal Support Vector Classifier (LSVC).
  99. Parameters:
  100. X_list : list of np.ndarray
  101. Each entry is a T x p matrix for a subject.
  102. y_list : list of int
  103. Class labels (0 or 1) for each subject.
  104. C : float
  105. Regularization parameter.
  106. max_iter : int
  107. Maximum number of iterations.
  108. tol : float
  109. Convergence tolerance on beta.
  111. Returns:
  112. alpha : np.ndarray
  113. Dual coefficients.
  114. beta : np.ndarray
  115. Temporal trend vector of shape (T,).
  116. """
  117. N = len(X_list)
  118. T = X_list[0].shape[0]
  120. # Binary labels {-1, +1}
  121. # Ensure one label per subject
  122. # If your y_list is a list of arrays of shape (T,) per subject:
  123. if isinstance(y_list[0], (list, np.ndarray)) and len(y_list[0]) > 1:
  124. y_bin = np.array([2 * int(round(np.mean(y))) - 1 for y in y_list])
  125. else:
  126. y_bin = np.array([2 * int(y) - 1 for y in y_list]) # Already per-subject
  128. # Initialize beta
  129. beta = np.ones(T)
  130. beta /= np.linalg.norm(beta)
  132. for it in range(max_iter):
  133. # --- Step 1: Solve QP for alpha given beta ---
  134. G = np.zeros((N, N))
  135. for i in range(N):
  136. Xi = X_list[i]
  137. for j in range(N):
  138. Xj = X_list[j]
  139. G[i, j] = beta @ Xi @ Xj.T @ beta
  141. P = np.outer(y_bin, y_bin) * G
  142. P = (P + P.T) / 2 + 1e-6 * np.eye(N) # Ensure positive semi-definite
  143. q = -np.ones(N)
  145. # Constraints
  146. G_qp = np.vstack([np.eye(N), -np.eye(N)])
  147. h_qp = np.hstack([C * np.ones(N), np.zeros(N)])
  148. A_qp = y_bin.reshape(1, -1)
  149. b_qp = np.array([0.0])
  151. alpha = solve_qp(P, q, G_qp, h_qp, A_qp, b_qp, solver='quadprog')
  152. if alpha is None:
  153. raise ValueError("QP solver failed to converge.")
  155. # --- Step 2: Update beta given alpha ---
  156. numerator = np.zeros(T)
  157. denominator = np.zeros((T, T))
  158. for i in range(N):
  159. ai_yi = alpha[i] * y_bin[i]
  160. Xi = X_list[i]
  161. for j in range(N):
  162. aj_yj = alpha[j] * y_bin[j]
  163. Xj = X_list[j]
  164. denominator += ai_yi * aj_yj * (Xi @ Xj.T)
  165. numerator += ai_yi * (Xi @ np.ones(Xi.shape[1])) # Linear aggregation
  167. # Regularize to ensure invertibility
  168. beta_new = np.linalg.solve(denominator + 1e-6 * np.eye(T), numerator)
  169. beta_new /= np.linalg.norm(beta_new)
  171. # Check convergence
  172. if np.linalg.norm(beta_new - beta) < tol:
  173. break
  174. beta = beta_new
  176. return alpha, beta, y_bin
  178. def predict_lsvc(X_new_list, support_vectors, alpha, beta, y_bin):
  179. preds = []
  180. N = len(support_vectors)
  182. for X_new in X_new_list:
  183. score = 0.0
  184. for i in range(N):
  185. Xi = support_vectors[i]
  186. score += alpha[i] * y_bin[i] * (beta @ X_new @ Xi.T @ beta)
  187. preds.append(1 if score >= 0 else 0)
  189. return np.array(preds)
  192. def vertical_dot_plot(y_true, y_pred, title, save_path=None):
  193. n_subjects = len(y_true)
  194. fig, ax = plt.subplots(figsize=(10, 4))
  196. for i, (yt, yp) in enumerate(zip(y_true, y_pred), start=1):
  197. y_pos = 1 if yt == 1 else 0.5
  198. color = 'green' if yt == yp else 'red'
  200. # Draw the vertical line
  201. ax.plot([i, i], [0, y_pos], color='black', linewidth=1)
  203. # Draw the circle
  204. ax.scatter(i, y_pos, color=color, s=200, zorder=3, edgecolors='black')
  206. # Reference horizontal dashed line at 0.57
  207. ax.axhline(0.57, color='teal', linewidth=2, linestyle='--')
  209. # Axis settings
  210. ax.set_xticks(range(1, n_subjects + 1))
  211. ax.set_xticklabels(range(1, n_subjects + 1))
  212. ax.set_xlabel("Subjects", fontsize=12, fontweight='bold')
  213. ax.set_ylabel("Performance", fontsize=12, fontweight='bold')
  214. ax.set_xlim(0.5, n_subjects + 0.5)
  215. ax.set_ylim(0, 1.5)
  216. ax.set_yticks([])
  217. ax.spines['top'].set_visible(False)
  218. ax.spines['right'].set_visible(False)
  220. # Custom axis arrows
  221. ax.plot([0, 0], [0, 1.5], color='teal', linewidth=2) # Y-axis line
  222. ax.plot([0.5, n_subjects + 0.5], [0, 0], color='teal', linewidth=2) # X-axis line
  224. # Add legend
  225. legend_elements = [
  226. Line2D([0], [0], marker='o', color='w', label='Correctly Classified',
  227. markerfacecolor='green', markersize=10, markeredgecolor='black'),
  228. Line2D([0], [0], marker='o', color='w', label='Miss Classified',
  229. markerfacecolor='red', markersize=10, markeredgecolor='black'),
  230. Line2D([0], [0], color='teal', linestyle='--', linewidth=2, label='Chance Level: 57%')
  231. ]
  232. ax.legend(handles=legend_elements, loc='upper right')
  234. ax.set_title(title, fontsize=14, fontweight='bold')
  235. plt.tight_layout()
  237. if save_path:
  238. plt.savefig(save_path, format='jpg', dpi=300)
  240. plt.show()
  242. #%%
  243. # ==== Step 1: Input Data ====
  244. # Avalanches Length features
  245. with open("Mean_Avalanches_MI_task_feedback_broad_1st_session.pkl", "rb") as f:
  246. subject_avalanche_analysis_MI_concat_1st = pickle.load(f)
  247. with open("Mean_Avalanches_Rest_task_feedback_broad_1st_session.pkl", "rb") as f:
  248. subject_avalanche_analysis_Rest_concat_1st = pickle.load(f)
  249. with open("Mean_Avalanches_MI_task_feedback_broad_2nd_session.pkl", "rb") as f:
  250. subject_avalanche_analysis_MI_concat_2nd = pickle.load(f)
  251. with open("Mean_Avalanches_Rest_task_feedback_broad_2nd_session.pkl", "rb") as f:
  252. subject_avalanche_analysis_Rest_concat_2nd = pickle.load(f)
  253. with open("Mean_Avalanches_MI_task_feedback_broad_3th_session.pkl", "rb") as f:
  254. subject_avalanche_analysis_MI_concat_3th = pickle.load(f)
  255. with open("Mean_Avalanches_Rest_task_feedback_broad_3th_session.pkl", "rb") as f:
  256. subject_avalanche_analysis_Rest_concat_3th = pickle.load(f)
  257. with open("Mean_Avalanches_MI_task_feedback_broad_4th_session.pkl", "rb") as f:
  258. subject_avalanche_analysis_MI_concat_4th = pickle.load(f)
  259. with open("Mean_Avalanches_Rest_task_feedback_broad_4th_session.pkl", "rb") as f:
  260. subject_avalanche_analysis_Rest_concat_4th = pickle.load(f)
  261. #%% Activations Features
  262. mean_activation_1 = np.load('/Users/camilla.mannino/Library/CloudStorage/OneDrive-ICM/paper_preATM/activations_1st&2nd_tot_mean_broad_weighted.pkl', allow_pickle=True)
  263. mean_activation_2 = np.load('/Users/camilla.mannino/Library/CloudStorage/OneDrive-ICM/paper_preATM/activations_3rd&4th_tot_mean_broad_weighted.pkl', allow_pickle=True)
  264. mean_activation_MI_1st = mean_activation_1['activations_MI_1st_tot_mean_broad_weigh']
  265. mean_activation_Rest_1st = mean_activation_1['activations_Rest_1st_tot_mean_broad_weigh']
  266. mean_activation_MI_2nd = mean_activation_1['activations_MI_2nd_tot_mean_broad_weigh']
  267. mean_activation_Rest_2nd = mean_activation_1['activations_Rest_2nd_tot_mean_broad_weigh']
  268. mean_activation_MI_3rd = mean_activation_2['activations_MI_3rd_tot_mean_broad_weigh']
  269. mean_activation_Rest_3rd = mean_activation_2['activations_Rest_3rd_tot_mean_broad_weigh']
  270. mean_activation_MI_4th = mean_activation_2['activations_MI_4th_tot_mean_broad_weigh']
  271. mean_activation_Rest_4th = mean_activation_2['activations_Rest_4th_tot_mean_broad_weigh']
  273. #%% Load Data over a set of selected ROIs
  275. # Avalanches Length Features
  276. #with open("Mean_Avalanches_MI_task_feedback_broad_1st_session_selected_ROIs_preATM_normalized.pkl", "rb") as f:
  277. # subject_avalanche_analysis_MI_concat_1st = pickle.load(f)
  278. #with open("Mean_Avalanches_Rest_task_feedback_broad_1st_session_selected_ROIs_preATM_normalized.pkl", "rb") as f:
  279. # subject_avalanche_analysis_Rest_concat_1st = pickle.load(f)
  280. #with open("Mean_Avalanches_MI_task_feedback_broad_2nd_session_selected_ROIs_preATM_normalized.pkl", "rb") as f:
  281. # subject_avalanche_analysis_MI_concat_2nd = pickle.load(f)
  282. #with open("Mean_Avalanches_Rest_task_feedback_broad_2nd_session_selected_ROIs_preATM_normalized.pkl", "rb") as f:
  283. # subject_avalanche_analysis_Rest_concat_2nd = pickle.load(f)
  284. #with open("Mean_Avalanches_MI_task_feedback_broad_3rd_session_selected_ROIs_preATM_normalized.pkl", "rb") as f:
  285. # subject_avalanche_analysis_MI_concat_3th = pickle.load(f)
  286. #with open("Mean_Avalanches_Rest_task_feedback_broad_3rd_session_selected_ROIs_preATM_normalized.pkl", "rb") as f:
  287. # subject_avalanche_analysis_Rest_concat_3th = pickle.load(f)
  288. #with open("Mean_Avalanches_MI_task_feedback_broad_4th_session_selected_ROIs_preATM_normalized.pkl", "rb") as f:
  289. # subject_avalanche_analysis_MI_concat_4th = pickle.load(f)
  290. #with open("Mean_Avalanches_Rest_task_feedback_broad_4th_session_selected_ROIs_preATM_normalized.pkl", "rb") as f:
  291. # subject_avalanche_analysis_Rest_concat_4th = pickle.load(f)
  293. # Activations Features
  294. #mean_activation = np.load('/Users/camilla.mannino/Library/CloudStorage/OneDrive-ICM/paper_preATM/activations_tot_mean_broad_selected_ROIs_preATM.pkl', allow_pickle=True)
  295. #mean_activation_MI_1st = mean_activation['activations_MI_1st_tot_mean_broad']
  296. #mean_activation_Rest_1st = mean_activation['activations_Rest_1st_tot_mean_broad']
  297. #mean_activation_MI_2nd = mean_activation['activations_MI_2nd_tot_mean_broad']
  298. #mean_activation_Rest_2nd = mean_activation['activations_Rest_2nd_tot_mean_broad']
  299. #mean_activation_MI_3rd = mean_activation['activations_MI_3rd_tot_mean_broad']
  300. #mean_activation_Rest_3rd = mean_activation['activations_Rest_3rd_tot_mean_broad']
  301. #mean_activation_MI_4th = mean_activation['activations_MI_4th_tot_mean_broad']
  302. #mean_activation_Rest_4th = mean_activation['activations_Rest_4th_tot_mean_broad']
  304. #%% Mean across trials for each subject inside each parameters' combination excluding trials without avalanches
  306. subjects = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]
  308. # Helper function to compute mean considering only values > 0
  309. def mean_gt_zero(values):
  310. values_gt_zero = [v for v in values if v > 0]
  311. return np.mean(values_gt_zero) if values_gt_zero else 0
  313. # ---------- First Interval ----------
  314. max_cardinal_order_MI_1st = max(len(subject_avalanche_analysis_MI_concat_1st[subject]) for subject in subjects)
  315. mean_length_array_MI_1st = [np.zeros(len(subjects)) for _ in range(max_cardinal_order_MI_1st)]
  317. for subject_index, subject in enumerate(subjects):
  318. subject_keys = list(subject_avalanche_analysis_MI_concat_1st[subject].keys())
  319. for cardinal_position, key in enumerate(subject_keys):
  320. mean_val = mean_gt_zero(
  321. subject_avalanche_analysis_MI_concat_1st[subject][key]["mean_lengths_per_trial"])
  322. mean_length_array_MI_1st[cardinal_position][subject_index] = mean_val
  324. max_cardinal_order_Rest_1st = max(len(subject_avalanche_analysis_Rest_concat_1st[subject]) for subject in subjects)
  325. mean_length_array_Rest_1st = [np.zeros(len(subjects)) for _ in range(max_cardinal_order_Rest_1st)]
  327. for subject_index, subject in enumerate(subjects):
  328. subject_keys = list(subject_avalanche_analysis_Rest_concat_1st[subject].keys())
  329. for cardinal_position, key in enumerate(subject_keys):
  330. mean_val = mean_gt_zero(
  331. subject_avalanche_analysis_Rest_concat_1st[subject][key]["mean_lengths_per_trial"])
  332. mean_length_array_Rest_1st[cardinal_position][subject_index] = mean_val
  334. # ---------- Second Interval ----------
  335. max_cardinal_order_MI_2nd = max(len(subject_avalanche_analysis_MI_concat_2nd[subject]) for subject in subjects)
  336. mean_length_array_MI_2nd = [np.zeros(len(subjects)) for _ in range(max_cardinal_order_MI_2nd)]
  338. for subject_index, subject in enumerate(subjects):
  339. subject_keys = list(subject_avalanche_analysis_MI_concat_2nd[subject].keys())
  340. for cardinal_position, key in enumerate(subject_keys):
  341. mean_val = mean_gt_zero(
  342. subject_avalanche_analysis_MI_concat_2nd[subject][key]["mean_lengths_per_trial"])
  343. mean_length_array_MI_2nd[cardinal_position][subject_index] = mean_val
  345. max_cardinal_order_Rest_2nd = max(len(subject_avalanche_analysis_Rest_concat_2nd[subject]) for subject in subjects)
  346. mean_length_array_Rest_2nd = [np.zeros(len(subjects)) for _ in range(max_cardinal_order_Rest_2nd)]
  348. for subject_index, subject in enumerate(subjects):
  349. subject_keys = list(subject_avalanche_analysis_Rest_concat_2nd[subject].keys())
  350. for cardinal_position, key in enumerate(subject_keys):
  351. mean_val = mean_gt_zero(
  352. subject_avalanche_analysis_Rest_concat_2nd[subject][key]["mean_lengths_per_trial"])
  353. mean_length_array_Rest_2nd[cardinal_position][subject_index] = mean_val
  355. # ---------- Third Interval ----------
  356. max_cardinal_order_MI_3rd = max(len(subject_avalanche_analysis_MI_concat_3th[subject]) for subject in subjects)
  357. mean_length_array_MI_3rd = [np.zeros(len(subjects)) for _ in range(max_cardinal_order_MI_3rd)]
  359. for subject_index, subject in enumerate(subjects):
  360. subject_keys = list(subject_avalanche_analysis_MI_concat_3th[subject].keys())
  361. for cardinal_position, key in enumerate(subject_keys):
  362. mean_val = mean_gt_zero(
  363. subject_avalanche_analysis_MI_concat_3th[subject][key]["mean_lengths_per_trial"])
  364. mean_length_array_MI_3rd[cardinal_position][subject_index] = mean_val
  366. max_cardinal_order_Rest_3rd = max(len(subject_avalanche_analysis_Rest_concat_3th[subject]) for subject in subjects)
  367. mean_length_array_Rest_3rd = [np.zeros(len(subjects)) for _ in range(max_cardinal_order_Rest_3rd)]
  369. for subject_index, subject in enumerate(subjects):
  370. subject_keys = list(subject_avalanche_analysis_Rest_concat_3th[subject].keys())
  371. for cardinal_position, key in enumerate(subject_keys):
  372. mean_val = mean_gt_zero(
  373. subject_avalanche_analysis_Rest_concat_3th[subject][key]["mean_lengths_per_trial"])
  374. mean_length_array_Rest_3rd[cardinal_position][subject_index] = mean_val
  376. # ---------- Fourth Interval ----------
  377. max_cardinal_order_MI_4th = max(len(subject_avalanche_analysis_MI_concat_4th[subject]) for subject in subjects)
  378. mean_length_array_MI_4th = [np.zeros(len(subjects)) for _ in range(max_cardinal_order_MI_4th)]
  380. for subject_index, subject in enumerate(subjects):
  381. subject_keys = list(subject_avalanche_analysis_MI_concat_4th[subject].keys())
  382. for cardinal_position, key in enumerate(subject_keys):
  383. mean_val = mean_gt_zero(
  384. subject_avalanche_analysis_MI_concat_4th[subject][key]["mean_lengths_per_trial"])
  385. mean_length_array_MI_4th[cardinal_position][subject_index] = mean_val
  387. max_cardinal_order_Rest_4th = max(len(subject_avalanche_analysis_Rest_concat_4th[subject]) for subject in subjects)
  388. mean_length_array_Rest_4th = [np.zeros(len(subjects)) for _ in range(max_cardinal_order_Rest_4th)]
  390. for subject_index, subject in enumerate(subjects):
  391. subject_keys = list(subject_avalanche_analysis_Rest_concat_4th[subject].keys())
  392. for cardinal_position, key in enumerate(subject_keys):
  393. mean_val = mean_gt_zero(
  394. subject_avalanche_analysis_Rest_concat_4th[subject][key]["mean_lengths_per_trial"])
  395. mean_length_array_Rest_4th[cardinal_position][subject_index] = mean_val
  397. #%% Difference avalanches' length computation for all sessions: Avalanches length
  399. mean_length_diff = {}
  400. for session_index, mean_length_array_Rest, mean_length_array_MI in zip(
  401. range(1, 5),
  402. [mean_length_array_Rest_1st, mean_length_array_Rest_2nd, mean_length_array_Rest_3rd, mean_length_array_Rest_4th],
  403. [mean_length_array_MI_1st, mean_length_array_MI_2nd, mean_length_array_MI_3rd, mean_length_array_MI_4th],
  404. ):
  405. mean_length_diff[session_index] = {
  406. cardinal_position: mean_length_array_Rest[cardinal_position] - mean_length_array_MI[cardinal_position]
  407. for cardinal_position in range(len(mean_length_array_Rest))
  408. }
  410. #%% Difference activations computation for all sessions: Activations
  411. mean_activation_diff = {}
  413. for session_index, mean_activation_array_Rest, mean_activation_array_MI in zip(range(1, 5),
  414. [mean_activation_Rest_1st, mean_activation_Rest_2nd, mean_activation_Rest_3rd, mean_activation_Rest_4th],
  415. [mean_activation_MI_1st, mean_activation_MI_2nd, mean_activation_MI_3rd, mean_activation_MI_4th],):
  416. mean_activation_diff[session_index] = {
  417. cardinal_position: {
  418. key: mean_activation_array_Rest[cardinal_position][key] - mean_activation_array_MI[cardinal_position][key]
  419. for key in mean_activation_array_Rest[cardinal_position]
  420. }
  421. for cardinal_position in range(len(mean_activation_array_Rest))
  422. }
  424. #%%
  425. n_cardinal_position = 10
  427. BCI_scores = {
  428. 1: np.array([73.8, 45, 66.1, 50, 51.7, 61.2, 54.4, 59.4, 52.8, 42.2, 53.9, 47.22, 53.3, 54.17, 60, 76.1, 48.33, 56, 53.89, 45]),
  429. 2: np.array([90.2, 35.6, 61.7, 50, 51.7, 50.6, 58.9, 66.11, 50, 45.6, 45, 52.22, 65.6, 50, 68.9, 70.6, 61.67, 63.89, 53.89, 57.22]),
  430. 3: np.array([86.6, 38.9, 72.8, 62.8, 61.7, 79.3, 51.7, 56.67, 68.9, 58.9, 55.6, 47.78, 57.8, 60, 76.1, 53.9, 66, 72, 52.78, 58.33]),
  431. 4: np.array([89.3, 38.1, 86.1, 73.1, 63.9, 88.9, 56.7, 70.0, 60.0, 66.1, 63.3, 53.9, 77.2, 69.2, 80.0, 61.1, 71.0, 73.0, 68.3, 56.7])
  432. }
  434. # 57.8 is the chance level - we set it as threshold
  435. binary_BCI_scores = {
  436. key: (values > 57).astype(int)
  437. for key, values in BCI_scores.items()
  438. }
  440. #%%
  441. # Parameters
  442. n_subjects = 20
  443. n_sessions = 4
  444. results = {}
  446. for cardinal_position in range(10):
  447. X_data = {session: [] for session in range(1, n_sessions + 1)}
  448. Y_data = binary_BCI_scores
  449. X_temporal_list = []
  451. for subj in range(n_subjects):
  452. features_per_subject = []
  454. for session in range(1, n_sessions + 1):
  455. length_feat = mean_length_diff[session][cardinal_position][subj]
  456. activations_feat = mean_activation_diff[session][cardinal_position][subj]
  457. features_matrix = np.array([length_feat, activations_feat])
  458. X_data[session].append(features_matrix)
  459. features_per_subject.append(features_matrix)
  461. y_true_session4 = Y_data[4]
  463. X_list, y_list = [], []
  464. for subj in range(n_subjects):
  465. X_subj = np.vstack([X_data[1][subj], X_data[2][subj], X_data[3][subj]])
  466. y_subj = np.array([Y_data[1][subj], Y_data[2][subj], Y_data[3][subj]])
  467. X_list.append(X_subj)
  468. y_list.append(y_subj)
  470. best_acc = 0
  471. best_acc_perc = 0
  472. best_acc_preds = []
  474. # Define grid of hyperparameters
  475. C_grid = [0.01, 0.1, 1, 10]
  476. tol_grid = [1e-10, 1e-9, 1e-8, 1e-7, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1]
  477. max_iter_grid = [50,100, 200]
  479. grid_results = {}
  481. # Store results for each value of C
  482. results_normal = {}
  484. for C in C_grid:
  485. y_preds_normal = []
  487. # Normal Model (SVC)
  488. normal_model = SVC(C=C, kernel='linear')
  490. # Perform Leave-One-Out Cross Validation (LOO)
  491. loo = LeaveOneOut()
  492. for train_idx, test_idx in loo.split(X_list):
  493. X_train = np.vstack([X_list[i] for i in train_idx])
  494. y_train = np.concatenate([y_list[i] for i in train_idx])
  495. X_test = np.vstack([X_list[i] for i in test_idx])
  497. # Train and predict with the normal model
  498. normal_model.fit(X_train, y_train)
  499. y_pred_normal = normal_model.predict(X_test)
  501. y_preds_normal.append(y_pred_normal[0])
  503. # Calculate accuracy for the normal model
  504. acc_normal = balanced_accuracy_score(y_true_session4, y_preds_normal)
  506. # Confusion matrix for the normal model
  507. cm_normal = confusion_matrix(y_true_session4, y_preds_normal)
  509. # Plot for normal SVC
  510. # vertical_dot_plot(y_true_session4, y_preds_normal, "SVC, Accuracy: 41%", save_path="normal_svc_results_new_2.jpg")
  511. # Store results for the current value of C
  512. results_normal[C] = {'Accuracy Normal': acc_normal, 'Confusion Matrix': cm_normal}
  514. # Print the results for the current value of C
  515. print(f"Results for Normal Model with C={C}:, Cardinal_position:{cardinal_position}")
  516. print(f"Accuracy Normal, Cardinal_position: {cardinal_position}: {acc_normal:.2f}")
  517. print(f"Confusion Matrix Normal, Cardinal_position {cardinal_position}:\n{cm_normal}")
  519. # Optional: Print the best model (highest accuracy) after the loop
  520. best_C = max(results_normal, key=lambda k: results_normal[k]['Accuracy Normal'])
  521. best_result = results_normal[best_C]
  523. print(f"Best C, Cardinal_position {cardinal_position}: {best_C}")
  524. print(f"Best Accuracy Normal, Cardinal_position {cardinal_position}: {best_result['Accuracy Normal']:.2f}")
  525. print(f"Best Confusion Matrix, Cardinal_position {cardinal_position}:\n{best_result['Confusion Matrix']}")
  528. #%% Logitudinal Support Vector Classifier Model
  529. # Hyperparameter grid search
  530. for C in C_grid:
  531. for tol in tol_grid:
  532. for max_iter in max_iter_grid:
  533. y_preds_lsvc = []
  535. # Perform Leave-One-Out Cross Validation (LOO)
  536. loo = LeaveOneOut()
  537. for train_idx, test_idx in loo.split(X_list):
  538. X_train = [X_list[i] for i in train_idx]
  539. y_train = [y_list[i] for i in train_idx]
  540. X_test = [X_list[i] for i in test_idx]
  542. try:
  543. alpha, beta, y_bin_train = longitudinal_svc_iterative(X_train, y_train, C=C, tol=tol,
  544. max_iter=max_iter)
  545. y_pred_lsvc = predict_lsvc(X_test, X_train, alpha, beta, y_bin_train)[0]
  546. except Exception as e:
  547. print(f"Skipped config C={C}, tol={tol}, max_iter={max_iter} due to error: {e}")
  548. y_pred_lsvc = 0 # Fallback value
  549. y_preds_lsvc.append(y_pred_lsvc)
  551. # Calculate accuracy and store results
  552. acc_l = balanced_accuracy_score(y_true_session4, y_preds_lsvc)
  553. grid_results[(C, tol, max_iter)] = {'Accuracy Long': acc_l, 'Predictions Long': y_preds_lsvc}
  555. # Find best hyperparameter configuration
  556. best_config = max(grid_results, key=lambda k: grid_results[k]['Accuracy Long'])
  557. best_result = grid_results[best_config]
  559. # Get predicted BCI scores
  560. y_true = np.array(Y_data[4]) # Actual BCI scores for session 4
  561. y_pred = np.array(best_result['Predictions Long']) # Predicted BCI scores for session 4
  563. # Compute confusion matrix
  564. cm = confusion_matrix(y_true, y_pred)
  565. #vertical_dot_plot(y_true_session4, y_pred, "LSVC, Accuracy: 88%", save_path="lsvc_results_new_2.jpg")
  567. print(f"Confusion Matrix for Cardinal Position {cardinal_position}:")
  568. print(cm)
  570. # Print best hyperparameter configuration and results
  571. print(f"Best configuration, Cardinal_position:{cardinal_position}: C={best_config[0]}, tol={best_config[1]}, max_iter={best_config[2]}")
  572. print(f"Best Accuracy, Cardinal_position:{cardinal_position}: {best_result['Accuracy Long']:.2f}")
  573. print(f"Predictions, Cardinal_position:{cardinal_position}: {best_result['Predictions Long']}")
  576. #%% Longitudinal Support Vector Classifier random session
  578. # Data structure to hold the features per session
  579. for cardinal_position in range(10):
  581. X_data = {session: [] for session in range(1, n_sessions + 1)} # Initialize X_data
  583. # Step 1: Extract features for each subject and session
  585. for subj in range(n_subjects):
  586. for session in range(1, n_sessions + 1):
  587. # Placeholder for actual feature extraction (replace with your real data extraction)
  588. length_feat = mean_length_diff[session][cardinal_position][subj]
  589. activations_feat = mean_activation_diff[session][cardinal_position][subj]
  590. features_matrix = np.array([length_feat, activations_feat])
  591. X_data[session].append(features_matrix)
  593. # Step 2: Shuffle the sessions for each subject independently (shuffling only X_data, not Y_data)
  594. shuffled_X_data = {session: [] for session in range(1, n_sessions + 1)}
  596. for subj in range(n_subjects):
  597. sessions_order = np.random.permutation(n_sessions) # Shuffle the sessions for each subject
  598. for i, session_idx in enumerate(sessions_order):
  599. session = session_idx + 1 # Session number starts from 1
  600. shuffled_X_data[session].append(X_data[session][subj])
  602. # Step 3: Create the final X_data and y_data
  603. X_list, y_list = [], []
  604. for subj in range(n_subjects):
  605. # Stack the shuffled session data for each subject
  606. X_subj = np.vstack([shuffled_X_data[session][subj] for session in range(1, n_sessions + 1)])
  608. # Keep the original labels (y_subj) for each subject intact (no shuffling of Y_data)
  609. y_subj = np.array([Y_data[1][subj], Y_data[2][subj], Y_data[3][subj]])
  611. X_list.append(X_subj)
  612. y_list.append(y_subj)
  614. # Convert to numpy arrays for easy handling during model training
  615. X_data_final = np.vstack(X_list)
  616. y_data_final = np.array(y_list)
  618. print("Shuffling Session complete. X_data_final and y_data_final are ready for further analysis.")
  620. # Step 4: Hyperparameter grid search initialization
  621. grid_results = {}
  623. # Step 5: Perform Leave-One-Out Cross Validation (LOO) and grid search for hyperparameters
  624. y_true_session4 = Y_data[4] # Labels for session 4
  625. best_acc = 0
  626. best_acc_perc = 0
  627. best_acc_preds = []
  629. for C in C_grid:
  630. for tol in tol_grid:
  631. for max_iter in max_iter_grid:
  632. y_preds = []
  634. # Leave-One-Out Cross Validation
  635. loo = LeaveOneOut()
  636. for train_idx, test_idx in loo.split(X_list):
  637. X_train = [X_list[i] for i in train_idx]
  638. y_train = [y_list[i] for i in train_idx]
  639. X_test = [X_list[i] for i in test_idx]
  641. try:
  642. # Replace this with your actual model training and prediction functions
  643. alpha, beta, y_bin_train = longitudinal_svc_iterative(X_train, y_train, C=C, tol=tol, max_iter=max_iter)
  644. y_pred_lsvc = predict_lsvc(X_test, X_train, alpha, beta, y_bin_train)[0]
  645. except Exception as e:
  646. print(f"Skipped config C={C}, tol={tol}, max_iter={max_iter} due to error: {e}")
  647. y_pred_lsvc = 0 # Fallback value
  649. y_preds.append(y_pred_lsvc)
  651. # Evaluate and store results
  652. acc = balanced_accuracy_score(y_true_session4, y_preds)
  653. grid_results[(C, tol, max_iter)] = {'Accuracy': acc, 'Predictions': y_preds}
  655. # Step 6: Find best hyperparameter configuration
  656. best_config = max(grid_results, key=lambda k: grid_results[k]['Accuracy'])
  657. best_result = grid_results[best_config]
  659. # Step 7: Get predicted and actual BCI scores
  660. y_true = np.array(Y_data[4]) # Actual BCI scores for session 4
  661. y_pred = np.array(best_result['Predictions']) # Predicted BCI scores for session 4
  663. # Step 8: Compute confusion matrix
  664. cm = confusion_matrix(y_true, y_pred)
  665. print(f"Confusion Matrix:")
  666. print(cm)
  668. # vertical_dot_plot(y_true_session4, y_pred, "LSVC, Random Sessions, Accuracy: 47%", save_path="lsvc_results_random_session_new2.jpg")
  670. # Step 9: Print best hyperparameter configuration and results
  671. print(f"Best configuration, Cardinal_position:{cardinal_position}: C={best_config[0]}, tol={best_config[1]}, max_iter={best_config[2]}")
  672. print(f"Best Accuracy, Cardinal_position:{cardinal_position}: {best_result['Accuracy']:.2f}")
  673. print(f"Predictions, Cardinal_position:{cardinal_position}: {best_result['Predictions']}")
  675. #%% Longitudinal Support Vector Classifier with Random Session and Random Subjects
  676. # Set seeds for reproducibility
  677. #seed_value = 24
  678. #np.random.seed(seed_value)
  679. #random.seed(seed_value)
  681. #for cardinal_position in range(10):
  682. # Extract features per subject and session
  683. # for subj in range(n_subjects):
  684. # for session in range(1, n_sessions + 1):
  685. # length_feat = mean_length_diff[session][cardinal_position][subj]
  686. # activations_feat = mean_activation_diff[session][cardinal_position][subj]
  687. # features_matrix = np.array([length_feat, activations_feat])
  688. # X_data[session].append(features_matrix)
  690. # Shuffle the sessions for each subject independently
  691. # shuffled_X_data = {session: [] for session in range(1, n_sessions + 1)}
  692. # for subj in range(n_subjects):
  693. # sessions_order = np.random.permutation(n_sessions)
  694. # for i, session_idx in enumerate(sessions_order):
  695. # session = session_idx + 1
  696. # shuffled_X_data[session].append(X_data[session][subj])
  698. # Shuffle subjects themselves
  699. # subject_order = np.random.permutation(n_subjects)
  700. # X_list, y_list = [], []
  701. # for subj_idx in subject_order:
  702. # X_subj = np.vstack([shuffled_X_data[session][subj_idx] for session in range(1, n_sessions + 1)])
  703. # y_subj = np.array([Y_data[session][subj_idx] for session in range(1, n_sessions + 1)])
  704. # X_list.append(X_subj)
  705. # y_list.append(y_subj)
  707. # X_data_final = np.vstack(X_list)
  708. # y_data_final = np.hstack(y_list)
  709. # print("Shuffling Subj + Sessions complete. X_data_final and y_data_final are ready for further analysis.")
  711. # Hyperparameter grid search initialization
  712. # grid_results = {}
  713. # y_true_session4 = Y_data[4]
  714. # best_acc = 0
  715. # best_acc_perc = 0
  716. # best_acc_preds = []
  718. # for C in C_grid:
  719. # for tol in tol_grid:
  720. # for max_iter in max_iter_grid:
  721. # y_preds = []
  722. # loo = LeaveOneOut()
  723. # for train_idx, test_idx in loo.split(X_list):
  724. # X_train = [X_list[i] for i in train_idx]
  725. # y_train = [y_list[i] for i in train_idx]
  726. # X_test = [X_list[i] for i in test_idx]
  727. # try:
  728. # alpha, beta, y_bin_train = longitudinal_svc_iterative(X_train, y_train, C=C, tol=tol,
  729. # max_iter=max_iter)
  730. # y_pred_lsvc = predict_lsvc(X_test, X_train, alpha, beta, y_bin_train)[0]
  731. # except Exception as e:
  732. # print(f"Skipped config C={C}, tol={tol}, max_iter={max_iter} due to error: {e}")
  733. # y_pred_lsvc = 0
  734. # y_preds.append(y_pred_lsvc)
  736. # acc = balanced_accuracy_score(y_true_session4, y_preds)
  737. # grid_results[(C, tol, max_iter)] = {'Accuracy': acc, 'Predictions': y_preds}
  739. # best_config = max(grid_results, key=lambda k: grid_results[k]['Accuracy'])
  740. # best_result = grid_results[best_config]
  741. # y_true = np.array(Y_data[4])
  742. # y_pred = np.array(best_result['Predictions'])
  744. # cm = confusion_matrix(y_true, y_pred)
  745. # print(f"Confusion Matrix for Cardinal Position {cardinal_position}:")
  746. # print(cm)
  748. # vertical_dot_plot(y_true_session4, y_pred, "LSVC, Random Sessions & Random Subjects, Accuracy: 62%",
  749. # save_path="lsvc_results_random_subject&sessions_new2.jpg")
  751. # print(
  752. # f"Best configuration, Cardinal_position:{cardinal_position}: C={best_config[0]}, tol={best_config[1]}, max_iter={best_config[2]}")
  753. # print(f"Best Accuracy, Cardinal_position:{cardinal_position}: {best_result['Accuracy']:.2f}")
  754. # print(f"Predictions, Cardinal_position:{cardinal_position}: {best_result['Predictions']}")

LSVC_model.py at commit 45a88f8, no license · at the source

Overview

Authors: Camilla Mannino1, Pierpaolo Sorrentino2,3, Mario Chavez1, Marie-Constance Corsi1
ORCID iDs: Camilla Mannino, Pierpaolo Sorrentino, Mario Chavez, Marie-Constance Corsi
  1. Sorbonne Université, Paris Brain Institute-ICM, CNRS, Inria, Inserm, AP-HP, Hôpital de la Pitié Salpêtrière, Paris, France
  2. Institut de Neurosciences des Systèmes, Aix-Marseille Université, Marseille, France
  3. Department of Biomedical Sciences, University of Sassari, Sassari, Italy
Institutions: Centre National de la Recherche Scientifique (France); Inserm (France); Sorbonne Université (France); Assistance Publique – Hôpitaux de Paris (France); Pitié-Salpêtrière Hospital (France); Institut du Cerveau (France); University of Sassari (Italy); Aix-Marseille Université (France); Institut de Neurosciences des Systèmes (France)
Journal: Imaging neuroscience (Cambridge, Mass.), volume 4, article IMAG.a.1259
Dates: received 12 August 2025; accepted 4 May 2026; published online 29 May 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1162/imag.a.1259 · PMID 42232076 · PMCID PMC13224313 · OpenAlex W4411036309
Open access: diamond, a free copy (OpenAlex)
Preprint: doi:10.1101/2025.05.31.657206
Status: code verified
Categories: EEG (modality), clinical / translational (subfield)
Methods: Spectral & time-frequency, Connectivity, Statistics, Smoothing, state filtering, decompositions, Machine learning, Preprocessing, fMRI & imaging, Single-unit activity, calcium imaging
Keywords: neuronal avalanches, Brain-Computer Interface (BCI), motor imagery, Electroencephalography (EEG), task-condition effect, learning effect, BCI-score repeated correlation, longitudinal predictive model, personalized training protocol
Topic: EEG and Brain-Computer Interfaces (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Citations: not cited yet (Europe PMC); 50 references in the paper

Abstract

Motor imagery-based Brain-Computer Interfaces (BCIs) restore control in persons with motor impairments, but up to 30% of users struggle, a phenomenon known as “BCI inefficiency”. This study tackles a key limitation of current protocol: the use of fixed-length sessions training paradigms that ignore individual learning variability. We propose a novel approach based on neuronal avalanches, spatiotemporal cascades of brain activities, as biomarkers to characterize and predict user-specific learning. From electroencephalography data across four sessions in 20 subjects, we characterized avalanches by their length and their spatiotemporal size. These features showed significant training and task effects and were found to correlate to BCI performance across sessions. We further assessed their ability to predict BCI success through longitudinal models, achieving up to 91% accuracy, improved by spatial filtering on selected brain regions. These findings demonstrate the utility of neuronal avalanche dynamics as robust biomarkers for BCI training, supporting the development of personalized protocols aimed at mitigating BCI illiteracy.

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

Repository

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

CamiMannino/Neuronal-avalanches-as-a-predictive-biomarker-for-guiding-tailored-BCI-training-programs

License: none: the authors keep all their rights
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: 45a88f8b7911f116d0359b5433c72acd2bd05636, 11 August 2025
Languages: Python (9)
Size: 10 files, 9 scripts
Software Heritage: not archived
Found in: “Data and Code Availability”
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: Matplotlib (9 files), NumPy (9 files), MNE-Python (7 files), SciPy (7 files), statsmodels (7 files), pandas (6 files), scikit-learn (6 files), seaborn (6 files), Pingouin (4 files)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
10 files
At the source: github.com/CamiMannino/Neuronal-avalanches-as-a-predictive-biomarker-for-guiding-tailored-BCI-training-programs

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

Tracing map

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

What the map holds:

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

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

Data

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

Data and Code Availability

The study dataset has been fully collected and curated. A dedicated data-descriptor paper is currently in preparation; upon its acceptance, the de-identified dataset and full documentation will be deposited in an open repository with a citable DOI and made publicly available. Until release, controlled access may be granted on reasonable request to the corresponding author.

Code used to import data, analyse data, and generate manuscript figures are available on GitHub: https://github.com/CamiMannino/Neuronal-avalanches-as-a-predictive-biomarker-for-guiding-tailored-BCI-training-programs.

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

Recorded: type, language, journal, volume, pages, dates, 4 authors, 9 keywords, 49 references.

Cite

This paper

Mannino, C., Sorrentino, P., Chavez, M., & Corsi, M.-C. (2026). Neuronal avalanches as a predictive biomarker for guiding tailored BCI training programs. Imaging neuroscience (Cambridge, Mass.), 4, IMAG.a.1259. https://doi.org/10.1162/imag.a.1259

BibTeX

@article{mannino2026neuronal,
author = {Mannino, Camilla and Sorrentino, Pierpaolo and Chavez, Mario and Corsi, Marie-Constance},
title = {{Neuronal avalanches as a predictive biomarker for guiding tailored BCI training programs}},
journal = {Imaging neuroscience (Cambridge, Mass.)},
year = {2026},
month = may,
volume = {4},
pages = {IMAG.a.1259},
publisher = {MIT Press},
issn = {2837-6056},
doi = {10.1162/imag.a.1259},
url = {https://doi.org/10.1162/imag.a.1259},
pmid = {42232076},
pmcid = {PMC13224313}
}

RIS

TY - JOUR
AU - Mannino, Camilla
AU - Sorrentino, Pierpaolo
AU - Chavez, Mario
AU - Corsi, Marie-Constance
TI - Neuronal avalanches as a predictive biomarker for guiding tailored BCI training programs
T2 - Imaging neuroscience (Cambridge, Mass.)
J2 - Imaging Neurosci (Camb)
PY - 2026
DA - 2026/05/29
VL - 4
SP - IMAG.a.1259
SN - 2837-6056
PB - MIT Press
DO - 10.1162/imag.a.1259
UR - https://doi.org/10.1162/imag.a.1259
LA - en
ER -

CSL-JSON

{
"id": "10.1162/imag.a.1259",
"type": "article-journal",
"title": "Neuronal avalanches as a predictive biomarker for guiding tailored BCI training programs",
"container-title": "Imaging neuroscience (Cambridge, Mass.)",
"author": [
{
"family": "Mannino",
"given": "Camilla"
},
{
"family": "Sorrentino",
"given": "Pierpaolo"
},
{
"family": "Chavez",
"given": "Mario"
},
{
"family": "Corsi",
"given": "Marie-Constance"
}
],
"container-title-short": "Imaging Neurosci (Camb)",
"volume": "4",
"page": "IMAG.a.1259",
"DOI": "10.1162/imag.a.1259",
"PMID": "42232076",
"PMCID": "PMC13224313",
"ISSN": "2837-6056",
"publisher": "MIT Press",
"URL": "https://doi.org/10.1162/imag.a.1259",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
29
]
]
}
}

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.1348 [code]
The role of high-amplitude bursts of high-gamma activity in naturalistic speech and music listening.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: MNE-Python, seaborn, pandas, 3 other tools, 5 references
[2] doi:10.1162/imag.a.1193
Linking local and large-scale salient events with oscillatory and broadband arrhythmic activities in the resting human brain.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: 5 references, author Pierpaolo Sorrentino
[3] doi:10.7554/elife.100605 [code]
Age-related changes in ‘cortical’ 1/f dynamics are linked to cardiac activity
Journal: n/a
In common: Pingouin, MNE-Python, statsmodels, 6 other tools, 1 reference
[4] doi:10.7554/elife.108673 [code]
Adaptive behavior is guided by integrated representations of controlled and non-controlled information.
Journal: eLife
In common: Pingouin, MNE-Python, statsmodels, 6 other tools, EEG
[5] doi:10.1162/imag.a.1269 [code]
From early to contemporary normative modeling: Mapping individual differences in neurophysiological signals.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Pingouin, MNE-Python, statsmodels, 6 other tools, EEG
[6] doi:10.1093/cercor/bhag077 [code]
The longitudinal development of intrinsic timescales in infancy and their relation to alpha brain rhythm.
Journal: Cerebral cortex (New York, N.Y. : 1991)
In common: Pingouin, MNE-Python, statsmodels, 6 other tools, EEG
[7] doi:10.1038/s41597-026-07350-9 [code]
An open multi-center MEG-EEG dataset for studying conscious visual perception.
Journal: Scientific data
In common: Pingouin, MNE-Python, statsmodels, 6 other tools, EEG
[8] doi:10.1038/s41531-026-01380-1 [code]
Identifying maximal beta power from directional subthalamic local field potentials in Parkinson's disease.
Journal: NPJ Parkinson's disease
In common: Pingouin, MNE-Python, statsmodels, 6 other tools, clinical / translational
[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: Pingouin, MNE-Python, statsmodels, 5 other tools, EEG, 1 reference
[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: Pingouin, MNE-Python, statsmodels, 6 other tools

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.