Al cerrar el módulo anterior dejamos una idea en el aire: todos los modelos que hemos construido hasta ahora para TecnoMarket —la red densa de MNIST, la mini-VGG de fotos de producto, el clasificador de reseñas, la LSTM de ventas— clasifican o predicen, pero ninguno crea. En esta lección cruzamos esa frontera con las Redes Generativas Adversariales (GAN), una arquitectura en la que dos redes compiten entre sí hasta que una de ellas aprende a generar datos nuevos indistinguibles de los reales. Para TecnoMarket esto abre una puerta muy concreta: generar imágenes promocionales y aumentar los datos de productos con pocas fotos. Aquí aprenderás la técnica y su arquitectura; el proyecto guiado completo de entrenamiento lo haremos en la lección 07-04.

Contenido

  1. Modelos discriminativos vs. generativos
  2. La idea adversarial: falsificador contra policía
  3. El espacio latente
  4. La dinámica de entrenamiento y sus pérdidas
  5. Problemas típicos de las GAN
  6. Variantes clave: DCGAN, GAN condicional y compañía
  7. Esqueleto de una DCGAN en Keras
  8. GAN en TecnoMarket: usos y límites

Modelos discriminativos vs. generativos

Todos los modelos del curso hasta este punto pertenecen a la misma familia: los modelos discriminativos. Reciben una entrada y producen una decisión o un número:

  • La red densa de 02-05 recibe un dígito y responde "es un 7".
  • La CNN de 03-04 recibe una foto y responde "es una tostadora".
  • La LSTM de 04-03 recibe una reseña y responde "sentimiento negativo".
  • La LSTM de 04-04 recibe ventas pasadas y responde "mañana venderás 412 unidades".

Formalmente, un modelo discriminativo aprende la frontera que separa clases (o la relación entrada→salida). Un modelo generativo hace algo más ambicioso: aprende cómo son los datos en sí, su distribución, y con ese conocimiento puede fabricar ejemplos nuevos que nunca existieron.

Aspecto Modelo discriminativo Modelo generativo
Pregunta que responde "¿Qué es esto?" "¿Cómo es esto?"
Aprende Fronteras entre clases La distribución de los datos
Salida Etiqueta, probabilidad, número Un dato nuevo (imagen, texto...)
Ejemplo en el curso CNN de fotos de producto (03-04) GAN de imágenes promocionales
Analogía Un crítico de arte Un pintor

La analogía del crítico y el pintor es útil: el crítico distingue un Velázquez de una falsificación sin saber pintar; el pintor, para pintar bien, necesita entender la luz, la composición, la anatomía... es decir, un conocimiento más profundo. Las GAN tienen la genialidad de poner a un crítico y a un pintor a entrenarse mutuamente.

La idea adversarial: falsificador contra policía

Una GAN se compone de dos redes neuronales que compiten:

  • El generador (G): el falsificador de billetes. Recibe ruido aleatorio y produce imágenes falsas. Al principio son garabatos; su objetivo es que cuelen como reales.
  • El discriminador (D): el policía. Recibe imágenes (unas reales del dataset, otras fabricadas por G) y debe decir cuáles son auténticas. Es un clasificador binario, exactamente como los que ya sabes construir.

La competición los mejora a ambos:

  1. Al principio, el falsificador produce billetes burdos y el policía los detecta con facilidad.
  2. El falsificador estudia en qué falla (recibe el "reparto de culpa" del gradiente, la misma backpropagation de 02-03, pero atravesando al policía) y mejora sus billetes.
  3. El policía, ante falsificaciones mejores, afina su criterio: mira la marca de agua, el relieve...
  4. El ciclo se repite hasta que las falsificaciones son tan buenas que el policía acierta poco más que lanzando una moneda.
flowchart LR
    Z[Ruido aleatorio z] --> G[Generador]
    G --> F[Imagenes falsas]
    R[(Imagenes reales<br/>del dataset)] --> D[Discriminador]
    F --> D
    D --> V{Real o falsa?}
    V -- error de D --> D
    V -- gradiente a traves de D --> G

Fíjate en la última flecha del diagrama: el generador nunca ve las imágenes reales. Solo aprende del veredicto del discriminador. Todo su conocimiento sobre "cómo es una foto de producto real" le llega filtrado por su adversario.

