Comment fonctionne un LLM : tokens, attention, échantillonnage et limites

Quand un ingénieur me demande comment fonctionne un LLM, la réponse « il devine le mot suivant » est exacte, mais elle ne l'aide pas à décider quoi que ce soit : pourquoi la facture explose sur des textes arabes, pourquoi le modèle invente une référence, pourquoi un contexte de 128 000 tokens ne coûte pas « juste » 16 fois plus qu'un contexte de 8 000. Cet article part de la version grand public que j'avais écrite (neurone, réseau, mot le plus probable) et descend d'un cran : le mécanisme complet, avec les formules utiles et des ordres de grandeur que je calcule sous vos yeux. Je signale ce que je simplifie. Il n'y a pas besoin d'avoir travaillé sur les LLM, seulement d'être à l'aise avec des vecteurs et des matrices.

L'IA, c'est quoi au juste ?

Un programme classique suit des règles écrites par un humain : « si le montant dépasse 10 000, demander une validation ». L'apprentissage automatique inverse la démarche. On fournit des exemples et une fonction paramétrée, et une procédure d'optimisation cherche les paramètres qui reproduisent au mieux ces exemples. Pour un filtre anti-spam, on ne décrit pas ce qu'est un spam : on montre des milliers de mails étiquetés, et les paramètres s'ajustent jusqu'à ce que la fonction les distingue correctement. Comme pour un enfant qui apprend à reconnaître un chat : personne ne lui récite une définition, on le corrige, et un jour il reconnaît un chat qu'il n'a jamais vu. La comparaison a ses limites (l'enfant généralise avec très peu d'exemples, pas le modèle), mais elle donne la bonne intuition.

Les quatre mots à connaître

• Les données : les exemples montrés à la machine (textes, images, mesures).
• L'entraînement : l'optimisation qui ajuste les paramètres pour réduire une erreur mesurée sur ces exemples. Long et coûteux, mais fait une fois par version de modèle.
• Le modèle : la fonction obtenue, c'est-à-dire une architecture plus un ensemble de paramètres figés.
• L'inférence : l'utilisation du modèle entraîné, par exemple quand vous envoyez un prompt. Les paramètres ne bougent plus.

Le neurone artificiel, une toute petite brique

Un neurone artificiel est une fonction minuscule. Il reçoit des nombres, multiplie chacun par un poids (son importance), additionne le tout avec un biais, puis passe le résultat dans une fonction non linéaire :

sortie = f(w1*x1 + w2*x2 + w3*x3 + b)

Reprenons l'exemple du parapluie : les entrées sont « ciel nuageux », « la météo annonce de la pluie », « on est en novembre », et la météo pèse plus lourd que la couleur du ciel. La non-linéarité f (ReLU, GELU, sigmoïde...) n'est pas un détail : sans elle, empiler des couches reviendrait mathématiquement à une seule multiplication matricielle, et le réseau ne saurait représenter que des relations linéaires.

Les réseaux de neurones : l'union fait la force

