Sélectionner les opérateurs TensorFlow

Étant donné que la bibliothèque d'opérateurs intégrée TensorFlow Lite ne prend en charge qu'un nombre limité d'opérateurs TensorFlow, tous les modèles ne sont pas convertibles. Pour plus de détails, reportez-vous à la compatibilité des opérateurs .

Pour autoriser la conversion, les utilisateurs peuvent activer l'utilisation de certaines opérations TensorFlow dans leur modèle TensorFlow Lite. Cependant, l'exécution de modèles TensorFlow Lite avec des opérations TensorFlow nécessite l'extraction du runtime principal de TensorFlow, ce qui augmente la taille binaire de l'interpréteur TensorFlow Lite. Pour Android, vous pouvez éviter cela en créant de manière sélective uniquement les opérations Tensorflow requises. Pour plus de détails, reportez-vous à réduire la taille binaire .

Ce document explique comment convertir et exécuter un modèle TensorFlow Lite contenant des opérations TensorFlow sur la plate-forme de votre choix. Il traite également des mesures de performances et de taille et des limitations connues .

Convertir un modèle

L'exemple suivant montre comment générer un modèle TensorFlow Lite 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 TensorFlow Lite 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

Lors de l'utilisation d'un modèle TensorFlow Lite qui a été converti avec la prise en charge de certaines opérations TensorFlow, le client doit également utiliser un environnement d'exécution TensorFlow Lite qui inclut la bibliothèque nécessaire d'opérations TensorFlow.

RAA Android

Pour réduire la taille binaire, créez vos propres fichiers AAR personnalisés comme indiqué dans la section suivante . Si la taille binaire n'est pas un problème considérable, nous vous recommandons d'utiliser l' AAR prédéfini 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 TensorFlow Lite 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 des instantanés nocturnes, assurez-vous d'avoir ajouté le référentiel d'instantanés Sonatype .

Une fois que vous avez ajouté la dépendance, le délégué nécessaire pour gérer les opérations TensorFlow du graphique doit être automatiquement installé pour les graphiques qui en ont besoin.

Remarque : la dépendance de TensorFlow ops est relativement importante, vous souhaiterez donc probablement filtrer les ABI x86 inutiles dans votre fichier .gradle en configurant vos abiFilters .

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

Construire l'AAR Android

Pour réduire la taille binaire ou d'autres cas avancés, vous pouvez également créer la bibliothèque manuellement. En supposant qu'un environnement de compilation TensorFlow Lite fonctionne , créez l'AAR Android avec des 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 intégrées et personnalisées de TensorFlow Lite ; et générer le fichier AAR bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar pour TensorFlow ops. Si vous ne disposez pas d'un environnement de construction fonctionnel, vous pouvez également créer les fichiers ci-dessus avec docker .

À partir de là, vous pouvez soit importer les fichiers AAR directement dans votre projet, soit publier les fichiers AAR personnalisés dans votre référentiel 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 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'
    implementation 'org.tensorflow:tensorflow-lite-select-tf-ops:0.1.100'
}

iOS

Utilisation de CocoaPods

TensorFlow Lite fournit des CocoaPods d'opérations TF prédéfinies pour arm64 , sur lesquelles vous pouvez compter avec les CocoaPods TensorFlowLiteSwift ou TensorFlowLiteObjC .

Remarque : si vous devez utiliser select TF ops dans un simulateur x86_64 , vous pouvez créer vous-même le framework select ops. Voir la section Utilisation de Bazel + Xcode pour plus de détails.

# 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 de lien supplémentaire pour forcer le chargement du framework TF ops sélectionné dans votre projet. Dans votre projet Xcode, accédez à Build Settings -> Other Linker Flags et ajoutez :

Pour les versions >= 2.9.0 :

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

Pour les versions < 2.9.0 :

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

Vous devriez alors pouvoir exécuter tous les modèles convertis avec SELECT_TF_OPS dans votre application iOS. Par exemple, vous pouvez modifier l' application iOS Image Classification pour tester la fonction Select TF ops.

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

Utilisation de Bazel + Xcode

TensorFlow Lite avec certaines opérations TensorFlow pour iOS peut être créé à l'aide de Bazel. Tout d'abord, suivez les instructions de construction 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 select TF ops, qui peut être ajouté au-dessus du TensorFlowLiteC.framework normal. Notez que le framework TF ops sélectionné ne peut pas être construit 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érera le framework sous le répertoire bazel-bin/tensorflow/lite/ios/ . Vous pouvez ajouter ce nouveau framework à votre projet Xcode en suivant les étapes similaires décrites dans la section des paramètres du projet Xcode dans le guide de construction iOS.

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

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

C/C++

Si vous utilisez Bazel ou CMake pour créer un interpréteur TensorFlow Lite, vous pouvez activer le délégué Flex en liant une bibliothèque partagée de délégué TensorFlow Lite Flex. Vous pouvez le construire avec Bazel en utilisant 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 .

Plateforme	Nom de la bibliothèque
Linux	libtensorflowlite_flex.so
macOS	libtensorflowlite_flex.dylib
les fenêtres	tensorflowlite_flex.dll

Notez que le TfLiteDelegate nécessaire sera installé automatiquement lors de la création de l'interpréteur lors de l'exécution tant que la bibliothèque partagée est liée. Il n'est pas nécessaire d'installer explicitement l'instance de délégué, comme cela est généralement requis avec d'autres types de délégués.

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

Python

TensorFlow Lite avec certaines opérations TensorFlow sera installé automatiquement avec le package TensorFlow pip . Vous pouvez également choisir de n'installer que le package pip TensorFlow Lite Interpreter .

Remarque : TensorFlow Lite avec certaines opérations TensorFlow est disponible dans la version du package TensorFlow pip depuis la version 2.3 pour Linux et la version 2.4 pour les autres environnements.

Métrique

Performance

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

Le tableau suivant décrit la durée moyenne d'exécution de l'inférence sur MobileNet sur un Pixel 2. Les durées indiquées correspondent à une moyenne de 100 exécutions. Ces cibles ont été construites pour Android en utilisant les drapeaux : --config=android_arm64 -c opt .

Construire	Temps (millisecondes)
Uniquement les opérations intégrées ( TFLITE_BUILTIN )	260.7
Utiliser uniquement les opérations TF ( SELECT_TF_OPS )	264,5

Taille binaire

Le tableau suivant décrit la taille binaire de TensorFlow Lite pour chaque build. Ces cibles ont été construites pour Android en utilisant --config=android_arm -c opt .

Construire	Taille binaire C++	Taille de l'APK Android
Uniquement les opérations intégrées	796 Ko	561 Ko
Opérations intégrées + opérations TF	23,0 Mo	8,0 Mo
Opérations intégrées + opérations TF (1)	4,1 Mo	1,8 Mo

(1) Ces bibliothèques sont construites de manière sélective pour le modèle i3d-kinetics-400 avec 8 opérations intégrées TFLite et 3 opérations Tensorflow. Pour plus de détails, veuillez consulter la section Réduire la taille binaire de TensorFlow Lite .

Limites connues

• Types non pris en charge : certaines opérations TensorFlow peuvent ne pas prendre en charge l'ensemble complet des types d'entrée/sortie généralement disponibles dans TensorFlow.

Mises à jour

• Variante 2.6
  • La prise en charge des opérateurs basés sur les attributs GraphDef et les initialisations des ressources HashTable ont été améliorées.
• Variante 2.5
  • Vous pouvez appliquer une optimisation connue sous le nom de quantification post-formation
• Variante 2.4
  • La compatibilité avec les délégués accélérés par le matériel s'est améliorée