PyTorch CNN Tutorial: Convolutional Neural Networks in Python erstellen und trainieren

Tutorials
Python

Convolutional Neural Networks (CNNs) sind ein Grundpfeiler der modernen Computer Vision und ermöglichen Anwendungen wie Bildrecognition, Gesichtserkennung und autonomes Fahren. Diese Netzwerke sind darauf ausgelegt, automatisch Muster und Merkmale aus Bildern zu extrahieren, wodurch sie leistungsfähiger sind als traditionelle Techniken des maschinellen Lernens für visuelle Aufgaben.

In diesem Tutorial werden wir ein CNN mit PyTorch implementieren, einem benutzerfreundlichen und äußerst effizienten Deep-Learning-Framework für Forschungs- und Produktionsanwendungen.

Voraussetzungen: Deep Learning und PyTorch

Bevor wir uns mit den Details von CNNs befassen, sollten Sie mit dem Bereich des Deep Learning und den Python-Bibliotheken, die wir während der Einrichtung unserer Umgebung verwenden werden, vertraut sein.

Deep Learning ist ein Teilbereich des maschinellen Lernens, bei dem die grundlegende Modellstruktur ein Netzwerk aus Eingaben, verborgenen Schichten und Ausgaben ist. Ein solches Netzwerk kann eine oder viele verborgene Schichten haben. Die ursprüngliche Intuition hinter Deep Learning war es, Modelle zu schaffen, die von der Art und Weise inspiriert sind, wie das menschliche Gehirn lernt: durch miteinander verbundene Zellen, die Neuronen genannt werden. Deshalb nennen wir Deep-Learning-Modelle weiterhin „neuronale“ Netzwerke. Diese geschichteten Modellstrukturen benötigen weit mehr Daten, um zu lernen, als andere Modelle des überwachten Lernens, um Muster aus unstrukturierten Daten abzuleiten. Normalerweise sprechen wir von mindestens Hunderttausenden von Datenpunkten.

Während es mehrere Frameworks und Pakete gibt, um Deep-Learning-Algorithmen zu implementieren, werden wir uns auf PyTorch konzentrieren, eines der beliebtesten und am besten gepflegten Frameworks. Neben der Verwendung durch Deep-Learning-Ingenieure in der Industrie ist PyTorch ein bevorzugtes Werkzeug unter Forschern. Viele Deep-Learning-Papiere werden unter Verwendung von PyTorch veröffentlicht. Es ist so konzipiert, dass es intuitiv und benutzerfreundlich ist und viele Gemeinsamkeiten mit der Python-Bibliothek NumPy teilt. 

Wenn Sie eine Einführung in diese Konzepte benötigen, sollten Sie sich noch heute für den Kurs Deep Learning mit PyTorch anmelden. 

Was ist ein Convolutional Neural Network (CNN)?

Convolutional Neural Networks, üblicherweise als CNN oder ConvNet bezeichnet, sind eine spezielle Art von Deep Neural Network, die sich gut für Computer-Vision-Aufgaben eignet. Die Erfindung von CNNs geht auf die 1980er Jahre zurück. Allerdings wurden sie erst in den 2010er Jahren populär, nachdem die Durchbrüche in der Berechnung durch die Implementierung von Grafikprozessoren (GPUs) erfolgten. Tatsächlich half die schnelle Popularisierung von CNNs dem Bereich der neuronalen Netzwerke, wieder in den Vordergrund zu treten, was zur sogenannten „dritten Welle der neuronalen Netzwerke“ führte, in der wir heute noch leben. 

CNNs sind speziell vom biologischen visuellen Kortex inspiriert. Der Kortex hat kleine Zellregionen, die auf spezifische Bereiche des visuellen Feldes reagieren. Diese Idee wurde durch ein faszinierendes Experiment von Hubel und Wiesel im Jahr 1962 erweitert.

