Client-Randomized Downlink Decoding: Making Model Compression Hide the Model from a Malicious Server

In federated learning, a central server repeatedly sends a shared model to many devices. Each device trains on its private data and returns only an update. Two problems with this broadcast step have been studied separately. First, sending the model down to devices is slow: it can take more than half of end-to-end training time over wireless links (Practical Hybrid Gradient Compression), so servers compress it. Second, a dishonest server can use the broadcast as an attack channel. It can plant "trap weights," which are carefully placed parameters that make each device's returned update spell out individual training images or sentences (When the Curious Abandon Honesty, The Gradient Puppeteer, MineGrad). Every one of these attacks assumes the device computes its gradient on exactly the weights the server chose.

We propose to move the randomness of downlink compression from the server to the device. The server sends a coarse, quantized model. Each device then fills in the precision the server never sent with its own private random jitter inside each quantization cell. The device also enforces a minimum cell size, measured relative to each weight row, regardless of how precisely the server transmits. Compression becomes something the device controls rather than something the server controls. The bits saved and the uncertainty the server faces about the device's weights are then set by the same quantity. Because the jitter is independent across devices, its first-order effect on the aggregated update averages out the way uplink compression noise does. This addresses the shared-noise problem that makes downlink compression harmful (Improved Convergence Analysis and SNR Control).

Core Claim

Active reconstruction attacks need the server to know, at fine precision, the weights the device will compute on. Downlink compression already discards that precision, but in existing systems the server decides what is discarded. A server that both compresses and attacks can therefore simply plan around its own quantizer.

If the device instead re-quantizes the received model onto a grid it chooses and adds private uniform jitter within each cell, the server learns only which cell each weight lies in. Concretely, device $i$ computes on

$$\tilde w_i = Q_{\Delta}(w_t) + u_i, \qquad u_i \sim \mathrm{Uniform}[-\Delta/2, \Delta/2]^d \text{ drawn privately},$$

where $Q_{\Delta}$ rounds the server model $w_t$ to a grid of step $\Delta$ and $\Delta$ is set per row as a fixed fraction of that row's norm. Setting $\Delta$ relative to the row norm means rescaling weights does not shrink the jitter relative to the activations.

The resulting averaged update has two error terms. The first-order term from the private jitter has variance falling as $1/n$ over $n$ participating devices. The remaining curvature bias is of order $L\,\mathbb{E}\|u_i\|^2$, where $L$ is the smoothness constant. This follows the standard smoothing argument: averaging gradients at independently perturbed points estimates the gradient of a slightly smoothed objective.

We claim three things. At matched downlink bit rates, this scheme reaches accuracy close to deterministic downlink compression. It sharply reduces the success of trap-weight, adapter-routing and backdoor-style attacks. And it requires no device-side memory, so it fits the cross-device setting where devices appear once and cannot keep error-feedback buffers.

Why the mechanism should bite, and where it should not

The effect depends on what each attack needs to hold exactly. In the trap-weight attack, the image is recovered as the ratio of a neuron's weight gradient to its bias gradient. That ratio does not depend on the exact weights. What does depend on them is which samples activate the neuron. Jitter of size $\Delta$ shifts each sample's pre-activation by up to roughly $\|\delta a\|\,\|x\|$, where $\delta a$ is the jitter on the neuron's weight row. Samples near the planted boundary therefore leak through, and the neuron returns a blend of several images. This is the same "ghost image" effect OASIS achieves with data augmentation, but it comes from the communication step and works for any input type.

PEFTLeak (MineGrad) is more exposed. It sets frozen transformer layers to act as identity maps, so that raw image patches pass unchanged to the small adapter layers that are trained. Jitter in each layer compounds along that path, and it also blurs the narrow intervals the server uses to pick out one patch at a time.

