# Les bases des LLM, du prochain token aux outils

> Comment fonctionne un LLM ? Des paramètres appris aux tokens et au Transformer, découvrez la génération de texte, le raisonnement et les appels d'outils.

Un assistant IA peut traduire un paragraphe, expliquer un morceau de code, résoudre un problème et parfois même agir à votre place. Vu de l'extérieur, ces capacités semblent très différentes.

Pourtant, elles reposent sur un mécanisme étonnamment constant : produire le prochain token.

C'est tout ?

Eh bien, oui. Mais dire qu'un LLM produit le prochain token, c'est un peu comme dire qu'un ordinateur manipule des nombres. C'est vrai, mais cela n'explique pas grand-chose tant qu'on ne regarde pas ce que ces nombres représentent et comment la machine les utilise.

C'est ce que nous allons faire. Pas besoin de connaissances en mathématiques. Nous allons suivre une phrase à travers le modèle, puis nous appuyer sur ce que nous aurons appris pour comprendre le raisonnement et les appels d'outils. À la fin, le vocabulaire des LLM devrait vous sembler beaucoup moins mystérieux.

## Un modèle apprend des régularités à partir d'exemples

Avant de regarder comment un grand modèle de langage génère du texte, il faut comprendre d'où vient son comportement.

Imaginez que vous construisez un détecteur de spam. Une approche consisterait à écrire une règle : si un message contient "gratuit" ou "urgent", le classer comme spam.

Simple. Et plutôt fragile.

"C'est urgent : peut-on décaler notre réunion à 15 h ?" contient l'un de nos mots suspects, mais ce n'est pas du spam pour autant. Ajoutez une exception pour les réunions, et vous trouverez vite un autre message qui met la nouvelle règle en défaut. Vous pouvez passer beaucoup de temps à essayer de décrire toutes les situations possibles.

Un modèle de langage apprend des paramètres numériques à partir d'exemples. Ces paramètres sont aussi appelés **poids**.

Lors d'une étape courante de l'entraînement, le modèle voit des séquences de tokens et tente de prédire ce qui vient ensuite. Sa prédiction est comparée au token qui suit réellement dans l'exemple d'entraînement. Le processus ajuste les paramètres pour améliorer ce type de prédiction. Répétez cela sur une grande quantité de texte, et les paramètres capturent des régularités dans le langage, le code et les relations décrites par ces textes.

Les assistants actuels passent généralement par des entraînements supplémentaires pour mieux suivre les instructions et améliorer leurs réponses. Ces étapes d'entraînement ajustent les paramètres appris qui déterminent les réponses du modèle.

<llm-fundamentals-learning>



</llm-fundamentals-learning>

L'animation réunit deux moments faciles à confondre : **l'entraînement** et **l'inférence**. L'entraînement modifie les paramètres. L'inférence les utilise pour générer une sortie.

Quand vous envoyez un message à un modèle déjà entraîné, ces paramètres restent normalement fixes. Le modèle peut utiliser les informations de votre conversation, y compris une correction que vous venez de lui donner, sans apprendre durablement cette correction dans ses poids.

Une application peut aussi enregistrer des souvenirs, rechercher des documents ou utiliser des conversations dans un entraînement ultérieur. Les souvenirs enregistrés et les documents retrouvés alimentent le contexte des prochaines requêtes. Un nouvel entraînement peut modifier les paramètres.

Au moment de l'inférence, le modèle produit ses réponses à partir de ses paramètres et du contexte qu'il reçoit. Il peut mémoriser certains passages de l'entraînement. Retrouver un document précis avec sa source nécessite un système de recherche distinct.

Même une réponse fluide et assurée mérite d'être vérifiée. Cherchez des sources que vous pouvez consulter.

## Un token est un morceau de texte

Donnons à notre modèle une phrase à compléter. Nous la gardons en anglais pour suivre les exemples des animations :

> The capital of France is

Autrement dit, "La capitale de la France est". Nous voyons des mots. Le modèle a besoin de nombres.

La première étape est la **tokenisation** : découper le texte en morceaux issus d'un vocabulaire. Ces morceaux sont les tokens. Selon le tokenizer, un token peut correspondre à un mot, à une partie de mot, à un signe de ponctuation ou à une portion plus petite de la représentation encodée d'un caractère.

Pour notre phrase, le découpage ressemble à un découpage en mots. Cela peut être trompeur. Avec le même tokenizer, "unbelievable" se découpe en "un", "belie" et "vable". Un autre tokenizer peut produire un découpage différent.

