Compiler LiteRT pour Android

Ce document explique comment créer vous-même la bibliothèque Android LiteRT. Normalement, il n'est pas nécessaire de compiler localement la bibliothèque Android LiteRT.

Utiliser les instantanés nocturnes

Pour utiliser les snapshots nocturnes, ajoutez le dépôt suivant à la configuration de compilation Gradle racine.

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

Ajoutez des instantanés nocturnes aux dépendances (ou modifiez-les si nécessaire) dans votre fichier 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'
    ...
}
...

Compiler LiteRT en local

Dans certains cas, vous pouvez utiliser une compilation locale de LiteRT. Par exemple, vous pouvez créer un binaire personnalisé qui inclut des opérations sélectionnées à partir de TensorFlow ou vous pouvez apporter des modifications locales à LiteRT.

Configurer l'environnement de compilation à l'aide de Docker

  • Téléchargez le fichier Docker. En téléchargeant le fichier Docker, vous acceptez que votre utilisation soit régie par les conditions d'utilisation suivantes :

En cliquant sur "Accepter", vous acceptez que toute utilisation d'Android Studio et du kit de développement natif Android soit régie par le contrat de licence du kit de développement logiciel Android disponible à l'adresse https://developer.android.com/studio/terms (cette URL peut être mise à jour ou modifiée par Google de temps en temps).

Vous devez accepter les conditions d'utilisation pour télécharger le fichier.

  • Vous pouvez éventuellement modifier la version du SDK ou du NDK Android. Placez le fichier Docker téléchargé dans un dossier vide et créez votre image Docker en exécutant la commande suivante :
docker build . -t tflite-builder -f tflite-android.Dockerfile
  • Démarrez le conteneur Docker de manière interactive en installant votre dossier actuel sur /host_dir à l'intérieur du conteneur (notez que /tensorflow_src est le dépôt TensorFlow à l'intérieur du conteneur) :
docker run -it -v $PWD:/host_dir tflite-builder bash

Si vous utilisez PowerShell sur Windows, remplacez "$PWD" par "pwd".

Si vous souhaitez utiliser un dépôt TensorFlow sur l'hôte, installez plutôt ce répertoire hôte (-v hostDir:/host_dir).

  • Une fois dans le conteneur, vous pouvez exécuter la commande suivante pour télécharger des outils et des bibliothèques Android supplémentaires (notez que vous devrez peut-être accepter la licence) :
sdkmanager \
  "build-tools;${ANDROID_BUILD_TOOLS_VERSION}" \
  "platform-tools" \
  "platforms;android-${ANDROID_API_LEVEL}"

Vous devez maintenant passer à la section Configurer WORKSPACE et .bazelrc pour configurer les paramètres de compilation.

Une fois les bibliothèques créées, vous pouvez les copier dans /host_dir à l'intérieur du conteneur pour pouvoir y accéder sur l'hôte.

Configurer un environnement de compilation sans Docker

Installer Bazel et les prérequis Android

Bazel est le principal système de compilation pour TensorFlow. Pour l'utiliser, vous devez l'avoir installé sur votre système, ainsi que le NDK et le SDK Android.

  1. Installez la dernière version du système de compilation Bazel.
  2. Android NDK est nécessaire pour compiler le code LiteRT natif (C/C++). La version 25b est actuellement recommandée. Vous la trouverez sur cette page.
    1. Le SDK Android et les outils de compilation peuvent être obtenus ici ou dans Android Studio. La version recommandée pour créer LiteRT est l'API >= 23 des outils de compilation.

Configurer WORKSPACE et .bazelrc

Il s'agit d'une étape de configuration unique requise pour créer les bibliothèques LiteRT. Exécutez le script ./configure dans le répertoire racine de l'extraction TensorFlow et répondez "Oui" lorsque le script vous demande de configurer de manière interactive ./WORKSPACE pour les compilations Android. Le script tentera de configurer les paramètres à l'aide des variables d'environnement suivantes :

  • ANDROID_SDK_HOME
  • ANDROID_SDK_API_LEVEL
  • ANDROID_NDK_HOME
  • ANDROID_NDK_API_LEVEL

Si ces variables ne sont pas définies, elles doivent être fournies de manière interactive dans l'invite de script. Une configuration réussie doit générer des entrées semblables à celles ci-dessous dans le fichier .tf_configure.bazelrc du dossier racine :

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"

Compiler et installer

Une fois Bazel correctement configuré, vous pouvez créer le fichier AAR LiteRT à partir du répertoire racine de l'extraction, comme suit :

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

Un fichier AAR est alors généré dans bazel-bin/tensorflow/lite/java/. Notez que cela crée un AAR "fat" avec plusieurs architectures différentes. Si vous n'en avez pas besoin, utilisez le sous-ensemble adapté à votre environnement de déploiement.

Vous pouvez créer des fichiers AAR plus petits ciblant uniquement un ensemble de modèles comme suit :

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

Le script ci-dessus génère le fichier tensorflow-lite.aar et, éventuellement, le fichier tensorflow-lite-select-tf-ops.aar si l'un des modèles utilise des opérations TensorFlow. Pour en savoir plus, consultez la section Réduire la taille du binaire LiteRT.

Ajouter un fichier AAR directement au projet

Déplacez le fichier tensorflow-lite.aar dans un répertoire nommé libs dans votre projet. Modifiez le fichier build.gradle de votre application pour faire référence au nouveau répertoire et remplacez la dépendance LiteRT existante par la nouvelle bibliothèque locale, par exemple :

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

Installer l'AAR dans le dépôt Maven local

Exécutez la commande suivante à partir de votre répertoire racine de vérification :

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

Dans le fichier build.gradle de votre application, assurez-vous d'avoir la dépendance mavenLocal() et remplacez la dépendance LiteRT standard par celle qui est compatible avec certaines opérations 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'
}

Notez que la version 0.1.100 ici est uniquement destinée aux tests/au développement. Une fois l'AAR local installé, vous pouvez utiliser les API d'inférence Java LiteRT standards dans le code de votre application.