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

```python
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