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

TensorBoard-Skalare: Protokollieren von Trainingsmetriken in Keras

Ansicht auf TensorFlow.org Quelle auf GitHub anzeigen

Überblick

Beim maschinellen Lernen müssen ausnahmslos wichtige Kennzahlen wie Verlust und deren Änderung im Verlauf des Trainings verstanden werden. Diese Metriken können Ihnen helfen zu verstehen, ob Sie beispielsweise überanpassen oder unnötig zu lange trainieren. Möglicherweise möchten Sie diese Metriken über verschiedene Trainingsläufe hinweg vergleichen, um das Debuggen und Verbessern Ihres Modells zu unterstützen.

Mit dem Scalars Dashboard von TensorBoard können Sie diese Metriken mithilfe einer einfachen API mit sehr geringem Aufwand visualisieren. Dieses Tutorial enthält sehr grundlegende Beispiele, mit denen Sie lernen, wie Sie diese APIs mit TensorBoard bei der Entwicklung Ihres Keras-Modells verwenden. Sie erfahren, wie Sie die Keras TensorBoard-Rückruf- und TensorFlow-Zusammenfassungs-APIs verwenden, um Standard- und benutzerdefinierte Skalare zu visualisieren.

Installieren

# Load the TensorBoard notebook extension.
%load_ext tensorboard
from datetime import datetime
from packaging import version

import tensorflow as tf
from tensorflow import keras

import numpy as np

print("TensorFlow version: ", tf.__version__)
assert version.parse(tf.__version__).release[0] >= 2, \
    "This notebook requires TensorFlow 2.0 or above."
TensorFlow version:  2.2

Richten Sie Daten für eine einfache Regression ein

Sie werden jetzt Keras verwenden , um eine Regression zu berechnen, dh die beste Anpassungslinie für einen gepaarten Datensatz zu finden. (Während die Verwendung neuronaler Netze und der Gradientenabstieg für diese Art von Problem übertrieben sind , ist dies ein sehr leicht verständliches Beispiel.)

Du wirst TensorBoard verwenden , wie Training und Testverluständerung über Epochen zu beobachten. Hoffentlich werden Training und Testverlust mit der Zeit abnehmen und dann stabil bleiben.

Generieren Sie zunächst 1000 Datenpunkte ungefähr entlang der Linie y = 0,5x + 2 . Teilen Sie diese Datenpunkte in Trainings- und Testsätze auf. Ihre Hoffnung ist, dass das neuronale Netz diese Beziehung lernt.

data_size = 1000
# 80% of the data is for training.
train_pct = 0.8

train_size = int(data_size * train_pct)

# Create some input data between -1 and 1 and randomize it.
x = np.linspace(-1, 1, data_size)
np.random.shuffle(x)

# Generate the output data.
# y = 0.5x + 2 + noise
y = 0.5 * x + 2 + np.random.normal(0, 0.05, (data_size, ))

# Split into test and train pairs.
x_train, y_train = x[:train_size], y[:train_size]
x_test, y_test = x[train_size:], y[train_size:]

Training des Modells und Protokollverlust

Sie können jetzt Ihr Modell definieren, trainieren und bewerten.

Um den Verlustskalar während des Trainings zu protokollieren, gehen Sie wie folgt vor:

  1. Erstellen Sie den Keras TensorBoard-Rückruf
  2. Geben Sie ein Protokollverzeichnis an
  3. Übergeben Sie den TensorBoard-Rückruf an Keras ' Model.fit () .

TensorBoard liest Protokolldaten aus der Protokollverzeichnishierarchie. In diesem Notizbuch besteht das Stammprotokollverzeichnis aus logs/scalars , denen ein Unterverzeichnis mit Zeitstempel angehängt ist. Das zeitgestempelte Unterverzeichnis ermöglicht es Ihnen, Trainingsläufe einfach zu identifizieren und auszuwählen, während Sie TensorBoard verwenden und Ihr Modell iterieren.

logdir = "logs/scalars/" + datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)

model = keras.models.Sequential([
    keras.layers.Dense(16, input_dim=1),
    keras.layers.Dense(1),
])

model.compile(
    loss='mse', # keras.losses.mean_squared_error
    optimizer=keras.optimizers.SGD(lr=0.2),
)

print("Training ... With default parameters, this takes less than 10 seconds.")
training_history = model.fit(
    x_train, # input
    y_train, # output
    batch_size=train_size,
    verbose=0, # Suppress chatty output; use Tensorboard instead
    epochs=100,
    validation_data=(x_test, y_test),
    callbacks=[tensorboard_callback],
)

print("Average test loss: ", np.average(training_history.history['loss']))
Training ... With default parameters, this takes less than 10 seconds.
Average test loss:  0.05271831926424056

Verlust mit TensorBoard untersuchen

Starten Sie nun TensorBoard und geben Sie das oben verwendete Stammprotokollverzeichnis an.

Warten Sie einige Sekunden, bis die Benutzeroberfläche von TensorBoard hochgefahren ist.

%tensorboard --logdir logs/scalars

Möglicherweise zeigt TensorBoard die Meldung "Für den aktuellen Datensatz sind keine Dashboards aktiv" an. Dies liegt daran, dass die anfänglichen Protokolldaten noch nicht gespeichert wurden. Im Verlauf des Trainings beginnt das Keras-Modell mit der Protokollierung von Daten. TensorBoard wird regelmäßig aktualisiert und zeigt Ihnen Ihre skalaren Metriken an. Wenn Sie ungeduldig sind, können Sie oben rechts auf den Pfeil Aktualisieren tippen.

