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 merumuskan dokumen. Tugas ini menyediakan dukungan bawaan untuk beberapa model bahasa besar teks ke teks, sehingga Anda dapat menerapkan model AI generatif terbaru di perangkat ke aplikasi Android.

Tugas ini mendukung varian Gemma berikut: Gemma-2 2B, Gemma 2B, dan Gemma 7B. Gemma adalah sekumpulan model terbuka yang ringan dan canggih, dibangun dari riset dan teknologi yang sama dengan yang digunakan untuk membuat model Gemini. Model ini juga mendukung model eksternal berikut: Phi-2, Falcon-RW-1B, dan StableLM-3B.

Selain model yang didukung, pengguna dapat menggunakan AI Edge Torch Google untuk mengekspor model PyTorch ke dalam model LiteRT (tflite) multi-tanda tangan, yang dipaketkan dengan parameter tokenizer untuk membuat Task Bundle yang kompatibel dengan LLM Inference API.

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

Contoh kode

Panduan ini merujuk pada contoh aplikasi pembuatan teks dasar untuk Android. Anda dapat menggunakan aplikasi ini sebagai titik awal untuk aplikasi Android Anda sendiri, atau merujuknya saat mengubah aplikasi yang ada. Kode contoh dihosting di GitHub.

Mendownload kode

Petunjuk berikut menunjukkan cara membuat salinan lokal contoh kode menggunakan alat command line git.

Untuk mendownload kode contoh:

1. Clone repositori git menggunakan perintah berikut:

   git clone https://github.com/google-ai-edge/mediapipe-samples
   

2. Secara opsional, konfigurasikan instance git Anda untuk menggunakan checkout jarang, sehingga Anda hanya memiliki file untuk aplikasi contoh LLM Inference API:

   cd mediapipe
   git sparse-checkout init --cone
   git sparse-checkout set examples/llm_inference/android
   

Setelah membuat versi lokal kode contoh, Anda dapat mengimpor project ke Android Studio dan menjalankan aplikasi. Untuk mengetahui petunjuknya, lihat Panduan Penyiapan untuk Android.

Penyiapan

Bagian ini menjelaskan langkah-langkah utama untuk menyiapkan lingkungan pengembangan dan project kode Anda secara khusus untuk menggunakan LLM Inference API. Untuk informasi umum tentang menyiapkan lingkungan pengembangan untuk menggunakan tugas MediaPipe, termasuk persyaratan versi platform, lihat Panduan penyiapan untuk Android.

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

Untuk perangkat dengan Android 12 (API 31) atau yang lebih tinggi, tambahkan dependensi library OpenCL native. Untuk mengetahui informasi selengkapnya, lihat dokumentasi tentang tag uses-native-library.

Tambahkan tag uses-native-library berikut ke file AndroidManifest.xml:

<uses-native-library android:name="libOpenCL.so" android:required="false"/>
<uses-native-library android:name="libOpenCL-car.so" android:required="false"/>
<uses-native-library android:name="libOpenCL-pixel.so" android:required="false"/>

Model

MediaPipe LLM Inference API memerlukan model bahasa text-to-text terlatih yang kompatibel dengan tugas ini. Setelah mendownload model, instal dependensi yang diperlukan dan kirim model ke perangkat Android. Jika menggunakan model selain Gemma, Anda harus mengonversi model ke format yang kompatibel dengan MediaPipe.

Untuk informasi selengkapnya tentang model terlatih yang tersedia untuk LLM Inference API, lihat bagian Model ringkasan tugas.

Mendownload model

Sebelum melakukan inisialisasi LLM Inference API, download salah satu model yang didukung dan simpan file dalam direktori project Anda:

• Gemma-2 2B: Versi terbaru dari lini model Gemma. Bagian dari rangkaian model open source yang ringan dan canggih, yang dibuat dari riset dan teknologi yang sama dengan yang digunakan untuk membuat model Gemini.
• Gemma 2B: Bagian dari sekumpulan model terbuka yang ringan dan canggih, yang dibuat dari riset dan teknologi yang sama dengan yang digunakan untuk membuat model Gemini. Sangat cocok untuk berbagai tugas pembuatan teks, termasuk menjawab pertanyaan, peringkasan, dan pemikiran.
• Phi-2: Model Transformer parameter 2,7 miliar, paling cocok untuk format Pertanyaan-Jawab, chat, dan kode.
• Falcon-RW-1B: Model khusus decoder sebab-akibat dengan 1 miliar parameter yang dilatih pada 350 miliar token RefinedWeb.
• StableLM-3B: Model bahasa khusus decoder dengan 3 miliar parameter yang dilatih sebelumnya pada 1 triliun token dari berbagai set data bahasa Inggris dan kode.

Selain model yang didukung, Anda dapat menggunakan AI Edge Torch Google untuk mengekspor model PyTorch ke dalam model LiteRT (tflite) multi-tanda tangan. Untuk mengetahui informasi selengkapnya, lihat Konverter Torch Generative untuk model PyTorch.

Sebaiknya gunakan Gemma-2 2B, yang tersedia di Model Kaggle. Untuk mengetahui informasi selengkapnya tentang model lain yang tersedia, lihat ringkasan tugas Bagian model.

