FGSM y perturbaciones acotadas
Tema: Adversarial y Robustez · Catálogo de recetas · temario: Syllabus IOAI
📍 Dónde se aprende: módulo 21 de la Ruta de Aprendizaje.
Qué hace
Genera perturbaciones adversariales —de un paso (FGSM) o iteradas (PGD)— acotadas a un presupuesto de norma.
Cuándo usarla
En las tareas donde hay que engañar a un modelo. Double Agent Dilemma (2026) pedía exactamente esto: perturbar cada imagen para que un ResNet y un ViT discreparan.
Implementación
Necesita: torch.
import torch
import torch.nn as nn
def fgsm(modelo, x, y, epsilon):
"""Ataque de un paso: mueve la entrada en la dirección que sube la pérdida.
El gradiente se toma respecto de **la entrada**, no de los pesos: el modelo
queda intacto y lo que cambia es la imagen. `epsilon` acota cuánto se mueve
cada píxel (norma infinito).
"""
modelo.eval()
x = x.clone().detach().requires_grad_(True)
perdida = nn.functional.cross_entropy(modelo(x), y)
grad, = torch.autograd.grad(perdida, x)
return (x + epsilon * grad.sign()).detach()
def pgd(modelo, x, y, epsilon, pasos=10, rango=(0.0, 1.0)):
"""FGSM iterado con proyección: más fuerte, y cuesta `pasos` veces más.
En cada paso se avanza un poco en la dirección del signo del gradiente y se
**proyecta** de vuelta al presupuesto de norma. El `clamp` al rango mantiene
la imagen válida: sin él se fabrica algo que el preprocesamiento del juez va
a recortar de todas formas, y el ataque no es el que creías.
"""
modelo.eval()
alfa = epsilon / pasos * 2.5 # paso algo mayor que ε/pasos
delta = torch.zeros_like(x)
for _ in range(pasos):
d = delta.clone().detach().requires_grad_(True)
perdida = nn.functional.cross_entropy(modelo(x + d), y)
grad, = torch.autograd.grad(perdida, d)
delta = proyectar_norma(d + alfa * grad.sign(), epsilon, norma="inf")
delta = (x + delta).clamp(*rango) - x
return (x + delta).detach()
def proyectar_norma(delta, epsilon, norma="inf"):
"""Recorta una perturbación para que respete su presupuesto de norma.
Casi todas las tareas adversariales puntúan mejor las perturbaciones
pequeñas: en Double Agent Dilemma (2026) el puntaje se multiplica por un
factor que penaliza la norma. Atacar sin acotar es regalar puntos.
"""
if norma == "inf":
return delta.clamp(-epsilon, epsilon)
plano = delta.flatten(1)
n = plano.norm(dim=1, keepdim=True).clamp_min(1e-12)
factor = (epsilon / n).clamp(max=1.0)
return (plano * factor).view_as(delta)⚠️ Notas
El gradiente se toma respecto de la entrada, no de los pesos: por eso x.requires_grad_(True) y no un optimizador. El modelo no se toca.
Casi todas las tareas adversariales penalizan la norma de la perturbación: atacar sin acotarla es regalar puntos. Y ojo con el orden de las transformaciones — en Double Agent Dilemma la perturbación se sumaba a la imagen cruda, en su resolución original, antes del pipeline de preprocesamiento.
🔗 Relacionadas
Verificada
Este código se ejecuta en cada publicación, contra una referencia obviamente correcta, en
herramientas/pruebas/redes.py. Si se rompe, el sitio no se actualiza.
Las otras puertas del vault: Ruta de Aprendizaje · Referencia · IOAI