Zbuduj TensorFlow Lite za pomocą CMake

Na tej stronie opisano, jak zbudować i używać biblioteki TensorFlow Lite za pomocą narzędzia CMake .

Poniższe instrukcje zostały przetestowane na 64-bitowym komputerze 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 systemie Ubuntu możesz po prostu uruchomić następujące polecenie.

sudo apt-get install cmake

Możesz też 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

Wydaj kompilację

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

cmake ../tensorflow_src/tensorflow/lite

Debuguj kompilację

Jeśli chcesz utworzyć kompilację debugowania zawierającą informacje o symbolach, musisz podać opcję -DCMAKE_BUILD_TYPE=Debug .

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

Kompiluj za pomocą testów jednostkowych 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 instalacyjny, 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 .

W idealnym przypadku powinieneś także udostępnić własne wersje zależności bibliotek. Będą one również musiały zostać wykorzystane w projekcie zależnym od TF Lite. Możesz użyć opcji -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON i ustawić zmienne <PackageName>_DIR tak, aby wskazywały instalacje biblioteki.

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

Kompilacja krzyżowa

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

Aby dokonać kompilacji krzyżowej 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 systemu Android należy zainstalować system Android NDK i podać ścieżkę NDK ze wspomnianą powyżej flagą -DCMAKE_TOOLCHAIN_FILE . Musisz także 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 testów jądra (jednostkowych) – kompilacja krzyżowa

Kompilacja krzyżowa testów jednostkowych wymaga kompilatora flatc dla architektury hosta. W tym celu istnieje CMakeLists zlokalizowana w tensorflow/lite/tools/cmake/native_tools/flatbuffers aby zbudować kompilator flatc z CMake z wyprzedzeniem w oddzielnym 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 natywnie zbudowane 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 flagą -DTFLITE_KERNEL_TEST=on wspomnianą powyżej.

cmake -DCMAKE_TOOLCHAIN_FILE=${OE_CMAKE_TOOLCHAIN_FILE} -DTFLITE_KERNEL_TEST=on -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path> ../tensorflow/lite/
Kompilowane krzyżowo testy jądra (jednostkowe) uruchamiają się w miejscu docelowym

Testy jednostkowe można uruchamiać jako osobne pliki wykonywalne lub przy użyciu narzędzia CTest. W przypadku CTest, jeśli dla kompilacji TF Lite jest włączony przynajmniej jeden z parametrów TFLITE_ENABLE_NNAPI, TFLITE_ENABLE_XNNPACK lub TFLITE_EXTERNAL_DELEGATE , wynikowe testy są generowane z dwiema różnymi etykietami (wykorzystującymi ten sam plik wykonywalny testu): - zwykły - oznaczający testy te działają na zapleczu procesora - delegat - oznaczając testy oczekujące dodatkowych argumentów uruchomienia używanych dla używanej specyfikacji delegata

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

Uruchomienie testów jednostkowych z backendem procesora (pod warunkiem, że plik CTestTestfile.cmake znajduje się w miejscu docelowym w bieżącym katalogu):

ctest -L plain

Uruchom przykłady testów jednostkowych przy użyciu delegatów (pod warunkiem, że pliki CTestTestfile.cmake oraz run-tests.cmake znajdują się w miejscu 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 delegatami do testów jednostkowych jest to, że skutecznie obsługuje tylko te, których oczekiwana wartość zwracana wynosi 0 . Różne zwracane wartości zostaną zgłoszone jako niepowodzenie testu.

Delegat procesora graficznego OpenCL

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

Aby skonfigurować obsługę delegowania procesora graficznego 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 porównawcze TensorFlow Lite i przykładowy obraz 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 zastąpić 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.

Nazwa opcji Funkcja Android Linuksa System operacyjny Mac Okna
TFLITE_ENABLE_RUY Włącz bibliotekę mnożenia macierzy RUY NA WYŁĄCZONY WYŁĄCZONY WYŁĄCZONY
TFLITE_ENABLE_NNAPI Włącz delegata NNAPI NA WYŁĄCZONY Nie dotyczy Nie dotyczy
TFLITE_ENABLE_GPU Włącz delegowanie GPU WYŁĄCZONY WYŁĄCZONY Nie dotyczy Nie dotyczy
TFLITE_ENABLE_XNNPACK Włącz delegata XNNPACK NA NA NA NA
TFLITE_ENABLE_MMAP Włącz MMAP NA NA NA Nie dotyczy

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

Oto minimalny przykład pliku CMakeLists.txt 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ć bibliotekę współdzieloną TensorFlow Lite dla interfejsu API języka C , 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.

Platforma Nazwa biblioteki
Linuksa libtensorflowlite_c.so
System operacyjny Mac libtensorflowlite_c.dylib
Okna tensorflowlite_c.dll