# Aperçu

Transformers propose plusieurs techniques d’optimisation de l’inférence afin de rendre les modèles rapides, abordables et accessibles. Les options incluent des mécanismes d’attention alternatifs pour réduire le trafic mémoire, la compilation du code pour une exécution plus rapide et des noyaux optimisés pour le débit. Cumulez ces techniques pour obtenir des performances maximales.

Pour la configuration de l'appareil et les réglages spécifiques au matériel, consultez les guides [Matériel](./hardware). Vérifiez quelles techniques sont prises en charge par votre matériel avant d'appliquer les optimisations ci-dessous.

> [!AgentPrompt]
> Aidez l'utilisateur à choisir une optimisation pour sa charge de travail d'inférence Transformers. Identifiez d'abord si la mémoire ou la vitesse devient un problème lors du chargement du modèle, du traitement d'entrées longues, de la génération de séquences plus longues ou du service de requêtes concurrentes. Utilisez le guide correspondant ci-dessous et vérifiez la prise en charge du modèle et du matériel de l'utilisateur avant de recommander un changement.
>
> 1. Demandez le modèle et la révision, les versions des bibliothèques, le GPU et la VRAM disponible, la RAM CPU, la longueur d’entrée, la limite de génération, la taille du lot et le nombre de requêtes simultanées. Posez des questions complémentaires si des détails manquants pourraient modifier la recommandation, et énoncez vos hypothèses. 2. Utilisez le point où le problème se produit pour choisir ce qu’il faut investiguer. Vérifiez les poids du modèle et les paramètres de chargement pour la mémoire au moment du chargement, le cache KV à mesure que les séquences générées s’allongent, les allocations d’attention pour les entrées longues, ainsi que l’état par requête et l’ordonnancement pour les requêtes simultanées. Traitez la quantification des poids et la quantification du cache KV comme des paramètres distincts. 3. Recommandez une modification à la fois. Vérifiez la compatibilité entre le modèle et le matériel, puis mesurez la mémoire GPU de pointe, la latence ou le débit, et la qualité de la sortie sur le même jeu de travail représentatif. Expliquez toute réduction de la longueur d’entrée, de la longueur de génération ou de la concurrence comme un compromis de charge de travail. 4. Rapportez la configuration proposée, la documentation qui la soutient, les compromis attendus, les questions de compatibilité non résolues et une procédure de validation. Distinguez les mesures des estimations. Si vous ne pouvez pas exécuter la charge de travail, indiquez que l’adéquation et les performances restent non vérifiées.

> [!NOTE]
> La mémoire et la vitesse sont étroitement liées, mais ne sont pas identiques. Réduire l’empreinte mémoire d’un modèle le rend « plus rapide » car il y a moins de données à manipuler. Les optimisations de vitesse pures ne réduisent pas toujours la mémoire et peuvent parfois augmenter sa consommation. Choisissez l’optimisation appropriée en fonction de votre cas d’usage et de votre matériel.

Utilisez le tableau ci-dessous pour choisir une technique d’optimisation.

