大家好，我是 V 哥。

上期咱们聊了怎么把 GPU 集群搭起来（没看过的兄弟赶紧去补课）。集群搭好了，就像你把那个 500 万的豪华厨房建好了，接下来咱们得开始“做菜”了——也就是大模型推理。

很多小白兄弟把模型训练完，或者从网上下载个开源模型（比如 Llama 3、Qwen），直接用 Python 那个 transformers 库去跑，结果发现：
“V哥，这玩意儿怎么这么慢？生成一句话要憋半天！而且显存怎么一下就爆了？”

这就对了。用原生代码跑推理，就像开法拉利去送外卖，还是在晚高峰的二环上——有劲儿使不出。

今天V哥就带你认识一个神器——vLLM。这玩意儿是目前大模型推理领域的"性能怪兽"，用好了能让你的推理速度提升3-24倍，不是我吹，是官方数据。

老规矩，不整虚的，全是干货，跟着V哥一步步来。

---

一、先搞懂：vLLM是个啥？为啥要用它？

1. 大模型推理的痛点

在讲vLLM之前，V哥先给你说说，为啥你自己跑模型那么慢。

假设你用最原始的方式加载一个Llama-7B模型：

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-chat-hf")
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-chat-hf")

# 推理
output = model.generate(tokenizer.encode("你好", return_tensors="pt").cuda())

这样跑有几个致命问题：

问题	后果
显存利用率低	一张80G的A100，可能只用了30%
吞吐量低	一秒钟只能处理几个请求
不支持并发	来10个用户，9个得排队
KV Cache没优化	显存浪费严重，长文本直接爆显存

这就好比你开着一辆法拉利，却只能在小区里跑20码——硬件性能完全没发挥出来。

2. vLLM是什么？

vLLM是UC Berkeley开发的一个高性能大模型推理引擎。

它的核心创新叫PagedAttention——V哥用大白话解释一下：

传统方式处理KV Cache（模型推理时的中间缓存）就像分配内存一样，一次性给你分一大块，用不完就浪费了。

PagedAttention的思路是：像操作系统管理内存页一样管理KV Cache。用多少分多少，不连续也没关系，用"页表"记录位置就行。

结果就是：

• 显存利用率从30%提升到90%以上
• 同样的硬件，能处理的并发请求多好几倍
• 吞吐量暴增

3. vLLM vs 其他推理框架

V哥给你做个对比：

特性	vLLM	TGI (HuggingFace)	Triton + TensorRT-LLM	Ollama
性能	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐
易用性	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐	⭐⭐⭐⭐⭐
模型支持	广泛	广泛	需要转换	有限
生产就绪	✅	✅	✅	❌
OpenAI兼容API	✅	✅	需配置	✅
分布式推理	✅	✅	✅	❌

V哥的建议：

• 想要性能+易用性平衡，选vLLM
• 追求极致性能且不怕折腾，选TensorRT-LLM
• 只是本地玩玩，选Ollama
• 在HuggingFace生态里，选TGI

今天咱们重点讲vLLM，因为它是目前最适合生产环境的选择。

---

二、环境准备

1. 硬件要求

模型规模	最低显存	推荐配置
7B	16GB	RTX 4090 / A10
13B	28GB	A100 40G
70B	140GB	2x A100 80G
70B (量化后)	40GB	A100 40G

V哥提醒：显存不够可以用量化版模型，后面会讲。

2. 软件环境

# 操作系统
Ubuntu 22.04 LTS

# Python版本
Python 3.9 - 3.11

# CUDA版本
CUDA 11.8 或 12.1

# 驱动版本
NVIDIA Driver 525+

3. 验证GPU环境

# 检查GPU
nvidia-smi

# 检查CUDA
nvcc --version

# 检查Python
python3 --version

---

三、安装vLLM

方式一：pip直接安装（最简单）

# 创建虚拟环境（强烈推荐）
python3 -m venv vllm-env
source vllm-env/bin/activate

# 安装vLLM
pip install vllm

# 如果网络慢，用国内镜像
pip install vllm -i https://pypi.tuna.tsinghua.edu.cn/simple

方式二：从源码安装（需要定制功能时）

git clone https://github.com/vllm-project/vllm.git
cd vllm
pip install -e .

方式三：Docker安装（生产环境推荐）

# 拉取官方镜像
docker pull vllm/vllm-openai:latest

# 或者指定版本
docker pull vllm/vllm-openai:v0.4.0

验证安装

python -c "import vllm; print(vllm.__version__)"

能打印版本号就成功了。

---

