Accéder au contenu principal

Un auto-entrepreneur passionné à votre service,

Pour votre projet de site internet et vos dépannages informatiques

Paramètres d'un modèle d'IA : ce que cachent vraiment ces milliards de chiffres

Publié le 16 Octobre 2026, dernière mise à jour le 16 Octobre 2026

7B, 70B, 405B, et maintenant plus de mille milliards. Chaque nouveau modèle d'IA arrive avec son chiffre, affiché en gros comme la cylindrée d'une voiture. J'ai longtemps lu ces nombres sans trop savoir ce qu'ils comptaient, et je ne pense pas être le seul. Un modèle peut pourtant avoir dix fois plus de paramètres qu'un autre et donner de moins bonnes réponses. Dans cet article, je reprends les choses depuis le début : ce qu'est un paramètre, comment il est réglé, pourquoi tous ne travaillent pas en même temps, et ce que tout ça implique pour la mémoire de votre machine si vous voulez faire tourner une IA chez vous.

Un paramètre, concrètement, c'est quoi ?

Un paramètre, c'est un nombre. Rien de plus. Plus précisément, c'est un coefficient stocké dans le modèle, qui pèse sur la façon dont il transforme les données qu'il reçoit et calcule ses prédictions. Quand on dit qu'un modèle compte 70 milliards de paramètres, on dit qu'il contient 70 milliards de ces valeurs.

Prise isolément, la valeur d'un paramètre ne dit à peu près rien. Qu'il vaille 0,018, -0,42 ou 1,27, si vous l'extrayez du modèle, vous ne pourrez rien en tirer. Ce qui compte, c'est sa position dans la chaîne de calculs et la façon dont il se combine avec des milliards d'autres. C'est cet ensemble qui décide ce qui sera amplifié, atténué ou mélangé dans les suites de nombres qui représentent les tokens (des morceaux de mots) à l'intérieur du modèle.

De la phrase au token suivant

Un modèle de langage écrit un token à la fois. À chaque étape, il fait passer le texte déjà présent dans toute sa série de calculs, et en sortie, il donne un score à chacun des tokens de son vocabulaire. Ces scores sont transformés en probabilités, puis un token est tiré.

Prenons « Paris est la capitale de la ». L'action combinée de milliards de paramètres va donner une forte probabilité au token qui ouvre la suite « France », et une probabilité très faible à ceux qui n'ont rien à faire là. Le token choisi s'ajoute au texte, et tout recommence pour le suivant. Jusqu'à la fin de la réponse.

Vous ne trouverez donc nulle part un paramètre qui « contient » Paris, la conjugaison du verbe être ou la date de la prise de la Bastille. Aucun ne stocke une information lisible telle quelle. Une même connaissance s'étale sur une foule de paramètres, et un même paramètre sert dans des contextes qui n'ont rien à voir entre eux. C'est d'ailleurs pour ça que comprendre ce qui se passe à l'intérieur d'un modèle est devenu un domaine de recherche à part entière, l'interprétabilité.

Paramètre et neurone ne sont pas synonymes. Un neurone artificiel est une unité de calcul du réseau, et il fait intervenir beaucoup de paramètres. Compter les paramètres ne revient donc pas à compter les neurones.

Tenseurs, poids, biais : où sont rangés les paramètres

Côté technique, ces milliards de valeurs ne sont pas en vrac. Elles sont regroupées dans des tableaux de nombres de tailles variées, répartis dans le modèle selon les opérations auxquelles ils servent. Voici les principaux types que l'on croise dans les fiches techniques :

Tenseurs
Le nom générique de ces tableaux multidimensionnels. Un fichier de modèle, c'est en gros une longue liste de tenseurs avec leurs valeurs.
Poids
La grande majorité des paramètres. Ils multiplient les valeurs qu'ils reçoivent et décident de l'importance de chaque signal dans le calcul.
Biais
Présents ou non selon l'architecture. Au lieu de multiplier, ils ajoutent une valeur au résultat, ce qui permet de le décaler quelles que soient les entrées.
Table d'embeddings
Elle donne à chaque token du vocabulaire sa représentation numérique de départ, une série de nombres apprise pendant l'entraînement. Avec un vocabulaire de 100 000 à 250 000 tokens, elle pèse déjà lourd à elle seule.
Paramètres de normalisation
Peu nombreux, ils ajustent l'échelle des valeurs intermédiaires pour garder des calculs stables d'une couche à l'autre.

