Perspective historique

• Modèle mathématique de l’axone géant du calmar (Hodgkin & Huxley, 1952)
• Modèle simplifié (McCulloch & Pitts, 1943)

Histoires de succès

• Synthèse et reconnaissance vocale (Ze, Senior, & Schuster, 2013), (J. Li et al., 2019)
• Traduction automatique (Google Neural Machine Translation)
• Modèles de langage (BERT, GPT, chatGPT 175B, Mistral) (Devlin, Chang, Lee, & Toutanova, 2019), (Brown et al., 2020)
• Génération augmentée par récupération (RAG, LangChain, LlamaIndex)

Voir aussi l’apprentissage profond par renforcement : Atari / AlphaGO / AlphaStar / AlphaChem; réseaux de neurones de graphes, etc.

Pourquoi l’apprentissage profond fonctionne-t-il aujourd’hui ?

Quelques raisons du succès actuel :

• GPU (puissance de calcul)

Ressources

Livres

Conférences et chercheurs

Quelques grands contributeurs au domaine :

• N-2 : McCulloch/Pitts, Rumelhart, Rosenblatt, Hopfield,
• N-1 : Hinton, Bengio, LeCun, Schmidhuber
• N : Goodfellow, Dauphin, Graves, Sutskever, Karpathy, Krizevsky, Hochreiter

Quelques conférences majeures en apprentissage machine : NIPS/NeurIPS, ICLR, CVPR, (ICML, ICASSP, ..)

Ressources en ligne :

• distill.pub, billets de blog (ex. pytorch.org blog),
• FastAI lectures, CS231n, MIT S191
• awesome deep learning, Awesome deep learning papers

Syllabus

• Cours 1, 2, 3 (01/10 3h, 09/10 2h) : Introduction, réseaux linéaires, RBF, descente de gradient, initialisation, régularisation
• TP : introduction à pytorch (17/10 pour ceux qui suivent ILIAR, sinon en autonomie)
• Cours 4, 5 (05/11, 06/11) : CNNs, Détection d’objet, segmentation sémantique
• TP : segmentation sémantique (12/11, 13/11)

TPs : sur le DCE/clusters GPU (1080, 2080 Ti, pytorch).

warning On utilise dcejs. Vous devez l’installer et le tester avant les TPs. Si vous avez des soucis, contactez moi

Evaluation

• Note de contrôle continu sur les TPs, en particulier “Segmentation sémantique” : rendu expérimental. Date limite ? avant les vacances de Noel ?

• Examen final mutualisé avec AS + DL (modalités bientôt précisées)

Graphe computationnel avec ou sans cycles

Un réseau de neurones est un graphe orienté :

• nœuds : unités de calcul
• arêtes : connexions pondérées

Il existe deux catégories de graphes :

• sans cycle : réseau de neurones à propagation avant
• avec au moins un cycle : réseaux de neurones récurrents

Régression linéaire

Problème : Étant donné \((x_i, y_i)\), \(x_i\in\mathbb{R}^{n+1}, y_i \in \mathbb{R}\)

Proposé par (Widrow & Hoff, 1962) : AdaLine

• On suppose que \(x[0] = 1\) pour inclure le biais
  
• Modèle linéaire : \(\hat{y} = w^T x\)

Classification binaire

Problème : Étant donné \((x_i, y_i)\), \(x_i\in\mathbb{R}^{n+1}, y_i \in \{0, 1\}\)

• Modèle logit linéaire : \(o(x) = w^Tx\) (nous supposons toujours \(x[0] = 1\) pour le biais)

• Fonction de transfert sigmoïde : \(\hat{y}(x) = p(x; w) = \sigma(o(x)) = \sigma(w^T x)\)

  • \(\sigma(x) = \frac{1}{1 + \exp(-x)}\), \(\sigma(x) \in [0, 1]\)
    
  • \(\frac{d}{dx}\sigma(x) = \sigma(x) (1 - \sigma(x))\)

Classification multiclasses N-voies

Problème : Étant donné \((x_i, y_i)\), \(x_i\in\mathbb{R}^{n+1}, y_i \in [|0, K-1|]\)

Supposons un \(P(y=y_i | x_i) = f_\theta(x_i, y_i)\) paramétrique. La vraisemblance conditionnelle des étiquettes se lit :

\[ \mathcal{L}(w) = \prod_i P(y=y_i | x_i) \]

Classification multiclasses N-voies

Problème : Étant donné \((x_i, y_i)\), \(x_i\in\mathbb{R}^{n+1}, y_i \in [|0, K-1|]\)

• Modèles linéaires pour chaque classe \(o_j(x) = w_j^T x\) (nous supposons toujours \(x[0] = 1\))
  
