OSCR

An Open Non-Invasive EEG Dataset for Spontaneous Auditory Attention Switch Decoding.

Code ↔ Paper

2 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 2 matches
  1. [1] § Technical Validation ↔ src/mamrdp/engine.py, lines 144–276 · score 0.82 · weight decay, Cross entropy, Adam, optimizer, fold, PyTorch
  2. [2] § Technical Validation ↔ src/mamrdp/model.py, lines 42–107 · score 0.69 · layer normalization, attention heads, stacked, dropout, classification, block

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 · 317 lines · 17 KB · no license · 1 match

  1. import csv
  2. import json
  3. import random
  4. import time
  5. from pathlib import Path
  7. import numpy as np
  8. import torch
  9. from torch.nn import functional as F
  10. from torch.utils.data import DataLoader
  12. from .config import save_json
  13. from .data import EEGWindows, fit_normalizer, split_trials
  14. from .metrics import (aggregate_events, bounded_recursive, classification_metrics,
  15. match_events, state_transitions, resolve_recursive_settings)
  16. from .model import MAMRDPNet, MemoryQueue, require_current_revision
  19. def seed_all(seed, threads=4):
  20. random.seed(seed)
  21. np.random.seed(seed)
  22. torch.manual_seed(seed)
  23. if torch.cuda.is_available():
  24. torch.cuda.manual_seed_all(seed)
  25. torch.set_num_threads(threads)
  26. torch.backends.cudnn.benchmark = False
  27. torch.backends.cudnn.deterministic = True
  30. def get_device(name):
  31. if name == "auto":
  32. name = "cuda" if torch.cuda.is_available() else "cpu"
  33. device = torch.device(name)
  34. if device.type not in ("cpu", "cuda"):
  35. raise ValueError("Supported devices: cpu, auto, cuda or cuda:<index>")
  36. if device.type == "cuda":
  37. if not torch.cuda.is_available():
  38. raise RuntimeError(
  39. "CUDA requested but unavailable. Check the NVIDIA driver and CUDA-enabled "
  40. "PyTorch installation with python check_gpu.py. For CPU use --device cpu explicitly.")
  41. index = device.index if device.index is not None else torch.cuda.current_device()
  42. if index >= torch.cuda.device_count():
  43. raise ValueError(f"CUDA index {index} unavailable; visible GPU count={torch.cuda.device_count()}")
  44. device = torch.device("cuda", index)
  45. torch.cuda.set_device(device)
  46. return device
  49. def device_info(device):
  50. result = {"device": str(device), "torch_version": str(torch.__version__),
  51. "torch_cuda_version": torch.version.cuda, "precision": "float32"}
  52. if device.type == "cuda":
  53. properties = torch.cuda.get_device_properties(device)
  54. result.update(gpu_name=properties.name, gpu_total_memory_gib=properties.total_memory / 2**30,
  55. cuda_visible_device_count=torch.cuda.device_count())
  56. return result
  59. def loader(dataset, cfg, device, shuffle=False, generator=None):
  60. return DataLoader(dataset, batch_size=cfg["training"]["batch_size"], shuffle=shuffle,
  61. num_workers=cfg["training"]["num_workers"],
  62. pin_memory=device.type == "cuda", generator=generator,
  63. persistent_workers=cfg["training"]["num_workers"] > 0,
  64. drop_last=False)
  67. def atomic_checkpoint(path, payload):
  68. path = Path(path)
  69. tmp = path.with_suffix(".tmp")
  70. torch.save(payload, tmp)
  71. tmp.replace(path)
  74. def load_checkpoint(path, device="cpu"):
  75. checkpoint = torch.load(path, map_location=device, weights_only=True)
  76. require_current_revision(checkpoint["config"]["model"])
  77. return checkpoint
  80. @torch.no_grad()
  81. def infer(model, dataset, cfg, device):
  82. model.eval()
  83. probabilities = np.zeros((len(dataset), 2), dtype=np.float32)
  84. truth = np.zeros(len(dataset), dtype=np.int64)
  85. ce_sum = 0.0
  86. for x, y, indices in loader(dataset, cfg, device):
  87. x, y = x.to(device, non_blocking=True), y.to(device, non_blocking=True)
  88. logits, _ = model(x)
  89. if not torch.isfinite(logits).all():
  90. raise FloatingPointError("Non-finite prediction")
  91. ce_sum += F.cross_entropy(logits, y, reduction="sum").item()
  92. probabilities[indices.numpy()] = logits.softmax(dim=-1).cpu().numpy()
  93. truth[indices.numpy()] = y.cpu().numpy()
  94. metrics = classification_metrics(truth, probabilities.argmax(axis=1))
  95. metrics["cross_entropy"] = ce_sum / len(dataset)
  96. return metrics, probabilities
  99. def export_evaluation(folder, dataset, probabilities, window_metrics, cfg):
  100. folder = Path(folder)
  101. folder.mkdir(parents=True, exist_ok=True)
  102. ec = resolve_recursive_settings(cfg["evaluation"], cfg["data"]["stride_s"])
  103. records = [dict(r) for r in dataset.records]
  104. groups = {}
  105. for index, rec in enumerate(records):
  106. groups.setdefault((rec["subject"], rec["trial_index"]), []).append(index)
  107. events = []
  108. for (sid, trial_index), indices in groups.items():
  109. trial = dataset.subjects[sid]["trials"][trial_index]
  110. p = probabilities[indices]
  111. states, gains = bounded_recursive(p, ec["recursive_n"], ec["recursive_bias"], ec["initial_gain"])
  112. times = [records[i][ec["event_time"] + "_s"] for i in indices]
  113. truth = list(zip(trial["state_times"][1:], trial["state_labels"][1:]))
  114. raw_switches = state_transitions(p.argmax(axis=1), times)
  115. filtered_switches = state_transitions(states, times)
  116. events.append({"subject": sid, "epoch": trial["epoch"], "trigger": trial["trigger"],
  117. "mix_file": trial["mix_file"], "true_switches": truth,
  118. "raw_switches": raw_switches, "recursive_switches": filtered_switches,
  119. "raw": match_events(truth, raw_switches, ec["match_tolerance_s"]),
  120. "recursive": match_events(truth, filtered_switches, ec["match_tolerance_s"])})
  121. for local, index in enumerate(indices):
  122. records[index].update(p_left=float(p[local, 0]), p_right=float(p[local, 1]),
  123. predicted_label=int(p[local].argmax()),
  124. recursive_label=int(states[local]),
  125. gain_left=float(gains[local, 0]), gain_right=float(gains[local, 1]))
  126. with (folder / "predictions.csv").open("w", newline="", encoding="utf-8-sig") as handle:
  127. writer = csv.DictWriter(handle, fieldnames=list(records[0]))
  128. writer.writeheader()
  129. writer.writerows(records)
  130. output = {"window": window_metrics,
  131. "raw_events": aggregate_events([v["raw"] for v in events]),
  132. "recursive_events": aggregate_events([v["recursive"] for v in events]),
  133. "evaluation_settings": ec,
  134. "label_map": {"0": "left (179)", "1": "right (184)"}}
  135. save_json(folder / "events.json", events)
  136. save_json(folder / "metrics.json", output)
  137. return output
  140. def dataset_from_keys(subjects, keys, normalizer, cfg):
  141. return EEGWindows(subjects, keys, normalizer, cfg["data"]["window_s"], cfg["data"]["stride_s"])
  144. def train_fold(cfg, subjects, protocol, heldout, run_name, resume=None):
  145. tc = cfg["training"]
  146. seed_all(tc["seed"] + heldout, tc["cpu_threads"])
  147. device = get_device(tc["device"])
  148. folder = Path(cfg["paths"]["output_root"]) / run_name / protocol / f"S{heldout:02d}"
  149. folder.mkdir(parents=True, exist_ok=True)
  150. if (folder / "last.pt").exists() and resume is None:
  151. raise FileExistsError(f"Run exists: {folder}. Use --resume or a different --run-name.")
  152. runtime = device_info(device)
  153. save_json(folder / "device.json", runtime)
  154. if device.type == "cuda":
  155. torch.cuda.reset_peak_memory_stats(device)
  156. print(f"GPU: {runtime['gpu_name']} ({device}), "
  157. f"{runtime['gpu_total_memory_gib']:.1f} GiB, float32", flush=True)
  158. split = split_trials(subjects, protocol, heldout, tc["seed"], tc["validation_fraction_loso"])
  159. normalizer = fit_normalizer(subjects, split["train"])
  160. channels = len(normalizer["mean"])
  161. datasets = {k: dataset_from_keys(subjects, v, normalizer, cfg) for k, v in split.items()}
  162. model = MAMRDPNet(channels, cfg["data"]["target_sample_rate"], cfg["model"]).to(device)
  163. queue = MemoryQueue(tc["queue_size"], cfg["model"]["feature_dim"], tc["temperature"]).to(device)
  164. optimizer = torch.optim.Adam(model.parameters(), lr=tc["learning_rate"], weight_decay=tc["weight_decay"])
  165. generator = torch.Generator().manual_seed(tc["seed"] + heldout)
  166. history, start_epoch, best_ce = [], 0, float("inf")
  167. fingerprints = {str(s): v["signature"] for s, v in subjects.items()}
  168. if resume:
  169. old = load_checkpoint(resume)
  170. if old["protocol"] != protocol or old["heldout"] != heldout:
  171. raise ValueError("Resume checkpoint protocol/heldout does not match this fold")
  172. if old["split"] != split or old["fingerprints"] != fingerprints:
  173. raise ValueError("Data/split changed since checkpoint; start a new run")
  174. for part in ("data", "model", "evaluation"):
  175. if old["config"][part] != cfg[part]:
  176. raise ValueError(f"Resume configuration changed: {part}")
  177. ignored = {"epochs", "device", "num_workers", "cpu_threads"}
  178. if any(old["config"]["training"][k] != v for k, v in tc.items() if k not in ignored):
  179. raise ValueError("Training settings changed; only epochs/device/workers/threads may change on resume")
  180. if Path(resume).resolve().parent != folder.resolve():
  181. raise ValueError("Resume in the original run directory (same --run-name/output-root)")
  182. model.load_state_dict(old["model"])
  183. queue.load_state_dict(old["queue"])
  184. optimizer.load_state_dict(old["optimizer"])
  185. for state in optimizer.state.values():
  186. for key, val in state.items():
  187. if isinstance(val, torch.Tensor) and key != "step":
  188. state[key] = val.to(device)
  189. history, start_epoch, best_ce = old["history"], old["epoch"], old["best_val_ce"]
  190. torch.set_rng_state(old["torch_rng"])
  191. if device.type == "cuda" and old["cuda_rng"]:
  192. torch.cuda.set_rng_state_all(old["cuda_rng"])
  193. generator.set_state(old["loader_rng"])
  194. save_json(folder / "config.json", cfg)
  195. split_report = {name: [{"subject": s, "trial_index": i,
  196. "trigger": subjects[s]["trials"][i]["trigger"]} for s, i in keys]
  197. for name, keys in split.items()}
  198. save_json(folder / "split.json", split_report)
  199. audio_sets = {name: {subjects[s]["trials"][i]["mix_file"] for s, i in keys}
  200. for name, keys in split.items()}
  201. save_json(folder / "data_audit.json", {
  202. "subjects": {str(s): v["audit"] for s, v in subjects.items()},
  203. "shared_audio_between_splits": {
  204. a + "_" + b: sorted(audio_sets[a] & audio_sets[b])
  205. for a, b in (("train", "val"), ("train", "test"), ("val", "test"))},
  206. "split_unit": "EEG trial (subject, epoch); not audio identity"})
  207. np.savez(folder / "normalizer.npz", **normalizer)
  208. train_loader = loader(datasets["train"], cfg, device, shuffle=True, generator=generator)
  209. print(f"{protocol} S{heldout}: {channels} channels, device={device}, "
  210. f"windows=" + str({k: len(v) for k, v in datasets.items()}), flush=True)
  211. for epoch in range(start_epoch, tc["epochs"]):
  212. model.train()
  213. sums = np.zeros(4, dtype=float)
  214. correct, seen = 0, 0
  215. grad_norm_sum, clipped_batches, batches = 0.0, 0, 0
  216. started = time.perf_counter()
  217. for x, y, _ in train_loader:
  218. x, y = x.to(device, non_blocking=True), y.to(device, non_blocking=True)
  219. optimizer.zero_grad(set_to_none=True)
  220. logits, z = model(x)
  221. ce = F.cross_entropy(logits, y)
  222. contrast = queue.loss(z, y)
  223. regularization = model.frequency_regularization()
  224. loss = ce + tc["contrastive_weight"] * contrast + tc["frequency_weight"] * regularization
  225. if not torch.isfinite(loss):
  226. raise FloatingPointError(f"Non-finite loss at epoch {epoch + 1}")
  227. loss.backward()
  228. grad_norm = torch.nn.utils.clip_grad_norm_(model.parameters(), tc["gradient_clip"], error_if_nonfinite=True)
  229. grad_norm_sum += float(grad_norm.item())
  230. clipped_batches += int(grad_norm.item() > tc["gradient_clip"])
  231. batches += 1
  232. optimizer.step()
  233. queue.enqueue(z, y)
  234. n = len(y)
  235. sums += np.array([loss.item(), ce.item(), contrast.item(), regularization.item()]) * n
  236. correct += int((logits.argmax(dim=1) == y).sum().item())
  237. seen += n
  238. val_metrics, _ = infer(model, datasets["val"], cfg, device)
  239. entry = {"epoch": epoch + 1, "train_loss": float(sums[0] / seen),
  240. "train_ce": float(sums[1] / seen), "train_contrastive": float(sums[2] / seen),
  241. "train_frequency_regularization": float(sums[3] / seen),
  242. "train_gradient_norm_mean": grad_norm_sum / batches,
  243. "train_gradient_clip_fraction": clipped_batches / batches,
  244. "train_accuracy": correct / seen, "val_ce": val_metrics["cross_entropy"],
  245. "val_accuracy": val_metrics["accuracy"], "val_f1_macro": val_metrics["f1_macro"],
  246. "seconds": time.perf_counter() - started}
  247. if device.type == "cuda":
  248. entry["cuda_peak_allocated_mib"] = torch.cuda.max_memory_allocated(device) / 2**20
  249. history.append(entry)
  250. improved = entry["val_ce"] < best_ce
  251. if improved:
  252. best_ce = entry["val_ce"]
  253. payload = {"format_version": 2, "model": model.state_dict(), "queue": queue.state_dict(),
  254. "optimizer": optimizer.state_dict(), "epoch": epoch + 1,
  255. "best_val_ce": best_ce, "config": cfg, "protocol": protocol, "heldout": heldout,
  256. "channels": channels, "split": split, "fingerprints": fingerprints,
  257. "normalizer": {k: torch.from_numpy(v) for k, v in normalizer.items()},
  258. "history": history, "torch_rng": torch.get_rng_state(),
  259. "cuda_rng": torch.cuda.get_rng_state_all() if device.type == "cuda" else [],
  260. "loader_rng": generator.get_state()}
  261. if improved:
  262. atomic_checkpoint(folder / "best.pt", payload)
  263. atomic_checkpoint(folder / "last.pt", payload)
  264. save_json(folder / "history.json", history)
  265. print(f"Epoch {epoch + 1:03d}/{tc['epochs']}: loss={entry['train_loss']:.4f}, "
  266. f"train_ACC={entry['train_accuracy']:.3f}, val_ACC={entry['val_accuracy']:.3f}, "
  267. f"val_CE={entry['val_ce']:.4f}, {entry['seconds']:.1f}s", flush=True)
  268. best = load_checkpoint(folder / "best.pt")
  269. model.load_state_dict(best["model"])
  270. test_metrics, probabilities = infer(model, datasets["test"], cfg, device)
  271. result = export_evaluation(folder / "test", datasets["test"], probabilities, test_metrics, cfg)
  272. result.update(subject=heldout, best_epoch=best["epoch"], checkpoint=str(folder / "best.pt"))
  273. save_json(folder / "result.json", result)
  274. print(f"TEST S{heldout}: ACC={test_metrics['accuracy']:.4f}, "
  275. f"F1(right)={test_metrics['f1_right']:.4f}, F1(macro)={test_metrics['f1_macro']:.4f}", flush=True)
  276. return result
  279. def test_checkpoint(path, cfg, subjects, output, new_subjects=False):
  280. checkpoint = load_checkpoint(path)
  281. if checkpoint["config"]["data"] != cfg["data"] or checkpoint["config"]["model"] != cfg["model"]:
  282. raise ValueError("Test must use the checkpoint's preprocessing/window/model settings")
  283. seed_all(cfg["training"]["seed"], cfg["training"]["cpu_threads"])
  284. device = get_device(cfg["training"]["device"])
  285. save_json(Path(output) / "device.json", device_info(device))
  286. if new_subjects:
  287. keys = [(s, i) for s, sub in subjects.items() for i in range(len(sub["trials"]))]
  288. else:
  289. keys = checkpoint["split"]["test"]
  290. for sid in {s for s, _ in keys}:
  291. if subjects[sid]["signature"] != checkpoint["fingerprints"][str(sid)]:
  292. raise ValueError(f"S{sid}: source data changed since training")
  293. normalizer = {k: v.numpy() for k, v in checkpoint["normalizer"].items()}
  294. if any(v["shape"][1] != checkpoint["channels"] for v in subjects.values()):
  295. raise ValueError("Checkpoint and input data have different channel counts")
  296. dataset = dataset_from_keys(subjects, keys, normalizer, cfg)
  297. model = MAMRDPNet(checkpoint["channels"], cfg["data"]["target_sample_rate"], cfg["model"]).to(device)
  298. model.load_state_dict(checkpoint["model"])
  299. metrics, probabilities = infer(model, dataset, cfg, device)
  300. return export_evaluation(output, dataset, probabilities, metrics, cfg)
  303. def summarize(results, destination):
  304. rows = [{"subject": r["subject"], "accuracy": r["window"]["accuracy"],
  305. "f1_right": r["window"]["f1_right"], "f1_macro": r["window"]["f1_macro"],
  306. "sdl_s": r["recursive_events"]["sdl_s"],
  307. "fp_per_trial": r["recursive_events"]["false_positive_per_trial"],
  308. "false_negative_rate": r["recursive_events"]["false_negative_rate"]} for r in results]
  309. stats = {}
  310. for name in rows[0]:
  311. if name == "subject":
  312. continue
  313. values = [r[name] for r in rows if r[name] is not None]
  314. stats[name] = {"mean": float(np.mean(values)) if values else None,
  315. "sd": float(np.std(values, ddof=1)) if len(values) > 1 else None,
  316. "n_subjects": len(values)}
  317. save_json(destination, {"per_subject": rows, "subject_mean_sd": stats})

