Cómo reducir el tamaño de los objetos binarios de LiteRT

Descripción general

Cuando se implementan modelos para aplicaciones de aprendizaje automático en el dispositivo (ODML), es Es importante tener en cuenta la memoria limitada disponible en los dispositivos móviles. Los tamaños de los objetos binarios del modelo están estrechamente relacionados con la cantidad de ops usadas en el un modelo de responsabilidad compartida. LiteRT te permite reducir el tamaño de los objetos binarios del modelo mediante compilaciones selectivas. Las compilaciones selectivas omiten las operaciones no utilizadas en tu conjunto de modelos y producir una biblioteca compacta solo con el entorno de ejecución y los kernels de op necesarios el modelo para que lo ejecute en tu dispositivo móvil.

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

  1. Biblioteca de operaciones integrada de LiteRT
  2. Operaciones personalizadas de LiteRT
  3. Selecciona la biblioteca de operaciones de TensorFlow

En la siguiente tabla, se demuestra el impacto de las compilaciones selectivas para algunos usos comunes casos:

Nombre del modelo Dominio Arquitectura de objetivos Tamaños de archivos AAR
Mobilenet_1.0_224(float) Clasificación de imágenes armeabi-v7a tensorflow-lite.aar (296,635 bytes)
arm64-v8a tensorflow-lite.aar (382,892 bytes)
SPICE 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-kinetics-400; Clasificación de videos 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)

Compila LiteRT de forma selectiva con Bazel

En esta sección, se supone que descargaste códigos fuente de TensorFlow y que configuraste el desarrollo local entorno para Bazel

Cómo compilar archivos AAR para un proyecto de Android

Para compilar los AAR de LiteRT personalizados, proporciona las rutas de acceso de tus archivos del 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 operaciones de LiteRT integradas y personalizadas y, opcionalmente, genera el archivo aar archivo bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar si tus modelos contienen Selecciona operaciones de TensorFlow. Tenga en cuenta que esto genera una “grasa” las AAR con diversas funciones arquitecturas de contenedores; si no los necesitas a todos, usa el subconjunto adecuado para tu entorno de implementación.

Compila con operaciones personalizadas

Si desarrollaste modelos LiteRT con operaciones personalizadas, puedes crearlos Para ello, agrega 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

La marca tflite_custom_ops_srcs contiene archivos de origen de tus operaciones personalizadas y La marca tflite_custom_ops_deps contiene dependencias para compilar esas fuentes archivos. Ten en cuenta que estas dependencias deben existir en el repositorio de TensorFlow.

Usos avanzados: Reglas de Bazel personalizadas

Si tu proyecto usa Bazel y quieres definir TFLite personalizado para un conjunto determinado de modelos, puedes definir las siguientes reglas en tu repositorio del 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 de selección de 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: Compila bibliotecas compartidas de C/C++ personalizadas

Si quieres compilar tus propios objetos compartidos C/C++ de TFLite personalizados con los modelos dados, puedes seguir estos pasos:

Ejecuta el siguiente comando en la raíz para crear un archivo BUILD temporal. del código fuente de TensorFlow:

mkdir -p tmp && touch tmp/BUILD

Cómo compilar objetos personalizados compartidos en C

Si quieres compilar un objeto compartido personalizado de TFLite C, agrega 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 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",
    ],
)

El destino agregado recientemente se puede compilar de la siguiente manera:

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

y para Android (reemplaza android_arm por android_arm64 para 64 bits):

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

Cómo compilar objetos compartidos de C++ personalizados

Si quieres compilar un objeto compartido personalizado de TFLite C++, agrega 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 destino agregado recientemente se puede compilar de la siguiente manera:

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

y para Android (reemplaza android_arm por 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 debes compilar lo siguiente: y también en la 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 destino agregado recientemente se puede compilar 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 (reemplaza android_arm por 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

Compila LiteRT de forma selectiva con Docker

En esta sección, se da por sentado que instalaste Docker en tu máquina local descargó el Dockerfile de LiteRT aquí.

Después de descargar el Dockerfile anterior, puedes compilar la imagen de Docker. Para ello, haz lo siguiente: en ejecución:

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

Cómo compilar archivos AAR para un proyecto de Android

Descarga la secuencia de comandos para compilar con Docker ejecutando lo siguiente:

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, puedes crear el AAR de LiteRT personalizado proporcionando tu archivo de modelo. rutas de aprendizaje, como se muestra a continuación.

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

La marca checkpoint es una confirmación, una rama o una etiqueta del repositorio de TensorFlow que quieres confirmar la compra antes de compilar las bibliotecas. de forma predeterminada es la más reciente de la versión. El comando anterior generará el archivo AAR tensorflow-lite.aar para operaciones LiteRT integradas y personalizadas y, opcionalmente, el archivo AAR tensorflow-lite-select-tf-ops.aar para determinadas operaciones de TensorFlow en tu directorio actual.

--cache_dir especifica el directorio de caché. Si no se proporciona, la secuencia de comandos crea un directorio llamado bazel-build-cache en el directorio de trabajo actual para el almacenamiento en caché.

Agrega archivos AAR al proyecto

Agrega archivos AAR mediante la importación directa de los AAR a tu proyecto o publicando las AAR personalizadas a tu Maven local de Terraform. Nota agrega los archivos AAR de tensorflow-lite-select-tf-ops.aar como si la generas.

Compilación selectiva para iOS

Consulta la sección Compila de forma local para configurar el entorno de compilación, configurar el espacio de trabajo de TensorFlow y, luego, seguir las guía para usar la función secuencia de comandos de compilación para iOS.