CNN

CNN (Convolutional Neural Network), auf Deutsch Faltendes Neuronales Netzwerk, ist eine spezialisierte Architektur im Bereich des Deep Learning, die besonders für die Verarbeitung von Bildern und anderen gitterförmigen Daten optimiert ist. CNNs erkennen automatisch Muster wie Kanten, Formen und komplexe Objekte in Bildern und bilden heute das Rückgrat vieler Computer-Vision-Anwendungen.

Die Architektur basiert auf dem biologischen Vorbild des visuellen Kortex und nutzt mathematische Faltungsoperationen (Convolutions), um hierarchische Merkmale aus Eingabedaten zu extrahieren. CNNs haben seit dem Durchbruch von AlexNet im Jahr 2012 die Bildverarbeitung revolutioniert und sind aus modernen KI-Systemen nicht mehr wegzudenken.

Geschichte und Entwicklung

Die Geschichte der CNNs reicht zurück bis in die 1980er Jahre. Die grundlegenden Konzepte wurden von der Forschung zum visuellen Kortex von Säugetieren inspiriert, insbesondere von den Arbeiten von David Hubel und Torsten Wiesel über einfache und komplexe Zellen im Sehsystem.

Wichtige Meilensteine

• 1980: Kunihiko Fukushima stellt das Neocognitron vor, einen frühen Vorlaeufer der CNNs
• 1989: Yann LeCun entwickelt LeNet für die Handschrifterkennung bei AT&T Bell Labs
• 1998: LeNet-5 wird erfolgreich für die Erkennung von Postleitzahlen eingesetzt
• 2012: AlexNet gewinnt die ImageNet-Challenge mit deutlichem Vorsprung und loest den Deep-Learning-Boom aus
• 2014: VGGNet und GoogLeNet (Inception) verbessern die Architektur weiter
• 2015: ResNet einfuehrt Residual Connections und ermöglicht sehr tiefe Netzwerke
• 2020er: CNNs werden mit Vision Transformers kombiniert und bleiben ein Kernbestandteil moderner Bildverarbeitung

Der Durchbruch von AlexNet 2012 war ein Wendepunkt: Das Netzwerk erreichte eine Top-5-Fehlerrate von 15,3% auf ImageNet, waehrend der zweitplatzierte traditionelle Ansatz bei 26,2% lag. Diese drastische Verbesserung überzeugte die Forschungsgemeinschaft vom Potenzial tiefer neuronaler Netze.

Aufbau und Schichten eines CNN

Ein typisches CNN besteht aus mehreren Schichttypen, die nacheinander angeordnet sind und zunehmend abstrakte Merkmale aus den Eingabedaten extrahieren. Die Kombination dieser Schichten ermöglicht es dem Netzwerk, von einfachen Kanten bis hin zu komplexen Objekten zu lernen.

Eingabeschicht (Input Layer)

Die Eingabeschicht nimmt die Rohdaten entgegen, typischerweise als mehrdimensionales Array (Tensor). Bei Farbbildern hat die Eingabe die Form Höhe x Breite x Kanaele, wobei die drei Farbkanaele (Rot, Gruen, Blau) die Tiefe definieren. Ein 224x224 Pixel grosses RGB-Bild hat beispielsweise die Form 224 x 224 x 3.

Faltungsschicht (Convolutional Layer)

Die Faltungsschicht ist das Herzstuck eines CNN. Hier werden kleine Filter (auch Kernel genannt) über das Eingabebild geschoben und erzeugen dabei Feature Maps. Jeder Filter erkennt ein bestimmtes Muster - frühe Schichten lernen einfache Merkmale wie Kanten und Ecken, spätere Schichten kombinieren diese zu komplexeren Formen wie Augen, Räder oder ganzen Objekten.

Die wichtigsten Parameter einer Faltungsschicht sind:

• Filtergrösse: Typischerweise 3x3 oder 5x5 Pixel
• Anzahl der Filter: Bestimmt die Tiefe der Ausgabe (z.B. 64, 128, 256 Filter)
• Stride: Schrittweite, mit der der Filter verschoben wird
• Padding: Auffüllen der Raender, um die Ausgabegrösse zu steuern

