GAN: el falsificador y el detective

El juego en una fórmula

El generador $G$ recibe ruido $z \sim p_z$ (en la lección, la campana estándar) y produce $G(z)$. El discriminador $D$ devuelve $D(x) \in (0, 1)$, la probabilidad que asigna a que $x$ venga de los datos. Goodfellow et al. (2014) plantean un juego de dos jugadores de tipo minimax:

$D$ sube $V$ diciendo «1» a los reales y «0» a los falsos (es la entropía cruzada de un clasificador binario, con signo cambiado); $G$ la baja haciendo que $D(G(z))$ se acerque a 1. Lo que gana uno lo pierde el otro: es un juego de suma cero.

El mejor detective posible y el empate

Con $G$ fijo, el discriminador óptimo es

donde $p_g$ es la distribución de los falsos. Si en una zona hay dos falsos por cada real, lo mejor que puede responder ahí es $1/3$. Es lo que se mide en la partida que colapsa: en la montaña izquierda (todos los falsos y la mitad de los reales) el detective responde entre 0.32 y 0.35; en la derecha, donde no hay falsos, 1.00. El artículo demuestra que el juego tiene su óptimo global en $p_g = p_{\text{datos}}$, con $D = \tfrac12$ en todas partes. Ahí la pérdida del detective vale $2\ln 2 \approx 1.386$ y la del generador (versión no saturante, abajo) $\ln 2 \approx 0.693$; en los últimos doscientos pasos de la partida sana de la lección promedian 1.384 y 0.702.

El truco no saturante y los $k$ pasos

Al principio, $D$ rechaza los falsos con mucha seguridad y $\log(1 - D(G(z)))$ se satura: casi no da gradiente. Por eso el mismo artículo propone que $G$ maximice $\log D(G(z))$, que tiene el mismo punto fijo y gradientes más fuertes al inicio. Es lo que usa la lección. El gradiente que corrige a $G$ pasa por $D$ (retropropagación a través de las dos redes, lección 8): para cada falso, $\partial \log D / \partial x$ dice hacia dónde moverlo. Las flechas de la escena son esa derivada, calculada con la curva real del detective.

El Algoritmo 1 alterna $k$ pasos de $D$ con uno de $G$; los autores usaron $k = 1$. En la lección, $k$ es el único hiperparámetro que cambia: con $k = 1$, las 20 semillas cubren las dos montañas; con $k = 5$, 15 las cubren, 4 colapsan (una montaña recibe menos de 5 % de los falsos) y una queda a medias (48 % y 6 %). El artículo advierte del desequilibrio contrario, entrenar demasiado a $G$ sin actualizar a $D$, que llama «el escenario Helvetica»: $G$ manda demasiados valores de $z$ al mismo $x$. En los dos sentidos, el equilibrio entre los jugadores importa.

La GAN de la lección

• Datos: mezcla 50/50 de $\mathcal N(-1.5,\ 0.4^2)$ y $\mathcal N(1.5,\ 0.4^2)$. Los 800 reales de la escena son cuantiles de cada campana, y los 800 sorteos del generador, cuantiles de $\mathcal N(0, 1)$: así cada histograma es reproducible.
• Redes: $G$ y $D$ son iguales, $1 \to 10\ \tanh \to 10\ \tanh \to 1$ (141 parámetros cada una). Adam con tasa $5 \times 10^{-4}$ y $\beta_1 = 0.5$, lotes de 256, 2000 pasos del generador. Los pesos se exportaron cuantizados a 16 bits y el navegador ejecuta las redes (solo la pasada hacia delante); los scripts train_gan.py y train_detective.py están en la carpeta de la lección.
• El detective solo: para presentarlo aparte, se entrenó el detective inicial de la partida sana durante 1000 pasos contra el falsificador inicial congelado (todo cerca de 0). Responde 0.95 a 1.6 y 0.05 a 0.07.
• «Cerca de una montaña»: a menos de 0.8 de su centro. Los reales: 47.75 % en cada una. Los falsos al final de la partida sana: 46.4 % y 48.1 %.
• Lo que no salió perfecto: las montañas falsas son más angostas (la más alta junta 337 de 800 falsos en un tramo de 0.25; la real, 98), y queda un puente de falsos en el valle. El puente es inevitable con este diseño: $G$ es una función continua de un solo número, así que los $z$ cercanos a 0 caen entre las dos montañas. Ahí $D(0) \approx 0.30$. El detective, pequeño y entrenado al mismo ritmo, no detecta lo angosto.

En código

import torch, torch.nn as nn
torch.manual_seed(0)

def red():   # 1 → 10 → 10 → 1, con tanh: 141 parámetros
    return nn.Sequential(nn.Linear(1, 10), nn.Tanh(), nn.Linear(10, 10), nn.Tanh(), nn.Linear(10, 1))

def reales(n):   # mezcla 50/50 de N(−1.5, 0.4²) y N(+1.5, 0.4²)
    signo = torch.randint(0, 2, (n, 1)) * 2 - 1
    return 1.5 * signo + 0.4 * torch.randn(n, 1)

G, D = red(), red()               # falsificador y detective
opt_G = torch.optim.Adam(G.parameters(), lr=5e-4, betas=(0.5, 0.999))
opt_D = torch.optim.Adam(D.parameters(), lr=5e-4, betas=(0.5, 0.999))
bce = nn.BCEWithLogitsLoss()      # aplica la sigmoide y calcula −log
uno, cero = torch.ones(256, 1), torch.zeros(256, 1)

for paso in range(2000):
    # turno del detective: a los reales debe decir 1; a los falsos, 0
    falsos = G(torch.randn(256, 1)).detach()
    perdida_D = bce(D(reales(256)), uno) + bce(D(falsos), cero)
    opt_D.zero_grad(); perdida_D.backward(); opt_D.step()
    # turno del falsificador: que el detective diga «real» a sus falsos
    perdida_G = bce(D(G(torch.randn(256, 1))), uno)
    opt_G.zero_grad(); perdida_G.backward(); opt_G.step()

with torch.no_grad():
    x = G(torch.randn(10000, 1))
    izq = ((x + 1.5).abs() < 0.8).float().mean().item()
    der = ((x - 1.5).abs() < 0.8).float().mean().item()
    print(f'falsos cerca de cada montaña: {izq:.2f} y {der:.2f}')
    dr, df = torch.sigmoid(D(reales(10000))).mean().item(), torch.sigmoid(D(x)).mean().item()
    print(f'detective, en promedio: reales {dr:.2f}, falsos {df:.2f}')
# falsos cerca de cada montaña: 0.47 y 0.48
# detective, en promedio: reales 0.50, falsos 0.50

(PyTorch 2.11 en CPU; otra versión puede dar cifras algo distintas.)

Lo que viene

Las GAN dominaron la generación de imágenes de alta calidad hasta que Dhariwal y Nichol (2021) mostraron que los modelos de difusión las superaban. Ellos mismos señalan que las GAN capturan menos variedad y son difíciles de entrenar, «colapsando sin hiperparámetros y regularizadores cuidadosamente elegidos», mientras que la difusión ofrece cobertura de la distribución, un objetivo de entrenamiento estacionario (no depende de un rival que cambia) y facilidad para escalar; su desventaja es que genera más lento, en muchos pasos de quitar ruido. Eso es la lección 17.