四、快速上手：5分钟跑起来一个模型

1. 下载模型

以Qwen2-7B-Instruct为例（国内访问友好）：

# 安装modelscope（国内镜像）
pip install modelscope

# 下载模型
python -c "
from modelscope import snapshot_download
model_dir = snapshot_download('qwen/Qwen2-7B-Instruct', cache_dir='./models')
print(f'模型下载到: {model_dir}')
"

或者用HuggingFace（需要科学上网）：

# 安装huggingface_hub
pip install huggingface_hub

# 下载模型
huggingface-cli download Qwen/Qwen2-7B-Instruct --local-dir ./models/Qwen2-7B-Instruct

2. 启动vLLM服务

最简单的方式——一行命令：

python -m vllm.entrypoints.openai.api_server \
    --model ./models/Qwen2-7B-Instruct \
    --trust-remote-code \
    --host 0.0.0.0 \
    --port 8000

看到类似这样的输出就成功了：

INFO:     Started server process [12345]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)

3. 测试API

方式一：用curl测试

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "./models/Qwen2-7B-Instruct",
    "messages": [
      {"role": "system", "content": "你是一个有帮助的助手。"},
      {"role": "user", "content": "用一句话介绍你自己"}
    ],
    "max_tokens": 100
  }'

方式二：用Python测试

from openai import OpenAI

# 注意：这里用的是OpenAI的SDK，但连的是本地vLLM服务
client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"  # vLLM默认不需要API key
)

response = client.chat.completions.create(
    model="./models/Qwen2-7B-Instruct",
    messages=[
        {"role": "system", "content": "你是一个有帮助的助手。"},
        {"role": "user", "content": "用一句话介绍你自己"}
    ],
    max_tokens=100
)

print(response.choices[0].message.content)

方式三：流式输出

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"
)

stream = client.chat.completions.create(
    model="./models/Qwen2-7B-Instruct",
    messages=[
        {"role": "user", "content": "写一首关于程序员的诗"}
    ],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end="", flush=True)

恭喜！你已经成功部署了一个大模型推理服务！

---

五、核心参数详解

vLLM的启动参数很多，V哥挑最重要的讲：

1. 模型相关参数

python -m vllm.entrypoints.openai.api_server \
    --model ./models/Qwen2-7B-Instruct \  # 模型路径或HuggingFace模型名
    --tokenizer ./models/Qwen2-7B-Instruct \  # tokenizer路径（通常和model一样）
    --trust-remote-code \  # 信任模型的自定义代码（Qwen等模型需要）
    --revision main \  # 模型版本（如果从HuggingFace下载）
    --dtype auto  # 数据类型：auto/float16/bfloat16/float32

2. 显存和性能参数

    --gpu-memory-utilization 0.9 \  # GPU显存利用率，默认0.9
    --max-model-len 4096 \  # 最大上下文长度
    --max-num-seqs 256 \  # 最大并发请求数
    --max-num-batched-tokens 8192  # 每批次最大token数

V哥解释：

参数	说明	调优建议
gpu-memory-utilization	显存占用比例	显存紧张就调低到0.8，富余就0.95
max-model-len	最大序列长度	根据业务需求设置，越长越吃显存
max-num-seqs	并发数	压测后根据性能调整

3. 多GPU/分布式参数

    --tensor-parallel-size 2 \  # 张量并行（单机多卡）
    --pipeline-parallel-size 1 \  # 流水线并行（多机）

什么时候用什么：

• 单机多卡：用--tensor-parallel-size，设置成GPU数量
• 多机多卡：结合使用，比如2机8卡，可以设置--tensor-parallel-size 4 --pipeline-parallel-size 2

4. 量化相关参数

    --quantization awq \  # 量化方法：awq/gptq/squeezellm
    --load-format auto  # 模型加载格式

5. 完整的生产环境启动命令示例

python -m vllm.entrypoints.openai.api_server \
    --model ./models/Qwen2-7B-Instruct \
    --trust-remote-code \
    --host 0.0.0.0 \
    --port 8000 \
    --gpu-memory-utilization 0.9 \
    --max-model-len 8192 \
    --max-num-seqs 128 \
    --tensor-parallel-size 1 \
    --dtype bfloat16 \
    --disable-log-requests  # 生产环境关闭请求日志

---

六、Docker部署（生产环境推荐）

1. 基础Docker部署

docker run -d \
    --name vllm-server \
    --gpus all \
    -v /path/to/models:/models \
    -p 8000:8000 \
    vllm/vllm-openai:latest \
    --model /models/Qwen2-7B-Instruct \
    --trust-remote-code \
    --host 0.0.0.0 \
    --port 8000