• Fonction de transfert Softmax : \(P[y=j|x] = \hat{y}_j = \frac{\exp(o_j(x))}{\sum_k \exp(o_k(x))}\)
• Généralisation de la sigmoïde pour une sortie vectorielle

Problèmes numériques avec le softmax et la perte d’entropie croisée

Éviter les grands exponentiels

Si vous calculez naïvement le softmax, vous obtiendrez \(\exp(..)\) qui devient rapidement grand.

Heureusement :

\[ softmax(o_1, o_2, o_3, ..) = softmax(o_1 - o^\star, o_2 - o^\star, o_3-o^\star) = \frac{\exp(o_i - o^\star)}{\sum_j \exp(o_j - o^\star)} \]

Vous calculez toujours \(\exp(z)\) avec \(z \leq 0\).

Éviter certains exponentiels avec le truc log-sum-exp \(\log(\sum_j \exp(o_j)) = o^\star + \log(\sum_j \exp(o_j-o^\star))\)

Vous n’avez pas vraiment besoin de calculer le \(\log(\hat{y}_j) = \log(softmax_j(x)))\) puisque :

\[ \log(\hat{y}_i) = \log(\frac{\exp(o_i-o^\star)}{\sum_j \exp(o_j - o^\star)}) = o_i - o^\star - \log(\sum_j \exp(o_j - o^\star)) \]

En pratique, cela explique pourquoi nous utilisons la perte d’entropie croisée avec des sorties logits plutôt que Softmax + log-vraisemblance négative ou même LogSoftMax + NLLLoss (ce qui n’a pas le log… ouais, confus…)

Objectif

Notre objectif est de minimiser le risque réel de la fonction de perte par rapport aux paramètres du réseau de neurones :

\[ argmin_\theta E_{X,Y \sim P_{X,Y}}[L(f_\theta(x), y)] \]

En général, nous avons un ensemble fini d’échantillons \((x_i, y_i)\), pas la densité \(P_{X,Y}\). Par conséquent, nous procédons par :

• minimiser le risque empirique sur un ensemble d’entraînement :

\[\frac{1}{N}\sum_{x_i,y_i} L(f_\theta(x_i), y_i)\]

• garder le meilleur modèle comme celui qui minimise la perte sur un ensemble de validation

Nous effectuons cette optimisation par descente de gradient.

Définition de la descente de gradient par minibatches

\[J(w,x,y) = \frac{1}{N} \sum_{i=1}^N L(w,x_i,y_i)\] par exemple \(L(w,x_i,y_i) = ||y_i - w^T x_i||^2\)

Mini-lot

• estimation bruitée du véritable gradient avec \(M\) échantillons (par exemple, \(M=64, 128\)) ; \(M\) est la taille du minibatch
• Randomisez \(\mathcal{J}\) avec \(|\mathcal{J}| = M\), un ensemble à la fois

\[ w_{t+1} = w_t - \epsilon_t \textcolor{red}{\frac{1}{M} \sum_{j \in \mathcal{J}} \nabla_w L(w,x_j,y_j)} \]

• estimation plus lisse que la descente de gradient stochastique (SGD, \(M=1\))
• idéal pour les architectures parallèles (GPU)

Graphe computationnel et différenciation par mode inverse

Calculer le gradient dans un réseau de neurones implique :

• différenciation par mode inverse (règle de la chaîne) \(\frac{\partial y_n}{\partial y_1} = \frac{\partial y_n}{\partial y_{n-1}}\frac{\partial y_{n-1}}{\partial y_{n-2}}\cdots\frac{\partial y_2}{\partial y_1}\)

• appliqué sur un graphe computationnel warning

Vers la programmation différentiable

Le graphe computationnel est une notion centrale dans les réseaux de neurones modernes/apprentissage profond. Élargissez le champ avec la programmation différentiable.

Ces dernières années, des blocs différentiables plus “sophistiqués” autres que \(f(W f(W..))\), et qui sont construits dynamiquement (mode eager vs graphe statique).

Gradient qui disparaît/explose : le problème fondamental

Le Problème Fondamental de l’Apprentissage Profond a été observé pour la première fois par (Josef Hochreiter, 1991) pour les RNN. Le gradient peut soit disparaître, soit exploser, surtout dans les réseaux profonds (les RNN sont très profonds).

• Rappelez-vous que le gradient rétropropagé implique : \[ \frac{\partial J}{\partial x_l} = \frac{\partial J}{\partial y_L} W_L f'(y_l) W_{L-1} f'(y_{l-1}) \cdots \] avec \(y_l = W_l x_l + b, x_l = f(y_{l-1})\).

• Nous devons assurer un bon flux du gradient :
  • en utilisant des fonctions de transfert appropriées comme ReLu, PreLu, etc.
  • en utilisant des éléments architecturaux : connexions de raccourci (ResNet), carrousel d’erreur constant (LSTM)
