Explorando la Inteligencia Artificial Generativa Avanzada | VAEs Condicionales

Exploración de la IA Generativa Avanzada | VAEs Condicionales

Introducción

Bienvenido a este artículo, donde exploraremos el emocionante mundo de la IA Generativa. Nos centraremos principalmente en los Autoencoders Variacionales Condicionales o CVAEs, que son como el siguiente nivel de la creatividad de la IA, fusionando las fortalezas de los Autoencoders Variacionales (VAEs) con la capacidad de seguir instrucciones específicas, brindándonos un control afinado sobre la creación de imágenes. A lo largo de este artículo, profundizaremos en los CVAEs y veremos cómo y por qué se pueden utilizar en diversos escenarios del mundo real, e incluso proporcionaremos algunos ejemplos de código fáciles de entender para mostrar su potencial.

Este artículo fue publicado como parte del Data Science Blogathon.

Comprendiendo los Autoencoders Variacionales (VAEs)

Antes de adentrarnos en los CVAEs, enfoquémonos en los fundamentos de los VAEs. Los VAEs son un tipo de modelo generativo que combina una red de codificación y una red de decodificación. Se utilizan para aprender la estructura subyacente de los datos y generar nuevas muestras.

• Acelerando la llegada de la energía de fusión con IA y accesibilidad
• FMOps/LLMOps Operacionalizar la IA generativa y las diferencias con MLOps
• Elevando la experiencia de la IA generativa Introduciendo el soporte de transmisión en la hospedaje de Amazon SageMaker

Claro, usemos un ejemplo sencillo que involucre las preferencias de café para explicar los Autoencoders Variacionales (VAEs)

Imagina que quieres representar las preferencias de café de todos en tu oficina:

• Codificador: Cada persona resume su elección de café (negro, latte, cappuccino) con algunas palabras (por ejemplo, fuerte, cremoso, suave).
• Variación: Comprende que incluso dentro de la misma elección (por ejemplo, latte), hay variaciones en la leche, la dulzura, etc.
• Espacio Latente: Crea un espacio flexible donde las preferencias de café pueden variar.
• Decodificador: Utiliza estos resúmenes para hacer café para los colegas, con pequeñas variaciones, respetando sus preferencias.
• Potencia Generativa: Puede crear nuevos estilos de café que se ajusten a los gustos individuales pero que no sean réplicas exactas.

Los VAEs funcionan de manera similar, aprendiendo características principales y variaciones en los datos para generar nuevos datos similares con pequeñas diferencias.

Aquí tienes una implementación simple de Autoencoder Variacional (VAE) utilizando Python y TensorFlow/Keras. Este ejemplo utiliza el conjunto de datos MNIST por simplicidad, pero puedes adaptarlo a otros tipos de datos.

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import numpy as np

# Cargar y preprocesar el conjunto de datos MNIST
(x_train, _), (x_test, _) = keras.datasets.mnist.load_data()
x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0

# Definir el modelo VAE
latent_dim = 2

# Codificador
encoder_inputs = keras.Input(shape=(28, 28))
x = layers.Flatten()(encoder_inputs)
x = layers.Dense(256, activation='relu')(x)
z_mean = layers.Dense(latent_dim)(x)
z_log_var = layers.Dense(latent_dim)(x)

# Truco de reparametrización
def sampling(args):
    z_mean, z_log_var = args
    epsilon = tf.keras.backend.random_normal(shape=(tf.shape(z_mean)[0], latent_dim))
    return z_mean + tf.exp(0.5 * z_log_var) * epsilon

z = layers.Lambda(sampling)([z_mean, z_log_var])

# Decodificador
decoder_inputs = keras.Input(shape=(latent_dim,))
x = layers.Dense(256, activation='relu')(decoder_inputs)
x = layers.Dense(28 * 28, activation='sigmoid')(x)
decoder_outputs = layers.Reshape((28, 28))(x)

# Definir el modelo VAE
encoder = keras.Model(encoder_inputs, [z_mean, z_log_var, z], name='encoder')
decoder = keras.Model(decoder_inputs, decoder_outputs, name='decoder')
vae_outputs = decoder(encoder(encoder_inputs)[2])
vae = keras.Model(encoder_inputs, vae_outputs, name='vae')

# Función de pérdida
def vae_loss(x, x_decoded_mean, z_log_var, z_mean):
    x = tf.keras.backend.flatten(x)
    x_decoded_mean = tf.keras.backend.flatten(x_decoded_mean)
    xent_loss = keras.losses.binary_crossentropy(x, x_decoded_mean)
    kl_loss = -0.5 * tf.reduce_mean(1 + z_log_var - tf.square(z_mean) - tf.exp(z_log_var))
    return xent_loss + kl_loss

