Aiuto proteggere la Grande Barriera Corallina con tensorflow sul Kaggle Join Sfida

Ottimizza le prestazioni di TensorFlow utilizzando Profiler

Questa guida mostra come utilizzare gli strumenti disponibili con TensorFlow Profiler per monitorare le prestazioni dei modelli TensorFlow. Imparerai come comprendere le prestazioni del tuo modello sull'host (CPU), sul dispositivo (GPU) o su una combinazione di host e dispositivi.

La profilazione aiuta a comprendere il consumo di risorse hardware (tempo e memoria) delle varie operazioni TensorFlow (ops) nel modello e a risolvere i colli di bottiglia delle prestazioni e, infine, a velocizzare l'esecuzione del modello.

Questa guida illustra come installare Profiler, i vari strumenti disponibili, le diverse modalità di raccolta dei dati sulle prestazioni da parte di Profiler e alcune best practice consigliate per ottimizzare le prestazioni del modello.

Se si vuole profilare le prestazioni del modello su Cloud TPU, fare riferimento alla guida di cloud TPU .

Installa i prerequisiti di Profiler e GPU

Installa il plugin Profiler per TensorBoard con pip. Si noti che Profiler richiede le ultime versioni di TensorFlow e TensorBoard (>=2.2).

pip install -U tensorboard_plugin_profile

Per profilare sulla GPU, devi:

  1. Incontra i driver NVIDIA® GPU e requisiti CUDA® Toolkit quotate in requisiti software supporto tensorflow GPU .
  2. Assicurarsi che i Strumenti NVIDIA® CUDA® Profiling Interface (CUPTI) esiste sul percorso:

    /sbin/ldconfig -N -v $(sed 's/:/ /g' <<< $LD_LIBRARY_PATH) | \
    grep libcupti
    

Se non si dispone di CUPTI sul sentiero, antepone la sua directory di installazione per il $LD_LIBRARY_PATH variabile d'ambiente eseguendo:

export LD_LIBRARY_PATH=/usr/local/cuda/extras/CUPTI/lib64:$LD_LIBRARY_PATH

Quindi, eseguire il ldconfig comando sopra nuovamente per verificare che la libreria CUPTI viene trovato.

Risolvi i problemi di privilegio

Quando si esegue profiling con CUDA® Toolkit in un ambiente Docker o su Linux, è possibile riscontrare problemi relativi ai privilegi CUPTI insufficienti ( CUPTI_ERROR_INSUFFICIENT_PRIVILEGES ). Vai alla Docs sviluppatori di NVIDIA per saperne di più su come è possibile risolvere questi problemi su Linux.

Per risolvere i problemi di privilegio CUPTI in un ambiente Docker, eseguire

docker run option '--privileged=true'

Strumenti di profilatura

Accedi al Profiler dalla scheda profilo in TensorBoard, che appare solo dopo aver catturato alcuni dati del modello.

Il Profiler ha una selezione di strumenti per aiutare con l'analisi delle prestazioni:

  • Pagina Panoramica
  • Input Pipeline Analyzer
  • Statistiche TensorFlow
  • Visualizzatore di tracce
  • Statistiche del kernel GPU
  • Strumento profilo di memoria
  • Visualizzatore pod

Pagina panoramica

La pagina di panoramica fornisce una vista di livello superiore di come il tuo modello si è comportato durante l'esecuzione di un profilo. La pagina mostra una pagina di panoramica aggregata per il tuo host e tutti i dispositivi e alcuni consigli per migliorare le prestazioni di addestramento del modello. Puoi anche selezionare singoli host nel menu a discesa Host.

La pagina di panoramica visualizza i dati come segue:

Immagine

  • Sintesi delle performance: Visualizza un riepilogo di alto livello delle vostre prestazioni del modello. Il riepilogo delle prestazioni ha due parti:

    1. Ripartizione del tempo di passaggio: suddivide il tempo medio di passaggio in più categorie di tempo trascorso:

      • Compilazione: tempo impiegato per la compilazione dei kernel.
      • Input: tempo impiegato a leggere i dati di input.
      • Output: tempo impiegato a leggere i dati di output.
      • Avvio del kernel: tempo impiegato dall'host per avviare i kernel
      • Tempo di calcolo dell'host..
      • Tempo di comunicazione da dispositivo a dispositivo.
      • Tempo di calcolo sul dispositivo.
      • Tutti gli altri, incluso il sovraccarico di Python.
    2. Precisioni di calcolo del dispositivo: riporta la percentuale di tempo di calcolo del dispositivo che utilizza calcoli a 16 e 32 bit.

  • Step-time Graph: visualizza un grafico tempo step dispositivo (in millisecondi) su tutte le fasi del campione. Ogni passaggio è suddiviso in più categorie (con colori diversi) in cui viene trascorso il tempo. L'area rossa corrisponde alla porzione di tempo in cui i dispositivi sono rimasti inattivi in ​​attesa dei dati di input dall'host. L'area verde mostra per quanto tempo il dispositivo ha effettivamente funzionato.

  • Top 10 operazioni tensorflow sul dispositivo (ad esempio GPU): Visualizza il op sul dispositivo che correvano il più lungo.

    Ogni riga mostra il tempo di un'operazione (come percentuale di tempo impiegato da tutte le operazioni), il tempo cumulativo, la categoria e il nome.

  • Run Ambiente: visualizza un riepilogo di alto livello dell'ambiente modello di run tra cui:

    • Numero di host utilizzati.
    • Tipo di dispositivo (GPU/TPU).
    • Numero di core del dispositivo.
  • Raccomandazione per il passo successivo: Report quando un modello viene immesso legato e consiglia strumenti che è possibile utilizzare per individuare i colli di bottiglia e modello di determinazione.

