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

Untersuchen des TensorFlow-Diagramms

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

Überblick

Das Graphs-Dashboard von TensorBoard ist ein leistungsstarkes Tool zur Untersuchung Ihres TensorFlow-Modells. Sie können schnell ein konzeptionelles Diagramm der Struktur Ihres Modells anzeigen und sicherstellen, dass es Ihrem beabsichtigten Design entspricht. Sie können auch ein Diagramm auf op-Ebene anzeigen, um zu verstehen, wie TensorFlow Ihr Programm versteht. Wenn Sie das Op-Level-Diagramm untersuchen, erhalten Sie einen Einblick, wie Sie Ihr Modell ändern können. Sie können Ihr Modell beispielsweise neu gestalten, wenn das Training langsamer als erwartet verläuft.

Dieses Tutorial bietet einen schnellen Überblick darüber, wie Sie Diagrammdiagnosedaten generieren und im Grafik-Dashboard von TensorBoard visualisieren können. Sie definieren und trainieren ein einfaches Keras Sequential-Modell für das Fashion-MNIST-Dataset und lernen, wie Sie Ihre Modellgraphen protokollieren und untersuchen. Sie werden auch eine Ablaufverfolgungs-API verwenden, um Diagrammdaten für Funktionen zu generieren, die mit der neuen Annotation tf.function .

Konfiguration

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

import tensorflow as tf
from tensorflow import keras

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.0

 import tensorboard
tensorboard.__version__
 
'2.2.1'
 # Clear any logs from previous runs
!rm -rf ./logs/ 
 

Definieren Sie ein Keras-Modell

In diesem Beispiel ist der Klassifizierer ein einfaches vierschichtiges sequentielles Modell.

 # Define the model.
model = keras.models.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(32, activation='relu'),
    keras.layers.Dropout(0.2),
    keras.layers.Dense(10, activation='softmax')
])

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

Laden Sie die Trainingsdaten herunter und bereiten Sie sie vor.

 (train_images, train_labels), _ = keras.datasets.fashion_mnist.load_data()
train_images = train_images / 255.0
 

Trainieren Sie das Modell und protokollieren Sie die Daten

Definieren Sie vor dem Training den Keras TensorBoard-Rückruf und geben Sie das Protokollverzeichnis an. Indem Sie diesen Rückruf an Model.fit () übergeben, stellen Sie sicher, dass Diagrammdaten zur Visualisierung in TensorBoard protokolliert werden.

 # Define the Keras TensorBoard callback.
logdir="logs/fit/" + datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)

# Train the model.
model.fit(
    train_images,
    train_labels, 
    batch_size=64,
    epochs=5, 
    callbacks=[tensorboard_callback])
 
Epoch 1/5
938/938 [==============================] - 2s 2ms/step - loss: 0.6955 - accuracy: 0.7618
Epoch 2/5
938/938 [==============================] - 2s 2ms/step - loss: 0.4877 - accuracy: 0.8296
Epoch 3/5
938/938 [==============================] - 2s 2ms/step - loss: 0.4458 - accuracy: 0.8414
Epoch 4/5
938/938 [==============================] - 2s 2ms/step - loss: 0.4246 - accuracy: 0.8476
Epoch 5/5
938/938 [==============================] - 2s 2ms/step - loss: 0.4117 - accuracy: 0.8508

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

Op-Level-Grafik

Starten Sie TensorBoard und warten Sie einige Sekunden, bis die Benutzeroberfläche geladen ist. Wählen Sie das Grafik-Dashboard aus, indem Sie oben auf „Grafiken“ tippen.

 %tensorboard --logdir logs
 

Standardmäßig zeigt TensorBoard das Op-Level-Diagramm an . (Auf der linken Seite sehen Sie das ausgewählte "Standard" -Tag.) Beachten Sie, dass das Diagramm invertiert ist. Die Daten fließen von unten nach oben, sodass sie im Vergleich zum Code auf dem Kopf stehen. Sie können jedoch sehen, dass das Diagramm eng mit der Keras-Modelldefinition übereinstimmt und zusätzliche Kanten zu anderen Berechnungsknoten aufweist.

Diagramme sind oft sehr groß, sodass Sie die Diagrammvisualisierung bearbeiten können:

  • Scrollen Sie zum Vergrößern und Verkleinern
  • Zum Schwenken ziehen
  • Durch Doppelklicken wird die Knotenerweiterung umgeschaltet (ein Knoten kann ein Container für andere Knoten sein).

Sie können Metadaten auch anzeigen, indem Sie auf einen Knoten klicken. Auf diese Weise können Sie Eingaben, Ausgaben, Formen und andere Details anzeigen.

Konzeptionelle Grafik

Neben dem Ausführungsdiagramm zeigt TensorBoard auch ein konzeptionelles Diagramm an . Dies ist nur eine Ansicht des Keras-Modells. Dies kann nützlich sein, wenn Sie ein gespeichertes Modell wiederverwenden und dessen Struktur untersuchen oder validieren möchten.

Um das konzeptionelle Diagramm anzuzeigen, wählen Sie das Tag "Keras" aus. In diesem Beispiel sehen Sie einen reduzierten sequentiellen Knoten. Doppelklicken Sie auf den Knoten, um die Struktur des Modells anzuzeigen:


Diagramme der Funktionen

In den bisherigen Beispielen wurden Diagramme von Keras-Modellen beschrieben, bei denen die Diagramme durch Definieren von Keras-Ebenen und Aufrufen von Model.fit () erstellt wurden.

Es kann vorkommen, dass Sie die Annotation tf.function müssen, um eine Python-Berechnungsfunktion in ein leistungsstarkes TensorFlow-Diagramm zu " tf.function " , dh zu transformieren. In diesen Situationen verwenden Sie die TensorFlow Summary Trace API , um signierte Funktionen für die Visualisierung in TensorBoard zu protokollieren.

So verwenden Sie die Summary Trace-API:

Sie können dann TensorBoard verwenden, um zu sehen, wie sich Ihre Funktion verhält.

 # The function to be traced.
@tf.function
def my_func(x, y):
  # A simple hand-rolled layer.
  return tf.nn.relu(tf.matmul(x, y))

# Set up logging.
stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
logdir = 'logs/func/%s' % stamp
writer = tf.summary.create_file_writer(logdir)

# Sample data for your function.
x = tf.random.uniform((3, 3))
y = tf.random.uniform((3, 3))

# Bracket the function call with
# tf.summary.trace_on() and tf.summary.trace_export().
tf.summary.trace_on(graph=True, profiler=True)
# Call only one tf.function when tracing.
z = my_func(x, y)
with writer.as_default():
  tf.summary.trace_export(
      name="my_func_trace",
      step=0,
      profiler_outdir=logdir)
 
 %tensorboard --logdir logs/func
 

Sie können jetzt die Struktur Ihrer Funktion sehen, wie sie von TensorBoard verstanden wird. Klicken Sie auf den Radiobutton "Profil", um die CPU- und Speicherstatistik anzuzeigen.