Curriculum Scheduling for Adversarial Training

132 concepts87 papers

Standard adversarial training is framed as a brutal minimax optimization problem:

$$\min_\theta \mathbb{E}_{(x,y) \sim \mathcal{D}} \left[ \max_{\|\delta\| \le \epsilon} \mathcal{L}(f_\theta(x+\delta), y) \right]$$

The inner loop acts as an adversary, searching for the most destructive perturbation $\delta$ within a budget $\epsilon$, while the outer loop updates the model parameters $\theta$ to minimize this worst-case loss.

While conceptually elegant, forcing a model to face a maximum-strength adversary from the very first epoch creates severe optimization pathologies. Early in training, a model's decision boundaries are highly volatile and unrefined. Exposing it immediately to aggressive perturbations causes the loss landscape to become incredibly jagged, trapping the optimization process in poor local minima, inducing gradient collapse, or causing the model to completely forget how to classify clean, unperturbed data.

Curriculum scheduling resolves this tension by matching the adversary's strength to the model's evolving capacity. Instead of throwing the network into the deep end, curriculum strategies start with a weak adversary and progressively scale up the difficulty. This allows the model to first capture fundamental data structures and establish a stable feature foundation before learning to make those representations robust.


Scaling the Perturbation Budget

The most intuitive way to implement an adversarial curriculum is to progressively expand the perturbation radius $\epsilon$ over the course of training.

Standard Training:    [ Full Epsilon ] ──────────────────────────────► High Robustness (But Optimization Instability)
Curriculum Training:  [ Epsilon = 0 ] ──► [ Small Epsilon ] ──► [ Full Epsilon ] ──► Stable Convergence & Clean Accuracy

When a model is forced to defend against a large $\epsilon$ from day one, it often resorts to degenerate solutions like gradient masking—creating highly convoluted decision boundaries that hide the loss surface rather than genuinely learning robust features.

To prevent this, Sriramanan et al. (2022) demonstrate that linearly ramping up the adversarial perturbation budget from zero to the target threshold stabilizes the min-max optimization. This gradual expansion acts as a regularizer that prevents catastrophic overfitting, particularly against sparse or highly constrained threat models.

This scheduling approach is critical not just for robustness, but for preserving standard utility. Dong et al. (2023) show that a linear warm-up of the perturbation budget prevents the model from experiencing "catastrophic forgetting" of clean image features during the early stages of training. By slowly tightening the constraints on the attacker, the model smoothly deforms its decision boundaries without collapsing its baseline predictive performance.

This insight is equally vital when adapting existing models to new tasks. Fine-tuning a non-robust pretrained model using a fixed, aggressive adversarial objective often causes the optimization process to stall or reject the downstream task's features. As shown by Ngnawe et al. (2026), transitioning through a multi-phase schedule—starting at zero perturbation to learn task-specific features, followed by a linear ramp-up to the target robustness constraint—ensures successful knowledge transfer and maintains high functional utility even under intense adversarial pressure.


Scaling Attack Optimality and Steps

An adversary's strength is determined not only by the size of its search space ($\epsilon$), but also by how thoroughly it explores that space. Generating a true worst-case perturbation requires an iterative optimization process (such as Projected Gradient Descent), and the number of steps or the convergence precision of this inner optimization dictates the "hardness" of the resulting adversarial example.

Wang et al. (2019) analyze this phenomenon using the First-Order Stationary Condition (FOSC) to quantify the optimality of an attack during training. They discover a fundamental learning interference: training on highly converged, perfectly optimized adversarial examples during the initial stages of learning actively impedes a model's ability to capture underlying data structures. By utilizing a phased approach that starts with weak, poorly converged attacks and gradually increases their optimality, the model avoids early representation collapse and achieves superior final robustness.

This concept also unlocks massive computational efficiencies when scaling up models. Standard multi-step adversarial training is notoriously expensive because every training step requires multiple gradient computations to generate the attack. Wang et al. (2024) leverage a weak-to-strong attack schedule to scale adversarial training to foundation-model proportions. By employing computationally cheap, single-step adversarial perturbations during early training phases and upgrading to multi-step attacks only during final fine-tuning, they provide a stable "warm start" for the model, drastically reducing total training time while achieving state-of-the-art robustness.


Why It Works: Volatility and Loss Landscapes

The success of curriculum adversarial training can be explained through both the geometry of the loss landscape and statistical learning theory.

In standard training, the adversarial loss landscape is highly non-convex, jagged, and riddled with sharp local minima. Liu et al. (2020) demonstrate that starting training with a minimal adversarial budget and scaling it up using linear or cosine functions prevents the model from becoming trapped in these suboptimal regions early on, when random initialization makes it highly vulnerable. The curriculum effectively smooths out the landscape during the critical initial phases of optimization.

Loss Landscape Geometry:
Standard AT (No Curriculum):   ▲  /\  /\    (Jagged, sharp minima; traps optimization early)
                               └──┴──┴──┴──► 
Curriculum AT (Early Phase):   __/\______   (Smoother landscape; allows stable feature learning)

From a theoretical perspective, Shi (2024) formalizes this easy-to-hard strategy by analyzing the generalization error bounds through the lens of online learning. The optimal perturbation radius is intrinsically linked to model volatility:

$$\epsilon_{\text{optimal}} \propto \frac{1}{\text{Model Volatility}}$$

Early in training, parameter volatility is high. Introducing a large perturbation radius at this stage destabilizes the generalization bound, causing the model to fail to converge. As the model stabilizes and parameter volatility drops, the perturbation radius can be safely expanded to maintain a tight generalization bound.

Complementing this view, Arora et al. (2025) provide a mathematical proof showing that gradually increasing attack intensity acts as a biased regularizer. This progression fundamentally lowers the sample complexity—the amount of data required—for the model to successfully generalize on highly complex, robust target tasks.


Staggered and Intermittent Scheduling

Curriculum scheduling does not always require a smooth, monotonic increase in difficulty. In some scenarios, the optimal path involves alternating or delaying adversarial pressure to balance competing objectives.

During fine-tuning, constant adversarial pressure can overwrite the rich, general-purpose features acquired during large-scale pre-training. To combat this, Jia et al. (2022) introduce a staggered training schedule. Instead of applying perturbations to every single batch, they inject adversarial examples only at periodic intervals:

Batch:      1       2       3       4       5       6
Standard: [ Adv ] [ Adv ] [ Adv ] [ Adv ] [ Adv ] [ Adv ]  --> Overwrites Pre-trained Features
Staggered:[Clean] [Clean] [ Adv ] [Clean] [Clean] [ Adv ]  --> Preserves Task-Specific Accuracy

This intermittent schedule prevents the optimization process from completely erasing task-specific features, demonstrating that lower-frequency adversarial updates can achieve a superior trade-off between predictive accuracy and general robustness. By treating adversarial difficulty as a dynamic variable—whether through budget size, optimization depth, or temporal frequency—curriculum scheduling transforms adversarial training from a chaotic optimization hazard into a stable, scalable learning process.

History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_curriculum_based_adversarial_training_1eee0c01,
  title = {curriculum-based adversarial training},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/curriculum-based-adversarial-training/rdr_1eee0c01333a4d3a9009bc24bcb6f9b0},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_curriculum_based_adversarial_training_1eee0c01_v1,
  title = {curriculum-based adversarial training},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/curriculum-based-adversarial-training/rdr_1eee0c01333a4d3a9009bc24bcb6f9b0/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}

See something wrong? Report a mistake