Régression linéaire avec numpy

Dans la première partie, nous avons toujours utilisé des grands modèles déjà entraînés. La seconde partie répond à une question : comment un modèle est-il entraîné ?

Commençons par l'exemple le plus simple. Ni réseau de neurones ni grand modèle, juste une droite. Ne la sous-estimez pas : toutes les notions des leçons suivantes, perte, gradient, taux d'apprentissage, rétropropagation, se voient d'abord clairement sur cette droite, puis s'appliquent telles quelles aux réseaux de neurones, et enfin à GPT.

Cette leçon n'a besoin que de numpy :

uv add numpy

Le problème : prédire le prix d'après la surface

Supposons que vous ayez relevé la surface et le prix de vente de 50 logements, et que vous vouliez en tirer une règle pour, à l'avenir, estimer le prix d'un logement d'après sa surface.

Nous fabriquons nous-mêmes les données, pour connaître la « bonne réponse » et pouvoir vérifier :

import numpy as np

rng = np.random.default_rng(0)

# 造一组数据：房价（万元）= 1.2 × 面积（平方米）+ 20，再加上一些随机的波动
area = rng.uniform(40, 150, size=50)
price = 1.2 * area + 20 + rng.normal(0, 12, size=50)

default_rng(0) fixe la graine du générateur aléatoire : vous obtenez exactement les mêmes données que moi. La vraie règle est « 1,2 par mètre carré, plus 20 » (en unités de 10 000 yuans, les 万 du code), mais chaque logement a un écart aléatoire (écart type de 12), comme dans la réalité où l'orientation, l'étage ou les finitions font varier le prix.

Les 5 premiers logements :

前 5 套房子：
   110.1 平方米   156.4 万元
    69.7 平方米    89.1 万元
    44.5 平方米    73.4 万元
    41.8 平方米    78.1 万元
   129.5 平方米   159.9 万元

Le modèle : une droite

L'hypothèse la plus simple : le prix et la surface sont liés par une droite.

预测价格 = w × 面积 + b

w est la pente, c'est-à-dire de combien le prix augmente par mètre carré supplémentaire ; b est l'ordonnée à l'origine, le prix pour une surface de 0 (qu'on peut voir comme un prix de base fixe). Ces deux nombres s'appellent les paramètres du modèle.

def predict(w, b, x):
    """模型：一条直线。w 是斜率（每平方米多少万），b 是截距。"""
    return w * x + b

« Entraîner un modèle », au fond, c'est : trouver le meilleur ensemble de paramètres. Pour ce modèle, trouver les meilleurs w et b.

Pour un grand modèle comme GPT, c'est pareil, sauf qu'il n'a pas 2 paramètres mais des milliards ou des centaines de milliards, et que le modèle n'est pas une droite mais une fonction extrêmement complexe. Au module 09, vous entraînerez vous-même un petit GPT de plus d'un million de paramètres, et au fond, vous ferez toujours la même chose.

La perte : comment mesurer le « bien »

Qu'est-ce que « la meilleure droite » ? Il faut un critère concret, qui donne un nombre.

Pour chaque logement, le modèle donne un prix prédit, qui diffère du vrai prix d'un écart. On élève tous les écarts au carré, puis on fait la moyenne : ce nombre s'appelle l'erreur quadratique moyenne (Mean Squared Error, MSE) :

均方误差 = 平均值( (预测价格 - 真实价格)² )

def mse(w, b):
    """损失：预测值和真实值之差的平方，取平均。"""
    errors = predict(w, b, area) - price
    return np.mean(errors ** 2)

Pourquoi élever au carré ? Pour deux raisons. D'abord, les écarts sont tantôt positifs, tantôt négatifs, et une moyenne directe les ferait se compenser ; au carré, ils deviennent tous positifs. Ensuite, le carré rend les grosses erreurs plus « visibles » : un écart de 10 donne 100 au carré, un écart de 30 donne 900. Le modèle est forcé de s'occuper d'abord des points où il se trompe grossièrement.

Ce nombre qui mesure « à quel point le modèle est mauvais » s'appelle de façon générale la perte (loss). Plus la perte est petite, meilleur est le modèle. On peut préciser le but de l'entraînement : trouver les paramètres qui minimisent la perte.

Deviner quelques droites

Devinons d'abord quelques w et b à l'intuition, et regardons la perte :

for w, b in [(1.0, 0.0), (1.0, 30.0), (1.5, 0.0), (1.2, 20.0)]:
    print(f"  w={w:<4} b={b:<5} 均方误差 {mse(w, b):9.1f}")

随手猜几条直线，看看误差：
  w=1.0  b=0.0   均方误差    1810.1
  w=1.0  b=30.0  均方误差     310.8
  w=1.5  b=0.0   均方误差     284.5
  w=1.2  b=20.0  均方误差     146.6

