LLM, modèles et harnais : le vocabulaire de l'IA

Le monde de l'IA regorge de jargon, et une bonne partie de la confusion vient de termes utilisés à tort comme synonymes : « modèle », « LLM », « IA », « réseau de neurones ». Pour comparer intelligemment les prix et choisir ce qu'on fait tourner, il faut d'abord comprendre précisément de quoi on parle. Voici les termes essentiels, du plus fondamental au plus technique.

Qu'est-ce qu'un modèle ?

Un modèle est un réseau de neurones entraîné : concrètement, un gros fichier de poids (souvent plusieurs Go) qui, à partir d'une entrée, prédit la sortie la plus probable. Pour un modèle de langage, l'entrée est du texte et la sortie est le token suivant le plus probable. On l'appelle aussi « poids » (weights), « checkpoint », ou parfois « paramètres ».

Le modèle est le résultat d'un entraînement : on a montré au réseau des milliards d'exemples, et il a ajusté ses poids pour minimiser ses erreurs de prédiction. Une fois entraîné, le modèle est figé : il ne « réapprend » pas pendant l'inférence (sauf cas particuliers comme les modèles adaptatifs). C'est important : un modèle n'a pas de mémoire entre deux conversations — chaque appel est indépendant, sauf ce que vous renvoyez dans le prompt.

Le LLM (Large Language Model)

Un LLM est un modèle de langage de grande taille, entraîné sur des milliards (parfois des trillions) de tokens de texte. GPT-4, Claude, Gemini, Llama, Mistral, Qwen, DeepSeek sont des LLM. Le « L » pour Large fait référence au nombre de paramètres (souvent des milliards) et au volume de données d'entraînement.

La taille se mesure en paramètres : un « 7B » a 7 milliards de paramètres, un « 70B » en a 70 milliards, un « 405B » en a 405 milliards. Plus il y en a, plus le modèle est capable en théorie, mais plus il demande de mémoire pour tourner. C'est la raison pour laquelle on parle tant de VRAM dans le guide sur le matériel.

Modèle de fondation vs fine-tune

Un modèle de fondation (base model) est entraîné de zéro sur un corpus général (web, livres, code). Il « sait » prédire du texte, mais il n'est pas aligné pour répondre à des instructions : si on lui dit « Écris-moi un poème », il peut répondre « Écris-moi une chanson » (il continue juste le texte). Pour le rendre utile, on le ré-entraîne sur des données ciblées : c'est le fine-tuning.

• Modèle de fondation (base) : Llama-3-8B, Mistral-7B-v0.3. Bruts, prédictifs, pas alignés.
• Instruct / chat : ré-entraîné pour suivre des instructions et tenir une conversation. Ex : Llama-3-8B-Instruct, Mistral-Instruct. C'est ce que vous voulez 95 % du temps.
• Fine-tune spécialisé : ré-entraîné sur un domaine (code, médical, juridique, mathématiques). Ex : DeepSeek-Coder, CodeLlama.
• RLHF / DPO : le modèle instruct est ensuite « aligné » par apprentissage par renforcement à partir de retours humains (RLHF) ou d'optimisation de préférence directe (DPO) pour qu'il soit utile, honnête et inoffensif.

En pratique, sur un agrégateur ou en local, vous choisissez presque toujours la version « Instruct » ou « Chat » — sauf si vous voulez fine-tuner vous-même à partir de la base.

Paramètres et quantization

Le nombre de paramètres donne une idée de la capacité, mais la taille en mémoire dépend aussi de la précision (le nombre de bits par poids). Un modèle en FP16 (16-bit) pèse 2 octets par paramètre ; en 4-bit, 0,5 octet. La quantization réduit la précision pour diminuer la taille et accélérer l'inférence, au prix d'une légère perte de qualité.

Le format GGUF popularisé par llama.cpp permet de stocker un modèle quantizé dans un seul fichier, avec différentes précisions (Q4_K_M, Q5_K_M, Q8_0…). Pour un usage local, Q4_K_M est le meilleur compromis : qualité quasi identique au FP16 pour la moitié de la taille du Q8.

Token, contexte et fenêtre

Un token est l'unité de base qu'un LLM manipule — pas un mot, mais un morceau de mot (environ 0,75 mot en anglais, ~1 token pour 2-3 caractères en français). Les prix des API sont « par million de tokens », d'où l'importance du comparateur de ce site.

