SDXL Turbo

Stable Diffusion XL (SDXL) Turbo fue propuesto en Adversarial Diffusion Distillation por Axel Sauer, Dominik Lorenz, Andreas Blattmann y Robin Rombach.

El resumen del artículo es:

Introducimos Adversarial Diffusion Distillation (ADD), un enfoque de entrenamiento novedoso que muestrea de manera eficiente modelos de difusión de imágenes a gran escala en solo 1–4 pasos, manteniendo al mismo tiempo una alta calidad de imagen. Utilizamos score distillation para aprovechar modelos de difusión de imágenes a gran escala disponibles como señal de maestro, en combinación con una pérdida adversarial para garantizar una alta fidelidad de imagen incluso en el régimen de pocos pasos, de uno o dos pasos de muestreo. Nuestros análisis muestran que nuestro modelo supera claramente a los métodos existentes de pocos pasos (GANs, Latent Consistency Models) en un solo paso y alcanza el rendimiento de los modelos de difusión de última generación (SDXL) en solo cuatro pasos. ADD es el primer método que habilita la síntesis de imágenes en tiempo real y en un solo paso con modelos fundacionales.

Consejos

• SDXL Turbo utiliza exactamente la misma arquitectura que SDXL, lo que significa que también tiene la misma API. Consulte la referencia de la API de SDXL para obtener más detalles.
• SDXL Turbo debe deshabilitar la escala de guía estableciendo guidance_scale=0.0.
• SDXL Turbo debe usar timestep_spacing='trailing' para el programador y entre 1 y 4 pasos.
• SDXL Turbo se ha entrenado para generar imágenes de tamaño 512x512.
• SDXL Turbo es de acceso abierto, pero no es de código abierto, lo que significa que podría ser necesario adquirir una licencia del modelo para utilizarlo en aplicaciones comerciales. Asegúrate de leer la ficha oficial del modelo para obtener más información.

¡Echa un vistazo a la organización de Stability AI en Hub para los puntos de control oficiales de los modelos base y refiner!

Asegúrate de tener instaladas las siguientes bibliotecas.

# uncomment to install the necessary libraries in Colab
#!pip install -q diffusers transformers accelerate

Cargar puntos de control de modelos

Los pesos del modelo pueden estar almacenados en subcarpetas separadas en el Hub o localmente, en cuyo caso, debes usar el método from_pretrained():

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained("stabilityai/sdxl-turbo", dtype=torch.float16, variant="fp16")
pipeline = pipeline.to("cuda")  # or "mps", "xpu", "cpu"

También puedes usar el método from_single_file() para cargar un punto de control de modelo almacenado en un formato de archivo único (.ckpt o .safetensors) desde el Hub o localmente. Para este método de carga, necesitas establecer timestep_spacing="trailing" (siéntete libre de experimentar con otros valores de configuración del programador para obtener mejores resultados):

from diffusers import StableDiffusionXLPipeline, EulerAncestralDiscreteScheduler
import torch

pipeline = StableDiffusionXLPipeline.from_single_file(
    "https://huggingface.co/stabilityai/sdxl-turbo/blob/main/sd_xl_turbo_1.0_fp16.safetensors",
    dtype=torch.float16, variant="fp16")
pipeline = pipeline.to("cuda")  # or "mps", "xpu", "cpu"
pipeline.scheduler = EulerAncestralDiscreteScheduler.from_config(pipeline.scheduler.config, timestep_spacing="trailing")

Texto a imagen

Para texto a imagen, pasa un prompt de texto. Por defecto, SDXL Turbo genera una imagen de 512x512, y esa resolución ofrece los mejores resultados. Puedes intentar establecer los parámetros height y width en 768x768 o 1024x1024, pero debes esperar degradaciones de calidad al hacerlo.

Asegúrate de establecer guidance_scale en 0.0 para desactivarlo, ya que el modelo se entrenó sin él. Un solo paso de inferencia es suficiente para generar imágenes de alta calidad. Aumentar el número de pasos a 2, 3 o 4 debería mejorar la calidad de la imagen.

from diffusers import AutoPipelineForText2Image
import torch

pipeline_text2image = AutoPipelineForText2Image.from_pretrained("stabilityai/sdxl-turbo", dtype=torch.float16, variant="fp16")
pipeline_text2image = pipeline_text2image.to("cuda")  # or "mps", "xpu", "cpu"

prompt = "A cinematic shot of a baby racoon wearing an intricate italian priest robe."

image = pipeline_text2image(prompt=prompt, guidance_scale=0.0, num_inference_steps=1).images[0]
image

Imagen a imagen

Para la generación de imagen a imagen, asegúrese de que num_inference_steps * strength sea mayor o igual a 1. El pipeline de imagen a imagen se ejecutará durante int(num_inference_steps * strength) pasos, por ejemplo, 0.5 * 2.0 = 1 paso en nuestro ejemplo a continuación.

from diffusers import AutoPipelineForImage2Image
from diffusers.utils import load_image, make_image_grid

# use from_pipe to avoid consuming additional memory when loading a checkpoint
pipeline_image2image = AutoPipelineForImage2Image.from_pipe(pipeline_text2image).to("cuda")  # or "mps", "xpu", "cpu"

init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/cat.png")
init_image = init_image.resize((512, 512))

prompt = "cat wizard, gandalf, lord of the rings, detailed, fantasy, cute, adorable, Pixar, Disney, 8k"

image = pipeline_image2image(prompt, image=init_image, strength=0.5, guidance_scale=0.0, num_inference_steps=2).images[0]
make_image_grid([init_image, image], rows=1, cols=2)

Acelerar aún más SDXL Turbo

• Compile el UNet si estás usando la versión 2.0 o superior de PyTorch. La primera ejecución de inferencia será muy lenta, pero las siguientes serán mucho más rápidas.

pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True)

• Al usar el VAE predeterminado, manténgalo en float32 para evitar costosas conversiones de dtype antes y después de cada generación. Solo necesita hacer esto una vez antes de su primera generación:

pipe.upcast_vae()

Como alternativa, también puede utilizar un VAE de 16 bits creado por el miembro de la comunidad @madebyollin que no necesita ser elevado a float32.