Que sont les poids d’un modèle ?

Un modèle d’IA moderne peut écrire du Python, reconnaître un chien, traduire du japonais, résumer un contrat, imiter Shakespeare et, parfois, vous raconter quelque chose de totalement faux avec l’assurance d’un homme à qui il n’est jamais venu à l’esprit de vérifier quoi que ce soit sur Google.

Sous toute cette sophistication se cache quelque chose d’étonnamment ordinaire :

des nombres.

Des milliards.

Quand un modèle est décrit comme 8B, 30B ou 70B, le B signifie milliards de paramètres.

Ces paramètres sont des valeurs numériques apprises à l’intérieur du réseau neuronal. La plupart se trouvent dans d’immenses structures mathématiques appelées matrices de poids.

Ce sont généralement ces nombres que l’on désigne par les poids d’un modèle.

Ce ne sont pas de petites phrases stockées quelque part dans l’ordinateur.

Il n’y a pas de ligne cachée indiquant :

France → Paris

Il n’y a pas de dossier intitulé :

Ce que je sais sur les chiens

Et aucun poids individuel ne porte un titre comme :

Vice-président principal chargé du sarcasme.

Dans un réseau neuronal, les connaissances sont réparties dans d’immenses configurations de nombres.

Cela paraît mystérieux.

L’idée de base ne l’est pas.

En fait, l’histoire commence il y a plus de quatre-vingts ans.

Avant que l’IA soit à la mode — ou même électronique

En 1943, le neurophysiologiste Warren McCulloch et le mathématicien Walter Pitts publient un modèle mathématique influent de neurone artificiel.

C’était avant l’IA moderne.

Avant les GPU.

Avant Python.

Avant même l’invention du transistor.

Leur question était d’une simplicité audacieuse :

Pourrait-on représenter mathématiquement quelque chose d’inspiré d’un neurone biologique sous la forme d’une unité de calcul ?

Leur neurone artificiel était extrêmement primitif selon nos critères actuels. Il recevait des entrées et produisait une sortie selon des règles mathématiques.

Mais une idée importante était née :

peut-être qu’un comportement complexe pouvait émerger d’un grand nombre d’unités de calcul simples reliées entre elles.

Les réseaux neuronaux modernes sont infiniment plus sophistiqués.

Mais cette idée ancestrale reste reconnaissable sous leur fonctionnement.

Commençons par un neurone artificiel

Oublions un instant les huit milliards de paramètres.

Construisons un minuscule neurone artificiel.

Supposons qu’il reçoive trois entrées numériques :

La lettre $x$ signifie simplement entrée.

Ces entrées pourraient finalement représenter presque n’importe quoi : des nombres issus de données financières, des morceaux d’image ou des représentations numériques internes du langage.

Chaque entrée est multipliée par un autre nombre :

La lettre $w$ désigne le poids.

Un poids détermine l’importance de la contribution de cette entrée au calcul du neurone.

Le neurone combine les valeurs ainsi :

La formule est plus intimidante que l’opération.

En langage courant, elle dit :

Multipliez chaque entrée par son poids, additionnez les résultats, puis ajoutez un autre nombre réglable appelé le biais.

Le biais est :

Il permet au neurone de décaler son résultat vers le haut ou vers le bas indépendamment des valeurs reçues.

Après avoir calculé la somme pondérée, un réseau neuronal fait normalement passer le résultat dans une fonction non linéaire :

Ici, $f$ signifie simplement :

Appliquez une autre transformation mathématique au résultat.

Pourquoi se donner cette peine ?

Parce que, sans fonctions non linéaires, empiler de nombreuses couches reviendrait encore, mathématiquement, à une seule transformation linéaire géante.

La non-linéarité permet au réseau de représenter des relations bien plus complexes.

Le parcours de base est donc :

entrées → poids → somme pondérée → transformation non linéaire → couche suivante

Un neurone artificiel n’écrira pas votre rapport trimestriel.

Des milliards de paramètres appris, organisés en couches sophistiquées, deviennent nettement plus intéressants.

Le perceptron arrive — et l’emballement pour l’IA aussi

À la fin des années 1950, le psychologue Frank Rosenblatt développe le perceptron, l’un des premiers systèmes de réseau neuronal capables d’être entraînés.

Le mot important est entraîné.

Au lieu qu’un programmeur choisisse explicitement chaque valeur interne utile, la machine pouvait ajuster elle-même l’intensité de ses connexions à partir d’exemples.

Ces intensités de connexion étaient des poids.

L’idée de base paraît remarquablement moderne :

Faites une prédiction.
Vérifiez si elle était fausse.
Ajustez les nombres.
Recommencez.

Les journaux s’enthousiasment énormément.

Ce qui prouve que les réseaux sociaux n’ont pas inventé l’emballement pour l’IA.

Les ordinateurs étaient un peu moins pratiques.

Aujourd’hui, vous pouvez exécuter des modèles de plusieurs milliards de paramètres sur une machine installée sous un bureau.

Rosenblatt travaillait à une époque où un ordinateur pouvait occuper une bonne partie d’une pièce tout en faisant beaucoup moins que votre téléphone.

Le progrès est parfois cruel envers le vieux matériel.

La gigantesque console de mixage

Pour imaginer les poids, pensez à une immense console de mixage audio.

Un signal arrive.

Un réglage en renforce une partie.

Un autre affaiblit quelque chose.

Un autre influence la combinaison de plusieurs signaux.

Imaginez maintenant non pas vingt réglages.

Ni vingt mille.

Des milliards.

Le comportement final dépend de leurs réglages combinés.

Mais cette analogie s’accompagne d’une mise en garde importante.

Un poids particulier ne correspond généralement pas précisément à un concept humain.