Beachten Sie beim Beobachten des Trainingsfortschritts, wie schnell sowohl der Trainings- als auch der Validierungsverlust abnehmen und dann stabil bleiben. Tatsächlich hätten Sie nach 25 Epochen mit dem Training aufhören können, da sich das Training nach diesem Zeitpunkt nicht wesentlich verbessert hat.

Bewegen Sie den Mauszeiger über das Diagramm, um bestimmte Datenpunkte anzuzeigen. Sie können auch versuchen, mit der Maus hineinzuzoomen oder einen Teil davon auszuwählen, um weitere Details anzuzeigen.

Beachten Sie den Selektor "Runs" auf der linken Seite. Ein "Lauf" repräsentiert eine Reihe von Protokollen aus einer Trainingsrunde, in diesem Fall das Ergebnis von Model.fit (). Entwickler haben normalerweise viele, viele Läufe, wenn sie experimentieren und ihr Modell im Laufe der Zeit entwickeln.

Verwenden Sie die Auswahl Läufe, um bestimmte Läufe auszuwählen, oder wählen Sie nur Training oder Validierung aus. Durch das Vergleichen von Läufen können Sie bewerten, welche Version Ihres Codes Ihr Problem besser löst.

Ok, das Verlustdiagramm von TensorBoard zeigt, dass der Verlust sowohl für das Training als auch für die Validierung konstant abnahm und sich dann stabilisierte. Das bedeutet, dass die Metriken des Modells wahrscheinlich sehr gut sind! Sehen Sie nun, wie sich das Modell im wirklichen Leben tatsächlich verhält.

Bei den Eingabedaten (60, 25, 2) sollte die Linie y = 0,5x + 2 (32, 14,5, 3) ergeben. Stimmt das Modell überein?

print(model.predict([60, 25, 2]))
# True values to compare predictions against: 
# [[32.0]
#  [14.5]
#  [ 3.0]]
[[32.234306 ]
 [14.5974245]
 [ 3.0074697]]

Nicht schlecht!

Benutzerdefinierte Skalare protokollieren

Was ist, wenn Sie benutzerdefinierte Werte wie eine dynamische Lernrate protokollieren möchten? Dazu müssen Sie die TensorFlow Summary API verwenden.

Trainieren Sie das Regressionsmodell neu und protokollieren Sie eine benutzerdefinierte Lernrate. Hier ist wie:

  1. Erstellen Sie einen tf.summary.create_file_writer() mit tf.summary.create_file_writer() .
  2. Definieren Sie eine benutzerdefinierte Lernratenfunktion. Dies wird an den Keras LearningRateScheduler- Rückruf übergeben.
  3. Verwenden Sie in der tf.summary.scalar() , um die benutzerdefinierte Lernrate zu protokollieren.
  4. Übergeben Sie den LearningRateScheduler-Rückruf an Model.fit ().

Um einen benutzerdefinierten Skalar zu protokollieren, müssen Sie im Allgemeinen tf.summary.scalar() mit einem tf.summary.scalar() . Der tf.summary.scalar() ist für das Schreiben der Daten für diesen Lauf in das angegebene Verzeichnis verantwortlich und wird implizit verwendet, wenn Sie tf.summary.scalar() .

logdir = "logs/scalars/" + datetime.now().strftime("%Y%m%d-%H%M%S")
file_writer = tf.summary.create_file_writer(logdir + "/metrics")
file_writer.set_as_default()

def lr_schedule(epoch):
  """
  Returns a custom learning rate that decreases as epochs progress.
  """
  learning_rate = 0.2
  if epoch > 10:
    learning_rate = 0.02
  if epoch > 20:
    learning_rate = 0.01
  if epoch > 50:
    learning_rate = 0.005

  tf.summary.scalar('learning rate', data=learning_rate, step=epoch)
  return learning_rate

lr_callback = keras.callbacks.LearningRateScheduler(lr_schedule)
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)

model = keras.models.Sequential([
    keras.layers.Dense(16, input_dim=1),
    keras.layers.Dense(1),
])

model.compile(
    loss='mse', # keras.losses.mean_squared_error
    optimizer=keras.optimizers.SGD(),
)

training_history = model.fit(
    x_train, # input
    y_train, # output
    batch_size=train_size,
    verbose=0, # Suppress chatty output; use Tensorboard instead
    epochs=100,
    validation_data=(x_test, y_test),
    callbacks=[tensorboard_callback, lr_callback],
)

Schauen wir uns noch einmal TensorBoard an.

%tensorboard --logdir logs/scalars

Beachten Sie, dass Sie mit dem Selektor "Läufe" auf der linken Seite einen <timestamp>/metrics ausführen. Wenn Sie diesen Lauf auswählen, wird ein Diagramm "Lernrate" angezeigt, mit dem Sie den Verlauf der Lernrate während dieses Laufs überprüfen können.

Sie können auch die Trainings- und Validierungsverlustkurven dieses Laufs mit Ihren früheren Läufen vergleichen.

Wie funktioniert dieses Modell?

print(model.predict([60, 25, 2]))
# True values to compare predictions against: 
# [[32.0]
#  [14.5]
#  [ 3.0]]
[[32.234013 ]
 [14.5973015]
 [ 3.0074618]]