LiteRT और TensorFlow ऑपरेटर के साथ काम करता है

आपके मॉडल में इस्तेमाल किए गए मशीन लर्निंग (एमएल) ऑपरेटर, TensorFlow मॉडल को LiteRT फ़ॉर्मैट में बदलने की प्रोसेस पर असर डाल सकते हैं. LiteRT कन्वर्टर, सामान्य अनुमान मॉडल में इस्तेमाल होने वाली TensorFlow की कुछ ही कार्रवाइयों के साथ काम करता है. इसका मतलब है कि हर मॉडल को सीधे तौर पर बदला नहीं जा सकता. कन्वर्टर टूल की मदद से, अतिरिक्त ऑपरेटर शामिल किए जा सकते हैं. हालांकि, इस तरह से मॉडल को कन्वर्ट करने के लिए, आपको LiteRT रनटाइम एनवायरमेंट में बदलाव करना होगा. इसका इस्तेमाल मॉडल को एक्ज़ीक्यूट करने के लिए किया जाता है. इससे, रनटाइम डिप्लॉयमेंट के स्टैंडर्ड विकल्पों का इस्तेमाल करने की आपकी क्षमता सीमित हो सकती है. जैसे, Google Play services.

LiteRT Converter को मॉडल स्ट्रक्चर का विश्लेषण करने और ऑप्टिमाइज़ेशन लागू करने के लिए डिज़ाइन किया गया है, ताकि इसे सीधे तौर पर काम करने वाले ऑपरेटरों के साथ इस्तेमाल किया जा सके. उदाहरण के लिए, आपके मॉडल में मौजूद एमएल ऑपरेटर के आधार पर, कनवर्टर उन ऑपरेटर को हटा या मर्ज कर सकता है, ताकि उन्हें LiteRT के समकक्ष ऑपरेटर पर मैप किया जा सके.

जिन कार्रवाइयों के लिए सुविधा उपलब्ध है उनके लिए भी, कभी-कभी इस्तेमाल के खास पैटर्न की ज़रूरत होती है, ताकि परफ़ॉर्मेंस बेहतर हो सके. LiteRT के साथ इस्तेमाल किया जा सकने वाला TensorFlow मॉडल बनाने का तरीका समझने के लिए, यह जानना ज़रूरी है कि कार्रवाइयों को कैसे बदला और ऑप्टिमाइज़ किया जाता है. साथ ही, इस प्रोसेस की सीमाएं क्या हैं.

ये ऑपरेटर इस्तेमाल किए जा सकते हैं

LiteRT में पहले से मौजूद ऑपरेटर, TensorFlow कोर लाइब्रेरी का हिस्सा हैं. आपके TensorFlow मॉडल में, कंपोज़िट ऑपरेटर या आपके तय किए गए नए ऑपरेटर के तौर पर कस्टम ऑपरेटर भी शामिल हो सकते हैं. नीचे दिए गए डायग्राम में, इन ऑपरेटर के बीच के संबंध दिखाए गए हैं.

एमएल मॉडल ऑपरेटर की इस रेंज में, तीन तरह के मॉडल हैं. ये मॉडल, कन्वर्ज़न प्रोसेस के साथ काम करते हैं:

1. ऐसे मॉडल जिनमें सिर्फ़ LiteRT का पहले से मौजूद ऑपरेटर शामिल है. (सुझाया गया)
2. ऐसे मॉडल जिनमें ऑपरेटर पहले से मौजूद होते हैं और TensorFlow कोर ऑपरेटर चुने जाते हैं.
3. ऐसे मॉडल जिनमें बिल्ट-इन ऑपरेटर, TensorFlow कोर ऑपरेटर, और/या कस्टम ऑपरेटर शामिल हों.

अगर आपके मॉडल में सिर्फ़ ऐसे ऑपरेशन शामिल हैं जो LiteRT के साथ मूल रूप से काम करते हैं, तो आपको इसे बदलने के लिए किसी अन्य फ़्लैग की ज़रूरत नहीं है. हमारा सुझाव है कि आप इस पाथ का इस्तेमाल करें, क्योंकि इस तरह का मॉडल आसानी से कन्वर्ट हो जाएगा. साथ ही, इसे डिफ़ॉल्ट LiteRT रनटाइम का इस्तेमाल करके ऑप्टिमाइज़ करना और चलाना आसान है. आपके पास अपने मॉडल को डिप्लॉय करने के लिए, Google Play services जैसे ज़्यादा विकल्प भी हैं. LiteRT कन्वर्टर गाइड की मदद से, शुरू किया जा सकता है. बिल्ट-इन ऑपरेटर की सूची के लिए, LiteRT ऑपरेशंस पेज देखें.

अगर आपको कोर लाइब्रेरी से कुछ TensorFlow ऑपरेशन शामिल करने हैं, तो आपको कन्वर्ज़न के समय यह जानकारी देनी होगी. साथ ही, यह पक्का करना होगा कि आपके रनटाइम में वे ऑपरेशन शामिल हों. ज़्यादा जानकारी के लिए, TensorFlow ऑपरेटर चुनना विषय पढ़ें.

