Collapse or Preserve: Data-Dependent Temporal Aggregation for Spiking Neural Network Acceleration

Jiahao Qin

cs.LGMar 14, 2026

Collapse or Preserve: Data-Dependent Temporal Aggregation for Spiking Neural Network Acceleration

Authors: Jiahao Qin

Abstract

Spike sparsity is widely believed to enable efficient spiking neural network (SNN) inference on GPU hardware. We demonstrate this is an illusion: five distinct sparse computation strategies on Apple M3 Max all fail to outperform dense convolution, because SIMD architectures cannot exploit the fine-grained, unstructured sparsity of i.i.d. binary spikes. Instead, we propose Temporal Aggregated Convolution (TAC), which exploits convolution linearity to pre-aggregate $K$ spike frames before a single convolution call, reducing $T$ calls to $T/K$ . On rate-coded data, TAC achieves 13.8times speedup with +1.6% accuracy on MNIST and +5.4% on Fashion-MNIST -- a simultaneous improvement in both speed and accuracy. However, on event-based data where the temporal dimension carries genuine motion information, TAC's temporal collapse is harmful. We therefore introduce TAC-TP (Temporal Preservation), which shares each group's convolution output across K independent LIF steps, preserving full temporal resolution for downstream layers. On DVS128-Gesture, TAC-TP achieves 95.1% accuracy (vs. 96.3% baseline) with 50% fewer convolution calls, while standard TAC drops to 91.3%. Our key finding is that the optimal temporal aggregation strategy is data-dependent: collapse the temporal dimension for rate-coded data (noise reduction) but preserve it for event data (information retention). Speedup is hardware-agnostic: TAC achieves 11.0times on NVIDIA V100, confirming the mechanism transfers across GPU architectures. All operators in the mlx-snn library are open source.

Figures & tables

Method	Speedup	Sparsity Used?	Failure Mode
Temporal Delta Conv	$1.28\times$	No	Temporal batching, not sparsity
Weight-Gather	$<1.0\times$	Attempted	Irregular memory access
Graph Compilation	$1.4\times$	No	General optimization
Sparse GEMM	$<1.0\times$	Attempted	No structured sparsity
Custom Metal SIMD	$0.01\times$	Attempted	Cannot beat vendor GEMM

Table 1: Five spike sparsity exploitation methods on Apple M3 Max. Dense Conv2d baseline: 1.0

\times

. None achieve meaningful sparsity-based speedup.

Figure 1: TAC (Temporal Collapse) operator. $K$ input spike frames are pre-aggregated with exponential decay weights into a single frame $A_{k}$ , which undergoes one Conv2d call (instead of $K$ ). The LIF neuron fires once per group, producing $T/K$ output timesteps. This temporal collapse acts as ensemble averaging on rate-coded data, improving accuracy while providing up to $13.8\times$ speedup.

Figure 2: TAC-TP (Temporal Preservation) operator. The same aggregation and single Conv2d call as TAC, but the output $Y_{k}$ is broadcast to $K$ independent LIF steps, each producing a separate output spike. This preserves the full temporal dimension $T$ , which is critical for event-based data where temporal structure encodes motion information.

Operator	Acc. (%)	$\Delta$	Speedup	Acc. (%)	$\Delta$	Speedup
	MNIST			Fashion-MNIST
Baseline	$97.22\pm 0.15$	—	$1.0\times$	$83.14\pm 0.77$	—	$1.0\times$
TAC $K$ =4	$98.78\pm 0.08$	+1.56	$5.3\times$	$87.98\pm 0.37$	+4.84	$5.5\times$
TAC $K$ =8	$\mathbf{98.85\pm 0.04}$	+1.63	$9.2\times$	$\mathbf{88.50\pm 0.24}$	+5.36	$9.3\times$
TAC $K$ =16	$98.82\pm 0.07$	+1.60	$\mathbf{13.8\times}$	$88.34\pm 0.16$	+5.20	$\mathbf{13.6\times}$
TAC-TP $K$ =4	$93.20\pm 1.78$	$-$ 4.02	$\sim$ 5 $\times$	$76.38\pm 0.36$	$-$ 6.76	$\sim$ 5 $\times$

