Crea LiteRT con CMake

In questa pagina viene descritto come creare e utilizzare la libreria LiteRT con CMake.

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

Passaggio 1. Installa lo strumento CMake

Richiede CMake 3.16 o versioni successive. Su Ubuntu, puoi semplicemente eseguire questo .

sudo apt-get install cmake

Oppure puoi seguire la guida all'installazione ufficiale di cmake

Passaggio 2: Clona il repository TensorFlow

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

Passaggio 3: Crea directory di build CMake

mkdir tflite_build
cd tflite_build

Passaggio 4: Esecuzione dello strumento CMake con configurazioni

Build della release

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

cmake ../tensorflow_src/tensorflow/lite

Build di debug

Se devi generare una build di debug che contiene informazioni sui simboli, devi fornisci l'opzione -DCMAKE_BUILD_TYPE=Debug.

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

Crea con i test delle unità kernel

Per poter eseguire i test del kernel, devi fornire il metodo -DTFLITE_KERNEL_TEST=on flag. Le specifiche della cross-compilazione per i test delle unità possono essere che trovi nella prossima sottosezione.

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

Crea pacchetto installabile

per creare un pacchetto installabile che possa essere usato come dipendenza da un altro Crea progetto con find_package(tensorflow-lite CONFIG), utilizza Opzione -DTFLITE_ENABLE_INSTALL=ON.

Idealmente, dovresti fornire anche le tue versioni delle dipendenze di libreria. Dovranno inoltre essere utilizzate dal progetto che dipende da LiteRT. Puoi usa -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON e imposta <PackageName>_DIR che puntino alle installazioni della tua libreria.

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

Cross-compilazione

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

Per eseguire il cross-compilazione di LiteRT, devi fornire il percorso l'SDK (ad es. SDK ARM64 o NDK nel caso di Android) con -DCMAKE_TOOLCHAIN_FILE flag.

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

Specifiche della cross-compilazione Android

Per la crosscompilazione su Android, devi installare Android NDK e fornire il percorso NDK con -DCMAKE_TOOLCHAIN_FILE segnalato sopra. Devi anche impostare un'ABI di destinazione con flag -DANDROID_ABI.

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

Specifiche dei test di kernel (unità) con cross-compilazione

La cross-compilazione dei test delle unità richiede un compilatore flatc per l'host dell'architettura. A questo scopo, è disponibile CMakeLists tensorflow/lite/tools/cmake/native_tools/flatbuffers per costruire il flatc con CMake in una directory di build separata utilizzando la toolchain.

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 un percorso di installazione personalizzato (ad es. in una directory contenente altri strumenti creati in modo nativo anziché l'interfaccia directory di build):

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

Per la stessa cross-compilazione LiteRT, parametro aggiuntivo -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path> che rimanda alla directory contenente è necessario fornire il binario nativo flatc insieme -DTFLITE_KERNEL_TEST=on segnalato sopra.

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

Lancio dei test del kernel (unità) con compilazione incrociata nella destinazione

I test delle unità possono essere eseguiti come eseguibili separati o utilizzando l'utilità CTest. Finora dei test CTest, se almeno uno dei parametri TFLITE_ENABLE_XMNPACKorTFLITE_EXTERNAL_DELEGATE` è abilitato per LiteRT i test risultanti vengono generati con due etichette diverse (utilizzando lo stesso eseguibile di test): normale che indica i test su cui vengono eseguiti Backend della CPU - delegate - che indica i test che prevedono un avvio aggiuntivo argomenti utilizzati per la specifica del delegato utilizzato

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

Lancio dei test delle unità con il backend della CPU (a condizione che CTestTestfile.cmake sia presente nella destinazione nella directory corrente):

ctest -L plain

Esempi di lancio di test delle unità con delegati (a condizione che CTestTestfile.cmake e run-tests.cmake file sono presenti in linea con il target in directory corrente):

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 ulteriori informazioni argomenti di lancio ai test delle unità è che supporta in modo efficace solo quelli con un valore restituito previsto pari a 0. I diversi valori restituiti verranno segnalati come test non riuscito.

Delega GPU OpenCL

Se la macchina di destinazione supporta OpenCL, puoi utilizzare Delega GPU, che può sfruttano la potenza della GPU.

Per configurare il supporto delegato per GPU OpenCL:

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

Passaggio 5: LiteRT di build

Nella directory tflite_build,

cmake --build . -j

Passaggio 6: Esempio di strumento Build LiteRT Benchmark ed esempio di immagine etichetta (facoltativo)

Nella directory tflite_build,

cmake --build . -j -t benchmark_model

cmake --build . -j -t label_image

Opzioni disponibili per creare LiteRT

Ecco l'elenco delle opzioni disponibili. Puoi sostituirlo con -D<option_name>=[ON|OFF]. Ad esempio, da -DTFLITE_ENABLE_XNNPACK=OFF a e disattivare l'opzione XMNPACK, che è abilitata per impostazione predefinita.

Creare un progetto CMake che utilizza LiteRT

Ecco il file CMakeLists.txt di Esempio minimo di TFLite.

Devi avere add_subdirectory() per la directory LiteRT e il link 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 LiteRT C

Se vuoi creare una libreria condivisa LiteRT per API C, segui il passaggio 1 per passaggio 3. Dopodiché, esegui seguenti comandi.

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

Questo comando genera la seguente libreria condivisa nella directory attuale.