Mengoptimalkan Penerapan LLM: vLLM PagedAttention dan Masa Depan Pelayanan AI yang Efisien

Model Bahasa Besar (LLM) yang diterapkan pada aplikasi dunia nyata menimbulkan tantangan unik, terutama dalam hal sumber daya komputasi, latensi, dan efisiensi biaya. Dalam panduan komprehensif ini, kita akan menjelajahi lanskap pelayanan LLM, dengan fokus khusus pada vLLM (model bahasa vektor), solusi yang mengubah cara kita menerapkan dan berinteraksi dengan model-model ini.

Tantangan Pelayanan Model Bahasa Besar

Sebelum kita memasuki solusi spesifik, mari kita lihat tantangan utama yang membuat pelayanan LLM menjadi tugas yang kompleks:

Sumber Daya Komputasi

LLM terkenal karena jumlah parameter yang sangat besar, mulai dari miliaran hingga ratusan miliar. Misalnya, GPT-3 memiliki 175 miliar parameter, sedangkan model yang lebih baru seperti GPT-4 diperkirakan memiliki lebih banyak lagi. Ukuran yang sangat besar ini berarti persyaratan komputasi yang signifikan untuk inferensi.

Contoh:
Bayangkan sebuah LLM yang relatif sederhana dengan 13 miliar parameter, seperti LLaMA-13B. Bahkan model ini memerlukan:

– Sekitar 26 GB memori hanya untuk menyimpan parameter model (dengan asumsi presisi 16-bit)
– Memori tambahan untuk aktivasi, mekanisme perhatian, dan komputasi antara
– Daya komputasi GPU yang substansial untuk inferensi waktu nyata

Latensi

Dalam banyak aplikasi, seperti chatbot atau generasi konten waktu nyata, latensi yang rendah sangat penting untuk pengalaman pengguna yang baik. Namun, kompleksitas LLM dapat menyebabkan waktu pemrosesan yang signifikan, terutama untuk urutan yang lebih panjang.

Contoh:
Bayangkan sebuah chatbot layanan pelanggan yang ditenagai oleh LLM. Jika setiap respons membutuhkan beberapa detik untuk dibuat, percakapan akan terasa tidak alami dan frustrasi bagi pengguna.

Biaya

Perangkat keras yang diperlukan untuk menjalankan LLM pada skala besar dapat sangat mahal. GPU atau TPU kelas atas sering diperlukan, dan konsumsi energi sistem ini sangat besar.

Contoh:
Menjalankan klaster NVIDIA A100 GPU (sering digunakan untuk inferensi LLM) dapat menghabiskan ribuan dolar per hari dalam biaya komputasi awan.

Pendekatan Tradisional untuk Pelayanan LLM

Sebelum kita menjelajahi solusi yang lebih maju, mari kita tinjau beberapa pendekatan tradisional untuk melayani LLM:

Penerapan Sederhana dengan Hugging Transformers

Perpustakaan Hugging Face Transformers menyediakan cara yang sederhana untuk menerapkan LLM, tetapi tidak dioptimalkan untuk pelayanan dengan throughput tinggi.

Contoh kode:

“`python
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_name = “meta-llama/Llama-2-13b-hf”
model = AutoModelForCausalLM.from_pretrained(model_name, device_map=”auto”)
tokenizer = AutoTokenizer.from_pretrained(model_name)

def generate_text(prompt, max_length=100):
inputs = tokenizer(prompt, return_tensors=”pt”).to(model.device)
outputs = model.generate(**inputs, max_length=max_length)
return tokenizer.decode(outputs[0], skip_special_tokens=True)

print(generate_text(“Masa depan AI adalah”))
“`

Meskipun pendekatan ini bekerja, tidak cocok untuk aplikasi dengan lalu lintas tinggi karena penggunaan sumber daya yang tidak efisien dan kurangnya optimasi untuk pelayanan.

Menggunakan TorchServe atau Kerangka Kerja Serupa

Kerangka kerja seperti TorchServe menyediakan kemampuan pelayanan yang lebih kuat, termasuk load balancing dan versi model. Namun, mereka masih tidak menangani tantangan spesifik pelayanan LLM, seperti manajemen memori yang efisien untuk model besar.

Memahami Manajemen Memori dalam Pelayanan LLM

Manajemen memori yang efisien sangat penting untuk melayani model bahasa besar (LLM) karena sumber daya komputasi yang luas yang diperlukan. Gambar-gambar berikut mengilustrasikan berbagai aspek manajemen memori, yang integral untuk mengoptimalkan kinerja LLM.

Memori Segmen vs. Memori Berhalaman

Manajemen Memori dalam OS vs. vLLM

 

Manajemen Memori dalam OS vs. vLLM

Gambar-gambar ini membandingkan teknik manajemen memori segmen dan memori berhalaman, yang umum digunakan dalam sistem operasi (OS).

• Memori Segmen: Teknik ini membagi memori menjadi segmen yang berbeda, masing-masing sesuai dengan program atau proses yang berbeda. Dalam konteks pelayanan LLM, segmen yang berbeda mungkin dialokasikan untuk komponen model yang berbeda, seperti tokenisasi, embedding, dan mekanisme perhatian. Setiap segmen dapat tumbuh atau menyusut secara independen, memberikan fleksibilitas tetapi potensial menyebabkan fragmentasi jika segmen tidak dikelola dengan baik.
• Memori Berhalaman: Di sini, memori dibagi menjadi halaman dengan ukuran tetap, yang dipetakan ke memori fisik. Halaman dapat dipertukarkan masuk dan keluar sesuai kebutuhan, memungkinkan penggunaan memori yang efisien. Dalam pelayanan LLM, ini dapat sangat penting untuk mengelola jumlah memori yang besar yang diperlukan untuk menyimpan bobot model dan komputasi antara.

Manajemen Memori dalam OS vs. vLLM

Gambar ini membandingkan manajemen memori tradisional dalam OS dengan pendekatan manajemen memori yang digunakan dalam vLLM.

• Manajemen Memori OS: Dalam sistem operasi tradisional, proses (misalnya, Proses A dan Proses B) dialokasikan halaman memori (Halaman 0, Halaman 1, dll.) dalam memori fisik. Alokasi ini dapat menyebabkan fragmentasi seiring waktu karena proses meminta dan melepaskan memori.
• Manajemen Memori vLLM: Kerangka kerja vLLM menggunakan cache Key-Value (KV) untuk mengelola memori lebih efisien. Permintaan (misalnya, Permintaan A dan Permintaan B) dialokasikan blok cache KV (Blok KV 0, Blok KV 1, dll.). Pendekatan ini membantu meminimalkan fragmentasi dan mengoptimalkan penggunaan memori, memungkinkan pelayanan model yang lebih cepat dan efisien.

Mekanisme Perhatian dalam LLM

Mekanisme Perhatian dalam LLM

Mekanisme perhatian adalah komponen fundamental dari model transformer, yang umum digunakan untuk LLM. Gambar ini mengilustrasikan rumus perhatian dan komponennya:

• Query (Q): Token baru dalam langkah decoder atau token terakhir yang dilihat oleh model.
• Kunci (K): Konteks sebelumnya yang harus diperhatikan oleh model.
• Nilai (V): Jumlah bobot atas konteks sebelumnya.

Rumus menghitung skor perhatian dengan mengambil produk dot antara query dengan kunci, mengalikan dengan akar kuadrat dari dimensi kunci, menerapkan fungsi softmax, dan akhirnya mengambil produk dot dengan nilai. Proses ini memungkinkan model untuk fokus pada bagian relevan dari urutan input saat menghasilkan setiap token.

Perbandingan Throughput Pelayanan

vLLM: Pelayanan LLM yang Mudah, Cepat, dan Murah dengan PagedAttention

Gambar ini mempresentasikan perbandingan throughput pelayanan antara kerangka kerja yang berbeda (HF, TGI, dan vLLM) menggunakan model LLaMA pada konfigurasi perangkat keras yang berbeda.

• LLaMA-13B, A100-40GB: vLLM mencapai throughput 14x – 24x lebih tinggi daripada Hugging Face Transformers (HF) dan 2,2x – 2,5x lebih tinggi daripada Hugging Face Text Generation Inference (TGI).
• LLaMA-7B, A10G: Trend yang sama diamati, dengan vLLM secara signifikan outperforming baik HF dan TGI.

vLLM: Arsitektur Pelayanan LLM Baru

vLLM, yang dikembangkan oleh peneliti di UC Berkeley, mewakili lompatan besar dalam teknologi pelayanan LLM. Mari kita jelajahi fitur dan inovasi utamanya:

PagedAttention

Di jantung vLLM terletak PagedAttention, algoritma perhatian baru yang terinspirasi oleh manajemen memori virtual dalam sistem operasi. Berikut adalah cara kerjanya:

– Partisi Cache Key-Value (KV): Alih-alih menyimpan cache KV secara kontinu dalam memori, PagedAttention membaginya menjadi blok dengan ukuran tetap.
– Penyimpanan Non-Kontinu: Blok-blok ini dapat disimpan non-kontinu dalam memori, memungkinkan manajemen memori yang lebih fleksibel.
– Alokasi On-Demand: Blok hanya dialokasikan ketika diperlukan, mengurangi pemborosan memori.
– Berbagi Efisien: Beberapa urutan dapat berbagi blok, memungkinkan optimasi untuk teknik seperti sampling paralel dan beam search.

