LLM Inference API memungkinkan Anda menjalankan model bahasa besar (LLM) sepenuhnya di perangkat, yang dapat digunakan untuk melakukan berbagai tugas, seperti menghasilkan 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 untuk aplikasi dan produk Anda.
Tugas ini mendukung Gemma 2B dan 7B, yang merupakan bagian dari sebuah kelompok model terbuka yang ringan dan canggih yang dibangun dari penelitian dan teknologi yang digunakan untuk membuat Gemini jaringan. Alat ini juga mendukung model eksternal berikut: Phi-2, Falcon-RW-1B dan StableLM-3B.
Selain model yang didukung secara native, pengguna dapat memetakan model menggunakan AI Edge dari Google penawaran (termasuk memetakan model PyTorch). Hal ini memungkinkan pengguna mengekspor model yang dipetakan menjadi multi-tanda tangan Model TensorFlow Lite, yang dipaketkan dengan parameter tokenizer untuk membuat Paket Tugas.
Mulai
Mulai gunakan tugas ini dengan mengikuti salah satu panduan implementasi berikut untuk platform target. Panduan khusus platform ini memandu Anda memahami implementasi tugas ini, dengan contoh kode yang menggunakan model yang tersedia dan opsi konfigurasi yang disarankan:
Web:
Android:
iOS
Detail tugas
Bagian ini menjelaskan kemampuan, input, output, dan konfigurasi opsi untuk tugas ini.
Fitur
LLM Inference API berisi fitur utama berikut:
- Pembuatan teks ke teks - Buat teks berdasarkan perintah teks input.
- Pemilihan LLM - Terapkan beberapa model untuk menyesuaikan aplikasi bagi kasus penggunaan tertentu. Anda juga dapat melatih ulang dan menerapkan bobot yang disesuaikan ke model transformer.
- Dukungan LoRA - Memperluas dan menyesuaikan kemampuan LLM dengan model LoRA dengan melatih semua {i>dataset<i} Anda, atau mengikuti LoRA bawaan dari komunitas open source (khusus model native).
Input tugas | Output tugas |
---|---|
LLM Inference API menerima input berikut:
|
LLM Inference API menghasilkan hasil berikut:
|
Opsi konfigurasi
Tugas ini memiliki opsi konfigurasi berikut:
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 |
loraPath |
Jalur absolut ke model LoRA secara lokal di perangkat. Catatan: ini hanya kompatibel dengan model GPU. | JALUR | 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 |
Model
LLM Inference API berisi dukungan bawaan untuk memisahkan teks ke teks berukuran besar yang dioptimalkan untuk berjalan di browser dan perangkat seluler. Ini model ringan dapat diunduh untuk menjalankan inferensi sepenuhnya di perangkat.
Sebelum menginisialisasi LLM Inference API, download salah satu model yang didukung dan menyimpan file dalam direktori project Anda.
Gemma 2 M
Gemma 2B adalah bagian dari keluarga model terbuka yang ringan dan canggih yang dibangun dari penelitian yang sama dan yang digunakan untuk membuat model Gemini. Tujuan berisi 2 miliar parameter dan bobot terbuka. Model ini sangat cocok untuk berbagai tugas pembuatan teks, termasuk menjawab pertanyaan, meringkas, dan penalaran.
Model Gemma 2B hadir dalam empat varian:
- gemma-2b-it-cpu-int4: Model 4-bit Gemma 2B dengan kompatibilitas CPU.
- gemma-2b-it-cpu-int8: Model 8-bit Gemma 2B dengan kompatibilitas CPU.
- gemma-2b-it-gpu-int4: Model 4-bit Gemma 2B dengan kompatibilitas GPU.
- gemma-2b-it-gpu-int8: Model 8-bit Gemma 2B dengan kompatibilitas GPU.
Anda juga dapat menyesuaikan model dan menambahkan bobot baru sebelum menambahkannya ke aplikasi. Sebagai Untuk mengetahui informasi selengkapnya tentang cara menyesuaikan dan menyesuaikan Gemma, lihat Menyesuaikan Gemma. Setelah mendownload Gemma dari Model Kaggle, model sudah dalam format yang sesuai untuk digunakan dengan MediaPipe.
Jika Anda mendownload Gemma 2B dari Hugging Wajah, Anda harus mengonversi model ke format yang cocok untuk MediaPipe. LLM Inference API mengharuskan file berikut untuk didownload dan dikonversi:
model-00001-of-00002.safetensors
model-00002-of-00002.safetensors
tokenizer.json
tokenizer_config.json
Gemma 7 M
Gemma 7B adalah model Gemma yang lebih besar dengan 7B parameter dan bobot terbuka. Modelnya lebih canggih untuk berbagai teks pembuatan tugas, termasuk menjawab pertanyaan, perangkuman, dan penalaran. Gemma 7B hanya didukung di Web.
Model Gemma 7B tersedia dalam satu varian:
- gemma-1.1-7b-it-gpu-int8: Model 8-bit Gemma 7B dengan kompatibilitas GPU.
Jika Anda mendownload Gemma 7B dari Hugging Face, Anda harus mengonversi model ke format yang sesuai untuk MediaPipe. Tujuan LLM Inference API memerlukan file berikut untuk didownload dan dikonversi:
model-00001-of-00004.safetensors
model-00002-of-00004.safetensors
model-00003-of-00004.safetensors
model-00004-of-00004.safetensors
tokenizer.json
tokenizer_config.json
Falcon 1 M
Falcon-1B adalah model khusus decoder kausal dengan 1 miliar parameter yang dilatih pada 350B token RefinedWeb.
LLM Inference API memerlukan file berikut untuk didownload dan disimpan secara lokal:
tokenizer.json
tokenizer_config.json
pytorch_model.bin
Setelah mengunduh file model Falcon, model siap dikonversi menjadi untuk format MediaPipe. Ikuti langkah-langkah di Mengonversi model ke MediaPipe format.
StabilLM 3B
StabilLM-3B adalah model bahasa khusus decoder berisi 3 miliar parameter yang telah dilatih sebelumnya 1 triliun token set data bahasa Inggris dan kode yang beragam untuk 4 epoch.
LLM Inference API memerlukan file berikut untuk didownload dan disimpan secara lokal:
tokenizer.json
tokenizer_config.json
model.safetensors
Setelah mendownload file model StabilM, model siap dikonversi ke format MediaPipe. Ikuti langkah-langkah di Mengonversi model ke MediaPipe format.
Phi-2
Phi-2 adalah model Transformer dengan 2,7 miliar parameter. Model ini dilatih menggunakan berbagai Teks sintetis NLP dan situs yang difilter. Model ini paling cocok untuk perintah menggunakan format Question-Answer, chat, dan kode.
LLM Inference API memerlukan file berikut untuk didownload dan disimpan secara lokal:
tokenizer.json
tokenizer_config.json
model-00001-of-00002.safetensors
model-00002-of-00002.safetensors
Setelah mengunduh file model Phi-2, model siap dikonversi menjadi untuk format MediaPipe. Ikuti langkah-langkah di Mengonversi model ke MediaPipe format.
Model yang Diekspor AI Edge
AI Edge adalah penawaran Google yang memungkinkan Anda mengonversi model yang dipetakan pengguna menjadi model TensorFlow Lite multi-tanda tangan. Untuk informasi lebih lanjut tentang pemetaan dan mengekspor model, kunjungi AI Edge Torch Halaman GitHub.
Setelah mengekspor model ke dalam format TFLite, model siap untuk dikonversi ke format MediaPipe. Untuk informasi selengkapnya, lihat Konversi model ke format MediaPipe.
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 |
Penyesuaian 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.
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 seperti model dasar.