Modell für maschinelles Sehen mit TensorFlow erstellen

1. Hinweis

In diesem Codelab erstellen Sie ein Modell für maschinelles Sehen, das mit TensorFlow Objekte erkennt.

Voraussetzungen

  • Gute Python-Kenntnisse
  • Grundkenntnisse im Programmieren

Lerninhalte

In diesem Codelab kannst du Folgendes tun:

  • Trainieren Sie ein neuronales Netzwerk, das Kleidungsstücke erkennt
  • Eine Reihe von Übungen, die Sie durch Experimentieren mit den verschiedenen Ebenen des Netzwerks führen

Inhalte, die Sie erstellen werden

  • Ein neuronales Netzwerk, das Kleidungsstücke identifiziert

Voraussetzungen

Wenn Sie mit TensorFlow noch kein neuronales Netzwerk für maschinelles Sehen erstellt haben, können Sie Colaboratory verwenden, eine browserbasierte Umgebung, die alle erforderlichen Abhängigkeiten enthält. Sie finden den Code für den Rest des Codelabs, das in Colab ausgeführt wird.

Andernfalls verwenden Sie für das Training von Modellen hauptsächlich Python, also müssen Sie es installieren. Darüber hinaus benötigst du TensorFlow und die NumPy-Bibliothek. Weitere Informationen zum Installieren von TensorFlow Geben Sie NumPy hier ein.

2. Mit dem Programmieren beginnen

Gehen Sie zuerst das ausführliche Colab-Notebook durch.

Importieren Sie zuerst TensorFlow.

import tensorflow as tf
print(tf.__version__)

Sie trainieren ein neuronales Netzwerk, das Kleidungsstücke aus einem gängigen Datensatz namens Fashion MNIST erkennt. Es umfasst 70.000 Bekleidungsartikel in zehn verschiedenen Kategorien. Jedes Kleidungsstück ist ein Graustufenbild mit 28 x 28 Pixel. Hier einige Beispiele:

Die mit dem Dataset verknüpften Labels sind:

Label

Beschreibung

0

T-Shirt/Top

1

Hose

2

Pullover

3

Kleid

4

Mantel

5

Sandalen

6

T-Shirt

7

Turnschuh

8

Tasche

9

Stiefeletten

Die Fashion MNIST-Daten sind in der tf.keras.datasets API verfügbar. Laden Sie es so:

mnist = tf.keras.datasets.fashion_mnist

Wenn Sie load_data für dieses Objekt aufrufen, erhalten Sie zwei Gruppen von zwei Listen: Trainingswerte und Testwerte. Diese stellen Grafikgrafiken mit Kleidungsstücken und deren Labels dar.

(training_images, training_labels), (test_images, test_labels) = mnist.load_data()

Wie sehen diese Werte aus? Sie können ein Trainingsbild und ein Trainingslabel drucken. Sie können mit verschiedenen Indizes im Array experimentieren.

import matplotlib.pyplot as plt
plt.imshow(training_images[0])
print(training_labels[0])
print(training_images[0])

Die Abzüge der Daten für das Element 0 sehen so aus:

Alle Werte sind Ganzzahlen zwischen 0 und 255. Wenn Sie ein neuronales Netzwerk trainieren, ist es einfacher, alle Werte zwischen 0 und 1 zu verarbeiten. Dieser Vorgang wird als Normalisierung bezeichnet. Zum Glück bietet Python eine einfache Möglichkeit, eine solche Liste ohne Schleife zu normalisieren.

training_images  = training_images / 255.0
test_images = test_images / 255.0

Sie sollten sich auch 42 ansehen, was einen anderen Bootmodus als der mit Index 0 ist.

Sie fragen sich vielleicht, warum es zwei Datensätze gibt: Training und Tests.

Die Idee ist, einen Satz von Daten für das Training und einen weiteren Datensatz zu haben, den das Modell noch nicht gefunden hat, um zu sehen, wie gut Werte klassifiziert werden können. Und schließlich Möchten Sie das Modell nur mit den Daten verwenden, die es vorher nicht gesehen hat. Ohne separate Testdaten riskieren Sie außerdem, dass das Netzwerk seine Trainingsdaten nur auswendig speichert, ohne sein Wissen zu allgemeinisieren.

3. Modell entwerfen

Jetzt das Modell entwerfen. Sie haben drei Ebenen. Gehen Sie sie nacheinander durch und informieren Sie sich über die verschiedenen Ebenentypen und die Parameter, die für sie verwendet werden.

