खास जानकारी
डिवाइस पर मौजूद मशीन लर्निंग (ओडीएमएल) ऐप्लिकेशन के लिए मॉडल डिप्लॉय करते समय, इसलिए, आपको मोबाइल डिवाइसों में उपलब्ध सीमित मेमोरी के बारे में जानकारी होनी चाहिए. मॉडल बाइनरी साइज़, मॉडल. LiteRT की मदद से, मॉडल बाइनरी साइज़ को कम किया जा सकता है. इसके लिए, चुनिंदा बिल्ड. चुनिंदा बिल्ड आपके मॉडल सेट में इस्तेमाल न होने वाली कार्रवाइयों को छोड़ देते हैं और एक ऐसी छोटी लाइब्रेरी बनाएं जिसमें सिर्फ़ रनटाइम और सेशन के लिए, ज़रूरी ऑपरेटर आपके मोबाइल डिवाइस पर चलने वाला मॉडल चुनें.
चुनिंदा बिल्ड नीचे दिए गए तीन ऑपरेशन लाइब्रेरी पर लागू होता है.
नीचे दी गई टेबल में, कुछ सामान्य इस्तेमाल के लिए चुनिंदा बिल्ड के असर के बारे में बताया गया है मामले:
मॉडल का नाम | डोमेन | टारगेट आर्किटेक्चर | एएआर फ़ाइल का(के) साइज़ |
---|---|---|---|
Mobilenet_1.0_224(float) | इमेज की कैटगरी तय करना | Armeabi-v7a | tensorflow-lite.aar (296,635 बाइट) |
आर्म64-v8a | tensorflow-lite.aar (382,892 बाइट) | ||
मसाला | साउंड पिच निकालने की सुविधा | Armeabi-v7a | tensorflow-lite.aar (375,813 बाइट) tensorflow-lite-select-tf-ops.aar (1,676,380 बाइट) |
आर्म64-v8a | tensorflow-lite.aar (421,826 बाइट) tensorflow-lite-select-tf-ops.aar (2,298,630 बाइट) |
||
i3d-काइनेटिक्स-400 | वीडियो की कैटगरी तय करने वाला मॉडल | Armeabi-v7a | tensorflow-lite.aar (240,085 बाइट) tensorflow-lite-select-tf-ops.aar (1,708,597 बाइट) |
आर्म64-v8a | tensorflow-lite.aar (273,713 बाइट) tensorflow-lite-select-tf-ops.aar (2,339,697 बाइट) |
Basel के साथ LiteRT को चुनिंदा तरीके से बनाएं
इस सेक्शन में यह माना जाता है कि आपने TensorFlow के सोर्स कोड डाउनलोड कर लिए हैं और लोकल डेवलपमेंट के बारे में बताओ एनवायरमेंट से बेज़ल.
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
ऊपर दिए गए निर्देश से AAR फ़ाइल bazel-bin/tmp/tensorflow-lite.aar
जनरेट होगी
LiteRT बिल्ट-इन और कस्टम ऑपरेशन के लिए; और वैकल्पिक रूप से, ऐरो जनरेट करता है
फ़ाइल bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar
, अगर आपके मॉडल में शामिल है
TensorFlow ऑपरेशन चुनें. ध्यान दें कि इससे "मोटा" बनता है कई अलग-अलग तरह के एएआर
आर्किटेक्चर; अगर आपको सभी की ज़रूरत नहीं है, तो ऐसे सबसेट का इस्तेमाल करें जो
डिप्लॉयमेंट एनवायरमेंट की सूची में शामिल करें.
कस्टम ऑपरेशन की मदद से बनाएं
अगर आपने अपनी ज़रूरत के हिसाब से ऑपरेशन वाले 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 के रेपो में मौजूद होनी चाहिए.
बेहतर इस्तेमाल: बेज़ल के लिए पसंद के मुताबिक बनाए गए नियम
अगर आपके प्रोजेक्ट में Basel का इस्तेमाल किया जा रहा है और आपको अपनी पसंद के मुताबिक 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++ शेयर किए गए ऑब्जेक्ट बनाने हैं, तो तो नीचे दिए गए चरणों का पालन करें:
रूट पर दिए गए निर्देश को चलाकर, कुछ समय के लिए BUILD फ़ाइल बनाएं TensorFlow सोर्स कोड की डायरेक्ट्री:
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 के लिए (android_arm
को 64-बिट के लिए 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 के लिए (android_arm
को 64-बिट के लिए android_arm64
से बदलें):
bazel build -c opt --cxxopt=--std=c++17 --config=android_arm \
//tmp:tensorflowlite
चुनिंदा TF ऑपरेशन वाले मॉडल के लिए, आपको नीचे दी गई चीज़ें भी बनानी होंगी शेयर लाइब्रेरी:
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 के लिए (android_arm
को 64-बिट के लिए 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 रेपो का टैग, ब्रांच या टैग है
आपको लाइब्रेरी बनाने से पहले चेकआउट करना हो; डिफ़ॉल्ट रूप से यह सबसे नया होता है
रिलीज़ ब्रांच. ऊपर दिए गए निर्देश से AAR फ़ाइल जनरेट होगी
LiteRT बिल्ट-इन और कस्टम ऑपरेशन के लिए tensorflow-lite.aar
. ज़रूरी नहीं है
चुनिंदा TensorFlow ऑपरेशन के लिए AAR फ़ाइल tensorflow-lite-select-tf-ops.aar
आपकी मौजूदा डायरेक्ट्री.
--कैश मेमोरी में, कैश मेमोरी में सेव की गई डायरेक्ट्री को चुना जा सकता है. अगर यह पैरामीटर उपलब्ध नहीं कराया जाता है, तो स्क्रिप्ट
इसके लिए मौजूदा काम करने वाली डायरेक्ट्री के तहत bazel-build-cache
नाम की एक डायरेक्ट्री बनाएं
कैश मेमोरी.
प्रोजेक्ट में AAR फ़ाइलें जोड़ें
AAR फ़ाइलें जोड़ने के लिए, सीधे AAR को अपने
या पब्लिश करके
आपके स्थानीय Maven के लिए कस्टम AAR
डेटा स्टोर करने की जगह. नोट जोड़ें
आपको tensorflow-lite-select-tf-ops.aar
के लिए AAR फ़ाइलें इस तौर पर जोड़नी होंगी
अच्छी तरह से जनरेट किया जा सकता है.
iOS के लिए चुनिंदा बिल्ड
सेट करने के लिए कृपया स्थानीय तौर पर बिल्डिंग सेक्शन देखें बिल्ड एनवायरमेंट को तैयार करें और TensorFlow के फ़ाइल फ़ोल्डर को कॉन्फ़िगर करें. इसके बाद, चुनने के तरीके का इस्तेमाल करने के लिए गाइड iOS के लिए बिल्ड स्क्रिप्ट.