Come posso usare il callback Tensorboard di Keras?

Ho costruito una rete neurale con Keras. Visualizzerei i suoi dati tramite Tensorboard, quindi ho utilizzato:

keras.callbacks.TensorBoard(log_dir='/Graph', histogram_freq=0,
                            write_graph=True, write_images=True)

come spiegato in keras.io . Quando eseguo il callback ricevo <keras.callbacks.TensorBoard at 0x7f9abb3898>, ma non ottengo alcun file nella mia cartella "Graph". C'è qualcosa di sbagliato nel modo in cui ho usato questo callback?

keras.callbacks.TensorBoard(log_dir='./Graph', histogram_freq=0,  
          write_graph=True, write_images=True)

Questa riga crea un oggetto Callens Tensorboard, è necessario acquisire quell'oggetto e assegnarlo alla fitfunzione del modello.

tbCallBack = keras.callbacks.TensorBoard(log_dir='./Graph', histogram_freq=0, write_graph=True, write_images=True)
...
model.fit(...inputs and parameters..., callbacks=[tbCallBack])

In questo modo hai assegnato il tuo oggetto callback alla funzione. Verrà eseguito durante l'allenamento e genererà file che possono essere utilizzati con tensorboard.

Se vuoi visualizzare i file creati durante l'allenamento, esegui nel tuo terminale

tensorboard --logdir path_to_current_dir/Graph 

Spero che questo ti aiuti !

Ecco come si utilizza il callback TensorBoard :

from keras.callbacks import TensorBoard

tensorboard = TensorBoard(log_dir='./logs', histogram_freq=0,
                          write_graph=True, write_images=False)
# define model
model.fit(X_train, Y_train,
          batch_size=batch_size,
          epochs=nb_epoch,
          validation_data=(X_test, Y_test),
          shuffle=True,
          callbacks=[tensorboard])

Modificare

keras.callbacks.TensorBoard(log_dir='/Graph', histogram_freq=0,  
          write_graph=True, write_images=True)

per

tbCallBack = keras.callbacks.TensorBoard(log_dir='Graph', histogram_freq=0,  
          write_graph=True, write_images=True)

e imposta il tuo modello

tbCallback.set_model(model)

Corri nel tuo terminale

tensorboard  --logdir Graph/

Se stai lavorando con la libreria Keras e vuoi usare la tensorboard per stampare i tuoi grafici di precisione e altre variabili, allora di seguito sono i passaggi da seguire.

passaggio 1: inizializzare la libreria di callback di keras per importare la tensorboard utilizzando il comando seguente

from keras.callbacks import TensorBoard

passaggio 2: includere il comando seguente nel programma appena prima del comando "model.fit ()".

tensor_board = TensorBoard(log_dir='./Graph', histogram_freq=0, write_graph=True, write_images=True)

Nota: utilizzare "./graph". Genererà la cartella dei grafici nella directory di lavoro corrente, evitando di usare "/ graph".

passaggio 3: includere il callback di Tensorboard in "model.fit ()". L'esempio è riportato di seguito.

model.fit(X_train,y_train, batch_size=batch_size, epochs=nb_epoch, verbose=1, validation_split=0.2,callbacks=[tensor_board])

passaggio 4: eseguire il codice e verificare se la cartella del grafico è presente nella directory di lavoro. se i codici sopra funzionano correttamente avrai la cartella "Graph" nella tua directory di lavoro.

passaggio 5: aprire Terminale nella directory di lavoro e digitare il comando seguente.

tensorboard --logdir ./Graph

passaggio 6: ora apri il browser web e inserisci l'indirizzo qui sotto.

http://localhost:6006

Dopo aver inserito, si aprirà la pagina Tensorbaord in cui è possibile vedere i grafici delle diverse variabili.

Ecco un po 'di codice:

K.set_learning_phase(1)
K.set_image_data_format('channels_last')

tb_callback = keras.callbacks.TensorBoard(
    log_dir=log_path,
    histogram_freq=2,
    write_graph=True
)
tb_callback.set_model(model)
callbacks = []
callbacks.append(tb_callback)

# Train net:
history = model.fit(
    [x_train],
    [y_train, y_train_c],
    batch_size=int(hype_space['batch_size']),
    epochs=EPOCHS,
    shuffle=True,
    verbose=1,
    callbacks=callbacks,
    validation_data=([x_test], [y_test, y_test_coarse])
).history

# Test net:
K.set_learning_phase(0)
score = model.evaluate([x_test], [y_test, y_test_coarse], verbose=0)

Fondamentalmente, histogram_freq=2è il parametro più importante da mettere a punto quando si chiama questo callback: imposta un intervallo di epoche per chiamare il callback, con l'obiettivo di generare meno file sui dischi.

Ecco quindi un esempio di visualizzazione dell'evoluzione dei valori per l'ultima convoluzione durante l'allenamento una volta visto in TensorBoard, sotto la scheda "istogrammi" (e ho trovato la scheda "distribuzioni" per contenere grafici molto simili, ma capovolto sul lato):

Nel caso in cui desideri vedere un esempio completo nel contesto, puoi fare riferimento a questo progetto open source: https://github.com/Vooban/Hyperopt-Keras-CNN-CIFAR-100

Se stai usando google-colab la visualizzazione semplice del grafico sarebbe:

import tensorboardcolab as tb

tbc = tb.TensorBoardColab()
tensorboard = tb.TensorBoardColabCallback(tbc)


history = model.fit(x_train,# Features
                    y_train, # Target vector
                    batch_size=batch_size, # Number of observations per batch
                    epochs=epochs, # Number of epochs
                    callbacks=[early_stopping, tensorboard], # Early stopping
                    verbose=1, # Print description after each epoch
                    validation_split=0.2, #used for validation set every each epoch
                    validation_data=(x_test, y_test)) # Test data-set to evaluate the model in the end of training

Hai scritto log_dir='/Graph'intendevi ./Graphinvece? L'hai inviato /home/user/Graphal momento.

Dovresti dare un'occhiata a Losswise ( https://losswise.com ), ha un plug-in per Keras che è più facile da usare rispetto a Tensorboard e ha alcune belle funzionalità extra. Con Losswise useresti semplicemente from losswise.libs import LosswiseKerasCallbacke poi callback = LosswiseKerasCallback(tag='my fancy convnet 1')andrai bene (vedi https://docs.losswise.com/#keras-plugin ).

Ci sono poche cose

Primo, no /Graphma./Graph

In secondo luogo, quando si utilizza il callback TensorBoard, passare sempre i dati di convalida, perché senza di essa non si avvia.

In terzo luogo, se si desidera utilizzare qualcosa di diverso dai riepiloghi scalari, utilizzare il fitmetodo solo perché fit_generatornon funzionerà. Oppure puoi riscrivere il callback con cui lavorare fit_generator.

Per aggiungere callback, basta aggiungerlo a model.fit(..., callbacks=your_list_of_callbacks)

Creare il callback Tensorboard:

from keras.callbacks import TensorBoard
from datetime import datetime
logDir = "./Graph/" + datetime.now().strftime("%Y%m%d-%H%M%S") + "/"
tb = TensorBoard(log_dir=logDir, histogram_freq=2, write_graph=True, write_images=True, write_grads=True)

Passare il callback Tensorboard alla chiamata adatta:

history = model.fit(X_train, y_train, epochs=200, callbacks=[tb])

Quando si esegue il modello, se viene visualizzato un errore Keras di

"Devi inserire un valore per il tensore del segnaposto"

prova a reimpostare la sessione di Keras prima della creazione del modello eseguendo:

import keras.backend as K
K.clear_session()