Adversarial training derives updates from surrogate losses, but source-loss descent does not directly characterize an update's effect on adversarial margins. We introduce ExGrad (extrapolative gradient recomposition), which constructs clean-input, adversarial-input, and adversarial-weight-perturbed (AWP) gradients. Virtual steps measure their margin responses, and a globally solvable three-variable problem selects coefficients over a bounded affine domain without nonnegativity constraints. Across affine radii on CIFAR-10, negative clean coefficients rapidly predominate and increase in magnitude with the radius. Cross-zero interventions show that setting the clean coefficient to zero is insufficient: mild subtraction improves PGD-20, while stronger subtraction trades clean accuracy for further PGD-20 gains. In CIFAR-10 WRN-28-4 controls, none of the three candidate-removal variants matches full ExGrad. Projection diagnostics show that negative clean coefficients usually coexist with positive net clean-axis projections, although both decrease as the radius grows. Norm-matched controls indicate that update magnitude alone does not explain the moderate-radius gains. Experiments on CIFAR-10, CIFAR-100, and ImageNet-100 show radius-dependent improvements over AWP. On CIFAR-100, ExGrad at R=0.8 improves all five reported metrics, including clean and AutoAttack accuracy by 3.84 and 1.75 percentage points. On ImageNet-100, the same radius improves all four robust metrics over both AWP and PGD-AT. These results identify clean-gradient subtraction as a response-revealed update preference whose strength and clean-robust operating point are controlled by the affine radius.
Figures & tables
Figure 1: Overview of ExGrad. (a) A mini-batch update in which three state-dependent gradients are probed from the same nominal parameters; their margin responses determine one affine recomposition, and only the recomposed gradient advances the optimizer. (b) The bounded unit-sum domain intersects the nonnegative simplex and extends beyond it to permit response-supported subtraction.
Dataset
Model
Method
Clean
PGD
APGD-CE
APGD-T
AA
CIFAR-10
WRN-28-4
PGD-AT
83.00 ± 0.47
53.41 ± 0.28
52.69 ± 0.27
49.15 ± 0.21
49.12 ± 0.21
TRADES ( β=3 )
84.94 ± 1.84
50.23 ± 0.39
49.40 ± 0.41
47.50 ± 0.33
47.51 ± 0.33
TRADES ( β=6 )
84.21 ± 0.67
52.33 ± 0.38
51.65 ± 0.39
49.54 ± 0.08
49.53 ± 0.05
TRADES ( β=9 )
82.40 ± 0.30
53.12 ± 0.23
52.38 ± 0.19
49.89 ± 0.15
49.88 ± 0.16
AWP
82.62 ± 0.34
56.48 ± 0.22
55.80 ± 0.27
51.09 ± 0.09
51.07 ± 0.11
ExGrad ( R=0.8 )
83.75 ± 0.21
56.51 ± 0.17
55.57 ± 0.19
51.25 ± 0.31
51.25 ± 0.30
Table 1: Clean and robust test accuracy (%). Best and second-best results within each dataset–model block are boldfaced and underlined, respectively.
Figure 2: Test-accuracy trajectories on CIFAR-10 with WRN-28-4. The upper and lower panels report PGD-20 and clean accuracy, respectively; ExGrad uses R=1.0 . All trajectories use a three-epoch moving average.
Figure 3: Clean-coordinate and clean-axis projection dynamics on CIFAR-10 with WRN-28-4. Rows correspond to R=0.8 , 1.0 , and 1.2 ; the left and right columns show βclean and pclean , respectively. Solid curves are within-epoch mini-batch means; shaded regions span the mini-batch minima and maxima.
βclean
βadv
βawp
Clean
PGD
Adap.
Adap.
0
83.38 ± 0.39
53.37 ± 0.38
Adap.
0
Adap.
82.75 ± 0.37
56.39 ± 0.16
0.1
Adap.
Adap.
84.91 ± 0.49
55.53 ± 0.23
0
Adap.
Adap.
83.27 ± 0.33
56.44 ± 0.10
−0.1
Adap.
Adap.
81.81 ± 0.14
57.12 ± 0.14
−0.2
Adap.
Adap.
81.17 ± 0.15
57.40 ± 0.04
Table 2: Ablations on CIFAR-10 with WRN-28-4. All settings use R=1 . “Adap.” denotes an adaptive coefficient. The fixed triplet averages the coefficients at the best-PGD checkpoint of each seed and is rounded to three decimals.
R
Match
Clean
PGD
Norm
0.8
No
83.75 ± 0.21
56.51 ± 0.17
0.943
0.8
Yes
83.81 ± 0.29
56.58 ± 0.26
1.000
1.0
No
81.19 ± 0.23
58.95 ± 0.09
1.083
1.0
Yes
81.13 ± 0.26
58.65 ± 0.27
1.000
1.2
No
79.77 ± 0.08
59.23 ± 0.27
1.217
1.2
Yes
79.92 ± 0.46
58.86 ± 0.12
1.000
Table 3: AWP-norm-matched control on CIFAR-10 with WRN-28-4. Norm is the applied update-to-AWP norm ratio and is unity by construction after matching.
Method
Time/epoch
Rel.
Alloc.
Reserv.
(s)
time
(MiB)
(MiB)
PGD-AT
44.20
0.84×
1096.90
1248
AWP
52.45
1.00×
1149.26
1258
ExGrad
76.09
1.45×
1173.50
1302
Table 4: Diagnostic-free training cost measured in separate processes on one H100 80GB (CIFAR-10/WRN-28-4, batch 128, FP32). Time averages synchronized epochs 2–5 after warm-up; memory reports PyTorch peaks.
Adversarial training remains one of the most effective defenses against adversarial attacks, but its standard PGD-based training is computationally expensive because adversarial examples are generated for every training sample. Selective adversarial training reduces this cost by perturbing only a subset of samples. However, existing selective techniques typically rely on point-wise difficulty signals such as loss, entropy, margin, or gradients. We show that these point-wise criteria do not capture local instability in a sample's neighborhood. Motivated by this, we propose Augmentation-Guided Adversarial Training (AGAT), a selective adversarial training framework that uses augmentation-induced local variation to allocate samples with unstable neighborhoods for adversarial training. AGAT ranks samples using Augmentation-based Local Stability (ALS), a lightweight score that measures the normalized change in model logits between an input and its label-preserving augmented variant. Experiments across different architectures on MNIST, CIFAR-10, CIFAR-100, and Tiny-ImageNet-200 demonstrate that AGAT achieves comparable or higher robust accuracy while applying adversarial supervision to only 20-30% of the training samples in each minibatch. AGAT also requires less training time than all other adversarial training baselines in the computational cost evaluation.
Daniel Agyei Asante, Mark Tetteh, Deborah Asamoah +2
Ohio University, United States · University of Nebraska Omaha, United States · University of Toronto, Canada +1
Generating adversarial examples at scale is a core primitive for robustness evaluation, adversarial training, and red-teaming, yet even "fast" attacks such as FGSM remain throughput-limited by the cost of a backward pass. We introduce a family of attacks that eliminates the backward pass by predicting the input gradient from forward-pass hidden states via a lightweight linear regression. Theoretically, we derive exact affine conditional gradient means, showing optimality in the (idealized) NTK regime. Empirically, our methods work when applied to practical finite-width models; we recover much of FGSM's attack performance while using only a small fraction of the time, corresponding to a 532% increase in throughput. These results suggest gradient prediction as a simple and general route to significantly faster adversarial generation under realistic wall-clock constraints.
Kamil Ciosek, Aleksandr V. Petrov, Nicolò Felicioni +1
This work concerns adversarial training against the small-norm adversarial examples that arise from the inherent input instability of a trained deep neural network. Examples in this class are small as measured in the relative ℓ2-norm, and therefore lie in the neighborhood of the input on which the model acts approximately linearly, the regime in which the perturbation remains imperceptible. We first show that such examples can be computed directly from the trained network parameters, without input gradient iterations, by means of a linearization called the low-rank Householder expansion (LRHE). The expansion describes the composed affine map rather than any individual layer, and the directions it identifies are read from the activation pattern already available in the forward pass. We then propose a simple adversarial training scheme built on this construction. No differentiation with respect to the input is performed at any point: training requires only additional forward evaluations, with weight parameters updated by the standard backward pass, and the inner maximization of the usual min-max formulation is eliminated entirely. That such a regularizer exists is our main finding: the methods that dispense with the inner search all obtain their local geometry by differentiating with respect to the input, and we show this is not necessary. The regularizer costs the equivalent of 2.8 PGD steps per epoch, an 8.7× reduction relative to 40-step adversarial training on MNIST and below the cost of 3-step training. The resulting models match three-step PGD adversarial training for relative ℓ2 budgets ε≤0.02 and 40-step training for ε≤0.012, falling away beyond, consistent with the locality of the expansion.