OSCR

MCLF: Montage consistent CNN-Liquid fusion for long-term scalp EEG seizure detection.

Code ↔ Paper

7 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 7 matches
  1. [1] § Method validation › Comparison with baseline methods ↔ tcn_bilstm.py, lines 1–9 · score 0.69 · temporal convolution, TCN BiLSTM, models
  2. [2] § Method validation › Comparison with baseline methods ↔ eval_tuev_external.py, lines 93–119 · score 0.69 · TCN BiLSTM, CNN Transformer, CNN Informer, models
  3. [3] § Method validation › Comparison with baseline methods ↔ eval_tuev_external.py, lines 93–119 · score 0.58 · TCN Bi LSTM, CNN Informer, seizure
  4. [4] § Method validation › Experimental setup ↔ train_eval_main.py, lines 337–408 · score 0.57 · training loss, Adam, patience, batch, model
  5. [5] § Method validation › Evaluation metrics ↔ train_eval_main.py, lines 676–711 · score 0.52 · segment sensitivity, FN, FP, TN, TP, accuracy
  6. [6] § Method validation › Dataset and annotations ↔ config.py, lines 20–21 · score 0.51 · CHB MIT scalp, signals, EEG, seizure
  7. [7] § Method validation › External robustness analysis on artifact-labeled EEG events ↔ eval_tuev_external.py, lines 318–349 · score 0.50 · positive prediction rates, confusion, bckg, eyem, artf, External

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 · 657 lines · 22 KB · no license · 3 matches

  1. # -*- coding: utf-8 -*-
  2. import os
  3. import csv
  4. import glob
  5. import argparse
  7. import numpy as np
  8. import torch
  9. import mne
  10. import matplotlib.pyplot as plt
  11. from sklearn.metrics import accuracy_score, recall_score, confusion_matrix, roc_auc_score, f1_score
  13. from config import setup_env
  14. from model import SeizureLiquidChannelNet
  15. from cnn_informer import CNNInformerNet
  16. from tcn_bilstm import TCN_BiLSTM
  17. from dataProcess import normalize_eeg, dwt_filter_eeg_0_32hz
  19. # =========================
  20. # 1) 与原 CHB 保持一致的输入定义
  21. # =========================
  22. FS_TARGET = 256
  23. EPOCH_SEC = 4.0
  24. EPOCH_LEN = int(FS_TARGET * EPOCH_SEC)
  26. CH_LABELS_18 = [
  27. 'FP1-F7', 'F7-T7', 'T7-P7', 'P7-O1',
  28. 'FP1-F3', 'F3-C3', 'C3-P3', 'P3-O1',
  29. 'FP2-F4', 'F4-C4', 'C4-P4', 'P4-O2',
  30. 'FP2-F8', 'F8-T8', 'T8-P8', 'P8-O2',
  31. 'FZ-CZ', 'CZ-PZ'
  32. ]
  34. REF_CANDIDATES = {
  35. "FP1": ["EEG FP1-REF", "FP1-REF", "FP1"],
  36. "F7": ["EEG F7-REF", "F7-REF", "F7"],
  37. "T7": ["EEG T7-REF", "T7-REF", "T7", "EEG T3-REF", "T3-REF", "T3"],
  38. "P7": ["EEG P7-REF", "P7-REF", "P7", "EEG T5-REF", "T5-REF", "T5"],
  39. "O1": ["EEG O1-REF", "O1-REF", "O1"],
  40. "F3": ["EEG F3-REF", "F3-REF", "F3"],
  41. "C3": ["EEG C3-REF", "C3-REF", "C3"],
  42. "P3": ["EEG P3-REF", "P3-REF", "P3"],
  43. "FP2": ["EEG FP2-REF", "FP2-REF", "FP2"],
  44. "F4": ["EEG F4-REF", "F4-REF", "F4"],
  45. "C4": ["EEG C4-REF", "C4-REF", "C4"],
  46. "P4": ["EEG P4-REF", "P4-REF", "P4"],
  47. "O2": ["EEG O2-REF", "O2-REF", "O2"],
  48. "F8": ["EEG F8-REF", "F8-REF", "F8"],
  49. "T8": ["EEG T8-REF", "T8-REF", "T8", "EEG T4-REF", "T4-REF", "T4"],
  50. "P8": ["EEG P8-REF", "P8-REF", "P8", "EEG T6-REF", "T6-REF", "T6"],
  51. "FZ": ["EEG FZ-REF", "FZ-REF", "FZ"],
  52. "CZ": ["EEG CZ-REF", "CZ-REF", "CZ"],
  53. "PZ": ["EEG PZ-REF", "PZ-REF", "PZ"],
  54. }
  56. BIPOLAR_MAP = [
  57. ("FP1", "F7"),
  58. ("F7", "T7"),
  59. ("T7", "P7"),
  60. ("P7", "O1"),
  61. ("FP1", "F3"),
  62. ("F3", "C3"),
  63. ("C3", "P3"),
  64. ("P3", "O1"),
  65. ("FP2", "F4"),
  66. ("F4", "C4"),
  67. ("C4", "P4"),
  68. ("P4", "O2"),
  69. ("FP2", "F8"),
  70. ("F8", "T8"),
  71. ("T8", "P8"),
  72. ("P8", "O2"),
  73. ("FZ", "CZ"),
  74. ("CZ", "PZ"),
  75. ]
  77. LABEL_ID_TO_NAME = {
  78. 1: "spsw",
  79. 2: "gped",
  80. 3: "pled",
  81. 4: "eyem",
  82. 5: "artf",
  83. 6: "bckg",
  85. }
  86. POSITIVE_LABELS = {"spsw"}
  87. NEGATIVE_LABELS = {"artf", "eyem", "bckg"}
  88. AUX_OOD_LABELS = {"gped", "pled"}
  90. THRESH_CANDIDATES = np.round(np.linspace(0.01, 0.90, 90), 2)
  93. # =========================
  94. # 2) 多模型支持
  95. # =========================
  96. def build_model(model_type: str):
  97. model_type = model_type.lower()
  99. if model_type == "liquid":
  100. return SeizureLiquidChannelNet()
  102. elif model_type == "cnn_transformer":
  103. return CNNInformerNet(model_type="cnn_transformer")
  105. elif model_type == "cnn_informer":
  106. return CNNInformerNet(model_type="cnn_informer", factor=3)
  108. elif model_type == "cnn_informer_nodistill":
  109. return CNNInformerNet(model_type="cnn_informer_nodistill", factor=3)
  111. elif model_type == "tcn_bilstm":
  112. return TCN_BiLSTM()
  114. else:
  115. raise ValueError(
  116. f"Unsupported model_type: {model_type}. "
  117. f"Choose from: liquid, cnn_transformer, cnn_informer, "
  118. f"cnn_informer_nodistill, tcn_bilstm"
  119. )
  122. # =========================
  123. # 3) 数据读取
  124. # =========================
  125. def find_channel(raw, aliases):
  126. for a in aliases:
  127. if a in raw.ch_names:
  128. return a
  129. return None
  132. def load_tuev_18ch_uV_consistent(edf_path):
  133. raw = mne.io.read_raw_edf(edf_path, preload=True, verbose=False)
  135. if int(raw.info["sfreq"]) != FS_TARGET:
  136. raw.resample(FS_TARGET)
  138. fs = float(raw.info["sfreq"])
  140. ref_data = {}
  141. mapping_used = {}
  142. for key, aliases in REF_CANDIDATES.items():
  143. ch = find_channel(raw, aliases)
  144. if ch is None:
  145. raw.close()
  146. raise ValueError(f"Missing REF channel for {key} in {edf_path}")
  147. mapping_used[key] = ch
  148. ref_data[key] = raw.get_data(picks=[ch])[0] * 1e6
  150. raw.close()
  152. data = []
  153. for a, b in BIPOLAR_MAP:
  154. data.append(ref_data[a] - ref_data[b])
  155. data = np.stack(data, axis=0).astype(np.float32)
  157. # 与训练保持一致：robust normalize -> DWT
  158. data = normalize_eeg(data, mode="robust", eps=1e-6, clip=5.0)
  159. data = dwt_filter_eeg_0_32hz(data, wavelet="db4", level=5, mode="symmetric")
  161. return data, fs, mapping_used
  164. def read_rec_events(rec_path):
  165. events = []
  166. with open(rec_path, "r", encoding="utf-8") as f:
  167. for line in f:
  168. line = line.strip()
  169. if not line or line.startswith("#"):
  170. continue
  171. parts = line.split(",")
  172. if len(parts) != 4:
  173. continue
  174. ch_idx = int(parts[0])
  175. st = float(parts[1])
  176. ed = float(parts[2])
  177. lab_id = int(parts[3])
  178. lab_name = LABEL_ID_TO_NAME.get(lab_id, "unknown")
  179. events.append({
  180. "channel": ch_idx,
  181. "start": st,
  182. "end": ed,
  183. "label_id": lab_id,
  184. "label_name": lab_name,
  185. })
  186. return events
  189. def crop_center_epoch(data_18ch, fs, start_sec, end_sec, epoch_len=EPOCH_LEN):
  190. total_len = data_18ch.shape[1]
  191. center = 0.5 * (start_sec + end_sec)
  192. center_idx = int(center * fs)
  194. half = epoch_len // 2
  195. s0 = center_idx - half
  196. s1 = center_idx + half
  198. if s0 < 0:
  199. s0 = 0
  200. s1 = epoch_len
  201. if s1 > total_len:
  202. s1 = total_len
  203. s0 = total_len - epoch_len
  205. if s0 < 0 or s1 > total_len or (s1 - s0) != epoch_len:
  206. return None
  208. seg = data_18ch[:, s0:s1]
  209. if seg.shape != (18, epoch_len):
  210. return None
  211. return seg.astype(np.float32)
  214. def build_tuev_eval_dataset(eval_root, save_mapping_preview_path=None, max_preview_files=10):
  215. edf_files = sorted(glob.glob(os.path.join(eval_root, "*", "*.edf")))
  217. X_list, y_list, fine_list = [], [], []
  218. X_aux_list, fine_aux_list = [], []
  220. preview_rows = []
  221. preview_count = 0
  223. for edf_path in edf_files:
  224. rec_path = edf_path.replace(".edf", ".rec")
  225. if not os.path.exists(rec_path):
  226. continue
  228. try:
  229. data_18ch, fs, mapping_used = load_tuev_18ch_uV_consistent(edf_path)
  230. events = read_rec_events(rec_path)
  231. except Exception as e:
  232. print(f"[SKIP] {edf_path}: {e}")
  233. continue
  235. if preview_count < max_preview_files:
  236. row = {"edf": os.path.basename(edf_path)}
  237. row.update(mapping_used)
  238. preview_rows.append(row)
  239. preview_count += 1
  241. for ev in events:
  242. lab = ev["label_name"]
  243. seg = crop_center_epoch(data_18ch, fs, ev["start"], ev["end"], epoch_len=EPOCH_LEN)
  244. if seg is None:
  245. continue
  247. if lab in POSITIVE_LABELS:
  248. X_list.append(seg)
  249. y_list.append(1)
  250. fine_list.append(lab)
  251. elif lab in NEGATIVE_LABELS:
  252. X_list.append(seg)
  253. y_list.append(0)
  254. fine_list.append(lab)
  255. elif lab in AUX_OOD_LABELS:
  256. X_aux_list.append(seg)
  257. fine_aux_list.append(lab)
  259. if len(X_list) == 0:
  260. raise RuntimeError("No valid main-eval samples built.")
  262. X = np.stack(X_list, axis=0).astype(np.float32)
  263. X = X[:, np.newaxis, :, :]
  264. y = np.array(y_list, dtype=np.int32)
  265. fine = np.array(fine_list)
  267. if len(X_aux_list) > 0:
  268. X_aux = np.stack(X_aux_list, axis=0).astype(np.float32)
  269. X_aux = X_aux[:, np.newaxis, :, :]
  270. fine_aux = np.array(fine_aux_list)
  271. else:
  272. X_aux = None
  273. fine_aux = None
  275. if save_mapping_preview_path and len(preview_rows) > 0:
  276. os.makedirs(os.path.dirname(save_mapping_preview_path), exist_ok=True)
  277. keys = list(preview_rows[0].keys())
  278. with open(save_mapping_preview_path, "w", newline="", encoding="utf-8") as f:
  279. w = csv.DictWriter(f, fieldnames=keys)
  280. w.writeheader()
  281. for r in preview_rows:
  282. w.writerow(r)
  284. return X, y, fine, X_aux, fine_aux
  287. # =========================
  288. # 4) 推理
  289. # =========================
  290. @torch.no_grad()
  291. def predict_batches(model, X, device, batch_size=256):
  292. model.eval()
  293. probs = []
  294. for i in range(0, len(X), batch_size):
  295. xb = torch.from_numpy(X[i:i+batch_size]).to(device, non_blocking=True)
  296. logits = model(xb).squeeze(1)
  297. p = torch.sigmoid(logits).detach().cpu().numpy().astype(np.float32)
  298. probs.append(p)
  299. return np.concatenate(probs, axis=0)
  302. # =========================
  303. # 5) 统计与可视化
  304. # =========================
  305. def summarize_by_fine_label_at_threshold(pred, fine_labels):
  306. out = {}
  307. for lab in sorted(set(fine_labels)):
  308. idx = (fine_labels == lab)
  309. if idx.sum() == 0:
  310. continue
  311. out[lab] = {
  312. "n": int(idx.sum()),
  313. "positive_prediction_rate": float(pred[idx].mean())
  314. }
  315. return out
  318. def compute_metrics_at_threshold(y_true, probs, fine_labels, threshold):
  319. pred = (probs >= threshold).astype(np.int32)
  321. acc = accuracy_score(y_true, pred)
  322. sens = recall_score(y_true, pred, pos_label=1, zero_division=0)
  324. tn, fp, fn, tp = confusion_matrix(y_true, pred, labels=[0, 1]).ravel()
  325. spec = tn / (tn + fp + 1e-9)
  326. prec = tp / (tp + fp + 1e-9)
  327. f1 = f1_score(y_true, pred, zero_division=0)
  328. bal_acc = 0.5 * (sens + spec)
  330. by_label = summarize_by_fine_label_at_threshold(pred, fine_labels)
  332. row = {
  333. "threshold": float(threshold),
  334. "accuracy": float(acc),
  335. "sensitivity": float(sens),
  336. "specificity": float(spec),
  337. "precision": float(prec),
  338. "f1": float(f1),
  339. "balanced_accuracy": float(bal_acc),
  340. "tp": int(tp),
  341. "fp": int(fp),
  342. "tn": int(tn),
  343. "fn": int(fn),
  344. "artf_pos_rate": float(by_label.get("artf", {}).get("positive_prediction_rate", np.nan)),
  345. "eyem_pos_rate": float(by_label.get("eyem", {}).get("positive_prediction_rate", np.nan)),
  346. "bckg_pos_rate": float(by_label.get("bckg", {}).get("positive_prediction_rate", np.nan)),
  347. "spsw_pos_rate": float(by_label.get("spsw", {}).get("positive_prediction_rate", np.nan)),
  348. }
  349. return row
  352. def save_threshold_tables(rows, out_dir):
  353. os.makedirs(out_dir, exist_ok=True)
  355. metrics_csv = os.path.join(out_dir, "threshold_metrics.csv")
  356. keys = list(rows[0].keys())
  357. with open(metrics_csv, "w", newline="", encoding="utf-8") as f:
  358. w = csv.DictWriter(f, fieldnames=keys)
  359. w.writeheader()
  360. for r in rows:
  361. w.writerow(r)
  363. by_label_csv = os.path.join(out_dir, "threshold_by_label.csv")
  364. label_rows = []
  365. for r in rows:
  366. thr = r["threshold"]
  367. for lab in ["spsw", "artf", "eyem", "bckg"]:
  368. label_rows.append({
  369. "threshold": thr,
  370. "label": lab,
  371. "positive_prediction_rate": r[f"{lab}_pos_rate"]
  372. })
  373. with open(by_label_csv, "w", newline="", encoding="utf-8") as f:
  374. w = csv.DictWriter(f, fieldnames=["threshold", "label", "positive_prediction_rate"])
  375. w.writeheader()
  376. for rr in label_rows:
  377. w.writerow(rr)
  379. return metrics_csv, by_label_csv
  382. def plot_threshold_curves(rows, out_dir):
  383. os.makedirs(out_dir, exist_ok=True)
  385. th = np.array([r["threshold"] for r in rows], dtype=np.float32)
  386. sens = np.array([r["sensitivity"] for r in rows], dtype=np.float32)
  387. spec = np.array([r["specificity"] for r in rows], dtype=np.float32)
  388. artf = np.array([r["artf_pos_rate"] for r in rows], dtype=np.float32)
  389. eyem = np.array([r["eyem_pos_rate"] for r in rows], dtype=np.float32)
  390. bckg = np.array([r["bckg_pos_rate"] for r in rows], dtype=np.float32)
  392. plt.figure(figsize=(8, 5))
  393. plt.plot(th, sens, label="Sensitivity", linewidth=2)
  394. plt.plot(th, spec, label="Specificity", linewidth=2)
  395. plt.plot(th, artf, label="ARTF positive rate", linewidth=2)
  396. plt.plot(th, eyem, label="EYEM positive rate", linewidth=1.5, linestyle="--")
  397. plt.plot(th, bckg, label="BCKG positive rate", linewidth=1.5, linestyle=":")
  398. plt.xlabel("Threshold")
  399. plt.ylabel("Rate")
  400. plt.title("Threshold sweep: sensitivity / specificity / artifact-related rates")
  401. plt.ylim(-0.02, 1.02)
  402. plt.grid(alpha=0.3)
  403. plt.legend()
  404. plt.tight_layout()
  405. plt.savefig(os.path.join(out_dir, "threshold_sens_spec_artf.png"), dpi=200)
  406. plt.close()
  408. plt.figure(figsize=(6, 6))
  409. plt.plot(1 - spec, sens, linewidth=2, marker="o", markersize=3)
  410. for i in range(0, len(th), max(1, len(th) // 10)):
  411. plt.text((1 - spec[i]) + 0.002, sens[i], f"{th[i]:.2f}", fontsize=8)
  412. plt.xlabel("1 - Specificity")
  413. plt.ylabel("Sensitivity")
  414. plt.title("Operating points under threshold sweep")
  415. plt.grid(alpha=0.3)
  416. plt.tight_layout()
  417. plt.savefig(os.path.join(out_dir, "threshold_roc_like.png"), dpi=200)
  418. plt.close()
  421. def summarize_prob_distribution_by_label(probs, fine_labels, out_dir, filename_prefix="prob_distribution_by_label"):
  422. os.makedirs(out_dir, exist_ok=True)
  424. labels = sorted(set(fine_labels))
  425. rows = []
  427. print("\n===== Probability distribution by original label =====")
  428. for lab in labels:
  429. idx = (fine_labels == lab)
  430. p = probs[idx]
  431. if len(p) == 0:
  432. continue
  434. row = {
  435. "label": lab,
  436. "n": int(len(p)),
  437. "mean": float(np.mean(p)),
  438. "median": float(np.median(p)),
  439. "std": float(np.std(p)),
  440. "p10": float(np.percentile(p, 10)),
  441. "p25": float(np.percentile(p, 25)),
  442. "p75": float(np.percentile(p, 75)),
  443. "p90": float(np.percentile(p, 90)),
  444. "p95": float(np.percentile(p, 95)),
  445. "max": float(np.max(p)),
  446. "min": float(np.min(p)),
  447. }
  448. rows.append(row)
  450. print(
  451. f"{lab:>5s} | n={row['n']:5d} | "
  452. f"mean={row['mean']:.4f} | median={row['median']:.4f} | std={row['std']:.4f} | "
  453. f"p90={row['p90']:.4f} | p95={row['p95']:.4f} | max={row['max']:.4f}"
  454. )
  456. csv_path = os.path.join(out_dir, f"{filename_prefix}.csv")
  457. with open(csv_path, "w", newline="", encoding="utf-8") as f:
  458. w = csv.DictWriter(f, fieldnames=list(rows[0].keys()))
  459. w.writeheader()
  460. for r in rows:
  461. w.writerow(r)
  463. plt.figure(figsize=(10, 6))
  464. bins = np.linspace(0, 1, 51)
  465. for lab in labels:
  466. idx = (fine_labels == lab)
  467. p = probs[idx]
  468. if len(p) == 0:
  469. continue
  470. plt.hist(p, bins=bins, alpha=0.35, density=True, label=lab)
  472. plt.xlabel("Predicted probability")
  473. plt.ylabel("Density")
  474. plt.title("Probability distribution by original label")
  475. plt.legend()
  476. plt.grid(alpha=0.3)
  477. plt.tight_layout()
  478. fig_path = os.path.join(out_dir, f"{filename_prefix}.png")
  479. plt.savefig(fig_path, dpi=200)
  480. plt.close()
  482. return csv_path, fig_path
  485. def summarize_binary_prob_distribution(probs, y_true, out_dir):
  486. os.makedirs(out_dir, exist_ok=True)
  488. pos = probs[y_true == 1]
  489. neg = probs[y_true == 0]
  491. def stats(arr, name):
  492. return {
  493. "group": name,
  494. "n": int(len(arr)),
  495. "mean": float(np.mean(arr)),
  496. "median": float(np.median(arr)),
  497. "std": float(np.std(arr)),
  498. "p90": float(np.percentile(arr, 90)),
  499. "p95": float(np.percentile(arr, 95)),
  500. "max": float(np.max(arr)),
  501. "min": float(np.min(arr)),
  502. }
  504. rows = [stats(pos, "positive"), stats(neg, "negative")]
  506. print("\n===== Probability distribution by binary class =====")
  507. for r in rows:
  508. print(
  509. f"{r['group']:>8s} | n={r['n']:5d} | "
  510. f"mean={r['mean']:.4f} | median={r['median']:.4f} | std={r['std']:.4f} | "
  511. f"p90={r['p90']:.4f} | p95={r['p95']:.4f} | max={r['max']:.4f}"
  512. )
  514. csv_path = os.path.join(out_dir, "prob_distribution_binary.csv")
  515. with open(csv_path, "w", newline="", encoding="utf-8") as f:
  516. w = csv.DictWriter(f, fieldnames=list(rows[0].keys()))
  517. w.writeheader()
  518. for r in rows:
  519. w.writerow(r)
  521. plt.figure(figsize=(8, 5))
  522. bins = np.linspace(0, 1, 51)
  523. plt.hist(pos, bins=bins, alpha=0.45, density=True, label="positive")
  524. plt.hist(neg, bins=bins, alpha=0.45, density=True, label="negative")
  525. plt.xlabel("Predicted probability")
  526. plt.ylabel("Density")
  527. plt.title("Probability distribution by binary class")
  528. plt.legend()
  529. plt.grid(alpha=0.3)
  530. plt.tight_layout()
  531. fig_path = os.path.join(out_dir, "prob_distribution_binary.png")
  532. plt.savefig(fig_path, dpi=200)
  533. plt.close()
  535. return csv_path, fig_path
  538. def print_best_points(rows):
  539. rows_sorted_bal = sorted(rows, key=lambda x: x["balanced_accuracy"], reverse=True)
  540. rows_sorted_f1 = sorted(rows, key=lambda x: x["f1"], reverse=True)
  541. rows_sorted_artf = sorted(rows, key=lambda x: (x["artf_pos_rate"], -x["sensitivity"]))
  543. print("\n===== Best threshold by balanced accuracy =====")
  544. print(rows_sorted_bal[0])
  546. print("\n===== Best threshold by F1 =====")
  547. print(rows_sorted_f1[0])
  549. print("\n===== Threshold with lowest ARTF positive rate (tie -> higher sensitivity) =====")
  550. print(rows_sorted_artf[0])
  553. # =========================
  554. # 6) 主程序
  555. # =========================
  556. def main():
  557. parser = argparse.ArgumentParser()
  558. parser.add_argument("--eval_root", type=str, default="archive/edf/eval")
  559. parser.add_argument("--ckpt", type=str, default="torch_models/GLOBAL_SeizureLiquidChannelNet.pt")
  560. parser.add_argument("--model_type", type=str, default="liquid",
  561. choices=[
  562. "liquid",
  563. "cnn_transformer",
  564. "cnn_informer",
  565. "cnn_informer_nodistill",
  566. "tcn_bilstm",
  567. ],
  568. help="which model architecture the checkpoint belongs to")
  569. parser.add_argument("--batch_size", type=int, default=256)
  570. parser.add_argument("--out_dir", type=str, default="tuev_external_eval_spsw")
  571. args = parser.parse_args()
  573. device = setup_env()
  574. os.makedirs(args.out_dir, exist_ok=True)
  576. mapping_preview_csv = os.path.join(args.out_dir, "channel_mapping_preview.csv")
  578. print("[INFO] Building TUEV eval dataset...")
  579. X, y, fine, X_aux, fine_aux = build_tuev_eval_dataset(
  580. args.eval_root,
  581. save_mapping_preview_path=mapping_preview_csv,
  582. max_preview_files=10
  583. )
  584. print(f"[INFO] Main task X={X.shape}, positive={int(y.sum())}, negative={int((y == 0).sum())}")
  585. if X_aux is not None:
  586. print(f"[INFO] Auxiliary OOD samples X_aux={X_aux.shape}")
  588. print(f"[INFO] Loading model: {args.model_type}")
  589. model = build_model(args.model_type)
  590. sd = torch.load(args.ckpt, map_location="cpu")
  591. model.load_state_dict(sd)
  592. model.to(device)
  593. model.eval()
  595. print("[INFO] Predicting main task once...")
  596. probs = predict_batches(model, X, device, batch_size=args.batch_size)
  598. try:
  599. auc = roc_auc_score(y, probs)
  600. except Exception:
  601. auc = float("nan")
  603. print("\n===== Threshold-free summary =====")
  604. print(f"AUROC: {auc:.4f}")
  606. dist_csv, dist_fig = summarize_prob_distribution_by_label(probs, fine, args.out_dir, "prob_distribution_by_label")
  607. bin_csv, bin_fig = summarize_binary_prob_distribution(probs, y, args.out_dir)
  609. print("[INFO] Sweeping thresholds...")
  610. rows = []
  611. for th in THRESH_CANDIDATES:
  612. row = compute_metrics_at_threshold(y, probs, fine, float(th))
  613. rows.append(row)
  615. metrics_csv, by_label_csv = save_threshold_tables(rows, args.out_dir)
  616. plot_threshold_curves(rows, args.out_dir)
  617. print_best_points(rows)
  619. print("\nSaved:")
  620. print(f" {metrics_csv}")
  621. print(f" {by_label_csv}")
  622. print(f" {dist_csv}")
  623. print(f" {bin_csv}")
  624. print(f" {dist_fig}")
  625. print(f" {bin_fig}")
  626. print(f" {mapping_preview_csv}")
  627. print(f" {os.path.join(args.out_dir, 'threshold_sens_spec_artf.png')}")
  628. print(f" {os.path.join(args.out_dir, 'threshold_roc_like.png')}")
  630. print("\n===== Quick view at selected thresholds =====")
  631. for target_th in [0.01, 0.02, 0.05, 0.10, 0.20, 0.30, 0.50]:
  632. cand = min(rows, key=lambda r: abs(r["threshold"] - target_th))
  633. print(
  634. f"th={cand['threshold']:.2f} | "
  635. f"Acc={cand['accuracy']*100:.2f}% | "
  636. f"Sens={cand['sensitivity']*100:.2f}% | "
  637. f"Spec={cand['specificity']*100:.2f}% | "
  638. f"F1={cand['f1']:.4f} | "
  639. f"ARTF={cand['artf_pos_rate']*100:.2f}% | "
  640. f"EYEM={cand['eyem_pos_rate']*100:.2f}% | "
  641. f"BCKG={cand['bckg_pos_rate']*100:.2f}%"
  642. )
  644. if X_aux is not None and len(X_aux) > 0:
  645. print("\n[INFO] Predicting auxiliary OOD labels (gped / pled)...")
  646. probs_aux = predict_batches(model, X_aux, device, batch_size=args.batch_size)
  648. aux_csv, aux_fig = summarize_prob_distribution_by_label(
  649. probs_aux, fine_aux, args.out_dir, "prob_distribution_aux_gped_pled"
  650. )
  651. print("\n===== Auxiliary OOD-label probability summary (not used in main binary metrics) =====")
  652. print(f" {aux_csv}")
  653. print(f" {aux_fig}")
  656. if __name__ == "__main__":
  657. main()

eval_tuev_external.py at commit 2ae9222, no license · at the source

Overview

Authors: Ying Wang1, Xuelian Zhao1, Xin Yin1
ORCID iDs: Xin Yin
  1. Zibo Central Hospital, 255020, Shandong, China
Institutions: Central Hospital of Zibo (China)
Journal: MethodsX, volume 16, article 103929
Dates: published online 25 April 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1016/j.mex.2026.103929 · PMID 42403954 · PMCID PMC13329098 · OpenAlex W7155612520
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: EEG (modality), epilepsy (population)
Methods: Connectivity, Statistics, Smoothing, state filtering, decompositions, Preprocessing, Spectral & time-frequency, Machine learning, Physiology & signal measures
Keywords: Scalp EEG, Seizure detection, Multi-channel fusion, Channel serialization, Liquid neural networks, Evidence accumulation, MCLF: Montage consistent CNN...Liquid Fusion for seizure detection
Topic: EEG and Brain-Computer Interfaces (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Citations: not cited yet (Europe PMC); 17 references in the paper

Abstract

Long-term scalp EEG monitoring yields hours of multi-channel recordings in which seizure-related patterns may appear only on a subset of derivations and can be obscured by transient artifacts. This work presents MCLF, a montage-consistent CNN–Liquid fusion method that implements cross-channel evidence integration as a state-based accumulation process within each epoch. Specifically, a shared 1D CNN encodes each channel into a common embedding space; embeddings are then arranged in a montage-consistent order and integrated by liquid state evolution to form an epoch-level representation for seizure scoring. A lightweight event-formation step converts the score sequence into clinically interpretable seizure events. Validation on the CHB-MIT dataset reports 100% event sensitivity with an FDR of 0.98/h and a mean latency of 2.33 s, while maintaining competitive segment-level performance relative to representative baselines. Key steps of the proposed method include:

Apply per-epoch DWT reconstruction (Db4, 5 levels) followed by z-score normalization to standardize inputs for long-term recordings.

Perform montage-consistent channel serialization and fuse the resulting channel stream via liquid state evolution for state-based evidence accumulation.

Form seizure events from epoch-level scores using MAF smoothing, thresholding, collar expansion, and event merging with validation-based parameter calibration.

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

Yinxin111/MCLF

License: none: the authors keep all their rights
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 2ae92225b4b25a44576847b4eaa365424fae3ef1, 12 April 2026
Languages: Python (15)
Size: 23 files, 15 scripts
Software Heritage: not archived
Found in: the resources table
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: PyTorch (12 files), NumPy (6 files), Matplotlib (3 files), MNE-Python (3 files), PyWavelets (1 file), scikit-learn (1 file), WFDB Python (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
16 files
At the source: github.com/Yinxin111/MCLF

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;
  • 15 scripts, each with its path and the digest of its content;
  • 7 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

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

Data

Datasets cited

Data availability

Data will be made available on request.

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

Recorded: type, language, journal, volume, pages, dates, 3 authors, 7 keywords, 9 references.

Cite

This paper

Wang, Y., Zhao, X., & Yin, X. (2026). MCLF: Montage consistent CNN-Liquid fusion for long-term scalp EEG seizure detection. MethodsX, 16, 103929. https://doi.org/10.1016/j.mex.2026.103929

BibTeX

@article{wang2026mclf,
author = {Wang, Ying and Zhao, Xuelian and Yin, Xin},
title = {{MCLF: Montage consistent CNN-Liquid fusion for long-term scalp EEG seizure detection}},
journal = {MethodsX},
year = {2026},
month = apr,
volume = {16},
pages = {103929},
publisher = {Elsevier},
issn = {2215-0161},
doi = {10.1016/j.mex.2026.103929},
url = {https://doi.org/10.1016/j.mex.2026.103929},
pmid = {42403954},
pmcid = {PMC13329098}
}

RIS

TY - JOUR
AU - Wang, Ying
AU - Zhao, Xuelian
AU - Yin, Xin
TI - MCLF: Montage consistent CNN-Liquid fusion for long-term scalp EEG seizure detection
T2 - MethodsX
J2 - MethodsX
PY - 2026
DA - 2026/04/25
VL - 16
SP - 103929
SN - 2215-0161
PB - Elsevier
DO - 10.1016/j.mex.2026.103929
UR - https://doi.org/10.1016/j.mex.2026.103929
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.mex.2026.103929",
"type": "article-journal",
"title": "MCLF: Montage consistent CNN-Liquid fusion for long-term scalp EEG seizure detection",
"container-title": "MethodsX",
"author": [
{
"family": "Wang",
"given": "Ying"
},
{
"family": "Zhao",
"given": "Xuelian"
},
{
"family": "Yin",
"given": "Xin"
}
],
"container-title-short": "MethodsX",
"volume": "16",
"page": "103929",
"DOI": "10.1016/j.mex.2026.103929",
"PMID": "42403954",
"PMCID": "PMC13329098",
"ISSN": "2215-0161",
"publisher": "Elsevier",
"URL": "https://doi.org/10.1016/j.mex.2026.103929",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
25
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1038/s41598-026-47627-y [code]
QuantumNeuroXAI: a quantum-inspired deep learning framework with explainability for brain signal analysis and neurological disorder detection.
Journal: Scientific reports
In common: MNE-Python, PyTorch, scikit-learn, 2 other tools, physionet.org/content/chbmit, EEG
[2] doi:10.1371/journal.pone.0352191 [code]
Bayesian Uncertainty-aware Deep Learning with noisy labels: Tackling annotation ambiguity in EEG seizure detection.
Journal: PloS one
In common: PyTorch, scikit-learn, Matplotlib, 1 other tool, physionet.org/content/chbmit, epilepsy, EEG
[3] doi:10.1038/s41746-026-02946-2 [code]
Fully-automated sleep staging for Parkinson's disease and isolated REM sleep behavior disorder.
Journal: NPJ digital medicine
In common: WFDB Python, MNE-Python, PyTorch, 3 other tools
[4] doi:10.1002/hbm.70628 [code]
EEG Biomarkers for Affective Disorders Diagnosis: An Evaluation and Validation Study.
Journal: Human brain mapping
In common: PyWavelets, MNE-Python, PyTorch, 3 other tools, EEG
[5] doi:10.1186/s13634-026-01330-2 [code]
Leednet: a lightweight network for event detection in EEG signals.
Journal: Journal on advances in signal processing
In common: PyWavelets, MNE-Python, PyTorch, 3 other tools, EEG
[6] doi:10.1016/j.isci.2026.117068 [code]
Directed graph neural networks with partial directed coherence for seizure prediction and epileptogenic network characterization.
Journal: iScience
In common: PyTorch, scikit-learn, NumPy, physionet.org/content/chbmit, epilepsy
[7] doi:10.1038/s41598-026-68506-6
Frequency-aware transformer networks for robust and generalizable EEG-based seizure detection.
Journal: Scientific reports
In common: physionet.org/content/chbmit, epilepsy, EEG, 1 reference
[8] doi:10.3390/brainsci16070680 [code]
ION-Sim: A Novel Open-Source Simulation Framework for Intraoperative Neurophysiological Monitoring.
Journal: Brain sciences
In common: PyWavelets, MNE-Python, PyTorch, 2 other tools, EEG
[9] doi:10.7554/elife.100605 [code]
Age-related changes in ‘cortical’ 1/f dynamics are linked to cardiac activity
Journal: n/a
In common: WFDB Python, MNE-Python, scikit-learn, 2 other tools
[10] doi:10.1371/journal.pone.0354510 [code]
Personalized adaptive virtual reality experience driven by electroencephalography-based pain recognition.
Journal: PloS one
In common: PyWavelets, MNE-Python, scikit-learn, 2 other tools, EEG

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.