Google AI Edge से I/O के एलान के बारे में ज़्यादा जानें

इस पेज का अनुवाद Cloud Translation API से किया गया है.

C Make की मदद से TensorFlow Lite बनाएं

इस पेज पर CMake टूल की मदद से TensorFlow Lite लाइब्रेरी बनाने और उसे इस्तेमाल करने का तरीका बताया गया है.

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

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

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

sudo apt-get install cmake

इसके अलावा, cmake इंस्टॉल करने की आधिकारिक गाइड का पालन किया जा सकता है

दूसरा चरण. TensorFlow का डेटा स्टोर करने की जगह का क्लोन

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

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

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

कर्नेल यूनिट टेस्ट के साथ बनाएं

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

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

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

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

आम तौर पर, आपको लाइब्रेरी डिपेंडेंसी के अपने वर्शन भी उपलब्ध कराने चाहिए. इन्हें TF Lite पर निर्भर प्रोजेक्ट में भी इस्तेमाल करना होगा. लाइब्रेरी इंस्टॉलेशन दिखाने के लिए, -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

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

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

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

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

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

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

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

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

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

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

पसंद के मुताबिक इंस्टॉल करने की जगह पर flatc को इंस्टॉल भी किया जा सकता है (उदाहरण के लिए, एक ऐसी डायरेक्ट्री के लिए जिसमें Cmake बिल्ड डायरेक्ट्री के बजाय, दूसरे मूल रूप से बनाए गए टूल मौजूद हैं):

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

TF Lite के क्रॉस-कंपाइलेशन के लिए, नेटिव flatc बाइनरी वाली डायरेक्ट्री पर ले जाने वाला अतिरिक्त पैरामीटर -DTFLITE_HOST_TOOLS_DIR=<flatc_dir_path>, ऊपर बताए गए -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 सुविधा का इस्तेमाल करके चलाया जा सकता है. जहां तक Cटेस्ट का सवाल है, तो अगर TF Lite बिल्ड के लिए कम से कम एक पैरामीटर TFLITE_ENABLE_XNNPACKorTFLITE_EXTERNAL_DELEGATE` को चालू किया गया है, तो नतीजे के तौर पर मिलने वाले टेस्ट दो अलग-अलग लेबल से जनरेट किए जाते हैं (एक ही टेस्ट एक्ज़ीक्यूटेबल का इस्तेमाल करते हुए): - सादा - इस्तेमाल किए गए टेस्ट को डिकोड करने के लिए इस्तेमाल किए गए अतिरिक्त टेस्ट के बारे में बताना -

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

पांचवां चरण. TensorFlow Lite बनाएं

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

cmake --build . -j

ध्यान दें: इससे मौजूदा डायरेक्ट्री में, एक स्टैटिक लाइब्रेरी libtensorflow-lite.a जनरेट होती है. हालांकि, यह लाइब्रेरी अपने-आप में पूरी नहीं होती, क्योंकि सभी ट्रांज़िटिव डिपेंडेंसी शामिल नहीं होती हैं. लाइब्रेरी का सही तरीके से इस्तेमाल करने के लिए, आपको एक CMake प्रोजेक्ट बनाना होगा. कृपया "ऐसा Cमेक प्रोजेक्ट बनाएं जो TensorFlow Lite का इस्तेमाल करता है" सेक्शन देखें.

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

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

cmake --build . -j -t benchmark_model

cmake --build . -j -t label_image

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

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

विकल्प का नाम	सुविधा	Android	Linux	macOS	Windows
`TFLITE_ENABLE_RUY`	RUY मैट्रिक्स मल्टीप्लिकेशन लाइब्रेरी चालू करें	चालू है	बंद है	बंद है	बंद है
`TFLITE_ENABLE_GPU`	जीपीयू डेलिगेट चालू करें	बंद है	बंद है	लागू नहीं	लागू नहीं
`TFLITE_ENABLE_XNNPACK`	XNNPACK डीलिगेट चालू करें	चालू है	चालू है	चालू है	चालू है
`TFLITE_ENABLE_MMAP`	MMAP चालू करें	चालू है	चालू है	चालू है	लागू नहीं

TensorFlow Lite का इस्तेमाल करने वाला Cमेक प्रोजेक्ट बनाना

यहां TFLite के कम से कम उदाहरण का C MakeLists.txt दिया गया है.

आपके पास TensorFlow Lite डायरेक्ट्री के लिए 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)

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

अगर आपको C API के लिए, TensorFlow Lite की शेयर की गई लाइब्रेरी बनानी है, तो सबसे पहले पहले चरण से तीसरे चरण पर जाएं. इसके बाद, नीचे दिए गए निर्देशों को चलाएँ.

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

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

प्लैटफ़ॉर्म	लाइब्रेरी का नाम
Linux	`libtensorflowlite_c.so`
macOS	`libtensorflowlite_c.dylib`
Windows	`tensorflowlite_c.dll`