Table 2: Results on MNIST and Fashion-MNIST (3 seeds, mean

\pm

std). TAC achieves simultaneous speedup and accuracy improvement. TAC-TP underperforms on rate-coded data because temporal preservation retains noise rather than signal.

Figure 3: TAC efficiency on rate-coded data (M3 Max). (a) Training speedup scales near-linearly with group size

K

, reaching

13.8\times

K\!=\!16

. (b) TAC simultaneously improves accuracy by

+1.6\%

(MNIST) and

+5.4\%

(FMNIST) through implicit ensemble averaging of Poisson samples.

Operator	Accuracy (%)	Conv Calls	Time/ep (s)	Speedup
Baseline	$96.30\pm 0.45$	80	69.0	$1.0\times$
TAC-TP $K$ =2	$95.13\pm 1.01$	40	57.5	$1.2\times$
TAC-TP $K$ =4	$93.8$	20	58.1	$1.2\times$
TAC-TP $K$ =8	$92.0$	10	56.0	$1.2\times$
TAC $K$ =2	$91.3$	40	46.6	$1.5\times$

Table 3: Results on DVS128-Gesture (

64\times 64

T\!=\!16

, 256 epochs). TAC-TP preserves temporal resolution and significantly outperforms TAC. Conv calls are counted per forward pass across all 5 conv layers.

Figure 4: DVS-Gesture efficiency comparison. (a) TAC-TP reduces convolution calls by

2

–

8\times

while TAC

K\!=\!2

uses the same 40 calls but collapses temporal resolution. (b) TAC-TP

K\!=\!2

retains

95.1\%

accuracy (

-1.2\%

), significantly outperforming TAC’s

91.3\%

. (c) Wall-clock training time per epoch shows meaningful reduction for all operators.

	MNIST			Fashion-MNIST
Operator	Acc. (%)	Time (s)	Speedup	Acc. (%)	Time (s)	Speedup
Baseline	$98.56\pm 0.24$	692	$1.0\times$	$88.11\pm 0.29$	682	$1.0\times$
TAC $K$ =4	$98.29\pm 0.05$	137	$5.1\times$	$82.97\pm 0.32$	137	$5.0\times$
TAC $K$ =8	$97.16\pm 0.10$	80	$8.7\times$	$75.86\pm 0.12$	82	$8.3\times$
TAC $K$ =16	$97.11\pm 0.14$	53	$\mathbf{13.1\times}$	$75.82\pm 0.39$	57	$\mathbf{12.0\times}$
TAC-TP $K$ =4	$97.84\pm 0.36$	455	$1.5\times$	$87.03\pm 0.72$	461	$1.5\times$

Table 4: Cross-platform validation on NVIDIA V100 (PyTorch/snnTorch, 3 seeds). Same architecture, hyperparameters, and epochs as M3 Max experiments. Training speedup computed from total training time.

Figure 5: Cross-platform speedup on MNIST. TAC’s near-linear speedup with

K

is consistent across Apple M3 Max (MLX) and NVIDIA V100 (PyTorch), confirming the mechanism is hardware-agnostic. TAC-TP provides modest speedup (

1.5\times

) as LIF dynamics still run per-timestep.

	Rate-Coded (MNIST)		Event (DVS-Gesture)
Strategy	$\Delta$ Acc	Speedup	$\Delta$ Acc	Speedup
TAC (collapse) $K$ =2	+1.6%	$\sim$ 2 $\times$	$-$ 5.0%	1.5 $\times$
TAC-TP (preserve) $K$ =2	—	—	$-$ 1.2%	1.2 $\times$

Table 5: Summary: TAC vs. TAC-TP across data types. The optimal strategy depends on whether the temporal dimension carries information (event) or noise (rate-coded).