The backdoor-style attack EGGV (The Gradient Puppeteer) is the most likely to survive. It shapes the whole gradient landscape rather than relying on one precise hyperplane. An adaptive server could also train it to work on average over random jitter. We treat this attack as the main stress test. Passive optimization-based inversion depends only weakly on exact weights, and we do not expect much protection against it. We will report that honestly rather than claim it.

Relation to prior work

DoCoFL supplies the compression machinery we reuse. It splits the model into an anchor, a compressed older model fetched in the background, plus a small compressed correction. It uses entropy-constrained uniform quantization, which runs over 1,000x faster than standard entropy-constrained quantization. It reports a 16x reduction in bandwidth during active rounds and an 8x reduction in total downlink bandwidth on EMNIST. It assumes an honest server, and all of its quantization randomness is chosen by the server. We apply private jitter to the correction (and optionally the anchor) on the device.

Bidirectional error-feedback methods (DoubleSqueeze, EF21 with Bells & Whistles, 2Direction) constrain the design. Their guarantees need persistent buffers on each device, which cross-device clients lack. That is why we want a scheme without device memory.

Improved Convergence Analysis and SNR Control motivates the design. Its finding is that downlink noise hurts because every device receives the same distortion, so the noise cannot average out across devices. Making the device-side component independent per device is our direct response.

On the privacy side, three attack papers motivate the threat model:

All three evaluate only full-precision broadcasts. Existing defenses act elsewhere in the pipeline:

  • CENSOR replaces the uplink gradient with a sample orthogonal to it.
  • SHE-LoRA encrypts sensitive adapter columns on the uplink.
  • Privacy-Aware Compression builds a 1-bit differentially private uplink compressor.

None of these touches the broadcast. SHE-LoRA explicitly assumes an honest-but-curious server, so it cannot stop a server that alters the model. Our scheme is complementary to all three, and we test it combined with CENSOR.

Research Program

We will build a device-side decoder that does three things:

  • It enforces a per-row minimum relative cell size $\Delta$.
  • It re-quantizes any received model, whether full-precision or ECUQ-coded, onto that grid.
  • It adds private within-cell jitter before local training.

On the server side we will pair this decoder with DoCoFL's anchor–correction scheme. The server then has no reason to send precision finer than $\Delta$, so the minimum cell size directly sets the downlink bit rate.

Analytically, we will derive a convergence bound for this scheme without error feedback. The bound should separate the shared rounding error from the independent jitter error. It should also show that the jitter contributes only a curvature bias of order $L\,\mathbb{E}\|u\|^2$ plus variance reduced by $1/n$, rather than a compounding error floor.

On the attack side, we will derive the margin a trap-weight attacker needs as a function of $\Delta$ and input norm. From this we predict the fraction of a batch that can still be isolated.

We will then build adaptive attacks. These include trap weights with enlarged margins, PEFTLeak with rounding pre-compensated, and EGGV trained on average over sampled jitter. The adaptive attacker knows $\Delta$ and the jitter distribution but not the device's draws.

Baselines

The naive reference point is uncompressed FedAvg with full-precision broadcast and no defense. It gives the attack ceiling, using the published reconstruction rates above as sanity checks, and the utility ceiling.

The strongest existing compression competitor is DoCoFL with ECUQ at the same bit budget. Here the quantizer is server-chosen and deterministic, and the server is aware of it. This baseline answers the gap left open in the literature: does ordinary downlink compression already break active attacks once the attacker plans for it? We run it on the same data splits, models and number of rounds. Bit budgets are matched exactly in bits per parameter per round. DoCoFL's published EMNIST reductions of 16x online and 8x total serve as a check that our reimplementation is faithful. We beat it if we reach similar accuracy at the same bits (within one point on CIFAR-100 ResNet-9, the setting where DoCoFL reports parity with FedAvg) while sharply lowering adaptive-attack success.

The ablation that isolates our key ingredient is public jitter. This uses the identical noise distribution, but the server knows the draw, for example through a shared seed. If private and public jitter protect equally, the benefit comes from noise, not from the server's uncertainty, and our claim fails.

