Crea TensorFlow Lite con CMake

Questa pagina descrive come creare e utilizzare la libreria TensorFlow Lite con lo strumento CMake .

Le seguenti istruzioni sono state testate su Ubuntu 16.04.3 PC a 64 bit (AMD64) , macOS Catalina (x86_64), Windows 10 e TensorFlow devel Docker image tensorflow/tensorflow:devel .

Passaggio 1. Installa lo strumento CMake

Richiede CMake 3.16 o versioni successive. Su Ubuntu, puoi semplicemente eseguire il seguente comando.

sudo apt-get install cmake

Oppure puoi seguire la guida all'installazione ufficiale di cmake

Passaggio 2. Clonare il repository TensorFlow

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

Passaggio 3. Crea la directory di compilazione di CMake

mkdir tflite_build
cd tflite_build

Passaggio 4. Esegui lo strumento CMake con le configurazioni

Rilascia build

Genera un binario di rilascio ottimizzato per impostazione predefinita. Se vuoi creare per la tua workstation, esegui semplicemente il seguente comando.

cmake ../tensorflow_src/tensorflow/lite

Debug build

Se è necessario produrre una build di debug con informazioni sui simboli, è necessario fornire l'opzione -DCMAKE_BUILD_TYPE=Debug .

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

Crea con gli unit test del kernel

Per poter eseguire i test del kernel, devi fornire il flag '-DTFLITE_KERNEL_TEST=on'. Le specifiche della compilazione incrociata degli unit test possono essere trovate nella sottosezione successiva.

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

Crea pacchetto installabile

Per creare un pacchetto installabile che può essere utilizzato come dipendenza da un altro progetto CMake con find_package(tensorflow-lite CONFIG) , usa l'opzione -DTFLITE_ENABLE_INSTALL=ON .

Idealmente dovresti anche fornire le tue versioni delle dipendenze della libreria. Questi dovranno anche essere utilizzati dal progetto che dipende da TF Lite. È possibile utilizzare -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON e impostare le variabili <PackageName>_DIR in modo che puntino alle installazioni della libreria.

cmake ../tensorflow_src/tensorflow/lite -DTFLITE_ENABLE_INSTALL=ON \
  -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON \
  -Dabsl_DIR=<install path>/lib/cmake/absl \
  -DEigen3_DIR=<install path>/share/eigen3/cmake \
  -DFlatbuffers_DIR=<install path>/lib/cmake/flatbuffers \
  -DNEON_2_SSE_DIR=<install path>/lib/cmake/NEON_2_SSE \
  -Dcpuinfo_DIR=<install path>/share/cpuinfo \
  -Druy_DIR=<install path>/lib/cmake/ruy

Compilazione incrociata

Puoi usare CMake per creare binari per architetture di destinazione ARM64 o Android.

Per eseguire la cross-compilazione di TF Lite, è necessario fornire il percorso dell'SDK (ad es. ARM64 SDK o NDK nel caso di Android) con il flag -DCMAKE_TOOLCHAIN_FILE .

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

Specifiche della cross-compilation di Android

Per la cross-compilation di Android, devi installare Android NDK e fornire il percorso NDK con il flag -DCMAKE_TOOLCHAIN_FILE menzionato sopra. Devi anche impostare l'ABI di destinazione con il flag -DANDROID_ABI .

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

Specifiche della compilazione incrociata dei test del kernel (unità).

La compilazione incrociata degli unit test richiede il compilatore flatc per l'architettura host. A tale scopo, esiste una CMakeLists situata in tensorflow/lite/tools/cmake/native_tools/flatbuffers per compilare il compilatore flatc con CMake in anticipo in una directory di compilazione separata utilizzando la toolchain host.

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

È anche possibile installare il flatc in una posizione di installazione personalizzata (ad esempio in una directory contenente altri strumenti creati in modo nativo invece della directory build di CMake):

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

Per la stessa compilazione incrociata di TF Lite, è necessario fornire il parametro aggiuntivo -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path> che punta alla directory contenente il binario flatc nativo insieme al flag -DTFLITE_KERNEL_TEST=on menzionato sopra.

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

I test del kernel (unità) cross-compilati vengono avviati sulla destinazione

Gli unit test possono essere eseguiti come eseguibili separati o utilizzando l'utilità CTest. Per quanto riguarda CTest, se almeno uno dei parametri TFLITE_ENABLE_NNAPI, TFLITE_ENABLE_XNNPACK o TFLITE_EXTERNAL_DELEGATE è abilitato per la build TF Lite, i test risultanti vengono generati con due differenti label (utilizzando lo stesso eseguibile di test): - plain - che denotano i test quelli eseguiti sul back-end della CPU - delegato - che denota i test che prevedono argomenti di avvio aggiuntivi utilizzati per la specifica del delegato utilizzata

Sia CTestTestfile.cmake che run-tests.cmake (come indicato di seguito) sono disponibili in <build_dir>/kernels .

Avvio di unit test con back-end CPU (a condizione CTestTestfile.cmake sia presente sulla destinazione nella directory corrente):

ctest -L plain

Avvia esempi di unit test utilizzando i delegati (a condizione che il CTestTestfile.cmake e run-tests.cmake siano presenti sulla destinazione nella directory corrente):

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

Una limitazione nota di questo modo di fornire argomenti di avvio relativi ai delegati aggiuntivi agli unit test è che supporta efficacemente solo quelli con un valore di ritorno previsto di 0 . Diversi valori di ritorno verranno segnalati come un test non riuscito.

Delegato GPU OpenCL

Se la tua macchina di destinazione ha il supporto OpenCL, puoi utilizzare il delegato GPU che può sfruttare la potenza della tua GPU.

Per configurare il supporto dei delegati GPU OpenCL:

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

Passaggio 5. Crea TensorFlow Lite

Nella directory tflite_build,

cmake --build . -j

Passaggio 6. Creazione dello strumento di benchmark TensorFlow Lite ed esempio di immagine dell'etichetta (opzionale)

Nella directory tflite_build,

cmake --build . -j -t benchmark_model

cmake --build . -j -t label_image

Opzioni disponibili per costruire TensorFlow Lite

Ecco l'elenco delle opzioni disponibili. Puoi sovrascriverlo con -D<option_name>=[ON|OFF] . Ad esempio, -DTFLITE_ENABLE_XNNPACK=OFF per disabilitare XNNPACK che è abilitato per impostazione predefinita.

Crea un progetto CMake che utilizza TensorFlow Lite

Ecco l' esempio minimo di CMakeLists.txt di TFLite .

È necessario disporre di add_subdirectory() per la directory TensorFlow Lite e collegare tensorflow-lite con 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)

Crea la libreria TensorFlow Lite C

Se desideri creare una libreria condivisa TensorFlow Lite per C API , segui prima il passaggio 1 al passaggio 3 . Successivamente, esegui i seguenti comandi.

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

Questo comando genera la seguente libreria condivisa nella directory corrente.