Comprendre les LLM open source

Avant de plonger dans les formats, la quantification ou le fine-tuning, il faut comprendre ce qu’est réellement un grand modèle de langage, comment il fonctionne et pourquoi ces notions sont indispensables pour l’exploiter en local. Ce chapitre pose les bases et se termine par un lexique complet des termes du domaine.

Qu’est-ce qu’un LLM ?

Un Large Language Model (grand modèle de langage) est un réseau de neurones artificiels entraîné sur d’immenses quantités de texte pour comprendre et générer du langage naturel. Le terme « Large » renvoie à deux aspects : le volume colossal de données d’entraînement (des centaines de milliards de mots) et le nombre de paramètres du modèle (de quelques milliards à plusieurs centaines de milliards).

Une analogie simple : imaginez un LLM comme un étudiant qui aurait lu l’intégralité d’Internet et des millions de livres, et mémorisé les patterns statistiques du langage. Il ne « comprend » pas vraiment au sens humain, mais il prédit avec une précision remarquable quel mot devrait suivre une séquence donnée.

L’objectif fondamental : prédire le prochain token

Au cœur de tout LLM se trouve une tâche apparemment simple : prédire le prochain mot (plus précisément, le prochain « token ») dans une séquence. Répétée des milliards de fois pendant l’entraînement, cette tâche permet au modèle d’apprendre implicitement la grammaire, les faits, le raisonnement et même une forme de « bon sens ».

Entrée : "Le chat est sur le"
   →  LLM  →
Sortie : "toit" (87%)
         "canapé" (8%)
         "lit" (3%)

Le modèle produit une distribution de probabilités sur l’ensemble de son vocabulaire. Les paramètres de génération (temperature, top-p, etc.) contrôlent comment cette distribution est utilisée pour sélectionner le token suivant.

L’architecture Transformer

Presque tous les LLM modernes reposent sur l’architecture Transformer, introduite par Google en 2017 dans l’article « Attention Is All You Need ». Elle a révolutionné le traitement du langage naturel grâce à un mécanisme appelé attention.

Pourquoi les Transformers ont-ils remplacé les RNN ?

Avant les Transformers, les modèles de langage utilisaient des réseaux de neurones récurrents (RNN, LSTM, GRU) qui traitaient le texte mot par mot, de façon séquentielle. Cela posait deux problèmes majeurs :

• Lenteur : impossible de paralléliser, chaque mot dépend du précédent.
• Mémoire limitée : difficulté à capturer les dépendances long terme (le modèle « oublie » le début de la phrase).

Les Transformers résolvent ces problèmes en traitant tous les tokens simultanément grâce à l’attention, permettant une parallélisation massive sur GPU et une mémoire efficace des contextes longs.

Les composants clés d’un Transformer

1. Tokenization

Avant d’entrer dans le modèle, le texte est converti en nombres. La tokenization découpe le texte en unités appelées tokens. Un token peut être :

• un mot entier : « chat » = 1 token ;
• une partie de mot : « extraordinaire » = « extra » + « ordinaire » = 2 tokens ;
• un caractère unique pour les mots rares.

Texte : "L'intelligence artificielle transforme le monde"

Tokens : ["L'", "intelligence", " artific", "ielle", " transform", "e", " le", " monde"]
IDs :    [445,  9006,          22817,       2143,    13389,         68,  514,   3462]

Les algorithmes courants sont BPE (Byte Pair Encoding), WordPiece (BERT) et SentencePiece (familles LLaMA/Qwen). Le vocabulaire typique contient 32 000 à 150 000 tokens.

Astuce pratique. Le nombre de tokens influence directement le coût et la vitesse d’inférence. Un texte de 1000 mots représente environ 1300-1500 tokens en anglais, et souvent davantage en français à cause des accents et d’une morphologie plus riche.

2. Embeddings

