Texto a imagen

Cuando piensas en modelos de difusión, el texto a imagen suele ser una de las primeras cosas que te vienen a la mente. El texto a imagen genera una imagen a partir de una descripción textual (por ejemplo, “Astronaut in a jungle, cold color palette, muted colors, detailed, 8k”), lo que también se conoce como prompt.

A un nivel muy general, un modelo de difusión toma un prompt y un ruido inicial aleatorio, y elimina iterativamente el ruido para construir una imagen. El proceso de denoising está guiado por el prompt, y una vez que el proceso de denoising termina tras un número predeterminado de pasos de tiempo, la representación de la imagen se decodifica en una imagen.

Lee el artículo de blog ¿Cómo funciona Stable Diffusion? para saber más sobre cómo funciona un modelo de difusión latente.

Puedes generar imágenes a partir de un prompt en 🤗 Diffusers en dos pasos:

1. Cargue un punto de control en la clase AutoPipelineForText2Image, que detecta automáticamente la clase de pipeline adecuada para usar en función del punto de control:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
	"stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16, variant="fp16"
).to("cuda")  # or "mps", "xpu", "cpu"

2. Pase un prompt a la pipeline para generar una imagen:

image = pipeline(
	"stained glass of darth vader, backlight, centered composition, masterpiece, photorealistic, 8k"
).images[0]
image

Modelos populares

Los modelos de texto a imagen más comunes son Stable Diffusion v1.5, Stable Diffusion XL (SDXL) y Kandinsky 2.2. También existen modelos ControlNet o adaptadores que se pueden usar con modelos de texto a imagen para un control más directo en la generación de imágenes. Los resultados de cada modelo son ligeramente diferentes debido a su arquitectura y proceso de entrenamiento, pero sin importar el modelo que elijas, su uso es más o menos el mismo. Usaremos el mismo prompt para cada modelo y compararemos sus resultados.

Stable Diffusion v1.5

Stable Diffusion v1.5 es un modelo de difusión latente inicializado desde Stable Diffusion v1-4 y afinado durante 595K pasos en imágenes de 512x512 del conjunto de datos LAION-Aesthetics V2. Puedes usar este modelo de la siguiente manera:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
	"stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16, variant="fp16"
).to("cuda")  # or "mps", "xpu", "cpu"
generator = torch.Generator("cuda").manual_seed(31)
image = pipeline("Astronaut in a jungle, cold color palette, muted colors, detailed, 8k", generator=generator).images[0]
image

Stable Diffusion XL

SDXL es una versión mucho más grande de los modelos anteriores de Stable Diffusion e implica un proceso de modelo de dos etapas que añade aún más detalles a una imagen. También incluye algunos micro-condicionamientos adicionales para generar imágenes de alta calidad con sujetos centrados. Echa un vistazo a la guía más completa de SDXL para aprender más sobre cómo usarlo. En general, puedes usar SDXL de la siguiente manera:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16"
).to("cuda")  # or "mps", "xpu", "cpu"
generator = torch.Generator("cuda").manual_seed(31)
image = pipeline("Astronaut in a jungle, cold color palette, muted colors, detailed, 8k", generator=generator).images[0]
image

Kandinsky 2.2

El modelo Kandinsky es un poco diferente de los modelos Stable Diffusion porque también utiliza un modelo de prior de imagen para crear embeddings que se usan para alinear mejor el texto y las imágenes en el modelo de difusión.

La forma más sencilla de usar Kandinsky 2.2 es:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
	"kandinsky-community/kandinsky-2-2-decoder", dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
generator = torch.Generator("cuda").manual_seed(31)
image = pipeline("Astronaut in a jungle, cold color palette, muted colors, detailed, 8k", generator=generator).images[0]
image

ControlNet

