Panduan Inferensi LLM untuk Android

LLM Inference API memungkinkan Anda menjalankan model bahasa besar (LLM) sepenuhnya di perangkat untuk aplikasi Android, yang dapat Anda gunakan untuk melakukan berbagai tugas, seperti membuat teks, mengambil informasi dalam bentuk bahasa alami, dan meringkas dokumen. Tugas ini menyediakan dukungan bawaan untuk beberapa model bahasa besar text-to-text, sehingga Anda dapat menerapkan model AI generatif di perangkat terbaru ke aplikasi Android Anda.

Untuk menambahkan LLM Inference API dengan cepat ke aplikasi Android Anda, ikuti Panduan memulai. Untuk contoh dasar aplikasi Android yang menjalankan LLM Inference API, lihat aplikasi contoh. Untuk pemahaman yang lebih mendalam tentang cara kerja LLM Inference API, lihat bagian opsi konfigurasi, konversi model, dan penyesuaian LoRA.

Anda dapat melihat cara kerja tugas ini dengan demo MediaPipe Studio. Untuk mengetahui informasi selengkapnya tentang kemampuan, model, dan opsi konfigurasi tugas ini, lihat Ringkasan.

Panduan memulai

Gunakan langkah-langkah berikut untuk menambahkan LLM Inference API ke aplikasi Android Anda. LLM Inference API dioptimalkan untuk perangkat Android kelas atas, seperti Pixel 8 dan Samsung S23 atau yang lebih baru, dan tidak mendukung emulator perangkat secara andal.

Menambahkan dependensi

LLM Inference API menggunakan library com.google.mediapipe:tasks-genai. Tambahkan dependensi ini ke file build.gradle aplikasi Android Anda:

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

Mendownload model

Download Gemma-3 1B dalam format terkuantisasi 4-bit dari Hugging Face. Untuk mengetahui informasi selengkapnya tentang model yang tersedia, lihat dokumentasi Model.

Kirim konten folder output_path ke perangkat 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

Menginisialisasi Tugas

Lakukan inisialisasi tugas dengan opsi konfigurasi dasar:

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

Menjalankan Tugas

Gunakan metode generateResponse() untuk menghasilkan respons teks. Tindakan ini akan menghasilkan satu respons yang dibuat.

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

Untuk melakukan streaming respons, gunakan metode generateResponseAsync().

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

llmInference.generateResponseAsync(inputPrompt)

Contoh aplikasi

Untuk melihat cara kerja LLM Inference API dan menjelajahi berbagai kemampuan AI Generatif di perangkat, lihat aplikasi Google AI Edge Gallery.

Galeri AI Edge Google adalah aplikasi Android open source yang berfungsi sebagai platform eksperimental interaktif bagi developer. Bagian ini menampilkan:

• Contoh praktis penggunaan LLM Inference API untuk berbagai tugas, termasuk:
  • Tanya Gambar: Upload gambar dan ajukan pertanyaan tentang gambar tersebut. Mendapatkan deskripsi, memecahkan masalah, atau mengidentifikasi objek.
  • Lab Perintah: Meringkas, menulis ulang, membuat kode, atau menggunakan perintah freeform untuk mempelajari kasus penggunaan LLM sekali putaran.
  • Chat AI: Terlibat dalam percakapan bolak-balik.
• Kemampuan untuk menemukan, mendownload, dan bereksperimen dengan berbagai model yang dioptimalkan untuk LiteRT dari Komunitas LiteRT Hugging Face dan rilis resmi Google (misalnya, Gemma 3N).
• Tolok ukur performa real-time di perangkat untuk berbagai model (Waktu Hingga Token Pertama, kecepatan dekode, dll.).
• Cara mengimpor dan menguji model .litertlm atau .task kustom Anda sendiri.

Aplikasi ini adalah sumber daya untuk memahami penerapan praktis LLM Inference API dan potensi AI Generatif di perangkat. Pelajari kode sumber dan download aplikasi dari repositori Google AI Edge Gallery GitHub.

