Étant donné que la bibliothèque d'opérateurs intégrés TensorFlow Lite n'accepte qu'un nombre limité d'opérateurs TensorFlow, tous les modèles ne sont pas convertibles. Pour plus d'informations, reportez-vous à la section Compatibilité des opérateurs.
Pour autoriser la conversion, les utilisateurs peuvent autoriser l'utilisation de certaines opérations TensorFlow dans leur modèle TensorFlow Lite. Toutefois, l'exécution de modèles TensorFlow Lite avec des opérations TensorFlow nécessite l'utilisation de l'environnement 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 en savoir plus, consultez la section Réduire la taille binaire.
Ce document explique comment convertir et run un modèle TensorFlow Lite contenant des opérations TensorFlow sur la plate-forme de votre choix. Il traite également des métriques sur les performances et la taille, ainsi que sur les limites connues.
Convertir un modèle
L'exemple suivant montre comment générer un modèle TensorFlow Lite avec des 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 une inférence
Lorsque vous utilisez un modèle TensorFlow Lite qui a été converti compatible avec certaines opérations TensorFlow, le client doit également utiliser un environnement d'exécution TensorFlow Lite qui inclut la bibliothèque d'opérations TensorFlow nécessaire.
AAR Android
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 important, nous vous recommandons d'utiliser l'AAR prédéfini avec des opérations TensorFlow hébergées sur MavenCentral.
Vous pouvez le spécifier dans vos dépendances build.gradle en l'ajoutant à 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 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 devrait être automatiquement installé pour les graphiques qui en ont besoin.
Remarque: La dépendance des opérations TensorFlow étant relativement importante, vous souhaiterez 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 d'autres cas avancés, vous pouvez également créer la bibliothèque manuellement. Dans un environnement de compilation TensorFlow Lite fonctionnel, créez l'AAR Android à l'aide de 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
Le fichier AAR bazel-bin/tmp/tensorflow-lite.aar est généré pour les opérations TensorFlow Lite intégrées et personnalisées, et le fichier AAR bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar pour les opérations TensorFlow. Si vous n'avez pas d'environnement de compilation opérationnel, vous pouvez également compiler les fichiers ci-dessus avec Docker.
Vous pouvez alors 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 que la dépendance mavenLocal() est définie et remplacez la dépendance TensorFlow Lite 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
TensorFlow Lite fournit des CocoaPods de sélection de tâches TF prédéfinis la nuit pour arm64, sur lesquels 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 d'opérations select. Pour en savoir plus, consultez la section Utiliser Bazel + 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'association supplémentaire pour forcer le chargement du framework d'opérations TF Ops dans votre projet. Dans votre projet Xcode, accédez à Build Settings -> Other Linker Flags, puis ajoutez:
Pour les versions 2.9.0 ou ultérieures:
-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 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_OPSactivé. - Ajoutez la dépendance
TensorFlowLiteSelectTfOpsàPodfilecomme indiqué. - Ajoutez l'indicateur Linker supplémentaire comme indiqué ci-dessus.
- Exécutez l'exemple d'application et vérifiez 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 compilation iOS pour configurer correctement votre espace de travail Bazel et le fichier .bazelrc.
Une fois que vous avez configuré l'espace de travail en activant la compatibilité avec iOS, vous pouvez utiliser la commande suivante pour créer le framework du module complémentaire TF Ops, qui peut être ajouté au TensorFlowLiteC.framework standard. Notez que le framework TF Ops sélectionné ne peut pas être créé pour l'architecture i386. Vous devez donc fournir explicitement la liste des architectures cibles, à l'exception de i386.
bazel build -c opt --config=ios --ios_multi_cpus=arm64,x86_64 \
//tensorflow/lite/ios:TensorFlowLiteSelectTfOps_framework
Le framework est alors généré dans 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 du guide de création iOS.
Après avoir ajouté le framework à votre projet d'application, vous devez spécifier un indicateur d'association supplémentaire 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, puis 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 associant une bibliothèque partagée déléguée TensorFlow Lite. Vous pouvez le compiler avec Bazel via 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.
| Plate-forme | Nom de la bibliothèque |
|---|---|
| Linux | libtensorflowlite_flex.so |
| macOS | libtensorflowlite_flex.dylib |
| Windows | tensorflowlite_flex.dll |
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 associée. Il n'est pas nécessaire d'installer explicitement l'instance déléguée, comme cela est généralement nécessaire 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 pip TensorFlow. Vous pouvez également choisir d'installer uniquement le package pip d'interpréteur TensorFlow Lite.
Métriques
Performances
Lorsque vous utilisez à la fois des opérations intégrées et des opérations TensorFlow spécifiques, toutes les optimisations TensorFlow Lite 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 une inférence sur MobileNet sur un Pixel 2. Les durées indiquées correspondent à une moyenne de 100 courses. Ces cibles ont été créées pour Android à l'aide des indicateurs: --config=android_arm64 -c opt.
| Créer | Durée (millisecondes) |
|---|---|
Opérations intégrées uniquement (TFLITE_BUILTIN) |
260,7 |
Utiliser uniquement des 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 avec --config=android_arm -c opt.
| Créer | Taille binaire C++ | Taille de l'APK Android |
|---|---|---|
| Uniquement les opérations intégrées | 796 Ko | 561 Ko |
| Opérations intégrées et opérations TF | 23,0 Mo | 8,0 Mo |
| Opérations intégrées et opérations TF (1) | 4,1 Mo | 1,8 Mo |
(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 binaire de TensorFlow Lite.
Limitations connues
- Types non compatibles: certaines opérations TensorFlow peuvent ne pas être compatibles avec l'ensemble des types d'entrées/sorties 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 de l'initialisation des 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 avec accélération matérielle s'est améliorée.