Sélectionnez 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 à 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 les opérations TensorFlow nécessite l'extraction du moteur d'exécution TensorFlow principal, 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 une plate-forme de votre choix. Il aborde également les mesures de performances et de taille , ainsi que les limitations connues .

Convertir un modèle

L'exemple suivant montre comment générer un modèle TensorFlow Lite avec certaines opérations TensorFlow.

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, veuillez créer 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 à la gestion des opérations TensorFlow du graphique doit être automatiquement installé pour les graphiques qui les nécessitent.

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

Construire l'AAR Android

Pour réduire la taille binaire ou dans d’autres cas avancés, vous pouvez également créer la bibliothèque manuellement. En supposant qu'un environnement de génération TensorFlow Lite fonctionne , créez l'AAR Android avec certaines opérations TensorFlow 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érez 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 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

Utiliser des CocoaPods

TensorFlow Lite fournit chaque nuit des CocoaPods d'opérations TF prédéfinis pour arm64 , sur lesquels vous pouvez compter aux côtés des CocoaPods TensorFlowLiteSwift ou TensorFlowLiteObjC .

# 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'éditeur de liens 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 fonctionnalité de sélection des opérations TF.

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

Utiliser 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 iOS activée, vous pouvez utiliser la commande suivante pour créer le framework complémentaire TF ops sélectionné, qui peut être ajouté au-dessus du TensorFlowLiteC.framework standard. Notez que le cadre d'opérations TF sélectionné ne peut pas être construit pour l'architecture i386 , vous devez donc fournir explicitement la liste des architectures cibles à l'exclusion 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 Paramètres du projet Xcode dans le guide de construction iOS.

Après avoir ajouté le framework dans votre projet d'application, un indicateur d'éditeur de liens 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 tant que 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 .

Plate-forme 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 au moment 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.

Python

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

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 le temps moyen nécessaire pour exécuter l'inférence sur MobileNet sur un Pixel 2. Les temps indiqués correspondent à une moyenne de 100 exécutions. Ces cibles ont été créées pour Android à l'aide des indicateurs : --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é créées 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-kinétique-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

  • Version 2.6
    • La prise en charge des opérateurs basés sur les attributs GraphDef et des initialisations des ressources HashTable a été améliorée.
  • Version 2.5
  • Version 2.4
    • La compatibilité avec les délégués accélérés par le matériel s'est améliorée