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

Beginnen Sie mit TensorBoard

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

Um etwas zu verbessern, müssen Sie beim maschinellen Lernen häufig in der Lage sein, es zu messen. TensorBoard ist ein Tool zum Bereitstellen der Messungen und Visualisierungen, die während des maschinellen Lernworkflows erforderlich sind. Es ermöglicht die Verfolgung von Experimentmetriken wie Verlust und Genauigkeit, die Visualisierung des Modellgraphen, die Projektion von Einbettungen in einen Raum mit niedrigeren Dimensionen und vieles mehr.

Dieser Schnellstart zeigt, wie Sie schnell mit TensorBoard beginnen können. Die verbleibenden Anleitungen auf dieser Website enthalten weitere Informationen zu bestimmten Funktionen, von denen viele hier nicht enthalten sind.

# Load the TensorBoard notebook extension
%load_ext tensorboard
import tensorflow as tf
import datetime
# Clear any logs from previous runs
rm -rf ./logs/

Normalisieren Sie am Beispiel des MNIST- Datasets die Daten und schreiben Sie eine Funktion, mit der ein einfaches Keras-Modell zum Klassifizieren der Bilder in 10 Klassen erstellt wird.

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

def create_model():
  return tf.keras.models.Sequential([
    tf.keras.layers.Flatten(input_shape=(28, 28)),
    tf.keras.layers.Dense(512, activation='relu'),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(10, activation='softmax')
  ])
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step

Verwenden von TensorBoard mit Keras Model.fit ()

Beim Training mit Model.fit () von Keras wird durch Hinzufügen des Rückrufs tf.keras.callbacks.TensorBoard sichergestellt, dass Protokolle erstellt und gespeichert werden. Aktivieren Sie außerdem die Histogrammberechnung für jede Epoche mit histogram_freq=1 (dies ist standardmäßig deaktiviert).

Platzieren Sie die Protokolle in einem Unterverzeichnis mit Zeitstempel, um eine einfache Auswahl verschiedener Trainingsläufe zu ermöglichen.

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

log_dir = "logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)

model.fit(x=x_train, 
          y=y_train, 
          epochs=5, 
          validation_data=(x_test, y_test), 
          callbacks=[tensorboard_callback])
Train on 60000 samples, validate on 10000 samples
Epoch 1/5
60000/60000 [==============================] - 15s 246us/sample - loss: 0.2217 - accuracy: 0.9343 - val_loss: 0.1019 - val_accuracy: 0.9685
Epoch 2/5
60000/60000 [==============================] - 14s 229us/sample - loss: 0.0975 - accuracy: 0.9698 - val_loss: 0.0787 - val_accuracy: 0.9758
Epoch 3/5
60000/60000 [==============================] - 14s 231us/sample - loss: 0.0718 - accuracy: 0.9771 - val_loss: 0.0698 - val_accuracy: 0.9781
Epoch 4/5
60000/60000 [==============================] - 14s 227us/sample - loss: 0.0540 - accuracy: 0.9820 - val_loss: 0.0685 - val_accuracy: 0.9795
Epoch 5/5
60000/60000 [==============================] - 14s 228us/sample - loss: 0.0433 - accuracy: 0.9862 - val_loss: 0.0623 - val_accuracy: 0.9823

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

Starten Sie TensorBoard über die Befehlszeile oder in einem Notebook. Die beiden Schnittstellen sind im Allgemeinen gleich. Verwenden Sie in Notebooks die %tensorboard Linienmagie. Führen Sie in der Befehlszeile denselben Befehl ohne "%" aus.

%tensorboard --logdir logs/fit

Eine kurze Übersicht über die angezeigten Dashboards (Registerkarten in der oberen Navigationsleiste):

  • Das Scalars- Dashboard zeigt, wie sich der Verlust und die Metriken mit jeder Epoche ändern. Sie können damit auch die Trainingsgeschwindigkeit, die Lernrate und andere Skalarwerte verfolgen.
  • Das Diagramm- Dashboard hilft Ihnen bei der Visualisierung Ihres Modells. In diesem Fall wird das Keras-Diagramm der Ebenen angezeigt, mit dessen Hilfe Sie sicherstellen können, dass es korrekt erstellt wurde.
  • Die Dashboards Verteilungen und Histogramme zeigen die Verteilung eines Tensors über die Zeit. Dies kann nützlich sein, um Gewichte und Verzerrungen zu visualisieren und zu überprüfen, ob sie sich erwartungsgemäß ändern.

Zusätzliche TensorBoard-Plugins werden automatisch aktiviert, wenn Sie andere Datentypen protokollieren. Mit dem Keras TensorBoard-Rückruf können Sie beispielsweise auch Bilder und Einbettungen protokollieren. Sie können sehen, welche anderen Plugins in TensorBoard verfügbar sind, indem Sie auf das Dropdown-Menü "Inaktiv" oben rechts klicken.

Verwenden von TensorBoard mit anderen Methoden

Verwenden tf.summary beim Training mit Methoden wietf.GradientTape() tf.summary , um die erforderlichen Informationen zu protokollieren.

Verwenden Sie dasselbe Dataset wie oben, konvertieren Sie es jedoch intf.data.Dataset , um dietf.data.Dataset zu nutzen:

train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test))

train_dataset = train_dataset.shuffle(60000).batch(64)
test_dataset = test_dataset.batch(64)

Der Trainingscode folgt dem erweiterten Schnellstart- Tutorial, zeigt jedoch, wie Metriken in TensorBoard protokolliert werden. Wählen Sie Verlust und Optimierer:

loss_object = tf.keras.losses.SparseCategoricalCrossentropy()
optimizer = tf.keras.optimizers.Adam()

