Android के लिए LiteRT

LiteRT की मदद से, Android ऐप्लिकेशन में TensorFlow, PyTorch, और JAX मॉडल चलाए जा सकते हैं. LiteRT सिस्टम, Android पर मॉडल को तेज़ी से और असरदार तरीके से चलाने के लिए, पहले से बने और ज़रूरत के मुताबिक बनाए जा सकने वाले एक्ज़ीक्यूशन एनवायरमेंट उपलब्ध कराता है. इसमें हार्डवेयर ऐक्सेलरेट करने के विकल्प भी शामिल हैं.

उदाहरण के लिए, LiteRT का इस्तेमाल करने वाले Android ऐप्लिकेशन के लिए, LiteRT के सैंपल रिपॉज़िटरी देखें.

मशीन लर्निंग मॉडल

LiteRT, TensorFlow, PyTorch, और JAX मॉडल का इस्तेमाल करता है. इन्हें छोटे, पोर्टेबल, और ज़्यादा असरदार मशीन लर्निंग मॉडल फ़ॉर्मैट में बदला जाता है. Android पर LiteRT के साथ पहले से बने मॉडल का इस्तेमाल किया जा सकता है. इसके अलावा, अपने मॉडल बनाए जा सकते हैं और उन्हें LiteRT फ़ॉर्मैट में बदला जा सकता है.

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

Android पर मॉडल चलाना

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

पहली इमेज. Android ऐप्लिकेशन में LiteRT मॉडल के लिए, फ़ंक्शनल एक्ज़ीक्यूशन फ़्लो.

फ़ंक्शनल डिज़ाइन लेवल पर, आपके Android ऐप्लिकेशन में LiteRT मॉडल को चलाने के लिए, ये एलिमेंट होने चाहिए:

• मॉडल को एक्ज़ीक्यूट करने के लिए, LiteRT रनटाइम एनवायरमेंट
• डेटा को टेंसर में बदलने के लिए, मॉडल इनपुट हैंडलर
• मॉडल आउटपुट हैंडलर, ताकि आउटपुट के नतीजे वाले टेंसर मिल सकें और उन्हें अनुमान के नतीजों के तौर पर समझा जा सके

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

LiteRT की मदद से ऐप्लिकेशन बनाना

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

रनटाइम एनवायरमेंट के विकल्प

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

• Google Play services के रनटाइम एनवायरमेंट में LiteRT (सुझाया गया)
• स्टैंड-अलोन LiteRT रनटाइम एनवायरमेंट

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

अपने Android ऐप्लिकेशन में इन रनटाइम एनवायरमेंट को ऐक्सेस करने के लिए, अपने ऐप्लिकेशन डेवलपमेंट एनवायरमेंट में LiteRT डेवलपमेंट लाइब्रेरी जोड़ें. अपने ऐप्लिकेशन में स्टैंडर्ड रनटाइम एनवायरमेंट इस्तेमाल करने के तरीके के बारे में जानने के लिए, अगला सेक्शन देखें.

लाइब्रेरी

Google Play services का इस्तेमाल करके, Interpreter API को ऐक्सेस किया जा सकता है. अपने Android ऐप्लिकेशन में, LiteRT core और support लाइब्रेरी का इस्तेमाल किया जा सकता है. LiteRT लाइब्रेरी और रनटाइम एनवायरमेंट इस्तेमाल करने के बारे में प्रोग्रामिंग से जुड़ी जानकारी के लिए, Android के लिए डेवलपमेंट टूल देखें.

मॉडल पाना

Android ऐप्लिकेशन में मॉडल चलाने के लिए, LiteRT फ़ॉर्मैट वाले मॉडल की ज़रूरत होती है. प्रीबिल्ट मॉडल का इस्तेमाल किया जा सकता है. इसके अलावा, कोई मॉडल बनाकर उसे लाइट फ़ॉर्मैट में बदला जा सकता है. अपने Android ऐप्लिकेशन के लिए मॉडल पाने के बारे में ज़्यादा जानने के लिए, LiteRT Models पेज देखें.

