AI & GPU
Wie man ResNet in PyTorch einfach versteht

Wie man ResNet in PyTorch einfach versteht

Einführung in ResNet

Was ist ResNet?

ResNet, kurz für Residual Neural Network, ist eine Deep-Learning-Architektur, die 2015 von Forschern bei Microsoft entwickelt wurde. Sie wurde konzipiert, um das Problem des Verschwindens/Explodierens des Gradienten zu lösen, ein häufig auftretendes Problem beim Training sehr tiefer neuronaler Netzwerke.

  1. Residual Neural Network: ResNet ist ein Typ neuronalen Netzwerks, das "Skip Connections" oder "Residual Connections" verwendet, um das Training viel tieferer Modelle zu ermöglichen. Diese Skip Connections erlauben dem Netzwerk, bestimmte Schichten zu umgehen und schaffen somit eine "Abkürzung", die zur Lösung des Problems des verschwindenden Gradienten beiträgt.

  2. Lösung des Problems des Verschwindens/Explodierens des Gradienten: In sehr tiefen neuronalen Netzwerken können die für das Backpropagation-Verfahren verwendeten Gradienten entweder verschwinden (sehr klein werden) oder explodieren (sehr groß werden), wenn sie sich durch das Netzwerk zurückpropagieren. Dies kann es dem Netzwerk erschweren, effektiv zu lernen, besonders in den tieferen Schichten. Die Skip Connections von ResNet helfen, dieses Problem zu lösen, indem sie den Gradienten ermöglichen, leichter durch das Netzwerk zu fließen.

Vorteile von ResNet

  1. Verbesserte Performance bei tiefen neuronalen Netzwerken: ResNet's Skip Connections ermöglichen das Training viel tieferer neuronaler Netzwerke, was zu deutlich verbesserten Leistungen bei unterschiedlichen Aufgaben wie Bildklassifikation, Objekterkennung und semantischer Segmentierung führen kann.

  2. Schnellere Konvergenz während des Trainings: Die Skip Connections in ResNet können auch zur schnelleren Konvergenz des Netzwerks während des Trainingsprozesses beitragen, indem sie den Gradienten ermöglichen, effizienter durch das Netzwerk zu fließen.

Implementierung von ResNet in PyTorch

Einrichtung der Umgebung

  1. Installation von PyTorch: Um mit der Implementierung von ResNet in PyTorch zu beginnen, müssen Sie zuerst die PyTorch-Bibliothek installieren. Sie können PyTorch von der offiziellen Website (https://pytorch.org/ (opens in a new tab)) herunterladen und installieren, basierend auf Ihrem Betriebssystem und der verwendeten Python-Version.

  2. Importieren der benötigten Bibliotheken: Sobald Sie PyTorch installiert haben, müssen Sie die benötigten Bibliotheken für Ihr Projekt importieren. Dazu gehören in der Regel PyTorch, NumPy und andere Bibliotheken, die Sie möglicherweise für die Datenverarbeitung, Visualisierung oder andere Aufgaben benötigen.

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import numpy as np
import matplotlib.pyplot as plt

Definition der ResNet-Architektur

Verständnis der grundlegenden Bausteine

  1. Faltungs­schichten: ResNet verwendet, wie viele andere Deep-Learning-Modelle, Faltungs­schichten als Hauptbausteine für die Merkmalsextraktion.

  2. Batch-Normalisierung: ResNet verwendet auch Batch-Normalisierungsschichten, um den Trainingsprozess zu stabilisieren und die Leistung des Modells zu verbessern.

  3. Aktivierungsfunktionen: Die ResNet-Architektur verwendet typischerweise ReLU (Rectified Linear Unit) als Aktivierungsfunktion, um Nichtlinearität in das Modell einzuführen.

  4. Pooling-Schichten: ResNet kann auch Pooling-Schichten wie Max-Pooling oder Durchschnitts-Pooling enthalten, um die räumlichen Dimensionen der Merkmalskarten zu reduzieren und Translation-Invarianz einzuführen.

Implementierung des ResNet-Blocks

  1. Residuale Verbindung: Die Schlüsselinnovation von ResNet ist die residuale Verbindung, die es dem Netzwerk ermöglicht, bestimmte Schichten zu umgehen, indem die Eingabe einer Schicht zu ihrer Ausgabe hinzugefügt wird. Dies hilft, das Problem des verschwindenden Gradienten zu mildern.
class ResNetBlock(nn.Module):
    def __init__(self, in_channels, out_channels, stride=1):
        super(ResNetBlock, self).__init__()
        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)
        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels)
        
        self.shortcut = nn.Sequential()
        if stride != 1 or in_channels != out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(out_channels)
            )
 
    def forward(self, x):
        residual = self.shortcut(x)
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
        out = self.conv2(out)
        out = self.bn2(out)
        out += residual
        out = self.relu(out)
        return out
  1. Shortcut-Verbindung: Neben der residuellen Verbindung verwendet ResNet auch eine "Shortcut-Verbindung", um die Dimensionen der Eingabe und Ausgabe des ResNet-Blocks bei Bedarf anzupassen.