CNNs versuchen, dieses Merkmal zu replizieren, indem sie komplexe neuronale Netzwerke erstellen, die aus verschiedenen, aufgabenorientierten Schichten bestehen. CNNs werden „feed-forward“ genannt, da 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 zurückgeführt werden.

Insbesondere besteht ein CNN typischerweise aus den folgenden Schichten:

Faltungsschicht

Dies ist der erste Baustein eines CNN. Wie der Name schon sagt, besteht die Hauptaufgabe darin, eine Faltung durchzuführen, was die Anwendung einer Gleitfensterfunktion auf eine Matrix von Pixeln darstellt, die ein Bild repräsentieren. Die auf die Matrix angewendete Gleitfunktion wird Kernel oder Filter genannt. In der Faltungsschicht werden mehrere Filter gleicher Größe angewendet, wobei jeder Filter verwendet wird, um ein spezifisches Muster aus dem Bild zu erkennen, wie zum Beispiel die Krümmung der Ziffern, die Kanten, die gesamte Form der Ziffern und mehr. 

Aktivierungsfunktion

Normalerweise wird nach jeder Faltung eine ReLU-Aktivierungsfunktion angewendet. Diese Funktion hilft dem Netzwerk, nichtlineare Beziehungen zwischen den Merkmalen im Bild zu erlernen, was das Netzwerk robuster macht, um verschiedene Muster zu identifizieren. Sie hilft auch dabei, die Probleme des verschwindenden Gradienten zu mildern. 

Pooling-Schicht

Das Ziel der Pooling-Schicht ist es, die bedeutendsten Merkmale aus der gefalteten Matrix herauszuziehen. Dies geschieht durch die Anwendung von Aggregationsoperationen, die die Dimension der Merkmalskarte (gefaltete Matrix) reduzieren und dadurch den Speicherbedarf während des Trainings des Netzwerks verringern. Pooling ist auch relevant zur Minderung von Overfitting.

Vollständig verbundene Schichten

Diese Schichten befinden sich in der letzten Schicht des konvolutionalen neuronalen Netzwerks, und ihre Eingänge entsprechen der abgeflachten eindimensionalen Matrix, die von der letzten Pooling-Schicht erzeugt wird. ReLU-Aktivierungsfunktionen werden auf sie angewendet, um Nichtlinearität zu erzeugen.

Architektur des konvolutionalen neuronalen Netzwerks. Quelle: DataCamp

Eine detailliertere Erklärung der Mathematik hinter CNNs finden Sie in unserem Tutorial, Convolutional Neural Networks in Python.

Warum CNNs für die Bilderkennung verwenden?

Faltungsneuronale Netzwerke waren eine der einflussreichsten Innovationen im Bereich der Computer Vision. Sie haben viel besser abgeschnitten als traditionelle maschinelle Lernmodelle wie SVMs und Entscheidungsbäume und haben Spitzenleistungsergebnisse erzielt.

Darüber hinaus verleihen die Faltungsschichten CNNs ihre translationsinvarianten Eigenschaften und ermöglichen es ihnen, Muster und Merkmale aus Daten zu identifizieren und zu extrahieren, unabhängig von Variationen in Position, Orientierung, Skalierung oder Translation.

CNNs haben sich in vielen verschiedenen Fallstudien und Anwendungen im wirklichen Leben als erfolgreich erwiesen, wie z.B.:

  • Bildklassifizierung, Objekterkennung, Segmentierung, Gesichtserkennung;
  • Autonome Fahrzeuge, die auf CNN-basierten Visionssystemen basieren;
  • Klassifizierung der Kristallstruktur mithilfe eines faltungsneuronalen Netzwerks;
  • Sicherheitssysteme von Überwachungskameras.

Jenseits von Bildklassifizierungsaufgaben sind CNNs vielseitig einsetzbar und können auf eine Vielzahl von anderen Bereichen angewendet werden, wie z.B. natürliche Sprachverarbeitung, Zeitreihenanalyse und Spracherkennung.

