OSCR

Structured multi-domain EEG descriptors with phase-based connectivity for lie and truth detection.

Code ↔ Paper

6 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 6 matches
  1. [1] § Method details › Feature extraction framework: structured multi-domain eeg descriptors with phase-based connectivity ↔ lie-truth-eeg-descriptor/run_liewaves_descriptor_pipeline.py, lines 126–161 · score 0.85 · power spectral density, 12–30 Hz, 8–12 Hz, 1–4 Hz, 4–8 Hz, Welch
  2. [2] § Method details ↔ lie-truth-eeg-descriptor/run_liewaves_descriptor_pipeline.py, lines 1–46 · score 0.75 · overlapping sliding window, multi domain descriptor, meta correlation, pipeline, segmentation, fold
  3. [3] § Method details › Algorithmic workflow of structured multi-domain eeg descriptors with phase-based connectivity ↔ lie-truth-eeg-descriptor/run_liewaves_descriptor_pipeline.py, lines 1–46 · score 0.65 · overlapping sliding window, Structured Multi Domain, EEG Descriptor, segmentation, preprocessing
  4. [4] § Method details › Algorithmic workflow of structured multi-domain eeg descriptors with phase-based connectivity ↔ lie-truth-eeg-descriptor/run_liewaves_descriptor_pipeline.py, lines 126–161 · score 0.64 · power spectral density, kurtosis, bands, Welch, Hjorth, Fractal
  5. [5] § Method details › Evaluation and testing scenario ↔ lie-truth-eeg-descriptor/run_liewaves_descriptor_pipeline.py, lines 462–546 · score 0.62 · F1 score, ROC, ACC, AUC, recall, predictions
  6. [6] § Method validation › Classification performance ↔ lie-truth-eeg-descriptor/run_liewaves_descriptor_pipeline.py, lines 387–421 · score 0.50 · Random Forest, RBF, kernel, configuration, XGB, RF

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 · 808 lines · 30 KB · no license · 6 matches

  1. """
  2. Structured Multi-Domain EEG Descriptor Pipeline for Lie and Truth Classification
  4. This script implements the preprocessing, window segmentation, feature extraction,
  5. classification, and evaluation pipeline used in the MethodsX manuscript.
  7. The implementation includes:
  8. 1. deterministic EEG preprocessing,
  9. 2. overlapping sliding-window segmentation,
  10. 3. structured multi-domain descriptor extraction,
  11. 4. fold-wise normalization,
  12. 5. window-level and grouped validation,
  13. 6. meta-correlation ablation analysis.
  15. The LieWaves dataset is not redistributed in this repository.
  16. Users should download the dataset from the official Mendeley Data repository.
  17. """
  19. import os, re, time, json
  20. import numpy as np
  21. import pandas as pd
  22. from itertools import combinations
  23. from collections import defaultdict
  25. from scipy.signal import welch, butter, filtfilt, iirnotch, hilbert
  26. from scipy.stats import skew, kurtosis, ttest_rel
  28. from sklearn.model_selection import StratifiedKFold, GroupKFold, LeaveOneGroupOut
  29. from sklearn.preprocessing import StandardScaler
  30. from sklearn.metrics import (
  31. accuracy_score, recall_score, f1_score, roc_auc_score,
  32. confusion_matrix, ConfusionMatrixDisplay
  33. )
  34. from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
  35. from sklearn.ensemble import RandomForestClassifier
  36. from sklearn.svm import SVC
  38. try:
  39. from xgboost import XGBClassifier
  40. HAS_XGB = True
  41. except Exception:
  42. HAS_XGB = False
  44. import matplotlib.pyplot as plt
  45. import warnings
  46. warnings.filterwarnings("ignore")
  48. # ========
  49. # CONFIG
  50. # ========
  51. DATA_DIR = "./data/LieWaves"
  52. RAW_DIR = os.path.join(DATA_DIR, "Raw")
  53. SUBJECT_STIMULI_XLSX = os.path.join(DATA_DIR, "Subject_Stimuli.xlsx")
  55. CHAN_ORDER = ["EEG.AF3", "EEG.T7", "EEG.Pz", "EEG.T8", "EEG.AF4"]
  56. SF = 128
  57. WINDOW_SIZE = 384
  58. STEP_SIZE = 16
  59. N_SPLITS = 5
  60. RANDOM_STATE = 42
  62. # Validation settings
  63. RUN_WINDOW_LEVEL_SKF = True
  64. RUN_SUBJECT_GROUPK = False
  65. RUN_SESSION_GROUPK = False
  66. RUN_LOSO = False
  67. RUN_NON_OVERLAP = False
  68. RUN_META_ABLATION = True
  70. # SVM is included in the main window-level evaluation.
  71. # It is disabled by default for optional grouped validation to reduce runtime.
  72. INCLUDE_SVM_IN_STRICT_VALIDATION = False
  73. INCLUDE_SVM_IN_WINDOW_LEVEL = True
  75. # Output
  76. OUT_DIR = "./results"
  77. FIG_DIR = os.path.join(OUT_DIR, "figures")
  78. TAB_DIR = os.path.join(OUT_DIR, "tables")
  79. os.makedirs(FIG_DIR, exist_ok=True)
  80. os.makedirs(TAB_DIR, exist_ok=True)
  82. # LDA plot options
  83. LDA_JITTER = 0.02
  84. LDA_POINT_SIZE = 10
  85. LDA_ALPHA = 0.75
  86. LDA_MAX_POINTS = 20000
  88. # ============================================================
  89. # Filtering functions
  90. # ============================================================
  91. def bandpass(x):
  92. b, a = butter(4, [0.5, 45], btype='bandpass', fs=SF)
  93. return filtfilt(b, a, x)
  95. def notch(x):
  96. b, a = iirnotch(50, 30, fs=SF)
  97. return filtfilt(b, a, x)
  99. def preprocess(arr):
  100. out = np.zeros_like(arr, dtype=np.float32)
  101. for ch in range(arr.shape[1]):
  102. out[:, ch] = bandpass(notch(arr[:, ch]))
  103. return out
  105. # ============================================================
  106. # Feature extraction functions
  107. # ============================================================
  108. def hjorth(x):
  109. dx = np.diff(x); ddx = np.diff(dx)
  110. v0, v1, v2 = np.var(x), np.var(dx), np.var(ddx)
  111. act = v0
  112. mob = np.sqrt(v1/v0) if v0 > 0 else 0
  113. comp = np.sqrt(v2/v1)/mob if (v1 > 0 and mob > 0) else 0
  114. return act, mob, comp
  116. def wpli(x, y):
  117. ax, ay = hilbert(x), hilbert(y)
  118. im = np.imag(ax * np.conj(ay))
  119. return float(np.abs(np.mean(im)) / (np.mean(np.abs(im)) + 1e-6))
  121. def fast_corr(a, b):
  122. am = a - a.mean()
  123. bm = b - b.mean()
  124. return float(np.dot(am, bm) / (np.std(a) * np.std(b) * len(a) + 1e-6))
  126. def extract_descriptor(window):
  127. C = window.shape[0]
  128. temporal, fractal, spectral = [], [], []
  130. for ch in range(C):
  131. x = (window[ch] - np.mean(window[ch])) / (np.std(window[ch]) + 1e-6)
  133. feats = [np.mean(x), np.std(x), skew(x), kurtosis(x)]
  134. feats += list(hjorth(x))
  135. temporal += feats
  137. N = len(x); L = np.sum(np.abs(np.diff(x)))
  138. fractal.append(float(np.log(N) / (np.log(N) + np.log(L/N) + 1e-6)))
  140. f, psd = welch(x, SF, nperseg=256)
  141. bands = [(1,4),(4,8),(8,12),(12,30)]
  142. abs_bp = np.array([np.sum(psd[(f>=b0) & (f<=b1)]) for b0,b1 in bands], dtype=float)
  143. rel_bp = abs_bp / (np.sum(abs_bp) + 1e-6)
  144. sent = -np.sum((psd/np.sum(psd)) * np.log(psd/np.sum(psd) + 1e-12))
  146. spectral += abs_bp.tolist() + rel_bp.tolist() + [float(sent)]
  148. spatial = []
  149. for i, j in combinations(range(C), 2):
  150. spatial.append(float(np.mean(window[i]) - np.mean(window[j])))
  151. spatial.append(wpli(window[i], window[j]))
  153. fTS = np.array(temporal + spatial, dtype=np.float32)
  154. fCorr = np.array([fast_corr(fTS, np.log1p(np.abs(fTS)))], dtype=np.float32)
  155. fF = np.array(fractal, dtype=np.float32)
  156. fSP = np.array(spectral, dtype=np.float32)
  158. # Feature order:
  159. # temporal + spatial + meta-correlation + fractal + spectral
  160. # 35 + 20 + 1 + 5 + 45 = 106 features.
  161. return np.concatenate([fTS, fCorr, fF, fSP]).astype(np.float32)
  163. # ============================================================
  164. # Feature group definitions
  165. # ============================================================
  166. def group_slices(n_channels=5):
  167. n_temporal = n_channels * 7
  168. n_pairs = n_channels * (n_channels - 1) // 2
  169. n_spatial = n_pairs * 2
  170. n_fTS = n_temporal + n_spatial
  171. n_fCorr = 1
  172. n_fF = n_channels
  173. n_fSP = n_channels * 9
  175. s_fTS = slice(0, n_fTS)
  176. s_fCorr = slice(s_fTS.stop, s_fTS.stop + n_fCorr)
  177. s_fF = slice(s_fCorr.stop, s_fCorr.stop + n_fF)
  178. s_fSP = slice(s_fF.stop, s_fF.stop + n_fSP)
  179. s_full = slice(0, s_fSP.stop)
  181. return {"fTS": s_fTS, "fCorr": s_fCorr, "fF": s_fF, "fSP": s_fSP, "full": s_full}
  183. SLICES = group_slices(n_channels=len(CHAN_ORDER))
  185. # ============================================================
  186. # FEATURE NAMES — ORIGINAL LOGIC KEPT
  187. # ============================================================
  188. def build_feature_names():
  189. names = []
  190. tnames = ["mean","std","skew","kurt","hjorth_act","hjorth_mob","hjorth_comp"]
  191. for ch in CHAN_ORDER:
  192. for tn in tnames:
  193. names.append(f"temporal_{ch}_{tn}")
  195. pairs = list(combinations(range(len(CHAN_ORDER)), 2))
  196. for (i,j) in pairs:
  197. names.append(f"spatial_asym_{CHAN_ORDER[i]}-{CHAN_ORDER[j]}")
  198. names.append(f"spatial_wpli_{CHAN_ORDER[i]}-{CHAN_ORDER[j]}")
  200. names.append("fCorr_corr(fTS,log1p(|fTS|))")
  202. for ch in CHAN_ORDER:
  203. names.append(f"fractal_{ch}")
  205. bnames = ["delta","theta","alpha","beta"]
  206. for ch in CHAN_ORDER:
  207. for bn in bnames:
  208. names.append(f"spectral_absbp_{ch}_{bn}")
  209. for bn in bnames:
  210. names.append(f"spectral_relbp_{ch}_{bn}")
  211. names.append(f"spectral_entropy_{ch}")
  213. return names
  215. FEAT_NAMES = build_feature_names()
  217. # ============================================================
  218. # Data loading and metadata construction
  219. # ============================================================
  220. def load_label_map():
  221. df = pd.read_excel(SUBJECT_STIMULI_XLSX)
  222. df.columns = [str(c).strip().upper() for c in df.columns]
  223. df = df[['SUBJECT','SESSION','LIE/TRUTH']]
  224. df['SUBJECT'] = df['SUBJECT'].astype(str).str.replace('S','', regex=False).astype(int)
  225. df['SESSION'] = df['SESSION'].astype(str).str.replace('S','', regex=False).astype(int)
  226. df['KEY'] = list(zip(df['SUBJECT'], df['SESSION']))
  227. label_map = dict(zip(df['KEY'], df['LIE/TRUTH']))
  228. print("Total labels loaded:", len(label_map))
  229. return label_map
  231. def parse_filename(f):
  232. m = re.match(r"S(\d+)S(\d+)\.csv", f)
  233. return (int(m.group(1)), int(m.group(2))) if m else None
  235. def sliding_window(data, step_size=STEP_SIZE):
  236. return [data[:, i:i+WINDOW_SIZE] for i in range(0, data.shape[1]-WINDOW_SIZE+1, step_size)]
  238. def load_data(step_size=STEP_SIZE):
  239. label_map = load_label_map()
  240. X, y = [], []
  241. subjects, sessions, file_groups = [], [], []
  242. filenames, window_indices = [], []
  244. for f in sorted(os.listdir(RAW_DIR)):
  245. key = parse_filename(f)
  246. if key is None or key not in label_map:
  247. continue
  249. subject_id, session_id = key
  250. df = pd.read_csv(os.path.join(RAW_DIR, f))[CHAN_ORDER]
  251. arr = preprocess(df.values).T # (C,T)
  253. windows = sliding_window(arr, step_size=step_size)
  254. for wi, w in enumerate(windows):
  255. X.append(extract_descriptor(w))
  256. y.append(int(label_map[key]))
  257. subjects.append(subject_id)
  258. sessions.append(session_id)
  259. file_groups.append(f"S{subject_id:02d}_Sess{session_id:02d}")
  260. filenames.append(f)
  261. window_indices.append(wi)
  263. X = np.array(X, dtype=np.float32)
  264. y = np.array(y, dtype=int)
  265. meta = pd.DataFrame({
  266. "subject": subjects,
  267. "session": sessions,
  268. "file_group": file_groups,
  269. "filename": filenames,
  270. "window_index": window_indices,
  271. "label": y
  272. })
  273. return X, y, meta
  275. # ============================================================
  276. # Plotting and result saving utilities
  277. # ============================================================
  278. def save_confusion_matrix(y_true, y_pred, title, outpath, labels=("Lie (0)", "Truth (1)")):
  279. cm = confusion_matrix(y_true, y_pred, labels=[0,1])
  280. cm_norm = cm.astype(float) / np.clip(cm.sum(axis=1, keepdims=True), 1, None)
  281. disp = ConfusionMatrixDisplay(confusion_matrix=cm_norm, display_labels=list(labels))
  282. disp.plot(cmap="Blues", colorbar=True)
  283. plt.title(title)
  284. plt.tight_layout()
  285. plt.savefig(outpath, dpi=300)
  286. plt.close()
  288. def paired_ttest_matrix(fold_metrics, metric_key, out_csv, out_png, title):
  289. model_names = list(fold_metrics.keys())
  290. n = len(model_names)
  291. pmat = np.ones((n, n), dtype=float)
  293. for i in range(n):
  294. for j in range(n):
  295. if i == j:
  296. pmat[i, j] = np.nan
  297. elif i < j:
  298. a = np.array(fold_metrics[model_names[i]][metric_key], dtype=float)
  299. b = np.array(fold_metrics[model_names[j]][metric_key], dtype=float)
  300. if len(a) == len(b) and len(a) > 1:
  301. p = ttest_rel(a, b).pvalue
  302. else:
  303. p = np.nan
  304. pmat[i, j] = p
  305. pmat[j, i] = p
  307. dfp = pd.DataFrame(pmat, index=model_names, columns=model_names)
  308. dfp.to_csv(out_csv, index=True)
  310. plt.figure()
  311. im = plt.imshow(pmat, aspect="auto")
  312. plt.colorbar(im)
  313. plt.xticks(range(n), model_names)
  314. plt.yticks(range(n), model_names)
  315. plt.title(title)
  317. for i in range(n):
  318. for j in range(n):
  319. txt = "-" if np.isnan(pmat[i, j]) else f"{pmat[i, j]:.3g}"
  320. plt.text(j, i, txt, ha="center", va="center")
  322. plt.tight_layout()
  323. plt.savefig(out_png, dpi=300)
  324. plt.close()
  326. def lda_plot_like_example(X, y, out_png,
  327. max_points=LDA_MAX_POINTS,
  328. jitter=LDA_JITTER,
  329. seed=RANDOM_STATE):
  330. rng = np.random.default_rng(seed)
  332. if (max_points is not None) and (X.shape[0] > max_points):
  333. idx = rng.choice(X.shape[0], size=max_points, replace=False)
  334. Xp = X[idx]
  335. yp = y[idx]
  336. else:
  337. Xp = X
  338. yp = y
  340. Xs = StandardScaler().fit_transform(Xp)
  342. lda = LinearDiscriminantAnalysis(n_components=1)
  343. z = lda.fit_transform(Xs, yp).ravel()
  345. y0 = (rng.random(np.sum(yp == 0)) - 0.5) * jitter
  346. y1 = (rng.random(np.sum(yp == 1)) - 0.5) * jitter
  348. plt.figure(figsize=(8, 4))
  349. plt.scatter(z[yp == 0], y0, s=LDA_POINT_SIZE, alpha=LDA_ALPHA, label="Lie (0)")
  350. plt.scatter(z[yp == 1], y1, s=LDA_POINT_SIZE, alpha=LDA_ALPHA, label="Truth (1)")
  351. plt.yticks([])
  352. plt.xlabel("LDA projection (LD1)")
  353. plt.title("LDA Separability View — Lie vs Truth")
  354. plt.legend()
  355. plt.tight_layout()
  356. plt.savefig(out_png, dpi=300)
  357. plt.close()
  359. def save_barh(values, names, title, out_png, topk=10):
  360. idx = np.argsort(values)[::-1][:topk]
  361. vals = values[idx][::-1]
  362. nms = [names[i] for i in idx][::-1]
  363. plt.figure(figsize=(8, 5))
  364. plt.barh(range(len(vals)), vals)
  365. plt.yticks(range(len(vals)), nms)
  366. plt.title(title)
  367. plt.tight_layout()
  368. plt.savefig(out_png, dpi=300)
  369. plt.close()
  371. def rf_importance_by_group(mean_imp, slices_dict, out_csv, out_png):
  372. rows = []
  373. for g in ["fTS", "fCorr", "fF", "fSP", "full"]:
  374. sl = slices_dict[g]
  375. rows.append((g, float(np.sum(mean_imp[sl]))))
  377. df = pd.DataFrame(rows, columns=["Group", "Total_importance"])
  378. df.to_csv(out_csv, index=False)
  380. plt.figure()
  381. plt.bar(df["Group"], df["Total_importance"])
  382. plt.title("RF Importance by Feature Group (Sum of Importances)")
  383. plt.tight_layout()
  384. plt.savefig(out_png, dpi=300)
  385. plt.close()
  387. # ============================================================
  388. # Classifier configuration
  389. # ============================================================
  390. def make_models(include_svm=True):
  391. models = {
  392. "RF": RandomForestClassifier(
  393. n_estimators=900,
  394. max_depth=None,
  395. min_samples_leaf=1,
  396. n_jobs=-1,
  397. random_state=RANDOM_STATE
  398. )
  399. }
  401. if HAS_XGB:
  402. models["XGB"] = XGBClassifier(
  403. n_estimators=1200,
  404. max_depth=8,
  405. learning_rate=0.015,
  406. subsample=0.85,
  407. colsample_bytree=0.85,
  408. reg_lambda=1,
  409. eval_metric="logloss",
  410. random_state=RANDOM_STATE
  411. )
  413. if include_svm:
  414. models["SVM"] = SVC(
  415. C=50,
  416. gamma="auto",
  417. kernel="rbf",
  418. probability=True,
  419. random_state=RANDOM_STATE
  420. )
  421. return models
  423. # ============================================================
  424. # FEATURE SETS FOR ABLATION
  425. # ============================================================
  426. def get_feature_sets(X):
  427. idx_full = np.arange(X.shape[1])
  428. idx_no_meta = np.setdiff1d(idx_full, np.arange(SLICES["fCorr"].start, SLICES["fCorr"].stop))
  429. feature_sets = {
  430. "full_106": idx_full,
  431. "without_meta_corr": idx_no_meta,
  432. }
  433. return feature_sets
  435. # ============================================================
  436. # OVERLAP / LEAKAGE DIAGNOSTICS
  437. # ============================================================
  438. def save_overlap_report(step_size, meta, out_json, out_csv):
  439. overlap_samples = WINDOW_SIZE - step_size
  440. overlap_percent = overlap_samples / WINDOW_SIZE * 100 if step_size < WINDOW_SIZE else 0.0
  441. report = {
  442. "window_size_samples": WINDOW_SIZE,
  443. "step_size_samples": step_size,
  444. "sampling_rate_hz": SF,
  445. "window_duration_seconds": WINDOW_SIZE / SF,
  446. "step_duration_seconds": step_size / SF,
  447. "overlap_samples": max(overlap_samples, 0),
  448. "overlap_percent_adjacent_windows": overlap_percent,
  449. "n_windows": int(len(meta)),
  450. "n_subjects": int(meta["subject"].nunique()),
  451. "n_file_groups": int(meta["file_group"].nunique()),
  452. "class_counts": {str(k): int(v) for k, v in meta["label"].value_counts().sort_index().items()}
  453. }
  454. with open(out_json, "w") as f:
  455. json.dump(report, f, indent=2)
  456. meta.groupby(["subject", "label"]).size().reset_index(name="n_windows").to_csv(out_csv, index=False)
  457. print("\n================ Overlap / Leakage Diagnostic ================")
  458. print(json.dumps(report, indent=2))
  459. print("==============================================================\n")
  460. return report
  462. # ============================================================
  463. # CV EVALUATOR — ADDED FOR REUSABILITY
  464. # ============================================================
  465. def evaluate_cv(X, y, cv, cv_name, out_prefix, groups=None, include_svm=True, feature_indices=None):
  466. if feature_indices is None:
  467. feature_indices = np.arange(X.shape[1])
  468. X_eval = X[:, feature_indices]
  470. models = make_models(include_svm=include_svm)
  471. fold_metrics = {m: defaultdict(list) for m in models}
  472. all_true = {m: [] for m in models}
  473. all_pred = {m: [] for m in models}
  474. rf_importances = []
  475. fold_rows = []
  477. if groups is None:
  478. split_iter = cv.split(X_eval, y)
  479. else:
  480. split_iter = cv.split(X_eval, y, groups=groups)
  482. for fold, (tr, te) in enumerate(split_iter, start=1):
  483. scaler = StandardScaler()
  484. Xtr = scaler.fit_transform(X_eval[tr])
  485. Xte = scaler.transform(X_eval[te])
  486. ytr, yte = y[tr], y[te]
  488. fold_group_info = ""
  489. if groups is not None:
  490. test_groups = sorted(set(np.array(groups)[te].tolist()))
  491. fold_group_info = ",".join(map(str, test_groups[:10]))
  492. if len(test_groups) > 10:
  493. fold_group_info += f",...(+{len(test_groups)-10})"
  495. for name, clf in models.items():
  496. t0 = time.perf_counter()
  497. clf.fit(Xtr, ytr)
  498. t1 = time.perf_counter()
  500. pred = clf.predict(Xte)
  501. if hasattr(clf, "predict_proba"):
  502. proba = clf.predict_proba(Xte)[:, 1]
  503. else:
  504. proba = pred.astype(float)
  505. t2 = time.perf_counter()
  507. acc = accuracy_score(yte, pred)
  508. rec = recall_score(yte, pred, average="binary", zero_division=0)
  509. f1 = f1_score(yte, pred, zero_division=0)
  510. try:
  511. auc = roc_auc_score(yte, proba)
  512. except Exception:
  513. auc = np.nan
  515. fold_metrics[name]["acc"].append(acc)
  516. fold_metrics[name]["recall"].append(rec)
  517. fold_metrics[name]["f1"].append(f1)
  518. fold_metrics[name]["auc"].append(auc)
  519. fold_metrics[name]["train_time"].append(t1 - t0)
  520. fold_metrics[name]["infer_time"].append(t2 - t1)
  522. all_true[name].extend(yte.tolist())
  523. all_pred[name].extend(pred.tolist())
  525. fold_rows.append({
  526. "cv_name": cv_name,
  527. "fold": fold,
  528. "model": name,
  529. "n_train": int(len(tr)),
  530. "n_test": int(len(te)),
  531. "test_groups": fold_group_info,
  532. "acc": acc,
  533. "recall": rec,
  534. "f1": f1,
  535. "auc": auc,
  536. "train_time": t1 - t0,
  537. "infer_time": t2 - t1
  538. })
  540. if name == "RF" and hasattr(clf, "feature_importances_"):
  541. # Importance corresponds to selected feature indices.
  542. imp_full = np.zeros(X.shape[1], dtype=float)
  543. imp_full[feature_indices] = clf.feature_importances_
  544. rf_importances.append(imp_full.copy())
  546. print(f"[{cv_name}] Fold {fold} done. Test size={len(te)}")
  548. # Summary
  549. summary_rows = []
  550. for name in models:
  551. acc = np.array(fold_metrics[name]["acc"], dtype=float)
  552. rec = np.array(fold_metrics[name]["recall"], dtype=float)
  553. f1 = np.array(fold_metrics[name]["f1"], dtype=float)
  554. auc = np.array(fold_metrics[name]["auc"], dtype=float)
  555. trt = np.array(fold_metrics[name]["train_time"], dtype=float)
  556. inf = np.array(fold_metrics[name]["infer_time"], dtype=float)
  558. summary_rows.append({
  559. "CV": cv_name,
  560. "Feature_Set": out_prefix,
  561. "Model": name,
  562. "ACC_mean(%)": float(np.nanmean(acc)*100),
  563. "ACC_std(%)": float(np.nanstd(acc)*100),
  564. "Recall_mean(%)": float(np.nanmean(rec)*100),
  565. "Recall_std(%)": float(np.nanstd(rec)*100),
  566. "F1_mean(%)": float(np.nanmean(f1)*100),
  567. "F1_std(%)": float(np.nanstd(f1)*100),
  568. "AUC_mean(%)": float(np.nanmean(auc)*100),
  569. "AUC_std(%)": float(np.nanstd(auc)*100),
  570. "Train_mean(s)": float(np.nanmean(trt)),
  571. "Train_std(s)": float(np.nanstd(trt)),
  572. "Infer_mean(s)": float(np.nanmean(inf)),
  573. "Infer_std(s)": float(np.nanstd(inf)),
  574. })
  576. df_summary = pd.DataFrame(summary_rows)
  577. df_folds = pd.DataFrame(fold_rows)
  578. df_summary.to_csv(os.path.join(TAB_DIR, f"summary_{out_prefix}_{cv_name}.csv"), index=False)
  579. df_folds.to_csv(os.path.join(TAB_DIR, f"fold_metrics_{out_prefix}_{cv_name}.csv"), index=False)
  581. print(f"\n================ Summary: {cv_name} | {out_prefix} ================")
  582. for r in summary_rows:
  583. print(f"\nModel: {r['Model']}")
  584. print(f"ACC : {r['ACC_mean(%)']:.2f}% ± {r['ACC_std(%)']:.2f}%")
  585. print(f"Recall: {r['Recall_mean(%)']:.2f}% ± {r['Recall_std(%)']:.2f}%")
  586. print(f"F1 : {r['F1_mean(%)']:.2f}% ± {r['F1_std(%)']:.2f}%")
  587. print(f"AUC : {r['AUC_mean(%)']:.2f}% ± {r['AUC_std(%)']:.2f}%")
  588. print(f"Train : {r['Train_mean(s)']:.4f}s ± {r['Train_std(s)']:.4f}s")
  589. print(f"Infer : {r['Infer_mean(s)']:.4f}s ± {r['Infer_std(s)']:.4f}s")
  590. print("==============================================================\n")
  592. # Confusion matrices
  593. for name in models:
  594. save_confusion_matrix(
  595. np.array(all_true[name]), np.array(all_pred[name]),
  596. title=f"LieWaves — {cv_name} Confusion ({name})",
  597. outpath=os.path.join(FIG_DIR, f"confusion_{out_prefix}_{cv_name}_{name}.png"),
  598. labels=("Lie (0)", "Truth (1)")
  599. )
  601. # Paired t-test only when at least 2 folds and comparable models
  602. try:
  603. paired_ttest_matrix(
  604. fold_metrics,
  605. metric_key="acc",
  606. out_csv=os.path.join(TAB_DIR, f"pvalues_acc_{out_prefix}_{cv_name}.csv"),
  607. out_png=os.path.join(FIG_DIR, f"pvalues_acc_{out_prefix}_{cv_name}.png"),
  608. title=f"Paired t-test p-values ({cv_name} ACC)"
  609. )
  610. except Exception as e:
  611. print(f"[WARN] Paired t-test skipped for {cv_name}: {e}")
  613. # RF feature importance
  614. if len(rf_importances) > 0:
  615. mean_imp = np.mean(np.vstack(rf_importances), axis=0)
  616. feat_names = FEAT_NAMES if len(FEAT_NAMES) == X.shape[1] else [f"f{i}" for i in range(X.shape[1])]
  617. df_fi = pd.DataFrame({"feature": feat_names, "importance": mean_imp})
  618. df_fi.sort_values("importance", ascending=False).to_csv(
  619. os.path.join(TAB_DIR, f"rf_feature_importance_all_{out_prefix}_{cv_name}.csv"),
  620. index=False
  621. )
  622. save_barh(
  623. mean_imp, feat_names,
  624. title=f"RF Feature Importance Top 10 — {cv_name}",
  625. out_png=os.path.join(FIG_DIR, f"rf_feature_importance_top10_{out_prefix}_{cv_name}.png"),
  626. topk=10
  627. )
  628. rf_importance_by_group(
  629. mean_imp, SLICES,
  630. out_csv=os.path.join(TAB_DIR, f"rf_importance_by_group_{out_prefix}_{cv_name}.csv"),
  631. out_png=os.path.join(FIG_DIR, f"rf_importance_by_group_{out_prefix}_{cv_name}.png")
  632. )
  634. return df_summary, df_folds
  636. # ============================================================
  637. # MAIN
  638. # ============================================================
  639. if __name__ == "__main__":
  640. # Save config for reproducibility / MethodsX code availability
  641. config = {
  642. "DATA_DIR": DATA_DIR,
  643. "RAW_DIR": RAW_DIR,
  644. "SUBJECT_STIMULI_XLSX": SUBJECT_STIMULI_XLSX,
  645. "CHAN_ORDER": CHAN_ORDER,
  646. "SF": SF,
  647. "WINDOW_SIZE": WINDOW_SIZE,
  648. "STEP_SIZE": STEP_SIZE,
  649. "N_SPLITS": N_SPLITS,
  650. "RANDOM_STATE": RANDOM_STATE,
  651. "RUN_WINDOW_LEVEL_SKF": RUN_WINDOW_LEVEL_SKF,
  652. "RUN_SUBJECT_GROUPK": RUN_SUBJECT_GROUPK,
  653. "RUN_SESSION_GROUPK": RUN_SESSION_GROUPK,
  654. "RUN_LOSO": RUN_LOSO,
  655. "RUN_NON_OVERLAP": RUN_NON_OVERLAP,
  656. "RUN_META_ABLATION": RUN_META_ABLATION,
  657. "INCLUDE_SVM_IN_STRICT_VALIDATION": INCLUDE_SVM_IN_STRICT_VALIDATION,
  658. "INCLUDE_SVM_IN_WINDOW_LEVEL": INCLUDE_SVM_IN_WINDOW_LEVEL,
  659. "HAS_XGB": HAS_XGB
  660. }
  661. with open(os.path.join(TAB_DIR, "run_config.json"), "w") as f:
  662. json.dump(config, f, indent=2)
  664. # 1) Load original overlapping-window dataset
  665. X, y, meta = load_data(step_size=STEP_SIZE)
  666. print("Total samples:", len(X))
  667. print("Dataset shape:", X.shape)
  668. print("Metadata shape:", meta.shape)
  669. meta.to_csv(os.path.join(TAB_DIR, "window_metadata_original_step16.csv"), index=False)
  671. if len(FEAT_NAMES) != X.shape[1]:
  672. print(f"[WARN] Feature name count {len(FEAT_NAMES)} != X features {X.shape[1]}. Using generic names.")
  673. FEAT_NAMES = [f"f{i}" for i in range(X.shape[1])]
  675. save_overlap_report(
  676. step_size=STEP_SIZE,
  677. meta=meta,
  678. out_json=os.path.join(TAB_DIR, "overlap_leakage_report_step16.json"),
  679. out_csv=os.path.join(TAB_DIR, "windows_per_subject_label_step16.csv")
  680. )
  682. # LDA plot for original full descriptor
  683. lda_plot_like_example(X, y, os.path.join(FIG_DIR, "lda_separability_original_step16.png"))
  685. # Save group definitions
  686. group_def = pd.DataFrame([
  687. {"Group": "fTS", "start": SLICES["fTS"].start, "stop": SLICES["fTS"].stop, "dim": SLICES["fTS"].stop - SLICES["fTS"].start},
  688. {"Group": "fCorr", "start": SLICES["fCorr"].start, "stop": SLICES["fCorr"].stop, "dim": SLICES["fCorr"].stop - SLICES["fCorr"].start},
  689. {"Group": "fF", "start": SLICES["fF"].start, "stop": SLICES["fF"].stop, "dim": SLICES["fF"].stop - SLICES["fF"].start},
  690. {"Group": "fSP", "start": SLICES["fSP"].start, "stop": SLICES["fSP"].stop, "dim": SLICES["fSP"].stop - SLICES["fSP"].start},
  691. {"Group": "full", "start": SLICES["full"].start, "stop": SLICES["full"].stop, "dim": SLICES["full"].stop - SLICES["full"].start},
  692. ])
  693. group_def.to_csv(os.path.join(TAB_DIR, "feature_group_slices.csv"), index=False)
  695. # 2) Define feature sets for full and meta-correlation ablation
  696. feature_sets = get_feature_sets(X) if RUN_META_ABLATION else {"full_106": np.arange(X.shape[1])}
  698. all_summaries = []
  700. # 3) Window-level StratifiedKFold evaluation
  701. if RUN_WINDOW_LEVEL_SKF:
  702. for fs_name, fs_idx in feature_sets.items():
  703. # Evaluate the full descriptor and the descriptor without meta-correlation.
  704. cv = StratifiedKFold(n_splits=N_SPLITS, shuffle=True, random_state=RANDOM_STATE)
  705. summary, _ = evaluate_cv(
  706. X, y,
  707. cv=cv,
  708. cv_name="window_stratified5fold",
  709. out_prefix=fs_name,
  710. groups=None,
  711. include_svm=INCLUDE_SVM_IN_WINDOW_LEVEL,
  712. feature_indices=fs_idx
  713. )
  714. all_summaries.append(summary)
  716. # 4) Optional subject-wise GroupKFold validation
  717. if RUN_SUBJECT_GROUPK:
  718. for fs_name, fs_idx in feature_sets.items():
  719. cv = GroupKFold(n_splits=N_SPLITS)
  720. summary, _ = evaluate_cv(
  721. X, y,
  722. cv=cv,
  723. cv_name="subject_group5fold",
  724. out_prefix=fs_name,
  725. groups=meta["subject"].values,
  726. include_svm=INCLUDE_SVM_IN_STRICT_VALIDATION,
  727. feature_indices=fs_idx
  728. )
  729. all_summaries.append(summary)
  731. # 5) Optional session/file-wise GroupKFold
  732. if RUN_SESSION_GROUPK:
  733. for fs_name, fs_idx in feature_sets.items():
  734. cv = GroupKFold(n_splits=N_SPLITS)
  735. summary, _ = evaluate_cv(
  736. X, y,
  737. cv=cv,
  738. cv_name="session_group5fold",
  739. out_prefix=fs_name,
  740. groups=meta["file_group"].values,
  741. include_svm=INCLUDE_SVM_IN_STRICT_VALIDATION,
  742. feature_indices=fs_idx
  743. )
  744. all_summaries.append(summary)
  746. # 6) Optional Leave-One-Subject-Out. This can be slow.
  747. if RUN_LOSO:
  748. for fs_name, fs_idx in feature_sets.items():
  749. cv = LeaveOneGroupOut()
  750. summary, _ = evaluate_cv(
  751. X, y,
  752. cv=cv,
  753. cv_name="LOSO_subject",
  754. out_prefix=fs_name,
  755. groups=meta["subject"].values,
  756. include_svm=INCLUDE_SVM_IN_STRICT_VALIDATION,
  757. feature_indices=fs_idx
  758. )
  759. all_summaries.append(summary)
  761. # 7) Optional non-overlapping windows sensitivity analysis
  762. if RUN_NON_OVERLAP:
  763. X_no, y_no, meta_no = load_data(step_size=WINDOW_SIZE)
  764. meta_no.to_csv(os.path.join(TAB_DIR, "window_metadata_nonoverlap_step384.csv"), index=False)
  765. save_overlap_report(
  766. step_size=WINDOW_SIZE,
  767. meta=meta_no,
  768. out_json=os.path.join(TAB_DIR, "overlap_leakage_report_step384.json"),
  769. out_csv=os.path.join(TAB_DIR, "windows_per_subject_label_step384.csv")
  770. )
  771. lda_plot_like_example(X_no, y_no, os.path.join(FIG_DIR, "lda_separability_nonoverlap_step384.png"))
  773. feature_sets_no = get_feature_sets(X_no) if RUN_META_ABLATION else {"full_106": np.arange(X_no.shape[1])}
  774. for fs_name, fs_idx in feature_sets_no.items():
  775. cv = StratifiedKFold(n_splits=N_SPLITS, shuffle=True, random_state=RANDOM_STATE)
  776. summary, _ = evaluate_cv(
  777. X_no, y_no,
  778. cv=cv,
  779. cv_name="nonoverlap_window_stratified5fold",
  780. out_prefix=fs_name,
  781. groups=None,
  782. include_svm=INCLUDE_SVM_IN_WINDOW_LEVEL,
  783. feature_indices=fs_idx
  784. )
  785. all_summaries.append(summary)
  787. cvg = GroupKFold(n_splits=N_SPLITS)
  788. summary, _ = evaluate_cv(
  789. X_no, y_no,
  790. cv=cvg,
  791. cv_name="nonoverlap_subject_group5fold",
  792. out_prefix=fs_name,
  793. groups=meta_no["subject"].values,
  794. include_svm=INCLUDE_SVM_IN_STRICT_VALIDATION,
  795. feature_indices=fs_idx
  796. )
  797. all_summaries.append(summary)
  799. # 8) Save combined summary
  800. if len(all_summaries) > 0:
  801. df_all = pd.concat(all_summaries, ignore_index=True)
  802. df_all.to_csv(os.path.join(TAB_DIR, "ALL_SUMMARY_COMBINED.csv"), index=False)
  803. print("\n================ ALL SUMMARY COMBINED ================")
  804. print(df_all[["CV", "Feature_Set", "Model", "ACC_mean(%)", "ACC_std(%)", "Recall_mean(%)", "F1_mean(%)", "AUC_mean(%)"]])
  805. print("======================================================\n")
  807. print(f"✅ All figures saved to: {FIG_DIR}")
  808. print(f"✅ All tables saved to: {TAB_DIR}")