• Nous pouvons prévenir l’explosion du gradient en le clipant (Pascanu, Mikolov, & Bengio, 2013)

Algorithmes d’optimisation basés sur le gradient

Algorithme canonique

• Commencer à \(\theta_0\)
• pour chaque mini-lot : \[ \begin{align*} \theta(t+1) &= \theta(t) - \epsilon \nabla_\theta L(\theta(t))\\ L(\theta) &= \frac{1}{M} \sum_i J(\theta, x_i, y_i) \end{align*} \]

Rationnel (développement de Taylor) : \(L(\theta_{t+1}) \approx L(\theta_{t}) + (\theta_{t+1} - \theta_{t})^T \nabla_{\theta} L(\theta_{t})\)

Variantes

• Le taux d’apprentissage peut (et devrait) être adapté au cours du temps, par exemple divisé par \(10\) tous les \(N_e\) époques.
• Méthodes du premier ordre avec des taux d’apprentissage adaptatifs, par exemple Nesterov Momentum, RMSProp, Adam, … (voir https://www.ruder.io/optimizing-gradient-descent/)

Exemple sur un problème de régression

Étapes générales :

0- Imports
1- Chargement des données
2- Définir le réseau
3- Définir la perte, l’optimiseur, les callbacks, …
4- Itérer et surveiller

Exemple sur un problème de régression

0- Imports

import torch
import torch.nn as nn
import torch.optim as optim

import sklearn
import sklearn.datasets

import tqdm

import matplotlib.pyplot as plt

1- Chargement des données

# Chargement des données
data = sklearn.datasets.fetch_california_housing()
# X is (20640, 8), y is (20640, )
X, y = data.data, data.target

# La normalization facilite la descente de gradient
mean, std = X.mean(axis=0), X.std(axis=0)
X = (X - mean)/std

X_train = torch.tensor(X).float()
y_train = torch.tensor(y).float()

# Un dataset est un objet indexable (__getitem__) et 
# dont on peut demander la taille (__len__)
train_dataset = torch.utils.data.TensorDataset(X_train, y_train)
# A dataloader will create the minibatches
train_dataloader = torch.utils.data.DataLoader(train_dataset,
                                               batch_size=64,
                                               shuffle=True,
                                               pin_memory=True)

Doc: Dataset, DataLoader. Pin memory

Itérer sur le train_dataloader fourni des paires de tenseur de taille \((64, 8)\) et \((64, )\)

Exemple sur un problème de régression

2- Définition du réseau

if torch.cuda.is_available():
    device = torch.device('gpu')
else:
    device = torch.device('cpu')

# Construction du modèle
Nh = 64
model = nn.Linear(8, 1)

model.to(device)

Doc: Linear, Sequential

Exemple sur un problème de régression

3- Définition de la perte, optimiseur, callbacks

# Définition de la perte
loss = nn.MSELoss()

# Définition de l'algorithme d'optimisation
optimizer = optim.Adam(model.parameters(),
                       lr=0.001)
scheduler = optim.lr_scheduler.StepLR(optimizer,
                                      step_size=10,
                                      gamma=0.5,
                                      verbose=True)

Doc: MSELoss, Adam, StepLR

Exemple sur un problème de régression

4- Itération et monitoring

for e in range(num_epochs):
    # On passe le réseau en mode "entrainement"
    model.train()

    print(f"Epoch {e}")
    for X, y in tqdm.tqdm(train_dataloader):
        # Send the data to the GPU if necessary
        X, y = X.to(device), y.to(device)

        # Reset the gradient accumulator
        optimizer.zero_grad()

        # Forward pass
        y_pred = model(X).squeeze()
        loss_value = loss(y_pred, y)

        # Backward pass
        loss_value.backward()

        # Weight update
        optimizer.step()

    print(f"MSELoss on the training set : {mseloss(train_dataloader)}")

    # Adaptation du taux d'apprentissage
    scheduler.step()

Évaluation

def mseloss(loader):
    # Estimation du risque réel après
    # chaque epoch
    cum_loss = 0.0
    n_samples = 0
   
    # Passage du modèle en mode évaluation
    model.eval()

    with torch.no_grad():
        for X, y in tqdm.tqdm(loader):
            X, y = X.to(device), y.to(device)

            # Passe forward
            y_pred = model(X).squeeze()
            loss_value = loss(y_pred, y)

            # La perte est moyennée, donc on la dénormalise
            # avant de l'intégrer
            cum_loss += loss_value * y_pred.size()[0]
            n_samples += y_pred.size()[0]
    return cum_loss/n_samples

Limites d’un classifieur linéaire

Les prédicteurs linéaires vus précédemment réalisent leurs prédictions sur un espace d’attributs (feature space) prédéfinis, fixés.

Peux t’on apprendre cet espace d’attributs \(\phi_j(x)\) ?

Architecture (Broomhead & Lowe, 1988)

• Les RBFNs sont des approximateurs à base de prototypes
• architecture spécifique avec une seule couche de paramètres entrainables \((\mu_j, \sigma_j)_{j\in[0..N_a-1]}\)

\[ \begin{eqnarray*} \phi(x) = \begin{pmatrix} 1 \\ \exp{\frac{-||x-\mu_0||^2}{2\sigma_0^2}} \\ \vdots\\ \exp{\frac{-||x-\mu_{N_a-1}||^2}{2\sigma_{N_a-1}^2}} \\ \end{pmatrix} \end{eqnarray*} \]

Apprentissage

• On sait apprendre les poids \(w\) : descente de gradient minibatch

• Comment fixer les centres et variances ? (Schwenker, Kestler, & Palm, 2001)

  • On les réparti uniformément ou aléatoirement, ou par quantification vectorielle (K-means++(Arthur & Vassilvitskii, 2007), GNG (Fritzke, 1994))

  • on fixe les centre/variances, on apprends les poids, on apprends tout ! (\(\nabla_{\mu} L, \nabla_{\sigma} L, \nabla_w L\))

Approximateur universel

Théorème : Approximateur universel (Park & Sandberg, 1991)

Notons \(\mathcal{S}\) la famille de fonctions basées sur des RBF \(\mathbb{R}^d\): \[\mathcal{S} = \{g \in \mathbb{R}^d \to \mathbb{R}, g(x) = \sum_i w_i K(\frac{x-\mu_i}{\sigma}), w \in \mathbb{R}^N\}\] avec \(K : \mathbb{R}^d \rightarrow \mathbb{R}\) continue presque partout et \(\int_{\mathbb{R}^d}K(x)dx \neq 0\),
Alors \(\mathcal{S}\) est dense dans \(L^p(\mathbb{R})\) pour tout \(p \in [1, \infty)\)

En particulier, cela s’applique aux RBFs à noyau gaussien \(K(x) = exp(-\frac{1}{2}x^2)\)

Exemple

Architecture

Vocabulaire

• Profondeur : nombre de couches de poids
• Largeur : nombre d’unités par couche
• Paramètres : poids et biais pour chaque unité
• Les connexions de couche de contournement peuvent contourner des couches
  
• une fonction de transfert cachée \(g\), une fonction de transfert de sortie spécifique à la tâche \(f\)

Un réseau FFNs avec \(1\) couche cachée est un approximant universel.

Fonction de transfert cachée

• historiquement : tangente hyperbolique \(\tanh(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}}\) ou sigmoïde \(\sigma(x) = \frac{1}{1 + \exp(-x)}\)
• maintenant principalement des unités linéaires rectifiées (ReLu)(Nair & Hinton, 2010),(Krizhevsky et al., 2012) ou des variantes : \[ \mbox{relu}(x) = \max(x, 0) \]

