<?xml version="1.0" encoding="utf-8"?><feed xmlns="http://www.w3.org/2005/Atom" xml:lang="zh-CN"><generator uri="https://jekyllrb.com/" version="3.10.0">Jekyll</generator><link href="https://charlestar.github.io/feed.xml" rel="self" type="application/atom+xml" /><link href="https://charlestar.github.io/" rel="alternate" type="text/html" hreflang="zh-CN" /><updated>2026-08-09T11:56:00+08:00</updated><id>https://charlestar.github.io/feed.xml</id><title type="html">Charlestar</title><subtitle>深入拆解大模型推理系统、GPU 优化与云原生工程实践。</subtitle><author><name>子辰</name><email>charlestarzhang@gmail.com</email></author><entry><title type="html">NVFP4 KV Cache：Blackwell 上的 4-bit 缓存量化</title><link href="https://charlestar.github.io/2026/06/02/nvfp4-kv-cacheblackwell/" rel="alternate" type="text/html" title="NVFP4 KV Cache：Blackwell 上的 4-bit 缓存量化" /><published>2026-06-02T12:00:00+08:00</published><updated>2026-08-09T00:00:00+08:00</updated><id>https://charlestar.github.io/2026/06/02/nvfp4-kv-cacheblackwell</id><content type="html" xml:base="https://charlestar.github.io/2026/06/02/nvfp4-kv-cacheblackwell/"><![CDATA[<blockquote>
  <p><strong>校订说明</strong>：原文包含无法追溯的公司案例、成本数字和自制性能表，现已删除。本文只保留 NVIDIA 与 vLLM 一手资料能够支持的结论；所有收益都必须在具体模型、上下文分布和硬件上复测。</p>
</blockquote>

<h2 id="1-为什么量化-kv-cache">1. 为什么量化 KV Cache</h2>

<p>自回归解码会为历史 token 保存每层的 Key 和 Value。忽略对齐和元数据时，缓存大小可近似写成：</p>

\[M \approx 2 \times L \times N \times H_{kv} \times D \times B\]

<p>其中 $L$ 是层数，$N$ 是已缓存 token 数，$H_{kv}$ 是 KV 头数，$D$ 是头维度，$B$ 是每个元素的字节数。量化降低 $B$，因此主要改善容量与内存带宽压力；它不会自动让所有算子获得同等比例的加速。</p>

<h2 id="2-nvfp4-到底是什么">2. NVFP4 到底是什么</h2>

<p>NVFP4 使用 E2M1 的 4-bit 数据值，并采用两级缩放：每 16 个值共享一个 E4M3 FP8 微块缩放因子，张量再共享一个 FP32 缩放因子。计入缩放开销后，它不是“严格每元素 4 bit”，但仍明显小于 FP8。</p>

<p>NVIDIA 公布的 KV Cache 方案把缓存从 FP8 压缩到 NVFP4，官方测试中缓存占用约减少 50%，并在所测代码、知识与长上下文基准上报告了小于 1% 的精度差异。这里的比较基线是 <strong>FP8 KV Cache</strong>，不能误写成相对 FP16 只减少 50%。</p>

<h2 id="3-收益边界">3. 收益边界</h2>

<ul>
  <li><strong>容量</strong>：相同缓存预算可容纳更多 token 或请求，但实际倍数受页大小、元数据和模型结构影响。</li>
  <li><strong>带宽</strong>：decode 阶段读取的缓存更小，可能改善 memory-bound 工作负载。</li>
  <li><strong>计算</strong>：缓存通常需要在注意力计算前反量化；端到端收益取决于内核实现和缓存命中率。</li>
  <li><strong>硬件</strong>：NVFP4 的主要目标是 NVIDIA Blackwell。其他 GPU 不应默认具有相同支持和收益。</li>
  <li><strong>质量</strong>：官方结果不是对所有模型与任务的保证，特别是长链推理、代码和检索任务必须单独验证。</li>
</ul>

<h2 id="4-部署检查表">4. 部署检查表</h2>

<ol>
  <li>先固定模型版本、数据集、采样参数和随机种子，记录 BF16/FP8 基线。</li>
  <li>同时比较 TTFT、TPOT、吞吐、峰值显存和任务质量，不只比较缓存字节数。</li>
  <li>分开测试短上下文、长上下文、低并发和高并发；量化收益通常随负载变化。</li>
  <li>确认推理框架、attention backend 和模型结构都支持 NVFP4；不支持时应显式失败而非静默回退。</li>
  <li>灰度发布并保留回退到 FP8/BF16 KV Cache 的能力。</li>
</ol>

<h2 id="5-两级缩放展开">5. 两级缩放展开</h2>

<p>对每个 16-value 微块，先选择 FP8 E4M3 scale，把值映射到 E2M1 可表示范围；整个 tensor 还有 FP32 scale 负责更大范围校准。概念上：</p>

<div class="language-text highlighter-rouge"><div class="highlight"><pre class="highlight"><code>x
 -&gt; divide by tensor_scale
 -&gt; divide by block_scale (one per 16 values)
 -&gt; round/clip to E2M1
 -&gt; pack two 4-bit values per byte
</code></pre></div></div>

<p>读取时反向应用 scales，并通常转换到 attention kernel 使用的更高精度。两级 scale 改善局部动态范围，但引入 metadata 和量化/反量化工作。</p>

<h2 id="6-为什么不是-75-实际节省">6. 为什么不是 75% 实际节省</h2>

<p>从 16-bit 数值到裸 4-bit 看似减少 75%，但 NVFP4 还需每 16 个值一个 FP8 scale 和每 tensor 一个 FP32 scale，并有对齐/页 metadata。相对 FP8 的官方 KV 方案约节省 50% 更符合实际对比。相对 BF16 的比例需按具体布局计算，不能只用 4/16。</p>

<h2 id="7-prefill-与-decode-的不同影响">7. Prefill 与 Decode 的不同影响</h2>

<p>Prefill 计算密集，KV 写入只是一部分；decode 每步反复读取历史 KV，更容易受缓存带宽影响。NVFP4 可能在长上下文 decode 和高缓存压力下更有价值，但反量化 kernel、缓存命中和 batch shape 会决定实际 TPOT。</p>

<h2 id="8-与-gqamla-叠加">8. 与 GQA/MLA 叠加</h2>

<p>GQA 通过减少 KV heads 降低 token cache，MLA 用低维 latent 表示压缩 KV，NVFP4 再降低存储精度。这些优化可以叠加，但基线已经很小时，量化 metadata/反量化成本占比会提高；质量敏感性也依表示而变。</p>

<h2 id="9-质量校准">9. 质量校准</h2>

<p>校准集应覆盖不同层、head、上下文位置和输入领域。除平均误差外，观察 scale saturation、异常值比例和 attention/logit 偏差。部署验证使用与业务相同的长上下文任务，而不是只跑短问答。</p>

<h2 id="10-容量计算">10. 容量计算</h2>

<p>先根据模型配置计算未量化 KV bytes/token，再乘目标并发和上下文分布；随后加入 block 对齐、scale metadata、prefix cache、CUDA Graph 和权重占用。只有剩余 HBM 才是可分配 KV 池，不能用 GPU 总显存直接除。</p>

<h2 id="参考资料">参考资料</h2>

<ul>
  <li><a href="https://developer.nvidia.com/blog/optimizing-inference-for-long-context-and-large-batch-sizes-with-nvfp4-kv-cache/">NVIDIA：Optimizing Inference for Long Context and Large Batch Sizes with NVFP4 KV Cache</a></li>
  <li><a href="https://developer.nvidia.com/blog/introducing-nvfp4-for-efficient-and-accurate-low-precision-inference/">NVIDIA：Introducing NVFP4 for Efficient and Accurate Low-Precision Inference</a></li>
  <li><a href="https://docs.vllm.ai/en/latest/api/vllm/v1/kv_cache_interface/">vLLM KV cache interface</a></li>
