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

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

यह टास्क, Gemma के इन वैरिएंट के साथ काम करता है: Gemma-2 2B, Gemma 2B, और Gemma 7B. Gemma एक लाइटवेट और बेहतरीन ओपन मॉडल है. इसे Gemini मॉडल में इस्तेमाल की गई रिसर्च और तकनीक का इस्तेमाल करके बनाया गया है. यह इन एक्सटर्नल मॉडल के साथ भी काम करता है: Phi-2, Falcon-RW-1B, और StableLM-3B.

काम करने वाले मॉडल के अलावा, उपयोगकर्ता Google के AI Edge Torch का इस्तेमाल करके, PyTorch के मॉडल को एक से ज़्यादा हस्ताक्षर वाले LiteRT (tflite) मॉडल में एक्सपोर्ट कर सकते हैं. ये मॉडल, tokenizer पैरामीटर के साथ बंडल किए जाते हैं, ताकि LLM के अनुमान लगाने वाले एपीआई के साथ काम करने वाले टास्क बंडल बनाए जा सकें.

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

कोड का उदाहरण

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

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

यहां दिए गए निर्देशों में, git कमांड-लाइन टूल का इस्तेमाल करके, उदाहरण के कोड की लोकल कॉपी बनाने का तरीका बताया गया है.

उदाहरण के तौर पर दिया गया कोड डाउनलोड करने के लिए:

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

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

2. इसके अलावा, अपने git इंस्टेंस को स्पैर्स चेकआउट का इस्तेमाल करने के लिए कॉन्फ़िगर करें, ताकि आपके पास सिर्फ़ LLM Inference API के उदाहरण वाले ऐप्लिकेशन की फ़ाइलें हों:

   cd mediapipe
   git sparse-checkout init --cone
   git sparse-checkout set examples/llm_inference/ios/
   

उदाहरण के तौर पर दिए गए कोड का लोकल वर्शन बनाने के बाद, MediaPipe टास्क लाइब्रेरी इंस्टॉल की जा सकती है. इसके बाद, Xcode का इस्तेमाल करके प्रोजेक्ट खोलें और ऐप्लिकेशन चलाएं. निर्देशों के लिए, iOS के लिए सेटअप गाइड देखें.

सेटअप

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

डिपेंडेंसी

LLM Inference API, MediaPipeTasksGenai लाइब्रेरी का इस्तेमाल करता है. इसे CocoaPods का इस्तेमाल करके इंस्टॉल करना ज़रूरी है. यह लाइब्रेरी, Swift और Objective-C, दोनों तरह के ऐप्लिकेशन के साथ काम करती है. साथ ही, इसके लिए भाषा के हिसाब से किसी अन्य सेटअप की ज़रूरत नहीं होती.

macOS पर CocoaPods इंस्टॉल करने के निर्देशों के लिए, CocoaPods को इंस्टॉल करने की गाइड देखें. अपने ऐप्लिकेशन के लिए ज़रूरी पॉड के साथ Podfile बनाने का तरीका जानने के लिए, CocoaPods का इस्तेमाल करना लेख पढ़ें.

नीचे दिए गए कोड का इस्तेमाल करके, Podfile में MediaPipeTasksGenai पॉड जोड़ें:

target 'MyLlmInferenceApp' do
  use_frameworks!
  pod 'MediaPipeTasksGenAI'
  pod 'MediaPipeTasksGenAIC'
end

अगर आपके ऐप्लिकेशन में यूनिट टेस्ट टारगेट शामिल हैं, तो Podfile को सेट अप करने के बारे में ज़्यादा जानकारी के लिए, iOS के लिए सेट अप करने की गाइड देखें.

मॉडल

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

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

कोई मॉडल डाउनलोड करें और Xcode का इस्तेमाल करके, उसे अपनी प्रोजेक्ट डायरेक्ट्री में जोड़ें. अपने Xcode प्रोजेक्ट में फ़ाइलें जोड़ने के तरीके के बारे में जानने के लिए, अपने Xcode प्रोजेक्ट में फ़ाइलों और फ़ोल्डर को मैनेज करना लेख पढ़ें.

LLM Inference API को शुरू करने से पहले, काम करने वाले किसी मॉडल को डाउनलोड करें और फ़ाइल को अपनी प्रोजेक्ट डायरेक्ट्री में सेव करें:

• Gemma-2 2B: Gemma फ़ैमिली के मॉडल का सबसे नया वर्शन. यह लाइटवेट और बेहतरीन ओपन मॉडल है. इसे Gemini मॉडल में इस्तेमाल की गई रिसर्च और तकनीक का इस्तेमाल करके बनाया गया है.
• Gemma 2B: यह लाइटवेट और बेहतरीन ओपन मॉडल है. इसे Gemini मॉडल में इस्तेमाल की गई रिसर्च और तकनीक का इस्तेमाल करके बनाया गया है. यह टेक्स्ट जनरेट करने के कई टास्क के लिए बेहतरीन है. जैसे, सवालों के जवाब देना, खास जानकारी देना, और तर्क देना.
• Phi-2: 2.7 बिलियन पैरामीटर वाला ट्रांसफ़ॉर्मर मॉडल, जो सवाल-जवाब, चैट, और कोड फ़ॉर्मैट के लिए सबसे सही है.
• Falcon-RW-1B: 1 अरब पैरामीटर वाला सिर्फ़ कैज़ल डिकोडर मॉडल, जिसे RefinedWeb के 350 अरब टोकन पर ट्रेन किया गया है.
• StableLM-3B: यह सिर्फ़ डिकोडर वाला 3 अरब पैरामीटर वाला लैंग्वेज मॉडल है. इसे अंग्रेज़ी और कोड के अलग-अलग डेटासेट के 1 ट्रिलियन टोकन पर पहले से ट्रेन किया गया है.

