एलएलएम इंफ़रेंस एपीआई, आपको वेब ऐप्लिकेशन के लिए ब्राउज़र पर पूरी तरह से लार्ज लैंग्वेज मॉडल (एलएलएम) चलाने की सुविधा देता है. इनका इस्तेमाल कई तरह के कामों के लिए किया जा सकता है. जैसे, टेक्स्ट जनरेट करना, नैचुरल लैंग्वेज में जानकारी पाना, और दस्तावेज़ों की खास जानकारी देना. इस टास्क में, एक से ज़्यादा टेक्स्ट-टू-टेक्स्ट लार्ज लैंग्वेज मॉडल का इस्तेमाल किया जा सकता है ताकि आप डिवाइस पर मौजूद नए जनरेटिव एआई मॉडल को अपने वेब ऐप्लिकेशन पर लागू कर सकें.
आपके पास इस टास्क को MediaPipe Studio के डेमो की मदद से, कार्रवाई के तौर पर देखने का विकल्प है. इस टास्क की क्षमताओं, मॉडल, और कॉन्फ़िगरेशन विकल्पों के बारे में ज़्यादा जानकारी के लिए, खास जानकारी देखें.
कोड का उदाहरण
एलएलएम अनुमान एपीआई के लिए उदाहरण वाले ऐप्लिकेशन में, आपके रेफ़रंस के लिए JavaScript में इस टास्क को बुनियादी तौर पर लागू करने के बारे में बताया गया है. अपना खुद का टेक्स्ट जनरेट करने वाला ऐप्लिकेशन बनाने के लिए, इस सैंपल ऐप्लिकेशन का इस्तेमाल किया जा सकता है.
एलएलएम इंफ़रेंस एपीआई GitHub पर उदाहरण ऐप्लिकेशन को ऐक्सेस किया जा सकता है.
सेटअप
इस सेक्शन में, डेवलपमेंट एनवायरमेंट को सेट अप करने के मुख्य चरणों के बारे में बताया गया है. साथ ही, ऐसे कोड प्रोजेक्ट भी बताए गए हैं जिन्हें खास तौर पर एलएलएम इंफ़रेंस एपीआई इस्तेमाल करने के मकसद से इस्तेमाल किया जाता है. MediaPipe Tasks का इस्तेमाल करने और प्लैटफ़ॉर्म वर्शन की ज़रूरी शर्तों के साथ-साथ अपना डेवलपमेंट एनवायरमेंट सेट अप करने से जुड़ी सामान्य जानकारी के लिए, वेब के लिए सेटअप गाइड देखें.
वेबसाइट का अलग-अलग ब्राउज़र पर चलना
एलएलएम अनुमान एपीआई के लिए, WebGPU के साथ काम करने वाले वेब ब्राउज़र की ज़रूरत होती है. साथ काम करने वाले ब्राउज़र की पूरी सूची देखने के लिए, GPU ब्राउज़र के साथ काम करने की सुविधा देखें.
JavaScript पैकेज
एलएलएम अनुमान एपीआई कोड, @mediapipe/tasks-genai पैकेज के ज़रिए उपलब्ध होता है. प्लैटफ़ॉर्म की सेटअप गाइड में दिए गए लिंक से इन लाइब्रेरी को ढूंढा और डाउनलोड किया जा सकता है.
लोकल स्टेजिंग के लिए ज़रूरी पैकेज इंस्टॉल करें:
npm install @mediapipe/tasks-genai
किसी सर्वर पर डिप्लॉय करने के लिए, सीधे अपने एचटीएमएल पेज पर कोड जोड़ने के लिए jsDelivr जैसी कॉन्टेंट डिलीवरी नेटवर्क (सीडीएन) सेवा का इस्तेमाल करें:
<head>
<script src="https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai/genai_bundle.cjs"
crossorigin="anonymous"></script>
</head>
मॉडल
MediaPipe LLM Infrence API को एक प्रशिक्षित मॉडल की ज़रूरत होती है, जो इस टास्क के साथ काम कर सके. वेब ऐप्लिकेशन के लिए, मॉडल जीपीयू के साथ काम करने वाला होना चाहिए.
एलएलएम इंफ़रेंस एपीआई के लिए उपलब्ध ट्रेनिंग मॉडल के बारे में ज़्यादा जानने के लिए, टास्क की खास जानकारी वाला मॉडल सेक्शन देखें.
मॉडल डाउनलोड करना
एलएलएम इंफ़रेंस एपीआई को शुरू करने से पहले, इस्तेमाल किया जा सकने वाला कोई मॉडल डाउनलोड करें और फ़ाइल को अपने प्रोजेक्ट डायरेक्ट्री में सेव करें:
- जेम्मा: यह एक हल्के और सबसे आधुनिक ओपन मॉडल के ग्रुप का हिस्सा है. इन्हें उसी रिसर्च और टेक्नोलॉजी से बनाया गया है जिसका इस्तेमाल Gemini मॉडल को बनाने के लिए किया गया था. यह टेक्स्ट जनरेट करने वाले कई तरह के टास्क में काम आता है. जैसे, सवाल का जवाब देना, ख़ास जानकारी देना, और तर्क देना. Gemma 2B या Gemma 7B मॉडल वाला वैरिएंट डाउनलोड करें.
- Phi-2: 2.7 अरब पैरामीटर ट्रांसफ़ॉर्मर मॉडल, जो सवाल के जवाब, चैट, और कोड फ़ॉर्मैट के लिए सबसे सही है.
- Falcon-RW-1B: यह एक अरब पैरामीटर कॉज़ल डिकोडर वाला मॉडल है. इसे RefinedWeb के 350B टोकन पर ट्रेनिंग दी गई है.
- StableLM-3B: अंग्रेज़ी और कोड के अलग-अलग डेटासेट के एक खरब टोकन पर, पहले से ट्रेन किया गया तीन अरब पैरामीटर डिकोडर भाषा का मॉडल.
हमारा सुझाव है कि आप Gemma 2B या Gemma 7B का इस्तेमाल करें. ये Kaggle मॉडल पर उपलब्ध हैं. ये ऐसे फ़ॉर्मैट में आते हैं जो LLM Infrence API के साथ पहले से काम करता है. अगर किसी दूसरे एलएलएम का इस्तेमाल किया जाता है, तो आपको मॉडल को MediaPipe-फ़्रेंडली फ़ॉर्मैट में बदलना होगा. जेम्मा के बारे में ज़्यादा जानकारी के लिए, Gemma साइट देखें. अन्य उपलब्ध मॉडल के बारे में ज़्यादा जानकारी के लिए, टास्क की खास जानकारी वाला मॉडल सेक्शन देखें.
मॉडल को 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 के साथ काम किया जा सकता है. | पूरी संख्या |
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 |
प्रोजेक्ट डायरेक्ट्री में मॉडल जोड़ें
मॉडल को अपनी प्रोजेक्ट डायरेक्ट्री में स्टोर करें:
<dev-project-root>/assets/gemma-2b-it-gpu-int4.bin
baseOptions ऑब्जेक्ट modelAssetPath पैरामीटर का इस्तेमाल करके, मॉडल का पाथ तय करें:
baseOptions: { modelAssetPath: `/assets/gemma-2b-it-gpu-int4.bin`}
टास्क बनाएं
अनुमान लगाने के लिए टास्क तैयार करने के लिए, एलएलएम अनुमान एपीआई createFrom...() फ़ंक्शन में से किसी एक का इस्तेमाल करें. ट्रेन की गई मॉडल फ़ाइल के रिलेटिव या ऐब्सलूट पाथ के साथ, createFromModelPath() फ़ंक्शन का इस्तेमाल किया जा सकता है. कोड के इस उदाहरण में, createFromOptions() फ़ंक्शन का इस्तेमाल किया गया है. कॉन्फ़िगरेशन के लिए उपलब्ध विकल्पों के बारे में ज़्यादा जानकारी के लिए, कॉन्फ़िगरेशन के विकल्प देखें.
नीचे दिया गया कोड इस टास्क को बनाने और कॉन्फ़िगर करने का तरीका बताता है:
const genai = await FilesetResolver.forGenAiTasks(
// path/to/wasm/root
"https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai@latest/wasm"
);
llmInference = await LlmInference.createFromOptions(genai, {
baseOptions: {
modelAssetPath: '/assets/gemma-2b-it-gpu-int4.bin'
},
maxTokens: 1000,
topK: 40,
temperature: 0.8,
randomSeed: 101
});
कॉन्फ़िगरेशन विकल्प
वेब और JavaScript ऐप्लिकेशन के लिए, इस टास्क में कॉन्फ़िगरेशन के ये विकल्प हैं:
| विकल्प का नाम | ब्यौरा | वैल्यू रेंज | डिफ़ॉल्ट मान |
|---|---|---|---|
modelPath |
प्रोजेक्ट डायरेक्ट्री में मॉडल को सेव करने की जगह का पाथ. | PATH | लागू नहीं |
maxTokens |
मॉडल द्वारा हैंडल किए जाने वाले टोकन (इनपुट टोकन + आउटपुट टोकन) की ज़्यादा से ज़्यादा संख्या. | पूरी संख्या | 512 |
topK |
जनरेट होने के हर चरण में मॉडल के हिसाब से टोकन की संख्या.
सुझावों को सबसे ऊपर के सबसे ज़्यादा संभावित टोकन तक सीमित करता है. topK को सेट करते समय, आपको randomSeed के लिए वैल्यू भी सेट करनी होगी. |
पूरी संख्या | 40 |
temperature |
जनरेट करने के दौरान की गई यादृच्छिकता की मात्रा. तापमान ज़्यादा होने पर,
जनरेट किए गए टेक्स्ट में ज़्यादा क्रिएटिविटी दिखती है. वहीं,
कम तापमान होने पर, इमेज का बेहतर तरीके से अनुमान लगाया जा सकता है. temperature को सेट करते समय, आपको randomSeed के लिए वैल्यू भी सेट करनी होगी. |
Float | 0.8 |
randomSeed |
टेक्स्ट जनरेट करने के दौरान इस्तेमाल किया गया कोई भी सीड. | पूरी संख्या | 0 |
loraRanks |
रनटाइम के दौरान, LoRA मॉडल इस्तेमाल करने के लिए LoRA रैंक का इस्तेमाल करता है. ध्यान दें: यह सुविधा सिर्फ़ जीपीयू मॉडल के साथ काम करती है. | पूर्णांक अरे | लागू नहीं |
डेटा तैयार करना
एलएलएम अनुमान एपीआई, टेक्स्ट (string) वाला डेटा स्वीकार करता है. यह टास्क, डेटा इनपुट की प्री-प्रोसेसिंग को हैंडल करता है. इसमें टोकनाइज़ेशन और टेंसर प्री-प्रोसेसिंग भी शामिल हैं.
सभी प्री-प्रोसेसिंग को generateResponse() फ़ंक्शन में हैंडल किया जाता है. इनपुट टेक्स्ट को पहले से प्रोसेस करने की कोई ज़रूरत नहीं है.
const inputPrompt = "Compose an email to remind Brett of lunch plans at noon on Saturday.";
टास्क चलाएं
एलएलएम अनुमान एपीआई, अनुमान ट्रिगर करने के लिए generateResponse() फ़ंक्शन का इस्तेमाल करता है.
टेक्स्ट की कैटगरी तय करने के लिए, इसका मतलब है कि इनपुट टेक्स्ट के लिए संभावित कैटगरी दिखाना.
नीचे दिया गया कोड बताता है कि टास्क मॉडल से प्रोसेसिंग को कैसे एक्ज़ीक्यूट करें.
const response = await llmInference.generateResponse(inputPrompt);
document.getElementById('output').textContent = response;
जवाब को स्ट्रीम करने के लिए, इनका इस्तेमाल करें:
llmInference.generateResponse(
inputPrompt,
(partialResult, done) => {
document.getElementById('output').textContent += partialResult;
});
नतीजे मैनेज करें और दिखाएं
एलएलएम अनुमान एपीआई एक स्ट्रिंग दिखाता है, जिसमें जनरेट किया गया जवाब का टेक्स्ट शामिल होता है.
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 वेट का इस्तेमाल किया जाता है.
रनटाइम के दौरान, वेब पर डाइनैमिक LoRA का इस्तेमाल किया जा सकता है. इसका मतलब है कि उपयोगकर्ता यह एलान करते हैं कि शुरू करने के दौरान, LoRA रैंक का इस्तेमाल किया जाएगा. साथ ही, रनटाइम के दौरान वे अलग-अलग LoRA मॉडल को बदल सकते हैं.const genai = await FilesetResolver.forGenAiTasks(
// path/to/wasm/root
"https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai@latest/wasm"
);
const llmInference = await LlmInference.createFromOptions(genai, {
// options for the base model
...
// LoRA ranks to be used by the LoRA models during runtime
loraRanks: [4, 8, 16]
});
रनटाइम के दौरान, बेस मॉडल शुरू होने के बाद, इस्तेमाल करने के लिए LoRA मॉडल लोड करें. साथ ही, एलएलएम रिस्पॉन्स जनरेट करने के दौरान, LoRA मॉडल रेफ़रंस को पास करके LoRA मॉडल को ट्रिगर करें.
// Load several LoRA models. The returned LoRA model reference is used to specify
// which LoRA model to be used for inference.
loraModelRank4 = await llmInference.loadLoraModel(loraModelRank4Url);
loraModelRank8 = await llmInference.loadLoraModel(loraModelRank8Url);
// Specify LoRA model to be used during inference
llmInference.generateResponse(
inputPrompt,
loraModelRank4,
(partialResult, done) => {
document.getElementById('output').textContent += partialResult;
});