OSCR

Interpretable EEG biomarkers for neurological disease models in mice using bag-of-waves classifiers.

Code ↔ Paper

7 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 7 matches
  1. [1] § Machine learning methods › Confidence intervals for accuracy ↔ cmd_analyze_classifier_LOO_pooled.ipynb, lines 334–375 · score 0.76 · confidence intervals, corrected resampled, standard error, freedom, LOO, splits
  2. [2] § Results › Classification results › TSC-genotype prediction ↔ make_ROC_curves.ipynb, lines 27–112 · score 0.69 · ROC curves, threshold, AUC, C57B6, sensitivity, BOS
  3. [3] § Machine learning methods › Classification models › Feature transformation via TFIDF ↔ get_classifiers_by_split.py, lines 19–128 · score 0.65 · hyper parameter selection, TFIDF transformation, pipeline, classifier, segments, training
  4. [4] § Machine learning methods › Bag-of-waves representation › Shift-invariant k-means clustering ↔ si2_kmeans.py, lines 127–196 · score 0.58 · assignment step, best shift, iteration, match, clustering, invariant
  5. [5] § Machine learning methods › Bag-of-waves representation › Shift-invariant k-means clustering ↔ si2_kmeans.py, lines 30–125 · score 0.55 · Euclidean norm, minimizing, squared, algorithm, shifting, clustering
  6. [6] § Machine learning methods › Bag-of-waves representation › Shift-invariant k-means clustering ↔ si2_kmeans.py, lines 30–125 · score 0.53 · shift invariant, chosen, minimize, cosine, squared, algorithm
  7. [7] § Machine learning methods › Classification models › Nested cross-validation for hyper-parameter selection and leave-one-out (LOO) model training ↔ get_classifiers_by_split.py, lines 19–128 · score 0.52 · hyper parameter, selection, internal, TFIDF, LOO, models

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 · 326 lines · 12 KB · no license · 3 matches

  1. """Sign-invariant and Shift-invariant k-means"""
  3. import sys
  4. import warnings
  6. import numpy as np
  7. from scipy.cluster.vq import vq
  10. from sklearn.utils.extmath import stable_cumsum, squared_norm, row_norms
  11. from sklearn.exceptions import ConvergenceWarning
  12. from BOWaves.utilities import sikmeans_utils
  13. from scipy.sparse.linalg import svds
  14. from si_vq import si_vq,si2_vq
  17. def _random_init(X, n_clusters, centroid_length, rng):
  18. n_samples = X.shape[0]
  19. seeds = rng.permutation(n_samples)[:n_clusters]
  20. centroids = X[seeds][:,:centroid_length]
  21. # centroids = sikmeans_utils.pick_random_windows(centroids, 1, centroid_length,
  22. # rng).squeeze() # this is unnecessary as it will simply pick first centroid_length
  24. return centroids
  27. ###############################################################################
  28. # Main algorithm
  30. # SVD flag added --------------------
  31. def si_kmeans(X, n_clusters, centroid_length, metric='cosine',
  32. init='random', use_sign_invariant=False, use_svd=True, do_sphere=True,
  33. n_init=10, max_iter=300, tol=1e-4, rng=None, verbose=False):
  34. """
  35. Shift-invariant k-means algorithm
  37. Parameters
  38. ----------
  39. X (numpy.ndarray):
  40. Data matrix with samples in its rows.
  41. n_clusters (int):
  42. Number of clusters to form, as well as the number of centroids to find.
  43. centroid_length (int):
  44. The length of each centroid.
  45. metric ('euclidean' or 'cosine'):
  46. Metric used to compute the distance between samples and cluster centroids. Default: 'euclidean'.
  47. init ('k-means++', 'random', numpy.ndarray, or a function):
  48. Method for initialization. If it's a function, it should have this
  49. call signature:
  50. centroids, shifts = init(
  51. X, n_clusters, centroid_length, rng, **kwargs).
  52. rng must be a Generator instance.
  53. n_init (int):
  54. The number of times the algorithm is run with different centroid seeds.
  55. The final results would be from the iteration where the inertia is the
  56. lowest.
  57. max_iter (init):
  58. Maximum number of iterations the algorithm will be run.
  59. tol (float):
  60. Upper bound that the squared euclidean norm of the change in the
  61. centroids must achieve to declare convergence.
  62. rng (int, Generator instance or None):
  63. Determines random number generation for centroid initialization. Use an
  64. int to make the randomness deterministic.
  65. verbose (bool):
  66. If True, print details about each iteration.
  68. Returns
  69. -------
  70. centroids (numpy.ndarray):
  71. A matrix with the learned centroids in its rows.
  72. labels (numpy.ndarray):
  73. labels[i] is the index of the centroid (row of `centroids`) closest
  74. to the sample X[i].
  75. shifts (numpy.ndarray):
  76. shift[i] is the shift that minimizes the distance to the closest
  77. centroid to the sample X[i].
  78. distances (numpy.ndarray):
  79. distances[i] is the distance from X[i,shift[i]:shift[i]+centroid_length]
  80. to its closest centroid.
  81. inertia (float):
  82. The sum of squared euclidean distances to the closest centroid of all the
  83. training samples.
  84. best_n_iter (int):
  85. Number of iterations needed to achieve convergence, according to `tol`.
  86. """
  88. rng = sikmeans_utils.check_rng(rng)
  90. best_labels, best_shifts, best_centroids = None, None, None
  91. best_distances, best_inertia, best_n_iter = None, None, None
  93. # subtract of mean of x for more accurate distance computations
  94. # NOTE: Can't do that because each centroid is the average of windows from X
  95. # that were chosen at different starting times.
  97. ss = rng.bit_generator._seed_seq
  98. child_seeds = ss.spawn(n_init)
  99. streams = [np.random.default_rng(s) for s in child_seeds]
  101. for seed in streams:
  102. # run a shift-invariant k-means once
  103. centroids, labels, shifts, distances, inertia, n_iter_ = si_kmeans_single(
  104. X, n_clusters, centroid_length, metric=metric, use_sign_invariant=use_sign_invariant,do_sphere=do_sphere, use_svd=use_svd,
  105. init=init, max_iter=max_iter, tol=tol, rng=seed, verbose=verbose)
  106. # determine if these results are the best so far
  107. if best_inertia is None or inertia < best_inertia:
  108. best_centroids = centroids.copy()
  109. best_labels = labels.copy()
  110. best_shifts = shifts.copy()
  111. best_distances = distances
  112. best_inertia = inertia
  113. best_n_iter = n_iter_
  115. distinct_clusters = len(set(best_labels))
  117. if distinct_clusters < n_clusters:
  118. warnings.warn(
  119. "Number of distinct clusters ({}) found smaller than "
  120. "n_clusters ({}). Possibly due to duplicate points "
  121. "in X.".format(distinct_clusters, n_clusters), ConvergenceWarning,
  122. stacklevel=2
  123. )
  125. return best_centroids, best_labels, best_shifts, best_distances, best_inertia, best_n_iter
  127. # SVD flag added --------------------
  128. def si_kmeans_single(X, n_clusters, centroid_length, metric='euclidean', use_sign_invariant=False, do_sphere=False, use_svd=False,
  129. init='k-means++', max_iter=300, tol=1e-3, rng=None, verbose=False):
  130. """
  131. Single run of shift-invariant k-means
  132. """
  134. rng = sikmeans_utils.check_rng(rng)
  137. best_labels, best_shifts, best_centroids = None, None, None
  138. best_distances, best_inertia = None, None
  140. # Random init only
  142. centroids = _random_init(X, n_clusters, centroid_length,rng)
  145. labels, shifts, distances, signs = _assignment_step(
  146. X, centroids, metric, use_sign_invariant)
  147. centroids = _init_centroids_update_step(
  148. X, centroid_length, n_clusters, labels, shifts, signs, do_sphere) # NEW
  150. # Added Normalization
  151. centroids /= np.sqrt(np.sum(centroids ** 2, axis = 1, keepdims= True))
  154. if verbose:
  155. print('Initialization completed.')
  157. for iteration in range(max_iter):
  158. centroids_old = centroids.copy()
  159. labels, shifts, distances, signs = _assignment_step(X, centroids, metric, use_sign_invariant)
  160. # SVD flag added --------------------
  161. centroids = _centroids_update_step(
  162. X, centroid_length, n_clusters, labels, shifts, signs, do_sphere, use_svd)
  164. # Added Normalization
  165. centroids /= np.sqrt(np.sum(centroids ** 2, axis = 1, keepdims= True))
  169. inertia = distances.mean()
  171. if verbose:
  172. print("Iteration %2d, inertia %.3f" % (iteration, inertia))
  174. if best_inertia is None or inertia < best_inertia:
  175. best_labels = labels.copy()
  176. best_shifts = shifts.copy()
  177. best_centroids = centroids.copy()
  178. best_distances = distances
  179. best_inertia = inertia
  181. centroid_change = squared_norm(centroids_old - centroids)/n_clusters/centroid_length
  182. #print(centroid_change, tol)
  183. if centroid_change <= tol:
  184. if verbose:
  185. print("Converged at iteration %d: "
  186. "centroid changes %e within tolerance %e"
  187. % (iteration, centroid_change, tol))
  188. break
  190. if centroid_change > 0:
  191. # rerun asingment step in case of non-convergence so that predicted
  192. # labels match cluster centers
  193. best_labels, best_shifts, best_distances, best_signs = _assignment_step(X, best_centroids, metric, use_sign_invariant)
  194. best_inertia = distances.mean()
  196. return best_centroids, best_labels, best_shifts, best_distances, best_inertia, iteration+1
  199. def _assignment_step(X, centroids, metric, use_sign_invariant):
  200. """
  201. Find the index of the shifted centroid that is closest to each sample
  203. Parameters
  204. ----------
  205. X (numpy.ndarray):
  206. Training data. Rows of X are samples.
  207. centroids (numpy.ndarray):
  208. Centroids of the clusters.
  210. Returns
  211. -------
  212. labels (numpy.ndarray):
  213. centroids[labels[i]] is the centroid closest to sample X[i]
  214. shifts (numpy.ndarray):
  215. X[i, shifts[i]:shifts[i]+centroid_length] is the window in X[i] closest to centroids[labels[i]].
  216. distances (numpy.ndarray):
  217. distances[i] is the distance of X[i, shifts[i]:shifts[i]+ centroid_length] to the closest centroid.
  218. """
  220. if use_sign_invariant:
  221. labels, shifts, distances,signs = si2_vq( X, centroids, metric)
  222. else:
  223. labels, shifts, distances = si_vq(X, centroids, metric)
  224. signs = np.ones_like(shifts)
  226. return labels, shifts, distances, signs
  228. # New SVD code is included here --------------------------------------------------------------------
  229. def _centroids_update_step(X, centroid_length, n_clusters, labels, shifts, signs, do_sphere=False, use_svd=False):
  230. """
  231. Update the cluster centroids
  232. """
  233. n_samples = X.shape[0]
  234. X_shifted = np.zeros((n_samples, centroid_length))
  235. centroids = np.zeros((n_clusters, centroid_length))
  238. # New SVD code for if use_svd is True
  239. if use_svd:
  241. for sample_id, sample in enumerate(X):
  242. shift = shifts[sample_id]
  243. x_window = signs[sample_id] * sample[shift:shift + centroid_length]
  245. if do_sphere:
  246. # Normalization Step
  247. X_shifted[sample_id] = x_window / (np.sqrt(np.sum(x_window**2))+ 1e-12)
  249. else:
  250. X_shifted[sample_id] = x_window
  252. cluster_ids = np.unique(labels)
  254. for cluster_id in cluster_ids:
  255. members = (labels == cluster_id)
  256. n_members = np.sum(members)
  257. if n_members == 1:
  258. centroids[cluster_id] = X_shifted[members].ravel()
  259. else:
  260. # SVD Step
  261. coef, _, vh = svds(X_shifted[members], k=1)
  262. centroids[cluster_id] = vh.ravel() * np.sign(np.mean(coef.ravel()))
  264. # Reassigning empty centroids code (Fixes crashes in certain strains)
  265. for k in np.where(np.linalg.norm(centroids, axis=1) == 0)[0]:
  266. centroids[k] = X[np.random.randint(n_samples), :centroid_length]
  269. # This part of the code is unedited for non-SVD use
  270. else:
  272. for sample_id, sample in enumerate(X):
  273. cluster_id = labels[sample_id]
  274. shift = shifts[sample_id]
  276. if do_sphere:
  277. # Normalization Step
  278. x_shift = signs[sample_id]*sample[shift:shift + centroid_length]
  279. centroids[cluster_id] += x_shift/np.sqrt(np.sum(x_shift**2))
  280. else:
  281. centroids[cluster_id] += signs[sample_id]*sample[shift:shift+centroid_length]
  283. # NOTE: Some clusters might be empty
  284. cluster_id, cluster_size = np.unique(labels, return_counts=True)
  285. centroids[cluster_id, :] /= cluster_size[:, np.newaxis]
  287. return centroids
  289. def _init_centroids_update_step(X, centroid_length, n_clusters, labels, shifts, signs,do_sphere=False):
  290. """
  291. Update the cluster centroids
  292. """
  294. cluster_ids, _ = np.unique(labels, return_counts=True)
  295. centroids = np.zeros((n_clusters, centroid_length))
  296. n_samples, sample_length = X.shape
  297. # adjust the shifts such that after adjustment the median shift is
  298. max_shift = sample_length - centroid_length
  299. opt_shift = max_shift/2
  300. adjusts = np.zeros((n_clusters))
  301. for k in cluster_ids:
  302. shifts_k = shifts[labels==k]
  303. adjusts[k] = opt_shift-np.median(shifts_k)
  305. cluster_sizes = np.zeros((n_clusters,1))
  306. for sample_id, sample in enumerate(X):
  307. cluster_id = labels[sample_id]
  308. temp = shifts[sample_id]+adjusts[cluster_id]
  309. if temp >= 0 and temp <= max_shift:
  310. shift = np.floor(temp).astype(int)
  311. if do_sphere:
  312. x_shift = signs[sample_id]*sample[shift:shift+centroid_length]
  313. centroids[cluster_id] += x_shift/np.sqrt(np.sum(x_shift**2))
  314. else:
  315. centroids[cluster_id] += signs[sample_id]*sample[shift:shift+centroid_length]
  317. cluster_sizes[cluster_id] += 1
  319. # NOTE: Some clusters might be empty drop them
  320. #centroids/= cluster_sizes
  321. for k in np.where(cluster_sizes==0)[0]:
  322. centroids[k,:] = 0
  323. for k in np.nonzero(cluster_sizes)[0]:
  324. centroids[k,:]/= cluster_sizes[k]
  326. return centroids

