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

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

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

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

क्विकस्टार्ट

अपने 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

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

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

Gemma-2 2B को 8-बिट क्वांटाइज़्ड फ़ॉर्मैट में Kaggle Models से डाउनलोड करें. उपलब्ध मॉडल के बारे में ज़्यादा जानकारी के लिए, मॉडल का दस्तावेज़ देखें.

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

टास्क शुरू करना

टास्क को बुनियादी कॉन्फ़िगरेशन विकल्पों के साथ शुरू करें:

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)

टास्क चलाना

टेक्स्ट वाला जवाब जनरेट करने के लिए, 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)")
}

सैंपल ऐप्लिकेशन

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

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

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

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

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

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

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

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

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

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

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

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

LoRA वेट बनाने के लिए, बेस मॉडल safetensors फ़ॉर्मैट में होना चाहिए. LoRA ट्रेनिंग के बाद, मॉडल को MediaPipe पर चलाने के लिए, उन्हें FlatBuffers फ़ॉर्मैट में बदला जा सकता है.

LoRA वेट तैयार करना

अपने डेटासेट पर फ़ाइन-ट्यून किए गए LoRA मॉडल को ट्रेन करने के लिए, PEFT की LoRA Methods गाइड का इस्तेमाल करें.

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 मॉडल के वेट, adapter_model.safetensors में उपलब्ध होते हैं. safetensors फ़ाइल, LoRA चेकपॉइंट है. इसका इस्तेमाल मॉडल कन्वर्ज़न के दौरान किया जाता है.

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

मॉडल के वज़न को Flatbuffer फ़ॉर्मैट में बदलने के लिए, MediaPipe Python पैकेज का इस्तेमाल करें. ConversionConfig, बेस मॉडल के विकल्पों के साथ-साथ LoRA के अतिरिक्त विकल्पों के बारे में बताता है.

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_FILE,
)

converter.convert_checkpoint(config)

कन्वर्टर, दो Flatbuffer फ़ाइलें बनाएगा. इनमें से एक फ़ाइल, बुनियादी मॉडल के लिए होगी और दूसरी फ़ाइल, 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 के साथ LLM इन्फ़्रेंस चलाने के लिए, बेस मॉडल की तरह ही generateResponse() या generateResponseAsync() तरीकों का इस्तेमाल करें.