OSCR

Spiking neural networks provide accurate and time-efficient models for whisker stimulus classification of the awake mouse.

Code ↔ Paper

3 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 3 matches
  1. [1] § Results › Setup of machine learning classifier benchmark ↔ analysis_ML/benchmark.py, lines 1–73 · score 0.76 · Decision Tree, Random Forest, logistic regression, XGB, DT, RF
  2. [2] § Results › Imbalanced data and model calibration ↔ analysis_ML/benchmark.py, lines 248–322 · score 0.64 · Precision Recall curves, loss, imbalance, Brier, Platt, probabilities
  3. [3] § Results › Imbalanced data and model calibration ↔ analysis_ML/benchmark.py, lines 248–322 · score 0.51 · Precision Recall curve, imbalanced, Platt, ROC, model

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

  1. from sys import path, argv
  3. import os
  4. os.environ['OPENBLAS_NUM_THREADS'] = '1'
  5. os.environ['MKL_NUM_THREADS'] = '1'
  7. import random
  8. import numpy as np
  9. import pandas as pd
  10. from sys import *
  11. import pickle
  12. import time
  13. from copy import deepcopy
  14. import utils as utils
  16. from sklearn.ensemble import RandomForestClassifier
  17. from sklearn.tree import DecisionTreeClassifier
  18. from sklearn.linear_model import LogisticRegression
  19. from xgboost import XGBClassifier
  20. from sklearn.model_selection import StratifiedKFold, train_test_split
  21. from sklearn.metrics import roc_auc_score, accuracy_score, brier_score_loss, confusion_matrix
  22. from sklearn.metrics import average_precision_score, precision_recall_curve, auc
  23. from sklearn.preprocessing import MinMaxScaler
  24. from sklearn.model_selection import GridSearchCV
  26. import warnings
  27. warnings.filterwarnings("ignore")
  29. path.insert(1, os.path.join(path[0], '../'))
  31. SEED = 248
  33. clf_map = {}
  34. clf_map['RF'] = RandomForestClassifier()
  35. clf_map['GLM'] = LogisticRegression()
  36. clf_map['XGB'] = XGBClassifier()
  37. clf_map['DT'] = DecisionTreeClassifier()
  39. nots_clfs = set(['GBM','XGB','RF','GLM','LSM','DT'])
  40. tsclf_algos = set(['MiRo'])
  41. sklike = set(['GBM','XGB','RF','GLM','MiRo','DT'])
  43. '''
  44. keep should be either "all" or "si0n100"
  45. label is either "RP" or "SD"
  46. feat is either "RAW" or "FFT"
  47. testing use "TEST" or "REAL"
  49. example run:
  50. python benchmark.py 21 all L6 SD peri RAW DT REAL
  52. '''
  54. mouse, keep, layer, label, window, feat, algo, balance, calibration, tdt, testing = argv[1:]
  55. int_mouse = int(mouse)
  56. print(keep, label, window, feat, sep='\t')
  58. calib_bool = calibration == 'cal'
  60. meta = pd.read_csv('../datasets/meta_with_header.csv')
  61. meta['RP'] = meta['response']
  62. meta['SD'] = [0 if si == 0 else 1 for si in meta['stimulus_intensity']]
  64. selected_SIs = []
  65. if keep.startswith('si'):
  66. temp = keep.replace('si','')
  67. selected_SIs = set( map(int, temp.split('n') ) )
  68. print('Keep only these intesities:', ','.join(map(str, selected_SIs)))
  69. meta = meta.loc[ [si in selected_SIs for si in meta['stimulus_intensity'] ] ].copy()
  71. if label == 'SiD':
  72. selected_SIs = list(sorted(list(selected_SIs)))
  73. meta[label] = [ selected_SIs.index[si] for si in meta['stimulus_intensity'] ]
  75. # keep only the OK trials
  76. meta = meta.loc[meta['KICK_IT'] == 0]
  78. # load the dataset and keep it as a simple non-TS dataset
  79. # later the columns are merged into Series for algos like MiRo
  80. # do the layer selection directly!
  81. features = None
  82. if feat.startswith('RAW'):
  83. features = pd.read_csv('../datasets/%s%s.csv'%(window, 'RAW'))
  84. else:
  85. features = pd.read_csv('../datasets/%s%s.csv'%(window, feat))
  87. if layer != 'all':
  88. keep_cols = list( filter(lambda x: layer in x, features.columns) )
  89. features = features[keep_cols]
  91. # check if this is a case with only part of "peri"
  92. if feat.startswith('RAW') and feat != 'RAW':
  93. if window != 'peri':
  94. print('Not sure if I should run this!')
  95. exit(-1)
  96. start, end = tuple(map(int,feat[3:].split('to')))
  97. keep_cols = [ '%s%s_ms%d'%(window,layer,ms) for ms in range(start, end+1) ]
  98. #print('\nCutting the TS from %d to %d, using these columns only:'%(start, end))
  99. #print(keep_cols[:5], '...', keep_cols[-5:])
  100. #print('Keeping %d time points\n'%(len(keep_cols)))
  101. features = features[keep_cols]
  103. # create main output path, check if exists, set up testing mode
  104. grids = utils.prep_grids() # load the grids
  105. the_grid = grids.get(algo,None)
  107. if algo.startswith('LSM'):
  108. import lsm_utils as lsm_utils
  109. the_grid = grids['LSM']
  110. if algo.startswith('MiRo'):
  111. from sktime.classification.kernel_based import RocketClassifier
  112. the_grid = grids['MiRo']
  113. clf_map['MiRo'] = RocketClassifier()
  114. clf_map[algo] = RocketClassifier()
  116. scores_fp = './output/scores/M%s.csv'%('_'.join(argv[1:]))
  117. probas_fp = './output/probas/M%s.pkl'%('_'.join(argv[1:]))
  118. preds_fp = './output/preds/M%s.pkl'%('_'.join(argv[1:]))
  119. bs_cvres_fp_BASE = './output/cv_results/M%s.csv'%('_'.join(argv[1:]))
  121. if algo.startswith('LSM') or algo.startswith('MiRo'):
  122. scores_fp = scores_fp.replace('./output/', './output/parts/')
  123. probas_fp = probas_fp.replace('./output/', './output/parts/')
  124. preds_fp = preds_fp.replace('./output/', './output/parts/')
  126. if os.path.exists('/mnt/c/Users/albre/'):
  127. scores_fp = scores_fp.replace('./output/','./local_output/')
  128. probas_fp = probas_fp.replace('./output/','./local_output/')
  129. preds_fp = preds_fp.replace('./output/','./local_output/')
  130. bs_cvres_fp_BASE = bs_cvres_fp_BASE.replace('./output/','./local_output/')
  132. # testing does only work with DT as algorithm
  133. if testing == 'TEST':
  134. the_grid = {'criterion': ['gini', 'entropy'], 'max_depth': [3,4]}
  135. else:
  136. if os.path.exists(scores_fp):
  137. print('Should be done already:', scores_fp)
  138. exit(0)
  139. # check if the run is "valid", MiRo can't do FFT!
  140. if algo in tsclf_algos and feat == 'FFT':
  141. print('The combi %s and %s does not work...'%(algo, feat))
  142. exit(0)
  143. # used to simply get some first info but not running anything
  144. if testing == 'STOP':
  145. exit(0)
  147. # prepare output data structures
  148. preds, probas = [], []
  149. scores = {'mouse':[], 'BS':[], 'keep':[], 'layer':[], 'label':[], 'window':[], 'feat':[],
  150. 'algo':[], 'bal':[], 'auROC':[], 'ACC':[], 'auPRC':[], 'AP':[], 'ClaBal':[], 'BRIER':[]}
  151. scores.update( {'time_tr':[], 'time_tr_ps':[], 'time_infer':[], 'time_infer_ps':[]} )
  153. # repeat for 10 bootstraps
  154. for bs in range(10):
  155. bs_cvres_fp = bs_cvres_fp_BASE.replace('M%s_'%(mouse), 'M%s_BS%d_'%(mouse,bs))
  157. # create a stecific SEED for each boostrap
  158. bs_SEED = ((bs+1) * SEED) * SEED
  159. random.seed(bs_SEED)
  160. # split here by mouse
  161. meta_train = meta.loc[meta['mouse'] != int_mouse].copy()
  162. meta_test = meta.loc[meta['mouse'] == int_mouse].copy()
  164. if balance == 'bal':
  165. meta_train = utils.balance_data(meta_train, label)
  166. meta_test = utils.balance_data(meta_test, label)
  168. train_idx = list(meta_train.index)
  169. test_idx = list(meta_test.index)
  171. # get the features X for the sklearn functions
  172. X_train = features.iloc[train_idx]
  173. X_test = features.iloc[test_idx]
  174. # get the labels y for the sklearn functions
  175. y_train = np.array(meta.loc[train_idx][label])
  176. y_test = np.array(meta.loc[test_idx][label])
  178. # JUST to get the number of trials available for the different mice:
  179. print('TRAIN: ', X_train.shape, meta_train.shape, y_train.shape, ' \t- %.3f'%(np.mean(y_train)))
  180. print('TEST: ', X_test.shape, meta_test.shape, y_test.shape, ' \t- %.3f'%(np.mean(y_test)))
  181. print()
  183. # make sure that the index in the DataFrame is simple
  184. X_train.index = pd.RangeIndex(start=0, stop=X_train.shape[0], step=1)
  185. X_test.index = pd.RangeIndex(start=0, stop=X_test.shape[0], step=1)
  187. # bootstrap indices and create a specific X_train
  188. bs_indices = list(sorted(random.choices(list(X_train.index),k=X_train.shape[0])))
  189. X_bs_train = X_train.iloc[bs_indices]
  190. X_bs_train.index = pd.RangeIndex(start=0, stop=X_bs_train.shape[0], step=1)
  191. y_bs_train = y_train[bs_indices]
  193. mmscaler = MinMaxScaler()
  194. mmscaler.fit(X_bs_train)
  195. X_bs_train = mmscaler.transform(X_bs_train)
  196. X_test = mmscaler.transform(X_test)
  197. X_bs_train = pd.DataFrame(X_bs_train, columns=X_train.columns)
  198. X_test = pd.DataFrame(X_test, columns=X_train.columns)
  200. if algo in tsclf_algos or algo.startswith('MiRo'):
  201. X_bs_train = utils.make_Series_df(X_bs_train)
  202. X_test = utils.make_Series_df(X_test)
  204. # the whole grid search starts here:
  205. y_pred, auROC, ACC, prob, auPRC, AP, BRIER = None, None, None, None, None, None, None
  206. train_time, infer_time, cv_results = None, None, None
  207. n_splits, dec_threshold = 3, 0.5
  208. scoring = ['accuracy','roc_auc']
  210. if algo.startswith('LSM'):
  211. lsm_bs = int(algo.replace('LSM',''))
  212. if bs != lsm_bs:
  213. continue
  214. bs_cvres_fp = bs_cvres_fp.replace(algo,'LSM')
  215. cv_results, prob, dec_threshold, train_time, infer_time = lsm_utils.run_grid_and_apply(X_bs_train,
  216. X_test, y_bs_train, n_splits, bs_SEED, scoring, the_grid, calib_bool)
  217. else:
  218. if algo.startswith('MiRo'):
  219. miro_bs = int(algo.replace('MiRo',''))
  220. print('Doing extra stuff for MiRo!')
  221. print('Skip all BS but', miro_bs)
  222. if bs != miro_bs:
  223. continue
  224. bs_cvres_fp = bs_cvres_fp.replace(algo,'MiRo')
  226. clf = deepcopy( clf_map[algo] )
  227. skf = StratifiedKFold(n_splits=n_splits, random_state=bs_SEED, shuffle=True)
  229. gscv = GridSearchCV(clf, the_grid, scoring=['accuracy','roc_auc'], refit='accuracy', cv=skf, n_jobs=1)
  231. train_time, infer_time = 0.0, 0.0
  232. prob = []
  234. # add the calibration
  235. if calib_bool:
  236. Xcal_train, Xcal_test, yCal_train, yCal_test = train_test_split(X_bs_train, y_bs_train,
  237. test_size=0.33, stratify=y_bs_train, random_state=bs_SEED*42)
  238. start_time = time.time()
  239. gscv.fit(Xcal_train, yCal_train)
  240. Xprobs = list( gscv.predict_proba(Xcal_test)[:,1] )
  241. Xprobs = np.array( Xprobs ).reshape(-1, 1)
  242. yprobs = np.array(yCal_test)
  243. train_time = time.time() - start_time
  245. platt_calib = LogisticRegression(solver="lbfgs")
  246. platt_calib.fit(Xprobs, yprobs)
  248. # apply model on testing data
  249. start_time = time.time()
  250. prob_uncal = list( gscv.predict_proba(X_test)[:,1] )
  251. prob_uncal = np.array(prob_uncal).reshape(-1, 1)
  252. prob = platt_calib.predict_proba(prob_uncal)[:, 1]
  253. infer_time = time.time() - start_time
  254. else:
  255. start_time = time.time()
  256. gscv.fit(X_bs_train, y_bs_train)
  257. train_time = time.time() - start_time
  259. start_time = time.time()
  260. prob_pred = gscv.predict_proba(X_test)
  261. prob = list(prob_pred[:,1])
  262. infer_time = time.time() - start_time
  264. cv_results = pd.DataFrame(gscv.cv_results_)
  266. # end of grid search, model applied, inference done...
  267. print('Done with BS %d... CV Results will be here:'%(bs))
  268. print(bs_cvres_fp, '\n')
  269. cv_results.to_csv(bs_cvres_fp, index=False)
  271. dec_threshold = 0.5
  273. # from here it is all the same to have a standardized output
  274. y_pred = [1 if p > dec_threshold else 0 for p in prob]
  275. auROC = roc_auc_score(y_test, prob)
  276. ACC = accuracy_score(y_test, y_pred)
  278. # adding average precision and auPRC for the imbalanced cases
  279. precision, recall, thresh = precision_recall_curve(y_test, prob)
  280. auPRC = auc(recall, precision)
  281. AP = average_precision_score(y_test, prob)
  282. BRIER = brier_score_loss(y_test, prob)
  284. scores['mouse'].append( mouse )
  285. scores['BS'].append( bs )
  286. scores['auROC'].append( auROC )
  287. scores['ACC'].append( ACC )
  288. scores['auPRC'].append( auPRC )
  289. scores['AP'].append( AP )
  290. scores['ClaBal'].append( np.mean(y_test) )
  291. scores['BRIER'].append( BRIER )
  292. scores['time_tr'].append(train_time)
  293. scores['time_tr_ps'].append(train_time/X_bs_train.shape[0]*100)
  294. scores['time_infer'].append(infer_time)
  295. scores['time_infer_ps'].append(infer_time/X_test.shape[0]*100)
  297. scores['keep'].append( keep ); scores['layer'].append( layer );
  298. scores['label'].append( label ); scores['window'].append( window );
  299. scores['feat'].append( feat ); scores['algo'].append( algo );
  300. scores['bal'].append( balance )
  302. tn, fp, fn, tp = confusion_matrix(y_test, y_pred).ravel().tolist()
  303. cm_str = '\n%d\t%d\n%d\t%d\n'%(tp, fp, fn, tn)
  305. probas.append(prob)
  306. preds.append(y_pred)
  309. scores = pd.DataFrame(scores)
  310. print(scores)
  312. scores.to_csv(scores_fp, index=False)
  313. print('Saved scores into:\n'+scores_fp)
  315. '''
  316. pickle.dump(probas, open(probas_fp, 'wb'))
  317. pickle.dump(preds, open(preds_fp, 'wb'))
  318. '''
  320. print()
  321. print('Mean auROC: %.5f'%(scores['auROC'].mean()))
  322. print('Mean ACC: %.5f'%(scores['ACC'].mean()))

