Pelajari lebih lanjut pengumuman dari I/O Google AI Edge kami

Halaman ini diterjemahkan oleh Cloud Translation API.

Panduan Inferensi LLM untuk Web

LLM Inference API memungkinkan Anda menjalankan model bahasa besar (LLM) sepenuhnya di browser untuk aplikasi web, 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 web Anda.

Anda dapat melihat cara kerja tugas ini dengan demo MediaPipe Studio. Untuk mengetahui informasi selengkapnya tentang 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 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 membuat kode project secara khusus untuk menggunakan LLM Inference API. Guna mengetahui informasi umum tentang cara 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 mengetahui daftar lengkap browser yang kompatibel, lihat Kompatibilitas browser GPU.

Paket JavaScript

Kode LLM Inference API tersedia melalui paket @mediapipe/tasks-genai. Anda dapat menemukan dan mendownload library ini dari link yang disediakan di Panduan penyiapan platform.

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 Anda:

<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 ini. Untuk aplikasi web, model harus kompatibel dengan GPU.

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: Bagian dari kelompok 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, perangkuman, dan penalaran. Download varian model Gemma 2B atau Gemma 7B.
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.

Sebaiknya gunakan Gemma 2B atau Gemma 7B, 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 informasi selengkapnya tentang Gemma, 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

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 parameter modelAssetPath objek baseOptions:

baseOptions: { modelAssetPath: `/assets/gemma-2b-it-gpu-int4.bin`}

Membuat tugas

Gunakan salah satu fungsi createFrom...() LLM Inference API untuk menyiapkan tugas untuk menjalankan inferensi. Anda dapat menggunakan fungsi createFromModelPath() dengan jalur relatif atau absolut ke file model yang telah dilatih. Contoh kode menggunakan fungsi createFromOptions(). Untuk mengetahui informasi selengkapnya tentang opsi konfigurasi yang tersedia, 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.	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`.	Mengambang	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 pra-pemrosesan input data, termasuk tokenisasi dan pra-pemrosesan tensor.

Semua pra-pemrosesan ditangani dalam fungsi generateResponse(). Tidak perlu pemrosesan tambahan 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, hal ini berarti menampilkan kemungkinan kategori untuk teks input.

Kode berikut menunjukkan cara menjalankan pemrosesan dengan model tugas.

const response = await llmInference.generateResponse(inputPrompt);
document.getElementById('output').textContent = response;

Untuk melakukan streaming respons, gunakan:

llmInference.generateResponse(
  inputPrompt,
  (partialResult, done) => {
        document.getElementById('output').textContent += partialResult;
});

Menangani dan menampilkan hasil

LLM Inference API menampilkan string, 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.

Web mendukung LoRA dinamis selama runtime. Artinya, pengguna mendeklarasikan 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;
});