</ul>]]></content><author><name>iStar</name></author><category term="AI Infra" /><category term="LLM推理" /><category term="KV Cache" /><category term="量化" /><summary type="html"><![CDATA[校订说明：原文包含无法追溯的公司案例、成本数字和自制性能表，现已删除。本文只保留 NVIDIA 与 vLLM 一手资料能够支持的结论；所有收益都必须在具体模型、上下文分布和硬件上复测。]]></summary></entry><entry><title type="html">llm-d：Kubernetes 原生分布式 LLM 推理栈</title><link href="https://charlestar.github.io/2026/06/01/llm-d-kubernetes-native-distributed-llm-inference/" rel="alternate" type="text/html" title="llm-d：Kubernetes 原生分布式 LLM 推理栈" /><published>2026-06-01T12:00:00+08:00</published><updated>2026-08-09T00:00:00+08:00</updated><id>https://charlestar.github.io/2026/06/01/llm-d-kubernetes-native-distributed-llm-inference</id><content type="html" xml:base="https://charlestar.github.io/2026/06/01/llm-d-kubernetes-native-distributed-llm-inference/"><![CDATA[<blockquote>
  <p><strong>校订说明</strong>：原文把概念性 YAML、Redis 任务队列和匿名金融公司数据写成 llm-d 的既成实现，缺少来源且会误导部署，现已移除。本文依据当前官方架构重新整理。</p>
</blockquote>

<h2 id="1-llm-d-的定位">1. llm-d 的定位</h2>

<p>llm-d 不是替代 vLLM 的单机推理引擎，而是位于模型服务器之上的 Kubernetes 分布式服务栈。它组合 vLLM、Kubernetes Gateway API/Inference Gateway 及 KV 传输组件，解决大规模服务中的路由、缓存、解耦部署和运维问题。</p>

<p>官方当前将能力概括为：</p>

<ul>
  <li>前缀缓存与负载感知的智能路由；</li>
  <li>分层 KV Cache 管理与全局缓存索引；</li>
  <li>Prefill/Decode 解耦和宽专家并行；</li>
  <li>流量控制、SLO 感知扩缩容与批处理。</li>
</ul>

<h2 id="2-核心数据路径">2. 核心数据路径</h2>

<div class="language-text highlighter-rouge"><div class="highlight"><pre class="highlight"><code>client
  -&gt; Gateway / llm-d Router
  -&gt; selected model-server endpoint (vLLM)
  -&gt; optional disaggregated prefill and decode workers
  -&gt; KV transfer/offload layer when the chosen recipe enables it
</code></pre></div></div>

<p>路由器可以利用队列、负载和前缀缓存信息选择端点。Prefill/Decode 解耦适合两个阶段资源特征不同的工作负载，但会引入 KV 传输、故障恢复和容量规划成本，并非默认一定更快。</p>

<h2 id="3-不应混淆的概念">3. 不应混淆的概念</h2>

<ul>
  <li><strong>Prefix cache</strong> 是模型服务器可复用的计算状态；它不等同于 Redis 中的普通业务对象。</li>
  <li><strong>KV 传输</strong> 需要面向大张量的高性能数据路径；官方方案会组合 NIXL 等组件，不能用示例消息队列替代。</li>
  <li><strong>Kubernetes 调度</strong> 决定 Pod 放置，llm-d Router 负责请求级路由；两者职责不同。</li>
  <li><strong>“多硬件支持”</strong> 代表项目提供多种 recipe 和集成，不代表任意模型、任意加速器无需验证即可互换。</li>
</ul>

<h2 id="4-上线前的验证顺序">4. 上线前的验证顺序</h2>

<ol>
  <li>先用单一 vLLM 实例建立质量、TTFT、TPOT 和吞吐基线。</li>
  <li>再测试 cache-aware routing，记录缓存命中率和尾延迟。</li>
  <li>只有 prefill/decode 比例和网络条件合适时再引入解耦。</li>
  <li>使用官方 Helm chart 与 well-lit-path 指南，不复制版本不明的概念 YAML。</li>
  <li>对路由器、模型服务器和 KV 数据路径分别设置容量与故障演练。</li>
</ol>

<p>官方展示的性能结果都绑定具体模型、硬件和流量分布，不能直接外推为通用的“成本降低 35%”或“QPS 提升 54%”。</p>

<h2 id="5-router-的决策信息">5. Router 的决策信息</h2>

<p>普通 round-robin 不知道请求长度、队列、KV 命中或各副本 GPU 状态。llm-d Router 的 Endpoint Picker 可以利用推理相关信号给候选 endpoint 打分，再由 proxy 转发。评分仍需防止热点：所有共享同一热门前缀的请求都去一个副本，可能让缓存收益被排队延迟抵消。</p>

<h2 id="6-prefilldecode-解耦数据流">6. Prefill/Decode 解耦数据流</h2>

<div class="language-text highlighter-rouge"><div class="highlight"><pre class="highlight"><code>request -&gt; prefill worker -&gt; KV blocks
                       \-&gt; transfer metadata
                           -&gt; decode worker -&gt; tokens
</code></pre></div></div>

<p>解耦允许两个池分别扩缩容和选择并行策略。代价是 KV 传输延迟、路由一致性和失败恢复。只有当阶段资源特征、网络带宽和请求长度分布适合时，解耦才优于共置。</p>

<h2 id="7-分层-kv-cache">7. 分层 KV Cache</h2>

<p>GPU HBM 最快但最小，CPU 内存/本地盘/远端存储更大但更慢。分层缓存的目标是把热门前缀留在快层，把较冷数据下沉，并用全局索引判断数据位置。命中慢层是否值得，取决于传输成本与重新 prefill 成本的比较。</p>

<h2 id="8-kubernetes-资源模型">8. Kubernetes 资源模型</h2>

<p>生产 recipe 还需处理 GPU 拓扑、Gang scheduling、健康探针、PodDisruptionBudget、滚动升级和多租户限流。HPA 仅看 CPU 利用率通常不足，应结合队列、TTFT/TPOT、KV 容量与模型加载时间设计扩缩容信号。</p>

<h2 id="9-最小实验路径">9. 最小实验路径</h2>

<p>先对同一批 prompt 比较 round-robin 与 prefix-aware routing；再增加请求率观察热点和尾延迟；最后才引入 P/D 解耦并测 KV transfer。每次只改变一个维度，更容易确定收益来自路由、缓存还是资源池拆分。</p>

<h2 id="参考资料">参考资料</h2>

<ul>
  <li><a href="https://github.com/llm-d/llm-d">llm-d 官方仓库</a></li>
  <li><a href="https://llm-d.ai/docs/architecture/">llm-d 官方架构文档</a></li>
  <li><a href="https://github.com/llm-d/llm-d/blob/main/docs/proposals/llm-d.md">llm-d founding proposal</a></li>
</ul>]]></content><author><name>iStar</name></author><category term="AI Infra" /><category term="Kubernetes" /><category term="llm-d" /><category term="分布式推理" /><summary type="html"><![CDATA[校订说明：原文把概念性 YAML、Redis 任务队列和匿名金融公司数据写成 llm-d 的既成实现，缺少来源且会误导部署，现已移除。本文依据当前官方架构重新整理。]]></summary></entry><entry><title type="html">MoE 与推测解码：计算、通信和接受率的联合优化</title><link href="https://charlestar.github.io/2026/05/29/moe-speculative-decoding/" rel="alternate" type="text/html" title="MoE 与推测解码：计算、通信和接受率的联合优化" /><published>2026-05-29T12:00:00+08:00</published><updated>2026-08-09T00:00:00+08:00</updated><id>https://charlestar.github.io/2026/05/29/moe-speculative-decoding</id><content type="html" xml:base="https://charlestar.github.io/2026/05/29/moe-speculative-decoding/"><![CDATA[<blockquote>
  <p><strong>校订说明</strong>：原文重复了整段“最佳实践”，并把多个研究构想、vLLM/SGLang 配置和精确收益写成已验证生产能力。以下版本删除这些断言。</p>