Vous ne pouvez pas ouvrir un modèle 8B, trouver le paramètre numéro 4 827 112 391 et annoncer :

« Excellent. Nous avons trouvé l’oreille gauche du chien. »

Les réseaux neuronaux modernes utilisent des représentations distribuées.

Un concept comme le chien, l’ironie, JavaScript, la gravité ou une façon polie d’expliquer à un client que sa maquette est affreuse peut dépendre de configurations impliquant d’immenses quantités de paramètres et d’états internes temporaires.

Le sens est distribué.

L’intelligence est dans la configuration.

Pas dans un bouton magique.

Avant l’entraînement : un idiot très coûteux

Lorsqu’on initialise un réseau neuronal, ses poids commencent généralement par de petites valeurs numériques choisies selon une méthode d’initialisation.

À ce stade, le réseau possède une architecture.

Il possède des milliards d’endroits où des connaissances pourraient un jour être représentées.

Mais il n’a pas encore appris de relations utiles.

On pourrait construire un modèle immense et obtenir malgré tout quelque chose de largement inutile.

Il est bon de s’en souvenir lorsque le nombre de paramètres hypnotise les gens.

Un entrepôt contenant dix milliards de cahiers vierges ne contient pas automatiquement plus de connaissances qu’une bibliothèque.

Il faut écrire quelque chose dans les cahiers.

L’entraînement est le processus qui change les nombres.

Pas en y écrivant des phrases.

Mais en créant des relations numériques utiles.

Laissons un neurone se tromper

Observons maintenant un petit exemple d’entraînement avec des nombres assez simples pour suivre les calculs à la main.

Supposons que notre neurone reçoive deux entrées.

La première entrée est :

La seconde est :

Le premier signal a donc une valeur numérique de un, et le second de un demi.

Le premier poids actuel est :

Le second est :

Et le biais est :

Utilisons maintenant notre calcul de somme pondérée :

Plutôt que de fixer la formule, décomposons-la.

La première entrée contribue à hauteur de :

La seconde entrée contribue à hauteur de :

Et le biais ajoute :

Additionnons les trois parties :

Notre neurone produit donc :

Le petit chapeau sur $y$ signifie :

la prédiction du modèle

Supposons maintenant que la bonne valeur cible de cet exemple soit :

Le modèle a prédit :

Le bon résultat était :

La prédiction est donc trop basse de :

Le neurone se trompe.

C’est une excellente nouvelle.

Les erreurs sont, en quelque sorte, le système éducatif des réseaux neuronaux.

Sans erreur, le processus d’entraînement n’a aucun signal lui indiquant ce qu’il faut améliorer.

La perte : un embarrassomètre mathématique

Le système d’entraînement a maintenant besoin d’une façon formelle de répondre à cette question :

À quel point cette prédiction était-elle fausse ?

C’est le rôle d’une fonction de perte.

Pour notre exemple miniature, nous pouvons utiliser une simple perte quadratique :

Traduisons chaque symbole.

$L$ signifie perte.

$\hat y$ signifie la prédiction du modèle.

$y$ signifie la bonne valeur cible.

La formule dit donc :

Soustrayez la bonne réponse de la prédiction, puis élevez la différence au carré.

Notre prédiction est :

La cible est :

Soustrayons :

Élevons maintenant le résultat au carré :

Notre perte est donc :

Pourquoi mettre l’erreur au carré ?

Entre autres raisons, nous ne voulons pas que des erreurs de sens opposés s’annulent.

Être trop bas de 0.30 reste une erreur.

Le carré nous donne une quantité positive que l’optimisation peut chercher à réduire.

Imaginez la perte comme un embarrassomètre mathématique.

Perte élevée :

Ça s’est mal passé.

Perte plus faible :

Moins embarrassant.

Un modèle de langage moderne utilise généralement une autre fonction de perte pour prédire le token suivant, souvent une forme de perte par entropie croisée.

Nous la rencontrerons plus tard.

Pour l’instant, l’idée essentielle est :

prédiction → mesurer l’erreur

La question suivante est plus difficile.

Notre petit exemple n’a que deux poids.

Un vrai modèle peut en avoir des milliards.

Quels poids étaient responsables de l’erreur ?

Et dans quelle direction faut-il les déplacer ?

1986 : les mathématiques apprennent à attribuer les torts

L’un des outils essentiels pour répondre à cette question est la rétropropagation.

Les idées mathématiques qui la sous-tendent ont une histoire plus longue, mais les travaux influents de David Rumelhart, Geoffrey Hinton et Ronald Williams en 1986 ont contribué à placer la rétropropagation au cœur de l’entraînement des réseaux neuronaux modernes.

Le problème est simple à énoncer.

La sortie était fausse.

Mais de nombreuses couches et de nombreux paramètres ont participé à sa production.

Comment déterminer les changements qui amélioreraient la sortie ?

La rétropropagation parcourt le réseau à rebours et calcule la sensibilité de l’erreur finale à chaque paramètre entraînable.

On peut l’imaginer comme un service comptable extraordinairement efficace.

Une erreur s’est produite.

On calcule maintenant la contribution de chacun.

Personne ne peut dire :

« Je suis presque sûr que c’était la couche 17. »

Le calcul différentiel a gardé les justificatifs.

Rétropropagation : que signifie la formule ?

Voici l’une des expressions que vous rencontrerez :

Si vous avez étudié le calcul différentiel il y a vingt ans et réussi à l’éviter depuis, cette notation peut provoquer des dégâts émotionnels inutiles.

L’idée est nettement plus simple que le symbole.

Elle pose cette question :

Si je modifiais ce poids précis d’une quantité infime, comment la perte changerait-elle ?

Cette valeur fait partie de ce qu’on appelle le gradient.

