🧠 Red Generativa Adversaria (DCGAN) para Generación de Imágenes¶

# ===========================================================================
# 2. IMPORTACIÓN DE LIBRERÍAS
# ===========================================================================
import tensorflow as tf
from tensorflow.keras import layers
import numpy as np
import matplotlib.pyplot as plt
import time
import os
import warnings

warnings.filterwarnings('ignore')

# Verificar dispositivo disponible
print(f"TensorFlow versión: {tf.__version__}")
print(f"GPU disponible: {tf.config.list_physical_devices('GPU')}")
print(f"Dispositivo de ejecución: {'GPU' if tf.config.list_physical_devices('GPU') else 'CPU'}")

# Semilla para reproducibilidad
SEED = 42
tf.random.set_seed(SEED)
np.random.seed(SEED)

# ===========================================================================
# 3. CARGA Y PREPROCESAMIENTO DE CIFAR-10
# ===========================================================================
from tensorflow.keras.datasets import cifar10

# Cargar datos (misma fuente que Semana 7)
(X_train_raw, y_train), (X_test_raw, y_test) = cifar10.load_data()

# Nombres de las clases CIFAR-10
CLASES = ['Avión', 'Automóvil', 'Pájaro', 'Gato', 'Ciervo',
          'Perro', 'Rana', 'Caballo', 'Barco', 'Camión']

print(f"Datos de entrenamiento: {X_train_raw.shape}")
print(f"Datos de prueba:        {X_test_raw.shape}")
print(f"Rango original de píxeles: [{X_train_raw.min()}, {X_train_raw.max()}]")

# Normalizar a [-1, 1] para compatibilidad con tanh del generador
X_train = (X_train_raw.astype("float32") - 127.5) / 127.5
X_test = (X_test_raw.astype("float32") - 127.5) / 127.5

print(f"Rango normalizado: [{X_train.min():.1f}, {X_train.max():.1f}]")
print(f"\nClases disponibles: {CLASES}")

# ===========================================================================
# VISUALIZACIÓN DE MUESTRAS REALES
# ===========================================================================
fig, axes = plt.subplots(3, 10, figsize=(16, 5))
fig.suptitle('Muestras reales del dataset CIFAR-10', fontsize=14, fontweight='bold')

for i in range(10):
    # Seleccionar 3 imágenes aleatorias de cada clase
    idx_clase = np.where(y_train.flatten() == i)[0]
    muestras = np.random.choice(idx_clase, 3, replace=False)

    for j in range(3):
        # Desnormalizar para visualización
        img = (X_train[muestras[j]] + 1) / 2.0
        axes[j, i].imshow(img)
        axes[j, i].axis('off')
        if j == 0:
            axes[j, i].set_title(CLASES[i], fontsize=8)

plt.tight_layout()
plt.savefig('muestras_reales_cifar10.png', dpi=150, bbox_inches='tight')
plt.show()
print(f"Distribución de clases en entrenamiento:")
for i, nombre in enumerate(CLASES):
    count = np.sum(y_train.flatten() == i)
    print(f"  {nombre}: {count} imágenes")

# ===========================================================================
# PIPELINE DE DATOS TENSORFLOW
# ===========================================================================
BUFFER_SIZE = 50000  # Tamaño del buffer de shuffle (todo el train set)
BATCH_SIZE = 128     # Estándar DCGAN

# Crear dataset de TensorFlow optimizado
train_dataset = tf.data.Dataset.from_tensor_slices(X_train)\
    .shuffle(BUFFER_SIZE)\
    .batch(BATCH_SIZE)\
    .prefetch(tf.data.AUTOTUNE)

print(f"Batches por época: {len(train_dataset)}")
print(f"Tamaño de batch: {BATCH_SIZE}")
print(f"Imágenes por época: {len(X_train)}")

# ===========================================================================
# 4.1 ARQUITECTURA DEL GENERADOR
# ===========================================================================
LATENT_DIM = 100  # Dimensión del espacio latente