La droite w=1.0, b=0 est loin des données, perte 1810. Avec une ordonnée à l'origine de 30, la perte tombe à 311. w=1.2, b=20 est exactement la vraie règle qui a servi à fabriquer les données : perte de seulement 146,6.

Remarquez que même la vraie règle n'a pas une perte nulle. Les données fluctuent de façon aléatoire, et aucune droite ne peut passer par tous les points. La perte ne descend jamais à 0 ; dans les vrais problèmes, c'est normal.

La méthode la plus bête : tout essayer

Puisqu'on sait calculer la perte, essayons tous les w et b possibles et gardons la combinaison de perte minimale. w de 0 à 3, par pas de 0,01 ; b de -50 à 100, par pas de 0,5 :

best = (None, None, float("inf"))
tries = 0
for w in np.arange(0.0, 3.0, 0.01):
    for b in np.arange(-50.0, 100.0, 0.5):
        tries += 1
        loss = mse(w, b)
        if loss < best[2]:
            best = (w, b, loss)

网格搜索：试了 90000 条直线，用了 0.2 秒
  最好的一条：w=1.26 b=14.5，均方误差 143.1

90 000 droites essayées ; la meilleure est w=1.26, b=14.5, perte 143,1, un peu plus basse encore que les 146,6 de la vraie règle (w=1.2, b=20). Rien d'étonnant : nous n'avons que 50 points de données, avec des fluctuations aléatoires, et la droite qui ajuste le mieux ces 50 points n'est pas forcément celle qui les a générés.

Que les w et b trouvés diffèrent des vraies valeurs nous accompagnera désormais : le modèle apprend les paramètres qui « expliquent le mieux les données sous ses yeux » ; si les données sont biaisées, les paramètres appris le sont aussi.

La recherche sur grille a un autre défaut discret : elle ne trouve que des points de la grille. w est essayé par pas de 0,01 ; si le vrai meilleur w est 1,2571, elle ne peut donner que 1,26. En affinant la grille, le nombre d'essais se multiplie. La descente de gradient de la leçon suivante n'a pas cette limite : elle peut s'approcher indéfiniment de la meilleure valeur.

Pourquoi cette méthode ne marche pas

Deux paramètres, quelques centaines de valeurs chacun : 90 000 combinaisons, en 0,2 seconde.

Avec 3 paramètres, ce serait des dizaines de millions de combinaisons ; avec 10, un nombre astronomique, que l'âge de l'univers ne suffirait pas à épuiser. Le plus petit réseau de neurones a déjà des dizaines ou des centaines de paramètres, le petit GPT du module 09 plus d'un million.

Il nous faut une méthode bien plus maligne : ne pas essayer à l'aveugle, mais savoir à chaque étape dans quelle direction et de combien modifier les paramètres. C'est la descente de gradient de la leçon suivante.

Exercices

1. Passez la fluctuation aléatoire des données de 12 à 0 (rng.normal(0, 0, size=50)) et relancez. La meilleure droite est-elle exactement w=1.2, b=20 ? Quelle est la perte ?
2. Remplacez la fonction de perte par « l'erreur absolue moyenne » np.mean(np.abs(errors)) et refaites la recherche sur grille. La droite trouvée est-elle la même qu'avec l'erreur quadratique moyenne ?
3. Ajoutez aux données un point extrême : un logement de 60 mètres carrés vendu 500 (area = np.append(area, 60); price = np.append(price, 500)). Faites la recherche sur grille avec l'erreur quadratique moyenne puis avec l'erreur absolue moyenne : laquelle est la plus influencée par ce point ? Pourquoi ?

Auto-test

1. Que signifie « entraîner un modèle » ?

Trouver le meilleur ensemble de paramètres, qui minimise la perte du modèle sur les données disponibles. Pour une droite, c'est trouver la meilleure pente w et la meilleure ordonnée à l'origine b. Pour un grand modèle, c'est pareil, avec beaucoup plus de paramètres et une forme de modèle bien plus complexe.

2. Pourquoi l'erreur quadratique moyenne élève-t-elle les erreurs au carré au lieu d'en faire directement la moyenne ?

Les erreurs sont tantôt positives, tantôt négatives, et une moyenne directe les ferait se compenser : même un très mauvais modèle pourrait obtenir une erreur moyenne proche de 0. Au carré, elles sont toutes positives, et les grosses erreurs sont davantage amplifiées : le modèle réduit d'abord les prédictions grossièrement fausses.

3. La recherche sur grille n'a pris que 0,2 seconde dans cet exemple. Pourquoi dit-on qu'elle ne peut pas servir à entraîner un réseau de neurones ?

Le nombre de combinaisons à essayer croît exponentiellement avec le nombre de paramètres. 2 paramètres donnent 90 000 combinaisons, 3 déjà des dizaines de millions ; un réseau de neurones a des centaines, des milliers, voire des milliards de paramètres, et le nombre de combinaisons est astronomique, impossible à épuiser.