<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>SSE on 吕炘嵘的博客</title>
    <link>https://blog.lvxinrong.com/tags/sse/</link>
    <description>Recent content in SSE on 吕炘嵘的博客</description>
    <image>
      <title>吕炘嵘的博客</title>
      <url>https://blog.lvxinrong.com/og-default.jpg</url>
      
      <link>https://blog.lvxinrong.com/tags/sse/</link>
    </image>
    <generator>Hugo</generator>
    <language>zh-CN</language>
    <lastBuildDate>Wed, 11 Nov 2026 13:53:19 +0800</lastBuildDate>
    <atom:link href="https://blog.lvxinrong.com/tags/sse/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>手搓 LLM 笔记 21：I3 推理与服务</title>
      <link>https://blog.lvxinrong.com/llm/llm-21-i3-inference-baseline/</link>
      <pubDate>Wed, 11 Nov 2026 13:53:19 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-21-i3-inference-baseline/</guid>
      <description>I3 完整实录：推理基线、会话级 KV Cache、INT8 / INT4、贪心投机解码、SSE 多会话、MHA / GQA 实测与 CUDA 复测，并定位 FP16 的 RMSNorm 平方溢出。保留性能负收益、数值边界与待复盘项。</description>
      <content:encoded><![CDATA[<p>I3 正式开始。和 I2 不同，这一段不再围绕训练吞吐、反向传播和参数更新展开，而是围绕一个已经训练好的模型：<strong>输入一段 prompt 之后，它是怎样一步一步生成回答的，又该如何测量和优化这条链路。</strong></p>
<p>第一站不是量化，也不是投机解码，而是先把推理基线立起来。没有基线，后面的“变快了”和“更省显存”都没有可靠的对照对象。</p>
<blockquote>
<p>阅读主线：第一至四节是 I3-0 推理基线；第五至七节是 I3-1 增量 prefill、会话复用与滑动窗口；第八至十四节是 I3-2 权重量化、16-bit 激活和 FP16 排障。第十一节保留修复前现场，第十三、十四节是修复后的正式复测；结尾第十五节统一汇总结论与边界。</p>
</blockquote>
<h2 id="一推理其实分为两步">一、推理其实分为两步</h2>
<p>过去看生成代码时，容易把整个 <code>generate()</code> 当成一个黑盒：输入提示词，循环若干次，文字就一个 token 一个 token 地出来了。</p>
<p>这次把它拆开后，结构其实非常清楚：<strong>Prefill（预填充）和 Decode（解码）</strong>。</p>
<h3 id="1-prefill一次性处理完整-prompt">1. Prefill：一次性处理完整 prompt</h3>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">完整 prompt
</span></span><span class="line"><span class="cl">    ↓ 一次性送入模型
</span></span><span class="line"><span class="cl">计算每个 prompt token 在每层的 K / V
</span></span><span class="line"><span class="cl">    ↓
</span></span><span class="line"><span class="cl">得到 past_kv + 最后一个位置的 logits
</span></span><span class="line"><span class="cl">    ↓
</span></span><span class="line"><span class="cl">采出第一个新 token
</span></span></code></pre></div><p>Prompt 中的所有 token 会一起进入模型。因果掩码仍然保证每个位置不能偷看未来，但矩阵计算可以覆盖整段 prompt，不必等前一个 prompt token 生成完再处理下一个。</p>
<p>这一步除了得到用于采样的 logits，还会留下每一层、每一个 prompt token 的 K 和 V，也就是 <code>past_kv</code>。</p>
<h3 id="2-decode每次只输入一个新-token">2. Decode：每次只输入一个新 token</h3>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">新生成的 token + past_kv
</span></span><span class="line"><span class="cl">    ↓
</span></span><span class="line"><span class="cl">计算这个新 token 的 K / V，并追加到 cache
</span></span><span class="line"><span class="cl">    ↓
</span></span><span class="line"><span class="cl">结合历史 K / V 做注意力计算
</span></span><span class="line"><span class="cl">    ↓
</span></span><span class="line"><span class="cl">得到 logits，采出下一个 token
</span></span><span class="line"><span class="cl">    ↓
</span></span><span class="line"><span class="cl">重复
</span></span></code></pre></div><p>Decode 并不是不再需要模型计算。每个新 token 仍然要经过所有 Transformer 层，只是历史 token 的 K/V 不需要重新计算。</p>
<p>所以 KV Cache 缓存的不是“答案”，也不只是最后一层的隐藏状态，而是：</p>
<blockquote>
<p><strong>每一层、每一个历史 token 的 K 和 V。</strong></p>
</blockquote>
<p>Prefill 主要影响首字延迟，Decode 则决定后续文字向外冒的速度。这就是 TTFT 和 decode tokens/s 要分开测的原因。</p>
<h2 id="二先建立一份不改生成行为的基线">二、先建立一份不改生成行为的基线</h2>
<p>本次新增：</p>
<ul>
<li><code>src/squid/generate/benchmark.py</code>：计时、KV Cache 字节统计与固定长度生成测量；</li>
<li><code>scripts/i3_inference_baseline.py</code>：加载真实模型，执行 warmup 和正式测量，保存报告；</li>
<li><code>tests/test_inference_benchmark.py</code>：对照原有生成函数，验证输出与 KV Cache 字节数。</li>
</ul>
<p>测量入口没有替换正式的 <code>generate()</code>，而是单独建立固定长度 benchmark。这样可以控制实验条件，也不急于改动生产链路。</p>
<h3 id="测量条件">测量条件</h3>
<ul>
<li>模型：Qwen2.5-0.5B-Instruct，真实本地权重；</li>
<li>设备：Mac / MPS；</li>
<li>精度：FP32；</li>
<li>Prompt：36 tokens；</li>
<li>固定生成：32 tokens；</li>
<li>解码：temperature=0，即贪心解码；</li>
<li>不启用 EOS 提前停止，保证每轮都生成相同数量的 token；</li>
<li>每种模式先 warmup 一次；</li>
<li>独立运行三轮，报告中位数；</li>
<li>模型加载和 prompt 编码不计入生成耗时。</li>
</ul>
<p>TTFT 从生成测量开始，到采出第一个新 token 为止。Decode 吞吐使用首字之后的 31 个 token 除以对应时间，不把首字重复算进 decode。</p>
<h2 id="三第一轮真实结果">三、第一轮真实结果</h2>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>模式</th>
        <th style="text-align: right">TTFT 中位数</th>
        <th style="text-align: right">Decode 吞吐中位数</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>KV Cache</td>
        <td style="text-align: right">43.28 ms</td>
        <td style="text-align: right">40.26 tokens/s</td>
      </tr>
      <tr>
        <td>No Cache</td>
        <td style="text-align: right">48.44 ms</td>
        <td style="text-align: right">23.28 tokens/s</td>
      </tr>
    </tbody>
  </table>
</div>
<p>在当前模型、prompt 长度和生成配置下：</p>
<ul>
<li>Cache 的 decode 吞吐约为 no-cache 的 <strong>1.73 倍</strong>；</li>
<li>两种模式的真实输出<strong>逐 token 一致</strong>；</li>
<li>Cache 的 TTFT 中位数较低，但 prompt 只有 36 tokens，三轮首字时间也有波动，先不对这项差异做过度解释；</li>
<li>这个结果使用 Qwen2.5-0.5B 和 Mac / MPS，不与 M3 当时 GPT-2 355M 的 3.6 倍结果直接混比。</li>
</ul>
<p>三轮 decode 吞吐分别为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Cache：   41.15 / 40.26 / 39.01 tokens/s
</span></span><span class="line"><span class="cl">No Cache：23.35 / 22.97 / 23.28 tokens/s
</span></span></code></pre></div><p>三轮汇总保存在 <code>data/reports/i3-inference-baseline-mps-summary.json</code>。</p>
<h2 id="四kv-cache-的实际字节数是怎样算出来的">四、KV Cache 的实际字节数是怎样算出来的</h2>
<p>这次没有只写理论公式，而是直接遍历模型返回的 <code>past_kv</code>：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="nb">sum</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">tensor</span><span class="o">.</span><span class="n">nelement</span><span class="p">()</span> <span class="o">*</span> <span class="n">tensor</span><span class="o">.</span><span class="n">element_size</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="n">layer_kv</span> <span class="ow">in</span> <span class="n">past_kv</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="n">tensor</span> <span class="ow">in</span> <span class="n">layer_kv</span>
</span></span><span class="line"><span class="cl"><span class="p">)</span>
</span></span></code></pre></div><p>这是两层循环。<code>past_kv</code> 的结构是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">past_kv
</span></span><span class="line"><span class="cl">├── 第 0 层：(K 张量, V 张量)
</span></span><span class="line"><span class="cl">├── 第 1 层：(K 张量, V 张量)
</span></span><span class="line"><span class="cl">├── ...
</span></span><span class="line"><span class="cl">└── 第 23 层：(K 张量, V 张量)
</span></span></code></pre></div><p>第一层循环遍历 24 个 Transformer 层，第二层循环遍历每层的 K 和 V。</p>
<p>其中：</p>
<ul>
<li><code>nelement()</code> 是张量中的标量元素总数，也就是各维度长度的乘积，等价于 <code>numel()</code>；</li>
<li><code>element_size()</code> 是单个元素占用的字节数，FP32 为 4 bytes，FP16 / BF16 为 2 bytes；</li>
<li>两者相乘，才是一个张量实际占用的字节数。</li>
</ul>
<p>本次 prefill 后，每个 K 或 V 的形状是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">[batch=1, kv_heads=2, tokens=36, head_dim=64]
</span></span></code></pre></div><p>所以一个张量包含：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">1 × 2 × 36 × 64 = 4608 个元素
</span></span></code></pre></div><p>FP32 下为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">4608 × 4 = 18,432 bytes
</span></span></code></pre></div><p>24 层、每层 K/V 两个张量，总计：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">18,432 × 24 × 2 = 884,736 bytes = 864 KiB
</span></span></code></pre></div><p>换成每个 token 的 KV Cache 成本：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">2（K 和 V）× 24 层 × 2 KV heads × 64 head_dim × 4 bytes
</span></span><span class="line"><span class="cl">= 24,576 bytes/token
</span></span><span class="line"><span class="cl">= 24 KiB/token
</span></span></code></pre></div><p>实测结果和公式完全一致。按这个每 token 成本推算，一个会话达到 4096 tokens 时，仅 KV Cache 约为 <strong>96 MiB</strong>；这是基于实测单位成本的推算，不是一次 4096-token 设备峰值测量。</p>
<h2 id="五代码审查中确认的三个边界">五、代码审查中确认的三个边界</h2>
<h3 id="1-为什么使用-max_new_tokens--1">1. 为什么使用 <code>max_new_tokens &lt; 1</code></h3>
<p>规则是允许所有大于等于 1 的值，因此需要拒绝 0 和负数。<code>!= 1</code> 会把 32、64 等合法值也错误拒绝。</p>
<p>当只生成一个 token 时，可以测 TTFT，但没有后续 decode token，因此 decode 吞吐记为 <code>None</code>，不伪造一个速度。</p>
<h3 id="2-为什么同时检查维度和-batch">2. 为什么同时检查维度和 batch</h3>
<p><code>idx</code> 的约定形状是 <code>(B, T)</code>：</p>
<ul>
<li><code>idx.ndim != 2</code>：要求输入确实有 batch 和 token 两个维度；</li>
<li><code>idx.shape[0] != 1</code>：当前基线只测单请求，因此 B 必须为 1；</li>
<li><code>idx.shape[1] &lt; 1</code>：拒绝空 prompt。</li>
</ul>
<p>最终接受的是 <code>(1, T)</code>，且 <code>T &gt;= 1</code>。</p>
<h3 id="3-固定长度测量与-eos-提前停止">3. 固定长度测量与 EOS 提前停止</h3>
<p>当前固定长度函数不接收 <code>eos_id</code>，也没有 EOS <code>break</code>，所以一定会生成指定数量的 token。即使采到 EOS，也只把它当作输出 token。</p>
<p>如果未来把它通用化为支持 EOS 的测量入口，最后一个 token 的计时必须同时覆盖“达到最大生成长度”和“EOS 提前结束”，实际生成 token 数也要按输出长度重新计算。不能只加一句 <code>break</code>，否则计时和吞吐统计都会留下边界问题。</p>
<p>这也是为什么当前函数明确叫 <code>measure_fixed_length_generation</code>，而没有冒充完整的通用生成器。</p>
<h2 id="六一个被新测试逼出来的增量-prefill-bug">六、一个被新测试逼出来的增量 Prefill Bug</h2>
<p>为了准备会话级 KV Cache，先让 <code>generate()</code> 支持传入和返回 <code>past_kv</code>，随后补了一条对照测试：</p>
<ol>
<li>第一轮从 3 个 prompt token 开始，生成 3 个 token，并返回 cache；</li>
<li>第二轮新增 2 个 token；</li>
<li>对照组把第一轮输出和新增 token 拼成完整 prompt，从头重算；</li>
<li>实验组只输入新增的 2 个 token，复用第一轮 cache；</li>
<li>两组新生成的 token 和最终 cache 长度必须一致。</li>
</ol>
<p>这条测试第一次运行时失败了：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">RuntimeError: The size of tensor a (8) must match the size of tensor b (2)
</span></span><span class="line"><span class="cl">at non-singleton dimension 3
</span></span></code></pre></div><h3 id="1-为什么是-2-和-8">1. 为什么是 2 和 8</h3>
<p>第一轮结束后，cache 中已有 6 个 token。第二轮一次新增 2 个 token，因此：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">q_len = 2
</span></span><span class="line"><span class="cl">k_len = 6 + 2 = 8
</span></span><span class="line"><span class="cl">attn_scores.shape = (B, H, 2, 8)
</span></span></code></pre></div><p>但 v1 的旧代码仍然按本轮 query 数量切掩码：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">mask_bool</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">mask</span><span class="o">.</span><span class="n">bool</span><span class="p">()[:</span><span class="n">q_len</span><span class="p">,</span> <span class="p">:</span><span class="n">q_len</span><span class="p">]</span>
</span></span></code></pre></div><p>得到的是 <code>2 × 2</code>，无法应用到 <code>2 × 8</code> 的注意力分数上。</p>
<h3 id="2-为什么旧测试一直没有发现">2. 为什么旧测试一直没有发现</h3>
<p>此前的两条常见路径都恰好绕开了这个问题：</p>
<ul>
<li>全新 prefill 没有历史 cache，<code>q_len == k_len</code>，方形掩码恰好适用；</li>
<li>单 token decode 时 <code>q_len == 1</code>，代码直接使用 <code>mask_bool = None</code>，因为唯一的新 token 可以看到全部历史。</li>
</ul>
<p>只有“已有 cache，同时一次新增多个 token”时，才会同时出现 <code>q_len &gt; 1</code> 和 <code>k_len &gt; q_len</code>。这就是多 token 增量 prefill 与此前单 token decode 的本质差别。</p>
<h3 id="3-不能只把掩码扩成-2--8">3. 不能只把掩码扩成 2 × 8</h3>
<p>还需要保证掩码的行对应新 token 的真实位置。本轮两个 token 的绝对位置是 6 和 7：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">位置 6：允许看到 0～6，必须屏蔽 7
</span></span><span class="line"><span class="cl">位置 7：允许看到 0～7
</span></span></code></pre></div><p>如果从掩码的第 0 行开始切，即使形状对了，语义也会错。正确修法是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">q_len</span> <span class="o">=</span> <span class="n">queries</span><span class="o">.</span><span class="n">shape</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="n">k_len</span> <span class="o">=</span> <span class="n">keys</span><span class="o">.</span><span class="n">shape</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">if</span> <span class="n">q_len</span> <span class="o">==</span> <span class="mi">1</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">    <span class="n">mask_bool</span> <span class="o">=</span> <span class="kc">None</span>
</span></span><span class="line"><span class="cl"><span class="k">else</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">    <span class="n">past_len</span> <span class="o">=</span> <span class="n">k_len</span> <span class="o">-</span> <span class="n">q_len</span>
</span></span><span class="line"><span class="cl">    <span class="n">mask_bool</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">mask</span><span class="o">.</span><span class="n">bool</span><span class="p">()[</span>
</span></span><span class="line"><span class="cl">        <span class="n">past_len</span><span class="p">:</span><span class="n">past_len</span> <span class="o">+</span> <span class="n">q_len</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="p">:</span><span class="n">k_len</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="p">]</span>
</span></span></code></pre></div><p><code>past_len:past_len + q_len</code> 选中与本轮 token 真实位置对应的掩码行，<code>:k_len</code> 则保留从全部历史到本轮当前的列。</p>
<p>修复后，目标测试通过；连同前面的生成与基线测试，当前为 <strong>9 passed</strong>。</p>
<h3 id="4-掩码切片到底取出了什么">4. 掩码切片到底取出了什么</h3>
<p>模型初始化时会预先生成一张覆盖最大上下文的因果掩码。如果 <code>context_length=1024</code>，<code>self.mask</code> 的形状就是 <code>(1024, 1024)</code>。</p>
<p>上三角掩码中，第 <code>i</code> 行的含义是：</p>
<ul>
<li>第 <code>0～i</code> 列为 <code>0 / False</code>：允许看到历史和当前位置；</li>
<li>第 <code>i+1</code> 列及之后为 <code>1 / True</code>：屏蔽未来位置。</li>
</ul>
<p><code>.bool()</code> 只负责把 0 / 1 转成 False / True，不重新决定屏蔽位置。切片也只是取出已有掩码的一部分，不修改原始掩码，更不会在切片时把某些位置设置为 True。真正使用掩码的是后续的 <code>attn_scores.masked_fill_(mask_bool, -torch.inf)</code>，它就地修改的是注意力分数，不是掩码。</p>
<p>当前修复中的二维切片是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">mask_bool</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">mask</span><span class="o">.</span><span class="n">bool</span><span class="p">()[</span>
</span></span><span class="line"><span class="cl">    <span class="n">past_len</span><span class="p">:</span><span class="n">past_len</span> <span class="o">+</span> <span class="n">q_len</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="p">:</span><span class="n">k_len</span><span class="p">,</span>
</span></span><span class="line"><span class="cl"><span class="p">]</span>
</span></span></code></pre></div><p>逗号前负责行，逗号后负责列：</p>
<ul>
<li>行：从第一个新 token 的绝对位置 <code>past_len</code> 开始，取 <code>q_len</code> 行；切片结束位置不包含在结果中；</li>
<li>列：从第 0 列开始，取 <code>k_len</code> 列，对应当前真实存在的全部 Key。</li>
</ul>
<p>代入本次测试的 <code>past_len=6</code>、<code>q_len=2</code>、<code>k_len=8</code>：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">mask_bool</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">mask</span><span class="o">.</span><span class="n">bool</span><span class="p">()[</span><span class="mi">6</span><span class="p">:</span><span class="mi">8</span><span class="p">,</span> <span class="p">:</span><span class="mi">8</span><span class="p">]</span>
</span></span></code></pre></div><p>这就是从完整掩码中取第 6、7 行和第 0～7 列，得到 <code>2 × 8</code>，正好对应 <code>2 × 8</code> 的注意力分数。</p>
<p>取这些行，是因为本轮新 token 的绝对位置为 6、7；只取这些列，是因为当前只有 8 个 Key。更后面的 Key 不存在，多取不仅没有意义，还会让掩码与注意力分数形状不一致。</p>
<p>当 <code>q_len=1</code> 时，唯一的新 token 已经位于序列末尾，所有现有 Key 都属于历史或当前位置，没有未来 Key 需要屏蔽，因此可以直接使用 <code>mask_bool=None</code>。</p>
<h3 id="5-三个模型版本不能一概而论">5. 三个模型版本不能一概而论</h3>
<ul>
<li>v1：已修复，并通过多 token 增量对照测试；</li>
<li>v2：起初保留相同的旧掩码逻辑，随后使用同样的 <code>past_len</code> 偏移切片修复；</li>
<li>v3：原本就使用 <code>past_len = k_len - q_len</code> 和偏移切片，没有这个缺陷。</li>
</ul>
<p>最后用 pytest 参数化，让同一条增量对照测试分别使用 v1 和 v2 运行，避免复制两份测试后逐渐失去同步。v1、v2 的新增 token 输出和最终 cache 长度均与完整重算一致。</p>
<p>这次最值得保留的经验是：<strong>测试“单 token decode 能复用 cache”，并不等于测试了“任意新增 token 段都能复用 cache”</strong>。正确性测试必须覆盖不同的 <code>q_len / past_len</code> 组合，而不是只跑一条最顺的路径。</p>
<h2 id="七让-kv-cache-活到下一轮对话">七、让 KV Cache 活到下一轮对话</h2>
<p>单次生成的 cache 复用已经跑通后，下一步是把 cache 交给 <code>ChatSession</code> 保存。这里需要同时维护两份状态：</p>
<ul>
<li><code>past_kv</code>：模型内部每一层的 K/V 张量；</li>
<li><code>cached_token_ids</code>：这些 K/V 实际对应哪些文本 token。</li>
</ul>
<p>只有新 prompt 的开头与 <code>cached_token_ids</code> 完全一致，才允许复用 <code>past_kv</code>。命中时只传入新增 token；历史被改写、模板变化或淘汰导致前缀不一致时，必须放弃旧 cache，重新 prefill。</p>
<h3 id="1-eos-后要以真实-cache-长度为准">1. EOS 后要以真实 cache 长度为准</h3>
<p>生成输出中的 token 数不一定等于 KV Cache 中的 token 数。当前 <code>generate()</code> 遇到 EOS 时，先把 EOS 加入输出，再直接 break，不会继续把 EOS 送入模型。</p>
<p>因此保存会话状态时，使用：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">cache_length</span> <span class="o">=</span> <span class="n">present_kv</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">shape</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="n">cached_token_ids</span> <span class="o">=</span> <span class="n">full_token_ids</span><span class="p">[:</span><span class="n">cache_length</span><span class="p">]</span>
</span></span></code></pre></div><p><code>present_kv[0][0]</code> 是第 0 层的 K 张量，其形状为 <code>(B, H_kv, T, D)</code>；<code>shape[2]</code> 是完整 cache 的序列长度 T。各层 K/V 的 T 在当前模型中一致，所以不需要取“最后一层”或“最后一个 token”。</p>
<h3 id="2-按-token-预算淘汰历史">2. 按 token 预算淘汰历史</h3>
<p>进入模型前，先为输出预留空间：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">prompt_budget = context_size - max_new_tokens
</span></span></code></pre></div><p>如果 prompt 超出预算，就删除最早的一轮历史，重新构建并编码 prompt，直到进入预算。System prompt 和当前输入仍由 prompt builder 保留，优先淘汰普通历史。</p>
<p>如果已经没有历史，当前输入自身仍然超长，则明确报错，不静默截断用户输入。这一限制也避免了模型实际使用尾部 <code>idx[:, -context_size:]</code>，而会话却错误记录头部 token IDs 的错位问题。</p>
<p>当前实现会在每轮淘汰后重新构建并编码完整 prompt。历史只有少量轮次时，这优先保证正确性；如果未来支持长会话，可以升级为按 token 块维护账本，减少重复编码。</p>
<h3 id="3-真实-qwen-两轮探针">3. 真实 Qwen 两轮探针</h3>
<p>测试使用同一个真实 Qwen2.5-0.5B-Instruct 模型和相同输入：</p>
<ul>
<li>一条会话正常保存并复用 cache；</li>
<li>另一条保留相同文本历史，但在每轮前清掉 cache，强制完整重算。</li>
</ul>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>轮次</th>
        <th>路径</th>
        <th style="text-align: right">本轮输入 tokens</th>
        <th>使用旧 cache</th>
        <th>输出一致</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>第一轮</td>
        <td>会话 cache</td>
        <td style="text-align: right">30</td>
        <td>否</td>
        <td>是</td>
      </tr>
      <tr>
        <td>第一轮</td>
        <td>完整重算</td>
        <td style="text-align: right">30</td>
        <td>否</td>
        <td>是</td>
      </tr>
      <tr>
        <td>第二轮</td>
        <td>会话 cache</td>
        <td style="text-align: right">15</td>
        <td>是</td>
        <td>是</td>
      </tr>
      <tr>
        <td>第二轮</td>
        <td>完整重算</td>
        <td style="text-align: right">61</td>
        <td>否</td>
        <td>是</td>
      </tr>
    </tbody>
  </table>
