Persistent Low-Rank Adversaries for Cheap Adversarial Training

Adversarial training makes an image classifier robust by training it on worst-case perturbed inputs. Finding each worst-case perturbation is itself a small optimization, usually several steps of gradient ascent on the input, and repeating it for every minibatch makes training 7 to 30 times slower than ordinary training. The two standard ways to cut this cost both throw information away. Single-step methods restart the search from scratch each time. "Free" training warm-starts the search only while replaying the same minibatch, which costs clean-data diversity.

An obvious fix is to let every training example keep its perturbation from one epoch to the next and take one more ascent step each time the example is seen. A multi-step attack would then be spread across the whole training run. This fails at scale for a curse-of-dimensionality reason. The stored adversary state grows with input dimension $d$ and dataset size, roughly 0.77 TB in fp32 for ImageNet at 224×224. We propose storing each example's perturbation as a small low-rank factorization and evolving it with a rank-adaptive update borrowed from dynamical low-rank methods for high-dimensional PDEs. This makes the persistent adversary fit in memory. The project asks whether such an amortized adversary gives multi-step robustness at single-step cost, and whether it avoids the sudden robustness collapse that afflicts single-step training.

Core Claim

The bet rests on one measured fact. Low-Rank Adversarial PGD Attack represents an $N\times M$ image perturbation as $\delta = UV^\top$ with rank $r\ll\min(N,M)$ and runs gradient ascent on the factors. At a rank of about 10% of the image side, it matches full-rank PGD success rates on ImageNet. It also cuts perturbation memory about fivefold on CIFAR-10. Those authors use this only as an attack and explicitly leave training-time use to future work.

That attack does not run faster per step, so dropping it into the training loop as-is would not reduce compute. Our claim is different. Low rank is what makes per-example persistence affordable, and persistence is what reduces compute. Per example and channel, storage falls from $NM$ to $r(N+M)$, roughly $\sqrt{d}$ instead of $d$ scaling for square images. This is the same move dynamical low-rank methods make for six-dimensional kinetic equations: they evolve the solution on a low-rank manifold instead of a full grid, as in An efficient dynamical low-rank algorithm for the Boltzmann-BGK equation.

There is a secondary claim. Because the stored adversary has accumulated many ascent steps, it should behave like a multi-step attack rather than a single fresh step. If so, it should resist catastrophic overfitting, the abrupt loss of multi-step robustness that single-step training suffers at large perturbation radii. It should do so without double backpropagation or extra forward passes.

Research Program

Each training example $i$ stores factors $U_i\in\mathbb{R}^{N\times r}$ and $V_i\in\mathbb{R}^{M\times r}$ per channel, kept in fp16. On each visit we form the perturbation and clip it into the threat ball:

$$\delta_i=\Pi_{\epsilon}(U_iV_i^\top),$$

where $\Pi_\epsilon$ clips entries to $[-\epsilon,\epsilon]$. We then run one forward and one backward pass. As in Adversarial training for free!, that single backward pass yields both the weight gradient and the input gradient $G_i=\nabla_x\mathcal{L}$. The weights take their step. The factors take an ascent step through the chain rule, $U_i \leftarrow U_i+\eta\, G_iV_i$ and $V_i\leftarrow V_i+\eta\, G_i^\top U_i$, which costs only small matrix products.

Fixed-rank factors can drift into a stale subspace. Every few visits we therefore apply a rank-adaptive correction modeled on An Augmented Backward-Corrected Projector Splitting Integrator. That integrator enlarges the current basis with new directions and truncates by an SVD tolerance, which guarantees that the previous iterate stays reachable. In our version the new directions are the top singular vectors of $G_i$, found with one randomized power iteration, and the result is truncated back to rank $r$. The original integrator was only ever used for minimization of network weights. Here it drives an ascent variable inside a min-max game, and we will check empirically whether the "previous iterate remains reachable" property keeps the adversary from regressing between epochs.

Because whole epochs pass between visits, the stored perturbation is also stale with respect to the current weights. To handle this, each visit can optionally add a fresh full-rank single-step sign correction within the leftover budget. This correction is computed from the same backward pass and is not stored.

The analysis has three parts. First, we measure how much per-visit gain of the persistent adversary survives one epoch of weight updates, compared with a freshly computed PGD perturbation. Second, we track the gradient-alignment diagnostic from Understanding and Improving Fast Adversarial Training, which drops from about 0.95 to 0.05 at collapse, and the input-gradient norm spike reported in Understanding Catastrophic Overfitting in Single-step Adversarial Training, to see whether persistence prevents either. Third, we probe for blind spots by attacking each trained model with LoRa-PGD at many ranks and with full-rank AutoAttack.