Chaque token est ensuite converti en un vecteur dense appelé embedding. Ce vecteur capture la « signification » du token dans un espace mathématique à haute dimension (typiquement 4096 à 8192 dimensions pour les grands modèles).

token_id → matrice d'embeddings (vocab_size × hidden_dim) → vecteur [x1, x2, ..., x4096]

Les tokens sémantiquement proches ont des embeddings proches. Exemple d’arithmétique des mots : roi - homme + femme ≈ reine. Les vecteurs parallèles montrent que la relation homme→femme est identique à roi→reine.

3. Encodage positionnel

Comme les Transformers voient tous les tokens en même temps, on ajoute un encodage positionnel à chaque embedding pour que le modèle connaisse l’ordre des mots :

embedding_final = embedding_token + encoding_position

Les modèles récents utilisent RoPE (Rotary Position Embedding), qui généralise mieux aux contextes plus longs que ceux vus à l’entraînement.

4. Le mécanisme d’attention (self-attention)

C’est le cœur du Transformer. L’attention permet à chaque token de « regarder » tous les autres et de déterminer lesquels sont pertinents pour sa compréhension. Pour chaque token, le modèle calcule :

1. Query (Q) : « De quelles informations ai-je besoin ? »
2. Key (K) : « Quelles informations puis-je fournir ? »
3. Value (V) : « Voici mon information. »

Le score d’attention se calcule par :

Attention(Q, K, V) = softmax(Q · Kᵀ / √dₖ) · V

La division par √dₖ (racine carrée de la dimension des clés) stabilise les gradients pendant l’entraînement.

5. Multi-Head Attention

Plutôt qu’une seule attention, les Transformers en utilisent plusieurs « têtes » en parallèle (typiquement 32 à 128). Chaque tête peut se spécialiser :

• une tête pour les relations grammaticales (sujet-verbe) ;
• une tête pour les coréférences (pronoms et antécédents) ;
• une tête pour les relations sémantiques.

6. Feed-Forward Networks (FFN)

Après l’attention, chaque token passe par un réseau feed-forward à deux couches. C’est là que le modèle stocke l’essentiel de ses « connaissances factuelles ». La dimension interne (souvent 4× la dimension cachée) explique pourquoi les FFN représentent environ 65 % des paramètres.

Input
  |
  v
[Layer Norm] --> [Multi-Head Attention] --> [+ Residual]
                                                |
                                                v
                        [Layer Norm] --> [FFN] --> [+ Residual]
                                                        |
                                                        v
                                                    Output

Architecture complète d’un LLM

Un LLM moderne empile plusieurs dizaines de ces couches Transformer (de l’ordre de 30 pour un modèle dense de 27B, davantage pour les plus grands). La séquence complète est :

1. Tokenization : texte → séquence de token IDs.
2. Embedding : token IDs → vecteurs denses + positions.
3. N couches Transformer : attention + FFN répétés N fois.
4. Layer Norm finale : normalisation de la sortie.
5. LM Head : projection vers le vocabulaire → probabilités.

Les paramètres d’un modèle

Quand on parle d’un modèle « 27B » ou « 35B », le « B » signifie milliards (billion). Ces paramètres sont les poids appris pendant l’entraînement, stockés dans les matrices du modèle.

Composant	Matrices	% des paramètres
Embeddings	Embedding + LM Head	~5-10 %
Attention	Q, K, V, projection de sortie	~25-30 %
Feed-Forward	Up, Gate, Down projections	~60-65 %
Normalization	Layer Norms	< 1 %

Sur Qwen3.6-35B-A3B, un modèle MoE (Mixture of Experts) à 35 milliards de paramètres dont seulement 3 milliards sont actifs par token, la majeure partie des paramètres réside dans les experts FFN, mais une fraction seulement est traversée à chaque pas de génération. C’est ce qui rend ces architectures particulièrement efficaces sur du matériel limité par la bande passante mémoire.

Taille mémoire et précision

