CMake की मदद से LiteRT बनाएं

इस पेज में बताया गया है कि LiteRT लाइब्रेरी को कैसे बनाया और इस्तेमाल किया जाए CMake टूल.

निम्नलिखित निर्देशों का Ubuntu 16.04.3 64-बिट पीसी (AMD64) पर परीक्षण किया गया है , macOS Catalina (x86_64), Windows 10, और TensorFlow devel Docker इमेज tensorflow/tensorflow:devel.

पहला चरण. CMake टूल इंस्टॉल करें

इसके लिए CMake 3.16 या बाद वाला वर्शन चाहिए. Ubuntu पर, आप नीचे दिए गए काम कर सकते हैं आदेश.

sudo apt-get install cmake

या फ़ॉलो किया जा सकता है सीमेक इंस्टॉलेशन की आधिकारिक गाइड

दूसरा चरण. TensorFlow का क्लोन रिपॉज़िटरी

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

तीसरा चरण. CMake की बिल्ड डायरेक्ट्री बनाएं

mkdir tflite_build
cd tflite_build

चरण 4. कॉन्फ़िगरेशन के साथ CMake टूल चलाएं

बिल्ड रिलीज़ करें

यह डिफ़ॉल्ट रूप से, ऑप्टिमाइज़ की गई रिलीज़ बाइनरी जनरेट करता है. अगर आपको डिजिटल विज्ञापन से अपने वर्कस्टेशन पर, बस नीचे दिया गया निर्देश चलाएं.

cmake ../tensorflow_src/tensorflow/lite

बिल्ड डीबग करें

अगर आपको सिंबल की जानकारी वाला डीबग बिल्ड बनाना है, तो -DCMAKE_BUILD_TYPE=Debug विकल्प दें.

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

कर्नेल यूनिट टेस्ट की मदद से बनाएं

कर्नेल टेस्ट चलाने के लिए, आपको -DTFLITE_KERNEL_TEST=on फ़्लैग. यूनिट टेस्ट के क्रॉस-कंपाइलेशन की खास बातें अगले सब-सेक्शन में मिलेगा.

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

इंस्टॉल किया जा सकने वाला पैकेज बनाएं

इंस्टॉल किया जा सकने वाला ऐसा पैकेज बनाना जिसे किसी दूसरे डिवाइस की डिपेंडेंसी के तौर पर इस्तेमाल किया जा सके find_package(tensorflow-lite CONFIG) के साथ प्रोजेक्ट बनाएं, इसके लिए -DTFLITE_ENABLE_INSTALL=ON विकल्प.

आपको लाइब्रेरी डिपेंडेंसी के अपने वर्शन भी देने चाहिए. LiteRT पर निर्भर प्रोजेक्ट में भी इनका इस्तेमाल करना होगा. आप -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON का इस्तेमाल करें और <PackageName>_DIR को सेट करें वैरिएबल का इस्तेमाल करें.

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

क्रॉस-कंपाइलेशन

CMake की मदद से ARM64 या Android टारगेट आर्किटेक्चर के लिए बाइनरी बनाए जा सकते हैं.

LiteRT को क्रॉस-कंपाइल करने के लिए, आपको -DCMAKE_TOOLCHAIN_FILE के साथ SDK टूल (उदाहरण के लिए, Android के मामले में ARM64 SDK या NDK) फ़्लैग करें.

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

Android क्रॉस-कंपाइलेशन की खास बातें

Android क्रॉस-कंपाइलेशन के लिए, आपको Android NDK और उसके साथ NDK पाथ उपलब्ध कराएं -DCMAKE_TOOLCHAIN_FILE फ़्लैग ऊपर बताया गया है. आपको टारगेट एबीआई भी सेट करना होगा -DANDROID_ABI फ़्लैग के साथ.

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

कर्नेल (इकाई) क्रॉस-कंपाइलेशन परीक्षणों की विशेषताएं

यूनिट टेस्ट के क्रॉस-कंपाइलेशन के लिए, होस्ट के लिएflac कंपाइलर की ज़रूरत होती है आर्किटेक्चर. इस काम के लिए, CMakeLists में CMakeLists मौजूद है, फ़्लैट बनाने के लिए tensorflow/lite/tools/cmake/native_tools/flatbuffers होस्ट का इस्तेमाल करके पहले से एक अलग बिल्ड डायरेक्ट्री में CMake के साथ कंपाइलर टूलचेन.

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

फ़्लैट को कस्टम इंस्टॉलेशन लोकेशन पर इंस्टॉल किया जा सकता है (जैसे, ऐसी डायरेक्ट्री में जिसमें CMake की जगह दूसरी मूल रूप से बनाए गए टूल मौजूद हों बिल्ड डायरेक्ट्री):

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

