Menu

Spiking conversion

Turning a sensing network into spikes: what it costs and what it saves

Study · NeuromorphicNovember 18, 2026Senova Systems Research

We converted a position-sensing network into a spiking network and measured accuracy and arithmetic against how long it runs. Even after 256 time steps it did not match the original, and it never used less arithmetic at equal accuracy.

Every result here comes from simulations of our own simplified models, run with fixed random seeds so they repeat exactly. Nothing has been measured on hardware yet. We report what came out, including where our approach did not win.

The question

Spiking hardware does work only when a neuron fires. The simplest way onto that hardware is to train an ordinary network and convert it: each neuron becomes an integrate-and-fire unit whose firing rate stands in for its activation. We wanted to know what that costs on a real problem from our own designs: reading a levitating puck's position from 36 Hall sensors and 36 coil currents.

What we did

We trained a network with ReLU activations (72 inputs, two hidden layers of 64, two outputs) on 40,000 simulated positions. It reached 0.33 mm rms error on test positions. We then converted it the standard way (Rueckauer et al., 2017): integrate-and-fire neurons that subtract the threshold when they fire, thresholds set from the 99.9th percentile of each layer's activations, the input fed as a steady current, and the output read from the last layer's accumulated potential.

We ran the spiking network for 4 to 256 time steps per estimate and counted every operation: the first layer's multiply-accumulates (done once, because the input current is steady) and one addition per spike per connection after that.

vj[t+1]=vj[t]+Ij[t]sj[t+1]=1 ⁣[ vj[t+1]≥1 ],vj[t+1]←vj[t+1]−sj[t+1]Ik[t]=bk′+∑jWkj′ sj[t]Wℓ′=Wℓ λℓ−1λℓ,bℓ′=bℓλℓlim⁡T→∞1T∑t=1Tsj[t]=ajλℓ(0≤aj≤λℓ)\begin{aligned} v_j[t+1] &= v_j[t] + I_j[t] \\ s_j[t+1] &= \mathbf{1}\!\left[\, v_j[t+1] \ge 1 \,\right], \qquad v_j[t+1] \leftarrow v_j[t+1] - s_j[t+1] \\ I_k[t] &= b'_k + \sum_j W'_{kj}\, s_j[t] \\ W'_\ell &= W_\ell\,\frac{\lambda_{\ell-1}}{\lambda_\ell}, \qquad b'_\ell = \frac{b_\ell}{\lambda_\ell} \\ \lim_{T \to \infty} \frac{1}{T}\sum_{t=1}^{T} s_j[t] &= \frac{a_j}{\lambda_\ell} \qquad (0 \le a_j \le \lambda_\ell) \end{aligned}

Symbols

vj[t]v_j[t]
membrane potential of neuron j at time step t
Ij[t]I_j[t]
input current into neuron j
sj[t]∈{0,1}s_j[t] \in \{0, 1\}
spike: 1 when the neuron fires
λℓ\lambda_\ell
99.9th percentile of layer ℓ's ReLU activations (sets the scale)
aja_j
the original network's ReLU activation for neuron j
TT
number of time steps the spiking network runs for

In plain words

Each neuron adds up its input current every step and fires when the total passes 1, keeping any overshoot (reset by subtraction, so nothing is lost). Over many steps its firing rate approaches the original ReLU activation divided by λ, the layer's 99.9th-percentile activation. Scaling each layer's weights by λ keeps rates in range.

ESNN≈NMAC(1)  eMAC  +  (∑t=1T∑jsj[t] Fj) eaddEANN≈NMAC  eMAC\begin{aligned} E_{\text{SNN}} &\approx N^{(1)}_{\text{MAC}}\; e_{\text{MAC}} \;+\; \Big(\sum_{t=1}^{T} \sum_{j} s_j[t]\, F_j\Big)\, e_{\text{add}} \\ E_{\text{ANN}} &\approx N_{\text{MAC}}\; e_{\text{MAC}} \end{aligned}

Symbols

eMAC=0.23 pJe_{\text{MAC}} = 0.23\ \text{pJ}
an 8-bit multiply-accumulate at 45 nm (Horowitz, 2014)
eadd=0.1 pJe_{\text{add}} = 0.1\ \text{pJ}
a 32-bit integer addition at 45 nm
NMAC(1)=72×64N^{(1)}_{\text{MAC}} = 72 \times 64
first-layer multiply-accumulates, done once per estimate
NMAC=8,832N_{\text{MAC}} = 8{,}832
all multiply-accumulates in the original network
FjF_j
fan-out: the number of connections leaving neuron j

In plain words

The energy model counts arithmetic only, using Horowitz's 45 nm figures: an 8-bit multiply-accumulate costs about 0.23 pJ and a 32-bit integer addition about 0.1 pJ. Each spike costs one addition per outgoing connection, so energy grows with how long the network runs.

What we found

05101548163264128256Time steps per estimate (log scale)Position error, rms (mm)
N1: position error of the spiking network as it runs for more time steps, against the network it was converted from (dashed)

Accuracy improves as the network runs longer, because firing rates need time to settle. At 64 steps the error was 1.10 mm; at 256 steps, 0.53 mm, against 0.33 mm for the original. Within 256 steps it never came within 10 % of the original.

02.557.51048163264128256Time steps per estimate (log scale)Energy per estimate (nJ)
N1: arithmetic energy per estimate (45 nm estimate, memory not included). Spiking network with integer arithmetic against the original network in 8-bit integers (dashed)

Arithmetic energy (a 45 nm estimate from Horowitz's ISSCC 2014 figures, memory not counted) grows with the number of steps, because every step brings more spikes. The spiking network used less arithmetic than the original in 8-bit integers (2.03 nJ) only up to 16 steps, where its error was 3.99 mm, far worse than the original's.

Spiking network against time steps (1,500 test positions)
StepsError, rms (mm)Spikes per estimateAdditionsEnergy, int (nJ)
415.75157291.13
87.81542,1961.28
163.991365,2461.58
322.0530211,4002.20
641.1063423,7393.43
1280.69129948,4245.90
2560.53262997,80310.84
0.1110100246810Arithmetic energy per estimate (nJ, integer)Position error, rms (mm, log)
N1: energy against accuracy. Each point on the curve is a number of time steps (4 to 256). Lower-left is better; the original network's 8-bit point is the dashed level.

Try it: slide through the time steps and watch accuracy and energy move together.

1.10 mmposition error, rmsoriginal network 0.33 mm
634spikes per estimate
24ksynaptic additions+ 4.6k first-layer MACs
3.43 nJarithmetic energyoriginal int8 2.03 nJ

Now at least as costly as the original and still 3.4× less accurate. This is why plain conversion is a poor deal here.

What it means

For this task, plain conversion is not worth it. The result matches what Intel's Loihi survey (Davies et al., 2021) reports: feedforward networks gain little on spiking hardware. The gains come from sparsity in time, recurrence and spike timing. A position estimate made from scratch every cycle uses none of those.

That pointed us to study N2: keep the network's state between samples, and do work only when the inputs change.

Limits: arithmetic-only energy, a simulated sensor model, and conversion without the later refinements (such as burst coding or fine-tuning after conversion) that shorten the settling time.

Sources

  1. Rueckauer et al., Frontiers in Neuroscience (2017)
  2. Davies et al., Proceedings of the IEEE (2021)
  3. Horowitz, ISSCC 2014