Capítulo 6: Proyecto: Generación de Dígitos Manuscritos con VAEs
6.4 Evaluación del Modelo
Evaluar el rendimiento de un Autoencoder Variacional (VAE) es crucial para asegurar que ha aprendido representaciones latentes significativas y puede generar imágenes de alta calidad. En esta sección, discutiremos varios métodos para evaluar nuestro VAE, incluyendo métricas cuantitativas y evaluaciones cualitativas. También proporcionaremos ejemplos de código para demostrar estas técnicas de evaluación.
6.4.1 Métricas Cuantitativas de Evaluación
Las métricas cuantitativas proporcionan medidas objetivas del rendimiento del modelo. Para los VAEs, algunas métricas comunes incluyen la pérdida de reconstrucción, la divergencia KL, la puntuación de Inception (IS) y la distancia de Inception de Fréchet (FID).
Pérdida de Reconstrucción
La pérdida de reconstrucción mide qué tan bien el decodificador puede reconstruir las imágenes de entrada a partir de las variables latentes. Una menor pérdida de reconstrucción indica que el modelo es capaz de generar imágenes que se asemejan mucho a la entrada original.
Ejemplo: Cálculo de la Pérdida de Reconstrucción
import numpy as np
from tensorflow.keras.losses import binary_crossentropy
# Calculate reconstruction loss for the test set
reconstructed_images = vae.predict(x_test)
reconstruction_loss = np.mean(binary_crossentropy(x_test, reconstructed_images))
print(f"Reconstruction Loss: {reconstruction_loss}")El script primero carga las bibliotecas necesarias. Luego, utiliza el modelo VAE entrenado para crear imágenes reconstruidas a partir del conjunto de datos de prueba. La pérdida de reconstrucción, que mide la diferencia entre las imágenes originales y las reconstruidas, se calcula utilizando la función de pérdida de entropía cruzada binaria. Finalmente, se imprime la pérdida de reconstrucción.
Divergencia KL
La Divergencia KL mide la diferencia entre la distribución latente aprendida y la distribución previa (generalmente una distribución normal estándar). Una menor divergencia KL indica que la distribución latente está más cerca de la distribución previa deseada.
Ejemplo: Cálculo de la Divergencia KL
# Calculate KL Divergence for the test set
def calculate_kl_divergence(encoder, x_test):
z_mean, z_log_var, _ = encoder.predict(x_test)
kl_divergence = 1 + z_log_var - np.square(z_mean) - np.exp(z_log_var)
kl_divergence = np.sum(kl_divergence, axis=-1)
kl_divergence *= -0.5
return np.mean(kl_divergence)
kl_divergence = calculate_kl_divergence(encoder, x_test)
print(f"KL Divergence: {kl_divergence}")La función calculate_kl_divergence toma un encoder y x_test como entradas. El encoder predice la media y la varianza logarítmica (z_mean y z_log_var), y estos se utilizan para calcular la divergencia KL. La divergencia KL se calcula para cada punto de datos en el conjunto de prueba, y luego se devuelve la media de la divergencia KL a través de todo el conjunto.
Finalmente, la divergencia KL se calcula utilizando esta función y se imprime en la consola.
Inception Score (IS)
El Inception Score evalúa la calidad y la diversidad de las imágenes generadas. Utiliza una red Inception preentrenada para clasificar las imágenes generadas y calcula la divergencia KL entre la distribución de etiquetas condicional y la distribución de etiquetas marginal.
Ejemplo: Cálculo del Inception Score
from tensorflow.keras.applications.inception_v3 import InceptionV3, preprocess_input
from scipy.stats import entropy
# Function to calculate Inception Score
def calculate_inception_score(images, n_split=10, eps=1E-16):
model = InceptionV3(include_top=False, pooling='avg', input_shape=(299, 299, 3))
images_resized = tf.image.resize(images, (299, 299))
images_preprocessed = preprocess_input(images_resized)
preds = model.predict(images_preprocessed)
split_scores = []
for i in range(n_split):
part = preds[i * preds.shape[0] // n_split: (i + 1) * preds.shape[0] // n_split]
py = np.mean(part, axis=0)
scores = []
for p in part:
scores.append(entropy(p, py))
split_scores.append(np.exp(np.mean(scores)))
return np.mean(split_scores), np.std(split_scores)
# Generate images for evaluation
n_samples = 1000
random_latent_vectors = np.random.normal(size=(n_samples, latent_dim))
generated_images = decoder.predict(random_latent_vectors)
generated_images = generated_images.reshape((n_samples, 28, 28, 1))
# Calculate Inception Score
is_mean, is_std = calculate_inception_score(generated_images)
print(f"Inception Score: {is_mean} ± {is_std}")La función calculate_inception_score toma un conjunto de imágenes como entrada, redimensiona las imágenes al tamaño adecuado para el modelo InceptionV3 y preprocesa las imágenes. Luego, utiliza el modelo InceptionV3 para hacer predicciones sobre las imágenes preprocesadas.
La función calcula el Inception Score dividiendo las predicciones en partes, calculando la entropía entre cada parte y la media de todas las partes, y luego promediando las puntuaciones de entropía exponenciadas a través de todas las partes.
Finalmente, genera un conjunto de imágenes a partir de vectores latentes aleatorios utilizando un decodificador (presumiblemente de un GAN), remodela las imágenes y calcula el Inception Score para las imágenes generadas. La media y la desviación estándar del Inception Score se imprimen a continuación.
Fréchet Inception Distance (FID)
FID mide la distancia entre las distribuciones de imágenes reales y generadas. Los puntajes FID más bajos indican que las imágenes generadas son más similares a las imágenes reales.
Ejemplo: Cálculo del FID
from numpy import cov, trace, iscomplexobj
from scipy.linalg import sqrtm
# Function to calculate FID
def calculate_fid(real_images, generated_images):
model = InceptionV3(include_top=False, pooling='avg', input_shape=(299, 299, 3))
real_images_resized = tf.image.resize(real_images, (299, 299))
generated_images_resized = tf.image.resize(generated_images, (299, 299))
real_images_preprocessed = preprocess_input(real_images_resized)
generated_images_preprocessed = preprocess_input(generated_images_resized)
act1 = model.predict(real_images_preprocessed)
act2 = model.predict(generated_images_preprocessed)
mu1, sigma1 = act1.mean(axis=0), cov(act1, rowvar=False)
mu2, sigma2 = act2.mean(axis=0), cov(act2, rowvar=False)
ssdiff = np.sum((mu1 - mu2) ** 2.0)
covmean = sqrtm(sigma1.dot(sigma2))
if iscomplexobj(covmean):
covmean = covmean.real
fid = ssdiff + trace(sigma1 + sigma2 - 2.0 * covmean)
return fid
# Sample real images
real_images = x_test[:n_samples].reshape((n_samples, 28, 28, 1))
# Calculate FID
fid_score = calculate_fid(real_images, generated_images)
print(f"FID Score: {fid_score}")La función calculate_fid toma dos parámetros: real_images y generated_images. Primero, redimensiona las imágenes a las dimensiones esperadas por el modelo InceptionV3 (299x299 píxeles). Luego, las imágenes se preprocesan y se alimentan al modelo para obtener sus activaciones.
Se calculan la media y la covarianza de las activaciones, que luego se utilizan para calcular el puntaje FID. El puntaje FID es una medida de similitud entre los dos conjuntos de imágenes; los puntajes más bajos indican imágenes generadas de mejor calidad o más similares.
Finalmente, se calcula y se imprime el puntaje FID entre una muestra de imágenes reales y las imágenes generadas.
6.4.2 Evaluación Cualitativa
La evaluación cualitativa implica inspeccionar visualmente las imágenes generadas para evaluar su calidad y diversidad. Este método es subjetivo, pero proporciona información valiosa sobre el rendimiento del modelo.
Inspección Visual
La inspección visual implica generar un conjunto de imágenes y examinarlas para evaluar su realismo y diversidad. Esto ayuda a identificar cualquier problema obvio, como borrosidad, artefactos o colapso de modos.
Ejemplo: Visualización de Imágenes Generadas
# Function to visualize generated images
def visualize_generated_images(decoder, latent_dim, n_samples=10):
random_latent_vectors = np.random.normal(size=(n_samples, latent_dim))
generated_images = decoder.predict(random_latent_vectors)
generated_images = generated_images.reshape((n_samples, 28, 28))
plt.figure(figsize=(10, 2))
for i in range(n_samples):
plt.subplot(1, n_samples, i + 1)
plt.imshow(generated_images[i], cmap='gray')
plt.axis('off')
plt.show()
# Visualize generated images
visualize_generated_images(decoder, latent_dim)Este ejemplo define una función, visualize_generated_images, y la utiliza. Esta función genera imágenes a partir de vectores latentes aleatorios (un tipo de representación de datos) utilizando un modelo de decodificador dado. Luego, remodela las imágenes generadas y las visualiza en una cuadrícula de subplots de 1 por n_samples. Después de definir la función, el script la llama para visualizar algunas imágenes generadas por el modelo 'decoder' con una 'latent_dim' (dimensión latente) especificada.
Recorrido del Espacio Latente
El recorrido del espacio latente implica interpolar entre puntos en el espacio latente y generar imágenes en cada paso. Esta técnica ayuda a visualizar cómo el VAE transita suavemente entre diferentes puntos de datos y puede revelar la estructura del espacio latente.
Ejemplo: Recorrido del Espacio Latente
# Function to perform latent space traversal
def latent_space_traversal(decoder, latent_dim, n_steps=10):
start_point = np.random.normal(size=(1, latent_dim))
end_point = np.random.normal(size=(1, latent_dim))
interpolation = np.linspace(start_point, end_point, n_steps)
generated_images = decoder.predict(interpolation)
generated_images = generated_images.reshape((n_steps, 28, 28))
plt.figure(figsize=(15, 2))
for i in range(n_steps):
plt.subplot(1, n_steps, i + 1)
plt.imshow(generated_images[i], cmap='gray')
plt.axis('off')
plt.show()
# Perform latent space traversal
latent_space_traversal(decoder, latent_dim)Esta es una función llamada 'latent_space_traversal'. Toma tres parámetros: un decodificador, una dimensión latente y un número opcional de pasos, que por defecto está configurado en 10. La función genera dos puntos aleatorios en el espacio latente, que son los puntos de inicio y final. Luego, crea una interpolación lineal entre estos dos puntos.
Los puntos generados en el espacio latente se pasan a través del decodificador para generar imágenes. Estas imágenes se remodelan en un formato de 28x28 píxeles (común para las imágenes del conjunto de datos MNIST) y se muestran en una gráfica. La última línea de código llama y ejecuta la función.
6.4.3 Evaluación de Características Específicas
Al explorar diferentes regiones del espacio latente, podemos generar dígitos con características específicas y evaluar qué tan bien el VAE ha aprendido a representar estas características.
Ejemplo: Exploración de Características Latentes Específicas
# Function to explore specific latent features
def explore_latent_features(decoder, latent_dim, feature_vector, variation_range=(-3, 3), n_variations=10):
feature_variations = np.linspace(variation_range[0], variation_range[1], n_variations)
latent_vectors = np.zeros((n_variations, latent_dim))
for i, variation in enumerate(feature_variations):
latent_vectors[i] = feature_vector
latent_vectors[i, 0] = variation # Vary the first feature for demonstration
generated_images = decoder.predict(latent_vectors)
generated_images = generated_images.reshape((n_variations, 28, 28))
plt.figure(figsize=(15, 2))
for i in range(n_variations):
plt.subplot(1, n_variations, i + 1)
plt.imshow(generated_images[i], cmap='gray')
plt.axis('off')
plt.show()
# Example feature vector
example_feature_vector = np.random.normal(size=(latent_dim,))
# Explore specific latent features
explore_latent_features(decoder, latent_dim, example_feature_vector).Este código de ejemplo es para una función llamada explore_latent_features. Esta función se utiliza para explorar y visualizar los efectos de variar características latentes específicas en un modelo generativo, como un Autoencoder Variacional (VAE). La función toma un modelo de decodificador, la dimensionalidad del espacio latente (latent_dim), un vector de características (feature_vector) y parámetros para el rango y el número de variaciones a aplicar al vector de características.
Primero, la función genera un conjunto de nuevos vectores latentes aplicando un rango de variaciones al vector de características de entrada. Luego, utiliza el modelo de decodificador para generar imágenes a partir de estos vectores latentes y remodela las imágenes para su visualización.
A continuación, traza las imágenes generadas en una fila, mostrando los efectos de variar la característica latente específica en las imágenes generadas. Utiliza un vector de características de ejemplo generado aleatoriamente a partir de una distribución normal para la demostración.
En el ejemplo, se varía la primera característica para la demostración. Sin embargo, puede modificar el índice para explorar otras características latentes.
6.4 Evaluación del Modelo
Evaluar el rendimiento de un Autoencoder Variacional (VAE) es crucial para asegurar que ha aprendido representaciones latentes significativas y puede generar imágenes de alta calidad. En esta sección, discutiremos varios métodos para evaluar nuestro VAE, incluyendo métricas cuantitativas y evaluaciones cualitativas. También proporcionaremos ejemplos de código para demostrar estas técnicas de evaluación.
6.4.1 Métricas Cuantitativas de Evaluación
Las métricas cuantitativas proporcionan medidas objetivas del rendimiento del modelo. Para los VAEs, algunas métricas comunes incluyen la pérdida de reconstrucción, la divergencia KL, la puntuación de Inception (IS) y la distancia de Inception de Fréchet (FID).
Pérdida de Reconstrucción
La pérdida de reconstrucción mide qué tan bien el decodificador puede reconstruir las imágenes de entrada a partir de las variables latentes. Una menor pérdida de reconstrucción indica que el modelo es capaz de generar imágenes que se asemejan mucho a la entrada original.
Ejemplo: Cálculo de la Pérdida de Reconstrucción
import numpy as np
from tensorflow.keras.losses import binary_crossentropy
# Calculate reconstruction loss for the test set
reconstructed_images = vae.predict(x_test)
reconstruction_loss = np.mean(binary_crossentropy(x_test, reconstructed_images))
print(f"Reconstruction Loss: {reconstruction_loss}")El script primero carga las bibliotecas necesarias. Luego, utiliza el modelo VAE entrenado para crear imágenes reconstruidas a partir del conjunto de datos de prueba. La pérdida de reconstrucción, que mide la diferencia entre las imágenes originales y las reconstruidas, se calcula utilizando la función de pérdida de entropía cruzada binaria. Finalmente, se imprime la pérdida de reconstrucción.
Divergencia KL
La Divergencia KL mide la diferencia entre la distribución latente aprendida y la distribución previa (generalmente una distribución normal estándar). Una menor divergencia KL indica que la distribución latente está más cerca de la distribución previa deseada.
Ejemplo: Cálculo de la Divergencia KL
# Calculate KL Divergence for the test set
def calculate_kl_divergence(encoder, x_test):
z_mean, z_log_var, _ = encoder.predict(x_test)
kl_divergence = 1 + z_log_var - np.square(z_mean) - np.exp(z_log_var)
kl_divergence = np.sum(kl_divergence, axis=-1)
kl_divergence *= -0.5
return np.mean(kl_divergence)
kl_divergence = calculate_kl_divergence(encoder, x_test)
print(f"KL Divergence: {kl_divergence}")La función calculate_kl_divergence toma un encoder y x_test como entradas. El encoder predice la media y la varianza logarítmica (z_mean y z_log_var), y estos se utilizan para calcular la divergencia KL. La divergencia KL se calcula para cada punto de datos en el conjunto de prueba, y luego se devuelve la media de la divergencia KL a través de todo el conjunto.
Finalmente, la divergencia KL se calcula utilizando esta función y se imprime en la consola.
Inception Score (IS)
El Inception Score evalúa la calidad y la diversidad de las imágenes generadas. Utiliza una red Inception preentrenada para clasificar las imágenes generadas y calcula la divergencia KL entre la distribución de etiquetas condicional y la distribución de etiquetas marginal.
Ejemplo: Cálculo del Inception Score
from tensorflow.keras.applications.inception_v3 import InceptionV3, preprocess_input
from scipy.stats import entropy
# Function to calculate Inception Score
def calculate_inception_score(images, n_split=10, eps=1E-16):
model = InceptionV3(include_top=False, pooling='avg', input_shape=(299, 299, 3))
images_resized = tf.image.resize(images, (299, 299))
images_preprocessed = preprocess_input(images_resized)
preds = model.predict(images_preprocessed)
split_scores = []
for i in range(n_split):
part = preds[i * preds.shape[0] // n_split: (i + 1) * preds.shape[0] // n_split]
py = np.mean(part, axis=0)
scores = []
for p in part:
scores.append(entropy(p, py))
split_scores.append(np.exp(np.mean(scores)))
return np.mean(split_scores), np.std(split_scores)
# Generate images for evaluation
n_samples = 1000
random_latent_vectors = np.random.normal(size=(n_samples, latent_dim))
generated_images = decoder.predict(random_latent_vectors)
generated_images = generated_images.reshape((n_samples, 28, 28, 1))
# Calculate Inception Score
is_mean, is_std = calculate_inception_score(generated_images)
print(f"Inception Score: {is_mean} ± {is_std}")La función calculate_inception_score toma un conjunto de imágenes como entrada, redimensiona las imágenes al tamaño adecuado para el modelo InceptionV3 y preprocesa las imágenes. Luego, utiliza el modelo InceptionV3 para hacer predicciones sobre las imágenes preprocesadas.
La función calcula el Inception Score dividiendo las predicciones en partes, calculando la entropía entre cada parte y la media de todas las partes, y luego promediando las puntuaciones de entropía exponenciadas a través de todas las partes.
Finalmente, genera un conjunto de imágenes a partir de vectores latentes aleatorios utilizando un decodificador (presumiblemente de un GAN), remodela las imágenes y calcula el Inception Score para las imágenes generadas. La media y la desviación estándar del Inception Score se imprimen a continuación.
Fréchet Inception Distance (FID)
FID mide la distancia entre las distribuciones de imágenes reales y generadas. Los puntajes FID más bajos indican que las imágenes generadas son más similares a las imágenes reales.
Ejemplo: Cálculo del FID
from numpy import cov, trace, iscomplexobj
from scipy.linalg import sqrtm
# Function to calculate FID
def calculate_fid(real_images, generated_images):
model = InceptionV3(include_top=False, pooling='avg', input_shape=(299, 299, 3))
real_images_resized = tf.image.resize(real_images, (299, 299))
generated_images_resized = tf.image.resize(generated_images, (299, 299))
real_images_preprocessed = preprocess_input(real_images_resized)
generated_images_preprocessed = preprocess_input(generated_images_resized)
act1 = model.predict(real_images_preprocessed)
act2 = model.predict(generated_images_preprocessed)
mu1, sigma1 = act1.mean(axis=0), cov(act1, rowvar=False)
mu2, sigma2 = act2.mean(axis=0), cov(act2, rowvar=False)
ssdiff = np.sum((mu1 - mu2) ** 2.0)
covmean = sqrtm(sigma1.dot(sigma2))
if iscomplexobj(covmean):
covmean = covmean.real
fid = ssdiff + trace(sigma1 + sigma2 - 2.0 * covmean)
return fid
# Sample real images
real_images = x_test[:n_samples].reshape((n_samples, 28, 28, 1))
# Calculate FID
fid_score = calculate_fid(real_images, generated_images)
print(f"FID Score: {fid_score}")La función calculate_fid toma dos parámetros: real_images y generated_images. Primero, redimensiona las imágenes a las dimensiones esperadas por el modelo InceptionV3 (299x299 píxeles). Luego, las imágenes se preprocesan y se alimentan al modelo para obtener sus activaciones.
Se calculan la media y la covarianza de las activaciones, que luego se utilizan para calcular el puntaje FID. El puntaje FID es una medida de similitud entre los dos conjuntos de imágenes; los puntajes más bajos indican imágenes generadas de mejor calidad o más similares.
Finalmente, se calcula y se imprime el puntaje FID entre una muestra de imágenes reales y las imágenes generadas.
6.4.2 Evaluación Cualitativa
La evaluación cualitativa implica inspeccionar visualmente las imágenes generadas para evaluar su calidad y diversidad. Este método es subjetivo, pero proporciona información valiosa sobre el rendimiento del modelo.
Inspección Visual
La inspección visual implica generar un conjunto de imágenes y examinarlas para evaluar su realismo y diversidad. Esto ayuda a identificar cualquier problema obvio, como borrosidad, artefactos o colapso de modos.
Ejemplo: Visualización de Imágenes Generadas
# Function to visualize generated images
def visualize_generated_images(decoder, latent_dim, n_samples=10):
random_latent_vectors = np.random.normal(size=(n_samples, latent_dim))
generated_images = decoder.predict(random_latent_vectors)
generated_images = generated_images.reshape((n_samples, 28, 28))
plt.figure(figsize=(10, 2))
for i in range(n_samples):
plt.subplot(1, n_samples, i + 1)
plt.imshow(generated_images[i], cmap='gray')
plt.axis('off')
plt.show()
# Visualize generated images
visualize_generated_images(decoder, latent_dim)Este ejemplo define una función, visualize_generated_images, y la utiliza. Esta función genera imágenes a partir de vectores latentes aleatorios (un tipo de representación de datos) utilizando un modelo de decodificador dado. Luego, remodela las imágenes generadas y las visualiza en una cuadrícula de subplots de 1 por n_samples. Después de definir la función, el script la llama para visualizar algunas imágenes generadas por el modelo 'decoder' con una 'latent_dim' (dimensión latente) especificada.
Recorrido del Espacio Latente
El recorrido del espacio latente implica interpolar entre puntos en el espacio latente y generar imágenes en cada paso. Esta técnica ayuda a visualizar cómo el VAE transita suavemente entre diferentes puntos de datos y puede revelar la estructura del espacio latente.
Ejemplo: Recorrido del Espacio Latente
# Function to perform latent space traversal
def latent_space_traversal(decoder, latent_dim, n_steps=10):
start_point = np.random.normal(size=(1, latent_dim))
end_point = np.random.normal(size=(1, latent_dim))
interpolation = np.linspace(start_point, end_point, n_steps)
generated_images = decoder.predict(interpolation)
generated_images = generated_images.reshape((n_steps, 28, 28))
plt.figure(figsize=(15, 2))
for i in range(n_steps):
plt.subplot(1, n_steps, i + 1)
plt.imshow(generated_images[i], cmap='gray')
plt.axis('off')
plt.show()
# Perform latent space traversal
latent_space_traversal(decoder, latent_dim)Esta es una función llamada 'latent_space_traversal'. Toma tres parámetros: un decodificador, una dimensión latente y un número opcional de pasos, que por defecto está configurado en 10. La función genera dos puntos aleatorios en el espacio latente, que son los puntos de inicio y final. Luego, crea una interpolación lineal entre estos dos puntos.
Los puntos generados en el espacio latente se pasan a través del decodificador para generar imágenes. Estas imágenes se remodelan en un formato de 28x28 píxeles (común para las imágenes del conjunto de datos MNIST) y se muestran en una gráfica. La última línea de código llama y ejecuta la función.
6.4.3 Evaluación de Características Específicas
Al explorar diferentes regiones del espacio latente, podemos generar dígitos con características específicas y evaluar qué tan bien el VAE ha aprendido a representar estas características.
Ejemplo: Exploración de Características Latentes Específicas
# Function to explore specific latent features
def explore_latent_features(decoder, latent_dim, feature_vector, variation_range=(-3, 3), n_variations=10):
feature_variations = np.linspace(variation_range[0], variation_range[1], n_variations)
latent_vectors = np.zeros((n_variations, latent_dim))
for i, variation in enumerate(feature_variations):
latent_vectors[i] = feature_vector
latent_vectors[i, 0] = variation # Vary the first feature for demonstration
generated_images = decoder.predict(latent_vectors)
generated_images = generated_images.reshape((n_variations, 28, 28))
plt.figure(figsize=(15, 2))
for i in range(n_variations):
plt.subplot(1, n_variations, i + 1)
plt.imshow(generated_images[i], cmap='gray')
plt.axis('off')
plt.show()
# Example feature vector
example_feature_vector = np.random.normal(size=(latent_dim,))
# Explore specific latent features
explore_latent_features(decoder, latent_dim, example_feature_vector).Este código de ejemplo es para una función llamada explore_latent_features. Esta función se utiliza para explorar y visualizar los efectos de variar características latentes específicas en un modelo generativo, como un Autoencoder Variacional (VAE). La función toma un modelo de decodificador, la dimensionalidad del espacio latente (latent_dim), un vector de características (feature_vector) y parámetros para el rango y el número de variaciones a aplicar al vector de características.
Primero, la función genera un conjunto de nuevos vectores latentes aplicando un rango de variaciones al vector de características de entrada. Luego, utiliza el modelo de decodificador para generar imágenes a partir de estos vectores latentes y remodela las imágenes para su visualización.
A continuación, traza las imágenes generadas en una fila, mostrando los efectos de variar la característica latente específica en las imágenes generadas. Utiliza un vector de características de ejemplo generado aleatoriamente a partir de una distribución normal para la demostración.
En el ejemplo, se varía la primera característica para la demostración. Sin embargo, puede modificar el índice para explorar otras características latentes.
6.4 Evaluación del Modelo
Evaluar el rendimiento de un Autoencoder Variacional (VAE) es crucial para asegurar que ha aprendido representaciones latentes significativas y puede generar imágenes de alta calidad. En esta sección, discutiremos varios métodos para evaluar nuestro VAE, incluyendo métricas cuantitativas y evaluaciones cualitativas. También proporcionaremos ejemplos de código para demostrar estas técnicas de evaluación.
6.4.1 Métricas Cuantitativas de Evaluación
Las métricas cuantitativas proporcionan medidas objetivas del rendimiento del modelo. Para los VAEs, algunas métricas comunes incluyen la pérdida de reconstrucción, la divergencia KL, la puntuación de Inception (IS) y la distancia de Inception de Fréchet (FID).
Pérdida de Reconstrucción
La pérdida de reconstrucción mide qué tan bien el decodificador puede reconstruir las imágenes de entrada a partir de las variables latentes. Una menor pérdida de reconstrucción indica que el modelo es capaz de generar imágenes que se asemejan mucho a la entrada original.
Ejemplo: Cálculo de la Pérdida de Reconstrucción
import numpy as np
from tensorflow.keras.losses import binary_crossentropy
# Calculate reconstruction loss for the test set
reconstructed_images = vae.predict(x_test)
reconstruction_loss = np.mean(binary_crossentropy(x_test, reconstructed_images))
print(f"Reconstruction Loss: {reconstruction_loss}")El script primero carga las bibliotecas necesarias. Luego, utiliza el modelo VAE entrenado para crear imágenes reconstruidas a partir del conjunto de datos de prueba. La pérdida de reconstrucción, que mide la diferencia entre las imágenes originales y las reconstruidas, se calcula utilizando la función de pérdida de entropía cruzada binaria. Finalmente, se imprime la pérdida de reconstrucción.
Divergencia KL
La Divergencia KL mide la diferencia entre la distribución latente aprendida y la distribución previa (generalmente una distribución normal estándar). Una menor divergencia KL indica que la distribución latente está más cerca de la distribución previa deseada.
Ejemplo: Cálculo de la Divergencia KL
# Calculate KL Divergence for the test set
def calculate_kl_divergence(encoder, x_test):
z_mean, z_log_var, _ = encoder.predict(x_test)
kl_divergence = 1 + z_log_var - np.square(z_mean) - np.exp(z_log_var)
kl_divergence = np.sum(kl_divergence, axis=-1)
kl_divergence *= -0.5
return np.mean(kl_divergence)
kl_divergence = calculate_kl_divergence(encoder, x_test)
print(f"KL Divergence: {kl_divergence}")La función calculate_kl_divergence toma un encoder y x_test como entradas. El encoder predice la media y la varianza logarítmica (z_mean y z_log_var), y estos se utilizan para calcular la divergencia KL. La divergencia KL se calcula para cada punto de datos en el conjunto de prueba, y luego se devuelve la media de la divergencia KL a través de todo el conjunto.
Finalmente, la divergencia KL se calcula utilizando esta función y se imprime en la consola.
Inception Score (IS)
El Inception Score evalúa la calidad y la diversidad de las imágenes generadas. Utiliza una red Inception preentrenada para clasificar las imágenes generadas y calcula la divergencia KL entre la distribución de etiquetas condicional y la distribución de etiquetas marginal.
Ejemplo: Cálculo del Inception Score
from tensorflow.keras.applications.inception_v3 import InceptionV3, preprocess_input
from scipy.stats import entropy
# Function to calculate Inception Score
def calculate_inception_score(images, n_split=10, eps=1E-16):
model = InceptionV3(include_top=False, pooling='avg', input_shape=(299, 299, 3))
images_resized = tf.image.resize(images, (299, 299))
images_preprocessed = preprocess_input(images_resized)
preds = model.predict(images_preprocessed)
split_scores = []
for i in range(n_split):
part = preds[i * preds.shape[0] // n_split: (i + 1) * preds.shape[0] // n_split]
py = np.mean(part, axis=0)
scores = []
for p in part:
scores.append(entropy(p, py))
split_scores.append(np.exp(np.mean(scores)))
return np.mean(split_scores), np.std(split_scores)
# Generate images for evaluation
n_samples = 1000
random_latent_vectors = np.random.normal(size=(n_samples, latent_dim))
generated_images = decoder.predict(random_latent_vectors)
generated_images = generated_images.reshape((n_samples, 28, 28, 1))
# Calculate Inception Score
is_mean, is_std = calculate_inception_score(generated_images)
print(f"Inception Score: {is_mean} ± {is_std}")La función calculate_inception_score toma un conjunto de imágenes como entrada, redimensiona las imágenes al tamaño adecuado para el modelo InceptionV3 y preprocesa las imágenes. Luego, utiliza el modelo InceptionV3 para hacer predicciones sobre las imágenes preprocesadas.
La función calcula el Inception Score dividiendo las predicciones en partes, calculando la entropía entre cada parte y la media de todas las partes, y luego promediando las puntuaciones de entropía exponenciadas a través de todas las partes.
Finalmente, genera un conjunto de imágenes a partir de vectores latentes aleatorios utilizando un decodificador (presumiblemente de un GAN), remodela las imágenes y calcula el Inception Score para las imágenes generadas. La media y la desviación estándar del Inception Score se imprimen a continuación.
Fréchet Inception Distance (FID)
FID mide la distancia entre las distribuciones de imágenes reales y generadas. Los puntajes FID más bajos indican que las imágenes generadas son más similares a las imágenes reales.
Ejemplo: Cálculo del FID
from numpy import cov, trace, iscomplexobj
from scipy.linalg import sqrtm
# Function to calculate FID
def calculate_fid(real_images, generated_images):
model = InceptionV3(include_top=False, pooling='avg', input_shape=(299, 299, 3))
real_images_resized = tf.image.resize(real_images, (299, 299))
generated_images_resized = tf.image.resize(generated_images, (299, 299))
real_images_preprocessed = preprocess_input(real_images_resized)
generated_images_preprocessed = preprocess_input(generated_images_resized)
act1 = model.predict(real_images_preprocessed)
act2 = model.predict(generated_images_preprocessed)
mu1, sigma1 = act1.mean(axis=0), cov(act1, rowvar=False)
mu2, sigma2 = act2.mean(axis=0), cov(act2, rowvar=False)
ssdiff = np.sum((mu1 - mu2) ** 2.0)
covmean = sqrtm(sigma1.dot(sigma2))
if iscomplexobj(covmean):
covmean = covmean.real
fid = ssdiff + trace(sigma1 + sigma2 - 2.0 * covmean)
return fid
# Sample real images
real_images = x_test[:n_samples].reshape((n_samples, 28, 28, 1))
# Calculate FID
fid_score = calculate_fid(real_images, generated_images)
print(f"FID Score: {fid_score}")La función calculate_fid toma dos parámetros: real_images y generated_images. Primero, redimensiona las imágenes a las dimensiones esperadas por el modelo InceptionV3 (299x299 píxeles). Luego, las imágenes se preprocesan y se alimentan al modelo para obtener sus activaciones.
Se calculan la media y la covarianza de las activaciones, que luego se utilizan para calcular el puntaje FID. El puntaje FID es una medida de similitud entre los dos conjuntos de imágenes; los puntajes más bajos indican imágenes generadas de mejor calidad o más similares.
Finalmente, se calcula y se imprime el puntaje FID entre una muestra de imágenes reales y las imágenes generadas.
6.4.2 Evaluación Cualitativa
La evaluación cualitativa implica inspeccionar visualmente las imágenes generadas para evaluar su calidad y diversidad. Este método es subjetivo, pero proporciona información valiosa sobre el rendimiento del modelo.
Inspección Visual
La inspección visual implica generar un conjunto de imágenes y examinarlas para evaluar su realismo y diversidad. Esto ayuda a identificar cualquier problema obvio, como borrosidad, artefactos o colapso de modos.
Ejemplo: Visualización de Imágenes Generadas
# Function to visualize generated images
def visualize_generated_images(decoder, latent_dim, n_samples=10):
random_latent_vectors = np.random.normal(size=(n_samples, latent_dim))
generated_images = decoder.predict(random_latent_vectors)
generated_images = generated_images.reshape((n_samples, 28, 28))
plt.figure(figsize=(10, 2))
for i in range(n_samples):
plt.subplot(1, n_samples, i + 1)
plt.imshow(generated_images[i], cmap='gray')
plt.axis('off')
plt.show()
# Visualize generated images
visualize_generated_images(decoder, latent_dim)Este ejemplo define una función, visualize_generated_images, y la utiliza. Esta función genera imágenes a partir de vectores latentes aleatorios (un tipo de representación de datos) utilizando un modelo de decodificador dado. Luego, remodela las imágenes generadas y las visualiza en una cuadrícula de subplots de 1 por n_samples. Después de definir la función, el script la llama para visualizar algunas imágenes generadas por el modelo 'decoder' con una 'latent_dim' (dimensión latente) especificada.
Recorrido del Espacio Latente
El recorrido del espacio latente implica interpolar entre puntos en el espacio latente y generar imágenes en cada paso. Esta técnica ayuda a visualizar cómo el VAE transita suavemente entre diferentes puntos de datos y puede revelar la estructura del espacio latente.
Ejemplo: Recorrido del Espacio Latente
# Function to perform latent space traversal
def latent_space_traversal(decoder, latent_dim, n_steps=10):
start_point = np.random.normal(size=(1, latent_dim))
end_point = np.random.normal(size=(1, latent_dim))
interpolation = np.linspace(start_point, end_point, n_steps)
generated_images = decoder.predict(interpolation)
generated_images = generated_images.reshape((n_steps, 28, 28))
plt.figure(figsize=(15, 2))
for i in range(n_steps):
plt.subplot(1, n_steps, i + 1)
plt.imshow(generated_images[i], cmap='gray')
plt.axis('off')
plt.show()
# Perform latent space traversal
latent_space_traversal(decoder, latent_dim)Esta es una función llamada 'latent_space_traversal'. Toma tres parámetros: un decodificador, una dimensión latente y un número opcional de pasos, que por defecto está configurado en 10. La función genera dos puntos aleatorios en el espacio latente, que son los puntos de inicio y final. Luego, crea una interpolación lineal entre estos dos puntos.
Los puntos generados en el espacio latente se pasan a través del decodificador para generar imágenes. Estas imágenes se remodelan en un formato de 28x28 píxeles (común para las imágenes del conjunto de datos MNIST) y se muestran en una gráfica. La última línea de código llama y ejecuta la función.
6.4.3 Evaluación de Características Específicas
Al explorar diferentes regiones del espacio latente, podemos generar dígitos con características específicas y evaluar qué tan bien el VAE ha aprendido a representar estas características.
Ejemplo: Exploración de Características Latentes Específicas
# Function to explore specific latent features
def explore_latent_features(decoder, latent_dim, feature_vector, variation_range=(-3, 3), n_variations=10):
feature_variations = np.linspace(variation_range[0], variation_range[1], n_variations)
latent_vectors = np.zeros((n_variations, latent_dim))
for i, variation in enumerate(feature_variations):
latent_vectors[i] = feature_vector
latent_vectors[i, 0] = variation # Vary the first feature for demonstration
generated_images = decoder.predict(latent_vectors)
generated_images = generated_images.reshape((n_variations, 28, 28))
plt.figure(figsize=(15, 2))
for i in range(n_variations):
plt.subplot(1, n_variations, i + 1)
plt.imshow(generated_images[i], cmap='gray')
plt.axis('off')
plt.show()
# Example feature vector
example_feature_vector = np.random.normal(size=(latent_dim,))
# Explore specific latent features
explore_latent_features(decoder, latent_dim, example_feature_vector).Este código de ejemplo es para una función llamada explore_latent_features. Esta función se utiliza para explorar y visualizar los efectos de variar características latentes específicas en un modelo generativo, como un Autoencoder Variacional (VAE). La función toma un modelo de decodificador, la dimensionalidad del espacio latente (latent_dim), un vector de características (feature_vector) y parámetros para el rango y el número de variaciones a aplicar al vector de características.
Primero, la función genera un conjunto de nuevos vectores latentes aplicando un rango de variaciones al vector de características de entrada. Luego, utiliza el modelo de decodificador para generar imágenes a partir de estos vectores latentes y remodela las imágenes para su visualización.
A continuación, traza las imágenes generadas en una fila, mostrando los efectos de variar la característica latente específica en las imágenes generadas. Utiliza un vector de características de ejemplo generado aleatoriamente a partir de una distribución normal para la demostración.
En el ejemplo, se varía la primera característica para la demostración. Sin embargo, puede modificar el índice para explorar otras características latentes.
6.4 Evaluación del Modelo
Evaluar el rendimiento de un Autoencoder Variacional (VAE) es crucial para asegurar que ha aprendido representaciones latentes significativas y puede generar imágenes de alta calidad. En esta sección, discutiremos varios métodos para evaluar nuestro VAE, incluyendo métricas cuantitativas y evaluaciones cualitativas. También proporcionaremos ejemplos de código para demostrar estas técnicas de evaluación.
6.4.1 Métricas Cuantitativas de Evaluación
Las métricas cuantitativas proporcionan medidas objetivas del rendimiento del modelo. Para los VAEs, algunas métricas comunes incluyen la pérdida de reconstrucción, la divergencia KL, la puntuación de Inception (IS) y la distancia de Inception de Fréchet (FID).
Pérdida de Reconstrucción
La pérdida de reconstrucción mide qué tan bien el decodificador puede reconstruir las imágenes de entrada a partir de las variables latentes. Una menor pérdida de reconstrucción indica que el modelo es capaz de generar imágenes que se asemejan mucho a la entrada original.
Ejemplo: Cálculo de la Pérdida de Reconstrucción
import numpy as np
from tensorflow.keras.losses import binary_crossentropy
# Calculate reconstruction loss for the test set
reconstructed_images = vae.predict(x_test)
reconstruction_loss = np.mean(binary_crossentropy(x_test, reconstructed_images))
print(f"Reconstruction Loss: {reconstruction_loss}")El script primero carga las bibliotecas necesarias. Luego, utiliza el modelo VAE entrenado para crear imágenes reconstruidas a partir del conjunto de datos de prueba. La pérdida de reconstrucción, que mide la diferencia entre las imágenes originales y las reconstruidas, se calcula utilizando la función de pérdida de entropía cruzada binaria. Finalmente, se imprime la pérdida de reconstrucción.
Divergencia KL
La Divergencia KL mide la diferencia entre la distribución latente aprendida y la distribución previa (generalmente una distribución normal estándar). Una menor divergencia KL indica que la distribución latente está más cerca de la distribución previa deseada.
Ejemplo: Cálculo de la Divergencia KL
# Calculate KL Divergence for the test set
def calculate_kl_divergence(encoder, x_test):
z_mean, z_log_var, _ = encoder.predict(x_test)
kl_divergence = 1 + z_log_var - np.square(z_mean) - np.exp(z_log_var)
kl_divergence = np.sum(kl_divergence, axis=-1)
kl_divergence *= -0.5
return np.mean(kl_divergence)
kl_divergence = calculate_kl_divergence(encoder, x_test)
print(f"KL Divergence: {kl_divergence}")La función calculate_kl_divergence toma un encoder y x_test como entradas. El encoder predice la media y la varianza logarítmica (z_mean y z_log_var), y estos se utilizan para calcular la divergencia KL. La divergencia KL se calcula para cada punto de datos en el conjunto de prueba, y luego se devuelve la media de la divergencia KL a través de todo el conjunto.
Finalmente, la divergencia KL se calcula utilizando esta función y se imprime en la consola.
Inception Score (IS)
El Inception Score evalúa la calidad y la diversidad de las imágenes generadas. Utiliza una red Inception preentrenada para clasificar las imágenes generadas y calcula la divergencia KL entre la distribución de etiquetas condicional y la distribución de etiquetas marginal.
Ejemplo: Cálculo del Inception Score
from tensorflow.keras.applications.inception_v3 import InceptionV3, preprocess_input
from scipy.stats import entropy
# Function to calculate Inception Score
def calculate_inception_score(images, n_split=10, eps=1E-16):
model = InceptionV3(include_top=False, pooling='avg', input_shape=(299, 299, 3))
images_resized = tf.image.resize(images, (299, 299))
images_preprocessed = preprocess_input(images_resized)
preds = model.predict(images_preprocessed)
split_scores = []
for i in range(n_split):
part = preds[i * preds.shape[0] // n_split: (i + 1) * preds.shape[0] // n_split]
py = np.mean(part, axis=0)
scores = []
for p in part:
scores.append(entropy(p, py))
split_scores.append(np.exp(np.mean(scores)))
return np.mean(split_scores), np.std(split_scores)
# Generate images for evaluation
n_samples = 1000
random_latent_vectors = np.random.normal(size=(n_samples, latent_dim))
generated_images = decoder.predict(random_latent_vectors)
generated_images = generated_images.reshape((n_samples, 28, 28, 1))
# Calculate Inception Score
is_mean, is_std = calculate_inception_score(generated_images)
print(f"Inception Score: {is_mean} ± {is_std}")La función calculate_inception_score toma un conjunto de imágenes como entrada, redimensiona las imágenes al tamaño adecuado para el modelo InceptionV3 y preprocesa las imágenes. Luego, utiliza el modelo InceptionV3 para hacer predicciones sobre las imágenes preprocesadas.
La función calcula el Inception Score dividiendo las predicciones en partes, calculando la entropía entre cada parte y la media de todas las partes, y luego promediando las puntuaciones de entropía exponenciadas a través de todas las partes.
Finalmente, genera un conjunto de imágenes a partir de vectores latentes aleatorios utilizando un decodificador (presumiblemente de un GAN), remodela las imágenes y calcula el Inception Score para las imágenes generadas. La media y la desviación estándar del Inception Score se imprimen a continuación.
Fréchet Inception Distance (FID)
FID mide la distancia entre las distribuciones de imágenes reales y generadas. Los puntajes FID más bajos indican que las imágenes generadas son más similares a las imágenes reales.
Ejemplo: Cálculo del FID
from numpy import cov, trace, iscomplexobj
from scipy.linalg import sqrtm
# Function to calculate FID
def calculate_fid(real_images, generated_images):
model = InceptionV3(include_top=False, pooling='avg', input_shape=(299, 299, 3))
real_images_resized = tf.image.resize(real_images, (299, 299))
generated_images_resized = tf.image.resize(generated_images, (299, 299))
real_images_preprocessed = preprocess_input(real_images_resized)
generated_images_preprocessed = preprocess_input(generated_images_resized)
act1 = model.predict(real_images_preprocessed)
act2 = model.predict(generated_images_preprocessed)
mu1, sigma1 = act1.mean(axis=0), cov(act1, rowvar=False)
mu2, sigma2 = act2.mean(axis=0), cov(act2, rowvar=False)
ssdiff = np.sum((mu1 - mu2) ** 2.0)
covmean = sqrtm(sigma1.dot(sigma2))
if iscomplexobj(covmean):
covmean = covmean.real
fid = ssdiff + trace(sigma1 + sigma2 - 2.0 * covmean)
return fid
# Sample real images
real_images = x_test[:n_samples].reshape((n_samples, 28, 28, 1))
# Calculate FID
fid_score = calculate_fid(real_images, generated_images)
print(f"FID Score: {fid_score}")La función calculate_fid toma dos parámetros: real_images y generated_images. Primero, redimensiona las imágenes a las dimensiones esperadas por el modelo InceptionV3 (299x299 píxeles). Luego, las imágenes se preprocesan y se alimentan al modelo para obtener sus activaciones.
Se calculan la media y la covarianza de las activaciones, que luego se utilizan para calcular el puntaje FID. El puntaje FID es una medida de similitud entre los dos conjuntos de imágenes; los puntajes más bajos indican imágenes generadas de mejor calidad o más similares.
Finalmente, se calcula y se imprime el puntaje FID entre una muestra de imágenes reales y las imágenes generadas.
6.4.2 Evaluación Cualitativa
La evaluación cualitativa implica inspeccionar visualmente las imágenes generadas para evaluar su calidad y diversidad. Este método es subjetivo, pero proporciona información valiosa sobre el rendimiento del modelo.
Inspección Visual
La inspección visual implica generar un conjunto de imágenes y examinarlas para evaluar su realismo y diversidad. Esto ayuda a identificar cualquier problema obvio, como borrosidad, artefactos o colapso de modos.
Ejemplo: Visualización de Imágenes Generadas
# Function to visualize generated images
def visualize_generated_images(decoder, latent_dim, n_samples=10):
random_latent_vectors = np.random.normal(size=(n_samples, latent_dim))
generated_images = decoder.predict(random_latent_vectors)
generated_images = generated_images.reshape((n_samples, 28, 28))
plt.figure(figsize=(10, 2))
for i in range(n_samples):
plt.subplot(1, n_samples, i + 1)
plt.imshow(generated_images[i], cmap='gray')
plt.axis('off')
plt.show()
# Visualize generated images
visualize_generated_images(decoder, latent_dim)Este ejemplo define una función, visualize_generated_images, y la utiliza. Esta función genera imágenes a partir de vectores latentes aleatorios (un tipo de representación de datos) utilizando un modelo de decodificador dado. Luego, remodela las imágenes generadas y las visualiza en una cuadrícula de subplots de 1 por n_samples. Después de definir la función, el script la llama para visualizar algunas imágenes generadas por el modelo 'decoder' con una 'latent_dim' (dimensión latente) especificada.
Recorrido del Espacio Latente
El recorrido del espacio latente implica interpolar entre puntos en el espacio latente y generar imágenes en cada paso. Esta técnica ayuda a visualizar cómo el VAE transita suavemente entre diferentes puntos de datos y puede revelar la estructura del espacio latente.
Ejemplo: Recorrido del Espacio Latente
# Function to perform latent space traversal
def latent_space_traversal(decoder, latent_dim, n_steps=10):
start_point = np.random.normal(size=(1, latent_dim))
end_point = np.random.normal(size=(1, latent_dim))
interpolation = np.linspace(start_point, end_point, n_steps)
generated_images = decoder.predict(interpolation)
generated_images = generated_images.reshape((n_steps, 28, 28))
plt.figure(figsize=(15, 2))
for i in range(n_steps):
plt.subplot(1, n_steps, i + 1)
plt.imshow(generated_images[i], cmap='gray')
plt.axis('off')
plt.show()
# Perform latent space traversal
latent_space_traversal(decoder, latent_dim)Esta es una función llamada 'latent_space_traversal'. Toma tres parámetros: un decodificador, una dimensión latente y un número opcional de pasos, que por defecto está configurado en 10. La función genera dos puntos aleatorios en el espacio latente, que son los puntos de inicio y final. Luego, crea una interpolación lineal entre estos dos puntos.
Los puntos generados en el espacio latente se pasan a través del decodificador para generar imágenes. Estas imágenes se remodelan en un formato de 28x28 píxeles (común para las imágenes del conjunto de datos MNIST) y se muestran en una gráfica. La última línea de código llama y ejecuta la función.
6.4.3 Evaluación de Características Específicas
Al explorar diferentes regiones del espacio latente, podemos generar dígitos con características específicas y evaluar qué tan bien el VAE ha aprendido a representar estas características.
Ejemplo: Exploración de Características Latentes Específicas
# Function to explore specific latent features
def explore_latent_features(decoder, latent_dim, feature_vector, variation_range=(-3, 3), n_variations=10):
feature_variations = np.linspace(variation_range[0], variation_range[1], n_variations)
latent_vectors = np.zeros((n_variations, latent_dim))
for i, variation in enumerate(feature_variations):
latent_vectors[i] = feature_vector
latent_vectors[i, 0] = variation # Vary the first feature for demonstration
generated_images = decoder.predict(latent_vectors)
generated_images = generated_images.reshape((n_variations, 28, 28))
plt.figure(figsize=(15, 2))
for i in range(n_variations):
plt.subplot(1, n_variations, i + 1)
plt.imshow(generated_images[i], cmap='gray')
plt.axis('off')
plt.show()
# Example feature vector
example_feature_vector = np.random.normal(size=(latent_dim,))
# Explore specific latent features
explore_latent_features(decoder, latent_dim, example_feature_vector).Este código de ejemplo es para una función llamada explore_latent_features. Esta función se utiliza para explorar y visualizar los efectos de variar características latentes específicas en un modelo generativo, como un Autoencoder Variacional (VAE). La función toma un modelo de decodificador, la dimensionalidad del espacio latente (latent_dim), un vector de características (feature_vector) y parámetros para el rango y el número de variaciones a aplicar al vector de características.
Primero, la función genera un conjunto de nuevos vectores latentes aplicando un rango de variaciones al vector de características de entrada. Luego, utiliza el modelo de decodificador para generar imágenes a partir de estos vectores latentes y remodela las imágenes para su visualización.
A continuación, traza las imágenes generadas en una fila, mostrando los efectos de variar la característica latente específica en las imágenes generadas. Utiliza un vector de características de ejemplo generado aleatoriamente a partir de una distribución normal para la demostración.
En el ejemplo, se varía la primera característica para la demostración. Sin embargo, puede modificar el índice para explorar otras características latentes.