OSCR

Analysis of cognitive mechanisms in phoneme perception and pronunciation errors among Korean language learners.

Code ↔ Paper

9 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 9 matches
  1. [1] § Experimental setup › Training dynamics and convergence analysis ↔ src/EEGNet_Hybrid.ipynb, lines 200–306 · score 0.82 · optimization step, training accuracy, EEGNet, validation loss, model training, gradient
  2. [2] § Experimental setup › Experimental details ↔ src/ShallowDeep.ipynb, lines 39–111 · score 0.78 · cosine annealing, squared error, MSE, schedule, regression, classification
  3. [3] § Experimental setup › Comparison with SOTA methods ↔ src/examples/EEGModels.py, lines 362–403 · score 0.70 · ShallowConvNet, convolutional networks, EEG models, deviation, EEG signal, filtering
  4. [4] § Experimental setup › Training dynamics and convergence analysis ↔ src/examples/MNIST_Early_Stopping_example.ipynb, lines 117–197 · score 0.68 · optimization step, validation loss, model training, gradient, epochs, prediction
  5. [5] § Experimental setup › Experimental details ↔ src/ShallowDeep.ipynb, lines 39–111 · score 0.63 · Weight decay, cropping, PyTorch, Adam, deep, batch
  6. [6] § Experimental setup › Dataset ↔ src/examples/EEGNet TF.ipynb, lines 1–88 · score 0.63 · brain computer interfaces, neuroscience, auditory, neural, filtering, epoch
  7. [7] § Experimental setup › Dataset ↔ src/examples/ERP.py, lines 1–67 · score 0.63 · brain computer interfaces, neuroscience, auditory, neural, filtering, epoch
  8. [8] § Experimental setup › Experimental details ↔ src/examples/plot_bcic_iv_2a_moabb_trial.ipynb, lines 192–245 · score 0.57 · cosine annealing, schedule, classification, optimized, loss, validation
  9. [9] § Experimental setup › Experimental details ↔ src/examples/plot_bcic_iv_2a_moabb_trial.ipynb, lines 192–245 · score 0.56 · Weight decay, PyTorch, Adam, batch, optimizer, epochs

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

