Strumenti di benchmark
Gli strumenti di benchmark di TensorFlow Lite attualmente misurano e calcolano statistiche per le seguenti importanti metriche sulle prestazioni:
- Tempo di inizializzazione
- Tempo di inferenza dello stato di riscaldamento
- Tempo di inferenza dello stato stazionario
- Memoria utilizzata durante il tempo di inizializzazione
- Utilizzo complessivo della memoria
Gli strumenti di benchmark sono disponibili come app di benchmark per Android e iOS e come programmi binari a riga di comando nativi e condividono tutti la stessa logica di misurazione delle prestazioni di base. Tieni presente che le opzioni e i formati di output disponibili sono leggermente diversi a causa delle differenze nell'ambiente di runtime.
App di benchmark per Android
Con Android hai a disposizione due opzioni per utilizzare lo strumento di benchmark. Uno è un binario di benchmark nativo e l'altro un'app di benchmark per Android, che indica meglio il rendimento del modello nell'app. In ogni caso, i valori dello strumento di benchmark saranno leggermente diversi da quelli dell'inferenza eseguita con il modello nell'app effettiva.
Questa app benchmark per Android non ha UI. Installa ed eseguilo utilizzando il comando adb e recupera i risultati con il comando adb logcat.
Scaricare o creare l'app
Scarica le app di benchmark predefinite per Android durante la notte utilizzando i link di seguito:
Per quanto riguarda le app di benchmark per Android che supportano operazioni TF tramite delegato Flex, utilizza i link di seguito:
Puoi anche creare l'app dal codice sorgente seguendo queste instructions.
Prepara benchmark
Prima di eseguire l'app di benchmark, installa l'app ed esegui il push del 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(predefinito=1)
Il numero di thread da utilizzare per eseguire l'interprete TFLite.use_gpu:bool(predefinito=false)
Utilizza Delega GPU.use_xnnpack:bool(predefinito=false)
Utilizza Delegato NPNPACK.
A seconda del dispositivo utilizzato, alcune di queste opzioni potrebbero non essere disponibili o non avere effetto. Consulta la sezione 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 di benchmark sono riportati come:
... tflite : Inference timings in us: Init: 5685, First inference: 18535, Warmup (avg): 14462.3, Inference (avg): 14575.2
Programma binario di benchmark nativo
Lo strumento di benchmark è fornito anche come file binario nativo benchmark_model. Puoi eseguire questo strumento dalla riga di comando della shell su Linux, Mac, dispositivi incorporati e dispositivi Android.
Scarica o crea il programma binario
Scarica i programmi binari della riga di comando nativi predefiniti per la notte seguendo i link riportati di seguito:
Per quanto riguarda i programmi binari predefiniti di notte che supportano le operazioni TF tramite delegato Flex, utilizza i link di seguito:
Puoi anche creare il programma binario di benchmark nativo dal sito source sul tuo computer.
bazel build -c opt //tensorflow/lite/tools/benchmark:benchmark_model
Per creare con la toolchain NDK di Android, devi prima configurare l'ambiente di compilazione seguendo questa guida oppure utilizzare l'immagine Docker come descritto in questa guida.
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 set di parametri indicato sopra con il programma binario nativo della riga di comando.
Profilazione delle operazioni del modello
Il programma binario del modello di benchmark consente inoltre di profilare le operazioni del modello e di ottenere i tempi di esecuzione di ciascun operatore. Per farlo, passa il flag --enable_op_profiling=true a benchmark_model durante la chiamata. I dettagli sono illustrati qui.
Programma binario nativo di benchmark per più opzioni di rendimento in una sola esecuzione
Viene inoltre fornito un programma binario C++ pratico e semplice per
eseguire il benchmark di più opzioni di prestazioni
in una singola esecuzione. Questo programma binario è basato sullo strumento di benchmark precedentemente indicato, in grado di eseguire il benchmark di una sola opzione di prestazioni alla volta. Condividono lo
stesso processo di build/installazione/esecuzione, ma il nome della destinazione Build di questo programma binario è
benchmark_model_performance_options e richiede alcuni parametri aggiuntivi.
Un parametro importante per questo programma binario è:
perf_options_list: string (predefinito='all')
Un elenco separato da virgole di opzioni di rendimento TFLite da confrontare.
Puoi ottenere programmi binari predefiniti di notte per questo strumento come elencato di seguito:
App di benchmark per iOS
Per eseguire benchmark su un dispositivo iOS, devi creare l'app dall'origine.
Inserisci il file del modello TensorFlow Lite nella directory
benchmark_data
dell'albero di origine e modifica il file benchmark_params.json. Questi file vengono pacchettizzati nell'app, che legge i dati dalla directory. Per istruzioni dettagliate, visita
l'app di benchmark per iOS.
Benchmark delle prestazioni per modelli noti
Questa sezione elenca i benchmark delle prestazioni di TensorFlow Lite per l'esecuzione di modelli più noti su alcuni dispositivi Android e iOS.
Benchmark di rendimento Android
Questi valori di benchmark delle prestazioni sono stati generati con il programma binario di benchmark nativo.
Per i benchmark di Android, l'affinità della CPU è impostata per utilizzare core di grandi dimensioni sul dispositivo al fine di ridurre la varianza (vedi i dettagli).
Presuppone 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 delega GPU, imposta --use_gpu=true.
I valori relativi al rendimento riportati di seguito sono misurati su Android 10.
| Nome modello | Dispositivo | CPU, 4 thread | GPU |
|---|---|---|---|
| Mobilenet_1.0_224(float) | Pixel 3 | 23,9 ms | 6,45 ms |
| Pixel 4 | 14,0 ms | 9,0 ms | |
| Mobilenet_1.0_224 (quant) | Pixel 3 | 13,4 ms | --- |
| Pixel 4 | 5,0 ms | --- | |
| NASNet per dispositivi mobili | Pixel 3 | 56 ms | --- |
| Pixel 4 | 34,5 ms | --- | |
| SqueezeNet | Pixel 3 | 35,8 ms | 9,5 ms |
| Pixel 4 | 23,9 ms | 11,1 ms | |
| Inception_ResNet_V2 | Pixel 3 | 422 ms | 99,8 ms |
| Pixel 4 | 272,6 ms | 87,2 ms | |
| Inception_V4 | Pixel 3 | 486 ms | 93 ms |
| Pixel 4 | 324,1 ms | 97,6 ms |
Benchmark di rendimento iOS
Questi valori di benchmark delle prestazioni sono stati generati con l'app di benchmark per iOS.
Per eseguire i benchmark per iOS, l'app di benchmark è stata modificata in modo da includere il modello appropriato e benchmark_params.json è stato modificato per 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.
| Nome modello | Dispositivo | CPU, 2 thread | GPU |
|---|---|---|---|
| Mobilenet_1.0_224(float) | iPhone XS | 14,8 ms | 3,4 ms |
| Mobilenet_1.0_224 (quant) | iPhone XS | 11 ms | --- |
| NASNet per dispositivi mobili | iPhone XS | 30,4 ms | --- |
| SqueezeNet | iPhone XS | 21,1 ms | 15,5 ms |
| Inception_ResNet_V2 | iPhone XS | 261,1 ms | 45,7 ms |
| Inception_V4 | iPhone XS | 309 ms | 54,4 ms |
Elementi interni di Trace TensorFlow Lite
Trace TensorFlow Lite interno in Android
Gli eventi interni dell'interprete TensorFlow Lite di un'app per Android possono essere acquisiti dagli strumenti di tracciamento Android. Si tratta degli stessi eventi dell'API Android Trace, pertanto gli eventi acquisiti dal codice Java/Kotlin vengono visualizzati insieme agli eventi interni di TensorFlow Lite.
Ecco alcuni esempi di eventi:
- Chiamata operatore
- Modifica del grafico da parte del delegato
- Allocazione dei tensori
Tra le diverse opzioni disponibili per l'acquisizione delle tracce, questa guida illustra il Profiler CPU di Android Studio e l'app System Tracciamento. Per altre opzioni, fai riferimento allo strumento a riga di comando Perfetto o allo strumento a riga di comando di Systrace.
Aggiunta di eventi di traccia nel codice Java
Questo è uno snippet di codice dell'app di esempio Classificazione delle immagini. L'interprete di TensorFlow Lite viene eseguito nella sezione recognizeImage/runInference. Questo passaggio è facoltativo, ma è utile
per capire 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();
Abilita il tracciamento di TensorFlow Lite
Per abilitare il tracciamento di TensorFlow Lite, imposta la proprietà di sistema di Android
debug.tflite.trace su 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 di TensorFlow Lite, verranno tracciati gli eventi chiave (ad es. la chiamata dell'operatore).
Dopo aver acquisito tutte le tracce, disabilita il tracciamento impostando il valore della proprietà su 0.
adb shell setprop debug.tflite.trace 0
Profiler CPU di Android Studio
Acquisisci le tracce con lo strumento Profilo CPU di Android Studio seguendo i passaggi riportati di seguito:
Seleziona Esegui > Profilo "app" dai menu in alto.
Fai clic in un punto qualsiasi della sequenza temporale della CPU quando viene visualizzata la finestra Profiler.
Seleziona "Trace System Calls" (Traccia chiamate di sistema) tra le modalità di profilazione della CPU.
Premi il pulsante "Registra".
Premi il pulsante "Interrompi".
Analizza il risultato della traccia.
In questo esempio, puoi visualizzare la gerarchia degli eventi in un thread e le statistiche per l'ora di ogni operatore e anche il flusso di dati dell'intera app tra i thread.
App di tracciamento del sistema
Acquisisci tracce senza Android Studio seguendo i passaggi descritti in App di tracciamento del sistema.
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 nell'UI di Perfetto.
Trace TensorFlow Lite interno in iOS
Gli eventi interni dell'interprete TensorFlow Lite di un'app per iOS possono essere acquisiti dallo strumento Instruments incluso in Xcode. Sono gli eventi signpost di iOS, quindi gli eventi acquisiti dal codice Swift/Objective-C vengono visualizzati insieme agli eventi interni di TensorFlow Lite.
Ecco alcuni esempi di eventi:
- Chiamata operatore
- Modifica del grafico da parte del delegato
- Allocazione dei tensori
Abilita il tracciamento di TensorFlow Lite
Imposta la variabile di ambiente debug.tflite.trace seguendo questi passaggi:
Seleziona Prodotto > Schema > Modifica schema... dai menu in alto di Xcode.
Fai clic su "Profilo" nel riquadro a sinistra.
Deseleziona la casella di controllo "Utilizza gli argomenti e le variabili di ambiente dell'azione Esegui".
Aggiungi
debug.tflite.tracenella sezione "Variabili di ambiente".
Se vuoi escludere gli eventi TensorFlow Lite durante la profilazione dell'app per iOS, disabilita il tracciamento rimuovendo la variabile di ambiente.
Strumenti XCode
Per acquisire le tracce, segui questi passaggi:
Seleziona Prodotto > Profilo dai menu in alto di Xcode.
All'avvio dello strumento Strumenti, fai clic su Logging tra i modelli di profilazione.
Premi il pulsante "Avvia".
Premi il pulsante "Interrompi".
Fai clic su "os_signpost" per espandere gli elementi del sottosistema OS Logging.
Fai clic sul sottosistema OS Logging "org.tensorflow.lite".
Analizza il risultato della traccia.
In questo esempio, puoi visualizzare la gerarchia di eventi e statistiche per ogni orario dell'operatore.
Utilizzo dei dati di tracciamento
I dati di tracciamento consentono di identificare i colli di bottiglia delle prestazioni.
Di seguito sono riportati alcuni esempi di insight che puoi ottenere dal profiler e potenziali soluzioni per migliorare le prestazioni:
- Se il numero di core della CPU disponibili è inferiore al numero di thread di inferenza, l'overhead di pianificazione della CPU può portare a prestazioni mediocre. Puoi riprogrammare altre attività che consumano molta CPU nell'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.