Sehen Sie sich Keynotes, Produktsitzungen, Workshops und mehr in Google I / O an. Siehe Wiedergabeliste

Leistungsmessung

Benchmark-Tools

Die TensorFlow Lite-Benchmark-Tools messen und berechnen derzeit Statistiken für die folgenden wichtigen Leistungsmetriken:

  • Initialisierungszeit
  • Inferenzzeit des Aufwärmzustands
  • Inferenzzeit des stationären Zustands
  • Speichernutzung während der Initialisierungszeit
  • Gesamte Speichernutzung

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

Android Benchmark App

Es gibt zwei Möglichkeiten, das Benchmark-Tool mit Android zu verwenden. Eine ist eine native Benchmark-Binärdatei und eine andere ist eine Android-Benchmark-App, mit der die Leistung des Modells in der App besser beurteilt werden kann. In beiden Fällen unterscheiden sich die Zahlen aus dem Benchmark-Tool immer noch geringfügig von denen, die auf das Modell in der tatsächlichen App schließen.

Diese Android-Benchmark-App hat keine Benutzeroberfläche. Installieren und führen Sie es mit dem Befehl adb und adb logcat Ergebnisse mit dem Befehl adb logcat .

Laden Sie die App herunter oder erstellen Sie sie

Laden Sie die nächtlichen vorgefertigten Android-Benchmark-Apps über die folgenden Links herunter:

Verwenden Sie für Android-Benchmark-Apps, die TF-Operationen über Flex Delegate unterstützen , die folgenden Links:

Sie können die App auch aus dem Quellcode erstellen, indem Sie diese Anweisungen befolgen .

Benchmark vorbereiten

Installieren Sie die App, bevor Sie die Benchmark-App ausführen, und übertragen Sie die Modelldatei wie folgt 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 für die Ausführung des Benchmarks angeben.

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

Je nachdem, welches Gerät Sie verwenden, sind einige dieser Optionen möglicherweise nicht verfügbar oder haben keine Auswirkung. Siehe Parameter für mehr Performance - Parameter , die Sie mit dem Benchmark - App laufen können.

logcat die Ergebnisse mit dem Befehl logcat :

adb logcat | grep "Average inference"

Die Benchmark-Ergebnisse werden wie folgt angegeben:

... tflite  : Average inference timings in us: Warmup: 91471, Init: 4108, Inference: 80660.1

Native Benchmark-Binärdatei

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

Laden Sie die Binärdatei herunter oder erstellen Sie sie

Laden Sie die nächtlichen vorgefertigten nativen Befehlszeilen-Binärdateien herunter, indem Sie den folgenden Links folgen:

Verwenden Sie für nächtliche vorgefertigte Binärdateien, die TF-Operationen über Flex-Delegate unterstützen , die folgenden Links:

Sie können die native Benchmark-Binärdatei auch aus der Quelle auf Ihrem Computer erstellen.

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

Um mit der Android NDK-Toolchain zu erstellen, müssen Sie zuerst die Build-Umgebung einrichten, indem Sie diesem Handbuch folgen, oder das Docker-Image wie in diesem Handbuch beschrieben verwenden .

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

Benchmark ausführen

Führen Sie die Binärdatei über die Shell aus, um Benchmarks auf Ihrem Computer auszuführen.

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

Sie können denselben Parametersatz wie oben für die native Befehlszeilen-Binärdatei verwenden.

Profiling Model Ops

Mit der Benchmark-Modell-Binärdatei können Sie auch Modelloperationen profilieren und die Ausführungszeiten der einzelnen Operatoren abrufen. --enable_op_profiling=true Sie dazu das Flag --enable_op_profiling=true während des --enable_op_profiling=true an benchmark_model . Details werden hier erklärt.

Native Benchmark-Binärdatei für mehrere Leistungsoptionen in einem Durchgang

Eine praktische und einfache C ++ - Binärdatei wird ebenfalls bereitgestellt, um mehrere Leistungsoptionen in einem einzigen Durchgang zu vergleichen. Diese Binärdatei basiert auf dem oben genannten Benchmark-Tool, mit dem jeweils nur eine Leistungsoption bewertet werden kann. Sie verwenden denselben Build / Install / Run-Prozess, aber der BUILD-Zielname dieser Binärdatei lautet benchmark_model_performance_options und erfordert einige zusätzliche Parameter. Ein wichtiger Parameter für diese Binärdatei ist:

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

Sie können nächtliche vorgefertigte Binärdateien für dieses Tool erhalten, wie unten aufgeführt:

iOS Benchmark App

Um Benchmarks auf einem iOS-Gerät auszuführen, müssen Sie die App aus dem Quellcode erstellen. Legen Sie die TensorFlow Lite-Modelldatei im Verzeichnis Benchmark_Data des Quellbaums ab und ändern Sie die Datei benchmark_params.json . Diese Dateien werden in die App gepackt und die App liest Daten aus dem Verzeichnis. Besuchen Sie die iOS-Benchmark-App, um detaillierte Anweisungen zu erhalten.

Leistungsbenchmarks für bekannte Modelle

In diesem Abschnitt werden die Leistungsbenchmarks von TensorFlow Lite aufgeführt, wenn bekannte Modelle auf einigen Android- und iOS-Geräten ausgeführt werden.

