खास जानकारी
डिवाइस पर मशीन लर्निंग (ओडीएमएल) ऐप्लिकेशन के लिए मॉडल डिप्लॉय करते समय, यह जानना ज़रूरी है कि मोबाइल डिवाइसों पर सीमित मेमोरी उपलब्ध होती है. मॉडल के बाइनरी साइज़, मॉडल में इस्तेमाल किए गए ऑप्स की संख्या से काफ़ी हद तक जुड़े होते हैं. LiteRT की मदद से, चुनिंदा बिल्ड का इस्तेमाल करके मॉडल के बाइनरी साइज़ को कम किया जा सकता है. चुनिंदा बिल्ड, आपके मॉडल सेट में इस्तेमाल न की गई कार्रवाइयों को छोड़ देते हैं. साथ ही, एक छोटी लाइब्रेरी बनाते हैं. इसमें सिर्फ़ रनटाइम और ओप कर्नल होते हैं. इनकी ज़रूरत मॉडल को आपके मोबाइल डिवाइस पर चलाने के लिए होती है.
चुनिंदा बिल्ड, इन तीन ऑपरेशन लाइब्रेरी पर लागू होता है.
नीचे दी गई टेबल में, कुछ सामान्य इस्तेमाल के मामलों के लिए चुनिंदा बिल्ड के असर को दिखाया गया है:
| मॉडल का नाम | डोमेन | टारगेट आर्किटेक्चर | एएआर फ़ाइल का साइज़ |
|---|---|---|---|
| Mobilenet_1.0_224(float) | इमेज क्लासिफ़िकेशन | armeabi-v7a | tensorflow-lite.aar (296,635 बाइट) |
| arm64-v8a | tensorflow-lite.aar (3,82,892 बाइट) | ||
| SPICE | आवाज़ की पिच का पता लगाना | armeabi-v7a | tensorflow-lite.aar (3,75,813 बाइट) tensorflow-lite-select-tf-ops.aar (16,76,380 बाइट) |
| arm64-v8a | tensorflow-lite.aar (4,21,826 बाइट) tensorflow-lite-select-tf-ops.aar (22,98,630 बाइट) |
||
| i3d-kinetics-400 | वीडियो का क्लासिफ़िकेशन | armeabi-v7a | tensorflow-lite.aar (240,085 बाइट) tensorflow-lite-select-tf-ops.aar (1,708,597 बाइट) |
| arm64-v8a | tensorflow-lite.aar (2,73,713 बाइट) tensorflow-lite-select-tf-ops.aar (23,39,697 बाइट) |
Bazel की मदद से, LiteRT को चुनिंदा तौर पर बनाना
इस सेक्शन में यह माना गया है कि आपने TensorFlow के सोर्स कोड डाउनलोड कर लिए हैं. साथ ही, आपने Bazel के लिए लोकल डेवलपमेंट एनवायरमेंट सेट अप कर लिया है.
Android प्रोजेक्ट के लिए AAR फ़ाइलें बनाना
यहां दिए गए तरीके से, मॉडल फ़ाइल के पाथ देकर कस्टम LiteRT AAR बनाए जा सकते हैं.
sh tensorflow/lite/tools/build_aar.sh \
--input_models=/a/b/model_one.tflite,/c/d/model_two.tflite \
--target_archs=x86,x86_64,arm64-v8a,armeabi-v7a
ऊपर दिए गए कमांड से, LiteRT में पहले से मौजूद और कस्टम ऑप्स के लिए, एएआर फ़ाइल bazel-bin/tmp/tensorflow-lite.aar जनरेट होगी. साथ ही, अगर आपके मॉडल में Select TensorFlow ऑप्स शामिल हैं, तो एएआर फ़ाइल bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar जनरेट होगी. ध्यान दें कि इससे कई अलग-अलग आर्किटेक्चर वाला "फ़ैट" एएआर बनता है. अगर आपको इन सभी की ज़रूरत नहीं है, तो अपने डिप्लॉयमेंट एनवायरमेंट के लिए सही सबसेट का इस्तेमाल करें.
कस्टम ऑप्स का इस्तेमाल करके मॉडल बनाना
अगर आपने कस्टम ऑप्स के साथ LiteRT मॉडल बनाए हैं, तो उन्हें बनाने के लिए, बिल्ड कमांड में ये फ़्लैग जोड़ें:
sh tensorflow/lite/tools/build_aar.sh \
--input_models=/a/b/model_one.tflite,/c/d/model_two.tflite \
--target_archs=x86,x86_64,arm64-v8a,armeabi-v7a \
--tflite_custom_ops_srcs=/e/f/file1.cc,/g/h/file2.h \
--tflite_custom_ops_deps=dep1,dep2
tflite_custom_ops_srcs फ़्लैग में, आपके कस्टम ऑप की सोर्स फ़ाइलें होती हैं. साथ ही, tflite_custom_ops_deps फ़्लैग में उन सोर्स फ़ाइलों को बनाने के लिए ज़रूरी डिपेंडेंसी होती हैं. ध्यान दें कि ये डिपेंडेंसी, TensorFlow के रेपो में मौजूद होनी चाहिए.
एडवांस इस्तेमाल: कस्टम Bazel नियम
अगर आपका प्रोजेक्ट Bazel का इस्तेमाल कर रहा है और आपको मॉडल के किसी सेट के लिए, कस्टम TFLite डिपेंडेंसी तय करनी हैं, तो अपने प्रोजेक्ट रिपॉज़िटरी में ये नियम तय करें:
सिर्फ़ पहले से मौजूद ऑप्स वाले मॉडल के लिए:
load(
"@org_tensorflow//tensorflow/lite:build_def.bzl",
"tflite_custom_android_library",
"tflite_custom_c_library",
"tflite_custom_cc_library",
)
# A selectively built TFLite Android library.
tflite_custom_android_library(
name = "selectively_built_android_lib",
models = [
":model_one.tflite",
":model_two.tflite",
],
)
# A selectively built TFLite C library.
tflite_custom_c_library(
name = "selectively_built_c_lib",
models = [
":model_one.tflite",
":model_two.tflite",
],
)
# A selectively built TFLite C++ library.
tflite_custom_cc_library(
name = "selectively_built_cc_lib",
models = [
":model_one.tflite",
":model_two.tflite",
],
)
Select TF ops वाले मॉडल के लिए:
load(
"@org_tensorflow//tensorflow/lite/delegates/flex:build_def.bzl",
"tflite_flex_android_library",
"tflite_flex_cc_library",
)
# A Select TF ops enabled selectively built TFLite Android library.
tflite_flex_android_library(
name = "selective_built_tflite_flex_android_lib",
models = [
":model_one.tflite",
":model_two.tflite",
],
)
# A Select TF ops enabled selectively built TFLite C++ library.
tflite_flex_cc_library(
name = "selective_built_tflite_flex_cc_lib",
models = [
":model_one.tflite",
":model_two.tflite",
],
)
एडवांस इस्तेमाल: कस्टम C/C++ शेयर की गई लाइब्रेरी बनाना
अगर आपको दिए गए मॉडल के लिए, अपने कस्टम TFLite C/C++ शेयर किए गए ऑब्जेक्ट बनाने हैं, तो यह तरीका अपनाएं:
TensorFlow के सोर्स कोड की रूट डायरेक्ट्री में, यह कमांड चलाकर कुछ समय के लिए BUILD फ़ाइल बनाएं:
mkdir -p tmp && touch tmp/BUILD
कस्टम C शेयर किए गए ऑब्जेक्ट बनाना
अगर आपको कस्टम TFLite C शेयर किया गया ऑब्जेक्ट बनाना है, तो tmp/BUILD फ़ाइल में यह जोड़ें:
load(
"//tensorflow/lite:build_def.bzl",
"tflite_custom_c_library",
"tflite_cc_shared_object",
)
tflite_custom_c_library(
name = "selectively_built_c_lib",
models = [
":model_one.tflite",
":model_two.tflite",
],
)
# Generates a platform-specific shared library containing the LiteRT C
# API implementation as define in `c_api.h`. The exact output library name
# is platform dependent:
# - Linux/Android: `libtensorflowlite_c.so`
# - Mac: `libtensorflowlite_c.dylib`
# - Windows: `tensorflowlite_c.dll`
tflite_cc_shared_object(
name = "tensorflowlite_c",
linkopts = select({
"//tensorflow:ios": [
"-Wl,-exported_symbols_list,$(location //tensorflow/lite/c:exported_symbols.lds)",
],
"//tensorflow:macos": [
"-Wl,-exported_symbols_list,$(location //tensorflow/lite/c:exported_symbols.lds)",
],
"//tensorflow:windows": [],
"//conditions:default": [
"-z defs",
"-Wl,--version-script,$(location //tensorflow/lite/c:version_script.lds)",
],
}),
per_os_targets = True,
deps = [
":selectively_built_c_lib",
"//tensorflow/lite/c:exported_symbols.lds",
"//tensorflow/lite/c:version_script.lds",
],
)
नया टारगेट इस तरह बनाया जा सकता है:
bazel build -c opt --cxxopt=--std=c++17 \
//tmp:tensorflowlite_c
Android के लिए (64-बिट के लिए android_arm को android_arm64 से बदलें):
bazel build -c opt --cxxopt=--std=c++17 --config=android_arm \
//tmp:tensorflowlite_c
C++ के कस्टम शेयर किए गए ऑब्जेक्ट बनाना
अगर आपको कस्टम TFLite C++ शेयर किया गया ऑब्जेक्ट बनाना है, तो tmp/BUILD फ़ाइल में यह जोड़ें:
load(
"//tensorflow/lite:build_def.bzl",
"tflite_custom_cc_library",
"tflite_cc_shared_object",
)
tflite_custom_cc_library(
name = "selectively_built_cc_lib",
models = [
":model_one.tflite",
":model_two.tflite",
],
)
# Shared lib target for convenience, pulls in the core runtime and builtin ops.
# Note: This target is not yet finalized, and the exact set of exported (C/C++)
# APIs is subject to change. The output library name is platform dependent:
# - Linux/Android: `libtensorflowlite.so`
# - Mac: `libtensorflowlite.dylib`
# - Windows: `tensorflowlite.dll`
tflite_cc_shared_object(
name = "tensorflowlite",
# Until we have more granular symbol export for the C++ API on Windows,
# export all symbols.
features = ["windows_export_all_symbols"],
linkopts = select({
"//tensorflow:macos": [
"-Wl,-exported_symbols_list,$(location //tensorflow/lite:tflite_exported_symbols.lds)",
],
"//tensorflow:windows": [],
"//conditions:default": [
"-Wl,-z,defs",
"-Wl,--version-script,$(location //tensorflow/lite:tflite_version_script.lds)",
],
}),
per_os_targets = True,
deps = [
":selectively_built_cc_lib",
"//tensorflow/lite:tflite_exported_symbols.lds",
"//tensorflow/lite:tflite_version_script.lds",
],
)
नया टारगेट इस तरह बनाया जा सकता है:
bazel build -c opt --cxxopt=--std=c++17 \
//tmp:tensorflowlite
Android के लिए (64-बिट के लिए android_arm को android_arm64 से बदलें):
bazel build -c opt --cxxopt=--std=c++17 --config=android_arm \
//tmp:tensorflowlite
Select TF ops वाले मॉडल के लिए, आपको यह शेयर की गई लाइब्रेरी भी बनानी होगी:
load(
"@org_tensorflow//tensorflow/lite/delegates/flex:build_def.bzl",
"tflite_flex_shared_library"
)
# Shared lib target for convenience, pulls in the standard set of TensorFlow
# ops and kernels. The output library name is platform dependent:
# - Linux/Android: `libtensorflowlite_flex.so`
# - Mac: `libtensorflowlite_flex.dylib`
# - Windows: `libtensorflowlite_flex.dll`
tflite_flex_shared_library(
name = "tensorflowlite_flex",
models = [
":model_one.tflite",
":model_two.tflite",
],
)
नया टारगेट इस तरह बनाया जा सकता है:
bazel build -c opt --cxxopt='--std=c++17' \
--config=monolithic \
--host_crosstool_top=@bazel_tools//tools/cpp:toolchain \
//tmp:tensorflowlite_flex
Android के लिए (64-बिट के लिए android_arm को android_arm64 से बदलें):
bazel build -c opt --cxxopt='--std=c++17' \
--config=android_arm \
--config=monolithic \
--host_crosstool_top=@bazel_tools//tools/cpp:toolchain \
//tmp:tensorflowlite_flex
Docker की मदद से LiteRT को चुनिंदा तौर पर बनाना
इस सेक्शन में यह माना गया है कि आपने अपने कंप्यूटर पर Docker इंस्टॉल कर लिया है. साथ ही, आपने LiteRT Dockerfile को यहां से डाउनलोड कर लिया है.
ऊपर दी गई Dockerfile डाउनलोड करने के बाद, docker इमेज बनाई जा सकती है. इसके लिए, यह कमांड चलाएं:
docker build . -t tflite-builder -f tflite-android.Dockerfile
Android प्रोजेक्ट के लिए AAR फ़ाइलें बनाना
Docker के साथ बनाने के लिए, स्क्रिप्ट डाउनलोड करें. इसके लिए, यह कमांड चलाएं:
curl -o build_aar_with_docker.sh \
https://raw.githubusercontent.com/tensorflow/tensorflow/master/tensorflow/lite/tools/build_aar_with_docker.sh &&
chmod +x build_aar_with_docker.sh
इसके बाद, मॉडल फ़ाइल के पाथ इस तरह देकर, कस्टम LiteRT AAR बनाया जा सकता है.
sh build_aar_with_docker.sh \
--input_models=/a/b/model_one.tflite,/c/d/model_two.tflite \
--target_archs=x86,x86_64,arm64-v8a,armeabi-v7a \
--checkpoint=master \
[--cache_dir=<path to cache directory>]
checkpoint फ़्लैग, TensorFlow रेपो का एक कमिट, ब्रांच या टैग है. आपको लाइब्रेरी बनाने से पहले इसे चेकआउट करना होगा. डिफ़ॉल्ट रूप से, यह रिलीज़ की गई सबसे नई ब्रांच होती है. ऊपर दिए गए निर्देश से, LiteRT में पहले से मौजूद और कस्टम ऑप्स के लिए एएआर फ़ाइल tensorflow-lite.aar जनरेट होगी. साथ ही, आपकी मौजूदा डायरेक्ट्री में TensorFlow के चुने गए ऑप्स के लिए एएआर फ़ाइल tensorflow-lite-select-tf-ops.aar जनरेट होगी. हालांकि, यह ज़रूरी नहीं है.
--cache_dir, कैश मेमोरी की डायरेक्ट्री के बारे में बताता है. अगर यह विकल्प नहीं दिया जाता है, तो स्क्रिप्ट, कैश मेमोरी के लिए मौजूदा वर्किंग डायरेक्ट्री में bazel-build-cache नाम की डायरेक्ट्री बनाएगी.
प्रोजेक्ट में AAR फ़ाइलें जोड़ना
AAR फ़ाइलें जोड़ने के लिए, AAR को सीधे अपने प्रोजेक्ट में इंपोर्ट करें या कस्टम AAR को अपने लोकल Maven रिपॉज़िटरी में पब्लिश करें. ध्यान दें कि अगर आपने tensorflow-lite-select-tf-ops.aar जनरेट किया है, तो आपको इसके लिए भी AAR फ़ाइलें जोड़नी होंगी.
iOS के लिए चुनिंदा बिल्ड
कृपया स्थानीय तौर पर बनाना सेक्शन देखें. इसमें, बिल्ड एनवायरमेंट सेट अप करने और TensorFlow वर्कस्पेस को कॉन्फ़िगर करने का तरीका बताया गया है. इसके बाद, iOS के लिए चुनिंदा बिल्ड स्क्रिप्ट का इस्तेमाल करने के लिए, गाइड देखें.