</blockquote>

<h2 id="1-为什么这个组合值得研究">1. 为什么这个组合值得研究</h2>

<p>推测解码减少目标模型串行执行的轮数。MoE 目标模型的每轮验证还包含路由、专家 GEMM 和 all-to-all，因此一次成功验证多个 token 可能摊薄权重读取与通信启动成本。</p>

<p>但“MoE 更贵”不自动推出“加速比更高”：草稿 token 可能触发不同专家，验证宽度会改变 grouped GEMM shape 和通信量，低接受率还会浪费这些工作。</p>

<h2 id="2-成本模型">2. 成本模型</h2>

<p>可用一个简化模型判断是否值得开启：</p>

\[T_{spec}=T_{draft}(k)+T_{verify}(k)+T_{rollback}\]

<p>只有当每轮平均接受 token 数带来的串行步数减少，超过草稿、宽验证和回滚成本时，端到端才会加速。MoE 场景还应把 dispatch/combine 通信计入 $T_{verify}$。</p>

<h2 id="3-可优化的环节">3. 可优化的环节</h2>

<ul>
  <li>根据近期接受长度动态调整 draft length；</li>
  <li>让验证 batch 的 token 排布更适合 grouped GEMM；</li>
  <li>重叠专家通信与可独立执行的计算；</li>
  <li>对草稿路径使用轻量模型、MTP 头或特征预测器；</li>
  <li>正确回滚 KV Cache、路由 metadata 和随机采样状态。</li>
</ul>

<p>“限制验证时激活的专家”可能改变目标模型分布，除非方法给出严格修正或明确接受近似，否则不能与 lossless speculative sampling 混为一谈。</p>

<h2 id="4-评测清单">4. 评测清单</h2>

<ul>
  <li>accepted tokens/step 与 draft/verify 时间；</li>
  <li>专家负载分布、all-to-all 时间和通信字节；</li>
  <li>greedy 一致性或 sampling 分布正确性；</li>
  <li>TTFT、TPOT、吞吐、显存和 goodput；</li>
  <li>batch、输入/输出长度及硬件拓扑的敏感性。</li>
</ul>

<h2 id="5-验证树如何影响专家负载">5. 验证树如何影响专家负载</h2>

<p>一次验证多个候选 token 会把更多 token 同时送入 router。优点是每个 expert 的局部 batch 可能变大，grouped GEMM 更高效；缺点是候选分支可能分散到更多 experts，增加 dispatch 和 all-to-all。收益取决于草稿树形状和路由分布。</p>

<h2 id="6-target-efficiency">6. Target efficiency</h2>

<p>可把目标模型有效工作定义为“最终保留 token / 目标验证成本”。只看 accepted token 数会忽略验证了多少最终被丢弃的分支。MoE 场景还可记录每个保留 token 对应的 expert token executions 和通信字节。</p>

<h2 id="7-通信重叠机会">7. 通信重叠机会</h2>

<p>若多个验证 microbatch 独立，可尝试在一组 experts 计算时 dispatch 下一组。但 dependency、buffer ownership 和 collective 顺序必须一致，尤其在多 rank 上不能让不同 rank 以不同顺序发起 collective。</p>

<h2 id="8-近似专家预算的风险">8. 近似专家预算的风险</h2>

<p>为了省成本而少激活目标模型原本选中的 expert，会改变 logits，经典接受/拒绝证明不再直接成立。此类方法应标为 approximate decoding，并通过质量指标与分布差异评估；不能与严格 lossless 方法混在同一表中。</p>

<h2 id="9-实验分解">9. 实验分解</h2>

<p>先在单 GPU/单节点上验证解码正确性和接受率，再启用 EP 测通信；随后比较无推测、密集/小模型草稿、EAGLE/MTP 等方案。把 kernel、通信和调度时间分别 profile，才能判断瓶颈是否真的被摊薄。</p>

<h2 id="参考资料">参考资料</h2>

<ul>
  <li><a href="https://arxiv.org/abs/2211.17192">Speculative Decoding paper</a></li>
  <li><a href="https://arxiv.org/abs/2401.15077">EAGLE paper</a></li>
  <li><a href="https://github.com/deepseek-ai/DeepSeek-V3">DeepSeek-V3</a></li>
  <li><a href="https://docs.vllm.ai/en/latest/features/spec_decode/">vLLM speculative decoding documentation</a></li>
</ul>]]></content><author><name>iStar</name></author><category term="AI Infra" /><category term="MoE" /><category term="推测解码" /><category term="LLM推理" /><summary type="html"><![CDATA[校订说明：原文重复了整段“最佳实践”，并把多个研究构想、vLLM/SGLang 配置和精确收益写成已验证生产能力。以下版本删除这些断言。]]></summary></entry><entry><title type="html">SpecForge：面向 SGLang 的推测解码模型训练框架</title><link href="https://charlestar.github.io/2026/05/27/specforge-eagle3-speculative-decoding/" rel="alternate" type="text/html" title="SpecForge：面向 SGLang 的推测解码模型训练框架" /><published>2026-05-27T12:00:00+08:00</published><updated>2026-08-09T00:00:00+08:00</updated><id>https://charlestar.github.io/2026/05/27/specforge-eagle3-speculative-decoding</id><content type="html" xml:base="https://charlestar.github.io/2026/05/27/specforge-eagle3-speculative-decoding/"><![CDATA[<blockquote>
  <p><strong>校订说明</strong>：原文包含 GPT-4/Claude 草稿模型、跨硬件吞吐表和成本/碳排放数字，官方资料并不支持这些内容，现已删除。</p>
</blockquote>

<h2 id="1-specforge-解决什么问题">1. SpecForge 解决什么问题</h2>

<p>SpecForge 是 SGLang 团队维护的推测解码模型训练框架。它的价值主要在工程链路：支持在线/离线数据、张量并行和 FSDP 训练，并让训练产物更顺畅地接入 SGLang serving。</p>

<p>推测解码包含两个不同问题：</p>

<ol>
  <li><strong>训练草稿模型</strong>：SpecForge 主要覆盖这一环节。</li>
  <li><strong>运行时验证与采样</strong>：由 SGLang 等推理引擎完成。</li>
</ol>

<p>因此“训练完成”不等于必然获得固定加速比。端到端收益取决于草稿成本、平均接受长度、目标模型验证效率、batch 大小和请求分布。</p>

<h2 id="2-eagle-3-的关键思路">2. EAGLE-3 的关键思路</h2>

<p>EAGLE 系列不是简单地用一个小语言模型独立生成 token，而是利用目标模型的特征来预测后续候选。EAGLE-3 进一步融合多层特征，旨在提高草稿对目标分布的拟合能力。</p>

<p>“接受率”也不能单独代表性能：更大的草稿树可能提高每轮接受 token 数，却同时增加草稿计算、验证宽度和显存占用。应同时报告：</p>

<ul>
  <li>accepted tokens per verification step；</li>
  <li>draft/verify 时间占比；</li>
  <li>TPOT、吞吐与峰值显存；</li>
  <li>greedy 与 sampling 两种模式下的正确性。</li>
</ul>

<h2 id="3-实践建议">3. 实践建议</h2>

<ul>
  <li>从官方已发布的 checkpoint 和配置开始，不要把概念性 Python 类当作真实 API。</li>
  <li>训练数据要贴近线上目标模型的输出分布和采样策略。</li>
  <li>checkpoint 必须与目标模型、tokenizer、特征层和 serving 版本匹配。</li>
  <li>先验证输出分布/greedy 等价性，再做性能对比。</li>
  <li>在真实 prompt 长度、输出长度和并发分布上评测，不外推单条样例结果。</li>
