Google Play services में ML Kit और LiteRT की मदद से, उपयोगकर्ता के डिवाइस पर इंटेलिजेंस का इस्तेमाल करना

सभी को नमस्ते.

हम बातचीत शुरू करने वाले हैं.

इसलिए, जब लोग आज "उपयोगकर्ता के डिवाइस पर मौजूद एआई" कहते हैं, तो उनका मतलब अक्सर एलएलएम से होता है.

आज आपने Gemini Nano के बारे में कई बातें सुनीं. इनमें ML Kit, Firebase, और Google के कई अन्य प्रॉडक्ट के बारे में बताया गया.

यह सेशन, क्लासिकल मशीन लर्निंग और आपके मॉडल के बारे में है.

शायद आपने आज इसका इस्तेमाल कुछ बार किया हो, लेकिन आपको इसके बारे में पता न हो.

ऐसे किसी भी ऐप्लिकेशन के बारे में सोचें जिसमें आपने बैकग्राउंड को धुंधला किया हो, बारकोड स्कैनर का इस्तेमाल किया हो या इमेज में बदलाव करने की सुविधा का इस्तेमाल किया हो.

इनमें से ज़्यादातर काम क्लासिकल एमएल पर आधारित होते हैं. आम तौर पर, ये उपयोगकर्ता के डिवाइस पर ही काम करते हैं.

अगर आपने कभी अपने ऐप्लिकेशन या APK में इनमें से कोई सुविधा जोड़ी है, तो आपको अक्सर इस दुविधा का सामना करना पड़ा होगा: क्या मुझे टर्नकी एपीआई का इस्तेमाल करना चाहिए या अपना मॉडल इस्तेमाल करना चाहिए?

इससे मेरे ऐप्लिकेशन के साइज़ पर क्या असर पड़ेगा?

आज आपको पता चलेगा कि आपको टर्नकी या अपना मॉडल लाने में से किसी एक को चुनने की ज़रूरत नहीं है.

एक ही लीन रनटाइम की मदद से, दोनों काम किए जा सकते हैं.

मेरा नाम चिंतन पारिख है.

मैं LiteRT का प्रॉडक्ट मैनेजर हूं. मेरे साथ फ़र्गस हैं, जो Android एमएल सेवाओं के इंजीनियरिंग लीड हैं.

नमस्ते.

आखिर में, आपको पता चलेगा कि हर कैमरा फ़्रेम पर दो मॉडल चलाने वाला ऐप्लिकेशन कैसे बनाया जा सकता है. यह ऐप्लिकेशन, करीब 30 फ़्रेम प्रति सेकंड की स्पीड से काम करेगा.

इस बातचीत के चार हिस्से हैं.

पहले हिस्से में, हम Google के उपयोगकर्ता के डिवाइस पर मौजूद एआई (AI) समाधानों के बारे में बात करेंगे. इनमें क्लासिकल एमएल, यानी कि ML Kit और LiteRT पर फ़ोकस किया जाएगा.

दूसरा, हम LiteRT और Play सेवाओं में हुए नए बदलावों के बारे में भी जानेंगे.

इसमें LiteRT के नए CompiledModel एपीआई और इसके साथ काम करने वाले डिवाइसों के बारे में भी बताया जाएगा.

तीसरा, हम आपको नया ऐप्लिकेशन बनाने का तरीका बताएंगे.

फ़र्गस, एक ही APK में ML Kit और कस्टम मॉडल की मदद से ऐप्लिकेशन बनाने के बारे में बताएंगे.

आखिर में, हम आपको एजेंट मोड का इस्तेमाल करके, किसी मौजूदा ऐप्लिकेशन को अपग्रेड करने का तरीका बताएंगे.

साथ ही, इस एजेंट की मदद से नया ऐप्लिकेशन भी बनाया जा सकता है.

ठीक है।

सबसे पहले, जानते हैं कि LiteRT क्या है?

LiteRT, Google का ऑन-डिवाइस इन्फ़्रेंस रनटाइम है. यह आपके मॉडल के लिए काम करता है.

यह उसी .tflite फ़ाइल फ़ॉर्मैट का इस्तेमाल करता है जिसका इस्तेमाल आपने पहले TensorFlow लाइट के साथ किया था.

इसे परफ़ॉर्मेंस को बेहतर बनाने के लिए फिर से डिज़ाइन किया गया है. साथ ही, यह कई फ़्रेमवर्क के साथ काम करता है.

इसका मतलब है कि PyTorch, TensorFlow, और JAX से मॉडल इंपोर्ट किए जा सकते हैं, ताकि उन्हें LiteRT के लिए फ़्लैट बफ़र फ़ॉर्मैट में बदला जा सके.

साल 2022 से, Google Play services में TensorFlow लाइट, कस्टम मॉडल के लिए Android का आधिकारिक उपयोगकर्ता के डिवाइस पर रनटाइम है.

आज इसे एक बड़ा अपग्रेड मिल रहा है. इस बातचीत में, हम इसी बारे में बात करेंगे.

इस अपग्रेड से, आपको LiteRT CompiledModel का नया एपीआई मिलेगा. इसमें जीपीयू अनुमान की नई और बेहतर सुविधा शामिल है. यह सुविधा, पहले के मुकाबले 1.4 गुना ज़्यादा तेज़ी से काम करेगी. साथ ही, इससे आपको छोटे साइज़ के APK वाले ऐप्लिकेशन बनाने में मदद मिलेगी.

तो फिर इसे Play सेवाओं के ज़रिए क्यों उपलब्ध कराया जाता है?

इसके कई फ़ायदे हैं. साथ ही, यह एक बड़ी समस्या है, जिसके बारे में मैंने कई लोगों से सुना है. इसमें ऐप्लिकेशन का साइज़ और एपीके ब्लोट एक बड़ी चुनौती बन रहा है, है न?

इसलिए, आपको कम रनटाइम मिलता है.

रनटाइम आपके APK में नहीं होता है. इसलिए, आपको थिन क्लाइंट पर निर्भर रहना पड़ता है. इससे आपके APK का साइज़ करीब आठ एमबी कम हो जाता है.

दूसरा फ़ायदा यह है कि यह असरदार है.

आपके पास रनटाइम की एक कॉपी है. इसलिए, LiteRT रनटाइम को सभी ऐप्लिकेशन के साथ शेयर किया जाता है.

इसलिए, अगर आपके पास कई ऐप्लिकेशन हैं, तो हर ऐप्लिकेशन से 8 एमबी स्टोरेज बचाया जा सकता है.

