Apa itu vLLM? Cara Menginstal dan Menggunakan vLLM, Dijelaskan

Selamat datang di panduan komprehensif tentang vLLM! Jika Anda terlibat dalam dunia Large Language Models (LLMs), Anda mungkin telah menghadapi tantangan kecepatan inferensi dan throughput. Melayani model-model masif ini secara efisien bisa menjadi hambatan. Di sinilah vLLM hadir sebagai solusi yang mengubah permainan. Tutorial ini akan memandu Anda melalui semua yang perlu Anda ketahui sebagai pemula: apa itu vLLM, mengapa itu penting, cara menginstalnya, dan cara menggunakannya untuk pemrosesan batch offline dan layanan online.

Apa Sebenarnya vLLM Itu?

Intinya, vLLM adalah pustaka throughput tinggi dan hemat memori yang dirancang khusus untuk inferensi dan layanan Large Language Model (LLM). Dikembangkan oleh para peneliti dan insinyur yang bertujuan untuk mengatasi keterbatasan kinerja sistem layanan yang ada, vLLM secara signifikan mempercepat proses mendapatkan prediksi (inferensi) dari LLM.

Metode tradisional untuk inferensi LLM seringkali kesulitan mengelola jejak memori yang besar dari mekanisme perhatian model (khususnya, cache KV) dan secara efisien melakukan batching permintaan yang masuk. vLLM memperkenalkan teknik-teknik baru, terutama PagedAttention, untuk mengatasi tantangan ini secara langsung. Ini memungkinkan throughput yang jauh lebih tinggi (lebih banyak permintaan diproses per detik) dan dapat melayani model lebih cepat dan lebih hemat biaya dibandingkan dengan banyak implementasi Hugging Face Transformers standar atau kerangka kerja layanan lainnya saat menangani permintaan bersamaan.

Anggap vLLM sebagai mesin yang sangat dioptimalkan untuk menjalankan LLM yang telah dilatih sebelumnya. Anda menyediakan model dan prompt, dan vLLM menangani tugas kompleks menghasilkan teks dengan cepat dan efisien, baik untuk satu batch prompt besar atau untuk banyak pengguna simultan yang berinteraksi dengan model yang diterapkan.

Mengapa Memilih vLLM untuk Inferensi LLM?

Beberapa alasan kuat menjadikan vLLM pilihan yang disukai bagi pengembang dan organisasi yang bekerja dengan LLM:

1. Kinerja Mutakhir: vLLM memberikan throughput yang jauh lebih tinggi dibandingkan dengan banyak implementasi dasar. Ini berarti Anda dapat menangani lebih banyak permintaan pengguna secara bersamaan atau memproses dataset besar lebih cepat dengan perangkat keras yang sama.
2. Manajemen Memori yang Efisien: Inovasi inti, PagedAttention, secara drastis mengurangi pemborosan memori dengan mengelola cache KV secara lebih efektif. Ini memungkinkan Anda untuk memasukkan model yang lebih besar ke dalam GPU Anda atau melayani model yang ada dengan overhead memori yang lebih sedikit, yang berpotensi mengurangi biaya perangkat keras.
3. Batching Berkelanjutan: Tidak seperti batching statis (di mana server menunggu batch penuh sebelum memproses), vLLM menggunakan batching berkelanjutan. Ini memproses permintaan secara dinamis saat mereka tiba, secara signifikan meningkatkan pemanfaatan GPU dan mengurangi latensi untuk permintaan individu.
4. Server yang Kompatibel dengan OpenAI: vLLM menyertakan server bawaan yang meniru API OpenAI. Ini membuatnya sangat mudah untuk menggunakan vLLM sebagai pengganti langsung untuk aplikasi yang sudah dibuat menggunakan klien Python OpenAI atau alat yang kompatibel. Anda sering dapat mengganti URL endpoint dan kunci API Anda, dan kode Anda yang ada akan berfungsi dengan instance vLLM yang Anda host sendiri.
5. Kemudahan Penggunaan: Terlepas dari internalnya yang canggih, vLLM menawarkan API yang relatif sederhana untuk inferensi offline (kelas LLM) dan layanan online (perintah vllm serve).
6. Kompatibilitas Model yang Luas: vLLM mendukung berbagai macam LLM sumber terbuka populer yang tersedia di Hugging Face Hub (dan berpotensi ModelScope).
7. Pengembangan dan Komunitas Aktif: vLLM adalah proyek sumber terbuka yang dipelihara secara aktif dengan komunitas yang berkembang, memastikan peningkatan berkelanjutan, perbaikan bug, dan dukungan untuk model dan fitur baru.
8. Kernel yang Dioptimalkan: vLLM menggunakan kernel CUDA yang sangat dioptimalkan untuk berbagai operasi, yang selanjutnya meningkatkan kinerja pada GPU NVIDIA.

