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.24'
}

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

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)

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

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

Google AI Edge Gallery एक ओपन-सोर्स Android ऐप्लिकेशन है. यह डेवलपर के लिए, इंटरैक्टिव प्लैटफ़ॉर्म के तौर पर काम करता है. इसमें ये चीज़ें दिखती हैं:

• अलग-अलग टास्क के लिए, LLM Inference API का इस्तेमाल करने के उदाहरण. इनमें ये शामिल हैं:
  • इमेज के बारे में पूछें: कोई इमेज अपलोड करें और उसके बारे में सवाल पूछें. जानकारी पाएं, समस्याओं को हल करें या ऑब्जेक्ट की पहचान करें.
  • प्रॉम्प्ट लैब: एक बार में जवाब देने वाले एलएलएम के इस्तेमाल के उदाहरणों को एक्सप्लोर करने के लिए, खास जानकारी दें, कोड फिर से लिखें, जनरेट करें या फ़्री फ़ॉर्म प्रॉम्प्ट का इस्तेमाल करें.
  • एआई चैट: एक से ज़्यादा बार बातचीत करने की सुविधा.
• Hugging Face LiteRT कम्यूनिटी और Google की आधिकारिक रिलीज़ (जैसे, Gemma 3N) से, LiteRT के ऑप्टिमाइज़ किए गए अलग-अलग मॉडल खोजने, डाउनलोड करने, और उनका इस्तेमाल करने की सुविधा.
• अलग-अलग मॉडल के लिए, डिवाइस पर रीयल-टाइम परफ़ॉर्मेंस के मानदंड (पहले टोकन का समय, डिकोड करने में लगने वाला समय वगैरह).
• अपने कस्टम .task मॉडल को इंपोर्ट और टेस्ट करने का तरीका.

यह ऐप्लिकेशन, एलएलएम इन्फ़रेंस एपीआई को लागू करने के तरीके और डिवाइस पर मौजूद जनरेटिव एआई की क्षमता को समझने के लिए एक संसाधन है. सोर्स कोड को एक्सप्लोर करें और Google AI Edge Gallery के GitHub रिपॉज़िटरी से ऐप्लिकेशन डाउनलोड करें.

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

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

मल्टीमोडल प्रॉम्प्ट

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

शुरू करने के लिए, Gemma 3n के MediaPipe के साथ काम करने वाले वैरिएंट का इस्तेमाल करें:

• Gemma-3n E2B: Gemma-3n फ़ैमिली का 2B मॉडल.
• Gemma-3n E4B: Gemma-3n फ़ैमिली का 4B मॉडल.

ज़्यादा जानकारी के लिए, Gemma-3n के दस्तावेज़ देखें.

प्रॉम्प्ट में इमेज देने के लिए, इनपुट इमेज या फ़्रेम को LLM Inference API में भेजने से पहले, उन्हें com.google.mediapipe.framework.image.MPImage ऑब्जेक्ट में बदलें:

import com.google.mediapipe.framework.image.BitmapImageBuilder
import com.google.mediapipe.framework.image.MPImage

// Convert the input Bitmap object to an MPImage object to run inference
val mpImage = BitmapImageBuilder(image).build()

LLM Inference API के लिए विज़न की सुविधा चालू करने के लिए, ग्राफ़ के विकल्पों में जाकर, EnableVisionModality कॉन्फ़िगरेशन विकल्प को true पर सेट करें:

LlmInferenceSession.LlmInferenceSessionOptions sessionOptions =
  LlmInferenceSession.LlmInferenceSessionOptions.builder()
    ...
    .setGraphOptions(GraphOptions.builder().setEnableVisionModality(true).build())
    .build();

Gemma-3n, हर सेशन में ज़्यादा से ज़्यादा एक इमेज स्वीकार करता है. इसलिए, MaxNumImages को 1 पर सेट करें.

LlmInferenceOptions options = LlmInferenceOptions.builder()
  ...
  .setMaxNumImages(1)
  .build();

यहां एलएलएम इंफ़रेंस एपीआई को लागू करने का उदाहरण दिया गया है. इसे विज़न और टेक्स्ट इनपुट को हैंडल करने के लिए सेट अप किया गया है:

MPImage image = getImageFromAsset(BURGER_IMAGE);

LlmInferenceSession.LlmInferenceSessionOptions sessionOptions =
  LlmInferenceSession.LlmInferenceSessionOptions.builder()
    .setTopK(10)
    .setTemperature(0.4f)
    .setGraphOptions(GraphOptions.builder().setEnableVisionModality(true).build())
    .build();

try (LlmInference llmInference =
    LlmInference.createFromOptions(ApplicationProvider.getApplicationContext(), options);
  LlmInferenceSession session =
    LlmInferenceSession.createFromOptions(llmInference, sessionOptions)) {
  session.addQueryChunk("Describe the objects in the image.");
  session.addImage(image);
  String result = session.generateResponse();
}

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