अगर आपको डिस्क में स्टोरेज बचाना है और ऐप्लिकेशन का साइज़ छोटा रखना है, तो यह तरीका बहुत काम का है.

दूसरा, इसे मैनेज किया जाता है.

Google, गड़बड़ियों को ठीक करने के लिए अपडेट भेजता है. साथ ही, जीपीयू ड्राइवर से जुड़ी समस्याओं को हल करता है, ताकि आपको कुछ न करना पड़े. इसके अलावा, सुरक्षा से जुड़े अन्य अपडेट भी अपने-आप होने वाले अपडेट के ज़रिए मिलते हैं.

जैसा कि मैंने बताया, जीपीयू की परफ़ॉर्मेंस पहले से बेहतर है. इसलिए, आपको 1.4 गुना ज़्यादा तेज़ जीपीयू मिलता है. हम इस बारे में भी ज़्यादा जानकारी देंगे.

साथ ही, हम पुराने Android डिवाइसों पर भी अपडेट भेज सकते हैं.

Play सेवाएं में LiteRT, साल 2016 के Android 7 और इसके बाद के सभी वर्शन के साथ काम करता है.

फ़र्गस आपको यह भी दिखाएंगे कि हम आने वाली स्लाइड में किन नए डिवाइसों पर इस सुविधा को उपलब्ध करा रहे हैं.

यह डिलीवरी व्हीकल है. अब अगले चरण, रनटाइम के बारे में बात करते हैं.

इसलिए, LiteRT नया नहीं है और यह एक्सपेरिमेंट के तौर पर उपलब्ध नहीं है.

फ़िलहाल, TensorFlow Lite और LiteRT का इस्तेमाल 2,50,000 से ज़्यादा ऐप्लिकेशन में किया जा रहा है.

आज के समय में, यह 3.8 अरब से ज़्यादा डिवाइसों पर काम करता है.

इसलिए, हो सकता है कि आप जिन ऐप्लिकेशन का इस्तेमाल कर रहे हों उनमें से कई ऐप्लिकेशन इसी पर काम करते हों और आपको इस बारे में पता न हो.

इसका मतलब है कि हर दिन 10 खरब से ज़्यादा अनुमान लगाए जाते हैं, है न?

इतने बड़े पैमाने पर, हमें चिपसेट से जुड़ी हर समस्या का सामना करना पड़ा है. हमने आरओएम या जीपीयू ड्राइवर से जुड़ी समस्याओं को हल किया है. साथ ही, हमारे पास आपके लिए एक समाधान है.

Google, LiteRT का इस्तेमाल अपने फ़्लैगशिप ऐप्लिकेशन के साथ-साथ, कई ऐप्लिकेशन, प्लैटफ़ॉर्म, और डिवाइसों पर भी करता है.

YouTube शॉर्ट वीडियो के इफ़ेक्ट, Meet में बैकग्राउंड सेगमेंटेशन, और फ़ोटो अनब्लर करने की सुविधा, कुछ ऐसे उदाहरण हैं जहां रीयल-टाइम वीडियो और इमेज जनरेट करने वाले बड़े मॉडल, LiteRT पर काम करते हैं.

यह भी बेहद ज़रूरी है, क्योंकि इस्तेमाल के उदाहरणों को उपयोगकर्ताओं के लिए दिलचस्प और आकर्षक बनाना बेहद ज़रूरी हो जाता है, है न?

इसलिए, यह वही रनटाइम है जिसे हमने इन फ़्लैगशिप सुविधाओं के लिए बेहतर बनाया है. यह आपको Play सेवाएं के ज़रिए मिलता है.

चलिए, इस बारे में भी बात करते हैं कि उपयोगकर्ता के डिवाइस पर ही एआई का इस्तेमाल क्यों करना चाहिए.

अगर आपके लिए इंतज़ार का समय, निजता, ऑफ़लाइन काम करना या कम लागत मायने रखती है, तो इसे ऑफ़लाइन चलाएं, है न?

इसकी और भी वजहें हो सकती हैं. हालांकि, उपयोगकर्ता के डिवाइस पर एआई मॉडल चलाने की कुछ सबसे अहम वजहें ये हैं.

उपयोगकर्ता के डिवाइस पर एआई मॉडल चलाना भी हमेशा मुफ़्त नहीं होता.

हालांकि, इसमें कुछ बारीकियां और चुनौतियां भी हैं.

इसलिए, हम इनमें से कुछ चुनौतियों पर भी बात करेंगे और आपके लिए आगे का रास्ता भी तय करेंगे, है न?

परफ़ॉर्मेंस: जैसा कि आपने पिछले ऐप्लिकेशन के कुछ उदाहरणों में देखा, इंतज़ार का समय और मेमोरी बजट हमेशा कम होता है, है न?

रीयल-टाइम वीडियो और ऑडियो के लिए, बेहतरीन परफ़ॉर्मेंस की ज़रूरत होती है.

इंटरैक्टिव सुविधाओं को आसान होने के साथ-साथ, तेज़ी से काम करने वाला भी होना चाहिए.

ऐसा न करने पर, उपयोगकर्ता का जुड़ाव कम हो जाता है.

हार्डवेयर में विविधता: अलग-अलग सीपीयू और जीपीयू कॉन्फ़िगरेशन वाले सैकड़ों एसओसी मौजूद हैं.

इन सभी के लिए कोड नहीं लिखा जा सकता, है न?

इनमें से किसी भी समस्या को कैसे हल किया जा सकता है?

APK का साइज़: नेटिव रनटाइम को बंडल करने से, हर डाउनलोड का साइज़ भी बड़ा हो जाता है. इससे आपकी कन्वर्ज़न रेट पर असर पड़ सकता है.

पसंद के मुताबिक बनाना: मॉडल को डिप्लॉय करने से पहले, मॉडल की ट्रेनिंग, क्वालिटी, और साइज़ बहुत ज़रूरी हैं.

इसलिए, डिवाइस पर काम करने वाला बेहतरीन ऐप्लिकेशन बनाना मुश्किल हो सकता है.

हालांकि, इन सभी स्थितियों में हम चाहते हैं कि प्लैटफ़ॉर्म आपके लिए काम करे, न कि आपको प्लैटफ़ॉर्म के लिए काम करना पड़े, है न?

Google के उपयोगकर्ता के डिवाइस पर पोर्टफ़ोलियो का मकसद, इन चुनौतियों को हल करना है. हम इस बारे में आगे बात करेंगे.

इसलिए, आज हम दो आसान समाधानों पर फ़ोकस करेंगे, ठीक है?

