Créer TensorFlow Lite pour Android

Ce document décrit comment créer vous-même la bibliothèque Android TensorFlow Lite. Normalement, vous n'avez pas besoin de créer localement la bibliothèque Android TensorFlow Lite. Si vous souhaitez simplement l'utiliser, consultez le démarrage rapide d'Android pour plus de détails sur la façon de les utiliser dans vos projets Android.

Utiliser des instantanés nocturnes

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

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

Créer TensorFlow Lite localement

Dans certains cas, vous souhaiterez peut-être utiliser une version locale de TensorFlow Lite. Par exemple, vous créez peut-être un binaire personnalisé qui inclut des opérations sélectionnées dans TensorFlow , ou vous souhaitez peut-être apporter des modifications locales à TensorFlow Lite.

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

  • Téléchargez le fichier Docker. En téléchargeant le fichier Docker, vous acceptez que les conditions d'utilisation suivantes régissent votre utilisation de celui-ci :

En cliquant pour accepter, vous acceptez par la présente que toute utilisation d'Android Studio et du kit de développement natif Android sera régie par le contrat de licence du kit de développement logiciel Android disponible sur https://developer.android.com/studio/terms (cette URL peut être mis à jour ou modifié par Google de temps à autre).

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

  • Vous pouvez éventuellement modifier la version du SDK Android ou du NDK. Placez le fichier Docker téléchargé dans un dossier vide et créez votre image Docker en exécutant :
docker build . -t tflite-builder -f tflite-android.Dockerfile
  • Démarrez le conteneur Docker de manière interactive en montant votre dossier actuel sur /host_dir à l'intérieur du conteneur (notez que /tensorflow_src est le référentiel TensorFlow à l'intérieur du conteneur) :
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 référentiel TensorFlow sur l'hôte, montez plutôt ce répertoire hôte (-v hostDir:/host_dir).

  • Une fois que vous êtes à l'intérieur du 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 construction.

Une fois que vous avez fini de créer les bibliothèques, vous pouvez les copier dans /host_dir à l'intérieur du conteneur afin de pouvoir y accéder sur l'hôte.

Configurer l'environnement de construction sans Docker

Installer les prérequis Bazel et Android

Bazel est le principal système de construction pour TensorFlow. Pour construire avec lui, 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 build Bazel .
  2. Le NDK Android est requis pour créer le code TensorFlow Lite natif (C/C++). La version actuellement recommandée est la 25b, qui peut être trouvée ici .
  3. Le SDK Android et les outils de construction peuvent être obtenus ici , ou bien dans le cadre d' Android Studio . L'API des outils de construction >= 23 est la version recommandée pour créer TensorFlow Lite.

Configurer WORKSPACE et .bazelrc

Il s'agit d'une étape de configuration unique requise pour créer les bibliothèques TF Lite. Exécutez le script ./configure dans le répertoire racine d'extraction de TensorFlow et répondez « Oui » lorsque le script demande de configurer de manière interactive les builds ./WORKSPACE pour 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 devrait générer des entrées similaires 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="26"
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"

Construire et installer

Une fois Bazel correctement configuré, vous pouvez créer l'AAR TensorFlow Lite à partir du répertoire racine d'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

Cela générera un fichier AAR dans bazel-bin/tensorflow/lite/java/ . Notez que cela construit un « gros » AAR avec plusieurs architectures différentes ; si vous n'en avez pas tous besoin, utilisez le sous-ensemble approprié à 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érera le fichier tensorflow-lite.aar et éventuellement le fichier tensorflow-lite-select-tf-ops.aar si l'un des modèles utilise les opérations Tensorflow. Pour plus de détails, veuillez consulter la section Réduire la taille binaire de TensorFlow Lite .

Ajouter AAR directement au projet

Déplacez le fichier tensorflow-lite.aar dans un répertoire appelé libs dans votre projet. Modifiez le fichier build.gradle de votre application pour référencer le nouveau répertoire et remplacez 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 AAR dans le référentiel Maven local

Exécutez la commande suivante à partir de votre répertoire racine d'extraction :

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 build.gradle de votre application, assurez-vous d'avoir la dépendance mavenLocal() et remplacez la dépendance TensorFlow Lite standard par celle qui prend en charge 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/développement. Une fois l'AAR local installé, vous pouvez utiliser les API d'inférence Java TensorFlow Lite standard dans le code de votre application.