Error Feedback Undoes Compression as a Privacy Defense

Federated learning trains one model across many devices by having each device send a model update, never its raw data, to a server. To save bandwidth, devices often compress these updates. They either keep only the largest few percent of coordinates (sparsification) or round each number to a few bits (quantization). Several papers report that this compression also makes it harder for a curious server to reconstruct the device's training images from the update. The catch is a standard trick that almost every practical compressor uses to keep training from slowing down: error feedback. The device remembers what it failed to send and adds it to the next update. Over rounds, then, nearly everything that compression "hid" eventually goes out.

This note proposes to show that effect, measure it, and fix it. The first part is an attack. It exploits the fact that, under error feedback, a client's compressed messages add up over time to almost exactly its uncompressed updates. A server can therefore run standard reconstruction on the summed stream and recover data at compression levels where single-round attacks fail. The second part is a compressor designed so that the information it defers is always covered by a differential privacy guarantee. Differential privacy (DP) is a formal promise, enforced by clipping each update's size and adding calibrated noise, that any one example has only a bounded effect on what is released. The compressor chooses which coordinates to send using only public information, which also lets it add less noise.

Core Claim

Error feedback keeps a local buffer $e_t$ of discarded residuals. The client sends $m_t = \mathcal{C}(e_t + g_t)$, where $\mathcal{C}$ is the compressor and $g_t$ is the client's true update at round $t$, and sets $e_{t+1} = e_t + g_t - m_t$. Summing over rounds gives the telescoping identity

$$\sum_{t=1}^{T} m_t \;=\; \sum_{t=1}^{T} g_t \;+\; e_1 - e_{T+1}.$$

The residual $e_{T+1}$ stays bounded for contractive compressors such as keeping the top-$K$ coordinates (Top-$K$); that boundedness is exactly what the convergence proofs rely on. So the server holds a near-lossless copy of the summed true updates. It also knows the model it broadcast at every round, so it can fit dummy data to the summed gradient trajectory. This yields our main hypothesis. Under error feedback, the empirical privacy benefit of compression decays with the number of observed rounds, and a telescoping attack closes most of the gap to the uncompressed attack.

The file lists this as an open gap (Gap 1). The error-feedback methods Clip21, Safe-EF and lossless sparsification via alternative spaces all carry residuals forward, and none of them studies reconstruction. On the other side, the compression-as-defense evidence comes from methods without error feedback. Mixed quantization drops DLG reconstruction PSNR from 55.3 to 8.1 on LeNet-5, but it uses no error feedback and has no formal guarantee.

The constructive claim is that the placement of privacy noise relative to the error buffer, together with how the kept coordinates are chosen, determines whether compression helps or hurts privacy. We propose public-mask error feedback. Each round, the kept coordinate set $S_t$ is computed from the previous global aggregate, which the server has already broadcast. The client then masks $e_t + g_t$ to $S_t$, clips that masked vector, and adds Gaussian noise only on those $k$ coordinates. Its buffer keeps the clipped-away and masked-away parts, and the buffer's own contribution is clipped, in the style of DiceSGD.

Because the mask does not depend on the client's data, the coordinate choice itself leaks nothing. Because only the kept coordinates are clipped and noised, the design aims to recover some of the sensitivity reduction that DP-SparFL obtains from random sparsification (a threshold of $\sqrt{s}C$ instead of $C$). The mask is still biased toward coordinates that matter. That property is what DP-SparFL explicitly gave up by restricting itself to random masks.

Research Program

The work has three parts.

The telescoping attack. We build it on top of existing reconstruction machinery rather than inventing new priors. The objective matches cosine similarity between the summed dummy gradients, computed at each round's broadcast model, and $\sum_t m_t$. We regularize with total variation and batch-norm statistics as surveyed in the gradient inversion survey. We run it both in pixel space and in the generative latent space of GIAS. As a stronger variant, we feed the approximately de-compressed per-round gradients into the robust temporal aggregation of TGIAs-RO. The de-compressed gradients are estimated as successive differences of partial sums, with the residual treated as bounded noise. TGIAs-RO already shows that multi-round observation defeats 40% sparsification. What it does not show is that error feedback supplies the attacker with a near-dense signal even at 99% sparsity.

Privacy accounting for the proposed compressor. The DP analysis follows the Rényi-DP route of DiceSGD, which proves that feeding back clipped residuals is private at a slightly higher noise multiplier. We extend that route to the case where the released vector is restricted to a public mask. We will state the sensitivity bound for the masked, clipped message and show how the buffer's re-injected mass enters the composition.

Convergence. We will prove a non-convex rate for the proposed compressor, reusing the contractive-compressor arguments of EF21-style analysis in Clip21. The public mask is contractive only in expectation along the optimization path, so the proof must bound how stale the previous aggregate is as a proxy for the current update. We will measure that staleness empirically as well.

Baselines

The naive reference point is uncompressed FedAvg with no DP, which gives the utility ceiling and the attack's upper bound. A second naive point is Top-$K$ with error feedback and no DP. Measuring the telescoping attack against it is the first core result. If single-round PSNR is low but summed-stream PSNR approaches the uncompressed case, the hypothesis holds.

