PyTorch CNN Tutorial: Faltungsneuronale Netze in Python aufbauen und trainieren

Faltungsneuronale Netze (Convolutional Neural Networks, CNNs) sind ein Eckpfeiler der modernen Computer Vision und ermöglichen Anwendungen wie Bilderkennung, Gesichtserkennung und selbstfahrende Autos. Diese Netzwerke wurden entwickelt, um automatisch Muster und Merkmale aus Bildern zu extrahieren, was sie leistungsfähiger macht als herkömmliche maschinelle Lernverfahren für visuelle Aufgaben.

In diesem Tutorial werden wir ein CNN mit PyTorch implementieren, einem Deep-Learning-Framework, das sowohl benutzerfreundlich als auch sehr effizient für Forschungs- und Produktionsanwendungen ist.

Voraussetzungen: Deep Learning und PyTorch

Bevor wir uns mit den Details von CNNs beschäftigen, musst du mit dem Bereich des Deep Learning und den Python-Bibliotheken vertraut sein, die wir bei der Einrichtung unserer Umgebung verwenden werden.

Deep Learning ist ein Teilbereich des maschinellen Lernens, bei dem die grundlegende Modellstruktur ein Netzwerk aus Eingaben, versteckten Schichten und Ausgaben ist. Ein solches Netz kann eine oder mehrere versteckte Schichten haben. Die ursprüngliche Intuition hinter Deep Learning war es, Modelle zu entwickeln, die sich daran orientieren, wie das menschliche Gehirn lernt: durch miteinander verbundene Zellen, die Neuronen. Deshalb nennen wir Deep-Learning-Modelle auch weiterhin "neuronale" Netzwerke. Diese mehrschichtigen Modellstrukturen benötigen viel mehr Daten zum Lernen als andere überwachte Lernmodelle, um Muster aus den unstrukturierten Daten abzuleiten. Normalerweise sprechen wir über mindestens hunderttausende von Datenpunkten.

Es gibt zwar mehrere Frameworks und Pakete für die Implementierung von Deep-Learning-Algorithmen, aber wir werden uns auf PyTorch konzentrieren, eines der beliebtesten und am besten gewarteten Frameworks. PyTorch wird nicht nur von Deep-Learning-Ingenieuren in der Industrie verwendet, sondern ist auch ein beliebtes Werkzeug unter Forschern. Viele Deep Learning-Arbeiten werden mit PyTorch veröffentlicht. Sie ist intuitiv und benutzerfreundlich gestaltet und hat viele Gemeinsamkeiten mit der Python-Bibliothek NumPy. 

Wenn du eine Einführung in diese Konzepte brauchst, solltest du dich noch heute für den Kurs Deep Learning mit PyTorch anmelden. 

Was ist ein Convolutional Neural Network (CNN)?

Faltungsneuronale Netze, auch CNN oder ConvNet genannt, sind eine spezielle Art von tiefen neuronalen Netzen, die sich gut für Computer Vision Aufgaben eignen. Die Erfindung von CNNs geht auf die 1980er Jahre zurück. Sie wurden jedoch erst in den 2010er Jahren zum Mainstream, nachdem die Implementierung von Grafikprozessoren (GPUs) einen Durchbruch bei der Datenverarbeitung gebracht hatte. Tatsächlich verhalf die schnelle Verbreitung von CNNs dem Bereich der neuronalen Netze zu neuer Popularität und führte zur sogenannten "dritten Welle neuronaler Netze", die wir heute noch erleben.

CNNs sind speziell vom biologischen visuellen Kortex inspiriert. Die Hirnrinde hat kleine Zellregionen, die für bestimmte Bereiche des Gesichtsfeldes empfindlich sind. Diese Idee wurde durch ein fesselndes Experiment von Hubel und Wiesel im Jahr 1962 erweitert. 