Android-Leistungsbenchmarks

Diese Performance-Benchmark-Zahlen wurden mit der nativen Benchmark-Binärdatei generiert.

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

Es wird davon ausgegangen, dass Modelle heruntergeladen und in das Verzeichnis /data/local/tmp/tflite_models . Die Benchmark-Binärdatei wird anhand dieser Anweisungen erstellt und befindet sich im Verzeichnis /data/local/tmp .

So führen Sie den Benchmark durch:

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

Um mit nnapi delegate ausgeführt zu werden, setzen Sie --use_nnapi=true . Um mit dem GPU-Delegaten ausgeführt zu werden, setzen Sie --use_gpu=true .

Die folgenden Leistungswerte werden unter Android 10 gemessen.

Modellname Gerät CPU, 4 Threads GPU NNAPI
Mobilenet_1.0_224 (float) Pixel 3 23,9 ms 6,45 ms 13,8 ms
Pixel 4 14,0 ms 9,0 ms 14,8 ms
Mobilenet_1.0_224 (quant) Pixel 3 13,4 ms --- ---. 6,0 ms
Pixel 4 5,0 ms --- ---. 3,2 ms
NASNet-Handy Pixel 3 56 ms --- ---. 102 ms
Pixel 4 34,5 ms --- ---. 99,0 ms
SqueezeNet Pixel 3 35,8 ms 9,5 ms 18,5 ms
Pixel 4 23,9 ms 11,1 ms 19,0 ms
Inception_ResNet_V2 Pixel 3 422 ms 99,8 ms 201 ms
Pixel 4 272,6 ms 87,2 ms 171,1 ms
Inception_V4 Pixel 3 486 ms 93 ms 292 ms
Pixel 4 324,1 ms 97,6 ms 186,9 ms

iOS-Leistungsbenchmarks

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

Um iOS-Benchmarks auszuführen, wurde die Benchmark-App so geändert, dass sie das entsprechende Modell enthält, und benchmark_params.json wurde geändert, um num_threads auf 2 zu setzen. Um den GPU-Delegaten zu verwenden, waren "use_gpu" : "1" und "gpu_wait_type" : "aggressive" Optionen wurde 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-Handy 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

Verfolgen Sie TensorFlow Lite-Interna in Android

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

Einige Beispiele für Ereignisse sind:

  • Aufruf des Bedieners
  • Diagrammänderung durch Delegierten
  • Tensorzuordnung

Neben verschiedenen Optionen zum Erfassen von Traces behandelt dieses Handbuch den Android Studio CPU Profiler und die System Tracing-App. Weitere Optionen finden Sie unter Perfetto-Befehlszeilentool oder Systrace-Befehlszeilentool .

Hinzufügen von Ablaufverfolgungsereignissen in Java-Code

Dies ist ein Codeausschnitt aus der Bildklassifizierung Beispiel - App. Der TensorFlow Lite-Interpreter wird im Abschnitt recognizeImage/runInference . Dieser Schritt ist optional, aber es ist hilfreich 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();

Aktivieren Sie die TensorFlow Lite-Ablaufverfolgung

Um die TensorFlow Lite-Ablaufverfolgung zu aktivieren, setzen Sie die Android-Systemeigenschaft debug.tflite.tracing auf 1, bevor Sie die Android-App starten.

adb shell setprop debug.tflite.trace 1

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

Nachdem Sie alle Traces erfasst haben, deaktivieren Sie die Tracing-Funktion, indem Sie den Eigenschaftswert auf 0 setzen.

adb shell setprop debug.tflite.trace 0

Android Studio CPU Profiler

Erfassen Sie Traces mit dem Android Studio CPU Profiler, indem Sie die folgenden Schritte ausführen:

  1. Wählen Sie " Ausführen"> "Profil-App" aus den oberen Menüs.

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

  3. Wählen Sie unter den CPU-Profilierungsmodi die Option "Systemaufrufe verfolgen".

    Wählen Sie "Systemaufrufe verfolgen".

  4. Drücken Sie die 'Aufnahme'-Taste.

  5. Drücken Sie die Stopp-Taste.

  6. Untersuchen Sie das Trace-Ergebnis.

    Android Studio Trace

In diesem Beispiel können Sie die Hierarchie der Ereignisse in einem Thread und die Statistiken für jede Bedienerzeit sowie den Datenfluss der gesamten App zwischen den Threads anzeigen.

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 Version des Android-Geräts im Perfetto- oder Systrace-Format gespeichert. Die erfassten Trace-Dateien können in der Perfetto-Benutzeroberfläche geöffnet werden.

Perfetto-Spur

Verwenden der Ablaufverfolgungsdaten

Mit den Ablaufverfolgungsdaten können Sie Leistungsengpässe identifizieren.

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

  • Wenn die Anzahl der verfügbaren CPU-Kerne kleiner als die Anzahl der Inferenz-Threads ist, kann der CPU-Planungsaufwand zu einer unterdurchschnittlichen Leistung führen. Sie können andere CPU-intensive Aufgaben in Ihrer Anwendung neu planen, um Überschneidungen mit Ihrer Modellinferenz zu vermeiden oder die Anzahl der Interpreter-Threads zu optimieren.
  • Wenn die Operatoren nicht vollständig delegiert sind, werden einige Teile des Modellgraphen 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.