@baimingtao/lbs-agent 1.0.0

package/extensions/skills/builtin/mlops/inference/vllm/references/quantization.md

@@ -0,0 +1,284 @@
+# 量化指南
+
+## 目录
+- 量化方法对比
+- AWQ 设置与使用
+- GPTQ 设置与使用
+- FP8 量化 (H100)
+- 模型准备
+- 精度与压缩的权衡
+
+## 量化方法对比
+
+| Method | Compression | Accuracy Loss | Speed | Best For |
+|--------|-------------|---------------|-------|----------|
+| **AWQ** | 4-bit (75%) | <1% | Fast | 70B models, production |
+| **GPTQ** | 4-bit (75%) | 1-2% | Fast | Wide model support |
+| **FP8** | 8-bit (50%) | <0.5% | Fastest | H100 GPUs only |
+| **SqueezeLLM** | 3-4 bit (75-80%) | 2-3% | Medium | Extreme compression |
+
+**建议**：
+- **生产环境**：70B 模型使用 AWQ
+- **H100 GPU**：使用 FP8 以获得最快速度
+- **最大兼容性**：使用 GPTQ
+- **极限压缩**：使用 SqueezeLLM
+
+## AWQ 设置与使用
+
+**AWQ** (Activation-aware Weight Quantization) 在 4-bit 下能达到最佳精度。
+
+**第 1 步：寻找预量化模型**
+
+在 HuggingFace 上搜索 AWQ 模型：
+```bash
+# Example: TheBloke/Llama-2-70B-AWQ
+# Example: TheBloke/Mixtral-8x7B-Instruct-v0.1-AWQ
+```
+
+**第 2 步：使用 AWQ 启动**
+
+```bash
+vllm serve TheBloke/Llama-2-70B-AWQ \
+  --quantization awq \
+  --tensor-parallel-size 1 \
+  --gpu-memory-utilization 0.95
+```
+
+**内存节省**：
+```
+Llama 2 70B fp16: 140GB VRAM (4x A100 needed)
+Llama 2 70B AWQ: 35GB VRAM (1x A100 40GB)
+= 4x memory reduction
+```
+
+**第 3 步：验证性能**
+
+测试输出结果是否可接受：
+```python
+from openai import OpenAI
+
+client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")
+
+# Test complex reasoning
+response = client.chat.completions.create(
+    model="TheBloke/Llama-2-70B-AWQ",
+    messages=[{"role": "user", "content": "Explain quantum entanglement"}]
+)
+
+print(response.choices[0].message.content)
+# Verify quality matches your requirements
+```
+
+**量化你自己的模型**（需要具备 80GB+ VRAM 的 GPU）：
+
+```python
+from awq import AutoAWQForCausalLM
+from transformers import AutoTokenizer
+
+model_path = "meta-llama/Llama-2-70b-hf"
+quant_path = "llama-2-70b-awq"
+
+# Load model
+model = AutoAWQForCausalLM.from_pretrained(model_path)
+tokenizer = AutoTokenizer.from_pretrained(model_path)
+
+# Quantize
+quant_config = {"zero_point": True, "q_group_size": 128, "w_bit": 4}
+model.quantize(tokenizer, quant_config=quant_config)
+
+# Save
+model.save_quantized(quant_path)
+tokenizer.save_pretrained(quant_path)
+```
+
+## GPTQ 设置与使用
+
+**GPTQ** 具有最广泛的模型支持和良好的压缩效果。
+
+**第 1 步：寻找 GPTQ 模型**
+
+```bash
+# Example: TheBloke/Llama-2-13B-GPTQ
+# Example: TheBloke/CodeLlama-34B-GPTQ
+```
+
+**第 2 步：使用 GPTQ 启动**
+
+```bash
+vllm serve TheBloke/Llama-2-13B-GPTQ \
+  --quantization gptq \
+  --dtype float16
+```
+
+**GPTQ 配置选项**：
+```bash
+# Specify GPTQ parameters if needed
+vllm serve MODEL \
+  --quantization gptq \
+  --gptq-act-order \  # Activation ordering
+  --dtype float16
+```
+
+**量化你自己的模型**：
+
+```python
+from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig
+from transformers import AutoTokenizer
+
+model_name = "meta-llama/Llama-2-13b-hf"
+quantized_name = "llama-2-13b-gptq"
+
+# Load model
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoGPTQForCausalLM.from_pretrained(model_name, quantize_config)
+
+# Prepare calibration data
+calib_data = [...]  # List of sample texts
+
+# Quantize
+quantize_config = BaseQuantizeConfig(
+    bits=4,
+    group_size=128,
+    desc_act=True
+)
+model.quantize(calib_data)
+
+# Save
+model.save_quantized(quantized_name)
+```
+
+## FP8 量化 (H100)
+
+**FP8** (8-bit floating point) 在 H100 GPU 上提供了最快的速度，且精度损失极小。
+
+**要求**:
+- H100 或 H800 GPU
+- CUDA 12.3+（推荐 12.8）
+- Hopper 架构支持
+
+**第 1 步：启用 FP8**
+
+```bash
+vllm serve meta-llama/Llama-3-70B-Instruct \
+  --quantization fp8 \
+  --tensor-parallel-size 2
+```
+
+**在 H100 上的性能提升**：
+```
+fp16: 180 tokens/sec
+FP8: 320 tokens/sec
+= 1.8x speedup
+```
+
+**第 2 步：验证精度**
+
+FP8 通常具有 <0.5% 的精度下降：
+```python
+# Run evaluation suite
+# Compare FP8 vs FP16 on your tasks
+# Verify acceptable accuracy
+```
+
+**动态 FP8 量化**（无需预量化模型）：
+
+```bash
+# vLLM automatically quantizes at runtime
+vllm serve MODEL --quantization fp8
+# No model preparation required
+```
+
+## 模型准备
+
+**预量化模型（最简单）**：
+
+1. 在 HuggingFace 搜索：`[model name] AWQ` 或 `[model name] GPTQ`
+2. 下载或直接使用：`TheBloke/[Model]-AWQ`
+3. 使用相应的 `--quantization` 参数启动
+
+**量化你自己的模型**：
+
+**AWQ**:
+```bash
+# Install AutoAWQ
+pip install autoawq
+
+# Run quantization script
+python quantize_awq.py --model MODEL --output OUTPUT
+```
+
+**GPTQ**:
+```bash
+# Install AutoGPTQ
+pip install auto-gptq
+
+# Run quantization script
+python quantize_gptq.py --model MODEL --output OUTPUT
+```
+
+**校准数据**:
+- 从目标领域使用 128-512 个多样化的示例
+- 能够代表生产环境的输入
+- 更高质量的校准 = 更好的精度
+
+## 精度与压缩的权衡
+
+**实验结果**（Llama 2 70B 在 MMLU 基准测试上）：
+
+| Quantization | Accuracy | Memory | Speed | Production-Ready |
+|--------------|----------|--------|-------|------------------|
+| FP16 (baseline) | 100% | 140GB | 1.0x | ✅ (if memory available) |
+| FP8 | 99.5% | 70GB | 1.8x | ✅ (H100 only) |
+| AWQ 4-bit | 99.0% | 35GB | 1.5x | ✅ (best for 70B) |
+| GPTQ 4-bit | 98.5% | 35GB | 1.5x | ✅ (good compatibility) |
+| SqueezeLLM 3-bit | 96.0% | 26GB | 1.3x | ⚠️ (check accuracy) |
+
+**何时使用哪种方法**：
+
+**不进行量化 (FP16)**：
+- 拥有充足的 GPU 内存
+- 需要绝对最佳的精度
+- 模型参数量 <13B
+
+**FP8**：
+- 使用 H100/H800 GPU
+- 需要在精度损失极小的情况下获得最快速度
+- 生产环境部署
+
+**AWQ 4-bit**：
+- 需要将 70B 模型装入 40GB GPU
+- 生产环境部署
+- 可接受 <1% 的精度损失
+
+**GPTQ 4-bit**：
+- 需要广泛的模型支持
+- 未使用 H100（否则请使用 FP8）
+- 可接受 1-2% 的精度损失
+
+**测试策略**：
+
+1. **Baseline**：在你的评估集上测量 FP16 精度
+2. **Quantize**：创建量化版本
+3. **Evaluate**：在相同任务上对比量化版本与 baseline
+4. **Decide**：如果性能下降幅度 < 阈值（通常为 1-2%）则予以接受
+
+**示例 evaluation**:
+```python
+from evaluate import load_evaluation_suite
+
+# Run on FP16 baseline
+baseline_score = evaluate(model_fp16, eval_suite)
+
+# Run on quantized
+quant_score = evaluate(model_awq, eval_suite)
+
+# Compare
+degradation = (baseline_score - quant_score) / baseline_score * 100
+print(f"Accuracy degradation: {degradation:.2f}%")
+
+# Decision
+if degradation < 1.0:
+    print("✅ Quantization acceptable for production")
+else:
+    print("⚠️ Review accuracy loss")
+```

