Panduan Inferensi LLM untuk Android

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

Tugas ini mendukung Gemma 2B, bagian dari kelompok model terbuka yang ringan dan canggih yang dibangun dari penelitian yang sama dan teknologi yang digunakan untuk membuat model Gemini. Alat ini juga mendukung model eksternal berikut: Phi-2, Falcon-RW-1B dan StableLM-3B, beserta semua model yang diekspor melalui AI Edge.

Untuk mengetahui informasi selengkapnya terkait kemampuan, model, dan opsi konfigurasi. tugas ini, lihat Ringkasan.

Contoh kode

Panduan ini mengacu pada contoh aplikasi pembuatan teks dasar untuk Android. Anda dapat menggunakan aplikasi sebagai titik awal untuk aplikasi Android Anda sendiri, atau merujuk ke sana saat memodifikasi aplikasi yang ada. Kode contoh di-{i>host<i} di GitHub.

Mendownload kode

Petunjuk berikut menunjukkan cara membuat salinan lokal dari 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 sparse, sehingga Anda memiliki hanya 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 dari kode contoh, Anda dapat mengimpor project ke Android Studio dan menjalankan aplikasi. Untuk petunjuk, lihat Panduan Penyiapan untuk Android.

Penyiapan

Bagian ini menjelaskan langkah-langkah utama untuk menyiapkan lingkungan pengembangan dan project kode 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 ini dependensi ke file build.gradle aplikasi Android Anda:

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

Model

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

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

Mendownload model

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

• Gemma 2B: Bagian dari kelompok model terbuka yang ringan dan canggih yang dibangun dari penelitian dan teknologi yang sama digunakan untuk menciptakan model Gemini. Sangat cocok untuk berbagai tugas pembuatan teks, termasuk menjawab pertanyaan, meringkas, dan penalaran.
• Phi-2: 2,7 miliar parameter Model transformer, paling cocok untuk Question-Answer, chat, dan kode format font.
• Falcon-RW-1B: 1 miliar model khusus decoder kausal yang dilatih dengan 350 miliar token RefinedWeb.
• StableLM-3B: 3 model bahasa khusus decoder miliar parameter yang dilatih sebelumnya pada 1 triliun token dari beragam {i>dataset<i} bahasa Inggris dan kode.

Atau, Anda dapat menggunakan model yang dipetakan dan diekspor melalui Troch AI Edge.

Sebaiknya gunakan Gemma 2B, yang tersedia di Kaggle Model dan menggunakan dalam format yang sudah kompatibel dengan LLM Inference API. Jika Anda menggunakan LLM lain, Anda harus mengonversi model ke Format yang sesuai untuk MediaPipe. Untuk informasi selengkapnya tentang Gemma 2B, lihat Gemma situs Anda. Untuk mengetahui informasi selengkapnya tentang model yang tersedia, lihat ringkasan tugas bagian Model.

Mengonversi model ke format MediaPipe

Konversi model native

Jika Anda menggunakan LLM eksternal (Phi-2, Falcon, atau StableLM) atau non-Kaggle dari Gemma, gunakan skrip konversi untuk memformat model yang akan yang kompatibel dengan MediaPipe.

Proses konversi model memerlukan paket MediaPipe PyPI. Konversi skrip tersedia di semua paket MediaPipe setelah 0.10.11.

Instal dan impor dependensi dengan hal berikut:

$ python3 -m pip install mediapipe

Gunakan library genai.converter untuk mengonversi model:

import mediapipe as mp
from mediapipe.tasks.python.genai import converter

config = converter.ConversionConfig(
  input_ckpt=INPUT_CKPT,
  ckpt_format=CKPT_FORMAT,
  model_type=MODEL_TYPE,
  backend=BACKEND,
  output_dir=OUTPUT_DIR,
  combine_file_only=False,
  vocab_model_file=VOCAB_MODEL_FILE,
  output_tflite_file=OUTPUT_TFLITE_FILE,
)

converter.convert_checkpoint(config)

Untuk mengonversi model LoRA, ConversionConfig harus menentukan model dasar serta opsi LoRA tambahan. Perhatikan karena API saja mendukung inferensi LoRA dengan GPU, backend harus ditetapkan 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.

Konversi model AI Edge

Jika Anda menggunakan LLM yang dipetakan ke model TFLite melalui AI Edge, gunakan skrip pemaketan untuk membuat Task Bundle. Proses pemaketan mengemas model yang dipetakan dengan metadata tambahan (mis., Parameter Tokenizer) yang diperlukan untuk menjalankan inferensi {i>end-to-end<i}.

Proses pemaketan model memerlukan paket MediaPipe PyPI. Konversi skrip tersedia di semua paket MediaPipe setelah 0.10.14.

Instal dan impor dependensi dengan hal berikut:

$ python3 -m pip install mediapipe

Gunakan library genai.bundler untuk memaketkan model:

import mediapipe as mp
from mediapipe.tasks.python.genai import bundler

config = bundler.BundleConfig(
    tflite_model=TFLITE_MODEL,
    tokenizer_model=TOKENIZER_MODEL,
    start_token=START_TOKEN,
    stop_tokens=STOP_TOKENS,
    output_filename=OUTPUT_FILENAME,
    enable_bytes_to_unicode_mapping=ENABLE_BYTES_TO_UNICODE_MAPPING,
)
bundler.create_bundle(config)

Kirim model ke perangkat

Mengirim konten folder output_path ke Android perangkat seluler.

$ 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 Anda. Fungsi createFromOptions() menerima nilai untuk konfigurasi lainnya. Untuk informasi selengkapnya mengenai opsi konfigurasi, lihat Konfigurasi lainnya.

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 input teks yang disediakan di bagian sebelumnya (inputPrompt). Proses ini menghasilkan satu respons yang dihasilkan.

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

Untuk men-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 ID teks respons.

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 Peringkat Rendah (LoRA) untuk model bahasa besar. Dengan memanfaatkan model LoRA yang telah disesuaikan, developer dapat menyesuaikan perilaku LLM melalui proses pelatihan yang hemat biaya.

Dukungan LoRA untuk LLM Inference API berfungsi untuk model Gemma-2B dan Phi-2 untuk backend GPU, dengan bobot LoRA yang hanya berlaku untuk lapisan atensi. Ini implementasi awal berfungsi sebagai API eksperimental untuk pengembangan mendatang dengan rencana untuk mendukung lebih banyak model dan berbagai jenis lapisan dalam pembaruan.

Menyiapkan model LoRA

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

# For Gemma-2B
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, serta 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 ditetapkan 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

LLM Inference API Web, Android, dan iOS diupdate untuk mendukung inferensi model LoRA. Web mendukung LoRA dinamis, yang dapat mengganti berbagai model LoRA selama runtime. Android dan iOS mendukung LoRA statis, yang menggunakan bobot LoRA yang sama selama masa aktif tugas.

// 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 seperti model dasar.