def build_generator():
    """
    Generador DCGAN para imágenes CIFAR-10 (32×32×3).

    Transforma un vector de ruido z ∈ ℝ¹⁰⁰ en una imagen a color de 32×32.
    Utiliza Conv2DTranspose para upsampling progresivo:
    (100,) → (4,4,256) → (8,8,128) → (16,16,64) → (32,32,3)
    """
    model = tf.keras.Sequential(name='Generador')

    # Capa 1: Proyección y reshape
    # Transforma el vector latente en un tensor 3D (mapa de características)
    model.add(layers.Dense(4 * 4 * 256, use_bias=False, input_shape=(LATENT_DIM,)))
    model.add(layers.BatchNormalization())
    model.add(layers.ReLU())
    model.add(layers.Reshape((4, 4, 256)))

    # Capa 2: Upsampling 4×4 → 8×8
    model.add(layers.Conv2DTranspose(128, (5, 5), strides=(2, 2),
                                      padding='same', use_bias=False))
    model.add(layers.BatchNormalization())
    model.add(layers.ReLU())

    # Capa 3: Upsampling 8×8 → 16×16
    model.add(layers.Conv2DTranspose(64, (5, 5), strides=(2, 2),
                                      padding='same', use_bias=False))
    model.add(layers.BatchNormalization())
    model.add(layers.ReLU())

    # Capa 4 (Salida): Upsampling 16×16 → 32×32 con 3 canales (RGB)
    # Activación tanh para rango [-1, 1]
    model.add(layers.Conv2DTranspose(3, (5, 5), strides=(2, 2),
                                      padding='same', use_bias=False,
                                      activation='tanh'))

    return model

# Construir el generador
generator = build_generator()
generator.summary()

# Verificar forma de salida del generador
noise_test = tf.random.normal([1, LATENT_DIM])
generated_test = generator(noise_test, training=False)
print(f"Forma de salida del generador: {generated_test.shape}")
print(f"Rango de valores: [{generated_test.numpy().min():.3f}, {generated_test.numpy().max():.3f}]")
assert generated_test.shape == (1, 32, 32, 3), "Error: la forma de salida no es correcta"
print("✅ Generador verificado correctamente")

# ===========================================================================
# 4.2 ARQUITECTURA DEL DISCRIMINADOR
# ===========================================================================

def build_discriminator():
    """
    Discriminador DCGAN para imágenes CIFAR-10 (32×32×3).

    Clasifica imágenes como reales o generadas.
    Utiliza Conv2D para downsampling:
    (32,32,3) → (16,16,64) → (8,8,128) → Flatten → 1
    """
    model = tf.keras.Sequential(name='Discriminador')

    # Capa 1: Downsampling 32×32 → 16×16
    model.add(layers.Conv2D(64, (5, 5), strides=(2, 2), padding='same',
                            input_shape=(32, 32, 3)))
    model.add(layers.LeakyReLU(0.2))
    model.add(layers.Dropout(0.3))

    # Capa 2: Downsampling 16×16 → 8×8
    model.add(layers.Conv2D(128, (5, 5), strides=(2, 2), padding='same'))
    model.add(layers.LeakyReLU(0.2))
    model.add(layers.Dropout(0.3))

    # Capa de salida: clasificación binaria
    model.add(layers.Flatten())
    model.add(layers.Dense(1, activation='sigmoid'))

    return model

# Construir el discriminador
discriminator = build_discriminator()
discriminator.summary()

# Verificar forma de salida del discriminador
decision_test = discriminator(generated_test, training=False)
print(f"Salida del discriminador: {decision_test.numpy()}")
print(f"Forma: {decision_test.shape}")
print("✅ Discriminador verificado correctamente")

