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

Spiking Layer-Adaptive Magnitude-based Pruning
Mar 16, 2026Junqiao Wang, Zhehang Ye, Yuqi OuyangSpiking Neural Networks Neural Network Pruning
Sichuan University-Pittsburgh Institute, Sichuan University, Chengdu, 610207, China · College of Computer Science, Sichuan University, Chengdu, 610065, China
Bullet Trains: Parallelizing Training of Temporally Precise Spiking Neural Networks
Feb 27, 2026Todd Morrill, Christian Pehle, Anthony ZadorSpiking Neural Networks Neuromorphic Computing
Department of Computer Science, Columbia University, New York, NY, USA · Department of Neuroscience, Cold Spring Harbor Laboratory, Cold Spring Harbor, NY, USA
ADSEQ: A delay-aware autograd-compatible framework for spike-event delivery in SNNs
Dec 5, 2025Lennart P. L. Landsmeer, Amirreza Movahedin, Said Hamdioui +1Automatic Differentiation Spiking Neural Networks
Department of Computer Engineering, Delft University of Technology, Netherlands · NeuroComputingLab, Department of Neuroscience, Erasmus Medical Center, Netherlands

Mar 16, 2026J/K move · Enter open · S save

Spiking Layer-Adaptive Magnitude-based Pruning

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

Open paper AskPDF arXiv

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.

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