Correlated Noise in the Core: Long-Horizon Private Federated Fine-Tuning That Does Not Trust the Server's Bases

Federated fine-tuning of large models runs into three problems at once. Sending full updates is too expensive. Sending small adapter updates still leaks training data, because a malicious server can shape the frozen parts of the model so that the shared gradients act as filters that reconstruct inputs. And adding differential-privacy noise, meaning random perturbation calibrated so that no single training example measurably changes what is released, uses up a fixed privacy budget a little more each round, so long training runs either drown in noise or run out of budget. The best tool against the third problem is correlated noise across rounds, where each round's noise partly cancels the previous round's. Its practical obstacle has been memory: every client must store several past noise vectors the size of the model. We propose running correlated-noise mechanisms entirely inside the tiny $r \times r$ "core" matrix that Fed-SB-style adapters communicate. In that space the noise memory is negligible, each client can add its own correlated noise before anything leaves the device, and the resulting guarantee holds no matter which projection bases or backbone weights the server sends.

The claim is that a known noise mechanism, used in the right low-dimensional space, closes several gaps together. Clients get formal long-horizon privacy against a server that is curious or actively malicious, with kilobyte-scale messages and kilobyte-scale noise buffers. On long runs this should give better accuracy at fixed privacy budget than Fed-SB with independent per-round noise. We will also measure, rather than assume, the privacy budget at which active adapter inversion stops working.

Core Claim

Fed-SB writes each layer's update as $\Delta W = B R A$. The server computes the orthonormal bases $A, B$ once by SVD on a 0.1% calibration split and freezes them. Clients then train and send only the $r \times r$ matrix $R$. This makes aggregation exact and removes the noise-times-noise blowup of private LoRA. Fed-SB still adds independent noise each round, and it assumes the server's bases are benign.

Banded matrix-factorization mechanisms take a different approach. BANDMF and BISR treat training as releasing running sums of gradients and add noise correlated across a window of $\hat b$ rounds. This sharply reduces error accumulated over long horizons. Their cost is a buffer of $\hat b$ past noise vectors of model size, which the research file flags as prohibitive for large models on edge hardware.

Inside the core, that buffer shrinks to $\hat b \cdot r^2$ numbers per adapted layer. For rank 64 and bandwidth 16, that is about 65 thousand floats per layer, small enough for any device.

We therefore move noise generation to the client. In round $t$, silo $k$ clips its per-example contributions to $R$ in the core space. It then releases

$$\tilde R_{k,t} = R_{k,t} + \sum_{j=0}^{\hat b-1} c_j\, z_{k,t-j},$$

where $z_{k,t-j}$ are fresh Gaussian draws stored in the silo's local buffer and $c_j$ are banded coefficients of the kind BISR computes in closed form. Clipping and noising both happen on the client, in a space whose meaning does not depend on how the server built $A$ and $B$. The example-level guarantee therefore holds against any server choice of bases or backbone weights, including the identity-mapping and filter constructions of MineGrad. This rests on one assumption we will check carefully rather than take for granted: the matrix-factorization analysis must remain valid when the server chooses its inputs adaptively.

We study two operating modes. In the silo-local mode, each silo protects its own examples and the server sees each noisy $\tilde R_{k,t}$. This is the strongest trust model and pays the full per-silo noise cost. In the secure-aggregation mode, each silo adds a $1/K$ share of the noise variance under secure summation. The shares sum to a correlated stream with the same coefficients, which recovers central-noise utility. The price is that dropouts must be absorbed with a variance margin.

Research Program

The work has three parts.

The first part is the mechanism and its privacy analysis. We will port BANDMF's banded construction and BISR's inverse-banded construction to per-silo core streams, then account for privacy under both modes. Two accounting questions follow from the file. Do the band constraints of the cross-silo setting with fixed participation let us drop BANDMF's participation-separation requirement? Does within-silo minibatch subsampling still amplify privacy? This second question matters because BISR's authors report that lower error in the running sums did not translate into accuracy gains once subsampling amplification was used. That observation constrains our design: we cannot assume lower error means better models, and we must measure accuracy directly.

The second part is an attack audit. We will build the strongest active attack we can against the core. A malicious server chooses $A$, $B$, and the frozen backbone, following MineGrad's identity routing and its interval filters fitted on proxy data. It may also re-randomize the bases across rounds, as MineGrad does at $r=8$. It then attempts patch recovery from the released $\tilde R$. We will add the batch-normalization manipulation of Breaking Secure Aggregation in the label-leakage variant. Finally, we will trace attack success as a function of the privacy budget. This answers the question MineGrad explicitly left open: the budget at which formal privacy neutralizes the attack.

The third part is a utility study over long horizons. Correlated noise is meant to pay off over hundreds to thousands of rounds, which is where independent per-round noise degrades. Dynamic privacy allocation shows this degradation for full-vector local-privacy federated learning beyond 8,000 iterations. We will test the same regime in the core.

Baselines

