En savoir plus sur les annonces de Google AI Edge lors de la conférence I/O

Cette page a été traduite par l'API Cloud Translation.

Compiler TensorFlow Lite avec CMake

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_XNNPACKorTFLITE_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`