Jika kecepatan, efisiensi, dan skalabilitas sangat penting untuk aplikasi LLM Anda, vLLM adalah teknologi yang harus Anda pertimbangkan dengan serius.

Model Apa yang Didukung vLLM?

vLLM mendukung berbagai macam model berbasis transformer populer yang dihosting di Hugging Face Hub. Ini termasuk banyak varian dari:

• Llama (Llama, Llama 2, Llama 3)
• Mistral & Mixtral
• Qwen & Qwen2
• GPT-2, GPT-J, GPT-NeoX
• OPT
• Bloom
• Falcon
• MPT
• Dan banyak lainnya, termasuk model multi-modal.

Daftarnya terus bertambah. Untuk daftar model yang didukung secara resmi yang paling mutakhir dan komprehensif, selalu rujuk ke dokumentasi vLLM resmi:

Daftar Model yang Didukung vLLM

Jika suatu model tidak tercantum secara eksplisit, model tersebut mungkin masih berfungsi jika arsitekturnya mirip dengan yang didukung, tetapi kompatibilitas tidak dijamin tanpa dukungan atau pengujian resmi. Menambahkan arsitektur model baru biasanya memerlukan kontribusi kode ke proyek vLLM.

Beberapa Terminologi Kunci vLLM:

Meskipun vLLM mudah digunakan di permukaan, memahami beberapa konsep intinya membantu menghargai mengapa itu sangat efektif:

• PagedAttention: Ini adalah fitur unggulan vLLM. Dalam mekanisme perhatian tradisional, cache Key-Value (KV) (yang menyimpan hasil antara untuk generasi) memerlukan blok memori yang berdekatan. Ini menyebabkan fragmentasi dan pemborosan memori (internal dan eksternal). PagedAttention bekerja seperti memori virtual dalam sistem operasi. Ini membagi cache KV menjadi blok (halaman) yang tidak berdekatan, memungkinkan manajemen memori yang jauh lebih fleksibel dan efisien. Ini secara signifikan mengurangi overhead memori (hingga 90% dalam beberapa kasus yang dilaporkan oleh pengembang) dan memungkinkan fitur seperti awalan bersama tanpa duplikasi memori.
• Batching Berkelanjutan: Alih-alih menunggu sejumlah permintaan tetap tiba sebelum memulai komputasi (batching statis), batching berkelanjutan memungkinkan mesin vLLM untuk mulai memproses urutan baru segera setelah urutan lama selesai menghasilkan token dalam batch. Ini membuat GPU terus sibuk, memaksimalkan throughput dan mengurangi waktu tunggu rata-rata untuk permintaan.

Kedua teknik ini bekerja sama secara sinergis untuk memberikan karakteristik kinerja vLLM yang mengesankan.

Sebelum Memulai dengan vLLM, Anda Perlu Memeriksa:

Sebelum Anda dapat menginstal dan menjalankan vLLM, pastikan sistem Anda memenuhi persyaratan berikut:

1. Sistem Operasi: Linux adalah OS yang didukung utama. Meskipun upaya komunitas mungkin ada untuk OS lain (seperti WSL2 di Windows atau macOS), Linux memberikan pengalaman yang paling mudah dan didukung secara resmi.
2. Versi Python: vLLM membutuhkan Python 3.9, 3.10, 3.11, atau 3.12. Sangat disarankan untuk menggunakan lingkungan virtual untuk mengelola dependensi Python Anda.
3. GPU NVIDIA dengan CUDA: Untuk kinerja optimal dan akses ke fitur inti, Anda memerlukan GPU NVIDIA dengan kemampuan komputasi yang didukung oleh PyTorch dan toolkit CUDA yang diperlukan terinstal. vLLM sangat bergantung pada CUDA untuk kernel yang dioptimalkan. Meskipun inferensi hanya-CPU dan dukungan untuk akselerator lain (seperti GPU AMD atau AWS Inferentia/Trainium) tersedia atau sedang dalam pengembangan, jalur utama melibatkan perangkat keras NVIDIA. Periksa situs web PyTorch resmi untuk kompatibilitas CUDA dengan versi driver GPU spesifik Anda.
4. PyTorch: vLLM dibangun di atas PyTorch. Proses instalasi biasanya menangani penginstalan versi yang kompatibel, tetapi pastikan Anda memiliki penginstalan PyTorch yang berfungsi yang kompatibel dengan versi CUDA Anda jika Anda mengalami masalah.

Panduan Langkah demi Langkah untuk Menginstal vLLM

Cara yang disarankan untuk menginstal vLLM adalah dengan menggunakan pengelola paket di dalam lingkungan virtual. Ini mencegah konflik dengan proyek Python lainnya. Berikut adalah langkah-langkah menggunakan alat populer:

Menggunakan pip dengan vLLM

pip adalah penginstal paket Python standar.

Buat dan Aktifkan Lingkungan Virtual (Disarankan):

python -m venv vllm-env
source vllm-env/bin/activate
# On Windows use: vllm-env\\\\Scripts\\\\activate

Instal vLLM:

pip install vllm

Perintah ini akan mengunduh dan menginstal versi stabil terbaru dari vLLM dan dependensi intinya, termasuk versi PyTorch yang kompatibel untuk pengaturan CUDA yang terdeteksi (jika memungkinkan).

Menggunakan Conda dengan vLLM

Conda adalah lingkungan dan pengelola paket populer lainnya, terutama di komunitas ilmu data.

Buat dan Aktifkan Lingkungan Conda:

conda create -n vllm-env python=3.11 -y # Or use 3.9, 3.10, 3.12
conda activate vllm-env

Instal vLLM menggunakan pip di dalam Conda:Umumnya disarankan untuk menggunakan pip untuk menginstal vLLM bahkan di dalam lingkungan Conda untuk memastikan Anda mendapatkan build kompatibel terbaru dengan mudah.

pip install vllm

Anda mungkin perlu menginstal PyTorch secara terpisah melalui Conda terlebih dahulu jika Anda lebih suka mengelolanya dengan cara itu, memastikan kompatibilitas: conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia (sesuaikan versi CUDA sesuai kebutuhan). Kemudian jalankan pip install vllm.

Menggunakan uv dengan vLLM

uv adalah penginstal dan resolver paket Python yang lebih baru dan sangat cepat.

Instal uv (jika Anda belum melakukannya): Ikuti instruksi pada dokumentasi uv resmi.

Buat dan Aktifkan Lingkungan menggunakan uv:

uv venv vllm-env --python 3.12 --seed # Or use 3.9, 3.10, 3.11
source vllm-env/bin/activate
# On Windows use: vllm-env\\\\Scripts\\\\activate

Instal vLLM menggunakan uv:

uv pip install vllm

Memverifikasi Instalasi vLLM Anda

Setelah instalasi, Anda dapat dengan cepat memverifikasinya dengan mencoba mengimpor vLLM di interpreter Python atau menjalankan perintah dasar:

# Activate your virtual environment first (e.g., source vllm-env/bin/activate)
python -c "import vllm; print(vllm.__version__)"

Ini akan mencetak versi vLLM yang diinstal tanpa kesalahan.

Atau, coba perintah bantuan untuk server (memerlukan instalasi yang berhasil):

vllm --help

