Auditing the Cheap Adversary: Triggered Compute for Fast Adversarial Training

Adversarial training makes a classifier robust by training it on deliberately perturbed inputs. Each update first searches for a small perturbation of the input that most increases the loss, then trains on it. Done carefully, with 7 to 40 gradient steps of search per batch, this multiplies training cost several times over. Done cheaply, with a single gradient step, it fails silently. Partway through training the model learns to beat the one-step search while becoming almost completely vulnerable to stronger attacks. The training loss keeps falling, nothing crashes, and robust accuracy drops to near zero within a few epochs. In software-engineering terms this failure, called catastrophic overfitting, is a non-crashing defect: the inner search component has stopped doing its job, and every downstream signal still looks healthy.

This proposal treats the cheap one-step adversary as a component that can fail, and audits it the way a software tester would. On a small random slice of each batch we run inexpensive checks of whether the one-step perturbation is still close to the worst case. Extra search steps are spent only when those checks fail. The bet is that robust training needs expensive search only intermittently, and that a well-chosen audit can find when. If that holds, training should match multi-step robustness at close to single-step cost, with overhead that tracks how often the cheap adversary actually breaks.

Core Claim

The claim is that a cheap online audit can serve as a reliable, early warning that the inner attack is failing. Triggering multi-step search only on audit failure should then beat spending the same extra compute uniformly or at random. The second half is what makes the proposal more than a monitor. If random escalation at matched budget works just as well, the audit carries no information and the idea fails.

Two signals form the audit, each grounded in a documented precursor of collapse. The first is a one-extra-step gain. On an audit subsample of $m$ examples, we take one more projected gradient step from the one-step perturbation $\delta_1$ to obtain $\delta_2$, and measure

$$r = \frac{\mathcal{L}(x+\delta_2) - \mathcal{L}(x+\delta_1)}{\mathcal{L}(x+\delta_1)},$$

where $\mathcal{L}$ is the training loss. When the loss surface is locally linear, a second step adds little and $r$ stays small. When the single-step direction and the multi-step direction diverge, $r$ grows. That divergence is the misalignment that A Training-Dynamics View of Catastrophic Overfitting ties to an explosion in the mixed input-parameter Hessian, a quantity too expensive to monitor directly. The second signal is an interior check. We test whether the half-magnitude perturbation $\delta_1/2$ misclassifies examples that the full perturbation $\delta_1$ does not. This directly probes the "decision boundary distortion" loophole of Understanding Catastrophic Overfitting in Single-step Adversarial Training, in which the model defends at the edge of the allowed perturbation ball but not inside it.

Both checks cost about one extra forward-backward pass on $m$ examples. With $m$ at 5–10% of the batch, the audit adds roughly 0.05–0.1 passes per sample. When either signal exceeds a threshold set relative to its own running median, the trainer switches the next $T$ steps to multi-step search, either for the whole batch or only for flagged examples. It then returns to single-step search once the signals settle.

Relation to Prior Work

Three papers motivate the proposal by showing that catastrophic overfitting has measurable precursors. Yeom and Lee identify the mixed-Hessian explosion. Kim et al. report input-gradient norms spiking by up to 35× before collapse. Rethinking Fast Adversarial Training observes irregular loss jumps beforehand. All three convert their diagnosis into an always-on fix: a weighted regularizer, a three-point magnitude search on every sample, or operator splitting. Each pays its cost on every step and depends on a sensitive weighting coefficient. We instead use the diagnosis as a trigger and pay only when it fires.

Plug-And-Pipeline supplies the closest compute accounting, measured in backpropagations per sample. It amortizes multi-step adversaries over a fixed 10% buffer, which is a uniform schedule. Our matched-budget random-escalation ablation tests exactly whether a uniform schedule is as good as a triggered one.

The software-debugging side constrains the design. DeepDiagnosis monitors eight classical symptoms, such as stalled loss, dead neurons, and exploding gradients, and explicitly leaves hyperparameter issues out of scope. None of its symptoms describe min-max failure. Indicators of Attack Failure diagnoses attack optimization failures offline. These include implementation errors in attack libraries that silently return the last iterate instead of the best one, and its debugging cut the reported robustness of defensive distillation from 95% to 1%. That work never runs inside training. We move a lightweight version of its logic online.

RobustBench constrains how we evaluate. It found that published defenses often overestimated robustness by more than 10% under weak attacks. Any speedup we claim must therefore survive AutoAttack, which combines two parameter-free gradient attacks, a boundary search, and a black-box query attack.

Research Program

The first component is the audit and trigger, built as a drop-in training callback for single-step adversarial training on top of a standard training loop.

The second is a seeded-defect suite for adversarial training loops, which connects this work to the defect-detection literature. We inject known silent bugs into otherwise working training code: a missing projection onto the perturbation ball, a missing clamp to valid pixel range, a sign error in the perturbation step, returning the last rather than the best iterate (as in Pintor et al.), a step size mis-scaled by the perturbation budget, and a perturbation computed with the model in the wrong train/eval mode. For each, we measure whether the audit fires, whether DeepDiagnosis-style classical symptoms fire, and whether a single-step validation accuracy monitor notices. This turns the claim that classical monitors miss these failures, currently an argument in the literature, into a measurement.

