Bullet Trains: Parallelizing Training of Temporally Precise Spiking Neural Networks
Authors: Todd Morrill, Christian Pehle, Anthony Zador
Organizations: Department of Computer Science, Columbia University, New York, NY, USA · Department of Neuroscience, Cold Spring Harbor Laboratory, Cold Spring Harbor, NY, USA
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.
Figures & tables
Figure 1: Our parallel method achieves up to 44x speedups over serial processing of spike events on several event-based datasets while retaining exact hard-reset dynamics. The plot shows results for the Spiking Heidelberg Digits (SHD) dataset.
Figure 2: Our contributions visualized—state trajectory of a LIF neuron consuming input spikes in parallel and producing an output spike with our Newton-Raphson solver. A shows the neuron jumping from the initial state s0 at time 0 (composed of membrane potential and synaptic current) directly to all future states s1=f1(s0),s2=f2(s0),… in parallel using associative scans. We use lightweight analytical checks to determine if an output spike will occur in the interval between any consecutive pair of input spikes by computing—in parallel— tVmax(s) , the time of maximum voltage starting at the interval’s left endpoint, and V(tVmax) the voltage at that time. The voltage state is hard reset at the spike time. B shows our iterative Newton-Raphson solver finding the output spike time t⋆ , computed to machine-precision.
Figure 3: Discrete-time binning causes quantization errors and loses spike ordering. Here, two spikes occurring at different times (0.0021s and 0.0027s) both round to 0.003s, making them indistinguishable to downstream neurons.
Figure 4: An example input queue feeding a neuron and producing an output queue. The input chunk size is 4 spikes, which means 4 input spikes are consumed in parallel. After consuming 3 input spikes in chunk 1, the neuron produces an output spike. The work done to consume the 4th input spike in chunk 1 is discarded, and the next chunk resumes processing input spikes immediately after the output spike time.
Figure 5: Spike time as a function of synaptic weight for different time constant configurations. Discrete-time approximation with Δt=1ms diverges from the ground truth spike time at nearly all weight values, while our method closely tracks the ground truth spike time.
Figure 6: Training time per batch as we vary chunk size on the SHD dataset with hidden dimensions ranging from 128 to 512 and batch size ranging from 32 to 128. Averages are taken over 100 batches.
Figure 7: Convergence of the Newton-Raphson and Bisection solvers towards the ground truth spike time.
Figure 8: Speedup of our parallel SNN implementation over a sequential event-based SNN implementation with exact hard-reset dynamics on the SHD dataset as we vary the hidden dimension and batch size. The model architecture uses 2 feedforward hidden layers and delays. Averages are taken over 100 batches (forward and backward pass) over 3 runs and chunk size is set to 128.
Dataset
Model
Exact Gradients
Continuous Spike Times
Parallelized
Compute Depth
Memory
Accuracy
MNIST
1F350H, τm=2τs ( Göltz et al., 2021 )
✓
✓
x
O(N)
O(N)
97.20 (0.10)
1F350H ( Wunderlich & Pehle, 2021 )
✓
✓
x
O(N)
O(N)
97.60 (0.10)
1F350H (Ours)
✓
✓
✓
O(ClogK)
O(N)
98.04 (0.07)
SHD
2F256HD ( Hammouamri et al., 2024 )
x
x
x
O(T)
O(T)
95.07 (0.24)
2F512HD ( Mészáros et al., 2025 )
✓
x
x
O(T)
O(N)
93.10
2F256HD (Ours)
✓
✓
✓
O(ClogK)
O(N)
94.77 (0.46)
Table 1: Classification accuracy comparison on event-based datasets. Model architectures are defined by number of layers and connectivity pattern (F for feedforward, R for recurrent), number of hidden units (H), and use of delays (D) (e.g., 2F512HD means 2 layers, feedforward connectivity, 512 hidden units, and use of delays). N is the number of spikes processed by a single neuron and T is the number of time steps in the simulation. Our metrics are averaged over 5 random seeds and standard deviation is reported in parentheses.
Figure 9: Impact of temporal discretization on Yin-Yang classification. We trained our method under different discrete-time constraints by quantizing spike times to multiples of Δt during training and testing. Accuracy degrades significantly as Δt increases, dropping to near-chance ( 33% ) at Δt≥2 ms. Continuous spike times ( Δt→0 , our standard method) maintain the highest accuracy, demonstrating that discrete-time methods would require Δt≪1 ms—incurring substantial computational costs—to preserve temporal information.
Appendix figures & tables8 assets
Supplementary material from the paper’s appendix.
Appendix
Parameter
Yin-Yang Value
MNIST Value
SHD Value
SSC Value
Optimizer
Adam
Adam
Adam
Adam
Learning Rate Schedule
Cosine Decay
Exponential
Cosine Decay
Cosine Decay
Cosine Decay Steps
6000
—
10000
88500
Learning Rate
0.02
0.02
0.001
0.001
Learning Rate End Value
0.0001
0.001
0.0001
0.0001
Learning Rate Decay Factor
—
0.95
—
—
Appendix
Table 2: System hyperparameters across the 3 datasets used.
Figure 10: Speedup of our parallel SNN implementation over a sequential event-based SNN implementation with exact hard-reset dynamics on the SSC dataset as we vary the hidden dimension and batch size. The model architecture uses 2 feedforward hidden layers and delays. Averages are taken over 100 batches (forward and backward pass) over 3 runs and chunk size is set to 128.
Hidden Layer Size
Batch Size
Computation Mode
Avg. Runtime (std. dev.)
128
32
Parallel
0.193 (0.003)
Serial
8.075 (0.212)
64
Parallel
0.284 (0.003)
Serial
8.195 (0.033)
128
Parallel
0.457 (0.004)
Serial
8.510 (0.067)
Appendix
Table 3: Average training time (forward and backward pass) per batch in seconds on the SSC dataset for our parallel SNN implementation versus a sequential event-based SNN implementation with exact hard-reset dynamics. The model architecture uses 2 feedforward hidden layers and delays. Averages are taken over 100 batches (forward and backward pass) over 3 runs and chunk size is set to 128.
Hidden Layer Size
Batch Size
Computation Mode
Avg. Runtime (std. dev.)
128
32
Parallel
0.189 (0.001)
Serial
8.352 (0.022)
64
Parallel
0.277 (0.002)
Serial
8.167 (0.044)
128
Parallel
0.449 (0.003)
Serial
8.614 (0.034)
Appendix
Table 4: Average training time (forward and backward pass) per batch in seconds on the SHD dataset for our parallel SNN implementation versus a sequential event-based SNN implementation with exact hard-reset dynamics. The model architecture uses 2 feedforward hidden layers and delays. Averages are taken over 100 batches (forward and backward pass) over 3 runs and chunk size is set to 128.
Method
Epoch Training Time (s) ↓
Max Memory (MiB) ↓
256 ( Hammouamri et al., 2024 )
157.89
8,978
512 ( Hammouamri et al., 2024 )
338.94
16,366
256 ( Mészáros et al., 2025 )
38.93
4,824
512 ( Mészáros et al., 2025 )
141.35
8,632
256 (Ours)
44.66
7,967
512 (Ours)
111.55
26,184
Appendix
Table 5: Absolute speed and memory comparison of our method to prior work on the SHD dataset with batch size 256. All methods use 2 hidden layers with delays and 256 or 512 hidden units per layer. * denotes metrics reported in Mészáros et al. (2025) on an RTX A5000; all other numbers were measured on an NVIDIA H100 (80GB). See text for details.
Figure 11: Spike metrics for 5 runs on the SSC dataset with 512 hidden units and chunk size 128. On average, layer one and two neurons consume approximately 100% of input spikes. We also note that both layer one and layer two retain a very high percentage of work done (e.g., 80-90%+).
Figure 12: Spike metrics for 5 runs on the SHD dataset with 256 hidden units and chunk size 128. On average, layer one and two neurons consume approximately 100% of input spikes. We also note that both layer one and layer two retain a very high percentage of work done (e.g., 80-90%+).
Figure 13: Spike metrics for 5 runs on the SHD dataset with 512 hidden units and chunk size 128. On average, layer one and two neurons consume approximately 100% of input spikes. We also note that both layer one and layer two retain a very high percentage of work done (e.g., 80-90%+).
Spiking neural networks process information through discrete, time-dependent neural events, aiming for efficient computation and biologically inspired learning.
Continuous-time spiking neural networks (SNNs) provide an event-driven framework for temporal computation, computational neuroscience, and neuromorphic hardware. However, training deep continuous-time SNNs is severely constrained by the memory required for exact spike-time computation, which evaluates and retains candidate firing times over intervals determined by presynaptic spike ordering. Here we introduce a memory-efficient training framework based on differentiable spike-time discretization (DSTD) for leaky integrate-and-fire neurons with general membrane and synaptic time constants. DSTD maps irregular presynaptic spikes onto differentiable weighted events at fixed time points, replacing the input-dependent candidate dimension with M fixed time intervals while accurately approximating continuous-time membrane-potential dynamics. This reduces candidate-related activation memory from O(NoutNin) to O(NoutM) in the case of time-to-first-spike (TTFS) coding, where Nin and Nout denote the numbers of presynaptic and postsynaptic neurons, respectively. We further introduce synfire-chain-inspired temporal regularization that organizes layer-wise firing windows, mitigates dead-neuron failures, and enables pipeline-like processing. In dense LIF layers, DSTD reduced peak memory consumption by up to approximately 100-fold and training time by up to approximately 20-fold compared with exact spike-time computation. Together, these methods allowed us to train 9-layer convolutional SNNs on CIFAR-10 and 20-layer convolutional SNNs on Fashion-MNIST on a single GPU.
Yusuke Sakemi, Tomoya Takeuchi, Takeo Hosomi +1
Research Center for Mathematical Engineering, Chiba Institute of Technology, Narashino, Japan · International Research Center for Neurointelligence (WPI-IRCN), The University of Tokyo, Tokyo, Japan · NEC Corporation, Kawasaki, Japan
Although spiking neural networks (SNNs) show promise in energy-efficient computing through event-driven computation and stateful temporal processing, their recurrent membrane dynamics render their training inherently sequential and inefficient for long sequences. Existing methods achieve full-sequence parallelism in SNNs through two main strategies: redesigning or approximating spiking dynamics to avoid reset-coupled temporal dependencies, or relying on iterative relaxed fixed-point solvers that suffer from excessive memory costs and iteration-dependent backward overhead. To address these limitations, we present FidLIF, a novel framework that reconciles the incremental update and hard-reset behavior of standard spiking LIF neurons with parallel forward propagation and BPTT-equivalent backward propagation. FidLIF iteratively recovers the full-sequence membrane-potential trajectory in parallel. By exploiting the lower bidiagonal structure induced by the local recurrence of LIF neurons, FidLIF formulates each forward trajectory correction and backward adjoint propagation as associative scans with an O(logT) temporal depth. This formulation also supports input-dependent neuronal parameters and allows the same neuron to perform full-sequence parallel training and incremental step-by-step inference at deployment. In our numerical convergence evaluation, FidLIF achieves a mean absolute error below 10−7 relative to the matched serial relaxed LIF dynamics, while yielding gradients numerically equivalent to exact BPTT. Our Triton implementation delivers favorable long-sequence latency and memory scaling, while achieving competitive performance on four sequential classification benchmarks. By reconciling parallel training with step-by-step execution, FidLIF enables high-fidelity spiking dynamics to benefit from parallel hardware without compromising incremental inference at deployment.
Kaixiang He, Yujie Wu
Department of Computing, The Hong Kong Polytechnic University
Spiking neural networks (SNNs) promise low-power event-driven computation for temporally rich tasks, but commonly used neuron models often trade off gradient-based trainability, dynamical richness, and high activity sparsity. These limitations are acute in regression, where approximation error, noise and spike discretization can severely degrade continuous-valued outputs. Indeed, many state-of-the-art (SOTA) SNNs rely on simple phenomenological dynamics trained with surrogate gradients and offer limited control over spiking diversity and sparsity. To overcome such limitations, we introduce multi-timescale conductance spiking networks, a gradient-trainable framework in which neural dynamics emerge from shaping the current-voltage (I-V) curve by tuning fast, slow and ultra-slow conductances. This parametrization allows systematic control over excitability, can be implemented efficiently in analog circuits, and yields rich firing regimes including tonic, phasic and bursting responses within a single model. We derive a discrete-time formulation of these differentiable dynamics, enabling direct backpropagation through time without surrogate-gradient approximations. To probe both trainability and accuracy, we evaluate feedforward networks of these neurons at the predictability limit of Mackey-Glass time-series regression and compare them to baseline LIF and SOTA AdLIF networks. Our model outperforms LIF and AdLIF networks, while exhibiting substantially sparser activity from both communication and computational perspectives. These results highlight multi-timescale conductance spiking neurons as a promising building block for energy-aware temporal processing and neuromorphic implementation.
Alex Fulleda-Garcia, Saray Soldado-Magraner, Josep Maria Margarit-Taulé
Instituto de Microelectrónica de Barcelona (IMB-CNM), Consejo Superior de Investigaciones Científicas (CSIC) Cerdanyola del Vallès, Spain · Department of Neurobiology, University of California Los Angeles (UCLA) Los Angeles, USA · Joint Senior authors