इनपुट डेटा को मैनेज करना

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

अनुमान लगाना

अनुमान का नतीजा जनरेट करने के लिए, मॉडल के ज़रिए डेटा को प्रोसेस करने को अनुमान लगाना कहा जाता है. Android ऐप्लिकेशन में इंटरफ़ेस चलाने के लिए, LiteRT रनटाइम एनवायरमेंट, मॉडल, और इनपुट डेटा की ज़रूरत होती है.

किसी डिवाइस पर मॉडल कितनी तेज़ी से अनुमान लगा सकता है, यह प्रोसेस किए गए डेटा के साइज़, मॉडल की जटिलता, और उपलब्ध कंप्यूटिंग संसाधनों पर निर्भर करता है. जैसे, मेमोरी और सीपीयू या ऐक्सलरेटर कहे जाने वाले खास प्रोसेसर. मशीन लर्निंग मॉडल, ग्राफ़िक्स प्रोसेसिंग यूनिट (जीपीयू) और टेंसर प्रोसेसिंग यूनिट (टीपीयू) जैसे खास प्रोसेसर पर ज़्यादा तेज़ी से काम कर सकते हैं. इसके लिए, LiteRT हार्डवेयर ड्राइवर का इस्तेमाल किया जाता है. इन्हें डेलिगेट कहा जाता है. डेलिगेट और मॉडल प्रोसेसिंग के हार्डवेयर ऐक्सलरेशन के बारे में ज़्यादा जानने के लिए, हार्डवेयर ऐक्सलरेशन की खास जानकारी देखें.

आउटपुट के नतीजों को मैनेज करना

मॉडल, अनुमान के नतीजे को टेंसर के तौर पर जनरेट करते हैं. आपके Android ऐप्लिकेशन को इन टेंसर को मैनेज करना होगा. इसके लिए, उसे कोई कार्रवाई करनी होगी या उपयोगकर्ता को नतीजा दिखाना होगा. मॉडल के आउटपुट के नतीजे, इमेज क्लासिफ़िकेशन के लिए एक नतीजे से जुड़े नंबर (0 = कुत्ता, 1 = बिल्ली, 2 = पक्षी) जितने आसान हो सकते हैं. साथ ही, ये नतीजे ज़्यादा जटिल भी हो सकते हैं. जैसे, किसी इमेज में क्लासिफ़ाई किए गए कई ऑब्जेक्ट के लिए कई बाउंडिंग बॉक्स. इनमें अनुमान की पुष्टि होने की रेटिंग 0 से 1 के बीच होती है.

ऐडवांस डेवलपमेंट पाथ

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

ऐडवांस रनटाइम एनवायरमेंट

LiteRT के लिए, स्टैंडर्ड रनटाइम और Google Play services रनटाइम एनवायरमेंट के अलावा, ऐसे अन्य रनटाइम एनवायरमेंट भी उपलब्ध हैं जिनका इस्तेमाल Android ऐप्लिकेशन के साथ किया जा सकता है. इन एनवायरमेंट का इस्तेमाल तब किया जा सकता है, जब आपके पास ऐसा मशीन लर्निंग मॉडल हो जो एमएल ऑपरेशन का इस्तेमाल करता हो. हालांकि, ये ऑपरेशन LiteRT के लिए स्टैंडर्ड रनटाइम एनवायरमेंट के साथ काम नहीं करते.

• LiteRT के लिए फ़्लेक्स रनटाइम
• कस्टम-बिल्ट LiteRT रनटाइम

LiteRT Flex runtime की मदद से, अपने मॉडल के लिए ज़रूरी ऑपरेटर शामिल किए जा सकते हैं. अपने मॉडल को चलाने के लिए, LiteRT को Android के लिए बनाया जा सकता है. इससे ऑपरेटर और अन्य ज़रूरी फ़ंक्शन शामिल किए जा सकते हैं. इनकी मदद से, TensorFlow मशीन लर्निंग मॉडल को चलाया जा सकता है. ज़्यादा जानकारी के लिए, Android के लिए LiteRT बनाना लेख पढ़ें.

