congestion-aware-delay-snn

name	congestion-aware-delay-snn
description	Congestion-Aware Dynamic Axonal Delay mechanism for Spiking Neural Networks. Decomposes delay into channel-wise static base delay + global activity-conditioned shift. Reduces delay parameters by ~50% while improving accuracy on temporal tasks. Source: arXiv:2605.01291 (Bai et al., May 2026).
category	ai_collection

Congestion-Aware Dynamic Axonal Delay for SNNs

Description

This skill covers the Congestion-Aware Dynamic Axonal Delay mechanism for Spiking Neural Networks (SNNs). Instead of assigning static delays to individual synapses (which creates too many parameters and limited adaptability), this approach decomposes delay into:

1. Channel-wise static base delay for temporal structuring
2. Global activity-conditioned shift that dynamically regulates state update rate under varying spike intensities

Source Paper: arXiv:2605.01291 - "Congestion-Aware Dynamic Axonal Delay for Spiking Neural Networks" (Dewei Bai, Hongxiang Peng, Yunyun Zeng, Ziyu Zhang, Hong Qu, May 2, 2026)

Activation Keywords

• congestion-aware delay
• dynamic axonal delay SNN
• delay learning SNN
• spike congestion
• temporal SNN
• SNN delay mechanism
• activity-conditioned delay
• 动态轴突延迟
• 脉冲神经网络延迟
• 拥塞感知延迟

Core Problem

Static Delay Limitations

Traditional delay learning in SNNs assigns a fixed delay to each synapse:

delay_ij = learnable_parameter  # per-synapse

Problems:

• Parameter explosion: O(N²) delay parameters for N neurons
• Limited adaptability: Cannot adjust to input-dependent activity dynamics
• Static behavior: Same delay regardless of network congestion state

Solution: Two-Level Delay Decomposition

Level 1: Channel-Wise Static Base Delay

Instead of per-synapse delays, assign delays per channel (group of synapses):

# Channel-wise base delay (dramatically fewer parameters)
base_delay[channel] = learnable_parameter  # O(C) where C << N²

# Differentiable linear interpolation for gradient flow
def continuous_delay(x, base_delay):
    floor_d = floor(base_delay)
    ceil_d = ceil(base_delay)
    frac = base_delay - floor_d
    return (1 - frac) * x[t - floor_d] + frac * x[t - ceil_d]

Level 2: Global Activity-Conditioned Shift

A global shift that dynamically adjusts based on current spike intensity:

# Measure network congestion (spike intensity)
spike_intensity = mean(recent_spike_counts)

# Activity-conditioned shift
shift = shift_network(spike_intensity)  # learned function

# Total effective delay
effective_delay = base_delay + shift

Key Insight

• Base delay captures the structural temporal relationships (what to align)
• Congestion shift captures the dynamic processing conditions (when to process)
• Together they model both what and when optimally

Discretization at Inference

During training, delays are continuous (differentiable via linear interpolation). At inference, they are discretized:

# Training: continuous (differentiable)
delay_continuous = base_delay + shift

# Inference: discretized (no interpolation overhead)
delay_discrete = round(delay_continuous)

Implementation Workflow

Step 1: Define Channel-Wise Base Delays

import torch
import torch.nn as nn

class CongestionAwareDelay(nn.Module):
    def __init__(self, num_channels, max_delay=10):
        super().__init__()
        # Channel-wise base delays
        self.base_delay = nn.Parameter(
            torch.randn(num_channels) * 0.5 + max_delay / 2
        )
        # Shift network parameters
        self.shift_mlp = nn.Sequential(
            nn.Linear(1, 16),
            nn.ReLU(),
            nn.Linear(16, 1)
        )
        self.max_delay = max_delay
    
    def forward(self, spikes, spike_intensity):
        """
        spikes: (batch, channel, time)
        spike_intensity: (batch,) current network congestion level
        """
        # Compute activity-conditioned shift
        shift = self.shift_mlp(spike_intensity.unsqueeze(-1))
        
        # Total delay
        total_delay = self.base_delay + shift.squeeze(-1)
        total_delay = torch.clamp(total_delay, 0, self.max_delay)
        
        # Apply delay with differentiable interpolation
        delayed = self._apply_delay(spikes, total_delay)
        return delayed

Step 2: Differentiable Delay Application

    def _apply_delay(self, x, delay):
        """Apply delay with linear interpolation for gradient flow."""
        batch, channel, time = x.shape
        output = torch.zeros_like(x)
        
        for c in range(channel):
            d = delay[c]
            floor_d = torch.floor(d).long()
            ceil_d = torch.ceil(d).long()
            frac = d - floor_d.float()
            
            # Linear interpolation between discrete time steps
            for t in range(time):
                t_floor = torch.clamp(t - floor_d, 0, time - 1)
                t_ceil = torch.clamp(t - ceil_d, 0, time - 1)
                output[:, c, t] = (
                    (1 - frac) * x[:, c, t_floor] +
                    frac * x[:, c, t_ceil]
                )
        
        return output

Step 3: Integration with SNN Layer

class DelayedSNNLayer(nn.Module):
    def __init__(self, in_channels, out_channels, max_delay=10):
        super().__init__()
        self.delay = CongestionAwareDelay(in_channels, max_delay)
        self.synaptic_weights = nn.Linear(in_channels, out_channels)
        self.lif = LIFNeuron(out_channels)
    
    def forward(self, spikes, spike_intensity):
        # Apply congestion-aware delay
        delayed_spikes = self.delay(spikes, spike_intensity)
        
        # Synaptic integration
        membrane_input = self.synaptic_weights(delayed_spikes.transpose(-1, -2))
        
        # LIF neuron dynamics
        output_spikes = self.lif(membrane_input)
        return output_spikes

Results

Dataset	Metric	SOTA Delay Methods	Congestion-Aware	Improvement
SHD	Accuracy	~92%	93.75%	+1.75%
SSC	Accuracy	~78%	80.49%	+2.49%
GSC-35	Accuracy	~94%	95.53%	+1.53%
All	Parameters	Baseline	-50%	Half the parameters

When to Use

• Temporal/spatiotemporal tasks where spike timing matters
• Speech recognition with SNNs
• Event-based sensor processing (DVS, audio)
• Resource-constrained deployment (need to reduce parameters)
• Dynamic environments where input statistics change

Advantages

1. Parameter efficiency: ~50% fewer delay parameters vs. per-synapse delays
2. Dynamic adaptability: Adjusts to network congestion in real-time
3. Differentiable training: Linear interpolation enables gradient-based optimization
4. Zero inference overhead: Discretization removes interpolation cost at deployment
5. Improved accuracy: Better spike alignment on temporal tasks

Pitfalls

• Shift network capacity: Too small → cannot model congestion dynamics; too large → defeats efficiency goal
• Delay range: Clamp delays to reasonable bounds to avoid temporal misalignment
• Intensity measurement: Use appropriate window size for spike intensity estimation
• Task sensitivity: Works best for tasks where temporal alignment is critical

Related Skills

• spiking-neural-network-analysis
• delay-adaptive-snn-classifier
• stdp-synaptic-delay-learning
• multiplication-free-spike-time-fpga

Reference

@article{bai2026congestion,
  title = {Congestion-Aware Dynamic Axonal Delay for Spiking Neural Networks},
  author = {Bai, Dewei and Peng, Hongxiang and Zeng, Yunyun and Zhang, Ziyu and Qu, Hong},
  journal = {arXiv preprint},
  year = {2026},
  eprint = {2605.01291},
  primaryClass = {cs.LG},
  date = {2026-05-02}
}