Criar perfil das cargas de trabalho do TensorFlow

Para criar o perfil de um modelo do TensorFlow em Cloud TPUs, use o TensorBoard e o plug-in do TensorBoard da TPU. O TensorBoard é pré-instalado nas VMs da TPU. Para informações sobre como instalar o plug-in do TensorBoard da TPU e capturar um perfil de desempenho, consulte Criar perfil para seu modelo com as ferramentas do Cloud TPU. Para informações gerais sobre o desempenho do Cloud TPU, consulte o guia de desempenho do Cloud TPU.

Para mais informações, consulte Callbacks do TensorBoard.

Observações sobre o desempenho das funções do TensorFlow

Veja a lista completa de operações do TensorFlow disponíveis no Cloud TPU.

tf.matmul

  • A transposição do resultado de qualquer um dos operandos é efetivamente gratuita.
  • Observe que tf.matmul suporta a fusão em sua entrada e saída. Isso significa que as funções de ativação ou as tendências aplicadas diretamente à saída de tf.matmul têm baixa sobrecarga.

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

  • Para as ativações, as dimensões de lote e de característica são preenchidas por um múltiplo de 8 ou 128.
    • Primeiro, o XLA rastreia o tamanho mais comum entre as dimensões de lote para convoluções no módulo. Isso ajuda a distinguir entre convoluções progressivas, convoluções de gradiente de ativação e convoluções de gradiente do kernel.
    • Se o tamanho de lote mais comum for maior ou igual a 64:
      • o lote é preenchido com um múltiplo de 128 e a característica é preenchida com um múltiplo de 8 para convoluções progressivas e regressivas;
      • o lote é preenchido com um múltiplo de 8 e a característica é preenchida com um múltiplo de 128 para as convoluções de atualização de gradiente.
    • Se o tamanho de lote mais comum for menor que 64:
      • o lote é preenchido com um múltiplo de 8 e a característica é preenchida com um múltiplo de 128 para convoluções progressivas e regressivas;
      • o lote é preenchido com um múltiplo de 128 e a característica é preenchida com um múltiplo de 8 para as convoluções de atualização de gradiente;
      • a transposição das ativações antes de enviá-las para uma convolução será gratuita se ela apenas alternar as dimensões de característica de entrada e de lote.
  • No caso do kernel, as dimensões de características de entrada e saída são preenchidas com um múltiplo de 8 ou 128. A determinação exata é influenciada pelos produtores e outros consumidores do kernel.
    • A transposição de um kernel antes de enviá-lo para uma convolução será gratuita se ela apenas alternar as dimensões de características de entrada e saída.
  • No caso do resultado, as dimensões de lote e de característica são preenchidas com um múltiplo de 8 ou 128.
    • A transposição do resultado de uma convolução será gratuita se ela apenas alternar as dimensões de lote e de característica de saída.
  • Observe que tf.nn.conv_n_d aceita a fusão em seu resultado, nas ativações e/ou no kernel. Isso significa que as funções de ativação ou as tendências aplicadas diretamente à saída têm baixa sobrecarga.

tf.nn.avg_pool, tf.nn.max_pool

  • As regras de preenchimento serão aplicadas se as dimensões espaciais forem maiores do que o lote e a característica. Cada combinação de lote e característica pode ser preenchida com um múltiplo de 8 ou 128.
  • Normalmente, o layout de uma operação de pool corresponde às convoluções que entram ou saem dele.
  • O cálculo do gradiente para tf.nn.max_pool pode ser mais lento que seu equivalente tf.nn.avg_pool. Considere a possibilidade de mudar do pooling máximo para o médio sempre que possível.

tf.concat, tf.slice, tf.strided_slice

  • Evite frações e concatenações desnecessários. Frações e concatenações em uma dimensão que foi preenchida são consideravelmente mais custosas.
    • A movimentação de dados será minimizada se a dimensão da fração não tiver sobrecarga de preenchimento.

tf.transpose

  • A transposição de qualquer um dos operandos de tf.matmul ou do respectivo resultado é gratuita.
  • Transpor as ativações de um tf.conv_n_d é gratuito se ele trocar as dimensões do recurso de lote e entrada.
  • A transposição do kernel de um tf.conv_n_d é gratuita se alternar as dimensões do recurso de entrada e saída.
  • Transpor o resultado de um tf.conv_n_d é gratuito se ele trocar as dimensões do recurso de lote e de saída.

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

  • Essas funções são dispendiosas porque envolvem a movimentação de dados de dimensões preenchidas para não preenchidas e vice-versa.

tf.reshape

  • Quando dados são movimentados em uma dimensão preenchida, a reconfiguração da forma pode ser dispendiosa no Cloud TPU.
  • Talvez seja útil reconfigurar a forma dos dados para R1 no host e, depois, reconfigurar de volta para uma forma de dimensão mais elevada no dispositivo, se o preenchimento for substancial. Isso pode aumentar a eficiência das transferências entre o host e o dispositivo.
    • Essa ação também pode ajudar durante os picos de utilização de memória, porque o parâmetro compactado pode ser descompactado sob demanda.

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

  • A geração de números pseudoaleatórios para distribuições uniformes ou de Bernoulli é muito rápida.
  • As distribuições normais são um pouco mais dispendiosas do que as distribuições uniformes ou de Bernoulli.
  • A geração de números pseudoaleatórios para distribuições categóricas e multinomiais é consideravelmente mais cara.

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

  • É possível realizar várias reduções com a mesma forma de entrada e saída em paralelo usando a fusão de operações.
    • Se possível, reescreva as cadeias sequenciais das reduções em cadeias paralelas.

  • As reduções são compatíveis com a fusão de operações elemento a elemento nas entradas, mas não nas saídas. Quando possível, reescreva expressões para promover a fusão. Exemplo:

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

    em:

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

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

  • O compilador XLA pode reduzir com eficiência as variantes fundidas do TensorFlow na normalização em lote. Usá-las pode ser consideravelmente mais eficiente do que a alternativa.

    • Prefira tf.nn.fused_batch_norm a tf.nn.batch_normalization.
    • Em tf.layers.batch_normalization, defina o argumento "fused" como "true".