What input size and inference latency are realistic for an RF CNN on edge hardware?

Typical inputs are 128 to 1024 complex IQ samples per decision window, formatted as a 2-by-N real tensor, or a spectrogram tile around 128 by 128 pixels. A compact 4 to 6 layer 1D CNN with a few hundred thousand parameters runs in well under 1 millisecond per window on a modern GPU and in the low single-digit milliseconds on an embedded GPU or DSP. FPGA implementations using INT8 quantization can sustain inference at multi-megasample-per-second IQ rates with deterministic latency under 100 microseconds, which is what real-time spectrum sensing and electronic support measures require. The practical limits are memory bandwidth for streaming IQ and the quantization-induced accuracy loss, usually held to under 1 to 2 percentage points with quantization-aware training.

Emerging RF Technology

Convolutional Neural Network (RF)

Q: Should an RF CNN train on raw IQ samples or on spectrograms?

Both representations are used and the choice depends on the task and compute budget. A 1D CNN operating on raw IQ feeds the in-phase and quadrature streams as a 2-by-N tensor and lets the network learn matched filters directly; this preserves phase information and works well for automatic modulation classification across PSK, QAM, and FSK families. A 2D CNN on a spectrogram or short-time Fourier transform image trades some phase detail for a compact time-frequency picture that excels at wideband signal detection, frequency-hopping emitter tracking, and interference localization. Raw-IQ models such as the ResNet variants in the RadioML benchmarks reach roughly 90 percent accuracy above 10 dB SNR on 24 modulation classes, while spectrogram CNNs are preferred when the input bandwidth spans many channels at once. A common production pattern uses an IQ front end for fine modulation decisions and a spectrogram branch for coarse spectrum awareness.

Q: How much does SNR degrade RF CNN classification accuracy?

Accuracy falls sharply below about 0 dB SNR for most published RF CNNs. On the RadioML 2018.01A dataset, a well-tuned residual CNN holds roughly 93 to 95 percent accuracy at 18 to 30 dB SNR, drops to about 80 percent near 6 dB, and collapses toward random guessing (around 4 percent for 24 classes) below minus 10 dB where the signal energy is buried in noise. Higher-order constellations such as 256-QAM degrade earliest because their decision regions are tightest. Data augmentation with simulated carrier frequency offset, sample-rate offset, and multipath fading, plus training across the full SNR sweep rather than only clean signals, is what keeps low-SNR performance from falling off a cliff. Curriculum schedules that start at high SNR and anneal downward also help convergence.

/kon-vuh-LOO-shuh-nuhl NOOR-uhl NET-wurk/

Applied to the radio domain, this deep learning architecture slides learned convolutional filter banks across raw complex IQ samples or time-frequency spectrograms to extract signal features without hand engineering. In RF, a convolutional neural network (CNN) replaces classical matched filters and cyclostationary detectors used in spectrum sensing and automatic modulation classification, learning the discriminating structure of PSK, QAM, and FSK waveforms directly from labeled IQ. Modern residual CNN designs reach roughly 90 to 95 percent classification accuracy above 10 dB SNR across 24 modulation classes, and INT8-quantized versions run inference in under 100 microseconds on FPGA fabric. They underpin emerging cognitive RF receivers, interference detectors, and signal-intelligence pipelines.

Category: Emerging RF Technology

Typical Input: 128 to 1024 IQ samples

Accuracy >10 dB SNR: ~90 to 95%

How CNNs Learn RF Signal Structure

Classical RF classifiers rely on hand-derived statistics such as higher-order cumulants, cyclic spectral correlation, and instantaneous amplitude or phase histograms. A convolutional neural network discards that feature-engineering step. It treats a window of complex baseband as a two-channel tensor, the in-phase stream stacked with the quadrature stream, and learns a hierarchy of one-dimensional filters whose weights are optimized by backpropagation against labeled examples. Early layers converge to short matched-filter-like kernels that respond to symbol transitions and pulse shapes; deeper layers combine those activations into representations that separate modulation families, symbol rates, and even individual emitter hardware imperfections.