Supposons qu’augmenter légèrement un poids augmente l’erreur.

Information utile.

Supposons que l’augmenter diminue l’erreur.

Utile aussi.

La dérivée renseigne donc l’optimiseur à la fois sur la direction et sur la sensibilité.

La rétropropagation utilise la règle de dérivation des fonctions composées pour calculer efficacement ces relations à travers de nombreuses couches.

Le réseau ne pense pas :

« J’ai confondu le chien avec un chat parce que j’ai trop regardé le pelage. »

Il ne se passe rien d’aussi littéraire.

Il calcule comment les changements de certains nombres influencent d’autres nombres.

Beaucoup de nombres.

Descente de gradient : maintenant, descendons la pente

Une fois les gradients calculés par rétropropagation, l’optimiseur dispose d’informations exploitables.

Une mise à jour simplifiée d’un poids ressemble à ceci :

Traduisons encore avant de l’utiliser.

$w_{\text{old}}$ est le poids actuel.

$w_{\text{new}}$ est le poids après l’étape d’entraînement.

Le gradient :

nous indique comment la perte évolue quand ce poids change.

Et la lettre grecque :

prononcée êta, est le taux d’apprentissage.

Le taux d’apprentissage détermine la taille du pas que doit faire l’optimiseur.

La formule entière signifie donc :

Partez du poids actuel.
Déterminez la direction qui augmente l’erreur.
Avancez d’une distance contrôlée dans la direction opposée.

Pourquoi la direction opposée ?

Parce que l’objectif est de faire baisser la perte.

Imaginez-vous sur une montagne, dans un brouillard épais.

Vous ne voyez pas la vallée.

Mais vous pouvez déterminer dans quelle direction la pente monte.

Si vous voulez descendre, partez de l’autre côté.

C’est l’intuition de base de la descente de gradient.

Le véritable paysage d’optimisation d’un réseau neuronal moderne peut avoir des milliards de dimensions.

Cela complique un peu le dessin de la montagne sur une serviette.

Si vous visualisez sans difficulté un paysage à soixante-dix milliards de dimensions, vous avez peut-être d’autres soucis.

L’entraînement moderne utilise souvent des optimiseurs plus sophistiqués comme Adam ou AdamW, qui suivent des informations supplémentaires et ajustent intelligemment le processus de mise à jour.

Mais l’idée centrale reste :

calculer comment les paramètres influencent l’erreur, puis les déplacer dans une direction censée la réduire.

Faisons-le maintenant pour de bon.

Une minuscule mise à jour — avec les vrais calculs

Notre neurone miniature avait reçu :

et :

Ses poids étaient :

et :

Le biais était :

Le neurone avait prédit :

Le résultat souhaité était :

Pour cette démonstration, nous utiliserons directement la somme pondérée comme prédiction afin que chaque étape arithmétique reste visible. Un vrai réseau peut aussi contenir une fonction d’activation dont la dérivée intervient dans la rétropropagation.

Notre erreur de prédiction avec son signe est :

Le signe négatif nous dit :

La prédiction du modèle est inférieure à la cible.

Notre perte quadratique était :

donc :

Calculons maintenant comment cette perte réagit à chaque poids.

Trouver le gradient du premier poids

Pour ce neurone simple, le gradient de la perte par rapport au premier poids est :

Cela paraît technique.

Mais toutes les valeurs sont déjà connues.

L’erreur est :

La première entrée est :

Remplaçons par ces valeurs :

Multiplions-les :

Que signifie moins 0.60 ?

Cela nous indique qu’à cet endroit, augmenter $w_1$ devrait diminuer la perte.

Le gradient pointe vers une augmentation de l’erreur.

La descente de gradient va dans la direction opposée.

Trouver le gradient du second poids

Faisons maintenant la même chose pour le second poids :

L’erreur reste :

Mais la seconde entrée vaut seulement :

Remplaçons :

ce qui donne :

Remarquez quelque chose d’utile.

L’amplitude du second gradient est deux fois plus petite que celle du premier.

Pourquoi ?

Parce que la seconde entrée :

vaut la moitié de la première :

Dans ce tout petit exemple, modifier le premier poids a davantage d’effet sur le résultat final.

C’est exactement le type de dépendance que la rétropropagation calcule automatiquement.

Choisir un taux d’apprentissage

Nous connaissons maintenant la direction.

Il reste à décider de la taille du pas.

Pour notre démonstration, choisissons :

Cela signifie que l’optimiseur se déplacera d’un dixième de l’amplitude du gradient lors de cette étape simplifiée.

C’est un nombre rond pratique pour expliquer.

Les vrais systèmes d’entraînement choisissent et planifient leurs taux d’apprentissage bien plus soigneusement.

Trop petit, et l’apprentissage peut devenir douloureusement lent.

Trop grand, et l’optimiseur risque de sauter par-dessus de bonnes solutions et de rebondir dans le paysage comme quelqu’un qui essaie de descendre une montagne en chaussures de ski.

Mettre à jour le premier poids

La règle de mise à jour est :

Pour le premier poids :

Multiplions d’abord le taux d’apprentissage par le gradient :

Donc :

Soustraire un nombre négatif revient à additionner :

Nous savons maintenant exactement d’où vient 0.26.

Personne ne l’a choisi parce qu’il était joli.

Aucun ingénieur n’a tapé :

Essayons 0.26.

Le gradient et le taux d’apprentissage l’ont produit.

Mettre à jour le second poids

Répétons maintenant exactement le même processus pour $w_2$ :

Multiplions :

Donc :

ce qui donne :

Voilà d’où vient 0.43.

Pour cet exemple pédagogique, nous laisserons le biais inchangé à :

