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

Inizia con TensorBoard

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

Nell'apprendimento automatico, per migliorare qualcosa spesso è necessario essere in grado di misurarlo. TensorBoard è uno strumento per fornire le misurazioni e le visualizzazioni necessarie durante il flusso di lavoro di machine learning. Consente il monitoraggio delle metriche dell'esperimento come la perdita e l'accuratezza, la visualizzazione del grafico del modello, la proiezione di incorporamenti in uno spazio dimensionale inferiore e molto altro ancora.

Questa guida rapida mostrerà come iniziare rapidamente con TensorBoard. Le restanti guide in questo sito web forniscono maggiori dettagli su capacità specifiche, molte delle quali non sono incluse qui.

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

Usando il set di dati MNIST come esempio, normalizza i dati e scrivi una funzione che crea un semplice modello Keras per classificare le immagini in 10 classi.

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

Utilizzo di TensorBoard con Keras Model.fit ()

Quando ci si allena con Model.fit () di Keras, l'aggiunta della richiamata tf.keras.callbacks.TensorBoard garantisce la creazione e l'archiviazione dei registri. Inoltre, abilita il calcolo dell'istogramma ogni epoca con histogram_freq=1 (questo è disattivato per impostazione predefinita)

Posiziona i log in una sottodirectory con data e ora per consentire una facile selezione di diverse sessioni di allenamento.

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>

Avvia TensorBoard tramite la riga di comando o all'interno di un'esperienza notebook. Le due interfacce sono generalmente le stesse. Nei notebook, usa la magia della linea %tensorboard . Sulla riga di comando, esegui lo stesso comando senza "%".

%tensorboard --logdir logs/fit

Una breve panoramica dei dashboard mostrati (schede nella barra di navigazione in alto):

  • La dashboard Scalars mostra come la perdita e le metriche cambiano ad ogni epoca. Puoi usarlo per monitorare anche la velocità di allenamento, la velocità di apprendimento e altri valori scalari.
  • La dashboard Grafici ti aiuta a visualizzare il tuo modello. In questo caso, viene mostrato il grafico dei livelli di Keras che può aiutarti a garantire che sia costruito correttamente.
  • I dashboard Distribuzioni e Istogrammi mostrano la distribuzione di un tensore nel tempo. Questo può essere utile per visualizzare pesi e pregiudizi e verificare che cambino nel modo previsto.

I plugin aggiuntivi di TensorBoard vengono abilitati automaticamente quando si registrano altri tipi di dati. Ad esempio, il callback di Keras TensorBoard ti consente di registrare anche immagini e incorporamenti. Puoi vedere quali altri plugin sono disponibili in TensorBoard facendo clic sul menu a discesa "inattivo" in alto a destra.

Utilizzo di TensorBoard con altri metodi

Quando ci si allena con metodi come tf.GradientTape() , utilizzare tf.summary per registrare le informazioni richieste.

Usa lo stesso set di dati come sopra, ma convertilo in tf.data.Dataset per sfruttare le funzionalità di batch:

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)

Il codice di formazione segue il tutorial di avvio rapido avanzato , ma mostra come registrare le metriche su TensorBoard. Scegli perdita e ottimizzatore:

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

Crea metriche stateful che possono essere utilizzate per accumulare valori durante l'allenamento e registrate in qualsiasi momento:

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

Definisci le funzioni di addestramento e test:

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)

Configurare i writer di riepilogo per scrivere i riepiloghi su disco in una directory dei registri diversa:

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)

Inizia la formazione. Utilizzare tf.summary.scalar() per registrare le metriche (perdita e accuratezza) durante l'addestramento / test nell'ambito dei writer di riepilogo per scrivere i riepiloghi su disco. Hai il controllo su quali metriche registrare e con quale frequenza. Altre funzioni di tf.summary consentono di registrare altri tipi di dati.

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

Apri di nuovo TensorBoard, questa volta puntandolo alla nuova directory di log. Avremmo anche potuto avviare TensorBoard per monitorare l'allenamento mentre procede.

%tensorboard --logdir logs/gradient_tape

Questo è tutto! Ora hai visto come utilizzare TensorBoard sia tramite il callback di Keras che tramite tf.summary per scenari più personalizzati.

TensorBoard.dev: ospita e condividi i risultati del tuo esperimento ML

TensorBoard.dev è un servizio pubblico gratuito che ti consente di caricare i tuoi registri di TensorBoard e di ottenere un permalink che può essere condiviso con tutti in documenti accademici, post di blog, social media, ecc. Ciò può consentire una migliore riproducibilità e collaborazione.

Per utilizzare TensorBoard.dev, esegui il seguente comando:

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

Si noti che questa invocazione utilizza il prefisso esclamativo ( ! ) Per invocare la shell piuttosto che il prefisso percentuale ( % ) per invocare la magia del colab. Quando si richiama questo comando dalla riga di comando non è necessario alcun prefisso.

Visualizza un esempio qui .

Per maggiori dettagli su come utilizzare TensorBoard.dev, vedere https://tensorboard.dev/#get-started