Analizzatore di pipeline di ingresso

Quando un programma TensorFlow legge i dati da un file, inizia nella parte superiore del grafico TensorFlow in modo pipeline. Il processo di lettura è suddiviso in più fasi di elaborazione dati collegate in serie, dove l'output di una fase è l'input di quella successiva. Questo sistema di lettura dei dati si chiama la pipeline di ingresso.

Una tipica pipeline per leggere i record dai file ha le seguenti fasi:

  1. Lettura file.
  2. Pre-elaborazione del file (opzionale).
  3. Trasferimento di file dall'host al dispositivo.

Una pipeline di input inefficiente può rallentare notevolmente l'applicazione. Una domanda viene considerata ingresso vincolato quando si trascorre una parte significativa di tempo in cantiere di ingresso. Usa le informazioni ottenute dall'analizzatore della pipeline di input per capire dove la pipeline di input è inefficiente.

L'analizzatore della pipeline di input ti dice immediatamente se il tuo programma è vincolato all'input e ti guida attraverso l'analisi lato dispositivo e host per eseguire il debug dei colli di bottiglia delle prestazioni in qualsiasi fase della pipeline di input.

Consulta le linee guida sulle prestazioni della pipeline di input per le best practice consigliate per ottimizzare le pipeline di input dei dati.

Dashboard della pipeline di input

Per aprire l'analizzatore tubazione di ingresso, selezionare il profilo, quindi selezionare input_pipeline_analyzer dal menu a discesa Strumenti.

Immagine

La dashboard contiene tre sezioni:

  1. Riassunto: Riepiloga la conduttura di ingresso generale con informazioni su se l'applicazione è in ingresso legato e, in caso affermativo, da quanto.
  2. Analisi lato dispositivo: Visualizza informazioni dettagliate, risultati di analisi del dispositivo-lato, tra il dispositivo passo-tempo e l'intervallo di tempo trascorso dispositivo in attesa dei dati di ingresso di tutti nuclei ad ogni passo.
  3. Analisi lato host: mostra un'analisi dettagliata sul lato host, compresa una ripartizione di tempo di elaborazione ingresso sull'host.

Riepilogo della pipeline di input

Il riepilogo riporta se il programma viene immesso vincolato presentando la percentuale di tempo speso per dispositivo in attesa di input dall'host. Se si utilizza una pipeline di input standard che è stata strumentata, lo strumento segnala dove viene spesa la maggior parte del tempo di elaborazione dell'input.

Analisi lato dispositivo

L'analisi lato dispositivo fornisce approfondimenti sul tempo trascorso sul dispositivo rispetto all'host e quanto tempo sul dispositivo è stato impiegato in attesa dei dati di input dall'host.

  1. Tempo della fase rilevata in numero passo: visualizza un grafico tempo step dispositivo (in millisecondi) su tutte le fasi del campione. Ogni passaggio è suddiviso in più categorie (con colori diversi) in cui viene trascorso il tempo. L'area rossa corrisponde alla porzione di tempo in cui i dispositivi sono rimasti inattivi in ​​attesa dei dati di input dall'host. L'area verde mostra per quanto tempo il dispositivo ha funzionato effettivamente.
  2. Statistiche temporali Fase: Rapporti la, deviazione standard della media, e gamma ([minimo, massimo]) del tempo step dispositivo.

Analisi lato host

L'analisi lato host riporta una ripartizione del tempo di elaborazione di ingresso (il tempo speso per tf.data ops API) sull'host in diverse categorie:

  • La lettura dei dati da file su richiesta: Tempo speso su lettura dei dati dal file senza caching, prefetching, e interleaving.
  • La lettura dei dati da file in anticipo: Il tempo dedicato alla lettura di file, tra cui il caching, prefetching, e interleaving.
  • I dati pre-elaborazione: Tempo speso su ops pre-elaborazione, come ad esempio l'immagine di decompressione.
  • Dati enqueuing da trasferire al dispositivo: Tempo speso mettere i dati in una coda di alimentazione prima di trasferire i dati al dispositivo.

Espandere Input statistiche Op per ispezionare le statistiche per i singoli ops di ingresso e le loro categorie suddivise per tempi di esecuzione.

Immagine

Apparirà una tabella di dati di origine con ogni voce contenente le seguenti informazioni:

  1. Op Ingresso: mostra il nome tensorflow op del op ingresso.
  2. Conte: indica il numero totale di casi di esecuzione op durante il periodo di profiling.
  3. Tempo totale (in ms): mostra la somma cumulativa di tempo speso per ciascuna di tali istanze.
  4. Tempo totale:% mostra il tempo totale speso per un OP come una frazione del tempo totale trascorso in lavorazione di ingresso.
  5. Totale Auto Tempo (in ms): mostra la somma cumulativa del tempo speso per sé ciascuna di tali istanze. Il tempo autonomo qui misura il tempo trascorso all'interno del corpo della funzione, escludendo il tempo trascorso nella funzione che chiama.
  6. Totale Auto Tempo%. Mostra il tempo autonomo totale come frazione del tempo totale impiegato per l'elaborazione dell'input.
  7. Categoria. Mostra la categoria di elaborazione dell'input op.

