OSCR

Hybrid knowledge- and data-driven modelling for robust spike detection and sorting in human C-fiber microneurography.

Code ↔ Paper

14 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 14 matches · 4 of them tie a paragraph to a whole file, not to given lines: weak matches, whose lines are not tinted
  1. [1] § Methods › A knowledge- and data-driven spike sorting pipeline › Template-based identification of optimal units ↔ scripts/templates_distance.py, lines 10–64 · score 0.80 · squared error, absolute error, Template distance, spike templates, MAE, MSE
  2. [2] § Methods › Validation and evaluation methods › Statistical analysis › Comparing statistical models ↔ Statistics/StatisticsCountData.R, the whole file · a weak match · score 0.78 · dispersion ratio, model formula, negative Binomial, Poisson, Pearson, log
  3. [3] § Methods › Validation and evaluation methods › Statistical analysis › Comparing statistical models ↔ Statistics/StatisticsCountDataSpike.R, the whole file · a weak match · score 0.78 · dispersion ratio, model formula, negative Binomial, Poisson, Pearson, log
  4. [4] § Methods › A knowledge- and data-driven spike sorting pipeline › Spike classification using machine learning ↔ scripts/model/svm_model.py, lines 51–104 · score 0.71 · SVM model, Optuna, background spikes, Hyperparameter, XGBoost, F1 score
  5. [5] § Results › Feature importance analysis ↔ scripts/feature_importance.py, lines 11–14 · score 0.67 · logistic regression, random forest, importance scores, classifier, models
  6. [6] § Results › Template similarity as a pre-sorting indicator ↔ scripts/templates_distance.py, lines 10–64 · score 0.64 · square error, absolute error, template distance, MAE, RMSE, metrics
  7. [7] § Methods › A knowledge- and data-driven spike sorting pipeline › Spike classification using machine learning ↔ scripts/model/xgboost_model.py, lines 55–106 · score 0.62 · Optuna, background spikes, Hyperparameter, XGBoost, F1 score, fold
  8. [8] § Results › A computational pipeline for adaptive spike detection and sorting › The combo XGBoost + achieves the highest median F1-scorehe combo XGBoost + achieves the highest median F1-score ↔ Statistics/StatisticsCountData.R, the whole file · a weak match · score 0.60 · dispersion ratios, negative Binomial, AIC, residuals, TN, FN
  9. [9] § Results › A computational pipeline for adaptive spike detection and sorting › The combo XGBoost + achieves the highest median F1-scorehe combo XGBoost + achieves the highest median F1-score ↔ Statistics/StatisticsCountDataSpike.R, the whole file · a weak match · score 0.59 · dispersion ratios, negative Binomial, AIC, residuals, FN, TP
  10. [10] § Methods › A knowledge- and data-driven spike sorting pipeline › Spike detection with constrained search space ↔ scripts/detection_via_thresholding.py, lines 237–254 · score 0.57 · find_peaks, Spike detection, SciPy, thresholds
  11. [11] § Results › A computational pipeline for adaptive spike detection and sorting › Constraining the search space with latency information ↔ scripts/detection_via_thresholding.py, lines 190–199 · score 0.52 · latency jump, search space, thresholding, detection, segments
  12. [12] § Methods › A knowledge- and data-driven spike sorting pipeline › Data pre-processing ↔ scripts/helper.py, lines 41–100 · score 0.52 · negative peak, raw signal, alignment, derivative, window
  13. [13] § Methods › A knowledge- and data-driven spike sorting pipeline › Data pre-processing ↔ scripts/pre_processing.py, lines 20–39 · score 0.51 · negative peak, raw signal, derivative, pre, window
  14. [14] § Methods › A knowledge- and data-driven spike sorting pipeline › Spike detection with constrained search space ↔ scripts/detection_via_thresholding.py, lines 190–199 · score 0.51 · Search spaces, spike detection, threshold, chemically, activity, latency

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 · 307 lines · 11 KB · MIT · 3 matches

  1. from snakemake.script import snakemake
  2. import pandas as pd
  3. import numpy as np
  4. from scipy.signal import find_peaks
  5. from tqdm.auto import tqdm
  6. from helper import (
  7. align_spike_to_fd_min,
  8. compute_window_bounds,
  9. extract_raw_values,
  10. check_if_background,
  11. rename_index,
  12. )
  14. tqdm.pandas()
  16. # read in dataframes s
  17. spikes = pd.read_pickle(snakemake.input.spikes)
  18. raw_data = pd.read_pickle(snakemake.input.raw_data)
  19. track_of_interest_label = snakemake.params.track_of_interest_label
  20. dataset_name = snakemake.params.name
  21. stimulations = pd.read_pickle(snakemake.input.stimulations)
  22. window_start_offset = snakemake.params.window_start_offset
  23. window_end_offset = snakemake.params.window_end_offset
  24. latency_difference_threshold = snakemake.params.latency_difference_threshold
  25. restrict_to_stimulus_ranges = snakemake.params.restrict_to_stimulus_ranges
  26. detection_threshold = snakemake.params.threshold
  27. use_absolute_latency_difference = snakemake.params.use_absolute_latency_difference
  28. peak_distance = snakemake.params.peak_distance
  29. peak_prominence = snakemake.params.peak_prominence
  30. evaluation_mode = snakemake.params.evaluation_mode
  33. # check if time ranges contain stimuli
  34. def contains_stimuli(stimulations, time_ranges):
  35. time_range_flags = {}
  36. for time_range_index in range(len(time_ranges)):
  37. for stim in stimulations:
  38. if (stim > time_ranges[time_range_index][0]) & (
  39. stim < time_ranges[time_range_index][1]
  40. ):
  41. time_range_flags[time_ranges[time_range_index]] = 1
  42. return time_range_flags
  45. # remove stimulation artifacts from detected spikes
  46. def remove_stimulation_artifacts(
  47. indices, times_list, stimulations, artifact_duration=0.01
  48. ):
  49. indices_copy = list(indices)
  50. for index in indices:
  51. timing = times_list[index]
  52. for stim in stimulations:
  53. # duration of stimulus not longer than 0.01 seconds
  54. if (timing > stim) and (timing < (stim + artifact_duration)):
  55. indices_copy.remove(index)
  56. return indices_copy
  59. # filter true spikes in time ranges for evaluation
  60. def filter_spikes_in_ranges(spikes, time_ranges):
  61. spike_in_range = False
  62. for start, end in time_ranges:
  63. spike_in_range |= (spikes["spike_ts"] >= start) & (spikes["spike_ts"] <= end)
  64. return spikes[spike_in_range]
  67. # function to evalute detection
  68. def evaluate_detection(true_spikes, detected_spikes, tolerance=0.002):
  69. true_spikes["matched"] = False
  70. detected_spikes["matched"] = False
  71. true_positive = 0
  73. # Match detected spikes to true spikes
  74. for i, true_spike in true_spikes.iterrows():
  75. in_range = detected_spikes[
  76. (detected_spikes["spike_ts"] >= (true_spike["spike_ts"] - tolerance))
  77. & (detected_spikes["spike_ts"] <= (true_spike["spike_ts"] + tolerance))
  78. & (~detected_spikes["matched"])
  79. ] # Unmatched spikes only
  80. if not in_range.empty:
  81. true_spikes.at[i, "matched"] = True
  82. if len(in_range) > 1:
  83. differences = in_range.apply(
  84. lambda row: np.abs(row.spike_ts - true_spike.spike_ts).min(), axis=1
  85. )
  86. index_with_smallest_difference = differences.idxmin()
  87. true_spikes.at[i, "matched"] = True
  88. detected_spikes.at[index_with_smallest_difference, "matched"] = True
  89. else:
  90. detected_spikes.at[in_range.index[0], "matched"] = True
  91. true_positive += 1
  93. false_negative = len(true_spikes) - true_positive
  94. false_positive = len(detected_spikes) - true_positive
  96. results = {
  97. "TP": true_positive,
  98. "FN": false_negative,
  99. "FP": false_positive,
  100. "Precision": (
  101. true_positive / (true_positive + false_positive)
  102. if true_positive + false_positive > 0
  103. else 0
  104. ),
  105. "Recall": (
  106. true_positive / (true_positive + false_negative)
  107. if true_positive + false_negative > 0
  108. else 0
  109. ),
  110. "F1": (
  111. (2 * true_positive / (2 * true_positive + false_positive + false_negative))
  112. if true_positive + false_positive + false_negative > 0
  113. else 0
  114. ),
  115. }
  116. return results
  119. # extract track of interest, specified before in config file
  120. spikes_of_interest = (
  121. spikes[spikes["track"] == track_of_interest_label]
  122. .reset_index(drop=False)
  123. .pipe(rename_index, "spike_idx")
  124. )
  125. spike_of_interest_times = spikes_of_interest.drop(["track"], axis=1)
  127. # label spikes and stimuli by their onset if they belong to the background or are extra spikes/stimuli
  128. spikes_of_interest = check_if_background(spikes_of_interest, "spike_ts")
  129. spikes_of_interest_background = spikes_of_interest[
  130. spikes_of_interest["is_background"] == True
  131. ].drop(["is_background"], axis=1)
  133. stimulations_of_interest = stimulations.reset_index()
  134. stimulations_of_interest = check_if_background(
  135. stimulations_of_interest, "stimulation_ts"
  136. ).set_index("stimulation_idx")
  137. stimulations_background = (
  138. stimulations_of_interest[stimulations_of_interest["is_background"] == True]
  139. .drop(["is_background"], axis=1)
  140. .reset_index(drop=True)
  141. .pipe(rename_index, "stimulation_idx")
  142. )
  144. # extract and align spikes from raw signal
  145. sio_background_window_iloc = (
  146. spikes_of_interest_background[["spike_ts"]]
  147. .progress_apply(
  148. align_spike_to_fd_min,
  149. args=(raw_data,),
  150. window_start_offset=window_start_offset,
  151. window_end_offset=window_end_offset,
  152. evaluation_mode=evaluation_mode,
  153. axis=0,
  154. )
  155. .progress_apply(
  156. compute_window_bounds,
  157. axis=1,
  158. result_type="expand",
  159. window_start_offset=-window_start_offset,
  160. window_end_offset=window_end_offset,
  161. )
  162. .rename(columns={0: "start_iloc", 1: "end_iloc"})
  163. )
  165. sio_background_raw = sio_background_window_iloc[
  166. ["start_iloc", "end_iloc"]
  167. ].progress_apply(extract_raw_values, args=(raw_data,), axis=1, result_type="expand")
  170. # add latency in ms
  171. spikes_of_interest_background["latency"] = -1 # np.nan
  172. spikes_of_interest_background["stimulation_ts"] = -1 # np.nan
  174. for matching_indices, row in stimulations_background.iterrows():
  175. stim_onset = row["stimulation_ts"]
  176. matching_rows = spikes_of_interest_background[
  177. (spikes_of_interest_background["spike_ts"] > stim_onset)
  178. & (spikes_of_interest_background["spike_ts"] <= stim_onset + 4)
  179. ]
  180. if len(matching_rows) > 0:
  181. latency = abs(stim_onset - matching_rows.spike_ts) * 1000
  182. spikes_of_interest_background.loc[matching_rows.index[0], "latency"] = round(
  183. float(latency.iloc[0]), 4
  184. )
  185. spikes_of_interest_background.loc[matching_rows.index[0], "stimulation_ts"] = (
  186. stim_onset
  187. )
  190. # if the latency jump/difference is greater than the threshold value, the speed of fiber correction slows down
  191. # and activity-dependent slowing was observed, this threshold is fiber dependent
  192. # limit search space for spike detection to segments with latency jumps greater than threshold
  193. # use abs for chemical data
  194. latency_diff = spikes_of_interest_background["latency"].diff()
  196. if use_absolute_latency_difference:
  197. latency_diff = latency_diff.abs()
  199. indices_latency_jumps = latency_diff[latency_diff >= latency_difference_threshold].index
  201. # determine the start of the signal segment to know where the search region begins
  202. onsets_segments_jumps = [
  203. spikes_of_interest_background.loc[index]["stimulation_ts"]
  204. for index in indices_latency_jumps
  205. ]
  206. print(onsets_segments_jumps)
  207. # collect time tanges of signal segments to apply spike detection only in these segments
  208. # if restrict_to_stimulus_ranges is set to True, only segments with stimuli are kept
  209. time_ranges = []
  210. stimulation_onsets = []
  212. for onset in onsets_segments_jumps:
  213. index = stimulations_background.index[
  214. stimulations_background["stimulation_ts"] == onset
  215. ].tolist()
  216. time_ranges.append(
  217. (
  218. stimulations_background.loc[index[0] - 1]["stimulation_ts"],
  219. stimulations_background.loc[index[0]]["stimulation_ts"],
  220. )
  221. )
  222. stimulation_onsets.append(
  223. stimulations_background.loc[index[0] - 1]["stimulation_ts"]
  224. )
  225. stimulation_onsets.append(stimulations_background.loc[index[0]]["stimulation_ts"])
  227. if restrict_to_stimulus_ranges:
  228. time_range_flags = contains_stimuli(stimulations, time_ranges)
  229. time_ranges = [
  230. time_range
  231. for time_range in time_ranges
  232. if time_range_flags.get(time_range, False)
  233. ]
  235. df_time_ranges = pd.DataFrame(time_ranges, columns=["start", "end"])
  237. # apply find_peaks for spike detection
  238. crossing_indices_scipy = {}
  239. times_list_scipy = {}
  240. amplitude_list_scipy = {}
  242. for index_time_range in range(len(time_ranges)):
  243. time_range_start = time_ranges[index_time_range][0]
  244. time_range_end = time_ranges[index_time_range][1]
  245. signal_piece = raw_data[time_range_start:time_range_end]
  246. peaks, _ = find_peaks(
  247. signal_piece,
  248. height=detection_threshold,
  249. distance=peak_distance,
  250. prominence=peak_prominence,
  251. )
  252. crossing_indices_scipy[index_time_range] = peaks
  253. times_list_scipy[index_time_range] = signal_piece.index
  254. amplitude_list_scipy[index_time_range] = signal_piece.values
  256. # iterate over each crossing and remove artifacts
  257. spike_times = []
  258. for k in crossing_indices_scipy:
  259. crossing_indices_scipy[k] = remove_stimulation_artifacts(
  260. crossing_indices_scipy[k], times_list_scipy[k], stimulations.values
  261. )
  262. for matching_indices in crossing_indices_scipy[k]:
  263. spike_times.append(times_list_scipy[k][matching_indices])
  265. # save detected spike times in dataframe
  266. spikes_detected = (
  267. pd.DataFrame({"spike_ts": spike_times})
  268. .reset_index(drop=True)
  269. .pipe(rename_index, "spike_idx")
  270. )
  272. # evaluate spike detection by comparing detected spikes with true spikes in the time ranges of interest
  273. # the ones with ground truth data
  274. # evaluate spike detection only if ground truth is available
  275. if evaluation_mode == "ground_truth":
  276. true_spikes_filtered = filter_spikes_in_ranges(
  277. spikes[spikes["track"] == track_of_interest_label], time_ranges
  278. )
  279. results = {"dataset": dataset_name, "detected_spikes_count": len(spikes_detected)}
  280. results_spike_detection = evaluate_detection(true_spikes_filtered, spikes_detected)
  281. final_dict = results | results_spike_detection
  282. df_result = pd.DataFrame.from_dict([final_dict])
  283. elif evaluation_mode == "background_spikes":
  284. df_result = pd.DataFrame(
  285. [
  286. {
  287. "dataset": dataset_name,
  288. "detected_spikes_count": len(spikes_detected),
  289. "TP": None,
  290. "FN": None,
  291. "FP": None,
  292. "Precision": None,
  293. "Recall": None,
  294. "F1": None,
  295. }
  296. ]
  297. )
  299. else:
  300. raise ValueError(f"Unknown evaluation_mode: {evaluation_mode}")
  301. # save dataframes and csv files
  302. spike_of_interest_times.to_csv(snakemake.output.spikes_of_interest_file)
  303. spikes_of_interest.to_pickle(snakemake.output.spikes_of_interest_df)
  304. spikes_detected.to_csv(snakemake.output.spikes_detected_file)
  305. spikes_detected.to_pickle(snakemake.output.spikes_detected_df)
  306. df_result.to_csv(snakemake.output.result_detection, index=False)
  307. df_time_ranges.to_csv(snakemake.output.time_ranges, index=False)

