É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
auPodfile
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 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 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 |
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
- Vous pouvez appliquer une optimisation connue sous le nom de quantification post-formation
- Version 2.4
- La compatibilité avec les délégués accélérés par le matériel s'est améliorée