Présentation de LiteRT: l'environnement d'exécution Google hautes performances pour l'IA sur l'appareil, anciennement connu sous le nom de TensorFlow Lite.

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

Compiler LiteRT pour Android

Ce document explique comment compiler une bibliothèque Android LiteRT sur votre vous-même. Normalement, vous n'avez pas besoin de compiler localement la bibliothèque Android LiteRT.

Utiliser les photos instantanées

Pour utiliser des instantanés nocturnes, ajoutez le dépôt suivant à votre build Gradle racine configuration.

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

ajouter des instantanés nocturnes aux dépendances (ou les modifier si nécessaire) dans votre fichier build.gradle

...
dependencies {
    ...
    implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly-SNAPSHOT'
    implementation 'com.google.ai.edge.litert:litert-gpu:0.0.0-nightly-SNAPSHOT'
    implementation 'com.google.ai.edge.litert:litert-support:0.0.0-nightly-SNAPSHOT'
    ...
}
...

Créer LiteRT en local

Dans certains cas, vous pouvez utiliser un build local de LiteRT. Pour Par exemple, vous pouvez créer un binaire personnalisé des opérations sélectionnées dans TensorFlow, ou apportez des modifications locales à LiteRT.

Configurer un environnement de compilation à 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 leur utilisation:

En cliquant sur "Accepter", vous acceptez que toute utilisation d'Android Studio et Le kit de développement Android natif sera régi par le Logiciel Android Contrat de licence du kit de développement disponible à l'adresse https://developer.android.com/studio/terms (cette URL est susceptible d'être mise à jour ou modifiée) par Google de temps en temps).

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

Vous pouvez éventuellement modifier la version du SDK ou du NDK Android. Placez le fichier Docker dans un dossier vide et créez votre image Docker en exécutant la commande suivante:

docker build . -t tflite-builder -f tflite-android.Dockerfile

Démarrez le conteneur Docker de manière interactive en installant votre dossier actuel sur /host_dir à l'intérieur du conteneur (notez que /tensorflow_src correspond au répertoire dans le 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 dépôt TensorFlow sur l'hôte, installez cet hôte (-v hostDir:/host_dir).

Une fois dans le conteneur, vous pouvez exécuter la commande suivante pour télécharger d'autres outils et bibliothèques Android (notez que vous devrez peut-être accepter les licence):

sdkmanager \
  "build-tools;${ANDROID_BUILD_TOOLS_VERSION}" \
  "platform-tools" \
  "platforms;android-${ANDROID_API_LEVEL}"

Vous devez maintenant passer à la section Configure WORKSPACE and .bazelrc (Configurer l'espace de travail et le fichier .bazelrc) pour configurer les paramètres de compilation.

Après avoir terminé de compiler les bibliothèques, vous pouvez les copier dans /host_dir à l'intérieur du conteneur afin que vous puissiez y accéder sur l'hôte.

Configurer un environnement de compilation sans Docker

Installer les prérequis Bazel et Android

Bazel est le principal système de compilation de TensorFlow. Pour utiliser ce modèle de développement, vous devez et le NDK et le SDK Android sont installés sur votre système.

Installez la dernière version du système de compilation Bazel.
Le NDK Android est requis pour compiler la version LiteRT native (C/C++) du code source. La version 25b actuellement recommandée est la version 25b. cliquez ici.
Vous pouvez obtenir le SDK Android et les outils de compilation cliquez ici ou ou dans le cadre Android Studio Compilation L'API Tools 23 ou version ultérieure est la version recommandée pour compiler LiteRT.

Configurer WORKSPACE et .bazelrc

Il s'agit d'une étape de configuration unique qui est nécessaire pour créer LiteRT bibliothèques. Exécuter le script ./configure dans le processus d'extraction TensorFlow racine et répondez « Oui » Lorsque le script demande à configurer de manière interactive ./WORKSPACE pour les builds Android. Le script tente de configurer les paramètres à l'aide de la méthode les 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 le script requête. Une configuration réussie doit générer des entrées semblables à ce qui suit 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="21"
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"

Compiler et installer

Une fois que Bazel est correctement configuré, vous pouvez créer l'AAR LiteRT à partir de le répertoire de paiement racine 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

Un fichier AAR sera généré dans bazel-bin/tensorflow/lite/java/. Remarque que cela crée un « graisse » AAR avec plusieurs architectures différentes : si vous ne avez besoin de tous, utilisez le sous-ensemble adapté à votre environnement de déploiement.

Pour créer des fichiers AAR plus petits ciblant uniquement un ensemble de modèles, procédez 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ère le fichier tensorflow-lite.aar et, éventuellement, le tensorflow-lite-select-tf-ops.aar si l'un des modèles utilise TensorFlow Ops. Pour en savoir plus, consultez les Section Réduire la taille binaire de LiteRT.

Ajouter l'AAR directement au projet

Déplacez le fichier tensorflow-lite.aar dans un répertoire nommé libs dans votre projet. Modifiez le fichier build.gradle de votre application pour référencer le nouveau répertoire. et remplacer la dépendance LiteRT existante par la nouvelle bibliothèque locale, e.g.:

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 l'AAR dans le dépôt 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 le fichier build.gradle de votre application, vérifiez que vous disposez de la dépendance mavenLocal() et remplacez la dépendance LiteRT standard par celle qui est compatible pour 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 de 0.1.100 n'est utilisée ici qu'à des fins les tests/le développement. Une fois l'AAR local installé, vous pouvez utiliser API d'inférence Java LiteRT dans le code de votre application.