Play सेवाएं की मदद से, उपयोगकर्ता के डिवाइस पर मौजूद एआई को जोड़ने के दो आसान तरीके हैं.

पहला तरीका, ML Kit का इस्तेमाल करके टर्नकी पाथ है, है न?

ये इस्तेमाल के लिए तैयार विज़न और लैंग्वेज एपीआई हैं. इनके लिए, मशीन लर्निंग की सीमित जानकारी की ज़रूरत होती है. साथ ही, कई मॉडल उपलब्ध कराए जाते हैं और ये सभी Play सेवाएं के ज़रिए डिलीवर किए जाते हैं.

हम अगली स्लाइड में इनके कुछ उदाहरण भी देखेंगे.

कस्टम पाथ, LiteRT के ज़रिए.

LiteRT की मदद से, अपना मॉडल लाया जा सकता है. साथ ही, उसे सीपीयू और जीपीयू पर चलाया जा सकता है.

रनटाइम, Play सेवाएं से भी मिलता है.

इसलिए, यह आपके-- इसलिए, इसे अपने APK में बंडल न करें.

ये दोनों ही ज़रूरी हैं.

साथ ही, वे एक साथ मिलकर भी बेहतर तरीके से काम कर सकते हैं.

हम अगले कुछ मिनटों में यही बनाने वाले हैं.

सबसे पहले, आइए जानते हैं कि ML Kit में क्या-क्या शामिल है.

यहां बताया गया है कि ML Kit में कौन-कौनसी सुविधाएं पहले से मौजूद हैं.

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

हमारे पास विज़न, बारकोड, दस्तावेज़, टेक्स्ट, पोज़, और ऐसी कई सुविधाओं के लिए कवरेज है. साथ ही, अनुवाद, स्मार्ट जवाब, और इकाई निकालने जैसी भाषा के एपीआई भी हैं, है न?

सबसे अहम बात यह है कि विज़न और भाषा से जुड़े कई एपीआई, LiteRT के साथ काम करते हैं.

इसलिए, अगर ML Kit आपकी ज़रूरत के मुताबिक काम करता है, तो यहां से शुरुआत की जा सकती है.

अगर ऐसा नहीं होता है, तो आपके पास अपना मॉडल इस्तेमाल करने का विकल्प होता है.

यहां एक अहम बात यह है कि ML Kit और आपका कस्टम मॉडल, दो रनटाइम नहीं होंगे. जैसा कि मैंने बताया था.

इन्हें एक ही LiteRT के दो मुख्य दरवाज़ों की तरह समझें. LiteRT, बैकग्राउंड में काम करेगा.

इसलिए, LiteRT एक ऐसा Play रनटाइम होगा जो इन दोनों सुविधाओं को मैनेज करेगा.

इसलिए, अगर आपका ऐप्लिकेशन पहले से ही Play Store का इस्तेमाल करता है, तो ML Kit के लिए इसका इस्तेमाल करें.

इसके अलावा, हम LiteRT पाथ के बारे में भी बात करेंगे.

चलिए, LiteRT में हुए नए बदलावों के बारे में भी जानते हैं.

जैसा कि मैंने बताया, LiteRT, TensorFlow लाइट का ही एक बेहतर वर्शन है, है ना?

इसलिए, सबसे बड़ा सुधार यह है कि हमारे पास तेज़ जीपीयू है.

तेज़ जीपीयू, OpenCL और OpenGL के साथ काम करता है. साथ ही, यह मेटल बैकएंड के लिए भी क्रॉस-प्लैटफ़ॉर्म के साथ काम करता है.

इसलिए, ज़रूरत के हिसाब से इसका इस्तेमाल कई प्लैटफ़ॉर्म के लिए किया जा सकता है.

यह आसान भी है.

सीपीयू, जीपीयू, और एनपीयू की मदद से, तेज़ी से काम करने के लिए हमारे पास एक ही वर्कफ़्लो है.

फ़िलहाल, सीपीयू और जीपीयू, Play सेवाएं में मौजूद हैं. वहीं, एनपीयू को LiteRT के ज़रिए बंडल किया गया है. इस पर अभी काम चल रहा है.

इसका मतलब है कि पहले हर ऐक्सेलरेटर के लिए, डेलिगेट का सेटअप अलग-अलग होता था, है न?

अब आपको ऐसा सिर्फ़ एक बार करना होगा.

इसलिए, एक ऐसा एपीआई है जो सीपीयू पर अपने-आप वापस चला जाता है. साथ ही, आपको डेलिगेट सेटअप करने की ज़रूरत नहीं पड़ती.

साथ ही, आपके पास ऐक्सेलरेटर कॉल करने का विकल्प होता है. इससे, कम कोड के साथ इसे आसानी से मैनेज किया जा सकता है.

यह काफ़ी असरदार भी है. जैसा कि मैंने बताया, यह मॉडल कई प्लैटफ़ॉर्म पर काम करता है.

यह बहुत ज़रूरी है कि हम अपने काम में फ़्लेक्सिबिलिटी लाएं.

इसलिए, .tflite फ़ॉर्मैट में कोई बदलाव नहीं होता.

अगर आपके पास पहले से कोई ऐप्लिकेशन है, तो अब भी इस फ़ॉर्मैट का इस्तेमाल किया जा सकता है.

अगर कोई नया ऐप्लिकेशन बनाया जा रहा है, तो इस फ़ाइल फ़ॉर्मैट का फिर से इस्तेमाल किया जा सकता है.

दिलचस्प बात यह है कि हम Interpreter API के साथ भी काम करते हैं. यह पहले TensorFlow लाइट में हुआ करता था.

अगर आपको अलग-अलग चरणों में माइग्रेट करना है, तो Interpreter API का इस्तेमाल किया जा सकता है. यह नए LiteRT का भी हिस्सा है. इससे आपको माइग्रेट करने में आसानी होगी.

इसलिए, यह रनटाइम है.

आइए, इस बारे में बात करते हैं कि इसका इस्तेमाल करके क्या बनाया जा सकता है.

इसलिए, आज Android ऐप्लिकेशन ये सुविधाएं बना रहे हैं.

कैमरा इफ़ेक्ट, फ़ोटो एडिटिंग, स्मार्ट टाइपिंग, गेम, और अवतार जैसी सभी सुविधाएं, है न?

इनमें से कई ऐप्लिकेशन को रीयल-टाइम में काम करने की क्षमता की ज़रूरत होगी.

जीपीयू, सीधे कैमरे से फ़्रेम भेज रहा है. इसलिए, चीज़ों को तेज़ी से और रीयल-टाइम में प्रोसेस करना ज़रूरी होगा.

