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

Android QuickStart

Pour commencer à utiliser tensorflow Lite sur Android, nous vous recommandons d'explorer l'exemple suivant.

Exemple de classification d'image Android

Lire tensorflow Lite Android classement d'image pour une explication du code source.

Cette application exemple utilise la classification d'images pour classer en permanence ce qu'il voit de la caméra face à l' arrière de l'appareil. L'application peut fonctionner soit sur l'appareil ou l'émulateur.

Inference est réalisée en utilisant la tensorflow Lite API Java et le support Android tensorflow Lite Library . L'application de démonstration classifie les images en temps réel, affichant les classements les plus probables. Top Il permet à l'utilisateur de choisir entre un virgule flottante ou quantifiée modèle, sélectionnez le nombre de threads, et décider si vous souhaitez exécuter sur le processeur, GPU, ou via NNAPI .

Construire dans Android studio

Pour construire l'exemple dans Android studio, suivez les instructions README.md .

Créez votre propre application Android

Pour commencer à écrire rapidement votre propre code Android, nous vous recommandons d' utiliser notre exemple de classification d'image Android comme point de départ.

Les sections suivantes contiennent des informations utiles pour travailler avec tensorflow Lite sur Android.

Utilisez le tensorflow Lite Android de soutien aux bibliothèques

Le support Android tensorflow Lite Library facilite l'intégration des modèles dans votre application. Il fournit des API de haut niveau qui contribuent à transformer les données brutes d'entrée dans la forme requise par le modèle, et interpréter la sortie du modèle, ce qui réduit la quantité de code nécessaire boilerplate.

Il prend en charge les formats de données communs pour les entrées et les sorties, y compris les images et les tableaux. Il fournit également des unités pré et post-traitement qui exécutent des tâches telles que le redimensionnement de l'image et le recadrage.

Pour commencer, suivez les instructions du tensorflow Lite Android de soutien aux bibliothèques README.md .

Utilisez le tensorflow AAR Lite de JCenter

Pour utiliser tensorflow Lite dans votre application Android, nous vous recommandons d' utiliser le tensorflow AAR Lite hébergé chez JCenter .

Vous pouvez spécifier dans vos build.gradle dépendances comme suit:

 dependencies {
    implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly'
}
 

Ce AAR comprend les binaires pour tous les Android ABIs . Vous pouvez réduire la taille en ne retenant que le binaire de votre application les ABIs dont vous avez besoin de soutien.

Nous vous recommandons la plupart des développeurs omettent le x86 , x86_64 et arm32 ABIs. Ceci peut être réalisé avec la configuration suivante Gradle, qui inclut spécifiquement que armeabi-v7a et arm64-v8a , qui devrait couvrir la plupart des appareils Android modernes.

 android {
    defaultConfig {
        ndk {
            abiFilters 'armeabi-v7a', 'arm64-v8a'
        }
    }
}
 

Pour en savoir plus sur abiFilters , voir NdkOptions dans la documentation Gradle Android.

Construire tensorflow Lite localement

Dans certains cas, vous voudrez peut-être utiliser une version locale de tensorflow Lite. Par exemple, vous pouvez construire un binaire personnalisé qui comprend les opérations sélectionnées à partir tensorflow , ou vous pouvez apporter des modifications locales à tensorflow Lite.

Mettre en place l'environnement de construction en utilisant Docker

  • Télécharger 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 à accepter, vous acceptez que toute utilisation du Studio Android et Android Development Kit natif sera régie par l'accord de développement logiciel Android Kit de licence disponible à https://developer.android.com/studio/terms ( par exemple URL peut être mis à jour ou modifié par Google de temps en temps).

Vous devez accepter les conditions de service pour télécharger le fichier. Reconnaissez

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

Si vous utilisez Windows PowerShell, remplacer "$ PWD" avec "passwd".

Si vous souhaitez utiliser un référentiel tensorflow sur l'hôte, monter ce répertoire hôte à la place (-v HOSTDIR: / tmp).

  • Une fois que vous êtes à l'intérieur du conteneur, vous pouvez exécuter les opérations suivantes 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é la construction des bibliothèques, vous pouvez les copier / tmp à l'intérieur du conteneur afin que vous puissiez y accéder à l'hôte.

