Panduan Inferensi LLM

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.

Cobalah!arrow_forward

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:

  • Panduan
  • Kode contoh

• Android:

  • Panduan
  • Kode contoh

• iOS

  • Panduan
  • Kode contoh

Detail tugas

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

Fitur

LLM Inference API berisi fitur utama berikut:

1. Pembuatan teks ke teks - Buat teks berdasarkan perintah teks input.
2. 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.
3. 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).

Opsi konfigurasi

Tugas ini memiliki opsi konfigurasi berikut:

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.

Unduh Gemma 2B

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.

Unduh Gemma 7B

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.

Unduh Falcon 1B

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.

Download StabilLM 3B

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.

Unduh Phi-2

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.

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)

Penyesuaian LoRA

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.

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