CNNs versuchen, diese Eigenschaft nachzubilden, indem sie komplexe neuronale Netze schaffen, die aus verschiedenen, aufgabenspezifischen Schichten bestehen. CNNs werden "feed-forward" genannt, weil die Informationen direkt durch das Modell fließen. Im Gegensatz zu anderen Modellen, die Techniken wie Backpropagation verwenden, gibt es keine Rückkopplungsverbindungen, bei denen die Ausgaben des Modells in sich selbst zurückgeführt werden.

Ein CNN besteht in der Regel aus den folgenden Schichten:

Faltungsschicht

Dies ist der erste Baustein eines CNN. Wie der Name schon sagt, ist die wichtigste mathematische Aufgabe die Faltung, d.h. die Anwendung einer Schiebefensterfunktion auf eine Matrix von Pixeln, die ein Bild darstellen. Die gleitende Funktion, die auf die Matrix angewendet wird, heißt Kernel oder Filter. In der Faltungsschicht werden mehrere gleich große Filter angewendet, und jeder Filter wird verwendet, um ein bestimmtes Muster aus dem Bild zu erkennen, z. B. die Krümmung der Ziffern, die Kanten, die gesamte Form der Ziffern und mehr. 

Aktivierungsfunktion

Normalerweise wird nach jeder Faltungsoperation eine ReLU-Aktivierungsfunktion angewendet. Diese Funktion hilft dem Netz, nicht-lineare Beziehungen zwischen den Merkmalen im Bild zu erlernen, wodurch das Netz bei der Erkennung verschiedener Muster robuster wird. Es hilft auch, das Problem der verschwindenden Steigung zu entschärfen. 

Poolingschicht

Das Ziel der Pooling-Schicht ist es, die wichtigsten Merkmale aus der gefalteten Matrix herauszufiltern. Dies geschieht durch die Anwendung einiger Aggregationsoperationen, die die Dimension der Merkmalskarte (gefaltete Matrix) reduzieren und dadurch den Speicherbedarf beim Training des Netzes verringern.  Das Pooling ist auch wichtig, um die Überanpassung abzuschwächen.

Vollständig verbundene Schichten

Diese Schichten befinden sich in der letzten Schicht des neuronalen Faltungsnetzwerks, und ihre Eingänge entsprechen der abgeflachten eindimensionalen Matrix, die von der letzten Pooling-Schicht erzeugt wurde. Für die Nichtlinearität werden ReLU-Aktivierungsfunktionen auf sie angewendet. 

Architektur des neuronalen Faltungsnetzwerks. Quelle: DataCamp

In unserem Tutorial Convolutional Neural Networks in Python findest du eine genauere Erklärung der Mathematik hinter CNNs .

Warum CNNs für die Bildklassifizierung verwenden?

Faltungsneuronale Netze sind eine der einflussreichsten Innovationen auf dem Gebiet der Computer Vision. Sie haben viel besser abgeschnitten als traditionelle maschinelle Lernmodelle wie SVMs und Entscheidungsbäume und haben die besten Ergebnisse erzielt. 

Darüber hinaus verleihen die Faltungsschichten den CNNs ihre translationsinvarianten Eigenschaften, die sie in die Lage versetzen, Muster und Merkmale aus den Daten zu erkennen und zu extrahieren, unabhängig von Veränderungen der Position, der Ausrichtung, des Maßstabs oder der Translation.


CNNs haben sich in vielen verschiedenen realen Fallstudien und Anwendungen bewährt, z. B:

• Bildklassifizierung, Objekterkennung, Segmentierung, Gesichtserkennung;
• Selbstfahrende Autos, die CNN-basierte Sichtsysteme nutzen;
• Klassifizierung der Kristallstruktur mithilfe eines neuronalen Faltungsnetzwerks;
• Sicherheitskamerasysteme.

Neben den Aufgaben der Bildklassifizierung sind CNNs vielseitig und können in einer Reihe von anderen Bereichen eingesetzt werden, z. B. bei der Verarbeitung natürlicher Sprache, der Zeitreihenanalyse und der Spracherkennung.

Implementierung eines CNN mit PyTorch

