Przedstawiamy LiteRT: wydajne środowisko wykonawcze Google do obsługi AI na urządzeniu, wcześniej znane jako TensorFlow Lite.

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

Utwórz LiteRT na Androida

Ten dokument opisuje, jak utworzyć bibliotekę LiteRT na Androida . Zwykle nie trzeba lokalnie tworzyć biblioteki LiteRT na Androida.

Korzystanie z nocnych zrzutów

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

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 edytuj je w razie potrzeby) do pliku build.gradle

...
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'
    ...
}
...

Tworzenie biblioteki LiteRT lokalnie

W niektórych przypadkach możesz użyć lokalnej kompilacji LiteRT. Dla: możesz np. utworzyć niestandardowy plik binarny zawierający operacje wybrane z TensorFlow, lub wprowadzić lokalne zmiany w LiteRT.

Konfigurowanie środowiska kompilacji przy użyciu Dockera

Pobierz plik Dockera. Pobierając plik Dockera, zgadzasz się na to, że następujące warunki korzystania z usługi regulują korzystanie z nich:

Klikając przycisk akceptacji, zgadzasz się, że wszelkie korzystanie z programu Android Studio oraz Android Native Development Kit będzie podlegał warunkom oprogramowania Android Umowa licencyjna na pakiet dla programistów jest dostępna na stronie https://developer.android.com/studio/terms (taki adres URL może zostać zaktualizowany lub zmieniony przez Google).

Aby pobrać .

Opcjonalnie możesz zmienić wersję pakietu Android SDK lub NDK. Pobrane pliki i utwórz obraz Dockera w pustym folderze, uruchamiając polecenie:

docker build . -t tflite-builder -f tflite-android.Dockerfile

Uruchom interaktywnie kontener Dockera przez podłączenie bieżącego folderu do /host_dir w kontenerze (zwróć uwagę, że /tensorflow_src to ścieżka dźwiękowa TensorFlow) w kontenerze):

docker run -it -v $PWD:/host_dir tflite-builder bash

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

Jeśli chcesz użyć repozytorium TensorFlow na hoście, podłącz go (-v hostDir:/katalog_hosta).

Po otwarciu kontenera możesz uruchomić następujące polecenia, aby pobrać aplikację dodatkowych narzędzi i bibliotek 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 plik .bazelrc, aby skonfigurować ustawienia kompilacji.

Po zakończeniu tworzenia 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 wymagań wstępnych dotyczących aplikacji Bazel i Androida

Podstawowym systemem kompilacji dla TensorFlow jest Bazel. Aby używać go do tworzenia reklam, musisz oraz zainstalowane w systemie Android NDK i pakiet SDK.

Zainstaluj najnowszą wersję systemu kompilacji Bazel.
Do utworzenia natywnej wersji LiteRT (C/C++) potrzebny jest Android NDK w kodzie. Aktualna zalecana wersja to 25b. Może znaleźć się tutaj.
Można uzyskać dostęp do Android SDK i narzędzi do kompilacji tutaj lub lub w ramach Android Studio Kompilacja API narzędzi >= 23 jest zalecaną wersją do tworzenia LiteRT.

Skonfiguruj WORKSPACE i .bazelrc

Jest to jednorazowy krok konfiguracji, który jest wymagany do utworzenia LiteRT biblioteki. Uruchom skrypt ./configure w głównej części procesu płatności TensorFlow i odpowiedz „Tak”. gdy skrypt prosi o interaktywne skonfigurowanie elementu ./WORKSPACE. dla kompilacji na Androida. Skrypt spróbuje skonfigurować ustawienia za pomocą następujące zmienne środowiskowe:

ANDROID_SDK_HOME
ANDROID_SDK_API_LEVEL
ANDROID_NDK_HOME
ANDROID_NDK_API_LEVEL

Jeśli te zmienne nie są ustawione, należy je udostępnić interaktywnie w skrypcie . Pomyślna konfiguracja powinna zwrócić wpisy podobne do tych poniżej 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 instalacja

Po prawidłowym skonfigurowaniu Bazel możesz utworzyć w głównym katalogu procesu płatności:

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 języku: bazel-bin/tensorflow/lite/java/. Notatka że w ten sposób powstaje „tkanka tłuszczowa”, stosowanie AAR w kilku różnych architekturach; jeśli nie chcesz potrzebujesz ich wszystkich, użyj podzbioru odpowiedniego dla Twojego środowiska wdrożenia.

Możesz tworzyć mniejsze pliki AAR kierowane tylko na zestaw modeli 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 tensorflow-lite-select-tf-ops.aar, jeśli jeden z modeli używa Operacje Tensorflow. Więcej informacji znajdziesz tutaj: Zmniejsz rozmiar pliku binarnego LiteRT.

Dodaj AAR bezpośrednio do projektu

Przenieś plik tensorflow-lite.aar do katalogu o nazwie libs w w projektach AI. Zmodyfikuj plik build.gradle aplikacji, aby odwoływał się do nowego katalogu i zastąpić istniejącą zależność LiteRT nową biblioteką lokalną, e.g.:

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

Wykonaj to polecenie w głównym 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

W build.gradle aplikacji sprawdź, czy masz zależność mavenLocal() oraz zastąp standardową zależność LiteRT tą, która obsługuje dla wybranych operacji 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 służy wyłącznie testowania/rozwoju. Po zainstalowaniu lokalnego AAR możesz użyć standardowego Interfejsy API wnioskowania w Javie LiteRT w kodzie aplikacji.