Leistungsmessung

Benchmarking-Tools

TensorFlow Lite-Benchmarktools messen und berechnen derzeit Statistiken für die folgenden wichtigen Leistungsmesswerte:

• Initialisierungszeit
• Inferenzzeit des Aufwärmstatus
• Inferenzzeit des stabilen Zustands
• Arbeitsspeichernutzung während der Initialisierungszeit
• Arbeitsspeichernutzung insgesamt

Die Benchmark-Tools sind als Benchmark-Apps für Android und iOS sowie als native Befehlszeilen-Binärdateien verfügbar. Sie verwenden alle dieselbe Logik zur zentralen Leistungsmessung. Beachten Sie, dass sich die verfügbaren Optionen und Ausgabeformate aufgrund der Unterschiede in der Laufzeitumgebung leicht unterscheiden.

Android-Benchmark-App

Es gibt zwei Möglichkeiten, das Benchmark-Tool unter Android zu verwenden. Eine ist ein natives Benchmark-Binärprogramm und eine andere eine Android-Benchmark-App, mit der besser bewertet wird, wie das Modell in der App abschneiden würde. In jedem Fall weichen die Zahlen vom Benchmark-Tool leicht von denen im Fall einer Inferenz mit dem Modell in der tatsächlichen App ab.

Diese Android-Benchmark-App hat keine Benutzeroberfläche. Installieren und führen Sie ihn mit dem Befehl adb aus und rufen Sie mit dem Befehl adb logcat die Ergebnisse ab.

App herunterladen oder erstellen

Laden Sie die vordefinierten Android-Benchmark-Apps über die folgenden Links herunter:

• android_aarch64
• android_arm

Android-Benchmark-Apps, die TF-Ops über den Flex-Delegaten unterstützen, finden Sie unter den folgenden Links:

• android_aarch64
• android_arm

Sie können die Anwendung auch aus dem Quellcode erstellen, indem Sie instructions folgen.

Benchmark vorbereiten

Bevor Sie die Benchmark-App ausführen, installieren Sie sie und übertragen Sie die Modelldatei so auf das Gerät:

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

Benchmark ausführen

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

graph ist ein erforderlicher Parameter.

• graph: string
  Der Pfad zur TFLite-Modelldatei.

Sie können weitere optionale Parameter zum Ausführen der Benchmark angeben.

• num_threads: int (Standard=1)
  Die Anzahl der Threads, die zum Ausführen des TFLite-Interpreters verwendet werden sollen.
• use_gpu: bool (Standard=falsch)
  Verwenden Sie den GPU-Delegaten.
• use_xnnpack: bool (Standard=false)
  Verwenden Sie den XNNPACK-Delegaten.

Je nach verwendetem Gerät sind einige dieser Optionen möglicherweise nicht verfügbar oder haben keine Auswirkungen. Unter Parameter finden Sie weitere Leistungsparameter, die Sie mit der Benchmark-App ausführen können.

Sehen Sie sich die Ergebnisse mit dem Befehl logcat an:

adb logcat | grep "Inference timings"

Die Benchmark-Ergebnisse werden so erfasst:

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

Natives Benchmark-Binärprogramm

Das Benchmark-Tool wird auch als natives binäres benchmark_model-Tool bereitgestellt. Sie können dieses Tool über eine Shell-Befehlszeile auf Linux- und Mac-Geräten, eingebetteten Geräten und Android-Geräten ausführen.

Binärprogramm herunterladen oder erstellen

Klicken Sie auf die folgenden Links, um die nächtlichen vordefinierten nativen Befehlszeilen-Binärdateien herunterzuladen:

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

Für nächtliche vordefinierte Binärdateien, die TF-Ops über den Flex-Delegaten unterstützen, verwenden Sie die folgenden Links:

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

Sie können das native Benchmark-Binärprogramm auch aus einer Quelle auf Ihrem Computer erstellen.

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

Wenn Sie Builds mit der Android-NDK-Toolchain erstellen möchten, müssen Sie zuerst die Build-Umgebung einrichten. Folgen Sie dazu dieser Anleitung oder verwenden Sie das Docker-Image wie in dieser Anleitung beschrieben.

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

Benchmark ausführen

Um Benchmarks auf Ihrem Computer auszuführen, führen Sie das Binärprogramm über die Shell aus.

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

Sie können die oben genannten Parameter mit dem nativen Befehlszeilen-Binärprogramm verwenden.

Profilerstellung für Modellvorgänge

Mit dem Binärmodell des Benchmarkmodells können Sie außerdem ein Profil von Modellvorgängen erstellen und die Ausführungszeiten jedes Operators abrufen. Übergeben Sie dazu beim Aufruf das Flag --enable_op_profiling=true an benchmark_model. Weitere Informationen

Natives Benchmark-Binärprogramm für mehrere Leistungsoptionen bei einer einzigen Ausführung