Aktivierungsfunktion (ReLU)

Nach jeder Faltung wird eine nichtlineare Aktivierungsfunktion angewendet. Die am häufigsten verwendete Funktion ist ReLU (Rectified Linear Unit), die alle negativen Werte auf Null setzt: f(x) = max(0, x). Diese einfache Funktion ermöglicht es dem Netzwerk, komplexe nichtlineare Zusammenhänge zu lernen und verhindert das Problem verschwindender Gradienten.

Pooling-Schicht

Pooling-Schichten reduzieren die räumliche Auflösung der Feature Maps und machen das Netzwerk robuster gegenüber kleinen Verschiebungen im Bild. Das gängigste Verfahren ist Max Pooling, bei dem aus einem Fenster (z.B. 2x2 Pixel) nur der maximale Wert übernommen wird. Dadurch halbiert sich die Breite und Höhe der Feature Map, waehrend die wichtigsten Aktivierungen erhalten bleiben.

Vollvernetzte Schicht (Fully Connected Layer)

Am Ende des Netzwerks werden die extrahierten Merkmale durch vollvernetzte Schichten geleitet, die alle Neuronen der vorherigen Schicht mit allen Neuronen der aktuellen Schicht verbinden. Diese Schichten kombinieren die lokalen Merkmale zu einer globalen Repraesentation und fuehren die finale Klassifikation durch.

Ausgabeschicht (Output Layer)

Die Ausgabeschicht produziert das finale Ergebnis. Bei Klassifikationsaufgaben wird oft eine Softmax-Funktion verwendet, die die Ausgabe in Wahrscheinlichkeiten für jede Klasse umwandelt. Die Summe aller Wahrscheinlichkeiten ergibt 1, und die Klasse mit der hoechsten Wahrscheinlichkeit ist die Vorhersage des Netzwerks.

Funktionsweise der Faltungsoperation

Die namensgebende Faltung (Convolution) ist eine mathematische Operation, bei der ein kleiner Filter Element für Element mit einem Ausschnitt des Eingabebildes multipliziert und die Ergebnisse summiert werden. Dieser Vorgang wird für jeden möglichen Bildausschnitt wiederholt.

Stell dir vor, du haeltst eine kleine Schablone (den Filter) über ein Bild und berechnest, wie gut das Muster der Schablone zum darunterliegenden Bildausschnitt passt. Wenn der Filter beispielsweise eine vertikale Kante repräsentiert, wird er hohe Werte produzieren, wo im Bild tatsaechlich vertikale Kanten vorkommen.

import numpy as np

# Beispiel: Vereinfachte Faltungsoperation
def convolution_2d(image, kernel):
    """Fuehrt eine 2D-Faltung durch."""
    img_h, img_w = image.shape
    k_h, k_w = kernel.shape
    
    # Ausgabegroesse berechnen
    out_h = img_h - k_h + 1
    out_w = img_w - k_w + 1
    output = np.zeros((out_h, out_w))
    
    # Filter ueber das Bild schieben
    for i in range(out_h):
        for j in range(out_w):
            # Elementweise Multiplikation und Summe
            region = image[i:i+k_h, j:j+k_w]
            output[i, j] = np.sum(region * kernel)
    
    return output

# Beispiel-Kernel fuer Kantenerkennung (Sobel)
sobel_horizontal = np.array([
    [-1, -2, -1],
    [ 0,  0,  0],
    [ 1,  2,  1]
])

print("Sobel-Filter fuer horizontale Kanten:")
print(sobel_horizontal)

Bekannte CNN-Architekturen

Im Laufe der Jahre wurden verschiedene CNN-Architekturen entwickelt, die jeweils neue Konzepte einfuehrten und die Leistung verbesserten. Hier sind die wichtigsten Meilensteine:

ResNet war ein besonders wichtiger Durchbruch: Die Residual Connections (Skip Connections) ermöglichten das Training von Netzwerken mit über 100 Schichten, indem sie das Problem verschwindender Gradienten loesten. Die Idee ist einfach aber wirkungsvoll: Die Eingabe einer Schicht wird direkt zur Ausgabe addiert, sodass das Netzwerk nur die Differenz (Residuum) lernen muss.

