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

LLM Inference API की मदद से, वेब ऐप्लिकेशन के लिए ब्राउज़र पर बड़े लैंग्वेज मॉडल (एलएलएम) चलाए जा सकते हैं. इनका इस्तेमाल कई तरह के कामों के लिए किया जा सकता है. जैसे, टेक्स्ट जनरेट करना, सामान्य भाषा में जानकारी हासिल करना, और दस्तावेज़ों की खास जानकारी देना. इस टास्क में, टेक्स्ट से टेक्स्ट में बदलने वाले कई लार्ज लैंग्वेज मॉडल के लिए, पहले से ही सहायता उपलब्ध होती है. इससे, डिवाइस पर मौजूद जनरेटिव एआई मॉडल को अपने वेब ऐप्लिकेशन में लागू किया जा सकता है.

यह टास्क, Gemma के इन वैरिएंट के साथ काम करता है: Gemma-3 1B, Gemma-2 2B, Gemma 2B, और Gemma 7B. Gemma एक लाइटवेट और बेहतरीन ओपन मॉडल है. इसे Gemini मॉडल में इस्तेमाल की गई रिसर्च और तकनीक का इस्तेमाल करके बनाया गया है. यह इन एक्सटर्नल मॉडल के साथ भी काम करता है: Phi-2, Falcon-RW-1B, और StableLM-3B.

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

कोड का उदाहरण

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

LLM Inference API के उदाहरण वाले ऐप्लिकेशन को GitHub पर ऐक्सेस किया जा सकता है.

सेटअप

इस सेक्शन में, LLM Inference API का इस्तेमाल करने के लिए, डेवलपमेंट एनवायरमेंट और प्रोजेक्ट को कोड करने के मुख्य चरणों के बारे में बताया गया है. MediaPipe Tasks का इस्तेमाल करने के लिए, डेवलपमेंट एनवायरमेंट सेट अप करने के बारे में सामान्य जानकारी पाने के लिए, वेब के लिए सेटअप गाइड देखें. इसमें, प्लैटफ़ॉर्म के वर्शन से जुड़ी ज़रूरी शर्तें भी शामिल हैं.

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

LLM Inference API के लिए, ऐसे वेब ब्राउज़र की ज़रूरत होती है जो WebGPU के साथ काम करता हो. साथ काम करने वाले ब्राउज़र की पूरी सूची के लिए, जीपीयू ब्राउज़र के साथ काम करने की सुविधा देखें.

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

LLM Inference API के लिए, पहले से ट्रेन किए गए मॉडल के बारे में ज़्यादा जानकारी के लिए, टास्क की खास जानकारी वाला मॉडल सेक्शन देखें.

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

LLM Inference API को शुरू करने से पहले, काम करने वाले किसी मॉडल को डाउनलोड करें और फ़ाइल को अपनी प्रोजेक्ट डायरेक्ट्री में सेव करें. हमारा सुझाव है कि आप Gemma-2 2B का इस्तेमाल करें. यह Kaggle के मॉडल पर उपलब्ध है.

आपके पास इनमें से किसी भी मॉडल को डाउनलोड करने का विकल्प है:

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

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

मॉडल को MediaPipe फ़ॉर्मैट में बदलना

LLM Inference API, इन टाइप के मॉडल के साथ काम करता है. इनमें से कुछ मॉडल के लिए, मॉडल को बदलना ज़रूरी होता है. अपने मॉडल के लिए ज़रूरी चरणों के तरीके की पहचान करने के लिए, टेबल का इस्तेमाल करें.

मॉडल कन्वर्ज़न का तरीका इन प्लैटफ़ॉर्म पर काम करता है फ़ाइल टाइप
Gemma-3 1B कन्वर्ज़न की ज़रूरत नहीं है Android, वेब .task
Gemma 2B, Gemma 7B, Gemma-2 2B कन्वर्ज़न की ज़रूरत नहीं है Android, iOS, वेब .bin
Phi-2, StableLM, Falcon MediaPipe कन्वर्ज़न स्क्रिप्ट Android, iOS, वेब .bin
PyTorch के सभी एलएलएम मॉडल AI Edge Torch जनरेटिव लाइब्रेरी Android, iOS .task

अन्य मॉडल को बदलने का तरीका जानने के लिए, मॉडल बदलना सेक्शन देखें.

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

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