फ़ोटो में बदलाव करने वाले कुछ मॉडल भी ज़्यादा स्टोरेज का इस्तेमाल कर रहे हैं.

एआर/वीआर की सुविधाओं के साथ भी ऐसा ही है. आपने स्मार्ट ग्लास के कुछ डेमो में भी देखा होगा कि इनमें से कई सुविधाएं, LiteRT का इस्तेमाल करती हैं.

यह वही रनटाइम है जो अब Google की मुख्य सुविधाओं और Play services में भी इस्तेमाल किया जाता है. इसलिए, आपको अपने APK में कुछ भी बंडल किए बिना यह सब मिल जाता है.

चलिए, अब एक ऐप्लिकेशन बनाते हैं. फ़र्गस हमें इसका तरीका बताएंगे.

चलिए, ऐसा करते हैं.

धन्यवाद, चिंतन.

इसलिए, मैं Google Play services में LiteRT की नई सुविधाओं के बारे में थोड़ी जानकारी देने जा रहा हूं.

इसलिए, मॉडल बनाने से पहले, एक और खबर. आपने अभी जो कुछ भी देखा है वह सिर्फ़ फ़ोन पर ही नहीं, बल्कि Wear OS और Android Automotive OS पर भी काम करता है. ऐसा इसलिए, क्योंकि Play सेवाएं में LiteRT की सुविधा उपलब्ध है.

इसलिए, आपके पास अपनी स्मार्टवॉच या पहने जाने वाले अन्य डिवाइसों या कार में, डिवाइस पर मौजूद मॉडल चलाने का विकल्प होता है.

पहले, फ़ोन पर किसी ऐसे ऐप्लिकेशन का इस्तेमाल किया जा सकता था जो Wear के लिए कंपैनियन ऐप्लिकेशन होता था. हालांकि, अब इसे पहने जाने वाले डिवाइस पर ही चलाया जा सकता है. Android Automotive के लिए भी ऐसा किया जा सकता है.

इसलिए, आपके पास एक ही एपीआई और एक ही .tflite मॉडल है, लेकिन ज़्यादा प्लैटफ़ॉर्म हैं.

हर फ़ॉर्म फ़ैक्टर के लिए, अलग से लागू करने की ज़रूरत नहीं है. इन सभी अलग-अलग डिवाइसों के लिए, एक ही तरह से लागू किया जा सकता है.

Play सेवाएं के डिस्ट्रिब्यूशन पैराडाइम की खासियत यह है कि हम इसे पुराने डिवाइसों पर चलाने के लिए बैकपोर्ट कर सकते हैं.

इसलिए, Android Automotive OS के लिए, हम साल 2020 में रिलीज़ हुए Android 11 तक के वर्शन के साथ काम करते हैं. वहीं, Wear OS के लिए, हम Wear OS 4 और इसके बाद के वर्शन के साथ काम करते हैं.

ठीक है।

इसलिए, अब मैं दो अलग-अलग तरीकों के बारे में बात करने जा रहा हूं. पहला, नया ऐप्लिकेशन बनाना और दूसरा, किसी मौजूदा ऐप्लिकेशन को अपग्रेड करना.

इस बारे में हम आगे बात करेंगे.

इसलिए, मैं एक ऐसे ऐप्लिकेशन के उदाहरण से शुरुआत करूंगा जिसमें ML Kit के साथ-साथ, LiteRT पर चलने वाले कस्टम जीपीयू मॉडल का इस्तेमाल किया गया है.

इसके बाद, किसी मौजूदा ऐप्लिकेशन को अपग्रेड करने के लिए, तीन छोटे बदलाव करने होंगे. पहला, डिपेंडेंसी अपडेट करने के लिए Gradle में बदलाव करना होगा. दूसरा, Play सेवाएं में LiteRT को चालू करने के लिए, init में बदलाव करना होगा. तीसरा, Interpreter API से CompiledModel API पर स्विच करना होगा.

हालांकि, हम पहले नए ऐप्लिकेशन को लॉन्च करेंगे. ऐसा इसलिए, क्योंकि अपग्रेड करने के बाद आपको पता चलेगा कि आपको क्या मिलने वाला है.

इसलिए, नया ऐप्लिकेशन बनाना.

हम यह ऐप्लिकेशन बनाने जा रहे हैं.

इसमें लाइव कैमरा व्यू होगा, जिसमें आप साफ़ तौर पर दिखेंगी और बैकग्राउंड को आर्टिस्टिक स्टाइल मिलेगा.

इसलिए, हम कैमरे के फ़्रेम का इस्तेमाल करेंगे.

हम कैमरा फ़्रेम से ली गई इमेज को, ML Kit की सेल्फ़ी सेगमेंटेशन सुविधा की मदद से स्ट्रीम करेंगे.

यह ML Kit के मौजूदा टर्नकी एपीआई में से एक है.

इससे एक फ़ोरग्राउंड मास्क बनेगा. यह मास्क बताएगा कि इमेज में मौजूद कौनसे पिक्सल, इमेज में मौजूद व्यक्ति से जुड़े हैं.

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

हम इसे पूरे कैमरा फ़्रेम पर लागू करेंगे. हालांकि, हमें सिर्फ़ बैकग्राउंड वाले हिस्से की चिंता है, क्योंकि आखिर में हम ओरिजनल कैमरा फ़्रेम, मास्क, और स्टाइल वाले बैकग्राउंड को लेंगे. इसके बाद, हम उन्हें एक आसान लॉजिक के साथ जोड़ेंगे, ताकि हमारे पास एक कंपोज़िट फ़्रेम हो, जिसमें हमने सब्जेक्ट को रखा है और बैकग्राउंड में स्टाइल है.

इसलिए, हम चाहते हैं कि हमारे पास एक ऐसा एपीआई हो जो हमारे ऐप्लिकेशन को अलग बनाए. हम टर्नकी एपीआई का इस्तेमाल करते हैं, जहां वे मौजूद होते हैं. साथ ही, कस्टम एपीआई का इस्तेमाल करते हैं, जहां वे हमारे ऐप्लिकेशन को अलग बनाते हैं.

यह पहला हिस्सा है, जहां हम ML Kit के सेल्फ़ी सेगमेंटेशन एपीआई को कॉल करते हैं.

// 1. Configure and create segmenter client
val segmenter = Segmentation.getClient(
    SelfieSegmenterOptions.Builder()
        .setDetectorMode(
            SelfieSegmenterOptions.STREAM_MODE)
        .build())

