adaptive-frequency-resonate-and-fire-spectral-estimation

name	adaptive-frequency-resonate-and-fire-spectral-estimation
description	Adaptive-Frequency Resonate-and-Fire (ARF) neurons for spectral estimation of streaming signals. Neuromorphic-inspired method that dynamically adjusts internal frequency to match dominant frequency components, enabling real-time range/velocity estimation in FMCW radar and neural signal processing.
trigger_words	["resonate-and-fire","spectral estimation","adaptive frequency","neuromorphic signal processing","FMCW radar","streaming signals","resonate neuron","frequency tracking","real-time processing","edge computing"]

Adaptive-Frequency Resonate-and-Fire Neurons for Spectral Estimation

Core Innovation

Adaptive-Frequency Resonate-and-Fire (ARF) neurons represent a breakthrough in neuromorphic signal processing, enabling real-time spectral estimation without storing large data buffers. This addresses a fundamental limitation of traditional FFT-based methods: the requirement to store and process entire signal blocks.

Key breakthrough: Sample-by-sample frequency estimation with memory scaling proportional to number of targets, not signal length.

Theoretical Framework

Resonate-and-Fire Neuron Dynamics

ARF neurons extend classical resonate-and-fire models with adaptive frequency tuning:

# Discrete-time ARF dynamics
θ_{n+1} = θ_n + ω_n Δt  (phase evolution)
ω_{n+1} = ω_n + η · (∂L/∂ω)  (frequency adaptation)
spike when: θ_n ≈ 2πk (resonance condition)

Where:

• $θ$ = internal phase state
• $ω$ = adaptive frequency parameter
• $η$ = learning rate for frequency adjustment
• $L$ = objective function matching signal frequency

Frequency Adaptation Mechanism

Each neuron dynamically adjusts its internal frequency to match dominant frequency components:

∂L/∂ω = correlation(signal, cos(ωt)) · feedback_weight

This enables:

• Automatic frequency locking to input signal
• Multi-target tracking via multiple neurons
• Continuous frequency estimation without FFT

Feedback Mechanism

For multi-target scenarios, introduces feedback inhibition:

• Neurons that lock to a frequency inhibit others
• Prevents multiple neurons tracking same frequency
• Enables distribution across frequency spectrum

Implementation Architecture

Core ARF Neuron Model

class ARFNeuron:
    def __init__(self, initial_freq, learning_rate):
        self.phase = 0.0
        self.frequency = initial_freq
        self.learning_rate = learning_rate
        self.spiked = False
        
    def update(self, signal_sample, dt):
        # Phase evolution
        self.phase += self.frequency * dt
        self.phase = self.phase % (2 * np.pi)
        
        # Frequency adaptation
        correlation = signal_sample * np.cos(self.phase)
        self.frequency += self.learning_rate * correlation
        
        # Spike generation
        if self.phase < 0.1:  # Near resonance
            self.spiked = True
            return self.frequency  # Estimated frequency
        else:
            self.spiked = False
            return None

Multi-Neuron Network

class ARFNetwork:
    def __init__(self, num_neurons, freq_range, learning_rate):
        # Initialize neurons across frequency range
        frequencies = np.linspace(freq_range[0], freq_range[1], num_neurons)
        self.neurons = [ARFNeuron(f, learning_rate) for f in frequencies]
        self.feedback_weights = np.ones(num_neurons)
        
    def process(self, signal_stream):
        estimated_freqs = []
        
        for sample in signal_stream:
            # Update all neurons
            freq_estimates = []
            for neuron in self.neurons:
                freq = neuron.update(sample, dt=1.0)
                if freq:
                    freq_estimates.append(freq)
            
            # Feedback inhibition
            for i, neuron in enumerate(self.neurons):
                if neuron.spiked:
                    # Inhibit other neurons
                    for j, other in enumerate(self.neurons):
                        if j != i:
                            other.frequency -= feedback_factor
            
            estimated_freqs.extend(freq_estimates)
        
        return estimated_freqs

FMCW Radar Application

Range and Velocity Estimation

In FMCW radar, frequency components encode target range and velocity:

beat_frequency = (2 · v · f_c) / c  (velocity)
range_frequency = (2 · R · B) / (c · T)  (range)

ARF neurons directly estimate these beat frequencies:

• Each neuron locks to a beat frequency component
• Real-time range/velocity extraction
• No FFT computation required

Advantages Over FFT

Metric	FFT-based	ARF neurons
Memory	O(N) signal buffer	O(K) neurons
Latency	Block processing delay	Sample-by-sample
Edge deployment	Memory-intensive	Resource-efficient
Multi-target	Post-processing	Inherent distribution

Neuromorphic Implementation

Hardware Realization

ARF neurons suitable for neuromorphic hardware:

• Memristive circuits: Phase accumulation
• Analog oscillators: Frequency adaptation
• Digital FPGA: Discrete-time implementation

Edge Computing Benefits

