Apprentissage
1.5 Descente de gradient
- Problème : Minimiser une fonction \(f(x)\) de \(\mathbb{R}^d\) dans \(\mathbb{R}\).
- Exemple : \(f(x) = \|x\|^2\), dont le minimum est à \(x = 0\).
- Initialisation : \(x_0 \in \mathbb{R}^d\)
- Mise à jour des paramètres : \[ x_{n+1} = x_{n} - \eta \nabla f(x_n) \] où \(\eta\) est le learning rate.
1.6 Descente de gradient stochastique
- Problème : Minimiser \(f(\mathbf{x})\) alors que \(\nabla f\) est coûteux à calculer
- On suppose que l’on dispose d’un estimateur \(G\) de \(\nabla f\), sans biais: \[E[G(x)] = \nabla f(x)\]
- On suppose \(G\) moins coûteux
- On appelle \(G\) le gradient stochastique
- SGD
- On échantillonne \(G(x_n)\)
- Mise à jour des paramètres : \[ x_{n+1} = x_{n} - \eta G(x_n) \]
3.5 modèle: FashionMNIST
On reprend le modèle du cours précédent, ainsi que les données du cours précédent :
import torch
import torch.nn as nn
import torch.nn.functional as F
class SimpleNN(nn.Module):
def __init__(self):
super(SimpleNN, self).__init__()
self.flatten = nn.Flatten()
# Définir les poids et biais pour trois couches
self.w1 = nn.Parameter(torch.randn(28*28,512))
self.b1 = nn.Parameter(torch.randn(512))
self.w2 = nn.Parameter(torch.randn(512, 512))
self.b2 = nn.Parameter(torch.randn(512))
self.w3 = nn.Parameter(torch.randn(512, 10))
self.b3 = nn.Parameter(torch.randn(10))
def forward(self, x):
x = self.flatten(x)
# Appliquer les transformations et les fonctions d'activation
x = F.relu(x.matmul(self.w1) + self.b1)
x = F.relu(x.matmul(self.w2) + self.b2)
x = x.matmul(self.w3) + self.b3
return x
# Instancier le modèle
model = SimpleNN()4.1 Mauvais learning rate
4.1.1 Problème de Taux d’Apprentissage Inadapté
Le taux d’apprentissage est un hyperparamètre clé qui contrôle la vitesse à laquelle un modèle ajuste ses poids pendant l’entraînement.
- Un taux d’apprentissage trop élevé peut entraîner des oscillations autour du minimum global ou même empêcher la convergence.
- Un taux d’apprentissage trop faible ralentit le processus d’entraînement, risquant de piéger le modèle dans un minimum local ou de stagner.
4.1.2 Learning schedule
- Les schedulers de learning rate ajustent automatiquement le taux d’apprentissage au cours de l’entraînement.
2 grands types:
- réduire le learning rate au cours du temps pour converger vers un minimum (exemple: StepLR)
- réduire le learning rate, puis le remonter, pour sortir des minimums locaux (exemple: CosineAnnealingWarmRestarts)
4.2 Saddle points
4.2.1 Saddle points
- Saddle Point : Point où le gradient est nul mais qui n’est ni un minimum ni un maximum
- Minimum Local : Point où le gradient est nul et représente un minimum de la fonction de perte
- Problème : La descente de gradient peut s’arrêter ou ralentir aux points selle
4.2.2 Solution: changer d’optimizer
- Descente de gradient classique : Reste bloquée facilement aux points selle
- Adam Optimizer :
- Utilise des moments pour adapter les pas de gradient
- Aide à échapper aux points selle et à optimiser plus rapidement
4.3 Overfitting
4.3.1 Early stopping
Arrête l’entraînement quand la performance sur le set de validation cesse de s’améliorer
Empêche le modèle de trop s’ajuster aux données d’entraînement
Critère de patience :
- Nombre d’epochs où l’on tolère une stagnation de la performance
Early stopping at epoch 30
4.3.2 Regularisation
Ajoute une pénalité à la fonction de coût pour des poids trop élevés
Réduit la complexité du modèle et favorise la généralisation
Types de régularisation :
- L2 Regularization (Ridge) : \(\text{Penalty} = \lambda \sum w^2\)
- L1 Regularization (Lasso) : \(\text{Penalty} = \lambda \sum |w|\)
- Dropout : Désactive aléatoirement des neurones pendant l’entraînement
Avantages :
- Diminue la variance
- Empêche le surajustement aux données d’entraînement
5.3 Double descent
- Intuition classique : plus de capacité \(\Rightarrow\) d’abord ça aide, puis ça nuit (courbe en U, biais-variance)
- Observation empirique : au-delà du point d’interpolation (le modèle peut ajuster parfaitement l’entraînement), l’erreur de test rebaisse
- Deux régimes séparés par un pic d’erreur : “classique” (sous-paramétré) puis “moderne” (sur-paramétré)
- Observé sur de nombreuses architectures, y compris de simples modèles linéaires à features aléatoires
