Cette page explique comment créer et utiliser la bibliothèque LiteRT avec CMake.
Les instructions suivantes ont été testées sur les PC 64 bits Ubuntu 16.04.3 (AMD64) , macOS Catalina (x86_64), Windows 10 et TensorFlow devel image Docker tensorflow/tensorflow:devel.
Étape 1 : Installer l'outil CMake
Elle nécessite CMake 3.16 ou version ultérieure. Sous Ubuntu, il vous suffit d'exécuter la commande suivante : .
sudo apt-get install cmake
Vous pouvez également suivre le guide d'installation officiel de cmake
Étape 2 : Cloner un 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
Build
Il génère un fichier binaire optimisé par défaut. Si vous souhaitez construire pour votre poste de travail, exécutez simplement la commande suivante.
cmake ../tensorflow_src/tensorflow/lite
Version de débogage
Si vous devez générer 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
Compiler avec des tests unitaires de noyau
Pour pouvoir exécuter les tests du noyau, vous devez fournir le
-DTFLITE_KERNEL_TEST=on
. Les spécificités de la compilation croisée
du test unitaire peuvent être
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 qui peut être utilisé comme dépendance par un autre
projet CMake avec find_package(tensorflow-lite CONFIG)
, utilisez le
-DTFLITE_ENABLE_INSTALL=ON
.
Idéalement, 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 LiteRT. Vous pouvez
Utilisez -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON
et définissez <PackageName>_DIR
pour pointer 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 LiteRT, vous devez indiquer le chemin d'accès
Le SDK (par exemple, le SDK ARM64 ou le NDK dans le cas d'Android) avec -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
Android NDK et fournissez le chemin d'accès au NDK avec
-DCMAKE_TOOLCHAIN_FILE
mentionné ci-dessus. Vous devez aussi définir l'ABI cible
avec l'option -DANDROID_ABI
.
cmake -DCMAKE_TOOLCHAIN_FILE=<NDK path>/build/cmake/android.toolchain.cmake \
-DANDROID_ABI=arm64-v8a ../tensorflow_src/tensorflow/lite
Caractéristiques des tests unitaires (unit) du noyau
La compilation croisée des tests unitaires nécessite un compilateur plat pour l'hôte.
de l'architecture. À cette fin, il existe un CMakeLists situé dans
tensorflow/lite/tools/cmake/native_tools/flatbuffers
pour créer le flatc ;
compilateur avec CMake à l'avance dans un répertoire de compilation distinct à l'aide de l'hôte
ou une chaîne d'outils.
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 à un emplacement personnalisé. (par exemple, vers un répertoire contenant d'autres outils créés en mode natif au lieu de la bibliothèque CMake répertoire de compilation):
cmake -DCMAKE_INSTALL_PREFIX=<native_tools_dir> ../tensorflow_src/tensorflow/lite/tools/cmake/native_tools/flatbuffers
cmake --build .
Pour la compilation croisée LiteRT proprement dite, 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 le
-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 (units) 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 distincts ou à l'aide de l'utilitaire CTest. Autant
en ce qui concerne CTest, si au moins un des paramètres
TFLITE_ENABLE_XNNPACKor
TFLITE_EXTERNAL_DELEGATE est activé pour LiteRT
les tests obtenus sont générés avec deux étiquettes différentes.
(en utilisant le même exécutable de test) : - plain : indique les versions de test exécutées
Backend de processeur (délégué) indiquant les tests prévoyant un lancement supplémentaire
arguments utilisés pour la spécification déléguée utilisée
CTestTestfile.cmake
et run-tests.cmake
(comme indiqué ci-dessous) sont
disponible dans <build_dir>/kernels
.
Lancement de tests unitaires avec le backend de processeur (à condition que CTestTestfile.cmake
soit défini sur
présentes 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 le paramètre
CTestTestfile.cmake
et le fichier run-tests.cmake
sont présents dans la cible dans
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
Il s'agit d'une limitation connue de cette méthode pour fournir des ressources supplémentaires les arguments des tests unitaires, c'est qu'ils ne prennent en charge que ceux qui ont la valeur renvoyée est égale à 0. Différentes valeurs renvoyées sont signalées sous la forme d'un lors du test.
Délégué GPU OpenCL
Si votre machine cible est compatible avec OpenCL, vous pouvez utiliser délégué de GPU, qui peut la puissance de votre GPU.
Pour configurer la compatibilité avec la délégation de GPU OpenCL:
cmake ../tensorflow_src/tensorflow/lite -DTFLITE_ENABLE_GPU=ON
Étape 5 : Concevoir LiteRT
Dans le répertoire tflite_build
,
cmake --build . -j
Étape 6 : Créer un outil d'analyse comparative LiteRT 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 pour créer LiteRT
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 | Fonctionnalité | Android | Linux | macOS | Windows |
---|---|---|---|---|---|
TFLITE_ENABLE_RUY
|
Activer la devise RUY matrice multiplication bibliothèque | ON | Désactivé | Désactivé | Désactivé |
TFLITE_ENABLE_GPU
|
Activer le GPU délégué | Désactivé | Désactivé | N/A | N/A |
TFLITE_ENABLE_XNNPACK
|
Activer XNNPACK délégué | ON | ON | ON | ON |
TFLITE_ENABLE_MMAP |
Activer MMAP | ON | ON | ON | N/A |
Créer un projet CMake qui utilise LiteRT
Voici le fichier CMakeLists.txt Exemple de minimum avec TFLite.
Vous devez avoir la fonction add_subdirectory() pour le répertoire et le lien LiteRT
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 une bibliothèque LiteRT C
Si vous souhaitez créer une bibliothèque partagée LiteRT pour l'API C, suivez l'étape 1 pour étape 3. Ensuite, exécutez la 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 |