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

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

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

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

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

शुरू करें

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

• वेब:

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

• Android:

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

• iOS

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

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

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

सुविधाएं

एलएलएम इन्फ़रेंस एपीआई में ये मुख्य सुविधाएं शामिल हैं:

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

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

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

मॉडल

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

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

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

Gemma-3n

Gemma-3n E2B और E4B, Gemma के सबसे नए मॉडल हैं. ये लाइटवेट और बेहतरीन ओपन मॉडल हैं. इन्हें Gemini मॉडल में इस्तेमाल की गई रिसर्च और तकनीक का इस्तेमाल करके बनाया गया है. Gemma 3n मॉडल को, कम संसाधन वाले डिवाइसों पर बेहतर तरीके से काम करने के लिए डिज़ाइन किया गया है. ये मॉडल, मल्टीमॉडल इनपुट ले सकते हैं. साथ ही, टेक्स्ट, इमेज, और ऑडियो इनपुट को प्रोसेस कर सकते हैं. इसके अलावा, ये टेक्स्ट आउटपुट जनरेट कर सकते हैं.

Gemma 3n मॉडल, चुनिंदा पैरामीटर चालू करने की टेक्नोलॉजी का इस्तेमाल करते हैं. इससे संसाधन की ज़रूरतें कम हो जाती हैं. इस तकनीक की मदद से मॉडल, 200 करोड़ और 400 करोड़ पैरामीटर के साथ काम कर पाते हैं. यह पैरामीटर की कुल संख्या से कम है

Gemma-3n E2B डाउनलोड करें

Gemma-3n E4B डाउनलोड करें

HuggingFace के Gemma-3n E2B और E4B मॉडल, .litertlm फ़ॉर्मैट में उपलब्ध हैं. साथ ही, ये Android और वेब के लिए LLM Inference API के साथ इस्तेमाल किए जा सकते हैं.

Gemma-3 1B

Gemini इस मॉडल में 100 करोड़ पैरामीटर हैं और यह ओपन वेट वाला मॉडल है.

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

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

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

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

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

Gemma-2 2B

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

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

इस मॉडल में 200 करोड़ पैरामीटर हैं और यह ओपन वेट वाला मॉडल है. Gemma-2 2B को इस क्लास के मॉडल के लिए, बेहतरीन तर्क देने की क्षमता के लिए जाना जाता है.

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

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

LiteRT Torch Generative API का इस्तेमाल करके, PyTorch मॉडल को बदलने के लिए यह तरीका अपनाएं:

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

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

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

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

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

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

अपने डेटासेट पर फ़ाइन ट्यून किए गए LoRA मॉडल को ट्रेन करने के लिए, HuggingFace पर दिए गए निर्देशों का पालन करें. इसके लिए, Gemma या Phi-2 जैसे मॉडल टाइप का इस्तेमाल करें. Gemma-2 2B, Gemma 2B, और Phi-2 मॉडल, safetensors फ़ॉर्मैट में HuggingFace पर उपलब्ध हैं. एलएलएम इन्फ़्रेंस एपीआई, सिर्फ़ अटेंशन लेयर पर 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 Inference 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 Inference API को अपडेट किया गया है, ताकि 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 के साथ LLM इन्फ़्रेंस चलाने के लिए, बेस मॉडल की तरह ही generateResponse() या generateResponseAsync() तरीकों का इस्तेमाल करें.