Statistiche TensorFlow

Lo strumento TensorFlow Stats mostra le prestazioni di ogni operazione TensorFlow (op) eseguita sull'host o sul dispositivo durante una sessione di profilazione.

Immagine

Lo strumento visualizza le informazioni sulle prestazioni in due riquadri:

  • Il riquadro superiore visualizza fino a quattro grafici a torta:

    1. La distribuzione del tempo di autoesecuzione di ciascuna operazione sull'host.
    2. La distribuzione del tempo di autoesecuzione di ogni tipo di operazione sull'host.
    3. La distribuzione del tempo di autoesecuzione di ciascuna operazione sul dispositivo.
    4. La distribuzione del tempo di autoesecuzione di ciascun tipo di operazione sul dispositivo.
  • Il riquadro inferiore mostra una tabella che riporta i dati sulle operazioni di TensorFlow con una riga per ogni operazione e una colonna per ogni tipo di dati (ordina le colonne facendo clic sull'intestazione della colonna). Fare clic sul pulsante Esporta in formato CSV sul lato destro del riquadro superiore per esportare i dati da questa tabella come file CSV.

    Notare che:

    • Se alcune operazioni hanno operazioni figlio:

      • Il tempo totale "accumulato" di un'operazione include il tempo trascorso all'interno delle operazioni figlio.
      • Il tempo totale "auto" di un'operazione non include il tempo trascorso all'interno delle operazioni figlio.
    • Se un'operazione viene eseguita sull'host:

      • La percentuale dell'autonomia totale sul dispositivo sostenuta dall'operazione sarà 0.
      • La percentuale cumulativa dell'autonomia totale sul dispositivo fino a questa operazione inclusa sarà 0.
    • Se un'operazione viene eseguita sul dispositivo:

      • La percentuale del tempo autonomo totale sull'host sostenuto da questa operazione sarà 0.
      • La percentuale cumulativa del tempo autonomo totale sull'host fino a questa operazione inclusa sarà 0.

Puoi scegliere di includere o escludere il tempo di inattività nei grafici a torta e nella tabella.

Visualizzatore di tracce

Il visualizzatore di tracce mostra una timeline che mostra:

  • Durata delle operazioni eseguite dal modello TensorFlow
  • Quale parte del sistema (host o dispositivo) ha eseguito un'operazione. In genere, l'host esegue operazioni di input, pre-elabora i dati di training e li trasferisce al dispositivo, mentre il dispositivo esegue l'effettivo training del modello

Il visualizzatore di tracce ti consente di identificare i problemi di prestazioni nel tuo modello, quindi prendere provvedimenti per risolverli. Ad esempio, a un livello elevato, è possibile identificare se l'input o l'addestramento del modello richiede la maggior parte del tempo. Eseguendo il drill-down, è possibile identificare quali operazioni richiedono più tempo per l'esecuzione. Tieni presente che il visualizzatore di tracce è limitato a 1 milione di eventi per dispositivo.

Interfaccia del visualizzatore di tracce

Quando apri il visualizzatore di tracce, viene visualizzato l'esecuzione più recente:

Immagine

Questa schermata contiene i seguenti elementi principali:

  1. Riquadro Timeline: Spettacoli ops che il dispositivo e l'host eseguiti nel corso del tempo.
  2. Dettagli riquadro: mostra informazioni aggiuntive per ops selezionate nel riquadro Timeline.

Il riquadro Timeline contiene i seguenti elementi:

  1. Top bar: Contiene vari comandi ausiliari.
  2. Asse temporale: mostra il tempo relativo all'inizio della traccia.
  3. Sezione e della pista etichette: Ogni sezione contiene tracce multiple e ha un triangolo sulla sinistra che è possibile fare clic per espandere e comprimere la sezione. C'è una sezione per ogni elemento di elaborazione nel sistema.
  4. Attrezzo del selettore: Contiene vari strumenti per interagire con il visualizzatore di analisi, come zoom, pan, Select, e Timing. Utilizzare lo strumento Temporizzazione per contrassegnare un intervallo di tempo.
  5. Eventi: Questi mostrano il tempo durante il quale è stato eseguito un op o la durata di meta-eventi, come passi di formazione.
Sezioni e tracce

Il visualizzatore di tracce contiene le seguenti sezioni:

  • Una sezione per ciascun nodo dispositivo, corrispondente al numero del chip del dispositivo e il nodo del dispositivo all'interno del chip (per esempio, /device:GPU:0 (pid 0) ). Ogni sezione del nodo del dispositivo contiene le seguenti tracce:
    • Passo: mostra la durata delle fasi di formazione che erano in esecuzione sul dispositivo
    • Tensorflow Ops: mostra l'OPS eseguiti sul dispositivo
    • XLA Ops: Spettacoli XLA operazioni (PO) che correva sul dispositivo se XLA è il compilatore utilizzato (ogni op tensorflow si traduce in uno o più ops XLA La XLA compilatore traduce i ops XLA in codice che viene eseguito sul dispositivo.).
  • Una sezione per thread in esecuzione su CPU del computer host, etichettato "Thread Host". La sezione contiene una traccia per ogni thread della CPU. Tieni presente che puoi ignorare le informazioni visualizzate accanto alle etichette delle sezioni.
Eventi

Gli eventi all'interno della timeline vengono visualizzati in diversi colori; i colori stessi non hanno un significato specifico.

Il visualizzatore di tracce può anche visualizzare tracce di chiamate di funzioni Python nel programma TensorFlow. Se si utilizza l' tf.profiler.experimental.start API, è possibile attivare Python analisi utilizzando il ProfilerOptions namedtuple all'avvio profiling. In alternativa, se si utilizza la modalità di campionamento per la profilatura, è possibile selezionare il livello di traccia utilizzando le opzioni a discesa nella finestra di dialogo Capture profilo.

Immagine

Statistiche del kernel GPU

Questo strumento mostra le statistiche sulle prestazioni e l'operazione di origine per ogni kernel accelerato dalla GPU.

Immagine

Lo strumento visualizza le informazioni in due riquadri:

  • Il riquadro superiore mostra un grafico a torta che mostra i kernel CUDA con il tempo totale trascorso più alto.

  • Il riquadro inferiore mostra una tabella con i seguenti dati per ogni coppia kernel-op univoca:

    • Un rango in ordine decrescente della durata totale della GPU trascorsa raggruppata per coppia kernel-op.
    • Il nome del kernel avviato.
    • Il numero di registri GPU utilizzati dal kernel.
    • La dimensione totale della memoria condivisa (statica + dinamica condivisa) utilizzata in byte.
    • La dimensione del blocco espresso come blockDim.x, blockDim.y, blockDim.z .
    • Le dimensioni della griglia espressi come gridDim.x, gridDim.y, gridDim.z .
    • Sia l'op è idoneo a utilizzare Tensor Cores .
    • Se il kernel contiene istruzioni Tensor Core.
    • Il nome dell'operazione che ha lanciato questo kernel.
    • Il numero di occorrenze di questa coppia kernel-op.
    • Il tempo totale della GPU trascorso in microsecondi.
    • Il tempo medio della GPU trascorso in microsecondi.
    • Il tempo GPU minimo trascorso in microsecondi.
    • Il tempo GPU massimo trascorso in microsecondi.

Strumento per il profilo della memoria

Lo strumento di memoria Profilo monitor l'utilizzo della memoria del dispositivo durante l'intervallo di profilatura. Puoi utilizzare questo strumento per:

  • Eseguire il debug dei problemi di memoria (OOM) individuando il picco di utilizzo della memoria e l'allocazione di memoria corrispondente alle operazioni di TensorFlow. È inoltre possibile eseguire il debug di problemi OOM che possono sorgere quando si esegue multi-tenancy inferenza.
  • Debug dei problemi di frammentazione della memoria.

Lo strumento del profilo di memoria visualizza i dati in tre sezioni:

  1. Riepilogo profilo memoria
  2. Grafico della sequenza temporale della memoria
  3. Tabella di ripartizione della memoria

Riepilogo del profilo di memoria

Questa sezione visualizza un riepilogo di alto livello del profilo di memoria del programma TensorFlow come mostrato di seguito:

Il riepilogo del profilo di memoria ha sei campi:

  1. ID Memory: discesa che elenca tutti i sistemi di memoria del dispositivo disponibile. Seleziona il sistema di memoria che desideri visualizzare dal menu a discesa.
  2. #Allocation: Il numero di allocazioni di memoria eseguite durante l'intervallo profilatura.
  3. #Deallocation: Il numero di deallocazioni memoria nell'intervallo profilatura
  4. Capacità di memoria: La capacità totale (in lardoni) del sistema di memoria che si seleziona.
  5. Picco Heap Uso: L'utilizzo della memoria di picco (in lardoni) in quanto il modello cominciò a correre.
  6. Picco Utilizzo memoria: L'utilizzo della memoria di picco (in listoni) nell'intervallo profiling. Questo campo contiene i seguenti sottocampi:
    1. Timestamp: Il timestamp di quando l'utilizzo della memoria di picco si è verificato sulla linea temporale grafico.
    2. Stack Prenotazione: quantità di memoria riservata sullo stack (in lardoni).
    3. Allocazione mucchio: Quantità di memoria allocata sul mucchio (in lardoni).
    4. Free Memory: quantità di memoria libera (in lardoni). La capacità di memoria è la somma totale della prenotazione dello stack, dell'allocazione dell'heap e della memoria libera.
    5. Frammentazione: La percentuale di frammentazione (più basso è meglio). Si è calcolato come una percentuale di (1 - Size of the largest chunk of free memory / Total free memory) .

Grafico della sequenza temporale della memoria

Questa sezione mostra un grafico dell'utilizzo della memoria (in GiB) e la percentuale di frammentazione rispetto al tempo (in ms).

Immagine

L'asse X rappresenta la linea temporale (in ms) dell'intervallo di profilatura. L'asse Y a sinistra rappresenta l'utilizzo della memoria (in GiB) e l'asse Y a destra rappresenta la percentuale di frammentazione. In ogni momento sull'asse X, la memoria totale è suddivisa in tre categorie: stack (in rosso), heap (in arancione) e free (in verde). Passa il mouse su un timestamp specifico per visualizzare i dettagli sugli eventi di allocazione/deallocazione della memoria in quel punto come di seguito:

Immagine

La finestra pop-up visualizza le seguenti informazioni:

  • timestamp (ms): La posizione dell'evento selezionato sulla timeline.
  • evento: Il tipo di evento (allocazione o deallocazione).
  • requested_size (lardoni): La quantità di memoria richiesta. Questo sarà un numero negativo per gli eventi di deallocazione.
  • allocation_size (lardoni): La quantità effettiva di memoria allocata. Questo sarà un numero negativo per gli eventi di deallocazione.
  • tf_op: L'op tensorflow che richiede l'assegnazione / deallocazione.
  • step_id: Il passo di formazione in cui si è verificato l'evento.
  • region_type: Il tipo di entità dati questa memoria allocata è per. I valori possibili sono temp per provvisori, output per le attivazioni e gradienti, e persist / dynamic per i pesi e le costanti.
  • data_type: Il tipo di elemento tensore (ad esempio, per uint8 8 bit integer senza segno).
  • tensor_shape: La forma del tensore allocata / deallocato.
  • memory_in_use (lardoni): La memoria totale che è in uso, a questo punto di tempo.

Tabella di ripartizione della memoria

Questa tabella mostra le allocazioni di memoria attive al momento del picco di utilizzo della memoria nell'intervallo di profilatura.

Immagine

C'è una riga per ogni TensorFlow Op e ogni riga ha le seguenti colonne:

  • Op Nome: il nome del op tensorflow.
  • Allocazione Dimensione (lardoni): La quantità totale di memoria allocata a questa op.
  • Formato richiesto (GIBS): La quantità totale di memoria richiesta per questa op.
  • Occorrenze: il numero di assegnazioni per questo op.
  • Tipo Regione: Il tipo di entità di dati che questa memoria allocata è per. I valori possibili sono temp per provvisori, output per le attivazioni e gradienti, e persist / dynamic per i pesi e le costanti.
  • Tipo di dati: Il tipo di elemento tensore.
  • Forma: La forma dei tensori assegnate.

Visualizzatore pod

Lo strumento Pod Viewer mostra la suddivisione di una fase di formazione per tutti i lavoratori.

Immagine

  • Il riquadro superiore ha un cursore per selezionare il numero del passaggio.
  • Il riquadro inferiore visualizza un istogramma in pila. Questa è una vista di alto livello delle categorie di step-time scomposte poste l'una sopra l'altra. Ogni colonna in pila rappresenta un lavoratore univoco.
  • Quando passi con il mouse su una colonna impilata, la scheda sul lato sinistro mostra maggiori dettagli sulla suddivisione dei passaggi.

tf.data analisi del collo di bottiglia

Il tf.data strumento di analisi collo di bottiglia rileva automaticamente i colli di bottiglia nel tf.data tubazioni di ingresso nel programma e fornisce raccomandazioni su come risolverli. Funziona con qualsiasi programma utilizzando tf.data indipendentemente dalla piattaforma (CPU / GPU / TPU). La sua analisi e le raccomandazioni sono basate su questa guida .

Rileva un collo di bottiglia seguendo questi passaggi:

  1. Trova l'host più legato all'input.
  2. Trova la più lenta esecuzione di un tf.data conduttura di ingresso.
  3. Ricostruire il grafico della pipeline di input dalla traccia del profiler.
  4. Trova il percorso critico nel grafico della pipeline di input.
  5. Identificare la trasformazione più lenta sul percorso critico come un collo di bottiglia.

L'interfaccia utente è divisa in tre sezioni: Analisi delle prestazioni sintesi, sintesi di tutti gli input Condotte e input da pipeline grafico.

Riepilogo dell'analisi delle prestazioni

Immagine

Questa sezione fornisce il riepilogo dell'analisi. Riferisce sulle lenti tf.data tubazioni di ingresso rilevati nel profilo. Questa sezione mostra anche l'host con più limiti di input e la relativa pipeline di input più lenta con la latenza massima. Ancora più importante, identifica quale parte della pipeline di input è il collo di bottiglia e come risolverlo. Le informazioni sul collo di bottiglia vengono fornite con il tipo di iteratore e il suo nome lungo.

Come leggere il nome lungo dell'iteratore tf.data

Un nome lungo viene formattato come Iterator::<Dataset_1>::...::<Dataset_n> . In nome lungo, <Dataset_n> corrisponde al tipo di iteratore e gli altri set di dati nel nome lungo rappresentano trasformazioni a valle.

Si consideri ad esempio il seguente set di dati della pipeline di input:

dataset = tf.data.Dataset.range(10).map(lambda x: x).repeat(2).batch(5)

I nomi lunghi per gli iteratori dal set di dati sopra saranno:

Tipo di iteratore Nome lungo
Gamma Iteratore::Lotto::Ripeti::Mappa::Intervallo
Carta geografica Iteratore::Lotto::Ripeti::Mappa
Ripetere Iteratore::Lotto::Ripeti
Lotto Iteratore::Lotto

Riepilogo di tutte le pipeline di input

Immagine

Questa sezione fornisce il riepilogo di tutte le pipeline di input su tutti gli host. In genere è presente una pipeline di input. Quando si utilizza la strategia di distribuzione, c'è una conduttura di ingresso host che esegue il programma tf.data codice e tanti oleodotti ingresso dispositivo recupero dei dati dall'ingresso tubazione host e trasferimento verso i dispositivi.

Per ogni pipeline di input, mostra le statistiche del suo tempo di esecuzione. Una chiamata viene considerata lenta se impiega più di 50 μs.

Grafico della pipeline di input

Immagine

Questa sezione mostra il grafico della pipeline di input con le informazioni sul tempo di esecuzione. È possibile utilizzare "Host" e "Input Pipeline" per scegliere quale host e pipeline di input visualizzare. Le esecuzioni del gasdotto di ingresso sono ordinati per il tempo di esecuzione per cui è possibile scegliere utilizzando il menu a discesa gerarchico decrescente.

Immagine

I nodi sul percorso critico hanno contorni in grassetto. Il nodo del collo di bottiglia, che è il nodo con il tempo autonomo più lungo sul percorso critico, ha un contorno rosso. Gli altri nodi non critici hanno contorni tratteggiati grigi.

In ogni nodo, Ora inizio indica l'ora di inizio dell'esecuzione. Lo stesso nodo può essere eseguita più volte, ad esempio, se v'è un Batch op nella tubazione di ingresso. Se viene eseguito più volte, è l'ora di inizio della prima esecuzione.

Durata totale è il tempo parete dell'esecuzione. Se viene eseguito più volte, è la somma dei tempi di muro di tutte le esecuzioni.

Auto Il tempo è Tempo complessivo senza il tempo di sovrapposizione con i suoi nodi figli immediati.

"# chiamate" è il numero di volte in cui viene eseguita la pipeline di input.

Raccogli dati sulle prestazioni

Il TensorFlow Profiler raccoglie le attività dell'host e le tracce della GPU del tuo modello TensorFlow. È possibile configurare il Profiler per raccogliere dati sulle prestazioni tramite la modalità programmatica o la modalità di campionamento.

API di profilazione

È possibile utilizzare le seguenti API per eseguire la profilazione.

  • Modalità programmatico utilizzando il TensorBoard Keras Richiamata ( tf.keras.callbacks.TensorBoard )

    # Profile from batches 10 to 15
    tb_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir,
                                                 profile_batch='10, 15')
    
    # Train the model and use the TensorBoard Keras callback to collect
    # performance profiling data
    model.fit(train_data,
              steps_per_epoch=20,
              epochs=5,
              callbacks=[tb_callback])
    
  • Modalità programmatico utilizzando l' tf.profiler funzione API

    tf.profiler.experimental.start('logdir')
    # Train the model here
    tf.profiler.experimental.stop()
    
  • Modalità programmatica utilizzando il gestore di contesto

    with tf.profiler.experimental.Profile('logdir'):
        # Train the model here
        pass
    

  • Modalità di campionamento: eseguire on-demand profiling utilizzando tf.profiler.experimental.server.start di avviare un server gRPC con la corsa del modello tensorflow. Dopo aver avviato il server gRPC ed eseguire il modello, è possibile acquisire un profilo tramite il pulsante profilo di cattura nel plugin profilo TensorBoard. Utilizzare lo script nella sezione Install profiler sopra per avviare un'istanza TensorBoard se non è già in esecuzione.

    Come esempio,

    # Start a profiler server before your model runs.
    tf.profiler.experimental.server.start(6009)
    # (Model code goes here).
    #  Send a request to the profiler server to collect a trace of your model.
    tf.profiler.experimental.client.trace('grpc://localhost:6009',
                                          'gs://your_tb_logdir', 2000)
    

    Un esempio per la profilazione di più lavoratori:

    # E.g. your worker IP addresses are 10.0.0.2, 10.0.0.3, 10.0.0.4, and you
    # would like to profile for a duration of 2 seconds.
    tf.profiler.experimental.client.trace(
        'grpc://10.0.0.2:8466,grpc://10.0.0.3:8466,grpc://10.0.0.4:8466',
        'gs://your_tb_logdir',
        2000)
    

