Pomiar skuteczności

Narzędzia do testów porównawczych

Narzędzia porównawcze TensorFlow Lite obecnie mierzą i obliczają statystyki dla następujących ważnych wskaźników wydajności:

  • Czas inicjalizacji
  • Czas wnioskowania stanu rozgrzania
  • Czas wnioskowania stanu ustalonego
  • Użycie pamięci w czasie inicjalizacji
  • Ogólne wykorzystanie pamięci

Narzędzia do testów porównawczych są dostępne jako aplikacje testowe dla systemów Android i iOS oraz jako natywne pliki binarne wiersza poleceń i wszystkie mają tę samą podstawową logikę pomiaru wydajności. Należy pamiętać, że dostępne opcje i formaty wyjściowe są nieco inne ze względu na różnice w środowisku wykonawczym.

Aplikacja testowa na Androida

Istnieją dwie możliwości korzystania z narzędzia testowego w systemie Android. Jeden to natywny plik binarny testu porównawczego , a drugi to aplikacja testowa dla systemu Android, która pozwala lepiej ocenić działanie modelu w aplikacji. Tak czy inaczej, liczby z narzędzia porównawczego będą nadal nieznacznie różnić się od wyników wnioskowania na podstawie modelu w rzeczywistej aplikacji.

Ta aplikacja testowa dla systemu Android nie ma interfejsu użytkownika. Zainstaluj i uruchom go za pomocą polecenia adb i pobierz wyniki za pomocą polecenia adb logcat .

Pobierz lub utwórz aplikację

Pobierz gotowe aplikacje do testów porównawczych systemu Android dostępne co wieczór, korzystając z poniższych łączy:

Jeśli chodzi o aplikacje testowe dla systemu Android, które obsługują operacje TF za pośrednictwem delegata Flex , skorzystaj z poniższych łączy:

Możesz także zbudować aplikację ze źródła, postępując zgodnie z tymi instrukcjami .

Przygotuj benchmark

Przed uruchomieniem aplikacji testowej zainstaluj aplikację i wypchnij plik modelu na urządzenie w następujący sposób:

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

Uruchom 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 jest wymaganym parametrem.

  • graph : string
    Ścieżka do pliku modelu TFLite.

Można określić więcej opcjonalnych parametrów uruchamiania testu porównawczego.

  • num_threads : int (domyślnie=1)
    Liczba wątków używanych do uruchamiania interpretera TFLite.
  • use_gpu : bool (domyślnie = fałsz)
    Użyj delegata GPU .
  • use_nnapi : bool (domyślnie = fałsz)
    Użyj delegata NNAPI .
  • use_xnnpack : bool (domyślnie = false )
    Użyj delegata XNNPACK .
  • use_hexagon : bool (domyślnie = false )
    Użyj delegata Hexagon .

W zależności od używanego urządzenia niektóre z tych opcji mogą być niedostępne lub nie mieć żadnego efektu. Więcej parametrów wydajności, które można uruchomić w aplikacji testowej, można znaleźć w sekcji parametry.

Wyświetl wyniki za pomocą polecenia logcat :

adb logcat | grep "Inference timings"

Wyniki testów porównawczych są raportowane jako:

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

Natywny plik binarny benchmarku

Narzędzie Benchmark jest również dostępne jako natywny binarny benchmark_model . Możesz uruchomić to narzędzie z wiersza poleceń powłoki na systemach Linux, Mac, urządzeniach wbudowanych i urządzeniach z systemem Android.

Pobierz lub zbuduj plik binarny

Pobierz co wieczór gotowe, natywne pliki binarne wiersza poleceń, korzystając z poniższych łączy:

Jeśli chodzi o gotowe pliki binarne, które obsługują operacje TF za pośrednictwem delegata Flex , skorzystaj z poniższych łączy:

Aby przeprowadzić test porównawczy z delegatem TensorFlow Lite Hexagon , wstępnie zbudowaliśmy również wymagane pliki libhexagon_interface.so (szczegóły na temat tego pliku można znaleźć tutaj ). Po pobraniu pliku odpowiedniej platformy z poniższych łączy zmień nazwę pliku na libhexagon_interface.so .

