Tutorial LMDeploy: Toolkit Lengkap untuk Deploy dan Serving Large Language Model
Large Language Model (LLM) semakin banyak digunakan dalam berbagai aplikasi, mulai dari chatbot hingga asisten kode. Namun, tantangan utama dalam menggunakan LLM adalah kebutuhan resource GPU yang besar dan latensi inferensi yang tinggi. LMDeploy hadir sebagai solusi komprehensif untuk mengompresi, mendeploy, dan melayani LLM secara efisien.
LMDeploy dikembangkan oleh tim InternLM dari Shanghai AI Laboratory. Toolkit ini mendukung berbagai model populer seperti LLaMA, Qwen, Mistral, InternLM, dan banyak lainnya. Dengan engine TurboMind yang dioptimasi dan dukungan kuantisasi W4A16/W8A8, LMDeploy memungkinkan Anda menjalankan model besar dengan resource yang lebih sedikit tanpa mengorbankan kualitas output secara signifikan.
Dalam tutorial ini, kita akan membahas cara instalasi, penggunaan dasar, kuantisasi model, serving via API, dan best practices untuk production deployment.
Instalasi
Prasyarat
Sebelum menginstal LMDeploy, pastikan Anda memiliki:
- Python 3.8 atau lebih baru
- CUDA 11.8 atau 12.x (untuk akselerasi GPU)
- GPU NVIDIA dengan minimal 8GB VRAM (untuk model 7B terkuantisasi)
Instalasi via pip
Cara termudah untuk menginstal LMDeploy adalah menggunakan pip:
pip install lmdeploy
Untuk instalasi dengan dukungan CUDA spesifik:
# Untuk CUDA 12.x
pip install lmdeploy
Untuk CUDA 11.8
pip install lmdeploy --extra-index-url https://download.pytorch.org/whl/cu118
Verifikasi Instalasi
Setelah instalasi selesai, verifikasi dengan menjalankan:
import lmdeploy
print(lmdeploy.version)
Atau melalui command line:
lmdeploy version
Instalasi dari Source (Opsional)
Jika Anda membutuhkan fitur terbaru dari branch development:
git clone https://github.com/InternLM/lmdeploy.git
cd lmdeploy
pip install -e .
Penggunaan Dasar
Chat Interaktif via Command Line
Cara paling cepat untuk mencoba LMDeploy adalah menggunakan mode chat interaktif:
lmdeploy chat internlm/internlm25-7b-chat
Perintah ini akan mengunduh model dari Hugging Face (jika belum ada) dan memulai sesi chat interaktif di terminal. Anda bisa langsung mengetikkan pertanyaan dan mendapatkan respons dari model.
Untuk menggunakan model dari path lokal:
lmdeploy chat /path/to/your/model
Menggunakan Pipeline API di Python
Untuk integrasi ke dalam aplikasi Python, LMDeploy menyediakan Pipeline API yang sederhana:
from lmdeploy import pipeline
Inisialisasi pipeline
pipe = pipeline("internlm/internlm25-7b-chat")
Inferensi single prompt
response = pipe(["Jelaskan apa itu machine learning dalam 3 kalimat"])
print(response[0].text)
Batch Inferensi
Salah satu keunggulan LMDeploy adalah kemampuan batch processing yang efisien:
from lmdeploy import pipeline
pipe = pipeline("internlm/internlm25-7b-chat")
prompts = [
"Apa itu neural network?",
"Jelaskan perbedaan supervised dan unsupervised learning",
"Bagaimana cara kerja transformer?",
"Apa kegunaan attention mechanism?"
]
responses = pipe(prompts)
for prompt, resp in zip(prompts, responses):
print(f"Q: {prompt}")
print(f"A: {resp.text}\n")
Konfigurasi Generasi
Anda dapat mengontrol parameter generasi teks menggunakan GenerationConfig:
from lmdeploy import pipeline, GenerationConfig
pipe = pipeline("internlm/internlm25-7b-chat")
genconfig = GenerationConfig(
maxnewtokens=512,
temperature=0.7,
topp=0.9,
topk=40,
repetitionpenalty=1.1
)
response = pipe(
["Tulis puisi pendek tentang kecerdasan buatan"],
genconfig=genconfig
)
print(response[0].text)
Multi-turn Conversation
LMDeploy mendukung percakapan multi-turn dengan menjaga konteks:
from lmdeploy import pipeline, GenerationConfig, ChatTemplateConfig
pipe = pipeline(
"internlm/internlm25-7b-chat",
chattemplateconfig=ChatTemplateConfig(
modelname="internlm2",
system="Kamu adalah asisten AI yang membantu."
)
)
Simulasi multi-turn conversation
messages = [
{"role": "user", "content": "Siapa penemu listrik?"},
]
response = pipe([messages])
print(f"Assistant: {response[0].text}")
Lanjutkan percakapan
messages.append({"role": "assistant", "content": response[0].text})
messages.append({"role": "user", "content": "Apa kontribusi terbesarnya?"})
response = pipe([messages])
print(f"Assistant: {response[0].text}")
Kuantisasi Model
Kuantisasi adalah teknik untuk mengurangi ukuran model dan mempercepat inferensi dengan menurunkan presisi bobot model. LMDeploy mendukung beberapa metode kuantisasi.
W4A16 Quantization (AWQ)
W4A16 berarti bobot dikuantisasi ke 4-bit sedangkan aktivasi tetap di 16-bit. Ini adalah metode yang paling umum digunakan:
lmdeploy lite autoawq \
internlm/internlm2
5-7b-chat \
--calib-dataset ptb \
--calib-samples 128 \
--calib-seqlen 2048 \
--w-bits 4 \
--w-group-size 128 \
--work-dir ./internlm25-7b-chat-4bit
Penjelasan parameter:
--calib-dataset: Dataset kalibrasi untuk menentukan range kuantisasi--calib-samples: Jumlah sampel kalibrasi--calib-seqlen: Panjang sekuens kalibrasi--w-bits: Jumlah bit untuk kuantisasi bobot (4-bit)--w-group-size: Ukuran grup untuk group-wise quantization--work-dir: Direktori output untuk model terkuantisasi
W8A8 Quantization
Untuk kuantisasi yang lebih presisi dengan overhead sedikit lebih besar:
lmdeploy lite smoothquant \
internlm/internlm25-7b-chat \
--calib-dataset ptb \
--calib-samples 128 \
--calib-seqlen 2048 \
--work-dir ./internlm25-7b-chat-w8a8
Menggunakan Model Terkuantisasi
Setelah kuantisasi selesai, gunakan model seperti biasa:
from lmdeploy import pipeline
Gunakan model AWQ 4-bit
pipe = pipeline("./internlm25-7b-chat-4bit")
response = pipe(["Jelaskan quantum computing secara sederhana"])
print(response[0].text)
Perbandingan Penggunaan Memory
Berikut perkiraan penggunaan VRAM untuk model 7B:
| Presisi | VRAM (approx) | Kecepatan Relatif |
|---------|---------------|-------------------|
| FP16 | ~14 GB | 1x (baseline) |
| W8A8 | ~8 GB | 1.2-1.5x |
| W4A16 | ~5 GB | 1.5-2x |
KV Cache Quantization
Selain kuantisasi model, LMDeploy juga mendukung kuantisasi KV cache untuk mengurangi penggunaan memori saat inferensi:
from lmdeploy import pipeline, TurbomindEngineConfig
engineconfig = TurbomindEngineConfig(
quantpolicy=8 # Kuantisasi KV cache ke 8-bit
)
pipe = pipeline(
"internlm/internlm25-7b-chat",
backendconfig=engineconfig
)
response = pipe(["Apa itu large language model?"])
print(response[0].text)
Penggunaan Lanjutan
Serving via API Server
LMDeploy menyediakan API server yang kompatibel dengan format OpenAI API, sehingga mudah diintegrasikan dengan aplikasi yang sudah menggunakan OpenAI SDK:
lmdeploy serve apiserver \
internlm/internlm2
5-7b-chat \
--server-name 0.0.0.0 \
--server-port 23333 \
--tp 1
Parameter penting:
--server-name: Bind address (0.0.0.0 untuk akses dari luar)--server-port: Port server--tp: Tensor parallelism (jumlah GPU yang digunakan)
Mengakses API Server
Setelah server berjalan, Anda bisa mengaksesnya menggunakan OpenAI SDK:
from openai import OpenAI
client = OpenAI(
apikey="not-needed",
baseurl="http://localhost:23333/v1"
)
Chat completion
response = client.chat.completions.create(
model="internlm/internlm25-7b-chat",
messages=[
{"role": "system", "content": "Kamu adalah asisten yang membantu."},
{"role": "user", "content": "Apa keuntungan menggunakan LMDeploy?"}
],
temperature=0.7,
maxtokens=512
)
print(response.choices[0].message.content)
Atau menggunakan curl:
curl http://localhost:23333/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "internlm/internlm25-7b-chat",
"messages": [
{"role": "user", "content": "Hello, apa kabar?"}
],
"temperature": 0.7
}'
Streaming Response
Untuk mendapatkan respons secara streaming:
from openai import OpenAI
client = OpenAI(
apikey="not-needed",
baseurl="http://localhost:23333/v1"
)
stream = client.chat.completions.create(
model="internlm/internlm25-7b-chat",
messages=[
{"role": "user", "content": "Ceritakan sejarah singkat AI"}
],
stream=True
)
for chunk in stream:
if chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
print()
Tensor Parallelism (Multi-GPU)
Untuk model yang lebih besar, Anda bisa mendistribusikan model ke beberapa GPU:
# Menggunakan 2 GPU
lmdeploy serve apiserver \
meta-llama/Meta-Llama-3-70B-Instruct \
--tp 2 \
--server-port 23333
Dalam Python:
from lmdeploy import pipeline, TurbomindEngineConfig
engineconfig = TurbomindEngineConfig(tp=2)
pipe = pipeline(
"meta-llama/Meta-Llama-3-70B-Instruct",
backendconfig=engineconfig
)
Vision Language Model (VLM) Support
LMDeploy juga mendukung model multimodal yang dapat memproses gambar:
from lmdeploy import pipeline
from lmdeploy.vl import loadimage
pipe = pipeline("OpenGVLab/InternVL2-8B")
image = loadimage("https://example.com/image.jpg")
response = pipe([("Deskripsikan gambar ini", image)])
print(response[0].text)
Untuk multiple images:
from lmdeploy import pipeline
from lmdeploy.vl import loadimage
pipe = pipeline("OpenGVLab/InternVL2-8B")
image1 = loadimage("image1.jpg")
image2 = loadimage("image2.jpg")
response = pipe([("Bandingkan kedua gambar ini", [image1, image2])])
print(response[0].text)
Konfigurasi TurboMind Engine
TurboMind adalah engine inferensi inti LMDeploy. Berikut konfigurasi lengkapnya:
from lmdeploy import pipeline, TurbomindEngineConfig
engineconfig = TurbomindEngineConfig(
tp=1, # Tensor parallelism
sessionlen=4096, # Maksimal panjang konteks
maxbatchsize=128, # Maksimal batch size
cachemaxentrycount=0.8, # Proporsi GPU memory untuk KV cache
quantpolicy=0, # 0: tanpa KV quant, 4: 4-bit, 8: 8-bit
ropescalingfactor=1.0, # RoPE scaling factor
)
pipe = pipeline(
"internlm/internlm25-7b-chat",
backendconfig=engineconfig
)
PyTorch Backend
Selain TurboMind, LMDeploy juga mendukung PyTorch backend untuk kompatibilitas yang lebih luas:
from lmdeploy import pipeline, PytorchEngineConfig
engineconfig = PytorchEngineConfig(
tp=1,
sessionlen=4096,
maxbatchsize=64,
cachemaxentrycount=0.8
)
pipe = pipeline(
"internlm/internlm25-7b-chat",
backendconfig=engineconfig
)
PyTorch backend berguna ketika:
- Model belum didukung oleh TurboMind
- Anda memerlukan fitur-fitur PyTorch spesifik
- Debugging dan pengembangan
Docker Deployment
Menjalankan dengan Docker
LMDeploy menyediakan Docker image resmi:
docker run --gpus all \
-v ~/.cache/huggingface:/root/.cache/huggingface \
-p 23333:23333 \
--ipc=host \
openmmlab/lmdeploy:latest \
lmdeploy serve apiserver \
internlm/internlm25-7b-chat \
--server-port 23333
Docker Compose
Untuk setup yang lebih terstruktur:
version: '3.8'
services:
lmdeploy:
image: openmmlab/lmdeploy:latest
deploy:
resources:
reservations:
devices:
- driver: nvidia
count: 1
capabilities: [gpu]
ports:
- "23333:23333"
volumes:
- huggingface-cache:/root/.cache/huggingface
ipc: host
command: >
lmdeploy serve apiserver
internlm/internlm25-7b-chat
--server-port 23333
--server-name 0.0.0.0
volumes:
huggingface-cache:
Best Practices
1. Pilih Metode Kuantisasi yang Tepat
- W4A16 (AWQ): Pilihan terbaik untuk sebagian besar use case. Mengurangi memory hingga 70% dengan degradasi kualitas minimal.
- W8A8: Gunakan jika Anda memerlukan presisi lebih tinggi atau model sensitif terhadap kuantisasi.
- FP16: Gunakan jika Anda memiliki resource GPU yang cukup dan memerlukan kualitas maksimal.
2. Optimalkan Konfigurasi Memory
engineconfig = TurbomindEngineConfig(
cache
maxentrycount=0.8, # Gunakan 80% free memory untuk KV cache
quantpolicy=8, # KV cache 8-bit untuk efisiensi
)
Jangan atur cachemaxentrycount terlalu tinggi karena bisa menyebabkan out-of-memory saat batch besar.
3. Gunakan Tensor Parallelism untuk Model Besar
Untuk model 70B+, distribusikan ke beberapa GPU:
engineconfig = TurbomindEngineConfig(
tp=4, # 4 GPU untuk model 70B
)
4. Monitor Performance
LMDeploy menyediakan endpoint metrics yang bisa diintegrasikan dengan Prometheus:
# Metrics tersedia di
curl http://localhost:23333/metrics
5. Atur Session Length dengan Bijak
Session length yang terlalu panjang akan mengonsumsi lebih banyak memory:
engineconfig = TurbomindEngineConfig(
sessionlen=2048, # Sesuaikan dengan kebutuhan aktual
)
6. Gunakan Continuous Batching
LMDeploy secara default menggunakan continuous batching yang memungkinkan throughput lebih tinggi dibandingkan static batching. Pastikan maxbatchsize diatur sesuai kapasitas GPU:
engineconfig = TurbomindEngineConfig(
maxbatchsize=64, # Sesuaikan dengan kapasitas GPU
)
7. Benchmark Sebelum Production
Selalu lakukan benchmark sebelum deployment:
lmdeploy serve apiserver internlm/internlm25-7b-chat --server-port 23333 &
Benchmark menggunakan tool bawaan
pip install openai
python -c "
from openai import OpenAI
import time
client = OpenAI(apikey='none', baseurl='http://localhost:23333/v1')
start = time.time()
for i in range(100):
client.chat.completions.create(
model='internlm/internlm25-7b-chat',
messages=[{'role': 'user', 'content': 'Hi'}],
maxtokens=50
)
elapsed = time.time() - start
print(f'100 requests in {elapsed:.2f}s ({100/elapsed:.1f} req/s)')
"
Model yang Didukung
LMDeploy mendukung berbagai model populer:
| Keluarga Model | Contoh |
|----------------|--------|
| LLaMA | LLaMA-2, LLaMA-3, LLaMA-3.1 |
| Qwen | Qwen-7B, Qwen-14B, Qwen-72B, Qwen2 |
| InternLM | InternLM-7B, InternLM2, InternLM2.5 |
| Mistral | Mistral-7B, Mixtral-8x7B |
| Gemma | Gemma-2B, Gemma-7B |
| ChatGLM | ChatGLM3, GLM-4 |
| Baichuan | Baichuan-7B, Baichuan-13B |
| Yi | Yi-6B, Yi-34B |
| DeepSeek | DeepSeek-V2 |
| Phi | Phi-2, Phi-3 |
Untuk daftar lengkap, kunjungi dokumentasi resmi LMDeploy.
Kesimpulan
LMDeploy adalah toolkit yang sangat berguna untuk siapa saja yang perlu mendeploy Large Language Model secara efisien. Dengan fitur utama seperti:
- TurboMind Engine: Inferensi cepat dengan continuous batching dan optimasi kernel CUDA
- Kuantisasi AWQ/W8A8: Mengurangi penggunaan memory secara signifikan
- API Server OpenAI-Compatible: Mudah diintegrasikan dengan ekosistem yang sudah ada
- Multi-GPU Support: Tensor parallelism untuk model besar
- VLM Support: Mendukung model multimodal
LMDeploy memungkinkan Anda menjalankan model besar pada hardware yang lebih terjangkau sambil mempertahankan kualitas output yang baik. Toolkit ini cocok untuk prototyping maupun production deployment.
Langkah selanjutnya yang bisa Anda eksplorasi: