Convolutional Neural Networks (CNN) mit TensorFlow Tutorial

Stell dir vor, du bist im Zoo und willst erkennen, ob ein Tier ein Gepard oder ein Leopard ist. Dein Gehirn analysiert mühelos Körper- und Gesichtsmerkmale und kommt zu einem stimmigen Ergebnis. Genauso lassen sich Convolutional Neural Networks (CNNs) trainieren, um dieselbe Erkennungsaufgabe zu lösen – selbst bei komplexen Mustern. Das macht sie so mächtig in der Computer Vision. 

Dieses konzeptionelle CNN-Tutorial startet mit einem Überblick darüber, was CNNs sind und warum sie im Machine Learning wichtig sind. Anschließend führt es dich Schritt für Schritt durch die Implementierung eines CNNs im TensorFlow-Framework 2.

Was ist ein CNN?

Ein Convolutional Neural Network (CNN oder ConvNet) ist ein Deep-Learning-Algorithmus, der speziell für Aufgaben konzipiert ist, bei denen Objekterkennung entscheidend ist – etwa Bildklassifikation, -erkennung und -segmentierung.  Viele Anwendungen aus der Praxis, etwa autonome Fahrzeuge, Überwachungskameras und mehr, nutzen CNNs. 

Warum CNNs wichtig sind

Es gibt mehrere Gründe, warum CNNs so wichtig sind:

• Im Gegensatz zu klassischen Machine-Learning-Modellen wie SVMs oder Entscheidungsbäumen, die manuelle Merkmalsextraktion erfordern, erledigen CNNs die automatische Merkmalsextraktion in großem Maßstab – effizient und leistungsfähig. 
• Die Convolution-Schichten machen CNNs translationsinvariant. Sie erkennen Muster und extrahieren Merkmale unabhängig von ihrer Position – auch wenn ein Bild rotiert, skaliert oder verschoben ist.
• Zahlreiche vortrainierte CNN-Modelle wie VGG-16, ResNet50, Inceptionv3 und EfficientNet haben nachweislich den Stand der Technik erreicht und lassen sich mit relativ wenig Daten auf neue Aufgaben feinjustieren. 
• CNNs lassen sich auch jenseits der Bildklassifikation einsetzen, zum Beispiel für Natural Language Processing, Zeitreihenanalyse und Spracherkennung.

Architektur eines CNN

Die Architektur von CNNs orientiert sich an der Struktur von Neuronen im menschlichen Sehsystem: Sie besteht aus mehreren Schichten, von denen jede bestimmte Merkmale in den Daten erkennt.  Wie in der folgenden Grafik dargestellt, setzt sich ein typisches CNN aus vier Hauptschichten zusammen: 

• Convolutional Layers
• Rectified Linear Unit (kurz ReLU)
• Pooling Layers
• Fully Connected Layers 

Schauen wir uns an einem Beispiel zur Klassifikation handgeschriebener Ziffern an, wie diese Schichten arbeiten.

Convolution-Schichten

Das ist der erste Baustein eines CNN. Wie der Name vermuten lässt, wird hier vor allem die Faltung (Convolution) ausgeführt: Eine gleitende Fensterfunktion wird auf eine Pixelmatrix eines Bildes angewendet. Diese gleitende Funktion heißt Kernel oder Filter – beide Begriffe werden synonym verwendet. 

In der Convolution-Schicht werden mehrere gleich große Filter angewendet. Jeder Filter erkennt ein bestimmtes Muster im Bild, etwa Krümmungen, Kanten oder die Gesamtform der Ziffer. 

Betrachten wir ein 32×32-Graustufenbild einer handgeschriebenen Ziffer. Die Werte in der Matrix dienen zur Veranschaulichung.

Außerdem betrachten wir den für die Faltung verwendeten Kernel. Er ist eine 3×3-Matrix. Die Gewichte jedes Kernelelements sind im Raster dargestellt. Nullen stehen auf schwarzen, Einsen auf weißen Feldern. 

Müssen wir diese Gewichte manuell bestimmen? 