Implementierung eines CNNs mit PyTorch

Jetzt, da Sie mit der Theorie der CNNs vertraut sind, sind wir bereit, die Hände schmutzig zu machen. In diesem Abschnitt werden wir ein einfaches CNN mit PyTorch erstellen und trainieren. Unser Ziel ist es, ein Modell zu erstellen, um Ziffern in Bildern zu klassifizieren. Um unser Modell zu trainieren und zu testen, werden wir den berühmten MNIST-Datensatz verwenden, eine Sammlung von 70.000 Graustufenbildern im Format 28×28 mit handgeschriebenen Ziffern.

1. Importieren der benötigten Bibliotheken

Hier finden Sie die Bibliotheken, die wir für dieses Tutorial verwenden werden. Im Wesentlichen werden wir PyTorch verwenden, um unser CNN zu erstellen, sowie das Computer-Vision-Modul torchvision von PyTorch, um den MNIST-Datensatz herunterzuladen und zu laden. Schließlich werden wir auch torchmetrics verwenden, 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 bietet auch ein reichhaltiges Ökosystem von Tools und Erweiterungen, einschließlich torchvision, einem Modul für Computer Vision. Torchvision enthält mehrere Bilddatensätze, die zum Training und Testen von neuronalen Netzwerken verwendet werden können. In unserem Tutorial werden wir den MNIST-Datensatz verwenden.

Zuerst werden wir den MNIST-Datensatz herunterladen und in ein Tensor konvertieren, die Kern-Datenstruktur in PyTorch, ähnlich wie NumPy-Arrays, aber mit GPU-Beschleunigungsfähigkeiten.

Dann verwenden wir auch DataLoader, um das Stapeln und Mischen sowohl der Trainings- als auch der Testdatensätze zu handhaben. Ein PyTorch DataLoader kann aus einem Dataset erstellt werden, um Daten zu laden, sie in Batches aufzuteilen und Transformationen an den Daten durchzuführen, falls gewünscht. Dann liefert es eine Datenprobe, die bereit für das Training ist. Im folgenden Code laden wir die Daten und speichern sie in DataLoaders mit einer Batchgröß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 könnte der Trainingsdatensatz weiter in zwei Partitionen von Trainings- und Validierungsdaten aufgeteilt werden. Validierung ist eine Technik im Deep Learning, um die Leistung des Modells während des Trainings zu bewerten. Es hilft dabei, potenzielles Overfitting und Underfitting unserer Modelle zu erkennen, und es ist besonders hilfreich zur Optimierung von Hyperparametern. Allerdings werden wir aus Gründen der Einfachheit in diesem Tutorial keine Validierung verwenden. Wenn Sie mehr über Validierung erfahren möchten, können Sie eine ausführliche Erklärung in unserem Einführungskurs in Deep Learning mit PyTorch nachlesen.

Jetzt, da wir unsere Daten haben, schauen wir uns an, wie ein zufälliger Batch von Ziffern aussieht:

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

# einige zufällige Trainingsbilder bekommen
dataiter = iter(dataloader_train)
images, labels = next(dataiter)
labels
# Bilder anzeigen
imshow(torchvision.utils.make_grid(images))

3. Definition der CNN-Architektur

Um das Klassifizierungsproblem zu lösen, werden wir die Klasse nn.Module nutzen, PyTorch’s Baustein zum intuitiven Erstellen anspruchsvoller neuronaler Netzwerkarchitekturen.

Im folgenden Code erstellen wir eine Klasse namens CNN, die die Eigenschaften der Klasse nn.Module erbt. Die Klasse CNN wird die Vorlage für ein CNN mit zwei convolutionalen Schichten sein, gefolgt von einer voll verbundenen Schicht.