LiteRT क्रॉस-कंपाइलेशन के लिए, अतिरिक्त पैरामीटर -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path> उस डायरेक्ट्री के बारे में बताता है जिसमें शामिल है नेटिव flatc बाइनरी के साथ -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/

टारगेट पर क्रॉस-कंपाइल्ड कर्नेल (यूनिट) टेस्ट लॉन्च किए गए

यूनिट टेस्ट को अलग-अलग एक्ज़ीक्यूटेबल के रूप में या CTest उपयोगिता का इस्तेमाल करके चलाया जा सकता है. अभी तक क्योंकि CTest का संबंध है, अगर कम से कम एक पैरामीटर TFLITE_ENABLE_XNNPACKorTFLITE_EXTERNAL_DELEGATE`, LiteRT के लिए चालू है बिल्ड के लिए इस्तेमाल किया जाता है, जिससे नतीजे दो अलग-अलग लेबल के साथ जनरेट होते हैं (जिन टेस्ट के लिए एक्ज़ीक्यूट किया जा सकता है उनका इस्तेमाल करना): - सादा - इससे, उन टेस्ट की जानकारी मिलती है जिन पर टेस्ट किए जा रहे हैं सीपीयू बैकएंड - डेलीगेट - यह उन टेस्ट के बारे में बताता है जिन्हें अतिरिक्त लॉन्च के लिए जाना जाता है इस्तेमाल किए गए डेलिगेट स्पेसिफ़िकेशन के लिए इस्तेमाल किए गए आर्ग्युमेंट

CTestTestfile.cmake और run-tests.cmake (जैसा कि नीचे बताया गया है) दोनों <build_dir>/kernels में उपलब्ध है.

सीपीयू बैकएंड के साथ यूनिट टेस्ट लॉन्च करना (बशर्ते CTestTestfile.cmake हो मौजूदा डायरेक्ट्री में टारगेट पर मौजूद है):

ctest -L plain

डेलिगेट के वोटों का इस्तेमाल करके यूनिट टेस्ट करने के उदाहरण (अगर इसमें CTestTestfile.cmake और run-tests.cmake फ़ाइल टारगेट पर मौजूद हैं मौजूदा डायरेक्ट्री से जुड़ा हो):

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

अतिरिक्त प्रतिनिधि से जुड़ी जानकारी देने के इस तरीके की पहले से मालूम सीमा यूनिट परीक्षणों में लॉंंच आर्ग्युमेंट के साथ-साथ वह 0 अनुमानित रिटर्न वैल्यू हो. रिटर्न की अलग-अलग वैल्यू इस तौर पर रिपोर्ट की जाएंगी टेस्ट फ़ेलियर.

OpenCL जीपीयू डेलिगेट

अगर आपकी टारगेट मशीन पर OpenCL काम करता है, तो GPU प्रतिनिधि जो ये काम कर सकते हैं: अपने जीपीयू का फ़ायदा पाएं.

OpenCL जीपीयू डेलिगेट सपोर्ट को कॉन्फ़िगर करने के लिए:

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

पांचवां चरण. LiteRT बनाएं

tflite_build डायरेक्ट्री में,

cmake --build . -j

छठा चरण. बिल्ड LiteRT बेंचमार्क टूल और लेबल इमेज का उदाहरण (ज़रूरी नहीं)

tflite_build डायरेक्ट्री में,

cmake --build . -j -t benchmark_model

cmake --build . -j -t label_image

LiteRT बनाने के लिए उपलब्ध विकल्प

यहां उपलब्ध विकल्पों की सूची दी गई है. आप इसे इससे ओवरराइड कर सकते हैं: -D<option_name>=[ON|OFF]. उदाहरण के लिए, -DTFLITE_ENABLE_XNNPACK=OFF से XNNPACK को बंद करना जो डिफ़ॉल्ट रूप से चालू रहता है.

LiteRT का इस्तेमाल करने वाला CMake प्रोजेक्ट बनाएं

यह रही इसका CMakeLists.txt TFLite कम से कम उदाहरण.

LiteRT डायरेक्ट्री और लिंक के लिए, add_subdirectory() लेना ज़रूरी है target_link_libraries() के साथ tensorflow-lite.

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)

LiteRT C लाइब्रेरी बनाएं

अगर आपको LiteRT के लिए शेयर की गई लाइब्रेरी बनानी है, तो C API, इसके लिए, पहले चरण को फ़ॉलो करें चरण 3 पहले. इसके बाद, कमांड का इस्तेमाल किया जा सकता है.

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

यह निर्देश मौजूदा डायरेक्ट्री में शेयर की गई इस लाइब्रेरी को जनरेट करता है.