si2_kmeans.py at commit df37f52, no license · at the source

Overview

Authors: Maria Isabel Cano Achuri1, Montana Kay Lara2,3, Khalil Abed Rabbo4, Benjamin T Wilson5, Austin Meek6, J Matthew Mahoney3,7, Amanda E Hernan3,8, Austin J Brockmeier1,6
ORCID iDs: Maria Isabel Cano Achuri, Montana Kay Lara, Khalil Abed Rabbo, Austin Meek, J Matthew Mahoney, Amanda E Hernan, Austin J Brockmeier
  1. Department of Electrical and Computer Engineering, University of Delaware, Newark, DE, United States of America
  2. Department of Psychiatry, University of California San Diego, La Jolla, CA, United States of America
  3. Department of Neurological Sciences, University of Vermont, Burlington, VT, United States of America
  4. Neuroscience Program, University of Vermont, Burlington, VT, United States of America
  5. University of Vermont, Burlington, VT, United States of America
  6. Department of Computer and Information Sciences, University of Delaware, Newark, DE, United States of America
  7. The Jackson Laboratory, Bar Harbor, ME, United States of America
  8. Division of Neuroscience, Nemours Children’s Health, Wilmington, DE, United States of America
Institutions: University of Delaware (United States); University of Vermont (United States); University of California San Diego (United States); Jackson Laboratory (United States); Nemours Children's Health System (United States)
Journal: Journal of neural engineering, volume 23, issue 3, article 036016
Dates: received 22 August 2025; accepted 4 March 2026; published online 20 May 2026; in print 1 June 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1088/1741-2552/ae4d8c · PMID 41780177 · PMCID PMC13093256 · OpenAlex W7133525507
Open access: hybrid, a free copy (OpenAlex)
Status: code verified
Categories: genetics / omics (modality), EEG (modality), mouse (organism), epilepsy (population), clinical / translational (subfield)
Methods: Connectivity, Spectral & time-frequency, Statistics, Machine learning
Keywords: biomarkers, dictionary learning, epilepsy, machine learning, tuberous sclerosis complex, sparse coding, EEG
MeSH: Disease Models, Animal*, Electroencephalography*, Nervous System Diseases*, Animals, Biomarkers, Classification Algorithms, Epilepsy, Machine Learning, Male, Mice, Mice, Inbred C57BL, Mice, Knockout, Predictive Learning Models, Tuberous Sclerosis Complex 1 Protein (* major topic)
Topic: Epilepsy research and treatment (Psychiatry and Mental health, Medicine), according to OpenAlex
Funding: HHS | NIH | National Institute of Neurological Disorders and Stroke (NINDS) (5K22NS104230, 5R01NS134491)
Citations: not cited yet (Europe PMC); 67 references in the paper