</div>
<p>第二轮 prefill 输入从 61 降为 15 个新增 token，减少约 <strong>75.4%</strong>。两条路径的两轮回答均一致，证明这次会话复用不只是状态对象被保存了，而是真实模型链路确实复用了旧 K/V。</p>
<p>该探针没有测量 TTFT 或总耗时，因此当前只声明输入规模和正确性收益，不提前宣称性能提升比例。报告保存在 <code>data/reports/i3-session-cache-probe.json</code>。</p>
<h3 id="4-当前验收与剩余边界">4. 当前验收与剩余边界</h3>
<ul>
<li>会话命中、历史淘汰后回退、当前输入超长拒绝均有测试；</li>
<li>生成、推理基线、RoPE、真实 Qwen cache 和会话相关测试合计 <strong>15 passed</strong>；</li>
<li>真实 Qwen 两轮 cache / 完整重算输出一致；</li>
<li>MPS 仍只有 allocated / driver 快照，没有与 CUDA 相同的峰值接口；</li>
<li>v1 / v2 在历史淘汰后使用完整重算；v3 已接通滑动窗口与部分 KV Cache 复用；</li>
<li>模型内部仍使用动态 <code>torch.cat</code> 追加 K/V，预分配 cache 尚未实现；</li>
<li>量化、投机解码、SSE 和 CUDA 复测尚未完成。</li>
</ul>
<h3 id="5-滑动窗口已接通细节留作后续专题">5. 滑动窗口已接通，细节留作后续专题</h3>
<p>v3 已接入显式 <code>position_offset</code>，<code>ChatSession</code> 使用 <code>next_position</code> 保存会话的原始位置进度。<code>_slide_cache_to_prompt()</code> 已接入 <code>ask()</code>：前缀不一致时，寻找可保留的固定前缀和最近后缀，同步裁剪各层 K/V 与 <code>cached_token_ids</code>，再只对剩余新增 token 做增量 prefill。</p>
<p>裁剪 cache 不会减少 <code>next_position</code>；只有清空会话或完全重建时才从 0 开始。每次生成后，根据 cache 的实际增长量推进位置，因此 EOS 已输出但未进入模型时不会被多算。</p>
<p>验收覆盖：</p>
<ul>
<li>带编号的虚拟 K/V：前缀、后缀和 token IDs 裁剪后逐项一致；</li>
<li>v3 真实模型结构：历史淘汰后只传增量，prefill 使用原始位置，后续 decode 正确递增；</li>
<li>真实 Qwen 权重第三轮滑动：cache 从 66 裁剪到 34 tokens，淘汰后的 prompt 为 53 tokens，实际只输入 19 个新增 token；位置从 66 继续，生成后推进到 90，与 cache 增长一致；</li>
<li>历史被有意淘汰后，回答允许变化，因此滑动场景不拿“与完整重算回答完全一致”作为错误目标。</li>
</ul>
<p>当前对位置编码、前缀 / 后缀匹配和 K/V 裁剪的细节理解仍不够扎实。按学习节奏，将这部分标记为<strong>后续专项研究</strong>；代码链路已经完成最小验收，但后续仍应补更多边界测试与原理复盘，而不是把“跑通”当成“已经吃透”。</p>
<p>I3 主线下一站转入 <strong>INT8 / INT4 权重量化推理</strong>。</p>
<h2 id="八权重量化先理解标尺再讨论-linear-替换">八、权重量化：先理解标尺，再讨论 Linear 替换</h2>
<p>I3 的量化主线是推理侧的 <strong>PTQ（训练后量化）</strong>：模型训练已经完成，不再做反向传播或参数更新，只把已有浮点权重转换成更低精度的表示。</p>
<p>量化的目标不是绝对“不损失能力”，而是在<strong>质量损失可接受</strong>的前提下，减少每个权重的存储空间，降低模型体积和运行时显存，并争取减少带宽开销。提速不是自动结果，仍取决于反量化成本和实际计算 kernel。</p>
<h3 id="1-int8--int4-减少的是每个参数的位数">1. INT8 / INT4 减少的是每个参数的位数</h3>
<p>FP32 每个参数占 4 bytes，INT8 占 1 byte，真正的 INT4 占 0.5 byte。参数量和模型结构没有改变，改变的是每个参数的表示精度。</p>
<p>INT4 如果只把 <code>-7～7</code> 的数值放入 <code>torch.int8</code>，仍然每个值占 1 byte，不是真正的 4-bit 存储；后续还需要 bit packing，把两个 4-bit 数打包进一个 byte。</p>
<p>权重量化与 KV Cache 量化也是两件事。W8A16 / W4A16 表示权重使用 8 / 4 bit、激活使用 16-bit 浮点；当前讨论的仅权重量化不会自动改变此前 KV Cache 的精度。</p>
<h3 id="2-scale-是每行自己的标尺">2. scale 是每行自己的标尺</h3>
<p>逐行对称 INT8 量化使用：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">M = 当前行最大绝对值
</span></span><span class="line"><span class="cl">scale = M / 127
</span></span><span class="line"><span class="cl">量化值 = round(weight / scale)
</span></span></code></pre></div><p>将除法展开：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">weight / (M / 127)
</span></span><span class="line"><span class="cl">= (weight / M) × 127
</span></span></code></pre></div><p>因为 <code>|weight| &lt;= M</code>，所以缩放结果的绝对值不会超过 127。最大绝对值映射到 ±127，其他元素按照自己占最大值的比例映射到中间位置，0 仍然映射到 0。</p>
<p><code>clamp(-127, 127)</code> 是最后的范围保护，正常情况下 absmax 与 scale 已经保证不会越界。<code>.round()</code> 后数值虽然已是整数形式，dtype 仍是浮点；最后 <code>.to(torch.int8)</code> 才改变实际存储类型。</p>
<p>零行没有最大值可作为非零标尺，因此将 scale 安全替换为 1。<code>torch.where(scale == 0, torch.ones_like(scale), scale)</code> 是逐元素选择：scale 为 0 的位置取 1，其余位置保留原值。零行经过 <code>0 / 1</code> 后仍然全部是 0。</p>
<p>小矩阵实测中：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">原始权重：[0.0, 0.5, -1.0, 1.0]
</span></span><span class="line"><span class="cl">INT8：   [0, 64, -127, 127]
</span></span><span class="line"><span class="cl">反量化： [0.0, 0.5039, -1.0, 1.0]
</span></span></code></pre></div><p><code>0.5</code> 到 <code>0.5039</code> 的差异就是量化误差。用户已亲自运行该探针，并完成两项数学测试，结果为 <strong>2 passed</strong>。</p>
<p>这份小矩阵还显示了 scale 的存储成本：12 个 FP32 权重原本占 48 bytes；12 个 INT8 权重占 12 bytes，但 3 个 FP32 行 scale 另占 12 bytes，总计 24 bytes。因此实际压缩倍率要包含 scale 等元数据，不能只看理论位数。</p>
<h3 id="3-ptq-与-lora-不是一回事">3. PTQ 与 LoRA 不是一回事</h3>
<p>LoRA 主要通过训练低秩适配参数来微调能力；权重量化改变的是已有权重的数值表示，不训练新能力。工程上两者都可能涉及 Linear 模块处理，但训练语义不同。</p>
<p>如果训练中使用量化，需要进入 QAT、浮点主权重、梯度近似或低精度训练 kernel 等问题。当前的 INT8 buffer 实现只用于训练后的推理，不支持直接训练 INT8 权重。</p>
<h3 id="4-替换的是-gqa-内部的-linear不是整个-gqa">4. 替换的是 GQA 内部的 Linear，不是整个 GQA</h3>
<p>本次讨论中具体要替换的是这类线性投影：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="bp">self</span><span class="o">.</span><span class="n">W_query</span> <span class="o">=</span> <span class="n">nn</span><span class="o">.</span><span class="n">Linear</span><span class="p">(</span><span class="n">emb_dim</span><span class="p">,</span> <span class="n">emb_dim</span><span class="p">)</span>
</span></span></code></pre></div><p>同理还包括 GQA 内部的 K/V 投影和输出投影等 Linear。这里不是替换整个 <code>GroupedQueryAttention</code>，更不是替换整个 <code>TransformerBlock</code>。</p>
<p>原调用链：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">TransformerBlock.forward()
</span></span><span class="line"><span class="cl">→ GroupedQueryAttention.forward()
</span></span><span class="line"><span class="cl">→ self.W_query(x)（nn.Linear）
</span></span><span class="line"><span class="cl">→ F.linear(x, FP32 weight, bias)
</span></span></code></pre></div><p>替换后：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">TransformerBlock.forward()          不变
</span></span><span class="line"><span class="cl">→ GroupedQueryAttention.forward()   不变
</span></span><span class="line"><span class="cl">→ self.W_query(x)（QuantizedLinearInt8）
</span></span><span class="line"><span class="cl">→ INT8 weight × scale，得到反量化浮点权重
</span></span><span class="line"><span class="cl">→ F.linear(x, 反量化 weight, bias)
</span></span></code></pre></div><p><code>nn.Linear.forward()</code> 的核心本来就是 <code>F.linear(x, weight, bias)</code>，即 <code>x @ weight.T + bias</code>。量化 Linear 重新调用 <code>F.linear</code>，不是漏掉了原层逻辑，而是只替换最底端线性计算的权重来源。</p>
<p>如果包装层同时保存原始 FP32 Linear 和 INT8 副本，原始权重仍占空间，就失去了量化节省存储的意义。因此这里是从原层取出权重并量化，再用不保存 FP32 主权重的新模块替换它。</p>
<p>当前反量化后仍通过 <code>F.linear</code> 做浮点计算，这是教学参考路径，不代表已经获得 INT8 硬件加速；每次 forward 产生的临时浮点权重也需要纳入后续内存测量。</p>
<p>此后已完成小型 v3 与真实 Qwen 的 INT8 / INT4 替换验收；具体过程、测试范围和实测边界见后续章节。</p>
<h2 id="九int8--int4-实测把每一个没看懂变成理解">九、INT8 / INT4 实测：把每一个“没看懂”变成理解</h2>
<p>今天学习量化时，并不是先理解再写代码，而是很多地方先产生疑问，再通过公式、形状和真实输出逐一对齐。比起最终的测试数字，这条理解路径更值得保留。</p>
<h3 id="1-从缩放缺少数学直觉到理解-scale">1. 从“缩放缺少数学直觉”到理解 scale</h3>
<p>最初知道 <code>scale = max / 127</code>，但对为什么缩放后一定落入 <code>-127～127</code> 缺少直觉。
后来将公式展开：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">weight / scale
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">= weight / (M / 127)
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">= (weight / M) × 127
</span></span></code></pre></div><p>其中 <code>M</code> 是当前行最大绝对值。当前元素的绝对值除以 <code>M</code>，结果一定在 0～1；再乘 127，就不会超出 INT8 对称量化的标尺。</p>
<p>同时纠正了“归一化做得好，权重就一定在 -1～1”的误解。RMSNorm 主要规范化激活，weight decay 也不是硬性限制权重范围；量化正是通过每行自己的 absmax 和 scale 适应不同权重范围。</p>
<h3 id="2-从不理解-where到理解零行保护">2. 从“不理解 where”到理解零行保护</h3>
<p>最初没有看懂：</p>
<pre tabindex="0"><code>scale = torch.where(
    scale == 0,
    torch.ones_like(scale),
    scale,
)
</code></pre><p>后来明确它是逐元素三元选择：</p>
<ul>
<li><code>scale == 0</code> 的位置，从全 1 张量中取 1；</li>
<li>其他位置保留原 scale；</li>
<li><code>ones_like()</code> 会保持相同的形状、dtype 和设备；</li>
<li>零行使用 scale=1 后，量化与反量化仍然都是 0，不会除零。</li>
</ul>
<h3 id="3-从两行链式代码到理解量化顺序">3. 从两行链式代码到理解量化顺序</h3>
<pre tabindex="0"><code>quantized = torch.round(weight / scale)
quantized = quantized.clamp(-127, 127).to(torch.int8)
</code></pre><pre tabindex="0"><code>weight / scale 每行按自己的标尺缩放

