Profila i carichi di lavoro TensorFlow

Per profilare un modello TensorFlow sulle Cloud TPU, utilizza TensorBoard e il plug-in TPU TensorBoard. TensorBoard è preinstallato sulle VM TPU. Per informazioni su come installare il plug-in TensorBoard TPU e acquisire un profilo delle prestazioni, consulta Profilo del modello con gli strumenti di Cloud TPU. Per informazioni generali sulle prestazioni di Cloud TPU, consulta la guida alle prestazioni di Cloud TPU.

Per ulteriori informazioni, consulta la sezione Callback di TensorBoard.

Note sulle prestazioni della funzione TensorFlow

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

tf.matmul

  • Il trasposizione del risultato di uno degli operandi è effettivamente gratuito.
  • Tieni presente che tf.matmul supporta l'integrazione nei suoi input e nei suoi 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 in un multiplo di 8 o 128.
    • First XLA monitora le dimensioni più comuni delle dimensioni batch per le convoluzioni nel modulo. Ciò consente di distinguere tra convoluzioni in avanti, convoluzioni dei gradienti di attivazione e convoluzioni dei gradienti del kernel.
    • Se la dimensione del batch più comune è maggiore o uguale a 64:
      • Batch è imbottito a un multiplo di 128 e la funzionalità a un multiplo di 8 è per convoluzioni avanti e indietro.
      • Il batch viene riempito fino a un multiplo di 8 e le caratteristiche corrispondono a un multiplo di 128 per le convoluzioni di aggiornamento del gradiente.
    • Se la dimensione del batch più comune è inferiore a 64:
      • Batch è imbottito a un multiplo di 8 e la caratteristica è a un multiplo di 128 per le convoluzioni avanti e indietro.
      • Batch viene riempito fino a un multiplo di 128 e le caratteristiche in un multiplo di 8 per le convoluzioni di aggiornamento del gradiente.
      • La trasposizione delle attivazioni immediatamente prima di inviarla in una convoluzione è gratuita se la trasposizione scambia solo la funzionalità di input e le dimensioni batch.
  • Per il kernel, le dimensioni delle funzionalità di input e di output vengono aggiunte a un multiplo di 8 o 128. La determinazione esatta è influenzata dai producer e dagli altri consumatori del kernel.
    • La trasposizione di un kernel immediatamente prima di inviarlo a una convoluzione è gratuita se la trasposizione scambia solo le dimensioni delle caratteristiche di input e output.
  • Per il risultato, le dimensioni del batch e delle caratteristiche vengono riempite a multiplo di 8 o 128.
    • La trasposizione del risultato di una convoluzione è gratuita se la trasposizione cambia solo le dimensioni delle funzionalità batch e di output.
  • Tieni presente che tf.nn.conv_n_d supporta l'integrazione nel risultato, le attivazioni e/o il 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

  • Si applicano le regole di spaziatura interna: le dimensioni spaziali sono più importanti delle funzionalità batch e delle funzionalità. Ogni batch e funzionalità può essere riempito con un multiplo di 8 o 128.
  • In genere, il layout di un'operazione di pool corrisponde alle convoluzioni che fluiscono dentro o fuori il pool.
  • Il calcolo del gradiente per tf.nn.max_pool potrebbe essere più lento rispetto all'equivalente tf.nn.avg_pool. Se possibile, valuta di passare dal pooling massimo al pooling medio.

tf.concat, tf.slice, tf.strided_slice

  • Evita sezioni e concatenazioni inutili. Le sezioni e le concatenazioni in una dimensione imbottita sono molto più costose.
    • Lo spostamento dei dati viene ridotto al minimo se la dimensione della sezione non ha un overhead di spaziatura interna.

tf.transpose

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

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

  • Sono costosi perché comportano lo spostamento dei dati da dimensioni non riempite a quelle non imbottite e viceversa.

tf.reshape

  • La rimodellazione può essere costosa su Cloud TPU quando si spostano i dati in una dimensione con spaziatura interna.
  • Può essere utile rimodellare i dati in R1 sull'host e rimodellarli in modo da avere dimensioni più elevate sul dispositivo se disponi di una spaziatura sostanziale. Ciò può rendere più efficienti i trasferimenti tra l'host e il dispositivo.
    • Può anche essere utile per i picchi di utilizzo della memoria, perché il parametro pacchettizzato può essere decompresso on demand.

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

  • La generazione di pseudo-numeri casuali per le distribuzioni uniformi o di Bernoulli è molto rapida.
  • Le distribuzioni normali sono leggermente più costose di quelle uniformi o di Bernoulli.
  • La generazione di pseudo-numeri 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 e tf.reduce_sum

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

  • Le riduzioni consentono di fondere operazioni a livello di elemento nei loro 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 unite di TensorFlow, Il loro utilizzo può essere notevolmente più efficiente dell'alternativa.

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