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 sind:

• 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 transformiert, 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:

• 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. Zusätzlich kann ein optionaler Validierungsanteil angegeben werden, 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 Stichproben, 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. Es enthält Präzision, Recall und F1-Score für jede Klasse. Die Methoden benötigen jedoch nur Klassenlabels, daher nicht vergessen, die Vektoren zurück in Labels umzuwandeln ([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, wird es 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 Leistung des Modells zu erhalten, kann die Konfusionsmatrix visualisiert werden. Sie zeigt die wahren Positiven, falschen Positiven, wahren Negativen und falschen Negativen Vorhersagen 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

• 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 kategoriale 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-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 – Dense-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 (die Klassen sind ausgeglichen, weitere Metriken können optional hinzugefügt 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, um die Modellleistung auf 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 auf Overfitting;
• Plotten von Trainingsgenauigkeit vs. Validierungsgenauigkeit zur Sicherstellung des Lernfortschritts.

COLAB CNN PROJEKT