Poids (paramètres)

Les milliards de nombres qui stockent tout ce qu'un modèle a appris pendant son entraînement.

7 min de lecture

#entraînement
#mémoire
#paramètres

En une phrase

Les poids sont les milliards de nombres qui composent un modèle d’IA : tout ce que le modèle a « appris » pendant son entraînement est stocké là, et nulle part ailleurs.

L’analogie

Imagine une console de mixage gigantesque, avec des milliards de potentiomètres. Au départ, tous les boutons sont réglés au hasard et le son est atroce. L’entraînement, c’est un technicien qui tourne chaque bouton, un tout petit peu à la fois, jusqu’à obtenir un son juste. Une fois le réglage terminé, la position de chaque bouton est précieuse : c’est elle, et rien d’autre, qui contient le savoir-faire. Note les positions et tu as le modèle ; efface-les et il ne reste qu’une carcasse muette.

Comment ça marche

Des nombres, et rien d’autre

Un modèle de langage est, physiquement, une pile de tableaux de nombres qu’on appelle des matrices. Quand un texte le traverse, chaque valeur qui le représente est multipliée par ces nombres, additionnée à d’autres, transformée encore et encore jusqu’à la sortie. Il n’y a pas de règles écrites quelque part, pas de dictionnaire, pas de base de connaissances : seulement des multiplications.

Le nom des modèles annonce d’ailleurs ce chiffre. « Llama 3 8B » signifie 8 milliards de paramètres, un peu plus de 8,03 milliards en réalité : le « 8B » est un arrondi commercial.

Poids, biais, paramètres

En toute rigueur, les paramètres se divisent en deux familles : les poids, qui multiplient les valeurs traversant le réseau, et les biais, qui leur ajoutent un décalage constant. Les deux s’apprennent pendant l’entraînement, et dans l’usage courant on dit « poids » pour l’ensemble. Le raccourci est d’autant plus inoffensif que plusieurs architectures récentes, dont Llama, ont retiré les biais de leurs couches principales : il ne reste presque que des poids.

Ce qui n’est pas un poids

Deux familles de nombres se confondent souvent avec eux, et la distinction éclaire beaucoup de choses.

Les activations sont les valeurs calculées à la volée pendant que le modèle traite ton texte. Elles changent à chaque phrase, elles sont jetées une fois la réponse écrite, et le fichier que tu télécharges n’en contient aucune.
Les hyperparamètres sont les réglages choisis avant l’entraînement par l’équipe qui le lance : nombre de couches, taille des lots de textes, taux d’apprentissage. Ils décident de la façon dont les poids vont s’ajuster, mais ils ne sont pas dedans. Impossible de retrouver le taux d’apprentissage utilisé en inspectant un modèle fini.

Retiens le partage : les poids sont ce que tu télécharges, les activations ce qui se passe pendant qu’il répond, les hyperparamètres les décisions de celui qui l’a entraîné.

Comment ces nombres trouvent leur valeur

Au tout début, les poids sont tirés au hasard et le modèle produit du charabia. Une boucle se répète ensuite des milliards de fois, en quatre temps.

Le modèle lit un extrait de texte et prédit la suite.
On compare sa prédiction à la vraie suite. L’écart est chiffré par une fonction de perte : plus il se trompe, plus le nombre est grand.
La rétropropagation repart de cette erreur et remonte le réseau couche par couche pour calculer, poids par poids, de combien l’erreur bougerait si on modifiait ce poids-là. Cette quantité s’appelle le gradient.
La descente de gradient applique la correction : chaque poids se décale légèrement dans le sens qui réduit l’erreur. L’amplitude du pas est fixée par le taux d’apprentissage.

Les deux dernières étapes sont souvent confondues, à tort : la rétropropagation ne fait que calculer les gradients, c’est la descente de gradient qui touche réellement aux poids. Aucun de ces ajustements ne « comprend » quoi que ce soit. C’est leur accumulation, sur des milliers de milliards de mots, qui fait émerger la grammaire, des faits et des styles.

Le poids des poids

