LiteRT की खास जानकारी

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

LiteRT 2.x के नए वर्शन में CompiledModel एपीआई लॉन्च किया गया है. यह एक मॉडर्न रनटाइम इंटरफ़ेस है, जिसे हार्डवेयर ऐक्सलरेशन को ज़्यादा से ज़्यादा करने के लिए डिज़ाइन किया गया है. Interpreter एपीआई (पहले इसे TensorFlow Lite कहा जाता था) अब भी पुराने वर्शन के साथ काम करता है. हालांकि, हमारा सुझाव है कि डेवलपर CompiledModel एपीआई का इस्तेमाल करें. इससे उन्हें डिवाइस पर एआई ऐप्लिकेशन की बेहतर परफ़ॉर्मेंस मिलेगी.

LiteRT की मुख्य सुविधाएं

LiteRT की मदद से डेवलपमेंट को आसान बनाना

अपने-आप चुने गए ऐक्सलरेटर और मैन्युअल तरीके से बनाए गए डेलिगेट में अंतर. बेहतर परफ़ॉर्मेंस के लिए, I/O बफ़र को मैनेज करने और एसिंक तरीके से काम करने की सुविधा. डिवाइस पर इन्फ़रेंस के बारे में जानकारी देने वाला दस्तावेज़ देखें.

बेहतरीन जीपीयू परफ़ॉर्मेंस

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

यूनिफ़ाइड एनपीयू ऐक्सलरेशन

चिपसेट बनाने वाली मुख्य कंपनियों से, एनपीयू का आसान ऐक्सेस पाकर अपने मॉडल को बेहतर बनाएं. एनपीयू की मदद से तेज़ी से काम करने से जुड़ा दस्तावेज़ देखें.

बेहतर एलएलएम सपोर्ट

LiteRT, जनरेटिव एआई मॉडल को मोबाइल, डेस्कटॉप, और वेब प्लैटफ़ॉर्म पर हाई-परफ़ॉर्मेंस के साथ डिप्लॉय करता है. जनरेटिव एआई को डिप्लॉय करने से जुड़ा दस्तावेज़ देखें.

मशीन लर्निंग के फ़्रेमवर्क के साथ काम करता है

LiteRT, PyTorch, TensorFlow, और JAX फ़्रेमवर्क से .tflite या .litertlm फ़ॉर्मैट में आसानी से कन्वर्ज़न करने की सुविधा देता है. मॉडल कन्वर्ज़न से जुड़े दस्तावेज़ देखें.

CompiledModel API का इस्तेमाल शुरू करना

• क्लासिकल एमएल मॉडल के लिए, यहां दिए गए डेमो ऐप्लिकेशन देखें.

  • इमेज सेगमेंटेशन Kotlin ऐप्लिकेशन: सीपीयू/जीपीयू/एनपीयू इन्फ़रेंस.
  • इमेज सेगमेंटेशन C++ ऐप्लिकेशन: async एक्ज़ीक्यूशन के साथ CPU/GPU/NPU इन्फ़रेंस.

• जनरेटिव एआई मॉडल के लिए, इन डेमो ऐप्लिकेशन को देखें:

  • EmbeddingGemma semantic similarity C++ App: सीपीयू/जीपीयू/एनपीयू इन्फ़रेंस.

डेवलपमेंट वर्कफ़्लो

LiteRT, Android, iOS, वेब, IoT, और डेस्कटॉप/लैपटॉप पर, डिवाइस पर ही अनुमान लगाता है. डिवाइस कोई भी हो, यहां दिया गया तरीका सबसे ज़्यादा इस्तेमाल किया जाता है. ज़्यादा निर्देशों के लिए, यहां दिए गए लिंक पर क्लिक करें.

एमएल से जुड़ी समस्या का सबसे सही समाधान पहचानना

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

मॉडल को पाना और उसे तैयार करना

LiteRT मॉडल को FlatBuffers के तौर पर जाना जाता है. यह एक पोर्टेबल फ़ॉर्मैट है. इसमें .tflite फ़ाइल एक्सटेंशन का इस्तेमाल किया जाता है.