Konstruktion des vollständigen ResNet-Modells

  1. Stapeln der ResNet-Blöcke: Um das vollständige ResNet-Modell zu erstellen, müssen Sie mehrere ResNet-Blöcke übereinander stapeln und dabei die Anzahl der Schichten und der Filter in jedem Block anpassen.

  2. Anpassen der Anzahl der Schichten: ResNet-Modelle gibt es in verschiedenen Varianten wie ResNet-18, ResNet-34, ResNet-50, ResNet-101 und ResNet-152, die unterschiedliche Anzahlen von Schichten haben. Die Anzahl der Schichten beeinflusst die Komplexität und Leistung des Modells.

Implementierung von ResNet-18 in PyTorch

Definition des ResNet-18-Modells

  1. Eingangsschicht: Die Eingangsschicht des ResNet-18-Modells akzeptiert in der Regel ein Bild einer bestimmten Größe, z. B. 224x224 Pixel.

  2. Faltungsschichten: Die anfänglichen Faltungsschichten des ResNet-18-Modells extrahieren grundlegende Merkmale aus dem Eingangsbild.

  3. ResNet-Blöcke: Der Kern des ResNet-18-Modells besteht aus der Stapelung mehrerer ResNet-Blöcke, die residuale Verbindungen verwenden, um das Training eines tieferen Netzwerks zu ermöglichen.

  4. Vollständig verbundene Schicht: Nach den Faltungsschichten und ResNet-Blöcken wird das Modell eine vollständig verbundene Schicht haben, um die endgültige Klassifikation oder Vorhersageaufgabe durchzuführen.

  5. Ausgabeschicht: Die Ausgabeschicht des ResNet-18-Modells wird eine Anzahl von Einheiten haben, die der Anzahl der Klassen im zu lösenden Problem entspricht.

class ResNet18(nn.Module):
    def __init__(self, num_classes=10):
        super(ResNet18, self).__init__()
        self.in_channels = 64
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
 
        self.layer1 = self._make_layer(64, 64, 2, stride=1)
        self.layer2 = self._make_layer(64, 128, 2, stride=2)
        self.layer3 = self._make_layer(128, 256, 2, stride=2)
        self.layer4 = self._make_layer(256, 512, 2, stride=2)
 
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(512, num_classes)
 
    def _make_layer(self, in_channels, out_channels, num_blocks, stride):
        layers = []
        layers.append(ResNetBlock(in_channels, out_channels, stride))
        self.in_channels = out_channels
        for i in range(1, num_blocks):
            layers.append(ResNetBlock(out_channels, out_channels))
        return nn.Sequential(*layers)
 
    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x)
 
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)
 
        x = self.avgpool(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x

Initialisierung des Modells

Um eine Instanz des ResNet-18-Modells zu erstellen, können Sie einfach die Klasse ResNet18 instanziieren:

model = ResNet18(num_classes=10)

Ausgeben der Modellzusammenfassung

Eine Zusammenfassung der Modellarchitektur von ResNet-18 können Sie mit der Funktion summary() aus der Bibliothek torchsummary ausgeben:

from torchsummary import summary
summary(model, input_size=(3, 224, 224))

Dies liefert eine detaillierte Übersicht über die Schichten des Modells, einschließlich der Anzahl der Parameter und der Ausgabeform jeder Schicht.

Training des ResNet-18-Modells

Vorbereitung des Datensatzes

Herunterladen und Laden des Datensatzes

Für dieses Beispiel verwenden wir den CIFAR-10-Datensatz, der ein weit verbreiteter Benchmark für Bildklassifikationsaufgaben ist. Sie können den Datensatz mit dem Modul torchvision.datasets.CIFAR10 herunterladen:

# CIFAR-10-Datensatz herunterladen und laden
train_dataset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transforms.ToTensor())
test_dataset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transforms.ToTensor())