run_liewaves_descriptor_pipeline.py at commit d4dec23, no license · at the source

Overview

Authors: Dwi Utari Surya1, Sholeh Hadi Pramono2, Panca Mudjirahardjo2, Muhammad Aziz Muslim2, Cries Avian2, Mahdin Rohmatillah2
ORCID iDs: Dwi Utari Surya
  1. Department of Creative and Digital Industry, Faculty of Vocational Studies, Universitas Brawijaya, 65145, Indonesia
  2. Department of Electrical Engineering, Faculty of Engineering, Universitas Brawijaya, Malang, 65145, Indonesia
Institutions: University of Brawijaya (Indonesia)
Journal: MethodsX, volume 17, article 104077
Dates: received 6 March 2026; accepted 27 July 2026; published online 28 July 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1016/j.mex.2026.104077 · PMID 42571525 · PMCID PMC13452325 · OpenAlex W7171544820
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: EEG (modality), methods / tools (subfield)
Methods: Spectral & time-frequency, Preprocessing, Statistics, Smoothing, state filtering, decompositions, Machine learning, Evoked potentials, Connectivity, Complexity, Physiology & signal measures
Keywords: EEG-based Lie and Truth detection, Multi-domain descriptors, Phase connectivity, Handcrafted EEG features
Journal subjects: Neuroscience
Topic: EEG and Brain-Computer Interfaces (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Citations: not cited yet (Europe PMC); 35 references in the paper

Abstract

Wearable EEG-based Lie and Truth detection requires structured descriptor engineering to achieve reproducible results and ensure method transparency. The existing approaches use loosely integrated features alongside hidden modeling methods, which create challenges for understanding their results and verifying research progress across different studies. The existing research gap requires the development of a deterministic descriptor framework to document wearable EEG systems.

The research presents the Structured Multi-Domain EEG Descriptor with Phase-Based Connectivity as a reproducible framework that uses five-channel wearable EEG signals to classify binary Lie-Truth. The method emphasizes coordinated descriptor organization and controlled evaluation, summarized as follows: • The structured integration of temporal statistics, fractal complexity, spectral power distributions, and phase-based connectivity within a unified descriptor representation augmented by meta-correlation modelling. • The processing framework provides detailed specifications for preprocessing, window-level segmentation, descriptor extraction, fold-wise normalization, classifier evaluation, and computational profiling. • A controlled evaluation strategy for examining statistical consistency, descriptor separability, domain-level feature contribution, and workstation-based computational feasibility. Validation on the publicly available LieWaves dataset demonstrates stable fold-wise behaviour and consistent classifier responses under controlled conditions.

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

dutarisurya/lie-truth-eeg-descriptor

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: d4dec2337ffb134a0783ce81b172b039ea48b890, 29 April 2026
Languages: Python (1)
Size: 4 files, 1 script
Software Heritage: not archived
Found in: the text
Holds: README, environment (lie-truth-eeg-descriptor/requirements.txt)
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: Matplotlib (1 file), NumPy (1 file), pandas (1 file), scikit-learn (1 file), SciPy (1 file), XGBoost (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
2 files
At the source: github.com/dutarisurya/lie-truth-eeg-descriptor

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

Tracing map

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

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 1 script, each with its path and the digest of its content;
  • 6 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

LieWaves data are available at Mendeley Data (https://doi.org/10.17632/5gzxb2bzs2.2). Code: https://github.com/dutarisurya/lie-truth-eeg-descriptor.

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, 6 authors, 4 keywords, 20 references.

Cite

This paper

Surya, D. U., Pramono, S. H., Mudjirahardjo, P., Muslim, M. A., Avian, C., & Rohmatillah, M. (2026). Structured multi-domain EEG descriptors with phase-based connectivity for lie and truth detection. MethodsX, 17, 104077. https://doi.org/10.1016/j.mex.2026.104077

BibTeX

@article{surya2026structured,
author = {Surya, Dwi Utari and Pramono, Sholeh Hadi and Mudjirahardjo, Panca and Muslim, Muhammad Aziz and Avian, Cries and Rohmatillah, Mahdin},
title = {{Structured multi-domain EEG descriptors with phase-based connectivity for lie and truth detection}},
journal = {MethodsX},
year = {2026},
month = jul,
volume = {17},
pages = {104077},
publisher = {Elsevier},
issn = {2215-0161},
doi = {10.1016/j.mex.2026.104077},
url = {https://doi.org/10.1016/j.mex.2026.104077},
pmid = {42571525},
pmcid = {PMC13452325}
}

RIS

TY - JOUR
AU - Surya, Dwi Utari
AU - Pramono, Sholeh Hadi
AU - Mudjirahardjo, Panca
AU - Muslim, Muhammad Aziz
AU - Avian, Cries
AU - Rohmatillah, Mahdin
TI - Structured multi-domain EEG descriptors with phase-based connectivity for lie and truth detection
T2 - MethodsX
J2 - MethodsX
PY - 2026
DA - 2026/07/28
VL - 17
SP - 104077
SN - 2215-0161
PB - Elsevier
DO - 10.1016/j.mex.2026.104077
UR - https://doi.org/10.1016/j.mex.2026.104077
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.mex.2026.104077",
"type": "article-journal",
"title": "Structured multi-domain EEG descriptors with phase-based connectivity for lie and truth detection",
"container-title": "MethodsX",
"author": [
{
"family": "Surya",
"given": "Dwi Utari"
},
{
"family": "Pramono",
"given": "Sholeh Hadi"
},
{
"family": "Mudjirahardjo",
"given": "Panca"
},
{
"family": "Muslim",
"given": "Muhammad Aziz"
},
{
"family": "Avian",
"given": "Cries"
},
{
"family": "Rohmatillah",
"given": "Mahdin"
}
],
"container-title-short": "MethodsX",
"volume": "17",
"page": "104077",
"DOI": "10.1016/j.mex.2026.104077",
"PMID": "42571525",
"PMCID": "PMC13452325",
"ISSN": "2215-0161",
"publisher": "Elsevier",
"URL": "https://doi.org/10.1016/j.mex.2026.104077",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
28
]
]
}
}

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.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: XGBoost, scikit-learn, pandas, 3 other tools, EEG, 1 reference
[2] doi:10.3390/s26134045
Brain Signal for Secure EEG Biometric Authentication: A Comprehensive Survey.
Journal: Sensors (Basel, Switzerland)
In common: methods / tools, EEG, 4 references
[3] doi:10.7554/elife.110588 [code]
Opening the black box toward a modular approach to spike sorting.
Journal: eLife
In common: XGBoost, scikit-learn, pandas, 3 other tools, methods / tools
[4] doi:10.1126/sciadv.aed3650 [code]
Truthful visualizations for mass spectrometry imaging enable high-spatial-resolution interactive &lt;i&gt;m/z&lt;/i&gt; mapping and exploration.
Journal: Science advances
In common: XGBoost, scikit-learn, pandas, 3 other tools, methods / tools
[5] doi:10.1186/s13059-026-04125-8 [code]
MLMarker: a machine learning framework for tissue inference and biomarker discovery.
Journal: Genome biology
In common: XGBoost, scikit-learn, pandas, 3 other tools, methods / tools
[6] doi:10.1038/s41586-026-10658-6 [code]
An AI system to help scientists write expert-level empirical software.
Journal: Nature
In common: XGBoost, scikit-learn, pandas, 3 other tools, methods / tools
[7] doi:10.3390/s26175327 [code]
Subject Identity Confounds qEEG Emotion Recognition on DEAP and DREAMER.
Journal: Sensors (Basel, Switzerland)
In common: XGBoost, scikit-learn, pandas, 3 other tools, EEG
[8] doi:10.1007/s10548-026-01238-y [code]
Topographic Reorganization of EEG Complexity During Visual Mental Imagery: Insights from Lempel-Ziv Complexity in High-Density EEG.
Journal: Brain topography
In common: XGBoost, scikit-learn, pandas, 3 other tools, EEG
[9] doi:10.3389/fnhum.2026.1869918 [code]
Single-subject auditory ERP-BCI performance enhancement in ALS via an AI coding assistant prompt.
Journal: Frontiers in human neuroscience
In common: XGBoost, scikit-learn, pandas, 3 other tools, EEG
[10] doi:10.1093/brain/awaf412 [code]
Multimodal multicentre investigation of diagnostic and prognostic markers in disorders of consciousness.
Journal: Brain : a journal of neurology
In common: XGBoost, scikit-learn, pandas, 3 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.