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_XNNPACKor
TFLITE_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.
Nombre de la opción | Función | Android | Linux | macOS | Windows |
---|---|---|---|---|---|
TFLITE_ENABLE_RUY
|
Habilitar RUY matriz multiplicación biblioteca | ON | APAGADO | APAGADO | APAGADO |
TFLITE_ENABLE_GPU
|
Habilitar GPU delegado | APAGADO | APAGADO | N/A | N/A |
TFLITE_ENABLE_XNNPACK
|
Habilitar XNNPACK delegado | ON | ON | ON | ON |
TFLITE_ENABLE_MMAP |
Habilitar MMAP | ON | ON | ON | N/A |
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.
Plataforma | Nombre de la biblioteca |
---|---|
Linux | libtensorflowlite_c.so |
macOS | libtensorflowlite_c.dylib |
Windows | tensorflowlite_c.dll |