Mettre en place l'environnement de construction sans Docker

Installer Bazel et Pré-requis Android

Bazel est le principal système de construction pour tensorflow. Pour construire avec elle, vous devez avoir et Android NDK et le SDK installé sur votre système.

  1. Installer la dernière version du système de construction Bazel .
  2. Android NDK est nécessaire pour construire le natif (C / C ++) tensorflow Code Lite. La version actuelle est recommandée 17c, qui peut être trouvé ici .
  3. Le SDK Android et les outils de construction peuvent être obtenus ici , ou encore dans le cadre de l' Android studio . Outils de construction API> = 23 est la version recommandée pour la construction de tensorflow Lite.
Configurer et .bazelrc Workspace

Exécutez le ./configure script dans le répertoire de la caisse de tensorflow racine, et la réponse « Oui » lorsque le script demande de configurer de manière interactive le ./WORKSPACE pour Android construit. Le script tentera de paramètres configure à 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, ils doivent être fournis de manière interactive dans l'invite de script. Configuration réussie devrait donner des entrées semblables à ce qui suit dans le .tf_configure.bazelrc fichier 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 Bazel est correctement configuré, vous pouvez construire le tensorflow AAR Lite à partir du répertoire de la caisse 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 va générer un fichier AAR dans bazel-bin/tensorflow/lite/java/ . Notez que cela construit une AAR « gras » avec plusieurs architectures différentes; si vous n'avez pas besoin tous, utilisez le sous-ensemble approprié pour votre environnement de déploiement. A partir de là, il y a plusieurs approches que vous pouvez prendre pour utiliser le .aar dans votre projet Android Studio.

Ajouter AAR directement au projet

Déplacez le tensorflow-lite.aar fichier dans un répertoire appelé libs dans votre projet. Modifier votre application de build.gradle fichier pour référencer le nouveau répertoire et remplacer le tensorflow existant dépendance Lite avec la nouvelle bibliothèque locale, par exemple:

 allprojects {
    repositories {
        jcenter()
        flatDir {
            dirs 'libs'
        }
    }
}

dependencies {
    compile(name:'tensorflow-lite', ext:'aar')
}
 
Installer AAR au dépôt local

Exécutez la commande suivante à partir du répertoire de la caisse 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 votre application build.gradle , assurez -vous que vous avez la mavenLocal() la dépendance et remplacer la dépendance norme tensorflow Lite avec celui qui a le soutien pour sélectionner les opérations de tensorflow:

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

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

Notez que la 0.1.100 version ici est purement pour des raisons de tests / développement. Avec l'AAR local installé, vous pouvez utiliser la norme inférence tensorflow Lite Java API dans votre code d'application.

Construire l'application Android en C ++

Il y a deux façons d'utiliser TFLite par C ++ si vous construisez votre application avec le NDK:

Utilisez API TFLite C

Telle est l'approche recommandée. Télécharger le tensorflow AAR Lite hébergé chez JCenter , renommez- tensorflow-lite-*.zip , Et décompressez. Vous devez inclure les quatre fichiers d' en- tête en - headers/tensorflow/lite/ et en- headers/tensorflow/lite/c/ dossier et pertinents libtensorflowlite_jni.so bibliothèque dynamique dans jni/ dossier dans votre projet NDK.

Le c_api.h fichier d' en- tête contient de la documentation de base sur l' utilisation de l'API TFLite C.

API Utiliser TFLite C

Si vous souhaitez utiliser TFLite via l'API C ++, vous pouvez construire les bibliothèques partagées C ++:

32bit armeabi-V7A:

 bazel build -c opt --config=android_arm //tensorflow/lite:libtensorflowlite.so
 

64bit arm64-v8a:

 bazel build -c opt --config=android_arm64 //tensorflow/lite:libtensorflowlite.so
 

À l' heure actuelle, il n'y a aucun moyen simple d'extraire tous les fichiers d' en- tête nécessaires, de sorte que vous devez inclure tous les fichiers d' en- tête dans tensorflow/lite/ du dépôt de tensorflow. De plus, vous aurez besoin des fichiers en- tête de FlatBuffers et Abseil .