model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), 
                                    tf.keras.layers.Dense(128, activation=tf.nn.relu), 
                                    tf.keras.layers.Dense(10, activation=tf.nn.softmax)])
  • Sequential definiert eine Sequenz von Ebenen im neuronalen Netzwerk.
  • Flatten wandelt ein Quadrat in einen eindimensionalen Vektor um.
  • Dense fügt eine Schicht mit Neuronen hinzu.
  • Die Activation-Funktionen bestimmen jede Ebene der Neuronen, was sie tun sollen. Es gibt viele Optionen, aber verwenden Sie diese erst einmal:
  • Relu bedeutet Folgendes: Wenn X größer als 0 ist, wird X zurückgegeben, andernfalls 0. Es werden nur Werte von 0 oder höher an die nächste Ebene im Netzwerk übergeben.
  • Softmax verwendet eine Reihe von Werten und wählt effektiv den größten Wert aus. Wenn die Ausgabe der letzten Ebene beispielsweise [0.1, 0.1, 0.05, 0.1, 9.5, 0.1, 0.05, 0.05, 0.05] enthält, brauchen Sie nicht nach dem größten Wert zu sortieren, sondern gibt [0,0,0,0,1,0,0,0] zurück.

4. Modell kompilieren und trainieren

Nachdem Sie das Modell definiert haben, müssen Sie es jetzt erstellen. Erstellen Sie ein Modell, indem Sie es zuerst mit den Funktionen optimizer und loss kompilieren und anschließend mit Ihren Trainingsdaten und Labels trainieren. Das Ziel ist es, die Beziehung zwischen den Trainingsdaten und den Trainingslabels anhand des Modells zu ermitteln. Später möchten Sie, dass das Modell Daten sieht, die Ihren Trainingsdaten ähneln. Erstellen Sie dann eine Vorhersage, wie diese Daten aussehen sollten.

Beachten Sie, dass metrics= als Parameter verwendet wird. So kann TensorFlow die Genauigkeit des Trainings ermitteln, indem die vorhergesagten Ergebnisse mit den bekannten Antworten (Labels) verglichen werden.

model.compile(optimizer = tf.keras.optimizers.Adam(),
              loss = 'sparse_categorical_crossentropy',
              metrics=['accuracy'])

model.fit(training_images, training_labels, epochs=5)

Wenn model.fit ausgeführt wird, treten Verluste und Genauigkeit auf:

Epoch 1/5
60000/60000 [=======] - 6s 101us/sample - loss: 0.4964 - acc: 0.8247
Epoch 2/5
60000/60000 [=======] - 5s 86us/sample - loss: 0.3720 - acc: 0.8656
Epoch 3/5
60000/60000 [=======] - 5s 85us/sample - loss: 0.3335 - acc: 0.8780
Epoch 4/5
60000/60000 [=======] - 6s 103us/sample - loss: 0.3134 - acc: 0.8844
Epoch 5/5
60000/60000 [=======] - 6s 94us/sample - loss: 0.2931 - acc: 0.8926

Nach Abschluss des Trainings wird am Ende der letzten Epoche ein Genauigkeitswert angezeigt. Der Wert kann in etwa so aussehen: 0,8926 wie oben. Sie sehen, dass Ihr neuronales Netzwerk etwa 89% genau ist, wenn Sie die Trainingsdaten klassifizieren. Anders ausgedrückt: Es hat eine Musterübereinstimmung zwischen dem Bild und den Labels erkannt, die in 89% der Fälle funktionieren. Das ist nicht besonders gut, aber schlecht, da es nur für fünf Epochen trainiert wurde und schnell erledigt werden kann.

5. Modell testen

Wie würde das Modell mit Daten abschneiden, die es nicht gesehen hat? Deshalb testen Sie das Test-Dataset. Sie rufen model.evaluate auf und übergeben die beiden Datensätze. Der Verlust wird dann für beide gemeldet. Probieren Sie es aus:

model.evaluate(test_images, test_labels)

Und hier die Ausgabe:

10000/10000 [=====] - 1s 56us/sample - loss: 0.3365 - acc: 0.8789
[0.33648381242752073, 0.8789]

Die Genauigkeit lag bei 0,8789, was eine Genauigkeit von etwa 88% bedeutet. Die Werte können leicht voneinander abweichen.

Wie erwartet, ist das Modell nicht mehr so genau mit den unbekannten Daten wie mit den Daten, für die es trainiert wurde. Je mehr Sie über TensorFlow wissen, desto besser können Sie es optimieren.

Probieren Sie im nächsten Schritt die Übungen aus.

6. Explorative Trainings

Übung 1

Führen Sie für diese erste Übung den folgenden Code aus:

classifications = model.predict(test_images)
print(classifications[0])

Für jedes Testbild wird eine Reihe von Klassifizierungen erstellt. Dann wird der erste Eintrag in den Klassifizierungen gedruckt. Die Ausgabe ist eine Liste mit Zahlen. Warum findest du das und was bedeuten diese Zahlen?

Wenn Sie print(test_labels[0]) ausführen, erhalten Sie eine 9. Wir verstehen die Gründe, warum die Liste so aussieht.

Die Ausgabe des Modells besteht aus einer Liste von zehn Zahlen. Diese Zahlen sind eine Wahrscheinlichkeit, dass der klassifizierte Wert das entsprechende Label ist. Der erste Wert in der Liste ist beispielsweise die Wahrscheinlichkeit, dass die Kleidung der Klasse 0 ist, die nächste die Anzahl 1. Alle Wahrscheinlichkeiten sind sehr gering. Dank Softmax ergeben sich außerdem alle Wahrscheinlichkeiten in der Liste auf 1,0.