Ilustrasi:

“`python
Cache KV Tradisional:
[Token 1 KV][Token 2 KV][Token 3 KV]…[Token N KV]
(Alokasi memori kontinu)

Cache KV PagedAttention:
[Blok 1] -> Alamat Fisik A
[Blok 2] -> Alamat Fisik C
[Blok 3] -> Alamat Fisik B
…
(Alokasi memori non-kontinu)
“`

Pendekatan ini secara signifikan mengurangi fragmentasi memori dan memungkinkan penggunaan memori GPU yang jauh lebih efisien.

Pengolahan Batch Kontinu

vLLM menerapkan pengolahan batch kontinu, yang secara dinamis memproses permintaan seiring dengan kedatangannya, bukan menunggu untuk membentuk batch dengan ukuran tetap. Ini menghasilkan latensi yang lebih rendah dan throughput yang lebih tinggi.

Contoh:
Bayangkan aliran permintaan masuk:

“`python
Waktu 0ms: Permintaan A tiba
Waktu 10ms: Mulai memproses Permintaan A
Waktu 15ms: Permintaan B tiba
Waktu 20ms: Mulai memproses Permintaan B (bersamaan dengan A)
Waktu 25ms: Permintaan C tiba
…
“`

Dengan pengolahan batch kontinu, vLLM dapat memulai pengolahan setiap permintaan segera, bukan menunggu untuk mengelompokkan mereka ke dalam batch dengan ukuran tetap.

Sampling Paralel yang Efisien

Untuk aplikasi yang memerlukan beberapa contoh output per prompt (misalnya, asisten penulisan kreatif), kemampuan berbagi memori vLLM sangat berguna. Ini dapat menghasilkan beberapa output sambil menggunakan kembali cache KV untuk awalan yang sama.

Contoh kode menggunakan vLLM:

“`python
from vllm import LLM, SamplingParams

llm = LLM(model=”meta-llama/Llama-2-13b-hf”)
prompts = [“Masa depan AI adalah”]

# Hasilkan 3 contoh per prompt
sampling_params = SamplingParams(n=3, temperature=0.8, max_tokens=100)
outputs = llm.generate(prompts, sampling_params)

for output in outputs:
print(f”Prompt: {output.prompt}”)
for i, out in enumerate(output.outputs):
print(f”Contoh {i + 1}: {out.text}”)
“`

Kode ini menghasilkan contoh yang efisien untuk prompt yang diberikan, menggunakan optimasi vLLM.

Benchmarking Kinerja vLLM

Untuk benar-benar menghargai dampak vLLM, mari kita lihat beberapa perbandingan kinerja:

Perbandingan Throughput

Berdasarkan informasi yang diberikan, vLLM secara signifikan outperforming solusi pelayanan lain:

– Hingga 24x throughput lebih tinggi dibandingkan dengan Hugging Face Transformers
– 2,2x – 3,5x throughput lebih tinggi daripada Hugging Face Text Generation Inference (TGI)

Ilustrasi:

“`
Throughput (Token/detik)
|
| ****
| ****
| ****
| **** ****
| **** **** ****
| **** **** ****
|————————
HF TGI vLLM
“`

Efisiensi Memori

PagedAttention vLLM menghasilkan penggunaan memori yang hampir optimal:

– Hanya sekitar 4% pemborosan memori, dibandingkan dengan 60-80% dalam sistem tradisional
– Efisiensi ini memungkinkan pelayanan model yang lebih besar atau penanganan permintaan paralel yang lebih banyak dengan perangkat keras yang sama

Menggunakan vLLM

Sekarang bahwa kita telah menjelajahi manfaat vLLM, mari kita jalankan proses pengaturan dan penggunaannya dalam proyek Anda.

6.1 Instalasi

Menginstal vLLM sangat mudah menggunakan pip:

“`python
!pip install vllm
“`

6.2 Penggunaan Dasar untuk Inferensi Offline

Berikut adalah contoh sederhana menggunakan vLLM untuk generasi teks offline:

“`python
from vllm import LLM, SamplingParams

# Inisialisasi model
llm = LLM(model=”meta-llama/Llama-2-13b-hf”)

# Siapkan prompt
prompts = [
“Tulis puisi pendek tentang kecerdasan buatan:”,
“Jelaskan komputasi kuantum dalam bahasa sederhana:”
]

# Tetapkan parameter sampling
sampling_params = SamplingParams(temperature=0.8, max_tokens=100)

# Hasilkan respons
outputs = llm.generate(prompts, sampling_params)

# Cetak hasil
for output in outputs:
print(f”Prompt: {output.prompt}”)
print(f”Tekst yang dihasilkan: {output.outputs[0].text}\n”)
“`

