{/* Trang này được tạo tự động từ SKILL.md của kỹ năng bởi website/scripts/generate-skill-docs.py. Chỉnh sửa nguồn SKILL.md, không phải trang này. */}

Phục vụ LLMs vLLM`vLLM: phân phối LLM thông lượng cao, API OpenAI, lượng tử hóa.

Siêu dữ liệu kỹ năng

Nguồn	Đi kèm (được cài đặt theo mặc định)
Đường dẫn

skills/mlops/inference/vLLM ` | | Phiên bản |

1.0.0 ` | | Tác giả | Nghiên cứu dàn nhạc | | Giấy phép | MIT | | Phụ thuộc |

vLLM

, `torch

, transformers | | Nền tảng | Linux, macOS | | Thẻ |

vLLM

, `Inference Serving

, `PagedAttention

, `Continuous Batching

, `High Throughput

, `Production

, `OpenAI API

, `Quantization

, Tensor Parallelism |

Tham khảo: đầy đủ SKILL.md

thông tin

Sau đây là định nghĩa kỹ năng đầy đủ mà Hermes tải khi kỹ năng này được kích hoạt. Đây là những gì tác nhân coi là hướng dẫn khi kỹ năng được kích hoạt.

vLLM - Cung cấp LLM hiệu suất cao

Khi nào nên sử dụng

Sử dụng khi triển khai API LLM sản xuất, tối ưu hóa độ trễ/thông lượng suy luận hoặc phân phát các mô hình có bộ nhớ GPU hạn chế. Hỗ trợ các điểm cuối, lượng tử hóa tương thích với OpenAI (GPTQ/AWQ/FP8) và song song tensor.

Bắt đầu nhanh`vLLM đạt được thông lượng cao hơn 24 lần so với máy biến áp tiêu chuẩn thông qua PagedAttention (bộ đệm KV dựa trên khối) và phân khối liên tục (trộn các yêu cầu điền trước/giải mã).

Cài đặt:

`

pip install vLLM

`
``**Suy luận ngoại tuyến cơ bản**:

`
`Python
from vLLM import LLM, SamplingParams

LLM = LLM(model="meta-Llama/Llama-3-8B-Instruct")
sampling = SamplingParams(temperature=0.7, max_tokens=256)

outputs = LLM.generate(["Explain quantum computing"], sampling)
print(outputs[0].outputs[0].text)

`
``**Máy chủ tương thích với OpenAI**:

`
`bash
vLLM serve meta-Llama/Llama-3-8B-Instruct

# Query with OpenAI SDK
Python -c "
from OpenAI import OpenAI
CLIent = OpenAI(base_url='http://localhost:8000/v1', API_key='EMPTY')
print(CLIent.chat.completions.create(
    model='meta-Llama/Llama-3-8B-Instruct',
    messages=[\{'role': 'user', 'content': 'Hello!'}]
).choices[0].message.content)
"

`

## Quy trình công việc chung

### Quy trình 1: Triển khai API sản xuất

Sao chép danh sách kiểm tra này và theo dõi tiến độ:

`
Deployment Progress:

- [ ] Step 1: Configure server settings
- [ ] Step 2: Test with limited traffic
- [ ] Step 3: Enable monitoring
- [ ] Step 4: Deploy to production
- [ ] Step 5: Verify performance metrics

`
``**Bước 1: Định cấu hình cài đặt máy chủ**

Chọn cấu hình dựa trên kích thước mô hình của bạn:

``` bash

# For 7B-13B models on single GPU
vLLM serve meta-Llama/Llama-3-8B-Instruct \
  --gpu-memory-utilization 0.9 \
  --max-model-len 8192 \
  --port 8000

# For 30B-70B models with tensor parallelism
vLLM serve meta-Llama/Llama-2-70b-hf \
  --tensor-parallel-size 4 \
  --gpu-memory-utilization 0.9 \
  --quantization awq \
  --port 8000

# For production with caching and metrics
vLLM serve meta-Llama/Llama-3-8B-Instruct \
  --gpu-memory-utilization 0.9 \
  --enable-prefix-caching \
  --enable-metrics \
  --metrics-port 9090 \
  --port 8000 \
  --host 0.0.0.0

`
``**Bước 2: Kiểm tra với lưu lượng truy cập hạn chế**

Chạy thử tải trước khi sản xuất:

``` bash

# Install load testing tool
pip install locust

# Create test_load.py with sample requests
# Run: locust -f test_load.py --host http://localhost:8000

`
``Xác minh TTFT (thời gian đến mã thông báo đầu tiên) < 500ms và thông lượng > 100 yêu cầu/giây.

**Bước 3: Kích hoạt tính năng giám sát**`vLLM hiển thị số liệu Prometheus trên cổng 9090:

``` bash
curl http://localhost:9090/metrics | grep vLLM