Mengonversi model ke format MediaPipe

LLM Inference API kompatibel dengan dua jenis kategori model, beberapa di antaranya memerlukan konversi model. Gunakan tabel untuk mengidentifikasi metode langkah yang diperlukan untuk model Anda.

Kami menghosting file .bin yang dikonversi untuk Gemma 2B, Gemma 7B, dan Gemma-2 2B di Kaggle. Model ini dapat langsung di-deploy menggunakan LLM Inference API kami. Untuk mempelajari cara mengonversi model lain, lihat bagian Konversi Model.

Mengirim model ke perangkat

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.bin

Membuat tugas

MediaPipe LLM Inference API menggunakan fungsi createFromOptions() untuk menyiapkan tugas. Fungsi createFromOptions() menerima nilai untuk opsi konfigurasi. Untuk informasi selengkapnya tentang opsi konfigurasi, lihat Opsi konfigurasi.

Kode berikut menginisialisasi tugas menggunakan opsi konfigurasi dasar:

// Set the configuration options for the LLM Inference task
val options = LlmInferenceOptions.builder()
        .setModelPATH('/data/local/.../')
        .setMaxTokens(1000)
        .setTopK(40)
        .setTemperature(0.8)
        .setRandomSeed(101)
        .build()

// Create an instance of the LLM Inference task
llmInference = LlmInference.createFromOptions(context, options)

Opsi konfigurasi

Gunakan opsi konfigurasi berikut untuk menyiapkan aplikasi Android:

Menyiapkan data

LLM Inference API menerima input berikut:

• prompt (string): Pertanyaan atau perintah.

val inputPrompt = "Compose an email to remind Brett of lunch plans at noon on Saturday."

Menjalankan tugas

Gunakan metode generateResponse() untuk menghasilkan respons teks terhadap teks input yang diberikan di bagian sebelumnya (inputPrompt). Tindakan ini akan menghasilkan satu respons yang dihasilkan.

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)

Menangani dan menampilkan hasil

LLM Inference API menampilkan LlmInferenceResult, yang menyertakan teks respons yang dihasilkan.

Here's a draft you can use:

Subject: Lunch on Saturday Reminder

Hi Brett,

Just a quick reminder about our lunch plans this Saturday at noon.
Let me know if that still works for you.

Looking forward to it!

Best,
[Your Name]

Penyesuaian model LoRA

API inferensi LLM Mediapipe dapat dikonfigurasi untuk mendukung Adaptasi Rangking Rendah (LoRA) untuk model bahasa besar. Dengan menggunakan model LoRA yang disesuaikan, developer dapat menyesuaikan perilaku LLM melalui proses pelatihan yang hemat biaya.

Dukungan LoRA dari LLM Inference API berfungsi untuk semua varian Gemma dan model Phi-2 untuk backend GPU, dengan bobot LoRA yang hanya berlaku untuk lapisan perhatian. Implementasi awal ini berfungsi sebagai API eksperimental untuk pengembangan mendatang dengan rencana untuk mendukung lebih banyak model dan berbagai jenis lapisan dalam update mendatang.

Menyiapkan model LoRA

Ikuti petunjuk di HuggingFace untuk melatih model LoRA yang telah disesuaikan di set data Anda sendiri dengan jenis model yang didukung, Gemma atau Phi-2. Model Gemma-2 2B, Gemma 2B, dan Phi-2 tersedia di HuggingFace dalam format safetensors. Karena LLM Inference API hanya mendukung LoRA pada lapisan perhatian, hanya tentukan lapisan perhatian saat membuat LoraConfig sebagai berikut:

# 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"],
)

Untuk pengujian, ada model LoRA yang disesuaikan dan dapat diakses secara publik yang sesuai dengan LLM Inference API yang tersedia di HuggingFace. Misalnya, monsterapi/gemma-2b-lora-maths-orca-200k untuk Gemma-2B dan lole25/phi-2-sft-ultrachat-lora untuk Phi-2.

Setelah melatih set data yang disiapkan dan menyimpan model, Anda akan mendapatkan file adapter_model.safetensors yang berisi bobot model LoRA yang telah disesuaikan. File safetensors adalah checkpoint LoRA yang digunakan dalam konversi model.

Sebagai langkah berikutnya, Anda perlu mengonversi bobot model menjadi Flatbuffer TensorFlow Lite menggunakan Paket Python MediaPipe. ConversionConfig harus menentukan opsi model dasar serta opsi LoRA tambahan. Perhatikan bahwa karena API hanya mendukung inferensi LoRA dengan GPU, backend harus disetel ke 'gpu'.

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_TFLITE_FILE,
)

converter.convert_checkpoint(config)

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

Inferensi model LoRA

Web, Android, dan iOS LLM Inference API diupdate untuk mendukung inferensi model LoRA.

// Set the configuration options for the LLM Inference task
val options = LlmInferenceOptions.builder()
        .setModelPath('<path to base model>')
        .setMaxTokens(1000)
        .setTopK(40)
        .setTemperature(0.8)
        .setRandomSeed(101)
        .setLoraPath('<path to LoRA model>')
        .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 dengan model dasar.