# SDXL Turbo

Stable Diffusion XL (SDXL) Turbo a été proposé dans [Adversarial Diffusion Distillation](https://stability.ai/research/adversarial-diffusion-distillation) par Axel Sauer, Dominik Lorenz, Andreas Blattmann et Robin Rombach.

L'abstract de l'article est :

*Nous présentons Adversarial Diffusion Distillation (ADD), une nouvelle approche d’entraînement qui permet d’échantillonner efficacement de grands modèles de diffusion d’images de base en seulement 1 à 4 étapes, tout en maintenant une haute qualité d’image. Nous utilisons la distillation de score pour exploiter de grands modèles de diffusion d’images prêts à l’emploi comme signal enseignant, en combinaison avec une perte adversariale afin d’assurer une haute fidélité d’image même dans le régime à faible nombre d’étapes, soit une ou deux étapes d’échantillonnage. Nos analyses montrent que notre modèle surpasse clairement les méthodes existantes à peu d’étapes (GANs, Latent Consistency Models) en une seule étape et atteint les performances des modèles de diffusion de pointe (SDXL) en seulement quatre étapes. ADD est la première méthode à débloquer la synthèse d’images en temps réel en une seule étape avec des modèles de base.*

## Astuces

- SDXL Turbo utilise exactement la même architecture que [SDXL](./stable_diffusion_xl), ce qui signifie qu'il possède également la même API. Veuillez consulter la référence de l'API [SDXL](./stable_diffusion_xl) pour plus de détails.
- SDXL Turbo doit désactiver l'échelle de guidage en définissant `guidance_scale=0.0`.
- SDXL Turbo doit utiliser `timestep_spacing='trailing'` pour le planificateur et utiliser entre 1 et 4 étapes.
- SDXL Turbo a été entraîné pour générer des images de taille 512x512.
- SDXL Turbo est accessible librement, mais n'est pas open source, ce qui signifie qu'il peut être nécessaire d'acheter une licence de modèle pour l'utiliser dans des applications commerciales. Assurez-vous de lire la [fiche modèle officielle](https://huggingface.co/stabilityai/sdxl-turbo) pour en savoir plus.

> [!TIP]
> Consultez l'organisation [Stability AI](https://huggingface.co/stabilityai) sur le Hub pour les points de contrôle officiels des modèles de base et de raffinement !

Assurez-vous d'avoir installé les bibliothèques suivantes.

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

## Charger les points de contrôle des modèles

Les poids du modèle peuvent être stockés dans des sous-dossiers distincts sur le Hub ou localement, auquel cas vous devez utiliser la méthode [from_pretrained()](/docs/diffusers/v0.43.0/fr/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"
```

Vous pouvez également utiliser la méthode [from_single_file()](/docs/diffusers/v0.43.0/fr/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file) pour charger un point de contrôle de modèle stocké dans un format de fichier unique (`.ckpt` ou `.safetensors`) depuis le Hub ou localement. Pour cette méthode de chargement, vous devez définir `timestep_spacing="trailing"` (n'hésitez pas à expérimenter avec les autres valeurs de configuration du planificateur pour obtenir de meilleurs résultats) :

```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")
```

## Texte vers image

Pour la génération d’images à partir de texte, transmettez un prompt texte. Par défaut, SDXL Turbo génère une image de 512x512, et cette résolution offre les meilleurs résultats. Vous pouvez essayer de définir les paramètres `height` et `width` sur 768x768 ou 1024x1024, mais vous devez vous attendre à une dégradation de la qualité en procédant ainsi.

Assurez-vous de définir `guidance_scale` à 0.0 pour le désactiver, car le modèle a été entraîné sans ce paramètre. Une seule étape d'inférence suffit pour générer des images de haute qualité. Augmenter le nombre d'étapes à 2, 3 ou 4 devrait améliorer la qualité des images.

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

    

## Image vers image

Pour la génération d’image à partir d’image, assurez-vous que `num_inference_steps * strength` est supérieur ou égal à 1. Le pipeline image-à-image s’exécutera pendant `int(num_inference_steps * strength)` étapes, par exemple `0.5 * 2.0 = 1` étape dans l’exemple ci-dessous.

```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)
```

    

## Accélérer encore plus SDXL Turbo

- Compilez le UNet si vous utilisez la version 2.0 ou supérieure de PyTorch. La première exécution d’inférence sera très lente, mais les suivantes seront beaucoup plus rapides.

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

- Lors de l'utilisation du VAE par défaut, conservez-le en `float32` pour éviter les conversions coûteuses de `dtype` avant et après chaque génération. Vous n'avez besoin de le faire qu'une seule fois, avant votre première génération :

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

En alternative, vous pouvez également utiliser un [VAE 16 bits](https://huggingface.co/madebyollin/sdxl-vae-fp16-fix) créé par le membre de la communauté [`@madebyollin`](https://huggingface.co/madebyollin), qui n'a pas besoin d'être converti en `float32`.