vae.compile(optimizer='adam', loss=vae_loss)
vae.fit(x_train, x_train, epochs=10, batch_size=32, validation_data=(x_test, x_test))

Explicación de los Autoencoders Variacionales Condicionales (CVAEs)

Los CVAEs amplían las capacidades de los VAEs al introducir entradas condicionales. Los CVAEs pueden generar muestras de datos basadas en condiciones o información específica. Por ejemplo, puedes generar imágenes condicionalmente de gatos o perros proporcionando al modelo la etiqueta de clase deseada como entrada.

Veamos un ejemplo en tiempo real.

Compras en línea con CVAEs Imagina que estás comprando zapatillas en línea:

• VAE básico (sin condiciones): El sitio web te muestra zapatillas aleatorias.
• CVAE (con condiciones): Seleccionas tus preferencias: color (rojo), talla (10) y estilo (running).
• Codificador: El sitio web entiende tus elecciones y filtra las zapatillas según estas condiciones.
• Variación: Reconociendo que incluso dentro de tus condiciones, hay variaciones (diferentes tonos de rojo, estilos de zapatillas para correr), las tiene en cuenta.
• Espacio latente: Crea un “espacio de personalización de zapatillas” donde se permiten variaciones.
• Decodificador: Usando tus condiciones personalizadas, te muestra zapatillas que se ajustan estrechamente a tus preferencias.

Los CVAEs, al igual que los sitios web de compras en línea, utilizan condiciones específicas (tus preferencias) para generar datos personalizados (opciones de zapatillas) que se alinean estrechamente con tus elecciones.

Continuando desde el ejemplo del Variational Autoencoder (VAE), puedes implementar un Conditional Variational Autoencoder (CVAE). En este ejemplo, consideraremos el conjunto de datos MNIST y generaremos dígitos de forma condicional basados en una etiqueta de clase.

# Definir el modelo CVAE
encoder = keras.Model([encoder_inputs, label], [z_mean, z_log_var, z], name='encoder')
decoder = keras.Model([decoder_inputs, label], decoder_outputs, name='decoder')
cvae_outputs = decoder([encoder([encoder_inputs, label])[2], label])
cvae = keras.Model([encoder_inputs, label], cvae_outputs, name='cvae')

Diferencia entre VAEs y CVAEs

VAE

• Los VAEs son como artistas que crean arte pero con un poco de aleatoriedad.
• Aprenden a crear variaciones diversas de datos sin ninguna instrucción específica.
• Útiles para generar nuevas muestras de datos sin condiciones, como arte aleatorio.

CVAE

• Los CVAEs son como artistas que pueden seguir solicitudes específicas.
• Generan datos basados en condiciones o instrucciones dadas.
• Útiles para tareas en las que deseas un control preciso sobre lo que se genera, como convertir un caballo en una cebra conservando las características principales.

Implementación de CVAEs: Ejemplos de código

Exploraremos un ejemplo sencillo de código en Python utilizando TensorFlow y Keras para implementar un CVAE para generar dígitos escritos a mano

# Importar las bibliotecas necesarias
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras.models import Model

# Definir la arquitectura del modelo CVAE
latent_dim = 2
input_shape = (28, 28, 1)
num_classes = 10

# Red del codificador
encoder_inputs = keras.Input(shape=input_shape)
x = layers.Conv2D(32, 3, padding='same', activation='relu')(encoder_inputs)
x = layers.Flatten()(x)
x = layers.Dense(64, activation='relu')(x)

# Entrada condicional
label = keras.Input(shape=(num_classes,))
x = layers.concatenate([x, label])

# Capas variacionales
z_mean = layers.Dense(latent_dim)(x)
z_log_var = layers.Dense(latent_dim)(x)

# Truco de reparametrización
def sampling(args):
    z_mean, z_log_var = args
    epsilon = tf.keras.backend.random_normal(shape=(tf.shape(z_mean)[0], latent_dim))
    return z_mean + tf.exp(0.5 * z_log_var) * epsilon

z = layers.Lambda(sampling)([z_mean, z_log_var])

# Red del decodificador
decoder_inputs = layers.Input(shape=(latent_dim,))
x = layers.concatenate([decoder_inputs, label])
x = layers.Dense(64, activation='relu')(x)
x = layers.Dense(28 * 28 * 1, activation='sigmoid')(x)
x = layers.Reshape((28, 28, 1))(x)

# Crear los modelos
encoder = Model([encoder_inputs, label], [z_mean, z_log_var, z], name='encoder')
decoder = Model([decoder_inputs, label], x, name='decoder')
cvae = Model([encoder_inputs, label], decoder([z, label]), name='cvae')
#import csv