detection_via_thresholding.py at commit 8fda173, under MIT · at the source

Overview

Authors: Alina Troglio1,2, Andrea Fiebig3, Anna Maxion4, Ekaterina Kutafina5, Barbara Namer2
  1. Institute of Neurophysiology, Uniklinik RWTH Aachen University,Aachen, Germany
  2. Department of Anesthesiology, Intensive Care, Emergency and Pain Medicine, University Hospital Würzburg, Center for Interdisciplinary Pain Medicine,Würzburg, Germany
  3. Research Group Neuroscience, Interdisciplinary Centre for Clinical Research (IZKF), Faculty of Medicine, RWTH Aachen University,Aachen, Germany
  4. Institute for Computational Biomedicine, RWTH Aachen University,Aachen, Germany
  5. Institute for Biomedical Informatics, Faculty of Medicine and University Hospital Cologne, University of Cologne,Cologne, Germany
Institutions: Universitätsklinikum Aachen (Germany); Universitätsklinikum Würzburg (Germany); RWTH Aachen University (Germany); University of Cologne (Germany)
Journal: Scientific reports, volume 16, issue 1, article 8975
Dates: received 11 June 2025; accepted 20 February 2026; published online 12 March 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1038/s41598-026-41561-9 · PMID 41820449 · PMCID PMC12987942 · OpenAlex W7135026704
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: extracellular electrophysiology (units, LFP) (modality), human (organism), pain (population), methods / tools (subfield)
Methods: Spectral & time-frequency, Preprocessing, Machine learning, Statistics, Evoked potentials, Connectivity, Single-unit activity, calcium imaging
Keywords: Microneurography, Spike detection, Spike sorting, Machine learning, Pain, Itch, C-fiber, Extracellular recording, Single-channel recording, Neuropathic pain
MeSH: Action Potentials*, Models, Neurological*, Nerve Fibers, Unmyelinated*, Boosting Machine Learning Algorithms, Humans, Machine Learning, Support Vector Machine (* major topic)
Topic: Neuroscience and Neural Engineering (Cellular and Molecular Neuroscience, Neuroscience), according to OpenAlex
Funding: Universität zu Köln (1017)
Citations: not cited yet (Europe PMC); 41 references in the paper