2. Docker Compose部署（推荐）

创建 docker-compose.yml：

version: '3.8'

services:
  vllm:
    image: vllm/vllm-openai:latest
    container_name: vllm-server
    runtime: nvidia
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN}  # 如果需要下载私有模型
    volumes:
      - ./models:/models
      - ./logs:/logs
    ports:
      - "8000:8000"
    command: >
      --model /models/Qwen2-7B-Instruct
      --trust-remote-code
      --host 0.0.0.0
      --port 8000
      --gpu-memory-utilization 0.9
      --max-model-len 8192
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  # 可选：添加Nginx反向代理
  nginx:
    image: nginx:alpine
    container_name: vllm-nginx
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
    depends_on:
      - vllm
    restart: unless-stopped

启动：

docker-compose up -d

# 查看日志
docker-compose logs -f vllm

3. Kubernetes部署

创建 vllm-deployment.yaml：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-server
  labels:
    app: vllm
spec:
  replicas: 1
  selector:
    matchLabels:
      app: vllm
  template:
    metadata:
      labels:
        app: vllm
    spec:
      containers:
      - name: vllm
        image: vllm/vllm-openai:latest
        args:
        - "--model"
        - "/models/Qwen2-7B-Instruct"
        - "--trust-remote-code"
        - "--host"
        - "0.0.0.0"
        - "--port"
        - "8000"
        - "--gpu-memory-utilization"
        - "0.9"
        ports:
        - containerPort: 8000
        resources:
          limits:
            nvidia.com/gpu: 1
        volumeMounts:
        - name: model-storage
          mountPath: /models
        livenessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 120
          periodSeconds: 30
        readinessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 60
          periodSeconds: 10
      volumes:
      - name: model-storage
        persistentVolumeClaim:
          claimName: model-pvc

---
apiVersion: v1
kind: Service
metadata:
  name: vllm-service
spec:
  selector:
    app: vllm
  ports:
  - port: 8000
    targetPort: 8000
  type: ClusterIP

---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: vllm-ingress
  annotations:
    nginx.ingress.kubernetes.io/proxy-read-timeout: "600"
    nginx.ingress.kubernetes.io/proxy-send-timeout: "600"
spec:
  rules:
  - host: llm.your-domain.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: vllm-service
            port:
              number: 8000

部署：

kubectl apply -f vllm-deployment.yaml

---

七、进阶玩法

1. 多模型部署

vLLM本身一个实例只能加载一个模型，但你可以：

方案一：启动多个vLLM实例

# 模型1 - 用GPU 0
CUDA_VISIBLE_DEVICES=0 python -m vllm.entrypoints.openai.api_server \
    --model ./models/Qwen2-7B-Instruct \
    --port 8000 &

# 模型2 - 用GPU 1
CUDA_VISIBLE_DEVICES=1 python -m vllm.entrypoints.openai.api_server \
    --model ./models/Llama-3-8B-Instruct \
    --port 8001 &

方案二：用Nginx做路由

upstream qwen {
    server localhost:8000;
}

upstream llama {
    server localhost:8001;
}

server {
    listen 80;
    
    location /v1/qwen/ {
        proxy_pass http://qwen/v1/;
    }
    
    location /v1/llama/ {
        proxy_pass http://llama/v1/;
    }
}

2. 量化模型部署（显存不够时）

如果你的显存不够跑原版模型，可以用量化版本：

AWQ量化模型（推荐）：

# AWQ量化版通常在模型名后面带-AWQ
python -m vllm.entrypoints.openai.api_server \
    --model TheBloke/Qwen2-7B-Instruct-AWQ \
    --quantization awq \
    --trust-remote-code

GPTQ量化模型：

python -m vllm.entrypoints.openai.api_server \
    --model TheBloke/Qwen2-7B-Instruct-GPTQ \
    --quantization gptq \
    --trust-remote-code

量化效果对比：

量化方式	显存占用	速度	质量损失
无量化	100%	100%	0%
AWQ 4bit	~25%	90%	1-2%
GPTQ 4bit	~25%	85%	2-3%

3. 多卡并行推理（跑大模型）

单机多卡（比如70B模型用2张A100）：

python -m vllm.entrypoints.openai.api_server \
    --model ./models/Llama-2-70b-chat-hf \
    --tensor-parallel-size 2 \  # 用2张卡
    --trust-remote-code

多机多卡（需要Ray集群）：

先在所有节点启动Ray：