In der Praxis werden die Kernel-Gewichte während des Trainings des neuronalen Netzes gelernt. 

Mit diesen beiden Matrizen führen wir die Faltung über das Skalarprodukt aus. Dabei gehen wir wie folgt vor: 

1. Setze die Kernel-Matrix links oben an und verschiebe sie nach rechts.
2. Multipliziere elementweise.  
3. Addiere die Produkte.
4. Der resultierende Wert ist der erste Eintrag (links oben) in der gefalteten Matrix.
5. Verschiebe den Kernel entsprechend der Schrittweite (Stride) nach unten.
6. Wiederhole die Schritte 1 bis 5, bis die Bildmatrix vollständig überdeckt ist.

Die Größe der gefalteten Matrix hängt von der Schrittweite ab. Je größer die Schrittweite, desto kleiner die resultierende Matrix.

In der Literatur heißt der Kernel auch Feature Detector, weil sich die Gewichte so feinabstimmen lassen, dass sie bestimmte Merkmale im Eingabebild erkennen. 

Zum Beispiel: 

• Ein Kernel, der Nachbarpixel mittelt, kann das Bild weichzeichnen.
• Ein Kernel, der Nachbarn subtrahiert, dient zur Kantenerkennung.

Je mehr Convolution-Schichten ein Netz hat, desto abstraktere Merkmale kann es erkennen. 

Aktivierungsfunktion

Nach jeder Faltung wird eine ReLU-Aktivierungsfunktion angewendet. Sie hilft dem Netz, nichtlineare Zusammenhänge zwischen Bildmerkmalen zu lernen, macht es robuster bei der Mustererkennung und mindert zugleich das Vanishing-Gradient-Problem. 

Pooling-Schicht

Pooling zieht die wichtigsten Merkmale aus der gefalteten Matrix heraus. Aggregationsoperationen verkleinern die Feature-Map (gefaltete Matrix) und senken so den Speicherbedarf während des Trainings. Pooling hilft außerdem, Overfitting zu reduzieren.

Häufige Aggregationsarten sind: 

• Max-Pooling: der maximale Wert innerhalb der Feature-Map
• Sum-Pooling: die Summe aller Werte der Feature-Map
• Average-Pooling: der Durchschnitt aller Werte. 

Unten siehst du eine Veranschaulichung der Beispiele: 

Mit jedem Pooling-Durchlauf wird die Feature-Map kleiner. 

Die letzte Pooling-Schicht flacht die Feature-Map ab (Flatten), damit sie von der Fully-Connected-Schicht verarbeitet werden kann. 

Fully Connected Layers

Diese Schichten stehen am Ende des Convolutional Neural Networks.  Ihre Eingaben stammen aus der eindimensional abgeflachten Matrix der letzten Pooling-Schicht. ReLU-Aktivierungen sorgen für Nichtlinearität. 

Zum Schluss erzeugt eine Softmax-Vorhersageschicht für jedes mögliche Label eine Wahrscheinlichkeit. Das Label mit der höchsten Wahrscheinlichkeit ist die Vorhersage. 

Dropout 

Dropout ist eine Regularisierungstechnik, die die Generalisierungsfähigkeit großer neuronaler Netze verbessert. Dabei werden während des Trainings zufällig Neuronen „abgeschaltet“, was die verbleibenden Neuronen zwingt, neue Merkmale aus den Eingabedaten zu lernen.  

Da wir die technische Umsetzung mit TensorFlow 2 vornehmen, gibt dir der nächste Abschnitt einen kompakten Überblick über die wichtigsten Komponenten des Frameworks, um effizient Deep-Learning-Modelle zu bauen. 

Was ist das TensorFlow-Framework?

Google hat TensorFlow im November 2015 veröffentlicht. Es wird als Open-Source-Machine-Learning-Framework für alle definiert – aus mehreren Gründen. 

