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. Vérifiez quelles techniques sont prises en charge par votre matériel avant d'appliquer les optimisations ci-dessous.

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.

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

Compilation

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 à generate() pour déclencher automatiquement torch.compile.

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]

Évitez d'appeler torch.compile(model) en dehors de generate() afin d'empêcher le modèle de se recompiler à chaque étape.

Backends d'attention

Les backends d'attention alternatifs 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() pour charger un backend d'attention optimisé.

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 charge des noyaux de calcul optimisés depuis le Hub 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.

import torch
from transformers import AutoModelForCausalLM

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

Quantification

La quantification 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(). 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.

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 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() pour définir une stratégie de cache.

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 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 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() pour l'activer.

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 maximise le débit en maintenant le GPU actif grâce à un ordonnancement dynamique et au préremplissage par morceaux. Les applications de Serving l'utilisent pour traiter simultanément plusieurs requêtes entrantes.

Utilisez generate_batch() pour activer le lotissement continu.

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