Course contentsShow
← Machine Learning and Deep Learning
Lesson 3404 of 3,53874. Adversarial RobustnessFree lesson

PGD Adversarial Training Implementation

Implementing adversarial training with PGD attacks: inner maximization and outer minimization loops in PyTorch.

PGD Adversarial Training Implementation

What you'll learn: How to implement adversarial training using PGD attacks through nested optimization loops in PyTorch.

The Core Idea

PGD adversarial training makes your model robust by training it on the hardest examples you can generate. It's a min-max game: the inner loop (maximization) creates the worst-case adversarial perturbations using PGD, while the outer loop (minimization) trains the model to correctly classify those tough examples.

Think of it like training a boxer: instead of practicing against predictable opponents, you hire the toughest sparring partners who exploit every weakness. Your model learns to defend against deliberate attacks, not just random noise.

Implementation Structure

The implementation has two nested loops:

Inner Loop: Attack Generation (Maximization)

Generate adversarial examples using PGD to maximize loss:

  • Start with clean inputs
  • For K steps, compute gradients with respect to inputs
  • Take steps in the direction that increases loss
  • Project perturbations back within epsilon ball

Outer Loop: Model Update (Minimization)

Standard training to minimize loss on adversarial examples:

  • Generate adversarial batch using inner loop
  • Forward pass on perturbed inputs
  • Compute loss and backpropagate
  • Update model weights
# Conceptual structure (actual PGD from lesson 3390)
for epoch in range(epochs):
    for x_clean, y in train_loader:
        # Inner max: generate adversarial examples
        x_adv = x_clean.clone().detach()
        for _ in range(pgd_steps):
            x_adv.requires_grad = True
            loss = criterion(model(x_adv), y)
            loss.backward()
            x_adv = x_adv + alpha * x_adv.grad.sign()
            x_adv = torch.clamp(x_adv, x_clean - epsilon, x_clean + epsilon)
        
        # Outer min: train on adversarial examples
        optimizer.zero_grad()
        outputs = model(x_adv)
        loss = criterion(outputs, y)
        loss.backward()
        optimizer.step()

Key Takeaway: PGD adversarial training implements robust learning through nested optimization—inner maximization generates strong attacks, outer minimization hardens the model against them.