package/extensions/skills/builtin/mlops/inference/vllm/references/server-deployment.md

@@ -0,0 +1,255 @@
+# 服务器部署模式
+
+## 目录
+- Docker 部署
+- Kubernetes 部署
+- 使用 Nginx 进行负载均衡
+- 多节点分布式服务
+- 生产环境配置示例
+- 健康检查与监控
+
+## Docker 部署
+
+**基础 Dockerfile**：
+```dockerfile
+FROM nvidia/cuda:12.1.0-devel-ubuntu22.04
+
+RUN apt-get update && apt-get install -y python3-pip
+RUN pip install vllm
+
+EXPOSE 8000
+
+CMD ["vllm", "serve", "meta-llama/Llama-3-8B-Instruct", \
+     "--host", "0.0.0.0", "--port", "8000", \
+     "--gpu-memory-utilization", "0.9"]
+```
+
+**构建并运行**：
+```bash
+docker build -t vllm-server .
+docker run --gpus all -p 8000:8000 vllm-server
+```
+
+**Docker Compose**（包含 metrics）：
+```yaml
+version: '3.8'
+services:
+  vllm:
+    image: vllm/vllm-openai:latest
+    command: >
+      --model meta-llama/Llama-3-8B-Instruct
+      --gpu-memory-utilization 0.9
+      --enable-metrics
+      --metrics-port 9090
+    ports:
+      - "8000:8000"
+      - "9090:9090"
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: all
+              capabilities: [gpu]
+```
+
+## Kubernetes 部署
+
+**Deployment manifest**：
+```yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: vllm-server
+spec:
+  replicas: 2
+  selector:
+    matchLabels:
+      app: vllm
+  template:
+    metadata:
+      labels:
+        app: vllm
+    spec:
+      containers:
+      - name: vllm
+        image: vllm/vllm-openai:latest
+        args:
+          - "--model=meta-llama/Llama-3-8B-Instruct"
+          - "--gpu-memory-utilization=0.9"
+          - "--enable-prefix-caching"
+        resources:
+          limits:
+            nvidia.com/gpu: 1
+        ports:
+        - containerPort: 8000
+          name: http
+        - containerPort: 9090
+          name: metrics
+        readinessProbe:
+          httpGet:
+            path: /health
+            port: 8000
+          initialDelaySeconds: 30
+          periodSeconds: 10
+        livenessProbe:
+          httpGet:
+            path: /health
+            port: 8000
+          initialDelaySeconds: 60
+          periodSeconds: 30
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: vllm-service
+spec:
+  selector:
+    app: vllm
+  ports:
+  - port: 8000
+    targetPort: 8000
+    name: http
+  - port: 9090
+    targetPort: 9090
+    name: metrics
+  type: LoadBalancer
+```
+
+## 使用 Nginx 进行负载均衡
+
+**Nginx 配置**：
+```nginx
+upstream vllm_backend {
+    least_conn;  # 路由到负载最小的服务器
+    server localhost:8001;
+    server localhost:8002;
+    server localhost:8003;
+}
+
+server {
+    listen 80;
+
+    location / {
+        proxy_pass http://vllm_backend;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+
+        # 针对长时间运行推理的超时设置
+        proxy_read_timeout 300s;
+        proxy_connect_timeout 75s;
+    }
+
+    # 指标接口
+    location /metrics {
+        proxy_pass http://localhost:9090/metrics;
+    }
+}
+```
+
+**启动多个 vLLM 实例**：
+```bash
+# 终端 1
+vllm serve MODEL --port 8001 --tensor-parallel-size 1
+
+# 终端 2
+vllm serve MODEL --port 8002 --tensor-parallel-size 1
+
+# 终端 3
+vllm serve MODEL --port 8003 --tensor-parallel-size 1
+
+# 启动 Nginx
+nginx -c /path/to/nginx.conf
+```
+
+## 多节点分布式服务
+
+对于单节点无法容纳的超大模型：
+
+**节点 1**（master）：
+```bash
+export MASTER_ADDR=192.168.1.10
+export MASTER_PORT=29500
+export RANK=0
+export WORLD_SIZE=2
+
+vllm serve meta-llama/Llama-2-70b-hf \
+  --tensor-parallel-size 8 \
+  --pipeline-parallel-size 2
+```
+
+**节点 2**（worker）：
+```bash
+export MASTER_ADDR=192.168.1.10
+export MASTER_PORT=29500
+export RANK=1
+export WORLD_SIZE=2
+
+vllm serve meta-llama/Llama-2-70b-hf \
+  --tensor-parallel-size 8 \
+  --pipeline-parallel-size 2
+```
+
+## 生产环境配置示例
+
+**高吞吐量**（批处理密集型工作负载）：
+```bash
+vllm serve MODEL \
+  --max-num-seqs 512 \
+  --gpu-memory-utilization 0.95 \
+  --enable-prefix-caching \
+  --trust-remote-code
+```
+
+**低延迟**（交互式工作负载）：
+```bash
+vllm serve MODEL \
+  --max-num-seqs 64 \
+  --gpu-memory-utilization 0.85 \
+  --enable-chunked-prefill
+```
+
+**内存受限**（在 40GB GPU 上运行 70B 模型）：
+```bash
+vllm serve TheBloke/Llama-2-70B-AWQ \
+  --quantization awq \
+  --tensor-parallel-size 1 \
+  --gpu-memory-utilization 0.95 \
+  --max-model-len 4096
+```
+
+## 健康检查与监控
+
+**健康检查接口**：
+```bash
+curl http://localhost:8000/health
+# 返回：{"status": "ok"}
+```
+
+**就绪检查**（等待模型加载完成）：
+```bash
+#!/bin/bash
+until curl -f http://localhost:8000/health; do
+    echo "等待 vLLM 准备就绪..."
+    sleep 5
+done
+echo "vLLM 已准备就绪！"
+```
+
+**Prometheus 采集**：
+```yaml
+# prometheus.yml
+scrape_configs:
+  - job_name: 'vllm'
+    static_configs:
+      - targets: ['localhost:9090']
+    metrics_path: '/metrics'
+    scrape_interval: 15s
+```
+
+**Grafana 面板**（关键指标）：
+- 每秒请求数：`rate(vllm_request_success_total[5m])`
+- TTFT p50：`histogram_quantile(0.5, vllm_time_to_first_token_seconds_bucket)`
+- TTFT p99：`histogram_quantile(0.99, vllm_time_to_first_token_seconds_bucket)`
+- GPU 缓存使用率：`vllm_gpu_cache_usage_perc`
+- 活跃请求数：`vllm_num_requests_running`