• Open Source: Veröffentlicht unter der Apache-2.0-Lizenz. So können Forschende, Organisationen und Entwickler ohne Einschränkungen beitragen und darauf aufbauen. 
• Machine-Learning-Framework: Es bringt Bibliotheken und Tools mit, die den Aufbau von ML-Modellen unterstützen.
• Für alle: Mit TensorFlow werden ML-Modelle in gängigen Sprachen wie Python einfacher umsetzbar. Eingebaute Bibliotheken wie Keras erleichtern das Erstellen robuster Deep-Learning-Modelle zusätzlich. 

Diese Fähigkeiten machen TensorFlow zu einer starken Wahl für neuronale Netze. 

Die Installation von TensorFlow 2 ist unkompliziert und lässt sich mit dem Python-Paketmanager pip vornehmen, wie in der offiziellen Dokumentation beschrieben. 

Nach der Installation sehen wir, dass Version 2.9.1 verwendet wird.

import tensorflow as tf
print("TensorFlow version:", tf.__version__)

Jetzt schauen wir uns die zentralen Bausteine zum Erstellen solcher Netze an. 

Was sind Tensors?

Beim Aufbau von ML- und DL-Modellen arbeiten wir häufig mit hochdimensionalen Daten. Tensors sind mehrdimensionale Arrays mit einheitlichem Datentyp, die verschiedene Merkmale der Daten repräsentieren. 

Unten siehst du eine grafische Darstellung verschiedener Tensor-Dimensionen. 

• Ein 0-dimensionaler Tensor enthält einen einzelnen Wert.
• Ein 1-dimensionaler Tensor („Rank-1“) ist eine Liste von Werten. 
• Ein 2-dimensionaler Tensor ist ein „Rank-2“-Tensor.
• Allgemein sprechen wir von einem N-dimensionalen Tensor, wobei N die Anzahl der Dimensionen angibt. In den obigen Fällen ist N 0, 1 bzw. 2.

Unten findest du ein Beispiel für 0- bis 3-dimensionale Tensors. Jeder Tensor wird mit der Funktion constant() aus TensorFlow erstellt. 

# Zero dimensional tensor
zero_dim_tensor = tf.constant(20)
print(zero_dim_tensor)

# One dimensional tensor
one_dim_tensor = tf.constant([12, 20, 53, 26, 11, 56])
print(one_dim_tensor)

# Two dimensional tensor
two_dim_array = [[3, 6, 7, 5],
             	[9, 2, 3, 4],
             	[7, 1, 10,6],
             	[0, 8, 11,2]]

two_dim_tensor = tf.constant(two_dim_array)
print(two_dim_tensor)

Wenn der obige Code erfolgreich ausgeführt wird, erscheinen die unten gezeigten Ausgaben. Das Schlüsselwort „tf.Tensor“ zeigt an, dass es sich um einen Tensor handelt. Angezeigt werden drei Parameter:

•  Der tatsächliche Wert des Tensors.
• Die shape() des Tensors: 0, 6 mal 1 und 4 mal 4 für den ersten, zweiten bzw. dritten Tensor.
• Der Datentyp über das Attribut dtype – hier jeweils int32.

Unser TensorFlow-Tutorial für Einsteiger bietet einen umfassenden Überblick und zeigt, wie man Modelle erstellt und trainiert.

Tensors vs. Matrizen: Unterschiede

Häufig werden Tensors mit Matrizen verwechselt. Auch wenn sie ähnlich wirken, unterscheiden sie sich grundlegend. Hier die wichtigsten Unterschiede:

• Eine Matrix kannst du dir als Tensor mit genau zwei Dimensionen vorstellen. 
• Tensors sind allgemeiner und können beliebig viele Dimensionen haben.

Im Vergleich zu Matrizen sind Tensors für Deep-Learning-Probleme oft besser geeignet, weil: 

• Sie mit beliebig vielen Dimensionen umgehen können und dadurch für multidimensionale Daten ideal sind.
• Sie dank ihrer Kompatibilität mit vielen Datentypen, Formen und Dimensionen vielseitiger sind.
• TensorFlow GPU- und TPU-Unterstützung für schnellere Berechnungen bietet – Tensors nutzen diese Vorteile nativ.
• Tensors unterstützen Broadcasting, also arithmetische Operationen zwischen unterschiedlich geformten Tensors – mit Matrizen ist das nicht immer möglich.  