काम करने वाले मॉडल के अलावा, PyTorch मॉडल को मल्टी-सिग्नेचर LiteRT (tflite) मॉडल में एक्सपोर्ट करने के लिए, Google के AI Edge Torch का इस्तेमाल किया जा सकता है. ज़्यादा जानकारी के लिए, PyTorch मॉडल के लिए Torch जनरेटिव कन्वर्टर देखें.

हमारा सुझाव है कि आप Gemma-2 2B का इस्तेमाल करें. यह Kaggle के मॉडल पर उपलब्ध है. उपलब्ध अन्य मॉडल के बारे में ज़्यादा जानने के लिए, टास्क की खास जानकारी वाला मॉडल सेक्शन देखें.

मॉडल को MediaPipe फ़ॉर्मैट में बदलना

LLM Inference API, दो कैटगरी के मॉडल के साथ काम करता है. इनमें से कुछ मॉडल के लिए, मॉडल कन्वर्ज़न की ज़रूरत होती है. अपने मॉडल के लिए ज़रूरी चरणों के तरीके की पहचान करने के लिए, टेबल का इस्तेमाल करें.

हम Gemma 2B, Gemma 7B, और Gemma-2 2B के लिए, बदली गई .bin फ़ाइलों को Kaggle पर होस्ट कर रहे हैं. इन मॉडल को सीधे तौर पर, हमारे एलएलएम इंफ़रेंस एपीआई का इस्तेमाल करके डिप्लॉय किया जा सकता है. अन्य मॉडल को बदलने का तरीका जानने के लिए, मॉडल बदलना सेक्शन देखें.

टास्क बनाना

LLM Inference API टास्क बनाने के लिए, इसके किसी एक इनिशलाइज़र को कॉल करें. LlmInference(options:) initializer, कॉन्फ़िगरेशन के विकल्पों के लिए वैल्यू सेट करता है.

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

नीचे दिए गए कोड में, इस टास्क को बनाने और कॉन्फ़िगर करने का तरीका बताया गया है.

import MediaPipeTasksGenai

let modelPath = Bundle.main.path(forResource: "model",
                                      ofType: "bin")

let options = LlmInferenceOptions()
options.baseOptions.modelPath = modelPath
options.maxTokens = 1000
options.topk = 40
options.temperature = 0.8
options.randomSeed = 101

let llmInference = try LlmInference(options: options)

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

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

डेटा तैयार करना

LLM Inference API, टेक्स्ट डेटा के साथ काम करता है. यह टास्क, डेटा इनपुट को पहले से प्रोसेस करने की सुविधा देता है. इसमें, टोकनेज़ेशन और टेंसर को पहले से प्रोसेस करना शामिल है.

डेटा को प्री-प्रोसेस करने की सभी प्रोसेस, generateResponse(inputText:) फ़ंक्शन में मैनेज की जाती है. इनपुट टेक्स्ट को पहले से प्री-प्रोसेस करने की ज़रूरत नहीं है.

let inputPrompt = "Compose an email to remind Brett of lunch plans at noon on Saturday."

टास्क चलाना

LLM Inference API को चलाने के लिए, generateResponse(inputText:) तरीके का इस्तेमाल करें. LLM Inference API, इनपुट टेक्स्ट के लिए संभावित कैटगरी दिखाता है.

let result = try LlmInference.generateResponse(inputText: inputPrompt)

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

let resultStream =  LlmInference.generateResponseAsync(inputText: inputPrompt)

do {
  for try await partialResult in resultStream {
    print("\(partialResult)")
  }
  print("Done")
}
catch {
  print("Response error: '\(error)")
}

नतीजों को मैनेज और दिखाना

एलएलएम इंफ़्यूज़न एपीआई, जनरेट किया गया जवाब टेक्स्ट दिखाता है.

Here's a draft you can use:

Subject: Lunch on Saturday Reminder

Hi Brett,

Just a quick reminder about our lunch plans this Saturday at noon.
Let me know if that still works for you.

Looking forward to it!

Best,
[Your Name]

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

Mediapipe LLM inference API को कॉन्फ़िगर करके, लार्ज लैंग्वेज मॉडल के लिए कम रैंक वाले अडैप्टेशन (LoRA) का इस्तेमाल किया जा सकता है. बेहतर बनाए गए 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 मॉडल के इंफ़रेंस की सुविधा काम कर सके.

import MediaPipeTasksGenai

let modelPath = Bundle.main.path(forResource: "model",
                                      ofType: "bin")
let loraPath= Bundle.main.path(forResource: "lora_model",
                                      ofType: "bin")
let options = LlmInferenceOptions()
options.modelPath = modelPath
options.maxTokens = 1000
options.topk = 40
options.temperature = 0.8
options.randomSeed = 101
options.loraPath = loraPath

let llmInference = try LlmInference(options: options)

LoRA के साथ एलएलएम इंफ़रेंस चलाने के लिए, बेस मॉडल के generateResponse() या generateResponseAsync() तरीकों का इस्तेमाल करें.