En FP32 (32 bits), chaque paramètre occupe 4 octets : un modèle de 27B nécessite donc plus de 100 Go juste pour les poids. C’est pourquoi la quantification est essentielle.

Précision	Taille par paramètre
FP32	4 octets
FP16	2 octets
INT8	1 octet
INT4	0,5 octet

Comment un LLM génère-t-il du texte ?

La génération est un processus autorégressif : le modèle produit un token à la fois, puis réutilise sa propre sortie comme entrée pour le suivant.

Prompt : "Bonjour, comment"

Étape 1 : "Bonjour, comment"             -> prédit : " allez"
Étape 2 : "Bonjour, comment allez"       -> prédit : "-"
Étape 3 : "Bonjour, comment allez-"      -> prédit : "vous"
Étape 4 : "Bonjour, comment allez-vous"  -> prédit : " ?"
Étape 5 : "Bonjour, comment allez-vous ?"-> prédit : [EOS]

Sortie finale : "Bonjour, comment allez-vous ?"

Le processus continue jusqu’à ce que le modèle génère le token spécial de fin de séquence ([EOS]) ou atteigne une limite de tokens définie.

Coût quadratique de l’attention. À chaque nouveau token, le modèle doit recalculer l’attention sur tous les tokens précédents. Avec une séquence de longueur N, la complexité est O(N²). C’est pourquoi le cache KV est crucial pour accélérer l’inférence — voir Cache KV.

Pré-entraînement vs fine-tuning

Pré-entraînement

Phase initiale où le modèle apprend sur des quantités massives de texte (téraoctets) avec un objectif simple : prédire le prochain token. Cette phase :

• coûte des millions de dollars en calcul GPU ;
• dure plusieurs semaines à plusieurs mois ;
• nécessite des milliers de GPU haut de gamme ;
• produit un modèle « de base » qui complète du texte mais ne suit pas d’instructions.

Fine-tuning (instruction tuning)

Le modèle est ensuite fine-tuné sur des conversations/instructions pour apprendre à suivre les consignes. C’est ce qui transforme un modèle « base » en modèle « instruct » ou « chat ».

• Modèle base : complète le texte de façon statistique. Si vous écrivez « Question : quelle est la capitale de la France ? », il pourrait continuer par « Question : quelle est la capitale de l’Allemagne ? ».
• Modèle instruct : répond à l’instruction. La même question donne « Paris est la capitale de la France. »

Alignement (RLHF, DPO)

Enfin, les modèles sont souvent alignés sur les préférences humaines via RLHF (Reinforcement Learning from Human Feedback) ou DPO (Direct Preference Optimization). Cela les rend plus utiles, plus sûrs et moins susceptibles de générer du contenu problématique.

Pourquoi l’open source est-il important ?

Les modèles open source — comme la famille Qwen3.6 (Alibaba), LLaMA (Meta), Mistral ou Gemma (Google) — offrent plusieurs avantages :

• Confidentialité : exécution 100 % locale, vos données ne quittent jamais votre infrastructure.
• Coût : pas de frais d’API, usage illimité une fois le matériel acquis.
• Personnalisation : possibilité de fine-tuner pour des cas d’usage spécifiques.
• Transparence : architecture et poids accessibles, auditables.
• Innovation : la communauté peut améliorer, optimiser et étendre les modèles.

C’est cette approche que SoberCloud privilégie : lors de nos tests sur un Strix Halo (AMD Ryzen AI MAX+ 395, iGPU Radeon 8060S, 128 Gio de mémoire unifiée), nous avons mesuré Qwen3.6-35B-A3B en GGUF Q5_K_XL (~26 Go) via llama.cpp Vulkan, à environ 73 tokens/s. Sur une RTX 3090 (24 Go), nous avons mesuré Qwen3.6-27B quantifié int4 AutoRound via vLLM, avec un contexte de 81k tokens grâce à un cache KV en fp8. Côté routage, un proxy OpenAI-compatible comme LiteLLM permet d’unifier plusieurs moteurs derrière une seule API.

