Ajuda a proteger a Grande Barreira de Corais com TensorFlow em Kaggle Junte Desafio

Construir TensorFlow Lite com CMake

Esta página descreve como construir e usar a biblioteca TensorFlow Lite com CMake ferramenta.

As seguintes instruções foram testados no Ubuntu 16.04.3 computador de 64 bits (AMD64), MacOS Catalina (x86_64), imagem do Windows 10 e TensorFlow devel Docker tensorflow / tensorflow: devel .

Etapa 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 cmake

Etapa 2. Clonar o repositório TensorFlow

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

Etapa 3. Crie o diretório de construção CMake

mkdir tflite_build
cd tflite_build

Etapa 4. Execute a ferramenta CMake com as configurações

Versão de lançamento

Ele gera um binário de lançamento otimizado por padrão. Se você deseja construir para sua estação de trabalho, simplesmente execute o seguinte comando.

cmake ../tensorflow_src/tensorflow/lite

Depurar compilação

Se você precisa para produzir uma compilação de depuração que tem informações de símbolos, você precisa fornecer -DCMAKE_BUILD_TYPE=Debug opção.

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

Construir com testes de unidade de kernel

Para poder executar os testes do 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

Compilação cruzada

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

A fim de cross-compilar o TF Lite, ou seja, precisa fornecer o caminho para o SDK (por exemplo ARM64 SDK ou NDK no caso do Android) com -DCMAKE_TOOLCHAIN_FILE bandeira.

cmake -DCMAKE_TOOLCHAIN_FILE=<CMakeToolchainFileLoc> ../tensorflow/lite/
Especificações da compilação cruzada do Android

Para Android cross-compilação, você precisa instalar o Android NDK e forneça o caminho NDK com -DCMAKE_TOOLCHAIN_FILE bandeira mencionado acima. Você também precisa meta estabelecida ABI com -DANDROID_ABI bandeira.

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 um compilador flatc para a arquitetura do host. Para este fim, há uma CMakeLists localizados em tensorflow/lite/tools/cmake/native_tools/flatbuffers para construir o compilador flatc com CMake com antecedência em um diretório de compilação separada, usando o conjunto de ferramentas 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 para um local de instalação personalizada (por exemplo, para um diretório que contém outras ferramentas nativamente construídas em vez do diretório de compilação CMake):

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

Para o próprio TF Lite cross-compilação, adicional parâmetro -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path> apontando para o diretório que contém as necessidades binários flatc nativas a serem prestados junto com os -DTFLITE_KERNEL_TEST=on a bandeira mencionado acima.

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

Delegado GPU OpenCL

Se a sua máquina de destino tem suporte OpenCL, você pode usar GPU delegado que pode alavancar o seu poder de GPU.

Para configurar o suporte de delegado de GPU OpenCL:

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

Etapa 5. Construir TensorFlow Lite

No diretório tflite_build,

cmake --build . -j

Etapa 6. Construir ferramenta de teste de referência 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 compilar TensorFlow Lite

Aqui está a lista de opções disponíveis. Você pode substituí-lo com -D<option_name>=[ON|OFF] . Por exemplo, -DTFLITE_ENABLE_XNNPACK=OFF para desativar XNNPACK que é ativado 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 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 usa TensorFlow Lite

Aqui está a CMakeLists.txt de TFLite exemplo mínimo .

Você precisa ter add_subdirectory () para o diretório TensorFlow Lite e ligação 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)

Compilar a biblioteca TensorFlow Lite C

Se você quer construir TensorFlow Lite biblioteca compartilhada para C API , acompanhamento passo 1 a passo 3 em primeiro lugar. Depois disso, execute os seguintes comandos.

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

Este comando 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