Le guide technique complet sur les grands modèles de langage — depuis la transformation du texte brut en nombres, en passant par l'architecture transformer et le mécanisme d'attention, jusqu'à l'entraînement, l'alignement, l'inférence, le RAG et le déploiement en production. Sans approximations ; de vraies équations et du vrai code.
Un grand modèle de langage (LLM) est un réseau de neurones entraîné à prédire le token suivant dans une séquence de texte. Cet unique objectif — la prédiction du token suivant — s'avère extraordinairement puissant : pour bien prédire, le modèle doit apprendre la grammaire, des faits, des schémas de raisonnement, la syntaxe du code, et bien plus encore.
Le terme « grand » renvoie au nombre de paramètres (de milliards à milliers de milliards de poids appris) et à l'échelle des données d'entraînement (des milliers de milliards de tokens issus du web, des livres et du code). À une échelle suffisante, les modèles présentent des capacités émergentes — des aptitudes absentes des modèles plus petits et non explicitement entraînées, comme l'arithmétique à plusieurs étapes, le raisonnement analogique et l'apprentissage en contexte à partir d'une poignée d'exemples.
Sur le plan architectural, tout grand LLM actuel est un transformer à décodeur seul (famille GPT, Llama, Mistral, Claude, Gemini). Le modèle prend en entrée une séquence d'identifiants de tokens et produit une distribution de probabilité sur le vocabulaire pour le token suivant. La génération est autorégressive : le modèle échantillonne un token, l'ajoute à la séquence, et recommence.
graph LR A[Input Text] --> B[Tokenizer] B --> C[Token IDs] C --> D[Embedding Layer] D --> E[Transformer Blocks xN] E --> F[LM Head] F --> G[Logits over Vocabulary] G --> H[Softmax + Sampling] H --> I[Next Token] I -->|Autoregressive loop| C
Des capacités qui n'apparaissent qu'au-delà de certains seuils d'échelle — apprentissage few-shot, raisonnement en chaîne de pensée, suivi d'instructions — et qui n'ont pas été explicitement entraînées.
Le modèle adapte son comportement en fonction d'exemples présents dans le prompt (few-shot) sans aucune mise à jour des poids. La fenêtre de contexte est la seule « mémoire » durant l'inférence.
Les poids du modèle encodent une compression avec perte du corpus d'entraînement. Les faits ne sont pas stockés mot pour mot — ils sont répartis sur des milliards de poids, d'où la survenue d'hallucinations.
Les LLM n'opèrent pas sur des caractères ou des mots — ils opèrent sur des tokens, des unités sous-lexicales produites par un tokenizer entraîné sur le même corpus. Comprendre la tokenization explique le coût, la longueur de contexte et de nombreuses particularités du comportement des modèles.
GPT-2, GPT-3, GPT-4o, Llama 4, Mistral Large 3
Fusionne itérativement la paire d'octets ou de caractères adjacents la plus fréquente. Part des octets individuels, ce qui lui permet de traiter tout texte Unicode sans token inconnu.
BERT, DistilBERT, ALBERT
Similaire à BPE, mais les fusions sont choisies pour maximiser la vraisemblance des données d'entraînement sous un modèle de langage, plutôt que la fréquence brute.
T5, Gemma, Qwen
Traite la tokenization comme un problème de segmentation probabiliste. Indépendant de la langue — fonctionne à partir de texte brut sans pré-tokenization (les espaces sont traités comme des caractères ordinaires).
| Mot | Tokens GPT-4o | Nombre de tokens |
|---|---|---|
| transformer | transformer | 2 |
| tokenization | tokenization | 2 |
| def calculate_loss(logits): | def calculate_loss(logits): | 6 |
| Üniversität | Üniversität | 4 |
| hello | hello | 1 |
| (3 spaces) | 1 |
| Modèle | Tokenizer | Taille du vocab | Remarque |
|---|---|---|---|
| GPT-2 | BPE | 50,257 | BPE au niveau octet |
| GPT-3 / GPT-3.5 | BPE (cl100k) | 100,277 | Identique à GPT-4 |
| GPT-4 / GPT-4o | BPE (o200k) | 200,019 | Meilleur multilingue |
| Llama 3.x / 4.x | BPE (tiktoken) | 128,256 | Amélioré par rapport aux 32k de Llama 2 |
| Mistral v0.x | BPE (SentencePiece) | 32,768 | Petit mais efficace |
| Gemma 2 | SentencePiece | 256,000 | Très grand vocabulaire multilingue |
import tiktoken
# GPT-4o uses the o200k_base encoding
enc = tiktoken.get_encoding("o200k_base")
text = "Tokenization is the first step in every LLM pipeline."
tokens = enc.encode(text)
print(f"Token IDs: {tokens}")
# Token IDs: [5808, 2065, 374, 279, 1176, 3094, 304, 1475, 445, 11237, 15598, 13]
print(f"Token count: {len(tokens)}") # 12
print(f"Decoded: {[enc.decode([t]) for t in tokens]}")
# ['Token', 'ization', ' is', ' the', ' first', ' step', ' in', ' every', ' L', 'LM', ' pipeline', '.']
# Cost estimation: GPT-4o input = $2.50 / 1M tokens
cost_per_token = 2.50 / 1_000_000
print(f"Cost for this sentence: ${cost_per_token * len(tokens):.8f}")Introduit dans « Attention Is All You Need » (Vaswani et al., 2017), le transformer a remplacé les réseaux récurrents par une architecture entièrement fondée sur l'attention. Tout grand LLM actuel repose sur cette fondation.
graph TD A[Input Tokens] --> B[Token Embeddings] B --> C[+ Positional Encoding] C --> D[Multi-Head Self-Attention] D --> E[Add and Layer Norm] E --> F[Feed-Forward Network] F --> G[Add and Layer Norm] G --> H[Next Block or Output]
L'intuition centrale du transformer : chaque token peut prêter attention simultanément à tous les autres tokens de la séquence. À partir d'une matrice d'entrée X, trois projections apprises produisent les requêtes (Q), les clés (K) et les valeurs (V) :
L'attention multi-têtes exécute H opérations d'attention indépendantes en parallèle, chacune avec des projections apprises différentes. Cela permet au modèle de prêter attention conjointement à des informations issues de sous-espaces de représentation différents. GPT-3 utilise 96 têtes d'attention ; Llama 4 Maverick utilise l'attention par requêtes groupées (GQA) pour un service efficace.
import torch
import torch.nn.functional as F
def scaled_dot_product_attention(Q, K, V, mask=None):
"""
Q, K, V: (batch, heads, seq_len, head_dim)
Returns: (batch, heads, seq_len, head_dim)
"""
d_k = Q.size(-1)
# Compute attention scores
scores = torch.matmul(Q, K.transpose(-2, -1)) / (d_k ** 0.5) # (batch, heads, seq, seq)
# Apply causal mask (decoder: attend only to past tokens)
if mask is not None:
scores = scores.masked_fill(mask == 0, float('-inf'))
# Softmax over key dimension
attn_weights = F.softmax(scores, dim=-1)
# Weighted sum of values
return torch.matmul(attn_weights, V), attn_weightsChaque bloc transformer contient un MLP à 2 couches appliqué indépendamment à chaque position de token. La dimension cachée vaut typiquement 4× la dimension du modèle (p. ex. d_model=4096, d_ff=16384 pour un modèle typique de classe 8B). Les LLM modernes utilisent l'activation SwiGLU (une variante à portes de SiLU) qui surpasse empiriquement ReLU et GELU.
Les couches FFN stockent l'essentiel des connaissances factuelles d'un modèle — la recherche montre que des « neurones de connaissance » concentrés dans le FFN peuvent être localisés et édités chirurgicalement (voir ROME/MEMIT). L'attention gère le routage et la composition ; les couches FFN gèrent le stockage.
Chaque sous-couche (attention, FFN) utilise une connexion résiduelle (output = x + sublayer(x)) et une normalisation de couche. Les LLM modernes utilisent le Pre-Norm (normaliser avant la sous-couche) plutôt que le Post-Norm pour la stabilité de l'entraînement, et RMSNorm (Root Mean Square norm, sans centrage de la moyenne) pour l'efficacité.
| Type | Exemples | Attention | Idéal pour |
|---|---|---|---|
| Encoder-only | BERT, RoBERTa, DeBERTa | Bidirectionnelle (attention complète) | Classification, NER, embeddings |
| Decoder-only | GPT-4o, Llama 4, Mistral Large 3, Claude Sonnet 4.6 | Causale (de gauche à droite) | Génération de texte, chat, raisonnement |
| Encoder-Decoder | T5, FLAN-T5, BART | Encodeur complet + attention croisée | Traduction, résumé, seq2seq |
Le pré-entraînement est la phase la plus coûteuse — typiquement plus de 95 % du calcul total. Le modèle voit des milliers de milliards de tokens et apprend à prédire le suivant. Cet objectif simple, à une échelle suffisante, produit la plupart des capacités que l'on associe aux LLM.
Étant donné une séquence de tokens [t₁, t₂, ..., tₙ], le modèle est entraîné à maximiser la log-vraisemblance de chaque token conditionnellement à tous les tokens précédents :
Chaque passe avant traite une séquence complète et produit une perte à chaque position en parallèle (teacher forcing). Lors de l'inférence, les tokens sont générés de manière autorégressive, un à la fois.
Hoffmann et al. (2022) ont montré que les grands modèles précédents (GPT-3, Gopher) étaient sous-entraînés — trop de paramètres pour trop peu de tokens. Le ratio optimal de Chinchilla est :
Tokens optimaux ≈ 20× paramètres
Un modèle de 7B paramètres devrait s'entraîner sur ~140B tokens pour un entraînement optimal en calcul. En pratique, les modèles s'entraînent sur bien plus (Llama 3.1 8B : 15T tokens ; modèles Llama 4 : ~40T est.) car le coût d'inférence compte — un modèle plus petit mais davantage entraîné coûte moins cher à servir.
| Modèle | Paramètres | Tokens d'entraînement | Année |
|---|---|---|---|
| GPT-2 | 117M – 1.5B | ~10B | 2019 |
| GPT-3 | 175B | ~300B | 2020 |
| Chinchilla | 70B | 1.4T | 2022 |
| Llama 2 (historical) | 7B – 70B | 2T | 2023 |
| Mistral 7B | 7.3B | ~8T (est.) | 2023 |
| Llama 3.1 8B | 8B | 15T | 2024 |
| Llama 3.1 405B | 405B | 15T | 2024 |
| Llama 4 Scout | ~17B active (MoE) | ~40T (est.) | 2025 |
| Llama 4 Maverick | ~17B active (MoE) | ~40T (est.) | 2025 |
Crawl web à l'échelle du pétaoctet, brut et filtré. Constitue l'essentiel de la plupart des corpus de pré-entraînement. Nécessite un filtrage qualité poussé (déduplication, détection de langue, suppression de la toxicité).
Jeu de données curé de 825 Go couvrant 22 sources dont GitHub, ArXiv, PubMed, FreeLaw, DM Mathematics. Ouvert et reproductible.
Reproductions ouvertes des données d'entraînement de LLaMA. DCLM (DataComp-LM, 2024) se concentre sur des ablations rigoureuses de qualité des données pour trouver les pipelines de filtrage optimaux.
Books3, Gutenberg, ArXiv, S2ORC. Rapport signal/bruit élevé ; essentiel pour le raisonnement de longue haleine et la profondeur factuelle.
Chaque GPU détient une réplique du modèle ; les lots sont répartis entre les GPU. Les gradients sont moyennés (AllReduce) après chaque passe arrière. Standard pour toutes les tailles.
Les matrices de poids individuelles sont réparties entre les GPU. Nécessite une interconnexion à haut débit (NVLink). Utilisé pour les modèles qui dépassent la VRAM d'un seul GPU.
Différentes couches affectées à différents GPU. Les micro-lots circulent dans le pipeline. Efficace pour les modèles très profonds ; nécessite un ordonnancement soigneux pour minimiser les bulles.
Un modèle de base pré-entraîné est un prédicteur du token suivant puissant mais imprévisible — il poursuivra n'importe quel texte, y compris des contenus nuisibles. L'entraînement d'alignement le transforme en un assistant utile, inoffensif et honnête.
Le modèle de base est affiné sur un jeu de données de paires (instruction, réponse idéale), rédigées ou curées par des annotateurs humains. Cela enseigne au modèle le format de suivi d'instructions. L'objectif d'entraînement est identique au pré-entraînement (entropie croisée), mais le jeu de données est petit (des dizaines de milliers d'exemples) et de haute qualité. Après le SFT, le modèle peut suivre des instructions mais peut encore être mensonger ou nuisible.
graph LR A[Pretrained LLM] --> B[SFT on Instruction Data] B --> C[SFT Model] C --> D[Generate Completions] D --> E[Human Preference Labels] E --> F[Train Reward Model] F --> G[RLHF with PPO] G --> H[Aligned LLM]
Modèle de récompense : Des annotateurs humains comparent des paires de réponses du modèle et étiquettent leur préférence. Un modèle distinct est entraîné à prédire la réponse préférée des humains pour un prompt donné. Ce signal de récompense scalaire capture des jugements de qualité nuancés, difficiles à spécifier sous forme de fonction de perte.
PPO (Proximal Policy Optimisation) : Le modèle SFT (la « politique ») est optimisé pour maximiser le score du modèle de récompense, tandis qu'une pénalité de divergence KL l'empêche de s'éloigner trop de la base SFT (ce qui provoquerait du reward hacking). PPO est coûteux en calcul : il requiert quatre modèles en mémoire simultanément.
Rafailov et al. (2023) ont montré que l'objectif RLHF peut être optimisé directement sur le modèle de politique sans modèle de récompense distinct ni boucle de RL. Étant donné des paires de réponses préférées et rejetées, DPO reparamètre la récompense comme une fonction des log-probabilités du modèle de politique et du modèle de référence :
DPO est plus simple, plus stable et moins coûteux que le RLHF avec PPO. La plupart des modèles open source alignés (Llama 4 Instruct, Mistral Instruct) utilisent DPO ou une variante (SimPO, IPO) pour l'étape d'alignement des préférences.
| Méthode | Modèle de récompense | Boucle RL | Stabilité | Utilisé par |
|---|---|---|---|---|
| RLHF (PPO) | Oui | Oui (PPO) | Modérée | InstructGPT, early ChatGPT |
| DPO | Non | Non | Élevée | Llama 4, Mistral, Zephyr |
| Constitutional AI (CAI) | Auto-critique | Oui (RLAIF) | Élevée | Claude (Anthropic) |
| GRPO / DAPO | À base de règles | Relative au groupe | Élevée | DeepSeek-R1, Qwen |
À chaque étape de génération, le modèle produit un vecteur de logits de taille |vocabulary|. La stratégie d'échantillonnage détermine comment un token unique est choisi dans cette distribution — et a un impact énorme sur la qualité, la diversité et la cohérence des sorties.
| Température | Effet | Cas d'usage |
|---|---|---|
| 0.0 (Greedy) | Toujours choisir le token de plus haute probabilité. Déterministe. | Classification, extraction structurée, Q&R factuelles |
| 0.2 – 0.4 | Distribution plus marquée, suit surtout le chemin le plus probable mais autorise de petites variations. | Génération de code, résumé |
| 0.6 – 0.8 | Équilibrée. Bon compromis entre cohérence et diversité. | Chat général, suivi d'instructions (défaut pour la plupart des modèles) |
| 1.0 | Échantillonne directement depuis la distribution du modèle. Plus varié. | Écriture créative, brainstorming |
| > 1.0 | Aplatit la distribution. Augmente l'aléa et la répétition. Produit souvent une sortie incohérente. | Rarement utile en production |
Trier les tokens par probabilité, prendre le plus petit ensemble dont la probabilité cumulée ≥ p, puis échantillonner dans cet ensemble. À p=0,9, le modèle ne considère que les tokens représentant ensemble 90 % de la masse de probabilité. Adapte dynamiquement la taille de l'ensemble candidat : sûr, le noyau est petit ; incertain, il est plus large.
Tronquer la distribution aux k tokens les plus probables, puis échantillonner parmi eux. Plus simple que le top-p mais utilise un k fixe quelle que soit la forme de la distribution. Le top-p est généralement préféré ; le top-k est utile lorsqu'un contrôle strict de la taille de l'ensemble candidat est nécessaire.
from openai import OpenAI
client = OpenAI()
# Factual / structured output: low temperature, no top-p
factual = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "What is the capital of France?"}],
temperature=0.0,
max_tokens=50,
)
# Creative writing: higher temperature + nucleus sampling
creative = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Write a haiku about neural networks."}],
temperature=0.9,
top_p=0.95,
max_tokens=100,
)
# Code generation: low temp, deterministic
code = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Write a Python quicksort function."}],
temperature=0.2,
max_tokens=300,
)Un transformer n'a aucune notion intrinsèque de l'ordre des tokens — l'attention est invariante par permutation. L'encodage positionnel injecte l'information d'ordre. Le choix de la méthode d'encodage détermine la capacité du modèle à généraliser à des séquences plus longues que sa longueur d'entraînement.
Un vecteur appris ou fixe (sinusoïdal) est ajouté à chaque embedding de token à la position i. GPT-2 et BERT utilisent des embeddings absolus appris. Limite stricte : le modèle ne peut pas généraliser à des positions jamais vues à l'entraînement.
Encode la position en faisant tourner les vecteurs Q et K dans l'espace complexe d'un angle proportionnel à la position. Le score d'attention dépend naturellement de la distance relative entre tokens. Utilisé par Llama 4, Mistral Large 3, Qwen et la plupart des modèles open-weight modernes. Permet des techniques d'extension de contexte comme YaRN et LongRoPE.
Durant la génération autorégressive, le modèle recalcule l'attention pour chaque token à chaque étape — naïvement O(n²) par étape. Le KV-cache stocke les tenseurs de clés et de valeurs de tous les tokens précédents. À chaque nouvelle étape, seuls les Q, K, V du nouveau token sont calculés et les K, V en cache sont ajoutés. Cela réduit la génération de O(n²) à O(n) par nouveau token.
| Modèle | Fenêtre de contexte | Encodage positionnel | Longueur effective* |
|---|---|---|---|
| GPT-4o | 128K | Apprise + RoPE (est.) | 128K |
| Claude Sonnet 4.6 | 200K | Non divulgué | ~150K (pratique) |
| Gemini 2.5 Pro | 1M | Non divulgué | ~500K (pratique) |
| Llama 4 Maverick | 1M | RoPE | 1M |
| Mistral Large 3 | 128K | Sliding Window + RoPE | 128K |
| DeepSeek-R1 | 128K | RoPE | 128K |
*Longueur effective : la fenêtre sur laquelle le modèle récupère l'information de manière fiable. Les travaux « Lost in the middle » montrent que les performances se dégradent pour les contenus placés au milieu de contextes très longs.
Le RAG répond à deux limites fondamentales des LLM : leur date de coupure des connaissances et leur tendance à halluciner. Plutôt que de s'appuyer sur ce que le modèle a mémorisé à l'entraînement, le RAG récupère des documents pertinents au moment de l'inférence et les injecte dans le prompt.
graph LR A[User Query] --> B[Embed Query] B --> C[Vector Search] C --> D[Top-k Chunks] D --> E[Inject into Prompt] A --> E E --> F[LLM Generation] F --> G[Grounded Answer]
Embedder la requête → recherche de similarité top-k → ajouter les fragments au prompt → générer. Simple mais sujet à des récupérations non pertinentes et à la surcharge de contexte.
Ajoute la réécriture de requête, le re-ranking (cross-encoders), les embeddings de documents hypothétiques (HyDE), la récupération récursive et la compression de contexte.
Pipeline découplé : routage, transformation de requête, récupération, scoring, filtrage et fusion peuvent chacun être remplacés indépendamment. Flexibilité maximale.
Découper tous les N tokens avec un chevauchement de M tokens. Rapide mais peut couper en milieu de phrase. Bonne base de référence.
Découper aux frontières de phrase ou de paragraphe. Préserve les unités sémantiques mais les fragments varient en taille.
Regrouper les phrases à forte similarité d'embedding en fragments cohérents. Meilleure qualité de récupération ; coût de calcul le plus élevé au moment de l'indexation.
Indexer à plusieurs granularités (document → section → paragraphe). Récupérer au niveau correspondant à la spécificité de la requête.
| Base de données | Déploiement | Échelle | Idéal pour |
|---|---|---|---|
| pgvector | Auto-hébergé (ext. Postgres) | Millions | Utilisateurs Postgres existants ; stack plus simple |
| Qdrant | Auto-hébergé / Cloud | Milliards | Hautes performances, filtrage riche, open source |
| Weaviate | Auto-hébergé / Cloud | Milliards | Multimodal, hybride sémantique + mots-clés |
| Pinecone | Cloud entièrement géré | Milliards | SaaS géré, exploitation minimale |
| Chroma | Local / auto-hébergé | Millions | Prototypage, développement local |
L'écart entre les modèles open-weight et les modèles de pointe propriétaires s'est considérablement réduit. Llama 4 Maverick égale GPT-4o sur de nombreux benchmarks ; DeepSeek-R1 surpasse o1 en mathématiques et en code pour une fraction du coût d'entraînement. Le choix porte de plus en plus sur le modèle de déploiement, la confidentialité des données et le coût total de possession.
| Modèle | Paramètres | Contexte | Licence | MMLU | Meilleur cas d'usage |
|---|---|---|---|---|---|
| Open Weight | |||||
| Llama 4 Scout | ~17B active (MoE) | 1M | Llama 4 Community License | 79.6 | Rapide, long contexte, sur l'appareil |
| Llama 4 Maverick | ~17B active (MoE) | 1M | Llama 4 Community License | 85.5 | Capacité/coût équilibrés, long contexte |
| Llama 4 Behemoth | ~288B active (MoE) | 128K | Llama 4 Community License | ~92 (est.) | Tâches open-weight de pointe |
| Mistral Large 3 | ~123B | 128K | Mistral Research License | 84.0 | Entreprise multilingue |
| Qwen2.5 72B | 72B | 128K | Apache 2.0 | 86.0 | Code, maths, multilingue |
| DeepSeek-R1 | 671B MoE | 128K | MIT | 90.8 | Raisonnement, maths, sciences |
| Gemma 2 27B | 27B | 8K | Gemma License | 75.2 | Recherche, réglage fin |
| Phi-4 | 14B | 16K | MIT | 84.8 | |
| Propriétaire | |||||
| GPT-4o | ~200B est. | 128K | Proprietary | 88.7 | Pointe généraliste, multimodal |
| Claude Sonnet 4.6 | Undisclosed | 200K | Proprietary | 88.7 | Long contexte, code, sûreté |
| Gemini 2.5 Pro | Undisclosed | 1M | Proprietary | 85.9 | Très long contexte, multimodal, raisonnement |
| o3 / o1 | Undisclosed | 200K | Proprietary | ~91+ | Raisonnement complexe, recherche de pointe |
Servir des LLM à grande échelle exige de résoudre la mémoire (la VRAM est rare), le débit (de nombreux utilisateurs simultanés) et la latence (les utilisateurs veulent des premiers tokens rapides). L'écosystème a développé des solutions puissantes pour chaque défi.
Réduire la précision numérique des poids du modèle réduit la VRAM et accélère le calcul. Les techniques modernes (GPTQ, AWQ, GGUF) appliquent la quantisation de façon non uniforme, en protégeant les poids les plus sensibles.
| Format | Bits/poids | Taille relative | Rétention de qualité | Outillage |
|---|---|---|---|---|
| FP32 | 32 | 100% | 100 % (référence) | PyTorch default |
| FP16 / BF16 | 16 | 50% | ~100 % | Standard training/inference |
| INT8 | 8 | 25% | ~99 % | bitsandbytes, TensorRT-LLM |
| INT4 (GPTQ/AWQ) | 4 | 12.5% | ~95–98 % | AutoGPTQ, AutoAWQ, llama.cpp |
| GGUF Q4_K_M | ~4.5 | ~14% | ~96 % | llama.cpp, Ollama |
| GGUF Q2_K | ~2.6 | ~8% | ~88 % | llama.cpp (CPU focus) |
PagedAttention pour une gestion efficace du KV-cache, batching continu, parallélisme de tenseurs. La référence pour le service GPU à haut débit. API compatible OpenAI.
Le serveur de production de Hugging Face. Flash Attention 2, batching continu, décodage spéculatif. Propulse l'Inference API.
Service local d'une simplicité déconcertante via des modèles GGUF. Une commande pour télécharger et exécuter n'importe quel modèle. Non conçu pour une forte concurrence mais excellent pour le développement.
Inférence en C++ pur avec quantisation GGUF. Fonctionne sur les CPU MacBook série M et les GPU grand public. Propulse Ollama en coulisses.
Le PagedAttention de vLLM (Kwon et al., 2023) gère la mémoire du KV-cache comme la mémoire virtuelle d'un OS — en la divisant en pages de taille fixe allouées de façon non contiguë. Cela élimine la fragmentation et la réservation gaspillée, permettant un débit 2–24× supérieur à HuggingFace Transformers à mémoire GPU égale.
Le batching continu permet à de nouvelles requêtes de rejoindre un lot en cours dès qu'une séquence se termine, plutôt que d'attendre la fin du lot entier. Cela améliore considérablement l'utilisation du GPU sous des charges de longueur variable.
# Start a vLLM server for Llama 4 Scout Instruct
# Requires: pip install vllm, CUDA GPU with ≥16GB VRAM
python -m vllm.entrypoints.openai.api_server \
--model meta-llama/Llama-4-Scout-17B-16E-Instruct \
--tensor-parallel-size 1 \
--max-model-len 32768 \
--dtype bfloat16 \
--port 8000
# The server exposes an OpenAI-compatible API:
curl http://localhost:8000/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "meta-llama/Llama-4-Scout-17B-16E-Instruct",
"messages": [{"role": "user", "content": "Explain attention mechanisms."}],
"temperature": 0.7,
"max_tokens": 512
}'L'évaluation est l'un des problèmes ouverts les plus difficiles de la recherche sur les LLM. Les benchmarks standard mesurent des capacités spécifiques mais corrèlent imparfaitement avec l'utilité dans le monde réel. Une stratégie d'évaluation complète combine benchmarks automatisés, évaluation humaine et LLM-as-judge.
| Benchmark | Mesure | Format | Limite |
|---|---|---|---|
| MMLU | Connaissances larges (57 matières) | QCM à 4 choix | Format QCM ; risque de contamination |
| HumanEval | Génération de code Python | Complétion de fonction + tests unitaires | Python uniquement ; distribution de tâches étroite |
| GSM8K | Problèmes mathématiques de niveau primaire | Arithmétique en forme libre | Saturé par les modèles de pointe (>95 %) |
| HellaSwag | NLI de sens commun | Complétion de phrase à 4 choix | Saturé ; adversarial mais daté |
| MT-Bench | Suivi d'instructions (multi-tours) | LLM-as-judge (GPT-4) | Le juge GPT-4 a ses propres biais |
| GPQA Diamond | Sciences de niveau doctoral | QCM à 4 choix par des experts du domaine | Petit jeu de données ; difficile à passer à l'échelle |
| MATH-500 | Mathématiques de compétition | Correspondance exacte de la réponse | Sensible au format ; les solutions peuvent être mémorisées |
| Modèle | MMLU | HumanEval | GSM8K | MATH |
|---|---|---|---|---|
| GPT-4o | 88.7 | 90.2 | 96.0 | 76.6 |
| Claude Sonnet 4.6 | 88.7 | 92.0 | 96.0 | 78.3 |
| Gemini 2.5 Pro | 85.9 | 84.1 | 91.7 | 67.7 |
| DeepSeek-R1 | 90.8 | 92.3 | 97.3 | 97.3 |
| Llama 4 Maverick | 85.5 | 85.4 | 95.0 | 72.0 |
| Llama 4 Scout | 79.6 | 77.0 | 89.0 | 58.0 |
| Mistral Large 3 | 84.0 | 92.0 | 93.0 | 69.0 |
| Llama 3.1 8B (2024) | 73.0 | 72.6 | 84.5 | 51.9 |
Pour les tâches ouvertes sans réponses de référence, un LLM puissant peut noter les réponses à l'aide d'une grille structurée. MT-Bench et Chatbot Arena utilisent cette approche. Le risque principal est le biais de position (le juge préfère les réponses qui apparaissent en premier) et le biais de verbosité (les réponses plus longues obtiennent de meilleures notes quelle que soit leur qualité).
from openai import OpenAI
client = OpenAI()
def llm_judge(question: str, answer: str, rubric: str) -> dict:
prompt = f"""You are an expert evaluator. Score the following answer on a 1-10 scale.
Question: {question}
Answer: {answer}
Rubric: {rubric}
Respond with JSON: {{"score": <int>, "reasoning": "<str>", "strengths": ["..."], "weaknesses": ["..."]}}"""
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": prompt}],
response_format={"type": "json_object"},
temperature=0.0,
)
import json
return json.loads(response.choices[0].message.content)
result = llm_judge(
question="Explain the attention mechanism in transformers.",
answer="Attention computes a weighted sum of values...",
rubric="Accuracy (4pt), Clarity (3pt), Completeness (3pt)",
)
print(f"Score: {result['score']}/10 — {result['reasoning']}")Comprendre le fonctionnement des LLM est la base — mais choisir le bon modèle, la bonne architecture de déploiement et la bonne stratégie d'évaluation pour votre cas d'usage précis exige une expérience concrète. Notre équipe a construit des systèmes LLM en production couvrant RAG, agents, réglage fin et déploiement en entreprise. Réservez une consultation pour discuter de votre projet.