Lexique complet

Référence alphabétique des termes techniques du domaine des LLM.

Terme	Définition
Alignement	Ajustement d’un modèle pour qu’il réponde selon les attentes humaines (sécurité, utilité). Techniques : RLHF, DPO, ORPO.
Attention	Mécanisme permettant à chaque token de « regarder » tous les autres pour déterminer leur pertinence. Cœur de l’architecture Transformer.
Autorégressif	Mode de génération où le modèle prédit un token à la fois, en réutilisant sa propre sortie comme entrée.
Agent (IA)	Système orchestrant un LLM avec une boucle « tool call → exécution → observation » pour atteindre un objectif multi-étapes de façon autonome.
AWQ	Activation-aware Weight Quantization. Méthode de quantification qui préserve les poids les plus importants pour la qualité.
Batch Size	Nombre de séquences traitées simultanément. Un batch plus grand améliore le throughput mais consomme plus de VRAM.
BF16 (bfloat16)	Flottant 16 bits avec la même plage que FP32 mais moins de précision. Privilégié pour l’entraînement sur GPU modernes.
BPE	Byte Pair Encoding. Tokenization fusionnant itérativement les paires de caractères/tokens les plus fréquentes.
Chain-of-Thought (CoT)	Prompting demandant au modèle de raisonner étape par étape avant de donner sa réponse finale.
Chat Template	Format structuré des conversations (tokens spéciaux, rôles) attendu par le modèle. Varie selon le modèle (ChatML, Llama, etc.).
Completion	Texte généré par le modèle en réponse à un prompt. Aussi appelé « génération » ou « réponse ».
Context Length	Nombre maximum de tokens (prompt + réponse) traités en une fois. Typiquement 4K à 128K tokens.
CUDA	Plateforme de calcul parallèle de NVIDIA, pour exécuter des calculs sur GPU NVIDIA.
Dataset	Ensemble de données pour entraîner ou fine-tuner un modèle (conversations, instructions ou texte brut).
dFlash	Variante de Flash Attention 4 (2025-2026) pour l’inférence long contexte : block-sparse dynamique, FP4, kernels dédiés au decode.
Decode (phase)	Phase de génération token par token après le prefill. Limitée par la bande passante mémoire (memory-bound).
Décodage spéculatif	Un petit modèle « draft » propose K tokens, le grand modèle « target » les valide en un forward pass. Distribution préservée, speedup ×2-×3.
Dense (modèle)	Architecture où tous les paramètres sont utilisés pour chaque token. Opposé à MoE où seule une partie est active.
DPO	Direct Preference Optimization. Alignement plus simple que RLHF, entraînant directement sur des paires de préférences.
EAGLE-3	Décodage spéculatif (2025) avec petit decoder consommant les features cachées du target. Speedup ×3.5-×6.5.
Embedding	Représentation vectorielle dense d’un token dans un espace à haute dimension (ex : 4096 dimensions). Capture le « sens » du token.
EOS (End of Sequence)	Token spécial indiquant la fin de la génération. Le modèle s’arrête quand il le produit.
EXL2 / EXL3	Formats de quantification pour ExLlamaV2/V3. Bits-per-weight mixtes pour optimiser le compromis qualité/taille.
Feed-Forward Network (FFN)	Réseau dense après l’attention dans chaque couche Transformer. Stocke la majorité des « connaissances » (~65 % des paramètres).
Fine-tuning	Entraînement supplémentaire d’un modèle pré-entraîné sur des données spécifiques pour l’adapter à une tâche ou un domaine.
Flash Attention	Algorithme d’attention optimisé réduisant les accès mémoire par fusion d’opérations. Accélère l’inférence et réduit la VRAM.
FLOPS	Floating Point Operations Per Second. Mesure de la puissance de calcul brute d’un processeur ou GPU.
FP16 / FP32	Flottants 16 ou 32 bits. FP32 est plus précis mais consomme plus de mémoire.
GGUF	GPT-Generated Unified Format. Format de fichier pour modèles quantifiés, utilisé par llama.cpp. Successeur de GGML.
GPTQ	Quantification post-entraînement utilisant une calibration sur données pour minimiser la perte de qualité.
Hallucination	Génération de contenu faux ou inventé présenté comme factuel. Problème fondamental des LLM qui prédisent le « plausible » plutôt que le « vrai ».
Harness	Couche logicielle orchestrant un LLM avec des outils (Read, Bash, Edit, Web…) en bouclant « génération → exécution → observation ». Claude Code, Cursor, Aider, Codex CLI en sont.
HuggingFace	Plateforme de partage de modèles, datasets et outils ML. Hub principal des modèles open source.
Inférence	Utilisation d’un modèle entraîné pour générer des prédictions/texte. Opposé à l’entraînement, qui modifie les poids.
Instruct (modèle)	Modèle fine-tuné pour suivre des instructions. Répond aux questions au lieu de simplement compléter le texte.
INT4 / INT8	Entiers 4 ou 8 bits, utilisés pour la quantification des poids, réduisant drastiquement la taille mémoire.
KV Cache	Key-Value Cache. Mémorise les calculs d’attention des tokens précédents pour éviter de les recalculer à chaque nouveau token.
Layer	Couche du réseau de neurones. Un LLM empile typiquement 24 à 80+ couches Transformer identiques.
LLM	Large Language Model. Modèle de langage de grande taille (milliards de paramètres) entraîné sur de vastes corpus.
LoRA	Low-Rank Adaptation. Fine-tuning efficient n’entraînant qu’une fraction des paramètres via des matrices de faible rang.
MCP	Model Context Protocol (Anthropic, 2024). Protocole standardisé pour connecter des outils externes à un harness LLM. Largement adopté en 2026.
MLA	Multi-head Latent Attention. Attention de DeepSeek V2/V3 compressant K/V dans un espace latent de bas rang. Réduit le KV cache jusqu’à ×35 vs MHA.
MTP	Multi-Token Prediction. Entraînement où le modèle apprend à prédire t+1, t+2, t+3 simultanément. Sert de draft intégré pour le décodage spéculatif.
Loss	Fonction de perte. Mesure l’erreur du modèle pendant l’entraînement. Pour les LLM : cross-entropy sur la prédiction du prochain token.
Metal	API graphique et de calcul d’Apple, utilisée pour l’inférence sur Mac (Apple Silicon).
MLX	Framework de ML d’Apple optimisé pour Apple Silicon. Alternative à PyTorch sur Mac.
MoE	Mixture of Experts. Architecture où seule une partie des paramètres (experts) est activée par token : modèles plus grands à coût d’inférence réduit.
Multi-Head Attention	Attention parallélisée en plusieurs « têtes » indépendantes, chacune pouvant se spécialiser sur un type de relation.
NSA	Native Sparse Attention (DeepSeek, 2025). Attention sparse nativement entraînée, gain ×10 sur les contextes > 128K avec impact qualité < 1 %.
ORPO	Odds Ratio Preference Optimization. Alignement combinant SFT et alignement en une seule étape.
Paramètres	Poids appris du réseau. Un modèle « 27B » a 27 milliards de paramètres dans ses matrices.
Perplexité	Mesure de la qualité d’un modèle de langage. Plus basse = meilleure prédiction. PPL = 2^(cross-entropy).
Prefill (phase)	Phase initiale où le modèle traite tout le prompt. Intensive en calcul (compute-bound), bénéficie des Tensor Cores.
Prompt	Texte d’entrée fourni au modèle : instruction, contexte et parfois exemples (few-shot).
Prompt Engineering	Art de formuler les prompts pour obtenir les meilleures réponses (CoT, few-shot, etc.).
QLoRA	Quantized LoRA. Combine LoRA avec un modèle de base quantifié (4-bit), réduisant fortement la VRAM nécessaire au fine-tuning.
RadixAttention	Innovation de SGLang : KV cache en arbre radix permettant le partage automatique de tout préfixe commun. Idéal pour les workloads agentiques.
Quantification	Réduction de la précision des poids (FP16→INT4) pour diminuer la mémoire et accélérer l’inférence, avec perte de qualité minimale.
RAG	Retrieval-Augmented Generation. Combine recherche documentaire et génération pour répondre avec des sources externes.
Rank (LoRA)	Dimension des matrices LoRA. Plus élevé = capture plus d’information mais plus de mémoire. Typiquement 8 à 256.
RLHF	Reinforcement Learning from Human Feedback. Alignement via un modèle de récompense entraîné sur des préférences humaines.
ROCm	Radeon Open Compute. Stack open source d’AMD pour le calcul GPU, alternative à CUDA.
RoPE	Rotary Position Embedding. Encodage positionnel moderne, bonne généralisation aux contextes longs.
SafeTensors	Format de fichier sécurisé pour stocker les tenseurs. Évite les vulnérabilités de pickle, plus rapide à charger.
SGLang	Moteur d’inférence LMSYS (2024) optimisé pour l’agentique : RadixAttention, FSM pour la sortie structurée, support natif MTP/EAGLE.
Sampling	Méthode de sélection du prochain token dans la distribution de probabilités. Inclut temperature, top-p, top-k.
SFT	Supervised Fine-Tuning. Fine-tuning supervisé sur des paires (instruction, réponse).
Softmax	Fonction convertissant des scores bruts en probabilités (somme = 1). Utilisée dans l’attention et pour la prédiction finale.
Sliding Window Attention (SWA)	Attention limitée aux W derniers tokens. Borne le KV cache et permet des contextes très longs. Souvent alternée avec attention complète (Mistral, Gemma).
Speculative Decoding	Voir « Décodage spéculatif ».
System Prompt	Instructions initiales définissant le comportement du modèle (personnalité, contraintes, format de réponse).
Temperature	Paramètre contrôlant la « créativité ». Basse (0.1-0.3) = déterministe. Haute (0.8-1.5) = plus aléatoire et créatif.
Tensor Cores	Unités spécialisées des GPU NVIDIA pour les opérations matricielles. Accélèrent l’attention et les FFN.
Throughput	Débit de génération en tokens par seconde (t/s). Dépend du hardware et des optimisations.
Token	Unité de base du texte pour le modèle (mot, partie de mot ou caractère). ~1.3 tokens par mot en anglais.
Tokenizer	Composant convertissant le texte en tokens et inversement. Chaque modèle a le sien.
Top-K	Limite le sampling aux K tokens les plus probables. Réduit les réponses improbables.
Top-P (Nucleus)	Limite le sampling aux tokens dont la somme des probabilités atteint P. Plus adaptatif que Top-K.
Transformer	Architecture de réseau de neurones basée sur l’attention (2017). Base de tous les LLM modernes.
VRAM	Video RAM. Mémoire du GPU. Limite principale pour la taille des modèles exécutables.
vLLM	Moteur d’inférence GPU créé à UC Berkeley. Innovation : PagedAttention. Référence du serving production multi-utilisateurs en 2026.
Vulkan	API graphique et de calcul multiplateforme. Fonctionne sur tous les GPU (AMD, NVIDIA, Intel).
Weights	Poids du modèle. Valeurs numériques apprises pendant l’entraînement, stockées dans les fichiers du modèle.
Zero-shot	Capacité à effectuer une tâche sans exemples préalables dans le prompt. Opposé à few-shot.

Pour aller plus loin

• Formats de modèles — GGUF, SafeTensors, MLX et comment choisir.
• Paramètres de génération — temperature, top-p, top-k et configurations recommandées.
• Dense vs MoE sur Strix Halo — retour d’expérience sur l’infrastructure SoberCloud.