Criar LiteRT com CMake

Esta página descreve como criar e usar a biblioteca LiteRT com ferramenta CMake.

As instruções a seguir foram testadas em um PC Ubuntu 16.04.3 de 64 bits (AMD64) , macOS Catalina (x86_64), Windows 10 e imagem Docker do TensorFlow devel tensorflow/tensorflow:devel.

Etapa 1. Instalar a ferramenta CMake

É necessário ter o CMake 3.16 ou mais recente. No Ubuntu, basta executar este comando: kubectl.

sudo apt-get install cmake

Ou você pode seguir o guia oficial de instalação do cmake

Etapa 2. clone o repositório do TensorFlow

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

Etapa 3. Criar o diretório de build do CMake

mkdir tflite_build
cd tflite_build

Etapa 4. Executar a ferramenta CMake com configurações

Versão de lançamento

Ele gera um binário de lançamento otimizado por padrão. Se você quer criar para na estação de trabalho, basta executar o comando a seguir.

cmake ../tensorflow_src/tensorflow/lite

Depurar build

Se precisar produzir um build de depuração com informações de símbolos, você vai precisar forneça a opção -DCMAKE_BUILD_TYPE=Debug.

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

Criar com testes de unidade do kernel

Para executar testes de kernel, é necessário fornecer o sinalização -DTFLITE_KERNEL_TEST=on. As especificidades da compilação cruzada de teste de unidade podem ser na próxima subseção.

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

Criar pacote instalável

Para criar um pacote instalável que pode ser usado como dependência por outro projeto CMake com find_package(tensorflow-lite CONFIG), use o -DTFLITE_ENABLE_INSTALL=ON.

O ideal é fornecer versões próprias de dependências de biblioteca. Eles também precisarão ser usados pelo projeto que depende da LiteRT. Você pode use o -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON e defina o <PackageName>_DIR para apontar para as instalações da 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

Compilação cruzada

Você pode usar o CMake para criar binários para arquiteturas de destino ARM64 ou Android.

Para fazer a compilação cruzada da LiteRT, você precisa fornecer o caminho para o SDK (por exemplo, SDK ARM64 ou NDK no caso do Android) com -DCMAKE_TOOLCHAIN_FILE .

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

Detalhes da compilação cruzada do Android

Para a compilação cruzada do Android, é necessário instalar Android NDK e forneça o caminho do NDK a sinalização -DCMAKE_TOOLCHAIN_FILE mencionada acima. Você também precisa definir a ABI de destino com a sinalização -DANDROID_ABI.

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

Especificações da compilação cruzada dos testes de kernel (unidade)

A compilação cruzada dos testes de unidade requer o compilador Flatc para o host. do Terraform. Para isso, há um CMakeLists localizado em tensorflow/lite/tools/cmake/native_tools/flatbuffers para criar o Flatc compilador com o CMake antecipadamente em um diretório de build separado usando o conjunto de ferramentas.

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

Também é possível instalar o flatc em um local personalizado Por exemplo, para um diretório que contenha outras ferramentas criadas nativamente em vez do arquivo diretório de build):

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

Para a própria compilação cruzada LiteRT, o parâmetro adicional -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path>, que aponta para o diretório que contém o binário flatc nativo precisa ser fornecido com o a sinalização -DTFLITE_KERNEL_TEST=on mencionada acima.

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

Os testes de kernel (unidade) de compilação cruzada são iniciados no destino

Os testes de unidade podem ser executados como executáveis separados ou com o utilitário CTest. Até agora em relação ao CTest, se pelo menos um dos parâmetros TFLITE_ENABLE_XNNPACKorTFLITE_EXTERNAL_DELEGATE` está ativado para o LiteRT os testes resultantes são gerados com dois rótulos diferentes (usando o mesmo executável de teste): simples: denotando os testes executados em Back-end da CPU — delegar — indicando os testes que esperam lançamento adicional argumentos usados para a especificação de delegado usada

Tanto CTestTestfile.cmake quanto run-tests.cmake (conforme mencionado abaixo) são disponível em <build_dir>/kernels.

Lançamento de testes de unidade com back-end de CPU (desde que o CTestTestfile.cmake seja presente no destino do diretório atual):

ctest -L plain

Inicie exemplos de testes de unidade usando delegados (desde que o CTestTestfile.cmake e o arquivo run-tests.cmake estão presentes no destino em diretório atual):

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

Uma limitação conhecida dessa forma de fornecer recursos de autenticação de lançamento para testes de unidade é que ele suporta efetivamente apenas aqueles com um valor de retorno esperado de 0. Valores de retorno diferentes serão informados como um falha no teste.

Delegado de GPU OpenCL

Se a máquina de destino tiver suporte a OpenCL, use O delegado da GPU, que pode a aproveitar a potência da sua GPU.

Para configurar o suporte ao delegado da GPU OpenCL, faça o seguinte:

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

Etapa 5. Criar LiteRT

No diretório tflite_build,

cmake --build . -j

Etapa 6. Crie a ferramenta de referência LiteRT e exemplo de imagem de rótulo (opcional)

No diretório tflite_build,

cmake --build . -j -t benchmark_model

cmake --build . -j -t label_image

Opções disponíveis para criar o LiteRT

Veja a lista de opções disponíveis. É possível substituí-lo por -D<option_name>=[ON|OFF]: Por exemplo, de -DTFLITE_ENABLE_XNNPACK=OFF a desativar o XNNPACK, que é ativado por padrão.

Criar um projeto CMake que usa o LiteRT

Este é o CMakeLists.txt do Exemplo mínimo do TFLite.

É necessário ter add_subdirectory() para o diretório LiteRT e o link tensorflow-lite com 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)

Criar a biblioteca LiteRT C

Se você quiser criar uma biblioteca compartilhada LiteRT para API C, siga a etapa 1 para etapa 3 primeiro. Depois disso, execute o comandos a seguir.

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

Esse comando gera a seguinte biblioteca compartilhada no diretório atual.