Gradients qui s'évanouissent et qui explosent

Apprentissage profond intermédiaire avec PyTorch

Michal Oleszak

Machine Learning Engineer

Gradients qui s'évanouissent

Les gradients diminuent à la rétropropagation
Les premières couches reçoivent de petites mises à jour
Le modèle n'apprend pas

Graphiques montrant la taille du gradient selon l'indice de couche : pour les premières couches, les gradients sont plus petits

Gradients qui explosent

Les gradients grossissent de plus en plus
Mises à jour de paramètres trop grandes
L'entraînement diverge

Graphiques montrant la taille du gradient selon l'indice de couche : pour les premières couches, les gradients sont plus grands

Solution aux gradients instables

Bonne initialisation des poids
Bonnes fonctions d'activation
Normalisation par lot

Trois étapes

Initialisation des poids

layer = nn.Linear(8, 1)
print(layer.weight)

Parameter containing:
tensor([[-0.0195,  0.0992,  0.0391,  0.0212,
         -0.3386, -0.1892, -0.3170,  0.2148]])

Initialisation des poids

Une bonne initialisation garantit :

Variance des entrées d'une couche = variance des sorties
Variance des gradients identique avant et après une couche

La méthode dépend de l'activation :

Pour ReLU et similaires, utiliser l'initialisation de He/Kaiming

Initialisation des poids

import torch.nn.init as init

init.kaiming_uniform_(layer.weight)
print(layer.weight)

Parameter containing:
tensor([[-0.3063, -0.2410,  0.0588,  0.2664,
          0.0502, -0.0136,  0.2274,  0.0901]])

Initialisation de He / Kaiming

init.kaiming_uniform_(self.fc1.weight)
init.kaiming_uniform_(self.fc2.weight)
init.kaiming_uniform_(
  self.fc3.weight,
  nonlinearity="sigmoid",
)

Initialisation de He / Kaiming

import torch.nn as nn
import torch.nn.init as init

class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(9, 16)
        self.fc2 = nn.Linear(16, 8)
        self.fc3 = nn.Linear(8, 1)


        init.kaiming_uniform_(self.fc1.weight)
        init.kaiming_uniform_(self.fc2.weight)
        init.kaiming_uniform_(
          self.fc3.weight,
          nonlinearity="sigmoid",
        )





    def forward(self, x):
        x = nn.functional.relu(self.fc1(x))
        x = nn.functional.relu(self.fc2(x))
        x = nn.functional.sigmoid(self.fc3(x))
        return x

Fonctions d'activation

Un tracé montrant la fonction ReLU. Pour les valeurs sous zéro, la ligne est horizontale à zéro ; au-dessus de zéro, la courbe a une pente positive.

Souvent l'activation par défaut
nn.functional.relu()
Zéro pour les entrées négatives : neurones « morts »

Un tracé montrant la fonction ELU. Semblable à ReLU, mais avec une transition lisse des valeurs négatives vers la région positive.

nn.functional.elu()
Gradients non nuls pour valeurs négatives : aide contre les neurones « morts »
Sortie moyenne près de zéro : aide contre l'évanouissement des gradients

Normalisation par lot

Après une couche :

Normaliser les sorties en :
- Soustrayant la moyenne
- Divisant par l'écart type
Redimensionner et décaler les sorties normalisées avec des paramètres appris

Le modèle apprend la distribution d'entrées optimale pour chaque couche :

Diminution de la perte plus rapide
Aide contre des gradients instables

Normalisation par lot

class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(9, 16)
        self.bn1 = nn.BatchNorm1d(16)

        ...


    def forward(self, x):
        x = self.fc1(x)
        x = self.bn1(x)
        x = nn.functional.elu(x)

        ...

Passons à la pratique !

Apprentissage profond intermédiaire avec PyTorch