Les espaces comptent aussi. Dans l'animation, un point médian rend visible l'espace au début d'un token. " capital" est un seul token dans cet exemple, espace compris.

<llm-fundamentals-tokens>



</llm-fundamentals-tokens>

Une fois le texte découpé, chaque token correspond à un **identifiant** dans le vocabulaire du tokenizer. Dans cet exemple, " France" a l'identifiant `9822`.

L'identifiant repère une entrée dans le vocabulaire, comme un numéro de catalogue. Le tokenizer attribue ces identifiants indépendamment de l'importance ou du sens d'un token.

L'identifiant sert ensuite à retrouver un **embedding**, c'est-à-dire un vecteur appris, une liste de nombres. C'est la représentation numérique que le modèle peut traiter. Les embeddings réels ont généralement bien plus de dimensions que les vecteurs montrés ci-dessus.

Nous pouvons maintenant distinguer ces éléments :

- Le token est un morceau de texte.
- L'identifiant du token le repère dans le vocabulaire.
- L'embedding le représente sous forme numérique pour le modèle.

Ces trois étapes transforment notre phrase en quelque chose que le modèle peut traiter.

Cela explique aussi pourquoi les limites et la tarification des modèles utilisent souvent les tokens plutôt que les mots. La quantité de texte représentée par un token dépend du tokenizer, de la langue et du contenu. Une conversion fixe entre mots et tokens n'est qu'une approximation.

## Le Transformer replace ces morceaux dans leur contexte

Le modèle doit ensuite tenir compte du contexte. Un même mot peut avoir des sens différents selon ce qui l'entoure, et l'ordre des mots compte.

La plupart des LLM actuels qui génèrent du texte utilisent un **Transformer composé uniquement d'un décodeur**, ou *decoder-only Transformer*. Inutile de détailler toutes ses opérations, mais deux éléments méritent qu'on s'y attarde : l'attention et le réseau à propagation avant, souvent appelé MLP.

**L'attention permet à la représentation d'un token de récupérer des informations à d'autres positions du contexte.** Dans un modèle de langage causal, l'attention à chaque position se limite à cette position et aux précédentes. Des informations sur la position des tokens permettent aussi au modèle de tenir compte de leur ordre.

Dans notre exemple, la représentation de " is" peut intégrer des informations provenant de "capital" et de "France". Le prochain token doit convenir à la phrase entière.

Le **MLP** transforme ensuite la représentation à chaque position. L'attention et ces transformations se répètent sur de nombreuses couches. Chaque couche met à jour les représentations avec des informations provenant du texte qui les entoure.

D'autres détails comptent, notamment la normalisation et les connexions résiduelles. Pour comprendre le principe, retenez que le Transformer combine à plusieurs reprises les informations pertinentes du contexte et transforme les représentations obtenues.

À la fin, le modèle utilise la représentation finale à la **dernière position** pour calculer un score pour chaque prochain token possible de son vocabulaire. Ces scores sont appelés **logits**. Une fonction appelée **softmax** les transforme en une distribution de probabilités.

Nous obtenons donc quelque chose comme ceci : " Paris" a une probabilité élevée, " Lyon" une probabilité plus faible, et beaucoup d'autres tokens ont des probabilités plus petites encore.

<llm-fundamentals-transformer>



</llm-fundamentals-transformer>

## Générer une réponse, c'est répéter la même opération

Nous avons une distribution de probabilités. Il nous faut maintenant un token.

Une **procédure de décodage** le sélectionne. Une option consiste à choisir le token ayant le score le plus élevé. Une autre consiste à effectuer un tirage dans la distribution, éventuellement après l'avoir modifiée avec des réglages comme la température ou le top-p.

La température modifie la concentration de la distribution utilisée pour ce tirage. Même à basse température, le modèle peut produire des erreurs factuelles.

Dans notre exemple, le token sélectionné est " Paris". Il est ajouté au contexte :

> The capital of France is Paris

Puis nous recommençons. Le modèle prédit maintenant ce qui suit cette séquence plus longue. Le prochain token sera peut-être un point. On l'ajoute, puis on continue jusqu'à atteindre une condition d'arrêt, comme un token de fin de tour ou une limite de sortie.

C'est ce qu'on appelle la **génération autorégressive** : le texte déjà généré fait partie de l'entrée utilisée pour produire la suite.