Skrip ini menunjukkan cara memuat model, menetapkan parameter sampling, dan menghasilkan teks untuk beberapa prompt.

6.3 Mengatur Server vLLM

Untuk pelayanan online, vLLM menyediakan server API yang kompatibel dengan OpenAI. Berikut adalah cara mengatur server:

1. Mulai server:

“`bash
python -m vllm.entrypoints.openai.api_server –model meta-llama/Llama-2-13b-hf
“`

2. Query server menggunakan curl:

“`bash
curl http://localhost:8000/v1/completions \
-H “Content-Type: application/json” \
-d ‘{“model”: “meta-llama/Llama-2-13b-hf”, “prompt”: “Masa depan AI adalah”, “max_tokens”: 100, “temperature”: 0.7}’
“`

Pengaturan ini memungkinkan Anda untuk melayani LLM dengan antarmuka yang kompatibel dengan API OpenAI, membuatnya mudah untuk mengintegrasikan ke dalam aplikasi yang ada.

Topik Lanjutan tentang vLLM

Meskipun vLLM menawarkan perbaikan signifikan dalam pelayanan LLM, ada pertimbangan dan topik lanjutan yang perlu dijelajahi:

7.1 Kuantisasi Model

Untuk pelayanan yang lebih efisien, terutama pada perangkat keras dengan memori terbatas, teknik kuantisasi dapat digunakan. Meskipun vLLM sendiri tidak mendukung kuantisasi, dapat digunakan bersama dengan model yang dikuantisasi:

“`python
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# Muat model yang dikuantisasi
model_name = “meta-llama/Llama-2-13b-hf”
model = AutoModelForCausalLM.from_pretrained(model_name, device_map=”auto”, load_in_8bit=True)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Gunakan model yang dikuantisasi dengan vLLM
from vllm import LLM

llm = LLM(model=model, tokenizer=tokenizer)
“`

7.2 Inferensi Terdistribusi

Untuk model yang sangat besar atau aplikasi dengan lalu lintas tinggi, inferensi terdistribusi di seluruh beberapa GPU atau mesin mungkin diperlukan. Meskipun vLLM tidak mendukung ini secara native, dapat diintegrasikan ke dalam sistem terdistribusi menggunakan kerangka kerja seperti Ray:

“`python
import ray
from vllm import LLM

@ray.remote(num_gpus=1)
class DistributedLLM:
def __init__(self, model_name):
self.llm = LLM(model=model_name)

def generate(self, prompt, params):
return self.llm.generate(prompt, params)

# Inisialisasi LLM terdistribusi
llm1 = DistributedLLM.remote(“meta-llama/Llama-2-13b-hf”)
llm2 = DistributedLLM.remote(“meta-llama/Llama-2-13b-hf”)

# Gunakan mereka secara paralel
result1 = llm1.generate.remote(“Prompt 1”, sampling_params)
result2 = llm2.generate.remote(“Prompt 2”, sampling_params)

# Dapatkan hasil
print(ray.get([result1, result2]))
“`

7.3 Pemantauan dan Pengamatan

Ketika melayani LLM dalam produksi, pemantauan sangat penting. Meskipun vLLM tidak menyediakan pemantauan bawaan, Anda dapat mengintegrasikannya dengan alat seperti Prometheus dan Grafana:

“`python
from prometheus_client import start_http_server, Summary
from vllm import LLM

# Definisi metrik
REQUEST_TIME = Summary(‘request_processing_seconds’, ‘Waktu yang dihabiskan untuk memproses permintaan’)

# Inisialisasi vLLM
llm = LLM(model=”meta-llama/Llama-2-13b-hf”)

# Expos metrik
start_http_server(8000)

# Gunakan model dengan pemantauan
@REQUEST_TIME.time()
def process_request(prompt):
return llm.generate(prompt)

# Loop pelayanan Anda di sini
“`

Pengaturan ini memungkinkan Anda untuk melacak metrik seperti waktu pemrosesan permintaan, yang dapat divisualisasikan dalam dasbor Grafana.

Kesimpulan

Melayani Model Bahasa Besar dengan efisien adalah tugas yang kompleks tetapi sangat penting dalam era AI. vLLM, dengan algoritma PagedAttention yang inovatif dan implementasi yang dioptimalkan, mewakili langkah besar dalam membuat penerapan LLM lebih mudah diakses dan efisien biaya.

Dengan meningkatkan throughput secara dramatis, mengurangi pemborosan memori, dan memungkinkan opsi pelayanan yang lebih fleksibel, vLLM membuka kemungkinan baru untuk mengintegrasikan model bahasa yang kuat ke dalam berbagai aplikasi. Apakah Anda membangun chatbot, sistem generasi konten, atau aplikasi NLP lainnya, memahami dan menggunakan alat seperti vLLM akan menjadi kunci kesuksesan.