Counting Energy

Spiking networks are usually introduced with one promise: they save energy. Spikes are sparse, a spike only needs an addition instead of a multiplication, and silent neurons cost nothing. This post checks that promise on the network trained in Training Spiking Networks, the spiking CNN that recognises DVS Gesture recordings, and compares it with two conventional CNNs with the same layers: one that runs on every 60 ms frame, like a camera at 16.7 frames per second, and one that sees the whole recording summed into a single image.

There is no neuromorphic chip on my desk, and timing a spiking network on a GPU measures PyTorch rather than the network. So the energy is counted: NeuroBench measures how much work each network does on the real test data, and published energies per operation turn that work into joules. The answer depends on what the spiking network is compared with, and the reasons are instructive.

1. Three Kinds of Work

A neural network on any hardware does three kinds of arithmetic that matter here:

• A multiply-accumulate (MAC), $y+=w\cdot x$, is what every connection of a conventional network does, for every input, on every pass.
• An accumulate (AC), $y+=w$, is what a connection does when its input is a spike: multiplying by 1 is not needed. When the input is 0, an event-driven chip does nothing at all.
• A neuron update, $U\leftarrow \beta U+I-S\theta$, is what every spiking neuron does at every time step. It has no counterpart in a ReLU network, which has no state.

Counting these three, per sample, is the hardware-independent part of the energy question. The cost of each one depends on the chip.

2. What NeuroBench Counts

NeuroBench (Yik et al., 2025) is a community benchmark framework for neuromorphic algorithms and systems. Its algorithm track does not report joules; it reports workload metrics, measured by hooks attached to a trained model while it runs on test data:

Metric	What it counts
Dense synaptic operations	every connection, as a GPU computes it, zeros included
Effective MACs	connections with a non-zero input, in layers whose input is not binary
Effective ACs	connections with a non-zero input, in layers whose input is only 0 and ±1
Neuron operations	membrane updates × a fixed number of operations per neuron type (4 for snntorch’s Leaky with subtract reset)
Activation sparsity	the fraction of neuron outputs that are 0
Footprint	bytes of parameters and buffers

The rule that decides MAC or AC is simple and strict: NeuroBench looks at a layer’s whole input tensor. If every value is 0 or ±1, the layer is spiking and its effective operations are ACs; a single other value makes all of them MACs. Bias, pooling and normalisation are not counted. Try the rule on a small layer:

Converting counts to joules

Joules come from multiplying the counts by an energy per operation, a step outside NeuroBench. I use two estimates:

$E_{\text{dense}}=N^{\text{dense}}\cdot E_{\text{MAC}}$

$E_{\text{event}}=N_{\text{MAC}}^{\text{eff}}\cdot E_{\text{MAC}}+N_{\text{AC}}^{\text{eff}}\cdot E_{\text{SOP}}+N_{\text{neuron}}\cdot E_{\text{neuron}}$

$E_{\text{dense}}$ is a conventional processor that computes every connection; $E_{\text{event}}$ is an event-driven chip that only touches active connections. The constants:

Constant	Value	Source
$E_{\text{MAC}}$	4.6 pJ	a 32-bit floating-point multiply (3.7 pJ) plus add (0.9 pJ) at 45 nm (Horowitz, 2014)
$E_{\text{SOP}}$	10 pJ nominal, varied from 1 to 23.6 pJ	an assumed spike-triggered accumulate; 23.6 pJ is the minimum energy per synaptic spike operation reported for Intel’s Loihi (Davies et al., 2018)
$E_{\text{neuron}}$	5 pJ per counted operation	assumed; 20 pJ per Leaky update

Two things about these constants matter for everything below. First, they are scenarios, not measurements: change them and the counts stay valid. Second, they do not describe the same thing. 4.6 pJ is the arithmetic alone; Loihi’s 23.6 pJ is a whole synaptic event on a real chip, including reading the weight and routing the spike. That is why an AC can cost more than a MAC here, the opposite of the usual “an addition is 5× cheaper than a multiply-accumulate” (0.9 vs 4.6 pJ). Memory access is not priced in either estimate.

Running it on our networks

The three networks share the same layers and the same 43,419 parameters; they differ only in how time enters:

NeuroBench only finds neurons it knows. The spiking CNN from the previous post computes its LIF update in a plain Python function, so I rebuilt it with snntorch’s Leaky neuron (β = 0.9, θ = 1, subtract reset), which performs exactly the same computation: the rebuilt network produces the same output spike counts as the original on all 264 test recordings, for all three trained seeds. The two CNNs got nn.ReLU modules for the same reason. The frame CNN is the same CNN applied to each 60 ms frame on its own, with the 30 score vectors averaged; it was trained like the others (3 seeds, same data and schedule) and is described in the previous post. All three run through NeuroBench 2.3.0, unmodified, on the full test set. The scripts are in energy (zip), and the Colab notebook of the previous post trains all three networks and counts their operations with the same rule (it reproduces NeuroBench’s counts exactly on the networks used here).

