Gemma 3 270M: Demo Projeyle Kılavuz (Android Uygulaması)

Google yakın zamanda Gemma 3 270M’i yayınladı; bu ultra kompakt, 270 milyon parametreli model, verimli yapay zekâ dağıtımında yeni bir paradigma sunuyor. Devasa genel amaçlı modellerin aksine Gemma 3 270M, kutudan çıktığı gibi komutları takip edebilme yeteneğini korurken, göreve özel ince ayar için tasarlanmıştır.

Bu eğitimde, Gemma 3 270M’e nasıl başlayacağınızı göstereceğim ve aşağıdaki ihtiyaçları olan geliştiriciler için neden harika bir seçenek olduğunu anlatacağım:

• Minimum hesaplama yüküyle yıldırım hızında çıkarım
• Aşırı enerji verimliliği (Pixel 9 Pro’da 25 sohbet için yalnızca %0,75 pil kullanımı)
• INT4 hassasiyetle niceleme ve minimum performans kaybı
• Tamamen cihaz üzerinde çalıştırma ile eksiksiz gizlilik

Okurlarımızı en yeni yapay zekâ gelişmeleri hakkında güncel tutmak için her Cuma yayımladığımız, haftanın öne çıkan haberlerini özetleyen ücretsiz bültenimiz The Median’ı gönderiyoruz. Abone olun, haftada sadece birkaç dakikada güncel kalın:

Gemma 3 270M Nedir?

Gemma 3 270M, yalnızca 270 milyon parametreyle güçlü komut takibi ve yapılandırılmış metin üretimi sunmak üzere tasarlanmış kompakt bir temel modeldir. Gemma 3 ailesinin en küçük üyesidir; ancak Gemma 3 1B ve 4B gibi daha büyük varyantlarla aynı mimariyi ve eğitim yöntemlerini miras alır.

Genel amaçlı büyük modellerin aksine Gemma 3 270M, verimlilik ve uzmanlaşmaya odaklanır. Bu modelle ilgili birkaç önemli nokta:

• Mobil cihazlarda zahmetsizce çalışır; nicelemeli çıkarım (INT4, Q8 ve daha fazlası) birden fazla sohbet boyunca %1’den az pil tüketir.
• 100M dönüştürücü parametresi ve 256.000 tokenlık bir sözlüğü destekleyen büyük bir 170M gömme matrisi vardır; bu da onu alanına özgü uygulamalarda nadir tokenları ele almak için ideal kılar.
• Komutla eğitilmiş denetim noktaları da mevcuttur; böylece bulut bağlantısı gerektirmeyen asistanlar, veri çıkarıcılar ve yaratıcı yazma araçları oluşturmak kolaylaşır.

Gemma 3 270M’in komut takip yetenekleri iyidir — IFEval kıyaslaması, bir modelin doğrulanabilir bilgileri takip etme becerisini test eder. Kaynak: Google

32K bağlam penceresi, düşük bellek kullanımı ve varlık çıkarımı, sınıflandırma ve hafif uyumluluk kontrolleri gibi görevlerde sağlam doğrulukla Gemma 3 270M, gizlilik, hız ve maliyet verimliliği arayan uç yapay zekâ geliştiricileri için mükemmeldir.

Gemma 3 270M’e Nasıl Erişilir?

Tercih ettiğiniz platforma bağlı olarak Gemma 3 270M’e başlamanın birkaç kolay yolu vardır:

1. Cloud Run

Gemma 3’ü Google Cloud Run üzerinde, ölçeklenebilir çıkarım için önceden oluşturulmuş GPU hızlandırmalı bir konteyner kullanarak dağıtabilirsiniz. Gemma 3 270M için konteynerinizi Gemma-on-CloudRun GitHub deposundan oluşturmanız gerekir; çünkü yalnızca daha büyük varyantlar (1B+) önceden hazırlanmıştır. Web veya arka uç uygulamaları için hızlı, güvenli ve uygun maliyetli çıkarımı etkinleştirmek üzere Google Cloud Run resmî kılavuzundaki talimatları izleyin.

2. Android (Önerilir)

En iyi kullanıcı deneyimi, Gemma 3 270M’in nicelemeli bir sürümünü (gemma3-270m-it-q8) ve Google’ın resmî Gemma Gallery Uygulamasını kullanarak cihaz üzerinde elde edilir. Bu yaklaşım son derece hızlı çevrimdışı çıkarım, güçlü gizlilik ve minimum pil tüketimi sağlar.

