Weitere Informationen zu den Ankündigungen der Google AI Edge auf der Google I/O

Diese Seite wurde von der Cloud Translation API übersetzt.

TensorFlow Lite mit CMake erstellen

Auf dieser Seite wird beschrieben, wie Sie die TensorFlow Lite-Bibliothek mit dem CMake-Tool erstellen und verwenden.

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

Schritt 1. CMake-Tool installieren

Es erfordert CMake 3.16 oder höher. Unter Ubuntu können Sie einfach den folgenden Befehl ausführen.

sudo apt-get install cmake

Oder folgen Sie der offiziellen 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

Sie generiert standardmäßig eine optimierte Release-Binärdatei. Wenn Sie einen Build für Ihre Workstation ausführen möchten, führen Sie einfach den folgenden Befehl aus.

cmake ../tensorflow_src/tensorflow/lite

Build-Fehler beheben

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

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

Mit Kernel-Einheitentests erstellen

Zum Ausführen von Kernel-Tests müssen Sie das Flag -DTFLITE_KERNEL_TEST=on angeben. Einzelheiten zu Unittests für die Cross-Compilation finden Sie im nächsten Unterabschnitt.

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

Installierbares Paket erstellen

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

Idealerweise sollten Sie auch Ihre eigenen Versionen von Bibliotheksabhängigkeiten bereitstellen. Diese müssen auch von dem Projekt verwendet werden, das von TF Lite abhängig ist. Sie können die -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON verwenden und die <PackageName>_DIR-Variablen so festlegen, dass sie 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 TF Lite müssen Sie den Pfad zum SDK (z.B. ARM64 SDK oder NDK im Fall von Android) mit dem Flag -DCMAKE_TOOLCHAIN_FILE angeben.

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

Details der Android-Cross-Compilation

Für die Android-Cross-Kompilierung müssen Sie Android NDK installieren und den NDK-Pfad mit dem oben genannten Flag -DCMAKE_TOOLCHAIN_FILE angeben. Außerdem müssen Sie das Ziel-ABI mit dem Flag -DANDROID_ABI festlegen.

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

Spezifikationen der Kreuzkompilierung von Kernel- (Unit-)Tests

Für die Kreuzkompilierung der Einheitentests ist der Flatc-Compiler für die Hostarchitektur erforderlich. Zu diesem Zweck gibt es eine CMakeLists in tensorflow/lite/tools/cmake/native_tools/flatbuffers, um den Flatc-Compiler mithilfe der Host-Toolchain im Voraus in einem separaten Build-Verzeichnis zu erstellen.

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, den flatc an einem benutzerdefinierten Speicherort zu installieren, z.B. in einem Verzeichnis, das andere native Tools enthält, anstatt das Build-Verzeichnis von CMake:

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

Für die TF Lite-Cross-Kompilierung selbst muss der zusätzliche Parameter -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path>, der auf das Verzeichnis verweist, das die native flatc-Binärdatei enthält, zusammen mit dem oben genannten Flag -DTFLITE_KERNEL_TEST=on angegeben werden.

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

Start von kompilierten Kernel- (Unit-)Tests am Ziel

Einheitentests können als separate ausführbare Datei oder mit dem CTest-Dienstprogramm ausgeführt werden. Wenn für CTest mindestens einer der Parameter TFLITE_ENABLE_XNNPACKorTFLITE_EXTERNAL_DELEGATE für den TF Lite-Build aktiviert ist, werden die resultierenden Tests mit zwei verschiedenen Labels generiert (unter Verwendung derselben ausführbaren Testdatei): plain – gibt an, dass die verwendeten Tests für das Back-End ausgeführt werden – und delegieren Sie das Argument zum Delegieren der verwendeten CPU – Delegieren Sie das Argument zum Delegieren.

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

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

ctest -L plain

Starten Sie Beispiele für Einheitentests mit Bevollmächtigten, sofern die Dateien CTestTestfile.cmake und run-tests.cmake im aktuellen Verzeichnis auf dem Ziel vorhanden sind:

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 delegierter Startargumente für Einheitentests besteht darin, dass sie nur diejenigen mit einem erwarteten Rückgabewert von 0 unterstützt. Unterschiedliche Rückgabewerte werden als Testfehler gemeldet.

OpenCL-GPU-Delegate

Wenn Ihre Zielmaschine OpenCL-Unterstützung bietet, können Sie den GPU-Delegaten verwenden, der Ihre GPU-Leistung nutzen kann.

So konfigurieren Sie die Unterstützung des OpenCL GPU-Delegaten:

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

Schritt 5: TensorFlow Lite erstellen

Führen Sie im Verzeichnis tflite_build die folgenden Schritte aus:

cmake --build . -j

Schritt 6: Build TensorFlow Lite Benchmark Tool und Label-Image – Beispiel (optional)

Führen Sie im Verzeichnis tflite_build die folgenden Schritte aus:

cmake --build . -j -t benchmark_model

cmake --build . -j -t label_image

Verfügbare Optionen zum Erstellen von TensorFlow Lite

Hier ist die Liste der verfügbaren Optionen. Sie können sie mit -D<option_name>=[ON|OFF] überschreiben. Beispiel: -DTFLITE_ENABLE_XNNPACK=OFF, um XNNPACK zu deaktivieren, das standardmäßig aktiviert ist.

Option	Feature	Android	Linux	macOS	Windows
`TFLITE_ENABLE_RUY`	RUY-Matrixmultiplikationsbibliothek aktivieren	AN	AUS	AUS	AUS
`TFLITE_ENABLE_GPU`	GPU-Delegierung aktivieren	AUS	AUS	–	–
`TFLITE_ENABLE_XNNPACK`	Aktivieren Sie den XNNPACK-Bevollmächtigten.	AN	AN	AN	AN
`TFLITE_ENABLE_MMAP`	MMAP aktivieren	AN	AN	AN	–

CMake-Projekt erstellen, das TensorFlow Lite verwendet

Hier ist die Datei CMakeLists.txt des Beispiels für TFLite-Minimal.

Sie benötigen add_subdirectory() für das TensorFlow Lite-Verzeichnis und tensorflow-lite müssen mit target_link_Libraries() verknüpft werden.

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)

TensorFlow Lite C-Bibliothek erstellen

Wenn Sie eine freigegebene TensorFlow Lite-Bibliothek für die C API erstellen möchten, führen Sie zuerst Schritt 1 bis Schritt 3 aus. Führen Sie anschließend die folgenden Befehle aus.

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

Dieser Befehl generiert die folgende gemeinsam genutzte Bibliothek im aktuellen Verzeichnis.

Plattform	Name der Bibliothek
Linux	`libtensorflowlite_c.so`
macOS	`libtensorflowlite_c.dylib`
Windows	`tensorflowlite_c.dll`