@baimingtao/lbs-agent 1.0.0

package/extensions/skills/optional/mlops/tensorrt-llm/SKILL.md

@@ -0,0 +1,189 @@
+---
+name: tensorrt-llm
+description: 使用 NVIDIA TensorRT 优化 LLM 推理，以实现最大吞吐量和最低延迟。适用于在 NVIDIA GPU (A100/H100) 上进行生产部署，当您需要比 PyTorch 快 10-100 倍的推理速度时，或者用于提供带有量化 (FP8/INT4)、in-flight batching 和 multi-GPU scaling 的模型服务。
+version: 1.0.0
+author: Orchestra Research
+license: MIT
+dependencies: [tensorrt-llm, torch]
+platforms: [linux, macos]
+metadata:
+  hermes:
+    tags: [Inference Serving, TensorRT-LLM, NVIDIA, Inference Optimization, High Throughput, Low Latency, Production, FP8, INT4, In-Flight Batching, Multi-GPU]
+
+---
+
+# TensorRT-LLM
+
+NVIDIA 的开源库，用于在 NVIDIA GPU 上优化 LLM 推理并提供一流的性能。
+
+## 何时使用 TensorRT-LLM
+
+**在以下情况下使用 TensorRT-LLM：**
+- 在 NVIDIA GPU (A100, H100, GB200) 上部署
+- 需要最大吞吐量（在 Llama 3 上达到 24,000+ tokens/sec）
+- 实时应用需要低延迟
+- 使用量化模型 (FP8, INT4, FP4)
+- 跨多个 GPU 或节点扩展
+
+**在以下情况下请改用 vLLM：**
+- 需要更简单的设置和 Python 优先的 API
+- 需要 PagedAttention 但不想进行 TensorRT 编译
+- 使用 AMD GPU 或非 NVIDIA 硬件
+
+**在以下情况下请改用 llama.cpp：**
+- 在 CPU 或 Apple Silicon 上部署
+- 需要 没有 NVIDIA GPU 的边缘部署
+- 需要更简单的 GGUF 量化格式
+
+## 快速 start
+
+### 安装
+
+```bash
+# Docker (推荐)
+docker pull nvidia/tensorrt_llm:latest
+
+# pip install
+pip install tensorrt_llm==1.2.0rc3
+
+# 要求 CUDA 13.0.0, TensorRT 10.13.2, Python 3.10-3.12
+```
+
+### 基础 inference
+
+```python
+from tensorrt_llm import LLM, SamplingParams
+
+# 初始化模型
+llm = LLM(model="meta-llama/Meta-Llama-3-8B")
+
+# 配置采样
+sampling_params = SamplingParams(
+    max_tokens=100,
+    temperature=0.7,
+    top_p=0.9
+)
+
+# 生成
+prompts = ["Explain quantum computing"]
+outputs = llm.generate(prompts, sampling_params)
+
+for output in outputs:
+    print(output.text)
+```
+
+### 使用 trtllm-serve 提供服务
+
+```bash
+# 启动服务器 (自动下载和编译模型)
+trtllm-serve meta-llama/Meta-Llama-3-8B \
+    --tp_size 4 \              # Tensor parallelism (4 GPUs)
+    --max_batch_size 256 \
+    --max_num_tokens 4096
+
+# 客户端请求
+curl -X POST http://localhost:8000/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "meta-llama/Meta-Llama-3-8B",
+    "messages": [{"role": "user", "content": "Hello!"}],
+    "temperature": 0.7,
+    "max_tokens": 100
+  }'
+```
+
+## Key features
+
+### 性能优化
+- **In-flight batching**: 在生成期间进行动态批处理
+- **Paged KV cache**: 高效的内存管理
+- **Flash Attention**: 优化的 attention kernels
+- **Quantization**: FP8, INT4, FP4 可实现 2-4 倍更快的推理
+- **CUDA graphs**: 减少 kernel 启动开销
+
+### 并行
+- **Tensor parallelism (TP)**: 跨 GPU 拆分模型
+- **Pipeline parallelism (PP)**: 逐层分布
+- **Expert parallelism**: 用于 Mixture-of-Experts 模型
+- **Multi-node**: 扩展至单机之外
+
+### 高级 features
+- **Speculative decoding**: 使用 draft models 加快生成速度
+- **LoRA serving**: 高效的多适配器部署
+- **Disaggregated serving**: 分离 prefill 和 generation
+
+## 常见模式
+
+### 量化模型 (FP8)
+
+```python
+from tensorrt_llm import LLM
+
+# 加载 FP8 量化模型 (速度快 2 倍，内存占用 50%)
+llm = LLM(
+    model="meta-llama/Meta-Llama-3-70B",
+    dtype="fp8",
+    max_num_tokens=8192
+)
+
+# 推理与以前相同
+outputs = llm.generate(["Summarize this article..."])
+```
+
+### Multi-GPU 部署
+
+```python
+# 跨 8 个 GPU 的 Tensor parallelism
+llm = LLM(
+    model="meta-llama/Meta-Llama-3-405B",
+    tensor_parallel_size=8,
+    dtype="fp8"
+)
+```
+
+### 批量推理
+
+```python
+# 高效处理 100 个提示词
+prompts = [f"Question {i}: ..." for i in range(100)]
+
+outputs = llm.generate(
+    prompts,
+    sampling_params=SamplingParams(max_tokens=200)
+)
+
+# 自动进行 in-flight batching 以实现最大吞吐量
+```
+
+## 性能基准测试
+
+**Meta Llama 3-8B** (H100 GPU):
+- 吞吐量: 24,000 tokens/sec
+- 延迟: 每个 token 约 10ms
+- 对比 PyTorch: **快 100 倍**
+
+**Llama 3-70B** (8× A100 80GB):
+- FP8 量化: 比 FP16 快 2 倍
+- 内存: 使用 FP8 减少 50%
+
+## 支持的模型
+
+- **LLaMA 系列**: Llama 2, Llama 3, CodeLlama
+- **GPT 系列**: GPT-2, GPT-J, GPT-NeoX
+- **Qwen**: Qwen, Qwen2, QwQ
+- **DeepSeek**: DeepSeek-V2, DeepSeek-V3
+- **Mixtral**: Mixtral-8x7B, Mixtral-8x22B
+- **视觉**: LLaVA, Phi-3-vision
+- HuggingFace 上的 **100+ 模型**
+
+## 参考资料
+
+- **[Optimization Guide](references/optimization.md)** - 量化、批处理、KV cache 调优
+- **[Multi-GPU Setup](references/multi-gpu.md)** - Tensor/pipeline parallelism, multi-node
+- **[Serving Guide](references/serving.md)** - 生产部署、监控、自动伸缩
+
+## Resources
+
+- **Docs**: https://nvidia.github.io/TensorRT-LLM/
+- **GitHub**: https://github.com/NVIDIA/TensorRT-LLM
+- **Models**: https://huggingface.co/models?library=tensorrt_llm