Einfaches CNN mit PyTorch

Hier ist ein Beispiel für ein einfaches CNN zur Bildklassifikation mit PyTorch. Das Netzwerk folgt dem klassischen Muster aus Faltungsschichten, ReLU-Aktivierungen, Pooling und vollvernetzten Schichten:

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

class SimpleCNN(nn.Module):
    def __init__(self, num_classes=10):
        super(SimpleCNN, self).__init__()
        
        # Erste Faltungsschicht: 3 Eingangskanaele -> 32 Feature Maps
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=32, 
                               kernel_size=3, padding=1)
        
        # Zweite Faltungsschicht: 32 -> 64 Feature Maps
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        
        # Dritte Faltungsschicht: 64 -> 128 Feature Maps
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
        
        # Max Pooling reduziert die Aufloesung
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
        
        # Vollvernetzte Schichten fuer Klassifikation
        # Nach 3x Pooling: 224 -> 112 -> 56 -> 28 Pixel
        self.fc1 = nn.Linear(128 * 28 * 28, 512)
        self.fc2 = nn.Linear(512, num_classes)
        
        # Dropout zur Regularisierung
        self.dropout = nn.Dropout(0.5)
    
    def forward(self, x):
        # Erste Faltung + ReLU + Pooling
        x = self.pool(F.relu(self.conv1(x)))
        
        # Zweite Faltung + ReLU + Pooling
        x = self.pool(F.relu(self.conv2(x)))
        
        # Dritte Faltung + ReLU + Pooling
        x = self.pool(F.relu(self.conv3(x)))
        
        # Flatten fuer vollvernetzte Schichten
        x = x.view(x.size(0), -1)
        
        # Vollvernetzte Schichten mit Dropout
        x = self.dropout(F.relu(self.fc1(x)))
        x = self.fc2(x)
        
        return x

# Modell erstellen
model = SimpleCNN(num_classes=10)
print(f"Modell-Parameter: {sum(p.numel() for p in model.parameters()):,}")

Anwendungsgebiete

CNNs finden heute in zahlreichen Bereichen Anwendung, überall dort wo visuelle Daten analysiert werden muessen. Hier sind die wichtigsten Einsatzgebiete:

Bildklassifikation

Die klassische CNN-Aufgabe: Ein Bild wird einer Kategorie zugeordnet. Anwendungen reichen von der Erkennung von Pflanzenarten oder Tierrassen bis zur Klassifikation von Produkten im E-Commerce oder medizinischen Bildern.

Objekterkennung

Bei der Objekterkennung (Object Detection) werden nicht nur Objekte klassifiziert, sondern auch ihre Position im Bild durch Bounding Boxes markiert. Bekannte Architekturen sind YOLO (You Only Look Once), Faster R-CNN und SSD. Diese Technologie steckt hinter autonomen Fahrzeugen, Sicherheitssystemen und Augmented-Reality-Anwendungen.

Semantische Segmentierung

Hier wird jedes Pixel im Bild einer Klasse zugeordnet. Anwendungen finden sich in der medizinischen Bildgebung (Tumorerkennung), beim autonomen Fahren (Strasse vs. Gehweg vs. Fahrzeuge) und in der Satellitenbild-Analyse.

Gesichtserkennung

CNNs ermöglichen die zuverlässige Erkennung und Verifikation von Gesichtern. Diese Technologie wird für Entsperrung von Smartphones, Zugangskontrolle und auch für umstrittene Überwachungsanwendungen eingesetzt.

Medizinische Bildanalyse

In der Medizin helfen CNNs bei der Analyse von Röntgenbildern, CT-Scans und MRT-Aufnahmen. Sie können Anomalien erkennen, die menschlichen Augen entgehen koennten, und unterstützen Ärzte bei der Diagnose von Krebs, Augenkrankheiten und anderen Erkrankungen.

Vor- und Nachteile von CNNs

Vorteile

