Capítulo 4: Generación de Rostros de Proyectos con GANs
4.5 Evaluación del Modelo
Evaluar el rendimiento de una Red Generativa Adversaria (GAN) es crucial para comprender qué tan bien el modelo está generando imágenes realistas e identificar áreas de mejora. Esta sección cubrirá métodos tanto cualitativos como cuantitativos para evaluar el modelo GAN entrenado en la generación de caras. Discutiremos métricas como Inception Score (IS) y Fréchet Inception Distance (FID), y proporcionaremos códigos de ejemplo para calcular estas métricas.
4.5.1 Evaluación Cualitativa
La evaluación cualitativa implica inspeccionar visualmente las imágenes generadas para evaluar su realismo y diversidad. Este método es subjetivo pero esencial para obtener una comprensión inicial del rendimiento del modelo. Aquí hay algunos aspectos a considerar durante la evaluación cualitativa:
- Realismo: ¿Las imágenes generadas parecen caras reales?
- Diversidad: ¿Las imágenes generadas son diversas, cubriendo una amplia gama de características y expresiones faciales?
- Artefactos: ¿Hay artefactos o inconsistencias notables en las imágenes generadas?
Ejemplo: Visualización de Imágenes Generadas
Puedes visualizar las imágenes generadas utilizando matplotlib para realizar una evaluación cualitativa:
import matplotlib.pyplot as plt
import numpy as np
def plot_generated_images(generator, latent_dim, n_samples=10):
noise = np.random.normal(0, 1, (n_samples, latent_dim))
generated_images = generator.predict(noise)
generated_images = (generated_images * 127.5 + 127.5).astype(np.uint8) # Rescale to [0, 255]
plt.figure(figsize=(20, 2))
for i in range(n_samples):
plt.subplot(1, n_samples, i + 1)
plt.imshow(generated_images[i])
plt.axis('off')
plt.show()
# Generate and plot new faces for qualitative evaluation
latent_dim = 100
plot_generated_images(generator, latent_dim, n_samples=10)La función plot_generated_images genera un número especificado de imágenes (por defecto, 10) utilizando el generador. Crea ruido aleatorio con una distribución normal, lo alimenta al modelo generador y luego vuelve a escalar las imágenes resultantes para que tengan valores de píxeles en el rango de [0, 255]. Las imágenes se muestran en una trama con el tamaño de figura especificado.
Las dos últimas líneas de código llaman a esta función usando un modelo generador y una dimensión latente de 100, generando y mostrando 10 imágenes.
4.5.2 Evaluación Cuantitativa
La evaluación cuantitativa proporciona medidas objetivas de la calidad y diversidad de las imágenes generadas. Dos métricas ampliamente utilizadas para evaluar los GAN son el Inception Score (IS) y el Fréchet Inception Distance (FID).
Inception Score (IS)
El Inception Score mide la calidad y diversidad de las imágenes generadas evaluando qué tan bien coinciden con las etiquetas de clase predichas por una red Inception preentrenada. Puntuaciones más altas indican mejor calidad y diversidad.
Formula:
FID=∣∣μr−μg∣∣2+Tr(Σr+Σg−2(ΣrΣg)1/2) donde μr,Σr y μg,Σg son las medias y covarianzas de las distribuciones de imágenes reales y generadas, respectivamente.
Ejemplo: Cálculo del Inception Score
from tensorflow.keras.applications.inception_v3 import InceptionV3, preprocess_input
from scipy.stats import entropy
import numpy as np
def calculate_inception_score(images, n_split=10, eps=1E-16):
# Load InceptionV3 model
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)
# Predict the probability distribution
preds = model.predict(images_preprocessed)
# Calculate the mean KL divergence
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
n_samples = 1000
noise = np.random.normal(0, 1, (n_samples, latent_dim))
generated_images = generator.predict(noise)
# Calculate Inception Score
is_mean, is_std = calculate_inception_score(generated_images)
print(f"Inception Score: {is_mean} ± {is_std}")El código primero importa los módulos necesarios y define una función llamada 'calculate_inception_score'. Esta función utiliza el modelo InceptionV3 de TensorFlow para predecir la distribución de probabilidad de las clases para cada imagen. Luego, calcula la divergencia de Kullback-Leibler (KL) entre las distribuciones predichas y la distribución media, que se utiliza para calcular el Inception Score.
Un Inception Score alto indica que el modelo genera imágenes diversas y realistas. La función devuelve la media y la desviación estándar de los Inception Scores para un conjunto dado de imágenes.
La última parte del código genera imágenes a partir de ruido aleatorio utilizando un modelo 'generator' y luego calcula e imprime el Inception Score para estas imágenes.
Fréchet Inception Distance (FID)
El Fréchet Inception Distance mide la distancia entre las distribuciones de imágenes reales y generadas. Puntajes FID más bajos indican mejor calidad y diversidad de las imágenes generadas.
Formula:
FID=∣∣μr−μg∣∣2+Tr(Σr+Σg−2(ΣrΣg)1/2) donde μr,Σr y μg,Σg son las medias y covarianzas de las distribuciones de imágenes reales y generadas, respectivamente.
Ejemplo: Cálculo del FID
from numpy import cov, trace, iscomplexobj
from scipy.linalg import sqrtm
def calculate_fid(real_images, generated_images):
# Load InceptionV3 model
model = InceptionV3(include_top=False, pooling='avg', input_shape=(299, 299, 3))
# Resize and preprocess images
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)
# Calculate activations
act1 = model.predict(real_images_preprocessed)
act2 = model.predict(generated_images_preprocessed)
# Calculate mean and covariance
mu1, sigma1 = act1.mean(axis=0), cov(act1, rowvar=False)
mu2, sigma2 = act2.mean(axis=0), cov(act2, rowvar=False)
# Calculate FID
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
# Generate images
n_samples = 1000
noise = np.random.normal(0, 1, (n_samples, latent_dim))
generated_images = generator.predict(noise)
# Sample real images
real_images = x_train[np.random.choice(x_train.shape[0], n_samples, replace=False)]
# Calculate FID
fid_score = calculate_fid(real_images, generated_images)
print(f"FID Score: {fid_score}")El script incluye una función calculate_fid(real_images, generated_images) que calcula el puntaje FID. Utiliza el modelo InceptionV3 de Keras para calcular las activaciones de imágenes reales y generadas. Estas activaciones se usan luego para calcular la media y la covarianza de los conjuntos de imágenes.
El puntaje FID se calcula como la suma de la diferencia al cuadrado entre las medias y la traza de la suma de las covarianzas menos dos veces la raíz cuadrada del producto de las covarianzas.
Luego, la función se utiliza con un conjunto de imágenes reales y un conjunto de imágenes generadas para calcular el puntaje FID. Las imágenes generadas son creadas por una red generadora a partir de ruido aleatorio, y las imágenes reales se toman de un conjunto de entrenamiento x_train. Finalmente, se imprime el puntaje FID.
4.5.3 Comparación con Modelos de Referencia
Para comprender el rendimiento de tu modelo GAN, es útil comparar los resultados con modelos de referencia. Esto podría implicar:
- Comparar con un GAN entrenado con una arquitectura diferente.
- Comparar con un GAN entrenado con diferentes hiperparámetros.
- Comparar con otros modelos generativos como los VAEs (Autoencoders Variacionales).
4.5.4 Abordar Problemas Comunes
Durante la evaluación, podrías encontrar problemas comunes como:
- Colapso de Modo: El generador produce una diversidad limitada en las imágenes de salida. Esto se puede abordar con técnicas como la discriminación por minibatch, GANs desenrollados o usando diferentes funciones de pérdida.
- Inestabilidad en el Entrenamiento: Las pérdidas del generador y del discriminador oscilan significativamente. Esto se puede mitigar usando técnicas como Wasserstein GANs (WGANs) o normalización espectral.
Resumen
Evaluar un GAN implica métodos tanto cualitativos como cuantitativos para asegurar que las imágenes generadas sean realistas y diversas. La evaluación cualitativa mediante la inspección visual ayuda a identificar problemas inmediatos, mientras que métricas cuantitativas como el Inception Score y el Fréchet Inception Distance proporcionan medidas objetivas del rendimiento. Al evaluar y comparar sistemáticamente las salidas del modelo, puedes identificar áreas de mejora y refinar tu GAN para producir imágenes de alta calidad.
4.5 Evaluación del Modelo
Evaluar el rendimiento de una Red Generativa Adversaria (GAN) es crucial para comprender qué tan bien el modelo está generando imágenes realistas e identificar áreas de mejora. Esta sección cubrirá métodos tanto cualitativos como cuantitativos para evaluar el modelo GAN entrenado en la generación de caras. Discutiremos métricas como Inception Score (IS) y Fréchet Inception Distance (FID), y proporcionaremos códigos de ejemplo para calcular estas métricas.
4.5.1 Evaluación Cualitativa
La evaluación cualitativa implica inspeccionar visualmente las imágenes generadas para evaluar su realismo y diversidad. Este método es subjetivo pero esencial para obtener una comprensión inicial del rendimiento del modelo. Aquí hay algunos aspectos a considerar durante la evaluación cualitativa:
- Realismo: ¿Las imágenes generadas parecen caras reales?
- Diversidad: ¿Las imágenes generadas son diversas, cubriendo una amplia gama de características y expresiones faciales?
- Artefactos: ¿Hay artefactos o inconsistencias notables en las imágenes generadas?
Ejemplo: Visualización de Imágenes Generadas
Puedes visualizar las imágenes generadas utilizando matplotlib para realizar una evaluación cualitativa:
import matplotlib.pyplot as plt
import numpy as np
def plot_generated_images(generator, latent_dim, n_samples=10):
noise = np.random.normal(0, 1, (n_samples, latent_dim))
generated_images = generator.predict(noise)
generated_images = (generated_images * 127.5 + 127.5).astype(np.uint8) # Rescale to [0, 255]
plt.figure(figsize=(20, 2))
for i in range(n_samples):
plt.subplot(1, n_samples, i + 1)
plt.imshow(generated_images[i])
plt.axis('off')
plt.show()
# Generate and plot new faces for qualitative evaluation
latent_dim = 100
plot_generated_images(generator, latent_dim, n_samples=10)La función plot_generated_images genera un número especificado de imágenes (por defecto, 10) utilizando el generador. Crea ruido aleatorio con una distribución normal, lo alimenta al modelo generador y luego vuelve a escalar las imágenes resultantes para que tengan valores de píxeles en el rango de [0, 255]. Las imágenes se muestran en una trama con el tamaño de figura especificado.
Las dos últimas líneas de código llaman a esta función usando un modelo generador y una dimensión latente de 100, generando y mostrando 10 imágenes.
4.5.2 Evaluación Cuantitativa
La evaluación cuantitativa proporciona medidas objetivas de la calidad y diversidad de las imágenes generadas. Dos métricas ampliamente utilizadas para evaluar los GAN son el Inception Score (IS) y el Fréchet Inception Distance (FID).
Inception Score (IS)
El Inception Score mide la calidad y diversidad de las imágenes generadas evaluando qué tan bien coinciden con las etiquetas de clase predichas por una red Inception preentrenada. Puntuaciones más altas indican mejor calidad y diversidad.
Formula:
FID=∣∣μr−μg∣∣2+Tr(Σr+Σg−2(ΣrΣg)1/2) donde μr,Σr y μg,Σg son las medias y covarianzas de las distribuciones de imágenes reales y generadas, respectivamente.
Ejemplo: Cálculo del Inception Score
from tensorflow.keras.applications.inception_v3 import InceptionV3, preprocess_input
from scipy.stats import entropy
import numpy as np
def calculate_inception_score(images, n_split=10, eps=1E-16):
# Load InceptionV3 model
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)
# Predict the probability distribution
preds = model.predict(images_preprocessed)
# Calculate the mean KL divergence
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
n_samples = 1000
noise = np.random.normal(0, 1, (n_samples, latent_dim))
generated_images = generator.predict(noise)
# Calculate Inception Score
is_mean, is_std = calculate_inception_score(generated_images)
print(f"Inception Score: {is_mean} ± {is_std}")El código primero importa los módulos necesarios y define una función llamada 'calculate_inception_score'. Esta función utiliza el modelo InceptionV3 de TensorFlow para predecir la distribución de probabilidad de las clases para cada imagen. Luego, calcula la divergencia de Kullback-Leibler (KL) entre las distribuciones predichas y la distribución media, que se utiliza para calcular el Inception Score.
Un Inception Score alto indica que el modelo genera imágenes diversas y realistas. La función devuelve la media y la desviación estándar de los Inception Scores para un conjunto dado de imágenes.
La última parte del código genera imágenes a partir de ruido aleatorio utilizando un modelo 'generator' y luego calcula e imprime el Inception Score para estas imágenes.
Fréchet Inception Distance (FID)
El Fréchet Inception Distance mide la distancia entre las distribuciones de imágenes reales y generadas. Puntajes FID más bajos indican mejor calidad y diversidad de las imágenes generadas.
Formula:
FID=∣∣μr−μg∣∣2+Tr(Σr+Σg−2(ΣrΣg)1/2) donde μr,Σr y μg,Σg son las medias y covarianzas de las distribuciones de imágenes reales y generadas, respectivamente.
Ejemplo: Cálculo del FID
from numpy import cov, trace, iscomplexobj
from scipy.linalg import sqrtm
def calculate_fid(real_images, generated_images):
# Load InceptionV3 model
model = InceptionV3(include_top=False, pooling='avg', input_shape=(299, 299, 3))
# Resize and preprocess images
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)
# Calculate activations
act1 = model.predict(real_images_preprocessed)
act2 = model.predict(generated_images_preprocessed)
# Calculate mean and covariance
mu1, sigma1 = act1.mean(axis=0), cov(act1, rowvar=False)
mu2, sigma2 = act2.mean(axis=0), cov(act2, rowvar=False)
# Calculate FID
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
# Generate images
n_samples = 1000
noise = np.random.normal(0, 1, (n_samples, latent_dim))
generated_images = generator.predict(noise)
# Sample real images
real_images = x_train[np.random.choice(x_train.shape[0], n_samples, replace=False)]
# Calculate FID
fid_score = calculate_fid(real_images, generated_images)
print(f"FID Score: {fid_score}")El script incluye una función calculate_fid(real_images, generated_images) que calcula el puntaje FID. Utiliza el modelo InceptionV3 de Keras para calcular las activaciones de imágenes reales y generadas. Estas activaciones se usan luego para calcular la media y la covarianza de los conjuntos de imágenes.
El puntaje FID se calcula como la suma de la diferencia al cuadrado entre las medias y la traza de la suma de las covarianzas menos dos veces la raíz cuadrada del producto de las covarianzas.
Luego, la función se utiliza con un conjunto de imágenes reales y un conjunto de imágenes generadas para calcular el puntaje FID. Las imágenes generadas son creadas por una red generadora a partir de ruido aleatorio, y las imágenes reales se toman de un conjunto de entrenamiento x_train. Finalmente, se imprime el puntaje FID.
4.5.3 Comparación con Modelos de Referencia
Para comprender el rendimiento de tu modelo GAN, es útil comparar los resultados con modelos de referencia. Esto podría implicar:
- Comparar con un GAN entrenado con una arquitectura diferente.
- Comparar con un GAN entrenado con diferentes hiperparámetros.
- Comparar con otros modelos generativos como los VAEs (Autoencoders Variacionales).
4.5.4 Abordar Problemas Comunes
Durante la evaluación, podrías encontrar problemas comunes como:
- Colapso de Modo: El generador produce una diversidad limitada en las imágenes de salida. Esto se puede abordar con técnicas como la discriminación por minibatch, GANs desenrollados o usando diferentes funciones de pérdida.
- Inestabilidad en el Entrenamiento: Las pérdidas del generador y del discriminador oscilan significativamente. Esto se puede mitigar usando técnicas como Wasserstein GANs (WGANs) o normalización espectral.
Resumen
Evaluar un GAN implica métodos tanto cualitativos como cuantitativos para asegurar que las imágenes generadas sean realistas y diversas. La evaluación cualitativa mediante la inspección visual ayuda a identificar problemas inmediatos, mientras que métricas cuantitativas como el Inception Score y el Fréchet Inception Distance proporcionan medidas objetivas del rendimiento. Al evaluar y comparar sistemáticamente las salidas del modelo, puedes identificar áreas de mejora y refinar tu GAN para producir imágenes de alta calidad.
4.5 Evaluación del Modelo
Evaluar el rendimiento de una Red Generativa Adversaria (GAN) es crucial para comprender qué tan bien el modelo está generando imágenes realistas e identificar áreas de mejora. Esta sección cubrirá métodos tanto cualitativos como cuantitativos para evaluar el modelo GAN entrenado en la generación de caras. Discutiremos métricas como Inception Score (IS) y Fréchet Inception Distance (FID), y proporcionaremos códigos de ejemplo para calcular estas métricas.
4.5.1 Evaluación Cualitativa
La evaluación cualitativa implica inspeccionar visualmente las imágenes generadas para evaluar su realismo y diversidad. Este método es subjetivo pero esencial para obtener una comprensión inicial del rendimiento del modelo. Aquí hay algunos aspectos a considerar durante la evaluación cualitativa:
- Realismo: ¿Las imágenes generadas parecen caras reales?
- Diversidad: ¿Las imágenes generadas son diversas, cubriendo una amplia gama de características y expresiones faciales?
- Artefactos: ¿Hay artefactos o inconsistencias notables en las imágenes generadas?
Ejemplo: Visualización de Imágenes Generadas
Puedes visualizar las imágenes generadas utilizando matplotlib para realizar una evaluación cualitativa:
import matplotlib.pyplot as plt
import numpy as np
def plot_generated_images(generator, latent_dim, n_samples=10):
noise = np.random.normal(0, 1, (n_samples, latent_dim))
generated_images = generator.predict(noise)
generated_images = (generated_images * 127.5 + 127.5).astype(np.uint8) # Rescale to [0, 255]
plt.figure(figsize=(20, 2))
for i in range(n_samples):
plt.subplot(1, n_samples, i + 1)
plt.imshow(generated_images[i])
plt.axis('off')
plt.show()
# Generate and plot new faces for qualitative evaluation
latent_dim = 100
plot_generated_images(generator, latent_dim, n_samples=10)La función plot_generated_images genera un número especificado de imágenes (por defecto, 10) utilizando el generador. Crea ruido aleatorio con una distribución normal, lo alimenta al modelo generador y luego vuelve a escalar las imágenes resultantes para que tengan valores de píxeles en el rango de [0, 255]. Las imágenes se muestran en una trama con el tamaño de figura especificado.
Las dos últimas líneas de código llaman a esta función usando un modelo generador y una dimensión latente de 100, generando y mostrando 10 imágenes.
4.5.2 Evaluación Cuantitativa
La evaluación cuantitativa proporciona medidas objetivas de la calidad y diversidad de las imágenes generadas. Dos métricas ampliamente utilizadas para evaluar los GAN son el Inception Score (IS) y el Fréchet Inception Distance (FID).
Inception Score (IS)
El Inception Score mide la calidad y diversidad de las imágenes generadas evaluando qué tan bien coinciden con las etiquetas de clase predichas por una red Inception preentrenada. Puntuaciones más altas indican mejor calidad y diversidad.
Formula:
FID=∣∣μr−μg∣∣2+Tr(Σr+Σg−2(ΣrΣg)1/2) donde μr,Σr y μg,Σg son las medias y covarianzas de las distribuciones de imágenes reales y generadas, respectivamente.
Ejemplo: Cálculo del Inception Score
from tensorflow.keras.applications.inception_v3 import InceptionV3, preprocess_input
from scipy.stats import entropy
import numpy as np
def calculate_inception_score(images, n_split=10, eps=1E-16):
# Load InceptionV3 model
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)
# Predict the probability distribution
preds = model.predict(images_preprocessed)
# Calculate the mean KL divergence
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
n_samples = 1000
noise = np.random.normal(0, 1, (n_samples, latent_dim))
generated_images = generator.predict(noise)
# Calculate Inception Score
is_mean, is_std = calculate_inception_score(generated_images)
print(f"Inception Score: {is_mean} ± {is_std}")El código primero importa los módulos necesarios y define una función llamada 'calculate_inception_score'. Esta función utiliza el modelo InceptionV3 de TensorFlow para predecir la distribución de probabilidad de las clases para cada imagen. Luego, calcula la divergencia de Kullback-Leibler (KL) entre las distribuciones predichas y la distribución media, que se utiliza para calcular el Inception Score.
Un Inception Score alto indica que el modelo genera imágenes diversas y realistas. La función devuelve la media y la desviación estándar de los Inception Scores para un conjunto dado de imágenes.
La última parte del código genera imágenes a partir de ruido aleatorio utilizando un modelo 'generator' y luego calcula e imprime el Inception Score para estas imágenes.
Fréchet Inception Distance (FID)
El Fréchet Inception Distance mide la distancia entre las distribuciones de imágenes reales y generadas. Puntajes FID más bajos indican mejor calidad y diversidad de las imágenes generadas.
Formula:
FID=∣∣μr−μg∣∣2+Tr(Σr+Σg−2(ΣrΣg)1/2) donde μr,Σr y μg,Σg son las medias y covarianzas de las distribuciones de imágenes reales y generadas, respectivamente.
Ejemplo: Cálculo del FID
from numpy import cov, trace, iscomplexobj
from scipy.linalg import sqrtm
def calculate_fid(real_images, generated_images):
# Load InceptionV3 model
model = InceptionV3(include_top=False, pooling='avg', input_shape=(299, 299, 3))
# Resize and preprocess images
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)
# Calculate activations
act1 = model.predict(real_images_preprocessed)
act2 = model.predict(generated_images_preprocessed)
# Calculate mean and covariance
mu1, sigma1 = act1.mean(axis=0), cov(act1, rowvar=False)
mu2, sigma2 = act2.mean(axis=0), cov(act2, rowvar=False)
# Calculate FID
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
# Generate images
n_samples = 1000
noise = np.random.normal(0, 1, (n_samples, latent_dim))
generated_images = generator.predict(noise)
# Sample real images
real_images = x_train[np.random.choice(x_train.shape[0], n_samples, replace=False)]
# Calculate FID
fid_score = calculate_fid(real_images, generated_images)
print(f"FID Score: {fid_score}")El script incluye una función calculate_fid(real_images, generated_images) que calcula el puntaje FID. Utiliza el modelo InceptionV3 de Keras para calcular las activaciones de imágenes reales y generadas. Estas activaciones se usan luego para calcular la media y la covarianza de los conjuntos de imágenes.
El puntaje FID se calcula como la suma de la diferencia al cuadrado entre las medias y la traza de la suma de las covarianzas menos dos veces la raíz cuadrada del producto de las covarianzas.
Luego, la función se utiliza con un conjunto de imágenes reales y un conjunto de imágenes generadas para calcular el puntaje FID. Las imágenes generadas son creadas por una red generadora a partir de ruido aleatorio, y las imágenes reales se toman de un conjunto de entrenamiento x_train. Finalmente, se imprime el puntaje FID.
4.5.3 Comparación con Modelos de Referencia
Para comprender el rendimiento de tu modelo GAN, es útil comparar los resultados con modelos de referencia. Esto podría implicar:
- Comparar con un GAN entrenado con una arquitectura diferente.
- Comparar con un GAN entrenado con diferentes hiperparámetros.
- Comparar con otros modelos generativos como los VAEs (Autoencoders Variacionales).
4.5.4 Abordar Problemas Comunes
Durante la evaluación, podrías encontrar problemas comunes como:
- Colapso de Modo: El generador produce una diversidad limitada en las imágenes de salida. Esto se puede abordar con técnicas como la discriminación por minibatch, GANs desenrollados o usando diferentes funciones de pérdida.
- Inestabilidad en el Entrenamiento: Las pérdidas del generador y del discriminador oscilan significativamente. Esto se puede mitigar usando técnicas como Wasserstein GANs (WGANs) o normalización espectral.
Resumen
Evaluar un GAN implica métodos tanto cualitativos como cuantitativos para asegurar que las imágenes generadas sean realistas y diversas. La evaluación cualitativa mediante la inspección visual ayuda a identificar problemas inmediatos, mientras que métricas cuantitativas como el Inception Score y el Fréchet Inception Distance proporcionan medidas objetivas del rendimiento. Al evaluar y comparar sistemáticamente las salidas del modelo, puedes identificar áreas de mejora y refinar tu GAN para producir imágenes de alta calidad.
4.5 Evaluación del Modelo
Evaluar el rendimiento de una Red Generativa Adversaria (GAN) es crucial para comprender qué tan bien el modelo está generando imágenes realistas e identificar áreas de mejora. Esta sección cubrirá métodos tanto cualitativos como cuantitativos para evaluar el modelo GAN entrenado en la generación de caras. Discutiremos métricas como Inception Score (IS) y Fréchet Inception Distance (FID), y proporcionaremos códigos de ejemplo para calcular estas métricas.
4.5.1 Evaluación Cualitativa
La evaluación cualitativa implica inspeccionar visualmente las imágenes generadas para evaluar su realismo y diversidad. Este método es subjetivo pero esencial para obtener una comprensión inicial del rendimiento del modelo. Aquí hay algunos aspectos a considerar durante la evaluación cualitativa:
- Realismo: ¿Las imágenes generadas parecen caras reales?
- Diversidad: ¿Las imágenes generadas son diversas, cubriendo una amplia gama de características y expresiones faciales?
- Artefactos: ¿Hay artefactos o inconsistencias notables en las imágenes generadas?
Ejemplo: Visualización de Imágenes Generadas
Puedes visualizar las imágenes generadas utilizando matplotlib para realizar una evaluación cualitativa:
import matplotlib.pyplot as plt
import numpy as np
def plot_generated_images(generator, latent_dim, n_samples=10):
noise = np.random.normal(0, 1, (n_samples, latent_dim))
generated_images = generator.predict(noise)
generated_images = (generated_images * 127.5 + 127.5).astype(np.uint8) # Rescale to [0, 255]
plt.figure(figsize=(20, 2))
for i in range(n_samples):
plt.subplot(1, n_samples, i + 1)
plt.imshow(generated_images[i])
plt.axis('off')
plt.show()
# Generate and plot new faces for qualitative evaluation
latent_dim = 100
plot_generated_images(generator, latent_dim, n_samples=10)La función plot_generated_images genera un número especificado de imágenes (por defecto, 10) utilizando el generador. Crea ruido aleatorio con una distribución normal, lo alimenta al modelo generador y luego vuelve a escalar las imágenes resultantes para que tengan valores de píxeles en el rango de [0, 255]. Las imágenes se muestran en una trama con el tamaño de figura especificado.
Las dos últimas líneas de código llaman a esta función usando un modelo generador y una dimensión latente de 100, generando y mostrando 10 imágenes.
4.5.2 Evaluación Cuantitativa
La evaluación cuantitativa proporciona medidas objetivas de la calidad y diversidad de las imágenes generadas. Dos métricas ampliamente utilizadas para evaluar los GAN son el Inception Score (IS) y el Fréchet Inception Distance (FID).
Inception Score (IS)
El Inception Score mide la calidad y diversidad de las imágenes generadas evaluando qué tan bien coinciden con las etiquetas de clase predichas por una red Inception preentrenada. Puntuaciones más altas indican mejor calidad y diversidad.
Formula:
FID=∣∣μr−μg∣∣2+Tr(Σr+Σg−2(ΣrΣg)1/2) donde μr,Σr y μg,Σg son las medias y covarianzas de las distribuciones de imágenes reales y generadas, respectivamente.
Ejemplo: Cálculo del Inception Score
from tensorflow.keras.applications.inception_v3 import InceptionV3, preprocess_input
from scipy.stats import entropy
import numpy as np
def calculate_inception_score(images, n_split=10, eps=1E-16):
# Load InceptionV3 model
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)
# Predict the probability distribution
preds = model.predict(images_preprocessed)
# Calculate the mean KL divergence
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
n_samples = 1000
noise = np.random.normal(0, 1, (n_samples, latent_dim))
generated_images = generator.predict(noise)
# Calculate Inception Score
is_mean, is_std = calculate_inception_score(generated_images)
print(f"Inception Score: {is_mean} ± {is_std}")El código primero importa los módulos necesarios y define una función llamada 'calculate_inception_score'. Esta función utiliza el modelo InceptionV3 de TensorFlow para predecir la distribución de probabilidad de las clases para cada imagen. Luego, calcula la divergencia de Kullback-Leibler (KL) entre las distribuciones predichas y la distribución media, que se utiliza para calcular el Inception Score.
Un Inception Score alto indica que el modelo genera imágenes diversas y realistas. La función devuelve la media y la desviación estándar de los Inception Scores para un conjunto dado de imágenes.
La última parte del código genera imágenes a partir de ruido aleatorio utilizando un modelo 'generator' y luego calcula e imprime el Inception Score para estas imágenes.
Fréchet Inception Distance (FID)
El Fréchet Inception Distance mide la distancia entre las distribuciones de imágenes reales y generadas. Puntajes FID más bajos indican mejor calidad y diversidad de las imágenes generadas.
Formula:
FID=∣∣μr−μg∣∣2+Tr(Σr+Σg−2(ΣrΣg)1/2) donde μr,Σr y μg,Σg son las medias y covarianzas de las distribuciones de imágenes reales y generadas, respectivamente.
Ejemplo: Cálculo del FID
from numpy import cov, trace, iscomplexobj
from scipy.linalg import sqrtm
def calculate_fid(real_images, generated_images):
# Load InceptionV3 model
model = InceptionV3(include_top=False, pooling='avg', input_shape=(299, 299, 3))
# Resize and preprocess images
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)
# Calculate activations
act1 = model.predict(real_images_preprocessed)
act2 = model.predict(generated_images_preprocessed)
# Calculate mean and covariance
mu1, sigma1 = act1.mean(axis=0), cov(act1, rowvar=False)
mu2, sigma2 = act2.mean(axis=0), cov(act2, rowvar=False)
# Calculate FID
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
# Generate images
n_samples = 1000
noise = np.random.normal(0, 1, (n_samples, latent_dim))
generated_images = generator.predict(noise)
# Sample real images
real_images = x_train[np.random.choice(x_train.shape[0], n_samples, replace=False)]
# Calculate FID
fid_score = calculate_fid(real_images, generated_images)
print(f"FID Score: {fid_score}")El script incluye una función calculate_fid(real_images, generated_images) que calcula el puntaje FID. Utiliza el modelo InceptionV3 de Keras para calcular las activaciones de imágenes reales y generadas. Estas activaciones se usan luego para calcular la media y la covarianza de los conjuntos de imágenes.
El puntaje FID se calcula como la suma de la diferencia al cuadrado entre las medias y la traza de la suma de las covarianzas menos dos veces la raíz cuadrada del producto de las covarianzas.
Luego, la función se utiliza con un conjunto de imágenes reales y un conjunto de imágenes generadas para calcular el puntaje FID. Las imágenes generadas son creadas por una red generadora a partir de ruido aleatorio, y las imágenes reales se toman de un conjunto de entrenamiento x_train. Finalmente, se imprime el puntaje FID.
4.5.3 Comparación con Modelos de Referencia
Para comprender el rendimiento de tu modelo GAN, es útil comparar los resultados con modelos de referencia. Esto podría implicar:
- Comparar con un GAN entrenado con una arquitectura diferente.
- Comparar con un GAN entrenado con diferentes hiperparámetros.
- Comparar con otros modelos generativos como los VAEs (Autoencoders Variacionales).
4.5.4 Abordar Problemas Comunes
Durante la evaluación, podrías encontrar problemas comunes como:
- Colapso de Modo: El generador produce una diversidad limitada en las imágenes de salida. Esto se puede abordar con técnicas como la discriminación por minibatch, GANs desenrollados o usando diferentes funciones de pérdida.
- Inestabilidad en el Entrenamiento: Las pérdidas del generador y del discriminador oscilan significativamente. Esto se puede mitigar usando técnicas como Wasserstein GANs (WGANs) o normalización espectral.
Resumen
Evaluar un GAN implica métodos tanto cualitativos como cuantitativos para asegurar que las imágenes generadas sean realistas y diversas. La evaluación cualitativa mediante la inspección visual ayuda a identificar problemas inmediatos, mientras que métricas cuantitativas como el Inception Score y el Fréchet Inception Distance proporcionan medidas objetivas del rendimiento. Al evaluar y comparar sistemáticamente las salidas del modelo, puedes identificar áreas de mejora y refinar tu GAN para producir imágenes de alta calidad.