एलएलएम का अनुमान लगाने वाली गाइड

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

इसे आज़माएं!arrow_forward

इस टास्क में, कई तरह के एलएलएम के लिए पहले से सहायता उपलब्ध होती है. LiteRT कम्यूनिटी पेज पर होस्ट किए गए मॉडल, MediaPipe के हिसाब से फ़ॉर्मैट में उपलब्ध होते हैं. साथ ही, उन्हें किसी और फ़ॉर्मैट में बदलने या कंपाइल करने की ज़रूरत नहीं होती.

AI Edge Torch का इस्तेमाल करके, PyTorch मॉडल को मल्टी-सिग्नेचर LiteRT (tflite) मॉडल में एक्सपोर्ट किया जा सकता है. ये मॉडल, टास्क बंडल बनाने के लिए टोकनेटर पैरामीटर के साथ बंडल किए जाते हैं. एआई एज टॉर्च की मदद से बदले गए मॉडल, एलएलएम इंफ़रेंस एपीआई के साथ काम करते हैं. साथ ही, ये सीपीयू बैकएंड पर चल सकते हैं. इस वजह से, ये Android और iOS ऐप्लिकेशन के लिए सही होते हैं.

शुरू करें

अपने टारगेट प्लैटफ़ॉर्म के लिए, लागू करने से जुड़ी इनमें से किसी एक गाइड का पालन करके, इस टास्क का इस्तेमाल शुरू करें. प्लैटफ़ॉर्म के हिसाब से बनी इन गाइड में, इस टास्क को लागू करने के बुनियादी तरीके के बारे में बताया गया है. साथ ही, इनमें उपलब्ध मॉडल और सुझाए गए कॉन्फ़िगरेशन के विकल्पों का इस्तेमाल करने वाले कोड के उदाहरण भी दिए गए हैं:

• वेब:

  • गाइड
  • कोड का उदाहरण

• Android:

  • गाइड
  • कोड का उदाहरण

• iOS

  • गाइड
  • कोड का उदाहरण

टास्क की जानकारी

इस सेक्शन में, इस टास्क की सुविधाओं, इनपुट, आउटपुट, और कॉन्फ़िगरेशन के विकल्पों के बारे में बताया गया है.

सुविधाएं

LLM Inference API में ये मुख्य सुविधाएं शामिल हैं:

1. टेक्स्ट से टेक्स्ट जनरेट करना - इनपुट टेक्स्ट प्रॉम्प्ट के आधार पर टेक्स्ट जनरेट करना.
2. एलएलएम चुनना - ऐप्लिकेशन को अपने खास इस्तेमाल के उदाहरणों के हिसाब से बनाने के लिए, एक से ज़्यादा मॉडल लागू करें. मॉडल को फिर से ट्रेन किया जा सकता है और उस पर पसंद के मुताबिक वेट लागू किए जा सकते हैं.
3. LoRA मॉडल के साथ काम करना - अपने सभी डेटासेट पर ट्रेनिंग देकर या ओपन-सोर्स कम्यूनिटी से पहले से तैयार LoRA मॉडल का इस्तेमाल करके, LoRA मॉडल की मदद से एलएलएम की सुविधा को बढ़ाएं और उसे पसंद के मुताबिक बनाएं. यह सुविधा, AI Edge Torch Generative API की मदद से बदले गए मॉडल के साथ काम नहीं करती.

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

इस टास्क के लिए, कॉन्फ़िगरेशन के ये विकल्प उपलब्ध हैं:

मॉडल

LLM Inference API, टेक्स्ट-टू-टेक्स्ट के कई बड़े लैंग्वेज मॉडल के साथ काम करता है. इसमें ब्राउज़र और मोबाइल डिवाइसों पर चलने के लिए ऑप्टिमाइज़ किए गए कई मॉडल के लिए, पहले से मौजूद सहायता भी शामिल है. इन छोटे मॉडल का इस्तेमाल, पूरी तरह से डिवाइस पर अनुमान लगाने के लिए किया जा सकता है.

LLM Inference API को शुरू करने से पहले, कोई मॉडल डाउनलोड करें और फ़ाइल को अपनी प्रोजेक्ट डायरेक्ट्री में सेव करें. LiteRT कम्यूनिटी के HuggingFace रिपॉज़िटरी में, पहले से बदले गए मॉडल का इस्तेमाल किया जा सकता है. इसके अलावा, AI Edge Torch जनरेटिव कन्वर्टर की मदद से, किसी मॉडल को MediaPipe के साथ काम करने वाले फ़ॉर्मैट में बदला जा सकता है.

अगर आपके पास LLM Inference API के साथ इस्तेमाल करने के लिए पहले से कोई एलएलएम नहीं है, तो इनमें से किसी एक मॉडल का इस्तेमाल शुरू करें.

Gemma-3 1B

