Régression linéaire

Un modèle est une machine à boutons. Lui donner des exemples — des entrées accompagnées des bonnes réponses — puis tourner les boutons jusqu'à obtenir les bonnes réponses s'appelle l'entraînement. La toute première machine à tourner des boutons est la régression linéaire.

Elle suppose que le monde ressemble à réponse = poids × entrée + biais. Le poids indique la pente de la relation ; le biais (ordonnée à l'origine) indique où commence la droite quand l'entrée vaut zéro. Deux boutons, une droite, une infinité d'ajustements possibles.

Pour chaque point de données, soustrayez la vérité de la prédiction : vous obtenez le résidu, la distance verticale du point à la droite. Positif, la droite passe trop bas ; négatif, trop haut.

Additionner les résidus permettrait à une droite située 100 trop haut ici et 100 trop bas là d'obtenir un score parfait. On élève donc au carré chaque résidu. Le carré supprime le signe et punit beaucoup plus durement les grosses erreurs. La moyenne de ces carrés est l'erreur quadratique moyenne (MSE), le tableau de score.

Imaginez un immense tableur : les lignes sont les poids, les colonnes les biais, et chaque cellule contient la MSE de ce couple. Représentez ces cellules comme un paysage — la hauteur est l'erreur, le sol les valeurs des boutons — et la régression linéaire donne toujours un bol convexe lisse avec exactement un point bas.

La pente sous vos pieds porte un nom : le gradient. Il pointe vers le haut, donc vous avancez dans la direction opposée. La taille de ce pas est le taux d'apprentissage (α). Trop petit, l'entraînement rampe ; trop grand, vous sautez par-dessus la vallée et rebondissez sur la paroi d'en face.

let w = 0, b = 0;
const lr = 0.01;

for (let epoch = 0; epoch < 400; epoch++) {
  let gradW = 0, gradB = 0;

  for (const { x, y } of data) {
    const residual = (w * x + b) - y;  // prediction - truth
    gradW += 2 * residual * x;         // dMSE/dw
    gradB += 2 * residual;             // dMSE/db
  }

  gradW /= data.length;                // average over the batch
  gradB /= data.length;

  w -= lr * gradW;                     // step downhill
  b -= lr * gradB;
}

1. 1Prédire : passer chaque exemple dans les boutons actuels.
2. 2Mesurer : calculer les résidus et les réduire à un seul nombre de perte.
3. 3Blâmer : calculer la contribution de chaque bouton (le gradient).
4. 4Corriger : décaler les deux boutons à l'opposé du gradient.
5. 5Répéter jusqu'à ce que la perte cesse de s'améliorer.

Cette boucle en cinq étapes ne change plus jamais. Un modèle de langage de 400 milliards de paramètres exécute la même boucle : seuls les boutons et la perte deviennent plus élaborés.

La régression linéaire suppose quatre choses : la relation est à peu près droite, les erreurs sont indépendantes, leur dispersion est constante et aucun point ne domine. Brisez-en une et l'ajustement peut sembler sûr de lui tout en étant faux.

• Valeurs aberrantes : une valeur énorme tire toute la droite, car les erreurs sont au carré.
• Courbure : les ventes en fonction du prix ne sont pas une droite. Donnez x et x² au modèle : il ajuste une courbe — toujours une régression « linéaire », linéaire en ses paramètres.
• Extrapolation : une droite ajustée sur des logements de 50 à 200 m² ne dit rien de fiable sur un manoir de 5 000 m².
• Corrélation ≠ causalité : une droite peut être parfaite et l'histoire derrière elle absurde.