4.2 Creación del Modelo

Crear un modelo GAN implica diseñar tanto el generador como el discriminador. El rol del generador es producir imágenes realistas a partir de ruido aleatorio, mientras que el rol del discriminador es distinguir entre imágenes reales del conjunto de datos e imágenes falsas generadas por el generador. Al entrenar estas dos redes de manera adversarial, buscamos producir un generador capaz de crear imágenes faciales altamente realistas.

4.2.1 Construcción del Generador

El generador es una red neuronal que toma ruido aleatorio como entrada y lo transforma en una imagen realista. Para nuestro proyecto de generación de caras, utilizaremos un generador de convolución profunda. La arquitectura incluirá varias capas de convoluciones transpuestas, normalización por lotes y funciones de activación para aumentar progresivamente la entrada de ruido hasta una imagen de tamaño completo.

Componentes Clave:

Capa Densa: La primera capa será una capa densa que toma el ruido de entrada y lo proyecta en un espacio de mayor dimensión.
Capa de Redimensionamiento: Esta capa redimensiona la salida de la capa densa en un tensor 3D adecuado para operaciones de convolución.
Capas de Convolución Transpuesta: Estas capas (también conocidas como capas de deconvolución) aumentarán el tamaño del tensor hasta el tamaño de imagen deseado.
Normalización por Lotes: La normalización por lotes se aplicará después de cada convolución transpuesta para estabilizar y acelerar el proceso de entrenamiento.
Funciones de Activación: Usaremos activaciones LeakyReLU en capas ocultas y activación Tanh en la capa de salida para asegurar que los valores de los píxeles estén en el rango [-1, 1].

Ejemplo: Código del Generador

import tensorflow as tf
from tensorflow.keras.layers import Dense, Reshape, BatchNormalization, LeakyReLU, Conv2DTranspose
from tensorflow.keras.models import Sequential

def build_generator(latent_dim):
    model = Sequential()

    # Dense layer
    model.add(Dense(256 * 8 * 8, activation="relu", input_dim=latent_dim))
    model.add(Reshape((8, 8, 256)))

    # Transposed convolutional layers
    model.add(Conv2DTranspose(128, kernel_size=4, strides=2, padding='same'))
    model.add(BatchNormalization())
    model.add(LeakyReLU(alpha=0.2))

    model.add(Conv2DTranspose(64, kernel_size=4, strides=2, padding='same'))
    model.add(BatchNormalization())
    model.add(LeakyReLU(alpha=0.2))

    model.add(Conv2DTranspose(32, kernel_size=4, strides=2, padding='same'))
    model.add(BatchNormalization())
    model.add(LeakyReLU(alpha=0.2))

    # Output layer
    model.add(Conv2DTranspose(3, kernel_size=4, strides=2, padding='same', activation='tanh'))

    return model

# Define the latent dimension (size of the random noise vector)
latent_dim = 100
generator = build_generator(latent_dim)
generator.summary()

El modelo se construye utilizando la API Sequential, comenzando con una capa densa que toma el latent_dim (tamaño del vector de ruido aleatorio) como entrada. La salida se remodela en un tensor de 8x8x256.

Luego aplica múltiples capas de convolución transpuesta (Conv2DTranspose), cada una seguida de normalización por lotes y una activación LeakyReLU. Estas capas aumentan progresivamente el tamaño espacial del tensor.

La última capa Conv2DTranspose produce un tensor con forma correspondiente a una imagen, con 3 canales de color (RGB) y activación tanh.

Al final, la estructura del generador se imprime utilizando el método summary().

4.2.2 Construcción del Discriminador

El discriminador es una red neuronal que toma una imagen como entrada y produce una probabilidad que indica si la imagen es real (del conjunto de datos) o falsa (generada por el generador). Para nuestro proyecto, utilizaremos un discriminador de convolución profunda con varias capas de convolución, normalización por lotes y funciones de activación.

Componentes Clave:

Capas de Convolución: Estas capas reducirán la muestra de la imagen de entrada, extrayendo características jerárquicas a diferentes niveles de abstracción.
Normalización por Lotes: Aplicada después de cada capa de convolución para estabilizar y acelerar el entrenamiento.
Funciones de Activación: Utilizaremos activaciones LeakyReLU en capas ocultas para permitir pequeños gradientes negativos y una activación sigmoide en la capa de salida para producir una probabilidad.

Ejemplo: Código del Discriminador

import tensorflow as tf
from tensorflow.keras.layers import Conv2D, Flatten, Dense, LeakyReLU, BatchNormalization
from tensorflow.keras.models import Sequential