Try it yourself Section 6 of the notebook prints the counts and energies of your own run; change E_SOP to 1 or 23.6 pJ to see how the comparison moves. In Colab, choose Runtime → Change runtime type → GPU, then Runtime → Run all. The notebook file is also in the repository: dvs_gesture_snn.ipynb.

3. The Counts

Per test recording (1.8 s, 30 steps of 60 ms), mean of the three trained seeds:

	Spiking CNN	CNN on every frame	CNN on the summed image
Test accuracy (NeuroBench)	88.5%	85.1%	84.5%
Parameters / footprint	43,419 / 174 KB	43,419 / 174 KB	43,419 / 174 KB
Dense synaptic operations	137.0 M (4.57 M per step × 30)	137.0 M (4.57 M per frame × 30)	4.57 M
Effective MACs	5.99 M (first layer only)	96.1 M	3.30 M
Effective ACs	13.8 M	0	0
Membrane updates / neuron ops	215,370 / 861,480	0	0
Activation sparsity	0.89	0.26	0.34

Three things stand out.

Only 15% of the dense work happens. The spiking network’s neurons fire in 6–15% of steps (12%, 11%, 6% and 15% in the four layers, seed 0), so most connections are idle at any moment. The frame CNN does exactly the same dense work, 30 passes over the same frames, but its ReLU outputs are zero only 26% of the time, so even skipping every zero leaves 70% of the work. That is the real advantage of spikes.

The first layer is not spiking. Its input is the log event count per pixel, $\log (1+n)$, which is not 0 or 1. NeuroBench therefore counts all of conv1 as MACs: 6.0 M of them, more than the whole summed-image CNN performs (3.3 M effective, 4.6 M dense). A spiking network is only as spiking as its input.

The work is repeated 30 times. The spiking network runs once per 60 ms step, like the frame CNN; the summed-image CNN runs once per recording. Every neuron also updates at every step, $7,179\times 30=215,370$ times, because the leak changes every non-zero membrane even when nothing arrives.

4. The Energy

With the constants above (seed 0 shown; the interactive version has all three seeds):

	Energy per recording (3 seeds)	Accuracy
Spiking CNN, event-driven ($E_{\text{event}}$)	170 ± 5 µJ	88.5%
Spiking CNN, run densely ($E_{\text{dense}}$)	630 µJ	88.5%
CNN on every frame, dense	630 µJ	85.1%
CNN on every frame, zeros skipped	442 ± 3 µJ	85.1%
CNN on the summed image, dense	21.0 µJ	84.5%

Against the network that sees the same frames at the same rate, the spiking network wins on both counts: it needs 3.7× less energy than the frame CNN run densely, 2.6× less than the frame CNN with every zero input skipped, and it is 3.4 points more accurate. The same factor 3.7 separates it from itself run densely, because dense execution costs the same for both networks.

The summed-image CNN is a different matter: it needs 8× less than the spiking network, because it runs once instead of 30 times. It pays with accuracy, and with clockwise/counter-clockwise confusions, but on energy it is in a class of its own. Of seed 0’s 177 µJ, 144.7 µJ are spike-triggered accumulates, 27.6 µJ the first layer’s MACs and 4.3 µJ neuron updates.

The comparison is sensitive to $E_{\text{SOP}}$, so here is the whole range:

$E_{\text{SOP}}$	Spiking CNN, event-driven	vs. frame CNN, dense (630 µJ)	vs. frame CNN, zeros skipped (442 µJ)	vs. summed-image CNN (21.0 µJ)
1 pJ	45.7 µJ	13.8× less	9.7× less	2.2× more
10 pJ	170.2 µJ	3.7× less	2.6× less	8.1× more
23.6 pJ	358.3 µJ	1.8× less	1.2× less	17× more

Even at $E_{\text{SOP}}=0$ the spiking network would need 31.9 µJ, because the first layer (27.6 µJ) and the neuron updates (4.3 µJ) alone exceed the summed-image CNN’s 21.0 µJ. With 8-bit integer MACs (0.23 pJ; Horowitz, 2014) that CNN drops to 1.05 µJ and the frame CNN to 22 µJ with zeros skipped, both cheaper than the spiking network, unless its synaptic events became cheaper in the same way.

Stopping early

