Panduan Inferensi LLM

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

Coba sekarang!arrow_forward

Tugas ini menyediakan dukungan bawaan untuk berbagai LLM. Model yang dihosting di halaman Komunitas LiteRT tersedia dalam format yang kompatibel dengan MediaPipe dan tidak memerlukan langkah-langkah konversi atau kompilasi tambahan.

Anda dapat menggunakan AI Edge Torch untuk mengekspor model PyTorch ke dalam model LiteRT (tflite) multi-signature, yang dibundel dengan parameter tokenizer untuk membuat Task Bundle. Model yang dikonversi dengan AI Edge Torch kompatibel dengan LLM Inference API dan dapat berjalan di backend CPU, sehingga cocok untuk aplikasi Android dan iOS.

Mulai

Mulai gunakan tugas ini dengan mengikuti salah satu panduan penerapan berikut untuk platform target Anda. Panduan khusus platform ini akan memandu Anda melakukan penerapan dasar tugas ini, dengan contoh kode yang menggunakan model yang tersedia dan opsi konfigurasi yang direkomendasikan:

• Web:

  • Panduan
  • Contoh kode

• Android:

  • Panduan
  • Contoh kode

• iOS

  • Panduan
  • Contoh kode

Detail tugas

Bagian ini menjelaskan kemampuan, input, output, dan opsi konfigurasi tugas ini.

Fitur

LLM Inference API berisi fitur utama berikut:

1. Pembuatan teks-ke-teks - Membuat teks berdasarkan perintah teks input.
2. Pemilihan LLM - Terapkan beberapa model untuk menyesuaikan aplikasi dengan kasus penggunaan spesifik Anda. Anda juga dapat melatih ulang dan menerapkan bobot yang disesuaikan ke model.
3. Dukungan LoRA - Perluas dan sesuaikan kemampuan LLM dengan model LoRA baik dengan melatih semua set data Anda, atau menggunakan model LoRA siap pakai dari komunitas open source (tidak kompatibel dengan model yang dikonversi dengan AI Edge Torch Generative API).

Opsi konfigurasi

Tugas ini memiliki opsi konfigurasi berikut:

Model

LLM Inference API mendukung banyak model bahasa besar text-to-text, termasuk dukungan bawaan untuk beberapa model yang dioptimalkan untuk berjalan di browser dan perangkat seluler. Model ringan ini dapat digunakan untuk menjalankan inferensi sepenuhnya di perangkat.

Sebelum menginisialisasi LLM Inference API, download model dan simpan file dalam direktori project Anda. Anda dapat menggunakan model yang telah dikonversi sebelumnya dari repositori HuggingFace Komunitas LiteRT, atau mengonversi model ke format yang kompatibel dengan MediaPipe menggunakan AI Edge Torch Generative Converter.

Jika Anda belum memiliki LLM untuk digunakan dengan LLM Inference API, mulai dengan salah satu model berikut.

Gemma-3n

Gemma-3n E2B dan E4B adalah model terbaru dalam rangkaian model terbuka yang ringan dan canggih dari Gemma, yang dibangun dari riset dan teknologi yang sama dengan yang digunakan untuk membuat model Gemini. Model Gemma 3n dirancang untuk eksekusi yang efisien di perangkat dengan resource rendah. Model ini mampu menerima input multimodal, menangani input teks, gambar, dan audio, serta menghasilkan output teks.

Model Gemma 3n menggunakan teknologi aktivasi parameter selektif untuk mengurangi persyaratan resource. Teknik ini memungkinkan model beroperasi dengan ukuran efektif parameter 2B dan 4B, yang lebih rendah daripada jumlah total parameter yang dikandungnya

Download Gemma-3n E2B

Download Gemma-3n E4B

Model Gemma-3n E2B dan E4B dari HuggingFace tersedia dalam format .litertlm, dan siap digunakan dengan LLM Inference API untuk Android dan Web.

Gemma-3 1B

