Obtén más información sobre nuestros anuncios de Google AI Edge de I/O.

Se usó la API de Cloud Translation para traducir esta página.

Compila TensorFlow Lite con CMake

En esta página, se describe cómo compilar y usar la biblioteca de TensorFlow Lite con la herramienta CMake.

Las siguientes instrucciones se probaron en PC de 64 bits (AMD64) con Ubuntu 16.04.3, macOS Catalina (x86_64), Windows 10 y la imagen de Docker de TensorFlow devel tensorflow/tensorflow:devel.

Paso 1: Cómo instalar la herramienta CMake

Requiere CMake 3.16 o una versión posterior. En Ubuntu, puedes ejecutar el siguiente comando.

sudo apt-get install cmake

También puedes seguir la guía oficial de instalación de CMake.

Paso 2. Clona el repositorio de TensorFlow

git clone https://github.com/tensorflow/tensorflow.git tensorflow_src

Paso 3: Cómo crear un directorio de compilación de CMake

mkdir tflite_build
cd tflite_build

Paso 4. Cómo ejecutar la herramienta CMake con configuraciones

Compilación de lanzamiento

Genera un objeto binario de lanzamiento optimizado de forma predeterminada. Si deseas compilar para tu estación de trabajo, solo ejecuta el siguiente comando.

cmake ../tensorflow_src/tensorflow/lite

Depurar compilación

Si necesitas producir una compilación de depuración que tenga información de símbolos, debes proporcionar la opción -DCMAKE_BUILD_TYPE=Debug.

cmake ../tensorflow_src/tensorflow/lite -DCMAKE_BUILD_TYPE=Debug

Cómo compilar con pruebas de unidades de kernel

Para poder ejecutar pruebas de kernel, debes proporcionar la marca -DTFLITE_KERNEL_TEST=on. En la siguiente subsección, puedes encontrar información específica sobre la compilación cruzada de pruebas de unidades.

cmake ../tensorflow_src/tensorflow/lite -DTFLITE_KERNEL_TEST=on

Compila un paquete instalable

Para compilar un paquete instalable que otro proyecto de CMake pueda usar como dependencia con find_package(tensorflow-lite CONFIG), usa la opción -DTFLITE_ENABLE_INSTALL=ON.

Idealmente, también deberías proporcionar tus propias versiones de las dependencias de la biblioteca. El proyecto que depende de TF Lite también los deberá usar. Puedes usar -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON y configurar las variables <PackageName>_DIR para que apunten a las instalaciones de tu biblioteca.

cmake ../tensorflow_src/tensorflow/lite -DTFLITE_ENABLE_INSTALL=ON \
  -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON \
  -DSYSTEM_FARMHASH=ON \
  -DSYSTEM_PTHREADPOOL=ON \
  -Dabsl_DIR=<install path>/lib/cmake/absl \
  -DEigen3_DIR=<install path>/share/eigen3/cmake \
  -DFlatBuffers_DIR=<install path>/lib/cmake/flatbuffers \
  -Dgemmlowp_DIR=<install path>/lib/cmake/gemmlowp \
  -DNEON_2_SSE_DIR=<install path>/lib/cmake/NEON_2_SSE \
  -Dcpuinfo_DIR=<install path>/share/cpuinfo \
  -Druy_DIR=<install path>/lib/cmake/ruy

Compilación cruzada

Puedes usar CMake para compilar objetos binarios para arquitecturas de destino ARM64 o Android.

Para hacer una compilación cruzada de TF Lite, es decir, debes proporcionar la ruta de acceso al SDK (p.ej., el SDK o NDK de ARM64 en el caso de Android) con la marca -DCMAKE_TOOLCHAIN_FILE.

cmake -DCMAKE_TOOLCHAIN_FILE=<CMakeToolchainFileLoc> ../tensorflow/lite/

Información específica sobre la compilación cruzada de Android

Para la compilación cruzada de Android, debes instalar el NDK de Android y proporcionar la ruta del NDK con la marca -DCMAKE_TOOLCHAIN_FILE mencionada anteriormente. También debes configurar la ABI de destino con la marca -DANDROID_ABI.

cmake -DCMAKE_TOOLCHAIN_FILE=<NDK path>/build/cmake/android.toolchain.cmake \
  -DANDROID_ABI=arm64-v8a ../tensorflow_src/tensorflow/lite

Detalles específicos de la compilación cruzada de pruebas de kernel (unidad)

La compilación cruzada de las pruebas de unidades requiere el compilador Flatc para la arquitectura del host. Para ello, hay CMakeLists ubicadas en tensorflow/lite/tools/cmake/native_tools/flatbuffers para compilar el compilador plano con CMake de antemano en un directorio de compilación independiente usando la cadena de herramientas del host.

mkdir flatc-native-build && cd flatc-native-build
cmake ../tensorflow_src/tensorflow/lite/tools/cmake/native_tools/flatbuffers
cmake --build .

También es posible instalar el flatc en una ubicación de instalación personalizada (por ejemplo, en un directorio que contenga otras herramientas compiladas de forma nativa en lugar del directorio de compilación de CMake):

cmake -DCMAKE_INSTALL_PREFIX=<native_tools_dir> ../tensorflow_src/tensorflow/lite/tools/cmake/native_tools/flatbuffers
cmake --build .

