Profilare i carichi di lavoro TensorFlow

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

Per saperne di più, consulta la sezione Richiami di TensorBoard.

Note sulle prestazioni della funzione TensorFlow

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

tf.matmul

  • La trasposizione del risultato di uno degli operandi è effettivamente libera.
  • Tieni presente che tf.matmul supporta l'unione nei suoi input e output. Ciò significa le funzioni di attivazione o i bias applicati direttamente all'output tf.matmul ha un overhead basso.

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

  • Per le attivazioni, le dimensioni di batch e funzionalità sono riempite multiplo 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 è riempito a un multiplo di 128 e la caratteristica è riempito a multiplo di 8 per le convoluzioni avanti e indietro.
      • Il Batch è riempito in un multiplo di 8 e la caratteristica è riempito in 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 a un multiplo di 128 e la caratteristica è riempito a multiplo 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 dipende i producer e gli altri consumer del kernel.
    • La trasposizione di un kernel subito prima di inviarlo a una convoluzione è gratuita se la trasposizione scambia solo le dimensioni delle caratteristiche di input e output.
  • Per ottenere il risultato, le dimensioni del batch e della caratteristica sono riempite in un multiplo di 8 o 128.
    • La trasposizione del risultato di una convoluzione è libera solo se la trasposizione inverti le dimensioni delle caratteristiche in batch e in 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

  • Si applicano le regole di spaziatura interna: le dimensioni spaziali sono più importanti di quelle batch funzionalità. Ogni batch e ogni elemento possono essere riempiti fino a un multiplo di 8 o 128.
  • Di solito, il layout di un'operazione di pool corrisponde alle convoluzioni che fluiscono dentro o fuori.
  • 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 sezioni e concatenazioni non necessarie. Le sezioni e le concatenazioni in una dimensione con spaziatura interna sono notevolmente più costose.
    • Lo spostamento dei dati è ridotto al minimo se la dimensione della sezione non ha spaziatura interna overhead.

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 l'input e dimensioni delle caratteristiche di output.
  • La trasposizione del risultato di un tf.conv_n_d è gratuita se scambia il batch e dimensioni delle caratteristiche di output.

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

  • 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 di quelle uniformi o di Bernoulli. distribuibili.
  • Generazione di pseudo numeri casuali per categoriche e multinomiali distribuzioni è notevolmente più costoso.

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.
    • 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 l'alternativa.

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