Abstract

Analyzing temporal spike patterns in C-fibers recorded via microneurography is challenging due to the use of a single recording electrode, waveform variability, and high similarity of spike shapes across neurons, limiting the interpretation of sensory coding, such as pain and itch. We present a computational pipeline combining peak detection and supervised classification for spike sorting to improve the analysis of discharges, identified through activity-dependent conduction velocity changes. In the knowledge-driven step, we extract spike templates from electrically evoked spikes obtained during low-frequency stimulation and focus on the “best” template as the fiber of interest. Spike detection is further restricted to intervals showing activity-dependent latency shifts, substantially reducing the search space compared to unsupervised clustering. In the data-driven steps, we systematically evaluate three feature sets and machine learning models: One-class SVM, SVM, and XGBoost. For the evaluation, we created a specialized stimulation protocol, providing reliable ground truth labels for all electrically evoked spikes, allowing precise spike time-locking. Compared to Spike2 software, our approach achieved higher F1-scores and reduced false positives, indicating improved spike sorting. Although XGBoost achieved the highest median F1-scores, optimal performance was dependent on individual combinations of feature sets and models for each recording. In some recordings with many nerve fibers and a low signal-to-noise ratio, reliable sorting was not feasible. This highlights the necessity to determine sortability and optimal configurations for individual recordings. To illustrate the potential of our approach to sensory spike train analysis, we present a proof-of-concept application of the pipeline to chemically induced C-fiber activity. These findings represent an important step toward reliable analysis of activity associated with pain and itch signaling.