Jetzt, wo du mit der Theorie der CNNs vertraut bist, können wir uns die Hände schmutzig machen. In diesem Abschnitt werden wir ein einfaches CNN mit PyTorch bauen und trainieren. Unser Ziel ist es, ein Modell zur Klassifizierung von Ziffern in Bildern zu entwickeln. Um unser Modell zu trainieren und zu testen, verwenden wir den berühmten MNIST-Datensatz, eine Sammlung von 70.000 28x28-Graustufenbildern mit handgeschriebenen Ziffern.

1. Erforderliche Bibliotheken importieren

Unten findest du die Bibliotheken, die wir für dieses Tutorial verwenden werden. Im Wesentlichen werden wir PyTorch nutzen, um unser CNN zu bauen, und das PyTorch Computer Vision Modul torchvision, um den MNIST-Datensatz herunterzuladen und zu laden. Schließlich werden wir auch torchmetrics nutzen, um die Leistung unseres Modells zu bewerten.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt


import torch
from torch import optim
from torch import nn
from torch.utils.data import DataLoader
from tqdm import tqdm

# !pip install torchvision
import torchvision

import torch.nn.functional as F
import torchvision.datasets as datasets
import torchvision.transforms as transforms

# !pip install torchmetrics
import torchmetrics

2. Laden und Vorverarbeiten des Datensatzes

PyTorch verfügt außerdem über ein reichhaltiges Ökosystem an Tools und Erweiterungen, darunter torchvision, ein Modul für Computer Vision. Torchvision enthält mehrere Bilddatensätze, die zum Trainieren und Testen neuronaler Netze verwendet werden können. In unserem Lernprogramm werden wir den MNIST-Datensatz verwenden. 

Zunächst laden wir den MNIST-Datensatz herunter und konvertieren ihn in einen Tensor, die zentrale Datenstruktur in PyTorch, ähnlich wie NumPy-Arrays, aber mit GPU-Beschleunigungsfunktionen.

Außerdem verwenden wir den DataLoader, um die Trainings- und Testdatensätze zu stapeln und zu mischen. Ein PyTorch DataLoader kann aus einem Dataset erstellt werden, um Daten zu laden, sie in Stapel aufzuteilen und bei Bedarf Transformationen an den Daten vorzunehmen. Dann ergibt sich eine Datenprobe, die für das Training bereit ist. Im folgenden Code laden wir die Daten und speichern sie in DataLoaders mit einer Stapelgröße von 60 Bildern:

batch_size = 60

train_dataset = datasets.MNIST(root="dataset/", download=True, train=True, transform=transforms.ToTensor())

train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)

test_dataset = datasets.MNIST(root="dataset/", download=True, train=False, transform=transforms.ToTensor())

test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=True)

Optional kann der Trainingsdatensatz weiter in zwei Partitionen aufgeteilt werden: Training und Validierung. Die Validierung ist eine Technik, die beim Deep Learning verwendet wird, um die Leistung des Modells während des Trainings zu bewerten. Sie hilft dabei, eine mögliche Über- oder Unteranpassung unserer Modelle zu erkennen, und ist besonders hilfreich bei der Optimierung von Hyperparametern. Der Einfachheit halber werden wir die Validierung in diesem Lernprogramm jedoch nicht verwenden. Wenn du mehr über die Validierung erfahren möchtest, kannst du dir eine ausführliche Erklärung in unserem Kurs Einführung in Deep Learning mit PyTorch ansehen.

Jetzt, wo wir unsere Daten haben, wollen wir sehen, wie ein zufälliger Stapel von Ziffern aussieht:

def imshow(img):
   npimg = img.numpy()
   plt.imshow(np.transpose(npimg, (1, 2, 0)))
   plt.show()

# get some random training images
dataiter = iter(dataloader_train)
images, labels = next(dataiter)
labels
# show images
imshow(torchvision.utils.make_grid(images))

3. Festlegen der CNN-Architektur