Możesz także zbudować natywny plik binarny testu porównawczego ze źródła na swoim komputerze.

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

Aby budować za pomocą zestawu narzędzi Android NDK, musisz najpierw skonfigurować środowisko kompilacji, postępując zgodnie z tym przewodnikiem lub użyć obrazu okna dokowanego zgodnie z opisem w tym przewodniku .

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

Uruchom benchmark

Aby uruchomić testy porównawcze na swoim komputerze, uruchom plik binarny z powłoki.

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

Możesz użyć tego samego zestawu parametrów , jak wspomniano powyżej, w natywnym pliku binarnym wiersza poleceń.

Profilowanie operacji modelu

Binarny model porównawczy umożliwia także profilowanie operacji modelu i uzyskiwanie czasów wykonania każdego operatora. Aby to zrobić, podczas wywołania przekaż flagę --enable_op_profiling=true do benchmark_model . Szczegóły wyjaśniono tutaj .

Natywny plik binarny testu porównawczego dla wielu opcji wydajności w jednym przebiegu

Dostępny jest również wygodny i prosty plik binarny C++ umożliwiający porównanie wielu opcji wydajności w jednym przebiegu. Ten plik binarny jest zbudowany w oparciu o wyżej wymienione narzędzie testowe, które może testować tylko jedną opcję wydajności na raz. Dzielą ten sam proces kompilacji/instalacji/uruchamiania, ale docelowa nazwa BUILD tego pliku binarnego to benchmark_model_performance_options i wymaga kilku dodatkowych parametrów. Ważnym parametrem tego pliku binarnego jest:

perf_options_list : string (domyślnie='all')
Rozdzielana przecinkami lista opcji wydajności TFLite do porównania.

Możesz uzyskać co noc gotowe pliki binarne dla tego narzędzia, jak podano poniżej:

Aplikacja testowa na iOS

Aby uruchomić testy porównawcze na urządzeniu z systemem iOS, musisz zbudować aplikację ze źródła . Umieść plik modelu TensorFlow Lite w katalogu benchmark_data drzewa źródłowego i zmodyfikuj plik benchmark_params.json . Pliki te są pakowane w aplikację, która odczytuje dane z katalogu. Aby uzyskać szczegółowe instrukcje, odwiedź aplikację testową systemu iOS .

Testy porównawcze wydajności dla dobrze znanych modeli

W tej sekcji wymieniono testy wydajności TensorFlow Lite podczas uruchamiania dobrze znanych modeli na niektórych urządzeniach z Androidem i iOS.

Testy wydajności Androida

Te numery testów porównawczych wydajności zostały wygenerowane przy użyciu natywnego pliku binarnego testu porównawczego .

W przypadku testów porównawczych Androida powinowactwo procesora jest ustawione tak, aby wykorzystywać duże rdzenie urządzenia w celu zmniejszenia wariancji (zobacz szczegóły ).

Zakłada, że ​​modele zostały pobrane i rozpakowane do katalogu /data/local/tmp/tflite_models . Plik binarny testu porównawczego jest tworzony przy użyciu tych instrukcji i zakłada się, że znajduje się w katalogu /data/local/tmp .

Aby uruchomić test porównawczy:

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

Aby uruchomić z delegatem nnapi, ustaw --use_nnapi=true . Aby uruchomić z delegatem GPU, ustaw --use_gpu=true .

Poniższe wartości wydajności zostały zmierzone na systemie Android 10.

