Generación de Imágenes con Redes Generativas Adversarias (GANs): De la Teoría a la Práctica con PyTorch

Las Redes Generativas Adversarias (GANs, por sus siglas en inglés) han revolucionado el campo del Deep Learning al permitir la creación de datos sintéticos, como imágenes o audio, que son indistinguibles de los datos reales. Desde su introducción por Ian Goodfellow y colaboradores en 2014, las GANs han capturado la imaginación de investigadores y desarrolladores por su capacidad para generar contenido original y altamente realista. En este tutorial, desglosaremos los principios fundamentales de las GANs y te mostraremos cómo construir y entrenar una desde cero usando la biblioteca PyTorch.

💡 ¿Qué son las GANs? Un Duelo Creativo

Imagina un falsificador de arte 🎨 y un detective de arte 🕵️‍♂️. El falsificador intenta crear réplicas tan perfectas que engañen al detective, mientras que el detective se entrena para distinguir las obras auténticas de las falsas. Ambos mejoran con el tiempo: el falsificador se vuelve más hábil creando falsificaciones, y el detective se vuelve más astuto identificándolas.

Esta analogía describe perfectamente el funcionamiento de una GAN. Se compone de dos redes neuronales que compiten entre sí en un juego de suma cero:

1. El Generador (G): La red que actúa como el falsificador. Toma un vector de ruido aleatorio (generalmente una distribución gaussiana) como entrada y lo transforma en una nueva muestra de datos (por ejemplo, una imagen). Su objetivo es generar datos que parezcan reales y engañen al Discriminador.
2. El Discriminador (D): La red que actúa como el detective. Recibe tanto muestras de datos reales (del conjunto de entrenamiento) como muestras generadas por el Generador. Su tarea es clasificar correctamente si una muestra dada es real o falsa (generada).

⚖️ El Equilibrio Adversario

El entrenamiento de una GAN es un proceso de minimax. El Generador intenta minimizar la probabilidad de que el Discriminador clasifique sus salidas como falsas, mientras que el Discriminador intenta maximizar la probabilidad de clasificar correctamente las muestras como reales o falsas.

En un estado ideal de equilibrio, el Generador es tan bueno que el Discriminador no puede hacer la diferencia entre datos reales y generados, resultando en una probabilidad del 50% para ambos tipos de muestras.

🛠️ Arquitectura Básica de una GAN

Aunque existen muchas variantes de GANs, la arquitectura fundamental es bastante consistente. Ambas redes (Generador y Discriminador) suelen ser Redes Neuronales Convolucionales (CNNs) para tareas de visión, debido a su eficacia en el procesamiento de imágenes.

🧬 El Generador

El Generador típicamente utiliza capas convolucionales transpuestas (también conocidas como deconvoluciones) para upsample el vector de ruido de baja dimensión a una imagen de alta resolución. Estas capas invierten el proceso de una convolución estándar, expandiendo la resolución espacial.

🔍 El Discriminador

El Discriminador es una red de clasificación binaria. Utiliza capas convolucionales estándar para downsample la imagen de entrada a una sola probabilidad: la probabilidad de que la imagen sea real. Al final, una capa sigmoide suele producir un valor entre 0 y 1.

🎯 Entendiendo la Función de Pérdida

La función de pérdida es crucial para el entrenamiento de las GANs y es la que impulsa la competencia entre el Generador y el Discriminador.

La función de pérdida total para una GAN se basa en la entropía cruzada binaria. Matemáticamente, el objetivo del Generador y el Discriminador se puede expresar como:

$ \min_G \max_D V(D, G) = \mathbb{E}{x \sim p{data}(x)}[\log D(x)] + \mathbb{E}_{z \sim p_z(z)}[\log(1 - D(G(z)))] $

Donde:

• $D(x)$ es la probabilidad de que el Discriminador clasifique $x$ (una imagen real) como real.
• $D(G(z))$ es la probabilidad de que el Discriminador clasifique $G(z)$ (una imagen generada a partir de ruido $z$) como real.
• $\mathbb{E}$ denota el valor esperado.