benchmark.py at commit a0be3fd, no license · at the source

Overview

Authors: Steffen Albrecht1, Jens R. Vandevelde1, Edoardo Vecchi2, Gabriele Berra2, Davide Bassetti3, Maik C. Stüttgen4, Heiko J. Luhmann1, Illia Horenko3
  1. Institute of Physiology, University Medical Center of the Johannes Gutenberg University Mainz, Mainz, Germany
  2. Undergraduate Education (FBDTI), Department of Innovative Technologies, University of Applied Sciences and Arts of Southern Switzerland, Lugano-Viganello, Switzerland
  3. Department of Mathematics, Artificial Intelligence in Mathematics, TU Kaiserslautern, Kaiserslautern, Germany
  4. Institute of Pathophysiology, University Medical Center of the Johannes Gutenberg University Mainz, Mainz, Germany
Institutions: Johannes Gutenberg University Mainz (Germany); University Medical Center of the Johannes Gutenberg University Mainz (Germany); University of Applied Sciences and Arts of Southern Switzerland (Switzerland); University of Kaiserslautern (Germany)
Journal: Frontiers in neuroscience, volume 20, article 1605209
Dates: received 3 April 2025; accepted 13 March 2026; published online 1 April 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.3389/fnins.2026.1605209 · PMID 41994573 · PMCID PMC13079647 · OpenAlex W7147374444
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: extracellular electrophysiology (units, LFP) (modality), mouse (organism), computational (subfield)
Methods: Spectral & time-frequency, Preprocessing, Connectivity, Machine learning, fMRI & imaging
Keywords: electrophysiology, local field potential, machine learning, neural prosthesis, neuroprosthetics, spiking neural networks, whisker stimulus classification
Topic: Advanced Memory and Neural Computing (Electrical and Electronic Engineering, Engineering), according to OpenAlex
Funding: Deutsche Forschungsgemeinschaft (STU 544/3-1)
Citations: not cited yet (Europe PMC); 76 references in the paper