Este código proporciona una estructura básica para un modelo CVAE. Para entrenar y generar imágenes, necesitarás un conjunto de datos adecuado y ajustes adicionales.

Aplicaciones de los CVAEs

Los CVAEs tienen aplicaciones en diversos campos, incluyendo:

Traducción de imagen a imagen: Se pueden utilizar para traducir imágenes de un dominio a otro mientras se preserva el contenido. Imagina que tienes una foto de un caballo y quieres convertirla en una cebra manteniendo las características principales. Los CVAEs pueden hacer eso:

#import csv# Traducir imagen de caballo a imagen de cebra
translated_image = cvae_generate(imagen_caballo, target="cebra")

Transferencia de estilo: Los CVAEs permiten transferir estilos artísticos entre imágenes. Supongamos que tienes una imagen y quieres que se parezca a una famosa pintura, como “La noche estrellada” de Van Gogh. Los CVAEs pueden aplicar ese estilo:

#import csv# Aplicar estilo "La noche estrellada" a tu foto
styled_image = cvae_apply_style(tu_foto, style="La noche estrellada")

• Detección de anomalías: Son eficaces para detectar anomalías en los datos. Tienes un conjunto de datos de latidos cardíacos normales y quieres detectar latidos irregulares. Los CVAEs pueden detectar anomalías:

# Detectar latidos cardíacos irregulares
is_anomaly = cvae_detect_anomaly(datos_latidos_cardiacos)

• Descubrimiento de medicamentos: Los CVAEs ayudan a generar estructuras moleculares para el descubrimiento de medicamentos. Digamos que necesitas encontrar nuevas moléculas para un medicamento salvavidas. Los CVAEs pueden ayudar a diseñar estructuras moleculares:

#import csv# Generar moléculas de medicamentos potenciales
drug_molecule = cvae_generate_molecule("anti-cancer")

Estas aplicaciones muestran cómo los CVAEs pueden transformar imágenes, aplicar estilos artísticos, detectar anomalías y ayudar en tareas cruciales como el descubrimiento de medicamentos, todo mientras mantienen los datos subyacentes significativos y útiles.

Desafíos y direcciones futuras

Desafíos

• Colapso de modo: Piensa en los CVAEs como un pintor que a veces olvida usar todos sus colores. El colapso de modo ocurre cuando los CVAEs siguen utilizando los mismos colores (representaciones) para diferentes cosas. Entonces, podrían pintar todos los animales con un solo color, perdiendo diversidad.
• Generación de imágenes de alta resolución: Imagina pedirle a un artista que pinte un mural detallado y grande en un lienzo pequeño. Es un desafío. Los CVAEs enfrentan un desafío similar al intentar crear imágenes altamente detalladas y grandes.

Metas futuras

Los investigadores quieren mejorar los CVAEs:

• Avoid Mode Collapse: Están trabajando para asegurarse de que el artista (CVAE) utilice todos los colores (representaciones) que tiene, creando resultados más diversos y precisos.
• Arte de alta resolución: Su objetivo es ayudar al artista (CVAE) a pintar murales (imágenes) más grandes y detallados mejorando las técnicas utilizadas. De esta manera, podemos obtener obras de arte impresionantes y de alta calidad de los CVAEs.

Conclusión

Los Autoencoders Variacionales Condicionales representan un avance revolucionario en la IA Generativa. Su capacidad para generar datos basados en condiciones específicas abre un mundo de posibilidades en diversas aplicaciones. Al comprender sus principios subyacentes e implementarlos de manera efectiva, podemos aprovechar el potencial de los CVAEs para la generación avanzada de imágenes y más allá.

Puntos clave

1. Avance de la IA Generativa: Permite la generación de imágenes con entradas condicionales.
2. Analogy simple del café: Piensa en los VAEs como resúmenes de preferencias de café, permitiendo variaciones mientras se preserva la esencia.
3. Código básico de VAE: Se proporciona un ejemplo de código en Python fácil de entender de un VAE, utilizando el conjunto de datos MNIST.
4. Implementación de CVAE: El artículo incluye un fragmento de código para implementar un CVAE para la generación condicional de imágenes.
5. Ejemplo de compras en línea: Se ilustra la capacidad de los CVAEs para personalizar datos basados en condiciones mediante una analogía de compras en línea de zapatillas.

Preguntas frecuentes

Los medios mostrados en este artículo no son propiedad de Analytics Vidhya y se utilizan a discreción del autor.

We will continue to update Zepes; if you have any questions or suggestions, please contact us!