Chaque paramètre occupe de la place, selon la précision avec laquelle on l’écrit : 4 octets en FP32, 2 octets en FP16 ou BF16, 1 octet en INT8. Un modèle de 8 milliards de paramètres en 16 bits pèse donc environ 16 Go, ce qui dépasse déjà la mémoire d’une carte graphique ordinaire. C’est exactement le problème que résout la quantification, en rognant la précision de chaque poids pour faire tenir le modèle sur du matériel grand public.

L’entraînement, lui, coûte bien plus cher que l’utilisation. En précision mixte avec l’optimiseur Adam, il faut garder en mémoire environ 18 octets par paramètre : 6 pour les poids eux-mêmes (une copie de travail et une copie de référence), 4 pour les gradients et 8 pour les statistiques de l’optimiseur. Contre 2 octets par paramètre une fois le modèle figé.

Des fichiers qu’on peut télécharger

Pour les modèles ouverts, les poids se distribuent comme de simples fichiers. Le format par défaut sur Hugging Face est safetensors : il ne contient que des tenseurs bruts et n’exécute aucun code au chargement, contrairement aux anciens fichiers Python qui pouvaient dissimuler un programme malveillant. GGUF, de son côté, s’est imposé pour faire tourner un modèle sur son propre ordinateur.

Une fois publiés, ces nombres sont figés : discuter avec un modèle ne les modifie pas d’un iota. Les faire bouger à nouveau demande de relancer un entraînement, et c’est tout le sujet du fine-tuning.

Dans la vraie vie

BLOOM, publié en 2022 par le collectif BigScience, est l’un des rares géants dont on connaît tout : 176 247 271 424 paramètres, entraînés de mars à juillet 2022 sur Jean Zay, le supercalculateur public français, avec 384 cartes graphiques A100. Les poids diffusés pèsent 329 Go ; le point de sauvegarde complet, états de l’optimiseur compris, monte à 2,3 To.
La frontière entre modèles « ouverts » et « fermés » passe exactement là : Llama ou Mistral publient leurs poids et tu peux les télécharger, les modèles servis uniquement par API gardent les leurs.
« 7B, 13B, 70B » : la taille annoncée d’un modèle se lit en paramètres, et donne directement une idée de la mémoire qu’il va réclamer.
Entraîner un grand modèle coûte des millions précisément parce qu’il faut des mois de calcul pour trouver les bonnes valeurs de ces nombres.

Idées reçues

« Les poids contiennent des phrases apprises par cœur. » Presque jamais, mais pas jamais. Une étude de 2025 estime la capacité de mémorisation d’un modèle de type GPT à environ 3,6 bits par paramètre : de quoi retenir mot pour mot quelques passages, en général ceux répétés des milliers de fois dans les données. L’immense majorité de ce que stockent les poids reste statistique, et rien là-dedans ne se consulte comme une base de données.
« On peut lire ce que le modèle sait en regardant ses poids. » Pas directement : un même neurone porte plusieurs concepts mêlés, un phénomène appelé superposition. Il faut des outils dédiés pour en extraire quoi que ce soit de lisible, et c’est tout l’objet de la recherche en interprétabilité.
« Plus il y a de poids, plus le modèle est intelligent. » L’étude Chinchilla (2022) a montré l’inverse à budget de calcul égal : un modèle de 70 milliards de paramètres entraîné sur assez de données a battu un modèle de 280 milliards sous-entraîné. Le nombre de poids ne vaut rien sans le volume et la qualité des données.

Pour aller plus loin

Gradient descent, how neural networks learn — 3Blue1Brown (EN, vidéo) : l’ajustement des poids rendu visible sur un réseau minuscule.
La révolution de l’apprentissage profond — Yoshua Bengio sur Interstices, Inria (FR) : d’où vient l’idée d’apprendre en modifiant des connexions.
Training Compute-Optimal Large Language Models — Hoffmann et al., 2022 (EN) : le papier Chinchilla, sur l’équilibre entre nombre de paramètres et volume de données.
How much do language models memorize? — Morris et al., 2025 (EN) : l’estimation des 3,6 bits de mémorisation par paramètre.
La documentation safetensors — Hugging Face (EN) : le format de fichier dans lequel circulent les poids.
Model training anatomy — Hugging Face (EN) : le détail des octets par paramètre pendant l’entraînement.