Un neurone seul ne fait presque rien. Organisés en couches, avec des millions de connexions, ils deviennent expressifs : chaque couche transforme la représentation produite par la précédente. Sur une photo, les premières couches répondent à des contours, les suivantes à des textures et à des parties d'objets, les dernières à l'objet entier. Cette hiérarchie n'est pas programmée, elle émerge de l'entraînement (c'est une description commode, pas une loi : dans les gros modèles, les rôles des couches sont moins nets).

L'apprentissage tient en une boucle. On fait passer un exemple, on mesure l'écart entre la sortie et la bonne réponse avec une fonction de perte, on calcule par rétropropagation le gradient de cette perte par rapport à chaque poids, puis on déplace chaque poids d'un petit pas dans la direction qui réduit l'erreur :

w <- w - eta * dL/dw        (eta : taux d'apprentissage)

La table de mixage avec des millions de boutons de ma version d'origine, c'est cela : chaque bouton est tourné très légèrement après chaque lot d'exemples. Quand le réseau compte beaucoup de couches, on parle d'apprentissage profond. Il a décollé il y a une quinzaine d'années grâce à deux ressources : plus de données et des GPU capables de multiplier des matrices massivement en parallèle.

Les LLM : prédire le token suivant

Un LLM (Large Language Model) est un réseau de neurones de l'architecture Transformer, entraîné sur d'énormes quantités de texte et de code avec un seul objectif : étant donné les tokens précédents, prédire une distribution de probabilité sur le token suivant. Rien d'autre pendant le pré-entraînement.

Dans cet exemple, la distribution porte sur quatre mots. En réalité elle porte sur tout le vocabulaire du modèle (des dizaines de milliers de tokens), et ce que le modèle manipule n'est pas des mots mais des tokens. Le chemin complet, du texte à la distribution, est le suivant.

Du texte aux tokens

Un modèle ne lit pas des caractères ni des mots, mais des tokens, des fragments issus d'un découpage appris. L'algorithme le plus répandu est le BPE (byte-pair encoding) et ses variantes : on part des octets ou des caractères, puis on fusionne itérativement les paires les plus fréquentes du corpus jusqu'à atteindre une taille de vocabulaire fixée, de l'ordre de 30 000 à plus de 250 000 entrées selon les modèles. Un mot courant devient un seul token, un mot rare se découpe en plusieurs sous-mots.

Pourquoi des sous-mots ? C'est un compromis. Les caractères donnent des séquences très longues (et le coût de l'attention croît avec la longueur). Les mots entiers donnent un vocabulaire énorme et aucun moyen de traiter un mot jamais vu. Les sous-mots gardent un vocabulaire raisonnable tout en couvrant n'importe quel texte.

Deux conséquences très concrètes pour un ingénieur :

• Le coût et la latence se comptent en tokens, pas en mots. Le nombre de tokens par mot dépend du tokenizer et de la langue. Un vocabulaire appris surtout sur de l'anglais découpe plus finement les langues moins représentées dans son corpus. L'arabe, avec sa morphologie riche (racines, préfixes et suffixes agglutinés), est souvent concerné : le même contenu peut consommer sensiblement plus de tokens qu'en anglais, donc coûter plus cher et occuper davantage de la fenêtre de contexte. L'écart varie beaucoup d'un tokenizer à l'autre et il se mesure, il ne se suppose pas.
• Les nombres et le code sont découpés de façon parfois surprenante, ce qui joue sur l'arithmétique (j'y reviens dans les limites).

Mesurer est simple :

import tiktoken

enc = tiktoken.get_encoding("cl100k_base")  # un tokenizer parmi d'autres
for texte in ["The sky is blue", "Le ciel est bleu", "السماء زرقاء"]:
    print(len(texte.split()), "mots ->", len(enc.encode(texte)), "tokens")

Comparez sur vos propres textes, avec le tokenizer du modèle que vous utilisez réellement : chaque fournisseur a le sien.

Embeddings : des identifiants aux vecteurs

Un identifiant entier ne veut rien dire pour un réseau. Le premier étage du modèle est une table de correspondance, la matrice d'embeddings, de taille V x d (V tokens de vocabulaire, d dimensions), qui associe à chaque token un vecteur appris. Pendant l'entraînement, des tokens utilisés dans des contextes proches se retrouvent avec des vecteurs proches : c'est ce qui permet au modèle de généraliser de « chat » à « chaton » sans règle explicite.

Ordre de grandeur, calculé : avec V = 128 000 et d = 4 096, cette seule table pèse 128 000 x 4 096, soit environ 524 millions de paramètres, avant même la première couche.

Un détail qui compte : le mécanisme d'attention, vu ci-dessous, ne tient pas compte de l'ordre des tokens par lui-même. L'information de position est donc injectée en plus (sinusoïdes dans l'article d'origine, encodages rotatifs dans beaucoup de modèles récents).

Le Transformer et le mécanisme d'attention

L'architecture Transformer a été introduite en 2017 dans l'article Attention Is All You Need. Un modèle de type LLM est un empilement de L blocs identiques en structure. Chaque bloc contient deux sous-couches, chacune entourée d'une connexion résiduelle (on ajoute l'entrée à la sortie) et d'une normalisation :