</ul>

<h2 id="4-训练数据流水线">4. 训练数据流水线</h2>

<div class="language-text highlighter-rouge"><div class="highlight"><pre class="highlight"><code>prompts
 -&gt; target model rollout / hidden-state capture
 -&gt; tokenize + align target features
 -&gt; training shards
 -&gt; EAGLE drafter training
 -&gt; checkpoint conversion
 -&gt; SGLang serving validation
</code></pre></div></div>

<p>离线数据易复现，但可能与最新 drafter 分布不一致；在线/on-policy 数据更贴近当前模型行为，成本和系统复杂度更高。实际训练可混合使用，并记录生成参数与目标模型 revision。</p>

<h2 id="5-feature-alignment">5. Feature alignment</h2>

<p>草稿训练样本中的 token position 必须和目标 hidden feature 一一对应。BOS/EOS、chat template、padding、截断和 packed sequence 都可能造成 off-by-one。最先应做的小测试，是在单条短序列上打印 token IDs、labels 和 feature indices，确认每个预测目标对齐。</p>

<h2 id="6-并行训练">6. 并行训练</h2>

<p>FSDP 主要切分参数/优化器状态，Tensor Parallel 切分层内计算。训练 drafter 时还要考虑目标特征数据的读取吞吐，避免 GPU 等待大量 hidden-state 文件。shard 应按样本边界组织并支持断点续训。</p>

<h2 id="7-checkpoint-交付契约">7. Checkpoint 交付契约</h2>

<p>产物至少要记录 base/target model、tokenizer、feature layers、drafter architecture、dtype、训练配置和导出格式。Serving 启动时应验证这些字段，而不是等到生成错误后才发现模型不匹配。</p>

<h2 id="8-从离线-loss-到线上收益">8. 从离线 loss 到线上收益</h2>

<p>更低训练 loss 不一定带来更高 accepted length。最终模型选择应在代表性 prompt 上测 acceptance、draft latency、verify latency 和端到端 TPOT，并监控不同领域/语言的差异。</p>

<h2 id="参考资料">参考资料</h2>

<ul>
  <li><a href="https://github.com/sgl-project/SpecForge">SpecForge 官方仓库</a></li>
  <li><a href="https://docs.sglang.ai/SpecForge/">SpecForge 文档</a></li>
  <li><a href="https://arxiv.org/abs/2503.01840">EAGLE-3 论文</a></li>
  <li><a href="https://github.com/sgl-project/sglang">SGLang 官方仓库</a></li>
</ul>]]></content><author><name>iStar</name></author><category term="AI Infra" /><category term="SGLang" /><category term="SpecForge" /><category term="推测解码" /><summary type="html"><![CDATA[校订说明：原文包含 GPT-4/Claude 草稿模型、跨硬件吞吐表和成本/碳排放数字，官方资料并不支持这些内容，现已删除。]]></summary></entry><entry><title type="html">vLLM Model Runner V2：GPU-native 与 async-first 的执行核心</title><link href="https://charlestar.github.io/2026/05/25/vllm-model-runner-v2-architecture-refactoring-gpu-native-and-zero-sync-design-analysis/" rel="alternate" type="text/html" title="vLLM Model Runner V2：GPU-native 与 async-first 的执行核心" /><published>2026-05-25T12:00:00+08:00</published><updated>2026-08-09T00:00:00+08:00</updated><id>https://charlestar.github.io/2026/05/25/vllm-model-runner-v2-architecture-refactoring-gpu-native-and-zero-sync-design-analysis</id><content type="html" xml:base="https://charlestar.github.io/2026/05/25/vllm-model-runner-v2-architecture-refactoring-gpu-native-and-zero-sync-design-analysis/"><![CDATA[<blockquote>
  <p><strong>校订说明</strong>：原文虚构了多组模型吞吐、内存碎片率和匿名电商案例，并把实验性状态写成完全兼容，现已删除。本文按 vLLM 官方公告与发布说明更新。</p>
</blockquote>

<h2 id="1-为什么重写-model-runner">1. 为什么重写 Model Runner</h2>

<p>Model Runner V2（MRV2）是 vLLM 对 GPU 执行路径的重新实现，不是 “vLLM V2”。官方总结的三项原则是：</p>

<ul>
  <li><strong>modular</strong>：分离模型特有逻辑与公共执行路径；</li>
  <li><strong>GPU-native</strong>：把适合的 bookkeeping 和输入准备移向 GPU；</li>
  <li><strong>async-first</strong>：从设计上支持 CPU/GPU 重叠，而不是事后叠加异步逻辑。</li>
</ul>

<p>它还重新梳理 persistent batch 的状态所有权，降低请求插入、删除和重排时的耦合。</p>

<h2 id="2-零同步应如何理解">2. “零同步”应如何理解</h2>

<p>目标是减少热路径上不必要的 GPU→CPU 同步点，让调度、输入准备、采样与下一轮执行尽可能重叠；它不意味着整个系统永远没有同步。日志、返回 token、动态控制流和不支持的算子仍可能形成同步边界。</p>

<h2 id="3-当前迁移状态">3. 当前迁移状态</h2>

<p>MRV2 最初通过 <code class="language-plaintext highlighter-rouge">VLLM_USE_V2_MODEL_RUNNER=1</code> 试用，之后逐步覆盖更多模型与功能。到 vLLM v0.25.0，官方发布说明称它已成为所有 dense 模型的默认路径；MoE、混合架构或特殊功能仍可能使用不同路径或回退策略。</p>

<p>因此部署文档不要固定写“v0.20+ 一律手动开启”或“API 完全兼容”。正确做法是：</p>

<ol>
  <li>查看目标版本 release notes 和支持矩阵；</li>
  <li>记录实际选中的 runner，而不是只看环境变量；</li>
  <li>使用同一模型、同一 workload 比较 TTFT、TPOT、吞吐和显存；</li>
  <li>对 speculative decoding、LoRA、多模态、量化和分布式组合单独回归。</li>
</ol>

<h2 id="4-性能数字如何阅读">4. 性能数字如何阅读</h2>

<p>官方文章展示了部分平台和工作负载上的提升，但不能把某张图的最大值复制成所有模型的固定 “56%”。MRV2 主要减少 CPU bookkeeping 和同步开销，因此小模型、高并发、短步长 workload 往往更敏感；大模型计算占主导时，收益比例可能不同。</p>

<h2 id="5-persistent-batch-为什么复杂">5. Persistent batch 为什么复杂</h2>

<p>相邻 decode step 的 batch 大部分请求不变，重建所有输入浪费 CPU 时间，因此 runner 会维护持久状态，只增量处理新增、完成和重排请求。状态通常包括 token IDs、positions、slot mapping、block table、sampling metadata 等。</p>

<p>V1 的困难在于这些结构既充当长期状态又直接充当某些 kernel 输入，布局变化容易牵动多个功能。MRV2 用更明确的状态层和输入准备层隔离这种耦合。</p>

<h2 id="6-gpu-native-input-preparation">6. GPU-native input preparation</h2>

<p>“GPU-native”不是把所有 Python 逻辑机械搬进 CUDA，而是识别适合批量执行的索引、拷贝和 metadata 更新，用 GPU/Triton kernel 处理，减少大量小 CPU 操作和 H2D 传输。复杂控制面仍可留在 CPU。</p>

<h2 id="7-async-first-的依赖图">7. Async-first 的依赖图</h2>

<p>若 step $t+1$ 的准备只依赖 step $t$ 的少量采样结果，就可以让 GPU 上的后处理产生紧凑结果，再通过 event/stream 串联下一步，而不把完整 tensor 同步回 CPU。遇到动态停止、logprobs 或 unsupported feature 时可能需要不同路径。</p>

