एलएलएम इन्फ़रेंस एपीआई की मदद से, डिवाइस पर पूरी तरह से लार्ज लैंग्वेज मॉडल (एलएलएम) का इस्तेमाल किया जा सकता है इस्तेमाल किया जा सकता है. इसका इस्तेमाल कई तरह के काम करने के लिए किया जा सकता है. जैसे, टेक्स्ट जनरेट करना, नैचुरल लैंग्वेज में जानकारी हासिल करना, और खास जानकारी देता है. यह टास्क, एक से ज़्यादा उपयोगकर्ताओं के लिए पहले से मौजूद काम करता है टेक्स्ट-टू-टेक्स्ट बड़े लैंग्वेज मॉडल, ताकि आप डिवाइस पर मौजूद नए वर्शन को लागू कर सकें आपके Android ऐप्लिकेशन के लिए जनरेटिव एआई मॉडल.
यह टास्क, Gemma के साथ काम करता है 2B, एक ही रिसर्च पर आधारित, लाइटवेट, आधुनिक ओपन मॉडल का परिवार और Gemini के मॉडल बनाने में इस्तेमाल हुई टेक्नोलॉजी. यह ऐप्लिकेशन, नीचे दिए गए बाहरी मॉडल के साथ भी काम करता है: Phi-2, Falcon-RW-1B और StableLM-3B, साथ ही, AI Edge से एक्सपोर्ट किए गए सभी मॉडल भी शामिल हैं.
क्षमताओं, मॉडल, और कॉन्फ़िगरेशन के विकल्पों के बारे में ज़्यादा जानकारी पाने के लिए इस टास्क की खास जानकारी देखें.
कोड का उदाहरण
इस गाइड में, Android के लिए बेसिक टेक्स्ट जनरेट करने वाले ऐप्लिकेशन के उदाहरण के बारे में बताया गया है. आपने लोगों तक पहुंचाया मुफ़्त में अपने Android ऐप्लिकेशन के लिए शुरुआती पॉइंट के तौर पर, उसका इस्तेमाल किया जा सकता है या को अपडेट करें. उदाहरण वाला कोड इस पर होस्ट किया गया है GitHub.
कोड डाउनलोड करें
नीचे दिए गए निर्देशों में आपको उदाहरण की स्थानीय कॉपी बनाने का तरीका बताया गया है git कमांड लाइन टूल का इस्तेमाल करके कोड बनाना और उसमें बदलाव करना.
उदाहरण कोड डाउनलोड करने के लिए:
- नीचे दिए गए कमांड का इस्तेमाल करके git रिपॉज़िटरी का क्लोन बनाएं:
git clone https://github.com/google-ai-edge/mediapipe-samples
- वैकल्पिक रूप से, विरल चेकआउट का इस्तेमाल करने के लिए अपने git इंस्टेंस को कॉन्फ़िगर करें, ताकि
सिर्फ़ एलएलएम इन्फ़रेंस एपीआई के उदाहरण ऐप्लिकेशन के लिए फ़ाइलें:
cd mediapipe git sparse-checkout init --cone git sparse-checkout set examples/llm_inference/android
उदाहरण के तौर पर दिए गए कोड का लोकल वर्शन बनाने के बाद, प्रोजेक्ट को इंपोर्ट किया जा सकता है और इस ऐप्लिकेशन को चलाएं. निर्देशों के लिए, Android.
सेटअप
इस सेक्शन में, आपके डेवलपमेंट एनवायरमेंट को सेट अप करने और को खास तौर पर, एलएलएम इन्फ़रेंस एपीआई का इस्तेमाल करने के लिए कोड प्रोजेक्ट किए जाते हैं. इस पर सामान्य जानकारी के लिए MediaPipe के टास्क इस्तेमाल करने के लिए डेवलपमेंट एनवायरमेंट सेट अप करना. इसमें ये भी शामिल हैं प्लैटफ़ॉर्म वर्शन की ज़रूरी शर्तें, Google के सभी प्रॉडक्ट के लिए सेटअप गाइड Android.
डिपेंडेंसी
एलएलएम इन्फ़रेंस एपीआई, com.google.mediapipe:tasks-genai लाइब्रेरी का इस्तेमाल करता है. इसे जोड़ें
आपके Android ऐप्लिकेशन की build.gradle फ़ाइल पर निर्भरता:
dependencies {
implementation 'com.google.mediapipe:tasks-genai:0.10.14'
}
मॉडल
MediaPipe LLM Inference API के लिए, ट्रेन किए गए टेक्स्ट-टू-टेक्स्ट लैंग्वेज मॉडल की ज़रूरत होती है. यह इन शर्तों को पूरा करते हैं. मॉडल डाउनलोड करने के बाद, ज़रूरी शर्तें पूरी करने वाले मॉडल को इंस्टॉल करें पर निर्भर होता है और मॉडल को Android डिवाइस पर पुश करें. अगर आप किसी मॉडल का इस्तेमाल कर रहे हैं Gemma के अलावा, आपको मॉडल को MediaPipe.
एलएलएम इन्फ़रेंस एपीआई के लिए, ट्रेन किए गए उपलब्ध मॉडल के बारे में ज़्यादा जानकारी पाने के लिए यह टास्क देखें मॉडल सेक्शन की खास जानकारी.
मॉडल डाउनलोड करें
एलएलएम इन्फ़रेंस एपीआई को शुरू करने से पहले, इसके साथ काम करने वाले किसी मॉडल को डाउनलोड करें और फ़ाइल को अपनी प्रोजेक्ट डायरेक्ट्री में सेव करें:
- Gemma 2B: लाइटवेट, आधुनिक ओपन मॉडल के परिवार का हिस्सा है, जिन्हें उसी रिसर्च और टेक्नोलॉजी का इस्तेमाल किया गया है जिसकी मदद से Gemini के मॉडल. कई अन्य संगठनों के लिए अच्छी है टेक्स्ट जनरेट करने से जुड़े टास्क. इनमें सवालों का जवाब देना, खास जानकारी देना, और तर्क के साथ.
- Phi-2: 2.7 अरब पैरामीटर ट्रांसफ़ॉर्मर मॉडल, सवालों के जवाब देने, चैट करने, और कोड के लिए सबसे सही है फ़ॉर्मैट.
- Falcon-RW-1B: 1 अरब सिर्फ़ पैरामीटर के कॉज़ल डिकोडर वाले मॉडल को, इसके 350 अरब टोकन पर ट्रेनिंग दी गई RefinedWeb.
- StableLM-3B: 3 अरब पैरामीटर डीकोडर-ओनली लैंग्वेज मॉडल को 10 खरबों पर प्री-ट्रेन किया गया के टोकन शामिल होंगे.
इसके अलावा, आपके पास मैप किए गए और एक्सपोर्ट किए गए मॉडल इस्तेमाल करने का भी विकल्प है एआई एज ट्रॉच.
हम Gemma 2B का इस्तेमाल करने का सुझाव देते हैं, जो Kaggle पर उपलब्ध है मॉडल और ये ऐसे फ़ॉर्मैट में होना चाहिए जो एलएलएम इन्फ़रेंस एपीआई के साथ पहले से ही काम करता हो. अगर आपको दूसरा एलएलएम है, तो आपको मॉडल को को MediaPipe-फ़्रेंडली फ़ॉर्मैट. Gemma 2B के बारे में ज़्यादा जानकारी के लिए, Gemma साइट पर जाएं. इसके अलावा, अन्य विषयों पर टास्क के लिए उपलब्ध मॉडल की खास जानकारी वाला मॉडल सेक्शन देखें.
मॉडल को MediaPipe फ़ॉर्मैट में बदलें
नेटिव मॉडल का कन्वर्ज़न
अगर आपने बाहरी एलएलएम (Phi-2, Falcon या StableLM) या किसी गैर-Kaggle का इस्तेमाल किया है Gemma का एक वर्शन है, तो हमारी कन्वर्ज़न स्क्रिप्ट का इस्तेमाल करके 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 के दूसरे विकल्प भी. ध्यान दें कि केवल API
जीपीयू के साथ, 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. |
पाथ |
ckpt_format |
मॉडल फ़ाइल फ़ॉर्मैट. | {"safetensors", "pytorch"} |
model_type |
एलएलएम को बदला जा रहा है. | {"PHI_2", "FALCON_RW_1B", "STABLELM_4E1T_3B", "GEMMA_2B"} |
backend |
मॉडल को चलाने के लिए इस्तेमाल किया जाने वाला प्रोसेसर (डेलीगेट). | {"cpu", "gpu"} |
output_dir |
हर लेयर की वेट वाली फ़ाइलों को होस्ट करने वाली आउटपुट डायरेक्ट्री का पाथ. | पाथ |
output_tflite_file |
आउटपुट फ़ाइल का पाथ. उदाहरण के लिए, "model_cpu.bin" या "model_gpu.bin" है. यह फ़ाइल सिर्फ़ LLM Inference API के साथ काम करती है. इसे सामान्य `tflite` फ़ाइल के तौर पर इस्तेमाल नहीं किया जा सकता. | पाथ |
vocab_model_file |
उस डायरेक्ट्री का पाथ जिसमें tokenizer.json और
tokenizer_config.json फ़ाइलें. Gemma के लिए, एक tokenizer.model फ़ाइल पर कर्सर ले जाएं. |
पाथ |
lora_ckpt |
सेफ़टेन्सर फ़ाइल के LoRA ckpt का पाथ, जो LoRA अडैप्टर की मोटाई को स्टोर करता है. | पाथ |
lora_rank |
LoRA cpt की रैंक को दिखाने वाला पूर्णांक. लॉरा भार को बदलने के लिए ज़रूरी है. अगर यह वैल्यू नहीं दी जाती है, तो कन्वर्टर यह मान लेता है कि कोई लोआरए वेट नहीं है. ध्यान दें: सिर्फ़ जीपीयू बैकएंड, LoRA के साथ काम करता है. | पूर्णांक |
lora_output_tflite_file |
LoRA वज़न के लिए आउटपुट tflite फ़ाइल नाम. | पाथ |
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 मॉडल. | पाथ |
tokenizer_model |
सेंटेंसपीस टोकनाइज़र मॉडल का पाथ. | पाथ |
start_token |
मॉडल के हिसाब से स्टार्ट टोकन. स्टार्ट टोकन इसमें मौजूद होना चाहिए: उपलब्ध कराया गया टोकनाइज़र मॉडल. | स्ट्रिंग |
stop_tokens |
मॉडल के हिसाब से स्टॉप टोकन. स्टॉप टोकन उपलब्ध कराया गया टोकनाइज़र मॉडल. | सूची[STRING] |
output_filename |
आउटपुट टास्क बंडल फ़ाइल का नाम. | पाथ |
मॉडल को डिवाइस पर पुश करें
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 Inफ़रेंस एपीआई, 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 |
प्रोजेक्ट डायरेक्ट्री में मॉडल को सेव करने के लिए पाथ. | पाथ | लागू नहीं |
maxTokens |
मॉडल, ज़्यादा से ज़्यादा कितने टोकन (इनपुट टोकन + आउटपुट टोकन) हैंडल करता है. | पूर्णांक | 512 |
topK |
टोकन की वह संख्या जिसे मॉडल, जनरेशन के हर चरण में स्वीकार करता है. अनुमान को टॉप के सबसे ज़्यादा संभावित टोकन तक सीमित रखा जाता है. | पूर्णांक | 40 |
temperature |
जनरेशन के दौरान दिखने वाली रैंडमनेस. बहुत ज़्यादा तापमान की वजह से जनरेट किए गए टेक्स्ट में ज़्यादा क्रिएटिविटी दिखनी चाहिए. साथ ही, कम तापमान से जनरेट हुए डेटा का अनुमान लगाया जा सकता है. | फ़्लोट | 0.8 |
randomSeed |
टेक्स्ट जनरेट करने के दौरान इस्तेमाल किया गया रैंडम सीड. | पूर्णांक | 0 |
loraPath |
डिवाइस पर स्थानीय तौर पर LoRA मॉडल का ऐब्सलूट पाथ. ध्यान दें: यह सुविधा सिर्फ़ जीपीयू मॉडल के साथ काम करती है. | पाथ | लागू नहीं |
resultListener |
एसिंक्रोनस तरीके से नतीजे पाने के लिए, रिज़ल्ट लिसनर को सेट करता है. सिर्फ़ तब लागू होता है, जब एक साथ काम नहीं करने वाली प्रोसेस जनरेट करने का तरीका इस्तेमाल किया जा रहा हो. | लागू नहीं | लागू नहीं |
errorListener |
गड़बड़ी की जानकारी देने वाला वैकल्पिक लिसनर सेट करता है. | लागू नहीं | लागू नहीं |
डेटा तैयार करें
एलएलएम इन्फ़रेंस एपीआई में ये इनपुट स्वीकार किए जाते हैं:
- prompt (स्ट्रिंग): कोई सवाल या प्रॉम्प्ट.
val inputPrompt = "Compose an email to remind Brett of lunch plans at noon on Saturday."
टास्क को पूरा करें
इनपुट के लिए टेक्स्ट रिस्पॉन्स जनरेट करने के लिए, generateResponse() तरीके का इस्तेमाल करें
पिछले सेक्शन (inputPrompt) में दिया गया टेक्स्ट. इससे एक
जनरेट किया गया जवाब.
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 मॉडल को पसंद के मुताबिक बनाने की सुविधा
लो-रैंक एडैप्टेशन (LoRA) के साथ काम करने के लिए, MediaMedia एलएलएम इंफ़रेंस एपीआई को कॉन्फ़िगर किया जा सकता है के लिए सबसे अच्छा विकल्प हो सकता है. बेहतर बनाए गए LoRA मॉडल का इस्तेमाल करके, डेवलपर ये काम कर सकते हैं: एलएलएम के काम करने के तरीके को ज़रूरत के मुताबिक बनाने के लिए, कम कीमत वाली ट्रेनिंग प्रोसेस का इस्तेमाल कर सकते हैं.
एलएलएम इन्फ़रेंस एपीआई, LoRA के साथ काम करता है. यह Gemma-2B और Phi-2 मॉडल के साथ काम करता है: जीपीयू बैकएंड में उपलब्ध है, जहां LoRA वेट सिर्फ़ अटेंशन लेयर पर लागू होते हैं. यह शुरुआत में यह सुविधा, आने वाले समय के डेवलपमेंट के लिए प्रयोग के तौर पर उपलब्ध एपीआई के तौर पर काम करती है. आने वाले समय में, हम कई और मॉडल और अलग-अलग तरह की लेयर को सपोर्ट करने की योजना बना रहे हैं अपडेट.
LoRA मॉडल तैयार करना
HuggingFace के बारे में दिए गए निर्देशों का पालन करके, Gemma-2B या Phi-2 वाले अपने डेटासेट पर बेहतर तरीके से ट्यून किए गए LoRA मॉडल को ट्रेनिंग दें. 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 Flatbuffer में बदलना होगा. 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 LLM Inference API को अपडेट किया गया है. वेब पर, डाइनैमिक 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() तरीकों का ही इस्तेमाल करें.