Misurazione del rendimento

Strumenti di benchmark

Gli strumenti di benchmark LiteRT attualmente misurano e calcolano le statistiche per le seguenti importanti metriche sul rendimento:

• Tempo di inizializzazione
• Tempo di inferenza dello stato di riscaldamento
• Tempo di inferenza dello stato stazionario
• Memoria utilizzata durante il tempo di inizializzazione
• Memoria utilizzata complessiva

Gli strumenti di benchmark sono disponibili come app di benchmark per Android e iOS e come file binari nativi della riga di comando e condividono tutti le stesse prestazioni di base dalla logica di misurazione. Tieni presente che le opzioni e i formati di output disponibili leggermente diverso a causa delle differenze nell'ambiente di runtime.

App di benchmark per Android

Lo strumento di benchmark con Android offre due opzioni. Uno è un binario di benchmark nativo e un altro è Android. un'app di benchmark per misurare meglio il rendimento del modello nell'app. Entrambi i valori dello strumento di benchmarking sono leggermente diversi da quelli che esegue l'inferenza con il modello nell'app effettiva.

Questa app di benchmark Android non ha UI. Installa ed eseguilo utilizzando l'adb e recuperare i risultati con il comando adb logcat.

Scarica o crea l'app

Scarica le app di benchmark Android predefinite di notte utilizzando i link che seguono:

• android_aarch64
• android_arm

Come per le app di benchmark Android che supportano le operazioni di TF tramite delegato flessibile, utilizza i link riportati di seguito:

• android_aarch64
• android_arm

Puoi anche creare l'app dal codice sorgente seguendo questi passaggi: istruzioni.

Prepara il benchmark

Prima di eseguire l'app di benchmark, installala ed esegui il push del file del modello al dispositivo nel seguente modo:

adb install -r -d -g android_aarch64_benchmark_model.apk
adb push your_model.tflite /data/local/tmp

Esegui benchmark

adb shell am start -S \
  -n org.tensorflow.lite.benchmark/.BenchmarkModelActivity \
  --es args '"--graph=/data/local/tmp/your_model.tflite \
              --num_threads=4"'

graph è un parametro obbligatorio.

• graph: string
  Il percorso del file del modello TFLite.

Puoi specificare altri parametri facoltativi per l'esecuzione del benchmark.

• num_threads: int (valore predefinito=1)
  Il numero di thread da utilizzare per eseguire l'interprete TFLite.
• use_gpu: bool (predefinito=falso)
  Usa il delegato GPU.
• use_xnnpack: bool (valore predefinito=false)
  Utilizza le funzionalità di Delegato xnNPACK.

A seconda del dispositivo in uso, alcune di queste opzioni potrebbero non essere disponibili o non hanno alcun effetto. Consulta parametri per ulteriori parametri di rendimento che potresti eseguire con l'app di benchmark.

Visualizza i risultati utilizzando il comando logcat:

adb logcat | grep "Inference timings"

I risultati dei benchmark sono riportati come:

... tflite  : Inference timings in us: Init: 5685, First inference: 18535, Warmup (avg): 14462.3, Inference (avg): 14575.2

File binario benchmark nativo

Lo strumento di benchmark viene fornito anche come file binario nativo benchmark_model. Puoi eseguire questo strumento dalla riga di comando della shell su Linux, Mac, dispositivi incorporati Dispositivi Android

Scarica o crea il programma binario

Scarica i file binari notturni nativi della riga di comando predefiniti seguendo le istruzioni link di seguito:

• linux_x86-64
• linux_aarch64
• linux_arm
• android_aarch64
• android_arm

Per quanto riguarda i file binari notturni predefiniti che supportano le operazioni di TF. tramite delegato flessibile, utilizza i link riportati di seguito:

• linux_x86-64
• linux_aarch64
• linux_arm
• android_aarch64
• android_arm

Puoi anche creare il file binario di benchmark nativo fonte sul computer.

bazel build -c opt //tensorflow/lite/tools/benchmark:benchmark_model

Per creare con la toolchain di Android NDK, devi configurare l'ambiente di build seguendo innanzitutto questo guida oppure utilizza l'immagine Docker, come descritto in .

bazel build -c opt --config=android_arm64 \
  //tensorflow/lite/tools/benchmark:benchmark_model

Esegui benchmark

Per eseguire i benchmark sul tuo computer, esegui il programma binario dalla shell.

path/to/downloaded_or_built/benchmark_model \
  --graph=your_model.tflite \
  --num_threads=4