<h2 id="8-回归矩阵">8. 回归矩阵</h2>

<p>除了性能，MRV2 迁移应验证 greedy/sampling、logprobs、beam/speculative decoding、prefix cache、LoRA、量化、多模态、TP/PP 和 CUDA Graph。任何 fallback 都应出现在日志/指标中，避免把 MRV1 结果误认为 MRV2。</p>

<h2 id="参考资料">参考资料</h2>

<ul>
  <li><a href="https://github.com/vllm-project/vllm-project.github.io/blob/main/_posts/2026-03-24-mrv2.md">vLLM 官方：Model Runner V2</a></li>
  <li><a href="https://github.com/vllm-project/vllm/releases">vLLM releases</a></li>
  <li><a href="https://github.com/vllm-project/vllm">vLLM 官方仓库</a></li>
</ul>]]></content><author><name>iStar</name></author><category term="AI Infra" /><category term="vLLM" /><category term="LLM推理" /><category term="GPU优化" /><summary type="html"><![CDATA[校订说明：原文虚构了多组模型吞吐、内存碎片率和匿名电商案例，并把实验性状态写成完全兼容，现已删除。本文按 vLLM 官方公告与发布说明更新。]]></summary></entry><entry><title type="html">FlashInfer Sorting-Free Sampling：无需显式排序的 GPU 采样</title><link href="https://charlestar.github.io/2026/05/24/flashinfer-sorting-free-sampling-llm-inference-sampling-performance-breakthrough/" rel="alternate" type="text/html" title="FlashInfer Sorting-Free Sampling：无需显式排序的 GPU 采样" /><published>2026-05-24T12:00:00+08:00</published><updated>2026-08-09T00:00:00+08:00</updated><id>https://charlestar.github.io/2026/05/24/flashinfer-sorting-free-sampling-llm-inference-sampling-performance-breakthrough</id><content type="html" xml:base="https://charlestar.github.io/2026/05/24/flashinfer-sorting-free-sampling-llm-inference-sampling-performance-breakthrough/"><![CDATA[<blockquote>
  <p><strong>校订说明</strong>：原文自制了客服、翻译和代码生成的性能表，并使用了并不存在的统一配置 API。本文改为解释官方算子的统计语义与集成边界。</p>
</blockquote>

<h2 id="1-为什么避免排序">1. 为什么避免排序</h2>

<p>Top-k/Top-p 采样的直观实现会对整个词表排序。词表很大、batch 较小时，排序和中间张量会成为可见开销。FlashInfer 提供基于 GPU 拒绝采样的算子，在不显式全排序的情况下实现 top-k、top-p 及组合过滤。</p>

<p>关键点是 <strong>分布等价</strong>，不是固定随机种子下逐 token 与另一实现完全相同。不同实现消耗随机数的顺序可能不同，因此输出样本可不同，但应服从同一目标分布。</p>

<h2 id="2-常用接口">2. 常用接口</h2>

<p>当前官方 API 包括：</p>

<ul>
  <li><code class="language-plaintext highlighter-rouge">top_k_sampling_from_probs</code></li>
  <li><code class="language-plaintext highlighter-rouge">top_p_sampling_from_probs</code></li>
  <li><code class="language-plaintext highlighter-rouge">top_k_top_p_sampling_from_logits</code></li>
  <li><code class="language-plaintext highlighter-rouge">min_p_sampling_from_probs</code></li>
</ul>

<p>参数名、输入是 logits 还是 probabilities、以及 top-k/top-p 的应用顺序会随具体接口而不同，应以安装版本的文档为准。</p>

<h2 id="3-正确性验证">3. 正确性验证</h2>

<ol>
  <li>检查被过滤 token 的经验概率接近零。</li>
  <li>在小词表上与可枚举的参考分布做统计检验。</li>
  <li>覆盖 $k=1$、$k=V$、$p\to0$、$p=1$ 和混合 batch 参数。</li>
  <li>分别验证 deterministic 选项和每请求 generator/seed 的行为。</li>
  <li>不把“统计等价”误写成“位级输出一致”。</li>
</ol>

<h2 id="4-性能验证">4. 性能验证</h2>

<p>单独测 kernel 延迟后，还要在真实 serving workload 中测端到端 TPOT。采样通常只是解码路径的一部分；当模型前向占主导时，即使采样 kernel 大幅加速，端到端收益也可能有限。</p>

<p>vLLM 已包含调用 FlashInfer sampling 的实现，但是否启用取决于版本、安装和采样配置。不要依赖博客中的虚构 <code class="language-plaintext highlighter-rouge">sampling_backend</code> 配置，应查看目标版本源码与文档。</p>

<h2 id="5-top-k-与-top-p-的语义">5. Top-k 与 Top-p 的语义</h2>

<p>Top-k 只保留概率最高的 $k$ 个 token；top-p 保留按概率从高到低累积达到阈值 $p$ 的最小集合，再归一化采样。两者组合时，先后顺序可能影响候选集合，因此 API 提供的 <code class="language-plaintext highlighter-rouge">filter_apply_order</code> 需要明确记录。</p>

<p>Min-p 则按当前最大概率的比例设置动态阈值，常写成保留 $p_i\ge p_{min}\max_j p_j$ 的 token。它与 top-p 的累计概率语义不同。</p>

<h2 id="6-拒绝采样直觉">6. 拒绝采样直觉</h2>

<p>无需排序的方法可以从原分布提出候选，再检查候选是否位于 top-k/top-p 允许集合；不满足则重试。GPU 上可并行生成随机量、估计/确定阈值并进行接受判断。最坏情况下可能多轮重试，因此实现通常设置最大轮数和 fallback。</p>

<h2 id="7-deterministic-参数">7. Deterministic 参数</h2>

<p>FlashInfer 文档中的 deterministic 通常描述算法执行/随机数使用的特定模式，不应直接理解为跨 GPU、跨版本和跨实现逐 bit 相同。需要可重放时，还要固定 generator/seed、offset、输入 logits 和软件栈。</p>

<h2 id="8-统计测试">8. 统计测试</h2>

<p>构造小词表和已知概率，采样足够多次，比较经验频率与 reference 分布。除了卡方/总变差距离，还应检查被过滤 token 从未出现、概率和为 1、每请求不同 $k/p$ 以及 NaN 输入行为。</p>

<h2 id="9-serving-集成">9. Serving 集成</h2>

<p>动态 batch 中每个请求可有不同 top-k/top-p/seed。实现需避免为每个请求启动独立 kernel，并正确维护 generator 状态。返回 logprobs 时，过滤前还是过滤后的概率也要遵循 API 契约。</p>

<h2 id="参考资料">参考资料</h2>

<ul>
  <li><a href="https://docs.flashinfer.ai/api/sampling.html">FlashInfer sampling API</a></li>
  <li><a href="https://github.com/flashinfer-ai/flashinfer">FlashInfer 官方仓库</a></li>
  <li><a href="https://github.com/vllm-project/vllm/blob/main/vllm/v1/sample/ops/topk_topp_sampler.py">vLLM FlashInfer sampler implementation</a></li>
</ul>]]></content><author><name>iStar</name></author><category term="AI Infra" /><category term="FlashInfer" /><category term="LLM推理" /><category term="Sampling" /><summary type="html"><![CDATA[校订说明：原文自制了客服、翻译和代码生成的性能表，并使用了并不存在的统一配置 API。本文改为解释官方算子的统计语义与集成边界。]]></summary></entry><entry><title type="html">vLLM V1 EngineCore：引擎进程与执行核心的解耦</title><link href="https://charlestar.github.io/2026/05/23/vllm-v1-engine-architecture-reconstruction-from-single-process-to-multi-process-enginecore-evolution/" rel="alternate" type="text/html" title="vLLM V1 EngineCore：引擎进程与执行核心的解耦" /><published>2026-05-23T12:00:00+08:00</published><updated>2026-08-09T00:00:00+08:00</updated><id>https://charlestar.github.io/2026/05/23/vllm-v1-engine-architecture-reconstruction-from-single-process-to-multi-process-enginecore-evolution</id><content type="html" xml:base="https://charlestar.github.io/2026/05/23/vllm-v1-engine-architecture-reconstruction-from-single-process-to-multi-process-enginecore-evolution/"><![CDATA[<blockquote>
  <p><strong>校订说明</strong>：原文包含不存在的 Python API、概念性 Docker/Kubernetes 配置和无来源性能表，现已删除。</p>