In PyTorch verwenden wir nn.Conv2d, um eine convolutionale Schicht zu definieren. Wir übergeben die Anzahl der Eingangs- und Ausgangs-Feature-Maps. Außerdem setzen wir einige der Parameter, damit die convolutionale Schicht funktioniert, einschließlich der Kernel- oder Filtergröße und der Padding-Einstellungen.

Als Nächstes fügen wir eine Max-Pooling-Schicht mit nn.MaxPool2d hinzu. In dieser schieben wir ein nicht überlappendes Fenster über die Ausgabe der vorherigen convolutionalen Schicht. An jeder Position wählen wir den maximalen Wert aus dem Fenster aus, um ihn weiterzugeben. Diese Operation reduziert die räumlichen Dimensionen der Feature-Maps, verringert die Anzahl der Parameter und die rechnerische Komplexität im Netzwerk. Schließlich fügen wir eine voll verbundene lineare Schicht hinzu.

Die Funktion forward() definiert, wie die verschiedenen Schichten verbunden sind, wobei nach jeder convolutionalen Schicht mehrere ReLU-Aktivierungsfunktionen hinzugefügt werden.

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__()

       # 1. Faltungsschicht
       self.conv1 = nn.Conv2d(in_channels=in_channels, out_channels=8, kernel_size=3, padding=1)
       # Max-Pooling-Schicht
       self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
       # 2. Faltungsschicht
       self.conv2 = nn.Conv2d(in_channels=8, out_channels=16, kernel_size=3, padding=1)
       # Vollständig verbundene Schicht
       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))  # Erste Faltung anwenden und ReLU-Aktivierung
       x = self.pool(x)           # Max-Pooling anwenden
       x = F.relu(self.conv2(x))  # Zweite Faltung anwenden und ReLU-Aktivierung
       x = self.pool(x)           # Max-Pooling anwenden
       x = x.reshape(x.shape[0], -1)  # Tensor abflachen
       x = self.fc1(x)            # Vollständig verbundene Schicht anwenden
       return x
       x = x.reshape(x.shape[0], -1)  # Tensor abflachen
       x = self.fc1(x)            # Vollständig verbundene Schicht anwenden
       return x

Nachdem wir die Klasse CNN definiert haben, können wir unser Modell erstellen und es auf das Gerät verschieben, auf dem es trainiert und ausgeführt wird.

Neuronale Netzwerke, einschließlich CNNs, zeigen eine bessere Leistung, wenn sie auf GPUs ausgeführt werden, aber das könnte auf Ihrem Computer der Fall sein. Daher werden wir das Modell nur auf einer GPU ausführen, wenn verfügbar; andernfalls werden wir eine reguläre CPU verwenden.

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. Das CNN-Modell trainieren

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

# Definiere die Verlustfunktion
criterion = nn.CrossEntropyLoss()

# Definiere den Optimierer
optimizer = optim.Adam(model.parameters(), lr=0.001)

Wir werden über zehn Epochen und Trainingsbatches iterieren, um das Modell zu trainieren und die üblichen Schritte für jedes Batch auszuführen, wie unten gezeigt.

num_epochs=10
for epoch in range(num_epochs):
 # Iteriere über Trainingsbatches
   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

Nachdem das Modell trainiert wurde, können wir seine Leistung auf dem Testdatensatz bewerten. Wir werden die Genauigkeit verwenden, eine beliebte Metrik für Klassifikationsprobleme. Die Genauigkeit misst den Anteil der korrekt klassifizierten Fälle an der Gesamtzahl der Objekte im Datensatz. Sie wird berechnet, indem die Anzahl der korrekten Vorhersagen durch die Gesamtzahl der vom Modell getätigten Vorhersagen 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, da sich einige Schichten in PyTorch-Modellen im Trainings- versus Testmodus unterschiedlich verhalten. Wir fügen auch einen Python-Kontext mit torch.no_grad hinzu, was anzeigt, dass wir keine Gradientenberechnung durchführen werden.

