Se usó la API de Cloud Translation para traducir esta página.
Switch to English

TensorFlow Profiler: rendimiento del modelo de perfil

Ver en TensorFlow.org Ejecutar en Google Colab Ver fuente en GitHub

Visión general

Los algoritmos de aprendizaje automático suelen ser computacionalmente costosos. Por lo tanto, es vital cuantificar el rendimiento de su aplicación de aprendizaje automático para asegurarse de que está ejecutando la versión más optimizada de su modelo. Usa TensorFlow Profiler para perfilar la ejecución de tu código de TensorFlow.

Preparar

from datetime import datetime
from packaging import version

import os

TensorFlow Profiler requiere las últimas versiones de TensorFlow y TensorBoard ( >=2.2 ).

pip install -U tensorboard_plugin_profile
import tensorflow as tf

print("TensorFlow version: ", tf.__version__)
TensorFlow version:  2.2.0-dev20200405

Confirma que TensorFlow pueda acceder a la GPU.

device_name = tf.test.gpu_device_name()
if not device_name:
  raise SystemError('GPU device not found')
print('Found GPU at: {}'.format(device_name))
Found GPU at: /device:GPU:0

Entrena un modelo de clasificación de imágenes con devoluciones de llamada de TensorBoard

En este instructivo, explorarás las capacidades de TensorFlow Profiler al capturar el perfil de rendimiento obtenido al entrenar un modelo para clasificar imágenes en el conjunto de datos MNIST .

Usa los conjuntos de datos de TensorFlow para importar los datos de entrenamiento y dividirlos en conjuntos de entrenamiento y prueba.