Les ReLu sont plus favorables au flux de gradient que les fonctions saturantes (plus de détails à ce sujet plus tard, lors de la discussion des graphes computationnels et du calcul du gradient).

Fonction de transfert de sortie

Exactement comme lorsque nous avons discuté des RBF, cela dépend de la tâche.

En pratique

model = nn.Sequential(
    nn.Linear(8, Nh), nn.ReLU(),
    nn.Linear(Nh, Nh), nn.ReLU(),
    nn.Linear(Nh, Nh), nn.ReLU(),
    nn.Linear(Nh, 1)
)

Est-il raisonnable d’utiliser la descente de gradient ?

En effet :

• nous ne pouvons pas faire mieux qu’un minimum local
• les réseaux neuronaux conduisent à une optimisation non convexe. Par exemple, considérons un réseau FFN à 2 couches :

Mais empiriquement, la plupart des minimums locaux sont proches (en performance) du minimum global, surtout avec des réseaux larges/profonds. Voir (Dauphin et al., 2014), (Pascanu, Dauphin, Ganguli, & Bengio, 2014), (Choromanska, Henaff, Mathieu, Arous, & LeCun, 2015). Les points selles semblent être plus critiques.

Méthodes du premier ordre : descente de gradient stochastique par minibatch

Algorithme

• Commencer à \(\theta_0\)
• pour chaque minibatch : \[ \begin{align*} \theta(t+1) &= \theta(t) - \epsilon \nabla_\theta L(\theta(t))\\ L(\theta) &= \frac{1}{M} \sum_i J(\theta, x_i, y_i) \end{align*} \]