def build_discriminator(img_shape):
    model = Sequential()

    # Convolutional layers
    model.add(Conv2D(64, kernel_size=4, strides=2, padding='same', input_shape=img_shape))
    model.add(LeakyReLU(alpha=0.2))

    model.add(Conv2D(128, kernel_size=4, strides=2, padding='same'))
    model.add(BatchNormalization())
    model.add(LeakyReLU(alpha=0.2))

    model.add(Conv2D(256, kernel_size=4, strides=2, padding='same'))
    model.add(BatchNormalization())
    model.add(LeakyReLU(alpha=0.2))

    model.add(Conv2D(512, kernel_size=4, strides=2, padding='same'))
    model.add(BatchNormalization())
    model.add(LeakyReLU(alpha=0.2))

    # Output layer
    model.add(Flatten())
    model.add(Dense(1, activation='sigmoid'))

    return model

# Define the image shape (e.g., 64x64 RGB images)
img_shape = (64, 64, 3)
discriminator = build_discriminator(img_shape)
discriminator.summary()

Este código de ejemplo define una función que construye un modelo de discriminador para una Red Generativa Adversaria (GAN) utilizando las bibliotecas TensorFlow y Keras. El modelo tiene una serie de capas de convolución, cada una seguida por una función de activación LeakyReLU y algunas incluyen Normalización por Lotes.

Estas capas se utilizan para extraer características de las imágenes de entrada. La capa de salida es una capa densa con una sola unidad y una función de activación sigmoide, que emitirá la probabilidad de que la imagen de entrada sea real. Luego, se construye el modelo con una forma de imagen especificada y se muestra la estructura del modelo.

4.2.3 Compilación de los Modelos

Antes de entrenar la GAN, necesitamos compilar el discriminador y el modelo combinado de GAN. El discriminador se compilará por separado con una función de pérdida de entropía cruzada binaria y un optimizador. El modelo combinado de GAN, que incluye el generador y el discriminador, también se compilará con una función de pérdida de entropía cruzada binaria y un optimizador.

Compilación del Discriminador:

# Compile the discriminator
discriminator.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

El modelo se entrenará para minimizar una función llamada 'entropía cruzada binaria' (comúnmente utilizada en problemas de clasificación binaria) y se rastreará la precisión del modelo como una métrica durante el proceso de entrenamiento.

Compilación del Modelo GAN Combinado:

Para el modelo combinado de GAN, primero necesitamos congelar los pesos del discriminador para asegurar que solo el generador se entrene durante la fase de entrenamiento del modelo combinado. El modelo combinado toma ruido como entrada, genera una imagen y luego evalúa la imagen generada usando el discriminador.

from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input

# Freeze the discriminator's weights during the combined model training
discriminator.trainable = False

# Create the combined GAN model
gan_input = Input(shape=(latent_dim,))
generated_img = generator(gan_input)
gan_output = discriminator(generated_img)

gan = Model(gan_input, gan_output)
gan.compile(optimizer='adam', loss='binary_crossentropy')

# Summary of the combined GAN model
gan.summary()

Aquí, los pesos del Discriminador se congelan para evitar que se entrene durante la fase de entrenamiento del modelo combinado. El Generador toma una entrada (la dimensión latente) y genera una imagen. Esta imagen generada se pasa al Discriminador, que la clasifica como real o falsa.

El modelo combinado de GAN se compila con el optimizador 'adam' y la función de pérdida 'binary_crossentropy', que es adecuada para un problema de clasificación binaria.

Finalmente, se muestra un resumen del modelo combinado de GAN, ofreciendo una visión general de la arquitectura y los parámetros del modelo.

4.2.4 Visualización de las Arquitecturas del Modelo

Visualizar las arquitecturas tanto del generador como del discriminador puede proporcionar información sobre sus estructuras y ayudar a identificar posibles problemas.

Visualización del Generador:

from tensorflow.keras.utils import plot_model

plot_model(generator, to_file='generator_model.png', show_shapes=True, show_layer_names=True)

La función plot_model se utiliza para crear esta visualización, que se guardará como 'generator_model.png'. El parámetro 'show_shapes' se establece en 'True' para mostrar las dimensiones de las capas del modelo, y 'show_layer_names' se establece en 'True' para mostrar los nombres de cada capa en el modelo.

Visualización del Discriminador:

plot_model(discriminator, to_file='discriminator_model.png', show_shapes=True, show_layer_names=True)

Esta línea de código utiliza la función plot_model de la biblioteca Keras para crear una visualización de la estructura del modelo 'discriminator'. Guarda esta visualización como un archivo .png llamado 'discriminator_model.png'. Los parámetros 'show_shapes=True' y 'show_layer_names=True' indican que la visualización debe incluir las formas de las capas del modelo y los nombres de cada capa.

Al crear y compilar con éxito el generador, el discriminador y el modelo GAN combinado, hemos sentado las bases para entrenar nuestra GAN. Los siguientes pasos involucran entrenar la GAN en el conjunto de datos CelebA, monitorear su rendimiento y evaluar la calidad de las imágenes generadas.