Utwórz LiteRT na Androida

Z tego dokumentu dowiesz się, jak samodzielnie utworzyć bibliotekę LiteRT na Androida. Zwykle nie musisz lokalnie tworzyć biblioteki LiteRT na Androida.

Korzystanie z nocnych zrzutów

Aby używać nocnych zrzutów, dodaj to 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 do pliku build.gradle zależności z nocnymi migawkami (lub w razie potrzeby je zmodyfikuj);

...
dependencies {
    ...
    implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly-SNAPSHOT'
    implementation 'com.google.ai.edge.litert:litert-gpu:0.0.0-nightly-SNAPSHOT'
    implementation 'com.google.ai.edge.litert:litert-support:0.0.0-nightly-SNAPSHOT'
    ...
}
...

Kompilowanie LiteRT lokalnie

W niektórych przypadkach możesz chcieć użyć lokalnej wersji LiteRT. Możesz na przykład tworzyć niestandardowy plik binarny, który zawiera operacje wybrane z TensorFlow, lub wprowadzać lokalne zmiany w LiteRT.

Konfigurowanie środowiska kompilacji za pomocą Dockera

  • Pobierz plik Dockera. Pobierając plik Docker, akceptujesz następujące warunki korzystania z usługi:

Klikając przycisk akceptacji, wyrażasz zgodę na to, że wszelkie korzystanie z Android Studio i pakietu Android Native Development Kit będzie podlegać Umowie licencyjnej dotyczącej pakietu Android SDK dostępnej na stronie https://developer.android.com/studio/terms (ten adres URL może być okresowo 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 skompiluj obraz Dockera, uruchamiając to polecenie:
docker build . -t tflite-builder -f tflite-android.Dockerfile
  • Uruchom interaktywnie kontener Dockera, montując bieżący folder w 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 programu PowerShell w systemie Windows, zastąp „$PWD” ciągiem „pwd”.

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

  • Gdy znajdziesz się w kontenerze, możesz uruchomić to 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 przejdź do sekcji Skonfiguruj WORKSPACE i .bazelrc, aby skonfigurować ustawienia kompilacji.

Po utworzeniu bibliotek możesz skopiować je do katalogu /host_dir w kontenerze, aby mieć do nich dostęp na hoście.

Konfigurowanie środowiska kompilacji bez Dockera

Instalowanie Bazela i wymagań wstępnych Androida

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

  1. Zainstaluj najnowszą wersję systemu kompilacji Bazel.
  2. Do skompilowania natywnego kodu LiteRT (C/C++) wymagany jest pakiet Android NDK. Obecnie zalecana wersja to 25b, którą znajdziesz tutaj.
    1. Pakiet Android SDK i narzędzia kompilacji można pobrać tutaj lub w ramach Androida Studio. Narzędzia do kompilacji API ≥ 23 to zalecana wersja do kompilacji LiteRT.

Konfigurowanie plików WORKSPACE i .bazelrc

Jest to jednorazowy krok konfiguracji wymagany do utworzenia bibliotek LiteRT. Uruchom skrypt ./configure w katalogu głównym wyewidencjonowanego repozytorium TensorFlow i odpowiedz „Yes” (Tak), gdy skrypt poprosi o interaktywne skonfigurowanie ./WORKSPACE na potrzeby kompilacji na Androida. Skrypt spróbuje skonfigurować ustawienia za pomocą tych 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 polecenia skryptu. Prawidłowa konfiguracja powinna dać 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"

Tworzenie i instalowanie

Gdy Bazel zostanie prawidłowo skonfigurowany, możesz utworzyć plik AAR LiteRT z katalogu głównego pobranej kopii w ten 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 folderze bazel-bin/tensorflow/lite/java/. Pamiętaj, że w ten sposób tworzysz „gruby” plik AAR z kilkoma różnymi architekturami. Jeśli nie potrzebujesz wszystkich, użyj podzbioru odpowiedniego dla środowiska wdrażania.

Możesz tworzyć mniejsze pliki AAR, które są przeznaczone tylko dla określonych modeli:

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 pliku LiteRT.

Dodawanie AAR bezpośrednio do projektu

Przenieś plik tensorflow-lite.aar do katalogu o nazwie libs w projekcie. Zmodyfikuj plik build.gradle aplikacji, aby odwoływał się do nowego katalogu, i zastąp istniejącą zależność LiteRT 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')
}

Instalowanie AAR w lokalnym repozytorium Maven

Uruchom to polecenie w głównym katalogu wyewidencjonowania:

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ść LiteRT zależnością, 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 wersja 0.1.100 jest tutaj używana wyłącznie na potrzeby testowania i programowania. Po zainstalowaniu lokalnego pliku AAR możesz używać w kodzie aplikacji standardowych interfejsów LiteRT Java Inference API.