torch.round() 四舍五入到整数位置

clamp(-127, 127) 范围保护

to(torch.int8) 最后才改变实际存储 dtype
</code></pre><h3 id="4-从替换整个层到只替换-linear-投影">4. 从“替换整个层？”到只替换 Linear 投影</h3>
<p>最初疑惑：TransformerBlock 的 forward 明明做了很多事情，为什么 QuantizedLinear 里只有一句 <code>F.linear()</code>？
后来确认，替换的是 GQA 内部这类线性投影：</p>
<pre tabindex="0"><code>self.W_query = nn.Linear(emb_dim, emb_dim)
</code></pre><p>不是替换整个 GQA，也不是替换 TransformerBlock。外层的 RoPE、掩码、softmax、残差等逻辑都不变。
<code>nn.Linear.forward()</code> 的核心本来就是 <code>F.linear(x, weight, bias)</code>。量化层只改变权重来源：INT8 / INT4 存储先反量化，再完成相同的线性计算。</p>
<h3 id="5-biasdetachclone-与-parameter--buffer">5. bias、detach、clone 与 Parameter / buffer</h3>
<p>最初担心原 Linear 的 <code>bias=cfg[&quot;qkv_bias&quot;]</code> 在替换后丢失。
后来明确：配置只在创建原 Linear 时使用；替换时直接检查 <code>linear.bias</code>，有就复制，没有就保留 None。因此 Q/K/V 有 bias、<code>out_proj</code> 无 bias 的差异可以逐层保留。
复制 bias 时：</p>
<pre tabindex="0"><code>linear.bias.detach().clone()
</code></pre><ul>
<li><code>detach()</code>：断开自动求导关系；</li>
<li><code>clone()</code>：复制独立的数据存储，不与旧模块共用；</li>
<li>权重只需 detach，是因为量化计算本身会生成新的 INT8 张量和 scale。
也理解了为什么量化权重与 scale 使用 <code>register_buffer()</code>：PTQ 是训练后转换，推理不需要通过梯度学习它们。buffer 仍会跟随设备迁移并进入持久状态。
<code>nn.Parameter</code> 本身不会自动导致梯度下降；是否更新仍取决于 backward 和 optimizer。原始 FP32 权重在推理时也可以仍是 Parameter。</li>
</ul>
<h3 id="6-从-parameters-与-state_dict-的模糊到发现统计-bug">6. 从 parameters 与 state_dict 的模糊到发现统计 Bug</h3>
<p>最初不清楚二者区别：</p>
<ul>
<li><code>model.parameters()</code>：遍历需要训练的 <code>nn.Parameter</code>，主要交给优化器；</li>
<li><code>model.state_dict()</code>：返回名称到持久张量的字典，包含 Parameter 和持久 buffer，主要用于保存与恢复。
量化后，INT8 权重与 scale 都是 buffer，只用 <code>parameters()</code> 会漏掉它们。</li>
</ul>
<p>第一版真实 Qwen 探针还暴露了共享权重去重问题：默认 <code>state_dict()</code> 返回的张量表示可能具有不同 Python <code>id</code>，即使模型里的 embedding 与 <code>out_head</code> 仍共享权重，也可能被重复统计。
修正为：</p>
<pre tabindex="0"><code>model.state_dict(keep_vars=True)
</code></pre><p>保留原 Parameter 对象身份后再去重，才得到可信的持久张量规模。这个修正只影响统计，不改变模型计算。</p>
<h3 id="7-理解-ppl-与-a32">7. 理解 PPL 与 A32</h3>
<p>PPL 就是 Perplexity，即困惑度：</p>
<pre tabindex="0"><code>PPL = exp(cross_entropy_loss)
</code></pre><p>它衡量相同数据、相同 tokenizer 下的 next-token 预测，越低通常越好，但不能代替所有任务能力评测。
也理解了量化标记：</p>
<pre tabindex="0"><code>W8A32 = INT8 权重 + FP32 激活
W4A32 = INT4 权重 + FP32 激活
W8A16 = INT8 权重 + FP16 / BF16 激活
W4A16 = INT4 权重 + FP16 / BF16 激活
</code></pre><p>A 是前向中的中间激活张量，不是激活函数。</p>
<h3 id="8-int8-真实-qwen-对照">8. INT8 真实 Qwen 对照</h3>
<p>在真实 Qwen2.5-0.5B-Instruct 上，共替换 168 个 Transformer 内部 Linear，保留 <code>out_head</code> 和 embedding 权重绑定。</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>指标</th>
        <th style="text-align: right">FP32 → INT8</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>持久张量规模</td>
        <td style="text-align: right">1976.13 MB → 903.87 MB</td>
      </tr>
      <tr>
        <td>存储减少</td>
        <td style="text-align: right">54.26%</td>
      </tr>
      <tr>
        <td>压缩倍率</td>
        <td style="text-align: right">约 2.19 倍</td>
      </tr>
      <tr>
        <td>Heldout PPL</td>
        <td style="text-align: right">69.294 → 69.540</td>
      </tr>
      <tr>
        <td>PPL 变化</td>
        <td style="text-align: right">上升约 0.354%</td>
      </tr>
      <tr>
        <td>TTFT 中位数</td>
        <td style="text-align: right">32.62 ms → 61.29 ms</td>
      </tr>
      <tr>
        <td>Decode 吞吐中位数</td>
        <td style="text-align: right">53.61 → 20.33 tokens/s</td>
      </tr>
    </tbody>
  </table>
