Tworzenie LiteRT przy użyciu CMake

Na tej stronie dowiesz się, jak utworzyć bibliotekę LiteRT i jak z niej korzystać CMake.

Poniższe instrukcje zostały przetestowane w systemie Ubuntu 16.04.3 64-bitowego komputera (AMD64) , macOS Catalina (x86_64), Windows 10 i obraz Dockera w TensorFlow tensorflow/tensorflow:devel.

Krok 1. Zainstaluj narzędzie CMake

Wymaga aplikacji CMake w wersji 3.16 lub nowszej. W Ubuntu możesz po prostu uruchomić następujące polecenia .

sudo apt-get install cmake

Możesz też obserwować oficjalny przewodnik instalacji Cmake

Krok 2. Klonowanie 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. Uruchamianie narzędzia CMake z konfiguracjami

Kompilacja wersji

Domyślnie generuje plik binarny wersji zoptymalizowanej. Jeśli chcesz tworzyć produkty w swojej stacji roboczej, wystarczy uruchomić poniższe polecenie.

cmake ../tensorflow_src/tensorflow/lite

Debuguj kompilację

Jeśli chcesz utworzyć kompilację do debugowania, która zawiera informacje o symbolach, musisz wykonać te czynności: podaj opcję -DCMAKE_BUILD_TYPE=Debug.

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

Tworzenie z użyciem testów jednostkowych jądra

Aby móc przeprowadzać testy jądra, musisz udostępnić flaga -DTFLITE_KERNEL_TEST=on. Szczegóły kompilacji testu jednostkowego mogą być które znajdziesz w następnej podsekcji.

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

Utwórz pakiet do zainstalowania

Aby utworzyć pakiet możliwy do zainstalowania, którego może używać inna zależność Utwórz projekt za pomocą dodatku find_package(tensorflow-lite CONFIG), użyj -DTFLITE_ENABLE_INSTALL=ON.

Najlepiej jest też podać własne wersje zależności bibliotek. Będą one też używane w projekcie zależnym od LiteRT. Dostępne opcje użyj komponentu -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON i ustaw <PackageName>_DIR do wskazywanych instalacji 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 danych

Za pomocą CMake możesz tworzyć pliki binarne dla docelowych architektur ARM64 lub Androida.

Aby krzyżowo skompilować LiteRT, musisz podać ścieżkę do pakiet SDK (np. ARM64 SDK lub NDK w przypadku Androida) za pomocą -DCMAKE_TOOLCHAIN_FILE flaga.

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

Szczegółowa kompilacja krzyżowa Androida

W przypadku kompilacji na urządzeniach z Androidem musisz zainstalować Android NDK i podaj ścieżkę NDK z Flaga -DCMAKE_TOOLCHAIN_FILE wspomniana powyżej. Musisz też ustawić docelowy interfejs ABI z flagą -DANDROID_ABI.

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

Specyfikacje kompilacji krzyżowej jądra systemu (jednostkowego)

Krzyżowa kompilacja testów jednostkowych wymaga kompilatora płaskiego dla hosta i architekturą. W tym celu znajduje się lista CMakeList tensorflow/lite/tools/cmake/native_tools/flatbuffers, aby zbudować płaski kompilatora z CMake w oddzielnym katalogu kompilacji przy użyciu hosta z łańcuchem narzędzi.

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

Możesz też zainstalować flatc w niestandardowej lokalizacji. (np. do katalogu zawierającego inne natywne narzędzia zamiast katalogu CMake katalogu kompilacji):

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

W przypadku samej kompilacji krzyżowej LiteRT dodatkowy parametr -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path> wskazuje katalog zawierający natywny flatc trzeba dodać razem z -DTFLITE_KERNEL_TEST=on flaga wymieniona powyżej.

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

Krzyżowoskompilowane testy jądra (jednostkowe) uruchamiają się w miejscu docelowym

Testy jednostkowe można uruchamiać jako osobne pliki wykonywalne lub za pomocą narzędzia CTest. Do tej pory jak dane CTest, jeśli co najmniej jeden z parametrów Opcja TFLITE_ENABLE_XNNPACKorTFLITE_EXTERNAL_DELEGATE jest włączona dla LiteRT kompilację, wynikowe testy będą generowane z 2 różnymi etykietami. (z wykorzystaniem tego samego pliku wykonywalnego testu): – zwykły – oznacza testy, na których są uruchamiane Backend procesora – przekazanie – oznaczanie testów oczekujących na dodatkowe uruchomienie argumenty używane w specyfikacji delegowanej

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

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

ctest -L plain

uruchamiać przykładowe testy jednostkowe z wykorzystaniem przedstawicieli (pod warunkiem, że W lokalizacji docelowej znajdują się pliki CTestTestfile.cmake oraz run-tests.cmake w bieżącym katalogu):

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

Znane ograniczenie tego sposobu dostarczania dodatkowych informacji argumentami do uruchomienia testów jednostkowych jest to, że skutecznie obsługuje tylko te oczekiwana wartość zwrotu wynosi 0. Różne wartości zwracanych wartości będą raportowane jako niepowodzenie testu.

Delegat GPU OpenCL

Jeśli komputer docelowy obsługuje OpenCL, możesz użyć parametru delegat GPU, który może wykorzystują moc GPU.

Aby skonfigurować obsługę przekazywania dostępu do GPU OpenCL:

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

Krok 5. Utwórz LiteRT

W katalogu tflite_build

cmake --build . -j

Krok 6. Utwórz narzędzie analizy porównawczej LiteRT 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 tworzenia LiteRT

Oto lista dostępnych opcji. Możesz go zastąpić kodem -D<option_name>=[ON|OFF] Na przykład od -DTFLITE_ENABLE_XNNPACK=OFF do wyłącz usługę XNNPACK, która jest domyślnie włączona.

Tworzenie projektu CMake korzystającego z LiteRT

Plik CMakeLists.txt zawiera Przykład z TFLite minimum.

Musisz mieć funkcję add_subdirectory() dla katalogu i linku LiteRT 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)

Utwórz bibliotekę LiteRT C

Jeśli chcesz utworzyć bibliotekę udostępnioną LiteRT dla C API wykonaj krok 1, aby krok 3. Następnie uruchom tych poleceń.

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

To polecenie wygeneruje następujące zasoby udostępniane w bieżącym katalogu.