4.4 Neuronale Netze und CNNs

Die Tür zum Deep Learning öffnen

In den vorherigen Kapiteln haben wir gesehen, dass traditionelle Computer-Vision-Methoden in der realen Welt häufig versagen. Ihr Erfolg hängt meist davon ab, dass die Szene zu einem bestimmten Muster oder einer Reihe von Annahmen passt – etwa stabile Beleuchtung, saubere Hintergründe, feste Blickwinkel oder vorhersagbare Objektformen. Sobald sich diese Bedingungen ändern, kann die Leistung schnell nachlassen. Deep Learning verfolgt jedoch einen ganz anderen Ansatz. Statt sich hauptsächlich auf handgefertigte Regeln zu stützen, lernt es nützliche visuelle Muster direkt aus großen Datenmengen. Dadurch kann es weitaus mehr Variation in Aussehen, Hintergrund, Skalierung, Beleuchtung und Pose verarbeiten. Infolgedessen hat Deep Learning Computer Vision für reale Anwendungen viel robuster und praxistauglicher gemacht.

Von Regeln zu gelernten Repräsentationen

In der klassischen Vision schreiben wir Regeln explizit:

das Bild weichzeichnen
die Kanten finden
die Kontur extrahieren

In einem neuronalen Netz lassen wir das Modell nützliche Muster aus Beispielen lernen.

Dies ist der entscheidende konzeptionelle Wandel: Das System lernt Repräsentationen, statt sich nur auf manuell entworfene Merkmale zu verlassen.

Was ist ein neuronales Netz

Ein neuronales Netz ist eine Funktion aus Schichten, die die Eingabedaten Schritt für Schritt transformieren.

Jede Schicht lernt Parameter. Während des Trainings werden diese Parameter so angepasst, dass die Ausgaben des Netzes für die Aufgabe nützlicher werden.

Wie sieht ein NN im Code aus?

python

import torch
import torch.nn as nn
import torch.nn.functional as F

# 1. Define the Network Structure
class SimpleMLP(nn.Module):
    def __init__(self, input_size=784, hidden_size=128, num_classes=10):
        super(SimpleMLP, self).__init__()
        
        # --- Fully Connected Layers (Dense Layers) ---
        
        # First layer: Maps input features to the first hidden layer
        self.fc1 = nn.Linear(input_size, hidden_size)
        
        # Second layer: Maps first hidden layer to the second hidden layer
        self.fc2 = nn.Linear(hidden_size, 64)
        
        # Output layer: Maps second hidden layer to the number of classes
        self.fc3 = nn.Linear(64, num_classes)
        
        # Optional: Dropout layer to prevent overfitting (drops 20% of neurons)
        self.dropout = nn.Dropout(p=0.2)

    # 2. Define the Data Flow (Forward Pass)
    def forward(self, x):
        # Flatten the input tensor
        # Converts (batch_size, channels, height, width) to (batch_size, -1)
        # Example: 28x28 image becomes a 784-dimensional vector
        x = x.view(x.size(0), -1)  
        
        # First hidden layer: Linear transformation -> ReLU Activation -> Dropout
        x = F.relu(self.fc1(x))
        x = self.dropout(x)
        
        # Second hidden layer: Linear transformation -> ReLU Activation
        x = F.relu(self.fc2(x))
        
        # Output layer: Linear transformation (no activation here, usually handled by loss function)
        x = self.fc3(x)
        
        return x

# 3. Instantiate the Model
model = SimpleMLP()
print(model)

Probieren Sie es aus

bash

cd 4.4-Neural-Networks-and-CNNs/code
python powerful_neural_network.py

🚀 Trainieren Sie Ihr eigenes neuronales Netz und sehen Sie, wie es sich schlägt!

Warum CNNs für Bilder geeignet sind

CNNs (convolutional neural networks) funktionieren gut für Bilder, weil Bilder nicht nur zufällige Zahlen sind. In einem Bild gehören benachbarte Pixel meist zur gleichen Kante, Form oder Textur, sodass lokale Muster sehr wichtig sind. CNNs nutzen dies aus, indem sie kleine Filter verwenden, die das Bild abtasten und nach nützlichen Merkmalen wie Kanten, Ecken und einfachen Formen suchen. Wenn das Netz tiefer wird, kombiniert es diese kleinen Merkmale zu größeren, etwa Teilen eines Objekts und schließlich dem gesamten Objekt selbst. Deshalb sind CNNs besonders gut darin, Bilder effizient und genau zu verstehen.

Input Shape : (1, 9, 9) - Output Shape : (1, 7, 7) - K : (3, 3) - P : (0, 0) - S : (1, 1) - D : (1, 1) - G : 1.gif