Rationnel (développement de Taylor) : \(L(\theta_{t+1}) \approx L(\theta_{t}) + (\theta_{t+1} - \theta_{t})^T \nabla_{\theta} L(\theta_{t})\)

Le choix de la taille du batch :

• Descente de gradient stochastique (petit minibatch, \(M=1\)) : estimation bruitée, peu adaptée aux GPU
• Descente de gradient par batch (\(M=N\)) : Plus adaptée aux GPU. Mais plus sujette à une mauvaise généralisation (écart de généralisation) et aux minimums locaux (Keskar, Mudigere, Nocedal, Smelyanskiy, & Tang, 2017). En gros, il faut éviter les minimums aigus.

L’optimisation peut converger lentement ou même diverger si le taux d’apprentissage \(\epsilon\) n’est pas approprié.

Choisir un taux d’apprentissage

Bengio : “Le taux d’apprentissage optimal est généralement proche du plus grand taux d’apprentissage qui ne provoque pas la divergence du critère d’entraînement” (Bengio, 2012)

Karpathy “\(0.0003\) est le meilleur taux d’apprentissage pour Adam, sans hésitation.” (Twitter, 2016)

(Note : Adam sera discuté dans quelques diapositives)

Voir aussi :
- Recommandations pratiques pour l’entraînement basé sur le gradient des architectures profondes (Bengio, 2012)
- Backpropagation efficace (Y. A. LeCun et al., 1998)

Exemple de problème de régression

Configuration

• \(N=30\) échantillons générés avec : \[ y = 3 x + 2 + \mathcal{U}(-0.1, 0.1) \]
• Modèle : \(f_\theta(x) = \theta^T\begin{bmatrix} 1 \\ x\end{bmatrix}\),
• Perte L2 : \(L(y_i, f_{\theta}(x_i)) = (y_i - f_{\theta}(x_i))^2\)

Exemple avec SGD

Paramètres : \(\epsilon=0.005\), \(\theta_0 = \begin{bmatrix} 10 \\ 5\end{bmatrix}\)

Converge vers \(\theta_{\infty} = \begin{bmatrix} 1.9882 \\ 2.9975\end{bmatrix}\)

Méthodes du premier ordre : momentum

Algorithme : Atténuons les oscillations avec un filtrage passe-bas sur \(\nabla_{\theta}\)

• Commencer à \(\theta_0\), \(v_0 = 0\)
• pour chaque minibatch : \[ \begin{align*} v(t+1) &= \mu v(t) - \epsilon \nabla_{\theta} J(\theta(t))\\ \theta(t+1) &= \theta(t) + v(t+1) \end{align*} \]

En général, \(\mu \approx 0.9\) ou \(0.99\).

• en tant que moyenne mobile exponentielle, il filtre en passe-bas et atténue ainsi les oscillations dans les directions à variation rapide
• il peut accélérer (augmenter le taux d’apprentissage) dans les directions constantes (ou à faible courbure).
  Si \(\nabla_{\theta} J = g\), \(v(0) = 0\) \[ v(t) = -\epsilon g \sum_{i=0}^{t-1} \mu^i = -\epsilon g \frac{1-\mu^{t}}{1-\mu} \]

Voir aussi distill.pub. Notez que les frameworks peuvent implémenter des variations subtiles.

Exemple avec SGD et momentum

Paramètres : \(\epsilon=0.005\), \(\mu=0.6\), \(\theta_0 = \begin{bmatrix} 10 \\ 5\end{bmatrix}\)

Converge vers \(\theta_{\infty} = \begin{bmatrix} 1.9837 \\ 2.9933\end{bmatrix}\)

Méthodes du premier ordre : momentum de Nesterov

Idée Anticiper pour potentiellement corriger la mise à jour. Basé sur le gradient accéléré de Nesterov. Formulation de (Sutskever, Martens, Dahl, & Hinton, 2013)

Algorithme

• Commencer à \(\theta_0\)
• pour chaque minibatch : \[ \begin{align*} \overline{\theta}(t) &= \theta(t) + \mu v(t)\\ v(t+1) &= \mu v(t) - \epsilon \nabla_{\theta}J(\overline{\theta}(t))\\ \theta(t+1) &= \theta(t) + v(t+1) \end{align*} \]

Exemple avec SGD et momentum de Nesterov

Paramètres : \(\epsilon=0.005\), \(\mu=0.8\), \(\theta_0 = \begin{bmatrix} 10 \\ 5\end{bmatrix}\)

Converge vers \(\theta_{\infty} = \begin{bmatrix} 1.9738 \\ 2.9914\end{bmatrix}\)

Comparaison des méthodes du 1er ordre

Sur notre simple problème de régression

Premier ordre : taux d’apprentissage adaptatif

Vous devriez toujours adapter votre taux d’apprentissage avec un planificateur de taux d’apprentissage

