एलएलएम इंफ़रेंस एपीआई, आपको Android ऐप्लिकेशन के लिए, बड़े लैंग्वेज मॉडल (एलएलएम) को डिवाइस पर पूरी तरह से चलाने की सुविधा देता है. इसका इस्तेमाल कई तरह के कामों के लिए किया जा सकता है. जैसे, टेक्स्ट जनरेट करना, आम भाषा में जानकारी पाना, और दस्तावेज़ों की खास जानकारी देना. इस टास्क में, एक से ज़्यादा टेक्स्ट-टू-टेक्स्ट लार्ज लैंग्वेज मॉडल काम करते हैं, ताकि आप डिवाइस पर मौजूद नए जनरेटिव एआई मॉडल को अपने Android ऐप्लिकेशन पर लागू कर सकें.
यह टास्क Gemma 2B के साथ काम करता है. यह एक हल्के और सबसे आधुनिक ओपन मॉडल का हिस्सा है. इन्हें उसी रिसर्च और टेक्नोलॉजी से बनाया गया है जिसका इस्तेमाल Gemini मॉडल को बनाने के लिए किया गया था. यह भी इन बाहरी मॉडल के साथ काम करता है: Phi-2, Falcon-RW-1B, और StableLM-3B, साथ ही, AI Edge से एक्सपोर्ट किए गए सभी मॉडल.
इस टास्क की क्षमताओं, मॉडल, और कॉन्फ़िगरेशन विकल्पों के बारे में ज़्यादा जानकारी के लिए, खास जानकारी देखें.
कोड का उदाहरण
इस गाइड में, Android के लिए टेक्स्ट जनरेट करने वाले बेसिक ऐप्लिकेशन के उदाहरण के बारे में बताया गया है. अपने Android ऐप्लिकेशन के लिए, शुरुआत करने की जगह के तौर पर इस ऐप्लिकेशन का इस्तेमाल किया जा सकता है या किसी मौजूदा ऐप्लिकेशन में बदलाव करते समय इसका इस्तेमाल किया जा सकता है. उदाहरण कोड को GitHub पर होस्ट किया गया है.
कोड डाउनलोड करें
नीचे दिए गए निर्देशों में git कमांड लाइन टूल का इस्तेमाल करके, उदाहरण कोड की लोकल कॉपी बनाने का तरीका बताया गया है.
उदाहरण कोड डाउनलोड करने के लिए:
- नीचे दिए गए निर्देश का इस्तेमाल करके, गिट रिपॉज़िटरी का क्लोन बनाएं:
git clone https://github.com/google-ai-edge/mediapipe-samples
- इसके अलावा, स्पार्स चेकआउट का इस्तेमाल करने के लिए गिट इंस्टेंस को कॉन्फ़िगर किया जा सकता है. ऐसा करने से, आपके पास सिर्फ़ LLM Infrence API के उदाहरण वाले ऐप्लिकेशन की फ़ाइलें होती हैं:
cd mediapipe git sparse-checkout init --cone git sparse-checkout set examples/llm_inference/android
उदाहरण कोड का स्थानीय वर्शन बनाने के बाद, प्रोजेक्ट को Android Studio में इंपोर्ट किया जा सकता है. इसके बाद, ऐप्लिकेशन को चलाया जा सकता है. निर्देशों के लिए, Android के लिए सेटअप गाइड देखें.
सेटअप
इस सेक्शन में, डेवलपमेंट एनवायरमेंट को सेट अप करने के मुख्य चरणों के बारे में बताया गया है. साथ ही, ऐसे कोड प्रोजेक्ट के बारे में भी बताया गया है जिन्हें खास तौर पर एलएलएम इंफ़रेंस एपीआई का इस्तेमाल करने के लिए इस्तेमाल किया जाता है. MediaPipe टास्क का इस्तेमाल करने और प्लैटफ़ॉर्म के वर्शन की ज़रूरी शर्तों के साथ-साथ अपना डेवलपमेंट एनवायरमेंट सेट अप करने के बारे में सामान्य जानकारी के लिए, Android के लिए सेटअप गाइड देखें.
डिपेंडेंसी
एलएलएम अनुमान एपीआई, com.google.mediapipe:tasks-genai लाइब्रेरी का इस्तेमाल करता है. अपने Android ऐप्लिकेशन
की build.gradle फ़ाइल में यह निर्भरता जोड़ें:
dependencies {
implementation 'com.google.mediapipe:tasks-genai:0.10.14'
}
मॉडल
MediaPipe LLM LLM Infrence API के लिए, टेक्स्ट-टू-टेक्स्ट भाषा का एक प्रशिक्षित मॉडल होना ज़रूरी है, जो इस टास्क के साथ काम करे. मॉडल डाउनलोड करने के बाद, ज़रूरी डिपेंडेंसी इंस्टॉल करें और मॉडल को Android डिवाइस पर पुश करें. अगर जेम्मा के अलावा किसी दूसरे मॉडल का इस्तेमाल किया जा रहा है, तो आपको मॉडल को MediaPipe के साथ काम करने वाले फ़ॉर्मैट में बदलना होगा.
एलएलएम इंफ़रेंस एपीआई के लिए उपलब्ध ट्रेनिंग मॉडल के बारे में ज़्यादा जानने के लिए, टास्क की खास जानकारी वाला मॉडल सेक्शन देखें.
मॉडल डाउनलोड करना
एलएलएम इंफ़रेंस एपीआई को शुरू करने से पहले, इस्तेमाल किया जा सकने वाला कोई मॉडल डाउनलोड करें और फ़ाइल को अपने प्रोजेक्ट डायरेक्ट्री में सेव करें:
- Gemma 2B: यह एक लाइटवेट और आधुनिक ओपन मॉडल है. इसे उसी रिसर्च और टेक्नोलॉजी से बनाया गया है जिसका इस्तेमाल Gemini मॉडल को बनाने के लिए किया गया था. यह टेक्स्ट जनरेट करने वाले कई तरह के टास्क में काम आता है. जैसे, सवाल का जवाब देना, ख़ास जानकारी देना, और तर्क देना.
- Phi-2: 2.7 अरब पैरामीटर ट्रांसफ़ॉर्मर मॉडल, जो सवाल के जवाब, चैट, और कोड फ़ॉर्मैट के लिए सबसे सही है.
- Falcon-RW-1B: यह एक अरब पैरामीटर कॉज़ल डिकोडर वाला मॉडल है. इसे RefinedWeb के 350B टोकन पर ट्रेनिंग दी गई है.
- StableLM-3B: अंग्रेज़ी और कोड के अलग-अलग डेटासेट के एक खरब टोकन पर, पहले से ट्रेन किया गया तीन अरब पैरामीटर डिकोडर भाषा का मॉडल.
इसके अलावा, एआई एज ट्रॉच की मदद से मैप और एक्सपोर्ट किए गए मॉडल इस्तेमाल किए जा सकते हैं.
हमारा सुझाव है कि आप Gemma 2B का इस्तेमाल करें, जो Kaggle मॉडल पर उपलब्ध है. यह ऐसे फ़ॉर्मैट में आता है जो LLM Infrence API के साथ पहले से ही काम करता है. अगर किसी दूसरे एलएलएम का इस्तेमाल किया जाता है, तो आपको मॉडल को MediaPipe-फ़्रेंडली फ़ॉर्मैट में बदलना होगा. Gemma 2B के बारे में ज़्यादा जानकारी के लिए, Gemma 2B साइट देखें. अन्य उपलब्ध मॉडल के बारे में ज़्यादा जानकारी के लिए, टास्क की खास जानकारी वाला मॉडल सेक्शन देखें.
मॉडल को MediaPipe फ़ॉर्मैट में बदलें
नेटिव मॉडल कन्वर्ज़न
अगर बाहरी एलएलएम (Phi-2, Falcon या StableLM) या Gemma का कोई गैर-Kaggle वर्शन इस्तेमाल किया जा रहा है, तो मॉडल को MediaPipe के साथ काम करने के लिए फ़ॉर्मैट करने के लिए, हमारी कन्वर्ज़न स्क्रिप्ट का इस्तेमाल करें.
मॉडल रूपांतरण प्रक्रिया के लिए MediaPipe PyPI पैकेज की आवश्यकता होती है. कन्वर्ज़न स्क्रिप्ट, 0.10.11 के बाद सभी MediaPipe पैकेज में उपलब्ध है.
नीचे दी गई चीज़ों की मदद से डिपेंडेंसी इंस्टॉल और इंपोर्ट करें:
$ python3 -m pip install mediapipe
मॉडल को बदलने के लिए, genai.converter लाइब्रेरी का इस्तेमाल करें:
import mediapipe as mp
from mediapipe.tasks.python.genai import converter
config = converter.ConversionConfig(
input_ckpt=INPUT_CKPT,
ckpt_format=CKPT_FORMAT,
model_type=MODEL_TYPE,
backend=BACKEND,
output_dir=OUTPUT_DIR,
combine_file_only=False,
vocab_model_file=VOCAB_MODEL_FILE,
output_tflite_file=OUTPUT_TFLITE_FILE,
)
converter.convert_checkpoint(config)
LoRA मॉडल को बदलने के लिए, ConversionConfig में बेस मॉडल के विकल्पों के साथ-साथ, LoRA के अन्य विकल्प भी बताए जाने चाहिए. ध्यान दें कि एपीआई, जीपीयू के साथ सिर्फ़ LoRA अनुमान के साथ काम करता है, इसलिए बैकएंड को 'gpu' पर सेट होना चाहिए.
import mediapipe as mp
from mediapipe.tasks.python.genai import converter
config = converter.ConversionConfig(
# Other params related to base model
...
# Must use gpu backend for LoRA conversion
backend='gpu',
# LoRA related params
lora_ckpt=LORA_CKPT,
lora_rank=LORA_RANK,
lora_output_tflite_file=LORA_OUTPUT_TFLITE_FILE,
)
converter.convert_checkpoint(config)
कन्वर्टर, दो TFLite फ़्लैटबफ़र फ़ाइलें बनाएगा, एक बेस मॉडल के लिए और दूसरी LoRA मॉडल के लिए.
| पैरामीटर | कंपनी का ब्यौरा | स्वीकार की गई वैल्यू |
|---|---|---|
input_ckpt |
model.safetensors या pytorch.bin फ़ाइल का पाथ. ध्यान दें कि कभी-कभी मॉडल सेफ़टेंसर फ़ॉर्मैट को एक से ज़्यादा फ़ाइलों में शार्ड किया जाता है, जैसे कि model-00001-of-00003.safetensors, model-00001-of-00003.safetensors. आपके पास फ़ाइल का पैटर्न तय करने का विकल्प होता है, जैसे कि model*.safetensors. |
PATH |
ckpt_format |
मॉडल फ़ाइल का फ़ॉर्मैट. | {"safetensors", "pytorch"} |
model_type |
एलएलएम को बदला जा रहा है. | {"PHI_2", "FALCON_RW_1B", "STABLELM_4E1T_3B", "GEMMA_2B"} |
backend |
मॉडल को चलाने के लिए इस्तेमाल किया जाने वाला प्रोसेसर (प्रतिनिधि). | {"cpu", "gpu"} |
output_dir |
हर लेयर की वेट फ़ाइलों को होस्ट करने वाली आउटपुट डायरेक्ट्री का पाथ. | PATH |
output_tflite_file |
आउटपुट फ़ाइल का पाथ. उदाहरण के लिए, "model_cpu.bin" या "model_gpu.bin". यह फ़ाइल सिर्फ़ एलएलएम अनुमान एपीआई के साथ काम करती है. इसे सामान्य `tflite` फ़ाइल के तौर पर इस्तेमाल नहीं किया जा सकता. | PATH |
vocab_model_file |
उस डायरेक्ट्री का पाथ जिसमें tokenizer.json और
tokenizer_config.json फ़ाइलें सेव की जाती हैं. जेम्मा के लिए, एक tokenizer.model फ़ाइल पर कर्सर ले जाएं. |
PATH |
lora_ckpt |
सेफ़टेंसर फ़ाइल के LoRA ckpt का पाथ, जिसमें LoRA अडैप्टर का वज़न सेव होता है. | PATH |
lora_rank |
LoRA ckpt की रैंक दिखाने वाला पूर्णांक. लॉरा वेट को बदलने के लिए ज़रूरी है. अगर यह पैरामीटर उपलब्ध नहीं कराया जाता, तो कन्वर्टर को यह लगता है कि कोई LoRA वेट नहीं है. ध्यान दें: सिर्फ़ जीपीयू बैकएंड में, LoRA के साथ काम किया जा सकता है. | Integer |
lora_output_tflite_file |
LoRA वज़न के लिए आउटपुट फ़ाइल का tflite फ़ाइल नाम. | PATH |
AI Edge मॉडल का कन्वर्ज़न
अगर AI Edge की मदद से, TFLite मॉडल पर मैप किए गए एलएलएम का इस्तेमाल किया जा रहा है, तो टास्क बंडल बनाने के लिए, हमारी बंडलिंग स्क्रिप्ट का इस्तेमाल करें. बंडलिंग प्रोसेस में, मैप किए गए मॉडल को अतिरिक्त मेटाडेटा (उदाहरण के लिए, टोकननाइज़र पैरामीटर) का इस्तेमाल, शुरू से अंत तक के अनुमान को चलाने के लिए किया जाता है.
मॉडल बंडलिंग प्रोसेस के लिए MediaPipe PyPI पैकेज की ज़रूरत होती है. कन्वर्ज़न स्क्रिप्ट, 0.10.14 के बाद सभी MediaPipe पैकेज में उपलब्ध है.
नीचे दी गई चीज़ों की मदद से डिपेंडेंसी इंस्टॉल और इंपोर्ट करें:
$ python3 -m pip install mediapipe
इस मॉडल को बंडल करने के लिए, genai.bundler लाइब्रेरी का इस्तेमाल करें:
import mediapipe as mp
from mediapipe.tasks.python.genai import bundler
config = bundler.BundleConfig(
tflite_model=TFLITE_MODEL,
tokenizer_model=TOKENIZER_MODEL,
start_token=START_TOKEN,
stop_tokens=STOP_TOKENS,
output_filename=OUTPUT_FILENAME,
enable_bytes_to_unicode_mapping=ENABLE_BYTES_TO_UNICODE_MAPPING,
)
bundler.create_bundle(config)
| पैरामीटर | कंपनी का ब्यौरा | स्वीकार की गई वैल्यू |
|---|---|---|
tflite_model |
AI Edge से एक्सपोर्ट किए गए TFLite मॉडल का पाथ. | PATH |
tokenizer_model |
StencePiece के टोकनाइज़र मॉडल का पाथ. | PATH |
start_token |
मॉडल के लिए खास स्टार्ट टोकन. दिए गए टोकनाइज़र मॉडल में, स्टार्ट टोकन मौजूद होना चाहिए. | स्ट्रिंग |
stop_tokens |
मॉडल के हिसाब से खास स्टॉप टोकन. दिए गए टोकनाइज़र मॉडल में, स्टॉप टोकन मौजूद होना चाहिए. | सूची[STRING] |
output_filename |
आउटपुट टास्क बंडल फ़ाइल का नाम. | PATH |
मॉडल को डिवाइस पर पुश करें
output_path फ़ोल्डर के कॉन्टेंट को Android डिवाइस पर पुश करें.
$ adb shell rm -r /data/local/tmp/llm/ # Remove any previously loaded models
$ adb shell mkdir -p /data/local/tmp/llm/
$ adb push output_path /data/local/tmp/llm/model_version.bin
टास्क बनाएं
MediaPipe LLM Infrence API, टास्क को सेट अप करने के लिए createFromOptions() फ़ंक्शन का इस्तेमाल करता है. createFromOptions() फ़ंक्शन, कॉन्फ़िगरेशन के विकल्पों के लिए वैल्यू स्वीकार करता है. कॉन्फ़िगरेशन के विकल्पों के बारे में ज़्यादा जानकारी के लिए, कॉन्फ़िगरेशन के विकल्प देखें.
नीचे दिया गया कोड, कॉन्फ़िगरेशन के बुनियादी विकल्पों का इस्तेमाल करके टास्क शुरू करता है:
// Set the configuration options for the LLM Inference task
val options = LlmInferenceOptions.builder()
.setModelPATH('/data/local/.../')
.setMaxTokens(1000)
.setTopK(40)
.setTemperature(0.8)
.setRandomSeed(101)
.build()
// Create an instance of the LLM Inference task
llmInference = LlmInference.createFromOptions(context, options)
कॉन्फ़िगरेशन विकल्प
Android ऐप्लिकेशन को सेट अप करने के लिए, इन कॉन्फ़िगरेशन विकल्पों का इस्तेमाल करें:
| विकल्प का नाम | कंपनी का ब्यौरा | वैल्यू रेंज | डिफ़ॉल्ट मान |
|---|---|---|---|
modelPath |
प्रोजेक्ट डायरेक्ट्री में मॉडल को सेव करने की जगह का पाथ. | PATH | लागू नहीं |
maxTokens |
मॉडल द्वारा हैंडल किए जाने वाले टोकन (इनपुट टोकन + आउटपुट टोकन) की ज़्यादा से ज़्यादा संख्या. | Integer | 512 |
topK |
जनरेट होने के हर चरण में मॉडल के हिसाब से टोकन की संख्या.
सुझावों को सबसे ऊपर के सबसे ज़्यादा संभावित टोकन तक सीमित करता है. topK को सेट करते समय, आपको randomSeed के लिए वैल्यू भी सेट करनी होगी. |
Integer | 40 |
temperature |
जनरेट करने के दौरान की गई यादृच्छिकता की मात्रा. तापमान ज़्यादा होने पर,
जनरेट किए गए टेक्स्ट में ज़्यादा क्रिएटिविटी दिखती है. वहीं,
कम तापमान होने पर, इमेज का बेहतर तरीके से अनुमान लगाया जा सकता है. temperature को सेट करते समय, आपको randomSeed के लिए वैल्यू भी सेट करनी होगी. |
Float | 0.8 |
randomSeed |
टेक्स्ट जनरेट करने के दौरान इस्तेमाल किया गया कोई भी सीड. | Integer | 0 |
loraPath |
डिवाइस पर, LoRA मॉडल के लिए ऐब्सलूट पाथ. ध्यान दें: यह सुविधा सिर्फ़ जीपीयू मॉडल के साथ काम करती है. | PATH | लागू नहीं |
resultListener |
नतीजे लिसनर को सेट करता है, ताकि एसिंक्रोनस तरीके से नतीजे पाए जा सकें. यह सिर्फ़ तब लागू होता है, जब एक साथ काम नहीं करने वाले जनरेट करने के तरीके का इस्तेमाल किया जा रहा हो. | लागू नहीं | लागू नहीं |
errorListener |
गड़बड़ी की जानकारी देने वाला वैकल्पिक लिसनर सेट करता है. | लागू नहीं | लागू नहीं |
डेटा तैयार करना
एलएलएम अनुमान एपीआई ये इनपुट स्वीकार करता है:
- prompt (स्ट्रिंग): कोई सवाल या प्रॉम्प्ट.
val inputPrompt = "Compose an email to remind Brett of lunch plans at noon on Saturday."
टास्क चलाएं
पिछले सेक्शन (inputPrompt) में दिए गए इनपुट टेक्स्ट का टेक्स्ट रिस्पॉन्स जनरेट करने के लिए, generateResponse() तरीके का इस्तेमाल करें. इससे, सिंगल
जनरेट किया गया रिस्पॉन्स मिलता है.
val result = llmInference.generateResponse(inputPrompt)
logger.atInfo().log("result: $result")
जवाब स्ट्रीम करने के लिए, generateResponseAsync() तरीके का इस्तेमाल करें.
val options = LlmInference.LlmInferenceOptions.builder()
...
.setResultListener { partialResult, done ->
logger.atInfo().log("partial result: $partialResult")
}
.build()
llmInference.generateResponseAsync(inputPrompt)
नतीजे मैनेज करें और दिखाएं
एलएलएम अनुमान एपीआई, LlmInferenceResult दिखाता है. इसमें जनरेट किया गया रिस्पॉन्स टेक्स्ट शामिल होता है.
Here's a draft you can use:
Subject: Lunch on Saturday Reminder
Hi Brett,
Just a quick reminder about our lunch plans this Saturday at noon.
Let me know if that still works for you.
Looking forward to it!
Best,
[Your Name]
LoRA मॉडल को पसंद के मुताबिक बनाने की सुविधा
MediaPipe एलएलएम अनुमान एपीआई को इस तरह से कॉन्फ़िगर किया जा सकता है कि बड़े लैंग्वेज मॉडल में, कम रैंक वाले अडैप्टेशन (LoRA) की सुविधा का इस्तेमाल किया जा सके. आसान LoRA मॉडल का इस्तेमाल करके, डेवलपर एक किफ़ायती ट्रेनिंग प्रोसेस के ज़रिए एलएलएम के व्यवहार को अपनी पसंद के मुताबिक बना सकते हैं.
एलएलएम इंफ़रेंस एपीआई का LoRA सपोर्ट, जीपीयू बैकएंड के Gemma-2B और Phi-2 मॉडल के लिए काम करता है. वहीं, LoRA वेट की जानकारी सिर्फ़ अटेंशन लेयर पर लागू होती है. शुरुआती तौर पर लागू करने की यह प्रोसेस, आने वाले समय में होने वाले डेवलपमेंट के लिए, एक एक्सपेरिमेंटल एपीआई के तौर पर काम करती है. आने वाले अपडेट में, ज़्यादा मॉडल और कई तरह की लेयर को इस्तेमाल करने की सुविधा दी जाएगी.
LoRA मॉडल तैयार करना
अपने डेटासेट वाले बेहतर ट्यून किए गए LoRA मॉडल को Gemma-2B या Phi-2 पर, काम करने वाले मॉडल के साथ ट्रेनिंग देने के लिए, HggingFace पर दिए गए निर्देशों का पालन करें. Gemma-2B और Phi-2 मॉडल, HuggingFace पर सेफ़ेंसर फ़ॉर्मैट में उपलब्ध हैं. एलएलएम अनुमान एपीआई, ध्यान खींचने वाली लेयर पर सिर्फ़ LoRA के साथ काम करता है. इसलिए, LoraConfig बनाते समय सिर्फ़ ध्यान देने वाली लेयर के बारे में बताएं:
# For Gemma-2B
from peft import LoraConfig
config = LoraConfig(
r=LORA_RANK,
target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
)
# For Phi-2
config = LoraConfig(
r=LORA_RANK,
target_modules=["q_proj", "v_proj", "k_proj", "dense"],
)
टेस्टिंग के लिए, सार्वजनिक तौर पर ऐक्सेस किए जा सकने वाले LoRA मॉडल उपलब्ध हैं. ये मॉडल, HuggingFace पर उपलब्ध एलएलएम इंफ़रेंस एपीआई के हिसाब से उपलब्ध हैं. उदाहरण के लिए, Gemma-2B के लिए monsterapi/gemma-2b-lora-maths-orca-200k और Phi-2 के लिए lole25/phi-2-sft-ultrachat-lora.
तैयार डेटासेट की ट्रेनिंग करने और मॉडल को सेव करने के बाद, आपको एक adapter_model.safetensors फ़ाइल मिलती है, जिसमें आसान LoRA मॉडल वेट होते हैं. सेफ़ेंसर फ़ाइल, LoRA चेकपॉइंट है. इसका इस्तेमाल मॉडल कन्वर्ज़न में किया जाता है.
अगले चरण में, आपको MediaPipe Python पैकेज का इस्तेमाल करके मॉडल वेट को TensorFlow Lite फ़्लैटबफ़र में बदलना होगा. ConversionConfig में, बेस मॉडल के विकल्पों के साथ-साथ अतिरिक्त LoRA विकल्प की जानकारी भी दी जानी चाहिए. ध्यान दें कि एपीआई, जीपीयू के साथ सिर्फ़ LoRA अनुमान के साथ काम करता है, इसलिए बैकएंड को 'gpu' पर सेट किया जाना चाहिए.
import mediapipe as mp
from mediapipe.tasks.python.genai import converter
config = converter.ConversionConfig(
# Other params related to base model
...
# Must use gpu backend for LoRA conversion
backend='gpu',
# LoRA related params
lora_ckpt=LORA_CKPT,
lora_rank=LORA_RANK,
lora_output_tflite_file=LORA_OUTPUT_TFLITE_FILE,
)
converter.convert_checkpoint(config)
कन्वर्टर, दो TFLite फ़्लैटबफ़र फ़ाइलें बनाएगा, एक बेस मॉडल के लिए और दूसरी LoRA मॉडल के लिए.
LoRA मॉडल का अनुमान
LoRA मॉडल के अनुमान के साथ काम करने के लिए, वेब, Android, और iOS एलएलएम इंफ़रेंस एपीआई को अपडेट किया गया है. वेब, डाइनैमिक LoRA के साथ काम करता है. यह रनटाइम के दौरान, अलग-अलग LoRA मॉडल को स्विच कर सकता है. Android और iOS, स्टैटिक LoRA के साथ काम करते हैं. इसमें, टास्क के पूरे समय के दौरान, एक ही LoRA वेट का इस्तेमाल किया जाता है.
शुरू करने के दौरान, Android में स्टैटिक LoRA की सुविधा दी जाती है. LoRA मॉडल को लोड करने के लिए, उपयोगकर्ता LoRA मॉडल पाथ के साथ-साथ बेस एलएलएम की जानकारी देते हैं.// Set the configuration options for the LLM Inference task
val options = LlmInferenceOptions.builder()
.setModelPath('<path to base model>')
.setMaxTokens(1000)
.setTopK(40)
.setTemperature(0.8)
.setRandomSeed(101)
.setLoraPath('<path to LoRA model>')
.build()
// Create an instance of the LLM Inference task
llmInference = LlmInference.createFromOptions(context, options)
LoRA की मदद से एलएलएम अनुमान चलाने के लिए, उन ही generateResponse() या generateResponseAsync() तरीकों का इस्तेमाल करें जिन्हें बेस मॉडल में इस्तेमाल किया गया था.