Zbuduj TensorFlow Lite za pomocą CMake

Ta strona opisuje, jak zbudować i używać biblioteki TensorFlow Lite za pomocą narzędzia CMake .

Poniższe instrukcje zostały przetestowane na 64-bitowym komputerze z systemem Ubuntu 16.04.3 (AMD64) , macOS Catalina (x86_64), Windows 10 i TensorFlow devel Docker image tensorflow/tensorflow:devel .

Krok 1. Zainstaluj narzędzie CMake

Wymaga CMake 3.16 lub nowszego. W Ubuntu możesz po prostu uruchomić następujące polecenie.

sudo apt-get install cmake

Lub możesz postępować zgodnie z oficjalnym przewodnikiem instalacji cmake

Krok 2. Sklonuj repozytorium TensorFlow

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

Krok 3. Utwórz katalog kompilacji CMake

mkdir tflite_build
cd tflite_build

Krok 4. Uruchom narzędzie CMake z konfiguracjami

Wersja kompilacji

Domyślnie generuje zoptymalizowany plik binarny wydania. Jeśli chcesz zbudować dla swojej stacji roboczej, po prostu uruchom następujące polecenie.

cmake ../tensorflow_src/tensorflow/lite

Debuguj kompilację

Jeśli chcesz utworzyć kompilację debugowania, która zawiera informacje o symbolu, musisz podać opcję -DCMAKE_BUILD_TYPE=Debug .

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

Buduj z testami jednostkowymi jądra

Aby móc uruchamiać testy jądra, musisz podać flagę '-DTFLITE_KERNEL_TEST=on'. Szczegóły dotyczące kompilacji krzyżowej testów jednostkowych można znaleźć w następnym podrozdziale.

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

Zbuduj pakiet instalacyjny

Aby zbudować pakiet instalowalny, który może być używany jako zależność przez inny projekt CMake z find_package(tensorflow-lite CONFIG) , użyj opcji -DTFLITE_ENABLE_INSTALL=ON .

Najlepiej byłoby również dostarczyć własne wersje zależności bibliotecznych. Będą one również musiały być używane przez projekt, który zależy od TF Lite. Można użyć opcji -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON i ustawić zmienne <PackageName>_DIR , aby wskazywały instalacje bibliotek.

cmake ../tensorflow_src/tensorflow/lite -DTFLITE_ENABLE_INSTALL=ON \
  -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON \
  -Dabsl_DIR=<install path>/lib/cmake/absl \
  -DEigen3_DIR=<install path>/share/eigen3/cmake \
  -DFlatbuffers_DIR=<install path>/lib/cmake/flatbuffers \
  -DNEON_2_SSE_DIR=<install path>/lib/cmake/NEON_2_SSE \
  -Dcpuinfo_DIR=<install path>/share/cpuinfo \
  -Druy_DIR=<install path>/lib/cmake/ruy

Kompilacja krzyżowa

Możesz użyć CMake do kompilowania plików binarnych dla architektur docelowych ARM64 lub Android.

W celu skompilowania TF Lite musisz podać ścieżkę do SDK (np. ARM64 SDK lub NDK w przypadku Androida) z flagą -DCMAKE_TOOLCHAIN_FILE .

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

Specyfika kompilacji krzyżowej Androida

W przypadku kompilacji krzyżowej Androida należy zainstalować Android NDK i podać ścieżkę NDK ze wspomnianą powyżej flagą -DCMAKE_TOOLCHAIN_FILE . Musisz również ustawić docelowy ABI z flagą -DANDROID_ABI .

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

Specyfika kompilacji krzyżowej testów jądra (jednostkowych)

Krzyżowa kompilacja testów jednostkowych wymaga kompilatora flatc dla architektury hosta. W tym celu w tensorflow/lite/tools/cmake/native_tools/flatbuffers się CMakeLists, które umożliwiają wcześniejsze zbudowanie kompilatora flatc za pomocą CMake w osobnym katalogu kompilacji przy użyciu łańcucha narzędzi hosta.

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

