Verschwindende und explodierende Gradienten

Deep Learning mit PyTorch für Fortgeschrittene

Michal Oleszak

Machine Learning Engineer

Verschwindende Gradienten

Gradienten werden beim Backward-Pass immer kleiner
Frühere Layer erhalten nur kleine Updates
Modell lernt nicht

Diagramme mit Gradienten-Größe vs. Layer-Index: In frühen Layern sind die Gradienten kleiner

Explodierende Gradienten

Gradienten werden immer größer
Parameter-Updates sind zu groß
Training divergiert

Diagramme mit Gradienten-Größe vs. Layer-Index: In frühen Layern sind die Gradienten größer

Lösung für instabile Gradienten

Saubere Gewichtsinitialisierung
Gute Aktivierungen
Batch-Normalisierung

Drei Schritte

Gewichte initialisieren

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]])

Gewichte initialisieren

Gute Initialisierung sorgt für:

Varianz der Layer-Eingaben = Varianz der Layer-Ausgaben
Gleiche Gradientenvarianz vor und nach einem Layer

Wie das geht, hängt von der Aktivierung ab:

Für ReLU & Ähnliches: He/Kaiming-Initialisierung

Gewichte initialisieren

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]])

He-/Kaiming-Initialisierung

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

He-/Kaiming-Initialisierung

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

Aktivierungsfunktionen

Ein Plot der ReLU-Funktion. Für Werte < 0 ist die Linie bei 0; für Werte > 0 steigt sie positiv.

Oft Standardaktivierung
nn.functional.relu()
Null für negative Eingaben – tote Neuronen

Ein Plot der ELU-Funktion. Ähnlich wie ReLU, aber mit weichem Übergang aus negativen in den positiven Bereich.

nn.functional.elu()
Nicht-null Gradienten für negative Werte – hilft gegen tote Neuronen
Mittlerer Output um 0 – hilft gegen verschwindende Gradienten

Batch-Normalisierung

Nach einem Layer:

Ausgaben normalisieren durch:
- Mittelwert abziehen
- Durch Standardabweichung teilen
Skalieren und verschieben mit gelernten Parametern

Das Modell lernt die optimale Eingabeverteilung je Layer:

Schnellere Verlustsenkung
Hilft gegen instabile Gradienten

Batch-Normalisierung

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)

        ...

Lass uns üben!

Deep Learning mit PyTorch für Fortgeschrittene