The strongest existing method for utility under DP is DiceSGD. On CIFAR-100 with a pre-trained ViT-small at $\epsilon=2$, DiceSGD reports 86.5% accuracy against 78.9% for standard clipped DP-SGD (DiceSGD). It sends full-dimensional vectors, so we run it at matched $\epsilon$ and compare accuracy per transmitted bit. Beating it means matching its accuracy within one point at $\epsilon=2$ while sending at least 20 times fewer bits, with telescoping-attack SSIM no worse than DiceSGD's.

The strongest private-and-compressed competitor is DP-SparFL (Gradient sparsification for efficient wireless FL with DP), which uses random sparsification with $\sqrt{s}C$ clipping and no error feedback. The file lists no reported numerical accuracy for it on Lacuna, so we reimplement it without the wireless scheduling component. RQM is included as the quantization-native DP baseline; the file lists no reported numerical accuracy for it on Lacuna either. Mixed quantization is included as the heuristic defense, to test whether its 55.3→8.1 PSNR drop survives multi-round and generative-prior attacks.

All methods share the same models, client partitions, $\epsilon$ targets and round budget. They also get the same grid of 24 configurations over learning rate, clipping threshold and sparsity, all tuned on a held-out validation split.

Three ablations isolate the key ingredients. The first swaps the public mask for the client's own Top-$K$ indices, which is data-dependent and so tests whether index leakage matters empirically. The second swaps it for a random mask, which tests whether the public mask's bias actually buys convergence. The third removes the error buffer, which tests how much convergence error feedback buys and how much leakage it costs.

Why not just…?

Why not just privatize first and compress afterward? Under this ordering, the client clips and noises the full update, and then applies Top-$K$ with error feedback to the noisy vector. Everything sent is post-processing of a DP output, so the buffer cannot leak extra. This is the most serious alternative, and it is run as a baseline. Our expectation is that it wastes the compressor: noise is spread over all $d$ coordinates at full sensitivity $C$, so Top-$K$ partly selects noise. The public-mask design instead noises only $k$ coordinates at reduced sensitivity. If privatize-then-compress matches our accuracy at equal $\epsilon$ and bits, the constructive half of this proposal is unnecessary, and we will report that the attack result plus this ordering is the recommendation.

Why not just drop error feedback and use random sparsification, as DP-SparFL does? Doing so removes the telescoping channel entirely. The price is permanently discarded information, which the convergence literature associates with drift and slower rates (the file cites work showing rates falling from linear to sublinear without compensation). Our ablation without the buffer measures the bits-to-target-accuracy gap directly. If that gap is small on non-IID CIFAR-10, the case for keeping error feedback weakens.

Why not just rely on secure aggregation so the server sees only sums? Multi-round leakage in secure aggregation shows that partial participation lets the server isolate individual updates by solving linear systems within $\mathcal{O}(N)$ rounds. Telescoping composes with that isolation. Dynamic sparse masks also sit poorly with secure aggregation's fixed-size dense inputs, whereas a public mask is shared by all clients and so is compatible with it. We test this compatibility directly by running the proposal inside a simulated secure-aggregation round.

Why not just take more local steps? The survey reports that ten local iterations cut single-round recovery success by over 60%. TGIAs-RO, however, shows that multi-round observation defeats that protection. We include local-step counts of 1, 5 and 10 as a factor in the attack study rather than as a competing defense.

Proposed Experiments

The attack study uses ResNet-18 on CIFAR-10 and ImageNet at 64×64, where GIAS reports 15.58 dB PSNR against 13.78 dB for pixel-space attacks. Batch sizes are 8 to 64, sparsity is 90% to 99.9%, quantization is 1 to 8 bits, and the number of observed rounds $T$ is 1 to 50. We report PSNR and SSIM for three attacks: single-round, telescoping, and telescoping plus TGIAs-RO. These cover both error-feedback and no-error-feedback compressors.

The decisive check is this. At 99% Top-$K$ sparsity, the telescoping attack on the error-feedback client should reach SSIM within 0.1 of the uncompressed attack by $T=20$, while the no-error-feedback client stays near chance. If summed-stream reconstruction fails to beat single-round reconstruction, Gap 1 is empty and we report that negative result.

The utility study uses CIFAR-10 split across 100 clients with Dirichlet label skew, CIFAR-100 with ViT-small fine-tuning at $\epsilon \in \{1, 2, 8\}$ to mirror the DiceSGD setting, and TinyImageNet. We report test accuracy, total uplink bits to a target accuracy, and the reference that lossless alternative-space sparsification reached 78% on CIFAR-10 with 149 times fewer bits than FedAvg without DP. Every private configuration is also attacked, which places each method on a three-way curve of accuracy, bits and reconstruction SSIM at a fixed $\epsilon$.

The second decisive check is that public-mask error feedback should strictly dominate both privatize-then-compress and DP-SparFL on accuracy-per-bit at matched $\epsilon$ and matched attack SSIM. If it does not, the attack finding stands alone and the constructive claim is withdrawn.