Die Liste und die Labels befinden sich auf 0. Das heißt, der Fußstiefel mit dem Label 9 bedeutet das Zehnte der zehn Klassen. Weil die Liste mit dem zehnten Element der höchste Wert ist, bedeutet das, dass das neuronale Netzwerk dem Element, das es klassifiziert, wahrscheinlich einen Knöchelstiefel präsentiert.

Übung 2

Sehen Sie sich die Ebenen in Ihrem Modell an. Experimentiere mit verschiedenen Werten für die Dichte der Schicht mit 512 Neuronen.

Welche unterschiedlichen Ergebnisse erzielen Sie für Verlust- und Schulungszeit? Was ist der Grund dafür?

Wenn Sie zum Beispiel auf 1.024 Neuronen erhöhen, müssen Sie mehr Berechnungen vornehmen und den Prozess dadurch verlangsamen. Aber in diesem Fall haben sie einen guten Effekt, weil das Modell genauer ist. Das heißt nicht, dass mehr immer besser ist. Sie können das Gesetz zur Abschärfung von Rendite sehr schnell einhalten.

Übung 3

Was passiert, wenn du die Ebene Flatten() entfernst? Was ist der Grund dafür?

In einem Fehler wird die Form der Daten angezeigt. Die Fehlerdetails erscheinen im Moment vage, doch die Faustregel lautet: Die erste Ebene in Ihrem Netzwerk muss dieselbe Form haben wie die Daten. Aktuell sind die Daten 28 x 28 Bilder und 28 Schichten von 28 Neuronen könnten nicht durchführbar sein.

Anstatt den gesamten Code zu schreiben, fügen Sie die Flatten()-Ebene am Anfang hinzu. Wenn die Arrays später in das Modell geladen werden, werden sie automatisch für Sie reduziert.

Übung 4

Ziehen Sie die letzten Ebenen (Ausgabe) in Betracht. Warum gibt es zehn? Was passiert, wenn Sie einen anderen Betrag als 10 haben?

Versuche, das Netzwerk mit 5 zu trainieren. Sie erhalten einen Fehler, wenn ein unerwarteter Wert gefunden wird. Eine weitere Faustregel: Die Anzahl der Neuronen in der letzten Ebene sollte mit der Anzahl der Klassen übereinstimmen, die Sie klassifizieren. In diesem Fall sind es die Ziffern 0 bis 9, also 10. Daher sollten Sie 10 Neuronen auf der letzten Schicht haben.

Übung 5

Berücksichtigen Sie die Auswirkungen zusätzlicher Ebenen im Netzwerk. Was geschieht, wenn Sie eine weitere Ebene zwischen der Ebene mit 512 und der letzten Ebene mit zehn hinzufügen?

Dies hat keine nennenswerten Auswirkungen, da die Daten relativ einfach sind. Für komplexere Daten sind oft zusätzliche Ebenen erforderlich.

Übung 6

Vor dem Training haben Sie die Daten normalisiert, von Werten zwischen 0 bis 255 und Werten von 0 bis 1. Welche Auswirkungen hätte das Entfernen dieser Datei? Hier ist der vollständige Code dafür. Beachte, dass die beiden Zeilen, die die Daten normalisieren, auskommentiert sind.

Warum erhältst du deiner Meinung nach unterschiedliche Ergebnisse? Auf Stack Overflow findest du eine gute Antwort.

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/255.0
#test_images=test_images/255.0
model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(),
  tf.keras.layers.Dense(512, activation=tf.nn.relu),
  tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
model.fit(training_images, training_labels, epochs=5)
model.evaluate(test_images, test_labels)
classifications = model.predict(test_images)
print(classifications[0])
print(test_labels[0])

7. Callbacks ansehen

Wenn du dich zuvor für zusätzliche Epochen geschult hast, gab es früher ein Problem, bei dem sich dein Verlust möglicherweise ändern würde. Es kann einige Zeit dauern, bis Sie mit dem Training fertig sind. Vielleicht hättest du gedacht, dass es schön wäre, wenn du das Training beenden könntest, wenn du einen gewünschten Wert erreichst (z. B. eine Genauigkeit von 95 %). Wenn du dieses Ziel nach drei Epochen erreichst, warum wartest du darauf, dass es noch viel mehr Epochen beendet?

Wie bei jedem anderen Programm gibt es Callbacks. Beispiele in der Praxis:

import tensorflow as tf

class myCallback(tf.keras.callbacks.Callback):
  def on_epoch_end(self, epoch, logs={}):
    if(logs.get('accuracy')>0.95):
      print("\nReached 95% accuracy so cancelling training!")
      self.model.stop_training = True

callbacks = myCallback()
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(512, activation=tf.nn.relu),
  tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(training_images, training_labels, epochs=5, callbacks=[callbacks])

8. Glückwunsch

Sie haben Ihr erstes ML-Modell erstellt. Informationen zum Optimieren Ihrer Modelle für maschinelles Sehen finden Sie unter Faltungen und Pooling erstellen.