A second ablation replaces structured cell jitter with Gaussian weight noise of matched mean squared error, added on the device without any compression. This tests whether tying the noise to compression matters beyond saving bandwidth.

The strongest existing active-attack defense is OASIS. It reports peak signal-to-noise ratio (PSNR) of reconstructions falling from about 140 dB to about 15–20 dB on ImageNet under trap-weight attacks. It keeps ImageNet accuracy above 90% and loses at most 1.5% on CIFAR-100. We run OASIS with its published augmentations, under the same models and the same tuning budget we give our $\Delta$ sweep. We beat it if we reach comparable PSNR suppression on vision at similar accuracy, while also cutting downlink bits, handling text (IMDB, Shakespeare) where OASIS does not apply, and holding up better against EGGV.

CENSOR is an uplink-defense baseline. It reports about 86% CIFAR-10 accuracy, matching no defense, but gives no numeric MSE or LPIPS values; no reported result was found on Lacuna for exact CENSOR reconstruction errors. It is run alone and stacked with our decoder.

Why not just…?

Why not just let the server compress the downlink and rely on that to break trap weights? The server that compresses is the same party that attacks. It can place trap weights exactly on its own quantization grid, or simply skip compression for the targeted round. No paper in the file measures attacks under downlink compression, so this is unproven either way. The DoCoFL-with-aware-attacker baseline will measure it directly. We expect it to give little protection, and if it does give substantial protection, our contribution shrinks accordingly.

Why not just add Gaussian noise to the received weights on the device? This is the most serious alternative, because the protective mechanism may be largely the same. It costs bandwidth rather than saving it, since the full-precision model must still be sent. It also does not let the device enforce a precision floor the server cannot override. Our matched-MSE Gaussian ablation settles how much the quantization structure itself matters. If Gaussian noise protects equally, the honest conclusion is narrower but still useful: downlink compressors should draw their randomness on the device, so that the noise needed for privacy comes free with the bandwidth savings.

Why not just use data augmentation as OASIS does? OASIS works only on images. It reduces no communication. It was designed against attacks that isolate single neurons and was never tested against EGGV. We will compare it head-to-head on vision and also stack it with our decoder. If OASIS alone dominates on vision, our claim rests on text, bandwidth and EGGV.

Why not just use secure aggregation? Secure aggregation hides individual updates within a single round. It does nothing against a server that alters the broadcast model, and it leaks individual updates across rounds under partial participation within $O(N)$ rounds (Securing Secure Aggregation). It is orthogonal to our scheme, not a substitute.

Proposed Experiments

For utility, we follow DoCoFL's setup: ResNet-9 on CIFAR-100, plus EMNIST, Shakespeare and Amazon Reviews, under writer-based or Dirichlet non-IID splits. We sweep the relative cell size $\Delta$, report accuracy against downlink bits per parameter, and run 3 seeds.

For privacy, we run each attack in its published setting:

  • Trap weights on ImageNet and CIFAR-10 at batch size 100, and on IMDB.
  • PEFTLeak on ViT with LoRA adapters on CIFAR-100 and TinyImageNet, at batch sizes 32 and 128.
  • EGGV on CIFAR-10, CIFAR-100 and TinyImageNet.

Each attack runs in a naive and an adaptive version. We report the fraction of exactly reconstructed samples, PSNR, LPIPS (a learned perceptual similarity score), and batch coverage.

The decisive check is a three-way comparison on adaptive EGGV and adaptive PEFTLeak at equal bits: private jitter versus public jitter versus deterministic ECUQ. Private jitter must clearly beat both, while accuracy stays within one point of DoCoFL. A second check tests the margin prediction: measured trap-weight isolation rates should fall with $\Delta\|x\|$ as derived. If adaptive EGGV keeps near-full coverage at every $\Delta$ that preserves accuracy, we will report that as a limit of the approach rather than tune around it.