LiteRT Next, एपीआई का एक नया सेट है. इससे LiteRT को बेहतर बनाया गया है. खास तौर पर, डिवाइस पर मौजूद एमएल और एआई ऐप्लिकेशन के लिए, हार्डवेयर ऐक्सेलरेशन और परफ़ॉर्मेंस के मामले में. ये एपीआई, अल्फा रिलीज़ हैं और ये Kotlin और C++ में उपलब्ध हैं.
LiteRT Next कंपाइल किया गया मॉडल एपीआई, TensorFlow Lite इंटरप्रिटर एपीआई पर आधारित है. यह डिवाइस पर मशीन लर्निंग के लिए, मॉडल लोड करने और उसे लागू करने की प्रोसेस को आसान बनाता है. नए एपीआई, हार्डवेयर ऐक्सेलरेशन का इस्तेमाल करने का एक नया और आसान तरीका उपलब्ध कराते हैं. इससे, मॉडल FlatBuffers, I/O बफ़र के साथ काम करने और डेलिगेट करने की ज़रूरत नहीं पड़ती. LiteRT Next API, LiteRT API के साथ काम नहीं करते. LiteRT Next की सुविधाओं का इस्तेमाल करने के लिए, शुरू करने से जुड़ी गाइड देखें.
LiteRT Next को लागू करने के उदाहरण के लिए, नीचे दिए गए डेमो ऐप्लिकेशन देखें:
क्विकस्टार्ट
LiteRT Next API की मदद से अनुमान लगाने के लिए, ये मुख्य चरण अपनाएं:
- कोई ऐसा मॉडल लोड करें जो इस सुविधा के साथ काम करता हो.
- इनपुट और आउटपुट टेंसर बफ़र को असाइन करें.
- कंपाइल किए गए मॉडल को लागू करें.
- अनुमान को आउटपुट बफ़र में पढ़ें.
नीचे दिए गए कोड स्निपेट में, Kotlin और C++ में पूरी प्रोसेस को बुनियादी तौर पर लागू करने का तरीका बताया गया है.
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));
Kotlin
// 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++ का इस्तेमाल शुरू करना गाइड देखें.
मुख्य सुविधाएं
LiteRT Next में ये मुख्य फ़ायदे और सुविधाएं शामिल हैं:
- नया LiteRT API: अपने-आप ऐक्सेलरेटर चुनने, असाइनमेंट को असाइन किए जाने के बाद उसे तुरंत लागू करने, और बेहतर I/O बफ़र मैनेजमेंट की सुविधा के साथ, डेवलपमेंट को आसान बनाएं.
- अपने-कैटगरी में सबसे अच्छी जीपीयू परफ़ॉर्मेंस: डिवाइस पर एमएल (मशीन लर्निंग) के लिए, सबसे आधुनिक जीपीयू ऐक्सेलरेशन का इस्तेमाल करें. बफ़र के साथ काम करने की नई सुविधा, जीपीयू के अलग-अलग बफ़र टाइप में शून्य कॉपी और कम से कम इंतज़ार की सुविधा चालू करती है.
- बेहतर जनरेटिव एआई का अनुमान: GenAI मॉडल के लिए, सबसे बेहतर परफ़ॉर्मेंस के साथ आसानी से इंटिग्रेशन की सुविधा चालू करें.
- यूनिफ़ाइड एनपीयू एक्सेलरेशन: चिपसेट की सेवा देने वाली मुख्य कंपनियों के एनपीयू को आसानी से ऐक्सेस करने की सुविधा दें. साथ ही, डेवलपर को एक जैसा अनुभव दें. LiteRT एनपीयू के ज़रिए बेहतर परफ़ॉर्मेंस पाने की सुविधा, रिलीज़ होने से पहले इस्तेमाल करने का ऐक्सेस देने वाले कार्यक्रम के तहत उपलब्ध है.
मुख्य सुधार
LiteRT Next (कंपाइल किया गया मॉडल एपीआई), LiteRT (TFLite इंटरप्रेटर एपीआई) में ये अहम सुधार करता है. LiteRT Next की मदद से अपने ऐप्लिकेशन को सेट अप करने के बारे में पूरी जानकारी पाने के लिए, शुरू करें गाइड देखें.
- ऐक्सेलरेटर का इस्तेमाल: LiteRT की मदद से जीपीयू पर मॉडल चलाने के लिए, डिलीगेट बनाने, फ़ंक्शन कॉल करने, और ग्राफ़ में बदलाव करने की ज़रूरत होती है. LiteRT के साथ, अगले चरण में सिर्फ़ ऐक्सेलरेटर की जानकारी दें.
- नेटिव हार्डवेयर बफ़र के साथ काम करने की सुविधा: LiteRT, बफ़र का विकल्प नहीं देता. साथ ही, यह सारा डेटा सीपीयू मेमोरी से भेजता है. LiteRT Next की मदद से, Android हार्डवेयर बफ़र (AHWB), OpenCL बफ़र, OpenGL बफ़र या अन्य खास बफ़र इस्तेमाल किए जा सकते हैं.
- एक साथ काम न करने वाले टास्क को लागू करना: LiteRT Next में, फिर से डिज़ाइन किया गया एसिंक्रोनस एपीआई शामिल है. यह सिंक फ़ेंस के आधार पर, एक साथ काम न करने वाले टास्क को लागू करने का सही तरीका उपलब्ध कराता है. इससे अलग-अलग टास्क के लिए, अलग-अलग हार्डवेयर का इस्तेमाल करके, प्रोसेस को तेज़ी से पूरा किया जा सकता है. जैसे, सीपीयू, जीपीयू, सीपीयू, और एनपीयू.
- मॉडल लोड करना: LiteRT Next में मॉडल लोड करने के लिए, अलग से बिल्डर चरण की ज़रूरत नहीं होती.