Hallo Habr! Ich präsentiere Ihnen die Übersetzung des Artikels "Trainieren Sie Ihr erstes neuronales Netzwerk: Grundklassifikation" .
Dies ist ein Trainingshandbuch für neuronale Netzwerkmodelle zum Klassifizieren von Bildern von Kleidung wie Turnschuhen und Hemden. Um ein neuronales Netzwerk zu erstellen, verwenden wir Python und die TensorFlow-Bibliothek.
Installieren Sie TensorFlow
Für die Arbeit benötigen wir folgende Bibliotheken:
- numpy (in der Kommandozeile schreiben wir: pip install numpy)
- matplotlib (in der Kommandozeile schreiben wir: pip install matplotlib)
- keras (in der Kommandozeile schreiben wir: pip install keras)
- jupyter (in der Kommandozeile schreiben wir: pip install jupyter)
Verwenden von pip: Schreiben Sie in der Befehlszeile pip install tensorflow
Wenn Sie eine Fehlermeldung erhalten, können Sie die .whl-Datei herunterladen und mit pip installieren: pip install file_path \ file_name.whl
Offizielles TensorFlow-Installationshandbuch
Starten Sie Jupyter. Um an der Befehlszeile zu beginnen, schreiben Sie ein Jupyter-Notizbuch.
Erste Schritte
In diesem Handbuch wird der Fashion MNIST-Datensatz verwendet, der 70.000 Graustufenbilder in 10 Kategorien enthält. Die Bilder zeigen einzelne Kleidungsstücke mit niedriger Auflösung (28 x 28 Pixel):
Wir werden 60.000 Bilder verwenden, 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 von TensorFlow aus auf Fashion MNIST zugreifen, indem Sie einfach Daten importieren und herunterladen:
fashion_mnist = keras.datasets.fashion_mnist (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
Beim Laden eines Datensatzes werden vier NumPy-Arrays zurückgegeben:
- Arrays train_images und train_labels sind die Daten, die das Modell für das Training verwendet
- Die Arrays test_images und test_labels werden zum Testen des Modells verwendet.
Bilder sind 28x28 NumPy-Arrays, deren Pixelwerte zwischen 0 und 255 liegen. Die Beschriftungen sind ein Array von Ganzzahlen von 0 bis 9. Sie entsprechen der Kleidungsklasse:
| Etikett | Klasse |
| 0 | T-Shirt (T-Shirt) |
| 1 | Hose (Hose) |
| 2 | Pullover (Pullover) |
| 3 | Kleid |
| 4 | Mantel (Mantel) |
| 5 | Sandale |
| 6 | Hemd |
| 7 | Sneaker (Turnschuhe) |
| 8 | Tasche |
| 9 | Stiefelette (Stiefeletten) |
Klassennamen sind nicht im Datensatz enthalten, daher schreiben wir sie selbst vor:
class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
Datenexploration
Berücksichtigen Sie das Datensatzformat, bevor Sie das Modell trainieren.
train_images.shape
Datenvorverarbeitung
Vor der Vorbereitung des Modells müssen die Daten vorverarbeitet werden. Wenn Sie das erste Bild im Trainingssatz überprüfen, 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)
Wir skalieren diese Werte auf einen Bereich von 0 bis 1:
train_images = train_images / 255.0 test_images = test_images / 255.0
Wir zeigen die ersten 25 Bilder aus dem Trainingssatz an und zeigen den Klassennamen unter jedem Bild. Stellen Sie sicher, dass die Daten das richtige Format haben.
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]])
Modellbau
Der Aufbau eines neuronalen Netzwerks erfordert das Optimieren von Schichten des Modells.
Der Hauptbaustein des neuronalen Netzwerks ist die Schicht. Der größte Teil des tiefen Lernens besteht darin, einfache Schichten zu kombinieren. 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=tf.nn.relu), keras.layers.Dense(10, activation=tf.nn.softmax) ])
Die erste Schicht im Netzwerk tf.keras.layers.Flatten konvertiert das Bildformat von einem 2D-Array (28 x 28 Pixel) in ein 1d-Array von 28 * 28 = 784 Pixel. Diese Ebene hat keine zu untersuchenden Parameter, sondern formatiert nur die Daten neu.
Die nächsten beiden Ebenen sind tf.keras.layers.Dense. Dies sind eng verbundene oder vollständig verbundene neuronale Schichten. Die erste dichte Schicht enthält 128 Knoten (oder Neuronen). Die zweite (und letzte) Ebene ist eine Ebene mit 10 Knoten tf.nn.softmax, die ein Array von zehn Wahrscheinlichkeitsschätzungen zurückgibt, deren Summe 1 ist. Jeder Knoten enthält eine Schätzung, die die Wahrscheinlichkeit angibt, dass das aktuelle Bild zu einer von 10 Klassen gehört.
Modell kompilieren
Bevor das Modell für das Training bereit ist, müssen einige weitere Einstellungen vorgenommen werden. Sie werden während der Kompilierungsphase des Modells hinzugefügt:
- Verlustfunktion - Misst, wie genau das Modell während des Trainings ist
- Mit dem Optimierer wird das Modell basierend auf den angezeigten Daten und der Verlustfunktion aktualisiert.
- Metriken (Metriken) - werden verwendet, um die Phasen des Trainings und Testens zu steuern
model.compile(optimizer=tf.train.AdamOptimizer(), loss='sparse_categorical_crossentropy', metrics=['accuracy'])
Modelltraining
Das Erlernen eines neuronalen Netzwerkmodells erfordert die folgenden Schritte:
- Übermittlung von Modelltrainingsdaten (in diesem Beispiel Arrays train_images und train_labels)
- Ein Modell lernt, Bilder und Tags zuzuordnen.
- Wir bitten das Modell, Vorhersagen über die Testsuite zu treffen (in diesem Beispiel das Array test_images). Wir überprüfen die Konformität der Label-Vorhersagen aus dem Label-Array (in diesem Beispiel das Array test_labels).
Rufen Sie die model.fit-Methode auf, um mit dem Training zu beginnen:
model.fit(train_images, train_labels, epochs=5)
Bei der Modellierung des Modells werden die Indikatoren für Verlust (Verlust) und Genauigkeit (gem.) Angezeigt. Dieses Modell erreicht laut Trainingsdaten eine Genauigkeit von etwa 0,88 (oder 88%).
Genauigkeitsbewertung
Vergleichen Sie, wie das Modell in einem Testdatensatz funktioniert:
test_loss, test_acc = model.evaluate(test_images, test_labels) print('Test accuracy:', test_acc)
Es stellt sich heraus, dass die Genauigkeit im Testdatensatz geringfügig geringer ist als die Genauigkeit im Trainingsdatensatz. Diese Lücke zwischen Trainingsgenauigkeit und Testgenauigkeit ist ein Beispiel für eine Umschulung. Umschulung ist, wenn ein Modell des maschinellen Lernens mit neuen Daten schlechter funktioniert als mit Trainingsdaten.
Prognose
Wir verwenden das Modell, um einige Bilder vorherzusagen.
predictions = model.predict(test_images)
Hier sagte das Modell die Beschriftung für jedes Bild im Testfall voraus. Schauen wir uns die erste Vorhersage an:
predictions[0]
Die Vorhersage ist ein Array von 10 Zahlen. Sie beschreiben das „Vertrauen“ des Modells, dass das Bild jeweils 10 verschiedenen Kleidungsstücken entspricht. Wir können sehen, welches Etikett den höchsten Vertrauenswert hat:
np.argmax(predictions[0])
Daher ist das Modell am sichersten, dass es sich bei diesem Bild um Ankle Boot (Ankle Boots) oder class_names handelt [9]. Und wir können das Testetikett überprüfen, um sicherzustellen, dass dies korrekt ist:
test_labels[0]
Wir werden Funktionen zur Visualisierung dieser Vorhersagen schreiben.
def plot_image(i, predictions_array, true_label, img): predictions_array, true_label, img = predictions_array[i], 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): predictions_array, true_label = predictions_array[i], true_label[i] plt.grid(False) plt.xticks([]) 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')
Schauen wir uns das 0. Bild, Vorhersagen und eine Reihe von Vorhersagen an.
i = 0 plt.figure(figsize=(6,3)) plt.subplot(1,2,1) plot_image(i, predictions, test_labels, test_images) plt.subplot(1,2,2) plot_value_array(i, predictions, test_labels)
Lassen Sie uns einige Bilder mit ihren Vorhersagen erstellen. Die richtigen Prognoseetiketten sind blau und die falschen Prognoseetiketten sind rot. Bitte beachten Sie, dass dies auch dann falsch sein kann, wenn er sehr zuversichtlich ist.
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, test_labels, test_images) plt.subplot(num_rows, 2*num_cols, 2*i+2) plot_value_array(i, predictions, test_labels)
Schließlich verwenden wir ein trainiertes Modell, um eine Vorhersage über ein einzelnes Bild zu treffen.
Tf.keras-Modelle sind optimiert, um Vorhersagen für Pakete (Batch) oder Sammlungen (Sammlung) zu treffen. Obwohl wir ein einzelnes Bild verwenden, müssen wir es daher der Liste hinzufügen:
Vorhersage für Bild:
predictions_single = model.predict(img) print(predictions_single)
plot_value_array(0, predictions_single, test_labels) _ = plt.xticks(range(10), class_names, rotation=45)
np.argmax(predictions_single[0])
Wie zuvor sagt das Modell das Etikett 9 voraus.
Wenn Sie Fragen haben, schreiben Sie in die Kommentare oder in private Nachrichten.