SDXL Turbo

Stable Diffusion XL (SDXL) Turbo foi proposto em Adversarial Diffusion Distillation por Axel Sauer, Dominik Lorenz, Andreas Blattmann e Robin Rombach.

O resumo do artigo é:

Apresentamos o Adversarial Diffusion Distillation (ADD), uma nova abordagem de treinamento que amostra eficientemente modelos de difusão de imagem em larga escala em apenas 1 a 4 etapas, mantendo alta qualidade de imagem. Utilizamos score distillation para aproveitar modelos de difusão de imagem em larga escala prontos para uso como sinal de professor, em combinação com uma perda adversarial para garantir alta fidelidade de imagem mesmo no regime de poucas etapas, com uma ou duas etapas de amostragem. Nossas análises mostram que nosso modelo supera claramente os métodos existentes de poucas etapas (GANs, Latent Consistency Models) em uma única etapa e atinge o desempenho dos modelos de difusão de estado da arte (SDXL) em apenas quatro etapas. O ADD é o primeiro método a viabilizar a síntese de imagem em tempo real em uma única etapa com modelos fundacionais.

Dicas

• O SDXL Turbo usa exatamente a mesma arquitetura do SDXL, o que significa que também possui a mesma API. Consulte a referência da API do SDXL para mais detalhes.
• O SDXL Turbo deve desabilitar a escala de orientação definindo guidance_scale=0.0.
• O SDXL Turbo deve usar timestep_spacing='trailing' para o scheduler e usar entre 1 e 4 etapas.
• O SDXL Turbo foi treinado para gerar imagens de tamanho 512x512.
• SDXL Turbo é de acesso aberto, mas não é de código aberto, o que significa que pode ser necessário adquirir uma licença do modelo para usá-lo em aplicações comerciais. Certifique-se de ler o cartão oficial do modelo para saber mais.

Confira a organização Stability AI no Hub para os checkpoints oficiais dos modelos base e refiner!

Certifique-se de que as seguintes bibliotecas estão instaladas.

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

Carregar checkpoints de modelos

Os pesos do modelo podem estar armazenados em subpastas separadas no Hub ou localmente, caso em que você deve usar o 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"

Você também pode usar o método from_single_file() para carregar um checkpoint de modelo armazenado em um formato de arquivo único (.ckpt ou .safetensors) do Hub ou localmente. Para esse método de carregamento, você precisa definir timestep_spacing="trailing" (sinta-se à vontade para experimentar com os outros valores de configuração do scheduler para obter melhores 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 para imagem

Para texto-para-imagem, passe um prompt de texto. Por padrão, o SDXL Turbo gera uma imagem de 512x512, e essa resolução oferece os melhores resultados. Você pode tentar definir os parâmetros height e width para 768x768 ou 1024x1024, mas deve esperar uma degradação de qualidade ao fazer isso.

Certifique-se de definir guidance_scale como 0.0 para desativar, pois o modelo foi treinado sem ele. Uma única etapa de inferência é suficiente para gerar imagens de alta qualidade. Aumentar o número de etapas para 2, 3 ou 4 deve melhorar a qualidade da imagem.

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

Imagem para imagem

Para a geração de imagem para imagem, verifique se num_inference_steps * strength é maior ou igual a 1. O pipeline de imagem para imagem será executado por int(num_inference_steps * strength) etapas, por exemplo, 0.5 * 2.0 = 1 etapa no nosso exemplo abaixo.

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)

Acelere ainda mais o SDXL Turbo

• Compile o UNet se estiver usando a versão 2.0 ou superior do PyTorch. A primeira execução de inferência será muito lenta, mas as subsequentes serão muito mais rápidas.

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

• Ao usar o VAE padrão, mantenha-o em float32 para evitar conversões de dtype custosas antes e depois de cada geração. Você só precisa fazer isso uma vez, antes da sua primeira geração:

pipe.upcast_vae()

Como alternativa, você também pode usar um VAE de 16 bits criado pelo membro da comunidade @madebyollin que não precisa ser convertido para float32.