OSCR

Architecture-data matching for EEG-EMG decoding: compact deep models match classical spectral decoders on the WAY-EEG-GAL grasp-and-lift dataset.

Code ↔ Paper

29 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 29 matches
  1. [1] § Materials and methods › Input representations ↔ code/02_classical_baseline.py, lines 1–61 · score 0.99 · magnitude squared coherence, 15–30 Hz, 30–45 Hz, 8–12 Hz, 55–95 Hz, low gamma
  2. [2] § Materials and methods › Decoders ↔ code/run_deep_models_local.py, lines 161–191 · score 0.94 · attention weighted edges, fully connected, Graph attention network, channel tokens, temporal CNN, Conv1d
  3. [3] § Materials and methods › Decoders ↔ code/run_deep_models_local.py, lines 128–158 · score 0.93 · learnable CLS token, Conv1d patch embedding, positional embedding, encoder layers, Transformer encoder, feed
  4. [4] § Materials and methods › Decoders ↔ code/02b_classical_eval.py, lines 1–23 · score 0.92 · random forest, linear SVM, gradient boosting, max_depth, max_iter, logistic regression
  5. [5] § Materials and methods › Decoders ↔ code/revision_ablations.py, lines 123–154 · score 0.89 · convolution attention hybrids, DBConformer, MFTNet, EEG Conformer, encoder layers, Transformer encoder
  6. [6] § Materials and methods › Decoders ↔ code/07_figures.py, lines 70–103 · score 0.89 · gradient boosting, hidden layers, max_depth, max_iter, logistic regression, class weight
  7. [7] § Materials and methods › Decoders ↔ code/04_neural_baselines.py, lines 1–25 · score 0.87 · flattened raw downsampled, hand crafted spectral, channel band, band power, log, coherence
  8. [8] § Materials and methods › Input representations ↔ code/revision_ablations.py, lines 247–288 · score 0.84 · 15–30 Hz, 30–45 Hz, 8–12 Hz, 55–95 Hz, IQR, log10
  9. [9] § Materials and methods › Decoders ↔ code/revision_ablations.py, lines 190–227 · score 0.80 · cross entropy loss, AdamW, weight decay, LOSO folds, PyTorch, seed
  10. [10] § Materials and methods › Preprocessing and trial epoching ↔ code/01_build_dataset.py, lines 1–52 · score 0.79 · 1–100 Hz, Interference EMG, 20–500 Hz, rectification, notch, decimated
  11. [11] § Materials and methods › Decoders ↔ code/run_deep_models_local.py, lines 87–125 · score 0.79 · separable temporal convolution, depthwise spatial convolution, EEGNet, kernel, ELU, blocks
  12. [12] § Materials and methods › Interpretability ↔ extract_deep_interpretability.py, lines 1–36 · score 0.79 · model native interpretability, deep decoders, channel attention, LOSO folds, EEGNet, filters
  13. [13] § Results › Robustness analyses › Deep-model interpretability sanity check ↔ extract_deep_interpretability.py, lines 124–242 · score 0.78 · depthwise spatial weights, attention rollout, temporal filters, EEG channels, EEGNet, heads
  14. [14] § Materials and methods › Decoders ↔ code/regen_fig3.py, lines 108–140 · score 0.76 · cross entropy loss, AdamW, weight decay, PyTorch, seed, batch
  15. [15] § Materials and methods › Preprocessing and trial epoching ↔ code/01_build_dataset.py, lines 1–52 · score 0.75 · Skipping ICA, sustained hold, notch, artifact, decimation, pipeline
  16. [16] § Results › Fused-model feature importance suggests sensorimotor EEG involvement; modality ablation (Section 3.5.3) shows dominant EMG dependence ↔ code/02_classical_baseline.py, lines 1–61 · score 0.74 · low gamma, high gamma, band power, EEG channel, AD, CED
  17. [17] § Materials and methods › Decoders ↔ code/07_figures.py, lines 47–68 · score 0.71 · MLP_spectral, MLP_temporal, MLP_graph, log, classical
  18. [18] § Materials and methods › Preprocessing and trial epoching ↔ code/07_figures.py, lines 142–168 · score 0.70 · Pipeline overview, raw temporal, channel pooled, WAY EEG GAL, Friedman, Wilcoxon
  19. [19] § Materials and methods › Interpretability ↔ code/06_interpretability.py, lines 1–24 · score 0.69 · coefficient magnitude, rest classes, model native, HGBM, classical, surface
  20. [20] § Materials and methods › Preprocessing and trial epoching ↔ code/01_build_dataset.py, lines 142–215 · score 0.67 · LEDOff, fallback window, LEDOn, cropped, lift, Preprocessing
  21. [21] § Materials and methods › Interpretability ↔ code/revision_ablations.py, lines 1–50 · score 0.67 · channel attention matrices, model native interpretability, style, convolutional, heads, folds
  22. [22] § Results › Confusion structure ↔ code/regen_figS3.py, lines 112–156 · score 0.65 · confusion matrices, logistic regression, best classical, suede, predictions, sandpaper
  23. [23] § Results › Confusion structure ↔ code/07_figures.py, lines 70–103 · score 0.65 · confusion matrices, logistic regression, best classical, suede, predictions, sandpaper
  24. [24] § Materials and methods › Decoders ↔ code/revision_ablations.py, lines 424–456 · score 0.63 · deep model EMG, bandwidth harmonization, EMG bandwidth, baseline, 250 Hz, 95 Hz
  25. [25] § Results › Confusion structure ↔ code/regen_fig3.py, lines 157–209 · score 0.59 · confusion matrices, logistic regression, EEGNet, suede, predictions, sandpaper
  26. [26] § Results › Confusion structure ↔ code/regen_figS3.py, lines 112–156 · score 0.59 · confusion matrices, logistic regression, EEGNet, suede, predictions, sandpaper
  27. [27] § Materials and methods › Dataset ↔ code/run_deep_models_local.py, lines 1–65 · score 0.53 · WAY EEG GAL, grasp, suede, sandpaper, lift, silk
  28. [28] § Materials and methods › Evaluation protocol and statistical analysis ↔ code/05_compare.py, lines 1–64 · score 0.52 · paired Wilcoxon, Cohen, dz, Balanced accuracy, Friedman, score
  29. [29] § Materials and methods › Evaluation protocol and statistical analysis ↔ code/revision_ablations.py, lines 247–288 · score 0.52 · F1 score, modality ablation, scaler, Balanced accuracy, fitted, macro

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 · 528 lines · 28 KB · MIT · 6 matches

  1. """
  2. revision_ablations.py
  3. =====================
  5. Follow-up ablations requested by the Stanford AI reviewer. Five experiments
  6. in one resumable script:
  8. (i) 5-seed robustness for cnn / transformer / gnn (means +/- SD across seeds)
  9. (ii) modality ablation: EEG-only, EMG-only, fused for HGBM, CNN, GNN
  10. (iii) compact convolution-attention hybrid (Conformer-style) as a tighter
  11. attention comparator distinct from the 4-layer Transformer
  12. (iv) partial-crossing conditioning analyses (decode weight at fixed surface,
  13. decode surface at fixed weight)
  14. (v) model-native interpretability dump: GNN per-channel attention weights,
  15. CNN gradient saliency over time-channel for representative trials
  16. (vi) EMG-bandwidth harmonisation: 95-Hz lowpass on EMG inputs to deep models
  17. so they see the same bandwidth as classical features (20-95 Hz)
  18. (vii) early-hold (first 500 ms) vs late-hold (last 500 ms) decoding to test
  19. whether tactile-evoked cortical signatures concentrate near contact
  21. Setup (same venv used for run_complete_local.py):
  22. .venv\Scripts\activate
  23. python code\revision_ablations.py
  25. Default run: all five experiments, ~ 45-90 min on RTX 5080. Use flags to
  26. restrict (e.g. --skip seeds modality):
  28. python code\revision_ablations.py --only seeds
  29. python code\revision_ablations.py --only modality conformer
  30. python code\revision_ablations.py --skip interp
  32. Outputs (all under <root>/results/):
  33. seed_robustness.csv per (model, task, seed, fold) row
  34. modality_ablation.csv per (model, task, modality, fold) row
  35. conformer_hybrid.csv per (task, fold) row (model = conformer)
  36. crossing_conditioning.csv per (task_within_factor, fold) row
  37. gnn_attention_weights.npy per-fold attention matrices [12, n_layers, n_heads, 37, 37]
  38. cnn_saliency_examples.npy [n_examples, 37, 500] gradient saliency
  39. revision_summary.txt human-readable summary block
  40. """
  41. from __future__ import annotations
  42. import argparse, sys, time
  43. from pathlib import Path
  44. import numpy as np, pandas as pd
  45. import torch, torch.nn as nn, torch.nn.functional as F
  46. from sklearn.ensemble import HistGradientBoostingClassifier
  47. from sklearn.metrics import balanced_accuracy_score, f1_score
  48. from sklearn.preprocessing import StandardScaler
  49. from sklearn.utils.class_weight import compute_class_weight
  50. from torch.utils.data import DataLoader, TensorDataset
  52. # --- Paths (auto-detect; same convention as run_complete_local.py) -----------
  53. SCRIPT_DIR = Path(__file__).resolve().parent
  54. ROOT = SCRIPT_DIR.parent if SCRIPT_DIR.name == "code" else SCRIPT_DIR
  55. CACHE = ROOT / "cache_v2"
  56. RESULTS = ROOT / "results"; RESULTS.mkdir(exist_ok=True)
  57. N_EEG, N_EMG, N_CHANNELS, N_SAMPLES, N_CLASSES = 32, 5, 37, 500, 3
  59. # ---- Models (same as run_complete_local.py) --------------------------------
  60. class EEGNet(nn.Module):
  61. def __init__(self, n_channels=N_CHANNELS, F1=16, D=2, F2=32, dropout=0.4):
  62. super().__init__()
  63. self.conv1 = nn.Conv2d(1, F1, (1, 64), padding=(0, 32), bias=False)
  64. self.bn1 = nn.BatchNorm2d(F1)
  65. self.conv2 = nn.Conv2d(F1, F1*D, (n_channels, 1), groups=F1, bias=False)
  66. self.bn2 = nn.BatchNorm2d(F1*D)
  67. self.pool1 = nn.AvgPool2d((1, 4)); self.drop1 = nn.Dropout(dropout)
  68. self.conv3 = nn.Conv2d(F1*D, F2, (1, 16), padding=(0, 8), bias=False)
  69. self.bn3 = nn.BatchNorm2d(F2)
  70. self.pool2 = nn.AvgPool2d((1, 8)); self.drop2 = nn.Dropout(dropout)
  71. with torch.no_grad():
  72. d = torch.zeros(1, 1, n_channels, N_SAMPLES)
  73. h = self.bn2(self.conv2(self.bn1(self.conv1(d))))
  74. h = self.pool2(self.bn3(self.conv3(self.pool1(h))))
  75. self.flat = h.numel()
  76. self.fc = nn.Linear(self.flat, N_CLASSES)
  77. def forward(self, x):
  78. x = x.unsqueeze(1)
  79. x = self.bn1(self.conv1(x))
  80. x = F.elu(self.bn2(self.conv2(x))); x = self.drop1(self.pool1(x))
  81. x = F.elu(self.bn3(self.conv3(x))); x = self.drop2(self.pool2(x))
  82. return self.fc(x.flatten(1))
  84. class EEGTransformer(nn.Module):
  85. def __init__(self, n_channels=N_CHANNELS, n_tokens=25, d_model=128, n_heads=8, n_layers=4, dropout=0.2):
  86. super().__init__()
  87. stride = N_SAMPLES // n_tokens
  88. self.patch = nn.Conv1d(n_channels, d_model, kernel_size=stride, stride=stride)
  89. self.cls = nn.Parameter(torch.randn(1, 1, d_model)*0.02)
  90. self.pos = nn.Parameter(torch.randn(1, n_tokens+1, d_model)*0.02)
  91. layer = nn.TransformerEncoderLayer(d_model=d_model, nhead=n_heads,
  92. dim_feedforward=d_model*2, dropout=dropout, batch_first=True, activation="gelu")
  93. self.encoder = nn.TransformerEncoder(layer, num_layers=n_layers)
  94. self.norm = nn.LayerNorm(d_model)
  95. self.fc = nn.Linear(d_model, N_CLASSES)
  96. def forward(self, x):
  97. x = self.patch(x).transpose(1, 2)
  98. cls = self.cls.expand(x.size(0), -1, -1)
  99. x = torch.cat([cls, x], dim=1) + self.pos
  100. x = self.encoder(x)
  101. return self.fc(self.norm(x[:, 0]))
  103. class EEGGNN(nn.Module):
  104. def __init__(self, n_channels=N_CHANNELS, embed_dim=64, n_heads=4, n_layers=2, dropout=0.2):
  105. super().__init__()
  106. self.stem = nn.Sequential(
  107. nn.Conv1d(1, 16, 16, stride=4), nn.ELU(),
  108. nn.Conv1d(16, 32, 8, stride=4), nn.ELU(),
  109. nn.AdaptiveAvgPool1d(1))
  110. self.proj = nn.Linear(32, embed_dim)
  111. layer = nn.TransformerEncoderLayer(d_model=embed_dim, nhead=n_heads,
  112. dim_feedforward=embed_dim*2, dropout=dropout, batch_first=True, activation="gelu")
  113. self.gat = nn.TransformerEncoder(layer, num_layers=n_layers)
  114. self.norm = nn.LayerNorm(embed_dim)
  115. self.fc = nn.Linear(embed_dim, N_CLASSES)
  116. def forward(self, x):
  117. B, C, T = x.shape
  118. h = self.stem(x.reshape(B*C, 1, T)).squeeze(-1)
  119. h = self.proj(h.view(B, C, 32))
  120. h = self.gat(h)
  121. return self.fc(self.norm(h.mean(1)))
  123. class ConformerHybrid(nn.Module):
  124. """Compact convolution-attention hybrid: an EEGNet stem (~4k params) followed by
  125. a single self-attention block (~25k params). ~30k params total -- aligned with
  126. the EEG-Conformer / DBConformer / EEG-MFTNet family at clinical sample size."""
  127. def __init__(self, n_channels=N_CHANNELS, F1=16, D=2, embed_dim=64, n_heads=4, dropout=0.2):
  128. super().__init__()
  129. self.conv1 = nn.Conv2d(1, F1, (1, 64), padding=(0, 32), bias=False)
  130. self.bn1 = nn.BatchNorm2d(F1)
  131. self.conv2 = nn.Conv2d(F1, F1*D, (n_channels, 1), groups=F1, bias=False)
  132. self.bn2 = nn.BatchNorm2d(F1*D)
  133. self.pool = nn.AvgPool2d((1, 8))
  134. self.drop = nn.Dropout(dropout)
  135. # tokenize the (F1*D)-channel time stream into 12 tokens
  136. with torch.no_grad():
  137. d = torch.zeros(1, 1, n_channels, N_SAMPLES)
  138. h = self.pool(self.bn2(self.conv2(self.bn1(self.conv1(d)))))
  139. self._L = h.shape[-1]
  140. self.proj = nn.Linear(F1*D, embed_dim)
  141. layer = nn.TransformerEncoderLayer(d_model=embed_dim, nhead=n_heads,
  142. dim_feedforward=embed_dim*2, dropout=dropout, batch_first=True, activation="gelu")
  143. self.attn = nn.TransformerEncoder(layer, num_layers=1)
  144. self.norm = nn.LayerNorm(embed_dim)
  145. self.fc = nn.Linear(embed_dim, N_CLASSES)
  146. def forward(self, x):
  147. x = x.unsqueeze(1)
  148. x = F.elu(self.bn2(self.conv2(self.bn1(self.conv1(x)))))
  149. x = self.drop(self.pool(x))
  150. # x: (B, F1*D, 1, L) -> tokens (B, L, F1*D)
  151. x = x.squeeze(2).transpose(1, 2)
  152. x = self.proj(x)
  153. x = self.attn(x)
  154. return self.fc(self.norm(x.mean(1)))
  156. MODELS = {"cnn": EEGNet, "transformer": EEGTransformer, "gnn": EEGGNN, "conformer": ConformerHybrid}
  158. # ---- Data loading ----------------------------------------------------------
  159. def load_all_data(task, modality="fused"):
  160. """modality in {fused, eeg, emg}. eeg drops EMG channels; emg keeps only EMG."""
  161. Xs, ys, subj = [], [], []
  162. for p in range(1, 13):
  163. d = np.load(CACHE / f"P{p}.npz")
  164. v = d["valid_mask"]
  165. eeg = d["eeg"][v]; emg = d["emg"][v]
  166. if modality == "eeg":
  167. x = eeg.astype(np.float32) # (n, 32, 500)
  168. elif modality == "emg":
  169. x = emg.astype(np.float32) # (n, 5, 500)
  170. else:
  171. x = np.concatenate([eeg, emg], axis=1).astype(np.float32) # (n, 37, 500)
  172. y = (d["y_weight"] if task == "weight" else d["y_surface"])[v]
  173. Xs.append(x); ys.append(y); subj.append(np.full(len(x), p, dtype=np.int8))
  174. return np.concatenate(Xs), np.concatenate(ys), np.concatenate(subj)
  176. def load_metadata():
  177. """Loads CurW and CurS per trial across all 12 subjects (used for conditioning)."""
  178. rows = []
  179. for p in range(1, 13):
  180. d = np.load(CACHE / f"P{p}.npz")
  181. v = d["valid_mask"]
  182. n = int(v.sum())
  183. rows.append(pd.DataFrame({
  184. "subj": np.full(n, p),
  185. "weight": d["y_weight"][v],
  186. "surface": d["y_surface"][v]
  187. }))
  188. return pd.concat(rows, ignore_index=True)
  190. # ---- Deep training one fold ------------------------------------------------
  191. def deep_loso_fold(model_class, X, y, subj, held, *, device, n_epochs, batch_size, lr, seed, n_channels=N_CHANNELS):
  192. torch.manual_seed(seed); np.random.seed(seed)
  193. test = subj == held
  194. Xtr, ytr = X[~test], y[~test].astype(np.int64)
  195. Xte, yte = X[test], y[test].astype(np.int64)
  196. mu = Xtr.mean(0, keepdims=True); sd = Xtr.std(0, keepdims=True) + 1e-6
  197. Xtr = ((Xtr-mu)/sd).astype(np.float32); Xte = ((Xte-mu)/sd).astype(np.float32)
  198. Xtr_t, ytr_t = torch.from_numpy(Xtr), torch.from_numpy(ytr)
  199. Xte_t = torch.from_numpy(Xte)
  200. cw = compute_class_weight("balanced", classes=np.array([0,1,2]), y=ytr)
  201. loss_fn = nn.CrossEntropyLoss(weight=torch.tensor(cw, dtype=torch.float32).to(device))
  202. if model_class in (EEGNet, ConformerHybrid):
  203. model = model_class(n_channels=n_channels).to(device)
  204. elif model_class is EEGGNN:
  205. model = model_class(n_channels=n_channels).to(device)
  206. elif model_class is EEGTransformer:
  207. model = model_class(n_channels=n_channels).to(device)
  208. else:
  209. model = model_class().to(device)
  210. opt = torch.optim.AdamW(model.parameters(), lr=lr, weight_decay=1e-4)
  211. loader = DataLoader(TensorDataset(Xtr_t, ytr_t), batch_size=batch_size, shuffle=True)
  212. model.train()
  213. for _ in range(n_epochs):
  214. for xb, yb in loader:
  215. xb, yb = xb.to(device), yb.to(device)
  216. opt.zero_grad()
  217. loss_fn(model(xb), yb).backward()
  218. opt.step()
  219. model.eval()
  220. preds = []
  221. with torch.no_grad():
  222. for i in range(0, len(Xte_t), batch_size):
  223. preds.append(model(Xte_t[i:i+batch_size].to(device)).argmax(1).cpu().numpy())
  224. yp = np.concatenate(preds)
  225. return dict(held_out_subject=int(held), n_test=int(test.sum()),
  226. balanced_accuracy=float(balanced_accuracy_score(yte, yp)),
  227. f1_macro=float(f1_score(yte, yp, average="macro"))), model
  229. # ---- Experiment 1: seed robustness -----------------------------------------
  230. def exp_seeds(device, models=("cnn","transformer","gnn"), seeds=(0,1,2,3,4),
  231. n_epochs=30, batch_size=64, lr=1e-3):
  232. rows = []
  233. for task in ("weight","surface"):
  234. X, y, subj = load_all_data(task, "fused")
  235. for m in models:
  236. for s in seeds:
  237. for h in range(1, 13):
  238. t0 = time.time()
  239. res, _ = deep_loso_fold(MODELS[m], X, y, subj, h,
  240. device=device, n_epochs=n_epochs,
  241. batch_size=batch_size, lr=lr, seed=s)
  242. rows.append({"experiment":"seeds","model":m,"task":task,"seed":s,**res,"sec":round(time.time()-t0,1)})
  243. print(f"[seeds] {m}/{task}/seed{s}/P{h:02d}: bal={res['balanced_accuracy']:.3f}", flush=True)
  244. pd.DataFrame(rows).to_csv(RESULTS / "seed_robustness.csv", index=False)
  245. print(f"saved {RESULTS/'seed_robustness.csv'}")
  247. # ---- Experiment 2: modality ablation ---------------------------------------
  248. def exp_modality(device, n_epochs=30, batch_size=64, lr=1e-3, seed=0):
  249. rows = []
  250. for task in ("weight","surface"):
  251. for modality in ("eeg","emg","fused"):
  252. n_ch = {"eeg": N_EEG, "emg": N_EMG, "fused": N_CHANNELS}[modality]
  253. X, y, subj = load_all_data(task, modality)
  254. # HGBM on flattened mean+std+IQR per channel + log-power per channel
  255. from scipy.signal import welch
  256. Xf = []
  257. for x in X:
  258. ch_mean = x.mean(axis=1); ch_std = x.std(axis=1)
  259. ch_iqr = np.percentile(x, 75, axis=1) - np.percentile(x, 25, axis=1)
  260. feats = [ch_mean, ch_std, ch_iqr]
  261. for lo, hi in [(8,12),(15,30),(30,45),(55,95)]:
  262. f, pxx = welch(x, fs=500, nperseg=128, axis=-1)
  263. mask = (f >= lo) & (f <= hi)
  264. feats.append(np.log10(pxx[..., mask].mean(axis=-1) + 1e-12))
  265. Xf.append(np.concatenate(feats))
  266. Xf = np.stack(Xf)
  267. sc = StandardScaler().fit(Xf); Xs = sc.transform(Xf)
  268. for h in range(1, 13):
  269. test = subj == h
  270. clf = HistGradientBoostingClassifier(max_iter=200, max_depth=4,
  271. learning_rate=0.05, class_weight="balanced",
  272. random_state=0)
  273. clf.fit(Xs[~test], y[~test])
  274. yp = clf.predict(Xs[test])
  275. rows.append({"experiment":"modality","model":"HGBM","modality":modality,
  276. "task":task,"held_out_subject":h,
  277. "balanced_accuracy": balanced_accuracy_score(y[test], yp),
  278. "f1_macro": f1_score(y[test], yp, average="macro")})
  279. for m in ("cnn", "gnn"):
  280. for h in range(1, 13):
  281. res, _ = deep_loso_fold(MODELS[m], X, y, subj, h, device=device,
  282. n_epochs=n_epochs, batch_size=batch_size,
  283. lr=lr, seed=seed, n_channels=n_ch)
  284. rows.append({"experiment":"modality","model":m,"modality":modality,
  285. "task":task,**res})
  286. print(f"[modality] {m}/{task}/{modality}/P{h:02d}: bal={res['balanced_accuracy']:.3f}", flush=True)
  287. pd.DataFrame(rows).to_csv(RESULTS / "modality_ablation.csv", index=False)
  288. print(f"saved {RESULTS/'modality_ablation.csv'}")
  290. # ---- Experiment 3: Conformer-style hybrid ----------------------------------
  291. def exp_conformer(device, n_epochs=30, batch_size=64, lr=1e-3, seed=0):
  292. rows = []
  293. for task in ("weight","surface"):
  294. X, y, subj = load_all_data(task, "fused")
  295. for h in range(1, 13):
  296. res, _ = deep_loso_fold(ConformerHybrid, X, y, subj, h,
  297. device=device, n_epochs=n_epochs,
  298. batch_size=batch_size, lr=lr, seed=seed)
  299. rows.append({"experiment":"conformer","model":"conformer","task":task,**res})
  300. print(f"[conformer] {task}/P{h:02d}: bal={res['balanced_accuracy']:.3f}", flush=True)
  301. pd.DataFrame(rows).to_csv(RESULTS / "conformer_hybrid.csv", index=False)
  302. print(f"saved {RESULTS/'conformer_hybrid.csv'}")
  304. # ---- Experiment 4: partial-crossing conditioning ---------------------------
  305. def exp_crossing(device, n_epochs=30, batch_size=64, lr=1e-3, seed=0):
  306. rows = []
  307. md = load_metadata()
  308. X_full, y_full, subj_full = load_all_data("weight", "fused")
  309. # Decode weight conditioned on a fixed surface (the surface with most coverage)
  310. for fix_surf in [0, 2]: # sandpaper, silk
  311. keep = md.surface.values == fix_surf
  312. X_sub = X_full[keep]; y_sub = y_full[keep]; subj_sub = subj_full[keep]
  313. for m in ("cnn", "gnn"):
  314. for h in range(1, 13):
  315. if (subj_sub == h).sum() < 5: continue
  316. res, _ = deep_loso_fold(MODELS[m], X_sub, y_sub, subj_sub, h,
  317. device=device, n_epochs=n_epochs,
  318. batch_size=batch_size, lr=lr, seed=seed)
  319. rows.append({"experiment":"conditioning","model":m,
  320. "decode":"weight","fixed_factor":"surface","fixed_value":int(fix_surf),
  321. "task":"weight",**res})
  322. # Decode surface conditioned on a fixed weight
  323. X_full2, y_full2, subj_full2 = load_all_data("surface", "fused")
  324. for fix_w in [0, 1, 2]:
  325. keep = md.weight.values == fix_w
  326. X_sub = X_full2[keep]; y_sub = y_full2[keep]; subj_sub = subj_full2[keep]
  327. for m in ("cnn", "gnn"):
  328. for h in range(1, 13):
  329. if (subj_sub == h).sum() < 5: continue
  330. res, _ = deep_loso_fold(MODELS[m], X_sub, y_sub, subj_sub, h,
  331. device=device, n_epochs=n_epochs,
  332. batch_size=batch_size, lr=lr, seed=seed)
  333. rows.append({"experiment":"conditioning","model":m,
  334. "decode":"surface","fixed_factor":"weight","fixed_value":int(fix_w),
  335. "task":"surface",**res})
  336. pd.DataFrame(rows).to_csv(RESULTS / "crossing_conditioning.csv", index=False)
  337. print(f"saved {RESULTS/'crossing_conditioning.csv'}")
  339. # ---- Experiment 5: model-native interpretability ---------------------------
  340. def exp_interp(device, n_epochs=30, batch_size=64, lr=1e-3, seed=0):
  341. """Hook attention weights from the GNN (per-fold) and gradient saliency for the CNN."""
  342. X, y, subj = load_all_data("weight", "fused")
  343. attn_per_fold = []
  344. for h in range(1, 13):
  345. torch.manual_seed(seed); np.random.seed(seed)
  346. test = subj == h
  347. Xtr, ytr = X[~test], y[~test].astype(np.int64)
  348. mu = Xtr.mean(0, keepdims=True); sd = Xtr.std(0, keepdims=True) + 1e-6
  349. Xtr = ((Xtr-mu)/sd).astype(np.float32)
  350. Xte = ((X[test]-mu)/sd).astype(np.float32)
  351. cw = compute_class_weight("balanced", classes=np.array([0,1,2]), y=ytr)
  352. loss_fn = nn.CrossEntropyLoss(weight=torch.tensor(cw, dtype=torch.float32).to(device))
  353. model = EEGGNN().to(device)
  354. opt = torch.optim.AdamW(model.parameters(), lr=lr, weight_decay=1e-4)
  355. Xtr_t = torch.from_numpy(Xtr); ytr_t = torch.from_numpy(ytr)
  356. loader = DataLoader(TensorDataset(Xtr_t, ytr_t), batch_size=batch_size, shuffle=True)
  357. model.train()
  358. for _ in range(n_epochs):
  359. for xb, yb in loader:
  360. xb, yb = xb.to(device), yb.to(device)
  361. opt.zero_grad(); loss_fn(model(xb), yb).backward(); opt.step()
  362. model.eval()
  363. # Hook attention from the first GAT layer
  364. attn_buffer = []
  365. def hook(module, inputs, output):
  366. # MultiheadAttention returns (attn_output, attn_weights) when need_weights=True
  367. pass
  368. # Compute attention manually by re-running the model with need_weights=True path
  369. Xte_t = torch.from_numpy(Xte).to(device)
  370. with torch.no_grad():
  371. B, C, T = Xte_t.shape
  372. h_ = model.stem(Xte_t.reshape(B*C, 1, T)).squeeze(-1)
  373. h_ = model.proj(h_.view(B, C, 32))
  374. # iterate the encoder layers and capture attention
  375. attns = []
  376. x_ = h_
  377. for layer in model.gat.layers:
  378. # nn.TransformerEncoderLayer self-attn
  379. x_norm = layer.norm1(x_)
  380. attn_out, attn_w = layer.self_attn(x_norm, x_norm, x_norm,
  381. need_weights=True, average_attn_weights=False)
  382. x_ = x_ + layer.dropout1(attn_out)
  383. x_ = x_ + layer.dropout2(layer.linear2(layer.dropout(layer.activation(layer.linear1(layer.norm2(x_))))))
  384. attns.append(attn_w.mean(0).cpu().numpy()) # [n_heads, C, C] averaged over batch
  385. attn_per_fold.append(np.stack(attns)) # [n_layers, n_heads, C, C]
  386. np.save(RESULTS / "gnn_attention_weights.npy", np.stack(attn_per_fold))
  387. print(f"saved {RESULTS/'gnn_attention_weights.npy'}", " shape:", np.stack(attn_per_fold).shape)
  388. # CNN saliency: train a single fold (P1 held out), compute per-class saliency on a few test trials
  389. torch.manual_seed(seed); np.random.seed(seed)
  390. test = subj == 1
  391. Xtr, ytr = X[~test], y[~test].astype(np.int64)
  392. Xte, yte = X[test], y[test].astype(np.int64)
  393. mu = Xtr.mean(0, keepdims=True); sd = Xtr.std(0, keepdims=True) + 1e-6
  394. Xtr = ((Xtr-mu)/sd).astype(np.float32); Xte = ((Xte-mu)/sd).astype(np.float32)
  395. cw = compute_class_weight("balanced", classes=np.array([0,1,2]), y=ytr)
  396. loss_fn = nn.CrossEntropyLoss(weight=torch.tensor(cw, dtype=torch.float32).to(device))
  397. cnn = EEGNet().to(device)
  398. opt = torch.optim.AdamW(cnn.parameters(), lr=lr, weight_decay=1e-4)
  399. loader = DataLoader(TensorDataset(torch.from_numpy(Xtr), torch.from_numpy(ytr)), batch_size=batch_size, shuffle=True)
  400. cnn.train()
  401. for _ in range(n_epochs):
  402. for xb, yb in loader:
  403. xb, yb = xb.to(device), yb.to(device)
  404. opt.zero_grad(); loss_fn(cnn(xb), yb).backward(); opt.step()
  405. cnn.eval()
  406. # Pick 2 trials per class
  407. examples_idx = []
  408. for c in range(3):
  409. cls_idx = np.where(yte == c)[0][:2]
  410. examples_idx.extend(cls_idx)
  411. saliencies = []
  412. for idx in examples_idx:
  413. x = torch.from_numpy(Xte[idx:idx+1]).to(device).requires_grad_(True)
  414. logits = cnn(x)
  415. c = int(yte[idx])
  416. cnn.zero_grad()
  417. logits[0, c].backward()
  418. sal = x.grad.abs().squeeze(0).cpu().numpy() # (37, 500)
  419. saliencies.append(sal)
  420. np.save(RESULTS / "cnn_saliency_examples.npy", np.stack(saliencies))
  421. print(f"saved {RESULTS/'cnn_saliency_examples.npy'}", " shape:", np.stack(saliencies).shape)
  424. # ---- Experiment 6: EMG-bandwidth harmonisation -----------------------------
  425. def exp_bandwidth(device, n_epochs=30, batch_size=64, lr=1e-3, seed=0):
  426. """Apply a 95-Hz lowpass to the deep-model EMG input and re-train CNN/GNN/HGBM
  427. so all decoders see the same EMG bandwidth (20-95 Hz). Compare the resulting
  428. LOSO accuracies to the unharmonised baseline."""
  429. from scipy.signal import butter, filtfilt
  430. rows = []
  431. # 95-Hz lowpass at 500 Hz: butter order 4
  432. b95, a95 = butter(4, 95.0 / 250.0, btype="low")
  433. for task in ("weight","surface"):
  434. # Load fused (32 EEG + 5 EMG)
  435. Xs, ys, subj = [], [], []
  436. for p in range(1, 13):
  437. d = np.load(CACHE / f"P{p}.npz")
  438. v = d["valid_mask"]
  439. eeg = d["eeg"][v]
  440. emg = d["emg"][v]
  441. # Apply 95-Hz LP to EMG channels along time axis
  442. emg_lp = filtfilt(b95, a95, emg, axis=-1).astype(np.float32)
  443. x = np.concatenate([eeg, emg_lp], axis=1).astype(np.float32)
  444. y = (d["y_weight"] if task == "weight" else d["y_surface"])[v]
  445. Xs.append(x); ys.append(y); subj.append(np.full(len(x), p, dtype=np.int8))
  446. X = np.concatenate(Xs); y = np.concatenate(ys); subj = np.concatenate(subj)
  447. for m in ("cnn", "gnn"):
  448. for h in range(1, 13):
  449. res, _ = deep_loso_fold(MODELS[m], X, y, subj, h, device=device,
  450. n_epochs=n_epochs, batch_size=batch_size,
  451. lr=lr, seed=seed)
  452. rows.append({"experiment":"bandwidth","model":m,"task":task,
  453. "harmonisation":"emg_lowpass_95hz",**res})
  454. print(f"[bandwidth] {m}/{task}/P{h:02d}: bal={res['balanced_accuracy']:.3f}", flush=True)
  455. pd.DataFrame(rows).to_csv(RESULTS / "bandwidth_harmonisation.csv", index=False)
  456. print(f"saved {RESULTS/'bandwidth_harmonisation.csv'}")
  458. # ---- Experiment 7: early-hold vs late-hold ---------------------------------
  459. def exp_earlyhold(device, n_epochs=30, batch_size=64, lr=1e-3, seed=0):
  460. """Decode from the first 500 ms (early-hold) vs the last 500 ms (late-hold)
  461. of the sustained-hold window. The cached window is already 1 s; we slice
  462. in half along the time axis."""
  463. rows = []
  464. for task in ("weight","surface"):
  465. X, y, subj = load_all_data(task, "fused") # (n, 37, 500)
  466. halves = {"early": X[..., :250], "late": X[..., 250:]}
  467. for label, X_half in halves.items():
  468. # Pad/repeat to 500 samples so the existing CNN/GNN architectures fit unchanged
  469. X_pad = np.concatenate([X_half, X_half], axis=-1) # tile to 500
  470. for m in ("cnn", "gnn"):
  471. for h in range(1, 13):
  472. res, _ = deep_loso_fold(MODELS[m], X_pad, y, subj, h, device=device,
  473. n_epochs=n_epochs, batch_size=batch_size,
  474. lr=lr, seed=seed)
  475. rows.append({"experiment":"earlyhold","model":m,"task":task,
  476. "phase":label, **res})
  477. print(f"[earlyhold] {m}/{task}/{label}/P{h:02d}: bal={res['balanced_accuracy']:.3f}", flush=True)
  478. pd.DataFrame(rows).to_csv(RESULTS / "earlyhold_vs_latehold.csv", index=False)
  479. print(f"saved {RESULTS/'earlyhold_vs_latehold.csv'}")
  482. # ---- Summary ---------------------------------------------------------------
  483. def summarize():
  484. summary = []
  485. for name, fn in [
  486. ("seed_robustness.csv", lambda df: df.groupby(["model","task"])["balanced_accuracy"].agg(["mean","std","count"]).round(3)),
  487. ("modality_ablation.csv", lambda df: df.groupby(["model","modality","task"])["balanced_accuracy"].agg(["mean","std"]).round(3)),
  488. ("conformer_hybrid.csv", lambda df: df.groupby(["task"])["balanced_accuracy"].agg(["mean","std"]).round(3)),
  489. ("crossing_conditioning.csv", lambda df: df.groupby(["model","decode","fixed_factor","fixed_value"])["balanced_accuracy"].agg(["mean","std","count"]).round(3)),
  490. ("bandwidth_harmonisation.csv", lambda df: df.groupby(["model","task"])["balanced_accuracy"].agg(["mean","std"]).round(3)),
  491. ("earlyhold_vs_latehold.csv", lambda df: df.groupby(["model","task","phase"])["balanced_accuracy"].agg(["mean","std"]).round(3)),
  492. ]:
  493. path = RESULTS / name
  494. if path.exists():
  495. df = pd.read_csv(path)
  496. summary.append(f"\n=== {name} ===\n{fn(df).to_string()}")
  497. out = "\n".join(summary)
  498. (RESULTS / "revision_summary.txt").write_text(out)
  499. print("\n" + out)
  500. print(f"\nsaved {RESULTS/'revision_summary.txt'}")
  502. # ---- Main ------------------------------------------------------------------
  503. def main():
  504. ap = argparse.ArgumentParser()
  505. ap.add_argument("--only", nargs="+", choices=["seeds","modality","conformer","crossing","interp","bandwidth","earlyhold"])
  506. ap.add_argument("--skip", nargs="+", default=[], choices=["seeds","modality","conformer","crossing","interp","bandwidth","earlyhold"])
  507. ap.add_argument("--epochs", type=int, default=30)
  508. ap.add_argument("--batch-size", type=int, default=64)
  509. ap.add_argument("--lr", type=float, default=1e-3)
  510. args = ap.parse_args()
  511. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
  512. print("Using device:", device)
  513. todo = ["seeds","modality","conformer","crossing","interp","bandwidth","earlyhold"]
  514. if args.only:
  515. todo = [t for t in todo if t in args.only]
  516. todo = [t for t in todo if t not in args.skip]
  517. print("Plan:", todo)
  518. if "seeds" in todo: exp_seeds(device, n_epochs=args.epochs, batch_size=args.batch_size, lr=args.lr)
  519. if "modality" in todo: exp_modality(device, n_epochs=args.epochs, batch_size=args.batch_size, lr=args.lr)
  520. if "conformer" in todo: exp_conformer(device, n_epochs=args.epochs, batch_size=args.batch_size, lr=args.lr)
  521. if "crossing" in todo: exp_crossing(device, n_epochs=args.epochs, batch_size=args.batch_size, lr=args.lr)
  522. if "interp" in todo: exp_interp(device, n_epochs=args.epochs, batch_size=args.batch_size, lr=args.lr)
  523. if "bandwidth" in todo: exp_bandwidth(device, n_epochs=args.epochs, batch_size=args.batch_size, lr=args.lr)
  524. if "earlyhold" in todo: exp_earlyhold(device, n_epochs=args.epochs, batch_size=args.batch_size, lr=args.lr)
  525. summarize()
  527. if __name__ == "__main__":
  528. main()

