Herausforderung: Aufbau eines Convolutional Neural Network
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))
Den Parameter input_shape
muss man nur in der Eingabeschicht angeben.
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')
Die finale Dense-Schicht besitzt in der Regel eine Anzahl von Einheiten, die der Anzahl der Klassen entspricht, und verwendet eine Softmax-Aktivierungsfunktion, um eine Wahrscheinlichkeitsverteilung über die Klassen auszugeben.
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
undbatch_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.
Danke für Ihr Feedback!
Fragen Sie AI
Fragen Sie AI
Fragen Sie alles oder probieren Sie eine der vorgeschlagenen Fragen, um unser Gespräch zu beginnen
Awesome!
Completion rate improved to 3.45
Herausforderung: Aufbau eines Convolutional Neural Network
Swipe um das Menü anzuzeigen
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))
Den Parameter input_shape
muss man nur in der Eingabeschicht angeben.
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')
Die finale Dense-Schicht besitzt in der Regel eine Anzahl von Einheiten, die der Anzahl der Klassen entspricht, und verwendet eine Softmax-Aktivierungsfunktion, um eine Wahrscheinlichkeitsverteilung über die Klassen auszugeben.
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
undbatch_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.
Danke für Ihr Feedback!