A lean audio-to-spike encoder reaches 99.77% on spoken digits

What the work claims

The authors claim that audio can be converted into useful spike trains with far less hardware and far fewer channels than the field's benchmark Lauscher cochlea model, and that the encoder and downstream classifier must be tuned together. Their High-Level Programmable (HLP) encoder uses a bank of N_f Butterworth band-pass filters, rectification, and integrate-and-fire neurons, with the threshold controlling spike density.¹

The headline numbers, all obtained with a feedforward fully-connected SNN, are: 99.77% test accuracy on a neuromorphic variant of Heidelberg Digits (NHD), 79.96% on a neuromorphic variant of Google Speech Commands (NSC), and 63.98% on a neuromorphic variant of TIMIT (NTIMIT). The paper also reports an FPGA implementation of a restricted architecture that reaches 99.63% on the English subset of NHD.¹

This is a primary experimental methods-and-benchmarking paper, not a theoretical result. The value is in the controlled comparison of encoder configurations and in the hardware demonstration.

How it works

The pipeline has two stages: a non-learnable cochlear encoder and a trainable SNN classifier. Audio is first passed through N_f logarithmically spaced Butterworth filters implemented in second-order-section form. The absolute value of each filter output drives an integrate-and-fire neuron. The accumulated spikes over 100 time steps are then fed to a feedforward SNN with one to three hidden layers of leaky integrate-and-fire neurons, trained with surrogate-gradient backpropagation through the snnTorch library.¹

The authors tune the encoder jointly with the classifier. For all datasets they settle on fourth-order filters; higher orders do not help. They find that removing membrane decay in the encoder neurons simplifies the design and lets the threshold alone control event rate. For the clean Heidelberg Digits data a threshold of 1 works best; for noisier TIMIT the best trade-off is a threshold of 0.06. The final default uses N_f = 13 channels, a tiny fraction of the 700 channels in the Lauscher encoder that produced the original Spiking Heidelberg Digits benchmark.¹

The efficiency argument rests on hardware-agnostic spike-count metrics. Training efficiency is accuracy divided by the total number of synaptic operations during training; inference efficiency is accuracy divided by the number of spikes during inference. Using these metrics, the authors show that reducing the filter count, downsampling the audio to 8 kHz, or clipping the least-active peripheral filters can raise efficiency by up to a factor of 2 while keeping accuracy within one thousandth of the baseline on the easier datasets.¹

The FPGA implementation targets a Zynq-7000 device running at 10 MHz. It uses eight central filters rather than 13 and processes 1.4-second audio samples in about 152 milliseconds including file loading and data movement. On the full English subset of NHD it classifies correctly on 99.63% of samples.¹

Where a skeptic should push

The most load-bearing assumption is that the accuracy numbers reflect encoder quality rather than dataset simplicity. Heidelberg Digits is a clean studio recording from only 12 speakers, with two of those speakers reserved for the test set. The paper itself shows that the gap between NHD and NSC largely disappears when the latter is restricted to the 12 most-represented speakers, suggesting that inter-speaker variability, not the encoder, drives the drop on harder sets. The 99.77% figure should therefore be read as a best-case ceiling, not a typical-case result.¹

Second, the reported accuracies are the best value over multiple epochs, averaged over three runs with different random seeds. This is a common reporting convention in the field, but it means the headline number is an optimistic selection from the training trajectory rather than a held-out single-run result.

Third, the FPGA result is on the English-only subset of NHD, not the full 20-class German-and-English dataset, and it uses a more constrained architecture. The hardware is also not fully optimized; the authors describe it as generic and note that removing bias computation would further reduce footprint. The 152 ms figure includes host-side overhead, so it is not a pure inference latency.

Encoding the world for a living processor

The non-obvious implication for organoid intelligence is that the input bottleneck may be smaller than it looks. A cultured neural network cannot process raw audio, images, or electrode voltages directly; it must receive information as patterns of electrical or optogenetic stimulation that its neurons can interpret as spikes. The HLP encoder provides a concrete, minimal recipe for one modality: 13 channels, fourth-order filters, integrate-and-fire neurons, and a threshold tuned to keep activity sparse. That is a plausible starting point for designing stimulus patterns for organoids, not because organoids use Butterworth filters, but because the result shows how little continuous preprocessing is needed to preserve class-discriminating information in spike form.

The opportunity is a transferable design principle. Organoid experiments typically use hand-tuned stimulus waveforms or direct recordings from other neural systems. A systematic encoder optimization, where stimulus statistics are varied and the downstream readout accuracy is measured, is rare in wetware work. This paper's conjoint optimization of encoder and classifier is exactly the experiment organoid intelligence needs: vary the spike-encoding of the input, hold the readout fixed, and ask how much of the task survives. The finding that 13 channels suffice for clean speech suggests that organoid input interfaces may not need thousands of electrodes to convey useful acoustic features; a small, tuned population stimulation pattern could be enough.

The threat is the same finding read from the other side. If a non-learnable silicon encoder can strip audio down to sparse spikes without losing task-relevant information, then the hard part of the computation may happen before the spikes ever reach living tissue. An organoid placed after such an encoder risks acting as a classifier of pre-digested features rather than as a genuine computational substrate. The paper's own ablation on speaker-restricted subsets shows that much of the remaining classification work is statistical regularity in the training data. For organoid intelligence, the honest test is whether the living network adds anything that the encoder and a simple linear readout cannot.

There is also a calibration lesson. The authors measure efficiency by counting synaptic events, not by wall-clock time or energy. That is the right level of abstraction for comparing across substrates, because an organoid's cost is not measured in watts alone but in the metabolic and experimental cost of maintaining each active synapse. Adopting event-based efficiency metrics, accuracy per spike or per synaptic operation, would let organoid work be compared to silicon SNNs on equal terms.

The bottom line

Established: a non-learnable 13-channel audio encoder plus a simple feedforward SNN reaches 99.77% on Heidelberg Digits, 79.96% on a neuromorphic Speech Commands variant, and 63.98% on a neuromorphic TIMIT variant, with an FPGA implementation reaching 99.63% on a restricted English-digit subset. The efficiency gains from downsampling and filter clipping are real on easy data but do not transfer cleanly to harder, more variable datasets.

For organoid intelligence the paper is a useful engineering reference and a warning. It gives a minimal viable specification for an audio-to-spike front end, and it shows that the front end can carry much of the task. The claim that organoids are needed for speech or temporal processing would be strengthened by showing that a living network, fed by a comparably lean encoder, outperforms the silicon pipeline on the same spike representation. It would be weakened if the organoid merely reproduces what the encoder and readout already achieve.