Cette page a été traduite par l'API Cloud Translation.
Switch to English

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, le moyen le plus simple consiste à utiliser TensorFlow Lite AAR hébergé chez JCenter . Consultez le guide de démarrage rapide d'Android pour plus de détails sur leur utilisation dans vos projets Android.

Construire 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 souhaiterez 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 d'Android Native Development Kit sera régie par le contrat de licence du kit de développement logiciel Android disponible à l' adresse https://developer.android.com/studio/terms (une telle 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. Reconnaître

  • 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 / tmp à 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:/tmp 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 ce répertoire hôte à la place (-v hostDir: / tmp).

  • Une fois que vous êtes à l'intérieur du conteneur, vous pouvez exécuter ce qui suit pour télécharger des outils et bibliothèques Android supplémentaires (notez que vous devrez peut-être accepter la licence):
android update sdk --no-ui -a --filter tools,platform-tools,android-${ANDROID_API_LEVEL},build-tools-${ANDROID_BUILD_TOOLS_VERSION}

Vous pouvez maintenant passer à la section "Construire et installer". Une fois que vous avez terminé de créer les bibliothèques, vous pouvez les copier dans / tmp à 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 système de construction principal pour TensorFlow. Pour créer 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 17c, que vous pouvez trouver ici .
  3. Le SDK Android et les outils de construction peuvent être obtenus ici , ou 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

Exécutez le script ./configure dans le répertoire de contrôle racine de TensorFlow et répondez «Oui» lorsque le script demande de configurer de manière interactive le ./WORKSPACE pour les versions 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 similaires aux suivantes dans le fichier .tf_configure.bazelrc dans le dossier racine:

build --action_env ANDROID_NDK_HOME="/usr/local/android/android-ndk-r17c"
build --action_env ANDROID_NDK_API_LEVEL="21"
build --action_env ANDROID_BUILD_TOOLS_VERSION="28.0.3"
build --action_env ANDROID_SDK_API_LEVEL="23"
build --action_env ANDROID_SDK_HOME="/usr/local/android/android-sdk-linux"

Construire et installer

Une fois que Bazel est correctement configuré, vous pouvez créer le TensorFlow Lite AAR à partir du répertoire de retrait racine comme suit:

bazel build -c opt --fat_apk_cpu=x86,x86_64,arm64-v8a,armeabi-v7a \
  --host_crosstool_top=@bazel_tools//tools/cpp:toolchain \
  //tensorflow/lite/java:tensorflow-lite

Cela générera un fichier AAR dans bazel-bin/tensorflow/lite/java/ . Notez que cela construit un AAR "gros" avec plusieurs architectures différentes; si vous n'avez pas besoin de tous, utilisez le sous-ensemble approprié à votre environnement de déploiement.

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 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 {
        jcenter()
        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 de retrait 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 build.gradle votre application, assurez-vous que vous disposez de la dépendance mavenLocal() et remplacez la dépendance TensorFlow Lite standard par celle qui prend en charge certaines opérations TensorFlow:

allprojects {
    repositories {
        jcenter()
        mavenLocal()
    }
}

dependencies {
    implementation 'org.tensorflow:tensorflow-lite:0.1.100'
}

Notez que la version 0.1.100 ici est purement pour des raisons de test / 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.