Dans un vrai réseau, un biais entraînable aurait normalement son propre gradient et pourrait être mis à jour par le même processus général.

Faire fonctionner le neurone à nouveau

Les entrées n’ont pas changé.

La première vaut toujours :

Mais son poids vaut maintenant :

Sa contribution est donc :

La seconde entrée reste :

Son nouveau poids est :

Sa contribution devient donc :

Le biais reste :

Additionnons tout :

La nouvelle prédiction du neurone est :

Avant l’étape d’entraînement, il prédisait :

Maintenant, il prédit :

La cible reste :

Il se trompe encore.

Mais regardez ce qui s’est passé.

Avant la mise à jour, la distance à la cible était :

Après la mise à jour :

L’erreur a diminué.

Nous pouvons aussi calculer la nouvelle perte quadratique :

D’abord :

Puis le carré :

La perte est donc passée de :

à :

Dans cet exemple volontairement simple, une étape de descente de gradient a considérablement réduit la perte.

Cela ne signifie pas qu’un vrai grand modèle de langage s’améliore du même pourcentage à chaque étape d’entraînement.

La véritable optimisation est bruitée, complexe et possède énormément plus de dimensions.

Mais notre minuscule exemple a montré une étape complète d’apprentissage sans rien cacher :

En mots :

Le neurone a fait une prédiction.
La perte a mesuré l’erreur.
Le calcul différentiel a déterminé la contribution des poids à l’erreur.
L’optimiseur a changé les poids.
La nouvelle prédiction s’est rapprochée de la cible.
La perte a diminué.

Il ne s’est rien passé de magique.

Les mathématiques ont changé les nombres.

Puis le système recommence.

Encore.

Et encore.

Notre exemple utilise deux poids parce que deux poids tiennent encore confortablement sur une page.

Un vrai réseau neuronal peut ajuster des millions ou des milliards de paramètres entraînables.

C’est là que le calcul à l’échelle industrielle entre dans l’histoire.

Comment un modèle de langage apprend-il ainsi ?

On n’entraîne généralement pas un grand modèle de langage en lui fournissant une immense table de règles explicites comme :

Paris = capitale de la France

Chien = mammifère

Python = l’indentation compte

À la place, une grande partie du préentraînement moderne des modèles de langage utilise un objectif d’une simplicité trompeuse :

Prédire le prochain token.

Restons donc avec Paris et suivons l’exemple jusqu’au bout.

Supposons que le texte d’entraînement contienne :

La capitale de la France est Paris.

À un moment de l’entraînement, le modèle reçoit :

La capitale de la France est

et doit prédire le prochain token.

Pour simplifier, supposons que Paris soit représenté par un seul token. La tokenisation réelle peut découper certains mots en plusieurs tokens, mais cela ne change pas le principe.

Au début de l’entraînement, le modèle pourrait produire des probabilités comme celles-ci :

Londres — 18%
Paris — 5%
Lyon — 4%
Rome — 3%
Berlin — 2%

Le reste de la probabilité est réparti entre des milliers d’autres tokens possibles.

Mais le texte d’entraînement nous indique que le véritable token suivant est :

Paris

Le modèle a donc fait une mauvaise prédiction.

Il n’a donné que cinq pour cent de probabilité à Paris, en privilégiant Londres.

L’entraînement doit maintenant mesurer à quel point cette prédiction était mauvaise.

Entropie croisée : la perte du modèle de langage

Pour prédire le prochain token, les modèles de langage utilisent couramment une forme de perte par entropie croisée.

Pour un seul token correct, l’expression simplifiée peut s’écrire :

Traduisons à nouveau avant de calculer.

$P_{\text{correct}}$ signifie :

la probabilité que le modèle a attribuée au token qui venait réellement ensuite

Dans notre exemple :

Cinq pour cent en écriture décimale donne :

Remplaçons :

Le résultat est approximativement :

Inutile de retenir 2.996.

L’important est ce que fait le logarithme.

Une faible probabilité pour la bonne réponse produit une perte relativement élevée.

Supposons maintenant que, bien plus tard dans l’entraînement, le même type de contexte donne à Paris une probabilité de soixante-dix pour cent :

Alors :

soit approximativement :

Donc :

Paris à 5% → perte relativement élevée

Paris à 70% → perte beaucoup plus faible

La fonction de perte ne sait pas ce qu’est Paris.

Elle ne sait pas ce qu’est la France.

Elle ne comprend pas le concept politique de capitale.

Elle dit simplement :

La probabilité attribuée au bon token aurait dû être plus élevée.

Ce signal numérique suffit.

La rétropropagation peut maintenant effectuer le même travail que dans notre neurone miniature.

Comment « Paris » atteint-il réellement les poids ?

La prédiction ne venait pas d’un seul poids.

Les mots :

La capitale de la France est

ont d’abord été convertis en représentations numériques de tokens.

Ces représentations ont traversé de nombreuses couches Transformer.

À l’intérieur, les mécanismes d’attention et les réseaux à propagation avant ont transformé les nombres à plusieurs reprises à l’aide de matrices de poids apprises.

Finalement, le modèle a produit des scores bruts pour les prochains tokens possibles.

Ces scores bruts s’appellent des logits.

Imaginez une version extrêmement simplifiée :

Ce ne sont pas encore des probabilités.

Ce sont des scores bruts de préférence.

Une opération mathématique appelée softmax convertit les logits en une distribution de probabilités dont les valeurs totalisent cent pour cent.

Après softmax, on pourrait obtenir :

Londres — 18%
Paris — 5%
Lyon — 4%
Rome — 3%

Les données d’entraînement nous disent :

Paris aurait dû gagner.

L’entropie croisée nous donne la perte.

