Gemma 3 270M: डेमो प्रोजेक्ट के साथ एक गाइड (Android ऐप)

Google ने हाल ही में Gemma 3 270M जारी किया है—270 मिलियन पैरामीटर्स वाला एक अल्ट्रा-कॉम्पैक्ट मॉडल, जो कुशल AI डिप्लॉयमेंट के एक नए पैराबिग्म का प्रतिनिधित्व करता है। विशाल जनरल-पर्पज़ मॉडलों के विपरीत, Gemma 3 270M को टास्क-विशिष्ट फाइन-ट्यूनिंग के लिए डिज़ाइन किया गया है, साथ ही बॉक्स से बाहर ही निर्देशों का पालन करने की क्षमता भी बनाए रखता है।

इस ट्यूटोरियल में, मैं आपको Gemma 3 270M के साथ शुरुआत करना दिखाऊँगा और यह प्रदर्शित करूँगा कि यह उन डेवलपर्स के लिए क्यों बेहतरीन विकल्प है जिन्हें आवश्यकता है:

• बेहद तेज़ इन्फरेंस, बहुत कम कम्प्यूटेशनल ओवरहेड के साथ
• बेहद अधिक ऊर्जा दक्षता (Pixel 9 Pro पर 25 बातचीतों में मात्र 0.75% बैटरी उपयोग)
• INT4 प्रिसिशन के साथ क्वांटाइज़ेशन और न्यूनतम परफॉर्मेंस लॉस
• पूर्ण ऑन-डिवाइस एक्ज़ीक्यूशन क्षमताओं के साथ संपूर्ण गोपनीयता

हम अपने पाठकों को नवीनतम AI अपडेट्स से अवगत रखते हैं The Median के माध्यम से—हमारा मुफ़्त शुक्रवार न्यूज़लेटर, जो हफ़्ते की प्रमुख खबरों को सरलता से समझाता है। सब्सक्राइब करें और सप्ताह में कुछ ही मिनटों में अपडेट रहें:

Gemma 3 270M क्या है?

Gemma 3 270M एक कॉम्पैक्ट फ़ाउंडेशन मॉडल है, जिसे केवल 270 मिलियन पैरामीटर्स के साथ मज़बूत निर्देश-अनुसरण और स्ट्रक्चर्ड टेक्स्ट जेनरेशन देने के लिए बनाया गया है। यह Gemma 3 परिवार का सबसे छोटा सदस्य है, फिर भी यह बड़े वेरिएंट्स जैसे Gemma 3 1B और 4B की ही आर्किटेक्चर और ट्रेनिंग रेसिपीज़ अपनाता है।

जनरल-पर्पज़ बड़े मॉडलों के विपरीत, Gemma 3 270M का फ़ोकस दक्षता और विशेषज्ञता पर है। इस मॉडल के बारे में कुछ प्रमुख बिंदु:

• यह मोबाइल डिवाइसों पर आसानी से चलता है; क्वांटाइज़्ड इन्फरेंस (INT4, Q8, और अन्य) कई बातचीतों में 1% से कम बैटरी की खपत करता है।
• इसमें 100M ट्रांसफ़ॉर्मर पैरामीटर्स और 170M का बड़ा एम्बेडिंग मैट्रिक्स है, जो 256,000 टोकन्स की शब्दावली सपोर्ट करता है—डोमेन-विशिष्ट एप्लिकेशनों में रेयर टोकन्स को संभालने के लिए आदर्श।
• इंस्ट्रक्शन-ट्यून किए गए चेकपॉइंट्स भी उपलब्ध हैं, जिससे क्लाउड कनेक्टिविटी के बिना असिस्टेंट्स, डेटा एक्सट्रैक्टर्स और क्रिएटिव राइटिंग टूल्स बनाना आसान हो जाता है।

Gemma 3 270M में अच्छी निर्देश-अनुसरण क्षमताएँ हैं—IFEval बेंचमार्क मॉडल की सत्यापनीय जानकारी का पालन करने की क्षमता का परीक्षण करता है। स्रोत: Google

32K कॉन्टेक्स्ट विंडो, कम मेमोरी उपयोग, और एंटिटी एक्सट्रैक्शन, क्लासिफिकेशन, व हल्के अनुपालन-जाँच जैसे कार्यों पर मज़बूत सटीकता के साथ, Gemma 3 270M उन एज AI डेवलपर्स के लिए उपयुक्त है जो गोपनीयता, गति और लागत-दक्षता चाहते हैं।

Gemma 3 270M तक कैसे पहुँचें?

आपके पसंदीदा प्लेटफ़ॉर्म के अनुसार, Gemma 3 270M के साथ शुरुआत करने के कई आसान तरीके हैं:

1. Cloud Run

