¿Cómo uso la devolución de llamada de Tensorboard de Keras?

He construido una red neuronal con Keras. Visualizaría sus datos por Tensorboard, por lo tanto, he utilizado:

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

como se explica en keras.io . Cuando ejecuto la devolución de llamada obtengo <keras.callbacks.TensorBoard at 0x7f9abb3898>, pero no obtengo ningún archivo en mi carpeta "Graph". ¿Hay algo mal en cómo he usado esta devolución de llamada?

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

Esta línea crea un objeto de Tensorboard de devolución de llamada, debe capturar ese objeto y asignarlo a la fitfunción de su modelo.

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

De esta manera le dio su objeto de devolución de llamada a la función. Se ejecutará durante el entrenamiento y generará archivos que se pueden usar con el tensorboard.

Si desea visualizar los archivos creados durante el entrenamiento, ejecute en su terminal

tensorboard --logdir path_to_current_dir/Graph 

Espero que esto ayude !

Así es como se usa la devolución de llamada 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])

Cambio

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

a

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

y configura tu modelo

tbCallback.set_model(model)

Corre en tu terminal

tensorboard  --logdir Graph/

Si está trabajando con la biblioteca Keras y desea utilizar el tensorboard para imprimir sus gráficos de precisión y otras variables, a continuación se detallan los pasos a seguir.

Paso 1: Inicialice la biblioteca de devolución de llamada de Keras para importar el tensorboard mediante el siguiente comando

from keras.callbacks import TensorBoard

Paso 2: incluye el siguiente comando en tu programa justo antes del comando "model.fit ()".

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

Nota: Use "./graph". Generará la carpeta de gráficos en su directorio de trabajo actual, evite usar "/ graph".

Paso 3: Incluir la devolución de llamada de Tensorboard en "model.fit ()". El ejemplo se muestra a continuación.

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

Paso 4: Ejecute su código y verifique si su carpeta de gráficos está allí en su directorio de trabajo. si los códigos anteriores funcionan correctamente, tendrá la carpeta "Graph" en su directorio de trabajo.

Paso 5: Abra la Terminal en su directorio de trabajo y escriba el comando a continuación.

tensorboard --logdir ./Graph

Paso 6: Ahora abre tu navegador web e ingresa la dirección a continuación.

http://localhost:6006

Después de ingresar, se abrirá la página Tensorbaord donde podrá ver sus gráficos de diferentes variables.

Aquí hay un código:

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)

Básicamente, histogram_freq=2es el parámetro más importante para sintonizar al llamar a esta devolución de llamada: establece un intervalo de épocas para llamar a la devolución de llamada, con el objetivo de generar menos archivos en los discos.

Así que aquí hay un ejemplo de visualización de la evolución de los valores para la última convolución durante el entrenamiento, una vez visto en TensorBoard, debajo de la pestaña "histogramas" (y encontré que la pestaña "distribuciones" contiene gráficos muy similares, pero volteados al costado):

En caso de que desee ver un ejemplo completo en contexto, puede consultar este proyecto de código abierto: https://github.com/Vooban/Hyperopt-Keras-CNN-CIFAR-100

Si está utilizando google-colab, la visualización simple del gráfico sería:

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

Escribiste log_dir='/Graph', ¿querías decir en su ./Graphlugar? Lo enviaste /home/user/Graphen este momento.

Debe consultar Losswise ( https://losswise.com ), tiene un complemento para Keras que es más fácil de usar que Tensorboard y tiene algunas características adicionales agradables. Con Losswise solo usarías from losswise.libs import LosswiseKerasCallbacky luego callback = LosswiseKerasCallback(tag='my fancy convnet 1')estarás listo (ver https://docs.losswise.com/#keras-plugin ).

Hay pocas cosas

Primero no /Graphpero./Graph

En segundo lugar, cuando usa la devolución de llamada TensorBoard, siempre pase los datos de validación, porque sin ella, no comenzaría.

En tercer lugar, si desea usar cualquier cosa excepto resúmenes escalares, entonces solo debe usar el fitmétodo porque fit_generatorno funcionará. O puede reescribir la devolución de llamada para trabajar fit_generator.

Para agregar devoluciones de llamada, solo agréguela a model.fit(..., callbacks=your_list_of_callbacks)

Cree la devolución de llamada de 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)

Pase la devolución de llamada de Tensorboard a la llamada de ajuste:

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

Al ejecutar el modelo, si obtiene un error de Keras de

"Debe alimentar un valor para el tensor de marcador de posición"

intente restablecer la sesión de Keras antes de la creación del modelo haciendo:

import keras.backend as K
K.clear_session()