Deep Learning mit CNN: Convolutional Neural Network Leitfaden

Convolutional Neural Networks (CNNs) gehören zu den leistungsstärksten Architekturen im Deep Learning. Sie liefern bahnbrechende Ergebnisse bei Bildklassifikation, Objekterkennung, Gesichtserkennung und medizinischer Bildanalyse. In diesem Artikel untersuchen wir die Kernkomponenten von CNNs und erstellen ein praktisches Modell mit TensorFlow/Keras.

Was ist Deep Learning?

Deep Learning ist ein Teilbereich des Machine Learning, bei dem künstliche neuronale Netze mit mehreren Schichten aufgebaut werden. Während traditionelles ML manuelle Feature-Extraktion erfordert, lernen Deep-Learning-Modelle automatisch hierarchische Merkmale aus Rohdaten.

Warum CNN?

Vollständig verbundene Netze sind für Bilddaten ineffizient. Ein 224x224x3-RGB-Bild hat 150.528 Eingangsneuronen. CNNs lösen dieses Problem durch:

• Parameterfreigabe: Derselbe Filter wird über das gesamte Bild geschoben
• Lokale Konnektivität: Jedes Neuron betrachtet nur einen kleinen Bereich
• Räumliche Hierarchie: Untere Schichten lernen Kanten, obere Schichten komplexe Strukturen

CNN-Architektur

Faltungsschicht (Convolution Layer)

Das Herzstück eines CNN. Kleine Filter (Kernel) werden über das Bild geschoben und erzeugen Feature Maps.

Pooling-Schicht

Reduziert die Dimensionen der Feature Maps, senkt Rechenkosten und verhindert Overfitting. Max Pooling nimmt den Maximalwert innerhalb des Fensters.

Vollständig verbundene Schicht

Befindet sich in den letzten Schichten und wandelt gelernte Merkmale in Klassenvorhersagen um.

CNN-Modell mit TensorFlow/Keras

import tensorflow as tf
from tensorflow.keras import layers, models

# CNN-Modell erstellen
model = models.Sequential([
    # Erster Faltungsblock
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
    layers.BatchNormalization(),
    layers.MaxPooling2D((2, 2)),

    # Zweiter Faltungsblock
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.BatchNormalization(),
    layers.MaxPooling2D((2, 2)),

    # Dritter Faltungsblock
    layers.Conv2D(128, (3, 3), activation='relu'),
    layers.BatchNormalization(),

    # Klassifikationsschichten
    layers.GlobalAveragePooling2D(),
    layers.Dense(128, activation='relu'),
    layers.Dropout(0.5),
    layers.Dense(10, activation='softmax')
])

model.summary()

Daten laden und Modell trainieren

# CIFAR-10 Datensatz laden
(X_train, y_train), (X_test, y_test) = tf.keras.datasets.cifar10.load_data()

# Pixelwerte auf [0, 1] normalisieren
X_train = X_train.astype('float32') / 255.0
X_test = X_test.astype('float32') / 255.0

# Modell kompilieren
model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# Callbacks
callbacks = [
    tf.keras.callbacks.EarlyStopping(
        monitor='val_loss', patience=5, restore_best_weights=True
    ),
    tf.keras.callbacks.ReduceLROnPlateau(
        monitor='val_loss', factor=0.5, patience=3
    )
]

# Training
history = model.fit(
    X_train, y_train,
    epochs=50,
    batch_size=64,
    validation_split=0.2,
    callbacks=callbacks
)

# Evaluation
test_loss, test_acc = model.evaluate(X_test, y_test)
print(f"Test-Genauigkeit: {test_acc:.2%}")

Dropout und Regularisierung

Overfitting ist eines der häufigsten Probleme in tiefen neuronalen Netzen. Dropout deaktiviert während des Trainings zufällig Neuronen und verhindert so eine übermäßige Abhängigkeit von bestimmten Neuronen. In vollständig verbundenen Schichten sind Dropout-Raten von 30-50% üblich, bei Faltungsschichten 10-25%.

L2-Regularisierung bestraft große Gewichtswerte und hält das Modell einfacher:

from tensorflow.keras import regularizers

