[PYTHON] Ich habe das TensorFlow-Tutorial mit Kommentaren ausgeführt (erstes neuronales Netzwerk: Beginn des Klassifizierungsproblems)

Referenz-URL: https://www.tensorflow.org/tutorials/keras/classification?hl=ja

Ziel

Mach Folgendes

Erstellen Sie ein neuronales Netzwerk, um Bilder zu klassifizieren
Trainieren Sie das neuronale Netzwerk
Bewerten Sie die Leistung des Modells

Vorbereitung

Vorbereitung der Verpackung

#TensorFlow und tf.Keras importieren
import tensorflow as tf
from tensorflow import keras

#Hilfsbibliothek importieren
import numpy as np
import matplotlib.pyplot as plt

#Tensorflow ver Bestätigung
print(tf.__version__)

2.3.0

Bereiten Sie den Datensatz vor

Dieses Mal werde ich Fashion-MNIST verwenden

Enthält 70.000 Schwarzweißbilder in 10 Kategorien Jedes ist ein Bild mit niedriger Auflösung (28 x 28 Pixel), das eine Art von Kleidung pro Blatt zeigt, wie in der folgenden Abbildung gezeigt.

Figure 1. Fashion-MNIST samples (by Zalando, MIT License).

Das Bild besteht aus einem 28x28 NumPy-Array Der Wert jedes Pixels ist eine ganze Zahl zwischen 0 und 255 Die Bezeichnung ist ein Array von Ganzzahlen von 0 bis 9. Jede Nummer entspricht der in der folgenden Tabelle angegebenen Kleidungsklasse.

Label	Class
0	T-shirt/top
1	Trouser
2	Pullover
3	Dress
4	Coat
5	Sandal
6	Shirt
7	Sneaker
8	Bag
9	Ankle boot

fashion_mnist = keras.datasets.fashion_mnist

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

Jedes Bild wird in ein einzelnes Etikett eingeteilt Weil der Datensatz den obigen Klassennamen nicht enthält Speichern Sie den Klassennamen für die spätere Ausgabe des Bildes

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

Beobachtung von Daten

print(train_images.shape)
print(test_images.shape)

(60000, 28, 28)
(10000, 28, 28)

plt.figure()
plt.imshow(train_images[0], cmap=plt.cm.binary)
plt.colorbar()
plt.grid(False)
plt.show()

Datenvorverarbeitung

Skalieren Sie Bilddatenwerte im Bereich von 0 bis 1

train_images = train_images / 255.0

test_images = test_images / 255.0

Bestätigung der Daten

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()

Modellbau / Lernen

Ein Modell bauen

28 ✖️ 28 2D-Daten auf 1D geglättet

tf.keras.layers.Flatten

input_shape = (28, 28) gibt die Form der Eingabedaten an

Definition der verborgenen Schicht

tf.keras.layers.Dense

128 ist die Anzahl der Einheiten (Anzahl der Neuronen) activity = 'relu' gibt die Aktivierungsfunktion ReLU an Weitere Aktivierungsfunktionen: https://www.tensorflow.org/api_docs/python/tf/keras/activations?hl=ja

Definition der vollständig verbundenen Schicht

Geben Sie 10 an, da es endgültig in 10 Klassen eingeteilt wird Da softmax als Aktivierungsfunktion verwendet wird, 10 Knoten Geben Sie die Wahrscheinlichkeit aus, dass das angezeigte Bild zu jeder der 10 Klassen gehört

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

Modell kompilieren

Ein Modell für das Lernen definieren

--optimer: Optimierer

Geben Sie diesmal "Adam" an
Andere Optimierungsalgorithmen: https://www.tensorflow.org/api_docs/python/tf/keras/optimizers
Verlust: Verlustfunktion
Geben Sie diesmal "Kreuzungsentropie" an --metrics: Elemente, die während des Trainings und Testens quantifiziert wurden
Geben Sie diesmal "Genauigkeit" an

model.compile(optimizer='adam', 
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

Modelltraining

model.fit(train_images, train_labels, epochs=5)

Epoch 1/5
1875/1875 [==============================] - 4s 2ms/step - loss: 0.4964 - accuracy: 0.8259
Epoch 2/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.3725 - accuracy: 0.8656
Epoch 3/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.3336 - accuracy: 0.8787
Epoch 4/5
1875/1875 [==============================] - 4s 2ms/step - loss: 0.3113 - accuracy: 0.8853
Epoch 5/5
1875/1875 [==============================] - 4s 2ms/step - loss: 0.2925 - accuracy: 0.8922





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

Auswertung

Bewerten Sie das Modell

Bewerten Sie das Modell anhand von Testdaten

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

print('\nTest accuracy:', test_acc)

313/313 - 0s - loss: 0.3479 - accuracy: 0.8780

Test accuracy: 0.878000020980835

Prognose

Vorhersage von Testdaten mit einem trainierten Modell

predictions = model.predict(test_images)

Klassifizierungsergebnis des ersten Bildes Ausgabe als Wahrscheinlichkeit

predictions[0]

array([2.1071783e-06, 2.4513878e-07, 3.5516130e-09, 2.4936966e-07,
       6.1619041e-08, 6.4291209e-03, 3.7025956e-08, 2.2654539e-02,
       3.6237492e-07, 9.7091323e-01], dtype=float32)

# `np.argmax`Holen Sie sich den Maximalwert (die Nummer der klassifizierten Beschriftung des Bildes) aus dem Array mit
print(f'predicted label : {np.argmax(predictions[0])}')
#Überprüfen Sie die richtigen Antwortdaten
print(f'true label : {test_labels[0]}')

predicted label : 9
true label : 9

def plot_image(i, predictions_array, true_label, img):
    """
Bild mit vorhergesagter Wahrscheinlichkeit anzeigen
    """
    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):
    """
Erstellen Sie ein Balkendiagramm mit Vorhersageergebnissen
    """
    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')

#Wird als erstes Bild der Testdaten angezeigt
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)
plt.show()

#Wird als 13. Bild der Testdaten angezeigt
i = 12
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)
plt.show()

Zeichnen Sie mit 15 Blatt Testdaten

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)
plt.show()

Vorhersage durch Extrahieren eines Bildes aus den Testdaten

img = test_images[0]

print(img.shape)

(28, 28)

Das tf.keras-Modell dient dazu, Vorhersagen über Chargen oder "Versammlungen" in einer Stichprobe zu treffen. Selbst wenn Sie ein Bild verwenden, müssen Sie es daher auflisten.

#Machen Sie ein Bild zu einem Mitglied von nur einem Stapel
img = (np.expand_dims(img,0))

print(img.shape)

(1, 28, 28)

predictions_single = model.predict(img)

print(predictions_single)

[[2.1071742e-06 2.4513832e-07 3.5515995e-09 2.4936892e-07 6.1618806e-08
  6.4291116e-03 3.7025885e-08 2.2654528e-02 3.6237492e-07 9.7091323e-01]]

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

np.argmax(predictions_single[0])