Precision That Grows With Each Iteration: Contraction-Aware Hardware for Unfolded Channel Estimators

Before a wireless receiver can decode data, it has to estimate the channel: how the signal between each transmit and receive antenna has been scaled and phase-shifted. The most accurate recent estimators are built by deep unfolding, which takes a classical iterative algorithm, fixes it at a few steps, and turns each step into a small trainable network. The best of these are fixed-point estimators. They repeatedly apply one learned map that is guaranteed to pull any two inputs closer together (a contraction), so they settle in about four iterations. All of them have only been run as floating-point software. The one estimator that has been built into real hardware is a generic image-style convolutional network, and it loses accuracy when the channel has few propagation paths. Meanwhile, estimation latency is almost always simulated as zero, even though a channel measured at time $t$ is used some time later, after it has already changed.

This note proposes building a fixed-point unfolded estimator on an FPGA (a reconfigurable chip) using a hardware structure that follows from the contraction itself. A contraction shrinks errors made in early iterations before the output is produced, so early iterations can run at low numerical precision and later ones at higher precision. The per-iteration bit widths can be predicted from the contraction factor. The whole design is then trained and chosen to minimize the error of the channel estimate at the moment it is used, with that delay measured on the board. The claim is that this matches the accuracy of uniformly quantized designs with fewer chip resources, and that on the latency-sensitive metric it beats both those designs and the existing hardware convolutional estimator.

Core Claim

Let $T$ be the learned estimator step, with contraction factor $\rho<1$. Run it for $K$ iterations from $x_0$, and suppose iteration $k$ introduces a rounding error of size at most $\delta_k$. The fixed point is $x^\star$. The standard perturbed fixed-point argument gives

$$\|x_K - x^\star\| \le \rho^K \|x_0 - x^\star\| + \sum_{k=1}^{K} \rho^{K-k}\,\delta_k .$$

Rounding error roughly halves with each extra bit ($\delta_k \propto 2^{-b_k}$ for $b_k$ bits). To make every term in the sum contribute equally, the bit width should increase by about $\log_2(1/\rho)$ bits per iteration. For example, with $\rho \approx 0.5$ that is about one extra bit per stage.

This yields a concrete, falsifiable prediction. A four-stage pipeline in which each stage has its own bit width, following this rule, should reach the accuracy of a uniform-width pipeline while using fewer multiplier blocks and memory. The saving should grow as $\rho$ shrinks.

The bound only holds if the quantized map is still a contraction. Nothing in the file checks this. The convergence proofs for FPN-OAMP and PR-DEN assume infinite precision. Rasch et al. found that noise on intermediate activations and outputs hurts accuracy more than noise on weights. That finding suggests the quantized activations inside the loop, not the weights, are what can break contraction. The design therefore also trains with a penalty on the measured contraction factor of the quantized map.

The second half of the claim concerns latency. A pipeline design is fixed by its iteration count and per-stage bit widths. Each design has a latency $\tau$, measured on the board, not modeled. We train and select designs on the effective error

$$\mathcal{L}_{\text{eff}} = \mathbb{E}\,\|H(t+\tau) - \hat H\|^2 / \|H(t+\tau)\|^2 ,$$

where $H(t+\tau)$ is the true channel when the estimate $\hat H$ is applied. This adapts the latency-injection idea from Air Learning to the physical layer. That work trained a drone controller with measured onboard latency and cut the real-world flight-time gap from 37.73% to 0.5%. Under this objective, the choice between accuracy and latency becomes a single optimum that depends on how fast the channel changes (the Doppler spread), rather than a frontier handed to the system designer.

Relation to Prior Work

Two groups of prior work motivate this proposal.

The first group is physics-grounded but software-only. FPN-OAMP pairs a fixed linear estimator with a learned denoiser inside a contractive fixed-point iteration. It converges in 4 iterations and gains up to 15 dB over plain OAMP on a 1024-antenna, 300 GHz dataset. PR-DEN derives a non-expansive dual-domain fixed-point map and reports about 5% further gain. AMP-SBL unfolding unrolls sparse Bayesian learning and hits an error floor at high SNR. All three run only in floating point. We reuse the FPN-OAMP structure because its fixed, precomputed linear stage fits naturally into on-chip memory.

The second group is hardware-first but physics-free. SwiftChannel puts an 8-bit, quantization-aware-trained super-resolution CNN on an RFSoC. It reaches −6.833 dB NMSE on CDL-B in 0.883 ms, but it degrades on sparse CDL-A. SwiftChannel uses one bit width throughout and does not model channel aging. We change both.

Constraining work comes from DRACO, which showed that cutting arithmetic can increase latency if it destroys data reuse. For that reason we unroll to uniform-shape pipeline stages rather than subarray-irregular ones. wa-hls4ml reports latency surrogates with $R^2 = 0.95$ on synthetic networks, but they degrade on real domain models. This is why latency is measured on the board and not predicted.

Research Program

We will build the estimator in three stages.

Stage 1: quantization-aware training with a contraction penalty. The FPN-OAMP denoiser is trained in fixed point, with a separate quantizer for each unrolled stage. Weights stay tied in floating point, but each stage gets its own quantized copy. A penalty keeps the contraction factor of the quantized map below a target value. We estimate that factor by power iteration on the Jacobian of the quantized step.