| Technique | Vitesse | Mémoire |
|---|:---:|:---:|
| [Compilation](#compilation) | ✅ | |
| [Backends d'attention](#attention-backends) | ✅ | ✅ |
| [Noyaux](#kernels) | ✅ | ✅ |
| [Quantification](#quantization) | ✅ | ✅ |
| [Mise en cache](#caching) | ✅ | ✅ |
| [Parallélisme](#parallelism) | ✅ | |
| [Batching continu](#continuous-batching) | ✅ | |

Ce guide vous propose une prise en main rapide des optimisations de Transformers.

## Compilation

[torch.compile](./perf_torch_compile) réduit la surcharge Python, fusionne les opérations et génère des noyaux optimisés pour vos formes et votre matériel. La première exécution sert de phase de mise en route, et les exécutions suivantes utilisent le chemin compilé plus rapide.

Passez un [cache de taille fixe](./kv_cache#fixed-size-cache) à [generate()](/docs/transformers/v5.23.0/fr/main_classes/text_generation#transformers.GenerationMixin.generate) pour déclencher automatiquement `torch.compile`.

```py
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-0.6B")
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-0.6B", dtype=torch.float16, device_map="auto")
input = tokenizer("The French Bread Law states", return_tensors="pt").to(model.device)

output = model.generate(**input, do_sample=False, max_new_tokens=20, cache_implementation="static")
tokenizer.batch_decode(output, skip_special_tokens=True)[0]
```

> [!WARNING]
> Évitez d'appeler `torch.compile(model)` en dehors de [generate()](/docs/transformers/v5.23.0/fr/main_classes/text_generation#transformers.GenerationMixin.generate) afin d'empêcher le modèle de se recompiler à chaque étape.

## Backends d'attention

Les [backends d'attention alternatifs](./attention_interface) réduisent le trafic mémoire. Par exemple, FlashAttention découpe les calculs d'attention en tuiles et évite les grands tenseurs intermédiaires afin de réduire l'empreinte mémoire.

Définissez `attn_implementation` dans [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger un backend d'attention optimisé.

```py
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-0.6B", attn_implementation="flash_attention_2")
```

## Kernels

Les noyaux fusionnent les opérations pour augmenter le débit et réduire l'utilisation de la mémoire. La bibliothèque [Kernels](https://huggingface.co/docs/kernels/en/index) charge des noyaux de calcul optimisés depuis le [Hub](https://huggingface.co/kernels-community) de manière flexible et sécurisée en termes de version.

L'exemple ci-dessous charge un noyau FlashAttention-2 optimisé sans installer le package.

```py
import torch
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-0.6B", attn_implementation="kernels-community/flash-attn2"
)
```

## Quantification

[La quantification](./quantization/overview) réduit la taille de chaque paramètre, ce qui diminue l’empreinte mémoire et augmente la vitesse, car vous pouvez effectuer davantage d’opérations.

Passez une configuration de quantification à l'argument `quantization_config` dans [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained). Chaque backend de quantification possède une configuration distincte avec des arguments différents. L'exemple ci-dessous quantifie un modèle en 4 bits et configure le type de données de calcul avec le backend [bitsandbytes](./quantization/bitsandbytes).

```py
import torch
from transformers import AutoModelForCausalLM, BitsAndBytesConfig

bnb_config = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_compute_dtype=torch.bfloat16)

model = AutoModelForCausalLM.from_pretrained(
    "allenai/Olmo-3-7B-Think", quantization_config=bnb_config
)
```

## Mise en cache

[Caching](./kv_cache) accélère la génération en réutilisant les clés et valeurs passées plutôt qu'en les recalculant pour chaque jeton. Pour compenser et réduire le coût mémoire lié au stockage des clés et valeurs passées, Transformers prend en charge le déchargement du cache sur le CPU. Seule la couche courante reste sur le GPU.

Utilisez l’argument `cache_implementation` dans [generate()](/docs/transformers/v5.23.0/fr/main_classes/text_generation#transformers.GenerationMixin.generate) pour définir une stratégie de cache.

```py
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-0.6B")
model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-0.6B", attn_implementation="kernels-community/flash-attn2"
)
inputs = tokenizer("The Le Décret Pain states that a baguette must,", return_tensors="pt")
outputs = model.generate(**inputs, do_sample=False, max_new_tokens=50, cache_implementation="offloaded")
```

## Parallélisme

[Parallelism](./perf_infer_gpu_multi) répartit un modèle sur plusieurs dispositifs afin que les modèles trop volumineux pour un seul dispositif s'exécutent rapidement. Cette approche consomme davantage de mémoire en raison des surcoûts liés au fractionnement et à la communication nécessaire pour synchroniser les résultats.

[Le parallélisme de tenseurs](./perf_infer_gpu_multi) répartit une couche de modèle sur plusieurs appareils. Définissez le nombre d'appareils avec `DistributedConfig(tp_size=N)` et transmettez-le à [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour l'activer.

```py
from transformers import AutoModelForCausalLM, DistributedConfig

distributed_config = DistributedConfig(tp_size=4)
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Meta-Llama-3-8B-Instruct",
    distributed_config=distributed_config,
)
print(model._tp_plan)
```

## Batching continu

[Continuous batching](./continuous_batching) maximise le débit en maintenant le GPU actif grâce à un ordonnancement dynamique et au préremplissage par morceaux. Les applications de [Serving](./serve-cli/serving) l'utilisent pour traiter simultanément plusieurs requêtes entrantes.

Utilisez [generate_batch()](/docs/transformers/v5.23.0/fr/main_classes/text_generation#transformers.ContinuousMixin.generate_batch) pour activer le lotissement continu.

```py
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from transformers.generation import ContinuousBatchingConfig, GenerationConfig

model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-0.6B",
    attn_implementation="sdpa",
    device_map="auto",
    torch_dtype=torch.bfloat16,
)
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-0.6B")

prompts = [
    "The Le Décret Pain states that a baguette must",
    "Explain gravity in one sentence.",
    "Name the capital of France.",
]
inputs = [tokenizer.encode(p) for p in prompts]

generation_config = GenerationConfig(
    max_new_tokens=32,
    eos_token_id=tokenizer.eos_token_id,
    pad_token_id=tokenizer.pad_token_id,
    do_sample=False,
)
continuous_batching_config = ContinuousBatchingConfig(max_batch_tokens=512)

outputs = model.generate_batch(
    inputs=inputs,
    generation_config=generation_config,
    continuous_batching_config=continuous_batching_config,
)

for request_id, output in outputs.items():
    text = tokenizer.decode(output.generated_tokens, skip_special_tokens=True)
    print(f"[{request_id}] {text}")
```