# ===========================================================================
# RESUMEN COMPARATIVO DE PARÁMETROS
# ===========================================================================
print("=" * 60)
print("RESUMEN DE LA ARQUITECTURA DCGAN")
print("=" * 60)
print(f"\nGenerador:")
print(f"  Parámetros totales:      {generator.count_params():,}")
print(f"  Entrada:                 vector z ∈ ℝ^{LATENT_DIM}")
print(f"  Salida:                  imagen 32×32×3 (RGB)")
print(f"  Activación de salida:    tanh → [-1, 1]")
print(f"\nDiscriminador:")
print(f"  Parámetros totales:      {discriminator.count_params():,}")
print(f"  Entrada:                 imagen 32×32×3 (RGB)")
print(f"  Salida:                  probabilidad ∈ [0, 1]")
print(f"  Activación de salida:    sigmoid")
print(f"\nTotal combinado:           {generator.count_params() + discriminator.count_params():,}")

# ===========================================================================
# 5. CONFIGURACIÓN DEL ENTRENAMIENTO
# ===========================================================================

# Función de pérdida: Binary Cross-Entropy
loss_fn = tf.keras.losses.BinaryCrossentropy()

# Optimizadores Adam con hiperparámetros de DCGAN
optimizer_G = tf.keras.optimizers.Adam(learning_rate=1e-4, beta_1=0.5)
optimizer_D = tf.keras.optimizers.Adam(learning_rate=1e-4, beta_1=0.5)

# Hiperparámetros de entrenamiento
EPOCHS = 50
NUM_EXAMPLES_TO_GENERATE = 36  # 6×6 grid para visualización

# Vector de ruido fijo para monitorear el progreso (siempre el mismo)
seed_noise = tf.random.normal([NUM_EXAMPLES_TO_GENERATE, LATENT_DIM])

print("Configuración del entrenamiento:")
print(f"  Épocas:           {EPOCHS}")
print(f"  Batch size:       {BATCH_SIZE}")
print(f"  Learning rate:    1e-4")
print(f"  β₁ (Adam):        0.5")
print(f"  Dim. latente:     {LATENT_DIM}")
print(f"  Función pérdida:  Binary Cross-Entropy")

# ===========================================================================
# FUNCIÓN DE VISUALIZACIÓN DURANTE ENTRENAMIENTO
# ===========================================================================

def generate_and_save_images(model, epoch, test_input, save=True):
    """Genera y visualiza imágenes usando el generador actual."""
    predictions = model(test_input, training=False)

    # Desnormalizar de [-1, 1] a [0, 1]
    predictions = (predictions + 1) / 2.0
    predictions = tf.clip_by_value(predictions, 0.0, 1.0)

    fig, axes = plt.subplots(6, 6, figsize=(10, 10))
    fig.suptitle(f'Imágenes generadas — Época {epoch}',
                 fontsize=14, fontweight='bold')

    for i in range(36):
        row, col = i // 6, i % 6
        axes[row, col].imshow(predictions[i].numpy())
        axes[row, col].axis('off')

    plt.tight_layout()

    if save:
        filename = f'dcgan_cifar10_epoca_{epoch:03d}.png'
        plt.savefig(filename, dpi=150, bbox_inches='tight')

    plt.show()

# Verificar función con imágenes aleatorias (antes de entrenar)
print("Imágenes del generador SIN entrenar (ruido puro):")
generate_and_save_images(generator, 0, seed_noise, save=False)

# ===========================================================================
# 6. BUCLE DE ENTRENAMIENTO
# ===========================================================================
print("=" * 60)
print("INICIO DEL ENTRENAMIENTO DCGAN")
print("=" * 60)

# Registros de pérdidas
history_loss_D = []
history_loss_G = []

start_total = time.time()