Method	Architecture	MNIST	FMNIST	DVS-Gesture
STBP ( Wu et al., 2018 )	Conv, 5 layers	99.42	—	—
tdBN ( Zheng et al., 2021 ) †	ResNet-19	—	—	96.87
TCJA-SNN ( Zhu et al., 2024 ) †	TCJA-7B	—	94.80	97.60
SpikingJelly ( Fang et al., 2023 )	CSNN, 5 layers	—	—	93.75
snnTorch Baseline ‡	Conv, 2 layers	98.56	88.11	—
Ours: Baseline (M3 Max)	Conv, 2/5 layers	97.22	83.14	96.30

Table 6: Comparison with published SNN methods. Our contribution is speedup, not SOTA accuracy. Methods marked

\dagger

use significantly deeper architectures.

\ddagger

: our snnTorch reproduction on V100 with identical setup.

Appendix figures & tables4 assets

Supplementary material from the paper’s appendix.

Appendix

Operator	Seed 0	Seed 1	Seed 2	Mean $\pm$ Std
Baseline	97.09	97.43	97.13	$97.22\pm 0.15$
TAC $K$ =4	98.69	98.89	98.75	$98.78\pm 0.08$
TAC $K$ =8	98.81	98.90	98.83	$98.85\pm 0.04$
TAC $K$ =16	98.74	98.81	98.91	$98.82\pm 0.07$
TAC-TP $K$ =4	90.66	94.66	94.27	$93.20\pm 1.78$
TAC-TP $K$ =8	89.91	91.00	88.31	$89.74\pm 1.10$

Appendix

Table 7: Per-seed best test accuracy on MNIST (T=25, 15 epochs).

Operator	Seed 0	Seed 1	Seed 2	Mean $\pm$ Std
Baseline	82.07	83.91	83.45	$83.14\pm 0.77$
TAC $K$ =4	87.47	88.38	88.08	$87.98\pm 0.37$
TAC $K$ =8	88.48	88.21	88.81	$88.50\pm 0.24$
TAC $K$ =16	88.14	88.54	88.35	$88.34\pm 0.16$
TAC-TP $K$ =4	76.82	75.95	76.38	$76.38\pm 0.36$
TAC-TP $K$ =8	71.70	77.85	77.09	$75.55\pm 2.70$

Appendix

Table 8: Per-seed best test accuracy on Fashion-MNIST (T=25, 15 epochs).

Operator	Seed 0	Seed 42	Seed 123	Mean $\pm$ Std	Conv Calls
Baseline	95.8	96.9	96.2	$96.30\pm 0.45$	80
TAC-TP $K$ =2	94.1	94.8	96.5	$95.13\pm 1.01$	40
TAC-TP $K$ =4	—	93.8	—	$93.8$	20
TAC-TP $K$ =8	—	92.0	—	$92.0$	10
TAC $K$ =2	—	91.3	—	$91.3$	40

Appendix

Table 9: Per-seed best test accuracy on DVS128-Gesture (

64\times 64

, 256 epochs with warm restarts).

Parameter	MNIST / FMNIST	DVS-Gesture
Timesteps ( $T$ )	25	16
Batch size	128	16
Learning rate	$10^{-3}$	$10^{-3}$
LR schedule	Cosine annealing	Cosine w/ warm restarts ( $T_{\text{max}}$ =64)
Optimizer	Adam	Adam
Epochs	15	256

Appendix

Table 10: Full hyperparameter configuration for all experiments.

Spiking Neural Networks

Spiking neural networks process information through discrete, time-dependent neural events, aiming for efficient computation and biologically inspired learning.

See all 336 papers

Mar 16, 2026

Spiking Layer-Adaptive Magnitude-based Pruning

