In wireless federated learning, many phones or sensors train a shared model and send their updates to a base station. The base station splits its radio band into many narrow frequency slices, called subcarriers, and hands different slices to different devices at the same time. This multi-user scheme is OFDMA (orthogonal frequency-division multiple access). Each device also compresses its update to a few bits per number before sending. The best compressors are "distribution-aware": they place more quantization levels where the update values are dense, near zero, and fewer in the sparse tails. Nobody has asked what happens when those compressed bits cross a noisy channel. In a non-uniform codebook, a single flipped bit in an index can turn a small near-zero value into a large tail value. Meanwhile, the subcarriers a device receives differ sharply in reliability, and so do the bit positions inside each transmitted symbol.
This note proposes the obvious fix that no one has built. Treat the compressor's bits as unequally important, treat the channel's bit slots as unequally reliable, and pair them deliberately: the most damaging bits go on the most reliable slots. We also learn the codebook with the channel's error pattern in view. The claim is that, at matched airtime and transmit energy, this pairing lets devices use aggressive non-uniform compression on moderate-quality channels without the update corruption that currently forces either heavy error-correction overhead or dropped packets. We evaluate the claim under an appraisal protocol borrowed from evidence-synthesis practice, so that the comparisons are matched rather than flattering.
Core Claim
Fix a device's quantized update. Each scalar is mapped to an index $i$ in a codebook $\{c_1,\dots,c_K\}$ with $K=2^b$ levels. The $b$ index bits are then placed into transmission "bit slots" $j$, where a slot is one bit position in a QAM symbol on one subcarrier. A QAM symbol is a point in the amplitude-phase plane that carries several bits at once. Each slot has its own bit-error probability $\varepsilon_j$. That probability depends on the subcarrier's signal-to-noise ratio and on the bit's position in the constellation: in 16-QAM, the bits that choose the quadrant are more robust than the bits that choose the point within it. For small error rates, the expected reconstruction error of the update is approximately
$$D \approx D_q(\mathcal{C}) + \sum_{b} \varepsilon_{\pi(b)}\,\kappa_b(\mathcal{C}),$$
where $D_q$ is the ordinary quantization error of codebook $\mathcal{C}$. The term $\kappa_b$ is the mean squared jump in reconstructed value caused by flipping index bit $b$, averaged over how often each index is used. The map $\pi$ assigns index bits to slots.
For a fixed codebook, the rearrangement inequality says the best $\pi$ simply sorts the bits by $\kappa_b$ in decreasing order and the slots by $\varepsilon_j$ in increasing order, then pairs them. So the assignment step is cheap. The real substance lies in two places. First, distribution-aware codebooks make the $\kappa_b$ very unequal, which uniform grids do not, so the pairing matters most exactly where compression is most aggressive. Second, the codebook itself should be re-learned with the channel term included. In that re-learning, centroids move toward positions whose bit-flip neighbours are not catastrophic.
Bit-plane codebooks such as the variable grid $\{0, c_1, c_2, c_1+c_2\}$ of BPDQ make $\kappa_b$ explicit and easy to control. In that grid, one coefficient stretches toward the tails and the other resolves the dense centre. We reuse this structure.
Channel-optimized quantization is a classical source-coding idea. What is new here is its coupling to three things at once: OFDMA's per-subcarrier reliability spread, codebooks fitted to the heavy-tailed shape of training updates, and the round-by-round scheduling of a federated learning system.
Position Relative to Prior Work
The proposal sits in a gap between two lines of work that each assume away the other's problem.
OFDMA-F²L jointly chooses clients, subchannels and modulation for federated learning over OFDMA. It shows that minimizing its convergence bound reduces to maximizing weighted sum-rate, and that a winner-takes-all subchannel policy is almost surely optimal. It transmits unquantized updates and models no quantization distortion. This paper supplies our channel model and scheduler, and we keep its scheduler fixed so that gains can be attributed to the bit placement.
FedFQ assigns different bit-widths to different update parameters using magnitude as an importance proxy. It reports reaching target accuracy on non-IID VGG11/CIFAR-10 with 1.61 GB of traffic against more than 58 GB for FedAvg. It assumes an error-free bit pipe. FedFQ motivates the proposal, because it shows that update distributions are skewed enough to reward non-uniform treatment. It is also our main compression baseline. Related quantized federated learning methods (FedHQ, adaptive quantization, UVeQFed) share the error-free-pipe assumption.
Three LLM quantization papers supply the codebook machinery, though none of them touches transmission. any4 learns per-row 4-bit codebooks with a weighted K-means. 1-Bit Wonder runs block-wise K-means down to 1 bit. BPDQ supplies the bit-plane grid. The quantile and histogram-equalization quantizers of Baskin et al. and Zhou et al. are the main uniform-occupancy alternative. They matter here because equal-occupancy bins in the tails are wide, and wide bins make the bit-flip jumps large.
The methodological-quality literature plays a different role: it constrains how we evaluate. The umbrella review of AI cancer identification found that 80.4% of systematic reviews rated high quality under JBI, while only 5% of the underlying evidence reached high GRADE certainty. 1-Bit Wonder showed that low-bit comparisons flip once models are compared at matched memory rather than matched parameter count. Both warn that headline gains in our area can come from mismatched comparisons. We therefore adopt a GRADE-style appraisal of our own claims (described below) rather than inventing quality scores for client updates. We considered scoring client updates for quality and rejected it as the core idea, because it reduces to robust aggregation, which is a separate problem.
Research Program
The first component measures how unequal the bit-flip costs actually are. We will record federated updates from CIFAR-10, Fashion-MNIST and MNIST training under Dirichlet label skew, using the partitions of DH-Benchmark. We fit uniform, quantile, K-means and bit-plane codebooks at 1–4 bits and compute the full profile of $\kappa_b$ for each. If the spread of $\kappa_b$ is small for non-uniform codebooks, the proposal loses its motivation, and we will report that.
The second component builds the transmitter. Each round, OFDMA-F²L's scheduler fixes client selection, subchannel assignment and modulation. Each client then sorts its slots by estimated $\varepsilon_j$, which it computes from the per-subcarrier signal-to-noise ratio it already needs for scheduling. It sorts its index bits by $\kappa_b$ and transmits under the sorted pairing. The index bits are sent without a hard drop-on-error rule; a lightweight outer code is applied only to the most significant bit-plane. The receiver decodes, dequantizes and aggregates.
The third component learns codebooks that account for the channel. We extend the K-means objective with the channel term, so that each centroid update averages over the values that would be decoded under expected slot errors. We refit the codebook every few rounds from the current error profile. The codebook itself costs a few dozen scalars per layer block to send, and we will send it on the most reliable slots.
The fourth component is the evaluation protocol. Every comparison is matched on three things: total airtime per round, transmit energy per round, and hyperparameter tuning budget. Accuracy is reported against airtime, not against rounds. Each claim is graded on four points modelled on GRADE: consistency across seeds and channel realizations, precision (confidence intervals over at least 5 seeds × 20 fading draws), indirectness (results under both a Rayleigh frequency-selective model and a tapped-delay profile), and whether any baseline was tuned less than the proposal.
Baselines
The naive reference is uniform 8-bit stochastic quantization. It is sent with OFDMA-F²L scheduling, fixed index-to-slot order, standard error correction, and packets dropped on checksum failure. It shows what one gets by stacking the existing pieces with no coupling between them.
The strongest existing competitor is FedFQ's fine-grained bit allocation feeding into OFDMA-F²L's scheduler, combined with a separate error-correction and modulation choice. That choice is searched over a grid, at the same airtime, to minimize the number of dropped updates. This is the "compress optimally, then protect optimally" design that separation-based engineering would recommend. It is the configuration most likely to match us.
For reference numbers, OFDMA-F²L reports about 18% faster convergence and 5% higher accuracy than alternatives on MNIST with an MLP. FedFQ reports 1.61 GB versus more than 58 GB to target accuracy on non-IID VGG11/CIFAR-10. No reported result was found on Lacuna for OFDMA-F²L's CIFAR-10 or Fashion-MNIST accuracy, or for any method combining quantized updates with OFDMA. We will therefore reproduce both baselines in our own simulator and compare there. Beating the strongest competitor means reaching the same target test accuracy with at least 20% less airtime, or reaching higher final accuracy at equal airtime, with non-overlapping 95% intervals, in the moderate signal-to-noise regime.
Three ablations isolate the key ingredient. The first uses a random index-to-slot mapping with the same non-uniform codebook, to show that the pairing itself matters. The second uses Gray-labelled uniform quantization with the sorted pairing, to test whether distribution-awareness is needed or whether ordinary uniform protection of significant bits already captures the gain. The third uses the channel-unaware codebook with the optimal pairing, to separate the effect of codebook re-learning from the effect of pairing.
Why not just…?
Why not just use stronger error correction and a lower-order modulation, keeping compression and protection separate? This is the real threat. Separation is asymptotically optimal for long blocks. Federated rounds under latency limits, however, send short packets, and every protection bit is airtime taken from the update. The strongest-baseline arm above runs exactly this design with its error-correction rate and modulation tuned at matched airtime. If it matches our method across signal-to-noise ratios, we will conclude that unequal protection is unnecessary, and the paper becomes a negative result about channel-coupled quantization in OFDMA.
Why not just run FedFQ's bit allocation and then let the OFDMA scheduler do its job? Neither stage sees the other's objective. FedFQ weighs parameters by magnitude assuming no bit errors, and winner-takes-all scheduling hands out subchannels by rate without regard to what the bits encode. The decoupled baseline tests this directly. Our prediction is that it loses most where FedFQ's 2-bit parameters land on weak slots.
Why not just use plain Gray coding with a uniform quantizer, which already makes most bit errors small? For uniform grids this may well be enough. The Gray-uniform ablation exists to find out, and the $\kappa_b$ profiling in the first component predicts the answer in advance. If uniform grids show nearly the same spread of $\kappa_b$ as non-uniform ones, the distribution-aware part of the claim fails.
Decisive Checks
The experiments run on simulated OFDMA uplinks with 8 and 16 subchannels, 10–50 clients and M-QAM modulation, following the OFDMA-F²L setting. We sweep mean signal-to-noise ratio from 5 to 25 dB and use CIFAR-10 CNN, Fashion-MNIST CNN and MNIST MLP under DH-Benchmark label, feature and quantity skew. Metrics are test accuracy against cumulative airtime, airtime to target accuracy, update reconstruction error after the channel, and energy per round.
The decisive pattern has three parts. The gain over the tuned separation baseline should be near zero at high signal-to-noise ratio, where all slots are reliable. It should peak at moderate signal-to-noise ratio. It should be larger for 1–2-bit non-uniform codebooks than for 4-bit codebooks. Every reported gain must survive the matched-budget appraisal above. A gain that holds only against the naive reference, or only when accuracy is plotted against rounds, will be reported as low-certainty evidence and not as the result.
References
- BPDQ: Bit-Plane Decomposition Quantization on a Variable Grid for Large Language Models
- OFDMA-F²L: Federated Learning With Flexible Aggregation Over an OFDMA Air Interface
- FedFQ: Federated Learning with Fine-Grained Quantization
- FedHQ: Hybrid Runtime Quantization for Federated Learning
- Communication Efficient Federated Learning with Adaptive Quantization
- UVeQFed: Universal Vector Quantization for Federated Learning
- any4: Learned 4-bit Numeric Representation for LLMs
- 1-Bit Wonder: Improving QAT Performance in the Low-Bit Regime through K-Means Quantization
- UNIQ: Uniform Noise Injection for Non-Uniform Quantization of Neural Networks
- Balanced Quantization: An Effective and Efficient Approach to Quantized Neural Networks
- Artificial Intelligence Performance in Image-Based Cancer Identification: Umbrella Review of Systematic Reviews