FFT-Only vs Learned Spectral Proxies for Rapid RF Triage

FFT-Only vs Tiny CNNs: Who Wins at Rapid RF Triage?

A 48× compute win with zero deep learning — and a hybrid trick for the edge cases

By Benjamin J. Gilbert
Spectrcyde RF Quantum SCYTHE
bgilbert2@com.edu
GitHub Repo + Reproducible Harness (coming soon)

The Mission: Yes/No in Milliseconds

In spectrum monitoring, every millisecond counts.
You get a burst of IQ samples.
You need to answer: “Is this digital or analog?” — fast.

Digital: BPSK, QPSK, 8PSK, 16QAM
Analog: AM, FM

No time for heavy models.
No room for high tail latency.

So we asked a heretical question:

Do we even need a neural net?

The Contenders

Pipeline	Description	FLOPs	p99 Latency @ 0 dB
FFT + Light Filters	1024-pt FFT → normalize → band energy, peak spacing, priors	~250,000	~1.5 ms
Tiny 1D CNN	3 conv layers over spectrum	12,000,000	~6.0 ms

48× fewer FLOPs. 4× lower tail latency.

The Results (SNR Sweep: –10 to +20 dB)

*Fig 1: FFT+filters beats the CNN in AUROC *and* compute.*

SNR	FFT+Filter AUROC	CNN AUROC
–10 dB	0.586	0.529
0 dB	0.651	0.582
+20 dB	0.754	0.671

FFT wins at every SNR.
And it’s orders of magnitude cheaper.

Latency: The Real Bottleneck

Fig 2: FFT p99 stays under 1.5 ms even at 0 dB. CNN balloons.

At 0 dB SNR:

FFT p99: 1.5 ms

CNN p99: 6.0 ms

In real-time triage, p99 is what kills you.

The Hybrid Gate: Best of Both Worlds

What if we only use the CNN when the FFT isn’t sure?

if fft_confidence > 0.9:
    return fft_result          # 1.5 ms, 0.25M FLOPs
else:
    return cnn_result          # 6.0 ms, 12M FLOPs

Let $ f $ = fraction of samples sent to CNN.

$$
\boxed{
C_{\text{hybrid}} = (1-f) \cdot 0.25M + f \cdot 12M
}
$$

Gate Rate $ f $	Avg FLOPs	Savings vs Pure CNN	p99 Latency
0% (FFT only)	0.25M	48×	1.5 ms
20%	2.6M	4.6×	~1.5 ms
100% (CNN only)	12M	1×	6.0 ms

Even a 20% gate rate saves 4.6× compute — and tail latency stays fast.

Fig 5: Hybrid dominates the Pareto front.

Confusion Matrices @ 10 dB

FFT misclassifies 1–2 samples per class.
CNN leaks 8PSK → 16QAM, QPSK → others.

Why This Matters

Edge SDRs (e.g., USRP, LimeSDR) have <100 mW compute budgets.
Tail latency kills real-time spectrum enforcement.
FFT is already in your pipeline — it’s free if you have IQ.

Use the FFT as your fast-path. Gate to CNN only when needed.

Reproducible. Today.

git clone https://github.com/bgilbert1984/rf-triage-benchmark
cd rf-triage-benchmark
make all

Generates:

metrics/triage_runs.csv
All figures
paper.pdf

Zero setup. Pure Python + NumPy + PyTorch.

Limitations (We’re Honest)

Synthetic data (Rician fading, calibrated SNR).
Latency modeled, not measured on real SDR.
Next step: Validate on field IQ (Ettus X410, real clocks).

TL;DR

Method	AUROC	FLOPs	p99 @ 0 dB	Verdict
Tiny CNN	0.671	12M	6.0 ms	Overkill
FFT+Filters	0.754	0.25M	1.5 ms	Winner
Hybrid (20% gate)	≥0.75	2.6M	1.5 ms	Best in practice

Want to Try It?

Star the repo. Run make all. Beat our AUROC with <1M FLOPs.

We dare you.

Paper: FFT-Only vs Learned Spectral Proxies for Rapid RF Triage (PDF)
Code: github.com/bgilbert1984/rf-triage-benchmark
Author: Benjamin J. Gilbert — RF heretic, latency minimalist

Originally published October 29, 2025
Follow for more edge RF + ML content.