OSCR

PhysioMotion Artifact: A task-driven EEG dataset with point-wise motion artifact annotations.

Code ↔ Paper

13 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 13 matches
  1. [1] § Methods › Preprocessing and Annotations ↔ preprocess.py, lines 20–63 · score 0.87 · bandpass filter, notch filter, 0.5–150 Hz, Bipolar referencing, bipolar montages, preprocessed
  2. [2] § Usage Notes ↔ classification/model_M.py, lines 4–63 · score 0.81 · NumPy, PyTorch, EEG artifact classification, GPUtil, Python, Hyperopt
  3. [3] § Technical Validation › Model Input ↔ classification/model_M.py, lines 4–63 · score 0.78 · GroupKFold, inner folds, outer folds, nested, tuned, hyperparameters
  4. [4] § Technical Validation › Results ↔ classification/model_B.py, lines 468–490 · score 0.76 · standard classification metrics, F1 score, confusion matrices, Precision, Recall, binary
  5. [5] § Technical Validation › Results ↔ classification/model_M.py, lines 70–123 · score 0.75 · swallow_eyebrow, tongue_eyebrow, class weighted, motion, chew, training
  6. [6] § Technical Validation › Model Input ↔ classification/model_B.py, lines 4–58 · score 0.70 · GroupKFold, inner folds, nested, tuned, hyperparameters, outer
  7. [7] § Technical Validation › Results ↔ classification/model_M.py, lines 457–466 · score 0.64 · F1 score, confusion matrices, multi class, metrics, classification, model
  8. [8] § Technical Validation › Model Architectures ↔ classification/model_B.py, lines 637–711 · score 0.62 · cross entropy loss, class weighted, optimized, training, model
  9. [9] § Technical Validation › Model Architectures ↔ classification/model_B.py, lines 637–711 · score 0.59 · cross entropy loss, class weighted, optimized, Model
  10. [10] § Technical Validation › Model Architectures ↔ classification/model_B.py, lines 299–358 · score 0.55 · Transformer encoders, CNN Transformer, layers, model, classifiers
  11. [11] § Technical Validation › Model Architectures ↔ classification/model_M.py, lines 283–335 · score 0.55 · Transformer encoders, CNN Transformer, layers, model, classifiers
  12. [12] § Technical Validation › Hyperparameter Optimization ↔ classification/model_B.py, lines 754–834 · score 0.54 · weight decay, Transformer layers, batch, CNN, Optimization
  13. [13] § Data Records › Preprocessed Data ↔ preprocess.py, lines 20–63 · score 0.51 · BIDS format, MNE, preprocessing, raw, EEG

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 · 873 lines · 31 KB · MIT · 6 matches

  1. #!/usr/bin/env python3
  2. # -*- coding: utf-8 -*-
  4. """
  5. Nested subject-independent GroupKFold training with Hyperopt for EEG artifact binary classification.
  7. Key features
  8. - Subject-level nested CV (outer = evaluation, inner = hyperparameter tuning)
  9. - Hyperopt (TPE) tuning on inner-fold mean validation loss
  10. - Robust CUDA OOM handling (a trial that OOMs is assigned a very bad loss and skipped)
  11. - Detailed logging to both console and a log file
  13. Notes
  14. - This script assumes each .pkl file contains a list of dicts, each dict includes:
  15. - "eeg_data": array-like shaped (C, T) (e.g., 34 x 375)
  16. - "artifact_types": list[str], e.g. ["close_base"] or ["blink", ...]
  17. - Labels are mapped to a binary task:
  18. - ["close_base"] -> "close_base"
  19. - otherwise -> "artifact"
  20. """
  22. import os
  23. import re
  24. import sys
  25. import math
  26. import time
  27. import pickle
  28. import random
  29. import logging
  30. import warnings
  31. from dataclasses import dataclass
  32. from collections import Counter, defaultdict
  33. from typing import Dict, List, Tuple
  35. import numpy as np
  37. import torch
  38. import torch.nn as nn
  39. import torch.optim as optim
  40. from torch.utils.data import Dataset, DataLoader, Subset
  42. from sklearn.model_selection import GroupKFold
  43. from sklearn.metrics import (
  44. classification_report,
  45. confusion_matrix,
  46. accuracy_score,
  47. balanced_accuracy_score,
  48. f1_score,
  49. precision_score,
  50. recall_score,
  51. )
  53. from hyperopt import fmin, tpe, hp, Trials, STATUS_OK
  55. try:
  56. import GPUtil
  57. except Exception:
  58. GPUtil = None
  60. # -------------------------
  61. # Configuration
  62. # -------------------------
  64. @dataclass
  65. class Config:
  66. # Data
  67. data_dir: str = "/home/mnt_disk1/Motion_Artifact_han1/Slidingwindow"
  68. top2_labels: Tuple[str, str] = ("close_base", "artifact")
  70. # Nested CV
  71. outer_k: int = 5
  72. inner_k: int = 3
  73. max_evals: int = 30
  74. seed: int = 42
  76. # Training
  77. final_num_epochs: int = 15
  78. final_patience: int = 3
  79. inner_num_epochs: int = 10
  80. inner_patience: int = 2
  82. # DataLoader
  83. num_workers: int = 2
  84. pin_memory: bool = True
  86. # Logging
  87. log_filename: str = "nested_groupkfold_verbose_log.txt"
  88. log_every_epoch: bool = True
  89. log_inner_fold_detail: bool = True
  90. log_trial_params: bool = True
  91. show_tqdm: bool = False # keep False for cleaner logs
  93. # GPU selection / OOM safety
  94. min_free_mb: int = 6000
  95. oom_bad_loss: float = 1e9
  97. # Hyperopt search space (OOM-safer default)
  98. # (You can widen it, but OOM risk increases.)
  99. batch_size_choices: Tuple[int, ...] = (64, 128)
  100. transformer_layers_choices: Tuple[int, ...] = (1, 2)
  101. transformer_nhead_choices: Tuple[int, ...] = (2, 4, 8)
  102. num_conv_blocks_choices: Tuple[int, ...] = (3, 4, 5)
  104. # Class-weight scaling search ranges
  105. cw0_low: float = 0.5
  106. cw0_high: float = 0.7
  107. cw1_low: float = 1.1
  108. cw1_high: float = 1.4
  111. CFG = Config()
  113. warnings.filterwarnings("ignore")
  116. # -------------------------
  117. # Logging utilities
  118. # -------------------------
  120. def setup_logger(log_filename: str) -> logging.Logger:
  121. logger = logging.getLogger("nested_cv")
  122. logger.setLevel(logging.INFO)
  123. logger.handlers.clear()
  125. fmt = logging.Formatter("%(asctime)s [%(levelname)s] %(message)s")
  127. fh = logging.FileHandler(log_filename, mode="w")
  128. fh.setFormatter(fmt)
  129. logger.addHandler(fh)
  131. sh = logging.StreamHandler(sys.stdout)
  132. sh.setFormatter(fmt)
  133. logger.addHandler(sh)
  135. return logger
  138. logger = setup_logger(CFG.log_filename)
  141. # -------------------------
  142. # Reproducibility
  143. # -------------------------
  145. def set_seed(seed: int) -> None:
  146. random.seed(seed)
  147. np.random.seed(seed)
  148. torch.manual_seed(seed)
  149. torch.cuda.manual_seed_all(seed)
  150. # Determinism (may reduce throughput)
  151. torch.backends.cudnn.deterministic = True
  152. torch.backends.cudnn.benchmark = False
  155. # -------------------------
  156. # GPU selection & cleanup
  157. # -------------------------
  159. def select_free_gpu(min_free_mb: int = 6000) -> torch.device:
  160. """
  161. Select the GPU with the largest free memory.
  162. If free memory is below threshold, fall back to CPU (safer for long tuning runs).
  163. """
  164. if (GPUtil is None) or (not torch.cuda.is_available()):
  165. logger.info("GPUtil not available or CUDA not available; using CPU.")
  166. return torch.device("cpu")
  168. gpus = GPUtil.getGPUs()
  169. if len(gpus) == 0:
  170. logger.info("No GPUs detected by GPUtil; using CPU.")
  171. return torch.device("cpu")
  173. best = max(gpus, key=lambda g: g.memoryFree)
  174. logger.info("GPU candidates: " + " | ".join([f"id={g.id}, free={g.memoryFree:.0f}MB" for g in gpus]))
  175. logger.info(f"Selected GPU: id={best.id} name={best.name}, free={best.memoryFree:.0f}MB")
  177. if best.memoryFree < min_free_mb:
  178. logger.warning(
  179. f"Best GPU free memory {best.memoryFree:.0f}MB < {min_free_mb}MB. "
  180. f"Falling back to CPU to reduce OOM risk. (You may lower min_free_mb to force GPU.)"
  181. )
  182. return torch.device("cpu")
  184. return torch.device(f"cuda:{best.id}")
  187. def cleanup_cuda() -> None:
  188. """Best-effort CUDA cache cleanup."""
  189. if torch.cuda.is_available():
  190. torch.cuda.empty_cache()
  191. try:
  192. torch.cuda.ipc_collect()
  193. except Exception:
  194. pass
  197. # -------------------------
  198. # Data loading
  199. # -------------------------
  201. SUBJECT_RE = re.compile(r"(sub\d+)_run\d+\.pkl$", re.IGNORECASE)
  204. def parse_subject_id(filename: str) -> str:
  205. """
  206. Parse subject id from filename like:
  207. sub1_run01.pkl -> "sub1"
  208. """
  209. m = SUBJECT_RE.search(filename)
  210. if not m:
  211. raise ValueError(
  212. f"Cannot parse subject_id from filename: {filename}. Expected pattern like sub1_run01.pkl"
  213. )
  214. return m.group(1).lower()
  217. def load_all_samples_with_subject(data_dir: str) -> List[dict]:
  218. """
  219. Load all samples from all .pkl files under data_dir.
  220. Adds 'subject_id' into each sample dict.
  221. """
  222. if not os.path.isdir(data_dir):
  223. raise FileNotFoundError(f"DATA_DIR not found: {data_dir}")
  225. pkl_files = sorted([f for f in os.listdir(data_dir) if f.endswith(".pkl")])
  226. if len(pkl_files) == 0:
  227. raise FileNotFoundError(f"No .pkl files found in {data_dir}")
  229. samples: List[dict] = []
  230. for fname in pkl_files:
  231. subject_id = parse_subject_id(fname)
  232. path = os.path.join(data_dir, fname)
  233. with open(path, "rb") as f:
  234. arr = pickle.load(f)
  236. # arr is expected to be list[dict]
  237. for s in arr:
  238. if isinstance(s, dict) and ("eeg_data" in s) and ("artifact_types" in s):
  239. d = dict(s)
  240. d["subject_id"] = subject_id
  241. samples.append(d)
  243. return samples
  246. # -------------------------
  247. # Dataset
  248. # -------------------------
  250. class EEGArtifactDataset(Dataset):
  251. """
  252. Binary dataset:
  253. label = "close_base" if artifact_types == ["close_base"] else "artifact"
  254. """
  256. def __init__(self, samples: List[dict], label_to_idx: Dict[str, int], scale: float = 1e6):
  257. super().__init__()
  258. self.label_to_idx = label_to_idx
  259. self.scale = float(scale)
  261. filtered = []
  262. for s in samples:
  263. if ("eeg_data" not in s) or ("artifact_types" not in s) or ("subject_id" not in s):
  264. continue
  266. label = "close_base" if s["artifact_types"] == ["close_base"] else "artifact"
  267. if label not in label_to_idx:
  268. continue
  270. d = dict(s)
  271. d["label"] = label
  272. filtered.append(d)
  274. self.samples = filtered
  276. logger.info(f"Filtered dataset size: {len(self.samples)}")
  277. label_counter = Counter([s["label"] for s in self.samples])
  278. subj_counter = Counter([s["subject_id"] for s in self.samples])
  279. logger.info(f"Label distribution: {label_counter}")
  280. logger.info(
  281. f"Num subjects: {len(subj_counter)} | "
  282. f"subject sample range: min={min(subj_counter.values())}, max={max(subj_counter.values())}"
  283. )
  285. def __len__(self) -> int:
  286. return len(self.samples)
  288. def __getitem__(self, idx: int):
  289. s = self.samples[idx]
  290. x = np.asarray(s["eeg_data"], dtype=np.float32) * self.scale # scale to microvolts
  291. y = self.label_to_idx[s["label"]]
  292. return torch.tensor(x, dtype=torch.float32), torch.tensor(y, dtype=torch.long)
  295. # -------------------------
  296. # Model
  297. # -------------------------
  299. class CNNTransformerModel(nn.Module):
  300. """
  301. CNN + Transformer encoder baseline.
  302. Input: (B, C, T) -> treated as (B, 1, C, T) to use 2D conv.
  303. """
  305. def __init__(
  306. self,
  307. num_classes: int = 2,
  308. cnn_filters: List[int] = None,
  309. transformer_nhead: int = 8,
  310. transformer_ff: int = 1024,
  311. transformer_layers: int = 1,
  312. dropout_p: float = 0.5,
  313. ):
  314. super().__init__()
  315. if cnn_filters is None:
  316. cnn_filters = [8, 16, 32, 64, 128]
  318. convs = []
  319. in_ch = 1
  320. for out_ch in cnn_filters:
  321. convs.append(
  322. nn.Sequential(
  323. nn.Conv2d(in_ch, out_ch, kernel_size=3, padding=1),
  324. nn.BatchNorm2d(out_ch),
  325. nn.ReLU(),
  326. nn.MaxPool2d(kernel_size=2, stride=2),
  327. )
  328. )
  329. in_ch = out_ch
  330. self.cnn = nn.Sequential(*convs)
  332. enc_layer = nn.TransformerEncoderLayer(
  333. d_model=cnn_filters[-1],
  334. nhead=transformer_nhead,
  335. dim_feedforward=transformer_ff,
  336. dropout=0.1,
  337. activation="relu",
  338. batch_first=True,
  339. )
  340. self.transformer = nn.TransformerEncoder(enc_layer, num_layers=transformer_layers)
  342. self.global_pool = nn.AdaptiveAvgPool1d(1)
  343. self.fc1 = nn.Linear(cnn_filters[-1], 100)
  344. self.fc2 = nn.Linear(100, 100)
  345. self.dropout = nn.Dropout(p=dropout_p)
  346. self.out = nn.Linear(100, num_classes)
  348. def forward(self, x: torch.Tensor) -> torch.Tensor:
  349. x = x.unsqueeze(1) # (B,1,C,T)
  350. x = self.cnn(x) # (B,Ch,H,W)
  351. x = x.flatten(2).transpose(1, 2) # (B,seq,Ch)
  352. x = self.transformer(x) # (B,seq,Ch)
  353. x = x.transpose(1, 2) # (B,Ch,seq)
  354. x = self.global_pool(x).squeeze(-1) # (B,Ch)
  355. x = torch.relu(self.fc1(x))
  356. x = torch.relu(self.fc2(x))
  357. x = self.dropout(x)
  358. return self.out(x)
  361. # -------------------------
  362. # Training / evaluation
  363. # -------------------------
  365. def compute_class_weights_from_indices(
  366. dataset: EEGArtifactDataset,
  367. indices: np.ndarray,
  368. label_to_idx: Dict[str, int]
  369. ) -> np.ndarray:
  370. """Compute inverse-frequency weights from a subset of indices."""
  371. counts = np.zeros(len(label_to_idx), dtype=np.float64)
  372. for i in indices:
  373. lbl = dataset.samples[int(i)]["label"]
  374. counts[label_to_idx[lbl]] += 1.0
  375. counts = np.maximum(counts, 1.0)
  376. total = float(counts.sum())
  377. weights = total / counts
  378. return weights.astype(np.float32)
  381. def train_one_run(
  382. model: nn.Module,
  383. criterion: nn.Module,
  384. optimizer: optim.Optimizer,
  385. train_loader: DataLoader,
  386. val_loader: DataLoader,
  387. device: torch.device,
  388. num_epochs: int,
  389. patience: int,
  390. run_name: str,
  391. log_every_epoch: bool,
  392. ) -> Tuple[float, float]:
  393. """
  394. Train with early stopping on validation loss.
  395. Returns: (best_val_loss, best_val_acc_at_end_epoch)
  396. """
  397. best_val_loss = float("inf")
  398. epochs_wo_improve = 0
  399. best_state = None
  400. best_val_acc = 0.0
  402. for epoch in range(1, num_epochs + 1):
  403. model.train()
  404. train_loss_sum = 0.0
  405. train_correct = 0
  406. train_n = 0
  408. for x, y in train_loader:
  409. x, y = x.to(device), y.to(device)
  410. optimizer.zero_grad(set_to_none=True)
  411. logits = model(x)
  412. loss = criterion(logits, y)
  413. loss.backward()
  414. optimizer.step()
  416. bs = x.size(0)
  417. train_loss_sum += float(loss.item()) * bs
  418. train_correct += int((logits.argmax(1) == y).sum().item())
  419. train_n += bs
  421. avg_train_loss = train_loss_sum / max(1, train_n)
  422. train_acc = train_correct / max(1, train_n)
  424. model.eval()
  425. val_loss_sum = 0.0
  426. val_correct = 0
  427. val_n = 0
  428. with torch.no_grad():
  429. for x, y in val_loader:
  430. x, y = x.to(device), y.to(device)
  431. logits = model(x)
  432. loss = criterion(logits, y)
  434. bs = x.size(0)
  435. val_loss_sum += float(loss.item()) * bs
  436. val_correct += int((logits.argmax(1) == y).sum().item())
  437. val_n += bs
  439. avg_val_loss = val_loss_sum / max(1, val_n)
  440. val_acc = val_correct / max(1, val_n)
  442. if log_every_epoch:
  443. logger.info(
  444. f"{run_name} | Epoch {epoch}/{num_epochs} "
  445. f"| train_loss={avg_train_loss:.4f}, train_acc={train_acc:.4f} "
  446. f"| val_loss={avg_val_loss:.4f}, val_acc={val_acc:.4f}"
  447. )
  449. if avg_val_loss < best_val_loss:
  450. best_val_loss = avg_val_loss
  451. best_val_acc = val_acc
  452. epochs_wo_improve = 0
  453. # Save CPU copy for safety
  454. best_state = {k: v.detach().cpu().clone() for k, v in model.state_dict().items()}
  455. else:
  456. epochs_wo_improve += 1
  457. if epochs_wo_improve >= patience:
  458. if log_every_epoch:
  459. logger.info(f"{run_name} | Early stopping at epoch {epoch}.")
  460. break
  462. if best_state is not None:
  463. model.load_state_dict(best_state)
  465. return float(best_val_loss), float(best_val_acc)
  468. def evaluate_model(model: nn.Module, loader: DataLoader, device: torch.device, labels: List[str]) -> Dict:
  469. """Evaluate on loader and return standard classification metrics + confusion matrix."""
  470. model.eval()
  471. preds, trues = [], []
  472. with torch.no_grad():
  473. for x, y in loader:
  474. x = x.to(device)
  475. logits = model(x)
  476. preds.extend(logits.argmax(1).cpu().numpy().tolist())
  477. trues.extend(y.numpy().tolist())
  479. y_true = np.array(trues, dtype=np.int64)
  480. y_pred = np.array(preds, dtype=np.int64)
  482. return {
  483. "acc": accuracy_score(y_true, y_pred),
  484. "bacc": balanced_accuracy_score(y_true, y_pred),
  485. "f1": f1_score(y_true, y_pred, average="binary"),
  486. "precision": precision_score(y_true, y_pred, average="binary", zero_division=0),
  487. "recall": recall_score(y_true, y_pred, average="binary", zero_division=0),
  488. "cm": confusion_matrix(y_true, y_pred),
  489. "report": classification_report(y_true, y_pred, target_names=labels, zero_division=0),
  490. }
  493. # -------------------------
  494. # Summary stats (mean/std/95% CI)
  495. # -------------------------
  497. def t_critical_975(df: int) -> float:
  498. """
  499. Two-sided 95% CI critical t value (0.975 quantile).
  500. For df > 30, use normal approximation 1.96.
  501. """
  502. table = {
  503. 1: 12.706, 2: 4.303, 3: 3.182, 4: 2.776, 5: 2.571,
  504. 6: 2.447, 7: 2.365, 8: 2.306, 9: 2.262, 10: 2.228,
  505. 11: 2.201, 12: 2.179, 13: 2.160, 14: 2.145, 15: 2.131,
  506. 16: 2.120, 17: 2.110, 18: 2.101, 19: 2.093, 20: 2.086,
  507. 21: 2.080, 22: 2.074, 23: 2.069, 24: 2.064, 25: 2.060,
  508. 26: 2.056, 27: 2.052, 28: 2.048, 29: 2.045, 30: 2.042
  509. }
  510. if df <= 0:
  511. return float("nan")
  512. return float(table.get(df, 1.96))
  515. def mean_std_ci(values: List[float]) -> Tuple[float, float, Tuple[float, float]]:
  516. v = np.asarray(values, dtype=np.float64)
  517. mean = float(v.mean())
  518. std = float(v.std(ddof=1)) if len(v) > 1 else 0.0
  519. n = len(v)
  520. if n > 1:
  521. tcrit = t_critical_975(n - 1)
  522. half = tcrit * std / math.sqrt(n)
  523. else:
  524. half = 0.0
  525. return mean, std, (mean - half, mean + half)
  528. # -------------------------
  529. # Hyperopt search space
  530. # -------------------------
  532. def build_search_space(cfg: Config) -> Dict:
  533. """
  534. Hyperopt search space. Keep it relatively safe to avoid OOM.
  535. """
  536. return {
  537. "lr": hp.loguniform("lr", np.log(1e-5), np.log(1e-3)),
  538. "batch_size": hp.choice("batch_size", list(cfg.batch_size_choices)),
  539. "transformer_layers": hp.choice("transformer_layers", list(cfg.transformer_layers_choices)),
  540. "transformer_nhead": hp.choice("transformer_nhead", list(cfg.transformer_nhead_choices)),
  541. "num_conv_blocks": hp.choice("num_conv_blocks", list(cfg.num_conv_blocks_choices)),
  542. "weight_decay": hp.loguniform("weight_decay", np.log(1e-6), np.log(1e-3)),
  543. "class_weight_scaling_0": hp.uniform("class_weight_scaling_0", cfg.cw0_low, cfg.cw0_high),
  544. "class_weight_scaling_1": hp.uniform("class_weight_scaling_1", cfg.cw1_low, cfg.cw1_high),
  545. }
  548. def decode_best_params(best: Dict, cfg: Config) -> Dict:
  549. """Decode hp.choice indices into actual values."""
  550. bs_choices = list(cfg.batch_size_choices)
  551. lyr_choices = list(cfg.transformer_layers_choices)
  552. head_choices = list(cfg.transformer_nhead_choices)
  553. conv_choices = list(cfg.num_conv_blocks_choices)
  555. return {
  556. "lr": float(best["lr"]),
  557. "batch_size": int(bs_choices[int(best["batch_size"])]),
  558. "transformer_layers": int(lyr_choices[int(best["transformer_layers"])]),
  559. "transformer_nhead": int(head_choices[int(best["transformer_nhead"])]),
  560. "num_conv_blocks": int(conv_choices[int(best["num_conv_blocks"])]),
  561. "weight_decay": float(best["weight_decay"]),
  562. "class_weight_scaling": [float(best["class_weight_scaling_0"]), float(best["class_weight_scaling_1"])],
  563. }
  566. # -------------------------
  567. # Main: nested CV
  568. # -------------------------
  570. def main(cfg: Config) -> None:
  571. set_seed(cfg.seed)
  572. device = select_free_gpu(min_free_mb=cfg.min_free_mb)
  574. logger.info("########################")
  575. logger.info("Nested GroupKFold subject-level CV (OOM-safe)")
  576. logger.info(f"DATA_DIR={cfg.data_dir}")
  577. logger.info(f"OUTER_K={cfg.outer_k}, INNER_K={cfg.inner_k}, MAX_EVALS={cfg.max_evals}")
  578. logger.info("Tip: to reduce CUDA fragmentation, you may set:")
  579. logger.info(" export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True")
  580. logger.info("########################")
  582. raw_samples = load_all_samples_with_subject(cfg.data_dir)
  583. logger.info(f"Total samples loaded (raw): {len(raw_samples)}")
  585. label_to_idx = {lbl: i for i, lbl in enumerate(cfg.top2_labels)}
  586. dataset = EEGArtifactDataset(raw_samples, label_to_idx)
  588. groups = np.array([s["subject_id"] for s in dataset.samples])
  589. unique_subjects = sorted(set(groups.tolist()))
  590. logger.info(f"Unique subjects ({len(unique_subjects)}): {unique_subjects}")
  592. space = build_search_space(cfg)
  594. outer_cv = GroupKFold(n_splits=min(cfg.outer_k, len(unique_subjects)))
  595. outer_metrics = defaultdict(list)
  597. for outer_fold, (trainval_idx, test_idx) in enumerate(
  598. outer_cv.split(np.zeros(len(dataset)), np.zeros(len(dataset)), groups=groups),
  599. start=1
  600. ):
  601. trainval_idx = np.array(trainval_idx, dtype=np.int64)
  602. test_idx = np.array(test_idx, dtype=np.int64)
  604. trainval_groups = groups[trainval_idx]
  605. test_groups = groups[test_idx]
  607. logger.info("=" * 90)
  608. logger.info(f"[Outer Fold {outer_fold}/{outer_cv.n_splits}]")
  609. logger.info(f"TrainVal subjects ({len(set(trainval_groups))}): {sorted(set(trainval_groups.tolist()))}")
  610. logger.info(f"Test subjects ({len(set(test_groups))}): {sorted(set(test_groups.tolist()))}")
  611. logger.info(f"TrainVal samples={len(trainval_idx)} | Test samples={len(test_idx)}")
  613. inner_n_splits = min(cfg.inner_k, len(set(trainval_groups.tolist())))
  614. if inner_n_splits < 2:
  615. raise ValueError("Not enough subjects in TrainVal split for inner GroupKFold. Reduce OUTER_K/INNER_K.")
  617. inner_cv = GroupKFold(n_splits=inner_n_splits)
  619. trial_counter = {"i": 0}
  620. best_seen = {"loss": float("inf")}
  622. def objective(params: Dict) -> Dict:
  623. trial_counter["i"] += 1
  624. t0 = time.time()
  626. lr = float(params["lr"])
  627. batch_size = int(params["batch_size"])
  628. transformer_layers = int(params["transformer_layers"])
  629. transformer_nhead = int(params["transformer_nhead"])
  630. num_conv_blocks = int(params["num_conv_blocks"])
  631. weight_decay = float(params["weight_decay"])
  632. class_weight_scaling = [float(params["class_weight_scaling_0"]), float(params["class_weight_scaling_1"])]
  634. base_filters = [8, 16, 32, 64, 128]
  635. cnn_filters = base_filters[:num_conv_blocks]
  637. # Constraint: d_model must be divisible by nhead
  638. if cnn_filters[-1] % transformer_nhead != 0:
  639. logger.info(
  640. f"[Outer {outer_fold}] Trial {trial_counter['i']} INVALID (d_model%head!=0) => loss={cfg.oom_bad_loss}"
  641. )
  642. return {"loss": cfg.oom_bad_loss, "status": STATUS_OK}
  644. if cfg.log_trial_params:
  645. logger.info(f"[Outer {outer_fold}] Trial {trial_counter['i']}/{cfg.max_evals} params={params}")
  647. fold_losses = []
  648. fold_accs = []
  650. try:
  651. for inner_fold, (inner_tr_rel, inner_va_rel) in enumerate(
  652. inner_cv.split(np.zeros(len(trainval_idx)), np.zeros(len(trainval_idx)), groups=trainval_groups),
  653. start=1
  654. ):
  655. inner_tr_idx = trainval_idx[inner_tr_rel]
  656. inner_va_idx = trainval_idx[inner_va_rel]
  658. # class weights computed from inner-train only
  659. base_w = compute_class_weights_from_indices(dataset, inner_tr_idx, label_to_idx)
  660. adjusted = base_w * np.array(class_weight_scaling, dtype=np.float32)
  661. class_w_tensor = torch.tensor(adjusted, dtype=torch.float32, device=device)
  663. tr_loader = DataLoader(
  664. Subset(dataset, inner_tr_idx.tolist()),
  665. batch_size=batch_size,
  666. shuffle=True,
  667. num_workers=cfg.num_workers,
  668. pin_memory=cfg.pin_memory,
  669. )
  670. va_loader = DataLoader(
  671. Subset(dataset, inner_va_idx.tolist()),
  672. batch_size=batch_size,
  673. shuffle=False,
  674. num_workers=cfg.num_workers,
  675. pin_memory=cfg.pin_memory,
  676. )
  678. model = CNNTransformerModel(
  679. num_classes=len(label_to_idx),
  680. cnn_filters=cnn_filters,
  681. transformer_layers=transformer_layers,
  682. transformer_nhead=transformer_nhead,
  683. ).to(device)
  685. criterion = nn.CrossEntropyLoss(weight=class_w_tensor)
  686. optimizer = optim.Adam(model.parameters(), lr=lr, weight_decay=weight_decay)
  688. run_name = f"[Outer {outer_fold}][Trial {trial_counter['i']}][Inner {inner_fold}]"
  689. val_loss, val_acc = train_one_run(
  690. model=model,
  691. criterion=criterion,
  692. optimizer=optimizer,
  693. train_loader=tr_loader,
  694. val_loader=va_loader,
  695. device=device,
  696. num_epochs=cfg.inner_num_epochs,
  697. patience=cfg.inner_patience,
  698. run_name=run_name,
  699. log_every_epoch=cfg.log_every_epoch,
  700. )
  702. fold_losses.append(val_loss)
  703. fold_accs.append(val_acc)
  705. if cfg.log_inner_fold_detail:
  706. subs_tr = sorted(set(trainval_groups[inner_tr_rel].tolist()))
  707. subs_va = sorted(set(trainval_groups[inner_va_rel].tolist()))
  708. logger.info(
  709. f"{run_name} | done | val_loss={val_loss:.4f}, val_acc={val_acc:.4f} "
  710. f"| tr_subs={subs_tr} | va_subs={subs_va}"
  711. )
  713. # release memory
  714. del model, optimizer, criterion, tr_loader, va_loader
  715. cleanup_cuda()
  717. except torch.cuda.OutOfMemoryError as e:
  718. logger.warning(
  719. f"[Outer {outer_fold}] Trial {trial_counter['i']} OOM => mark as bad loss. "
  720. f"err={str(e)[:160]}"
  721. )
  722. cleanup_cuda()
  723. dt = time.time() - t0
  724. logger.info(f"[Outer {outer_fold}] Trial {trial_counter['i']} finished (OOM) | time={dt:.1f}s")
  725. return {"loss": cfg.oom_bad_loss, "status": STATUS_OK}
  727. mean_loss = float(np.mean(fold_losses)) if len(fold_losses) > 0 else cfg.oom_bad_loss
  728. mean_acc = float(np.mean(fold_accs)) if len(fold_accs) > 0 else 0.0
  729. dt = time.time() - t0
  731. best_seen["loss"] = min(best_seen["loss"], mean_loss)
  733. logger.info(
  734. f"[Outer {outer_fold}] Trial {trial_counter['i']} finished "
  735. f"| inner_mean_loss={mean_loss:.6f}, inner_mean_acc={mean_acc:.4f} "
  736. f"| best_loss_so_far={best_seen['loss']:.6f} | time={dt:.1f}s"
  737. )
  738. return {"loss": mean_loss, "status": STATUS_OK}
  740. logger.info(f"[Outer Fold {outer_fold}] Hyperopt tuning (inner CV mean val_loss) ...")
  741. trials = Trials()
  742. best = fmin(
  743. fn=objective,
  744. space=space,
  745. algo=tpe.suggest,
  746. max_evals=cfg.max_evals,
  747. trials=trials,
  748. rstate=np.random.default_rng(cfg.seed + outer_fold),
  749. )
  751. best_params = decode_best_params(best, cfg)
  752. logger.info(f"[Outer Fold {outer_fold}] Best hyperparams: {best_params}")
  754. # ----- Final training: trainval -> test evaluation -----
  755. base_filters = [8, 16, 32, 64, 128]
  756. cnn_filters = base_filters[:best_params["num_conv_blocks"]]
  758. base_w = compute_class_weights_from_indices(dataset, trainval_idx, label_to_idx)
  759. adjusted = base_w * np.array(best_params["class_weight_scaling"], dtype=np.float32)
  760. class_w_tensor = torch.tensor(adjusted, dtype=torch.float32, device=device)
  762. train_loader = DataLoader(
  763. Subset(dataset, trainval_idx.tolist()),
  764. batch_size=best_params["batch_size"],
  765. shuffle=True,
  766. num_workers=cfg.num_workers,
  767. pin_memory=cfg.pin_memory,
  768. )
  769. test_loader = DataLoader(
  770. Subset(dataset, test_idx.tolist()),
  771. batch_size=best_params["batch_size"],
  772. shuffle=False,
  773. num_workers=cfg.num_workers,
  774. pin_memory=cfg.pin_memory,
  775. )
  777. model = CNNTransformerModel(
  778. num_classes=len(label_to_idx),
  779. cnn_filters=cnn_filters,
  780. transformer_layers=best_params["transformer_layers"],
  781. transformer_nhead=best_params["transformer_nhead"],
  782. ).to(device)
  784. criterion = nn.CrossEntropyLoss(weight=class_w_tensor)
  785. optimizer = optim.Adam(model.parameters(), lr=best_params["lr"], weight_decay=best_params["weight_decay"])
  787. logger.info(f"[Outer Fold {outer_fold}] Final training on TrainVal, then evaluate on Test ...")
  789. try:
  790. _ = train_one_run(
  791. model=model,
  792. criterion=criterion,
  793. optimizer=optimizer,
  794. train_loader=train_loader,
  795. val_loader=test_loader, # keep your original behavior
  796. device=device,
  797. num_epochs=cfg.final_num_epochs,
  798. patience=cfg.final_patience,
  799. run_name=f"[Outer {outer_fold}][FINAL]",
  800. log_every_epoch=True,
  801. )
  802. except torch.cuda.OutOfMemoryError as e:
  803. logger.error(f"[Outer Fold {outer_fold}] FINAL training OOM. err={str(e)[:200]}")
  804. cleanup_cuda()
  805. # minimal retry strategy: smaller batch size
  806. retry_bs = 32
  807. logger.warning(f"[Outer Fold {outer_fold}] Retry FINAL with batch_size={retry_bs} ...")
  808. train_loader = DataLoader(
  809. Subset(dataset, trainval_idx.tolist()),
  810. batch_size=retry_bs,
  811. shuffle=True,
  812. num_workers=cfg.num_workers,
  813. pin_memory=cfg.pin_memory,
  814. )
  815. test_loader = DataLoader(
  816. Subset(dataset, test_idx.tolist()),
  817. batch_size=retry_bs,
  818. shuffle=False,
  819. num_workers=cfg.num_workers,
  820. pin_memory=cfg.pin_memory,
  821. )
  822. optimizer = optim.Adam(model.parameters(), lr=best_params["lr"], weight_decay=best_params["weight_decay"])
  823. _ = train_one_run(
  824. model=model,
  825. criterion=criterion,
  826. optimizer=optimizer,
  827. train_loader=train_loader,
  828. val_loader=test_loader,
  829. device=device,
  830. num_epochs=cfg.final_num_epochs,
  831. patience=cfg.final_patience,
  832. run_name=f"[Outer {outer_fold}][FINAL][RETRY_BS32]",
  833. log_every_epoch=True,
  834. )
  836. metrics = evaluate_model(model, test_loader, device, labels=list(cfg.top2_labels))
  837. logger.info(f"[Outer Fold {outer_fold}] TEST metrics:")
  838. logger.info(f" ACC = {metrics['acc']:.4f}")
  839. logger.info(f" BACC = {metrics['bacc']:.4f}")
  840. logger.info(f" F1 = {metrics['f1']:.4f}")
  841. logger.info(f" Prec = {metrics['precision']:.4f}")
  842. logger.info(f" Rec = {metrics['recall']:.4f}")
  843. logger.info(" Classification Report:\n" + metrics["report"])
  844. logger.info(" Confusion Matrix:\n" + str(metrics["cm"]))
  846. ckpt_path = f"nested_groupkfold_verbose_fold{outer_fold}_model.pth"
  847. torch.save(model.state_dict(), ckpt_path)
  848. logger.info(f"[Outer Fold {outer_fold}] Saved model checkpoint: {ckpt_path}")
  850. outer_metrics["acc"].append(float(metrics["acc"]))
  851. outer_metrics["bacc"].append(float(metrics["bacc"]))
  852. outer_metrics["f1"].append(float(metrics["f1"]))
  853. outer_metrics["precision"].append(float(metrics["precision"]))
  854. outer_metrics["recall"].append(float(metrics["recall"]))
  856. del model, optimizer, criterion, train_loader, test_loader
  857. cleanup_cuda()
  859. # ----- Summary -----
  860. logger.info("=" * 90)
  861. logger.info("Nested GroupKFold Summary (Outer-fold variability)")
  862. for k in ["acc", "bacc", "f1", "precision", "recall"]:
  863. mean, std, ci = mean_std_ci(outer_metrics[k])
  864. logger.info(f"{k.upper():>9s}: mean={mean:.4f}, std={std:.4f}, 95%CI=({ci[0]:.4f}, {ci[1]:.4f})")
  865. logger.info("-" * 90)
  866. for k in ["acc", "bacc", "f1", "precision", "recall"]:
  867. logger.info(f"{k.upper():>9s} per-fold: {['{:.4f}'.format(x) for x in outer_metrics[k]]}")
  869. logger.info("Done.")
  872. if __name__ == "__main__":
  873. main(CFG)