Baselines

The naive reference points are ordinary training and FGSM with random initialization from Fast is better than free. The latter reports 45% PGD robust accuracy on CIFAR-10 in 6 minutes and 43% on ImageNet in 12 hours, but it collapses at $\epsilon=16/255$. Multi-step PGD training serves as the robustness ceiling and the cost reference. Free training is the closest relative in spirit because it also warm-starts perturbations. It reports about 46% against PGD-20 on CIFAR-10 in about 13 hours and 40% on ImageNet ResNet-50 in 2 days on 4 GPUs.

At large radius, the strongest competitor that avoids double backpropagation is RAT, from Rethinking Fast Adversarial Training. RAT applies Douglas-Rachford splitting to single-step training and reports 19.58% AutoAttack accuracy at $\epsilon=16/255$ on CIFAR-10 in 1.7 hours, against 6.3 hours for PGD training. At the standard radius, the strongest competitor is ELLE-A from Efficient local linearity regularization to overcome catastrophic overfitting. It reports 44.32% AutoAttack accuracy on CIFAR-10 but needs three extra forward passes per sample. GradAlign is included as a costly but reliable reference. FLC pooling, from FrequencyLowCut Pooling, is included as a cheap architectural fix; it reports 38.41% PGD accuracy with FGSM at a 1.26× overhead.

Every method uses the same backbone (PreActResNet-18 on CIFAR-10, ResNet-50 on ImageNet), the same epoch budget, and the same hardware. Each gets an equal hyperparameter sweep, which covers RAT's $\lambda$, ELLE's strength, and our step size and rank. All are evaluated with AutoAttack through RobustBench.

Beating RAT means exceeding 19.58% AutoAttack accuracy at $16/255$ in no more wall-clock time than RAT under our rerun. Beating ELLE-A means matching its accuracy at $8/255$ with fewer forward passes.

Two ablations isolate the key ingredient. The first is non-persistent LoRa-PGD in the loop, which is the obvious version of the gap: a low-rank attack re-initialized at every visit. The second is persistent full-rank storage. A third, secondary ablation removes the fresh full-rank correction.

Why not just…?

Why not just store full-rank perturbations persistently? On CIFAR-10 this is genuinely feasible: 50k × 3072 values is about 600 MB. It is the most serious threat to the proposal. If full-rank persistence matches or beats low-rank persistence there, then low rank contributes nothing except memory. The method's value would then rest entirely on ImageNet-scale feasibility, which we test against a disk-streamed full-rank buffer by measuring throughput. We report this comparison first and frame the contribution according to its outcome. A better result for low rank would suggest that the rank constraint also acts as a useful regularizer, which would fit the link between catastrophic overfitting and high-frequency aliasing reported by FLC pooling.

Why not just raise the replay count in Free training? Free training already warm-starts perturbations, but only across consecutive replays of one minibatch. Its authors document that a high replay count reduces sample diversity and lowers clean accuracy. Our persistence works across epochs with no replay, so the data stream is unchanged. Comparing clean accuracy at matched robustness settles whether this matters in practice.

Why not just use RAT or ELLE-A, which already fix catastrophic overfitting cheaply? If either matches our robustness at equal cost, the stabilization claim fails. Even then, the cost claim could survive, because those methods still use a fresh single-step adversary that is weaker than an accumulated one at $8/255$. The head-to-head comparisons at both radii decide this.

Why not just plug LoRa-PGD into the training loop? Its per-step speed matches PGD's, so a $K$-step low-rank inner loop costs as much as $K$-step PGD. The non-persistent ablation measures this directly.

Proposed Experiments

On CIFAR-10 at $\epsilon=8/255$ and $16/255$ we train every baseline and our method, varying the rank $r\in\{2,4,8,16\}$. We report clean accuracy, AutoAttack accuracy, wall-clock time, and peak memory, and we plot gradient alignment over training. On ImageNet with ResNet-50 at the Fast/Free settings, we compare against Fast and Free training at matched GPU-hours and report the size of the adversary buffer.

Three results decide the project. First, at $16/255$ our method must avoid collapse and exceed RAT's 19.58% AutoAttack accuracy within RAT's time budget. Second, AutoAttack accuracy must stay within a few points of accuracy against the strongest low-rank attack. A large gap would show that the low-rank training adversary left full-rank blind spots, or that the model learned to mask its gradients. Third, the persistent low-rank adversary must beat non-persistent LoRa-PGD at equal compute; if it does not, persistence, the central idea, is not doing the work.