Utiliser les dérivées pour mettre à jour les paramètres du modèle

Introduction au Deep Learning avec PyTorch

Jasmin Ludolf

Senior Data Science Content Developer, DataCamp

Une analogie pour les dérivées

La dérivée représente la pente de la courbe

Pentes fortes (flèches rouges) :
- Grands pas, dérivée élevée
Pentes douces (flèches vertes) :
- Petits pas, dérivée faible
Fond de la vallée (flèche bleue) :
- Plat, dérivée nulle

une image d'une vallée

Fonctions convexes et non convexes

Voici une fonction convexe

un exemple de fonction convexe

Voici une fonction non convexe

un exemple de fonction non convexe avec minimum global en surbrillance

Lien entre dérivées et entraînement du modèle

Calculer la perte au passage avant durant l'entraînement

$$ Calcul de la perte

Lien entre dérivées et entraînement du modèle

Les gradients aident à minimiser la perte, à ajuster les poids et les biais
Répéter jusqu'à ce que les couches soient ajustées

$$ Calcul des gradients

Notions de rétropropagation

Considérer un réseau de trois couches :
- Commencer par les gradients de perte pour $L2$
- Utiliser $L2$ pour calculer les gradients de $L1$
- Répéter pour toutes les couches ($L1$, $L0$)

Schéma de la rétropropagation

Rétropropagation avec PyTorch

# Exécuter un passage avant
model = nn.Sequential(nn.Linear(16, 8),
                      nn.Linear(8, 4),
                      nn.Linear(4, 2))
prediction = model(sample)


# Calculer la perte et les gradients
criterion = CrossEntropyLoss()
loss = criterion(prediction, target)
loss.backward()

# Accéder aux gradients de chaque couche
model[0].weight.grad
model[0].bias.grad
model[1].weight.grad
model[1].bias.grad
model[2].weight.grad
model[2].bias.grad

Mettre à jour manuellement les paramètres du modèle

# Le taux d'apprentissage est généralement petit
lr = 0.001

# Mettre à jour les poids
weight = model[0].weight
weight_grad = model[0].weight.grad


weight = weight - lr * weight_grad


# Mettre à jour les biais
bias = model[0].bias
bias_grad = model[0].bias.grad

bias = bias - lr * bias_grad

Accéder au gradient de chaque couche
Multiplier par le taux d'apprentissage
Soustraire ce produit du poids

Descente de gradient

Pour les fonctions non convexes, nous utiliserons la descente de gradient
PyTorch simplifie cela avec des optimiseurs
- Descente de gradient stochastique (SGD)

import torch.optim as optim

# Créer l'optimiseur
optimizer = optim.SGD(model.parameters(), lr=0.001)


# Effectuer la mise à jour des paramètres
optimizer.step()

Passons à la pratique !

Introduction au Deep Learning avec PyTorch