आप Gemma 3 को Google Cloud Run पर प्रीबिल्ट GPU-एक्सेलरेटेड कंटेनर का उपयोग करके स्केलेबल इन्फरेंस के लिए डिप्लॉय कर सकते हैं। Gemma 3 270M के लिए, आपको अपना कंटेनर Gemma-on-CloudRun GitHub repo से बनाना होगा, क्योंकि केवल बड़े वेरिएंट्स (1B+) ही प्रीबिल्ट हैं। वेब या बैकएंड एप्लिकेशनों के लिए तेज़, सुरक्षित और किफ़ायती इन्फरेंस सक्षम करने हेतु Google Cloud Run के आधिकारिक गाइड का पालन करें।

2. Android (अनुशंसित)

सबसे अच्छा उपयोगकर्ता अनुभव ऑन-डिवाइस होता है, Gemma 3 270M के क्वांटाइज़्ड वर्ज़न (gemma3-270m-it-q8) और Google के आधिकारिक Gemma Gallery App का उपयोग करते हुए। यह तरीका अत्यंत तेज़ ऑफ़लाइन इन्फरेंस, मज़बूत गोपनीयता, और न्यूनतम बैटरी उपयोग देता है।

3. लोकल इन्फरेंस

आप अपने लैपटॉप पर भी निम्न टूल्स का उपयोग करके Gemma 3 270M चला सकते हैं:

• LM Studio: अपने LM Studio वातावरण में .gguf या .litertlm एक्सटेंशन वाला मॉडल डाउनलोड करें और उसे तुरंत चैट इंटरफ़ेस में चलाएँ या लोकली होस्ट करें।
• Ollama: आप ollama run gemma3:270m कमांड का उपयोग करके इस मॉडल को अपनी मशीन पर लोकली रन कर सकते हैं।
• Llama.cpp: यह भी Gemma 3 270M मॉडल के लिए अल्ट्रा-लाइटवेट CPU इन्फरेंस प्रदान करता है।
• Docker: आप Docker कंटेनर के माध्यम से भी Gemma 3 चला सकते हैं—या तो Hugging Face से या Gemma के आधिकारिक GitHub रिपोजिटरी से।
• HuggingFace: उपयोगकर्ता HuggingFace इंटरफ़ेस के माध्यम से सीधे इस मॉडल तक पहुँच सकते हैं या इन्फरेंस कर सकते हैं, या लोकल उपयोग के लिए प्रीट्रेंड और इंस्ट्रक्शन-ट्यून दोनों मॉडल डाउनलोड कर सकते हैं।

4. मॉडल को फाइन-ट्यून करें

Gemma 3 270M, Hugging Face Transformers, JAX, या Unsloth में भी उपलब्ध है ताकि आप अपने डोमेन-विशिष्ट डेटा पर फाइन-ट्यून कर सकें। मॉडल का छोटा आकार तेज़, कम-लागत वाले प्रयोगों के लिए आदर्श है, और QAT चेकपॉइंट्स फाइन-ट्यूनिंग के बाद सीधे INT4 डिप्लॉयमेंट सक्षम करते हैं।

अगले चरण में, मैं आपको एक कार्यशील Android ऐप बनाना सिखाऊँगा जो टेक्स्ट प्रॉम्प्ट्स प्रोसेस करने के लिए Gemma 3 270M मॉडल का उपयोग करता है। हम Google की आधिकारिक Gallery रिपोजिटरी को बेस के रूप में उपयोग करेंगे और उसे कस्टमाइज़ करेंगे।

चरण 1: ऐप को क्लोन और सेट अप करें

आइए एक नया प्रोजेक्ट सेट अप करके और Google की मौलिक रिपोजिटरी को क्लोन करके शुरू करते हैं।

चरण 1.1: नया Android Studio प्रोजेक्ट बनाएँ

अपने लैपटॉप पर, Android Studio में प्रोजेक्ट को एक नए प्रोजेक्ट के रूप में खोलें और Empty Activity चुनें।

चरण 1.2: नई खाली एक्टिविटी सेट अप करें

इसके बाद, अपनी एक्टिविटी का नाम भरें (उदाहरण के लिए, “Gemma 3 270M”) और बाकी सेटिंग्स यथावत रखें। फिर, Finish पर क्लिक करें।

चरण 1.3: मुख्य रिपोजिटरी क्लोन करें

अब, Android Studio के भीतर (बाएँ नीचे) टर्मिनल खोलें और निम्नलिखित bash कमांड्स चलाएँ:

git clone https://github.com/google-ai-edge/gallery
cd gallery/androidसंचालित द्वारा

इससे आपका प्रोजेक्ट खुलेगा। आप टैब के बाएँ हिस्से में सभी प्रोजेक्ट फ़ाइलें देख सकते हैं।

चरण 2: मॉडल कनेक्ट करें

Gemma 3 270M मॉडल को अपनी Android ऐप से जोड़ने के लिए, आपको इसे ऐप की Tasks.kt फ़ाइल के अंदर एक नए टास्क के रूप में रजिस्टर करना होगा।

