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

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

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

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

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

अपने iOS ऐप्लिकेशन में LLM Inference API जोड़ने के लिए, यह तरीका अपनाएं. 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 के लिए सेट अप करने की गाइड देखें.

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

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

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

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

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

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

अपने डेटासेट पर बेहतर LoRA मॉडल को ट्रेन करने के लिए, PEFT की LoRA के तरीकों वाली गाइड का इस्तेमाल करें.

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"],
)

तैयार किए गए डेटासेट पर ट्रेनिंग देने और मॉडल को सेव करने के बाद, adapter_model.safetensors में बेहतर बनाए गए LoRA मॉडल के वेट उपलब्ध होते हैं. 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 मॉडल का पाथ और बेस LLM तय करें.

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() तरीकों का इस्तेमाल करें.