Supplementary Information: The online version contains supplementary material available at 10.1038/s41598-026-41561-9.

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

Digital-C-Fiber/SpikeSortingForSpikingPatterns

License: MIT
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 8fda173cd68efac4fca223ec09fa330b3a4bae35, 27 March 2026
Languages: Python (14), R (4)
Size: 35 files, 18 scripts
Software Heritage: not archived
Found in: “Software accessibility”
Holds: README, license file, environment (environment.yml)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: pandas (14 files), Snakemake (12 files), NumPy (11 files), SciPy (6 files), scikit-learn (5 files), ggpubr (4 files), glmmTMB (4 files), Matplotlib (4 files), broom (2 files), ggplot2 (2 files), lme4 (2 files), lmerTest (2 files), Neo (2 files), XGBoost (2 files)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
20 files
At the source: github.com/Digital-C-Fiber/SpikeSortingForSpikingPatterns

digital-c-fiber/spikesortingforspikingpatterns](https:

License: none: the authors keep all their rights
State: the link is dead, verified on 30 September 2026
Evidence: found in the paper
Software Heritage: not archived
Found in: “Data availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 30 September 2026: the link is dead
  • 30 September 2026: the link is dead
At the source: github.com/Digital-C-Fiber/SpikeSortingForSpikingPatterns](https:/github.com/Digital-C-Fiber/SpikeSortingForSpikingPatterns)