for epoch in range(1, EPOCHS + 1):
    start_epoch = time.time()

    epoch_loss_D = []
    epoch_loss_G = []

    for batch in train_dataset:
        d_loss, g_loss = train_step(batch)
        epoch_loss_D.append(d_loss.numpy())
        epoch_loss_G.append(g_loss.numpy())

    # Promediar pérdidas de la época
    avg_loss_D = np.mean(epoch_loss_D)
    avg_loss_G = np.mean(epoch_loss_G)
    history_loss_D.append(avg_loss_D)
    history_loss_G.append(avg_loss_G)

    elapsed = time.time() - start_epoch

    # Imprimir progreso
    if epoch % 5 == 0 or epoch == 1:
        print(f"Época {epoch:3d}/{EPOCHS} | "
              f"Loss D: {avg_loss_D:.4f} | "
              f"Loss G: {avg_loss_G:.4f} | "
              f"Tiempo: {elapsed:.1f}s")

    # Visualizar cada 10 épocas
    if epoch % 10 == 0:
        generate_and_save_images(generator, epoch, seed_noise)

total_time = time.time() - start_total
print(f"\n{'=' * 60}")
print(f"ENTRENAMIENTO COMPLETADO")
print(f"Tiempo total: {total_time/60:.1f} minutos")
print(f"{'=' * 60}")

# ===========================================================================
# 7.1 CURVAS DE PÉRDIDA
# ===========================================================================
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))

# Pérdida del Discriminador
ax1.plot(history_loss_D, color='#e74c3c', linewidth=1.5, label='Discriminador')
ax1.set_title('Pérdida del Discriminador', fontsize=13, fontweight='bold')
ax1.set_xlabel('Época')
ax1.set_ylabel('Loss')
ax1.legend()
ax1.grid(True, alpha=0.3)

# Pérdida del Generador
ax2.plot(history_loss_G, color='#3498db', linewidth=1.5, label='Generador')
ax2.set_title('Pérdida del Generador', fontsize=13, fontweight='bold')
ax2.set_xlabel('Época')
ax2.set_ylabel('Loss')
ax2.legend()
ax2.grid(True, alpha=0.3)

plt.suptitle('Curvas de Entrenamiento DCGAN — CIFAR-10', fontsize=15, fontweight='bold', y=1.02)
plt.tight_layout()
plt.savefig('curvas_perdida_dcgan.png', dpi=150, bbox_inches='tight')
plt.show()

# Ambas juntas para comparar
fig, ax = plt.subplots(figsize=(10, 5))
ax.plot(history_loss_D, color='#e74c3c', linewidth=1.5, alpha=0.8, label='Discriminador')
ax.plot(history_loss_G, color='#3498db', linewidth=1.5, alpha=0.8, label='Generador')
ax.set_title('Comparación de Pérdidas G vs D', fontsize=13, fontweight='bold')
ax.set_xlabel('Época')
ax.set_ylabel('Loss')
ax.legend(fontsize=12)
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('comparacion_perdidas_GvsD.png', dpi=150, bbox_inches='tight')
plt.show()

print(f"\nPérdida final del Discriminador: {history_loss_D[-1]:.4f}")
print(f"Pérdida final del Generador:     {history_loss_G[-1]:.4f}")

# ===========================================================================
# 7.2 GENERACIÓN DE 36 IMÁGENES NUEVAS (COLLAGE FINAL)
# ===========================================================================
print("Generando 36 imágenes nuevas con la DCGAN entrenada...\n")

# Generar con nuevo ruido aleatorio (no el seed fijo)
noise_final = tf.random.normal([36, LATENT_DIM])
generated_final = generator(noise_final, training=False)

# Desnormalizar
generated_final = (generated_final + 1) / 2.0
generated_final = tf.clip_by_value(generated_final, 0.0, 1.0)

# Crear collage 6×6
fig, axes = plt.subplots(6, 6, figsize=(12, 12))
fig.suptitle('Collage de 36 Imágenes Generadas por la DCGAN\n(Entrenada con CIFAR-10)',
             fontsize=16, fontweight='bold')