Nazwa modelu Urządzenie Procesor, 4 wątki GPU NNAPI
Mobilenet_1.0_224(pływająca) Piksel 3 23,9 ms 6,45 ms 13,8 ms
Piksel 4 14,0 ms 9,0 ms 14,8 ms
Mobilenet_1.0_224 (ilość) Piksel 3 13,4 ms --- 6,0 ms
Piksel 4 5,0 ms --- 3,2 ms
NASNet komórkowy Piksel 3 56 ms --- 102 ms
Piksel 4 34,5 ms --- 99,0 ms
Ściśnij Net Piksel 3 35,8 ms 9,5 ms 18,5 ms
Piksel 4 23,9 ms 11,1 ms 19,0 ms
Incepcja_ResNet_V2 Piksel 3 422 ms 99,8 ms 201 ms
Piksel 4 272,6 ms 87,2 ms 171,1 ms
Incepcja_V4 Piksel 3 486 ms 93 ms 292 ms
Piksel 4 324,1 ms 97,6 ms 186,9 ms

Testy wydajności iOS

Te wartości porównawcze wydajności zostały wygenerowane za pomocą aplikacji porównawczej na iOS .

Aby uruchomić testy porównawcze iOS, aplikacja testowa została zmodyfikowana w celu uwzględnienia odpowiedniego modelu, a benchmark_params.json został zmodyfikowany w celu ustawienia num_threads na 2. Aby użyć delegata GPU, użyto opcji "use_gpu" : "1" i "gpu_wait_type" : "aggressive" dodano także do benchmark_params.json .

Nazwa modelu Urządzenie Procesor, 2 wątki GPU
Mobilenet_1.0_224(pływająca) iPhone’a XS 14,8 ms 3,4 ms
Mobilenet_1.0_224 (ilość) iPhone’a XS 11 ms ---
NASNet komórkowy iPhone’a XS 30,4 ms ---
Ściśnij Net iPhone’a XS 21,1 ms 15,5 ms
Incepcja_ResNet_V2 iPhone’a XS 261,1 ms 45,7 ms
Incepcja_V4 iPhone’a XS 309 ms 54,4 ms

Śledź elementy wewnętrzne TensorFlow Lite

Śledź elementy wewnętrzne TensorFlow Lite w systemie Android

Zdarzenia wewnętrzne z interpretera TensorFlow Lite aplikacji na Androida mogą być przechwytywane przez narzędzia do śledzenia systemu Android . Są to te same zdarzenia w Android Trace API, więc przechwycone zdarzenia z kodu Java/Kotlin są widoczne razem ze zdarzeniami wewnętrznymi TensorFlow Lite.

Oto kilka przykładów wydarzeń:

  • Wywołanie operatora
  • Modyfikacja wykresu przez delegata
  • Alokacja tensora

Wśród różnych opcji przechwytywania śladów w tym przewodniku omówiono narzędzie Android Studio CPU Profiler i aplikację System Tracing. Aby poznać inne opcje, zobacz Narzędzie wiersza poleceń Perfetto lub Narzędzie wiersza poleceń Systrace .

Dodawanie zdarzeń śledzenia w kodzie Java

To jest fragment kodu z przykładowej aplikacji Klasyfikacja obrazów . Interpreter TensorFlow Lite działa w sekcji recognizeImage/runInference . Ten krok jest opcjonalny, ale przydatny, aby pomóc zauważyć, gdzie następuje wywołanie wnioskowania.

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

Włącz śledzenie TensorFlow Lite

Aby włączyć śledzenie TensorFlow Lite, przed uruchomieniem aplikacji na Androida ustaw właściwość systemu Android debug.tflite.trace na 1.

adb shell setprop debug.tflite.trace 1

Jeśli ta właściwość została ustawiona podczas inicjowania interpretera TensorFlow Lite, śledzone będą kluczowe zdarzenia (np. wywołanie operatora) z interpretera.

Po przechwyceniu wszystkich śladów wyłącz śledzenie, ustawiając wartość właściwości na 0.

adb shell setprop debug.tflite.trace 0

Profiler procesora Android Studio

Przechwytuj ślady za pomocą narzędzia Android Studio CPU Profiler, wykonując poniższe czynności:

  1. Z górnego menu wybierz opcję Uruchom > Profil „aplikacja” .

  2. Kliknij w dowolnym miejscu na osi czasu procesora, gdy pojawi się okno Profilera.

  3. Wybierz opcję „Śledź wywołania systemowe” spośród trybów profilowania procesora.

    Wybierz „Śledź wywołania systemowe”

  4. Naciśnij przycisk „Nagraj”.

  5. Naciśnij przycisk „Zatrzymaj”.

  6. Zbadaj wynik śledzenia.

    Śledzenie Androida Studio

