OSCR

ACORN: Adaptive Consensus of Repeated Clusterings Identifies Pyramidal Neurons and Interneurons in the Primate Motor Cortex Based on Extracellular Spike Waveforms.

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] § Materials and Methods ↔ cleanspike.py, lines 116 to 181 · score 0.67 · pattern matched noise, spike waveforms, cleanspike, stimuli, imputation, sweeps · Report a mismatch
  2. [2] § Materials and Methods › Code accessibility ↔ cleanspike.py, lines 1 to 61 · score 0.59 · pattern matched noise, Precision, imputation, Windows, Python, MATLAB · Report a mismatch
  3. [3] § Materials and Methods ↔ cleanspike.py, lines 1 to 61 · score 0.56 · background noise, spike window, troughs, waveform · 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 · 346 lines · 18 KB · no license · 3 matches

  1. #!/usr/bin/env python
  2. # coding: utf-8
  3. """
  4. cleanspike.py -- Python port of cleanspike.m from the ACORN repository.
  6. "Pattern-matched noise imputation": every sweep is aligned on its trough, and
  7. the parts of the spike window before and after the spike itself are replaced by
  8. stretches of that sweep's own background noise, chosen so that they join the
  9. remaining waveform as smoothly as possible.
  11. cleaned = cleanspike(inputsweeps, stimulusindex, spikestartindex,
  12. spiketroughindex, spikeendindex, samplingfrequency)
  14. * inputsweeps should be a matrix of sweeps-by-samples
  15. * stimulusindex should be, in samples, the time of the main stimulation (set it to NaN if not applicable!, e.g. when no stimulation was delivered)
  16. * spikestartindex should be, in samples, the time when the mean spike is considered to have begun (better to err on the side of including a bit more than needed)
  17. * spiketroughindex should be, in samples, the time when the mean spike shape is at its lowest
  18. * spikeendindex should be in, in samples, the time when the mean spike is considered to have ended (better to err on the side of including a bit more than needed)
  19. * samplingfrequency should be the number of samples per second
  21. * outputsweeps will be a matrix of sweeps-by-samples, with spike waveforms "cleaned" through "pattern-matched noise imputation"
  22. * the optional second return value will be a matrix of sweeps-by-samples, with spike waveforms aligned but NOT "cleaned" through "pattern-matched noise imputation"
  24. The calculation follows the MATLAB file line by line (the MATLAB variable names
  25. are kept so the two can be read side by side). Deliberate differences:
  27. * INDEXING. Sample indices are 0-based by default, as everywhere else in
  28. Python. If your indices come from MATLAB (1-based), pass ``index_base=1``;
  29. the numbers are then interpreted exactly as cleanspike.m interprets them.
  30. * The second MATLAB output (nargout > 1) is requested with
  31. ``return_aligned=True``.
  32. * The input array is never modified, and it is always processed in float64.
  33. (cleanspike.m computes in single precision if given single precision, so
  34. results then agree to about 7 digits only. Integer arrays cannot hold NaN,
  35. which the method relies on; cleanspike.m needs floating-point input, the
  36. port converts.)
  37. * Out-of-range windows raise an error instead of silently wrapping around
  38. (negative indices mean "count from the end" in numpy).
  40. Requires only numpy.
  41. """
  43. from __future__ import annotations
  45. import math
  46. import warnings
  48. import numpy as np
  50. __all__ = ["cleanspike"]
  52. # --- constants, identical to cleanspike.m ------------------------------------
  53. SPIKEWINDOWMS = 2.0 # ms, duration
  54. TROUGHMS = +0.3 # ms, relative to spike window start
  55. ALIGNMENTSEARCHRADIUSMS = 0.1 # ms, max for aligning troughs across sweeps
  56. PRESTIMULUSENDMS = -8 # ms, relative to stimulusindex
  57. MAINSTIMULUSSTARTMS = -1 # ms, relative to stimulusindex
  58. MAINSTIMULUSENDMS = +2 # ms, relative to stimulusindex
  61. # --- small helpers that reproduce MATLAB behaviour ---------------------------
  62. def _matlab_round(x: float) -> int:
  63. """MATLAB round(): ties go away from zero (Python's round() goes to even)."""
  64. a = abs(x)
  65. r = math.floor(a)
  66. if a - r >= 0.5:
  67. r += 1
  68. return int(math.copysign(r, x))
  71. def _as_index(value, name: str) -> int:
  72. """Accept only whole numbers as sample indices (MATLAB would error too)."""
  73. f = float(value)
  74. if not math.isfinite(f) or f != math.floor(f):
  75. raise ValueError(f"{name} must be a whole number of samples, got {value!r}")
  76. return int(f)
  79. def _nanargmin_first(x: np.ndarray) -> tuple[int, bool]:
  80. """0-based position of the smallest non-NaN value (first one if tied).
  82. MATLAB's min() returns index 1 when everything is NaN; so do we (0), and
  83. the second return value says that this happened. (np.argmin would return
  84. the position of the first NaN, np.nanargmin would raise.)
  85. """
  86. valid = ~np.isnan(x)
  87. if not valid.any():
  88. return 0, True
  89. return int(np.nanargmin(x)), False
  92. def _exclude(mask: np.ndarray, first: int, last: int, name: str) -> None:
  93. """mask(first:last) = false with MATLAB 1-based inclusive indices.
  95. An empty range (last < first) does nothing, as in MATLAB. It is NOT passed
  96. on to numpy, where e.g. mask[0:-50] would blank almost the whole array.
  97. """
  98. if last < first:
  99. return
  100. if first < 1:
  101. raise IndexError(f"{name}: range starts before the first sample")
  102. if last > mask.size:
  103. # MATLAB would silently grow the logical array; the net effect there is
  104. # the same as stopping at the last sample.
  105. warnings.warn(f"{name}: range ends after the last sample; clipped", stacklevel=3)
  106. last = mask.size
  107. mask[first - 1:last] = False
  110. def _nan_counts(x: np.ndarray) -> np.ndarray:
  111. """c[j] = number of NaNs in x[0:j]; so x[a:b] has c[b] - c[a] NaNs."""
  112. return np.concatenate(([0], np.cumsum(np.isnan(x))))
  115. # --- the function -------------------------------------------------------------
  116. def cleanspike(inputsweeps, stimulusindex, spikestartindex, spiketroughindex,
  117. spikeendindex, samplingfrequency, *, index_base: int = 0,
  118. return_aligned: bool = False):
  119. """Clean spike waveforms by pattern-matched noise imputation.
  121. Parameters
  122. ----------
  123. inputsweeps : array, sweeps-by-samples
  124. One sweep per row. Not modified.
  125. stimulusindex : number, NaN or None
  126. Sample of the main stimulation. NaN/None if no stimulation was
  127. delivered (nothing stimulus-related is then excluded).
  128. spikestartindex, spikeendindex : int
  129. Samples where the mean spike is considered to begin / to have ended
  130. (better to err on the side of including a bit more than needed).
  131. spiketroughindex : int
  132. Sample where the mean spike shape is at its lowest.
  133. samplingfrequency : number
  134. Samples per second.
  135. index_base : 0 or 1, keyword only
  136. 0 (default): the four indices above are Python-style, first sample = 0.
  137. 1: they are MATLAB-style, first sample = 1, exactly as in cleanspike.m.
  138. return_aligned : bool, keyword only
  139. Also return the aligned but NOT cleaned spike windows (the optional
  140. second output of cleanspike.m).
  142. Returns
  143. -------
  144. outputsweeps : float64 array, sweeps-by-window samples
  145. Cleaned spike waveforms (window = 2 ms starting 0.3 ms before trough).
  146. originalindividualspikeshapes : float64 array, only if return_aligned
  147. """
  148. if index_base not in (0, 1):
  149. raise ValueError("index_base must be 0 (Python) or 1 (MATLAB)")
  150. tomatlab = 1 - index_base # added to a user index to get the MATLAB index
  152. # MATLAB passes arrays by value; numpy passes references. Work on a private
  153. # float64 copy so the caller's data is untouched and NaN can be stored.
  154. inputsweeps = np.array(inputsweeps, dtype=np.float64, copy=True)
  155. if inputsweeps.ndim == 1:
  156. inputsweeps = inputsweeps[np.newaxis, :] # a single sweep
  157. if inputsweeps.ndim != 2:
  158. raise ValueError("inputsweeps must be a sweeps-by-samples matrix")
  159. sweepn, analysiswindown = inputsweeps.shape
  161. samplingfrequency = float(samplingfrequency)
  162. # From here on all indices are MATLAB indices (1-based, ranges inclusive);
  163. # they are turned into numpy slices only at the point of use.
  164. spikestartindex = _as_index(spikestartindex, "spikestartindex") + tomatlab
  165. spiketroughindex = _as_index(spiketroughindex, "spiketroughindex") + tomatlab
  166. spikeendindex = _as_index(spikeendindex, "spikeendindex") + tomatlab
  167. if stimulusindex is None:
  168. stimulusindex = math.nan
  169. stimulusindex = float(stimulusindex)
  170. if math.isinf(stimulusindex):
  171. raise ValueError("stimulusindex must be a number, NaN or None")
  172. stimulusindex += tomatlab
  174. if not 1 <= spiketroughindex <= analysiswindown:
  175. raise IndexError(f"spiketroughindex is outside the sweep ({analysiswindown} samples)")
  177. alignmentsamples = math.ceil(ALIGNMENTSEARCHRADIUSMS / 1000 * samplingfrequency)
  179. spikewindowstart = math.floor(spiketroughindex - TROUGHMS / 1000 * samplingfrequency)
  180. spikewindowend = math.ceil(spikewindowstart + SPIKEWINDOWMS / 1000 * samplingfrequency)
  181. spikewindown = spikewindowend - spikewindowstart + 1
  183. # in samples, relative to spike window start (1-based position in window)
  184. troughinwindow = 1 + _matlab_round(TROUGHMS / 1000 * samplingfrequency)
  186. if spikewindowstart < 1 or spikewindowend > analysiswindown:
  187. raise IndexError(
  188. f"the spike window (samples {spikewindowstart - tomatlab}..{spikewindowend - tomatlab}) does not "
  189. f"fit inside the sweep ({1 - tomatlab}..{analysiswindown - tomatlab}); cleanspike.m fails here as well")
  191. # --- align the trough of every sweep -------------------------------------
  192. currentlookfrom = max(spiketroughindex - alignmentsamples, 1)
  193. currentlookuntil = min(currentlookfrom + 2 * alignmentsamples, analysiswindown)
  195. for sweepi in range(sweepn):
  196. currentlocalminwhere, _ = _nanargmin_first(inputsweeps[sweepi, currentlookfrom - 1:currentlookuntil])
  197. currentlocalminwhere += 1 # MATLAB position within the search range
  198. displacementneeded = spiketroughindex - (currentlookfrom + currentlocalminwhere - 1)
  199. if displacementneeded > 0:
  200. inputsweeps[sweepi, displacementneeded:] = inputsweeps[sweepi, :-displacementneeded].copy()
  201. inputsweeps[sweepi, :displacementneeded] = np.nan
  202. elif displacementneeded < 0:
  203. inputsweeps[sweepi, :displacementneeded] = inputsweeps[sweepi, -displacementneeded:].copy()
  204. inputsweeps[sweepi, displacementneeded:] = np.nan
  206. # .copy(): a numpy slice is a view, a MATLAB slice is a copy
  207. individualspikeshapes = inputsweeps[:, spikewindowstart - 1:spikewindowend].copy()
  208. originalindividualspikeshapes = individualspikeshapes.copy()
  209. with warnings.catch_warnings():
  210. warnings.simplefilter("ignore", RuntimeWarning) # all-NaN column -> NaN, silently as in MATLAB
  211. originalmeanspikeshape = np.nanmean(individualspikeshapes, axis=0)
  213. potentialnoisesweeps = inputsweeps.copy()
  215. ispotentialnoise = np.ones(analysiswindown, dtype=bool)
  216. # exclude our spike from being considered as a potential source for imputation
  217. _exclude(ispotentialnoise, spikestartindex, spikeendindex, "spikestartindex:spikeendindex")
  219. if not math.isnan(stimulusindex): # if it's NaN, nothing stimulus-related is excluded
  220. # exclude the prestimulus interval
  221. prestimulusendindex = min(math.ceil(stimulusindex + PRESTIMULUSENDMS / 1000 * samplingfrequency),
  222. analysiswindown)
  223. _exclude(ispotentialnoise, 1, prestimulusendindex, "prestimulus interval")
  224. # exclude the main stimulus interval
  225. mainstimulusstartindex = max(math.floor(stimulusindex + MAINSTIMULUSSTARTMS / 1000 * samplingfrequency), 1)
  226. mainstimulusendindex = min(math.ceil(stimulusindex + MAINSTIMULUSENDMS / 1000 * samplingfrequency),
  227. analysiswindown)
  228. _exclude(ispotentialnoise, mainstimulusstartindex, mainstimulusendindex, "main stimulus interval")
  230. # --- exclude "probable spikes", now on a per-sweep basis ------------------
  231. for sweepi in range(sweepn):
  232. currentpotentialnoise = potentialnoisesweeps[sweepi, :].copy()
  233. currentpotentialnoise[~ispotentialnoise] = np.nan # exclude stimulation artifacts from the noise estimate
  234. validn = int(np.count_nonzero(~np.isnan(currentpotentialnoise)))
  235. if validn == 0:
  236. currentspikethreshold = math.nan
  237. else:
  238. # per Quiroga, Nadasdy & Ben-Shaul (2004), after Donoho & Johnstone (1994)
  239. currentspikethreshold1 = 3 * np.nanmedian(np.abs(currentpotentialnoise)) / 0.6745
  240. # MATLAB std() normalises by N-1 (numpy's default is N) and gives 0 for a single value
  241. currentpotentialnoisestd = np.nanstd(currentpotentialnoise, ddof=1) if validn > 1 else 0.0
  242. currentspikethreshold2 = 0 + 3 * currentpotentialnoisestd # grand mean should be 0 (highpass)
  243. # the more conservative of the two thresholds (which will exclude more)
  244. # (np.fmin ignores a NaN operand like MATLAB's min; Python's built-in min() does not)
  245. currentspikethreshold = float(np.fmin(currentspikethreshold1, currentspikethreshold2))
  246. with np.errstate(invalid="ignore"):
  247. exclude = (~ispotentialnoise
  248. | (currentpotentialnoise > currentspikethreshold)
  249. | (currentpotentialnoise < -currentspikethreshold))
  250. potentialnoisesweeps[sweepi, exclude] = np.nan
  252. windowpositions = np.arange(1, spikewindown + 1) # MATLAB positions within the spike window
  253. with np.errstate(invalid="ignore"):
  254. isnegative = originalmeanspikeshape < 0
  255. # [m(1:end-1)-m(2:end) < 0, false]
  256. risesnext = np.append(originalmeanspikeshape[:-1] - originalmeanspikeshape[1:] < 0, False)
  257. # [false, m(2:end)-m(1:end-1) < 0]
  258. fellbefore = np.append(False, originalmeanspikeshape[1:] - originalmeanspikeshape[:-1] < 0)
  260. def _warn_no_noise(sweepi: int, part: str) -> None:
  261. warnings.warn(
  262. f"cleanspike: sweep {sweepi + index_base} has no usable noise stretch for the part {part} "
  263. "the trough; the first samples of the sweep were used instead (as cleanspike.m does), "
  264. "so this sweep may contain NaN", stacklevel=3)
  266. # --- Processing BEFORE the trough ----------------------------------------
  267. # before the trough AND negative AND negative-direction
  268. found = np.flatnonzero((windowpositions <= troughinwindow - 3) & isnegative & risesnext)
  269. if found.size > 0:
  270. dipbackbelowzeroindex = int(found[-1]) + 1 # find(..., 1, 'last')
  271. needtoreplaceuntil = dipbackbelowzeroindex
  272. needtoreplacen = dipbackbelowzeroindex
  273. for swi in range(sweepn):
  274. noise = potentialnoisesweeps[swi, :]
  275. # patterndifferences holds, at each index, the weighted sum of squared distances across a
  276. # 3 datapoint "overlap" immediately AFTER the interval (index = LAST sample of the candidate)
  277. patterndifferences = np.full(analysiswindown, np.nan)
  278. n = analysiswindown
  279. if n > 3:
  280. patterndifferences[:n - 3] = (
  281. (noise[1:n - 2] - individualspikeshapes[swi, needtoreplaceuntil]) ** 2.0 * 1.0
  282. + (noise[2:n - 1] - individualspikeshapes[swi, needtoreplaceuntil + 1]) ** 2.0 * 0.5
  283. + (noise[3:n] - individualspikeshapes[swi, needtoreplaceuntil + 2]) ** 2.0 * 0.25)
  284. # exclude intervals that would stretch outside of the analysis window or include excluded timepoints
  285. nancount = _nan_counts(noise)
  286. lastsample = np.arange(n) # 0-based last sample of the candidate
  287. firstsample = lastsample - needtoreplacen + 1 # 0-based first sample of the candidate
  288. invalid = firstsample < 0
  289. ok = ~invalid
  290. invalid[ok] = (nancount[lastsample[ok] + 1] - nancount[firstsample[ok]]) > 0
  291. patterndifferences[invalid] = np.nan
  293. relativelybestwhere, nonefound = _nanargmin_first(patterndifferences)
  294. takefrom = relativelybestwhere - needtoreplacen + 1
  295. if takefrom < 0:
  296. raise ValueError(
  297. f"cleanspike: sweep {swi + index_base} has no usable noise stretch of {needtoreplacen} "
  298. "samples for the part before the trough (cleanspike.m stops with an indexing error "
  299. "in the same situation)")
  300. if nonefound:
  301. _warn_no_noise(swi, "before")
  302. individualspikeshapes[swi, :needtoreplaceuntil] = noise[takefrom:relativelybestwhere + 1]
  304. # --- Processing AFTER the trough -----------------------------------------
  305. # after the trough AND negative AND negative-direction
  306. found = np.flatnonzero((windowpositions > troughinwindow + 3) & isnegative & fellbefore)
  307. if found.size > 0:
  308. returntozeroindex = int(found[0]) + 1 # find(..., 1, 'first')
  309. needtoreplacefrom = returntozeroindex
  310. needtoreplacen = spikewindown - needtoreplacefrom + 1
  311. for swi in range(sweepn):
  312. noise = potentialnoisesweeps[swi, :]
  313. # ... across a 3 datapoint "overlap" immediately BEFORE the interval
  314. # (index = FIRST sample of the candidate)
  315. patterndifferences = np.full(analysiswindown, np.nan)
  316. n = analysiswindown
  317. if n > 3:
  318. patterndifferences[3:] = (
  319. (noise[2:n - 1] - individualspikeshapes[swi, needtoreplacefrom - 2]) ** 2.0 * 1.0
  320. + (noise[1:n - 2] - individualspikeshapes[swi, needtoreplacefrom - 3]) ** 2.0 * 0.5
  321. + (noise[0:n - 3] - individualspikeshapes[swi, needtoreplacefrom - 4]) ** 2.0 * 0.25)
  322. nancount = _nan_counts(noise)
  323. firstsample = np.arange(n)
  324. pastend = firstsample + needtoreplacen # one past the 0-based last sample
  325. invalid = pastend > n
  326. ok = ~invalid
  327. invalid[ok] = (nancount[pastend[ok]] - nancount[firstsample[ok]]) > 0
  328. patterndifferences[invalid] = np.nan
  330. relativelybestwhere, nonefound = _nanargmin_first(patterndifferences)
  331. if nonefound:
  332. _warn_no_noise(swi, "after")
  333. individualspikeshapes[swi, needtoreplacefrom - 1:] = \
  334. noise[relativelybestwhere:relativelybestwhere + needtoreplacen]
  336. # final baseline compensation (the median may have slightly changed as a result of the imputation)
  337. with warnings.catch_warnings():
  338. warnings.simplefilter("ignore", RuntimeWarning)
  339. meanspikeshape = np.nanmean(individualspikeshapes, axis=0)
  340. # plain median on purpose: as in cleanspike.m, a NaN in the mean shape makes the whole output NaN
  341. finalbaselinecompensation = np.median(meanspikeshape)
  342. outputsweeps = individualspikeshapes - finalbaselinecompensation
  344. if return_aligned:
  345. return outputsweeps, originalindividualspikeshapes
  346. return outputsweeps

