Comment une IA apprend : la descente de gradient pas à pas

Apprendre = ajuster des paramètres pour réduire une erreur

Un programme classique contient des règles écrites par un humain. En apprentissage automatique (machine learning), on fournit des exemples et le programme ajuste lui-même ses réglages. Trois ingrédients :

• un modèle : une formule avec des paramètres réglables (par exemple une droite y = a·x + b) ;
• une fonction d’erreur (loss) : un nombre qui mesure à quel point le modèle se trompe sur les exemples ;
• un algorithme d’optimisation : une méthode pour modifier les paramètres afin de réduire l’erreur.

Une droite qui apprend

Voici des points (par exemple : heures de révision → note). On cherche la droite qui passe « au mieux » parmi eux. Règle a et b à la main, puis laisse l’algorithme le faire.

Observe l’erreur (MSE) baisser à chaque étape d’apprentissage. Essaie différents taux d’apprentissage.

La descente de gradient

Imagine que tu es dans le brouillard sur une colline et que tu veux descendre au point le plus bas. Tu ne vois pas la vallée, mais tu sens la pente sous tes pieds : tu fais un pas dans la direction qui descend le plus. Puis tu recommences. C’est la descente de gradient.

Le gradient indique, pour chaque paramètre, dans quel sens l’erreur augmente. On déplace le paramètre dans le sens inverse, d’un pas proportionnel au taux d’apprentissage.

# Points (heures de révision, note)
xs = [1, 2, 3, 4, 5, 6]
ys = [6, 8, 9, 12, 13, 16]

a, b = 0.0, 0.0        # paramètres du modèle y = a*x + b
taux = 0.02            # taille du pas
n = len(xs)

for etape in range(2000):
    # gradient de l'erreur quadratique moyenne
    ga = sum(2 * (a * x + b - y) * x for x, y in zip(xs, ys)) / n
    gb = sum(2 * (a * x + b - y)     for x, y in zip(xs, ys)) / n
    a -= taux * ga     # on descend la pente
    b -= taux * gb
    if etape % 400 == 0:
        err = sum((a * x + b - y) ** 2 for x, y in zip(xs, ys)) / n
        print(etape, "erreur =", round(err, 3))

print("modèle appris : y =", round(a, 2), "x +", round(b, 2))
print("prévision pour 7 h :", round(a * 7 + b, 1))

Un réseau de neurones applique exactement la même idée, avec des millions voire des milliards de paramètres au lieu de deux. Le principe reste : mesurer l’erreur, calculer le gradient (par rétropropagation), ajuster.

Les pièges de l’apprentissage

• Taux d’apprentissage trop grand : on rebondit d’un côté à l’autre de la vallée et l’erreur ne baisse pas (parfois elle explose).
• Taux trop petit : la descente est interminable.
• Sur-apprentissage (overfitting) : le modèle mémorise les exemples, bruit compris, et se trompe sur les nouvelles données. Remède : évaluer sur des données jamais vues pendant l’entraînement (jeu de test).
• Données biaisées : un modèle reproduit ce qu’il a vu. Si les exemples sont déséquilibrés, ses décisions le seront aussi.