Cómo compilar LiteRT con CMake

En esta página, se describe cómo compilar y usar la biblioteca LiteRT con CMake.

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

Paso 1: Cómo instalar la herramienta CMake

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

sudo apt-get install cmake

También puedes seguir la guía de instalación oficial 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 la versión

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

cmake ../tensorflow_src/tensorflow/lite

Compilación de depuración

Si necesitas producir una compilación de depuración con información de símbolos, debes hacer lo siguiente: 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 -DTFLITE_KERNEL_TEST=on. Los detalles específicos de la compilación cruzada de prueba de unidades que encontrarás en la siguiente subsección.

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

Compila un paquete instalable

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

Lo ideal es que también proporciones tus propias versiones de las dependencias de bibliotecas. También deberá usarlas el proyecto que depende de LiteRT. Puedes usa -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON y establece <PackageName>_DIR. variables para apuntar 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 de ARM64 o Android.

Para compilar de forma cruzada el LiteRT, debes proporcionar la ruta de acceso a el SDK (p.ej., el SDK de ARM64 o el NDK en el caso de Android) con -DCMAKE_TOOLCHAIN_FILE marca.

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

Especificaciones de la compilación cruzada de Android

Para la compilación cruzada de Android, debes instalar Android NDK y proporcionas la ruta del NDK con -DCMAKE_TOOLCHAIN_FILE mencionada anteriormente. También debes establecer 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

Información específica de las pruebas de kernel (unidad) de compilación cruzada

La compilación cruzada de las pruebas de unidades requiere un compilador plano para el host. arquitectura. Para ello, hay un CMakeLists ubicado en tensorflow/lite/tools/cmake/native_tools/flatbuffers para compilar el plano de compilación con CMake de forma anticipada en un directorio de compilación independiente a través del host. de la cadena de herramientas.

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 objeto flatc en una ubicación de instalación personalizada. (p.ej., a un directorio que contiene otras herramientas compiladas de forma nativa en lugar de CMake directorio de compilación):

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

Para la compilación cruzada LiteRT en sí, se necesita un parámetro -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path> que apunta al directorio que contiene se debe proporcionar el objeto binario flatc junto con el -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/

Se lanzan las pruebas de kernel (de unidad) compiladas de forma cruzada en el destino

Las pruebas de unidades se pueden ejecutar como ejecutables independientes o mediante la utilidad CTest. Hasta el momento en lo que respecta a CTest, si al menos uno de los parámetros TFLITE_ENABLE_XNNPACKorTFLITE_EXTERNAL_DELEGATE está habilitado para LiteRT las pruebas se generan con dos etiquetas diferentes (con el mismo ejecutable de prueba): - sin formato: Indica en qué pruebas se ejecutan las pruebas. Backend de la CPU: delegado, que indica las pruebas que esperan un lanzamiento adicional. argumentos usados para la especificación del delegado utilizado

Tanto CTestTestfile.cmake como run-tests.cmake (como se mencionan a continuación) se disponible en <build_dir>/kernels.

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

ctest -L plain

Iniciar ejemplos de pruebas de unidades con delegados (siempre y cuando CTestTestfile.cmake y run-tests.cmake archivo están presentes en el destino en el 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

Esta forma de proporcionar una limitación conocida relacionada con los argumentos de lanzamiento a las pruebas de unidades es que solo admite de forma eficaz aquellos un valor de retorno esperado de 0. Los diferentes valores de retorno se informarán como un y la prueba fallida.

Delegado de GPU de OpenCL

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

Para configurar la compatibilidad con el delegado de GPU de OpenCL, sigue estos pasos:

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

Paso 5: Compila LiteRT

En el directorio tflite_build,

cmake --build . -j

Paso 6: Cómo compilar la herramienta LiteRT Benchmark y un 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 compilar LiteRT

Esta es la lista de opciones disponibles. Puedes anularlo con -D<option_name>=[ON|OFF] Por ejemplo, de -DTFLITE_ENABLE_XNNPACK=OFF a inhabilitar XNNPACK, que está habilitado de forma predeterminada.

Cómo crear un proyecto CMake que use LiteRT

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

Debes tener add_subdirectory() para el directorio y el vínculo de LiteRT. 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)

Cómo compilar la biblioteca LiteRT de C

Si quieres compilar una biblioteca compartida LiteRT API de C, sigue el paso 1 para paso 3 primero. Luego, ejecuta siguientes comandos.

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

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