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

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

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

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

क्विकस्टार्ट

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

डिपेंडेंसी जोड़ें

LLM Inference API, @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>

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

Kaggle के मॉडल से, Gemma-2 2B को 8-बिट क्वांटाइज़ किए गए फ़ॉर्मैट में डाउनलोड करें. उपलब्ध मॉडल के बारे में ज़्यादा जानने के लिए, मॉडल का दस्तावेज़ देखें.

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

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

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

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

टास्क शुरू करना

बुनियादी कॉन्फ़िगरेशन के विकल्पों की मदद से टास्क शुरू करें:

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-int8.bin'
    },
    maxTokens: 1000,
    topK: 40,
    temperature: 0.8,
    randomSeed: 101
});

टास्क चलाना

अनुमान ट्रिगर करने के लिए, generateResponse() फ़ंक्शन का इस्तेमाल करें.

const response = await llmInference.generateResponse(inputPrompt);
document.getElementById('output').textContent = response;

जवाब को स्ट्रीम करने के लिए, इनका इस्तेमाल करें:

llmInference.generateResponse(
  inputPrompt,
  (partialResult, done) => {
        document.getElementById('output').textContent += partialResult;
});

सैंपल ऐप्लिकेशन

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

यहां दिए गए कमांड का इस्तेमाल करके, Git डेटा स्टोर करने की जगह को क्लोन करें:

git clone https://github.com/google-ai-edge/mediapipe-samples

ज़्यादा जानकारी के लिए, वेब के लिए सेटअप गाइड देखें.

कॉन्फ़िगरेशन विकल्प

वेब ऐप्लिकेशन सेट अप करने के लिए, कॉन्फ़िगरेशन के इन विकल्पों का इस्तेमाल करें:

विकल्प का नाम ब्यौरा वैल्यू की रेंज डिफ़ॉल्ट मान
modelPath प्रोजेक्ट डायरेक्ट्री में मॉडल को सेव करने का पाथ. पाथ लागू नहीं
maxTokens मॉडल, ज़्यादा से ज़्यादा कितने टोकन (इनपुट टोकन + आउटपुट टोकन) हैंडल कर सकता है. पूर्णांक 512
topK जनरेट करने के हर चरण में, मॉडल जिन टोकन का इस्तेमाल करता है उनकी संख्या. सबसे ज़्यादा संभावित टोकन के लिए, अनुमान लगाने की सुविधा को सीमित करता है. पूर्णांक 40
temperature जनरेट करने के दौरान, रैंडम तरीके से जोड़े गए एलिमेंट की संख्या. ज़्यादा तापमान होने पर, जनरेट किए गए टेक्स्ट में ज़्यादा क्रिएटिविटी दिखती है. वहीं, कम तापमान होने पर, अनुमान के मुताबिक टेक्स्ट जनरेट होता है. फ़्लोट 0.8
randomSeed टेक्स्ट जनरेट करने के दौरान इस्तेमाल किया जाने वाला रैंडम सीड. पूर्णांक 0
loraRanks रनटाइम के दौरान LoRA मॉडल के इस्तेमाल के लिए LoRA रैंक. ध्यान दें: यह सुविधा सिर्फ़ GPU मॉडल के साथ काम करती है. इंटिजर कलेक्शन लागू नहीं

मॉडल कन्वर्ज़न

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

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

LoRA को पसंद के मुताबिक बनाना

एलएलएम इंफ़रेंस एपीआई, PEFT (पैरामीटर-बेहतर फ़ाइन-ट्यूनिंग) लाइब्रेरी का इस्तेमाल करके, LoRA (कम रैंक वाला अडैप्टेशन) ट्यूनिंग के साथ काम करता है. LoRA ट्यूनिंग, कम लागत वाली ट्रेनिंग प्रोसेस की मदद से एलएलएम के व्यवहार को पसंद के मुताबिक बनाती है. इसके लिए, पूरे मॉडल को फिर से ट्रेन करने के बजाय, नए ट्रेनिंग डेटा के आधार पर ट्रेन किए जा सकने वाले वेट का एक छोटा सेट बनाया जाता है.

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

LoRA वज़न बनाने के लिए, बेस मॉडल safetensors फ़ॉर्मैट में होना चाहिए. LoRA ट्रेनिंग के बाद, MediaPipe पर चलाने के लिए मॉडल को FlatBuffers फ़ॉर्मैट में बदला जा सकता है.

LoRA वेट तैयार करना

अपने डेटासेट पर बेहतर LoRA मॉडल को ट्रेन करने के लिए, PEFT की LoRA के तरीकों वाली गाइड का इस्तेमाल करें.

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 मॉडल के वेट adapter_model.safetensors में उपलब्ध होते हैं. safetensors फ़ाइल, LoRA चेकपॉइंट है. इसका इस्तेमाल मॉडल कन्वर्ज़न के दौरान किया जाता है.

मॉडल कन्वर्ज़न

मॉडल के वज़न को Flatbuffer फ़ॉर्मैट में बदलने के लिए, MediaPipe Python पैकेज का इस्तेमाल करें. ConversionConfig, बुनियादी मॉडल के विकल्पों के साथ-साथ, LoRA के अन्य विकल्पों के बारे में बताता है.

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_FILE,
)

converter.convert_checkpoint(config)

कनवर्टर, MediaPipe के साथ काम करने वाली दो फ़ाइलें जनरेट करेगा. एक बेस मॉडल के लिए और दूसरी 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 मॉडल को ट्रिगर करें.

// 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;
});