Two input formats dominate. The 1D IQ format preserves phase and is the workhorse for fine-grained modulation classification; the 2D spectrogram format trades phase detail for a wideband time-frequency picture that suits detection, frequency-hop tracking, and interference geolocation. Benchmark datasets such as RadioML 2016.10A and 2018.01A standardized the field, sweeping signals from roughly minus 20 dB to plus 30 dB SNR with realistic carrier frequency offset, sample-rate offset, and multipath fading so that trained models generalize to over-the-air capture rather than to clean simulation.

The trade space differs from analog RF design but is just as concrete. Larger receptive fields and deeper residual stacks raise accuracy but cost parameters, memory bandwidth, and inference latency. Quantization to INT8 and pruning shrink the model for FPGA or embedded-GPU deployment at the edge, typically sacrificing only 1 to 2 percentage points of accuracy when quantization-aware training is used. Robustness to low SNR, adversarial interference, and unseen channel conditions remains the active research frontier.

The Convolution and Classification Math

1D Convolution Over IQ:
z_k[n] = Σ_m=0^M−1 w_k[m] × x[n−m] + b_k

ReLU Activation:
a_k[n] = max(0, z_k[n])

Softmax Class Probability:
p_i = e^s_i / Σ_j e^s_j

Cross-Entropy Training Loss:
L = −Σ_i y_i × log(p_i)

Where x = 2×N IQ tensor, w_k = filter k of length M, b_k = bias, s_i = logit for class i, p_i = predicted probability, y_i = one-hot label. Output feature map length ≈ N for "same" padding, or (N − M)/stride + 1 for "valid" padding.

Input Representations and Deployment Trade-offs

Attribute	1D CNN on Raw IQ	2D CNN on Spectrogram
Input tensor	2 × 128 to 1024 (I, Q)	~128 × 128 STFT image
Phase info	Preserved	Mostly discarded
Best task	Modulation classification	Wideband detection, hop tracking
Accuracy >10 dB SNR	~90 to 95% (24 classes)	~85 to 92% (detection)
Typical params	0.1 to 1 M	1 to 10 M
Edge inference	<1 ms GPU, <100 μs FPGA INT8	1 to 5 ms GPU
Low-SNR floor	Collapses below −10 dB	Detection holds slightly lower

Common Questions

Frequently Asked Questions

Should an RF CNN train on raw IQ samples or on spectrograms?

Both work; the choice follows the task. A 1D CNN on raw IQ (a 2×N tensor) keeps phase and excels at modulation classification, reaching ~90% accuracy above 10 dB SNR on 24 classes in the RadioML benchmarks. A 2D CNN on a spectrogram or STFT image gives a compact time-frequency view that wins for wideband detection and frequency-hop tracking. Production systems often run an IQ branch for fine decisions and a spectrogram branch for coarse spectrum awareness.

How much does SNR degrade RF CNN classification accuracy?

On RadioML 2018.01A a tuned residual CNN holds ~93 to 95% at 18 to 30 dB SNR, drops to ~80% near 6 dB, and falls toward random guessing (~4% for 24 classes) below −10 dB. High-order constellations like 256-QAM degrade first. Training across the full SNR sweep with augmented carrier and sample-rate offsets plus multipath, rather than on clean signals only, is what prevents a low-SNR cliff.

What input size and inference latency are realistic on edge hardware?

Decision windows are typically 128 to 1024 complex IQ samples (a 2×N tensor) or a ~128×128 spectrogram tile. A compact 4 to 6 layer 1D CNN runs in under 1 ms per window on a GPU and low single-digit ms on an embedded GPU. INT8 FPGA implementations sustain multi-megasample-per-second IQ with deterministic latency under 100 μs, which is what real-time spectrum sensing and electronic support measures need.

Related Terms

← Convolutional Interleaver Cool-Down Time →