// 2. Prepare image & run inference
fun processFrame(mediaImage: Image) {
  val image = InputImage.fromMediaImage(
      mediaImage, /* rotationDegrees= */ 0)
  segmenter.process(image)
      .addOnSuccessListener { mask -> … }
}

तो यह एक सामान्य एपीआई की तरह है, है न?

यह Android डेवलपर के लिए, सबसे ज़रूरी चीज़ों में से एक है.

इसके लिए, एपीआई के दस्तावेज़ देखें या Gemini से इसे बनाने के लिए कहें.

हालांकि, यह काफ़ी आसान है.

क्लाइंट बनाते समय, आपको कुछ विकल्प पास करने होंगे.

इस मामले में, हम स्ट्रीमिंग मोड तय कर रहे हैं, ताकि हम वीडियो फ़्रेम की स्ट्रीम को प्रोसेस कर सकें.

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

इनपुट के तौर पर, कैमरे से ली गई इमेज का इस्तेमाल किया जाता है.

और ये सभी एपीआई, रॉ टेंसर के बजाय ऐप्लिकेशन-लेवल के टाइप का इस्तेमाल करते हैं. इसलिए, आप वाकई बहुत हाई लेवल पर प्रोग्रामिंग कर रहे हैं और यह बहुत आसान है.

इसके लिए, दूसरे हिस्से यानी कस्टम मॉडल के लिए, हम PyTorch मॉडल का इस्तेमाल करेंगे.

मुझे लगता है कि चिंतन को यह Kaggle या Hugging Face जैसी किसी चीज़ से मिला है…

दाईं ओर.

हां, और या फिर आप अपनी खुद की फ़ाइलों को भी कन्वर्ट कर सकते हैं.

अपना मॉडल बनाया जा सकता है.

माफ़ करें, वापस जा रही हूँ.

हां, तो यह स्टैक कुछ ऐसा दिखता है.

PyTorch मॉडल को LiteRT मॉडल में बदला जा सकता है और क्वांटाइज़ किया जा सकता है.

इसके बाद, उसे अपने ऐप्लिकेशन के साथ अपनी पसंद के मुताबिक डिस्ट्रिब्यूट किया जा सकता है.

इसे ऐसेट के तौर पर ऐप्लिकेशन के साथ बंडल किया जा सकता है या अलग से डाउनलोड किया जा सकता है.

दोनों में से कोई भी तरीका इस्तेमाल किया जा सकता है.

इसके बाद, यह Play सेवाएं में LiteRT रनटाइम के ऊपर मौजूद होता है.

इसके बाद, सीपीयू पर ऑप्टिमाइज़ करने के लिए सीपीयू कर्नेल होते हैं. साथ ही, एमएल ड्रिफ़्ट, जीपीयू ऐक्सेलरेटर का नाम है.

हां, जैसा कि मैंने कहा, आपको TFLite मॉडल मिलता है. आप चाहें, तो मॉडल को खुद ट्रेन करें या कोई मौजूदा मॉडल ढूंढें. दोनों ही तरीके काम करते हैं.

PyTorch से कन्वर्ट करने के लिए, Python की कुछ ही लाइनों की ज़रूरत होती है.

import litert_torch

model = my_models.Stylizer().eval()

# Convert with torch.export under the hood
edge_model = litert_torch.convert(
    model, sample_inputs)
edge_model.export("stylizer_f32.tflite")

इसलिए, LiteRT-Torch को pip इंस्टॉल करें, litert_torch.convert को कॉल करें, उसे कुछ sample_inputs पास करें, जो रैंडम इनपुट हो सकते हैं, और TFLite फ़ाइल को एक्सपोर्ट करें.

अगर आपको ai-edge-torch के बारे में पता है, तो बता दें कि LiteRT-Torch इसका नया नाम है.

इसके बाद, क्वांटाइज़ेशन करना बहुत आसान है.

# Python
# previously ai_edge_quantizer
from litert_quantizer import quantizer, recipe

qt = quantizer.Quantizer("stylizer_f32.tflite")

# int8 weights, float activations
qt.load_quantization_recipe(
    recipe.dynamic_wi8_afp32())

qt.quantize().export_model("stylizer_int8.tflite")

LiteRT Quantizer से क्वांटाइज़र और रेसिपी इंपोर्ट करें.

क्वांटाइज़र बनाते समय, आपको ओरिजनल फ़्लोटिंग-पॉइंट मॉडल पास करना होता है. साथ ही, आपको एक रेसिपी पास करनी होती है. यह वह स्टैंडर्ड रेसिपी है जिसका इस्तेमाल हम जीपीयू के लिए करते हैं. इसमें 8-बिट के पूर्णांक वेट का इस्तेमाल किया जाता है, लेकिन ऐक्टिवेशन को 32-बिट के फ़्लोटिंग पॉइंट के तौर पर रखा जाता है.

इसके बाद, आपको सिर्फ़ quantize को कॉल करना होगा. फिर आउटपुट मॉडल को सेव करने के लिए, export_model को कॉल करना होगा.

इससे आपको एक क्वांटाइज़्ड मॉडल मिलेगा, जिसे इस्तेमाल किया जा सकता है. इसमें वैल्यू की संख्या कम होगी और यह ज़्यादा बेहतर तरीके से काम करेगा.

ठीक है, तो हां, CompiledModel एपीआई जीपीयू की वजह से ही यह इतना शानदार है.

जैसा कि चिंतन ने बताया, लेगसी TFLite जीपीयू की तुलना में, इसमें काफ़ी ज़्यादा स्पीड मिलती है.

यह संख्या, मॉडल के हिसाब से थोड़ी अलग हो सकती है. हालांकि, आम तौर पर यह 1.4 गुना होती है.

यह सीपीयू इन्फ़्रेंस से 10 गुना ज़्यादा तेज़ है. इसलिए, यह एक बड़ी कामयाबी है, है न?

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

इसलिए, यह एक असली इंसेंटिव है.

यह तेज़ी से कैसे काम करता है?

ठीक है, तो हम कई चीज़ों के लिए सहायता देते हैं. उदाहरण के लिए, एसिंक्रोनस तरीके से लागू करना, ताकि आप AHardwareBuffer को सीधे पास कर सकें या उस कैमरा रेंडर पाइपलाइन से OpenGL बफ़र को सीधे टेंसर बफ़र में पास कर सकें.

