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

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 guide de démarrage rapide 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'
        }
    }
}

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 à partir de 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 en régissent l'utilisation :

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 à l' adresse https://developer.android.com/studio/terms (cette URL peut être mis à jour ou modifiés par Google de temps à autre).

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

Vous pouvez éventuellement modifier la version Android SDK ou 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 à l'intérieur du conteneur, vous pouvez exécuter ce qui suit 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 terminé 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 système de build principal pour TensorFlow. Pour construire avec, vous devez l'avoir ainsi que le NDK et le SDK Android installés sur votre système.

Installez la dernière version du système de construction Bazel .
Le NDK Android est requis pour créer le code natif (C/C++) TensorFlow Lite. La version actuellement recommandée est 21e, qui peut être trouvée ici .
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 compilation >= 23 est la version recommandée pour la création de 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 de paiement racine de TensorFlow et répondez "Oui" lorsque le script vous demande de configurer de manière interactive le ./WORKSPACE 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 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-r21e"
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 que Bazel est correctement configuré, vous pouvez créer l'AAR TensorFlow Lite à partir du répertoire de paiement 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 \
  --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 AAR "gras" 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 Tensorflow ops. 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 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 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 purement à des fins de test/développement. Une fois l'AAR local installé, vous pouvez utiliser les API d'inférence Java standard de TensorFlow Lite dans le code de votre application.