# Edge deployment characteristics
memory_per_target = sizeof(ARFNeuron)  # ~O(1) parameters
total_memory = num_targets * memory_per_target  # Independent of signal length
processing_per_sample = num_targets * neuron_updates  # Constant time per sample

Power Efficiency

• No FFT computation (significant savings)
• Sample-by-sample processing (no buffering overhead)
• Adaptive computation (neurons only active when detecting)

Experimental Validation

Simulated Data Results

Successfully tracks multiple targets across:

• Single target scenarios
• Multi-target with distinct frequencies
• Overlapping frequency ranges

Real Radar Data Performance

• Range estimation accuracy: Comparable to FFT
• Velocity estimation: Real-time tracking demonstrated
• Multi-target separation: Feedback mechanism validated

Performance Metrics

• Frequency estimation error vs FFT
• Memory usage comparison
• Processing latency measurement
• Target tracking fidelity

Neuroscience Applications

EEG Frequency Tracking

ARF neurons can track EEG frequency bands:

• Alpha (8-12 Hz), Beta (13-30 Hz), Gamma (30-100 Hz)
• Real-time band power estimation
• Event-related desynchronization detection

Neural Signal Processing

# EEG frequency tracking example
eeg_arf = ARFNetwork(
    num_neurons=10,
    freq_range=(1, 100),  # EEG frequency range
    learning_rate=0.001
)

# Track dominant frequencies in real-time
dominant_freqs = eeg_arf.process(eeg_stream)

Spike Train Analysis

For neural spike trains:

• Estimate oscillatory components
• Track bursting frequencies
• Detect rhythmic patterns

Key Algorithmic Innovations

1. Sample-by-Sample Processing

ω_estimated = lim_{n→∞} ω_n (convergence to true frequency)

2. Feedback Inhibition

∂ω_i/∂t = -γ · Σ_{j≠i} spike_j · (ω_i - ω_j)

Prevents frequency collapse to single component.

3. Frequency Range Initialization

Distribute initial frequencies across expected range:

• Uniform spacing for unknown targets
• Prior distribution for known frequency bands
• Dynamic adjustment during tracking

Pitfalls and Considerations

Frequency Lock Time

• Neurons require convergence time
• Trade-off between learning rate and stability
• Fast adaptation may cause overshoot

Multi-Target Interference

• Close frequencies may compete
• Feedback strength tuning critical
• Spatial distribution helps separation

Noise Sensitivity

• High noise levels challenge frequency locking
• Signal-to-noise threshold considerations
• Robustness enhancement techniques needed

Learning Rate Selection

• Too high: Instability, oscillations
• Too low: Slow convergence, missed targets
• Adaptive rates may improve performance

Related Methodologies

Comparison with FFT

• FFT: Block processing, full spectrum, high memory
• ARF: Streaming, targeted frequencies, low memory

Comparison with IIR Filters

• IIR: Fixed bandpass, manual tuning
• ARF: Adaptive frequency, automatic tuning

Comparison with Wavelet Transform

• Wavelet: Multi-scale, time-frequency
• ARF: Real-time, frequency-focused

Implementation Guidelines

Step-by-Step Setup

1. Define Frequency Range:

   • Expected target frequencies
   • Radar band or EEG bands
   • Neuron distribution across range

2. Configure Neurons:

   network = ARFNetwork(
       num_neurons=expected_targets * 2,  # Oversample
       freq_range=(min_freq, max_freq),
       learning_rate=0.01  # Tune empirically
   )
   

3. Set Feedback Parameters:

   • Inhibition strength
   • Competition dynamics
   • Frequency separation threshold

4. Process Streaming Data:

   • Feed samples one-by-one
   • Collect frequency estimates
   • Track neuron state evolution

Hyperparameter Tuning

• learning_rate: Speed vs stability
• feedback_strength: Multi-target separation
• num_neurons: Frequency resolution
• phase_threshold: Spike generation sensitivity

Research Directions

Open Questions

• Optimal neuron number vs frequency resolution
• Adaptive learning rate strategies
• Non-stationary frequency tracking

Extensions

• Combined with other neuromorphic neurons
• Hierarchical frequency decomposition
• Multi-dimensional frequency tracking

Citation

@article{chiavazza2026adaptive,
  title={Adaptive-Frequency Resonate-and-Fire Neurons for Spectral Estimation of Streaming Radar Signals},
  author={Chiavazza, Stefano and Yuan, Sen and Geilen, Marc and Fioranelli, Francesco and Corradi, Federico},
  journal={arXiv preprint arXiv:2606.13516},
  year={2026}
}

Activation

Keywords: resonate-and-fire, spectral estimation, adaptive frequency, neuromorphic signal processing, FMCW radar, streaming signals, resonate neuron, frequency tracking, real-time processing, edge computing, sample-by-sample, target tracking, feedback inhibition, range velocity, memory efficiency, EEG frequency, neural signal, oscillator dynamics, phase evolution, frequency locking