cleanspike.py at commit c4a126d, no license · at the source

Overview

Authors: Zoltan Soltesz1, Viviane S. G. M. Tenorio2, Takamichi Tohyama3, Anne M. E. Baker1, Stuart N. Baker1, Alexander Kraskov1
ORCID iDs: Zoltan Soltesz, Stuart N. Baker, Alexander Kraskov
  1. Faculty of Medical Sciences, Newcastle University, Newcastle NE2 4HH, United Kingdom
  2. School of Engineering and Built Environment, Sheffield Hallam University, Sheffield S1 1WB, United Kingdom
  3. Department of Rehabilitation Medicine, School of Medicine, Fujita Health University, Aichi 470-1192, Japan
Institutions: Newcastle University (United Kingdom); Sheffield Hallam University (United Kingdom); Fujita Health University (Japan)
Journal: eNeuro, volume 13, issue 10, pages ENEURO.0394-25.2026
Dates: received 14 October 2025; accepted 22 September 2026; published online 23 October 2026; in print October 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1523/eneuro.0394-25.2026 · PMID 42880967 · PMCID PMC13713218 · OpenAlex W7222104320
Open access: gold, a free copy (OpenAlex)
Status: code verified (how the code is found and verified)
Categories: extracellular electrophysiology (units, LFP) (modality), mouse (organism), non-human primate (organism)
Methods: Statistics, Smoothing, state filtering, decompositions, Connectivity, fMRI & imaging, Single-unit activity, calcium imaging
Keywords: antidromic identification, electrophysiology, ground truth dataset, neuron classification, pyramidal tract neurons, supplementary motor area
MeSH: Action Potentials*, Interneurons*, Motor Cortex*, Pyramidal Cells*, Animals, Cluster Analysis, Clustering Algorithms, Female, Macaca mulatta, Mice (* major topic)
Journal subjects: Research Article: New Research, Sensory and Motor Systems
Topic: Neuroscience and Neural Engineering (Cellular and Molecular Neuroscience, Neuroscience), according to OpenAlex
Funding: UKRI | Biotechnology and Biological Sciences Research Council (AFRC) (BB/Y000625/1, BB/V00896X/1); HHS | National Institutes of Health (NIH) (R01NS119319); EU Grant to the In2PrimateBrains Consortium (956669); DSIT | Advanced Research and Invention Agency (ARIA) (SCNI-PR01-P09)
Citations: not cited yet (Europe PMC); 32 references in the paper

