Réduire la taille binaire de LiteRT

Présentation

Lors du déploiement de modèles pour des applications de machine learning sur l'appareil (ODML), il est important d'être conscient 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 du modèle. LiteRT vous permet de réduire la taille binaire des modèles en utilisant les compilations sélectives. Les compilations sélectives ignorent les opérations inutilisées dans votre ensemble de modèles et générer une bibliothèque compacte avec uniquement l'environnement d'exécution et les noyaux opérationnels requis pour le modèle à exécuter sur votre appareil mobile.

La compilation sélective s'applique aux trois bibliothèques d'opérations suivantes.

  1. Bibliothèque d'opérations intégrée LiteRT
  2. Opérations personnalisées LiteRT
  3. Sélectionner la bibliothèque d'opérations TensorFlow

Le tableau ci-dessous montre l'impact des builds sélectifs pour une utilisation courante cas:

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)

Développer de manière sélective LiteRT avec Bazel

Dans cette section, nous partons du principe que vous avez téléchargé les codes source TensorFlow et défini le développement local environnement pour Bazel.

Créer des fichiers AAR pour le projet Android

Vous pouvez créer des AAR LiteRT personnalisées en fournissant les chemins d'accès aux fichiers de votre 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 LiteRT intégrées et personnalisées ; et, éventuellement, génère l'AAR fichier bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar si vos modèles contiennent Sélectionnez les opérations TensorFlow. Notez que cela crée une "graisse" l'application automatique des recommandations d'architecture si vous n'avez pas besoin de tous, utilisez le sous-ensemble approprié pour dans votre environnement de déploiement.

Compiler avec des opérations personnalisées

Si vous avez développé des modèles LiteRT 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 des dépendances permettant de créer ces 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 un TFLite personnalisé d'un ensemble de modèles donné, vous pouvez définir la ou les règles suivantes dans votre le dépôt du 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 C/C++ TFLite personnalisés vers modèles donnés, vous pouvez suivre les étapes ci-dessous:

Exécutez la commande suivante à la racine pour créer un fichier CREATE temporaire 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 ce qui suit à 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 LiteRT 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é C++ TFLite personnalisé, ajoutez ce qui suit : dans le 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 les éléments suivants : bibliothèque partagée:

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 manière sélective LiteRT avec Docker

Dans cette section, nous partons du principe que vous avez déjà installé Docker sur votre ordinateur local et téléchargé le fichier Dockerfile LiteRT cliquez ici.

Après avoir téléchargé le Dockerfile ci-dessus, vous pouvez créer l'image Docker en en cours d'exécution:

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 LiteRT personnalisée en fournissant votre fichier de modèle comme indiqué ci-dessous.

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 vous souhaitez effectuer le paiement avant de construire les bibliothèques ; Par défaut, il s'agit de la dernière version de sortie. La commande ci-dessus génère le fichier AAR tensorflow-lite.aar pour les opérations LiteRT intégrées et personnalisées, et éventuellement le fichier AAR tensorflow-lite-select-tf-ops.aar pour sélectionner des opérations TensorFlow dans votre répertoire actuel.

--cache_dir spécifie le répertoire de cache. S'il n'est pas fourni, le script créez un répertoire nommé bazel-build-cache dans le répertoire de travail actuel pour mise en cache.

Ajouter des fichiers AAR au projet

Ajoutez des fichiers AAR en important directement l'AAR dans votre projet, ou en publiant l'AAR personnalisée vers votre fichier Maven local Cloud Storage. Remarque que vous devez ajouter les fichiers AAR pour tensorflow-lite-select-tf-ops.aar en tant que si vous la générez.

Compilation sélective pour iOS

Veuillez consulter la section Compiler en local pour définir l'environnement de compilation et de configurer l'espace de travail TensorFlow, guide d'utilisation de la méthode pour iOS.