</blockquote>

<h2 id="1-v1-重构的目标">1. V1 重构的目标</h2>

<p>vLLM V1 把请求处理、调度、KV Cache 管理和模型执行重新组织为更清晰的 EngineCore 边界。EngineCore 可以运行在同一进程，也可以通过进程间通信与前端解耦；“V1”并不简单等于“所有部署都强制多进程”。</p>

<div class="language-text highlighter-rouge"><div class="highlight"><pre class="highlight"><code>API / AsyncLLM frontend
        ↓ request / output messages
EngineCore client
        ↓
EngineCore: scheduler + KV cache manager + executor
        ↓
model runner / workers
</code></pre></div></div>

<h2 id="2-统一调度">2. 统一调度</h2>

<p>V1 以 token budget 为核心统一处理 prompt token 与 output token，使 chunked prefill、prefix caching 和 speculative decoding 更容易组合。调度器仍需在吞吐、TTFT、TPOT 和公平性之间取舍，不存在对所有 workload 都最优的固定策略。</p>

<h2 id="3-prefix-caching">3. Prefix Caching</h2>

<p>Automatic Prefix Caching 通过块哈希识别可复用前缀。命中缓存能跳过部分 prefill 计算，但不会跳过 decode，也不会保证所有重复文本都命中：tokenization、块边界、LoRA/模型配置和缓存驱逐都会影响复用。</p>

<h2 id="4-迁移原则">4. 迁移原则</h2>

<ul>
  <li>使用目标版本的官方 CLI；不要复制内部类构造示例。</li>
  <li>对模型、量化、LoRA、多模态和并行配置做支持矩阵检查。</li>
  <li>以真实流量回放比较 V0/V1，不把论文或单一基准的最大值当 SLA。</li>
  <li>监控请求队列、TTFT、TPOT、缓存命中率和 preemption。</li>
  <li>保留快速回退，并在升级时阅读 breaking changes。</li>
</ul>

<h2 id="5-enginecore-的消息边界">5. EngineCore 的消息边界</h2>

<p>前端把请求转换为 EngineCore 可处理的结构，EngineCore 每轮返回新增 token、完成状态和必要统计。把核心放到独立进程可以隔离 tokenizer/API 的波动，也允许不同 frontend 共享核心，但会增加序列化、IPC 队列、背压与进程故障处理。</p>

<p>高性能实现通常传递紧凑 metadata，而不是复制大张量。输入、输出与控制消息还需要 request ID 和严格生命周期，避免取消请求后迟到结果污染新请求。</p>

<h2 id="6-token-budget-调度示例">6. Token-budget 调度示例</h2>

<p>假设本轮预算为 1024 token：一个新请求还有 900 prompt tokens，两个在途请求各需生成 1 token。调度器可以先给 decode 各 1 token，再把剩余 1022 分给 chunked prefill。下一轮继续未完成 prompt。这样既避免一次大 prefill 阻塞 decode，也提高 GPU batch 的有效工作量。</p>

<p>真实策略还要受可用 KV blocks、encoder inputs、speculative lookahead 和优先级约束。</p>

<h2 id="7-prefix-cache-命中不是免费午餐">7. Prefix cache 命中不是免费午餐</h2>

<p>命中能省 prefill FLOPs，但哈希查找、block 引用和缓存占用仍有成本。高基数随机 prompt 可能让缓存快速驱逐；共享前缀短于块边界时收益也有限。评测应同时报告 hit rate 和被跳过的 token 数，单纯“请求命中比例”可能夸大价值。</p>

<h2 id="8-故障与背压">8. 故障与背压</h2>

<p>多进程 EngineCore 必须明确：队列满时拒绝还是等待、worker 退出后请求如何失败、frontend 断连是否取消生成、以及重启后 KV state 是否重算。架构解耦提高可维护性，但这些分布式系统问题不会自动消失。</p>

<h2 id="参考资料">参考资料</h2>

<ul>
  <li><a href="https://blog.vllm.ai/2025/01/27/v1-alpha-release.html">vLLM V1 alpha announcement</a></li>
  <li><a href="https://docs.vllm.ai/">vLLM 官方文档</a></li>
  <li><a href="https://github.com/vllm-project/vllm">vLLM 官方仓库</a></li>
</ul>]]></content><author><name>iStar</name></author><category term="AI Infra" /><category term="vLLM" /><category term="EngineCore" /><category term="LLM推理" /><summary type="html"><![CDATA[校订说明：原文包含不存在的 Python API、概念性 Docker/Kubernetes 配置和无来源性能表，现已删除。]]></summary></entry><entry><title type="html">FlashInfer-Bench：AI 生成 GPU Kernel 的评测与上线边界</title><link href="https://charlestar.github.io/2026/05/22/flashinfer-bench-ai-auto-generated-gpu-kernel-production-deployment-practice/" rel="alternate" type="text/html" title="FlashInfer-Bench：AI 生成 GPU Kernel 的评测与上线边界" /><published>2026-05-22T12:00:00+08:00</published><updated>2026-08-09T00:00:00+08:00</updated><id>https://charlestar.github.io/2026/05/22/flashinfer-bench-ai-auto-generated-gpu-kernel-production-deployment-practice</id><content type="html" xml:base="https://charlestar.github.io/2026/05/22/flashinfer-bench-ai-auto-generated-gpu-kernel-production-deployment-practice/"><![CDATA[<blockquote>
  <p><strong>校订说明</strong>：原文把概念性命令、虚构基准和未经验证的在线替换写成现成功能。FlashInfer-Bench 首先是定义、生成、验证和评测 kernel 的框架，不是自动替换线上算子的无风险控制面。</p>
</blockquote>

<h2 id="1-它解决的问题">1. 它解决的问题</h2>

<p>AI 生成的 GPU kernel 很容易在单一 shape 上跑得快，却在边界输入、不同 dtype 或不同 GPU 上出错。FlashInfer-Bench 用标准化 definition、workload 和 reference implementation 描述任务，让候选 solution 能在同一套正确性与性能规则下比较。</p>

<div class="language-text highlighter-rouge"><div class="highlight"><pre class="highlight"><code>definition + workload + reference
                ↓
        candidate solution
                ↓
 correctness gate -&gt; benchmark -&gt; ranking/artifact
</code></pre></div></div>

<p>这里最重要的是 <strong>correctness gate 在性能排名之前</strong>。仅通过少量随机输入，不能证明数值稳定性、越界安全或所有 shape 都正确。</p>

<h2 id="2-从评测到生产还缺什么">2. 从评测到生产还缺什么</h2>

<ul>
  <li>固定编译器、驱动、CUDA 和目标 GPU 架构；</li>
  <li>覆盖极小/极大 shape、非对齐尺寸、NaN/Inf 和空 batch；</li>
  <li>与高精度 reference 比较，并按算子定义设置误差阈值；</li>
  <li>使用隔离进程和资源限制执行不受信任代码；</li>
  <li>保存源码、编译参数、二进制、测试报告和可复现环境；</li>
  <li>灰度、监控、熔断并保留已知正确 kernel 的回退路径。</li>
</ul>

<h2 id="3-性能评测原则">3. 性能评测原则</h2>

