Questa pagina è stata tradotta dall'API Cloud Translation.
Switch to English

Esame del grafico TensorFlow

Visualizza su TensorFlow.org Esegui in Google Colab Visualizza sorgente su GitHub

Panoramica

La dashboard Graphs di TensorBoard è un potente strumento per esaminare il tuo modello TensorFlow. È possibile visualizzare rapidamente un grafico concettuale della struttura del modello e assicurarsi che corrisponda al design previsto. Puoi anche visualizzare un grafico a livello operativo per capire come TensorFlow comprende il tuo programma. L'esame del grafico a livello operativo può darti un'idea di come cambiare il tuo modello. Ad esempio, è possibile riprogettare il modello se l'allenamento procede più lentamente del previsto.

Questo tutorial presenta una rapida panoramica di come generare i dati diagnostici dei grafici e visualizzarli nella dashboard dei grafici di TensorBoard. Definirai e formerai un semplice modello sequenziale di Keras per il set di dati Fashion-MNIST e imparerai come registrare ed esaminare i grafici del tuo modello. Utilizzerai anche un'API di traccia per generare dati grafici per le funzioni create utilizzando la nuova annotazione tf.function .

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

Addestra il modello e registra i dati

Prima dell'allenamento, definire il callback di Keras TensorBoard , specificando la directory di registro. Passando questo callback a Model.fit (), si assicura che i dati del grafico siano 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 a livello operativo

Avviare TensorBoard e attendere alcuni secondi per caricare l'interfaccia utente. Seleziona il pannello Grafici toccando “Grafici” in alto.

 %tensorboard --logdir logs
 

Per impostazione predefinita, TensorBoard visualizza il grafico del livello operativo. (A sinistra, puoi vedere il tag “Predefinito” selezionato.) Nota che il grafico è invertito; i dati scorrono dal basso verso l'alto, quindi sono capovolti rispetto al codice. Tuttavia, puoi vedere che il grafico corrisponde strettamente alla definizione del modello di Keras, con bordi extra rispetto ad altri nodi di calcolo.

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

  • Scorri per ingrandire e ridurre
  • Trascina per eseguire la panoramica
  • Fare doppio clic per attivare / disattivare l'espansione del 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 di esecuzione, TensorBoard visualizza anche un grafico concettuale . Questa è una visione del solo modello Keras. Ciò può essere utile se stai riutilizzando un modello salvato e desideri esaminarne o convalidarne la struttura.

Per vedere il grafico concettuale, selezionare il tag "keras". Per questo esempio, vedrai un nodo sequenziale compresso. Fare doppio clic sul nodo per vedere la struttura del modello:


Grafici delle funzioni tf

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

È possibile che si tf.function una situazione in cui è necessario utilizzare l'annotazione tf.function per "autografare" , ovvero trasformare una funzione di calcolo Python in un grafico TensorFlow ad alte prestazioni. Per queste situazioni, si utilizza l' API di traccia riepilogo TensorFlow per registrare le 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 del sito di chiamata della funzione.
  • Aggiungi informazioni del profilo (memoria, tempo CPU) al grafico passando profiler=True
  • Con un writer di file di riepilogo, chiamare tf.summary.trace_export() per salvare i dati del registro

È quindi possibile 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.