Reducir el tamaño binario de TensorFlow Lite

Descripción general

Al implementar modelos para aplicaciones de aprendizaje automático en dispositivos (ODML), es importante tener en cuenta la memoria limitada disponible en los dispositivos móviles. Los tamaños binarios del modelo están estrechamente relacionados con la cantidad de operaciones utilizadas en el modelo. TensorFlow Lite le permite reducir los tamaños binarios del modelo mediante compilaciones selectivas. Las compilaciones selectivas omiten operaciones no utilizadas en su conjunto de modelos y producen una biblioteca compacta con solo el tiempo de ejecución y los núcleos operativos necesarios para que el modelo se ejecute en su dispositivo móvil.

La compilación selectiva se aplica a las siguientes tres bibliotecas de operaciones.

  1. Biblioteca de operaciones integrada de TensorFlow Lite
  2. Operaciones personalizadas de TensorFlow Lite
  3. Seleccione la biblioteca de operaciones de TensorFlow

La siguiente tabla demuestra el impacto de las compilaciones selectivas para algunos casos de uso comunes:

Nombre del modelo Dominio Arquitectura de destino Tamaño(s) de archivo AAR
Mobilenet_1.0_224(flotante) Clasificación de imágenes armeabi-v7a tensorflow-lite.aar (296,635 bytes)
arm64-v8a tensorflow-lite.aar (382,892 bytes)
ESPECIA Extracción de tono de sonido armeabi-v7a tensorflow-lite.aar (375,813 bytes)
tensorflow-lite-select-tf-ops.aar (1.676.380 bytes)
arm64-v8a tensorflow-lite.aar (421,826 bytes)
tensorflow-lite-select-tf-ops.aar (2.298.630 bytes)
i3d-cinética-400 Clasificación de vídeos armeabi-v7a tensorflow-lite.aar (240.085 bytes)
tensorflow-lite-select-tf-ops.aar (1.708.597 bytes)
arm64-v8a tensorflow-lite.aar (273,713 bytes)
tensorflow-lite-select-tf-ops.aar (2.339.697 bytes)

Construya selectivamente TensorFlow Lite con Bazel

Esta sección supone que ha descargado los códigos fuente de TensorFlow y configurado el entorno de desarrollo local para Bazel.

Cree archivos AAR para el proyecto de Android

Puede crear los AAR personalizados de TensorFlow Lite proporcionando las rutas de archivo de su modelo de la siguiente manera.

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

El comando anterior generará el archivo AAR bazel-bin/tmp/tensorflow-lite.aar para las operaciones personalizadas e integradas de TensorFlow Lite; y, opcionalmente, genera el archivo aar bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar si sus modelos contienen operaciones Select TensorFlow. Tenga en cuenta que esto crea un AAR "grueso" con varias arquitecturas diferentes; Si no los necesita todos, utilice el subconjunto apropiado para su entorno de implementación.

Construye con operaciones personalizadas

Si ha desarrollado modelos de Tensorflow Lite con operaciones personalizadas, puede compilarlos agregando las siguientes marcas al comando de compilación:

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

El indicador tflite_custom_ops_srcs contiene archivos fuente de sus operaciones personalizadas y el indicador tflite_custom_ops_deps contiene dependencias para crear esos archivos fuente. Tenga en cuenta que estas dependencias deben existir en el repositorio de TensorFlow.

Usos avanzados: reglas personalizadas de Bazel

Si su proyecto utiliza Bazel y desea definir dependencias TFLite personalizadas para un conjunto determinado de modelos, puede definir las siguientes reglas en el repositorio de su proyecto:

Solo para los modelos con operaciones integradas:

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",
    ],
)

Para los modelos con operaciones Select 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",
    ],
)

Usos avanzados: cree bibliotecas compartidas C/C++ personalizadas

Si desea crear sus propios objetos compartidos TFLite C/C++ personalizados para los modelos dados, puede seguir los pasos a continuación:

Cree un archivo BUILD temporal ejecutando el siguiente comando en el directorio raíz del código fuente de TensorFlow:

mkdir -p tmp && touch tmp/BUILD

Creación de objetos compartidos C personalizados

Si desea crear un objeto compartido TFLite C personalizado, agregue lo siguiente al archivo 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",
    ],
)

El objetivo recién agregado se puede construir de la siguiente manera:

bazel build -c opt --cxxopt=--std=c++17 \
  //tmp:tensorflowlite_c

y para Android (reemplace android_arm con android_arm64 para 64 bits):

bazel build -c opt --cxxopt=--std=c++17 --config=android_arm \
  //tmp:tensorflowlite_c

Creación de objetos compartidos C++ personalizados

Si desea crear un objeto compartido TFLite C++ personalizado, agregue lo siguiente al archivo 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",
    ],
)

El objetivo recién agregado se puede construir de la siguiente manera:

bazel build -c opt  --cxxopt=--std=c++17 \
  //tmp:tensorflowlite

y para Android (reemplace android_arm con android_arm64 para 64 bits):

bazel build -c opt --cxxopt=--std=c++17 --config=android_arm \
  //tmp:tensorflowlite

Para los modelos con operaciones Select TF, también necesita crear la siguiente biblioteca compartida:

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",
  ],
)

El objetivo recién agregado se puede construir de la siguiente manera:

bazel build -c opt --cxxopt='--std=c++17' \
      --config=monolithic \
      --host_crosstool_top=@bazel_tools//tools/cpp:toolchain \
      //tmp:tensorflowlite_flex

y para Android (reemplace android_arm con android_arm64 para 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

Construya selectivamente TensorFlow Lite con Docker

Esta sección asume que instaló Docker en su máquina local y descargó el Dockerfile de TensorFlow Lite aquí .

Después de descargar el Dockerfile anterior, puede crear la imagen de la ventana acoplable ejecutando:

docker build . -t tflite-builder -f tflite-android.Dockerfile

Cree archivos AAR para el proyecto de Android

Descargue el script para compilar con Docker ejecutando:

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

Luego, puede crear el AAR personalizado de TensorFlow Lite proporcionando las rutas de archivo de su modelo de la siguiente manera.

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>]

El indicador checkpoint es una confirmación, una rama o una etiqueta del repositorio de TensorFlow que desea verificar antes de crear las bibliotecas; de forma predeterminada es la rama de última versión. El comando anterior generará el archivo AAR tensorflow-lite.aar para las operaciones personalizadas e integradas de TensorFlow Lite y, opcionalmente, el archivo AAR tensorflow-lite-select-tf-ops.aar para las operaciones seleccionadas de TensorFlow en su directorio actual.

--cache_dir especifica el directorio de caché. Si no se proporciona, el script creará un directorio llamado bazel-build-cache en el directorio de trabajo actual para el almacenamiento en caché.

Agregar archivos AAR al proyecto

Agregue archivos AAR importando directamente el AAR a su proyecto o publicando el AAR personalizado en su repositorio Maven local . Tenga en cuenta que también debe agregar los archivos AAR para tensorflow-lite-select-tf-ops.aar si lo genera.

Compilación selectiva para iOS

Consulte la sección Compilación local para configurar el entorno de compilación y el espacio de trabajo de TensorFlow y luego siga la guía para usar el script de compilación selectiva para iOS.