OSCR

Spatiotemporal Dynamics in Prespeech Semantic Category Decoding: An Intracranial EEG Study.

Code ↔ Paper

5 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 5 matches
  1. [1] § Materials and Methods › Cross-temporal regression analysis ↔ 2.5-2.7_decoding_semantic_left.py, lines 551–623 · score 0.68 · R2 matrices, linear regression, cross temporal, BA pairs, body, mapping
  2. [2] § Materials and Methods › Preprocessing ↔ 2.4_preprocessing_sub16.m, lines 84–174 · score 0.64 · wavelet transform, 70–170 Hz, amplitudes, baseline, HG, Preprocessing
  3. [3] § Result › Time-resolved semantic category decoding performance ↔ 2.5-2.7_decoding_semantic_left.py, lines 53–62 · score 0.58 · temporal pole, dlPFC, frontal, parietal, gyrus, occipital
  4. [4] § Result › Interregional predictive dynamics in prespeech ↔ 2.5-2.7_decoding_semantic_left.py, lines 551–623 · score 0.58 · R2 matrix, linear regression, Cross temporal, BA
  5. [5] § Result › Time-resolved semantic category decoding performance ↔ 2.5-2.7_decoding_semantic_left.py, lines 53–62 · score 0.51 · dlPFC, pars, supramarginal, fusiform, frontal, parietal

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 · 623 lines · 25 KB · no license · 4 matches

  2. """
  3. Author: Ye Jin Park <[email hidden]>
  4. Seoul National University
  5. Human Brain Function Laboratory
  7. ECoG_Decoding : Semantic category [Left hemisphere]
  9. """
  11. #%% Imports and Parameters
  12. import os
  13. import numpy as np
  14. import pandas as pd
  15. import scipy.io as sio
  16. import matplotlib.pyplot as plt
  17. import seaborn as sns
  18. from collections import defaultdict
  19. from itertools import permutations
  20. from sklearn.svm import SVC
  21. from sklearn.pipeline import make_pipeline
  22. from sklearn.preprocessing import StandardScaler
  23. from sklearn.linear_model import LinearRegression
  24. from sklearn.utils import shuffle
  25. from sklearn.model_selection import StratifiedKFold
  26. from scipy.stats import ttest_1samp
  27. from statsmodels.stats.multitest import multipletests
  28. import warnings
  29. warnings.filterwarnings("ignore")
  31. # Paths and constants
  32. base_path = 'G:/export'
  33. output_dir = 'C:/Users/yejin/OneDrive/1st_result'
  34. talairach_path = 'G:/Talairach/Talairach.xlsx'
  35. os.makedirs(output_dir, exist_ok=True)
  37. subjects = ['220112_NBM', '220209_CJS', '220224_PJW', '220310_JAH', '220503_HSH2',
  38. '220707_JHJ', '220803_SJH', '221018_JSH', '230328_KHS', '230728_LSJ_left']
  39. subject_ba_mapping = {
  40. '220112_NBM': 'NBM', '220209_CJS': 'CJS', '220224_PJW': 'PJW', '220310_JAH': 'JAH',
  41. '220503_HSH2': 'HSH2', '220707_JHJ': 'JHJ', '220803_SJH': 'SJH', '221018_JSH': 'JSH',
  42. '230328_KHS': 'KHS', '230728_LSJ_left': 'LSJ_L'
  43. }
  45. f_low, f_high = 70, 170
  46. win_size, step_size = 10, 5
  47. usable_timepoints = 55
  48. window_starts = list(range(0, usable_timepoints - win_size + 1, step_size))
  49. window_centers = [(start + win_size // 2) * 10 for start in window_starts]
  50. n_folds = 5
  51. n_permutations = 1000
  53. # Load BA mapping
  54. ba_to_lobe = {
  55. 'Left-AntPFC (10)': 'Frontal', 'Left-dlPFC(dorsal) (9)': 'Frontal', 'Left-dlPFC(lat) (46)': 'Frontal',
  56. 'Left-OrbFrontal (11)': 'Frontal', 'Left-ParsOrbitalis (47)': 'Frontal', 'Left-Broca-Operc (44)': 'Frontal',
  57. 'Left-Broca-Triang (45)': 'Frontal', 'Left-PreMot+SuppMot (6)': 'Frontal', 'Left-PrimMotor (4)': 'Frontal',
  58. 'Left-InfTempGyrus (20)': 'Temporal', 'Left-MedTempGyrus (21)': 'Temporal', 'Left-SupTempGyrus (22)': 'Temporal',
  59. 'Left-TemporalPole (38)': 'Temporal', 'Left-PrimAuditory (41)': 'Temporal', 'Left-Fusiform (37)': 'Occipital',
  60. 'Left-AngGyrus (39)': 'Parietal', 'Left-SupramargGyr (40)': 'Parietal', 'Left-PrimSensory (1)': 'Parietal',
  61. 'Left-SecVisual (18)': 'Occipital', 'Left-VisAssoc (19)': 'Occipital', 'Left-VisMotor (7)': 'Occipital'
  62. }
  64. #%% Step 1–3: Load data and store trials for feature selection and decoding separately
  65. print("Step 1–3 : loading data and splitting into selection and decoding sets…")
  67. talairach_df = pd.read_excel(talairach_path)
  69. channel_data_train = defaultdict(lambda: defaultdict(list))
  70. channel_data_test = defaultdict(lambda: defaultdict(list))
  71. selected_channels = defaultdict(list)
  72. selected_channels_by_subj = defaultdict(list)
  73. channel_owner = dict()
  75. rng, train_ratio = np.random.RandomState(42), 0.7
  77. # 1) Load and split data
  78. for subj in subjects:
  79. try:
  80. subj_short = subject_ba_mapping[subj]
  82. body_data = sio.loadmat(os.path.join(base_path, subj, f"A0_body_{subj}.mat"))['Con_TFData_cut']
  83. nonbody_data = sio.loadmat(os.path.join(base_path, subj, f"A1_nonbody_{subj}.mat"))['Con_TFData_cut']
  84. chan_list = sio.loadmat(os.path.join(base_path, subj, "ChanList.mat"))['ChanList'][0]
  86. body_hg = body_data[:, f_low:f_high, :55, :].mean(axis=1)
  87. nonbody_hg = nonbody_data[:, f_low:f_high, :55, :].mean(axis=1)
  89. for idx in range(body_hg.shape[0]):
  90. real_ch = int(chan_list[idx])
  92. ba_row = talairach_df[(talairach_df['Subject'] == subj_short) &
  93. (talairach_df['Channel'] == real_ch)]
  94. if ba_row.empty:
  95. continue
  96. ba = ba_row['BA'].values[0]
  98. channel_owner[(ba, real_ch)] = subj
  100. trials_ch = []
  101. for tr in range(body_hg.shape[-1]):
  102. x = body_hg[idx, :, tr]
  103. if x.shape[0]==55 and not np.any(np.isnan(x)) and not np.all(x==0):
  104. trials_ch.append( (x,1) )
  105. for tr in range(nonbody_hg.shape[-1]):
  106. x = nonbody_hg[idx, :, tr]
  107. if x.shape[0]==55 and not np.any(np.isnan(x)) and not np.all(x==0):
  108. trials_ch.append( (x,0) )
  110. # Random split into train/test
  111. if len(trials_ch) < 20:
  112. continue
  113. idx_perm = rng.permutation(len(trials_ch))
  114. split = int(len(trials_ch)*train_ratio)
  115. train_idx = idx_perm[:split]
  116. test_idx = idx_perm[split:]
  118. for i in train_idx:
  119. channel_data_train[ba][real_ch].append(trials_ch[i])
  120. for i in test_idx:
  121. channel_data_test[ba][real_ch].append(trials_ch[i])
  123. except Exception as e:
  124. print(f" Error loading {subj}: {e}")
  126. # 2) Feature selection using TRAIN set
  127. for ba, chan_dict in channel_data_train.items():
  128. for ch, trials in chan_dict.items():
  129. if len(trials) < 20:
  130. continue
  132. X_trials, y_trials = zip(*trials)
  133. X = np.stack(X_trials)
  134. y = np.array(y_trials)
  136. accs = []
  137. for start in window_starts:
  138. X_win = X[:, start:start+win_size]
  139. cv = StratifiedKFold(n_splits=n_folds, shuffle=True, random_state=42)
  140. fold = []
  141. for tr, te in cv.split(X_win, y):
  142. mdl = make_pipeline(StandardScaler(), SVC(kernel='linear'))
  143. mdl.fit(X_win[tr], y[tr])
  144. fold.append(mdl.score(X_win[te], y[te]))
  145. accs.append(np.mean(fold))
  147. if np.mean(accs) > 0.5:
  148. selected_channels[ba].append(ch)
  149. subj_folder = channel_owner[(ba,ch)]
  150. selected_channels_by_subj[ba].append((subj_folder,ch))
  152. selected_channels_by_subject = selected_channels_by_subj
  154. # For classifier comparison
  155. channel_data = defaultdict(lambda: defaultdict(list))
  156. for ba in set(channel_data_train.keys()).union(channel_data_test.keys()):
  157. for ch in set(channel_data_train[ba].keys()).union(channel_data_test[ba].keys()):
  158. channel_data[ba][ch] = channel_data_train[ba][ch] + channel_data_test[ba][ch]
  160. print("✔ Step 1–3 complete: channels selected using 70% train split.")
  162. #%% Step 4: Grouped Multi-channel Decoding
  163. print("Step 4: Computing decoding accuracy")
  165. results = defaultdict(list)
  166. all_result_rows = []
  168. for ba in selected_channels:
  169. X_all, y_all = [], []
  170. for ch in selected_channels[ba]:
  171. trials = channel_data_test[ba][ch]
  172. for x, y in trials:
  173. X_all.append(x)
  174. y_all.append(y)
  176. if len(X_all) < 10:
  177. print(f"Skipping BA {ba} (not enough held-out trials).")
  178. continue
  180. X_all = np.stack(X_all)
  181. y_all = np.array(y_all)
  183. for start in window_starts:
  184. end = start+win_size
  185. X_win = X_all[:, start:end]
  186. X_concat = X_win.reshape(X_win.shape[0], -1)
  188. accs = []
  189. cv = StratifiedKFold(n_splits=min(n_folds, len(y_all)), shuffle=True, random_state=42)
  190. for train_idx, test_idx in cv.split(X_concat, y_all):
  191. model = make_pipeline(StandardScaler(), SVC(kernel='linear'))
  192. model.fit(X_concat[train_idx], y_all[train_idx])
  193. accs.append(model.score(X_concat[test_idx], y_all[test_idx]))
  195. mean_acc = np.mean(accs)
  196. std_acc = np.std(accs)
  197. results[ba].append((mean_acc, std_acc))
  199. ste = std_acc / np.sqrt(n_folds)
  200. t_center = (start + win_size //2)*10
  201. all_result_rows.append([ba, t_center, mean_acc, ste])
  203. # Save results
  204. df_all = pd.DataFrame(all_result_rows, columns=["BA","Time(ms)","Accuracy","STE"])
  205. df_all.to_csv(os.path.join(output_dir, "AllBAs_MultiChannelGroupedDecoding.csv"), index=False)
  208. # --- (B) Plot decoding curves per lobe ---
  209. # Remove (number) suffix from BA names
  210. ba_clean_map = {ba: ba.split(" (")[0] for ba in selected_channels}
  211. ba_to_lobe_clean = {ba_clean_map[ba]: ba_to_lobe[ba] for ba in selected_channels if ba in ba_to_lobe}
  213. # Load decoding results
  214. df_all = pd.read_csv(os.path.join(output_dir, "AllBAs_MultiChannelGroupedDecoding.csv"))
  215. df_all['BA_clean'] = df_all['BA'].apply(lambda x: x.split(" (")[0])
  216. df_all['Lobe'] = df_all['BA_clean'].map(ba_to_lobe_clean)
  218. # Plot decoding accuracy curves per lobe
  219. for lobe in sorted(df_all['Lobe'].dropna().unique()):
  220. plt.figure(figsize=(10, 5))
  221. for ba in df_all[df_all['Lobe'] == lobe]['BA_clean'].unique():
  222. sub_df = df_all[(df_all['BA_clean'] == ba) & (df_all['Lobe'] == lobe)]
  223. plot_df = sub_df[sub_df['Time(ms)'] >= 50]
  224. plt.plot(plot_df['Time(ms)'], plot_df['Accuracy'], label=ba)
  225. plt.fill_between(plot_df['Time(ms)'],
  226. plot_df['Accuracy'] - plot_df['STE'],
  227. plot_df['Accuracy'] + plot_df['STE'], alpha=0.2)
  228. plt.title(f"{lobe} Lobe - Grouped Multi-channel Decoding")
  229. plt.xlabel("Time (ms)")
  230. plt.ylabel("Accuracy")
  231. plt.axhline(0.5, color='gray', linestyle='--')
  232. plt.ylim(0.45, 0.8)
  233. plt.xlim(50, 500)
  234. plt.xticks(np.arange(50, 501, 50))
  235. plt.grid(True)
  236. plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
  237. plt.tight_layout()
  238. plt.savefig(os.path.join(output_dir, f"{lobe}_GroupedDecodingAccuracy.png"))
  239. plt.close()
  241. print("✔ Step 4 complete: Grouped decoding and plots saved.")
  243. #%% Step 5: Classifier comparison (Best SVM BA per lobe, with significance testing)
  245. from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
  246. from sklearn.ensemble import RandomForestClassifier
  247. from scipy.stats import f_oneway, ttest_ind
  249. print("Step 5: Classifier comparison (Best SVM BA per lobe, 150–250 and averaged)...")
  251. clf_models = {
  252. 'SVM': SVC(kernel='linear'),
  253. 'LDA': LDA(),
  254. 'RF': RandomForestClassifier(n_estimators=100, random_state=42)
  255. }
  256. lobe_best_bas = {}
  257. boxplot_records_150_250 = []
  258. boxplot_records_full = []
  260. # Find best BA per lobe based on SVM (150–250 ms)
  261. for ba in selected_channels:
  262. if ba not in ba_to_lobe:
  263. continue
  264. lobe = ba_to_lobe[ba]
  265. chans = selected_channels[ba]
  266. trials = [x for ch in chans for x in channel_data[ba][ch]]
  267. if not trials:
  268. continue
  269. X_trials, y_trials = zip(*trials)
  270. X = np.stack(X_trials)
  271. y = np.array(y_trials)
  273. accs = []
  274. for start, center in zip(window_starts, window_centers):
  275. if 150 <= center <= 250:
  276. X_win = X[:, start:start+win_size]
  277. X_concat = X_win.reshape(X_win.shape[0], -1)
  278. cv = StratifiedKFold(n_splits=n_folds, shuffle=True, random_state=42)
  279. for train_idx, test_idx in cv.split(X_concat, y):
  280. model = make_pipeline(StandardScaler(), SVC(kernel='linear'))
  281. model.fit(X_concat[train_idx], y[train_idx])
  282. accs.append(model.score(X_concat[test_idx], y[test_idx]))
  283. if accs:
  284. avg_acc = np.mean(accs)
  285. if lobe not in lobe_best_bas or avg_acc > lobe_best_bas[lobe][1]:
  286. lobe_best_bas[lobe] = (ba, avg_acc)
  288. # Evaluate LDA/RF on best BA per lobe
  289. for lobe, (ba, _) in lobe_best_bas.items():
  290. chans = selected_channels[ba]
  291. trials = [x for ch in chans for x in channel_data[ba][ch]]
  292. X_trials, y_trials = zip(*trials)
  293. X = np.stack(X_trials)
  294. y = np.array(y_trials)
  296. for clf_name, clf_model in clf_models.items():
  297. accs_150 = []
  298. accs_full = []
  299. for start, center in zip(window_starts, window_centers):
  300. X_win = X[:, start:start+win_size]
  301. X_concat = X_win.reshape(X_win.shape[0], -1)
  302. cv = StratifiedKFold(n_splits=n_folds, shuffle=True, random_state=42)
  303. for train_idx, test_idx in cv.split(X_concat, y):
  304. model = make_pipeline(StandardScaler(), clf_model)
  305. model.fit(X_concat[train_idx], y[train_idx])
  306. acc = model.score(X_concat[test_idx], y[test_idx])
  307. if 150 <= center <= 250:
  308. accs_150.append(acc)
  309. accs_full.append(acc)
  310. for acc in accs_150:
  311. boxplot_records_150_250.append({'Lobe': lobe, 'Classifier': clf_name, 'Accuracy': acc})
  312. for acc in accs_full:
  313. boxplot_records_full.append({'Lobe': lobe, 'Classifier': clf_name, 'Accuracy': acc})
  315. # Save and plot
  316. df_150 = pd.DataFrame(boxplot_records_150_250)
  317. df_full = pd.DataFrame(boxplot_records_full)
  318. df_150.to_csv(os.path.join(output_dir, "Classifier_Boxplot_BestBA_150to250.csv"), index=False)
  319. df_full.to_csv(os.path.join(output_dir, "Classifier_Boxplot_BestBA_Averaged.csv"), index=False)
  321. def plot_with_significance(df, title, fname, palette):
  322. plt.figure(figsize=(12, 6))
  323. ax = sns.boxplot(data=df, x='Lobe', y='Accuracy', hue='Classifier', palette=palette)
  324. plt.title(title)
  325. plt.ylabel("Decoding Accuracy")
  326. plt.tight_layout()
  328. # Significance stars
  329. lobes = df['Lobe'].unique()
  330. clfs = df['Classifier'].unique()
  331. for lobe in lobes:
  332. data_lobe = df[df['Lobe'] == lobe]
  333. accs = [data_lobe[data_lobe['Classifier'] == clf]['Accuracy'].values for clf in clfs]
  334. if len(accs) == 3 and all(len(a) > 1 for a in accs):
  335. stat, p_anova = f_oneway(*accs)
  336. if p_anova < 0.05:
  337. pairs = [(0,1), (0,2), (1,2)]
  338. pvals = [ttest_ind(accs[i], accs[j]).pvalue for i,j in pairs]
  339. _, pvals_corr, _, _ = multipletests(pvals, method='fdr_bh')
  340. xlocs = [0, 0.2, 0.4]
  341. for (i,j), p, offset in zip(pairs, pvals_corr, xlocs):
  342. if p < 0.05:
  343. x1 = list(clfs).index(clfs[i]) + offset
  344. x2 = list(clfs).index(clfs[j]) + offset
  345. y = max(np.max(accs[i]), np.max(accs[j])) + 0.02
  346. plt.plot([x1, x1, x2, x2], [y, y+0.005, y+0.005, y], lw=1.5, c='k')
  347. plt.text((x1+x2)*.5, y+0.007, "*", ha='center', va='bottom', fontsize=14)
  349. plt.savefig(os.path.join(output_dir, fname))
  350. plt.close()
  352. # Plot with stars
  353. plot_with_significance(df_150, "Classifier Comparison (Best SVM BA per Lobe) - 150–250 ms",
  354. "Classifier_Boxplot_BestBA_150to250ms_withStars.png", palette="Set3")
  355. plot_with_significance(df_full, "Classifier Comparison (Best SVM BA per Lobe) - Averaged Accuracy (50–500 ms)",
  356. "Classifier_Boxplot_BestBA_Averaged_withStars.png", palette="Set3")
  358. print("✔ Step 5 complete: Boxplots with significance testing saved.")
  361. #%% Step 6: FDR on peak decoding accuracy
  362. raw_pvals, ba_peak_stats = [], []
  363. for ba in results:
  364. accs, stds = zip(*results[ba])
  365. peak_idx = int(np.argmax(accs))
  366. peak_acc = accs[peak_idx]
  367. peak_std = stds[peak_idx]
  368. sim_folds = np.random.normal(loc=peak_acc, scale=peak_std, size=n_folds)
  369. _, pval = ttest_1samp(sim_folds, 0.5, alternative='greater')
  370. raw_pvals.append(pval)
  371. ba_peak_stats.append((ba, window_centers[peak_idx], peak_acc, pval))
  372. rejected, pvals_corr, _, _ = multipletests(raw_pvals, alpha=0.05, method='fdr_bh')
  373. fdr_rows = [(ba, time, acc, p, pc, sig) for (ba, time, acc, p), pc, sig in zip(ba_peak_stats, pvals_corr, rejected)]
  374. fdr_df = pd.DataFrame(fdr_rows, columns=["BA", "PeakTime(ms)", "PeakAccuracy", "p_uncorrected", "p_FDR", "Significant"])
  375. fdr_df.to_csv(os.path.join(output_dir, "FDR_PeakAccuracy_Significance.csv"), index=False)
  377. print("✔ Step 6 complete: FDR on peak decoding saved.")
  379. #%% Step 7–8: Select Early/Late BAs and Prepare Trial Matrices
  380. early_threshold, late_threshold = 250, 251
  381. lobe_to_bas = defaultdict(lambda: {'early': [], 'late': []})
  382. ba_to_lobe_clean = {k.split(" (")[0]: v for k, v in ba_to_lobe.items()}
  384. for _, row in fdr_df[fdr_df['Significant']].iterrows():
  385. ba = row['BA']
  386. peak_time = row['PeakTime(ms)']
  387. lobe = ba_to_lobe.get(ba)
  388. if lobe:
  389. if peak_time <= early_threshold:
  390. lobe_to_bas[lobe]['early'].append((ba, peak_time))
  391. elif peak_time >= late_threshold:
  392. lobe_to_bas[lobe]['late'].append((ba, peak_time))
  394. selected_ba_set = set()
  395. ba_peak_times = {}
  396. for lobe, group in lobe_to_bas.items():
  397. for tag in ['early', 'late']:
  398. if group[tag]:
  399. best = max(group[tag], key=lambda x: fdr_df[fdr_df['BA'] == x[0]]['PeakAccuracy'].values[0])
  400. selected_ba_set.add(best[0])
  401. ba_peak_times[best[0]] = best[1]
  403. roi_data_by_category = defaultdict(lambda: defaultdict(list))
  404. for ba in selected_ba_set:
  405. for ch in selected_channels[ba]:
  406. for x, y in channel_data[ba][ch]:
  407. roi_data_by_category[ba][y].append(x)
  409. min_trials = min([len(v) for cat in [0, 1] for ba in roi_data_by_category for v in [roi_data_by_category[ba][cat]]])
  410. roi_trimmed = {ba: {cat: np.stack(roi_data_by_category[ba][cat][:min_trials]) for cat in [0, 1]} for ba in selected_ba_set}
  412. print("✔ Step 7–8 complete: ROI data trimmed per category.")
  414. #%% Step 9: Plot decoding accuracy for selected BA pairs used in R²
  415. print("Step 9: Plotting decoding accuracy curves for selected BA pairs...")
  417. df_all = pd.read_csv(os.path.join(output_dir, "AllBAs_MultiChannelGroupedDecoding.csv"))
  419. for src, tgt in permutations(selected_ba_set, 2):
  420. if src == tgt:
  421. continue
  422. src_clean = src.split(" (")[0]
  423. tgt_clean = tgt.split(" (")[0]
  425. df_src = df_all[df_all['BA'].str.startswith(src_clean)]
  426. df_tgt = df_all[df_all['BA'].str.startswith(tgt_clean)]
  428. if df_src.empty or df_tgt.empty:
  429. continue
  431. plt.figure(figsize=(10, 5))
  433. # Plot source BA
  434. sub_src = df_src[df_src['Time(ms)'] >= 50]
  435. plt.plot(sub_src['Time(ms)'], sub_src['Accuracy'], label=f"{src_clean}", color='tab:blue')
  436. plt.fill_between(sub_src['Time(ms)'],
  437. sub_src['Accuracy'] - sub_src['STE'],
  438. sub_src['Accuracy'] + sub_src['STE'],
  439. alpha=0.2, color='tab:blue')
  441. # Plot target BA
  442. sub_tgt = df_tgt[df_tgt['Time(ms)'] >= 50]
  443. plt.plot(sub_tgt['Time(ms)'], sub_tgt['Accuracy'], label=f"{tgt_clean}", color='tab:orange')
  444. plt.fill_between(sub_tgt['Time(ms)'],
  445. sub_tgt['Accuracy'] - sub_tgt['STE'],
  446. sub_tgt['Accuracy'] + sub_tgt['STE'],
  447. alpha=0.2, color='tab:orange')
  449. # Format
  450. plt.title(f"Decoding Accuracy: {src_clean} and {tgt_clean}")
  451. plt.xlabel("Time (ms)")
  452. plt.ylabel("Accuracy")
  453. plt.axhline(0.5, linestyle='--', color='gray')
  454. plt.xlim(50, 500)
  455. plt.ylim(0.45, 0.8)
  456. plt.xticks(np.arange(50, 501, 50))
  457. plt.grid(True)
  458. plt.legend()
  459. plt.tight_layout()
  460. plt.savefig(os.path.join(output_dir, f"DecodingComparison_{src_clean}_to_{tgt_clean}.png"))
  461. plt.close()
  463. #%% Step 10 : write Sem_<time>.csv
  464. print("Step 10 : exporting Sem_<time>.csv files (FDR-passed peaks only)…")
  466. subject_number_map = {
  467. 'NBM':1,'CJS':2,'PJW':3,'JAH':4,'HSH2':6,
  468. 'JHJ':7,'SJH':8,'JSH':10,'KHS':15,'LSJ_L':19
  469. }
  471. # --- info from FDR step ---
  472. fdr_passed = fdr_df[fdr_df['Significant']]
  473. ba_peak_time = dict(zip(fdr_passed['BA'], fdr_passed['PeakTime(ms)']))
  474. ba_peak_accuracy = dict(zip(fdr_passed['BA'], fdr_passed['PeakAccuracy']))
  476. # build one CSV per peak time
  477. for t in sorted(set(ba_peak_time.values())):
  478. rows=[]
  479. for ba, peak_t in ba_peak_time.items():
  480. if peak_t != t:
  481. continue
  482. acc = ba_peak_accuracy[ba]
  484. # channels that survived feature-selection for this BA
  485. for subj_folder, ch in selected_channels_by_subject.get(ba, []):
  486. subj_short = subject_ba_mapping[subj_folder]
  487. subj_num = subject_number_map.get(subj_short)
  488. if subj_num is None:
  489. continue
  491. rows.append({'Subject':subj_num,
  492. 'Channel':int(ch),
  493. 'Accuracy':acc})
  495. # save if anything to write
  496. if rows:
  497. df_sem = (pd.DataFrame(rows)
  498. .sort_values(['Subject','Channel']))
  499. df_sem.to_csv(os.path.join(output_dir, f"Sem_{t}.csv"), index=False)
  500. print(f" • Sem_{t}.csv written ({len(df_sem)} rows)")
  502. print("✔ Sem files exported (only FDR-passed peak windows).")
  504. #%% Step 11 : PRINT SUMMARY (FDR table • best BA per lobe • planned R² pairs)
  505. print("\n" + "="*70)
  506. print(" STEP 11 ▸ SUMMARY OF STATISTICALLY-RELEVANT RESULTS")
  507. print("="*70)
  509. # 1. FDR table (only significant rows)
  510. print("\n--- Peak Accuracy and Significance (FDR-passed BAs) ---")
  511. cols_show = ["BA", "PeakTime(ms)", "PeakAccuracy", "p_FDR"]
  512. print(
  513. fdr_df[fdr_df["Significant"]][cols_show]
  514. .sort_values("PeakAccuracy", ascending=False)
  515. .to_string(index=False)
  516. )
  518. # 2. Best BA per lobe (lowest p_FDR, tie-break by highest accuracy)
  519. print("\n--- Best Performing BA per Lobe ---")
  520. for lobe in sorted(lobe_to_bas.keys()):
  521. ba_list = lobe_to_bas[lobe]["early"] + lobe_to_bas[lobe]["late"]
  522. if not ba_list:
  523. continue
  524. best_ba = min(
  525. ba_list,
  526. key=lambda ba_tp: (
  527. fdr_df.loc[fdr_df["BA"] == ba_tp[0], "p_FDR"].values[0],
  528. -fdr_df.loc[fdr_df["BA"] == ba_tp[0], "PeakAccuracy"].values[0],
  529. ),
  530. )
  531. ba, t_peak = best_ba
  532. acc_peak = fdr_df.loc[fdr_df["BA"] == ba, "PeakAccuracy"].values[0]
  533. print(f"{lobe:<9}: {ba:<30} acc={acc_peak:.3f} @ {int(t_peak)} ms")
  535. # 3. Build ONE definitive list of R² pairs
  536. print("\n--- Planned Cross-Temporal R² (Source → Target) ---")
  538. planned_pairs = [
  539. (src, tgt)
  540. for src, tgt in permutations(sorted(selected_ba_set), 2)
  541. if ba_to_lobe[src] != ba_to_lobe[tgt] # different lobe
  542. and ba_peak_times[src] < ba_peak_times[tgt] # early → late
  543. ]
  545. for src, tgt in planned_pairs:
  546. print(f"{src} ({ba_to_lobe[src]}) → {tgt} ({ba_to_lobe[tgt]})")
  548. print(f"Total pairs queued: {len(planned_pairs)}")
  549. print("="*70 + "\n")
  551. #%% Step 12 : Cross-Temporal R²
  552. category_names = {0: "NonBody", 1: "Body"}
  554. print("Step 12: computing category-specific cross-temporal R² …")
  556. num_pairs = len(planned_pairs)
  557. num_matrices = num_pairs * 2
  558. print(f"▶ Will process {num_pairs} BA pairs → {num_matrices} R² matrices")
  560. for src, tgt in planned_pairs:
  561. for cat in (0, 1):
  562. label = category_names[cat]
  564. # trials for this single category only
  565. X_src = roi_trimmed[src][cat]
  566. Y_tgt = roi_trimmed[tgt][cat]
  568. r2_matrix = np.zeros((usable_timepoints, usable_timepoints))
  569. pval_matrix = np.ones_like(r2_matrix)
  571. for t1 in range(usable_timepoints):
  572. x = X_src[:, t1].reshape(-1, 1)
  573. for t2 in range(usable_timepoints):
  574. y = Y_tgt[:, t2]
  576. r2_obs = LinearRegression().fit(x, y).score(x, y)
  577. r2_matrix[t1, t2] = r2_obs
  579. null_scores = [
  580. LinearRegression().fit(x, shuffle(y))
  581. .score(x, shuffle(y))
  582. for _ in range(n_permutations)
  583. ]
  584. pval_matrix[t1, t2] = np.mean(np.array(null_scores) >= r2_obs)
  586. # tidy BA names for files
  587. s_name = src.split(" (")[0].replace(" ", "")
  588. t_name = tgt.split(" (")[0].replace(" ", "")
  590. # save outputs
  591. pd.DataFrame(r2_matrix).to_csv(
  592. os.path.join(output_dir,
  593. f"R2_{s_name}_to_{t_name}_{label}.csv"),
  594. index=False,
  595. )
  596. pd.DataFrame(pval_matrix).to_csv(
  597. os.path.join(output_dir,
  598. f"Pval_{s_name}_to_{t_name}_{label}.csv"),
  599. index=False,
  600. )
  602. # heat-map
  603. plt.figure(figsize=(8, 6))
  604. sns.heatmap(
  605. r2_matrix, cmap="viridis",
  606. xticklabels=10, yticklabels=10,
  607. cbar_kws={"label": "R²"}
  608. )
  609. ticks = np.arange(0, usable_timepoints, 10)
  610. plt.xticks(ticks, ticks * 10)
  611. plt.yticks(ticks, ticks * 10)
  612. plt.title(f"R² • {label}: {s_name} → {t_name}")
  613. plt.xlabel("Target time (ms)")
  614. plt.ylabel("Source time (ms)")
  615. plt.tight_layout()
  616. plt.savefig(
  617. os.path.join(output_dir,
  618. f"Heat_{s_name}_to_{t_name}_{label}.png"),
  619. dpi=300,
  620. )
  621. plt.close()
  623. print("✔ Step 12 complete – category-specific R² matrices & plots saved.")

2.5-2.7_decoding_semantic_left.py at commit f377f34, no license · at the source

Overview

Authors: Ye Jin Park1, Jii Kwon2, Gyuwon Lee2, Kevin Meng3, Chun Kee Chung4
ORCID iDs: Ye Jin Park, Jii Kwon, Gyuwon Lee, Kevin Meng, Chun Kee Chung
  1. Department of Interdisciplinary Program in Neuroscience, Seoul National University, Seoul 08826, Republic of Korea
  2. Department of Brain and Cognitive Sciences, Seoul National University, Seoul 08826, Republic of Korea
  3. Department of Biomedical Engineering, The University of Melbourne, Victoria 3010, Australia
  4. Neuroscience Research Institute, Seoul National University Medical Research Center, Seoul 03080, Republic of Korea
Institutions: Seoul National University (South Korea); The University of Melbourne (Australia)
Journal: eNeuro, volume 13, issue 4, pages ENEURO.0254-25.2026
Dates: received 1 July 2025; accepted 30 March 2026; published online 21 April 2026; in print April 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1523/eneuro.0254-25.2026 · PMID 41956899 · PMCID PMC13116012 · OpenAlex W7152624757
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: intracranial EEG (iEEG / ECoG / SEEG) (modality), human (organism), cognitive (subfield)
Methods: Spectral & time-frequency, Preprocessing, Statistics, Smoothing, state filtering, decompositions, Machine learning, Connectivity, fMRI & imaging, Physiology & signal measures
Keywords: cortical dynamics, intracranial EEG, pre-speech processing, semantic decoding, speech production
MeSH: Cerebral Cortex*, Electrocorticography*, Gamma Rhythm*, Reading*, Semantics*, Adult, Brain Mapping, Female, Humans, Male, Young Adult (* major topic)
Topic: EEG and Brain-Computer Interfaces (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Citations: not cited yet (Europe PMC); 51 references in the paper

Abstract

Despite advances in brain–computer interfaces, decoding high-level language representations prior to speech remains challenging. While prior efforts have focused on acoustic or articulatory features, how semantic categories are decoded in time and space remains unclear. Here, we investigated how semantic representations unfold over time by analyzing high-gamma (HG; 70–170 Hz) electrocorticography signals from 20 subjects (7 females and 13 males) performing a word-reading task with body- and nonbody-related words. HG activity was examined from word presentation to 500 ms. Group-level time–resolved decoding within each Brodmann area (BA) revealed significant classification accuracy above chance in both hemispheres (p < 0.05, FDR-corrected). In the left hemisphere, peak BAs followed a frontal–temporal–occipital–parietal cascade: dorsolateral prefrontal cortex (dlPFC; 50 ms), inferior temporal and fusiform gyri (350–400 ms), and supramarginal gyrus (SMG; 500 ms). In contrast, the right hemisphere exhibited an occipital–temporal–frontal–temporal–parietal sequence: visual and temporal pole (TP) regions (50–100 ms), dlPFC (200 ms), fusiform gyrus (400 ms), and angular gyrus (450 ms). This contrasts with the frontal-initiated cascade of the left hemisphere, underscoring hemispheric differences in the timing of peak decoding loci. Cross-temporal regression revealed predictive interregional engagement. In the left hemisphere, early dlPFC activity (0–150 ms) predicted later SMG responses (300–350 ms). In the right, a strong predictive link emerged from the TP to the angular gyrus (200–300 ms; peak R2 ≈ 0.70). These findings demonstrate that semantic category decoding relies on temporally structured interregional interactions, revealing distinct hemispheric patterns.

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 5 matches between paragraphs and lines of code.

jinnilog/semantic-category-2025

License: none: the authors keep all their rights
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: f377f34faeeb38b50375249fbb8b0361ea73e97f, 2 July 2025
Languages: MATLAB (2), Python (1)
Size: 3 files, 3 scripts
Software Heritage: not archived
Found in: “Code accessibility”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: Wavelet Toolbox (2 files), EEGLAB (1 file), Signal Processing Toolbox (1 file), Statistics and Machine Learning Toolbox (1 file), Matplotlib (1 file), NumPy (1 file), pandas (1 file), scikit-learn (1 file), SciPy (1 file), seaborn (1 file), statsmodels (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
3 files
At the source: github.com/jinnilog/semantic-category-2025.git

Code accessibility

The code described in the paper is freely available online at https://github.com/jinnilog/semantic-category-2025.git. The code is available as Extended Data (https://doi.org/10.1523/ENEURO.0254-25.2026.d1).

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

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;
  • 3 scripts, each with its path and the digest of its content;
  • 5 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.

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

Recorded: type, language, journal, volume, issue, pages, dates, 5 authors, 5 keywords, 11 MeSH terms, 50 references.

Cite

This paper

Park, Y. J., Kwon, J., Lee, G., Meng, K., & Chung, C. K. (2026). Spatiotemporal Dynamics in Prespeech Semantic Category Decoding: An Intracranial EEG Study. eNeuro, 13(4), ENEURO.0254-25.2026. https://doi.org/10.1523/eneuro.0254-25.2026

BibTeX

@article{park2026spatiotemporal,
author = {Park, Ye Jin and Kwon, Jii and Lee, Gyuwon and Meng, Kevin and Chung, Chun Kee},
title = {{Spatiotemporal Dynamics in Prespeech Semantic Category Decoding: An Intracranial EEG Study}},
journal = {eNeuro},
year = {2026},
month = apr,
volume = {13},
number = {4},
pages = {ENEURO.0254--25.2026},
publisher = {Society for Neuroscience},
issn = {2373-2822},
doi = {10.1523/eneuro.0254-25.2026},
url = {https://doi.org/10.1523/eneuro.0254-25.2026},
pmid = {41956899},
pmcid = {PMC13116012}
}

RIS

TY - JOUR
AU - Park, Ye Jin
AU - Kwon, Jii
AU - Lee, Gyuwon
AU - Meng, Kevin
AU - Chung, Chun Kee
TI - Spatiotemporal Dynamics in Prespeech Semantic Category Decoding: An Intracranial EEG Study
T2 - eNeuro
J2 - eNeuro
PY - 2026
DA - 2026/04/23
VL - 13
IS - 4
SP - ENEURO.0254
EP - 25.2026
SN - 2373-2822
PB - Society for Neuroscience
DO - 10.1523/eneuro.0254-25.2026
UR - https://doi.org/10.1523/eneuro.0254-25.2026
LA - en
ER -

CSL-JSON

{
"id": "10.1523/eneuro.0254-25.2026",
"type": "article-journal",
"title": "Spatiotemporal Dynamics in Prespeech Semantic Category Decoding: An Intracranial EEG Study",
"container-title": "eNeuro",
"author": [
{
"family": "Park",
"given": "Ye Jin"
},
{
"family": "Kwon",
"given": "Jii"
},
{
"family": "Lee",
"given": "Gyuwon"
},
{
"family": "Meng",
"given": "Kevin"
},
{
"family": "Chung",
"given": "Chun Kee"
}
],
"container-title-short": "eNeuro",
"volume": "13",
"issue": "4",
"page": "ENEURO.0254-25.2026",
"DOI": "10.1523/eneuro.0254-25.2026",
"PMID": "41956899",
"PMCID": "PMC13116012",
"ISSN": "2373-2822",
"publisher": "Society for Neuroscience",
"URL": "https://doi.org/10.1523/eneuro.0254-25.2026",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
23
]
]
}
}

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.1523/eneuro.0289-25.2026 [code]
Reconstruction of Imagined Melody with Relative Pitch Decoding in Electrocorticography.
Journal: eNeuro
In common: EEGLAB, seaborn, scikit-learn, 4 other tools, intracranial EEG (iEEG / ECoG / SEEG), cognitive, 1 reference, 2 authors
[2] doi:10.1162/imag.a.1201 [code]
All spectral frequencies of neural activity reveal semantic representation in the human anterior ventral temporal cortex.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: EEGLAB, Signal Processing Toolbox, Statistics and Machine Learning Toolbox, 2 other tools, intracranial EEG (iEEG / ECoG / SEEG), 6 references
[3] doi:10.7554/elife.107088 [code]
Development of auditory and spontaneous movement responses to music over the first postnatal year.
Journal: eLife
In common: Wavelet Toolbox, EEGLAB, Signal Processing Toolbox, 7 other tools, 1 reference
[4] doi:10.1038/s42003-026-10108-z [code]
Time-resolved EEG decoding reveals altered neural dynamics of affective semantic evaluation in depression and suicidality.
Journal: Communications biology
In common: EEGLAB, statsmodels, seaborn, 5 other tools, cognitive, 3 references
[5] doi:10.1162/imag.a.105 [code]
Right posterior theta reflects human parahippocampal phase resetting by salient cues during goal-directed navigation
Journal: n/a
In common: Wavelet Toolbox, EEGLAB, statsmodels, 6 other tools, cognitive
[6] doi:10.1162/imag.a.1229 [code]
40 Hz audiovisual stimulation improves sustained attention and related brain oscillations.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Wavelet Toolbox, EEGLAB, Signal Processing Toolbox, 6 other tools
[7] doi:10.1162/nol.a.247 [code]
Same Sentences, Different Grammars, Different Brain Responses?: An MEG Study on Case and Agreement Encoding in Hindi and Nepali Split-Ergative Structures.
Journal: Neurobiology of language (Cambridge, Mass.)
In common: statsmodels, seaborn, pandas, 3 other tools, 4 references
[8] doi:10.1038/s41598-026-56070-y [code]
SSDLabeler: realistic semi-synthetic data generation for multi-label artifact classification in EEG.
Journal: Scientific reports
In common: EEGLAB, Signal Processing Toolbox, statsmodels, 6 other tools
[9] doi:10.1038/s41586-026-10448-0 [code]
Plasticity and language in the anaesthetized human hippocampus.
Journal: Nature
In common: Signal Processing Toolbox, Statistics and Machine Learning Toolbox, SciPy, 2 other tools, cognitive, 3 references
[10] doi:10.1002/advs.202519893 [code]
NeuroSuite for Long-Term Functional and Structural Studies of Air-Liquid Interface Cerebral Organoids.
Journal: Advanced science (Weinheim, Baden-Wurttemberg, Germany)
In common: Wavelet Toolbox, EEGLAB, Signal Processing Toolbox, 5 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.