推理引擎

推理引擎：LLM服务的核心基础设施 模型只是"大脑"，推理引擎是"神经系统"——它决定了模型服务能多快、能并发多少请求、成本多低。选对推理引擎，单GPU的吞吐量差异可达5-10倍。 三大主流引擎 vLLM：社区标准 架构特点： PagedAttention：操作系统级KV Cache管理 Continuous Batching：迭代级动态批处理 纯Python实现（核心算子用CUDA/Triton） 支持大多数主流开源模型 核心技术：PagedAttention 传统KV Cache: 请求A: [已分配 5/5 blocks] [等待分配...] 请求B: [已分配 3/3 blocks] → 内存碎片化，浪费30-60% PagedAttention: Block Pool: [A1][B1][A2][C1][B2][A3]... 每个请求通过页表映射到物理block → 零碎片，内存利用率接近100% 性能特征： 吞吐量：比HuggingFace Transformers高24倍 首token延迟：中等 显存利用率：90%+ 支持多模型共享GPU 优势： 社区支持最广，几乎所有模型首发支持 部署简单（一行命令启动） 持续迭代，功能快速扩展 劣势： 纯Python实现，某些热路径不如C++优化 不支持一些极致优化（如FP8推理） 调度策略相对简单 SGLang：结构化生成之王 架构特点： 前缀缓存（Prefix Caching）：跨请求共享计算 程序化生成：支持结构化输出约束 原生支持JSON/正则约束 C++核心，Python接口 核心技术：RadixAttention 请求1: "system: 你是助手\nuser: 天气" → 缓存KV Cache 请求2: "system: 你是助手\nuser: 股票" → 复用"system: 你是助手\n"的前缀KV Cache → 只需计算新的部分 多请求共享相同system prompt时，前缀缓存可节省50%+计算。 ...

