Descente de gradient et rétropropagation en Python

Le concept en termes simples

Entraîner, c'est ajuster les poids pour réduire la perte. Le gradient indique la direction dans laquelle la perte augmente, donc la descente de gradient fait de petits pas dans la direction opposée. La rétropropagation utilise la règle de dérivation en chaîne pour calculer ce gradient pour chaque poids.

Entraînez un neurone par descente de gradient : utilisez la règle de dérivation en chaîne pour savoir comment chaque poids influence la perte, puis descendez la pente.

Idées clés

Le gradient est la pente de la perte par rapport à chaque poids.
Le taux d'apprentissage fixe la taille du pas : trop grand, on dépasse ; trop petit, c'est lent.
La rétropropagation applique la règle de dérivation en chaîne de la sortie jusqu'à la première couche.
Une époque est un passage complet sur toutes les données d'entraînement.

Quand l’utiliser ?

Comprendre ce qui se passe à l'intérieur des réseaux de neurones et des bibliothèques d'IA.
Apprendre l'idée avant de l'implémenter dans les défis correspondants.
Se préparer aux cours d'apprentissage automatique, aux entretiens et aux projets.

À vous de jouer

Appuyez sur Lecture pour entraîner. La droite se rapproche des points pendant que le chemin orange descend le paysage de perte jusqu'à son point le plus bas.

Code d’exemple

Exécuter le code →

main.py

# Train one neuron y = w * x + b to fit points on the line y = 2x + 1.
data = [(0, 1), (1, 3), (2, 5), (3, 7)]
w, b = 0.0, 0.0
learning_rate = 0.05

for epoch in range(1, 201):
    grad_w = grad_b = 0.0
    for x, y in data:
        error = (w * x + b) - y          # prediction minus target
        # Chain rule: d(error²)/dw = 2 * error * x, d(error²)/db = 2 * error
        grad_w += 2 * error * x
        grad_b += 2 * error
    # Step against the gradient to make the loss smaller.
    w -= learning_rate * grad_w / len(data)
    b -= learning_rate * grad_b / len(data)
    if epoch in (1, 10, 50, 200):
        loss = sum(((w * x + b) - y) ** 2 for x, y in data) / len(data)
        print(f"epoch {epoch:>3}: w={w:.3f} b={b:.3f} loss={loss:.4f}")

Résultat attendu

epoch   1: w=0.850 b=0.400 loss=7.0587
epoch  10: w=2.009 b=0.958 loss=0.0009
epoch  50: w=2.005 b=0.989 loss=0.0000
epoch 200: w=2.000 b=1.000 loss=0.0000

Fonctionnement

Pour chaque point, l'erreur est la prédiction moins la cible. La règle de dérivation en chaîne donne le gradient de l'erreur quadratique, 2·error·x pour w et 2·error pour b. En faisant la moyenne sur les données et en avançant contre le gradient, w et b se rapprochent de 2 et 1, et la perte tombe presque à 0.

Modifiez les valeurs et exécutez le programme avec le compilateur Python en ligne CodeUtility, sans installation locale.

Exercices pratiques

Modifiez les entrées et testez les cas limites avant d’utiliser des données plus volumineuses.

Modifiez les entrées ou les poids et prédisez la sortie avant d'exécuter.
Affichez les valeurs intermédiaires pour suivre chaque étape du calcul.
Résolvez les défis liés ci-dessous pour implémenter l'idée vous-même.

Exécuter dans l’IDE Python →

S'entraîner avec un défi

Utilisez le contenu de cette leçon pour résoudre un vrai problème. Chaque défi s'exécute dans le navigateur, avec des tests instantanés et une revue par l'IA.

Tous les défis