Capítulo 4: Generación de Rostros de Proyectos con GANs
4.3 Entrenamiento de la GAN
Entrenar una Red Generativa Adversaria (GAN) es un proceso matizado que implica actualizar iterativamente las redes del generador y el discriminador para mejorar la calidad de las imágenes generadas. Esta sección te guiará a través de los pasos para entrenar una GAN para generar caras humanas realistas, incluyendo los bucles de entrenamiento necesarios, funciones de pérdida y técnicas de monitoreo.
4.3.1 Resumen del Proceso de Entrenamiento
El proceso de entrenamiento de una GAN implica dos pasos principales en cada iteración:
- Entrenamiento del Discriminador: El discriminador se entrena para diferenciar entre imágenes reales del conjunto de datos e imágenes falsas generadas por el generador.
- Entrenamiento del Generador: El generador se entrena para producir imágenes que puedan engañar al discriminador haciéndole clasificar las imágenes falsas como reales.
Para lograr esto, el bucle de entrenamiento consiste en:
- Generar un lote de imágenes falsas a partir de ruido aleatorio.
- Obtener un lote de imágenes reales del conjunto de datos.
- Entrenar el discriminador con imágenes reales y falsas.
- Entrenar el generador a través del modelo GAN combinado, donde los pesos del discriminador están congelados.
4.3.2 Entrenamiento del Discriminador
El discriminador se entrena para maximizar la probabilidad de clasificar correctamente las imágenes reales y falsas. La función de pérdida utilizada es la entropía cruzada binaria.
LD=−m1∑i=1m[yilog(D(xi))+(1−yi)log(1−D(G(zi)))]
donde yiy_iyi es la etiqueta (1 para real, 0 para falso), D(xi)D(x_i)D(xi) es la predicción del discriminador para imágenes reales, y D(G(zi))D(G(z_i))D(G(zi)) es la predicción del discriminador para imágenes falsas.
Ejemplo: Código de Entrenamiento del Discriminador
import numpy as np
# Training parameters
epochs = 10000
batch_size = 64
sample_interval = 1000
# Adversarial ground truths
real = np.ones((batch_size, 1))
fake = np.zeros((batch_size, 1))
# Training loop for discriminator
for epoch in range(epochs):
# Train the discriminator
# Select a random batch of real images
idx = np.random.randint(0, train_images.shape[0], batch_size)
real_images = train_images[idx]
# Generate a batch of fake images
noise = np.random.normal(0, 1, (batch_size, latent_dim))
fake_images = generator.predict(noise)
# Train the discriminator on real and fake images
d_loss_real = discriminator.train_on_batch(real_images, real)
d_loss_fake = discriminator.train_on_batch(fake_images, fake)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# Print progress
if epoch % sample_interval == 0:
print(f"{epoch} [D loss: {d_loss[0]}, acc.: {d_loss[1] * 100}%]")Los parámetros de entrenamiento indican que el proceso de entrenamiento continuará durante 10,000 épocas, con un tamaño de lote de 64 y un intervalo de muestreo de 1000.
Las variables 'real' y 'fake' representan las etiquetas para las imágenes reales y falsas respectivamente, que se utilizan durante el entrenamiento del discriminador.
Dentro del bucle de entrenamiento, para cada época, el discriminador se entrena con un lote de imágenes reales y un lote de imágenes falsas. En cada iteración, se selecciona aleatoriamente un lote de imágenes reales de los datos de entrenamiento, y el generador genera un lote de imágenes falsas.
Se calcula la pérdida del discriminador tanto para imágenes reales como falsas, y se toma el promedio. Si la época actual es un múltiplo del intervalo de muestreo, el programa imprime el número de época, la pérdida del discriminador y la precisión.
4.3.3 Entrenamiento del Generador
El generador se entrena para maximizar la probabilidad de que el discriminador clasifique sus salidas como reales. Esto se logra entrenando el generador a través del modelo GAN combinado, donde los pesos del discriminador están congelados.
Pérdida del Generador:
Ejemplo: Código de Entrenamiento del Generador
# Training loop for generator
for epoch in range(epochs):
# Train the discriminator
idx = np.random.randint(0, train_images.shape[0], batch_size)
real_images = train_images[idx]
noise = np.random.normal(0, 1, (batch_size, latent_dim))
fake_images = generator.predict(noise)
d_loss_real = discriminator.train_on_batch(real_images, real)
d_loss_fake = discriminator.train_on_batch(fake_images, fake)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# Train the generator
noise = np.random.normal(0, 1, (batch_size, latent_dim))
g_loss = gan.train_on_batch(noise, real)
# Print progress
if epoch % sample_interval == 0:
print(f"{epoch} [D loss: {d_loss[0]}, acc.: {d_loss[1] * 100}%] [G loss: {g_loss}]")
# Generate and save images
noise = np.random.normal(0, 1, (10, latent_dim))
generated_images = generator.predict(noise)
fig, axs = plt.subplots(1, 10, figsize=(20, 2))
for i, img in enumerate(generated_images):
axs[i].imshow((img * 127.5 + 127.5).astype(np.uint8))
axs[i].axis('off')
plt.show()Primero, se selecciona un conjunto de imágenes reales y se genera un conjunto de imágenes falsas mediante el generador. El discriminador se entrena con ambos conjuntos. Luego, se calcula la pérdida promedio del discriminador.
A continuación, el generador se entrena utilizando el mismo ruido como entrada pero con las etiquetas de las imágenes reales. El objetivo aquí es engañar al discriminador para que piense que las imágenes generadas son reales.
El script luego imprime el progreso del entrenamiento, incluida la pérdida del discriminador y del generador. Si se alcanza un cierto número de épocas (determinado por el sample_interval), el generador producirá y guardará algunas imágenes de muestra para inspección. Las imágenes se normalizan y se muestran utilizando matplotlib.
4.3.4 Monitoreo del Proceso de Entrenamiento
Para asegurarse de que la GAN se está entrenando de manera efectiva, es esencial monitorear el proceso de entrenamiento. Esto incluye:
- Monitoreo de la Pérdida: Rastrear los valores de pérdida tanto del discriminador como del generador a lo largo del tiempo.
- Muestras Generadas: Generar y visualizar periódicamente imágenes para evaluar cualitativamente el rendimiento del generador.
- Guardado de Modelos: Guardar los pesos del modelo a intervalos regulares para protegerse contra posibles interrupciones del entrenamiento y facilitar la evaluación futura o un entrenamiento adicional.
Ejemplo: Código de Monitoreo
import matplotlib.pyplot as plt
# Function to plot generated images
def plot_generated_images(epoch, generator, examples=10, dim=(1, 10), figsize=(20, 2)):
noise = np.random.normal(0, 1, (examples, latent_dim))
generated_images = generator.predict(noise)
generated_images = (generated_images * 127.5 + 127.5).astype(np.uint8)
plt.figure(figsize=figsize)
for i in range(examples):
plt.subplot(dim[0], dim[1], i + 1)
plt.imshow(generated_images[i])
plt.axis('off')
plt.tight_layout()
plt.savefig(f"gan_generated_image_epoch_{epoch}.png")
plt.close()
# Training loop with monitoring
for epoch in range(epochs):
idx = np.random.randint(0, train_images.shape[0], batch_size)
real_images = train_images[idx]
noise = np.random.normal(0, 1, (batch_size, latent_dim))
fake_images = generator.predict(noise)
d_loss_real = discriminator.train_on_batch(real_images, real)
d_loss_fake = discriminator.train_on_batch(fake_images, fake)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
noise = np.random.normal(0, 1, (batch_size, latent_dim))
g_loss = gan.train_on_batch(noise, real)
if epoch % sample_interval == 0:
print(f"{epoch} [D loss: {d_loss[0]}, acc.: {d_loss[1] * 100}%] [G loss: {g_loss}]")
plot_generated_images(epoch, generator)
if epoch % 1000 == 0:
generator.save(f'generator_epoch_{epoch}.h5')
discriminator.save(f'discriminator_epoch_{epoch}.h5')Las GANs consisten en dos partes: un generador y un discriminador. El generador crea nuevas instancias de datos, mientras que el discriminador las evalúa para determinar su autenticidad.
Se define la función "plot_generated_images" para visualizar las imágenes generadas por la GAN después de épocas específicas.
A continuación, se configura un bucle de entrenamiento donde se alimentan imágenes reales al discriminador junto con imágenes falsas generadas por el generador. El discriminador se entrena para diferenciar entre imágenes reales y falsas.
El generador también se entrena para engañar al discriminador, haciéndole creer que las imágenes del generador son reales. Se registran las pérdidas del discriminador y del generador para su inspección.
Si la época actual es un múltiplo del "sample_interval", el código imprime las pérdidas y grafica las imágenes generadas. Si la época actual es un múltiplo de 1000, se guardan los modelos del generador y del discriminador.
Resumen
Entrenar una GAN para generar caras humanas realistas implica un delicado equilibrio entre entrenar el discriminador y el generador. Al actualizar iterativamente ambas redes, monitorear su rendimiento y guardar modelos a intervalos regulares, podemos crear una potente GAN capaz de producir imágenes de alta calidad. Este proceso requiere una atención cuidadosa a los detalles, ya que la inestabilidad en el entrenamiento puede llevar a problemas como el colapso de modos.
Con el proceso de entrenamiento configurado y en funcionamiento, los siguientes pasos se centrarán en evaluar la GAN entrenada, ajustar su rendimiento y aprovechar las imágenes generadas para diversas aplicaciones.
4.3 Entrenamiento de la GAN
Entrenar una Red Generativa Adversaria (GAN) es un proceso matizado que implica actualizar iterativamente las redes del generador y el discriminador para mejorar la calidad de las imágenes generadas. Esta sección te guiará a través de los pasos para entrenar una GAN para generar caras humanas realistas, incluyendo los bucles de entrenamiento necesarios, funciones de pérdida y técnicas de monitoreo.
4.3.1 Resumen del Proceso de Entrenamiento
El proceso de entrenamiento de una GAN implica dos pasos principales en cada iteración:
- Entrenamiento del Discriminador: El discriminador se entrena para diferenciar entre imágenes reales del conjunto de datos e imágenes falsas generadas por el generador.
- Entrenamiento del Generador: El generador se entrena para producir imágenes que puedan engañar al discriminador haciéndole clasificar las imágenes falsas como reales.
Para lograr esto, el bucle de entrenamiento consiste en:
- Generar un lote de imágenes falsas a partir de ruido aleatorio.
- Obtener un lote de imágenes reales del conjunto de datos.
- Entrenar el discriminador con imágenes reales y falsas.
- Entrenar el generador a través del modelo GAN combinado, donde los pesos del discriminador están congelados.
4.3.2 Entrenamiento del Discriminador
El discriminador se entrena para maximizar la probabilidad de clasificar correctamente las imágenes reales y falsas. La función de pérdida utilizada es la entropía cruzada binaria.
LD=−m1∑i=1m[yilog(D(xi))+(1−yi)log(1−D(G(zi)))]
donde yiy_iyi es la etiqueta (1 para real, 0 para falso), D(xi)D(x_i)D(xi) es la predicción del discriminador para imágenes reales, y D(G(zi))D(G(z_i))D(G(zi)) es la predicción del discriminador para imágenes falsas.
Ejemplo: Código de Entrenamiento del Discriminador
import numpy as np
# Training parameters
epochs = 10000
batch_size = 64
sample_interval = 1000
# Adversarial ground truths
real = np.ones((batch_size, 1))
fake = np.zeros((batch_size, 1))
# Training loop for discriminator
for epoch in range(epochs):
# Train the discriminator
# Select a random batch of real images
idx = np.random.randint(0, train_images.shape[0], batch_size)
real_images = train_images[idx]
# Generate a batch of fake images
noise = np.random.normal(0, 1, (batch_size, latent_dim))
fake_images = generator.predict(noise)
# Train the discriminator on real and fake images
d_loss_real = discriminator.train_on_batch(real_images, real)
d_loss_fake = discriminator.train_on_batch(fake_images, fake)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# Print progress
if epoch % sample_interval == 0:
print(f"{epoch} [D loss: {d_loss[0]}, acc.: {d_loss[1] * 100}%]")Los parámetros de entrenamiento indican que el proceso de entrenamiento continuará durante 10,000 épocas, con un tamaño de lote de 64 y un intervalo de muestreo de 1000.
Las variables 'real' y 'fake' representan las etiquetas para las imágenes reales y falsas respectivamente, que se utilizan durante el entrenamiento del discriminador.
Dentro del bucle de entrenamiento, para cada época, el discriminador se entrena con un lote de imágenes reales y un lote de imágenes falsas. En cada iteración, se selecciona aleatoriamente un lote de imágenes reales de los datos de entrenamiento, y el generador genera un lote de imágenes falsas.
Se calcula la pérdida del discriminador tanto para imágenes reales como falsas, y se toma el promedio. Si la época actual es un múltiplo del intervalo de muestreo, el programa imprime el número de época, la pérdida del discriminador y la precisión.
4.3.3 Entrenamiento del Generador
El generador se entrena para maximizar la probabilidad de que el discriminador clasifique sus salidas como reales. Esto se logra entrenando el generador a través del modelo GAN combinado, donde los pesos del discriminador están congelados.
Pérdida del Generador:
Ejemplo: Código de Entrenamiento del Generador
# Training loop for generator
for epoch in range(epochs):
# Train the discriminator
idx = np.random.randint(0, train_images.shape[0], batch_size)
real_images = train_images[idx]
noise = np.random.normal(0, 1, (batch_size, latent_dim))
fake_images = generator.predict(noise)
d_loss_real = discriminator.train_on_batch(real_images, real)
d_loss_fake = discriminator.train_on_batch(fake_images, fake)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# Train the generator
noise = np.random.normal(0, 1, (batch_size, latent_dim))
g_loss = gan.train_on_batch(noise, real)
# Print progress
if epoch % sample_interval == 0:
print(f"{epoch} [D loss: {d_loss[0]}, acc.: {d_loss[1] * 100}%] [G loss: {g_loss}]")
# Generate and save images
noise = np.random.normal(0, 1, (10, latent_dim))
generated_images = generator.predict(noise)
fig, axs = plt.subplots(1, 10, figsize=(20, 2))
for i, img in enumerate(generated_images):
axs[i].imshow((img * 127.5 + 127.5).astype(np.uint8))
axs[i].axis('off')
plt.show()Primero, se selecciona un conjunto de imágenes reales y se genera un conjunto de imágenes falsas mediante el generador. El discriminador se entrena con ambos conjuntos. Luego, se calcula la pérdida promedio del discriminador.
A continuación, el generador se entrena utilizando el mismo ruido como entrada pero con las etiquetas de las imágenes reales. El objetivo aquí es engañar al discriminador para que piense que las imágenes generadas son reales.
El script luego imprime el progreso del entrenamiento, incluida la pérdida del discriminador y del generador. Si se alcanza un cierto número de épocas (determinado por el sample_interval), el generador producirá y guardará algunas imágenes de muestra para inspección. Las imágenes se normalizan y se muestran utilizando matplotlib.
4.3.4 Monitoreo del Proceso de Entrenamiento
Para asegurarse de que la GAN se está entrenando de manera efectiva, es esencial monitorear el proceso de entrenamiento. Esto incluye:
- Monitoreo de la Pérdida: Rastrear los valores de pérdida tanto del discriminador como del generador a lo largo del tiempo.
- Muestras Generadas: Generar y visualizar periódicamente imágenes para evaluar cualitativamente el rendimiento del generador.
- Guardado de Modelos: Guardar los pesos del modelo a intervalos regulares para protegerse contra posibles interrupciones del entrenamiento y facilitar la evaluación futura o un entrenamiento adicional.
Ejemplo: Código de Monitoreo
import matplotlib.pyplot as plt
# Function to plot generated images
def plot_generated_images(epoch, generator, examples=10, dim=(1, 10), figsize=(20, 2)):
noise = np.random.normal(0, 1, (examples, latent_dim))
generated_images = generator.predict(noise)
generated_images = (generated_images * 127.5 + 127.5).astype(np.uint8)
plt.figure(figsize=figsize)
for i in range(examples):
plt.subplot(dim[0], dim[1], i + 1)
plt.imshow(generated_images[i])
plt.axis('off')
plt.tight_layout()
plt.savefig(f"gan_generated_image_epoch_{epoch}.png")
plt.close()
# Training loop with monitoring
for epoch in range(epochs):
idx = np.random.randint(0, train_images.shape[0], batch_size)
real_images = train_images[idx]
noise = np.random.normal(0, 1, (batch_size, latent_dim))
fake_images = generator.predict(noise)
d_loss_real = discriminator.train_on_batch(real_images, real)
d_loss_fake = discriminator.train_on_batch(fake_images, fake)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
noise = np.random.normal(0, 1, (batch_size, latent_dim))
g_loss = gan.train_on_batch(noise, real)
if epoch % sample_interval == 0:
print(f"{epoch} [D loss: {d_loss[0]}, acc.: {d_loss[1] * 100}%] [G loss: {g_loss}]")
plot_generated_images(epoch, generator)
if epoch % 1000 == 0:
generator.save(f'generator_epoch_{epoch}.h5')
discriminator.save(f'discriminator_epoch_{epoch}.h5')Las GANs consisten en dos partes: un generador y un discriminador. El generador crea nuevas instancias de datos, mientras que el discriminador las evalúa para determinar su autenticidad.
Se define la función "plot_generated_images" para visualizar las imágenes generadas por la GAN después de épocas específicas.
A continuación, se configura un bucle de entrenamiento donde se alimentan imágenes reales al discriminador junto con imágenes falsas generadas por el generador. El discriminador se entrena para diferenciar entre imágenes reales y falsas.
El generador también se entrena para engañar al discriminador, haciéndole creer que las imágenes del generador son reales. Se registran las pérdidas del discriminador y del generador para su inspección.
Si la época actual es un múltiplo del "sample_interval", el código imprime las pérdidas y grafica las imágenes generadas. Si la época actual es un múltiplo de 1000, se guardan los modelos del generador y del discriminador.
Resumen
Entrenar una GAN para generar caras humanas realistas implica un delicado equilibrio entre entrenar el discriminador y el generador. Al actualizar iterativamente ambas redes, monitorear su rendimiento y guardar modelos a intervalos regulares, podemos crear una potente GAN capaz de producir imágenes de alta calidad. Este proceso requiere una atención cuidadosa a los detalles, ya que la inestabilidad en el entrenamiento puede llevar a problemas como el colapso de modos.
Con el proceso de entrenamiento configurado y en funcionamiento, los siguientes pasos se centrarán en evaluar la GAN entrenada, ajustar su rendimiento y aprovechar las imágenes generadas para diversas aplicaciones.
4.3 Entrenamiento de la GAN
Entrenar una Red Generativa Adversaria (GAN) es un proceso matizado que implica actualizar iterativamente las redes del generador y el discriminador para mejorar la calidad de las imágenes generadas. Esta sección te guiará a través de los pasos para entrenar una GAN para generar caras humanas realistas, incluyendo los bucles de entrenamiento necesarios, funciones de pérdida y técnicas de monitoreo.
4.3.1 Resumen del Proceso de Entrenamiento
El proceso de entrenamiento de una GAN implica dos pasos principales en cada iteración:
- Entrenamiento del Discriminador: El discriminador se entrena para diferenciar entre imágenes reales del conjunto de datos e imágenes falsas generadas por el generador.
- Entrenamiento del Generador: El generador se entrena para producir imágenes que puedan engañar al discriminador haciéndole clasificar las imágenes falsas como reales.
Para lograr esto, el bucle de entrenamiento consiste en:
- Generar un lote de imágenes falsas a partir de ruido aleatorio.
- Obtener un lote de imágenes reales del conjunto de datos.
- Entrenar el discriminador con imágenes reales y falsas.
- Entrenar el generador a través del modelo GAN combinado, donde los pesos del discriminador están congelados.
4.3.2 Entrenamiento del Discriminador
El discriminador se entrena para maximizar la probabilidad de clasificar correctamente las imágenes reales y falsas. La función de pérdida utilizada es la entropía cruzada binaria.
LD=−m1∑i=1m[yilog(D(xi))+(1−yi)log(1−D(G(zi)))]
donde yiy_iyi es la etiqueta (1 para real, 0 para falso), D(xi)D(x_i)D(xi) es la predicción del discriminador para imágenes reales, y D(G(zi))D(G(z_i))D(G(zi)) es la predicción del discriminador para imágenes falsas.
Ejemplo: Código de Entrenamiento del Discriminador
import numpy as np
# Training parameters
epochs = 10000
batch_size = 64
sample_interval = 1000
# Adversarial ground truths
real = np.ones((batch_size, 1))
fake = np.zeros((batch_size, 1))
# Training loop for discriminator
for epoch in range(epochs):
# Train the discriminator
# Select a random batch of real images
idx = np.random.randint(0, train_images.shape[0], batch_size)
real_images = train_images[idx]
# Generate a batch of fake images
noise = np.random.normal(0, 1, (batch_size, latent_dim))
fake_images = generator.predict(noise)
# Train the discriminator on real and fake images
d_loss_real = discriminator.train_on_batch(real_images, real)
d_loss_fake = discriminator.train_on_batch(fake_images, fake)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# Print progress
if epoch % sample_interval == 0:
print(f"{epoch} [D loss: {d_loss[0]}, acc.: {d_loss[1] * 100}%]")Los parámetros de entrenamiento indican que el proceso de entrenamiento continuará durante 10,000 épocas, con un tamaño de lote de 64 y un intervalo de muestreo de 1000.
Las variables 'real' y 'fake' representan las etiquetas para las imágenes reales y falsas respectivamente, que se utilizan durante el entrenamiento del discriminador.
Dentro del bucle de entrenamiento, para cada época, el discriminador se entrena con un lote de imágenes reales y un lote de imágenes falsas. En cada iteración, se selecciona aleatoriamente un lote de imágenes reales de los datos de entrenamiento, y el generador genera un lote de imágenes falsas.
Se calcula la pérdida del discriminador tanto para imágenes reales como falsas, y se toma el promedio. Si la época actual es un múltiplo del intervalo de muestreo, el programa imprime el número de época, la pérdida del discriminador y la precisión.
4.3.3 Entrenamiento del Generador
El generador se entrena para maximizar la probabilidad de que el discriminador clasifique sus salidas como reales. Esto se logra entrenando el generador a través del modelo GAN combinado, donde los pesos del discriminador están congelados.
Pérdida del Generador:
Ejemplo: Código de Entrenamiento del Generador
# Training loop for generator
for epoch in range(epochs):
# Train the discriminator
idx = np.random.randint(0, train_images.shape[0], batch_size)
real_images = train_images[idx]
noise = np.random.normal(0, 1, (batch_size, latent_dim))
fake_images = generator.predict(noise)
d_loss_real = discriminator.train_on_batch(real_images, real)
d_loss_fake = discriminator.train_on_batch(fake_images, fake)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# Train the generator
noise = np.random.normal(0, 1, (batch_size, latent_dim))
g_loss = gan.train_on_batch(noise, real)
# Print progress
if epoch % sample_interval == 0:
print(f"{epoch} [D loss: {d_loss[0]}, acc.: {d_loss[1] * 100}%] [G loss: {g_loss}]")
# Generate and save images
noise = np.random.normal(0, 1, (10, latent_dim))
generated_images = generator.predict(noise)
fig, axs = plt.subplots(1, 10, figsize=(20, 2))
for i, img in enumerate(generated_images):
axs[i].imshow((img * 127.5 + 127.5).astype(np.uint8))
axs[i].axis('off')
plt.show()Primero, se selecciona un conjunto de imágenes reales y se genera un conjunto de imágenes falsas mediante el generador. El discriminador se entrena con ambos conjuntos. Luego, se calcula la pérdida promedio del discriminador.
A continuación, el generador se entrena utilizando el mismo ruido como entrada pero con las etiquetas de las imágenes reales. El objetivo aquí es engañar al discriminador para que piense que las imágenes generadas son reales.
El script luego imprime el progreso del entrenamiento, incluida la pérdida del discriminador y del generador. Si se alcanza un cierto número de épocas (determinado por el sample_interval), el generador producirá y guardará algunas imágenes de muestra para inspección. Las imágenes se normalizan y se muestran utilizando matplotlib.
4.3.4 Monitoreo del Proceso de Entrenamiento
Para asegurarse de que la GAN se está entrenando de manera efectiva, es esencial monitorear el proceso de entrenamiento. Esto incluye:
- Monitoreo de la Pérdida: Rastrear los valores de pérdida tanto del discriminador como del generador a lo largo del tiempo.
- Muestras Generadas: Generar y visualizar periódicamente imágenes para evaluar cualitativamente el rendimiento del generador.
- Guardado de Modelos: Guardar los pesos del modelo a intervalos regulares para protegerse contra posibles interrupciones del entrenamiento y facilitar la evaluación futura o un entrenamiento adicional.
Ejemplo: Código de Monitoreo
import matplotlib.pyplot as plt
# Function to plot generated images
def plot_generated_images(epoch, generator, examples=10, dim=(1, 10), figsize=(20, 2)):
noise = np.random.normal(0, 1, (examples, latent_dim))
generated_images = generator.predict(noise)
generated_images = (generated_images * 127.5 + 127.5).astype(np.uint8)
plt.figure(figsize=figsize)
for i in range(examples):
plt.subplot(dim[0], dim[1], i + 1)
plt.imshow(generated_images[i])
plt.axis('off')
plt.tight_layout()
plt.savefig(f"gan_generated_image_epoch_{epoch}.png")
plt.close()
# Training loop with monitoring
for epoch in range(epochs):
idx = np.random.randint(0, train_images.shape[0], batch_size)
real_images = train_images[idx]
noise = np.random.normal(0, 1, (batch_size, latent_dim))
fake_images = generator.predict(noise)
d_loss_real = discriminator.train_on_batch(real_images, real)
d_loss_fake = discriminator.train_on_batch(fake_images, fake)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
noise = np.random.normal(0, 1, (batch_size, latent_dim))
g_loss = gan.train_on_batch(noise, real)
if epoch % sample_interval == 0:
print(f"{epoch} [D loss: {d_loss[0]}, acc.: {d_loss[1] * 100}%] [G loss: {g_loss}]")
plot_generated_images(epoch, generator)
if epoch % 1000 == 0:
generator.save(f'generator_epoch_{epoch}.h5')
discriminator.save(f'discriminator_epoch_{epoch}.h5')Las GANs consisten en dos partes: un generador y un discriminador. El generador crea nuevas instancias de datos, mientras que el discriminador las evalúa para determinar su autenticidad.
Se define la función "plot_generated_images" para visualizar las imágenes generadas por la GAN después de épocas específicas.
A continuación, se configura un bucle de entrenamiento donde se alimentan imágenes reales al discriminador junto con imágenes falsas generadas por el generador. El discriminador se entrena para diferenciar entre imágenes reales y falsas.
El generador también se entrena para engañar al discriminador, haciéndole creer que las imágenes del generador son reales. Se registran las pérdidas del discriminador y del generador para su inspección.
Si la época actual es un múltiplo del "sample_interval", el código imprime las pérdidas y grafica las imágenes generadas. Si la época actual es un múltiplo de 1000, se guardan los modelos del generador y del discriminador.
Resumen
Entrenar una GAN para generar caras humanas realistas implica un delicado equilibrio entre entrenar el discriminador y el generador. Al actualizar iterativamente ambas redes, monitorear su rendimiento y guardar modelos a intervalos regulares, podemos crear una potente GAN capaz de producir imágenes de alta calidad. Este proceso requiere una atención cuidadosa a los detalles, ya que la inestabilidad en el entrenamiento puede llevar a problemas como el colapso de modos.
Con el proceso de entrenamiento configurado y en funcionamiento, los siguientes pasos se centrarán en evaluar la GAN entrenada, ajustar su rendimiento y aprovechar las imágenes generadas para diversas aplicaciones.
4.3 Entrenamiento de la GAN
Entrenar una Red Generativa Adversaria (GAN) es un proceso matizado que implica actualizar iterativamente las redes del generador y el discriminador para mejorar la calidad de las imágenes generadas. Esta sección te guiará a través de los pasos para entrenar una GAN para generar caras humanas realistas, incluyendo los bucles de entrenamiento necesarios, funciones de pérdida y técnicas de monitoreo.
4.3.1 Resumen del Proceso de Entrenamiento
El proceso de entrenamiento de una GAN implica dos pasos principales en cada iteración:
- Entrenamiento del Discriminador: El discriminador se entrena para diferenciar entre imágenes reales del conjunto de datos e imágenes falsas generadas por el generador.
- Entrenamiento del Generador: El generador se entrena para producir imágenes que puedan engañar al discriminador haciéndole clasificar las imágenes falsas como reales.
Para lograr esto, el bucle de entrenamiento consiste en:
- Generar un lote de imágenes falsas a partir de ruido aleatorio.
- Obtener un lote de imágenes reales del conjunto de datos.
- Entrenar el discriminador con imágenes reales y falsas.
- Entrenar el generador a través del modelo GAN combinado, donde los pesos del discriminador están congelados.
4.3.2 Entrenamiento del Discriminador
El discriminador se entrena para maximizar la probabilidad de clasificar correctamente las imágenes reales y falsas. La función de pérdida utilizada es la entropía cruzada binaria.
LD=−m1∑i=1m[yilog(D(xi))+(1−yi)log(1−D(G(zi)))]
donde yiy_iyi es la etiqueta (1 para real, 0 para falso), D(xi)D(x_i)D(xi) es la predicción del discriminador para imágenes reales, y D(G(zi))D(G(z_i))D(G(zi)) es la predicción del discriminador para imágenes falsas.
Ejemplo: Código de Entrenamiento del Discriminador
import numpy as np
# Training parameters
epochs = 10000
batch_size = 64
sample_interval = 1000
# Adversarial ground truths
real = np.ones((batch_size, 1))
fake = np.zeros((batch_size, 1))
# Training loop for discriminator
for epoch in range(epochs):
# Train the discriminator
# Select a random batch of real images
idx = np.random.randint(0, train_images.shape[0], batch_size)
real_images = train_images[idx]
# Generate a batch of fake images
noise = np.random.normal(0, 1, (batch_size, latent_dim))
fake_images = generator.predict(noise)
# Train the discriminator on real and fake images
d_loss_real = discriminator.train_on_batch(real_images, real)
d_loss_fake = discriminator.train_on_batch(fake_images, fake)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# Print progress
if epoch % sample_interval == 0:
print(f"{epoch} [D loss: {d_loss[0]}, acc.: {d_loss[1] * 100}%]")Los parámetros de entrenamiento indican que el proceso de entrenamiento continuará durante 10,000 épocas, con un tamaño de lote de 64 y un intervalo de muestreo de 1000.
Las variables 'real' y 'fake' representan las etiquetas para las imágenes reales y falsas respectivamente, que se utilizan durante el entrenamiento del discriminador.
Dentro del bucle de entrenamiento, para cada época, el discriminador se entrena con un lote de imágenes reales y un lote de imágenes falsas. En cada iteración, se selecciona aleatoriamente un lote de imágenes reales de los datos de entrenamiento, y el generador genera un lote de imágenes falsas.
Se calcula la pérdida del discriminador tanto para imágenes reales como falsas, y se toma el promedio. Si la época actual es un múltiplo del intervalo de muestreo, el programa imprime el número de época, la pérdida del discriminador y la precisión.
4.3.3 Entrenamiento del Generador
El generador se entrena para maximizar la probabilidad de que el discriminador clasifique sus salidas como reales. Esto se logra entrenando el generador a través del modelo GAN combinado, donde los pesos del discriminador están congelados.
Pérdida del Generador:
Ejemplo: Código de Entrenamiento del Generador
# Training loop for generator
for epoch in range(epochs):
# Train the discriminator
idx = np.random.randint(0, train_images.shape[0], batch_size)
real_images = train_images[idx]
noise = np.random.normal(0, 1, (batch_size, latent_dim))
fake_images = generator.predict(noise)
d_loss_real = discriminator.train_on_batch(real_images, real)
d_loss_fake = discriminator.train_on_batch(fake_images, fake)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# Train the generator
noise = np.random.normal(0, 1, (batch_size, latent_dim))
g_loss = gan.train_on_batch(noise, real)
# Print progress
if epoch % sample_interval == 0:
print(f"{epoch} [D loss: {d_loss[0]}, acc.: {d_loss[1] * 100}%] [G loss: {g_loss}]")
# Generate and save images
noise = np.random.normal(0, 1, (10, latent_dim))
generated_images = generator.predict(noise)
fig, axs = plt.subplots(1, 10, figsize=(20, 2))
for i, img in enumerate(generated_images):
axs[i].imshow((img * 127.5 + 127.5).astype(np.uint8))
axs[i].axis('off')
plt.show()Primero, se selecciona un conjunto de imágenes reales y se genera un conjunto de imágenes falsas mediante el generador. El discriminador se entrena con ambos conjuntos. Luego, se calcula la pérdida promedio del discriminador.
A continuación, el generador se entrena utilizando el mismo ruido como entrada pero con las etiquetas de las imágenes reales. El objetivo aquí es engañar al discriminador para que piense que las imágenes generadas son reales.
El script luego imprime el progreso del entrenamiento, incluida la pérdida del discriminador y del generador. Si se alcanza un cierto número de épocas (determinado por el sample_interval), el generador producirá y guardará algunas imágenes de muestra para inspección. Las imágenes se normalizan y se muestran utilizando matplotlib.
4.3.4 Monitoreo del Proceso de Entrenamiento
Para asegurarse de que la GAN se está entrenando de manera efectiva, es esencial monitorear el proceso de entrenamiento. Esto incluye:
- Monitoreo de la Pérdida: Rastrear los valores de pérdida tanto del discriminador como del generador a lo largo del tiempo.
- Muestras Generadas: Generar y visualizar periódicamente imágenes para evaluar cualitativamente el rendimiento del generador.
- Guardado de Modelos: Guardar los pesos del modelo a intervalos regulares para protegerse contra posibles interrupciones del entrenamiento y facilitar la evaluación futura o un entrenamiento adicional.
Ejemplo: Código de Monitoreo
import matplotlib.pyplot as plt
# Function to plot generated images
def plot_generated_images(epoch, generator, examples=10, dim=(1, 10), figsize=(20, 2)):
noise = np.random.normal(0, 1, (examples, latent_dim))
generated_images = generator.predict(noise)
generated_images = (generated_images * 127.5 + 127.5).astype(np.uint8)
plt.figure(figsize=figsize)
for i in range(examples):
plt.subplot(dim[0], dim[1], i + 1)
plt.imshow(generated_images[i])
plt.axis('off')
plt.tight_layout()
plt.savefig(f"gan_generated_image_epoch_{epoch}.png")
plt.close()
# Training loop with monitoring
for epoch in range(epochs):
idx = np.random.randint(0, train_images.shape[0], batch_size)
real_images = train_images[idx]
noise = np.random.normal(0, 1, (batch_size, latent_dim))
fake_images = generator.predict(noise)
d_loss_real = discriminator.train_on_batch(real_images, real)
d_loss_fake = discriminator.train_on_batch(fake_images, fake)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
noise = np.random.normal(0, 1, (batch_size, latent_dim))
g_loss = gan.train_on_batch(noise, real)
if epoch % sample_interval == 0:
print(f"{epoch} [D loss: {d_loss[0]}, acc.: {d_loss[1] * 100}%] [G loss: {g_loss}]")
plot_generated_images(epoch, generator)
if epoch % 1000 == 0:
generator.save(f'generator_epoch_{epoch}.h5')
discriminator.save(f'discriminator_epoch_{epoch}.h5')Las GANs consisten en dos partes: un generador y un discriminador. El generador crea nuevas instancias de datos, mientras que el discriminador las evalúa para determinar su autenticidad.
Se define la función "plot_generated_images" para visualizar las imágenes generadas por la GAN después de épocas específicas.
A continuación, se configura un bucle de entrenamiento donde se alimentan imágenes reales al discriminador junto con imágenes falsas generadas por el generador. El discriminador se entrena para diferenciar entre imágenes reales y falsas.
El generador también se entrena para engañar al discriminador, haciéndole creer que las imágenes del generador son reales. Se registran las pérdidas del discriminador y del generador para su inspección.
Si la época actual es un múltiplo del "sample_interval", el código imprime las pérdidas y grafica las imágenes generadas. Si la época actual es un múltiplo de 1000, se guardan los modelos del generador y del discriminador.
Resumen
Entrenar una GAN para generar caras humanas realistas implica un delicado equilibrio entre entrenar el discriminador y el generador. Al actualizar iterativamente ambas redes, monitorear su rendimiento y guardar modelos a intervalos regulares, podemos crear una potente GAN capaz de producir imágenes de alta calidad. Este proceso requiere una atención cuidadosa a los detalles, ya que la inestabilidad en el entrenamiento puede llevar a problemas como el colapso de modos.
Con el proceso de entrenamiento configurado y en funcionamiento, los siguientes pasos se centrarán en evaluar la GAN entrenada, ajustar su rendimiento y aprovechar las imágenes generadas para diversas aplicaciones.