Opsi konfigurasi

Gunakan opsi konfigurasi berikut untuk menyiapkan aplikasi Android:

Prompt multimodal

API Android LLM Inference API mendukung perintah multimodal dengan model yang menerima input teks, gambar, dan audio. Dengan mengaktifkan multimodalitas, pengguna dapat menyertakan kombinasi gambar dan teks atau audio dan teks dalam perintah mereka.LLM kemudian memberikan respons teks.

Untuk memulai, gunakan varian Gemma 3n yang kompatibel dengan MediaPipe:

• Gemma-3n E2B: model 2B yang efektif dari rangkaian Gemma-3n.
• Gemma-3n E4B: model 4B yang efektif dari rangkaian Gemma-3n.

Untuk mengetahui informasi selengkapnya, lihat dokumentasi Gemma-3n.

Ikuti langkah-langkah di bawah untuk mengaktifkan input gambar atau audio untuk LLM Inference API.

Input gambar

Untuk memberikan gambar dalam perintah, konversi gambar atau frame input menjadi objek com.google.mediapipe.framework.image.MPImage sebelum meneruskannya ke 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()

Untuk mengaktifkan dukungan visual untuk LLM Inference API, tetapkan opsi konfigurasi EnableVisionModality ke true dalam opsi Grafik:

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

Tetapkan maksimum 10 gambar per sesi.

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

Berikut adalah contoh penerapan LLM Inference API yang disiapkan untuk menangani input teks dan visual:

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

Input audio

Mengaktifkan dukungan audio di LlmInferenceOptions

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

Aktifkan dukungan Audio di sessionOptions

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

Mengirim data audio selama inferensi. Catatan: Audio harus berformat saluran mono sebagai .wav

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

Berikut adalah contoh penerapan LLM Inference API yang disiapkan untuk menangani input audio dan teks:

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

Penyesuaian LoRA

LLM Inference API mendukung penyesuaian LoRA (Low-Rank Adaptation) menggunakan library PEFT (Parameter-Efficient Fine-Tuning). Penyesuaian LoRA menyesuaikan perilaku LLM melalui proses pelatihan yang hemat biaya, dengan membuat sekumpulan kecil bobot yang dapat dilatih berdasarkan data pelatihan baru, bukan melatih ulang seluruh model.

LLM Inference API mendukung penambahan bobot LoRA ke lapisan perhatian model Gemma-2 2B, Gemma 2B, dan Phi-2. Download model dalam format safetensors.

Model dasar harus dalam format safetensors untuk membuat bobot LoRA. Setelah pelatihan LoRA, Anda dapat mengonversi model ke format FlatBuffers untuk dijalankan di MediaPipe.

Menyiapkan bobot LoRA

Gunakan panduan Metode LoRA dari PEFT untuk melatih model LoRA yang di-fine-tune pada set data Anda sendiri.

LLM Inference API hanya mendukung LoRA pada lapisan perhatian, jadi hanya tentukan lapisan perhatian di 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"],
)

Setelah dilatih pada set data yang disiapkan dan model disimpan, bobot model LoRA yang di-fine-tune tersedia di adapter_model.safetensors. File safetensors adalah checkpoint LoRA yang digunakan selama konversi model.

Konversi model

Gunakan Paket Python MediaPipe untuk mengonversi bobot model ke format Flatbuffer. ConversionConfig menentukan opsi model dasar beserta opsi LoRA tambahan.

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)

Konverter akan menghasilkan dua file Flatbuffer, satu untuk model dasar dan satu lagi untuk model LoRA.

Inferensi model LoRA

Android mendukung LoRA statis selama inisialisasi. Untuk memuat model LoRA, tentukan jalur model LoRA serta LLM dasar.

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

Untuk menjalankan inferensi LLM dengan LoRA, gunakan metode generateResponse() atau generateResponseAsync() yang sama seperti model dasar.