LLM Inference API memungkinkan Anda menjalankan model bahasa besar (LLM) sepenuhnya di {i>browser<i} untuk aplikasi web, yang dapat Anda gunakan untuk melakukan berbagai tugas-tugas lain, seperti membuat teks, mengambil informasi dalam 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 web Anda.
Anda dapat melihat cara kerja tugas ini dengan MediaPipe Studio demo. Untuk mengetahui informasi selengkapnya terkait kemampuan, model, dan opsi konfigurasi. tugas ini, lihat Ringkasan.
Contoh kode
Aplikasi contoh untuk LLM Inference API menyediakan implementasi dasar tugas ini dalam JavaScript sebagai referensi Anda. Anda dapat menggunakan aplikasi contoh ini untuk mendapatkan mulai membangun aplikasi pembuatan teks Anda sendiri.
Anda dapat mengakses aplikasi contoh LLM Inference API di GitHub.
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 MediaPipe Tasks, termasuk persyaratan versi platform, lihat Panduan penyiapan untuk Web.
Kompatibilitas browser
LLM Inference API memerlukan browser web dengan kompatibilitas WebGPU. Untuk daftar browser yang kompatibel, lihat browser GPU kompatibilitas yang berbeda.
Paket JavaScript
Kode LLM Inference API tersedia melalui
@mediapipe/tasks-genai
paket. Anda bisa menemukan dan mendownload library ini dari link yang disediakan dalam
Panduan penyiapan platform Google.
Instal paket yang diperlukan untuk staging lokal:
npm install @mediapipe/tasks-genai
Untuk men-deploy ke server, gunakan layanan jaringan penayangan konten (CDN) seperti jsDelivr untuk menambahkan kode langsung ke halaman HTML:
<head>
<script src="https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai/genai_bundle.cjs"
crossorigin="anonymous"></script>
</head>
Model
MediaPipe LLM Inference API memerlukan model terlatih yang kompatibel dengan tugas Anda. Untuk aplikasi web, modelnya harus kompatibel dengan GPU.
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: 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. Download varian model Gemma 2B atau Gemma 7B.
- 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.
Sebaiknya gunakan Gemma 2B atau Gemma 7B, yang tersedia di Kaggle Model dan hadir 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, lihat Situs Gemma. Untuk informasi selengkapnya tentang model lain 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.
Parameter | Deskripsi | Nilai yang Diterima |
---|---|---|
input_ckpt |
Jalur ke file model.safetensors atau pytorch.bin . Perhatikan bahwa terkadang format safetensor model dibagi menjadi beberapa file, misalnya model-00001-of-00003.safetensors , model-00001-of-00003.safetensors . Anda dapat menentukan pola file, seperti model*.safetensors . |
JALUR |
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. | JALUR |
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. | JALUR |
vocab_model_file |
Jalur ke direktori yang menyimpan tokenizer.json dan
tokenizer_config.json file. Untuk Gemma, arahkan kursor ke satu file tokenizer.model . |
JALUR |
lora_ckpt |
Jalur ke LoRA ckpt file safetensors yang menyimpan bobot adaptor LoRA. | JALUR |
lora_rank |
Bilangan bulat yang mewakili peringkat LoRA ckpt. Diperlukan untuk mengonversi bobot lora. Jika tidak diberikan, pengonversi akan berasumsi bahwa tidak ada bobot LoRA. Catatan: Hanya backend GPU yang mendukung LoRA. | Bilangan Bulat |
lora_output_tflite_file |
Output nama file tflite untuk bobot LoRA. | JALUR |
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)
Parameter | Deskripsi | Nilai yang Diterima |
---|---|---|
tflite_model |
Jalur ke AI Edge mengekspor model TFLite. | JALUR |
tokenizer_model |
Jalur ke model tokenizer SentencePiece. | JALUR |
start_token |
Token mulai spesifik per model. Token awal harus ada di model tokenizer yang disediakan. | STRING |
stop_tokens |
Token perhentian spesifik per model. Token perhentian harus ada dalam model tokenizer yang disediakan. | DAFTAR[STRING] |
output_filename |
Nama file paket tugas output. | JALUR |
Menambahkan model ke direktori project
Simpan model dalam direktori project Anda:
<dev-project-root>/assets/gemma-2b-it-gpu-int4.bin
Tentukan jalur model dengan objek baseOptions
modelAssetPath
:
baseOptions: { modelAssetPath: `/assets/gemma-2b-it-gpu-int4.bin`}
Membuat tugas
Gunakan salah satu fungsi createFrom...()
LLM Inference API untuk menyiapkan tugas
menjalankan inferensi. Anda dapat menggunakan fungsi createFromModelPath()
dengan
jalur relatif atau absolut ke file model terlatih. Contoh kode ini menggunakan
Fungsi createFromOptions()
. Untuk informasi selengkapnya tentang
opsi konfigurasi, lihat Opsi konfigurasi.
Kode berikut menunjukkan cara membangun dan mengonfigurasi tugas ini:
const genai = await FilesetResolver.forGenAiTasks(
// path/to/wasm/root
"https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai@latest/wasm"
);
llmInference = await LlmInference.createFromOptions(genai, {
baseOptions: {
modelAssetPath: '/assets/gemma-2b-it-gpu-int4.bin'
},
maxTokens: 1000,
topK: 40,
temperature: 0.8,
randomSeed: 101
});
Opsi konfigurasi
Tugas ini memiliki opsi konfigurasi berikut untuk aplikasi Web dan JavaScript:
Nama Opsi | Deskripsi | Rentang Nilai | Nilai Default |
---|---|---|---|
modelPath |
Jalur ke tempat model disimpan dalam direktori project. | JALUR | T/A |
maxTokens |
Jumlah maksimum token (token input + token output) yang ditangani model. | Bilangan Bulat | 512 |
topK |
Jumlah token yang dipertimbangkan model di setiap langkah pembuatan. Membatasi prediksi ke token top k yang paling mungkin. | Bilangan Bulat | 40 |
temperature |
Jumlah keacakan yang diperkenalkan selama pembuatan. Semakin tinggi temperatur akan menghasilkan lebih banyak kreativitas dalam teks yang dihasilkan, sementara suhu yang lebih rendah menghasilkan generasi yang lebih dapat diprediksi. | Float | 0,8 |
randomSeed |
Seed acak yang digunakan selama pembuatan teks. | Bilangan Bulat | 0 |
loraRanks |
Peringkat LoRA yang akan digunakan oleh model LoRA selama runtime. Catatan: ini hanya kompatibel dengan model GPU. | Array bilangan bulat | T/A |
Menyiapkan data
LLM Inference API menerima data teks (string
). Tugas ini menangani input data
pra-pemrosesan, termasuk tokenisasi dan pra-pemrosesan tensor.
Semua pra-pemrosesan ditangani dalam fungsi generateResponse()
. Ada
tidak perlu pra-pemrosesan teks input.
const inputPrompt = "Compose an email to remind Brett of lunch plans at noon on Saturday.";
Menjalankan tugas
LLM Inference API menggunakan fungsi generateResponse()
untuk memicu inferensi.
Untuk klasifikasi teks, berarti menampilkan kategori yang memungkinkan untuk
teks input.
Kode berikut menunjukkan cara menjalankan pemrosesan dengan tugas model transformer.
const response = await llmInference.generateResponse(inputPrompt);
document.getElementById('output').textContent = response;
Untuk men-streaming respons, gunakan hal berikut:
llmInference.generateResponse(
inputPrompt,
(partialResult, done) => {
document.getElementById('output').textContent += partialResult;
});
Menangani dan menampilkan hasil
LLM Inference API menampilkan string, yang berisi 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 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.
Web mendukung LoRA dinamis selama runtime. Artinya, pengguna menyatakan peringkat LoRA yang akan digunakan selama inisialisasi, dan dapat menukar model LoRA yang berbeda selama runtime.const genai = await FilesetResolver.forGenAiTasks(
// path/to/wasm/root
"https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai@latest/wasm"
);
const llmInference = await LlmInference.createFromOptions(genai, {
// options for the base model
...
// LoRA ranks to be used by the LoRA models during runtime
loraRanks: [4, 8, 16]
});
Selama runtime, setelah model dasar diinisialisasi, muat model LoRA yang akan digunakan. Selain itu, picu model LoRA dengan meneruskan referensi model LoRA saat menghasilkan respons LLM.
// Load several LoRA models. The returned LoRA model reference is used to specify
// which LoRA model to be used for inference.
loraModelRank4 = await llmInference.loadLoraModel(loraModelRank4Url);
loraModelRank8 = await llmInference.loadLoraModel(loraModelRank8Url);
// Specify LoRA model to be used during inference
llmInference.generateResponse(
inputPrompt,
loraModelRank4,
(partialResult, done) => {
document.getElementById('output').textContent += partialResult;
});