La rétropropagation parcourt ensuite le réseau à rebours, en calculant comment de petites modifications des paramètres concernés influenceraient cette perte.

L’optimiseur les met à jour.

Pas un changement gigantesque.

Un nombre immense de changements microscopiques.

Puis un autre morceau de texte arrive.

Une phrase n’enseigne pas la géographie

Le modèle ne voit pas :

La capitale de la France est Paris.

une fois pour annoncer immédiatement :

« Géographie terminée. »

Ses données d’entraînement peuvent aussi contenir :

Paris est la capitale de la France.

La ville capitale de la France est Paris.

Le gouvernement français siège à Paris.

Paris est une grande ville européenne.

La France est un pays d’Europe occidentale.

La Seine traverse Paris.

Et d’immenses quantités d’autres contextes concernant la France, Paris, les villes, les gouvernements, les pays, les langues, les voyages, l’histoire et la géographie.

Chaque exemple produit des prédictions.

Chaque prédiction produit une perte.

Chaque perte génère des gradients.

Chaque étape d’entraînement modifie légèrement les paramètres.

Avec le temps, les relations qui se recoupent se tissent progressivement dans le réseau.

Ce mot — tissent — est utile.

Le fait n’est pas placé dans une boîte marquée :

France → Paris

Il devient une partie d’un tissu mathématique distribué.

Après suffisamment d’entraînement

Finalement, le modèle voit :

La capitale de la France est

et sa distribution de sortie ressemble peut-être davantage à ceci :

Paris — 92%
Lyon — 1.2%
Marseille — 0.7%
Londres — 0.3%

Paris gagne maintenant facilement.

Où le fait est-il donc stocké ?

Pas dans un poids.

Pas dans un neurone.

Pas dans un enregistrement textuel caché.

La relation est répartie dans le réseau.

C’est aussi pourquoi le modèle peut répondre à :

Quelle ville fait office de capitale de la France ?

ou :

Quelle est la ville capitale de la France ?

La phrase exacte a changé.

Mais les relations sous-jacentes entre les concepts restent utiles.

Le modèle ne cherche pas simplement la phrase exacte du texte d’entraînement.

Il effectue des calculs dans un réseau appris de relations numériques.

Voilà aussi pourquoi la tâche apparemment simple de prédire le prochain token peut mener à un comportement étonnamment riche.

Pour bien prédire le langage, il est utile d’apprendre la grammaire.

Le sens.

Les faits.

Les relations.

Le style.

La structure.

Les schémas de raisonnement.

L’objectif est simple :

Prédire ce qui vient ensuite.

Ce que le modèle doit apprendre pour y devenir exceptionnellement bon ne l’est pas.

Et finalement, ces relations apprises se reflètent dans ses poids.

Chiens, chats et pourquoi « l’importance des caractéristiques » peut vous tromper

Une explication courante des poids d’un réseau neuronal passe par la classification d’images.

Supposons qu’un modèle soit entraîné à distinguer les chiens des chats.

Il pourrait découvrir que certains motifs visuels liés au museau, aux oreilles, à la structure du visage ou à la forme du corps sont plus utiles que d’autres.

C’est une intuition utile.

Mais il ne faut pas la prendre au pied de la lettre.

Un réseau moderne ne contient normalement pas :

Poids des oreilles = 0.84

Poids de la couleur du pelage = 0.17

Les premières couches peuvent devenir sensibles à des motifs relativement simples, comme les contours.

Les couches suivantes peuvent les combiner en textures et en formes.

Des représentations encore plus tardives peuvent réagir à des structures de plus en plus complexes.

La classification finale émerge des interactions entre de nombreuses couches et de nombreux paramètres.

Donc, quand nous disons :

le modèle a appris que la forme des oreilles compte

nous traduisons un processus numérique distribué complexe en langage humain.

Il n’y a pas de bouton étiqueté OREILLE.

2012 : le GPU entre dans l’histoire

Les réseaux neuronaux existaient depuis des décennies.

Pourquoi leurs capacités ont-elles soudain progressé si vite ?

Le matériel en est une raison majeure.

En 2012, Alex Krizhevsky, Ilya Sutskever et Geoffrey Hinton présentent ce qui sera connu sous le nom d’AlexNet, un réseau profond de reconnaissance d’images comportant environ soixante millions de paramètres.

L’utilisation d’unités de traitement graphique, ou GPU, était un ingrédient essentiel.

Les GPU avaient largement évolué parce que l’infographie exige d’énormes quantités d’opérations mathématiques similaires exécutées en parallèle.

Les jeux vidéo devaient traiter rapidement pixels, triangles, éclairage et textures.

Les réseaux neuronaux ont regardé ce matériel et ont en quelque sorte dit :

« Cette machine à multiplier a l’air utile. »

L’industrie du jeu vidéo avait accidentellement passé des années à développer une infrastructure pour l’apprentissage automatique.

Quelque part, un dragon virtuel mérite une part du mérite de l’IA moderne.

Des poids individuels aux tenseurs

Notre minuscule neurone utilisait des valeurs individuelles comme :

et :

Un vrai réseau ne peut pas gérer commodément des milliards de paramètres de cette façon.

Les nombres sont plutôt organisés en structures appelées tenseurs.

Une simple liste de nombres peut être vue comme un tenseur à une dimension.

Un tableau rectangulaire de nombres est un tenseur à deux dimensions, généralement appelé matrice.

Les ensembles de dimensions supérieures sont aussi des tenseurs.

De grandes parties des calculs d’un réseau neuronal peuvent s’exprimer sous des formes compactes comme :

Traduisons celle-ci aussi.

$X$ représente un ensemble de nombres d’entrée.

$W$ représente une matrice de poids appris.

La multiplication :

