Tutorial di TensorBoard: Visualizzazione di grafici con TensorFlow

Cos'è TensorBoard?

TensorBoard è l'interfaccia utilizzata per visualizzare il grafico e altri strumenti per comprendere, eseguire il debug e ottimizzare il modello. È uno strumento che fornisce misurazioni e visualizzazioni per un flusso di lavoro di apprendimento automatico. Aiuta track metriche come la perdita e l'accuratezza, visualizzano il grafico del modello e proiettano gli embedding in spazi a dimensionalità inferiore.

TensorBoard viene fornito con TensorFlow e funziona come un piccolo server web locale che legge i file di evento che un processo di addestramento scrive su disco.

Esempio di visualizzazione di grafici TensorFlow tramite TensorBoard

L'immagine qui sotto proviene dal grafico di TensorBoard che genererai in questo tutorial. Si tratta del pannello principale:

Dall'immagine sotto potete vedere il pannello di visualizzazione dei grafici di TensorBoard. Il pannello contiene diverse schede, collegate al livello di informazioni aggiunte quando si esegue il modello.

• Scalari: Mostrare diverse informazioni utili durante l'addestramento del modello
• grafici: Mostra il modello
• Istogramma: Visualizza i pesi con un istogramma
• Distribuzione: Mostra la distribuzione del peso
• Proiettore: Mostra l'analisi delle componenti principali e l'algoritmo T-SNE. La tecnica utilizzata per la riduzione della dimensionalità.

Durante questo tutorial di TensorBoard, addestrerai un semplice apprendimento profondo modello, e il grafico che produce viene letto dal basso verso l'alto.

Osservando il grafico, è possibile comprendere il funzionamento del modello. I badge numerati nello screenshot sottostante indicano queste quattro fasi:

1. Accoda i dati al modello: invia al modello una quantità di dati pari alla dimensione del batch, ovvero il numero di feed di dati dopo ogni iterazione
2. Fornisci i dati ai tensori
3. Allena il modello
4. Visualizza il numero di lotti durante l'addestramento. Salvare il modello sul disco.

L'idea di base di TensorBoard è che una rete neurale può comportarsi come una scatola nera, e hai bisogno di uno strumento per ispezionare cosa c'è dentro. Pensa a TensorBoard come a una torcia per immergerti nella rete.

Aiuta a comprendere le dipendenze tra le operazioni, come vengono calcolati i pesi, visualizza la funzione di perdita e molte altre informazioni utili. Quando riunisci tutte queste informazioni, hai un ottimo strumento per eseguire il debug e scoprire come migliorare il modello.

Per darvi un'idea di quanto possa essere utile il grafico di TensorBoard, osservate le due curve di perdita qui sotto:

Una rete neurale decide come connettere i diversi neuroni e quanti strati sono necessari affinché il modello possa prevedere un risultato. Una volta definita l'architettura, non solo è necessario addestrare il modello, ma anche una metrica che ne misuri l'accuratezza della previsione. Questa metrica è chiamata funzione di perdita e l'obiettivo è minimizzarla, il che significa semplicemente che il modello commette meno errori.

Ogni algoritmo di addestramento ripete il calcolo molte volte finché la funzione di perdita non si stabilizza su una linea più piatta. Minimizzare la perdita richiede anche un tasso di apprendimento, ovvero la velocità con cui il modello apprende. Se si imposta un tasso di apprendimento troppo elevato, il modello non ha mai il tempo di imparare nulla: questo è il grafico a sinistra, dove la linea oscilla perché il modello sta di fatto procedendo a tentoni. Il grafico a destra mostra la perdita che diminuisce con le iterazioni fino a quando la curva si appiattisce, il che significa che il modello ha trovato una soluzione.

TensorBoard è un ottimo strumento per visualizzare queste metriche ed evidenziare potenziali problemi. Una rete neurale può impiegare ore o settimane prima di trovare una soluzione e TensorBoard aggiorna le metriche mentre il processo è ancora in corso. Pertanto, non è necessario attendere la fine per verificare se il modello si sta addestrando correttamente: basta aprire TensorBoard, controllare l'andamento dell'addestramento e apportare le modifiche necessarie.

Come si usa TensorBoard?

In questa sezione imparerai come aprire TensorBoard dal terminale su macOS e dalla riga di comando su WindowsQui l'attenzione si concentra sullo strumento piuttosto che sul modello, quindi il codice di addestramento è volutamente mantenuto breve.

Innanzitutto, è necessario importare le librerie che verranno utilizzate durante l'addestramento.

## Import the library
import tensorflow as tf
import numpy as np

Tu crei i dati. Si tratta di un array di 10000 righe e 5 colonne.

