OSCR

Decoding visual object recognition from EEG signals.

Code ↔ Paper

18 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 18 matches
  1. [1] § Materials and methods › Source modeling and regions of interest › Source space. ↔ scripts/mne_source_localization_trialwise.py, lines 188–285 · score 0.92 · Noise covariance, depth weighted, BEM solution, cortical surface, source localization, source space
  2. [2] § Materials and methods › Tasks and evaluation protocol ↔ scripts/dipole_selection_roi.py, lines 43–53 · score 0.91 · African elephant, desktop computer, electric guitar, folding chair, airliner, banana
  3. [3] § Materials and methods › Tasks and evaluation protocol ↔ scripts/train_paper.py, lines 63–66 · score 0.91 · African elephant, desktop computer, electric guitar, folding chair, airliner, banana
  4. [4] § Results ↔ scripts/train_classifier.py, lines 1–52 · score 0.87 · logistic regression, linear SVM, candidate classifiers, ridge classifier, class pilot, ROI core
  5. [5] § Results › Classifier and feature-family screening › Classifier selection. ↔ scripts/train_classifier.py, lines 1–52 · score 0.86 · logistic regression, candidate classifiers, Linear SVM, band power representation, ridge classifier, class pilot
  6. [6] § Materials and methods › Feature extraction › Band power. ↔ scripts/train_paper.py, lines 240–262 · score 0.81 · 8–13 Hz, 13–30 Hz, 30–120, 1–4 Hz, 4–8 Hz, beta
  7. [7] § Materials and methods › Classifiers ↔ scripts/train_classifier.py, lines 78–147 · score 0.78 · logistic regression, candidate classifier, linear SVM, ridge classifier, KNN, RF
  8. [8] § Results › Evaluation on full EEG-ImageNet label sets ↔ scripts/dipole_selection_roi.py, lines 61–75 · score 0.74 · superior frontal, dlPFC, visual cortex, cuneus, PCC, IPL
  9. [9] § Results › Evaluation on full EEG-ImageNet label sets ↔ scripts/dipole_selection_roi_all_class.py, lines 45–59 · score 0.74 · superior frontal, dlPFC, visual cortex, cuneus, PCC, IPL
  10. [10] § Materials and methods › Classifiers ↔ scripts/train_classifier.py, lines 78–147 · score 0.73 · logistic regression, linear SVM, Ridge classification, distance, KNN, pipelines
  11. [11] § Materials and methods › Feature extraction › Coupling measures. ↔ scripts/train_paper.py, lines 1–45 · score 0.70 · 13–30 Hz, 30–120 Hz, 70–150 Hz, phase, PLV, amplitude
  12. [12] § Materials and methods › Classifiers ↔ scripts/train_classifier.py, lines 226–333 · score 0.69 · power features, Classifier comparison, ROI high, band power, class pilot, folds
  13. [13] § Materials and methods › Feature extraction › Band power. ↔ scripts/train_paper.py, lines 1–45 · score 0.63 · 30–120 Hz, 70–150 Hz, band power, configurations, train, 70 Hz
  14. [14] § Results › Classifier and feature-family screening › Catch22 features. ↔ scripts/dipole_selection_roi.py, lines 61–75 · score 0.61 · superior frontal, dlPFC, IPL, SPL, parahippocampal, precuneus
  15. [15] § Results › Classifier and feature-family screening › Catch22 features. ↔ scripts/dipole_selection_roi_all_class.py, lines 45–59 · score 0.61 · superior frontal, dlPFC, IPL, SPL, parahippocampal, precuneus
  16. [16] § Results › Evaluation on full EEG-ImageNet label sets ↔ scripts/pair_test_ll24_vs_ll50_full_auto.py, lines 1–34 · score 0.60 · paired Wilcoxon signed, LL baseline, rank, Coarse, EEG, 50 ROIs
  17. [17] § Results › Baseline models with feature-family add-ons › Add-ons on the line-length baseline. ↔ scripts/pair_test_ll24_vs_ll50_full_auto.py, lines 1–34 · score 0.56 · paired Wilcoxon signed, LL baseline, rank
  18. [18] § Results › Baseline selection and feature add-ons ↔ scripts/train_classifier.py, lines 226–333 · score 0.54 · 70–150 Hz, ROI high, band power, 70 Hz, pilot, accuracy

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 · 337 lines · 9.8 KB · MIT · 6 matches

  1. #!/usr/bin/env python3
  2. # -*- coding: utf-8 -*-
  3. """
  4. train_classifier.py
  5. ===================
  7. Classifier selection experiment for the 8-class pilot:
  9. - Uses the same data-loading procedure and ROI order as train_paper.py
  10. (24-ROI core parcellation, 8-class subset).
  11. - Builds a 24-dimensional high-gamma (70–150 Hz) band-power representation.
  12. - Compares five candidate classifiers:
  13. 1) Random Forest (RF)
  14. 2) Linear SVM
  15. 3) ℓ2-regularized multinomial Logistic Regression
  16. 4) K-Nearest Neighbors (KNN)
  17. 5) Ridge Classifier
  19. All three models are evaluated on:
  20. - the same subjects,
  21. - the same trials,
  22. - the same 5-fold stratified CV splits,
  23. - the same feature representation.
  25. For each subject and classifier, we report mean ± SD accuracy across folds.
  26. We then summarize accuracy across subjects for each classifier.
  28. Usage:
  29. cd imed-mne/train-paper
  30. python train_classifier.py --subjects all
  31. # or specific subjects:
  32. # python train_classifier.py --subjects 0 1 2
  33. """
  35. import argparse
  36. from pathlib import Path
  37. from typing import Dict, Tuple, List
  39. import numpy as np
  40. import pandas as pd
  42. from sklearn.model_selection import StratifiedKFold
  43. from sklearn.metrics import accuracy_score
  44. from sklearn.preprocessing import LabelEncoder
  45. from sklearn.svm import LinearSVC
  46. from sklearn.linear_model import LogisticRegression
  47. from sklearn.pipeline import make_pipeline
  48. from sklearn.preprocessing import StandardScaler
  49. from sklearn.base import clone
  51. from sklearn.neighbors import KNeighborsClassifier
  52. from sklearn.linear_model import RidgeClassifier
  54. # Import data-loading and feature-building utilities from train_paper.py
  55. from train_paper import (
  56. load_subject_trials, # X, y, sfreq, roi_names
  57. features_gamma, # gamma band-power features
  58. ROI_ORDER_24,
  59. RANDOM_STATE,
  60. )
  62. # -------------------------------
  63. # Config
  64. # -------------------------------
  66. # High-gamma band for classifier comparison (Hz)
  67. GAMMA_BAND: Tuple[float, float] = (70.0, 150.0)
  69. # Output directory
  70. DEFAULT_OUT_DIR = Path("./outputs_classifier_selection")
  71. DEFAULT_OUT_DIR.mkdir(parents=True, exist_ok=True)
  74. # -------------------------------
  75. # Classifier factory
  76. # -------------------------------
  78. def build_classifier_dict(random_state: int) -> Dict[str, object]:
  79. """
  80. Define the candidate classifiers with reasonable, symmetric settings.
  82. - Random Forest (RF): same hyperparameters as train_paper.py
  83. - Linear SVM: LinearSVC with L2 penalty and class_weight='balanced'
  84. - Logistic Regression: multinomial, L2, class_weight='balanced'
  85. - KNN: distance-based classifier with standardized inputs
  86. - Ridge: linear ridge classifier with standardized inputs
  88. All linear / distance-based models are wrapped in a StandardScaler pipeline.
  89. """
  90. from sklearn.ensemble import RandomForestClassifier
  92. clf_rf = RandomForestClassifier(
  93. n_estimators=500,
  94. max_depth=None,
  95. max_features='sqrt',
  96. class_weight='balanced',
  97. random_state=random_state,
  98. n_jobs=-1,
  99. )
  101. clf_svm = make_pipeline(
  102. StandardScaler(),
  103. LinearSVC(
  104. C=1.0,
  105. class_weight='balanced',
  106. max_iter=10000,
  107. )
  108. )
  110. clf_logreg = make_pipeline(
  111. StandardScaler(),
  112. LogisticRegression(
  113. penalty="l2",
  114. C=1.0,
  115. solver="lbfgs",
  116. max_iter=1000,
  117. class_weight="balanced",
  118. )
  119. )
  122. clf_knn = make_pipeline(
  123. StandardScaler(),
  124. KNeighborsClassifier(
  125. n_neighbors=5,
  126. weights="distance",
  127. metric="minkowski",
  128. p=2, # Euclidean distance
  129. )
  130. )
  132. clf_ridge = make_pipeline(
  133. StandardScaler(),
  134. RidgeClassifier(
  135. alpha=1.0,
  136. class_weight="balanced",
  137. random_state=random_state,
  138. )
  139. )
  141. return {
  142. "RandomForest": clf_rf,
  143. "LinearSVM": clf_svm,
  144. "LogisticRegression": clf_logreg,
  145. "KNN": clf_knn,
  146. "Ridge": clf_ridge,
  147. }
  150. # -------------------------------
  151. # CV evaluation helper
  152. # -------------------------------
  154. def evaluate_classifiers_for_subject(
  155. X: np.ndarray,
  156. y: np.ndarray,
  157. clf_dict: Dict[str, object],
  158. n_splits: int = 5,
  159. seed: int = 42,
  160. ) -> List[dict]:
  161. """
  162. Evaluate each classifier in clf_dict on the SAME CV splits for one subject.
  164. Parameters
  165. ----------
  166. X : array, shape (n_trials, n_features)
  167. Feature matrix for this subject.
  168. y : array-like, shape (n_trials,)
  169. Class labels (strings or integers).
  170. clf_dict : dict
  171. Mapping from classifier name -> sklearn estimator (unfitted).
  172. n_splits : int
  173. Number of stratified CV folds.
  174. seed : int
  175. Random seed for fold generation.
  177. Returns
  178. -------
  179. results : list of dict
  180. One entry per classifier with per-subject mean and SD accuracy and
  181. number of folds used.
  182. """
  183. # Encode labels for CV split stability (strings are fine, but encoding is explicit)
  184. le = LabelEncoder()
  185. y_enc = le.fit_transform(y)
  187. skf = StratifiedKFold(
  188. n_splits=n_splits,
  189. shuffle=True,
  190. random_state=seed,
  191. )
  192. # Generate splits once and reuse for all classifiers
  193. splits = list(skf.split(X, y_enc))
  195. results = []
  197. for clf_name, clf_proto in clf_dict.items():
  198. fold_accs = []
  200. for fold_idx, (tr_idx, te_idx) in enumerate(splits):
  201. X_tr, X_te = X[tr_idx], X[te_idx]
  202. y_tr, y_te = y_enc[tr_idx], y_enc[te_idx]
  204. # Clone classifier to avoid leakage between folds
  205. clf = clone(clf_proto)
  206. clf.fit(X_tr, y_tr)
  207. y_pred = clf.predict(X_te)
  208. acc = accuracy_score(y_te, y_pred)
  209. fold_accs.append(acc)
  211. fold_accs = np.asarray(fold_accs, dtype=float)
  212. results.append({
  213. "classifier": clf_name,
  214. "mean_acc_5fold": float(fold_accs.mean()),
  215. "std_acc_5fold": float(fold_accs.std()),
  216. "n_folds": int(len(fold_accs)),
  217. })
  219. return results
  222. # -------------------------------
  223. # Main
  224. # -------------------------------
  226. def main():
  227. parser = argparse.ArgumentParser(
  228. description="Classifier comparison on 8-class pilot using 24-ROI high-gamma (70–150 Hz) band power."
  229. )
  230. parser.add_argument(
  231. "--subjects",
  232. type=str,
  233. nargs="+",
  234. required=True,
  235. help="Subject IDs (0..15) or 'all' to scan ROI JSONs.",
  236. )
  237. parser.add_argument(
  238. "--out-dir",
  239. type=str,
  240. default=str(DEFAULT_OUT_DIR),
  241. help="Output directory for per-subject and group-level summaries.",
  242. )
  243. args = parser.parse_args()
  245. out_dir = Path(args.out_dir)
  246. out_dir.mkdir(parents=True, exist_ok=True)
  248. # Resolve subject list
  249. if len(args.subjects) == 1 and args.subjects[0].lower() == "all":
  250. # Discover subjects from ROI selection files, as in train_paper.py
  251. roi_dir = Path("../roi_selections")
  252. subs = sorted([
  253. int(p.stem.split('_')[1])
  254. for p in roi_dir.glob("subject_*_roi_selections.json")
  255. ])
  256. else:
  257. subs = [int(s) for s in args.subjects]
  259. print("Subjects to process:", subs)
  261. clf_dict = build_classifier_dict(random_state=RANDOM_STATE)
  263. all_rows = []
  265. for sid in subs:
  266. print(f"\n=== Subject {sid} ===")
  267. try:
  268. X_trials, y_labels, sfreq, roi_names = load_subject_trials(sid)
  269. except Exception as e:
  270. print(f"[ERR] Subject {sid}: {e}")
  271. continue
  273. if X_trials.size == 0 or len(y_labels) == 0:
  274. print(f"[WARN] Subject {sid}: no usable 8-class trials. Skipping.")
  275. continue
  277. n_trials, n_rois, n_times = X_trials.shape
  278. print(f" - Trials: {n_trials} | ROIs: {n_rois} | Timepoints: {n_times} | sfreq = {sfreq:.1f} Hz")
  280. # Build 24-ROI high-gamma (70–150 Hz) band-power features
  281. X_feat, feat_names = features_gamma(X_trials, sfreq, roi_names, GAMMA_BAND)
  282. print(f" - Feature representation: 24-ROI high-γ {GAMMA_BAND[0]}–{GAMMA_BAND[1]} Hz")
  283. print(f" -> Feature matrix shape: {X_feat.shape}")
  285. # Evaluate all classifiers for this subject
  286. subj_results = evaluate_classifiers_for_subject(
  287. X=X_feat,
  288. y=y_labels,
  289. clf_dict=clf_dict,
  290. n_splits=5,
  291. seed=RANDOM_STATE,
  292. )
  294. for r in subj_results:
  295. row = {
  296. "subject": sid,
  297. "n_trials": n_trials,
  298. "n_features": X_feat.shape[1],
  299. "classifier": r["classifier"],
  300. "mean_acc_5fold": r["mean_acc_5fold"],
  301. "std_acc_5fold": r["std_acc_5fold"],
  302. "n_folds": r["n_folds"],
  303. }
  304. all_rows.append(row)
  306. # Save per-subject results
  307. if not all_rows:
  308. print("\nNo results to save (no subjects with usable data).")
  309. return
  311. df = pd.DataFrame(all_rows)
  312. per_subject_path = out_dir / "classifier_selection_per_subject.csv"
  313. df.to_csv(per_subject_path, index=False)
  314. print(f"\nSaved per-subject results to: {per_subject_path}")
  316. # Group-level summary across subjects
  317. grouped = df.groupby("classifier")["mean_acc_5fold"].agg(
  318. mean_acc="mean",
  319. std_acc="std",
  320. n_subjects="count",
  321. ).reset_index()
  323. group_path = out_dir / "classifier_selection_group_summary.csv"
  324. grouped.to_csv(group_path, index=False)
  325. print(f"Saved group-level summary to: {group_path}")
  327. print("\n=== Group-level accuracy across subjects (8-class, 24-ROI high-γ) ===")
  328. for _, row in grouped.iterrows():
  329. name = row["classifier"]
  330. mean_acc = row["mean_acc"]
  331. std_acc = row["std_acc"]
  332. n_sub = int(row["n_subjects"])
  333. print(f"{name:18s} {mean_acc:.3f} ± {std_acc:.3f} (n={n_sub})")
  336. if __name__ == "__main__":
  337. main()

