TensorFlow 2 Schnellstart für Experten

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

Dies ist eine Notizbuchdatei von Google Colaboratory . Python-Programme werden direkt im Browser ausgeführt – eine großartige Möglichkeit, TensorFlow zu erlernen und zu verwenden. Um dieser Anleitung 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-Laufzeitumgebung her: Wählen Sie oben rechts in der Menüleiste VERBINDEN aus .
  2. Führen Sie alle Notebook-Codezellen aus: Wählen Sie Laufzeit > Alle ausführen aus.

Laden Sie TensorFlow 2 herunter und installieren Sie es. 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 und bereiten Sie den MNIST-Datensatz 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")

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 mit 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 einen Optimierer und eine 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.13717158138751984, Accuracy: 95.86000061035156, Test Loss: 0.06587446480989456, Test Accuracy: 97.82999420166016
Epoch 2, Loss: 0.043185196816921234, Accuracy: 98.68500518798828, Test Loss: 0.05287541449069977, Test Accuracy: 98.27999877929688
Epoch 3, Loss: 0.022479964420199394, Accuracy: 99.26499938964844, Test Loss: 0.06215928494930267, Test Accuracy: 98.1500015258789
Epoch 4, Loss: 0.013441390357911587, Accuracy: 99.55000305175781, Test Loss: 0.06074066460132599, Test Accuracy: 98.23999786376953
Epoch 5, Loss: 0.009441041387617588, Accuracy: 99.6883316040039, Test Loss: 0.054912615567445755, Test Accuracy: 98.5199966430664

Der Bildklassifikator wird nun für diesen Datensatz mit einer Genauigkeit von ~98 % trainiert. Um mehr zu erfahren, lesen Sie die TensorFlow-Tutorials .