dataframe_api.ipynb

Kernel: Python 3

Copyright 2020 The TensorFlow Authors.

#@title Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

Acceso a los datos de TensorBoard como DataFrames

Descripción general

La principal característica de TensorBoard es su interfaz gráfica de usuario interactiva. Sin embargo, los usuarios a veces quieren programáticamente leer los registros de datos almacenados en TensorBoard, con fines tales como la realización de análisis post-hoc y la creación de visualizaciones personalizadas de los datos de registro.

TensorBoard 2.3 es compatible con este caso de uso con tensorboard.data.experimental.ExperimentFromDev(). Permite el acceso programático a los registros escalares de TensorBoard. Esta página demuestra el uso básico de esta nueva API.

Nota:

1. Esta API se encuentra todavía en fase experimental, como refleja su espacio de nombres API. Esto significa que la API puede estar sujeta a cambios de última hora en el futuro.

2. Actualmente, esta característica sólo es compatible con logdirs subidos a TensorBoard.dev, un servicio gratuito alojado para persistir y compartir su TensorBoard. En el futuro se incorporará soporte para logdir de TensorBoard almacenados localmente. En pocas palabras, puede cargar un logdir TensorBoard en su sistema de archivos local a TensorBoard.dev con una sola línea de comando: tensorboard dev upload --logdir <logdir>. Consulte la documentación en tensorboard.dev para obtener más detalles.

Preparación

Para utilizar la API programática, asegúrese de instalar pandas junto a tensorboard.

Utilizaremos matplotlib y seaborn para gráficos personalizados en esta guía, pero puede elegir su herramienta preferida para analizar y visualizar DataFrame.

!pip install tensorboard pandas
!pip install matplotlib seaborn

from packaging import version

import pandas as pd
from matplotlib import pyplot as plt
import seaborn as sns
from scipy import stats
import tensorboard as tb

major_ver, minor_ver, _ = version.parse(tb.__version__).release
assert major_ver >= 2 and minor_ver >= 3, \
    "This notebook requires TensorBoard 2.3 or later."
print("TensorBoard version: ", tb.__version__)

TensorBoard version:  2.3.0a20200626

Cargando escalares TensorBoard como un pandas.DataFrame

Una vez que un logdir de TensorBoard se ha cargado en TensorBoard.dev, se convierte en lo que denominamos un experimento. Cada experimento tiene un ID único, que se puede encontrar en la URL de TensorBoard.dev del experimento. Para nuestra demostración a continuación, utilizaremos un experimento de TensorBoard.dev en: https://tensorboard.dev/experiment/c1KCv3X3QvGwaXfgX1c4tg

experiment_id = "c1KCv3X3QvGwaXfgX1c4tg"
experiment = tb.data.experimental.ExperimentFromDev(experiment_id)
df = experiment.get_scalars()
df

df es un pandas.DataFrame que contiene todos los registros escalares del experimento.

Las columnas del DataFrame son:

• run: cada ejecución corresponde a un subdirectorio del logdir original. En este experimento, cada ejecución procede de un entrenamiento completo de una red neuronal convolucional (CNN) en el conjunto de datos MNIST con un tipo de optimizador determinado (un hiperparámetro de entrenamiento). Este DataFrame contiene múltiples ejecuciones de este tipo, que corresponden a ejecuciones de entrenamiento repetidas con diferentes tipos de optimizadores.

• tag: describe lo que significa el value de la misma fila, es decir, qué métrica representa el valor en la fila. En este experimento, sólo tenemos dos etiquetas únicas: epoch_accuracy y epoch_loss para las métricas de precisión y pérdida respectivamente.

• step: es un número que refleja el orden de serie de la fila correspondiente en su recorrido. Aquí step se refiere en realidad al número de época. Si desea obtener las marcas de tiempo además de los valores step, puede utilizar el argumento de palabra clave include_wall_time=True al llamar a get_scalars().

• value: Este es el valor numérico real de interés. Como se ha descrito anteriormente, cada value en este DataFrame concreto es una pérdida o una precisión, dependiendo de la tag de la fila.

print(df["run"].unique())
print(df["tag"].unique())

['adam,run_1/train' 'adam,run_1/validation' 'adam,run_2/train'
 'adam,run_2/validation' 'adam,run_3/train' 'adam,run_3/validation'
 'adam,run_4/train' 'adam,run_4/validation' 'adam,run_5/train'
 'adam,run_5/validation' 'rmsprop,run_1/train' 'rmsprop,run_1/validation'
 'rmsprop,run_2/train' 'rmsprop,run_2/validation' 'rmsprop,run_3/train'
 'rmsprop,run_3/validation' 'rmsprop,run_4/train'
 'rmsprop,run_4/validation' 'rmsprop,run_5/train'
 'rmsprop,run_5/validation' 'sgd,run_1/train' 'sgd,run_1/validation'
 'sgd,run_2/train' 'sgd,run_2/validation' 'sgd,run_3/train'
 'sgd,run_3/validation' 'sgd,run_4/train' 'sgd,run_4/validation'
 'sgd,run_5/train' 'sgd,run_5/validation']
['epoch_accuracy' 'epoch_loss']

Obtener un DataFrame pivotado (de forma amplia)