<p>报告至少应包含延迟分布、吞吐、warm-up、重复次数、输入 shape 分布和硬件信息。单个 batch size 的最大提升不能概括真实服务收益；kernel 级加速也不能直接等同于端到端加速。</p>

<h2 id="4-合理定位">4. 合理定位</h2>

<p>FlashInfer-Bench 让“生成—验证—比较”更系统，但生产上线仍属于独立的软件供应链与安全问题。更准确的表述是：它为 AI 生成 kernel 提供可复现评测基础，而不是保证生成代码可直接进入生产。</p>

<h2 id="5-definitionworkload-与-solution">5. Definition、workload 与 solution</h2>

<ul>
  <li><strong>Definition</strong> 描述算子签名、dtype/shape 约束和语义。</li>
  <li><strong>Workload</strong> 给出真实要评测的输入分布及权重。</li>
  <li><strong>Solution</strong> 是某个 backend/kernel 实现。</li>
</ul>

<p>把三者分离后，同一语义可比较多个实现，同一 kernel 也能在多个 workload 上测试。若 definition 含糊，AI 很容易通过利用未说明边界“刷榜”而非正确优化。</p>

<h2 id="6-correctness-gate-设计">6. Correctness gate 设计</h2>

<p>正确性不应只有单一 <code class="language-plaintext highlighter-rouge">allclose</code>：</p>

<ol>
  <li>生成随机与对抗 shape；</li>
  <li>用高可信 reference 计算输出；</li>
  <li>对不同 dtype 设置合理 atol/rtol；</li>
  <li>检查 NaN、越界写和未初始化内存；</li>
  <li>多次运行捕获竞态与非确定性；</li>
  <li>对 reduction/atomic 算子允许合理舍入差异。</li>
</ol>

<p>可在 sanitizers、超时和隔离进程中运行候选，防止错误 kernel 挂死整个评测服务。</p>

<h2 id="7-防止-benchmark-gaming">7. 防止 benchmark gaming</h2>

<p>隐藏测试集、变化 shape 分布、检查输出依赖输入、限制硬编码和异常缓存。性能结果要包含编译时间还是只含运行时间也必须明确。只优化公开的少量输入可能得到高分，却无法泛化到线上。</p>

<h2 id="8-artifact-promotion">8. Artifact promotion</h2>

<p>候选通过评测后生成不可变 artifact，记录源码 hash、工具链、GPU 架构和测试报告。进入 staging 后用 shadow traffic 比较 reference；只有质量、稳定性和端到端收益都达标才逐步放量。</p>

<h2 id="9-回退与版本管理">9. 回退与版本管理</h2>

<p>运行时选择 kernel 时应有兼容性谓词和已知正确 fallback。驱动、CUDA 或框架升级会使旧二进制失效，因此 artifact 不能只按算子名缓存。</p>

<h2 id="参考资料">参考资料</h2>

<ul>
  <li><a href="https://github.com/flashinfer-ai/flashinfer-bench">FlashInfer-Bench 官方仓库</a></li>
  <li><a href="https://github.com/flashinfer-ai/flashinfer-bench-starter-kit">MLSys 2026 starter kit</a></li>
  <li><a href="https://github.com/flashinfer-ai/flashinfer">FlashInfer 官方仓库</a></li>
</ul>]]></content><author><name>iStar</name></author><category term="AI Infra" /><category term="FlashInfer" /><category term="GPU Kernel" /><category term="Benchmark" /><summary type="html"><![CDATA[校订说明：原文把概念性命令、虚构基准和未经验证的在线替换写成现成功能。FlashInfer-Bench 首先是定义、生成、验证和评测 kernel 的框架，不是自动替换线上算子的无风险控制面。]]></summary></entry><entry><title type="html">QuantSpec：分层量化 KV Cache 的自推测解码</title><link href="https://charlestar.github.io/2026/05/21/QuantSpec-Self-Speculative-Decoding-with-Hierarchical-Quantized-KV-Cache-for-Long-Context-Inference-Acceleration/" rel="alternate" type="text/html" title="QuantSpec：分层量化 KV Cache 的自推测解码" /><published>2026-05-21T12:00:00+08:00</published><updated>2026-08-09T00:00:00+08:00</updated><id>https://charlestar.github.io/2026/05/21/QuantSpec-Self-Speculative-Decoding-with-Hierarchical-Quantized-KV-Cache-for-Long-Context-Inference-Acceleration</id><content type="html" xml:base="https://charlestar.github.io/2026/05/21/QuantSpec-Self-Speculative-Decoding-with-Hierarchical-Quantized-KV-Cache-for-Long-Context-Inference-Acceleration/"><![CDATA[<blockquote>
  <p><strong>校订说明</strong>：原文把概念性 vLLM/SGLang 类写成现成 API，并添加了法律、金融等虚构案例。以下内容严格区分论文方案与推理框架现成功能。</p>
</blockquote>

<h2 id="1-核心动机">1. 核心动机</h2>

<p>长上下文下，目标模型与独立草稿模型各自维护 KV Cache 会增加显存压力。QuantSpec 采用同一模型的低精度路径生成草稿，再由高精度路径验证，并对不同阶段使用分层量化 KV Cache，以降低草稿开销和缓存占用。</p>

<h2 id="2-分层缓存的直觉">2. 分层缓存的直觉</h2>

<div class="language-text highlighter-rouge"><div class="highlight"><pre class="highlight"><code>已确认前缀 -&gt; 更激进的低比特缓存
近期/候选区域 -&gt; 较高精度缓存
draft -&gt; verify -&gt; accept/reject -&gt; update cache state
</code></pre></div></div>

<p>“自推测”避免额外加载一个完整草稿模型，但低精度执行仍需要可用 kernel，量化/反量化也有成本。分层缓存还必须正确处理回滚：被拒绝的候选 token 不能污染已确认状态。</p>

<h2 id="3-正确性与质量">3. 正确性与质量</h2>

<p>经典推测采样可以通过接受/拒绝与修正分布保持目标分布不变；量化草稿只影响提议效率。若验证路径、概率计算或 KV 状态也被近似，就必须重新说明误差来源，不能笼统声称“完全无损”。</p>

<h2 id="4-如何阅读论文结果">4. 如何阅读论文结果</h2>

<p>论文中的加速与显存结果绑定模型、序列长度、GPU、量化格式和 batch size。工程评估至少应复现：</p>

<ul>
  <li>平均接受长度和拒绝率；</li>
  <li>draft、verify、rollback 各阶段耗时；</li>
  <li>峰值显存与有效 KV 字节/token；</li>
  <li>perplexity/任务指标与采样分布；</li>
  <li>长上下文不同位置的误差。</li>
</ul>

<h2 id="5-集成边界">5. 集成边界</h2>

<p>截至校订时，不能仅凭一段自定义 <code class="language-plaintext highlighter-rouge">QuantSpecConfig</code> 代码断言 vLLM 或 SGLang 已原生提供同名接口。应先确认官方 release、文档和实现；没有上游支持时，它仍是研究复现/自定义后端工作，而非开箱即用配置。</p>

<h2 id="6-为什么旧-kv-更适合低精度">6. 为什么旧 KV 更适合低精度</h2>

<p>近期 token 往往更可能受到局部注意力和高权重访问，较早 token 的缓存数量却占长上下文的大部分。分层策略可让近期窗口保留较高精度，远端历史使用更低精度，在容量和误差间折中。这个经验并非对每个模型成立，检索型任务可能突然强烈访问很早位置。</p>

<h2 id="7-量化单元">7. 量化单元</h2>

<p>KV 量化通常需要 scale：按 tensor 最省 metadata 但适应性弱；按 head、token 或 block 能更好跟随动态范围，却增加 scale 存储和 kernel 复杂度。4-bit 数据还涉及 nibble packing、对齐和反量化向量化。</p>

<p>一个对称量化示意为：</p>

