Spiking neural networks provide accurate and time-efficient models for whisker stimulus classification of the awake mouse.
2 blocks of code here have a permanent identifier (oscr:b:…), listed with the matches below: citable for good, with a page of its own. Select a match and press Cite to copy it. What a block identifier is.
The 3 matches
- [1] § Results › Setup of machine learning classifier benchmark ↔ analysis_ML/benchmark.py, lines 1 to 73 · score 0.76 · Decision Tree, Random Forest, logistic regression, XGB, DT, RF · block
oscr:b:1CM8GJWT9KB8R-H· Report a mismatch - [2] § Results › Imbalanced data and model calibration ↔ analysis_ML/benchmark.py, lines 248 to 322 · score 0.64 · Precision Recall curves, loss, imbalance, Brier, Platt, probabilities · block
oscr:b:QJNEQ2ATNSFFZ-8· Report a mismatch - [3] § Results › Imbalanced data and model calibration ↔ analysis_ML/benchmark.py, lines 248 to 322 · score 0.51 · Precision Recall curve, imbalanced, Platt, ROC, model · block
oscr:b:QJNEQ2ATNSFFZ-8· Report a mismatch
Paper
Loaded from Europe PMC by your browser; OSCR does not store it: 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
- from sys import path, argv
- import os
- os.environ['OPENBLAS_NUM_THREADS'] = '1'
- os.environ['MKL_NUM_THREADS'] = '1'
- import random
- import numpy as np
- import pandas as pd
- from sys import *
- import pickle
- import time
- from copy import deepcopy
- import utils as utils
- from sklearn.ensemble import RandomForestClassifier
- from sklearn.tree import DecisionTreeClassifier
- from sklearn.linear_model import LogisticRegression
- from xgboost import XGBClassifier
- from sklearn.model_selection import StratifiedKFold, train_test_split
- from sklearn.metrics import roc_auc_score, accuracy_score, brier_score_loss, confusion_matrix
- from sklearn.metrics import average_precision_score, precision_recall_curve, auc
- from sklearn.preprocessing import MinMaxScaler
- from sklearn.model_selection import GridSearchCV
- import warnings
- warnings.filterwarnings("ignore")
- path.insert(1, os.path.join(path[0], '../'))
- SEED = 248
- clf_map = {}
- clf_map['RF'] = RandomForestClassifier()
- clf_map['GLM'] = LogisticRegression()
- clf_map['XGB'] = XGBClassifier()
- clf_map['DT'] = DecisionTreeClassifier()
- nots_clfs = set(['GBM','XGB','RF','GLM','LSM','DT'])
- tsclf_algos = set(['MiRo'])
- sklike = set(['GBM','XGB','RF','GLM','MiRo','DT'])
- '''
- keep should be either "all" or "si0n100"
- label is either "RP" or "SD"
- feat is either "RAW" or "FFT"
- testing use "TEST" or "REAL"
- example run:
- python benchmark.py 21 all L6 SD peri RAW DT REAL
- '''
- mouse, keep, layer, label, window, feat, algo, balance, calibration, tdt, testing = argv[1:]
- int_mouse = int(mouse)
- print(keep, label, window, feat, sep='\t')
- calib_bool = calibration == 'cal'
- meta = pd.read_csv('../datasets/meta_with_header.csv')
- meta['RP'] = meta['response']
- meta['SD'] = [0 if si == 0 else 1 for si in meta['stimulus_intensity']]
- selected_SIs = []
- if keep.startswith('si'):
- temp = keep.replace('si','')
- selected_SIs = set( map(int, temp.split('n') ) )
- print('Keep only these intesities:', ','.join(map(str, selected_SIs)))
- meta = meta.loc[ [si in selected_SIs for si in meta['stimulus_intensity'] ] ].copy()
- if label == 'SiD':
- selected_SIs = list(sorted(list(selected_SIs)))
- meta[label] = [ selected_SIs.index[si] for si in meta['stimulus_intensity'] ]
- # keep only the OK trials
- meta = meta.loc[meta['KICK_IT'] == 0]
- # load the dataset and keep it as a simple non-TS dataset
- # later the columns are merged into Series for algos like MiRo
- # do the layer selection directly!
- features = None
- if feat.startswith('RAW'):
- features = pd.read_csv('../datasets/%s%s.csv'%(window, 'RAW'))
- else:
- features = pd.read_csv('../datasets/%s%s.csv'%(window, feat))
- if layer != 'all':
- keep_cols = list( filter(lambda x: layer in x, features.columns) )
- features = features[keep_cols]
- # check if this is a case with only part of "peri"
- if feat.startswith('RAW') and feat != 'RAW':
- if window != 'peri':
- print('Not sure if I should run this!')
- exit(-1)
- start, end = tuple(map(int,feat[3:].split('to')))
- keep_cols = [ '%s%s_ms%d'%(window,layer,ms) for ms in range(start, end+1) ]
- #print('\nCutting the TS from %d to %d, using these columns only:'%(start, end))
- #print(keep_cols[:5], '...', keep_cols[-5:])
- #print('Keeping %d time points\n'%(len(keep_cols)))
- features = features[keep_cols]
- # create main output path, check if exists, set up testing mode
- grids = utils.prep_grids() # load the grids
- the_grid = grids.get(algo,None)
- if algo.startswith('LSM'):
- import lsm_utils as lsm_utils
- the_grid = grids['LSM']
- if algo.startswith('MiRo'):
- from sktime.classification.kernel_based import RocketClassifier
- the_grid = grids['MiRo']
- clf_map['MiRo'] = RocketClassifier()
- clf_map[algo] = RocketClassifier()
- scores_fp = './output/scores/M%s.csv'%('_'.join(argv[1:]))
- probas_fp = './output/probas/M%s.pkl'%('_'.join(argv[1:]))
- preds_fp = './output/preds/M%s.pkl'%('_'.join(argv[1:]))
- bs_cvres_fp_BASE = './output/cv_results/M%s.csv'%('_'.join(argv[1:]))
- if algo.startswith('LSM') or algo.startswith('MiRo'):
- scores_fp = scores_fp.replace('./output/', './output/parts/')
- probas_fp = probas_fp.replace('./output/', './output/parts/')
- preds_fp = preds_fp.replace('./output/', './output/parts/')
- if os.path.exists('/mnt/c/Users/albre/'):
- scores_fp = scores_fp.replace('./output/','./local_output/')
- probas_fp = probas_fp.replace('./output/','./local_output/')
- preds_fp = preds_fp.replace('./output/','./local_output/')
- bs_cvres_fp_BASE = bs_cvres_fp_BASE.replace('./output/','./local_output/')
- # testing does only work with DT as algorithm
- if testing == 'TEST':
- the_grid = {'criterion': ['gini', 'entropy'], 'max_depth': [3,4]}
- else:
- if os.path.exists(scores_fp):
- print('Should be done already:', scores_fp)
- exit(0)
- # check if the run is "valid", MiRo can't do FFT!
- if algo in tsclf_algos and feat == 'FFT':
- print('The combi %s and %s does not work...'%(algo, feat))
- exit(0)
- # used to simply get some first info but not running anything
- if testing == 'STOP':
- exit(0)
- # prepare output data structures
- preds, probas = [], []
- scores = {'mouse':[], 'BS':[], 'keep':[], 'layer':[], 'label':[], 'window':[], 'feat':[],
- 'algo':[], 'bal':[], 'auROC':[], 'ACC':[], 'auPRC':[], 'AP':[], 'ClaBal':[], 'BRIER':[]}
- scores.update( {'time_tr':[], 'time_tr_ps':[], 'time_infer':[], 'time_infer_ps':[]} )
- # repeat for 10 bootstraps
- for bs in range(10):
- bs_cvres_fp = bs_cvres_fp_BASE.replace('M%s_'%(mouse), 'M%s_BS%d_'%(mouse,bs))
- # create a stecific SEED for each boostrap
- bs_SEED = ((bs+1) * SEED) * SEED
- random.seed(bs_SEED)
- # split here by mouse
- meta_train = meta.loc[meta['mouse'] != int_mouse].copy()
- meta_test = meta.loc[meta['mouse'] == int_mouse].copy()
- if balance == 'bal':
- meta_train = utils.balance_data(meta_train, label)
- meta_test = utils.balance_data(meta_test, label)
- train_idx = list(meta_train.index)
- test_idx = list(meta_test.index)
- # get the features X for the sklearn functions
- X_train = features.iloc[train_idx]
- X_test = features.iloc[test_idx]
- # get the labels y for the sklearn functions
- y_train = np.array(meta.loc[train_idx][label])
- y_test = np.array(meta.loc[test_idx][label])
- # JUST to get the number of trials available for the different mice:
- print('TRAIN: ', X_train.shape, meta_train.shape, y_train.shape, ' \t- %.3f'%(np.mean(y_train)))
- print('TEST: ', X_test.shape, meta_test.shape, y_test.shape, ' \t- %.3f'%(np.mean(y_test)))
- print()
- # make sure that the index in the DataFrame is simple
- X_train.index = pd.RangeIndex(start=0, stop=X_train.shape[0], step=1)
- X_test.index = pd.RangeIndex(start=0, stop=X_test.shape[0], step=1)
- # bootstrap indices and create a specific X_train
- bs_indices = list(sorted(random.choices(list(X_train.index),k=X_train.shape[0])))
- X_bs_train = X_train.iloc[bs_indices]
- X_bs_train.index = pd.RangeIndex(start=0, stop=X_bs_train.shape[0], step=1)
- y_bs_train = y_train[bs_indices]
- mmscaler = MinMaxScaler()
- mmscaler.fit(X_bs_train)
- X_bs_train = mmscaler.transform(X_bs_train)
- X_test = mmscaler.transform(X_test)
- X_bs_train = pd.DataFrame(X_bs_train, columns=X_train.columns)
- X_test = pd.DataFrame(X_test, columns=X_train.columns)
- if algo in tsclf_algos or algo.startswith('MiRo'):
- X_bs_train = utils.make_Series_df(X_bs_train)
- X_test = utils.make_Series_df(X_test)
- # the whole grid search starts here:
- y_pred, auROC, ACC, prob, auPRC, AP, BRIER = None, None, None, None, None, None, None
- train_time, infer_time, cv_results = None, None, None
- n_splits, dec_threshold = 3, 0.5
- scoring = ['accuracy','roc_auc']
- if algo.startswith('LSM'):
- lsm_bs = int(algo.replace('LSM',''))
- if bs != lsm_bs:
- continue
- bs_cvres_fp = bs_cvres_fp.replace(algo,'LSM')
- cv_results, prob, dec_threshold, train_time, infer_time = lsm_utils.run_grid_and_apply(X_bs_train,
- X_test, y_bs_train, n_splits, bs_SEED, scoring, the_grid, calib_bool)
- else:
- if algo.startswith('MiRo'):
- miro_bs = int(algo.replace('MiRo',''))
- print('Doing extra stuff for MiRo!')
- print('Skip all BS but', miro_bs)
- if bs != miro_bs:
- continue
- bs_cvres_fp = bs_cvres_fp.replace(algo,'MiRo')
- clf = deepcopy( clf_map[algo] )
- skf = StratifiedKFold(n_splits=n_splits, random_state=bs_SEED, shuffle=True)
- gscv = GridSearchCV(clf, the_grid, scoring=['accuracy','roc_auc'], refit='accuracy', cv=skf, n_jobs=1)
- train_time, infer_time = 0.0, 0.0
- prob = []
- # add the calibration
- if calib_bool:
- Xcal_train, Xcal_test, yCal_train, yCal_test = train_test_split(X_bs_train, y_bs_train,
- test_size=0.33, stratify=y_bs_train, random_state=bs_SEED*42)
- start_time = time.time()
- gscv.fit(Xcal_train, yCal_train)
- Xprobs = list( gscv.predict_proba(Xcal_test)[:,1] )
- Xprobs = np.array( Xprobs ).reshape(-1, 1)
- yprobs = np.array(yCal_test)
- train_time = time.time() - start_time
- platt_calib = LogisticRegression(solver="lbfgs")
- platt_calib.fit(Xprobs, yprobs)
- # apply model on testing data
- start_time = time.time()
- prob_uncal = list( gscv.predict_proba(X_test)[:,1] )
- prob_uncal = np.array(prob_uncal).reshape(-1, 1)
- prob = platt_calib.predict_proba(prob_uncal)[:, 1]
- infer_time = time.time() - start_time
- else:
- start_time = time.time()
- gscv.fit(X_bs_train, y_bs_train)
- train_time = time.time() - start_time
- start_time = time.time()
- prob_pred = gscv.predict_proba(X_test)
- prob = list(prob_pred[:,1])
- infer_time = time.time() - start_time
- cv_results = pd.DataFrame(gscv.cv_results_)
- # end of grid search, model applied, inference done...
- print('Done with BS %d... CV Results will be here:'%(bs))
- print(bs_cvres_fp, '\n')
- cv_results.to_csv(bs_cvres_fp, index=False)
- dec_threshold = 0.5
- # from here it is all the same to have a standardized output
- y_pred = [1 if p > dec_threshold else 0 for p in prob]
- auROC = roc_auc_score(y_test, prob)
- ACC = accuracy_score(y_test, y_pred)
- # adding average precision and auPRC for the imbalanced cases
- precision, recall, thresh = precision_recall_curve(y_test, prob)
- auPRC = auc(recall, precision)
- AP = average_precision_score(y_test, prob)
- BRIER = brier_score_loss(y_test, prob)
- scores['mouse'].append( mouse )
- scores['BS'].append( bs )
- scores['auROC'].append( auROC )
- scores['ACC'].append( ACC )
- scores['auPRC'].append( auPRC )
- scores['AP'].append( AP )
- scores['ClaBal'].append( np.mean(y_test) )
- scores['BRIER'].append( BRIER )
- scores['time_tr'].append(train_time)
- scores['time_tr_ps'].append(train_time/X_bs_train.shape[0]*100)
- scores['time_infer'].append(infer_time)
- scores['time_infer_ps'].append(infer_time/X_test.shape[0]*100)
- scores['keep'].append( keep ); scores['layer'].append( layer );
- scores['label'].append( label ); scores['window'].append( window );
- scores['feat'].append( feat ); scores['algo'].append( algo );
- scores['bal'].append( balance )
- tn, fp, fn, tp = confusion_matrix(y_test, y_pred).ravel().tolist()
- cm_str = '\n%d\t%d\n%d\t%d\n'%(tp, fp, fn, tn)
- probas.append(prob)
- preds.append(y_pred)
- scores = pd.DataFrame(scores)
- print(scores)
- scores.to_csv(scores_fp, index=False)
- print('Saved scores into:\n'+scores_fp)
- '''
- pickle.dump(probas, open(probas_fp, 'wb'))
- pickle.dump(preds, open(preds_fp, 'wb'))
- '''
- print()
- print('Mean auROC: %.5f'%(scores['auROC'].mean()))
- print('Mean ACC: %.5f'%(scores['ACC'].mean()))
benchmark.py at commit a0be3fd, no license · at the source
Overview
- Institute of Physiology, University Medical Center of the Johannes Gutenberg University Mainz, Mainz, Germany
- Undergraduate Education (FBDTI), Department of Innovative Technologies, University of Applied Sciences and Arts of Southern Switzerland, Lugano-Viganello, Switzerland
- Department of Mathematics, Artificial Intelligence in Mathematics, TU Kaiserslautern, Kaiserslautern, Germany
- Institute of Pathophysiology, University Medical Center of the Johannes Gutenberg University Mainz, Mainz, Germany
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
0b8783b161b2e2f8fa521a6a62ddd33f473b2d76, 6 November 2020Availability: 1 check, the latest on 28 September 2026: the link answers
- 28 September 2026: the link answers
9 files
- example.py, Python, 119 lines
- lsm/
__init__.py , Python, 1 line - lsm/
nest/ , Python, 144 lines__init__.py - lsm/
nest/ , Python, 15 linesutils.py - lsm/
utils.py , Python, 77 lines - setup.py, Python, 16 lines
- style-check.sh, Shell, 3 lines
- LICENSE, License, 674 lines
- README.md, Text, 18 lines
gitlab.rlp.net/salbrec/sdrpml
a0be3fd0c5954d2f579208f4cba85c0859868925, 18 April 2026Availability: 1 check, the latest on 28 September 2026: the link answers
- 28 September 2026: the link answers
12 files
- analysis_ML/
benchmark.py , Python, 340 lines, 3 matches - analysis_ML/
lsm/ , Python, 1 line__init__.py - analysis_ML/
lsm/ , Python, 144 linesnest/ __init__.py - analysis_ML/
lsm/ , Python, 15 linesnest/ utils.py - analysis_ML/
lsm/ , Python, 77 linesutils.py - analysis_ML/
lsm_utils.py , Python, 133 lines - analysis_ML/
make_runs.py , Python, 81 lines - analysis_ML/
make_runs_shorter_RAW.py , Python, 87 lines - analysis_ML/
utils.py , Python, 100 lines - datasets/
ts_to_classical_df.py , Python, 30 lines - preprocess_sessions.m, MATLAB, 507 lines
- README.md, Text, 6 lines
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://
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://
BibTeX
@article{albrecht2026spi
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/
url = {https://
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/
VL - 20
SP - 1605209
SN - 1662-4548
PB - Frontiers Media SA
DO - 10.3389/
UR - https://
LA - en
ER -
CSL-JSON
{
"id": "10.3389/
"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":
"volume": "20",
"page": "1605209",
"DOI": "10.3389/
"PMID": "41994573",
"PMCID": "PMC13079647",
"ISSN": "1662-4548",
"publisher": "Frontiers Media SA",
"URL": "https://
"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: eLifeIn 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 biologyIn common: NEST Simulator, XGBoost, Signal Processing Toolbox, 5 other tools, mouse
- [3] doi:10.1371/journal.pcbi.1011830 [code]
- Uncovering population contributions to the extracellular potential in the mouse visual system using Laminar Population Analysis.Journal: PLoS computational biologyIn common: scikit-learn, pandas, SciPy, 2 other tools, extracellular electrophysiology (units, LFP), mouse, 3 references
- [4] doi:10.7554/elife.87169 [code]
- Uncovering circuit mechanisms of current sinks and sources with biophysical simulations of primary visual cortex.Journal: eLifeIn common: scikit-learn, pandas, SciPy, 2 other tools, extracellular electrophysiology (units, LFP), mouse, 3 references
- [5] doi:10.1038/s41598-022-24156-y
- Effects of optogenetic inhibition of a small fraction of parvalbumin-positive interneurons on the representation of sensory stimuli in mouse barrel cortex.Journal: Scientific reportsIn common: extracellular electrophysiology (units, LFP), mouse, 5 references
- [6] doi:10.1038/s41467-025-56125-0 [code]
- Syngap1 promotes cognitive function through regulation of cortical sensorimotor dynamics.Journal: Nature communicationsIn common: scikit-learn, pandas, SciPy, 2 other tools, mouse, 3 references
- [7] doi:10.1371/journal.pcbi.1011625 [code]
- Metamodelling of a two-population spiking neural network.Journal: PLoS computational biologyIn common: NEST Simulator, scikit-learn, SciPy, 2 other tools, extracellular electrophysiology (units, LFP), computational, 1 reference
- [8] doi:10.1093/cercor/bhae405 [code]
- Reconciliation of weak pairwise spike-train correlations and highly coherent local field potentials across space.Journal: Cerebral cortex (New York, N.Y. : 1991)In common: NEST Simulator, pandas, SciPy, 2 other tools, extracellular electrophysiology (units, LFP), computational, 1 reference
- [9] doi:10.1523/eneuro.0435-22.2023 [code]
- Adaptation Shapes Local Cortical Reactivity: From Bifurcation Diagram and Simulations to Human Physiological and Pathological Responses.Journal: eNeuroIn common: NEST Simulator, Signal Processing Toolbox, SciPy, 2 other tools, computational, 1 reference
- [10] doi:10.7554/elife.82412 [code]
- Ultrafast (400 Hz) network oscillations induced in mouse barrel cortex by optogenetic activation of thalamocortical axons.Journal: eLifeIn common: extracellular electrophysiology (units, LFP), mouse, 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.
Claim this paper
Correct its record
Say what each link of this record is, remove the ones that are not the paper's, add the ones that are missing. The correction becomes a new version of the record, in its Versions section.
Validate its tracing map
You validate the map as this page shows it: 2 repositories of the authors' code, each at its verified commit and with its license, 18 scripts, and 3 matches between paragraphs and code (see the Code and Map sections). It then receives a DOI on Zenodo, with you (your ORCID iD) and OSCR as its creators; the code itself is not deposited.
The map's fingerprint: sha256:bd66c84a7ac9483e…
Add the badge to the code's README
If you are an author or a maintainer of this paper's code, you can add this badge. It says what OSCR knows of the paper (its code, its validated tracing map) and links the code to this page. Paste one of these snippets under the README's title. Keep the two marks around it, so that the badge can be replaced in place and is never added twice. OSCR changes nothing in your repository.
Markdown
<!-- oscr-badge:start -->
[](https://openscicode.org/badge/doi/10.3389/fnins.2026.1605209)
<!-- oscr-badge:end -->reStructuredText
.. oscr-badge:start
.. image:: https://openscicode.org/badge/doi/10.3389/fnins.2026.1605209.svg
:target: https://openscicode.org/badge/doi/10.3389/fnins.2026.1605209
:alt: OSCR
.. oscr-badge:endHTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.3389/fnins.2026.1605209"><img src="https://openscicode.org/badge/doi/10.3389/fnins.2026.1605209.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->On GitHub, open the README, choose Edit (the pencil), paste the snippet under the title, then "Commit changes".
If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge 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: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.
Report a mismatch between the code and the paper · Report a code error (signed in)
Reproductions: reports from readers who ran the authors' code and did not get the paper's result, what they ran, with which environment, commit and data.
Report a reproduction failure (signed in)
Versions of its code: the releases of its code tied to a version of this paper (the preprint, the accepted manuscript, the version of record…), each with the tracing map versioned with it.
Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.