Melakukan Inferensi Batch Offline dengan vLLM

Inferensi batch offline mengacu pada pembuatan teks untuk daftar prompt input yang telah ditentukan sebelumnya sekaligus. Ini berguna untuk tugas-tugas seperti mengevaluasi model, menghasilkan respons untuk dataset, atau pra-menghitung hasil. vLLM membuat ini efisien menggunakan kelas LLM-nya.

Memahami Kelas LLM vLLM

Kelas vllm.LLM adalah titik masuk utama untuk inferensi offline. Anda menginisialisasinya dengan menentukan model yang ingin Anda gunakan.

from vllm import LLM

# Initialize the LLM engine with a model from Hugging Face Hub
# Make sure you have enough GPU memory for the chosen model!
# Example: Using a smaller model like OPT-125m
llm = LLM(model="facebook/opt-125m")

# Example: Using a larger model like Llama-3-8B-Instruct (requires significant GPU memory)
# llm = LLM(model="meta-llama/Meta-Llama-3-8B-Instruct")

print("vLLM engine initialized.")

Secara default, vLLM mengunduh model dari Hugging Face Hub. Jika model Anda dihosting di ModelScope, Anda perlu mengatur variabel lingkungan VLLM_USE_MODELSCOPE=1 sebelum menjalankan skrip Python Anda.

Mengonfigurasi Parameter Pengambilan Sampel vLLM

Untuk mengontrol bagaimana teks dihasilkan, Anda menggunakan kelas vllm.SamplingParams. Ini memungkinkan Anda untuk mengatur parameter seperti:

• temperature: Mengontrol keacakan. Nilai yang lebih rendah (misalnya, 0,2) membuat output lebih deterministik dan fokus; nilai yang lebih tinggi (misalnya, 0,8) meningkatkan keacakan.
• top_p (Pengambilan Sampel Nukleus): Hanya mempertimbangkan token yang paling mungkin yang probabilitas kumulatifnya melebihi top_p. Nilai umum adalah 0,95.
• top_k: Hanya mempertimbangkan top_k token yang paling mungkin di setiap langkah.
• max_tokens: Jumlah maksimum token yang akan dihasilkan untuk setiap prompt.
• stop: Daftar string yang, ketika dihasilkan, akan menghentikan proses pembuatan untuk prompt spesifik itu.

from vllm import SamplingParams

# Define sampling parameters
# If not specified, vLLM might use defaults from the model's generation_config.json
sampling_params = SamplingParams(
    temperature=0.7,
    top_p=0.9,
    max_tokens=100, # Limit the length of the generated text
    stop=["\\\\n", " Human:", " Assistant:"] # Stop generation if these tokens appear
)

print("Sampling parameters configured.")

Catatan Penting: Secara default, vLLM mencoba memuat dan menggunakan pengaturan dari file generation_config.json yang terkait dengan model di Hugging Face Hub. Jika Anda ingin mengabaikan ini dan menggunakan parameter pengambilan sampel default vLLM kecuali ditimpa oleh objek SamplingParams Anda, inisialisasi kelas LLM seperti ini: llm = LLM(model="...", generation_config="vllm"). Jika Anda memberikan objek SamplingParams ke metode generate, parameter tersebut akan selalu didahulukan daripada konfigurasi model dan default vLLM.

Menjalankan Pekerjaan Batch vLLM Pertama Anda

Sekarang, mari kita gabungkan objek LLM, SamplingParams, dan daftar prompt untuk menghasilkan teks.

from vllm import LLM, SamplingParams

# 1. Define your input prompts
prompts = [
    "The capital of France is",
    "Explain the theory of relativity in simple terms:",
    "Write a short poem about a rainy day:",
    "Translate 'Hello, world!' to German:",
]

# 2. Configure sampling parameters
sampling_params = SamplingParams(temperature=0.7, top_p=0.95, max_tokens=150)

# 3. Initialize the vLLM engine (use a model suitable for your hardware)
try:
    # Using a relatively small, capable model
    llm = LLM(model="mistralai/Mistral-7B-Instruct-v0.1")
    # Or for smaller GPUs:
    # llm = LLM(model="facebook/opt-1.3b")
    # llm = LLM(model="facebook/opt-125m")