consiste à combiner de nombreuses valeurs d’entrée avec de nombreux poids appris selon les règles de multiplication matricielle.

Le résultat :

est un nouvel ensemble de valeurs numériques transformées.

La notation paraît minuscule.

Le calcul réel peut contenir des millions ou des milliards d’opérations individuelles de multiplication et d’addition.

C’est pourquoi les GPU sont si précieux.

Ils peuvent effectuer d’énormes quantités de ces opérations en parallèle.

Pendant que l’IA semble discuter calmement de Dostoïevski, le GPU multiplie à l’échelle industrielle.

La conversation paraît intellectuelle.

Le matériel voit de l’arithmétique.

2017 : l’attention change l’architecture

En 2017, l’article « Attention Is All You Need » présente l’architecture Transformer.

Les Transformers deviennent la base de la plupart des grands modèles de langage modernes.

Cette architecture introduit une façon puissante de faire interagir différentes parties d’une séquence grâce à l’attention.

Mais l’arrivée de l’attention n’a pas supprimé les poids.

Bien au contraire.

Les Transformers contiennent de grandes matrices apprises dans toute leur architecture.

L’attention utilise des matrices de projection apprises.

Les couches à propagation avant utilisent des matrices apprises.

Les systèmes d’embeddings contiennent des paramètres appris.

L’architecture est devenue radicalement plus sophistiquée.

La monnaie de base est restée les nombres.

2020 : 175 milliards font les gros titres

Puis vient le changement d’échelle.

En 2020, GPT-3 est présenté avec :

175 milliards de paramètres.

Comparez cela aux quelque soixante millions de paramètres d’AlexNet, huit ans auparavant seulement.

Le domaine est passé de millions de valeurs apprises à des centaines de milliards.

L’idée fondamentale reste reconnaissable :

Apprendre des paramètres numériques utiles à partir de données.

Les chercheurs améliorent l’architecture.

Les méthodes d’entraînement progressent.

Les jeux de données grandissent.

Les grappes de GPU deviennent immenses.

Puis, comme souvent en informatique, nous ajoutons un nombre déraisonnable de zéros.

Que contient physiquement un modèle 8B ?

Le nombre de paramètres cesse maintenant d’être abstrait.

Il devient un problème physique de stockage.

Supposons qu’un modèle contienne :

paramètres.

Cela représente environ huit milliards de valeurs numériques apprises.

Supposons que chaque paramètre soit stocké sur seize bits.

Seize bits correspondent à :

Le stockage brut approximatif des paramètres est donc :

ce qui donne :

soit environ :

D’où viennent ces seize gigaoctets ?

Rien de mystérieux.

Nous avons huit milliards de nombres.

Chacun nécessite deux octets.

Huit milliards multipliés par deux donnent environ seize milliards d’octets.

Considérons maintenant un modèle de soixante-dix milliards de paramètres à la même précision.

Le calcul est :

ce qui donne environ :

rien que pour le stockage brut des paramètres.

Soudain :

« Modèle 70B »

n’est plus simplement un nom de modèle.

C’est un problème matériel.

Votre GPU commence à s’y intéresser.

Votre RAM système pourrait s’y intéresser.

Votre portefeuille finit par s’y intéresser.

Quantification : que réduisons-nous réellement ?

Supposons que seize bits par paramètre demandent trop de mémoire.

Pouvons-nous représenter les mêmes valeurs apprises avec moins de bits ?

C’est l’idée de base de la quantification.

Prenons notre modèle 8B hypothétique.

À seize bits par paramètre, son stockage brut idéalisé est d’environ :

Supposons maintenant que nous représentions beaucoup de poids avec environ quatre bits.

Quatre bits, c’est un demi-octet :

Donc :

donne environ :

L’important est ce qui ne s’est pas produit.

Nous n’avons pas transformé un modèle de huit milliards de paramètres en modèle de deux milliards.

Le modèle possède toujours à peu près autant de paramètres.

Nous avons changé la précision numérique utilisée pour les représenter.

Pour une intuition simple, pensez à l’arrondi.

Vous pourriez stocker :

ou :

Le second nombre est moins précis.

La véritable quantification des réseaux neuronaux est bien plus sophistiquée qu’un simple arrondi des décimales. Les méthodes pratiques utilisent des facteurs d’échelle, des groupes, des encodages spécialisés et d’autres techniques pour préserver un comportement utile tout en réduisant la mémoire.

Mais le compromis physique central reste :

moins de bits par poids → moins de mémoire

C’est pourquoi les utilisateurs d’IA locale consacrent une part surprenante de leur vie à débattre de Q4, Q5, Q6 et Q8.

De loin, on croirait entendre parler d’huile moteur.

Il s’agit généralement de faire tenir des milliards de nombres dans une carte graphique.

Les poids ne sont pas les activations

Une autre distinction compte énormément lorsqu’on parle de matériel.

Les poids sont persistants.

Ils sont stockés avec le modèle.

Éteignez la machine.

Rechargez le même modèle demain.

Les poids appris restent.

Les activations sont temporaires.

Quand une entrée traverse le réseau, chaque couche produit des états numériques intermédiaires.

Ces valeurs dépendent de l’entrée actuelle.

Changez le prompt, et les activations changent.

Pensez à une usine.

Les poids sont les machines installées.

Les activations sont les matériaux qui traversent actuellement ces machines.

Voilà pourquoi charger les poids dans la mémoire du GPU ne couvre pas tous les besoins en mémoire.

Le calcul lui-même a besoin d’un espace de travail.

Les modèles de langage peuvent aussi utiliser beaucoup de mémoire pour un cache de clés et de valeurs, ou cache KV, qui conserve des informations intermédiaires utiles issues des tokens déjà traités.

À mesure que le contexte grandit, ce cache peut grandir aussi.