Spiking Neural Networks (SNNs) provide energy-efficient computation but their deployment is constrained by dense connectivity and high spiking operation costs. Existing magnitude-based pruning strategies, when naively applied to SNNs, fail to account for temporal accumulation, non-uniform timestep contributions, and membrane stability, often leading to severe performance degradation. This paper proposes Spiking Layer-Adaptive Magnitude-based Pruning (SLAMP), a theory-guided pruning framework that generalizes layer-adaptive magnitude pruning to temporal SNNs by explicitly controlling worst-case output distortion across layers and timesteps. SLAMP formulates sparsity allocation as a temporal distortion-constrained optimization problem, yielding time-aware layer importance scores that reduce to conventional layer-adaptive pruning in single-timestep limit. An efficient two-stage procedure is derived, combining temporal score estimation, global sparsity allocation, and magnitude pruning with retraining for stability recovery. Experiments on CIFAR10, CIFAR100, and the event-based CIFAR10-DVS datasets demonstrate that SLAMP achieves substantial connectivity and spiking operation reductions while preserving accuracy, enabling efficient and deployable SNN inference.

Junqiao Wang, Zhehang Ye, Yuqi Ouyang

Sichuan University-Pittsburgh Institute, Sichuan University, Chengdu, 610207, China · College of Computer Science, Sichuan University, Chengdu, 610065, China

Spiking Neural Networks Neural Network Pruning Efficient Neural Network Inference

Ask PDF

Feb 27, 2026

Bullet Trains: Parallelizing Training of Temporally Precise Spiking Neural Networks

Continuous-time, event-native spiking neural networks (SNNs) operate strictly on spike events, treating spike timing and ordering as the representation rather than an artifact of time discretization. This viewpoint aligns with biological computation and with the native resolution of event sensors and neuromorphic processors, while enabling compute and memory that scale with the number of events. However, two challenges hinder practical, end-to-end trainable event-based SNN systems: 1) exact charge--fire--reset dynamics impose inherently sequential processing of input spikes, and 2) precise spike times must be solved without time bins. We address both. First, we use parallel associative scans to consume multiple input spikes at once, yielding up to 44x speedups over sequential simulation while retaining exact hard-reset dynamics. Second, we implement differentiable spike time solvers that compute spike times to machine-precision without discrete-time approximations or restrictive analytic assumptions. We demonstrate the viability of training SNNs using our solutions on four event-based datasets on GPUs.

Todd Morrill, Christian Pehle, Anthony Zador

Department of Computer Science, Columbia University, New York, NY, USA · Department of Neuroscience, Cold Spring Harbor Laboratory, Cold Spring Harbor, NY, USA

Spiking Neural Networks Neuromorphic Computing

Ask PDF

Dec 5, 2025

ADSEQ: A delay-aware autograd-compatible framework for spike-event delivery in SNNs

Spiking neural networks (SNNs), central to computational neuroscience and neuromorphic machine learning (ML), require efficient simulation and gradient-based training. While AI accelerators offer promising speedups, gradient-based SNNs typically implement sparse spike events using dense, memory-heavy data-structures. Existing exact gradient methods lack generality, and current simulators often omit or inefficiently handle delayed spikes. We address this by deriving gradient computation through spike event queues, including delays, and implementing this into memory-efficient, autodifferentiable spike event queues (ADSEQ). These are benchmarked across CPU, GPU, TPU, and LPU platforms. We find that queue design strongly shapes performance. CPUs, as expected, perform well with traditional tree-based or FIFO implementations, while GPUs excel with ring buffers for smaller simulations, yet under higher memory pressure prefer more sparse data-structures. TPUs seem to favor an implementation based on sorting intrinsics. Selective spike dropping provides a simple performance-accuracy trade-off, which could be enhanced by future autograd frameworks adapting diverging primal/tangent data-structures.

Lennart P. L. Landsmeer, Amirreza Movahedin, Said Hamdioui +1

Department of Computer Engineering, Delft University of Technology, Netherlands · NeuroComputingLab, Department of Neuroscience, Erasmus Medical Center, Netherlands

Automatic Differentiation Spiking Neural Networks

Ask PDF

Abstract

Spiking Neural Networks

Explore similar work

Spiking Layer-Adaptive Magnitude-based Pruning

Bullet Trains: Parallelizing Training of Temporally Precise Spiking Neural Networks

ADSEQ: A delay-aware autograd-compatible framework for spike-event delivery in SNNs