train_classifier.py at commit 36c5bdf, under MIT · at the source

Overview

Authors: Yiwen Kang1, Mehdy Dousty1,2,3, Farnaz Khodami1, Ervin Sejdić1,3
ORCID iDs: Yiwen Kang, Mehdy Dousty
  1. Department of Electrical and Computer Engineering, University of Toronto, Toronto, Ontario, Canada
  2. Vector Institute for Artificial Intelligence, Toronto, Ontario, Canada
  3. North York General Hospital, Toronto, Ontario, Canada
Institutions: University of Toronto (Canada); North York General Hospital (Canada); Vector Institute (Canada)
Journal: PloS one, volume 21, issue 6, article e0351872
Dates: received 11 January 2026; accepted 2 June 2026; published online 24 June 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1371/journal.pone.0351872 · PMID 42341014 · PMCID PMC13293449 · OpenAlex W7165807578
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: EEG (modality), human (organism)
Methods: Spectral & time-frequency, Preprocessing, Statistics, Smoothing, state filtering, decompositions, Machine learning, Connectivity, Evoked potentials, fMRI & imaging, Physiology & signal measures
MeSH: Brain-Computer Interfaces*, Electroencephalography*, Pattern Recognition, Visual*, Brain Mapping, Humans, Random Forest (* major topic)
Journal subjects: Research and Analysis Methods, Bioassays and Physiological Analysis, Electrophysiological Techniques, Brain Electrophysiology, Electroencephalography, Biology and Life Sciences, Physiology, Electrophysiology, Neurophysiology, Neuroscience, Brain Mapping, Medicine and Health Sciences, Clinical Medicine, Clinical Neurophysiology, Imaging Techniques, Neuroimaging, Cognitive Science, Cognitive Psychology, Perception, Sensory Perception, Vision, Psychology, Social Sciences, Computer and Information Sciences, Software Engineering, Preprocessing, Engineering and Technology, Anatomy, Brain, Visual Cortex, Cognition, Memory, Visual Object Recognition, Learning and Memory, Mathematical and Statistical Techniques, Statistical Methods, Multivariate Analysis, Principal Component Analysis, Physical Sciences, Mathematics, Statistics
Topic: EEG and Brain-Computer Interfaces (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Citations: not cited yet (Europe PMC); 87 references in the paper

Abstract

Brain–computer interfaces (BCIs) and clinical EEG require compact and interpretable decoders, yet scalp sensors mix cortical signals and blur frequency-specific activity. Identifying which cortical regions and features carry discriminative visual information enables efficient, anatomically grounded object recognition decoding. This study localizes the cortical sources of informative EEG signals and identifies compact, mechanism-guided features that are most efficient given fixed data or compute budgets. To address this, we construct a source-space decoding pipeline that projects sensor signals onto anatomically defined cortical regions. Trial-wise activity is summarized within regions of interest (ROIs), and four feature families are extracted from each ROI: band-limited power (delta–gamma), line length (LL) for transient activity, temporal morphology, and couplings reflecting coordination between regions. Per-participant Random Forest (RF) classifiers are trained, and generality is quantified as consistency and ROI importance rankings across participants. A low-dimensional representation based on line length yields the strongest overall performance, while temporal morphology and coupling features contribute less under short RSVP (Rapid Serial Visual Presentation) trials. Relative to the EEG-ImageNet sensor-space baseline (310 features), the 24-ROI LL-only stack shows higher reported mean accuracy while using 92% fewer features (24 features), while a finer-grained, extended visual-pathway ROI set shows higher reported mean accuracy while using 84% fewer features (50 features). Adding a small, anatomically constrained high-γ block produces near-tied performance rather than a consistent improvement. These findings indicate that, for single-trial 0.5 s RSVP decoding, most discriminative information is captured by simple time-domain structure in anatomically defined ROIs. High-γ power remains a useful reference feature family, but its incremental value is limited once LL is included. By grounding features in neuro-informed regions, this approach compares favorably, at the level of reported mean accuracy, with the sensor-space baseline while providing clear anatomical attribution at substantially lower dimensionality, supporting lightweight and interpretable EEG decoding.

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

Repositories

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

Promise-Z5Q2SQ/EEG-ImageNet-Dataset

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 7c78157100d3737690d73f206f4385e72613290d, 15 May 2025
Languages: Python (13), Shell (3)
Size: 23 files, 16 scripts
Software Heritage: not archived
Found in: “Data Availability”
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: PyTorch (10 files), NumPy (7 files), Pillow (3 files), MNE-Python (2 files), scikit-learn (2 files), Hugging Face Transformers (2 files), PyTorch Geometric (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
18 files
At the source: github.com/Promise-Z5Q2SQ/EEG-ImageNet-Dataset

anniekang1112/eeg-imagenet-visual-decoding

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 36c5bdf984848a146ea98e8aadf7e81b719f1674, 9 June 2026
Languages: Python (9)
Size: 12 files, 9 scripts
Software Heritage: not archived
Found in: “Data Availability”
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (8 files), pandas (8 files), MNE-Python (6 files), SciPy (6 files), scikit-learn (4 files), Matplotlib (2 files), PyTorch (2 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
11 files
At the source: github.com/anniekang1112/eeg-imagenet-visual-decoding

Zenodo 20617271

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

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:

  • 3 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 34 scripts, each with its path and the digest of its content;
  • 18 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

No new EEG dataset was generated by this study. The original EEG recordings analyzed in this work are publicly available through the EEG-ImageNet dataset repository. Original EEG-ImageNet dataset is publicly available from the GitHub repositories (https://github.com/Promise-Z5Q2SQ/EEG-ImageNet-Dataset and https://github.com/anniekang1112/eeg-imagenet-visual-decoding). The analysis code used for source localization, ROI selection, feature extraction, model training, and statistical testing is publicly available from the Zenodo repository (https://doi.org/10.5281/zenodo.20617271). The original EEG recordings remain available through the EEG-ImageNet repository. Large intermediate files generated during source localization and feature extraction were not redistributed because they are derived from the public EEG-ImageNet dataset and can be regenerated using the provided analysis pipeline.

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, issue, pages, dates, 4 authors, 6 MeSH terms, 73 references.

Cite

This paper

Kang, Y., Dousty, M., Khodami, F., & Sejdić, E. (2026). Decoding visual object recognition from EEG signals. PloS one, 21(6), e0351872. https://doi.org/10.1371/journal.pone.0351872

BibTeX

@article{kang2026decoding,
author = {Kang, Yiwen and Dousty, Mehdy and Khodami, Farnaz and Sejdić, Ervin},
title = {{Decoding visual object recognition from EEG signals}},
journal = {PloS one},
year = {2026},
month = jun,
volume = {21},
number = {6},
pages = {e0351872},
publisher = {PLOS},
issn = {1932-6203},
doi = {10.1371/journal.pone.0351872},
url = {https://doi.org/10.1371/journal.pone.0351872},
pmid = {42341014},
pmcid = {PMC13293449}
}

RIS

TY - JOUR
AU - Kang, Yiwen
AU - Dousty, Mehdy
AU - Khodami, Farnaz
AU - Sejdić, Ervin
TI - Decoding visual object recognition from EEG signals
T2 - PloS one
J2 - PLoS One
PY - 2026
DA - 2026/06/24
VL - 21
IS - 6
SP - e0351872
SN - 1932-6203
PB - PLOS
DO - 10.1371/journal.pone.0351872
UR - https://doi.org/10.1371/journal.pone.0351872
LA - en
ER -

CSL-JSON

{
"id": "10.1371/journal.pone.0351872",
"type": "article-journal",
"title": "Decoding visual object recognition from EEG signals",
"container-title": "PloS one",
"author": [
{
"family": "Kang",
"given": "Yiwen"
},
{
"family": "Dousty",
"given": "Mehdy"
},
{
"family": "Khodami",
"given": "Farnaz"
},
{
"family": "Sejdić",
"given": "Ervin"
}
],
"container-title-short": "PLoS One",
"volume": "21",
"issue": "6",
"page": "e0351872",
"DOI": "10.1371/journal.pone.0351872",
"PMID": "42341014",
"PMCID": "PMC13293449",
"ISSN": "1932-6203",
"publisher": "PLOS",
"URL": "https://doi.org/10.1371/journal.pone.0351872",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
24
]
]
}
}

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.1093/cercor/bhag075 [code]
Cortical dynamics of icon perception: effects of concreteness and attractiveness.
Journal: Cerebral cortex (New York, N.Y. : 1991)
In common: MNE-Python, Pillow, scikit-learn, 4 other tools, 5 references
[2] doi:10.3389/fncom.2026.1786996 [code]
Schumann-anchored golden ratio organization of human neural oscillations.
Journal: Frontiers in computational neuroscience
In common: MNE-Python, Pillow, scikit-learn, 4 other tools, EEG, 5 references
[3] doi:10.1162/imag.a.1245 [code]
Towards precision EEG connectomics: Evaluating the benefits of dense sampling.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: MNE-Python, pandas, SciPy, 2 other tools, EEG, 6 references
[4] doi:10.1038/s41593-026-02285-1 [code]
Fixation duration on natural scenes is explained by memory encoding not processing demand.
Journal: Nature neuroscience
In common: MNE-Python, Pillow, PyTorch, 5 other tools, 4 references
[5] doi:10.1126/sciadv.aea3919 [code]
Hierarchical brain dynamics supporting visual perceptual transitions.
Journal: Science advances
In common: MNE-Python, pandas, SciPy, 2 other tools, 7 references
[6] doi:10.1038/s41467-026-76098-y [code]
A single computational objective can produce specialization of streams in visual cortex.
Journal: Nature communications
In common: Hugging Face Transformers, Pillow, PyTorch, 5 other tools, 2 references
[7] doi:10.1002/hbm.70516 [code]
Effects of Age on Resting-State Cortical Networks.
Journal: Human brain mapping
In common: MNE-Python, scikit-learn, pandas, 3 other tools, 5 references
[8] doi:10.3390/s26134019 [code]
NeuroStat: An Open-Source EEG Connectivity Platform for Randomised Controlled Trials.
Journal: Sensors (Basel, Switzerland)
In common: MNE-Python, pandas, SciPy, 2 other tools, EEG, 5 references
[9] doi:10.1002/hbm.70528 [code]
Explainable AI Insights Into EEG Classification and Its Alignment to Neural Correlates.
Journal: Human brain mapping
In common: MNE-Python, Pillow, PyTorch, 5 other tools, EEG, 2 references
[10] doi:10.7554/elife.100605 [code]
Age-related changes in ‘cortical’ 1/f dynamics are linked to cardiac activity
Journal: —
In common: MNE-Python, scikit-learn, pandas, 3 other tools, 4 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.