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 Ladung des Datensatzes, die Vorverarbeitung der Bilder, die Definition des CNN-Modells, das Training sowie die Auswertung der Modellleistung.

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 Vorverarbeitungsmethoden umfassen:

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

• 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 etwa [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:

Convolutional Layer (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 in 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 Hauptmethoden gesteuert:

• Modell anpassen: 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. Sie beinhaltet außerdem einen optionalen Validierungsanteil, um die Leistung des Modells auf unbekannten Daten während des Trainings 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 Samples, die verarbeitet werden, bevor die Modellgewichte aktualisiert werden, und die Anzahl der Epochen gibt an, wie oft der gesamte Datensatz durch das Modell geleitet wird.

5. Auswertung

Klassifikationsbericht

sklearn.metrics.classification_report() vergleicht wahre und vorhergesagte Werte aus dem Testdatensatz. 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ückzuwandeln ([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

Nachdem das Modell trainiert wurde, erfolgt die Auswertung am Testdatensatz, um die Generalisierungsfähigkeit zu beurteilen. Die Auswertung liefert Metriken, die bereits in der .compile()-Methode genannt 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 abschneidet:

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

plt.show()

Aufgabe

1. Laden und Vorverarbeiten des Datensatzes

• Importieren des CIFAR-10-Datensatzes aus Keras;
• Normalisierung der Pixelwerte auf den Bereich [0,1] für bessere Konvergenz;
• Umwandlung der Klassenlabels in das one-hot encoded Format für die kategorische Klassifikation.

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 Layers (Verhindern von Overfitting durch zufälliges Deaktivieren von Neuronen):

• Dropout-Rate: 25%.

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

Fully Connected Layers – 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 Verlustfunktion (für Mehrklassenklassifikation);
• Accuracy metric zur Messung der Leistung (Klassen sind ausgeglichen, weitere Metriken können ergänzt werden).

3. Training des Modells

• Festlegen der Parameter epochs und batch_size für das Training (z. B. epochs=20, batch_size=64);
• Festlegen 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 Ausgeben der Genauigkeit;
• Plotten von Trainingsverlust vs. Validierungsverlust zur Überprüfung von Overfitting;
• Plotten von Trainingsgenauigkeit vs. Validierungsgenauigkeit zur Sicherstellung des Lernfortschritts.

COLAB CNN PROJEKT