Que sont les paramètres, la perte et l’apprentissage, et à quoi ressemblent-ils quand on les regarde changer?

Un grand modèle de langage compte des milliards de paramètres, beaucoup trop pour les regarder. Les idées sont identiques avec deux, et avec deux, on peut afficher chaque valeur à chaque étape. Ce projet n’exige que Python et NumPy, une bibliothèque de tableaux de nombres.

Voici le montage. Prenez 200 températures, en Celsius et en Fahrenheit, avec un peu de bruit de mesure. Ne donnez pas la règle de conversion au programme. Donnez-lui un modèle à deux paramètres, w et b, qui prédit w × entrée + b, et laissez-le les trouver.

La boucle d’apprentissage en dix lignes

import numpy as np
rng = np.random.default_rng(0)
c = rng.uniform(-30, 40, 200)
f = 1.8 * c + 32 + rng.normal(0, 1.0, 200)   # la règle, plus du bruit
x = c / 40.0                                  # entrée mise à l'échelle

w, b, lr = 0.0, 0.0, 0.3
for step in range(301):
    error = w * x + b - f
    loss = (error ** 2).mean()                # à quel point c'est faux, en un seul nombre
    if step in (0, 1, 2, 5, 10, 20, 50, 100, 300):
        print(step, round(w, 3), round(b, 3), round(loss, 3))
    w -= lr * 2 * (error * x).mean()          # poussée contre la pente de la perte
    b -= lr * 2 * error.mean()
print("pente par degré :", round(w / 40, 3), "décalage :", round(b, 2))

La perte est ici l’erreur quadratique moyenne : la moyenne des erreurs de chaque prédiction, au carré. Les deux lignes qui mettent à jour w et b utilisent le gradient, la pente de la perte par rapport à chaque paramètre. Il répond à une seule question : si ce nombre montait un peu, la perte monterait-elle ou descendrait-elle, et à quelle vitesse? Déplacer chaque nombre à contre-pente, c’est la descente de gradient. Le taux d’apprentissage, lr, dit quelle est la taille de chaque déplacement.

À quoi ça ressemble

Mesuré ici (NumPy 2.5.4, Python 3.14, Apple M5 Max). w est donné par 40 degrés parce que l’entrée a été mise à l’échelle; la vraie valeur est 72.

La règle finale est F = 1,796 × C + 31,94, contre les vrais 1,8 et 32. Trois choses méritent un second regard.

• b dépasse jusqu’à 38, puis revient. L’apprentissage ne suit pas un chemin droit, même sur le problème le plus simple qui soit.
• La perte s’arrête à 1,042, pas à zéro. Le bruit ajouté a une variance d’environ 1, et aucune droite ne peut prédire du bruit aléatoire. Une perte qui cesse de baisser n’est pas toujours un problème.
• Les premiers gains sont énormes et les derniers, minuscules. La chute entre les étapes 0 et 1 dépasse tout ce qui suit. Une courbe se lit mieux sur une échelle logarithmique.

Pour être sûr qu’un gradient est juste, mesurez-le. Poussez w d’une toute petite quantité de chaque côté et voyez de combien la perte bouge. À w=3, b=5, la formule donne −53,97233 et la poussée aussi. Cette vérification attrape de vrais bogues quand on écrit une boucle d’entraînement à la main.

Le réglage qui décide de tout

Le taux d’apprentissage est le premier réglage à connaître. Trop bas, le progrès se traîne; trop haut, le modèle ne se stabilise jamais. Voici ce conseil en chiffres, chaque exécution durant 100 étapes à partir du même départ.

Remarquez à quel point le bon et le catastrophique sont proches : 0,6 fonctionne et 1,0 envoie la perte dans les centaines de milliards. Rien ne vous avertit avant le précipice.

La mise à l’échelle de l’entrée compte tout autant. Avec les valeurs Celsius brutes plutôt que c / 40, les taux de 0,01 et 0,003 ont divergé, et le taux stable de 0,001 n’a atteint qu’une perte de 631 après 100 étapes. Les mêmes données et le même modèle exigent beaucoup plus d’étapes quand une entrée est grande. C’est pourquoi les recettes d’entraînement normalisent les entrées.

Le véritable entraînement utilise rarement cette mise à jour toute simple. Adam conserve des estimations courantes des gradients de chaque paramètre et ajuste chaque pas en conséquence, ce qui le rend bien moins capricieux quant à ces réglages. Cela signifie aussi des nombres de plus à stocker pour chaque paramètre, ce qui revient dans le projet sur la mémoire.

Pourquoi un plus gros modèle n’apprend-il pas simplement davantage?

Une droite ne peut pas tout représenter, et ajouter des droites n’aide pas si rien ne les plie. XOR est le test classique : la sortie vaut 1 quand exactement une des deux entrées est active. Entraîné pendant 5 000 étapes avec une sortie sigmoïde, le modèle en ligne droite se stabilise à 0,5 pour les quatre cas, le mieux qu’il puisse faire. L’ajout d’une couche cachée avec une fonction non linéaire change ce que le modèle est capable d’exprimer.

Mais la capacité ne garantit pas le succès. Voici les résultats de 50 départs aléatoires chacun, mesurés ici :

Deux unités cachées suffisent en principe, et pourtant 8 départs sur 50 sont restés coincés. La capacité supplémentaire a facilité la recherche. Cela explique en partie pourquoi les modèles pratiques dépassent le strict minimum, et pourquoi la graine peut changer votre résultat. Plus de paramètres, c’est aussi plus de place pour mémoriser plutôt que généraliser, le piège que la recette d’entraînement d’Andrej Karpathy vous dit d’utiliser exprès : obtenir d’abord un modèle capable de surapprendre, puis le retenir. La taille d’un modèle fixe ce qu’il pourrait apprendre. S’il l’apprend vraiment dépend des données, des réglages et des vérifications honnêtes qui viennent ensuite dans cette série.