\[s=\frac{\max |x|}{2^{b-1}-1},\qquad q=\operatorname{clip}(\operatorname{round}(x/s))\]

<p>论文具体格式应以原文为准；这个公式只用于理解 scale 与舍入误差。</p>

<h2 id="8-cache-提交与回滚">8. Cache 提交与回滚</h2>

<p>草稿路径写入低精度候选状态，验证路径需要高精度/目标状态。实现可维护 staging 区：接受的前缀提交到正式缓存，拒绝及其后候选丢弃。原地覆盖若没有事务式边界，容易让下一轮读取错误 KV。</p>

<h2 id="9-误差定位">9. 误差定位</h2>

<p>分别比较 K/V 重构误差、单层 attention output、整模型 logits 与最终任务质量。若只看 perplexity，可能漏掉长上下文检索的局部失败；若只看 end-to-end task，又难定位是量化、草稿还是回滚错误。</p>

<h2 id="10-复现路线">10. 复现路线</h2>

<p>先实现无推测的分层 KV 量化并验证质量；再加入 self-draft；最后加入接受/回滚。每一步都有独立 reference，能避免多个近似同时引入后无法定位问题。</p>

<h2 id="参考资料">参考资料</h2>

<ul>
  <li><a href="https://arxiv.org/abs/2502.10424">QuantSpec paper</a></li>
  <li><a href="https://arxiv.org/abs/2302.07863">Speculative Decoding with Big Little Decoder</a></li>
  <li><a href="https://docs.vllm.ai/">vLLM 官方文档</a></li>
  <li><a href="https://docs.sglang.ai/">SGLang 官方文档</a></li>
</ul>]]></content><author><name>iStar</name></author><category term="AI Infra" /><category term="推测解码" /><category term="KV Cache" /><category term="量化" /><summary type="html"><![CDATA[校订说明：原文把概念性 vLLM/SGLang 类写成现成 API，并添加了法律、金融等虚构案例。以下内容严格区分论文方案与推理框架现成功能。]]></summary></entry><entry><title type="html">DeepSeek V3.2 稀疏注意力：Lightning Indexer 与 Top-k 选择</title><link href="https://charlestar.github.io/2026/05/18/deepseek-v3-2-sparse-attention/" rel="alternate" type="text/html" title="DeepSeek V3.2 稀疏注意力：Lightning Indexer 与 Top-k 选择" /><published>2026-05-18T12:00:00+08:00</published><updated>2026-08-09T00:00:00+08:00</updated><id>https://charlestar.github.io/2026/05/18/deepseek-v3-2-sparse-attention</id><content type="html" xml:base="https://charlestar.github.io/2026/05/18/deepseek-v3-2-sparse-attention/"><![CDATA[<blockquote>
  <p><strong>校订说明</strong>：原文对 Claude/Gemini 的内部注意力结构作了无来源断言，并包含自制硬件基准、质量表和成本数据，现已删除。</p>
</blockquote>

<h2 id="1-dsa-的结构">1. DSA 的结构</h2>

<p>DeepSeek Sparse Attention（DSA）由两个阶段组成：</p>

<ol>
  <li><strong>Lightning Indexer</strong> 为当前 query 与历史 token 计算轻量相关性分数；</li>
  <li><strong>Fine-grained token selection</strong> 选择 top-k KV 条目执行正式注意力。</li>
</ol>

<p>当 $k$ 固定且 $k\ll n$ 时，正式注意力部分由 $O(n^2)$ 降为约 $O(nk)$。但索引、top-k、稀疏 gather 和缓存布局也有成本，所以不能直接把渐进复杂度等同于端到端加速。</p>

<h2 id="2-lightning-indexer">2. Lightning Indexer</h2>

<p>官方 V3.2-Exp 说明中，indexer 使用少量头，并可采用 FP8。概念上可写为：</p>

\[I_{t,s}=\sum_j w_{t,j}^{I}\,\operatorname{ReLU}(q_{t,j}^{I}\cdot k_s^{I})\]

<p>随后根据 $I_{t,:}$ 选择 top-k 历史位置。这里的 index 分数服务于候选选择，不等同于最终 attention probability。</p>

<h2 id="3-工程难点">3. 工程难点</h2>

<ul>
  <li>top-k 本身需要高效 kernel，长序列下不能大量物化中间张量；</li>
  <li>稀疏索引要映射到分页 KV Cache 的物理块；</li>
  <li>gather 后的访问模式可能不连续，理论 FLOPs 下降不保证带宽效率同步提高；</li>
  <li>continuous batching 中不同请求长度和选择位置不同，需要 ragged metadata；</li>
  <li>短上下文可能没有足够收益，应允许 dense fallback。</li>
</ul>

<h2 id="4-质量与评测">4. 质量与评测</h2>

<p>稀疏选择会改变模型能访问的上下文。评测应覆盖 needle retrieval、长文档问答、长代码和长链推理，并与 dense attention 在相同权重/采样条件下比较。不能把某个平均分差异概括为所有任务“质量无损”。</p>

<h2 id="5-indexer-与正式注意力的数据流">5. Indexer 与正式注意力的数据流</h2>

<div class="language-text highlighter-rouge"><div class="highlight"><pre class="highlight"><code>hidden state h_t
 -&gt; lightweight query/index weights
 -&gt; score against historical index keys
 -&gt; top-k positions
 -&gt; gather compressed/full KV for selected positions
 -&gt; sparse attention
 -&gt; output projection
</code></pre></div></div>

<p>Indexer key 可以比正式 K/V 更小，并使用更低精度，从而让扫描历史的成本低于完整 attention。最终 attention 仍使用模型定义的表示计算输出。</p>

<h2 id="6-复杂度拆解">6. 复杂度拆解</h2>

<p>令序列长度为 $n$、选择数量为 $k$。正式 attention 约为 $O(nk)$，但 index score 若对所有历史位置计算，仍有 $O(n^2d_I)$ 项，只是 $d_I$ 和头数较小、精度更低。工程收益来自“便宜的全局筛选 + 昂贵计算只做 top-k”，不能简单忽略 indexer 成本。</p>

<h2 id="7-top-k-kernel">7. Top-k Kernel</h2>

<p>长序列 top-k 需要分块选择和归并。直接生成完整 score 矩阵会破坏内存优势；更合理的是每个 tile 保留局部候选，再层级归并全局 top-k。并行实现还要稳定处理相同分数、mask 和 causal 范围。</p>

<h2 id="8-与-paged-kv-的结合">8. 与 Paged KV 的结合</h2>

<p>逻辑 token position 经 block table 转成物理 page/offset，稀疏选择结果可能非常离散。实现需要批量 gather 并尽量合并相邻位置，减少随机访存。IndexCache 一类结构可缓存 indexer 所需状态，但不等同于正式 KV Cache。</p>

<h2 id="9-dense-fallback">9. Dense fallback</h2>

<p>当上下文不超过 $k$、top-k 管理成本高于 dense kernel，或某种 backend 不支持稀疏路径时，使用 dense attention 更合理。阈值应由 microbenchmark 决定，并按 GPU 架构调整。</p>

<h2 id="参考资料">参考资料</h2>

<ul>
  <li><a href="https://github.com/deepseek-ai/DeepSeek-V3.2-Exp">DeepSeek-V3.2-Exp 官方仓库</a></li>
  <li><a href="https://github.com/vllm-project/vllm">vLLM 官方仓库</a></li>
  <li><a href="https://github.com/flashinfer-ai/flashinfer">FlashInfer 官方仓库</a></li>
</ul>]]></content><author><name>iStar</name></author><category term="AI Infra" /><category term="LLM推理" /><category term="稀疏注意力" /><summary type="html"><![CDATA[校订说明：原文对 Claude/Gemini 的内部注意力结构作了无来源断言，并包含自制硬件基准、质量表和成本数据，现已删除。]]></summary></entry></feed>