The third component is an analysis of when escalation is needed. We record the trigger timeline across perturbation budgets $\epsilon$ and architectures. The aim is to learn whether expensive search is concentrated early, near learning-rate changes, or near collapse, and whether that pattern transfers across datasets.

Baselines

The naive reference point is plain one-step (FGSM) adversarial training with no regularizer. It defines the lowest cost and, at larger $\epsilon$, the collapse we must prevent. Kim et al. report that it falls to 0.1% under 50-step PGD on CIFAR-10. The upper reference is multi-step PGD adversarial training with 10 steps, which defines the target robustness and the cost we aim to undercut. Yeom and Lee report 51.79% PGD-10 robust accuracy for it on CIFAR-10. For 7-step PGD, Kim et al. report 11.1 hours of training against 3.9 hours for their method.

The strongest existing competitor is the mixed-Hessian KL regularizer of Yeom and Lee. It reports 52.46% PGD-10 accuracy on CIFAR-10 while training nearly 3× faster than PGD-10, and 32.59% PGD robustness on ViT-Small where baselines collapse. It is the strongest because it already beats multi-step training on robustness at lower cost. We also run three further competitors. RAT reports 19.58% AutoAttack accuracy at $\epsilon=16/255$ on CIFAR-10, with 1.7 versus 6.3 hours for PGD adversarial training. Kim et al.'s magnitude search reports 33.9% PGD-50 accuracy. PAP reports about 46.3% PGD-20 accuracy at 1.2 backpropagations per sample, against about 48.8% for PGD adversarial training. These numbers come from different attacks and setups, so we rerun every method ourselves.

For fairness, all methods use the same architecture (PreAct ResNet-18 for CIFAR, ViT-Small for the transformer setting), the same epochs and learning-rate schedule, and the same data augmentation. Each method, including ours, gets an equal tuning budget of eight configurations for its main coefficient or threshold. Results are reported over three seeds, with AutoAttack robust accuracy, clean accuracy, measured backpropagations per sample, and wall-clock time on identical hardware.

The ablation that isolates the key ingredient is matched-budget random escalation. It spends exactly the same total extra search steps as our triggered run, but at uniformly random times. We also run a variant that escalates on schedule in proportion to training progress. Beating the strongest baseline means one of two outcomes at $\epsilon \in \{8/255, 16/255\}$. Either we reach equal or better AutoAttack accuracy at fewer backpropagations per sample, or we reach higher AutoAttack accuracy at equal cost. In addition, our method must lose less across the threshold sweep than the KL method loses across its coefficient sweep. Beating random escalation requires a statistically clear AutoAttack gain at identical compute.

Why not just…?

Why not just run multi-step PGD all the time? It is reliable but costs 7–40 backpropagations per sample. Yeom and Lee show that it is not even a robustness ceiling, since their single-step method beats it. It remains our upper reference. If the audit triggers so often that our cost approaches PGD's, the proposal fails, and the trigger-rate measurements will show this directly.

Why not just early-stop or roll back using a periodic multi-step validation check? This is a real threat, since a PGD check on a held-out batch once per epoch is cheap. Its weakness is resolution. Collapse happens within a few epochs, so a per-epoch check detects it after the fact. Rolling back then discards training rather than redirecting it. We include this as a baseline with rollback to the last good checkpoint and an equal tuning budget, and compare both final AutoAttack accuracy and wasted compute. If it matches our method, the honest conclusion is that per-step auditing is unnecessary, and we would report that.

Why not just always use Kim et al.'s magnitude search or Yeom and Lee's regularizer? Both already work, but they pay a fixed overhead on every sample. Both also depend on coefficients whose sensitivity their own authors acknowledge. Our method wins only if intermittent triggering buys the same robustness at less cost or with less sensitivity. The matched-cost comparison and the sweep spread settle this. A plausible honest outcome is that our trigger combined with their regularizer at low weight is best, and we test that combination.

Why not just threshold the input-gradient norm, which Kim et al. found spikes before collapse? It is cheaper still, needing no extra step, and we include it as a trigger variant. Raw norms drift with learning rate and data scale, however, and a large norm does not say whether the one-step attack is actually suboptimal. The one-extra-step gain measures that directly. Lead time and false alarms against the gradient-norm trigger, inside the same escalation scheme, decide which signal earns its place.

Proposed Experiments and Decisive Checks

The main experiments use CIFAR-10 and CIFAR-100 at $\epsilon=8/255$ and $16/255$, where single-step collapse is common, along with Tiny-ImageNet and ViT-Small on CIFAR-10. Because Yeom and Lee report that ViT baselines collapse, the transformer setting is a stress test.

The first decisive check is detection. On unregularized single-step runs that collapse, we measure the lead time in steps between the first audit trigger and the point where PGD accuracy falls below half its peak. On PGD-10 runs that never collapse, we measure the false-alarm rate. On the seeded-defect suite, we measure per-bug detection rate against classical-symptom monitors.

The second is the matched-budget comparison against random escalation. This is the result the proposal stands or falls on.

The third guards against false robustness, the tension RobustBench and Pintor et al. raise against fast-training claims. Every final model is evaluated with full AutoAttack, alongside the Indicators of Attack Failure checks from the official code. Any method whose AutoAttack accuracy falls far below its PGD accuracy, or that trips the unreachable-misclassification indicator, is reported as unreliable, whether it is ours or a baseline.