Comment un modèle trouve la bonne valeur de ses paramètres

Quand vous posez une question à une IA, ses paramètres ne bougent pas. Ils sont figés et identiques d'une requête à l'autre. Tout le travail de réglage a eu lieu avant, pendant l'entraînement.

L'image qui me parle le plus, c'est celle d'une table de mixage avec des milliards de curseurs. Au départ, ils sont placés à peu près au hasard. Le modèle reçoit un morceau de texte, tente de prédire la suite, et on mesure l'écart entre sa prédiction et le vrai texte. Cet écart, la « perte », sert ensuite à calculer dans quel sens pousser chaque curseur, et de combien, pour que l'erreur diminue un peu.

Ce calcul ne se fait pas curseur par curseur. Une méthode appelée rétropropagation permet d'obtenir d'un seul coup, pour l'ensemble des paramètres, la direction de la correction. La descente de gradient applique ensuite ces petits ajustements. Le cycle se répète sur des milliers de milliards de tokens, et les réglages se stabilisent peu à peu. À la fin, on obtient une sorte de gigantesque preset numérique que le modèle utilisera pour toutes ses réponses.

Il y a en réalité plusieurs étapes. Le pré-entraînement, sur d'énormes volumes de texte, donne au modèle sa connaissance générale de la langue et du monde. Viennent ensuite des phases d'affinage (fine-tuning, apprentissage par renforcement à partir de retours humains ou automatiques) qui en font un assistant capable de suivre des consignes. Ces phases modifient elles aussi les paramètres, mais de façon beaucoup plus légère.

Un point que je trouve important : le modèle ne remplit pas une base de données. Il n'archive pas les pages lues. À force d'ajustements, il capte des régularités, des associations entre mots et entre idées, qu'il peut réutiliser face à un texte jamais vu. Il lui arrive quand même de retenir mot pour mot certains passages très présents dans ses données, ce qui pose d'ailleurs des questions de droit d'auteur et de confidentialité.

Plus de paramètres, une IA forcément plus performante ?

À architecture et entraînement équivalents, un modèle de 70 milliards de paramètres a plus de marge qu'un modèle de 7 milliards. Il peut représenter des liens plus fins entre les mots, distinguer les sens d'un terme selon le contexte, combiner plusieurs informations dans une même réponse. En apprentissage automatique, on appelle ça la capacité du modèle.

Mais dix fois plus de paramètres ne donnent ni dix fois plus de connaissances, ni des réponses dix fois meilleures. La quantité et la qualité des données, la puissance de calcul investie, l'architecture, la durée et les méthodes d'entraînement comptent autant, parfois plus.

L'exemple que tout le monde cite, et à juste titre, vient de DeepMind en 2022. Ses chercheurs ont comparé deux modèles entraînés avec le même budget de calcul : Gopher, avec 280 milliards de paramètres, et Chinchilla, avec seulement 70 milliards. Gopher avait vu environ 300 milliards de tokens pendant son entraînement, Chinchilla 1 400 milliards. Résultat, le plus petit des deux faisait mieux sur la grande majorité des tests. L'étude, publiée sur arXiv, en a tiré une règle souvent résumée ainsi : pour un budget donné, il vaut mieux environ 20 tokens d'entraînement par paramètre plutôt qu'un modèle géant sous-alimenté en données.

Depuis, les laboratoires vont souvent bien au-delà de ce ratio. Ils entraînent de petits modèles sur des volumes de données énormes, parce qu'un modèle compact coûte beaucoup moins cher à faire tourner ensuite, des millions de fois par jour. C'est pour ça qu'un modèle de 8 milliards de paramètres sorti cette année peut tenir tête à un modèle bien plus gros d'il y a deux ou trois ans.

Ce que je retiens : le nombre de paramètres indique un potentiel, pas un niveau. Deux modèles de même taille peuvent donner des résultats très différents selon les tâches, et un modèle plus gros n'est pas forcément plus fiable ni moins sujet aux hallucinations. Pour comparer, je regarde des tests sur des tâches proches des miennes, ou mieux, j'essaie moi-même.

