Clean-Accuracy-Budgeted Augmentation Search for Adversarial Training

Adversarial training teaches an image classifier to resist small, worst-case pixel perturbations. The usual price is lower accuracy on ordinary, unperturbed ("clean") images. Data augmentation, meaning random transformations of training images such as rotations, color shifts, or cutouts, can help or hurt this trade-off depending on which transformations are used, how strong they are, and when during training they are applied. Methods that search for augmentation policies automatically have so far optimized either clean accuracy alone or robustness with a fixed-weight penalty that keeps augmented images "close" to clean ones. None of them lets a practitioner say "give me the most robust model whose clean accuracy stays at least 86%" and have the augmentation policy enforce that.

We propose to state the trade-off as a constraint. An augmentation policy is trained online alongside the classifier to maximize robustness. A Lagrange multiplier is driven by clean accuracy measured on held-out data, and it pulls the policy toward milder transformations whenever clean accuracy falls below a user-chosen floor. Because the multiplier rises and falls during training, the constraint produces a time-varying augmentation schedule, so the easy-to-hard-to-easy curriculum that earlier work had to hand-design should emerge on its own. The central empirical question is whether this adaptive constraint gives a better clean-versus-robust frontier than sweeping fixed trade-off weights at the same compute. That result could go either way, and we design the experiments to settle it.

Core Claim

The closest existing method is AROID. It trains a small per-image policy network with a policy-gradient estimator (REINFORCE) during adversarial training. Its objective combines three terms: a vulnerability term that seeks transformations whose adversarial loss is high, an affinity term that penalizes distribution shift away from clean data, and a diversity term. It reaches 55.91% AutoAttack robust accuracy on CIFAR-10 and nearly removes robust overfitting. However, the affinity term is a training-set proxy with a fixed weight, and the paper does not trace how clean accuracy degrades.

Our claim is narrower and testable. We replace the fixed affinity weight with a held-out clean-accuracy constraint enforced by an adaptive multiplier. Two things should follow. First, at every clean-accuracy level, the resulting models should have robust accuracy at least as high as the best fixed-weight model with the same compute. Second, the gain should come from the time-varying strength of augmentation that the multiplier induces.

The second prediction is motivated by Challenges of Adversarial Image Augmentations. That paper shows that always choosing the hardest augmentation ("TrueAdv") selects extreme magnitudes 77% of the time and lowers CIFAR-10 accuracy by 1.1%. Adversarial AutoAugment worked only because noise in its controller made it act like a mild curriculum. A hand-set cyclic schedule was the only schedule competitive with random augmentation. That study measured clean accuracy only. We ask whether a constraint can discover such a schedule automatically and whether the schedule holds up under formal attacks.

Research Program

Let $f_w$ be the classifier with weights $w$, and let $\pi_\theta$ be the per-image augmentation policy with parameters $\theta$. The policy outputs a transformation type and magnitude from the standard discrete operation set. For the robust loss we use the TRADES decomposition, which splits robust error into natural error plus boundary error; boundary error is the chance that an input sits within the perturbation radius of the decision boundary. The policy is trained to solve

$$\max_\theta \; \mathbb{E}_{x \sim \pi_\theta}\big[\mathrm{KL}\big(f_w(x)\,\|\,f_w(x^{adv})\big)\big] \quad \text{s.t.} \quad \mathrm{Acc}_{val}(f_w) \ge \tau .$$

Here $x^{adv}$ is the PGD adversarial example of the augmented image $x$, $\mathrm{KL}$ is the TRADES boundary term, and $\tau$ is the user's clean-accuracy floor measured on a held-out split of clean images. The policy's per-image reward is its boundary term minus $\mu$ times that image's clean cross-entropy increase relative to the unaugmented image. The multiplier $\mu \ge 0$ is updated every $k$ steps as

$$\mu \leftarrow \max\big(0,\; \mu + \eta\,(\tau - \mathrm{Acc}_{val})\big),$$

where $\eta$ is a step size and $\mathrm{Acc}_{val}$ is a running estimate of held-out clean accuracy. The classifier itself trains with the ordinary TRADES loss on augmented images. We reuse AROID's policy architecture, REINFORCE estimator, and diversity term from its official code (TreeLLi/AROID), so the only change is the constraint.

We will build this, run it for a grid of floors $\tau$, and record the multiplier trajectory and the magnitude distribution the policy selects over training. That record lets us check directly whether the learned schedule resembles the easy-hard-easy shape found by hand in earlier work.

Baselines

