Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

Grundlegende Klassifizierung: Klassifizieren Sie Bilder von Kleidung

Ansicht auf TensorFlow.org Quelle auf GitHub anzeigen Notizbuch herunterladen

In diesem Handbuch wird ein neuronales Netzwerkmodell trainiert, um Bilder von Kleidung wie Turnschuhen und Hemden zu klassifizieren. Es ist in Ordnung, wenn Sie nicht alle Details verstehen. Dies ist eine schnelle Übersicht über ein vollständiges TensorFlow-Programm, in der die Details erläutert werden.

In diesem Handbuch wird tf.keras verwendet , eine übergeordnete API zum Erstellen und Trainieren von Modellen in TensorFlow.

# TensorFlow and tf.keras
import tensorflow as tf
from tensorflow import keras

# Helper libraries
import numpy as np
import matplotlib.pyplot as plt

print(tf.__version__)
2.3.0

Importieren Sie den Fashion MNIST-Datensatz

fashion_mnist = keras.datasets.fashion_mnist

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

Beim Laden des Datensatzes werden vier NumPy-Arrays zurückgegeben:

  • Die Arrays train_images und train_labels sind der Trainingssatz - die Daten, die das Modell zum Lernen verwendet.
  • Das Modell wird test_labels Arrays test set , test_images und test_labels .

Die Bilder sind 28x28 NumPy Arrays, mit Pixelwerten im Bereich von 0 bis 255. Die Etiketten sind eine Reihe von ganzen Zahlen, die von 0 bis 9. Diese entsprechen der Klasse der Kleidung das Bild darstellt:

Etikette Klasse
0 T-Shirt / Top
1 Hose
2 Zur Seite fahren
3 Kleid
4 Mantel
5 Sandale
6 Hemd
7 Sneaker
8 Tasche
9 Stiefelette

Jedes Bild wird einem einzelnen Etikett zugeordnet. Da die Klassennamen nicht im Datensatz enthalten sind, speichern Sie sie hier, um sie später beim Plotten der Bilder zu verwenden:

class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

Erkunden Sie die Daten

Lassen Sie uns das Format des Datensatzes untersuchen, bevor Sie das Modell trainieren. Das Folgende zeigt, dass das Trainingsset 60.000 Bilder enthält, wobei jedes Bild als 28 x 28 Pixel dargestellt wird:

train_images.shape
(60000, 28, 28)

Ebenso enthält das Trainingsset 60.000 Etiketten:

len(train_labels)
60000

Jedes Label ist eine Ganzzahl zwischen 0 und 9:

train_labels
array([9, 0, 0, ..., 3, 0, 5], dtype=uint8)

Das Test-Set enthält 10.000 Bilder. Wieder wird jedes Bild als 28 x 28 Pixel dargestellt:

test_images.shape
(10000, 28, 28)

Das Testset enthält 10.000 Bildetiketten:

len(test_labels)
10000

Verarbeiten Sie die Daten vor

Die Daten müssen vor dem Training des Netzwerks vorverarbeitet werden. Wenn Sie das erste Bild im Trainingssatz untersuchen, werden Sie feststellen, dass die Pixelwerte im Bereich von 0 bis 255 liegen:

plt.figure()
plt.imshow(train_images[0])
plt.colorbar()
plt.grid(False)
plt.show()

png

Skalieren Sie diese Werte auf einen Bereich von 0 bis 1, bevor Sie sie dem neuronalen Netzwerkmodell zuführen. Dazu teilt die Werte von 255. Es ist wichtig , dass der Trainingssatz und der Testsatz in der gleichen Art und Weise vorverarbeitet werden:

train_images = train_images / 255.0

test_images = test_images / 255.0

Um zu überprüfen, ob die Daten das richtige Format haben und ob Sie bereit sind, das Netzwerk aufzubauen und zu trainieren, zeigen wir die ersten 25 Bilder aus dem Trainingssatz und den Klassennamen unter jedem Bild an.

plt.figure(figsize=(10,10))
for i in range(25):
    plt.subplot(5,5,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]])
plt.show()

png