Utilizzare la finestra Capture profilo per specificare:

  • Un elenco delimitato da virgole di URL del servizio profilo o nomi TPU.
  • Una durata di profilazione.
  • Il livello di tracciamento delle chiamate di funzione di dispositivo, host e Python.
  • Quante volte vuoi che il Profiler tenti di acquisire i profili se inizialmente non ha successo.

Profilazione di cicli di allenamento personalizzati

Andare sul profilo cicli di formazione personalizzato nel codice tensorflow, strumento del ciclo di formazione con l' tf.profiler.experimental.Trace API per segnare i confini passo per il Profiler.

Il name argomento è usato come prefisso per i nomi di passi, lo step_num argomento chiave è aggiunto nei nomi di passo, e il _r argomento chiave che rende questo evento di traccia ottenere elaborati come un evento passo dal Profiler.

Come esempio,

for step in range(NUM_STEPS):
    with tf.profiler.experimental.Trace('train', step_num=step, _r=1):
        train_data = next(dataset)
        train_step(train_data)

Ciò consentirà l'analisi delle prestazioni basata sui passaggi del Profiler e farà sì che gli eventi dei passaggi vengano visualizzati nel visualizzatore di tracce.

Assicurati di includere l'iteratore set di dati all'interno del tf.profiler.experimental.Trace contesto per un'analisi accurata del gasdotto di ingresso.

