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_XNNPACKor
TFLITE_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 |