Cette page explique comment compiler et utiliser la bibliothèque TensorFlow Lite avec l'outil CMake.
Les instructions suivantes ont été testées sur Ubuntu 16.04.3 64 bits (AMD64), macOS Catalina (x86_64), Windows 10 et l'image Docker de développement TensorFlow tensorflow/tensorflow:devel.
Étape 1. Installer l'outil CMake
Elle nécessite CMake 3.16 ou version ultérieure. Sous Ubuntu, vous pouvez simplement exécuter la commande suivante.
sudo apt-get install cmake
Vous pouvez également consulter le guide d'installation officiel de cmake.
Étape 2 : Cloner le dépôt TensorFlow
git clone https://github.com/tensorflow/tensorflow.git tensorflow_src
Étape 3. Créer un répertoire de compilation CMake
mkdir tflite_build
cd tflite_build
Étape 4. Exécuter l'outil CMake avec des configurations
Version
Elle génère un binaire de version optimisé par défaut. Si vous souhaitez compiler pour votre poste de travail, exécutez simplement la commande suivante.
cmake ../tensorflow_src/tensorflow/lite
Déboguer le build
Si vous devez générer une version de débogage contenant des informations de symbole, vous devez fournir l'option -DCMAKE_BUILD_TYPE=Debug
.
cmake ../tensorflow_src/tensorflow/lite -DCMAKE_BUILD_TYPE=Debug
Compiler avec des tests unitaires du noyau
Pour pouvoir exécuter les tests du noyau, vous devez fournir l'option -DTFLITE_KERNEL_TEST=on
. Les détails de la compilation croisée des tests unitaires sont disponibles dans la sous-section suivante.
cmake ../tensorflow_src/tensorflow/lite -DTFLITE_KERNEL_TEST=on
Créer un package installable
Pour créer un package installable pouvant être utilisé comme dépendance par un autre projet CMake avec find_package(tensorflow-lite CONFIG)
, utilisez l'option -DTFLITE_ENABLE_INSTALL=ON
.
Dans l'idéal, vous devez également fournir vos propres versions des dépendances de bibliothèque.
Ceux-ci devront également être utilisés par le projet qui dépend de TF Lite. Vous pouvez utiliser -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON
et définir les variables <PackageName>_DIR
pour qu'elles pointent vers les installations de votre bibliothèque.
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
Compilation croisée
Vous pouvez utiliser CMake pour créer des binaires pour les architectures cibles ARM64 ou Android.
Pour effectuer une compilation croisée de TF Lite, vous devez fournir le chemin d'accès au SDK (par exemple, le SDK ARM64 ou le NDK dans le cas d'Android) avec l'indicateur -DCMAKE_TOOLCHAIN_FILE
.
cmake -DCMAKE_TOOLCHAIN_FILE=<CMakeToolchainFileLoc> ../tensorflow/lite/
Caractéristiques de la compilation croisée Android
Pour la compilation croisée Android, vous devez installer le NDK Android et fournir le chemin d'accès au NDK avec l'indicateur -DCMAKE_TOOLCHAIN_FILE
mentionné ci-dessus. Vous devez également définir l'ABI cible avec l'indicateur -DANDROID_ABI
.
cmake -DCMAKE_TOOLCHAIN_FILE=<NDK path>/build/cmake/android.toolchain.cmake \
-DANDROID_ABI=arm64-v8a ../tensorflow_src/tensorflow/lite
Spécificités du noyau (unité) testant une compilation croisée
La compilation croisée des tests unitaires nécessite un compilateur platc pour l'architecture hôte. À cet effet, des listes CMakeList situées dans tensorflow/lite/tools/cmake/native_tools/flatbuffers
permettent de compiler à l'avance le compilateur platc avec CMake dans un répertoire de compilation distinct à l'aide de la chaîne d'outils hôte.
mkdir flatc-native-build && cd flatc-native-build
cmake ../tensorflow_src/tensorflow/lite/tools/cmake/native_tools/flatbuffers
cmake --build .
Il est également possible d'installer flatc dans un emplacement personnalisé (par exemple, dans un répertoire contenant d'autres outils intégrés de manière native au lieu du répertoire de compilation CMake):
cmake -DCMAKE_INSTALL_PREFIX=<native_tools_dir> ../tensorflow_src/tensorflow/lite/tools/cmake/native_tools/flatbuffers
cmake --build .
Pour la compilation croisée de TF Lite elle-même, un paramètre supplémentaire -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path>
pointant vers le répertoire contenant le binaire flatc natif doit être fourni avec l'indicateur -DTFLITE_KERNEL_TEST=on
mentionné ci-dessus.
cmake -DCMAKE_TOOLCHAIN_FILE=${OE_CMAKE_TOOLCHAIN_FILE} -DTFLITE_KERNEL_TEST=on -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path> ../tensorflow/lite/
Les tests de noyau (unitaire) croisés sont lancés sur la cible
Les tests unitaires peuvent être exécutés en tant qu'exécutables distincts ou à l'aide de l'utilitaire CTest. En ce qui concerne CTest, si au moins l'un des paramètres TFLITE_ENABLE_XNNPACKor
TFLITE_EXTERNAL_DELEGATE est activé pour le build TF Lite, les tests obtenus sont générés avec deux libellés différents (en utilisant le même exécutable de test) : plain : argument indiquant les tests qui sont exécutés sur le backend sans être délégués ; déléguer les tests utilisés sur le backend utilisé
CTestTestfile.cmake
et run-tests.cmake
(comme indiqué ci-dessous) sont disponibles dans <build_dir>/kernels
.
Lancement des tests unitaires avec le backend du processeur (à condition que CTestTestfile.cmake
soit présent sur la cible dans le répertoire actuel):
ctest -L plain
Lancez des exemples de tests unitaires à l'aide de délégués (à condition que les fichiers CTestTestfile.cmake
et run-tests.cmake
soient présents sur la cible dans le répertoire actuel):
cmake -E env TESTS_ARGUMENTS=--use_xnnpack=true ctest -L delegate
cmake -E env TESTS_ARGUMENTS=--external_delegate_path=<PATH> ctest -L delegate
Une limite connue de cette méthode permettant de fournir des arguments de lancement supplémentaires liés au délégué pour les tests unitaires est qu'elle ne prend en charge que ceux dont la valeur renvoyée attendue est 0. Différentes valeurs renvoyées seront signalées comme un échec du test.
Délégué de GPU OpenCL
Si votre machine cible est compatible avec OpenCL, vous pouvez utiliser le délégué de GPU qui peut exploiter la puissance de votre GPU.
Pour configurer la prise en charge du délégué de GPU OpenCL:
cmake ../tensorflow_src/tensorflow/lite -DTFLITE_ENABLE_GPU=ON
Étape 5 : Compiler TensorFlow Lite
Dans le répertoire tflite_build
,
cmake --build . -j
Étape 6 : Créer un outil d'analyse comparative TensorFlow Lite et un exemple d'image de libellé (facultatif)
Dans le répertoire tflite_build
,
cmake --build . -j -t benchmark_model
cmake --build . -j -t label_image
Options disponibles pour créer TensorFlow Lite
Voici la liste des options disponibles. Vous pouvez la remplacer par -D<option_name>=[ON|OFF]
. Par exemple, -DTFLITE_ENABLE_XNNPACK=OFF
pour désactiver XNNPACK, qui est activé par défaut.
Nom de l'option | Sélection | Android | Linux | macOS | Windows |
---|---|---|---|---|---|
TFLITE_ENABLE_RUY
|
Activer la bibliothèque de multiplications matricielles RUY | ACTIVÉE | OFF | OFF | OFF |
TFLITE_ENABLE_GPU
|
Activer la délégation GPU | OFF | OFF | N/A | N/A |
TFLITE_ENABLE_XNNPACK
|
Activer le délégué XNNPACK | ACTIVÉE | ACTIVÉE | ACTIVÉE | ACTIVÉE |
TFLITE_ENABLE_MMAP |
Activer MMAP | ACTIVÉE | ACTIVÉE | ACTIVÉE | N/A |
Créer un projet CMake qui utilise TensorFlow Lite
Voici le fichier CMakeLists.txt de l'exemple minimal TFLite.
Vous devez disposer de add_subdirectory() pour le répertoire TensorFlow Lite et d'associer tensorflow-lite
à 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)
Créer une bibliothèque TensorFlow Lite C
Si vous souhaitez créer une bibliothèque partagée TensorFlow Lite pour l'API C, suivez d'abord l'étape 1 à l'étape 3. Exécutez ensuite les commandes suivantes.
cmake ../tensorflow_src/tensorflow/lite/c
cmake --build . -j
Cette commande génère la bibliothèque partagée suivante dans le répertoire actuel.
Plate-forme | Nom de la bibliothèque |
---|---|
Linux | libtensorflowlite_c.so |
macOS | libtensorflowlite_c.dylib |
Windows | tensorflowlite_c.dll |