Cómo crear perfiles de cargas de trabajo de TensorFlow

Para generar perfiles de un modelo de TensorFlow en Cloud TPU, usa TensorBoard y el complemento de TensorBoard de TPU. TensorBoard está preinstalado en las VMs de TPU. Para obtener información sobre cómo instalar el complemento de TPU para TensorBoard y capturar un perfil de rendimiento, consulta Perfila tu modelo con las herramientas de Cloud TPU. Para obtener información general sobre el rendimiento de Cloud TPU, consulta la guía de rendimiento de Cloud TPU.

Para obtener más información, consulta Devoluciones de llamada de TensorBoard.

Notas sobre el rendimiento de las funciones de TensorFlow

Consulta la lista completa de operaciones de TensorFlow disponibles en Cloud TPU.

tf.matmul

  • La transposición del resultado de cualquiera de los operandos es efectivamente gratuita.
  • Ten en cuenta que tf.matmul admite la fusión en su entrada y salida. Esto significa que las funciones de activación o los sesgos aplicados directamente en el resultado de tf.matmul tienen una sobrecarga baja.

tf.nn.conv_n_d, tf.nn.depthwise_conv2d, tf.nn.separable_conv2d

  • Para las activaciones, las dimensiones de lotes y de atributos se rellenan a un múltiplo de 8 o 128.
    • Primero, XLA hace un seguimiento del tamaño más común de las dimensiones de los lotes para las convoluciones en el módulo. Esto ayuda a distinguir entre convoluciones hacia delante, de gradiente de activación y de gradiente de kernel.
    • Si el tamaño más común de lote es mayor o igual que 64, se da lo siguiente:
      • El lote se rellena a un múltiplo de 128 y el atributo a uno de 8 para las convoluciones hacia delante y atrás.
      • El lote se rellena a un múltiplo de 8 y el atributo a uno de 128 para las convoluciones de actualización de gradiente.
    • Si el tamaño más común de lote es menor que 64, se da lo siguiente:
      • El lote se rellena a un múltiplo de 8 y el atributo a uno de 128 para las convoluciones hacia delante y atrás.
      • El lote se rellena a un múltiplo de 128 y el atributo a uno de 8 para las convoluciones de actualización de gradiente.
      • La transposición de las activaciones justo antes de enviarlas a la convolución es gratis si solo intercambia las dimensiones del lote y del atributo de entrada.
  • Para el kernel, las dimensiones del atributo de entrada y del resultado se rellenan a un múltiplo de 8 o 128. La determinación exacta está influenciada por los productores y otros consumidores del kernel.
    • La transposición del kernel justo antes de enviarla a la convolución es gratis si solo intercambia las dimensiones del atributo de entrada y del resultado.
  • Para el resultado, las dimensiones del lote y el atributo se rellenan a un múltiplo de 8 o 128.
    • La transposición del resultado de una convolución es gratis si solo intercambia las dimensiones del atributo de entrada y del lote.
  • Ten en cuenta que tf.nn.conv_n_d admite la fusión en su resultado, las activaciones o el kernel. Esto significa que las funciones de activación o los sesgos aplicados directamente en el resultado tienen una sobrecarga baja.

tf.nn.avg_pool, tf.nn.max_pool

  • Se aplican las reglas de relleno: las dimensiones espaciales son más importantes que el lote y el atributo. Cada lote y atributo se puede rellenar a un múltiplo de 8 o 128.
  • Por lo general, el diseño de una operación de grupo coincide con las convoluciones que entran o salen de esta.
  • El cálculo del gradiente para tf.nn.max_pool puede ser más lento que el equivalente a tf.nn.avg_pool. Considera cambiar de la agrupación máxima a la promedio cuando sea posible.

tf.concat, tf.slice, tf.strided_slice

  • Evita los segmentos y las concatenaciones innecesarias. En una dimensión que se ha rellenado, estas se consideran más costosas.
    • El movimiento de datos se minimiza si la dimensión de los segmentos no tiene sobrecarga de relleno.

tf.transpose

  • La transposición de cualquiera de los operandos de tf.matmul o su resultado es gratuita.
  • La transposición de las activaciones de un tf.conv_n_d es gratuita si se intercambian las dimensiones del lote y del atributo de resultado.
  • La transposición del kernel de un tf.conv_n_d es gratuita si se intercambian las dimensiones de los atributos de entrada y salida.
  • La transposición del resultado de un tf.conv_n_d es gratuita si se intercambian las dimensiones del lote y del atributo de resultado.

tf.batch_to_space, tf.space_to_batch, tf.space_to_depth, tf.depth_to_space

  • Estas son costosas, ya que implican mover datos de dimensiones rellenadas a otras no rellenadas, y viceversa.

tf.reshape

  • El cambio de forma podría ser costoso en Cloud TPU cuando se mueven en torno a datos en una dimensión rellenada.
  • Puede ser beneficioso cambiar la forma de los datos a R1 en el host y volver a cambiarla a una forma de dimensión mayor en el dispositivo si existe un relleno sustancial. Esto puede lograr que las transferencias entre el host y el dispositivo sean más eficientes.
    • Además, puede ayudar con la utilización máxima de la memoria, ya que el parámetro empaquetado puede desempaquetarse bajo demanda.

tf.random_uniform, tf.distributions.Bernoulli, tf.random_normal, tf.multinomial

  • La generación de números pseudo al azar para distribuciones uniformes o de Bernoulli es muy rápida.
  • Las distribuciones normales son un poco más costosas que las uniformes o de Bernoulli.
  • La generación de números pseudo al azar para distribuciones categóricas y multinominales es considerablemente más costosa.

tf.reduce_all, tf.reduce_any, tf.reduce_logsumexp, tf.reduce_max, tf.reduce_min, tf.reduce_prod, tf.reduce_sum

  • Se pueden realizar reducciones múltiples con la misma forma de entrada y resultado en paralelo mediante la fusión de operaciones.
    • Vuelve a escribir cadenas secuenciales de reducciones en otras paralelas, de ser posible.

  • Las reducciones admiten la fusión de operaciones relativas a los elementos en su entrada, pero no en sus resultados. Cuando sea posible, vuelve a escribir expresiones para promover la fusión. Por ejemplo:

        tf.multiply(tf.reduce_sum(x), y)

    En:

        tf.reduce_sum(tf.multiply(x, y))

tf.nn.batch_normalization, tf.nn.fused_batch_norm, tf.layers.batch_normalization

  • El compilador de XLA puede reducir de forma eficiente las variantes fusionadas de TensorFlow de la normalización de lotes. Su uso puede ser considerablemente más eficiente que la alternativa.

    • Es preferible tf.nn.fused_batch_norm en lugar de tf.nn.batch_normalization.
    • Para tf.layers.batch_normalization, configura el argumento "fusionado" como verdadero.