`
``Các chỉ số chính cần theo dõi:

- 
`vLLM:time_to_first_token_seconds

 - Độ trễ
- 
`vLLM:num_requests_running

 - Yêu cầu hoạt động
- 
`vLLM:gpu_cache_usage_perc

 - Sử dụng bộ đệm KV`**Bước 4: Triển khai vào sản xuất**

Sử dụng Docker để triển khai nhất quán:

``` bash

# Run vLLM in Docker
Docker run --gpus all -p 8000:8000 \
  vLLM/vLLM-OpenAI:latest \
  --model meta-Llama/Llama-3-8B-Instruct \
  --gpu-memory-utilization 0.9 \
  --enable-prefix-caching

`
``**Bước 5: Xác minh số liệu hiệu suất**

Kiểm tra xem việc triển khai có đáp ứng mục tiêu không:
- TTFT < 500ms (đối với lời nhắc ngắn)
- Thông lượng > yêu cầu mục tiêu/giây
- Sử dụng GPU > 80%
- Không có lỗi OOM trong nhật ký

### Luồng công việc 2: Suy luận hàng loạt ngoại tuyến

Để xử lý các tập dữ liệu lớn mà không cần chi phí máy chủ.

Sao chép danh sách kiểm tra này:

`
Batch Processing:
- [ ] Step 1: Prepare input data
- [ ] Step 2: Configure LLM engine
- [ ] Step 3: Run batch inference
- [ ] Step 4: Process results

`
``**Bước 1: Chuẩn bị dữ liệu đầu vào**

``` python

# Load prompts from file
prompts = []
with open("prompts.txt") as f:
    prompts = [line.strip() for line in f]

print(f"Loaded \{len(prompts)} prompts")

`
``**Bước 2: Định cấu hình công cụ LLM**

``` python
from vLLM import LLM, SamplingParams

LLM = LLM(
    model="meta-Llama/Llama-3-8B-Instruct",
    tensor_parallel_size=2,  # Use 2 GPUs
    gpu_memory_utilization=0.9,
    max_model_len=4096
)

sampling = SamplingParams(
    temperature=0.7,
    top_p=0.95,
    max_tokens=512,
    stop=["</s", "\n\n"]
)

`
``**Bước 3: Chạy suy luận hàng loạt**`vLLM tự động phân nhóm các yêu cầu để đạt hiệu quả:

`Python

# Process all prompts in one call
outputs = LLM.generate(prompts, sampling)

# vLLM handles batching internally
# No need to manually chunk prompts

`
``**Bước 4: Xử lý kết quả**

``` python

# Extract generated text
results = []
for output in outputs:
    prompt = output.prompt
    generated = output.outputs[0].text
    results.append({
        "prompt": prompt,
        "generated": generated,
        "tokens": len(output.outputs[0].token_ids)
    })

# Save to file
 import JSON
with open("results.JSONl", "w") as f:
    for result in results:
        f.write(JSON.dumps(result) + "\n")

print(f"Processed \{len(results)} prompts")

`

### Workflow 3: Phân phối mô hình lượng tử hóa

Phù hợp với các mô hình lớn trong bộ nhớ GPU hạn chế.

`
Quantization Setup:
- [ ] Step 1: Choose quantization method
- [ ] Step 2: Find or create quantiZed model
- [ ] Step 3: Launch with quantization flag
- [ ] Step 4: Verify accuracy

`
``**Bước 1: Chọn phương pháp lượng tử hóa**
- **AWQ**: Tốt nhất cho model 70B, giảm độ chính xác ở mức tối thiểu
- **GPTQ**: Hỗ trợ model rộng, nén tốt
- **FP8**: Nhanh nhất trên GPU H100`**Bước 2: Tìm hoặc tạo mô hình lượng tử hóa**

Sử dụng các mô hình được lượng tử hóa trước từ HuggingFace:

``` bash

# Search for AWQ models
# Example: TheBloke/Llama-2-70B-AWQ

`
``**Bước 3: Khởi chạy với cờ lượng tử hóa**

``` bash

# Using pre-quantiZed model
vLLM serve TheBloke/Llama-2-70B-AWQ \
  --quantization awq \
  --tensor-parallel-size 1 \
  --gpu-memory-utilization 0.95

# Results: 70B model in ~40GB VRAM

`
``**Bước 4: Xác minh tính chính xác**

Kết quả đầu ra thử nghiệm phù hợp với chất lượng mong đợi:

``` python

# Compare quantiZed vs non-quantiZed responses
# Verify task-specific performance unchanged