Los modelos ControlNet son modelos auxiliares o adaptadores que se ajustan finamente sobre modelos de texto a imagen, como Stable Diffusion v1.5. El uso de modelos ControlNet en combinación con modelos de texto a imagen ofrece diversas opciones para un control más explícito sobre cómo generar una imagen. Con ControlNet, se añade una imagen de entrada de condicionamiento adicional al modelo. Por ejemplo, si se proporciona una imagen de una pose humana (generalmente representada como múltiples puntos clave conectados en un esqueleto) como entrada de condicionamiento, el modelo genera una imagen que sigue la pose de la imagen. Consulta la guía más detallada de ControlNet para aprender más sobre otras entradas de condicionamiento y cómo usarlas.

En este ejemplo, condicionemos el ControlNet con una imagen de estimación de pose humana. Cargue el modelo ControlNet preentrenado en estimaciones de pose humana:

from diffusers import ControlNetModel, AutoPipelineForText2Image
from diffusers.utils import load_image
import torch

controlnet = ControlNetModel.from_pretrained(
	"lllyasviel/control_v11p_sd15_openpose", dtype=torch.float16, variant="fp16"
).to("cuda")  # or "mps", "xpu", "cpu"
pose_image = load_image("https://huggingface.co/lllyasviel/control_v11p_sd15_openpose/resolve/main/images/control.png")

Pasa el controlnet al AutoPipelineForText2Image y proporciona el prompt y la imagen de estimación de pose:

pipeline = AutoPipelineForText2Image.from_pretrained(
	"stable-diffusion-v1-5/stable-diffusion-v1-5", controlnet=controlnet, dtype=torch.float16, variant="fp16"
).to("cuda")  # or "mps", "xpu", "cpu"
generator = torch.Generator("cuda").manual_seed(31)
image = pipeline("Astronaut in a jungle, cold color palette, muted colors, detailed, 8k", image=pose_image, generator=generator).images[0]
image

Configurar los parámetros de la canalización

Hay varios parámetros que se pueden configurar en el pipeline y que afectan cómo se genera una imagen. Puedes cambiar el tamaño de salida de la imagen, especificar un prompt negativo para mejorar la calidad de la imagen, y más. Esta sección profundiza en cómo usar estos parámetros.

Altura y ancho

Los parámetros height y width controlan la altura y el ancho (en píxeles) de la imagen generada. De forma predeterminada, el modelo Stable Diffusion v1.5 genera imágenes de 512x512, pero puedes cambiarlo a cualquier tamaño que sea múltiplo de 8. Por ejemplo, para crear una imagen rectangular:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
	"stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16, variant="fp16"
).to("cuda")  # or "mps", "xpu", "cpu"
image = pipeline(
	"Astronaut in a jungle, cold color palette, muted colors, detailed, 8k", height=768, width=512
).images[0]
image

Otros modelos pueden tener tamaños de imagen predeterminados diferentes según los tamaños de imagen del conjunto de datos de entrenamiento. Por ejemplo, el tamaño de imagen predeterminado de SDXL es 1024x1024 y el uso de valores más bajos para height y width puede resultar en imágenes de menor calidad. ¡Asegúrate de consultar primero la referencia de la API del modelo!

Escala de guía

El parámetro guidance_scale afecta en qué medida el prompt influye en la generación de imágenes. Un valor más bajo otorga al modelo “creatividad” para generar imágenes que están más laxamente relacionadas con el prompt. Los valores más altos de guidance_scale empujan al modelo a seguir el prompt con mayor fidelidad, y si este valor es demasiado alto, es posible que observes algunos artefactos en la imagen generada.

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
	"stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
image = pipeline(
	"Astronaut in a jungle, cold color palette, muted colors, detailed, 8k", guidance_scale=3.5
).images[0]
image

Prompt negativo

De la misma manera que un prompt guía la generación, un negative prompt dirige al modelo para que evite generar elementos no deseados. Se utiliza comúnmente para mejorar la calidad general de la imagen eliminando características deficientes, como “low resolution” o “bad details”. También puedes usar un negative prompt para eliminar o modificar el contenido y el estilo de una imagen.

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
	"stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