# 主节点
ray start --head --port=6379

# 工作节点
ray start --address='master-ip:6379'

然后启动vLLM：

python -m vllm.entrypoints.openai.api_server \
    --model ./models/Llama-2-70b-chat-hf \
    --tensor-parallel-size 4 \
    --pipeline-parallel-size 2 \
    --trust-remote-code

4. 自定义采样参数

vLLM支持OpenAI API的所有采样参数：

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")

response = client.chat.completions.create(
    model="./models/Qwen2-7B-Instruct",
    messages=[{"role": "user", "content": "写一个故事"}],
    temperature=0.8,  # 创造性，0-2，越高越随机
    top_p=0.95,  # 核采样，0-1
    max_tokens=1000,  # 最大生成长度
    frequency_penalty=0.5,  # 频率惩罚，减少重复
    presence_penalty=0.5,  # 存在惩罚，增加多样性
    stop=["。", "\n\n"],  # 停止词
    n=1  # 生成几个回复
)

5. Function Calling（函数调用）

vLLM支持OpenAI风格的function calling：

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "获取指定城市的天气",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "城市名称"
                    }
                },
                "required": ["city"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="./models/Qwen2-7B-Instruct",
    messages=[{"role": "user", "content": "北京今天天气怎么样？"}],
    tools=tools,
    tool_choice="auto"
)

print(response.choices[0].message.tool_calls)

---

八、性能优化技巧

1. 基准测试

先测一下你的服务性能：

# 安装压测工具
pip install locust

# 创建压测脚本 locustfile.py

from locust import HttpUser, task, between
import json

class VLLMUser(HttpUser):
    wait_time = between(1, 2)
    
    @task
    def chat(self):
        self.client.post(
            "/v1/chat/completions",
            json={
                "model": "./models/Qwen2-7B-Instruct",
                "messages": [{"role": "user", "content": "你好"}],
                "max_tokens": 100
            }
        )

运行压测：

locust -f locustfile.py --host=http://localhost:8000

2. 优化建议

场景	优化方法
吞吐量优先	增大max-num-seqs，开启continuous batching
延迟优先	减小max-num-seqs，单独服务重要请求
显存不足	降低gpu-memory-utilization，用量化模型
长文本场景	增大max-model-len，但要确保显存够

3. 监控指标

vLLM自带Prometheus metrics：

# 启动时开启metrics
python -m vllm.entrypoints.openai.api_server \
    --model ./models/Qwen2-7B-Instruct \
    --disable-log-stats  # 关闭控制台统计，用Prometheus采集

访问 http://localhost:8000/metrics 可以看到：

• vllm:num_requests_running - 正在处理的请求数
• vllm:num_requests_waiting - 等待中的请求数
• vllm:gpu_cache_usage_perc - GPU缓存使用率
• vllm:avg_generation_throughput_toks_per_s - 生成吞吐量

---

九、常见问题排查

问题1：CUDA out of memory

症状：启动或推理时报显存不足

解决方案：

# 方案1：降低显存利用率
--gpu-memory-utilization 0.7

# 方案2：减小最大序列长度
--max-model-len 2048

# 方案3：用量化模型
--quantization awq

# 方案4：用多卡并行
--tensor-parallel-size 2

问题2：模型加载失败

症状：各种模型加载报错

解决方案：

# 检查是否需要trust-remote-code
--trust-remote-code

# 检查模型是否完整
ls -la ./models/Qwen2-7B-Instruct/

# 重新下载模型
rm -rf ./models/Qwen2-7B-Instruct
# 重新执行下载命令

问题3：推理速度慢

症状：响应时间长，吞吐量低

排查步骤：

# 1. 检查GPU利用率
nvidia-smi -l 1

# 2. 检查是否有其他进程占用GPU
nvidia-smi

# 3. 确认用的是GPU而不是CPU
# 日志里应该有类似这样的输出：
# INFO: Using GPU 0: NVIDIA A100

问题4：API调用报错

症状：请求返回错误

常见原因：

# 错误1：model名称不对
# 解决：使用启动时指定的模型路径
"model": "./models/Qwen2-7B-Instruct"  # 不是 "qwen"

# 错误2：消息格式不对
# 解决：使用正确的消息格式
"messages": [
    {"role": "system", "content": "..."},  # 可选
    {"role": "user", "content": "..."}
]

# 错误3：token超限
# 解决：减小max_tokens或输入长度

问题5：多卡并行失败

症状：tensor-parallel启动报错

解决方案：

# 检查GPU数量
nvidia-smi -L