except Exception as e:
    print(f"Error initializing LLM: {e}")
    print("Please ensure you have enough GPU memory and CUDA is set up correctly.")
    exit()

# 4. Generate text for the prompts
# The generate method takes the list of prompts and sampling parameters
print("Generating responses...")
outputs = llm.generate(prompts, sampling_params)
print("Generation complete.")

# 5. Print the results
# The output is a list of RequestOutput objects
for output in outputs:
    prompt = output.prompt
    generated_text = output.outputs[0].text # Get the text from the first generated sequence
    print("-" * 20)
    print(f"Prompt: {prompt!r}")
    print(f"Generated Text: {generated_text!r}")
    print("-" * 20)

Skrip ini menginisialisasi vLLM, mendefinisikan prompt dan parameter, menjalankan proses pembuatan secara efisien dalam batch, dan kemudian mencetak output untuk setiap prompt. Panggilan llm.generate() menangani kompleksitas batching dan eksekusi GPU secara internal.

Menyiapkan Server yang Kompatibel dengan OpenAI vLLM

Salah satu fitur vLLM yang paling kuat adalah kemampuannya untuk bertindak sebagai server backend berkinerja tinggi yang berbicara bahasa yang sama dengan API OpenAI. Ini memungkinkan Anda untuk dengan mudah menghosting model sumber terbuka Anda sendiri dan mengintegrasikannya ke dalam aplikasi yang dirancang untuk OpenAI.

Meluncurkan Server vLLM

Memulai server sangat mudah menggunakan perintah vllm serve di terminal Anda.

Aktifkan lingkungan virtual Anda tempat vLLM diinstal.

source vllm-env/bin/activate

Jalankan perintah vllm serve:Anda perlu menentukan model yang ingin Anda layani.

# Example using Mistral-7B-Instruct
vllm serve mistralai/Mistral-7B-Instruct-v0.1

# Example using a smaller model like Qwen2-1.5B-Instruct
# vllm serve Qwen/Qwen2-1.5B-Instruct

Perintah ini akan:

• Unduh model yang ditentukan (jika belum di-cache).
• Muat model ke GPU Anda.
• Mulai server web (menggunakan Uvicorn secara default).
• Dengarkan permintaan API yang masuk, biasanya di http://localhost:8000.

Opsi Umum:

• -model <model_name_or_path>: (Wajib) Model yang akan dilayani.
• -host <ip_address>: Alamat IP untuk mengikat server (misalnya, 0.0.0.0 untuk membuatnya dapat diakses di jaringan Anda). Defaultnya adalah localhost.
• -port <port_number>: Port untuk didengarkan. Defaultnya adalah 8000.
• -tensor-parallel-size <N>: Untuk layanan multi-GPU, membagi model di seluruh N GPU.
• -api-key <your_key>: Jika disetel, server akan mengharapkan kunci API ini di header Authorization: Bearer <your_key> dari permintaan yang masuk. Anda juga dapat mengatur variabel lingkungan VLLM_API_KEY.
• -generation-config vllm: Gunakan parameter pengambilan sampel default vLLM alih-alih generation_config.json model.
• -chat-template <path_to_template_file>: Gunakan file template obrolan Jinja khusus alih-alih yang ditentukan dalam konfigurasi tokenizer.

Server akan mengeluarkan log yang menunjukkan bahwa server berjalan dan siap menerima permintaan.

Berinteraksi dengan Server vLLM: API Penyelesaian

Setelah server berjalan, Anda dapat mengirim permintaan ke endpoint /v1/completions-nya, seperti yang Anda lakukan dengan API penyelesaian OpenAI yang lebih lama.

Menggunakan curl:

curl <http://localhost:8000/v1/completions> \\\\
    -H "Content-Type: application/json" \\\\
    -d '{
        "model": "mistralai/Mistral-7B-Instruct-v0.1",
        "prompt": "San Francisco is a city in",
        "max_tokens": 50,
        "temperature": 0.7
    }'

