वेब के लिए एलएलएम का अनुमान लगाने से जुड़ी गाइड

एलएलएम इन्फ़्रेंस एपीआई की मदद से, लार्ज लैंग्वेज मॉडल (एलएलएम) को पूरी तरह से ब्राउज़र, जिसे वेब ऐप्लिकेशन के लिए ब्राउज़र इस्तेमाल किया जा सकता है. टास्क, जैसे कि टेक्स्ट जनरेट करना, नैचुरल लैंग्वेज में जानकारी हासिल करना, और दस्तावेज़ों की खास जानकारी तैयार करने में मदद मिलती है. यह टास्क, एक से ज़्यादा उपयोगकर्ताओं के लिए पहले से मौजूद काम करता है टेक्स्ट-टू-टेक्स्ट बड़े लैंग्वेज मॉडल, ताकि आप डिवाइस पर मौजूद नए वर्शन को लागू कर सकें आपके वेब ऐप्लिकेशन के लिए जनरेटिव एआई मॉडल.

MediaPipe Studio में, इस टास्क को काम करते हुए देखा जा सकता है डेमो. क्षमताओं, मॉडल, और कॉन्फ़िगरेशन के विकल्पों के बारे में ज़्यादा जानकारी पाने के लिए इस टास्क की खास जानकारी देखें.

कोड का उदाहरण

एलएलएम इन्फ़रेंस एपीआई के लिए उदाहरण के तौर पर दिया गया ऐप्लिकेशन, इन चीज़ों को बुनियादी तौर पर लागू करने की सुविधा देता है आपके संदर्भ के लिए JavaScript में इस काम को शामिल करें. यह जानकारी पाने के लिए, अपना टेक्स्ट जनरेट करने वाला ऐप्लिकेशन बनाना शुरू कर दिया है.

एलएलएम इन्फ़रेंस एपीआई के उदाहरण के तौर पर दिए गए ऐप्लिकेशन को यहां से ऐक्सेस किया जा सकता है GitHub.

सेटअप

इस सेक्शन में, आपके डेवलपमेंट एनवायरमेंट को सेट अप करने और खास तौर पर, एलएलएम इन्फ़रेंस एपीआई का इस्तेमाल करने के लिए कोड प्रोजेक्ट किए जाते हैं. इस पर सामान्य जानकारी के लिए MediaPipe Tasks का इस्तेमाल करने के लिए अपना डेवलपमेंट एनवायरमेंट सेट अप करना. इसमें प्लैटफ़ॉर्म वर्शन की ज़रूरी शर्तें, Google के सभी प्रॉडक्ट के लिए सेटअप गाइड वेब.

ब्राउज़र के साथ काम करना

LLM Inference API का इस्तेमाल करने के लिए, ऐसा वेब ब्राउज़र होना ज़रूरी है जिसमें 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 Inference API के लिए, एक प्रशिक्षित मॉडल की ज़रूरत होती है, जो इस एपीआई के साथ काम कर सकता हो टास्क. वेब ऐप्लिकेशन के लिए मॉडल, जीपीयू के साथ काम करने वाला होना चाहिए.

एलएलएम इन्फ़रेंस एपीआई के लिए, ट्रेन किए गए उपलब्ध मॉडल के बारे में ज़्यादा जानकारी पाने के लिए यह टास्क देखें मॉडल सेक्शन की खास जानकारी.

मॉडल डाउनलोड करें

एलएलएम इन्फ़रेंस एपीआई को शुरू करने से पहले, इसके साथ काम करने वाले किसी मॉडल को डाउनलोड करें और फ़ाइल को अपनी प्रोजेक्ट डायरेक्ट्री में सेव करें:

  • Gemma: लाइटवेट, आधुनिक ओपन मॉडल के परिवार का हिस्सा है, जिन्हें उसी रिसर्च और टेक्नोलॉजी का इस्तेमाल किया गया है जिसकी मदद से Gemini के मॉडल. कई अन्य संगठनों के लिए अच्छी है टेक्स्ट जनरेट करने से जुड़े टास्क. इनमें सवालों का जवाब देना, खास जानकारी देना, और तर्क के साथ. Gemma 2B या Gemma 7B मॉडल वैरिएंट डाउनलोड करें.
  • Phi-2: 2.7 अरब पैरामीटर ट्रांसफ़ॉर्मर मॉडल, सवालों के जवाब देने, चैट करने, और कोड के लिए सबसे सही है फ़ॉर्मैट.
  • Falcon-RW-1B: 1 अरब सिर्फ़ पैरामीटर के कॉज़ल डिकोडर वाले मॉडल को, इसके 350 अरब टोकन पर ट्रेनिंग दी गई RefinedWeb.
  • StableLM-3B: 3 अरब पैरामीटर डीकोडर-ओनली लैंग्वेज मॉडल को 10 खरबों पर प्री-ट्रेन किया गया के टोकन शामिल होंगे.

हम Gemma 2B या Gemma 7B का इस्तेमाल करने का सुझाव देते हैं, जो Kaggle पर उपलब्ध हैं मॉडल और ये ऐसे फ़ॉर्मैट में होना चाहिए जो एलएलएम इन्फ़रेंस एपीआई के साथ पहले से ही काम करता हो. अगर आपको दूसरा एलएलएम है, तो आपको मॉडल को को MediaPipe-फ़्रेंडली फ़ॉर्मैट. Gemma के बारे में ज़्यादा जानकारी के लिए, 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 एलएलएम को बदला जा रहा है. {&quot;PHI_2&quot;, &quot;FALCON_RW_1B&quot;, &quot;STABLELM_4E1T_3B&quot;, &quot;GEMMA_2B&quot;}
backend मॉडल को चलाने के लिए इस्तेमाल किया जाने वाला प्रोसेसर (डेलीगेट). {&quot;cpu&quot;, &quot;gpu&quot;}
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 आउटपुट टास्क बंडल फ़ाइल का नाम. पाथ

मॉडल को प्रोजेक्ट डायरेक्ट्री में जोड़ें

मॉडल को अपनी प्रोजेक्ट डायरेक्ट्री में सेव करें:

<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 प्रोजेक्ट डायरेक्ट्री में मॉडल को सेव करने के लिए पाथ. पाथ लागू नहीं
maxTokens मॉडल, ज़्यादा से ज़्यादा कितने टोकन (इनपुट टोकन + आउटपुट टोकन) हैंडल करता है. पूर्णांक 512
topK टोकन की वह संख्या जिसे मॉडल, जनरेशन के हर चरण में स्वीकार करता है. अनुमान को टॉप के सबसे ज़्यादा संभावित टोकन तक सीमित रखा जाता है. पूर्णांक 40
temperature जनरेशन के दौरान दिखने वाली रैंडमनेस. बहुत ज़्यादा तापमान की वजह से जनरेट किए गए टेक्स्ट में ज़्यादा क्रिएटिविटी दिखनी चाहिए. साथ ही, कम तापमान से जनरेट हुए डेटा का अनुमान लगाया जा सकता है. फ़्लोट 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 मॉडल को पसंद के मुताबिक बनाने की सुविधा

लो-रैंक एडैप्टेशन (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 वज़न का उपयोग करता है.

रनटाइम के दौरान, वेब पर डाइनैमिक 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;
});