Aide à protéger la Grande barrière de corail avec tensorflow sur Kaggle Rejoignez Défi

Créer TensorFlow Lite pour Android

Ce document explique 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 voulez juste utiliser, la façon la plus simple utilise le tensorflow AAR Lite hébergé à MavenCentral . Voir Android quickstart 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 référentiel 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 'http://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 pouvez construire un binaire personnalisé qui comprend les opérations sélectionnées à partir tensorflow , ou vous pouvez 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 à 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 à autre).

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

  • 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 que vous êtes à 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}"

Maintenant , vous devez passer à l' Configurer et .bazelrc Workspace section 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 l'utiliser, vous devez l'avoir ainsi que le NDK et le SDK Android installés sur votre système.

  1. Installer la dernière version du système de construction Bazel .
  2. Le NDK Android est requis pour créer le code TensorFlow Lite natif (C/C++). La version actuelle est recommandée 19c, 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 . L'API d'outils de création >= 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 qui est nécessaire pour créer les bibliothèques TF Lite. 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 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. 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-r19c"
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 l'AAR TensorFlow Lite à partir du répertoire d'extraction 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 un AAR « gros » avec plusieurs architectures différentes ; si vous n'en avez pas 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

Au- dessus de script générer le tensorflow-lite.aar fichier et éventuellement le tensorflow-lite-select-tf-ops.aar fichier si l' un des modèles est d' utiliser ops tensorflow. Pour plus de détails, s'il vous plaît voir la taille binaire Réduire tensorflow Lite section.

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 {
        mavenCentral()
        maven {  // Only for snapshot artifacts
            name 'ossrh-snapshot'
            url 'http://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 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 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 {
        mavenCentral()
        maven {  // Only for snapshot artifacts
            name 'ossrh-snapshot'
            url 'http://oss.sonatype.org/content/repositories/snapshots'
        }
        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.