Erstellen Sie statusbehaftete Metriken, mit denen Sie während des Trainings Werte sammeln und zu jedem Zeitpunkt protokollieren können:

# Define our metrics
train_loss = tf.keras.metrics.Mean('train_loss', dtype=tf.float32)
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy('train_accuracy')
test_loss = tf.keras.metrics.Mean('test_loss', dtype=tf.float32)
test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy('test_accuracy')

Definieren Sie die Trainings- und Testfunktionen:

def train_step(model, optimizer, x_train, y_train):
  with tf.GradientTape() as tape:
    predictions = model(x_train, training=True)
    loss = loss_object(y_train, predictions)
  grads = tape.gradient(loss, model.trainable_variables)
  optimizer.apply_gradients(zip(grads, model.trainable_variables))

  train_loss(loss)
  train_accuracy(y_train, predictions)

def test_step(model, x_test, y_test):
  predictions = model(x_test)
  loss = loss_object(y_test, predictions)

  test_loss(loss)
  test_accuracy(y_test, predictions)

Richten Sie Zusammenfassungsschreiber ein, um die Zusammenfassungen in einem anderen Protokollverzeichnis auf die Festplatte zu schreiben:

current_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
train_log_dir = 'logs/gradient_tape/' + current_time + '/train'
test_log_dir = 'logs/gradient_tape/' + current_time + '/test'
train_summary_writer = tf.summary.create_file_writer(train_log_dir)
test_summary_writer = tf.summary.create_file_writer(test_log_dir)

Fange an zu trainieren. Verwenden Sie tf.summary.scalar() , um Metriken (Verlust und Genauigkeit) während des Trainings / Testens im Rahmen der Zusammenfassungsschreiber zu protokollieren und die Zusammenfassungen auf die Festplatte zu schreiben. Sie haben die Kontrolle darüber, welche Metriken protokolliert werden sollen und wie oft dies durchgeführt werden soll. Andere tf.summary Funktionen ermöglichen die Protokollierung anderer Datentypen.

model = create_model() # reset our model

EPOCHS = 5

for epoch in range(EPOCHS):
  for (x_train, y_train) in train_dataset:
    train_step(model, optimizer, x_train, y_train)
  with train_summary_writer.as_default():
    tf.summary.scalar('loss', train_loss.result(), step=epoch)
    tf.summary.scalar('accuracy', train_accuracy.result(), step=epoch)

  for (x_test, y_test) in test_dataset:
    test_step(model, x_test, y_test)
  with test_summary_writer.as_default():
    tf.summary.scalar('loss', test_loss.result(), step=epoch)
    tf.summary.scalar('accuracy', test_accuracy.result(), step=epoch)

  template = 'Epoch {}, Loss: {}, Accuracy: {}, Test Loss: {}, Test Accuracy: {}'
  print (template.format(epoch+1,
                         train_loss.result(), 
                         train_accuracy.result()*100,
                         test_loss.result(), 
                         test_accuracy.result()*100))

  # Reset metrics every epoch
  train_loss.reset_states()
  test_loss.reset_states()
  train_accuracy.reset_states()
  test_accuracy.reset_states()
Epoch 1, Loss: 0.24321186542510986, Accuracy: 92.84333801269531, Test Loss: 0.13006582856178284, Test Accuracy: 95.9000015258789
Epoch 2, Loss: 0.10446818172931671, Accuracy: 96.84833526611328, Test Loss: 0.08867532759904861, Test Accuracy: 97.1199951171875
Epoch 3, Loss: 0.07096975296735764, Accuracy: 97.80166625976562, Test Loss: 0.07875105738639832, Test Accuracy: 97.48999786376953
Epoch 4, Loss: 0.05380449816584587, Accuracy: 98.34166717529297, Test Loss: 0.07712937891483307, Test Accuracy: 97.56999969482422
Epoch 5, Loss: 0.041443776339292526, Accuracy: 98.71833038330078, Test Loss: 0.07514958828687668, Test Accuracy: 97.5

Öffnen Sie TensorBoard erneut und zeigen Sie diesmal auf das neue Protokollverzeichnis. Wir hätten TensorBoard auch starten können, um das Training während des Fortschritts zu überwachen.

%tensorboard --logdir logs/gradient_tape

Das ist es! Sie haben jetzt gesehen, wie Sie TensorBoard sowohl über den Keras-Rückruf als auch über tf.summary für benutzerdefinierte Szenarien verwenden.

TensorBoard.dev: Hosten und teilen Sie Ihre ML-Versuchsergebnisse

TensorBoard.dev ist ein kostenloser öffentlicher Dienst, mit dem Sie Ihre TensorBoard-Protokolle hochladen und einen Permalink erhalten können, der in wissenschaftlichen Artikeln, Blog-Posts, sozialen Medien usw. für alle freigegeben werden kann. Dies kann eine bessere Reproduzierbarkeit und Zusammenarbeit ermöglichen.

Führen Sie den folgenden Befehl aus, um TensorBoard.dev zu verwenden:

!tensorboard dev upload \
  --logdir logs/fit \
  --name "(optional) My latest experiment" \
  --description "(optional) Simple comparison of several hyperparameters" \
  --one_shot

Beachten Sie, dass dieser Aufruf das Ausrufezeichen ( ! ) Zum Aufrufen der Shell und nicht das Prozentpräfix ( % ) zum Aufrufen der Colab-Magie verwendet. Wenn Sie diesen Befehl über die Befehlszeile aufrufen, ist keines der beiden Präfixe erforderlich.

Sehen Sie sich hier ein Beispiel an .

Weitere Informationen zur Verwendung von TensorBoard.dev finden Sie unter https://tensorboard.dev/#get-started