C और C++ API

LiteRT, C और C++ का इस्तेमाल करके मॉडल चलाने के लिए एक एपीआई भी उपलब्ध कराता है. अगर आपका ऐप्लिकेशन Android NDK का इस्तेमाल करता है, तो आपको इस एपीआई का इस्तेमाल करना चाहिए. अगर आपको एक से ज़्यादा प्लैटफ़ॉर्म के बीच कोड शेयर करना है, तो इस एपीआई का इस्तेमाल किया जा सकता है. इस डेवलपमेंट विकल्प के बारे में ज़्यादा जानने के लिए, डेवलपमेंट टूल पेज देखें.

सर्वर पर आधारित मॉडल का एक्ज़ीक्यूशन

आम तौर पर, आपको अपने ऐप्लिकेशन में मॉडल को Android डिवाइस पर चलाना चाहिए, ताकि आपके उपयोगकर्ताओं को कम समय में नतीजे मिल सकें और उनके डेटा की निजता को बेहतर बनाया जा सके. हालांकि, कुछ मामलों में डिवाइस से बाहर, क्लाउड सर्वर पर मॉडल चलाना बेहतर होता है. उदाहरण के लिए, अगर आपके पास कोई ऐसा बड़ा मॉडल है जिसे आसानी से कंप्रेस नहीं किया जा सकता. कंप्रेस करने पर भी, वह इतना छोटा नहीं होता कि उपयोगकर्ताओं के Android डिवाइसों पर काम कर सके या उन डिवाइसों पर ठीक से काम कर सके. अगर आपकी मुख्य प्राथमिकता यह है कि मॉडल की परफ़ॉर्मेंस अलग-अलग डिवाइसों पर एक जैसी हो, तो यह तरीका आपके लिए सबसे सही हो सकता है.

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

कस्टम मॉडल बनाना और उसे ऑप्टिमाइज़ करना

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

Android के इस्तेमाल किए जा सकने वाले वर्शन

अहम जानकारी: अपनी डिपेंडेंसी को अप-टू-डेट रखें, ताकि यह पक्का किया जा सके कि वे नई सुविधाओं और सुरक्षा से जुड़े अपडेट के साथ काम करती हैं.

Compiled Model API बनाम Interpreter API

• Compiled Model API – यह ऐक्सलरेटर-फ़र्स्ट है. इसमें यूनिफ़ाइड बफ़र इंटरऑप और एसिंक पाइपलाइन के साथ, AOT/JIT कंपाइल किए गए एक्ज़ीक्यूशन की सुविधा मिलती है.
• Interpreter API – यह मौजूदा TensorFlow Lite स्टाइल कोड के साथ काम करता है.

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

लागू करने के तरीके के उदाहरणों के लिए, यह देखें:

• इमेज सेगमेंटेशन (Kotlin, CPU/GPU)
• एसिंक सेगमेंटेशन (C++, CPU/GPU/NPU)
• मिलते-जुलते मतलब (C++) – लोकल सैंपल

Common & CPU

जीपीयू

NPU

क्विकस्टार्ट (Compiled Model API)

Compiled Model API की मदद से अनुमान लगाने के लिए, ये मुख्य चरण पूरे करने होते हैं:

1. इमेज के साथ काम करने वाला मॉडल लोड करें.
2. इनपुट और आउटपुट टेंसर बफ़र असाइन करें.
3. कंपाइल किए गए मॉडल को लागू करें.
4. अनुमानों को आउटपुट बफ़र में पढ़ें.

यहां दिए गए कोड स्निपेट में, Kotlin और C++ में पूरी प्रोसेस को लागू करने का बुनियादी तरीका दिखाया गया है.

// Load model and initialize runtime
LITERT_ASSIGN_OR_RETURN(auto model, Model::CreateFromFile("mymodel.tflite"));
LITERT_ASSIGN_OR_RETURN(auto env, Environment::Create({}));
LITERT_ASSIGN_OR_RETURN(auto compiled_model,
    CompiledModel::Create(env, model, kLiteRtHwAcceleratorCpu));

