# Aperçu

L'inférence par diffusion est coûteuse en calculs, et vous exécutez souvent un [DiffusionPipeline](/docs/diffusers/main/fr/api/pipelines/overview#diffusers.DiffusionPipeline) plusieurs fois avant d'obtenir un résultat satisfaisant. Cette page présente un aperçu des principales techniques d'optimisation de Diffusers, de leur fonctionnement et de leurs cas d'usage.

## Parcours de démarrage

Lorsque le modèle tient sur un seul GPU, commencez par cette charge de référence. Définissez `dtype` et placez le pipeline sur un accélérateur. N'utilisez le déchargement du modèle sur CPU que lorsque la mémoire est limitée. Vous pouvez également accélérer l'inférence en réduisant le nombre d'étapes ou en utilisant un planificateur plus rapide.

Lorsque vous omettez `dtype`, Diffusers charge les composants en `float32`. Passez `dtype=torch.bfloat16` (ou `torch.float16` si bfloat16 n'est pas pris en charge), puis placez le pipeline sur un accélérateur avec `pipeline.to("cuda")`.

```py
import torch
from diffusers import DiffusionPipeline

pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    dtype=torch.bfloat16,
)
pipeline.to("cuda")  # or "mps", "xpu"

prompt = """
cinematic film still of a cat sipping a margarita in a pool in Palm Springs, California
highly detailed, high budget hollywood movie, cinemascope, moody, epic, gorgeous, film grain
"""
pipeline(prompt).images[0]
```

Si le pipeline ne tient pas, ou si la mémoire est limitée, appelez [enable_model_cpu_offload()](/docs/diffusers/main/fr/api/pipelines/overview#diffusers.DiffusionPipeline.enable_model_cpu_offload) au lieu de tout conserver sur le GPU. Il place le modèle actif sur le GPU et garde les autres composants sur le CPU.

À ignorer lorsque le modèle tient en mémoire. Le déchargement est plus lent lorsqu'il n'est pas nécessaire.

Pour plus d'options de déchargement, voir [Réduire l'utilisation de la mémoire](./memory#offloading).

```py
pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    dtype=torch.bfloat16,
)
pipeline.enable_model_cpu_offload()
```

Latence réduite avec un nombre inférieur de `num_inference_steps` ou un planificateur plus rapide tel que [DPMSolverMultistepScheduler](/docs/diffusers/main/fr/api/schedulers/multistep_dpm_solver#diffusers.DPMSolverMultistepScheduler). Cela accélère généralement la génération, mais peut réduire la qualité de l’image par rapport à un planificateur plus lent et de meilleure qualité. Consultez [Techniques d’optimisation](#optimization-techniques) ci-dessous pour d’autres techniques de vitesse.

```py
import time
from diffusers import DPMSolverMultistepScheduler

pipeline.scheduler = DPMSolverMultistepScheduler.from_config(pipeline.scheduler.config)

start_time = time.perf_counter()
image = pipeline(prompt, num_inference_steps=25).images[0]
end_time = time.perf_counter()

print(f"Image generation took {end_time - start_time:.3f} seconds")
```

## Techniques d'optimisation

Lorsque le chemin de démarrage ne suffit pas, utilisez ces techniques. Si l’inférence est trop lente, commencez par `torch.compile`, le cache ou les backends d’attention. Si vous êtes à court de mémoire, commencez par l’offloading ou la quantification.

Inférence plus rapide :

- [torch.compile](./fp16#torchcompile) — Compile le UNet, le transformer ou le VAE en noyaux optimisés.
- [Compilation régionale](./fp16#regional-compilation) — Compilez les blocs répétés pour réduire la latence de démarrage à froid de `torch.compile` et réutiliser les artefacts compilés.
- [Mise en cache](./cache) — Réutilisez les intermédiaires entre les étapes de débruitage si vous souhaitez plus de vitesse et pouvez consacrer de la mémoire.
- [Backends d'attention](./attention_backends) — Remplacez les implémentations d'attention de Diffusers via une API unifiée lorsque l'attention est le goulot d'étranglement.
- [Kernels](./fp16#kernels) — Chargez les noyaux de calcul optimisés du Hub (attention et opérations CUDA personnalisées telles que RMSNorm ou RoPE) lorsque vous avez besoin d'accélérations spécifiques au matériel au-delà de PyTorch standard.

Moins de mémoire :

- [Déchargement](./memory#offloading) — Déplacer les modèles ou les couches inactifs vers le CPU grâce au déchargement CPU, modèle ou groupe.
- [Quantification](../quantization/overview) — Chargez des poids plus petits pour réduire la mémoire (certains backends accélèrent également l'inférence). [GGUF](../quantization/gguf) est un point de départ courant.
- [Tronçonnage du VAE](./memory#vae-slicing) et [tiling du VAE](./memory#vae-tiling) — Décoder de grands lots ou des images haute résolution par morceaux pour réduire la mémoire de pointe.

Les deux :

- [Quantifier, compiler et décharger](./speed-memory-optims) — Combinez la quantification, `torch.compile` et le déchargement lorsqu'une seule technique ne suffit pas.