Reducir el tamaño binario de TensorFlow Lite

Descripción general

Al implementar modelos para aplicaciones de aprendizaje automático en el dispositivo (ODML), es importante tener en cuenta la memoria limitada que está disponible en los dispositivos móviles. Los tamaños binarios del modelo están estrechamente relacionados con el número de operaciones utilizadas en el modelo. TensorFlow Lite le permite reducir los tamaños binarios del modelo mediante compilaciones selectivas. Las compilaciones selectivas omiten las 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:

Cree selectivamente TensorFlow Lite con Bazel

En esta sección se supone que descargó los códigos fuente de TensorFlow y configuró el entorno de desarrollo local en Bazel.

Crear archivos AAR para el proyecto de Android

Puede crear los AAR de TensorFlow Lite personalizados 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 integradas y personalizadas de TensorFlow Lite; y, opcionalmente, genera el archivo 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, use el subconjunto apropiado para su entorno de implementación.

Construya con operaciones personalizadas

Si ha desarrollado modelos de Tensorflow Lite con operaciones personalizadas, puede compilarlos agregando los siguientes indicadores 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 de origen de sus operaciones personalizadas y el indicador tflite_custom_ops_deps contiene dependencias para crear esos archivos de origen. 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 las 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 las operaciones Select TF, también debe 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

Cree selectivamente TensorFlow Lite con Docker

Esta sección asume que instaló Docker en su máquina local y descargó el archivo Docker 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

Crear 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 del punto de checkpoint es una confirmación, una rama o una etiqueta del repositorio de TensorFlow que desea verificar antes de compilar las bibliotecas; por defecto es la última rama de lanzamiento. El comando anterior generará el archivo AAR tensorflow-lite.aar para las operaciones integradas y personalizadas de TensorFlow Lite y, opcionalmente, el archivo AAR tensorflow-lite-select-tf-ops.aar para las operaciones Select TensorFlow en su directorio actual.

--cache_dir especifica el directorio de caché. Si no se proporciona, la secuencia de comandos 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.

Construcción selectiva para iOS

Consulte la sección Construir localmente para configurar el entorno de construcción y configurar el espacio de trabajo de TensorFlow y luego siga la guía para usar la secuencia de comandos de construcción selectiva para iOS.