Außerdem wird eine praktische und einfache C++-Binärdatei bereitgestellt, um mehrere Leistungsoptionen in einem einzigen Durchlauf zu vergleichen. Dieses Binärprogramm basiert auf dem oben genannten Benchmark-Tool, das jeweils nur eine einzige Leistungsoption für das Benchmarking verwenden konnte. Sie verwenden denselben Build-/Installations-/Ausführungsprozess, aber der build-Zielname dieser Binärdatei lautet benchmark_model_performance_options und es sind einige zusätzliche Parameter erforderlich. Ein wichtiger Parameter für diese Binärdatei ist:

perf_options_list: string (default='all')
Eine durch Kommas getrennte Liste von TFLite-Leistungsoptionen für das Benchmarking.

Sie können für dieses Tool vorgefertigte Binärprogramme für Nachtaufnahmen abrufen, wie unten aufgeführt:

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

iOS-Benchmark-App

Zum Ausführen von Benchmarks auf einem iOS-Gerät müssen Sie die App aus der Quelle erstellen. Legen Sie die TensorFlow Lite-Modelldatei im Verzeichnis benchmark_data der Quellstruktur ab und ändern Sie die Datei benchmark_params.json. Diese Dateien werden in die Anwendung gepackt und die Anwendung liest Daten aus dem Verzeichnis. Eine ausführliche Anleitung finden Sie in der Benchmark-App für iOS.

Leistungs-Benchmarks für bekannte Modelle

In diesem Abschnitt sind die TensorFlow Lite-Leistungs-Benchmarks für die Ausführung bekannter Modelle auf einigen Android- und iOS-Geräten aufgeführt.

Android-Leistungs-Benchmarks

Diese Leistungsvergleichszahlen wurden mit dem nativen Benchmark-Binärprogramm generiert.

Bei Android-Benchmarks ist die CPU-Affinität so eingestellt, dass auf dem Gerät große Kerne verwendet werden, um die Varianz zu reduzieren (siehe Details).

Dabei wird davon ausgegangen, dass Modelle heruntergeladen und in das Verzeichnis /data/local/tmp/tflite_models entpackt wurden. Die Benchmark-Binärdatei wird mit dieser Anleitung erstellt und geht davon aus, dass sie sich im Verzeichnis /data/local/tmp befindet.

So führen Sie die Benchmark aus:

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

Legen Sie --use_gpu=true für die Ausführung mit dem GPU-Delegaten fest.

Die unten aufgeführten Leistungswerte werden unter Android 10 gemessen.

Modellname	Gerät	CPU, 4 Threads	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 Mobile	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

iOS-Leistungs-Benchmarks

Diese Leistungsvergleichszahlen wurden mit der iOS-Benchmark-App generiert.

Zum Ausführen von iOS-Benchmarks wurde die Benchmark-App geändert, sodass sie das entsprechende Modell enthält, und benchmark_params.json wurde geändert, um num_threads auf 2 zu setzen. Zur Verwendung des GPU-Delegaten wurden die Optionen "use_gpu" : "1" und "gpu_wait_type" : "aggressive" auch zu benchmark_params.json hinzugefügt.

Modellname	Gerät	CPU, 2 Threads	GPU
Mobilenet_1.0_224(float)	iPhone XS	14,8 ms	3,4 ms
Mobilenet_1.0_224 (Quant)	iPhone XS	11 ms	---
NASNet Mobile	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

TensorFlow Lite-Internes verfolgen

TensorFlow Lite-Internes in Android verfolgen

Interne Ereignisse vom TensorFlow Lite-Interpreter einer Android-App können von Android-Tracing-Tools erfasst werden. Es handelt sich um dieselben Ereignisse mit der Android Trace API, sodass die aus Java-/Kotlin-Code erfassten Ereignisse zusammen mit den internen TensorFlow Lite-Ereignissen angezeigt werden.

Hier einige Beispiele für Ereignisse:

• Operatoraufruf
• Diagrammänderung durch Bevollmächtigten
• Tensor-Zuweisung

In dieser Anleitung werden unter anderem der CPU-Profiler von Android Studio und die App „System Tracing“ behandelt. Weitere Optionen finden Sie unter Perfetto-Befehlszeilentool und Systrace-Befehlszeilentool.

Trace-Ereignisse in Java-Code hinzufügen

Dies ist ein Code-Snippet aus der Beispielanwendung für die Bildklassifizierung. Der TensorFlow Lite-Interpreter wird im Abschnitt recognizeImage/runInference ausgeführt. Dieser Schritt ist optional, aber es hilft zu erkennen, wo der Inferenzaufruf erfolgt.

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

TensorFlow Lite-Tracing aktivieren

Um TensorFlow Lite-Tracing zu aktivieren, legen Sie die Android-Systemeigenschaft debug.tflite.trace auf 1 fest, bevor Sie die Android-App starten.

adb shell setprop debug.tflite.trace 1

