Compiler TensorFlow Lite pour Android

Ce document explique comment compiler vous-même une bibliothèque Android TensorFlow Lite. Normalement, vous n'avez pas besoin de compiler localement la bibliothèque Android TensorFlow Lite.

Utiliser Instantanés nocturnes

Pour utiliser des instantanés nocturnes, ajoutez le dépôt suivant à votre 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 de votre build.gradle (ou modifiez-les si nécessaire)

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

Compiler TensorFlow Lite en local

Dans certains cas, vous pouvez utiliser un build local de TensorFlow Lite. Par exemple, vous pouvez créer un binaire personnalisé incluant des opérations sélectionnées à partir de TensorFlow, ou apporter des modifications locales à TensorFlow Lite.

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 Android natif est 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 dans /host_dir (notez que /tensorflow_src correspond au dépôt TensorFlow):
docker run -it -v $PWD:/host_dir tflite-builder bash

Si vous utilisez PowerShell sous 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 bibliothèques et des outils 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 Configure WORKSPACE and .bazelrc (Configurer l'espace de travail et les fichiers .bazelrc) pour configurer les paramètres de compilation.

Une fois les bibliothèques créées, vous pouvez les copier dans /host_dir dans le conteneur afin de 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 système de compilation principal de TensorFlow. Pour compiler avec elle, vous devez l'avoir, ainsi que le NDK et le SDK Android installés sur votre système.

  1. Installez la dernière version du système de compilation Bazel.
  2. Le NDK Android est nécessaire pour compiler le code TensorFlow Lite natif (C/C++). La version actuelle recommandée est 25b, disponible ici.
  3. Vous pouvez obtenir le SDK Android et les outils de compilation sur cette page ou dans Android Studio. L'API Build Tools 23 ou version ultérieure est la version recommandée pour compiler TensorFlow Lite.

Configurer WORKSPACE et .bazelrc

Il s'agit d'une étape de configuration unique, nécessaire pour compiler les bibliothèques TF Lite. Exécutez le script ./configure dans le répertoire de paiement TensorFlow racine et répondez "Yes" (Oui) lorsque le script demande de configurer ./WORKSPACE de manière interactive pour les builds 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 aux suivantes 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 l'AAR TensorFlow Lite à partir du répertoire de paiement racine 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 binaire TensorFlow Lite.

Ajouter l'AAR directement au projet

Déplacez le fichier tensorflow-lite.aar dans le répertoire de votre projet nommé libs. Modifiez le fichier build.gradle de votre application pour référencer le nouveau répertoire et remplacer la dépendance TensorFlow Lite 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 de paiement racine:

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 de disposer de la dépendance mavenLocal() et remplacez la dépendance TensorFlow Lite standard par celle 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 présentée ici est uniquement destinée à des fins de test ou de développement. Une fois l'AAR locale installée, vous pouvez utiliser les API d'inférence Java TensorFlow Lite standards dans le code de votre application.