Para la compilación cruzada de TF Lite, se debe proporcionar el parámetro adicional -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path> que apunta al directorio que contiene el objeto binario flatc nativo junto con la marca -DTFLITE_KERNEL_TEST=on mencionada anteriormente.

cmake -DCMAKE_TOOLCHAIN_FILE=${OE_CMAKE_TOOLCHAIN_FILE} -DTFLITE_KERNEL_TEST=on -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path> ../tensorflow/lite/

Lanzamiento de pruebas de kernel compiladas de forma cruzada en el destino

Las pruebas de unidades se pueden ejecutar como ejecutables independientes o con la utilidad CTest. En lo que respecta a CTest, si al menos uno de los parámetros TFLITE_ENABLE_XNNPACKorTFLITE_EXTERNAL_DELEGATE` está habilitado para la compilación de TF Lite, las pruebas resultantes se generan con dos etiquetas diferentes (con la misma ejecutable de prueba): las pruebas sin formato - denotan las pruebas que se ejecutan en el backend de la CPU - delegan las pruebas que se ejecutan para el backend de la CPU y delegan las especificaciones adicionales que se delegan para el backend de la CPU

Tanto CTestTestfile.cmake como run-tests.cmake (como se indica a continuación) están disponibles en <build_dir>/kernels.

Lanzamiento de pruebas de unidades con el backend de la CPU (siempre que CTestTestfile.cmake esté presente en el destino en el directorio actual):

ctest -L plain

Inicia ejemplos de pruebas de unidades mediante delegados (siempre que los archivos CTestTestfile.cmake y run-tests.cmake estén presentes en el destino del directorio actual):

cmake -E env TESTS_ARGUMENTS=--use_xnnpack=true ctest -L delegate
cmake -E env TESTS_ARGUMENTS=--external_delegate_path=<PATH> ctest -L delegate

Una limitación conocida de esta manera de proporcionar argumentos de lanzamiento adicionales relacionados con delegados a las pruebas de unidades es que solo admite de forma efectiva aquellos que tienen un valor de retorno esperado de 0. Los diferentes valores que se muestran se informarán como una prueba con errores.

Delegado de GPU de OpenCL

Si tu máquina de destino es compatible con OpenCL, puedes usar un delegado de GPU que puede aprovechar la energía de tu GPU.

Para configurar la compatibilidad con delegados de GPU de OpenCL, haz lo siguiente:

cmake ../tensorflow_src/tensorflow/lite -DTFLITE_ENABLE_GPU=ON

Paso 5: Compila con TensorFlow Lite

En el directorio tflite_build, haz lo siguiente:

cmake --build . -j

Paso 6. Compila la herramienta de comparativas de TensorFlow Lite y ejemplo de la imagen de etiqueta (opcional)

En el directorio tflite_build, haz lo siguiente:

cmake --build . -j -t benchmark_model

cmake --build . -j -t label_image

Opciones disponibles para compilar TensorFlow Lite

A continuación, se muestra la lista de opciones disponibles. Puedes anularlo con -D<option_name>=[ON|OFF]. Por ejemplo, -DTFLITE_ENABLE_XNNPACK=OFF para inhabilitar XNNPACK, que está habilitado de forma predeterminada.

Nombre de la opción	Función	Android	Linux	macOS	Windows
`TFLITE_ENABLE_RUY`	Habilitar la biblioteca de multiplicación de matrices RUY	ON	APAGADO	APAGADO	APAGADO
`TFLITE_ENABLE_GPU`	Habilita el delegado de la GPU	APAGADO	APAGADO	N/A	N/A
`TFLITE_ENABLE_XNNPACK`	Habilita el delegado XNNPACK	ON	ON	ON	ON
`TFLITE_ENABLE_MMAP`	Habilitar MMAP	ON	ON	ON	N/A

Cómo crear un proyecto CMake que use TensorFlow Lite

A continuación, se muestra el archivo CMakeLists.txt del ejemplo mínimo de TFLite.

Debes tener add_subdirectory() para el directorio de TensorFlow Lite y vincular tensorflow-lite con target_link_libraries().

cmake_minimum_required(VERSION 3.16)
project(minimal C CXX)

set(TENSORFLOW_SOURCE_DIR "" CACHE PATH
  "Directory that contains the TensorFlow project" )
if(NOT TENSORFLOW_SOURCE_DIR)
  get_filename_component(TENSORFLOW_SOURCE_DIR
    "${CMAKE_CURRENT_LIST_DIR}/../../../../" ABSOLUTE)
endif()

add_subdirectory(
  "${TENSORFLOW_SOURCE_DIR}/tensorflow/lite"
  "${CMAKE_CURRENT_BINARY_DIR}/tensorflow-lite" EXCLUDE_FROM_ALL)

add_executable(minimal minimal.cc)
target_link_libraries(minimal tensorflow-lite)

Compila la biblioteca de C de TensorFlow Lite

Si quieres compilar la biblioteca compartida de TensorFlow Lite para la API de C, primero sigue el paso 1 hasta el paso 3. Después, ejecuta los siguientes comandos.

cmake ../tensorflow_src/tensorflow/lite/c
cmake --build . -j

Con este comando, se genera la siguiente biblioteca compartida en el directorio actual.

Plataforma	Nombre de la biblioteca
Linux	`libtensorflowlite_c.so`
macOS	`libtensorflowlite_c.dylib`
Windows	`tensorflowlite_c.dll`