LiteRT की खास जानकारी में आपका स्वागत है

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 मॉडल को क्वांटाइज़ करने का एक टूल है. इसका मकसद, ऐडवांस उपयोगकर्ताओं को संसाधन की मांग करने वाले मॉडल (जैसे, GenAI मॉडल).

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

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

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