Scopri di più sui nostri annunci di Google AI Edge da I/O

Questa pagina è stata tradotta dall'API Cloud Translation.

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 PC a 64 bit (AMD64) Ubuntu 16.04.3, macOS Catalina (x86_64), Windows 10 e TensorFlow per lo sviluppo di image Docker 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

In alternativa, puoi seguire la guida ufficiale all'installazione 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. Esegui lo strumento CMake con le configurazioni

Release build

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

cmake ../tensorflow_src/tensorflow/lite

Build di debug

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

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

Creazione con test delle unità kernel

Per poter eseguire i test del kernel, devi fornire il flag -DTFLITE_KERNEL_TEST=on. Le specifiche per la compilazione incrociata del test di unità sono disponibili nella sottosezione successiva.

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

Crea pacchetto installabile

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

Idealmente, dovresti anche fornire le tue versioni delle dipendenze di libreria. che dovranno essere utilizzati anche dal progetto che dipende da TF Lite. Puoi utilizzare -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON e impostare le variabili <PackageName>_DIR in modo 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

Crosscompilazione

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

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

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

Specifiche della cross-compilazione Android

Per la cross-compilazione 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 cross-compilazione dei test del kernel (unità)

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

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

È anche possibile installare flatc in un percorso di installazione personalizzato (ad esempio in una directory contenente altri strumenti creati in modo nativo anziché la directory di compilazione CMake):

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

Per la cross-compilazione TF Lite, è necessario fornire un parametro aggiuntivo -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path> che punta alla directory contenente il programma 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/

Avvio dei test del kernel (unità) cross-compilati in base alla destinazione

I test delle unità possono essere eseguiti come file eseguibili separati oppure utilizzando l'utilità CTest. Per quanto riguarda CTest, se almeno uno dei parametri TFLITE_ENABLE_XNPACKorTFLITE_EXTERNAL_DELEGATE` è abilitato per la build TF Lite, i test risultanti vengono generati con due diverse etichette (utilizzando lo stesso eseguibile di test): - plain - indica i test eseguiti sulla CPU - delegare i test usati per le specifiche di backend utilizzate

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

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

ctest -L plain

Avvia esempi di test delle unità utilizzando delegati (a condizione che i file CTestTestfile.cmake e run-tests.cmake siano presenti nella destinazione nella directory attuale):

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 ai test delle unità argomenti di lancio aggiuntivi correlati ai delegati è che supporta in modo efficace solo quelli con un valore restituito previsto pari a 0. Valori restituiti diversi verranno segnalati come errore di test.

Delegato GPU OpenCL

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

Per configurare il supporto del delegato GPU OpenCL:

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

Passaggio 5: Creazione di TensorFlow Lite

Nella directory tflite_build,

cmake --build . -j

Passaggio 6: (Facoltativo) Esempio di immagine di etichetta e strumento di benchmark di Build TensorFlow Lite

Nella directory tflite_build,

cmake --build . -j -t benchmark_model

cmake --build . -j -t label_image

Opzioni disponibili per creare TensorFlow Lite

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

Nome opzione	Funzionalità	Android	Linux	macOS	Windows
`TFLITE_ENABLE_RUY`	Abilita la libreria di moltiplicazione della matrice RUY	ON	OFF	OFF	OFF
`TFLITE_ENABLE_GPU`	Abilita delega GPU	OFF	OFF	N/A	N/A
`TFLITE_ENABLE_XNNPACK`	Abilita delega IntroNPACK	ON	ON	ON	ON
`TFLITE_ENABLE_MMAP`	Attiva MMAP	ON	ON	ON	N/A

Creare un progetto CMake che utilizza TensorFlow Lite

Ecco il file CMakeLists.txt sull'esempio minimo TFLite.

Devi avere add_subdirectory() per la directory TensorFlow Lite e collegare 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)

Crea la libreria TensorFlow Lite C

Se vuoi creare la libreria condivisa TensorFlow Lite per l'API C, segui prima il passaggio 1 al passaggio 3. Esegui i comandi seguenti.

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

Questo comando genera la seguente libreria condivisa nella directory attuale.

Piattaforma	Nome della biblioteca
Linux	`libtensorflowlite_c.so`
macOS	`libtensorflowlite_c.dylib`
Windows	`tensorflowlite_c.dll`