`

## Khi nào nên sử dụng so với các lựa chọn thay thế`**Sử dụng vLLM khi:**
- Triển khai API LLM sản xuất (100+ req/giây)
- Phục vụ các điểm cuối tương thích với OpenAI
- Bộ nhớ GPU hạn chế nhưng cần model lớn
- Ứng dụng đa người dùng (chatbots, trợ lý)
- Cần độ trễ thấp với thông lượng cao`**Sử dụng các lựa chọn thay thế thay thế:**
- **Llama.cpp**: Suy luận CPU/cạnh, một người dùng
- **Máy biến áp HuggingFace**: Nghiên cứu, tạo mẫu, tạo một lần
- **TensorRT-LLM**: Chỉ dành cho NVIDIA, cần hiệu năng tối đa tuyệt đối
- **Suy luận thế hệ văn bản**: Đã có trong hệ sinh thái HuggingFace

## Các vấn đề thường gặp`**Vấn đề: Hết bộ nhớ trong khi tải mô hình**

Giảm mức sử dụng bộ nhớ:

`
``` bash
vLLM serve MODEL \

  --gpu-memory-utilization 0.7 \
  --max-model-len 4096

`
``Hoặc sử dụng lượng tử hóa:

`
``` bash
vLLM serve MODEL --quantization awq

`
``**Vấn đề: Mã thông báo đầu tiên chậm (TTFT > 1 giây)**

Bật bộ nhớ đệm tiền tố cho các lời nhắc lặp lại:

`
`bash
vLLM serve MODEL --enable-prefix-caching

`
``Đối với những lời nhắc dài, hãy bật tính năng điền trước theo từng đoạn:

`
`bash
vLLM serve MODEL --enable-chunked-prefill

`
``**Vấn đề: Lỗi không tìm thấy mô hình**

Sử dụng 

`
--tRust-remote-code
` cho các mẫu tùy chỉnh:

`
``` bash
vLLM serve MODEL --tRust-remote-code

`
``**Vấn đề: Thông lượng thấp (<50 req/giây)**Tăng trình tự đồng thời:

`
`bash
vLLM serve MODEL --max-num-seqs 512

`
``Kiểm tra mức sử dụng GPU bằng 
`nvidia-smi

 - phải >80%.

**Vấn đề: Suy luận chậm hơn dự kiến**

Xác minh tính song song tensor sử dụng sức mạnh của 2 GPU:

`
`bash
vLLM serve MODEL --tensor-parallel-size 4  # Not 3

`
``Kích hoạt giải mã suy đoán để tạo nhanh hơn:

`
`bash
vLLM serve MODEL --speculative-model DRAFT_MODEL

`

## Chủ đề nâng cao`**Mẫu triển khai máy chủ**: Xem [references/server-deployment.md](https://GitHub.com/NousResearch/Hermes-agent/blob/main/skills/mlops/inference/vLLM/references/server-deployment.md) để biết cấu hình Docker, Kubernetes và cân bằng tải.

**Tối ưu hóa hiệu suất**: Xem [references/optimization.md](https://GitHub.com/NousResearch/Hermes-agent/blob/main/skills/mlops/inference/vLLM/references/optimization.md) để biết cách điều chỉnh PagedAttention, chi tiết phân nhóm liên tục và kết quả điểm chuẩn.

**Hướng dẫn lượng tử hóa**: Xem [references/quantization.md](https://GitHub.com/NousResearch/Hermes-agent/blob/main/skills/mlops/inference/vLLM/references/quantization.md) để biết cách thiết lập AWQ/GPTQ/FP8, chuẩn bị mô hình và so sánh độ chính xác.

**Khắc phục sự cố**: Xem [references/troubleshooting.md](https://GitHub.com/NousResearch/Hermes-agent/blob/main/skills/mlops/inference/vLLM/references/troubleshooting.md) để biết thông báo lỗi chi tiết, các bước gỡ lỗi và chẩn đoán hiệu suất.

## Yêu cầu về phần cứng
- **Mẫu nhỏ (7B-13B)**: 1x A10 (24GB) hoặc A100 (40GB)

- **Mẫu trung bình (30B-40B)**: 2x A100 (40GB) với tính năng song song tensor
- **Mẫu lớn (70B+)**: 4x A100 (40GB) hoặc 2x A100 (80GB), sử dụng AWQ/GPTQ

Nền tảng được hỗ trợ: NVIDIA (chính), AMD ROCm, GPU Intel, TPU

## Tài nguyên
- Tài liệu chính thức: https://docs.vLLM.ai
- GitHub: https://GitHub.com/vLLM-project/vLLM
- Bài viết: "Quản lý bộ nhớ hiệu quả cho mô hình ngôn ngữ lớn phục vụ với PagedAttention" (SOSP 2023)
- Cộng đồng: https://discuss.vLLM.ai