Tutorial LMDeploy: Toolkit Lengkap untuk Deploy dan Serving Large Language Model

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

By Ruby Abdullah · · tutorial
LMDeployLLM DeploymentModel QuantizationTurboMindMLOps

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/internlm25-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/internlm25-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(

cachemaxentrycount=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:

  • Coba kuantisasi model favorit Anda dan bandingkan hasilnya
  • Setup API server untuk tim Anda
  • Integrasikan dengan aplikasi menggunakan OpenAI SDK
  • Eksplorasi VLM support untuk use case multimodal
  • Benchmark dan optimasi untuk production workload Anda
  • Artikel Terkait

    TorchServe: Panduan Lengkap Deployment Model PyTorch ke Production

    TorchServe: Panduan Lengkap Deployment Model PyTorch ke Production Penulis: Ruby Abdullah Kategori: Tutorial Tags: PyTor...

    Tutorial MLflow: Platform Open-Source untuk MLOps End-to-End

    Tutorial MLflow: Platform Open-Source untuk MLOps End-to-End MLflow adalah platform open-source yang dikembangkan oleh D...

    Tutorial Lengkap Prompt Flow: Framework Microsoft untuk Membangun Aplikasi LLM

    Tutorial Lengkap Prompt Flow: Framework Microsoft untuk Membangun Aplikasi LLM Prompt Flow adalah framework open-source ...

    Truss: Cara Package, Serve, dan Deploy Model ML dengan Rapi

    Truss: Cara Package, Serve, dan Deploy Model ML dengan Rapi Halo temen-temen, ketemu lagi sama aku, Ruby. Kali ini aku p...