Il frammento di codice di seguito è un anti-pattern:

for step, train_data in enumerate(dataset):
    with tf.profiler.experimental.Trace('train', step_num=step, _r=1):
        train_step(train_data)

Casi d'uso di profilazione

Il profiler copre una serie di casi d'uso lungo quattro diversi assi. Alcune delle combinazioni sono attualmente supportate e altre verranno aggiunte in futuro. Alcuni dei casi d'uso sono:

  • Vs locale profilazione remoto: Si tratta di due modi comuni di impostare il vostro ambiente di profilatura. Nella profilazione locale, l'API di profilatura viene chiamata sulla stessa macchina su cui è in esecuzione il modello, ad esempio una workstation locale con GPU. Nella profilazione remota, l'API di profilatura viene chiamata su una macchina diversa da quella in cui è in esecuzione il modello, ad esempio su un Cloud TPU.
  • Profiling più lavoratori: è possibile profilo più macchine quando si utilizzano le capacità di formazione distribuite su tensorflow.
  • Piattaforma hardware: CPU Profilo, GPU, e TPU.

La tabella seguente fornisce una rapida panoramica dei casi d'uso supportati da TensorFlow menzionati sopra:

API di profilazione Locale A distanza Più lavoratori Piattaforme hardware
TensorBoard Keras Callback Supportato Non supportato Non supportato CPU, GPU
tf.profiler.experimental avvio / arresto API Supportato Non supportato Non supportato CPU, GPU
tf.profiler.experimental client.trace API Supportato Supportato Supportato CPU, GPU, TPU
API di gestione del contesto Supportato Non supportato Non supportato CPU, GPU

