# 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.

> [!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/main/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/main/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/main/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/main/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/main/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/main/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/main/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}")
```