Donc :

Les poids tiennent dans la VRAM

ne signifie pas automatiquement :

Le modèle peut travailler confortablement dans cette VRAM.

Le canapé peut passer par la porte de l’appartement.

Vous aimeriez tout de même avoir un endroit où rester debout.

Les poids changent-ils pendant que vous discutez avec le modèle ?

Normalement :

Non.

Quand un modèle entraîné répond à un prompt, il effectue de l’inférence.

L’inférence signifie :

Utiliser les paramètres déjà appris pour calculer une sortie.

Les poids sont lus.

Ils ne sont normalement pas réécrits parce que vous avez posé une question.

Heureusement.

Sinon, une conversation suffisamment étrange pourrait remodeler le réseau pour toujours.

Une conversation crée un état temporaire : contexte, activations, cache KV, résultats d’outils et autres informations de travail.

Ce sont des choses différentes des paramètres entraînés persistants.

Le résumé le plus simple est :

L’entraînement change les poids. L’inférence utilise les poids.

Cette phrase explique énormément de choses sur l’IA.

L’ajustement fin : changer les nombres à nouveau

Un modèle préentraîné peut recevoir un entraînement supplémentaire par la suite.

Ce processus s’appelle l’ajustement fin.

Imaginez un modèle général qui comprend déjà le langage.

Vous pourriez l’ajuster sur :

des documents juridiques,

la terminologie médicale,

des exemples de programmation,

des conversations de service client,

des analyses financières,

ou un autre domaine spécialisé.

L’entraînement modifie à nouveau des paramètres pour mieux adapter le modèle à la nouvelle tâche.

Un ajustement fin complet peut mettre à jour d’immenses quantités de paramètres et demander des ressources de calcul importantes.

D’autres méthodes, comme l’adaptation de faible rang, ou LoRA, entraînent des structures supplémentaires de paramètres beaucoup plus petites tout en laissant intacte la majeure partie du modèle d’origine.

La distinction pratique est importante.

Donner un PDF au modèle pendant une conversation modifie normalement son contexte.

L’ajustement fin modifie des paramètres appris.

L’un fournit des informations temporaires.

L’autre modifie le modèle entraîné.

Le modèle n’est pas tout le système

Supposons que deux personnes téléchargent exactement le même modèle.

Même point de contrôle.

Mêmes poids.

Même quantification.

L’une construit un excellent système de recherche.

L’autre produit des réponses peu fiables avec une belle mise en forme.

Comment est-ce possible ?

Parce que le modèle n’est qu’un composant.

Autour de lui peuvent se trouver prompts, systèmes de recherche, bases de données, mémoire, outils, navigateurs, routage, permissions, validation et code applicatif.

Cet ensemble logiciel est parfois appelé harness ou environnement d’agents.

Le harness ne réécrit normalement pas les poids du modèle à chaque nouvelle demande.

Il contrôle les informations qui atteignent le modèle, les outils que celui-ci peut utiliser et ce qui arrive au résultat.

Mêmes poids.

Environnement différent.

Comportement différent.

Le moteur peut être identique.

Le véhicule ne l’est pas forcément.

Qu’est-ce qu’un modèle à poids ouverts ?

Pendant l’entraînement, les paramètres changent constamment.

À des moments utiles, les développeurs sauvegardent leur état actuel.

Cet état sauvegardé est appelé point de contrôle, ou checkpoint.

Un point de contrôle est essentiellement un instantané de l’état numérique appris du modèle à un moment donné.

Si ces fichiers de paramètres entraînés sont proposés au téléchargement, on parle généralement de modèle à poids ouverts.

Selon la licence, on peut l’exécuter localement, le quantifier, l’ajuster, l’étudier, l’intégrer à des produits ou redistribuer des versions dérivées.

Mais il existe une distinction terminologique importante.

Des poids ouverts ne signifient pas automatiquement un modèle open source.

Un développeur peut publier les poids tout en gardant privés les données d’entraînement, certaines parties du code, la méthode complète d’entraînement ou d’autres composants.

Les licences peuvent également imposer des restrictions.

Il s’agit donc de deux questions différentes :

Puis-je télécharger les poids entraînés ?

et :

L’ensemble du processus de développement du modèle est-il ouvert ?

Les réponses peuvent être différentes.

Les mots comptent.

Surtout quand les avocats arrivent.

Pourquoi les poids ouverts ont changé la donne

Entraîner un puissant modèle de fondation à partir de zéro peut demander d’immenses ressources :

données, grappes de GPU, électricité, ingénierie, temps et argent.

Télécharger des poids entraînés permet à quelqu’un d’autre de commencer après que cet entraînement coûteux a déjà eu lieu.

Vous recevez l’état numérique appris.

Vous ne reproduisez pas toute l’éducation.

Pour les chercheurs, cela permet l’étude.

Pour les développeurs, cela permet le déploiement local et l’expérimentation.

Pour les organisations, cela peut offrir davantage de contrôle.

Et pour les amateurs et les curieux de technique, cela crée quelque chose qui aurait paru extraordinaire il n’y a pas si longtemps :

Un modèle entraîné sur une infrastructure industrielle peut finir sous forme de fichiers sur un ordinateur chez vous.

La grappe d’entraînement peut occuper un centre de données.

Le point de contrôle terminé peut finir sur un SSD sous votre bureau, à côté de trois câbles USB que personne ne se souvient avoir achetés.

Sacré voyage pour un tenseur.

Ce que les poids ne sont pas

Après tout cela, plusieurs idées fausses deviennent plus faciles à écarter.

Les poids ne sont pas une base de données.

Il n’y a pas de ligne contenant :

capital_of_france = Paris