El espacio latente

¿Qué es ese "ruido aleatorio" que entra al generador? Es un vector z de, por ejemplo, 100 números extraídos de una distribución normal. Ese vector vive en el espacio latente, y el generador aprende a mapear cada punto de ese espacio a una imagen.

Esto te sonará: en 03-04 vimos que una CNN convierte imágenes en embeddings —vectores donde la cercanía (similitud coseno) significa parecido visual— y en 04-03 hicimos lo mismo con palabras. El espacio latente de una GAN es la misma idea en sentido inverso: en lugar de comprimir una imagen a un vector, expandimos un vector a una imagen. Y hereda las propiedades interesantes de los embeddings:

  • Puntos cercanos generan imágenes parecidas: si mueves z un poco, la tostadora generada cambia ligeramente de ángulo o color.
  • Se puede interpolar: recorrer la línea recta entre z1 (que genera una cafetera roja) y z2 (una cafetera negra) produce una transición suave de cafeteras intermedias.
  • Direcciones con significado: en GAN bien entrenadas aparecen direcciones del espacio latente que controlan atributos ("más brillo", "fondo más claro"), igual que en los embeddings de palabras había direcciones de significado.

El generador es, en esencia, un decodificador del espacio latente al espacio de imágenes. Guarda esta idea: en la próxima lección (autoencoders) construiremos ese espacio latente de forma explícita y controlada.

La dinámica de entrenamiento y sus pérdidas

El entrenamiento alterna dos pasos, repetidos miles de veces:

Paso 1 — entrenar al discriminador (el generador se congela):

  • Se le muestran imágenes reales con etiqueta 1 e imágenes generadas con etiqueta 0.
  • Su pérdida es la entropía cruzada binaria (BCE) que ya usaste en 02-04 para clasificación binaria. Nada nuevo: es un clasificador haciendo su trabajo.

Paso 2 — entrenar al generador (el discriminador se congela):

  • El generador produce imágenes y se las pasa al discriminador con etiqueta 1 ("quiero que te las creas").
  • La pérdida vuelve a ser BCE, pero medida sobre la opinión del discriminador. Si el discriminador dice "0.05 de probabilidad de real", la pérdida del generador es alta y el gradiente le indica cómo retocar sus pesos para engañarlo mejor.

Este tira y afloja es un juego minimax: el discriminador intenta maximizar su acierto y el generador intenta minimizarlo. No hace falta el formalismo matemático completo; la intuición operativa es esta:

El equilibrio ideal no es que uno gane, sino un empate de alto nivel: el generador produce imágenes tan buenas que el discriminador responde ~0.5 ("no sabría decirte") para todo.

Esto tiene una consecuencia práctica importante que distingue a las GAN de todo lo anterior: la curva de pérdida ya no baja monótonamente hasta estabilizarse, como las que analizaste en 02-05. Las pérdidas de G y D oscilan, suben y bajan en función del rival. Para saber si la GAN va bien no basta mirar las curvas: hay que mirar las imágenes generadas periódicamente.

Problemas típicos de las GAN

Entrenar dos redes en competición es notoriamente inestable. Estos son los tres problemas clásicos:

Problema Qué pasa Síntomas Remedios habituales
Mode collapse (colapso de modos) El generador descubre una imagen que engaña al discriminador y la produce siempre, ignorando la diversidad real Todas las muestras generadas son casi idénticas (p. ej., siempre la misma cafetera con el mismo ángulo) Batch de muestras diverso, variantes como WGAN, minibatch discrimination
Inestabilidad / desequilibrio Una red aplasta a la otra: si D se vuelve perfecto, el gradiente que le llega a G se desvanece (el vanishing gradient de 02-03 reaparece) y G deja de aprender La pérdida de D cae a ~0 y la de G se dispara; las imágenes dejan de mejorar Learning rates bajos y distintos para G y D, label smoothing (etiquetas 0.9 en vez de 1), no sobreentrenar a D
No convergencia Las dos redes oscilan sin llegar al equilibrio: G engaña, D se adapta, G cambia de estrategia... en círculos Pérdidas que oscilan sin patrón; la calidad de las imágenes mejora y empeora cíclicamente Adam con beta_1 bajo (0.5), arquitecturas probadas (DCGAN), paciencia y checkpoints frecuentes