Dann iterieren wir über die Testbeispiele ohne Gradientenberechnung. Für jedes Test-Batch erhalten wir die Ausgaben des Modells, wählen die wahrscheinlichste Klasse aus und übergeben sie zusammen mit den Labels an die Genauigkeitsfunktion. Schließlich berechnen wir die Metriken und drucken die Ergebnisse aus. Wir haben eine Genauigkeitsbewertung von 0,98 erreicht, was bedeutet, dass unser Modell 98 % der Ziffern korrekt klassifiziert hat. Nicht schlecht!

# Einrichtung der Mehrklassen-Genauigkeitsmetrik
acc = Accuracy(task="multiclass",num_classes=10)

# Über Iteration der Datensatz-Batches
model.eval()
with torch.no_grad():
   for images, labels in dataloader_test:
       # Vorhergesagte Wahrscheinlichkeiten für das Testdaten-Batch abrufen
       outputs = model(images)
       _, preds = torch.max(outputs, 1)
       acc(preds, labels)
       precision(preds, labels)
       recall(preds, labels)

# Gesamte Testgenauigkeit berechnen
test_accuracy = acc.compute()
print(f"Test accuracy: {test_accuracy}")

>>> Test accuracy: 0.9857000112533569

Sie könnten auch andere beliebte Klassifikationsmetriken verwenden, einschließlich Rückruf und Präzision. Wir erklären Ihnen alles über diese Metriken mit praktischen Beispielen in unserem Intermediate Deep Learning mit PyTorch Kurs.

Verbesserung der Modellleistung

Während unser CNN-Modell eine starke Leistung erzielt, gibt es mehrere Strategien, die wir verwenden können, um seine Genauigkeit, Robustheit und Generalisierung auf neue Daten weiter zu verbessern.

In diesem Abschnitt werden wir Schlüsseltechniken wie Datenvergrößerung, Hyperparameterabstimmung und Transferlernen erkunden, um die Leistung unseres Modells zu optimieren.

Datenvergrößerungstechniken

Datenvergrößerung ist eine Technik, um die Genauigkeit unseres Modells zu verbessern, indem zufällig neue Trainingsdaten erstellt werden. Beispielsweise kann man während des Ladens Transformationen auf die Trainingsbilder anwenden, wie Größenänderung, horizontales oder vertikales Spiegeln, zufällige Rotation usw. Auf diese Weise können augmentierte Bilder erstellt und diesen dasselbe Label wie dem Originalbild zugewiesen werden, wodurch die Größe des Trainingssets erhöht wird.

Durch das Hinzufügen von zufälligen Transformationen zu den Originalbildern können wir mehr Daten generieren und gleichzeitig die Größe und Vielfalt des Trainingssets erhöhen. Es macht das Modell robuster gegenüber den in realen Bildern häufig vorkommenden Variationen und Verzerrungen und reduziert Überanpassung, da das Modell lernt, die zufälligen Transformationen zu ignorieren.

Es ist jedoch wichtig, bei der Datenvergrößerung vorsichtig zu sein, da sie manchmal den Schulungsprozess beeinträchtigen kann. Wenn wir beispielsweise die vertikale Spiegelung auf die Zahl „6“ anwenden, wird sie wie die Zahl „9“ aussehen. Wenn sie dem Modell als „6“ zugewiesen wird, wird das Modell verwirrt und das Training behindert. Diese Beispiele zeigen, dass bestimmte Vergrößerungen manchmal das Label beeinflussen können.

Hyperparameterabstimmung

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

Zum Beispiel könnten Sie Ihre CNN-Schichten optimieren, indem Sie die Größe der Filter ändern oder das Padding erhöhen. Sie könnten auch einen anderen Wert für die Anfangsgewichte der Neuronen festlegen.