W tym przykładzie możesz zobaczyć hierarchię zdarzeń w wątku i statystyki dla każdego czasu operatora, a także zobaczyć przepływ danych całej aplikacji pomiędzy wątkami.

Aplikacja do śledzenia systemu

Przechwytuj ślady bez Android Studio, wykonując czynności opisane w aplikacji System Tracing .

W tym przykładzie te same zdarzenia TFLite zostały przechwycone i zapisane w formacie Perfetto lub Systrace w zależności od wersji urządzenia z systemem Android. Przechwycone pliki śledzenia można otworzyć w interfejsie użytkownika Perfetto .

Perfetowy ślad

Śledź elementy wewnętrzne TensorFlow Lite w systemie iOS

Zdarzenia wewnętrzne z interpretera TensorFlow Lite aplikacji na iOS można przechwytywać za pomocą narzędzia Instruments dołączonego do Xcode. Są to zdarzenia drogowskazowe dla systemu iOS, więc przechwycone zdarzenia z kodu Swift/Objective-C są widoczne razem ze zdarzeniami wewnętrznymi TensorFlow Lite.

Oto kilka przykładów wydarzeń:

  • Wywołanie operatora
  • Modyfikacja wykresu przez delegata
  • Alokacja tensora

Włącz śledzenie TensorFlow Lite

Ustaw zmienną środowiskową debug.tflite.trace , wykonując poniższe kroki:

  1. Wybierz Produkt > Schemat > Edytuj schemat... z górnych menu Xcode.

  2. Kliknij „Profil” w lewym okienku.

  3. Usuń zaznaczenie pola wyboru „Użyj argumentów i zmiennych środowiskowych akcji Uruchom”.

  4. Dodaj debug.tflite.trace w sekcji „Zmienne środowiskowe”.

    Ustaw zmienną środowiskową

Jeśli chcesz wykluczyć zdarzenia TensorFlow Lite podczas profilowania aplikacji na iOS, wyłącz śledzenie, usuwając zmienną środowiskową.

Instrumenty XCode

Przechwyć ślady, wykonując poniższe czynności:

  1. Wybierz opcję Produkt > Profil z górnego menu Xcode.

  2. Kliknij opcję Rejestrowanie wśród szablonów profilowania po uruchomieniu narzędzia Instrumenty.

  3. Naciśnij przycisk Start.

  4. Naciśnij przycisk „Zatrzymaj”.

  5. Kliknij „os_signpost”, aby rozwinąć elementy podsystemu rejestrowania systemu operacyjnego.

  6. Kliknij podsystem rejestrowania systemu operacyjnego „org.tensorflow.lite”.

  7. Zbadaj wynik śledzenia.

    Śledzenie instrumentów Xcode

W tym przykładzie możesz zobaczyć hierarchię zdarzeń i statystyki dla każdego czasu operatora.

Korzystanie z danych śledzenia

Dane śledzenia umożliwiają identyfikację wąskich gardeł wydajności.

Oto kilka przykładów spostrzeżeń, które możesz uzyskać od profilera i potencjalnych rozwiązań poprawiających wydajność:

  • Jeśli liczba dostępnych rdzeni procesora jest mniejsza niż liczba wątków wnioskowania, narzut planowania procesora może prowadzić do niskiej wydajności. Możesz zmienić harmonogram innych zadań intensywnie obciążających procesor w aplikacji, aby uniknąć nakładania się na wnioski z modelu lub dostosować liczbę wątków interpretera.
  • Jeśli operatory nie są w pełni delegowane, niektóre części wykresu modelu są wykonywane na procesorze, a nie na oczekiwanym akceleratorze sprzętowym. Nieobsługiwane operatory można zastąpić podobnymi obsługiwanymi operatorami.