Consejo transversal: guarda imágenes generadas cada N épocas y compáralas. Es el equivalente visual de las curvas train/val que ya dominas.

Variantes clave

La GAN original (2014) usaba capas densas. Desde entonces la familia ha crecido; estas son las variantes que debes conocer a nivel conceptual:

  • DCGAN (Deep Convolutional GAN): sustituye las capas densas por convoluciones. El discriminador es una CNN normal (como las del módulo 3) y el generador usa convoluciones transpuestas que hacen el camino inverso: de un vector pequeño a una imagen grande, doblando la resolución en cada capa. Es la arquitectura de referencia para empezar y la que usaremos en 07-04.
  • GAN condicional (cGAN): además del ruido, el generador recibe una etiqueta ("genera un dígito 7", "genera una cafetera"). Así se controla qué se genera, no solo que sea realista. Para TecnoMarket es la variante interesante: sin condición, la GAN genera "un producto cualquiera"; con condición, genera productos de la categoría que pidas.
  • StyleGAN: la familia responsable de los rostros hiperrealistas que habrás visto en la web; introduce control fino por niveles de detalle (pose, rasgos, textura).
  • CycleGAN: traduce entre dominios sin pares de ejemplo (foto↔cuadro, verano↔invierno). Pista de su utilidad comercial: convertir la foto de un sofá en "el mismo sofá en un salón nórdico".

Existe otra familia generativa, los modelos de difusión, que hoy domina la generación de imágenes comerciales; la mencionaremos al hablar de tendencias en 08-03.

Esqueleto de una DCGAN en Keras

Veamos cómo se materializan generador y discriminador para imágenes de 64×64 en color (como miniaturas de producto de TecnoMarket). Este es el esqueleto arquitectónico; el bucle de entrenamiento alternado completo lo construiremos paso a paso en 07-04.

from tensorflow import keras
from tensorflow.keras import layers

DIM_LATENTE = 100  # tamaño del vector de ruido z

# --- GENERADOR: de un vector de 100 numeros a una imagen 64x64x3 ---
generador = keras.Sequential([
    # Proyectamos el ruido a un "mapa" pequeño de 4x4 con 512 canales
    layers.Dense(4 * 4 * 512, input_shape=(DIM_LATENTE,)),
    layers.Reshape((4, 4, 512)),

    # Cada Conv2DTranspose con strides=2 DUPLICA la resolucion:
    # es la operacion inversa a la convolucion con stride 2 del modulo 3
    layers.Conv2DTranspose(256, 4, strides=2, padding="same"),  # 8x8
    layers.BatchNormalization(),          # estabiliza (lo veremos en 05-04)
    layers.LeakyReLU(0.2),                # ReLU "con fuga": deja pasar
                                          # un poco de gradiente en negativos
    layers.Conv2DTranspose(128, 4, strides=2, padding="same"),  # 16x16
    layers.BatchNormalization(),
    layers.LeakyReLU(0.2),

    layers.Conv2DTranspose(64, 4, strides=2, padding="same"),   # 32x32
    layers.BatchNormalization(),
    layers.LeakyReLU(0.2),

    # Ultima capa: 3 canales (RGB) y tanh -> valores en [-1, 1],
    # por eso las imagenes reales se normalizan tambien a [-1, 1]
    layers.Conv2DTranspose(3, 4, strides=2, padding="same",
                           activation="tanh"),                  # 64x64x3
], name="generador")

# --- DISCRIMINADOR: una CNN binaria como las del modulo 3 ---
discriminador = keras.Sequential([
    # Convoluciones con stride 2 que REDUCEN la resolucion a la mitad
    layers.Conv2D(64, 4, strides=2, padding="same",
                  input_shape=(64, 64, 3)),                     # 32x32
    layers.LeakyReLU(0.2),

    layers.Conv2D(128, 4, strides=2, padding="same"),           # 16x16
    layers.LeakyReLU(0.2),

    layers.Conv2D(256, 4, strides=2, padding="same"),           # 8x8
    layers.LeakyReLU(0.2),

    layers.Flatten(),
    layers.Dropout(0.3),                  # regularizacion (05-04)
    layers.Dense(1, activation="sigmoid") # probabilidad de "real"
], name="discriminador")