Erstellen Sie das Modell

Um das neuronale Netzwerk aufzubauen, müssen die Ebenen des Modells konfiguriert und anschließend das Modell kompiliert werden.

Richten Sie die Ebenen ein

Der Grundbaustein eines neuronalen Netzwerks ist die Schicht . Ebenen extrahieren Darstellungen aus den in sie eingegebenen Daten. Hoffentlich sind diese Darstellungen für das vorliegende Problem von Bedeutung.

Der größte Teil des tiefen Lernens besteht darin, einfache Schichten miteinander zu verketten. Die meisten Ebenen, wie z. B. tf.keras.layers.Dense , haben Parameter, die während des Trainings gelernt werden.

model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dense(10)
])

Die erste Schicht in diesem Netzwerk, tf.keras.layers.Flatten , transformiert das Format der Bilder von einem zweidimensionalen Array (von 28 x 28 Pixel) in ein eindimensionales Array (von 28 * 28 = 784 Pixel). Stellen Sie sich diese Ebene so vor, als würden Sie Pixelreihen im Bild entstapeln und aneinanderreihen. Diese Ebene hat keine Parameter zu lernen; Es werden nur die Daten neu formatiert.

Nachdem die Pixel abgeflacht sind, besteht das Netzwerk aus einer Folge von zwei tf.keras.layers.Dense Ebenen. Dies sind dicht verbundene oder vollständig verbundene neuronale Schichten. Die erste Dense Schicht hat 128 Knoten (oder Neuronen). Die zweite (und letzte) Ebene gibt ein Protokollarray mit einer Länge von 10 zurück. Jeder Knoten enthält eine Bewertung, die angibt, dass das aktuelle Bild zu einer der 10 Klassen gehört.

Kompilieren Sie das Modell

Bevor das Modell für das Training bereit ist, müssen einige weitere Einstellungen vorgenommen werden. Diese werden während des Kompilierungsschritts des Modells hinzugefügt:

  • Verlustfunktion - Hiermit wird gemessen, wie genau das Modell während des Trainings ist. Sie möchten diese Funktion minimieren, um das Modell in die richtige Richtung zu "steuern".
  • Optimierer - Auf diese Weise wird das Modell basierend auf den angezeigten Daten und seiner Verlustfunktion aktualisiert.
  • Metriken - Dient zum Überwachen der Schulungs- und Testschritte. Im folgenden Beispiel wird die Genauigkeit verwendet , der Bruchteil der Bilder, die korrekt klassifiziert wurden.
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

Trainiere das Modell

Das Training des neuronalen Netzwerkmodells erfordert die folgenden Schritte:

  1. Geben Sie die Trainingsdaten an das Modell weiter. In diesem Beispiel befinden sich die Trainingsdaten in den Arrays train_images und train_labels .
  2. Das Modell lernt, Bilder und Beschriftungen zuzuordnen.
  3. Sie fordern das Modell auf, Vorhersagen über einen test_images zu treffen - in diesem Beispiel das Array test_images .
  4. test_labels dass die Vorhersagen mit den Beschriftungen aus dem Array test_labels .

Füttere das Modell

Rufen model.fit zum Starten des Trainings die model.fit Methode auf, die so genannt wird, weil sie das Modell an die Trainingsdaten " model.fit ":

model.fit(train_images, train_labels, epochs=10)
Epoch 1/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.5007 - accuracy: 0.8232
Epoch 2/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.3743 - accuracy: 0.8654
Epoch 3/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.3358 - accuracy: 0.8778
Epoch 4/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.3119 - accuracy: 0.8849
Epoch 5/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2957 - accuracy: 0.8911
Epoch 6/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2802 - accuracy: 0.8963
Epoch 7/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2674 - accuracy: 0.9008
Epoch 8/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2571 - accuracy: 0.9045
Epoch 9/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2491 - accuracy: 0.9086
Epoch 10/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2380 - accuracy: 0.9110

<tensorflow.python.keras.callbacks.History at 0x7f29ebf31518>