package/extensions/skills/optional/mlops/tensorrt-llm/references/multi-gpu.md

@@ -0,0 +1,298 @@
+# 多 GPU 部署指南
+
+跨多个 GPU 和节点扩展 TensorRT-LLM 的综合指南。
+
+## 并行策略
+
+### Tensor Parallelism (TP)
+
+**功能**：将模型层进行水平切分。
+
+**适用场景**：
+- 模型能装入总 GPU 显存，但超出单张 GPU 显存
+- 需要低延迟（单次前向传播）
+- 同一节点内的 GPU（为了最佳性能需要 NVLink）
+
+**示例** (Llama 3-70B on 4× A100):
+```python
+from tensorrt_llm import LLM
+
+llm = LLM(
+    model="meta-llama/Meta-Llama-3-70B",
+    tensor_parallel_size=4,  # Split across 4 GPUs
+    dtype="fp16"
+)
+
+# Model automatically sharded across GPUs
+# Single forward pass, low latency
+```
+
+**性能表现**：
+- 延迟：与单 GPU 基本一致
+- 吞吐量：提升 4 倍（4 张 GPU）
+- 通信开销：高（每层都需要同步激活值）
+
+### Pipeline Parallelism (PP)
+
+**功能**：将模型层进行垂直切分（按层）。
+
+**适用场景**：
+- 超大模型 (175B+)
+- 可容忍较高延迟
+- 跨多个节点的 GPU
+
+**示例** (Llama 3-405B on 8× H100):
+```python
+llm = LLM(
+    model="meta-llama/Meta-Llama-3-405B",
+    tensor_parallel_size=4,   # TP=4 within nodes
+    pipeline_parallel_size=2, # PP=2 across nodes
+    dtype="fp8"
+)
+
+# Total: 8 GPUs (4×2)
+# Layers 0-40: Node 1 (4 GPUs with TP)
+# Layers 41-80: Node 2 (4 GPUs with TP)
+```
+
+**性能表现**：
+- 延迟：较高（需按流水线顺序执行）
+- 吞吐量：配合 micro-batching 可实现高吞吐量
+- 通信开销：低于 TP
+
+### Expert Parallelism (EP)
+
+**功能**：将 MoE experts 分布到多张 GPU 上。
+
+**适用场景**：Mixture-of-Experts 模型 (Mixtral, DeepSeek-V2)
+
+**示例** (Mixtral-8x22B on 8× A100):
+```python
+llm = LLM(
+    model="mistralai/Mixtral-8x22B",
+    tensor_parallel_size=4,
+    expert_parallel_size=2,  # Distribute 8 experts across 2 groups
+    dtype="fp8"
+)
+```
+
+## 配置示例
+
+### 小型模型 (7-13B) - 单 GPU
+
+```python
+# Llama 3-8B on 1× A100 80GB
+llm = LLM(
+    model="meta-llama/Meta-Llama-3-8B",
+    dtype="fp16"  # or fp8 for H100
+)
+```
+
+**资源消耗**：
+- GPU：1× A100 80GB
+- 显存：约 16GB 模型 + 30GB KV cache
+- 吞吐量：3,000-5,000 tokens/sec
+
+### 中型模型 (70B) - 同一节点多 GPU
+
+```python
+# Llama 3-70B on 4× A100 80GB (NVLink)
+llm = LLM(
+    model="meta-llama/Meta-Llama-3-70B",
+    tensor_parallel_size=4,
+    dtype="fp8"  # 70GB → 35GB per GPU
+)
+```
+
+**资源消耗**：
+- GPU：4× A100 80GB (配备 NVLink)
+- 显存：每张 GPU 约 35GB (FP8)
+- 吞吐量：10,000-15,000 tokens/sec
+- 延迟：15-20ms / token
+
+### 大型模型 (405B) - 多节点
+
+```python
+# Llama 3-405B on 2 nodes × 8 H100 = 16 GPUs
+llm = LLM(
+    model="meta-llama/Meta-Llama-3-405B",
+    tensor_parallel_size=8,    # TP within each node
+    pipeline_parallel_size=2,  # PP across 2 nodes
+    dtype="fp8"
+)
+```
+
+**资源消耗**：
+- GPU：2 个节点 × 8 H100 80GB
+- 显存：每张 GPU 约 25GB (FP8)
+- 吞吐量：20,000-30,000 tokens/sec
+- 网络：推荐使用 InfiniBand
+
+## 服务端部署
+
+### 单节点多 GPU
+
+```bash
+# Llama 3-70B on 4 GPUs (automatic TP)
+trtllm-serve meta-llama/Meta-Llama-3-70B \
+    --tp_size 4 \
+    --max_batch_size 256 \
+    --dtype fp8
+
+# Listens on http://localhost:8000
+```
+
+### 结合 Ray 的多节点部署
+
+```bash
+# Node 1 (head node)
+ray start --head --port=6379
+
+# Node 2 (worker)
+ray start --address='node1:6379'
+
+# Deploy across cluster
+trtllm-serve meta-llama/Meta-Llama-3-405B \
+    --tp_size 8 \
+    --pp_size 2 \
+    --num_workers 2 \  # 2 nodes
+    --dtype fp8
+```
+
+### Kubernetes 部署
+
+```yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: tensorrt-llm-llama3-70b
+spec:
+  replicas: 1
+  template:
+    spec:
+      containers:
+      - name: trtllm
+        image: nvidia/tensorrt_llm:latest
+        command:
+          - trtllm-serve
+          - meta-llama/Meta-Llama-3-70B
+          - --tp_size=4
+          - --max_batch_size=256
+        resources:
+          limits:
+            nvidia.com/gpu: 4  # Request 4 GPUs
+```
+
+## 并行策略决策树
+
+```
+Model size < 20GB?
+├─ YES: Single GPU (no parallelism)
+└─ NO: Model size < 80GB?
+    ├─ YES: TP=2 or TP=4 (same node)
+    └─ NO: Model size < 320GB?
+        ├─ YES: TP=4 or TP=8 (same node, NVLink required)
+        └─ NO: TP=8 + PP=2 (multi-node)
+```
+
+## 通信优化
+
+### NVLink 与 PCIe
+
+**NVLink** (DGX A100, HGX H100):
+- 带宽：600 GB/s (A100), 900 GB/s (H100)
+- 理想适用于 TP (通信频繁)
+- **推荐用于所有多 GPU 配置**
+
+**PCIe**:
+- 带宽：64 GB/s (PCIe 4.0 x16)
+- 比 NVLink 慢 10 倍
+- 应避免用于 TP，可使用 PP 替代
+
+### 用于多节点的 InfiniBand
+
+**HDR InfiniBand** (200 Gb/s):
+- 多节点 TP 或 PP 的必需配置
+- 延迟：<1μs
+- **405B 及以上大模型的必备条件**
+
+## 多 GPU 监控
+
+```python
+# Monitor GPU utilization
+nvidia-smi dmon -s u
+
+# Monitor memory
+nvidia-smi dmon -s m
+
+# Monitor NVLink utilization
+nvidia-smi nvlink --status
+
+# TensorRT-LLM built-in metrics
+curl http://localhost:8000/metrics
+```
+
+**关键指标**：
+- GPU 利用率：目标在 80-95%
+- 显存使用：各 GPU 间应保持均衡
+- NVLink 流量：TP 模式下较高，PP 模式下较低
+- 吞吐量：所有 GPU 的 tokens/sec 总和
+
+## 常见问题
+
+### GPU 显存不均衡
+
+**症状**：GPU 0 占用 90% 显存，GPU 3 占用 40%
+
+**解决方案**：
+- 检查 TP/PP 配置
+- 查看模型切分情况（应保持均等）
+- 重启服务以重置状态
+
+### NVLink 利用率低
+
+**症状**：TP=4 时，NVLink 带宽 <100 GB/s
+
+**解决方案**：
+- 确认 NVLink 拓扑：`nvidia-smi topo -m`
+- 检查是否回退到了 PCIe 通信
+- 确保 GPU 连接在同一个 NVSwitch 上
+
+### 多 GPU 出现 OOM
+
+**解决方案**：
+- 增大 TP size（使用更多 GPU）
+- 减小 batch size
+- 启用 FP8 quantization
+- 使用 pipeline parallelism
+
+## 性能扩展表现
+
+### TP 扩展表现 (Llama 3-70B, FP8)
+
+| GPUs | TP Size | 吞吐量 | 延迟 | 效率 |
+|------|---------|------------|---------|------------|
+| 1 | 1 | OOM | - | - |
+| 2 | 2 | 6,000 tok/s | 18ms | 85% |
+| 4 | 4 | 11,000 tok/s | 16ms | 78% |
+| 8 | 8 | 18,000 tok/s | 15ms | 64% |
+
+**注意**：GPU 数量增多会导致通信开销增加，从而引起效率下降。
+
+### PP 扩展表现 (Llama 3-405B, FP8)
+
+| Nodes | TP | PP | Total GPUs | 吞吐量 |
+|-------|----|----|------------|------------|
+| 1 | 8 | 1 | 8 | OOM |
+| 2 | 8 | 2 | 16 | 25,000 tok/s |
+| 4 | 8 | 4 | 32 | 45,000 tok/s |
+
+## 最佳实践
+
+1. **条件允许时优先使用 TP 而非 PP**（延迟更低）
+2. **所有 TP 部署均应使用 NVLink**
+3. **多节点部署需使用 InfiniBand**
+4. **在模型能放入显存的前提下，从最小的 TP 配置开始尝试**
+5. **监控 GPU 负载均衡** - 所有 GPU 的利用率应大致接近
+6. **正式投入生产前先运行 benchmark 进行测试**
+7. **在 H100 上使用 FP8** 可获得 2 倍速度提升

