Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Guida alle prestazioni di TensorFlow

Panoramica

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

Per ulteriori informazioni, consulta la sezione callback TensorBoard.

Note sulle prestazioni delle funzioni TensorFlow

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

tf.matmul

  • La trasposizione del risultato di uno degli operandi è effettivamente gratuita.
  • Tieni presente che tf.matmul supporta la fusione nei rispettivi input e output. Ciò significa che le funzioni di attivazione o i bias applicati direttamente all'output di tf.matmul hanno un overhead basso.

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

  • Per le attivazioni, le dimensioni del batch e delle caratteristiche vengono aggiunte a un multiplo di 8 o 128.
    • La prima XLA monitora la dimensione più comune delle dimensioni del batch per le convoluzioni nel modulo. In questo modo è possibile distinguere tra convoluzioni in avanti, quelle di sfumatura di attivazione e quelle di sfumatura del kernel.
    • Se la dimensione del batch più comune è maggiore o uguale a 64:
      • Il batch è riempito con un multiplo di 128 e la funzione è riempita con un multiplo di 8 per le convoluzioni avanti e indietro.
      • Il batch è riempito con un multiplo di 8 e la funzionalità è riempita con un multiplo di 128 per le convoluzioni dell'aggiornamento sfumatura.
    • Se la dimensione del batch più comune è inferiore a 64:
      • Il batch è riempito con un multiplo di 8 e la funzione è riempita con un multiplo di 128 per le convoluzioni avanti e indietro.
      • Il batch è riempito con un multiplo di 128 e la funzionalità è riempita con un multiplo di 8 per le convoluzioni dell'aggiornamento sfumatura.
      • La trasposizione delle attivazioni prima dell'invio a una convoluzione è gratuita se la trasposizione scambia solo la dimensione di input e le dimensioni del batch.
  • Per il kernel, le dimensioni della caratteristica di input e di output vengono aggiunte a un multiplo di 8 o 128. L'esatta determinazione è influenzata dai produttori e dagli altri consumatori del kernel.
    • La trasposizione di un kernel subito prima di inviarlo a una convoluzione è gratuita se il transpose scambia solo le dimensioni delle caratteristiche di input e di output.
  • Di conseguenza, le dimensioni batch e delle caratteristiche vengono aggiunte a un multiplo di 8 o 128.
    • La trasposizione del risultato di una convoluzione è gratuita se il transpose scambia solo le dimensioni del batch e delle caratteristiche di output.
  • Tieni presente che tf.nn.conv_n_d supporta la fusione nel suo risultato, le attivazioni e/o il kernel. Ciò significa che le funzioni di attivazione o i bias applicati direttamente all'output hanno un overhead basso.

tf.nn.avg_pool, tf.nn.max_pool

  • Si applicano le regole di spaziatura interna: le dimensioni spaziali sono più importanti del batch e della funzionalità. Ogni batch e funzionalità possono essere aggiunti a un multiplo di 8 o 128.
  • In genere, il layout di un'operazione in pool corrisponde alle convoluzioni che scorrono o fuori.
  • Il calcolo del gradiente per tf.nn.max_pool potrebbe essere più lento del suo equivalente in tf.nn.avg_pool. Se possibile, valuta la possibilità di passare dal pool max a quello pool medio.

tf.concat, tf.slice, tf.strided_slice

  • Evita sezioni e concatenazioni non necessarie. Sezioni e concatenazioni in una dimensione imbottita sono notevolmente più costose.
    • Lo spostamento dei dati è ridotto al minimo se la dimensione della sezione non ha un'area di spaziatura interna.

tf.transpose

  • La trasposizione di qualsiasi operando di un elemento tf.matmul o del relativo risultato è gratuita.
  • La trasposizione delle attivazioni di un tf.conv_n_d è gratuita se scambia le dimensioni dei batch e delle caratteristiche di input.
  • La trasposizione del kernel di un tf.conv_n_d è gratuita se cambia le dimensioni delle caratteristiche di input e di output.
  • La trasposizione del risultato di un elemento tf.conv_n_d è gratuita se scambia le dimensioni dei batch e delle caratteristiche di output.

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

  • Sono costosi perché prevedono lo spostamento dei dati dalle dimensioni imbottite a quelle non imbottite e viceversa.

tf.reshape

  • Il rimodellamento può essere costoso su Cloud TPU quando si spostano dati in una dimensione imbottita.
  • Può essere utile reformattare i dati per R1 sull'host e riformattarli in una forma di dimensione maggiore sul dispositivo se esiste una spaziatura interna sostanziale. In questo modo i trasferimenti tra host e dispositivo sono più efficienti.
    • Può anche essere utile per l'utilizzo massimo della memoria, perché il parametro packed può essere decompresso on demand.

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

  • La generazione di numeri casuali Pseudo per le distribuzioni uniformi o Bernoulli è molto veloce.
  • Le distribuzioni normali sono leggermente più costose delle distribuzioni uniformi o Bernoulli.
  • La generazione di numeri casuali Pseudo per le distribuzioni Categorical/Multinomial è 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

  • Più riduzioni con la stessa forma di input e output possono essere eseguite in parallelo tramite fusion.
    • Cerca di riscrivere le catene sequenziali di riduzioni in quelle parallele, se possibile.

  • Le riduzioni supportano l'unione di operazioni elementari nell'input, ma non nell'output. Quando possibile, riscrivi le espressioni per promuovere 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 con fusibili di TensorFlow di normalizzazione batch. Utilizzarli può essere notevolmente più efficiente rispetto all'alternativa.
    • Preferenza: tf.nn.fused_batch_norm rispetto a tf.nn.batch_normalization.
    • Per tf.layers.batch_normalization, imposta l'argomento "fused" su true.