engine.py at commit a2799e7, no license · at the source

Overview

Authors: Xuefei Wang1, Yuting Ding1, Yueting Ban1, Lei Wang2, Fei Chen1
  1. Department of Electronic and Electrical Engineering, Southern University of Science and Technology, Shenzhen, Guangdong 518055 P. R. China
  2. School of Electronics and Communication Engineering, Guangzhou University, Guangzhou, Guangdong 510000 P. R. China
Institutions: Southern University of Science and Technology (China); Guangzhou University (China)
Journal: Scientific data, volume 13, issue 1, article 883
Dates: received 24 October 2025; accepted 13 April 2026; published online 16 April 2026
Type: Data paper · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41597-026-07244-w · PMID 41991955 · PMCID PMC13261058 · OpenAlex W7154577762
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: EEG (modality), human (organism), methods / tools (subfield)
Methods: Spectral & time-frequency, Connectivity, Preprocessing, Physiology & signal measures
MeSH: Attention*, Auditory Perception*, Brain-Computer Interfaces*, Electroencephalography*, Algorithms, Humans (* major topic)
Topic: EEG and Brain-Computer Interfaces (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: The National Key Research and Development Program of China (No. 2023YFF1203502); the Center for Computational Science and Engineering at Southern University of Science and Technology
Citations: cited by 2 papers (Europe PMC); 42 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.

Repository

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

XXuefeii/AASD-Processing

License: none: the authors keep all their rights
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: a2799e7beb933e9414142f1b660838a5204ee0d7, 22 September 2026
Languages: Python (8), MATLAB (1)
Size: 12 files, 9 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, environment (src/mamrdp/requirements.txt)
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (4 files), PyTorch (4 files), SciPy (2 files), EEGLAB (1 file), h5py (1 file), pandas (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
10 files
At the source: github.com/XXuefeii/AASD-Processing

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-07244-w.

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;
  • 9 scripts, each with its path and the digest of its content;
  • 2 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-07244-w.

Versions

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

Version 1, 29 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 5 authors, 6 MeSH terms, 2 funders, 29 references.

Cite

This paper

Wang, X., Ding, Y., Ban, Y., Wang, L., & Chen, F. (2026). An Open Non-Invasive EEG Dataset for Spontaneous Auditory Attention Switch Decoding. Scientific data, 13(1), 883. https://doi.org/10.1038/s41597-026-07244-w

BibTeX

@article{wang2026open,
author = {Wang, Xuefei and Ding, Yuting and Ban, Yueting and Wang, Lei and Chen, Fei},
title = {{An Open Non-Invasive EEG Dataset for Spontaneous Auditory Attention Switch Decoding}},
journal = {Scientific data},
year = {2026},
month = apr,
volume = {13},
number = {1},
pages = {883},
publisher = {Nature Publishing Group},
issn = {2052-4463},
doi = {10.1038/s41597-026-07244-w},
url = {https://doi.org/10.1038/s41597-026-07244-w},
pmid = {41991955},
pmcid = {PMC13261058}
}

RIS

TY - JOUR
AU - Wang, Xuefei
AU - Ding, Yuting
AU - Ban, Yueting
AU - Wang, Lei
AU - Chen, Fei
TI - An Open Non-Invasive EEG Dataset for Spontaneous Auditory Attention Switch Decoding
T2 - Scientific data
J2 - Sci Data
PY - 2026
DA - 2026/04/16
VL - 13
IS - 1
SP - 883
SN - 2052-4463
PB - Nature Publishing Group
DO - 10.1038/s41597-026-07244-w
UR - https://doi.org/10.1038/s41597-026-07244-w
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41597-026-07244-w",
"type": "article-journal",
"title": "An Open Non-Invasive EEG Dataset for Spontaneous Auditory Attention Switch Decoding",
"container-title": "Scientific data",
"author": [
{
"family": "Wang",
"given": "Xuefei"
},
{
"family": "Ding",
"given": "Yuting"
},
{
"family": "Ban",
"given": "Yueting"
},
{
"family": "Wang",
"given": "Lei"
},
{
"family": "Chen",
"given": "Fei"
}
],
"container-title-short": "Sci Data",
"volume": "13",
"issue": "1",
"page": "883",
"DOI": "10.1038/s41597-026-07244-w",
"PMID": "41991955",
"PMCID": "PMC13261058",
"ISSN": "2052-4463",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41597-026-07244-w",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
16
]
]
}
}

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

