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 memberikan dukungan bawaan untuk beberapa model bahasa besar teks-ke-teks, sehingga Anda dapat menerapkan model AI generatif terbaru di perangkat ke aplikasi Android Anda.
Tugas ini mendukung Gemma 2B, bagian dari keluarga model terbuka yang ringan dan canggih yang dibuat dari riset dan teknologi yang sama dengan yang digunakan untuk membuat model Gemini. Platform 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 tentang 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 aplikasi tersebut saat memodifikasi aplikasi yang sudah ada. Kode contoh dihosting di GitHub.
Mendownload kode
Petunjuk berikut menunjukkan cara membuat salinan lokal dari kode contoh menggunakan alat command line git.
Untuk mendownload kode contoh:
- Clone repositori git menggunakan perintah berikut:
git clone https://github.com/google-ai-edge/mediapipe-samples
- Secara opsional, konfigurasikan instance git untuk menggunakan checkout sparse 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 dari 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 membuat kode project secara khusus untuk menggunakan LLM Inference API. Untuk informasi umum tentang menyiapkan lingkungan pengembangan Anda 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'
}
Model
MediaPipe LLM Inference API memerlukan model bahasa teks-ke-teks 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 mengetahui informasi selengkapnya tentang model terlatih yang tersedia untuk LLM Inference API, lihat ringkasan tugas bagian Model.
Download model
Sebelum menginisialisasi LLM Inference API, download salah satu model yang didukung dan simpan file tersebut dalam direktori project Anda:
- Gemma 2B: Bagian dari kelompok model terbuka yang ringan dan canggih yang dibangun dari riset dan teknologi yang sama dengan yang digunakan untuk membuat model Gemini. Sangat cocok untuk berbagai tugas pembuatan teks, termasuk menjawab pertanyaan, perangkuman, dan penalaran.
- Phi-2: Model Transformer parameter 2,7 miliar, paling cocok untuk format Tanya Jawab, chat, dan kode.
- Falcon-RW-1B: 1 miliar model khusus dekoder kausal parameter dilatih dengan 350 miliar token RefinedWeb.
- StableLM-3B: 3 miliar model bahasa khusus decoder parameter yang telah dilatih sebelumnya dengan 1 triliun token dari beragam set data kode dan bahasa Inggris.
Atau, Anda dapat menggunakan model yang dipetakan dan diekspor melalui AI Edge Troch.
Sebaiknya gunakan Gemma 2B, yang tersedia di Model Kaggle dan tersedia dalam format yang sudah kompatibel dengan LLM Inference API. Jika menggunakan LLM lain, Anda harus mengonversi model ke format yang cocok untuk MediaPipe. Untuk mengetahui informasi selengkapnya tentang Gemma 2B, lihat situs Gemma. Untuk mengetahui informasi selengkapnya tentang model lain yang tersedia, lihat bagian Model ringkasan tugas.
Mengonversi model ke format MediaPipe
Konversi model native
Jika Anda menggunakan LLM eksternal (Phi-2, Falcon, atau StableLM) atau Gemma versi non-Kaggle, gunakan skrip konversi kami untuk memformat model agar kompatibel dengan MediaPipe.
Proses konversi model memerlukan paket MediaPipe PyPI. Skrip konversi
tersedia di semua paket MediaPipe setelah 0.10.11
.
Instal dan impor dependensi dengan kode 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 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.
Parameter | Deskripsi | Nilai yang Diterima |
---|---|---|
input_ckpt |
Jalur ke file model.safetensors atau pytorch.bin . Perlu diketahui bahwa terkadang format safetensor model di-sharding menjadi beberapa file, misalnya model-00001-of-00003.safetensors , model-00001-of-00003.safetensors . Anda dapat menentukan pola file, seperti model*.safetensors . |
PATH |
ckpt_format |
Format file model. | {"safetensors", "pytorch"} |
model_type |
LLM yang sedang dikonversi. | {"PHI_2", "FALCON_RW_1B", "STABLELM_4E1T_3B", "GEMMA_2B"} |
backend |
Prosesor (delegasi) yang digunakan untuk menjalankan model. | {"cpu", "gpu"} |
output_dir |
Jalur ke direktori output yang menghosting file bobot per lapisan. | PATH |
output_tflite_file |
Jalur ke file output. Misalnya, "model_cpu.bin" atau "model_gpu.bin". File ini hanya kompatibel dengan LLM Inference API dan tidak dapat digunakan sebagai file `tflite` umum. | PATH |
vocab_model_file |
Jalur ke direktori yang menyimpan file tokenizer.json dan
tokenizer_config.json . Untuk Gemma, arahkan kursor ke satu file tokenizer.model . |
PATH |
lora_ckpt |
Jalur ke ckpt LoRA dari file safetensors yang menyimpan bobot adaptor LoRA. | PATH |
lora_rank |
Bilangan bulat yang menunjukkan peringkat LoRA ckpt. Diperlukan untuk mengonversi bobot lora. Jika tidak diberikan, pengonversi mengasumsikan tidak ada bobot LoRA. Catatan: Hanya backend GPU yang mendukung LoRA. | Bilangan bulat |
lora_output_tflite_file |
Nama file tflite output untuk bobot LoRA. | PATH |
Konversi model Edge AI
Jika Anda menggunakan LLM yang dipetakan ke model TFLite melalui AI Edge, gunakan skrip bundling kami untuk membuat Task Bundle. Proses pemaketan mengemas model yang dipetakan dengan metadata tambahan (misalnya Parameter Tokenizer) yang diperlukan untuk menjalankan inferensi end-to-end.
Proses pemaketan model memerlukan paket MediaPipe PyPI. Skrip konversi
tersedia di semua paket MediaPipe setelah 0.10.14
.
Instal dan impor dependensi dengan kode 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)
Parameter | Deskripsi | Nilai yang Diterima |
---|---|---|
tflite_model |
Jalur ke AI Edge mengekspor model TFLite. | PATH |
tokenizer_model |
Jalur ke model tokenizer SentencePiece. | PATH |
start_token |
Token awal khusus model. Token awal harus ada dalam model tokenizer yang disediakan. | STRING |
stop_tokens |
Membuat model token perhentian khusus. Token perhentian harus ada dalam model tokenizer yang disediakan. | DAFTAR[STRING] |
output_filename |
Nama file paket tugas output. | PATH |
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:
Nama Opsi | Deskripsi | Rentang Nilai | Nilai Default |
---|---|---|---|
modelPath |
Jalur ke tempat model disimpan dalam direktori project. | PATH | T/A |
maxTokens |
Jumlah maksimum token (token input + token output) yang ditangani model. | Bilangan bulat | 512 |
topK |
Jumlah token yang dipertimbangkan model pada setiap langkah pembuatan.
Membatasi prediksi ke token k teratas yang paling mungkin. Saat menetapkan
topK , Anda juga harus menetapkan nilai untuk
randomSeed . |
Bilangan bulat | 40 |
temperature |
Jumlah keacakan yang diperkenalkan selama pembuatan. Suhu yang lebih tinggi menghasilkan lebih banyak kreativitas pada teks yang dihasilkan, sedangkan suhu yang lebih rendah menghasilkan pembuatan teks yang lebih dapat diprediksi. Saat menetapkan
temperature , Anda juga harus menetapkan nilai untuk
randomSeed . |
Float | 0,8 |
randomSeed |
Seed acak yang digunakan selama pembuatan teks. | Bilangan bulat | 0 |
loraPath |
Jalur absolut ke model LoRA secara lokal di perangkat. Catatan: ini hanya kompatibel dengan model GPU. | PATH | T/A |
resultListener |
Menetapkan pemroses hasil untuk menerima hasil secara asinkron. Hanya berlaku saat menggunakan metode pembuatan asinkron. | T/A | T/A |
errorListener |
Menetapkan pemroses error opsional. | T/A | T/A |
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
). Cara ini akan menghasilkan respons
tunggal 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 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 model Gemma-2B dan Phi-2 untuk backend GPU, dengan bobot LoRA yang hanya berlaku untuk lapisan atensi. Implementasi awal ini berfungsi sebagai API eksperimental untuk pengembangan mendatang dengan rencana untuk mendukung lebih banyak model dan berbagai jenis lapisan dalam update mendatang.
Mempersiapkan model LoRA
Ikuti petunjuk di HuggingFace untuk melatih model LoRA yang telah disesuaikan dengan baik di set data Anda 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 pada lapisan atensi, hanya tentukan lapisan atensi saat membuat LoraConfig
seperti 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 ditingkatkan 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 sudah 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 TensorFlow Lite Flatbuffer menggunakan Paket MediaPipe Python. 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 mengalihkan berbagai model LoRA selama runtime. Android dan iOS mendukung LoRA statis, yang menggunakan bobot LoRA yang sama selama masa aktif tugas.
Android mendukung LoRA statis selama inisialisasi. Untuk memuat model LoRA, pengguna menentukan jalur model LoRA serta LLM dasar.// 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.