Créer TensorFlow Lite avec CMake

Cette page décrit comment créer et utiliser la bibliothèque TensorFlow Lite avec l'outil CMake .

Les instructions suivantes ont été testées sur Ubuntu 16.04.3 PC 64 bits (AMD64), macOS Catalina (x86_64), Windows 10 et TensorFlow devel Docker image tensorflow/tensorflow:devel .

Remarque : Cette fonctionnalité est disponible depuis la version 2.4.

Étape 1. Installer l'outil CMake

Il nécessite CMake 3.16 ou supérieur. Sur Ubuntu, vous pouvez simplement exécuter la commande suivante.

sudo apt-get install cmake

Ou vous pouvez suivre le guide d'installation officiel de cmake

Étape 2. Cloner le référentiel TensorFlow

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

Remarque : Si vous utilisez l'image TensorFlow Docker, le référentiel est déjà fourni dans /tensorflow_src/ .

Étape 3. Créer le répertoire de construction CMake

mkdir tflite_build
cd tflite_build

Étape 4. Exécutez l'outil CMake avec les configurations

Version de version

Il génère un binaire de version optimisé par défaut. Si vous souhaitez créer pour votre poste de travail, exécutez simplement la commande suivante.

cmake ../tensorflow_src/tensorflow/lite

Version de débogage

Si vous devez produire une version de débogage contenant des informations sur les symboles, vous devez fournir l'option -DCMAKE_BUILD_TYPE=Debug .

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

Construire avec des tests unitaires du noyau

Pour pouvoir exécuter des tests du noyau, vous devez fournir l'indicateur '-DTFLITE_KERNEL_TEST=on'. Les spécificités de la compilation croisée des tests unitaires se trouvent 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 .

Idéalement, vous devriez également fournir vos propres versions des dépendances de la 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 <PackageName>_DIR pour pointer vers vos installations de bibliothèque.

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

Remarque : Reportez-vous à la documentation de CMake pour find_package pour en savoir plus sur la gestion et la localisation des packages.

Compilation croisée

Vous pouvez utiliser CMake pour créer des binaires pour les architectures cibles ARM64 ou Android.

Afin de cross-compiler le TF Lite, vous devez notamment fournir le chemin d'accès au SDK (par exemple, ARM64 SDK ou NDK dans le cas d'Android) avec l'indicateur -DCMAKE_TOOLCHAIN_FILE .

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

Spécificités de la compilation croisée Android

Pour la compilation croisée Android, vous devez installer Android NDK et fournir le chemin 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 de la compilation croisée des tests noyau (unitaire)

La compilation croisée des tests unitaires nécessite un compilateur flatc pour l'architecture hôte. À cette fin, il existe un CMakeLists situé dans tensorflow/lite/tools/cmake/native_tools/flatbuffers pour construire le compilateur flatc avec CMake à l'avance dans un répertoire de construction séparé à 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 le flatc dans un emplacement d'installation personnalisé (par exemple, dans un répertoire contenant d'autres outils construits nativement au lieu du répertoire de construction CMake) :

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

Pour la compilation croisée TF Lite elle-même, le 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' -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 du noyau (unitaire) compilés de manière croisée se lancent sur la cible

Les tests unitaires peuvent être exécutés en tant qu'exécutables séparés ou à l'aide de l'utilitaire CTest. En ce qui concerne CTest, si au moins un des paramètres TFLITE_ENABLE_NNAPI, TFLITE_ENABLE_XNNPACK ou TFLITE_EXTERNAL_DELEGATE est activé pour la construction TF Lite, les tests résultants sont générés avec deux étiquettes différentes (utilisant le même exécutable de test) : - plain - désignant les tests ceux exécutés sur le backend CPU - délégué - indiquant les tests attendant des arguments de lancement supplémentaires utilisés pour la spécification déléguée utilisée

CTestTestfile.cmake et run-tests.cmake (comme indiqué ci-dessous) sont disponibles dans <build_dir>/kernels .

Lancement des tests unitaires avec backend CPU (à condition que le CTestTestfile.cmake soit présent sur cible dans le répertoire courant) :

ctest -L plain

Lancez des exemples de tests unitaires à l'aide de délégués (à condition que le CTestTestfile.cmake ainsi que le fichier run-tests.cmake soient présents sur la cible dans le répertoire courant) :

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

Une limitation connue de cette façon de fournir des arguments de lancement supplémentaires liés au délégué aux tests unitaires est qu'elle ne prend en charge que ceux dont la valeur de retour attendue est 0 . Des valeurs de retour différentes seront signalées comme un échec du test.

Délégué GPU OpenCL

Si votre machine cible prend en charge OpenCL, vous pouvez utiliser le délégué GPU qui peut tirer parti de la puissance de votre GPU.

Pour configurer la prise en charge des délégués GPU OpenCL :

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

Remarque : Il est expérimental et disponible à partir de TensorFlow 2.5. Il pourrait y avoir des problèmes de compatibilité. Il n'est vérifié qu'avec les appareils Android et NVidia CUDA OpenCL 1.2.

Étape 5. Créer TensorFlow Lite

Dans le répertoire tflite_build,

cmake --build . -j

Remarque : Cela génère une bibliothèque statique libtensorflow-lite.a dans le répertoire courant, mais la bibliothèque n'est pas autonome puisque toutes les dépendances transitives ne sont pas incluses. Pour utiliser correctement la bibliothèque, vous devez créer un projet CMake. Veuillez vous référer à la section "Créer un projet CMake qui utilise TensorFlow Lite" .

Étape 6. Créer un outil de référence TensorFlow Lite et un exemple d'image d'étiquette (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 le 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	Caractéristique	Android	Linux	macOS	les fenêtres
TFLITE_ENABLE_RUY	Activer la bibliothèque de multiplication de matrice RUY	SUR	À L'ARRÊT	À L'ARRÊT	À L'ARRÊT
TFLITE_ENABLE_NNAPI	Activer le délégué NNAPI	SUR	À L'ARRÊT	N / A	N / A
TFLITE_ENABLE_GPU	Activer le délégué GPU	À L'ARRÊT	À L'ARRÊT	N / A	N / A
TFLITE_ENABLE_XNNPACK	Activer le délégué XNNPACK	SUR	SUR	SUR	SUR
TFLITE_ENABLE_MMAP	Activer MMAP	SUR	SUR	SUR	N / A

Créer un projet CMake qui utilise TensorFlow Lite

Voici l' exemple minimal CMakeLists.txt de TFLite .

Vous devez avoir add_subdirectory() pour le répertoire TensorFlow Lite et lier tensorflow-lite avec 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)

Construire la bibliothèque TensorFlow Lite C

Si vous souhaitez créer une bibliothèque partagée TensorFlow Lite pour l' API C , suivez d'abord les étapes 1 à 3 . Après cela, exécutez 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 courant.

Plateforme	Nom de la bibliothèque
Linux	libtensorflowlite_c.so
macOS	libtensorflowlite_c.dylib
les fenêtres	tensorflowlite_c.dll

Remarque : Vous avez besoin des en-têtes nécessaires (c_api.h, c_api_experimental.h et common.h) pour utiliser la bibliothèque partagée générée.