LiteRT मॉडल को इन तरीकों से हासिल किया जा सकता है:

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

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

  मॉडल टाइप	पहले से ट्रेन किए गए मॉडल का सोर्स
  क्लासिकल एमएल (.tflite फ़ॉर्मैट)	Kaggle या HuggingFace पर जाएं उदाहरण के लिए, इमेज सेगमेंटेशन मॉडल और सैंपल ऐप्लिकेशन
  जनरेटिव एआई (.litertlm फ़ॉर्मैट)	LiteRT का Hugging Face पेज उदाहरण के लिए, Gemma Family

• अगर आपको पहले से ट्रेन किए गए मॉडल का इस्तेमाल नहीं करना है, तो चुने गए PyTorch, TensorFlow या JAX मॉडल को LiteRT मॉडल में बदलें. [PRO USER]

  मॉडल फ़्रेमवर्क	सैंपल मॉडल	कन्वर्ज़न टूल
  Pytorch	Hugging Face Torchvision	लिंक
  TensorFlow	Kaggle Models Hugging Face	लिंक
  JAX	Hugging Face	लिंक

• Generative API [PRO USER] का इस्तेमाल करके, बेहतर ऑप्टिमाइज़ेशन के लिए अपना एलएलएम बनाएं

  हमारी Generative API लाइब्रेरी, PyTorch के बिल्ट-इन बिल्डिंग ब्लॉक उपलब्ध कराती है. इनकी मदद से, Gemma, TinyLlama, और अन्य जैसे ट्रांसफ़ॉर्मर मॉडल बनाए जा सकते हैं. इसके लिए, मोबाइल के हिसाब से बनाए गए ऐब्स्ट्रैक्शन का इस्तेमाल किया जाता है. इससे हम कन्वर्ज़न की गारंटी दे सकते हैं. साथ ही, मोबाइल के रनटाइम, LiteRT पर बेहतर तरीके से एक्ज़ीक्यूट कर सकते हैं. Generative API के बारे में जानकारी देने वाला दस्तावेज़ देखें.

ऑप्टिमाइज़ करें [PRO USER]

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

ज़्यादा जानकारी के लिए, एआई एज क्वांटाइज़र का दस्तावेज़ देखें.

मॉडल को एज प्लैटफ़ॉर्म पर अपने ऐप्लिकेशन में इंटिग्रेट करना

LiteRT की मदद से, एमएल मॉडल को पूरी तरह से डिवाइस पर चलाया जा सकता है. साथ ही, यह Android, iOS, वेब, डेस्कटॉप, और IoT प्लैटफ़ॉर्म पर बेहतर परफ़ॉर्मेंस देता है.

अपने पसंदीदा प्लैटफ़ॉर्म पर LiteRT मॉडल को इंटिग्रेट करने के लिए, यहां दी गई गाइड का इस्तेमाल करें:

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

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

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

// Fill the input buffer
inputBuffers.get(0).writeFloat(input0)
inputBuffers.get(1).writeFloat(input1)

// Invoke
compiledModel.run(inputBuffers, outputBuffers)

// Read the output
val output = outputBuffers.get(0).readFloat()

// Load model and initialize runtime
LITERT_ASSIGN_OR_RETURN(auto env, GetEnvironment());
LITERT_ASSIGN_OR_RETURN(auto options, GetOptions());
LITERT_ASSIGN_OR_RETURN(
    auto compiled_model,
    CompiledModel::Create(env, "/path/to/mymodel.tflite", options));

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

// Fill the input buffer
LITERT_ABORT_IF_ERROR(input_buffers[0].Write(input0));
LITERT_ABORT_IF_ERROR(input_buffers[1].Write(input1));

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

// Read the output
LITERT_ABORT_IF_ERROR(output_buffers[0].Read(output0));

कोई बैकएंड चुनें

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

अतिरिक्त दस्तावेज़ और सहायता

• ज़्यादा LiteRT सैंपल ऐप्लिकेशन के लिए, LiteRT-Samples GitHub Repo पर जाएं.

• TensorFlow Lite के मौजूदा उपयोगकर्ताओं के लिए, माइग्रेशन गाइड देखें.

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