TensorFlow: Constants, Variables und Placeholders

Neben Konstanten gibt es auch Variablen und Placeholders – allesamt Bausteine eines Rechengraphen (Computational Graph). 

Ein Computational Graph ist die Darstellung einer Abfolge von Operationen und des Datenflusses zwischen ihnen. 

Schauen wir uns die Unterschiede dieser Tensor-Typen an.

Constants

Konstanten sind Tensors, deren Werte sich während der Ausführung des Rechengraphen nicht ändern. Du erstellst sie mit tf.constant(). Sie eignen sich für feste Parameter, die beim Training unverändert bleiben.

Variables

Variablen sind Tensors, deren Werte sich während der Ausführung ändern können. Sie werden mit tf.Variable() erstellt. In neuronalen Netzen sind Gewichte und Biases typische Variablen, da sie im Training aktualisiert werden. 

Placeholders

In TensorFlow 1 wurden Placeholders als leere Container genutzt, die zunächst keinen Wert haben – quasi als Platzhalter für spätere Daten. Das erlaubt flexible Datensätze und Batch-Größen beim Training und bei der Validierung.

In TensorFlow 2 wurden Placeholders durch tf.function() ersetzt – einen pythonischen, dynamischen Ansatz, um Daten in den Rechengraphen einzuspeisen. 

CNN: Schritt-für-Schritt-Implementierung

Setzen wir das Gelernte um. In diesem Abschnitt implementieren wir ein Convolutional Neural Network in TensorFlow für das CIFAR-10-Dataset, ein integrierter Datensatz mit folgenden Eigenschaften: 

• 60.000 Farb-Bilder mit 32 mal 32 Pixeln
• 10 Klassen
• 6.000 Bilder pro Klasse
• Insgesamt 50.000 Trainingsbilder 
• Und 10.000 Testbilder

Den Quellcode zum Artikel findest du in DataCamps Workspace.

Architektur des Netzwerks

Bevor wir in die Umsetzung gehen, schauen wir uns die Übersicht der Architektur an. 

• Der Eingang des Modells ist ein 32×32×3-Tensor für Breite, Höhe und Kanäle. 
• Es gibt zwei Convolution-Schichten. Die erste hat 32 Filter der Größe 3×3 und ReLU, die zweite 64 Filter der Größe 3×3.
• Die erste Pooling-Schicht verwendet 2×2 Max-Pooling.
• Die zweite Pooling-Schicht ebenfalls 2×2 Max-Pooling.
• Die Fully-Connected-Schicht hat 128 Einheiten und ReLU.
• Der Output hat 10 Einheiten für die 10 Klassen; Softmax erzeugt die Wahrscheinlichkeitsverteilung.

Datensatz laden

Der integrierte Datensatz wird aus keras.datasets() wie folgt geladen: 

(train_images, train_labels), (test_images, test_labels) = cf10.load_data()

Explorative Datenanalyse

Hier zeigen wir exemplarisch ein paar Bilder, da wir die Klassenverteilung im Training und Test bereits kennen. 

Die Hilfsfunktion show_images() zeigt standardmäßig 12 Bilder und erwartet drei Hauptparameter: 

• Die Trainingsbilder
• Die Klassennamen
• Und die Trainingslabels.

import matplotlib.pyplot as plt

def show_images(train_images,
            	class_names,
            	train_labels,
            	nb_samples = 12, nb_row = 4):
    
	plt.figure(figsize=(12, 12))
	for i in range(nb_samples):
    	plt.subplot(nb_row, nb_row, i + 1)
    	plt.xticks([])
    	plt.yticks([])
    	plt.grid(False)
    	plt.imshow(train_images[i], cmap=plt.cm.binary)
    	plt.xlabel(class_names[train_labels[i][0]])
	plt.show()

Nun rufen wir die Funktion mit den nötigen Parametern auf. 