Możliwe jest również zainstalowanie flatc w niestandardowej lokalizacji instalacji (np. w katalogu zawierającym inne natywne narzędzia zamiast katalogu kompilacji CMake):

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

W przypadku samej kompilacji krzyżowej TF Lite należy podać dodatkowy parametr -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path> wskazujący na katalog zawierający natywny plik binarny flatc wraz z wspomnianą powyżej flagą -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/

Testy jądra (jednostek) skompilowanych krzyżowo uruchamiają się w systemie docelowym

Testy jednostkowe można uruchamiać jako oddzielne pliki wykonywalne lub za pomocą narzędzia CTest. Jeśli chodzi o CTest, jeśli przynajmniej jeden z parametrów TFLITE_ENABLE_NNAPI, TFLITE_ENABLE_XNNPACK lub TFLITE_EXTERNAL_DELEGATE jest włączony dla kompilacji TF Lite, wynikowe testy są generowane z dwoma różnymi etykietami (używając tego samego pliku wykonywalnego testu): - zwykły - oznaczający testy te uruchamiane na backendzie procesora - delegat - oznacza testy oczekujące na dodatkowe argumenty uruchomienia używane dla użytej specyfikacji delegata

Zarówno CTestTestfile.cmake , jak i run-tests.cmake (zgodnie z opisem poniżej) są dostępne w <build_dir>/kernels .

Uruchomienie testów jednostkowych z backendem procesora (pod warunkiem, że CTestTestfile.cmake jest obecny na target w bieżącym katalogu):

ctest -L plain

Uruchom przykłady testów jednostkowych przy użyciu delegatów (pod warunkiem, że CTestTestfile.cmake oraz run-tests.cmake są obecne w systemie docelowym w bieżącym katalogu):

cmake -E env TESTS_ARGUMENTS=--use_nnapi=true\;--nnapi_accelerator_name=vsi-npu ctest -L delegate
cmake -E env TESTS_ARGUMENTS=--use_xnnpack=true ctest -L delegate
cmake -E env TESTS_ARGUMENTS=--external_delegate_path=<PATH> ctest -L delegate

Znanym ograniczeniem tego sposobu dostarczania dodatkowych argumentów uruchamiania związanych z delegatem do testów jednostkowych jest to, że skutecznie obsługuje on tylko te, które mają oczekiwaną wartość zwracaną wynoszącą 0 . Różne zwracane wartości zostaną zgłoszone jako niepowodzenie testu.

Delegat GPU OpenCL

Jeśli Twoja maszyna docelowa obsługuje OpenCL, możesz użyć delegata GPU , który może wykorzystać moc GPU.

Aby skonfigurować obsługę delegata GPU OpenCL:

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

Krok 5. Zbuduj TensorFlow Lite

W katalogu tflite_build,

cmake --build . -j

Krok 6. Zbuduj narzędzie testowe TensorFlow Lite i przykład obrazu etykiety (opcjonalnie)

W katalogu tflite_build,

cmake --build . -j -t benchmark_model

cmake --build . -j -t label_image

Dostępne opcje budowania TensorFlow Lite

Oto lista dostępnych opcji. Możesz to zmienić za pomocą -D<option_name>=[ON|OFF] . Na przykład -DTFLITE_ENABLE_XNNPACK=OFF , aby wyłączyć XNNPACK, który jest domyślnie włączony.

Utwórz projekt CMake, który korzysta z TensorFlow Lite

Oto minimalny przykład CMakeLists.txt z TFLite .

Musisz mieć add_subdirectory() dla katalogu TensorFlow Lite i połączyć tensorflow-lite z 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)

Zbuduj bibliotekę TensorFlow Lite C

Jeśli chcesz zbudować współdzieloną bibliotekę TensorFlow Lite dla C API , wykonaj najpierw kroki od 1 do 3 . Następnie uruchom następujące polecenia.

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

To polecenie generuje następującą bibliotekę współdzieloną w bieżącym katalogu.