Ayuda a proteger la Gran Barrera de Coral con TensorFlow en Kaggle Únete Challenge

Reducir el tamaño binario de TensorFlow Lite

Visión general

Al implementar modelos para aplicaciones de aprendizaje automático en el dispositivo (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 el número de operaciones utilizadas en el modelo. TensorFlow Lite te permite reducir los tamaños de modelos binarios mediante el uso de 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 incorporada de TensorFlow Lite
  2. Operaciones personalizadas de TensorFlow Lite
  3. Seleccionar 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 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-kinetics-400 Clasificación de video 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)

Problemas / limitaciones conocidos

  1. La compilación selectiva para la API C y la versión de iOS no se admiten actualmente.

Cree de forma selectiva TensorFlow Lite con Bazel

En esta sección se supone que ha descargado códigos fuente TensorFlow y configurar el entorno de desarrollo local a Basel.

Crear 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 de AAR bazel-bin/tmp/tensorflow-lite.aar para TensorFlow Lite incorporado y la costumbre de operaciones; y, opcionalmente, genera el archivo de AAR bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar si sus modelos contienen ops Seleccionar TensorFlow. Tenga en cuenta que esto crea un AAR "gordo" con varias arquitecturas diferentes; si no los necesita todos, utilice el subconjunto apropiado para su entorno de implementación.

Construye con operaciones personalizadas

Si desarrolló 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 tflite_custom_ops_srcs bandera contiene archivos de origen de sus operaciones a medida y la tflite_custom_ops_deps bandera contiene dependencias para construir los 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 le gustaría definir dependencias personalizadas de TFLite para un conjunto determinado de modelos, puede definir las siguientes reglas en el repositorio de su proyecto:

Solo para los modelos con las 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 Seleccionar 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 construir sus propios objetos compartidos TFLite C / C ++ personalizados para los modelos dados, puede seguir los pasos a continuación:

Crea 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

Construyendo objetos compartidos C personalizados

Si desea construir una costumbre TFLite C compartió objeto, añada lo siguiente a tmp/BUILD archivo:

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++14 \
  //tmp:tensorflowlite_c

y para Android (sustituir android_arm con android_arm64 de 64 bits):

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

Construyendo objetos compartidos personalizados de C ++

Si desea construir una costumbre TFLite C ++ objeto compartido, añada lo siguiente a tmp/BUILD archivo:

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++14 \
  //tmp:tensorflowlite

y para Android (sustituir android_arm con android_arm64 de 64 bits):

bazel build -c opt --cxxopt=--std=c++14 --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++14' \
      --config=monolithic \
      --host_crosstool_top=@bazel_tools//tools/cpp:toolchain \
      //tmp:tensorflowlite_flex

y para Android (sustituir android_arm con android_arm64 de 64 bits):

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

Compile TensorFlow Lite de forma selectiva con Docker

En esta sección se supone que se ha instalado acoplable en su máquina local y descargado el TensorFlow Lite Dockerfile 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 checkpoint de la bandera es una confirmación, una rama o una etiqueta de la cesión temporal TensorFlow que desea la caja antes de construir las bibliotecas; de forma predeterminada, es la última rama de la versión. El comando anterior generará el archivo de AAR tensorflow-lite.aar para TensorFlow Lite incorporados y ops personalizados y, opcionalmente, el archivo de AAR tensorflow-lite-select-tf-ops.aar para operaciones Seleccione TensorFlow en el 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

Añadir archivos AAR por directamente la importación de la AAR en su proyecto , o mediante la publicación de la AAR personalizado a su repositorio local de Maven . Tenga en cuenta que hay que añadir los archivos de AAR para tensorflow-lite-select-tf-ops.aar así, si es que generamos.