Um das Klassifizierungsproblem zu lösen, werden wir die Klasse nn.Module nutzen, den PyTorch-Baustein zur intuitiven Erstellung anspruchsvoller neuronaler Netzarchitekturen. 

Im folgenden Code erstellen wir eine Klasse namens CNN, die die Eigenschaften der Klasse nn.Module erbt. Die Klasse CNN ist die Blaupause eines CNN mit zwei Faltungsschichten, gefolgt von einer voll verknüpften Schicht. 

In PyTorch verwenden wir nn.Conv2d, um eine Faltungsschicht zu definieren. Wir übergeben ihm die Anzahl der Input- und Output-Feature-Maps. Wir stellen auch einige Parameter ein, damit die Faltungsschicht funktioniert, z. B. die Kernel- oder Filtergröße und das Padding. 

Als Nächstes fügen wir eine Max-Pooling-Ebene mit nn.MaxPool2d hinzu. ​Darin schieben wir ein nicht überlappendes Fenster über die Ausgabe der vorherigen Faltungsschicht. An jeder Position wählen wir den maximalen Wert aus dem Fenster aus, den wir weitergeben. Durch diesen Vorgang werden die räumlichen Dimensionen der Merkmalskarten reduziert, was die Anzahl der Parameter und die Rechenkomplexität des Netzes verringert. Zum Schluss fügen wir eine vollständig verbundene lineare Schicht hinzu. 

Die Funktion forward() legt fest, wie die verschiedenen Schichten verbunden werden, indem sie mehrere ReLU-Aktivierungsfunktionen nach jeder Faltungsschicht hinzufügt.

class CNN(nn.Module):
   def __init__(self, in_channels, num_classes):

       """
       Building blocks of convolutional neural network.

       Parameters:
           * in_channels: Number of channels in the input image (for grayscale images, 1)
           * num_classes: Number of classes to predict. In our problem, 10 (i.e digits from  0 to 9).
       """
       super(CNN, self).__init__()

       # 1st convolutional layer
       self.conv1 = nn.Conv2d(in_channels=in_channels, out_channels=8, kernel_size=3, padding=1)
       # Max pooling layer
       self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
       # 2nd convolutional layer
       self.conv2 = nn.Conv2d(in_channels=8, out_channels=16, kernel_size=3, padding=1)
       # Fully connected layer
       self.fc1 = nn.Linear(16 * 7 * 7, num_classes)

   def forward(self, x):
       """
       Define the forward pass of the neural network.

       Parameters:
           x: Input tensor.

       Returns:
           torch.Tensor
               The output tensor after passing through the network.
       """
       x = F.relu(self.conv1(x))  # Apply first convolution and ReLU activation
       x = self.pool(x)           # Apply max pooling
       x = F.relu(self.conv2(x))  # Apply second convolution and ReLU activation
       x = self.pool(x)           # Apply max pooling
       x = x.reshape(x.shape[0], -1)  # Flatten the tensor
       x = self.fc1(x)            # Apply fully connected layer
       return x
       x = x.reshape(x.shape[0], -1)  # Flatten the tensor
       x = self.fc1(x)            # Apply fully connected layer
       return x

Sobald wir die Klasse CNN definiert haben, können wir unser Modell erstellen und es auf das Gerät übertragen, wo es trainiert und ausgeführt werden soll. 

Neuronale Netzwerke, einschließlich CNNs, zeigen eine bessere Leistung, wenn sie auf GPUs laufen, aber das kann auch auf deinem Computer der Fall sein. Deshalb lassen wir das Modell nur auf einem Grafikprozessor laufen, wenn er verfügbar ist; ansonsten verwenden wir eine normale CPU.

device = "cuda" if torch.cuda.is_available() else "cpu"

