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 Experten

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

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:

Importieren Sie TensorFlow in Ihr Programm:

import tensorflow as tf

from tensorflow.keras.layers import Dense, Flatten, Conv2D
from tensorflow.keras import Model

Laden Sie den MNIST-Datensatz und bereiten Sie ihn vor .

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

# Add a channels dimension
x_train = x_train[..., tf.newaxis].astype("float32")
x_test = x_test[..., tf.newaxis].astype("float32")
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step

Verwenden Sie tf.data , um den Datensatz zu tf.data und zu mischen:

train_ds = tf.data.Dataset.from_tensor_slices(
    (x_train, y_train)).shuffle(10000).batch(32)

test_ds = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)

Erstellen Sie das tf.keras Modell mithilfe der Keras- Modell-Unterklassen-API :

class MyModel(Model):
  def __init__(self):
    super(MyModel, self).__init__()
    self.conv1 = Conv2D(32, 3, activation='relu')
    self.flatten = Flatten()
    self.d1 = Dense(128, activation='relu')
    self.d2 = Dense(10)

  def call(self, x):
    x = self.conv1(x)
    x = self.flatten(x)
    x = self.d1(x)
    return self.d2(x)

# Create an instance of the model
model = MyModel()

Wählen Sie eine Optimierungs- und Verlustfunktion für das Training:

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

optimizer = tf.keras.optimizers.Adam()

Wählen Sie Metriken aus, um den Verlust und die Genauigkeit des Modells zu messen. Diese Metriken akkumulieren die Werte über Epochen und drucken dann das Gesamtergebnis.

train_loss = tf.keras.metrics.Mean(name='train_loss')
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')

test_loss = tf.keras.metrics.Mean(name='test_loss')
test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='test_accuracy')

Verwenden Sietf.GradientTape , um das Modell zu trainieren:

@tf.function
def train_step(images, labels):
  with tf.GradientTape() as tape:
    # training=True is only needed if there are layers with different
    # behavior during training versus inference (e.g. Dropout).
    predictions = model(images, training=True)
    loss = loss_object(labels, predictions)
  gradients = tape.gradient(loss, model.trainable_variables)
  optimizer.apply_gradients(zip(gradients, model.trainable_variables))

  train_loss(loss)
  train_accuracy(labels, predictions)

Testen Sie das Modell:

@tf.function
def test_step(images, labels):
  # training=False is only needed if there are layers with different
  # behavior during training versus inference (e.g. Dropout).
  predictions = model(images, training=False)
  t_loss = loss_object(labels, predictions)

  test_loss(t_loss)
  test_accuracy(labels, predictions)
EPOCHS = 5

for epoch in range(EPOCHS):
  # Reset the metrics at the start of the next epoch
  train_loss.reset_states()
  train_accuracy.reset_states()
  test_loss.reset_states()
  test_accuracy.reset_states()

  for images, labels in train_ds:
    train_step(images, labels)

  for test_images, test_labels in test_ds:
    test_step(test_images, test_labels)

  print(
    f'Epoch {epoch + 1}, '
    f'Loss: {train_loss.result()}, '
    f'Accuracy: {train_accuracy.result() * 100}, '
    f'Test Loss: {test_loss.result()}, '
    f'Test Accuracy: {test_accuracy.result() * 100}'
  )
Epoch 1, Loss: 0.1360151171684265, Accuracy: 95.94332885742188, Test Loss: 0.06302054226398468, Test Accuracy: 97.90999603271484
Epoch 2, Loss: 0.04181966185569763, Accuracy: 98.71833038330078, Test Loss: 0.05256362631917, Test Accuracy: 98.22999572753906
Epoch 3, Loss: 0.020464003086090088, Accuracy: 99.33500671386719, Test Loss: 0.05558345466852188, Test Accuracy: 98.30999755859375
Epoch 4, Loss: 0.012017485685646534, Accuracy: 99.60333251953125, Test Loss: 0.06642905622720718, Test Accuracy: 98.1500015258789
Epoch 5, Loss: 0.00839359499514103, Accuracy: 99.73666381835938, Test Loss: 0.07797500491142273, Test Accuracy: 98.19999694824219

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