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

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

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

कोड का उदाहरण

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

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

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

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

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

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

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

   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 बनाने का तरीका जानने के लिए, देखने के लिए, Google Play Store में CocoaPods.

इस कोड का इस्तेमाल करके, Podfile में MediaPipeTasksGenai पॉड को जोड़ें:

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

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

मॉडल

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

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

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

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

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

• gemma-2b-it-cpu-int4: सीपीयू के साथ काम करने वाला Gemma 4-बिट मॉडल.
• gemma-2b-it-gpu-int4: जीपीयू के साथ काम करने वाला Gemma 4-बिट मॉडल.
• AI Edge To उदाहरण के लिए, मैप किए गए ऐसे मॉडल जो 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 ऐप्लिकेशन के लिए, नीचे दिए गए कॉन्फ़िगरेशन के विकल्प मौजूद हैं:

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

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

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

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

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

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

HuggingFace के बारे में दिए गए निर्देशों का पालन करके, Gemma-2B या Phi-2 वाले अपने डेटासेट पर बेहतर तरीके से ट्यून किए गए LoRA मॉडल को ट्रेनिंग दें. 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 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 मॉडल का अनुमान

LoRA मॉडल के अनुमान के साथ काम करने के लिए, वेब, Android, और iOS LLM Inference API को अपडेट किया गया है. वेब पर, डाइनैमिक LoRA काम करता है. यह रनटाइम के दौरान अलग-अलग LoRA मॉडल को बदल सकता है. Android और iOS, स्टैटिक 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() तरीकों का ही इस्तेमाल करें.