Während das Modell trainiert, werden die Verlust- und Genauigkeitsmetriken angezeigt. Dieses Modell erreicht eine Genauigkeit von etwa 0,91 (oder 91%) der Trainingsdaten.

Genauigkeit bewerten

Vergleichen Sie als Nächstes die Leistung des Modells für den Testdatensatz:

test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=2)

print('\nTest accuracy:', test_acc)
313/313 - 0s - loss: 0.3312 - accuracy: 0.8832

Test accuracy: 0.8831999897956848

Es stellt sich heraus, dass die Genauigkeit des Testdatensatzes etwas geringer ist als die Genauigkeit des Trainingsdatensatzes. Diese Lücke zwischen Trainingsgenauigkeit und Testgenauigkeit stellt eine Überanpassung dar . Eine Überanpassung tritt auf, wenn ein Modell für maschinelles Lernen bei neuen, zuvor nicht sichtbaren Eingaben schlechter abschneidet als bei den Trainingsdaten. Ein überpassendes Modell "speichert" das Rauschen und die Details im Trainingsdatensatz bis zu einem Punkt, an dem es die Leistung des Modells für die neuen Daten negativ beeinflusst. Weitere Informationen finden Sie unter:

Voraussagen machen

Mit dem trainierten Modell können Sie damit Vorhersagen über einige Bilder treffen. Die linearen Ausgaben des Modells werden protokolliert . Fügen Sie eine Softmax-Ebene hinzu, um die Protokolle in Wahrscheinlichkeiten zu konvertieren, die einfacher zu interpretieren sind.

probability_model = tf.keras.Sequential([model, 
                                         tf.keras.layers.Softmax()])
predictions = probability_model.predict(test_images)

Hier hat das Modell die Beschriftung für jedes Bild im Testsatz vorhergesagt. Werfen wir einen Blick auf die erste Vorhersage:

predictions[0]
array([2.3710859e-08, 3.1721327e-11, 1.4305586e-11, 1.3425981e-09,
       3.3166289e-10, 1.6982469e-04, 4.0853692e-07, 9.2678880e-03,
       9.4139558e-08, 9.9056178e-01], dtype=float32)

Eine Vorhersage ist ein Array von 10 Zahlen. Sie repräsentieren das "Vertrauen" des Modells, dass das Bild jedem der 10 verschiedenen Kleidungsstücke entspricht. Sie können sehen, welches Etikett den höchsten Konfidenzwert hat:

np.argmax(predictions[0])
9

Das Modell ist daher sehr zuversichtlich, dass es sich bei diesem Bild um einen Stiefel oder um class_names[9] . Die Prüfung des Testetiketts zeigt, dass diese Klassifizierung korrekt ist:

test_labels[0]
9

Stellen Sie dies grafisch dar, um den vollständigen Satz von 10 Klassenvorhersagen anzuzeigen.

def plot_image(i, predictions_array, true_label, img):
  true_label, img = true_label[i], img[i]
  plt.grid(False)
  plt.xticks([])
  plt.yticks([])

  plt.imshow(img, cmap=plt.cm.binary)

  predicted_label = np.argmax(predictions_array)
  if predicted_label == true_label:
    color = 'blue'
  else:
    color = 'red'

  plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label],
                                100*np.max(predictions_array),
                                class_names[true_label]),
                                color=color)

def plot_value_array(i, predictions_array, true_label):
  true_label = true_label[i]
  plt.grid(False)
  plt.xticks(range(10))
  plt.yticks([])
  thisplot = plt.bar(range(10), predictions_array, color="#777777")
  plt.ylim([0, 1])
  predicted_label = np.argmax(predictions_array)

  thisplot[predicted_label].set_color('red')
  thisplot[true_label].set_color('blue')

Überprüfen Sie die Vorhersagen

Mit dem trainierten Modell können Sie damit Vorhersagen über einige Bilder treffen.

Schauen wir uns das 0. Bild, die Vorhersagen und das Vorhersagearray an. Richtige Vorhersageetiketten sind blau und falsche Vorhersageetiketten sind rot. Die Zahl gibt den Prozentsatz (von 100) für das vorhergesagte Etikett an.

