💻 computer science

Efficiently Training Time-to-First-Spike Spiking Neural Networks from Scratch

This paper proposes a comprehensive training framework incorporating specialized initialization, normalization, a temporal decoder, and average pooling to overcome the instability and accuracy limitations of Time-to-First-Spike Spiking Neural Networks, achieving state-of-the-art performance across multiple datasets.

Original authors: Kaiwei Che, Zhengyu Ma, Yifan Huang, Peng Xue, Li Yuan, Timothée Masquelier, Wei Fang, Yonghong Tian

Published 2026-06-17

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Kaiwei Che, Zhengyu Ma, Yifan Huang, Peng Xue, Li Yuan, Timothée Masquelier, Wei Fang, Yonghong Tian

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a group of messengers (neurons) to deliver a single, urgent note (a spike) to a boss. The goal is to get the right message across using the least amount of energy and the fastest possible time. This is the challenge of training "Spiking Neural Networks" (SNNs), which are computer models inspired by how real brains work.

The specific type of network this paper focuses on is called Time-to-First-Spike (TTFS). In this system, a neuron is only allowed to shout once. The timing of that single shout carries the information. If it shouts early, it means one thing; if it shouts late, it means something else.

The problem the authors faced is that teaching these "one-shout" networks is incredibly difficult. They often get confused, stay silent, or shout at the wrong times, leading to poor performance.

Here is how the authors, led by Kaiwei Che and Zhengyu Ma, fixed this using four main strategies, explained with everyday analogies:

1. The "Perfect Starting Line" (Parameter Initialization)

The Problem: Imagine a relay race where the baton gets lighter and lighter with every runner. By the time it reaches the last runner, it's so light they can't feel it. In computer terms, using standard starting settings (called "Kaiming initialization") causes the signal to fade away as it travels through the layers of the network. The neurons never get enough "charge" to shout.

The Fix: The authors created a new starting rule called ETTFS-init. Instead of guessing the starting weight, they calculated the exact amount of "push" needed so that the signal stays strong and consistent from the first runner to the last. It's like ensuring every runner in the relay gets a baton of the exact same weight, so the message never gets lost.

2. The "Steady Hand" (Weight Normalization)

The Problem: Even if you start with a perfect baton, the runners might get tired or excited during the race, causing the baton to wobble or change weight. In training, the "weights" (the strength of connections between neurons) can drift away from their ideal state, making the training unstable.

The Fix: The authors added a Weight Normalization step. Think of this as a coach who constantly checks the baton and gently adjusts it back to the perfect weight after every practice run. This keeps the training stable and helps the network learn faster without the signal getting messy.

3. The "Early Bird" Decoder (Temporal Weighting Decoder)

The Problem: In a normal network, you might wait for everyone to finish shouting before deciding who won. But in a TTFS network, the first shout is the most important. Traditional methods often ignore this urgency or take too long to calculate the result.

The Fix: The authors built a special Decoder that acts like a judge who values speed above all else. They assign a "bonus score" to shouts that happen early and a "penalty" to shouts that happen later.

Analogy: Imagine a race where the winner isn't just the fastest, but the one who crosses the line first gets a massive gold medal, the second gets silver, and so on. This encourages the neurons to fire as early as possible, which speeds up the whole process and saves energy.

4. The "Fair Mixer" (Pooling Layers)

The Problem: To process information, networks often group neurons together (pooling). The authors found that using a "Max-Pooling" method (picking the loudest shout) was a trap. If two different neurons in a group shouted at different times, the "Max" method would accidentally create a situation where it looks like two shouts happened, breaking the "one-shout only" rule.

The Fix: They switched to Average-Pooling. Instead of picking the loudest shout, they take the average of the group.

Analogy: If you have a group of people and you want to know the general mood, asking "Who is the loudest?" might miss the nuance. Asking "What is the average mood?" keeps the rules intact. This ensures the network strictly follows the "one shout per neuron" rule, which is essential for the math to work.

The Results: A Faster, Smarter, Greener Network

By combining these four fixes, the authors created a training framework (ETTFS) that:

Trains Faster: The network learns without getting stuck or confused.
Runs Faster: It makes decisions in fewer "time steps" (like finishing a race in fewer seconds).
Uses Less Energy: Because it fires fewer spikes and stops early, it is incredibly efficient for special "neuromorphic" hardware (chips designed to mimic brains).

The Scoreboard:
The team tested their method on several standard datasets (like recognizing handwritten digits or fashion items). They achieved state-of-the-art accuracy, beating almost all other methods that train these networks from scratch.

MNIST (Handwritten Digits): 99.48% accuracy.
Fashion-MNIST: 92.90% accuracy.
CIFAR10 (Color Images): 90.56% accuracy.
DVS Gesture (Hand movements): 95.83% accuracy.

In short, the paper provides a new "rulebook" for teaching these ultra-efficient, one-shout neural networks, making them reliable enough to be used in real-world, energy-saving devices.

Technical Summary: Efficiently Training Time-to-First-Spike Spiking Neural Networks from Scratch

1. Problem Statement

Spiking Neural Networks (SNNs) are promising for energy-efficient neuromorphic computing due to their event-driven nature. Among various neural coding schemes, Time-to-First-Spike (TTFS) coding is particularly attractive because it encodes information via the timing of a single spike per neuron, offering extreme sparsity and minimal energy consumption.

However, training TTFS SNNs from scratch (direct training) faces significant challenges:

Signal Diminishing and Gradient Vanishing: Standard initialization methods (e.g., Kaiming) cause the variance of post-synaptic currents to decay rapidly across layers in TTFS networks. This leads to silent neurons and vanishing gradients, resulting in unstable training and low accuracy.
Training Instability: The strict constraint of firing at most once per neuron makes the network sensitive to weight distribution shifts during gradient descent.
Inference Latency: Existing decoders often fail to fully leverage the temporal information to encourage early firing, leading to higher inference time-steps.
Pooling Compatibility: Standard max-pooling violates the "one-spike" constraint of TTFS coding, as it can result in multiple spikes being aggregated over time, breaking the theoretical assumptions required for efficient TTFS training.

2. Methodology: The ETTFS Framework

The authors propose ETTFS, a comprehensive training framework designed to stabilize and accelerate TTFS SNN training from scratch. The framework consists of four core components:

2.1. ETTFS Initialization (ETTFS-init)

To address signal diminishing, the authors derive a novel parameter initialization strategy.

Analysis: They demonstrate that under Kaiming initialization, the variance of the input current decays asymptotically to zero as the number of time-steps ( $T$ ) increases, specifically scaling as $1/(3T)$ .
Solution: They propose initializing weights from a uniform distribution scaled by $\sqrt{T/N_l}$ , where $N_l$ is the number of input features. This ensures that the average input current variance across time-steps remains stable (normalized to 1) regardless of the network depth or time-step count, preventing the silent neuron problem.

2.2. Weight Normalization

Even with proper initialization, weight distributions can shift during training, violating the stability conditions.

Mechanism: The authors apply weight normalization to constrain weights around their initialized state.
Affine Transform: To prevent the loss of representational capacity caused by fixed scaling, a learnable affine transform (scaling $\gamma$ and bias $\beta$ ) is applied to the synaptic output during training.
Inference Efficiency: Crucially, the affine transform is fused into the synaptic weights during inference ( $\tilde{W} = \gamma W$ , $\tilde{B} = \beta$ ), ensuring no additional computational overhead.

2.3. Temporal Weighting Decoder (TWD)

Traditional decoders based on firing rates are ineffective for TTFS.

Mechanism: The authors propose a differentiable decoder that aggregates output spikes over time using decayed temporal weights ( $w[t]$ ).
Function: The weight $w[t]$ is set to decay (exponentially or linearly) as time progresses. This encourages the network to fire earlier, as earlier spikes contribute more to the final output value.
Result: This allows the network to minimize latency by stopping inference as soon as a spike is detected in the output layer, while maintaining differentiability for backpropagation.

2.4. Average-Pooling for One-Spike Constraints

The paper re-evaluates pooling layers in the context of TTFS.

Problem: Max-pooling can violate the "at-most-one-spike" assumption. If multiple neurons in a pooling window fire at different time steps, the max-pooled output can sum to more than 1 over time.
Solution: The authors advocate for average-pooling. Since each input sequence sums to exactly 1 (due to the one-spike constraint), the average of these sequences also sums to 1, preserving the one-spike characteristic essential for the theoretical stability of the initialization and normalization methods.

3. Key Contributions

Identification of Signal Diminishing: The authors identify that standard Kaiming initialization causes signal variance to vanish in TTFS networks and propose ETTFS-init to stabilize post-synaptic current distributions.
Stabilization via Normalization: They introduce a weight normalization scheme with learnable affine transforms that maintains stable weight distributions during training and fuses into weights for efficient inference.
Novel Decoder: A Temporal Weighting Decoder is proposed to encourage early firing, reducing inference latency while preserving differentiability.
Pooling Re-evaluation: The paper argues that average-pooling is the correct choice for TTFS SNNs to maintain the one-spike constraint, whereas max-pooling is incompatible.
State-of-the-Art Performance: The framework enables direct training of TTFS SNNs to achieve high accuracy on multiple benchmarks without relying on ANN-to-SNN conversion or pre-trained weights.

4. Experimental Results

The ETTFS framework was evaluated on MNIST, Fashion-MNIST, CIFAR10, CIFAR100, and the neuromorphic DVS Gesture dataset.

Accuracy: ETTFS achieves state-of-the-art accuracy among directly trained TTFS SNNs:
- MNIST: 99.48%
- Fashion-MNIST: 92.90%
- CIFAR10: 90.56%
- CIFAR100: 70.27%
- DVS Gesture: 95.83% (First reported result for TTFS on this dataset).
Latency: The framework significantly reduces inference time-steps compared to previous methods (e.g., TQ-TTFS). For CIFAR10, the average inference time-step is reduced to 2.93, compared to 4.62 for TQ-TTFS.
Energy Efficiency: Due to fewer time-steps and lower spike counts, ETTFS demonstrates superior energy consumption metrics (Event-driven synaptic energy, static/dynamic energy, and memory access energy) compared to rate coding and other TTFS methods.
Stability: Ablation studies show that ETTFS-init prevents gradient vanishing (gradients remain in the $10^{-3}$ range vs. $10^{-10}$ with Kaiming) and allows for stable training of deeper networks (up to 11 layers) where Kaiming initialization fails.

5. Significance and Claims

The paper claims that ETTFS provides a robust solution for training TTFS SNNs from scratch, overcoming the historical trade-off between the extreme energy efficiency of TTFS coding and training stability.

Bridging the Gap: The framework bridges the performance gap between direct training and ANN-to-SNN conversion, achieving comparable or superior accuracy with significantly lower latency and energy costs.
Hardware Alignment: By utilizing step-by-step propagation and early stopping, the method aligns perfectly with the asynchronous, event-driven nature of neuromorphic hardware, unlike layer-by-layer conversion methods which incur high latency.
Limitations: The authors modestly note that current results are limited to small-scale datasets (e.g., CIFAR, MNIST) and do not yet extend to large-scale datasets like ImageNet, identifying this as a direction for future research.

The work establishes a new baseline for TTFS SNNs, demonstrating that with proper initialization, normalization, and decoding, these networks can be trained efficiently and effectively without external pre-training.