Présentation
Lorsque vous déployez des modèles pour des applications de machine learning sur l'appareil (ODML), il est important de tenir compte de la mémoire limitée disponible sur les appareils mobiles. Les tailles binaires du modèle sont étroitement liées au nombre d'opérations utilisées dans le modèle. TensorFlow Lite vous permet de réduire la taille binaire du modèle à l'aide de compilations sélectives. Les compilations sélectives ignorent les opérations inutilisées dans votre ensemble de modèles et produisent une bibliothèque compacte ne contenant que l'environnement d'exécution et les noyaux d'opérations requis pour que le modèle s'exécute sur votre appareil mobile.
La compilation sélective s'applique aux trois bibliothèques d'opérations suivantes.
- Bibliothèque d'opérations intégrée TensorFlow Lite
- Opérations personnalisées TensorFlow Lite
- Sélectionner la bibliothèque d'opérations TensorFlow
Le tableau ci-dessous montre l'impact des builds sélectifs pour certains cas d'utilisation courants:
Nom du modèle | Domaine | Architecture cible | Taille des fichiers AAR |
---|---|---|---|
Mobilenet_1.0_224(float) | Classification d'images | armeabi-v7a | tensorflow-lite.aar (296 635 octets) |
arm64-v8a | tensorflow-lite.aar (382 892 octets) | ||
ÉPICÉ | Extraction de la hauteur sonore | armeabi-v7a | tensorflow-lite.aar (375 813 octets) tensorflow-lite-select-tf-ops.aar (1 676 380 octets) |
arm64-v8a | tensorflow-lite.aar (421 826 octets) tensorflow-lite-select-tf-ops.aar (2 298 630 octets) |
||
i3d-kinetics-400 | Classification de vidéos | armeabi-v7a | tensorflow-lite.aar (240 085 octets) tensorflow-lite-select-tf-ops.aar (1 708 597 octets) |
arm64-v8a | tensorflow-lite.aar (273 713 octets) tensorflow-lite-select-tf-ops.aar (2 339 697 octets) |
Compiler de manière sélective TensorFlow Lite avec Bazel
Cette section suppose que vous avez téléchargé les codes sources TensorFlow et configuré l'environnement de développement local dans Bazel.
Créer des fichiers AAR pour le projet Android
Vous pouvez créer des fichiers AAR TensorFlow Lite personnalisés en fournissant les chemins d'accès aux fichiers de modèle 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
La commande ci-dessus génère le fichier AAR bazel-bin/tmp/tensorflow-lite.aar
pour les opérations TensorFlow Lite intégrées et personnalisées. Elle génère également le fichier AAR bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar
si vos modèles contiennent des opérations TensorFlow Lite. Notez que cela crée une AAR "fat" avec plusieurs architectures différentes. Si vous n'avez pas besoin de toutes, utilisez le sous-ensemble adapté à votre environnement de déploiement.
Compiler avec des opérations personnalisées
Si vous avez développé des modèles TensorFlow Lite avec des opérations personnalisées, vous pouvez les créer en ajoutant les options suivantes à la commande de compilation:
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 \
--tflite_custom_ops_srcs=/e/f/file1.cc,/g/h/file2.h \
--tflite_custom_ops_deps=dep1,dep2
L'option tflite_custom_ops_srcs
contient les fichiers sources de vos opérations personnalisées et l'option tflite_custom_ops_deps
contient les dépendances permettant de créer ces fichiers sources. Notez que ces dépendances doivent exister dans le dépôt TensorFlow.
Utilisations avancées: règles Bazel personnalisées
Si votre projet utilise Bazel et que vous souhaitez définir des dépendances TFLite personnalisées pour un ensemble de modèles donné, vous pouvez définir la ou les règles suivantes dans le dépôt de votre projet:
Pour les modèles avec les opérations intégrées uniquement:
load(
"@org_tensorflow//tensorflow/lite:build_def.bzl",
"tflite_custom_android_library",
"tflite_custom_c_library",
"tflite_custom_cc_library",
)
# A selectively built TFLite Android library.
tflite_custom_android_library(
name = "selectively_built_android_lib",
models = [
":model_one.tflite",
":model_two.tflite",
],
)
# A selectively built TFLite C library.
tflite_custom_c_library(
name = "selectively_built_c_lib",
models = [
":model_one.tflite",
":model_two.tflite",
],
)
# A selectively built TFLite C++ library.
tflite_custom_cc_library(
name = "selectively_built_cc_lib",
models = [
":model_one.tflite",
":model_two.tflite",
],
)
Pour les modèles dotés de l'option Select TF ops (Sélectionner des opérations TF) :
load(
"@org_tensorflow//tensorflow/lite/delegates/flex:build_def.bzl",
"tflite_flex_android_library",
"tflite_flex_cc_library",
)
# A Select TF ops enabled selectively built TFLite Android library.
tflite_flex_android_library(
name = "selective_built_tflite_flex_android_lib",
models = [
":model_one.tflite",
":model_two.tflite",
],
)
# A Select TF ops enabled selectively built TFLite C++ library.
tflite_flex_cc_library(
name = "selective_built_tflite_flex_cc_lib",
models = [
":model_one.tflite",
":model_two.tflite",
],
)
Utilisations avancées: Créer des bibliothèques partagées C/C++ personnalisées
Si vous souhaitez créer vos propres objets partagés TFLite C/C++ personnalisés pour les modèles donnés, procédez comme suit:
Créez un fichier Build temporaire en exécutant la commande suivante dans le répertoire racine du code source TensorFlow:
mkdir -p tmp && touch tmp/BUILD
Créer des objets C partagés personnalisés
Si vous souhaitez créer un objet partagé TFLite C personnalisé, ajoutez les éléments suivants au fichier tmp/BUILD
:
load(
"//tensorflow/lite:build_def.bzl",
"tflite_custom_c_library",
"tflite_cc_shared_object",
)
tflite_custom_c_library(
name = "selectively_built_c_lib",
models = [
":model_one.tflite",
":model_two.tflite",
],
)
# Generates a platform-specific shared library containing the TensorFlow Lite C
# API implementation as define in `c_api.h`. The exact output library name
# is platform dependent:
# - Linux/Android: `libtensorflowlite_c.so`
# - Mac: `libtensorflowlite_c.dylib`
# - Windows: `tensorflowlite_c.dll`
tflite_cc_shared_object(
name = "tensorflowlite_c",
linkopts = select({
"//tensorflow:ios": [
"-Wl,-exported_symbols_list,$(location //tensorflow/lite/c:exported_symbols.lds)",
],
"//tensorflow:macos": [
"-Wl,-exported_symbols_list,$(location //tensorflow/lite/c:exported_symbols.lds)",
],
"//tensorflow:windows": [],
"//conditions:default": [
"-z defs",
"-Wl,--version-script,$(location //tensorflow/lite/c:version_script.lds)",
],
}),
per_os_targets = True,
deps = [
":selectively_built_c_lib",
"//tensorflow/lite/c:exported_symbols.lds",
"//tensorflow/lite/c:version_script.lds",
],
)
La cible nouvellement ajoutée peut être créée comme suit:
bazel build -c opt --cxxopt=--std=c++17 \
//tmp:tensorflowlite_c
et pour Android (remplacez android_arm
par android_arm64
pour les versions 64 bits):
bazel build -c opt --cxxopt=--std=c++17 --config=android_arm \
//tmp:tensorflowlite_c
Créer des objets partagés C++ personnalisés
Si vous souhaitez créer un objet partagé TFLite C++ personnalisé, ajoutez les éléments suivants au fichier tmp/BUILD
:
load(
"//tensorflow/lite:build_def.bzl",
"tflite_custom_cc_library",
"tflite_cc_shared_object",
)
tflite_custom_cc_library(
name = "selectively_built_cc_lib",
models = [
":model_one.tflite",
":model_two.tflite",
],
)
# Shared lib target for convenience, pulls in the core runtime and builtin ops.
# Note: This target is not yet finalized, and the exact set of exported (C/C++)
# APIs is subject to change. The output library name is platform dependent:
# - Linux/Android: `libtensorflowlite.so`
# - Mac: `libtensorflowlite.dylib`
# - Windows: `tensorflowlite.dll`
tflite_cc_shared_object(
name = "tensorflowlite",
# Until we have more granular symbol export for the C++ API on Windows,
# export all symbols.
features = ["windows_export_all_symbols"],
linkopts = select({
"//tensorflow:macos": [
"-Wl,-exported_symbols_list,$(location //tensorflow/lite:tflite_exported_symbols.lds)",
],
"//tensorflow:windows": [],
"//conditions:default": [
"-Wl,-z,defs",
"-Wl,--version-script,$(location //tensorflow/lite:tflite_version_script.lds)",
],
}),
per_os_targets = True,
deps = [
":selectively_built_cc_lib",
"//tensorflow/lite:tflite_exported_symbols.lds",
"//tensorflow/lite:tflite_version_script.lds",
],
)
La cible nouvellement ajoutée peut être créée comme suit:
bazel build -c opt --cxxopt=--std=c++17 \
//tmp:tensorflowlite
et pour Android (remplacez android_arm
par android_arm64
pour les versions 64 bits):
bazel build -c opt --cxxopt=--std=c++17 --config=android_arm \
//tmp:tensorflowlite
Pour les modèles avec les opérations Select TF, vous devez également créer la bibliothèque partagée suivante:
load(
"@org_tensorflow//tensorflow/lite/delegates/flex:build_def.bzl",
"tflite_flex_shared_library"
)
# Shared lib target for convenience, pulls in the standard set of TensorFlow
# ops and kernels. The output library name is platform dependent:
# - Linux/Android: `libtensorflowlite_flex.so`
# - Mac: `libtensorflowlite_flex.dylib`
# - Windows: `libtensorflowlite_flex.dll`
tflite_flex_shared_library(
name = "tensorflowlite_flex",
models = [
":model_one.tflite",
":model_two.tflite",
],
)
La cible nouvellement ajoutée peut être créée comme suit:
bazel build -c opt --cxxopt='--std=c++17' \
--config=monolithic \
--host_crosstool_top=@bazel_tools//tools/cpp:toolchain \
//tmp:tensorflowlite_flex
et pour Android (remplacez android_arm
par android_arm64
pour les versions 64 bits):
bazel build -c opt --cxxopt='--std=c++17' \
--config=android_arm \
--config=monolithic \
--host_crosstool_top=@bazel_tools//tools/cpp:toolchain \
//tmp:tensorflowlite_flex
Compiler de façon sélective TensorFlow Lite avec Docker
Cette section suppose que vous avez installé Docker sur votre ordinateur local et téléchargé le fichier Dockerfile de TensorFlow Lite ici.
Après avoir téléchargé le fichier Dockerfile ci-dessus, vous pouvez créer l'image Docker en exécutant la commande suivante:
docker build . -t tflite-builder -f tflite-android.Dockerfile
Créer des fichiers AAR pour le projet Android
Téléchargez le script de compilation avec Docker en exécutant la commande suivante:
curl -o build_aar_with_docker.sh \
https://raw.githubusercontent.com/tensorflow/tensorflow/master/tensorflow/lite/tools/build_aar_with_docker.sh &&
chmod +x build_aar_with_docker.sh
Vous pouvez ensuite créer l'AAR TensorFlow Lite personnalisé en fournissant les chemins d'accès des fichiers de modèle comme suit.
sh build_aar_with_docker.sh \
--input_models=/a/b/model_one.tflite,/c/d/model_two.tflite \
--target_archs=x86,x86_64,arm64-v8a,armeabi-v7a \
--checkpoint=master \
[--cache_dir=<path to cache directory>]
L'option checkpoint
est un commit, une branche ou un tag du dépôt TensorFlow que vous souhaitez extraire avant de créer les bibliothèques. Par défaut, il s'agit de la dernière branche de version. La commande ci-dessus génère le fichier AAR tensorflow-lite.aar
pour les opérations personnalisées et intégrées de TensorFlow Lite, et éventuellement le fichier AAR tensorflow-lite-select-tf-ops.aar
pour la sélection d'opérations TensorFlow dans votre répertoire actuel.
L'option --cache_dir spécifie le répertoire de cache. S'il n'est pas fourni, le script crée un répertoire nommé bazel-build-cache
sous le répertoire de travail actuel pour la mise en cache.
Ajouter des fichiers AAR au projet
Ajoutez des fichiers AAR en important l'AAR directement dans votre projet ou en publiant l'AAR personnalisée dans votre dépôt Maven local. Notez que vous devez également ajouter les fichiers AAR pour tensorflow-lite-select-tf-ops.aar
si vous le générez.
Compilation sélective pour iOS
Consultez la section Compiler localement pour configurer l'environnement de compilation et l'espace de travail TensorFlow, puis suivez le guide pour utiliser le script de compilation sélective pour iOS.