Sélectionner des opérateurs TensorFlow

Étant donné que la bibliothèque d'opérateurs intégrée LiteRT n'est compatible qu'avec un nombre limité d'opérateurs TensorFlow, tous les modèles ne sont pas convertibles. Pour en savoir plus, consultez la section Compatibilité avec les opérateurs.

Pour autoriser la conversion, les utilisateurs peuvent activer l'utilisation de certaines opérations TensorFlow dans leur modèle LiteRT. Toutefois, l'exécution de modèles LiteRT avec des opérations TensorFlow nécessite d'extraire le runtime TensorFlow principal, ce qui augmente la taille du binaire de l'interpréteur LiteRT. Pour Android, vous pouvez éviter cela en compilant de manière sélective uniquement les opérations TensorFlow requises. Pour en savoir plus, consultez Réduire la taille du binaire.

Ce document explique comment convertir et exécuter un modèle LiteRT contenant des opérations TensorFlow sur la plate-forme de votre choix. Il aborde également les métriques de performances et de taille, ainsi que les limites connues.

Convertir un modèle

L'exemple suivant montre comment générer un modèle LiteRT avec des opérations TensorFlow sélectionnées.

import tensorflow as tf

converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.target_spec.supported_ops = [
  tf.lite.OpsSet.TFLITE_BUILTINS, # enable LiteRT ops.
  tf.lite.OpsSet.SELECT_TF_OPS # enable TensorFlow ops.
]
tflite_model = converter.convert()
open("converted_model.tflite", "wb").write(tflite_model)

Exécuter l'inférence

Lorsqu'un modèle LiteRT converti avec la prise en charge d'opérations TensorFlow sélectionnées est utilisé, le client doit également utiliser un environnement d'exécution LiteRT qui inclut la bibliothèque d'opérations TensorFlow nécessaire.

Android AAR

Pour réduire la taille du binaire, veuillez créer vos propres fichiers AAR personnalisés en suivant les instructions de la section suivante. Si la taille du binaire n'est pas un problème majeur, nous vous recommandons d'utiliser le fichier AAR précompilé avec les opérations TensorFlow hébergées sur MavenCentral.

Vous pouvez le spécifier dans vos dépendances build.gradle en l'ajoutant à côté de l'AAR LiteRT standard, comme suit :

dependencies {
    implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly-SNAPSHOT'
    // This dependency adds the necessary TF op support.
    implementation 'org.tensorflow:tensorflow-lite-select-tf-ops:0.0.0-nightly-SNAPSHOT'
}

Pour utiliser les instantanés nocturnes, assurez-vous d'avoir ajouté le dépôt d'instantanés Sonatype.

Une fois la dépendance ajoutée, le délégué nécessaire à la gestion des opérations TensorFlow du graphique doit être installé automatiquement pour les graphiques qui en ont besoin.

Remarque : La dépendance des opérations TensorFlow est relativement importante. Vous souhaiterez donc probablement filtrer les ABI x86 inutiles dans votre fichier .gradle en configurant votre abiFilters.

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

Créer l'AAR Android

Pour réduire la taille du binaire ou dans d'autres cas avancés, vous pouvez également compiler la bibliothèque manuellement. En supposant que vous disposez d'un environnement de compilation LiteRT fonctionnel, compilez l'AAR Android avec les opérations TensorFlow sélectionnées comme suit :

sh tensorflow/lite/tools/build_aar.sh \
  --input_models=/a/b/model_one.tflite,/c/d/model_two.tflite \
  --target_archs=x86,x86_64,arm64-v8a,armeabi-v7a

Cela générera le fichier AAR bazel-bin/tmp/tensorflow-lite.aar pour les opérations LiteRT intégrées et personnalisées, ainsi que le fichier AAR bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar pour les opérations TensorFlow. Si vous ne disposez pas d'un environnement de compilation fonctionnel, vous pouvez également compiler les fichiers ci-dessus avec Docker.

À partir de là, vous pouvez importer les fichiers AAR directement dans votre projet ou publier les fichiers AAR personnalisés dans votre dépôt Maven local :

mvn install:install-file \
  -Dfile=bazel-bin/tmp/tensorflow-lite.aar \
  -DgroupId=org.tensorflow \
  -DartifactId=tensorflow-lite -Dversion=0.1.100 -Dpackaging=aar
mvn install:install-file \
  -Dfile=bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar \
  -DgroupId=org.tensorflow \
  -DartifactId=tensorflow-lite-select-tf-ops -Dversion=0.1.100 -Dpackaging=aar

Enfin, dans le fichier build.gradle de votre application, assurez-vous d'avoir la dépendance mavenLocal() et remplacez la dépendance LiteRT standard par celle qui est compatible avec 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'
    implementation 'org.tensorflow:tensorflow-lite-select-tf-ops:0.1.100'
}

iOS

Utiliser CocoaPods

LiteRT fournit des CocoaPods d'opérations TF sélectionnées précompilées pour arm64, sur lesquels vous pouvez vous appuyer en plus des CocoaPods TensorFlowLiteSwift ou TensorFlowLiteObjC.

Remarque : Si vous devez utiliser des opérations TF spécifiques dans un simulateur x86_64, vous pouvez créer vous-même le framework d'opérations spécifiques. Pour en savoir plus, consultez la section Utiliser Bazel et Xcode.

# In your Podfile target:
  pod 'TensorFlowLiteSwift'   # or 'TensorFlowLiteObjC'
  pod 'TensorFlowLiteSelectTfOps', '~> 0.0.1-nightly'

