Capítulo 5: Explorando Autoencoders Variacionales (VAEs)
5.5 Variaciones de los VAEs (Beta-VAE, VAE Condicional)
Los Autoencoders Variacionales, o VAEs, han surgido como un marco fundamental y revolucionario en el mundo del aprendizaje automático. Se han desarrollado numerosas extensiones y modificaciones a partir de este modelo base, cada una con el objetivo de abordar desafíos específicos o mejorar aspectos particulares del modelo VAE original.
Este continuo desarrollo y avance en el campo ha hecho que estos modelos sean cada vez más completos y robustos. En esta sección, profundizaremos en los detalles de dos variaciones populares: el Beta-VAE y el VAE Condicional.
Estas adaptaciones del modelo VAE principal introducen un impresionante grado de flexibilidad adicional y control. Este mayor nivel de adaptabilidad amplía aún más el rango de aplicaciones para las cuales se pueden utilizar los modelos VAE, convirtiéndolos en una herramienta aún más poderosa en el campo del aprendizaje automático y el análisis de datos.
5.5.1 Beta-VAE
El Beta-VAE es un modelo innovador que introduce un nuevo hiperparámetro, denotado como $(\beta)$, en la función objetivo de un Autoencoder Variacional tradicional (VAE). Este elemento adicional proporciona un mayor control sobre el delicado equilibrio entre dos componentes clave de la función: la pérdida de reconstrucción y la divergencia KL (Kullback-Leibler).
La pérdida de reconstrucción se refiere a la capacidad del modelo para recrear los datos de entrada, mientras que la divergencia KL mide la diferencia entre la distribución de probabilidad aprendida por el modelo y la verdadera distribución.
Ajustando cuidadosamente el valor de $(\beta)$, el modelo Beta-VAE puede fomentar de manera más efectiva el aprendizaje de representaciones disentangled (desenredadas) dentro del espacio latente. Las representaciones desenredadas pueden conducir a una mejor interpretabilidad y robustez en el modelo, haciendo que el Beta-VAE sea un avance significativo en el campo.
Función Objetivo:
Beta-VAE Loss=Reconstruction Loss+β×KL Divergence
Un valor más alto de ( \beta ) coloca más énfasis en el término de divergencia KL, promoviendo el desenredamiento a expensas de la calidad de la reconstrucción. Por el contrario, un valor más bajo de ( \beta ) prioriza la precisión de la reconstrucción.
Ejemplo: Implementación de Beta-VAE
import tensorflow as tf
from tensorflow.keras.layers import Input, Dense, Lambda, Layer
from tensorflow.keras.models import Model
from tensorflow.keras import backend as K
# Sampling layer using the reparameterization trick
class Sampling(Layer):
def call(self, inputs):
z_mean, z_log_var = inputs
batch = tf.shape(z_mean)[0]
dim = tf.shape(z_mean)[1]
epsilon = K.random_normal(shape=(batch, dim))
return z_mean + K.exp(0.5 * z_log_var) * epsilon
# Encoder network
def build_encoder(input_shape, latent_dim):
inputs = Input(shape=input_shape)
x = Dense(512, activation='relu')(inputs)
x = Dense(256, activation='relu')(x)
z_mean = Dense(latent_dim, name='z_mean')(x)
z_log_var = Dense(latent_dim, name='z_log_var')(x)
z = Sampling()([z_mean, z_log_var])
return Model(inputs, [z_mean, z_log_var, z], name='encoder')
# Decoder network
def build_decoder(latent_dim, output_shape):
latent_inputs = Input(shape=(latent_dim,))
x = Dense(256, activation='relu')(latent_inputs)
x = Dense(512, activation='relu')(x)
outputs = Dense(output_shape, activation='sigmoid')(x)
return Model(latent_inputs, outputs, name='decoder')
# Define the input shape and latent dimension
input_shape = (784,)
latent_dim = 2
# Build the encoder and decoder
encoder = build_encoder(input_shape, latent_dim)
decoder = build_decoder(latent_dim, input_shape[0])
# Define the Beta-VAE model
inputs = Input(shape=input_shape)
z_mean, z_log_var, z = encoder(inputs)
outputs = decoder(z)
beta_vae = Model(inputs, outputs, name='beta_vae')
# Define the Beta-VAE loss function
def beta_vae_loss(inputs, outputs, z_mean, z_log_var, beta=1.0):
reconstruction_loss = tf.keras.losses.binary_crossentropy(inputs, outputs)
reconstruction_loss *= input_shape[0]
kl_loss = 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var)
kl_loss = K.sum(kl_loss, axis=-1)
kl_loss *= -0.5
return K.mean(reconstruction_loss + beta * kl_loss)
# Compile the Beta-VAE model
beta_vae.compile(optimizer='adam', loss=lambda x, y: beta_vae_loss(x, y, z_mean, z_log_var, beta=4.0))
# Train the Beta-VAE model
beta_vae.fit(x_train, x_train, epochs=50, batch_size=128, validation_data=(x_test, x_test))En este ejemplo:
El script primero importa las bibliotecas necesarias y define una capa de Muestreo, que se utiliza para extraer muestras aleatorias del espacio latente usando el truco de reparametrización.
Luego, define funciones para construir las partes del codificador y decodificador del VAE, cada una de las cuales es una red neuronal profunda. El codificador transforma la entrada en una representación latente, y el decodificador reconstruye la entrada original a partir de la representación latente.
A continuación, se definen la forma de entrada y la dimensión latente, y se construyen el codificador y el decodificador utilizando estos parámetros.
Luego se define el modelo Beta-VAE, conectando las redes del codificador y decodificador.
A continuación, se define una función de pérdida personalizada para el Beta-VAE, que incluye tanto la pérdida de reconstrucción como la divergencia Kullback-Leibler (KL). La divergencia KL mide cuánto se desvía la distribución latente aprendida de la distribución prior. El factor 'beta' controla el equilibrio entre la pérdida de reconstrucción y la divergencia KL.
Finalmente, se compila y entrena el modelo Beta-VAE utilizando la función de pérdida definida, un optimizador 'adam', y datos de entrenamiento y prueba.
5.5.2 Variational Autoencoder Condicional (CVAE)
El Autoencoder Variacional Condicional (CVAE) es una extensión del Autoencoder Variacional estándar (VAE), un modelo generativo popular. El CVAE mejora la funcionalidad del VAE al condicionar tanto el codificador, que se encarga de comprimir los datos de entrada en una representación latente, como el decodificador, que reconstruye los datos originales a partir de esta representación latente, con información adicional como etiquetas de clase.
Esta condición adicional permite al modelo generar datos que se adhieren a atributos específicos. Por lo tanto, si desea generar datos que sigan cierto criterio o desea tener más control sobre las características de los datos generados, el CVAE es particularmente útil.
Esto lo convierte en una excelente opción para tareas que requieren generación controlada, donde se necesita tener cierto grado de influencia sobre la salida.
Función Objetivo:
CVAE Loss=E
q(z∣x,y)
[−logp(x∣z,y)]+D
KL
(q(z∣x,y)∥p(z∣y))
En esta formulación, ( y ) representa la información de condicionamiento adicional (por ejemplo, etiquetas de clase).
Ejemplo: Implementación de Autoencoder Variacional Condicional (CVAE)
# Encoder network for CVAE
def build_cvae_encoder(input_shape, num_classes, latent_dim):
inputs = Input(shape=input_shape)
labels = Input(shape=(num_classes,))
x = Dense(512, activation='relu')(inputs)
x = tf.keras.layers.concatenate([x, labels])
x = Dense(256, activation='relu')(x)
z_mean = Dense(latent_dim, name='z_mean')(x)
z_log_var = Dense(latent_dim, name='z_log_var')(x)
z = Sampling()([z_mean, z_log_var])
return Model([inputs, labels], [z_mean, z_log_var, z], name='cvae_encoder')
# Decoder network for CVAE
def build_cvae_decoder(latent_dim, num_classes, output_shape):
latent_inputs = Input(shape=(latent_dim,))
labels = Input(shape=(num_classes,))
x = Dense(256, activation='relu')(latent_inputs)
x = tf.keras.layers.concatenate([x, labels])
x = Dense(512, activation='relu')(x)
outputs = Dense(output_shape, activation='sigmoid')(x)
return Model([latent_inputs, labels], outputs, name='cvae_decoder')
# Define the input shape, number of classes, and latent dimension
input_shape = (784,)
num_classes = 10
latent_dim = 2
# Build the encoder and decoder for CVAE
cvae_encoder = build_cvae_encoder(input_shape, num_classes, latent_dim)
cvae_decoder = build_cvae_decoder(latent_dim, num_classes, input_shape[0])
# Define the Conditional VAE model
inputs = Input(shape=input_shape)
labels = Input(shape=(num_classes,))
z_mean, z_log_var, z = cvae_encoder([inputs, labels])
outputs = cvae_decoder([z, labels])
cvae = Model([inputs, labels], outputs, name='cvae')
# Define the CVAE loss function
def cvae_loss(inputs, outputs, z_mean, z_log_var):
reconstruction_loss = tf.keras.losses.binary_crossentropy(inputs, outputs)
reconstruction_loss *= input_shape[0]
kl_loss = 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var)
kl_loss = K.sum(kl_loss, axis=-1)
kl_loss *= -0.5
return K.mean(reconstruction_loss + kl_loss)
# Compile the CVAE model
cvae.compile(optimizer='adam', loss=lambda x, y: cvae_loss(x, y, z_mean, z_log_var))
# Prepare the labels for training
y_train = tf.keras.utils.to_categorical(y_train, num_classes)
y_test = tf.keras.utils.to_categorical(y_test, num_classes)
# Train the CVAE model
cvae.fit([x_train, y_train], x_train, epochs=50, batch_size=128, validation_data=([x_test, y_test], x_test))En este ejemplo:
El script comienza definiendo una función para construir la parte del codificador del CVAE. El papel del codificador en un CVAE es tomar los datos de entrada y codificarlos en un espacio latente de menor dimensión. Esto se realiza utilizando capas densas (totalmente conectadas) y la función de activación 'relu'. La función del codificador recibe como argumentos la forma de entrada, el número de clases y la dimensión latente, y devuelve un modelo que realiza esta codificación.
Luego, el script define una función para construir la parte del decodificador del CVAE. El rol del decodificador es tomar un punto en el espacio latente y decodificarlo de vuelta al espacio de datos original. Al igual que el codificador, el decodificador se construye utilizando capas densas y la función de activación 'relu'. Recibe como argumentos la dimensión latente, el número de clases y la forma de salida, y devuelve un modelo que realiza esta decodificación.
Después de definir las funciones para construir el codificador y el decodificador, el script luego define los parámetros específicos para este CVAE, incluyendo la forma de entrada, el número de clases y la dimensión latente. Luego utiliza estos parámetros y las funciones definidas previamente para construir el codificador y el decodificador.
La siguiente parte del script define el modelo global del CVAE. Esto se hace primero definiendo capas de entrada para los datos de entrada y las etiquetas. Estos datos de entrada y etiquetas luego se pasan a través del codificador para obtener la media y la varianza logarítmica del espacio latente y un punto muestreado en el espacio latente. Este punto muestreado y las etiquetas luego se pasan a través del decodificador para obtener las salidas. El modelo CVAE se define entonces como tomando las entradas y etiquetas y produciendo estas salidas.
Luego, el script define una función de pérdida personalizada para el CVAE. Esta función de pérdida incluye tanto una pérdida de reconstrucción (que mide qué tan bien el decodificador puede reconstruir la entrada original desde el espacio latente) como una divergencia KL (que mide cuánto se desvía la distribución latente aprendida de la distribución prior). Esta función de pérdida luego se utiliza para compilar el modelo CVAE con el optimizador Adam.
La parte final del script prepara las etiquetas para el entrenamiento convirtiéndolas al formato categórico, y luego entrena el modelo CVAE utilizando los datos de entrenamiento, las etiquetas preparadas y la función de pérdida definida previamente. El modelo se entrena durante 50 épocas con un tamaño de lote de 128, y también se proporcionan datos de validación para que el modelo evalúe su rendimiento en datos invisibles.
Resumen
Las variaciones de los Autoencoders Variacionales (VAE), como Beta-VAE y el VAE Condicional (CVAE), amplían las capacidades de los VAE estándar introduciendo flexibilidad y control adicionales. Beta-VAE incorpora un hiperparámetro $(\beta)$ para equilibrar la compensación entre la pérdida de reconstrucción y la divergencia KL, fomentando representaciones disentanglement. El VAE Condicional (CVAE) permite la generación controlada de datos condicionando el modelo a información adicional, como etiquetas de clase.
Al implementar y experimentar con estas variaciones, puedes adaptar los VAE para que se ajusten mejor a tareas y aplicaciones específicas, mejorando la capacidad del modelo para aprender representaciones latentes significativas y generar datos de alta calidad. Esta comprensión integral de las variaciones de los VAE abre nuevas posibilidades para la investigación y aplicaciones prácticas en modelado generativo.
5.5 Variaciones de los VAEs (Beta-VAE, VAE Condicional)
Los Autoencoders Variacionales, o VAEs, han surgido como un marco fundamental y revolucionario en el mundo del aprendizaje automático. Se han desarrollado numerosas extensiones y modificaciones a partir de este modelo base, cada una con el objetivo de abordar desafíos específicos o mejorar aspectos particulares del modelo VAE original.
Este continuo desarrollo y avance en el campo ha hecho que estos modelos sean cada vez más completos y robustos. En esta sección, profundizaremos en los detalles de dos variaciones populares: el Beta-VAE y el VAE Condicional.
Estas adaptaciones del modelo VAE principal introducen un impresionante grado de flexibilidad adicional y control. Este mayor nivel de adaptabilidad amplía aún más el rango de aplicaciones para las cuales se pueden utilizar los modelos VAE, convirtiéndolos en una herramienta aún más poderosa en el campo del aprendizaje automático y el análisis de datos.
5.5.1 Beta-VAE
El Beta-VAE es un modelo innovador que introduce un nuevo hiperparámetro, denotado como $(\beta)$, en la función objetivo de un Autoencoder Variacional tradicional (VAE). Este elemento adicional proporciona un mayor control sobre el delicado equilibrio entre dos componentes clave de la función: la pérdida de reconstrucción y la divergencia KL (Kullback-Leibler).
La pérdida de reconstrucción se refiere a la capacidad del modelo para recrear los datos de entrada, mientras que la divergencia KL mide la diferencia entre la distribución de probabilidad aprendida por el modelo y la verdadera distribución.
Ajustando cuidadosamente el valor de $(\beta)$, el modelo Beta-VAE puede fomentar de manera más efectiva el aprendizaje de representaciones disentangled (desenredadas) dentro del espacio latente. Las representaciones desenredadas pueden conducir a una mejor interpretabilidad y robustez en el modelo, haciendo que el Beta-VAE sea un avance significativo en el campo.
Función Objetivo:
Beta-VAE Loss=Reconstruction Loss+β×KL Divergence
Un valor más alto de ( \beta ) coloca más énfasis en el término de divergencia KL, promoviendo el desenredamiento a expensas de la calidad de la reconstrucción. Por el contrario, un valor más bajo de ( \beta ) prioriza la precisión de la reconstrucción.
Ejemplo: Implementación de Beta-VAE
import tensorflow as tf
from tensorflow.keras.layers import Input, Dense, Lambda, Layer
from tensorflow.keras.models import Model
from tensorflow.keras import backend as K
# Sampling layer using the reparameterization trick
class Sampling(Layer):
def call(self, inputs):
z_mean, z_log_var = inputs
batch = tf.shape(z_mean)[0]
dim = tf.shape(z_mean)[1]
epsilon = K.random_normal(shape=(batch, dim))
return z_mean + K.exp(0.5 * z_log_var) * epsilon
# Encoder network
def build_encoder(input_shape, latent_dim):
inputs = Input(shape=input_shape)
x = Dense(512, activation='relu')(inputs)
x = Dense(256, activation='relu')(x)
z_mean = Dense(latent_dim, name='z_mean')(x)
z_log_var = Dense(latent_dim, name='z_log_var')(x)
z = Sampling()([z_mean, z_log_var])
return Model(inputs, [z_mean, z_log_var, z], name='encoder')
# Decoder network
def build_decoder(latent_dim, output_shape):
latent_inputs = Input(shape=(latent_dim,))
x = Dense(256, activation='relu')(latent_inputs)
x = Dense(512, activation='relu')(x)
outputs = Dense(output_shape, activation='sigmoid')(x)
return Model(latent_inputs, outputs, name='decoder')
# Define the input shape and latent dimension
input_shape = (784,)
latent_dim = 2
# Build the encoder and decoder
encoder = build_encoder(input_shape, latent_dim)
decoder = build_decoder(latent_dim, input_shape[0])
# Define the Beta-VAE model
inputs = Input(shape=input_shape)
z_mean, z_log_var, z = encoder(inputs)
outputs = decoder(z)
beta_vae = Model(inputs, outputs, name='beta_vae')
# Define the Beta-VAE loss function
def beta_vae_loss(inputs, outputs, z_mean, z_log_var, beta=1.0):
reconstruction_loss = tf.keras.losses.binary_crossentropy(inputs, outputs)
reconstruction_loss *= input_shape[0]
kl_loss = 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var)
kl_loss = K.sum(kl_loss, axis=-1)
kl_loss *= -0.5
return K.mean(reconstruction_loss + beta * kl_loss)
# Compile the Beta-VAE model
beta_vae.compile(optimizer='adam', loss=lambda x, y: beta_vae_loss(x, y, z_mean, z_log_var, beta=4.0))
# Train the Beta-VAE model
beta_vae.fit(x_train, x_train, epochs=50, batch_size=128, validation_data=(x_test, x_test))En este ejemplo:
El script primero importa las bibliotecas necesarias y define una capa de Muestreo, que se utiliza para extraer muestras aleatorias del espacio latente usando el truco de reparametrización.
Luego, define funciones para construir las partes del codificador y decodificador del VAE, cada una de las cuales es una red neuronal profunda. El codificador transforma la entrada en una representación latente, y el decodificador reconstruye la entrada original a partir de la representación latente.
A continuación, se definen la forma de entrada y la dimensión latente, y se construyen el codificador y el decodificador utilizando estos parámetros.
Luego se define el modelo Beta-VAE, conectando las redes del codificador y decodificador.
A continuación, se define una función de pérdida personalizada para el Beta-VAE, que incluye tanto la pérdida de reconstrucción como la divergencia Kullback-Leibler (KL). La divergencia KL mide cuánto se desvía la distribución latente aprendida de la distribución prior. El factor 'beta' controla el equilibrio entre la pérdida de reconstrucción y la divergencia KL.
Finalmente, se compila y entrena el modelo Beta-VAE utilizando la función de pérdida definida, un optimizador 'adam', y datos de entrenamiento y prueba.
5.5.2 Variational Autoencoder Condicional (CVAE)
El Autoencoder Variacional Condicional (CVAE) es una extensión del Autoencoder Variacional estándar (VAE), un modelo generativo popular. El CVAE mejora la funcionalidad del VAE al condicionar tanto el codificador, que se encarga de comprimir los datos de entrada en una representación latente, como el decodificador, que reconstruye los datos originales a partir de esta representación latente, con información adicional como etiquetas de clase.
Esta condición adicional permite al modelo generar datos que se adhieren a atributos específicos. Por lo tanto, si desea generar datos que sigan cierto criterio o desea tener más control sobre las características de los datos generados, el CVAE es particularmente útil.
Esto lo convierte en una excelente opción para tareas que requieren generación controlada, donde se necesita tener cierto grado de influencia sobre la salida.
Función Objetivo:
CVAE Loss=E
q(z∣x,y)
[−logp(x∣z,y)]+D
KL
(q(z∣x,y)∥p(z∣y))
En esta formulación, ( y ) representa la información de condicionamiento adicional (por ejemplo, etiquetas de clase).
Ejemplo: Implementación de Autoencoder Variacional Condicional (CVAE)
# Encoder network for CVAE
def build_cvae_encoder(input_shape, num_classes, latent_dim):
inputs = Input(shape=input_shape)
labels = Input(shape=(num_classes,))
x = Dense(512, activation='relu')(inputs)
x = tf.keras.layers.concatenate([x, labels])
x = Dense(256, activation='relu')(x)
z_mean = Dense(latent_dim, name='z_mean')(x)
z_log_var = Dense(latent_dim, name='z_log_var')(x)
z = Sampling()([z_mean, z_log_var])
return Model([inputs, labels], [z_mean, z_log_var, z], name='cvae_encoder')
# Decoder network for CVAE
def build_cvae_decoder(latent_dim, num_classes, output_shape):
latent_inputs = Input(shape=(latent_dim,))
labels = Input(shape=(num_classes,))
x = Dense(256, activation='relu')(latent_inputs)
x = tf.keras.layers.concatenate([x, labels])
x = Dense(512, activation='relu')(x)
outputs = Dense(output_shape, activation='sigmoid')(x)
return Model([latent_inputs, labels], outputs, name='cvae_decoder')
# Define the input shape, number of classes, and latent dimension
input_shape = (784,)
num_classes = 10
latent_dim = 2
# Build the encoder and decoder for CVAE
cvae_encoder = build_cvae_encoder(input_shape, num_classes, latent_dim)
cvae_decoder = build_cvae_decoder(latent_dim, num_classes, input_shape[0])
# Define the Conditional VAE model
inputs = Input(shape=input_shape)
labels = Input(shape=(num_classes,))
z_mean, z_log_var, z = cvae_encoder([inputs, labels])
outputs = cvae_decoder([z, labels])
cvae = Model([inputs, labels], outputs, name='cvae')
# Define the CVAE loss function
def cvae_loss(inputs, outputs, z_mean, z_log_var):
reconstruction_loss = tf.keras.losses.binary_crossentropy(inputs, outputs)
reconstruction_loss *= input_shape[0]
kl_loss = 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var)
kl_loss = K.sum(kl_loss, axis=-1)
kl_loss *= -0.5
return K.mean(reconstruction_loss + kl_loss)
# Compile the CVAE model
cvae.compile(optimizer='adam', loss=lambda x, y: cvae_loss(x, y, z_mean, z_log_var))
# Prepare the labels for training
y_train = tf.keras.utils.to_categorical(y_train, num_classes)
y_test = tf.keras.utils.to_categorical(y_test, num_classes)
# Train the CVAE model
cvae.fit([x_train, y_train], x_train, epochs=50, batch_size=128, validation_data=([x_test, y_test], x_test))En este ejemplo:
El script comienza definiendo una función para construir la parte del codificador del CVAE. El papel del codificador en un CVAE es tomar los datos de entrada y codificarlos en un espacio latente de menor dimensión. Esto se realiza utilizando capas densas (totalmente conectadas) y la función de activación 'relu'. La función del codificador recibe como argumentos la forma de entrada, el número de clases y la dimensión latente, y devuelve un modelo que realiza esta codificación.
Luego, el script define una función para construir la parte del decodificador del CVAE. El rol del decodificador es tomar un punto en el espacio latente y decodificarlo de vuelta al espacio de datos original. Al igual que el codificador, el decodificador se construye utilizando capas densas y la función de activación 'relu'. Recibe como argumentos la dimensión latente, el número de clases y la forma de salida, y devuelve un modelo que realiza esta decodificación.
Después de definir las funciones para construir el codificador y el decodificador, el script luego define los parámetros específicos para este CVAE, incluyendo la forma de entrada, el número de clases y la dimensión latente. Luego utiliza estos parámetros y las funciones definidas previamente para construir el codificador y el decodificador.
La siguiente parte del script define el modelo global del CVAE. Esto se hace primero definiendo capas de entrada para los datos de entrada y las etiquetas. Estos datos de entrada y etiquetas luego se pasan a través del codificador para obtener la media y la varianza logarítmica del espacio latente y un punto muestreado en el espacio latente. Este punto muestreado y las etiquetas luego se pasan a través del decodificador para obtener las salidas. El modelo CVAE se define entonces como tomando las entradas y etiquetas y produciendo estas salidas.
Luego, el script define una función de pérdida personalizada para el CVAE. Esta función de pérdida incluye tanto una pérdida de reconstrucción (que mide qué tan bien el decodificador puede reconstruir la entrada original desde el espacio latente) como una divergencia KL (que mide cuánto se desvía la distribución latente aprendida de la distribución prior). Esta función de pérdida luego se utiliza para compilar el modelo CVAE con el optimizador Adam.
La parte final del script prepara las etiquetas para el entrenamiento convirtiéndolas al formato categórico, y luego entrena el modelo CVAE utilizando los datos de entrenamiento, las etiquetas preparadas y la función de pérdida definida previamente. El modelo se entrena durante 50 épocas con un tamaño de lote de 128, y también se proporcionan datos de validación para que el modelo evalúe su rendimiento en datos invisibles.
Resumen
Las variaciones de los Autoencoders Variacionales (VAE), como Beta-VAE y el VAE Condicional (CVAE), amplían las capacidades de los VAE estándar introduciendo flexibilidad y control adicionales. Beta-VAE incorpora un hiperparámetro $(\beta)$ para equilibrar la compensación entre la pérdida de reconstrucción y la divergencia KL, fomentando representaciones disentanglement. El VAE Condicional (CVAE) permite la generación controlada de datos condicionando el modelo a información adicional, como etiquetas de clase.
Al implementar y experimentar con estas variaciones, puedes adaptar los VAE para que se ajusten mejor a tareas y aplicaciones específicas, mejorando la capacidad del modelo para aprender representaciones latentes significativas y generar datos de alta calidad. Esta comprensión integral de las variaciones de los VAE abre nuevas posibilidades para la investigación y aplicaciones prácticas en modelado generativo.
5.5 Variaciones de los VAEs (Beta-VAE, VAE Condicional)
Los Autoencoders Variacionales, o VAEs, han surgido como un marco fundamental y revolucionario en el mundo del aprendizaje automático. Se han desarrollado numerosas extensiones y modificaciones a partir de este modelo base, cada una con el objetivo de abordar desafíos específicos o mejorar aspectos particulares del modelo VAE original.
Este continuo desarrollo y avance en el campo ha hecho que estos modelos sean cada vez más completos y robustos. En esta sección, profundizaremos en los detalles de dos variaciones populares: el Beta-VAE y el VAE Condicional.
Estas adaptaciones del modelo VAE principal introducen un impresionante grado de flexibilidad adicional y control. Este mayor nivel de adaptabilidad amplía aún más el rango de aplicaciones para las cuales se pueden utilizar los modelos VAE, convirtiéndolos en una herramienta aún más poderosa en el campo del aprendizaje automático y el análisis de datos.
5.5.1 Beta-VAE
El Beta-VAE es un modelo innovador que introduce un nuevo hiperparámetro, denotado como $(\beta)$, en la función objetivo de un Autoencoder Variacional tradicional (VAE). Este elemento adicional proporciona un mayor control sobre el delicado equilibrio entre dos componentes clave de la función: la pérdida de reconstrucción y la divergencia KL (Kullback-Leibler).
La pérdida de reconstrucción se refiere a la capacidad del modelo para recrear los datos de entrada, mientras que la divergencia KL mide la diferencia entre la distribución de probabilidad aprendida por el modelo y la verdadera distribución.
Ajustando cuidadosamente el valor de $(\beta)$, el modelo Beta-VAE puede fomentar de manera más efectiva el aprendizaje de representaciones disentangled (desenredadas) dentro del espacio latente. Las representaciones desenredadas pueden conducir a una mejor interpretabilidad y robustez en el modelo, haciendo que el Beta-VAE sea un avance significativo en el campo.
Función Objetivo:
Beta-VAE Loss=Reconstruction Loss+β×KL Divergence
Un valor más alto de ( \beta ) coloca más énfasis en el término de divergencia KL, promoviendo el desenredamiento a expensas de la calidad de la reconstrucción. Por el contrario, un valor más bajo de ( \beta ) prioriza la precisión de la reconstrucción.
Ejemplo: Implementación de Beta-VAE
import tensorflow as tf
from tensorflow.keras.layers import Input, Dense, Lambda, Layer
from tensorflow.keras.models import Model
from tensorflow.keras import backend as K
# Sampling layer using the reparameterization trick
class Sampling(Layer):
def call(self, inputs):
z_mean, z_log_var = inputs
batch = tf.shape(z_mean)[0]
dim = tf.shape(z_mean)[1]
epsilon = K.random_normal(shape=(batch, dim))
return z_mean + K.exp(0.5 * z_log_var) * epsilon
# Encoder network
def build_encoder(input_shape, latent_dim):
inputs = Input(shape=input_shape)
x = Dense(512, activation='relu')(inputs)
x = Dense(256, activation='relu')(x)
z_mean = Dense(latent_dim, name='z_mean')(x)
z_log_var = Dense(latent_dim, name='z_log_var')(x)
z = Sampling()([z_mean, z_log_var])
return Model(inputs, [z_mean, z_log_var, z], name='encoder')
# Decoder network
def build_decoder(latent_dim, output_shape):
latent_inputs = Input(shape=(latent_dim,))
x = Dense(256, activation='relu')(latent_inputs)
x = Dense(512, activation='relu')(x)
outputs = Dense(output_shape, activation='sigmoid')(x)
return Model(latent_inputs, outputs, name='decoder')
# Define the input shape and latent dimension
input_shape = (784,)
latent_dim = 2
# Build the encoder and decoder
encoder = build_encoder(input_shape, latent_dim)
decoder = build_decoder(latent_dim, input_shape[0])
# Define the Beta-VAE model
inputs = Input(shape=input_shape)
z_mean, z_log_var, z = encoder(inputs)
outputs = decoder(z)
beta_vae = Model(inputs, outputs, name='beta_vae')
# Define the Beta-VAE loss function
def beta_vae_loss(inputs, outputs, z_mean, z_log_var, beta=1.0):
reconstruction_loss = tf.keras.losses.binary_crossentropy(inputs, outputs)
reconstruction_loss *= input_shape[0]
kl_loss = 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var)
kl_loss = K.sum(kl_loss, axis=-1)
kl_loss *= -0.5
return K.mean(reconstruction_loss + beta * kl_loss)
# Compile the Beta-VAE model
beta_vae.compile(optimizer='adam', loss=lambda x, y: beta_vae_loss(x, y, z_mean, z_log_var, beta=4.0))
# Train the Beta-VAE model
beta_vae.fit(x_train, x_train, epochs=50, batch_size=128, validation_data=(x_test, x_test))En este ejemplo:
El script primero importa las bibliotecas necesarias y define una capa de Muestreo, que se utiliza para extraer muestras aleatorias del espacio latente usando el truco de reparametrización.
Luego, define funciones para construir las partes del codificador y decodificador del VAE, cada una de las cuales es una red neuronal profunda. El codificador transforma la entrada en una representación latente, y el decodificador reconstruye la entrada original a partir de la representación latente.
A continuación, se definen la forma de entrada y la dimensión latente, y se construyen el codificador y el decodificador utilizando estos parámetros.
Luego se define el modelo Beta-VAE, conectando las redes del codificador y decodificador.
A continuación, se define una función de pérdida personalizada para el Beta-VAE, que incluye tanto la pérdida de reconstrucción como la divergencia Kullback-Leibler (KL). La divergencia KL mide cuánto se desvía la distribución latente aprendida de la distribución prior. El factor 'beta' controla el equilibrio entre la pérdida de reconstrucción y la divergencia KL.
Finalmente, se compila y entrena el modelo Beta-VAE utilizando la función de pérdida definida, un optimizador 'adam', y datos de entrenamiento y prueba.
5.5.2 Variational Autoencoder Condicional (CVAE)
El Autoencoder Variacional Condicional (CVAE) es una extensión del Autoencoder Variacional estándar (VAE), un modelo generativo popular. El CVAE mejora la funcionalidad del VAE al condicionar tanto el codificador, que se encarga de comprimir los datos de entrada en una representación latente, como el decodificador, que reconstruye los datos originales a partir de esta representación latente, con información adicional como etiquetas de clase.
Esta condición adicional permite al modelo generar datos que se adhieren a atributos específicos. Por lo tanto, si desea generar datos que sigan cierto criterio o desea tener más control sobre las características de los datos generados, el CVAE es particularmente útil.
Esto lo convierte en una excelente opción para tareas que requieren generación controlada, donde se necesita tener cierto grado de influencia sobre la salida.
Función Objetivo:
CVAE Loss=E
q(z∣x,y)
[−logp(x∣z,y)]+D
KL
(q(z∣x,y)∥p(z∣y))
En esta formulación, ( y ) representa la información de condicionamiento adicional (por ejemplo, etiquetas de clase).
Ejemplo: Implementación de Autoencoder Variacional Condicional (CVAE)
# Encoder network for CVAE
def build_cvae_encoder(input_shape, num_classes, latent_dim):
inputs = Input(shape=input_shape)
labels = Input(shape=(num_classes,))
x = Dense(512, activation='relu')(inputs)
x = tf.keras.layers.concatenate([x, labels])
x = Dense(256, activation='relu')(x)
z_mean = Dense(latent_dim, name='z_mean')(x)
z_log_var = Dense(latent_dim, name='z_log_var')(x)
z = Sampling()([z_mean, z_log_var])
return Model([inputs, labels], [z_mean, z_log_var, z], name='cvae_encoder')
# Decoder network for CVAE
def build_cvae_decoder(latent_dim, num_classes, output_shape):
latent_inputs = Input(shape=(latent_dim,))
labels = Input(shape=(num_classes,))
x = Dense(256, activation='relu')(latent_inputs)
x = tf.keras.layers.concatenate([x, labels])
x = Dense(512, activation='relu')(x)
outputs = Dense(output_shape, activation='sigmoid')(x)
return Model([latent_inputs, labels], outputs, name='cvae_decoder')
# Define the input shape, number of classes, and latent dimension
input_shape = (784,)
num_classes = 10
latent_dim = 2
# Build the encoder and decoder for CVAE
cvae_encoder = build_cvae_encoder(input_shape, num_classes, latent_dim)
cvae_decoder = build_cvae_decoder(latent_dim, num_classes, input_shape[0])
# Define the Conditional VAE model
inputs = Input(shape=input_shape)
labels = Input(shape=(num_classes,))
z_mean, z_log_var, z = cvae_encoder([inputs, labels])
outputs = cvae_decoder([z, labels])
cvae = Model([inputs, labels], outputs, name='cvae')
# Define the CVAE loss function
def cvae_loss(inputs, outputs, z_mean, z_log_var):
reconstruction_loss = tf.keras.losses.binary_crossentropy(inputs, outputs)
reconstruction_loss *= input_shape[0]
kl_loss = 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var)
kl_loss = K.sum(kl_loss, axis=-1)
kl_loss *= -0.5
return K.mean(reconstruction_loss + kl_loss)
# Compile the CVAE model
cvae.compile(optimizer='adam', loss=lambda x, y: cvae_loss(x, y, z_mean, z_log_var))
# Prepare the labels for training
y_train = tf.keras.utils.to_categorical(y_train, num_classes)
y_test = tf.keras.utils.to_categorical(y_test, num_classes)
# Train the CVAE model
cvae.fit([x_train, y_train], x_train, epochs=50, batch_size=128, validation_data=([x_test, y_test], x_test))En este ejemplo:
El script comienza definiendo una función para construir la parte del codificador del CVAE. El papel del codificador en un CVAE es tomar los datos de entrada y codificarlos en un espacio latente de menor dimensión. Esto se realiza utilizando capas densas (totalmente conectadas) y la función de activación 'relu'. La función del codificador recibe como argumentos la forma de entrada, el número de clases y la dimensión latente, y devuelve un modelo que realiza esta codificación.
Luego, el script define una función para construir la parte del decodificador del CVAE. El rol del decodificador es tomar un punto en el espacio latente y decodificarlo de vuelta al espacio de datos original. Al igual que el codificador, el decodificador se construye utilizando capas densas y la función de activación 'relu'. Recibe como argumentos la dimensión latente, el número de clases y la forma de salida, y devuelve un modelo que realiza esta decodificación.
Después de definir las funciones para construir el codificador y el decodificador, el script luego define los parámetros específicos para este CVAE, incluyendo la forma de entrada, el número de clases y la dimensión latente. Luego utiliza estos parámetros y las funciones definidas previamente para construir el codificador y el decodificador.
La siguiente parte del script define el modelo global del CVAE. Esto se hace primero definiendo capas de entrada para los datos de entrada y las etiquetas. Estos datos de entrada y etiquetas luego se pasan a través del codificador para obtener la media y la varianza logarítmica del espacio latente y un punto muestreado en el espacio latente. Este punto muestreado y las etiquetas luego se pasan a través del decodificador para obtener las salidas. El modelo CVAE se define entonces como tomando las entradas y etiquetas y produciendo estas salidas.
Luego, el script define una función de pérdida personalizada para el CVAE. Esta función de pérdida incluye tanto una pérdida de reconstrucción (que mide qué tan bien el decodificador puede reconstruir la entrada original desde el espacio latente) como una divergencia KL (que mide cuánto se desvía la distribución latente aprendida de la distribución prior). Esta función de pérdida luego se utiliza para compilar el modelo CVAE con el optimizador Adam.
La parte final del script prepara las etiquetas para el entrenamiento convirtiéndolas al formato categórico, y luego entrena el modelo CVAE utilizando los datos de entrenamiento, las etiquetas preparadas y la función de pérdida definida previamente. El modelo se entrena durante 50 épocas con un tamaño de lote de 128, y también se proporcionan datos de validación para que el modelo evalúe su rendimiento en datos invisibles.
Resumen
Las variaciones de los Autoencoders Variacionales (VAE), como Beta-VAE y el VAE Condicional (CVAE), amplían las capacidades de los VAE estándar introduciendo flexibilidad y control adicionales. Beta-VAE incorpora un hiperparámetro $(\beta)$ para equilibrar la compensación entre la pérdida de reconstrucción y la divergencia KL, fomentando representaciones disentanglement. El VAE Condicional (CVAE) permite la generación controlada de datos condicionando el modelo a información adicional, como etiquetas de clase.
Al implementar y experimentar con estas variaciones, puedes adaptar los VAE para que se ajusten mejor a tareas y aplicaciones específicas, mejorando la capacidad del modelo para aprender representaciones latentes significativas y generar datos de alta calidad. Esta comprensión integral de las variaciones de los VAE abre nuevas posibilidades para la investigación y aplicaciones prácticas en modelado generativo.
5.5 Variaciones de los VAEs (Beta-VAE, VAE Condicional)
Los Autoencoders Variacionales, o VAEs, han surgido como un marco fundamental y revolucionario en el mundo del aprendizaje automático. Se han desarrollado numerosas extensiones y modificaciones a partir de este modelo base, cada una con el objetivo de abordar desafíos específicos o mejorar aspectos particulares del modelo VAE original.
Este continuo desarrollo y avance en el campo ha hecho que estos modelos sean cada vez más completos y robustos. En esta sección, profundizaremos en los detalles de dos variaciones populares: el Beta-VAE y el VAE Condicional.
Estas adaptaciones del modelo VAE principal introducen un impresionante grado de flexibilidad adicional y control. Este mayor nivel de adaptabilidad amplía aún más el rango de aplicaciones para las cuales se pueden utilizar los modelos VAE, convirtiéndolos en una herramienta aún más poderosa en el campo del aprendizaje automático y el análisis de datos.
5.5.1 Beta-VAE
El Beta-VAE es un modelo innovador que introduce un nuevo hiperparámetro, denotado como $(\beta)$, en la función objetivo de un Autoencoder Variacional tradicional (VAE). Este elemento adicional proporciona un mayor control sobre el delicado equilibrio entre dos componentes clave de la función: la pérdida de reconstrucción y la divergencia KL (Kullback-Leibler).
La pérdida de reconstrucción se refiere a la capacidad del modelo para recrear los datos de entrada, mientras que la divergencia KL mide la diferencia entre la distribución de probabilidad aprendida por el modelo y la verdadera distribución.
Ajustando cuidadosamente el valor de $(\beta)$, el modelo Beta-VAE puede fomentar de manera más efectiva el aprendizaje de representaciones disentangled (desenredadas) dentro del espacio latente. Las representaciones desenredadas pueden conducir a una mejor interpretabilidad y robustez en el modelo, haciendo que el Beta-VAE sea un avance significativo en el campo.
Función Objetivo:
Beta-VAE Loss=Reconstruction Loss+β×KL Divergence
Un valor más alto de ( \beta ) coloca más énfasis en el término de divergencia KL, promoviendo el desenredamiento a expensas de la calidad de la reconstrucción. Por el contrario, un valor más bajo de ( \beta ) prioriza la precisión de la reconstrucción.
Ejemplo: Implementación de Beta-VAE
import tensorflow as tf
from tensorflow.keras.layers import Input, Dense, Lambda, Layer
from tensorflow.keras.models import Model
from tensorflow.keras import backend as K
# Sampling layer using the reparameterization trick
class Sampling(Layer):
def call(self, inputs):
z_mean, z_log_var = inputs
batch = tf.shape(z_mean)[0]
dim = tf.shape(z_mean)[1]
epsilon = K.random_normal(shape=(batch, dim))
return z_mean + K.exp(0.5 * z_log_var) * epsilon
# Encoder network
def build_encoder(input_shape, latent_dim):
inputs = Input(shape=input_shape)
x = Dense(512, activation='relu')(inputs)
x = Dense(256, activation='relu')(x)
z_mean = Dense(latent_dim, name='z_mean')(x)
z_log_var = Dense(latent_dim, name='z_log_var')(x)
z = Sampling()([z_mean, z_log_var])
return Model(inputs, [z_mean, z_log_var, z], name='encoder')
# Decoder network
def build_decoder(latent_dim, output_shape):
latent_inputs = Input(shape=(latent_dim,))
x = Dense(256, activation='relu')(latent_inputs)
x = Dense(512, activation='relu')(x)
outputs = Dense(output_shape, activation='sigmoid')(x)
return Model(latent_inputs, outputs, name='decoder')
# Define the input shape and latent dimension
input_shape = (784,)
latent_dim = 2
# Build the encoder and decoder
encoder = build_encoder(input_shape, latent_dim)
decoder = build_decoder(latent_dim, input_shape[0])
# Define the Beta-VAE model
inputs = Input(shape=input_shape)
z_mean, z_log_var, z = encoder(inputs)
outputs = decoder(z)
beta_vae = Model(inputs, outputs, name='beta_vae')
# Define the Beta-VAE loss function
def beta_vae_loss(inputs, outputs, z_mean, z_log_var, beta=1.0):
reconstruction_loss = tf.keras.losses.binary_crossentropy(inputs, outputs)
reconstruction_loss *= input_shape[0]
kl_loss = 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var)
kl_loss = K.sum(kl_loss, axis=-1)
kl_loss *= -0.5
return K.mean(reconstruction_loss + beta * kl_loss)
# Compile the Beta-VAE model
beta_vae.compile(optimizer='adam', loss=lambda x, y: beta_vae_loss(x, y, z_mean, z_log_var, beta=4.0))
# Train the Beta-VAE model
beta_vae.fit(x_train, x_train, epochs=50, batch_size=128, validation_data=(x_test, x_test))En este ejemplo:
El script primero importa las bibliotecas necesarias y define una capa de Muestreo, que se utiliza para extraer muestras aleatorias del espacio latente usando el truco de reparametrización.
Luego, define funciones para construir las partes del codificador y decodificador del VAE, cada una de las cuales es una red neuronal profunda. El codificador transforma la entrada en una representación latente, y el decodificador reconstruye la entrada original a partir de la representación latente.
A continuación, se definen la forma de entrada y la dimensión latente, y se construyen el codificador y el decodificador utilizando estos parámetros.
Luego se define el modelo Beta-VAE, conectando las redes del codificador y decodificador.
A continuación, se define una función de pérdida personalizada para el Beta-VAE, que incluye tanto la pérdida de reconstrucción como la divergencia Kullback-Leibler (KL). La divergencia KL mide cuánto se desvía la distribución latente aprendida de la distribución prior. El factor 'beta' controla el equilibrio entre la pérdida de reconstrucción y la divergencia KL.
Finalmente, se compila y entrena el modelo Beta-VAE utilizando la función de pérdida definida, un optimizador 'adam', y datos de entrenamiento y prueba.
5.5.2 Variational Autoencoder Condicional (CVAE)
El Autoencoder Variacional Condicional (CVAE) es una extensión del Autoencoder Variacional estándar (VAE), un modelo generativo popular. El CVAE mejora la funcionalidad del VAE al condicionar tanto el codificador, que se encarga de comprimir los datos de entrada en una representación latente, como el decodificador, que reconstruye los datos originales a partir de esta representación latente, con información adicional como etiquetas de clase.
Esta condición adicional permite al modelo generar datos que se adhieren a atributos específicos. Por lo tanto, si desea generar datos que sigan cierto criterio o desea tener más control sobre las características de los datos generados, el CVAE es particularmente útil.
Esto lo convierte en una excelente opción para tareas que requieren generación controlada, donde se necesita tener cierto grado de influencia sobre la salida.
Función Objetivo:
CVAE Loss=E
q(z∣x,y)
[−logp(x∣z,y)]+D
KL
(q(z∣x,y)∥p(z∣y))
En esta formulación, ( y ) representa la información de condicionamiento adicional (por ejemplo, etiquetas de clase).
Ejemplo: Implementación de Autoencoder Variacional Condicional (CVAE)
# Encoder network for CVAE
def build_cvae_encoder(input_shape, num_classes, latent_dim):
inputs = Input(shape=input_shape)
labels = Input(shape=(num_classes,))
x = Dense(512, activation='relu')(inputs)
x = tf.keras.layers.concatenate([x, labels])
x = Dense(256, activation='relu')(x)
z_mean = Dense(latent_dim, name='z_mean')(x)
z_log_var = Dense(latent_dim, name='z_log_var')(x)
z = Sampling()([z_mean, z_log_var])
return Model([inputs, labels], [z_mean, z_log_var, z], name='cvae_encoder')
# Decoder network for CVAE
def build_cvae_decoder(latent_dim, num_classes, output_shape):
latent_inputs = Input(shape=(latent_dim,))
labels = Input(shape=(num_classes,))
x = Dense(256, activation='relu')(latent_inputs)
x = tf.keras.layers.concatenate([x, labels])
x = Dense(512, activation='relu')(x)
outputs = Dense(output_shape, activation='sigmoid')(x)
return Model([latent_inputs, labels], outputs, name='cvae_decoder')
# Define the input shape, number of classes, and latent dimension
input_shape = (784,)
num_classes = 10
latent_dim = 2
# Build the encoder and decoder for CVAE
cvae_encoder = build_cvae_encoder(input_shape, num_classes, latent_dim)
cvae_decoder = build_cvae_decoder(latent_dim, num_classes, input_shape[0])
# Define the Conditional VAE model
inputs = Input(shape=input_shape)
labels = Input(shape=(num_classes,))
z_mean, z_log_var, z = cvae_encoder([inputs, labels])
outputs = cvae_decoder([z, labels])
cvae = Model([inputs, labels], outputs, name='cvae')
# Define the CVAE loss function
def cvae_loss(inputs, outputs, z_mean, z_log_var):
reconstruction_loss = tf.keras.losses.binary_crossentropy(inputs, outputs)
reconstruction_loss *= input_shape[0]
kl_loss = 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var)
kl_loss = K.sum(kl_loss, axis=-1)
kl_loss *= -0.5
return K.mean(reconstruction_loss + kl_loss)
# Compile the CVAE model
cvae.compile(optimizer='adam', loss=lambda x, y: cvae_loss(x, y, z_mean, z_log_var))
# Prepare the labels for training
y_train = tf.keras.utils.to_categorical(y_train, num_classes)
y_test = tf.keras.utils.to_categorical(y_test, num_classes)
# Train the CVAE model
cvae.fit([x_train, y_train], x_train, epochs=50, batch_size=128, validation_data=([x_test, y_test], x_test))En este ejemplo:
El script comienza definiendo una función para construir la parte del codificador del CVAE. El papel del codificador en un CVAE es tomar los datos de entrada y codificarlos en un espacio latente de menor dimensión. Esto se realiza utilizando capas densas (totalmente conectadas) y la función de activación 'relu'. La función del codificador recibe como argumentos la forma de entrada, el número de clases y la dimensión latente, y devuelve un modelo que realiza esta codificación.
Luego, el script define una función para construir la parte del decodificador del CVAE. El rol del decodificador es tomar un punto en el espacio latente y decodificarlo de vuelta al espacio de datos original. Al igual que el codificador, el decodificador se construye utilizando capas densas y la función de activación 'relu'. Recibe como argumentos la dimensión latente, el número de clases y la forma de salida, y devuelve un modelo que realiza esta decodificación.
Después de definir las funciones para construir el codificador y el decodificador, el script luego define los parámetros específicos para este CVAE, incluyendo la forma de entrada, el número de clases y la dimensión latente. Luego utiliza estos parámetros y las funciones definidas previamente para construir el codificador y el decodificador.
La siguiente parte del script define el modelo global del CVAE. Esto se hace primero definiendo capas de entrada para los datos de entrada y las etiquetas. Estos datos de entrada y etiquetas luego se pasan a través del codificador para obtener la media y la varianza logarítmica del espacio latente y un punto muestreado en el espacio latente. Este punto muestreado y las etiquetas luego se pasan a través del decodificador para obtener las salidas. El modelo CVAE se define entonces como tomando las entradas y etiquetas y produciendo estas salidas.
Luego, el script define una función de pérdida personalizada para el CVAE. Esta función de pérdida incluye tanto una pérdida de reconstrucción (que mide qué tan bien el decodificador puede reconstruir la entrada original desde el espacio latente) como una divergencia KL (que mide cuánto se desvía la distribución latente aprendida de la distribución prior). Esta función de pérdida luego se utiliza para compilar el modelo CVAE con el optimizador Adam.
La parte final del script prepara las etiquetas para el entrenamiento convirtiéndolas al formato categórico, y luego entrena el modelo CVAE utilizando los datos de entrenamiento, las etiquetas preparadas y la función de pérdida definida previamente. El modelo se entrena durante 50 épocas con un tamaño de lote de 128, y también se proporcionan datos de validación para que el modelo evalúe su rendimiento en datos invisibles.
Resumen
Las variaciones de los Autoencoders Variacionales (VAE), como Beta-VAE y el VAE Condicional (CVAE), amplían las capacidades de los VAE estándar introduciendo flexibilidad y control adicionales. Beta-VAE incorpora un hiperparámetro $(\beta)$ para equilibrar la compensación entre la pérdida de reconstrucción y la divergencia KL, fomentando representaciones disentanglement. El VAE Condicional (CVAE) permite la generación controlada de datos condicionando el modelo a información adicional, como etiquetas de clase.
Al implementar y experimentar con estas variaciones, puedes adaptar los VAE para que se ajusten mejor a tareas y aplicaciones específicas, mejorando la capacidad del modelo para aprender representaciones latentes significativas y generar datos de alta calidad. Esta comprensión integral de las variaciones de los VAE abre nuevas posibilidades para la investigación y aplicaciones prácticas en modelado generativo.