Menu

Event-driven sensing

Only compute what changed: event-driven position sensing for a levitating stage

Study · NeuromorphicNovember 18, 2026Senova Systems Research

A delta network that passes on only the changes in its inputs and activations did 18.4 % of the arithmetic of the same network run in full (5 times less), for 5 % more position error, at 5,000 estimates a second.

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

A control loop that reads a levitating puck 5,000 times a second does the same full computation every time, even though the puck spends much of its time hovering and the readings barely change from one sample to the next. Neuromorphic hardware's real advantage is to skip that repeated work. How much of it can be skipped, and what does it cost in accuracy?

What we did

We simulated 8 seconds of operation at 5 kHz: the puck alternating between hovering and smooth moves, the coil currents following it, and sensor noise on every reading. We ran the same trained network two ways. Dense: the full calculation on every sample (8,832 multiply-accumulates). Delta: each input is passed on only when it has changed by more than a threshold since it was last sent, and each hidden neuron passes on only changes in its output. This is the idea behind sigma-delta and delta networks (O'Connor and Welling, 2017; Neil et al., 2017). It runs on ordinary processors and is native to event-driven chips.

Δxi[t]={xi[t]−x^iif ∣xi[t]−x^i∣>θin(then x^i←xi[t])0otherwisez[t]=z[t−1]+∑i : Δxi[t]≠0W:,i Δxi[t]a[t]=ReLU⁡ ⁣(z[t]),Δaj sent only if ∣aj−a^j∣>θhidcost[t]=64⋅∣{ i:Δxi[t]≠0 }∣versus72×64=4,608 dense\begin{aligned} \Delta x_i[t] &= \begin{cases} x_i[t] - \hat{x}_i & \text{if } \lvert x_i[t] - \hat{x}_i \rvert > \theta_{\text{in}} \quad (\text{then } \hat{x}_i \leftarrow x_i[t]) \\ 0 & \text{otherwise} \end{cases} \\[6pt] \mathbf{z}[t] &= \mathbf{z}[t-1] + \sum_{i \,:\, \Delta x_i[t] \neq 0} W_{:,i}\, \Delta x_i[t] \\[6pt] \mathbf{a}[t] &= \operatorname{ReLU}\!\big(\mathbf{z}[t]\big), \qquad \Delta a_j \ \text{sent only if } \lvert a_j - \hat{a}_j \rvert > \theta_{\text{hid}} \\[6pt] \text{cost}[t] &= 64 \cdot \big\lvert \{\, i : \Delta x_i[t] \neq 0 \,\} \big\rvert \quad \text{versus} \quad 72 \times 64 = 4{,}608 \ \text{dense} \end{aligned}

Symbols

xi[t]x_i[t]
input i at sample t (a sensor reading or coil current, standardised)
x^i\hat{x}_i
the last value input i sent
θin, θhid\theta_{\text{in}},\ \theta_{\text{hid}}
change thresholds for inputs and hidden neurons
z[t]\mathbf{z}[t]
the layer's running pre-activation sum, kept between samples
W:,iW_{:,i}
the column of weights belonging to input i

In plain words

Each input remembers the last value it sent. It sends again only when it has moved more than the threshold, and then only the difference. The layer keeps its running sum, so each event costs one column of weights (64 multiply-accumulates) instead of the whole matrix. Hidden layers do the same with their outputs. With the thresholds at zero this gives exactly the dense result.

What we found

Dense network8832 opsDelta, exact (all changes)6498 opsDelta, low thresholds1626 opsDelta, medium thresholds308 opsDelta, high thresholds66 opsDelta, very high thresholds19 opsShorter is better.
N2: arithmetic operations per sample at 5 kHz. The dense network does the same work on every sample; the delta network only works on changes.

Try it: move the threshold and watch the work and the error over time. Work drops while the stage hovers and rises when it moves.

1.6koperations per sampledense 8.8k
5.4×less arithmetic
0.27 mmposition error, rmsdense 0.26 mm
1.6kops while hovering1.7k while moving
1.0k10k00.511.5Time (s)Ops per sample
Work per sample over the first 2 s (50 ms bins, log scale). Shaded: the stage is moving.Stage moving
00.511.5200.511.5Time (s)Error (mm)
Position error over the same 2 s (rms per 50 ms bin)Stage moving

Even with no threshold, passing on only non-zero changes cut the work to 73.6 % of dense, with identical output. Sensor noise changes every input slightly on every sample, so thresholds do the real work. With low thresholds the network did 18.4 % of the dense arithmetic for 0.27 mm error against 0.26 mm. With high thresholds it did 0.7 % of the work, 134 times less, for 0.83 mm. While hovering it averaged 28 operations per sample, against 97 while moving.

00.511.5020406080100Operations, % of densePosition error, rms (mm)
N2: the trade-off. Each point is a threshold setting: work done (as a share of the dense network) against position error.
Delta network settings, 8 s at 5 kHz (thresholds: inputs in standard deviations, hidden in activation units)
SettingOps per sample% of denseError, rms (mm)Hovering opsMoving ops
Dense88321000.26
exact (all changes)649873.60.2665476454
low thresholds162618.40.2715961652
medium thresholds3083.50.42240367
high thresholds660.70.832897
very high thresholds190.21.44232

What it means

This is where event-driven computing pays off: the same network, the same accuracy within a few percent, and a fraction of the arithmetic, because most samples carry little news. The threshold is a dial between work and accuracy that a controller could turn at run time: low while the stage moves, high while it hovers.

Arithmetic is not the whole energy bill. Moving weights from memory often costs more than the arithmetic (Horowitz, 2014). A delta network still touches one row of weights per event, so savings in memory traffic should follow, but a measurement on a chip will settle by how much.

Limits: simulated sensors and paths; operation counts, not chip measurements; thresholds tuned by hand, not learned.

Sources

  1. O'Connor and Welling, Sigma-delta quantized networks (ICLR 2017)
  2. Neil et al., Delta networks for optimized recurrent network computation (ICML 2017)
  3. Horowitz, ISSCC 2014