Ta strona została przetłumaczona przez Cloud Translation API.
Switch to English

Krótkie wprowadzenie do Androida

Aby rozpocząć korzystanie z TensorFlow Lite w systemie Android, zalecamy zapoznanie się z następującym przykładem.

Przykład klasyfikacji obrazów Androida

Przeczytaj klasyfikację obrazu TensorFlow Lite dla systemu Android, aby uzyskać wyjaśnienie kodu źródłowego.

Ta przykładowa aplikacja wykorzystuje klasyfikację obrazu, aby w sposób ciągły klasyfikować wszystko, co widzi z tylnego aparatu urządzenia. Aplikacja może działać na urządzeniu lub w emulatorze.

Wnioskowanie jest wykonywane przy użyciu interfejsu API języka Java TensorFlow Lite i biblioteki obsługi systemu Android TensorFlow Lite . Aplikacja demo klasyfikuje klatki w czasie rzeczywistym, wyświetlając najbardziej prawdopodobne klasyfikacje. Pozwala użytkownikowi wybrać model zmiennoprzecinkowy lub kwantowany , wybrać liczbę wątków i zdecydować, czy ma działać na CPU, GPU, czy przez NNAPI .

Zbuduj w Android Studio

Aby zbudować przykład w Android Studio, postępuj zgodnie z instrukcjami w pliku README.md .

Stwórz własną aplikację na Androida

Aby szybko rozpocząć pisanie własnego kodu systemu Android, zalecamy skorzystanie z naszego przykładu klasyfikacji obrazów systemu Android jako punktu wyjścia.

Poniższe sekcje zawierają przydatne informacje dotyczące pracy z TensorFlow Lite w systemie Android.

Skorzystaj z biblioteki obsługi systemu Android TensorFlow Lite

Biblioteka obsługi TensorFlow Lite dla systemu Android ułatwia integrację modeli z aplikacją. Zapewnia interfejsy API wysokiego poziomu, które pomagają przekształcić surowe dane wejściowe do postaci wymaganej przez model i interpretują dane wyjściowe modelu, zmniejszając ilość wymaganego kodu standardowego.

Obsługuje typowe formaty danych dla wejść i wyjść, w tym obrazy i tablice. Zapewnia również jednostki przetwarzania wstępnego i końcowego, które wykonują zadania, takie jak zmiana rozmiaru obrazu i kadrowanie.

Aby rozpocząć, postępuj zgodnie z instrukcjami w TensorFlow Lite Android Support Library README.md .

Użyj TensorFlow Lite AAR od JCenter

Aby korzystać z TensorFlow Lite w aplikacji na Androida, zalecamy korzystanie z TensorFlow Lite AAR hostowanego w JCenter .

Możesz to określić w zależnościach build.gradle w następujący sposób:

dependencies {
    implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly'
}

Ten raport AAR zawiera pliki binarne dla wszystkich interfejsów ABI systemu Android . Możesz zmniejszyć rozmiar pliku binarnego aplikacji, uwzględniając tylko te ABI, które chcesz obsługiwać.

Zalecamy większości programistów pominięcie arm32 ABI x86 , x86_64 i arm32 . Można to osiągnąć za pomocą następującej konfiguracji Gradle, która w szczególności obejmuje tylko armeabi-v7a i arm64-v8a , które powinny obejmować większość nowoczesnych urządzeń z Androidem.

android {
    defaultConfig {
        ndk {
            abiFilters 'armeabi-v7a', 'arm64-v8a'
        }
    }
}

Aby dowiedzieć się więcej o abiFilters , zobacz NdkOptions w dokumentacji Androida Gradle.

Twórz TensorFlow Lite lokalnie

W niektórych przypadkach możesz chcieć użyć lokalnej kompilacji TensorFlow Lite. Na przykład możesz budować niestandardowy plik binarny, który zawiera operacje wybrane z TensorFlow , lub możesz chcieć wprowadzić lokalne zmiany w TensorFlow Lite.

Skonfiguruj środowisko kompilacji za pomocą platformy Docker

  • Pobierz plik Docker. Pobierając plik Docker, zgadzasz się, że korzystanie z niego podlega następującym warunkom świadczenia usług:

Klikając, aby zaakceptować, zgadzasz się, że wszelkie korzystanie z Android Studio i Android Native Development Kit będzie podlegać Umowie licencyjnej zestawu Android Software Development Kit dostępnej pod adresem https://developer.android.com/studio/terms (taki adres URL może być od czasu do czasu aktualizowane lub zmieniane przez Google).

Musisz zaakceptować warunki korzystania z usługi, aby pobrać plik. Potwierdź

  • Opcjonalnie możesz zmienić wersję Android SDK lub NDK. Umieść pobrany plik Dockera w pustym folderze i skompiluj obraz Dockera, uruchamiając:
docker build . -t tflite-builder -f tflite-android.Dockerfile
  • Uruchom kontener Dockera interaktywnie, montując bieżący folder do / tmp wewnątrz kontenera (zwróć uwagę, że / tensorflow_src to repozytorium TensorFlow wewnątrz kontenera):
docker run -it -v $PWD:/tmp tflite-builder bash

Jeśli używasz programu PowerShell w systemie Windows, zamień „$ PWD” na „pwd”.

Jeśli chcesz użyć repozytorium TensorFlow na hoście, zamontuj ten katalog hosta (-v katalog_hosta: / tmp).

  • Gdy znajdziesz się w kontenerze, możesz uruchomić następujące opcje, aby pobrać dodatkowe narzędzia i biblioteki Androida (pamiętaj, że może być konieczne zaakceptowanie licencji):
android update sdk --no-ui -a --filter tools,platform-tools,android-${ANDROID_API_LEVEL},build-tools-${ANDROID_BUILD_TOOLS_VERSION}

Możesz teraz przejść do sekcji „Kompiluj i instaluj”. Po zakończeniu budowania bibliotek możesz skopiować je do / tmp wewnątrz kontenera, aby uzyskać do nich dostęp na hoście.

Skonfiguruj środowisko kompilacji bez Dockera

Zainstaluj Bazel i wymagania wstępne Androida

Bazel to podstawowy system kompilacji dla TensorFlow. Aby z nim zbudować, musisz go mieć i zainstalować w systemie Android NDK i SDK.

  1. Zainstaluj najnowszą wersję systemu kompilacji Bazel .
  2. Android NDK jest wymagany do zbudowania natywnego (C / C ++) kodu TensorFlow Lite. Aktualnie zalecana wersja to 17c, którą można znaleźć tutaj .
  3. Zestaw Android SDK i narzędzia do kompilacji można pobrać tutaj lub alternatywnie jako część Android Studio . Build tools API> = 23 to zalecana wersja do budowania TensorFlow Lite.
Skonfiguruj WORKSPACE i .bazelrc

Uruchom skrypt ./configure w głównym katalogu pobierania TensorFlow i odpowiedz „Tak”, gdy skrypt zapyta o interaktywną konfigurację ./WORKSPACE dla systemu Android. Skrypt podejmie próbę skonfigurowania ustawień przy użyciu następujących zmiennych środowiskowych:

  • ANDROID_SDK_HOME
  • ANDROID_SDK_API_LEVEL
  • ANDROID_NDK_HOME
  • ANDROID_NDK_API_LEVEL

Jeśli te zmienne nie są ustawione, należy je podać interaktywnie w zachęcie skryptu. Pomyślna konfiguracja powinna przynieść wpisy podobne do poniższych w pliku .tf_configure.bazelrc w folderze głównym:

build --action_env ANDROID_NDK_HOME="/usr/local/android/android-ndk-r17c"
build --action_env ANDROID_NDK_API_LEVEL="21"
build --action_env ANDROID_BUILD_TOOLS_VERSION="28.0.3"
build --action_env ANDROID_SDK_API_LEVEL="23"
build --action_env ANDROID_SDK_HOME="/usr/local/android/android-sdk-linux"

Zbuduj i zainstaluj

Po prawidłowym skonfigurowaniu Bazel możesz zbudować TensorFlow Lite AAR z głównego katalogu checkout w następujący sposób:

bazel build -c opt --fat_apk_cpu=x86,x86_64,arm64-v8a,armeabi-v7a \
  --host_crosstool_top=@bazel_tools//tools/cpp:toolchain \
  //tensorflow/lite/java:tensorflow-lite

Spowoduje to wygenerowanie pliku AAR w bazel-bin/tensorflow/lite/java/ . Zauważ, że tworzy to „gruby” AAR z kilkoma różnymi architekturami; jeśli nie potrzebujesz ich wszystkich, użyj podzbioru odpowiedniego dla środowiska wdrażania.

bash tensorflow/lite/tools/build_aar.sh \
  --input_models=model1,model2 \
  --target_archs=x86,x86_64,arm64-v8a,armeabi-v7a

tensorflow-lite.aar skrypt wygeneruje plik tensorflow-lite.aar i opcjonalnie plik tensorflow-lite-select-tf-ops.aar , jeśli jeden z modeli korzysta z operacji Tensorflow.

Dodaj AAR bezpośrednio do projektu

Przenieś plik tensorflow-lite.aar do katalogu o nazwie libs w swoim projekcie. Zmodyfikuj plik build.gradle aplikacji, aby odwoływał się do nowego katalogu i zastąp istniejącą zależność TensorFlow Lite nową biblioteką lokalną, np .:

allprojects {
    repositories {
        jcenter()
        flatDir {
            dirs 'libs'
        }
    }
}

dependencies {
    compile(name:'tensorflow-lite', ext:'aar')
}
Zainstaluj AAR w lokalnym repozytorium Maven

Wykonaj następujące polecenie z głównego katalogu pobierania:

mvn install:install-file \
  -Dfile=bazel-bin/tensorflow/lite/java/tensorflow-lite.aar \
  -DgroupId=org.tensorflow \
  -DartifactId=tensorflow-lite -Dversion=0.1.100 -Dpackaging=aar

W mavenLocal() build.gradle aplikacji upewnij się, że masz zależność mavenLocal() i zastąp standardową zależność TensorFlow Lite tą, która obsługuje wybrane operacje TensorFlow:

allprojects {
    repositories {
        jcenter()
        mavenLocal()
    }
}

dependencies {
    implementation 'org.tensorflow:tensorflow-lite:0.1.100'
}

Zwróć uwagę, że wersja 0.1.100 jest tutaj wyłącznie do celów testowania / rozwoju. Po zainstalowaniu lokalnego AAR można używać standardowych interfejsów API wnioskowania Java TensorFlow Lite w kodzie aplikacji.

Zbuduj aplikację na Androida w C ++

Istnieją dwa sposoby używania TFLite przez C ++, jeśli tworzysz swoją aplikację za pomocą NDK:

Użyj interfejsu API TFLite C.

To jest zalecane podejście. Pobierz TensorFlow Lite AAR hostowany w JCenter , zmień jego nazwę na tensorflow-lite-*.zip i rozpakuj. Musisz podać cztery pliki nagłówka w headers/tensorflow/lite/ a headers/tensorflow/lite/c/ folderu i odpowiedni libtensorflowlite_jni.so biblioteka dynamiczna w jni/ folderu w projekcie NDK.

c_api.h nagłówkowy c_api.h zawiera podstawową dokumentację dotyczącą korzystania z interfejsu API TFLite C.

Użyj interfejsu API TFLite C ++

Jeśli chcesz używać TFLite przez C ++ API, możesz zbudować współdzielone biblioteki C ++:

32-bitowy armeabi-v7a:

bazel build -c opt --config=android_arm //tensorflow/lite:libtensorflowlite.so

64-bitowe arm64-v8a:

bazel build -c opt --config=android_arm64 //tensorflow/lite:libtensorflowlite.so

Obecnie nie ma prostego sposobu na wyodrębnienie wszystkich potrzebnych plików nagłówkowych, dlatego należy dołączyć wszystkie pliki nagłówkowe do tensorflow/lite/ z repozytorium TensorFlow. Dodatkowo będziesz potrzebować plików nagłówkowych z FlatBuffers i Abseil .