The spiking network and the frame CNN both produce an answer at every step, so both can stop when they are sure enough; the CNN on the summed image always needs the whole 1.8 s window. Accuracy against energy, if they stop after $t$ steps:

Stop after	Spiking CNN: accuracy	energy at $E_{\text{SOP}}$ = 1 / 10 / 23.6 pJ	Frame CNN: accuracy	energy, dense / zeros skipped
1 step (0.06 s)	9.1%	1.2 / 2.1 / 3.5 µJ	59.5%	21.0 / 14.9 µJ
10 steps (0.6 s)	77.6%	15.0 / 52.7 / 110 µJ	79.8%	210 / 148 µJ
15 steps (0.9 s)	83.0%	22.7 / 82.0 / 172 µJ	81.1%	315 / 222 µJ
20 steps (1.2 s)	85.7%	30.4 / 112 / 234 µJ	84.6%	420 / 295 µJ
30 steps (1.8 s)	88.5%	45.7 / 170 / 358 µJ	85.1%	630 / 442 µJ
CNN, summed image			84.5%	21.0 µJ

The two per-frame networks behave differently at the start. The frame CNN is right 60% of the time after a single frame, because every frame is a complete picture to it; the spiking network needs a few steps before any output neuron fires, and is at chance after one. At the same number of steps the frame CNN stays more accurate until about step 15; at the same energy, the spiking network is ahead for any budget above about 35 µJ (at $E_{\text{SOP}}$ = 10 pJ), because one of its steps costs 5.7 µJ against 21 µJ for a dense frame-CNN pass (14.7 µJ with zeros skipped). Against the summed-image CNN, only the optimistic end, $E_{\text{SOP}}=1$ pJ, comes close: about the same energy for about the same accuracy after 15 steps, with the answer 0.9 s earlier.

What would it take?

The counts show where the energy goes, so they also show what would have to change. These are arithmetic on the measured counts, not new experiments:

• Spiking input. If the input were 0/1 events instead of log counts, conv1’s 6.0 M operations would become ACs. At $E_{\text{SOP}}=1$ pJ the full 30 steps would cost about 24 µJ instead of 46 µJ. At 10 pJ it would cost more (about 200 µJ), because then an AC is dearer than a MAC. This network was not trained on binary input, so its accuracy there is unknown.
• Fewer steps or a cheaper synaptic event. Both scale the dominant AC term directly.
• Sparser activity. The AC count is proportional to the firing rates; spike-count regularisation during training (in the bag of tricks of the previous post) would reduce it, usually at some cost in accuracy.

So the answer depends on the question. Against a conventional network that processes the same stream of frames, the spiking network is cheaper and more accurate. Against a network that waits for the whole recording and looks once, it is not cheaper; that network is unusually cheap because it throws time away, and it pays with 4 accuracy points and many more direction confusions. “Spiking” does not mean “efficient” by itself: the input, the number of steps and the price of a synaptic event decide.

5. Mistakes That Make Counts Wrong

A neuron NeuroBench does not know is counted as zero. It only hooks layers it recognises, and an unrecognised module is not an error, it is simply invisible. Running the original version of our network, whose LIF update is a plain function, through the same benchmark gives:

Metric	LIF as a function	LIF as snntorch Leaky
Effective ACs	14.5 M	14.5 M
Neuron operations	0	861,480
Membrane updates	0	215,370
Activation sparsity	0.0	0.89

The synaptic counts are right because the convolutions are standard layers, but the neurons have disappeared: their energy is zero, and the activation sparsity of 0.0 reads as “every neuron is active all the time”. A custom neuron, a recurrent cell written with raw matrices, or an attention block needs its own hook or an analytical count. When a model looks cheaper than expected, check what was not counted.

Footprint counts state buffers at whatever size they last had. snntorch keeps the membrane potentials as buffers, and NeuroBench’s footprint includes buffers. My first run reported 7.75 MB instead of 174 KB, because an earlier check had pushed all 264 test recordings through the network in one batch and left 264 copies of the membrane state behind. Benchmark a freshly loaded model.

A layer’s MAC or AC label comes from its input, not from the network’s name. A “spiking” network with a real-valued first layer, or with an attention block on real values, has MACs. In this network they are 16% of the energy at $E_{\text{SOP}}$ = 10 pJ, and 86% at 0 pJ.

6. What the Counts Leave Out

The estimates above price arithmetic only. A real chip also pays for:

