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

TensorFlow 2 Schnellstart für Anfänger

Ansicht auf TensorFlow.org Quelle auf GitHub anzeigen Notizbuch herunterladen

Diese kurze Einführung verwendet Keras, um:

  1. Erstellen Sie ein neuronales Netzwerk, das Bilder klassifiziert.
  2. Trainiere dieses neuronale Netzwerk.
  3. Und schließlich bewerten Sie die Genauigkeit des Modells.

Dies ist eine Google Colaboratory- Notizbuchdatei. Python-Programme werden direkt im Browser ausgeführt - eine großartige Möglichkeit, TensorFlow zu lernen und zu verwenden. Führen Sie das Notizbuch in Google Colab aus, indem Sie auf die Schaltfläche oben auf dieser Seite klicken, um diesem Lernprogramm zu folgen.

  1. Stellen Sie in Colab eine Verbindung zu einer Python-Laufzeit her: Wählen Sie oben rechts in der Menüleiste die Option VERBINDEN .
  2. Führen Sie alle Notebook-Codezellen aus: Wählen Sie Laufzeit > Alle ausführen.

Laden Sie TensorFlow herunter und installieren Sie es. 2. Importieren Sie TensorFlow in Ihr Programm:

import tensorflow as tf

Laden Sie den MNIST-Datensatz und bereiten Sie ihn vor . Konvertieren Sie die Samples von Ganzzahlen in Gleitkommazahlen:

mnist = tf.keras.datasets.mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step

Erstellen Sie das Modell tf.keras.Sequential , indem Sie Ebenen stapeln. Wählen Sie eine Optimierungs- und Verlustfunktion für das Training:

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

Für jedes Beispiel gibt das Modell einen Vektor mit " Logits " - oder " Log-Odds " -Werten zurück , einen für jede Klasse.

predictions = model(x_train[:1]).numpy()
predictions
array([[ 0.48826253, -1.3999053 ,  0.09991729, -0.45614815, -0.02467804,
         0.04654375,  0.60656685, -0.00573175, -0.8574921 ,  0.18740411]],
      dtype=float32)

Die Funktion tf.nn.softmax konvertiert diese Protokolle für jede Klasse in "Wahrscheinlichkeiten":

tf.nn.softmax(predictions).numpy()
array([[0.16138417, 0.02442531, 0.10944721, 0.0627637 , 0.09662592,
        0.10375877, 0.18165185, 0.09847407, 0.04201527, 0.11945374]],
      dtype=float32)

Der losses.SparseCategoricalCrossentropy Verlust verwendet einen Vektor von Logs und einen True Index und gibt für jedes Beispiel einen Skalarverlust zurück.

loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

Dieser Verlust entspricht der negativen logarithmischen Wahrscheinlichkeit der wahren Klasse: Er ist Null, wenn das Modell der richtigen Klasse sicher ist.

Dieses untrainierte Modell liefert Wahrscheinlichkeiten nahe am Zufall (1/10 für jede Klasse), daher sollte der anfängliche Verlust nahe bei -tf.log(1/10) ~= 2.3 .

loss_fn(y_train[:1], predictions).numpy()
2.2656865
model.compile(optimizer='adam',
              loss=loss_fn,
              metrics=['accuracy'])

Die Model.fit Methode passt die Modellparameter an, um den Verlust zu minimieren:

model.fit(x_train, y_train, epochs=5)
Epoch 1/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.2988 - accuracy: 0.9129
Epoch 2/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.1434 - accuracy: 0.9577
Epoch 3/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.1088 - accuracy: 0.9680
Epoch 4/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.0880 - accuracy: 0.9732
Epoch 5/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.0764 - accuracy: 0.9762

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

Die Model.evaluate Methode überprüft die Modell Leistung, in der Regel auf einem „ Validation-Set “ oder „ Testfallsatz “.

model.evaluate(x_test,  y_test, verbose=2)
313/313 - 0s - loss: 0.0825 - accuracy: 0.9753

[0.082541823387146, 0.9753000140190125]

Der Bildklassifizierer wird jetzt mit einer Genauigkeit von ~ 98% für diesen Datensatz trainiert. Weitere Informationen finden Sie in den TensorFlow-Tutorials .

Wenn Sie möchten, dass Ihr Modell eine Wahrscheinlichkeit zurückgibt, können Sie das trainierte Modell einwickeln und den Softmax daran anhängen:

probability_model = tf.keras.Sequential([
  model,
  tf.keras.layers.Softmax()
])
probability_model(x_test[:5])
<tf.Tensor: shape=(5, 10), dtype=float32, numpy=
array([[1.10684750e-08, 1.83911752e-09, 4.16778039e-06, 2.09917707e-05,
        2.52162125e-10, 1.42050753e-08, 4.36062014e-14, 9.99972701e-01,
        8.98372505e-08, 2.04497496e-06],
       [2.00035629e-06, 9.42618586e-04, 9.98860598e-01, 7.35740541e-05,
        1.13993419e-15, 2.42923397e-05, 4.99836897e-05, 7.89078004e-12,
        4.69004663e-05, 1.13254475e-10],
       [1.29524764e-07, 9.99264300e-01, 2.86976556e-05, 5.00339229e-06,
        5.07194600e-05, 2.73460446e-05, 1.02238562e-04, 2.87745963e-04,
        1.96110443e-04, 3.77457800e-05],
       [9.99742687e-01, 1.17186330e-10, 1.08949971e-05, 4.33815472e-08,
        4.19790666e-07, 1.04005512e-05, 1.62759185e-04, 6.06017238e-05,
        6.79190123e-07, 1.15275661e-05],
       [4.76452078e-05, 7.98210220e-10, 1.33194571e-05, 2.75660672e-09,
        9.97387826e-01, 2.63943889e-07, 1.27575304e-05, 1.31325112e-04,
        2.29564466e-06, 2.40453542e-03]], dtype=float32)>