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