Event-driven sensing
Only compute what changed: event-driven position sensing for a levitating stage
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.
Symbols
- input i at sample t (a sensor reading or coil current, standardised)
- the last value input i sent
- change thresholds for inputs and hidden neurons
- the layer's running pre-activation sum, kept between samples
- 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
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.
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.
| Setting | Ops per sample | % of dense | Error, rms (mm) | Hovering ops | Moving ops |
|---|---|---|---|---|---|
| Dense | 8832 | 100 | 0.26 | ||
| exact (all changes) | 6498 | 73.6 | 0.26 | 6547 | 6454 |
| low thresholds | 1626 | 18.4 | 0.27 | 1596 | 1652 |
| medium thresholds | 308 | 3.5 | 0.42 | 240 | 367 |
| high thresholds | 66 | 0.7 | 0.83 | 28 | 97 |
| very high thresholds | 19 | 0.2 | 1.44 | 2 | 32 |
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.