• Diminution linéaire de \(\epsilon_0\) jusqu’à \(\epsilon_f\)
• diviser par deux le taux d’apprentissage lorsque l’erreur de validation cesse de s’améliorer
• diviser par deux le taux d’apprentissage selon un calendrier fixe (tous les \(50^e\) epochs)

Premier ordre adaptatif : taux d’apprentissage adaptatif

Certaines approches récentes changent l’idée de “diminution du taux d’apprentissage” (“conditions de Robbins-Monro”)

Voir (Smith, 2018), The 1cycle policy - S. Gugger

Descente de Gradient Stochastique avec Redémarrage (Loshchilov & Hutter, 2017)

Les meilleures performances peuvent être liées à l’atteinte de minimums plus plats (c’est-à-dire avec des prédictions moins sensibles que des minimums plus aigus). Les modèles atteints avant les redémarrages peuvent être moyennés (voir Snapshot ensemble).

Il semble également que des taux d’apprentissage initiaux élevés conduisent à de meilleurs modèles à long terme (Y. Li, Wei, & Ma, 2019).

Premier ordre adaptatif : Adagrad

Adagrad Gradient adaptatif (Duchi, Hazan, & Singer, 2011)

• Accumuler le carré du gradient \[ r(t+1) = r(t) + \nabla_{\theta}J(\theta(t)) \odot \nabla_{\theta}J(\theta(t))\\ \]
• Ajuster individuellement les taux d’apprentissage \[ \theta(t+1) = \theta(t) - \frac{\epsilon}{\delta + \sqrt{r(t+1)}} \odot \nabla_{\theta}J(\theta(t)) \]

Le \(\sqrt{.}\) est expérimentalement critique ; \(\delta \approx [1e-8, 1e-4]\) pour la stabilité numérique.

Petits gradients \(\rightarrow\) plus grand taux d’apprentissage pour avancer rapidement dans les directions plates
Grands gradients \(\rightarrow\) plus petit taux d’apprentissage pour calmer la descente dans les directions à forte courbure.

Premier ordre adaptatif : RMSprop

RMSprop Hinton (non publié, Coursera)

Idée : nous devrions utiliser une moyenne mobile exponentielle lors de l’accumulation du gradient.

• Accumuler le carré du gradient \[ r(t+1) = \rho r(t) + (1-\rho)\nabla_{\theta}J(\theta(t)) \odot \nabla_{\theta}J(\theta(t))\\ \]
• Ajuster individuellement les taux d’apprentissage \[ \theta(t+1) = \theta(t) - \frac{\epsilon}{\delta + \sqrt{r(t+1)}} \odot \nabla_{\theta}J(\theta(t)) \] \(\rho \approx 0.9\)

Premier ordre adaptatif : ADAM

Moments adaptatifs (ADAM) (Kingma & Ba, 2015)

• Comme pour momentum et RMSprop, on stocke les moyennes mobiles des gradients passés : \[ \begin{align*} m(t+1) &= \beta_1 m(t) + (1-\beta_1)\nabla_{\theta}J(\theta(t))\\ v(t+1) &= \beta_2 v(t) + (1-\beta_2)\nabla_{\theta}J(\theta(t))\odot \nabla_{\theta}J(\theta(t)) \end{align*} \] \(m(t)\) et \(v(t)\) sont les premier et second moments (non centrés) de \(\nabla_{\theta} J\). Ils sont corrigés du biais \(\hat{m}(t)\), \(\hat{v}(t)\), puis :

\[ \theta(t+1) = \theta(t) - \frac{\epsilon}{\delta + \sqrt{\hat{v}(t+1)}} \hat{m}(t+1) \]

Premier ordre : en résumé

(Goodfellow, Bengio, & Courville, 2016) Il n’y a actuellement pas de consensus […] aucun algorithme unique n’a émergé comme le meilleur […] les plus populaires et couramment utilisés incluent SGD, SGD avec momentum, RMSprop, RMSprop avec momentum, Adadelta et Adam.

Voir aussi Chap. 8 de (Goodfellow et al., 2016)

Le point de départ est important : XOR

XOR est facile, non ?

• Modèle : 2-4-1, activations sigmoïdales (super !); 17 paramètres
• Init : \(\mathcal{U}(−10, 10)\), biais=0 (hum hum)
• Perte : Entropie croisée binaire (super !)
• Optimiseur : SGD ( = 0.1, momentum=0.99 )

Mais cela échoue lamentablement (6/20 échecs). Tmax=1000

Le point de départ est important : XOR

XOR est facile, non ?

• Modèle : 2-4-1, activations sigmoïdales (super !); 17 paramètres

• Perte : Entropie croisée binaire (super !)
• Optimiseur : SGD ( = 0.1, momentum=0.99 )

