spiking-bandpass-wavelet-encoding

name

spiking-bandpass-wavelet-encoding

description

Spiking Bandpass Wavelet encoding methodology for temporal signal processing. Recasts spike encoders as time-causal wavelet frames with quantitative bandwidths and reconstruction error bounds. Maps spike representations to signal processing theory, enabling neuromorphic hardware implementation. Applicable to SNN temporal encoding, neuromorphic signal processing, event-based sensing, ECG/audio processing with spiking networks. Activation: spiking wavelet, spike encoding, temporal signal encoding, bandpass wavelet, neuromorphic signal processing, spike-based encoding, time-causal wavelets, ECG spiking, audio spiking, spike reconstruction

Spiking Bandpass Wavelet Encoding

Based on: Pedersen, Lindeberg & Gerstoft (2026) arXiv:2605.09770

Core Insight

Spike-based encodings are typically formulated probabilistically, disconnected from signal processing theory. This work recasts spike encoders as time-causal wavelet frames with:

• Quantitative bandwidth specifications
• Reconstruction error bounds
• Direct mapping to neuromorphic hardware

Theoretical Framework

Spike Encoder as Wavelet Frame

A spike encoder produces events when the signal crosses a threshold. This can be reformulated as a wavelet transform where:

1. Basis functions: Bandpass wavelets derived from the spike generation mechanism
2. Time-causality: Each wavelet depends only on past signal values
3. Sparsity: Natural sparsity from the spike threshold mechanism
4. Locality: Each spike encodes local signal features

Reconstruction

Signal reconstruction from spikes is possible up to:

• Spike quantization error
• Time discretization error

Achieves normalized RMSE comparable to continuous wavelet transforms.

Implementation Pattern

import numpy as np

class SpikingWaveletEncoder:
    """Encode temporal signals using spiking bandpass wavelets."""
    
    def __init__(self, n_channels, bandwidth, sample_rate):
        self.n_channels = n_channels
        self.bandwidth = bandwidth
        self.sample_rate = sample_rate
        # Wavelet filters per channel
        self.filters = self._build_wavelet_filters()
    
    def _build_wavelet_filters(self):
        """Construct bandpass wavelet filters for each channel."""
        filters = []
        for i in range(self.n_channels):
            center_freq = self.bandwidth * (2 ** i)
            # Time-causal bandpass wavelet
            t = np.arange(0, 100) / self.sample_rate
            wavelet = np.exp(-t * center_freq) * np.sin(2 * np.pi * center_freq * t)
            wavelet = wavelet / np.sum(wavelet**2)  # normalize
            filters.append(wavelet)
        return np.array(filters)
    
    def encode(self, signal):
        """Encode signal as spike train via wavelet thresholding."""
        spikes = []
        for filt in self.filters:
            # Convolve with wavelet (time-causal)
            response = np.convolve(signal, filt, mode='same')
            # Generate spikes at threshold crossings
            threshold = np.std(response) * 0.5
            spike_times = np.where(np.diff(np.sign(response - threshold)) > 0)[0]
            spikes.append(spike_times)
        return spikes
    
    def decode(self, spikes, original_length):
        """Reconstruct signal from spike train."""
        reconstruction = np.zeros(original_length)
        for i, spike_times in enumerate(spikes):
            for t in spike_times:
                if t < len(self.filters[i]):
                    reconstruction[t:t+len(self.filters[i])] += self.filters[i]
        return reconstruction

# Usage on ECG or audio:
# encoder = SpikingWaveletEncoder(n_channels=8, bandwidth=10, sample_rate=1000)
# spikes = encoder.encode(ecg_signal)
# reconstructed = encoder.decode(spikes, len(ecg_signal))

Key Properties

Property	Description
Sparsity	Only fires when signal exceeds local threshold
Energy efficiency	Sparse spike events minimize computation
Time-causal	No future information needed
Bandwidth control	Adjustable frequency coverage per channel
Hardware mapping	Direct implementation on neuromorphic chips

Applications

• ECG signal processing with spiking networks
• Audio feature extraction for neuromorphic hearing
• Event-based vision sensor preprocessing
• Temporal signal compression
• Real-time anomaly detection in streaming data

Advantages Over Traditional Encodings

• Signal processing connection: Bridges spike coding and wavelet theory
• Reconstruction guarantees: Error bounds on signal recovery
• Neuromorphic compatibility: Maps directly to event-based hardware
• No probabilistic assumptions: Deterministic wavelet formulation

Related Skills

• cortico-cerebellar-modularity-rnn - Brain-inspired RNN architecture
• spikingjelly-framework - SNN deep learning framework
• snn-performance-analysis - SNN performance evaluation
• edgespike-edge-iot-snn - Edge SNN deployment

ArXiv Reference

• Paper: arXiv:2605.09770v1
• Title: Encoding and Decoding Temporal Signals with Spiking Bandpass Wavelets
• Authors: Jens Egholm Pedersen, Tony Lindeberg, Peter Gerstoft
• Date: 2026-05-10
• Categories: cs.NE, eess.SP, q-bio.NC