Google I/O è un involucro! Recupera le sessioni di TensorFlow Visualizza le sessioni

Esame del grafico TensorFlow

Visualizza su TensorFlow.org Esegui in Google Colab Visualizza la fonte su GitHub Scarica taccuino

Panoramica

Grafici cruscotto di TensorBoard è un potente strumento per l'esame il vostro modello tensorflow. Puoi visualizzare rapidamente un grafico concettuale della struttura del tuo modello e assicurarti che corrisponda al design previsto. Puoi anche visualizzare un grafico a livello operativo per capire come TensorFlow interpreta il tuo programma. L'esame del grafico del livello operativo può darti un'idea di come modificare il tuo modello. Ad esempio, è possibile riprogettare il modello se l'addestramento procede più lentamente del previsto.

Questo tutorial presenta una rapida panoramica su come generare dati diagnostici grafici e visualizzarli nel dashboard Grafici di TensorBoard. Definirai e addestrerai un semplice modello Keras Sequential per il set di dati Fashion-MNIST e imparerai come registrare ed esaminare i grafici del tuo modello. Potrai anche utilizzare un'API tracing per generare i dati del grafico per le funzioni create utilizzando il nuovo tf.function annotazione.

Impostare

# 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/

Definire un modello Keras

In questo esempio, il classificatore è un semplice modello sequenziale a quattro livelli.

# 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'])

Scarica e prepara i dati di allenamento.

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

Addestrare il modello e registrare i dati

Prima dell'allenamento, definire il callback Keras TensorBoard , specificando la directory di log. Passando questo callback a Model.fit(), ti assicuri che i dati del grafico vengano registrati per la visualizzazione in TensorBoard.

# 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>

Grafico del livello operativo

Avvia TensorBoard e attendi qualche secondo per il caricamento dell'interfaccia utente. Seleziona la dashboard Grafici toccando "Grafici" in alto.

%tensorboard --logdir logs

Puoi anche utilizzare facoltativamente TensorBoard.dev per creare un esperimento ospitato e condivisibile.

!tensorboard dev upload \
  --logdir logs \
  --name "Sample op-level graph" \
  --one_shot

Per default, TensorBoard mostra il grafico di livello op. (A sinistra, puoi vedere il tag "Predefinito" selezionato.) Nota che il grafico è invertito; i dati fluiscono dal basso verso l'alto, quindi sono capovolti rispetto al codice. Tuttavia, puoi vedere che il grafico corrisponde strettamente alla definizione del modello Keras, con bordi aggiuntivi rispetto ad altri nodi di calcolo.

I grafici sono spesso molto grandi, quindi puoi manipolare la visualizzazione del grafico:

  • Scorrere fino a ingrandire e rimpicciolire
  • Trascina per padella
  • Doppio click alterna espansione nodo (un nodo può essere un contenitore per altri nodi)

Puoi anche vedere i metadati facendo clic su un nodo. Ciò consente di visualizzare input, output, forme e altri dettagli.

Grafico concettuale

Oltre al grafico esecuzione, TensorBoard visualizza anche un grafico concettuale. Questa è solo una visione del modello Keras. Questo può essere utile se stai riutilizzando un modello salvato e vuoi esaminarne o convalidarne la struttura.

Per vedere il grafico concettuale, seleziona il tag “keras”. Per questo esempio, si vedrà un nodo sequenziale crollato. Fare doppio clic sul nodo per vedere la struttura del modello:


Grafici di tf.functions

Gli esempi finora hanno descritto i grafici dei modelli Keras, dove i grafici sono stati creati definendo i livelli Keras e chiamando Model.fit().

Si può verificare una situazione in cui è necessario utilizzare il tf.function annotazione "autografo" , vale a dire, trasformare, una funzione di calcolo Python in un grafico tensorflow ad alte prestazioni. Per queste situazioni, si utilizza tensorflow Sintesi traccia API per accedere funzioni autografate per la visualizzazione in TensorBoard.

Per utilizzare l'API di traccia di riepilogo:

  • Definire e annotare una funzione con tf.function
  • Utilizzare tf.summary.trace_on() immediatamente prima che il sito funzione di chiamata.
  • Aggiungere le informazioni del profilo (memoria, tempo di CPU) per grafico passando profiler=True
  • Con uno scrittore file di riepilogo, chiamata tf.summary.trace_export() per salvare i dati di registro

Puoi quindi utilizzare TensorBoard per vedere come si comporta la tua funzione.

# 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

Ora puoi vedere la struttura della tua funzione come compresa da TensorBoard. Fare clic sul pulsante di opzione "Profilo" per visualizzare le statistiche della CPU e della memoria.