Pérdida del Discriminador

El Discriminador quiere maximizar $D(x)$ (clasificar imágenes reales como 1) y minimizar $D(G(z))$ (clasificar imágenes falsas como 0). Por lo tanto, su pérdida es:

$ L_D = - \mathbb{E}{x \sim p{data}(x)}[\log D(x)] - \mathbb{E}_{z \sim p_z(z)}[\log(1 - D(G(z)))] $

Pérdida del Generador

El Generador quiere que el Discriminador clasifique sus imágenes falsas como reales, es decir, quiere maximizar $D(G(z))$. Sin embargo, para evitar problemas de gradientes al inicio del entrenamiento, se suele optimizar la pérdida del Generador para minimizar $ -\log D(G(z)) $ o, equivalentemente, $ \log(1 - D(G(z))) $.

$ L_G = - \mathbb{E}_{z \sim p_z(z)}[\log D(G(z))] $

🚀 Implementación de una GAN Simple con PyTorch

Vamos a construir una GAN para generar imágenes de dígitos MNIST. Este dataset es pequeño y permite un entrenamiento relativamente rápido, ideal para aprender.

📦 Preparación del Entorno y Datos

Primero, necesitamos importar las bibliotecas necesarias y configurar el entorno.

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torchvision.utils import save_image
import os

# Configuración de dispositivos (GPU si está disponible, si no CPU)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f"Usando dispositivo: {device}")

# Hyperparámetros
latent_dim = 100 # Dimensión del vector de ruido
image_size = 28 # Tamaño de las imágenes MNIST (28x28)
num_epochs = 50
batch_size = 128
learning_rate = 0.0002
betas = (0.5, 0.999) # Parámetros para el optimizador Adam

# Directorio para guardar las imágenes generadas
output_dir = 'generated_images'
os.makedirs(output_dir, exist_ok=True)

# Transformaciones para el dataset MNIST
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,)) # Normalizar a rango [-1, 1]
])

# Cargar el dataset MNIST
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)

🏗️ Definición del Generador

Nuestro Generador será una red secuencial que transforma un vector de ruido latent_dim en una imagen de 28x28 píxeles.