data/ फ़ोल्डर में जाएँ और Tasks.kt फ़ाइल खोलें। वहाँ, आप विशेष रूप से मॉडल के Q8 क्वांटाइज़्ड वेरिएंट gemma3-270m-it-q8 के लिए एक नया टास्क एंट्री परिभाषित करेंगे, जो लो-मेमोरी और ऑन-डिवाइस इन्फरेंस के लिए ऑप्टिमाइज़्ड है। यह फ़ॉर्मेट सीमित RAM वाले मोबाइल डिवाइसों के लिए उपयुक्त है।

नोट: इस ट्यूटोरियल के लिए, मैं Q8 मॉडल कॉन्फ़िगरेशन का उपयोग करूँगा, जो कम मेमोरी की आवश्यकता रखता है। आप यह मॉडल यहाँ एक्सेस कर सकते हैं: https://huggingface.co/litert-community/gemma-3-270m-it

val TASK_GEMMA_3_270M = Task(
  type = TaskType.LLM_PROMPT_LAB,
  icon = Icons.Outlined.Widgets,
  models = mutableListOf(
    Model(
      name = "gemma3-270m-it-q8",
      downloadFileName = "gemma3-270m-it-q8.task",
      url = "https://huggingface.co/litert-community/gemma-3-270m-it/resolve/main/gemma3-270m-it-q8.task",
      sizeInBytes = 318_767_104L
    )
  ),
  description = "Gemma 3 270M (Q8): On-device instruction-following LLM",
  docUrl = "https://ai.google.dev/gemma",
  sourceCodeUrl = "https://github.com/google-ai-edge/gallery",
  textInputPlaceHolderRes = R.string.chat_textinput_placeholder
)संचालित द्वारा

इसके बाद, मुख्य टास्क सूची में शामिल करके इस नए टास्क को ऐप में रजिस्टर करें:

/** All tasks */
val TASKS: List<Task> = listOf(
  TASK_LLM_ASK_IMAGE,
  TASK_LLM_CHAT,
  TASK_LLM_PROMPT_LAB,
  TASK_IMAGE_CLASSIFICATION,
  TASK_TEXT_CLASSIFICATION,
  TASK_IMAGE_GENERATION,
  TASK_GEMMA_3_270M
)संचालित द्वारा

यहाँ कोड में नए LiteRT टास्क डिफिनिशन का विवरण है:

• नया टास्क परिभाषित करता है: TASK_GEMMA_3_270M वैरिएबल ऐप की Tasks.kt फ़ाइल के अंदर Gemma 3 270M को एक चयन योग्य विकल्प के रूप में रजिस्टर करता है, ताकि यह टास्क सूची में दिखाई दे।
• .task फ़ाइल लिंक करना: उपरोक्त कोड Hugging Face पर होस्टेड gemma3-270m-it-q8.task बंडल की ओर संकेत करता है, जिसे ऐप के भीतर डाउनलोड किया जाता है और रनटाइम पर उपयोग होता है।
• मॉडल विवरण: .task फ़ाइल में क्वांटाइज़्ड मॉडल वेट्स, टोकनाइज़र, मेटाडेटा और कॉन्फ़िग्स होते हैं, जो LiteRT को मॉडल कुशलता से चलाने के लिए आवश्यक हैं।
• Q8 वेरिएंट: यह क्वांटाइज़ेशन मेमोरी बचत और आउटपुट क्वालिटी के बीच संतुलन बनाता है—फोन के लिए पर्याप्त हल्का रहते हुए भी निर्देश-अनुसरण को अच्छे से हैंडल करता है।
• टास्क मेटाडेटा: यह विवरण, डाक्यूमेंटेशन URL और सोर्स कोड लिंक जोड़ता है, जिससे Gallery ऐप में टास्क को समझना और मेंटेन करना आसान होता है।
• टास्क सूची: अंततः यह सुनिश्चित करता है कि मॉडल टास्क सूची में TASK_GEMMA_3_270M के रूप में पहचाना जाए।

चरण 3: मॉडल पॉपुलेशन फ़िक्स

डिफ़ॉल्ट रूप से, Gallery ऐप अपने मॉडल सूचियों को एक रिमोट अलाउलिस्ट JSON से पॉपुलेट करता है। यदि आपका कस्टम Gemma 3 270M एंट्री वहाँ शामिल नहीं है, तो यह UI में नहीं दिखेगा, भले ही आपने कोड में TASK_GEMMA_3_270M जोड़ दिया हो। यह चरण अलाउलिस्ट लोड होने के बाद आपके 270M मॉडल को LLM Prompt Lab टास्क में ग्राफ़्ट करता है, जिससे यह हर बार चयन योग्य रहे।

modelmanager/ModelManagerViewModel.kt खोलें, loadModelAllowlist() फ़ंक्शन खोजें, और (अलाउलिस्टेड मॉडलों को कन्वर्ट करने वाले लूप के बाद) यह जोड़ें:

Log.d(TAG, "Adding TASK_GEMMA_3_270M models to LLM_PROMPT_LAB")
            for (gemmaModel in TASK_GEMMA_3_270M.models) {
              if (!TASK_LLM_PROMPT_LAB.models.any { it.name == gemmaModel.name }) {
                Log.d(TAG, "Adding model ${gemmaModel.name} to LLM_PROMPT_LAB")
                TASK_LLM_PROMPT_LAB.models.add(gemmaModel)
              }संचालित द्वारा

यह कोड आवश्यक क्यों है, इसके कारण:

• अलाउलिस्ट रीसेट: ऐप स्टार्टअप पर सर्वर अलाउलिस्ट से TASK_LLM_PROMPT_LAB.models को क्लियर करके फिर से बनाता है। जब तक आप अपने लोकल मॉडल को फिर से इंजेक्ट नहीं करते, वह मिट जाएगा।
• आइडेम्पोटेंट और डुप्लिकेट-सुरक्षित: गार्ड any { it.name == gemmaModel.name } यह सुनिश्चित करता है कि जब loadModelAllowlist() फ़ंक्शन फिर से चलता है, तो डुप्लिकेट न हों।
• ऑफ़लाइन-फ्रेंडली: यह कोड तब भी काम करता है जब अलाउलिस्ट नेटवर्क से या डिस्क फॉलबैक से लोड होती है—दोनों ही स्थितियों में मॉडल जोड़ा जाता है।

पूरी फ़ंक्शन यहाँ है:

fun loadModelAllowlist() {
    _uiState.update {
      uiState.value.copy(
        loadingModelAllowlist = true, loadingModelAllowlistError = ""
      )
    }
    viewModelScope.launch(Dispatchers.IO) {
      try {
        withTimeoutOrNull(30000L) { // 30 second timeout
          // Load model allowlist json.
          Log.d(TAG, "Loading model allowlist from internet...")
          val data = getJsonResponse<ModelAllowlist>(url = MODEL_ALLOWLIST_URL)
          var modelAllowlist: ModelAllowlist? = data?.jsonObj
          if (modelAllowlist == null) {
            Log.d(TAG, "Failed to load model allowlist from internet. Trying to load it from disk")
            modelAllowlist = readModelAllowlistFromDisk()
          } else {
            Log.d(TAG, "Done: loading model allowlist from internet")
            saveModelAllowlistToDisk(modelAllowlistContent = data?.textContent ?: "{}")
          }
          if (modelAllowlist == null) {
            Log.e(TAG, "Failed to load model allowlist from both internet and disk")
            _uiState.update { 
              uiState.value.copy(
                loadingModelAllowlist = false,
                loadingModelAllowlistError = "Failed to load model list"
              ) 
            }
            return@withTimeoutOrNull
          }
          Log.d(TAG, "Allowlist: $modelAllowlist")
          // Convert models in the allowlist.
          TASK_LLM_CHAT.models.clear()
          TASK_LLM_PROMPT_LAB.models.clear()
          TASK_LLM_ASK_IMAGE.models.clear()          
          try {
            for (allowedModel in modelAllowlist.models) {
              if (allowedModel.disabled == true) {
                continue
              }
              val model = allowedModel.toModel()
              if (allowedModel.taskTypes.contains(TASK_LLM_CHAT.type.id)) {
                TASK_LLM_CHAT.models.add(model)
              }
              if (allowedModel.taskTypes.contains(TASK_LLM_PROMPT_LAB.type.id)) {
                TASK_LLM_PROMPT_LAB.models.add(model)
              }
              if (allowedModel.taskTypes.contains(TASK_LLM_ASK_IMAGE.type.id)) {
                TASK_LLM_ASK_IMAGE.models.add(model)
              }
            }
            // Add models from TASK_GEMMA_3_270M to LLM_PROMPT_LAB
            Log.d(TAG, "Adding TASK_GEMMA_3_270M models to LLM_PROMPT_LAB")
            for (gemmaModel in TASK_GEMMA_3_270M.models) {
              if (!TASK_LLM_PROMPT_LAB.models.any { it.name == gemmaModel.name }) {
                Log.d(TAG, "Adding model ${gemmaModel.name} to LLM_PROMPT_LAB")
                TASK_LLM_PROMPT_LAB.models.add(gemmaModel)
              }
            }
          } catch (e: Exception) {
            Log.e(TAG, "Error processing model allowlist", e)
          }
          // Pre-process all tasks.
          try {
            processTasks()
          } catch (e: Exception) {
            Log.e(TAG, "Error processing tasks", e)
          }
          // Update UI state.
          val newUiState = createUiState()
          _uiState.update {
            newUiState.copy(
              loadingModelAllowlist = false,
            )
          }
          // Process pending downloads.
          try {
            processPendingDownloads()
          } catch (e: Exception) {
            Log.e(TAG, "Error processing pending downloads", e)
          }
        } ?: run {
          // Timeout occurred
          Log.e(TAG, "Model allowlist loading timed out")
          _uiState.update { 
            uiState.value.copy(
              loadingModelAllowlist = false,
              loadingModelAllowlistError = "Model list loading timed out"
            ) 
          }
        }
      } catch (e: Exception) {
        Log.e(TAG, "Error in loadModelAllowlist", e)
        _uiState.update { 
          uiState.value.copy(
            loadingModelAllowlist = false,
            loadingModelAllowlistError = "Failed to load model list: ${e.message}"
          ) 
        }
      }
    }
  }संचालित द्वारा

चरण 4: नेविगेशन लॉजिक अपडेट करें

डिफ़ॉल्ट रूप से, ऐप मानता है कि वर्तमान में चुना गया टास्क क्लिक किए गए मॉडल से मेल खाता है। एक बार जब आप Gemma 3 270M को Prompt Lab टास्क (चरण 3) में इंजेक्ट करते हैं, तो यह मान्यता टूट सकती है। यह चरण नेविगेशन को मॉडल-अवेयर बनाता है, ताकि टैप्स, डीप लिंक्स, और रिस्टोर्ड स्टेट हमेशा सही स्क्रीन पर जाएँ।

navigation/GalleryNavGraph.kt खोलें और मॉडल नेविगेशन कंट्रोल लॉजिक को निम्नानुसार अपडेट करें:

पहले:

onModelClicked = { model ->
  navigateToTaskScreen(
    navController = navController, taskType = curPickedTask.type, model = model
  )
}संचालित द्वारा

बाद में:

onModelClicked = { model ->
  Log.d("GalleryNavGraph", "Model clicked: ${model.name}, current task: ${curPickedTask.type}")
  val actualTask = when {
    TASK_LLM_CHAT.models.any { it.name == model.name } -> TASK_LLM_CHAT
    TASK_LLM_PROMPT_LAB.models.any { it.name == model.name } -> TASK_LLM_PROMPT_LAB
    TASK_LLM_ASK_IMAGE.models.any { it.name == model.name } -> TASK_LLM_ASK_IMAGE
    TASK_TEXT_CLASSIFICATION.models.any { it.name == model.name } -> TASK_TEXT_CLASSIFICATION
    TASK_IMAGE_CLASSIFICATION.models.any { it.name == model.name } -> TASK_IMAGE_CLASSIFICATION
    TASK_IMAGE_GENERATION.models.any { it.name == model.name } -> TASK_IMAGE_GENERATION
    else -> curPickedTask
  }
  Log.d("GalleryNavGraph", "Navigating to task: ${actualTask.type} for model: ${model.name}")
  navigateToTaskScreen(
    navController = navController, taskType = actualTask.type, model = model
  )
}संचालित द्वारा

यदि कोई मॉडल वर्तमान में चयनित टास्क से भिन्न टास्क में दिखाई देता है (या इंजेक्ट किया गया है), तो यह कोड सुनिश्चित करता है कि स्क्रीन मॉडल की क्षमताओं से मेल खाए। 

डीप लिंक्स या रिस्टोर्ड स्टेट के साथ काम करते समय, ऐप किसी ऐसे मॉडल को खोलने का प्रयास कर सकता है जो अब उपलब्ध नहीं है। उचित हैंडलिंग के बिना, इसका परिणाम खाली स्क्रीन हो सकता है। इसे टालने के लिए, हम एक सेफ़्टी चेक जोड़ते हैं—यदि मॉडल गायब है, तो हम चेतावनी लॉग करते हैं और उपयोगकर्ता को रीडायरेक्ट करते हैं। ऐसे करें:

// Added error handling for model not found:
if (model != null) {
  Log.d("GalleryNavGraph", "Model found for LlmChat: ${model.name}")
  modelManagerViewModel.selectModel(model)
  LlmChatScreen(/* ... */)
} else {
  Log.w("GalleryNavGraph", "Model not found for LlmChat, modelName: ${it.arguments?.getString("modelName")}")
  // Handle case where model is not found
  androidx.compose.runtime.LaunchedEffect(Unit) {
    navController.navigateUp()
  }
}संचालित द्वारा

यह कोड ऐप को कार्यशील बनाए रखता है। फ़्रीज़ होने या खाली स्क्रीन दिखाने के बजाय, यह navController का उपयोग करके सुरक्षित रूप से वापस नेविगेट करता है। इस तरह, भले ही कोई मॉडल गायब हो, समग्र अनुभव बाधित हुए बिना उपयोगकर्ता प्रवाह सुचारू रूप से जारी रहता है।

चरण 5: सुरक्षा और विश्वसनीयता 

मोबाइल डिवाइस पर बड़ा भाषा मॉडल चलाना डेस्कटॉप कंप्यूटर पर चलाने से भिन्न है। स्टोरेज अविश्वसनीय हो सकता है, मेमोरी बजट अधिक कड़े होते हैं, और इनिशियलाइज़ेशन फ़ेल्यर्स को ऐप क्रैश से बचाने के लिए संभालना पड़ता है। Android पर Gemma 3 270M (Q8, ~304MB) को स्थिर बनाने के लिए, मैंने अतिरिक्त सेफ़्टी चेक्स और फ़ेलओवर स्ट्रैटेजीज़ जोड़ीं।

चरण 5.1: सहिष्णु साइजिंग के साथ फ़ाइल वैलिडेशन

मॉडल लोड करने से पहले, ऐप .task फ़ाइल पर सेनीटी चेक्स करता है। यह सुनिश्चित करता है कि मॉडल फ़ाइल मौजूद है, पढ़ने योग्य है, और अपेक्षित आकार के काफ़ी करीब है (±10% के भीतर)। यह टॉलरेंस कंप्रेशन या पैकेजिंग के कारण होने वाले छोटे अंतर को स्वीकार करता है, जबकि करप्ट या आंशिक डाउनलोड को पकड़ता है।

// File validation and logging
Log.d(TAG, "Checking model file: $modelPath")
Log.d(TAG, "Model file exists: ${modelFile.exists()}")
Log.d(TAG, "Model file can read: ${modelFile.canRead()}")
Log.d(TAG, "Model file size: ${modelFile.length()} bytes")
Log.d(TAG, "Model file absolute path: ${modelFile.absolutePath}")
// Size validation with tolerance (10%)
val expectedSize = model.sizeInBytes
val fileSize = modelFile.length()
val sizeDifference = kotlin.math.abs(fileSize - expectedSize)
val sizeTolerance = (expectedSize * 0.1).toLong()
if (!modelFile.exists() || !modelFile.canRead() || sizeDifference > sizeTolerance) {
  onDone("Model file invalid (missing/unreadable/wrong size).")
  return
}संचालित द्वारा

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

चरण 5.2: मेमोरी-अवेयर बैकएंड चयन 

यदि आप आक्रामक रूप से शुरू करते हैं (लंबे आउटपुट, GPU एलोकेशन स्पाइक्स), तो बड़े मॉडल Out-Of-Memory (OOM) त्रुटियाँ दे सकते हैं। इसे कम करने के लिए, मैंने फ़ाइल आकार और डिवाइस कॉन्फ़िगरेशन के आधार पर सबसे सुरक्षित बैकएंड (CPU बनाम GPU/NPU) चुनने के लिए लॉजिक जोड़ा, साथ ही ओवरसाइज़्ड बाइनरी के लिए मैक्स टोकन्स को ट्रिम किया।

val preferredBackend = when {
  fileSize > 200_000_000L -> {
    Log.d(TAG, "Model is large (${fileSize / 1024 / 1024}MB), using CPU backend for safety")
    LlmInference.Backend.CPU
  }
  accelerator == Accelerator.CPU.label -> LlmInference.Backend.CPU
  accelerator == Accelerator.GPU.label -> LlmInference.Backend.GPU
  else -> LlmInference.Backend.CPU
}
val baseMaxTokens = 1024 // your default; tune to taste
val maxTokens = if (fileSize > 200_000_000L) {
  kotlin.math.min(baseMaxTokens, 512)
} else {
  baseMaxTokens
}संचालित द्वारा

यह सुनिश्चित करता है कि बड़े मॉडल डिफ़ॉल्ट रूप से CPU पर जाएँ (ज़्यादा सुरक्षित, पर धीमे)। कोड .task फ़ाइल के बाइट आकार (fileSize) की जाँच करता है और उसे एक थ्रेशहोल्ड (maxTokens) से तुलना करता है। यदि यह 200 MB से अधिक है, तो यह इन्फरेंस को CPU पर स्विच करता है और टोकन बजट आधा कर देता है। यह एक साथ होने वाले GPU एलोकेशन से होने वाले मेमोरी स्पाइक्स और ओवरसाइज़्ड जेनरेशन रिक्वेस्ट्स से सुरक्षा प्रदान करता है।

चरण 5.3: एक्सेप्शन हैंडलिंग

LiteRT को इनिशियलाइज़ करते समय रनटाइम क्रिएशन और सेशन क्रिएशन में अंतर करना महत्वपूर्ण है। यदि सेशन क्रिएशन विफल होता है लेकिन आप रनटाइम खुला छोड़ देते हैं, तो आप संसाधन लीक कर सकते हैं और मेमोरी लॉक कर सकते हैं, जिससे क्रमिक विफलताएँ हो सकती हैं। इसे ठीक करने के लिए, मैंने कोड को try/catch ब्लॉक्स में रैप किया और स्पष्ट क्लीनअप जोड़ा।

val llmInference = try {
  LlmInference.createFromOptions(context, options)
} catch (e: Exception) {
  Log.e(TAG, "Failed to create LlmInference instance", e)
  onDone("Failed to create model instance: ${e.message}")
  return
}
val session = try {
  LlmInferenceSession.createFromOptions(/* ... */)
} catch (e: Exception) {
  Log.e(TAG, "Failed to create LlmInferenceSession", e)
  try {
    llmInference.close()
  } catch (closeException: Exception) {
    Log.e(TAG, "Failed to close LlmInference after session creation failure", closeException)
  }
  onDone("Failed to create model session: ${e.message}")
  return
}संचालित द्वारा

यह try/catch स्वच्छ रोलबैक की गारंटी देता है—यदि रनटाइम क्रिएशन असफल होता है, तो आगे कुछ नहीं बढ़ता; लेकिन यदि सेशन क्रिएशन असफल होता है, तो रनटाइम को स्पष्ट रूप से बंद कर दिया जाता है। यह सुनिश्चित करता है कि हीप-एलोकेटेड llmInference ऑब्जेक्ट .close() के माध्यम से डिस्पोज़ हो, जिससे मेमोरी और फ़ाइल हैंडल्स रिलीज़ हो जाएँ। अन्यथा, आप JNI रेफ़रेंसेज़ के जोखिम में रहते हैं जो अगले मॉडल लोड पर क्रैश करा सकते हैं।

चरण 5.4: इन्फरेंस-टाइम गार्ड्स

भले ही कोई मॉडल सफलतापूर्वक लोड हो जाए, इन्फरेंस रेस कंडीशन्स, नल रेफ़रेंसेज़, या अनइनिशियलाइज़्ड इंस्टैंसेज़ के कारण विफल हो सकता है। इसे सख़्त करने के लिए, मैंने पूरे इन्फरेंस ब्लॉक के चारों ओर नल चेक्स और एक्सेप्शन कैच जोड़े।

try {
  Log.d(TAG, "Starting inference for model '${model.name}' with input: '${input.take(50)}...'")
  val instance = model.instance as LlmModelInstance? ?: run {
    Log.e(TAG, "Model instance is null for '${model.name}'")
    resultListener("Error: Model not initialized", true)
    return
  }
} catch (e: Exception) {
  Log.e(TAG, "Error during inference for model '${model.name}'", e)
  resultListener("Error during inference: ${e.message}", true)
}संचालित द्वारा

उपरोक्त कोड यह सुनिश्चित करता है कि इन्फरेंस केवल वैध मॉडल इंस्टेंस के साथ ही आगे बढ़े, और रनटाइम त्रुटियों को साफ़-सुथरे ढंग से कैच करे। as LlmModelInstance? कास्ट जाँचता है कि मॉडल इंस्टेंस सही प्रकार का है या नहीं, और एल्विस-जैसा फॉलबैक यदि नल हो तो निष्पादन को तुरंत रोक देता है। try/catch में ब्लॉक लपेटने से कोई भी एक्सेप्शन पकड़ में आता है और उन्हें उपयोगकर्ता-दिखाई देने वाले एरर संदेशों के रूप में भेजा जाता है।

चरण 6: अपने डिवाइस पर ऐप इंस्टॉल और रन करें

जब आप सभी आवश्यक बदलाव कर लें, तो हम ऐप चलाएँगे। अपने लोकल Android डिवाइस पर ऐप चलाने के लिए, निम्न चरणों के साथ Android Studio में वायरलेस डिबगिंग का उपयोग करके अपने डिवाइस को पेयर करें।

चरण 6.1: Android डिवाइस सेट अप करें

अपने Android डिवाइस पर Settings ऐप में जाएँ और Developer options सक्षम करें। फिर Wireless debugging चालू करें। आपको दो पेयरिंग विकल्पों वाली स्क्रीन दिखनी चाहिए।

चरण 6.2: Android Studio में डिवाइस प्रबंधित करें

Android Studio में Device Manager खोलें (आइकन पर Android लोगो वाला फ़ोन दिखता है) और Pair using QR code पर क्लिक करें।

अपने डिवाइस से QR कोड स्कैन करें और पेयरिंग सेटअप पूरा करें। एक बार डिवाइस कनेक्ट होने पर, Device Manager के अंतर्गत आपका डिवाइस नाम दिखाई देगा। सुनिश्चित करें कि आपका सिस्टम और Android डिवाइस दोनों एक ही WiFi नेटवर्क से जुड़े हों।

चरण 6.3: ऐप चलाएँ

Android डिवाइस मिररिंग शुरू करने के लिए Device Mirroring आइकन (जिसमें डेस्कटॉप स्क्रीन और फ़ोन स्क्रीन दिखती है) पर क्लिक करें। जैसे ही आपका डिवाइस स्क्रीन मिरर हो जाए, हरे Run आइकन पर क्लिक करें ताकि ऐप आपके डिवाइस पर डिप्लॉय हो जाए।

चरण 6.4: मॉडलों को ऑन-डिवाइस डाउनलोड करें

ऐप लॉन्च होगा, और एक ब्राउज़र विंडो खुलेगी जो आपको मॉडल फ़ाइल को सुरक्षित रूप से डाउनलोड करने के लिए write टोकन के साथ Hugging Face में लॉग इन करने के लिए प्रेरित करेगी।

HuggingFace में लॉग इन करने के बाद, चयनित मॉडल पर start download पर क्लिक करें, और आपका मॉडल डाउनलोड होना शुरू हो जाएगा। इस उदाहरण में, मैं डिफ़ॉल्ट रूप से gemma3-270m-it-q8 मॉडल का उपयोग कर रहा हूँ। अब आप इस मॉडल के साथ प्रयोग शुरू कर सकते हैं।

चरण 7: प्रयोग शुरू करें

इस ट्यूटोरियल के लिए, मैंने चार प्रयोग चलाए:

प्रयोग 1: फ्री-फ़ॉर्म लेखन

इस प्रयोग में, मैंने मॉडल को एक फ्री-फ़ॉर्म कहानी लिखने के लिए प्रॉम्प्ट किया, और ये परिणाम रहे:

मॉडल स्पष्ट संरचना के साथ विषय-वस्तु पर असरदार टेक्स्ट बनाता है, हालाँकि यह अक्सर सुरक्षित खेलता है और कुछ हद तक सामान्य-सा लग सकता है। लंबे आउटपुट पर, मॉडल आमतौर पर कुछ वाक्यों को दोहराता है। इससे यह छोटे पोस्ट्स, विवरणों और आउटलाइन के लिए सबसे उपयुक्त बनता है। हालाँकि, फर्स्ट-टोकन जेनरेशन क़रीब 0.53 सेकंड में काफ़ी तेज़ है, और ऑन-डिवाइस इन्फरेंस के लिए डिकोड स्पीड भी अच्छी है।

प्रयोग 2: टोन री-राइट

अगले चरण में, मैंने पहले से लिखे एक पैराग्राफ़ का उपयोग किया और Gemma 3 270M से उसे फ्रेंडली टोन में फिर से लिखने को कहा।

इंस्ट्रक्शन-फ़ॉलोइंग मज़बूत है—औपचारिक, अनौपचारिक और फ्रेंडली टोन के बीच स्पष्ट बदलाव करते हुए भी अर्थ बरक़रार रहता है। छोटे पैसेज के लिए गति लगभग त्वरित है, जिससे ईमेल पॉलिश करने या शैलियों के बीच टेक्स्ट को कन्वर्ट करने के लिए यह उपयुक्त है।

प्रयोग 3: टेक्स्ट का सार

मैंने पहले से लिखे टेक्स्ट को बुलेट पॉइंट्स में समरी भी किया। आप समरी, पॉइंट्स, टेकअवे और अन्य के साथ प्रयोग कर सकते हैं।

इस प्रयोग में, मॉडल समरी करता है और मुख्य बिंदुओं को पकड़ता है। छोटे और मध्यम आकार के दस्तावेजों के लिए गति उत्कृष्ट है। कुछ उपयोग मामलों में एग्ज़ीक्यूटिव समरी, बुलेट हाइलाइट्स या TL;DR शामिल हैं। 

प्रयोग 4: कोड स्निपेट राइटर

अंत में, मैंने मॉडल से एक छोटा कोड स्निपेट लिखने को कहा। यह पाया:

मॉडल बॉयलरप्लेट और छोटे यूटिलिटीज़ जेनरेट करने में प्रभावी है, हालाँकि यह इम्पोर्ट्स, एज केस, या जटिल लॉजिक को गाइडेंस के बिना मिस कर सकता है। छोटे स्निपेट्स तेज़ी से बनते हैं, जबकि लंबी कम्प्लीशन्स कॉन्टेक्स्ट बढ़ने पर थोड़ी धीमी हो जाती हैं। यह हेल्पर फ़ंक्शन्स और कॉन्फ़िग्स के लिए सबसे अच्छा काम करता है। 

यदि आप पूरे प्रोजेक्ट कोड को एक्सप्लोर करना चाहते हैं, तो मैंने यह GitHub रिपोजिटरी सेट अप कर दी है।

निष्कर्ष

इस गाइड में, हमने चरण-दर-चरण देखा कि Gemma 3 270M मॉडल को कैसे चलाएँ—मॉडल डाउनलोड करने और उसे कस्टम Android ऐप में वायर करने से लेकर नेविगेशन, विश्वसनीयता और इन्फरेंस-टाइम सेफ़्टी को संभालने तक।

Gemma 3 तेज़ इन्फरेंस, कम कम्प्यूटेशनल ओवरहेड, बहुत कम पावर उपयोग, INT4 क्वांटाइज़ेशन के लिए सपोर्ट (परफॉर्मेंस पर न्यूनतम प्रभाव के साथ), और पूर्ण ऑन-डिवाइस रनिंग प्रदान करता है जिससे गोपनीयता बनी रहती है।