Gemma-3 1B adalah model paling ringan dalam rangkaian model open source yang ringan dan canggih dari Gemma, yang dibangun dari riset dan teknologi yang sama dengan yang digunakan untuk membuat model Gemini. Model ini berisi 1 miliar parameter dan bobot terbuka.

Download Gemma-3 1B

Model Gemma-3 1B dari HuggingFace tersedia dalam format .task/.litertlm, dan siap digunakan dengan LLM Inference API untuk aplikasi Android dan Web.

Saat menjalankan Gemma-3 1B dengan LLM Inference API, konfigurasi opsi berikut dengan tepat:

• preferredBackend: Gunakan opsi ini untuk memilih antara backend CPU atau GPU. Opsi ini hanya tersedia untuk Android.
• supportedLoraRanks: LLM Inference API tidak dapat dikonfigurasi untuk mendukung Low-Rank Adaptation (LoRA) dengan model Gemma-3 1B. Jangan gunakan opsi supportedLoraRanks atau loraRanks.
• maxTokens: Nilai untuk maxTokens harus cocok dengan ukuran konteks yang dibuat ke dalam model. Hal ini juga dapat disebut sebagai cache Key-Value (KV) atau panjang konteks.
• numResponses: Harus selalu 1. Opsi ini hanya tersedia untuk Web.

Saat menjalankan Gemma-3 1B di aplikasi web, inisialisasi dapat menyebabkan pemblokiran yang panjang di thread saat ini. Jika memungkinkan, selalu jalankan model dari thread pekerja.

Gemma-2 2B

Gemma-2 2B adalah varian 2B dari Gemma-2, dan berfungsi di semua platform.

Download Gemma-2 2B

Model ini berisi 2B parameter dan bobot terbuka. Gemma-2 2B dikenal dengan kemampuan penalaran canggih untuk model di kelasnya.

Konversi Model PyTorch

Model generatif PyTorch dapat dikonversi ke format yang kompatibel dengan MediaPipe menggunakan AI Edge Torch Generative API. Anda dapat menggunakan API untuk mengonversi model PyTorch menjadi model multi-signature LiteRT (TensorFlow Lite). Untuk mengetahui detail selengkapnya tentang pemetaan dan mengekspor model, buka halaman GitHub AI Edge Torch.

Mengonversi model PyTorch dengan AI Edge Torch Generative API melibatkan langkah-langkah berikut:

1. Download checkpoint model PyTorch.
2. Gunakan AI Edge Torch Generative API untuk membuat, mengonversi, dan menguantisasi model ke format file yang kompatibel dengan MediaPipe (.tflite).
3. Buat Task Bundle (.task/.litertlm) dari file tflite dan tokenizer model.

Konverter Generatif Torch hanya mengonversi untuk CPU dan memerlukan mesin Linux dengan RAM minimal 64 GB.

Untuk membuat Paket Tugas, gunakan skrip penggabungan untuk membuat Paket Tugas. Proses penggabungan mengemas model yang dipetakan dengan metadata tambahan (misalnya, Parameter Tokenizer) yang diperlukan untuk menjalankan inferensi end-to-end.

Proses penggabungan model memerlukan paket MediaPipe PyPI. Skrip konversi tersedia di semua paket MediaPipe setelah 0.10.14.

Instal dan impor dependensi dengan perintah 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)

Penyesuaian LoRA

Dukungan LoRA untuk LLM Inference API berfungsi untuk semua model Gemma dan Phi-2 untuk backend GPU, dengan bobot LoRA yang hanya berlaku untuk lapisan perhatian. Implementasi awal ini berfungsi sebagai API eksperimental untuk pengembangan di masa mendatang dengan rencana untuk mendukung lebih banyak model dan berbagai jenis lapisan dalam update mendatang.

Menyiapkan model LoRA

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

# For Gemma
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 di-fine-tune 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 telah disiapkan dan menyimpan model, Anda akan mendapatkan file adapter_model.safetensors yang berisi bobot model LoRA yang telah di-fine-tune. 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 disetel 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

Web, Android, dan iOS LLM Inference API diupdate untuk mendukung inferensi model LoRA.

// 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.