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 un PC Ubuntu 16.04.3 64 bits (AMD64), macOS Catalina (x86_64), Windows 10 et TensorFlow devel Docker image tensorflow/tensorflow:devel .
Étape 1. Installez 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
É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 sortie
Il génère par défaut un binaire de version optimisé. 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
Afin de pouvoir exécuter des tests de noyau, vous devez fournir l'indicateur -DTFLITE_KERNEL_TEST=on
. Les détails de la compilation croisée des tests unitaires peuvent être trouvés dans la sous-section suivante.
cmake ../tensorflow_src/tensorflow/lite -DTFLITE_KERNEL_TEST=on
Construire 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 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.
Afin de compiler de manière croisée 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 du noyau (unitaires)
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 natifs 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, 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/
Lancement des tests de noyau (unitaires) compilés de manière croisée 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 le build TF Lite, les tests résultants sont générés avec deux étiquettes différentes (en utilisant le même exécutable de test) : - plain - désignant les tests ceux exécutés sur le backend CPU - délégué - désignant les tests attendant des arguments de lancement supplémentaires utilisés pour la spécification du délégué utilisé
CTestTestfile.cmake
et run-tests.cmake
(comme indiqué ci-dessous) sont disponibles dans <build_dir>/kernels
.
Lancement des tests unitaires avec le backend CPU (à condition que le CTestTestfile.cmake
soit présent sur la cible dans le répertoire courant) :
ctest -L plain
Lancez des exemples de tests unitaires à l'aide de délégués (à condition que les fichiers CTestTestfile.cmake
ainsi que 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 aux délégués aux tests unitaires est qu'elle ne prend en charge que ceux dont la valeur de retour attendue est 0 . Différentes valeurs de retour seront signalées comme un échec du test.
Délégué GPU OpenCL
Si votre machine cible prend en charge OpenCL, vous pouvez utiliser un délégué GPU qui peut exploiter 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
Étape 5. Créer TensorFlow Lite
Dans le répertoire tflite_build
,
cmake --build . -j
É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 avec -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 | Fonctionnalité | Android | Linux | macOS | les fenêtres |
---|---|---|---|---|---|
TFLITE_ENABLE_RUY | Activer la bibliothèque de multiplication matricielle RUY | SUR | DÉSACTIVÉ | DÉSACTIVÉ | DÉSACTIVÉ |
TFLITE_ENABLE_NNAPI | Activer le délégué NNAPI | SUR | DÉSACTIVÉ | N / A | N / A |
TFLITE_ENABLE_GPU | Activer le délégué GPU | DÉSACTIVÉ | DÉSACTIVÉ | 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)
Créer 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.
Plate-forme | Nom de la bibliothèque |
---|---|
Linux | libtensorflowlite_c.so |
macOS | libtensorflowlite_c.dylib |
les fenêtres | tensorflowlite_c.dll |