Kompilacja TensorFlow Lite na Androida

Ten dokument wyjaśnia, jak samodzielnie utworzyć bibliotekę Androida TensorFlow Lite. Standardowo nie musisz lokalnie tworzyć biblioteki TensorFlow Lite na Androida.

Używanie zrzutów nocnych

Aby używać nocnych zrzutów, dodaj poniższe repozytorium do głównej konfiguracji kompilacji Gradle.

allprojects {
    repositories {      // should be already there
        mavenCentral()  // should be already there
        maven {         // add this repo to use snapshots
          name 'ossrh-snapshot'
          url 'https://oss.sonatype.org/content/repositories/snapshots'
        }
    }
}

dodaj nocne zrzuty do zależności (lub zmodyfikuj je w razie potrzeby) do pliku build.gradle.

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

Kompilowanie TensorFlow Lite lokalnie

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

Konfigurowanie środowiska kompilacji za pomocą Dockera

  • Pobierz plik Dockera. Pobierając plik Dockera, zgadzasz się na korzystanie z niego zgodnie z tymi warunkami:

Klikając „Akceptuję”, zgadzasz się, aby całe wykorzystywanie Android Studio i Android Native Development Kit podlegało umowie licencyjnej na Androida Software Development Kit dostępnej na https://developer.android.com/studio/terms (taki adres URL może być od czasu do czasu aktualizowany lub zmieniany przez Google).

Aby pobrać plik, musisz zaakceptować warunki korzystania z usługi.

  • Opcjonalnie możesz zmienić wersję pakietu Android SDK lub NDK. Umieść pobrany plik Dockera w pustym folderze i utwórz obraz Dockera, uruchamiając polecenie:
docker build . -t tflite-builder -f tflite-android.Dockerfile
  • Uruchom interaktywny kontener Dockera, podłączając bieżący folder do katalogu /host_dir w kontenerze (pamiętaj, że /tensorflow_src to repozytorium TensorFlow w kontenerze):
docker run -it -v $PWD:/host_dir tflite-builder bash

Jeśli używasz PowerShell w systemie Windows, zastąp „$PWD” ciągiem „pwd”.

Jeśli chcesz używać repozytorium TensorFlow na hoście, podłącz ten katalog hosta (-v hostDir:/host_dir).

  • Gdy znajdziesz się w kontenerze, możesz uruchomić to polecenie, by pobrać dodatkowe narzędzia i biblioteki Androida (pamiętaj, że konieczne może być zaakceptowanie licencji):
sdkmanager \
  "build-tools;${ANDROID_BUILD_TOOLS_VERSION}" \
  "platform-tools" \
  "platforms;android-${ANDROID_API_LEVEL}"

Teraz przejdź do sekcji Skonfiguruj WORKSPACE i .bazelrc, aby skonfigurować ustawienia kompilacji.

Po zakończeniu tworzenia bibliotek możesz je skopiować do katalogu /host_dir wewnątrz kontenera, aby mieć do nich dostęp na hoście.

Konfigurowanie środowiska kompilacji bez Dockera

Instalowanie wymagań wstępnych dotyczących Bazel i Androida

Bazel to podstawowy system kompilacji dla TensorFlow. Aby z niego korzystać, musisz mieć w systemie zainstalowany pakiet NDK i pakiet SDK Androida.

  1. Zainstaluj najnowszą wersję systemu kompilacji Baidu.
  2. Do utworzenia natywnego kodu TensorFlow Lite (C/C++) potrzebny jest pakiet Android NDK. Obecna zalecana wersja to 25b, którą znajdziesz tutaj.
  3. Pakiet Android SDK i narzędzia do tworzenia są dostępne tutaj lub z Android Studio. Interfejs Build Tools API w wersji >= 23 to zalecana wersja do kompilowania TensorFlow Lite.

Skonfiguruj WORKSPACE i .bazelrc

Jest to jednorazowy krok konfiguracji wymagany do utworzenia bibliotek TF Lite. Uruchom skrypt ./configure w głównym katalogu płatności TensorFlow i odpowiedz „Tak”, gdy skrypt poprosi o interaktywną konfigurację ./WORKSPACE kompilacji na Androida. Skrypt spróbuje skonfigurować ustawienia przy użyciu tych zmiennych środowiskowych:

  • ANDROID_SDK_HOME
  • ANDROID_SDK_API_LEVEL
  • ANDROID_NDK_HOME
  • ANDROID_NDK_API_LEVEL

Jeśli te zmienne nie są ustawione, trzeba je podać interaktywnie w prompcie skryptu. Pomyślna konfiguracja powinna zwrócić wpisy podobne do tych w pliku .tf_configure.bazelrc w folderze głównym:

build --action_env ANDROID_NDK_HOME="/usr/local/android/android-ndk-r25b"
build --action_env ANDROID_NDK_API_LEVEL="21"
build --action_env ANDROID_BUILD_TOOLS_VERSION="30.0.3"
build --action_env ANDROID_SDK_API_LEVEL="30"
build --action_env ANDROID_SDK_HOME="/usr/local/android/android-sdk-linux"

Skompiluj i zainstaluj

Po prawidłowym skonfigurowaniu Bazel możesz utworzyć AAR TensorFlow Lite z głównego katalogu płatności w następujący sposób:

bazel build -c opt --cxxopt=--std=c++17 --config=android_arm64 \
  --fat_apk_cpu=x86,x86_64,arm64-v8a,armeabi-v7a \
  --define=android_dexmerger_tool=d8_dexmerger \
  --define=android_incremental_dexing_tool=d8_dexbuilder \
  //tensorflow/lite/java:tensorflow-lite

Spowoduje to wygenerowanie pliku AAR w: bazel-bin/tensorflow/lite/java/. Pamiętaj, że spowoduje to utworzenie „twardego” AAR z kilkoma różnymi architekturami. Jeśli nie potrzebujesz ich wszystkich, użyj podzbioru odpowiedniego dla swojego środowiska wdrożenia.

Mniejsze pliki AAR kierowane tylko na zbiór modeli możesz tworzyć w ten sposób:

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

Powyższy skrypt wygeneruje plik tensorflow-lite.aar i opcjonalnie plik tensorflow-lite-select-tf-ops.aar, jeśli jeden z modeli używa operacji Tensorflow. Więcej informacji znajdziesz w sekcji Zmniejszanie rozmiaru binarnego TensorFlow Lite.

Dodaj AAR bezpośrednio do projektu

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

allprojects {
    repositories {
        mavenCentral()
        maven {  // Only for snapshot artifacts
            name 'ossrh-snapshot'
            url 'https://oss.sonatype.org/content/repositories/snapshots'
        }
        flatDir {
            dirs 'libs'
        }
    }
}

dependencies {
    compile(name:'tensorflow-lite', ext:'aar')
}

Zainstaluj AAR w lokalnym repozytorium Maven

Wykonaj to polecenie z głównego katalogu płatności:

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

Sprawdź w build.gradle swojej aplikacji, czy masz zależność mavenLocal(), i zastąp standardową zależność TensorFlow Lite tą, która obsługuje wybrane operacje TensorFlow:

allprojects {
    repositories {
        mavenCentral()
        maven {  // Only for snapshot artifacts
            name 'ossrh-snapshot'
            url 'https://oss.sonatype.org/content/repositories/snapshots'
        }
        mavenLocal()
    }
}

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

Pamiętaj, że ta wersja 0.1.100 służy wyłącznie do testowania i programowania. Po zainstalowaniu lokalnego AAR możesz używać w kodzie aplikacji standardowych interfejsów API wnioskowania w Javie TensorFlow Lite.