Misurazione del rendimento

Strumenti di benchmark

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

• Tempo di inizializzazione
• Tempo di inferenza dello stato di warmup
• Tempo di inferenza dello stato stazionario
• Utilizzo di memoria durante il tempo di inizializzazione
• Utilizzo complessivo della memoria

Gli strumenti di benchmarking sono disponibili come app di benchmarking per Android e iOS e come binari della riga di comando precompilati e condividono tutti la stessa logica di misurazione delle prestazioni di base. Tieni presente che le opzioni disponibili e i formati di output sono leggermente diversi a causa delle differenze nell'ambiente di runtime.

Binario di benchmark precompilato (utilizzando l'API CompiledModel)

Esistono due opzioni per utilizzare lo strumento di benchmarking con Android. Uno è un binario di benchmark nativo (basato sull'API CompiledModel) e l'altro è un'app di benchmark per Android (basata sull'API Interpreter). Lo strumento LiteRT Benchmark viene fornito come binario integrato benchmark_model. Puoi eseguire questo strumento da una riga di comando della shell su Linux, macOS, Windows, Raspberry Pi, dispositivi incorporati e dispositivi Android con accelerazione GPU abilitata.

Scaricare o creare il programma binario

Scarica i file binari precompilati della riga di comando notturni seguendo i link riportati di seguito:

• linux_x86_64
• linux_arm64
• android_arm64
• macos_arm64
• windows_x86_64

Puoi anche creare il binario di benchmark dal codice sorgente sul tuo computer.

bazel build -c opt //litert/tools:benchmark_model

Per eseguire la build con la toolchain Android NDK, devi prima configurare l'ambiente di build seguendo questa guida o utilizzare l'immagine Docker come descritto in questa guida.

bazel build -c opt --config=android_arm64 \
  //litert/tools:benchmark_model

Esegui benchmark

Per eseguire benchmark sul computer, esegui il file binario dalla shell.

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

Puoi utilizzare lo stesso insieme di parametri menzionati in precedenza con il binario della riga di comando predefinito.

Acceleratore GPU

Questi binari precompilati includono il nuovo acceleratore GPU LiteRT. Supporta OpenCL e WebGPU supportati da Vulkan (Linux), Metal (macOS) e Direct3D (Windows).

Per utilizzare l'acceleratore GPU, passa il flag --use_gpu=true.

Operazioni del modello di profilo

Il file binario del modello di benchmark consente anche di profilare le operazioni del modello e ottenere i tempi di esecuzione di ciascun operatore. Per farlo, passa il flag --use_profiler=true a benchmark_model durante la chiamata.

App di benchmark per Android (che utilizza l'API Interpreter)

Viene fornita anche un'app di benchmark per Android basata sull'API Interpreter v1. Si tratta di una misura migliore di come si comporterebbe il modello in un'app per Android. I numeri dello strumento di benchmark differiranno comunque leggermente rispetto all'inferenza con il modello nell'app effettiva.

Questa app di benchmarking per Android non ha un'interfaccia utente. Installa ed esegui il comando utilizzando il comando adb e recupera i risultati utilizzando il comando adb logcat.

Scaricare o creare l'app

Scarica le app di benchmark Android precompilate notturne utilizzando i seguenti link:

• android_aarch64
• android_arm

Per quanto riguarda le app di benchmark per Android che supportano le operazioni TF tramite il delegato flessibile, utilizza i seguenti link:

• android_aarch64
• android_arm

Puoi anche creare l'app dal codice sorgente seguendo queste istruzioni.

Prepara benchmark

Prima di eseguire l'app di benchmark, installala e trasferisci il file del modello sul 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 l'esecuzione dell'interprete TFLite.
• use_gpu: bool (default=false)
  Utilizza il delegato GPU.
• use_xnnpack: bool (valore predefinito=false)
  Utilizza XNNPACK delegate.

A seconda del dispositivo che utilizzi, alcune di queste opzioni potrebbero non essere disponibili o non avere effetto. Consulta la sezione parametri per altri parametri di rendimento che puoi eseguire con l'app di benchmarking.

Visualizza i risultati utilizzando il comando logcat:

adb logcat | grep "Inference timings"

I risultati del benchmark vengono riportati come:

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

App benchmark per iOS

Per eseguire benchmark su un dispositivo iOS, devi creare l'app dal codice sorgente. Inserisci il file del modello LiteRT nella directory benchmark_data dell'albero delle origini e modifica il file benchmark_params.json. Questi file vengono inseriti nel pacchetto dell'app e l'app legge i dati dalla directory. Visita l'app di benchmark per iOS per istruzioni dettagliate.

Benchmark del rendimento per modelli noti

Questa sezione elenca i benchmark delle prestazioni di LiteRT durante l'esecuzione di modelli noti su alcuni dispositivi Android e iOS.

Benchmark delle prestazioni di Android

Questi numeri di benchmark delle prestazioni sono stati generati con il file binario di benchmark nativo.

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

Suppone che i modelli siano stati scaricati e decompressi nella directory /data/local/tmp/tflite_models. Il programma binario di benchmark viene creato utilizzando 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 il delegato GPU, imposta --use_gpu=true.

I valori di rendimento riportati di seguito sono misurati su Android 10.

Benchmark del rendimento per iOS

Questi numeri di benchmark prestazionali sono stati generati con l'app di benchmark per iOS.

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

Elementi interni di Trace LiteRT

Tracciare i componenti interni di LiteRT in Android

Gli eventi interni dell'interprete LiteRT di un'app per Android possono essere acquisiti dagli strumenti di tracciamento Android. Si tratta degli stessi eventi dell'API Trace di Android, quindi gli eventi acquisiti dal codice Java/Kotlin vengono visualizzati insieme agli eventi interni di LiteRT.

Alcuni esempi di eventi sono:

• Chiamata all'operatore
• Modifica del grafico da parte del delegato
• Allocazione dei tensori

Tra le diverse opzioni per acquisire le tracce, questa guida tratta il Profiler CPU di Android Studio e l'app System Tracing. Per altre opzioni, consulta Strumento da riga di comando Perfetto o Strumento da riga di comando Systrace.

Aggiunta di eventi di traccia nel codice Java

Questo è uno snippet di codice dell'app di esempio Classificazione delle immagini. L'interprete LiteRT viene eseguito nella sezione recognizeImage/runInference. Questo passaggio è facoltativo, ma è utile per aiutare a notare 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();

Abilitare il tracciamento LiteRT

Per attivare la tracciabilità LiteRT, imposta la proprietà di sistema Android debug.tflite.trace su 1 prima di avviare l'app Android.

adb shell setprop debug.tflite.trace 1

Se questa proprietà è stata impostata durante l'inizializzazione dell'interprete LiteRT, verranno tracciati gli eventi chiave (ad es. l'invocazione dell'operatore) dell'interprete.

Dopo aver acquisito tutte le tracce, disattiva la tracciatura impostando il valore della proprietà su 0.

adb shell setprop debug.tflite.trace 0

CPU Profiler di Android Studio

Acquisisci le tracce con Android Studio CPU Profiler seguendo questi passaggi:

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

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

3. Seleziona "Trace System Calls" (Traccia chiamate di sistema) tra le modalità di profilazione della CPU.

   

4. Premi il pulsante "Registra".

5. Premi il pulsante "Interrompi".

6. Esamina il risultato della traccia.

   

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

App Tracciamento del sistema

Acquisisci tracce senza Android Studio seguendo i passaggi descritti nell'app System Tracing.

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

Tracciare i componenti interni di LiteRT in iOS

Gli eventi interni dell'interprete LiteRT di un'app per iOS possono essere acquisiti dallo strumento Instruments incluso in Xcode. Si tratta degli eventi signpost iOS, quindi gli eventi acquisiti dal codice Swift/Objective-C vengono visualizzati insieme agli eventi interni di LiteRT.

Alcuni esempi di eventi sono:

• Chiamata all'operatore
• Modifica del grafico da parte del delegato
• Allocazione dei tensori

Abilitare il tracciamento LiteRT

Imposta la variabile di ambiente debug.tflite.trace seguendo i passaggi riportati di seguito:

1. Seleziona Product > Scheme > Edit Scheme… (Prodotto > Schema > Modifica schema…) dai menu in alto di Xcode.

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

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

4. Aggiungi debug.tflite.trace nella sezione "Variabili di ambiente".

   

Se vuoi escludere gli eventi LiteRT durante la profilazione dell'app per iOS, disattiva la tracciatura rimuovendo la variabile di ambiente.

XCode Instruments

Acquisisci le tracce seguendo i passaggi riportati di seguito:

1. Seleziona Product > Profile (Prodotto > Profilo) dai menu in alto di Xcode.

2. Fai clic su Registrazione tra i modelli di profilazione all'avvio dello strumento Instruments.

3. Premi il pulsante "Avvia".

4. Premi il pulsante "Interrompi".

5. Fai clic su "os_signpost" per espandere gli elementi del sottosistema di logging del sistema operativo.

6. Fai clic sul sottosistema di logging del sistema operativo "org.tensorflow.lite".

7. Esamina il risultato della traccia.

   

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

Utilizzo dei dati di tracciamento

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

Ecco alcuni esempi di approfondimenti che puoi ottenere dal profiler e potenziali soluzioni per migliorare le prestazioni:

• Se il numero di core CPU disponibili è inferiore al numero di thread di inferenza, il sovraccarico di pianificazione della CPU può comportare prestazioni scadenti. Puoi riprogrammare altre attività che utilizzano molta CPU nella tua applicazione per evitare sovrapposizioni con l'inferenza del modello o modificare il numero di thread dell'interprete.
• Se gli operatori non sono completamente delegati, alcune parti del grafico del modello vengono eseguite sulla CPU anziché sull'acceleratore hardware previsto. Puoi sostituire gli operatori non supportati con operatori supportati simili.