Wenn dieses Attribut bei der Initialisierung des TensorFlow Lite-Interpreters festgelegt wurde, werden Schlüsselereignisse (z.B. Operatoraufruf) vom Interpreter verfolgt.

Wenn Sie alle Traces erfasst haben, deaktivieren Sie das Tracing. Dazu setzen Sie den Attributwert auf 0.

adb shell setprop debug.tflite.trace 0

CPU-Profiler von Android Studio

So erfassen Sie Traces mit dem Android Studio CPU Profiler:

1. Wählen Sie in den oberen Menüs Ausführen > Profil 'app' aus.

2. Klicken Sie auf eine beliebige Stelle auf der CPU-Zeitachse, wenn das Profiler-Fenster angezeigt wird.

3. Wählen Sie als CPU-Profilerstellung die Option „Trace System Calls“ (Systemaufrufe verfolgen) aus.

   

4. Drücke auf die Schaltfläche „Aufnehmen“.

5. Drücken Sie die Schaltfläche „Stopp“.

6. Untersuchen Sie das Trace-Ergebnis.

   

In diesem Beispiel sehen Sie die Hierarchie der Ereignisse in einem Thread und Statistiken für jede Operatorzeit sowie den Datenfluss der gesamten Anwendung zwischen den Threads.

System-Tracing-App

Erfassen Sie Traces ohne Android Studio, indem Sie die in der System Tracing-App beschriebenen Schritte ausführen.

In diesem Beispiel wurden dieselben TFLite-Ereignisse erfasst und je nach Android-Version im Perfetto- oder Systrace-Format gespeichert. Die erfassten Trace-Dateien können in der Perfetto-UI geöffnet werden.

TensorFlow Lite-Internes unter iOS verfolgen

Interne Ereignisse vom TensorFlow Lite-Interpreter einer iOS-App können vom Instruments-Tool erfasst werden, das in Xcode enthalten ist. Es handelt sich um die iOS-Wegweiser-Ereignisse, sodass die erfassten Ereignisse aus dem Swift-/Objective-C-Code zusammen mit den internen TensorFlow Lite-Ereignissen angezeigt werden.

Hier einige Beispiele für Ereignisse:

• Operatoraufruf
• Diagrammänderung durch Bevollmächtigten
• Tensor-Zuweisung

TensorFlow Lite-Tracing aktivieren

Legen Sie die Umgebungsvariable debug.tflite.trace so fest:

1. Wählen Sie in den oberen Menüs von Xcode Produkt > Schema > Schema bearbeiten... aus.

2. Klicken Sie im linken Bereich auf „Profil“.

3. Heben Sie die Auswahl des Kästchens "Use the run action's argument's and Um variables" (Argumente und Umgebungsvariablen der Ausführungsaktion verwenden) auf.

4. Fügen Sie im Bereich „Umgebungsvariablen“ debug.tflite.trace hinzu.

   

Wenn Sie TensorFlow Lite-Ereignisse bei der Profilerstellung für die iOS-App ausschließen möchten, deaktivieren Sie das Tracing, indem Sie die Umgebungsvariable entfernen.

XCode-Instrumente

So erfassen Sie Traces:

1. Wählen Sie aus den oberen Menüs von Xcode Product > Profile (Produkt > Profil) aus.

2. Klicken Sie beim Starten des Tools „Instruments“ unter den Profilerstellungsvorlagen auf Logging.

3. Drücke auf die Schaltfläche „Start“.

4. Drücken Sie die Schaltfläche „Stopp“.

5. Klicken Sie auf „os_signpost“, um die Elemente des OS Logging-Subsystems zu maximieren.

6. Klicken Sie auf „org.tensorflow.lite“ OS Logging-Subsystem.

7. Untersuchen Sie das Trace-Ergebnis.

   

In diesem Beispiel sehen Sie die Hierarchie der Ereignisse und Statistiken für jede Operatorzeit.

Tracing-Daten verwenden

Die Nachverfolgungsdaten ermöglichen es Ihnen, Leistungsengpässe zu erkennen.

Hier sind einige Beispiele für Erkenntnisse, die Sie vom Profiler erhalten können, sowie mögliche Lösungen zur Leistungsverbesserung:

• Wenn die Anzahl der verfügbaren CPU-Kerne kleiner als die Anzahl der Inferenzthreads ist, kann der CPU-Planungsaufwand zu einer unterdurchschnittlichen Leistung führen. Sie können andere CPU-intensive Aufgaben in Ihrer Anwendung verschieben, um eine Überlappung mit der Modellinferenz zu vermeiden, oder die Anzahl der Interpreter-Threads optimieren.
• Wenn die Operatoren nicht vollständig delegiert sind, werden einige Teile der Modellgrafik auf der CPU und nicht auf dem erwarteten Hardwarebeschleuniger ausgeführt. Sie können die nicht unterstützten Operatoren durch ähnliche unterstützte Operatoren ersetzen.