# 确保tensor-parallel-size不超过GPU数量
--tensor-parallel-size 2  # 如果你有2张卡

# 检查NCCL通信
export NCCL_DEBUG=INFO
python -m vllm.entrypoints.openai.api_server ...

---

十、实战案例：搭建一个完整的问答服务

最后，V哥给你一个完整的生产级别部署方案。

项目结构

my-llm-service/
├── docker-compose.yml
├── nginx/
│   └── nginx.conf
├── app/
│   ├── main.py
│   └── requirements.txt
├── models/
│   └── Qwen2-7B-Instruct/
└── scripts/
    ├── start.sh
    └── test.py

docker-compose.yml

version: '3.8'

services:
  vllm:
    image: vllm/vllm-openai:latest
    container_name: vllm
    runtime: nvidia
    volumes:
      - ./models:/models
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
    command: >
      --model /models/Qwen2-7B-Instruct
      --trust-remote-code
      --host 0.0.0.0
      --port 8000
      --gpu-memory-utilization 0.9
      --max-model-len 8192
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  api:
    build: ./app
    container_name: api-server
    ports:
      - "5000:5000"
    environment:
      - VLLM_URL=http://vllm:8000
    depends_on:
      vllm:
        condition: service_healthy
    restart: unless-stopped

  nginx:
    image: nginx:alpine
    container_name: nginx
    ports:
      - "80:80"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
    depends_on:
      - api
    restart: unless-stopped

app/main.py

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from openai import OpenAI
import os

app = FastAPI(title="My LLM Service")

# 连接vLLM
client = OpenAI(
    base_url=os.getenv("VLLM_URL", "http://localhost:8000") + "/v1",
    api_key="not-needed"
)

class ChatRequest(BaseModel):
    question: str
    system_prompt: str = "你是一个有帮助的AI助手。"
    max_tokens: int = 1000

class ChatResponse(BaseModel):
    answer: str
    usage: dict

@app.post("/chat", response_model=ChatResponse)
async def chat(request: ChatRequest):
    try:
        response = client.chat.completions.create(
            model="/models/Qwen2-7B-Instruct",
            messages=[
                {"role": "system", "content": request.system_prompt},
                {"role": "user", "content": request.question}
            ],
            max_tokens=request.max_tokens,
            temperature=0.7
        )
        
        return ChatResponse(
            answer=response.choices[0].message.content,
            usage={
                "prompt_tokens": response.usage.prompt_tokens,
                "completion_tokens": response.usage.completion_tokens,
                "total_tokens": response.usage.total_tokens
            }
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/health")
async def health():
    return {"status": "ok"}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=5000)

app/requirements.txt

fastapi==0.109.0
uvicorn==0.27.0
openai==1.10.0
pydantic==2.5.0

app/Dockerfile

FROM python:3.10-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple

COPY main.py .

CMD ["python", "main.py"]

nginx/nginx.conf

events {
    worker_connections 1024;
}

http {
    upstream api {
        server api:5000;
    }

    server {
        listen 80;

        location / {
            proxy_pass http://api;
            proxy_http_version 1.1;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_read_timeout 300s;
        }
    }
}

启动服务

# 启动所有服务
docker-compose up -d

# 查看日志
docker-compose logs -f

# 测试
curl -X POST http://localhost/chat \
  -H "Content-Type: application/json" \
  -d '{"question": "什么是机器学习？"}'

---

总结

好了兄弟们，vLLM部署这事儿今天就讲到这。

让我们回顾一下核心知识点：

1. vLLM是什么 → 高性能大模型推理引擎，核心是PagedAttention
       ↓
2. 快速上手 → pip install vllm + 一行命令启动
       ↓
3. 核心参数 → gpu-memory-utilization、max-model-len、tensor-parallel-size
       ↓
4. 生产部署 → Docker/K8s + 健康检查 + 监控
       ↓
5. 进阶玩法 → 多模型、量化、多卡并行、Function Calling
       ↓
6. 性能优化 → 压测 + 参数调优 + 监控指标

V哥划重点：

• vLLM最大的优势是开箱即用，API兼容OpenAI
• 显存不够就用量化模型，AWQ是首选
• 生产环境一定要加健康检查和监控
• 性能调优要先压测，别瞎猜

有问题评论区见，V哥看到都会回复。

下期咱们聊聊如何微调一个大模型——是的，不只是用，还要会调。不见不散！

---

V哥碎碎念：这篇文章又是接近一万字，手都敲麻了。如果对你有帮助，点个赞、转发一下，让更多兄弟少踩坑！