Esta página descreve como criar e usar a biblioteca TensorFlow Lite com a ferramenta CMake .
As instruções a seguir foram testadas no Ubuntu 16.04.3 PC de 64 bits (AMD64), macOS Catalina (x86_64), Windows 10 e TensorFlow devel Docker image tensorflow/tensorflow:devel .
Passo 1. Instale a ferramenta CMake
Requer CMake 3.16 ou superior. No Ubuntu, você pode simplesmente executar o seguinte comando.
sudo apt-get install cmake
Ou você pode seguir o guia oficial de instalação do cmake
Etapa 2. Clonar repositório TensorFlow
git clone https://github.com/tensorflow/tensorflow.git tensorflow_src
Etapa 3. Crie o diretório de compilação do CMake
mkdir tflite_build
cd tflite_build
Etapa 4. Execute a ferramenta CMake com configurações
Versão de lançamento
Ele gera um binário de versão otimizado por padrão. Se você deseja construir para sua estação de trabalho, basta executar o seguinte comando.
cmake ../tensorflow_src/tensorflow/lite
Compilação de depuração
Se você precisar produzir uma compilação de depuração que possua informações de símbolo, será necessário fornecer a opção -DCMAKE_BUILD_TYPE=Debug
.
cmake ../tensorflow_src/tensorflow/lite -DCMAKE_BUILD_TYPE=Debug
Construa com testes de unidade do kernel
Para poder executar testes de kernel, você precisa fornecer o sinalizador -DTFLITE_KERNEL_TEST=on
. As especificações de compilação cruzada de teste de unidade podem ser encontradas na próxima subseção.
cmake ../tensorflow_src/tensorflow/lite -DTFLITE_KERNEL_TEST=on
Construir pacote instalável
Para construir um pacote instalável que pode ser usado como dependência por outro projeto CMake com find_package(tensorflow-lite CONFIG)
, use a opção -DTFLITE_ENABLE_INSTALL=ON
.
Idealmente, você também deve fornecer suas próprias versões de dependências de biblioteca. Estes também precisarão ser utilizados pelo projeto que depende do TF Lite. É possível usar -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON
e configurar as variáveis <PackageName>_DIR
para apontar para as instalações de sua 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 compilar o TF Lite, você precisa fornecer o caminho para o SDK (por exemplo, ARM64 SDK ou NDK no caso do Android) com o sinalizador -DCMAKE_TOOLCHAIN_FILE
.
cmake -DCMAKE_TOOLCHAIN_FILE=<CMakeToolchainFileLoc> ../tensorflow/lite/
Especificações da compilação cruzada do Android
Para compilação cruzada do Android, você precisa instalar o Android NDK e fornecer o caminho do NDK com o sinalizador -DCMAKE_TOOLCHAIN_FILE
mencionado acima. Você também precisa definir a ABI de destino com o sinalizador -DANDROID_ABI
.
cmake -DCMAKE_TOOLCHAIN_FILE=<NDK path>/build/cmake/android.toolchain.cmake \
-DANDROID_ABI=arm64-v8a ../tensorflow_src/tensorflow/lite
Especificidades dos testes de kernel (unidade) de compilação cruzada
A compilação cruzada dos testes de unidade requer o compilador flatc para a arquitetura host. Para este propósito, existe um CMakeLists localizado em tensorflow/lite/tools/cmake/native_tools/flatbuffers
para construir o compilador flatc com CMake antecipadamente em um diretório de construção separado usando o conjunto de ferramentas do host.
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 de instalação personalizado (por exemplo, em um diretório contendo outras ferramentas nativas em vez do diretório de construção do CMake):
cmake -DCMAKE_INSTALL_PREFIX=<native_tools_dir> ../tensorflow_src/tensorflow/lite/tools/cmake/native_tools/flatbuffers
cmake --build .
Para a compilação cruzada do TF Lite em si, o parâmetro adicional -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path>
apontando para o diretório que contém o binário flatc nativo precisa ser fornecido junto com o sinalizador -DTFLITE_KERNEL_TEST=on
mencionado acima.
cmake -DCMAKE_TOOLCHAIN_FILE=${OE_CMAKE_TOOLCHAIN_FILE} -DTFLITE_KERNEL_TEST=on -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path> ../tensorflow/lite/
Testes de kernel (unidade) compilados cruzados são iniciados no destino
Os testes de unidade podem ser executados como executáveis separados ou usando o utilitário CTest. No que diz respeito ao CTest, se pelo menos um dos parâmetros TFLITE_ENABLE_NNAPI, TFLITE_ENABLE_XNNPACK
ou TFLITE_EXTERNAL_DELEGATE
estiver habilitado para a compilação do TF Lite, os testes resultantes serão gerados com dois rótulos diferentes (utilizando o mesmo executável de teste): - simples - denotando os testes aqueles executados no backend da CPU - delegado - denotando os testes que esperam argumentos de inicialização adicionais usados para a especificação de delegado usada
Tanto CTestTestfile.cmake
quanto run-tests.cmake
(conforme mencionado abaixo) estão disponíveis em <build_dir>/kernels
.
Lançamento de testes de unidade com backend de CPU (desde que CTestTestfile.cmake
esteja presente no destino no diretório atual):
ctest -L plain
Inicie exemplos de testes de unidade usando delegados (desde que o CTestTestfile.cmake
e também o arquivo run-tests.cmake
estejam presentes no destino no diretório atual):
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
Uma limitação conhecida desta forma de fornecer argumentos de inicialização adicionais relacionados a delegados para testes unitários é que ela efetivamente suporta apenas aqueles com um valor de retorno esperado de 0 . Valores de retorno diferentes serão relatados como falha no teste.
Delegado de GPU OpenCL
Se sua máquina de destino tiver suporte a OpenCL, você poderá usar o delegado de GPU , que pode aproveitar o poder de sua GPU.
Para configurar o suporte ao delegado GPU OpenCL:
cmake ../tensorflow_src/tensorflow/lite -DTFLITE_ENABLE_GPU=ON
Etapa 5. Crie o TensorFlow Lite
No diretório tflite_build
,
cmake --build . -j
Etapa 6. Criar ferramenta de benchmark do TensorFlow Lite 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 construir o TensorFlow Lite
Aqui está a lista de opções disponíveis. Você pode substituí-lo por -D<option_name>=[ON|OFF]
. Por exemplo, -DTFLITE_ENABLE_XNNPACK=OFF
para desabilitar o XNNPACK que está habilitado por padrão.
Nome da opção | Recurso | Android | Linux | Mac OS | janelas |
---|---|---|---|---|---|
TFLITE_ENABLE_RUY | Habilitar biblioteca de multiplicação de matrizes RUY | SOBRE | DESLIGADO | DESLIGADO | DESLIGADO |
TFLITE_ENABLE_NNAPI | Habilitar delegado NNAPI | SOBRE | DESLIGADO | N / D | N / D |
TFLITE_ENABLE_GPU | Habilitar delegado de GPU | DESLIGADO | DESLIGADO | N / D | N / D |
TFLITE_ENABLE_XNNPACK | Habilitar delegado XNNPACK | SOBRE | SOBRE | SOBRE | SOBRE |
TFLITE_ENABLE_MMAP | Habilitar MMAP | SOBRE | SOBRE | SOBRE | N / D |
Crie um projeto CMake que use TensorFlow Lite
Aqui está o exemplo mínimo do CMakeLists.txt do TFLite .
Você precisa ter add_subdirectory() para o diretório TensorFlow Lite e vincular 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 biblioteca TensorFlow Lite C
Se você deseja criar uma biblioteca compartilhada do TensorFlow Lite para API C , siga da etapa 1 à etapa 3 primeiro. Depois disso, execute os seguintes comandos.
Linux/Mac OS
cmake ../tensorflow_src/tensorflow/lite/c
cmake --build . -j
janelas
cmake ../tensorflow_src/tensorflow/lite/c
cmake --build . -j --config Release
Biblioteca Compilada
O comando acima gera a seguinte biblioteca compartilhada no diretório atual.
Plataforma | Nome da biblioteca |
---|---|
Linux | libtensorflowlite_c.so |
Mac OS | libtensorflowlite_c.dylib |
janelas | tensorflowlite_c.dll |