Abstract

Machine learning algorithms have great potential for classifying brain activity, and lightweight classifier algorithms, requiring little computational resources, can be used on low-energy neuromorphic hardware designed for implantable neuroprosthetics. One of these efficient algorithms, the Liquid State Machine, implements the concept of Spiking Neural Networks and has been shown to achieve outstanding results on the task of whisker stimulus detection from the mouse barrel cortex, a widely used model system. While this is promising for neuroprosthetics, it has been unclear how a Spiking Neural Network or other machine learning algorithms perform on data recorded from awake mice and how trained models generalize across individuals, the latter being relevant to transferring trained models to new hardware. Using laminar multi-electrode local field potential recordings obtained from four mice performing a single-whisker detection task, we benchmarked the performance of a collection of lightweight classification algorithms. We found that the Liquid State Machine, a generalized linear model, and the time series classifier ROCKET are the most accurate for stimulus detection. Among those, the Liquid State Machine achieved the fastest model training and inference runtime and provided robust accuracy across individual mice. Additional analyses show that there is no significant improvement in using multiple cortical layers as input for the model and that 40 ms of stimulus recording is sufficient to maintain high detection accuracy.

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

IGITUGraz/LSM

License: GPL-3.0
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: 0b8783b161b2e2f8fa521a6a62ddd33f473b2d76, 6 November 2020
Languages: Python (6), Shell (1)
Size: 11 files, 7 scripts
Software Heritage: not archived
Found in: the text, “Soft- and hardware specifications”
Holds: README, license file, environment (setup.py)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (5 files), NEST Simulator (3 files), Matplotlib (1 file), SciPy (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
9 files
At the source: github.com/IGITUGraz/LSM

gitlab.rlp.net/salbrec/sdrpml

License: none: the authors keep all their rights
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: a0be3fd0c5954d2f579208f4cba85c0859868925, 18 April 2026
Languages: Python (10), MATLAB (1)
Size: 51 files, 11 scripts
Software Heritage: not archived
Found in: “Data availability statement”
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (6 files), scikit-learn (5 files), pandas (4 files), NEST Simulator (2 files), Signal Processing Toolbox (1 file), Matplotlib (1 file), SciPy (1 file), XGBoost (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
12 files
At the source: gitlab.rlp.net/salbrec/sdrpml.git

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:

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

No dataset and no data link were found in the paper.

Data availability statement

The datasets used, and the Python code performing the ML benchmark are publicly available in a gitlab repository: https://gitlab.rlp.net/salbrec/sdrpml.git.

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

  • Funding: added Deutsche Forschungsgemeinschaft: STU 544/3-1

Version 1, 28 September 2026: the first record

Recorded: type, language, journal, volume, pages, dates, 8 authors, 7 keywords, 60 references.

Cite

This paper

Albrecht, S., Vandevelde, J. R., Vecchi, E., Berra, G., Bassetti, D., Stüttgen, M. C., Luhmann, H. J., & Horenko, I. (2026). Spiking neural networks provide accurate and time-efficient models for whisker stimulus classification of the awake mouse. Frontiers in neuroscience, 20, 1605209. https://doi.org/10.3389/fnins.2026.1605209

BibTeX

@article{albrecht2026spiking,
author = {Albrecht, Steffen and Vandevelde, Jens R. and Vecchi, Edoardo and Berra, Gabriele and Bassetti, Davide and Stüttgen, Maik C. and Luhmann, Heiko J. and Horenko, Illia},
title = {{Spiking neural networks provide accurate and time-efficient models for whisker stimulus classification of the awake mouse}},
journal = {Frontiers in neuroscience},
year = {2026},
month = apr,
volume = {20},
pages = {1605209},
publisher = {Frontiers Media SA},
issn = {1662-4548},
doi = {10.3389/fnins.2026.1605209},
url = {https://doi.org/10.3389/fnins.2026.1605209},
pmid = {41994573},
pmcid = {PMC13079647}
}

RIS

TY - JOUR
AU - Albrecht, Steffen
AU - Vandevelde, Jens R.
AU - Vecchi, Edoardo
AU - Berra, Gabriele
AU - Bassetti, Davide
AU - Stüttgen, Maik C.
AU - Luhmann, Heiko J.
AU - Horenko, Illia
TI - Spiking neural networks provide accurate and time-efficient models for whisker stimulus classification of the awake mouse
T2 - Frontiers in neuroscience
J2 - Front Neurosci
PY - 2026
DA - 2026/04/01
VL - 20
SP - 1605209
SN - 1662-4548
PB - Frontiers Media SA
DO - 10.3389/fnins.2026.1605209
UR - https://doi.org/10.3389/fnins.2026.1605209
LA - en
ER -

CSL-JSON

{
"id": "10.3389/fnins.2026.1605209",
"type": "article-journal",
"title": "Spiking neural networks provide accurate and time-efficient models for whisker stimulus classification of the awake mouse",
"container-title": "Frontiers in neuroscience",
"author": [
{
"family": "Albrecht",
"given": "Steffen"
},
{
"family": "Vandevelde",
"given": "Jens R."
},
{
"family": "Vecchi",
"given": "Edoardo"
},
{
"family": "Berra",
"given": "Gabriele"
},
{
"family": "Bassetti",
"given": "Davide"
},
{
"family": "Stüttgen",
"given": "Maik C."
},
{
"family": "Luhmann",
"given": "Heiko J."
},
{
"family": "Horenko",
"given": "Illia"
}
],
"container-title-short": "Front Neurosci",
"volume": "20",
"page": "1605209",
"DOI": "10.3389/fnins.2026.1605209",
"PMID": "41994573",
"PMCID": "PMC13079647",
"ISSN": "1662-4548",
"publisher": "Frontiers Media SA",
"URL": "https://doi.org/10.3389/fnins.2026.1605209",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
1
]
]
}
}

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.7554/elife.109717 [code]
Retrosplenial cortex enables context-dependent goal-directed sensorimotor transformation.
Journal: eLife
In common: XGBoost, scikit-learn, pandas, 3 other tools, mouse, 3 references
[2] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: NEST Simulator, XGBoost, Signal Processing Toolbox, 5 other tools, mouse
[3] doi:10.7554/elife.110588 [code]
Opening the black box toward a modular approach to spike sorting.
Journal: eLife
In common: XGBoost, scikit-learn, pandas, 3 other tools, extracellular electrophysiology (units, LFP), mouse, 1 reference
[4] doi:10.7554/elife.107099 [code]
Local inhibitory dynamics underpin temporal integration and functional segregation between barrels and septa in the mouse barrel cortex.
Journal: eLife
In common: Signal Processing Toolbox, mouse, 4 references
[5] doi:10.1371/journal.pcbi.1014730 [code]
A unified model of short- and long-term plasticity: Effects on network connectivity and information capacity.
Journal: PLoS computational biology
In common: NEST Simulator, scikit-learn, pandas, 3 other tools, 1 reference
[6] doi:10.1038/s41467-026-71725-0 [code]
Interactions across hemispheres in prefrontal cortex reflect global cognitive processing.
Journal: Nature communications
In common: Signal Processing Toolbox, scikit-learn, pandas, 3 other tools, 2 references
[7] doi:10.64898/2026.03.12.710517 [code]
Cortical excitability inversely modulates fMRI connectivity via low-frequency neuronal coupling
Journal: bioRxiv (preprint)
In common: NEST Simulator, Signal Processing Toolbox, pandas, 3 other tools
[8] 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: XGBoost, scikit-learn, pandas, 3 other tools, mouse, 1 reference
[9] doi:10.1038/s41592-026-03154-2 [code]
Simultaneous single-cell calcium imaging of neuronal population activity and brain-wide BOLD fMRI.
Journal: Nature methods
In common: Signal Processing Toolbox, scikit-learn, pandas, 3 other tools, mouse, 1 reference
[10] doi:10.21203/rs.3.rs-9914920/v1 [code]
Prediction of cognitive performance by demographics, sleep, and brain morphometry: machine learning findings from ENIGMA-Sleep Working Group
Journal: Research Square (preprint)
In common: XGBoost, scikit-learn, pandas, 3 other tools, 1 reference

Contribute

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

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

Request its removal

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

Discussion, reproductions, activity

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

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

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