Zbuduj TensorFlow Lite na Androida

Ten dokument opisuje, jak samodzielnie zbudować bibliotekę TensorFlow Lite Android. Zwykle nie musisz lokalnie budować biblioteki TensorFlow Lite Android. Jeśli chcesz po prostu z niego korzystać, zapoznaj się ze skróconym wprowadzeniem systemu Android , aby uzyskać więcej informacji o tym, jak ich używać 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'
        }
    }
}

Zbuduj TensorFlow Lite lokalnie

W niektórych przypadkach możesz chcieć użyć lokalnej wersji 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ą Docker

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

Klikając, aby zaakceptować, zgadzasz się, że wszelkie korzystanie z 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ć od czasu do czasu aktualizowane lub zmieniane przez Google).

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

  • Opcjonalnie możesz zmienić wersję Android SDK lub NDK. Umieść pobrany plik Docker w pustym folderze i zbuduj swój obraz Docker, uruchamiając:
docker build . -t tflite-builder -f tflite-android.Dockerfile
  • Uruchom kontener docker interaktywnie, montując bieżący folder do /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, zastąp „$PWD” słowem „pwd”.

Jeśli chcesz użyć repozytorium TensorFlow na hoście, zamiast tego podłącz ten katalog hosta (-v katalog_hosta:/katalog_hosta).

  • Gdy znajdziesz się w kontenerze, możesz uruchomić następujące polecenie, aby pobrać dodatkowe narzędzia i biblioteki 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 Configure WORKSPACE i .bazelrc , aby skonfigurować ustawienia kompilacji.

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

Skonfiguruj środowisko kompilacji bez Dockera

Zainstaluj Bazel i wymagania wstępne dla Androida

Bazel to podstawowy system kompilacji dla TensorFlow. Aby zbudować z nim, musisz go mieć oraz zainstalowane 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. Aktualna zalecana wersja to 19c, którą można znaleźć tutaj .
  3. 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

Jest to jednorazowy krok konfiguracyjny, który jest wymagany do zbudowania bibliotek TF Lite. Uruchom skrypt ./configure w głównym katalogu kasowym TensorFlow i odpowiedz „Tak”, gdy skrypt poprosi o interaktywną konfigurację ./WORKSPACE dla kompilacji 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 skryptu. Pomyślna konfiguracja powinna dać wpisy podobne do następujących w pliku .tf_configure.bazelrc w folderze głównym:

build --action_env ANDROID_NDK_HOME="/usr/local/android/android-ndk-r19c"
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 Bazela 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 to buduje "gruby" AAR z kilkoma różnymi architekturami; jeśli nie potrzebujesz ich wszystkich, użyj podzbioru odpowiedniego dla środowiska wdrażania.

Możesz tworzyć mniejsze pliki AAR przeznaczone tylko dla 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 używa 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 checkout:

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 pliku 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 {
        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'
}

Zauważ, że wersja 0.1.100 jest tutaj przeznaczona wyłącznie do testowania/rozwoju. Po zainstalowaniu lokalnego AAR możesz użyć standardowych interfejsów API TensorFlow Lite Java w kodzie aplikacji.