推理引擎：大模型生产的最后一公里 模型训练完成后，推理引擎决定了它能否高效地服务用户。同样的模型，用不同的推理引擎部署，吞吐量可能相差5-10倍。vLLM、SGLang和TensorRT-LLM是当前最主流的三大推理引擎，各有特色。 三大引擎概述 vLLM vLLM由UC Berkeley团队开发，以PagedAttention技术闻名： from vllm import LLM, SamplingParams llm = LLM( model="meta-llama/Meta-Llama-3-70B", tensor_parallel_size=4, # 4卡张量并行 gpu_memory_utilization=0.90, max_model_len=8192, enable_prefix_caching=True, # 前缀缓存 swap_space=16, # CPU swap空间(GB) ) sampling = SamplingParams( temperature=0.7, top_p=0.9, max_tokens=512, ) outputs = llm.generate(["你好，介绍一下自己"], sampling) 核心技术： PagedAttention：虚拟内存式KV Cache管理 Continuous Batching：动态批处理 Prefix Caching：共享前缀缓存 支持多种量化（AWQ、GPTQ、FP8） SGLang SGLang由UC Berkeley团队（vLLM部分成员）开发，专注于结构化生成： import sglang as sgl @sgl.function def multi_step_reasoning(s, question): s += "请分析以下问题：" + question s += "第一步：理解问题" + sgl.gen("understanding", max_tokens=200) s += "第二步：分析方案" + sgl.gen("analysis", max_tokens=300) s += "第三步：结论" + sgl.gen("conclusion", max_tokens=200) # RadixAttention自动缓存前缀 engine = sgl.Engine( model_path="meta-llama/Meta-Llama-3-70B", tp_size=4, ) result = multi_step_reasoning.run(question="AI对就业市场的影响") 核心技术： RadixAttention：基于基数树的前缀缓存，比vLLM的前缀缓存更高效 结构化生成：JSON、正则表达式约束的生成 前端DSL：Python装饰器定义生成流程 多轮对话优化：对话前缀自动复用 TensorRT-LLM NVIDIA官方推理引擎，与硬件深度优化： import tensorrt_llm from tensorrt_llm.runtime import ModelRunner # 构建引擎（需先转换模型） builder = tensorrt_llm.Builder() config = builder.create_builder_config( max_batch_size=128, max_input_len=8192, max_output_len=1024, use_fp8=True, # FP8量化 use_paged_kv_cache=True, tokens_per_block=128, ) engine = builder.build_engine(model, config) # 运行推理 runner = ModelRunner(engine) outputs = runner.generate( input_ids=input_ids, sampling_config=sampling_config ) 核心技术： ...

引言 vLLM是2026年最流行的高性能LLM推理引擎。从PagedAttention到连续批处理，vLLM不断创新推理优化技术。本文将全面介绍2026年vLLM社区的最新进展。 vLLM 2026核心特性 PagedAttention 2.0 vLLM的招牌技术，2026年升级到2.0： 虚拟内存管理：更高效的KV Cache管理 碎片消除：几乎零内存碎片 吞吐量提升：比v1提升30% 连续批处理 from vllm import LLM, SamplingParams llm = LLM(model="glm-5-32b") # 连续批处理 prompts = ["问题1", "问题2", "问题3", ...] sampling_params = SamplingParams(temperature=0.7, max_tokens=500) outputs = llm.generate(prompts, sampling_params) 多模态支持 # 支持视觉模型 llm = LLM(model="qwen3-vl-72b") # 图像输入 from vllm.multimodal import ImageFeature outputs = llm.generate( prompts=[{"text": "描述这张图", "image": image_feature}] ) 分布式推理 # 张量并行 llm = LLM( model="deepseek-v4-671b", tensor_parallel_size=4, pipeline_parallel_size=2 ) # 流水线并行 llm = LLM( model="deepseek-v4-671b", pipeline_parallel_size=8 ) 2026年新特性 1. Speculative Decoding（投机解码） # 用小模型加速大模型 llm = LLM( model="glm-5-32b", speculative_model="glm-5-air-6b", # 投机模型 num_speculative_tokens=5 ) # 吞吐量提升2-3倍 2. 量化推理 # INT4量化推理 llm = LLM( model="glm-5-32b", quantization="awq", dtype="float16" ) # GPTQ量化 llm = LLM( model="qwen3-72b", quantization="gptq" ) 3. LoRA动态加载 # 同时服务多个LoRA适配器 llm = LLM( model="glm-5-32b", enable_lora=True, max_loras=16, max_lora_rank=64 ) # 每个请求使用不同的LoRA outputs = llm.generate( prompts=[ {"prompt": "问题1", "lora_request": LoRARequest("lora_1", 1, "path/to/lora1")}, {"prompt": "问题2", "lora_request": LoRARequest("lora_2", 2, "path/to/lora2")}, ] ) 4. 语法引导生成 # 约束输出为JSON from vllm.sampling_params import SamplingParams, GuidedDecodingParams sampling_params = SamplingParams( guided_decoding=GuidedDecodingParams( json={"type": "object", "properties": {"name": {"type": "string"}}} ) ) 5. 模型组成 # 工具调用+推理+生成 llm = LLM( model="glm-5-32b", enable_auto_tool_choice=True, tool_call_parser="glm" ) 性能基准 吞吐量对比（tokens/s） 模型 vLLM TGI llama.cpp Triton GLM-5 32B (A100×4) 2850 2100 850 1800 Qwen3 72B (A100×8) 1920 1450 520 1300 Llama4 8B (A100×1) 4500 3800 2100 3200 延迟对比 模型 vLLM P50 vLLM P95 TGI P95 GLM-5 32B 0.8s 2.1s 3.5s Qwen3 7B 0.2s 0.5s 0.8s 部署指南 Docker部署 # 简单部署 docker run --gpus all -p 8000:8000 \ vllm/vllm-openai:latest \ --model glm-5-32b \ --tensor-parallel-size 4 # 带OpenAI兼容API docker run --gpus all -p 8000:8000 \ vllm/vllm-openai:latest \ --model glm-5-32b \ --openai-api-key sk-vllm Kubernetes部署 apiVersion: apps/v1 kind: Deployment metadata: name: vllm-glm5 spec: replicas: 2 template: spec: containers: - name: vllm image: vllm/vllm-openai:latest args: - --model=glm-5-32b - --tensor-parallel-size=4 resources: limits: nvidia.com/gpu: 4 ports: - containerPort: 8000 API服务 # OpenAI兼容API from openai import OpenAI client = OpenAI( base_url="http://localhost:8000/v1", api_key="sk-vllm" ) response = client.chat.completions.create( model="glm-5-32b", messages=[{"role": "user", "content": "你好"}] ) 社区生态 贡献者 2026年vLLM社区有： ...

Hermes Agent：面向企业的智能体架构 Hermes Agent（爱马仕智能体）是 2026 年企业级 Agent 领域的一匹黑马。它由前 Google Brain 和 Meta AI 团队成员联合创建，定位为"企业级通用智能体操作系统"。与消费级 Agent 不同，Hermes 从第一天起就为生产环境设计，在可靠性、安全性和可扩展性方面树立了新的标杆。 核心设计理念 Hermes 的架构设计围绕三个核心理念： 确定性优先：在需要确定性的场景中，使用状态机而非自由对话 可解释性：每一步决策都有完整的推理链和置信度评分 渐进式自主：从辅助人类到自主执行的渐进路径 技术架构总览 ┌──────────────────────────────────────────────────────────┐ │ Interaction Layer │ │ REST API │ gRPC │ WebSocket │ SDK │ CLI │ IDE Plugin │ └─────────────────────┬────────────────────────────────────┘ │ ┌─────────────────────┴────────────────────────────────────┐ │ Orchestration Layer │ │ ┌────────────┐ ┌─────────────┐ ┌──────────────────┐ │ │ │ Planner │ │ Executor │ │ Reflector │ │ │ │ (规划引擎) │ │ (执行引擎) │ │ (反思引擎) │ │ │ └────────────┘ └─────────────┘ └──────────────────┘ │ │ ┌────────────┐ ┌─────────────┐ ┌──────────────────┐ │ │ │ Memory │ │ Knowledge │ │ Safety Guard │ │ │ │ (记忆) │ │ (知识库) │ │ (安全护栏) │ │ │ └────────────┘ └─────────────┘ └──────────────────┘ │ └─────────────────────┬────────────────────────────────────┘ │ ┌─────────────────────┴────────────────────────────────────┐ │ Execution Layer │ │ Code Sandbox │ API Gateway │ Data Pipeline │ ML Pipeline │ └─────────────────────┬────────────────────────────────────┘ │ ┌─────────────────────┴────────────────────────────────────┐ │ Infrastructure Layer │ │ Kubernetes │ Service Mesh │ Observability │ Secret Mgmt │ └──────────────────────────────────────────────────────────┘ 核心组件深度解析 1. Planner（规划引擎） Hermes 的规划引擎支持两种模式： ...

MLX：Apple 的 AI 底座 MLX 是 Apple 在 2023 年底开源的机器学习框架，专为 Apple Silicon（M1-M4 系列）设计。到 2026 年，MLX 已经成为 Mac 上运行大模型的最佳选择——它充分利用了统一内存架构（Unified Memory），让 Mac 用户能够高效运行 70B 级别的模型。 与 CUDA + vLLM 的组合类似，MLX + mlx-lm 是 Mac 用户的"本地大模型推理方案"。 Apple Silicon 的独特优势 统一内存架构 传统 PC 架构： ┌─────────┐ ┌──────────┐ │ CPU │────│ GPU VRAM │ │ RAM │ │ 24 GB │ │ 64 GB │ └──────────┘ └─────────┘ 数据需要在 CPU RAM 和 GPU VRAM 之间拷贝 Apple Silicon 架构： ┌─────────────────────────┐ │ Unified Memory │ │ 128 GB │ │ ┌─────┐ ┌─────┐ │ │ │ CPU │ │ GPU │ │ │ │ Cores│ │Cores│ │ │ └─────┘ └─────┘ │ │ ┌─────┐ ┌─────┐ │ │ │Neural│ │Media│ │ │ │Engine│ │Engine│ │ │ └─────┘ └─────┘ │ └─────────────────────────┘ CPU 和 GPU 共享同一块内存，零拷贝 Mac GPU 内存对照 Mac 型号 统一内存 可用于 LLM 推荐最大模型 M3 MacBook Air 16 GB ~10 GB 7B (Q4) M3 Pro MacBook 36 GB ~28 GB 32B (Q4) M3 Max MacBook 64 GB ~52 GB 72B (Q4) M3 Max MacBook 128 GB ~110 GB 72B (Q8) M4 Max Mac Studio 128 GB ~112 GB 72B (Q8) M4 Ultra Mac Studio 256 GB ~230 GB 120B (Q8) MLX 核心能力 安装 # 安装 MLX 和 mlx-lm pip install mlx-lm # 或安装完整 MLX pip install mlx 基础推理 from mlx_lm import load, generate # 加载模型 model, tokenizer = load( "mlx-community/Qwen2.5-32B-Instruct-4bit", # MLX 自动选择最优量化方案 # 4bit 模型约 18 GB 内存 ) # 生成 response = generate( model, tokenizer, prompt="解释量子纠缠", max_tokens=512, temp=0.7, top_p=0.9, verbose=True # 显示 token 速度 ) # 流式生成 from mlx_lm import stream_generate for token in stream_generate( model, tokenizer, prompt="写一首关于春天的诗", max_tokens=200 ): print(token.text, end="", flush=True) OpenAI 兼容 API 服务 from mlx_lm.server import run_server # 启动 API 服务器 run_server( model="mlx-community/Qwen2.5-32B-Instruct-4bit", host="0.0.0.0", port=8080, # API 兼容 OpenAI ) # 或通过命令行启动 mlx_lm.server \ --model mlx-community/Qwen2.5-32B-Instruct-4bit \ --port 8080 \ --host 0.0.0.0 # 使用 OpenAI SDK 调用 from openai import OpenAI client = OpenAI(base_url="http://localhost:8080/v1", api_key="mlx") response = client.chat.completions.create( model="default", messages=[{"role": "user", "content": "Hello!"}], stream=True ) 模型转换 import mlx.core as mx from mlx_lm import convert # 将 HuggingFace 模型转换为 MLX 格式 convert( hf_path="Qwen/Qwen2.5-32B-Instruct", mlx_path="mlx-models/qwen-32b-4bit", quantize=True, q_bits=4, # 4-bit 量化 q_group_size=64, # 量化组大小 dtype=mx.float16, ) # 转换后可以直接加载使用 model, tokenizer = load("mlx-models/qwen-32b-4bit") 多模态推理 from mlx_vlm import load, generate from mlx_vlm.prompt_utils import apply_chat_template from mlx_vlm.utils import load_config # 加载多模态模型 model, processor = load("mlx-community/Qwen2.5-VL-32B-Instruct-4bit") config = load_config("mlx-community/Qwen2.5-VL-32B-Instruct-4bit") # 图像理解 image = "path/to/image.jpg" prompt = "描述这张图片的内容" formatted_prompt = apply_chat_template( processor, config, prompt, num_images=1 ) output = generate( model, processor, formatted_prompt, [image], max_tokens=500, verbose=True ) 性能优化 量化策略 import mlx.core as mx # 不同量化方案对比 quantization_configs = { "4bit": {"bits": 4, "group_size": 64}, # 最省内存 "6bit": {"bits": 6, "group_size": 64}, # 平衡 "8bit": {"bits": 8, "group_size": 64}, # 最高质量 "4bit_gs128": {"bits": 4, "group_size": 128}, # 大组，更快 } # 性能对比（M3 Max, Qwen2.5-32B） # | 方案 | 内存 | 速度 | 质量 | # |---------|-------|-----------|------| # | 4bit | 18 GB | 42 tok/s | 良 | # | 6bit | 26 GB | 38 tok/s | 优 | # | 8bit | 34 GB | 35 tok/s | 最优 | # | 4bit_gs | 18 GB | 48 tok/s | 良 | 内存优化 from mlx_lm import load, generate import mlx.core as mx # 1. 使用统一内存 mx.metal.set_memory_limit(48 * 1024 * 1024 * 1024) # 48 GB 限制 # 2. 启用内存回收 mx.metal.set_memory_efficient(True) # 3. KV Cache 量化 model, tokenizer = load( "mlx-community/Qwen2.5-32B-Instruct-4bit", kv_cache_quantization=True, # KV Cache 4bit 量化 kv_cache_bits=4, ) # 4. 长上下文优化 generate( model, tokenizer, prompt="长文本...", max_tokens=4096, # MLX 自动管理 KV Cache # 统一内存让长上下文更高效 ) 性能基准 Mac 型号 模型 量化 速度 (tok/s) 首 Token 内存 M3 Air 16GB Qwen2.5-7B 4bit 28 0.8s 5 GB M3 Pro 36GB Qwen2.5-14B 4bit 45 0.4s 9 GB M3 Max 64GB Qwen2.5-32B 4bit 42 0.5s 20 GB M3 Max 128GB Qwen2.5-72B 4bit 18 1.2s 42 GB M3 Max 128GB Qwen2.5-72B 8bit 15 1.5s 75 GB M4 Max 128GB Qwen2.5-72B 4bit 28 0.8s 42 GB M4 Ultra 256GB Qwen3-120B 8bit 22 1.0s 130 GB 与 Ollama 对比（M3 Max 64GB） 指标 MLX Ollama 差异 Qwen2.5-7B 速度 32 tok/s 28 tok/s +14% Qwen2.5-32B 速度 42 tok/s 45 tok/s -7% Qwen2.5-72B 速度 18 tok/s 18.5 tok/s -3% 首Token延迟 0.5s 0.8s -37% 内存占用 18 GB 20 GB -10% 模型加载 3s 6s -50% MLX 在小模型和首 Token 延迟上更优，Ollama 在大模型上略快。两者差距很小。 ...

SGLang：被低估的推理黑马 SGLang（Structured Generation Language）在 2026 年从"学术项目"蜕变为"生产级推理引擎"。由 LMSYS 团队（ChatBot Arena 的创建者）开发，SGLang 的核心创新是 RadixAttention——一种基于基数树的 KV Cache 复用技术，在多轮对话和复杂 Agent 场景中实现了惊人的性能提升。 核心技术创新 1. RadixAttention RadixAttention 是 SGLang 的标志性技术。它将 KV Cache 组织为基数树结构，实现前缀复用： 传统方案：每个请求独立维护 KV Cache ┌──────┐ ┌──────┐ ┌──────┐ │Req 1 │ │Req 2 │ │Req 3 │ │KV │ │KV │ │KV │ │Cache │ │Cache │ │Cache │ └──────┘ └──────┘ └──────┘ 浪费：相同前缀重复计算 RadixAttention：共享前缀的 KV Cache ┌─ "用户: 你好" (共享) │ ├─ "助手: 你好！有什么可以帮您？" (Req 1) │ └─ "助手: 您好！请问需要什么帮助？" (Req 2) └─ "用户: 写代码" (共享) └─ "助手: 好的，请告诉我..." (Req 3) import sglang as sgl # RadixAttention 自动复用前缀 @sgl.function def multi_turn_chat(s, question): s += "以下是一个专业对话：\n" s += "用户: " + question + "\n" s += "助手: " + sgl.gen("answer", max_tokens=256) # 多轮对话中，前缀自动复用 # 第一轮 state1 = multi_turn_chat.run(question="什么是 RAG？") # 第二轮（复用第一轮的前缀） state2 = multi_turn_chat.run(question="RAG 和微调有什么区别？") # 第三轮（复用前两轮的前缀） state3 = multi_turn_chat.run(question="如何结合使用？") # KV Cache 复用率随轮次增加而提高 # 实测：5 轮对话后，KV Cache 复用率达 85%+ 2. 结构化输出 SGLang 原生支持 JSON Schema 约束生成： ...

TGI 2026：HuggingFace 的推理引擎 Text Generation Inference（TGI）是 HuggingFace 推出的大模型推理服务框架。与 vLLM 并列为开源推理引擎双雄。2026 年，TGI 在企业级特性方面持续强化，成为 HuggingFace 生态（Hub + Inference Endpoints + TGI）的核心组件。 2026 架构概览 ┌──────────────────────────────────────────────────┐ │ Client Layer │ │ REST API │ gRPC │ WebSocket │ Python/JS SDK │ ├──────────────────────────────────────────────────┤ │ Router Layer │ │ ┌────────────┐ ┌──────────┐ ┌────────────────┐ │ │ │ Load │ │ Queue │ │ Response │ │ │ │ Balancer │ │ Manager │ │ Aggregator │ │ │ └────────────┘ └──────────┘ └────────────────┘ │ ├──────────────────────────────────────────────────┤ │ Inference Layer │ │ ┌────────────┐ ┌──────────┐ ┌────────────────┐ │ │ │ Continuous │ │ Flash │ │ Speculative │ │ │ │ Batching │ │ Attention│ │ Decoding │ │ │ └────────────┘ └──────────┘ └────────────────┘ │ │ ┌────────────┐ ┌──────────┐ ┌────────────────┐ │ │ │ Tensor │ │ Pipeline │ │ Quantization │ │ │ │ Parallel │ │ Parallel │ │ (AWQ/GPTQ/FP8) │ │ │ └────────────┘ └──────────┘ └────────────────┘ │ ├──────────────────────────────────────────────────┤ │ Model Layer │ │ Safetensors │ GGUF │ Tokenizer │ Config │ └──────────────────────────────────────────────────┘ TGI vs vLLM 定位差异 维度 TGI vLLM 核心优势 HF 生态集成 极致吞吐量 部署方式 Docker 优先 灵活部署 模型格式 Safetensors 优先 GGUF/多种 企业特性 完善 基础 社区 HF 社区 独立社区 推理速度 快 最快 模型支持 跟随 HF 跟随社区 部署指南 Docker 部署 # 基础部署 docker run --gpus all -p 8080:80 \ -v /data/models:/models \ ghcr.io/huggingface/text-generation-inference:3.0 \ --model Qwen/Qwen2.5-32B-Instruct \ --quantization awq \ --max-total-tokens 32768 \ --max-batch-size 256 \ --max-concurrent-requests 512 高级配置 # 完整生产配置 docker run --gpus all -p 8080:80 \ -v /data/models:/models \ -v /data/cache:/data \ -e HUGGING_FACE_HUB_TOKEN=$HF_TOKEN \ ghcr.io/huggingface/text-generation-inference:3.0 \ --model Qwen/Qwen2.5-72B-Instruct \ --model-auto-config \ --revision main \ --quantization awq \ --dtype float16 \ --max-total-tokens 65536 \ --max-batch-size 128 \ --max-concurrent-requests 256 \ --max-batch-prefill-tokens 8192 \ --max-waiting-tokens 20 \ --max-waiting-batches 4 \ --waiting-served-ratio 1.2 \ --cuda-memory-fraction 0.90 \ --tensor-parallel-size 2 \ --num-shard 2 \ --sharded true \ --enable-flash-attention \ --enable-prefix-caching \ --enable-chunked-prefill \ --disable-custom-kernels false \ --json-output \ --google-service-account /data/gcp.json Python SDK 使用 from text_generation import Client, AsyncClient # 同步客户端 client = Client("http://localhost:8080") # 简单生成 response = client.generate( prompt="解释量子纠缠", max_new_tokens=512, temperature=0.7, top_p=0.9, repetition_penalty=1.1, stop=["<|im_end|>"], ) print(response.generated_text) # 流式生成 for token in client.generate_stream( prompt="写一首诗", max_new_tokens=200, ): print(token.token.text, end="", flush=True) # 批量生成 responses = client.generate_batch( prompts=["你好", "Hello", "Bonjour"], max_new_tokens=50 ) # 异步客户端 async_client = AsyncClient("http://localhost:8080") response = await async_client.generate("Hello", max_new_tokens=100) OpenAI 兼容 API from openai import OpenAI # TGI 兼容 OpenAI API client = OpenAI( base_url="http://localhost:8080/v1", api_key="tgi" ) response = client.chat.completions.create( model="Qwen/Qwen2.5-32B-Instruct", messages=[ {"role": "system", "content": "你是助手"}, {"role": "user", "content": "Hello"} ], stream=True, tools=[{ "type": "function", "function": { "name": "get_time", "parameters": {"type": "object", "properties": {}} } }] ) 核心优化 1. 连续批处理 TGI 的连续批处理（Continuous Batching）是其高吞吐量的核心： ...

vLLM 2026：推理引擎的事实标准 vLLM 在 2026 年已经成为大模型推理部署的事实标准。根据社区统计，全球超过 70% 的开源大模型生产部署使用 vLLM 作为推理引擎。它的核心优势在于 PagedAttention 技术带来的高吞吐量和低延迟，以及对各类开源模型的广泛支持。 2026 核心特性 版本演进 特性 vLLM 0.3 (2024) vLLM 0.8 (2026) PagedAttention v1 v3（内存效率+40%） 连续批处理 支持 支持 + 动态批大小 张量并行 支持 支持 + 专家并行 量化 AWQ/GPTQ AWQ/GPTQ/FP8/INT4 多模态 实验性 原生支持 Speculative Decoding 不支持 支持 长上下文 32k 1M+ 分离式推理 不支持 Prefill/Decode 分离 安装与环境准备 基础安装 # 创建虚拟环境 python -m venv vllm-env source vllm-env/bin/activate # Linux # vllm-env\Scripts\activate # Windows # 安装 vLLM（CUDA 12.1+） pip install vllm==0.8.5 # 验证安装 python -c "import vllm; print(vllm.__version__)" GPU 环境检查 # 检查 CUDA 版本 nvidia-smi # 需要 CUDA 12.1+，驱动 535+ # 检查 GPU 内存 nvidia-smi --query-gpu=name,memory.total,memory.free --format=csv 模型内存需求参考 模型 参数量 FP16 显存 INT8 显存 INT4 显存 推荐 GPU Qwen2.5-7B 7B 14 GB 8 GB 5 GB RTX 4090 Llama-4-8B 8B 16 GB 9 GB 5 GB RTX 4090 Qwen2.5-32B 32B 64 GB 34 GB 20 GB A100 80GB Llama-4-70B 70B 140 GB 75 GB 42 GB 2×A100 80GB Qwen3-72B 72B 145 GB 78 GB 44 GB 2×A100 80GB DeepSeek-V3 671B (MoE) 1.3 TB 700 GB 400 GB 8×H100 80GB 基础部署 单 GPU 部署 from vllm import LLM, SamplingParams # 加载模型 llm = LLM( model="Qwen/Qwen2.5-32B-Instruct", quantization="awq", # 使用 AWQ 量化 max_model_len=32768, # 最大上下文长度 gpu_memory_utilization=0.90, # GPU 内存利用率 tensor_parallel_size=1, # 张量并行度 dtype="float16", # 数据类型 trust_remote_code=True, enforce_eager=False, # 使用 CUDA Graph 优化 swap_space=4, # CPU 交换空间 (GB) max_num_seqs=256, # 最大并发序列数 ) # 配置采样参数 sampling_params = SamplingParams( temperature=0.7, top_p=0.9, top_k=50, max_tokens=2048, repetition_penalty=1.05, ) # 批量推理 prompts = [ "解释量子计算的基本原理", "写一首关于春天的诗", "用 Python 实现快速排序算法", ] outputs = llm.generate(prompts, sampling_params) for output in outputs: print(output.outputs[0].text) 多 GPU 张量并行 # 2×A100 80GB 部署 70B 模型 llm = LLM( model="meta-llama/Llama-4-70B-Instruct", tensor_parallel_size=2, # 2 路张量并行 pipeline_parallel_size=1, # 流水线并行 gpu_memory_utilization=0.92, max_model_len=65536, dtype="float16", enable_prefix_caching=True, # 前缀缓存 enable_chunked_prefill=True, # 分块预填充 ) OpenAI 兼容 API 服务 # 启动 API 服务器 python -m vllm.entrypoints.openai.api_server \ --model Qwen/Qwen2.5-32B-Instruct \ --quantization awq \ --tensor-parallel-size 2 \ --gpu-memory-utilization 0.90 \ --max-model-len 32768 \ --port 8000 \ --host 0.0.0.0 \ --api-key sk-your-api-key \ --served-model-name qwen-32b \ --enable-prefix-caching \ --enable-chunked-prefill \ --max-num-seqs 256 \ --uvicorn-log-level info # 客户端调用（兼容 OpenAI SDK） from openai import OpenAI client = OpenAI( api_key="sk-your-api-key", base_url="http://localhost:8000/v1" ) response = client.chat.completions.create( model="qwen-32b", messages=[ {"role": "system", "content": "你是专业翻译"}, {"role": "user", "content": "Translate: Hello World"} ], temperature=0.3, max_tokens=100, stream=True # 支持流式输出 ) for chunk in response: if chunk.choices[0].delta.content: print(chunk.choices[0].delta.content, end="") 性能优化 1. 量化策略 # FP8 量化（H100 专用，吞吐量最高） llm = LLM( model="Qwen/Qwen2.5-72B-Instruct", quantization="fp8", dtype="bfloat16", gpu_memory_utilization=0.92, ) # INT4 AWQ 量化（最省显存） llm = LLM( model="Qwen/Qwen2.5-72B-Instruct", quantization="awq", quantization_config={ "bits": 4, "group_size": 128, "zero_point": True, }, ) # GPTQ 量化 llm = LLM( model="TheBloke/Llama-4-70B-GPTQ", quantization="gptq", dtype="float16", ) 2. Speculative Decoding（投机解码） # 使用小模型加速大模型推理 llm = LLM( model="Qwen/Qwen2.5-72B-Instruct", speculative_model="Qwen/Qwen2.5-1.5B-Instruct", # 草稿模型 num_speculative_tokens=5, # 每次投机 5 个 token speculative_draft_tensor_parallel_size=1, gpu_memory_utilization=0.92, ) # 效果：吞吐量提升 2-3x，延迟降低 40-60% # 代价：草稿模型需要共享词表 3. 分离式推理（Prefill-Decode 分离） # 2026 新特性：将 Prefill 和 Decode 分离到不同 GPU # 适合高并发场景 # Prefill 节点（计算密集） python -m vllm.entrypoints.openai.api_server \ --model Qwen/Qwen2.5-72B-Instruct \ --disaggregation-mode prefill \ --disaggregation-port 5001 \ --port 8000 # Decode 节点（内存密集） python -m vllm.entrypoints.openai.api_server \ --model Qwen/Qwen2.5-72B-Instruct \ --disaggregation-mode decode \ --disaggregation-port 5001 \ --port 8001 # 路由层（自动分发请求） python -m vllm.entrypoints.disagg_router \ --prefill-endpoint http://gpu1:8000 \ --decode-endpoint http://gpu2:8001 \ --port 8080 4. 长上下文优化 # 1M 上下文部署 llm = LLM( model="Qwen/Qwen2.5-32B-Instruct-1M", max_model_len=1048576, # 1M tokens gpu_memory_utilization=0.95, # 长上下文优化 enable_chunked_prefill=True, # 分块预填充 max_num_batched_tokens=8192, # 每批最大 token 数 max_num_seqs=32, # 降低并发数以容纳长序列 # KV Cache 优化 block_size=16, # PagedAttention 块大小 swap_space=16, # CPU 交换空间 # 滑动窗口注意力（适用于超长上下文） sliding_window=131072, # 128K 滑动窗口 ) 生产部署架构 Kubernetes 部署 apiVersion: apps/v1 kind: Deployment metadata: name: vllm-qwen-32b spec: replicas: 2 selector: matchLabels: app: vllm-qwen-32b template: metadata: labels: app: vllm-qwen-32b spec: containers: - name: vllm image: vllm/vllm-openai:v0.8.5 args: - --model=Qwen/Qwen2.5-32B-Instruct - --quantization=awq - --tensor-parallel-size=2 - --gpu-memory-utilization=0.90 - --max-model-len=32768 - --port=8000 resources: limits: nvidia.com/gpu: 2 memory: 128Gi requests: nvidia.com/gpu: 2 memory: 64Gi ports: - containerPort: 8000 readinessProbe: httpGet: path: /health port: 8000 initialDelaySeconds: 120 periodSeconds: 10 livenessProbe: httpGet: path: /health port: 8000 initialDelaySeconds: 300 periodSeconds: 30 --- apiVersion: v1 kind: Service metadata: name: vllm-service spec: selector: app: vllm-qwen-32b ports: - port: 8000 targetPort: 8000 type: LoadBalancer 负载均衡配置 # Nginx 负载均衡 upstream vllm_backend { least_conn; # 最少连接策略 server gpu-node-1:8000 weight=1 max_fails=3 fail_timeout=30s; server gpu-node-2:8000 weight=1 max_fails=3 fail_timeout=30s; server gpu-node-3:8000 weight=1 max_fails=3 fail_timeout=30s; keepalive 32; keepalive_timeout 60s; } server { listen 80; location /v1/ { proxy_pass http://vllm_backend; proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; # 流式响应支持 proxy_buffering off; proxy_cache off; chunked_transfer_encoding on; # 超时设置 proxy_connect_timeout 10s; proxy_read_timeout 300s; proxy_send_timeout 60s; } location /health { proxy_pass http://vllm_backend/health; } } 性能基准 吞吐量对比（Qwen2.5-32B AWQ，2×A100 80GB） 配置 吞吐量 (tok/s) P50 延迟 P99 延迟 并发数 基础配置 2,800 0.8s 3.2s 64 + 前缀缓存 3,500 0.6s 2.5s 64 + 分块预填充 4,200 0.5s 2.1s 128 + Speculative 6,800 0.3s 1.2s 128 + FP8 (H100) 8,500 0.25s 0.9s 256 与其他推理引擎对比 引擎 吞吐量 延迟 显存效率 易用性 vLLM 0.8 4,200 tok/s 0.5s 92% ⭐⭐⭐⭐⭐ TGI 3.0 3,100 tok/s 0.7s 85% ⭐⭐⭐⭐ SGLang 0.3 4,800 tok/s 0.4s 90% ⭐⭐⭐⭐ TensorRT-LLM 5,200 tok/s 0.3s 95% ⭐⭐⭐ Ollama 1,800 tok/s 1.2s 70% ⭐⭐⭐⭐⭐ 监控与运维 Prometheus 指标 # vLLM 内置 Prometheus 指标 # 访问 http://localhost:8000/metrics # 关键指标： # vllm:num_requests_running - 正在运行的请求数 # vllm:num_requests_waiting - 等待队列长度 # vllm:gpu_cache_usage_perc - GPU 缓存使用率 # vllm:time_to_first_token - TTFT（首 Token 延迟） # vllm:time_per_output_token - TPOT（每 Token 延迟） # vllm:e2e_request_latency - 端到端延迟 # Prometheus 采集配置 scrape_configs: - job_name: 'vllm' static_configs: - targets: ['gpu-node-1:8000', 'gpu-node-2:8000'] metrics_path: /metrics scrape_interval: 10s 常见问题排查 问题 原因 解决方案 OOM 显存不足 降低 gpu_memory_utilization 或使用量化 首Token延迟高 Prefill 慢 启用 chunked_prefill 吞吐量低 批处理不足 增加 max_num_seqs 请求排队 并发过高 增加副本数或降低 max_model_len 模型加载慢 磁盘 I/O 使用本地 SSD 缓存模型 总结 vLLM 在 2026 年仍然是开源 LLM 推理部署的最佳选择。它的 PagedAttention v3、Speculative Decoding、分离式推理等特性让它在性能上保持领先，同时 OpenAI 兼容 API 降低了使用门槛。 ...

vLLM 架构总览 vLLM 由 UC Berkeley 团队开发，核心创新是 PagedAttention——一种受操作系统虚拟内存启发的注意力机制。其架构层次： ┌─────────────────────────────────────────────┐ │ OpenAI Compatible API │ │ (Streaming / Function Calling) │ ├─────────────────────────────────────────────┤ │ Request Scheduler │ │ (Continuous Batching + Priority Queue) │ ├──────────────┬──────────────────────────────┤ │ PagedAttention│ ParallelWorker │ │ KV Cache Mgr │ (Tensor Pipeline Parallel)│ ├──────────────┴──────────────────────────────┤ │ GPU Workers (CUDA) │ │ FlashAttention / FlashInfer Backend │ └─────────────────────────────────────────────┘ PagedAttention 原理 核心问题 传统 LLM 推理中，KV Cache 按最大序列长度预分配连续显存。这导致： 内部碎片：实际序列 < 最大序列，浪费 60-80% 显存 外部碎片：频繁分配/释放产生碎片 无法共享：相同前缀的请求各自维护 KV Cache PagedAttention 方案 借鉴 OS 的分页机制，将 KV Cache 分割为固定大小的 block（通常每 block 存 16 个 token 的 KV）： ...

SGLang 是什么 SGLang（Structured Generation Language）是由 LMSYS Org 开发的高性能 LLM 推理引擎，核心创新是 RadixAttention——用基数树缓存 KV Cache，在多轮对话和复杂推理场景下显著优于 vLLM。 核心创新：RadixAttention 传统推理引擎的 KV Cache 是按请求隔离的——每个请求独立计算 Attention 的 K 和 V，无法复用。在多轮对话中，前几轮的 KV Cache 每次都要重算。 SGLang 用基数树（Radix Tree）管理 KV Cache： RadixTree: [system prompt] → [user msg 1 + assistant msg 1] → [user msg 2 + ...] ↑ 命中缓存 ↑ 命中缓存 ↑ 新计算 当新请求的前缀与已缓存的前缀匹配时，直接复用 KV Cache，跳过重复计算。 效果： 多轮对话：第 N 轮只计算第 N 轮的 KV，前 N-1 轮全部命中缓存 Few-shot 场景：多个示例的前缀共享缓存 Agent 场景：system prompt 长且固定，缓存命中率接近 100% 与 vLLM 的 PagedAttention 对比 特性 vLLM PagedAttention SGLang RadixAttention 缓存粒度 物理页（块级） 逻辑前缀（语义级） 跨请求复用 需手动启用 prefix caching 自动复用 多轮对话 每轮重新计算 prefix 前缀自动命中 树结构管理 页表 基数树 缓存命中率 中 高 内存效率 高 高 安装 # 安装 SGLang pip install sglang # 或从源码安装 pip install --upgrade pip pip install "sglang[all]" GPU 要求：CUDA 12.0+，推荐 A100/H100/L40S。消费级显卡（3090/4090）也可用。 ...