Après avoir exécuté pod install, vous devez fournir un indicateur d'édition de liens supplémentaire pour forcer le chargement du framework d'opérations TF sélectionné dans votre projet. Dans votre projet Xcode, accédez à Build Settings > Other Linker Flags, puis ajoutez :

Pour les versions >= 2.9.0 :

-force_load $(SRCROOT)/Pods/TensorFlowLiteSelectTfOps/Frameworks/TensorFlowLiteSelectTfOps.xcframework/ios-arm64/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps

Pour les versions antérieures à 2.9.0 :

-force_load $(SRCROOT)/Pods/TensorFlowLiteSelectTfOps/Frameworks/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps

Vous devriez ensuite pouvoir exécuter tous les modèles convertis avec SELECT_TF_OPS dans votre application iOS. Par exemple, vous pouvez modifier l'application iOS de classification d'images pour tester la fonctionnalité de sélection des opérations TF.

• Remplacez le fichier de modèle par celui converti avec SELECT_TF_OPS activé.
• Ajoutez la dépendance TensorFlowLiteSelectTfOps à Podfile comme indiqué.
• Ajoutez l'indicateur de l'éditeur de liens supplémentaire comme indiqué ci-dessus.
• Exécutez l'exemple d'application et vérifiez si le modèle fonctionne correctement.

Utiliser Bazel et Xcode

LiteRT avec des opérations TensorFlow sélectionnées pour iOS peut être créé à l'aide de Bazel. Tout d'abord, suivez les instructions de compilation iOS pour configurer correctement votre espace de travail Bazel et votre fichier .bazelrc.

Une fois que vous avez configuré l'espace de travail avec la prise en charge d'iOS activée, vous pouvez utiliser la commande suivante pour créer le framework d'addon d'opérations TF sélectionnées, qui peut être ajouté en plus de l'outil TensorFlowLiteC.framework habituel. Notez que le framework d'opérations TF de sélection ne peut pas être créé pour l'architecture i386. Vous devez donc fournir explicitement la liste des architectures cibles, à l'exclusion de i386.

bazel build -c opt --config=ios --ios_multi_cpus=arm64,x86_64 \
  //tensorflow/lite/ios:TensorFlowLiteSelectTfOps_framework

Cela génère le framework dans le répertoire bazel-bin/tensorflow/lite/ios/. Vous pouvez ajouter ce nouveau framework à votre projet Xcode en suivant des étapes similaires à celles décrites dans la section Paramètres du projet Xcode du guide de compilation iOS.

Après avoir ajouté le framework au projet de votre application, un indicateur d'édition de liens supplémentaire doit être spécifié dans le projet de votre application pour forcer le chargement du framework d'opérations TF sélectionné. Dans votre projet Xcode, accédez à Build Settings > Other Linker Flags, puis ajoutez :

-force_load <path/to/your/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps>

C/C++

Si vous utilisez Bazel ou CMake pour compiler l'interpréteur LiteRT, vous pouvez activer le délégué Flex en associant une bibliothèque partagée de délégué LiteRT Flex. Vous pouvez le compiler avec Bazel à l'aide de la commande suivante.

bazel build -c opt --config=monolithic tensorflow/lite/delegates/flex:tensorflowlite_flex

Cette commande génère la bibliothèque partagée suivante dans bazel-bin/tensorflow/lite/delegates/flex.

Notez que les TfLiteDelegate nécessaires seront installés automatiquement lors de la création de l'interpréteur au moment de l'exécution, à condition que la bibliothèque partagée soit liée. Il n'est pas nécessaire d'installer explicitement l'instance déléguée, comme c'est généralement le cas avec d'autres types de délégués.

Remarque : Cette fonctionnalité est disponible depuis la version 2.7.

Python

LiteRT avec certaines opérations TensorFlow sera installé automatiquement avec le package pip TensorFlow. Vous pouvez également choisir d'installer uniquement le package pip de l'interpréteur LiteRT.

Métriques

Performances

Lorsque vous utilisez un mélange d'opérations TensorFlow intégrées et sélectionnées, toutes les optimisations LiteRT et les opérations intégrées optimisées sont disponibles et utilisables avec le modèle converti.

Le tableau suivant décrit le temps moyen nécessaire pour exécuter l'inférence sur MobileNet sur un Pixel 2. Les temps indiqués sont une moyenne de 100 exécutions. Ces cibles ont été conçues pour Android à l'aide des indicateurs suivants : --config=android_arm64 -c opt.

Taille binaire

Le tableau suivant décrit la taille binaire de LiteRT pour chaque build. Ces cibles ont été conçues pour Android à l'aide de --config=android_arm -c opt.

(1) Ces bibliothèques sont créées de manière sélective pour le modèle i3d-kinetics-400 avec huit opérations TFLite intégrées et trois opérations TensorFlow. Pour en savoir plus, consultez la section Réduire la taille du binaire LiteRT.

Limites connues

• Types non compatibles : il est possible que certaines opérations TensorFlow ne soient pas compatibles avec l'ensemble des types d'entrée/de sortie habituellement disponibles dans TensorFlow.

Mises à jour

• Version 2.6
  • La compatibilité avec les opérateurs basés sur les attributs GraphDef et les initialisations de ressources HashTable a été améliorée.
• Version 2.5
  • Vous pouvez appliquer une optimisation appelée quantification post-entraînement.
• Version 2.4
  • La compatibilité avec les délégués à accélération matérielle a été améliorée.