Similar papers

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

[1] doi:10.1371/journal.pbio.3003876 [code]
Competing speech streams are simultaneously represented in the human cortex during attention switching.
Journal: PLoS biology
In common: EEG, 6 references
[2] doi:10.7554/elife.100056 [code]
Multi-talker speech comprehension at different temporal scales in listeners with normal and impaired hearing.
Journal: eLife
In common: PyTorch, pandas, SciPy, 1 other tool, EEG, 3 references
[3] doi:10.1111/ejn.70538 [code]
Neural Tracking of Sustained Attention, Attention Switching, and Natural Conversation in Audiovisual Environments Using Wearable EEG.
Journal: The European journal of neuroscience
In common: pandas, SciPy, NumPy, EEG, 3 references
[4] doi:10.1038/s41562-026-02414-7 [code]
Optimized feature gains explain and predict successes and failures of human selective listening.
Journal: Nature human behaviour
In common: h5py, PyTorch, pandas, 2 other tools, 2 references
[5] doi:10.1038/s41597-025-06397-4 [code]
MEG-SCANS - A comprehensive magnetoencephalography speech dataset with Stories, Chirps and Noisy Sentences
Journal: n/a
In common: pandas, SciPy, NumPy, methods / tools, 3 references
[6] doi:10.1038/s41597-026-07215-1 [code]
The Brain, Body, and Behavior Dataset (BBBD): Multimodal Recordings during Educational Videos.
Journal: Scientific data
In common: EEGLAB, pandas, SciPy, 1 other tool, methods / tools, EEG, 2 references
[7] doi:10.1038/s41598-026-56070-y [code]
SSDLabeler: realistic semi-synthetic data generation for multi-label artifact classification in EEG.
Journal: Scientific reports
In common: EEGLAB, PyTorch, pandas, 1 other tool, EEG, 2 references
[8] doi:10.1371/journal.pone.0347671 [code]
RMETNet: A cross-subject motor imagery EEG signal classification model based on TSLANet and riemannian geometry features.
Journal: PloS one
In common: PyTorch, pandas, SciPy, 1 other tool, methods / tools, EEG, 2 references
[9] doi:10.3390/s26175444 [code]
The Deep-Match Framework for Event-Related Potential Detection in EEG.
Journal: Sensors (Basel, Switzerland)
In common: EEGLAB, h5py, PyTorch, 2 other tools, methods / tools, EEG
[10] doi:10.1016/j.ibneur.2026.05.013 [code]
Anticipatory slow potentials before auditory feedback show posterior predominance but limited condition effects in speech-in-noise.
Journal: IBRO neuroscience reports
In common: EEGLAB, pandas, SciPy, 1 other tool, EEG, 2 references

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.