Kjo faqe përshkruan se si të ndërtoni dhe përdorni bibliotekën LiteRT me mjetin CMake .
Udhëzimet e mëposhtme janë testuar në Ubuntu 16.04.3 64-bit PC (AMD64), macOS Catalina (x86_64), Windows 10 dhe TensorFlow Devel Docker image tensorflow/tensorflow:devel .
Hapi 1. Instaloni mjetin CMake
Kërkon CMake 3.16 ose më të lartë. Në Ubuntu, thjesht mund të ekzekutoni komandën e mëposhtme.
sudo apt-get install cmake
Ose mund të ndiqni udhëzuesin zyrtar të instalimit cmake
Hapi 2. Klononi depon e TensorFlow
git clone https://github.com/tensorflow/tensorflow.git tensorflow_src
Hapi 3. Krijo drejtorinë e ndërtimit të CMake
mkdir tflite_build
cd tflite_build
Hapi 4. Ekzekutoni mjetin CMake me konfigurime
Lëshoni ndërtimin
Ai gjeneron një binar të optimizuar të lëshimit si parazgjedhje. Nëse dëshironi të ndërtoni për stacionin tuaj të punës, thjesht ekzekutoni komandën e mëposhtme.
cmake ../tensorflow_src/tensorflow/lite
Ndërtimi i korrigjimit
Nëse keni nevojë të krijoni një ndërtim korrigjimi që ka informacion simboli, ju duhet të siguroni opsionin -DCMAKE_BUILD_TYPE=Debug .
cmake ../tensorflow_src/tensorflow/lite -DCMAKE_BUILD_TYPE=Debug
Ndërtoni me teste të njësisë së kernelit
Për të qenë në gjendje të ekzekutoni testet e kernelit, duhet të jepni flamurin -DTFLITE_KERNEL_TEST=on . Specifikat e përpilimit të kryqëzuar të testit të njësisë mund të gjenden në nënseksionin tjetër.
cmake ../tensorflow_src/tensorflow/lite -DTFLITE_KERNEL_TEST=on
Ndërtoni paketën e instalueshme
Për të ndërtuar një paketë të instalueshme që mund të përdoret si një varësi nga një projekt tjetër CMake me find_package(tensorflow-lite CONFIG) , përdorni opsionin -DTFLITE_ENABLE_INSTALL=ON .
Në mënyrë ideale, duhet të ofroni edhe versionet tuaja të varësive të bibliotekës. Këto do të duhet gjithashtu të përdoren nga projekti që varet nga LiteRT. Mund të përdorni -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON dhe të vendosni variablat <PackageName>_DIR që të tregojnë instalimet e bibliotekës suaj.
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
Ndër-përmbledhje
Ju mund të përdorni CMake për të ndërtuar binare për arkitekturat e synuara ARM64 ose Android.
Për të ndërthurur LiteRT-në, duhet të siguroni shtegun për në SDK (p.sh. ARM64 SDK ose NDK në rastin e Android) me flamurin -DCMAKE_TOOLCHAIN_FILE .
cmake -DCMAKE_TOOLCHAIN_FILE=<CMakeToolchainFileLoc> ../tensorflow/lite/
Specifikat e ndërthurjes së Android
Për ndërthurjen e Android, duhet të instaloni Android NDK dhe të siguroni shtegun NDK me -DCMAKE_TOOLCHAIN_FILE flamurin e përmendur më sipër. Ju gjithashtu duhet të vendosni ABI-në e synuar me flamurin -DANDROID_ABI .
cmake -DCMAKE_TOOLCHAIN_FILE=<NDK path>/build/cmake/android.toolchain.cmake \
-DANDROID_ABI=arm64-v8a ../tensorflow_src/tensorflow/lite
Specifikat e testeve të kernelit (njësive) të ndërthurjes
Kompilimi i kryqëzuar i testeve të njësisë kërkon përpilues flatc për arkitekturën e hostit. Për këtë qëllim, ekziston një CMakeLists e vendosur në tensorflow/lite/tools/cmake/native_tools/flatbuffers për të ndërtuar paraprakisht përpiluesin flatc me CMake në një direktori të veçantë ndërtimi duke përdorur zinxhirin e veglave pritës.
mkdir flatc-native-build && cd flatc-native-build
cmake ../tensorflow_src/tensorflow/lite/tools/cmake/native_tools/flatbuffers
cmake --build .
Është gjithashtu e mundur të instaloni flatc në një vendndodhje instalimi të personalizuar (p.sh. në një drejtori që përmban mjete të tjera të ndërtuara në mënyrë origjinale në vend të drejtorisë së ndërtimit CMake):
cmake -DCMAKE_INSTALL_PREFIX=<native_tools_dir> ../tensorflow_src/tensorflow/lite/tools/cmake/native_tools/flatbuffers
cmake --build .
Për vetë përpilimin e ndërthurur të LiteRT, duhet të sigurohet parametri shtesë -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path> që tregon direktoriumin që përmban binarin vendas flatc së bashku me -DTFLITE_KERNEL_TEST=on flamurin e përmendur më sipër.
cmake -DCMAKE_TOOLCHAIN_FILE=${OE_CMAKE_TOOLCHAIN_FILE} -DTFLITE_KERNEL_TEST=on -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path> ../tensorflow/lite/
Testet e kernelit (njësive) të ndërthurura nisen në objektiv
Testet e njësisë mund të ekzekutohen si ekzekutues të veçantë ose duke përdorur programin CTest. Për sa i përket CTest-it, nëse të paktën një nga parametrat TFLITE_ENABLE_XNNPACK or TFLITE_EXTERNAL_DELEGATE është aktivizuar për ndërtimin e LiteRT, testet që rezultojnë gjenerohen me dy etiketa të ndryshme (duke përdorur të njëjtin ekzekutues provë): - i thjeshtë - që tregon testet shtesë që presin testet e CPU-së. nisni argumentet e përdorura për specifikimin e delegatit të përdorur
Të dy CTestTestfile.cmake dhe run-tests.cmake (siç përmendet më poshtë) janë të disponueshme në <build_dir>/kernels .
Nisja e testeve të njësisë me prapavijën e CPU-së (me kusht që CTestTestfile.cmake të jetë i pranishëm në objektiv në drejtorinë aktuale):
ctest -L plain
Nisni shembuj të testeve të njësive duke përdorur delegatë (me kusht që skedari CTestTestfile.cmake si dhe skedari run-tests.cmake të jenë të pranishëm në objektiv në direktorinë aktuale):
cmake -E env TESTS_ARGUMENTS=--use_xnnpack=true ctest -L delegate
cmake -E env TESTS_ARGUMENTS=--external_delegate_path=<PATH> ctest -L delegate
Një kufizim i njohur i kësaj mënyre të ofrimit të argumenteve shtesë të nisjes lidhur me delegat në testet e njësisë është se ai në mënyrë efektive mbështet vetëm ato me një vlerë të pritshme kthimi prej 0 . Vlerat e ndryshme të kthimit do të raportohen si një dështim i testit.
Delegat i OpenCL GPU
Nëse makina juaj e synuar ka mbështetje OpenCL, mund të përdorni delegatin e GPU-së i cili mund të shfrytëzojë fuqinë tuaj GPU.
Për të konfiguruar mbështetjen e delegatëve të OpenCL GPU:
cmake ../tensorflow_src/tensorflow/lite -DTFLITE_ENABLE_GPU=ON
Hapi 5. Ndërtoni LiteRT
Në drejtorinë tflite_build ,
cmake --build . -j
Hapi 6. Build LiteRT Benchmark Tool and Label Image Shembull (opsionale)
Në drejtorinë tflite_build ,
cmake --build . -j -t benchmark_model
cmake --build . -j -t label_image
Opsionet e disponueshme për të ndërtuar LiteRT
Këtu është lista e opsioneve të disponueshme. Mund ta anashkaloni me -D<option_name>=[ON|OFF] . Për shembull, -DTFLITE_ENABLE_XNNPACK=OFF për të çaktivizuar XNNPACK i cili është i aktivizuar si parazgjedhje.
| Emri i opsionit | Veçori | Android | Linux | macOS | Dritaret |
|---|---|---|---|---|---|
TFLITE_ENABLE_RUY | Aktivizo bibliotekën e shumëzimit të matricës RUY | AKTIV | FAKT | FAKT | FAKT |
TFLITE_ENABLE_GPU | Aktivizo delegatin e GPU | FAKT | FAKT | N/A | N/A |
TFLITE_ENABLE_XNNPACK | Aktivizo delegatin XNNPACK | AKTIV | AKTIV | AKTIV | AKTIV |
TFLITE_ENABLE_MMAP | Aktivizo MMAP | AKTIV | AKTIV | AKTIV | N/A |
Krijo një projekt CMake i cili përdor LiteRT
Këtu është shembulli minimal CMakeLists.txt i TFLite .
Duhet të keni add_subdirectory() për direktoriumin LiteRT dhe të lidhni tensorflow-lite me 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)
Ndërtoni bibliotekën LiteRT C
Nëse dëshironi të ndërtoni bibliotekë të përbashkët LiteRT për C API , ndiqni hapin 1 deri në hapin 3 fillimisht. Pas kësaj, ekzekutoni komandat e mëposhtme.
TENSORFLOW_VERSION=$(grep "TF_VERSION = " "../tensorflow_src/tensorflow/tf_version.bzl" | cut -d= -f2 | sed 's/[ "-]//g')
IFS='.' read -r -a array <<< "$TENSORFLOW_VERSION"
TF_MAJOR=${array[0]}
TF_MINOR=${array[1]}
TF_PATCH=${array[2]}
TF_CXX_FLAGS="-DTF_MAJOR_VERSION=${TF_MAJOR} -DTF_MINOR_VERSION=${TF_MINOR} -DTF_PATCH_VERSION=${TF_PATCH} -DTF_VERSION_SUFFIX=''"
cmake -DCMAKE_C_FLAGS="${TF_CXX_FLAGS}" -DCMAKE_CXX_FLAGS="${TF_CXX_FLAGS}" ../tensorflow_src/tensorflow/lite/c
cmake --build . -j
Kjo komandë gjeneron bibliotekën e mëposhtme të përbashkët në drejtorinë aktuale.
| Platforma | Emri i bibliotekës |
|---|---|
| Linux | libtensorflowlite_c.so |
| macOS | libtensorflowlite_c.dylib |
| Dritaret | tensorflowlite_c.dll |
Kjo faqe përshkruan se si të ndërtoni dhe përdorni bibliotekën LiteRT me mjetin CMake .
Udhëzimet e mëposhtme janë testuar në Ubuntu 16.04.3 64-bit PC (AMD64), macOS Catalina (x86_64), Windows 10 dhe TensorFlow Devel Docker image tensorflow/tensorflow:devel .
Hapi 1. Instaloni mjetin CMake
Kërkon CMake 3.16 ose më të lartë. Në Ubuntu, thjesht mund të ekzekutoni komandën e mëposhtme.
sudo apt-get install cmake
Ose mund të ndiqni udhëzuesin zyrtar të instalimit cmake
Hapi 2. Klononi depon e TensorFlow
git clone https://github.com/tensorflow/tensorflow.git tensorflow_src
Hapi 3. Krijo drejtorinë e ndërtimit të CMake
mkdir tflite_build
cd tflite_build
Hapi 4. Ekzekutoni mjetin CMake me konfigurime
Lëshoni ndërtimin
Ai gjeneron një binar të optimizuar të lëshimit si parazgjedhje. Nëse dëshironi të ndërtoni për stacionin tuaj të punës, thjesht ekzekutoni komandën e mëposhtme.
cmake ../tensorflow_src/tensorflow/lite
Ndërtimi i korrigjimit
Nëse keni nevojë të krijoni një ndërtim korrigjimi që ka informacion simboli, ju duhet të siguroni opsionin -DCMAKE_BUILD_TYPE=Debug .
cmake ../tensorflow_src/tensorflow/lite -DCMAKE_BUILD_TYPE=Debug
Ndërtoni me teste të njësisë së kernelit
Për të qenë në gjendje të ekzekutoni testet e kernelit, duhet të jepni flamurin -DTFLITE_KERNEL_TEST=on . Specifikat e përpilimit të kryqëzuar të testit të njësisë mund të gjenden në nënseksionin tjetër.
cmake ../tensorflow_src/tensorflow/lite -DTFLITE_KERNEL_TEST=on
Ndërtoni paketën e instalueshme
Për të ndërtuar një paketë të instalueshme që mund të përdoret si një varësi nga një projekt tjetër CMake me find_package(tensorflow-lite CONFIG) , përdorni opsionin -DTFLITE_ENABLE_INSTALL=ON .
Në mënyrë ideale, duhet të ofroni edhe versionet tuaja të varësive të bibliotekës. Këto do të duhet gjithashtu të përdoren nga projekti që varet nga LiteRT. Mund të përdorni -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON dhe të vendosni variablat <PackageName>_DIR që të tregojnë instalimet e bibliotekës suaj.
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
Ndër-përmbledhje
Ju mund të përdorni CMake për të ndërtuar binare për arkitekturat e synuara ARM64 ose Android.
Për të ndërthurur LiteRT-në, duhet të siguroni shtegun për në SDK (p.sh. ARM64 SDK ose NDK në rastin e Android) me flamurin -DCMAKE_TOOLCHAIN_FILE .
cmake -DCMAKE_TOOLCHAIN_FILE=<CMakeToolchainFileLoc> ../tensorflow/lite/
Specifikat e ndërthurjes së Android
Për ndërthurjen e Android, duhet të instaloni Android NDK dhe të siguroni shtegun NDK me -DCMAKE_TOOLCHAIN_FILE flamurin e përmendur më sipër. Ju gjithashtu duhet të vendosni ABI-në e synuar me flamurin -DANDROID_ABI .
cmake -DCMAKE_TOOLCHAIN_FILE=<NDK path>/build/cmake/android.toolchain.cmake \
-DANDROID_ABI=arm64-v8a ../tensorflow_src/tensorflow/lite
Specifikat e testeve të kernelit (njësive) të ndërthurjes
Kompilimi i kryqëzuar i testeve të njësisë kërkon përpilues flatc për arkitekturën e hostit. Për këtë qëllim, ekziston një CMakeLists e vendosur në tensorflow/lite/tools/cmake/native_tools/flatbuffers për të ndërtuar paraprakisht përpiluesin flatc me CMake në një direktori të veçantë ndërtimi duke përdorur zinxhirin e veglave pritës.
mkdir flatc-native-build && cd flatc-native-build
cmake ../tensorflow_src/tensorflow/lite/tools/cmake/native_tools/flatbuffers
cmake --build .
Është gjithashtu e mundur të instaloni flatc në një vendndodhje instalimi të personalizuar (p.sh. në një drejtori që përmban mjete të tjera të ndërtuara në mënyrë origjinale në vend të drejtorisë së ndërtimit CMake):
cmake -DCMAKE_INSTALL_PREFIX=<native_tools_dir> ../tensorflow_src/tensorflow/lite/tools/cmake/native_tools/flatbuffers
cmake --build .
Për vetë përpilimin e ndërthurur të LiteRT, duhet të sigurohet parametri shtesë -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path> që tregon direktoriumin që përmban binarin vendas flatc së bashku me -DTFLITE_KERNEL_TEST=on flamurin e përmendur më sipër.
cmake -DCMAKE_TOOLCHAIN_FILE=${OE_CMAKE_TOOLCHAIN_FILE} -DTFLITE_KERNEL_TEST=on -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path> ../tensorflow/lite/
Testet e kernelit (njësive) të ndërthurura nisen në objektiv
Testet e njësisë mund të ekzekutohen si ekzekutues të veçantë ose duke përdorur programin CTest. Për sa i përket CTest-it, nëse të paktën një nga parametrat TFLITE_ENABLE_XNNPACK or TFLITE_EXTERNAL_DELEGATE është aktivizuar për ndërtimin e LiteRT, testet që rezultojnë gjenerohen me dy etiketa të ndryshme (duke përdorur të njëjtin ekzekutues provë): - i thjeshtë - që tregon testet shtesë që presin testet e CPU-së. nisni argumentet e përdorura për specifikimin e delegatit të përdorur
Të dy CTestTestfile.cmake dhe run-tests.cmake (siç përmendet më poshtë) janë të disponueshme në <build_dir>/kernels .
Nisja e testeve të njësisë me prapavijën e CPU-së (me kusht që CTestTestfile.cmake të jetë i pranishëm në objektiv në drejtorinë aktuale):
ctest -L plain
Nisni shembuj të testeve të njësive duke përdorur delegatë (me kusht që skedari CTestTestfile.cmake si dhe skedari run-tests.cmake të jenë të pranishëm në objektiv në direktorinë aktuale):
cmake -E env TESTS_ARGUMENTS=--use_xnnpack=true ctest -L delegate
cmake -E env TESTS_ARGUMENTS=--external_delegate_path=<PATH> ctest -L delegate
Një kufizim i njohur i kësaj mënyre të ofrimit të argumenteve shtesë të nisjes lidhur me delegat në testet e njësisë është se ai në mënyrë efektive mbështet vetëm ato me një vlerë të pritshme kthimi prej 0 . Vlerat e ndryshme të kthimit do të raportohen si një dështim i testit.
Delegat i OpenCL GPU
Nëse makina juaj e synuar ka mbështetje OpenCL, mund të përdorni delegatin e GPU-së i cili mund të shfrytëzojë fuqinë tuaj GPU.
Për të konfiguruar mbështetjen e delegatëve të OpenCL GPU:
cmake ../tensorflow_src/tensorflow/lite -DTFLITE_ENABLE_GPU=ON
Hapi 5. Ndërtoni LiteRT
Në drejtorinë tflite_build ,
cmake --build . -j
Hapi 6. Build LiteRT Benchmark Tool and Label Image Shembull (opsionale)
Në drejtorinë tflite_build ,
cmake --build . -j -t benchmark_model
cmake --build . -j -t label_image
Opsionet e disponueshme për të ndërtuar LiteRT
Këtu është lista e opsioneve të disponueshme. Mund ta anashkaloni me -D<option_name>=[ON|OFF] . Për shembull, -DTFLITE_ENABLE_XNNPACK=OFF për të çaktivizuar XNNPACK i cili është i aktivizuar si parazgjedhje.
| Emri i opsionit | Veçori | Android | Linux | macOS | Dritaret |
|---|---|---|---|---|---|
TFLITE_ENABLE_RUY | Aktivizo bibliotekën e shumëzimit të matricës RUY | AKTIV | FAKT | FAKT | FAKT |
TFLITE_ENABLE_GPU | Aktivizo delegatin e GPU | FAKT | FAKT | N/A | N/A |
TFLITE_ENABLE_XNNPACK | Aktivizo delegatin XNNPACK | AKTIV | AKTIV | AKTIV | AKTIV |
TFLITE_ENABLE_MMAP | Aktivizo MMAP | AKTIV | AKTIV | AKTIV | N/A |
Krijo një projekt CMake i cili përdor LiteRT
Këtu është shembulli minimal CMakeLists.txt i TFLite .
Duhet të keni add_subdirectory() për direktoriumin LiteRT dhe të lidhni tensorflow-lite me 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)
Ndërtoni bibliotekën LiteRT C
Nëse dëshironi të ndërtoni bibliotekë të përbashkët LiteRT për C API , ndiqni hapin 1 deri në hapin 3 fillimisht. Pas kësaj, ekzekutoni komandat e mëposhtme.
TENSORFLOW_VERSION=$(grep "TF_VERSION = " "../tensorflow_src/tensorflow/tf_version.bzl" | cut -d= -f2 | sed 's/[ "-]//g')
IFS='.' read -r -a array <<< "$TENSORFLOW_VERSION"
TF_MAJOR=${array[0]}
TF_MINOR=${array[1]}
TF_PATCH=${array[2]}
TF_CXX_FLAGS="-DTF_MAJOR_VERSION=${TF_MAJOR} -DTF_MINOR_VERSION=${TF_MINOR} -DTF_PATCH_VERSION=${TF_PATCH} -DTF_VERSION_SUFFIX=''"
cmake -DCMAKE_C_FLAGS="${TF_CXX_FLAGS}" -DCMAKE_CXX_FLAGS="${TF_CXX_FLAGS}" ../tensorflow_src/tensorflow/lite/c
cmake --build . -j
Kjo komandë gjeneron bibliotekën e mëposhtme të përbashkët në drejtorinë aktuale.
| Platforma | Emri i bibliotekës |
|---|---|
| Linux | libtensorflowlite_c.so |
| macOS | libtensorflowlite_c.dylib |
| Dritaret | tensorflowlite_c.dll |
Kjo faqe përshkruan se si të ndërtoni dhe përdorni bibliotekën LiteRT me mjetin CMake .
Udhëzimet e mëposhtme janë testuar në Ubuntu 16.04.3 64-bit PC (AMD64), macOS Catalina (x86_64), Windows 10 dhe TensorFlow Devel Docker image tensorflow/tensorflow:devel .
Hapi 1. Instaloni mjetin CMake
Kërkon CMake 3.16 ose më të lartë. Në Ubuntu, thjesht mund të ekzekutoni komandën e mëposhtme.
sudo apt-get install cmake
Ose mund të ndiqni udhëzuesin zyrtar të instalimit cmake
Hapi 2. Klononi depon e TensorFlow
git clone https://github.com/tensorflow/tensorflow.git tensorflow_src
Hapi 3. Krijo drejtorinë e ndërtimit të CMake
mkdir tflite_build
cd tflite_build
Hapi 4. Ekzekutoni mjetin CMake me konfigurime
Lëshoni ndërtimin
Ai gjeneron një binar të optimizuar të lëshimit si parazgjedhje. Nëse dëshironi të ndërtoni për stacionin tuaj të punës, thjesht ekzekutoni komandën e mëposhtme.
cmake ../tensorflow_src/tensorflow/lite
Ndërtimi i korrigjimit
Nëse keni nevojë të krijoni një ndërtim korrigjimi që ka informacion simboli, ju duhet të siguroni opsionin -DCMAKE_BUILD_TYPE=Debug .
cmake ../tensorflow_src/tensorflow/lite -DCMAKE_BUILD_TYPE=Debug
Ndërtoni me teste të njësisë së kernelit
Për të qenë në gjendje të ekzekutoni testet e kernelit, duhet të jepni flamurin -DTFLITE_KERNEL_TEST=on . Specifikat e përpilimit të kryqëzuar të testit të njësisë mund të gjenden në nënseksionin tjetër.
cmake ../tensorflow_src/tensorflow/lite -DTFLITE_KERNEL_TEST=on
Ndërtoni paketën e instalueshme
Për të ndërtuar një paketë të instalueshme që mund të përdoret si një varësi nga një projekt tjetër CMake me find_package(tensorflow-lite CONFIG) , përdorni opsionin -DTFLITE_ENABLE_INSTALL=ON .
Në mënyrë ideale, duhet të ofroni edhe versionet tuaja të varësive të bibliotekës. Këto do të duhet gjithashtu të përdoren nga projekti që varet nga LiteRT. Mund të përdorni -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON dhe të vendosni variablat <PackageName>_DIR që të tregojnë instalimet e bibliotekës suaj.
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
Përmbledhje e kryqëzuar
Ju mund të përdorni CMake për të ndërtuar binare për arkitekturat e synuara ARM64 ose Android.
Për të ndërthurur LiteRT-në, duhet të siguroni shtegun për në SDK (p.sh. ARM64 SDK ose NDK në rastin e Android) me flamurin -DCMAKE_TOOLCHAIN_FILE .
cmake -DCMAKE_TOOLCHAIN_FILE=<CMakeToolchainFileLoc> ../tensorflow/lite/
Specifikat e ndërthurjes së Android
Për ndërthurjen e Android, duhet të instaloni Android NDK dhe të siguroni shtegun NDK me -DCMAKE_TOOLCHAIN_FILE flamurin e përmendur më sipër. Ju gjithashtu duhet të vendosni ABI-në e synuar me flamurin -DANDROID_ABI .
cmake -DCMAKE_TOOLCHAIN_FILE=<NDK path>/build/cmake/android.toolchain.cmake \
-DANDROID_ABI=arm64-v8a ../tensorflow_src/tensorflow/lite
Specifikat e testeve të kernelit (njësive) të ndërthurjes
Kompilimi i kryqëzuar i testeve të njësisë kërkon përpilues flatc për arkitekturën e hostit. Për këtë qëllim, ekziston një CMakeLists e vendosur në tensorflow/lite/tools/cmake/native_tools/flatbuffers për të ndërtuar paraprakisht përpiluesin flatc me CMake në një direktori të veçantë ndërtimi duke përdorur zinxhirin e veglave pritës.
mkdir flatc-native-build && cd flatc-native-build
cmake ../tensorflow_src/tensorflow/lite/tools/cmake/native_tools/flatbuffers
cmake --build .
Është gjithashtu e mundur të instaloni flatc në një vendndodhje instalimi të personalizuar (p.sh. në një drejtori që përmban mjete të tjera të ndërtuara në mënyrë origjinale në vend të drejtorisë së ndërtimit CMake):
cmake -DCMAKE_INSTALL_PREFIX=<native_tools_dir> ../tensorflow_src/tensorflow/lite/tools/cmake/native_tools/flatbuffers
cmake --build .
Për vetë përpilimin e ndërthurur të LiteRT, duhet të sigurohet parametri shtesë -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path> që tregon direktoriumin që përmban binarin vendas flatc së bashku me -DTFLITE_KERNEL_TEST=on flamurin e përmendur më sipër.
cmake -DCMAKE_TOOLCHAIN_FILE=${OE_CMAKE_TOOLCHAIN_FILE} -DTFLITE_KERNEL_TEST=on -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path> ../tensorflow/lite/
Testet e kernelit (njësive) të ndërthurura nisen në objektiv
Testet e njësisë mund të ekzekutohen si ekzekutues të veçantë ose duke përdorur programin CTest. Për sa i përket CTest-it, nëse të paktën një nga parametrat TFLITE_ENABLE_XNNPACK or TFLITE_EXTERNAL_DELEGATE është aktivizuar për ndërtimin e LiteRT, testet që rezultojnë gjenerohen me dy etiketa të ndryshme (duke përdorur të njëjtin ekzekutues provë): - i thjeshtë - që tregon testet shtesë që presin testet e CPU-së. nisni argumentet e përdorura për specifikimin e delegatit të përdorur
Të dy CTestTestfile.cmake dhe run-tests.cmake (siç përmendet më poshtë) janë të disponueshme në <build_dir>/kernels .
Nisja e testeve të njësisë me prapavijën e CPU-së (me kusht që CTestTestfile.cmake të jetë i pranishëm në objektiv në drejtorinë aktuale):
ctest -L plain
Nisni shembuj të testeve të njësive duke përdorur delegatë (me kusht që skedari CTestTestfile.cmake si dhe skedari run-tests.cmake të jenë të pranishëm në objektiv në direktorinë aktuale):
cmake -E env TESTS_ARGUMENTS=--use_xnnpack=true ctest -L delegate
cmake -E env TESTS_ARGUMENTS=--external_delegate_path=<PATH> ctest -L delegate
Një kufizim i njohur i kësaj mënyre të ofrimit të argumenteve shtesë të nisjes lidhur me delegat në testet e njësisë është se ai në mënyrë efektive mbështet vetëm ato me një vlerë të pritshme kthimi prej 0 . Vlerat e ndryshme të kthimit do të raportohen si një dështim i testit.
Delegat i OpenCL GPU
Nëse makina juaj e synuar ka mbështetje OpenCL, mund të përdorni delegatin e GPU-së i cili mund të shfrytëzojë fuqinë tuaj GPU.
Për të konfiguruar mbështetjen e delegatëve të OpenCL GPU:
cmake ../tensorflow_src/tensorflow/lite -DTFLITE_ENABLE_GPU=ON
Hapi 5. Ndërtoni LiteRT
Në drejtorinë tflite_build ,
cmake --build . -j
Hapi 6. Build LiteRT Benchmark Tool and Label Image Shembull (opsionale)
Në drejtorinë tflite_build ,
cmake --build . -j -t benchmark_model
cmake --build . -j -t label_image
Opsionet e disponueshme për të ndërtuar LiteRT
Këtu është lista e opsioneve të disponueshme. Mund ta anashkaloni me -D<option_name>=[ON|OFF] . Për shembull, -DTFLITE_ENABLE_XNNPACK=OFF për të çaktivizuar XNNPACK i cili është i aktivizuar si parazgjedhje.
| Emri i opsionit | Veçori | Android | Linux | macOS | Dritaret |
|---|---|---|---|---|---|
TFLITE_ENABLE_RUY | Aktivizo bibliotekën e shumëzimit të matricës RUY | AKTIV | FAKT | FAKT | FAKT |
TFLITE_ENABLE_GPU | Aktivizo delegatin e GPU | FAKT | FAKT | N/A | N/A |
TFLITE_ENABLE_XNNPACK | Aktivizo delegatin XNNPACK | AKTIV | AKTIV | AKTIV | AKTIV |
TFLITE_ENABLE_MMAP | Aktivizo MMAP | AKTIV | AKTIV | AKTIV | N/A |
Krijo një projekt CMake i cili përdor LiteRT
Këtu është shembulli minimal CMakeLists.txt i TFLite .
Duhet të keni add_subdirectory() për direktoriumin LiteRT dhe të lidhni tensorflow-lite me 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)
Ndërtoni bibliotekën LiteRT C
Nëse dëshironi të ndërtoni bibliotekë të përbashkët LiteRT për C API , ndiqni hapin 1 deri në hapin 3 fillimisht. Pas kësaj, ekzekutoni komandat e mëposhtme.
TENSORFLOW_VERSION=$(grep "TF_VERSION = " "../tensorflow_src/tensorflow/tf_version.bzl" | cut -d= -f2 | sed 's/[ "-]//g')
IFS='.' read -r -a array <<< "$TENSORFLOW_VERSION"
TF_MAJOR=${array[0]}
TF_MINOR=${array[1]}
TF_PATCH=${array[2]}
TF_CXX_FLAGS="-DTF_MAJOR_VERSION=${TF_MAJOR} -DTF_MINOR_VERSION=${TF_MINOR} -DTF_PATCH_VERSION=${TF_PATCH} -DTF_VERSION_SUFFIX=''"
cmake -DCMAKE_C_FLAGS="${TF_CXX_FLAGS}" -DCMAKE_CXX_FLAGS="${TF_CXX_FLAGS}" ../tensorflow_src/tensorflow/lite/c
cmake --build . -j
Kjo komandë gjeneron bibliotekën e mëposhtme të përbashkët në drejtorinë aktuale.
| Platforma | Emri i bibliotekës |
|---|---|
| Linux | libtensorflowlite_c.so |
| macOS | libtensorflowlite_c.dylib |
| Dritaret | tensorflowlite_c.dll |
Kjo faqe përshkruan se si të ndërtoni dhe përdorni bibliotekën LiteRT me mjetin CMake .
Udhëzimet e mëposhtme janë testuar në Ubuntu 16.04.3 64-bit PC (AMD64), macOS Catalina (x86_64), Windows 10 dhe TensorFlow Devel Docker image tensorflow/tensorflow:devel .
Hapi 1. Instaloni mjetin CMake
Kërkon CMake 3.16 ose më të lartë. Në Ubuntu, thjesht mund të ekzekutoni komandën e mëposhtme.
sudo apt-get install cmake
Ose mund të ndiqni udhëzuesin zyrtar të instalimit cmake
Hapi 2. Klononi depon e TensorFlow
git clone https://github.com/tensorflow/tensorflow.git tensorflow_src
Hapi 3. Krijo drejtorinë e ndërtimit të CMake
mkdir tflite_build
cd tflite_build
Hapi 4. Ekzekutoni mjetin CMake me konfigurime
Lëshoni ndërtimin
Ai gjeneron një binar të optimizuar të lëshimit si parazgjedhje. Nëse dëshironi të ndërtoni për stacionin tuaj të punës, thjesht ekzekutoni komandën e mëposhtme.
cmake ../tensorflow_src/tensorflow/lite
Ndërtimi i korrigjimit
Nëse keni nevojë të krijoni një ndërtim korrigjimi që ka informacion simboli, ju duhet të siguroni opsionin -DCMAKE_BUILD_TYPE=Debug .
cmake ../tensorflow_src/tensorflow/lite -DCMAKE_BUILD_TYPE=Debug
Ndërtoni me teste të njësisë së kernelit
Për të qenë në gjendje të ekzekutoni testet e kernelit, duhet të jepni flamurin -DTFLITE_KERNEL_TEST=on . Specifikat e përpilimit të kryqëzuar të testit të njësisë mund të gjenden në nënseksionin tjetër.
cmake ../tensorflow_src/tensorflow/lite -DTFLITE_KERNEL_TEST=on
Ndërtoni paketën e instalueshme
Për të ndërtuar një paketë të instalueshme që mund të përdoret si një varësi nga një projekt tjetër CMake me find_package(tensorflow-lite CONFIG) , përdorni opsionin -DTFLITE_ENABLE_INSTALL=ON .
Në mënyrë ideale, duhet të ofroni edhe versionet tuaja të varësive të bibliotekës. Këto do të duhet gjithashtu të përdoren nga projekti që varet nga LiteRT. Mund të përdorni -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON dhe të vendosni variablat <PackageName>_DIR që të tregojnë instalimet e bibliotekës suaj.
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
Përmbledhje e kryqëzuar
Ju mund të përdorni CMake për të ndërtuar binare për arkitekturat e synuara ARM64 ose Android.
Për të ndërthurur LiteRT-në, duhet të siguroni shtegun për në SDK (p.sh. ARM64 SDK ose NDK në rastin e Android) me flamurin -DCMAKE_TOOLCHAIN_FILE .
cmake -DCMAKE_TOOLCHAIN_FILE=<CMakeToolchainFileLoc> ../tensorflow/lite/
Specifikat e ndërthurjes së Android
Për ndërthurjen e Android, duhet të instaloni Android NDK dhe të siguroni shtegun NDK me -DCMAKE_TOOLCHAIN_FILE flamurin e përmendur më sipër. Ju gjithashtu duhet të vendosni ABI-në e synuar me flamurin -DANDROID_ABI .
cmake -DCMAKE_TOOLCHAIN_FILE=<NDK path>/build/cmake/android.toolchain.cmake \
-DANDROID_ABI=arm64-v8a ../tensorflow_src/tensorflow/lite
Specifikat e testeve të kernelit (njësive) të ndërthurjes
Kompilimi i kryqëzuar i testeve të njësisë kërkon përpilues flatc për arkitekturën e hostit. Për këtë qëllim, ekziston një CMakeLists e vendosur në tensorflow/lite/tools/cmake/native_tools/flatbuffers për të ndërtuar paraprakisht përpiluesin flatc me CMake në një direktori të veçantë ndërtimi duke përdorur zinxhirin e veglave pritës.
mkdir flatc-native-build && cd flatc-native-build
cmake ../tensorflow_src/tensorflow/lite/tools/cmake/native_tools/flatbuffers
cmake --build .
Është gjithashtu e mundur të instaloni flatc në një vendndodhje instalimi të personalizuar (p.sh. në një drejtori që përmban mjete të tjera të ndërtuara në mënyrë origjinale në vend të drejtorisë së ndërtimit CMake):
cmake -DCMAKE_INSTALL_PREFIX=<native_tools_dir> ../tensorflow_src/tensorflow/lite/tools/cmake/native_tools/flatbuffers
cmake --build .
Për vetë përpilimin e ndërthurur të LiteRT, duhet të sigurohet parametri shtesë -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path> që tregon direktoriumin që përmban binarin vendas flatc së bashku me -DTFLITE_KERNEL_TEST=on flamurin e përmendur më sipër.
cmake -DCMAKE_TOOLCHAIN_FILE=${OE_CMAKE_TOOLCHAIN_FILE} -DTFLITE_KERNEL_TEST=on -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path> ../tensorflow/lite/
Testet e kernelit (njësive) të ndërthurura nisen në objektiv
Testet e njësisë mund të ekzekutohen si ekzekutues të veçantë ose duke përdorur programin CTest. Për sa i përket CTest-it, nëse të paktën një nga parametrat TFLITE_ENABLE_XNNPACK or TFLITE_EXTERNAL_DELEGATE është aktivizuar për ndërtimin e LiteRT, testet që rezultojnë gjenerohen me dy etiketa të ndryshme (duke përdorur të njëjtin ekzekutues provë): - i thjeshtë - që tregon testet shtesë që presin testet e CPU-së. nisni argumentet e përdorura për specifikimin e delegatit të përdorur
Të dy CTestTestfile.cmake dhe run-tests.cmake (siç përmendet më poshtë) janë të disponueshme në <build_dir>/kernels .
Nisja e testeve të njësisë me prapavijën e CPU-së (me kusht që CTestTestfile.cmake të jetë i pranishëm në objektiv në drejtorinë aktuale):
ctest -L plain
Nisni shembuj të testeve të njësive duke përdorur delegatë (me kusht që skedari CTestTestfile.cmake si dhe skedari run-tests.cmake të jenë të pranishëm në objektiv në direktorinë aktuale):
cmake -E env TESTS_ARGUMENTS=--use_xnnpack=true ctest -L delegate
cmake -E env TESTS_ARGUMENTS=--external_delegate_path=<PATH> ctest -L delegate
Një kufizim i njohur i kësaj mënyre të ofrimit të argumenteve shtesë të nisjes lidhur me delegat në testet e njësisë është se ai në mënyrë efektive mbështet vetëm ato me një vlerë të pritshme kthimi prej 0 . Vlerat e ndryshme të kthimit do të raportohen si një dështim i testit.
Delegat i OpenCL GPU
Nëse makina juaj e synuar ka mbështetje OpenCL, mund të përdorni delegatin e GPU-së i cili mund të shfrytëzojë fuqinë tuaj GPU.
Për të konfiguruar mbështetjen e delegatëve të OpenCL GPU:
cmake ../tensorflow_src/tensorflow/lite -DTFLITE_ENABLE_GPU=ON
Hapi 5. Ndërtoni LiteRT
Në drejtorinë tflite_build ,
cmake --build . -j
Hapi 6. Build LiteRT Benchmark Tool and Label Image Shembull (opsionale)
Në drejtorinë tflite_build ,
cmake --build . -j -t benchmark_model
cmake --build . -j -t label_image
Opsionet e disponueshme për të ndërtuar LiteRT
Këtu është lista e opsioneve të disponueshme. Mund ta anashkaloni me -D<option_name>=[ON|OFF] . Për shembull, -DTFLITE_ENABLE_XNNPACK=OFF për të çaktivizuar XNNPACK i cili është i aktivizuar si parazgjedhje.
| Emri i opsionit | Veçori | Android | Linux | macOS | Dritaret |
|---|---|---|---|---|---|
TFLITE_ENABLE_RUY | Aktivizo bibliotekën e shumëzimit të matricës RUY | AKTIV | FAKT | FAKT | FAKT |
TFLITE_ENABLE_GPU | Aktivizo delegatin e GPU | FAKT | FAKT | N/A | N/A |
TFLITE_ENABLE_XNNPACK | Aktivizo delegatin XNNPACK | AKTIV | AKTIV | AKTIV | AKTIV |
TFLITE_ENABLE_MMAP | Aktivizo MMAP | AKTIV | AKTIV | AKTIV | N/A |
Krijo një projekt CMake i cili përdor LiteRT
Këtu është shembulli minimal CMakeLists.txt i TFLite .
Duhet të keni add_subdirectory() për direktoriumin LiteRT dhe të lidhni tensorflow-lite me 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)
Ndërtoni bibliotekën LiteRT C
Nëse dëshironi të ndërtoni bibliotekë të përbashkët LiteRT për C API , ndiqni hapin 1 deri në hapin 3 fillimisht. Pas kësaj, ekzekutoni komandat e mëposhtme.
TENSORFLOW_VERSION=$(grep "TF_VERSION = " "../tensorflow_src/tensorflow/tf_version.bzl" | cut -d= -f2 | sed 's/[ "-]//g')
IFS='.' read -r -a array <<< "$TENSORFLOW_VERSION"
TF_MAJOR=${array[0]}
TF_MINOR=${array[1]}
TF_PATCH=${array[2]}
TF_CXX_FLAGS="-DTF_MAJOR_VERSION=${TF_MAJOR} -DTF_MINOR_VERSION=${TF_MINOR} -DTF_PATCH_VERSION=${TF_PATCH} -DTF_VERSION_SUFFIX=''"
cmake -DCMAKE_C_FLAGS="${TF_CXX_FLAGS}" -DCMAKE_CXX_FLAGS="${TF_CXX_FLAGS}" ../tensorflow_src/tensorflow/lite/c
cmake --build . -j
Kjo komandë gjeneron bibliotekën e mëposhtme të përbashkët në drejtorinë aktuale.
| Platforma | Emri i bibliotekës |
|---|---|
| Linux | libtensorflowlite_c.so |
| macOS | libtensorflowlite_c.dylib |
| Dritaret | tensorflowlite_c.dll |