• Automatisches Feature Learning: CNNs lernen relevante Merkmale selbst, ohne manuelle Feature-Extraktion
• Translationsinvarianz: Objekte werden unabhaengig von ihrer Position im Bild erkannt
• Parameter-Effizienz: Durch Weight Sharing werden weniger Parameter benoetigt als bei vollvernetzten Netzen
• Hierarchisches Lernen: Von einfachen zu komplexen Merkmalen
• Bewaehrte Architekturen: Viele vortrainierte Modelle verfuegbar (Transfer Learning)

Nachteile

• Rechenintensiv: Training erfordert leistungsstarke GPUs oder TPUs
• Grosse Datensaetze noetig: Für gute Ergebnisse werden viele Trainingsbeispiele benoetigt
• Black Box: Die gelernten Merkmale sind schwer interpretierbar
• Empfindlich gegen Rotationen: Starke Rotationen können Probleme verursachen
• Adversarial Examples: Kleine, für Menschen unsichtbare Stoerungen können zu Fehlklassifikationen fuehren

CNNs vs. Vision Transformer

Seit 2020 haben Vision Transformer (ViT) die Dominanz von CNNs in einigen Bildverarbeitungsaufgaben herausgefordert. Waehrend CNNs auf lokalen Faltungsoperationen basieren, nutzen Transformer globale Aufmerksamkeitsmechanismen (Attention).

In der Praxis werden heute oft hybride Ansaetze verwendet, die CNN-Komponenten mit Transformer-Elementen kombinieren. CNNs bleiben aufgrund ihrer Effizienz und guten Performance bei begrenzten Daten weiterhin relevant, insbesondere für Echtzeitanwendungen und Edge-Geraete.

Transfer Learning mit CNNs

Transfer Learning ist eine Technik, bei der ein auf einem grossen Datensatz (wie ImageNet mit Millionen von Bildern) vortrainiertes CNN für eine neue Aufgabe angepasst wird. Die frühen Schichten des Netzwerks, die allgemeine Merkmale wie Kanten und Texturen gelernt haben, werden beibehalten, waehrend nur die letzten Schichten neu trainiert werden.

Diese Methode hat mehrere Vorteile: Sie spart Trainingszeit, benoetigt weniger Daten und fuehrt oft zu besseren Ergebnissen als ein Training von Grund auf. In der Praxis ist Transfer Learning der Standardansatz, wenn du mit CNNs arbeitest und nicht Millionen von Trainingsbildern zur Verfuegung hast.

import torch
import torchvision.models as models
import torch.nn as nn

# Vortrainiertes ResNet18 laden
model = models.resnet18(pretrained=True)

# Alle Parameter einfrieren (kein Training)
for param in model.parameters():
    param.requires_grad = False

# Letzte Schicht ersetzen fuer eigene Klassenzahl
num_features = model.fc.in_features
model.fc = nn.Linear(num_features, num_classes=5)  # z.B. 5 Klassen

# Nur die neue Schicht wird trainiert
print("Transfer Learning: Nur die letzte Schicht wird trainiert")

CNNs in der Praxis

Als Fachinformatiker für Anwendungsentwicklung wirst du CNNs möglicherweise in Projekten einsetzen, die Bildverarbeitung erfordern. Die grossen Deep-Learning-Frameworks wie PyTorch und TensorFlow bieten umfangreiche Unterstützung für CNNs, einschliesslich vortrainierter Modelle und einfacher APIs.

Für effizientes Training und Inferenz werden GPUs benoetigt, die durch ihre parallele Architektur ideal für die Matrixoperationen in CNNs geeignet sind. Cloud-Dienste wie Google Colab oder AWS bieten Zugang zu GPUs für Experimente und Training.

In der Systemintegration sind CNNs relevant, wenn du Infrastruktur für KI-Workloads planst. Bilderkennungssysteme, Qualitaetskontrolle in der Fertigung oder Videoanalyse erfordern entsprechende Hardware und Netzwerkkapazitaeten.

Quellen und weiterfuehrende Links

• Stanford CS231n: Convolutional Neural Networks for Visual Recognition
• PyTorch CNN Tutorial
• CNN Explainer - Interaktive Visualisierung
• ImageNet Large Scale Visual Recognition Challenge
• Deep Residual Learning (ResNet Paper)