image = pipeline(
	prompt="Astronaut in a jungle, cold color palette, muted colors, detailed, 8k",
	negative_prompt="ugly, deformed, disfigured, poor details, bad anatomy",
).images[0]
image

Generador

Un objeto torch.Generator permite la reproducibilidad en un pipeline al establecer una semilla manual. Puede usar un Generator para generar lotes de imágenes y mejorar iterativamente una imagen generada a partir de una semilla, como se detalla en la guía Mejorar la calidad de la imagen con generación determinista.

Puede establecer una semilla y un Generator como se muestra a continuación. Crear una imagen con un Generator debe devolver el mismo resultado cada vez, en lugar de generar aleatoriamente una imagen nueva.

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
	"stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
generator = torch.Generator(device="cuda").manual_seed(30)
image = pipeline(
	"Astronaut in a jungle, cold color palette, muted colors, detailed, 8k",
	generator=generator,
).images[0]
image

Controlar la generación de imágenes

Existen varias formas de ejercer un mayor control sobre cómo se genera una imagen, además de configurar los parámetros de un pipeline, como el ponderado de prompts y los modelos ControlNet.

Pesos de los prompts

El ponderado de prompts es una técnica para aumentar o disminuir la importancia de los conceptos en un prompt, con el fin de enfatizar o minimizar ciertas características en una imagen. Recomendamos usar la biblioteca Compel para ayudarte a generar los embeddings de prompts ponderados.

Aprenda a crear los embeddings de prompt en la guía Prompt weighting. Este ejemplo se centra en cómo usar los embeddings de prompt en el pipeline.

Una vez que hayas creado los embeddings, puedes pasarlos al parámetro prompt_embeds (y negative_prompt_embeds si estás usando un prompt negativo) en el pipeline.

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
	"stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
image = pipeline(
	prompt_embeds=prompt_embeds, # generated from Compel
	negative_prompt_embeds=negative_prompt_embeds, # generated from Compel
).images[0]

ControlNet

Como viste en la sección de ControlNet, estos modelos ofrecen una forma más flexible y precisa de generar imágenes al incorporar una entrada de imagen de condicionamiento adicional. Cada modelo de ControlNet se preentrena en un tipo particular de imagen de condicionamiento para generar nuevas imágenes que se le asemejen. Por ejemplo, si tomas un modelo de ControlNet preentrenado en mapas de profundidad, puedes darle al modelo un mapa de profundidad como entrada de condicionamiento y generará una imagen que preserve la información espacial contenida en él. Esto es más rápido y fácil que especificar la información de profundidad en un prompt. ¡Incluso puedes combinar múltiples entradas de condicionamiento con un Multi-ControlNet!

Existen muchos tipos de entradas de condicionamiento que puedes utilizar, y 🤗 Diffusers admite ControlNet para los modelos Stable Diffusion y SDXL. Consulta la guía más completa de ControlNet para aprender a utilizar estos modelos.

Optimizar

Los modelos de difusión son grandes y la naturaleza iterativa del desruido de una imagen es computacionalmente costosa e intensiva. Pero eso no significa que necesites acceso a GPUs potentes, o incluso a muchas, para usarlos. Existen muchas técnicas de optimización para ejecutar modelos de difusión en recursos de consumo y de nivel gratuito. Por ejemplo, puedes cargar los pesos del modelo en media precisión para ahorrar memoria de GPU y aumentar la velocidad, o descargar el modelo completo a la GPU para ahorrar aún más memoria.

PyTorch 2.0 también admite un mecanismo de atención más eficiente en memoria llamado atención de producto escalar que se habilita automáticamente si estás usando PyTorch 2.0. Puedes combinar esto con torch.compile para acelerar aún más tu código:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained("stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16, variant="fp16").to("cuda")  # or "mps", "xpu", "cpu"
pipeline.unet = torch.compile(pipeline.unet, mode="reduce-overhead", fullgraph=True)

Para obtener más consejos sobre cómo optimizar tu código para ahorrar memoria y acelerar la inferencia, lee las guías Accelerate inference y Reduce memory usage.