हम ज़ीरो-कॉपी ऑप्टिमाइज़ेशन की सुविधा देते हैं. इसलिए, जब आपको कम इंतज़ार के समय में चीज़ों को प्रोसेस करना हो, तो ऐसा किया जा सकता है. जैसे, जब आपको हर फ़्रेम को कुछ मिलीसेकंड में प्रोसेस करना हो, तब मेमोरी बफ़र को कॉपी करना भी एक मुश्किल काम हो सकता है.

इसलिए, रीयल-टाइम में काम करने वाले ऐसे ऐप्लिकेशन जिनके लिए आपको ज़ीरो-कॉपी ऑप्टिमाइज़ेशन का इस्तेमाल करना है, हम उसके लिए सहायता उपलब्ध कराते हैं.

इसके बाद, जैसा कि चिंतन ने बताया, यह एक क्रॉस-प्लैटफ़ॉर्म है. इसमें जीपीयू बैक एंड के तौर पर OpenGL, OpenCL, और Metal का इस्तेमाल किया जा सकता है.

आखिर में, एमएल ड्रिफ़्ट ऑप्टिमाइज़र एक ओपन-सोर्स है.

यह Apache लाइसेंस के तहत उपलब्ध है.

Google ने हाल ही में इसे ओपन-सोर्स किया है.

ठीक है. इसके बाद, यहां ऐप्लिकेशन का कोड है.

// Kotlin
// Build once, off the main thread.
private val model: CompiledModel =
    CompiledModel.create(
        context.assets,
        "stylizer_int8.tflite",
        // Simple GPU setup!
        CompiledModel.Options(Accelerator.GPU),
        environment
    )

// Reuse buffers across frames.
private val inputBuffers  = model.createInputBuffers()
private val outputBuffers = model.createOutputBuffers()

fun stylize(input: FloatArray): FloatArray {
    inputBuffers[0].writeFloat(input)
    model.run(inputBuffers, outputBuffers) // sync
    return outputBuffers[0].readFloat()
}

जैसा कि आप देख सकते हैं, यह काफ़ी छोटा और आसान है.

इसलिए, मॉडल को एक बार बनाएं और फिर उसे हर फ़्रेम में इस्तेमाल करें.

इसलिए, CompiledModel.create को .tflite फ़ाइल में पास किया जाता है.

आपको बस यह बताना होता है कि आपको जीपीयू पर चलाना है. इसके बाद, इनपुट और outputBuffers को बनाया जाता है.

इसके बाद, मुख्य लूप में, जहां हर फ़्रेम को प्रोसेस किया जा रहा है, वहां इनपुट और आउटपुट को पास करते हुए इस model.run को कॉल करें.

inputBuffers को लिखने के बाद, model.run को कॉल करें. इसके बाद, outputBuffers से पढ़ें.

ठीक है।

हां, और फिर अगर आप वहां सिर्फ़ जीपीयू की जानकारी देते हैं, तो यह जीपीयू पर चलेगा.

अगर आपने वहां सीपीयू और जीपीयू भी तय किया है, तो यह जीपीयू को चलाने की कोशिश करेगा.

अगर किसी वजह से जीपीयू उपलब्ध नहीं है, तो सीपीयू का इस्तेमाल किया जाएगा.

इसलिए, कुछ मामलों में सीपीयू फ़ॉलबैक आपके ऐप्लिकेशन के लिए काफ़ी असरदार नहीं हो सकता. ऐसे में, आपको सिर्फ़ जीपीयू का इस्तेमाल करना चाहिए.

आम तौर पर, आपको सीपीयू फ़ॉलबैक की ज़रूरत होती है.

ठीक है।

इसलिए, हमने इसे बंडल किए गए LiteRT के साथ बनाया है. यह फ़िलहाल Play सेवाएं का इस्तेमाल नहीं करता.

इसलिए, चलिए हम आपको Play सेवाओं में LiteRT इस्तेमाल करने का तरीका बताते हैं.

इसलिए, तीन बदलाव किए गए हैं: पहला बदलाव, डिपेंडेंसी में किया गया है.

// Easier with CompiledModel API: 3 steps

// 1. app/build.gradle: replace litert with play-services-litert
- implementation 'com.google.ai.edge.litert:litert:...'
+ implementation 'com.google.android.gms:play-services-litert:17.0.0'  // also pulls in litert-api

आपको अपनी Gradle फ़ाइल या किसी अन्य जगह पर, इस्तेमाल किए जा रहे बिल्ड सिस्टम में, Maven पैकेज की डिपेंडेंसी की जानकारी देने वाली जगह पर, बदलाव करना होगा.

साथ ही, litert डिपेंडेंसी या TensorFlow लाइट Maven पैकेज की किसी भी पुरानी डिपेंडेंसी को हटाकर, उन्हें play-services-litert से बदलें.

इससे litert-api पैकेज भी इंस्टॉल हो जाता है.

अब, अगर आपको कोई ऐसी मिडल लेयर लिखनी है जो सिर्फ़ LiteRT पर निर्भर हो, लेकिन उसे इस बात से कोई फ़र्क़ न पड़ता हो कि रनटाइम, ऐप्लिकेशन से आ रहा है या Play सेवाएं से, तो LiteRT API पर निर्भर रहा जा सकता है. साथ ही, एनवायरमेंट को इनपुट पैरामीटर के तौर पर लिया जा सकता है.

इसलिए, दूसरा चरण एनवायरमेंट पैरामीटर है.

यहां आपको डिपेंडेंसी इंजेक्शन देना होता है. इससे यह पता चलता है कि आपको Play सेवाएं LiteRT का इस्तेमाल करना है.

इसलिए, gms.litert.LiteRt को इंपोर्ट करें और शुरू करने वाले फ़ंक्शन को कॉल करें. साथ ही, कॉन्टेक्स्ट को पास करें, जो कि आपकी Android गतिविधि है.

// 2. Initialize the LiteRT Environment from Play services (context = your Activity)
- val environment = Environment.create(...)
+ import com.google.android.gms.litert.LiteRt
+ val environment = LiteRt.initialize(context).await()

// 3. Pass environment whenever you call CompiledModel.create

// That's it! The rest of your app uses the normal CompiledModel APIs from litert-api.

यह एक एसिंक्रोनस प्रोसेस है. इसलिए, आपको .await को कॉल करना होगा या बाकी प्रोसेस को कॉलबैक पर आधारित रखना होगा.

इसके बाद, एनवायरमेंट मिलने पर, CompiledModel.create को कॉल करते समय उस एनवायरमेंट को पास करें.

इससे, Play सेवाएं से Play सेवाएं LiteRT रनटाइम का इस्तेमाल किया जा सकेगा.

बस, हो गया.

