Profila i carichi di lavoro TensorFlow

Per eseguire il profiling di un modello TensorFlow su Cloud TPU, utilizza TensorBoard e il plug-in TPU TensorBoard. TensorBoard è preinstallato nelle VM TPU. Per informazioni su come installare il plug-in TPU TensorBoard e acquisire un profilo delle prestazioni, consulta Profilare il modello con gli strumenti Cloud TPU. Per informazioni generali sul rendimento di Cloud TPU, consulta la guida al rendimento di Cloud TPU.

Per saperne di più, consulta Callback di TensorBoard.

Note sul rendimento delle funzioni TensorFlow

Consulta l'elenco completo delle operazioni TensorFlow disponibili su Cloud TPU.

tf.matmul

  • La trasposizione del risultato di uno degli operandi è praticamente gratuita.
  • Tieni presente che tf.matmul supporta l'unione in input e in output. Ciò significa che le funzioni di attivazione o i bias applicati direttamente all'output di tf.matmul hanno un overhead ridotto.

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

  • Per le attivazioni, le dimensioni del batch e delle funzionalità vengono riempite fino a un moltiplo di 8 o 128.
    • La prima XLA monitora le dimensioni batch più comuni per le convolute nel modulo. In questo modo è possibile distinguere tra convolute forward, convolute con gradiente di attivazione e convolute con gradiente del kernel.
    • Se la dimensione del batch più comune è maggiore o uguale a 64:
      • Il batch viene riempito fino a un multiplo di 128 e le funzionalità vengono riempite fino a un multiple di 8 per le convoluzioni in avanti e indietro.
      • Il batch è riempito fino a un multiplo di 8 e la caratteristica è riempito a un multiplo di 128 per le convoluzioni di aggiornamento del gradiente.
    • Se la dimensione del batch più comune è inferiore a 64:
      • Il batch viene riempito fino a un multiplo di 8 e le funzionalità vengono riempite fino a un multiplo di 128 per le convolute in avanti e all'indietro.
      • Il Batch è riempito fino a un multiplo di 128 e la caratteristica è imbottito in un multipli di 8 per le convoluzioni di aggiornamento del gradiente.
      • La trasposizione delle attivazioni appena prima dell'invio a una convoluzione è gratuita se la trasposizione scambia solo le dimensioni della funzionalità di input e del batch.
  • Per il kernel, le dimensioni delle caratteristiche di input e di output vengono riempite fino a un multiplo di 8 o 128. La determinazione esatta è influenzata dai produttori e da altri consumatori del kernel.
    • La trasposizione di un kernel subito prima di inviarlo a una convezione è gratuita se la trasposizione scambia solo le dimensioni delle funzionalità di input e output.
  • Per il risultato, le dimensioni del batch e degli elementi vengono riempite fino a un multiplo di 8 o 128.
    • La trasposizione del risultato di una convezione è gratuita se la trasposizione scambia solo le dimensioni delle funzionalità di batch e di output.
  • Tieni presente che tf.nn.conv_n_d supporta l'unione nel risultato, nelle attivazioni e/o nel kernel. Ciò significa che le funzioni di attivazione o i bias applicati direttamente all'output hanno un overhead ridotto.

tf.nn.avg_pool, tf.nn.max_pool

  • Vengono applicate le regole di spaziatura: le dimensioni spaziali sono più importanti di batch e funzionalità. Ogni batch e ogni elemento possono essere riempiti fino a un multiplo di 8 o 128.
  • In genere, il layout di un'operazione di pool corrisponde alle convolute che vi confluiscono o da cui escono.
  • Il calcolo del gradiente per tf.nn.max_pool potrebbe essere più lento rispetto all'equivalente tf.nn.avg_pool. Valuta la possibilità di passare dalla somma massima alla media, se possibile.

tf.concat, tf.slice, tf.strided_slice

  • Evita slice e concatenazioni non necessarie. Le sezioni e le concatenazioni in una dimensione con spaziatura interna sono notevolmente più costose.
    • Lo spostamento dei dati viene ridotto al minimo se la dimensione del segmento di traffico non ha un overhead di riempimento.

tf.transpose

  • La trasposizione di uno degli operandi di un tf.matmul o del suo risultato è gratuita.
  • La trasposizione delle attivazioni di un tf.conv_n_d è gratuita se scambia le dimensioni del batch e delle funzionalità di input.
  • La trasposizione del kernel di un tf.conv_n_d è gratuita se scambia le dimensioni delle funzionalità di input e di output.
  • La trasposizione del risultato di un tf.conv_n_d è gratuita se scambia le dimensioni del batch e della funzionalità di output.

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

  • Questi sono costosi perché richiedono lo spostamento dei dati dalle dimensioni con spaziatura interna a quelle senza spaziatura interna e viceversa.

tf.reshape

  • La trasformazione potrebbe essere costosa su Cloud TPU quando si spostano i dati in una dimensione con spaziatura interna.
  • Può essere utile ricreare la forma dei dati in R1 sull'host e poi riformularli nuovamente in una forma di dimensione superiore sul dispositivo se è presente un padding sostanziale. In questo modo, i trasferimenti tra host e dispositivo possono essere più efficienti.
    • Può essere utile anche per l'utilizzo della memoria di picco perché il parametro imballato può essere simballato on demand.

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

  • La generazione di numeri pseudo casuali per distribuzioni uniformi o di Bernoulli è molto rapida.
  • Le distribuzioni normali sono leggermente più costose rispetto alle distribuzioni uniformi o di Bernoulli.
  • La generazione di numeri pseudo casuali per le distribuzioni categoriche e multinomiali è notevolmente più costosa.

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

  • È possibile eseguire più riduzioni con la stessa forma di input e output in parallelo utilizzando la fusione delle operazioni.
    • Se possibile, prova a riscrivere le catene sequenziali di riduzioni in catene parallele.

  • Le riduzioni supportano l'unione di operazioni elementari nell'input, ma non nell'output. Se possibile, riscrivi le espressioni per favorire la fusione. Ad esempio:

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

    In:

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

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

  • Il compilatore XLA può ridurre in modo efficiente le varianti fuse di TensorFlow della normalizzazione batch. Il loro utilizzo può essere notevolmente più efficiente rispetto all'alternativa.

    • Preferisco tf.nn.fused_batch_norm a tf.nn.batch_normalization.
    • Per tf.layers.batch_normalization, imposta l'argomento "fused" su true.