Abstract

Understanding how neural circuits generate behavior requires knowledge of both neural activity patterns and the cell types they originate from. While the scale of neuronal recordings has dramatically increased since the advent of dense multicontact probes, accurate identification of cell types remains elusive. Traditional approaches have used spike width to attempt a classification, with narrow spikes assumed to be inhibitory interneurons. However, fast pyramidal tract neurons (PTNs; known to be excitatory) with thin spikes and interneurons with wide spikes challenge these assumptions. Here we accomplish three related objectives. First, we produce a ground truth dataset of extracellular spike shapes from electrophysiologically identified pyramidal neurons from primary (M1) and supplementary motor areas (SMA) and optogenetically identified interneurons in M1 in female macaque monkeys. Next, we show that spike width correlates with antidromic latency not only in M1 but also in the SMA, suggesting that it is a physiologically meaningful measure across the motor cortex. Finally, we introduce our unsupervised ensemble clustering method, “ACORN,” and characterize its performance on our neocortical macaque dataset, the C4 cerebellar database, and a juxtacellularly recorded mouse dataset, demonstrating strong out-of-the-box performance across species, brain areas, and recording techniques. ACORN can cluster neuronal waveforms without training or tuning and provides data-derived confidence values for its predictions. Our ground truth data can be used as a reference to help identify or verify clusters in novel datasets. Together, our method and database provide a streamlined foundation for electrophysiological cell classification without necessitating changes to recording paradigms.

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

