Zbuduj TensorFlow Lite na Androida

W tym dokumencie opisano, jak samodzielnie zbudować bibliotekę TensorFlow Lite dla systemu Android. Zwykle nie trzeba lokalnie budować biblioteki TensorFlow Lite dla systemu Android. Jeśli chcesz po prostu z niego skorzystać, zobacz przewodnik Szybki start dotyczący systemu Android , aby uzyskać więcej informacji na temat używania ich w projektach systemu Android.

Użyj nocnych migawek

Aby korzystać z nocnych migawek, dodaj następujące 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 migawki do zależności (lub edytuj 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'
    ...
}
...

Zbuduj 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 zawierający operacje wybrane z TensorFlow lub możesz chcieć wprowadzić lokalne zmiany w TensorFlow Lite.

Skonfiguruj środowisko kompilacji za pomocą Dockera

  • Pobierz plik Dockera. Pobierając plik Docker, zgadzasz się, że poniższe warunki korzystania z usługi regulują korzystanie z niego:

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

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

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

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

Jeśli chcesz używać repozytorium TensorFlow na hoście, zamiast tego zamontuj ten katalog hosta (-v hostDir:/host_dir).

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

Teraz powinieneś przejść do sekcji Konfiguruj obszar roboczy i .bazelrc, aby skonfigurować ustawienia kompilacji.

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

Skonfiguruj środowisko kompilacji bez Dockera

Zainstaluj wymagania wstępne Bazela i Androida

Bazel to podstawowy system kompilacji dla TensorFlow. Aby z niego korzystać, musisz go mieć oraz zainstalowane w systemie Android NDK i SDK.

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

Skonfiguruj WORKSPACE i .bazelrc

Jest to jednorazowy krok konfiguracyjny wymagany do zbudowania bibliotek TF Lite. Uruchom skrypt ./configure w głównym katalogu pobierania TensorFlow i odpowiedz „Tak”, gdy skrypt poprosi o interaktywną konfigurację kompilacji ./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 wierszu poleceń skryptu. Pomyślna konfiguracja powinna dać 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-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"

Zbuduj i zainstaluj

Po prawidłowym skonfigurowaniu Bazela możesz zbudować TensorFlow Lite AAR z głównego katalogu checkout 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/ . Zauważ, że tworzy to „gruby” AAR z kilkoma różnymi architekturami; jeśli nie potrzebujesz ich wszystkich, użyj podzbioru odpowiedniego dla Twojego środowiska wdrażania.

Możesz tworzyć mniejsze pliki AAR dotyczące tylko zestawu modeli w następujący 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 korzysta z Tensorflow ops. Aby uzyskać więcej informacji, zobacz sekcję Zmniejszanie rozmiaru binarnego TensorFlow Lite .

Dodaj AAR bezpośrednio do projektu

Przenieś plik tensorflow-lite.aar do katalogu o nazwie libs w swoim 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 następujące polecenie z głównego katalogu realizacji transakcji:

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 build.gradle swojej aplikacji upewnij się, że masz zależność mavenLocal() i zamień standardową zależność TensorFlow Lite na 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'
}

Należy pamiętać, że wersja 0.1.100 służy wyłącznie do testowania/rozwoju. Po zainstalowaniu lokalnego AAR możesz używać standardowych interfejsów API wnioskowania TensorFlow Lite Java w kodzie aplikacji.