En nuestro experimento, las dos etiquetas (epoch_loss y epoch_accuracy) están presentes en el mismo conjunto de pasos en cada ejecución. Esto nos permite obtener un DataFrame de "forma ancha" directamente de get_scalars() utilizando el argumento de la palabra clave pivot=True. La forma amplia DataFrame tiene todas sus etiquetas incluidas como columnas del DataFrame, lo que resulta más cómodo para trabajar en algunos casos, incluido el presente.

Sin embargo, tenga en cuenta que si no se cumple la condición de tener conjuntos uniformes de valores de paso en todas las etiquetas durante todas las ejecuciones, el uso de pivot=True producirá un error.

dfw = experiment.get_scalars(pivot=True) 
dfw

Tenga en cuenta que en vez de una sola columna de "valor", el DataFrame de forma amplia incluye las dos etiquetas (métricas) como sus columnas de forma explícita: epoch_accuracy y epoch_loss.

Cómo guardar el DataFrame como CSV

pandas.DataFrame tiene una buena interoperabilidad con CSV. Puede almacenarlo como un archivo CSV local y volver a cargarlo más tarde. Por ejemplo:

csv_path = '/tmp/tb_experiment_1.csv'
dfw.to_csv(csv_path, index=False)
dfw_roundtrip = pd.read_csv(csv_path)
pd.testing.assert_frame_equal(dfw_roundtrip, dfw)

Efectuar análisis estadísticos y de visualización personalizados

# Filter the DataFrame to only validation data, which is what the subsequent
# analyses and visualization will be focused on.
dfw_validation = dfw[dfw.run.str.endswith("/validation")]
# Get the optimizer value for each row of the validation DataFrame.
optimizer_validation = dfw_validation.run.apply(lambda run: run.split(",")[0])

plt.figure(figsize=(16, 6))
plt.subplot(1, 2, 1)
sns.lineplot(data=dfw_validation, x="step", y="epoch_accuracy",
             hue=optimizer_validation).set_title("accuracy")
plt.subplot(1, 2, 2)
sns.lineplot(data=dfw_validation, x="step", y="epoch_loss",
             hue=optimizer_validation).set_title("loss")

Text(0.5, 1.0, 'loss')

Los gráficos anteriores muestran las curvas temporales de la precisión de validación y de la pérdida de validación. Cada curva muestra en promedio 5 ejecuciones bajo un tipo de optimizador. Gracias a una función incorporada de seaborn.lineplot(), cada curva muestra también ±1 desviación estándar alrededor del promedio, lo que nos da una idea clara de la variabilidad de estas curvas y de la importancia de las diferencias entre los tres tipos de optimizadores. Esta visualización de la variabilidad aún no es compatible con la interfaz gráfica de usuario de TensorBoard.

Queremos estudiar la hipótesis de que la pérdida mínima de validación difiere significativamente entre los optimizadores "adam", "rmsprop" y "sgd". Así que vamos a extraer un DataFrame para la pérdida mínima de validación bajo cada uno de los optimizadores.

A continuación, realizamos un boxplot para visualizar la diferencia en las pérdidas mínimas de validación.

adam_min_val_loss = dfw_validation.loc[optimizer_validation=="adam", :].groupby(
    "run", as_index=False).agg({"epoch_loss": "min"})
rmsprop_min_val_loss = dfw_validation.loc[optimizer_validation=="rmsprop", :].groupby(
    "run", as_index=False).agg({"epoch_loss": "min"})
sgd_min_val_loss = dfw_validation.loc[optimizer_validation=="sgd", :].groupby(
    "run", as_index=False).agg({"epoch_loss": "min"})
min_val_loss = pd.concat([adam_min_val_loss, rmsprop_min_val_loss, sgd_min_val_loss])

sns.boxplot(data=min_val_loss, y="epoch_loss",
            x=min_val_loss.run.apply(lambda run: run.split(",")[0]))

<matplotlib.axes._subplots.AxesSubplot at 0x7f5e017c8150>

# Perform pairwise comparisons between the minimum validation losses
# from the three optimizers.
_, p_adam_vs_rmsprop = stats.ttest_ind(
    adam_min_val_loss["epoch_loss"],
    rmsprop_min_val_loss["epoch_loss"]) 
_, p_adam_vs_sgd = stats.ttest_ind(
    adam_min_val_loss["epoch_loss"],
    sgd_min_val_loss["epoch_loss"]) 
_, p_rmsprop_vs_sgd = stats.ttest_ind(
    rmsprop_min_val_loss["epoch_loss"],
    sgd_min_val_loss["epoch_loss"]) 
print("adam vs. rmsprop: p = %.4f" % p_adam_vs_rmsprop)
print("adam vs. sgd: p = %.4f" % p_adam_vs_sgd)
print("rmsprop vs. sgd: p = %.4f" % p_rmsprop_vs_sgd)

adam vs. rmsprop: p = 0.0244
adam vs. sgd: p = 0.9749
rmsprop vs. sgd: p = 0.0135

Por lo tanto, a un nivel de significancia de 0.05, nuestro análisis confirma nuestra hipótesis de que la pérdida mínima de validación es significativamente mayor (es decir, peor) en el optimizador rmsprop comparado con los otros dos optimizadores incluídos en nuestro experimento.

En resumen, este tutorial proporciona un ejemplo de cómo acceder a datos escalares como panda.DataFrame de TensorBoard.dev. En él se demuestra el tipo de análisis y visualización flexibles y potentes que puede realizar con los DataFrame.