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

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

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

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

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

अपने Android ऐप्लिकेशन में LLM Inference API जोड़ने के लिए, यह तरीका अपनाएं. LLM Inference API, Pixel 8 और Samsung S23 या उसके बाद के वर्शन वाले Android डिवाइसों के लिए ऑप्टिमाइज़ किया गया है. यह डिवाइस एम्युलेटर के साथ काम नहीं करता.

डिपेंडेंसी जोड़ें

LLM Inference API, com.google.mediapipe:tasks-genai लाइब्रेरी का इस्तेमाल करता है. अपने Android ऐप्लिकेशन की build.gradle फ़ाइल में यह डिपेंडेंसी जोड़ें:

dependencies {
    implementation 'com.google.mediapipe:tasks-genai:0.10.22'
}

Android 12 (एपीआई 31) या इसके बाद के वर्शन वाले डिवाइसों के लिए, नेटिव OpenCL लाइब्रेरी डिपेंडेंसी जोड़ें. ज़्यादा जानकारी के लिए, uses-native-library टैग के दस्तावेज़ देखें.

AndroidManifest.xml फ़ाइल में ये uses-native-library टैग जोड़ें:

<uses-native-library android:name="libOpenCL.so" android:required="false"/>
<uses-native-library android:name="libOpenCL-car.so" android:required="false"/>
<uses-native-library android:name="libOpenCL-pixel.so" android:required="false"/>

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

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

output_path फ़ोल्डर का कॉन्टेंट, Android डिवाइस पर पुश करें.

$ adb shell rm -r /data/local/tmp/llm/ # Remove any previously loaded models
$ adb shell mkdir -p /data/local/tmp/llm/
$ adb push output_path /data/local/tmp/llm/model_version.task

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

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

// Set the configuration options for the LLM Inference task
val taskOptions = LlmInferenceOptions.builder()
        .setModelPath('/data/local/tmp/llm/model_version.task')
        .setMaxTopK(64)
        .build()

// Create an instance of the LLM Inference task
llmInference = LlmInference.createFromOptions(context, taskOptions)

टास्क चलाना

टेक्स्ट वाला जवाब जनरेट करने के लिए, generateResponse() तरीके का इस्तेमाल करें. इससे एक जनरेट किया गया जवाब मिलता है.

val result = llmInference.generateResponse(inputPrompt)
logger.atInfo().log("result: $result")

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

val options = LlmInference.LlmInferenceOptions.builder()
  ...
  .setResultListener { partialResult, done ->
    logger.atInfo().log("partial result: $partialResult")
  }
  .build()

llmInference.generateResponseAsync(inputPrompt)

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

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

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

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

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

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

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

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

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

तैयार किए गए डेटासेट पर ट्रेनिंग देने और मॉडल को सेव करने के बाद, बेहतर बनाए गए 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 मॉडल का अनुमान

Android, शुरू करने के दौरान स्टैटिक LoRA का इस्तेमाल करता है. LoRA मॉडल लोड करने के लिए, LoRA मॉडल के पाथ के साथ-साथ बेस LLM की जानकारी दें.

// Set the configuration options for the LLM Inference task
val options = LlmInferenceOptions.builder()
        .setModelPath(BASE_MODEL_PATH)
        .setMaxTokens(1000)
        .setTopK(40)
        .setTemperature(0.8)
        .setRandomSeed(101)
        .setLoraPath(LORA_MODEL_PATH)
        .build()

// Create an instance of the LLM Inference task
llmInference = LlmInference.createFromOptions(context, options)

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