जब भी हो सके, अपने बदले गए मॉडल में कस्टम ऑपरेटर शामिल करने के आखिरी विकल्प का इस्तेमाल न करें. कस्टम ऑपरेटर ऐसे ऑपरेटर होते हैं जिन्हें कई प्रिमिटिव TensorFlow कोर ऑपरेटर को मिलाकर बनाया जाता है या पूरी तरह से नया ऑपरेटर बनाया जाता है. कस्टम ऑपरेटर को बदलने पर, वे LiteRT की बिल्ट-इन लाइब्रेरी के बाहर की डिपेंडेंसी का इस्तेमाल करके, पूरे मॉडल का साइज़ बढ़ा सकते हैं. अगर कस्टम ऑप्स को खास तौर पर मोबाइल या डिवाइस डिप्लॉयमेंट के लिए नहीं बनाया गया है, तो सर्वर एनवायरमेंट की तुलना में, संसाधन की कमी वाले डिवाइसों पर डिप्लॉय करने पर, परफ़ॉर्मेंस खराब हो सकती है. आखिर में, कस्टम ऑपरेटर के लिए आपको मॉडल रनटाइम एनवायरमेंट में बदलाव करना होगा. ठीक वैसे ही जैसे TensorFlow Core के कुछ ऑपरेटर शामिल करने के लिए करना होता है. इससे आपको स्टैंडर्ड रनटाइम सेवाओं का फ़ायदा नहीं मिल पाता. जैसे, Google Play services.

इस तरह के कोड काम करते हैं

LiteRT की ज़्यादातर कार्रवाइयां, फ़्लोटिंग-पॉइंट (float32) और क्वांटाइज़्ड (uint8, int8) इन्फ़रेंस, दोनों को टारगेट करती हैं. हालांकि, कई कार्रवाइयां अब तक tf.float16 और स्ट्रिंग जैसे अन्य टाइप के लिए उपलब्ध नहीं हैं.

ऑपरेशंस के अलग-अलग वर्शन इस्तेमाल करने के अलावा, फ़्लोटिंग-पॉइंट और क्वांटाइज़ किए गए मॉडल के बीच एक और अंतर है. यह अंतर, उन्हें बदलने के तरीके से जुड़ा है. क्वांटाइज़्ड कन्वर्ज़न के लिए, टेंसर की डाइनैमिक रेंज की जानकारी ज़रूरी होती है. इसके लिए, मॉडल ट्रेनिंग के दौरान "फ़ेक-क्वांटाइज़ेशन" की ज़रूरत होती है. साथ ही, कैलिब्रेशन डेटा सेट के ज़रिए रेंज की जानकारी मिलती है या "ऑन-द-फ़्लाई" रेंज का अनुमान लगाया जाता है. ज़्यादा जानकारी के लिए, क्वांटाइज़ेशन देखें.

सीधे तौर पर होने वाले कन्वर्ज़न, लगातार फ़ोल्डिंग और फ़्यूज़िंग

LiteRT, TensorFlow की कई कार्रवाइयों को प्रोसेस कर सकता है. भले ही, उनके लिए कोई सीधा विकल्प उपलब्ध न हो. ऐसा उन कार्रवाइयों के लिए होता है जिन्हें ग्राफ़ से आसानी से हटाया जा सकता है (tf.identity), जिन्हें टेंसर से बदला जा सकता है (tf.placeholder) या जिन्हें ज़्यादा जटिल कार्रवाइयों में जोड़ा जा सकता है (tf.nn.bias_add). कभी-कभी, इन प्रोसेस में से किसी एक के ज़रिए, साथ काम करने वाली कुछ कार्रवाइयों को भी हटाया जा सकता है.

यहां TensorFlow के उन ऑपरेशनों की सूची दी गई है जिन्हें आम तौर पर ग्राफ़ से हटा दिया जाता है. ध्यान दें कि इस सूची में पूरी जानकारी नहीं है. इस तरह के और भी उदाहरण हो सकते हैं:

• tf.add
• tf.debugging.check_numerics
• tf.constant
• tf.div
• tf.divide
• tf.fake_quant_with_min_max_args
• tf.fake_quant_with_min_max_vars
• tf.identity
• tf.maximum
• tf.minimum
• tf.multiply
• tf.no_op
• tf.placeholder
• tf.placeholder_with_default
• tf.realdiv
• tf.reduce_max
• tf.reduce_min
• tf.reduce_sum
• tf.rsqrt
• tf.shape
• tf.sqrt
• tf.square
• tf.subtract
• tf.tile
• tf.nn.batch_norm_with_global_normalization
• tf.nn.bias_add
• tf.nn.fused_batch_norm
• tf.nn.relu
• tf.nn.relu6

एक्सपेरिमेंट के तौर पर उपलब्ध कार्रवाइयां

यहां दी गई LiteRT कार्रवाइयां मौजूद हैं, लेकिन कस्टम मॉडल के लिए तैयार नहीं हैं:

• CALL
• CONCAT_EMBEDDINGS
• CUSTOM
• EMBEDDING_LOOKUP_SPARSE
• HASHTABLE_LOOKUP
• LSH_PROJECTION
• SKIP_GRAM
• SVDF