Construya TensorFlow Lite con CMake

Esta página describe cómo crear y utilizar la biblioteca TensorFlow Lite con la herramienta CMake .

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

Paso 1. Instale la herramienta CMake

Requiere CMake 3.16 o superior. En Ubuntu, simplemente puedes ejecutar el siguiente comando.

sudo apt-get install cmake

O puedes seguir la guía de instalación oficial de cmake.

Paso 2. Clonar el repositorio de TensorFlow

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

Paso 3. Cree el directorio de compilación de CMake

mkdir tflite_build
cd tflite_build

Paso 4. Ejecute la herramienta CMake con configuraciones

Versión de lanzamiento

Genera un binario de versión optimizado de forma predeterminada. Si desea compilar para su estación de trabajo, simplemente ejecute el siguiente comando.

cmake ../tensorflow_src/tensorflow/lite

compilación de depuración

Si necesita generar una compilación de depuración que tenga información de símbolos, debe proporcionar la opción -DCMAKE_BUILD_TYPE=Debug .

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

Construir con pruebas unitarias del kernel

Para poder ejecutar pruebas del kernel, debe proporcionar el indicador -DTFLITE_KERNEL_TEST=on . Los detalles específicos de la compilación cruzada de las pruebas unitarias se pueden encontrar en la siguiente subsección.

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

Construir paquete instalable

Para crear un paquete instalable que pueda ser utilizado como dependencia por otro proyecto de CMake con find_package(tensorflow-lite CONFIG) , use la opción -DTFLITE_ENABLE_INSTALL=ON .

Idealmente, también debería proporcionar sus propias versiones de las dependencias de la biblioteca. Estos también deberán ser utilizados por el proyecto que depende de TF Lite. Puede usar -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON y configurar las variables <PackageName>_DIR para que apunten a las instalaciones de su 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

Puede utilizar CMake para crear archivos binarios para arquitecturas de destino ARM64 o Android.

Para realizar una compilación cruzada de TF Lite, es necesario proporcionar la ruta al SDK (por ejemplo, ARM64 SDK o NDK en el caso de Android) con el indicador -DCMAKE_TOOLCHAIN_FILE .

cmake -DCMAKE_TOOLCHAIN_FILE=<CMakeToolchainFileLoc> ../tensorflow/lite/
Detalles de la compilación cruzada de Android

Para la compilación cruzada de Android, debe instalar el NDK de Android y proporcionar la ruta del NDK con el indicador -DCMAKE_TOOLCHAIN_FILE mencionado anteriormente. También debe configurar el ABI objetivo con el indicador -DANDROID_ABI .

cmake -DCMAKE_TOOLCHAIN_FILE=<NDK path>/build/cmake/android.toolchain.cmake \
  -DANDROID_ABI=arm64-v8a ../tensorflow_src/tensorflow/lite
Detalles de la compilación cruzada de pruebas del kernel (unidad)

La compilación cruzada de las pruebas unitarias requiere un compilador flatc para la arquitectura del host. Para este propósito, hay CMakeLists ubicado en tensorflow/lite/tools/cmake/native_tools/flatbuffers para construir el compilador flatc con CMake de antemano en un directorio de compilación separado utilizando 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 flatc en una ubicación de instalación personalizada (por ejemplo, en un directorio que contenga otras herramientas creadas 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 en sí, se debe proporcionar el parámetro adicional -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path> que apunta al directorio que contiene el binario flatc nativo junto con el indicador -DTFLITE_KERNEL_TEST=on mencionado anteriormente.

cmake -DCMAKE_TOOLCHAIN_FILE=${OE_CMAKE_TOOLCHAIN_FILE} -DTFLITE_KERNEL_TEST=on -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path> ../tensorflow/lite/
Las pruebas de kernel (unitarias) compiladas cruzadas se inician en el objetivo

Las pruebas unitarias se pueden ejecutar como ejecutables separados o utilizando la utilidad CTest. En lo que respecta a CTest, si al menos uno de los parámetros TFLITE_ENABLE_NNAPI, TFLITE_ENABLE_XNNPACK o TFLITE_EXTERNAL_DELEGATE está habilitado para la compilación TF Lite, las pruebas resultantes se generan con dos etiquetas diferentes (utilizando el mismo ejecutable de prueba): - simple - que denota las pruebas los que se ejecutan en el backend de la CPU - delegado - que denota las pruebas que esperan argumentos de lanzamiento adicionales utilizados para la especificación del delegado utilizado

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

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

ctest -L plain

Inicie ejemplos de pruebas unitarias utilizando delegados (siempre que el archivo CTestTestfile.cmake y run-tests.cmake estén presentes en el destino en el directorio actual):

cmake -E env TESTS_ARGUMENTS=--use_nnapi=true\;--nnapi_accelerator_name=vsi-npu ctest -L delegate
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 forma de proporcionar argumentos de lanzamiento adicionales relacionados con delegados a las pruebas unitarias es que efectivamente admite solo aquellas con un valor de retorno esperado de 0 . Se informarán valores de retorno diferentes como error de prueba.

Delegado de GPU OpenCL

Si su máquina de destino es compatible con OpenCL, puede utilizar el delegado de GPU que puede aprovechar la potencia de su GPU.

Para configurar la compatibilidad con delegados de GPU OpenCL:

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

Paso 5. Construya TensorFlow Lite

En el directorio tflite_build ,

cmake --build . -j

Paso 6. Cree la herramienta de referencia TensorFlow Lite y el ejemplo de imagen de etiqueta (opcional)

En el directorio tflite_build ,

cmake --build . -j -t benchmark_model
cmake --build . -j -t label_image

Opciones disponibles para construir TensorFlow Lite

Aquí está la lista de opciones disponibles. Puede anularlo con -D<option_name>=[ON|OFF] . Por ejemplo, -DTFLITE_ENABLE_XNNPACK=OFF para deshabilitar XNNPACK, que está habilitado de forma predeterminada.

Nombre de la opción Característica Androide linux Mac OS ventanas
TFLITE_ENABLE_RUY Habilitar la biblioteca de multiplicación de matrices RUY EN APAGADO APAGADO APAGADO
TFLITE_ENABLE_NNAPI Habilitar delegado NNAPI EN APAGADO N / A N / A
TFLITE_ENABLE_GPU Habilitar delegado de GPU APAGADO APAGADO N / A N / A
TFLITE_ENABLE_XNNPACK Habilitar delegado XNNPACK EN EN EN EN
TFLITE_ENABLE_MMAP Habilitar MMAP EN EN EN N / A

Cree un proyecto CMake que use TensorFlow Lite

Aquí está el ejemplo mínimo CMakeLists.txt de TFLite .

Debe 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)

Construya la biblioteca TensorFlow Lite C

Si desea crear una biblioteca compartida de TensorFlow Lite para la API de C , siga primero del paso 1 al paso 3 . Después de eso, ejecute los siguientes comandos.

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

Este comando genera la siguiente biblioteca compartida en el directorio actual.

Plataforma Nombre de la biblioteca
linux libtensorflowlite_c.so
Mac OS libtensorflowlite_c.dylib
ventanas tensorflowlite_c.dll