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.
- Biblioteca de operaciones integrada de LiteRT
- Operaciones personalizadas de LiteRT
- 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.