# SDXL Turbo

Stable Diffusion XL (SDXL) Turbo foi proposto em [Adversarial Diffusion Distillation](https://stability.ai/research/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](./stable_diffusion_xl), o que significa que também possui a mesma API. Consulte a referência da API do [SDXL](./stable_diffusion_xl) 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](https://huggingface.co/stabilityai/sdxl-turbo) para saber mais.

> [!TIP]
> Confira a organização [Stability AI](https://huggingface.co/stabilityai) no Hub para os checkpoints oficiais dos modelos base e refiner!

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

```py
# 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()](/docs/diffusers/main/pt/api/pipelines/overview#diffusers.DiffusionPipeline.from_pretrained):

```py
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()](/docs/diffusers/main/pt/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.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):

```py
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. Um único passo de inferência é suficiente para gerar imagens de alta qualidade. Aumentar o número de passos para 2, 3 ou 4 deve melhorar a qualidade da imagem.

```py
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 exemplo abaixo.

```py
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.

```py
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:

```py
pipe.upcast_vae()
```

Como alternativa, você também pode usar um [VAE de 16 bits](https://huggingface.co/madebyollin/sdxl-vae-fp16-fix) criado pelo membro da comunidade [`@madebyollin`](https://huggingface.co/madebyollin) que não precisa ser convertido para `float32`.