1. une couche d'attention, où chaque token va chercher de l'information dans les autres tokens ;
2. un petit réseau « feed-forward » (MLP), appliqué indépendamment à chaque position, qui transforme chaque vecteur.

L'intuition. Dans « La banque a refusé le prêt parce qu'elle était trop risquée », que désigne « elle » ? Pour représenter ce mot correctement, le modèle doit aller consulter d'autres positions de la phrase. L'attention est une recherche pondérée dans la séquence : chaque token formule une requête, compare cette requête à une clé propre à chaque autre token, puis récupère un mélange des valeurs, d'autant plus pondéré que la clé correspond.

Le formalisme. À partir de la matrice X des vecteurs d'entrée (une ligne par token), on calcule trois projections linéaires apprises : Q = X·W_Q (requêtes), K = X·W_K (clés), V = X·W_V (valeurs). Puis :

Attention(Q, K, V) = softmax( Q·K^T / sqrt(d_k) ) · V

Lisons-la pour ce qu'elle est. Q·K^T est une matrice n x n de produits scalaires : le score de chaque paire (token i, token j), pour n tokens. On divise par sqrt(d_k) (d_k : dimension des clés) parce que la variance d'un produit scalaire croît avec la dimension : sans cette mise à l'échelle, les scores deviennent grands et le softmax sature, avec des gradients quasi nuls. Le softmax appliqué ligne par ligne transforme chaque ligne en poids positifs de somme 1. Enfin, la multiplication par V produit, pour chaque token, une moyenne pondérée des valeurs. Ce n'est rien de plus qu'une moyenne pondérée dont les poids sont calculés à partir du contenu.

Deux précisions importantes :

• Dans un modèle générateur, on applique un masque causal : le token i n'a le droit de regarder que les positions j <= i, sinon il « verrait le futur » pendant l'entraînement.
• On ne fait pas une attention, mais plusieurs en parallèle (multi-head), chacune avec ses propres projections, dans des sous-espaces différents. Leurs sorties sont concaténées puis reprojetées.