</div>
<p>本次输入的 top-1 token 保持一致，但生成文本存在少量差异。
INT8 减少了存储与当前分配内存，却因每次前向都反量化并使用 FP32 <code>F.linear</code> 而明显变慢。decode 吞吐只剩当前 FP32 对照的约 37.92%。
PPL 使用 <code>blog_v1</code> heldout 的 5120 个 token；质量结论只限这份数据。性能数字与此前 I3-0 使用不同 prompt 和运行批次，不跨批次混用。</p>
<h3 id="9-从不知道一个-byte-存了什么到理解-int4-packing">9. 从“不知道一个 byte 存了什么”到理解 INT4 packing</h3>
<p>最初的盲点是：把一个 INT8 拆成两个 INT4 后，分别存了什么？
后来确认，不是拆分一个已有的 INT8 权重，而是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">两个不同的 FP32 权重
</span></span><span class="line"><span class="cl">→ 分别量化成两个 INT4 量化码
</span></span><span class="line"><span class="cl">→ 一个放低 4 位，另一个放高 4 位
</span></span><span class="line"><span class="cl">→ 合并进一个 byte
</span></span></code></pre></div><p>合并与拆分分别是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">packed</span> <span class="o">=</span> <span class="n">low</span> <span class="o">|</span> <span class="p">(</span><span class="n">high</span> <span class="o">&lt;&lt;</span> <span class="mi">4</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">low</span> <span class="o">=</span> <span class="n">packed</span> <span class="o">&amp;</span> <span class="mh">0x0F</span>
</span></span><span class="line"><span class="cl"><span class="n">high</span> <span class="o">=</span> <span class="p">(</span><span class="n">packed</span> <span class="o">&gt;&gt;</span> <span class="mi">4</span><span class="p">)</span> <span class="o">&amp;</span> <span class="mh">0x0F</span>
</span></span></code></pre></div><p><code>torch.stack([low, high], dim=-1)</code> 再 reshape，是为了把“所有低位值”和“所有高位值”恢复成原来的交替顺序。
4-bit 补码中的 <code>8～15</code> 表示 <code>-8～-1</code>，所以解包后对大于等于 8 的值减 16。
奇数列会补一个约定的 0。最后一个真实值放在最后一个 byte 的低 4 位，高 4 位为补齐码。原始 <code>in_features</code> 必须额外保存，因为仅凭 packed byte 数无法区分原始 5 列还是 6 列；解包后用它去掉补齐码。</p>
<p>由此也理解了：</p>
<ul>
<li><code>in_features</code>：原始权重每行有多少列，也是输入特征数；</li>
<li><code>out_features</code>：权重有多少行，也是输出特征数；</li>
<li>INT8 可以从量化矩阵形状直接得到 <code>in_features</code>；</li>
<li>INT4 打包后必须从原 Linear 显式保存 <code>linear.in_features</code>。
当前对 pack / unpack 的原理已经大致理解，具体位运算实现仍标记为后续复盘，不把“大概看懂”写成完全掌握。</li>
</ul>
<h3 id="10-int4-真实-qwen-对照">10. INT4 真实 Qwen 对照</h3>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>指标</th>
        <th style="text-align: right">FP32 → INT4</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>持久张量规模</td>
        <td style="text-align: right">1976.13 MB → 724.95 MB</td>
      </tr>
      <tr>
        <td>存储减少</td>
        <td style="text-align: right">63.31%</td>
      </tr>
      <tr>
        <td>压缩倍率</td>
        <td style="text-align: right">约 2.73 倍</td>
      </tr>
      <tr>
        <td>Heldout PPL</td>
        <td style="text-align: right">69.294 → 159.215</td>
      </tr>
      <tr>
        <td>PPL 变化</td>
        <td style="text-align: right">上升约 129.77%</td>
      </tr>
      <tr>
        <td>TTFT 中位数</td>
        <td style="text-align: right">29.41 ms → 114.70 ms</td>
      </tr>
      <tr>
        <td>Decode 吞吐中位数</td>
        <td style="text-align: right">53.03 → 9.83 tokens/s</td>
      </tr>
      <tr>
        <td>INT4 的最大 logit 差异达到 12.036，平均差异 2.331；本次 prompt 的 top-1 token 已改变。真实生成中出现偏离问题、语义重复的文本，与 PPL 的明显上升相互印证。</td>
        <td></td>
      </tr>
    </tbody>
  </table>
</div>
<p>当前 INT4 的 decode 吞吐只剩 FP32 对照的约 18.53%。进一步节约存储的同时，质量损失与解包、反量化成本都显著增加。</p>
<p>这不是“INT4 技术不可用”的普遍结论，而是当前朴素逐行 INT4 实现的真实边界。Group-wise 量化、校准、异常通道处理、QAT 与融合 kernel 均未实现。</p>
<h2 id="十fp16-ppl-异常排查">十、FP16 PPL 异常排查</h2>
<p>在 W8A16 实验中，FP16 参考组的 heldout PPL 为 497.58，而 FP32 参考组为 69.29；加入 INT8 权重后，FP16 路径 PPL 为 506.21。</p>
<p>随后发现 BF16 参考组 PPL 为 69.23，与 FP32 接近；W8A16（BF16）为 69.89。说明当前异常与 FP16 特定路径相关，而不是所有 16-bit 激活都会发生。</p>
<p>曾尝试在 <code>model.half()</code> 后将每层 <code>inv_freq</code> 恢复为 FP32，但评估结果逐项不变，因此“仅恢复 inv_freq”不能解释或修复当前异常。</p>
<p>随后使用同一小批数据完成了 CPU / MPS 的 FP32、FP16、BF16 对照，并继续定位到 RMSNorm 的 FP16 平方溢出。完整证据、修复和复测结果见第十二节。</p>
<h2 id="十一16-bit-激活对照区分-fp16bf16-与量化开销">十一、16-bit 激活对照：区分 FP16、BF16 与量化开销</h2>
<p>完成 W8A32 / W4A32 后，继续将激活切换到 16 bit。<code>model.half()</code> 的含义是把浮点参数和浮点 buffer 从 FP32 转成 FP16，不是减少参数数量或改变张量形状；整数与布尔张量保持原类型。<code>model.bfloat16()</code> 则切换到 BF16。</p>
<p>为避免同时改变两个变量，W8A16 / W4A16 的参考组也必须使用相同的 16-bit 激活，而不能继续拿 FP32 作为唯一对照。</p>
<h3 id="1-同一份-heldout-上的-ppl">1. 同一份 heldout 上的 PPL</h3>
<p>所有路径仍使用 <code>blog_v1</code> heldout 的 5120 个 token、context=128、batch=4、10 个批次。</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>路径</th>
        <th style="text-align: right">16-bit 参考组 PPL</th>
        <th style="text-align: right">量化后 PPL</th>
        <th style="text-align: right">相对参考组变化</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>W8A16（FP16）</td>
        <td style="text-align: right">497.585</td>
        <td style="text-align: right">506.211</td>
        <td style="text-align: right">+1.733%</td>
      </tr>
      <tr>
        <td>W8A16（BF16）</td>
        <td style="text-align: right">69.235</td>
        <td style="text-align: right">69.887</td>
        <td style="text-align: right">+0.942%</td>
      </tr>
      <tr>
        <td>W4A16（BF16）</td>
        <td style="text-align: right">69.235</td>
        <td style="text-align: right">161.227</td>
        <td style="text-align: right">+132.871%</td>
      </tr>
    </tbody>
  </table>
</div>
<p>BF16 参考组与 FP32 的 69.294 很接近，说明当前 BF16 链路没有出现 FP16 那种大幅偏移。</p>
<p>W4A16（BF16）与 W4A32 的 159.215 很接近，说明当前 INT4 的显著质量损失主要来自低精度权重本身，切换 BF16 激活不能修复。</p>
<h3 id="2-w8a16bf16真实生成">2. W8A16（BF16）真实生成</h3>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>指标</th>
        <th style="text-align: right">BF16 参考组 → W8A16</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>TTFT 中位数</td>
        <td style="text-align: right">25.41 ms → 55.17 ms</td>
      </tr>
      <tr>
        <td>Decode 吞吐中位数</td>
        <td style="text-align: right">66.25 → 22.89 tokens/s</td>
      </tr>
      <tr>
        <td>总耗时中位数</td>
        <td style="text-align: right">0.509 s → 1.455 s</td>
      </tr>
      <tr>
        <td>当前分配内存</td>
        <td style="text-align: right">1413.37 MB → 1045.14 MB</td>
      </tr>
    </tbody>
  </table>
</div>
<p>Decode 吞吐只剩参考组的约 34.55%，TTFT 耗时约为参考组的 2.17 倍。BF16 基线本身较快，但当前逐层反量化路径仍然明显变慢。</p>
<h3 id="3-w4a16bf16真实生成">3. W4A16（BF16）真实生成</h3>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>指标</th>
        <th style="text-align: right">BF16 参考组 → W4A16</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>TTFT 中位数</td>
        <td style="text-align: right">25.68 ms → 107.95 ms</td>
      </tr>
      <tr>
        <td>Decode 吞吐中位数</td>
        <td style="text-align: right">68.29 → 10.60 tokens/s</td>
      </tr>
      <tr>
        <td>总耗时中位数</td>
        <td style="text-align: right">0.496 s → 3.131 s</td>
      </tr>
      <tr>
        <td>当前分配内存</td>
        <td style="text-align: right">1413.37 MB → 907.25 MB</td>
      </tr>
    </tbody>
  </table>