Maintenant, c’est mieux (0/20 échecs). Tmax=1000

Standardiser vos entrées

La descente de gradient converge plus rapidement si vos données sont normalisées et décorrélées. Notez \(x_i \in \mathbb{R}^d\) comme étant vos données d’entrée, \(\hat{x}_i\) leurs données normalisées.

• Mise à l’échelle Min-Max \[ \forall i,j \hat{x}_{i,j} = \frac{x_{i,j} - \min_k x_{k,j}}{\max_k x_{k,j} - \min_k x_{k,j} + \epsilon} \]

• Normalisation Z-score (objectif : \(\hat{\mu}_j = 0, \hat{\sigma}_j = 1\)) \[ \forall i,j, \hat{x}_{i,j} = \frac{x_{i,j} - \mu_j}{\sigma_j + \epsilon} \]

• Blanchiment ZCA (objectif : \(\hat{\mu}_j = 0, \hat{\sigma}_j = 1\), \(\frac{1}{n-1} \hat{X} \hat{X}^T = I\))

\[ \hat{X} = W X, W = \frac{1}{\sqrt{n-1}} (XX^T)^{-1/2} \]

Normalisation Z-score / Standardisation des entrées

Souvenez-vous de notre régression linéaire : \(y = 3x+2+\mathcal{U}(-0.1, 0.1)\), perte L2, 30 échantillons 1D

Schémas d’initialisation

• Une bonne initialisation doit briser la symétrie : les schémas d’initialisation constants font que toutes les unités apprennent la même chose

• Une bonne initialisation doit commencer l’optimisation dans une région de faible capacité : réseau de neurones linéaire

• Un bon schéma d’initialisation doit préserver la distribution des activations et des gradients : gradients explosifs/vanissants

En pratique

Voir les implémentations nn.Linear ou nn.Conv2d.

Initialisation des poids en pratique (PyTorch)

Par défaut, les paramètres sont initialisés de manière aléatoire. Par exemple, dans torch.nn.Linear :

class Linear(torch.nn.Module):
    def __init__(self):
        ...
        self.reset_parameters()
    
    def reset_parameters(self) -> None:
        # Setting a=sqrt(5) in kaiming_uniform is the same as initializing with
        # uniform(-1/sqrt(in_features), 1/sqrt(in_features)). For details, see
        # https://github.com/pytorch/pytorch/issues/57109
        torch.nn.init.kaiming_uniform_(self.weight, a=math.sqrt(5))
        fan_in, _ = torch.init.calculate_fan_in_and_fan_out(self.weight)
        bound = 1/math.sqrt(fan_in)
        init.uniform_(self.bias, -bound, bound)

import torch.nn.init as init