इसका मतलब है कि आपके ऐप्लिकेशन का बाकी हिस्सा, LiteRT एपीआई के LiteRT CompiledModel एपीआई का ही इस्तेमाल करता है.

Play सेवाएं का इस्तेमाल करने के लिए, आपके अनुमान कोड के बाकी हिस्से में कोई बदलाव नहीं होता.

साथ ही, इस माइग्रेशन को धीरे-धीरे किया जा सकता है.

आपको यह काम एक साथ करने की ज़रूरत नहीं है. एक बार में एक कॉम्पोनेंट को माइग्रेट किया जा सकता है.

अगर आपका ऐप्लिकेशन बड़ा है, तो LiteRT का इस्तेमाल करने वाले हर कॉम्पोनेंट को माइग्रेट करना सही रहेगा. इसके बाद, एक-एक करके कॉम्पोनेंट को माइग्रेट किया जा सकता है और उनकी जांच की जा सकती है.

हालांकि, इसमें एक समस्या है. आपको सिर्फ़ साइज़ में कमी का फ़ायदा मिलता है. स्टोरेज में जगह की बचत सिर्फ़ तब होती है, जब बंडल किए गए रनटाइम पर आखिरी डिपेंडेंसी को हटा दिया जाता है.

अगर ऐसा है, तो आपको एक और बात का ध्यान रखना होगा. वह यह कि आपको Play सेवाएं में LiteRT और बंडल किए गए LiteRT के बीच ऑब्जेक्ट को मिक्स नहीं करना चाहिए.

इसलिए, अगर आपको Play सेवाओं में LiteRT से टेंसर, कंपाइल किए गए मॉडल या इंटरप्रेटर मिल रहे हैं, तो आपको उन्हें बंडल किए गए LiteRT को पास नहीं करना चाहिए. इसके उलट भी ऐसा नहीं करना चाहिए.

हालांकि, इन चीज़ों को मिक्स करने से भी काम बन जाता है.

ठीक है।

तो यह था नया ऐप्लिकेशन बनाने का तरीका.

अब मैं आपको किसी मौजूदा ऐप्लिकेशन को अपग्रेड करने का तरीका बताऊंगा.

इसलिए, हो सकता है कि आपके पास कोई ऐसा ऐप्लिकेशन हो जो Interpreter API का इस्तेमाल कर रहा हो.

इसे हम पुराना TFLite एपीआई कहते हैं. यह इंटरप्रेटर को मुख्य क्लास के तौर पर इस्तेमाल करता है.

बाईं ओर, Interpreter API का इस्तेमाल करके लिखा गया कोड है. दाईं ओर, नया CompiledModel एपीआई कोड है.

// Dependencies (Gradle):
// play-services-tflite-java and/or litert (bundled)

// Init
TfLite.initialize(context).await()

// Load
val interpreterOptions =
    InterpreterApi.Options().apply {
      runtime = TfLiteRuntime.FROM_SYSTEM_ONLY
    }

val interpreter =
    InterpreterApi.create(modelFile, interpreterOptions)

// Prepare inputs/outputs
val inputs = …
val outputs = …

// Execute
interpreter.run(inputs, outputs)

// Dependencies (Gradle):
// play-services-litert

// Init
val environment =
  LiteRt.initialize(context).await()

// Load
val modelOptions = CompiledModel.Options(Accelerator.CPU)

val model =
    CompiledModel.create(modelPath, modelOptions, environment)

// Prepare inputs/outputs
val inputBuffers = model.createInputBuffers()
val outputBuffers = model.createOutputBuffers()

