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.