Herausforderung: Aufbau eines CNN

Convolutional Neural Networks (CNNs) werden aufgrund ihrer Fähigkeit, hierarchische Merkmale zu extrahieren, häufig für die Bildklassifikation eingesetzt. In dieser Aufgabe wird ein VGG-ähnliches CNN mit TensorFlow und Keras auf dem CIFAR-10-Datensatz implementiert und trainiert. Der Datensatz besteht aus 60.000 Bildern (32×32×3), die zu 10 verschiedenen Klassen gehören, darunter Flugzeuge, Autos, Vögel, Katzen und weitere.

Dieses Projekt führt durch die Schritte Laden des Datensatzes, Vorverarbeitung der Bilder, Definition des CNN-Modells, Training und Auswertung der Leistung.

1. Datenvorverarbeitung für CNNs

Vor dem Training eines CNN ist die Vorverarbeitung der Daten ein entscheidender Schritt, um eine bessere Leistung und schnellere Konvergenz zu gewährleisten. Gängige Methoden der Vorverarbeitung sind:

• Normalisierung: Diese Methode skaliert die Pixelwerte der Bilder von einem Bereich zwischen 0 und 255 auf einen Bereich zwischen 0 und 1. Dies wird häufig als x_train / 255.0, x_test / 255.0 implementiert;

• One-Hot-Encoding: Labels werden häufig in One-Hot-codierte Vektoren für Klassifikationsaufgaben umgewandelt. Dies erfolgt typischerweise mit der Funktion keras.utils.to_categorical, die ganzzahlige Labels (z. B. 0, 1, 2, usw.) in einen One-Hot-codierten Vektor umwandelt, wie zum Beispiel [1, 0, 0, 0] für ein Klassifikationsproblem mit 4 Klassen.

2. Aufbau der CNN-Architektur

Eine CNN-Architektur besteht aus mehreren Schichten, die verschiedene Aufgaben zur Merkmalsextraktion und Vorhersage übernehmen. Zentrale CNN-Schichten können wie folgt implementiert werden:

Faltungsschicht (Conv2D)

keras.layers.Conv2D(filters, kernel_size, activation='relu', padding='same', input_shape=(height, width, channels))

Pooling-Schicht (MaxPooling2D)

keras.layers.MaxPooling2D(pool_size=(2, 2))

Flatten-Schicht

keras.layers.Flatten()

Dense-Schicht

layers.Dense(units=512, activation='relu')
layers.Dense(10, activation='softmax')

3. Modellkompilierung

Nach der Definition der Architektur muss das Modell kompiliert werden. In diesem Schritt werden die Verlustfunktion, der Optimierer und die Metriken festgelegt, die das Modell während des Trainings steuern. Die folgenden Methoden werden häufig bei CNNs verwendet:

Optimierer (Adam)

Der Optimierer passt die Gewichte des Modells an, um die Verlustfunktion zu minimieren. Der Adam-Optimierer ist aufgrund seiner Effizienz und der Fähigkeit, die Lernrate während des Trainings anzupassen, sehr beliebt.

keras.optimizers.Adam()

Verlustfunktion (Categorical Crossentropy)

Für Mehrklassenklassifikation wird typischerweise die kategorische Kreuzentropie als Verlustfunktion verwendet. Dies kann wie folgt implementiert werden:

keras.losses.CategoricalCrossentropy()

Metriken

Die Modellleistung wird bei Klassifikationsaufgaben mit Metriken wie Genauigkeit, Präzision, Recall usw. überwacht. Diese können wie folgt definiert werden:

metrics = [
    keras.metrics.Accuracy(), 
    keras.metrics.Precision(), 
    keras.metrics.Recall()
]

Kompilieren

model.compile(optimizer='adam', 
              loss='categorical_crossentropy', # Or keras.losses.CategoricalCrossentropy()
              metrics=metrics)

4. Training des Modells

Das Training eines CNN umfasst das Einspeisen der Eingabedaten in das Netzwerk, das Berechnen des Verlusts und das Aktualisieren der Gewichte mittels Backpropagation. Der Trainingsprozess wird durch die folgenden zentralen Methoden gesteuert:

• Anpassen des Modells: Die Methode fit() wird verwendet, um das Modell zu trainieren. Diese Methode erhält die Trainingsdaten, die Anzahl der Epochen und die Batch-Größe. Zusätzlich kann ein optionaler Validierungsanteil angegeben werden, um die Modellleistung während des Trainings an unbekannten Daten zu bewerten:

