Diffusers documentation
Imagen a imagen
Imagen a imagen
Image-to-image es similar a text-to-image, pero además de un prompt, también puedes pasar una imagen inicial como punto de partida para el proceso de difusión. La imagen inicial se codifica en el espacio latente y se le añade ruido. Luego, el modelo de difusión latente toma un prompt y la imagen latente con ruido, predice el ruido añadido y elimina el ruido predicho de la imagen latente inicial para obtener la nueva imagen latente. Por último, un decodificador decodifica la nueva imagen latente de vuelta a una imagen.
Con 🤗 Diffusers, es tan fácil como 1-2-3:
- Cargue un punto de control en la clase AutoPipelineForImage2Image; este pipeline maneja automáticamente la carga de la clase de pipeline correcta en función del punto de control:
import torch
from diffusers import AutoPipelineForImage2Image
from diffusers.utils import load_image, make_image_grid
pipeline = AutoPipelineForImage2Image.from_pretrained(
"kandinsky-community/kandinsky-2-2-decoder", dtype=torch.float16, use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()A lo largo de la guía, notará que usamos enable_model_cpu_offload() y enable_xformers_memory_efficient_attention() para ahorrar memoria y aumentar la velocidad de inferencia. Si está usando PyTorch 2.0, no necesita llamar a enable_xformers_memory_efficient_attention() en su pipeline, ya que ya estará utilizando la scaled-dot product attention nativa de PyTorch 2.0.
- Cargue una imagen para pasarla a la tubería:
init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/cat.png")- Pase un prompt y una imagen a la pipeline para generar una imagen:
prompt = "cat wizard, gandalf, lord of the rings, detailed, fantasy, cute, adorable, Pixar, Disney, 8k"
image = pipeline(prompt, image=init_image).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
Modelos populares
Los modelos de imagen a imagen más populares son Stable Diffusion v1.5, Stable Diffusion XL (SDXL) y Kandinsky 2.2. Los resultados de los modelos Stable Diffusion y Kandinsky varían debido a las diferencias en su arquitectura y proceso de entrenamiento; en general, se puede esperar que SDXL produzca imágenes de mayor calidad que Stable Diffusion v1.5. Echemos un vistazo rápido a cómo usar cada uno de estos modelos y comparemos sus resultados.
Stable Diffusion v1.5
Stable Diffusion v1.5 es un modelo de difusión latente inicializado a partir de un checkpoint anterior y afinado adicionalmente durante 595K pasos en imágenes de 512x512. Para usar este pipeline para image-to-image, deberá preparar una imagen inicial para pasarla al pipeline. Luego puede pasar un prompt y la imagen al pipeline para generar una nueva imagen:
import torch
from diffusers import AutoPipelineForImage2Image
from diffusers.utils import make_image_grid, load_image
pipeline = AutoPipelineForImage2Image.from_pretrained(
"stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16, variant="fp16", use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()
# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png"
init_image = load_image(url)
prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
# pass prompt and image to pipeline
image = pipeline(prompt, image=init_image).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
Stable Diffusion XL (SDXL)
SDXL es una versión más potente del modelo Stable Diffusion. Utiliza un modelo base más grande y un modelo refiner adicional para aumentar la calidad de la salida del modelo base. Lea la guía de SDXL para obtener una explicación más detallada sobre cómo usar este modelo y otras técnicas que emplea para generar imágenes de alta calidad.
import torch
from diffusers import AutoPipelineForImage2Image
from diffusers.utils import make_image_grid, load_image
pipeline = AutoPipelineForImage2Image.from_pretrained(
"stabilityai/stable-diffusion-xl-refiner-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()
# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-sdxl-init.png"
init_image = load_image(url)
prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
# pass prompt and image to pipeline
image = pipeline(prompt, image=init_image, strength=0.5).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
Kandinsky 2.2
El modelo Kandinsky es diferente de los modelos Stable Diffusion porque utiliza un modelo de prior de imagen para crear embeddings de imagen. Los embeddings ayudan a crear una mejor alineación entre el texto y las imágenes, permitiendo que el modelo de difusión latente genere mejores imágenes.
La forma más sencilla de usar Kandinsky 2.2 es:
import torch
from diffusers import AutoPipelineForImage2Image
from diffusers.utils import make_image_grid, load_image
pipeline = AutoPipelineForImage2Image.from_pretrained(
"kandinsky-community/kandinsky-2-2-decoder", dtype=torch.float16, use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()
# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png"
init_image = load_image(url)
prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
# pass prompt and image to pipeline
image = pipeline(prompt, image=init_image).images[0]
make_image_grid([init_image, image], rows=1, cols=2) 
Configurar los parámetros de la canalización
Hay varios parámetros importantes que puedes configurar en el pipeline y que afectarán al proceso de generación de imágenes y a la calidad de las imágenes. Veamos más de cerca qué hacen estos parámetros y cómo afecta su modificación a la salida.
Fuerza
strength es uno de los parámetros más importantes a considerar y tendrá un gran impacto en la imagen generada. Determina en qué medida la imagen generada se asemeja a la imagen inicial. En otras palabras:
- 📈 un valor de
strengthmás alto otorga al modelo más “creatividad” para generar una imagen diferente de la imagen inicial; un valor destrengthde 1.0 significa que la imagen inicial se ignora más o menos - 📉 un valor de
strengthmás bajo significa que la imagen generada es más similar a la imagen inicial
Los parámetros strength y num_inference_steps están relacionados porque strength determina el número de pasos de ruido a añadir. Por ejemplo, si num_inference_steps es 50 y strength es 0.8, esto significa añadir 40 (50 * 0.8) pasos de ruido a la imagen inicial y luego desruidar durante 40 pasos para obtener la imagen recién generada.
import torch
from diffusers import AutoPipelineForImage2Image
from diffusers.utils import make_image_grid, load_image
pipeline = AutoPipelineForImage2Image.from_pretrained(
"stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16, variant="fp16", use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()
# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png"
init_image = load_image(url)
prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
# pass prompt and image to pipeline
image = pipeline(prompt, image=init_image, strength=0.8).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
Escala de guía
El parámetro guidance_scale se utiliza para controlar el grado de alineación entre la imagen generada y el texto de la solicitud. Un valor más alto de guidance_scale significa que la imagen generada está más alineada con la solicitud, mientras que un valor más bajo de guidance_scale significa que la imagen generada tiene más margen para desviarse de la solicitud.
Puedes combinar guidance_scale con strength para un control aún más preciso sobre la expresividad del modelo. Por ejemplo, combina un alto strength + guidance_scale para una creatividad máxima o utiliza una combinación de bajo strength y bajo guidance_scale para generar una imagen que se asemeje a la imagen inicial pero que no esté tan estrictamente ligada al prompt.
import torch
from diffusers import AutoPipelineForImage2Image
from diffusers.utils import make_image_grid, load_image
pipeline = AutoPipelineForImage2Image.from_pretrained(
"stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16, variant="fp16", use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()
# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png"
init_image = load_image(url)
prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
# pass prompt and image to pipeline
image = pipeline(prompt, image=init_image, guidance_scale=8.0).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
Prompt negativo
Un prompt negativo condiciona al modelo para que no incluya ciertos elementos en una imagen, y puede utilizarse para mejorar la calidad de la imagen o modificarla. Por ejemplo, puedes mejorar la calidad de la imagen incluyendo prompts negativos como “poor details” o “blurry” para animar al modelo a generar una imagen de mayor calidad. O bien, puedes modificar una imagen especificando los elementos que se deben excluir de ella.
import torch
from diffusers import AutoPipelineForImage2Image
from diffusers.utils import make_image_grid, load_image
pipeline = AutoPipelineForImage2Image.from_pretrained(
"stabilityai/stable-diffusion-xl-refiner-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()
# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png"
init_image = load_image(url)
prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
negative_prompt = "ugly, deformed, disfigured, poor details, bad anatomy"
# pass prompt and image to pipeline
image = pipeline(prompt, negative_prompt=negative_prompt, image=init_image).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
Pipelines de imagen a imagen encadenados
Existen otras formas interesantes de utilizar un pipeline de imagen a imagen, además de simplemente generar una imagen (aunque eso también es bastante genial). Puedes llevarlo un paso más allá y encadenarlo con otros pipelines.
Texto a imagen a imagen
Encadenar un pipeline de texto a imagen y un pipeline de imagen a imagen permite generar una imagen a partir de texto y utilizar la imagen generada como imagen inicial para el pipeline de imagen a imagen. Esto es útil si se desea generar una imagen completamente desde cero. Por ejemplo, encademos un modelo de Stable Diffusion y un modelo de Kandinsky.
Comience generando una imagen con el pipeline de texto a imagen:
from diffusers import AutoPipelineForText2Image, AutoPipelineForImage2Image
import torch
from diffusers.utils import make_image_grid
pipeline = AutoPipelineForText2Image.from_pretrained(
"stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16, variant="fp16", use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()
text2image = pipeline("Astronaut in a jungle, cold color palette, muted colors, detailed, 8k").images[0]
text2imageAhora puede pasar esta imagen generada a la pipeline de imagen a imagen:
pipeline = AutoPipelineForImage2Image.from_pretrained(
"kandinsky-community/kandinsky-2-2-decoder", dtype=torch.float16, use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()
image2image = pipeline("Astronaut in a jungle, cold color palette, muted colors, detailed, 8k", image=text2image).images[0]
make_image_grid([text2image, image2image], rows=1, cols=2)Imagen a imagen a imagen
También puede encadenar varios pipelines de imagen a imagen para crear imágenes más interesantes. Esto puede ser útil para realizar transferencias de estilo de forma iterativa en una imagen, generar GIFs cortos, restaurar el color de una imagen o restaurar áreas faltantes de una imagen.
Comience generando una imagen:
import torch
from diffusers import AutoPipelineForImage2Image
from diffusers.utils import make_image_grid, load_image
pipeline = AutoPipelineForImage2Image.from_pretrained(
"stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16, variant="fp16", use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()
# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png"
init_image = load_image(url)
prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
# pass prompt and image to pipeline
image = pipeline(prompt, image=init_image, output_type="latent").images[0]Es importante especificar
output_type="latent"en el pipeline para mantener todas las salidas en el espacio latente y evitar un paso innecesario de decodificación y codificación. Esto solo funciona si los pipelines encadenados utilizan el mismo VAE.
Pase la salida latente de este pipeline al siguiente pipeline para generar una imagen en un estilo de arte de cómic:
pipeline = AutoPipelineForImage2Image.from_pretrained(
"ogkalu/Comic-Diffusion", dtype=torch.float16
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()
# need to include the token "charliebo artstyle" in the prompt to use this checkpoint
image = pipeline("Astronaut in a jungle, charliebo artstyle", image=image, output_type="latent").images[0]Repite una vez más para generar la imagen final en un estilo de pixel art:
pipeline = AutoPipelineForImage2Image.from_pretrained(
"kohbanye/pixel-art-style", dtype=torch.float16
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()
# need to include the token "pixelartstyle" in the prompt to use this checkpoint
image = pipeline("Astronaut in a jungle, pixelartstyle", image=image).images[0]
make_image_grid([init_image, image], rows=1, cols=2)Imagen a amplificador a superresolución
Otra forma de encadenar tu pipeline de imagen a imagen es con un pipeline de escalado y superresolución para aumentar realmente el nivel de detalle en una imagen.
Comience con un pipeline de imagen a imagen:
import torch
from diffusers import AutoPipelineForImage2Image
from diffusers.utils import make_image_grid, load_image
pipeline = AutoPipelineForImage2Image.from_pretrained(
"stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16, variant="fp16", use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()
# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png"
init_image = load_image(url)
prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
# pass prompt and image to pipeline
image_1 = pipeline(prompt, image=init_image, output_type="latent").images[0]Es importante especificar
output_type="latent"en el pipeline para mantener todas las salidas en el espacio latente y evitar un paso innecesario de decodificación y codificación. Esto solo funciona si los pipelines encadenados utilizan el mismo VAE.
Encadenarlo a un pipeline de upscaler para aumentar la resolución de la imagen:
from diffusers import StableDiffusionLatentUpscalePipeline
upscaler = StableDiffusionLatentUpscalePipeline.from_pretrained(
"stabilityai/sd-x2-latent-upscaler", dtype=torch.float16, use_safetensors=True
)
upscaler.enable_model_cpu_offload()
upscaler.enable_xformers_memory_efficient_attention()
image_2 = upscaler(prompt, image=image_1).images[0]Por último, encadenarlo a un pipeline de superresolución para mejorar aún más la resolución:
from diffusers import StableDiffusionUpscalePipeline
super_res = StableDiffusionUpscalePipeline.from_pretrained(
"stabilityai/stable-diffusion-x4-upscaler", dtype=torch.float16, variant="fp16", use_safetensors=True
)
super_res.enable_model_cpu_offload()
super_res.enable_xformers_memory_efficient_attention()
image_3 = super_res(prompt, image=image_2).images[0]
make_image_grid([init_image, image_3.resize((512, 512))], rows=1, cols=2)Controlar la generación de imágenes
Intentar generar una imagen que se vea exactamente como lo deseas puede ser difícil, por lo que las técnicas y modelos de generación controlada son tan útiles. Si bien puedes usar negative_prompt para controlar parcialmente la generación de imágenes, existen métodos más robustos como el ponderado de prompts y ControlNets.
Pesos de los prompts
El ponderado de prompts permite escalar la representación de cada concepto en un prompt. Por ejemplo, en un prompt como “Astronaut in a jungle, cold color palette, muted colors, detailed, 8k”, puedes elegir aumentar o disminuir los embeddings de “astronaut” y “jungle”. La biblioteca Compel proporciona una sintaxis simple para ajustar los pesos de los prompts y generar los embeddings. Puedes aprender a crear los embeddings en la guía de Ponderado de prompts.
AutoPipelineForImage2Image tiene un parámetro prompt_embeds (y negative_prompt_embeds si estás usando un prompt negativo) donde puedes pasar los embeddings que reemplazan al parámetro prompt.
from diffusers import AutoPipelineForImage2Image
import torch
pipeline = AutoPipelineForImage2Image.from_pretrained(
"stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16, variant="fp16", use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()
image = pipeline(prompt_embeds=prompt_embeds, # generated from Compel
negative_prompt_embeds=negative_prompt_embeds, # generated from Compel
image=init_image,
).images[0]ControlNet
ControlNets ofrecen una forma más flexible y precisa de controlar la generación de imágenes, ya que puedes utilizar una imagen de condicionamiento adicional. La imagen de condicionamiento puede ser una imagen canny, un mapa de profundidad, una segmentación de imagen e incluso garabatos. Sea cual sea el tipo de imagen de condicionamiento que elijas, el ControlNet genera una imagen que preserva la información contenida en ella.
Por ejemplo, condicional una imagen con un mapa de profundidad para conservar la información espacial de la imagen.
from diffusers.utils import load_image, make_image_grid
# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png"
init_image = load_image(url)
init_image = init_image.resize((958, 960)) # resize to depth image dimensions
depth_image = load_image("https://huggingface.co/lllyasviel/control_v11f1p_sd15_depth/resolve/main/images/control.png")
make_image_grid([init_image, depth_image], rows=1, cols=2)Carga un modelo de ControlNet condicionado en mapas de profundidad y el AutoPipelineForImage2Image:
from diffusers import ControlNetModel, AutoPipelineForImage2Image
import torch
controlnet = ControlNetModel.from_pretrained("lllyasviel/control_v11f1p_sd15_depth", dtype=torch.float16, variant="fp16", use_safetensors=True)
pipeline = AutoPipelineForImage2Image.from_pretrained(
"stable-diffusion-v1-5/stable-diffusion-v1-5", controlnet=controlnet, dtype=torch.float16, variant="fp16", use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()Ahora genera una nueva imagen condicionada en el mapa de profundidad, la imagen inicial y el prompt:
prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
image_control_net = pipeline(prompt, image=init_image, control_image=depth_image).images[0]
make_image_grid([init_image, depth_image, image_control_net], rows=1, cols=3) 
Aplicaremos un nuevo estilo a la imagen generada desde ControlNet encadenándolo con un pipeline de imagen a imagen:
pipeline = AutoPipelineForImage2Image.from_pretrained(
"nitrosocke/elden-ring-diffusion", dtype=torch.float16,
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()
prompt = "elden ring style astronaut in a jungle" # include the token "elden ring style" in the prompt
negative_prompt = "ugly, deformed, disfigured, poor details, bad anatomy"
image_elden_ring = pipeline(prompt, negative_prompt=negative_prompt, image=image_control_net, strength=0.45, guidance_scale=10.5).images[0]
make_image_grid([init_image, depth_image, image_control_net, image_elden_ring], rows=2, cols=2)
Optimizar
Ejecutar modelos de difusión es computacionalmente costoso e intensivo, pero con algunos trucos de optimización es totalmente posible ejecutarlos en GPUs de consumo y de nivel gratuito. Por ejemplo, puedes usar una forma de atención más eficiente en memoria, como la atención de producto punto escalado de PyTorch 2.0 o xFormers (puedes usar uno u otro, pero no hay necesidad de usar ambos). También puedes descargar el modelo a la GPU mientras los demás componentes del pipeline esperan en la CPU.
+ pipeline.enable_model_cpu_offload()
+ pipeline.enable_xformers_memory_efficient_attention()Con torch.compile, puedes aumentar aún más la velocidad de inferencia envolviendo tu UNet con él:
pipeline.unet = torch.compile(pipeline.unet, mode="reduce-overhead", fullgraph=True)Para obtener más información, consulte las guías Reduce memory usage y Accelerate inference.
Update on GitHub