• Memory. Reading 64 bits from a small 8 KB SRAM costs about 10 pJ, from DRAM 1.3–2.6 nJ (Horowitz, 2014): more than any operation above. Whether weights and membrane states stay in local memory often decides the result. Hardware-aware studies that include memory find that many claimed savings of spiking networks shrink or vanish (Lemaire et al., 2022; Dampfhoffer et al., 2023).
• Bias, pooling, routing and control, which NeuroBench’s operation counts leave out by design.
• The sensor. An event camera produces data only where something changes, and that saving happens before any network runs. A complete comparison counts the camera as well: an RGB camera plus a frame-based network against an event camera plus a spiking network. That system-level question is the subject of the last post in this series.

NeuroBench’s system track exists for the measured version of all this: energy and latency on real hardware.

7. Common Claims, Checked

Claim	Verdict
”Spiking networks are 10–100× more energy-efficient than ANNs.”	It depends on the reference. On DVS Gesture, across the whole range of assumed synaptic costs, the event-driven spiking CNN was 1.2–10× cheaper than the same CNN running on every frame (even with every zero input skipped) and 1.8–14× cheaper than itself run densely, but 2–17× more expensive than a CNN that looks once at the time-summed event image.
”An addition costs a fraction of a multiply-accumulate, so spikes are cheap.”	In arithmetic, yes: 0.9 vs 4.6 pJ at 45 nm. On real neuromorphic hardware a synaptic event includes memory and routing; Loihi reports at least 23.6 pJ per synaptic spike operation.
”Sparse activity means low energy.”	Against the same workload, yes: over the same 30 frames the spiking network performs 13.8 M accumulates where the frame CNN performs 96 M multiply-accumulates. But sparsity does not undo the 30 steps: a single pass of the summed-image CNN is only 4.6 M operations.
”NeuroBench measures energy.”	Its algorithm track counts operations; joules come from constants you choose, which should be stated. Its system track measures energy on hardware.
”In a spiking network, every layer does accumulates.”	Only layers whose input is 0/±1. A real-valued input, such as event counts, makes the first layer multiply-accumulates; here that layer alone cost more than the whole summed-image CNN.
”Neuron updates are negligible.”	Here they were 2.4% of the energy (4.3 µJ), but every neuron updates at every step, and neurons with more state (adaptive thresholds, synaptic currents) cost several times more per update.
”If NeuroBench reports zero, the cost is zero.”	Not for layers it does not recognise: our LIF written as a function was reported with 0 neuron operations and an activation sparsity of 0.0.

---

Summary

Idea	In one line
Three kinds of work	MACs for real-valued inputs, ACs for spikes, and a state update per neuron per step
NeuroBench	counts Dense, effective MACs, effective ACs and neuron operations on real data; joules are your assumption
The MAC/AC rule	decided per layer from the input tensor: one value outside {0, ±1} makes the layer MACs
On DVS Gesture	170 µJ for the event-driven spiking CNN (88.5%), 442–630 µJ for a CNN on every frame (85.1%), 21 µJ for a CNN on the summed image (84.5%), at 10 pJ per synaptic event
Why	spikes skip 85% of the work that a frame CNN does; but a real-valued first layer, 30 steps, and a synaptic event priced above a MAC keep it above a single pass
What helps	spiking input, fewer steps, sparser activity, stopping early, and a cheaper synaptic event

Next: From ANN to Akida: Converting a Frame CNN with CNN2SNN: the other route to a spiking network, a trained and quantized CNN converted for BrainChip’s Akida chip, and how its events compare with the spiking network’s.

---

References

Benchmarks and energy estimation

• Yik, J., Van den Berghe, K., den Blanken, D., et al. (2025). The NeuroBench framework for benchmarking neuromorphic computing algorithms and systems. Nature Communications, 16. arXiv:2304.04640
• Horowitz, M. (2014). Computing’s energy problem (and what we can do about it). IEEE International Solid-State Circuits Conference (ISSCC), 10–14.
• Lemaire, E., Cordone, L., Castagnetti, A., Novac, P.-E., Courtois, J., & Miramond, B. (2022). An analytical estimation of spiking neural networks energy efficiency. ICONIP. arXiv:2210.13107
• Dampfhoffer, M., Mesquida, T., Valentian, A., & Anghel, L. (2023). Are SNNs really more energy-efficient than ANNs? An in-depth hardware-aware study. IEEE Transactions on Emerging Topics in Computational Intelligence, 7(3).

Hardware

• Davies, M., Srinivasa, N., Lin, T.-H., et al. (2018). Loihi: A neuromorphic manycore processor with on-chip learning. IEEE Micro, 38(1), 82–99.

Data and tools

• Amir, A., Taba, B., Berg, D., et al. (2017). A low power, fully event-based gesture recognition system. CVPR.
• Eshraghian, J. K., Ward, M., Neftci, E. O., et al. (2023). Training spiking neural networks using lessons from deep learning. Proceedings of the IEEE, 111(9), 1016–1054. (snntorch)