history = model.fit(x_train, y_train, epochs=10, batch_size=32, validation_split=0.2)

• Batch-Größe und Epochen: Die Batch-Größe bestimmt die Anzahl der Stichproben, die verarbeitet werden, bevor die Modellgewichte aktualisiert werden, und die Anzahl der Epochen gibt an, wie oft der gesamte Datensatz durch das Modell geführt wird.

5. Auswertung

Klassifikationsbericht

sklearn.metrics.classification_report() vergleicht wahre und vorhergesagte Werte aus dem Testdatensatz. Es enthält Präzision, Recall und F1-Score für jede Klasse. Die Methoden benötigen jedoch nur Klassenlabels, daher nicht vergessen, diese aus den Vektoren zurückzukonvertieren ([0,0,1,0] -> 2):

y_pred = model.predict(x_test)
y_pred_classes = np.argmax(y_pred,axis = 1)
y_test_classes = np.argmax(y_test, axis = 1)

report = classification_report(y_test_classes, y_pred_classes, target_names=class_names)
print(report)

Auswertung

Nach dem Training des Modells wird dieses auf dem Testdatensatz ausgewertet, um seine Generalisierungsfähigkeit zu beurteilen. Die Auswertung liefert Metriken, die bereits in der .compile()-Methode erwähnt wurden. Die Auswertung erfolgt mit .evaluate():

results = model.evaluate(x_test, y_test, verbose=2, return_dict=True)

Konfusionsmatrix

Um weitere Einblicke in die Modellleistung zu erhalten, kann die Konfusionsmatrix visualisiert werden. Sie zeigt True Positives, False Positives, True Negatives und False Negatives für jede Klasse. Die Konfusionsmatrix kann mit TensorFlow berechnet werden:

confusion_mtx = tf.math.confusion_matrix(y_test_classes, y_pred_classes)

Diese Matrix kann anschließend mithilfe von Heatmaps visualisiert werden, um zu beobachten, wie gut das Modell für jede Klasse arbeitet:

plt.figure(figsize=(12, 9))
c = sns.heatmap(confusion_mtx, annot=True, fmt='g')
c.set(xticklabels=class_names, yticklabels=class_names)

plt.show()

1. Laden und Vorverarbeiten des Datensatzes

• CIFAR-10-Datensatz aus Keras importieren;
• Pixelwerte zur besseren Konvergenz auf den Bereich [0,1] normalisieren;
• Klassenlabels in das one-hot encoded-Format für die kategoriale Klassifikation umwandeln.

2. Definition des CNN-Modells

Implementierung einer VGG-ähnlichen CNN-Architektur mit den folgenden Schlüsselschichten:

Convolutional Layers:

• Kernelgröße: 3×3;
• Aktivierungsfunktion: ReLU;
• Padding: 'same'.

Pooling Layers:

• Pooling-Typ: max pooling;
• Pooling-Größe: 2×2.

Dropout-Schichten (Verhindern von Overfitting durch zufälliges Deaktivieren von Neuronen):

• Dropout-Rate: 25%.

Flatten-Schicht – Umwandlung von 2D-Feature-Maps in einen 1D-Vektor für die Klassifikation.

Vollständig verbundene Schichten – Dichte Schichten für die finale Klassifikation, mit einer ReLU- oder Softmax-Ausgabeschicht.

Kompilieren des Modells mit:

• Adam optimizer (für effizientes Lernen);
• Categorical cross-entropy als Verlustfunktion (für Mehrklassenklassifikation);
• Accuracy metric zur Leistungsbewertung (Klassen sind ausgeglichen, weitere Metriken können ergänzt werden).

3. Training des Modells

• Angabe der Parameter epochs und batch_size für das Training (z. B. epochs=20, batch_size=64);
• Festlegung des Parameters validation_split, um den Prozentsatz der Trainingsdaten als Validierungsdaten zu definieren und die Modellleistung an unbekannten Bildern zu verfolgen;
• Speichern des Trainingsverlaufs zur Visualisierung von Genauigkeits- und Verlusttrends.

4. Auswertung und Visualisierung der Ergebnisse

• Testen des Modells auf den CIFAR-10-Testdaten und Ausgabe der Genauigkeit;
• Plotten von Trainingsverlust vs. Validierungsverlust zur Überprüfung von Overfitting;
• Plotten von Trainingsgenauigkeit vs. Validierungsgenauigkeit zur Sicherstellung des Lernfortschritts.

COLAB CNN PROJEKT