Best practice per prestazioni ottimali del modello

Utilizzare i seguenti consigli a seconda dei casi per i modelli TensorFlow per ottenere prestazioni ottimali.

In generale, esegui tutte le trasformazioni sul dispositivo e assicurati di utilizzare l'ultima versione compatibile di librerie come cuDNN e Intel MKL per la tua piattaforma.

Ottimizza la pipeline dei dati di input

Utilizza i dati di [#input_pipeline_analyzer] per ottimizzare la pipeline di input dei dati. Un'efficiente pipeline di input dei dati può migliorare drasticamente la velocità di esecuzione del modello riducendo i tempi di inattività del dispositivo. Cercate di incorporare le migliori pratiche descritte nel prestazione migliore con l'API tf.data guida e di seguito per rendere la vostra pipeline di immissione dei dati più efficiente.

  • In generale, la parallelizzazione di tutte le operazioni che non devono essere eseguite in sequenza può ottimizzare in modo significativo la pipeline di input dei dati.

  • In molti casi, è utile modificare l'ordine di alcune chiamate o mettere a punto gli argomenti in modo che funzionino al meglio per il proprio modello. Durante l'ottimizzazione della pipeline dei dati di input, eseguire il benchmark solo del caricatore di dati senza i passaggi di addestramento e backpropagation per quantificare l'effetto delle ottimizzazioni in modo indipendente.

  • Prova a eseguire il tuo modello con dati sintetici per verificare se la pipeline di input è un collo di bottiglia delle prestazioni.

  • Usa tf.data.Dataset.shard per la formazione multi-GPU. Assicurati di shard molto presto nel ciclo di input per evitare riduzioni del throughput. Quando lavori con TFRecords, assicurati di dividere l'elenco di TFRecords e non il contenuto dei TFRecords.

  • Parallelizzare diversi ops impostando dinamicamente il valore della num_parallel_calls utilizzando tf.data.AUTOTUNE .

  • Si consideri che limita l'utilizzo di tf.data.Dataset.from_generator in quanto è più lento rispetto a ops tensorflow puri.

  • Si consideri che limita l'utilizzo di tf.py_function in quanto non può essere serializzato e non è supportato per l'esecuzione in tensorflow distribuito.

  • Utilizzare tf.data.Options per controllare le ottimizzazioni statiche alla tubazione di ingresso.

Leggere anche il tf.data analisi delle prestazioni guida per maggiori indicazioni su come ottimizzare la pipeline di ingresso.

Ottimizza l'aumento dei dati

Quando si lavora con i dati di immagine, rendere il vostro dati l'aumento più efficiente per colata a diversi tipi di dati dopo l'applicazione di trasformazioni spaziali, come flipping, ritaglio, rotazione, ecc

Usa NVIDIA® DALI

In alcuni casi, come quando si dispone di un sistema con un rapporto GPU/CPU elevato, tutte le ottimizzazioni di cui sopra potrebbero non essere sufficienti per eliminare i colli di bottiglia nel caricatore dati causati dalle limitazioni dei cicli della CPU.

Se si utilizza le GPU NVIDIA® per computer vision e applicazioni audio di apprendimento profonde, è possibile utilizzare i dati di carico Library ( DALI ) per accelerare la pipeline dei dati.

Controllare il NVIDIA® DALI: Operazioni documentazione per un elenco di ops DALI supportati.

Usa il threading e l'esecuzione parallela

Ops funzionare su più thread di CPU con il tf.config.threading API di eseguire più velocemente.

TensorFlow imposta automaticamente il numero di thread di parallelismo per impostazione predefinita. Il pool di thread disponibile per l'esecuzione di operazioni TensorFlow dipende dal numero di thread CPU disponibili.

Controllare l'aumento di velocità parallela massima per un singolo op utilizzando tf.config.threading.set_intra_op_parallelism_threads . Tieni presente che se esegui più operazioni in parallelo, condivideranno tutte il pool di thread disponibile.

Se si dispone op indipendenti non bloccanti (OPS senza percorso diretto tra loro sul grafico), uso tf.config.threading.set_inter_op_parallelism_threads eseguirli contemporaneamente utilizzando il pool di thread disponibili.

Varie

Quando si lavora con modelli più piccoli su GPU NVIDIA®, è possibile impostare tf.compat.v1.ConfigProto.force_gpu_compatible=True per forzare tutti i tensori della CPU da assegnare con la memoria appuntato CUDA per dare un impulso significativo alla performance del modello. Tuttavia, prestare attenzione durante l'utilizzo di questa opzione per modelli sconosciuti/molto grandi poiché ciò potrebbe influire negativamente sulle prestazioni dell'host (CPU).

Migliora le prestazioni del dispositivo

Seguire le best practice dettagliate qui e nella guida di ottimizzazione delle prestazioni della GPU per ottimizzare le prestazioni on-device modello tensorflow.

Se utilizzi GPU NVIDIA, registra l'utilizzo della GPU e della memoria in un file CSV eseguendo:

nvidia-smi
--query-gpu=utilization.gpu,utilization.memory,memory.total,
memory.free,memory.used --format=csv

Configura il layout dei dati

Quando si lavora con dati che contengono informazioni sui canali (come le immagini), ottimizzare il formato del layout dei dati per preferire i canali per ultimi (NHWC su NCHW).

Canale-ultimi formati di dati migliorano Tensor Nucleo utilizzo e fornire miglioramenti significativi delle prestazioni soprattutto nei modelli convoluzionali quando accoppiato con AMP. I layout di dati NCHW possono ancora essere gestiti da Tensor Core, ma introducono un sovraccarico aggiuntivo dovuto alle operazioni di trasposizione automatica.

È possibile ottimizzare il layout dei dati a preferire i layout NHWC impostando data_format="channels_last" per i livelli, come tf.keras.layers.Conv2D , tf.keras.layers.Conv3D e tf.keras.layers.RandomRotation .

Utilizzare tf.keras.backend.set_image_data_format per impostare il formato di layout dei dati di default per il backend API Keras.

Massimizza la cache L2

When working with NVIDIA® GPUs, execute the code snippet below before the training loop to max out the L2 fetch granularity to 128 bytes.

import ctypes

_libcudart = ctypes.CDLL('libcudart.so')
# Set device limit on the current device
# cudaLimitMaxL2FetchGranularity = 0x05
pValue = ctypes.cast((ctypes.c_int*1)(), ctypes.POINTER(ctypes.c_int))
_libcudart.cudaDeviceSetLimit(ctypes.c_int(0x05), ctypes.c_int(128))
_libcudart.cudaDeviceGetLimit(pValue, ctypes.c_int(0x05))
assert pValue.contents.value == 128

Configure GPU thread usage

The GPU thread mode decides how GPU threads are used.

Set the thread mode to gpu_private to make sure that preprocessing does not steal all the GPU threads. This will reduce the kernel launch delay during training. You can also set the number of threads per GPU. Set these values using environment variables.

import os

os.environ['TF_GPU_THREAD_MODE']='gpu_private'
os.environ['TF_GPU_THREAD_COUNT']='1'

Configure GPU memory options

In general, increase the batch size and scale the model to better utilize GPUs and get higher throughput. Note that increasing the batch size will change the model's accuracy so the model needs to be scaled by tuning hyperparameters like the learning rate to meet the target accuracy.

Also, use tf.config.experimental.set_memory_growth to allow GPU memory to grow to prevent all the available memory from being fully allocated to ops that require only a fraction of the memory. This allows other processes which consume GPU memory to run on the same device.

To learn more, check out the Limiting GPU memory growth guidance in the GPU guide to learn more.

Miscellaneous

  • Increase the training mini-batch size (number of training samples used per device in one iteration of the training loop) to the maximum amount that fits without an out of memory (OOM) error on the GPU. Increasing the batch size impacts the model's accuracy—so make sure you scale the model by tuning hyperparameters to meet the target accuracy.

  • Disable reporting OOM errors during tensor allocation in production code. Set report_tensor_allocations_upon_oom=False in tf.compat.v1.RunOptions .

  • For models with convolution layers, remove bias addition if using batch normalization. Batch normalization shifts values by their mean and this removes the need to have a constant bias term.

  • Use TF Stats to find out how efficiently on-device ops run.

  • Use tf.function to perform computations and optionally, enable the jit_compile=True flag ( tf.function(jit_compile=True ). To learn more, go to Use XLA tf.function .

  • Minimize host Python operations between steps and reduce callbacks. Calculate metrics every few steps instead of at every step.

  • Keep the device compute units busy.

  • Send data to multiple devices in parallel.

  • Consider using 16-bit numerical representations , such as fp16 —the half-precision floating point format specified by IEEE—or the Brain floating-point bfloat16 format.

Additional resources

Known limitations

Profiling multiple GPUs on TensorFlow 2.2 and TensorFlow 2.3

TensorFlow 2.2 and 2.3 support multiple GPU profiling for single host systems only; multiple GPU profiling for multi-host systems is not supported. To profile multi-worker GPU configurations, each worker has to be profiled independently. From TensorFlow 2.4 multiple workers can be profiled using the tf.profiler.experimental.client.trace API.

CUDA® Toolkit 10.2 or later is required to profile multiple GPUs. As TensorFlow 2.2 and 2.3 support CUDA® Toolkit versions only up to 10.1, you need to create symbolic links to libcudart.so.10.1 and libcupti.so.10.1 :

sudo ln -s /usr/local/cuda/lib64/libcudart.so.10.2 /usr/local/cuda/lib64/libcudart.so.10.1
sudo ln -s /usr/local/cuda/extras/CUPTI/lib64/libcupti.so.10.2 /usr/local/cuda/extras/CUPTI/lib64/libcupti.so.10.1