<llm-fundamentals-generation>



</llm-fundamentals-generation>

La réponse se construit token après token, chaque nouveau token étant influencé par ce qui le précède. Les implémentations peuvent réutiliser des calculs intermédiaires mis en cache pour réduire le travail à chaque étape.

Et notre contexte initial peut être bien plus riche qu'une phrase inachevée. Il peut contenir des instructions, des messages précédents, des documents, du code ou des résultats d'outils. Tout cela influence la suite.

Si vous avez lu mon article sur [Code Mode et le contexte des LLM](/fr/posts/code-mode-two-tools-and-an-mcp-can-save-your-llm-context), vous comprenez pourquoi la gestion du contexte compte autant. Le modèle génère à partir de ce qu'on lui a fourni, dans une fenêtre de contexte limitée. Des informations manquantes, du contenu sans rapport ou des instructions trompeuses peuvent tous affecter le résultat.

## Comment la prédiction du prochain token peut-elle produire des capacités utiles ?

Prédire le prochain token sur des textes variés demande d'apprendre de nombreux types de régularités.

Pour compléter un exemple de traduction, il est utile de saisir les relations entre les langues. Pour poursuivre un programme, il est utile de représenter les régularités du code. Pour répondre à une question dans une conversation, il est utile de suivre les instructions et d'utiliser les informations qui l'entourent.

L'entraînement et le passage à l'échelle peuvent produire de nombreuses capacités à partir de ce mécanisme commun. Les performances varient selon le modèle et la tâche. Il faut donc évaluer la fiabilité sur le travail que vous souhaitez lui confier.

Deux capacités méritent qu'on les examine de plus près, car elles donnent souvent l'impression que les assistants fonctionnent d'une tout autre façon : le raisonnement et les appels d'outils.

### Le raisonnement, un travail intermédiaire avant de répondre

Prenons ce problème :

> Un carnet et un stylo coûtent 11 € au total. Le carnet coûte 10 € de plus que le stylo. Combien coûte le stylo ?

La réponse tentante est 1 €. Mais le carnet coûterait alors 11 €, et l'ensemble coûterait 12 €. Cela ne fonctionne pas.

Si nous écrivons la relation, le problème devient plus simple. Appelons `x` le prix du stylo. Le carnet coûte `x + 10`, donc `x + (x + 10) = 11`. Nous obtenons `x = 0,50`.

<llm-fundamentals-capabilities mode="reasoning">



</llm-fundamentals-capabilities>

Les modèles de raisonnement peuvent consacrer davantage de calcul à un travail intermédiaire avant de livrer une réponse. Ce travail peut consister à générer des tokens de raisonnement, à évaluer plusieurs approches ou à revoir une première tentative. La génération de ces tokens intermédiaires utilise toujours le même mécanisme de prédiction du prochain token.

Le travail intermédiaire donne au modèle davantage d'occasions de revoir sa réponse. Consacrer plus de calcul peut améliorer les résultats sur certains problèmes. Cela augmente aussi la latence et le coût. La réponse finale reste à vérifier.

Pour notre stylo, la vérification est simple : 0,50 € + 10,50 € = 11 €, et la différence est de 10 €. Pour une vraie décision d'entreprise, la vérification peut nécessiter des éléments extérieurs au modèle.

### Les appels d'outils, une requête générée pour être exécutée ailleurs

Posons maintenant une autre question :

> Quelle heure est-il à Paris en ce moment ?

La réponse change chaque minute. L'assistant a donc besoin de consulter une horloge à jour.

L'application qui entoure le modèle peut lui donner accès à un outil, par exemple `get_time`. La description de l'outil indique au modèle ce que fait la fonction et quels arguments elle attend. Le modèle peut alors générer une requête structurée avec `city` défini à `Paris`.

<llm-fundamentals-capabilities mode="tools">



</llm-fundamentals-capabilities>

L'application reçoit la requête, la valide et exécute la fonction externe. Elle ajoute le résultat au contexte du modèle. Celui-ci peut alors générer une réponse à partir de cette information à jour.

Deux systèmes différents accomplissent deux tâches différentes :

1. **Le modèle génère une requête** à partir des définitions des outils disponibles et du contexte.
2. **L'application exécute une fonction** et renvoie son résultat.

Le logiciel qui entoure le modèle le relie à l'horloge et lui fournit l'heure actuelle.