Une estimation utile : un bloc contient environ 12·d² paramètres (environ 4·d² pour l'attention, 8·d² pour le MLP). Pour une configuration publiée comme celle de GPT-3 (d = 12 288, 96 couches), 12 x 12 288² x 96 donne environ 174 milliards, très proche des 175 milliards annoncés. Les matrices d'embeddings et les détails d'architecture expliquent le reste de l'écart : c'est une estimation, pas un décompte.

Logits, softmax, et choix du token

À la sortie de la dernière couche, le vecteur du dernier token est projeté sur le vocabulaire entier : on obtient un score réel par token, les logits. Ils ne sont pas des probabilités (ils peuvent être négatifs et ne somment pas à 1). Le softmax les convertit :

p_i = exp(z_i) / somme_j exp(z_j)

Prenons des logits illustratifs pour « Le ciel est » : bleu 3,0 ; gris 1,9 ; nuageux 1,3 ; magnifique 0,7. Les exponentielles valent 20,1 ; 6,7 ; 3,7 ; 2,0, pour une somme de 32,5. D'où les probabilités 61,9 % ; 20,6 % ; 11,3 % ; 6,2 %, soit l'histogramme du début. Le softmax est monotone : le token au logit le plus élevé est toujours le plus probable, mais l'écart de probabilité dépend de l'écart de logits, de façon exponentielle.

La génération est une boucle autorégressive

Le modèle ne produit qu'un token par passage. Pour écrire une réponse, on répète : calculer la distribution, choisir un token, l'ajouter à l'entrée, recommencer, jusqu'à un token de fin de séquence ou une limite de longueur.

Deux conséquences d'ingénierie. D'abord, le temps de réponse est à peu près proportionnel au nombre de tokens générés : c'est pour cela que les réponses longues sont lentes et que les API facturent séparément entrée et sortie. Ensuite, recalculer à chaque tour les clés et valeurs de tous les tokens précédents serait un gaspillage, d'où le cache KV : on conserve K et V des tokens déjà traités et on ne calcule que ceux du nouveau token. Ce cache a un coût mémoire : pour une configuration illustrative (32 couches, 8 têtes de clés/valeurs de dimension 128, nombres en 16 bits, 8 192 tokens), on obtient 2 x 32 x 8 192 x 8 x 128 x 2 octets, soit 1 Gio par séquence en cours. Multipliez par le nombre de requêtes simultanées : la mémoire des GPU se dispute entre les poids du modèle et ces caches.

Échantillonnage : température, top-k, top-p

Reste à choisir le token à partir de la distribution. Le choix du plus probable à chaque tour (décodage glouton) est déterministe mais peut donner des textes répétitifs et plats ; tirer au sort selon les probabilités donne des textes plus variés. Trois réglages courants :

• La température T divise les logits avant le softmax. T < 1 accentue les écarts (distribution plus pointue), T > 1 les écrase (plus de diversité, plus de risque), T tendant vers 0 revient au décodage glouton.
• Top-k ne garde que les k tokens les plus probables avant de renormaliser.
• Top-p (nucleus sampling) garde le plus petit ensemble de tokens dont la probabilité cumulée atteint p. Il s'adapte à la forme de la distribution : peu de candidats quand le modèle est sûr, davantage quand il hésite.

import math, random

def sample(logits, T=1.0, top_k=None, top_p=None):
    """logits : dict token -> score. Version simplifiée, sans optimisation."""
    scaled = {t: z / T for t, z in logits.items()}
    m = max(scaled.values())                      # stabilité numérique
    exp = {t: math.exp(z - m) for t, z in scaled.items()}
    total = sum(exp.values())
    probs = sorted(((t, e / total) for t, e in exp.items()),
                   key=lambda x: -x[1])
    if top_k:
        probs = probs[:top_k]
    if top_p:
        kept, cum = [], 0.0
        for t, p in probs:
            kept.append((t, p))
            cum += p
            if cum >= top_p:
                break
        probs = kept
    z = sum(p for _, p in probs)                  # renormalisation
    r, acc = random.random() * z, 0.0
    for t, p in probs:
        acc += p
        if r <= acc:
            return t
    return probs[-1][0]

logits = {"bleu": 3.0, "gris": 1.9, "nuageux": 1.3, "magnifique": 0.7}
print(sample(logits, T=0.5, top_p=0.9))

Avec les logits ci-dessus, voici ce que devient la probabilité de « bleu » selon T (calcul direct du softmax) :

Une température basse ne rend pas le modèle « plus vrai », seulement plus déterministe. Et même à T = 0, certaines API ne garantissent pas des sorties strictement identiques d'un appel à l'autre (ordre des opérations flottantes sur GPU, regroupement des requêtes) : ne construisez pas un test sur l'égalité exacte de textes générés.

Fenêtre de contexte et coût quadratique

La fenêtre de contexte est le nombre maximal de tokens (entrée plus sortie) que le modèle traite en une fois. Dans la version naïve de l'attention, la matrice Q·K^T fait n x n : le calcul et la mémoire de ce terme croissent avec le carré de la longueur. À 8 000 tokens, cela fait 64 millions de scores par tête et par couche ; à 128 000 tokens, environ 16,4 milliards, soit 256 fois plus pour une séquence 16 fois plus longue.

Des implémentations comme FlashAttention évitent de stocker toute la matrice en mémoire, et diverses variantes (attention par fenêtre glissante, partage des têtes de clés/valeurs) réduisent le coût, mais le calcul exact reste quadratique en temps. Remplir la fenêtre n'est donc jamais gratuit. Et une grande fenêtre n'implique pas que le modèle exploite aussi bien tout ce qu'on y met : plusieurs travaux ont observé que l'usage d'une information dépend de sa position dans le contexte. Retenez surtout que la fenêtre est un budget à gérer, pas un disque sans fond.

Comment on fabrique un modèle

Les assistants que vous utilisez sont le produit de plusieurs phases successives, qui n'optimisent pas la même chose.

Pré-entraînement. La perte est l'entropie croisée : on minimise -log p(token réel | tokens précédents) sur chaque position. C'est la phase qui coûte presque tout. Une approximation courante du calcul nécessaire est 6 x N x D opérations flottantes (N paramètres, D tokens d'entraînement). L'étude Chinchilla de DeepMind a conclu que, à budget de calcul fixé, taille du modèle et quantité de données devaient croître ensemble : un modèle de 70 milliards de paramètres entraîné sur 1 400 milliards de tokens (soit 20 tokens par paramètre, la règle empirique souvent retenue) a dépassé des modèles bien plus gros mais moins nourris. Pour 70 milliards de paramètres et 1,4 billion de tokens, 6 x 70e9 x 1,4e12 donne environ 5,9e23 opérations. Beaucoup de modèles récents sont entraînés sur bien plus de données que ce ratio, parce qu'un modèle plus petit et plus entraîné coûte moins cher à chaque inférence.

Ajustement supervisé (SFT). Le modèle de base complète du texte, il ne répond pas à une question. On le reprend avec des exemples de conversations (consigne, bonne réponse), avec une perte calculée sur les tokens de la réponse. On apprend ici un comportement et un format plus que des connaissances.

Alignement. On entraîne à partir de comparaisons : un humain, ou parfois un autre modèle, indique laquelle de deux réponses est préférable. Soit on apprend un modèle de récompense puis on optimise le modèle par apprentissage par renforcement (RLHF), soit on optimise directement sur les paires de préférences (DPO et variantes). Plus récemment, l'apprentissage par renforcement sur des tâches vérifiables (code qui passe des tests, réponse mathématique exacte) est utilisé pour les modèles dits de raisonnement ; je n'entre pas dans les détails, qui varient selon les éditeurs et ne sont pas toujours publics.

Ce que « paramètres » veut dire

Les paramètres sont les nombres appris : les poids des matrices d'embeddings, d'attention et de MLP. Un modèle « de 70 milliards de paramètres » est un fichier de 70 milliards de nombres. Cela se traduit directement en mémoire : à 2 octets par paramètre (précision 16 bits), 70 milliards font environ 140 Go ; quantifié sur 4 bits, environ 35 Go, plus une marge pour les caches et l'activation. C'est ce qui décide du matériel nécessaire pour l'héberger, un sujet que je traite dans l'article sur l'IA en local.

Les ordres de grandeur : quelques milliards à une dizaine de milliards pour les petits modèles qui tournent sur un poste ; plusieurs dizaines de milliards pour les modèles intermédiaires ; 175 milliards pour GPT-3, qui a servi de référence ; plusieurs centaines de milliards pour les plus gros modèles à poids ouverts. La taille des modèles propriétaires récents n'est en général pas publiée. Un nombre de paramètres plus élevé n'implique pas automatiquement un meilleur modèle : la qualité et la quantité des données, et les phases d'ajustement, pèsent autant.

Pourquoi les hallucinations sont une conséquence du mécanisme

Une hallucination est une réponse fluide et assurée mais fausse. Ce n'est pas un bug isolé que l'on corrigerait ligne à ligne, c'est la conséquence directe de ce que le modèle optimise.

• L'objectif est la plausibilité, pas la vérité. Pendant le pré-entraînement, aucune étape ne distingue un fait exact d'une phrase vraisemblable. Le modèle apprend la distribution du texte, et un texte faux mais bien formé est probable.
• Il n'existe pas d'état « je ne sais pas » par défaut. À chaque tour, le softmax produit une distribution qui somme à 1 et un token est choisi. Faute de connaissance, la distribution est plus plate, mais un token sort quand même. Seul l'entraînement (SFT, alignement) apprend au modèle à s'abstenir, de façon imparfaite.
• Les faits rares sont mal mémorisés. Une référence bibliographique ou un numéro d'article de loi vu une fois dans le corpus est compressé de façon lossy dans les paramètres. Le modèle reconstruit « quelque chose qui ressemble à une référence » : bon format, bons types de mots, contenu inventé.
• Les erreurs s'auto-entretiennent. Un token faux, une fois émis, fait partie de l'entrée des tours suivants. Le modèle poursuit de façon cohérente avec sa propre erreur.
• L'échantillonnage ajoute du risque. Un T élevé ou un top-p large donne sa chance à des tokens peu probables, mais baisser T ne supprime pas le problème, car le token le plus probable peut déjà être faux.

On peut réduire les hallucinations (donner les sources dans le contexte, demander des citations vérifiables, valider les sorties par du code, évaluer sur un jeu de cas représentatif) mais pas les supprimer par construction. Concevez l'application en partant du principe qu'une réponse peut être fausse et que le système doit pouvoir le détecter ou en limiter l'impact.

Raisonnement, calcul, connaissances datées

• Calcul. Un LLM ne dispose pas d'un module d'arithmétique exact : il prédit des tokens de chiffres, avec un découpage des nombres qui dépend du tokenizer. Il réussit bien les cas courants et échoue de façon imprévisible sur des opérations longues ou rares. Pour tout calcul qui doit être juste, appelez du code ou un outil.
• Raisonnement. Faire écrire au modèle des étapes intermédiaires (chain of thought) lui donne davantage de calcul par réponse et améliore souvent les résultats sur des problèmes à étapes, mais ces étapes ne sont ni une preuve ni une trace fidèle de ce qui s'est calculé. Je les traite comme un moyen d'obtenir de meilleures réponses, pas comme une explication fiable.
• Connaissances datées. Les connaissances sont figées à la date de fin du corpus d'entraînement (la date limite des connaissances). Un modèle ne connaît ni la dernière version d'une bibliothèque, ni votre base de données, ni l'événement de la semaine dernière, à moins qu'on le lui fournisse dans le contexte.

Prompting, RAG ou fine-tuning : ce que chacun change

Ces trois leviers agissent à des endroits différents, et on les confond souvent.

• Le prompting consiste à mieux formuler l'entrée : consignes claires, format de sortie attendu, quelques exemples (few-shot). Le modèle n'apprend rien durablement, il conditionne simplement sa distribution sur ce que vous lui donnez. C'est le premier levier à essayer parce qu'il est gratuit à modifier, mais il consomme des tokens à chaque appel.
• Le RAG (retrieval-augmented generation) cherche, au moment de la question, des passages pertinents dans vos documents, puis les place dans le prompt avec la question. Il traite le problème des connaissances datées ou privées et permet de citer ses sources. Sa qualité est celle de la recherche : si les bons passages ne sont pas retrouvés, le modèle répondra sans eux. Je détaille l'architecture dans l'article sur l'IA et vos documents.
• Le fine-tuning continue l'entraînement sur vos exemples, en modifiant les poids, souvent par des adaptateurs de faible rang (LoRA) qui n'entraînent qu'une petite fraction des paramètres. Il convient pour fixer un style, un format de sortie, ou spécialiser le modèle sur une tâche étroite. Il est en revanche peu fiable pour lui faire retenir des faits précis, et il impose de constituer un jeu de données et un jeu d'évaluation. C'est mon dernier recours, pas le premier.

Mon ordre de travail habituel : prompting et évaluation d'abord, RAG si le problème est le manque de connaissances, fine-tuning si le problème est le comportement et que l'évaluation montre que les deux premiers ne suffisent pas.

Penser vite, penser lentement

Un détour par la psychologie aide à situer les modèles. Daniel Kahneman, dans Système 1 / Système 2 : les deux vitesses de la pensée, distingue une pensée rapide et intuitive (Système 1) et une pensée lente et délibérée (Système 2). Les LLM utilisés comme assistants, surtout quand ils produisent un raisonnement avant de répondre, ressemblent au Système 2 : lents, coûteux, capables de produire du texte libre. Or beaucoup de décisions d'un système d'information relèvent du Système 1 : ce mail est-il une réclamation, quel service doit le traiter, cette transaction est-elle suspecte. Ce sont des questions rapides, répétées des milliers de fois, avec un ensemble de réponses connu d'avance.

Les SOM

C'est à ce type de décisions que vise une catégorie annoncée en septembre 2026 : les SOM (System One Models). Le premier représentant, Jev, vient de la société TypeSafe. Selon les descriptions publiées par son éditeur et reprises par la presse spécialisée, il ne génère pas de texte : on lui donne un état (un mail, un dossier) et des questions dont les réponses possibles sont fixées par un schéma (choix dans une liste, note sur une échelle, oui/non), et il renvoie en une seule passe une réponse et une confiance par question. L'éditeur annonce des gains très importants de vitesse et de coût par rapport aux LLM ; je n'ai trouvé que des chiffres d'éditeur et des comptes rendus de seconde main, et aucune évaluation indépendante. Je les prends donc comme des promesses à vérifier sur vos données, pas comme des acquis. Comme pour tout modèle, le nombre de cas où il se trompe de case ne se déduit pas d'une brochure.

Le principe sous-jacent, lui, est vérifiable par n'importe quel ingénieur : une décision accompagnée d'une probabilité permet de choisir un seuil. À 98 % de confiance, le logiciel agit seul ; à 55 %, le dossier part vers un humain. Cela n'a de sens que si la confiance est calibrée, c'est-à-dire que parmi les réponses données avec 90 % de confiance, environ 90 % sont justes. Cela se mesure sur un jeu de validation, et c'est la première chose que je contrôlerais avant de brancher un tel modèle sur un flux réel. On peut aussi approcher cette logique avec un LLM classique, en contraignant la sortie à un schéma et en lisant les probabilités des tokens de la réponse quand l'API les expose, mais la calibration n'est pas garantie et doit être mesurée de la même façon.

Le bon outil pour la bonne tâche

La leçon utile n'est pas de savoir quel modèle est « le meilleur », mais de les composer :

1. Un modèle de classification (SOM ou autre) trie. Il oriente et signale rapidement les cas inhabituels.
2. Le logiciel classique applique les règles. Calculs, dates, validations : tout ce qui doit être exact à 100 %.
3. Le LLM traite les cas ouverts. Rédiger, analyser un document, expliquer, avec des sources dans le contexte si l'exactitude compte.
4. L'humain tranche quand la confiance est faible ou que l'enjeu est élevé.

Ce qu'il faut retenir

• Un LLM est une fonction qui, à chaque tour, convertit une séquence de tokens en une distribution de probabilité sur le token suivant, via embeddings, couches d'attention et MLP, logits et softmax.
• Le coût se joue en tokens (langue incluse), en longueur de contexte (attention quadratique en version naïve, cache KV en mémoire) et en longueur de réponse (une passe par token).
• L'entraînement se fait en phases : pré-entraînement (compétence), ajustement supervisé (format), alignement (préférences).
• Les hallucinations découlent de l'objectif de plausibilité : on les réduit avec des sources, des outils et de l'évaluation, on ne les supprime pas.
• Prompting, RAG et fine-tuning ne résolvent pas les mêmes problèmes : manque de consignes, manque de connaissances, manque de comportement.

Si vous deviez commencer par une seule chose, je vous suggère de mesurer le nombre de tokens de vos propres textes (dans vos langues) et de construire un petit jeu d'évaluation de vos vrais cas. Ces deux mesures éclairent plus de décisions qu'un benchmark public. Et si un point vous semble simplifié à l'excès, c'est probablement le cas : le mécanisme est stable, mais les détails (encodages de position, variantes d'attention, recettes d'alignement) changent vite d'un modèle à l'autre.

Références

• Vaswani et al., Attention Is All You Need (2017) : https://arxiv.org/abs/1706.03762
• Brown et al., Language Models are Few-Shot Learners (GPT-3, 2020) : https://arxiv.org/abs/2005.14165
• Hoffmann et al., Training Compute-Optimal Large Language Models (Chinchilla, 2022) : https://arxiv.org/abs/2203.15556
• Holtzman et al., The Curious Case of Neural Text Degeneration (nucleus sampling, 2019) : https://arxiv.org/abs/1904.09751
• Lewis et al., Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks (2020) : https://arxiv.org/abs/2005.11401
• DataCamp, article sur Jev et les System One Models (source secondaire, chiffres d'éditeur) : https://www.datacamp.com/blog/system-one-models-jev