Vorverarbeitung der Daten

Vor dem Training des Modells müssen Sie die Daten vorverarbeiten, z. B. die Pixelwerte normalisieren und Data-Augmentation-Techniken anwenden:

# Definition der Daten-Transformationen
transform_train = transforms.Compose([
    transforms.RandomCrop(32, padding=4),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])
 
transform_test = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])
 
# Erstellung der Datenaufbereiter
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=128, shuffle=True, num_workers=2)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=100, shuffle=False, num_workers=2)

Definition der Trainingsschleife

Festlegen des Geräts (CPU oder GPU)

Um von der GPU-Beschleunigung profitieren zu können, können Sie das Modell und die Daten auf die GPU übertragen:

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = model.to(device)

Definition der Verlustfunktion und des Optimierers

Nachfolgend müssen Sie die Verlustfunktion und den Optimierer definieren, die während des Trainingsprozesses verwendet werden:

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.1, momentum=0.9, weight_decay=5e-4)

Implementierung der Trainingsschleife

Die Trainingsschleife umfasst die folgenden Schritte:

  1. Vorwärtsdurchgang durch das Modell
  2. Berechnung des Verlusts
  3. Rückwärtspropagation der Gradienten
  4. Aktualisierung der Modellparameter
  5. Verfolgung des Trainingsverlusts und der Genauigkeit
num_epochs = 100
train_losses = []
train_accuracies = []
val_losses = []
val_accuracies = []
 
for epoch in range(num_epochs):
    # Trainingsphase
    model.train()
    running_loss = 0.0
    correct = 0
    total = 0
    for i, (inputs, labels) in enumerate(train_loader):
        inputs, labels = inputs.to(device), labels.to(device)
 
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
 
## Optimierung des Modells
 
### Regularisierung
 
Regularisierung ist eine Technik, die verwendet wird, um Overfitting in Deep-Learning-Modellen zu vermeiden. Overfitting tritt auf, wenn ein Modell auf den Trainingsdaten gut abschneidet, aber nicht auf neuen, unbekannten Daten generalisiert. Regularisierungstechniken helfen dem Modell, besser zu generalisieren, indem sie eine Strafe für die Komplexität einführen oder Lärm in den Trainingsprozess einbringen.
 
Eine beliebte Regularisierungstechnik ist die L2-Regularisierung, auch als Gewichtsabnahme bekannt. Diese Methode fügt der Verlustfunktion einen Strafterm hinzu, der proportional zum quadrierten Betrag der Gewichte des Modells ist. Die Verlustfunktion mit L2-Regularisierung kann wie folgt geschrieben werden:

Verlust = ursprünglicher Verlust + lambda * sum(w^2)


wobei `lambda` die Regularisierungsstärke ist und `w` die Gewichte des Modells sind.

Eine weitere beliebte Regularisierungstechnik ist das Dropout. Dropout setzt während des Trainings einen Teil der Aktivierungen in einer Schicht zufällig auf Null, was die Kapazität des Modells reduziert und es zwingt, robustere Merkmale zu erlernen. Dies hilft, Overfitting zu verhindern und die Generalisierungsleistung des Modells zu verbessern.

Hier ist ein Beispiel, wie man Dropout in einem PyTorch-Modell implementiert:

```python
import torch.nn as nn

class MeinModell(nn.Module):
    def __init__(self):
        super(MeinModell, self).__init__()
        self.fc1 = nn.Linear(64, 128)
        self.dropout = nn.Dropout(p=0.5)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.fc1(x)
        x = self.dropout(x)
        x = self.fc2(x)
        return x

In diesem Beispiel wird die Dropout-Schicht nach der ersten vollständig verbundenen Schicht mit einer Ausfallrate von 0,5 angewendet, was bedeutet, dass während des Trainings 50% der Aktivierungen zufällig auf Null gesetzt werden.

Optimierungsalgorithmen

Die Wahl des Optimierungsalgorithmus kann einen erheblichen Einfluss auf die Leistung und Konvergenz eines Deep-Learning-Modells haben. Hier sind einige beliebte Optimierungsalgorithmen, die in Deep Learning verwendet werden:

Stochastic Gradient Descent (SGD)

SGD ist der einfachste Optimierungsalgorithmus, bei dem die Gradienten anhand eines einzelnen Trainingsbeispiels oder einer kleinen Batch von Beispielen berechnet und die Gewichte entsprechend aktualisiert werden. SGD kann langsam konvergieren, ist aber einfach und effektiv.

import torch.optim as optim
 
modell = MeinModell()
optimizer = optim.SGD(modell.parameters(), lr=0.01, momentum=0.9)

Adam

Adam (Adaptive Moment Estimation) ist ein fortschrittlicherer Optimierungsalgorithmus, der adaptive Lernraten für jeden Parameter berechnet. Er kombiniert die Vorteile von Momentum und RMSProp und ist daher eine beliebte Wahl für viele Deep-Learning-Aufgaben.

optimizer = optim.Adam(modell.parameters(), lr=0.001)

AdaGrad

AdaGrad (Adaptive Gradient) ist ein Optimierungsalgorithmus, der die Lernrate für jeden Parameter basierend auf den historischen Gradienten anpasst. Er ist für spärliche Daten effektiv, kann aber im Laufe der Zeit unter einer aggressiven Reduzierung der Lernrate leiden.

optimizer = optim.Adagrad(modell.parameters(), lr=0.01)

RMSProp

RMSProp (Root Mean Square Propagation) ist ein weiterer Optimierungsalgorithmus zur adaptiven Lernratenanpassung, der einen gleitenden Durchschnitt der quadratischen Gradienten beibehält. Er ist besonders nützlich für nicht-stationäre Ziele, wie sie in rekurrenten neuronalen Netzwerken vorkommen.

optimizer = optim.RMSprop(modell.parameters(), lr=0.001, alpha=0.99)

Die Wahl des Optimierungsalgorithmus hängt von dem spezifischen Problem, der Struktur des Modells und den Eigenschaften der Daten ab. Es ist oft eine gute Idee, verschiedene Algorithmen auszuprobieren und ihre Leistung auf Ihrer Aufgabe zu vergleichen.

Transfer Learning

Transfer Learning ist eine Technik, bei der ein auf einem großen Datensatz trainiertes Modell als Ausgangspunkt für ein Modell auf einer anderen, aber verwandten Aufgabe verwendet wird. Dies kann besonders nützlich sein, wenn der Ziel-Datensatz klein ist, da es dem Modell ermöglicht, die auf dem größeren Datensatz gelernten Merkmale zu nutzen.

Ein häufiger Ansatz für das Transfer Learning in Deep Learning besteht darin, ein vortrainiertes Modell zu verwenden, wie es zum Beispiel für populäre Computer-Vision- oder Natural Language Processing-Aufgaben verfügbar ist, und das Modell auf dem Ziel-Datensatz zu feinabstimmen. Dabei werden die unteren Schichten des vortrainierten Modells eingefroren und nur die oberen Schichten mit den neuen Daten trainiert.

Hier ist ein Beispiel, wie man ein vortrainiertes ResNet-Modell für eine Bildklassifikationsaufgabe in PyTorch feinabstimmt:

import torchvision.models as models
import torch.nn as nn
 
# Das vortrainierte ResNet-Modell laden
resnet = models.resnet18(pretrained=True)
 
# Die Parameter des vortrainierten Modells einfrieren
for param in resnet.parameters():
    param.requires_grad = False
 
# Die letzte Schicht durch eine neue vollständig verbundene Schicht ersetzen
num_features = resnet.fc.in_features
resnet.fc = nn.Linear(num_features, 10)  # Annahme: 10 Klassen
 
# Das Modell auf dem neuen Datensatz trainieren
optimizer = optim.Adam(resnet.fc.parameters(), lr=0.001)

In diesem Beispiel laden wir zuerst das vortrainierte ResNet18-Modell und frieren die Parameter der unteren Schichten ein. Dann ersetzen wir die letzte vollständig verbundene Schicht durch eine neue Schicht mit der entsprechenden Anzahl von Ausgaben für unsere Ziel-Aufgabe (in diesem Fall 10 Klassen). Schließlich trainieren wir das Modell mit dem Adam-Optimierer und aktualisieren nur die Parameter der neuen vollständig verbundenen Schicht.

Transfer Learning kann die Leistung von Deep-Learning-Modellen erheblich verbessern, insbesondere wenn der Ziel-Datensatz klein ist. Es ist eine leistungsstarke Technik, die Zeit und Ressourcen bei der Modellentwicklung sparen kann.

Modellinterpretierbarkeit

Mit zunehmendem Komplexitätsgrad und Verbreitung von Deep-Learning-Modellen gewinnt die Interpretierbarkeit von Modellen immer mehr an Bedeutung. Interpretierbarkeit bezieht sich auf die Fähigkeit, den internen Entscheidungsprozess eines Modells zu verstehen und zu erklären.

Eine beliebte Technik zur Verbesserung der Modellinterpretierbarkeit ist die Verwendung von Aufmerksamkeitsmechanismen. Aufmerksamkeit ermöglicht es dem Modell, sich auf die relevantesten Teile der Eingabe zu konzentrieren, wenn eine Vorhersage getroffen wird, und kann visualisiert werden, um zu verstehen, welche Merkmale das Modell verwendet.

Hier ist ein Beispiel, wie man einen Aufmerksamkeitsmechanismus in einem PyTorch-Modell für eine Natural Language Processing-Aufgabe implementiert:

import torch.nn as nn
import torch.nn.functional as F
 
class AufmerksamkeitsModell(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim):
        super(AufmerksamkeitsModell, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.lstm = nn.LSTM(embedding_dim, hidden_dim, bidirectional=True, batch_first=True)
        self.aufmerksamkeit = nn.Linear(hidden_dim * 2, 1)
 
    def forward(self, input_ids):
        # Die Eingabe einbetten
        embedded = self.embedding(input_ids)
 
        # Die eingebettete Eingabe durch den LSTM schicken
        lstm_output, _ = self.lstm(embedded)
 
        # Die Aufmerksamkeitsgewichte berechnen
        aufmerksamkeitsgewichte = F.softmax(self.aufmerksamkeit(lstm_output), dim=1)
 
        # Die gewichtete Summe der LSTM-Ausgaben berechnen
        context = torch.sum(aufmerksamkeitsgewichte * lstm_output, dim=1)
 
        return context

In diesem Beispiel wird der Aufmerksamkeitsmechanismus als lineare Schicht implementiert, die die LSTM-Ausgaben als Eingabe verwendet und eine Reihe von Aufmerksamkeitsgewichten produziert. Diese Gewichte werden dann verwendet, um die gewichtete Summe der LSTM-Ausgaben zu berechnen, die die endgültige Ausgabe des Modells ist.

Durch die Visualisierung der Aufmerksamkeitsgewichte können Sie Einblicke gewinnen, auf welche Teile der Eingabe das Modell bei der Vorhersage fokussiert ist. Dies kann Ihnen helfen, den Entscheidungsprozess des Modells zu verstehen und potenzielle Verzerrungen oder Verbesserungsmöglichkeiten zu identifizieren.

Eine andere Technik zur Verbesserung der Modellinterpretierbarkeit ist die Analyse der Merkmalsbedeutung. Dies beinhaltet die Identifizierung der wichtigsten Merkmale, die das Modell zur Vorhersage verwendet. Eine beliebte Methode dafür sind die Shapley-Werte, die eine Möglichkeit bieten, den Beitrag jedes Merkmals zum Modellausgang zu quantifizieren.

Die Verbesserung der Modellinterpretierbarkeit ist ein wichtiges Forschungsgebiet im Bereich Deep Learning, da dies dazu beitragen kann, Vertrauen in diese leistungsstarken Modelle aufzubauen und sicherzustellen, dass sie verantwortungsvoll eingesetzt werden.

Fazit

In diesem Tutorial haben wir eine Reihe von Themen im Zusammenhang mit Deep Learning behandelt, darunter Modelloptimierung, Transfer Learning und Modellinterpretierbarkeit. Wir haben Techniken wie Regularisierung, Optimierungsalgorithmen und Aufmerksamkeitsmechanismen diskutiert und Beispiele dafür gegeben, wie diese Konzepte in PyTorch implementiert werden können.

Da sich Deep Learning ständig weiterentwickelt und immer weiter verbreitet wird, ist es wichtig, diese fortgeschrittenen Themen zu verstehen und sie auf eigene Projekte anwenden zu können. Durch die Beherrschung dieser Techniken sind Sie besser gerüstet, um leistungsstarke, robuste und interpretierbare Deep-Learning-Modelle zu entwickeln, die eine Vielzahl von Problemen lösen können.

Denken Sie daran, dass Deep Learning ein sich schnell veränderndes Feld ist und es wichtig ist, mit den neuesten Forschungsergebnissen und bewährten Verfahren auf dem Laufenden zu bleiben. Erforschen Sie weiter, experimentieren Sie und lernen Sie, und Sie werden den Weg zum Deep Learning-Experten einschlagen.

Wie man MLflow einfach auf Databricks nutzen kannSo nutzen Sie einfach die GPU-Fähigkeiten von TensorFlow