Saiba mais sobre os anúncios do I/O (em inglês) do Google AI Edge

Esta página foi traduzida pela API Cloud Translation.

Criar o TensorFlow Lite com o CMake

Nesta página, descrevemos como criar e usar a biblioteca do TensorFlow Lite com a ferramenta CMake.

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

Etapa 1. Instalar a ferramenta CMake

Ele exige o CMake 3.16 ou mais recente. No Ubuntu, é possível simplesmente executar o comando a seguir.

sudo apt-get install cmake

Ou siga o guia de instalação oficial do cmake (em inglês).

Etapa 2: clonar o repositório do TensorFlow

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

Etapa 3. Criar diretório de build do CMake

mkdir tflite_build
cd tflite_build

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

Build de lançamento

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

cmake ../tensorflow_src/tensorflow/lite

Depurar build

Se você precisar produzir um build de depuração que tenha informações de símbolo, 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 a flag -DTFLITE_KERNEL_TEST=on. Os detalhes da compilação cruzada de testes de unidade podem ser encontrados 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 do CMake com find_package(tensorflow-lite CONFIG), use a opção -DTFLITE_ENABLE_INSTALL=ON.

Além disso, você precisa fornecer suas próprias versões de dependências de biblioteca. Eles também precisarão ser usados pelo projeto que depende do TF Lite. É possível usar o -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON e definir as variáveis <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 do TF Lite, é necessário fornecer o caminho para o SDK (por exemplo, SDK do ARM64 ou NDK no caso do Android) com a sinalização -DCMAKE_TOOLCHAIN_FILE.

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

Especificações da compilação cruzada do Android

Para a compilação cruzada do Android, é necessário instalar o Android NDK e fornecer o caminho dele com a flag -DCMAKE_TOOLCHAIN_FILE mencionada acima. Também é necessário 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 de compilação cruzada de testes de kernel (unidade)

A compilação cruzada dos testes de unidade requer o compilador flatc para a arquitetura do host. Para essa finalidade, há um CMakeLists localizado em tensorflow/lite/tools/cmake/native_tools/flatbuffers para criar o compilador Flatc com o CMake antecipadamente em um diretório de build separado usando o conjunto de ferramentas de 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 que contenha outras ferramentas nativas em vez do diretório de build 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, 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 a flag -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/

Testes de kernel (unidade) de compilação cruzada são lançados 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_XNNPACKorTFLITE_EXTERNAL_DELEGATE` estiver ativado para o build do TF Lite, os testes resultantes serão gerados com dois rótulos diferentes (usando o mesmo executável de teste): - simples, denotando os testes que são executados na especificação de back-end usados, delegando os testes usados para os testes delegados usados

Tanto CTestTestfile.cmake quanto run-tests.cmake (conforme indicado abaixo) estão disponíveis em <build_dir>/kernels.

Lançamento de testes de unidade com o back-end da 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 arquivo CTestTestfile.cmake e run-tests.cmake estejam presentes no destino no 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 maneira de fornecer argumentos de inicialização relacionados ao delegado para testes de unidade é que ela é efetivamente compatível apenas com aqueles com um valor de retorno esperado de 0. Valores de retorno diferentes serão informados como uma falha no teste.

Delegado de GPU do OpenCL

Se a máquina de destino for compatível com OpenCL, será possível usar o delegado de GPU, que pode aproveitar a energia da GPU.

Para configurar o suporte ao delegado de GPU do OpenCL:

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

Etapa 5. Criar o TensorFlow Lite

No diretório tflite_build,

cmake --build . -j

Etapa 6. Criar a ferramenta de comparativo de mercado do TensorFlow Lite e um 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 TensorFlow Lite

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

Nome da opção	Engenharia de	Android	Linux	macOS	Windows
`TFLITE_ENABLE_RUY`	Ativar a biblioteca de multiplicação de matriz RUY	ON	DESLIGADO	DESLIGADO	DESLIGADO
`TFLITE_ENABLE_GPU`	Ativar delegação de GPU	DESLIGADO	DESLIGADO	N/A	N/A
`TFLITE_ENABLE_XNNPACK`	Ativar a delegação XNNPACK	ON	ON	ON	ON
`TFLITE_ENABLE_MMAP`	Ativar MMAP	ON	ON	ON	N/A

Criar um projeto do CMake que usa o TensorFlow Lite

Confira o CMakeLists.txt do exemplo mínimo de TFLite (em inglês).

Você precisa ter add_subdirectory() para o diretório do TensorFlow Lite e vincular tensorflow-lite a 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 uma biblioteca C do TensorFlow Lite

Se você quiser criar uma biblioteca compartilhada do TensorFlow Lite para a API C, siga a etapa 1 até a etapa 3 primeiro. Depois disso, execute os 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`