Da wir die optimalen Werte der Hyperparameter im Voraus nicht kennen, wird ein gewisser Grad an Versuch und Irrtum erforderlich sein. Dies geschieht normalerweise durch eine Technik, die als Grid-Suche bekannt ist, die es Ihnen ermöglicht, ein Modell systematisch über ein Gitter von Parameterwerten zu bewerten.

Seien Sie jedoch vorsichtig, wenn Sie diese Technik verwenden, da sie normalerweise rechenintensiv ist, insbesondere bei komplexen neuronalen Netzen und großen Trainingsdatensätzen.

Ebenso könnten Sie die Komplexität Ihres Modells erhöhen, indem Sie weitere konvolutionale und lineare Schichten hinzufügen. Seien Sie jedoch vorsichtig, wenn Sie neue Schichten hinzufügen, da die Anzahl der Neuronen drastisch ansteigen kann, was zu längeren Trainingszeiten und potenziellen Überanpassungen führen kann.

Sie können mehr über die Hyperparameter-Optimierung in unserem Einführung in Deep Learning mit PyTorch Kurs erfahren.

Verwendung von vortrainierten Modellen

Das Training von Deep-Learning-Modellen von Grund auf ist ein langer und mühsamer Prozess und erfordert in der Regel eine Menge Trainingsdaten. Stattdessen können wir häufig vortrainierte Modelle verwenden, d.h. Modelle, die bereits für eine bestimmte Aufgabe trainiert wurden.

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

Die Verwendung von vortrainierten Modellen in PyTorch ist recht einfach. Torchvision bietet eine Sammlung von vortrainierten Modellen für verschiedene bildbezogene Aufgaben. Diese Modelle sind auf groß angelegten Bilddatensätzen vortrainiert und leicht zugänglich. Schauen Sie sich unseren Deep Learning for Images with PyTorch Course an, um alles zu lernen, was Sie über sie wissen müssen.

Bereitstellung des CNN-Modells

Nachdem Sie Ihr hochgenaues Klassifizierungsmodell in PyTorch trainiert haben, können Sie das Modell und seine vortrainierten Gewichte jetzt speichern, um es in Zukunft zu verwenden und mit Ihrem Team zu teilen, um sicherzustellen, dass sie es nahtlos laden können.

Um ein Modell zu speichern, können wir torch.save verwenden. Eine häufige Dateierweiterung für Torch-Modelle ist entweder pt oder pth. Um die Gewichte des Modells zu speichern, übergeben wir model.state_dict an torch.save und geben den Ausgabedateinamen an, z.B. MulticlassCNN.pth.

Um ein gespeichertes Modell zu laden, initialisieren wir ein neues Modell mit derselben Architektur. Dann verwenden wir die Methode load state dict zusammen mit torch.load, um die Parameter in das neue Modell zu laden.

# Modell speichern
torch.save(model.state_dict(), 'MulticlassCNN.pth')

# Neues Modell erstellen
loaded_model = CNN(in_channels=1, num_classes=10)

# Das gespeicherte Modell laden
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 umfassenden Überblick über CNNs gegeben und Details zu jeder Schicht der CNN-Architektur bereitgestellt. Darüber hinaus haben wir eine Anleitung zur Implementierung eines CNN in PyTorch bereitgestellt, die die Hauptschritte von der Datenladung über das Modell-Design bis hin zum Training und zur Evaluierung des Modells abdeckt. Schließlich analysieren wir auch mehrere Strategien zur Verbesserung der Leistung unseres Modells. Wir haben all diese Fähigkeiten in einem realen Szenario im Zusammenhang mit einer Multiklassen-Klassifizierungsaufgabe angewendet.

Es gibt viel über Deep Learning zu lernen, arguably eines der spannendsten und anspruchsvollsten Felder in der KI. Glücklicherweise ist DataCamp hier, um zu helfen. Schauen Sie sich unsere speziellen Materialien und Kurse an und werden Sie ein Experte für neuronale Netzwerke:

Source:
https://www.datacamp.com/tutorial/pytorch-cnn-tutorial