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

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

अपने Android ऐप्लिकेशन में LLM Inference API को तुरंत जोड़ने के लिए, क्विकस्टार्ट का पालन करें. LLM Inference API का इस्तेमाल करने वाले 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.27'
}

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

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 AI Edge Gallery ऐप्लिकेशन देखें.

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

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

एलएलएम इन्फ़्रेंस एपीआई के लिए इमेज या ऑडियो इनपुट की सुविधा चालू करने के लिए, यहां दिया गया तरीका अपनाएं.

इमेज इनपुट

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

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()

एलएलएम इन्फ़रेंस एपीआई के लिए विज़न सपोर्ट चालू करने के लिए, ग्राफ़ के विकल्पों में जाकर EnableVisionModality कॉन्फ़िगरेशन विकल्प को true पर सेट करें:

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

हर सेशन में ज़्यादा से ज़्यादा 10 इमेज सेट करें.

LlmInferenceOptions options = LlmInferenceOptions.builder()
  ...
  .setMaxNumImages(10)
  .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();
}

ऑडियो इनपुट

LlmInferenceOptions में ऑडियो सपोर्ट चालू करें

val inferenceOptions = LlmInference.LlmInferenceOptions.builder()
  ...
  .setAudioModelOptions(AudioModelOptions.builder().build())
  .build()

sessionOptions में ऑडियो की सुविधा चालू करें

    val sessionOptions =  LlmInferenceSessionOptions.builder()
      ...
      .setGraphOptions(GraphOptions.builder().setEnableAudioModality(true).build())
      .build()

अनुमान लगाने के दौरान ऑडियो डेटा भेजना. ध्यान दें: ऑडियो, मोनो चैनल में होना चाहिए और .wav फ़ॉर्मैट में होना चाहिए

val audioData: ByteArray = ...
inferenceEngine.llmInferenceSession.addAudio(audioData)

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

val audioData: ByteArray = ...
val inferenceOptions = LlmInference.LlmInferenceOptions.builder()
  ...
  .setAudioModelOptions(AudioModelOptions.builder().build())
  .build()
val sessionOptions =  LlmInferenceSessionOptions.builder()
  ...
  .setGraphOptions(GraphOptions.builder().setEnableAudioModality(true).build())
  .build()

LlmInference.createFromOptions(context, inferenceOptions).use { llmInference ->
  LlmInferenceSession.createFromOptions(llmInference, sessionOptions).use { session ->
    session.addQueryChunk("Transcribe the following speech segment:")
    session.addAudio(audioData)
    val 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 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 मॉडल का अनुमान

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

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