import tensorflow_datasets as tfds
tfds.disable_progress_bar()
(ds_train, ds_test), ds_info = tfds.load(
    'mnist',
    split=['train', 'test'],
    shuffle_files=True,
    as_supervised=True,
    with_info=True,
)
WARNING:absl:Dataset mnist is hosted on GCS. It will automatically be downloaded to your
local data directory. If you'd instead prefer to read directly from our public
GCS bucket (recommended if you're running on GCP), you can instead set
data_dir=gs://tfds-data/datasets.


Downloading and preparing dataset mnist/3.0.0 (download: 11.06 MiB, generated: Unknown size, total: 11.06 MiB) to /root/tensorflow_datasets/mnist/3.0.0...
Dataset mnist downloaded and prepared to /root/tensorflow_datasets/mnist/3.0.0. Subsequent calls will reuse this data.

Procese previamente los datos de entrenamiento y prueba normalizando los valores de los píxeles para que estén entre 0 y 1.

def normalize_img(image, label):
  """Normalizes images: `uint8` -> `float32`."""
  return tf.cast(image, tf.float32) / 255., label

ds_train = ds_train.map(normalize_img)
ds_train = ds_train.batch(128)
ds_test = ds_test.map(normalize_img)
ds_test = ds_test.batch(128)

Cree el modelo de clasificación de imágenes usando Keras.

model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(input_shape=(28, 28, 1)),
  tf.keras.layers.Dense(128,activation='relu'),
  tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(
    loss='sparse_categorical_crossentropy',
    optimizer=tf.keras.optimizers.Adam(0.001),
    metrics=['accuracy']
)

Cree una devolución de llamada de TensorBoard para capturar perfiles de rendimiento y llámelo mientras entrena el modelo.

# Create a TensorBoard callback
logs = "logs/" + datetime.now().strftime("%Y%m%d-%H%M%S")

tboard_callback = tf.keras.callbacks.TensorBoard(log_dir = logs,
                                                 histogram_freq = 1,
                                                 profile_batch = '500,520')

model.fit(ds_train,
          epochs=2,
          validation_data=ds_test,
          callbacks = [tboard_callback])
Epoch 1/2
469/469 [==============================] - 11s 22ms/step - loss: 0.3684 - accuracy: 0.8981 - val_loss: 0.1971 - val_accuracy: 0.9436
Epoch 2/2
 50/469 [==>...........................] - ETA: 9s - loss: 0.2014 - accuracy: 0.9439WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/summary_ops_v2.py:1271: stop (from tensorflow.python.eager.profiler) is deprecated and will be removed after 2020-07-01.
Instructions for updating:
use `tf.profiler.experimental.stop` instead.

Warning:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/summary_ops_v2.py:1271: stop (from tensorflow.python.eager.profiler) is deprecated and will be removed after 2020-07-01.
Instructions for updating:
use `tf.profiler.experimental.stop` instead.

469/469 [==============================] - 11s 24ms/step - loss: 0.1685 - accuracy: 0.9525 - val_loss: 0.1376 - val_accuracy: 0.9595

<tensorflow.python.keras.callbacks.History at 0x7f23919a6a58>

Usa TensorFlow Profiler para perfilar el rendimiento del entrenamiento del modelo

TensorFlow Profiler está integrado en TensorBoard. Cargue TensorBoard usando Colab Magic y ejecútelo. Vea los perfiles de rendimiento navegando a la pestaña Perfil .

# Load the TensorBoard notebook extension.
%load_ext tensorboard

El perfil de rendimiento de este modelo es similar al de la siguiente imagen.

# Launch TensorBoard and navigate to the Profile tab to view performance profile
%tensorboard --logdir=logs
<IPython.core.display.Javascript object>

La pestaña Perfil abre la página Descripción general que muestra un resumen de alto nivel del rendimiento de su modelo. Si observa el gráfico de tiempo de paso a la derecha, puede ver que el modelo está muy ligado a la entrada (es decir, pasa mucho tiempo en la línea de entrada de datos). La página Descripción general también le brinda recomendaciones sobre los próximos pasos potenciales que puede seguir para optimizar el rendimiento de su modelo.

Para comprender dónde se produce el cuello de botella en el rendimiento en la canalización de entrada, seleccione el Visor de seguimiento en el menú desplegable Herramientas de la izquierda. El Visor de seguimiento le muestra una línea de tiempo de los diferentes eventos que ocurrieron en la CPU y la GPU durante el período de creación de perfiles.

Trace Viewer muestra varios grupos de eventos en el eje vertical. Cada grupo de eventos tiene múltiples pistas horizontales, llenas de eventos de seguimiento. La pista es una línea de tiempo de eventos para eventos ejecutados en un hilo o una secuencia de GPU. Los eventos individuales son los bloques rectangulares de colores en las pistas de la línea de tiempo. El tiempo se mueve de izquierda a derecha. Navegue por los eventos de seguimiento utilizando los atajos de teclado W (acercar), S (alejar), A (desplazarse hacia la izquierda) y D (desplazarse hacia la derecha).

Un solo rectángulo representa un evento de seguimiento. Seleccione el icono del cursor del mouse en la barra de herramientas flotante (o use el método abreviado de teclado 1 ) y haga clic en el evento de seguimiento para analizarlo. Esto mostrará información sobre el evento, como su hora de inicio y duración.

Además de hacer clic, puede arrastrar el mouse para seleccionar un grupo de eventos de seguimiento. Esto le dará una lista de todos los eventos en esa área junto con un resumen del evento. Utilice la tecla M para medir la duración de los eventos seleccionados.

Los eventos de seguimiento se recopilan de:

  • CPU: los eventos de la CPU se muestran en un grupo de eventos llamado /host:CPU . Cada pista representa un hilo en la CPU. Los eventos de CPU incluyen eventos de canalización de entrada, eventos de programación de operaciones (op) de GPU, eventos de ejecución de operaciones de CPU, etc.
  • GPU: los eventos de GPU se muestran en grupos de eventos con el prefijo /device:GPU: Cada grupo de eventos representa una secuencia en la GPU.

Depurar los cuellos de botella del rendimiento

Utilice Trace Viewer para localizar los cuellos de botella de rendimiento en su canal de entrada. La siguiente imagen es una instantánea del perfil de rendimiento.

profiler_trace_viewer_bad_ip

Al observar los seguimientos de eventos, puede ver que la GPU está inactiva mientras la tf_data_iterator_get_next se ejecuta en la CPU. Esta operación es responsable de procesar los datos de entrada y enviarlos a la GPU para su entrenamiento. Como regla general, es una buena idea mantener siempre activo el dispositivo (GPU / TPU).

Utilice la API tf.data para optimizar la canalización de entrada. En este caso, vamos a almacenar en caché el conjunto de datos de entrenamiento y obtener los datos previamente para garantizar que siempre haya datos disponibles para que la GPU los procese. Consulte aquí para obtener más detalles sobre el uso de tf.data para optimizar sus canalizaciones de entrada.

(ds_train, ds_test), ds_info = tfds.load(
    'mnist',
    split=['train', 'test'],
    shuffle_files=True,
    as_supervised=True,
    with_info=True,
)
ds_train = ds_train.map(normalize_img)
ds_train = ds_train.batch(128)
ds_train = ds_train.cache()
ds_train = ds_train.prefetch(tf.data.experimental.AUTOTUNE)
ds_test = ds_test.map(normalize_img)
ds_test = ds_test.batch(128)
ds_test = ds_test.cache()
ds_test = ds_test.prefetch(tf.data.experimental.AUTOTUNE)

Entrene el modelo nuevamente y capture el perfil de rendimiento reutilizando la devolución de llamada de antes.

model.fit(ds_train,
          epochs=2,
          validation_data=ds_test,
          callbacks = [tboard_callback])
Epoch 1/2
469/469 [==============================] - 10s 22ms/step - loss: 0.1194 - accuracy: 0.9658 - val_loss: 0.1116 - val_accuracy: 0.9680
Epoch 2/2
469/469 [==============================] - 1s 3ms/step - loss: 0.0918 - accuracy: 0.9740 - val_loss: 0.0979 - val_accuracy: 0.9712

<tensorflow.python.keras.callbacks.History at 0x7f23908762b0>

Vuelva a iniciar TensorBoard y abra la pestaña Perfil para observar el perfil de rendimiento de la canalización de entrada actualizada.

El perfil de rendimiento del modelo con la canalización de entrada optimizada es similar a la imagen siguiente.

%tensorboard --logdir=logs
Reusing TensorBoard on port 6006 (pid 750), started 0:00:12 ago. (Use '!kill 750' to kill it.)
<IPython.core.display.Javascript object>

En la página Descripción general, puede ver que el tiempo de paso promedio se ha reducido al igual que el tiempo de paso de entrada. El gráfico paso a paso también indica que el modelo ya no está muy ligado a los insumos. Abra el Visor de seguimiento para examinar los eventos de seguimiento con la canalización de entrada optimizada.

profiler_trace_viewer_good_ip

Trace Viewer muestra que la tf_data_iterator_get_next ejecuta mucho más rápido. Por lo tanto, la GPU obtiene un flujo constante de datos para realizar el entrenamiento y logra una utilización mucho mejor a través del entrenamiento de modelos.

Resumen

Usa TensorFlow Profiler para perfilar y depurar el rendimiento del entrenamiento del modelo. Lea la guía de Profiler y vea el perfil de rendimiento en la charla TF 2 de TensorFlow Dev Summit 2020 para obtener más información sobre TensorFlow Profiler.