Abstract

Objective. Electroencephalograms (EEGs) are time-series records of the electrical potential from collective neural activity in the brain. EEG waveform patterns—rhythmic and irregular oscillations and transient patterns of sharp waves or spikes—are potential phenotypical biomarkers, reflecting genotype-specific neural activity. This is especially relevant to diagnosing epilepsy without direct seizure observations, which is common in clinical settings, as well as in animal models, which often have subtle neurological phenotypes without overt epilepsy. Herein, we investigate genotypic prediction from long-term EEG signals of freely behaving mice belonging to six groups defined by the presence or absence of a neurological disease-genotype (TSC1 gene knockout) in three different inbred strains with distinct genetic backgrounds. Approach. We propose a machine learning approach to predict the genotypes of individual mice from the occurrence counts of waveforms that approximate short windows of the EEG. That is, a dictionary of waveforms is optimized to approximate windows from each genotype, and the vectors of waveform occurrence counts are the features for predicting genotypes via logistic regression models. Main results. Across two-fold cross-validation of the waveform dictionary learning, and leave-one-individual-out genotype prediction, we find that waveform counts pooled over multiple hour segments enable reliable prediction of mouse strain with an accuracy of 70% (95% CI 62–78) compared to chance rate of 38%. For two of the three strains, DBA2 and C57B6, strain-specific classifiers reliably determined the epilepsy-genotype (TSC1 gene knockout) with accuracies of 86% (95% CI 70–101) and 67% (95% 55–79), respectively. None of the mice of these strains had evidence of overt seizures or EEG-based seizure detection. In comparison, a state-of-the-art time-series classification approach (Hydra) enables higher strain classification at 98%, comparable TSC1-genotype prediction for the two strains (86% and 71% respectively), but the method is not interpretable. Significance. The methodologies and results show the potential of EEG waveforms as interpretable phenotypes and bag-of-waves as a feature representation for identifying epilepsy genotypes.

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

