1. Hinweis
In diesem Codelab lernen Sie, wie Sie mithilfe von CNNs Ihre Bildklassifizierungsmodelle verbessern.
Voraussetzungen
Dieses Codelab baut auf den in zwei vorherigen Raten abgeschlossenen Aufgaben Modell für maschinelles Sehen erstellen auf, in der wir einen Teil des Codes einführen, den Sie hier verwenden. Außerdem geht es um das Codelab Builds Faltungen und Pooling, bei dem wir Faltungen und Pooling einsetzen.
Lerninhalte
- Computervision und Genauigkeit mit Faltungen verbessern
Inhalte, die Sie erstellen werden
- Ebenen, die Ihr neuronales Netzwerk optimieren
Voraussetzungen
Sie finden den Code für den Rest des Codelabs, das in Colab ausgeführt wird.
Außerdem müssen TensorFlow und die Bibliotheken installiert sein, die Sie im vorherigen Codelab installiert haben.
2. Genauigkeit von maschinellem Sehen mit Faltungen verbessern
Jetzt wissen Sie, wie Sie mit einem Deep Neural Network (DNN) mit drei Ebenen die Modebilderkennung durchführen: die Eingabeebene (in der Form der Eingabedaten), die Ausgabeebene (in der Form der gewünschten Ausgabe) und eine ausgeblendete Ebene. Sie haben verschiedene Parameter getestet, die sich auf die endgültige Genauigkeit auswirken, beispielsweise unterschiedliche Größen der ausgeblendeten Ebenen und die Anzahl der Trainingsphasen.
Der gesamte Code kann hier noch einmal angezeigt werden. Führen Sie sie aus und notieren Sie sich die Testgenauigkeit, die am Ende ausgegeben wird.
import tensorflow as tf
mnist = tf.keras.datasets.fashion_mnist
(training_images, training_labels), (test_images, test_labels) = mnist.load_data()
training_images=training_images/255.0
test_images=test_images/255.0
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(training_images, training_labels, epochs=5)
test_loss, test_accuracy = model.evaluate(test_images, test_labels)
print ('Test loss: {}, Test accuracy: {}'.format(test_loss, test_accuracy*100))
Wahrscheinlich liegt Ihre Genauigkeit bei etwa 89% beim Training und 87% bei der Validierung. Und mit Faltungen lässt sich der Inhalt noch weiter eingrenzen, sodass der Fokus auf bestimmten Details liegt.
Wenn Sie Bildverarbeitung mit einem Filter durchgeführt haben, werden Ihnen wahrscheinlich Faltungen bekannt.
Kurz gesagt: Sie nehmen ein Array (normalerweise 3 x 3 oder 5 x 5) über das Bild. Wenn Sie die zugrunde liegenden Pixel basierend auf der Formel in dieser Matrix ändern, können Sie Vorgänge wie die Edge-Erkennung ausführen. In der Regel wird ein 3 x 3 Pixel zur Edge-Erkennung definiert, wenn die mittlere Zelle 8 ist und alle Nachbarn -1 sind. In diesem Fall multiplizieren Sie den Wert für jedes Pixel mit 8 und subtrahieren dann den Wert jedes Nachbarn. Wenn Sie das für jedes Pixel tun, erhalten Sie ein neues Bild mit Kanten.
Die Kamera ist optimal für das maschinelle Sehen geeignet. Wenn Sie beispielsweise die Ränder optimieren, können Sie Elemente besser voneinander unterscheiden. Außerdem ist die Menge der benötigten Informationen viel geringer, da Sie nur mit den hervorgehobenen Funktionen trainieren.
Dies ist das Konzept von Convolutional Neural Networks. Fügen Sie einige Ebenen hinzu, um eine Faltung durchzuführen, bevor Sie die dichten Schichten haben. Dann werden die Informationen, die an die dichten Schichten gehen, fokussierter und möglicherweise genauer.
3. Code ausprobieren
Führen Sie den folgenden Code aus. Es ist das gleiche neuronale Netzwerk wie zuvor, aber diesmal mit faltenden Ebenen zuerst. Es dauert länger, aber sehen Sie sich die Auswirkungen auf die Genauigkeit an:
import tensorflow as tf
print(tf.__version__)
mnist = tf.keras.datasets.fashion_mnist
(training_images, training_labels), (test_images, test_labels) = mnist.load_data()
training_images=training_images.reshape(60000, 28, 28, 1)
training_images=training_images / 255.0
test_images = test_images.reshape(10000, 28, 28, 1)
test_images=test_images / 255.0
model = tf.keras.models.Sequential([
tf.keras.layers.Conv2D(64, (3, 3), activation='relu', input_shape=(28, 28, 1)),
tf.keras.layers.MaxPooling2D(2, 2),
tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),
tf.keras.layers.MaxPooling2D(2,2),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.summary()
model.fit(training_images, training_labels, epochs=5)
test_loss, test_accuracy = model.evaluate(test_images, test_labels)
print ('Test loss: {}, Test accuracy: {}'.format(test_loss, test_accuracy*100))
Wahrscheinlich stieg der Umfang der Trainingsdaten um etwa 93% und die Validierungsdaten um 91 %.
Führen Sie nun weitere Epochen aus, z. B. 20 Jahre, und sehen Sie sich die Ergebnisse an. Obwohl die Trainingsergebnisse wirklich gut ausfallen, könnten die Validierungsergebnisse aufgrund eines Phänomens namens Überanpassung sogar sinken.
Eine Überanpassung tritt auf, wenn das Netzwerk die Daten aus dem Trainings-Dataset zu gut lernt. Daher hat es sich darauf spezialisiert, nur diese Daten zu erkennen, und ist dadurch in der Regel weniger effektiv andere Daten zu sehen. Wenn Sie beispielsweise nur auf den Rädern trainiert haben, sind die Daten im Netzwerk möglicherweise sehr gut zu sehen, aber die Turnschuhe sind verwirrend.
Sehen Sie sich den Code noch einmal an und sehen Sie sich die einzelnen Schritte zur Erstellung der Faltungen an.
4. Daten erfassen
Der erste Schritt besteht darin, die Daten zu erfassen.
Sie werden feststellen, dass hier eine Änderung vorgenommen wurde und dass die Trainingsdaten neu gestaltet werden mussten. Das liegt daran, dass die erste Faltung einen einzigen Tensor enthält, der alles enthält. Statt 60.000 Elemente der Größe 28 x 28 x 1 in einer Liste haben Sie also eine einzige 4D-Liste im Format 60.000 x 28 x 28 x 1 und in den Testbildern dieselbe. Wenn Sie dies nicht tun, erhalten Sie beim Training eine Fehlermeldung, da die Faltungen die Form nicht erkennen.
import tensorflow as tf
mnist = tf.keras.datasets.fashion_mnist
(training_images, training_labels), (test_images, test_labels) = mnist.load_data()
training_images=training_images.reshape(60000, 28, 28, 1)
training_images = training_images/255.0
test_images = test_images.reshape(10000, 28, 28, 1)
test_images = test_images/255.0
5. Modell definieren
Definieren Sie als Nächstes das Modell. Anstelle der Eingabeebene oben fügen Sie eine Faltungsebene hinzu. Die Parameter lauten wie folgt:
- Die Anzahl der Faltungen, die Sie generieren möchten. Ein Wert wie 32 ist ein guter Ausgangspunkt.
- Die Größe der Faltungsmatrix, in diesem Fall ein 3x3-Raster.
- Die zu verwendende Aktivierungsfunktion, in diesem Fall
relu. - In der ersten Ebene ist die Form der Eingabedaten.
Sie führen die Faltung mit einer maximalen Pool-Ebene aus, die dazu dient, das Bild zu komprimieren, während der Inhalt der Merkmale, die durch die Faltung hervorgehoben werden, erhalten wird. Durch die Angabe von (2,2) für das maximale Pooling wird die Größe des Bilds um den Faktor 4 reduziert. Es erstellt ein Array mit 2 × 2 Pixeln und wählt den größten Pixelwert aus, der 4 Pixel in 1 Pixel konvertiert. Diese Berechnung wird im gesamten Bild wiederholt, wobei die Hälfte der horizontalen Pixel und die vertikale Anzahl der Pixel halbiert wird.
Du kannst model.summary() aufrufen, um die Größe und Form des Netzwerks zu sehen. Beachten Sie, dass die Bildgröße nach jeder Max-Pool-Ebene folgendermaßen reduziert wird:
_________________________________________________________________ Layer (type) Output Shape Param # ================================================================= conv2d_2 (Conv2D) (None, 26, 26, 64) 640 _________________________________________________________________ max_pooling2d_2 (MaxPooling2 (None, 13, 13, 64) 0 _________________________________________________________________ conv2d_3 (Conv2D) (None, 11, 11, 64) 36928 _________________________________________________________________ max_pooling2d_3 (MaxPooling2 (None, 5, 5, 64) 0 _________________________________________________________________ flatten_2 (Flatten) (None, 1600) 0 _________________________________________________________________ dense_4 (Dense) (None, 128) 204928 _________________________________________________________________ dense_5 (Dense) (None, 10) 1290 =================================================================
Hier der vollständige Code für die CNN:
model = tf.keras.models.Sequential([
tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
tf.keras.layers.MaxPooling2D(2, 2),
#Add another convolution
tf.keras.layers.Conv2D(64, (3,3), activation='relu'),
tf.keras.layers.MaxPooling2D(2, 2),
#Now flatten the output. After this you'll just have the same DNN structure as the non convolutional version
tf.keras.layers.Flatten(),
#The same 128 dense layers, and 10 output layers as in the pre-convolution example:
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(10, activation='softmax')
])
6. Modell kompilieren und trainieren
Kompilieren Sie das Modell, rufen Sie die Fit-Methode für das Training auf und bewerten Sie den Verlust und die Genauigkeit des Test-Datasets.
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(training_images, training_labels, epochs=5)
test_loss, test_acc = model.evaluate(test_images, test_labels)
print ('Test loss: {}, Test accuracy: {}'.format(test_loss, test_acc*100))
7. Faltungen und Pooling visualisieren
Mit diesem Code werden die Faltungen grafisch dargestellt. Das print (test_labels[:100]) zeigt die ersten 100 Labels im Test-Dataset an. Sie sehen, dass die Labels an Index 0, Index 23 und Index 2 alle denselben Wert (9) haben. Sie sind alle Schuhe. Sehen Sie sich das Ergebnis einer Faltung auf jedem an, um gemeinsame Funktionen zwischen diesen zu erkennen. Wenn jetzt der DNN mit diesen Daten trainiert, arbeitet er mit viel weniger Informationen und es findet möglicherweise eine Gemeinsamkeit zwischen Schuhen basierend auf dieser Faltung und einer Kombination aus Pooling zu.
print(test_labels[:100])
[9 2 1 1 6 1 4 6 5 7 4 5 7 3 4 1 2 4 8 0 2 5 7 9 1 4 6 0 9 3 8 8 3 3 8 0 7 5 7 9 6 1 3 7 6 7 2 1 2 2 4 4 5 8 2 2 8 4 8 0 7 7 8 5 1 1 2 3 9 8 7 0 2 6 2 3 1 2 8 4 1 8 5 9 5 0 3 2 0 6 5 3 6 7 1 8 0 1 4 2]
Sie können jetzt einige der entsprechenden Bilder für diese Labels auswählen und so darstellen, dass sie wie die Faltungen aussehen. Im folgenden Code sind also FIRST_IMAGE, SECOND_IMAGE und THIRD_IMAGE alle Indexe für den Wert 9, einen Fußkettstiefel.
import matplotlib.pyplot as plt
f, axarr = plt.subplots(3,4)
FIRST_IMAGE=0
SECOND_IMAGE=23
THIRD_IMAGE=28
CONVOLUTION_NUMBER = 6
from tensorflow.keras import models
layer_outputs = [layer.output for layer in model.layers]
activation_model = tf.keras.models.Model(inputs = model.input, outputs = layer_outputs)
for x in range(0,4):
f1 = activation_model.predict(test_images[FIRST_IMAGE].reshape(1, 28, 28, 1))[x]
axarr[0,x].imshow(f1[0, : , :, CONVOLUTION_NUMBER], cmap='inferno')
axarr[0,x].grid(False)
f2 = activation_model.predict(test_images[SECOND_IMAGE].reshape(1, 28, 28, 1))[x]
axarr[1,x].imshow(f2[0, : , :, CONVOLUTION_NUMBER], cmap='inferno')
axarr[1,x].grid(False)
f3 = activation_model.predict(test_images[THIRD_IMAGE].reshape(1, 28, 28, 1))[x]
axarr[2,x].imshow(f3[0, : , :, CONVOLUTION_NUMBER], cmap='inferno')
axarr[2,x].grid(False)
Und dann sollte jemand so sehen, wie die Faltung den Kern der Schuhsohle nutzt und so ein gemeinsames Merkmal für alle Schuhe erkennt.
8. Übungen
Übung 1
Versuchen Sie, die Faltungen zu bearbeiten. Ändern Sie die Anzahl der Faltungen von 32 in 16 oder 64. Wie wirkt sich das auf die Genauigkeit und die Trainingszeit aus?
Übung 2
Entfernen Sie die letzte Faltung. Wie wirkt sich das auf die Genauigkeit oder die Trainingszeit aus?
Übung 3
Fügen Sie weitere Faltungen hinzu. Welche Auswirkungen hat das?
Übung 4
Entfernen Sie alle Faltungen, bis auf die erste. Welche Auswirkungen hat das? Experimentieren Sie damit.
9. Glückwunsch
Du hast deine erste CNN gebaut! Informationen zur weiteren Optimierung Ihrer Modelle für maschinelles Sehen finden Sie in Convolutional Neural Networks (CNNs) mit komplexen Bildern verwenden.