model_B.py at commit 93a8363, under MIT · at the source

Overview

Authors: Chunfeng Yang1, Jiangwei Yu2, Aonan He1, Wentao Xiang3, Xi Wang1, Guangquan Zhou2, Yudong Zhang1, Miao Cao4, Yang Chen1, Juan M Gorriz5
  1. Key Laboratory of New Generation Artificial Intelligence Technology and Its Interdisciplinary Applications (Southeast University), Ministry of Education, Jiangsu Provincial Joint International Research Laboratory of Medical Information Processing, School of Computer Science and Engineering, Southeast University and Centre de Recherche en Information Biomédicale Sino-français (CRIBs), 2 Sipailou, Nanjing, 210096 Jiangsu China
  2. School of Biological Science and Medical Engineering, Southeast University, Nanjing, Jiangsu 210096 China
  3. Jiangsu Province Engineering Research Center for Smart Wearable and Rehabilitation Devices, School of Biomedical Engineering and Informatics, Nanjing Medical University, Nanjing, 211166 Jiangsu China
  4. School of Health Sciences, Swinburne University of Technology, John Street, Hawthorn, Victoria 3122 Australia
  5. Data Science and Computational Intelligence Institute, University of Granada, Granada, 52005 Spain
Institutions: Southeast University (China); Nanjing Medical University (China); Swinburne University of Technology (Australia); Universidad de Granada (Spain)
Journal: Scientific data, volume 13, issue 1, article 807
Dates: received 19 September 2025; accepted 19 March 2026; published online 9 April 2026
Type: Data paper · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41597-026-07120-7 · PMID 41957382 · PMCID PMC13223301 · OpenAlex W7152408264
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: EEG (modality), human (organism), methods / tools (subfield)
Methods: Spectral & time-frequency, Preprocessing, Physiology & signal measures
Keywords: Data acquisition, Data publication and archiving, Machine learning, Neural decoding
MeSH: Artifacts*, Electroencephalography*, Convolutional Neural Networks, Humans, Movement (* major topic)
Topic: EEG and Brain-Computer Interfaces (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: National Natural Science Foundation of China (T2225025); Southeast University
Citations: not cited yet (Europe PMC); 34 references in the paper

Abstract

The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repositories

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

JiangweiYu221/PhysioMotion_Artifact

License: MIT
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: 93a8363d2ec62604f120ffde14c85b6b3112134d, 8 March 2026
Languages: Python (6)
Size: 9 files, 6 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (5 files), MNE-BIDS (3 files), pandas (3 files), Matplotlib (2 files), MNE-Python (2 files), PyTorch (2 files), scikit-learn (2 files)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
8 files
At the source: github.com/JiangweiYu221/PhysioMotion_Artifact

neuracle/neuracle-api

License: LGPL-2.1
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: 4477c996c50d5e1c28cde702c2be52e3f6c80002, 8 December 2022
Languages: MATLAB (7), Python (7)
Size: 16 files, 14 scripts
Software Heritage: archived
Found in: the text, “Usage Notes”
Holds: license file
Not found: README, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (4 files), Psychtoolbox (2 files), Matplotlib (1 file), MNE-Python (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
15 files
At the source: github.com/neuracle/neuracle-api

Code availability statement

The paper has a code availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1038/s41597-026-07120-7.

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;
  • 20 scripts, each with its path and the digest of its content;
  • 13 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 statement

The paper has a data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1038/s41597-026-07120-7.

Versions

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

Version 1, 29 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 10 authors, 4 keywords, 5 MeSH terms, 2 funders, 24 references.

Cite

This paper

Yang, C., Yu, J., He, A., Xiang, W., Wang, X., Zhou, G., Zhang, Y., Cao, M., Chen, Y., & Gorriz, J. M. (2026). PhysioMotion Artifact: A task-driven EEG dataset with point-wise motion artifact annotations. Scientific data, 13(1), 807. https://doi.org/10.1038/s41597-026-07120-7

BibTeX

@article{yang2026physiomotion,
author = {Yang, Chunfeng and Yu, Jiangwei and He, Aonan and Xiang, Wentao and Wang, Xi and Zhou, Guangquan and Zhang, Yudong and Cao, Miao and Chen, Yang and Gorriz, Juan M},
title = {{PhysioMotion Artifact: A task-driven EEG dataset with point-wise motion artifact annotations}},
journal = {Scientific data},
year = {2026},
month = apr,
volume = {13},
number = {1},
pages = {807},
publisher = {Nature Publishing Group},
issn = {2052-4463},
doi = {10.1038/s41597-026-07120-7},
url = {https://doi.org/10.1038/s41597-026-07120-7},
pmid = {41957382},
pmcid = {PMC13223301}
}

RIS

TY - JOUR
AU - Yang, Chunfeng
AU - Yu, Jiangwei
AU - He, Aonan
AU - Xiang, Wentao
AU - Wang, Xi
AU - Zhou, Guangquan
AU - Zhang, Yudong
AU - Cao, Miao
AU - Chen, Yang
AU - Gorriz, Juan M
TI - PhysioMotion Artifact: A task-driven EEG dataset with point-wise motion artifact annotations
T2 - Scientific data
J2 - Sci Data
PY - 2026
DA - 2026/04/09
VL - 13
IS - 1
SP - 807
SN - 2052-4463
PB - Nature Publishing Group
DO - 10.1038/s41597-026-07120-7
UR - https://doi.org/10.1038/s41597-026-07120-7
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41597-026-07120-7",
"type": "article-journal",
"title": "PhysioMotion Artifact: A task-driven EEG dataset with point-wise motion artifact annotations",
"container-title": "Scientific data",
"author": [
{
"family": "Yang",
"given": "Chunfeng"
},
{
"family": "Yu",
"given": "Jiangwei"
},
{
"family": "He",
"given": "Aonan"
},
{
"family": "Xiang",
"given": "Wentao"
},
{
"family": "Wang",
"given": "Xi"
},
{
"family": "Zhou",
"given": "Guangquan"
},
{
"family": "Zhang",
"given": "Yudong"
},
{
"family": "Cao",
"given": "Miao"
},
{
"family": "Chen",
"given": "Yang"
},
{
"family": "Gorriz",
"given": "Juan M"
}
],
"container-title-short": "Sci Data",
"volume": "13",
"issue": "1",
"page": "807",
"DOI": "10.1038/s41597-026-07120-7",
"PMID": "41957382",
"PMCID": "PMC13223301",
"ISSN": "2052-4463",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41597-026-07120-7",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
9
]
]
}
}

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/s41597-025-05174-7 [code]
A large-scale MEG and EEG dataset for object recognition in naturalistic scenes
Journal: n/a
In common: MNE-BIDS, Psychtoolbox, MNE-Python, 5 other tools, methods / tools, EEG, 1 reference
[2] doi:10.1093/cercor/bhag113 [code]
Long-term reliability and stability of parameterized resting state EEG: evidence from a five-year follow-up.
Journal: Cerebral cortex (New York, N.Y. : 1991)
In common: MNE-BIDS, MNE-Python, scikit-learn, 3 other tools, methods / tools, EEG, 2 references
[3] doi:10.1038/s41598-026-56070-y [code]
SSDLabeler: realistic semi-synthetic data generation for multi-label artifact classification in EEG.
Journal: Scientific reports
In common: PyTorch, scikit-learn, pandas, 2 other tools, EEG, 3 references
[4] doi:10.1007/s12021-026-09803-3 [code]
NeuroFusion: A Unified Framework for Generalized Visual Stimulus Decoding from fMRI Across Datasets and Subjects.
Journal: Neuroinformatics
In common: MNE-BIDS, MNE-Python, PyTorch, 4 other tools, methods / tools
[5] doi:10.3390/bioengineering13070820 [code]
Benchmarking Multimodal Workload Classification: Effects of Modality, Validation Protocol, and Segmentation Contrast on an Open Graded-Arithmetic Dataset.
Journal: Bioengineering (Basel, Switzerland)
In common: MNE-Python, PyTorch, scikit-learn, 3 other tools, methods / tools, EEG, 2 references
[6] doi:10.1371/journal.pone.0343722 [code]
Comprehensive methodology for sample enrichment in EEG biomarker studies for Alzheimer's risk classification.
Journal: PloS one
In common: MNE-BIDS, MNE-Python, scikit-learn, 3 other tools, EEG, 1 reference
[7] doi:10.1097/j.pain.0000000000004044 [code]
No effect of rhythmic visual stimulation on experimental pain perception.
Journal: Pain
In common: MNE-BIDS, MNE-Python, pandas, 2 other tools, EEG, 2 references
[8] doi:10.3758/s13428-026-02997-z [code]
PyLossless: A non-destructive EEG processing pipeline.
Journal: Behavior research methods
In common: MNE-BIDS, MNE-Python, pandas, 1 other tool, methods / tools, EEG, 2 references
[9] 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, 3 other tools, methods / tools, EEG, 1 reference
[10] doi:10.1038/s41597-026-07377-y [code]
An open-access multi-site fMRI dataset for investigating conscious visual perception.
Journal: Scientific data
In common: MNE-BIDS, MNE-Python, scikit-learn, 3 other tools, 1 reference

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.