Puoi utilizzare lo stesso insieme parametri come accennato in precedenza con il programma binario nativo della riga di comando.

Profilazione delle operazioni del modello

Il programma binario del modello benchmark ti consente anche di profilare le operazioni del modello e ottenere tempi di esecuzione di ciascun operatore. Per farlo, passa il flag Da --enable_op_profiling=true a benchmark_model durante la chiamata. I dettagli sono spiegata qui

Programma binario nativo del benchmark per più opzioni di prestazioni in una sola esecuzione

Viene fornito anche un programma binario C++ pratico e semplice eseguire il benchmark di più opzioni di prestazioni in un'unica esecuzione. Questo programma binario è basato sullo strumento di benchmark indicato in precedenza che potevano essere utilizzate come benchmark di una sola opzione di prestazioni alla volta. Condividono lo stesso processo di build/installazione/esecuzione, ma il nome di destinazione BUILD di questo programma binario è benchmark_model_performance_options e richiede alcuni parametri aggiuntivi. Un parametro importante di questo programma binario è:

perf_options_list: string (predefinito='all')
Un elenco separato da virgole di opzioni per le prestazioni TFLite da confrontare.

Puoi ottenere programmi binari notturni predefiniti per questo strumento, come indicato di seguito:

• linux_x86-64
• linux_aarch64
• linux_arm
• android_aarch64
• android_arm

App di benchmark per iOS

Per eseguire benchmark su dispositivi iOS, devi creare l'app da fonte. Inserisci il file del modello LiteRT nella benchmark_data della struttura di origine e modifica il file benchmark_params.json. Quelli che vengono pacchettizzati nell'app, che legge i dati dalla directory. Visita la pagina il App di benchmark per iOS per istruzioni dettagliate.

Benchmark delle prestazioni per modelli noti

Questa sezione elenca i benchmark delle prestazioni LiteRT quando funziona bene noti su alcuni dispositivi Android e iOS.

Benchmark prestazioni Android

I valori dei benchmark di rendimento sono stati generati utilizzando binario di benchmark nativo.

Per i benchmark Android, l'affinità della CPU è impostata per utilizzare grandi core sul dispositivo per ridurre la varianza (vedi dettagli).

Si presuppone che i modelli siano stati scaricati e decompressi Directory /data/local/tmp/tflite_models. Il file binario di benchmark viene creato queste istruzioni e si presume che si trovi nella directory /data/local/tmp.

Per eseguire il benchmark:

adb shell /data/local/tmp/benchmark_model \
  --num_threads=4 \
  --graph=/data/local/tmp/tflite_models/${GRAPH} \
  --warmup_runs=1 \
  --num_runs=50

Per l'esecuzione con delegato GPU, imposta --use_gpu=true.

I valori delle prestazioni riportati di seguito sono misurati su Android 10.

Benchmark delle prestazioni per iOS

I valori dei benchmark di rendimento sono stati generati utilizzando App di benchmark per iOS.

Per eseguire benchmark per iOS, l'app Benchmark è stata modificata in modo da includere i modello e benchmark_params.json è stato modificato per impostare num_threads su 2. Per utilizzare il delegato GPU, le opzioni "use_gpu" : "1" e "gpu_wait_type" : "aggressive" sono stati aggiunti anche a benchmark_params.json.

Interni di Trace LiteRT

Interni di Trace LiteRT in Android

Gli eventi interni dell'interprete LiteRT di un'app Android possono essere acquisita da Strumenti di tracciamento di Android. Sono gli stessi eventi di Android API Trace, pertanto gli eventi acquisiti dal codice Java/Kotlin vengono visualizzati insieme a LiteRT eventi interni.

Alcuni esempi di eventi sono:

• Chiamata operatore
• Modifica del grafico per delegato
• Allocazione dei tensori

Questa guida illustra le varie opzioni disponibili per l'acquisizione di tracce, CPU Profiler di Studio e l'app di tracciamento del sistema. Consulta Strumento a riga di comando Perfetto o Strumento a riga di comando di Systrace per visualizzare altre opzioni.

Aggiunta di eventi di traccia nel codice Java

Questo è uno snippet di codice Classificazione delle immagini di esempio. L'interprete LiteRT viene eseguito Sezione recognizeImage/runInference. Questo passaggio è facoltativo, ma è utile per vedere dove viene effettuata la chiamata di inferenza.

  Trace.beginSection("recognizeImage");
  ...
  // Runs the inference call.
  Trace.beginSection("runInference");
  tflite.run(inputImageBuffer.getBuffer(), outputProbabilityBuffer.getBuffer().rewind());
  Trace.endSection();
  ...
  Trace.endSection();