(Ganti "mistralai/Mistral-7B-Instruct-v0.1" dengan model sebenarnya yang Anda layani)

Menggunakan Pustaka Python openai:

from openai import OpenAI

# Point the client to your vLLM server endpoint
client = OpenAI(
    api_key="EMPTY", # Use "EMPTY" or your actual key if you set one with --api-key
    base_url="<http://localhost:8000/v1>"
)

print("Sending request to vLLM server (Completions)...")

try:
    completion = client.completions.create(
        model="mistralai/Mistral-7B-Instruct-v0.1", # Model name must match the one served
        prompt="Explain the benefits of using vLLM:",
        max_tokens=150,
        temperature=0.5
    )

    print("Response:")
    print(completion.choices[0].text)

except Exception as e:
    print(f"An error occurred: {e}")

(Ingatlah untuk mengganti nama model jika Anda melayani model yang berbeda)

Berinteraksi dengan Server vLLM: API Penyelesaian Obrolan

vLLM juga mendukung endpoint /v1/chat/completions yang lebih modern, cocok untuk model percakapan dan format pesan terstruktur (peran sistem, pengguna, asisten).

Menggunakan curl:

curl <http://localhost:8000/v1/chat/completions> \\\\
    -H "Content-Type: application/json" \\\\
    -d '{
        "model": "mistralai/Mistral-7B-Instruct-v0.1",
        "messages": [
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": "What is the main advantage of PagedAttention in vLLM?"}
        ],
        "max_tokens": 100,
        "temperature": 0.7
    }'

(Ganti nama model sesuai kebutuhan)

Menggunakan Pustaka Python openai:

from openai import OpenAI

# Point the client to your vLLM server endpoint
client = OpenAI(
    api_key="EMPTY", # Use "EMPTY" or your actual key
    base_url="<http://localhost:8000/v1>"
)

print("Sending request to vLLM server (Chat Completions)...")

try:
    chat_response = client.chat.completions.create(
        model="mistralai/Mistral-7B-Instruct-v0.1", # Model name must match the one served
        messages=[
            {"role": "system", "content": "You are a helpful programming assistant."},
            {"role": "user", "content": "Write a simple Python function to calculate factorial."}
        ],
        max_tokens=200,
        temperature=0.5
    )

    print("Response:")
    print(chat_response.choices[0].message.content)

except Exception as e:
    print(f"An error occurred: {e}")

(Ingatlah untuk mengganti nama model jika perlu)

Menggunakan server yang kompatibel dengan OpenAI adalah cara yang ampuh untuk menerapkan endpoint inferensi LLM berkinerja tinggi dengan perubahan minimal pada logika aplikasi Anda yang ada.

Mari Kita Bicara Tentang Backend Perhatian vLLM

vLLM menggunakan "backend" khusus untuk menghitung mekanisme perhatian secara efisien. Backend ini adalah implementasi yang dioptimalkan yang memanfaatkan pustaka atau teknik yang berbeda, terutama menargetkan GPU NVIDIA. Pilihan backend dapat memengaruhi kinerja dan penggunaan memori. Yang utama meliputi:

1. FlashAttention: Menggunakan pustaka FlashAttention (versi 1 dan 2). FlashAttention adalah algoritma perhatian yang sangat dioptimalkan yang secara signifikan mempercepat komputasi dan mengurangi penggunaan memori dengan menghindari kebutuhan untuk mewujudkan matriks perhatian perantara yang besar dalam Memori Bandwidth Tinggi (HBM) GPU. Ini seringkali merupakan opsi tercepat untuk banyak GPU modern (seperti arsitektur Ampere, Hopper) dan panjang urutan. vLLM biasanya menyertakan roda pra-bangun dengan dukungan FlashAttention.
2. Xformers: Memanfaatkan pustaka xFormers, yang dikembangkan oleh Meta AI. xFormers juga menyediakan implementasi perhatian yang hemat memori dan dioptimalkan (seperti MemoryEfficientAttention). Ini menawarkan kompatibilitas luas di berbagai arsitektur GPU dan dapat menjadi alternatif atau fallback yang baik jika FlashAttention tidak tersedia atau optimal untuk skenario tertentu. Instalasi standar vLLM seringkali menyertakan dukungan untuk xFormers.
3. FlashInfer: Opsi backend yang lebih baru yang memanfaatkan pustaka FlashInfer. FlashInfer menyediakan kernel yang sangat dioptimalkan yang secara khusus disesuaikan untuk menerapkan LLM, berfokus pada berbagai skenario pengisian awal dan dekode, termasuk fitur-fitur seperti dekode spekulatif dan penanganan efisien cache KV yang dipaginasi. Biasanya tidak ada roda vLLM pra-bangun yang berisi FlashInfer, yang berarti Anda harus menginstalnya secara terpisah di lingkungan Anda sebelum vLLM dapat menggunakannya. Lihat dokumentasi resmi FlashInfer atau Dockerfile vLLM untuk instruksi instalasi jika Anda berniat menggunakan backend ini.

Pemilihan Backend Otomatis:Secara default, vLLM secara otomatis mendeteksi backend perhatian yang paling sesuai dan berkinerja berdasarkan perangkat keras Anda (arsitektur GPU), pustaka yang diinstal (apakah FlashAttention/xFormers/FlashInfer tersedia?), dan model spesifik yang digunakan. Ini melakukan pemeriksaan untuk memastikan kompatibilitas dan bertujuan untuk memberikan kinerja terbaik di luar kotak tanpa konfigurasi manual.

Pemilihan Backend Manual:Dalam beberapa kasus penggunaan tingkat lanjut atau untuk tujuan benchmarking, Anda mungkin ingin memaksa vLLM untuk menggunakan backend tertentu. Anda dapat melakukan ini dengan mengatur variabel lingkungan VLLM_ATTENTION_BACKEND sebelum meluncurkan proses vLLM Anda (baik skrip offline atau server).

# Example: Force using FlashAttention (if installed and compatible)
export VLLM_ATTENTION_BACKEND=FLASH_ATTN
python your_offline_script.py
# or
# export VLLM_ATTENTION_BACKEND=FLASH_ATTN
# vllm serve your_model ...

# Example: Force using xFormers
export VLLM_ATTENTION_BACKEND=XFORMERS
python your_offline_script.py

# Example: Force using FlashInfer (requires prior installation)
export VLLM_ATTENTION_BACKEND=FLASHINFER
python your_offline_script.py

Untuk sebagian besar pemula, mengandalkan pemilihan backend otomatis vLLM direkomendasikan. Pengaturan backend secara manual biasanya dicadangkan untuk eksperimen atau pemecahan masalah masalah kinerja tertentu.

Memecahkan Masalah Umum Instalasi dan Penggunaan vLLM

Meskipun vLLM bertujuan untuk kemudahan penggunaan, Anda mungkin menghadapi beberapa rintangan umum, terutama selama penyiapan. Berikut adalah beberapa masalah yang sering terjadi dan solusi potensialnya:

1. Kesalahan CUDA Out of Memory (OOM):

• Masalah: Anda melihat kesalahan seperti torch.cuda.OutOfMemoryError: CUDA out of memory.
• Penyebab: LLM yang Anda coba muat membutuhkan lebih banyak GPU VRAM daripada yang tersedia di perangkat keras Anda. Model yang lebih besar (misalnya, 7B parameter ke atas) mengonsumsi memori yang signifikan.
• Solusi:
• Gunakan Model yang Lebih Kecil: Coba muat varian yang lebih kecil (misalnya, opt-1.3b, Qwen/Qwen2-1.5B-Instruct) terlebih dahulu untuk mengonfirmasi bahwa penyiapan Anda berfungsi.
• Kurangi Ukuran Batch (Server): Meskipun vLLM menangani batching secara dinamis, konkurensi yang sangat tinggi masih dapat melebihi memori. Pantau penggunaan.
• Gunakan Kuantisasi: Muat versi model yang dikuantisasi (misalnya, AWQ, GPTQ, GGUF - periksa dokumentasi vLLM untuk jenis kuantisasi yang didukung). Kuantisasi mengurangi jejak memori, seringkali dengan sedikit trade-off dalam akurasi. Contoh: llm = LLM(model="TheBloke/Mistral-7B-Instruct-v0.1-AWQ"). Perhatikan bahwa pustaka kuantisasi tertentu mungkin perlu diinstal.
• Paralelisme Tensor: Jika Anda memiliki beberapa GPU, gunakan argumen -tensor-parallel-size N saat meluncurkan server atau tensor_parallel_size=N saat menginisialisasi kelas LLM untuk mendistribusikan model di seluruh N GPU.
• Periksa Proses Lain: Pastikan tidak ada aplikasi lain yang mengonsumsi memori GPU yang signifikan. Gunakan nvidia-smi di terminal untuk memeriksa penggunaan memori.

