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++ ऐप्लिकेशन: एसिंक एक्ज़ीक्यूशन के साथ 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 के बारे में जानकारी देने वाला दस्तावेज़ देखें.

Optimize [PRO USER]

ऐडवांस डेवलपर के लिए AI Edge Quantizer, कनवर्ट किए गए LiteRT मॉडल को क्वांटाइज़ करने का एक टूल है. इसका मकसद, ऐडवांस उपयोगकर्ताओं को संसाधन की मांग करने वाले मॉडल (जैसे, GenAI मॉडल).

ज़्यादा जानकारी के लिए, AI Edge Quantizer का दस्तावेज़ देखें.

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

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 टूल पेज.