revision_ablations.py at commit 2caa855, under MIT · at the source

Overview

Authors: Osmar Pinto Neto1,2,3
  1. Biomedical Engineering Postgraduate Program, Anhembi Morumbi University, São José dos Campos, Brazil
  2. Department of Kinesiology, California State University San Marcos (CSUSM), San Marcos, CA, United States
  3. Neurometra, Carlsbad, CA, United States
Institutions: Anhembi Morumbi University (Brazil); California State University, San Marcos (United States)
Journal: Frontiers in neuroscience, volume 20, article 1874302
Dates: received 6 May 2026; accepted 26 June 2026; published online 20 July 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.3389/fnins.2026.1874302 · PMID 42548755 · PMCID PMC13429724 · OpenAlex W7169816556
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: EEG (modality), other (modality), methods / tools (subfield)
Methods: Spectral & time-frequency, Preprocessing, Connectivity, Statistics, Smoothing, state filtering, decompositions, Machine learning, Physiology & signal measures
Keywords: brain-computer interface, deep learning, EEG, EEGNet, EMG, graph attention network, grasp-and-lift, interpretability
Topic: EEG and Brain-Computer Interfaces (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Anima Institute (12/2025)
Citations: not cited yet (Europe PMC); 31 references in the paper

Abstract

Modern deep learning has broadened the tools available for non-invasive neural decoding, but its advantage over well-engineered classical pipelines remains unclear at clinical neural-engineering sample sizes. We compared four classical decoders, three multilayer perceptron (MLP) variants, and three deep-learning architectures (an EEGNet-style compact convolutional network, a four-layer Transformer encoder trained from scratch, and a graph attention network) on the public WAY-EEG-GAL grasp-and-lift dataset (12 participants, 3,528 trials). Models were evaluated using leave-one-subject-out (LOSO) cross-validation to decode object weight (165, 330, and 660 g) and grasp-surface friction (sandpaper, suede, and silk). After Benjamini–Hochberg false discovery rate (BH-FDR) correction within the primary/robustness family, none of the deep-versus-best-classical comparisons reached significance. The graph attention network led nominally on weight (0.643), and the compact convolutional network (CNN) led nominally on surface (0.565), but neither exceeded the best classical baselines (HGBM = 0.617 for weight; logistic regression = 0.562 for surface). Two-direction bandwidth controls showed that the nominal graph neural network (GNN) advantage on weight reflected access to higher-frequency electromyography (EMG) content rather than a robust architectural gain. The GNN weight signal was concentrated in the first 500 ms of sustained hold (0.639 early vs. 0.540 late, q = 0.007), whereas the compact CNN was comparatively robust to bandwidth and phase. A four-layer Transformer trained from scratch underperformed (q = 0.003 for both tasks), consistent with a parameter–data mismatch at n = 12. Modality ablation showed that both tasks were dominated by peripheral EMG features: electroencephalography (EEG)-only decoding was near chance for weight (0.34–0.37) and surface (0.36–0.38; all q < 0.0015 vs. EMG-only). EMG-only HGBM achieved the highest accuracy in the study (0.712 for weight and 0.584 for surface), and adding EEG channels reduced HGBM weight decoding (q = 0.007) and CNN surface decoding (q = 0.012). In contrast, the graph attention network was robust to EEG-induced fusion dilution (q > 0.5), consistent with attention-based down-weighting of low-information channels. Together, bandwidth, modality, phase, and conditioning controls indicate that, at clinical sample sizes, the critical design choice is not architectural complexity but modality-relevant channel selection and the ability to suppress low-information channels.

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

Repositories

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

osmar235/eeg-emg-architecture-data-matching

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 2caa855503f5697eb11bdee065cc40b2694df736, 22 June 2026
Languages: Python (14), Jupyter (1)
Size: 45 files, 15 scripts
Software Heritage: not archived
Found in: “Data availability statement”
Holds: README, license file, CITATION.cff, environment (requirements.txt), documentation, 1 notebook
Not found: tests, continuous integration
Tools: NumPy (15 files), pandas (13 files), scikit-learn (13 files), SciPy (8 files), PyTorch (7 files), Matplotlib (6 files), JAX (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
17 files
At the source: github.com/osmar235/eeg-emg-architecture-data-matching

Zenodo 19966634

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Data availability statement”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (13 files), pandas (12 files), scikit-learn (11 files), SciPy (7 files), PyTorch (5 files), Matplotlib (4 files), JAX (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers (HTTP 200)
  • 27 September 2026: the link answers (HTTP 200)
15 files
At the source: doi.org/10.5281/zenodo.19966634

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

Tracing map

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

What the map holds:

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

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

Data

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

Data availability statement

The raw WAY-EEG-GAL dataset analyzed in this study is publicly available from Luciw et al. (2014) and via PhysioNet. All analysis code, derived per-subject feature tensors, model checkpoints, and figure-generation scripts are available on GitHub (https://github.com/osmar235/eeg-emg-architecture-data-matching) and archived on Zenodo (DOI: 10.5281/zenodo.19966634 (https://doi.org/10.5281/zenodo.19966634)).

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

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, pages, dates, 1 author, 8 keywords, 1 funder, 28 references.

Cite

This paper

Pinto Neto, O. (2026). Architecture-data matching for EEG-EMG decoding: compact deep models match classical spectral decoders on the WAY-EEG-GAL grasp-and-lift dataset. Frontiers in neuroscience, 20, 1874302. https://doi.org/10.3389/fnins.2026.1874302

BibTeX

@article{pintoneto2026architecture,
author = {Pinto Neto, Osmar},
title = {{Architecture-data matching for EEG-EMG decoding: compact deep models match classical spectral decoders on the WAY-EEG-GAL grasp-and-lift dataset}},
journal = {Frontiers in neuroscience},
year = {2026},
month = jul,
volume = {20},
pages = {1874302},
publisher = {Frontiers Media SA},
issn = {1662-4548},
doi = {10.3389/fnins.2026.1874302},
url = {https://doi.org/10.3389/fnins.2026.1874302},
pmid = {42548755},
pmcid = {PMC13429724}
}

RIS

TY - JOUR
AU - Pinto Neto, Osmar
TI - Architecture-data matching for EEG-EMG decoding: compact deep models match classical spectral decoders on the WAY-EEG-GAL grasp-and-lift dataset
T2 - Frontiers in neuroscience
J2 - Front Neurosci
PY - 2026
DA - 2026/07/20
VL - 20
SP - 1874302
SN - 1662-4548
PB - Frontiers Media SA
DO - 10.3389/fnins.2026.1874302
UR - https://doi.org/10.3389/fnins.2026.1874302
LA - en
ER -

CSL-JSON

{
"id": "10.3389/fnins.2026.1874302",
"type": "article-journal",
"title": "Architecture-data matching for EEG-EMG decoding: compact deep models match classical spectral decoders on the WAY-EEG-GAL grasp-and-lift dataset",
"container-title": "Frontiers in neuroscience",
"author": [
{
"family": "Pinto Neto",
"given": "Osmar"
}
],
"container-title-short": "Front Neurosci",
"volume": "20",
"page": "1874302",
"DOI": "10.3389/fnins.2026.1874302",
"PMID": "42548755",
"PMCID": "PMC13429724",
"ISSN": "1662-4548",
"publisher": "Frontiers Media SA",
"URL": "https://doi.org/10.3389/fnins.2026.1874302",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
20
]
]
}
}

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.1371/journal.pone.0347671 [code]
RMETNet: A cross-subject motor imagery EEG signal classification model based on TSLANet and riemannian geometry features.
Journal: PloS one
In common: PyTorch, scikit-learn, pandas, 3 other tools, methods / tools, EEG, 4 references
[2] doi:10.3390/s26103065 [code]
Subject-Wise Depression Screening from Eight-Channel Resting-State EEG Using Asymmetry-Aware Spectral Features and Connectivity Ablation.
Journal: Sensors (Basel, Switzerland)
In common: PyTorch, scikit-learn, pandas, 3 other tools, other, EEG, 3 references
[3] doi:10.1038/s41598-026-68186-2 [code]
NeuroStream: spectral-spatio-temporal deep learning for visual stimulus classification from EEG.
Journal: Scientific reports
In common: PyTorch, scikit-learn, pandas, 3 other tools, methods / tools, EEG, 3 references
[4] doi:10.1038/s41746-026-02778-0 [code]
Trust-gated synthetic EEG augmentation reduces performance drops when generalizing to new patients.
Journal: NPJ digital medicine
In common: PyTorch, scikit-learn, pandas, 3 other tools, EEG, 3 references
[5] doi:10.3390/bios16080437 [code]
Deep Learning for Ear-EEG-Based Brain-Computer Interface: A Systematic Comparison and Design Insights.
Journal: Biosensors
In common: PyTorch, scikit-learn, pandas, 2 other tools, EEG, 3 references
[6] doi:10.3389/fpsyg.2026.1774068 [code]
Analysis of cognitive mechanisms in phoneme perception and pronunciation errors among Korean language learners.
Journal: Frontiers in psychology
In common: PyTorch, scikit-learn, pandas, 3 other tools, EEG, 2 references
[7] doi:10.1038/s41586-026-10658-6 [code]
An AI system to help scientists write expert-level empirical software.
Journal: Nature
In common: JAX, PyTorch, scikit-learn, 4 other tools, methods / tools
[8] doi:10.1371/journal.pone.0346575 [code]
Statistically valid explainable black-box machine learning: applications in sex classification across species using brain imaging.
Journal: PloS one
In common: JAX, PyTorch, scikit-learn, 4 other tools, methods / tools
[9] doi:10.3390/e28030310
Entropy-Based Dual-Teacher Distillation for Efficient Motor Imagery EEG Classification.
Journal: Entropy (Basel, Switzerland)
In common: methods / tools, EEG, 5 references
[10] doi:10.3390/s26051730 [code]
SFE-GAT: Structure-Feature Evolution Graph Attention Network for Motor Imagery Decoding.
Journal: Sensors (Basel, Switzerland)
In common: PyTorch, SciPy, Matplotlib, 1 other tool, EEG, 3 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.