model_reg = models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3),
                  kernel_regularizer=regularizers.l2(1e-4)),
    layers.BatchNormalization(),
    layers.MaxPooling2D((2, 2)),
    layers.Dropout(0.15),

    layers.Conv2D(64, (3, 3), activation='relu',
                  kernel_regularizer=regularizers.l2(1e-4)),
    layers.BatchNormalization(),
    layers.MaxPooling2D((2, 2)),
    layers.Dropout(0.2),

    layers.Conv2D(128, (3, 3), activation='relu',
                  kernel_regularizer=regularizers.l2(1e-4)),
    layers.BatchNormalization(),

    layers.GlobalAveragePooling2D(),
    layers.Dense(256, activation='relu',
                 kernel_regularizer=regularizers.l2(1e-4)),
    layers.Dropout(0.5),
    layers.Dense(10, activation='softmax')
])

Learning Rate Scheduling

Eine feste Lernrate ist oft nicht optimal. Zu Beginn des Trainings erkundet eine höhere Lernrate den Parameterraum, danach wird sie für feinere Anpassungen reduziert:

lr_schedule = tf.keras.optimizers.schedules.CosineDecay(
    initial_learning_rate=0.001,
    decay_steps=1000,
    alpha=1e-6
)

optimizer = tf.keras.optimizers.Adam(learning_rate=lr_schedule)

Modellbewertung mit Confusion Matrix

Für ein tiefes Verständnis der Modellleistung sind Confusion Matrices und klassenspezifische Metriken unerlässlich:

from sklearn.metrics import confusion_matrix, classification_report
import seaborn as sns
import numpy as np

y_pred = model.predict(X_test)
y_pred_classes = np.argmax(y_pred, axis=1)
y_true = y_test.flatten()

klassen = ['Flugzeug', 'Auto', 'Vogel', 'Katze', 'Hirsch',
           'Hund', 'Frosch', 'Pferd', 'Schiff', 'LKW']

cm = confusion_matrix(y_true, y_pred_classes)

plt.figure(figsize=(10, 8))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
            xticklabels=klassen, yticklabels=klassen)
plt.title('Confusion Matrix')
plt.xlabel('Vorhergesagt')
plt.ylabel('Tatsächlich')
plt.tight_layout()
plt.show()

print(classification_report(y_true, y_pred_classes, target_names=klassen))

Transfer Learning

Anstatt von Grund auf zu trainieren, können vortrainierte Modelle genutzt werden, um mit weniger Daten eine hohe Leistung zu erzielen. Die unteren Schichten eines ImageNet-trainierten Modells haben bereits universelle Merkmale wie Kanten und Texturen gelernt.

base_model = tf.keras.applications.ResNet50V2(
    include_top=False, weights='imagenet', input_shape=(224, 224, 3)
)
base_model.trainable = False

model_tl = models.Sequential([
    base_model,
    layers.GlobalAveragePooling2D(),
    layers.BatchNormalization(),
    layers.Dense(256, activation='relu'),
    layers.Dropout(0.4),
    layers.Dense(10, activation='softmax')
])

Bekannte CNN-Architekturen

• LeNet-5 (1998): Handschrifterkennung
• AlexNet (2012): Gewann ImageNet, startete die Deep-Learning-Revolution
• VGGNet (2014): Zeigte die Stärke tiefer Netze mit 3x3-Filtern
• ResNet (2015): Ermöglichte Training bis 152 Schichten durch Skip Connections
• EfficientNet (2019): Effiziente Architektur durch Compound Scaling

Optimierungstipps

1. Batch Normalization: Nach jeder Schicht zur Stabilisierung des Trainings
2. Dropout: 30-50% in vollständig verbundenen Schichten
3. Data Augmentation: Datensatz künstlich vergrößern
4. Learning Rate Scheduling: Lernrate im Trainingsverlauf reduzieren

Zusammenfassung

CNNs sind die Grundbausteine der Bildklassifikation und Computer Vision. Durch die Kombination von Faltungs-, Pooling- und vollständig verbundenen Schichten extrahieren sie aussagekräftige Merkmale aus Rohpixeldaten. Dropout und L2-Regularisierung halten Overfitting in Schach, während Learning Rate Scheduling den Trainingsprozess optimiert. Confusion-Matrix-Analyse zeigt Schwächen bei bestimmten Klassen auf, und Transfer Learning ermöglicht hohe Genauigkeit auch mit begrenzten Daten. Mit TensorFlow/Keras lassen sich diese Architekturen in wenigen Codezeilen erstellen und durch moderne Techniken wie Feature-Map-Visualisierung analysieren.