Gemma-3 1B, Gemma फ़ैमिली का सबसे नया मॉडल है. यह लाइटवेट और बेहतरीन ओपन मॉडल है. इसे Gemini मॉडल में इस्तेमाल की गई रिसर्च और तकनीक का इस्तेमाल करके बनाया गया है. इस मॉडल में 10 करोड़ पैरामीटर और ओपन वेट शामिल हैं. 1B वैरिएंट, Gemma फ़ैमिली का सबसे छोटा मॉडल है. इसलिए, इसे डिवाइस पर इस्तेमाल करने के कई उदाहरणों के लिए आदर्श माना जाता है.

Gemma-3 1B डाउनलोड करें

HuggingFace का Gemma-3 1B मॉडल, .task फ़ॉर्मैट में उपलब्ध है. साथ ही, यह Android और वेब ऐप्लिकेशन के लिए एलएलएम इंफ़रेंस एपीआई के साथ इस्तेमाल के लिए तैयार है.

LLM Inference API के साथ Gemma-3 1B को चलाते समय, इन विकल्पों को इस हिसाब से कॉन्फ़िगर करें:

• preferredBackend: CPU या GPU के बीच से किसी एक बैकएंड को चुनने के लिए, इस विकल्प का इस्तेमाल करें. यह विकल्प सिर्फ़ Android के लिए उपलब्ध है.
• supportedLoraRanks: LLM Inference API को Gemma-3 1B मॉडल के साथ, कम रैंक वाले अडैप्टेशन (LoRA) के साथ काम करने के लिए कॉन्फ़िगर नहीं किया जा सकता. supportedLoraRanks या loraRanks विकल्पों का इस्तेमाल न करें.
• maxTokens: maxTokens की वैल्यू, मॉडल में बनाए गए कॉन्टेक्स्ट साइज़ से मेल खानी चाहिए. इसे की-वैल्यू (KV) कैश या कॉन्टेक्स्ट की लंबाई भी कहा जा सकता है.
• numResponses: यह हमेशा 1 होना चाहिए. यह विकल्प सिर्फ़ वेब के लिए उपलब्ध है.

वेब ऐप्लिकेशन पर Gemma-3 1B को चलाने पर, शुरू करने की प्रोसेस की वजह से मौजूदा थ्रेड में लंबे समय तक ब्लॉक हो सकता है. अगर हो सके, तो मॉडल को हमेशा वर्कर्स थ्रेड से चलाएं.

जेमा-2 2B

Gemma-2 2B, Gemma-2 का 2B वैरिएंट है और यह सभी प्लैटफ़ॉर्म पर काम करता है.

Gemma-2 2B डाउनलोड करें

इस मॉडल में 2B पैरामीटर और ओपन वेट शामिल हैं. Gemma-2 2B, अपनी क्लास के मॉडल के लिए, सबसे बेहतर तरीके से तर्क करने की सुविधाओं के लिए जाना जाता है.

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

AI Edge Torch जनरेटिव एपीआई की मदद से, PyTorch जनरेटिव मॉडल को MediaPipe के साथ काम करने वाले फ़ॉर्मैट में बदला जा सकता है. PyTorch मॉडल को मल्टी-सिग्नेचर LiteRT (TensorFlow Lite) मॉडल में बदलने के लिए, एपीआई का इस्तेमाल किया जा सकता है. मॉडल को मैप करने और एक्सपोर्ट करने के बारे में ज़्यादा जानकारी के लिए, AI Edge Torch के GitHub पेज पर जाएं.

AI Edge Torch जनरेटिव एपीआई का इस्तेमाल करके, PyTorch मॉडल को बदलने के लिए, यह तरीका अपनाएं:

1. PyTorch मॉडल के चेकपॉइंट डाउनलोड करें.
2. मॉडल को लिखने, बदलने, और उसे MediaPipe के साथ काम करने वाले फ़ाइल फ़ॉर्मैट (.tflite) में बदलने के लिए, AI Edge Torch जनरेटिव एपीआई का इस्तेमाल करें.
3. tflite फ़ाइल और मॉडल टॉकेनेटर से टास्क बंडल (.task) बनाएं.

Torch Generative Converter सिर्फ़ सीपीयू के लिए बदलाव करता है. इसके लिए, कम से कम 64 जीबी रैम वाली Linux मशीन की ज़रूरत होती है.

टास्क बंडल बनाने के लिए, बंडलिंग स्क्रिप्ट का इस्तेमाल करके टास्क बंडल बनाएं. बंडलिंग की प्रोसेस, मैप किए गए मॉडल को अतिरिक्त मेटाडेटा के साथ पैक करती है. उदाहरण के लिए, Tokenizer पैरामीटर) की ज़रूरत होती है.

मॉडल को बंडल करने की प्रोसेस के लिए, 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)

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 मॉडल के इंफ़रेंस की सुविधा काम कर सके.

// 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() तरीकों का इस्तेमाल करें.