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

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

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

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

AI Edge Torch का इस्तेमाल करके, PyTorch मॉडल को मल्टी-सिग्नेचर LiteRT (tflite) मॉडल में एक्सपोर्ट किया जा सकता है. ये मॉडल, टास्क बंडल बनाने के लिए टोकनाइज़र पैरामीटर के साथ बंडल किए जाते हैं. AI Edge Torch की मदद से बदले गए मॉडल, LLM Inference API के साथ काम करते हैं. साथ ही, इन्हें सीपीयू बैकएंड पर चलाया जा सकता है. इसलिए, ये 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 Community की HuggingFace रिपॉज़िटरी से, पहले से ही बदले गए मॉडल का इस्तेमाल किया जा सकता है. इसके अलावा, AI Edge Torch Generative Converter की मदद से, किसी मॉडल को MediaPipe के साथ काम करने वाले फ़ॉर्मैट में बदला जा सकता है.

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

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

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

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

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

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

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