Capítulo 10: Proyecto: Generación de Imágenes con Modelos de Difusión
10.4 Generación de Nuevas Imágenes
Una vez que el modelo de difusión está entrenado, podemos usarlo para generar nuevas imágenes a partir de ruido aleatorio. Este proceso implica comenzar con un vector de ruido y aplicar iterativamente el modelo para eliminar el ruido, transformando el ruido aleatorio en imágenes coherentes y estructuradas. En esta sección, detallaremos los pasos para generar nuevas imágenes utilizando el modelo de difusión entrenado, proporcionando códigos de ejemplo para ilustrar cada paso.
10.4.1 Inicialización del Ruido Aleatorio
El primer paso para generar nuevas imágenes es inicializar un lote de vectores de ruido aleatorio. Estos vectores de ruido servirán como punto de partida para que el modelo de difusión los transforme en imágenes.
Ejemplo: Inicialización del Ruido Aleatorio
import numpy as np
# Define the shape of the noise vectors
noise_shape = (32, 32, 3)
batch_size = 10
# Generate a batch of random noise vectors
random_noise = np.random.normal(size=(batch_size, *noise_shape))
# Print the shape of the noise vectors
print(f"Random noise shape: {random_noise.shape}")El código está creando el lote de vectores de ruido aleatorio. Primero importa la biblioteca numpy. Luego, define la forma de los vectores de ruido como una tupla (32, 32, 3) y el tamaño del lote como 10.
Después de eso, usa la función random.normal de numpy para generar un lote de vectores de ruido aleatorio, donde el tamaño del array generado es (batch_size, *noise_shape). El asterisco antes de noise_shape se usa para desempaquetar los valores en la tupla noise_shape. Finalmente, imprime la forma del lote de ruido aleatorio generado.
10.4.2 Proceso Iterativo de Desruido
El núcleo del proceso de generación de imágenes implica aplicar iterativamente el modelo de difusión entrenado a los vectores de ruido. En cada paso, el modelo predice y elimina una porción del ruido, transformando gradualmente el ruido aleatorio en imágenes estructuradas. También usamos codificaciones de pasos para guiar al modelo a través de los pasos de difusión.
Ejemplo: Proceso Iterativo de Desruido
def generate_images(model, noise_vectors, num_steps, d_model):
"""
Generates images by iteratively applying the diffusion model.
Parameters:
- model: The trained diffusion model.
- noise_vectors: Batch of random noise vectors.
- num_steps: Number of diffusion steps.
- d_model: Dimensionality of the step encoding.
Returns:
- Generated images.
"""
generated_images = noise_vectors.copy()
for step in range(num_steps):
step_encodings = sinusoidal_step_encoding(np.full((batch_size, 1), step), d_model)
generated_images = model.predict([generated_images, step_encodings])
return generated_images
# Example usage
num_steps = 10
generated_images = generate_images(diffusion_model, random_noise, num_steps, d_model)
# Plot the generated images
import matplotlib.pyplot as plt
plt.figure(figsize=(12, 4))
for i in range(batch_size):
plt.subplot(2, 5, i + 1)
plt.imshow((generated_images[i] * 0.5) + 0.5)
plt.axis('off')
plt.suptitle('Generated Images')
plt.show()La función generate_images aplica el modelo de difusión a vectores de ruido durante un número específico de pasos. También utiliza codificación sinusoidal de pasos durante cada paso.
La función toma cuatro parámetros: el modelo de difusión entrenado, los vectores de ruido, el número de pasos de difusión y la dimensionalidad de la codificación de pasos. Devuelve las imágenes generadas.
Se proporciona un ejemplo de cómo usar la función. Demuestra la generación de imágenes con el modelo de difusión usando ruido aleatorio y trazando las imágenes generadas usando matplotlib.
10.4.3 Mejora de la Calidad de la Imagen
Para mejorar aún más la calidad de las imágenes generadas, podemos aplicar técnicas de postprocesamiento como el filtrado de imágenes y el afilado. Estas técnicas pueden ayudar a mejorar el atractivo visual de las imágenes y eliminar cualquier artefacto restante.
Ejemplo: Mejora de la Calidad de la Imagen
from skimage.filters import unsharp_mask
def enhance_images(images):
"""
Enhances the quality of generated images using image filtering.
Parameters:
- images: Batch of generated images.
Returns:
- Enhanced images.
"""
enhanced_images = []
for img in images:
enhanced_img = unsharp_mask((img * 0.5) + 0.5, radius=1.0, amount=1.0)
enhanced_images.append(enhanced_img)
return np.array(enhanced_images)
# Example usage
enhanced_images = enhance_images(generated_images)
# Plot the enhanced images
plt.figure(figsize=(12, 4))
for i in range(batch_size):
plt.subplot(2, 5, i + 1)
plt.imshow(enhanced_images[i])
plt.axis('off')
plt.suptitle('Enhanced Images')
plt.show()Este código mejora la calidad de las imágenes utilizando una técnica llamada enmascaramiento de desenfoque (unsharp masking). La función 'enhance_images' toma un lote de imágenes como entrada, aplica enmascaramiento de desenfoque a cada imagen utilizando la función 'unsharp_mask' de la biblioteca 'skimage.filters', y devuelve las imágenes mejoradas.
Después de que las imágenes se mejoran, el código también incluye un ejemplo de cómo usar esta función y cómo trazar estas imágenes utilizando la biblioteca pyplot de matplotlib. La sección de trazado del código muestra cada imagen mejorada en un subtrama separado sin ejes y le da al gráfico general el título de 'Enhanced Images'.
10.4.4 Guardando las Imágenes Generadas
Después de generar y mejorar las imágenes, es importante guardarlas para su uso o evaluación futura. Podemos guardar las imágenes en un formato como PNG o JPEG.
Ejemplo: Guardando las Imágenes Generadas
import os
from skimage.io import imsave
def save_images(images, directory, prefix="generated_image"):
"""
Saves generated images to the specified directory.
Parameters:
- images: Batch of generated images.
- directory: Directory to save the images.
- prefix: Prefix for the image filenames.
"""
if not os.path.exists(directory):
os.makedirs(directory)
for i, img in enumerate(images):
filename = os.path.join(directory, f"{prefix}_{i + 1}.png")
imsave(filename, (img * 255).astype(np.uint8))
# Example usage
save_images(enhanced_images, "generated_images")Este script es una función para guardar el lote de imágenes en un directorio especificado. La función toma como argumentos las imágenes (el lote de imágenes a guardar), el directorio (la ubicación donde se guardarán las imágenes) y un prefijo opcional (la parte inicial del nombre del archivo guardado). Si el directorio especificado no existe, se creará. Las imágenes se guardan en formato PNG con el nombre de archivo que es una combinación del prefijo y su posición en el lote.
Resumen
En esta sección, cubrimos el proceso detallado de generación de nuevas imágenes utilizando el modelo de difusión entrenado. Comenzamos inicializando vectores de ruido aleatorio, que sirven como punto de partida para la generación de imágenes. Luego, aplicamos el proceso iterativo de eliminación de ruido, donde el modelo predice y elimina el ruido de las imágenes paso a paso, transformando el ruido en imágenes coherentes y estructuradas.
Para mejorar aún más la calidad de las imágenes generadas, aplicamos técnicas de postprocesamiento como el filtrado de imágenes y el enfoque. Finalmente, guardamos las imágenes generadas y mejoradas para su uso o evaluación futura.
Siguiendo estos pasos, puede utilizar efectivamente un modelo de difusión entrenado para generar imágenes de alta calidad a partir de ruido aleatorio. En las siguientes secciones, evaluaremos el rendimiento de las imágenes generadas y exploraremos mejoras adicionales y aplicaciones de los modelos de difusión en tareas de generación de imágenes.
10.4 Generación de Nuevas Imágenes
Una vez que el modelo de difusión está entrenado, podemos usarlo para generar nuevas imágenes a partir de ruido aleatorio. Este proceso implica comenzar con un vector de ruido y aplicar iterativamente el modelo para eliminar el ruido, transformando el ruido aleatorio en imágenes coherentes y estructuradas. En esta sección, detallaremos los pasos para generar nuevas imágenes utilizando el modelo de difusión entrenado, proporcionando códigos de ejemplo para ilustrar cada paso.
10.4.1 Inicialización del Ruido Aleatorio
El primer paso para generar nuevas imágenes es inicializar un lote de vectores de ruido aleatorio. Estos vectores de ruido servirán como punto de partida para que el modelo de difusión los transforme en imágenes.
Ejemplo: Inicialización del Ruido Aleatorio
import numpy as np
# Define the shape of the noise vectors
noise_shape = (32, 32, 3)
batch_size = 10
# Generate a batch of random noise vectors
random_noise = np.random.normal(size=(batch_size, *noise_shape))
# Print the shape of the noise vectors
print(f"Random noise shape: {random_noise.shape}")El código está creando el lote de vectores de ruido aleatorio. Primero importa la biblioteca numpy. Luego, define la forma de los vectores de ruido como una tupla (32, 32, 3) y el tamaño del lote como 10.
Después de eso, usa la función random.normal de numpy para generar un lote de vectores de ruido aleatorio, donde el tamaño del array generado es (batch_size, *noise_shape). El asterisco antes de noise_shape se usa para desempaquetar los valores en la tupla noise_shape. Finalmente, imprime la forma del lote de ruido aleatorio generado.
10.4.2 Proceso Iterativo de Desruido
El núcleo del proceso de generación de imágenes implica aplicar iterativamente el modelo de difusión entrenado a los vectores de ruido. En cada paso, el modelo predice y elimina una porción del ruido, transformando gradualmente el ruido aleatorio en imágenes estructuradas. También usamos codificaciones de pasos para guiar al modelo a través de los pasos de difusión.
Ejemplo: Proceso Iterativo de Desruido
def generate_images(model, noise_vectors, num_steps, d_model):
"""
Generates images by iteratively applying the diffusion model.
Parameters:
- model: The trained diffusion model.
- noise_vectors: Batch of random noise vectors.
- num_steps: Number of diffusion steps.
- d_model: Dimensionality of the step encoding.
Returns:
- Generated images.
"""
generated_images = noise_vectors.copy()
for step in range(num_steps):
step_encodings = sinusoidal_step_encoding(np.full((batch_size, 1), step), d_model)
generated_images = model.predict([generated_images, step_encodings])
return generated_images
# Example usage
num_steps = 10
generated_images = generate_images(diffusion_model, random_noise, num_steps, d_model)
# Plot the generated images
import matplotlib.pyplot as plt
plt.figure(figsize=(12, 4))
for i in range(batch_size):
plt.subplot(2, 5, i + 1)
plt.imshow((generated_images[i] * 0.5) + 0.5)
plt.axis('off')
plt.suptitle('Generated Images')
plt.show()La función generate_images aplica el modelo de difusión a vectores de ruido durante un número específico de pasos. También utiliza codificación sinusoidal de pasos durante cada paso.
La función toma cuatro parámetros: el modelo de difusión entrenado, los vectores de ruido, el número de pasos de difusión y la dimensionalidad de la codificación de pasos. Devuelve las imágenes generadas.
Se proporciona un ejemplo de cómo usar la función. Demuestra la generación de imágenes con el modelo de difusión usando ruido aleatorio y trazando las imágenes generadas usando matplotlib.
10.4.3 Mejora de la Calidad de la Imagen
Para mejorar aún más la calidad de las imágenes generadas, podemos aplicar técnicas de postprocesamiento como el filtrado de imágenes y el afilado. Estas técnicas pueden ayudar a mejorar el atractivo visual de las imágenes y eliminar cualquier artefacto restante.
Ejemplo: Mejora de la Calidad de la Imagen
from skimage.filters import unsharp_mask
def enhance_images(images):
"""
Enhances the quality of generated images using image filtering.
Parameters:
- images: Batch of generated images.
Returns:
- Enhanced images.
"""
enhanced_images = []
for img in images:
enhanced_img = unsharp_mask((img * 0.5) + 0.5, radius=1.0, amount=1.0)
enhanced_images.append(enhanced_img)
return np.array(enhanced_images)
# Example usage
enhanced_images = enhance_images(generated_images)
# Plot the enhanced images
plt.figure(figsize=(12, 4))
for i in range(batch_size):
plt.subplot(2, 5, i + 1)
plt.imshow(enhanced_images[i])
plt.axis('off')
plt.suptitle('Enhanced Images')
plt.show()Este código mejora la calidad de las imágenes utilizando una técnica llamada enmascaramiento de desenfoque (unsharp masking). La función 'enhance_images' toma un lote de imágenes como entrada, aplica enmascaramiento de desenfoque a cada imagen utilizando la función 'unsharp_mask' de la biblioteca 'skimage.filters', y devuelve las imágenes mejoradas.
Después de que las imágenes se mejoran, el código también incluye un ejemplo de cómo usar esta función y cómo trazar estas imágenes utilizando la biblioteca pyplot de matplotlib. La sección de trazado del código muestra cada imagen mejorada en un subtrama separado sin ejes y le da al gráfico general el título de 'Enhanced Images'.
10.4.4 Guardando las Imágenes Generadas
Después de generar y mejorar las imágenes, es importante guardarlas para su uso o evaluación futura. Podemos guardar las imágenes en un formato como PNG o JPEG.
Ejemplo: Guardando las Imágenes Generadas
import os
from skimage.io import imsave
def save_images(images, directory, prefix="generated_image"):
"""
Saves generated images to the specified directory.
Parameters:
- images: Batch of generated images.
- directory: Directory to save the images.
- prefix: Prefix for the image filenames.
"""
if not os.path.exists(directory):
os.makedirs(directory)
for i, img in enumerate(images):
filename = os.path.join(directory, f"{prefix}_{i + 1}.png")
imsave(filename, (img * 255).astype(np.uint8))
# Example usage
save_images(enhanced_images, "generated_images")Este script es una función para guardar el lote de imágenes en un directorio especificado. La función toma como argumentos las imágenes (el lote de imágenes a guardar), el directorio (la ubicación donde se guardarán las imágenes) y un prefijo opcional (la parte inicial del nombre del archivo guardado). Si el directorio especificado no existe, se creará. Las imágenes se guardan en formato PNG con el nombre de archivo que es una combinación del prefijo y su posición en el lote.
Resumen
En esta sección, cubrimos el proceso detallado de generación de nuevas imágenes utilizando el modelo de difusión entrenado. Comenzamos inicializando vectores de ruido aleatorio, que sirven como punto de partida para la generación de imágenes. Luego, aplicamos el proceso iterativo de eliminación de ruido, donde el modelo predice y elimina el ruido de las imágenes paso a paso, transformando el ruido en imágenes coherentes y estructuradas.
Para mejorar aún más la calidad de las imágenes generadas, aplicamos técnicas de postprocesamiento como el filtrado de imágenes y el enfoque. Finalmente, guardamos las imágenes generadas y mejoradas para su uso o evaluación futura.
Siguiendo estos pasos, puede utilizar efectivamente un modelo de difusión entrenado para generar imágenes de alta calidad a partir de ruido aleatorio. En las siguientes secciones, evaluaremos el rendimiento de las imágenes generadas y exploraremos mejoras adicionales y aplicaciones de los modelos de difusión en tareas de generación de imágenes.
10.4 Generación de Nuevas Imágenes
Una vez que el modelo de difusión está entrenado, podemos usarlo para generar nuevas imágenes a partir de ruido aleatorio. Este proceso implica comenzar con un vector de ruido y aplicar iterativamente el modelo para eliminar el ruido, transformando el ruido aleatorio en imágenes coherentes y estructuradas. En esta sección, detallaremos los pasos para generar nuevas imágenes utilizando el modelo de difusión entrenado, proporcionando códigos de ejemplo para ilustrar cada paso.
10.4.1 Inicialización del Ruido Aleatorio
El primer paso para generar nuevas imágenes es inicializar un lote de vectores de ruido aleatorio. Estos vectores de ruido servirán como punto de partida para que el modelo de difusión los transforme en imágenes.
Ejemplo: Inicialización del Ruido Aleatorio
import numpy as np
# Define the shape of the noise vectors
noise_shape = (32, 32, 3)
batch_size = 10
# Generate a batch of random noise vectors
random_noise = np.random.normal(size=(batch_size, *noise_shape))
# Print the shape of the noise vectors
print(f"Random noise shape: {random_noise.shape}")El código está creando el lote de vectores de ruido aleatorio. Primero importa la biblioteca numpy. Luego, define la forma de los vectores de ruido como una tupla (32, 32, 3) y el tamaño del lote como 10.
Después de eso, usa la función random.normal de numpy para generar un lote de vectores de ruido aleatorio, donde el tamaño del array generado es (batch_size, *noise_shape). El asterisco antes de noise_shape se usa para desempaquetar los valores en la tupla noise_shape. Finalmente, imprime la forma del lote de ruido aleatorio generado.
10.4.2 Proceso Iterativo de Desruido
El núcleo del proceso de generación de imágenes implica aplicar iterativamente el modelo de difusión entrenado a los vectores de ruido. En cada paso, el modelo predice y elimina una porción del ruido, transformando gradualmente el ruido aleatorio en imágenes estructuradas. También usamos codificaciones de pasos para guiar al modelo a través de los pasos de difusión.
Ejemplo: Proceso Iterativo de Desruido
def generate_images(model, noise_vectors, num_steps, d_model):
"""
Generates images by iteratively applying the diffusion model.
Parameters:
- model: The trained diffusion model.
- noise_vectors: Batch of random noise vectors.
- num_steps: Number of diffusion steps.
- d_model: Dimensionality of the step encoding.
Returns:
- Generated images.
"""
generated_images = noise_vectors.copy()
for step in range(num_steps):
step_encodings = sinusoidal_step_encoding(np.full((batch_size, 1), step), d_model)
generated_images = model.predict([generated_images, step_encodings])
return generated_images
# Example usage
num_steps = 10
generated_images = generate_images(diffusion_model, random_noise, num_steps, d_model)
# Plot the generated images
import matplotlib.pyplot as plt
plt.figure(figsize=(12, 4))
for i in range(batch_size):
plt.subplot(2, 5, i + 1)
plt.imshow((generated_images[i] * 0.5) + 0.5)
plt.axis('off')
plt.suptitle('Generated Images')
plt.show()La función generate_images aplica el modelo de difusión a vectores de ruido durante un número específico de pasos. También utiliza codificación sinusoidal de pasos durante cada paso.
La función toma cuatro parámetros: el modelo de difusión entrenado, los vectores de ruido, el número de pasos de difusión y la dimensionalidad de la codificación de pasos. Devuelve las imágenes generadas.
Se proporciona un ejemplo de cómo usar la función. Demuestra la generación de imágenes con el modelo de difusión usando ruido aleatorio y trazando las imágenes generadas usando matplotlib.
10.4.3 Mejora de la Calidad de la Imagen
Para mejorar aún más la calidad de las imágenes generadas, podemos aplicar técnicas de postprocesamiento como el filtrado de imágenes y el afilado. Estas técnicas pueden ayudar a mejorar el atractivo visual de las imágenes y eliminar cualquier artefacto restante.
Ejemplo: Mejora de la Calidad de la Imagen
from skimage.filters import unsharp_mask
def enhance_images(images):
"""
Enhances the quality of generated images using image filtering.
Parameters:
- images: Batch of generated images.
Returns:
- Enhanced images.
"""
enhanced_images = []
for img in images:
enhanced_img = unsharp_mask((img * 0.5) + 0.5, radius=1.0, amount=1.0)
enhanced_images.append(enhanced_img)
return np.array(enhanced_images)
# Example usage
enhanced_images = enhance_images(generated_images)
# Plot the enhanced images
plt.figure(figsize=(12, 4))
for i in range(batch_size):
plt.subplot(2, 5, i + 1)
plt.imshow(enhanced_images[i])
plt.axis('off')
plt.suptitle('Enhanced Images')
plt.show()Este código mejora la calidad de las imágenes utilizando una técnica llamada enmascaramiento de desenfoque (unsharp masking). La función 'enhance_images' toma un lote de imágenes como entrada, aplica enmascaramiento de desenfoque a cada imagen utilizando la función 'unsharp_mask' de la biblioteca 'skimage.filters', y devuelve las imágenes mejoradas.
Después de que las imágenes se mejoran, el código también incluye un ejemplo de cómo usar esta función y cómo trazar estas imágenes utilizando la biblioteca pyplot de matplotlib. La sección de trazado del código muestra cada imagen mejorada en un subtrama separado sin ejes y le da al gráfico general el título de 'Enhanced Images'.
10.4.4 Guardando las Imágenes Generadas
Después de generar y mejorar las imágenes, es importante guardarlas para su uso o evaluación futura. Podemos guardar las imágenes en un formato como PNG o JPEG.
Ejemplo: Guardando las Imágenes Generadas
import os
from skimage.io import imsave
def save_images(images, directory, prefix="generated_image"):
"""
Saves generated images to the specified directory.
Parameters:
- images: Batch of generated images.
- directory: Directory to save the images.
- prefix: Prefix for the image filenames.
"""
if not os.path.exists(directory):
os.makedirs(directory)
for i, img in enumerate(images):
filename = os.path.join(directory, f"{prefix}_{i + 1}.png")
imsave(filename, (img * 255).astype(np.uint8))
# Example usage
save_images(enhanced_images, "generated_images")Este script es una función para guardar el lote de imágenes en un directorio especificado. La función toma como argumentos las imágenes (el lote de imágenes a guardar), el directorio (la ubicación donde se guardarán las imágenes) y un prefijo opcional (la parte inicial del nombre del archivo guardado). Si el directorio especificado no existe, se creará. Las imágenes se guardan en formato PNG con el nombre de archivo que es una combinación del prefijo y su posición en el lote.
Resumen
En esta sección, cubrimos el proceso detallado de generación de nuevas imágenes utilizando el modelo de difusión entrenado. Comenzamos inicializando vectores de ruido aleatorio, que sirven como punto de partida para la generación de imágenes. Luego, aplicamos el proceso iterativo de eliminación de ruido, donde el modelo predice y elimina el ruido de las imágenes paso a paso, transformando el ruido en imágenes coherentes y estructuradas.
Para mejorar aún más la calidad de las imágenes generadas, aplicamos técnicas de postprocesamiento como el filtrado de imágenes y el enfoque. Finalmente, guardamos las imágenes generadas y mejoradas para su uso o evaluación futura.
Siguiendo estos pasos, puede utilizar efectivamente un modelo de difusión entrenado para generar imágenes de alta calidad a partir de ruido aleatorio. En las siguientes secciones, evaluaremos el rendimiento de las imágenes generadas y exploraremos mejoras adicionales y aplicaciones de los modelos de difusión en tareas de generación de imágenes.
10.4 Generación de Nuevas Imágenes
Una vez que el modelo de difusión está entrenado, podemos usarlo para generar nuevas imágenes a partir de ruido aleatorio. Este proceso implica comenzar con un vector de ruido y aplicar iterativamente el modelo para eliminar el ruido, transformando el ruido aleatorio en imágenes coherentes y estructuradas. En esta sección, detallaremos los pasos para generar nuevas imágenes utilizando el modelo de difusión entrenado, proporcionando códigos de ejemplo para ilustrar cada paso.
10.4.1 Inicialización del Ruido Aleatorio
El primer paso para generar nuevas imágenes es inicializar un lote de vectores de ruido aleatorio. Estos vectores de ruido servirán como punto de partida para que el modelo de difusión los transforme en imágenes.
Ejemplo: Inicialización del Ruido Aleatorio
import numpy as np
# Define the shape of the noise vectors
noise_shape = (32, 32, 3)
batch_size = 10
# Generate a batch of random noise vectors
random_noise = np.random.normal(size=(batch_size, *noise_shape))
# Print the shape of the noise vectors
print(f"Random noise shape: {random_noise.shape}")El código está creando el lote de vectores de ruido aleatorio. Primero importa la biblioteca numpy. Luego, define la forma de los vectores de ruido como una tupla (32, 32, 3) y el tamaño del lote como 10.
Después de eso, usa la función random.normal de numpy para generar un lote de vectores de ruido aleatorio, donde el tamaño del array generado es (batch_size, *noise_shape). El asterisco antes de noise_shape se usa para desempaquetar los valores en la tupla noise_shape. Finalmente, imprime la forma del lote de ruido aleatorio generado.
10.4.2 Proceso Iterativo de Desruido
El núcleo del proceso de generación de imágenes implica aplicar iterativamente el modelo de difusión entrenado a los vectores de ruido. En cada paso, el modelo predice y elimina una porción del ruido, transformando gradualmente el ruido aleatorio en imágenes estructuradas. También usamos codificaciones de pasos para guiar al modelo a través de los pasos de difusión.
Ejemplo: Proceso Iterativo de Desruido
def generate_images(model, noise_vectors, num_steps, d_model):
"""
Generates images by iteratively applying the diffusion model.
Parameters:
- model: The trained diffusion model.
- noise_vectors: Batch of random noise vectors.
- num_steps: Number of diffusion steps.
- d_model: Dimensionality of the step encoding.
Returns:
- Generated images.
"""
generated_images = noise_vectors.copy()
for step in range(num_steps):
step_encodings = sinusoidal_step_encoding(np.full((batch_size, 1), step), d_model)
generated_images = model.predict([generated_images, step_encodings])
return generated_images
# Example usage
num_steps = 10
generated_images = generate_images(diffusion_model, random_noise, num_steps, d_model)
# Plot the generated images
import matplotlib.pyplot as plt
plt.figure(figsize=(12, 4))
for i in range(batch_size):
plt.subplot(2, 5, i + 1)
plt.imshow((generated_images[i] * 0.5) + 0.5)
plt.axis('off')
plt.suptitle('Generated Images')
plt.show()La función generate_images aplica el modelo de difusión a vectores de ruido durante un número específico de pasos. También utiliza codificación sinusoidal de pasos durante cada paso.
La función toma cuatro parámetros: el modelo de difusión entrenado, los vectores de ruido, el número de pasos de difusión y la dimensionalidad de la codificación de pasos. Devuelve las imágenes generadas.
Se proporciona un ejemplo de cómo usar la función. Demuestra la generación de imágenes con el modelo de difusión usando ruido aleatorio y trazando las imágenes generadas usando matplotlib.
10.4.3 Mejora de la Calidad de la Imagen
Para mejorar aún más la calidad de las imágenes generadas, podemos aplicar técnicas de postprocesamiento como el filtrado de imágenes y el afilado. Estas técnicas pueden ayudar a mejorar el atractivo visual de las imágenes y eliminar cualquier artefacto restante.
Ejemplo: Mejora de la Calidad de la Imagen
from skimage.filters import unsharp_mask
def enhance_images(images):
"""
Enhances the quality of generated images using image filtering.
Parameters:
- images: Batch of generated images.
Returns:
- Enhanced images.
"""
enhanced_images = []
for img in images:
enhanced_img = unsharp_mask((img * 0.5) + 0.5, radius=1.0, amount=1.0)
enhanced_images.append(enhanced_img)
return np.array(enhanced_images)
# Example usage
enhanced_images = enhance_images(generated_images)
# Plot the enhanced images
plt.figure(figsize=(12, 4))
for i in range(batch_size):
plt.subplot(2, 5, i + 1)
plt.imshow(enhanced_images[i])
plt.axis('off')
plt.suptitle('Enhanced Images')
plt.show()Este código mejora la calidad de las imágenes utilizando una técnica llamada enmascaramiento de desenfoque (unsharp masking). La función 'enhance_images' toma un lote de imágenes como entrada, aplica enmascaramiento de desenfoque a cada imagen utilizando la función 'unsharp_mask' de la biblioteca 'skimage.filters', y devuelve las imágenes mejoradas.
Después de que las imágenes se mejoran, el código también incluye un ejemplo de cómo usar esta función y cómo trazar estas imágenes utilizando la biblioteca pyplot de matplotlib. La sección de trazado del código muestra cada imagen mejorada en un subtrama separado sin ejes y le da al gráfico general el título de 'Enhanced Images'.
10.4.4 Guardando las Imágenes Generadas
Después de generar y mejorar las imágenes, es importante guardarlas para su uso o evaluación futura. Podemos guardar las imágenes en un formato como PNG o JPEG.
Ejemplo: Guardando las Imágenes Generadas
import os
from skimage.io import imsave
def save_images(images, directory, prefix="generated_image"):
"""
Saves generated images to the specified directory.
Parameters:
- images: Batch of generated images.
- directory: Directory to save the images.
- prefix: Prefix for the image filenames.
"""
if not os.path.exists(directory):
os.makedirs(directory)
for i, img in enumerate(images):
filename = os.path.join(directory, f"{prefix}_{i + 1}.png")
imsave(filename, (img * 255).astype(np.uint8))
# Example usage
save_images(enhanced_images, "generated_images")Este script es una función para guardar el lote de imágenes en un directorio especificado. La función toma como argumentos las imágenes (el lote de imágenes a guardar), el directorio (la ubicación donde se guardarán las imágenes) y un prefijo opcional (la parte inicial del nombre del archivo guardado). Si el directorio especificado no existe, se creará. Las imágenes se guardan en formato PNG con el nombre de archivo que es una combinación del prefijo y su posición en el lote.
Resumen
En esta sección, cubrimos el proceso detallado de generación de nuevas imágenes utilizando el modelo de difusión entrenado. Comenzamos inicializando vectores de ruido aleatorio, que sirven como punto de partida para la generación de imágenes. Luego, aplicamos el proceso iterativo de eliminación de ruido, donde el modelo predice y elimina el ruido de las imágenes paso a paso, transformando el ruido en imágenes coherentes y estructuradas.
Para mejorar aún más la calidad de las imágenes generadas, aplicamos técnicas de postprocesamiento como el filtrado de imágenes y el enfoque. Finalmente, guardamos las imágenes generadas y mejoradas para su uso o evaluación futura.
Siguiendo estos pasos, puede utilizar efectivamente un modelo de difusión entrenado para generar imágenes de alta calidad a partir de ruido aleatorio. En las siguientes secciones, evaluaremos el rendimiento de las imágenes generadas y exploraremos mejoras adicionales y aplicaciones de los modelos de difusión en tareas de generación de imágenes.