Cette séparation est essentielle pour la sécurité. Un modèle peut demander la mauvaise action ou générer des arguments invalides. L'application doit faire respecter les permissions, valider les entrées et décider quelles actions nécessitent une confirmation. Ces contrôles relèvent du code d'exécution de l'application.

Reliez la génération, le travail intermédiaire et les outils dans une boucle, et vous obtenez la base de nombreux agents IA : un système capable d'avancer vers un objectif en plusieurs étapes. L'application coordonne le LLM, les outils et les résultats au fil de ces étapes.

## Lire la fiche d'identité d'un modèle

Une fois ces idées comprises, les annonces de nouveaux modèles deviennent plus faciles à lire. Chaque chiffre décrit une partie précise du système.

Voici les champs que je regarde :

<table>
<thead>
  <tr>
    <th>
      Champ
    </th>
    
    <th>
      Signification
    </th>
    
    <th>
      Points à vérifier
    </th>
  </tr>
</thead>

<tbody>
  <tr>
    <td>
      Paramètres
    </td>
    
    <td>
      Le nombre de valeurs numériques apprises que contient le modèle. "B" signifie milliard et "T" signifie mille milliards.
    </td>
    
    <td>
      Évaluez les performances sur votre tâche précise.
    </td>
  </tr>
  
  <tr>
    <td>
      Paramètres actifs
    </td>
    
    <td>
      Pour certains modèles à mélange d'experts, le nombre de paramètres utilisés pour un token.
    </td>
    
    <td>
      Vérifiez aussi les besoins totaux en mémoire et les coûts de déploiement.
    </td>
  </tr>
  
  <tr>
    <td>
      Fenêtre de contexte
    </td>
    
    <td>
      Le nombre de tokens qui peuvent tenir dans le contexte du modèle, selon les limites propres au fournisseur.
    </td>
    
    <td>
      Testez la fiabilité avec laquelle le modèle utilise les informations de ce contexte. Vérifiez séparément comment l'application gère la mémoire persistante.
    </td>
  </tr>
  
  <tr>
    <td>
      Disponibilité des poids
    </td>
    
    <td>
      Si vous pouvez obtenir les paramètres appris du modèle.
    </td>
    
    <td>
      Vérifiez séparément la disponibilité des données et du code d'entraînement.
    </td>
  </tr>
  
  <tr>
    <td>
      Licence et accès
    </td>
    
    <td>
      Ce que vous avez le droit de faire, et si vous pouvez utiliser une API, exécuter le modèle vous-même, ou les deux.
    </td>
    
    <td>
      Vérifiez les besoins matériels avant de prévoir un auto-hébergement.
    </td>
  </tr>
</tbody>
</table>

Par exemple, un modèle fictif annoncé avec "100B au total, 10B actifs, 128k de contexte, poids téléchargeables" nous renseigne sur son architecture, la taille de son contexte et sa distribution. Pour le comparer à un modèle plus petit, évaluez les deux sur vos documents.

Consultez la licence pour connaître les usages autorisés des poids téléchargeables. Le code et les données d'entraînement peuvent avoir des conditions distinctes ou rester privés. Et si un fournisseur ne communique pas le nombre de paramètres, c'est simplement une information que nous n'avons pas.

## Ce qu'il faut retenir

Voyez un LLM comme un modèle qui construit une réponse un petit morceau de texte à la fois. Chaque morceau est un token.

L'entraînement lui apprend des régularités à partir d'exemples. Quand vous envoyez un message, il utilise ces régularités et les informations de la conversation pour choisir le prochain token. Puis il ajoute ce token à la conversation et choisit le suivant, jusqu'à ce que la réponse soit terminée.

Cela explique plusieurs choses que vous remarquerez en utilisant un assistant :

- Il peut utiliser une correction que vous lui donnez dans la conversation sans l'apprendre durablement.
- Il peut écrire une réponse convaincante mais fausse. Vérifiez les affirmations factuelles à l'aide de sources fiables.
- Il peut faire un travail intermédiaire avant de répondre. Le résultat reste à vérifier.
- Il peut demander à utiliser un outil, comme une horloge ou un moteur de recherche. L'application exécute cet outil et transmet le résultat au modèle.

Quand vous lisez une réponse, demandez-vous donc sur quoi elle repose. Avez-vous fourni l'information ? Un outil l'a-t-il renvoyée ? Ou le modèle répond-il à partir de régularités apprises pendant l'entraînement ? Connaître la différence vous aide à décider quoi croire et quoi vérifier.