La fenêtre de contexte est la quantité de tokens que le modèle peut « voir » en une fois : prompt + réponse compris. Un modèle à 8k tokens traite ~6 000 mots ; un modèle à 128k tokens, ~96 000 mots (un livre). Plus la fenêtre est grande, plus le modèle peut raisonner sur de longs documents — mais plus c'est cher (en tokens) et plus ça demande de VRAM (le « KV cache » grandit avec le contexte).

Qu'est-ce qu'un « harness » (harnais) ?

Un harness d'évaluation est un cadre logiciel qui sert à tester un modèle de façon reproductible. Il charge le modèle, lui fait passer une batterie de benchmarks standardisés (MMLU, HumanEval, GSM8K, HellaSwag, TruthfulQA…), et calcule un score. Le plus connu est lm-evaluation-harness d'EleutherAI, utilisé par Hugging Face et presque tous les labos pour comparer les modèles.

Le harness ne crée pas le modèle : il le « harnache » pour le soumettre à des tests standardisés, comme un châssis de test en mécanique. Sans harness, on ne peut pas comparer deux modèles objectivement — chacun publierait ses propres métriques optimisées.

Les benchmarks courants mesurent des capacités distinctes :

• MMLU : connaissances générales (57 matières).
• HumanEval : génération de code Python.
• GSM8K : problèmes mathématiques de niveau collège.
• GPQA : questions de niveau PhD (résistance à la devinette).
• IFEval : capacité à suivre des instructions précises.

Attention aux pièges : la contamination (les benchmarks fuitent dans l'entraînement), le surapprentissage sur les benchmarks, et la différence entre score de benchmark et utilité réelle. Un modèle peut exceller sur MMLU et être frustrant en conversation. Les benchmarks sont utiles pour comparer, pas pour prédire l'expérience utilisateur.

Modality : texte, multimodal, vision

Certains modèles ne traitent que le texte (Llama, Mistral, DeepSeek), d'autres sont multimodaux : texte + image (GPT-4o, Gemini, Qwen-VL, Llama-3.2-Vision), voire texte + image + audio + vidéo. La modality indique quels types d'entrée le modèle accepte. Les modèles multimodaux sont plus gourmands (ils embarquent aussi un encodeur d'image, type ViT/CLIP) et souvent plus chers à l'API.

• Texte uniquement : Llama-3, Mistral, DeepSeek, Qwen (texte).
• Texte + image : GPT-4o, Claude 3.5, Gemini, Qwen-VL, Llama-3.2-Vision.
• Texte + audio : GPT-4o-audio, certains modèles Gemini.
• Génération d'image : un autre type de modèle (diffusion) — Stable Diffusion, FLUX, Midjourney. Pas des LLM, mais souvent comparés.

Moteurs d'inférence : llama.cpp, vLLM, Ollama, MLX

Le modèle est un fichier ; il faut un moteur d'inférence pour le charger et générer du texte. Les principaux :

• llama.cpp : le couteau suisse, en C++, optimisé CPU et GPU, format GGUF. La base de presque tout l'écosystème local.
• Ollama : un wrapper convivial autour de llama.cpp, avec un CLI simple et une API. Le plus facile pour démarrer en local.
• LM Studio : interface graphique (desktop) sur llama.cpp, pour ceux qui veulent cliquer plutôt que taper des commandes.
• vLLM : moteur serveur haute performance, optimisé pour la production (PagedAttention, batching continu). Le choix pour servir un modèle à plusieurs utilisateurs.
• MLX : framework Apple pour la mémoire unifiée des puces M. Très efficace sur Mac.
• TensorRT-LLM : moteur NVIDIA ultra-optimisé, mais complexe à déployer.

En résumé

• Modèle = les poids, le fichier figé.
• LLM = un grand modèle de langage (milliards de paramètres).
• Base vs instruct = brut vs aligné pour les instructions.
• Quantization = compresser (FP16 → 4-bit) pour moins de mémoire.
• Token / contexte = l'unité de mesure et la mémoire de travail.
• Harness = l'outil qui évalue le modèle de façon reproductible.
• Moteur = le logiciel qui fait tourner le modèle (llama.cpp, vLLM…).

Avec ce vocabulaire, le comparateur de prix de la page d'accueil devient limpide : chaque ligne est un modèle (instruct, à une certaine quantization), avec un prix par token d'entrée et de sortie. Pour savoir sur quelle machine le faire tourner, consultez le guide sur le matériel.