model = CNN(in_channels=1, num_classes=10).to(device)
print(model)
>>> CNN(
  (conv1): Conv2d(1, 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(8, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (fc1): Linear(in_features=784, out_features=10, bias=True)
)

4. Training des CNN-Modells

Jetzt, wo wir unser Modell haben, ist es an der Zeit, es zu trainieren. Dazu müssen wir zunächst festlegen, wie wir die Leistung des Modells messen wollen. Da wir es mit einem Mehrklassen-Klassifizierungsproblem zu tun haben, verwenden wir die Cross-Entropy-Verlustfunktion, die in PyTorch als nn.CrossEntropyLoss verfügbar ist. Wir werden auch den Adam-Optimierer verwenden, einen der beliebtesten Optimierungsalgorithmen. 

# Define the loss function
criterion = nn.CrossEntropyLoss()

# Define the optimizer
optimizer = optim.Adam(model.parameters(), lr=0.001)

Wir iterieren über zehn Epochen und Trainingsstapel, um das Modell zu trainieren, und führen die übliche Abfolge von Schritten für jeden Stapel durch, wie unten gezeigt.

num_epochs=10
for epoch in range(num_epochs):
 # Iterate over training batches
   print(f"Epoch [{epoch + 1}/{num_epochs}]")

   for batch_index, (data, targets) in enumerate(tqdm(dataloader_train)):
       data = data.to(device)
       targets = targets.to(device)
       scores = model(data)
       loss = criterion(scores, targets)
       optimizer.zero_grad()
       loss.backward()
       optimizer.step()

Epoch [1/10]
100%|██████████| 1000/1000 [00:13<00:00, 72.94it/s]
Epoch [2/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.27it/s]
Epoch [3/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.16it/s]
Epoch [4/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.00it/s]
Epoch [5/10]
100%|██████████| 1000/1000 [00:13<00:00, 75.69it/s]
Epoch [6/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.24it/s]
Epoch [7/10]
100%|██████████| 1000/1000 [00:12<00:00, 78.23it/s]
Epoch [8/10]
100%|██████████| 1000/1000 [00:12<00:00, 78.16it/s]
Epoch [9/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.96it/s]
Epoch [10/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.93it/s]

5. Bewertung des Modells

Sobald das Modell trainiert ist, können wir seine Leistung anhand des Testdatensatzes bewerten. Wir werden die Genauigkeit verwenden, eine beliebte Metrik für Klassifizierungsprobleme. Die Genauigkeit misst den Anteil der richtig klassifizierten Fälle an der Gesamtzahl der Objekte im Datensatz. Sie wird berechnet, indem die Anzahl der richtigen Vorhersagen durch die Gesamtzahl der Vorhersagen des Modells geteilt wird. 

Zuerst richten wir die Genauigkeitsmetrik von torchmetrics ein. Als Nächstes verwenden wir die .eval-Methode des Modells, um das Modell in den Evaluierungsmodus zu versetzen, denn einige Schichten in PyTorch-Modellen verhalten sich in den Trainings- und Testphasen unterschiedlich. Außerdem fügen wir mit torch.no_grad einen Python-Kontext hinzu, der anzeigt, dass wir keine Gradientenberechnung durchführen werden.

Dann iterieren wir über Testbeispiele ohne Gradientenberechnung. Für jeden Teststapel erhalten wir die Modellausgaben, wählen die wahrscheinlichste Klasse aus und übergeben sie zusammen mit den Bezeichnungen an die Genauigkeitsfunktion. Zum Schluss berechnen wir die Metriken und drucken die Ergebnisse aus. Wir haben eine Genauigkeit von 0,98 erreicht, was bedeutet, dass unser Modell 98 % der Ziffern richtig klassifiziert hat. Nicht schlecht!

# Set up of multiclass accuracy metric
acc = Accuracy(task="multiclass",num_classes=10)

# Iterate over the dataset batches
model.eval()
with torch.no_grad():
   for images, labels in dataloader_test:
       # Get predicted probabilities for test data batch
       outputs = model(images)
       _, preds = torch.max(outputs, 1)
       acc(preds, labels)
       precision(preds, labels)
       recall(preds, labels)

#Compute total test accuracy
test_accuracy = acc.compute()
print(f"Test accuracy: {test_accuracy}")

>>> Test accuracy: 0.9857000112533569

Du kannst auch andere gängige Klassifizierungsmetriken wie Recall und Precision verwenden. Wir erklären dir alles über diese Metriken mit praktischen Beispielen in unserem Kurs Intermediate Deep Learning with PyTorch.

Verbesserung der Modellleistung

Obwohl unser CNN-Modell eine starke Leistung erzielt, gibt es mehrere Strategien, mit denen wir seine Genauigkeit, Robustheit und Verallgemeinerung auf neue Daten weiter verbessern können. 

In diesem Abschnitt werden wir wichtige Techniken wie die Datenerweiterung, die Abstimmung der Hyperparameter und das Transferlernen untersuchen, um die Leistung unseres Modells zu optimieren.

Techniken zur Datenerweiterung

Die Datenerweiterung ist eine Technik, mit der wir die Genauigkeit unseres Modells verbessern, indem wir zufällig neue Trainingsdaten erstellen. Während des Ladens kann man zum Beispiel Transformationen auf die Trainingsbilder anwenden, wie Größenänderung, horizontales oder vertikales Spiegeln, zufällige Drehung und so weiter. Auf diese Weise kannst du erweiterte Bilder erstellen und ihnen das gleiche Label wie dem Originalbild zuweisen, wodurch sich die Trainingsmenge vergrößert.

Durch das Hinzufügen zufälliger Transformationen zu den Originalbildern können wir mehr Daten generieren und gleichzeitig die Größe und Vielfalt der Trainingsmenge erhöhen. Sie macht das Modell robuster gegenüber Schwankungen und Verzerrungen, die in realen Bildern häufig vorkommen, und reduziert die Überanpassung, da das Modell lernt, die zufälligen Transformationen zu ignorieren. 

Es ist jedoch wichtig, bei der Datenerweiterung vorsichtig zu sein, denn manchmal kann sie den Trainingsprozess beeinträchtigen. Wenn wir zum Beispiel in unserem Problem die Zahl "6" vertikal spiegeln, sieht sie wie die Zahl "9" aus. Wenn du sie an das Modell mit der Bezeichnung "6" weitergibst, verwirrt das das Modell und erschwert das Training. Diese Beispiele zeigen, dass bestimmte Erweiterungen manchmal Auswirkungen auf das Label haben können.

Hyperparameter-Abstimmung

Eine weitere Strategie zur Verbesserung der Leistung unseres Modells besteht darin, die Werte der Hyperparameter in den verschiedenen Schichten des Modells zu ändern. Diese Abstimmung der Hyperparameter erfordert ein tiefes Verständnis der Mathematik hinter neuronalen Netzen und der Bedeutung der verschiedenen Hyperparameter. 

Du könntest zum Beispiel deine CNN-Ebenen anpassen, indem du die Größe der Filter änderst oder die Füllung erhöhst. Du kannst auch einen anderen Wert für die Anfangsgewichte der Neuronen festlegen. 

Da wir die optimalen Werte der Hyperparameter nicht im Voraus kennen, müssen wir ein gewisses Maß an Versuch und Irrtum walten lassen. Dies geschieht in der Regel durch eine Technik, die als Rastersuche bekannt ist und mit der du ein Modell systematisch über ein Raster von Parameterwerten auswerten kannst. 

Sei jedoch vorsichtig, wenn du diese Technik verwendest, denn sie ist in der Regel sehr rechenintensiv, vor allem wenn du mit komplexen neuronalen Netzen und großen Trainingsdatensätzen arbeitest.

Ebenso kannst du die Komplexität deines Modells erhöhen, indem du mehr Faltungsschichten und lineare Schichten hinzufügst. Sei jedoch vorsichtig, wenn du neue Schichten hinzufügst, denn die Anzahl der Neuronen kann sich drastisch erhöhen, was zu längeren Trainingszeiten und möglichen Überanpassungen führt.

Mehr über Hyperparameter-Tuning erfährst du in unserem Kurs Einführung in Deep Learning mit PyTorch.

Vorgefertigte Modelle verwenden

Deep-Learning-Modelle von Grund auf zu trainieren ist ein langwieriger und mühsamer Prozess, der in der Regel eine große Menge an Trainingsdaten erfordert. Stattdessen können wir oft vortrainierte Modelle verwenden, d.h. Modelle, die bereits für eine bestimmte Aufgabe trainiert wurden. 

Manchmal können wir ein bereits trainiertes Modell direkt wiederverwenden, wenn es die Aufgabe, die uns interessiert, bereits lösen kann. In anderen Fällen müssen wir vielleicht das trainierte Modell an die neue Aufgabe anpassen. Dies wird als Transferlernen bezeichnet.

Die Verwendung von vortrainierten Modellen in PyTorch ist ziemlich einfach. Torchvision bietet eine Sammlung von vortrainierten Modellen für verschiedene bildbezogene Aufgaben. Diese Modelle sind auf großen Bilddatensätzen vortrainiert und leicht verfügbar. In unserem Kurs Deep Learning for Images with PyTorch erfährst du alles, was du darüber wissen musst.

Einsatz des CNN-Modells

Nachdem du dein hochpräzises Klassifizierungsmodell in PyTorch trainiert hast, kannst du das Modell und seine vortrainierten Gewichte für die spätere Verwendung speichern und mit deinem Team teilen, um sicherzustellen, dass es nahtlos geladen werden kann.

Um ein Modell zu speichern, können wir torch.save verwenden. Eine gängige Dateierweiterung für Taschenlampenmodelle ist entweder pt oder pth. Um die Gewichte des Modells zu speichern, übergeben wir model.state_dict an torch.save und geben den Namen der Ausgabedatei an, zum Beispiel MulticlassCNN.pth.

Um ein gespeichertes Modell zu laden, initialisieren wir ein neues Modell mit der gleichen Architektur. Dann verwenden wir die Methode "Load State" dict zusammen mit torch.load, um die Parameter in das neue Modell zu laden.

# Save the model
torch.save(model.state_dict(), 'MulticlassCNN.pth')

# Create a new model
loaded_model = CNN(in_channels=1, num_classes=10)

# Load the saved model
loaded_model.load_state_dict(torch.load('MulticlassCNN.pth'))
print(loaded_model)


CNN(
  (conv1): Conv2d(1, 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(8, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (fc1): Linear(in_features=784, out_features=10, bias=True)
)

Fazit

Wir haben einen vollständigen Überblick über CNNs gegeben und die einzelnen Schichten der CNN-Architektur detailliert beschrieben. Außerdem haben wir einen Leitfaden für die Implementierung eines CNN in PyTorch erstellt, der die wichtigsten Schritte vom Laden der Daten und dem Entwurf des Modells bis hin zum Training und der Auswertung des Modells abdeckt. Schließlich analysieren wir auch verschiedene Strategien zur Verbesserung der Leistung unseres Modells. Wir haben all diese Fähigkeiten auf ein reales Szenario angewandt, bei dem es um eine Klassifizierungsaufgabe mit mehreren Klassen ging. 

Es gibt viel über Deep Learning zu lernen, das wohl eines der spannendsten und anspruchsvollsten Gebiete der KI ist. Zum Glück ist DataCamp da, um zu helfen. Schau dir unsere speziellen Materialien und Kurse an und werde ein Experte für neuronale Netze:

• Eine Einführung in Faltungsneuronale Netze: Ein umfassender Leitfaden zu CNNs im Deep Learning 
• Convolutional Neural Networks in Python mit Keras
• Python Convolutional Neural Networks (CNN) mit TensorFlow Tutorial
• Einführung in Aktivierungsfunktionen in neuronalen Netzen 
• Meistere Deep Learning für Text mit PyTorch Kurs
• Deep Learning in Python
• Wie du im Jahr 2025 Deep Learning lernst: Ein vollständiger Leitfaden
• Intermediate Deep Learning mit PyTorch Kurs
• Ein Leitfaden für PyTorch-Zertifizierungen und -Zertifikate