// Execute
model.run(inputBuffers, outputBuffers

इसलिए, आपको सिर्फ़ TfLite.initialize को LiteRt.initialize में बदलना होगा. अब यह एक एनवायरमेंट दिखाता है.

इसके बाद, एनवायरमेंट को CompiledModel.create में पास करें.

इसलिए, यह एक छोटा बदलाव है. इससे APK का साइज़ नहीं बढ़ता.

अगली स्लाइड में, हम आपको जीपीयू की मदद से ऐसा करने का तरीका दिखाएंगे. यह सिर्फ़ एक और विकल्प है.

इसलिए, जीपीयू को चालू करने के लिए आपको इस अतिरिक्त कोड की ज़रूरत होगी.

// Dependencies (Gradle):
// play-services-tflite-java and/or litert (bundled)

// Init
val initOptions = TfLiteInitializationOptions.builder()
    .setEnableGpuDelegateSupport(true).build()
TfLite.initialize(context, initOptions).await()
val useGpu =
    TfLiteGpu.isGpuDelegateAvailable(context).await()

// Load
val interpreterOptions =
    InterpreterApi.Options().apply {
      runtime = TfLiteRuntime.FROM_SYSTEM_ONLY
    }
if (useGpu) {
    interpreterOptions.addDelegateFactory(
        GpuDelegateFactory());
}
val interpreter =
    InterpreterApi.create(modelFile, interpreterOptions)

// Prepare inputs/outputs
val inputs = …
val outputs = …

// Execute
interpreter.run(inputs, outputs)

// Dependencies (Gradle):
// play-services-litert

// Init
val initOptions = LiteRtInitializationOptions.builder()
    .setEnableGpu(true).build()
val environment = LiteRt.initialize(context, initOptions).await()

// Load
val modelOptions =
    CompiledModel.Options(Accelerator.CPU, Accelerator.GPU)

val model =
    CompiledModel.create(modelPath, modelOptions, environment)

// Prepare inputs/outputs
val inputBuffers = model.createInputBuffers()
val outputBuffers = model.createOutputBuffers()

// Execute
model.run(inputBuffers, outputBuffers)

जैसा कि आपने देखा, जीपीयू को चालू करने के लिए नए एपीआई में मौजूद कोड, पहले के कोड की तुलना में थोड़ा आसान है.

इसलिए, LiteRT को शुरू करने के विकल्पों में setEnableGpu को किया गया पहला कॉल, जिसे आपने LiteRt.initialize को पास किया है, उससे जीपीयू ऐक्सेलरेटर का कोड आपके ऐप्लिकेशन में लोड हो जाएगा.

इसके बाद, modelOptions बनाते समय और उन्हें CompiledModel.create को पास करते समय, आपको यह बताना होगा कि किसी मॉडल के लिए किस ऐक्सेलरेटर का इस्तेमाल किया जाएगा. इसके अलावा, आपको यह भी बताना होगा कि आपको अन्य मॉडल को सिर्फ़ जीपीयू पर चलाना है या सीपीयू फ़ॉलबैक के साथ जीपीयू पर चलाना है या सिर्फ़ सीपीयू पर चलाना है.

ठीक है।

हां, जैसा कि आपने देखा, नए एपीआई की मदद से जीपीयू को चालू करना बहुत आसान है.

तो आपको असल में क्या फ़ायदा मिलता है?

चिंतन आपको इस बारे में बताएंगे.

ठीक है।

ठीक है, धन्यवाद फ़र्गस.

तो चलिए, बात करते हैं कि इन सभी से हमें क्या मिलता है?

आपको याद होगा कि हमने एक ऐप्लिकेशन बनाने की बात कही थी. चलिए, देखते हैं कि हमने असल में क्या बनाया है.

तो, यह मैं हूं. हमने यहां जो किया है वह यह है कि हमने मुझे ढूंढने के लिए ML Kit का इस्तेमाल किया है. इसलिए, सेगमेंटेशन ML Kit जैसे टर्नकी एपीआई से किया जा रहा है.

इसलिए, मैं बस वहां अपना सिर ढूंढ रहा हूं.

इसके बाद, LiteRT बैकग्राउंड को पेंट करने के लिए, स्टाइल ट्रांसफ़र जैसे किसी दूसरे मॉडल की स्टाइल का इस्तेमाल करता है.

इसके अलावा, हमने आपको जो अन्य फ़ायदे बताए हैं उनमें करीब 8 एमबी स्टोरेज की बचत शामिल है. अब आपके पास एक रनटाइम है, जिसका इस्तेमाल आपके सभी ऐप्लिकेशन के बीच किया जाता है या कम से कम यहां शेयर किए गए ऐप्लिकेशन के बीच किया जाता है. साथ ही, आपको अपने-आप होने वाले अपडेट मिलते हैं. इसके अलावा, आपके पास एक तेज़ जीपीयू भी है जो आपको करीब 30 फ़्रेम प्रति सेकंड की स्पीड देता है. यह स्पीड, रीयल-टाइम में काम करने वाली चीज़ों के लिए ज़रूरी है, ताकि उपयोगकर्ता को बेहतर अनुभव मिल सके.

अच्छी बात यह है कि आपको यह सब मैन्युअल तरीके से करने की ज़रूरत नहीं है.

हमने Android में एक नई स्किल भी लॉन्च की है. यह Android LiteRT स्किल है, जिसे हमने पब्लिश किया है. यह उपयोगकर्ता के डिवाइस पर मौजूद एमएल को कुछ ही मिनटों में अपग्रेड कर देती है.

इसलिए, इसके साथ कुछ चीज़ें की जा सकती हैं: किसी मौजूदा ऐप्लिकेशन को अपग्रेड किया जा सकता है, नए ऐप्लिकेशन को स्कैफ़ोल्ड किया जा सकता है. साथ ही, Play सेवाओं के इस नए इंटिग्रेशन का इस्तेमाल करने के लिए, अपने ऐप्लिकेशन को अपग्रेड भी किया जा सकता है.

इसलिए, ये सभी सुविधाएं उपलब्ध हैं.

यह लिंक स्लाइड और GitHub पर मौजूद है. साथ ही, यह हमारे दस्तावेज़ और ब्लॉग में भी दिखेगा.

हां, यह उन लोगों के लिए भी मददगार होना चाहिए जो जल्द ही बदलाव करना चाहते हैं.

इसके बाद, फ़र्गस हमें बताएंगे कि आगे क्या होने वाला है.

इसलिए, हम LiteRT के साथ उपयोगकर्ता के डिवाइस पर मौजूद एआई के लिए प्रतिबद्ध हैं.

हम जीपीयू ऐक्सेलरेटर और मॉडल कवरेज को बेहतर बनाने के लिए लगातार निवेश कर रहे हैं. साथ ही, LiteRT 2.x के लिए नियमित तौर पर अपडेट उपलब्ध करा रहे हैं. ये अपडेट, ओपन सोर्स बंडल किए गए LiteRT और Play सेवाएं LiteRT Maven पैकेज, दोनों के लिए उपलब्ध हैं. Play सेवाएं LiteRT Maven पैकेज, Play सेवाएं में LiteRT है.

हम पुराने सिस्टम के साथ काम करने की सुविधा भी उपलब्ध कराते रहेंगे.

Play services रनटाइम, पुराने एसडीके की मदद से बनाए गए ऐप्लिकेशन के साथ काम करता रहेगा.

हाँ।

यह हमारे उपयोगकर्ताओं के लिए बहुत ज़रूरी है और हमारे लिए भी.

LiteRT 1.x SDK टूल अब मेंटेनेंस मोड में हैं. इसलिए, इनमें सिर्फ़ सुरक्षा से जुड़ी ज़रूरी गड़बड़ियां ठीक की जाती हैं.

साथ ही, NNAPI को बंद किया जा रहा है. इसे हमने 2024 में बंद कर दिया था. इसे 2027 से हटाया जा सकता है.

इसलिए, अगर आपने NNAPI का इस्तेमाल किया है, तो कृपया बंडल किए गए LiteRT के साथ जीपीयू ऐक्सेलरेटर या एनपीयू ऐक्सेलरेटर का इस्तेमाल करें.

ठीक है।

हाँ।

इसलिए, जितनी जल्दी हो सके 2.x और CompiledModel पर माइग्रेट करें. इससे आपको बाद में कम काम करना पड़ेगा.

इसलिए, तीन चीज़ें ध्यान में रखें.

इसलिए, कॉन्टेंट बनाएं.

ML Kit का इस्तेमाल शुरू करें. अगर इससे आपकी ज़रूरत पूरी हो जाती है, तो यह बहुत अच्छी बात है.

अगर ऐसा नहीं होता है, तो अपने कस्टम मॉडल के लिए LiteRT का इस्तेमाल करें.

Google Play services में LiteRT पर अपग्रेड करें, ताकि एपीके का साइज़ कम किया जा सके और शेयर किए गए रनटाइम का इस्तेमाल किया जा सके.

साथ ही, जीपीयू के अनुमान को तेज़ी से और आसानी से पाने के लिए, CompiledModel एपीआई का इस्तेमाल करें.

हाँ।

इस बारे में पूरी जानकारी, AI Edge पर LiteRT के दस्तावेज़ों वाली साइट पर मौजूद है. इसका यूआरएल यहां दिया गया है.

तो, हां.

हमारे साथ जुड़ने के लिए धन्यवाद. हमें यह देखने का बेसब्री से इंतज़ार रहेगा कि आप लोग क्या बनाते हैं.