<dev-project-root>/assets/gemma-2b-it-gpu-int4.bin

baseOptions ऑब्जेक्ट modelAssetPath पैरामीटर की मदद से, मॉडल का पाथ बताएं:

baseOptions: { modelAssetPath: `/assets/gemma-2b-it-gpu-int4.bin`}

टास्क बनाना

अनुमान लगाने के लिए टास्क तैयार करने के लिए, LLM Inference API 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 रैंक. ध्यान दें: यह सुविधा सिर्फ़ GPU मॉडल के साथ काम करती है. इंटिजर कलेक्शन लागू नहीं

डेटा तैयार करना

LLM Inference API, टेक्स्ट (string) डेटा स्वीकार करता है. यह टास्क, डेटा इनपुट को प्री-प्रोसेस करता है. इसमें, टोकनेज़ेशन और टेंसर प्री-प्रोसेसिंग भी शामिल है.

डेटा को प्री-प्रोसेस करने की सभी प्रोसेस, generateResponse() फ़ंक्शन में मैनेज की जाती है. इनपुट टेक्स्ट को पहले से प्रोसेस करने की ज़रूरत नहीं है.

const inputPrompt = "Compose an email to remind Brett of lunch plans at noon on Saturday.";

टास्क चलाना

LLM Inference API, अनुमान लगाने के लिए 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 LLM inference API को कॉन्फ़िगर करके, लार्ज लैंग्वेज मॉडल के लिए कम रैंक वाले अडैप्टेशन (LoRA) का इस्तेमाल किया जा सकता है. बेहतर बनाए गए LoRA मॉडल का इस्तेमाल करके, डेवलपर कम लागत वाली ट्रेनिंग प्रोसेस की मदद से एलएलएम के व्यवहार को पसंद के मुताबिक बना सकते हैं.

LLM इंफ़रेंस एपीआई के LoRA सपोर्ट की सुविधा, जीपीयू बैकएंड के लिए Gemma के सभी वैरिएंट और Phi-2 मॉडल के साथ काम करती है. इसमें LoRA वेट सिर्फ़ ध्यान देने वाली लेयर पर लागू होते हैं. शुरुआती तौर पर लागू किए गए इस एपीआई को, आने वाले समय में होने वाली नई सुविधाओं के लिए एक्सपेरिमेंट के तौर पर इस्तेमाल किया जाएगा. आने वाले अपडेट में, ज़्यादा मॉडल और अलग-अलग तरह की लेयर के साथ काम करने की सुविधाएं जोड़ी जाएंगी.

LoRA मॉडल तैयार करना

अपने डेटासेट पर बेहतर LoRA मॉडल को ट्रेन करने के लिए, HuggingFace पर दिए गए निर्देशों का पालन करें. इसके लिए, Gemma या Phi-2 जैसे काम करने वाले मॉडल टाइप का इस्तेमाल करें. Gemma-2 2B, Gemma 2B, और Phi-2 मॉडल, HuggingFace पर सुरक्षित टेंसर फ़ॉर्मैट में उपलब्ध हैं. LLM Inference API, सिर्फ़ ध्यान देने वाली लेयर पर LoRA का इस्तेमाल करता है. इसलिए, LoraConfig बनाते समय सिर्फ़ ध्यान देने वाली लेयर तय करें. इसके लिए, यह तरीका अपनाएं:

# For Gemma
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 पर उपलब्ध LLM के अनुमान लगाने वाले API के साथ इस्तेमाल किया जा सकता है. उदाहरण के लिए, Gemma-2B के लिए monsterapi/gemma-2b-lora-maths-orca-200k और Phi-2 के लिए lole25/phi-2-sft-ultrachat-lora.

तैयार किए गए डेटासेट पर ट्रेनिंग देने और मॉडल को सेव करने के बाद, आपको एक adapter_model.safetensors फ़ाइल मिलती है. इसमें, बेहतर बनाए गए LoRA मॉडल के वेट होते हैं. safetensors फ़ाइल, मॉडल कन्वर्ज़न में इस्तेमाल किया जाने वाला 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 मॉडल का अनुमान

वेब, Android, और iOS LLM इंफ़रेंस एपीआई को अपडेट किया गया है, ताकि 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;
});