Google I / O kehrt vom 18. bis 20. Mai zurück! Reservieren Sie Platz und erstellen Sie Ihren Zeitplan Registrieren Sie sich jetzt
Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

TensorFlow 2 Schnellstart für Anfänger

Ansicht auf TensorFlow.org In Google Colab ausführen Quelle auf GitHub anzeigen Notizbuch herunterladen

In dieser kurzen Einführung wird Keras verwendet, 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. Um diesem Tutorial zu folgen, führen Sie das Notizbuch in Google Colab aus, indem Sie auf die Schaltfläche oben auf dieser Seite klicken.

  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

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.67086774, -0.25231966,  0.01695401, -0.20872438, -0.5840499 ,
         0.20415965, -0.07967779,  0.01230302,  0.2564202 ,  0.19890268]],
      dtype=float32)

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

tf.nn.softmax(predictions).numpy()
array([[0.18120685, 0.07198457, 0.09422877, 0.07519217, 0.05166196,
        0.11362814, 0.08554938, 0.09379152, 0.11972431, 0.11303235]],
      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.math.log(1/10) ~= 2.3 .

loss_fn(y_train[:1], predictions).numpy()
2.1748242
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.4813 - accuracy: 0.8565
Epoch 2/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.1533 - accuracy: 0.9553
Epoch 3/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.1057 - accuracy: 0.9686
Epoch 4/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0908 - accuracy: 0.9721
Epoch 5/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0700 - accuracy: 0.9788
<tensorflow.python.keras.callbacks.History at 0x7f7c15df5358>

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.0748 - accuracy: 0.9758
[0.07476752996444702, 0.9757999777793884]

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([[7.78855878e-08, 6.61358468e-11, 6.59998250e-07, 1.59961201e-05,
        2.46321262e-11, 1.29930243e-07, 2.94833365e-14, 9.99982715e-01,
        4.22193658e-08, 4.47160573e-07],
       [4.33228813e-08, 1.27517624e-05, 9.99970555e-01, 1.60829786e-05,
        2.47642311e-16, 7.49611928e-09, 1.37607294e-08, 4.11349470e-12,
        6.27970280e-07, 9.24811917e-14],
       [2.03916397e-06, 9.99185383e-01, 1.84247561e-04, 1.05477593e-05,
        2.75765397e-05, 5.58228692e-07, 1.01305332e-05, 4.32787347e-04,
        1.45807702e-04, 8.87280294e-07],
       [9.99742925e-01, 5.94857603e-08, 8.63709865e-05, 1.54006088e-08,
        1.39324254e-06, 4.43872267e-07, 1.60094583e-04, 5.25048790e-07,
        8.63345750e-09, 8.21989215e-06],
       [5.87329941e-06, 3.34152190e-07, 3.92818802e-05, 3.36201609e-08,
        9.96013522e-01, 5.50971926e-08, 4.14997248e-06, 1.14215931e-04,
        2.20527431e-06, 3.82039533e-03]], dtype=float32)>