Attiva il tracciamento LiteRT

Per attivare il tracciamento LiteRT, imposta la proprietà del sistema Android debug.tflite.trace a 1 prima di avviare l'app per Android.

adb shell setprop debug.tflite.trace 1

Se questa proprietà è stata impostata quando viene inizializzato l'interprete LiteRT, gli eventi chiave (ad es. la chiamata di un operatore) dall'interprete verranno tracciati.

Dopo aver acquisito tutte le tracce, disabilita il tracciamento impostando il valore della proprietà a 0.

adb shell setprop debug.tflite.trace 0

Profiler CPU di Android Studio

Acquisisci le tracce con Profilo CPU di Android Studio procedendo nel seguente modo:

1. Seleziona Esegui > Profilo "app" dai menu in alto.

2. Fai clic in un punto qualsiasi nella sequenza temporale della CPU quando viene visualizzata la finestra Profiler.

3. Seleziona "Trace System Calls". tra le modalità di profilazione della CPU.

   

4. Premi "Registra" .

5. Premi "Interrompi" .

6. Esamina il risultato della traccia.

   

In questo esempio, puoi vedere la gerarchia degli eventi in un thread e le statistiche per ogni orario dell'operatore e vedere anche il flusso di dati dell'intera app tra thread.

App di tracciamento del sistema

Acquisisci tracce senza Android Studio seguendo i passaggi descritti in App di tracciamento del sistema.

In questo esempio, sono stati acquisiti gli stessi eventi TFLite e salvati in Perfetto o Systrace, a seconda della versione del dispositivo Android. Lo screenshot I file di traccia possono essere aperti nella UI di Perfetto.

Interni di Trace LiteRT in iOS

Gli eventi interni dell'interprete LiteRT di un'app per iOS possono essere acquisita da Strumenti incluso in Xcode. Sono gli strumenti per sviluppatori signpost eventi, in modo che gli eventi acquisiti dal codice Swift/Objective-C vengano visualizzati insieme con eventi interni LiteRT.

Alcuni esempi di eventi sono:

• Chiamata operatore
• Modifica del grafico per delegato
• Allocazione dei tensori

Attiva il tracciamento LiteRT

Per impostare la variabile di ambiente debug.tflite.trace:

1. Seleziona Prodotto > Schema > Modifica schema... dai menu superiori di Xcode.

2. Fai clic su "Profilo". nel riquadro a sinistra.

3. Deseleziona "Utilizza gli argomenti e le variabili di ambiente dell'azione" casella di controllo.

4. Aggiungi debug.tflite.trace in "Variabili di ambiente" .

   

Se vuoi escludere gli eventi LiteRT durante la profilazione dell'app per iOS, e disabilitare il tracciamento rimuovendo la variabile di ambiente.

XCode Instruments

Acquisisci le tracce procedendo nel seguente modo:

1. Seleziona Prodotto > Profile dai menu superiori di Xcode.

2. Fai clic su Logging tra i modelli di profilazione quando viene avviato lo strumento Strumenti.

3. Premi "Avvia" .

4. Premi "Interrompi" .

5. Fai clic su "os_signpost". per espandere gli elementi del sottosistema OS Logging.

6. Fai clic su "org.tensorflow.lite". sottosistema OS Logging.

7. Esamina il risultato della traccia.

   

In questo esempio, puoi vedere la gerarchia degli eventi e delle statistiche per ogni dell'operatore.

Utilizzo dei dati di tracciamento

I dati di tracciamento ti consentono di identificare i colli di bottiglia delle prestazioni.

Ecco alcuni esempi di insight che puoi ottenere dal profiler potenziali soluzioni per migliorare il rendimento:

• Se il numero di core della CPU disponibili è inferiore al numero di inferenza thread, l'overhead di pianificazione della CPU può portare a prestazioni inferiori. È possibile riprogrammare altre attività che richiedono un uso intensivo della CPU nell'applicazione per evitare sovrapporre l'inferenza del modello o modificare il numero thread.
• Se gli operatori non sono completamente delegati, alcune parti del grafico del modello vengono eseguiti sulla CPU anziché sull'acceleratore hardware previsto. Tu può sostituire gli operatori non supportati con operatori supportati simili.