Repository

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

ajbrockmeier/bowaves-mice-genotyping

License: none: the authors keep all their rights
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: df37f52509cd7932f8587460ca8a9833d935793f, 6 August 2026
Languages: Python (8), Jupyter (5)
Size: 28 files, 13 scripts
Software Heritage: not archived
Found in: “Data availability statement”
Holds: README, environment (requirements.txt), 5 notebooks
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (10 files), pandas (10 files), scikit-learn (9 files), Matplotlib (6 files), SciPy (5 files), SHAP (3 files), MNE-Python (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
14 files
At the source: github.com/ajbrockmeier/bowaves-mice-genotyping

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

Tracing map

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

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 13 scripts, each with its path and the digest of its content;
  • 7 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

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

Data

Datasets cited

Data availability statement

The complete set of code is available at this URL: https://github.com/ajbrockmeier/bowaves-mice-genotyping.

The data that support the findings of this study are openly available at the following URL/DOI: https://zenodo.org/records/18577633 [67].

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 2, 28 September 2026

  • Publisher: n/a → IOP Publishing

Version 1, 28 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 8 authors, 7 keywords, 14 MeSH terms, 1 funder, 42 references.

Cite

This paper

Isabel Cano Achuri, M., Kay Lara, M., Abed Rabbo, K., Wilson, B. T., Meek, A., Mahoney, J. M., Hernan, A. E., & Brockmeier, A. J. (2026). Interpretable EEG biomarkers for neurological disease models in mice using bag-of-waves classifiers. Journal of neural engineering, 23(3), 036016. https://doi.org/10.1088/1741-2552/ae4d8c

BibTeX

@article{isabelcanoachuri2026interpretable,
author = {Isabel Cano Achuri, Maria and Kay Lara, Montana and Abed Rabbo, Khalil and Wilson, Benjamin T and Meek, Austin and Mahoney, J Matthew and Hernan, Amanda E and Brockmeier, Austin J},
title = {{Interpretable EEG biomarkers for neurological disease models in mice using bag-of-waves classifiers}},
journal = {Journal of neural engineering},
year = {2026},
month = may,
volume = {23},
number = {3},
pages = {036016},
publisher = {IOP Publishing},
issn = {1741-2560},
doi = {10.1088/1741-2552/ae4d8c},
url = {https://doi.org/10.1088/1741-2552/ae4d8c},
pmid = {41780177},
pmcid = {PMC13093256}
}

RIS

TY - JOUR
AU - Isabel Cano Achuri, Maria
AU - Kay Lara, Montana
AU - Abed Rabbo, Khalil
AU - Wilson, Benjamin T
AU - Meek, Austin
AU - Mahoney, J Matthew
AU - Hernan, Amanda E
AU - Brockmeier, Austin J
TI - Interpretable EEG biomarkers for neurological disease models in mice using bag-of-waves classifiers
T2 - Journal of neural engineering
J2 - J Neural Eng
PY - 2026
DA - 2026/05/20
VL - 23
IS - 3
SP - 036016
SN - 1741-2560
PB - IOP Publishing
DO - 10.1088/1741-2552/ae4d8c
UR - https://doi.org/10.1088/1741-2552/ae4d8c
LA - en
ER -

CSL-JSON

{
"id": "10.1088/1741-2552/ae4d8c",
"type": "article-journal",
"title": "Interpretable EEG biomarkers for neurological disease models in mice using bag-of-waves classifiers",
"container-title": "Journal of neural engineering",
"author": [
{
"family": "Isabel Cano Achuri",
"given": "Maria"
},
{
"family": "Kay Lara",
"given": "Montana"
},
{
"family": "Abed Rabbo",
"given": "Khalil"
},
{
"family": "Wilson",
"given": "Benjamin T"
},
{
"family": "Meek",
"given": "Austin"
},
{
"family": "Mahoney",
"given": "J Matthew"
},
{
"family": "Hernan",
"given": "Amanda E"
},
{
"family": "Brockmeier",
"given": "Austin J"
}
],
"container-title-short": "J Neural Eng",
"volume": "23",
"issue": "3",
"page": "036016",
"DOI": "10.1088/1741-2552/ae4d8c",
"PMID": "41780177",
"PMCID": "PMC13093256",
"ISSN": "1741-2560",
"publisher": "IOP Publishing",
"URL": "https://doi.org/10.1088/1741-2552/ae4d8c",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
20
]
]
}
}

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.3390/s26175327 [code]
Subject Identity Confounds qEEG Emotion Recognition on DEAP and DREAMER.
Journal: Sensors (Basel, Switzerland)
In common: SHAP, MNE-Python, scikit-learn, 4 other tools, EEG
[2] doi:10.1007/s10548-026-01238-y [code]
Topographic Reorganization of EEG Complexity During Visual Mental Imagery: Insights from Lempel-Ziv Complexity in High-Density EEG.
Journal: Brain topography
In common: SHAP, MNE-Python, scikit-learn, 4 other tools, EEG
[3] doi:10.1038/s41598-026-52330-z [code]
SHAP analysis of an improved EEG-based mental workload classification framework: utilizing data augmentation and explainable AI.
Journal: Scientific reports
In common: SHAP, MNE-Python, scikit-learn, 4 other tools, EEG
[4] doi:10.1038/s42003-026-10205-z [code]
Source-space EEG alpha activity reveals brain age gaps due to neurodegeneration and disparity.
Journal: Communications biology
In common: SHAP, scikit-learn, pandas, 3 other tools, EEG, 1 reference
[5] doi:10.1038/s41467-026-71555-0 [code]
A deep representation learning model to predict response to vagus nerve stimulation.
Journal: Nature communications
In common: SHAP, scikit-learn, pandas, 3 other tools, epilepsy, clinical / translational
[6] 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-Python, scikit-learn, pandas, 3 other tools, EEG, 1 reference
[7] doi:10.1371/journal.pone.0351872 [code]
Decoding visual object recognition from EEG signals.
Journal: PloS one
In common: MNE-Python, scikit-learn, pandas, 3 other tools, EEG, 1 reference
[8] 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, scikit-learn, pandas, 3 other tools, EEG, 1 reference
[9] doi:10.1093/bioinformatics/btag213 [code]
Interpretable deep survival analysis of Alzheimer's disease via metabolic genetic variants.
Journal: Bioinformatics (Oxford, England)
In common: SHAP, scikit-learn, pandas, 3 other tools, clinical / translational, genetics / omics
[10] doi:10.3389/fphys.2026.1830956 [code]
A systematic evaluation of explainable AI methods for high-dimensional transcriptome-based cancer survival prediction.
Journal: Frontiers in physiology
In common: SHAP, scikit-learn, pandas, 3 other tools, clinical / translational, genetics / omics

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.