Jupyter notebook · 347 lines · 15 KB · no license · 2 matches

  1. # %%
  2. from sklearn.model_selection import train_test_split
  3. from sklearn.preprocessing import StandardScaler , LabelEncoder
  4. import sys, io
  5. import pandas as pd
  6. from ipynb.fs.full.Data_Processing import *
  7. from ipynb.fs.full.evaluation import *
  8. from braindecode.datasets.xy import create_from_X_y
  9. from braindecode.training.losses import CroppedLoss
  10. import time
  11. import numpy as np
  12. import torch
  13. from braindecode.util import set_random_seeds
  14. from braindecode.models import ShallowFBCSPNet , Deep4Net
  15. from skorch.callbacks import LRScheduler, EarlyStopping
  16. from skorch.helper import predefined_split
  17. from braindecode import EEGClassifier , EEGRegressor
  18. from collections import namedtuple
  19. import pickle
  20. from sklearn.model_selection import KFold
  22. cuda = torch.cuda.is_available() # check if GPU is available, if True chooses to use it
  23. device = 'cuda' if cuda else 'cpu'
  24. if cuda:
  25. torch.backends.cudnn.benchmark = True
  26. seed = 20200220 # random seed to make results reproducible
  27. # Set random seed to be able to reproduce results
  28. set_random_seeds(seed=seed, cuda=cuda)
  30. class ShallowDeep:
  31. def __init__(self, model_type, bandpass, eval_type, class_type):
  32. self.model_type = model_type
  33. self.bandpass = bandpass
  34. self.eval_type = eval_type
  35. self.class_type = class_type
  39. def choose_cnn (self, model_depth, model_type, trainset, validset , n_classes , device, cuda , n_epochs):
  40. # Extract number of chans and time steps from dataset
  41. n_chans = trainset[0][0].shape[0]
  42. input_window_samples = trainset[0][0].shape[1]
  44. if model_type =='reg':
  45. n_classes = 1
  47. if model_depth == 'shallow':
  48. lr = 0.0625 * 0.01
  49. weight_decay = 0
  50. model = ShallowFBCSPNet(n_chans, n_classes, input_window_samples=input_window_samples, final_conv_length="auto")
  51. else:
  52. lr = 1 * 0.01
  53. weight_decay = 0.5 * 0.001
  54. """
  55. For 30 samples, filter time_length = 1
  56. For 60 > samples, filter time length is left empty
  57. for 15 samples, filter_time length = 1, filter_length_2 = 1, filter_length_3 = 1
  58. """
  59. model = Deep4Net(n_chans, n_classes, input_window_samples=input_window_samples,
  60. final_conv_length='auto', pool_time_length=1, filter_time_length = 1,pool_time_stride=1)
  61. if cuda:
  62. model = model.cuda(0)
  64. batch_size = 32
  66. if model_type == 'clf':
  67. clf = EEGClassifier(
  68. model,
  69. criterion=torch.nn.NLLLoss,
  70. optimizer=torch.optim.AdamW,
  71. train_split=predefined_split(validset), # using valid_set for validation
  72. optimizer__lr=lr,
  73. optimizer__weight_decay=weight_decay,
  74. batch_size=batch_size,
  75. callbacks=[
  76. "accuracy",
  77. ("lr_scheduler", LRScheduler('CosineAnnealingLR', T_max=n_epochs - 1)),
  78. ("EarlyStopping", EarlyStopping(monitor = 'valid_loss', threshold = 0.00001)),
  79. ],
  80. device=device,)
  81. return clf
  82. else:
  84. # remove softmax
  85. new_model = torch.nn.Sequential()
  86. for name, module_ in model.named_children():
  87. if "softmax" in name:
  88. continue
  89. new_model.add_module(name, module_)
  91. model = new_model
  93. regressor = EEGRegressor(
  94. model,
  95. cropped = False,
  96. criterion=CroppedLoss,
  97. criterion__loss_function=torch.nn.functional.mse_loss,
  98. optimizer=torch.optim.AdamW,
  99. train_split=predefined_split(validset),
  100. optimizer__lr=lr,
  101. optimizer__weight_decay=weight_decay,
  102. iterator_train__shuffle=True,
  103. batch_size=batch_size,
  104. callbacks=[
  105. "neg_root_mean_squared_error",
  106. # seems n_epochs -1 leads to desired behavior of lr=0 after end of training?
  107. ("lr_scheduler", LRScheduler('CosineAnnealingLR', T_max=n_epochs - 1)),
  108. ("EarlyStopping", EarlyStopping(monitor = 'valid_loss', threshold = 0.00001)),
  109. ],
  110. device=device)
  111. return regressor
  117. def kfold_predict (self, X,y, model_type, n_epochs, model_depth,class_type):
  118. kf= KFold(n_splits = 5, shuffle = True, random_state = 1)
  120. if model_type == 'clf':
  121. results = {"Accuracy":[], "Precision":[], "Recall":[], "F1 Score Macro":[],
  122. "F1 Score Micro":[],"Balanced Accuracy":[]}
  123. else:
  124. results = {'RMSE':[], 'R2':[]}
  126. total_predictions = []
  127. total_true = []
  128. num_classes = 0
  129. clf = None
  130. for train_index, test_index in kf.split(X):
  131. print("Train: ", train_index, "Validation: ", test_index)
  133. #Train/test split
  134. X_train, X_valid = np.concatenate(X[train_index]), np.concatenate(X[test_index])
  135. y_train, y_valid = np.concatenate(y[train_index]).astype('int'), np.concatenate(y[test_index]).astype('int')
  137. # check the the classes in the validation set
  138. y_valid_classes = list(set(y_valid))
  139. y_train_classes = list(set(y_train))
  140. if check_if_valid_labels_are_in_train(y_train_classes, y_valid_classes) == False:
  141. continue
  144. size = len(X_train) + len(X_valid) #get dataset size
  146. #standardise per channel
  147. X_train, X_valid = standardise(X_train, X_valid)
  149. #convert to binary if binary classification
  150. if class_type == 'binary':
  151. y_train = convert_to_binary(y_train)
  152. y_valid = convert_to_binary(y_valid)
  154. #label the categorical variables
  155. if model_type == 'clf':
  156. y_train, y_valid, le = categorise(y_train, y_valid)
  158. # Convert training and validation sets into a suitable format
  159. save_stdout = sys.stdout
  160. sys.stdout = open('/cs/tmp/ybk1/trash', 'w')
  161. trainset = create_from_X_y(X_train, y_train, drop_last_window=False)
  162. validset = create_from_X_y(X_valid, y_valid, drop_last_window=False)
  163. sys.stdout = save_stdout
  165. # count the number of classes
  166. if len(set(y_train)) > num_classes:
  167. num_classes = len(set(y_train))
  169. # commence the training process
  170. time_start = time.time()
  171. save_stdout = sys.stdout
  172. sys.stdout = open('/cs/tmp/ybk1/trash', 'w')
  173. cnn = self.choose_cnn (model_depth, model_type, trainset, validset , num_classes , device, cuda, n_epochs).fit(trainset, y=None, epochs=n_epochs)
  175. sys.stdout = save_stdout
  176. print('Training completed created! Time elapsed: {} seconds'.format(time.time()-time_start))
  178. # make predictions
  179. if model_type == 'clf':
  180. y_pred = le.inverse_transform(cnn.predict(X_valid))
  181. y_true = le.inverse_transform(y_valid)
  182. else:
  183. y_pred = cnn.predict(X_valid)
  184. y_true = y_valid
  186. total_predictions.append(y_pred)
  187. total_true.append(y_true)
  188. r = get_results(y_true, y_pred, model_type)
  190. for key in r: # loop through dictionary to add to all the scores to the results dictionary
  191. results[key].append(r[key])
  194. for key in results: # finallly average out the results
  195. results[key] = average(results[key])
  197. return results, np.concatenate(total_predictions), np.concatenate(total_true), num_classes, size, cnn
  199. def save_plots(self,y_true, y_pred, user, label, model_depth, bandpass, window_size_samples, model_type, cnn,class_type):
  200. if model_type == 'clf':
  201. # plot confusion matrix
  202. cm = confusion_matrix(y_true, y_pred)
  203. saved_file = "results/CNN/{5}/confusion/k fold/{2}/per user/User_{0}_Label_{1}_bandpass_{3}_window_{4}_class_type{6}.png".format(user, label, model_depth, bandpass, window_size_samples, model_type, class_type)
  204. plot_confusion_matrix(cm, set(y_true), saved_file ,normalize=True)
  206. #plot loss curve
  207. plot_loss_curve(cnn)
  208. plt.savefig("results/CNN/{5}/loss curves/k fold/{2}/per user/User_{0}_Label_{1}_bandpass_{3}_window_{4}_class_type{6}.png".format(user, label, model_depth, bandpass, window_size_samples, model_type, class_type))
  210. if model_type == 'reg':
  211. saved_file = "results/CNN/{5}/y vs y_pred/{2}/per user/User_{0}_Label_{1}_bandpass_{3}_window_{4}_class_type{6}.png".format(user, label, model_depth, bandpass, window_size_samples, model_type, class_type)
  212. plot_model(y_true, y_pred, user, label,file=saved_file)
  214. def run_per_user_sd(self, model_type, bandpass, class_type):
  215. """
  216. Method for running the CNN per user
  217. """
  218. multiple = None
  219. sigma = None
  221. model_depths = ['deep', 'shallow']
  222. results = []
  223. for model_depth in model_depths:
  225. time_original = time.time()
  228. labels = ['attention','interest','effort']
  229. window_size_samples = 120
  230. n_epochs = 100
  231. # saved_file = "/cs/home/ybk1/Dissertation/data/all_users_sampled_with_individual_tests_30_window_annotated_EEG.pickle"
  232. saved_file = "saved user and test data/all_users_sampled_{0}_window_annotated_EEG_no_agg_bandpass_{1}_slider_{0}.pickle".format(window_size_samples, bandpass)
  233. all_tests = load_file(saved_file)
  234. users = all_tests.keys()
  236. for user in users:
  237. torch.backends.cudnn.benchmark = True
  239. for label in labels:
  240. print("Running - Model_type: {4}, ClassType:{3}, Model: {0}, User: {1}, label: {2}".format(model_depth, user,label, class_type, model_type))
  242. time_start = time.time()
  243. dt = all_tests[user] # dictionary of all the individual tests per user
  245. X = np.array([np.array(x).transpose(0,2,1).astype(np.float32) for x in dt['inputs']])
  246. y = np.array([np.array(x) for x in dt[label]]) #Convert the categories into labels
  248. # train and make predictions
  249. r, y_pred, y_true, num_classes, size, cnn = self.kfold_predict(X,y, model_type, n_epochs, model_depth,class_type)
  250. print(r['Accuracy'])
  252. # get results
  253. duration = time.time() - time_start
  254. results.append(collate_results(r, user, label, duration,
  255. num_classes, size, model_type,
  256. n_epochs, window_size_samples,
  257. model_depth, multiple, sigma, bandpass, class_type))
  259. self.save_plots(y_true, y_pred, user, label, model_depth, bandpass, window_size_samples, model_type, cnn, class_type)
  261. print("Finished analysis on User {0}_{1}".format(user,label))
  262. print("Finished analysis on User {0}".format(user))
  264. results = pd.DataFrame(results)
  265. results.to_csv("results/bulk/shallow_deep_performance_window_size_{0}_per_user_model_type_{1}bandpass_{3}_class-type{3}.csv".format(window_size_samples, model_type, bandpass, class_type), index=False )
  266. final_duration = time.time()- time_original
  267. print("All analyses are complete! Time elapsed: {0}".format(final_duration))
  268. return results
  270. def run_cross_user_sd(self, model_type, bandpass, class_type):
  272. multiple = None
  273. sigma = None
  275. model_depths = ['deep','shallow']
  276. for model_depth in model_depths:
  278. time_original = time.time()
  280. window_size_samples = 120
  282. n_epochs = 100
  283. results = []
  284. labels = ['attention','interest','effort']
  286. saved_file = "saved user and test data/all_users_sampled_{0}_window_annotated_EEG_agg_bandpass_{1}_slider_{0}.pickle".format(window_size_samples, bandpass)
  287. all_tests_agg = load_file(saved_file)
  288. users = all_tests_agg.keys()
  289. user ='all'
  290. torch.backends.cudnn.benchmark = True
  292. for label in labels:
  293. print("Running - Model_type: {4}, ClassType:{3}, Model: {0}, User: {1}, label: {2}".format(model_depth, user,label, class_type, model_type))
  295. time_start = time.time()
  298. # convert the inputs into #samples, channels, #timepoints format
  299. X = np.array([all_tests_agg[user]['inputs'].transpose(0,2,1).astype(np.float32) for user in all_tests_agg])
  300. y = np.array([all_tests_agg[user][label] for user in all_tests_agg])
  302. # train and make predictions
  303. r, y_pred, y_true, num_classes, size, cnn = self.kfold_predict(X,y, model_type, n_epochs, model_depth,class_type)
  305. # get results
  306. duration = time.time() - time_start
  307. results.append(collate_results(r, user, label, duration,
  308. num_classes, size, model_type,
  309. n_epochs, window_size_samples,
  310. model_depth, multiple, sigma, bandpass, class_type))
  312. #save plots
  313. self.save_plots(y_true, y_pred, user, label, model_depth, bandpass, window_size_samples, model_type, cnn,class_type)
  316. print("Finished analysis on label {0}".format(label))
  317. print("Finished analysis on User {0}".format(user))
  318. results = pd.DataFrame(results)
  319. results.to_csv("results/CNN/{3}/tabulated/k fold/{1}/{1}CNN_Valid_performance_window_size_{0}_cross_user_bandpass_{2}_classtype_{4}.csv".format(window_size_samples ,
  320. model_depth,bandpass, model_type, class_type), index=False )
  321. final_duration = time.time()- time_original
  322. print("All analyses are complete! Time elapsed: {0}".format(final_duration))
  324. return results
  326. def run_shallow_deep(self):
  327. if self.eval_type == 'per user':
  328. results = self.run_per_user_sd(self.model_type, self.bandpass, self.class_type)
  329. return results
  330. elif self.eval_type == 'cross user':
  331. results = self.run_cross_user_sd(self.model_type, self.bandpass,self.class_type)
  332. return results
  333. elif self.eval_type == 'both':
  335. results = []
  336. results.append(self.run_cross_user_sd(self.model_type, self.bandpass))
  337. results.append(self.run_per_user_sd(self.model_type, self.bandpass))
  339. results = pd.concat(results)
  340. return results
  342. sd2 =ShallowDeep('clf', False, 'cross user', 'binary')
  343. sd2.run_shallow_deep()