Modèles denses et Mixture of Experts : tous les paramètres ne travaillent pas en même temps

Il y a une autre subtilité, et elle change beaucoup la lecture des chiffres : selon l'architecture, tous les paramètres annoncés ne participent pas à chaque prédiction.

Dans un modèle dit « dense », la quasi-totalité des paramètres intervient pour chaque nouveau token. Les modèles en Mixture of Experts (MoE, ou « mélange d'experts ») fonctionnent autrement. Une partie du réseau est découpée en blocs de paramètres, les experts, et un mécanisme de routage choisit, pour chaque token, les quelques experts qui vont s'en occuper. On distingue alors deux nombres :

  • les paramètres totaux, c'est-à-dire tout ce que contient le modèle ;
  • les paramètres actifs, ceux qui sont réellement mobilisés pour traiter un token.

Le mot « expert » est trompeur. Il ne s'agit pas de petites IA spécialisées l'une en maths, l'autre en traduction, la troisième en code. Le routeur choisit en fonction du token et de son contexte, et ce choix peut changer d'un token à l'autre au sein de la même phrase. Aucune thématique claire ne se dégage en général quand on regarde ce que fait chaque expert.

L'actualité fournit un très bon exemple. Mistral AI a présenté le 6 octobre 2026 son nouveau modèle phare, Mistral Large 4, surnommé « Le Chonk ». Il est disponible en préversion via l'API, et ses poids ouverts sont annoncés pour la fin du mois d'octobre. Voici comment il se compare à son prédécesseur :

Paramètres totaux et actifs chez Mistral (données annoncées par l'éditeur)
Modèle Paramètres totaux Paramètres actifs par token Part active Fenêtre de contexte
Mistral Large 3 (fin 2025) 675 milliards 41 milliards environ 6 % 256 000 tokens
Mistral Large 4 (préversion, octobre 2026) 1 050 milliards environ 49 milliards moins de 5 % 1 million de tokens
Pour Large 4, certaines pages de la documentation de préversion indiquent 52 milliards de paramètres actifs. Source : documentation Mistral AI.

Autrement dit, Large 4 dispose de plus de mille milliards de paramètres, mais n'en fait travailler qu'une petite vingtaine sur mille pour chaque token. La quantité de calcul nécessaire à la génération ressemble donc davantage à celle d'un modèle dense d'une cinquantaine de milliards de paramètres qu'à celle d'un monstre d'un billion. C'est ce qui rend ces architectures si populaires : beaucoup de capacité, pour un coût de calcul par token contenu.

Inactif ne veut pas dire absent. Les experts qui ne servent pas pour un token donné restent chargés, prêts à être appelés au token suivant. Un MoE réduit le calcul, pas la mémoire : il faut toujours stocker l'intégralité des paramètres. Pour Large 4, cela représente une infrastructure de plusieurs GPU de datacenter, même avec ses 49 milliards de paramètres actifs.

Des milliards de paramètres à faire tenir en mémoire

Car chaque paramètre, actif ou pas, prend de la place. Et sa valeur n'y change rien : 0,018 ou 1,27, c'est pareil. Ce qui détermine l'encombrement, c'est le nombre de bits utilisés pour coder ce nombre. Plus on en utilise, moins on arrondit la valeur. C'est ce qu'on appelle la précision numérique.

Le calcul de base est simple. En 16 bits, chaque paramètre occupe 2 octets. Un modèle de 7 milliards de paramètres pèse donc environ 14 Go, rien que pour ses coefficients. À 70 milliards, on passe à 140 Go. Et pour un modèle d'un billion de paramètres, on dépasse les 2 To. Vous voyez le problème si votre carte graphique a 12 ou 16 Go de mémoire.

Mémoire occupée par les seuls paramètres, selon la précision (valeurs théoriques)
Taille du modèle 16 bits (2 octets) 8 bits (1 octet) 4 bits (0,5 octet)
7 milliards 14 Go 7 Go 3,5 Go
70 milliards 140 Go 70 Go 35 Go
1 050 milliards (Mistral Large 4) 2 100 Go 1 050 Go 525 Go
À ces chiffres s'ajoute la mémoire de travail du modèle (contexte, calculs intermédiaires).

Ce tableau ne compte que les paramètres. Pendant la génération, le modèle a aussi besoin de mémoire pour ses calculs, et notamment pour le cache KV, qui garde en mémoire ce qu'il a déjà calculé sur le texte en cours. Ce cache grossit avec la longueur du contexte : une conversation longue ou un gros document à analyser peuvent ajouter plusieurs gigaoctets.

La quantification, ou comment faire entrer un gros modèle dans un PC

Comment se fait-il, alors, que des modèles de plusieurs dizaines de milliards de paramètres tournent aujourd'hui sur des ordinateurs personnels ? Parce que les paramètres n'ont pas tous besoin d'une précision de 16 bits. C'est le principe de la quantification : coder les valeurs sur moins de bits, en acceptant un peu d'approximation.

En passant de 16 à 4 bits, notre modèle de 7 milliards de paramètres descend à environ 3,5 Go en théorie. Celui de 70 milliards tombe à 35 Go. C'est encore beaucoup, mais ça devient envisageable sur une machine bien équipée, ou avec de la mémoire unifiée comme sur certains Mac.

Il y a un prix à payer. En arrondissant les valeurs, la quantification modifie les calculs du modèle, et selon la méthode et le nombre de bits conservés, la qualité des réponses peut baisser. Les techniques actuelles limitent bien ces pertes : elles gardent par exemple certaines couches sensibles en précision plus élevée, ou regroupent les paramètres par blocs avec leur propre facteur d'échelle. En 8 bits, la différence est le plus souvent imperceptible. En 4 bits, elle reste faible pour un usage courant. En dessous de 3 bits, ça se dégrade nettement.

Sur les dépôts de modèles, vous verrez souvent des noms comme Q8_0, Q5_K_M ou Q4_K_M. Ce sont les niveaux de quantification du format GGUF, utilisé par llama.cpp et par les outils qui s'appuient dessus. Le chiffre après le Q donne le nombre de bits approximatif. Comme ces formats mélangent plusieurs précisions, un fichier Q4_K_M pèse en pratique un peu plus que la valeur théorique à 4 bits.

Faire tourner un modèle en local : mes repères

J'utilise Ollama pour faire tourner des modèles directement sur ma machine. Je ne vais pas vous dresser la liste de ceux que j'ai testés, j'en ai essayé plusieurs et je ne les ai pas tous notés. Par contre, je n'ai pas choisi au hasard : je suis passé par des plateformes qui indiquent, à partir de la configuration (carte graphique, quantité de VRAM et de RAM), quels modèles et quelles quantifications ont une chance de tourner correctement. Ça évite de télécharger 40 Go pour se rendre compte que tout rame.

Si vous voulez vous lancer, voici les trois outils que je conseille de regarder :

Ollama
Gratuit, disponible sous Windows, macOS et Linux. Une commande suffit pour télécharger et lancer un modèle, et il expose une API locale que d'autres applications peuvent utiliser. C'est mon choix au quotidien.
LM Studio
Une application avec interface graphique, pratique pour démarrer sans terminal. Elle permet de chercher des modèles et signale ceux qui sont adaptés à votre matériel.
llama.cpp
Le moteur open source sur lequel reposent beaucoup d'outils. Plus technique, mais il offre le plus de réglages.

Les modèles eux-mêmes se trouvent en grande partie sur Hugging Face, qui peut d'ailleurs indiquer la compatibilité des fichiers avec votre matériel une fois celui-ci renseigné dans vos paramètres de compte.

Pour choisir une taille de modèle, la règle que j'applique est simple : le fichier du modèle quantifié doit tenir dans la mémoire de la carte graphique, avec quelques gigaoctets de marge pour le contexte. S'il déborde, l'outil répartit le travail entre la carte graphique et le processeur, et la vitesse chute fortement.

Ordres de grandeur pour un usage local en 4 bits
Mémoire disponible (VRAM ou mémoire unifiée) Taille de modèle envisageable Usage typique
6 à 8 Go 3 à 8 milliards de paramètres Reformulation, résumé, questions simples
12 à 16 Go 8 à 14 milliards, parfois plus Assistant polyvalent, aide au code
24 Go Jusqu'à 30 milliards environ Raisonnement plus solide, documents longs
48 Go et plus 70 milliards Usage avancé, proche de certains modèles en ligne
Ces repères varient selon le modèle, la quantification choisie et la longueur du contexte.

Les modèles MoE de taille moyenne sont intéressants en local : avec peu de paramètres actifs, ils génèrent vite, même si une partie des poids est placée en RAM classique plutôt qu'en VRAM. Il faut quand même assez de mémoire au total pour tout charger.

Décoder une fiche de modèle

Avec tout ce qui précède, les noms à rallonge des modèles deviennent lisibles. Voici les abréviations que l'on croise le plus souvent :

7B, 70B, 1T
Le nombre total de paramètres. B pour « billion » en anglais, soit un milliard, et T pour « trillion », soit mille milliards.
A3B, A49B
Sur un modèle MoE, le nombre de paramètres actifs par token. Un nom comme « 30B-A3B » désigne 30 milliards de paramètres au total, dont 3 milliards actifs.
FP16, BF16, FP8
Le format des nombres et leur précision : 16 bits ou 8 bits en virgule flottante. BF16 est une variante de 16 bits très utilisée pour l'entraînement.
Q8, Q5_K_M, Q4_K_M
Les niveaux de quantification du format GGUF. Plus le chiffre est bas, plus le fichier est léger et plus la perte de qualité possible est grande.
Contexte (128K, 1M)
La quantité de tokens que le modèle peut prendre en compte d'un coup. Ce n'est pas lié au nombre de paramètres, mais un grand contexte consomme beaucoup de mémoire.
Instruct, Chat, Base
Une version « Base » sort tout juste du pré-entraînement et se contente de prolonger du texte. Les versions « Instruct » ou « Chat » ont été affinées pour suivre des consignes et dialoguer.

Questions fréquentes

Un modèle avec plus de paramètres fait-il moins d'erreurs ?
Pas forcément. Une plus grande taille aide souvent, mais la qualité des données et de l'entraînement pèse autant. Un gros modèle mal entraîné peut halluciner autant, voire plus, qu'un modèle compact bien conçu.
Paramètres et tokens, c'est la même chose ?
Non. Les paramètres sont les coefficients internes du modèle. Les tokens sont les morceaux de texte qu'il lit et écrit. On parle de tokens pour la taille des données d'entraînement ou du contexte, de paramètres pour la taille du modèle.
Les paramètres changent-ils quand je discute avec une IA ?
Non. Ils sont figés après l'entraînement. Si l'assistant semble « se souvenir » de vous, c'est grâce au contexte de la conversation ou à une fonction de mémoire séparée, pas à une modification de ses paramètres.
Peut-on faire tourner Mistral Large 4 sur un PC ?
Non, pas sur un PC classique. Même en 4 bits, ses paramètres occupent environ 525 Go. Il faut plusieurs GPU de serveur. Pour un usage local, mieux vaut viser des modèles de quelques milliards à quelques dizaines de milliards de paramètres.
Quelle quantification choisir pour commencer ?
Q4_K_M est le compromis le plus courant entre taille et qualité. Si votre mémoire le permet, Q5 ou Q8 apportent un peu de qualité en plus.

Conclusion

Le nombre de paramètres reste une information utile : il donne une idée de la taille d'un modèle, de son potentiel et surtout de la mémoire qu'il va réclamer. Mais il ne dit rien, à lui seul, de la qualité des réponses. Entre les données d'entraînement, l'architecture, la part de paramètres réellement actifs et la précision à laquelle le modèle est chargé, il y a beaucoup de choses derrière un « 70B ».

Pour ma part, quand je découvre un nouveau modèle, je regarde trois choses : ses paramètres actifs, la taille du fichier dans la quantification qui m'intéresse, et des tests sur des tâches qui ressemblent aux miennes. Le reste, je le vérifie en l'essayant.

Source

Comment cet article a-t-il été réalisé ? Le texte a été rédigé par mes soins, puis relu avec l'aide d'une intelligence artificielle afin de corriger d'éventuelles erreurs d'orthographe ou de grammaire. L'illustration de présentation a également été créée à l'aide de l'IA.