i = 0
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions[i], test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions[i],  test_labels)
plt.show()

png

i = 12
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions[i], test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions[i],  test_labels)
plt.show()

png

Zeichnen wir mehrere Bilder mit ihren Vorhersagen. Beachten Sie, dass das Modell auch dann falsch sein kann, wenn es sehr sicher ist.

# Plot the first X test images, their predicted labels, and the true labels.
# Color correct predictions in blue and incorrect predictions in red.
num_rows = 5
num_cols = 3
num_images = num_rows*num_cols
plt.figure(figsize=(2*2*num_cols, 2*num_rows))
for i in range(num_images):
  plt.subplot(num_rows, 2*num_cols, 2*i+1)
  plot_image(i, predictions[i], test_labels, test_images)
  plt.subplot(num_rows, 2*num_cols, 2*i+2)
  plot_value_array(i, predictions[i], test_labels)
plt.tight_layout()
plt.show()

png

Verwenden Sie das trainierte Modell

Verwenden Sie schließlich das trainierte Modell, um eine Vorhersage für ein einzelnes Bild zu treffen.

# Grab an image from the test dataset.
img = test_images[1]

print(img.shape)
(28, 28)

tf.keras Modelle sind optimiert, um Vorhersagen für einen Stapel oder eine Sammlung von Beispielen gleichzeitig zu treffen. Dementsprechend müssen Sie ein einzelnes Bild zu einer Liste hinzufügen, obwohl Sie es verwenden:

# Add the image to a batch where it's the only member.
img = (np.expand_dims(img,0))

print(img.shape)
(1, 28, 28)

Sagen Sie nun das richtige Etikett für dieses Bild voraus:

predictions_single = probability_model.predict(img)

print(predictions_single)
[[3.8163576e-05 7.6493567e-14 9.9756038e-01 2.8972957e-09 7.7012519e-04
  1.9186120e-12 1.6312959e-03 2.7591241e-17 4.4947028e-12 4.1419238e-15]]

plot_value_array(1, predictions_single[0], test_labels)
_ = plt.xticks(range(10), class_names, rotation=45)

png

keras.Model.predict gibt eine Liste von Listen zurück - eine Liste für jedes Bild im Datenstapel. Holen Sie sich die Vorhersagen für unser (einziges) Bild im Stapel:

np.argmax(predictions_single[0])
2

Und das Modell sagt erwartungsgemäß ein Etikett voraus.


#
# Copyright (c) 2017 François Chollet
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.

In diesem Handbuch wird der Fashion MNIST- Datensatz verwendet, der 70.000 Graustufenbilder in 10 Kategorien enthält. Die Bilder zeigen einzelne Kleidungsstücke in niedriger Auflösung (28 x 28 Pixel), wie hier zu sehen:

Mode MNIST Sprite
Abbildung 1. Fashion-MNIST-Beispiele (von Zalando, MIT-Lizenz).

Fashion MNIST ist als Ersatz für den klassischen MNIST- Datensatz gedacht, der häufig als "Hallo Welt" von Programmen für maschinelles Lernen für Computer Vision verwendet wird. Der MNIST-Datensatz enthält Bilder handgeschriebener Ziffern (0, 1, 2 usw.) in einem Format, das mit dem der hier verwendeten Kleidungsstücke identisch ist.

Dieser Leitfaden verwendet Fashion MNIST für Abwechslung und weil es ein etwas schwierigeres Problem ist als normales MNIST. Beide Datensätze sind relativ klein und werden verwendet, um zu überprüfen, ob ein Algorithmus wie erwartet funktioniert. Sie sind gute Ausgangspunkte zum Testen und Debuggen von Code.

Hier werden 60.000 Bilder verwendet, um das Netzwerk zu trainieren, und 10.000 Bilder, um zu bewerten, wie genau das Netzwerk gelernt hat, Bilder zu klassifizieren. Sie können direkt über TensorFlow auf den Fashion MNIST zugreifen. Importieren und laden Sie die Fashion MNIST-Daten direkt aus TensorFlow: