Uso de TensorBoard para la visualización

TensorBoard es un conjunto de herramientas de visualización que facilita la comprensión y depuración de programas de aprendizaje profundo. Por ejemplo, permite ver el gráfico del modelo, trazar varios valores escalares a medida que avanza el entrenamiento y visualizar las incrustaciones.

Python

La clase TensorBoardProgressWriter en Python ahora admite la salida en el formato nativo de TensorBoard, lo que permite funcionalidades de visualización enriquecidas para CNTK trabajos. En la actualidad, TensorBoardProgressWriter se puede usar para:

• Gráfico de modelos de registro.
• Registre valores escalares arbitrarios durante el entrenamiento.
• Registra automáticamente los valores de una función de pérdida y tasa de errores durante el entrenamiento.
• Mostrar imágenes (desde la versión 2.2)

En primer lugar, debe crear una instancia de una clase TensorBoardProgressWriter proporcionando algunos de los argumentos siguientes:

• freq : la frecuencia con la que se registra en los archivos de salida. Por ejemplo, el valor de 2 hará que cada segunda llamada al método de actualización escriba en el disco.
• log_dir : directorio donde se crearán los archivos de salida.
• rank : en el caso del entrenamiento distribuido, debe establecerse en un rango de un trabajador. Si se establece, TensorBoardProgressWriter se asegura de que solo se registra el progreso del trabajo 0.
• model: un modelo de CNTK que se va a visualizar.

Por ejemplo, la línea siguiente crea una instancia de TensorBoardProgressWriter que creará archivos en el directorio "log" y escribirá en el disco en cada 10ª llamada. También conservará el gráfico del my_model para su visualización más adelante.

tensorboard_writer = TensorBoardProgressWriter(freq=10, log_dir=’log’, model=my_model)

A continuación, debe proporcionar el objeto anterior a Trainer tras la construcción:

trainer = Trainer(my_model, (ce, pe), learner, tensorboard_writer)

El objeto Trainer se asegurará de actualizar TensorBoardProgressWriter con los valores de la métrica de pérdida/evaluación después del entrenamiento o las pruebas en cada minibatch. Por lo tanto, no es necesario llamar explícitamente a TensorBoardProgressWriter para registrar estos valores. Para registrar cualquier otro valor escalar, puede usar write_value(), por ejemplo:

    # Log mean of each parameter tensor, to confirm that the parameters change indeed.
    # Don't want to do that very often though, not to spend too much time computing the mean.
    if minibatch_idx % 10000 == 0:
        for p in my_model.parameters:
            tensorboard_writer.write_value(p.uid + "/mean",  reduce_mean(p).eval(), minibatch_idx)

Desde CNTK 2.2, puede usar la característica de imagen tensorBoard para CNTK. Para mostrar imágenes, debe llamar al método TensorBoardProgressWriter.write_image(). A continuación se muestra un ejemplo, se usa TensorBoard para mostrar imágenes del conjunto de datos MNIST.

En primer lugar, se leen imágenes del conjunto de datos MNIST y se alimentan como parte de la entrada del modelo.

    # Input variables denoting the features and label data
    input_var = C.ops.input_variable((num_channels, image_height, image_width), np.float32)
    label_var = C.ops.input_variable(num_output_classes, np.float32)

    # Create a model
    with C.layers.default_options(activation=C.ops.relu, pad=False):
        conv1 = C.layers.Convolution2D((5, 5), 32, pad=True)(scaled_input)
       ...

    #load image data as model input
    reader_train = create_reader(os.path.join(data_path, 'minist_data_set_file'), True, input_dim,
                                 num_output_classes)
    input_map = {
        input_var: reader_train.streams.features,
        label_var: reader_train.streams.labels
    }

Para serializar la imagen en tensorboard, debe capturar la variable de imagen durante el entrenamiento y, a continuación, llamar a TensorBoardProgressWriter.write_image() para mostrarla. Puede capturar cualquier variable intermedia como imágenes, en el ejemplo siguiente, el input_var tiene las imágenes que queremos serializar.

    for epoch in range(max_epochs): 
        sample_count = 0
        while sample_count < epoch_size:  
	    #train the model using input data
            data = reader_train.next_minibatch(min(minibatch_size, epoch_size - sample_count),
                                               input_map=input_map)
	    #Store input data in the output  
            output = trainer.train_minibatch(data, outputs=[input_var])  

	    #Write output images to tensorboard
	    tensorboard_writer.write_image('training', output[1], sample_count)

TensorBoard no forma parte del paquete de CNTK y debe instalarse por separado. Después de la instalación, una vez iniciado el trabajo de entrenamiento, puede iniciar TensorBoard para supervisar su progreso ejecutando el siguiente comando:

    tensorboard --logdir=log

(suponiendo que el comando se ejecuta desde el directorio de trabajo del script) y vaya a http://localhost:6006/ en su explorador web favorito.

Los siguientes scripts contienen ejemplos sobre cómo usar TensorBoardProgressWriter:

Examples/Image/Classification/MLP/Python/SimpleMNIST.py
Examples/Image/Classification/ResNet/Python/TrainResNet_CIFAR10.py
Examples/Image/Classification/ConvNet/Python/ConvNet_CIFAR10_DataAug_Distributed.py
Examples/LanguageUnderstanding/ATIS/Python/LanguageUnderstanding.py

BrainScript

También puede indicar a CNTK que registren el progreso del entrenamiento y el gráfico del modelo desde BrainScript. Los dos valores siguientes en la salida de TensorBoard del control de bloques SGD:

• tensorBoardLogDir : directorio donde se deben crear los archivos de eventos de TensorBoard. De forma predeterminada, este valor está vacío, lo que significa que no hay ninguna salida de TensorBoard.
• tensorBoardNumMBsToLogResult : la frecuencia con la que la métrica de pérdida/evaluación intermedia (por minibatch) se registra en TensorBoard. Esta configuración solo se usa cuando tensorBoardLogDir no estaba vacío. De forma predeterminada, usa el mismo valor que numMBsToShowResult. Si se establece en 0, no se genera ninguna salida intermedia, solo estadísticas por época. Si se establece en un entero N positivo, se obtiene la salida de progreso de TensorBoard para cada minibatches N.

Normalmente, pasará esta configuración al iniciar CNTK desde la línea de comandos:

    CNTK.exe configFile=myConfig tensorBoardLogDir=log tensorBoardNumMBsToLogResult=10