class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',
           	'dog', 'frog', 'horse', 'ship', 'truck']

show_images(train_images, class_names, train_labels)

Eine erfolgreiche Ausführung erzeugt die folgenden Bilder. 

Datenvorverarbeitung

Vor dem Training normalisieren wir die Pixelwerte auf den gleichen Bereich (z. B. 0 bis 1). Das ist bei Bildern üblich, um Skalierungsunterschiede auszugleichen und die Konvergenz im Training zu beschleunigen. 

max_pixel_value = 255

train_images = train_images / max_pixel_value
test_images = test_images / max_pixel_value

Wir sehen außerdem, dass die Labels kategorial sind („cat“, „horse“, „bird“ usw.). Wir müssen sie in numerische Form überführen, damit das Netz sie verarbeiten kann.

from tensorflow.keras.utils import to_categorical
train_labels = to_categorical(train_labels, len(class_names))
test_labels = to_categorical(test_labels, len(class_names))

Modellarchitektur umsetzen

Als nächstes implementieren wir die Architektur entsprechend der Beschreibung. 

Zuerst definieren wir das Modell mit der Klasse Sequential() und fügen Schichten per add() hinzu. 

from tensorflow.keras import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense

# Variables
INPUT_SHAPE = (32, 32, 3)
FILTER1_SIZE = 32
FILTER2_SIZE = 64
FILTER_SHAPE = (3, 3)
POOL_SHAPE = (2, 2)
FULLY_CONNECT_NUM = 128
NUM_CLASSES = len(class_names)

# Model architecture implementation
model = Sequential()
model.add(Conv2D(FILTER1_SIZE, FILTER_SHAPE, activation='relu', input_shape=INPUT_SHAPE))
model.add(MaxPooling2D(POOL_SHAPE))
model.add(Conv2D(FILTER2_SIZE, FILTER_SHAPE, activation='relu'))
model.add(MaxPooling2D(POOL_SHAPE))
model.add(Flatten())
model.add(Dense(FULLY_CONNECT_NUM, activation='relu'))
model.add(Dense(NUM_CLASSES, activation='softmax'))

Mit summary() erhältst du eine Übersicht der Modellarchitektur mit Infos zu jeder Schicht, ihrem Typ, der Ausgabedimension und der Gesamtzahl trainierbarer Parameter. 

Modelltraining

Jetzt konfigurieren und starten wir das Training – mit compile() und fit(). Diese Parameter setzen wir: 

• Optimizer: aktualisiert Gewichte und Biases – hier Adam. 
• Loss-Funktion: misst Fehlklassifikationen – wir nutzen Categorical Crossentropy.
• Metriken: bewerten die Performance. Wir zeigen Accuracy, Precision und Recall.

from tensorflow.keras.metrics import Precision, Recall

BATCH_SIZE = 32
EPOCHS = 30

METRICS = metrics=['accuracy',
               	Precision(name='precision'),
               	Recall(name='recall')]

model.compile(optimizer='adam',
          	loss='categorical_crossentropy',
          	metrics = METRICS)

# Train the model
training_history = model.fit(train_images, train_labels,
                	epochs=EPOCHS, batch_size=BATCH_SIZE,
                	validation_data=(test_images, test_labels))

Modellevaluierung

Nach dem Training vergleichen wir die Leistung auf Trainings- und Testdaten, indem wir die obigen Metriken mit der Hilfsfunktion show_performance_curve() über die Epochen visualisieren. 

• Die x-Achse zeigt die Epochenzahl.
• Die y-Achse zeigt die jeweilige Modellleistung. 
• Die Kurve zeigt den Metrikwert pro Epoche.

Zur besseren Orientierung markiert eine vertikale rote Linie die Schnittstelle der Trainings- und Validierungskurven inklusive des optimalen Werts.