class MyModel(torch.nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.classifier =  nn.Sequential(
            *linear_relu(input_size, 256),
            *linear_relu(256, 256),
            nn.Linear(256, num_classes)
        )
        self.init()

    def init(self):
        @torch.no_grad()
        def finit(m):
            if type(m) == nn.Linear:
                init.kaiming_uniform_(m.weight,
                                      a=0,
                                      mode='fan_in',
                                      nonlinearity='relu')
                m.bias.fill_(0.0)
        self.apply(finit)

def linear_relu(dim_in, dim_out):
    return [nn.Linear(dim_in, dim_out),
            nn.ReLU(inplace=True)]

Internal covariate shift

(Ioffe & Szegedy, 2015) a observé un changement dans la distribution des activations du réseau dû aux modifications des paramètres du réseau pendant l’entraînement.

Expérience : 3 couches entièrement connectées (100 unités), sigmoïde, sortie softmax, ensemble de données MNIST

Batch Normalization

Idée : standardiser les activations de chaque couche pour maintenir les mêmes distributions pendant l’entraînement (Ioffe & Szegedy, 2015)

• Le gradient doit être conscient de cette normalisation, sinon, il pourrait y avoir une explosion des paramètres (voir (Ioffe & Szegedy, 2015)) \(\rightarrow\) nous avons besoin d’une couche de normalisation différentiable.

• introduit une couche de normalisation par batch différentiable :

\[ z = g(W x + b) \rightarrow z = g(BN(W x)) \]

Batch normalization

Pendant l’entraînement

• mettre des couches BN partout dans le réseau, après la couche linéaire/conv, avant les ReLus
• évaluer les statistiques \(\mu, \sigma\) sur les minibatches (sur \(B\) pour \((B, N)\) et sur \(B\times H \times W\) pour \((B, C, H, W)\))
• mettre à jour une moyenne mobile exponentielle de la moyenne \(\mu_{\mathcal{B}}\) et de la variance \(\sigma^2_{\mathcal{B}}\)

model = MyModel()  # a pytorch nn.Module
# For training
model.train()
# For testing
model.test()

Termes de pénalité dans la fonction de perte

Couches Dropout

Introduites dans (Srivastava, Hinton, Krizhevsky, Sutskever, & Salakhutdinov, 2014):

Idée 1 : prévenir la co-adaptation. Un motif est robuste par lui-même, non pas grâce aux autres qui font partie du travail.
Idée 2 : moyenne de tous les sous-réseaux (apprentissage par ensemble)

Comment :

• Pour chaque mini-lot, annuler les activations cachées et d’entrée avec une probabilité \(p\) (\(p=0.5\) pour caché, \(p=0.2\) pour l’entrée). Au moment du test, multiplier chaque activation par \(p\)

• Dropout “inversé” : multiplier les activations conservées par \(p\) au moment de l’entraînement. Au moment du test, il suffit de faire un passage avant normal.

L1/L2/Dropout dans Pytorch

L1/L2

class MyModel(nn.Module):
    def __init__(..., l2_reg, ..):
        self.lin1 = nn.Linear(784, 256)
        self.lin2 = nn.Linear(256, 256)
        self.l2_reg = l2_reg

    def penalty(self):
        return l2_reg * (self.lin1.weight.norm(2) + ...) 

def train():
    ...
    optimizer.zero_grad()
    loss.backward()
    model.penalty().backward()

Dropout

import torch.nn as nn

class MyModel(nn.Module):
    def __init__(self, ..):
        self.classifier = nn.Sequential(
            *dropout_linear_relu(784, 128, 0.5),
            *dropout_linear_relu(128, 256, 0.5),
            nn.Linear(256, num_classes)
        )

def dropout_linear_relu(dim_in, dim_out, p_zeroed):
    return [nn.Dropout(p_zeroed),
            nn.Linear(dim_in, dim_out),
            nn.ReLU(inplace=True)]

Augmentation des données

Principe appliquer des perturbations aléatoires à l’entrée pour lesquelles vous pouvez calculer les conséquences sur la cible.

Vous pouvez utiliser des librairies dédiées, e.g. albumentations.ai

Augmentation des données en pratique

Par exemple, en utilisant le module torchvision.transforms.v2

import torchvision
from torchvision.transforms import v2

base_dataset = torchvision.datasets.Caltech101(
    root=root_dir,
    download=True,
    transform=None,
)

preprocess_transforms = [
    v2.ToImage(),
    GrayToRGB(),
    v2.Resize(128),  # Keeps the aspect ratio
    v2.RandomCrop(128),  # Crops the variable size to a fixed 128 x 128
    v2.ToDtype(torch.float32, scale=True),
    v2.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
]
augmentation_transforms = [
    v2.RandomHorizontalFlip(),
    v2.RandomRotation(10),
    v2.RandomResizedCrop(128, scale=(0.8, 1.0)),
    v2.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.2),
]

train_transforms = v2.Compose(preprocess_transforms + augmentation_transforms)
train_dataset = WrappedDataset(train_dataset, train_transforms)

class WrappedDataset(torch.utils.data.dataset.Dataset):
    def __init__(self, dataset, transform):
        super().__init__()
        self.dataset = dataset
        self.transform = transform

    def __getitem__(self, idx):
        xi, yi = self.dataset[idx]
        t_xi = self.transform(xi)
        return t_xi, yi

    def __repr__(self):
        return f"{self.__class__.__name__}(dataset={self.dataset}, transform={self.transform})"

    def __len__(self):
        return len(self.dataset)

Transfer learning

Principe :

• Préentraîner votre réseau de neurones sur un grand ensemble de données (potentiellement hors domaine)
• Affiner sur vos données limitées (finetuning)

Voir

• Pytorch Hub,
• timm,
• Hugging face hub

Dans le TP2, sur la ségmentation sémantique, nous utiliserons un modèle pré-entrainé comme encodeur.

Récemment, il y a une tendance à l’apprentissage auto-supervisé. Pré-entrainement sans labels utilisant des tâches prétextes.

Transfer learning en pratique

Par exemple, en utilisant timm

import timm

class TimmEncoder(nn.Module):
    def __init__(self, cin):
        super().__init__()
        self.model = timm.create_model(
            model_name="resnet18", in_chans=cin, pretrained=True
        )

    def forward(self, x):
        x = self.model.conv1(x)
        x = self.model.bn1(x)
        x = self.model.act1(x)
        x = self.model.maxpool(x)

        f1 = self.model.layer1(x)
        f2 = self.model.layer2(f1)
        f3 = self.model.layer3(f2)
        f4 = self.model.layer4(f3)

        return f4, [f1, f2, f3]

voir aussi la documentation

Références (1/2)

Voir plutôt le document en ligne references.pdf

Références (2/2)