Puntos que conviene entender bien:

  • El generador es una CNN al revés: donde la CNN del módulo 3 reducía la imagen con stride/pooling hasta un vector, Conv2DTranspose con strides=2 la amplía (4→8→16→32→64). La jerarquía bordes→texturas→partes→objetos se recorre en sentido contrario: primero la estructura global, luego el detalle.
  • LeakyReLU en lugar de ReLU: una ReLU pura da gradiente cero para entradas negativas; en un entrenamiento tan delicado, eso mata neuronas y desestabiliza. LeakyReLU deja pasar una pequeña pendiente (0.2) en la zona negativa.
  • tanh final y datos en [-1, 1]: el rango de salida del generador debe coincidir con el rango de las imágenes reales que ve el discriminador; si no, el policía distinguiría los billetes por el "color del papel" y no por su contenido.
  • El discriminador no lleva BatchNormalization en la práctica habitual de la primera capa, y sí lleva Dropout: no queremos que sea demasiado bueno demasiado pronto.

GAN en TecnoMarket: usos y límites

¿Para qué quiere una tienda online generar imágenes?

  • Imágenes promocionales: generar variaciones de una foto de producto (fondos, ambientaciones, composiciones para banners) sin sesión fotográfica. Una cGAN condicionada por categoría podría producir borradores de creatividades que el equipo de diseño refina.
  • Aumento de datos para productos raros: el clasificador de fotos de 03-04 funciona mal en categorías con pocas imágenes (¿cuántas fotos hay de una freidora de aire de una marca minoritaria?). Una GAN entrenada en la categoría puede generar ejemplos sintéticos adicionales para reequilibrar el dataset, complementando el aumento de datos clásico que veremos en 05-04.
  • Prototipado de catálogo: visualizar cómo se vería un producto en distintos colores o entornos antes de fabricarlo o fotografiarlo.

Y los límites, que no son pequeños:

  • Calidad y artefactos: una GAN modesta genera imágenes con defectos (texturas raras, geometrías imposibles). Para material de cara al cliente hay que filtrar con revisión humana — el mismo patrón de cola de revisión que montamos en el pipeline de 03-04.
  • Coste de entrenamiento: las GAN de alta calidad exigen muchos datos y mucha GPU; para una empresa mediana suele compensar más partir de modelos ya entrenados (idea que generalizamos en 05-03).
  • Riesgos de uso indebido: la misma tecnología genera deepfakes y imágenes engañosas. Publicar una imagen sintética de un producto que no se corresponde con la realidad no es un problema técnico sino ético y legal; lo tratamos en profundidad en 08-01.

Errores Comunes y Consejos

  • Juzgar la GAN por sus curvas de pérdida como si fuera un clasificador. Es el error número uno al venir de modelos discriminativos. Las pérdidas de G y D oscilan por diseño; una pérdida de G que baja a cero suele ser mala señal (D ha dejado de aprender). Evalúa mirando muestras generadas.
  • Olvidar alinear los rangos. Si las imágenes reales están en [0, 255] o [0, 1] y el generador emite en [-1, 1] (tanh), el discriminador "gana" trivialmente. Normaliza los datos reales a [-1, 1].
  • Entrenar demasiado al discriminador. Parece lógico ("cuanto mejor el policía, mejor aprenderá el falsificador"), pero un D perfecto devuelve gradientes casi nulos a G. Equilibrio, no perfección.
  • Esperar diversidad sin comprobarla. Genera una rejilla de 8×8 muestras con distintos z cada pocas épocas; si todas se parecen, tienes mode collapse y conviene reducir el learning rate o cambiar de variante.
  • Empezar por arquitecturas exóticas. DCGAN con los hiperparámetros clásicos (Adam, lr=0.0002, beta_1=0.5) es el punto de partida sensato; innova solo cuando lo básico funcione.

Ejercicios

Ejercicio 1. Clasifica cada uno de estos modelos del curso como discriminativo o generativo, y justifica en una frase: (a) la LSTM de predicción de ventas de 04-04; (b) el generador de una GAN; (c) el discriminador de una GAN; (d) el clasificador de reseñas de 04-03.

