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

⚠️ ज़रूरी जानकारी: एलएलएम इन्फ़रेंस एपीआई का अपडेट

एलएलएम इन्फ़रेंस एपीआई के Android और iOS वर्शन को अब बंद कर दिया गया है. वेब वर्शन को बंद नहीं किया गया है

---

अपने मोबाइल प्रोजेक्ट को **LiteRT-LM** पर माइग्रेट करें, ताकि आपको लगातार सहायता और बेहतर परफ़ॉर्मेंस मिलती रहे.

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

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

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

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

शुरू करें

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

• वेब:

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

• Android:

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

• iOS

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

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

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

सुविधाएं

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

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

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

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

मॉडल

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

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

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

Gemma-3n

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

Gemma 3n मॉडल, रिसॉर्स की ज़रूरत को कम करने के लिए, चुनिंदा पैरामीटर ऐक्टिवेशन टेक्नोलॉजी का इस्तेमाल करते हैं. इस तकनीक की मदद से, मॉडल 2B और 4B पैरामीटर के साथ काम कर सकते हैं. यह उनके कुल पैरामीटर की संख्या से कम है

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

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

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

Gemma-3 1B

Gemma-3 1B, Gemma का सबसे लाइटवेट मॉडल है. Gemma, लाइटवेट और बेहतरीन ओपन मॉडल है. इसे Gemini मॉडल में इस्तेमाल की गई रिसर्च और तकनीक का इस्तेमाल करके बनाया गया है. इस मॉडल में 1B पैरामीटर और ओपन वेट शामिल हैं.

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

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

एलएलएम इन्फ़रेंस एपीआई के साथ Gemma-3 1B चलाने के लिए, इन विकल्पों को अपनी ज़रूरत के हिसाब से कॉन्फ़िगर करें:

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

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

Gemma-2 2B

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

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

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

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

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

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

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

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

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

Gemma या Phi-2 जैसे, काम करने वाले मॉडल टाइप के साथ, अपने डेटासेट पर फ़ाइन-ट्यून किया गया LoRA मॉडल ट्रेन करने के लिए, HuggingFace पर दिए गए निर्देशों का पालन करें. 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 पर एलएलएम इन्फ़रेंस एपीआई के साथ काम करते हैं. उदाहरण के लिए, monsterapi/gemma-2b-lora-maths-orca-200k के लिए monsterapi/gemma-2b-lora-maths-orca-200k और lole25/phi-2-sft-ultrachat-lora के लिए 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)

कन्वर्टर, दो टीएफ़एलइट फ़्लैटबफ़र फ़ाइलें आउटपुट करेगा. इनमें से एक, बेस मॉडल के लिए और दूसरी, LoRA मॉडल के लिए होगी.

LoRA मॉडल इन्फ़रेंस

वेब, Android, और iOS के एलएलएम इन्फ़रेंस एपीआई को, 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() तरीकों का इस्तेमाल करें.