3. Yerel çıkarım

Gemma 3 270M’i dizüstü bilgisayarınızda şu araçlarla da çalıştırabilirsiniz:

• LM Studio: LM Studio ortamınızda .gguf ya da .litertlm uzantılı bir modeli indirin ve sohbet arayüzünde hemen çalıştırın veya yerelde barındırın.
• Ollama: Bu modeli makinenizde yerel olarak çalıştırmak için ollama run gemma3:270m komutunu da kullanabilirsiniz.
• Llama.cpp: Bu da ultra hafif CPU çıkarımı için Gemma 3 270M modelini sunar.
• Docker: Gemma 3’ü Hugging Face’ten veya Gemma’nın resmî GitHub deposundan bir Docker konteyneriyle de çalıştırabilirsiniz.
• HuggingFace: Kullanıcılar bu modele HuggingFace arayüzü üzerinden doğrudan erişebilir veya çıkarım yapabilir ya da yerel kullanım için hem önceden eğitilmiş hem de komutla eğitilmiş modelleri indirebilir.

4. Modeli ince ayar yapın

Gemma 3 270M, Hugging Face Transformers, JAX veya Unsloth’ta alanınıza özgü veriler üzerinde ince ayar yapmak için de kullanılabilir. Modelin küçük boyutu, hızlı ve düşük maliyetli deneyler için idealdir; QAT denetim noktaları, ince ayar sonrasında doğrudan INT4 dağıtımını etkinleştirir.

Sırada, metin istemlerini işlemek için Gemma 3 270M modelini kullanan çalışan bir Android uygulaması oluşturmayı adım adım göstereceğim. Temel olarak Google’ın resmî Gallery deposunu kullanacak ve özelleştireceğiz.

Adım 1: Uygulamayı Klonlayın ve Kurun

Yeni bir proje oluşturarak ve Google’dan orijinal depoyu klonlayarak başlayalım.

Adım 1.1: Yeni bir Android Studio projesi oluşturun

Dizüstü bilgisayarınızda projeyi Android Studioda yeni bir proje olarak açın ve Empty Activity seçin.

Adım 1.2: Yeni boş bir etkinlik ayarlayın

Ardından, etkinliğinizin adını (örneğin, “Gemma 3 270M”) girin ve geri kalanını olduğu gibi bırakın. Sonra Finish’e tıklayın.

Adım 1.3: Ana depoyu klonlayın

Şimdi Android Studio içindeki terminali (sol altta) açın ve aşağıdaki bash komutlarını çalıştırın:

git clone https://github.com/google-ai-edge/gallery
cd gallery/androidAltyapı:

Bu, projenizi açacaktır. Tüm proje dosyalarını sekmenin sol tarafında görüntüleyebilirsiniz.

Adım 2: Modeli Bağlayın

Gemma 3 270M modelini Android uygulamanıza bağlamak için, uygulamanın Tasks.kt dosyası içinde yeni bir görev olarak kaydetmeniz gerekir.

data/ klasörüne gidin ve Tasks.kt dosyasını açın. Burada, düşük bellek kullanımı ve cihaz üzerinde çıkarım için optimize edilmiş modelin Q8 nicelemeli varyantı gemma3-270m-it-q8 için özel bir görev girdisi tanımlayacaksınız. Bu format, sınırlı RAM’e sahip mobil cihazlara uygundur.

Not: Bu eğitimde, daha az bellek gerektiren bir Q8 model yapılandırması kullanacağım. Bu modele buradan erişebilirsiniz: 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
)Altyapı:

Ardından, ana görev listesine ekleyerek bu yeni görevi uygulamada kaydedin:

/** 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
)Altyapı:

Yeni LiteRT görev tanımının kodda neler yaptığına dair özet:

• Yeni bir görev tanımlar: TASK_GEMMA_3_270M değişkeni, Gemma 3 270M’i uygulamanın Tasks.kt dosyasında seçilebilir bir seçenek olarak kaydeder; böylece görev listesinde görünür.
• .task dosyasını bağlar: Yukarıdaki kod, uygulama içinde indirilen ve çalışma zamanında kullanılan Hugging Face’te barındırılan gemma3-270m-it-q8.task paketine işaret eder.
• Model ayrıntıları: .task dosyası, LiteRT’nin modeli verimli şekilde çalıştırması için gereken nicelemeli model ağırlıkları, belirteçleyici, üstveri ve yapılandırmaları içerir.
• Q8 varyantı: Bu niceleme, bellek tasarrufu ile iyi çıktı kalitesi arasında denge kurar; telefonlar için yeterince hafiftir ve komut takibini iyi bir şekilde sürdürür.
• Görev üstverisi: Açıklama, dokümantasyon URL’si ve kaynak kod bağlantısı ekler; bu da Gallery uygulaması içinde görevin anlaşılmasını ve bakımını kolaylaştırır.
• Görev listesi: Son olarak modeli TASK_GEMMA_3_270M olarak listeleyerek görev listesi altında tanınmasını sağlar.

Adım 3: Model Listesi Düzeltmesi

Varsayılan olarak Gallery uygulaması, model listelerini uzak bir izinli liste JSON’undan doldurur. Özel Gemma 3 270M girdiniz orada yoksa, kodda TASK_GEMMA_3_270M eklemiş olsanız bile arayüzde görünmez. Bu adım, izinli liste yüklendikten sonra 270M modelinizi LLM Prompt Lab görevine ekler ve her seferinde seçilebilir olmasını sağlar.

modelmanager/ModelManagerViewModel.kt dosyasını açın, loadModelAllowlist() fonksiyonunu bulun ve (izinli listedeki modelleri dönüştüren döngüden sonra) şunu ekleyin:

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)
              }Altyapı:

Bu kodun gerekli olmasının nedeni:

• İzinli liste sıfırlaması: Uygulama başlangıçta TASK_LLM_PROMPT_LAB.models’i sunucu izinli listesinden temizleyip yeniden oluşturur. Yerel modeliniz, tekrar eklemezseniz silinir.
• İdempotent ve yinelenmeye dayanıklı: any { it.name == gemmaModel.name } koruması, loadModelAllowlist() fonksiyonu tekrar çalıştığında yinelemeleri önler.
• Çevrimdışı dostu: Bu kod, izinli liste ağdan veya diskten yüklense de çalışır. Model her iki durumda da listeye eklenir.

İşte tamamı:

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}"
          ) 
        }
      }
    }
  }Altyapı:

Adım 4: Gezinme Mantığını Güncelleyin

Varsayılan olarak uygulama, seçili görevin tıklanan modelle eşleştiğini varsayar. Gemma 3 270M’i Prompt Lab görevine (Adım 3) eklediğinizde bu varsayım bozulabilir. Bu adım, gezinmeyi modele duyarlı hâle getirir; böylece dokunmalar, derin bağlantılar ve geri yüklenen durumlar her zaman doğru ekrana yönlenir.

navigation/GalleryNavGraph.kt dosyasını açın ve model gezinme kontrol mantığını aşağıdaki gibi güncelleyin:

Önce:

onModelClicked = { model ->
  navigateToTaskScreen(
    navController = navController, taskType = curPickedTask.type, model = model
  )
}Altyapı:

Sonra:

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
  )
}Altyapı:

Bir model, mevcut seçili görevden farklı bir görevin içinde görünüyorsa (veya oraya enjekte edildiyse) bu kod, ekranın modelin yetenekleriyle eşleşmesini garanti eder. 

Derin bağlantılar veya geri yüklenen durumla uğraşırken, uygulama artık mevcut olmayan bir modeli açmayı deneyebilir. Uygun işleme olmadan bu, boş bir ekranla sonuçlanır. Bunu önlemek için, model eksikse bir uyarı kaydedip kullanıcıyı yönlendiren bir güvenlik kontrolü ekliyoruz. Şöyle yapıyoruz:

// 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()
  }
}Altyapı:

Bu kod, uygulamanın işlevselliğini korur. Donmak veya boş ekran göstermek yerine navController kullanarak güvenle geri gider. Böylece bir model eksik olsa bile kullanıcı akışı genel deneyimi bozmadan sorunsuz devam eder.

Adım 5: Güvenlik ve Güvenilirlik 

Büyük bir dil modelini mobil cihazda çalıştırmak, masaüstünde çalıştırmaktan farklıdır. Depolama güvenilir olmayabilir, bellek bütçeleri daha sıkıdır ve başlatma hataları uygulama çökmesini önlemek için ele alınmalıdır. Gemma 3 270M’i (Q8, ~304MB) Android’de kararlı kılmak için ek güvenlik kontrolleri ve yedek stratejiler ekledim.

Adım 5.1: Toleranslı boyutlandırma ile dosya doğrulaması

Modeli yüklemeden önce uygulama .task dosyası üzerinde mantık kontrolleri yapar. Bu, model dosyasının var olduğundan, okunabildiğinden ve beklenen boyutuna yakın olduğundan (±%10 içinde) emin olur. Bu tolerans, sıkıştırma veya paketleme kaynaklı küçük farkları hesaba katar ve bozuk ya da kısmi indirmeleri yakalar.

// 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
}Altyapı:

Bu kod parçası, yüklemeden önce bir model dosyasını doğrular. Yol, okunabilirlik ve boyut gibi temel ayrıntıları günlüğe yazar; ardından dosyanın var olup olmadığını, okunup okunamadığını ve beklenen boyutla eşleşip eşleşmediğini kontrol eder. Bu kontrollerden biri başarısız olursa, çıkarım denemek ve çökme riske etmek yerine onDone() yöntemiyle erken durur.

Adım 5.2: Bellek farkındalıklı arka uç seçimi 

Büyük modeller, agresif başlarsanız (uzun çıktılar, GPU tahsis sıçramaları) Bellek Yetersiz (OOM) hataları verebilir. Bunu azaltmak için, dosya boyutu ve cihaz yapılandırmasına göre en güvenli arka ucu (CPU vs GPU/NPU) dinamik olarak seçen ve aşırı büyük ikililer için maksimum token sayısını kısan bir mantık ekledim.

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
}Altyapı:

Bu, büyük modellerin varsayılan olarak CPU’yu seçmesini (daha güvenli ama daha yavaş) sağlar. Kod .task dosyasının bayt boyutunu (fileSize) bir eşikle (maxTokens) karşılaştırır. 200 MB’ı aşarsa çıkarımı CPU’ya geçirir ve token bütçesini yarıya indirir. Bu, eşzamanlı GPU tahsisinden kaynaklanan bellek sıçramalarına ve aşırı büyük üretim isteklerine karşı koruma sağlar.

Adım 5.3: İstisna yönetimi

LiteRT başlatılırken çalışma zamanı oluşturma ile oturum oluşturmayı ayırt etmek önemlidir. Oturum oluşturma başarısız olursa ancak çalışma zamanını açık bırakırsanız, kaynak sızıntısı ve bellek kilitlenmesi yaşayıp ardışık hatalara neden olabilirsiniz. Bunu düzeltmek için kodu açık temizlikle try/catch bloklarına sardım.

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
}Altyapı:

Bu try/catch, temiz bir geri almayı garanti eder; yani çalışma zamanı oluşturma başarısız olursa başka hiçbir şey ilerlemez; oturum oluşturma başarısız olursa çalışma zamanı açıkça kapatılır. Böylece yığında ayrılmış llmInference nesnesi .close() ile imha edilerek bellek ve dosya tanıtıcıları serbest bırakılır. Aksi takdirde bir sonraki model yüklemesinde çökmeye yol açabilecek JNI referansları riski oluşur.

Adım 5.4: Çıkarım zamanı korumaları

Bir model başarıyla yüklense bile, yarış durumları, null başvurular veya ilklendirilmeyen örnekler nedeniyle çıkarım başarısız olabilir. Bu adımı sağlamlaştırmak için, tam çıkarım bloğunun etrafına null kontrolleri ve istisna yakalama ekledim.

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)
}Altyapı:

Yukarıdaki kod, yalnızca geçerli bir model örneğiyle çıkarım yapılmasını ve çalışma zamanı hatalarının temiz şekilde yakalanmasını garanti eder. as LlmModelInstance? dönüştürmesi, model örneğinin doğru türde olup olmadığını kontrol eder ve Elvis benzeri geri dönüş null ise yürütmeyi kısa devre yapar. Bloğu try/catch içine almak, tüm istisnaların yakalanıp kullanıcıya görünür hata iletileri olarak döndürülmesini sağlar.

Adım 6: Uygulamayı Cihazınıza Kurup Çalıştırın

Gerekli tüm değişiklikleri yaptıktan sonra uygulamayı çalıştıracağız. Yerel Android cihazınızda uygulamanızı çalıştırmak için, aşağıdaki adımlarla Android Studio ile kablosuz hata ayıklama üzerinden cihazınızı eşleştirin.

Adım 6.1: Android cihazı ayarlayın

Android cihazınızda Ayarlar uygulamasına gidip Geliştirici seçeneklerini etkinleştirin. Ardından Kablosuz hata ayıklamayı açın. İki eşleştirme seçeneği içeren bir ekran görmelisiniz.

Adım 6.2: Android Studio’da cihazları yönetin

Android Studio’da Device Manager’ı (Android logolu telefon simgesi) açın ve Pair using QR code’a tıklayın.

QR kodunu cihazınızla tarayın ve eşleştirme kurulumunu tamamlayın. Cihazınız bağlandığında, Device Manager altında cihaz adınızı göreceksiniz. Sisteminizin ve Android cihazınızın aynı WiFi ağına bağlı olduğundan emin olun.

Adım 6.3: Uygulamayı çalıştırın

Android cihazınızı yansıtmayı, Device Mirroring simgesine (bir masaüstü ekranı ve bir telefon ekranı gösterir) tıklayarak başlatın. Cihaz ekranınız yansıtıldığında, yeşil Run simgesine tıklayarak uygulamayı cihazınıza dağıtın.

Adım 6.4: Modelleri cihaz üzerinde indirin

Uygulama başlatılacak ve modeli güvenli şekilde indirmek için bir write belirteciyle Hugging Face’e giriş yapmanız istenen bir tarayıcı penceresi açılacaktır.

HuggingFace’e giriş yaptıktan sonra, seçtiğiniz modelde start download’a tıklayın ve modeliniz indirilmeye başlasın. Bu örnekte varsayılan olarak gemma3-270m-it-q8 modelini kullanıyorum. Artık bu modelle denemelere başlayabilirsiniz.

Adım 7: Denemelere Başlayın

Bu eğitim kapsamında dört deneme yaptım:

Deneme 1: Serbest yazım

Bu denemede modelden serbest biçimli bir hikâye yazmasını istedim ve sonuçlar şöyle:

Model, net bir yapıyla konuya uygun metin üretiyor; ancak temkinli davranma ve biraz genel kalma eğiliminde. Daha uzun çıktılarda genellikle bazı cümleleri tekrar ediyor. Bu da onu kısa yazılar, açıklamalar ve taslaklar için en uygun hâle getiriyor. Bununla birlikte ilk token üretimi yaklaşık 0,53 saniye ile oldukça hızlı ve çözümleme hızı da cihaz üzeri çıkarım için iyi.

Deneme 2: Ton yeniden yazımı

Sonraki adımda, önceden yazılmış bir paragrafı daha samimi bir tonda yeniden yazmasını istedim.

Komut takibi güçlü; anlamı korurken resmî, gündelik ve samimi tonlar arasında net geçişler yapabiliyor. Kısa pasajlarda hız neredeyse anlık; bu da e-postaları parlatma veya metni tarzlar arasında dönüştürme için uygun kılıyor.

Deneme 3: Metni özetleme

Önceden yazılmış metni madde işaretleriyle de özetledim. Özetler, maddeler, çıkarımlar ve daha fazlasıyla deneyebilirsiniz.

Bu denemede model, özetleyip temel noktaları yakalıyor. Kısa ve orta uzunluktaki belgelerde hız mükemmel. Kullanım alanları arasında yönetici özetleri, madde madde vurgular veya TL;DR’ler sayılabilir. 

Deneme 4: Kod parçacığı yazarı

Son olarak modelden küçük bir kod parçacığı yazmasını istedim. Gözlemlerim şöyle:

Model, şablon ve küçük yardımcılar üretmede etkilidir; ancak yönlendirme olmadan içe aktarmaları, uç durumları veya karmaşık mantığı kaçırabilir. Kısa parçacıklar hızlı üretilirken, daha uzun tamamlamalar bağlam büyüdükçe biraz yavaşlar. En iyi yardımcı işlevler ve yapılandırmalar için çalışır. 

Tam proje kodunu keşfetmek isterseniz bu GitHub deposunu hazırladım.

Sonuç

Bu kılavuzda, Gemma 3 270M modelini çalıştırmayı; modeli indirip özel bir Android uygulamasına bağlamaktan gezinme, güvenilirlik ve çıkarım zamanı güvenliğini ele almaya kadar adım adım inceledik.

Gemma 3, düşük hesaplama yüküyle hızlı çıkarım sunar, çok az güç tüketir, performans üzerinde minimum etkiyle INT4 nicelemeyi destekler ve gizliliği korumak için tamamen cihaz üzerinde çalışır.