zolts/ACORN

License: none: the authors keep all their rights
State: the link answers, verified on 30 October 2026
Evidence: files inventoried
Commit: c4a126d5c967697cf349811676780b34acfecab0, 14 October 2026
Languages: Python (4), MATLAB (2)
Size: 12 files, 6 scripts
Software Heritage: not archived
Found in: “Code accessibility”
Holds: README, environment (requirements.txt)
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (4 files), pandas (3 files), h5py (2 files), scikit-learn (2 files), SciPy (2 files), UMAP (2 files)
Availability: 1 check, the latest on 30 October 2026: the link answers
  • 30 October 2026: the link answers
7 files
At the source: github.com/zolts/ACORN

Code accessibility

The ACORN code, as well as an implementation of the “pattern-matched noise imputation” used in this paper, is freely available (https://github.com/zolts/ACORN). The code is not OS-specific. Here, it was run on a Dell Precision 7,920 PC with a Microsoft Windows 10 Enterprise operating system, using Python 3.8 (Python Software Foundation) and MATLAB R2025b (MathWorks).

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:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 6 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.

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 October 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 6 authors, 6 keywords, 10 MeSH terms, 4 funders, 27 references.

Cite

This paper

Soltesz, Z., Tenorio, V. S. G. M., Tohyama, T., Baker, A. M. E., Baker, S. N., & Kraskov, A. (2026). ACORN: Adaptive Consensus of Repeated Clusterings Identifies Pyramidal Neurons and Interneurons in the Primate Motor Cortex Based on Extracellular Spike Waveforms. eNeuro, 13(10), ENEURO.0394-25.2026. https://doi.org/10.1523/eneuro.0394-25.2026

BibTeX

@article{soltesz2026acorn,
author = {Soltesz, Zoltan and Tenorio, Viviane S. G. M. and Tohyama, Takamichi and Baker, Anne M. E. and Baker, Stuart N. and Kraskov, Alexander},
title = {{ACORN: Adaptive Consensus of Repeated Clusterings Identifies Pyramidal Neurons and Interneurons in the Primate Motor Cortex Based on Extracellular Spike Waveforms}},
journal = {eNeuro},
year = {2026},
month = oct,
volume = {13},
number = {10},
pages = {ENEURO.0394--25.2026},
publisher = {Society for Neuroscience},
issn = {2373-2822},
doi = {10.1523/eneuro.0394-25.2026},
url = {https://doi.org/10.1523/eneuro.0394-25.2026},
pmid = {42880967},
pmcid = {PMC13713218}
}

RIS

TY - JOUR
AU - Soltesz, Zoltan
AU - Tenorio, Viviane S. G. M.
AU - Tohyama, Takamichi
AU - Baker, Anne M. E.
AU - Baker, Stuart N.
AU - Kraskov, Alexander
TI - ACORN: Adaptive Consensus of Repeated Clusterings Identifies Pyramidal Neurons and Interneurons in the Primate Motor Cortex Based on Extracellular Spike Waveforms
T2 - eNeuro
J2 - eNeuro
PY - 2026
DA - 2026/10/27
VL - 13
IS - 10
SP - ENEURO.0394
EP - 25.2026
SN - 2373-2822
PB - Society for Neuroscience
DO - 10.1523/eneuro.0394-25.2026
UR - https://doi.org/10.1523/eneuro.0394-25.2026
LA - en
ER -

CSL-JSON

{
"id": "10.1523/eneuro.0394-25.2026",
"type": "article-journal",
"title": "ACORN: Adaptive Consensus of Repeated Clusterings Identifies Pyramidal Neurons and Interneurons in the Primate Motor Cortex Based on Extracellular Spike Waveforms",
"container-title": "eNeuro",
"author": [
{
"family": "Soltesz",
"given": "Zoltan"
},
{
"family": "Tenorio",
"given": "Viviane S. G. M."
},
{
"family": "Tohyama",
"given": "Takamichi"
},
{
"family": "Baker",
"given": "Anne M. E."
},
{
"family": "Baker",
"given": "Stuart N."
},
{
"family": "Kraskov",
"given": "Alexander"
}
],
"container-title-short": "eNeuro",
"volume": "13",
"issue": "10",
"page": "ENEURO.0394-25.2026",
"DOI": "10.1523/eneuro.0394-25.2026",
"PMID": "42880967",
"PMCID": "PMC13713218",
"ISSN": "2373-2822",
"publisher": "Society for Neuroscience",
"URL": "https://doi.org/10.1523/eneuro.0394-25.2026",
"language": "en",
"issued": {
"date-parts": [
[
2026,
10,
27
]
]
}
}

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.1038/s41467-026-71331-0 [code]
A multimodal approach for visualizing and identifying electrophysiological cell types in vivo.
Journal: Nature communications
In common: UMAP, scikit-learn, pandas, 2 other tools, extracellular electrophysiology (units, LFP), mouse, 10 references
[2] doi:10.1073/pnas.2521556123 [code]
Neuropixels reveal laminar microcircuit organization in monkey V1 in vivo.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: UMAP, h5py, scikit-learn, 3 other tools, extracellular electrophysiology (units, LFP), non-human primate, 6 references
[3] doi:10.1038/s41467-026-76939-w [code]
HIPPIE: a generative model for electrophysiological analysis across species, technologies, and modalities.
Journal: Nature communications
In common: UMAP, h5py, scikit-learn, 3 other tools, non-human primate, mouse, 4 references
[4] doi:10.7554/elife.110588 [code]
Opening the black box toward a modular approach to spike sorting.
Journal: eLife
In common: UMAP, h5py, scikit-learn, 3 other tools, extracellular electrophysiology (units, LFP), mouse, 3 references
[5] doi:10.1371/journal.pbio.3003527 [code]
Efficient and reliable spike sorting from neural recordings with UMAP-based unsupervised nonlinear dimensionality reduction.
Journal: PLoS biology
In common: UMAP, h5py, scikit-learn, 3 other tools, extracellular electrophysiology (units, LFP), 3 references
[6] doi:10.1016/j.xpro.2023.102320 [code]
WaveMAP for identifying putative cell types from in vivo electrophysiology.
Journal: STAR protocols
In common: UMAP, h5py, scikit-learn, 3 other tools, extracellular electrophysiology (units, LFP), 3 references
[7] doi:10.1016/j.neuron.2025.08.030 [code]
Ultra-high-density Neuropixels probes improve detection and identification in neuronal recordings.
Journal: Neuron
In common: h5py, scikit-learn, pandas, 2 other tools, extracellular electrophysiology (units, LFP), mouse, 3 references
[8] doi:10.1038/s41467-024-53477-x [code]
The human claustrum tracks slow waves during sleep.
Journal: Nature communications
In common: UMAP, h5py, scikit-learn, 3 other tools, 2 references
[9] doi:10.64898/2026.01.23.701239 [code]
Opening the black box: a modular approach to spike sorting
Journal: bioRxiv (preprint)
In common: UMAP, h5py, scikit-learn, 3 other tools, extracellular electrophysiology (units, LFP), 1 reference
[10] doi:10.1016/j.celrep.2024.114519 [code]
Circuit dynamics of superficial and deep CA1 pyramidal cells and inhibitory cells in freely moving macaques.
Journal: Cell reports
In common: UMAP, scikit-learn, pandas, 2 other tools, non-human primate, 2 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.

Add the badge to the code's README

OSCR: the badge of this paper

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 -->
[![OSCR](https://openscicode.org/badge/doi/10.1523/eneuro.0394-25.2026.svg)](https://openscicode.org/badge/doi/10.1523/eneuro.0394-25.2026)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.1523/eneuro.0394-25.2026.svg
   :target: https://openscicode.org/badge/doi/10.1523/eneuro.0394-25.2026
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.1523/eneuro.0394-25.2026"><img src="https://openscicode.org/badge/doi/10.1523/eneuro.0394-25.2026.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.