LiteRT mit CMake erstellen

Auf dieser Seite wird beschrieben, wie Sie die LiteRT-Bibliothek CMake-Tool.

Die folgende Anleitung wurde auf Ubuntu 16.04.3 64-Bit-PC (AMD64) getestet , macOS Catalina (x86_64), Windows 10 und TensorFlow Entwickler-Docker-Image tensorflow/tensorflow:devel.

Schritt 1: CMake-Tool installieren

Dafür ist CMake 3.16 oder höher erforderlich. Unter Ubuntu können Sie einfach folgenden Befehl ausführen: .

sudo apt-get install cmake

Oder folgen Sie offizielle Installationsanleitung für cmake

Schritt 2: TensorFlow-Repository klonen

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

Schritt 3: CMake-Build-Verzeichnis erstellen

mkdir tflite_build
cd tflite_build

Schritt 4: CMake-Tool mit Konfigurationen ausführen

Release-Build

Standardmäßig wird eine optimierte Release-Binärdatei generiert. Wenn Sie für Ihre auf Ihrer Workstation ist, führen Sie einfach den folgenden Befehl aus.

cmake ../tensorflow_src/tensorflow/lite

Fehler im Build beheben

Wenn Sie einen Debug-Build mit Symbolinformationen erstellen müssen, geben Sie die Option -DCMAKE_BUILD_TYPE=Debug an.

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

Mit Kernel-Unittests erstellen

Um Kernel-Tests ausführen zu können, müssen Sie die Flag -DTFLITE_KERNEL_TEST=on. Details zur Cross-Kompilierung von Einheitentests finden Sie im nächsten Unterabschnitt.

cmake ../tensorflow_src/tensorflow/lite -DTFLITE_KERNEL_TEST=on

Installierbares Paket erstellen

Um ein installierbares Paket zu erstellen, das als Abhängigkeit von einer anderen Person verwendet werden kann CMake-Projekt mit find_package(tensorflow-lite CONFIG), verwenden Sie die Option -DTFLITE_ENABLE_INSTALL=ON.

Idealerweise sollten Sie auch eigene Versionen von Bibliotheksabhängigkeiten bereitstellen. Diese müssen auch von dem LiteRT-basierten Projekt verwendet werden. Sie können -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON verwenden und <PackageName>_DIR festlegen Variablen, die auf Ihre Bibliotheksinstallationen verweisen.

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

Cross-Kompilierung

Mit CMake können Sie Binärdateien für ARM64- oder Android-Zielarchitekturen erstellen.

Für die Cross-Kompilierung von LiteRT müssen Sie insbesondere den Pfad zu das SDK (z.B. ARM64 SDK oder NDK bei Android) durch -DCMAKE_TOOLCHAIN_FILE melden.

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

Besonderheiten der Cross-Kompilierung unter Android

Für die Android-Cross-Kompilierung müssen Sie Android NDK und geben Sie den NDK-Pfad mit -DCMAKE_TOOLCHAIN_FILE. Du musst auch das Ziel-ABI festlegen mit dem Flag -DANDROID_ABI.

cmake -DCMAKE_TOOLCHAIN_FILE=<NDK path>/build/cmake/android.toolchain.cmake \
  -DANDROID_ABI=arm64-v8a ../tensorflow_src/tensorflow/lite

Besonderheiten der Kreuzkompilierung von Kernel- (Einheitentests)

Für die Kreuzkompilierung der Einheitentests ist ein Flatc-Compiler für den Host erforderlich Architektur. Zu diesem Zweck gibt es CMakeLists tensorflow/lite/tools/cmake/native_tools/flatbuffers, um das Flatc zu erstellen Compiler mit CMake in einem separaten Build-Verzeichnis unter Verwendung des Hosts Toolchain.

mkdir flatc-native-build && cd flatc-native-build
cmake ../tensorflow_src/tensorflow/lite/tools/cmake/native_tools/flatbuffers
cmake --build .

Es ist auch möglich, das Flatc an einem benutzerdefinierten Speicherort zu installieren. (z.B. in ein Verzeichnis mit anderen nativ erstellten Tools anstelle des CMake- Build-Verzeichnis erstellen):

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