Stage 2: hardware generation. Each stage becomes one module of an HLS streaming pipeline (HLS, or high-level synthesis, compiles C-like code into circuits), in the style of SwiftChannel's RFSoC engine and generated through hls4ml. The fixed linear stage is stored in block RAM. Stage widths follow the $\log_2(1/\rho)$ rule, then are refined by a small search over the actual synthesized designs.

Stage 3: latency measurement and retraining. We measure the latency distribution of each synthesized design on the board, including input and output transfers. That measured distribution is fed back into training under $\mathcal{L}_{\text{eff}}$. Target channels are generated at the delayed time, following the Air Learning recipe.

The analysis tests three things: whether the measured contraction factor predicts the bit-width slope, whether contraction survives quantization, and at which Doppler spreads the aging term changes the best design.

Baselines

Least-squares interpolation on the FPGA. This is the do-nothing reference point. It is nearly zero-latency, and CeBed reports that learned estimators saturate or even fall below it at high out-of-distribution SNR. It is run on the same board and the same channels, with no tuning. Any proposed design must beat it on $\mathcal{L}_{\text{eff}}$ at every SNR tested, or we report exactly where it fails.

SwiftChannel. This is the strongest existing hardware method. Its reported numbers are −6.833 dB NMSE on seen CDL-B and 0.883 ms latency on a Zynq UltraScale+ RFSoC (SwiftChannel). We re-implement it on the same RFSoC family, train it on the same CDL-A through CDL-E splits, and give it the same hyperparameter-search budget. Beating it means lower NMSE on CDL-A and on the unseen profiles at no greater latency, and lower $\mathcal{L}_{\text{eff}}$ at high Doppler.

Floating-point FPN-OAMP and PR-DEN in software. These set the accuracy ceiling. On the THz dataset they are compared against the reported gain of up to 15 dB over OAMP. The file contains no reported result on Lacuna for FPN-OAMP on CDL channels or on any hardware, so we establish these numbers ourselves.

Uniform-width quantized FPN-OAMP. This is the key ablation. It is the same network and the same hls4ml flow at a single bit width, swept from 8 to 16 bits, and given the same training budget as the proposal. The proposal wins if it matches this design's NMSE within 0.2 dB while using measurably fewer DSP blocks (the chip's hardware multipliers) and less block RAM.

Two further ablations. One removes the contraction penalty and one removes the latency-aware objective. They separate the contribution of each ingredient.

Why not just…?

Why not just apply uniform 8-bit quantization-aware training through hls4ml? This is the most serious threat. If uniform 8 bits already preserves contraction and accuracy, the per-stage schedule only saves resources, and the saving might be small. The uniform-width sweep settles the question directly. If the resource savings at matched NMSE fall within synthesis noise, we will report the schedule as unnecessary and keep only the contraction-verification result. The evidence that uniform low precision is risky comes from Rasch et al.: activation and output noise dominates accuracy loss, and the inputs to an iterated map are exactly such activations.

Why not just keep SwiftChannel's CNN and train it on more sparse channels? More data might close part of the CDL-A gap. However, the CNN encodes no physical structure, and CeBed's high-SNR degradation suggests the problem goes beyond data coverage. We will give SwiftChannel a training mix that is balanced across CDL profiles, then compare on held-out profiles and SNRs.

Why not just add a channel predictor after any fast estimator, instead of latency-aware training? A learned extrapolator placed after least squares or SwiftChannel could handle channel aging almost as well. We include this combination as a baseline, trained with the same measured $\tau$. If it matches our design, the contribution narrows to the precision schedule, and we will say so.

Why not just run fewer iterations? Truncating to one or two stages lowers latency, but the error bound predicts an accuracy floor of order $\rho^K$. The sweep over $K$ under $\mathcal{L}_{\text{eff}}$ shows exactly where truncation wins.

Proposed Experiments

Datasets. We use MATLAB 5G Toolbox CDL channels (profiles A through E), sweeping SNR and user speed, to compare directly with SwiftChannel. We use the CeBed scenarios to test SNR shift. We use a reduced-aperture version of the FPN-OAMP THz near-field setup, sized to fit the RFSoC.

Metrics. We report NMSE, effective NMSE at the time of use, latency distributions measured on the board, LUT/DSP/BRAM usage (the chip's logic, multiplier, and memory resources), and the empirical contraction factor of each quantized stage.

Decisive checks. The proposal succeeds only if three things hold.

First, the fitted slope of bit width against iteration must track $\log_2(1/\rho)$ across denoisers trained to different contraction factors. If it does not, the core mechanism is wrong.

Second, the quantized maps must keep a measured contraction factor below 1 on test data only when the contraction penalty is used.

Third, the design selected under $\mathcal{L}_{\text{eff}}$ must differ from the one selected under zero-latency NMSE at high Doppler, and must beat it there. At low Doppler we expect the two to coincide, which serves as a sanity check. This third check will also show whether latency differences of tens to hundreds of microseconds between designs matter relative to realistic coherence times. If they do not, the latency half of the claim is withdrawn.