X_train = (np.random.sample((10000,5)))
y_train =  (np.random.sample((10000,1)))
X_train.shape

Uscita

(10000, 5)

Il codice seguente trasforma i dati e crea il modello.

Si noti che il tasso di apprendimento è pari a 0.1. Se si modifica questo valore, il modello non troverà una soluzione. Questo è quanto accaduto sul lato sinistro dell'immagine qui sopra.

L'esempio utilizza un estimatore TensorFlow, l'API di alto livello che incapsula i calcoli matematici. Gli estimatori appartengono all'API TensorFlow 1.x, quindi i due frammenti seguenti vengono eseguiti sotto un'installazione 1.x o tramite l' tf.compat.v1 spazio dei nomi.

Per creare i file di log, è necessario specificare il percorso. Questo viene fatto con l'argomento model_dir.

Nell'esempio TensorBoard riportato di seguito, si memorizza il modello all'interno della directory di lavoro, ovvero dove si memorizza il notebook o Python file. All'interno di questo percorso, TensorFlow creerà una cartella chiamata train con una sottocartella chiamata linreg.

feature_columns = [
      tf.feature_column.numeric_column('x', shape=X_train.shape[1:])]
DNN_reg = tf.estimator.DNNRegressor(feature_columns=feature_columns,
# Indicate where to store the log file    
     model_dir='train/linreg',    
     hidden_units=[500, 300],    
     optimizer=tf.train.ProximalAdagradOptimizer(      
          learning_rate=0.1,      
          l1_regularization_strength=0.001    
      )
)