</div>
<p>Decode 吞吐只剩参考组的约 15.52%，TTFT 耗时约为参考组的 4.20 倍。生成文本仍出现偏离原问题与语义重复，和 PPL 的显著上升一致。</p>
<h3 id="4-当前结论与未完成边界">4. 当前结论与未完成边界</h3>
<ul>
<li>当前教学实现中，权重量化降低了持久存储与当前分配内存，但没有带来推理提速；分解式解包、反量化和浮点 <code>F.linear</code> 产生了明显开销。</li>
<li>INT8 在当前 heldout 上质量损失较小；INT4 在两种激活精度下都出现显著质量损失。</li>
<li>本节 16-bit 结果记录的是 RMSNorm 修复前的实验现场；共享修复合入后，相关 BF16 / FP16 结果需要用当前代码重新复测。</li>
<li>FP16 的 RMSNorm 平方溢出已定位并修复，完整过程见第十二节，不能用此前的 BF16 结果掩盖 FP16 问题。</li>
<li>当前报告中的模型规模是去重后的持久张量字节数，不是实际 <code>.pth</code> 文件大小。</li>
<li>CUDA 复测、多任务质量评测、group-wise INT4、校准、QAT 与融合 kernel 仍未完成。</li>
<li>投机解码尚未开始；先完成共享修复后的量化复测。</li>
</ul>
<h2 id="十二fp16-ppl-异常闭环rmsnorm-的平方溢出">十二、FP16 PPL 异常闭环：RMSNorm 的平方溢出</h2>
<h3 id="1-先区分设备与-dtype">1. 先区分设备与 dtype</h3>
<p>同一批 128 tokens 的设备 / dtype 探针显示：</p>
<ul>
<li>MPS FP32 loss 为 3.73094，MPS BF16 为 3.73438，均正常；</li>
<li>CPU FP32 为 3.73086，CPU BF16 为 3.73438，与 MPS 接近；</li>
<li>CPU 与 MPS 的 FP16 logits 绝对值统计一致：<code>absmax=29.21875</code>、<code>mean_abs=2.19140625</code>，说明 FP16 模型前向偏移不是 MPS 独有；</li>
<li>CPU FP16 的 cross-entropy loss 为 Infinity，但 logits 全部有限，说明 loss 的 FP16 归约溢出与模型 logits 非有限是两件事。</li>
</ul>
<p>单批诊断只用于探针内部对照，不与十批评估的 PPL 数字混用。</p>
<h3 id="2-继续检查-rmsnorm-中间值">2. 继续检查 RMSNorm 中间值</h3>
<p>当前 RMSNorm 原实现使用输入自身 dtype 计算：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">mean_square</span> <span class="o">=</span> <span class="n">x</span><span class="o">.</span><span class="n">pow</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span><span class="o">.</span><span class="n">mean</span><span class="p">(</span><span class="n">dim</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="n">keepdim</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="n">y</span> <span class="o">=</span> <span class="n">x</span> <span class="o">*</span> <span class="n">torch</span><span class="o">.</span><span class="n">rsqrt</span><span class="p">(</span><span class="n">mean_square</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">eps</span><span class="p">)</span> <span class="o">*</span> <span class="bp">self</span><span class="o">.</span><span class="n">scale</span>
</span></span></code></pre></div><p>逐层 forward hook 发现：FP16 从 <code>trf_block.3.norm1</code> 开始，后续各层 norm 与 <code>final_norm</code> 的 <code>mean_square</code> 持续出现非有限值；FP32 与 BF16 均没有。</p>
<p>第一处异常层的输入绝对值最大值为 619：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">619² = 383,161
</span></span><span class="line"><span class="cl">FP16 最大有限值约为 65,504
</span></span></code></pre></div><p>因此平方在 FP16 下溢出为 <code>inf</code>。随后 <code>rsqrt(inf)=0</code>，有限输入乘 0 后输出仍可能是有限的 0，所以最终 logits 不一定出现 NaN，但隐藏状态已经失真。这解释了为什么 PPL 大幅上升，却没有直接以模型报错的形式暴露。</p>
<h3 id="3-使用-fp32-累积修复">3. 使用 FP32 累积修复</h3>
<p>修复后的 RMSNorm 只在内部转换为 FP32 完成平方、均值和归一化，输出再转回输入 dtype：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">forward</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">x</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">input_dtype</span> <span class="o">=</span> <span class="n">x</span><span class="o">.</span><span class="n">dtype</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="n">x_float</span> <span class="o">=</span> <span class="n">x</span><span class="o">.</span><span class="n">float</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="n">mean_square</span> <span class="o">=</span> <span class="n">x_float</span><span class="o">.</span><span class="n">pow</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span><span class="o">.</span><span class="n">mean</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="n">dim</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="n">keepdim</span><span class="o">=</span><span class="kc">True</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="n">y</span> <span class="o">=</span> <span class="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="n">x_float</span>
</span></span><span class="line"><span class="cl">        <span class="o">*</span> <span class="n">torch</span><span class="o">.</span><span class="n">rsqrt</span><span class="p">(</span><span class="n">mean_square</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">eps</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="o">*</span> <span class="bp">self</span><span class="o">.</span><span class="n">scale</span><span class="o">.</span><span class="n">float</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">y</span><span class="o">.</span><span class="n">to</span><span class="p">(</span><span class="n">dtype</span><span class="o">=</span><span class="n">input_dtype</span><span class="p">)</span>
</span></span></code></pre></div><p>这样不会把整个模型转回 FP32，后续 Linear 的输入与权重仍保持相同的 FP16 / BF16 类型。</p>
<p>新增回归使用 <code>619.0</code> 的 FP16 输入：旧实现会溢出并输出 0，修复后输出有限且为 1，同时保持 FP16 dtype。用户运行该回归及相关 RoPE、推理基线、量化模块和真实 Qwen cache 测试，结果为 <strong>10 passed</strong>。</p>
<h3 id="4-复测证明根因与修复一致">4. 复测证明根因与修复一致</h3>
<p>修复后重新运行原始 W8A16（FP16）PPL：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">FP16 参考组：
</span></span><span class="line"><span class="cl">loss = 4.23828
</span></span><span class="line"><span class="cl">PPL  = 69.2887
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">FP16 + INT8 权重：
</span></span><span class="line"><span class="cl">loss = 4.24160
</span></span><span class="line"><span class="cl">PPL  = 69.5191
</span></span><span class="line"><span class="cl">相对参考组上升约 0.333%
</span></span></code></pre></div><p>FP16 参考组已从修复前的 497.585 降回 69.289，与 FP32 的 69.294 基本一致。由此形成完整闭环：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">FP16 中间激活平方溢出
</span></span><span class="line"><span class="cl">→ RMSNorm 输出失真
</span></span><span class="line"><span class="cl">→ PPL 大幅上升
</span></span><span class="line"><span class="cl">→ RMSNorm 改为 FP32 累积
</span></span><span class="line"><span class="cl">→ FP16 PPL 恢复正常
</span></span></code></pre></div><p>这次排障的重要经验是：<strong>最终输出有限，不代表中间过程没有溢出；某一层输出仍有限，也不代表它的数值语义仍然正确。</strong></p>
<p>共享 RMSNorm 修复会影响其他 dtype 路径，因此既有 BF16 / FP16 性能与质量结果需要按当前代码重新复测，不能自动沿用到修复后的最终报告。</p>
<h2 id="十三rmsnorm-修复后的-bf16-正式复测">十三、RMSNorm 修复后的 BF16 正式复测</h2>
<p>共享 RMSNorm 改为 FP32 累积后，重新运行 BF16 的 PPL 与真实生成，以下结果替代此前修复前数据，作为当前代码的正式对照。</p>
<h3 id="1-ppl-复测">1. PPL 复测</h3>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>路径</th>
        <th style="text-align: right">BF16 参考组 PPL</th>
        <th style="text-align: right">量化后 PPL</th>
        <th style="text-align: right">相对参考组变化</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>W8A16（BF16）</td>
        <td style="text-align: right">69.560</td>
        <td style="text-align: right">69.887</td>
        <td style="text-align: right">+0.470%</td>
      </tr>
      <tr>
        <td>W4A16（BF16）</td>
        <td style="text-align: right">69.560</td>
        <td style="text-align: right">159.224</td>
        <td style="text-align: right">+128.902%</td>
      </tr>
    </tbody>
  </table>
</div>
<p>FP32 累积改变了 BF16 参考组的少量数值，但没有改变主要结论：INT8 在当前 heldout 上损失较小，INT4 仍有显著损失。</p>
<h3 id="2-w8a16bf16生成复测">2. W8A16（BF16）生成复测</h3>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>指标</th>
        <th style="text-align: right">BF16 参考组 → W8A16</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>TTFT 中位数</td>
        <td style="text-align: right">26.29 ms → 56.07 ms</td>
      </tr>
      <tr>
        <td>Decode 吞吐中位数</td>
        <td style="text-align: right">63.97 → 22.46 tokens/s</td>
      </tr>
      <tr>
        <td>总耗时中位数</td>
        <td style="text-align: right">0.526 s → 1.481 s</td>
      </tr>
      <tr>
        <td>当前分配内存</td>
        <td style="text-align: right">1413.37 MB → 1045.14 MB</td>
      </tr>
    </tbody>
  </table>
</div>
<p>TTFT 耗时约为参考组的 2.13 倍，decode 吞吐约为参考组的 35.11%。当前实现仍因逐层反量化而明显变慢。</p>
<h3 id="3-w4a16bf16生成复测">3. W4A16（BF16）生成复测</h3>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>指标</th>
        <th style="text-align: right">BF16 参考组 → W4A16</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>TTFT 中位数</td>
        <td style="text-align: right">26.30 ms → 109.09 ms</td>
      </tr>
      <tr>
        <td>Decode 吞吐中位数</td>
        <td style="text-align: right">63.72 → 10.57 tokens/s</td>
      </tr>
      <tr>
        <td>总耗时中位数</td>
        <td style="text-align: right">0.529 s → 3.140 s</td>
      </tr>
      <tr>
        <td>当前分配内存</td>
        <td style="text-align: right">1413.37 MB → 907.25 MB</td>
      </tr>
    </tbody>
  </table>
</div>
<p>TTFT 耗时约为参考组的 4.15 倍，decode 吞吐约为参考组的 16.59%。INT4 生成文本仍存在明显语义偏移，与 PPL 大幅上升一致。</p>
<p>这些数字来自用户在同一 Mac / MPS、同一 prompt、1 次 warmup、3 次正式测量下的实际运行。不同实验批次的中位数不与其他日期或其他 prompt 的结果混用。</p>
<h2 id="十四修复后的-fp16-生成对照">十四、修复后的 FP16 生成对照</h2>
<p>RMSNorm 修复后，继续补测 W8A16（FP16）的真实生成，确认不仅 PPL 恢复，生成路径也不再受平方溢出影响。</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>指标</th>
        <th style="text-align: right">FP16 参考组 → W8A16（FP16）</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>TTFT 中位数</td>
        <td style="text-align: right">26.19 ms → 56.44 ms</td>
      </tr>
      <tr>
        <td>Decode 吞吐中位数</td>
        <td style="text-align: right">63.28 → 22.64 tokens/s</td>
      </tr>
      <tr>
        <td>总耗时中位数</td>
        <td style="text-align: right">0.533 s → 1.471 s</td>
      </tr>
      <tr>
        <td>当前分配内存</td>
        <td style="text-align: right">1413.37 MB → 1045.14 MB</td>
      </tr>
    </tbody>
  </table>
</div>
<p>TTFT 耗时约为参考组的 2.16 倍，decode 吞吐约为参考组的 35.77%。结果与 BF16 量化路径相近：存储与当前分配内存下降，但当前分解式反量化实现仍然明显变慢。</p>
<p>FP16 参考组已恢复正常流畅生成；量化组仍有数值和文本差异，但不再出现修复前由 RMSNorm 溢出造成的异常质量路径。</p>
<p>至此，Mac 上已完成 W8A32、W4A32、W8A16 / W4A16（BF16）以及 W8A16（FP16）的当前实验闭环。实际 <code>.pth</code> 文件大小、CUDA 复测、多任务质量评测、group-wise INT4 与融合 kernel 仍保留为后续边界。</p>
<h2 id="十五阶段总结速度空间质量与理解是四本账">十五、阶段总结：速度、空间、质量与理解是四本账</h2>
<p>这篇笔记从一条简单的生成调用出发，最后覆盖了 KV Cache、会话状态、权重量化和数值排障。为了避免细节淹没结论，这里统一收拢实验口径与最终结果。</p>
<h3 id="1-实验口径">1. 实验口径</h3>
<ul>
<li>推理基线使用真实 Qwen2.5-0.5B-Instruct、Mac / MPS、FP32、36 个 prompt tokens、固定生成 32 tokens；cache / no-cache 独立运行三轮并取中位数。</li>
<li>会话探针使用相同真实模型和固定多轮输入，分别检查完整重算、会话复用和滑动淘汰；没有测量其 TTFT 收益，不把输入 token 减少比例当作提速比例。</li>
<li>量化存储探针替换 168 个 Transformer 内部 Linear，保留 <code>out_head</code> 与 embedding 的权重绑定；持久张量通过 <code>state_dict(keep_vars=True)</code> 去重统计，不等同于实际 <code>.pth</code> 文件大小。</li>
<li>PPL 使用 <code>blog_v1</code> heldout 的 5120 个 token，context=128、batch=4、10 批；PPL 只代表当前语料的 next-token 预测变化。</li>
<li>量化生成使用同一 prompt、固定 32 tokens、贪心解码、1 次 warmup、3 次正式测量并取中位数。固定长度测量有意不启用 EOS 提前停止，不将输出中的后续标记解释为正式服务异常。</li>
<li>MPS 使用 current allocated / driver allocated 快照；没有与 CUDA 相同的峰值接口，不伪造跨设备峰值对照。</li>
</ul>
<h3 id="2-kv-cache-与会话复用的核心结果">2. KV Cache 与会话复用的核心结果</h3>
<ul>
<li>单次生成中，cache 的 decode 吞吐中位数为 40.26 tokens/s，no-cache 为 23.28 tokens/s，约 <strong>1.73 倍</strong>；两种路径逐 token 输出一致。</li>
<li>Qwen 当前 FP32 配置的 KV Cache 实测为 <strong>24 KiB/token</strong>；36 个 prompt tokens 对应 864 KiB。4096 tokens 的 96 MiB 是按单位成本推算，不是实测设备峰值。</li>
<li>第二轮完整重算需要输入 61 tokens，会话复用后只输入 15 个新增 token，输入减少约 <strong>75.4%</strong>，回答保持一致。</li>
<li>真实第三轮滑动中，cache 从 66 裁剪到 34 tokens，淘汰后的 prompt 为 53 tokens，实际只输入 19 个新增 token；位置从 66 继续，生成后推进到 90。</li>
<li>会话复用与滑动窗口证明了状态和位置链路的正确性，但没有单独测量性能收益；滑动位置与裁剪细节仍需要后续复盘。</li>
</ul>
<h3 id="3-量化结果汇总">3. 量化结果汇总</h3>
<p>下表中的参考组随实验路径变化：W32 使用 FP32，A16 使用相同 16-bit 激活参考组。不同批次的 FP32 / BF16 性能中位数不跨实验混用。</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>路径</th>
        <th style="text-align: right">持久张量规模</th>
        <th style="text-align: right">PPL：参考 → 量化</th>
        <th style="text-align: right">TTFT：参考 → 量化</th>
        <th style="text-align: right">Decode：参考 → 量化</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>W8A32</td>
        <td style="text-align: right">1976.13 → 903.87 MB</td>
        <td style="text-align: right">69.294 → 69.540</td>
        <td style="text-align: right">32.62 → 61.29 ms</td>
        <td style="text-align: right">53.61 → 20.33 tokens/s</td>
      </tr>
      <tr>
        <td>W4A32</td>
        <td style="text-align: right">1976.13 → 724.95 MB</td>
        <td style="text-align: right">69.294 → 159.215</td>
        <td style="text-align: right">29.41 → 114.70 ms</td>
        <td style="text-align: right">53.03 → 9.83 tokens/s</td>
      </tr>
      <tr>
        <td>W8A16（BF16）</td>
        <td style="text-align: right">本轮未重复测量</td>
        <td style="text-align: right">69.560 → 69.887</td>
        <td style="text-align: right">26.29 → 56.07 ms</td>
        <td style="text-align: right">63.97 → 22.46 tokens/s</td>
      </tr>
      <tr>
        <td>W4A16（BF16）</td>
        <td style="text-align: right">本轮未重复测量</td>
        <td style="text-align: right">69.560 → 159.224</td>
        <td style="text-align: right">26.30 → 109.09 ms</td>
        <td style="text-align: right">63.72 → 10.57 tokens/s</td>
      </tr>
      <tr>
        <td>W8A16（FP16，修复后）</td>
        <td style="text-align: right">本轮未重复测量</td>
        <td style="text-align: right">69.289 → 69.519</td>
        <td style="text-align: right">26.19 → 56.44 ms</td>
        <td style="text-align: right">63.28 → 22.64 tokens/s</td>
      </tr>
    </tbody>
  </table>
</div>
<p>由此得到几个有边界的结论：</p>
<ol>
<li><strong>INT8 在当前 heldout 上质量损失较小</strong>。W8A32 / W8A16 的 PPL 相对各自参考组只有约 0.3%～0.5% 的上升；这不等于所有任务都无损。</li>
<li><strong>当前逐行 INT4 的质量损失显著</strong>。PPL 接近翻倍，top-1 与真实文本均发生变化；不能推广为所有 INT4 方法都如此，因为 group-wise、校准、异常通道处理和 QAT 均未使用。</li>
<li><strong>当前教学实现没有因量化而提速</strong>。每次前向都需要反量化，INT4 还需要解包和符号恢复，随后仍执行浮点 <code>F.linear</code>。没有融合低精度 kernel 时，额外开销超过了存储与带宽收益。</li>
<li><strong>持久张量压缩不等于运行时内存按相同比例下降</strong>。设备分配器、激活、临时反量化权重和 KV Cache 都有独立开销。</li>
</ol>
<h3 id="4-fp16-异常给出的额外答案">4. FP16 异常给出的额外答案</h3>
<p>FP16 参考组最初 PPL 高达 497.585，并不是量化导致，也不是所有 16-bit 激活的普遍现象。</p>
<p>逐层排查最终确认：第 3 层 RMSNorm 输入 absmax 达到 619，平方为 383161，超过 FP16 最大有限值 65504；<code>mean_square</code> 溢出为 <code>inf</code>，随后 <code>rsqrt(inf)=0</code>，隐藏状态被压成有限的 0，因此最终 logits 有限却早已失真。</p>
<p>RMSNorm 改为 FP32 累积、输出再转回原 dtype 后，FP16 参考组 PPL 恢复为 69.289，W8A16 为 69.519；10 项相关回归由用户运行通过，生成路径也恢复正常。</p>
<p>这次排障说明：<strong>最终输出有限，不代表中间过程没有溢出；测试某一层是否能运行，也不等于它的数值语义正确。</strong></p>
<h3 id="5-阶段边界与后续承接">5. 阶段边界与后续承接</h3>
<p>这里记录的是当时的 Mac 阶段状态，而非整篇笔记的最终状态：推理基线、增量 prefill、会话 cache、token 预算、量化与 FP16 修复已完成；投机解码、SSE 和 CUDA 复测尚未开始。</p>
<p>后续章节继续完成了这些遗留项：</p>
<ul>
<li>第十六节：贪心投机解码、cache 回滚与真实 Draft / Target 对照；</li>
<li>第十七至十八节：SSE、会话隔离及用户可见的新建 / 切换入口；</li>
<li>第十九至二十一节：MHA / GQA 实测、量化叠加投机与 CUDA 复测；</li>
<li>第二十二节：最终收官、剩余边界与 V4 承接。</li>
</ul>
<p>实际量化模型文件大小、多任务质量评测、预分配 KV Cache、group-wise INT4、校准、QAT、融合 kernel，以及滑动窗口与 INT4 pack / unpack 的独立复盘，仍不因此前实验而自动视为完成。</p>
<p>测试数字均对应当时明确列出的测试文件与范围，不把不同阶段的 <code>passed</code> 数量累加成一次全量回归。功能进度与学习理解也继续保持两本账：跑通的功能可以记录为已验证，尚未吃透的部分仍明确留给后续。</p>
<h2 id="十六投机解码正确性闭环完成但当前实现没有提速">十六、投机解码：正确性闭环完成，但当前实现没有提速</h2>
<h3 id="1-从纯校验到真实双模型">1. 从纯校验到真实双模型</h3>
<p>I3-3 使用 Qwen2.5-0.5B-Instruct 作为 Draft、Qwen2.5-1.5B-Instruct 作为 Target。两者使用同一 tokenizer，Draft 负责一次猜测多个 token，Target 负责批量校验、修正和保持最终输出标准。</p>
<p>实现拆为三层：</p>
<ol>
<li><code>verify_greedy_draft()</code>：只计算接受长度、Target 修正、拒绝数量和全部接受时的 bonus token；</li>
<li>no-cache 双模型生成：通过完整重算验证算法，不处理 cache 回滚；</li>
<li>cached 双模型生成：分别维护 Draft / Target 的 KV Cache，回滚被拒绝部分，并将修正 / bonus token 同步输入双方模型。</li>
</ol>
<p>Bonus 的含义是：当 k 个草稿全部被接受时，Target 处理完第 k 个草稿后，该位置的 logits 已经能预测第 k+1 个 token，因此可以额外产生一个无需单独校验的 token。如果中间发生拒绝，bonus 的计算历史已经失效，不能使用。</p>
<p>修正或 bonus token 虽然已经进入最终文本，但尚未进入模型状态，因此还要同步输入 Draft 和 Target，保证下一轮双方看到同一份真实历史。</p>
<h3 id="2-分层验收">2. 分层验收</h3>
<ul>
<li>纯校验测试覆盖全部接受、中间拒绝、首个拒绝、最后一个拒绝、长度错误和 KV Cache 精确裁剪，合计 7 项通过；</li>
<li>no-cache 真实模型结构对照 2 项通过，覆盖相同模型全部接受 / bonus 与不同 Draft 的 Target 一致性；</li>
<li>cached 双模型对照 2 项通过，覆盖修正、双方回滚和状态同步；</li>
<li>所有测试均由用户实际运行，数字不与其他阶段累加成一次全量回归。</li>
</ul>
<p>真实 Target 加载先完成 Qwen2.5-1.5B 的 V3 / 官方 CPU FP32 logits 对照：最大差异约 3.72e-5，平均差异约 3.83e-6，allclose(1e-4) 通过，top-1 一致。</p>
<h3 id="3-真实生成结果">3. 真实生成结果</h3>
<p>统一使用固定 prompt、32 个新 token、贪心解码、1 次 warmup、3 次正式测量。</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>配置</th>
        <th>输出逐 token 一致</th>
        <th style="text-align: right">Draft 接受率</th>
        <th style="text-align: right">Target-only 中位耗时</th>
        <th style="text-align: right">投机中位耗时</th>
        <th>结果</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>BF16，k=4</td>
        <td>是</td>
        <td style="text-align: right">55.00%</td>
        <td style="text-align: right">0.904 s</td>
        <td style="text-align: right">1.395 s</td>
        <td>投机约 1.54 倍耗时</td>
      </tr>
      <tr>
        <td>BF16，k=2</td>
        <td><strong>否</strong></td>
        <td style="text-align: right">67.86%</td>
        <td style="text-align: right">0.938 s</td>
        <td style="text-align: right">1.689 s</td>
        <td>正确性验收失败，不接受性能结论</td>
      </tr>
      <tr>
        <td>FP32，k=2</td>
        <td>是</td>
        <td style="text-align: right">48.48%</td>
        <td style="text-align: right">1.269 s</td>
        <td style="text-align: right">2.464 s</td>
        <td>投机约 1.94 倍耗时</td>
      </tr>
      <tr>
        <td>FP32，k=4</td>
        <td>是</td>
        <td style="text-align: right">33.93%</td>
        <td style="text-align: right">1.504 s</td>
        <td style="text-align: right">2.810 s</td>
        <td>投机约 1.87 倍耗时</td>
      </tr>
      <tr>
        <td>FP32，k=8</td>
        <td>是</td>
        <td style="text-align: right">20.41%</td>
        <td style="text-align: right">1.293 s</td>
        <td style="text-align: right">3.349 s</td>
        <td>投机约 2.59 倍耗时</td>
      </tr>
    </tbody>
  </table>
</div>
<p>FP32 k=2 的账目为：16 个接受的 Draft token + 10 个 Target 修正 token + 6 个 bonus token = 32 个最终 token。</p>
<p>FP32 k=4 的账目为：19 个接受的 Draft token + 11 个 Target 修正 token + 2 个 bonus token = 32 个最终 token。</p>
<p>BF16 k=2 的文本与 Target-only 不一致；切换到同设备 FP32 后恢复逐 token 一致。这说明 BF16 多 token 校验与单 token decode 的数值差异可能累积并改变 argmax。该现象只保留为当前实现的数值边界，不宣称已经定位到某个底层 kernel。</p>
<h3 id="4-为什么没有加速">4. 为什么没有加速</h3>
<p>当前负收益来自多项共同开销：</p>
<ul>
<li>Draft 仍需逐 token 前向；</li>
<li>Target 批量校验需要处理整段草稿；</li>
<li>被拒绝部分需要回滚双方 cache；</li>
<li>修正 / bonus token 还要同步进入双方模型；</li>
<li>Python 循环、设备同步与张量操作都有成本；</li>
<li>1.5B Target 在当前 MPS 上可能还不足以形成明显的单步摊销优势；</li>
<li>当前 Draft / Target 的接受率不足以抵消这些成本。</li>
</ul>
<p>因此当前结论是：<strong>投机算法已在当前实现中跑通，但这组 0.5B / 1.5B 模型、Mac / MPS、Python 分解路径和测试负载没有获得性能收益</strong>。不能据此推广为投机解码在生产 GPU、融合运行时或更大 Target 上无效。</p>
<h3 id="5-当前边界">5. 当前边界</h3>
<ul>
<li>当前只实现贪心投机，不支持 temperature / top-k / top-p 的严格分布保持；</li>
<li>采样场景需要使用目标与草稿概率的接受规则及残差修正，不能简单比较 argmax；</li>
<li>已补测 FP32 k=8：接受率降至 20.41%，98 个草稿仅接受 20 个，无 bonus，投机耗时约为 Target-only 的 2.59 倍；未做自适应 lookahead；</li>
<li>尚未进行 CUDA 复测；</li>
<li>BF16 k=2 的数值不一致需要后续独立排查，不能写成所有 BF16 路径都通过；</li>
<li>当前性能结论是负收益，但算法正确性和测试证据完整保留。</li>
</ul>
<h2 id="十七sse-流式输出与多会话隔离">十七、SSE 流式输出与多会话隔离</h2>
<p>I3-4 将原来“等待完整回答后一次性返回 JSON”的服务，扩展为逐 token 推送的 SSE 服务，并按 <code>session_id</code> 隔离会话状态。本阶段由用户显式切换到工作模式，Kimi 负责实现与运行验证，用户负责最终验收。</p>
<h3 id="1-流式生成与-chatsession-状态复用">1. 流式生成与 ChatSession 状态复用</h3>
<p><code>generate_stream()</code> 使用与 <code>generate()</code> 相同的 prefill / decode、采样、EOS 和位置参数，在每个新 token 产生时 yield；迭代结束后通过 <code>StopIteration.value</code> 返回完整序列与最终 cache。</p>
<p><code>ChatSession</code> 的 <code>ask()</code> 和 <code>ask_stream()</code> 共用输入准备、回答清理、history、cache 和 <code>next_position</code> 收尾。流式路径累计解码 token IDs，再计算本次新增文本，避免直接改变最终回答的语义。</p>
<p>如果流式生成中途异常或连接断开，当前未完成 cache 会被失效，下一次请求使用完整重算，避免把半截生成状态误当成有效历史。</p>
<p>验收结果：</p>
<ul>
<li><code>generate_stream()</code> 与 <code>generate()</code> 的输出 token 和各层 K/V 完全一致；</li>
<li><code>ask_stream()</code> 与 <code>ask()</code> 的回答、history、cached token IDs、位置和 cache 一致；</li>
<li>中途关闭流后状态被清理，随后可重新生成；</li>
<li>流式生成、会话、原有生成与推理基线相关测试合计 <strong>16 passed</strong>，仅覆盖本次明确列出的测试文件。</li>
</ul>
<h3 id="2-sse-服务端">2. SSE 服务端</h3>
<p>新增 <code>POST /chat/stream</code>，响应使用：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Content-Type: text/event-stream; charset=utf-8
</span></span><span class="line"><span class="cl">Cache-Control: no-cache
</span></span><span class="line"><span class="cl">X-Accel-Buffering: no
</span></span></code></pre></div><p>每个事件写入后立即 flush：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">data: {&#34;session_id&#34;:&#34;...&#34;,&#34;delta&#34;:&#34;你&#34;}
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">data: {&#34;session_id&#34;:&#34;...&#34;,&#34;delta&#34;:&#34;好&#34;}
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">data: {&#34;session_id&#34;:&#34;...&#34;,&#34;done&#34;:true}
</span></span></code></pre></div><p>不再使用 <code>Content-Length</code> 作为流式响应长度。结束或异常后关闭当前连接；客户端断开时由生成器清理未完成状态。</p>
<p>原 <code>POST /chat</code> 同步接口保留，便于与 SSE 路径做对照。</p>
<h3 id="3-多会话隔离与有界存储">3. 多会话隔离与有界存储</h3>
<p>新增 <code>SessionStore</code>：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">session_id A → 独立 ChatSession A
</span></span><span class="line"><span class="cl">session_id B → 独立 ChatSession B
</span></span></code></pre></div><p>每个会话分别保存 history、KV Cache、cached token IDs 和位置进度。默认最多保留 16 个会话，使用 LRU 淘汰最久未使用的会话，避免本地状态无限增长。<code>LVCHAT_MAX_SESSIONS</code> 和 <code>LVCHAT_MAX_NEW_TOKENS</code> 可用于本地实验配置。</p>
<p>当前仍使用单线程 <code>HTTPServer</code>，因此这是<strong>多会话状态隔离、请求串行处理</strong>，不宣称支持并发模型推理或生产级调度。</p>
<h3 id="4-浏览器流式渲染">4. 浏览器流式渲染</h3>
<p>页面为每个浏览器生成并保存独立 <code>session_id</code>，通过 <code>fetch()</code> POST 发送消息，再使用 <code>ReadableStream</code> + <code>TextDecoder</code> 增量读取 SSE 事件。</p>
<p>流式过程中使用纯文本追加，结束后复用已有的安全 Markdown 渲染；同时校验事件的 <code>session_id</code>，避免接收其他会话的内容。页面文案已同步为 SSE / 多会话模式。</p>
<h3 id="5-真实服务与浏览器验收">5. 真实服务与浏览器验收</h3>
<p>使用真实 Qwen2.5-0.5B-Instruct、每轮最多 16 个新 token、最多 2 个会话：</p>
<ul>
<li>session A 第一轮“记住：我最喜欢的运动是划船”收到 16 个 delta 事件和最终 done；</li>
<li>session A 第二轮“我最喜欢的运动是什么？”回答“你最喜欢的运动是划船。”，收到 7 个 delta 事件和 done；</li>
<li>session B 问同一问题时没有继承 A 的偏好，健康检查显示 2 个独立会话；</li>
<li>浏览器中真实发送问题后，页面逐段接收并展示回答，状态为“就绪 · SSE 流式返回”，TURN 计数正常；</li>
<li>JavaScript 语法检查通过。</li>
</ul>
<p>验收中观察到模型回答偶有 ``。同步 <code>/chat</code> 在全新会话中也出现相同字符，因此该现象属于当前模型 token 输出 / 解码的质量边界，不是 SSE 增量推送引入的错误。</p>
<p>当前服务保留在 <code>http://127.0.0.1:8000/</code> 供用户验收。SSE 改善的是内容逐步可见，不改变模型本身的速度或能力。</p>
<h2 id="十八多会话入口补齐从服务端隔离到用户可用">十八、多会话入口补齐：从服务端隔离到用户可用</h2>
<p>SSE 首次验收时，页面虽然显示 Multi，但只有后端按 <code>session_id</code> 隔离，没有新建或切换会话的用户入口。用户验收及时发现：服务端能力存在，不等于用户侧功能闭环已经完成。</p>
<h3 id="补充实现">补充实现</h3>
<ul>
<li>顶部新增会话下拉框与“新建会话”按钮；</li>
<li><code>SessionStore</code> 增加会话元数据列表和按 ID 查找；</li>
<li>新增 <code>GET /sessions</code>：返回会话 ID、首轮标题和轮数；</li>
<li>新增 <code>GET /session/history?session_id=...</code>：返回指定会话的文本历史；</li>
<li>新建会话生成新的 UUID，清空当前页面输入与历史区域；</li>
<li>切换会话时加载对应历史，恢复消息、TURN 数和当前会话标识；</li>
<li>切换过程只读取已有状态，不重新执行模型；模型 history、KV Cache 和位置进度仍按同一个 session ID 对齐；</li>
<li>生成过程中禁用新建与切换，避免请求进行中切换状态。</li>
</ul>
<h3 id="验收">验收</h3>
<p>会话元数据、查找、LRU、流式生成与 ChatSession 相关测试合计 <strong>11 passed</strong>，JavaScript 语法检查通过。</p>
<p>真实浏览器中完成：</p>
<ol>
<li>会话 A 输入“记住：我喜欢划船”，下拉框显示该会话 1 轮；</li>
<li>点击“新建会话”，页面清空并使用新的 session ID；</li>
<li>会话 B 独立输入“我最喜欢的运动是什么？”；</li>
<li>再切回会话 A，原始提问、回答和 TURN 数完整恢复；</li>
<li>两个会话的服务端 history、KV Cache 与页面文本保持独立。</li>
</ol>
<p>当前仍是单线程请求处理；多会话管理不代表并发推理。旧服务进程曾占用 8000 端口，核对命令后正常结束旧实例，再启动新版完成验收，没有用终止不明进程的方式绕过问题。</p>
<h3 id="浏览器验收截图">浏览器验收截图</h3>
<p><img alt="I3 浏览器验收：会话选择、新建会话、流式状态与本地模型回答" loading="lazy" src="https://blog.lvxinrong.com/images/i3-sse-multi-session.png"></p>
<p>截图记录了用户最终验收时的页面：顶部可以切换已有会话或新建会话，右侧显示当前 session、TURN 数和 SSE 流式返回状态，正文由本地模型逐段生成并安全渲染。</p>
<p>这张截图证明的是<strong>会话管理与流式服务链路已经跑通</strong>。截图中的模型回答仅用于展示输出，不作为 SSE 技术定义或模型能力结论。</p>
<h2 id="十九补验mha--gqa-的-kv-cache-实际占用">十九、补验：MHA / GQA 的 KV Cache 实际占用</h2>
<p>为补齐 I0 拆出的资源验收，新增 <code>scripts/i3_kv_mha_gqa_probe.py</code>。使用同一个 <code>GroupedQueryAttention</code> 实现，只改变 KV head 数：MHA 为 14，GQA 为 2；Q heads 均为 14，head_dim=64，24 层，36 个输入 token，FP32。</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>指标</th>
        <th style="text-align: right">MHA</th>
        <th style="text-align: right">GQA</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>KV Cache 字节数 / token</td>
        <td style="text-align: right">172,032</td>
        <td style="text-align: right">24,576</td>
      </tr>
      <tr>
        <td>36 tokens 的实际 KV 字节数</td>
        <td style="text-align: right">6,193,152</td>
        <td style="text-align: right">884,736</td>
      </tr>
      <tr>
        <td>当前分配内存增量</td>
        <td style="text-align: right">6,193,152</td>
        <td style="text-align: right">884,736</td>
      </tr>
      <tr>
        <td>驱动分配增量</td>
        <td style="text-align: right">0</td>
        <td style="text-align: right">0</td>
      </tr>
    </tbody>
  </table>
</div>
<p>GQA 的实际 cache 为 MHA 的 <strong>1/7</strong>，减少 <strong>85.71%</strong>。张量遍历得到的字节数与 MPS current allocated 的前后增量完全一致，理论与设备实测闭合。</p>
<p>驱动分配增量为 0 不代表没有新增占用，而是新增张量仍落在已有驱动分配 / 缓存空间中。这里比较的是同一路径添加 cache 前后的增量；MHA 与 GQA 的 K/V 投影权重规模不同，不把两种模式的总模型内存当作同一基线。</p>
<p>本探针只验证 attention 形状与内存，不评估模型语义或训练效果。报告保存在 <code>data/reports/i3-kv-mha-gqa-mps.json</code>，由用户在学习模式下实际运行验收。</p>
<h2 id="二十补验量化叠加投机与-ttft">二十、补验：量化叠加投机与 TTFT</h2>
<p>在 MHA / GQA 实测之后，继续为投机路径补充 TTFT，并增加 Draft / Target 同时 INT8 量化的叠加实验。参考组也使用量化后的 Target，避免把量化收益与投机收益混在一起。</p>
<h3 id="1-ttft-计时边界">1. TTFT 计时边界</h3>
<p>投机函数从 Draft / Target 初始 prefill 前开始计时，到第一轮产生最终接受 token 为止。曾出现 TTFT 全部为 0 的接线问题，根因是将不足 1 秒的浮点时间误包为 <code>int()</code>，导致小数被截断；移除该转换后恢复有效测量，并补充非零 TTFT 回归。</p>
<h3 id="2-未量化-fp32k4">2. 未量化 FP32，k=4</h3>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>指标</th>
        <th style="text-align: right">Target-only</th>
        <th style="text-align: right">投机解码</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>TTFT 中位数</td>
        <td style="text-align: right">63.30 ms</td>
        <td style="text-align: right">235.95 ms</td>
      </tr>
      <tr>
        <td>总耗时中位数</td>
        <td style="text-align: right">1.324 s</td>
        <td style="text-align: right">2.568 s</td>
      </tr>
      <tr>
        <td>总 tokens/s 中位数</td>
        <td style="text-align: right">24.16</td>
        <td style="text-align: right">12.46</td>
      </tr>
    </tbody>
  </table>
</div>
<p>TTFT 约为参考组的 3.73 倍，输出逐 token 一致。</p>
<h3 id="3-int8-量化叠加投机fp32k4">3. INT8 量化叠加投机，FP32，k=4</h3>
<p>Draft 替换 168 个 Linear，Target 替换 196 个 Linear；<code>out_head</code> 保持不量化。</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>指标</th>
        <th style="text-align: right">INT8 Target-only</th>
        <th style="text-align: right">INT8 + 投机</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>TTFT 中位数</td>
        <td style="text-align: right">177.78 ms</td>
        <td style="text-align: right">600.56 ms</td>
      </tr>
      <tr>
        <td>总耗时中位数</td>
        <td style="text-align: right">4.936 s</td>
        <td style="text-align: right">8.394 s</td>
      </tr>
      <tr>
        <td>总 tokens/s 中位数</td>
        <td style="text-align: right">6.48</td>
        <td style="text-align: right">3.81</td>
      </tr>
      <tr>
        <td>Draft 接受率</td>
        <td style="text-align: right">—</td>
        <td style="text-align: right">30.00%</td>
      </tr>
    </tbody>
  </table>
</div>
<p>INT8 + 投机的 TTFT 约为量化参考组的 3.38 倍，总耗时约为 1.70 倍。最终输出与量化 Target-only 逐 token 一致。</p>
<p>当前分配内存约为 4097.27 MB，低于此前未量化双模型报告的 9111.89 MB；但驱动分配约为 11426.02 MB，高于未量化组的 10354.38 MB。不同内存口径不能合并成“全面更省显存”，也没有将其他进程的绝对值冒充同一进程峰值。</p>
<p>当前量化与投机叠加仍未获得性能收益：量化的反量化成本与投机的草稿、校验、回滚和同步成本同时存在。该结论只适用于当前模型、Mac / MPS 和教学实现，不代表融合 kernel 或生产 GPU 上的组合效果。</p>
<h2 id="二十一cuda-同口径复测量化开销缩小投机仍未转正">二十一、CUDA 同口径复测：量化开销缩小，投机仍未转正</h2>
<p>在 Windows + WSL2 / Ubuntu 24.04 + RTX 4070 Ti 上，使用相同代码、Qwen 权重、token store 和测量配置完成 I3 补验。环境为 PyTorch 2.14.1+cu130，Python 3.12.12，FP16 / BF16、autocast、SDPA 与 compile 探针均通过。</p>
<h3 id="1-推理基线与-kv-cache">1. 推理基线与 KV Cache</h3>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>模式</th>
        <th style="text-align: right">TTFT 中位数</th>
        <th style="text-align: right">Decode 中位数</th>
        <th>输出</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>KV Cache</td>
        <td style="text-align: right">21.75 ms</td>
        <td style="text-align: right">57.56 tokens/s</td>
        <td>与 no-cache 逐 token 一致</td>
      </tr>
      <tr>
        <td>No Cache</td>
        <td style="text-align: right">19.91 ms</td>
        <td style="text-align: right">54.41 tokens/s</td>
        <td>与 cache 逐 token 一致</td>
      </tr>
    </tbody>
  </table>
</div>
<p>当前 CUDA 下 cache 的 decode 提速约 <strong>1.06 倍</strong>，低于 Mac 基线的 1.73 倍；短 prompt 下 no-cache 重算已经很快，不能跨设备沿用收益倍数。</p>
<p>MHA / GQA 探针在 CUDA 首次运行时混入约 8.13 MiB 的首次工作区 / 运行时增量，并暴露 MPS 专属 <code>driver_allocated_bytes</code> 字段不存在的问题。增加正式测量前 warmup、重置峰值，并仅对 MPS 计算 driver 增量后：</p>
<ul>
<li>MHA 当前分配增量 = 6,193,152 bytes；</li>
<li>GQA 当前分配增量 = 884,736 bytes；</li>
<li>两者均与实际 KV 张量字节数完全一致，GQA 仍为 MHA 的 1/7。</li>
</ul>
<p>该修复说明首次运行时开销不能直接当成模型的固定内存成本。</p>
<h3 id="2-量化质量与存储">2. 量化质量与存储</h3>
<p>CUDA 上持久张量压缩比例与 Mac 一致：INT8 减少 54.26%（约 2.19 倍），INT4 减少 63.31%（约 2.73 倍）。</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>路径</th>
        <th style="text-align: right">参考 PPL → 量化 PPL</th>
        <th style="text-align: right">相对变化</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>W8A32</td>
        <td style="text-align: right">69.294 → 69.537</td>
        <td style="text-align: right">+0.350%</td>
      </tr>
      <tr>
        <td>W4A32</td>
        <td style="text-align: right">69.294 → 160.364</td>
        <td style="text-align: right">+131.425%</td>
      </tr>
      <tr>
        <td>W8A16（FP16）</td>
        <td style="text-align: right">69.275 → 69.546</td>
        <td style="text-align: right">+0.391%</td>
      </tr>
      <tr>
        <td>W8A16（BF16）</td>
        <td style="text-align: right">69.560 → 69.778</td>
        <td style="text-align: right">+0.313%</td>
      </tr>
      <tr>
        <td>W4A16（BF16）</td>
        <td style="text-align: right">69.560 → 160.222</td>
        <td style="text-align: right">+130.337%</td>
      </tr>
    </tbody>
  </table>
</div>
<p>FP16 没有再出现 RMSNorm 导致的几百 PPL 异常，说明 FP32 累积修复在 CUDA 上同样有效。INT4 的 top-1 变化与显著 PPL 上升仍存在。</p>
<h3 id="3-量化真实生成">3. 量化真实生成</h3>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>路径</th>
        <th style="text-align: right">TTFT：参考 → 量化</th>
        <th style="text-align: right">Decode 剩余比例</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>W8A32</td>
        <td style="text-align: right">18.86 → 23.44 ms</td>
        <td style="text-align: right">80.90%</td>
      </tr>
      <tr>
        <td>W4A32</td>
        <td style="text-align: right">19.33 → 43.48 ms</td>
        <td style="text-align: right">43.09%</td>
      </tr>
      <tr>
        <td>W8A16（FP16）</td>
        <td style="text-align: right">20.52 → 25.83 ms</td>
        <td style="text-align: right">75.75%</td>
      </tr>
      <tr>
        <td>W8A16（BF16）</td>
        <td style="text-align: right">21.48 → 25.44 ms</td>
        <td style="text-align: right">84.67%</td>
      </tr>
      <tr>
        <td>W4A16（BF16）</td>
        <td style="text-align: right">21.42 → 50.09 ms</td>
        <td style="text-align: right">44.70%</td>
      </tr>
    </tbody>
  </table>
</div>
<p>量化在 CUDA 上仍然变慢，但相对开销普遍小于 Mac。相同分解实现会因设备而改变相对成本，不能把 Mac 的减速比例直接套到 CUDA。</p>
<h3 id="4-投机与-int8-叠加">4. 投机与 INT8 叠加</h3>
<p>统一使用 k=4、32 个新 token、1 次 warmup、3 次正式测量：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>路径</th>
        <th>输出逐 token 一致</th>
        <th style="text-align: right">TTFT：参考 → 投机</th>
        <th style="text-align: right">总耗时：参考 → 投机</th>
        <th style="text-align: right">Draft 接受率</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>FP32</td>
        <td>是</td>
        <td style="text-align: right">24.47 → 149.18 ms</td>
        <td style="text-align: right">0.711 → 2.141 s</td>
        <td style="text-align: right">33.93%</td>
      </tr>
      <tr>
        <td>BF16</td>
        <td><strong>否</strong></td>
        <td style="text-align: right">28.89 → 175.12 ms</td>
        <td style="text-align: right">0.827 → 1.667 s</td>
        <td style="text-align: right">55.00%</td>
      </tr>
      <tr>
        <td>FP32 + INT8</td>
        <td>是</td>
        <td style="text-align: right">57.38 → 244.13 ms</td>
        <td style="text-align: right">1.725 → 3.388 s</td>
        <td style="text-align: right">30.00%</td>
      </tr>
    </tbody>
  </table>
</div>
<p>FP32 投机的总耗时约为 Target-only 的 3.01 倍，INT8 叠加约为 1.96 倍。BF16 因输出不一致，不能作为严格性能收益验收。</p>
<p>结合 Mac 上 BF16 k=2 的不一致，当前 BF16 精确输出等价性在不同设备 / lookahead 下尚不稳定；不宣称已定位到具体底层 kernel。FP32 是当前严格正确性对照路径。</p>
<h3 id="5-当前边界-1">5. 当前边界</h3>
<ul>
<li>CUDA 复测使用 k=4，不表示已完成 k=2 / 8 的 CUDA 扫描；</li>
<li>当前投机实现仍未在 Mac 或 CUDA 上取得正收益；</li>
<li>量化报告中的 peak 可能包含转换与前序步骤，不能直接当成推理节省峰值；</li>
<li>预分配 KV Cache 仍后移，动态 <code>torch.cat</code> 尚未消除；</li>
<li>采样投机、自适应 lookahead、融合 kernel 与生产级 Serving 均未覆盖。</li>
</ul>
<p>I3 补验 1～3 至此完成；预分配 KV Cache 按约定后移。</p>
<h2 id="二十二i3-正式收官从模型生成到可用的推理服务">二十二、I3 正式收官：从模型生成到可用的推理服务</h2>
<p>I3 这个里程碑用了三天。它不再是单一的训练或推理实验，而是从 next-token 生成开始，逐步完成缓存、量化、双模型校验、流式服务、会话管理和双设备验收的一条完整链路。</p>
<h3 id="1-最终交付清单">1. 最终交付清单</h3>
<ul>
<li><strong>推理基线</strong>：区分 prefill / decode，实测 TTFT、decode 吞吐、KV Cache 字节数与设备内存；</li>
<li><strong>增量 prefill 修复</strong>：补齐 v1 / v2 在已有 cache 下多 token 输入的因果掩码偏移；</li>
<li><strong>会话级 KV Cache</strong>：保存 token IDs、K/V 和位置进度，支持命中、失效、token 预算与 v3 滑动裁剪；</li>
<li><strong>权重量化</strong>：实现逐行 INT8、INT4 packing / unpacking，并完成 W8A32 / W4A32、W8A16 / W4A16 对照；</li>
<li><strong>投机解码</strong>：实现贪心接受、Target 修正、bonus、双方 cache 回滚和状态同步；</li>
<li><strong>SSE 流式服务</strong>：逐事件推送、连接中断状态失效、浏览器流式渲染；</li>
<li><strong>多会话管理</strong>：按 session ID 隔离 history / cache / 位置，支持有界 LRU、新建、切换与历史恢复；</li>
<li><strong>补验</strong>：MHA / GQA 实际 KV 占用、量化叠加投机与 TTFT、CUDA 同口径复测；</li>
<li><strong>学习笔记</strong>：保留真实报告、测试范围、浏览器验收截图和未覆盖边界。</li>
</ul>
<h3 id="2-最重要的实测结论">2. 最重要的实测结论</h3>
<ul>
<li>KV Cache 在 Mac 基线中 decode 提速约 <strong>1.73 倍</strong>，CUDA 当前短 prompt 下约 <strong>1.06 倍</strong>；相同优化在不同设备上的收益不同。</li>
<li>Qwen 当前 FP32 配置下，GQA 的实际 KV Cache 为 MHA 的 <strong>1/7</strong>，减少 <strong>85.71%</strong>，张量计算与设备增量一致。</li>
<li>INT8 持久张量减少 <strong>54.26%</strong>，当前 heldout PPL 损失较小；INT4 持久张量减少 <strong>63.31%</strong>，但当前逐行实现出现显著 PPL 损失与文本退化。</li>
<li>当前量化路径在 Mac 与 CUDA 上都未提速；CUDA 的相对反量化开销通常更小，但存储下降仍不等于推理加速。</li>
<li>当前贪心投机在 FP32 下保持 Target 逐 token 一致，但 k=2 / 4 / 8 均为负收益；k 增大时接受率依次为 48.48%、33.93%、20.41%，没有换来更快生成。</li>
<li>BF16 在 Mac k=2 与 CUDA k=4 上出现过输出不一致，严格数值等价性尚不稳定，未将相关性能结果当作正确性验收通过。</li>
<li>FP16 PPL 异常的根因是 RMSNorm 的 FP16 平方溢出，而非量化或某个单一设备；改为 FP32 累积后，FP16 PPL 与生成均恢复正常。</li>
</ul>
<p>这些结果都不是“某项技术一定好或不好”，而是当前代码、模型、设备与负载下的真实交易记录。</p>
<h3 id="3-学习收官与工程边界">3. 学习收官与工程边界</h3>
<p>功能完成不等于所有内容已经吃透。以下内容仍保留为后续学习或工程专题：</p>
<ul>
<li>滑动窗口的位置与前缀 / 后缀裁剪细节；</li>
<li>INT4 pack / unpack 的独立复盘；</li>
<li>预分配 KV Cache，当前动态 <code>torch.cat</code> 尚未消除；</li>
<li>严格采样投机的概率接受与残差修正；</li>
<li>自适应 lookahead、融合量化 kernel 与生产级推理调度；</li>
<li>实际量化模型文件大小与多任务质量评测；</li>
<li>多会话并发推理；当前请求仍串行处理。</li>
</ul>
<p>测试与实验均按当时列出的范围执行，不把不同阶段数字累加成一次全量回归。当前学习范围的相关回归曾由用户实际运行并达到 <strong>44 passed</strong>；后续专项仍需按各自边界验收。</p>
<h3 id="4-下一站modelv4--qwen3">4. 下一站：ModelV4 / Qwen3</h3>
<p>I3 的选修番外已经建立：模型兼容性审计与 ModelV4。下一项不是继续堆推理指标，而是学习面对陌生模型时如何判断兼容性：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">读取 config.json
</span></span><span class="line"><span class="cl">→ 检查权重键、形状与分片
</span></span><span class="line"><span class="cl">→ 阅读官方 forward 语义
</span></span><span class="line"><span class="cl">→ 建立兼容性矩阵
</span></span><span class="line"><span class="cl">→ 在完全隔离的 V4 中承接 Qwen3-0.6B Dense
</span></span><span class="line"><span class="cl">→ 做官方 logits、cache decode 与固定生成对照
</span></span></code></pre></div><p>V3 保持为稳定的 Qwen2.5 参照系，V4 使用独立模型目录、加载器与测试。I3 的功能进度、实验结论和学习理解到这里正式收官。</p>
]]></content:encoded>
    </item>
  </channel>
</rss>