package/extensions/skills/optional/mlops/tensorrt-llm/references/optimization.md

@@ -0,0 +1,242 @@
+# TensorRT-LLM 优化指南
+
+使用 TensorRT-LLM 优化 LLM 推理的全面指南。
+
+## Quantization
+
+### FP8 Quantization（H100 推荐）
+
+**优点**：
+- 推理速度提升 2 倍
+- 显存占用减少 50%
+- 精度损失极小（perplexity 下降 <1%）
+
+**用法**：
+```python
+from tensorrt_llm import LLM
+
+# Automatic FP8 quantization
+llm = LLM(
+    model="meta-llama/Meta-Llama-3-70B",
+    dtype="fp8",
+    quantization="fp8"
+)
+```
+
+**性能表现**（Llama 3-70B 运行于 8× H100）：
+- FP16: 5,000 tokens/sec
+- FP8: **10,000 tokens/sec**（速度提升 2 倍）
+- 显存占用: 140GB → 70GB
+
+### INT4 Quantization（极致压缩）
+
+**优点**：
+- 显存占用减少 4 倍
+- 推理速度提升 3-4 倍
+- 可在同一硬件上运行更大的模型
+
+**用法**：
+```python
+# INT4 with AWQ calibration
+llm = LLM(
+    model="meta-llama/Meta-Llama-3-405B",
+    dtype="int4_awq",
+    quantization="awq"
+)
+
+# INT4 with GPTQ calibration
+llm = LLM(
+    model="meta-llama/Meta-Llama-3-405B",
+    dtype="int4_gptq",
+    quantization="gptq"
+)
+```
+
+**权衡**：
+- 精度：perplexity 增加 1-3%
+- 速度：比 FP16 快 3-4 倍
+- 适用场景：当显存极其有限时
+
+## In-Flight Batching
+
+**功能**：在生成阶段动态 batch 请求，而无需等待所有 sequence 完成。
+
+**配置**：
+```python
+# Server configuration
+trtllm-serve meta-llama/Meta-Llama-3-8B \
+    --max_batch_size 256 \           # Maximum concurrent sequences
+    --max_num_tokens 4096 \           # Total tokens in batch
+    --enable_chunked_context \        # Split long prompts
+    --scheduler_policy max_utilization
+```
+
+**性能表现**：
+- 吞吐量：比静态 batching **高 4-8 倍**
+- 延迟：在混合负载下具有更低的 P50/P99 延迟
+- GPU 利用率：80-95%（对比原先的 40-60%）
+
+## Paged KV Cache
+
+**功能**：像操作系统管理虚拟内存（paging）一样管理 KV cache 内存。
+
+**优点**：
+- 吞吐量提高 40-60%
+- 无内存碎片
+- 支持更长的 sequence
+
+**配置**：
+```python
+# Automatic paged KV cache (default)
+llm = LLM(
+    model="meta-llama/Meta-Llama-3-8B",
+    kv_cache_free_gpu_mem_fraction=0.9,  # Use 90% GPU mem for cache
+    enable_prefix_caching=True            # Cache common prefixes
+)
+```
+
+## Speculative Decoding
+
+**功能**：使用小型 draft model 预测多个 token，并由目标模型并行验证。
+
+**加速效果**：在长文本生成中速度提升 2-3 倍
+
+**用法**：
+```python
+from tensorrt_llm import LLM
+
+# Target model (Llama 3-70B)
+llm = LLM(
+    model="meta-llama/Meta-Llama-3-70B",
+    speculative_model="meta-llama/Meta-Llama-3-8B",  # Draft model
+    num_speculative_tokens=5                          # Tokens to predict ahead
+)
+
+# Same API, 2-3× faster
+outputs = llm.generate(prompts)
+```
+
+**最佳的 drafting 模型组合**：
+- 目标模型：Llama 3-70B → Draft 模型：Llama 3-8B
+- 目标模型：Qwen2-72B → Draft 模型：Qwen2-7B
+- 模型同系列，参数量小 8-10 倍
+
+## CUDA Graphs
+
+**功能**：通过录制 GPU 操作来减少 kernel 启动开销。
+
+**优点**：
+- 延迟降低 10-20%
+- P99 延迟更加稳定
+- 对小 batch size 效果更好
+
+**配置**（默认自动启用）：
+```python
+llm = LLM(
+    model="meta-llama/Meta-Llama-3-8B",
+    enable_cuda_graph=True,  # Default: True
+    cuda_graph_cache_size=2  # Cache 2 graph variants
+)
+```
+
+## Chunked Context
+
+**功能**：将长 prompt 切分为 chunk，以减少显存占用峰值。
+
+**适用场景**：显存有限且 prompt 长度 >8K tokens
+
+**配置**：
+```bash
+trtllm-serve meta-llama/Meta-Llama-3-8B \
+    --max_num_tokens 4096 \
+    --enable_chunked_context \
+    --max_chunked_prefill_length 2048  # Process 2K tokens at a time
+```
+
+## Overlap Scheduling
+
+**功能**：重叠计算与内存操作。
+
+**优点**：
+- 吞吐量提升 15-25%
+- 提升 GPU 利用率
+- v1.2.0+ 版本中默认启用
+
+**无需配置** - 自动启用。
+
+## Quantization 对比表
+
+| 方法 | Memory | Speed | Accuracy | Use Case |
+| -------- | -------- | ------- | ---------- | ---------- |
+| FP16 | 1× (baseline) | 1× | Best | High accuracy needed |
+| FP8 | 0.5× | 2× | -0.5% ppl | **H100 default** |
+| INT4 AWQ | 0.25× | 3-4× | -1.5% ppl | Memory critical |
+| INT4 GPTQ | 0.25× | 3-4× | -2% ppl | Maximum speed |
+
+## 调优工作流
+
+1. **从默认配置开始**：
+   ```python
+   llm = LLM(model="meta-llama/Meta-Llama-3-70B")
+   ```
+
+2. **启用 FP8**（如果是 H100）：
+   ```python
+   llm = LLM(model="...", dtype="fp8")
+   ```
+
+3. **调整 batch size**：
+   ```python
+   # Increase until OOM, then reduce 20%
+   trtllm-serve ... --max_batch_size 256
+   ```
+
+4. **启用 chunked context**（如果有长 prompt）：
+   ```bash
+   --enable_chunked_context --max_chunked_prefill_length 2048
+   ```
+
+5. **尝试 speculative decoding**（如果对延迟极其敏感）：
+   ```python
+   llm = LLM(model="...", speculative_model="...")
+   ```
+
+## Benchmarking
+
+```bash
+# Install benchmark tool
+pip install tensorrt_llm[benchmark]
+
+# Run benchmark
+python benchmarks/python/benchmark.py \
+    --model meta-llama/Meta-Llama-3-8B \
+    --batch_size 64 \
+    --input_len 128 \
+    --output_len 256 \
+    --dtype fp8
+```
+
+**需要关注的指标**：
+- 吞吐量 (tokens/sec)
+- 延迟 P50/P90/P99 (ms)
+- GPU 显存使用量 (GB)
+- GPU 利用率 (%)
+
+## 常见问题
+
+**OOM 错误**：
+- 减小 `max_batch_size`
+- 减小 `max_num_tokens`
+- 启用 INT4 quantization
+- 增大 `tensor_parallel_size`
+
+**吞吐量低**：
+- 增大 `max_batch_size`
+- 启用 in-flight batching
+- 确认已启用 CUDA graphs
+- 检查 GPU 利用率
+
+**延迟高**：
+- 尝试 speculative decoding
+- 减小 `max_batch_size`（减少排队）
+- 使用 FP8 代替 FP16