Uscita

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {&#x27;_model_dir': 'train/linreg', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1818e63828>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

L'ultimo passaggio di questo esempio di visualizzazione di un grafico con TensorFlow consiste nell'addestramento del modello. Durante l'addestramento, TensorFlow scrive le informazioni nella directory del modello.

# Train the estimator
train_input = tf.estimator.inputs.numpy_input_fn(    
     x={"x": X_train},    
     y=y_train, shuffle=False,num_epochs=None)
DNN_reg.train(train_input,steps=3000)

Uscita

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Saving checkpoints for 1 into train/linreg/model.ckpt.
INFO:tensorflow:loss = 40.060104, step = 1
INFO:tensorflow:global_step/sec: 197.061
INFO:tensorflow:loss = 10.62989, step = 101 (0.508 sec)
INFO:tensorflow:global_step/sec: 172.487
INFO:tensorflow:loss = 11.255318, step = 201 (0.584 sec)
INFO:tensorflow:global_step/sec: 193.295
INFO:tensorflow:loss = 10.604872, step = 301 (0.513 sec)
INFO:tensorflow:global_step/sec: 175.378
INFO:tensorflow:loss = 10.090343, step = 401 (0.572 sec)
INFO:tensorflow:global_step/sec: 209.737
INFO:tensorflow:loss = 10.057928, step = 501 (0.476 sec)
INFO:tensorflow:global_step/sec: 171.646
INFO:tensorflow:loss = 10.460144, step = 601 (0.583 sec)
INFO:tensorflow:global_step/sec: 192.269
INFO:tensorflow:loss = 10.529617, step = 701 (0.519 sec)
INFO:tensorflow:global_step/sec: 198.264
INFO:tensorflow:loss = 9.100082, step = 801 (0.504 sec)
INFO:tensorflow:global_step/sec: 226.842
INFO:tensorflow:loss = 10.485607, step = 901 (0.441 sec)
INFO:tensorflow:global_step/sec: 152.929
INFO:tensorflow:loss = 10.052481, step = 1001 (0.655 sec)
INFO:tensorflow:global_step/sec: 166.745
INFO:tensorflow:loss = 11.320213, step = 1101 (0.600 sec)
INFO:tensorflow:global_step/sec: 161.854
INFO:tensorflow:loss = 9.603306, step = 1201 (0.619 sec)
INFO:tensorflow:global_step/sec: 179.074
INFO:tensorflow:loss = 11.110269, step = 1301 (0.556 sec)
INFO:tensorflow:global_step/sec: 202.776
INFO:tensorflow:loss = 11.929443, step = 1401 (0.494 sec)
INFO:tensorflow:global_step/sec: 144.161
INFO:tensorflow:loss = 11.951693, step = 1501 (0.694 sec)
INFO:tensorflow:global_step/sec: 154.144
INFO:tensorflow:loss = 8.620987, step = 1601 (0.649 sec)
INFO:tensorflow:global_step/sec: 151.094
INFO:tensorflow:loss = 10.666125, step = 1701 (0.663 sec)
INFO:tensorflow:global_step/sec: 193.644
INFO:tensorflow:loss = 11.0349865, step = 1801 (0.516 sec)
INFO:tensorflow:global_step/sec: 189.707
INFO:tensorflow:loss = 9.860596, step = 1901 (0.526 sec)
INFO:tensorflow:global_step/sec: 176.423
INFO:tensorflow:loss = 10.695, step = 2001 (0.567 sec)
INFO:tensorflow:global_step/sec: 213.066
INFO:tensorflow:loss = 10.426752, step = 2101 (0.471 sec)
INFO:tensorflow:global_step/sec: 220.975
INFO:tensorflow:loss = 10.594796, step = 2201 (0.452 sec)
INFO:tensorflow:global_step/sec: 219.289
INFO:tensorflow:loss = 10.4212265, step = 2301 (0.456 sec)
INFO:tensorflow:global_step/sec: 215.123
INFO:tensorflow:loss = 9.668612, step = 2401 (0.465 sec)
INFO:tensorflow:global_step/sec: 175.65
INFO:tensorflow:loss = 10.009649, step = 2501 (0.569 sec)
INFO:tensorflow:global_step/sec: 206.962
INFO:tensorflow:loss = 10.477722, step = 2601 (0.483 sec)
INFO:tensorflow:global_step/sec: 229.627
INFO:tensorflow:loss = 9.877638, step = 2701 (0.435 sec)
INFO:tensorflow:global_step/sec: 195.792
INFO:tensorflow:loss = 10.274586, step = 2801 (0.512 sec)
INFO:tensorflow:global_step/sec: 176.803
INFO:tensorflow:loss = 10.061047, step = 2901 (0.566 sec)
INFO:tensorflow:Saving checkpoints for 3000 into train/linreg/model.ckpt.
INFO:tensorflow:Loss for final step: 10.73032.

<tensorflow.python.estimator.canned.dnn.DNNRegressor at 0x1818e63630>

In TensorFlow 2, lo stesso compito viene svolto dalla callback Keras TensorBoard, che scrive il grafico e le metriche per ogni epoca senza alcun codice di stima:

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

model.fit(train_images, train_labels, epochs=5,
          callbacks=[tensorboard_callback])

Una volta terminata l'esecuzione, la directory dei log contiene un file di checkpoint, un graph.pbtxt file e uno o più events.out.tfevents file — esattamente ciò che legge TensorBoard.

Per macOS utenti

La visualizzazione del Finder qui sotto mostra la nuova cartella train/linreg creata all'interno della directory di lavoro.

Per Windows utenti

On Windows Gli stessi file compaiono nel percorso specificato in model_dir, come evidenziato nella barra degli indirizzi.

Lo stesso formato di file evento viene prodotto da PyTorch, quindi la dashboard non è limitata alle esecuzioni di TensorFlow.

Ora che hai scritto gli eventi di log, puoi aprire TensorBoard. TensorBoard è in esecuzione sulla porta 6006 per impostazione predefinita (Jupyter utilizza la porta 8888). Utilizzare il Terminale su macOS o il prompt di Anaconda su Windows.

Per macOS utenti

# Different for you
cd /Users/Guru99/tuto_TF
source activate hello-tf!

Il notebook è memorizzato nel percorso /Utenti/Guru99/tuto_TF

Per Windows utenti

cd C:\Users\Admin\Anaconda3
activate hello-tf

Il notebook è archiviato nel percorso C:\Users\Admin\Anaconda3

Per avviare TensorBoard, esegui il seguente comando da quella directory.

Per macOS utenti

tensorboard --logdir=./train/linreg

Per Windows utenti

tensorboard --logdir=.\train\linreg

TensorBoard viene quindi servito all'indirizzo http://localhost:6006

Migliori tensorboard dev Il sottocomando non funziona più: il servizio TensorBoard.dev ospitato su server esterni è stato chiuso il 1° gennaio 2024. L'utilizzo locale non è interessato.

Su alcune macchine la console visualizza il nome host anziché localhost, come nel prompt di Anaconda riportato di seguito. Entrambi gli indirizzi aprono la stessa dashboard.

Copia e incolla l'indirizzo nel tuo browser preferito. Dovresti visualizzare la dashboard di Scalars mostrata di seguito.

Se invece visualizzi qualcosa di simile:

Significa che TensorBoard non riesce a trovare il file di log. Assicurati di puntare cd indirizzati al percorso corretto oppure verifica che l'evento di log sia stato effettivamente creato. In caso contrario, esegui nuovamente il codice di addestramento.

Se desideri chiudere TensorBoard, premi CTRL+C nella finestra del terminale.

Suggerimento: controlla il prompt di Anaconda per conoscere la directory di lavoro corrente.

Nella schermata qui sopra, il prompt si trova in C:\Users\Admin, quindi il file di registro dovrebbe essere creato in quella cartella.

DOMANDE FREQUENTI