The naive reference point is TRADES with standard crop-and-flip augmentation, swept over its trade-off weight $\lambda$. TRADES itself reports 88.64% natural accuracy at one setting and 56.61% robust accuracy under PGD on CIFAR-10 at another, which shows that $\lambda$ moves a model along a frontier. Every other method must beat this frontier, not a single point on it.

The strongest automated competitor is AROID, run from its official code, with its affinity weight swept to produce a frontier. This sweep doubles as the key ablation. The only difference between this sweep and our method is fixed weight versus adaptive, validation-driven multiplier. The reported number is 55.91% AutoAttack robust accuracy on CIFAR-10 (AROID). The file gives no clean accuracy for that setting, so we will measure it ourselves.

The strongest fixed-policy competitor is DAJAT (Efficient and Effective Augmentation Strategy for Adversarial Training). It trains on simple and AutoAugment views of each image jointly, with separate batch-normalization statistics for each and a consistency loss between them. It reports about 86.67% clean and 51.56% AutoAttack accuracy on CIFAR-10.

We also include static CutMix with weight averaging from Data Augmentation Can Improve Robustness, which reports 60.07% AutoAttack accuracy on CIFAR-10 without extra data. We will re-run it at our own architecture and training budget rather than quoting that figure, because the architectures differ.

A second ablation separates the schedule from the per-image policy. We record the magnitude schedule learned by our method and replay it as a global, image-independent schedule with no controller.

For fairness, all methods use the same architecture (ResNet-18 for the sweeps and WideResNet-34-10 for headline points), the same epochs, 10-step PGD at $\ell_\infty$ radius $8/255$, and the same number of training runs per frontier. Tuning of $\eta$ and $k$ is done on CIFAR-10 only and then frozen. Our method counts as better if, at matched clean accuracy (within 0.3 points), its AutoAttack accuracy exceeds the best baseline point by more than the seed-to-seed spread across three seeds, on at least two of the three datasets.

Why not just…?

Why not just tune TRADES' $\lambda$? Tuning $\lambda$ moves a model along the frontier that a fixed data distribution permits. It does not show whether augmentation can push that frontier outward. Topology-preserving Adversarial Training recovers up to 8.78 points of natural accuracy on CIFAR-100 on top of TRADES, which suggests the TRADES frontier is not tight. The $\lambda$ sweep is our reference frontier, so this alternative is tested directly.

Why not just sweep AROID's affinity weight? This is the real threat. If a sweep of fixed weights traces the same frontier as our adaptive multiplier, then the constraint only offers a convenient way to specify the target, not a better method. We treat that outcome as the main negative result and report it as such. The adaptive multiplier should win only if time-varying strength matters under attack, as it did for clean accuracy in Challenges of Adversarial Image Augmentations.

Why not just train on heavy augmentation and then switch it off at the end? Data Augmentation Revisited shows that a fixed final phase of light augmentation restores clean accuracy, raising CIFAR-100 accuracy from 78.95% to 80.85%. It never measured adversarial robustness. We run this two-stage schedule under TRADES, along with the hand-set cyclic schedule from Blaas et al., and our schedule-replay ablation isolates exactly this question. If a hand-set two-stage schedule matches our method, our contribution reduces to a method for finding when to make the switch.

Why not just use static CutMix with weight averaging? Its robust accuracy is strong, but its policy is fixed. Rebuffi et al. note that CutMix degrades on SVHN, where cutting and pasting patches destroys digits. Including SVHN tests whether a search that adapts to the dataset avoids that failure without manual redesign.

Proposed Experiments

We train on CIFAR-10, CIFAR-100, SVHN, and Tiny ImageNet under $\ell_\infty$ radius $8/255$, and additionally at radii $4/255$ and $12/255$ on CIFAR-10 to see how the frontier shifts with threat strength. Robustness is evaluated only with AutoAttack under the RobustBench protocol, which guards against gradient masking. Our method involves no test-time randomness.

For each method we plot clean accuracy against AutoAttack accuracy and report two quantities: the frontier's hypervolume, and robust accuracy at matched clean accuracy for five floors $\tau$ between the TRADES extremes. We also report CIFAR-10-C mean corruption error. A Fourier Perspective on Model Robustness shows that adversarial training biases models toward low frequencies and hurts robustness to fog and contrast, so we check whether constrained augmentation reduces that cost.

The decisive check is the adaptive-versus-fixed comparison against the AROID affinity sweep at equal runs and compute. The second check is whether replaying the learned global schedule recovers most of the gain. The third is whether the learned magnitude trajectory shows the easy-hard-easy shape, rather than a monotone ramp or the extreme-magnitude collapse seen with TrueAdv.