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

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

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

कोड का उदाहरण

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

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

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

उदाहरण कोड डाउनलोड करने के लिए:

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

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

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

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

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

सेटअप

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

डिपेंडेंसी

एलएलएम इंफ़रेंस एपीआई, 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 Infrence API टास्क को एक प्रशिक्षित मॉडल की ज़रूरत होती है, जो इस टास्क के साथ काम कर सके. एलएलएम इंफ़रेंस एपीआई के लिए उपलब्ध ट्रेनिंग मॉडल के बारे में ज़्यादा जानकारी के लिए, टास्क की खास जानकारी मॉडल सेक्शन देखें.

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

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

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

iOS ऐप्लिकेशन बनाते समय, इनमें से किसी एक वैरिएंट का इस्तेमाल करें:

• gemma-2b-it-cpu-int4: जेम्मा 4-बिट मॉडल, जो सीपीयू के साथ काम करता है.
• gemma-2b-it-gpu-int4: Gemma 4-बिट मॉडल, जिसमें जीपीयू के साथ काम करने की सुविधा है.
• AI Edge Toch मैप किया गया मॉडल, जो iOS मेमोरी की शर्तों के मुताबिक होता है.

दूसरे मॉडल के बारे में ज़्यादा जानकारी के लिए, टास्क की खास जानकारी मॉडल सेक्शन देखें.

टास्क बनाएं

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

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

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

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 ऐप्लिकेशन के लिए कॉन्फ़िगरेशन के ये विकल्प शामिल हैं:

विकल्प का नाम	कंपनी का ब्यौरा	वैल्यू रेंज	डिफ़ॉल्ट मान
modelPath	प्रोजेक्ट डायरेक्ट्री में मॉडल को सेव करने की जगह का पाथ.	PATH	लागू नहीं
maxTokens	मॉडल द्वारा हैंडल किए जाने वाले टोकन (इनपुट टोकन + आउटपुट टोकन) की ज़्यादा से ज़्यादा संख्या.	Integer	512
topk	जनरेट होने के हर चरण में मॉडल के हिसाब से टोकन की संख्या. सुझावों को सबसे ऊपर के सबसे ज़्यादा संभावित टोकन तक सीमित करता है. topk को सेट करते समय, आपको randomSeed के लिए वैल्यू भी सेट करनी होगी.	Integer	40
temperature	जनरेट करने के दौरान की गई यादृच्छिकता की मात्रा. तापमान ज़्यादा होने पर, जनरेट किए गए टेक्स्ट में ज़्यादा क्रिएटिविटी दिखती है. वहीं, कम तापमान होने पर, इमेज का बेहतर तरीके से अनुमान लगाया जा सकता है. temperature को सेट करते समय, आपको randomSeed के लिए वैल्यू भी सेट करनी होगी.	Float	0.8
randomSeed	टेक्स्ट जनरेट करने के दौरान इस्तेमाल किया गया कोई भी सीड.	Integer	0
loraPath	डिवाइस पर, LoRA मॉडल के लिए ऐब्सलूट पाथ. ध्यान दें: यह सुविधा सिर्फ़ जीपीयू मॉडल के साथ काम करती है.	PATH	लागू नहीं

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

एलएलएम अनुमान एपीआई, टेक्स्ट डेटा के साथ काम करता है. यह टास्क, डेटा इनपुट की प्री-प्रोसेसिंग को हैंडल करता है. इसमें टोकनाइज़ेशन और टेंसर प्री-प्रोसेसिंग भी शामिल हैं.

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

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

टास्क चलाएं

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

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)")
}

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

एलएलएम अनुमान एपीआई, LlmInferenceResult दिखाता है. इसमें जनरेट किया गया रिस्पॉन्स टेक्स्ट शामिल होता है.

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

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

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

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

# For Gemma-2B
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 पर उपलब्ध एलएलएम इंफ़रेंस एपीआई के हिसाब से उपलब्ध हैं. उदाहरण के लिए, Gemma-2B के लिए monsterapi/gemma-2b-lora-maths-orca-200k और Phi-2 के लिए lole25/phi-2-sft-ultrachat-lora.

तैयार डेटासेट की ट्रेनिंग करने और मॉडल को सेव करने के बाद, आपको एक adapter_model.safetensors फ़ाइल मिलती है, जिसमें आसान LoRA मॉडल वेट होते हैं. सेफ़ेंसर फ़ाइल, LoRA चेकपॉइंट है. इसका इस्तेमाल मॉडल कन्वर्ज़न में किया जाता है.

अगले चरण में, आपको MediaPipe Python पैकेज का इस्तेमाल करके मॉडल वेट को TensorFlow Lite फ़्लैटबफ़र में बदलना होगा. 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 मॉडल का अनुमान

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

iOS शुरू होने के दौरान, स्टैटिक LoRA के साथ काम करता है. LoRA मॉडल को लोड करने के लिए, उपयोगकर्ता 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() तरीकों का इस्तेमाल करें जिन्हें बेस मॉडल में इस्तेमाल किया गया था.