The naive reference point is Fed-SB exactly as published. It uses server-computed frozen bases and independent Gaussian noise each round, calibrated by standard Rényi accounting, as in Rényi DP ERM. We run it with the same model, data split, number of rounds, rank, and hyperparameter search budget as our method; the only change is the noise process. Its reported strength is 70.33% accuracy on SNLI at $\epsilon=1$, against 49.57% for FedIT (Fed-SB). Beating it means higher accuracy at matched $\epsilon$, with the gap widening as rounds increase. A result at short horizons alone would not count.

The strongest existing long-horizon method is full-adapter BANDMF. It applies correlated noise to the flattened LoRA parameter vector, using the construction of BANDMF. This paper reports a 1–4 percentage-point gain over DP-SGD on CIFAR-10. It also reports reducing $\epsilon$ from 6.69 to 4.35 at equal utility in a production keyboard deployment. We run it at the bandwidth that fits the same client memory as our method, and also at its preferred bandwidth with memory reported separately. To beat it, our method must match its accuracy at much lower memory and communication. Alternatively, it must exceed it, because removing the noise-times-noise cross term should matter more as $\epsilon$ shrinks.

PRISM is the strongest geometry-aware private LoRA method. It adds noise in the tangent space of the low-rank matrix manifold. We implement a federated version with server averaging of tangent updates. Its reported result is 0.690 average accuracy on Math-10K at $\epsilon=6$, against 0.641 for AdamW private LoRA. We compare on Math-10K under identical federation settings. To beat it, our method must reach equal or better accuracy at lower step time, since PRISM reports roughly doubled step time.

Two ablations isolate the key ingredient. The first keeps our client-side core noise but makes it independent across rounds. Any difference from the full method is then attributable to correlation alone. The second keeps correlation but generates the noise centrally at a trusted server. Comparing it with the client-side version separates the utility cost of not trusting the server from the benefit of correlation.

The heuristic defense reference is mixed quantization. It reports DLG reconstruction PSNR falling from 55.3 dB to 8.1 dB, with 96.67% MNIST accuracy. We include it only in the attack audit, under our active attacker.

Why not just…?

Why not just keep Fed-SB with independent noise and rely on subsampling amplification? This is the real threat. BISR's authors found that lower error in running sums did not always yield accuracy gains once amplification was used. Correlation could therefore buy nothing in practice. The first ablation settles this directly by comparing correlated and independent core noise at 200, 1,000, and 3,000 rounds. If the gap stays within seed noise at all horizons, the honest conclusion is that the core's small dimension already solves budget depletion. The contribution would then reduce to the client-side trust model and the attack audit.

Why not just let clients verify the bases instead of adding noise? If the calibration split and backbone weights are public, each client can recompute the SVD and hash-check the backbone. That neutralizes MineGrad-style manipulation of $A$ and $B$ at no cost to accuracy. We accept this and will run verified bases as a condition. It does not remove passive inversion of $R$ across rounds, which user-level leakage work shows accumulates over successive updates. It also fails when the calibration data is itself private to the server. Our audit reports attack success under verified bases without noise to quantify what verification alone leaves exposed.

Why not just use mixed quantization, which is cheaper and kept accuracy high? Its protection depends on the attacker lacking the dequantization scales. It was evaluated only against passive optimization attacks on LeNet-5. It also has no account of how leakage accumulates across rounds. The audit applies our active core attacker to quantized releases. If patch recovery remains high, as MineGrad found for uniform quantization, that settles the question.

Why not just use PRISM's tangent-space noise? Fed-SB's frozen bases already make the update linear in $R$, so the problem the tangent geometry solves does not arise in the core. PRISM is also centralized and slower per step. The head-to-head on Math-10K tests whether its extra flexibility, an update subspace that is not frozen, buys back accuracy. That flexibility is the one place it could win under non-IID silos.

Proposed Experiments

Language experiments use the private SNLI and commonsense setups of Fed-SB with Llama-3.2 3B, and Math-10K with a Gemma model following PRISM. We partition data across 10 and 50 silos, both IID and with Dirichlet label skew, at $\epsilon \in \{1, 3, 6\}$ and three horizons. We report accuracy, bytes sent per round, client noise-buffer memory, and step time.

The vision audit fine-tunes a ViT with core adapters on CIFAR-100, CIFAR-10, and TinyImageNet. We vary batch size between 32 and 128 and rank between 8 and 64. For reference, MineGrad reports 85.9% patch recovery on CIFAR-100 at batch 32 against unprotected adapters. We report the fraction of recovered patches, PSNR, and label-recovery accuracy as functions of $\epsilon$.

The decisive checks are four. First, whether correlated core noise beats independent core noise at long horizons under matched $\epsilon$. Second, whether active patch recovery falls to chance at a budget where SNLI accuracy remains close to Fed-SB's published 70.33% at $\epsilon=1$. Third, whether silo-local noise costs too much accuracy without secure aggregation, which would decide which mode is practical. Fourth, whether skewed silos expose the rigidity of the frozen subspace enough that PRISM's free subspace wins. In that case the follow-up is periodic, client-verifiable re-estimation of the bases.