Créer LiteRT avec CMake

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

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.