1. Kesalahan Instalasi (Kompatibilitas CUDA/PyTorch):

• Masalah: pip install vllm gagal dengan kesalahan terkait CUDA, PyTorch, atau kompilasi ekstensi.
• Penyebab: Ketidakcocokan antara driver NVIDIA yang Anda instal, versi CUDA Toolkit, dan versi PyTorch yang coba diinstal atau digunakan oleh vLLM.
• Solusi:
• Periksa Kompatibilitas: Pastikan versi driver NVIDIA Anda mendukung versi CUDA Toolkit yang diperlukan oleh build PyTorch yang ingin Anda gunakan. Lihat matriks instalasi situs web PyTorch.
• Instal PyTorch Secara Manual: Terkadang, menginstal versi PyTorch yang kompatibel secara eksplisit sebelum menginstal vLLM membantu. Buka situs web resmi PyTorch, pilih OS Anda, pengelola paket (pip/conda), platform komputasi (versi CUDA), dan jalankan perintah yang disediakan. Kemudian, pip install vllm.
• Gunakan Gambar Docker Resmi: Pertimbangkan untuk menggunakan gambar Docker vLLM resmi. Mereka dilengkapi dengan versi CUDA, PyTorch, dan vLLM yang kompatibel, menghindari kerepotan instalasi lokal. Periksa Docker Hub untuk vllm/vllm-openai.
• Periksa Alat Build: Pastikan Anda telah menginstal alat build yang diperlukan (build-essential di Debian/Ubuntu, atau yang setara).

1. Kegagalan Pemuatan Model:

• Masalah: vLLM gagal memuat model yang ditentukan, mungkin dengan kesalahan "tidak ditemukan" atau masalah konfigurasi.
• Penyebab: Nama/jalur model salah, model memerlukan kode jarak jauh tepercaya, masalah format model, atau masalah jaringan yang mencegah pengunduhan.
• Solusi:
• Verifikasi Nama Model: Periksa kembali pengidentifikasi Hugging Face Hub yang tepat (misalnya, mistralai/Mistral-7B-Instruct-v0.1).
• Percayai Kode Jarak Jauh: Beberapa model memerlukan eksekusi kode khusus yang ditentukan dalam repositori mereka. Untuk kelas LLM, gunakan trust_remote_code=True. Untuk server, gunakan flag -trust-remote-code: vllm serve my_model --trust-remote-code. Hanya lakukan ini jika Anda mempercayai sumber model.
• Gunakan Jalur Lokal: Jika Anda telah mengunduh model secara lokal, berikan jalur ke direktori yang berisi file model dan konfigurasi tokenizer: llm = LLM(model="/path/to/local/model").
• Periksa Ruang Disk: Pastikan Anda memiliki cukup ruang disk untuk mengunduh bobot model (bisa puluhan GB).
• Masalah Jaringan: Periksa koneksi internet Anda. Jika berada di belakang proxy, konfigurasikan variabel lingkungan HTTP_PROXY dan HTTPS_PROXY.

1. Kinerja Lambat:

• Masalah: Kecepatan inferensi jauh lebih rendah dari yang diharapkan.
• Penyebab: Backend perhatian suboptimal dipilih,