// Preallocate input/output buffers
LITERT_ASSIGN_OR_RETURN(auto input_buffers, compiled_model.CreateInputBuffers());
LITERT_ASSIGN_OR_RETURN(auto output_buffers, compiled_model.CreateOutputBuffers());

// Fill the first input
float input_values[] = { /* your data */ };
input_buffers[0].Write<float>(absl::MakeConstSpan(input_values, /*size*/));

// Invoke
compiled_model.Run(input_buffers, output_buffers);

// Read the output
std::vector<float> data(output_data_size);
output_buffers[0].Read<float>(absl::MakeSpan(data));

// Load model and initialize runtime
val  model =
    CompiledModel.create(
        context.assets,
        "mymodel.tflite",
        CompiledModel.Options(Accelerator.CPU)
    )

// Preallocate input/output buffers
val inputBuffers = model.createInputBuffers()
val outputBuffers = model.createOutputBuffers()

// Fill the first input
inputBuffers[0].writeFloat(FloatArray(data_size) { data_value /* your data */ })

// Invoke
model.run(inputBuffers, outputBuffers)

// Read the output
val outputFloatArray = outputBuffers[0].readFloat()

ज़्यादा जानकारी के लिए, Kotlin का इस्तेमाल शुरू करना और C++ का इस्तेमाल शुरू करना गाइड देखें.

मुख्य सुविधाएं (Compiled Model API)

• टर्न-की ऐक्सेलरेटर चुनने की सुविधा और एसिंक – मॉडल बनाते समय सीपीयू/जीपीयू/एनपीयू चुनें और डेलिगेट प्लंबिंग के बिना एसिंक तरीके से चलाएं.
• यूनिफ़ाइड ज़ीरो-कॉपी बफ़र – प्री/पोस्ट-प्रोसेसिंग और अनुमान के लिए, AHWB/GL/OpenCL/WebGPU/Metal बफ़र शेयर करें.
• जनरेटिव-रेडी थ्रूपुट – इसे मेमोरी कैशिंग और जीपीयू/एनपीयू फ़ॉलबैक के साथ बड़े मॉडल के लिए ऑप्टिमाइज़ किया गया है.

Interpreter API, मौजूदा TensorFlow Lite कोडबेस के साथ काम करता है. इसका इस्तेमाल तब करें, जब आपको डेलिगेट के स्टेबल वर्शन की ज़रूरत हो या तीसरे पक्ष के ऐसे रैपर की ज़रूरत हो जो क्लासिक इंटरप्रेटर के साथ काम करते हों.

ऐक्सलरेटर

• सीपीयू (डिफ़ॉल्ट): XNNPACK के लिए ऑप्टिमाइज़ किया गया है. इसमें डाइनैमिक शेप इस्तेमाल किए जा सकते हैं.
• जीपीयू: आज OpenCL बैकएंड उपलब्ध है. WebGPU और Metal बैकएंड, कंपाइल किए गए मॉडल एपीआई के ज़रिए उपलब्ध हैं.
• एनपीयू: एओटी/जेआईटी के लिए, Qualcomm AI Engine Direct और MediaTek NeuroPilot काम करते हैं; Pixel AOT उपलब्ध है; Apple/Intel NPU के लिए सहायता उपलब्ध कराने की योजना है.

एपीआई कब चुनना चाहिए

• अगर आपको जीपीयू/एनपीयू, ज़ीरो-कॉपी बफ़र या एसिंक एक्ज़ीक्यूशन का सबसे तेज़ तरीका चाहिए, तो Compiled Model API का इस्तेमाल करें.
• अगर आपको मौजूदा TensorFlow Lite कोड, टूल या डेलिगेट के साथ ज़्यादा से ज़्यादा कंपैटिबिलिटी चाहिए, तो Interpreter API का इस्तेमाल करें.