Für die LiteRT-Cross-Kompilierung selbst wird ein zusätzlicher Parameter -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path> verweist auf das Verzeichnis, das muss das native Binärprogramm Flatc zusammen mit dem Parameter -DTFLITE_KERNEL_TEST=on.

cmake -DCMAKE_TOOLCHAIN_FILE=${OE_CMAKE_TOOLCHAIN_FILE} -DTFLITE_KERNEL_TEST=on -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path> ../tensorflow/lite/

Start kompilierter Kerneltests (Einheiten) am Ziel

Einheitentests können als separate ausführbare Dateien oder mit dem Dienstprogramm CTest ausgeführt werden. Bis jetzt wenn mindestens einer der Parameter TFLITE_ENABLE_XNNPACKorTFLITE_EXTERNAL_DELEGATE ist für LiteRT aktiviert werden die resultierenden Tests mit zwei verschiedenen Labels generiert. (unter Verwendung derselben ausführbaren Testdatei): einfach – zur Angabe der Testläufe, die ausgeführt werden CPU-Back-End – delegieren – gibt die Tests an, die einen zusätzlichen Start erwarten Argumente für die verwendete Delegatspezifikation

Sowohl CTestTestfile.cmake als auch run-tests.cmake (siehe unten) sind verfügbar in <build_dir>/kernels.

Start von Einheitentests mit dem CPU-Back-End (vorausgesetzt, der CTestTestfile.cmake ist auf Ziel im aktuellen Verzeichnis vorhanden):

ctest -L plain

Starten Sie Beispiele für Einheitentests mit Bevollmächtigten (vorausgesetzt, die Datei „CTestTestfile.cmake“ und „run-tests.cmake“ sind im Ziel vorhanden in aktuellem Verzeichnis):

cmake -E env TESTS_ARGUMENTS=--use_xnnpack=true ctest -L delegate
cmake -E env TESTS_ARGUMENTS=--external_delegate_path=<PATH> ctest -L delegate

Eine bekannte Einschränkung dieser Art der Bereitstellung zusätzlicher delegatbezogener die Einführung von Argumenten für Einheitentests ist, dass sie effektiv nur diejenigen mit erwarteter Rückgabewert von 0. Unterschiedliche Rückgabewerte werden als Testfehler.

OpenCL-GPU-Delegierung

Wenn Ihre Zielmaschine OpenCL unterstützt, können Sie Folgendes verwenden: GPU Delegate, Ihre GPU-Leistung zu nutzen.

So konfigurieren Sie die Unterstützung von OpenCL-GPU-Delegate:

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

Schritt 5: LiteRT erstellen

Im Verzeichnis tflite_build

cmake --build . -j

Schritt 6: Beispiel für Build LiteRT Benchmark-Tool und Labelbild (optional)

Im Verzeichnis tflite_build

cmake --build . -j -t benchmark_model

cmake --build . -j -t label_image

Verfügbare Optionen zum Erstellen von LiteRT

Im Folgenden finden Sie eine Liste der verfügbaren Optionen. Sie können sie überschreiben mit -D<option_name>=[ON|OFF] Beispiel: -DTFLITE_ENABLE_XNNPACK=OFF für deaktiviert XNNPACK, das standardmäßig aktiviert ist.

CMake-Projekt mit LiteRT erstellen

Hier ist die CMakeLists.txt-Datei Minimal-Beispiel von TFLite.

Sie benötigen add_subdirectory() für das LiteRT-Verzeichnis und den Link. tensorflow-lite mit 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)

LiteRT C-Bibliothek erstellen

Wenn Sie eine gemeinsam genutzte LiteRT-Bibliothek C API führen Sie Schritt 1 aus, um Schritt 3 zuerst. Führen Sie anschließend den folgenden Befehle.

cmake ../tensorflow_src/tensorflow/lite/c
cmake --build . -j

Dieser Befehl generiert die folgende freigegebene Bibliothek im aktuellen Verzeichnis.