class Generator(nn.Module):
    def __init__(self, latent_dim, img_size):
        super(Generator, self).__init__()
        self.img_size = img_size

        self.main = nn.Sequential(
            # Entrada: vector de ruido latent_dim
            nn.Linear(latent_dim, 128 * (img_size // 4) * (img_size // 4)),
            nn.BatchNorm1d(128 * (img_size // 4) * (img_size // 4)),
            nn.LeakyReLU(0.2, inplace=True),
            # Remodelar a un tensor 3D para deconvoluciones
            nn.Unflatten(1, (128, img_size // 4, img_size // 4)),

            nn.ConvTranspose2d(128, 64, kernel_size=4, stride=2, padding=1),
            nn.BatchNorm2d(64),
            nn.LeakyReLU(0.2, inplace=True),

            nn.ConvTranspose2d(64, 1, kernel_size=4, stride=2, padding=1),
            nn.Tanh() # Salida de imagen en rango [-1, 1]
        )

    def forward(self, input):
        return self.main(input)

# Instanciar el Generador
netG = Generator(latent_dim, image_size).to(device)
print("\nGenerador:\n", netG)

🕵️‍♀️ Definición del Discriminador

El Discriminador tomará una imagen de 28x28 y la reducirá a una sola probabilidad.

class Discriminator(nn.Module):
    def __init__(self, img_size):
        super(Discriminator, self).__init__()
        self.img_size = img_size

        self.main = nn.Sequential(
            # Entrada: imagen de 1 canal, img_size x img_size
            nn.Flatten(),
            nn.Linear(img_size * img_size, 512),
            nn.LeakyReLU(0.2, inplace=True),
            
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2, inplace=True),

            nn.Linear(256, 1),
            nn.Sigmoid() # Salida de probabilidad entre 0 y 1
        )

    def forward(self, input):
        return self.main(input)

# Instanciar el Discriminador
netD = Discriminator(image_size).to(device)
print("\nDiscriminador:\n", netD)

🔄 Inicialización de Pesos

Es una buena práctica inicializar los pesos de las redes para ayudar en la estabilidad del entrenamiento de GANs.

def weights_init(m):
    classname = m.__class__.__name__
    if classname.find('Conv') != -1:
        nn.init.normal_(m.weight.data, 0.0, 0.02)
    elif classname.find('BatchNorm') != -1:
        nn.init.normal_(m.weight.data, 1.0, 0.02)
        nn.init.constant_(m.bias.data, 0)

netG.apply(weights_init)
netD.apply(weights_init)

⚖️ Función de Pérdida y Optimizadores

Utilizaremos la pérdida de entropía cruzada binaria (BCEWithLogitsLoss es común, pero BCELoss con Sigmoid al final de D también funciona) y el optimizador Adam.

criterion = nn.BCELoss()

# Etiquetas para las imágenes reales y falsas
real_label = 1.
fake_label = 0.

# Optimizadores para G y D
optimizerD = optim.Adam(netD.parameters(), lr=learning_rate, betas=betas)
optimizerG = optim.Adam(netG.parameters(), lr=learning_rate, betas=betas)

🏋️‍♀️ Proceso de Entrenamiento

El entrenamiento de una GAN implica dos pasos alternos por cada iteración:

1. Entrenar el Discriminador:

   • Clasificar imágenes reales. Calcular la pérdida. (D debe predecir real_label)
   • Generar imágenes falsas. Clasificarlas. Calcular la pérdida. (D debe predecir fake_label)
   • Combinar las pérdidas y actualizar los pesos del Discriminador.

2. Entrenar el Generador:

   • Generar nuevas imágenes falsas.
   • El Discriminador las clasifica. Calcular la pérdida del Generador. (G quiere que D prediga real_label para sus falsificaciones).
   • Actualizar los pesos del Generador.

# Vector de ruido fijo para visualizar el progreso de la generación
fixed_noise = torch.randn(64, latent_dim, device=device)

print("\nIniciando el entrenamiento...")
for epoch in range(num_epochs):
    for i, data in enumerate(train_loader, 0):
        # ------------------------------------ #
        # (1) Actualizar la red del Discriminador: maximizar log(D(x)) + log(1 - D(G(z)))
        # ------------------------------------ #
        netD.zero_grad()

        # Entrenar con todas las imágenes reales
        real_cpu = data[0].to(device)
        b_size = real_cpu.size(0)
        label = torch.full((b_size,), real_label, dtype=torch.float, device=device)
        output = netD(real_cpu).view(-1)
        errD_real = criterion(output, label)
        errD_real.backward()
        D_x = output.mean().item()

        # Entrenar con todas las imágenes falsas generadas
        noise = torch.randn(b_size, latent_dim, device=device)
        fake = netG(noise)
        label.fill_(fake_label)
        output = netD(fake.detach()).view(-1) # .detach() es crucial aquí
        errD_fake = criterion(output, label)
        errD_fake.backward()
        D_G_z1 = output.mean().item()

        errD = errD_real + errD_fake
        optimizerD.step()

        # ------------------------------------ #
        # (2) Actualizar la red del Generador: maximizar log(D(G(z))) o minimizar -log(D(G(z)))
        # ------------------------------------ #
        netG.zero_grad()
        label.fill_(real_label) # Las etiquetas del Generador son 'reales' para que D sea engañado
        output = netD(fake).view(-1)
        errG = criterion(output, label)
        errG.backward()
        D_G_z2 = output.mean().item()
        optimizerG.step()

        if i % 100 == 0:
            print(f"[{epoch}/{num_epochs}][{i}/{len(train_loader)}] Loss_D: {errD.item():.4f} Loss_G: {errG.item():.4f} D(x): {D_x:.4f} D(G(z)): {D_G_z1:.4f}/{D_G_z2:.4f}")

    # Guardar imágenes generadas cada época para visualizar el progreso
    with torch.no_grad():
        fake = netG(fixed_noise).detach().cpu()
        save_image(fake, f'{output_dir}/fake_samples_epoch_{epoch:03d}.png', normalize=True, nrow=8)

print("Entrenamiento completado!")

📊 Métricas y Monitoreo del Entrenamiento

Monitorear el entrenamiento de GANs puede ser complicado. Aquí hay algunas métricas clave y comportamientos a observar:

• Loss_D (Error del Discriminador): Debe disminuir inicialmente a medida que D aprende a distinguir entre real y falso. Luego, debería estabilizarse o fluctuar. Si baja demasiado rápido a cero, D es demasiado bueno.
• Loss_G (Error del Generador): Debe disminuir a medida que G aprende a producir imágenes más realistas. Un valor muy alto o fluctuante puede indicar problemas.
• D(x): La probabilidad media de que D clasifique las imágenes reales como reales. Debería acercarse a 1.
• D(G(z)): La probabilidad media de que D clasifique las imágenes falsas como reales. Este valor debería fluctuar alrededor de 0.5 en un entrenamiento ideal. D_G_z1 es la clasificación de falsas antes de la actualización de G, y D_G_z2 es después.

📉 Problemas Comunes en el Entrenamiento de GANs

El entrenamiento de GANs es conocido por su inestabilidad. Aquí hay algunos problemas comunes:

• Modo Colapso (Mode Collapse): El Generador produce solo una pequeña variedad de salidas, ignorando la diversidad del conjunto de datos real. Esto ocurre cuando el Generador encuentra una o pocas muestras que engañan al Discriminador y se limita a generarlas.

  • ¿Cómo mitigar el Modo Colapso?

    * Usar *Mini-batch Discrimination*. * Añadir ruido a las entradas del Discriminador. * Usar *unrolled GANs*. * Técnicas de regularización (ej., R1 regularization).

• Fallo en la Convergencia: Las pérdidas pueden oscilar salvajemente o no disminuir, indicando que ninguna de las redes está aprendiendo eficazmente.

  • ¿Cómo abordar la falta de convergencia?

    * Ajustar `learning_rate` y parámetros `betas` de Adam. * Balancear las actualizaciones de G y D (ej., entrenar D k veces por cada actualización de G). * Probar diferentes arquitecturas o funciones de activación.

• Discriminador Demasiado Fuerte/Débil: Si el Discriminador es demasiado fuerte, el Generador no puede aprender. Si es demasiado débil, el Generador puede generar ruido y el Discriminador no lo detectará.

  • Equilibrio Discriminador/Generador

    * Ajustar el `learning_rate` relativo. * Usar suavizado de etiquetas (label smoothing) para D. * Añadir ruido a las etiquetas de D.

✨ Aplicaciones Avanzadas de GANs

Las GANs han evolucionado rápidamente, dando lugar a variantes más sofisticadas con aplicaciones impresionantes:

✅ Conclusión

Las Redes Generativas Adversarias representan un campo fascinante y en constante evolución dentro del Deep Learning. A través de la competencia entre un Generador y un Discriminador, estas redes pueden aprender distribuciones de datos complejas y generar contenido asombrosamente realista. Si bien su entrenamiento puede ser un desafío debido a problemas de estabilidad, las recompensas en términos de capacidades de generación son enormes.

Esperamos que este tutorial te haya proporcionado una comprensión sólida de los principios de las GANs y la confianza para empezar a experimentar con ellas en PyTorch. ¡El siguiente paso es explorar datasets más grandes y arquitecturas más complejas para desbloquear todo el potencial creativo de las GANs!