1. Einführung in Convolutional Neural Networks (CNNs)
2. Hauptkomponenten von CNNs
- Convolutional Layers: Diese Schichten führen Faltung (Convolution) auf die Eingabedaten durch, um Merkmale zu extrahieren.
- Pooling Layers: Diese Schichten reduzieren die räumlichen Dimensionen der Daten.
- Fully Connected Layers: Diese Schichten sind wie in klassischen neuronalen Netzwerken und verbinden jedes Neuron mit jedem Neuron der nächsten Schicht.
2.1 Convolutional Layers (Faltungsschichten)
Einführung in Convolutional Layers
Convolutional Layers sind das Herzstück von CNNs und dienen dazu, Merkmale aus den Eingabedaten zu extrahieren. Diese Schichten verwenden Faltungskerne (Filter), die über das Eingabebild gleiten und Punktprodukte zwischen dem Filter und den Eingabepixeln berechnen. Das Ergebnis ist eine Feature-Map, die bestimmte Merkmale des Bildes wie Kanten, Ecken oder Texturen hervorhebt.
Hauptkomponenten
- Filter (Kerne): Kleine Matrizen (z.B. 3x3 oder 5x5), die über das Eingabebild gleiten.
- Stride: Die Schrittweite, mit der der Filter über das Bild bewegt wird.
- Padding: Hinzufügen von Rändern um das Bild, um die Dimensionen der Ausgabe zu kontrollieren.
Beispiel:
import torch
import torch.nn as nn
# Definieren einer Convolutional Layer
conv_layer = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1)
# Beispielhafte Eingabedaten (Batchgröße, Kanäle, Höhe, Breite)
input_data = torch.randn(1, 3, 32, 32)
# Anwenden der Convolutional Layer
output_data = conv_layer(input_data)
print(output_data.shape)
Output:
torch.Size([1, 16, 32, 32])
In diesem Beispiel wird eine Convolutional Layer definiert, die einen 3x3-Filter verwendet, um ein Eingabebild mit 3 Kanälen (RGB) zu verarbeiten und 16 Ausgabe-Kanäle zu erzeugen.
2.2 Pooling Layers
Einführung in Pooling Layers
Pooling Layers reduzieren die räumlichen Dimensionen der Feature-Maps, wodurch die Berechnungen effizienter werden und das Netzwerk eine gewisse Translation-Invarianz erreicht. Es gibt verschiedene Arten von Pooling, darunter Max-Pooling und Average-Pooling.
Haupttypen
- Max-Pooling: Wählt den maximalen Wert innerhalb eines bestimmten Bereichs (z.B. 2x2).
- Average-Pooling: Berechnet den Durchschnittswert innerhalb eines bestimmten Bereichs.
Beispiel:
# Definieren von Max Pooling und Average Pooling
max_pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
avg_pool = nn.AvgPool2d(kernel_size=2, stride=2, padding=0)
# Beispielhafte Eingabedaten
input_data = torch.randn(1, 16, 32, 32)
# Anwenden von Max Pooling und Average Pooling
output_max_pool = max_pool(input_data)
output_avg_pool = avg_pool(input_data)
print(output_max_pool.shape)
print(output_avg_pool.shape)
In diesem Beispiel wird die räumliche Dimension von 32x32 auf 16x16 reduziert, indem Max-Pooling und Average-Pooling mit einer Kernelgröße von 2x2 und einer Schrittweite von 2 angewendet werden.
2.3 Fully Connected Layers (Vollständig verbundene Schichten)
Einführung in Fully Connected Layers
Fully Connected Layers sind wie klassische neuronale Netzwerkschichten, in denen jedes Neuron mit jedem Neuron der nächsten Schicht verbunden ist. Diese Schichten werden normalerweise am Ende eines CNNs verwendet, um die extrahierten Merkmale zu verarbeiten und die endgültige Vorhersage zu treffen.
Hauptkomponenten:
- Neuronen: Einheiten, die Gewichtungen und Bias enthalten.
- Aktivierungsfunktionen: Nichtlineare Transformationen, die auf die Ausgabe angewendet werden.
Beispiel:
# Definieren von Fully Connected Layers
fc1 = nn.Linear(in_features=32*8*8, out_features=128)
fc2 = nn.Linear(in_features=128, out_features=10)
# Beispielhafte Eingabedaten (flachgelegt)
input_data = torch.randn(1, 32*8*8)
# Anwenden der Fully Connected Layers
output_fc1 = fc1(input_data)
output_fc2 = fc2(output_fc1)
print(output_fc1.shape)
print(output_fc2.shape)
Output:
torch.Size([1, 128])
torch.Size([1, 10])
In diesem Beispiel wird eine Fully Connected Layer definiert, die 3288 Eingabefeatures (z.B. eine flachgelegte Feature-Map) auf 128 Neuronen abbildet und dann auf 10 Klassen reduziert (z.B. für eine Klassifikationsaufgabe).
Erklährung:
Erste Fully Connected Layer:
fc1 = nn.Linear(in_features=32*8*8, out_features=128)
Parameter:
in_features: Die Anzahl der Eingabefeatures. In diesem Fall beträgt die Anzahl der Eingabefeatures 32*8*8.
- Dies bedeutet, dass die Eingabe an diese Schicht eine flachgelegte (1D) Version einer 3D-Tensor-Feature-Map mit den Dimensionen 32 (Kanäle), 8 (Höhe) und 8 (Breite) ist.
- Typischerweise wird die Eingabe an eine Fully Connected Layer von den vorhergehenden Convolutional und Pooling Layers stammen, die die räumlichen Dimensionen der Eingabe reduziert und die Anzahl der Kanäle erhöht haben.
out_features: Die Anzahl der Neuronen (bzw. Ausgabefeatures) in dieser Schicht. In diesem Fall beträgt die Anzahl der Ausgabefeatures 128.
Funktionsweise:
Diese Schicht nimmt eine Eingabe von 32*8*8 (2048) Features und gibt 128 Features aus.
Jedes der 128 Neuronen hat eine Gewichtsmatrix, die mit den 32*8*8 Eingabefeatures multipliziert wird, sowie einen Bias-Term.
Zweite Fully Connected Layer:
fc2 = nn.Linear(in_features=128, out_features=10)
Parameter:
in_features: Die Anzahl der Eingabefeatures. In diesem Fall beträgt die Anzahl der Eingabefeatures 128.
- Dies bedeutet, dass die Eingabe an diese Schicht aus den 128 Ausgabefeatures der vorhergehenden Fully Connected Layer (fc1) stammt.
out_features: Die Anzahl der Neuronen (bzw. Ausgabefeatures) in dieser Schicht. In diesem Fall beträgt die Anzahl der Ausgabefeatures 10.
- Typischerweise wird dies die Anzahl der Klassen in einer Klassifikationsaufgabe sein. Zum Beispiel, wenn wir den CIFAR-10 Datensatz klassifizieren, haben wir 10 Klassen (jeweils für eine bestimmte Kategorie wie Auto, Vogel, Katze, etc.).
Funktionsweise:
- Diese Schicht nimmt die 128 Ausgabefeatures der vorhergehenden Schicht und gibt 10 Features aus.
- Jedes der 10 Neuronen hat eine Gewichtsmatrix, die mit den 128 Eingabefeatures multipliziert wird, sowie einen Bias-Term.
Gesamtstruktur und Funktion
Einbindung in ein neuronales Netzwerk:
- Diese Fully Connected Layers sind in der Regel am Ende eines CNNs positioniert, um die endgültige Entscheidung zu treffen.
- Die Daten durchlaufen zuerst mehrere Convolutional und Pooling Layers, die die wesentlichen Merkmale extrahieren und die Dimensionen der Daten reduzieren.
- Die extrahierten Merkmale werden dann flachgelegt (d.h., von einer mehrdimensionalen Tensor-Form in eine 1D-Form umgewandelt) und an die Fully Connected Layers übergeben.
3. Aufbau eines einfachen CNNs
import torch
import torch.nn as nn
import torch.nn.functional as F
class SimpleCNN(nn.Module):
def __init__(self):
super(SimpleCNN, self).__init__()
# Erste Faltungsschicht
self.conv1 = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1)
# Zweite Faltungsschicht
self.conv2 = nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3, stride=1, padding=1)
# Pooling-Schicht
self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
# Vollständig verbundene Schichten
self.fc1 = nn.Linear(32 * 8 * 8, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(-1, 32 * 8 * 8) # Flachlegen der Tensoren für Fully Connected Layers
x = F.relu(self.fc1(x))
x = self.fc2(x)
return x
# Initialisieren des Modells
model = SimpleCNN()
print(model)
SimpleCNN(
(conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(conv2): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(fc1): Linear(in_features=2048, out_features=128, bias=True)
(fc2): Linear(in_features=128, out_features=10, bias=True)
)