Un poids seul n’est généralement pas un concept lisible par un humain.

Trouver :

dans un tenseur ne vous dit presque rien en soi.

Les poids ne changent normalement pas pendant l’inférence ordinaire.

L’entraînement les modifie.

L’inférence les utilise.

Un poids ne correspond généralement pas à une caractéristique.

Le sens est réparti entre de nombreux paramètres et couches.

Le nombre de paramètres n’est pas synonyme d’intelligence.

L’architecture compte.

Les données d’entraînement comptent.

L’optimisation compte.

Le post-entraînement compte.

La gestion du contexte compte.

L’environnement compte.

Un idiot à quatre-vingts milliards de paramètres resterait un idiot.

Il lui faudrait simplement un GPU plus cher.

Poids et paramètres

On utilise souvent les mots poids et paramètre presque indifféremment.

Dans une conversation courante, cela convient généralement.

Techniquement, paramètre est le terme le plus large.

Les poids sont des paramètres.

Les biais, les valeurs de normalisation et d’autres valeurs entraînables peuvent aussi être des paramètres.

Donc, quand quelqu’un dit :

« C’est un modèle 70B »,

le sens le plus précis est :

Le modèle contient environ soixante-dix milliards de paramètres appris.

La plupart de ces paramètres se trouvent dans de grandes matrices apprises.

Les gens continueront à les appeler des poids.

La civilisation devrait s’en remettre.

Que signifie dire qu’un modèle « sait » quelque chose ?

Les mathématiques commencent maintenant à toucher à la philosophie.

Un modèle de langage ne contient pas de bibliothécaire miniature qui fouille des rayonnages de faits.

Il n’y a pas de petite base SQL cachée dans le Transformer.

L’entraînement façonne plutôt des milliards de relations numériques pour que certains motifs d’entrée tendent à produire des motifs de sortie utiles.

Demandez :

La capitale de la France est —

et le réseau appris privilégie nettement :

Paris.

Demandez du code Python, et un autre motif d’activité interne apparaît.

Demandez de l’histoire médiévale, et un autre encore.

Les mêmes poids persistants participent à tous ces comportements.

Quand nous disons qu’un modèle sait quelque chose, nous voulons donc plutôt dire, mathématiquement :

Ses paramètres appris ont atteint une configuration qui produit un comportement compatible avec l’apprentissage de cette information ou de cette capacité.

Savoir si cela mérite le même mot connaissance que celui que nous employons pour les humains est une question philosophique bien plus vaste.

Mieux vaut probablement s’y attaquer après le dîner.

Toute l’histoire en deux schémas

Pour ceux qui souhaitent le squelette technique sans refaire tout le voyage, l’inférence peut se résumer ainsi :

En langage courant :

Donnez une entrée au réseau entraîné.
Faites-la passer dans des couches contenant des poids appris.
Générez des états internes temporaires.
Produisez une sortie.

L’entraînement ajoute une seconde boucle :

En langage courant :

Faites une prédiction.
Mesurez à quel point elle était fausse.
Calculez quels changements de paramètres devraient réduire l’erreur.
Mettez ces paramètres à jour.

Puis recommencez.

Et recommencez.

Et recommencez.

Ou, dans la version techniquement utile la plus courte :

L’inférence utilise les nombres. L’entraînement change les nombres.

Tout le reste est architecture, données, optimisation, matériel et échelle.

Certes, ces quatre sujets ont occupé un bon nombre de chercheurs.

Pourquoi cela vous concerne même si vous n’entraînez jamais rien

La plupart des personnes qui utilisent une IA locale ne calculeront jamais un gradient à la main.

Ce n’est pas un problème.

La plupart des automobilistes n’usinent pas non plus leur propre vilebrequin.

Mais comprendre les poids explique beaucoup de choses qu’un utilisateur d’IA curieux de technique finit par rencontrer.

Pourquoi un modèle 8B occupe-t-il plusieurs gigaoctets ?

Parce qu’il faut stocker physiquement des milliards de paramètres numériques appris.

Pourquoi Q4 demande-t-il beaucoup moins de mémoire qu’une précision sur seize bits ?

Parce qu’on utilise moins de bits pour représenter beaucoup de ces paramètres.

Pourquoi la quantification peut-elle légèrement modifier le comportement ?

Parce que la précision numérique a changé.

Pourquoi l’ajustement fin peut-il modifier un modèle ?

Parce qu’un entraînement supplémentaire change des paramètres.

Pourquoi envoyer un PDF n’apprend-il pas durablement son contenu au modèle ?

Parce que le PDF change le contexte actuel, pas les poids persistants.

Pourquoi deux systèmes utilisant des poids identiques peuvent-ils se comporter très différemment ?

Parce que le modèle n’est qu’une partie de son environnement.

Et pourquoi peut-on télécharger un modèle d’IA entraîné ?

Parce qu’une grande partie du résultat de l’entraînement peut être conservée sous forme d’immenses ensembles de paramètres numériques appris.

L’idée a commencé avec de minuscules neurones mathématiques.

Puis sont arrivés les perceptrons entraînables.

La rétropropagation a rendu l’apprentissage multicouche praticable.

Les GPU ont apporté des quantités extraordinaires d’arithmétique parallèle.

Les Transformers ont réorganisé le traitement du langage.

Le nombre de paramètres est passé des millions aux milliards, et au-delà.

L’échelle a changé presque au point de devenir méconnaissable.

La boucle centrale est restée étonnamment familière :

Faites une prédiction.

Mesurez l’erreur.

Calculez ce qui doit changer.

Changez un peu les nombres.

Réessayez.

Faites-le suffisamment de fois, avec assez de données, de mathématiques, de matériel et d’électricité —

et, finalement, les nombres commencent à vous répondre.