Ejercicio 2. Durante el entrenamiento de una DCGAN sobre fotos de cafeteras de TecnoMarket observas que, a partir de la época 40, la pérdida del discriminador cae hacia 0.01 y la del generador crece sin parar, y las imágenes generadas dejan de mejorar. (a) ¿Cuál de los tres problemas típicos es? (b) Propón dos remedios concretos.

Ejercicio 3. En el esqueleto de la DCGAN, calcula la secuencia de resoluciones espaciales que atraviesa el generador desde el Reshape hasta la salida, y explica qué papel juega strides=2 en Conv2DTranspose comparándolo con el strides=2 de una Conv2D del módulo 3.

Soluciones

Solución 1.

  • (a) Discriminativo: mapea una entrada (ventana de ventas pasadas) a una predicción numérica; no modela cómo "son" las series, solo la relación entrada→salida.
  • (b) Generativo: fabrica datos nuevos (imágenes) a partir de ruido; implícitamente aprende la distribución de las imágenes reales.
  • (c) Discriminativo: es un clasificador binario real/falso, con BCE, como cualquier clasificador del módulo 2-3. Que viva dentro de una GAN no cambia su naturaleza.
  • (d) Discriminativo: entrada (reseña) → etiqueta (sentimiento).

Solución 2.

  • (a) Es el problema de inestabilidad por desequilibrio: el discriminador se ha vuelto casi perfecto y el gradiente útil que atraviesa D hacia G se desvanece (el mismo fenómeno de vanishing gradient de 02-03), de modo que G ya no puede aprender.
  • (b) Remedios razonables: bajar el learning rate del discriminador (o entrenarlo menos pasos por cada paso de G); aplicar label smoothing (etiquetar las reales como 0.9 en lugar de 1.0 para que D no se vuelva tan confiado); añadir Dropout al discriminador. Cualquier par de estos es válido.

Solución 3.

La secuencia es 4×4 → 8×8 → 16×16 → 32×32 → 64×64: el Reshape crea un mapa de 4×4×512 y cada una de las cuatro Conv2DTranspose con strides=2 duplica alto y ancho. En una Conv2D normal, strides=2 significa "salta de dos en dos al deslizar el filtro", con lo que la salida tiene la mitad de resolución (reducción, como en el módulo 3). En Conv2DTranspose la operación se invierte: cada posición de entrada "pinta" una vecindad en una salida más grande, de modo que strides=2 duplica la resolución. El generador recorre así la jerarquía de la CNN en sentido inverso: de representación abstracta y pequeña a imagen concreta y grande.

Conclusión

Has cruzado la frontera entre clasificar y crear. Las ideas clave: los modelos generativos aprenden la distribución de los datos, no solo fronteras; una GAN enfrenta a un generador (falsificador) y un discriminador (policía) en un juego minimax cuyo objetivo es un empate de alto nivel; el generador mapea un espacio latente —primo hermano de los embeddings que ya conocías— a imágenes; y el entrenamiento es inestable por naturaleza, con el mode collapse y el desequilibrio como enemigos habituales. Con la DCGAN tienes la arquitectura de referencia, y en 07-04 la entrenaremos de principio a fin.

Pero queda una pregunta abierta: la GAN crea su espacio latente "a ciegas", empujada por un adversario. ¿Y si pudiéramos construir ese espacio latente de forma directa, obligando a la red a comprimir y reconstruir los datos reales? Ese es exactamente el autoencoder, protagonista de la siguiente lección — y, de paso, la herramienta con la que TecnoMarket va a detectar fraude.

Curso de Deep Learning

Módulo 1: Introducción a Deep Learning

Módulo 2: Fundamentos de Redes Neuronales

Módulo 3: Redes Neuronales Convolucionales (CNN)

Módulo 4: Redes Neuronales Recurrentes (RNN)

Módulo 5: Técnicas Avanzadas en Deep Learning

Módulo 6: Herramientas y Frameworks

Módulo 7: Proyectos Prácticos

Módulo 8: Consideraciones Éticas y Futuro del Deep Learning

© Copyright 2026. Todos los derechos reservados