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_XNNPACKor
TFLITE_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.
Nome da opção | Recurso | Android | Linux | macOS | Windows |
---|---|---|---|---|---|
TFLITE_ENABLE_RUY
|
Ativar RUY matriz multiplicação biblioteca | ATIVADO | DESATIVADO | DESATIVADO | DESATIVADO |
TFLITE_ENABLE_GPU
|
Ativar GPU delegar | DESATIVADO | DESATIVADO | N/A | N/A |
TFLITE_ENABLE_XNNPACK
|
Ativar XNNPACK delegar | ATIVADO | ATIVADO | ATIVADO | ATIVADO |
TFLITE_ENABLE_MMAP |
Ativar MMAP | ATIVADO | ATIVADO | ATIVADO | N/A |
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.
Plataforma | Nome da biblioteca |
---|---|
Linux | libtensorflowlite_c.so |
macOS | libtensorflowlite_c.dylib |
Windows | tensorflowlite_c.dll |