for i in range(36):
    row, col = i // 6, i % 6
    axes[row, col].imshow(generated_final[i].numpy())
    axes[row, col].axis('off')
    axes[row, col].set_title(f'Img {i+1}', fontsize=8)

plt.tight_layout()
plt.savefig('collage_36_imagenes_generadas.png', dpi=200, bbox_inches='tight')
plt.show()

print(f"\n✅ Se generaron 36 imágenes nuevas exitosamente")
print(f"   Collage guardado como: collage_36_imagenes_generadas.png")

# ===========================================================================
# 7.3 EVOLUCIÓN TEMPORAL
# ===========================================================================
# Generar imágenes con el seed fijo en diferentes "momentos" del entrenamiento
# (Ya se guardaron durante el entrenamiento, aquí mostramos la final)

print("Evolución del generador durante el entrenamiento:")
print(f"  Época  1: Ruido aleatorio puro")
print(f"  Época 10: Primeras formas emergentes")
print(f"  Época 20: Estructuras más definidas")
print(f"  Época 30: Colores y formas reconocibles")
print(f"  Época 40: Mayor coherencia visual")
print(f"  Época 50: Resultado final")

# Mostrar resultado final con el seed fijo
generate_and_save_images(generator, EPOCHS, seed_noise, save=True)

# ===========================================================================
# 7.4 COMPARACIÓN REAL VS GENERADA
# ===========================================================================
fig, (ax_real, ax_fake) = plt.subplots(1, 2, figsize=(14, 6))

# Panel izquierdo: Imágenes reales
real_sample = (X_train[:16] + 1) / 2.0
grid_real = np.zeros((4*32, 4*32, 3))
for i in range(16):
    r, c = i // 4, i % 4
    grid_real[r*32:(r+1)*32, c*32:(c+1)*32] = real_sample[i]

ax_real.imshow(grid_real)
ax_real.set_title('Imágenes Reales (CIFAR-10)', fontsize=13, fontweight='bold')
ax_real.axis('off')

# Panel derecho: Imágenes generadas
noise_comp = tf.random.normal([16, LATENT_DIM])
fake_comp = generator(noise_comp, training=False)
fake_comp = tf.clip_by_value((fake_comp + 1) / 2.0, 0.0, 1.0).numpy()

grid_fake = np.zeros((4*32, 4*32, 3))
for i in range(16):
    r, c = i // 4, i % 4
    grid_fake[r*32:(r+1)*32, c*32:(c+1)*32] = fake_comp[i]

ax_fake.imshow(grid_fake)
ax_fake.set_title('Imágenes Generadas (DCGAN)', fontsize=13, fontweight='bold')
ax_fake.axis('off')

plt.suptitle('Comparación: Real vs. Generada', fontsize=15, fontweight='bold')
plt.tight_layout()
plt.savefig('comparacion_real_vs_generada.png', dpi=150, bbox_inches='tight')
plt.show()

# ===========================================================================
# 7.5 RESUMEN DE MÉTRICAS
# ===========================================================================
print("=" * 60)
print("RESUMEN DE MÉTRICAS DE RENDIMIENTO")
print("=" * 60)
print(f"\nDataset:                 CIFAR-10 (32×32×3, RGB)")
print(f"Imágenes entrenamiento:  {len(X_train):,}")
print(f"Épocas completadas:      {EPOCHS}")
print(f"Tiempo total:            {total_time/60:.1f} minutos")
print(f"\nPérdida final Discriminador: {history_loss_D[-1]:.4f}")
print(f"Pérdida final Generador:     {history_loss_G[-1]:.4f}")
print(f"\nParámetros del Generador:     {generator.count_params():,}")
print(f"Parámetros del Discriminador: {discriminator.count_params():,}")
print(f"Parámetros totales:           {generator.count_params() + discriminator.count_params():,}")
print(f"\nImágenes generadas:          36 (collage 6×6)")
print(f"\n{'=' * 60}")