Software accessibility

The complete spike sorting pipeline, including data preprocessing, feature extraction, and classification, is openly available at https://github.com/Digital-C-Fiber/SpikeSortingForSpikingPatterns. The repository includes source code, documentation, and an example recording.

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

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;
  • 14 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

The raw datasets generated and/or analyzed during the current work are available from the corresponding author on reasonable request. The source code and selected test data are available on [https://github.com/Digital-C-Fiber/SpikeSortingForSpikingPatterns](https:/github.com/Digital-C-Fiber/SpikeSortingForSpikingPatterns).

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, 30 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 5 authors, 10 keywords, 7 MeSH terms, 1 funder, 34 references.

Cite

This paper

Troglio, A., Fiebig, A., Maxion, A., Kutafina, E., & Namer, B. (2026). Hybrid knowledge- and data-driven modelling for robust spike detection and sorting in human C-fiber microneurography. Scientific reports, 16(1), 8975. https://doi.org/10.1038/s41598-026-41561-9

BibTeX

@article{troglio2026hybrid,
author = {Troglio, Alina and Fiebig, Andrea and Maxion, Anna and Kutafina, Ekaterina and Namer, Barbara},
title = {{Hybrid knowledge- and data-driven modelling for robust spike detection and sorting in human C-fiber microneurography}},
journal = {Scientific reports},
year = {2026},
month = mar,
volume = {16},
number = {1},
pages = {8975},
publisher = {Nature Publishing Group},
issn = {2045-2322},
doi = {10.1038/s41598-026-41561-9},
url = {https://doi.org/10.1038/s41598-026-41561-9},
pmid = {41820449},
pmcid = {PMC12987942}
}

RIS

TY - JOUR
AU - Troglio, Alina
AU - Fiebig, Andrea
AU - Maxion, Anna
AU - Kutafina, Ekaterina
AU - Namer, Barbara
TI - Hybrid knowledge- and data-driven modelling for robust spike detection and sorting in human C-fiber microneurography
T2 - Scientific reports
J2 - Sci Rep
PY - 2026
DA - 2026/03/12
VL - 16
IS - 1
SP - 8975
SN - 2045-2322
PB - Nature Publishing Group
DO - 10.1038/s41598-026-41561-9
UR - https://doi.org/10.1038/s41598-026-41561-9
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41598-026-41561-9",
"type": "article-journal",
"title": "Hybrid knowledge- and data-driven modelling for robust spike detection and sorting in human C-fiber microneurography",
"container-title": "Scientific reports",
"author": [
{
"family": "Troglio",
"given": "Alina"
},
{
"family": "Fiebig",
"given": "Andrea"
},
{
"family": "Maxion",
"given": "Anna"
},
{
"family": "Kutafina",
"given": "Ekaterina"
},
{
"family": "Namer",
"given": "Barbara"
}
],
"container-title-short": "Sci Rep",
"volume": "16",
"issue": "1",
"page": "8975",
"DOI": "10.1038/s41598-026-41561-9",
"PMID": "41820449",
"PMCID": "PMC12987942",
"ISSN": "2045-2322",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41598-026-41561-9",
"language": "en",
"issued": {
"date-parts": [
[
2026,
3,
12
]
]
}
}

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.110588 [code]
Opening the black box toward a modular approach to spike sorting.
Journal: eLife
In common: Neo, XGBoost, scikit-learn, 4 other tools, extracellular electrophysiology (units, LFP), methods / tools, 7 references
[2] doi:10.1113/jp290729 [code]
Modelling the memory of unmyelinated axons: Integration of a data-driven approach with physiological memory concept.
Journal: The Journal of physiology
In common: pandas, SciPy, Matplotlib, 1 other tool, 6 references
[3] doi:10.1016/j.patter.2026.101590 [code]
Density-based longitudinal neuron tracking in high-density electrophysiological recordings.
Journal: Patterns (New York, N.Y.)
In common: Neo, scikit-learn, pandas, 3 other tools, extracellular electrophysiology (units, LFP), 4 references
[4] 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: broom, lmerTest, lme4, 7 other tools, methods / tools
[5] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: XGBoost, broom, lme4, 7 other tools
[6] doi:10.1016/j.celrep.2026.117505 [code]
Impaired spatial coding and neuronal hyperactivity in the medial entorhinal cortex of aged APP knock-in mice.
Journal: Cell reports
In common: glmmTMB, broom, lmerTest, 5 other tools, extracellular electrophysiology (units, LFP)
[7] doi:10.1016/j.nicl.2026.104012 [code]
Structural-functional multilayer brain network properties and outcome of combined repetitive transcranial magnetic stimulation and psychotherapy for obsessive-compulsive disorder.
Journal: NeuroImage. Clinical
In common: XGBoost, lmerTest, lme4, 7 other tools
[8] doi:10.3390/ijms27135713 [code]
Chronic Administration of Marinobufagenin in Mice Causes Hyperlocomotion and Decrease in Anxiety by Altering Monoamine Turnover Unaccompanied by Motor Deficits or Oxidative Stress.
Journal: International journal of molecular sciences
In common: glmmTMB, broom, lmerTest, 5 other tools
[9] doi:10.1016/j.celrep.2026.117073 [code]
Single-cell epigenomics uncovers heterochromatin instability and transcription factor dysfunction during mouse brain aging.
Journal: Cell reports
In common: Snakemake, broom, lme4, 6 other tools
[10] doi:10.1162/imag.a.1321 [code]
Phase similarity between similar objects indicates representational merging across retrieval training but not sleep.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: broom, lmerTest, lme4, 6 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.