def show_performance_curve(training_result, metric, metric_label):
    
	train_perf = training_result.history[str(metric)]
	validation_perf = training_result.history['val_'+str(metric)]
	intersection_idx = np.argwhere(np.isclose(train_perf,
                                            	validation_perf, atol=1e-2)).flatten()[0]
	intersection_value = train_perf[intersection_idx]
    
	plt.plot(train_perf, label=metric_label)
	plt.plot(validation_perf, label = 'val_'+str(metric))
	plt.axvline(x=intersection_idx, color='r', linestyle='--', label='Intersection')
    
	plt.annotate(f'Optimal Value: {intersection_value:.4f}',
         	xy=(intersection_idx, intersection_value),
         	xycoords='data',
         	fontsize=10,
         	color='green')
            	 
	plt.xlabel('Epoch')
	plt.ylabel(metric_label)
	plt.legend(loc='lower right')

Danach wenden wir die Funktion für Accuracy und Precision an.

show_performance_curve(training_history, 'accuracy', 'accuracy')

show_performance_curve(training_history, 'precision', 'precision')

Ohne Fine-Tuning und weitergehende Vorverarbeitung erreichen wir:  

• Eine Accuracy von 67,09% – das Modell klassifiziert also 67 von 100 Beispielen korrekt. 
• Eine Precision von 76,55% – von 100 positiven Vorhersagen sind rund 77 korrekt (True Positives), die restlichen 23 sind False Positives. 
• Diese Werte treten jeweils in Epoche 3 (Accuracy) und Epoche 2 (Precision) auf.

Diese zwei Metriken geben einen Gesamtüberblick über das Modellverhalten. 

Was, wenn wir pro Klasse wissen wollen, wo das Modell stark ist und wo es schwächelt?

Das zeigt die Confusion Matrix: Sie listet pro Klasse die Anzahl korrekter und falscher Vorhersagen. So setzt du sie um: Zuerst Vorhersagen auf den Testdaten, dann Confusion Matrix berechnen und anzeigen.

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

test_predictions = model.predict(test_images)

test_predicted_labels = np.argmax(test_predictions, axis=1)

test_true_labels = np.argmax(test_labels, axis=1)

cm = confusion_matrix(test_true_labels, test_predicted_labels)

cmd = ConfusionMatrixDisplay(confusion_matrix=cm)

cmd.plot(include_values=True, cmap='viridis', ax=None, xticks_rotation='horizontal')
plt.show()

• Die Klassen 0, 1, 6, 7, 8, 9 – also airplane, automobile, frog, horse, ship und truck – haben die höchsten Werte auf der Diagonalen. Das zeigt: Diese Klassen sagt das Modell am besten voraus. 
• Bei den übrigen Klassen tut es sich schwerer:  
• Hohe Werte außerhalb der Diagonalen zeigen Verwechslungen. So werden zum Beispiel birds (Klasse 2) mit airplanes verwechselt und automobiles mit trucks (Klasse 9).

Mehr zur Confusion Matrix findest du in unserem Tutorial Understanding Confusion Matrix in R – mit Kursmaterial aus DataCamps „Machine Learning Toolbox“.

Das Modell lässt sich weiter verbessern durch:  

• Image Augmentation
• Transfer Learning mit vortrainierten Modellen wie ResNet, MobileNet oder VGG. Unser Transfer-Learning-Tutorial erklärt das Konzept und Praxisbeispiele.
• Weitere Regularisierung wie L1, L2 oder Dropout.  
• Feinjustieren von Hyperparametern wie Lernrate, Batch-Größe und Anzahl der Schichten. 

Fazit

Dieser Artikel bietet einen kompletten Überblick über CNNs in TensorFlow und erläutert die einzelnen Schichten der CNN-Architektur. Außerdem gab es eine kurze Einführung in TensorFlow und wie es ML-Engineers und Forschende beim Aufbau anspruchsvoller neuronaler Netze unterstützt. 

All das haben wir in einem realen Multiclass-Klassifikationsszenario angewendet.  

Unser Beginner’s Guide to Object Detection ist ein guter nächster Schritt, um dein Wissen in Computer Vision zu vertiefen. Er erklärt die zentralen Bausteine der Objekterkennung und zeigt die Implementierung von SSD und Faster R-CNN in TensorFlow.