ShallowDeep.ipynb at commit 2309398, no license · at the source

Overview

Authors: Yuwen Zhang1
  1. Zhengzhou Normal University, Zhengzhou, Henan, China
Institutions: Zhengzhou Normal University (China)
Journal: Frontiers in psychology, volume 17, article 1774068
Dates: received 23 December 2025; accepted 18 May 2026; published online 15 June 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.3389/fpsyg.2026.1774068 · PMID 42376149 · PMCID PMC13311114 · OpenAlex W7164800854
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: EEG (modality), cognitive (subfield)
Methods: Spectral & time-frequency, Preprocessing, Smoothing, state filtering, decompositions, Statistics, Machine learning
Keywords: attention mechanisms, cognitive load tracking, EEG signal analysis, Korean phoneme recognition, uncertainty quantification
Topic: EEG and Brain-Computer Interfaces (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Citations: not cited yet (Europe PMC); 39 references in the paper

Abstract

Introduction: Cognitive load tracking in Korean phoneme recognition presents significant changes due to the intricate spatiotemporal dynamics of EEG signals and the inherent variability in cognitive states. Traditional methods often struggle with these complexities, leading to suboptimal performance in accurately modeling cognitive load. This paper introduces an innovative framework, the Adaptive EEG Attention Trac, designed to overcome these limitations by leveraging attention-augmented EEG signals.

Methods: The proposed methodology comprises three integral components: the Manifold Constrained Signal Encoding, the Agent-driven Temporal Attention Routing, and the Uncertainty-aware Cognitive Load Prediction. The encoder is responsible for transforming raw EEG signals into a compact latent representation while adhering to manifold constraints, thereby ensuring structural fidelity. The attention router dynamically allocates focus across temporal segments, enhancing both interpretability and relevance of the signals. The predictor incorporates uncertainty quantification, which is crucial for providing robust estimations of cognitive load. Furthermore, the Uncertainty Propagation Adjustment strategy is introduced to explicitly model and propagate uncertainty throughout the computational pipeline, thereby refining predictions and enhancing reliability.

Results and discussion: Experimental results substantiate the efficacy of the proposed framework, demonstrating its capability to accurately track cognitive load during Korean phoneme recognition tasks. This advancement significantly contributes to the field of EEG-based cognitive modeling, offering a more reliable and interpretable approach to understanding cognitive processes.

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

Khalizo/Deep-Learning-Detection-Of-EEG-Based-Attention

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 230939815ae58c75fdf5baf27a5954d559fef5b5, 7 February 2023
Languages: Jupyter (30), Python (10)
Size: 4,981 files, 40 scripts
Software Heritage: not archived
Found in: the resources table
Holds: README, environment (requirements.txt), 15 notebooks
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (34 files), Matplotlib (22 files), scikit-learn (22 files), pandas (18 files), PyTorch (14 files), MNE-Python (10 files), SciPy (10 files), TensorFlow (10 files), Braindecode (6 files), Keras (5 files), h5py (3 files), pyRiemann (3 files), LightGBM (2 files), seaborn (2 files), XGBoost (2 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
41 files
At the source: github.com/Khalizo/Deep-Learning-Detection-Of-EEG-Based-Attention

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;
  • 40 scripts, each with its path and the digest of its content;
  • 9 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 original contributions presented in the study are included in the article/supplementary material, further inquiries can be directed to the corresponding author.

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

Versions

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

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, pages, dates, 1 author, 5 keywords, 25 references.

Cite

This paper

Zhang, Y. (2026). Analysis of cognitive mechanisms in phoneme perception and pronunciation errors among Korean language learners. Frontiers in psychology, 17, 1774068. https://doi.org/10.3389/fpsyg.2026.1774068

BibTeX

@article{zhang2026analysis,
author = {Zhang, Yuwen},
title = {{Analysis of cognitive mechanisms in phoneme perception and pronunciation errors among Korean language learners}},
journal = {Frontiers in psychology},
year = {2026},
month = jun,
volume = {17},
pages = {1774068},
publisher = {Frontiers Media SA},
issn = {1664-1078},
doi = {10.3389/fpsyg.2026.1774068},
url = {https://doi.org/10.3389/fpsyg.2026.1774068},
pmid = {42376149},
pmcid = {PMC13311114}
}

RIS

TY - JOUR
AU - Zhang, Yuwen
TI - Analysis of cognitive mechanisms in phoneme perception and pronunciation errors among Korean language learners
T2 - Frontiers in psychology
J2 - Front Psychol
PY - 2026
DA - 2026/06/15
VL - 17
SP - 1774068
SN - 1664-1078
PB - Frontiers Media SA
DO - 10.3389/fpsyg.2026.1774068
UR - https://doi.org/10.3389/fpsyg.2026.1774068
LA - en
ER -

CSL-JSON

{
"id": "10.3389/fpsyg.2026.1774068",
"type": "article-journal",
"title": "Analysis of cognitive mechanisms in phoneme perception and pronunciation errors among Korean language learners",
"container-title": "Frontiers in psychology",
"author": [
{
"family": "Zhang",
"given": "Yuwen"
}
],
"container-title-short": "Front Psychol",
"volume": "17",
"page": "1774068",
"DOI": "10.3389/fpsyg.2026.1774068",
"PMID": "42376149",
"PMCID": "PMC13311114",
"ISSN": "1664-1078",
"publisher": "Frontiers Media SA",
"URL": "https://doi.org/10.3389/fpsyg.2026.1774068",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
15
]
]
}
}

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.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: Braindecode, pyRiemann, MNE-Python, 8 other tools, EEG, 1 reference
[2] doi:10.3390/s26175327 [code]
Subject Identity Confounds qEEG Emotion Recognition on DEAP and DREAMER.
Journal: Sensors (Basel, Switzerland)
In common: pyRiemann, XGBoost, Keras, 8 other tools, EEG, cognitive
[3] doi:10.1371/journal.pgen.1012242 [code]
Wiz regulates clustered protocadherin genes by restricting CTCF/cohesin loop extrusion in a genomic-distance biased manner.
Journal: PLoS genetics
In common: LightGBM, XGBoost, Keras, 8 other tools
[4] doi:10.3389/fnhum.2026.1869918 [code]
Single-subject auditory ERP-BCI performance enhancement in ALS via an AI coding assistant prompt.
Journal: Frontiers in human neuroscience
In common: pyRiemann, LightGBM, XGBoost, 6 other tools, EEG
[5] doi:10.7554/elife.110588 [code]
Opening the black box toward a modular approach to spike sorting.
Journal: eLife
In common: LightGBM, XGBoost, TensorFlow, 8 other tools
[6] 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: Keras, MNE-Python, TensorFlow, 8 other tools, EEG
[7] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: XGBoost, Keras, TensorFlow, 7 other tools
[8] doi:10.1371/journal.pcbi.1014615 [code]
Toward reliable machine learning models for neural circuit inference: A diagnostic study of CNNs on spike trains.
Journal: PLoS computational biology
In common: XGBoost, Keras, TensorFlow, 7 other tools
[9] doi:10.1038/s41598-026-48613-0 [code]
An snRNA-seq aging clock for the fruit fly head sheds light on sex-biased aging.
Journal: Scientific reports
In common: XGBoost, Keras, TensorFlow, 7 other tools
[10] doi:10.1038/s41467-026-75455-1 [code]
Shared latent representations of speech production for cross-patient speech decoding.
Journal: Nature communications
In common: Keras, TensorFlow, h5py, 7 other tools, cognitive

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.