Ein CNN hat in der Regel eine geschichtete Struktur, um ein Bild in ein höherwertiges visuelles Verständnis zu verwandeln. Es beginnt mit einem Eingabebild, das dann durch mehrere Faltungsschichten geleitet wird, die lokale Muster wie Kanten, Texturen und Formen lernen. Diesen folgen oft Aktivierungsfunktionen wie ReLU und Pooling-Schichten, die die räumliche Größe reduzieren und dabei wichtige Informationen erhalten. Nach mehreren solchen Blöcken werden die Feature-Maps zu einer kompakten Repräsentation flach gelegt oder gepoolt und dann an eine oder mehrere vollständig verbundene Schichten weitergegeben, um die endgültige Vorhersage zu erzeugen, etwa ein Klassen-Label. Kurz gesagt sieht ein typisches CNN so aus:

Eingabe → Faltung + Aktivierung → Pooling → wiederholte Merkmalsextraktionsblöcke → vollständig verbundene Schicht → Ausgabe

Vorteile der Faltung:

lokale Mustererkennung

Die Faltung hilft dem Modell, kleine nützliche Muster in einem Bild zu finden, etwa Kanten, Ecken, Texturen oder einfache Formen. Diese kleinen Muster sind die grundlegenden Bausteine zum Verständnis größerer Objekte.

Parameter-Sharing

Derselbe Filter wird in verschiedenen Teilen des Bildes verwendet. Das bedeutet, das Modell muss nicht für jede Position eine neue Gewichtsmenge lernen, was es effizienter macht und die Anzahl der Parameter reduziert.

Robustheit gegenüber Verschiebung

Wenn sich ein Objekt an eine andere Stelle im Bild bewegt, kann der Faltungsfilter es immer noch erkennen. Mit anderen Worten: Das Modell kann dasselbe Muster auch dann erkennen, wenn sich seine Position ändert.

Feature Maps

Wenn eine Faltungsschicht ein Bild verarbeitet, erzeugt sie Feature Maps. Diese Karten reagieren auf Muster wie:

Kanten
Ecken
Texturen
größere semantische Strukturen in tieferen Schichten

Pooling und Downsampling

Pooling reduziert die räumliche Größe und behält dabei wichtige Informationen.

Das hilft:

den Rechenaufwand zu reduzieren
die Robustheit zu verbessern
kompaktere Repräsentationen aufzubauen

Probieren Sie es aus

bash

cd 4.4-Neural-Networks-and-CNNs/code
python cnn_process_visualization.py

🚀 Führen Sie das Skript aus, um den Verarbeitungsprozess des Faltungsnetzes auf dem Bild zu erleben.

Training vs. Inferenz

Training: Das Modell lernt durch Aktualisierung der Gewichte
Inference: Das trainierte Modell trifft Vorhersagen, ohne Gewichte zu aktualisieren

Diese Unterscheidung ist entscheidend, da sich die späteren Deployment-Kapitel hauptsächlich auf Inferenz konzentrieren.

Wie sieht ein CNN im Code aus?

python

mport torch
import torch.nn as nn

class TinyCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 16, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(16, 32, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2)
        )
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(32 * 56 * 56, 64),
            nn.ReLU(),
            nn.Linear(64, 10)
        )

    def forward(self, x):
        x = self.features(x)
        x = self.classifier(x)
        return x

model = TinyCNN()
dummy = torch.randn(1, 3, 224, 224)
output = model(dummy)
print(output.shape)

Häufige Missverständnisse

„Ein CNN sieht buchstäblich wie ein menschliches Auge."
- CNNs verarbeiten numerische Muster. Die Analogie ist hilfreich, aber nicht wörtlich zu nehmen.
„Mehr Schichten bedeuten immer bessere Leistung."
- Tiefere Modelle können leistungsfähiger sein, sind aber auch schwerer zu trainieren und einzusetzen.
„Wenn ich den Code verstehe, verstehe ich automatisch das Training."
- Training hängt auch von Daten, Verlust, Optimierung und Evaluierung ab.

Übungen / Reflexion

Erklären Sie in eigenen Worten, warum Faltung für Bilder besser geeignet ist als eine einfache vollständig verbundene Schicht.
Führen Sie das Tiny-CNN-Beispiel aus und geben Sie die Ausgabeform aus.
Ändern Sie die Anzahl der Ausgabekanäle in der ersten Faltung und beobachten Sie, wie sich die Modellstruktur ändert.
Überlegen Sie, wie sich CNNs von klassischen Filtern wie Weichzeichnen oder Kantendetektion unterscheiden.

Zusammenfassung

Neuronale Netze lernen Repräsentationen aus Daten, und CNNs sind für Bilder besonders effektiv, weil sie lokale Strukturen ausnutzen. Faltung, Feature Maps, Pooling und der Unterschied zwischen Training und Inferenz zu verstehen, bereitet Lernende auf moderne Vision-Aufgaben vor.

Vorgeschlagener nächster Schritt

Fahren Sie fort mit 4.5 Computer-Vision-Aufgaben mit Deep Learning.

Referenzen

PyTorch Tutorials

PreviousKlassische Computer Vision

NextDeep-Learning-Aufgaben für Computer Vision