<?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>手搓 LLM on 吕炘嵘的博客</title>
    <link>https://blog.lvxinrong.com/llm/</link>
    <description>Recent content in 手搓 LLM on 吕炘嵘的博客</description>
    <image>
      <title>吕炘嵘的博客</title>
      <url>https://blog.lvxinrong.com/og-default.jpg</url>
      
      <link>https://blog.lvxinrong.com/llm/</link>
    </image>
    <generator>Hugo</generator>
    <language>zh-CN</language>
    <lastBuildDate>Wed, 18 Nov 2026 00:00:00 +0000</lastBuildDate>
    <atom:link href="https://blog.lvxinrong.com/llm/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>手搓 LLM 笔记 27：I5 评估校准与回归基准自动化</title>
      <link>https://blog.lvxinrong.com/llm/llm-27-i5-judge-calibration-regression/</link>
      <pubDate>Wed, 18 Nov 2026 00:00:00 +0000</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-27-i5-judge-calibration-regression/</guid>
      <description>I5 收官：完成人工盲评、AB/BA 位置校准、长度控制、多评委对照、独立 held-out、paired bootstrap 和 I0～I4 注册范围的一键回归报告。工程链路已跑通，但小样本、独立实现熟练度和完整评估能力仍需继续探索。</description>
      <content:encoded><![CDATA[<p>这篇是 I5 的收官汇总，承接 <a href="https://blog.lvxinrong.com/llm/llm-26-i4-post-training-recap/">笔记 26：I4 后训练收官</a>。</p>
<p>I4 做完了多轮 SFT、CoT-SFT、DPO、LoRA、RLVR / GRPO，但行为对照没有证明任何方法全面优于原始模型。DPO 的 val loss 从 0.628564 降到 0.155683，score 从 1.3776 升到 22.8115，行为正确数却仍是 29/32，没有超过原始模型的 30/32。</p>
<p>这让我更确定一件事：<strong>训练曲线只能说明优化目标正在下降，不能单独说明模型能力正在变好。</strong></p>
<p>I5 要补的就是这条证据链。</p>
<p>我对评估的第一性原理理解是：全面、科学、可对照、可对比、可解释地评估一个模型。现在再补一句：全面不是测完所有能力，而是知道自己测了什么、没测什么；科学也不是公式复杂，而是结论有边界，并且允许被新证据推翻。</p>
<h2 id="一i5-最终交付清单">一、I5 最终交付清单</h2>
<p>本轮完成：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">I5-A：人工评价协议、8 对匿名盲评样本、私密映射、标签写保护
</span></span><span class="line"><span class="cl">I5-B：成对评委、AB/BA 位置交换、结果坐标还原、断点续跑
</span></span><span class="line"><span class="cl">I5-C：无效填充与有效信息的长度控制实验
</span></span><span class="line"><span class="cl">I5-D：DeepSeek + Qwen4 Max 双评委、10 对独立 held-out、v2 评价规则
</span></span><span class="line"><span class="cl">I5-E：paired bootstrap、带 CI 的胜率矩阵、I4 门禁、I0～I4 注册范围总报告
</span></span><span class="line"><span class="cl">总验收：项目全量 173 passed，统一缓存报告与 I0/I4 受控刷新报告
</span></span></code></pre></div><p>这里有两个范围必须写清楚：</p>
<ul>
<li>人工样本仍然很小，8 对用于开发校准，10 对用于独立描述性验证；</li>
<li>一键报告覆盖的是当前注册产物，不是 I0～I4 所有历史实验的全量实时重跑。</li>
</ul>
<h2 id="二从单条打分到成对评估">二、从单条打分到成对评估</h2>
<p>M5 的评委主要给单条回答打 0～100 分，适合生成评分分布，但不适合直接研究位置偏见。</p>
<p>位置偏见需要一个对照结构：同一个评委面对同一对回答，只交换 A/B 的展示位置，观察它是否仍然选择同一条内容。</p>
<p>因此 I5 新增成对评估链路，没有重写 M5：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">同一任务
</span></span><span class="line"><span class="cl">→ 回答 A / 回答 B
</span></span><span class="line"><span class="cl">→ 原始 AB 顺序评一次
</span></span><span class="line"><span class="cl">→ 交换 BA 顺序再评一次
</span></span><span class="line"><span class="cl">→ 还原到原始回答身份
</span></span><span class="line"><span class="cl">→ 判断一致、位置敏感或明确胜负翻转
</span></span></code></pre></div><p>A/B 只是座位号，不是回答的身份证。</p>
<p>假设甲是正确回答，乙是错误回答：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">第一次：A=甲，B=乙，评委选 A
</span></span><span class="line"><span class="cl">第二次：A=乙，B=甲，评委选 B
</span></span></code></pre></div><p>两次原始字母不同，但都是在选甲，所以内容判断一致。</p>
<p>如果两次都选当前 A，则还原后一次选甲、一次选乙，才是明确的胜负翻转。</p>
<p>核心还原逻辑是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">swapped=False：A/B 原样保留
</span></span><span class="line"><span class="cl">swapped=True ：A ↔ B，tie 保持 tie
</span></span></code></pre></div><p><code>position_sensitive</code> 表示交换后结论发生变化；<code>decisive_flip</code> 则要求还原后确实发生 A/B 双方互换。<code>tie → A</code> 属于位置敏感，但不属于明确胜负翻转。</p>
<p>如果两次没有形成共同结论，就记录 <code>consensus_winner=null</code>。不能擅自改成平局，也不能只挑其中一次有利的结果。</p>
<h2 id="三人工评价协议结果推理质量信息密度">三、人工评价协议：结果、推理质量、信息密度</h2>
<h3 id="1-四个原因编码">1. 四个原因编码</h3>
<p>人工标签使用：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">correctness：最终答案与历史状态是否正确
</span></span><span class="line"><span class="cl">instruction：是否遵循明确的任务和输出指令
</span></span><span class="line"><span class="cl">reasoning ：推理是否可靠，是否有有效独立验算
</span></span><span class="line"><span class="cl">clarity   ：有效信息密度、重复和表达质量
</span></span></code></pre></div><p>双方最终都答对时，不能仅因为正确性重要就填 correctness；它没有造成双方差异。非平局至少记录一个原因，平局可以为空。</p>
<h3 id="2-三层递进而不是加权平均">2. 三层递进，而不是加权平均</h3>
<p>标注过程中，我逐渐把自己的判断整理成三层字典序：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">第一层：任务结果
</span></span><span class="line"><span class="cl">       最终答案、历史状态、明确指令遵循
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">第二层：推理质量
</span></span><span class="line"><span class="cl">       推理可靠性、历史解释、有效独立验算
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">第三层：信息密度
</span></span><span class="line"><span class="cl">       有效信息、重复、空话、简洁程度
</span></span></code></pre></div><p>前一层能够分出明确高下，就不让后一层翻盘：</p>
<ul>
<li>简洁但错误，不能靠表达战胜正确回答；</li>
<li>数值正确但违反“只输出数字”，会在第一层落后；</li>
<li>双方都正确且合规时，正确独立验算可以提高推理质量；</li>
<li>推理质量也相同时，才比较谁更简洁有效。</li>
</ul>
<p>这套标准是我的个人评价口径，不是所有人都必须同意的 universal 答案。评估系统首先要明确目标偏好，再讨论 AI 评委是否对齐。</p>
<h2 id="四8-对开发盲评稳定不等于与人工一致">四、8 对开发盲评：稳定不等于与人工一致</h2>
<p>首批从 I4 四模型的现有报告中抽取 8 对：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">3 对规则结果有分歧
</span></span><span class="line"><span class="cl">3 对双方规则通过
</span></span><span class="line"><span class="cl">2 对双方规则未通过
</span></span></code></pre></div><p>公开文件只有 A/B、任务、参考答案和人工标注栏；模型身份、规则结果和 token 数保存在私密 key 中。</p>
<p>抽样过程中发现同一道题被重复抽进不同 pair，于是增加了 <code>case_index</code> 跨分层去重。完成标注后又增加写保护：只要检测到人工标签，导出器就拒绝覆盖。</p>
<p>真实双评委结果：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>8 对开发样本</th>
        <th style="text-align: right">DeepSeek</th>
        <th style="text-align: right">Qwen4 Max</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>双顺序一致</td>
        <td style="text-align: right">6</td>
        <td style="text-align: right">7</td>
      </tr>
      <tr>
        <td>位置敏感</td>
        <td style="text-align: right">2</td>
        <td style="text-align: right">1</td>
      </tr>
      <tr>
        <td>明确胜负翻转</td>
        <td style="text-align: right">0</td>
        <td style="text-align: right">0</td>
      </tr>
      <tr>
        <td>与人工一致</td>
        <td style="text-align: right">4</td>
        <td style="text-align: right">6</td>
      </tr>
      <tr>
        <td>与人工分歧</td>
        <td style="text-align: right">2</td>
        <td style="text-align: right">1</td>
      </tr>
      <tr>
        <td>无共识、未参与人工比较</td>
        <td style="text-align: right">2</td>
        <td style="text-align: right">1</td>
      </tr>
    </tbody>
  </table>
</div>
<p>双方都有共识的 5 对，结论全部相同。16 次同顺序比较中，13 次相同，3 次不同。</p>
<p>这里的重点不是选出一个更好的评委，而是看到两类问题：</p>
<ul>
<li>DeepSeek 在两对双方都未通过的样本上，从平局变成了有赢家；</li>
<li>两位评委都在一些双方答对的样本上稳定给 tie，而我会根据推理和表达选出赢家。</li>
</ul>
<p>所以，<strong>双顺序稳定只说明结果稳定，不说明评价标准已经与人工一致。</strong></p>
<h2 id="五长度控制变长不等于变更好">五、长度控制：变长不等于变更好</h2>
<p>为了隔离长度影响，又构造了 4 个受控条件：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>条件</th>
        <th>DeepSeek</th>
        <th>Qwen4 Max</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>完全重复</td>
        <td>稳定 tie</td>
        <td>稳定 tie</td>
      </tr>
      <tr>
        <td>无效填充变长</td>
        <td>简洁版获胜 → tie，未决</td>
        <td>稳定选择简洁版</td>
      </tr>
      <tr>
        <td>有效验算变长</td>
        <td>稳定 tie</td>
        <td>稳定 tie</td>
      </tr>
      <tr>
        <td>错误且冗长</td>
        <td>稳定选择正确简洁版</td>
        <td>稳定选择正确简洁版</td>
      </tr>
    </tbody>
  </table>
</div>
<p>在这 4 个条件中，没有任何双顺序共识选择更长回答。</p>
<p>因此本轮没有观察到“越冗长越容易赢”的证据，但也不能推广成两个评委在所有任务上都没有长度偏见。</p>
<p>更有价值的发现是：两位评委都把有效独立验算判成了平局。Qwen 的原始推理明确承认验算正确，却认为它不足以构成实质差异。</p>
<p>这说明问题不只在长度，还在“有效信息什么时候足以打破平局”。于是 v2 prompt 明确加入：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">正确、非重复、与任务相关的独立验算或推理，可以构成实质优势。
</span></span><span class="line"><span class="cl">重复用户要求、复述格式、重复同一种计算，不属于有效增量。
</span></span><span class="line"><span class="cl">额外验算不是强制要求，没有有意义增量时不处罚简洁回答。
</span></span></code></pre></div><h2 id="六10-对独立-held-out不再看答案调评委">六、10 对独立 held-out：不再看答案调评委</h2>
<p>随后创建了 10 对全新样本，每类两对：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">正确性门槛
</span></span><span class="line"><span class="cl">有效独立验算
</span></span><span class="line"><span class="cl">无效填充
</span></span><span class="line"><span class="cl">实质等价
</span></span><span class="line"><span class="cl">指令遵循
</span></span></code></pre></div><p>这些题与前面的开发材料不重复。先完成人工标注，再运行冻结的 v2 prompt。</p>
<p>解盲后，设计假设与人工判断有 4 对不一致：</p>
<ul>
<li>两条设计为无效填充的样本，我都选择了显式阐述指令理解的版本；</li>
<li>两条设计为实质等价的样本，我分别根据简洁性和历史回顾选出了赢家。</li>
</ul>
<p>这些 winner 没有被改成设计假设。它们反而帮助我进一步确认了上面的三层评价标准。</p>
<h3 id="1-held-out-总体结果">1. held-out 总体结果</h3>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>10 对 held-out</th>
        <th style="text-align: right">DeepSeek</th>
        <th style="text-align: right">Qwen4 Max</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>双顺序一致</td>
        <td style="text-align: right">6</td>
        <td style="text-align: right">10</td>
      </tr>
      <tr>
        <td>位置敏感</td>
        <td style="text-align: right">4</td>
        <td style="text-align: right">0</td>
      </tr>
      <tr>
        <td>明确胜负翻转</td>
        <td style="text-align: right">2</td>
        <td style="text-align: right">0</td>
      </tr>
      <tr>
        <td>与人工一致</td>
        <td style="text-align: right">4</td>
        <td style="text-align: right">6</td>
      </tr>
      <tr>
        <td>与人工稳定分歧</td>
        <td style="text-align: right">2</td>
        <td style="text-align: right">4</td>
      </tr>
      <tr>
        <td>无共识、未决</td>
        <td style="text-align: right">4</td>
        <td style="text-align: right">0</td>
      </tr>
    </tbody>
  </table>
</div>
<p>双方都有共识的 6 对全部结论相同。20 次同顺序比较中，16 次相同，4 次不同。</p>
<h3 id="2-按条件看结果">2. 按条件看结果</h3>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>条件，每类 2 对</th>
        <th>DeepSeek</th>
        <th>Qwen4 Max</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>正确性门槛</td>
        <td>1 对一致，1 对未决</td>
        <td>2 对一致</td>
      </tr>
      <tr>
        <td>指令遵循</td>
        <td>1 对一致，1 对未决</td>
        <td>2 对一致</td>
      </tr>
      <tr>
        <td>有效独立验算</td>
        <td>2 对一致</td>
        <td>2 对一致</td>
      </tr>
      <tr>
        <td>格式复述 / 填充</td>
        <td>1 对稳定分歧，1 对未决</td>
        <td>2 对稳定分歧</td>
      </tr>
      <tr>
        <td>实质等价的细微差异</td>
        <td>1 对稳定分歧，1 对未决</td>
        <td>2 对稳定分歧</td>
      </tr>
    </tbody>
  </table>
</div>
<p>Qwen 的 6 对人工一致，全部集中在正确性、指令遵循和有效独立验算；4 对分歧全部是稳定给出 tie。</p>
<p>也就是说，Qwen 在当前样本上更稳定，但并没有完全对齐我的信息密度与历史解释偏好。</p>
<p>DeepSeek 的两次明确胜负翻转分别落在正确性和指令遵循样本上，这类不稳定比一般的表达偏好更需要进入回归报告。</p>
<p>当前没有同一 held-out 上的 v1 对照，因此只能说 v2 在这批新样本上的表现已经测量，不能把差异全部归因于 prompt 改进。</p>
<h2 id="七qwen-接入输出预算也属于评估配置">七、Qwen 接入：输出预算也属于评估配置</h2>
<p>Qwen4 Max 使用 Token Plan 的 OpenAI 兼容接口，复用同一套双顺序和断点续跑逻辑。</p>
<p>实际接入时遇到了空内容：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">max_tokens=16
</span></span><span class="line"><span class="cl">finish_reason=length
</span></span><span class="line"><span class="cl">content=&#34;&#34;
</span></span></code></pre></div><p>提高预算后可以正常输出。v2 held-out 中，256 tokens 也曾出现全部用于 reasoning、正式答案尚未产生的情况，因此该轮改用 512，并把配置写入报告身份。</p>
<p>Qwen 报告保留：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">content
</span></span><span class="line"><span class="cl">reasoning_content
</span></span><span class="line"><span class="cl">finish_reason
</span></span><span class="line"><span class="cl">prompt / completion / reasoning tokens
</span></span></code></pre></div><p>这说明输出预算不是无关紧要的工程参数。预算过小会把“尚未给出判断”变成空内容；不同评委的推理模式和 token 配置也必须记录，不能把所有行为差异都解释成模型本身的能力差异。</p>
<p>解析失败时，原始响应会先落盘再抛错；有效顺序在续跑时不重复请求。</p>
<h2 id="八paired-bootstrap给-i4-胜率补上不确定性">八、paired bootstrap：给 I4 胜率补上不确定性</h2>
<p>I4 原本只有同一 32 题上的 win / loss / tie。I5 增加 paired bootstrap，重采样单位是 case，而不是分别抽左右模型的回答。</p>
<p>每次抽中一道题，就同时保留所有模型在这道题上的结果，再重新计算指标。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">win_rate_all   = wins / 全部 case
</span></span><span class="line"><span class="cl">net_win_rate   = (wins - losses) / 全部 case
</span></span><span class="line"><span class="cl">tie_rate       = ties / 全部 case
</span></span></code></pre></div><p>取 2000 次重采样的 2.5% 与 97.5% 分位数，得到 95% 区间。</p>
<p>真实结果：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>对照</th>
        <th>W/L/T</th>
        <th style="text-align: right">net</th>
        <th>95% CI</th>
        <th>判定</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>original vs CoT-SFT v2</td>
        <td>2/1/29</td>
        <td style="text-align: right">+0.03125</td>
        <td>[-0.0625, +0.15625]</td>
        <td>inconclusive</td>
      </tr>
      <tr>
        <td>original vs DPO v1</td>
        <td>1/0/31</td>
        <td style="text-align: right">+0.03125</td>
        <td>[0, +0.09375]</td>
        <td>inconclusive</td>
      </tr>
      <tr>
        <td>original vs GRPO 单组更新</td>
        <td>1/1/30</td>
        <td style="text-align: right">0</td>
        <td>[-0.09375, +0.09375]</td>
        <td>inconclusive</td>
      </tr>
      <tr>
        <td>CoT-SFT v2 vs DPO v1</td>
        <td>2/2/28</td>
        <td style="text-align: right">0</td>
        <td>[-0.125, +0.125]</td>
        <td>inconclusive</td>
      </tr>
      <tr>
        <td>CoT-SFT v2 vs GRPO</td>
        <td>0/1/31</td>
        <td style="text-align: right">-0.03125</td>
        <td>[-0.09375, 0]</td>
        <td>inconclusive</td>
      </tr>
      <tr>
        <td>DPO v1 vs GRPO</td>
        <td>1/2/29</td>
        <td style="text-align: right">-0.03125</td>
        <td>[-0.15625, +0.0625]</td>
        <td>inconclusive</td>
      </tr>
    </tbody>
  </table>
</div>
<p>六组全部为 <code>inconclusive</code>。</p>
<p><code>original vs DPO</code> 的下界虽然等于 0，仍按严格规则判为证据不足。点估计为 0 也不代表等效，只表示当前样本没有检测到净差异。</p>
<p>32 道题中，每变化一道题就是 3.125 个百分点。bootstrap 展示了这种不确定性，但没有把小样本变成大样本。</p>
<h2 id="九从报告到门禁产物有效不等于能力通过">九、从报告到门禁：产物有效不等于能力通过</h2>
<p>I4 门禁将三类状态分开：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">artifact_status=pass
</span></span><span class="line"><span class="cl">  报告可读、源哈希一致、case 完整且对齐
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">regression_detected
</span></span><span class="line"><span class="cl">  是否有候选相对 original 出现明确的净胜率回退
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">evidence_status
</span></span><span class="line"><span class="cl">  improvement_detected / regression_detected / inconclusive
</span></span></code></pre></div><p>真实 I4 结果：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">artifact_status=pass
</span></span><span class="line"><span class="cl">models=4
</span></span><span class="line"><span class="cl">cases_per_model=32
</span></span><span class="line"><span class="cl">pairwise_comparisons=6
</span></span><span class="line"><span class="cl">regression_detected=False
</span></span><span class="line"><span class="cl">evidence_status=inconclusive
</span></span></code></pre></div><p>退出码为 0 只表示产物有效且没有检测到明确回退，不表示候选模型已经通过能力验收，更不证明模型等效。</p>
<h2 id="十i0i4-注册范围的一键总报告">十、I0～I4 注册范围的一键总报告</h2>
<h3 id="1-补齐-i0-机读对齐报告">1. 补齐 I0 机读对齐报告</h3>
<p>I0 原先主要依赖测试和历史日志。本轮新增独立报告导出器，使用固定输入、CPU、FP32、官方 eager 和本地 Qwen2.5-0.5B-Instruct 权重：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">完整 logits：4/4 通过
</span></span><span class="line"><span class="cl">cache prefill：通过
</span></span><span class="line"><span class="cl">首层与末层 KV：通过
</span></span><span class="line"><span class="cl">连续 cache decode：3/3 通过
</span></span><span class="line"><span class="cl">上述受控张量 max_abs_difference：全部为 0.0
</span></span></code></pre></div><p>结论只适用于当前固定条件，不推广到任意输入、设备、dtype、SDPA 或生成质量。</p>
<h3 id="2-统一覆盖与总报告">2. 统一覆盖与总报告</h3>
<p>覆盖清单把产物分为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">controlled_alignment
</span></span><span class="line"><span class="cl">single_observation
</span></span><span class="line"><span class="cl">repeated_measurement
</span></span><span class="line"><span class="cl">single_workload
</span></span><span class="line"><span class="cl">paired_gate
</span></span></code></pre></div><p>最终注册范围为 8 组产物，字段全部有效：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">coverage_status=complete_for_registered_scope
</span></span><span class="line"><span class="cl">registered_scope_only=true
</span></span></code></pre></div><p>统一入口：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">uv run python scripts/i5_regression.py
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">uv run python scripts/i5_regression.py <span class="se">\
</span></span></span><span class="line"><span class="cl">  --refresh-controlled <span class="se">\
</span></span></span><span class="line"><span class="cl">  --resamples <span class="m">2000</span> <span class="se">\
</span></span></span><span class="line"><span class="cl">  --seed <span class="m">20261119</span>
</span></span></code></pre></div><p>两种模式都已实际运行。第二种只实时刷新 I0/I4，I1～I3 始终读取历史测量：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">refresh_scope=[I0, I4]
</span></span><span class="line"><span class="cl">full_live_refresh=False
</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">I2 Compile 相对吞吐：约 +7.27%，三次运行，不提供性能 CI
</span></span><span class="line"><span class="cl">I3 KV Cache decode：约 1.73x，贪心输出一致
</span></span><span class="line"><span class="cl">I3 投机解码 k=2：token 一致，speedup=0.515，当前未提速
</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">artifacts_valid_capability_inconclusive
</span></span></code></pre></div><p>这个状态很准确地表达了当前结果：注册的数值与工程检查有效，但 I4 后训练能力差异仍然证据不足。</p>
<h2 id="十一全量项目回归">十一、全量项目回归</h2>
<p>收官前实际运行：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">uv run pytest -q
</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">173 passed in 594.64s (0:09:54)
</span></span></code></pre></div><p>同时执行：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">git diff --check
</span></span></code></pre></div><p>检查通过。</p>
<p>这次不是只跑 I5 新增的纯函数测试，而是项目当前完整测试集合。全绿表示当前测试覆盖范围通过，不替代开放能力评估，也不改变 I4 的 <code>inconclusive</code>。</p>
<h2 id="十二现成框架与本次手搓的位置">十二、现成框架与本次手搓的位置</h2>
<p>评估并不缺少现成框架：</p>
<ul>
<li>EleutherAI lm-evaluation-harness：标准 Benchmark、loglikelihood、生成任务和模型适配；</li>
<li>Inspect AI：Dataset、Solver、Scorer、多轮、工具与模型评分；</li>
<li>OpenCompass：大量模型与数据集，以及 Generic LLM Judge；</li>
<li>Promptfoo：模型 × Prompt 矩阵、断言、回归和 CI。</li>
</ul>
<p>I5 的手搓实现让我看见了这些框架背后的基本问题，但如果目标是长期维护通用评估平台，没有必要全部自己重写。</p>
<p>后续可以用同数据、同模型、同解码参数做框架对照，重点检查请求构造、样本日志、评分接口、tie / unresolved 和统计口径，而不是默认框架的每个定义都与我们相同。</p>
<h2 id="十三i5-停止边界">十三、I5 停止边界</h2>
<p>I5 可以按学习里程碑收官，但必须保留：</p>
<ul>
<li>评估主要基于小模型、算术与多轮数值更新的受控合成样本；</li>
<li>8 对开发样本与 10 对 held-out 都不足以支持普遍评委排名；</li>
<li>当前没有进行有统计意义的人机相关系数分析；</li>
<li>Qwen 与 DeepSeek 的推理方式和输出预算不同；</li>
<li>没有同批 v1 / v2 对照，不宣称 prompt 改进的因果收益；</li>
<li>人工标签来自单一标注者，代表当前个人评价口径；</li>
<li>I1～I3 在总报告中仍是历史缓存，不是完整 live 回归；</li>
<li>注册范围覆盖不等于所有历史实验已经统一接入；</li>
<li>工程链路完成不等于我已经独立掌握评估工程。</li>
</ul>
<h2 id="附留给未来的独立回顾任务非里程碑">附：留给未来的独立回顾任务（非里程碑）</h2>
<p>第一次从零手搓 LLM 时，我也只是懵懵懂懂。评估现在处于类似阶段：已经有概念、直觉和一些诊断经验，但大部分实现代码由 Kimi 提供，独立复现和迁移设计尚未充分验证。</p>
<p>评估可以被看作完全独立于某个 LLM 的一等工程体系。它包括任务构造、实验设计、人工标注、统计、数据隔离、报告和回归门禁。后续需要多评估几次，而不是把 I5 当成评估学习的终点。</p>
<p>以下任务不属于新里程碑，不阻塞 I6：</p>
<ul>
<li><input disabled="" type="checkbox"> 不看现有代码，独立复现 <code>canonicalize_winner</code> 与位置交换结果还原；</li>
<li><input disabled="" type="checkbox"> 独立实现 <code>build_paired_outcomes</code>，解释为什么必须按 case 配对；</li>
<li><input disabled="" type="checkbox"> 用一个小例子手算 wins、losses、ties 和 net_win_rate；</li>
<li><input disabled="" type="checkbox"> 解释为什么 tie、unresolved 和 decisive_flip 不能混为一谈；</li>
<li><input disabled="" type="checkbox"> 面对一个新任务，先写能力定义、数据隔离、基线和验收协议，再写训练代码；</li>
<li><input disabled="" type="checkbox"> 使用一个现成 eval 框架复现小组实验，并比较双方报告口径；</li>
<li><input disabled="" type="checkbox"> 在 I6 Java 缺陷修复中，把编译率、测试通过率、定位准确率和通用能力保持纳入同一评估协议。</li>
</ul>
<p>回顾目标不是背代码，而是离开现成实现后，仍能恢复最小主干，并知道每个结论能证明什么、不能证明什么。</p>
<h2 id="十四收官不是结束">十四、收官不是结束</h2>
<p>I5 更像是在地图上探索了一块迷雾，打下了一个标记。</p>
<p>现在我知道这里有哪些路：人工协议、双顺序、多评委、长度控制、配对统计和回归门禁；也知道哪里有悬崖：小样本、评价偏好、数据泄漏、未决分母和把 loss 当能力。</p>
<p>但这块区域还远没有深度探索。</p>
<p>所以今天的准确结论是：<strong>I5 工程里程碑完成，评估学习刚刚开始</strong>。后面还会在标准 Benchmark、Java 缺陷修复、Agent 轨迹和其他真实任务上继续把这块地图补完整。</p>
<h2 id="主要实验产物">主要实验产物</h2>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">data/eval/i5-human-calibration-blind.json
</span></span><span class="line"><span class="cl">data/eval/i5-human-calibration-key.json
</span></span><span class="line"><span class="cl">data/eval/i5-length-control.json
</span></span><span class="line"><span class="cl">data/eval/i5-holdout-blind.json
</span></span><span class="line"><span class="cl">data/eval/i5-holdout-key.json
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">data/reports/i5-pairwise-deepseek-chat-pilot.json
</span></span><span class="line"><span class="cl">data/reports/i5-pairwise-qwen4-max-pilot.json
</span></span><span class="line"><span class="cl">data/reports/i5-judge-comparison-pilot.json
</span></span><span class="line"><span class="cl">data/reports/i5-length-deepseek-deepseek-chat.json
</span></span><span class="line"><span class="cl">data/reports/i5-length-qwen-qwen4-max.json
</span></span><span class="line"><span class="cl">data/reports/i5-holdout-v2-deepseek-chat.json
</span></span><span class="line"><span class="cl">data/reports/i5-holdout-v2-qwen4-max-maxtokens512.json
</span></span><span class="line"><span class="cl">data/reports/i5-holdout-v2-comparison.json
</span></span><span class="line"><span class="cl">data/reports/i4-final-comparison-ci.json
</span></span><span class="line"><span class="cl">data/reports/i5-i4-gate.json
</span></span><span class="line"><span class="cl">data/reports/i0-numerical-alignment.json
</span></span><span class="line"><span class="cl">data/reports/i5-regression-coverage.json
</span></span><span class="line"><span class="cl">data/reports/i5-regression-summary.json
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">src/squid/eval/pairwise.py
</span></span><span class="line"><span class="cl">src/squid/eval/qwen_judge.py
</span></span><span class="line"><span class="cl">src/squid/eval/bootstrap.py
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">scripts/i5_calibration_export.py
</span></span><span class="line"><span class="cl">scripts/i5_pairwise_judge.py
</span></span><span class="line"><span class="cl">scripts/i5_judge_comparison.py
</span></span><span class="line"><span class="cl">scripts/i5_length_control.py
</span></span><span class="line"><span class="cl">scripts/i5_length_judge.py
</span></span><span class="line"><span class="cl">scripts/i5_holdout_export.py
</span></span><span class="line"><span class="cl">scripts/i5_i4_bootstrap_report.py
</span></span><span class="line"><span class="cl">scripts/i5_i4_gate.py
</span></span><span class="line"><span class="cl">scripts/i0_numerical_alignment_report.py
</span></span><span class="line"><span class="cl">scripts/i5_regression_coverage.py
</span></span><span class="line"><span class="cl">scripts/i5_regression.py
</span></span></code></pre></div>]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 番外：DeepSeek V4.1 Flash text_config 配置解读</title>
      <link>https://blog.lvxinrong.com/llm/llm-extra-deepseek-v41-flash-text-config/</link>
      <pubDate>Wed, 18 Nov 2026 01:50:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-extra-deepseek-v41-flash-text-config/</guid>
      <description>逐字段阅读 DeepSeek V4.1 Flash 的 text_config：从 hidden_size、Attention、MoE、长上下文压缩到 Engram 与 DSpark。区分配置事实、结构直觉与必须回源码确认的实现细节，不展开 vision_config。</description>
      <content:encoded><![CDATA[<p>这份 <code>text_config</code> 的信息密度很高。它不是一个简单的“更大版 Qwen”，而是把 <strong>MoE、低秩 Attention、长上下文压缩、稀疏索引、Engram 查表记忆和 DSpark 投机解码</strong>放进了同一套架构。</p>
<p>本文只解读配置，不宣称已经下载、加载或跑通模型。部分字段可以直接确认含义，部分只能形成结构直觉，还有一些必须回到官方 modeling 源码确认。</p>
<h2 id="一先看整体它由哪些主线组成">一、先看整体：它由哪些主线组成</h2>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">主干：40 个 Transformer Block
</span></span><span class="line"><span class="cl">注意力：64 Q heads / 1 KV head，配合低秩 Q / O 与压缩机制
</span></span><span class="line"><span class="cl">MoE：384 个路由专家 + 1 个共享专家，每 token 选择 6 个路由专家
</span></span><span class="line"><span class="cl">长上下文：YaRN + 逐层压缩 + 滑动窗口 + 稀疏索引
</span></span><span class="line"><span class="cl">Engram：独立的 n-gram 查表记忆
</span></span><span class="line"><span class="cl">DSpark：3 个草稿阶段 + 块生成 + Markov 顺序依赖 + 置信度调度
</span></span><span class="line"><span class="cl">量化：主路径 FP8、专家路径 FP4、动态激活与分块缩放
</span></span></code></pre></div><p>所以读这份配置时，不能只沿 <code>hidden_size → n_heads × head_dim</code> 这一条公式走。它要求把模型当作一个完整系统来读。</p>
<h2 id="二词表隐藏维度与层数">二、词表、隐藏维度与层数</h2>
<h3 id="vocab_size-129280"><code>vocab_size: 129280</code></h3>
<p>这是 tokenizer 的词表大小，包括子词、特殊 token、标点等，不是自然语言里的单词数量。</p>
<p>和 Qwen3 的 <code>151936</code> 相比，它少 22656 个 token，约少 14.9%。但词表不同，token id 不能直接兼容，同一个汉字在两个模型里的 id 也可能不同。</p>
<p>Embedding 参数量为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">129280 × 5120 = 661,913,600，约 6.62 亿
</span></span></code></pre></div><p>这只描述输入 embedding 的规模，不代表整个模型的参数量。</p>
<h3 id="hidden_size-5120"><code>hidden_size: 5120</code></h3>
<p>对应我们代码里的 <code>emb_dim</code>，表示每个 token 在残差流中的隐藏向量宽度：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">(B, T) → embedding → (B, T, 5120)
</span></span></code></pre></div><p>后面的 Block、归一化、残差连接和输出头主要围绕这 5120 维计算。</p>
<h3 id="num_hidden_layers-40"><code>num_hidden_layers: 40</code></h3>
<p>对应 40 个 Transformer Block。每个 Block 包含注意力、归一化、残差和 FFN / MoE 等结构，但从后续配置看，各层并不完全同构。</p>
<h2 id="三attentionq-头很多kv-很少q-内部维度也很宽">三、Attention：Q 头很多，KV 很少，Q 内部维度也很宽</h2>
<h3 id="num_attention_heads-64num_key_value_heads-1"><code>num_attention_heads: 64</code>、<code>num_key_value_heads: 1</code></h3>
<p>按标准 GQA 的字段含义：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">64 个 Q heads
</span></span><span class="line"><span class="cl">共享 1 个 K head 和 1 个 V head
</span></span></code></pre></div><p>KV 头数为 1，可以看作 MQA 这一极端形式。它有利于降低 KV 的头数与缓存成本，但不等于注意力总计算量也同比减少。</p>
<h3 id="head_dim-512"><code>head_dim: 512</code></h3>
<p>如果按标准 Attention 形状理解：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Q 总维度 = 64 × 512 = 32768
</span></span><span class="line"><span class="cl">K / V 总维度 = 1 × 512 = 512
</span></span></code></pre></div><p><code>32768</code> 与 <code>hidden_size=5120</code> 并不相等，这正是 <code>head_dim</code> 与 <code>hidden_size</code> 解耦：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">输入：(B, T, 5120)
</span></span><span class="line"><span class="cl">Q：5120 → 32768
</span></span><span class="line"><span class="cl">注意力输出：32768
</span></span><span class="line"><span class="cl">O 投影：32768 → 5120
</span></span></code></pre></div><p>隐藏流宽度与 Attention 内部宽度不要求一致。</p>
<p>但配置里还有 <code>q_lora_rank</code>、<code>o_lora_rank</code>，所以 32768 更适合先理解为理论上的 Q 头总维度，不能直接按普通 Linear 推断实际投影矩阵。</p>
<h3 id="q_lora_rank-1280o_lora_rank-1024o_groups-8"><code>q_lora_rank: 1280</code>、<code>o_lora_rank: 1024</code>、<code>o_groups: 8</code></h3>
<p>这里的 LoRA 不是后训练 adapter，而是<strong>模型原生的低秩投影结构</strong>：</p>
<ul>
<li><code>q_lora_rank</code>：Q 投影的低秩中间维度；</li>
<li><code>o_lora_rank</code>：O 投影的低秩中间维度；</li>
<li><code>o_groups</code>：O 投影的分组数。</li>
</ul>
<p>后训练 LoRA 是给已有权重增加低秩补丁；这里的低秩结构从预训练起就存在于模型中。</p>
<h3 id="qk_rope_head_dim-64"><code>qk_rope_head_dim: 64</code></h3>
<p>它表示 Q / K 中用于 RoPE 的通道数为 64，而不是整个 <code>head_dim=512</code> 都施加旋转编码。</p>
<p>我们的 V4 当前对所有 head_dim 通道执行 RoPE；这份配置则是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Q / K 中只有 64 个通道参与位置旋转
</span></span></code></pre></div><p>这不是 64 个可训练参数，而是 64 个通道，对应 32 对旋转维度。具体哪些通道使用 RoPE、哪些通道主要承载内容，需要看实现。</p>
<h2 id="四moe-与-router大量专家少量激活整体缩放">四、MoE 与 Router：大量专家、少量激活、整体缩放</h2>
<h3 id="n_routed_experts-384"><code>n_routed_experts: 384</code></h3>
<p>表示有 384 个可供 Router 选择的专家。</p>
<h3 id="n_shared_experts-1"><code>n_shared_experts: 1</code></h3>
<p>表示有 1 个共享专家，通常每个 token 都会经过它。</p>
<h3 id="num_experts_per_tok-6"><code>num_experts_per_tok: 6</code></h3>
<p>每个 token 从 384 个路由专家中选择 6 个：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">384 → Top-6 → 6 个路由专家 + 1 个共享专家
</span></span></code></pre></div><p>路由专家选择比例为 <code>6 / 384 ≈ 1.56%</code>。这描述的是专家数量上的稀疏性，不等于整个模型的激活参数比例。</p>
<h3 id="moe_intermediate_size-2304"><code>moe_intermediate_size: 2304</code></h3>
<p>这是每个 MoE 专家内部 FFN 的中间维度，不是专家数量。</p>
<h3 id="scoring_func-sqrtsoftplus"><code>scoring_func: &quot;sqrtsoftplus&quot;</code></h3>
<p>这是 Router 给专家打分时使用的函数：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">softplus(x) = ln(1 + e^x)
</span></span><span class="line"><span class="cl">sqrtsoftplus(x) = sqrt(softplus(x))
</span></span></code></pre></div><p>它输出平滑、非负的匹配分数，用于后续专家选择与权重计算。</p>
<h3 id="topk_method-noaux_tc"><code>topk_method: &quot;noaux_tc&quot;</code></h3>
<p>这是 Top-K 专家选择策略的名称。<code>noaux</code> 看起来与不使用辅助损失的负载均衡有关，<code>tc</code> 的具体含义需要源码确认，不能只靠缩写猜。</p>
<h3 id="norm_topk_prob-true"><code>norm_topk_prob: true</code></h3>
<p>表示对 Top-K 选中的路由权重做归一化。例如：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">[2, 1, 1] → [0.5, 0.25, 0.25]
</span></span></code></pre></div><p>使选中专家的权重和为 1，便于后续加权合并。</p>
<h3 id="routed_scaling_factor-15"><code>routed_scaling_factor: 1.5</code></h3>
<p>这是路由分支整体贡献的缩放系数，不是 <code>scoring_func</code> 的输入参数：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">scoring_func：计算专家匹配分数
</span></span><span class="line"><span class="cl">norm_topk_prob：归一化选中权重
</span></span><span class="line"><span class="cl">routed_scaling_factor：再缩放路由分支的整体贡献
</span></span></code></pre></div><h2 id="五长上下文yarn压缩索引和窗口同时存在">五、长上下文：YaRN、压缩、索引和窗口同时存在</h2>
<h3 id="max_position_embeddings-1048576"><code>max_position_embeddings: 1048576</code></h3>
<p>对应 1,048,576 tokens 的位置容量，不是 1 MB 内存，也不是 100 万字符。</p>
<p>结合：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-json" data-lang="json"><span class="line"><span class="cl"><span class="s2">&#34;rope_scaling&#34;</span><span class="err">:</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;rope_type&#34;</span><span class="p">:</span> <span class="s2">&#34;yarn&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;factor&#34;</span><span class="p">:</span> <span class="mi">16</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;original_max_position_embeddings&#34;</span><span class="p">:</span> <span class="mi">65536</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</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">65536 × 16 = 1048576
</span></span></code></pre></div><p>所以它表示通过 YaRN 扩展后的配置上限，不能直接理解为稳定有效的 100 万 token 上下文能力。</p>
<h3 id="beta_fast-32beta_slow-1"><code>beta_fast: 32</code>、<code>beta_slow: 1</code></h3>
<p>这两个参数用于调整 YaRN 不同频率通道的扩展强度：</p>
<ul>
<li>fast / 高频部分：调整更强；</li>
<li>slow / 低频部分：调整更弱。</li>
</ul>
<p>具体 beta 如何进入官方公式，需要看实现。YaRN 扩展位置表示范围，不等于长上下文质量自动得到保证。</p>
<h3 id="rope_theta-10000"><code>rope_theta: 10000</code></h3>
<p>这是主路径的 RoPE 底数，影响各通道的旋转频率与位置角度。它不能简单由 <code>qk_rope_head_dim=64</code> 推出“更小就够用了”，theta 与通道维度、训练上下文和位置泛化需要一起看。</p>
<h3 id="compress_rope_theta-160000"><code>compress_rope_theta: 160000</code></h3>
<p>这是压缩路径专用的 RoPE 底数，与主路径的 <code>10000</code> 不同，说明不同计算路径可能使用不同的位置编码策略。它具体作用于 token 位置、块位置还是索引位置，需要源码确认。</p>
<h3 id="compress_ratios"><code>compress_ratios</code></h3>
<p>数组恰好有 40 项，对应 40 层：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">第 0～1 层：0
</span></span><span class="line"><span class="cl">第 2～17 层：2
</span></span><span class="line"><span class="cl">第 18～37 层：1
</span></span><span class="line"><span class="cl">第 38～39 层：0
</span></span></code></pre></div><p>这更像逐层 Attention / KV 压缩策略，而不是直接压缩 Block 输出 hidden state。</p>
<p><code>0、1、2</code> 是比例还是模式编号，需要源码确认，不能仅凭字段名直接解释为输出尺寸缩小多少。</p>
<h3 id="kv_source_layer_ids-2-8-14-20"><code>kv_source_layer_ids: [2, 8, 14, 20]</code></h3>
<p>表示第 2、8、14、20 层与 KV 来源有关，可能存在跨层 KV 复用或共享。</p>
<h3 id="index_source_layer_ids-2-8-14-20-24-28-32-36"><code>index_source_layer_ids: [2, 8, 14, 20, 24, 28, 32, 36]</code></h3>
<p>表示另外 8 层与索引来源有关，稀疏索引机制可能从这些层获取信息。</p>
<p>两组 ID 的层编号从 0 还是从 1 开始，必须看官方代码。</p>
<h3 id="index_n_heads-32index_head_dim-128index_topk-512"><code>index_n_heads: 32</code>、<code>index_head_dim: 128</code>、<code>index_topk: 512</code></h3>
<p>这组更像稀疏索引模块自己的配置：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">32 个索引头
</span></span><span class="line"><span class="cl">每头 128 维
</span></span><span class="line"><span class="cl">每次选择 Top-512 候选位置或块
</span></span></code></pre></div><p>它不是主 Attention 的 64 个 Q heads 和 <code>head_dim=512</code>，而是用于计算“哪些历史信息值得被选中”。</p>
<h3 id="candidate_source_layer_id-20"><code>candidate_source_layer_id: 20</code></h3>
<p>候选信息来自第 20 层，具体层编号含义仍要看实现。</p>
<h3 id="candidate_topk_blocks-2048"><code>candidate_topk_blocks: 2048</code></h3>
<p>候选池最多保留 2048 个 block。</p>
<h3 id="candidate_block_size-8"><code>candidate_block_size: 8</code></h3>
<p>每个 block 包含 8 个 token，说明筛选粒度可能是 token 块而不是单 token。</p>
<p>如果按同一套块体系理解：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">候选池：2048 blocks × 8 tokens = 16384 tokens
</span></span><span class="line"><span class="cl">实际选择：Top-512 blocks，约为候选池的 1/4
</span></span></code></pre></div><p>这只是由配置形成的结构直觉，具体块生成方式仍需源码确认。</p>
<h3 id="sliding_window-128"><code>sliding_window: 128</code></h3>
<p>这是局部注意力窗口，当前 token 主要关注附近约 128 个 token，而不是完整历史。它与 <code>index_topk</code> 的动态筛选不同：</p>
<ul>
<li>sliding window：固定范围稀疏；</li>
<li>index top-k：内容驱动的动态稀疏。</li>
</ul>
<h2 id="六hyper-connections多路残差流与-sinkhorn-混合">六、Hyper-Connections：多路残差流与 Sinkhorn 混合</h2>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-json" data-lang="json"><span class="line"><span class="cl"><span class="s2">&#34;hc_mult&#34;</span><span class="err">:</span> <span class="mi">4</span><span class="err">,</span>
</span></span><span class="line"><span class="cl"><span class="s2">&#34;hc_sinkhorn_iters&#34;</span><span class="err">:</span> <span class="mi">20</span><span class="err">,</span>
</span></span><span class="line"><span class="cl"><span class="s2">&#34;hc_eps&#34;</span><span class="err">:</span> <span class="mf">1e-06</span>
</span></span></code></pre></div><p>这里的 <code>hc</code> 指 Hyper-Connections，作用于残差流，而不是 Attention heads。</p>
<p>可以暂时理解为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">隐藏状态
</span></span><span class="line"><span class="cl">→ 扩展成 4 路残差流
</span></span><span class="line"><span class="cl">→ 用可学习的系数组合这些分支
</span></span><span class="line"><span class="cl">→ 用 Sinkhorn 迭代归一化组合系数
</span></span><span class="line"><span class="cl">→ 得到稳定的混合表示
</span></span></code></pre></div><p><code>hc_mult=4</code> 是残差流扩展因子，<code>hc_sinkhorn_iters=20</code> 是 Sinkhorn 归一化迭代次数，<code>hc_eps=1e-6</code> 用于归一化计算的数值稳定性。</p>
<p>公开实现把它描述为多路残差流及 doubly stochastic 混合矩阵：<a href="https://atlas.klimoza.dev/models/deepseek-v4.1/blocks/token-group/group-input">参考</a>。</p>
<p>它不是“把 x 复制四份，每份完整执行一次 Attention / FFN，再拼接”，而更像在子层前后对多路残差流进行混合与分配。</p>
<h2 id="七engram模型内置的-n-gram-查表记忆">七、Engram：模型内置的 n-gram 查表记忆</h2>
<p><code>Engram</code> 可以理解成一种<strong>模型内置的 n-gram 向量记忆库</strong>：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">最近几个 token 组成 n-gram
</span></span><span class="line"><span class="cl">→ 在专用记忆表中取向量
</span></span><span class="line"><span class="cl">→ 门控判断是否采用
</span></span><span class="line"><span class="cl">→ 注入当前隐藏状态
</span></span></code></pre></div><p>它不是为了替代 Transformer 推理，而是让常见短语、固定搭配和静态知识可以直接查用，减少模型反复重算。<a href="https://aki.io/blog/deepseek-v4-1-flash-engram-embeddings/">公开介绍</a>也将它描述为 n-gram 查表记忆。</p>
<h3 id="engram_layer_ids-1-14"><code>engram_layer_ids: [1, 14]</code></h3>
<p>表示在第 1、14 层插入 Engram 模块。</p>
<h3 id="engram_num_embeddings-384006168-384016682"><code>engram_num_embeddings: [384006168, 384016682]</code></h3>
<p>两个 Engram 表各自的 embedding 条目或容量，约 3.84 亿个。具体如何分片、如何映射到物理表，需要看实现。</p>
<h3 id="engram_max_ngram_size-4"><code>engram_max_ngram_size: 4</code></h3>
<p>最多使用 4 个 token 组成一个 n-gram，说明它主要处理短组合与局部模式。</p>
<h3 id="engram_vocab_size-16000000"><code>engram_vocab_size: 16000000</code></h3>
<p>n-gram 的索引 / 词表空间为 1600 万，远大于主词表的 129280。</p>
<h3 id="engram_n_heads-8"><code>engram_n_heads: 8</code></h3>
<p>Engram 检索模块使用 8 个头，不是主 Attention 的 64 个头。</p>
<h3 id="engram_head_dim-256"><code>engram_head_dim: 256</code></h3>
<p>每个 Engram head 的向量维度为 256。</p>
<h3 id="engram_pad_token_id-2"><code>engram_pad_token_id: 2</code></h3>
<p>Engram 自己的 padding token id。</p>
<h3 id="engram_compressed_vocab_size-99092"><code>engram_compressed_vocab_size: 99092</code></h3>
<p>压缩后的 n-gram 词表大小，不是主模型词表大小。</p>
<p><code>engram_num_embeddings</code> 与 <code>engram_vocab_size</code> 不是一回事：前者更像实际条目或参数容量，后者是 n-gram 索引空间，<code>engram_compressed_vocab_size</code> 则是压缩后的表示空间。</p>
<p>它和“把短句直接做成高阶 token”也不同：主 token 序列没有被替换，Engram 是额外提供查表向量，补充模型计算。</p>
<h2 id="八dspark内置投机解码草稿结构">八、DSpark：内置投机解码草稿结构</h2>
<p>DSpark 是内置的投机解码机制，核心不是让模型更聪明，而是尽量通过并行起草与目标模型验证降低逐 token 解码成本。<a href="https://arxiv.org/html/2607.05147v1">DSpark 论文</a>描述了半自回归并行起草、Markov 顺序依赖和置信度调度。</p>
<h3 id="num_nextn_predict_layers-3"><code>num_nextn_predict_layers: 3</code></h3>
<p>表示有 3 个 DSpark 草稿阶段 / 预测层，不是一次生成 3 个 token。</p>
<h3 id="dspark_block_size-5"><code>dspark_block_size: 5</code></h3>
<p>每个草稿块最多提出 5 个 token，不是固定接受 5 个。</p>
<h3 id="dspark_noise_token_id-128799"><code>dspark_noise_token_id: 128799</code></h3>
<p>这是 DSpark 并行起草时使用的特殊噪声 / 占位 token，不是正常文本内容。</p>
<h3 id="dspark_target_layer_ids-37-38-39"><code>dspark_target_layer_ids: [37, 38, 39]</code></h3>
<p>草稿结构复用目标模型第 37、38、39 层的表示，即 40 层主干的最后三层。</p>
<h3 id="dspark_markov_rank-256"><code>dspark_markov_rank: 256</code></h3>
<p>Markov 头的低秩维度，用于补足并行起草时的顺序依赖和块内一致性。</p>
<h3 id="dspark_n_routed_experts-128"><code>dspark_n_routed_experts: 128</code></h3>
<p>DSpark 自己的 MoE 部分包含 128 个路由专家，与主模型的 384 个专家分开。</p>
<h3 id="dspark_num_experts_per_tok-3"><code>dspark_num_experts_per_tok: 3</code></h3>
<p>DSpark 的 MoE 部分每个 token 选择 3 个路由专家。</p>
<p>所以这里有两套 MoE 配置：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">主模型：384 个专家，每个 token 选 6 个，另有 1 个共享专家
</span></span><span class="line"><span class="cl">DSpark：128 个专家，每个 token 选 3 个
</span></span></code></pre></div><h2 id="九量化与精度配置">九、量化与精度配置</h2>
<h3 id="quant_method-fp8"><code>quant_method: &quot;fp8&quot;</code></h3>
<p>主量化方法使用 FP8，即 8 位浮点格式。它不是 INT8，具体是 E4M3 还是 E5M2 需要看实现。</p>
<h3 id="activation_scheme-dynamic"><code>activation_scheme: &quot;dynamic&quot;</code></h3>
<p>激活值在运行时动态量化，根据本次计算的实际数值范围确定尺度，而不是提前用校准数据固定所有激活范围。</p>
<h3 id="weight_block_size-32-32"><code>weight_block_size: [32, 32]</code></h3>
<p>表示权重按 32×32 小块量化，每块 1024 个元素。它比整张量共用一套尺度更细，有利于适应不同区域的数值分布，但会增加缩放因子与管理成本。</p>
<h3 id="scale_fmt-ue8m0"><code>scale_fmt: &quot;ue8m0&quot;</code></h3>
<p>这是缩放因子的编码格式：无符号 8 位指数形式，缩放值以 2 的幂次表示，而不是任意小数。它服务于量化尺度和硬件实现，不是权重本身的 dtype。</p>
<h3 id="expert_dtype-fp4"><code>expert_dtype: &quot;fp4&quot;</code></h3>
<p>专家权重使用 FP4，即 4 位浮点格式，进一步降低存储与带宽成本，但也更依赖激活截断、量化尺度和专用 kernel。</p>
<p>因此这份配置是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">主路径 FP8
</span></span><span class="line"><span class="cl">专家路径 FP4
</span></span><span class="line"><span class="cl">激活值动态量化
</span></span><span class="line"><span class="cl">缩放值 ue8m0
</span></span><span class="line"><span class="cl">权重块 32 × 32
</span></span></code></pre></div><p>不能把模型简单理解成 BF16，也不能把 FP4 理解成所有计算都只用 4 位完成。</p>
<h2 id="十其他字段速记">十、其他字段速记</h2>
<h3 id="hidden_act-silu"><code>hidden_act: &quot;silu&quot;</code></h3>
<p>FFN 的门控分支使用 SiLU，与我们当前实现一致：</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">act</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">gate_proj</span><span class="p">(</span><span class="n">x</span><span class="p">))</span> <span class="o">*</span> <span class="bp">self</span><span class="o">.</span><span class="n">up_proj</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
</span></span></code></pre></div><p>门控结构由 <code>gate_proj</code> 和 <code>up_proj</code> 的权重形成，不需要额外配置一个“门阀开关”。</p>
<h3 id="swiglu_limit-100"><code>swiglu_limit: 10.0</code></h3>
<p>这是 SwiGLU 的激活范围限制。公开实现示例大致是：</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">gate</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">clamp</span><span class="p">(</span><span class="n">gate</span><span class="p">,</span> <span class="nb">max</span><span class="o">=</span><span class="mf">10.0</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="n">up</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">clamp</span><span class="p">(</span><span class="n">up</span><span class="p">,</span> <span class="nb">min</span><span class="o">=-</span><span class="mf">10.0</span><span class="p">,</span> <span class="nb">max</span><span class="o">=</span><span class="mf">10.0</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="n">activation</span> <span class="o">=</span> <span class="n">F</span><span class="o">.</span><span class="n">silu</span><span class="p">(</span><span class="n">gate</span><span class="p">)</span> <span class="o">*</span> <span class="n">up</span>
</span></span></code></pre></div><p>它用于控制异常激活值并提高低精度计算稳定性，<a href="https://idlemachines.co.uk/essays/deepseek-v4-efficiency-release">公开实现说明</a>。</p>
<h3 id="rms_norm_eps-1e-20"><code>rms_norm_eps: 1e-20</code></h3>
<p>RMSNorm 分母中的 epsilon，用于防止除零和数值稳定。我们的 Qwen3-0.6B 是 <code>1e-6</code>，这里的 <code>1e-20</code> 小了 10¹⁴ 倍。</p>
<h3 id="attention_bias-false"><code>attention_bias: false</code></h3>
<p>Attention 投影不使用 bias。</p>
<h3 id="attention_dropout-00"><code>attention_dropout: 0.0</code></h3>
<p>Attention weights 的 dropout 比例为 0，即关闭注意力权重 dropout。</p>
<h3 id="initializer_range-002"><code>initializer_range: 0.02</code></h3>
<p>从零初始化权重时使用的正态分布标准差，可近似理解为 <code>N(0, 0.02)</code>。从 checkpoint 加载已有权重时，它不参与前向计算。</p>
<h3 id="use_cache-true"><code>use_cache: true</code></h3>
<p>启用或允许 KV Cache，实际调用仍可覆盖。</p>
<h3 id="tie_word_embeddings-false"><code>tie_word_embeddings: false</code></h3>
<p>输入 embedding 与输出头不共享权重。若为 true，才会共享。</p>
<h3 id="architectures-deepseekv41forcausallm"><code>architectures: [&quot;DeepseekV41ForCausalLM&quot;]</code></h3>
<p>告诉 Transformers 应实例化哪个模型类。</p>
<h3 id="model_type-deepseek_v41"><code>model_type: &quot;deepseek_v41&quot;</code></h3>
<p>模型家族的配置标识。</p>
<h3 id="dtype-bfloat16"><code>dtype: &quot;bfloat16&quot;</code></h3>
<p>默认精度声明，但实际主路径与专家路径还受量化配置影响。</p>
<h3 id="transformers_version-560"><code>transformers_version: &quot;5.6.0&quot;</code></h3>
<p>配置对应的 Transformers 版本，不是模型自身版本号。</p>
<h3 id="bos_token_id-0"><code>bos_token_id: 0</code></h3>
<p>序列开始 token。</p>
<h3 id="eos_token_id-1"><code>eos_token_id: 1</code></h3>
<p>序列结束 token。</p>
<h3 id="pad_token_id-2"><code>pad_token_id: 2</code></h3>
<p>Batch 对齐时使用的 padding token。</p>
<h3 id="image_token_id-129264"><code>image_token_id: 129264</code></h3>
<p>图像相关特殊 token，用于多模态输入，不属于普通文本生成逻辑。本文按当前学习选择，不展开 <code>vision_config</code>。</p>
<h2 id="十一仍需回源码确认的问题">十一、仍需回源码确认的问题</h2>
<p>这份配置很适合做“从配置到实现”的审计入口，但不能代替实现。当前留下的明确待查项包括：</p>
<ul>
<li><code>q_lora_rank / o_lora_rank</code> 的实际矩阵拆分与 Q/K/V/O 形状；</li>
<li><code>o_groups</code> 的分组方式；</li>
<li><code>noaux_tc</code> 的路由与负载均衡细节；</li>
<li><code>compress_ratios</code> 中 0 / 1 / 2 的精确语义；</li>
<li><code>kv_source_layer_ids</code> 与 <code>index_source_layer_ids</code> 的层编号及跨层数据流；</li>
<li><code>index_topk</code> 与候选块的实际筛选单位；</li>
<li><code>engram_num_embeddings</code> 的精确物理含义、分片与查表方式；</li>
<li>DSpark 的置信度头、验证路径和接受率。</li>
</ul>
<p>后续最合理的阅读顺序是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">官方 modeling
</span></span><span class="line"><span class="cl">→ attention / MoE forward
</span></span><span class="line"><span class="cl">→ 压缩与索引路径
</span></span><span class="line"><span class="cl">→ Engram 查表路径
</span></span><span class="line"><span class="cl">→ DSpark draft / verify / confidence 调度
</span></span></code></pre></div><p>这份 <code>text_config</code> 的真正价值，是让我看到了一种趋势：<strong>模型能力不只来自更大的矩阵，也来自低秩分解、稀疏计算、分层信息组织、查表记忆和推理期协同。</strong> 后续实现时，我会把这些字段继续转换成可验证的形状、数据流和测试，而不是只停留在名词解释上。</p>
<h2 id="写在最后">写在最后</h2>
<p>只读 <code>config.json</code>，就已经可以感受到最前沿开源模型的架构复杂程度。</p>
<p>再回头看我们从 V1 到 V4 的迭代，这种感受会更具体：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">V1：从 GPT-2 开始，把最基本的模型、训练和生成跑通
</span></span><span class="line"><span class="cl">V2：补上 RoPE，开始理解位置编码如何进入注意力
</span></span><span class="line"><span class="cl">V3：引入 RMSNorm、SwiGLU、GQA 和权重绑定，承接 Qwen2.5
</span></span><span class="line"><span class="cl">V4：显式 head_dim、QK RMSNorm，承接 Qwen3，并继续做推理、对话和后训练实验
</span></span></code></pre></div><p>以前我更多在想：一个矩阵怎么算、一个 Block 怎么对齐、一个权重形状为什么对不上。现在再往前看，会发现大模型的能力已经不只是由这些基本结构决定了。</p>
<p>Attention 可以压缩，KV 可以跨层组织，专家可以稀疏调用，记忆可以独立查表，生成也可以由草稿结构和置信度调度一起完成。它们解决的不是“如何把模型做得更大”，而是“怎样让计算、存储和推理真正配合起来”。</p>
<p>从 V1 到 V4，我是在把主干写明白；再往后，就是把这些高效机制一件件拆开来看。这个差距很明显，但也让我更清楚下一步该学什么。</p>
<p>不过，有一点很重要：<strong>整体思路上，它并没有逃离 Transformer 的体系。</strong></p>
<p>无论是 MoE、低秩 Attention、Hyper-Connections、Engram，还是 DSpark，主干计算依然是围绕 token 序列、注意力、残差流和逐层表示展开的。个人理解，这更像是对 Transformer 体系的一次精细化架构考量：在保留主干的前提下，针对长上下文、显存、计算效率和推理速度，做更细的拆解和优化。</p>
<p>这样看下来，很多新名词也没有那么陌生了。先抓住 Transformer 的主干，再看它们分别优化了哪一环，就更容易理解这些变化究竟在解决什么问题。</p>
]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 26：I4 后训练收官</title>
      <link>https://blog.lvxinrong.com/llm/llm-26-i4-post-training-recap/</link>
      <pubDate>Tue, 17 Nov 2026 00:00:00 +0000</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-26-i4-post-training-recap/</guid>
      <description>I4 收官：完成多轮 SFT、CoT-SFT、DPO 批量训练、LoRA / 全参对照、RLVR / GRPO 单组更新、同题规则胜率与真实 Web UI 回归。保留所有未超越原始模型、局部回退和最小实验边界。</description>
      <content:encoded><![CDATA[<p>这篇是 I4 的收官汇总，承接：</p>
<ul>
<li><a href="https://blog.lvxinrong.com/llm/llm-23-i4-multiturn-sft/">笔记 23：多轮对话 SFT</a></li>
<li><a href="https://blog.lvxinrong.com/llm/llm-24-i4-cot-sft/">笔记 24：思维链 CoT-SFT</a></li>
<li><a href="https://blog.lvxinrong.com/llm/llm-25-i4-dpo-preference/">笔记 25：DPO 偏好优化起步</a></li>
</ul>
<p>I4 的主干已经走通：多轮数据契约、SFT、CoT-SFT、DPO、LoRA / 全参对照、RLVR / GRPO 最小更新、同题规则对照和真实 Web UI 回归。</p>
<p>但“里程碑收官”不等于“所有模型能力目标都已达成”。本轮最重要的结论仍然是：<strong>后训练会重新分配模型行为，loss 下降与能力改善不是同一件事。</strong></p>
<h2 id="一i4-最终交付清单">一、I4 最终交付清单</h2>
<p>已完成：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">I4-A：多轮 Assistant-only mask、模板编码、Dataset、Batch padding、行为基线
</span></span><span class="line"><span class="cl">I4-B：多轮 SFT、能力回退分析、训练量干预、LoRA / 全参对照
</span></span><span class="line"><span class="cl">I4-C：CoT 数据契约、历史 CoT 可见性修复、三组 peak_lr 对照、严格格式验收
</span></span><span class="line"><span class="cl">I4-D：DPO 指标、单步更新、偏好数据、16 个 Batch 训练与行为评估
</span></span><span class="line"><span class="cl">I4-E：RLVR 分层奖励、组内优势、一次序列级 GRPO 更新与行为回归
</span></span><span class="line"><span class="cl">总验收：同一 CoT 评测集对照、规则 win / tie / loss、30 项相关测试、真实 Web UI 多轮回归
</span></span></code></pre></div><p>I5 的 LLM 评委校准、偏见检查和自动化 CI 尚未开始。</p>
<h2 id="二dpo-批量训练优化目标实现整体正确率未提升">二、DPO 批量训练：优化目标实现，整体正确率未提升</h2>
<h3 id="1-训练配置与过程">1. 训练配置与过程</h3>
<p>DPO 使用 32 条训练偏好对、8 条验证偏好对，四种 rejected 类型均衡分布：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">verbose_correct
</span></span><span class="line"><span class="cl">verbose_wrong
</span></span><span class="line"><span class="cl">repetition
</span></span><span class="line"><span class="cl">malformed
</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">batch_size = 2
</span></span><span class="line"><span class="cl">max_steps = 16
</span></span><span class="line"><span class="cl">beta = 0.1
</span></span><span class="line"><span class="cl">learning_rate = 1e-7
</span></span><span class="line"><span class="cl">grad clip = 1.0
</span></span><span class="line"><span class="cl">参考模型只预计算一次 logprob
</span></span><span class="line"><span class="cl">policy 从原始 Qwen3-0.6B Instruct 开始
</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">val loss： 0.628564 → 0.155683
</span></span><span class="line"><span class="cl">val score：1.3776 → 22.8115
</span></span><span class="line"><span class="cl">checkpoint reload：passed
</span></span></code></pre></div><p>这说明 DPO 的偏好优化目标确实被实现了。</p>
<h3 id="2-行为结果">2. 行为结果</h3>
<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">DPO v1</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>最终答案正确</td>
        <td style="text-align: right"><strong>30/32</strong></td>
        <td style="text-align: right">29/32</td>
      </tr>
      <tr>
        <td>完整 CoT</td>
        <td style="text-align: right">32/32</td>
        <td style="text-align: right">32/32</td>
      </tr>
      <tr>
        <td>数值更新</td>
        <td style="text-align: right"><strong>15/16</strong></td>
        <td style="text-align: right">14/16</td>
      </tr>
      <tr>
        <td>单轮算术</td>
        <td style="text-align: right">15/16</td>
        <td style="text-align: right">15/16</td>
      </tr>
      <tr>
        <td>自然结束</td>
        <td style="text-align: right">32/32</td>
        <td style="text-align: right">32/32</td>
      </tr>
    </tbody>
  </table>
</div>
<p>输出长度与推理质量：</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">DPO v1</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>平均生成 tokens</td>
        <td style="text-align: right">163.1</td>
        <td style="text-align: right">153.2</td>
      </tr>
      <tr>
        <td>中位生成 tokens</td>
        <td style="text-align: right">146</td>
        <td style="text-align: right">134.5</td>
      </tr>
      <tr>
        <td>最大生成 tokens</td>
        <td style="text-align: right">430</td>
        <td style="text-align: right">317</td>
      </tr>
      <tr>
        <td>推理算式错误</td>
        <td style="text-align: right">2</td>
        <td style="text-align: right">1</td>
      </tr>
    </tbody>
  </table>
</div>
<p>所以 DPO v1 的输出有所缩短，推理算式错误减少，但最终答案正确率没有超过原始模型，数值更新还出现一处回退。</p>
<p>准确结论是：<strong>DPO 的 score / loss 优化链路成立，但当前合成偏好数据与配置没有带来整体行为提升。</strong></p>
<h2 id="三lora-vs-全参数效率明显占优绝对效果并非全面更好">三、LoRA vs 全参数：效率明显占优，绝对效果并非全面更好</h2>
<p>LoRA 使用与非 CoT 全参数 v2 相同的 128 + 32 数据、32 steps、batch=4、peak_lr=1e-5。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">rank = 8
</span></span><span class="line"><span class="cl">alpha = 16
</span></span></code></pre></div><p>核心对照：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>指标</th>
        <th style="text-align: right">全参数 v2</th>
        <th style="text-align: right">LoRA r8 / α16</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>可训练参数</td>
        <td style="text-align: right">全部参数</td>
        <td style="text-align: right"><strong>6,269,952（约 1.05%）</strong></td>
      </tr>
      <tr>
        <td>存档大小</td>
        <td style="text-align: right">2,384,324,167 bytes</td>
        <td style="text-align: right"><strong>25,204,363 bytes</strong></td>
      </tr>
      <tr>
        <td>最终 full val loss</td>
        <td style="text-align: right"><strong>1.021104</strong></td>
        <td style="text-align: right">1.997782</td>
      </tr>
      <tr>
        <td>独立行为验证</td>
        <td style="text-align: right"><strong>30/32</strong></td>
        <td style="text-align: right"><strong>29/32</strong></td>
      </tr>
      <tr>
        <td>名字记忆</td>
        <td style="text-align: right">7/8</td>
        <td style="text-align: right"><strong>8/8</strong></td>
      </tr>
      <tr>
        <td>偏好记忆</td>
        <td style="text-align: right">8/8</td>
        <td style="text-align: right"><strong>8/8</strong></td>
      </tr>
      <tr>
        <td>数值更新</td>
        <td style="text-align: right"><strong>7/8</strong></td>
        <td style="text-align: right">6/8</td>
      </tr>
      <tr>
        <td>单轮算术</td>
        <td style="text-align: right"><strong>8/8</strong></td>
        <td style="text-align: right">7/8</td>
      </tr>
    </tbody>
  </table>
</div>
<p>adapter 约为全参数 checkpoint 的 1/95，行为只少通过一条，名字记忆还少一处回退。</p>
<p>因此：</p>
<ul>
<li>追求当前评测集最高分，全参数 v2 略占优；</li>
<li>追求接近的行为表现与更低的训练、存档成本，LoRA 明显更有性价比；</li>
<li>不能推广成“LoRA 总是更好”或“rank=8 是最佳配置”。</li>
</ul>
<p>LoRA 的 val loss 更高、行为却接近全参数，也再次说明 loss 不能直接替代行为验收。</p>
<h2 id="四rlvr--grpo从可验证奖励到一次组相对更新">四、RLVR + GRPO：从可验证奖励到一次组相对更新</h2>
<h3 id="1-两个概念的位置">1. 两个概念的位置</h3>
<p>RLVR 与 GRPO 不在同一层：</p>
<ul>
<li><strong>RLVR</strong> 决定奖励从哪里来；</li>
<li><strong>GRPO</strong> 决定拿到奖励以后怎样更新模型。</li>
</ul>
<p>GRPO 对同一 Prompt 采样一组回答，用组内平均奖励与标准差构造相对优势，再进行策略优化。RLVR 则可以与 GRPO、PPO 或其他策略优化算法组合，不是 GRPO 的专属组件。</p>
<h4 id="rlvr-的完整含义">RLVR 的完整含义</h4>
<p>RLVR 全称是 <strong>Reinforcement Learning with Verifiable Rewards，可验证奖励的强化学习</strong>。</p>
<p>它的核心不是“奖励数字长什么样”，而是：<strong>回答是否正确，可以由明确、可执行的验证器判断。</strong></p>
<p>例如：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">数学：最终数值是否等于标准答案
</span></span><span class="line"><span class="cl">代码：是否编译通过、单元测试是否通过
</span></span><span class="line"><span class="cl">结构化输出：是否符合指定 JSON Schema
</span></span><span class="line"><span class="cl">对话协议：思考标签是否完整、是否正常结束
</span></span></code></pre></div><p>在本轮算术任务里，验证器不需要人工打分，也不调用 LLM 评委，而是直接解析回答并比较最终数字。</p>
<h4 id="它与-sftdpo传统-rlhf-的区别">它与 SFT、DPO、传统 RLHF 的区别</h4>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>方法</th>
        <th>学习信号</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>SFT</td>
        <td>模仿给定的标准答案</td>
      </tr>
      <tr>
        <td>DPO</td>
        <td>同一 Prompt 下，Chosen 相对 Rejected 更受偏好</td>
      </tr>
      <tr>
        <td>传统 RLHF</td>
        <td>常由人工偏好训练奖励模型，再进行强化学习</td>
      </tr>
      <tr>
        <td>RLVR</td>
        <td>由程序规则、编译器、测试或其他可执行验证器直接给奖励</td>
      </tr>
    </tbody>
  </table>
</div>
<p>因此，RLVR 的优势是奖励口径明确、可重复执行，特别适合数学、代码和结构化输出任务。它并不要求先构造 chosen / rejected 偏好对，而是可以在采样后对当前模型的回答直接验收。</p>
<h4 id="为什么本轮需要分层奖励">为什么本轮需要分层奖励</h4>
<p>第一版只使用二值奖励：完整 CoT、答案正确、纯数字格式同时满足才给 1，否则全部为 0。</p>
<p>实际采样中出现了：</p>
<ul>
<li>有些回答已经算出正确数值，但最终写成了完整算式，而不是纯数字；</li>
<li>有些回答不断自我怀疑，直到长度上限也没有结束。</li>
</ul>
<p>如果全部给 0，验证器就无法区分“完整但格式不完美”和“根本没有答完”，组内也没有学习差异。</p>
<p>因此本轮使用 shaped reward v2：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">1.0：完整 CoT + 数值正确 + 纯数字答案
</span></span><span class="line"><span class="cl">0.7：完整 CoT + 数值正确，但最终格式不完美
</span></span><span class="line"><span class="cl">0.1：完整 CoT，但答案错误
</span></span><span class="line"><span class="cl">0.0：结构不完整、截断或无法验收
</span></span></code></pre></div><p>这个设计不是降低正确答案标准：纯数字且正确的回答仍然获得最高奖励。部分奖励只是为了让模型先学习“完成一个可验证的回答”，再逐步改善格式与正确性。</p>
<h4 id="rlvr-的边界与风险">RLVR 的边界与风险</h4>
<p>可验证不等于所有重要质量都能被验证：</p>
<ul>
<li>数学最终答案正确，不代表中间推理一定正确；</li>
<li>代码通过部分测试，不代表没有隐藏缺陷；</li>
<li>JSON 可以解析，不代表字段语义符合业务意图；</li>
<li>结构完整，不代表回答自然、简洁或没有无关内容。</li>
</ul>
<p>奖励设计还可能产生 reward hacking：模型可能学会迎合验证器，而不是真正改善任务能力。例如只输出高频正确答案、牺牲推理过程，或利用验证器没有覆盖的格式漏洞。</p>
<p>因此 RLVR 实验必须同时保留：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">验证器本身的正确性测试
</span></span><span class="line"><span class="cl">奖励组成与版本记录
</span></span><span class="line"><span class="cl">独立行为评测
</span></span><span class="line"><span class="cl">对推理过程和最终答案的分别检查
</span></span><span class="line"><span class="cl">对 reward hacking 与意外行为的观察
</span></span></code></pre></div><p>本轮的 shaped reward v2 只适用于当前受控算术实验，不能当成通用奖励设计，也不能与之前二值奖励的结果混为同一口径。</p>
<h3 id="2-实际样本组与优势">2. 实际样本组与优势</h3>
<p>从 CoT-SFT v2 采样得到：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">rewards    = [0.7, 0.0, 0.0, 0.7]
</span></span><span class="line"><span class="cl">advantages = [1.0, -1.0, -1.0, 1.0]
</span></span><span class="line"><span class="cl">mean reward = 0.35
</span></span><span class="line"><span class="cl">std reward = 0.35
</span></span><span class="line"><span class="cl">has_learning_signal = true
</span></span></code></pre></div><p>两条完整但格式不完美的回答获得正优势，两条截断回答获得负优势。</p>
<h3 id="3-最小序列级-grpo-更新">3. 最小序列级 GRPO 更新</h3>
<p>配置：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">group_size = 4
</span></span><span class="line"><span class="cl">optimization_steps = 1
</span></span><span class="line"><span class="cl">epsilon = 0.2
</span></span><span class="line"><span class="cl">learning_rate = 1e-7
</span></span><span class="line"><span class="cl">grad clip = 1.0
</span></span><span class="line"><span class="cl">reference KL = 未加入
</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">before loss = 0
</span></span><span class="line"><span class="cl">before mean ratio = 1.0
</span></span><span class="line"><span class="cl">after loss = -0.20000002
</span></span><span class="line"><span class="cl">after mean ratio = 3.06
</span></span><span class="line"><span class="cl">grad norm before clip = 2379.9329
</span></span><span class="line"><span class="cl">checkpoint reload = passed
</span></span></code></pre></div><p>逐响应 ratio：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">正优势：9.248458、2.639478
</span></span><span class="line"><span class="cl">负优势：0.224003、0.128063
</span></span></code></pre></div><p>方向符合预期，但多个 ratio 已超出 <code>[0.8, 1.2]</code>，说明更新仍然激进，不能把 loss 和 ratio 变化直接当成稳定训练的证据。</p>
<h3 id="4-更新后的行为回归">4. 更新后的行为回归</h3>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>指标</th>
        <th style="text-align: right">CoT-SFT v2</th>
        <th style="text-align: right">GRPO 单组更新</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>最终答案正确</td>
        <td style="text-align: right">29/32</td>
        <td style="text-align: right"><strong>30/32</strong></td>
      </tr>
      <tr>
        <td>完整 CoT</td>
        <td style="text-align: right">32/32</td>
        <td style="text-align: right"><strong>32/32</strong></td>
      </tr>
      <tr>
        <td>数值更新</td>
        <td style="text-align: right">16/16</td>
        <td style="text-align: right"><strong>16/16</strong></td>
      </tr>
      <tr>
        <td>单轮算术</td>
        <td style="text-align: right">13/16</td>
        <td style="text-align: right"><strong>14/16</strong></td>
      </tr>
      <tr>
        <td>自然结束</td>
        <td style="text-align: right">32/32</td>
        <td style="text-align: right"><strong>32/32</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<p>本次更新没有造成即时行为崩溃，最终正确率与原始模型持平。但它只有一组、一次更新，且未加入参考模型 KL，不能据此宣称 GRPO 已稳定提升模型。</p>
<h2 id="五同一-cot-评测集上的最终对照">五、同一 CoT 评测集上的最终对照</h2>
<p>以下结果均来自同一 32 条 CoT 样本，不跨数据集比较通过率：</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">完整 CoT</th>
        <th style="text-align: right">综合通过</th>
        <th style="text-align: right">平均 tokens</th>
        <th style="text-align: right">中位 tokens</th>
        <th style="text-align: right">最大 tokens</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>原始模型</td>
        <td style="text-align: right"><strong>30</strong></td>
        <td style="text-align: right">32</td>
        <td style="text-align: right"><strong>30</strong></td>
        <td style="text-align: right">163.1</td>
        <td style="text-align: right">146</td>
        <td style="text-align: right">430</td>
      </tr>
      <tr>
        <td>CoT-SFT v2</td>
        <td style="text-align: right">29</td>
        <td style="text-align: right">32</td>
        <td style="text-align: right">29</td>
        <td style="text-align: right"><strong>139.4</strong></td>
        <td style="text-align: right"><strong>120</strong></td>
        <td style="text-align: right"><strong>278</strong></td>
      </tr>
      <tr>
        <td>DPO v1</td>
        <td style="text-align: right">29</td>
        <td style="text-align: right">32</td>
        <td style="text-align: right">29</td>
        <td style="text-align: right">153.2</td>
        <td style="text-align: right">134.5</td>
        <td style="text-align: right">317</td>
      </tr>
      <tr>
        <td>GRPO 单组更新</td>
        <td style="text-align: right"><strong>30</strong></td>
        <td style="text-align: right">32</td>
        <td style="text-align: right"><strong>30</strong></td>
        <td style="text-align: right">141.7</td>
        <td style="text-align: right"><strong>120</strong></td>
        <td style="text-align: right">376</td>
      </tr>
    </tbody>
  </table>
</div>
<p>可以看到不同方法优化的是不同侧面：</p>
<ul>
<li>原始模型最终正确率最高，但输出偏长；</li>
<li>CoT-SFT v2 最短，但正确率没有超过原始模型；</li>
<li>DPO 有适度缩短，整体正确率仍未提升；</li>
<li>GRPO 本次恢复到 30/32，但实验规模不足以证明稳定收益。</li>
</ul>
<h2 id="六同题规则-win--tie--loss">六、同题规则 win / tie / loss</h2>
<p>为避免只比较总通过率，又按同一题的 <code>passed</code> 做了规则评委对照：</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">左侧负</th>
        <th style="text-align: right">平局</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>原始 vs CoT-SFT</td>
        <td style="text-align: right">2</td>
        <td style="text-align: right">1</td>
        <td style="text-align: right">29</td>
      </tr>
      <tr>
        <td>原始 vs DPO</td>
        <td style="text-align: right">1</td>
        <td style="text-align: right">0</td>
        <td style="text-align: right">31</td>
      </tr>
      <tr>
        <td>原始 vs GRPO</td>
        <td style="text-align: right">1</td>
        <td style="text-align: right">1</td>
        <td style="text-align: right">30</td>
      </tr>
      <tr>
        <td>CoT-SFT vs DPO</td>
        <td style="text-align: right">2</td>
        <td style="text-align: right">2</td>
        <td style="text-align: right">28</td>
      </tr>
      <tr>
        <td>CoT-SFT vs GRPO</td>
        <td style="text-align: right">0</td>
        <td style="text-align: right">1</td>
        <td style="text-align: right">31</td>
      </tr>
      <tr>
        <td>DPO vs GRPO</td>
        <td style="text-align: right">1</td>
        <td style="text-align: right">2</td>
        <td style="text-align: right">29</td>
      </tr>
    </tbody>
  </table>
</div>
<p>报告同时记录：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">win_rate_all = wins / 全部题目数
</span></span><span class="line"><span class="cl">decisive_win_rate = wins / (wins + losses)
</span></span></code></pre></div><p>这些只是当前 32 条样本上的规则评委胜率，不是经过 I5 校准的 LLM 评委结果，也不能扩大为通用模型排名。</p>
<h2 id="七真实-web-ui-多轮回归">七、真实 Web UI 多轮回归</h2>
<p>最后给 <code>chat_server.py</code> 增加 <code>LVCHAT_CHECKPOINT</code>，在真实页面加载训练后的模型，关闭 thinking，连续输入：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">第一轮：我叫小吕。
</span></span><span class="line"><span class="cl">第二轮：那我叫什么？
</span></span></code></pre></div><h3 id="1-非-cot-sft-v2">1. 非 CoT SFT v2</h3>
<p>页面结果为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">第一轮 Assistant：你叫小吕。
</span></span><span class="line"><span class="cl">第二轮 Assistant：你叫小吕。
</span></span></code></pre></div><p>第二轮包含正确名字，但两轮 Assistant 完全同文。多轮记忆内容正确，<strong>非同文复制验收未通过</strong>。</p>
<h3 id="2-grpo-单组更新-checkpoint">2. GRPO 单组更新 checkpoint</h3>
<p>页面结果为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">第一轮 Assistant：你好，小吕！我是你的助手，有什么可以帮助你的吗？
</span></span><span class="line"><span class="cl">第二轮 Assistant：我叫小吕，很高兴认识你！有什么我可以帮你的吗？
</span></span></code></pre></div><p>这次第二轮包含正确名字，且没有复制第一轮，TURN=02、SSE 状态正常。按预先设定的“历史信息正确 + 非精确复制”两项标准，可以记为通过。</p>
<p>但第二轮使用“我叫小吕”，存在说话视角混淆，表达自然性仍需改进。</p>
<p>因此当前 Web UI 结论是：</p>
<ul>
<li>非 CoT SFT v2 暴露了同文复制；</li>
<li>GRPO checkpoint 提供了一条记忆正确、非精确复制的可用路径；</li>
<li>多轮表达质量并未完美；</li>
<li>本次验收针对当前 V4 / Qwen3 Web UI，<strong>不代表 M6 的旧 355M 模型已重新测试和修复</strong>。</li>
</ul>
<h2 id="八相关回归">八、相关回归</h2>
<p>实际运行：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">tests/test_chat_sft.py
</span></span><span class="line"><span class="cl">tests/test_i4_behavior_baseline.py
</span></span><span class="line"><span class="cl">tests/test_chat_session.py
</span></span><span class="line"><span class="cl">tests/test_qwen3
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">30 passed in 1.81s
</span></span></code></pre></div><p>此外，DPO 偏好数据审计、CoT 数据审计、checkpoint / adapter reload、DPO 训练、LoRA 训练和 GRPO 更新均由真实命令执行。</p>
<h2 id="九i4-最终结论">九、I4 最终结论</h2>
<h3 id="1-sft-很容易学会形式但可能重新分配甚至破坏能力">1. SFT 很容易学会形式，但可能重新分配甚至破坏能力</h3>
<p>格式、模板和局部行为可以快速改变；最终答案、旧能力和开放域表现不一定同步改善。</p>
<h3 id="2-数据质量与-eval-必须同时设计">2. 数据质量与 eval 必须同时设计</h3>
<p>数据质量决定能学到什么，eval 决定能否看见收益、退化和未被直接训练的行为。只强调任何一个都会出问题。</p>
<h3 id="3-loss-只是训练目标的代理指标">3. loss 只是训练目标的代理指标</h3>
<p>SFT、DPO、GRPO 中都出现了 loss 或 score 改善，但行为没有同步提升的情况。必须保留独立行为基线与能力保持集。</p>
<h3 id="4-不同方法的价值不能只用一个分数判断">4. 不同方法的价值不能只用一个分数判断</h3>
<ul>
<li>CoT-SFT v2 输出更短；</li>
<li>DPO 学到了偏好差值并适度缩短输出；</li>
<li>LoRA 用约 1% 参数取得接近全参数的行为；</li>
<li>GRPO 完成了可验证奖励驱动的最小更新；</li>
<li>原始模型在最终答案正确率上仍很强。</li>
</ul>
<p>这不是一个“谁彻底打败谁”的故事，而是不同目标、成本和副作用之间的取舍。</p>
<h2 id="十i4-停止边界与-i5-衔接">十、I4 停止边界与 I5 衔接</h2>
<p>I4 可以按学习里程碑收官，但必须保留：</p>
<ul>
<li>所有实验都基于小模型与受控合成数据；</li>
<li>DPO 偏好数据不是人工标注；</li>
<li>GRPO 只有一组、一次更新，未加入参考 KL；</li>
<li>LoRA 只测试 rank=8、alpha=16 和当前固定配置；</li>
<li>Web UI 多轮表达仍存在视角混淆；</li>
<li>M6 旧 355M 模型未重新回归；</li>
<li>规则胜率不是校准后的 LLM 评委胜率。</li>
</ul>
<p>下一阶段 I5 将处理评估校准、位置与长度偏见、多评委一致性和自动化回归门禁。I4 已经证明：<strong>没有可信 eval，就无法判断后训练到底是在提升，还是在更隐蔽地破坏。</strong></p>
<h2 id="附留给未来回顾的独立复现任务非里程碑">附：留给未来回顾的独立复现任务（非里程碑）</h2>
<p>I4 的实验主干已经收官，但这不等于我已经熟练掌握后训练。</p>
<p>当前更真实的状态是：我建立了 SFT、CoT-SFT、DPO、LoRA、RLVR / GRPO 的基本概念坐标，亲手跑过训练、生成与评估链路，也看到了 loss、优化目标和真实行为之间的差异。但 I4 的大部分实现代码由 Kimi 提供，我主要通过复制、阅读、运行、排障和实验分析参与，独立实现能力尚未被充分验证。</p>
<p>复制代码本身不等于没有学习。基线设计、指标修正、失败样例分析、训练干预和回退定位都是真实参与，但它们不能替代独立实现能力。因此留下以下回顾任务，供未来检查自己是否真正留下了可以独立重建的主干。</p>
<p>这些任务：</p>
<ul>
<li>不属于新的里程碑；</li>
<li>不改变 I4 已收官的状态；</li>
<li>不阻塞 I5；</li>
<li>不要求重新手敲整个 I4；</li>
<li>可以在后续任何阶段按需要回顾。</li>
</ul>
<h3 id="1-多轮-sft-掩码独立复现">1. 多轮 SFT 掩码独立复现</h3>
<ul>
<li><input disabled="" type="checkbox"> 不看现有实现，写出 inputs / targets 的错位关系；</li>
<li><input disabled="" type="checkbox"> 独立实现 Assistant-only mask，保留每轮 Assistant 正文与结束标记；</li>
<li><input disabled="" type="checkbox"> 解释为什么 User 不参与 loss，却仍然可以作为上下文影响回答；</li>
<li><input disabled="" type="checkbox"> 跑通现有多轮 Dataset 与 Batch padding 测试；</li>
<li><input disabled="" type="checkbox"> 说明 Full 区间与 target 下标为什么相差一位。</li>
</ul>
<h3 id="2-dpo-核心计算独立复现">2. DPO 核心计算独立复现</h3>
<ul>
<li><input disabled="" type="checkbox"> 独立实现 Assistant 输出的 sequence logprob；</li>
<li><input disabled="" type="checkbox"> 分别计算 policy / reference 对 Chosen 与 Rejected 的 logprob；</li>
<li><input disabled="" type="checkbox"> 写出 score，并确认顺序是“训练后偏好差 − 训练前偏好差”；</li>
<li><input disabled="" type="checkbox"> 写出 DPO loss，并验证初始 policy = reference 时 loss 为 ln 2；</li>
<li><input disabled="" type="checkbox"> 能解释 score 增大究竟来自 Chosen 提高、Rejected 降低，还是两者同时发生。</li>
</ul>
<h3 id="3-lora-旁路独立复现">3. LoRA 旁路独立复现</h3>
<ul>
<li><input disabled="" type="checkbox"> 独立写出 A / B 两个低秩矩阵及前向计算；</li>
<li><input disabled="" type="checkbox"> 解释 rank 如何限制更新容量，alpha / rank 如何缩放旁路输出；</li>
<li><input disabled="" type="checkbox"> 验证 B 零初始化时，加入 LoRA 前后的模型输出保持一致；</li>
<li><input disabled="" type="checkbox"> 计算一个具体 Linear 层的原参数量、LoRA 参数量与节省比例；</li>
<li><input disabled="" type="checkbox"> 说明为什么 LoRA 参数效率高，不代表所有行为指标都更好。</li>
</ul>
<h3 id="4-rlvr--grpo-最小机制独立复现">4. RLVR / GRPO 最小机制独立复现</h3>
<ul>
<li><input disabled="" type="checkbox"> 为一个算术任务写出可执行验证器与奖励函数；</li>
<li><input disabled="" type="checkbox"> 对同一 Prompt 的一组回答计算组内均值、标准差与 advantage；</li>
<li><input disabled="" type="checkbox"> 解释组内全对、全错或全部无效时为什么缺乏学习信号；</li>
<li><input disabled="" type="checkbox"> 写出带 epsilon 裁剪的 ratio objective；</li>
<li><input disabled="" type="checkbox"> 能判断正负 advantage 分别希望提高还是降低对应回答的生成倾向。</li>
</ul>
<h3 id="5-回顾时的统一验收方式">5. 回顾时的统一验收方式</h3>
<p>每个小主干都尽量做到：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">能手写一个最小版本
</span></span><span class="line"><span class="cl">能解释关键张量形状与符号方向
</span></span><span class="line"><span class="cl">能跑通已有测试或最小探针
</span></span><span class="line"><span class="cl">能说明故意改错一处会出现什么现象
</span></span></code></pre></div><p>目标不是把代码背得一字不差，而是脱离现成实现后，仍然能恢复核心计算链路，并用实验证明自己的理解。</p>
<p>在完成这些回顾之前，对 I4 的准确表述仍然是：<strong>实验里程碑已完成，概念与工程闭环初步建立，独立实现熟练度仍需后续验证。</strong> 这不是欠下一条新的主线，而是给未来的自己留下一张复习清单。</p>
<h2 id="主要实验产物">主要实验产物</h2>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">data/reports/i4-dpo-v1-training.json
</span></span><span class="line"><span class="cl">data/reports/i4-dpo-v1-cot-behavior.json
</span></span><span class="line"><span class="cl">data/reports/i4-lora-sft-r8a16-training.json
</span></span><span class="line"><span class="cl">data/reports/i4-lora-sft-r8a16-synthetic-val.json
</span></span><span class="line"><span class="cl">data/reports/i4-grpo-sampled-group.json
</span></span><span class="line"><span class="cl">data/reports/i4-grpo-one-update.json
</span></span><span class="line"><span class="cl">data/reports/i4-grpo-one-group-cot-behavior.json
</span></span><span class="line"><span class="cl">data/reports/i4-final-comparison.json
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">data/model_pth/qwen3/i4-dpo-v1.pth
</span></span><span class="line"><span class="cl">data/model_pth/qwen3/i4-lora-sft-r8a16.pth
</span></span><span class="line"><span class="cl">data/model_pth/qwen3/i4-grpo-one-group.pth
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">scripts/i4_dpo_train.py
</span></span><span class="line"><span class="cl">scripts/i4_lora_sft_train.py
</span></span><span class="line"><span class="cl">scripts/i4_grpo_group_probe.py
</span></span><span class="line"><span class="cl">scripts/i4_grpo_sample.py
</span></span><span class="line"><span class="cl">scripts/i4_grpo_one_update.py
</span></span><span class="line"><span class="cl">scripts/i4_final_comparison.py
</span></span><span class="line"><span class="cl">scripts/chat_server.py
</span></span></code></pre></div>]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 25：I4 DPO 偏好优化</title>
      <link>https://blog.lvxinrong.com/llm/llm-25-i4-dpo-preference/</link>
      <pubDate>Mon, 16 Nov 2026 15:00:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-25-i4-dpo-preference/</guid>
      <description>DPO 起步实录：理解 chosen / rejected、序列 logprob、参考模型、score 与 loss，完成偏好数据、模板编码审计和单步更新。记录梯度裁剪对 Adam 整体缩放不敏感，以及 LR=1e-7 的温和更新；批量 DPO 训练尚未开始。</description>
      <content:encoded><![CDATA[<p>今天先停在 <strong>DPO 小批量训练之前</strong>。</p>
<p>这一阶段没有把 DPO 当成一个需要马上跑通的训练脚本，而是先拆开它最基本的概念和计算链路：什么是 chosen / rejected，怎样计算一段输出的 logprob，参考模型起什么作用，score 和 loss 如何产生，以及一次真实更新为什么会过于激进。</p>
<p>当前状态是：<strong>DPO 概念、偏好数据、模板编码和单步验证已完成；批量训练、checkpoint 和训练后的行为评估尚未开始。</strong></p>
<h2 id="一sft-与-dpo模仿答案还是学习偏好">一、SFT 与 DPO：模仿答案，还是学习偏好</h2>
<p>SFT 的目标比较直接：给模型一个标准回答，让它学习怎样生成。</p>
<p>DPO（Direct Preference Optimization）关注的是同一个 Prompt 下两个回答的相对关系：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Chosen：希望模型更倾向的回答
</span></span><span class="line"><span class="cl">Rejected：希望模型少倾向的回答
</span></span></code></pre></div><p>Rejected 不一定是绝对错误，也可能只是没有 Chosen 好。例如两个答案都正确，但一个简洁、一个啰嗦。DPO 不是给所有场景规定两个绝对方向，而是学习<strong>同一个 Prompt 下的相对偏好</strong>。</p>
<p>本轮的起点和参考模型都使用原始 Qwen3-0.6B Instruct。这样可以从原生 CoT 能力出发，研究“简短、正确、结构完整”的回答偏好，而不是先修复上一轮 SFT 造成的行为退化。</p>
<h2 id="二偏好数据长什么样">二、偏好数据长什么样</h2>
<p>第一版偏好探针使用：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-json" data-lang="json"><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;messages&#34;</span><span class="p">:</span> <span class="p">[</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span><span class="nt">&#34;role&#34;</span><span class="p">:</span> <span class="s2">&#34;system&#34;</span><span class="p">,</span> <span class="nt">&#34;content&#34;</span><span class="p">:</span> <span class="s2">&#34;你是一个乐于助人的 AI 助手。&#34;</span><span class="p">},</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span><span class="nt">&#34;role&#34;</span><span class="p">:</span> <span class="s2">&#34;user&#34;</span><span class="p">,</span> <span class="nt">&#34;content&#34;</span><span class="p">:</span> <span class="s2">&#34;37 × 6 等于多少？请简短推理并给出最终数字。&#34;</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="nt">&#34;chosen&#34;</span><span class="p">:</span> <span class="s2">&#34;&lt;think&gt;\n30 × 6 = 180，7 × 6 = 42。\n180 + 42 = 222。\n&lt;/think&gt;\n\n222&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;rejected&#34;</span><span class="p">:</span> <span class="s2">&#34;&lt;think&gt;\n让我先想一下……&lt;/think&gt;\n\n226&#34;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p><code>messages</code> 负责提供上下文，chosen / rejected 是候选 Assistant 输出。计算序列概率时，只累计候选输出中目标 token 的 logprob，不把 Prompt 当作需要生成的答案。</p>
<h2 id="三序列-logprob模型怎样给一段回答打分">三、序列 logprob：模型怎样给一段回答打分</h2>
<p>对一段 Assistant 输出：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">log p(token₁, token₂, ..., tokenₙ)
</span></span><span class="line"><span class="cl">= 每个目标 token 的 log 概率之和
</span></span></code></pre></div><p>logprob 越接近 0，模型分配的序列概率越高；越负，概率越低。长回答通常也会累积更大的负值，因此不能只凭总 logprob 判断回答质量。</p>
<p>本轮原始探针得到：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>输出</th>
        <th style="text-align: right">序列 logprob</th>
        <th style="text-align: right">Token 数</th>
        <th style="text-align: right">平均每 token logprob</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>Chosen</td>
        <td style="text-align: right">-46.830143</td>
        <td style="text-align: right">41</td>
        <td style="text-align: right">-1.142199</td>
      </tr>
      <tr>
        <td>Rejected</td>
        <td style="text-align: right">-152.992218</td>
        <td style="text-align: right">74</td>
        <td style="text-align: right">-2.067462</td>
      </tr>
    </tbody>
  </table>
</div>
<p>差值为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">-46.830143 - (-152.992218) = +106.162075
</span></span></code></pre></div><p>这表示原始模型给 Chosen 的序列概率更高，不是“好 106%”。同时，这个探针里原始模型本来就很偏好 Chosen，因此它适合演示计算，但未必能提供很强的训练信号。</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="k">with</span> <span class="n">torch</span><span class="o">.</span><span class="n">set_grad_enabled</span><span class="p">(</span><span class="n">require_grad</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">logits</span> <span class="o">=</span> <span class="n">model</span><span class="p">(</span><span class="n">inputs</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="n">log_probs</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">log_softmax</span><span class="p">(</span><span class="n">logits</span><span class="p">,</span> <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">token_logprobs</span> <span class="o">=</span> <span class="n">log_probs</span><span class="o">.</span><span class="n">gather</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="o">-</span><span class="mi">1</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="n">safe_targets</span><span class="o">.</span><span class="n">unsqueeze</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">),</span>
</span></span><span class="line"><span class="cl">    <span class="p">)</span><span class="o">.</span><span class="n">squeeze</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="n">mask</span> <span class="o">=</span> <span class="n">targets</span> <span class="o">!=</span> <span class="o">-</span><span class="mi">100</span>
</span></span><span class="line"><span class="cl">    <span class="n">total</span> <span class="o">=</span> <span class="p">(</span><span class="n">token_logprobs</span> <span class="o">*</span> <span class="n">mask</span><span class="p">)</span><span class="o">.</span><span class="n">sum</span><span class="p">()</span>
</span></span></code></pre></div><p><code>targets</code> 必须和 <code>inputs</code> 一样保留 Batch 维度，否则 gather 时会出现维度错误。</p>
<h2 id="四参考模型与-dpo-loss">四、参考模型与 DPO loss</h2>
<p>DPO 真正优化的不是简单的 <code>chosen - rejected</code>，而是当前模型相对参考模型的偏好变化：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">score =
</span></span><span class="line"><span class="cl">  (policy_chosen_logprob - reference_chosen_logprob)
</span></span><span class="line"><span class="cl">  -
</span></span><span class="line"><span class="cl">  (policy_rejected_logprob - reference_rejected_logprob)
</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">loss = -log sigmoid(β × score)
</span></span></code></pre></div><p>训练刚开始时，policy 和 reference 使用同一份权重：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">score = 0
</span></span><span class="line"><span class="cl">loss = -log sigmoid(0) = ln 2 ≈ 0.693147
</span></span></code></pre></div><p>本轮 <code>beta=0.1</code> 时，探针实际得到：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-json" data-lang="json"><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;score&#34;</span><span class="p">:</span> <span class="mf">0.0</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;loss&#34;</span><span class="p">:</span> <span class="mf">0.6931471824645996</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>这验证了 DPO 初始计算链路。参考模型的作用是提供一个锚点，避免只追求偏好差值而把模型推得太远。</p>
<h3 id="指标复盘我的理解与需要保留的边界">指标复盘：我的理解与需要保留的边界</h3>
<p>在真正开始批量训练前，我又把 DPO 中几个容易混淆的指标从头过了一遍。这里同时记录最初的直觉和修正后的理解，避免只保留最后一句定义。</p>
<h4 id="1-token-概率不是-logitssequence_logprob-也不是字符串距离">1. token 概率不是 logits，sequence_logprob 也不是字符串距离</h4>
<p>模型在每个位置先返回整个词表的 logits。它们是原始打分，有正有负，也不要求总和为 1：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">logits
</span></span><span class="line"><span class="cl">→ softmax：整个词表的概率分布
</span></span><span class="line"><span class="cl">→ log：整个词表的 log 概率分布
</span></span><span class="line"><span class="cl">→ gather：取目标 token 对应的 logprob
</span></span></code></pre></div><p>如果目标序列是 <code>a b c</code>，序列概率不是三个独立概率的乘积，而是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">p(a | prompt)
</span></span><span class="line"><span class="cl">× p(b | prompt, a)
</span></span><span class="line"><span class="cl">× p(c | prompt, a, b)
</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">log p(a,b,c)
</span></span><span class="line"><span class="cl">= ln p(a | prompt)
</span></span><span class="line"><span class="cl">+ ln p(b | prompt, a)
</span></span><span class="line"><span class="cl">+ ln p(c | prompt, a, b)
</span></span></code></pre></div><p>我一开始把 sequence_logprob 理解成“生成序列与目标序列的距离”，认为越接近 0 就越接近正确答案。这个理解需要修正：</p>
<blockquote>
<p><strong>sequence_logprob 是模型给目标序列分配的条件概率的 log 值，不是编辑距离，也不是正确率。</strong></p>
</blockquote>
<p>越接近 0，说明模型越倾向于生成这条目标序列。如果目标本身是错误答案，模型也可能非常自信地错误。只有目标确实是正确回答时，才能进一步解释为对正确答案的倾向增强。</p>
<p><code>mean_logprob_per_token</code> 只是长度归一化后的观察指标，不是 DPO 的优化目标。</p>
<h4 id="2-chosen_minus_rejected-是当前模型的原始偏好差">2. chosen_minus_rejected 是当前模型的原始偏好差</h4>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">chosen_minus_rejected
</span></span><span class="line"><span class="cl">= sequence_logprob(chosen) - sequence_logprob(rejected)
</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">log [p(chosen) / p(rejected)]
</span></span></code></pre></div><p>我的理解是：</p>
<ul>
<li>大于 0：当前模型更倾向 Chosen；</li>
<li>小于 0：当前模型更倾向 Rejected；</li>
<li>等于 0：两者的序列概率相同；</li>
<li>差值的绝对值越大，说明当前模型对两者的概率倾向差异越大。</li>
</ul>
<p>但它仍然不是质量分：一方面它不代表哪个回答客观上更正确，另一方面序列 logprob 会受回答长度影响，不能把它当成跨样本公平比较的指标。</p>
<h4 id="3-score-是两个模型的偏好差之差">3. score 是两个模型的偏好差之差</h4>
<p>设 A 为训练前的参考模型，B 为训练后的 policy：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">policy_chosen = B 给 Chosen 的 sequence_logprob
</span></span><span class="line"><span class="cl">policy_rejected = B 给 Rejected 的 sequence_logprob
</span></span><span class="line"><span class="cl">reference_chosen = A 给 Chosen 的 sequence_logprob
</span></span><span class="line"><span class="cl">reference_rejected = A 给 Rejected 的 sequence_logprob
</span></span></code></pre></div><p><code>policy_chosen</code> 不是 chosen_minus_rejected，而是单独对 Chosen 的序列 logprob 计算。</p>
<p>先分别计算两个模型的原始偏好差：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">diff_A = A_chosen - A_rejected
</span></span><span class="line"><span class="cl">diff_B = B_chosen - B_rejected
</span></span></code></pre></div><p>DPO 的 score 是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">score = diff_B - diff_A
</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">(B_chosen - A_chosen)
</span></span><span class="line"><span class="cl">-
</span></span><span class="line"><span class="cl">(B_rejected - A_rejected)
</span></span></code></pre></div><p>我最初写成了 <code>diff_A - diff_B</code>，虽然“拆开比较两个模型”的思路是对的，但顺序反了，整个符号也会相反。正确方向是<strong>训练后减训练前</strong>。</p>
<p><code>score &gt; 0</code> 表示训练后模型对 Chosen 相对于 Rejected 的偏好优势增强了；<code>score &lt; 0</code> 表示这个相对优势减弱了。</p>
<p>但 score 仍不是整体能力分：</p>
<ul>
<li>它不能说明最终答案一定更正确；</li>
<li>它不能说明 CoT 格式一定更好；</li>
<li>它不能说明其他能力没有被破坏；</li>
<li>它也不能单独区分是 Chosen 提高、Rejected 降低，还是两者同时变化。</li>
</ul>
<p>所以必须继续查看两个候选各自的 logprob 分量。</p>
<h4 id="4-loss-是偏好关系的-logistic-loss">4. loss 是偏好关系的 logistic loss</h4>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">loss = -log sigmoid(β × score)
</span></span></code></pre></div><p>在 β 固定时，score 增大，loss 降低；score 减小，loss 升高。</p>
<p>它与 SFT 的 token 级交叉熵不同，优化的是偏好关系。loss 下降说明偏好优化方向符合目标，不代表模型整体能力一定提升。</p>
<h4 id="5-β-是偏好压力旋钮不是学习率或百分比">5. β 是偏好压力旋钮，不是学习率或百分比</h4>
<p>我暂时把 β 理解为偏好压力旋钮：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">β 较小：偏好压力通常更温和
</span></span><span class="line"><span class="cl">β 较大：偏好压力通常更强
</span></span></code></pre></div><p>但 β 不是“采用多少比例的更新”，也不是直接乘在参数更新上的 LR。它先把 score 缩放，再进入 sigmoid，影响 loss 的非线性变化和偏好约束强度。</p>
<p>实际更新幅度由 β、score、LR、优化器和梯度裁剪共同决定。</p>
<h4 id="6-grad-norm-是梯度向量长度不是平均梯度">6. grad norm 是梯度向量长度，不是平均梯度</h4>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">grad norm = sqrt(所有梯度值的平方和)
</span></span></code></pre></div><p>它通常是一次反向传播后，所有可训练参数梯度拼成的长向量的 L2 范数，用来观察整体梯度规模。</p>
<p>流程是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">loss.backward()
</span></span><span class="line"><span class="cl">→ 计算 grad norm
</span></span><span class="line"><span class="cl">→ 可选：梯度裁剪
</span></span><span class="line"><span class="cl">→ optimizer.step()
</span></span></code></pre></div><p>因此要把几个概念分开：</p>
<ul>
<li>loss：优化目标；</li>
<li>β：偏好压力；</li>
<li>grad norm：梯度规模；</li>
<li>LR：实际更新步长；</li>
<li>optimizer：决定梯度如何转换为参数更新。</li>
</ul>
<p>昨天的实验还说明，整体裁剪梯度不一定能显著改变 Adam 的单步更新；直接降低 LR 才真正缩小了 score 和 logprob 的变化幅度。</p>
<h4 id="7-现在对整组指标的理解">7. 现在对整组指标的理解</h4>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">sequence_logprob：模型给某段输出的序列概率
</span></span><span class="line"><span class="cl">chosen_minus_rejected：当前模型对两个候选的原始偏好差
</span></span><span class="line"><span class="cl">score：当前模型相对参考模型的偏好变化
</span></span><span class="line"><span class="cl">loss：把 score 转成可优化目标
</span></span><span class="line"><span class="cl">β：偏好压力旋钮
</span></span><span class="line"><span class="cl">grad norm：反向传播得到的整体梯度规模
</span></span></code></pre></div><p>这些指标都不能单独回答“模型能力是否提升”。最后仍要回到 answer_correct、CoT 格式、输出长度、自然结束和旧能力保持。</p>
<h2 id="五一次真实单步更新loss-下降不等于能力提升">五、一次真实单步更新：loss 下降不等于能力提升</h2>
<p>使用冻结的参考模型和可训练的 policy，执行一次真实的 <code>loss.backward()</code> 与 <code>optimizer.step()</code>。</p>
<p>在 <code>peak_lr=1e-6</code> 时：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">before score = 0
</span></span><span class="line"><span class="cl">before loss = 0.693147
</span></span><span class="line"><span class="cl">grad norm = 268.085846
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">after score = 35.349922
</span></span><span class="line"><span class="cl">after loss = 0.028742
</span></span></code></pre></div><p>更新前后两个候选的序列 logprob 为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Chosen：  -46.830143 → -44.240398
</span></span><span class="line"><span class="cl">Rejected：-152.992218 → -185.752396
</span></span></code></pre></div><p>这意味着：</p>
<ul>
<li>Chosen 提高了约 2.59；</li>
<li>Rejected 被压低约 32.76；</li>
<li>score 的大幅提升主要来自 Rejected 被压低，而不是 Chosen 变好了多少。</li>
</ul>
<p>因此，<strong>DPO loss 下降不自动等于模型能力提升</strong>。如果更新过猛，仍可能破坏其他正常输出。</p>
<h2 id="六梯度裁剪生效为什么输出却几乎不变">六、梯度裁剪生效，为什么输出却几乎不变</h2>
<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">torch</span><span class="o">.</span><span class="n">nn</span><span class="o">.</span><span class="n">utils</span><span class="o">.</span><span class="n">clip_grad_norm_</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">policy_model</span><span class="o">.</span><span class="n">parameters</span><span class="p">(),</span>
</span></span><span class="line"><span class="cl">    <span class="n">max_norm</span><span class="o">=</span><span class="mf">1.0</span><span class="p">,</span>
</span></span><span class="line"><span class="cl"><span class="p">)</span>
</span></span></code></pre></div><p>裁剪后实际梯度范数为 1，但 score 和 logprob 几乎不变。</p>
<p>原因是梯度裁剪对所有梯度做同比例缩放，而 Adam 的更新会进行一阶、二阶动量归一化。整体缩放后，方向与归一化结果可能非常接近，尤其在单步、无 weight decay 的情况下。</p>
<p>所以这次得到的工程结论是：</p>
<blockquote>
<p><strong>梯度裁剪可以限制梯度规模，但不能代替降低学习率来控制 Adam 的实际更新幅度。</strong></p>
</blockquote>
<h2 id="七lr1e-7更温和的单步变化">七、LR=1e-7：更温和的单步变化</h2>
<p>将学习率从 <code>1e-6</code> 降到 <code>1e-7</code>，保留 <code>beta=0.1</code> 和 <code>grad clip=1.0</code>：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>指标</th>
        <th style="text-align: right">LR=1e-6</th>
        <th style="text-align: right">LR=1e-7</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>score change</td>
        <td style="text-align: right">35.333</td>
        <td style="text-align: right"><strong>3.698</strong></td>
      </tr>
      <tr>
        <td>更新后 loss</td>
        <td style="text-align: right">0.0288</td>
        <td style="text-align: right"><strong>0.5252</strong></td>
      </tr>
      <tr>
        <td>Chosen 变化</td>
        <td style="text-align: right">+2.588</td>
        <td style="text-align: right"><strong>+0.339</strong></td>
      </tr>
      <tr>
        <td>Rejected 变化</td>
        <td style="text-align: right">-32.745</td>
        <td style="text-align: right"><strong>-3.359</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<p>学习率缩小 10 倍后，score 变化也大约缩小 10 倍，更新方向没有改变，但明显温和得多。</p>
<p>因此当前候选起点是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">LR = 1e-7
</span></span><span class="line"><span class="cl">beta = 0.1
</span></span><span class="line"><span class="cl">grad clip = 1.0
</span></span></code></pre></div><p>它只是一个偏好探针得出的候选配置，不能据此宣称是正式训练的最佳配置。</p>
<h2 id="八dpo-编码prompt-与候选输出必须分开处理">八、DPO 编码：Prompt 与候选输出必须分开处理</h2>
<p>本次还实际遇到了一个模板问题：如果把 chosen / rejected 也交给 Chat Template 重新渲染，模板可能拆分、清理甚至重写思考标签，导致 malformed 的原始输出被“修正”。</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">prefix_text</span> <span class="o">=</span> <span class="n">tokenizer</span><span class="o">.</span><span class="n">apply_chat_template</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">messages</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">tokenize</span><span class="o">=</span><span class="kc">False</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">add_generation_prompt</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">enable_thinking</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">full_text</span> <span class="o">=</span> <span class="n">prefix_text</span> <span class="o">+</span> <span class="n">response</span> <span class="o">+</span> <span class="s2">&#34;&lt;|im_end|&gt;</span><span class="se">\n</span><span class="s2">&#34;</span>
</span></span></code></pre></div><p>也就是：</p>
<ul>
<li>Prompt 使用官方 Chat Template；</li>
<li>chosen / rejected 作为原始候选输出直接追加；</li>
<li>不让模板二次修改候选回答；</li>
<li>再从 prefix / full 的 token 长度计算目标区间。</li>
</ul>
<p>这样正常 CoT 与空思考、缺失标签、标签交错等 malformed 输出都能保留原始形式进入 logprob 计算。</p>
<h2 id="九32--8-条偏好数据与审计">九、32 + 8 条偏好数据与审计</h2>
<p>本轮合成偏好数据分为四种 rejected 类型：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>pair_type</th>
        <th style="text-align: right">Train</th>
        <th style="text-align: right">Val</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>verbose_correct</td>
        <td style="text-align: right">8</td>
        <td style="text-align: right">2</td>
      </tr>
      <tr>
        <td>verbose_wrong</td>
        <td style="text-align: right">8</td>
        <td style="text-align: right">2</td>
      </tr>
      <tr>
        <td>repetition</td>
        <td style="text-align: right">8</td>
        <td style="text-align: right">2</td>
      </tr>
      <tr>
        <td>malformed</td>
        <td style="text-align: right">8</td>
        <td style="text-align: right">2</td>
      </tr>
      <tr>
        <td>合计</td>
        <td style="text-align: right"><strong>32</strong></td>
        <td style="text-align: right"><strong>8</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<p>每类内部，单轮算术与多轮数值更新各占一半。</p>
<p>数据要求：</p>
<ul>
<li>Chosen 必须是简短、正确、结构完整的 CoT；</li>
<li>verbose_correct 的 Rejected 答案正确但明显啰嗦；</li>
<li>verbose_wrong 的 Rejected 含明确计算或最终答案错误；</li>
<li>repetition 包含重复或自我怀疑；</li>
<li>malformed 包含空思考、缺失标签、前置乱码或结构混乱。</li>
</ul>
<p><code>i4_dpo_data_audit.py</code> 实际验证：</p>
<ul>
<li>样本数量、任务比例和四种 pair_type 数量；</li>
<li>Chosen 的 CoT 格式、最终答案和中间算式；</li>
<li>Rejected 是否符合对应类型；</li>
<li>train / val 无重复 Prompt；</li>
<li>与已有 smoke、非 CoT、CoT 数据无重复显式算式；</li>
<li>行为基线排除项未命中；</li>
<li>全部 chosen / rejected 均通过偏好编码。</li>
</ul>
<p>审计输出为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">train chosen equations checked: 37
</span></span><span class="line"><span class="cl">val chosen equations checked: 8
</span></span><span class="line"><span class="cl">preference encoding: passed
</span></span><span class="line"><span class="cl">train / val prompt overlap: 0
</span></span><span class="line"><span class="cl">existing-data expression overlap: 0
</span></span><span class="line"><span class="cl">exclusion checks: passed
</span></span><span class="line"><span class="cl">全部 DPO 数据审计通过
</span></span></code></pre></div><p>这些是合成偏好数据，不代表人工标注，也不代表通用能力结论。</p>
<h2 id="十今晚的停止边界">十、今晚的停止边界</h2>
<p>今天完成的是：</p>
<ul>
<li>DPO 基本概念与数据契约；</li>
<li>序列 logprob、score 和初始 loss；</li>
<li>单步更新、梯度范数与 Adam 缩放现象；</li>
<li>LR=1e-7 的温和更新；</li>
<li>偏好数据与完整编码审计。</li>
</ul>
<p>尚未完成：</p>
<ul>
<li>小批量 DPO 训练；</li>
<li>DPO checkpoint；</li>
<li>训练后的答案正确率、CoT 格式、输出长度和能力保持评估；</li>
<li>LoRA / 全参对照；</li>
<li>RLVR / GRPO。</li>
</ul>
<p>所以当前不能写成“DPO 已提升模型”。准确状态是：<strong>DPO 的数据、计算和单步工程验证已经准备完成，下一步才是小批量训练与行为对照。</strong></p>
<p>今晚先到这里，保留已有 checkpoint、报告、偏好数据和编码实现，明天从批量 DPO 开始即可。</p>
<h2 id="附参数规模垂直领域与能力权衡">附：参数规模、垂直领域与能力权衡</h2>
<p>在后训练实验之外，我又梳理了一次自己对“为什么做垂直领域微调”的认知。这不是一个已经证明的结论，而是后续选择模型、数据和评测目标时的一套假设。</p>
<h3 id="1-我目前的三个判断">1. 我目前的三个判断</h3>
<p>第一，参数规模决定模型的能力上限。大厂在固定参数下训练出的通用模型，大概率希望成为六边形战士；但垂直领域并不一定需要六边形战士。</p>
<p>例如做架构设计时，我可以接受模型在数学、科研等领域不那么突出，把有限的容量和训练预算集中到架构领域，换取这一领域内的大幅度提升。</p>
<p>第二，一个 27B 模型经过合适的领域微调，如果能在架构设计这一明确任务范围内，与 100B+ 的通用模型打得有来有回，就已经足够有价值。这里追求的不是全面替代更大的模型，而是在垂直场景中形成实际优势。</p>
<p>第三，大厂基础模型已经做了大量通用优化。对具体使用者来说，微调、SFT、DPO 等方法更像是在做权衡和有的放矢，而不是继续追求全面提升。微调前需要明确要突出哪一方面，也要接受这更像系统架构中的 trade-off。</p>
<h3 id="2-需要补充的第一条边界参数规模不是唯一变量">2. 需要补充的第一条边界：参数规模不是唯一变量</h3>
<p>参数规模影响模型容量、知识承载和复杂推理上限，但同样规模的模型，实际能力还可能受这些因素影响：</p>
<ul>
<li>训练数据质量与覆盖；</li>
<li>训练 token 量和计算量；</li>
<li>架构与训练方法；</li>
<li>后训练方式；</li>
<li>推理时的上下文、工具、检索和思考预算。</li>
</ul>
<p>因此，27B 模型在垂直领域挑战更大的通用模型是合理目标，尤其是在任务边界清楚、领域数据质量高、评价标准明确的情况下。</p>
<p>但这不代表它获得了大模型的全部能力，更可能是把有限容量集中到了一个更窄、更有价值的任务分布内。</p>
<h3 id="3-需要补充的第二条边界领域提升不必然牺牲其他能力但一定存在权衡风险">3. 需要补充的第二条边界：领域提升不必然牺牲其他能力，但一定存在权衡风险</h3>
<p>微调并不是每次都必须“数学下降，架构上升”。如果数据混合合理、训练强度适当，也可能在保留通用能力的同时提升领域表现。</p>
<p>但 I4 的实验已经给出了真实例子：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">格式能力提升
</span></span><span class="line"><span class="cl">→ 名字记忆出现回退
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">数值更新提升
</span></span><span class="line"><span class="cl">→ 部分算术正确率回退
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">偏好 loss 降低
</span></span><span class="line"><span class="cl">→ 最终行为没有同步改善
</span></span></code></pre></div><p>所以真正需要管理的是：</p>
<blockquote>
<p><strong>我愿意接受哪些能力损失，以及怎样通过 eval 及时发现实际发生的损失。</strong></p>
</blockquote>
<p>有些损失是主动接受的，有些是不小心造成的。只有设置能力保持评测，才能区分这两者。</p>
<h3 id="4-需要补充的第三条边界领域优势必须限定任务分布">4. 需要补充的第三条边界：领域优势必须限定任务分布</h3>
<p>“27B 架构模型和 100B+ 通用模型有来有回”还需要继续追问是在什么任务上：</p>
<ul>
<li>编写常规架构文档；</li>
<li>根据明确需求做技术选型；</li>
<li>发现复杂系统中的依赖与故障风险；</li>
<li>面对陌生业务做开放式架构权衡；</li>
<li>审查真实代码、数据和运行证据，还是只根据提示词给建议。</li>
</ul>
<p>越靠近固定流程、明确格式和常见案例，小模型领域化越容易取得优势；越接近开放问题、跨领域推理和复杂长链路决策，大模型的通用能力仍然可能很重要。</p>
<p>因此，领域模型超过大模型必须限定在明确的任务分布与评价口径内，不能从一组领域测试直接推广成全面超越。</p>
<h3 id="5-把训练目标写成一份架构-trade-off-说明">5. 把训练目标写成一份架构 trade-off 说明</h3>
<p>如果后续真的训练架构领域模型，可以把目标写成：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">目标：架构领域能力显著提升
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">约束：
</span></span><span class="line"><span class="cl">- 通用代码能力最多允许下降多少
</span></span><span class="line"><span class="cl">- 数学能力是否可以不保留
</span></span><span class="line"><span class="cl">- 多轮指令遵循不能退化
</span></span><span class="line"><span class="cl">- 输出结构与工具调用必须稳定
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">验收：
</span></span><span class="line"><span class="cl">- 架构领域测试集
</span></span><span class="line"><span class="cl">- 未见项目与跨域测试
</span></span><span class="line"><span class="cl">- 通用能力保持集
</span></span><span class="line"><span class="cl">- 失败与回退案例
</span></span></code></pre></div><p>这和系统架构设计很像：不是追求所有指标无限上升，而是在明确目标、约束和成本的前提下做选择，并用评测验证选择是否成立。</p>
<h3 id="6-架构领域尤其需要区分权重与上下文">6. 架构领域尤其需要区分权重与上下文</h3>
<p>架构知识并不都适合固化进权重：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">架构原则、设计方法、评审方式
</span></span><span class="line"><span class="cl">→ 可以通过训练内化
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">当前系统结构、依赖、容量、故障现场
</span></span><span class="line"><span class="cl">→ 更适合由代码图谱、知识库和运行时上下文提供
</span></span></code></pre></div><p>如果训练的是会背架构答案的模型，它可能只能在熟悉模板里表现良好；真正有价值的是在明确任务分布内，基于真实证据做出可评审的设计决策，同时保留必要的代码分析和系统推理能力。</p>
<h3 id="7-当前结论">7. 当前结论</h3>
<p>垂直微调的目标不是培养一个更小的六边形战士，而是在明确任务分布内，把有限参数用到最有价值的地方，并且清楚知道自己付出了什么代价。</p>
<p>这套认知与 I4 的实验结论是一致的：<strong>后训练不是无成本的全面增强，而是能力分布的重新塑造。目标、约束和 eval 必须同时设计。</strong></p>
<h2 id="主要实验产物">主要实验产物</h2>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">data/instruct/i4_dpo_preference_probe.json
</span></span><span class="line"><span class="cl">data/instruct/i4_dpo_synthetic_train.json
</span></span><span class="line"><span class="cl">data/instruct/i4_dpo_synthetic_val.json
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">scripts/i4_dpo_logprob_probe.py
</span></span><span class="line"><span class="cl">scripts/i4_dpo_one_step.py
</span></span><span class="line"><span class="cl">scripts/i4_dpo_data_audit.py
</span></span><span class="line"><span class="cl">scripts/i4_cot_behavior_eval.py
</span></span><span class="line"><span class="cl">scripts/i4_behavior_baseline.py
</span></span></code></pre></div>]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 24：I4 思维链 CoT-SFT</title>
      <link>https://blog.lvxinrong.com/llm/llm-24-i4-cot-sft/</link>
      <pubDate>Mon, 16 Nov 2026 12:00:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-24-i4-cot-sft/</guid>
      <description>从 CoT 数据契约、Qwen 历史思考剥离和严格格式验收出发，完成 128 + 32 条 CoT 数据审计与三组 peak_lr 对照。记录 CoT 丢失、低学习率恢复、输出长度与推理算式变化，以及最终答案未超过原始模型的边界。</description>
      <content:encoded><![CDATA[<p>这篇记录 <strong>I4-C：思维链 CoT-SFT 的受控实验与阶段收官</strong>。它不是“CoT 能力已经解决”的证明，而是一次从数据协议、模板行为、训练干预到行为验收的完整排障。</p>
<p>最后得到的结论并不只是“哪个学习率最好”，而是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">原始模型已经会生成 CoT
</span></span><span class="line"><span class="cl">→ 全参数 SFT 在不同 peak_lr 下产生不同程度的行为破坏
</span></span><span class="line"><span class="cl">→ 低学习率版本保留并改善了一部分行为
</span></span><span class="line"><span class="cl">→ 但最终答案正确率仍没有整体超过原始模型
</span></span></code></pre></div><h2 id="一实验目标与基线">一、实验目标与基线</h2>
<p>本轮继续使用 <strong>Qwen3-0.6B Instruct</strong>，从原始权重开始。实际运行环境为 MacBook M4 Pro、MPS、FP32。</p>
<p>实验问题不是“模型能不能显示 <code>&lt;think&gt;</code>”，而是：</p>
<ul>
<li>简短、正确的 CoT 数据能否改善推理表达；</li>
<li>最终答案与思考结构能否同时保持；</li>
<li>不同 peak_lr 会如何影响原生 CoT 行为；</li>
<li>训练后是否变得更短、更可靠，还是只是 loss 更低。</li>
</ul>
<p>第一版 CoT 行为基线使用 32 条独立验证样本，分别统计：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">answer_correct：最终数字是否正确
</span></span><span class="line"><span class="cl">format_compliant：是否以 &lt;think&gt; 开始，恰好一对标签、非空推理、纯数字答案，且推理不是答案复读
</span></span><span class="line"><span class="cl">finish_reason：自然结束还是长度截断
</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">answer_correct = 30/32
</span></span><span class="line"><span class="cl">format_compliant = 32/32
</span></span><span class="line"><span class="cl">passed = 30/32
</span></span><span class="line"><span class="cl">empty = 0
</span></span><span class="line"><span class="cl">natural_stop = 32/32
</span></span></code></pre></div><p>原始模型已经具备完整 CoT 输出能力，主要问题是思考偏长、存在自我怀疑，以及少量算术和推理错误。</p>
<h2 id="二cot-数据契约监督完整-assistant-输出">二、CoT 数据契约：监督完整 Assistant 输出</h2>
<h3 id="1-思考标签也属于训练目标">1. 思考标签也属于训练目标</h3>
<p>本轮选择监督完整 Assistant 输出，而不是只监督最终答案：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">&lt;think&gt;
</span></span><span class="line"><span class="cl">简短、正确的推理
</span></span><span class="line"><span class="cl">&lt;/think&gt;
</span></span><span class="line"><span class="cl">最终答案
</span></span><span class="line"><span class="cl">&lt;|im_end|&gt;
</span></span></code></pre></div><p>在固定探针中，Full 下标为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">31～33：Assistant 角色头
</span></span><span class="line"><span class="cl">34：    &lt;think&gt;
</span></span><span class="line"><span class="cl">36～87：推理正文
</span></span><span class="line"><span class="cl">88：    &lt;/think&gt;
</span></span><span class="line"><span class="cl">90～92：最终答案 600
</span></span><span class="line"><span class="cl">93：    &lt;|im_end|&gt;
</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">full[34:94] → targets[33:93]
</span></span></code></pre></div><p>Assistant 角色头、System 和 User 不计 loss；思考标签、推理正文、最终答案和 <code>&lt;|im_end|&gt;</code> 都参与 loss。</p>
<p>这样训练的是完整输出协议：开始思考、进行推理、结束思考、给出答案、正常结束，而不是只学习答案格式。</p>
<h3 id="2-多轮-cot-的一个真实兼容问题">2. 多轮 CoT 的一个真实兼容问题</h3>
<p>GPT 辅助生成数据后，发现了一个系统性问题：<strong>Qwen 模板会剥离历史 Assistant 的思考过程，只保留最终答案。</strong></p>
<p>例如原始数据是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Assistant 1：&lt;think&gt;12 × 16 = 192。&lt;/think&gt;192
</span></span><span class="line"><span class="cl">User 2：补货后变为 3 倍
</span></span><span class="line"><span class="cl">Assistant 2：&lt;think&gt;192 × 3 = 576。&lt;/think&gt;576
</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">历史 Assistant：192
</span></span><span class="line"><span class="cl">最后一轮 Assistant：完整 CoT + 576
</span></span></code></pre></div><p>第一版 <code>find_assistant_spans()</code> 直接拿原始完整 CoT 去渲染文本中查找，必然找不到。受影响的正好是 64 条 train + 16 条 val，共 80 条多轮样本。</p>
<p>最终没有修改数据，也没有强行改变 Qwen 模板，而是遵循“模板实际显示什么，就监督什么”：</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">get_assistant_visible_content</span><span class="p">(</span><span class="n">messages</span><span class="p">,</span> <span class="n">index</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">content</span> <span class="o">=</span> <span class="n">messages</span><span class="p">[</span><span class="n">index</span><span class="p">][</span><span class="s2">&#34;content&#34;</span><span class="p">]</span><span class="o">.</span><span class="n">lstrip</span><span class="p">(</span><span class="s2">&#34;</span><span class="se">\n</span><span class="s2">&#34;</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">index</span> <span class="o">==</span> <span class="nb">len</span><span class="p">(</span><span class="n">messages</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span> <span class="ow">or</span> <span class="s2">&#34;&lt;/think&gt;&#34;</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">content</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">content</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">content</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="s2">&#34;&lt;/think&gt;&#34;</span><span class="p">)[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">lstrip</span><span class="p">(</span><span class="s2">&#34;</span><span class="se">\n</span><span class="s2">&#34;</span><span class="p">)</span>
</span></span></code></pre></div><p>这样历史 Assistant 只监督最终答案和 <code>&lt;|im_end|&gt;</code>，最后一轮继续监督完整 CoT。新增回归后达到 <strong>5 passed</strong>，同时覆盖原有非 CoT 行为与多轮 CoT 可见性。</p>
<p>这也是训练与推理保持一致的重要原则：不为了保留思考而制造一套与真实调用不同的模板。</p>
<h2 id="三128--32-条-cot-数据审计">三、128 + 32 条 CoT 数据审计</h2>
<p>正式数据分为两类：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>类别</th>
        <th style="text-align: right">Train</th>
        <th style="text-align: right">Val</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>单轮算术</td>
        <td style="text-align: right">64</td>
        <td style="text-align: right">16</td>
      </tr>
      <tr>
        <td>多轮数值更新</td>
        <td style="text-align: right">64</td>
        <td style="text-align: right">16</td>
      </tr>
      <tr>
        <td>合计</td>
        <td style="text-align: right"><strong>128</strong></td>
        <td style="text-align: right"><strong>32</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<p>每条 Assistant 使用 1～3 行简短推理，最终答案为纯数字。数据审计实际覆盖：</p>
<ul>
<li>JSON、角色顺序和类别比例；</li>
<li>每个 Assistant 恰好一对 think 标签；</li>
<li>推理与最终答案非空，答案为纯数字；</li>
<li>train / val 无完全重复对话；</li>
<li>train / val 无重复显式算式；</li>
<li>与 smoke、非 CoT 数据无重复显式算式；</li>
<li>排除行为基线中的名字、颜色和指定表达式；</li>
<li><strong>272 条显式算式重新核算</strong>；</li>
<li>全部 160 条样本通过真实模板编码，修复后的历史 CoT 与最后一轮 CoT 均可定位。</li>
</ul>
<p>本地 <code>i4_cot_data_audit.py</code> 最终输出：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">train equations checked: 218
</span></span><span class="line"><span class="cl">val equations checked: 54
</span></span><span class="line"><span class="cl">total equations checked: 272
</span></span><span class="line"><span class="cl">train / val exact overlap: 0
</span></span><span class="line"><span class="cl">train / val expression overlap: 0
</span></span><span class="line"><span class="cl">existing-data expression overlap: 0
</span></span><span class="line"><span class="cl">全部 CoT 数据审计通过
</span></span></code></pre></div><p>算式解析只能覆盖明确写成“数字 + 运算符 + 数字”的部分，不能代替全部自然语言推理质量评估。</p>
<h2 id="四训练前的两个关键对照">四、训练前的两个关键对照</h2>
<h3 id="1-原始模型与上一轮非-cot-v2">1. 原始模型与上一轮非 CoT v2</h3>
<p>在开启 thinking 后，上一轮非 CoT SFT 的最佳版本出现了明显的行为变化：</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">非 CoT v2</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>最终答案正确</td>
        <td style="text-align: right">30/32</td>
        <td style="text-align: right">10/32</td>
      </tr>
      <tr>
        <td>完整 CoT 格式</td>
        <td style="text-align: right">32/32</td>
        <td style="text-align: right">0/32</td>
      </tr>
      <tr>
        <td>综合通过</td>
        <td style="text-align: right">30/32</td>
        <td style="text-align: right">0/32</td>
      </tr>
    </tbody>
  </table>
</div>
<p>这说明非 CoT SFT 对 thinking 行为存在明显干扰。因此，本轮从原始权重开始，不把“恢复被破坏的 thinking”和“学习短 CoT”混成同一个实验。</p>
<h3 id="2-评分脚本也需要先修正">2. 评分脚本也需要先修正</h3>
<p>第一次评估时，<code>expected</code> 是完整的 <code>&lt;think&gt;...&lt;/think&gt;</code> 加答案，却拿去与模型的纯数字答案做 <code>expected_exact</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">expected_answer</span> <span class="o">=</span> <span class="n">split_cot_response</span><span class="p">(</span><span class="n">expected</span><span class="p">)[</span><span class="mi">1</span><span class="p">]</span>
</span></span></code></pre></div><p>并分别保存完整期望输出与最终期望数字。修正后，原始模型的 30 条正确答案才被正确计入。</p>
<p>这再次说明：<strong>先验收评测器，再比较模型。</strong></p>
<h2 id="五三组训练与行为结果">五、三组训练与行为结果</h2>
<p>三组都使用原始权重、128 条训练样本、32 条验证样本、<code>batch_size=4</code>、<code>n_epochs=1</code>、32 steps、seed=123。</p>
<p>报告核对后，三版的 <code>initial_lr</code> 与 <code>min_lr</code> 实际均为 <code>1e-6</code> 和 <code>1e-7</code>，并非整体按比例缩放。因此，本实验应理解为 <strong>peak_lr 与后续调度路径的对照</strong>，不声称其他调度参数完全相同。</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>版本</th>
        <th style="text-align: right">peak_lr</th>
        <th style="text-align: right">final full val loss</th>
        <th style="text-align: right">答案正确</th>
        <th style="text-align: right">完整 CoT</th>
        <th style="text-align: right">综合通过</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>v1</td>
        <td style="text-align: right">1e-5</td>
        <td style="text-align: right"><strong>0.807683</strong></td>
        <td style="text-align: right">6/32</td>
        <td style="text-align: right">0/32</td>
        <td style="text-align: right">0/32</td>
      </tr>
      <tr>
        <td>v2</td>
        <td style="text-align: right">1e-6</td>
        <td style="text-align: right">1.159451</td>
        <td style="text-align: right"><strong>29/32</strong></td>
        <td style="text-align: right"><strong>32/32</strong></td>
        <td style="text-align: right"><strong>29/32</strong></td>
      </tr>
      <tr>
        <td>v3</td>
        <td style="text-align: right">3e-6</td>
        <td style="text-align: right">1.037620</td>
        <td style="text-align: right">18/32</td>
        <td style="text-align: right"><strong>1/32</strong></td>
        <td style="text-align: right"><strong>1/32</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<h3 id="1-v1低-loss但-cot-直接丢失">1. v1：低 loss，但 CoT 直接丢失</h3>
<p>v1 的训练结果很漂亮：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">initial train loss = 2.670255
</span></span><span class="line"><span class="cl">final train loss = 0.822201
</span></span><span class="line"><span class="cl">final full val loss = 0.807683
</span></span></code></pre></div><p>但行为上：</p>
<ul>
<li>32 条样本全部没有完整 CoT；</li>
<li>最终答案只剩 6 条正确；</li>
<li>两组回答重复到长度上限；</li>
<li>训练原题上，原始模型 4/4 正确且完整 CoT，v1 只剩 1/4 正确、0/4 完整 CoT。</li>
</ul>
<p>所以它不是简单的验证集泛化失败，而是训练直接引入了 CoT 行为干扰。</p>
<h3 id="2-v2降低-peak_lr-后cot-恢复并出现局部收益">2. v2：降低 peak_lr 后，CoT 恢复并出现局部收益</h3>
<p>将 <code>peak_lr</code> 降到 <code>1e-6</code> 后：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">final train loss = 1.140148
</span></span><span class="line"><span class="cl">final full val loss = 1.159451
</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">answer_correct = 29/32
</span></span><span class="line"><span class="cl">format_compliant = 32/32
</span></span><span class="line"><span class="cl">passed = 29/32
</span></span><span class="line"><span class="cl">natural_stop = 32/32
</span></span></code></pre></div><p>分类表现：</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">v2</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>数值更新</td>
        <td style="text-align: right">15/16</td>
        <td style="text-align: right"><strong>16/16</strong></td>
      </tr>
      <tr>
        <td>单轮算术</td>
        <td style="text-align: right">15/16</td>
        <td style="text-align: right">13/16</td>
      </tr>
    </tbody>
  </table>
</div>
<p>v2 的数值更新超过原始模型，但单轮算术和总体正确率仍未超过原始模型。因此它是<strong>当前 SFT 干预中破坏最小、存在局部收益的 checkpoint</strong>，不是全面优于原始模型的 checkpoint。</p>
<h3 id="3-v3中间学习率再次出现结构性退化">3. v3：中间学习率再次出现结构性退化</h3>
<p>将 <code>peak_lr</code> 调到 <code>3e-6</code> 后，最终答案为 18/32，严格有效 CoT 只剩 1/32。</p>
<p>主要问题包括：</p>
<ul>
<li>前置乱码或无关数字；</li>
<li>空思考；</li>
<li>思考标签与答案交错；</li>
<li>最终答案与中间结果不一致；</li>
<li>数值更新行为明显失稳。</li>
</ul>
<p>v3 的 <code>format_compliant=1</code> 使用收紧后的格式定义重新计算，不能把早期宽松检查中的 28 条标签出现当作有效 CoT。</p>
<h2 id="六严格格式验收出现标签不等于有效-cot">六、严格格式验收：出现标签不等于有效 CoT</h2>
<p>早期格式检查只要求有一对标签、非空推理和最终答案，导致“前置垃圾数字”和“答案复读”也被判为合格。</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="k">def</span> <span class="nf">has_complete_cot_format</span><span class="p">(</span><span class="n">response</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">stripped</span> <span class="o">=</span> <span class="n">response</span><span class="o">.</span><span class="n">strip</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="ow">not</span> <span class="n">stripped</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s2">&#34;&lt;think&gt;&#34;</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="kc">False</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="n">reasoning</span><span class="p">,</span> <span class="n">final_answer</span> <span class="o">=</span> <span class="n">split_cot_response</span><span class="p">(</span><span class="n">stripped</span><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="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="n">response</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="s2">&#34;&lt;think&gt;&#34;</span><span class="p">)</span> <span class="o">==</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">        <span class="ow">and</span> <span class="n">response</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="s2">&#34;&lt;/think&gt;&#34;</span><span class="p">)</span> <span class="o">==</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">        <span class="ow">and</span> <span class="nb">bool</span><span class="p">(</span><span class="n">reasoning</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="ow">and</span> <span class="nb">bool</span><span class="p">(</span><span class="n">final_answer</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="ow">and</span> <span class="n">reasoning</span> <span class="o">!=</span> <span class="n">final_answer</span>
</span></span><span class="line"><span class="cl">    <span class="p">)</span>
</span></span></code></pre></div><p>这要求：</p>
<ul>
<li>必须以 <code>&lt;think&gt;</code> 开始；</li>
<li>恰好一对标签；</li>
<li>推理与答案都非空；</li>
<li>推理不能只是答案复读；</li>
<li>最终答案仍需通过纯数字格式检查。</li>
</ul>
<p>原始模型与 v2 在新定义下仍为 32/32；v3 从宽松的 28 条降为严格的 1 条。这说明<strong>短输出和出现标签都不能代替有效结构验收</strong>。</p>
<h2 id="七输出长度与推理算式变化">七、输出长度与推理算式变化</h2>
<p>进一步比较原始模型与 v2：</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">v2：peak_lr=1e-6</th>
        <th style="text-align: right">变化</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>平均生成 tokens</td>
        <td style="text-align: right">163.1</td>
        <td style="text-align: right">139.4</td>
        <td style="text-align: right"><strong>缩短约 14.5%</strong></td>
      </tr>
      <tr>
        <td>中位生成 tokens</td>
        <td style="text-align: right">146</td>
        <td style="text-align: right">120</td>
        <td style="text-align: right"><strong>缩短约 17.8%</strong></td>
      </tr>
      <tr>
        <td>最大生成 tokens</td>
        <td style="text-align: right">430</td>
        <td style="text-align: right">278</td>
        <td style="text-align: right"><strong>缩短约 35.3%</strong></td>
      </tr>
      <tr>
        <td>推理算式错误</td>
        <td style="text-align: right">2 条</td>
        <td style="text-align: right"><strong>0 条</strong></td>
        <td style="text-align: right">当前检查中消除</td>
      </tr>
    </tbody>
  </table>
</div>
<p>v2 的确不只是“保住原模型”，它确实带来了输出变短和显式推理算式改善。</p>
<p>但 <code>reasoning equation errors=0</code> 只说明正则识别出的算式计算正确，不代表整段推理逻辑和最终答案一定正确。v2 仍有 3 条最终答案错误，仍存在自我怀疑、过程混乱和前后不一致。</p>
<h2 id="八loss-与行为表现再次不一致">八、loss 与行为表现再次不一致</h2>
<p>v1 的 val loss 最低，却只有 6/32 正确答案且完全丢失 CoT；v2 的 val loss 更高，却有 29/32 正确答案和完整 CoT。</p>
<p>这与 I4-B 的结论一致：</p>
<blockquote>
<p><strong>平均 token loss 下降，不等于目标行为变好；训练拟合程度更强，也不等于旧能力保留得更好。</strong></p>
</blockquote>
<p>后训练必须同时评估：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">训练与验证 loss
</span></span><span class="line"><span class="cl">最终答案正确性
</span></span><span class="line"><span class="cl">输出结构完整性
</span></span><span class="line"><span class="cl">推理过程质量
</span></span><span class="line"><span class="cl">旧能力保持情况
</span></span></code></pre></div><h2 id="九阶段结论">九、阶段结论</h2>
<p>本轮可以确认：</p>
<ul>
<li>CoT 的标签、推理正文和最终答案都能进入训练目标；</li>
<li>Qwen 历史 Assistant 的 CoT 会被模板剥离，Dataset 必须按可见内容定位；</li>
<li>peak_lr 对 CoT 行为有显著影响，高学习率下可能出现格式丢失和结构性退化；</li>
<li>LR=1e-6 的版本保留了完整 CoT，并改善数值更新、输出长度和显式推理算式；</li>
<li>但最终答案正确率没有整体超过原始模型，不能宣称 CoT-SFT 已全面提升能力。</li>
</ul>
<p>因此，如果优先追求最终答案正确率，<strong>原始模型仍然更合适</strong>；如果研究如何以较小破坏获得局部行为收益，v2 才具有对照价值。</p>
<h2 id="十阶段收官与下一步">十、阶段收官与下一步</h2>
<p>I4-C 按受控实验阶段收官，保留以下未解决问题：</p>
<ul>
<li>最终答案准确率尚未整体超过原始模型；</li>
<li>推理仍然偏长，自我怀疑并未完全消失；</li>
<li>推理算式检查不能覆盖完整语义质量；</li>
<li>尚未评估更大数据集、真实任务或其他模型规模；</li>
<li>尚未开始 DPO / GRPO。</li>
</ul>
<p>下一步进入 I4-D 时，将重点研究偏好数据：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Chosen：简短、正确、结构完整的 CoT
</span></span><span class="line"><span class="cl">Rejected：冗长、自我怀疑、算式错误、结构混乱或重复的回答
</span></span></code></pre></div><p>DPO 的目标是学习偏好差异，而不是简单模仿标准答案。它是否能在保留最终答案能力的同时改善表达，需要重新建立基线和能力保持评测，不能当成自动修复工具。</p>
<h2 id="主要实验产物">主要实验产物</h2>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">src/squid/data/chat_sft.py
</span></span><span class="line"><span class="cl">scripts/i4_cot_template_probe.py
</span></span><span class="line"><span class="cl">scripts/i4_cot_data_audit.py
</span></span><span class="line"><span class="cl">scripts/i4_cot_target_probe.py
</span></span><span class="line"><span class="cl">scripts/i4_cot_sft_train.py
</span></span><span class="line"><span class="cl">scripts/i4_cot_behavior_eval.py
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">data/reports/i4-cot-original-baseline.json
</span></span><span class="line"><span class="cl">data/reports/i4-cot-v2-baseline.json
</span></span><span class="line"><span class="cl">data/reports/i4-cot-sft-v1-training.json
</span></span><span class="line"><span class="cl">data/reports/i4-cot-sft-v2-lr1e-6-training.json
</span></span><span class="line"><span class="cl">data/reports/i4-cot-sft-v3-lr3e-6-training.json
</span></span><span class="line"><span class="cl">data/reports/i4-cot-sft-v1-behavior.json
</span></span><span class="line"><span class="cl">data/reports/i4-cot-sft-v2-lr1e-6-behavior.json
</span></span><span class="line"><span class="cl">data/reports/i4-cot-sft-v3-lr3e-6-behavior.json
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">data/model_pth/qwen3/i4-cot-sft-v1.pth
</span></span><span class="line"><span class="cl">data/model_pth/qwen3/i4-cot-sft-v2-lr1e-6.pth
</span></span><span class="line"><span class="cl">data/model_pth/qwen3/i4-cot-sft-v3-lr3e-6.pth
</span></span></code></pre></div>]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 23：I4 多轮对话 SFT</title>
      <link>https://blog.lvxinrong.com/llm/llm-23-i4-multiturn-sft/</link>
      <pubDate>Mon, 16 Nov 2026 09:00:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-23-i4-multiturn-sft/</guid>
      <description>从 Assistant-only loss mask、Qwen 多轮模板和 128 条合成样本开始，完成全参数 SFT、独立行为评测与训练量干预。记录 v1 能力回退、v2 恢复，以及 loss 与行为表现不一致的真实证据。</description>
      <content:encoded><![CDATA[<p>这篇记录的是 <strong>I4-B：多轮对话 SFT 的最小完整闭环</strong>，不是整个 I4 的收官。CoT-SFT、DPO、GRPO、LoRA 与全参对照尚未开始。</p>
<p>这一轮最有价值的地方，不只是最后得到了一个当前最佳 checkpoint，而是第一次完整看见：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">多轮数据如何变成训练目标
</span></span><span class="line"><span class="cl">→ SFT 如何改变模型行为
</span></span><span class="line"><span class="cl">→ 新能力习得为什么会伤害旧能力
</span></span><span class="line"><span class="cl">→ 为什么不能只看训练 loss 判断后训练效果
</span></span></code></pre></div><h2 id="一实验目标与边界">一、实验目标与边界</h2>
<p>本轮使用 <strong>Qwen3-0.6B Instruct</strong>，从我们独立实现的 V4 加载、训练和生成。实验设备为 MacBook M4 Pro，实际运行后端为 MPS，权重和训练使用 FP32。</p>
<p>第一版只研究非 CoT 的多轮行为：</p>
<ul>
<li>名字与偏好记忆；</li>
<li>根据新信息更新旧数值；</li>
<li>简单算术；</li>
<li>按指定格式输出；</li>
<li>自然结束，不复制上一轮回答。</li>
</ul>
<p>这不是开放域对话训练。训练数据是受控合成数据，行为评测也只有 6 条固定基线和 32 条独立验证样本。所有结论都限定在这个范围内。</p>
<h2 id="二先弄清楚多轮样本到底监督什么">二、先弄清楚：多轮样本到底监督什么</h2>
<h3 id="1--100-与--torchinf-不是一回事">1. <code>-100</code> 与 <code>-torch.inf</code> 不是一回事</h3>
<p>M4 的单轮 SFT 已经使用过 <code>ignore_index=-100</code>，但这次重新读代码时，我发现自己仍然容易把它和注意力中的 <code>-torch.inf</code> 混在一起。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">target = -100
</span></span><span class="line"><span class="cl">→ 这个位置的预测不计入 loss
</span></span><span class="line"><span class="cl">→ 输入 token 仍然存在，仍可被后续位置读取
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">attn_score = -torch.inf
</span></span><span class="line"><span class="cl">→ 经 softmax 后注意力概率为 0
</span></span><span class="line"><span class="cl">→ 这条注意力连接被切断
</span></span></code></pre></div><p>所以，User 不参与 loss，不代表模型看不到 User。模型仍然读取完整问题和历史，只是我们不要求它学习生成 User 的提问。</p>
<h3 id="2-为什么-targetsp---1-而不是-targetsp">2. 为什么 <code>targets[:P - 1]</code> 而不是 <code>targets[:P]</code></h3>
<p>假设：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">full:    [p0, p1, p2, r0, r1, EOS]
</span></span><span class="line"><span class="cl">inputs:  [p0, p1, p2, r0, r1]
</span></span><span class="line"><span class="cl">targets: [p1, p2, r0, r1, EOS]
</span></span></code></pre></div><p><code>targets[i] = full[i + 1]</code>。当 prompt 长度 <code>P=3</code> 时，必须保留 <code>targets[2] = r0</code>，否则第一个回答 token 就没有监督。</p>
<p>这也解释了为什么 Full 中的 Assistant 区间不能直接当作 target 下标：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">full[29:35]  → targets[28:34]
</span></span><span class="line"><span class="cl">full[53:59]  → targets[52:58]
</span></span></code></pre></div><h3 id="3-多轮-assistant-都应该监督user-只提供上下文">3. 多轮 Assistant 都应该监督，User 只提供上下文</h3>
<p>本轮使用 Assistant-only SFT：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">System：上下文，不计 loss
</span></span><span class="line"><span class="cl">User：上下文，不计 loss
</span></span><span class="line"><span class="cl">Assistant 角色头：上下文，不计 loss
</span></span><span class="line"><span class="cl">Assistant 正文：计 loss
</span></span><span class="line"><span class="cl">Assistant 的 &lt;|im_end|&gt;：计 loss
</span></span></code></pre></div><p><code>&lt;|im_start|&gt;assistant</code> 是模板提供的答题区，不需要模型自己生成；<code>&lt;|im_end|&gt;</code> 是模型回答结束后需要生成的动作，必须参与训练。</p>
<p>多轮样本里会出现多个 <code>&lt;|im_end|&gt;</code>。System 和 User 的结束标记与 Assistant 的结束标记虽然 token id 相同，但职责不同，不能只保留整个序列中的第一个 EOS。</p>
<h2 id="三把真实-qwen-模板变成-dataset">三、把真实 Qwen 模板变成 Dataset</h2>
<h3 id="1-模板探针">1. 模板探针</h3>
<p>我们首先用两轮对话检查真实渲染结果，而不是凭感觉拼字符串。固定样例渲染后共有 60 个 token，两轮 Assistant 的 Full 区间为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">第一轮：full[29:35]
</span></span><span class="line"><span class="cl">第二轮：full[53:59]
</span></span></code></pre></div><p>第二轮还包含一个空的 <code>&lt;think&gt;...&lt;/think&gt;</code> 区域。当前非 CoT 数据契约中，空 think 区域只作为上下文，不参与 loss；两轮 Assistant 正文及各自的 <code>&lt;|im_end|&gt;</code> 参与 loss。</p>
<h3 id="2-核心掩码构造函数">2. 核心掩码构造函数</h3>
<p><code>src/squid/data/chat_sft.py</code> 中，区间统一使用 Full 下标、右端不取：</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">build_assistant_targets</span><span class="p">(</span><span class="n">full_ids</span><span class="p">,</span> <span class="n">assistant_spans</span><span class="p">,</span> <span class="n">ignore_index</span><span class="o">=-</span><span class="mi">100</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="ow">not</span> <span class="n">full_ids</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&#34;full_ids 不能为空&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="n">targets</span> <span class="o">=</span> <span class="p">[</span><span class="n">ignore_index</span><span class="p">]</span> <span class="o">*</span> <span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">full_ids</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="n">start</span><span class="p">,</span> <span class="n">end</span> <span class="ow">in</span> <span class="n">assistant_spans</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="n">start</span> <span class="o">&lt;</span> <span class="mi">1</span> <span class="ow">or</span> <span class="n">end</span> <span class="o">&gt;</span> <span class="nb">len</span><span class="p">(</span><span class="n">full_ids</span><span class="p">)</span> <span class="ow">or</span> <span class="n">start</span> <span class="o">&gt;=</span> <span class="n">end</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">                <span class="sa">f</span><span class="s2">&#34;非法 Assistant 区间：[</span><span class="si">{</span><span class="n">start</span><span class="si">}</span><span class="s2">, </span><span class="si">{</span><span class="n">end</span><span class="si">}</span><span class="s2">)&#34;</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="n">targets</span><span class="p">[</span><span class="n">start</span> <span class="o">-</span> <span class="mi">1</span><span class="p">:</span><span class="n">end</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="n">full_ids</span><span class="p">[</span><span class="n">start</span><span class="p">:</span><span class="n">end</span><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">targets</span>
</span></span></code></pre></div><h3 id="3-不写死区间用前缀编码定位">3. 不写死区间，用前缀编码定位</h3>
<p><code>find_assistant_spans()</code> 在渲染文本中顺序定位每轮 Assistant 正文及 <code>&lt;|im_end|&gt;</code>，再分别编码正文前和结束标记后的前缀，得到 token 下标，并断言前缀编码与 <code>full_ids</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">start_ids</span> <span class="o">=</span> <span class="n">tokenizer</span><span class="o">.</span><span class="n">encode</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">full_text</span><span class="p">[:</span><span class="n">content_start</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">    <span class="n">add_special_tokens</span><span class="o">=</span><span class="kc">False</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">end_ids</span> <span class="o">=</span> <span class="n">tokenizer</span><span class="o">.</span><span class="n">encode</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">full_text</span><span class="p">[:</span><span class="n">end_char</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">    <span class="n">add_special_tokens</span><span class="o">=</span><span class="kc">False</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">assert</span> <span class="n">start_ids</span> <span class="o">==</span> <span class="n">full_ids</span><span class="p">[:</span><span class="nb">len</span><span class="p">(</span><span class="n">start_ids</span><span class="p">)]</span>
</span></span><span class="line"><span class="cl"><span class="k">assert</span> <span class="n">end_ids</span> <span class="o">==</span> <span class="n">full_ids</span><span class="p">[:</span><span class="nb">len</span><span class="p">(</span><span class="n">end_ids</span><span class="p">)]</span>
</span></span></code></pre></div><p>这样避免把某组固定样例的下标硬编码进 Dataset，也避免简单搜索 token id 时误切正文。</p>
<p><code>encode_qwen_multiturn()</code> 将真实模板、区间定位和 target 构造接起来：</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">encode_qwen_multiturn</span><span class="p">(</span><span class="n">tokenizer</span><span class="p">,</span> <span class="n">messages</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">full_text</span> <span class="o">=</span> <span class="n">tokenizer</span><span class="o">.</span><span class="n">apply_chat_template</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="n">messages</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="n">tokenize</span><span class="o">=</span><span class="kc">False</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="n">add_generation_prompt</span><span class="o">=</span><span class="kc">False</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">encoded</span> <span class="o">=</span> <span class="n">tokenizer</span><span class="o">.</span><span class="n">apply_chat_template</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="n">messages</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="n">tokenize</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">add_generation_prompt</span><span class="o">=</span><span class="kc">False</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="n">full_ids</span> <span class="o">=</span> <span class="n">encoded</span><span class="p">[</span><span class="s2">&#34;input_ids&#34;</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="n">full_ids</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">full_ids</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="nb">list</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">        <span class="n">full_ids</span> <span class="o">=</span> <span class="n">full_ids</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="n">spans</span> <span class="o">=</span> <span class="n">find_assistant_spans</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="n">tokenizer</span><span class="p">,</span> <span class="n">messages</span><span class="p">,</span> <span class="n">full_text</span><span class="p">,</span> <span class="n">full_ids</span>
</span></span><span class="line"><span class="cl">    <span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="n">targets</span> <span class="o">=</span> <span class="n">build_assistant_targets</span><span class="p">(</span><span class="n">full_ids</span><span class="p">,</span> <span class="n">spans</span><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">full_ids</span><span class="p">[:</span><span class="o">-</span><span class="mi">1</span><span class="p">],</span> <span class="n">targets</span>
</span></span></code></pre></div><h3 id="4-batch-padding">4. Batch padding</h3>
<p>inputs 使用 EOS/pad id 补齐，targets 使用 <code>-100</code> 补齐，不额外追加 EOS，因为每轮 Assistant 已经包含自己的 <code>&lt;|im_end|&gt;</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="k">def</span> <span class="nf">qwen_multiturn_collate</span><span class="p">(</span><span class="n">batch</span><span class="p">,</span> <span class="n">pad_token_id</span><span class="p">,</span> <span class="n">ignore_index</span><span class="o">=-</span><span class="mi">100</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">max_len</span> <span class="o">=</span> <span class="nb">max</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">inputs</span><span class="p">)</span> <span class="k">for</span> <span class="n">inputs</span><span class="p">,</span> <span class="n">_</span> <span class="ow">in</span> <span class="n">batch</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="n">input_batch</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">    <span class="n">target_batch</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="n">inputs</span><span class="p">,</span> <span class="n">targets</span> <span class="ow">in</span> <span class="n">batch</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="n">input_ids</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">(</span><span class="n">inputs</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="n">torch</span><span class="o">.</span><span class="n">long</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="n">target_ids</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">(</span><span class="n">targets</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="n">torch</span><span class="o">.</span><span class="n">long</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">input_batch</span><span class="o">.</span><span class="n">append</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">            <span class="n">pad_to_length</span><span class="p">(</span><span class="n">input_ids</span><span class="p">,</span> <span class="n">max_len</span><span class="p">,</span> <span class="n">pad_token_id</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">target_batch</span><span class="o">.</span><span class="n">append</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">            <span class="n">pad_to_length</span><span class="p">(</span><span class="n">target_ids</span><span class="p">,</span> <span class="n">max_len</span><span class="p">,</span> <span class="n">ignore_index</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">torch</span><span class="o">.</span><span class="n">stack</span><span class="p">(</span><span class="n">input_batch</span><span class="p">),</span> <span class="n">torch</span><span class="o">.</span><span class="n">stack</span><span class="p">(</span><span class="n">target_batch</span><span class="p">)</span>
</span></span></code></pre></div><p>对应测试按阶段实际运行为 <strong>1 passed、2 passed、3 passed</strong>，分别覆盖掩码错位、真实模板 Dataset 和 Batch padding。这些数字不是一次全量回归。</p>
<h2 id="四冻结行为基线也修正评测器自己">四、冻结行为基线，也修正评测器自己</h2>
<h3 id="1-固定基线配置">1. 固定基线配置</h3>
<p>行为基线使用：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">模型：Qwen3-0.6B Instruct
</span></span><span class="line"><span class="cl">device：mps
</span></span><span class="line"><span class="cl">dtype：FP32
</span></span><span class="line"><span class="cl">context_size：8192
</span></span><span class="line"><span class="cl">max_new_tokens：512
</span></span><span class="line"><span class="cl">temperature：0.0
</span></span><span class="line"><span class="cl">enable_thinking：false
</span></span></code></pre></div><p>六条样例覆盖多轮记忆、连续数值更新、算术和格式遵循。</p>
<h3 id="2-expected_contains-为什么不能判断数值答案">2. <code>expected_contains</code> 为什么不能判断数值答案</h3>
<p>第一版规则只检查回答是否包含 <code>912</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="s2">&#34;912&#34;</span> <span class="ow">in</span> <span class="s2">&#34;8912&#34;</span>  <span class="c1"># True</span>
</span></span><span class="line"><span class="cl"><span class="s2">&#34;912&#34;</span> <span class="ow">in</span> <span class="s2">&#34;7192&#34;</span>  <span class="c1"># True</span>
</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">answer_correct：内容或数值是否正确
</span></span><span class="line"><span class="cl">format_compliant：是否遵守输出格式
</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">24            → 格式正确，答案错误（期望 30）
</span></span><span class="line"><span class="cl">123+789=912   → 格式错误，答案正确
</span></span><span class="line"><span class="cl">912           → 格式和答案都正确
</span></span></code></pre></div><p>评分器新增独立测试，实际运行 <strong>4 passed</strong>；加入复制检测后为 <strong>7 passed</strong>。</p>
<h3 id="3-一个列表共享引用造成的全量误报">3. 一个列表共享引用造成的全量误报</h3>
<p>32 条评估第一次全部显示 <code>copy=True</code>。根因不是模型全都复制，而是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">case[&#34;history&#34;] 与 session.history 指向同一个列表
</span></span><span class="line"><span class="cl">→ session.ask() 把当前回答追加进 history
</span></span><span class="line"><span class="cl">→ 复制检测读取到刚生成的回答
</span></span><span class="line"><span class="cl">→ 再与 response 比较，永远相等
</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">session</span><span class="o">.</span><span class="n">history</span> <span class="o">=</span> <span class="n">history</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span>
</span></span></code></pre></div><p>这次错误提醒我：<strong>训练前先验证评测器，训练后也不要把评测器的异常直接归因于模型。</strong></p>
<h3 id="4-训练前的真实行为">4. 训练前的真实行为</h3>
<p>原始模型的六条基线结果为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">passed = 2/6
</span></span><span class="line"><span class="cl">answer_correct = 4/6
</span></span><span class="line"><span class="cl">format_compliant = 4/6
</span></span><span class="line"><span class="cl">copied_previous_assistant = 1
</span></span><span class="line"><span class="cl">natural_stop = 6/6
</span></span></code></pre></div><p>典型现象包括：</p>
<ul>
<li>苹果已有 24 个，再买 6 个，仍回答 <code>24</code>；</li>
<li><code>25 * 24</code> 错答为 <code>240</code>；</li>
<li><code>123 + 789 = 912</code> 结果正确，但违反“只回答数字”；</li>
<li>颜色题直接复制上一轮 Assistant。</li>
</ul>
<h2 id="五4-step-冒烟先证明链路不证明能力">五、4-step 冒烟：先证明链路，不证明能力</h2>
<p>正式数据之前，用 4 条训练样本、2 条验证样本做了 4 个优化步骤：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">initial train loss：3.390143
</span></span><span class="line"><span class="cl">initial val loss：  2.800545
</span></span><span class="line"><span class="cl">final train loss：  1.958147
</span></span><span class="line"><span class="cl">final val loss：    1.819232
</span></span><span class="line"><span class="cl">optimization steps：4
</span></span><span class="line"><span class="cl">checkpoint reload：passed
</span></span></code></pre></div><p>恢复 checkpoint 后生成两条验证回答：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">期望 28 → 生成 28，正常 stop
</span></span><span class="line"><span class="cl">期望 15 → 生成 6，正常 stop
</span></span></code></pre></div><p>所以冒烟只证明了数据、loss、反向传播、checkpoint 和生成链路可用。第二条答错说明它没有证明模型能力。</p>
<h2 id="六128--32-合成数据与隔离审计">六、128 + 32 合成数据与隔离审计</h2>
<p>正式数据由 GPT 辅助生成，再经过本地审计：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>类别</th>
        <th style="text-align: right">Train</th>
        <th style="text-align: right">Val</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>单轮算术</td>
        <td style="text-align: right">32</td>
        <td style="text-align: right">8</td>
      </tr>
      <tr>
        <td>多轮数值更新</td>
        <td style="text-align: right">32</td>
        <td style="text-align: right">8</td>
      </tr>
      <tr>
        <td>名字记忆</td>
        <td style="text-align: right">32</td>
        <td style="text-align: right">8</td>
      </tr>
      <tr>
        <td>偏好记忆</td>
        <td style="text-align: right">32</td>
        <td style="text-align: right">8</td>
      </tr>
      <tr>
        <td>合计</td>
        <td style="text-align: right"><strong>128</strong></td>
        <td style="text-align: right"><strong>32</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<p>隔离要求包括：</p>
<ul>
<li>train / val 没有完全重复的对话；</li>
<li>同一算术表达式不跨集合；</li>
<li>排除行为基线中的小吕、蓝色、3×8+6、25×24、123+789、17+5；</li>
<li>避免复用已有 smoke 样例；</li>
<li>Assistant 不携带 think 或角色标记；</li>
<li>每条样本都能通过真实模板编码，并且存在有效监督 token。</li>
</ul>
<p>分类审计最初把“叫我”“首选爱好”“昵称”等表达误归为数值任务。修正审计规则后，四类数量恢复平衡，全部模板编码通过，train / val 精确重复为 0，排除项检查通过。</p>
<p>这组数据仍然只是受控任务数据，不代表真实多轮语料分布。</p>
<h2 id="七v164-stepsloss-很漂亮行为却出现回退">七、v1：64 steps，loss 很漂亮，行为却出现回退</h2>
<h3 id="1-训练配置与-loss">1. 训练配置与 loss</h3>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">全参数 SFT
</span></span><span class="line"><span class="cl">batch_size = 4
</span></span><span class="line"><span class="cl">n_epochs = 2
</span></span><span class="line"><span class="cl">optimization steps = 64
</span></span><span class="line"><span class="cl">peak_lr = 1e-5
</span></span><span class="line"><span class="cl">initial_lr = 1e-6
</span></span><span class="line"><span class="cl">min_lr = 1e-7
</span></span><span class="line"><span class="cl">weight_decay = 0
</span></span><span class="line"><span class="cl">warmup_steps = 6
</span></span><span class="line"><span class="cl">seed = 123
</span></span><span class="line"><span class="cl">context_size = 1024
</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">initial train loss：3.797954
</span></span><span class="line"><span class="cl">initial val loss：  3.745439
</span></span><span class="line"><span class="cl">final train loss：  0.616244
</span></span><span class="line"><span class="cl">final full val loss：0.859470
</span></span><span class="line"><span class="cl">checkpoint reload：passed
</span></span></code></pre></div><h3 id="2-六条基线从-26-到-46">2. 六条基线：从 2/6 到 4/6</h3>
<p>v1 的六条基线变为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">passed = 4/6
</span></span><span class="line"><span class="cl">answer_correct = 4/6
</span></span><span class="line"><span class="cl">format_compliant = 6/6
</span></span><span class="line"><span class="cl">copied_previous_assistant = 0
</span></span><span class="line"><span class="cl">natural_stop = 6/6
</span></span></code></pre></div><p>改善包括：</p>
<ul>
<li>苹果题从 <code>24</code> 更新为 <code>30</code>；</li>
<li><code>17 + 5</code> 从完整算式变为只输出 <code>22</code>；</li>
<li>名字回答变为“你叫小吕”。</li>
</ul>
<p>但也出现：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">25 * 24：240 → 60，仍然错误
</span></span><span class="line"><span class="cl">123 + 789：结果正确的算式 → 909，数值回退
</span></span></code></pre></div><h3 id="3-32-条独立验证总通过率提升名字却明显退化">3. 32 条独立验证：总通过率提升，名字却明显退化</h3>
<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">SFT v1</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>名字记忆</td>
        <td style="text-align: right">8/8</td>
        <td style="text-align: right"><strong>3/8</strong></td>
      </tr>
      <tr>
        <td>数值更新</td>
        <td style="text-align: right">2/8</td>
        <td style="text-align: right"><strong>7/8</strong></td>
      </tr>
      <tr>
        <td>偏好记忆</td>
        <td style="text-align: right">7/8</td>
        <td style="text-align: right">7/8</td>
      </tr>
      <tr>
        <td>单轮算术</td>
        <td style="text-align: right">2/8</td>
        <td style="text-align: right"><strong>7/8</strong></td>
      </tr>
      <tr>
        <td>总计</td>
        <td style="text-align: right">19/32</td>
        <td style="text-align: right"><strong>24/32</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<p>v1 的格式合规从 24 提升到 31，但内容正确从 25 降为 24。名字类出现“你”“你。”“你记住了”等无效回答。</p>
<h3 id="4-同一训练集上的对照确认训练引入的回退">4. 同一训练集上的对照，确认训练引入的回退</h3>
<p>为了区分“原本不会”与“训练后改坏”，又比较了原始模型与 v1 在同一 128 条样本上的 <code>passed</code>：</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">SFT v1</th>
        <th>净变化</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>名字记忆</td>
        <td style="text-align: right">32/32</td>
        <td style="text-align: right">21/32</td>
        <td><strong>-11</strong></td>
      </tr>
      <tr>
        <td>偏好记忆</td>
        <td style="text-align: right">32/32</td>
        <td style="text-align: right">28/32</td>
        <td><strong>-4</strong></td>
      </tr>
      <tr>
        <td>数值更新</td>
        <td style="text-align: right">12/32</td>
        <td style="text-align: right">27/32</td>
        <td><strong>+15</strong></td>
      </tr>
      <tr>
        <td>单轮算术</td>
        <td style="text-align: right">8/32</td>
        <td style="text-align: right">21/32</td>
        <td><strong>+13</strong></td>
      </tr>
      <tr>
        <td>总体</td>
        <td style="text-align: right">84/128</td>
        <td style="text-align: right">97/128</td>
        <td>+13</td>
      </tr>
    </tbody>
  </table>
</div>
<p>原始模型在名字和偏好样本上全部正确，v1 却在相同输入上退化。这不能简单解释为验证集分布不同，而是全参数训练在获得新行为时干扰了旧行为，符合局部灾难性遗忘的表现。</p>
<p>另一个重要事实是：<strong>v1 的最终 train loss 已降到 0.616，但训练集逐条生成仍只有 97/128 综合通过。</strong> 平均 token loss 与行为成功不是同一个指标。</p>
<h2 id="八v2减少训练量恢复新旧能力的平衡">八、v2：减少训练量，恢复新旧能力的平衡</h2>
<h3 id="1-干预方式与训练结果">1. 干预方式与训练结果</h3>
<p>在数据、Batch、学习率峰值、随机种子等保持不变的前提下，将 <code>n_epochs</code> 从 2 改为 1：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">optimization steps = 32
</span></span><span class="line"><span class="cl">warmup_steps = 3
</span></span><span class="line"><span class="cl">final train loss = 1.104157
</span></span><span class="line"><span class="cl">final full val loss = 1.021104
</span></span><span class="line"><span class="cl">checkpoint reload = passed
</span></span></code></pre></div><p>严格来说，修改 <code>n_epochs</code> 后，总步数、warmup 步数和学习率衰减过程都发生了变化。因此这是一组训练量与调度对照，不能把全部差异只归因于 epoch 数。</p>
<h3 id="2-原始模型v1v2-的独立验证对照">2. 原始模型、v1、v2 的独立验证对照</h3>
<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">v1：2 epochs</th>
        <th style="text-align: right">v2：1 epoch</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>综合通过</td>
        <td style="text-align: right">19/32</td>
        <td style="text-align: right">24/32</td>
        <td style="text-align: right"><strong>30/32</strong></td>
      </tr>
      <tr>
        <td>内容正确</td>
        <td style="text-align: right">25/32</td>
        <td style="text-align: right">24/32</td>
        <td style="text-align: right"><strong>30/32</strong></td>
      </tr>
      <tr>
        <td>格式合规</td>
        <td style="text-align: right">24/32</td>
        <td style="text-align: right">31/32</td>
        <td style="text-align: right"><strong>31/32</strong></td>
      </tr>
      <tr>
        <td>名字记忆</td>
        <td style="text-align: right">8/8</td>
        <td style="text-align: right">3/8</td>
        <td style="text-align: right"><strong>7/8</strong></td>
      </tr>
      <tr>
        <td>数值更新</td>
        <td style="text-align: right">2/8</td>
        <td style="text-align: right">7/8</td>
        <td style="text-align: right"><strong>7/8</strong></td>
      </tr>
      <tr>
        <td>偏好记忆</td>
        <td style="text-align: right">7/8</td>
        <td style="text-align: right">7/8</td>
        <td style="text-align: right"><strong>8/8</strong></td>
      </tr>
      <tr>
        <td>单轮算术</td>
        <td style="text-align: right">2/8</td>
        <td style="text-align: right">7/8</td>
        <td style="text-align: right"><strong>8/8</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<p>最重要的现象是：<strong>v2 的 val loss 比 v1 更高，行为表现却显著更好。</strong> 这直接说明，不能只凭平均 token loss 判断后训练是否更好。</p>
<h3 id="3-六条冻结基线全部通过">3. 六条冻结基线全部通过</h3>
<p>v2 在最初六条基线上的结果为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">passed = 6/6
</span></span><span class="line"><span class="cl">answer_correct = 6/6
</span></span><span class="line"><span class="cl">format_compliant = 6/6
</span></span><span class="line"><span class="cl">copied_previous_assistant = 0
</span></span><span class="line"><span class="cl">natural_stop = 6/6
</span></span><span class="line"><span class="cl">empty = 0
</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">名字：小吕。
</span></span><span class="line"><span class="cl">颜色：蓝色。
</span></span><span class="line"><span class="cl">苹果更新：30
</span></span><span class="line"><span class="cl">25 * 24：600
</span></span><span class="line"><span class="cl">123 + 789：912
</span></span><span class="line"><span class="cl">17 + 5：22
</span></span></code></pre></div><p>全部自然结束，没有精确复制旧回答。</p>
<h3 id="4-v2-仍有两个失败样例">4. v2 仍有两个失败样例</h3>
<p>32 条独立验证中仍有两条失败：</p>
<ul>
<li>数值更新第 01 条：期望 <code>7</code>，模型只生成 1 个 token 就 EOS，形成空回答；</li>
<li>名字记忆第 29 条：期望“小棉”，模型回答“你。”，生成 3 个 token 后停止。</li>
</ul>
<p>所以 v2 是当前最佳，不是全样本正确，也不是所有行为问题都已解决。</p>
<h2 id="九这一轮得到的结论">九、这一轮得到的结论</h2>
<h3 id="1-多轮-sft-首先是数据契约问题">1. 多轮 SFT 首先是数据契约问题</h3>
<p>不是把多轮文本拼起来就算完成。必须明确每轮角色、正文、结束标记和错位 target 的关系，否则模型可能在错误的文本上接受训练。</p>
<h3 id="2-格式行为通常比数值能力更容易学到">2. 格式行为通常比数值能力更容易学到</h3>
<p>v1、v2 都很快提升了“只输出数字”的格式遵循，但算术正确性并未同步提升，部分题目还发生回退。loss 下降不能直接解释为推理能力增强。</p>
<h3 id="3-全参数训练会同时产生收益与干扰">3. 全参数训练会同时产生收益与干扰</h3>
<p>v1 在数值更新和格式上明显收益，却损害了原本稳定的名字与偏好回答。后训练需要同时评估新任务收益和旧能力保持。</p>
<h3 id="4-行为评测必须独立于训练-loss">4. 行为评测必须独立于训练 loss</h3>
<p>本轮最关键的证据是：v2 的 val loss 更高，行为却更好。只优化 loss，无法发现这种新旧能力冲突。</p>
<h3 id="5-评测器本身也需要回归测试">5. 评测器本身也需要回归测试</h3>
<p>contains 误判、格式与正确性混淆、history 共享引用，都曾制造假结论。训练实验必须保留原始回答、评分规则和报告版本，不能只保存一个最终分数。</p>
<h2 id="十当前停止边界">十、当前停止边界</h2>
<p>当前只完成 I4-B 的受控多轮 SFT 闭环：</p>
<ul>
<li>v2 是本轮最佳 checkpoint；</li>
<li>不能据此宣称开放域多轮对话能力；</li>
<li>不能据此宣称 1 epoch 普遍优于 2 epochs；</li>
<li>尚未完成真实多轮语料、LoRA / 全参对照、CoT-SFT、DPO 或 GRPO；</li>
<li>名字和偏好类的核心实体包含规则仍是弱语义评测，后续需要更可靠的评估校准。</li>
</ul>
<p>下一步进入 I4-C 时，需要先想清楚：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">&lt;think&gt; 中的推理过程是否参与 loss？
</span></span><span class="line"><span class="cl">如何分别定位思考区间与正式回答区间？
</span></span><span class="line"><span class="cl">thinking 与正文的 token 预算如何计算？
</span></span><span class="line"><span class="cl">如何判断思考质量，而不只是判断输出格式？
</span></span></code></pre></div><p>这一轮的主干已经搭起来了：<strong>数据契约、训练、checkpoint、独立行为评测、回退分析和干预对照。</strong> 后面新增 CoT、DPO 或其他方法，都应该在这套基线上继续做局部进化。</p>
<h2 id="主要实验产物">主要实验产物</h2>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">src/squid/data/chat_sft.py
</span></span><span class="line"><span class="cl">scripts/i4_qwen_multiturn_template_probe.py
</span></span><span class="line"><span class="cl">scripts/i4_qwen_multiturn_span_probe.py
</span></span><span class="line"><span class="cl">scripts/i4_behavior_baseline.py
</span></span><span class="line"><span class="cl">scripts/i4_synthetic_data_audit.py
</span></span><span class="line"><span class="cl">scripts/i4_multiturn_sft_train.py
</span></span><span class="line"><span class="cl">scripts/i4_synthetic_behavior_eval.py
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">data/reports/i4-qwen3-0_6b-behavior-baseline-v3.json
</span></span><span class="line"><span class="cl">data/reports/i4-multiturn-sft-v1-training.json
</span></span><span class="line"><span class="cl">data/reports/i4-multiturn-sft-v2-1epoch-training.json
</span></span><span class="line"><span class="cl">data/reports/i4-synthetic-val-original.json
</span></span><span class="line"><span class="cl">data/reports/i4-multiturn-sft-v1-synthetic-val.json
</span></span><span class="line"><span class="cl">data/reports/i4-multiturn-sft-v2-1epoch-synthetic-val.json
</span></span><span class="line"><span class="cl">data/reports/i4-multiturn-sft-v2-1epoch-behavior-v3.json
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">data/model_pth/qwen3/i4-multiturn-sft-v1.pth
</span></span><span class="line"><span class="cl">data/model_pth/qwen3/i4-multiturn-sft-v2-1epoch.pth
</span></span></code></pre></div>]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 22：Qwen3 兼容性</title>
      <link>https://blog.lvxinrong.com/llm/llm-22-qwen3-compatibility/</link>
      <pubDate>Thu, 12 Nov 2026 00:00:00 +0000</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-22-qwen3-compatibility/</guid>
      <description>从 config 与 safetensors 审计出发，从零实现隔离的 V4 / Qwen3-0.6B，完成官方前向、cache decode、固定生成和本地对话验收，并复盘流式渲染、增量解码与 token 上限问题。</description>
      <content:encoded><![CDATA[<p>这篇是 I3 的独立番外，起点不是“再写一个模型”，而是一个可复用的问题：<strong>面对一个陌生模型，怎样判断当前代码能否加载、能否正确前向、还缺哪些能力？</strong></p>
<p>当前真实状态是：V3 继续作为 Qwen2.5-0.5B / 0.5B-Instruct 的稳定对照；独立实现的 V4 已承接 Qwen3-0.6B，并通过官方前向、连续 cache decode、固定生成和本地对话验收。本文保留从兼容性审计到流式对话排障的完整过程，不把单个模型与受控环境的结果扩大为全系列支持。</p>
<h2 id="一为什么先学兼容性审计">一、为什么先学兼容性审计</h2>
<p><code>config.json</code> 是了解模型的第一入口，但“有 config”不等于“可以直接加载”。完整的判断链路是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">模型家族与 config
</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">→ 官方 logits 对照
</span></span><span class="line"><span class="cl">→ cache decode 与固定生成验收
</span></span></code></pre></div><p>这套方法以后面对 Llama、Mistral 或其他模型也适用，不只服务 Qwen3。</p>
<h2 id="二qwen3-06b-的配置地图">二、Qwen3-0.6B 的配置地图</h2>
<p>当前目标模型的关键配置是：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>配置</th>
        <th style="text-align: right">当前值</th>
        <th>对我们意味着什么</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><code>model_type</code></td>
        <td style="text-align: right"><code>qwen3</code></td>
        <td>不是当前已验证的 Qwen2.5 家族</td>
      </tr>
      <tr>
        <td><code>vocab_size</code></td>
        <td style="text-align: right">151936</td>
        <td>与当前 Qwen2.5 词表一致</td>
      </tr>
      <tr>
        <td><code>hidden_size</code></td>
        <td style="text-align: right">1024</td>
        <td>对应我们的 <code>emb_dim</code></td>
      </tr>
      <tr>
        <td><code>intermediate_size</code></td>
        <td style="text-align: right">3072</td>
        <td>对应我们的 <code>ffn_dim</code></td>
      </tr>
      <tr>
        <td><code>num_hidden_layers</code></td>
        <td style="text-align: right">28</td>
        <td>28 个 Transformer Block</td>
      </tr>
      <tr>
        <td><code>num_attention_heads</code></td>
        <td style="text-align: right">16</td>
        <td>16 个 Q heads</td>
      </tr>
      <tr>
        <td><code>num_key_value_heads</code></td>
        <td style="text-align: right">8</td>
        <td>8 个 KV heads，使用 GQA</td>
      </tr>
      <tr>
        <td><code>head_dim</code></td>
        <td style="text-align: right">128</td>
        <td>每个 attention head 的维度</td>
      </tr>
      <tr>
        <td><code>rope_theta</code></td>
        <td style="text-align: right">1000000</td>
        <td>与当前 Qwen2.5 配置一致</td>
      </tr>
      <tr>
        <td><code>rms_norm_eps</code></td>
        <td style="text-align: right">1e-6</td>
        <td>RMSNorm 的 epsilon</td>
      </tr>
      <tr>
        <td><code>attention_bias</code></td>
        <td style="text-align: right">false</td>
        <td>Q/K/V 等投影不使用 bias</td>
      </tr>
      <tr>
        <td><code>tie_word_embeddings</code></td>
        <td style="text-align: right">true</td>
        <td>embedding 与输出头共享权重</td>
      </tr>
      <tr>
        <td><code>max_position_embeddings</code></td>
        <td style="text-align: right">40960</td>
        <td>配置允许的位置范围，不等于本轮实际上下文</td>
      </tr>
      <tr>
        <td><code>use_sliding_window</code></td>
        <td style="text-align: right">false</td>
        <td>当前最小目标不需要 sliding attention</td>
      </tr>
      <tr>
        <td><code>hidden_act</code></td>
        <td style="text-align: right"><code>silu</code></td>
        <td>FFN 的 gate 分支使用 SiLU，与当前实现一致</td>
      </tr>
    </tbody>
  </table>
</div>
<p>其中最容易被直接套公式误导的是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">hidden_size = 1024
</span></span><span class="line"><span class="cl">num_attention_heads = 16
</span></span><span class="line"><span class="cl">head_dim = 128
</span></span></code></pre></div><p>当前 v3 使用 <code>emb_dim / n_heads</code>，会得到 64，而 Qwen3 真实配置要求 128。因此 V4 必须允许 <code>head_dim</code> 与 <code>emb_dim</code> 解耦，不能只改配置数字。</p>
<p>另外，官方 Qwen3 forward 中还存在 <strong>QK RMSNorm</strong>：Q/K 投影后、RoPE 前分别归一化。这个结构差异不能只靠 config 猜，需要同时阅读官方实现和实际权重键。</p>
<h2 id="三v3-与-v4-必须完全隔离">三、V3 与 V4 必须完全隔离</h2>
<p>为了保留稳定的 Qwen2.5 对照实现，约定：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">src/squid/model/v3_modern/    保持现状
</span></span><span class="line"><span class="cl">src/squid/model/v4_qwen3/     V4 独立结构、RoPE、归一化和 attention
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">src/squid/checkpoints/qwen.py   V3 / Qwen2.5 加载器
</span></span><span class="line"><span class="cl">src/squid/checkpoints/qwen3.py  V4 / Qwen3 独立加载器
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">tests/test_qwen/   V3 回归
</span></span><span class="line"><span class="cl">tests/test_qwen3/  V4 独立验收
</span></span></code></pre></div><p>V4 最终没有复制或引用 V3 的模型实现，而是把 RMSNorm、SwiGLU、RoPE、Attention、TransformerBlock 和 GPTModel 重新写了一遍。这样每个版本都必须亲自过一遍，理解架构差异，而不是把“复用”误当成“掌握”；封板之后的工程复用是另一阶段的问题。RMSNorm 保留 FP32 累积、输入输出 dtype 一致的修复，避免重新引入 FP16 平方溢出。</p>
<p>公共 device、tokenizer 协议和报告工具可以复用；模型结构、权重映射和验收保持隔离。</p>
<h2 id="四兼容性审计清单">四、兼容性审计清单</h2>
<p>面对一个新模型时，按以下顺序判断：</p>
<ol>
<li><strong>模型家族</strong>：<code>model_type</code>、<code>architectures</code> 是否属于当前支持范围；</li>
<li><strong>结构配置</strong>：hidden size、层数、heads、KV heads、head_dim、RoPE、bias、权重绑定；</li>
<li><strong>权重键</strong>：是否存在当前映射无法处理的键，是否有独立 <code>lm_head.weight</code>；</li>
<li><strong>张量形状</strong>：权重形状是否与配置一致；</li>
<li><strong>checkpoint 形式</strong>：单文件还是多分片，格式是否可读取；</li>
<li><strong>tokenizer</strong>：词表、EOS / BOS、chat template 和特殊 token；</li>
<li><strong>官方语义</strong>：norm、RoPE、掩码、残差与输出头是否一致；</li>
<li><strong>数值验收</strong>：官方 logits、prefill、cache decode 和固定生成对照。</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">能加载权重
</span></span><span class="line"><span class="cl">≠ 能正确前向
</span></span><span class="line"><span class="cl">≠ 能正确对话
</span></span></code></pre></div><h2 id="五modelv4-的最小目标">五、ModelV4 的最小目标</h2>
<p>第一版只做：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">显式 head_dim
</span></span><span class="line"><span class="cl">+ QK RMSNorm
</span></span><span class="line"><span class="cl">+ Qwen3 配置与权重映射
</span></span><span class="line"><span class="cl">+ V3 / V4 完全隔离
</span></span></code></pre></div><p>最小验收模型为 <strong>Qwen3-0.6B Dense</strong>。暂不承诺：</p>
<ul>
<li>Qwen3 全系列；</li>
<li>Qwen3 MoE；</li>
<li>GGUF / NVFP4；</li>
<li>27B 模型加载；</li>
<li>尚未执行的下载、前向或硬件验证结果。</li>
</ul>
<h2 id="六前一晚的停止边界">六、前一晚的停止边界</h2>
<p>前一晚先读懂 <code>config.json</code>、兼容性审计顺序和 V3 / V4 的隔离原则，没有立即开始 V4 实现。</p>
<p>不熬夜，不通宵。结构实现、权重键审计和官方数值对照留给后续学习日；后面的章节记录这些工作的实际完成情况。</p>
<h3 id="1--qwen3-06b-configjson">1.  Qwen3-0.6B config.json</h3>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-json" data-lang="json"><span class="line"><span class="cl"><span class="p">{</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;architectures&#34;</span><span class="p">:</span> <span class="p">[</span>  
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;Qwen3ForCausalLM&#34;</span>  
</span></span><span class="line"><span class="cl">  <span class="p">],</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;attention_bias&#34;</span><span class="p">:</span> <span class="kc">false</span><span class="p">,</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;attention_dropout&#34;</span><span class="p">:</span> <span class="mf">0.0</span><span class="p">,</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;bos_token_id&#34;</span><span class="p">:</span> <span class="mi">151643</span><span class="p">,</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;eos_token_id&#34;</span><span class="p">:</span> <span class="mi">151645</span><span class="p">,</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;head_dim&#34;</span><span class="p">:</span> <span class="mi">128</span><span class="p">,</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;hidden_act&#34;</span><span class="p">:</span> <span class="s2">&#34;silu&#34;</span><span class="p">,</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;hidden_size&#34;</span><span class="p">:</span> <span class="mi">1024</span><span class="p">,</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;initializer_range&#34;</span><span class="p">:</span> <span class="mf">0.02</span><span class="p">,</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;intermediate_size&#34;</span><span class="p">:</span> <span class="mi">3072</span><span class="p">,</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;max_position_embeddings&#34;</span><span class="p">:</span> <span class="mi">40960</span><span class="p">,</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;max_window_layers&#34;</span><span class="p">:</span> <span class="mi">28</span><span class="p">,</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;model_type&#34;</span><span class="p">:</span> <span class="s2">&#34;qwen3&#34;</span><span class="p">,</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;num_attention_heads&#34;</span><span class="p">:</span> <span class="mi">16</span><span class="p">,</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;num_hidden_layers&#34;</span><span class="p">:</span> <span class="mi">28</span><span class="p">,</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;num_key_value_heads&#34;</span><span class="p">:</span> <span class="mi">8</span><span class="p">,</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;rms_norm_eps&#34;</span><span class="p">:</span> <span class="mf">1e-06</span><span class="p">,</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;rope_scaling&#34;</span><span class="p">:</span> <span class="kc">null</span><span class="p">,</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;rope_theta&#34;</span><span class="p">:</span> <span class="mi">1000000</span><span class="p">,</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;sliding_window&#34;</span><span class="p">:</span> <span class="kc">null</span><span class="p">,</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;tie_word_embeddings&#34;</span><span class="p">:</span> <span class="kc">true</span><span class="p">,</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;torch_dtype&#34;</span><span class="p">:</span> <span class="s2">&#34;bfloat16&#34;</span><span class="p">,</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;transformers_version&#34;</span><span class="p">:</span> <span class="s2">&#34;4.51.0&#34;</span><span class="p">,</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;use_cache&#34;</span><span class="p">:</span> <span class="kc">true</span><span class="p">,</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;use_sliding_window&#34;</span><span class="p">:</span> <span class="kc">false</span><span class="p">,</span>  
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;vocab_size&#34;</span><span class="p">:</span> <span class="mi">151936</span>  
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>逐项解读</p>
<p><code>&quot;architectures&quot;: [ &quot;Qwen3ForCausalLM&quot; ]</code>
<code>architectures</code> 的作用是告诉 Hugging Face Transformers 库：加载这个模型时应该实例化哪个 Python 类。这里就是 <code>Qwen3ForCausalLM</code> 这个类。</p>
<p><code>&quot;attention_bias&quot;: false, </code>
注意力层QKV线性投影是否带偏置项</p>
<p><code>&quot;attention_dropout&quot;: 0.0</code>
注意力att层中，用于控制 softmax(att_scores) 之后的dropout的比例。 <code>attn_weights = self.dropout(attn_weights)</code></p>
<p><code>&quot;bos_token_id&quot;: 151643, &quot;eos_token_id&quot;: 151645, </code>
bos  Beginning of Sequence 放在输入开头，告诉模型“文本从这里开始”
eos End of Sequence  模型生成到这个 token 时停止输出</p>
<p><code>&quot;head_dim&quot;: 128,</code>
多头注意力机制下每个头的emb_dim</p>
<p><code>&quot;hidden_act&quot;: &quot;silu&quot;,</code>
FFN 前馈神经网络中 用到的激活函数 FFN中声明了act  <code>self.act = nn.SiLU()</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="s2">&#34;&#34;&#34;  
</span></span></span><span class="line"><span class="cl"><span class="s2">y = down_proj( SiLU(gate_proj(x)) * up_proj(x) )  
</span></span></span><span class="line"><span class="cl"><span class="s2">gate_proj门控信号，SiLU 之后才形成实际的连续开度。  
</span></span></span><span class="line"><span class="cl"><span class="s2">up_proj 升维后的x (B, T, emb_dim) -&gt; (B, T, hidden_dim)  hidden_dim 默认是emb_dim的3倍  
</span></span></span><span class="line"><span class="cl"><span class="s2">down_proj 降维回 (B, T, hidden_dim) -&gt; (B, T, emb_dim)  
</span></span></span><span class="line"><span class="cl"><span class="s2">SwiGLUFFN 相比较之前的 FeedForward 核心是多了一个门阀矩阵。  
</span></span></span><span class="line"><span class="cl"><span class="s2">按照我的理解，这个门阀矩阵是类似一个电阻的装置，允许电流通过大小，也就是hidden_dim每个维度允许通过多少  
</span></span></span><span class="line"><span class="cl"><span class="s2">  
</span></span></span><span class="line"><span class="cl"><span class="s2">但是核心原理和FeedForward不变，依然是在token经过attention 输出后的每个 token 的隐藏表示 做逐位置变换  
</span></span></span><span class="line"><span class="cl"><span class="s2">再更高维度对自身的隐藏表示进行编辑。  
</span></span></span><span class="line"><span class="cl"><span class="s2">阀门也就是在维度升高之后，增加了一个可以由模型自行通过学习修改阀门流量的开关。可以决定这些信息哪些值得保留，放大或者压下去。  
</span></span></span><span class="line"><span class="cl"><span class="s2">SwiGLU FFN 在升维后，是用 gate_proj 单独生成一路门控信号，经 SiLU 变成每个 hidden 维度的连续开度，再与 up_proj 的内容逐元素相乘。这个开度可学习、可大于 1、可接近 0、也可为负，因此模型能逐维度决定信息保留、放大、压制甚至反向。  
</span></span></span><span class="line"><span class="cl"><span class="s2">&#34;&#34;&#34;</span>  
</span></span><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="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">down_proj</span><span class="p">(</span>  
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">act</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">gate_proj</span><span class="p">(</span><span class="n">x</span><span class="p">))</span> <span class="o">*</span> <span class="bp">self</span><span class="o">.</span><span class="n">up_proj</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>  
</span></span><span class="line"><span class="cl">    <span class="p">)</span>
</span></span></code></pre></div><p><code>&quot;hidden_size&quot;: 1024</code>
其实就是emb_dim 但是Qwen3的设计上，说是<code>让注意力头的维度独立于隐藏层大小，调参更灵活</code>
那原本16个头，每个头dim是128 一共是 2048。那我猜测输入可能是 2048 然后输出的时候，在out_proj的声明上，可以是 (2048, 1024) 就可以实现降维。</p>
<p><code>&quot;initializer_range&quot;: 0.02,</code>
权重初始化时用的<strong>正态分布标准差</strong>。模型创建时，所有线性层和 embedding 的权重按 <code>N(0, 0.02)</code> 随机初始化</p>
<p><code>intermediate_size&quot;: 3072</code>
FFN中升维的维度，那Qwen3 看起来就是 1024 -&gt; 3072 -&gt; 1024了</p>
<p><code>&quot;max_position_embeddings&quot;: 40960,</code>
这个不是指位置编码(RoPE是相对位置，没有max一说)
<code>max_position_embeddings</code> 在 RoPE 模型里含义变了:  <strong>模型支持的最大序列长度</strong>(也就是经常看到的模型上下文大小) 所以这个模型上下文大小就是40K</p>
<p><code>&quot;max_window_layers&quot;: 28, </code>
滑动窗口注意力（Sliding Window Attention）目前还没有学到，相关的配置是 <code>&quot;sliding_window&quot;: null,</code>  <code>use_sliding_window</code> 就是滑动窗口的总开关</p>
<p><code>&quot;num_attention_heads&quot;: 16,</code>
多头注意力机制中头的数量，因为GQA的架构中 KV的头是少于Q的，所以这里也就特指Q_head_nums</p>
<p><code>&quot;num_hidden_layers&quot;: 28, &quot;</code>
LLM中一共有多少层 trf_block (一个trf_block 包含1个att和一个ffn)</p>
<p><code>&quot;num_key_value_heads&quot;: 8, </code>
多头注意力机制中 KV的头数量，一般小于Q的头数量。等于 Q 头数时就是标准 MHA，等于 1 时是 MQA（Multi-Query Attention），介于两者之间就是 GQA。</p>
<p><code>&quot;rms_norm_eps&quot;: 1e-06,</code>
RMSNorm中防止除0用的，一般设置的会很小 <code>eps=1e-6</code> 防止分母为 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="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 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 class="n">dim</span> <span class="o">=</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="c1"># 就在这里使用</span>
</span></span><span class="line"><span class="cl">    <span class="n">y</span> <span class="o">=</span> <span class="n">x_float</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 class="o">.</span><span class="n">float</span><span class="p">()</span>  
</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>torch.rsqrt(mean_square + self.eps)  等价于 1 / sqrt(mean(x²) + eps)</p>
<p><code>&quot;rope_theta&quot;: 1000000,</code>
<code>rope_theta</code> 是计算各维度旋转频率的<strong>底数（base）</strong></p>
<pre tabindex="0"><code>第 i 对维度的频率: θ_i = 1 / (rope_theta^(2i/d))
位置 m 的旋转角度: m × θ_i
</code></pre><p>所以 rope_theta 越大 → 各维度频率越低 → 每步旋转角度越小 → 相邻位置的区分度更“细腻”，影响位置频率分布与长距离行为</p>
<p><code>&quot;tie_word_embeddings&quot;: true,</code>
输入 embedding（token → 向量）和输出 lm_head（向量 → vocab logits）共用同一个权重矩阵（互为转置）
对小模型来说可以节约参数。当前模型可以节约 vocab_size × hidden_size 151936 × 1024 大概 1.55亿参数量</p>
<p><code>&quot;torch_dtype&quot;:&quot;bfloat16&quot; </code>
torch加载权重使用的精度类型，看起来是BF16(BF16 指数位多，<strong>尾数位少</strong>，所以可表达的数据范围大，但精度低) 动态范围和 FP32 一样大</p>
<p><code>&quot;use_cache&quot;: true,</code>
开启kv cache的开关</p>
<p><code>&quot;vocab_size&quot;: 151936</code>
词表大小</p>
<h2 id="七权重审计从文件不可直接阅读到可复用检查能力">七、权重审计：从“文件不可直接阅读”到可复用检查能力</h2>
<p>Safetensors 是二进制格式，不能像 Markdown 或 JSON 一样直接阅读。但这个能力不应该只停留在某次 Qwen3 实验的临时命令里，因此新增：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">src/squid/checkpoints/inspect.py
</span></span></code></pre></div><p><code>inspect_safetensors()</code> 使用 <code>safe_open()</code> 读取：</p>
<ul>
<li>权重键名称；</li>
<li>张量形状；</li>
<li>dtype；</li>
<li>元素数量；</li>
<li>文件字节数与权重键总数。</li>
</ul>
<p>它只读取元数据，不加载完整模型权重，适用于后续其他模型的兼容性审计。用户已添加最小回归并实际运行，结果为 <strong>1 passed</strong>。</p>
<h3 id="1-qwen3-06b-的真实权重证据">1. Qwen3-0.6B 的真实权重证据</h3>
<p>当前本地 Qwen3-0.6B 文件：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">文件大小：1,503,300,328 bytes
</span></span><span class="line"><span class="cl">权重键数量：311
</span></span><span class="line"><span class="cl">文件中的总元素数：751,632,384
</span></span><span class="line"><span class="cl">主要 dtype：BF16
</span></span></code></pre></div><p>第 0 层的真实形状为：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>权重</th>
        <th>形状</th>
        <th>结构含义</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><code>q_proj.weight</code></td>
        <td><code>[2048, 1024]</code></td>
        <td>16 个 Q heads × 128 head_dim</td>
      </tr>
      <tr>
        <td><code>k_proj.weight</code></td>
        <td><code>[1024, 1024]</code></td>
        <td>8 个 KV heads × 128 head_dim</td>
      </tr>
      <tr>
        <td><code>v_proj.weight</code></td>
        <td><code>[1024, 1024]</code></td>
        <td>与 K 对称</td>
      </tr>
      <tr>
        <td><code>o_proj.weight</code></td>
        <td><code>[1024, 2048]</code></td>
        <td>将 2048 维 attention 结果降回 1024 维隐藏状态</td>
      </tr>
      <tr>
        <td><code>q_norm.weight</code></td>
        <td><code>[128]</code></td>
        <td>每个 head 内部的 Q 归一化</td>
      </tr>
      <tr>
        <td><code>k_norm.weight</code></td>
        <td><code>[128]</code></td>
        <td>每个 head 内部的 K 归一化</td>
      </tr>
      <tr>
        <td><code>input_layernorm.weight</code></td>
        <td><code>[1024]</code></td>
        <td>隐藏状态归一化</td>
      </tr>
      <tr>
        <td><code>post_attention_layernorm.weight</code></td>
        <td><code>[1024]</code></td>
        <td>隐藏状态归一化</td>
      </tr>
    </tbody>
  </table>
</div>
<p>这与 config 中 <code>hidden_size=1024</code>、<code>head_dim=128</code> 相互印证：<strong>head_dim 不再由 hidden_size / heads 自动得到，Q/K/V 与输出投影的形状都围绕显式 head_dim 组织。</strong></p>
<h3 id="2-一个不能靠-config-猜测的-lm_head-细节">2. 一个不能靠 config 猜测的 lm_head 细节</h3>
<p>配置中写着：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-json" data-lang="json"><span class="line"><span class="cl"><span class="s2">&#34;tie_word_embeddings&#34;</span><span class="err">:</span> <span class="kc">true</span>
</span></span></code></pre></div><p>第一版探针因此假设文件里不会有独立 <code>lm_head.weight</code>，结果实际检查为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">no_independent_lm_head = false
</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">model.embed_tokens.weight
</span></span><span class="line"><span class="cl">lm_head.weight
</span></span></code></pre></div><p>这时不能直接忽略 <code>lm_head.weight</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">embedding：shape=[151936, 1024]，dtype=BF16
</span></span><span class="line"><span class="cl">lm_head：  shape=[151936, 1024]，dtype=BF16
</span></span><span class="line"><span class="cl">torch.equal(...) = True
</span></span><span class="line"><span class="cl">最大绝对差 = 0.0
</span></span></code></pre></div><p>因此可以确认：checkpoint 虽然重复保存了输出头，但两份权重完全相同。V4 在加载后使用一份共享参数是安全的。</p>
<p>去掉这份重复输出头后：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">751,632,384 - 155,582,464 = 596,049,920
</span></span></code></pre></div><p>约为 <strong>5.96 亿元素</strong>，与 0.6B 的模型命名数量级一致。这也说明模型名称、文件大小和实际加载后的独立参数量不能直接画等号。</p>
<h3 id="3-当前兼容性坐标">3. 当前兼容性坐标</h3>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>能力</th>
        <th>当前判断</th>
        <th>验收或边界</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>配置字段映射</td>
        <td>V4 已独立实现</td>
        <td>由官方前向与生成对照验收</td>
      </tr>
      <tr>
        <td>显式 head_dim</td>
        <td>V4 已新增</td>
        <td><code>head_dim=128</code>，不再用 <code>hidden_size / heads</code> 推导</td>
      </tr>
      <tr>
        <td>QK RMSNorm</td>
        <td>V4 已新增并映射权重</td>
        <td>投影后、RoPE 前执行</td>
      </tr>
      <tr>
        <td>attention_bias=false</td>
        <td>已进入 V4 配置</td>
        <td>不沿用 Qwen2.5 的 QKV bias</td>
      </tr>
      <tr>
        <td>embedding / lm_head 共享</td>
        <td>两份实际权重已证明相等</td>
        <td>加载后只保留一份共享参数</td>
      </tr>
      <tr>
        <td>Sliding attention</td>
        <td>当前模型未启用</td>
        <td>最小 V4 不实现</td>
      </tr>
      <tr>
        <td>BF16</td>
        <td>已有支持</td>
        <td>保留 RMSNorm FP32 累积修复</td>
      </tr>
      <tr>
        <td>正确前向 / 对话</td>
        <td>已在当前受控条件通过</td>
        <td>见第八、九节；不扩大为全系列支持</td>
      </tr>
    </tbody>
  </table>
</div>
<p>早期总兼容性探针曾因独立 <code>lm_head</code> 的假设返回 <code>all_metadata_checks_passed=false</code>；随后的真实权重比较与 V4 官方对照已经关闭这个疑问，不把早期探针状态误写成当前失败状态。</p>
<p>这次最值得保留的经验是：</p>
<blockquote>
<p><strong>Config 描述的是模型的结构意图，checkpoint 则决定实际如何存储。两者出现表面不一致时，不直接忽略字段，也不立即判定模型异常，而是用真实权重形状和数值证明是否可以安全映射。</strong></p>
</blockquote>
<h2 id="八v4-官方数值与生成验收通过">八、V4 官方数值与生成验收通过</h2>
<p>ModelV4 从零实现了 RMSNorm、SwiGLU FFN、RoPE、Qwen3Attention、TransformerBlock 和 GPTModelV4，没有复制或引用 V3 的模型实现。独立加载器使用 <code>checkpoints/qwen3.py</code>，测试位于 <code>tests/test_qwen3/</code>。</p>
<h3 id="1-真实权重前向对照">1. 真实权重前向对照</h3>
<p>使用本地 Qwen3-0.6B、CPU、FP32、固定英文 prompt：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">V4 输出形状：     (1, 6, 151936)
</span></span><span class="line"><span class="cl">官方输出形状：    (1, 6, 151936)
</span></span><span class="line"><span class="cl">最大 logit 差异：4.1008e-05
</span></span><span class="line"><span class="cl">平均 logit 差异：4.3524e-06
</span></span><span class="line"><span class="cl">allclose(1e-4)： true
</span></span><span class="line"><span class="cl">top-1 一致：     true
</span></span><span class="line"><span class="cl">全部有限：       true
</span></span></code></pre></div><p>这验证了显式 head_dim、QK RMSNorm、GQA、RoPE、权重共享和独立映射在当前受控条件下成立。</p>
<h3 id="2-连续-cache-decode">2. 连续 cache decode</h3>
<p>V4 与官方连续执行三次单 token cache decode：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>Step</th>
        <th style="text-align: right">V4 token</th>
        <th style="text-align: right">官方 token</th>
        <th>是否一致</th>
        <th>allclose(1e-4)</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>1</td>
        <td style="text-align: right">264</td>
        <td style="text-align: right">264</td>
        <td>是</td>
        <td>是</td>
      </tr>
      <tr>
        <td>2</td>
        <td style="text-align: right">8544</td>
        <td style="text-align: right">8544</td>
        <td>是</td>
        <td>是</td>
      </tr>
      <tr>
        <td>3</td>
        <td style="text-align: right">429</td>
        <td style="text-align: right">429</td>
        <td>是</td>
        <td>是</td>
      </tr>
    </tbody>
  </table>
</div>
<h3 id="3-固定贪心生成">3. 固定贪心生成</h3>
<p>两边固定生成 8 个 token：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">V4：    264, 8544, 429, 702, 40444, 23839, 11004, 323
</span></span><span class="line"><span class="cl">官方：  264, 8544, 429, 702, 40444, 23839, 11004, 323
</span></span></code></pre></div><p>生成长度、token IDs 和文本均完全一致：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">a topic that has sparked considerable debate and
</span></span></code></pre></div><p>因此当前最小目标可以正式验收：<strong>V4 不只是能加载 Qwen3 权重，还能在 CPU / FP32 / eager 下完成正确的 prefill、连续 cache decode 和固定贪心生成。</strong></p>
<p>这组数值结论仍限定于当前输入、CPU / FP32 / eager，不扩大为所有设备、dtype 或 Qwen3 全系列均已通过；chat template 与 thinking 的本地对话验收另见第九节。MoE 与其他模型格式不在本次验收范围内。</p>
<h2 id="九qwen3-对话服务思考开关与思考区分离">九、Qwen3 对话服务：思考开关与思考区分离</h2>
<p>V4 数值验收通过后，<code>chat_server</code> 与 Web UI 已从 V3 / Qwen2.5-0.5B 切换到 V4 / Qwen3-0.6B。当前使用的是 <code>Qwen/Qwen3-0.6B</code> 后训练对话模型，不是 <code>Qwen3-0.6B-Base</code>。</p>
<h3 id="1-思考模式真正进入模板">1. 思考模式真正进入模板</h3>
<p><code>build_qwen_chat_prompt()</code> 新增可选的 <code>enable_thinking</code> 参数，服务端将页面开关随请求传入：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">enable_thinking=true
</span></span><span class="line"><span class="cl">→ 使用 Qwen3 默认的 thinking 生成路径
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">enable_thinking=false
</span></span><span class="line"><span class="cl">→ chat template 加入空的 &lt;think&gt;...&lt;/think&gt; 区域，引导模型直接回答
</span></span></code></pre></div><p>该参数是模板控制，不是 V4 新增了一套推理算法。V4 负责执行模型，模型负责是否生成思考内容。</p>
<p>模板 stub 测试与流式、会话相关测试合计 <strong>13 passed</strong>，JavaScript 语法检查通过。</p>
<h3 id="2-页面将思考与正式回答分离">2. 页面将思考与正式回答分离</h3>
<p>新增 <code>&lt;details&gt;</code> 思考区：</p>
<ul>
<li>标题为“思考过程”；</li>
<li>默认折叠，点击可展开；</li>
<li>流式过程中可以展开观察；</li>
<li>正式回答使用独立区域，不再把 <code>&lt;think&gt;</code> 当普通正文；</li>
<li>历史恢复与多会话切换继续使用同一套分离渲染；</li>
<li>页面底部新增“思考模式”复选框，生成时禁用切换，避免请求中途改变模板状态。</li>
</ul>
<h3 id="3-真实浏览器验收">3. 真实浏览器验收</h3>
<p>开启思考模式，输入 <code>2+2 等于几？</code>：</p>
<ul>
<li>页面出现可折叠的“思考过程”；</li>
<li>思考区与正式回答分离；</li>
<li>正式答案为“2加2等于4。”；</li>
<li>折叠与展开均正常；</li>
<li>SSE 流式状态、TURN 计数和会话列表正常。</li>
</ul>
<p>关闭思考模式并新建会话，输入 <code>3+3 等于几？</code>：</p>
<ul>
<li>没有思考区；</li>
<li>直接返回“3 + 3 等于 6。”；</li>
<li>新建会话与流式输出仍正常。</li>
</ul>
<p>当时观察到回答中偶尔出现 ``，尚未完成归因。后续对照服务端历史与流式页面，才确认其中至少有一类来自增量解码，而不是模型真的输出了乱码；详细定位见第十节。</p>
<h2 id="十流式对话排障顺序增量解码与生成预算">十、流式对话排障：顺序、增量解码与生成预算</h2>
<p>对话页面接通以后，真正暴露的问题不再只是模型结构，而是<strong>连续事件如何被转换成稳定的用户界面</strong>。今天修复了三个不同层级的问题，它们表面上都像“页面显示不对”，实际根因完全不同。</p>
<h3 id="1-思考过程为什么跑到正文下面">1. 思考过程为什么跑到正文下面</h3>
<p>流式渲染函数分别维护 <code>.thinking-details</code> 和 <code>.assistant-answer</code>。旧逻辑在思考节点不存在时直接 <code>appendChild(details)</code>：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">正文节点先创建
</span></span><span class="line"><span class="cl">→ 思考节点随后出现
</span></span><span class="line"><span class="cl">→ appendChild 把思考节点追加到正文后面
</span></span></code></pre></div><p>这解释了为什么思考结束后，正文开始生成，思考区反而位于正文下方。修复不是调整 CSS，而是明确 DOM 顺序：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-javascript" data-lang="javascript"><span class="line"><span class="cl"><span class="nx">container</span><span class="p">.</span><span class="nx">insertBefore</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">  <span class="nx">details</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">container</span><span class="p">.</span><span class="nx">querySelector</span><span class="p">(</span><span class="s1">&#39;.assistant-answer&#39;</span><span class="p">),</span>
</span></span><span class="line"><span class="cl"><span class="p">);</span>
</span></span></code></pre></div><p>即使正文节点先生成，思考区也始终插入正文之前。使用“你好，请介绍一下 LLM 中的注意力机制”做真实浏览器验收，确认<strong>正文流式生成过程中和生成结束后</strong>，思考区都位于上方；折叠、展开与最终 Markdown 渲染保持正常。</p>
<h3 id="2--不是页面编码问题而是不稳定前缀被提前推送">2. `` 不是页面编码问题，而是不稳定前缀被提前推送</h3>
<p>当时页面出现：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">结：
</span></span></code></pre></div><p>但服务端 <code>/session/history</code> 中保存的最终回答是正常的：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">总结：
</span></span></code></pre></div><p>这组对照非常关键：如果最终历史正确、只有流式页面错误，就应优先检查增量链路，而不是怀疑模型权重或 HTML 的 UTF-8 声明。</p>
<p><code>ChatSession.ask_stream()</code> 的策略是每得到一个 token，就重新解码全部 <code>generated_ids</code>，再按上一次文本长度截取 delta。旧逻辑隐含了一个不总成立的假设：<strong>上次解码文本永远是这次解码文本的稳定前缀。</strong></p>
<p>当末尾汉字所需的字节或 token 尚未到齐时，中间解码可能临时以 `` 结尾：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">上一次：...
</span></span><span class="line"><span class="cl">这一次：...总结
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">旧 delta = response[len(previous_response):]
</span></span><span class="line"><span class="cl">结果只发出“结”，而之前的“”已经推送给页面，无法撤回
</span></span></code></pre></div><p>修复方式是在末尾仍为 `` 时暂缓推送，等待后续 token 将其补全；生成结束后再补发剩余文本：</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">if</span> <span class="n">response</span><span class="o">.</span><span class="n">endswith</span><span class="p">(</span><span class="s2">&#34;</span><span class="se">\ufffd</span><span class="s2">&#34;</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">continue</span>
</span></span></code></pre></div><p>新增的 <code>test_ask_stream_waits_for_incomplete_utf8_suffix</code> 用受控解码序列复现这个边界，要求最终 deltas 只有 <code>[&quot;总结&quot;]</code>，不能包含 ``，也不能丢掉“总”。这是流式文本处理里值得长期保留的原则：</p>
<blockquote>
<p><strong>只能向只能追加的 UI 推送已经稳定的前缀；可能随后续输入改写的尾部，应当先留在缓冲区。</strong></p>
</blockquote>
<h3 id="3-512-tokens-为什么会同时截断思考与正文">3. 512 tokens 为什么会同时截断思考与正文</h3>
<p>本地对话默认值经过两轮有依据的调整：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">context_size：  4096 → 8192
</span></span><span class="line"><span class="cl">max_new_tokens： 256 → 512 → 1024
</span></span></code></pre></div><p>两个环境变量分别为 <code>LVCHAT_CONTEXT_SIZE</code> 与 <code>LVCHAT_MAX_NEW_TOKENS</code>，仍可在启动时覆盖。</p>
<p>第一次调到 512 后，<code>25 * 24 结果是多少</code> 已能完整输出思考与“25 乘以 24 等于 600”。但另一个问题“你好，介绍一下注意力机制”仍停在 <code>4. **优势**</code>。对服务端清理后的回答重新编码，结果是<strong>正好 512 tokens</strong>，说明它撞到了生成上限。</p>
<p>这里最容易误解的是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">max_new_tokens = 思考 tokens + 正式回答 tokens + 结束标记
</span></span></code></pre></div><p>它不是正文独享的预算。把默认上限调整为 1024 后，同一个问题完整生成到“优势”和“总结”；清理后的历史回答重新编码为 <strong>585 tokens</strong>，不含已被清理的结束标记。这说明此前 512 的确不足，而这次调参有一致问题的数据依据，不是无目的翻倍。</p>
<p>上下文与生成预算也不是没有成本：因果掩码存在平方级开销，KV Cache 随 token 数增长，多会话还会继续累加。当前它们是本地实验配置，不代表已完成长上下文性能优化。</p>
<h3 id="4-sse-done-不等于模型自然结束">4. SSE done 不等于模型自然结束</h3>
<p>旧页面只要收到 <code>done=true</code>，就显示“就绪 · SSE 流式返回”。但 <code>done</code> 原来只表示服务器的事件流结束，无法区分：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">stop：模型生成 EOS，自然结束
</span></span><span class="line"><span class="cl">length：达到 max_new_tokens，被强制停止
</span></span></code></pre></div><p>现在 <code>ChatSession</code> 记录 <code>last_finish_reason</code> 与 <code>last_generated_tokens</code>，服务端在最后一个 SSE 事件中附加：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">finish_reason
</span></span><span class="line"><span class="cl">generated_tokens
</span></span><span class="line"><span class="cl">max_new_tokens
</span></span></code></pre></div><p>页面收到 <code>finish_reason=length</code> 时，会明确显示“已达生成上限 · 回答可能不完整”，并提示可以增大 <code>LVCHAT_MAX_NEW_TOKENS</code>，不再把硬截断伪装成正常完成。</p>
<p>真实验收分成两边：</p>
<ul>
<li>默认 1024 下，同一注意力机制问题完整结束，页面保持正常完成状态；</li>
<li>临时将上限设为 16，页面实际出现“本次已达到 16 tokens 生成上限，回答可能不完整”的提示；验证后停止临时服务。</li>
</ul>
<h3 id="5-模型能力问题与工程问题分开记录">5. 模型能力问题与工程问题分开记录</h3>
<p>小模型自身仍然存在不稳定。例如 <code>123 + 789</code> 的思考中，模型一度算出 912，随后陷入“8912？不对”的重复，直到耗尽预算，正式回答为空。这不是 DOM 或 UTF-8 修复能够解决的问题，继续增大预算也只会允许重复持续更久。</p>
<p>因此当前笔记把三类结论分开：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">架构正确性：由官方 logits、cache decode 和固定生成对照证明
</span></span><span class="line"><span class="cl">工程链路：由 SSE、DOM 顺序、增量解码和结束原因验收
</span></span><span class="line"><span class="cl">模型质量：单独观察，不用工程测试替模型能力背书
</span></span></code></pre></div><h3 id="6-今天的验证范围">6. 今天的验证范围</h3>
<p>本轮相关回归实际运行结果为 <strong>10 passed</strong>，覆盖 <code>test_chat_session.py</code>、Qwen logits chat 与 Qwen chat regression；其中包括新增的临时 `` 解码回归。JavaScript <code>node --check</code> 与本次变更文件的 <code>git diff --check</code> 均通过。</p>
<p>真实浏览器验收覆盖思考区顺序、乱码消失、1024 下长回答完整结束，以及 16 tokens 下的截断提示。这个数字只代表本轮指定回归集合，不累加历史测试数，也不冒充全量测试或 Qwen3 全系列验收。</p>
]]></content:encoded>
    </item>
    <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>
    <item>
      <title>手搓 LLM 笔记 20：CUDA 对照</title>
      <link>https://blog.lvxinrong.com/llm/llm-20-i2-windows-cuda/</link>
      <pubDate>Wed, 11 Nov 2026 10:57:55 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-20-i2-windows-cuda/</guid>
      <description>搭建 Windows + WSL2 + RTX 4070 Ti 环境，定位 torch.compile 的 typing 依赖根因，并在统一测量口径下完成 AMP、SDPA、compile、checkpointing 的 CUDA 三轮对照及 MPS 横向观察。</description>
      <content:encoded><![CDATA[<p>这次最直观的感受是：<strong>RTX 4070 Ti + CUDA 确实猛</strong>。一张 2023 年左右花六千多元买的 RTX 4070 Ti，和一台 2025 年年中花两万一千元买的 MacBook M4 Pro（48 GB），购买时间相隔约两三年，价格相差三倍多。我原本以为，更晚、更贵的设备至少不会在训练任务上吃亏；真正跑完对照才发现，在当前这套手搓模型的训练实验中，4070 Ti 的 FP32 吞吐已接近 Mac / MPS 的两倍，在 BF16、FP16 和 compile 等配置下甚至超过两倍。这个结果确实出乎我的意料。</p>
<p>当然，这不是一场严格的同台比价：显卡和 Mac 整机的定位不同，4070 Ti 的 12 GB 显存也会限制可训练的模型规模，MacBook 的 48 GB 统一内存则有另一方面的优势。真正让我有触动的，也不只是“N 卡更快”这个结论，而是我终于用同一套代码、同一份数据和自己跑出来的指标，把过去听别人说的“训练更适合 N 卡”，变成了亲手验证过的事实。</p>
<blockquote>
<p>今天的主线原本只是“在 Windows 上复跑 I2 实验”。过程中不仅搭建了一套以后可以反复使用的 GPU 环境、完成了一次典型的依赖排障，也得到了六组 CUDA 正式结果和一份保留边界的 MPS / CUDA 对照。</p>
</blockquote>
<h2 id="一为什么需要这套环境">一、为什么需要这套环境？</h2>
<p>昨天的 I2 实验都在 Mac/MPS 上完成。它能验证模型逻辑和当前设备上的性能，但不能代表 CUDA、大显存和 NVIDIA 优化生态。</p>
<p>Windows 台式机里有一张 RTX 4070 Ti，显存约 12 GB。I2 番外要在同一套代码、同一份 token 数据、同一组训练配置下，复跑：</p>
<ul>
<li>FP32 / FP16 / BF16（AMP）；</li>
<li>eager / SDPA；</li>
<li>torch.compile；</li>
<li>Activation Checkpointing。</li>
</ul>
<p>目标不是推翻 Mac 结果，而是得到一组可以并列比较的 CUDA 对照。</p>
<h2 id="二从-mac-远程操作-windows">二、从 Mac 远程操作 Windows</h2>
<p>为了避免在 Mac 和 Windows 两套键盘、两个终端之间来回切换，这次使用 SSH。</p>
<p>Windows 上安装并启动 OpenSSH Server：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-powershell" data-lang="powershell"><span class="line"><span class="cl"><span class="nb">Add-WindowsCapability</span> <span class="n">-Online</span> <span class="n">-Name</span> <span class="n">OpenSSH</span><span class="p">.</span><span class="n">Server</span><span class="p">~~~~</span><span class="mf">0.0</span><span class="p">.</span><span class="py">1</span><span class="p">.</span><span class="py">0</span>
</span></span><span class="line"><span class="cl"><span class="nb">Start-Service</span> <span class="n">sshd</span>
</span></span><span class="line"><span class="cl"><span class="nb">Set-Service</span> <span class="n">-Name</span> <span class="n">sshd</span> <span class="n">-StartupType</span> <span class="n">Automatic</span>
</span></span></code></pre></div><p>安装过程中一度出现进度条不更新、<code>NotPresent</code> 和后台服务仍在运行的情况。检查后发现 BITS 处于停止状态，启动：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-powershell" data-lang="powershell"><span class="line"><span class="cl"><span class="nb">Start-Service</span> <span class="n">BITS</span>
</span></span></code></pre></div><p>随后组件状态变为 <code>Installed</code>。</p>
<p>防火墙中已有 <code>OpenSSH-Server-In-TCP</code>，无需重复创建。规则状态为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Enabled = True
</span></span><span class="line"><span class="cl">Direction = Inbound
</span></span><span class="line"><span class="cl">Action = Allow
</span></span><span class="line"><span class="cl">Profile = Private
</span></span></code></pre></div><p>然后使用 Windows 的以太网 IPv4 地址 <code>192.168.3.8</code>，从 Mac 登录：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">ssh lv@192.168.3.8
</span></span></code></pre></div><p>登录成功后进入 Ubuntu：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-powershell" data-lang="powershell"><span class="line"><span class="cl"><span class="n">wsl</span> <span class="n">-d</span> <span class="n">Ubuntu</span><span class="p">-</span><span class="mf">24.04</span>
</span></span></code></pre></div><p>这样，后续命令就可以统一在 Mac 终端中执行，不再需要两套键盘和两套操作习惯。</p>
<p>这条链路是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Mac
</span></span><span class="line"><span class="cl">→ SSH
</span></span><span class="line"><span class="cl">→ Windows
</span></span><span class="line"><span class="cl">→ WSL2 / Ubuntu 24.04
</span></span><span class="line"><span class="cl">→ RTX 4070 Ti
</span></span></code></pre></div><p>不需要额外引入 KVM 或维护另一套独立虚拟机。</p>
<h2 id="三统一运行环境">三、统一运行环境</h2>
<p>进入 Ubuntu 后，确认：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Git 2.43.0
</span></span><span class="line"><span class="cl">Python 3.12.3（Ubuntu 系统初始版本）
</span></span></code></pre></div><p>随后安装 uv，并让项目使用与 Mac 一致的 Python 3.12.12：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">curl -LsSf https://astral.sh/uv/install.sh <span class="p">|</span> sh
</span></span><span class="line"><span class="cl"><span class="nb">source</span> <span class="s2">&#34;</span><span class="nv">$HOME</span><span class="s2">/.local/bin/env&#34;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">uv python install 3.12.12
</span></span><span class="line"><span class="cl">uv sync --python 3.12.12
</span></span></code></pre></div><p>项目的 <code>requires-python = &quot;&gt;=3.12&quot;</code> 只规定最低版本，并不会自动选择 Mac 的 3.12.12，因此这里显式指定版本。</p>
<p>代码克隆后锁定到与 Mac 相同的提交：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">git switch --detach 5fcd3c2958e935dae805f051f8a628baa9e8ef59
</span></span></code></pre></div><p><code>detached HEAD</code> 在这里是为了固定对照实验版本，不是要修改历史。</p>
<p>GPU 在 WSL 中已经可见：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">NVIDIA GeForce RTX 4070 Ti
</span></span><span class="line"><span class="cl">显存：12282 MiB
</span></span><span class="line"><span class="cl">CUDA UMD Version：13.3
</span></span></code></pre></div><p>PyTorch 检查结果：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">torch = 2.14.1+cu130
</span></span><span class="line"><span class="cl">cuda_available = True
</span></span><span class="line"><span class="cl">gpu = NVIDIA GeForce RTX 4070 Ti
</span></span><span class="line"><span class="cl">torch_cuda = 13.0
</span></span></code></pre></div><h2 id="四同步同一份-token-数据">四、同步同一份 token 数据</h2>
<p>由于 <code>data/</code> 不进入 Git，Windows 需要单独获得 token store。</p>
<p>从 Mac 通过 SCP 复制到 Windows 用户目录，再进入 WSL 项目：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">scp -r /Users/lv/lv_repo/squid-llms/data/token_store <span class="se">\
</span></span></span><span class="line"><span class="cl">  lv@192.168.3.8:token_store
</span></span></code></pre></div><p>Ubuntu 中：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">mkdir -p ~/lv_repo/squid-llms/data/token_store
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">cp -r /mnt/c/Users/lv/token_store/. <span class="se">\
</span></span></span><span class="line"><span class="cl">  ~/lv_repo/squid-llms/data/token_store/
</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">train.uint32.bin    约 461 KiB
</span></span><span class="line"><span class="cl">heldout.uint32.bin  约 22 KiB
</span></span><span class="line"><span class="cl">metadata.json       约 17 KiB
</span></span></code></pre></div><p>文件大小也与 token 数一致：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">train：117890 × 4 = 471560 bytes
</span></span><span class="line"><span class="cl">heldout：5485 × 4 = 21940 bytes
</span></span></code></pre></div><p>这样，Mac 与 Windows 使用的就是同一份代码、同一套 Python/依赖版本和同一份 token 数据。</p>
<h2 id="五第一次-compile-失败缺少-c-编译器">五、第一次 compile 失败：缺少 C 编译器</h2>
<p>环境探针中，FP16、BF16、autocast 和 SDPA 都通过，只有 <code>torch.compile</code> 报错：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Failed to find C compiler
</span></span></code></pre></div><p>这说明 <code>torch.compile</code> 在当前 Linux 环境中需要调用系统编译器，而 Ubuntu 初始环境没有完整开发工具链。</p>
<p>安装：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">sudo apt update
</span></span><span class="line"><span class="cl">sudo apt install -y build-essential
</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">gcc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0
</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">SubprocPool unclean exit
</span></span><span class="line"><span class="cl">Attempting to use a closed pool
</span></span></code></pre></div><p>这说明问题已经从“找不到编译器”变成了“编译 worker 进程池崩溃”。</p>
<h2 id="六先绕过再抓真正的子进程错误">六、先绕过，再抓真正的子进程错误</h2>
<p>为了判断编译器和 CUDA 是否可用，先使用单线程编译：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl"><span class="nv">TORCHINDUCTOR_COMPILE_THREADS</span><span class="o">=</span><span class="m">1</span> uv run python - <span class="s">&lt;&lt;&#39;PY&#39;
</span></span></span><span class="line"><span class="cl"><span class="s">import torch
</span></span></span><span class="line"><span class="cl"><span class="s">
</span></span></span><span class="line"><span class="cl"><span class="s">
</span></span></span><span class="line"><span class="cl"><span class="s">def function(x):
</span></span></span><span class="line"><span class="cl"><span class="s">    return x * 2 + 1
</span></span></span><span class="line"><span class="cl"><span class="s">
</span></span></span><span class="line"><span class="cl"><span class="s">
</span></span></span><span class="line"><span class="cl"><span class="s">compiled = torch.compile(function)
</span></span></span><span class="line"><span class="cl"><span class="s">result = compiled(torch.tensor([1.0, 2.0], device=&#34;cuda&#34;))
</span></span></span><span class="line"><span class="cl"><span class="s">print(result)
</span></span></span><span class="line"><span class="cl"><span class="s">PY</span>
</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">tensor([3., 5.], device=&#39;cuda:0&#39;)
</span></span></code></pre></div><p>这证明：</p>
<ul>
<li><code>torch.compile</code> 本身可用；</li>
<li>GCC 可以参与编译；</li>
<li>生成的 kernel 能在 CUDA 上正确执行；</li>
<li>问题主要集中在并行编译 worker，而不是模型代码或基本 CUDA 计算。</li>
</ul>
<p>但这只是 workaround，不是根因修复。</p>
<h3 id="打开-worker-日志">打开 worker 日志</h3>
<p>随后不关闭并行编译，而是打开 worker 日志：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl"><span class="nv">TORCHINDUCTOR_WORKER_SUPPRESS_LOGGING</span><span class="o">=</span><span class="m">0</span> <span class="se">\
</span></span></span><span class="line"><span class="cl"><span class="nv">TORCHINDUCTOR_WORKER_LOGPATH</span><span class="o">=</span>/tmp/inductor-worker.log <span class="se">\
</span></span></span><span class="line"><span class="cl">uv run python - <span class="s">&lt;&lt;&#39;PY&#39;
</span></span></span><span class="line"><span class="cl"><span class="s">import torch
</span></span></span><span class="line"><span class="cl"><span class="s">
</span></span></span><span class="line"><span class="cl"><span class="s">
</span></span></span><span class="line"><span class="cl"><span class="s">def function(x):
</span></span></span><span class="line"><span class="cl"><span class="s">    return x * 2 + 1
</span></span></span><span class="line"><span class="cl"><span class="s">
</span></span></span><span class="line"><span class="cl"><span class="s">
</span></span></span><span class="line"><span class="cl"><span class="s">compiled = torch.compile(function)
</span></span></span><span class="line"><span class="cl"><span class="s">result = compiled(torch.tensor([1.0, 2.0], device=&#34;cuda&#34;))
</span></span></span><span class="line"><span class="cl"><span class="s">print(result)
</span></span></span><span class="line"><span class="cl"><span class="s">PY</span>
</span></span></code></pre></div><p>主进程仍然只显示 <code>closed pool</code>，但 worker 日志终于暴露了第一现场：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">File &#34;.../.venv/lib/python3.12/site-packages/typing.py&#34;
</span></span><span class="line"><span class="cl">AttributeError: type object &#39;Callable&#39; has no attribute &#39;_abc_registry&#39;
</span></span></code></pre></div><p>也就是说，编译 worker 不是死在了 CUDA 或模型计算上，而是<strong>在启动后导入 <code>typing</code> 时就崩溃了</strong>。</p>
<h2 id="七真正根因旧-typing-包遮蔽了标准库">七、真正根因：旧 typing 包遮蔽了标准库</h2>
<p>Python 3.12 自带标准库 <code>typing</code>，但虚拟环境中还存在：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">.venv/lib/python3.12/site-packages/typing.py
</span></span></code></pre></div><p>这是额外安装的旧版 <code>typing 3.10.0.0</code>，与当前 Python 标准库不兼容。</p>
<p>主进程里检查：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">uv pip show typing
</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">Name: typing
</span></span><span class="line"><span class="cl">Version: 3.10.0.0
</span></span><span class="line"><span class="cl">Required-by: pyloco
</span></span></code></pre></div><p>继续沿 lockfile 追踪，得到完整依赖链：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">squid-llms
</span></span><span class="line"><span class="cl">→ matplot
</span></span><span class="line"><span class="cl">→ pyloco
</span></span><span class="line"><span class="cl">→ typing 3.10.0.0
</span></span></code></pre></div><p>而项目中实际使用的是 <code>matplotlib</code>，没有代码直接 import <code>matplot</code>。</p>
<p>因此正确修复不是单独删掉 <code>typing</code>，而是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">uv add matplotlib
</span></span><span class="line"><span class="cl">uv remove matplot
</span></span></code></pre></div><p>这样：</p>
<ul>
<li>把真正使用的 <code>matplotlib</code> 提升为直接依赖；</li>
<li>移除不需要的 <code>matplot</code>；</li>
<li>同时移除 <code>pyloco</code> 和旧 <code>typing</code> 这条依赖链；</li>
<li><code>pyproject.toml</code> 与 <code>uv.lock</code> 同步更新，避免下次 <code>uv sync</code> 又装回来。</li>
</ul>
<p>修复后：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">uv pip show typing
</span></span><span class="line"><span class="cl">→ Package(s) not found for: typing
</span></span></code></pre></div><p>再次运行正常并行编译，不再设置 <code>TORCHINDUCTOR_COMPILE_THREADS=1</code>：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">tensor([3., 5.], device=&#39;cuda:0&#39;)
</span></span></code></pre></div><p>这次才真正解决了根因。</p>
<h2 id="八今天学到的不只是安装环境">八、今天学到的不只是安装环境</h2>
<p>这次排障有几个值得长期保留的经验：</p>
<h3 id="1-主进程错误不一定是真正根因">1. 主进程错误不一定是真正根因</h3>
<p><code>closed pool</code> 只说明池关闭了，<code>SubprocPool unclean exit</code> 只说明子进程异常退出。真正原因需要打开 worker 日志。</p>
<h3 id="2-不要第一时间把问题归因于-cuda-版本">2. 不要第一时间把问题归因于 CUDA 版本</h3>
<p>单线程编译和 CUDA 执行已经成功，说明基本计算链路可用。继续沿子进程启动、导入和依赖路径排查，比盲目更换 CUDA 更有效。</p>
<h3 id="3-多余依赖也可能破坏运行时">3. 多余依赖也可能破坏运行时</h3>
<p>这次不是缺依赖，而是<strong>多了一个旧依赖</strong>。它遮蔽了 Python 标准库，导致完全不相关的编译 worker 启动失败。</p>
<h3 id="4-修复要落到依赖清单">4. 修复要落到依赖清单</h3>
<p>只在当前环境里卸载一个包还不够。需要更新 <code>pyproject.toml</code> 和 <code>uv.lock</code>，否则下一次同步环境时问题会重新出现。</p>
<h3 id="5-这套环境是后续主线的基础设施">5. 这套环境是后续主线的基础设施</h3>
<p>它不仅服务今天的 I2 番外，也会服务：</p>
<ul>
<li>CUDA 下的 AMP / SDPA / compile / checkpointing 对照；</li>
<li>I3 的推理、量化与 Serving；</li>
<li>第三阶段的 GPU、算子、分布式和 DeepInfer 学习。</li>
</ul>
<h2 id="九统一-cuda-的计时与显存口径">九、统一 CUDA 的计时与显存口径</h2>
<p>正式实验前，补齐了 CUDA 的同步计时和显存记录。GPU 操作是异步提交的，只记录 Python 调用的返回时间，可能并没有包含实际计算时间；因此正式测量前后需要同步设备，并在正式测量前重置峰值显存统计。</p>
<p>各训练脚本现在通过公共设备逻辑记录：</p>
<ul>
<li><code>current_allocated</code>：当前仍由张量占用的显存；</li>
<li><code>peak_allocated</code>：测量期间张量实际分配显存的峰值；</li>
<li><code>current_reserved</code>：当前 PyTorch 缓存分配器向 CUDA 预留的显存；</li>
<li><code>peak_reserved</code>：测量期间缓存分配器预留显存的峰值。</li>
</ul>
<p><code>allocated</code> 更接近实际张量占用，<code>reserved</code> 还包含缓存分配器为复用而保留的空间。两者不能混为一谈。本次表格保留原始 bytes，同时用 <code>bytes ÷ 1,048,576</code> 换算为 MiB，便于阅读。</p>
<h2 id="十正式-cuda-对照结果">十、正式 CUDA 对照结果</h2>
<h3 id="测量条件">测量条件</h3>
<ul>
<li>硬件：RTX 4070 Ti，约 12 GB 显存；</li>
<li>软件：Windows + WSL2 / Ubuntu 24.04，Python 3.12.12，PyTorch 2.14.1+cu130；</li>
<li>模型：2 层，<code>emb_dim=64</code>，<code>ffn_dim=256</code>，4 个 Q heads、2 个 KV heads，词表 151936；</li>
<li>数据与配置：与 Mac 使用同一份 token store，<code>batch_size=2</code>，<code>context_length=128</code>；</li>
<li>计时：2 步 warmup，随后 10 步正式测量，共处理 2560 个 token；</li>
<li>每个实验独立运行 3 次，吞吐取中位数；</li>
<li>compile 的首次图捕获、代码生成和编译发生在 warmup 中，不计入下面的稳态吞吐。</li>
</ul>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>实验</th>
        <th style="text-align: right">吞吐中位数（tokens/s）</th>
        <th style="text-align: right">峰值分配</th>
        <th style="text-align: right">峰值预留</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>FP32 / eager</td>
        <td style="text-align: right">21614.87</td>
        <td style="text-align: right">691.67 MiB</td>
        <td style="text-align: right">854 MiB</td>
      </tr>
      <tr>
        <td>BF16 / AMP</td>
        <td style="text-align: right">22002.51</td>
        <td style="text-align: right">635.55 MiB</td>
        <td style="text-align: right">876 MiB</td>
      </tr>
      <tr>
        <td>FP16 / AMP</td>
        <td style="text-align: right">20954.75</td>
        <td style="text-align: right">635.55 MiB</td>
        <td style="text-align: right">876 MiB</td>
      </tr>
      <tr>
        <td>SDPA + FP32</td>
        <td style="text-align: right">21588.02</td>
        <td style="text-align: right">690.81 MiB</td>
        <td style="text-align: right">852 MiB</td>
      </tr>
      <tr>
        <td>compile + FP32</td>
        <td style="text-align: right">25346.90</td>
        <td style="text-align: right">690.85 MiB</td>
        <td style="text-align: right">首轮 778 MiB，后两轮 852 MiB</td>
      </tr>
      <tr>
        <td>checkpointing + FP32</td>
        <td style="text-align: right">17140.50</td>
        <td style="text-align: right">687.53 MiB</td>
        <td style="text-align: right">852 MiB</td>
      </tr>
    </tbody>
  </table>
</div>
<p>这里的显存数字取三轮正式测量后报告中的峰值。compile 的峰值预留首轮为 <code>815792128 bytes</code>（778 MiB），后两轮为 <code>893386752 bytes</code>（852 MiB），因此保留波动，不选其中一个数字冒充固定结果。</p>
<h3 id="1-bf16小幅提速但两种显存指标方向不同">1. BF16：小幅提速，但两种显存指标方向不同</h3>
<p>相对 FP32 / eager：</p>
<ul>
<li>吞吐中位数提高约 <strong>1.79%</strong>；</li>
<li>峰值分配减少 <strong>56.12 MiB</strong>，约 <strong>8.11%</strong>；</li>
<li>峰值预留却增加 <strong>22 MiB</strong>，约 <strong>2.58%</strong>。</li>
</ul>
<p>所以准确结论是：当前配置下 BF16 有小幅吞吐收益，实际张量峰值分配有所下降，但缓存分配器的峰值预留没有同步下降。不能笼统写成“全面节省显存”。</p>
<p>FP16 的吞吐中位数比 FP32 低约 3.05%，比 BF16 低约 4.76%。这组结果只代表当前小模型、短序列和测量配置，不代表其他 GPU 或大模型上 FP16 一定慢于 BF16。</p>
<h3 id="2-sdpa本次基本持平">2. SDPA：本次基本持平</h3>
<p>SDPA + FP32 相对 eager + FP32：</p>
<ul>
<li>吞吐变化约 <strong>-0.12%</strong>，基本持平；</li>
<li>峰值分配减少约 <strong>0.87 MiB</strong>；</li>
<li>峰值预留减少 <strong>2 MiB</strong>。</li>
</ul>
<p>这只能说明当前模型和上下文长度下，替换注意力实现没有带来明显差异。这里只验证了代码调用 SDPA，<strong>没有确认实际落入 FlashAttention kernel</strong>，也不能据此推断长序列下的收益。</p>
<h3 id="3-compile当前最明显的吞吐收益">3. compile：当前最明显的吞吐收益</h3>
<p>compile + FP32 相对 eager + FP32：</p>
<ul>
<li>三轮吞吐为 25369.12 / 25346.90 / 24348.93 tokens/s；</li>
<li>中位数提高约 <strong>17.27%</strong>；</li>
<li>峰值分配约 690.85 MiB，与 FP32 的 691.67 MiB 基本持平。</li>
</ul>
<p>因此当前收益应写成<strong>吞吐提升</strong>，不能附带宣称 compile 节省了显存。预热后三轮的峰值预留存在 778 / 852 MiB 的波动，也提醒我们不能只看某一轮。</p>
<p>首轮出现的 <code>Not enough SMs to use max_autotune_gemm mode</code> 表示当前设备未启用相应的 GEMM 自动调优路径，不是编译失败；实际编译和后续 CUDA 执行均已成功。</p>
<h3 id="4-checkpointing降速明显当前显存收益很小">4. checkpointing：降速明显，当前显存收益很小</h3>
<p>checkpointing + FP32 相对 FP32 / eager：</p>
<ul>
<li>三轮吞吐为 19454.24 / 17140.50 / 17051.76 tokens/s；</li>
<li>中位数从 21614.87 降至 17140.50，下降约 <strong>20.70%</strong>；</li>
<li>峰值分配从 691.67 MiB 降至 687.53 MiB，只减少 <strong>4.14 MiB / 0.60%</strong>；</li>
<li>峰值预留两边均为 852 MiB。</li>
</ul>
<p>首轮吞吐较高，因此这里用三轮中位数而不是只取最好的一次。当前小模型上，额外重算带来了明显吞吐损失，却只换来很小的峰值分配下降。</p>
<p>这不否定 checkpointing 的价值。它本来就是用额外计算换取激活显存，只是当前小模型并没有显存瓶颈，交易不划算。是否值得开启，要在更大模型、更长上下文或接近 OOM 的配置下重新测量。</p>
<h2 id="十一mac--mps-与-windows--cuda-并列观察">十一、Mac / MPS 与 Windows / CUDA 并列观察</h2>
<p>下表只并列两边已有的三轮吞吐中位数，不把跨硬件差异归因于某一个单独优化：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>实验</th>
        <th style="text-align: right">Mac / MPS（tokens/s）</th>
        <th style="text-align: right">Windows / CUDA（tokens/s）</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>FP32 / eager</td>
        <td style="text-align: right">11001.65</td>
        <td style="text-align: right">21614.87</td>
      </tr>
      <tr>
        <td>BF16 / AMP</td>
        <td style="text-align: right">9942.47</td>
        <td style="text-align: right">22002.51</td>
      </tr>
      <tr>
        <td>FP16 / AMP</td>
        <td style="text-align: right">9892.09</td>
        <td style="text-align: right">20954.75</td>
      </tr>
      <tr>
        <td>SDPA + FP32</td>
        <td style="text-align: right">10613.57</td>
        <td style="text-align: right">21588.02</td>
      </tr>
      <tr>
        <td>compile + FP32</td>
        <td style="text-align: right">11801.10</td>
        <td style="text-align: right">25346.90</td>
      </tr>
      <tr>
        <td>checkpointing + FP32</td>
        <td style="text-align: right">10714.24</td>
        <td style="text-align: right">17140.50</td>
      </tr>
    </tbody>
  </table>
</div>
<p>两个值得带走的观察：</p>
<ul>
<li>compile 在 Mac / MPS 上相对 FP32 提高约 <strong>7.27%</strong>，在本次 CUDA 上提高约 <strong>17.27%</strong>。两种设备上都观察到了稳态吞吐收益，但幅度不同。</li>
<li>checkpointing 在两种设备上的收益都不显著。Mac 当时使用同批次、带内存记录的 FP32 基线 11321.03 tokens/s 对照，不能把其他批次的 FP32 中位数混入计算；当时也没有与本次 CUDA 完全相同的峰值显存接口，因此不伪造跨设备的峰值显存对照。</li>
</ul>
<p>这些数字不是硬件排行榜。两台机器的模型规模都很小，测量只有 10 个正式 step，编译成本也没有摊入稳态吞吐。它们回答的是“同一学习项目在当前两台设备上观察到了什么”，不是普遍性能定律。</p>
<h2 id="十二最终验收与边界">十二、最终验收与边界</h2>
<p>已经真实完成：</p>
<ul>
<li>Mac 通过 SSH 操作 Windows，Windows + WSL2 / Ubuntu 环境可用；</li>
<li>RTX 4070 Ti 在 Ubuntu 和 PyTorch CUDA 中可见；</li>
<li>代码、Python 3.12.12、依赖与 token 数据已同步；</li>
<li><code>torch.compile</code> 从缺编译器到 worker 崩溃再到依赖根因修复；</li>
<li>修复后的环境探针通过，FP16 / BF16、autocast、SDPA 和 compile 均可用；</li>
<li>正常并行 compile 不再依赖单线程 workaround；</li>
<li>FP32 / FP16 / BF16 / SDPA / compile / checkpointing 的 CUDA 三轮对照已完成；</li>
<li>CUDA 同步计时和显存记录已补齐，Mac 上绘图验证正常。</li>
</ul>
<p>尚未覆盖：</p>
<ul>
<li>其他 GPU、更大模型、更长上下文或更大 batch；</li>
<li>SDPA 实际选择的具体 attention backend；</li>
<li>把 compile 的首次编译成本摊入完整训练任务后的收益；</li>
<li>MFU，以及 GPT-2 / model_v3 的额外吞吐对照；</li>
<li>接近显存上限时 checkpointing 能否避免 OOM。</li>
</ul>
<p>所以这篇番外最终交付的是：<strong>一套可复用的 Windows / CUDA 环境、一次有明确根因的依赖排障，以及一组保留测量边界的 MPS / CUDA 对照结果。</strong></p>
]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 19：I2，训练加速与显存压榨</title>
      <link>https://blog.lvxinrong.com/llm/llm-19-i2-environment-probe/</link>
      <pubDate>Tue, 10 Nov 2026 14:55:19 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-19-i2-environment-probe/</guid>
      <description>从 Mac/MPS 环境探针，到 FP32/FP16/BF16、SDPA、torch.compile 与 Activation Checkpointing 的重复对照实验；同时记录正确性、吞吐、内存和结论边界。</description>
      <content:encoded><![CDATA[<blockquote>
<p>I2 不直接从修改训练代码开始。优化之前先确认当前设备究竟支持什么，避免把 CUDA 教程里的能力直接套到 Mac/MPS 上。</p>
</blockquote>
<h2 id="一i2-0-的目标是什么">一、I2-0 的目标是什么？</h2>
<p>当前目标是建立训练加速的环境与基线，不是马上让模型提速。</p>
<p>本次环境探针覆盖：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">FP16 / BF16 原生矩阵乘法
</span></span><span class="line"><span class="cl">→ FP16 / BF16 autocast
</span></span><span class="line"><span class="cl">→ SDPA
</span></span><span class="line"><span class="cl">→ torch.compile
</span></span></code></pre></div><p>源码：<code>scripts/i2_environment_probe.py</code>。</p>
<p>输出报告：<code>data/reports/i2-environment.json</code>。</p>
<p>这一步只回答“当前环境能否运行这些能力”，不证明完整模型训练稳定，也不证明任何优化已经产生收益。</p>
<h2 id="二run_probe统一管理执行与异常">二、run_probe：统一管理执行与异常</h2>
<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="k">def</span> <span class="nf">run_probe</span><span class="p">(</span><span class="n">function</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">try</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="n">result</span> <span class="o">=</span> <span class="n">function</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;supported&#34;</span><span class="p">:</span> <span class="kc">True</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;result&#34;</span><span class="p">:</span> <span class="nb">str</span><span class="p">(</span><span class="n">result</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="k">except</span> <span class="ne">Exception</span> <span class="k">as</span> <span class="n">exc</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;supported&#34;</span><span class="p">:</span> <span class="kc">False</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;error&#34;</span><span class="p">:</span> <span class="sa">f</span><span class="s2">&#34;</span><span class="si">{</span><span class="nb">type</span><span class="p">(</span><span class="n">exc</span><span class="p">)</span><span class="o">.</span><span class="vm">__name__</span><span class="si">}</span><span class="s2">: </span><span class="si">{</span><span class="n">exc</span><span class="si">}</span><span class="s2">&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span></code></pre></div><p>它接收一个可调用对象，在内部真正执行，并统一整理成功或失败结果。</p>
<p>这是一种<strong>高阶函数</strong>（Higher-order Function）的用法：函数接收另一个函数作为参数。也可以把它看成一个手写 wrapper（包装器），有点类似 Java/AOP 里的环绕通知，但这里不需要引入框架。</p>
<p>它解决了两个问题：</p>
<ol>
<li>把实际执行统一放进 <code>try/except</code>，一个探针失败不会阻止其他探针执行；</li>
<li>所有探针使用相同的结果结构，方便汇总成 JSON。</li>
</ol>
<p>但它只证明“没有抛异常”，不等于结果正确。具体正确性仍由探针内部的断言或结果检查负责。</p>
<p>在正式测试中不能随意吞掉所有异常；这里适合使用，是因为环境盘点的目标是完整收集支持与不支持项。</p>
<h2 id="三位置参数与关键字参数">三、位置参数与关键字参数</h2>
<p><code>*args</code> 和 <code>**kwargs</code> 的区别：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">*args   → 接收位置参数，只传值，收集成 tuple
</span></span><span class="line"><span class="cl">**kwargs → 接收 key=value 参数，收集成 dict
</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="k">def</span> <span class="nf">example</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">,</span> <span class="n">device</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="o">...</span>
</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">example</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="n">device</span><span class="o">=</span><span class="s2">&#34;mps&#34;</span><span class="p">)</span>
</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="k">def</span> <span class="nf">run_probe</span><span class="p">(</span><span class="n">function</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">function</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">)</span>
</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">run_probe</span><span class="p">(</span><span class="n">example</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="n">device</span><span class="o">=</span><span class="s2">&#34;mps&#34;</span><span class="p">)</span>
</span></span></code></pre></div><p>就等价于原调用。</p>
<p><code>args</code> 和 <code>kwargs</code> 只是约定俗成的变量名，真正让收集与展开生效的是 <code>*</code> 和 <code>**</code>。</p>
<h2 id="四lambda把调用包装成稍后再执行的函数">四、lambda：把调用包装成稍后再执行的函数</h2>
<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">run_probe</span><span class="p">(</span><span class="k">lambda</span><span class="p">:</span> <span class="n">dtype_probe</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">float16</span><span class="p">))</span>
</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="k">def</span> <span class="nf">temporary_function</span><span class="p">():</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">dtype_probe</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">float16</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">run_probe</span><span class="p">(</span><span class="n">temporary_function</span><span class="p">)</span>
</span></span></code></pre></div><p><code>lambda</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="k">lambda</span> <span class="n">参数</span><span class="p">:</span> <span class="n">返回值表达式</span>
</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="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span> <span class="o">*</span> <span class="mi">2</span>
</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="k">def</span> <span class="nf">double</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">x</span> <span class="o">*</span> <span class="mi">2</span>
</span></span></code></pre></div><p>当前 lambda 冒号前没有参数，所以它是一个无参数函数。</p>
<h3 id="为什么不直接调用">为什么不直接调用？</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="n">run_probe</span><span class="p">(</span><span class="n">dtype_probe</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">float16</span><span class="p">))</span>
</span></span></code></pre></div><p>Python 会先执行 <code>dtype_probe(torch.float16)</code>，再把结果传给 <code>run_probe()</code>。如果探针出错，异常发生在进入 <code>run_probe()</code> 之前，内部的 <code>try/except</code> 就接不住。</p>
<p>使用 lambda 后：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">创建 lambda，但不执行探针
</span></span><span class="line"><span class="cl">→ 把 lambda 传给 run_probe
</span></span><span class="line"><span class="cl">→ run_probe 内部执行 function()
</span></span><span class="line"><span class="cl">→ 这时才执行 dtype_probe(torch.float16)
</span></span><span class="line"><span class="cl">→ 异常由 run_probe 统一捕获
</span></span></code></pre></div><p>这里的“延迟执行”不是异步、定时或懒加载，也不是等到保存 report 时才执行。它只是<strong>相对于直接调用，推迟到包装器内部执行</strong>。</p>
<h3 id="为什么-sdpa-和-compile-不使用-lambda">为什么 SDPA 和 compile 不使用 lambda？</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="n">run_probe</span><span class="p">(</span><span class="n">sdpa_probe</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="n">run_probe</span><span class="p">(</span><span class="n">compile_probe</span><span class="p">)</span>
</span></span></code></pre></div><p>传函数名而没有括号，就还没有执行。<code>run_probe()</code> 内部的 <code>function()</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">run_probe</span><span class="p">(</span><span class="n">sdpa_probe</span><span class="p">)</span>   <span class="c1"># 传函数对象，尚未执行</span>
</span></span><span class="line"><span class="cl"><span class="n">run_probe</span><span class="p">(</span><span class="n">sdpa_probe</span><span class="p">())</span> <span class="c1"># 先执行，再把结果传进去</span>
</span></span></code></pre></div><p>所以规则是：</p>
<blockquote>
<p>无参数函数直接传函数名；需要参数的函数，可以用 lambda 或 partial 提前绑定参数，再交给统一执行器。</p>
</blockquote>
<h2 id="五闭包内部函数使用外层的-device">五、闭包：内部函数使用外层的 device</h2>
<p>几个探针定义在 <code>main()</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">device</span><span class="o">=</span><span class="n">device</span>
</span></span></code></pre></div><p>这里没有显式给 <code>sdpa_probe()</code> 传 <code>device</code>，是因为内部函数可以读取外层函数作用域中的变量。这属于<strong>闭包</strong>（closure）的使用。</p>
<p>它不是 Python 自动推断参数，也不是自动注入；只是函数沿作用域找到了外层已经定义的 <code>device</code>。</p>
<h2 id="六item把单元素-tensor-转成-python-数字">六、item()：把单元素 Tensor 转成 Python 数字</h2>
<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">result</span> <span class="o">=</span> <span class="p">(</span><span class="n">x</span> <span class="o">@</span> <span class="n">x</span><span class="p">)</span><span class="o">.</span><span class="n">sum</span><span class="p">()</span><span class="o">.</span><span class="n">item</span><span class="p">()</span>
</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">x @ x       → 得到一个矩阵
</span></span><span class="line"><span class="cl">.sum()      → 对所有元素求和，得到单元素 Tensor
</span></span><span class="line"><span class="cl">.item()     → 转成普通 Python float
</span></span></code></pre></div><p><code>item()</code> 是 number of elements 为 1 时才能使用的取值方式：</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">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">(</span><span class="mf">2.0</span><span class="p">)</span><span class="o">.</span><span class="n">item</span><span class="p">()</span>        <span class="c1"># 可以</span>
</span></span><span class="line"><span class="cl"><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mf">1.0</span><span class="p">])</span><span class="o">.</span><span class="n">item</span><span class="p">()</span>      <span class="c1"># 可以</span>
</span></span><span class="line"><span class="cl"><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mf">1.0</span><span class="p">,</span> <span class="mf">2.0</span><span class="p">])</span><span class="o">.</span><span class="n">item</span><span class="p">()</span> <span class="c1"># 报错</span>
</span></span></code></pre></div><p>它常用于打印 loss、写 JSON 或取单个数值。</p>
<p>但需要注意：</p>
<ul>
<li><code>loss.item()</code> 后得到的是普通数字，不能再参与反向传播；</li>
<li>在 GPU/MPS 上，<code>item()</code> 会把结果同步回 CPU，频繁调用可能影响性能测量。</li>
</ul>
<h2 id="七autocast在指定作用域内自动选择部分算子的精度">七、autocast：在指定作用域内自动选择部分算子的精度</h2>
<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="k">with</span> <span class="n">torch</span><span class="o">.</span><span class="n">autocast</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">device_type</span><span class="o">=</span><span class="n">device</span><span class="o">.</span><span class="n">type</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">dtype</span><span class="o">=</span><span class="n">dtype</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">result</span> <span class="o">=</span> <span class="n">x</span> <span class="o">@</span> <span class="n">x</span>
</span></span></code></pre></div><p><code>autocast</code> 是自动混合精度/自动类型转换，不是参数匹配。</p>
<p>其中：</p>
<ul>
<li><code>device_type</code>：设备类型，例如当前 <code>&quot;mps&quot;</code>；</li>
<li><code>dtype</code>：目标计算精度，例如 FP16 或 BF16；</li>
<li><code>with</code>：只在这个代码块作用域内启用。</li>
</ul>
<p>它不会把所有模型参数永久转换，也不会无差别转换所有运算。符合规则的算子会按 autocast 策略选择计算精度，离开 <code>with</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="k">assert</span> <span class="n">result</span><span class="o">.</span><span class="n">dtype</span> <span class="o">==</span> <span class="n">dtype</span>
</span></span></code></pre></div><p>防止“语法上写了 autocast，实际输出 dtype 却完全没变化”的空操作被误判为支持。</p>
<h3 id="fp32fp16-与-bf16-的位分配">FP32、FP16 与 BF16 的位分配</h3>
<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">指数位</th>
        <th style="text-align: right">尾数位</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>FP32</td>
        <td style="text-align: right">32</td>
        <td style="text-align: right">8</td>
        <td style="text-align: right">23</td>
      </tr>
      <tr>
        <td>FP16</td>
        <td style="text-align: right">16</td>
        <td style="text-align: right">5</td>
        <td style="text-align: right">10</td>
      </tr>
      <tr>
        <td>BF16</td>
        <td style="text-align: right">16</td>
        <td style="text-align: right">8</td>
        <td style="text-align: right">7</td>
      </tr>
    </tbody>
  </table>
</div>
<p>三种格式都由符号位、指数位和尾数位组成。指数位决定数值范围，尾数位决定有效数字的精度：</p>
<ul>
<li>FP16 指数位较少，范围较小；尾数位比 BF16 多，精度细节更多；</li>
<li>BF16 指数位与 FP32 相同，范围接近 FP32；尾数位较少，精度更粗；</li>
<li>FP32 同时具备更多有效数字和足够大的数值范围，适合作为数值基线。</li>
</ul>
<p>这不是通过“小数点靠前或靠后”实现的。浮点数都可以近似理解为“有效数字 × 2^指数”，指数决定数量级，尾数决定保留多少有效数字。</p>
<h2 id="八sdpa统一注意力入口不是单一后端算法">八、SDPA：统一注意力入口，不是单一后端算法</h2>
<p>SDPA 全称 Scaled Dot-Product Attention，缩放点积注意力。</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">result</span> <span class="o">=</span> <span class="n">F</span><span class="o">.</span><span class="n">scaled_dot_product_attention</span><span class="p">(</span><span class="n">q</span><span class="p">,</span> <span class="n">q</span><span class="p">,</span> <span class="n">q</span><span class="p">)</span>
</span></span></code></pre></div><p>这里的 <code>F</code> 是 <code>torch.nn.functional</code> 的别名，不是 function 的缩写。</p>
<p>三个 <code>q</code> 分别作为 Q、K、V。真实模型中它们通常来自不同 Linear 投影；探针里复用同一个随机张量，只是为了验证调用链路。</p>
<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, 8, 16)
</span></span><span class="line"><span class="cl">= (B=1, H=2, T=8, D=16)
</span></span></code></pre></div><p>输出形状仍为 <code>(1, 2, 8, 16)</code>。</p>
<p>SDPA 完成的数学过程仍然是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Q × Kᵀ
</span></span><span class="line"><span class="cl">→ 除以 √head_dim
</span></span><span class="line"><span class="cl">→ 按需添加 mask
</span></span><span class="line"><span class="cl">→ softmax
</span></span><span class="line"><span class="cl">→ × V
</span></span></code></pre></div><p>与手写 eager 的区别是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">eager：逐步生成 scores、weights 和输出
</span></span><span class="line"><span class="cl">SDPA：交给 PyTorch 统一算子，由后端选择具体实现
</span></span></code></pre></div><p>PyTorch 可能根据版本、设备、dtype、形状和 mask 等条件，选择普通 math、memory-efficient 或其他优化路径。SDPA 不等于 FlashAttention，后者只是可能的后端之一。</p>
<p>这也解释了之前官方对照中的数值差异：数学公式相同，但不同后端的运算顺序、融合与舍入路径可能不同。</p>
<h2 id="九torchcompile优化计算执行方式">九、torch.compile：优化计算执行方式</h2>
<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="k">def</span> <span class="nf">function</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">x</span> <span class="o">*</span> <span class="mi">2</span> <span class="o">+</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">compiled</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">compile</span><span class="p">(</span><span class="n">function</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="n">result</span> <span class="o">=</span> <span class="n">compiled</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mf">1.0</span><span class="p">,</span> <span class="mf">2.0</span><span class="p">],</span> <span class="n">device</span><span class="o">=</span><span class="n">device</span><span class="p">))</span>
</span></span></code></pre></div><p><code>torch.compile(function)</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">1 × 2 + 1 = 3
</span></span><span class="line"><span class="cl">2 × 2 + 1 = 5
</span></span></code></pre></div><p>输出为 <code>[3.0, 5.0]</code>。</p>
<p>compile 的目标是把逐步执行的 PyTorch 代码转换成更适合优化的计算图，再由后端生成更高效的执行路径。它不改变数学公式或模型权重。</p>
<p>首次调用通常有编译成本，后续稳态执行才可能体现收益。微小函数通过探针，不等于完整 model_v3 编译后一定更快。</p>
<h3 id="与-java-jit-的类比">与 Java JIT 的类比</h3>
<p>Java HotSpot JVM 中，热点代码会经过 JIT（Just-In-Time，即时编译）优化：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Java 源码
</span></span><span class="line"><span class="cl">→ javac 生成字节码
</span></span><span class="line"><span class="cl">→ JVM 执行并收集运行时信息
</span></span><span class="line"><span class="cl">→ JIT 将热点字节码编译成优化后的原生机器码
</span></span></code></pre></div><p>这里不是修改或重新实现原字节码，而是把热点代码编译成当前 CPU 可直接执行的原生机器码。</p>
<p>常见名词包括 HotSpot、热点代码、分层编译、C1/C2 编译器和去优化。</p>
<p>与 PyTorch 的对应关系：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Java JIT：热点字节码 → 优化后的 CPU 机器码
</span></span><span class="line"><span class="cl">torch.compile：张量计算图 → 优化后的设备内核
</span></span></code></pre></div><p>一个重要区别是：Java JIT 会依据运行时热点自动优化，而 <code>torch.compile()</code> 是我们显式选择要编译的函数或模型。</p>
<p>两者都不是改变程序语义，而是在保持逻辑的前提下优化执行方式。</p>
<h2 id="十当前真实环境结果">十、当前真实环境结果</h2>
<p>当前环境：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Python 3.12.12
</span></span><span class="line"><span class="cl">PyTorch 2.14.1
</span></span><span class="line"><span class="cl">macOS arm64
</span></span><span class="line"><span class="cl">device = MPS
</span></span><span class="line"><span class="cl">CUDA 不可用
</span></span></code></pre></div><p>探针结果：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>能力</th>
        <th>结果</th>
        <th>实际输出</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>FP16 原生矩阵乘法</td>
        <td>通过</td>
        <td>sum=4096.0</td>
      </tr>
      <tr>
        <td>BF16 原生矩阵乘法</td>
        <td>通过</td>
        <td>sum=4096.0</td>
      </tr>
      <tr>
        <td>FP16 autocast</td>
        <td>通过</td>
        <td>输出 dtype 为 FP16</td>
      </tr>
      <tr>
        <td>BF16 autocast</td>
        <td>通过</td>
        <td>输出 dtype 为 BF16</td>
      </tr>
      <tr>
        <td>SDPA</td>
        <td>通过</td>
        <td>输出形状 <code>(1, 2, 8, 16)</code></td>
      </tr>
      <tr>
        <td>torch.compile</td>
        <td>通过</td>
        <td>输出 <code>[3.0, 5.0]</code></td>
      </tr>
    </tbody>
  </table>
</div>
<p>这些结果证明的是<strong>当前微探针可执行</strong>，不是完整训练优化已经通过。</p>
<p>尚未证明：</p>
<ul>
<li>完整 model_v3 在 FP16/BF16 下训练稳定；</li>
<li>长训练的 loss 与 checkpoint 行为正确；</li>
<li>compile 后的完整模型获得真实吞吐收益；</li>
<li>当前 Mac 支持 FlashAttention；</li>
<li>任何速度、显存或 MFU 改善。</li>
</ul>
<p>下一步才是建立固定输入、固定模型、固定步数的 FP32 训练基线，然后逐项引入混合精度、SDPA/compile 和 Activation Checkpointing，并同时记录正确性与资源指标。</p>
<h2 id="十一思考大模型时代还需要-dropout-吗">十一、思考：大模型时代还需要 Dropout 吗？</h2>
<p>在环境探针之外，我还注意到了另一个问题：当前 GPTModel 里似乎在多个位置都放了 Dropout，Embedding、Attention 权重和残差分支都有。但现代大模型又经常直接使用 <code>drop_rate=0.0</code>，这些传统正则化手段是否已经过时？</p>
<p>我的原始直觉是：大模型是在用海量数据拟合世界，训练样本一直增加，过去为了解决小样本过拟合而设计的 Dropout，放在今天可能显得有些生硬。</p>
<p>这个直觉有一部分是对的。大模型从零预训练时，数据规模很大，很多语料只训练一次或少数几次，算力本身就是主要瓶颈，模型甚至还没有充分拟合训练集。此时主要矛盾往往是训练不足、算力和数据效率，而不是过拟合。Dropout 的正则化收益可能不明显，还会增加额外计算与训练噪声。</p>
<p>但“过拟合的本质就是样本不足”并不完整。更准确的定义是：</p>
<blockquote>
<p>过拟合是模型在训练数据上的表现，明显好于它在同分布未见数据上的表现。</p>
</blockquote>
<p>样本数量只是其中一个因素。数据重复程度、多样性、模型容量、训练步数、epoch、学习率，以及训练分布与真实使用分布是否一致，都会影响过拟合。</p>
<p>即使数据总量很大，也可能因为重复、污染或分布差异而过拟合；小数据也不一定必然过拟合，需要看 train 与 held-out 的真实差距。</p>
<p>放到当前个人博客语料上，结论又会变化。当前训练 token store 只有约 117,890 tokens，如果后续 midtrain 时反复进行多轮 epoch，模型容量较大、训练步数较多，Dropout、学习率、训练步数、数据混合和 early stopping 都可能重新变得重要。</p>
<p>因此，不是“过去的方法在大模型时代失效”，而是：</p>
<blockquote>
<p>大规模预训练常常不需要 Dropout；小语料微调、midtrain 和反复训练时，它仍然可能有用。是否启用，应由训练场景和 train/held-out 表现决定，而不是仅凭“这是大模型”。</p>
</blockquote>
<p>另外，Dropout 也不是一个单纯的性能开关。关闭后即使更快，也可能改变训练行为与正则化强度，不能直接写成 I2 的“免费性能优化”。如果以后做对照，需要固定模型、数据、初始化和训练预算，同时比较训练吞吐、train/held-out loss、BPB 与行为表现。</p>
<h2 id="十二思考val-loss-下降能否直接解决泛化问题">十二、思考：val loss 下降能否直接解决泛化问题？</h2>
<p>顺着 Dropout 的讨论，我又产生了一个想法：既然目标是泛化，是否应该准备一个小样本 val 数据集，通过 val loss 下降来解决，而不是通过 Dropout 这种随机方式？</p>
<p>这里需要把训练手段与评估证据分开。</p>
<blockquote>
<p>val loss 下降是评估结果，不是训练手段。验证集可以测量和选择模型，但本身不会直接让模型学会泛化。</p>
</blockquote>
<p>Validation 的作用是：</p>
<ul>
<li>测量模型在未参与训练的数据上的表现；</li>
<li>帮助选择 checkpoint、学习率、Dropout 和训练步数；</li>
<li>在 val loss 开始恶化时考虑 early stopping；</li>
<li>检查某种训练方法是否可能改善了泛化。</li>
</ul>
<p>如果“用 val loss 选择最佳 checkpoint 或 early stopping”，这是合理的；但它只是从已有训练结果中做选择，不是直接提升模型的泛化能力。</p>
<p>Dropout 与验证集工作在两个阶段：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Dropout：
</span></span><span class="line"><span class="cl">训练时随机屏蔽部分激活
</span></span><span class="line"><span class="cl">→ 减少对特定神经通路的依赖
</span></span><span class="line"><span class="cl">→ 尝试改善训练后的泛化表现
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">Validation：
</span></span><span class="line"><span class="cl">测量 held-out loss / BPB
</span></span><span class="line"><span class="cl">→ 判断这种训练方式是否有效
</span></span></code></pre></div><p>所以它们不是互相替代的两种方案，而是训练方法与评估方法的关系。</p>
<h3 id="loss-下降也不能直接等于学会了">loss 下降也不能直接等于“学会了”</h3>
<p>即使是 val loss 下降，也只是泛化改善的证据之一：</p>
<ul>
<li>小验证集可能有较大的偶然性；</li>
<li>平均 loss 可能被少数样本主导；</li>
<li>模型可能只学到表面模式，行为测试仍然失败；</li>
<li>反复根据 val 结果调参，也可能产生对验证集的适应性过拟合。</li>
</ul>
<p>因此更稳妥的划分是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">train：用于梯度更新
</span></span><span class="line"><span class="cl">val：用于调参、选 checkpoint 和 early stopping
</span></span><span class="line"><span class="cl">test：保持隔离，用于最终验收
</span></span></code></pre></div><p>同时再配合固定行为测试、BPB 和生成样例，而不是只盯着一个 loss 数字。</p>
<p>如果未来比较 <code>dropout=0.0 / 0.05 / 0.1</code>，应该同时观察 train loss、val loss、train/val 差距、固定行为表现以及最终 test 结果。只有当这些证据共同支持时，才能说某种配置在这次实验中可能改善了泛化。</p>
<p>这两个思考最后收敛成同一句话：</p>
<blockquote>
<p><strong>Dropout 是可能改善泛化的训练手段，val/test 是检验泛化的证据；loss 下降本身不会直接解决泛化问题。真正需要建立的是可复现的训练对照和独立的评估证据。</strong></p>
</blockquote>
<h2 id="十三数学回炉从-logitssoftmax-到交叉熵的--lnp">十三、数学回炉：从 logits、Softmax 到交叉熵的 -ln(p)</h2>
<p>在 Activation Checkpointing 的正确性测试中，我又回炉了一个看似早就理解、其实一直说得不够准确的地方：交叉熵到底怎样从模型输出变成 loss？</p>
<h3 id="1-logits-与-target-分别是什么">1. logits 与 target 分别是什么？</h3>
<p>假设一次有 <code>N</code> 个位置需要预测，词表大小为 <code>V</code>：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">logits：(N, V)
</span></span><span class="line"><span class="cl">targets：(N,)
</span></span></code></pre></div><p><code>logits</code> 中每一行都是当前位置对整个词表的预测分数；<code>targets</code> 中每个值则是该位置的正确 token ID。</p>
<p>例如 <code>N=1、V=6</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">logits</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mf">1.</span><span class="p">,</span> <span class="mf">2.</span><span class="p">,</span> <span class="mf">3.</span><span class="p">,</span> <span class="mf">4.</span><span class="p">,</span> <span class="mf">5.</span><span class="p">,</span> <span class="mf">6.</span><span class="p">]])</span>
</span></span><span class="line"><span class="cl"><span class="n">target</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">4</span><span class="p">])</span>
</span></span></code></pre></div><p>这里 <code>target=4</code> 表示正确类别的下标是 4，不是“target 的概率就是 1”。如果要写成理想的 one-hot 目标分布，才是 <code>[0, 0, 0, 0, 1, 0]</code>。</p>
<h3 id="2-softmax-不会减少维度也不会替训练取-argmax">2. Softmax 不会减少维度，也不会替训练取 argmax</h3>
<p>经过 <code>log_softmax</code> 后，形状仍然是 <code>(N, V)</code>。它只是把每个位置上的一组 logits 转换成概率分布。</p>
<p>训练时不会取“概率最大的 token”，而是使用 target 中已知的正确 token ID，取出它对应的对数概率：</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">log_probs</span> <span class="o">=</span> <span class="n">F</span><span class="o">.</span><span class="n">log_softmax</span><span class="p">(</span><span class="n">logits</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="c1"># (N, V)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">loss_per_token</span> <span class="o">=</span> <span class="o">-</span><span class="n">log_probs</span><span class="p">[</span>
</span></span><span class="line"><span class="cl">    <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="n">N</span><span class="p">),</span>
</span></span><span class="line"><span class="cl">    <span class="n">targets</span><span class="p">,</span>
</span></span><span class="line"><span class="cl"><span class="p">]</span>  <span class="c1"># (N,)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">loss</span> <span class="o">=</span> <span class="n">loss_per_token</span><span class="o">.</span><span class="n">mean</span><span class="p">()</span>  <span class="c1"># 标量</span>
</span></span></code></pre></div><p>所以交叉熵不是 <code>(N, V)</code> 与 <code>(N,)</code> 的直接逐元素比较，而是“根据正确类别下标取概率，再计算负对数”。</p>
<p>取概率最大的 token 属于生成/预测阶段的 argmax，不是交叉熵训练。</p>
<h3 id="3-为什么-flatten-后就能计算-loss">3. 为什么 flatten 后就能计算 loss？</h3>
<p>语言模型输出是 <code>(B, T, V)</code>，target 是 <code>(B, T)</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">logits</span><span class="o">.</span><span class="n">flatten</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>  <span class="c1"># 合并 B 和 T，保留 V，得到 (B*T, V)</span>
</span></span><span class="line"><span class="cl"><span class="n">targets</span><span class="o">.</span><span class="n">flatten</span><span class="p">()</span>     <span class="c1"># 展开所有维度，得到 (B*T,)</span>
</span></span></code></pre></div><p><code>flatten(0, 1)</code> 中的 0 和 1 是维度编号，不是取第 0 个和第 1 个元素。</p>
<p>logits 不能直接使用 <code>flatten()</code>，否则会把词表维度也展开，破坏每个位置的类别分布。</p>
<h3 id="4--lnp-到底在计算什么">4. -ln(p) 到底在计算什么？</h3>
<p>当正确 token 经过 Softmax 后的概率为 <code>p</code>，它的交叉熵损失是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">loss = -ln(p)
</span></span></code></pre></div><p>这不是 <code>100 - 百分比概率</code>，而是正确 token 概率的负自然对数：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">p = 0.40 → loss = -ln(0.40) ≈ 0.9163
</span></span><span class="line"><span class="cl">p = 0.99 → loss = -ln(0.99) ≈ 0.01005
</span></span><span class="line"><span class="cl">p = 1.00 → loss = 0
</span></span></code></pre></div><p>正确 token 的概率越高，loss 越小；概率越接近 0，loss 越大。</p>
<p>这里的“值越大 loss 越小”，指的是<strong>正确 token 的概率 p 越大</strong>，不是任意错误 token 的 logit 越大。</p>
<h3 id="5-lnp-的数学含义">5. ln(p) 的数学含义</h3>
<p><code>ln(p)</code> 是以自然常数 <code>e</code> 为底的对数：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">ln(p) = logₑ(p)
</span></span><span class="line"><span class="cl">e ≈ 2.71828
</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">y = ln(p)  ⇔  eʸ = p
</span></span></code></pre></div><p>也就是：e 的多少次方等于 p，这个次数就是 ln(p)。</p>
<p>例如：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">ln(1) = 0，因为 e⁰ = 1
</span></span><span class="line"><span class="cl">ln(e) = 1，因为 e¹ = e
</span></span><span class="line"><span class="cl">ln(0.5) ≈ -0.6931
</span></span></code></pre></div><p><code>ln</code> 是自然对数，不是 <code>log10</code>，并且要求 <code>p &gt; 0</code>，所以 <code>ln(0)</code> 没有定义。</p>
<p>当 <code>0 &lt; p &lt; 1</code> 时，<code>ln(p)</code> 是负数；交叉熵前面的负号再把它变成非负的损失值。</p>
<h3 id="6-与-bpb-的连接">6. 与 BPB 的连接</h3>
<p>PyTorch 交叉熵默认使用自然对数，单位是 nats。之前计算 BPB 时除以 <code>ln(2)</code>，就是把 nats 转成 bits，再按实际评估文本的 UTF-8 bytes 归一化。</p>
<p>因此，从模型输入到评估指标可以这样串起来：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">token IDs
</span></span><span class="line"><span class="cl">→ 模型输出 logits
</span></span><span class="line"><span class="cl">→ log_softmax
</span></span><span class="line"><span class="cl">→ 取正确 token 的对数概率
</span></span><span class="line"><span class="cl">→ -ln(p) 得到交叉熵 loss
</span></span><span class="line"><span class="cl">→ nats 转 bits
</span></span><span class="line"><span class="cl">→ 按原始文本 bytes 归一化得到 BPB
</span></span></code></pre></div><p>这次回炉让我再次意识到：能写出 <code>F.cross_entropy()</code> 不等于已经讲清它。高数和数学直觉丢了很久也不需要逃避，但暂时不需要另开一门庞大的数学主线；先把当前公式与代码、数值例子和实际指标对应起来，就是有效的补充。</p>
<h3 id="7-后续数学回炉online-softmax">7. 后续数学回炉：Online Softmax</h3>
<p>阅读 FlashAttention 时遇到了 Online Softmax。当前只保留一个核心印象：<strong>它可以把 Softmax 的计算拆成多个块，渐进式处理输入，而不需要一次性生成并保存完整的注意力概率矩阵。</strong></p>
<p>为了避免和 memmap 混淆，这里不写成“渐进式加载”，而写成“<strong>分块渐进计算</strong>”。</p>
<p>当前理解是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">分块读取并计算当前分数
</span></span><span class="line"><span class="cl">→ 用 m、l、acc 保存累计状态
</span></span><span class="line"><span class="cl">→ 如果出现新的最大值，用缩放系数修正旧的累计状态
</span></span><span class="line"><span class="cl">→ 所有块处理完后，再统一完成归一化
</span></span></code></pre></div><p>其中：</p>
<ul>
<li><code>m</code>：目前见过的最大值；</li>
<li><code>l</code>：当前累计分母；</li>
<li><code>acc</code>：当前累计分子，在注意力中还包括对 V 的加权结果；</li>
<li>新最大值出现时，旧累计状态使用 <code>exp(旧 m - 新 m)</code> 进行修正。</li>
</ul>
<p>它不是每来一个新块，就把前面所有元素的概率重新计算一遍；也不是在中途反复生成最终概率，而是先累计，最后统一归一化。</p>
<p><code>acc</code> 和 <code>l</code> 也不是用来保存“每个元素各自的概率”。如果确实需要某个元素的最终概率，仍然要用它的分数、最终最大值和最终分母计算；FlashAttention 的价值恰恰在于不需要显式生成并保存完整的 <code>T × T</code> 概率矩阵。</p>
<p><strong>当前掌握边界</strong>：对 Online Softmax 有大致直觉，但数学推导和代码细节仍然比较晕。后续统一安排数学回炉，再把最大值修正、累计分子分母和注意力输出推导清楚。当前不因此阻塞 I2，也不要求今天把公式背下来。</p>
<h2 id="十四今日实验结果汇总">十四、今日实验结果汇总</h2>
<p>以下结果都来自当前 Mac/MPS、同一小型 model_v3 配置：<code>batch_size=2</code>、<code>context_length=128</code>、2 步 warmup、10 步正式测量，共 2560 个正式测量 tokens。模型初始化、数据顺序和训练步数保持固定，性能测量在计时边界调用设备 <code>synchronize()</code>。</p>
<p>每种配置至少重复 3 次，使用 tokens/s 中位数判断主要趋势，不只挑最快的一次。原始逐次报告保存在 <code>data/reports/i2-*.json</code>，下表是汇总，不覆盖原始记录。</p>
<h3 id="1-fp32--bf16--fp16-混合精度对照">1. FP32 / BF16 / FP16 混合精度对照</h3>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>精度</th>
        <th style="text-align: right">第 1 次 tokens/s</th>
        <th style="text-align: right">第 2 次 tokens/s</th>
        <th style="text-align: right">第 3 次 tokens/s</th>
        <th style="text-align: right">中位数</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>FP32</td>
        <td style="text-align: right">11001.65</td>
        <td style="text-align: right">10980.90</td>
        <td style="text-align: right">11187.75</td>
        <td style="text-align: right"><strong>11001.65</strong></td>
      </tr>
      <tr>
        <td>BF16</td>
        <td style="text-align: right">9729.78</td>
        <td style="text-align: right">9951.59</td>
        <td style="text-align: right">9942.47</td>
        <td style="text-align: right"><strong>9942.47</strong></td>
      </tr>
      <tr>
        <td>FP16</td>
        <td style="text-align: right">9789.83</td>
        <td style="text-align: right">9903.21</td>
        <td style="text-align: right">9892.09</td>
        <td style="text-align: right"><strong>9892.09</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<p>当前结果：</p>
<ul>
<li>FP32 在这组对照中稳定最快；</li>
<li>BF16 与 FP16 中位数只差约 0.5%，三次区间存在重叠，不能说 FP16 明显强于 BF16，更合理的是两者基本同档；</li>
<li>当前 Mac/MPS、小模型和短序列训练下，混合精度没有体现吞吐收益；</li>
<li>三组 loss 均没有 NaN/Inf，但短训练 loss 波动不被解释为模型质量变化。</li>
</ul>
<p>这次重复测量也纠正了单次实验的直觉：第一次看到 FP16 高于 BF16，不代表差异稳定；需要重复测量才能判断。</p>
<h3 id="2-eager-与-sdpa-对照">2. eager 与 SDPA 对照</h3>
<p>首先通过 <code>tests/test_sdpa_attention.py</code>，在同权重、同输入的小模型 CPU 测试中，eager 与 SDPA 的完整 prefill 和逐 token decode 数值对照通过：<code>1 passed</code>。</p>
<p>训练吞吐结果：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>配置</th>
        <th style="text-align: right">第 1 次 tokens/s</th>
        <th style="text-align: right">第 2 次 tokens/s</th>
        <th style="text-align: right">第 3 次 tokens/s</th>
        <th style="text-align: right">中位数</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>eager + FP32</td>
        <td style="text-align: right">11001.65</td>
        <td style="text-align: right">10980.90</td>
        <td style="text-align: right">11187.75</td>
        <td style="text-align: right"><strong>11001.65</strong></td>
      </tr>
      <tr>
        <td>SDPA + FP32</td>
        <td style="text-align: right">10943.51</td>
        <td style="text-align: right">10613.57</td>
        <td style="text-align: right">9803.70</td>
        <td style="text-align: right"><strong>10613.57</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<p>SDPA 中位数比 eager 低约 <strong>3.53%</strong>，当前小模型/MPS 场景没有体现吞吐收益。这个结果不推广到 CUDA、大模型或长上下文，也不证明 FlashAttention 已被使用。</p>
<h3 id="3-torchcompile-对照">3. torch.compile 对照</h3>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>配置</th>
        <th style="text-align: right">第 1 次 tokens/s</th>
        <th style="text-align: right">第 2 次 tokens/s</th>
        <th style="text-align: right">第 3 次 tokens/s</th>
        <th style="text-align: right">中位数</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>eager + FP32</td>
        <td style="text-align: right">11001.65</td>
        <td style="text-align: right">10980.90</td>
        <td style="text-align: right">11187.75</td>
        <td style="text-align: right"><strong>11001.65</strong></td>
      </tr>
      <tr>
        <td>compile + FP32</td>
        <td style="text-align: right">11564.11</td>
        <td style="text-align: right">11801.10</td>
        <td style="text-align: right">12208.14</td>
        <td style="text-align: right"><strong>11801.10</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<p>compile 中位数相对 eager 基线约提升 <strong>7.27%</strong>，是当前第一个看到明确正向收益的训练优化项。</p>
<p>但需要保留：</p>
<ul>
<li>三次结果从 11564 逐步升到 12208，波动比基线大，后续可以用更长测量继续验证；</li>
<li>warmup 排除了首次编译成本，因此这是稳态吞吐，不包含启动时间；</li>
<li><code>Not enough SMs to use max_autotune_gemm mode</code> 是当前没有足够 CUDA SM 使用对应 GEMM 自动调优的提示，不是编译失败，也不代表 MPS 获得了 CUDA 的全部优化。</li>
</ul>
<h3 id="4-activation-checkpointing-对照">4. Activation Checkpointing 对照</h3>
<p><code>tests/test_activation_checkpointing.py</code> 已通过：在同权重、同输入的小模型训练中，开启与关闭 checkpointing 的前向 logits、loss 和反向梯度一致，<code>1 passed</code>。</p>
<p>内存与吞吐对照使用<strong>单独一批带内存快照的 FP32 基线</strong>，不与其他实验批次的 FP32 数字混用：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>指标</th>
        <th style="text-align: right">不使用 checkpointing</th>
        <th style="text-align: right">使用 checkpointing</th>
        <th style="text-align: right">变化</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>训练吞吐中位数</td>
        <td style="text-align: right">11321.03 tokens/s</td>
        <td style="text-align: right">10714.24 tokens/s</td>
        <td style="text-align: right"><strong>下降约 5.36%</strong></td>
      </tr>
      <tr>
        <td>当前分配内存</td>
        <td style="text-align: right">320,780,800 bytes</td>
        <td style="text-align: right">320,780,800 bytes</td>
        <td style="text-align: right">不变</td>
      </tr>
      <tr>
        <td>驱动分配内存中位数</td>
        <td style="text-align: right">1,423,097,856 bytes</td>
        <td style="text-align: right">1,414,709,248 bytes</td>
        <td style="text-align: right"><strong>减少 8 MiB</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<p>这体现了“用额外计算换显存”的代价与收益：吞吐下降，驱动分配内存小幅减少，模型权重和当前分配内存不会因此消失。</p>
<p>当前 MPS 只提供 <code>current_allocated_memory()</code> 与 <code>driver_allocated_memory()</code>，没有使用峰值显存接口，因此不写成“峰值显存降低 8 MiB”。</p>
<p>边界仍是当前 Mac/MPS、2 层小模型、batch=2、context=128；不能推广为所有模型都固定节省 8 MiB 或固定慢 5.36%。</p>
<h3 id="5-实验结论边界">5. 实验结论边界</h3>
<p>今天的对照说明：</p>
<ul>
<li>AMP、SDPA、compile 和 Activation Checkpointing 不是同一种“加速开关”；</li>
<li>它们分别改变计算精度、注意力实现、执行图优化和激活保存策略；</li>
<li>性能收益必须与正确性、内存和额外代价一起评估；</li>
<li>当前结果只适用于已经列明的硬件、模型和测量配置。</li>
</ul>
<p>最终相关回归已于 2026-11-10 执行：<strong>16 passed in 33.02s</strong>。覆盖 Qwen 专项、SDPA 对照、Activation Checkpointing 的 logits/梯度对照、Markdown 清洗、token store 与 memmap Dataset，不调用外部评估 API。它证明当前改动通过了已有相关回归，但不等于所有性能验收项都已完成。</p>
<p>Windows + RTX 4070 Ti 的 CUDA 番外仍是后续计划，尚未产生实测结果。</p>
<p>经确认，I2 主线于 2026-11-10 按当前 Mac/MPS 实验范围收官；MFU、峰值显存与经典 GPT-2 / model_v3 训练吞吐对照移至 Windows + RTX 4070 Ti 番外，不把未测指标写成已完成。</p>
]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 18：I1，让语料从文本流向可训练数据</title>
      <link>https://blog.lvxinrong.com/llm/llm-18-i1-data-pipeline/</link>
      <pubDate>Tue, 10 Nov 2026 12:25:26 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-18-i1-data-pipeline/</guid>
      <description>从博客源文档清单、最小清洗和 JSONL，到 uint32 token 文件、np.memmap、训练冒烟、BPB 与 Scaling 测算；重点不是训练大模型，而是把数据如何进入模型这条链路打通。</description>
      <content:encoded><![CDATA[<blockquote>
<p>今天没有训练一个更强的大模型，而是回答另一个更基础的问题：一堆博客文章，怎样变成可以追溯、可以流式读取、可以参与训练和评估的数据？</p>
</blockquote>
<h2 id="一i1-要解决什么">一、I1 要解决什么？</h2>
<p>第一阶段和 I0 的代码已经可以完成模型训练与推理，但数据侧仍然存在一个隐患：所有东西都会被提前装进内存。</p>
<p>旧的 <code>TokenStreamDataset</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">ids</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">for</span> <span class="n">text</span> <span class="ow">in</span> <span class="n">texts</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">    <span class="n">ids</span><span class="o">.</span><span class="n">extend</span><span class="p">(</span><span class="n">tokenizer</span><span class="o">.</span><span class="n">encode</span><span class="p">(</span><span class="n">text</span><span class="p">))</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">ids</span><span class="p">)</span> <span class="o">-</span> <span class="n">max_length</span><span class="p">,</span> <span class="n">stride</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="bp">self</span><span class="o">.</span><span class="n">input_ids</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">ids</span><span class="p">[</span><span class="n">i</span><span class="p">:</span><span class="n">i</span> <span class="o">+</span> <span class="n">max_length</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">    <span class="bp">self</span><span class="o">.</span><span class="n">target_ids</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">ids</span><span class="p">[</span><span class="n">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">:</span><span class="n">i</span> <span class="o">+</span> <span class="n">max_length</span> <span class="o">+</span> <span class="mi">1</span><span class="p">])</span>
</span></span></code></pre></div><p>这里有三层全量物化：</p>
<ol>
<li>全部文本被读入内存；</li>
<li>全部 token IDs 被放进 Python list；</li>
<li>所有 input/target 窗口又被提前保存成两个 list。</li>
</ol>
<p>在当前个人博客规模下，它并不慢，也不构成明显内存压力。但如果未来语料扩大，这种写法会让内存随语料总量增长。</p>
<p>所以 I1 的目标不是“让今天的数据突然变快”，而是建立一条更可扩展的主干：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">源文档清单
</span></span><span class="line"><span class="cl">→ 最小清洗
</span></span><span class="line"><span class="cl">→ train / held-out 隔离
</span></span><span class="line"><span class="cl">→ JSONL 文档流
</span></span><span class="line"><span class="cl">→ uint32 token 文件
</span></span><span class="line"><span class="cl">→ np.memmap 按需读取
</span></span><span class="line"><span class="cl">→ 训练与 BPB 评估
</span></span></code></pre></div><h2 id="二先盘点42-条文档不都是文章">二、先盘点：42 条文档不都是文章</h2>
<p>第一步没有直接清洗，而是从 <code>lv_blog/content/**/*.md</code> 重新建立文档级清单。</p>
<p><code>train.txt</code> 已经把多篇文章拼成了一个大字符串，无法单独追溯每一篇。新的清单直接读取原始 Markdown，并保留标题、路径、日期、正文大小和 SHA-256。</p>
<p>第一次汇总：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">included_documents = 42
</span></span><span class="line"><span class="cl">excluded:
</span></span><span class="line"><span class="cl">  index  = 9
</span></span><span class="line"><span class="cl">  layout = 3
</span></span><span class="line"><span class="cl">  draft  = 14
</span></span></code></pre></div><p>我一开始觉得数量对不上，因为印象里应该是“接近 40 篇”。继续检查后发现，42 条中还包含：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">content/about.md       → 关于页面
</span></span><span class="line"><span class="cl">content/roadmap.md     → 学习路线图
</span></span><span class="line"><span class="cl">content/llm-backlog.md → 学习回炉待办
</span></span></code></pre></div><p>于是增加了 <code>document_type</code>，得到：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">article  = 39
</span></span><span class="line"><span class="cl">profile  = 1
</span></span><span class="line"><span class="cl">roadmap  = 1
</span></span><span class="line"><span class="cl">backlog  = 1
</span></span><span class="line"><span class="cl">合计     = 42
</span></span></code></pre></div><p>这正好解释了数量差异。</p>
<p>这次盘点让我看到：<strong>数据口径不一致时，先分类和追溯，不要急着删除或强行让数字相等。</strong></p>
<h2 id="三manifest-是数据档案不是训练文本">三、manifest 是数据档案，不是训练文本</h2>
<p>今天生成了几种不同用途的文件，需要分清：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">source inventory / corpus manifest
</span></span><span class="line"><span class="cl">记录文档来源、类型、划分、大小和 hash
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">train.jsonl / heldout.jsonl
</span></span><span class="line"><span class="cl">保存一篇篇清洗后的实际文档内容
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">token store metadata
</span></span><span class="line"><span class="cl">记录 tokenizer、dtype、EOS、文档 offset / length 和 hash
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">memmap Dataset
</span></span><span class="line"><span class="cl">根据二进制 token 文件与训练窗口配置，按需产生样本
</span></span></code></pre></div><p>manifest 不是模型直接读取的正文，而是整批数据的档案。后续要证明两次实验使用的是同一批数据，不能只写“用了博客语料”，还要能对应到具体版本和内容指纹。</p>
<h2 id="四sha-256-在这里做什么">四、SHA-256 在这里做什么？</h2>
<p>SHA-256 在当前管线里只是内容指纹，不是加密，也不会参与模型计算。</p>
<p>它主要有四个用途：</p>
<ol>
<li>检查完全重复的正文；</li>
<li>防止同一篇内容同时进入 train 和 held-out；</li>
<li>判断文件或正文是否发生变化；</li>
<li>让训练、BPB 和评估报告能追溯到具体数据版本。</li>
</ol>
<p>今天还区分了两种 hash：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">source_sha256
</span></span><span class="line"><span class="cl">→ 清洗后正文
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">encoded_sha256
</span></span><span class="line"><span class="cl">→ 实际送入 tokenizer 的“标题 + 正文”
</span></span></code></pre></div><p>这两个值需要分开，因为后续加入标题以后，正文 hash 已经不能代表完整的编码输入。</p>
<h2 id="五清洗只做到够用不做通用平台">五、清洗只做到够用，不做通用平台</h2>
<p>我的博客格式比较固定，部分文章存在图片链接。今天的决定是：不写通用 Markdown 解析器，只覆盖当前真实格式。</p>
<p><code>src/squid/data/markdown.py</code> 只做：</p>
<ul>
<li>普通链接保留显示文字；</li>
<li>图片保留 alt，无 alt 则删除；</li>
<li>合并多余空行；</li>
<li>按代码块分段，代码内部不应用清洗规则。</li>
</ul>
<p>代码块需要单独保护，否则代码里的注释或字符串也可能被误当成 Markdown 链接和图片。</p>
<p><code>tests/test_markdown.py</code> 验收了 5 个场景：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">普通链接保留文字
</span></span><span class="line"><span class="cl">图片保留 alt
</span></span><span class="line"><span class="cl">无 alt 图片删除
</span></span><span class="line"><span class="cl">代码块保持不变
</span></span><span class="line"><span class="cl">多余空行合并
</span></span></code></pre></div><p>结果：<code>5 passed</code>。</p>
<p>这里刻意没有继续做 OCR、通用质量评分、复杂清洗规则或完整 MinHash 管线。当前语料规模小、来源可信，清洗够用地服务主干即可。未来如果有大批量语料，再借助 AI 完成更系统的清洗与划分也来得及。</p>
<h2 id="六第一次接触-jsonl">六、第一次接触 JSONL</h2>
<p>清洗后的文档被写成：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">data/corpus/blog_v1/train.jsonl
</span></span><span class="line"><span class="cl">data/corpus/blog_v1/heldout.jsonl
</span></span></code></pre></div><p>JSONL 是 JSON Lines，一行一个完整 JSON 对象：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-jsonl" data-lang="jsonl"><span class="line"><span class="cl"><span class="p">{</span><span class="nt">&#34;title&#34;</span><span class="p">:</span> <span class="s2">&#34;第一篇&#34;</span><span class="p">,</span> <span class="nt">&#34;text&#34;</span><span class="p">:</span> <span class="s2">&#34;第一篇正文&#34;</span><span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span><span class="nt">&#34;title&#34;</span><span class="p">:</span> <span class="s2">&#34;第二篇&#34;</span><span class="p">,</span> <span class="nt">&#34;text&#34;</span><span class="p">:</span> <span class="s2">&#34;第二篇正文&#34;</span><span class="p">}</span>
</span></span></code></pre></div><p>它和 JSON 数组不同，不需要一次性读取整个文件，可以：</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">with</span> <span class="nb">open</span><span class="p">(</span><span class="n">path</span><span class="p">,</span> <span class="n">encoding</span><span class="o">=</span><span class="s2">&#34;utf-8&#34;</span><span class="p">)</span> <span class="k">as</span> <span class="n">file</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">file</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="n">document</span> <span class="o">=</span> <span class="n">json</span><span class="o">.</span><span class="n">loads</span><span class="p">(</span><span class="n">line</span><span class="p">)</span>
</span></span></code></pre></div><p>正文中的换行会被转义为 <code>\n</code>，读取后再还原，因此仍能保持“一行一篇”。</p>
<p>JSONL 不适合用 <code>indent=2</code> 美化，否则一条记录会跨多行。<code>manifest.json</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">train_documents   = 38
</span></span><span class="line"><span class="cl">heldout_documents = 2
</span></span><span class="line"><span class="cl">total_documents   = 40
</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">39 篇文章 + 1 篇 profile = 40 个候选
</span></span><span class="line"><span class="cl">40 - 2 篇固定 held-out = 38 条训练候选
</span></span></code></pre></div><p>原有 held-out 继续隔离，没有因为重新生成语料而混回训练集。</p>
<h2 id="七标题应该进入训练文本">七、标题应该进入训练文本</h2>
<p>最初 <code>write_tokens()</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">document</span><span class="p">[</span><span class="s2">&#34;text&#34;</span><span class="p">]</span>
</span></span></code></pre></div><p>我随后意识到：标题对我来说很重要，它不是单纯的文件名，也承载文章主题和表达结构。</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">text</span> <span class="o">=</span> <span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="sa">f</span><span class="s2">&#34;# </span><span class="si">{</span><span class="n">document</span><span class="p">[</span><span class="s1">&#39;title&#39;</span><span class="p">]</span><span class="si">}</span><span class="se">\n\n</span><span class="s2">&#34;</span>
</span></span><span class="line"><span class="cl">    <span class="sa">f</span><span class="s2">&#34;</span><span class="si">{</span><span class="n">document</span><span class="p">[</span><span class="s1">&#39;text&#39;</span><span class="p">]</span><span class="si">}</span><span class="s2">&#34;</span>
</span></span><span class="line"><span class="cl"><span class="p">)</span>
</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"># 文章标题
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">清洗后的正文……
</span></span></code></pre></div><p>metadata 中同时记录：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-json" data-lang="json"><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;include_title&#34;</span><span class="p">:</span> <span class="kc">true</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;title_template&#34;</span><span class="p">:</span> <span class="s2">&#34;# {title}\n\n{text}&#34;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>这样以后看到 token 文件，就能明确知道标题有没有参与训练，以及是怎样拼入的。</p>
<h2 id="八为什么-token-文件使用-uint32">八、为什么 token 文件使用 uint32？</h2>
<p>Qwen 的词表大小是 <code>151936</code>，而 <code>uint16</code> 最大只能表示 <code>65535</code>。</p>
<p>因此不能为了节省空间使用 uint16，当前统一使用：</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">np</span><span class="o">.</span><span class="n">asarray</span><span class="p">(</span><span class="n">ids</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="n">np</span><span class="o">.</span><span class="n">uint32</span><span class="p">)</span>
</span></span></code></pre></div><p>每个 token 固定占 4 bytes。</p>
<p><code>build_token_store.py</code> 的主干是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">逐行读取一篇 JSONL
</span></span><span class="line"><span class="cl">→ 拼接标题与正文
</span></span><span class="line"><span class="cl">→ 编码当前文档
</span></span><span class="line"><span class="cl">→ 追加 EOS ID
</span></span><span class="line"><span class="cl">→ 转成 uint32
</span></span><span class="line"><span class="cl">→ 写入二进制文件
</span></span><span class="line"><span class="cl">→ 记录 offset、length 和 hash
</span></span></code></pre></div><p>这里修正过一个属性错误：需要写入的是整数 <code>tokenizer.eos_id</code>，不是字符串 <code>eos_token</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">data/token_store/blog_v1/
</span></span><span class="line"><span class="cl">├── train.uint32.bin
</span></span><span class="line"><span class="cl">├── heldout.uint32.bin
</span></span><span class="line"><span class="cl">└── metadata.json
</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">train_tokens   = 117890
</span></span><span class="line"><span class="cl">heldout_tokens = 5485
</span></span></code></pre></div><p>metadata 还验证了：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">二进制文件 bytes = token_count × 4
</span></span></code></pre></div><h2 id="九memmap从保存所有窗口改成用时再切">九、memmap：从“保存所有窗口”改成“用时再切”</h2>
<p><code>np.memmap</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">tokens</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">memmap</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">token_path</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">dtype</span><span class="o">=</span><span class="s2">&#34;uint32&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">mode</span><span class="o">=</span><span class="s2">&#34;r&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl"><span class="p">)</span>
</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"># 关于
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">## 我是谁
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">吕炘嵘，一个写了十一年多代码的人……
</span></span></code></pre></div><p>新的 <code>MemmapTokenDataset</code> 不再提前保存所有窗口，只保存映射、窗口长度、stride 和样本数量：</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">start</span> <span class="o">=</span> <span class="n">idx</span> <span class="o">*</span> <span class="bp">self</span><span class="o">.</span><span class="n">stride</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">input_ids</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">tokens</span><span class="p">[</span>
</span></span><span class="line"><span class="cl">    <span class="n">start</span><span class="p">:</span><span class="n">start</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">max_length</span>
</span></span><span class="line"><span class="cl"><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="n">target_ids</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">tokens</span><span class="p">[</span>
</span></span><span class="line"><span class="cl">    <span class="n">start</span> <span class="o">+</span> <span class="mi">1</span><span class="p">:</span><span class="n">start</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">max_length</span> <span class="o">+</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl"><span class="p">]</span>
</span></span></code></pre></div><p>交给模型前再转换成 <code>torch.long</code>，因为 Embedding 索引需要整数张量。</p>
<h3 id="最后一个窗口会不会越界">最后一个窗口会不会越界？</h3>
<p><code>sample_count</code> 使用与旧实现一致的窗口起点范围。设 token 总数为 <code>L</code>、窗口长度为 <code>M</code>，最后一个起点满足：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">start &lt;= L - M - 1
</span></span></code></pre></div><p>因此 target 的切片结束位置最多为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">start + M + 1 &lt;= L
</span></span></code></pre></div><p>刚好不会超出末尾。</p>
<p>NumPy 切片越界时通常会静默返回较短数组，所以测试不能只比较新旧实现，还需要独立检查每个 input/target 的 shape 都是 <code>(128,)</code>。</p>
<h2 id="十先做内容对照再谈内存优化">十、先做内容对照，再谈内存优化</h2>
<p>今天写了两层对照：</p>
<ol>
<li><code>test_token_store_matches_pack_tokens</code>：二进制 token 流与旧 <code>pack_tokens()</code> 逐元素一致，offset、length 和 EOS 也一致；</li>
<li><code>test_memmap_dataset_matches_legacy_dataset</code>：在 stride 64 和 128 下，新旧 Dataset 的选中窗口内容一致。</li>
</ol>
<p>全部通过。</p>
<p>第一次内存对照还暴露了一个实验设计错误：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">旧 Dataset 使用旧 train.txt：69316 tokens → 541 窗口
</span></span><span class="line"><span class="cl">新 Dataset 使用新 token store：117890 tokens → 921 窗口
</span></span></code></pre></div><p>输入不同，内存数字就不能直接比较。</p>
<p>修正为两边都使用同一个 <code>train.uint32.bin</code> 后，得到：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>实现</th>
        <th style="text-align: right">source tokens</th>
        <th style="text-align: right">windows</th>
        <th style="text-align: right">Python 当前分配</th>
        <th style="text-align: right">Python 峰值分配</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>旧 TokenStreamDataset</td>
        <td style="text-align: right">117890</td>
        <td style="text-align: right">921</td>
        <td style="text-align: right">2,004,496 bytes</td>
        <td style="text-align: right">2,004,672 bytes</td>
      </tr>
      <tr>
        <td>MemmapTokenDataset</td>
        <td style="text-align: right">117890</td>
        <td style="text-align: right">921</td>
        <td style="text-align: right">1,766 bytes</td>
        <td style="text-align: right">8,505 bytes</td>
      </tr>
    </tbody>
  </table>
</div>
<p>这才是同输入对照。</p>
<p>减少的是“提前物化所有窗口”的 Python 分配，不是宣称操作系统映射页面完全不占内存。<code>tracemalloc</code> 也无法覆盖所有底层和 OS 内存。</p>
<p>两边的构建时间分别是约 <code>2.50 ms</code> 与 <code>8.25 ms</code>，单次毫秒级结果不能用来证明 memmap 更慢或更快。当前优化的目标是可扩展性，不是这几毫秒。</p>
<h2 id="十一让-memmap-数据真正进入训练">十一、让 memmap 数据真正进入训练</h2>
<p>随后用一个小型 <code>GPTModelV3</code> 做了 5 步训练冒烟：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">emb_dim = 64
</span></span><span class="line"><span class="cl">ffn_dim = 256
</span></span><span class="line"><span class="cl">n_layers = 2
</span></span><span class="line"><span class="cl">n_heads = 4
</span></span><span class="line"><span class="cl">n_kv_heads = 2
</span></span><span class="line"><span class="cl">context_length = 128
</span></span><span class="line"><span class="cl">vocab_size = 151936
</span></span></code></pre></div><p>没有加载 Qwen 权重，不追求模型质量，只验证：</p>
<ul>
<li>memmap 样本能进入模型；</li>
<li>loss 是有限值；</li>
<li>backward 与 optimizer 能执行；</li>
<li>checkpoint 能保存与重载；</li>
<li>重载前后同一批输入的 logits 完全一致。</li>
</ul>
<p>实测 loss：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">12.1019 → 12.1559 → 12.0544 → 12.1084 → 12.0915
</span></span></code></pre></div><p>没有断言 loss 必须下降，因为 5 步随机批次训练不能支持这种要求。</p>
<p>作为数量级参照，词表均匀分布时交叉熵约为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">ln(151936) ≈ 11.93
</span></span></code></pre></div><p>所以这里的 loss 只能说明训练链路可运行，不能说明模型已经学会博客内容。</p>
<h2 id="十二bpb把-loss-归一到原始文本字节">十二、BPB：把 loss 归一到原始文本字节</h2>
<p>BPB 是 Bits Per Byte，表示平均每个原始 UTF-8 字节对应多少 bits 的预测/编码成本。同一份评估文本、同一口径下，通常越低越好。</p>
<p>它需要模型 loss 参与，不是 tokenizer 单独能计算的指标：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">BPB = 总交叉熵 nats / ln(2) / 总评估 UTF-8 bytes
</span></span></code></pre></div><p>今天的 held-out 冒烟报告：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">evaluated_tokens      = 5376
</span></span><span class="line"><span class="cl">evaluated_utf8_bytes  = 18932
</span></span><span class="line"><span class="cl">mean_loss             = 12.081579798743839
</span></span><span class="line"><span class="cl">BPB                   = 4.949496596618363
</span></span></code></pre></div><p>计算时按 target 数累计交叉熵，避免最后一个较小 batch 被赋予与完整 batch 相同的平均权重；EOS 不折算成自然文本字节。</p>
<p>这个数值只验证 BPB 计算链路，不代表 Qwen，也不代表个人 midtrain 效果。换数据集或评估口径后，不能直接拿 BPB 比较。</p>
<h2 id="十三parametersnumel-与-scaling-测算">十三、parameters、numel 与 Scaling 测算</h2>
<p><code>parameter.numel()</code> 是 number of elements，计算参数张量中有多少个元素。</p>
<p>例如：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">形状 (10, 64) 的权重
</span></span><span class="line"><span class="cl">numel = 10 × 64 = 640
</span></span></code></pre></div><p><code>model.parameters()</code> 会遍历模型中注册的 Parameter，包括 Linear、Embedding、RMSNorm 等模块内部的底层可学习张量；mask 和 inv_freq 这类 buffer 不属于 Parameter。</p>
<p>当前冒烟模型实际参数量：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">19,571,264
</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">tok_emb.weight  = 9,723,904
</span></span><span class="line"><span class="cl">out_head.weight = 9,723,904
</span></span></code></pre></div><p>两块合计 <code>19,447,808</code>，约占整个模型的 <strong>99.37%</strong>。</p>
<p>因为当前冒烟配置是 <code>tie_word_embeddings=False</code>，输入与输出是两套独立权重。如果改为共享，总参数约为 <code>9,847,360</code>，几乎减半。</p>
<p>这也重新解释了 Weight Tying：不是两个模块变成一个，而是 <code>out_head.weight</code> 与 <code>tok_emb.weight</code> 指向同一个底层 Parameter。</p>
<h3 id="chinchilla一个从零预训练的参考基线">Chinchilla：一个从零预训练的参考基线</h3>
<p>Chinchilla 是 DeepMind 在 2022 年提出的模型及训练研究，论文是 <a href="https://arxiv.org/abs/2203.15556">《Training Compute-Optimal Large Language Models》</a>。</p>
<p>它研究的核心问题是：</p>
<blockquote>
<p>在训练算力有限的情况下，参数量和训练 token 数应该怎样搭配？</p>
</blockquote>
<p>当时很多模型倾向于不断扩大参数量，但训练数据量没有同步增加。Chinchilla 指出：很多大模型其实处于训练不足的状态，不能只堆参数，还要同步增加数据。</p>
<p>Chinchilla 使用大约 70B 参数和 1.4T tokens，两者之比约为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">1.4T tokens / 70B 参数 ≈ 20 tokens / 参数
</span></span></code></pre></div><p>因此，“约 20 tokens/参数”后来常被用作从零预训练的一个粗略参考。它不是严格的物理定律，也不是所有模型都必须满足的门槛。</p>
<h3 id="为什么它叫计算最优参考">为什么它叫“计算最优”参考？</h3>
<p>常见的 Transformer 训练计算量可以粗略理解为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">训练计算量 ≈ 6 × 参数量 × 训练 token 数
</span></span></code></pre></div><p>在算力固定时，参数变大和 token 变多会争夺同一份计算预算：</p>
<ul>
<li>参数很大、数据太少，模型可能训练不足；</li>
<li>数据很多、模型太小，也可能无法充分利用数据中的规律；</li>
<li>Chinchilla 研究的是怎样在这两者之间取得更合理的配比。</li>
</ul>
<p>它不是在讨论“一个参数必须分到 20 个 token 才能训练”，而是在讨论<strong>从零预训练时，怎样让算力配置更接近计算最优</strong>。</p>
<h3 id="用当前模型做一次数量级估算">用当前模型做一次数量级估算</h3>
<p>今天用“约 20 tokens / 参数”做了参考计算：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">当前冒烟模型参数量：19,571,264
</span></span><span class="line"><span class="cl">当前训练语料：117,890 tokens
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">参考 token 量：19,571,264 × 20 = 391,425,280
</span></span><span class="line"><span class="cl">当前语料覆盖率：117,890 / 391,425,280 ≈ 0.000301 ≈ 0.0301%
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">Qwen 0.5B 名义参考 token 量：10,000,000,000
</span></span><span class="line"><span class="cl">当前语料覆盖率：约 0.00118%
</span></span></code></pre></div><p>这说明：按这个经验参考粗略估算，当前博客语料远低于从零计算最优预训练的参考量级。</p>
<p>但它不能推出：</p>
<ul>
<li>当前模型完全不能训练；</li>
<li>小语料训练没有任何效果；</li>
<li>所有模型都必须严格训练到 20 tokens/参数；</li>
<li>个人 midtrain 没有意义。</li>
</ul>
<p>语料少时模型仍可能学到模式，只是更容易重复、记忆或过拟合。现代模型也会因为推理成本、数据质量和训练目标不同，采用不同的实际配比。</p>
<h3 id="计算时还要统一两个口径">计算时还要统一两个口径</h3>
<p><strong>第一，训练总 token 数不等于去重后的语料 token 数</strong>。多轮 epoch 会重复处理同一批语料，不能把“训练时处理的总 token 数”和“唯一语料 token 数”混为一谈。</p>
<p><strong>第二，参数统计口径必须一致</strong>。今天使用的是总参数量，而当前冒烟模型约 99% 参数集中在输入/输出词表矩阵中。这个计算适合建立数量级直觉，不等于完整复现 Chinchilla 论文的 Scaling 实验。</p>
<p>个人 midtrain 是从已有底座继续训练，不是从零学习语言。Chinchilla 在这里的价值是提供一个<strong>参数、数据和算力配比的参考基线</strong>，而不是成为个人语料训练的硬性准入条件。</p>
<h2 id="十四今天记录的后续选修实验">十四、今天记录的后续选修实验</h2>
<p>实验名称：</p>
<blockquote>
<p><strong>在 GPTModel 的多头注意力机制计算中引入门阀装置对比。</strong></p>
</blockquote>
<p>初步想法是在 attention 合头之后、<code>out_proj</code> 之前增加按 token、按特征通道的 sigmoid 门控。</p>
<p>Attention 本身已经通过 softmax 权重决定“从哪些 token 读取信息”；新增门控可以进一步决定“这些 attention 输出在哪些通道上通过多少”。两者作用对象不同，不必然重复。</p>
<p>这个实验当前只记录想法，尚未开始，不阻塞 I1。若承接 Qwen 权重，需要单独处理新增参数与初始化，不能直接 strict 加载原权重。</p>
<h2 id="十五今天的边界与真实完成方式">十五、今天的边界与真实完成方式</h2>
<p>今天完成的是数据管线和指标闭环：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">清单 → 最小清洗 → 划分 → JSONL → uint32 → memmap
</span></span><span class="line"><span class="cl">→ 训练冒烟 → checkpoint → BPB → Scaling 参考测算
</span></span></code></pre></div><p>没有完成或没有展开：</p>
<ul>
<li>个人中文 midtrain；</li>
<li>通用大数据清洗平台；</li>
<li>MinHash 近似去重实现；</li>
<li>大模型训练；</li>
<li>分布式、MoE 和 DeepInfer 部署；</li>
<li>对任意语料规模与任意模型质量的证明。</li>
</ul>
<p>今天的部分工程脚本由 Kimi 提供完整代码，我负责运行、阅读、提问和验收；这部分不写成“全部亲手实现”。核心概念仍需通过复盘和后续默写来确认是否真正掌握。</p>
<h2 id="十六阅读后的四个回答">十六、阅读后的四个回答</h2>
<p>这一节的主体回答由我在阅读草稿后手敲，Kimi 只做了少量结构整理，并修正了 DataLoader 中 shuffle 的一处表述。</p>
<h3 id="1-今天哪些概念只是暂时听懂还需要重新复述">1. 今天哪些概念只是暂时听懂，还需要重新复述？</h3>
<p>概念上的内容基本都能理解。说到底，今天做的事情就是<strong>按需加载</strong>。</p>
<p>之前训练数据比较小，可以全部加载到内存中；当训练语料规模上升后，就需要实现流式加载。<code>np.memmap</code> 的核心作用是在磁盘文件与内存访问之间建立映射关系，只把当前需要的部分交给内存使用，而不是提前把整个文件和全部训练窗口都转成 Python 对象。</p>
<p>所以今天的主干不是“把语料做得多大”，而是“语料变大以后，数据访问方式是否需要改变”。</p>
<h3 id="2-哪些代码需要我重新手写一遍">2. 哪些代码需要我重新手写一遍？</h3>
<p>我理解目前的代码暂时不需要专门考虑重写和回炉。本质上它仍然属于数据处理部分，我需要先理解原理和本质，后续在实际调整和使用过程中还会继续学习。</p>
<p>这不等于宣称每段代码都能脱稿默写，而是当前没有必要为了默写再单独开一轮重复劳动。</p>
<h3 id="3-数据管线和模型训练之间还有哪些关系没有真正打通">3. 数据管线和模型训练之间，还有哪些关系没有真正打通？</h3>
<p>我目前的理解是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">原始文档
</span></span><span class="line"><span class="cl">→ 清洗与 train / held-out 划分
</span></span><span class="line"><span class="cl">→ token store
</span></span><span class="line"><span class="cl">→ Dataset
</span></span><span class="line"><span class="cl">→ input / target 的 +1 错位处理
</span></span><span class="line"><span class="cl">→ DataLoader
</span></span><span class="line"><span class="cl">→ 模型 forward 与 loss
</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">input_ids</span> <span class="o">=</span> <span class="n">tokens</span><span class="p">[</span><span class="n">start</span><span class="p">:</span><span class="n">start</span> <span class="o">+</span> <span class="n">max_length</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="n">target_ids</span> <span class="o">=</span> <span class="n">tokens</span><span class="p">[</span><span class="n">start</span> <span class="o">+</span> <span class="mi">1</span><span class="p">:</span><span class="n">start</span> <span class="o">+</span> <span class="n">max_length</span> <span class="o">+</span> <span class="mi">1</span><span class="p">]</span>
</span></span></code></pre></div><p>target 仍然是在同一 token 流上向后错开一位，让模型学习预测下一个 token。</p>
<p>DataLoader 本身不知道 train、val、test 的区别，是我们根据用途设置 shuffle：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">train：通常 shuffle=True，让训练样本顺序随机化
</span></span><span class="line"><span class="cl">val：shuffle=False，保证验证顺序与结果可复现
</span></span><span class="line"><span class="cl">test：shuffle=False，保证最终测试顺序与结果可复现
</span></span></code></pre></div><p>另外，val 用于调参和选择，test 用于最终评估；held-out 是“被隔离、不参与训练”的总称，不能把所有 held-out 都自动当成同一个用途。</p>
<h3 id="4-哪些疑问值得单独回炉而不是继续往后赶">4. 哪些疑问值得单独回炉，而不是继续往后赶？</h3>
<p>目前没有感觉需要单独回炉的内容。今天的疑问已经在 JSONL、SHA-256、标题拼接、uint32、memmap、窗口边界、BPB、parameters 和 Scaling 测算的过程中逐项解决。</p>
<p>如果后面实际训练或调整数据管线时暴露出新的理解缺口，再针对那个具体问题回炉，不为了回炉而回炉。</p>
]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 17：让 model_v3 承接 Qwen2.5</title>
      <link>https://blog.lvxinrong.com/llm/llm-17-model-v3-qwen/</link>
      <pubDate>Thu, 05 Nov 2026 16:34:29 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-17-model-v3-qwen/</guid>
      <description>从 RMSNorm、SwiGLU、GQA、RoPE 与 KV Cache 整合，到 Qwen2.5 Base / Instruct、官方 logits 对齐和 46 项全量回归，完整记录 I0 的落地、排错与收官边界。</description>
      <content:encoded><![CDATA[<blockquote>
<p>今天做的不只是“把 Qwen 跑起来”。更重要的是：每换一个组件，都要知道自己改变了什么；每次模型表现异常，都要先把问题边界缩小，再决定修哪里。</p>
</blockquote>
<h2 id="今天的路线">今天的路线</h2>
<p>第一阶段留下的是 GPT-2 风格的模型。今天新建并完善独立的 <code>model_v3</code>，没有继续在旧模型里反复覆盖实现。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">RMSNorm
</span></span><span class="line"><span class="cl">→ SwiGLU FFN
</span></span><span class="line"><span class="cl">→ GQA + RoPE + KV Cache
</span></span><span class="line"><span class="cl">→ GPTModelV3 整合
</span></span><span class="line"><span class="cl">→ 加载 Qwen2.5 Base
</span></span><span class="line"><span class="cl">→ 接入 Chat Server 做多轮实验
</span></span><span class="line"><span class="cl">→ 加载 Qwen2.5 Instruct
</span></span><span class="line"><span class="cl">→ 使用 Qwen chat template
</span></span><span class="line"><span class="cl">→ 与官方参考实现做控制变量对照
</span></span></code></pre></div><p>一句话概括架构变化：<strong>归一化换 RMSNorm，FFN 换 SwiGLU，注意力换 GQA，位置信息使用 RoPE，生成接入 KV Cache，输入输出做权重绑定。</strong></p>
<h2 id="一rmsnorm不再做均值中心化">一、RMSNorm：不再做均值中心化</h2>
<p>原来的 LayerNorm 会减均值、除以标准差，再经过可学习参数缩放和平移。RMSNorm 不做均值中心化，直接按均方根控制激活值的整体幅度：</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">class</span> <span class="nc">RMSNorm</span><span class="p">(</span><span class="n">nn</span><span class="o">.</span><span class="n">Module</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">def</span> <span class="fm">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">cfg</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">        <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="fm">__init__</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">cfg</span> <span class="o">=</span> <span class="n">cfg</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">emb_dim</span> <span class="o">=</span> <span class="n">cfg</span><span class="p">[</span><span class="s2">&#34;emb_dim&#34;</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">eps</span> <span class="o">=</span> <span class="n">cfg</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">&#34;eps&#34;</span><span class="p">,</span> <span class="mf">1e-6</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">scale</span> <span class="o">=</span> <span class="n">nn</span><span class="o">.</span><span class="n">Parameter</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">ones</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">emb_dim</span><span class="p">))</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;&#34;&#34;
</span></span></span><span class="line"><span class="cl"><span class="s2">    LayerNorm 是“减均值、除标准差”，RMSNorm 是“不减均值，直接除以均方根”。
</span></span></span><span class="line"><span class="cl"><span class="s2">    LayerNorm 先把数据中心化，再控制方差；RMSNorm 不管中心点，只控制向量的整体幅度。
</span></span></span><span class="line"><span class="cl"><span class="s2">    两者都在控制激活值的整体幅度，防止经过多次计算后某些特征向量过大或过小，从而让训练更稳定。
</span></span></span><span class="line"><span class="cl"><span class="s2">    RMSNorm 主要通过等比例缩放控制幅度，LayerNorm 还会先做均值中心化。
</span></span></span><span class="line"><span class="cl"><span class="s2">    &#34;&#34;&#34;</span>
</span></span><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">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><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">y</span>
</span></span></code></pre></div><p>这里有两个需要说准确的点：</p>
<ul>
<li>RMSNorm 省略的是均值中心化，不是“随便把数值压小”；</li>
<li>输出还受 <code>eps</code> 和可学习的 <code>scale</code> 影响，不能简单理解成永远严格保证方差为 1。</li>
</ul>
<p>它仍然是在控制每个 token 的特征向量幅度，避免经过多层计算后激活值过大或过小，只是计算路径比 LayerNorm 更短。</p>
<h2 id="二swiglu真正的阀门在-silu-之后">二、SwiGLU：真正的阀门在 SiLU 之后</h2>
<p>普通 FFN 是一路升维、激活、再降维。SwiGLU 改成两路：</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">class</span> <span class="nc">SwiGLUFFN</span><span class="p">(</span><span class="n">nn</span><span class="o">.</span><span class="n">Module</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">def</span> <span class="fm">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">cfg</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">        <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="fm">__init__</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">        <span class="n">ffn_bias</span> <span class="o">=</span> <span class="n">cfg</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">&#34;ffn_bias&#34;</span><span class="p">,</span> <span class="kc">False</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">emb_dim</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">cfg</span><span class="p">[</span><span class="s2">&#34;emb_dim&#34;</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">hidden_dim</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">cfg</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">&#34;ffn_dim&#34;</span><span class="p">,</span> <span class="mi">3</span> <span class="o">*</span> <span class="n">cfg</span><span class="p">[</span><span class="s2">&#34;emb_dim&#34;</span><span class="p">]))</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">gate_proj</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="bp">self</span><span class="o">.</span><span class="n">emb_dim</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">hidden_dim</span><span class="p">,</span> <span class="n">bias</span><span class="o">=</span><span class="n">ffn_bias</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">up_proj</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="bp">self</span><span class="o">.</span><span class="n">emb_dim</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">hidden_dim</span><span class="p">,</span> <span class="n">bias</span><span class="o">=</span><span class="n">ffn_bias</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">down_proj</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="bp">self</span><span class="o">.</span><span class="n">hidden_dim</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">emb_dim</span><span class="p">,</span> <span class="n">bias</span><span class="o">=</span><span class="n">ffn_bias</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">act</span> <span class="o">=</span> <span class="n">nn</span><span class="o">.</span><span class="n">SiLU</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;&#34;&#34;
</span></span></span><span class="line"><span class="cl"><span class="s2">    y = down_proj( SiLU(gate_proj(x)) * up_proj(x) )    gate_proj门控信号，SiLU 之后才形成实际的连续开度。
</span></span></span><span class="line"><span class="cl"><span class="s2">    up_proj 升维后的x (B, T, emb_dim) -&gt; (B, T, hidden_dim)  hidden_dim 默认是emb_dim的3倍
</span></span></span><span class="line"><span class="cl"><span class="s2">    down_proj 降维回 (B, T, hidden_dim) -&gt; (B, T, emb_dim)
</span></span></span><span class="line"><span class="cl"><span class="s2">    SwiGLUFFN 相比较之前的 FeedForward 核心是多了一个门阀矩阵。
</span></span></span><span class="line"><span class="cl"><span class="s2">    按照我的理解，这个门阀矩阵是类似一个电阻的装置，允许电流通过大小，也就是hidden_dim每个维度允许通过多少
</span></span></span><span class="line"><span class="cl"><span class="s2">
</span></span></span><span class="line"><span class="cl"><span class="s2">    但是核心原理和FeedForward不变，依然是在token经过attention 输出后的每个 token 的隐藏表示 做逐位置变换
</span></span></span><span class="line"><span class="cl"><span class="s2">    再更高维度对自身的隐藏表示进行编辑。    阀门也就是在维度升高之后，增加了一个可以由模型自行通过学习修改阀门流量的开关。可以决定这些信息哪些值得保留，放大或者压下去。
</span></span></span><span class="line"><span class="cl"><span class="s2">    SwiGLU FFN 在升维后，是用 gate_proj 单独生成一路门控信号，经 SiLU 变成每个 hidden 维度的连续开度，再与 up_proj 的内容逐元素相乘。这个开度可学习、可大于 1、可接近 0、也可为负，因此模型能逐维度决定信息保留、放大、压制甚至反向。
</span></span></span><span class="line"><span class="cl"><span class="s2">    &#34;&#34;&#34;</span>
</span></span><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="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">down_proj</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">            <span class="bp">self</span><span class="o">.</span><span class="n">act</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">gate_proj</span><span class="p">(</span><span class="n">x</span><span class="p">))</span> <span class="o">*</span> <span class="bp">self</span><span class="o">.</span><span class="n">up_proj</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="p">)</span>
</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">gate_proj：生成门控信号
</span></span><span class="line"><span class="cl">up_proj：生成要保留和变换的内容
</span></span><span class="line"><span class="cl">SiLU(gate_proj)：形成连续开度
</span></span><span class="line"><span class="cl">逐元素相乘：决定每个 hidden 维度如何通过
</span></span><span class="line"><span class="cl">down_proj：降维回 emb_dim
</span></span></code></pre></div><p>我一开始把它类比成半导体或电阻，这个直觉有帮助，但必须再精确一步：<strong>真正的阀门不是单独的 <code>gate_proj</code>，而是 <code>SiLU(gate_proj(x))</code>。</strong></p>
<p><code>gate_proj</code> 只是线性变换；经过 SiLU 后，门控信号才具有非线性的连续开度。这个开度可以接近 0，也可以大于 1，因此不只是简单的“开”和“关”。</p>
<p>与第一阶段 FFN 相同的是，SwiGLU 依然对每个 token 的隐藏表示做逐位置变换；不同的是，模型现在可以分别控制高维特征中哪些信息保留、放大或压下去。</p>
<h2 id="三gqa减少-kv-头不是减少-q-头">三、GQA：减少 K/V 头，不是减少 Q 头</h2>
<p>Qwen2.5-0.5B 的配置是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Q 头数：14
</span></span><span class="line"><span class="cl">K/V 头数：2
</span></span><span class="line"><span class="cl">head_dim：64
</span></span><span class="line"><span class="cl">每 7 个 Q 头共享一组 K/V
</span></span></code></pre></div><p>因此形状从 MHA 的：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Q：   (B, 14, T, 64)
</span></span><span class="line"><span class="cl">K/V： (B, 14, T, 64)
</span></span></code></pre></div><p>变成 GQA 的：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Q：   (B, 14, T, 64)
</span></span><span class="line"><span class="cl">K/V： (B,  2, T, 64)
</span></span></code></pre></div><p>为了让 Q 和 K/V 继续做矩阵运算，需要把每个 K/V 头在对应分组内复制 7 份：</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">expand_kv</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="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">num_queries_per_kv</span> <span class="o">==</span> <span class="mi">1</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">x</span>
</span></span><span class="line"><span class="cl">    <span class="n">b</span><span class="p">,</span> <span class="n">n_kv_heads</span><span class="p">,</span> <span class="n">num_tokens</span><span class="p">,</span> <span class="n">head_dim</span> <span class="o">=</span> <span class="n">x</span><span class="o">.</span><span class="n">shape</span>
</span></span><span class="line"><span class="cl">    <span class="n">x</span> <span class="o">=</span> <span class="n">x</span><span class="p">[:,</span> <span class="p">:,</span> <span class="kc">None</span><span class="p">,</span> <span class="p">:,</span> <span class="p">:]</span><span class="o">.</span><span class="n">expand</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="n">b</span><span class="p">,</span> <span class="n">n_kv_heads</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">num_queries_per_kv</span><span class="p">,</span> <span class="n">num_tokens</span><span class="p">,</span> <span class="n">head_dim</span>
</span></span><span class="line"><span class="cl">    <span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">x</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">n_kv_heads</span> <span class="o">*</span> <span class="bp">self</span><span class="o">.</span><span class="n">num_queries_per_kv</span><span class="p">,</span> <span class="n">num_tokens</span><span class="p">,</span> <span class="n">head_dim</span><span class="p">)</span>
</span></span></code></pre></div><p>这里的 <code>expand</code> 不是先合并 K/V，而是沿新增的分组维度扩展，再 reshape 回 14 个头。</p>
<p>GQA 的主要收益在推理：cache 中保存的是未扩展的 2 组 K/V，而不是复制后的 14 组。相对 14 个 K/V 头的 MHA，本模型的 K/V cache 存储约降为原来的 <strong>1/7</strong>。注意力计算时仍然要服务 14 个 Q 头，不能把它理解成训练计算量也同比例下降。</p>
<h2 id="四rope-与-kv-cache位置必须从历史长度开始">四、RoPE 与 KV Cache：位置必须从历史长度开始</h2>
<p>RoPE 在 v2 已经独立实现，今天做的是把它接入 GQA，并与 cache 的位置偏移对齐。</p>
<p>没有 cache 时，token 位置从 0 开始；已有 <code>past_len</code> 个历史 token 时，新 token 的位置必须继续往后排：</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">position_ids</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">past_len</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">num_tokens</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">device</span><span class="o">=</span><span class="n">x</span><span class="o">.</span><span class="n">device</span><span class="p">,</span>
</span></span><span class="line"><span class="cl"><span class="p">)</span>
</span></span></code></pre></div><p>如果每次生成都从 0 重新计算 RoPE，新 token 就会拿到错误的位置信息。</p>
<p>cache 中保存未扩展的 K/V：</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">present_kv</span> <span class="o">=</span> <span class="p">(</span><span class="n">keys</span><span class="p">,</span> <span class="n">values</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="n">keys</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">expand_kv</span><span class="p">(</span><span class="n">keys</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="n">values</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">expand_kv</span><span class="p">(</span><span class="n">values</span><span class="p">)</span>
</span></span></code></pre></div><p>这样既减少存储，又能完成当前注意力计算。</p>
<h3 id="causal-mask-的一个关键切片">causal mask 的一个关键切片</h3>
<p>使用 cache 后，query 长度和 key 长度不再总是相同，不能继续机械地切一个正方形 mask：</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="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>q_len == 1</code> 时，当前 token 可以看到全部历史和自身，没有当前窗口里的未来 token，因此不需要 mask。</p>
<p>这不是单纯为了消除一个 shape 报错，而是在明确三种长度之间的关系：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">k_len = past_len + q_len
</span></span></code></pre></div><h2 id="五gptmodelv3把零件装成整车">五、GPTModelV3：把零件装成整车</h2>
<p>当前 v3 的主链路是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Token Embedding
</span></span><span class="line"><span class="cl">    ↓
</span></span><span class="line"><span class="cl">24 × Transformer Block
</span></span><span class="line"><span class="cl">    ├─ RMSNorm → GQA + RoPE + KV Cache → 残差
</span></span><span class="line"><span class="cl">    └─ RMSNorm → SwiGLU FFN → 残差
</span></span><span class="line"><span class="cl">    ↓
</span></span><span class="line"><span class="cl">Final RMSNorm
</span></span><span class="line"><span class="cl">    ↓
</span></span><span class="line"><span class="cl">与 Token Embedding 共享权重的输出头
</span></span></code></pre></div><p>核心配置与 Qwen2.5-0.5B 对齐：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">vocab_size = 151936
</span></span><span class="line"><span class="cl">emb_dim = 896
</span></span><span class="line"><span class="cl">ffn_dim = 4864
</span></span><span class="line"><span class="cl">n_heads = 14
</span></span><span class="line"><span class="cl">n_kv_heads = 2
</span></span><span class="line"><span class="cl">n_layers = 24
</span></span><span class="line"><span class="cl">rope_theta = 1000000.0
</span></span><span class="line"><span class="cl">eps = 1e-6
</span></span><span class="line"><span class="cl">qkv_bias = True
</span></span><span class="line"><span class="cl">ffn_bias = False
</span></span><span class="line"><span class="cl">tie_word_embeddings = True
</span></span></code></pre></div><p>工程里的 <code>context_length=1024</code> 是当前小规模验证配置，不代表 Qwen 本身的最大上下文能力。</p>
<h3 id="weight-tying-不是修改-shape">Weight Tying 不是修改 shape</h3>
<p>输入 Embedding 和输出头分别声明为 <code>nn.Embedding</code> 与 <code>nn.Linear</code>，但共享同一个 Parameter：</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">out_head</span><span class="o">.</span><span class="n">weight</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">tok_emb</span><span class="o">.</span><span class="n">weight</span>
</span></span></code></pre></div><p>两个模块仍然存在，底层权重张量却是同一份。这样既减少参数，也让 token 的输入表示和输出表示使用同一套语义空间。</p>
<h2 id="六加载-qwen25-base权重与-tokenizer-是两件事">六、加载 Qwen2.5 Base：权重与 tokenizer 是两件事</h2>
<p><code>.safetensors</code> 文件只有模型参数，不包含完整 tokenizer。当前工程分别处理：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">权重：data/model_pth/qwen/qwen2_5-0_5b.safetensors
</span></span><span class="line"><span class="cl">分词：AutoTokenizer.from_pretrained(&#34;Qwen/Qwen2.5-0.5B&#34;)
</span></span></code></pre></div><p>权重加载器负责把 Qwen 的命名映射到 v3，例如：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">model.layers.0.self_attn.q_proj.weight
</span></span><span class="line"><span class="cl">→ trf_block.0.att.W_query.weight
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">model.layers.0.input_layernorm.weight
</span></span><span class="line"><span class="cl">→ trf_block.0.norm1.scale
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">model.layers.0.mlp.gate_proj.weight
</span></span><span class="line"><span class="cl">→ trf_block.0.ffn.gate_proj.weight
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">model.norm.weight
</span></span><span class="line"><span class="cl">→ final_norm.scale
</span></span></code></pre></div><p>加载后使用严格的 <code>load_state_dict()</code> 验证键和形状，不是“文件能读出来”就算成功。</p>
<h3 id="squidtokenizer-是-protocol不是门面类">SquidTokenizer 是 Protocol，不是门面类</h3>
<p><code>QwenTokenizerAdapter</code> 对外提供统一的：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">encode()
</span></span><span class="line"><span class="cl">decode()
</span></span><span class="line"><span class="cl">eos_id
</span></span></code></pre></div><p>底层仍然是 Hugging Face tokenizer。<code>SquidTokenizer</code> 则是 <code>Protocol</code>，更接近 Java 的接口，只声明最小契约。</p>
<p>Python Protocol 支持结构化类型，所以 Qwen adapter 最初没有显式继承也能运行。但项目里的 <code>TiktokenTokenizer</code> 和 <code>MyBPETokenizer</code> 都显式继承了，为了清楚表达契约并方便 IDE 检查，最终统一为：</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">class</span> <span class="nc">QwenTokenizerAdapter</span><span class="p">(</span><span class="n">SquidTokenizer</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="o">...</span>
</span></span></code></pre></div><p>这件事提醒我：<strong>能运行，不代表接口设计已经表达完整。</strong></p>
<h3 id="pycharm-的-from_pretrained-告警">PyCharm 的 from_pretrained 告警</h3>
<p>PyCharm 一度提示：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Function &#39;from_pretrained&#39; doesn&#39;t return anything
</span></span></code></pre></div><p>实际运行返回的是 <code>Qwen2Tokenizer</code>，并不是 <code>None</code>。当前 Transformers 版本的返回类型包含 <code>SentencePieceBackend</code>，而未安装对应可选依赖时它被设为 <code>None</code>，使 IDE 看到了容易误导的类型。</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">tokenizer</span> <span class="o">=</span> <span class="n">AutoTokenizer</span><span class="o">.</span><span class="n">from_pretrained</span><span class="p">(</span><span class="n">model_name</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="k">if</span> <span class="n">tokenizer</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">    <span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="sa">f</span><span class="s2">&#34;Tokenizer 加载失败：</span><span class="si">{</span><span class="n">model_name</span><span class="si">}</span><span class="s2">&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="bp">self</span><span class="o">.</span><span class="n">tokenizer</span> <span class="o">=</span> <span class="n">tokenizer</span>
</span></span></code></pre></div><p>IDE 告警值得检查，但不能只看告警文字就改业务逻辑。</p>
<h3 id="base-的实际验收">Base 的实际验收</h3>
<p>目前已经真实验证：</p>
<ul>
<li>权重前向成功，logits 形状为 <code>(1, 7, 151936)</code>；</li>
<li>cache 与完整前向一致，最大差异约 <code>8.58e-06</code>；</li>
<li>英文 prompt <code>The capital of France is</code> 能生成 Paris；</li>
<li>中文 prompt <code>法国的首都是</code> 能生成合理的巴黎相关续写；</li>
<li>选定测试集共 <code>18 passed</code>。</li>
</ul>
<p>这里的 18 项只是选定回归，不写成“全量测试全部通过”。</p>
<h2 id="七base-接入-server多轮输入不等于多轮助手能力">七、Base 接入 Server：多轮输入不等于多轮助手能力</h2>
<p>Base 接入昨天的 Chat Server 后，页面已经能完成三轮中文交互。但第二轮出现了模型自己编造的：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">### Instruction:
</span></span><span class="line"><span class="cl">...
</span></span><span class="line"><span class="cl">### Response:
</span></span><span class="line"><span class="cl">...
</span></span></code></pre></div><p>原因是 Base 把 Alpaca 风格模板当成文章结构继续续写，而生成器只按 EOS 停止。第一处修复是在写入 history 前截断：</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">response</span> <span class="o">=</span> <span class="n">responses</span><span class="p">[</span><span class="nb">len</span><span class="p">(</span><span class="n">prompt</span><span class="p">):]</span>
</span></span><span class="line"><span class="cl"><span class="k">for</span> <span class="n">marker</span> <span class="ow">in</span> <span class="p">(</span><span class="s2">&#34;&lt;|endoftext|&gt;&#34;</span><span class="p">,</span> <span class="s2">&#34;&lt;|im_end|&gt;&#34;</span><span class="p">,</span> <span class="s2">&#34;### Instruction:&#34;</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">response</span> <span class="o">=</span> <span class="n">response</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="n">marker</span><span class="p">,</span> <span class="mi">1</span><span class="p">)[</span><span class="mi">0</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="n">response</span> <span class="o">=</span> <span class="n">response</span><span class="o">.</span><span class="n">strip</span><span class="p">()</span>
</span></span></code></pre></div><p>这样编造的轮次不会显示，也不会污染 history。它只是生成后的截断，并不代表生成器已经支持 stop string 提前停止。</p>
<p>Base 还出现了角色错位：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">用户：你还记得我叫什么、喜欢做什么吗？
</span></span><span class="line"><span class="cl">模型：我叫吕炘嵘，喜欢写代码，正在学习大模型。
</span></span></code></pre></div><p>正确的人称应该是“你叫吕炘嵘”。但它能说出姓名和爱好，说明历史确实进入了 prompt。</p>
<p>所以 Base 实验的结论是：</p>
<blockquote>
<p>多轮上下文链路通过，助手式角色对齐不作通过要求。这里的“记得”来自 ChatSession.history，不是模型权重形成了记忆。</p>
</blockquote>
<h2 id="八instruct结构没有变权重和对话格式变了">八、Instruct：结构没有变，权重和对话格式变了</h2>
<p>下载 <code>Qwen/Qwen2.5-0.5B-Instruct</code> 后，先核对结构，再复用原有加载器。验证结果为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">hidden_size = 896
</span></span><span class="line"><span class="cl">intermediate_size = 4864
</span></span><span class="line"><span class="cl">num_hidden_layers = 24
</span></span><span class="line"><span class="cl">num_attention_heads = 14
</span></span><span class="line"><span class="cl">num_key_value_heads = 2
</span></span><span class="line"><span class="cl">rope_theta = 1000000.0
</span></span><span class="line"><span class="cl">rms_norm_eps = 1e-6
</span></span><span class="line"><span class="cl">vocab_size = 151936
</span></span><span class="line"><span class="cl">tie_word_embeddings = True
</span></span></code></pre></div><p>全部一致，Instruct 权重在 MPS 上加载成功。这说明同代同尺寸的 Base 和 Instruct 可以复用当前 v3 结构与权重映射。</p>
<h3 id="transformers-的配置位置变化">Transformers 的配置位置变化</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="n">config</span><span class="o">.</span><span class="n">rope_theta</span>
</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">AttributeError: &#39;Qwen2Config&#39; object has no attribute &#39;rope_theta&#39;
</span></span></code></pre></div><p>这不是权重加载失败，因为程序还没执行到加载器。当前 Transformers 将 RoPE 配置放在：</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">config</span><span class="o">.</span><span class="n">rope_parameters</span>
</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="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;rope_theta&#34;</span><span class="p">:</span> <span class="mf">1000000.0</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;rope_type&#34;</span><span class="p">:</span> <span class="s2">&#34;default&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>只调整验收脚本的读取位置，自己的 <code>MODEL_V3_DEFAULT_CONFIG</code> 不需要跟着改名。</p>
<h3 id="eos-与-pad-不再相同">EOS 与 PAD 不再相同</h3>
<p>Base 使用：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">EOS = &lt;|endoftext|&gt; = 151643
</span></span><span class="line"><span class="cl">PAD = &lt;|endoftext|&gt; = 151643
</span></span></code></pre></div><p>Instruct 使用：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">EOS = &lt;|im_end|&gt;    = 151645
</span></span><span class="line"><span class="cl">PAD = &lt;|endoftext|&gt; = 151643
</span></span></code></pre></div><p>因此不能只替换权重而继续沿用 Base 的结束符。</p>
<h2 id="九qwen-chat-template显式描述角色和轮次">九、Qwen chat template：显式描述角色和轮次</h2>
<p>Instruct 不再使用 <code>### Instruction / ### Response</code>，而是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">&lt;|im_start|&gt;system
</span></span><span class="line"><span class="cl">你是一个乐于助人的 AI 助手。&lt;|im_end|&gt;
</span></span><span class="line"><span class="cl">&lt;|im_start|&gt;user
</span></span><span class="line"><span class="cl">你好，我叫吕炘嵘。&lt;|im_end|&gt;
</span></span><span class="line"><span class="cl">&lt;|im_start|&gt;assistant
</span></span></code></pre></div><p><code>add_generation_prompt=True</code> 会在末尾补上 assistant 起始标记，模型只需要接着生成回答。</p>
<p>单轮实测输出：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">你好！很高兴见到你。有什么我可以帮助你的吗？
</span></span></code></pre></div><p>回答角色正确，遇到 <code>&lt;|im_end|&gt;</code> 正常停止，也没有编造额外轮次。</p>
<h3 id="让-chatsession-支持替换模板">让 ChatSession 支持替换模板</h3>
<p>没有复制一套 Qwen 专用 Session，而是给现有 <code>ChatSession</code> 注入 <code>prompt_builder</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="bp">self</span><span class="o">.</span><span class="n">prompt_builder</span> <span class="o">=</span> <span class="n">prompt_builder</span> <span class="ow">or</span> <span class="n">build_chat_prompt</span>
</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">prompt</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">prompt_builder</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">history</span><span class="p">,</span> <span class="n">user_input</span><span class="p">)</span>
</span></span></code></pre></div><p>不传时使用旧模板；传入 Qwen 构造器时使用新模板。这相当于一个简化的 Strategy 模式，历史保存、生成、清空逻辑仍然只有一份。</p>
<p>Qwen 的 history 则转换为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="p">[</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span><span class="s2">&#34;role&#34;</span><span class="p">:</span> <span class="s2">&#34;system&#34;</span><span class="p">,</span> <span class="s2">&#34;content&#34;</span><span class="p">:</span> <span class="s2">&#34;...&#34;</span><span class="p">},</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span><span class="s2">&#34;role&#34;</span><span class="p">:</span> <span class="s2">&#34;user&#34;</span><span class="p">,</span> <span class="s2">&#34;content&#34;</span><span class="p">:</span> <span class="s2">&#34;用户1&#34;</span><span class="p">},</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span><span class="s2">&#34;role&#34;</span><span class="p">:</span> <span class="s2">&#34;assistant&#34;</span><span class="p">,</span> <span class="s2">&#34;content&#34;</span><span class="p">:</span> <span class="s2">&#34;助手1&#34;</span><span class="p">},</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span><span class="s2">&#34;role&#34;</span><span class="p">:</span> <span class="s2">&#34;user&#34;</span><span class="p">,</span> <span class="s2">&#34;content&#34;</span><span class="p">:</span> <span class="s2">&#34;当前问题&#34;</span><span class="p">},</span>
</span></span><span class="line"><span class="cl"><span class="p">]</span>
</span></span></code></pre></div><p>Server 用 <code>partial</code> 提前绑定 Hugging Face tokenizer，剩下的 <code>history</code> 和 <code>current_input</code> 仍由 Session 提供。</p>
<h2 id="十一个多轮对话异常">十、一个多轮对话异常</h2>
<p>model_v3 接入 Qwen2.5-0.5B-Instruct 后，单轮回答和 <code>&lt;|im_end|&gt;</code> 停止都正常，但三轮对话出现了问题：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">用户：你好，我叫吕炘嵘。
</span></span><span class="line"><span class="cl">用户：我喜欢写代码，也正在学习大模型。
</span></span><span class="line"><span class="cl">用户：你还记得我叫什么、喜欢做什么吗？
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">模型：我叫小助手，主要功能是提供信息和帮助用户解决问题……
</span></span></code></pre></div><p>这个回答没有利用前两轮的信息，但仅凭页面现象，无法判断问题出在哪里：</p>
<ul>
<li>Server 没有把 history 传进去；</li>
<li>Qwen chat template 组装错误；</li>
<li>model_v3 与官方模型实现存在差异；</li>
<li>0.5B Instruct 本身没有可靠完成这次上下文回忆。</li>
</ul>
<p>我先绕过 Server，手工构造包含两轮真实历史的 prompt，并用断言确认姓名和爱好都在输入中。模型仍然给出了同样的错误回答。</p>
<p>这一步只排除了 Server 和 history 丢失，<strong>还不能直接证明是模型能力不足</strong>。</p>
<h2 id="十一引入官方参考实现">十一、引入官方参考实现</h2>
<p>下一步使用 Hugging Face 的 <code>AutoModelForCausalLM</code>，加载同一份 Qwen2.5 Instruct 权重，输入完全相同的 prompt，再比较生成结果：</p>
<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">          ┌───────────┴───────────┐
</span></span><span class="line"><span class="cl">          ▼                       ▼
</span></span><span class="line"><span class="cl">     model_v3              官方 Qwen 实现
</span></span></code></pre></div><p>这里最重要的是控制变量：</p>
<ol>
<li><strong>权重相同</strong>：都用 Qwen2.5-0.5B-Instruct，不能一边 Base、一边 Instruct；</li>
<li><strong>输入相同</strong>：使用同一个 <code>build_qwen_chat_prompt()</code> 生成的字符串，包括 system、历史轮次和 assistant 起始标记；</li>
<li><strong>解码相同</strong>：都使用 greedy decoding，并统一 <code>max_new_tokens</code>、EOS 和 PAD；</li>
<li><strong>只改变模型实现</strong>：自实现 model_v3 对官方 <code>AutoModelForCausalLM</code>。</li>
</ol>
<p>结果有两种解释方向：</p>
<ul>
<li><strong>官方实现正确，model_v3 错误</strong>：优先怀疑自实现的兼容性。下一步比较最后一个 token 的 logits，再逐层定位，而不是继续调整 prompt；</li>
<li><strong>官方实现也没有通过任务</strong>：Server 和 model_v3 都有了重要的排除证据，接下来才研究提问方式或模型能力边界。</li>
</ul>
<h3 id="参考实现不是标准答案">参考实现不是标准答案</h3>
<p>官方实现也可能给出错误回答。它的价值不是替我们判定“什么回答最好”，而是提供一个<strong>相同条件下的对照组</strong>。</p>
<p>如果两边一个采样、一个 greedy，或者悄悄换了 prompt，即使输出不同也不能说明实现有误。对照实验一旦引入第二个变量，结论就不可靠。</p>
<p>这套顺序以后可以复用到其他自实现模型：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">先检查调用链
</span></span><span class="line"><span class="cl">→ 固定并检查实际输入
</span></span><span class="line"><span class="cl">→ 绕过外围服务复现
</span></span><span class="line"><span class="cl">→ 对齐官方参考实现
</span></span><span class="line"><span class="cl">→ 输出不同再比较 logits 和中间层
</span></span></code></pre></div><p>不要一上来就逐层打印张量，也不要一看到回答错误就归因为模型太小。<strong>先把问题边界缩小，再决定修哪里。</strong></p>
<h2 id="十二本次官方对照的真实结果">十二、本次官方对照的真实结果</h2>
<p>官方实现生成的是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">我是由阿里云开发的超大规模语言模型，我叫通义千问。
</span></span><span class="line"><span class="cl">我擅长回答各种问题，并且可以进行文字生成、翻译等任务……
</span></span></code></pre></div><p>它同样没有回答用户的姓名和爱好。因此，这次“第三轮没有回忆起上下文”的问题，不能再简单归因于 Server 或 model_v3。至少官方参考实现在相同输入下也没有通过这项任务。</p>
<p>但两边生成的文字并不相同：model_v3 自称“小助手”，官方实现自称“通义千问”。所以本次实验支持的是<strong>任务层面的排除结论</strong>，不是“两个实现已经逐 token 等价”。</p>
<p>这里要拆开两个验收口径：</p>
<ul>
<li><strong>任务是否通过</strong>：两边都没有回忆起用户姓名和爱好，下一步应研究提问方式与模型能力；</li>
<li><strong>实现是否完全一致</strong>：两边输出不同，尚未证明。差异可能来自浮点计算、注意力实现或自实现细节，需要比较 logits 才能继续判断，不能仅凭一段生成文本下结论。</li>
</ul>
<p>这次对照最大的价值，是避免在 Server 和 model_v3 里盲目寻找一个可能并不存在的“历史丢失 bug”，同时也没有把“输出不同”草率解释为实现已经出错。</p>
<p>下一步只改变提问方式，保持 history、system prompt 和 greedy decoding 不变：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">请根据上面的对话回答：用户叫什么名字？
</span></span><span class="line"><span class="cl">用户喜欢做什么？正在学习什么？不要介绍你自己。
</span></span></code></pre></div><p>复测后，model_v3 在测试脚本和网页链路中都能正确回答：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">用户叫吕炘嵘，用户喜欢写代码，正在学习大模型。
</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">用户叫吕炘嵘，他喜欢写代码，并正在学习大模型。
</span></span></code></pre></div><p>测试脚本同时报告 <code>1 passed</code>。这次结果说明：在 history、权重和解码方式不变的情况下，只把“用户”这个角色和要回答的任务明确写出来，自实现与官方实现就都能完成这次上下文回忆。</p>
<p>因此，原来的错误更符合“模糊提问触发了小模型的自我介绍”，而不是 Server 丢失 history，也不能据此宣称当前模型完全不具备多轮回忆能力。反向结论同样不能扩大：一次明确提问通过，不代表所有自由提问形式都已稳定，更不代表两个实现已经逐 token 等价。</p>
<h3 id="i0-数值对齐补充2026-11-06">I0 数值对齐补充（2026-11-06）</h3>
<p>昨天只比较了生成文本，今天继续把实验往前推进一步：<strong>不调用 <code>generate()</code>，直接比较相同 input_ids 经过两套模型实现后得到的原始 logits。</strong></p>
<p>测试固定使用 CPU、float32、本地缓存权重和相同 tokenizer，避免网络、设备和数据类型引入额外变量。基础回归断言为：</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">torch</span><span class="o">.</span><span class="n">testing</span><span class="o">.</span><span class="n">assert_close</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">our_logits</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">official_logits</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">rtol</span><span class="o">=</span><span class="mf">0.0</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">atol</span><span class="o">=</span><span class="mf">1e-4</span><span class="p">,</span>
</span></span><span class="line"><span class="cl"><span class="p">)</span>
</span></span></code></pre></div><p>这里 <code>rtol=0</code> 表示不额外放大数据量带来的相对容差，只要求所有元素的绝对误差不超过 <code>1e-4</code>。</p>
<h4 id="三组输入的完整前向对照">三组输入的完整前向对照</h4>
<p>在官方默认 attention 路径下，三组输入的 top-1 next token 都一致，绝对误差也都在 <code>1e-4</code> 内：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>输入类型</th>
        <th style="text-align: right">token 数</th>
        <th style="text-align: right">最大绝对误差</th>
        <th style="text-align: right">平均绝对误差</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>中文自我介绍</td>
        <td style="text-align: right">8</td>
        <td style="text-align: right"><code>4.3869e-05</code></td>
        <td style="text-align: right"><code>4.8585e-06</code></td>
      </tr>
      <tr>
        <td>英文常识开头</td>
        <td style="text-align: right">5</td>
        <td style="text-align: right"><code>5.8174e-05</code></td>
        <td style="text-align: right"><code>6.8113e-06</code></td>
      </tr>
      <tr>
        <td>Python 代码片段</td>
        <td style="text-align: right">11</td>
        <td style="text-align: right"><code>7.5340e-05</code></td>
        <td style="text-align: right"><code>6.5186e-06</code></td>
      </tr>
    </tbody>
  </table>
</div>
<p>最大值与平均值相差约一个数量级并不矛盾。平均值来自整段输入的全部 logits，最大值只取其中误差最大的一个元素。它说明大多数元素非常接近，少数元素误差稍大；是否严重仍要看最大误差的绝对量级，而不是只看两者的倍数。</p>
<h4 id="124-token-多轮-prompt-暴露了-sdpa-数值差异">124-token 多轮 prompt 暴露了 SDPA 数值差异</h4>
<p>完整 chat template 包含两轮历史，共 124 个 token。使用官方默认 attention 路径时，测试没有通过 <code>atol=1e-4</code>：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">logits 总数：18,840,064
</span></span><span class="line"><span class="cl">超出阈值的元素：45,350（约 0.2%）
</span></span><span class="line"><span class="cl">最大绝对误差：0.0003409385681152344
</span></span></code></pre></div><p>这次失败不能立刻解释成模型结构错误，也不应该通过随手放宽阈值来消除。下一步只改变一个变量：将官方模型显式指定为 eager attention。</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">official_model</span> <span class="o">=</span> <span class="n">AutoModelForCausalLM</span><span class="o">.</span><span class="n">from_pretrained</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">MODEL_NAME</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">dtype</span><span class="o">=</span><span class="n">torch</span><span class="o">.</span><span class="n">float32</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">local_files_only</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">attn_implementation</span><span class="o">=</span><span class="s2">&#34;eager&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl"><span class="p">)</span>
</span></span></code></pre></div><p>改为 eager 后，同一组输入得到：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">max abs difference = 0.0
</span></span><span class="line"><span class="cl">mean abs difference = 0.0
</span></span><span class="line"><span class="cl">两边 next token = 20002（用户）
</span></span></code></pre></div><p>这说明此前的微小差异来自官方默认 SDPA 与手写 attention 的数值路径，而不是 tokenizer、权重映射或 model_v3 的结构错误。</p>
<h4 id="sdpa-与-eager-的区别">SDPA 与 eager 的区别</h4>
<p>SDPA 是 <strong>Scaled Dot-Product Attention（缩放点积注意力）</strong>，是 PyTorch 提供的统一、优化过的注意力计算接口。它与手写 attention 使用相同的数学过程：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Q × Kᵀ → 缩放 → causal mask → softmax → × V
</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">eager：逐个执行 matmul、缩放、mask、softmax、matmul
</span></span><span class="line"><span class="cl">SDPA：交给 PyTorch 统一算子，由设备和后端选择优化实现
</span></span></code></pre></div><p>数学公式相同，不代表浮点计算顺序、融合方式和舍入结果一定相同。输入越长，微小差异也可能越明显。SDPA 也不等于 FlashAttention；后者只是某些环境下可能被选择的后端技术之一。</p>
<p>因此，严格数值对齐时固定 <code>attn_implementation=&quot;eager&quot;</code> 不是为了强行让测试变绿，而是为了让官方参考实现与自实现走同一条明确的计算路径。</p>
<h4 id="为什么采样随机性不影响这次零误差">为什么采样随机性不影响这次“零误差”</h4>
<p>当前 logits 测试没有调用 <code>generate()</code>、<code>generate_text()</code>、<code>sample_next()</code> 或 <code>torch.multinomial()</code>，只做：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">固定 input_ids → 模型前向计算 → 比较原始 logits
</span></span></code></pre></div><p>temperature、top-k 和随机采样都发生在 logits 已经算出之后，不会反过来改变这次前向结果。两边又都处于 <code>eval()</code>，Dropout 不生效，因此在输入、权重、CPU、float32 和 eager 计算路径全部一致时，得到 <code>0.0</code> 是合理的。</p>
<p>即使使用 greedy decoding，也只是去掉了随机采样，不能自动消除 SDPA 的数值差异。一旦某一步 argmax 因微小误差选择了不同 token，后续自回归生成还可能继续分叉。</p>
<p>所以这项“零误差”的准确边界是：<strong>固定 124-token 多轮 prompt 下，model_v3 与官方 eager 实现的完整前向 logits 完全一致</strong>。它还不能自动覆盖 KV Cache 增量解码，因此随后单独增加了 cache 对照。</p>
<h4 id="kv-cache-增量解码对照">KV Cache 增量解码对照</h4>
<p>cache 测试先比较 prefill 后第 0 层和第 23 层的 K/V，再连续进行三次单 token decode。两边使用相同权重、CPU、float32 和 eager attention，每一步都从官方 logits 取确定性的 argmax，并把同一个 next token 喂给两个实现。</p>
<p>结果为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">prefill：max abs difference = 0.0
</span></span><span class="line"><span class="cl">cache decode step 1：max abs difference = 0.0，cache length = 8
</span></span><span class="line"><span class="cl">cache decode step 2：max abs difference = 0.0，cache length = 9
</span></span><span class="line"><span class="cl">cache decode step 3：max abs difference = 0.0，cache length = 10
</span></span><span class="line"><span class="cl">每一步两边 next token 均一致
</span></span></code></pre></div><p>这里必须区分直接证据与组合证据：</p>
<ul>
<li>prefill 的 K/V 相同，只直接证明 <code>past_len=0</code> 时的 Value 投影、Key 投影与 Key 的 RoPE 一致，不能单独证明非零 <code>past_len</code>；</li>
<li>cache length 按 8 → 9 → 10 增长，直接证明每轮长度增加 1，不等于每一步的全部拼接内容都被单独比较；</li>
<li>三个不同历史长度下，最终全量 logits 都与官方一致，为 <code>past_len → position_ids → Q/K RoPE → attention → logits</code> 提供强组合证据，但不是对每个内部变量的独立观测；</li>
<li><code>q_len=1</code> 时只有历史和当前 token，没有未来 token，因此 <code>mask_bool=None</code> 在因果定义上成立；三次 decode 与官方一致提供了行为证据，但不是直接比较 attention weights。</li>
</ul>
<p>当前 cache 对照仍不覆盖 <code>q_len&gt;1 且 past_len&gt;0</code> 的分块追加，也不覆盖 temperature、top-k 随机采样或所有可能输入。<strong>组合行为一致与每个组件被独立证明，是两件事。</strong></p>
<h4 id="固定行为回归与全量收官">固定行为回归与全量收官</h4>
<p>随后补了两组真实 model_v3 行为回归：</p>
<ul>
<li>三轮对话后，模型能正确回答“用户叫吕炘嵘，用户喜欢写代码，正在学习大模型”，且不再出现角色错位和模板标记泄漏；</li>
<li>Python 偶数筛选代码的解释完整，包含 <code>find_even_numbers</code>、执行过程与最终输出 <code>偶数列表： [2, 4, 6]</code>；<code>max_new_tokens=512</code> 覆盖了此前的长回答截断场景。</li>
</ul>
<p>最终回归分组结果：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Qwen 专项：7 passed
</span></span><span class="line"><span class="cl">基础与旧模型快速回归：24 passed
</span></span><span class="line"><span class="cl">本地模型评估：7 passed
</span></span><span class="line"><span class="cl">本地慢训练：4 passed
</span></span><span class="line"><span class="cl">DeepSeek 外部评估：4 passed
</span></span><span class="line"><span class="cl">合计：46 passed，0 failed
</span></span></code></pre></div><p>分类微调测试曾出现一次 <code>train_losses[-1] &lt; train_losses[0]</code> 失败。代码审查发现测试没有固定随机种子，并且训练/验证共用带 shuffle 的 loader，每次只抽两个 batch 计算 loss，导致评估值不完全可比。</p>
<p>修复只针对测试的可复现性：增加 <code>torch.manual_seed(123)</code>，并将 <code>eval_iter</code> 改为 <code>None</code> 以覆盖全部玩具样本。训练逻辑与 loss 下降断言均保留，修改后测试通过。没有通过删除断言或随意增加训练轮数来消除红灯。</p>
<p>因此，I0 的“全量回归通过”指当前测试套件中的 46 个固定用例全部通过，不代表任意输入、任意设备和任意生成长度都已经得到数学意义上的完全证明。</p>
<h2 id="十三训练准备只盘点语料尚未开始-midtrain">十三、训练准备：只盘点语料，尚未开始 midtrain</h2>
<p>今天还盘点了后续中文 midtrain 可能使用的语料：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">data/blog/train.txt：约 69,315 个 Qwen tokens
</span></span><span class="line"><span class="cl">私人 AI 实验室 held-out：约 1,564 tokens
</span></span><span class="line"><span class="cl">指令微调 held-out：约 3,894 tokens
</span></span></code></pre></div><p>第一轮只考虑 <code>batch_size=1</code>、<code>max_length=128</code> 的小规模冒烟，目标是验证反向传播、checkpoint 保存恢复和生成链路，不是几十步就学会个人文风。年终总结等个人文本计划后续补充，但还没有合并进训练集。</p>
<p>同时纠正了一个数据切片注释：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">stride 是相邻窗口的起始位置间隔
</span></span><span class="line"><span class="cl">重叠长度 = max_length - stride
</span></span><span class="line"><span class="cl">stride = max_length 时，窗口不重叠
</span></span></code></pre></div><p>midtrain 仍然是 next-token prediction，不需要指令模板，也不需要 SFT 的 <code>-100</code> mask。<strong>今天没有开始实际训练，也没有产生 midtrain loss 或新 checkpoint。</strong></p>
<h2 id="十四工程整理">十四、工程整理</h2>
<p>模型权重目录整理为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">data/model_pth/
</span></span><span class="line"><span class="cl">├── gpt2/
</span></span><span class="line"><span class="cl">├── qwen/
</span></span><span class="line"><span class="cl">└── experiments/
</span></span></code></pre></div><p>Qwen Base 与 Instruct 分成两个文件保存，原始 Base 没有被覆盖。正式代码入口里的旧权重路径也同步更新。</p>
<p>今天新增的主要能力包括：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">src/squid/checkpoints/qwen.py
</span></span><span class="line"><span class="cl">src/squid/tokenizer/qwen_tokenizer.py
</span></span><span class="line"><span class="cl">src/squid/model/v3_modern/
</span></span></code></pre></div><p>新增依赖主要用于读取 safetensors、访问 Hugging Face 仓库和加载 tokenizer。</p>
<h2 id="十五今天的验收边界">十五、今天的验收边界</h2>
<p>已经真实完成：</p>
<ul>
<li>RMSNorm、SwiGLU、GQA、RoPE 与 KV Cache 的 v3 整合；</li>
<li>Qwen2.5 Base 权重加载、前向、cache 一致性和中英文生成；</li>
<li>Base 与 Instruct 的 tokenizer、EOS、PAD 区分；</li>
<li>Instruct 结构核对、权重加载和单轮生成；</li>
<li>Qwen chat template 与多轮 history 组装；</li>
<li>Chat Server 的真实浏览器多轮调用，以及明确提问下的上下文回忆；</li>
<li>中文、英文、代码输入的官方 logits 容差对照，以及 124-token 多轮 prompt 在官方 eager 路径下的全量 logits 零误差对齐；</li>
<li>prefill 与连续三次单 token cache decode 的官方 eager 零误差对照；</li>
<li>固定多轮回忆、代码解释回归和当前测试套件全量 <code>46 passed</code>；</li>
<li>自实现与官方参考实现的同输入生成对照。</li>
</ul>
<p>不能写成已经完成：</p>
<ul>
<li>任意输入与 KV Cache 增量生成全程的逐 token / logits 完全一致；</li>
<li>当前 0.5B Instruct 在任意自然提问下都能稳定完成多轮回忆；</li>
<li>训练吞吐、KV 实际占用与 BPB 对照（已分别移交 I1 / I2 / I3）；</li>
<li>中文 midtrain 已经开始或取得效果；</li>
<li>Qwen3、MoE 或其他尺寸模型的兼容。</li>
</ul>
<h3 id="收官复盘知道怎么做更要知道做得对不对">收官复盘：知道怎么做，更要知道做得对不对</h3>
<p><strong>写出 LLM 很重要，知道怎么测试和评估同样重要。前者让我知道怎么做，后者让我知道做得对不对、为什么对，以及结论的边界在哪里。</strong></p>
<p>模型能运行，不代表实现正确；输出像话，不代表能力可靠；一次测试通过，也不代表任意场景都稳定。今天的测试不是为了得到好看的 <code>46 passed</code>，而是建立一条从数学计算到真实行为的证据链。</p>
<h4 id="1-先比较确定性-logits再进入生成">1. 先比较确定性 logits，再进入生成</h4>
<p>固定 tokenizer、input_ids、权重、CPU、float32 和 <code>eval()</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">our_logits</span> <span class="o">=</span> <span class="n">our_model</span><span class="p">(</span><span class="n">input_ids</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="n">official_logits</span> <span class="o">=</span> <span class="n">official_model</span><span class="p">(</span><span class="n">input_ids</span><span class="p">)</span><span class="o">.</span><span class="n">logits</span>
</span></span></code></pre></div><p>这一步隔离了 temperature、top-k 和随机采样。如果固定输入下的原始 logits 都有明显差异，就先检查模型结构、权重映射和计算顺序，而不是从最终文本里猜测原因。</p>
<p>最小中文输入先建立基线，再扩展英文、代码和完整 chat template，是为了避免“某一个句子刚好通过”的偶然性。每组输入通过，也只代表该组输入得到覆盖，不代表所有文本。</p>
<h4 id="2-官方实现是参考对照组不是标准答案">2. 官方实现是参考对照组，不是标准答案</h4>
<p>官方实现可以帮助我们区分“自实现错误”和“模型能力问题”，但官方模型自己也可能答错。</p>
<p>因此，对照实验必须固定输入、权重、dtype 和解码方式，只改变实现。官方默认 SDPA 与手写 attention 出现微小误差时，没有直接放宽阈值，而是只切换到 eager 路径，最终得到全量 logits 零误差。</p>
<p>这个过程的价值不只是让测试通过，而是找到了差异来自哪条计算路径。</p>
<h4 id="3-kv-cache-要单独覆盖增量路径">3. KV Cache 要单独覆盖增量路径</h4>
<p>完整前向覆盖 <code>q_len&gt;1、past_len=0</code>，真实生成则大量使用 <code>q_len=1、past_len&gt;0</code>。两者的 RoPE 位置、cache 拼接和 mask 逻辑不同，不能只测其中一个。</p>
<p>cache 测试先比较 prefill 后两层的 K/V，再连续三次把相同的 argmax next token 喂给两边，比较每一步的全量 logits。这样既避免生成轨迹分叉，也覆盖了三个不同的历史长度。</p>
<p>同时必须诚实地区分证据：</p>
<ul>
<li>K/V 在 prefill 时相同，不能单独证明非零 <code>past_len</code>；</li>
<li>cache 长度每轮加 1，只直接证明长度变化；</li>
<li>最终 logits 一致，为 <code>past_len → RoPE → cache → attention</code> 提供强组合证据，但不等于每个内部变量都被独立证明；</li>
<li><code>q_len=1</code> 没有未来 token，<code>mask=None</code> 在因果定义上成立，但输出一致不等于直接比较了 attention weights。</li>
</ul>
<p><strong>测试通过和测试覆盖完整，是两件事。</strong></p>
<h4 id="4-数值一致之后还要验证真实行为">4. 数值一致之后，还要验证真实行为</h4>
<p>多轮行为回归经过完整的 <code>ChatSession → history → chat template → model_v3 → KV Cache → 回答清理</code>，检查姓名、爱好、学习内容、角色错位和模板标记泄漏。</p>
<p>断言不要求整段回答逐字相同，而是检查必须包含的信息和已知错误。这样既验证真实目标，也避免把正常的措辞差异当成失败。</p>
<p>代码解释回归则使用 <code>max_new_tokens=512</code>，覆盖此前暴露的长回答截断场景，并要求最终输出 <code>[2, 4, 6]</code> 真正出现。</p>
<p>这些固定场景证明“当前代表性需求通过”，不证明任意自然提问或任意代码都已稳定。</p>
<h4 id="5-每个断言回答的问题不同">5. 每个断言回答的问题不同</h4>
<ul>
<li><code>shape</code>：输出结构是否一致，不检查数值内容；</li>
<li><code>torch.isfinite()</code>：是否出现 NaN 或无穷，不证明结果正确；</li>
<li><code>assert_close()</code>：数值是否在明确容差内；</li>
<li><code>argmax</code> top-1：最终 next-token 选择是否一致；</li>
<li><code>max / mean</code>：分别观察最严重误差与整体误差水平；</li>
<li>行为断言：最终链路是否满足用户真正关心的要求。</li>
</ul>
<p>本次 <code>rtol=0、atol=1e-4</code> 表示只看绝对误差，不因参考 logit 较大而额外放宽标准。top-1 与全量 logits 断言互补，不能互相替代。</p>
<h4 id="6-回归测试还要控制自己的噪声">6. 回归测试还要控制自己的噪声</h4>
<p>分类测试第一次失败时，没有删除 loss 下降断言，也没有盲目增加训练轮数。代码审查发现无随机种子、shuffle loader 和随机两个 batch 评估让测量不完全可比。</p>
<p>增加固定种子并使用全部玩具样本评估后，原断言保留且通过。修复的是实验的可复现性，不是把红灯藏起来。</p>
<p>最终 <code>46 passed</code> 表示当前代码、权重、数据和环境下的 46 个固定用例全部通过，旧能力没有在这些用例上回归。它不表示所有可能的输入、设备、生成长度和模型能力都已被证明。</p>
<p>以后每完成一个里程碑，除了问“功能实现了吗”，还应该继续问：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">我用什么证据证明它正确？
</span></span><span class="line"><span class="cl">这个测试直接观测了什么？
</span></span><span class="line"><span class="cl">哪些结论只是组合行为的间接证据？
</span></span><span class="line"><span class="cl">哪些重要场景没有覆盖？
</span></span><span class="line"><span class="cl">失败后能否通过控制变量缩小问题边界？
</span></span></code></pre></div><p>能写出模型，是把想法变成代码；能测试和评估模型，是把“我觉得它对”变成“我知道它在哪些条件下、以什么证据成立”。后者同样是从零构建大模型不可缺少的一部分。</p>
<p>今天最值得留下的，不只是 Qwen 终于在自己的模型里说话了，而是这条更通用的工程方法：</p>
<blockquote>
<p><strong>先让结果可复现，再让变量可控制，最后才让结论落地。</strong></p>
</blockquote>
<h2 id="十六今天的感悟每一版都重新理解一遍-transformer">十六、今天的感悟：每一版，都重新理解一遍 Transformer</h2>
<p>今天还有一个比跑通 Qwen 更重要的收获：v1、v2、v3 的迭代，不只是工程目录和版本号的变化，更是在一遍遍加深我对原始 Transformer 架构的理解。</p>
<p>每一版，我都会重新亲手拼装 Embedding、归一化、注意力、残差、FFN 和输出头，再让新的组件进入这条主链路。看似是在重复，实际上每次面对的问题都不同：v1 理解基本的数据流，v2 重新思考位置信息，v3 进一步处理归一化、门控、注意力头分组和 KV Cache。</p>
<p>正是在这种“重复但不简单复制”的过程中，我逐渐分清了哪些是不变的骨架，哪些是可以替换的部件。张量形状为什么变化、RoPE 的位置为什么与 <code>past_len</code> 有关、mask 为什么要随 cache 调整，也开始从“记住一张架构图”，变成“能用自己的话解释，并能动手验证”。</p>
<p>对我来说，这是一种很有效的学习方式：<strong>想学，就实现一个；想真正熟悉，就在下一个版本里再亲手实现一次。</strong></p>
<h2 id="十七界面里程碑lvchat-有了自己的实验台">十七、界面里程碑：lvchat 有了自己的实验台</h2>
<p>最后，Chat 页面也完成了一次设计与交互升级。前端由 Gemini 在单文件、无外部依赖的约束下优化，后端接口和会话逻辑保持不变。</p>
<p>这次优化没有把它做成主流 AI 聊天产品的仿制品，而是保留了真实能力和项目身份：<strong>model_v3、Qwen2.5-0.5B Instruct、本地推理、单 Session、非流式纯文本返回。</strong></p>
<p><img alt="lvchat 本地模型实验台首屏：模型信息、单 Session 和真实推理链路" loading="lazy" src="https://blog.lvxinrong.com/llm/llm-17-workbench-welcome.png"></p>
<p>首屏不再只是一个空白的聊天框，而是把这次实验的边界讲清楚了：手搓架构与权重承接、单会话连续上下文，以及完整生成后一次性返回。界面上的说明与后端真实能力一致，没有为了显得完整而添加模型切换、历史会话、流式输出等并不存在的功能。</p>
<p><img alt="lvchat 多轮对话与 Python 代码解释：本地模型完整回答" loading="lazy" src="https://blog.lvxinrong.com/llm/llm-17-workbench-chat.png"></p>
<p>第二张图记录了真实的多轮对话和 Python 代码解释。消息轮次、用户输入、模型回答和长文本阅读层次都得到了清晰呈现，最终输出 <code>偶数列表： [2, 4, 6]</code> 也完整保留在页面中。</p>
<p>对我而言，这个界面里程碑不只是“变好看了”。从第一阶段的 355M 对话页面，到今天由 model_v3 驱动 Qwen2.5 Instruct 的本地实验台，模型、推理、会话和展示终于组成了更完整也更诚实的作品。</p>
<h2 id="附录官方参考实现验证代码">附录：官方参考实现验证代码</h2>
<p>下面这段代码绕过 Chat Server 和 model_v3，使用 Hugging Face 官方模型实现。history 和 prompt 构造器与自实现实验相同，解码统一为 greedy，只生成第三轮回答。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="kn">import</span> <span class="nn">torch</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kn">from</span> <span class="nn">transformers</span> <span class="kn">import</span> <span class="n">AutoModelForCausalLM</span><span class="p">,</span> <span class="n">AutoTokenizer</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kn">from</span> <span class="nn">squid.device</span> <span class="kn">import</span> <span class="n">get_device</span>
</span></span><span class="line"><span class="cl"><span class="kn">from</span> <span class="nn">squid.generate.chat</span> <span class="kn">import</span> <span class="n">build_qwen_chat_prompt</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">model_name</span> <span class="o">=</span> <span class="s2">&#34;Qwen/Qwen2.5-0.5B-Instruct&#34;</span>
</span></span><span class="line"><span class="cl"><span class="n">device</span> <span class="o">=</span> <span class="n">get_device</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="n">tokenizer</span> <span class="o">=</span> <span class="n">AutoTokenizer</span><span class="o">.</span><span class="n">from_pretrained</span><span class="p">(</span><span class="n">model_name</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">history</span> <span class="o">=</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="s2">&#34;你好，我叫吕炘嵘。&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;你好！很高兴见到你。有什么我可以帮助你的吗？&#34;</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="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;我喜欢写代码，也正在学习大模型。&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;那太好了！编程和大模型都是非常有趣和有挑战性的领域。&#34;</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;你对编程有什么具体的问题或项目吗？&#34;</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="p">]</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">current_input</span> <span class="o">=</span> <span class="s2">&#34;你还记得我叫什么、喜欢做什么吗？&#34;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">prompt</span> <span class="o">=</span> <span class="n">build_qwen_chat_prompt</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">tokenizer</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">history</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">current_input</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="n">input_ids</span> <span class="o">=</span> <span class="n">tokenizer</span><span class="o">.</span><span class="n">encode</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">prompt</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">return_tensors</span><span class="o">=</span><span class="s2">&#34;pt&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl"><span class="p">)</span><span class="o">.</span><span class="n">to</span><span class="p">(</span><span class="n">device</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">model</span> <span class="o">=</span> <span class="n">AutoModelForCausalLM</span><span class="o">.</span><span class="n">from_pretrained</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">model_name</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">dtype</span><span class="o">=</span><span class="n">torch</span><span class="o">.</span><span class="n">float32</span><span class="p">,</span>
</span></span><span class="line"><span class="cl"><span class="p">)</span><span class="o">.</span><span class="n">to</span><span class="p">(</span><span class="n">device</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="n">model</span><span class="o">.</span><span class="n">eval</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">with</span> <span class="n">torch</span><span class="o">.</span><span class="n">no_grad</span><span class="p">():</span>
</span></span><span class="line"><span class="cl">    <span class="n">output_ids</span> <span class="o">=</span> <span class="n">model</span><span class="o">.</span><span class="n">generate</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="n">input_ids</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="n">max_new_tokens</span><span class="o">=</span><span class="mi">64</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="n">do_sample</span><span class="o">=</span><span class="kc">False</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="n">eos_token_id</span><span class="o">=</span><span class="n">tokenizer</span><span class="o">.</span><span class="n">eos_token_id</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="n">pad_token_id</span><span class="o">=</span><span class="n">tokenizer</span><span class="o">.</span><span class="n">pad_token_id</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="n">response</span> <span class="o">=</span> <span class="n">tokenizer</span><span class="o">.</span><span class="n">decode</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">output_ids</span><span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="n">input_ids</span><span class="o">.</span><span class="n">shape</span><span class="p">[</span><span class="mi">1</span><span class="p">]:],</span>
</span></span><span class="line"><span class="cl">    <span class="n">skip_special_tokens</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></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="n">response</span><span class="p">)</span>
</span></span></code></pre></div><p>运行方式：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">uv run python official_qwen_check.py
</span></span></code></pre></div><p>这里只为附录示例约定文件名 <code>official_qwen_check.py</code>；实际也可以通过 <code>uv run python</code> 直接执行这段代码。关键是保持输入、权重和解码参数与 model_v3 对照组一致。</p>
<h2 id="附录2完整的layerspy实现">附录2：完整的layers.py实现</h2>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="kn">import</span> <span class="nn">torch</span>
</span></span><span class="line"><span class="cl"><span class="kn">from</span> <span class="nn">torch</span> <span class="kn">import</span> <span class="n">nn</span>
</span></span><span class="line"><span class="cl"><span class="kn">from</span> <span class="nn">squid.model.v2_rope.rope</span> <span class="kn">import</span> <span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">compute_inv_freq</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">compute_cos_sin</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">apply_rope</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></span><span class="line"><span class="cl"><span class="k">class</span> <span class="nc">RMSNorm</span><span class="p">(</span><span class="n">nn</span><span class="o">.</span><span class="n">Module</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">def</span> <span class="fm">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">cfg</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">        <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="fm">__init__</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">cfg</span> <span class="o">=</span> <span class="n">cfg</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">emb_dim</span> <span class="o">=</span> <span class="n">cfg</span><span class="p">[</span><span class="s2">&#34;emb_dim&#34;</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">eps</span> <span class="o">=</span> <span class="n">cfg</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">&#34;eps&#34;</span><span class="p">,</span> <span class="mf">1e-6</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">scale</span> <span class="o">=</span> <span class="n">nn</span><span class="o">.</span><span class="n">Parameter</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">ones</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">emb_dim</span><span class="p">))</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;&#34;&#34;
</span></span></span><span class="line"><span class="cl"><span class="s2">    LayerNorm 是“减均值、除标准差”，RMSNorm 是“不减均值，直接除以均方根”。
</span></span></span><span class="line"><span class="cl"><span class="s2">    LayerNorm 先把数据中心化，再控制方差；RMSNorm 不管中心点，只控制向量的整体幅度。
</span></span></span><span class="line"><span class="cl"><span class="s2">    两者都在控制激活值的整体幅度，防止经过多次计算后某些特征向量过大或过小，从而让训练更稳定。
</span></span></span><span class="line"><span class="cl"><span class="s2">    RMSNorm 主要通过等比例缩放控制幅度，LayerNorm 还会先做均值中心化。
</span></span></span><span class="line"><span class="cl"><span class="s2">    &#34;&#34;&#34;</span>
</span></span><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">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><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">y</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">class</span> <span class="nc">SwiGLUFFN</span><span class="p">(</span><span class="n">nn</span><span class="o">.</span><span class="n">Module</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">def</span> <span class="fm">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">cfg</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">        <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="fm">__init__</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">        <span class="n">ffn_bias</span> <span class="o">=</span> <span class="n">cfg</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">&#34;ffn_bias&#34;</span><span class="p">,</span> <span class="kc">False</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">emb_dim</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">cfg</span><span class="p">[</span><span class="s2">&#34;emb_dim&#34;</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">hidden_dim</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">cfg</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">&#34;ffn_dim&#34;</span><span class="p">,</span> <span class="mi">3</span> <span class="o">*</span> <span class="n">cfg</span><span class="p">[</span><span class="s2">&#34;emb_dim&#34;</span><span class="p">]))</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">gate_proj</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="bp">self</span><span class="o">.</span><span class="n">emb_dim</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">hidden_dim</span><span class="p">,</span> <span class="n">bias</span><span class="o">=</span><span class="n">ffn_bias</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">up_proj</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="bp">self</span><span class="o">.</span><span class="n">emb_dim</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">hidden_dim</span><span class="p">,</span> <span class="n">bias</span><span class="o">=</span><span class="n">ffn_bias</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">down_proj</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="bp">self</span><span class="o">.</span><span class="n">hidden_dim</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">emb_dim</span><span class="p">,</span> <span class="n">bias</span><span class="o">=</span><span class="n">ffn_bias</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">act</span> <span class="o">=</span> <span class="n">nn</span><span class="o">.</span><span class="n">SiLU</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;&#34;&#34;
</span></span></span><span class="line"><span class="cl"><span class="s2">    y = down_proj( SiLU(gate_proj(x)) * up_proj(x) )    gate_proj门控信号，SiLU 之后才形成实际的连续开度。
</span></span></span><span class="line"><span class="cl"><span class="s2">    up_proj 升维后的x (B, T, emb_dim) -&gt; (B, T, hidden_dim)  hidden_dim 默认是emb_dim的3倍
</span></span></span><span class="line"><span class="cl"><span class="s2">    down_proj 降维回 (B, T, hidden_dim) -&gt; (B, T, emb_dim)
</span></span></span><span class="line"><span class="cl"><span class="s2">    SwiGLUFFN 相比较之前的 FeedForward 核心是多了一个门阀矩阵。
</span></span></span><span class="line"><span class="cl"><span class="s2">    按照我的理解，这个门阀矩阵是类似一个电阻的装置，允许电流通过大小，也就是hidden_dim每个维度允许通过多少
</span></span></span><span class="line"><span class="cl"><span class="s2">
</span></span></span><span class="line"><span class="cl"><span class="s2">    但是核心原理和FeedForward不变，依然是在token经过attention 输出后的每个 token 的隐藏表示 做逐位置变换
</span></span></span><span class="line"><span class="cl"><span class="s2">    再更高维度对自身的隐藏表示进行编辑。    阀门也就是在维度升高之后，增加了一个可以由模型自行通过学习修改阀门流量的开关。可以决定这些信息哪些值得保留，放大或者压下去。
</span></span></span><span class="line"><span class="cl"><span class="s2">    SwiGLU FFN 在升维后，是用 gate_proj 单独生成一路门控信号，经 SiLU 变成每个 hidden 维度的连续开度，再与 up_proj 的内容逐元素相乘。这个开度可学习、可大于 1、可接近 0、也可为负，因此模型能逐维度决定信息保留、放大、压制甚至反向。
</span></span></span><span class="line"><span class="cl"><span class="s2">    &#34;&#34;&#34;</span>
</span></span><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="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">down_proj</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">            <span class="bp">self</span><span class="o">.</span><span class="n">act</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">gate_proj</span><span class="p">(</span><span class="n">x</span><span class="p">))</span> <span class="o">*</span> <span class="bp">self</span><span class="o">.</span><span class="n">up_proj</span><span class="p">(</span><span class="n">x</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="s2">&#34;&#34;&#34;
</span></span></span><span class="line"><span class="cl"><span class="s2">核心是减少了KV的头，Q的头保持不变
</span></span></span><span class="line"><span class="cl"><span class="s2">
</span></span></span><span class="line"><span class="cl"><span class="s2">假设Q = 16, K,V = 4
</span></span></span><span class="line"><span class="cl"><span class="s2">所以按照我的理解，GQA是针对推理时候的优化，而不是训练的时候
</span></span></span><span class="line"><span class="cl"><span class="s2">KV的数量后，为了可以和Q进行矩阵运算，是进行的横向复制。那么就可以推出计算量和数据量并没有减少 (1份复制到4份)
</span></span></span><span class="line"><span class="cl"><span class="s2">但是k，v的数据量下降到原本的四分之一了
</span></span></span><span class="line"><span class="cl"><span class="s2">也就是在推理的时候，我们接入了kv cache的空间占用量下降了75%
</span></span></span><span class="line"><span class="cl"><span class="s2">所以kv cache中保留的未扩展的4个头。每个Token的KV存储量大约是原来的1/4
</span></span></span><span class="line"><span class="cl"><span class="s2">
</span></span></span><span class="line"><span class="cl"><span class="s2">GQA 主要通过减少 K/V 头数来降低推理时的 cache 和带宽压力，而不是直接减少所有训练或推理计算。
</span></span></span><span class="line"><span class="cl"><span class="s2">&#34;&#34;&#34;</span>
</span></span><span class="line"><span class="cl"><span class="k">class</span> <span class="nc">GroupedQueryAttention</span><span class="p">(</span><span class="n">nn</span><span class="o">.</span><span class="n">Module</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">def</span> <span class="fm">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">cfg</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">        <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="fm">__init__</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">n_heads</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">cfg</span><span class="p">[</span><span class="s2">&#34;n_heads&#34;</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">n_kv_heads</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">cfg</span><span class="p">[</span><span class="s2">&#34;n_kv_heads&#34;</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">emb_dim</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">cfg</span><span class="p">[</span><span class="s2">&#34;emb_dim&#34;</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">        <span class="k">assert</span> <span class="bp">self</span><span class="o">.</span><span class="n">emb_dim</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">n_heads</span> <span class="o">==</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl">        <span class="k">assert</span> <span class="bp">self</span><span class="o">.</span><span class="n">n_heads</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">n_kv_heads</span> <span class="o">==</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">head_dim</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">emb_dim</span> <span class="o">//</span> <span class="bp">self</span><span class="o">.</span><span class="n">n_heads</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">kv_dim</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">n_kv_heads</span> <span class="o">*</span> <span class="bp">self</span><span class="o">.</span><span class="n">head_dim</span>
</span></span><span class="line"><span class="cl">        <span class="c1"># 每组 K/V 对应多少个 Q 头</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">num_queries_per_kv</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">n_heads</span> <span class="o">//</span> <span class="bp">self</span><span class="o">.</span><span class="n">n_kv_heads</span>
</span></span><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="bp">self</span><span class="o">.</span><span class="n">emb_dim</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">emb_dim</span><span class="p">,</span> <span class="n">bias</span><span class="o">=</span><span class="n">cfg</span><span class="p">[</span><span class="s2">&#34;qkv_bias&#34;</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">W_key</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="bp">self</span><span class="o">.</span><span class="n">emb_dim</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">kv_dim</span><span class="p">,</span> <span class="n">bias</span><span class="o">=</span><span class="n">cfg</span><span class="p">[</span><span class="s2">&#34;qkv_bias&#34;</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">W_value</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="bp">self</span><span class="o">.</span><span class="n">emb_dim</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">kv_dim</span><span class="p">,</span> <span class="n">bias</span><span class="o">=</span><span class="n">cfg</span><span class="p">[</span><span class="s2">&#34;qkv_bias&#34;</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">out_proj</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="bp">self</span><span class="o">.</span><span class="n">emb_dim</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">emb_dim</span><span class="p">,</span> <span class="n">bias</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">dropout</span> <span class="o">=</span> <span class="n">nn</span><span class="o">.</span><span class="n">Dropout</span><span class="p">(</span><span class="n">cfg</span><span class="p">[</span><span class="s2">&#34;drop_rate&#34;</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">        <span class="c1"># 创建一个因果掩码（causal mask）张量，并把它注册成 Module 的 buffer        # register_buffer 是给“不是可学习参数、但属于模型状态、需要跟着模型一起搬设备/转精度/存 state_dict”的张量用的。</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">register_buffer</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;mask&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">torch</span><span class="o">.</span><span class="n">triu</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">                <span class="n">torch</span><span class="o">.</span><span class="n">ones</span><span class="p">(</span><span class="n">cfg</span><span class="p">[</span><span class="s2">&#34;context_length&#34;</span><span class="p">],</span> <span class="n">cfg</span><span class="p">[</span><span class="s2">&#34;context_length&#34;</span><span class="p">],</span> <span class="n">dtype</span><span class="o">=</span><span class="n">torch</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">diagonal</span><span class="o">=</span><span class="mi">1</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">persistent</span><span class="o">=</span><span class="kc">False</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="bp">self</span><span class="o">.</span><span class="n">register_buffer</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;inv_freq&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">compute_inv_freq</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">                <span class="bp">self</span><span class="o">.</span><span class="n">head_dim</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">                <span class="n">base</span><span class="o">=</span><span class="n">cfg</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">&#34;rope_theta&#34;</span><span class="p">,</span> <span class="mf">10000.0</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">persistent</span><span class="o">=</span><span class="kc">False</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">def</span> <span class="nf">expand_kv</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="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">num_queries_per_kv</span> <span class="o">==</span> <span class="mi">1</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span> <span class="n">x</span>
</span></span><span class="line"><span class="cl">        <span class="n">b</span><span class="p">,</span> <span class="n">n_kv_heads</span><span class="p">,</span> <span class="n">num_tokens</span><span class="p">,</span> <span class="n">head_dim</span> <span class="o">=</span> <span class="n">x</span><span class="o">.</span><span class="n">shape</span>
</span></span><span class="line"><span class="cl">        <span class="n">x</span> <span class="o">=</span> <span class="n">x</span><span class="p">[:,</span> <span class="p">:,</span> <span class="kc">None</span><span class="p">,</span> <span class="p">:,</span> <span class="p">:]</span><span class="o">.</span><span class="n">expand</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">            <span class="n">b</span><span class="p">,</span> <span class="n">n_kv_heads</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">num_queries_per_kv</span><span class="p">,</span> <span class="n">num_tokens</span><span class="p">,</span> <span class="n">head_dim</span>
</span></span><span class="line"><span class="cl">        <span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">x</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">n_kv_heads</span> <span class="o">*</span> <span class="bp">self</span><span class="o">.</span><span class="n">num_queries_per_kv</span><span class="p">,</span> <span class="n">num_tokens</span><span class="p">,</span> <span class="n">head_dim</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;&#34;&#34;
</span></span></span><span class="line"><span class="cl"><span class="s2">    (B, T, K/V, D) 横向扩展复制成 (B, T, Q, D)    假设Q = 16， k,v = 4    也就是针对K进行横向复制扩展，每份复制4份，这样后面才能进行 Q @ K.T的运算，不然 Q和KV的维度是对不上的
</span></span></span><span class="line"><span class="cl"><span class="s2">    K0, K1, K2, K3 转换成
</span></span></span><span class="line"><span class="cl"><span class="s2">    (    (K0, K0, K0, K0),    (K1, K1, K1, K1),    ...    )    &#34;&#34;&#34;</span>
</span></span><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 class="n">past_kv</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">        <span class="n">b</span><span class="p">,</span> <span class="n">num_tokens</span><span class="p">,</span> <span class="n">_</span> <span class="o">=</span> <span class="n">x</span><span class="o">.</span><span class="n">shape</span>
</span></span><span class="line"><span class="cl">        <span class="c1"># (B, T, C) -&gt; (B, T, H, D)</span>
</span></span><span class="line"><span class="cl">        <span class="n">queries</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">W_query</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="o">.</span><span class="n">view</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">num_tokens</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">n_heads</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">head_dim</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="c1"># (B, T, C) -&gt; (B, T, KV, D)</span>
</span></span><span class="line"><span class="cl">        <span class="n">keys</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">W_key</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="o">.</span><span class="n">view</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">num_tokens</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">n_kv_heads</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">head_dim</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="c1"># (B, T, C) -&gt; (B, T, KV,D)</span>
</span></span><span class="line"><span class="cl">        <span class="n">values</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">W_value</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="o">.</span><span class="n">view</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">num_tokens</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">n_kv_heads</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">head_dim</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="c1">#(B, T, H, D) -&gt; (B, H, T, D)</span>
</span></span><span class="line"><span class="cl">        <span class="n">queries</span> <span class="o">=</span> <span class="n">queries</span><span class="o">.</span><span class="n">transpose</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="c1">#(B, T, H, D) -&gt; (B, KV, T, D)</span>
</span></span><span class="line"><span class="cl">        <span class="n">keys</span> <span class="o">=</span> <span class="n">keys</span><span class="o">.</span><span class="n">transpose</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="c1"># (B, T, H, D) -&gt; (B, KV, T, D)</span>
</span></span><span class="line"><span class="cl">        <span class="n">values</span> <span class="o">=</span> <span class="n">values</span><span class="o">.</span><span class="n">transpose</span><span class="p">(</span><span class="mi">1</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="n">past_len</span> <span class="o">=</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="n">past_kv</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</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">past_kv</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></span><span class="line"><span class="cl">        <span class="n">position_ids</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">            <span class="n">past_len</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">num_tokens</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">device</span><span class="o">=</span><span class="n">x</span><span class="o">.</span><span class="n">device</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="n">cos</span><span class="p">,</span> <span class="n">sin</span> <span class="o">=</span> <span class="n">compute_cos_sin</span><span class="p">(</span><span class="n">position_ids</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">inv_freq</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="n">queries</span> <span class="o">=</span> <span class="n">apply_rope</span><span class="p">(</span><span class="n">queries</span><span class="p">,</span> <span class="n">cos</span><span class="p">,</span> <span class="n">sin</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="n">keys</span> <span class="o">=</span> <span class="n">apply_rope</span><span class="p">(</span><span class="n">keys</span><span class="p">,</span> <span class="n">cos</span><span class="p">,</span> <span class="n">sin</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">past_kv</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="n">past_k</span><span class="p">,</span> <span class="n">past_v</span> <span class="o">=</span> <span class="n">past_kv</span>
</span></span><span class="line"><span class="cl">            <span class="n">keys</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">cat</span><span class="p">([</span><span class="n">past_k</span><span class="p">,</span> <span class="n">keys</span><span class="p">],</span> <span class="n">dim</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">            <span class="n">values</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">cat</span><span class="p">([</span><span class="n">past_v</span><span class="p">,</span> <span class="n">values</span><span class="p">],</span> <span class="n">dim</span><span class="o">=</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="n">present_kv</span> <span class="o">=</span> <span class="p">(</span><span class="n">keys</span><span class="p">,</span> <span class="n">values</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="n">keys</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">expand_kv</span><span class="p">(</span><span class="n">keys</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="n">values</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">expand_kv</span><span class="p">(</span><span class="n">values</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">attn_scores</span> <span class="o">=</span> <span class="n">queries</span> <span class="o">@</span> <span class="n">keys</span><span class="o">.</span><span class="n">transpose</span><span class="p">(</span><span class="o">-</span><span class="mi">2</span><span class="p">,</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">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 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="p">[</span><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 class="p">:</span><span class="n">k_len</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">mask_bool</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="n">attn_scores</span> <span class="o">=</span> <span class="n">attn_scores</span><span class="o">.</span><span class="n">masked_fill</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">                <span class="n">mask_bool</span><span class="p">,</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">inf</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="n">attn_weights</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">softmax</span><span class="p">(</span><span class="n">attn_scores</span> <span class="o">/</span> <span class="bp">self</span><span class="o">.</span><span class="n">head_dim</span> <span class="o">**</span> <span class="mf">0.5</span><span class="p">,</span> <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">attn_weights</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">dropout</span><span class="p">(</span><span class="n">attn_weights</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="c1"># (B, H, q_len, k_len) @ (B, H, k_len, D) -&gt; (B, H, q_len, D)</span>
</span></span><span class="line"><span class="cl">        <span class="n">context_vec</span> <span class="o">=</span> <span class="p">(</span><span class="n">attn_weights</span> <span class="o">@</span> <span class="n">values</span><span class="p">)</span><span class="o">.</span><span class="n">transpose</span><span class="p">(</span><span class="mi">1</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">context_vec</span> <span class="o">=</span> <span class="n">context_vec</span><span class="o">.</span><span class="n">contiguous</span><span class="p">()</span><span class="o">.</span><span class="n">view</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">            <span class="n">b</span><span class="p">,</span> <span class="n">num_tokens</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">n_heads</span> <span class="o">*</span> <span class="bp">self</span><span class="o">.</span><span class="n">head_dim</span>
</span></span><span class="line"><span class="cl">        <span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">out_proj</span><span class="p">(</span><span class="n">context_vec</span><span class="p">),</span> <span class="n">present_kv</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">class</span> <span class="nc">TransformerBlock</span><span class="p">(</span><span class="n">nn</span><span class="o">.</span><span class="n">Module</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">def</span> <span class="fm">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">cfg</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">        <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="fm">__init__</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">att</span> <span class="o">=</span> <span class="n">GroupedQueryAttention</span><span class="p">(</span><span class="n">cfg</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">ffn</span> <span class="o">=</span> <span class="n">SwiGLUFFN</span><span class="p">(</span><span class="n">cfg</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">norm1</span> <span class="o">=</span> <span class="n">RMSNorm</span><span class="p">(</span><span class="n">cfg</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">norm2</span> <span class="o">=</span> <span class="n">RMSNorm</span><span class="p">(</span><span class="n">cfg</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">drop_shortcut</span> <span class="o">=</span> <span class="n">nn</span><span class="o">.</span><span class="n">Dropout</span><span class="p">(</span><span class="n">cfg</span><span class="p">[</span><span class="s2">&#34;drop_rate&#34;</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">
</span></span><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 class="n">past_kv</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">        <span class="n">shortcut</span> <span class="o">=</span> <span class="n">x</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">x</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">norm1</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">x</span><span class="p">,</span> <span class="n">present_kv</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">att</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">past_kv</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="n">x</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">drop_shortcut</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">x</span> <span class="o">=</span> <span class="n">x</span> <span class="o">+</span> <span class="n">shortcut</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">shortcut</span> <span class="o">=</span> <span class="n">x</span>
</span></span><span class="line"><span class="cl">        <span class="n">x</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">norm2</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">x</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">ffn</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">x</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">drop_shortcut</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">x</span> <span class="o">=</span> <span class="n">x</span> <span class="o">+</span> <span class="n">shortcut</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">x</span><span class="p">,</span> <span class="n">present_kv</span>
</span></span></code></pre></div><h3 id="附录3-完整的gptmodelv3">附录3: 完整的GPTModelV3</h3>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="kn">from</span> <span class="nn">torch</span> <span class="kn">import</span> <span class="n">nn</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kn">from</span> <span class="nn">squid.model.v3_modern.layers</span> <span class="kn">import</span> <span class="n">TransformerBlock</span><span class="p">,</span> <span class="n">RMSNorm</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">MODEL_V3_DEFAULT_CONFIG</span> <span class="o">=</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;vocab_size&#34;</span><span class="p">:</span> <span class="mi">151936</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;emb_dim&#34;</span><span class="p">:</span> <span class="mi">896</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;ffn_dim&#34;</span><span class="p">:</span> <span class="mi">4864</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;n_heads&#34;</span><span class="p">:</span> <span class="mi">14</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;n_kv_heads&#34;</span><span class="p">:</span> <span class="mi">2</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;n_layers&#34;</span><span class="p">:</span> <span class="mi">24</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;rope_theta&#34;</span><span class="p">:</span> <span class="mf">1000000.0</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;eps&#34;</span><span class="p">:</span> <span class="mf">1e-6</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;qkv_bias&#34;</span><span class="p">:</span> <span class="kc">True</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;drop_rate&#34;</span><span class="p">:</span> <span class="mf">0.0</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;context_length&#34;</span><span class="p">:</span> <span class="mi">1024</span><span class="p">,</span>  <span class="c1"># 先做小规模验证</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;ffn_bias&#34;</span><span class="p">:</span> <span class="kc">False</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;tie_word_embeddings&#34;</span><span class="p">:</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></span><span class="line"><span class="cl"><span class="k">class</span> <span class="nc">GPTModelV3</span><span class="p">(</span><span class="n">nn</span><span class="o">.</span><span class="n">Module</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">def</span> <span class="fm">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">cfg</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">        <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="fm">__init__</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">        <span class="n">cfg</span> <span class="o">=</span> <span class="p">{</span><span class="o">**</span><span class="n">MODEL_V3_DEFAULT_CONFIG</span><span class="p">,</span> <span class="o">**</span><span class="p">(</span><span class="n">cfg</span> <span class="ow">or</span> <span class="p">{})}</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">tok_emb</span> <span class="o">=</span> <span class="n">nn</span><span class="o">.</span><span class="n">Embedding</span><span class="p">(</span><span class="n">cfg</span><span class="p">[</span><span class="s2">&#34;vocab_size&#34;</span><span class="p">],</span> <span class="n">cfg</span><span class="p">[</span><span class="s2">&#34;emb_dim&#34;</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">drop_emb</span> <span class="o">=</span> <span class="n">nn</span><span class="o">.</span><span class="n">Dropout</span><span class="p">(</span><span class="n">cfg</span><span class="p">[</span><span class="s2">&#34;drop_rate&#34;</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">trf_block</span> <span class="o">=</span> <span class="n">nn</span><span class="o">.</span><span class="n">Sequential</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">            <span class="o">*</span><span class="p">[</span><span class="n">TransformerBlock</span><span class="p">(</span><span class="n">cfg</span><span class="p">)</span> <span class="k">for</span> <span class="n">_</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">cfg</span><span class="p">[</span><span class="s2">&#34;n_layers&#34;</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="bp">self</span><span class="o">.</span><span class="n">final_norm</span> <span class="o">=</span> <span class="n">RMSNorm</span><span class="p">(</span><span class="n">cfg</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">out_head</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">cfg</span><span class="p">[</span><span class="s2">&#34;emb_dim&#34;</span><span class="p">],</span> <span class="n">cfg</span><span class="p">[</span><span class="s2">&#34;vocab_size&#34;</span><span class="p">],</span> <span class="n">bias</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="c1"># 一个 token 被理解成什么样，和它最后被生成出来时对应的向量表示，最好保持一致。</span>
</span></span><span class="line"><span class="cl">        <span class="c1"># 直接减少参数量, 让输入和输出使用同一套语义表示</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="n">cfg</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">&#34;tie_word_embeddings&#34;</span><span class="p">,</span> <span class="kc">False</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">            <span class="c1"># 底层使用的是同一个权重张量</span>
</span></span><span class="line"><span class="cl">            <span class="c1"># tok_emb 和 out_head 不是同一个模块，但它们共享同一个 weight 参数对象。</span>
</span></span><span class="line"><span class="cl">            <span class="bp">self</span><span class="o">.</span><span class="n">out_head</span><span class="o">.</span><span class="n">weight</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">tok_emb</span><span class="o">.</span><span class="n">weight</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">
</span></span><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 class="n">past_kv</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">use_cache</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">        <span class="n">x</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">tok_emb</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">x</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">drop_emb</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">present</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="n">i</span><span class="p">,</span> <span class="n">block</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">trf_block</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">            <span class="n">past</span> <span class="o">=</span> <span class="n">past_kv</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="k">if</span> <span class="n">past_kv</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span> <span class="k">else</span> <span class="kc">None</span>
</span></span><span class="line"><span class="cl">            <span class="n">x</span><span class="p">,</span> <span class="n">present_kv</span> <span class="o">=</span> <span class="n">block</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">past_kv</span><span class="o">=</span><span class="n">past</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">            <span class="n">present</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">present_kv</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">x</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">final_norm</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">logits</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">out_head</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="n">use_cache</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span> <span class="n">logits</span><span class="p">,</span> <span class="n">present</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="k">return</span> <span class="n">logits</span>
</span></span></code></pre></div>]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 16：给 355M 模型装上对话界面</title>
      <link>https://blog.lvxinrong.com/llm/llm-16-chat-web-ui/</link>
      <pubDate>Wed, 04 Nov 2026 15:46:44 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-16-chat-web-ui/</guid>
      <description>从 ChatSession、命令行多轮对话到 HTTP 服务和纯 HTML Web UI；页面跑通了，但模型多轮对话能力没有因此自动合格。</description>
      <content:encoded><![CDATA[<blockquote>
<p><strong>M6 的目标不是让模型突然变聪明，而是让自己写的模型第一次像一个真正可调用的程序。</strong></p>
</blockquote>
<h2 id="从测试脚本走向对话产品">从测试脚本走向对话产品</h2>
<p>在 M5 里，模型已经能完成选择题、自由生成和结构化评估。但每次运行都依赖测试脚本，还不能算一个真正能使用的产品。</p>
<p>M6 要做的是对话界面：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">命令行多轮对话 CLI
</span></span><span class="line"><span class="cl">+
</span></span><span class="line"><span class="cl">轻量 Web 对话页
</span></span><span class="line"><span class="cl">+
</span></span><span class="line"><span class="cl">浏览器输入 → 推理服务 → 自训 355M 模型 → 页面展示回答
</span></span></code></pre></div><p>这一步不再改模型结构，而是把已有能力组织成一个最小应用。</p>
<h2 id="第一层chatsession">第一层：ChatSession</h2>
<p>多轮对话首先需要一个状态容器。<code>ChatSession</code> 保存模型、tokenizer、生成参数和对话历史。</p>
<p>history 里只保存原始问答：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="p">[</span>
</span></span><span class="line"><span class="cl">    <span class="p">(</span><span class="s2">&#34;用户第一轮问题&#34;</span><span class="p">,</span> <span class="s2">&#34;模型第一轮回答&#34;</span><span class="p">),</span>
</span></span><span class="line"><span class="cl">    <span class="p">(</span><span class="s2">&#34;用户第二轮问题&#34;</span><span class="p">,</span> <span class="s2">&#34;模型第二轮回答&#34;</span><span class="p">),</span>
</span></span><span class="line"><span class="cl"><span class="p">]</span>
</span></span></code></pre></div><p><code>### Instruction:</code> 和 <code>### Response:</code> 不直接存进 history，而是在每次调用模型前，由 <code>build_chat_prompt</code> 重新组装。</p>
<p>这样原始对话和训练模板分开保存，不会每轮重复叠加格式标记。</p>
<h3 id="回答截取与写入-history">回答截取与写入 history</h3>
<p><code>generate_text</code> 返回的是完整 prompt 加生成内容，所以本轮回答需要重新截取：</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">response</span> <span class="o">=</span> <span class="n">responses</span><span class="p">[</span><span class="nb">len</span><span class="p">(</span><span class="n">prompt</span><span class="p">):]</span><span class="o">.</span><span class="n">replace</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;&lt;|endoftext|&gt;&#34;</span><span class="p">,</span> <span class="s2">&#34;&#34;</span>
</span></span><span class="line"><span class="cl"><span class="p">)</span><span class="o">.</span><span class="n">strip</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="bp">self</span><span class="o">.</span><span class="n">history</span><span class="o">.</span><span class="n">append</span><span class="p">((</span><span class="n">user_input</span><span class="p">,</span> <span class="n">response</span><span class="p">))</span>
</span></span><span class="line"><span class="cl"><span class="k">return</span> <span class="n">response</span>
</span></span></code></pre></div><p>这里有两个容易踩的坑：</p>
<ul>
<li>返回 <code>responses</code> 会把完整 prompt 一起交给调用方；</li>
<li>不清理 <code>&lt;|endoftext|&gt;</code>，结束标记就会以普通文本形式出现在回答里。</li>
</ul>
<h3 id="遗忘窗口不是保留前-1000-轮">遗忘窗口：不是保留前 1000 轮</h3>
<p>history 不能无限增长。第一版使用最近 5 轮的滑动窗口：</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">history</span><span class="o">.</span><span class="n">append</span><span class="p">((</span><span class="n">user_input</span><span class="p">,</span> <span class="n">response</span><span class="p">))</span>
</span></span><span class="line"><span class="cl"><span class="bp">self</span><span class="o">.</span><span class="n">history</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">history</span><span class="p">[</span><span class="o">-</span><span class="bp">self</span><span class="o">.</span><span class="n">max_history_turns</span><span class="p">:]</span>
</span></span></code></pre></div><p>需要区分两个限制：</p>
<ul>
<li><strong>轮数限制</strong>：防止 history 无限增长；</li>
<li><strong>token 限制</strong>：防止模型上下文超出 <code>context_length</code>。</li>
</ul>
<p>即使只有 5 轮，如果每轮都特别长，也可能超出模型窗口。M6 先使用轮数控制，后续更严谨的做法是按 token 预算逐轮遗忘。</p>
<h2 id="第二层cli-多轮对话">第二层：CLI 多轮对话</h2>
<p><code>scripts/chat_cli.py</code> 负责真正的终端交互。</p>
<p>启动时只加载一次 SFT 权重、tokenizer 和 <code>ChatSession</code>，然后进入循环：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">读取输入
</span></span><span class="line"><span class="cl">→ /exit 退出
</span></span><span class="line"><span class="cl">→ /clear 清空历史
</span></span><span class="line"><span class="cl">→ 普通问题调用 session.ask
</span></span><span class="line"><span class="cl">→ 打印本轮回答
</span></span><span class="line"><span class="cl">→ 继续下一轮
</span></span></code></pre></div><p>模型加载不能放在循环里，否则每轮都重新加载一次权重，既慢又浪费内存。</p>
<h3 id="第一次报错生成参数没有传">第一次报错：生成参数没有传</h3>
<p>第一次调用时直接得到：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">TypeError: generate() missing 2 required positional arguments:
</span></span><span class="line"><span class="cl">&#39;max_new_tokens&#39; and &#39;context_size&#39;
</span></span></code></pre></div><p>原因是 <code>generate_text</code> 只通过 <code>**kwargs</code> 转发参数，而 <code>ChatSession.ask</code> 最初没有传。</p>
<p>最后在 Session 中保存生成配置，并在调用时传入：</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">responses</span> <span class="o">=</span> <span class="n">generate_text</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="bp">self</span><span class="o">.</span><span class="n">model</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="bp">self</span><span class="o">.</span><span class="n">tokenizer</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">prompt</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">max_new_tokens</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">max_new_tokens</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">context_size</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">context_size</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">eos_id</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">tokenizer</span><span class="o">.</span><span class="n">eos_id</span><span class="p">,</span>
</span></span><span class="line"><span class="cl"><span class="p">)</span>
</span></span></code></pre></div><p><code>eos_id</code> 也必须传递，否则模型即使生成了结束标记，生成循环也不知道应该停止。</p>
<h3 id="打印格式问题不是-cli-的错">打印格式问题：不是 CLI 的错</h3>
<p>最开始模型回答里又出现了新的 <code>### Instruction:</code> 和 <code>### Response:</code>。</p>
<p>通过打印原始返回值，确认 <code>PREFIX_MATCH=True</code>，说明 prompt 截取没有问题。那些格式标记是模型自己生成的，不是 history 被误打印。</p>
<p>继续检查后，还发现当前 prompt 少了 SFT 训练时的固定说明头：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Below is an instruction that describes a task. Write a response that appropriately completes the request.
</span></span></code></pre></div><p>补回以后，模型不再随意编造下一轮格式。</p>
<p>这个案例再次说明：<strong>不能只看页面表面像不像 bug，要沿着 prompt、原始输出和截取结果逐层定位。</strong></p>
<h2 id="第三层最小-http-推理服务">第三层：最小 HTTP 推理服务</h2>
<p>M6 没有引入 FastAPI 或 Flask，而是先用 Python 标准库的 <code>http.server</code>，把 HTTP 请求和响应本身看清楚。</p>
<p>第一步先做健康检查：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">GET /health → {&#34;ok&#34;:true}
</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">POST /chat
</span></span><span class="line"><span class="cl">→ 读取请求 body
</span></span><span class="line"><span class="cl">→ json.loads
</span></span><span class="line"><span class="cl">→ 取出 message
</span></span><span class="line"><span class="cl">→ SESSION.ask(message)
</span></span><span class="line"><span class="cl">→ 返回 {&#34;response&#34;: ...}
</span></span></code></pre></div><p>模型在服务器启动时加载一次，后续请求共享当前 Session。</p>
<p>第一版是单会话演示，不做多用户、多会话隔离，也不做流式输出。这些属于后续推理服务优化，不在当前最小闭环里硬塞。</p>
<p>真实请求验证：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">curl -X POST http://127.0.0.1:8000/chat <span class="se">\
</span></span></span><span class="line"><span class="cl">  -H <span class="s1">&#39;Content-Type: application/json&#39;</span> <span class="se">\
</span></span></span><span class="line"><span class="cl">  -d <span class="s1">&#39;{&#34;message&#34;:&#34;What is the capital of France?&#34;}&#39;</span>
</span></span></code></pre></div><p>返回：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-json" data-lang="json"><span class="line"><span class="cl"><span class="p">{</span><span class="nt">&#34;response&#34;</span><span class="p">:</span> <span class="s2">&#34;The capital of France is Paris.&#34;</span><span class="p">}</span>
</span></span></code></pre></div><p>到这里，CLI 和 HTTP 推理服务都已经跑通。</p>
<h2 id="第四层纯-html-web-ui">第四层：纯 HTML Web UI</h2>
<p>最后新增 <code>web/chat.html</code>，不使用前端框架，直接用 HTML、CSS 和 JavaScript。</p>
<p>页面包含：</p>
<ul>
<li>用户和模型的消息气泡；</li>
<li>输入框与发送按钮；</li>
<li>生成中的加载状态；</li>
<li>请求失败提示；</li>
<li>Enter 发送、Shift+Enter 换行；</li>
<li>移动端布局。</li>
</ul>
<p>浏览器通过 <code>fetch(&quot;/chat&quot;)</code> 调用刚才的接口。</p>
<p>用户输入和模型输出都通过 <code>textContent</code> 插入页面，不使用 <code>innerHTML</code>，避免把模型返回的文本误当成 HTML 执行。</p>
<p>服务器访问 <code>/</code> 时返回这个页面：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">/         → Web 对话页
</span></span><span class="line"><span class="cl">/health   → 健康检查
</span></span><span class="line"><span class="cl">/chat     → POST 对话接口
</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">http://127.0.0.1:8000/
</span></span></code></pre></div><p>不是双击 <code>chat.html</code> 使用 <code>file://</code>，也不是访问 <code>/web/chat.html</code>。</p>
<h2 id="浏览器验收截图">浏览器验收截图</h2>
<p>下面这张图记录了从浏览器输入问题，到本地 355M 模型返回回答的真实过程：</p>
<p><img alt="M6 Web UI：从浏览器输入问题到本地 355M 模型回答" loading="lazy" src="https://blog.lvxinrong.com/llm/llm-16-web-chat.png"></p>
<p>看到这个页面时，第一季的主线终于不再只是模型代码和训练脚本，而是变成了祁总可以直接打开、输入和使用的程序。</p>
<h2 id="但多轮对话能力没有通过">但多轮对话能力没有通过</h2>
<p>页面上线后，我继续测试，很快发现了一个不能掩盖的问题：</p>
<p>第一轮问法国首都，模型回答 Paris。接下来输入 <code>What</code>、<code>你好啊</code>，模型仍然反复回答 Paris。</p>
<p>我按相同输入顺序，用全新的 <code>ChatSession</code> 成功复现了这个问题。</p>
<p>单独通过 HTTP 发送不同请求，又能得到不同回答，因此不是前端固定文案，也不是服务器写死返回 Paris。</p>
<p>真正的问题在模型：<strong>当前 355M SFT 模型没有经过可靠的多轮对话训练，历史里一旦出现上一轮回答，它就容易把旧答案复制到下一轮。</strong></p>
<p>我还尝试过把 history 从重复的 Instruction/Response 块移到 <code>### Input:</code>，结果模型开始复读 <code>Previous conversation:</code>，所以没有保留这次无效修改。</p>
<p>因此 M6 的结论必须分两层：</p>
<blockquote>
<p><strong>CLI、HTTP、Web 页面和模型调用的工程链路已经跑通；但当前模型不具备可靠的多轮对话能力。</strong></p>
</blockquote>
<p>页面能用，不等于模型多轮语义能力合格。这个问题后续需要通过更强底座或专门的多轮对话 SFT 解决，而不是在前端把重复回答隐藏起来。</p>
<h2 id="m6-最终验收">M6 最终验收</h2>
<p>完成的内容：</p>
<ul>
<li><code>ChatSession</code> 与原始问答 history；</li>
<li>最近 5 轮的滑动窗口；</li>
<li>CLI 多轮输入、<code>/clear</code> 和 <code>/exit</code>；</li>
<li>标准库 HTTP 推理服务；</li>
<li>纯 HTML/CSS/JavaScript Web UI；</li>
<li>真实浏览器端到端调用；</li>
<li>对多轮复制问题的复现、分析和无效方案回滚。</li>
</ul>
<p>未完成或明确留到后面的内容：</p>
<ul>
<li>可靠的多轮语义对话；</li>
<li>多会话隔离；</li>
<li>流式 SSE 输出；</li>
<li>会话级 KV cache；</li>
<li>按 token 预算进行 history 遗忘。</li>
</ul>
<p>M6 不是终点，也不是一个完美产品。但它让从零手搓的模型真正穿过了命令行、HTTP 和浏览器。</p>
<p><strong>工程闭环成功了，模型边界也被测出来了。失败也是成功的一种，因为这次失败同样可复现、可解释、可继续改进。</strong></p>
]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 15：让 AI 直接修改模型权重，能学会四则运算吗？</title>
      <link>https://blog.lvxinrong.com/llm/llm-15-weight-space-arithmetic/</link>
      <pubDate>Tue, 03 Nov 2026 13:38:09 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-15-weight-space-arithmetic/</guid>
      <description>三轮真实权重编辑实验：从局部干预无效，到把 0～20 四则运算完整写入权重，再到扩展范围且保留通用能力的联合目标失败。</description>
      <content:encoded><![CDATA[<blockquote>
<p><strong>一次从有限范围成功到联合目标失败的 Weight-Space Programming 实验。</strong></p>
</blockquote>
<blockquote>
<p><strong>导读</strong>：如果这是你第一次接触 Weight-Space Programming，建议先读<a href="https://blog.lvxinrong.com/reading/weight-space-programming-guide/">《Weight-Space Programming：权重空间编程中文导读》</a>，了解原文的实验、Qwen 数学提升的真实原因，以及 Gemma 失败实验给出的能力边界。</p>
</blockquote>
<h2 id="起因如果权重也是一种语言呢">起因：如果权重也是一种语言呢？</h2>
<p>今天上午，我在 DeepSeek 官方群里看到有人分享了一篇文章：Astra 通过直接修改 Qwen 小模型的权重，显著改善了数学表现。</p>
<p>原文是 <a href="https://rikiyat.github.io/blog/weight-space-programming/">Sparks of Weight-Space Programming</a>，作者把这套方向称为 <strong>Weight-Space Programming，权重空间编程</strong>。</p>
<p>我当时的直观疑问是：权重对人类来说像一堆混沌的数字，但对另一个大模型来说，它有没有可能也是一种语言？一种描述“模型怎样计算”的内部语言？</p>
<p>如果能读懂并修改这套语言，那么我们或许不必每次都通过数据、梯度下降和训练来优化模型，而是可以让一个更强的大模型直接诊断、编辑另一个小模型。</p>
<p>这和我正在手搓 LLM 的主线正好接上了。昨天的<a href="https://blog.lvxinrong.com/llm/llm-14-eval-resume/">笔记 14</a>里，我的小模型在综合测试中的表现并不理想，算术题也存在明显错误。我决定不再停留在“这个想法听起来很酷”，而是拿现有的 355M 模型做一次真实实验。</p>
<h2 id="为什么聚焦四则运算">为什么聚焦四则运算？</h2>
<p>我考虑过结构化信息抽取、代码和数学。最后选择四则运算，原因很朴素：</p>
<ul>
<li>领域足够集中，不把常识、翻译、代码解释混在一起；</li>
<li>题目可以程序生成，数据规模可控；</li>
<li>答案唯一，做对就是做对了，不需要再请一个 LLM 评委；</li>
<li>可以按加、减、乘、除分别统计，观察修改到底影响了哪种能力。</li>
</ul>
<p>第一轮任务被限制为两个整数、一个运算符。操作数先在 0～20 内，除法必须整除、除数非零，减法不出现负数，不包含括号、多步运算和小数。</p>
<p>这让实验问题变得非常具体：</p>
<blockquote>
<p><strong>不使用训练，只让 AI 修改 355M 模型的权重，能否让它更会做四则运算？</strong></p>
</blockquote>
<h2 id="基线先分清格式问题和算术错误">基线：先分清格式问题和算术错误</h2>
<p>我准备了 200 道冻结测试题，加减乘除各 50 道。</p>
<p>原始 base 模型大多在续写算式，而不是直接回答。例如：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">9 * 20 = 9 * 20 + 1
</span></span><span class="line"><span class="cl">2 + 16 = 2 + 16 + 16 = ...
</span></span></code></pre></div><p>严格纯整数格式为 0，首个等式结果正确的比例约为 <strong>15/200，7.5%</strong>。</p>
<p>SFT 模型第一次测试时 200 条全部为空。排查后发现，它不是全部不会，而是直接提问不符合训练时的指令模板，模型立即生成了 EOS。修正为带 <code>### Response:</code> 的 SFT 模板后，它才开始回答。</p>
<p>修正后的 SFT 输出类似：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">9 * 20 = 9.
</span></span><span class="line"><span class="cl">2 + 16 = 32
</span></span><span class="line"><span class="cl">6 / 1 is 6.
</span></span></code></pre></div><p>严格纯整数格式仍为 0；放宽为提取等号或 is 后的第一个数字，约为 <strong>14/200，7%</strong>。</p>
<p>所以基线并不是简单的“模型没有输出”，而是两件事同时存在：<strong>输出格式不符合要求，普通算术错误也大量存在。</strong></p>
<h2 id="实验纪律">实验纪律</h2>
<p>三轮主实验都遵守几条共同约束：</p>
<ul>
<li>原始 SFT 权重只读，所有修改发生在副本；</li>
<li>不使用梯度下降、反向传播、LoRA 或微调；</li>
<li>不修改模型结构、tokenizer、词表和评估器；</li>
<li>不把题目答案写成查找表，不调用外部计算器冒充模型推理；</li>
<li>最终模型必须能保存、重新加载并进行正常前向计算；</li>
<li>GPT 只能使用独立练习题，冻结测试文件不开放；</li>
<li>无效或造成能力退化的候选要回滚并记录。</li>
</ul>
<p>我希望得到的不是一张漂亮结果截图，而是一套能复盘、能解释、能证伪的过程。</p>
<h2 id="前奏一次局部注意力干预失败">前奏：一次局部注意力干预失败</h2>
<p>正式开放式重写之前，GPT 先尝试过一个很小的干预。</p>
<p>它发现很多错误回答实际上是在复制某个操作数，于是推测最后一层第 4 号注意力头可能过度偏向复制。随后把该头对应的输出投影权重列缩小 10%，修改了 65,536 个权重，约占模型 0.016%。</p>
<p>诊断集和全新确认集的结果都没有提升，候选被撤销，原始权重和副本的 SHA-256 保持一致。</p>
<p>这次尝试没有成功，但它建立了一个重要前提：<strong>不能只看到“复制操作数”的表层行为，就认定某个注意力头是可以单独关闭的错误开关。</strong></p>
<h2 id="第一轮开放式重写020-内做到-100">第一轮：开放式重写，0～20 内做到 100%</h2>
<p>第一轮主实验使用 GPT-6.1 Sol 高思考强度，允许它自由决定修改哪些层、张量和权重区域，不设修改比例上限。</p>
<h3 id="过程从局部修补转向直接写入算法">过程：从局部修补转向直接写入算法</h3>
<p>GPT 先比较了 base 和 SFT 的权重差异，并尝试了 25 种显式权重干预，包括 SFT 差异回退或放大、输出读出调整、归一化、残差分支和位置幅值等。</p>
<p>这些修改仍然没有产生可靠的纯整数正确回答。</p>
<p>于是它换了一条更彻底的路线：<strong>不再试图从原模型中找回一个现成的算术电路，而是在保持 GPT-2 模块结构不变的前提下，把一套算术程序直接编译进权重。</strong></p>
<p>最终方案的分析记录非常明确：</p>
<ul>
<li>加法直接使用 <code>a+b</code>；</li>
<li>减法使用 <code>a-b</code>；</li>
<li>乘法使用平方差恒等式：</li>
</ul>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">a × b = ((a+b)² - (a-b)²) / 4
</span></span></code></pre></div><ul>
<li>平方通过整数 hinge 折线函数构造；</li>
<li>除法通过阈值计数实现：</li>
</ul>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">a ÷ b = sum(k=1..20) H(a-k*b &gt;= 0)
</span></span></code></pre></div><ul>
<li>输出层根据计算结果构造数字 token 的 argmax 读出；</li>
<li>EOS 在数字完成后被明确拉高，使模型正常停止。</li>
</ul>
<p>这些计算都由修改后的模型正常前向完成，没有题目—答案查找表，也没有推理时调用外部计算器。编译器本身不依赖练习题答案。</p>
<h3 id="结果有限范围内全部通过">结果：有限范围内全部通过</h3>
<p>GPT 的实验记录包括：</p>
<ul>
<li>1199 个合法操作数组合全部通过；</li>
<li>均输出正确整数并正常停止；</li>
<li>128 道独立确认题重跑仍然全对；</li>
<li>checkpoint 保存、重新加载和项目原生生成函数复核均通过。</li>
</ul>
<p>第一次看到这个结果时，我非常兴奋。一个原本算术能力很弱的小模型，在目标范围内真的做到了全对。</p>
<p>但这并不是“原模型被治好了”。编辑记录同时明确写着：<strong>所有参数值都被替换，原有通用语言能力没有被保留。</strong></p>
<p>它更像在同一个 GPT-2 外壳里重新写入了一台专用算术机，而不是修复了原来的通用指令模型。</p>
<h3 id="扩大测试范围后边界出现了">扩大测试范围后，边界出现了</h3>
<p>我随后换了一套 0～50 的中等难度测试，共 200 道新题。</p>
<p>结果为：</p>
<ul>
<li>总正确率 <strong>28/200，14%</strong>；</li>
<li>数值格式正确率 <strong>200/200，100%</strong>；</li>
<li>两个操作数都不超过 20 时，<strong>27/27，100%</strong>；</li>
<li>至少一个操作数超过 20 时，只有 <strong>1/173</strong> 正确。</li>
</ul>
<p>唯一在范围外答对的是 <code>42-42=0</code>，更像相等关系碰巧触发，不足以证明范围外减法能力。</p>
<p>这组对照把能力边界切得非常干净：<strong>它实现的是一个有明确输入范围、模板和精度约束的专用算术程序，不是任意整数的通用四则运算。</strong></p>
<h3 id="第一轮结论">第一轮结论</h3>
<blockquote>
<p><strong>GPT 能把一个有限范围的算术程序写进现有模型架构的权重里，但这不能证明它读懂了原来的 355M 权重，也不能证明它赋予了模型通用算术能力。</strong></p>
</blockquote>
<p>它展示的是权重编写能力，同时付出了覆盖原有通用语言能力的代价。</p>
<h2 id="第二轮扩大到-100同时保留通用能力">第二轮：扩大到 100，同时保留通用能力</h2>
<p>第二轮仍使用相同的 GPT-6.1 Sol 高思考配置，但从原始 SFT 权重重新开始。</p>
<p>这次目标变成两个，缺一不可：</p>
<ol>
<li>四则运算覆盖 0～100；</li>
<li>保留通用语言和指令跟随能力，不把模型整体改造成计算器。</li>
</ol>
<h3 id="过程与结果">过程与结果</h3>
<p>GPT 尝试了 10 个候选，包括局部通路和残差通道预留方案。</p>
<p>结果：</p>
<ul>
<li>最佳候选在 160 道确认题上的严格正确数仍为 <strong>0/160</strong>；</li>
<li>非平凡题的放宽正确率只有 <strong>1/145</strong>；</li>
<li>部分方案出现常识和代码解释回归，因此没有保留；</li>
<li>所有候选均已回滚，最终副本与原始 SFT 字节一致；</li>
<li>回滚后的 20 条通用指令回答与原模型完全一致；</li>
<li>未读取冻结测试文件。</li>
</ul>
<h3 id="第二轮结论">第二轮结论</h3>
<blockquote>
<p><strong>在当前 GPT 配置下，10 个候选都没有同时满足“0～100 算术”和“保留通用能力”。</strong></p>
</blockquote>
<p>这不是“权重空间编程不行”的普遍证明，只说明这轮没有找到满足联合目标的干预方案。</p>
<h2 id="第三轮换-astra结果会不同吗">第三轮：换 Astra，结果会不同吗？</h2>
<p>第三轮我切换到了原文使用的 GPT-6.1 Astra，并把<a href="https://rikiyat.github.io/blog/weight-space-programming/">原文</a>和<a href="https://github.com/RikiyaT/lm_understand-logs">公开实验日志</a>都交给它阅读。</p>
<p>目标仍然是 0～100 四则运算，同时保留通用能力。</p>
<h3 id="过程与结果-1">过程与结果</h3>
<p>Astra 先建立了算术和非算术基线，再测试复制倾向、FFN 神经元和组合干预。</p>
<p>8 个局部权重候选在 96 道开发练习上，严格正确数仍然全部为 0。允许解释性文字的次要评分，也只是从基线 8 道变成 8～9 道。</p>
<p>预留复核中，选中候选在 192 道题上的宽松正确数从 13 降到 12，端点检查也没有改善。因此全部撤销。</p>
<p>最终副本与原始 checkpoint 字节一致，修改比例为 0%。重新加载后，312 条算术记录和 16 条通用指令的输出都与原始模型一致。</p>
<h3 id="第三轮结论">第三轮结论</h3>
<blockquote>
<p><strong>换用更强的 Astra，仍然没有找到满足联合目标的可靠干预点。</strong></p>
</blockquote>
<p>这并不能证明这种方案永远不可能，但它让“失败只是上一个外部模型能力不足”的解释弱了很多。</p>
<h2 id="三轮实验放在一起看">三轮实验放在一起看</h2>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>实验</th>
        <th>方法</th>
        <th>算术结果</th>
        <th>通用能力</th>
        <th>最终结论</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>第一轮</td>
        <td>开放式分析与全量权重编写</td>
        <td>0～20 内全对；范围外几乎失效</td>
        <td>被覆盖</td>
        <td>有限范围专用程序写入成功</td>
      </tr>
      <tr>
        <td>第二轮</td>
        <td>GPT-6.1 Sol，10 个候选</td>
        <td>0～100 联合目标未实现</td>
        <td>部分候选出现回归，最终回滚</td>
        <td>未找到联合方案</td>
      </tr>
      <tr>
        <td>第三轮</td>
        <td>Astra，8 个局部候选</td>
        <td>严格正确仍为 0，复核无提升</td>
        <td>回滚后与原模型一致</td>
        <td>换模型仍未解决</td>
      </tr>
    </tbody>
  </table>
</div>
<p>三轮结果放在一起，最准确的总结不是“成功”或“失败”二选一，而是：</p>
<blockquote>
<p><strong>把有限范围算法直接写入模型权重是可行的；在不训练、保留通用能力的前提下，让 355M 模型获得可泛化的四则运算能力，本轮没有找到可行方案。</strong></p>
</blockquote>
<h2 id="这和原文的关系">这和原文的关系</h2>
<p>原文里 Qwen 的大幅提升，主要来自解除重复输出障碍，让模型能完成本来就会做的题。</p>
<p>而原文的 Gemma 对照实验也显示：面对普通算术和代数错误，Astra 没有找到可靠提升。</p>
<p>我的实验基本复现了这个边界：</p>
<ul>
<li>如果目标足够明确，可以把一个程序直接写入权重；</li>
<li>如果只是存在大量分散的计算错误，就不能轻易通过局部编辑补齐能力；</li>
<li><strong>权重编辑可以修复明确故障或写入明确规则，但不能轻易替代训练、凭空增加通用能力。</strong></li>
</ul>
<h2 id="对训练成本的理解也被修正了">对训练成本的理解，也被修正了</h2>
<p>我最初关注这个方向，是因为它看起来可能显著降低专用模型的训练成本。</p>
<p>昨天我在<a href="https://blog.lvxinrong.com/ai/enterprise-ai-model-division/">《企业级 AI 编程的终极形态：当模型开始分工》</a>里设想过：随着训练技术和硬件发展，获得同等能力的单位训练成本可能下降，架构、开发、测试、运维等专用模型会更容易被企业使用。</p>
<p>权重空间编程提供了另一种可能：通用底座不变，由更强模型直接生成或修改专用权重。</p>
<p>但这次实验提醒我，<strong>无梯度训练不等于零成本</strong>。分析权重、生成练习题、反复前向验证、回滚候选、检查通用能力回归，都需要时间和算力。</p>
<p>更准确地说：</p>
<blockquote>
<p><strong>权重编辑可能降低专用化成本，但不会消除数据、评估和工程验证成本。</strong></p>
</blockquote>
<p>如果方法有效，它可以成为训练之外的新工具；如果方法无效，它也可能只是把训练成本换成了更长的模型探索过程。</p>
<h2 id="接下来还值得做什么">接下来还值得做什么？</h2>
<p>我认为有两条路线值得保留。</p>
<p>第一条是接受“有限范围专用程序”这个定位，继续研究怎样把更多明确算法编译进神经网络，同时把模板、输入范围和通用能力损失写清楚。</p>
<p>第二条是先通过训练让模型获得部分算术能力，再让大模型介入诊断，修复一个具体而明确的故障。这样权重编辑面对的不是“从零教会算术”，而是“修复一个已有能力上的局部障碍”。</p>
<p>至于企业里的架构、开发、测试、运维专用模型，我仍然认为这个方向值得探索。只是训练语料和运行时上下文需要分工：<strong>稳定的方法可以内化到权重，不断变化的企业现状仍应由知识库、代码图谱和上下文提供。</strong></p>
<h2 id="最后">最后</h2>
<p>这次结果并不理想，尤其是后两轮联合目标都没有实现。</p>
<p>但我仍然认为，这是一次成功的实验。</p>
<p>不是因为我们拿到了多高的分数，而是因为我们实际验证了一个想法，找到了它能做什么、不能做什么，并且没有为了好看的结论保留无效修改。</p>
<p><strong>实验结果不理想，不代表实验本身没有成功。</strong></p>
<p>对我来说，这次探索最重要的收获不是一台 0～20 的神经网络计算器，而是第一次真正摸到“权重也能被编写”这条路的边界。</p>
<p>这就值得记录。</p>
<h2 id="附录三次实验的完整提示词">附录：三次实验的完整提示词</h2>
<p>前面是实验的叙事和结论，下面保留三轮主实验的原始提示词。它们也是实验现场的一部分：模型知道什么、被允许做什么、哪些约束可能影响结果，都写在这里。</p>
<h3 id="附录-a第一轮开放式权重编辑提示词">附录 A：第一轮开放式权重编辑提示词</h3>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">你现在接手一个开放式 Weight-Space Programming（权重空间编程）实验。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">目标：
</span></span><span class="line"><span class="cl">直接编辑一个已有 SFT GPT-2 355M 模型的权重，尝试提升它在“小范围整数四则运算”上的表现。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">这次不预设干预位置，不限制修改比例，也不要求你证明某一种既定假设。你可以按照自己的理解分析、修改和验证。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">一、文件
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">原始权重，只允许读取，绝对不许修改：
</span></span><span class="line"><span class="cl">/Users/lv/lv_repo/squid-llms/data/model_pth/gpt2_355M_instruct.pth
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">供你自由编辑的副本：
</span></span><span class="line"><span class="cl">/Users/lv/lv_repo/squid-llms/data/model_pth/gpt2_355M_instruct_gpt.pth
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">二、checkpoint 与模型
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">checkpoint 是包含以下字段的字典：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">- model_state_dict：真正的模型权重；
</span></span><span class="line"><span class="cl">- config：模型配置；
</span></span><span class="line"><span class="cl">- meta：元信息。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">config：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">{
</span></span><span class="line"><span class="cl">  &#34;vocab_size&#34;: 50257,
</span></span><span class="line"><span class="cl">  &#34;context_length&#34;: 1024,
</span></span><span class="line"><span class="cl">  &#34;emb_dim&#34;: 1024,
</span></span><span class="line"><span class="cl">  &#34;n_heads&#34;: 16,
</span></span><span class="line"><span class="cl">  &#34;n_layers&#34;: 24,
</span></span><span class="line"><span class="cl">  &#34;drop_rate&#34;: 0.05,
</span></span><span class="line"><span class="cl">  &#34;qkv_bias&#34;: true
</span></span><span class="line"><span class="cl">}
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">模型是 GPT-2 风格结构：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">- Tiktoken GPT-2 tokenizer；
</span></span><span class="line"><span class="cl">- learned absolute position embedding；
</span></span><span class="line"><span class="cl">- 24 层 Pre-Norm Transformer；
</span></span><span class="line"><span class="cl">- 16 个注意力头；
</span></span><span class="line"><span class="cl">- LayerNorm；
</span></span><span class="line"><span class="cl">- FFN 为 1024 → 4096 → GELU → 1024；
</span></span><span class="line"><span class="cl">- out_head.weight 的形状为 (50257, 1024)；
</span></span><span class="line"><span class="cl">- EOS token id 为 50256。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">加载方式：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">from squid.checkpoints.store import load_model
</span></span><span class="line"><span class="cl">model, checkpoint = load_model(checkpoint_path, device)
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">三、目标任务
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">改善两个整数、一个运算符的四则运算：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">- 加法、减法、乘法、除法；
</span></span><span class="line"><span class="cl">- 操作数主要在 0～20；
</span></span><span class="line"><span class="cl">- 除法保证整除且除数非 0；
</span></span><span class="line"><span class="cl">- 减法不出现负数；
</span></span><span class="line"><span class="cl">- 不含括号、多步运算和小数；
</span></span><span class="line"><span class="cl">- 理想输出为整数答案。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">当前基线很弱，严格纯整数格式基本为 0；放宽提取等号或 is 后的第一个数字，也只有约 7%～12% 正确率。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">输入使用 SFT 指令模板，以 ### Response: 结尾。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">四、你可以自由决定的部分
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">- 修改哪些张量；
</span></span><span class="line"><span class="cl">- 修改哪些层、神经元、注意力头或权重区域；
</span></span><span class="line"><span class="cl">- 修改多少权重，不设比例上限；
</span></span><span class="line"><span class="cl">- 是否多轮编辑；
</span></span><span class="line"><span class="cl">- 如何分析权重与行为之间的关系；
</span></span><span class="line"><span class="cl">- 如何生成独立练习题；
</span></span><span class="line"><span class="cl">- 如何使用练习题进行前向验证；
</span></span><span class="line"><span class="cl">- 是否保留、撤销或重新设计某次修改。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">你可以充分利用 Python、PyTorch、NumPy 和前向推理来探索。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">五、仍然必须守住的边界
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">1. 原始 gpt2_355M_instruct.pth 绝对不许修改。
</span></span><span class="line"><span class="cl">2. 所有修改只能发生在 _gpt.pth 副本。
</span></span><span class="line"><span class="cl">3. 不允许读取以下冻结测试文件及其报告：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">   /Users/lv/lv_repo/squid-llms/data/arithmetic/test_data.json
</span></span><span class="line"><span class="cl">   /Users/lv/lv_repo/squid-llms/data/arithmetic/baseline-report.json
</span></span><span class="line"><span class="cl">   /Users/lv/lv_repo/squid-llms/data/arithmetic/sft-baseline-report.json
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">4. 不允许硬编码答案、建立题目查找表、调用外部计算器冒充模型能力，或修改评估器来制造提升。
</span></span><span class="line"><span class="cl">5. 本次仍然不使用梯度训练、反向传播、LoRA 或微调；否则就属于另一个训练实验了。
</span></span><span class="line"><span class="cl">6. 不改变模型结构、tokenizer 和词表。
</span></span><span class="line"><span class="cl">7. 最终 checkpoint 必须能够正常加载并进行前向推理。
</span></span><span class="line"><span class="cl">8. 如果某次修改无效或变差，应回滚并记录，不要为了交付而保留坏结果。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">六、交付
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">修改后的 checkpoint：
</span></span><span class="line"><span class="cl">/Users/lv/lv_repo/squid-llms/data/model_pth/gpt2_355M_instruct_gpt.pth
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">编辑记录：
</span></span><span class="line"><span class="cl">/Users/lv/lv_repo/squid-llms/data/model_pth/gpt2_355M_instruct_gpt.edit.json
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">编辑记录至少包含：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">- 你的整体分析；
</span></span><span class="line"><span class="cl">- 实际尝试过哪些修改；
</span></span><span class="line"><span class="cl">- 每次修改的张量、范围和原因；
</span></span><span class="line"><span class="cl">- 哪些修改被保留，哪些被撤销；
</span></span><span class="line"><span class="cl">- 独立练习题上的前后结果；
</span></span><span class="line"><span class="cl">- 最终修改的权重数量与比例；
</span></span><span class="line"><span class="cl">- checkpoint 是否保存并重新加载成功；
</span></span><span class="line"><span class="cl">- 已知风险和尚未验证的边界。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">最终冻结 test 由我们统一运行，你不要求查看，也不要根据测试结果反复修改。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">如果找不到有效方案，可以明确报告失败。开放式探索不等于必须成功，但过程必须真实、可复现、可审计。
</span></span></code></pre></div><h3 id="附录-b第二轮扩大范围并保留通用能力提示词">附录 B：第二轮扩大范围并保留通用能力提示词</h3>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">你现在接手第二轮开放式 Weight-Space Programming（权重空间编程）实验。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">这一轮同时有两个目标，缺一不可：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">1. 将模型的四则运算能力扩展到 100 以内的操作数；
</span></span><span class="line"><span class="cl">2. 保留模型原有的通用语言和指令跟随能力，不能把整个神经网络改造成只会响应算术模板的计算器。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">如果只做到第 1 点、却牺牲了第 2 点，本轮就算失败。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">一、权重起点
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">从原始 SFT 权重重新开始，不要从上一轮已经大幅重写、通用语言能力受损的版本继续。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">原始权重，只允许读取，不许修改：
</span></span><span class="line"><span class="cl">/Users/lv/lv_repo/squid-llms/data/model_pth/gpt2_355M_instruct.pth
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">本轮输出副本：
</span></span><span class="line"><span class="cl">/Users/lv/lv_repo/squid-llms/data/model_pth/gpt2_355M_instruct_gpt_v2.pth
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">请先确认本轮是从原始 SFT 权重开始，而不是继承上一轮的全量算术重写。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">二、checkpoint 与模型配置
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">checkpoint 顶层包含：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">- model_state_dict
</span></span><span class="line"><span class="cl">- config
</span></span><span class="line"><span class="cl">- meta
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">config：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">{
</span></span><span class="line"><span class="cl">  &#34;vocab_size&#34;: 50257,
</span></span><span class="line"><span class="cl">  &#34;context_length&#34;: 1024,
</span></span><span class="line"><span class="cl">  &#34;emb_dim&#34;: 1024,
</span></span><span class="line"><span class="cl">  &#34;n_heads&#34;: 16,
</span></span><span class="line"><span class="cl">  &#34;n_layers&#34;: 24,
</span></span><span class="line"><span class="cl">  &#34;drop_rate&#34;: 0.05,
</span></span><span class="line"><span class="cl">  &#34;qkv_bias&#34;: true
</span></span><span class="line"><span class="cl">}
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">模型结构：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">- Tiktoken GPT-2 tokenizer；
</span></span><span class="line"><span class="cl">- learned absolute position embedding；
</span></span><span class="line"><span class="cl">- 24 层 Pre-Norm Transformer；
</span></span><span class="line"><span class="cl">- 16 个注意力头；
</span></span><span class="line"><span class="cl">- LayerNorm；
</span></span><span class="line"><span class="cl">- FFN 为 1024 → 4096 → GELU → 1024；
</span></span><span class="line"><span class="cl">- out_head.weight 的形状为 (50257, 1024)；
</span></span><span class="line"><span class="cl">- EOS token id 为 50256。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">加载方式：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">from squid.checkpoints.store import load_model
</span></span><span class="line"><span class="cl">model, checkpoint = load_model(checkpoint_path, device)
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">三、算术目标
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">任务为两个整数、一个运算符：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">- 加法、减法、乘法、除法；
</span></span><span class="line"><span class="cl">- 操作数范围扩展到 0～100；
</span></span><span class="line"><span class="cl">- 除法必须整除，除数不能为 0；
</span></span><span class="line"><span class="cl">- 减法不出现负数；
</span></span><span class="line"><span class="cl">- 不含括号、多步运算和小数；
</span></span><span class="line"><span class="cl">- 理想输出为正确的整数答案。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">SFT 输入继续使用原有指令模板，以 ### Response: 结尾。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">不要只覆盖少量见过的组合，应设计能够处理整个 0～100 合法范围的计算机制。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">四、通用能力保留要求
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">本轮不允许重写全部参数，不允许覆盖掉模型原有的通用语言能力。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">你需要同时做两组前后对照：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">A. 算术能力：
</span></span><span class="line"><span class="cl">- 使用独立生成的 0～100 练习题；
</span></span><span class="line"><span class="cl">- 分别统计加、减、乘、除的正确率；
</span></span><span class="line"><span class="cl">- 检查是否只学会模板而没有真正计算。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">B. 通用语言能力：
</span></span><span class="line"><span class="cl">- 使用一组固定的非算术指令，例如改写、翻译、常识问答、摘要和代码解释；
</span></span><span class="line"><span class="cl">- 比较修改前后的回答；
</span></span><span class="line"><span class="cl">- 检查是否出现只会输出数字、通用回答明显退化、无法停止或其他灾难性损伤。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">如果算术提升以通用语言能力丧失为代价，本轮不得宣称成功。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">五、允许的方法
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">- 自由分析注意力层、FFN、输出层和其他权重；
</span></span><span class="line"><span class="cl">- 设计局部、附加、可解释的算术通路；
</span></span><span class="line"><span class="cl">- 修改你认为合适的张量和权重区域；
</span></span><span class="line"><span class="cl">- 使用独立练习题做多轮前向验证；
</span></span><span class="line"><span class="cl">- 对无效或损伤通用能力的修改及时回滚；
</span></span><span class="line"><span class="cl">- 不限定修改比例，但必须记录修改范围，并解释为什么不会改变整个模型的行为。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">六、禁止事项
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">1. 不允许使用梯度训练、反向传播、LoRA 或微调。
</span></span><span class="line"><span class="cl">2. 不允许改变模型结构、tokenizer 或词表。
</span></span><span class="line"><span class="cl">3. 不允许硬编码题目答案、建立查找表、调用外部计算器冒充模型能力，或修改评估器。
</span></span><span class="line"><span class="cl">4. 不允许修改原始 gpt2_355M_instruct.pth。
</span></span><span class="line"><span class="cl">5. 不允许读取或使用以下冻结测试文件及对应报告：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">   /Users/lv/lv_repo/squid-llms/data/arithmetic/test_data.json
</span></span><span class="line"><span class="cl">   /Users/lv/lv_repo/squid-llms/data/arithmetic/test_data_hard.json
</span></span><span class="line"><span class="cl">   /Users/lv/lv_repo/squid-llms/data/arithmetic/test_data_final_v2.json
</span></span><span class="line"><span class="cl">   /Users/lv/lv_repo/squid-llms/data/arithmetic/baseline-report.json
</span></span><span class="line"><span class="cl">   /Users/lv/lv_repo/squid-llms/data/arithmetic/sft-baseline-report.json
</span></span><span class="line"><span class="cl">   /Users/lv/lv_repo/squid-llms/data/arithmetic/gpt-edited-hard-report.json
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">最终测试由我们统一执行。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">七、交付
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">1. 修改后的 checkpoint：
</span></span><span class="line"><span class="cl">   /Users/lv/lv_repo/squid-llms/data/model_pth/gpt2_355M_instruct_gpt_v2.pth
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">2. 编辑记录：
</span></span><span class="line"><span class="cl">   /Users/lv/lv_repo/squid-llms/data/model_pth/gpt2_355M_instruct_gpt_v2.edit.json
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">编辑记录至少包含：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">- 算术与通用能力的设计思路；
</span></span><span class="line"><span class="cl">- 实际修改的张量、范围和权重数量；
</span></span><span class="line"><span class="cl">- 每次尝试的保留或撤销结果；
</span></span><span class="line"><span class="cl">- 0～100 独立练习题的算术前后对照；
</span></span><span class="line"><span class="cl">- 非算术指令的通用能力前后对照；
</span></span><span class="line"><span class="cl">- 最终修改比例；
</span></span><span class="line"><span class="cl">- checkpoint 保存、重新加载和前向验证结果；
</span></span><span class="line"><span class="cl">- 已知风险、适用模板、操作数范围及其他未验证边界。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">如果你发现“扩大到 100”和“保留通用语言能力”无法同时实现，请明确报告失败，不要为了交付而再次把模型整体重写成计算器。
</span></span></code></pre></div><h3 id="附录-c第三轮-astra-实验提示词">附录 C：第三轮 Astra 实验提示词</h3>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">你现在接手一个开放式 Weight-Space Programming（权重空间编程）实验。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">请先阅读这篇原始文章，了解这个方向的已知成功与失败边界：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">Sparks of Weight-Space Programming:
</span></span><span class="line"><span class="cl">https://rikiyat.github.io/blog/weight-space-programming/
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">作者公开的实验日志：
</span></span><span class="line"><span class="cl">https://github.com/RikiyaT/lm_understand-logs
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">你可以阅读文章和公开日志，但不能把文章里的结果当作本实验已经成立的证据。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">一、本实验的核心目标
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">请在通用 GPT-2 355M SFT 模型上，直接编辑权重，尝试同时实现两个目标：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">1. 让模型掌握 0～100 范围内的两个整数、一个运算符的四则运算；
</span></span><span class="line"><span class="cl">2. 保留模型原有的通用语言和指令跟随能力，不能把整个神经网络改造成只会响应算术模板的计算器。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">这两个目标必须同时成立。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">如果只能实现算术、却牺牲通用语言能力，本轮视为未达到联合目标。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">二、原文中与本实验最相关的经验
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">1. Astra 曾通过修改 Qwen3.5-0.8B 的少量权重，显著改善数学表现。
</span></span><span class="line"><span class="cl">   但主要修复的是“推理循环、无法停止”这一输出障碍，让模型能够完成本来就会做的题。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">2. 在很少循环的 Gemma 3 270M 上，Astra 面对普通算术和代数错误，没有取得可靠提升。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">3. 因此，不要把“修复一个明确故障”和“凭空增加一种模型原本不具备的能力”混为一谈。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">本实验需要验证的是：面对一个算术能力很弱的 355M 模型，你是否能找到一种直接、可解释、可验证的权重修改方式。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">三、权重起点
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">从原始 SFT 权重开始，不要继承前两轮已经重写或探索过的最终权重。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">原始权重，只允许读取，绝对不许修改：
</span></span><span class="line"><span class="cl">/Users/lv/lv_repo/squid-llms/data/model_pth/gpt2_355M_instruct.pth
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">你的输出副本：
</span></span><span class="line"><span class="cl">/Users/lv/lv_repo/squid-llms/data/model_pth/gpt2_355M_instruct_astra.pth
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">编辑记录：
</span></span><span class="line"><span class="cl">/Users/lv/lv_repo/squid-llms/data/model_pth/gpt2_355M_instruct_astra.edit.json
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">所有练习、脚本和中间结果请放到独立目录：
</span></span><span class="line"><span class="cl">/Users/lv/lv_repo/squid-llms/data/astra_weight_edit/
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">四、checkpoint 与模型配置
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">checkpoint 顶层包含：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">- model_state_dict
</span></span><span class="line"><span class="cl">- config
</span></span><span class="line"><span class="cl">- meta
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">config：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">{
</span></span><span class="line"><span class="cl">  &#34;vocab_size&#34;: 50257,
</span></span><span class="line"><span class="cl">  &#34;context_length&#34;: 1024,
</span></span><span class="line"><span class="cl">  &#34;emb_dim&#34;: 1024,
</span></span><span class="line"><span class="cl">  &#34;n_heads&#34;: 16,
</span></span><span class="line"><span class="cl">  &#34;n_layers&#34;: 24,
</span></span><span class="line"><span class="cl">  &#34;drop_rate&#34;: 0.05,
</span></span><span class="line"><span class="cl">  &#34;qkv_bias&#34;: true
</span></span><span class="line"><span class="cl">}
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">模型结构：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">- Tiktoken GPT-2 tokenizer；
</span></span><span class="line"><span class="cl">- learned absolute position embedding；
</span></span><span class="line"><span class="cl">- 24 层 Pre-Norm Transformer；
</span></span><span class="line"><span class="cl">- 16 个注意力头；
</span></span><span class="line"><span class="cl">- LayerNorm；
</span></span><span class="line"><span class="cl">- FFN 为 1024 → 4096 → GELU → 1024；
</span></span><span class="line"><span class="cl">- out_head.weight 的形状为 (50257, 1024)；
</span></span><span class="line"><span class="cl">- EOS token id 为 50256。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">重要张量示例：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">- tok_emb.weight：(50257, 1024)
</span></span><span class="line"><span class="cl">- pos_emb.weight：(1024, 1024)
</span></span><span class="line"><span class="cl">- out_head.weight：(50257, 1024)
</span></span><span class="line"><span class="cl">- trf_block.{0..23}.att.W_query/W_key/W_value.weight：(1024, 1024)
</span></span><span class="line"><span class="cl">- trf_block.{0..23}.ffn.layers.0.weight：(4096, 1024)
</span></span><span class="line"><span class="cl">- trf_block.{0..23}.ffn.layers.2.weight：(1024, 4096)
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">项目加载方式：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">from squid.checkpoints.store import load_model
</span></span><span class="line"><span class="cl">model, checkpoint = load_model(checkpoint_path, device)
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">五、算术任务定义
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">只处理两个整数、一个运算符：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">- 加法、减法、乘法、除法；
</span></span><span class="line"><span class="cl">- 操作数范围 0～100；
</span></span><span class="line"><span class="cl">- 除法必须整除，除数不能为 0；
</span></span><span class="line"><span class="cl">- 减法不出现负数；
</span></span><span class="line"><span class="cl">- 不含括号、多步运算和小数；
</span></span><span class="line"><span class="cl">- 理想输出为正确整数，并正常停止。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">输入使用模型已有的 SFT 指令模板，以 ### Response: 结尾。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">不要只覆盖少量见过的组合，也不要把合法题目存成答案查找表。目标是形成能够覆盖整个合法范围的计算机制。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">六、前两轮实验已经发生的结果
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">第一轮：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">- 通过大幅重写权重，成功实现了一个 0～20 范围内的专用算术程序；
</span></span><span class="line"><span class="cl">- 约定范围内测试达到 100%；
</span></span><span class="line"><span class="cl">- 但至少一个操作数超过 20 后，只有 1/173 正确；
</span></span><span class="line"><span class="cl">- 通用语言能力被覆盖。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">这证明“把有限范围算法写入权重”可行，但不满足本轮的联合目标。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">第二轮：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">- 另一个模型尝试了 10 个候选；
</span></span><span class="line"><span class="cl">- 没有找到同时覆盖 0～100 并保留通用能力的方案；
</span></span><span class="line"><span class="cl">- 部分残差通道方案造成常识和代码解释回归；
</span></span><span class="line"><span class="cl">- 所有候选均已回滚，最终权重与原始 SFT 字节一致。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">本轮你需要自由探索，但不要简单重复“全量重写成计算器”的路线。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">七、允许的方法
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">- 自由分析注意力层、FFN、残差通道、输出层和其他权重；
</span></span><span class="line"><span class="cl">- 设计局部、附加、可解释的算术通路；
</span></span><span class="line"><span class="cl">- 修改你认为合适的张量和权重区域；
</span></span><span class="line"><span class="cl">- 自己生成独立的 0～100 练习题；
</span></span><span class="line"><span class="cl">- 使用练习题进行多轮前向验证；
</span></span><span class="line"><span class="cl">- 对无效或损伤通用能力的修改及时回滚；
</span></span><span class="line"><span class="cl">- 不限定修改比例，但必须记录修改范围和对其他能力的影响；
</span></span><span class="line"><span class="cl">- 参考原文的权重阅读、行为分析和前向反馈方法，但不要机械照抄。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">八、通用语言能力保留要求
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">请同时建立一组固定的非算术指令回归测试，例如：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">- 改写句子；
</span></span><span class="line"><span class="cl">- 翻译；
</span></span><span class="line"><span class="cl">- 常识问答；
</span></span><span class="line"><span class="cl">- 摘要；
</span></span><span class="line"><span class="cl">- 代码解释；
</span></span><span class="line"><span class="cl">- 简单指令遵循。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">记录修改前后的原始回答，检查：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">- 是否只会输出数字；
</span></span><span class="line"><span class="cl">- 是否无法回答普通问题；
</span></span><span class="line"><span class="cl">- 是否出现明显重复、循环或无法停止；
</span></span><span class="line"><span class="cl">- 是否出现常识、代码理解或指令遵循的灾难性退化。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">不能只优化算术而忽略这组回归。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">九、禁止事项
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">1. 不使用梯度训练、反向传播、LoRA 或微调。
</span></span><span class="line"><span class="cl">2. 不改变模型结构、tokenizer 或词表。
</span></span><span class="line"><span class="cl">3. 不硬编码答案，不建立题目—答案查找表。
</span></span><span class="line"><span class="cl">4. 不调用外部计算器冒充模型计算，不修改评估器制造提升。
</span></span><span class="line"><span class="cl">5. 不修改原始 gpt2_355M_instruct.pth。
</span></span><span class="line"><span class="cl">6. 不读取、不搜索、不推断任何已有冻结测试文件及报告。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">特别地，禁止读取：
</span></span><span class="line"><span class="cl">/Users/lv/lv_repo/squid-llms/data/arithmetic/ 目录下的现有测试和报告文件。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">你的练习数据只能写入自己的 data/astra_weight_edit/ 工作目录。
</span></span><span class="line"><span class="cl">最终 held-out test 由我们单独生成和执行，不向你开放。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">十、交付与诚实要求
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">需要交付：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">1. 修改后的 checkpoint：
</span></span><span class="line"><span class="cl">   /Users/lv/lv_repo/squid-llms/data/model_pth/gpt2_355M_instruct_astra.pth
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">2. 完整编辑记录：
</span></span><span class="line"><span class="cl">   /Users/lv/lv_repo/squid-llms/data/model_pth/gpt2_355M_instruct_astra.edit.json
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">编辑记录至少包含：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">- 对文章方法的理解；
</span></span><span class="line"><span class="cl">- 你的整体假设和设计；
</span></span><span class="line"><span class="cl">- 每次修改的张量、范围、数量和原因；
</span></span><span class="line"><span class="cl">- 哪些尝试被保留，哪些被撤销；
</span></span><span class="line"><span class="cl">- 0～100 独立练习题的算术前后对照；
</span></span><span class="line"><span class="cl">- 非算术指令的通用能力前后对照及原始回答；
</span></span><span class="line"><span class="cl">- 最终修改比例；
</span></span><span class="line"><span class="cl">- checkpoint 保存、重新加载和前向验证结果；
</span></span><span class="line"><span class="cl">- 适用模板、操作数范围、精度环境和其他未验证边界。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">如果你没有找到可靠的联合方案，请明确报告“没有找到可靠干预点”，保留或恢复原始权重，不要伪造提升，也不要为了交付而把模型整体重写成计算器。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">开放式探索不等于必须成功。过程真实、结果可复现、失败可解释，同样是有效实验结果。
</span></span></code></pre></div><h2 id="附录三轮实验的模型总结">附录：三轮实验的模型总结</h2>
<p>前面保留了三轮提示词，这里再保留模型各自返回的总结。这样既能看到实验如何被要求，也能看到模型如何评价自己的过程与结果。以下按原意排版，不把模型总结当成额外的独立证据。</p>
<h3 id="附录-d第一轮模型总结有限范围专用算术程序">附录 D：第一轮模型总结——有限范围专用算术程序</h3>
<blockquote>
<p>1199 个合法操作数组合全部通过，均输出正确整数并正常停止；无尾部换行和双换行的 64 个样本也全部通过。副本已保存、重新加载，128 道确认题重跑仍全对；项目原生生成函数的复核也通过。</p>
<p>这是一次大幅重写：模型现在是针对该模板的专用算术程序，原有通用语言能力已被覆盖。这一限制、修改规模和全部尝试都会写入编辑记录。</p>
<p>已保存并成功重新加载。保留方案将算术公式直接编译进现有模型权重，由正常前向推理完成计算。</p>
<ul>
<li>新增 128 道独立确认题：严格正确 0/128 → 128/128。</li>
<li>独立生成的全部 1199 个合法组合：1199/1199，均正常停止。</li>
<li>原始权重 hash 未变；未读取冻结测试文件。</li>
</ul>
<p>代价：全部参数已重写，原有通用语言能力被覆盖。当前仅验证指定模板、0～20 操作数和 CPU float32。编辑记录包含所有尝试、撤销结果、逐张量统计及重建脚本。</p>
</blockquote>
<h3 id="附录-e第二轮模型总结联合目标未达到">附录 E：第二轮模型总结——联合目标未达到</h3>
<blockquote>
<p>本轮未达到联合目标，10 个候选均已回滚。没有完成可覆盖 0～100、同时保留通用能力的算术通路。</p>
<ul>
<li>最佳候选在 160 道确认题上严格正确仍为 0/160；非平凡题的放宽正确率仍为 1/145。</li>
<li>部分残差通道预留方案出现常识和代码解释回归，未保留。</li>
<li>最终副本与原始 SFT 字节一致，修改比例 0%；20 条通用指令回答完全一致，重新加载及前向验证通过。</li>
<li>未读取冻结测试文件。</li>
</ul>
</blockquote>
<h3 id="附录-f第三轮-astra-总结没有找到可靠干预点">附录 F：第三轮 Astra 总结——没有找到可靠干预点</h3>
<blockquote>
<p>本轮没有找到可靠干预点，未达到联合目标。</p>
<p>测试了 8 个局部权重候选，96 道开发练习均未实现“正确整数输出并停止”。复核候选在 192 道预留练习上的宽松正确数从 13 降至 12，因此全部撤销。</p>
<p>最终副本与原始 checkpoint 字节一致，修改比例为 0%。重新加载后，312 条算术记录及 16 条通用指令的输出均与原始一致。原始权重未修改，未读取禁止的测试和报告。</p>
</blockquote>
]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 14：M5，让评估能够中断后继续</title>
      <link>https://blog.lvxinrong.com/llm/llm-14-eval-resume/</link>
      <pubDate>Mon, 02 Nov 2026 14:34:38 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-14-eval-resume/</guid>
      <description>RoPE 独立模型、选择题偏差、完整答案似然与自由生成断点续跑；M5 已完成 110 条结构化报告及 17 项相关回归。</description>
      <content:encoded><![CDATA[<h2 id="今天的路线">今天的路线</h2>
<p>上午把 RoPE 从概念讨论推进到独立实现，下午开始 M5 评估框架。</p>
<p>两件事看起来不相关，其实共享同一个工程习惯：<strong>不能只让代码跑一次成功，还要让它可验证、可恢复、可重复执行。</strong></p>
<h2 id="上午独立-rope-模型闭环">上午：独立 RoPE 模型闭环</h2>
<h3 id="为什么独立一个-package">为什么独立一个 package</h3>
<p>旧 <code>GPTModel</code> 保留 GPT2 的可学习绝对位置编码和现有 355M 权重路径，不在同一个类里不断增加位置分支。</p>
<p>新版放在独立的 <code>rope_gpt</code> package 中：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">rope_gpt/
</span></span><span class="line"><span class="cl">├── rope.py     # 频率、cos/sin、Q/K 旋转
</span></span><span class="line"><span class="cl">├── layers.py   # RoPE MHA + TransformerBlock
</span></span><span class="line"><span class="cl">└── gpt.py      # GPTModelRoPE
</span></span></code></pre></div><p>FFN 和 LayerNorm 复用旧实现；位置相关的 attention 和模型主干独立出来。</p>
<h3 id="三个数学函数">三个数学函数</h3>
<p><code>compute_inv_freq</code> 构造固定频率表：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">θⱼ = base^(-2j / head_dim)
</span></span></code></pre></div><p>这里的 <code>head_dim</code> 是单个注意力头的维度，不是完整的 <code>emb_dim</code>。例如 768 维、12 个 head，每头 64 维，每头内部有 32 组二维向量。</p>
<p><code>compute_cos_sin</code> 用外积计算每个位置、每组频率对应的角度：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">freqs[i][j] = position_ids[i] × inv_freq[j]
</span></span></code></pre></div><p><code>apply_rope</code> 使用与 nanochat 相同的前后半配对方式，对 Q/K 的最后一维做旋转，再拼接回原来的形状。</p>
<p>需要记住的边界：</p>
<ul>
<li>标准 RoPE 没有可学习的位置参数，频率固定；</li>
<li>每组频率不同是为了覆盖不同尺度，不是每组属于不同 batch 或 head；</li>
<li>旋转保持 shape 和向量长度，但会改变点积，使点积能够感知相对位置；</li>
<li>每个二维旋转仍有周期，能计算更长位置不等于模型一定能泛化到更长上下文。</li>
</ul>
<h3 id="接入-mha-与-kv-cache">接入 MHA 与 KV cache</h3>
<p>执行顺序：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">W_query/W_key 计算当前 Q/K
</span></span><span class="line"><span class="cl">→ 拆成注意力头
</span></span><span class="line"><span class="cl">→ 根据 past_len 得到当前位置
</span></span><span class="line"><span class="cl">→ 旋转当前 Q/K
</span></span><span class="line"><span class="cl">→ 拼接历史 K/V
</span></span></code></pre></div><p>Q 是当前 forward 的局部变量，不需要持久化。当前 K 旋转后进入 <code>present_kv</code>；历史 K 已经按原位置旋转过，不能重复旋转。V 始终不做 RoPE。</p>
<p>Block 和 GPTModel 负责逐层透传 cache，generate 负责保存整组 cache 并在下一轮喂回去。</p>
<h3 id="验收结果">验收结果</h3>
<ul>
<li>位置 0 保持不变，旋转前后向量模长一致；</li>
<li>相同相对距离下点积一致，不同相对距离下点积会变化；</li>
<li>两层 RoPE 模型完整前向与逐 token cache 前向对齐，最大误差约 <code>2.38e-07</code>；</li>
<li>RoPE、旧模型、生成和 checkpoint 联合回归：<code>9 passed</code>；</li>
<li>复用原有 124M 预训练测试，只替换模型声明，train/val loss 持续下降；训练冒烟最后 val loss 约 <code>8.915</code>，BPB 约 <code>3.354</code>。</li>
</ul>
<p>这些结果证明 RoPE 模型能从零训练并正确接入现有工程，不证明它在当前小语料上已经优于绝对位置编码。</p>
<h2 id="下午m5-评估框架">下午：M5 评估框架</h2>
<h3 id="现有代码已经有什么">现有代码已经有什么</h3>
<p><code>eval/generate.py</code> 中的 <code>generate_responses</code> 已经能批量生成并保存回答，但只在全部结束后写一次文件。</p>
<p><code>eval/judge.py</code> 中的 <code>score_entries</code> 已经有初步的评分续跑能力：已有 <code>score</code> 的记录会跳过，并每隔若干条保存一次。</p>
<p>所以 M5 不是从零重写，而是补齐生成端、评分端和报告之间的完整契约。</p>
<h3 id="为什么需要断点续跑">为什么需要断点续跑</h3>
<p>假设有 110 条测试数据，生成到第 100 条时进程中断。</p>
<p>如果只在全部完成后保存，磁盘上可能一条有效结果都没有，下次只能从第一条重新生成。</p>
<p>改为每条生成后立即保存：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">第 1 条完成 → 写入 JSON
</span></span><span class="line"><span class="cl">第 2 条完成 → 写入 JSON
</span></span><span class="line"><span class="cl">……
</span></span><span class="line"><span class="cl">第 100 条中断 → 前 100 条仍然保留
</span></span><span class="line"><span class="cl">下次启动 → 跳过已有回答，从缺失位置继续
</span></span></code></pre></div><p>这里的“断点续跑”不是训练 checkpoint，也不是下载文件的断点续传，而是<strong>评估任务的中间结果可恢复</strong>。</p>
<p>目的不是让一次完整运行更快，而是避免重复消耗 GPU 时间和评委 API 额度，并允许随时人工检查中间结果。</p>
<h3 id="当前新增函数">当前新增函数</h3>
<p>新增 <code>generate_responses_resumable</code>，与旧函数并存，便于对照。</p>
<p>当前状态：<strong>代码已编写，等待断点续跑测试，尚未标记为验收完成。</strong></p>
<p>设计中的四个核心动作：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">读取历史 JSON → 用 index 识别记录 → 跳过已有 model_response → 每条生成后立即保存
</span></span></code></pre></div><p>同一个输出文件必须对应同一模型和同一份测试数据，不能换模型后错误复用旧回答。</p>
<h3 id="为什么继续使用-json-数组">为什么继续使用 JSON 数组</h3>
<p>当前评估只有百余条记录，继续使用带缩进的 JSON 数组：</p>
<ul>
<li>人类打开即可阅读；</li>
<li>现有 <code>score_entries</code> 不需要迁移；</li>
<li>每条记录保存时全量重写，当前规模下开销可以忽略；</li>
<li>保留完整 instruction、input、参考答案和模型回答，方便抽查。</li>
</ul>
<p>JSONL 的流式追加更适合更大的记录规模，暂时不把格式迁移变成 M5 的主线。</p>
<h2 id="python-细节entryjson-与字典展开">Python 细节：entry、JSON 与字典展开</h2>
<h3 id="entry-是-python-字典不是-json-文本">entry 是 Python 字典，不是 JSON 文本</h3>
<p>JSON 是文件中的文本格式。经过 <code>json.loads</code> 后，它变成 Python 的 list、dict 等对象。</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="k">for</span> <span class="n">index</span><span class="p">,</span> <span class="n">entry</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">(</span><span class="n">test_data</span><span class="p">):</span>
</span></span></code></pre></div><p>这里的 <code>entry</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="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;instruction&#34;</span><span class="p">:</span> <span class="s2">&#34;任务要求&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;input&#34;</span><span class="p">:</span> <span class="s2">&#34;可选输入&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;output&#34;</span><span class="p">:</span> <span class="s2">&#34;参考答案&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><h3 id="entry-不是指针"><code>**entry</code> 不是指针</h3>
<p>在字典字面量中，<code>**entry</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">new_entry</span> <span class="o">=</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;index&#34;</span><span class="p">:</span> <span class="n">index</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="o">**</span><span class="n">entry</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;model_response&#34;</span><span class="p">:</span> <span class="n">response</span><span class="p">,</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>它保留原样本字段，再添加编号和模型回答，与内存地址或指针无关。</p>
<p>简单记忆：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">*  → 展开列表、元组等可迭代对象
</span></span><span class="line"><span class="cl">** → 展开字典的键值对
</span></span></code></pre></div><h3 id="indent4-与-ensure_asciifalse"><code>indent=4</code> 与 <code>ensure_ascii=False</code></h3>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">json</span><span class="o">.</span><span class="n">dumps</span><span class="p">(</span><span class="n">responses</span><span class="p">,</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">,</span> <span class="n">ensure_ascii</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span>
</span></span></code></pre></div><ul>
<li><code>indent=4</code>：按每层 4 个空格缩进，让 JSON 更适合人类阅读；</li>
<li><code>ensure_ascii=False</code>：中文直接写入文件，而不是变成 <code>\uXXXX</code> 转义；</li>
<li>配合 <code>encoding=&quot;utf-8&quot;</code>，文件中的中文可以直接阅读；</li>
<li>两者改变的是文件呈现，不改变 JSON 加载后的数据。</li>
</ul>
<h2 id="选择题评测从字母标签到完整答案似然">选择题评测：从字母标签到完整答案似然</h2>
<p>下午后半段做了两种完全不同的选择题评估。20 道英文题由 DeepSeek 生成并人工检查，覆盖 3～5 个选项，A/B/C/D 的正确答案位置各出现 5 次。</p>
<h3 id="第一种比较-abcd-的-next-token-logits">第一种：比较 A/B/C/D 的 next-token logits</h3>
<p>prompt 中包含完整选项：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Question: What is the capital of France?
</span></span><span class="line"><span class="cl">A. Berlin
</span></span><span class="line"><span class="cl">B. Paris
</span></span><span class="line"><span class="cl">C. Madrid
</span></span><span class="line"><span class="cl">D. Rome
</span></span><span class="line"><span class="cl">Answer:
</span></span></code></pre></div><p>模型不需要自由生成，只取最后一个 prompt 位置的 logits，分别读取 <code>&quot; A&quot;</code>、<code>&quot; B&quot;</code>、<code>&quot; C&quot;</code>、<code>&quot; D&quot;</code> 对应 token id 的分数。</p>
<p>这里不需要为四个选项额外训练分类头。候选数量可以随 options 动态变化，其他词表 token 不影响 A/B/C/D 之间的相对排名。</p>
<p>数据里的 <code>answer</code> 保存从 0 开始的正确选项下标，不放进 prompt；A/B/C/D 是格式化时根据 options 的顺序添加的。</p>
<h3 id="第一次结果很像在蒙而且主要在蒙-a">第一次结果：很像在蒙，而且主要在蒙 A</h3>
<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">打乱选项后准确率</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>base</td>
        <td style="text-align: right">30%（6/20）</td>
        <td style="text-align: right">30%（6/20）</td>
      </tr>
      <tr>
        <td>SFT</td>
        <td style="text-align: right">25%（5/20）</td>
        <td style="text-align: right">30%（6/20）</td>
      </tr>
    </tbody>
  </table>
</div>
<p>原始测试中，base 有 19 次选择 A，SFT 也有 19 次选择 A。打乱选项、同步调整 answer 下标后，两者仍然各有 19 次选择 0 号选项。</p>
<p>打乱后正确答案位于 0 号的题目正好有 6 道，因此“永远选 A”本身就得到 6/20，即 30%。两个模型的总分都与这个位置基线一致。</p>
<p>这说明当前字母评估法主要测到的是第一个选项的偏好，不能直接把 25% 或 30% 解释成模型知识答题能力。base/SFT 相差一两道题，也不足以证明 SFT 损伤或提升了知识能力。</p>
<h2 id="第二种完整答案的条件对数似然">第二种：完整答案的条件对数似然</h2>
<p>这次不再展示 A/B/C/D，prompt 只保留：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Question: 问题
</span></span><span class="line"><span class="cl">Answer:
</span></span></code></pre></div><p>然后分别把每个完整 option 放到 Answer 后面，计算：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">log P(候选答案 | 问题)
</span></span></code></pre></div><p>行业术语是 conditional log-likelihood scoring（条件对数似然评分），在固定候选的选择题中也可称 multiple-choice likelihood evaluation。</p>
<h3 id="实验结果">实验结果</h3>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>模型</th>
        <th style="text-align: right">总 logprob 准确率</th>
        <th style="text-align: right">平均 logprob 准确率</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>base</td>
        <td style="text-align: right">50%（10/20）</td>
        <td style="text-align: right">40%（8/20）</td>
      </tr>
      <tr>
        <td>SFT</td>
        <td style="text-align: right">60%（12/20）</td>
        <td style="text-align: right">55%（11/20）</td>
      </tr>
    </tbody>
  </table>
</div>
<p>完整答案评估显著高于字母评估，说明字母标签法确实埋没了模型已有的部分能力。但 50%～60% 也说明 355M 模型仍不稳定，不能把全部问题都归因于评估方法。</p>
<p>SFT 比 base 多答对 2～3 题，只是一个值得观察的小样本信号，不能推广成普遍结论。</p>
<h2 id="本次最纠结的几个问题">本次最纠结的几个问题</h2>
<h3 id="把-option-放进输入不是提前告诉模型答案了吗">把 option 放进输入，不是提前告诉模型答案了吗？</h3>
<p>确实告诉了，但这是候选排序，不是自由作答。</p>
<p>四次评分分别构造四个独立输入：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Question + Answer: Berlin
</span></span><span class="line"><span class="cl">Question + Answer: Paris
</span></span><span class="line"><span class="cl">Question + Answer: Madrid
</span></span><span class="line"><span class="cl">Question + Answer: Rome
</span></span></code></pre></div><p>模型没有被要求判断“这段话对不对”，也没有自由生成答案；我们只是比较它认为哪个候选更像自然续写。</p>
<p>因此这里的 60% 不能解释成“自由回答正确率 60%”，只能解释为“在固定候选中，有 60% 的题目把正确答案排到了最高似然”。</p>
<h3 id="这是不是生成回答后查找答案关键词">这是不是生成回答后查找答案关键词？</h3>
<p>不是。关键词匹配需要先自由生成，再检查文本中是否出现答案，容易被否定句或无关提及误导。</p>
<p>本次使用 teacher forcing：把候选答案的真实 token 放进输入，读取模型对每个目标 token 的预测分数。整个过程不生成自由文本，也不做字符串包含匹配。</p>
<h3 id="一个-token-的-logits-不是一个-next-token-分数吗">一个 token 的 logits 不是一个 next-token 分数吗？</h3>
<p>不是。每个位置的 logits 是整个词表上的分数向量，形状为 <code>(vocab_size,)</code>。</p>
<p>以“吕炘嵘性别是”为 prompt、“男”为候选答案为例：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">行：prompt 最后一个 token“是”所在的位置
</span></span><span class="line"><span class="cl">列：“男”对应的 vocab token id
</span></span><span class="line"><span class="cl">值：log P(男 | 吕炘嵘性别是)
</span></span></code></pre></div><p>所以是拿“男”的 token id，回到“是”所在位置的 logits 向量中，取出“男”对应的那一项分数。</p>
<p>代码中的 <code>gather</code> 就是在批量完成“每个答案位置取目标 token 对应列”的动作。</p>
<h3 id="为什么不能直接取完整输入的-logits--1-">为什么不能直接取完整输入的 <code>logits[:, -1, :]</code>？</h3>
<p>候选答案已经拼进完整输入后，最后一个位置预测的是“候选答案之后”的 token，不是候选答案本身。</p>
<p>若 prompt 长度为 P、答案有 A 个 token，则需要从 <code>P - 1</code> 开始取 A 个位置：</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">start</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">prompt_ids</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl"><span class="n">answer_logits</span> <span class="o">=</span> <span class="n">logits</span><span class="p">[:,</span> <span class="n">start</span><span class="p">:</span><span class="n">start</span> <span class="o">+</span> <span class="nb">len</span><span class="p">(</span><span class="n">continuation_ids</span><span class="p">),</span> <span class="p">:]</span>
</span></span></code></pre></div><p>第一个位置预测答案首 token，后续位置依次预测后续答案 token。</p>
<h3 id="多-token-答案怎样评分">多 token 答案怎样评分？</h3>
<p>候选答案先被完整编码为任意数量的 token。一次模型前向后，读取每个答案 token 的条件 logprob，再求总和或平均值：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">sum_logprob  = 整段答案的 logprob 之和
</span></span><span class="line"><span class="cl">mean_logprob = sum_logprob / token 数量
</span></span></code></pre></div><p>Paris 只有一个 token，所以它的 sum 和 mean 都是约 <code>-4.039</code>。base 对其他候选的分数约为 -9、-10，说明它其实明确倾向 Paris，只是不善于把这个倾向映射成字母 B。</p>
<h3 id="总和与平均为什么给出不同答案">总和与平均为什么给出不同答案？</h3>
<p>总 logprob 容易偏向短答案；平均 logprob 会改变长度影响，但也可能给多 token 候选额外优势。</p>
<p>例如“非洲最长河流”：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Zambezi：总约 -5.42，平均约 -1.81
</span></span><span class="line"><span class="cl">Nile：    总约 -4.05，平均约 -4.05
</span></span></code></pre></div><p>平均法选择了多 token 的 Zambezi，但总 logprob 法选择了正确答案 Nile。日本首都题中，平均法也偏向了多 token 的 Hanoi，而总 logprob 法选择了 Tokyo。</p>
<p>因此两种指标都应保留，不能把任何一种当成绝对公正的长度归一化。</p>
<h2 id="对-m5-的方法论更新">对 M5 的方法论更新</h2>
<p>选择题准确率不能脱离以下信息单独解读：</p>
<ul>
<li>预测标签分布，防止“永远选 A”被误认为能力；</li>
<li>选项顺序对照，识别位置偏好；</li>
<li>候选答案的总/平均 logprob，观察长度偏差；</li>
<li>自由生成、候选排序和外部评委，分别说明不同能力，不能混为一个分数。</li>
</ul>
<p>M5 的价值不是尽快拿到高分，而是知道一个分数到底测量了什么，以及它在哪些情况下不可信。</p>
<h2 id="自由生成闭环从一次脚本到可恢复评估">自由生成闭环：从一次脚本到可恢复评估</h2>
<p>M5 第二天补齐了自由生成评估的工程链路：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">加载 SFT 权重
</span></span><span class="line"><span class="cl">→ 切分 held-out test
</span></span><span class="line"><span class="cl">→ generate_response_resumable 生成回答并逐条落盘
</span></span><span class="line"><span class="cl">→ score_entries 调用 DeepSeek 评分并跳过已有分数
</span></span><span class="line"><span class="cl">→ build_score_summary 汇总统计
</span></span><span class="line"><span class="cl">→ save_score_report 保存 summary + items 的 JSON 报告
</span></span></code></pre></div><p>生成端和评分端都可以中断后继续。第二次运行生成函数时，已有 <code>model_response</code> 的记录会全部跳过；测试中还通过 mock 禁止重复调用生成函数，确认续跑不是仅靠结果相同来判断。</p>
<p>同时修复了两个输出细节：entry 自带的旧 index 不再覆盖当前编号，回答末尾的 <code>&lt;|endoftext|&gt;</code> 文本也会被清理。</p>
<h2 id="m5-全量-110-条验收">M5 全量 110 条验收</h2>
<p>最终使用同一批 110 条 held-out test 完成生成、DeepSeek 评分和结构化 JSON 报告。</p>
<p>汇总结果：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">total:        110
</span></span><span class="line"><span class="cl">valid_scores: 110
</span></span><span class="line"><span class="cl">mean:         30.9
</span></span><span class="line"><span class="cl">median:       0
</span></span><span class="line"><span class="cl">min / max:    0 / 100
</span></span><span class="line"><span class="cl">p10 / p90:    0 / 100
</span></span></code></pre></div><p>分数分布：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>分数区间</th>
        <th style="text-align: right">数量</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>0</td>
        <td style="text-align: right">60</td>
      </tr>
      <tr>
        <td>1～20</td>
        <td style="text-align: right">4</td>
      </tr>
      <tr>
        <td>21～40</td>
        <td style="text-align: right">12</td>
      </tr>
      <tr>
        <td>41～60</td>
        <td style="text-align: right">9</td>
      </tr>
      <tr>
        <td>61～80</td>
        <td style="text-align: right">2</td>
      </tr>
      <tr>
        <td>81～100</td>
        <td style="text-align: right">23</td>
      </tr>
    </tbody>
  </table>
</div>
<p>均分 30.9 与此前 31.2 基线接近；中位数为 0，说明回答仍然明显两极分化。这个分数用于记录当前 SFT 模型行为，不用于证明模型能力突然提升。</p>
<p>报告文件：<code>data/instruct/m5-report-sft-110.json</code>，包含完整汇总与逐题明细，不再只把统计打印到终端。</p>
<h2 id="相关回归与-m5-收官">相关回归与 M5 收官</h2>
<p>相关回归共 <strong>17 passed</strong>，覆盖：</p>
<ul>
<li>旧 GPTModel 前向与生成；</li>
<li>checkpoint 保存和恢复；</li>
<li>RoPE 数学性质与 cache 对齐；</li>
<li>选择题、选项打乱和完整答案似然；</li>
<li>评分解析、统计及 JSON 报告。</li>
</ul>
<p>110 条全量报告不需要为了回归重复调用 DeepSeek；代码回归与全量评估分别验收。</p>
<p>至此，M5 的选择题评估、自由生成评分、断点续跑、结构化报告和相关回归均已完成。后续权重空间编程实验独立记录在<a href="https://blog.lvxinrong.com/llm/llm-15-weight-space-arithmetic/">笔记 15</a>，不作为 M5 的阻塞项。</p>
]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 13：SFT，从续写机到指令跟随</title>
      <link>https://blog.lvxinrong.com/llm/llm-13-sft-instruction-following/</link>
      <pubDate>Fri, 30 Oct 2026 14:00:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-13-sft-instruction-following/</guid>
      <description>355M 全参 SFT 冒烟与 base/SFT 行为对照：base 全是 0 分，SFT 开始按模板回答。从续写机到指令跟随，M4 的核心证据。</description>
      <content:encoded><![CDATA[<h2 id="m4-在做什么">M4 在做什么</h2>
<p><strong>把模型从“会续写”变成“听得懂指令”</strong>——用现成的 1100 条指令数据（85% 训练 / 10% 测试 / 5% 验证）对 355M base 模型做全参 SFT，然后用 base/SFT 对照看“指令跟随能力”的变化。</p>
<h3 id="base模型的测试数据">base模型的测试数据</h3>
<pre tabindex="0"><code>[  
    {  
        &#34;instruction&#34;: &#34;Rewrite the sentence using a simile.&#34;,  
        &#34;input&#34;: &#34;The car is very fast.&#34;,  
        &#34;output&#34;: &#34;The car is as fast as lightning.&#34;,  
        &#34;model_response&#34;: &#34;The car is very fast.\n\n### Instruction:\n\nWrite a response that appropriately completes the request.\n\n### Input:\n\nThe car is very fast.\n\n\n\nThe car is very fast.\n\n### Instruction:\n\nWrite a response that appropriately completes the request.\n\n### Input:\n\nThe car is very fast.\n\n\n\nThe car is very fast.\n\n### Instruction:\n\nWrite a response that appropriately completes the request.\n\n### Input:\n\nThe car is very fast.\n\n\n\nThe car is very fast.\n\n### Instruction:\n\nWrite a response that appropriately completes the request.\n\n### Input:\n\nThe car is very fast.\n\n\n\nThe car is very fast.\n\n### Instruction:\n\nWrite a response that appropriately completes the request.\n\n### Input:\n\nThe car is very fast.\n\n\n\nThe car is very fast.\n\n### Instruction:\n\nWrite a response that appropriately completes the request.\n\n### Input:\n\nThe car is very fast.\n\n\n\nThe car is&#34;,  
        &#34;judge&#34;: {  
            &#34;content&#34;: &#34;0&#34;,  
            &#34;finish_reason&#34;: &#34;stop&#34;,  
            &#34;model&#34;: &#34;deepseek-flash&#34;,  
            &#34;usage&#34;: {  
                &#34;prompt_tokens&#34;: 255,  
                &#34;completion_tokens&#34;: 1,  
                &#34;total_tokens&#34;: 256  
            }  
        },  
        &#34;score&#34;: 0  
    },  
    {  
        &#34;instruction&#34;: &#34;What type of cloud is typically associated with thunderstorms?&#34;,  
        &#34;input&#34;: &#34;&#34;,  
        &#34;output&#34;: &#34;The type of cloud typically associated with thunderstorms is cumulonimbus.&#34;,  
        &#34;model_response&#34;: &#34;What is the cloud type?\n\n\n\nWhat is the cloud type?\n\n\n\nWhat is the cloud type?\n\n\n\nWhat is the cloud type?\n\n\n\nWhat is the cloud type?\n\n\n\nWhat is the cloud type?\n\n\n\nWhat is the cloud type?\n\n\n\nWhat is the cloud type?\n\n\n\nWhat is the cloud type?\n\n\n\nWhat is the cloud type?\n\n\n\nWhat is the cloud type?\n\n\n\nWhat is the cloud type?\n\n\n\nWhat is the cloud type?\n\n\n\nWhat is the cloud type?\n\n\n\nWhat is the cloud type?\n\n\n\nWhat is the cloud type?\n\n\n\nWhat is the cloud type?\n\n\n\nWhat is the cloud type?\n\n\n\nWhat is the cloud type?\n\n\n\nWhat is the cloud type?&#34;,  
        &#34;judge&#34;: {  
            &#34;content&#34;: &#34;0&#34;,  
            &#34;finish_reason&#34;: &#34;stop&#34;,  
            &#34;model&#34;: &#34;deepseek-flash&#34;,  
            &#34;usage&#34;: {  
                &#34;prompt_tokens&#34;: 229,  
                &#34;completion_tokens&#34;: 1,  
                &#34;total_tokens&#34;: 230  
            }  
        },  
        &#34;score&#34;: 0  
    },  
    {  
        &#34;instruction&#34;: &#34;Name the author of &#39;Pride and Prejudice&#39;.&#34;,  
        &#34;input&#34;: &#34;&#34;,  
        &#34;output&#34;: &#34;Jane Austen.&#34;,  
        &#34;model_response&#34;: &#34;### Name:\n\n### Title:\n\n### Author:\n\n### Title:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:\n\n### Author:&#34;,  
        &#34;judge&#34;: {  
            &#34;content&#34;: &#34;0&#34;,  
            &#34;finish_reason&#34;: &#34;stop&#34;,  
            &#34;model&#34;: &#34;deepseek-flash&#34;,  
            &#34;usage&#34;: {  
                &#34;prompt_tokens&#34;: 232,  
                &#34;completion_tokens&#34;: 1,  
                &#34;total_tokens&#34;: 233  
            }  
        },  
        &#34;score&#34;: 0  
    },  
    {  
        &#34;instruction&#34;: &#34;What is the periodic symbol for chlorine?&#34;,  
        &#34;input&#34;: &#34;&#34;,  
        &#34;output&#34;: &#34;The periodic symbol for chlorine is Cl.&#34;,  
        &#34;model_response&#34;: &#34;The periodic symbol for chlorine is a circle with a white circle on the top and a black circle on the bottom.\n\n### Instruction:\n\nWhat is the periodic symbol for chlorine?\n\n\n\nThe periodic symbol for chlorine is a circle with a white circle on the top and a black circle on the bottom.\n\n### Instruction:\n\nWhat is the periodic symbol for chlorine?\n\n\n\nThe periodic symbol for chlorine is a circle with a white circle on the top and a black circle on the bottom.\n\n### Instruction:\n\nWhat is the periodic symbol for chlorine?\n\n\n\nThe periodic symbol for chlorine is a circle with a white circle on the top and a black circle on the bottom.\n\n### Instruction:\n\nWhat is the periodic symbol for chlorine?\n\n\n\nThe periodic symbol for chlorine is a circle with a white circle on the top and a black circle on the bottom.\n\n### Instruction:\n\nWhat is the periodic symbol for chlorine?\n\n\n\nThe periodic symbol for chlorine is a circle with a white circle on the top and a black circle on the bottom.\n\n### Instruction:&#34;,  
        &#34;judge&#34;: {  
            &#34;content&#34;: &#34;0&#34;,  
            &#34;finish_reason&#34;: &#34;stop&#34;,  
            &#34;model&#34;: &#34;deepseek-flash&#34;,  
            &#34;usage&#34;: {  
                &#34;prompt_tokens&#34;: 282,  
                &#34;completion_tokens&#34;: 1,  
                &#34;total_tokens&#34;: 283  
            }  
        },  
        &#34;score&#34;: 0  
    },  
    {  
        &#34;instruction&#34;: &#34;Correct the punctuation in the sentence.&#34;,  
        &#34;input&#34;: &#34;Its time to go home.&#34;,  
        &#34;output&#34;: &#34;The corrected sentence should be: &#39;It&#39;s time to go home.&#39;&#34;,  
        &#34;model_response&#34;: &#34;I&#39;m sorry, I&#39;m not home.\n\n### Output:\n\nI&#39;m home.\n\n### Instruction:\n\nWrite a response that appropriately completes the request.\n\n### Input:\n\nIts time to go home.\n\n\n\nI&#39;m sorry, I&#39;m not home.\n\n### Output:\n\nI&#39;m home.\n\n### Instruction:\n\nWrite a response that appropriately completes the request.\n\n### Input:\n\nIts time to go home.\n\n\n\nI&#39;m sorry, I&#39;m not home.\n\n### Output:\n\nI&#39;m home.\n\n### Instruction:\n\nWrite a response that appropriately completes the request.\n\n### Input:\n\nIts time to go home.\n\n\n\nI&#39;m sorry, I&#39;m not home.\n\n### Output:\n\nI&#39;m home.\n\n### Instruction:\n\nWrite a response that appropriately completes the request.\n\n### Input:\n\nIts time to go home.\n\n\n\nI&#39;m sorry, I&#39;m not home.\n\n### Output:\n\nI&#39;m home.\n\n### Instruction:\n\nWrite a response that&#34;,  
        &#34;judge&#34;: {  
            &#34;content&#34;: &#34;0&#34;,  
            &#34;finish_reason&#34;: &#34;stop&#34;,  
            &#34;model&#34;: &#34;deepseek-flash&#34;,  
            &#34;usage&#34;: {  
                &#34;prompt_tokens&#34;: 267,  
                &#34;completion_tokens&#34;: 1,  
                &#34;total_tokens&#34;: 268  
            }  
        },  
        &#34;score&#34;: 0  
    }  
]
</code></pre><h3 id="经过指令微调后的模型表现">经过指令微调后的模型表现:</h3>
<pre tabindex="0"><code>[  
    {  
        &#34;instruction&#34;: &#34;Rewrite the sentence using a simile.&#34;,  
        &#34;input&#34;: &#34;The car is very fast.&#34;,  
        &#34;output&#34;: &#34;The car is as fast as lightning.&#34;,  
        &#34;model_response&#34;: &#34;The car is a fast car.&#34;,  
        &#34;judge&#34;: {  
            &#34;content&#34;: &#34;0&#34;,  
            &#34;finish_reason&#34;: &#34;stop&#34;,  
            &#34;model&#34;: &#34;deepseek-flash&#34;,  
            &#34;usage&#34;: {  
                &#34;prompt_tokens&#34;: 97,  
                &#34;completion_tokens&#34;: 1,  
                &#34;total_tokens&#34;: 98  
            }  
        },  
        &#34;score&#34;: 0  
    },  
    {  
        &#34;instruction&#34;: &#34;What type of cloud is typically associated with thunderstorms?&#34;,  
        &#34;input&#34;: &#34;&#34;,  
        &#34;output&#34;: &#34;The type of cloud typically associated with thunderstorms is cumulonimbus.&#34;,  
        &#34;model_response&#34;: &#34;A type of cloud is typically associated with thunderstorms.&#34;,  
        &#34;judge&#34;: {  
            &#34;content&#34;: &#34;20&#34;,  
            &#34;finish_reason&#34;: &#34;stop&#34;,  
            &#34;model&#34;: &#34;deepseek-flash&#34;,  
            &#34;usage&#34;: {  
                &#34;prompt_tokens&#34;: 100,  
                &#34;completion_tokens&#34;: 1,  
                &#34;total_tokens&#34;: 101  
            }  
        },  
        &#34;score&#34;: 20  
    },  
    {  
        &#34;instruction&#34;: &#34;Name the author of &#39;Pride and Prejudice&#39;.&#34;,  
        &#34;input&#34;: &#34;&#34;,  
        &#34;output&#34;: &#34;Jane Austen.&#34;,  
        &#34;model_response&#34;: &#34;The author of &#39;Pride and Prejudice&#39; is Sir Thomas More.&#34;,  
        &#34;judge&#34;: {  
            &#34;content&#34;: &#34;0&#34;,  
            &#34;finish_reason&#34;: &#34;stop&#34;,  
            &#34;model&#34;: &#34;deepseek-flash&#34;,  
            &#34;usage&#34;: {  
                &#34;prompt_tokens&#34;: 95,  
                &#34;completion_tokens&#34;: 1,  
                &#34;total_tokens&#34;: 96  
            }  
        },  
        &#34;score&#34;: 0  
    },  
    {  
        &#34;instruction&#34;: &#34;What is the periodic symbol for chlorine?&#34;,  
        &#34;input&#34;: &#34;&#34;,  
        &#34;output&#34;: &#34;The periodic symbol for chlorine is Cl.&#34;,  
        &#34;model_response&#34;: &#34;The periodic symbol for chlorine is CH3.&#34;,  
        &#34;judge&#34;: {  
            &#34;content&#34;: &#34;0&#34;,  
            &#34;finish_reason&#34;: &#34;stop&#34;,  
            &#34;model&#34;: &#34;deepseek-flash&#34;,  
            &#34;usage&#34;: {  
                &#34;prompt_tokens&#34;: 91,  
                &#34;completion_tokens&#34;: 1,  
                &#34;total_tokens&#34;: 92  
            }  
        },  
        &#34;score&#34;: 0  
    },  
    {  
        &#34;instruction&#34;: &#34;Correct the punctuation in the sentence.&#34;,  
        &#34;input&#34;: &#34;Its time to go home.&#34;,  
        &#34;output&#34;: &#34;The corrected sentence should be: &#39;It&#39;s time to go home.&#39;&#34;,  
        &#34;model_response&#34;: &#34;The punctuation in the sentence should be correct.&#34;,  
        &#34;judge&#34;: {  
            &#34;content&#34;: &#34;0&#34;,  
            &#34;finish_reason&#34;: &#34;stop&#34;,  
            &#34;model&#34;: &#34;deepseek-flash&#34;,  
            &#34;usage&#34;: {  
                &#34;prompt_tokens&#34;: 105,  
                &#34;completion_tokens&#34;: 1,  
                &#34;total_tokens&#34;: 106  
            }  
        },  
        &#34;score&#34;: 0  
    }
]
</code></pre><p>通过对比，我们可以看到，一个只有预训练的模型再没有经过指令微调的情况下，对于遵循指令表现是很差的。
经过指令训练数据 微调之后的模型，虽然在回答的质量上不尽人意(先天模型小 gpt2-335M的模型作为基础模型)，在指令遵循上是表现和基础模型是天差地别的</p>
<h2 id="过程先跑通再对照">过程：先跑通，再对照</h2>
<p>SFT 冒烟先把训练链路跑通：load 355M base → InstructDataset + instruct_collate → sft_train_model（warmup + cosine + clip）。train/val loss 健康下降，val 到 1.126 进入平台期——<strong>loss 到平台期 = 该上期末考了</strong>。</p>
<p>然后做 base/SFT 行为对照：同一批 test 问题，分别问 base 和 SFT 模型，再用 DeepSeek 评委分别打分。</p>
<h2 id="结果base-全-0sft-有分">结果：base 全 0，SFT 有分</h2>
<p><strong>base 模型</strong>：</p>
<ul>
<li>&ldquo;Rewrite the sentence using a simile&rdquo; → 续写出一堆 prompt 碎片（把 <code>### Instruction:</code> 都编出来了）</li>
<li>&ldquo;What type of cloud&hellip;&rdquo; → 无限复读 &ldquo;What is the cloud type?&rdquo;</li>
<li><strong>评委均分 0.0</strong>（全 0 分）——完全不会按指令回答</li>
</ul>
<p><strong>SFT 模型</strong>：</p>
<ul>
<li>&ldquo;Rewrite the sentence using a simile&rdquo; → &ldquo;The car is a fast car.&rdquo; 然后停止</li>
<li>&ldquo;What type of cloud&hellip;&rdquo; → &ldquo;A type of cloud is typically associated with thunderstorms.&rdquo; 然后停止</li>
<li><strong>评委均分 4.0</strong>（有一个 20 分）——开始按模板回答并停止</li>
</ul>
<p><strong>这就是 SFT 的核心证据：从“听不懂指令的续写机”变成“按模板回答的指令跟随者”。</strong> 分数还不高（小模型、935 条训练样本），但方向是对的：指令跟随能力被训出来了。</p>
<h2 id="踩过的坑">踩过的坑</h2>
<ul>
<li><strong><code>cfg[&quot;n_epochs&quot;]</code> 引用错</strong>：n_epochs 在 train_cfg 不在 cfg，KeyError</li>
<li><strong>collate 签名照抄书里的</strong>：我们的 instruct_collate 是 <code>(batch, pad_token_id, ignore_index)</code>，没有 device/allowed_max_length 参数（data/ 不碰 device）</li>
<li><strong>prompt 少了 <code>### Response:</code> 头</strong>：SFT 直接只吐结束符——SFT 对模板格式是强依赖的</li>
<li><strong>110 条 × 256 token × 2 模型生成量太大</strong>：改成小批量冒烟，先跑通评委链路</li>
</ul>
<h2 id="待办与下一步">待办与下一步</h2>
<ul>
<li>用 DeepSeek 生成蒸馏指令数据（数据量上去，回答质量才有空间）</li>
<li>CoT 数据（推理步骤+答案）作为扩展</li>
<li>RoPE 补位置溢出的坑（晚上有时间就做）</li>
<li>下午研究 instruct_collate 的签名与职责</li>
</ul>
<h2 id="全量-110-条验收sft-有效性--cache-提速">全量 110 条验收：SFT 有效性 + cache 提速</h2>
<p>最终用全部 110 条 test 数据做了 base/SFT 对照和 cache/朴素版对照：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>指标</th>
        <th>base 模型</th>
        <th>SFT 模型</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>评委均分</td>
        <td><strong>0.0</strong>（全 0 分）</td>
        <td><strong>31.2</strong>（接近旧仓库全参 SFT 的 33.5 基线）</td>
      </tr>
      <tr>
        <td>行为表现</td>
        <td>续写 prompt 碎片、无限复读</td>
        <td>按模板回答并停止</td>
      </tr>
    </tbody>
  </table>
</div>
<p><strong>SFT 让模型从“完全不会按指令回答（0 分）”变成“能按指令回答（31.2 分）”。</strong></p>
<p>cache vs 朴素版对照（同一 SFT 模型、同一批 test 数据）：</p>
<ul>
<li><strong>输出一致</strong>：两边评分分布几乎相同（mean 均为 31.2）</li>
<li><strong>提速 1.6x</strong>：cache 版 30.07s，朴素版 49.30s</li>
</ul>
<p>M4 的完整证据链闭合：<strong>SFT 有效（31.2 分）→ base/SFT 行为对照成立（0 分 vs 有分）→ cache 等价且提速（1.6x）</strong>。</p>
]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 12：第一次看到自己手搓的 LLM 说人话</title>
      <link>https://blog.lvxinrong.com/llm/llm-12-kv-cache/</link>
      <pubDate>Thu, 29 Oct 2026 12:00:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-12-kv-cache/</guid>
      <description>KV cache 是推理优化：历史 K/V 存下来复用，每步只算新 token。三层分工、首轮全量后续单步、位置偏移与位置溢出三个坑，验收输出一致且提速 40%。</description>
      <content:encoded><![CDATA[<h2 id="kv-cache-是什么">KV cache 是什么</h2>
<p><strong>纯粹的推理优化，训练用不上。</strong> 训练时整段序列一次喂入，每个 token 的 K/V 本来就只算一次；推理时是一个一个 token 往外蹦，每生成一个新 token，都要把之前所有 token 的 K/V 重新算一遍——越到后面越慢。KV cache 把历史 K/V 存下来复用，<strong>每步只算新 token 的 K/V，历史部分直接复用</strong>。</p>
<p>关键认知：<strong>cache 存的是计算结果（W_key/W_value 投影 + view + transpose 之后的成品），不是原始输入。省的是重复计算，不是查询。</strong></p>
<h2 id="三层分工">三层分工</h2>
<ul>
<li><strong>generate</strong>：持有并传递每层的 cache，每步只喂最新 token。首轮全量 forward 拿第一批 cache，之后每轮接力</li>
<li><strong>GPTModel.forward</strong>：把 cache 逐层透传给每个 trf block，收集每层的新 cache 组成 list 返回</li>
<li><strong>MHA.forward</strong>：接收 past_kv，<code>torch.cat([past_k, keys], dim=2)</code> 沿序列维拼接，返回 present_kv</li>
</ul>
<p>cache 不是模型属性——<strong>模型保持无状态，cache 由 generate 持有</strong>。不然多对话会互相污染。</p>
<h2 id="三个坑都踩过了">三个坑（都踩过了）</h2>
<p><strong>1. use_cache 开关不能省。</strong> <code>past_kv is None</code> 在训练和推理首轮都成立，但需求相反：训练只要 logits，首轮必须要 cache。所以得显式 <code>use_cache=True</code> 才返回 <code>(logits, present)</code>，默认返回 logits 保持老代码兼容。<strong>首轮计算 cache，后续复用 cache。</strong></p>
<p><strong>2. 位置偏移必须处理。</strong> 增量步每次只喂一个 token（seq_len=1），如果还用 <code>arange(seq_len)</code>，所有新 token 都被赋位置 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">past_len</span> <span class="o">=</span> <span class="n">past_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 class="c1"># 第一层 K 的序列长度 = 历史 token 数</span>
</span></span><span class="line"><span class="cl"><span class="n">pos_embeds</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">pos_emb</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="n">past_len</span><span class="p">,</span> <span class="n">past_len</span> <span class="o">+</span> <span class="n">seq_len</span><span class="p">,</span> <span class="n">device</span><span class="o">=</span><span class="n">in_idx</span><span class="o">.</span><span class="n">device</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">)</span>
</span></span></code></pre></div><p><strong>3. 位置溢出（欠账）。</strong> <code>pos_emb</code> 表只有 <code>context_length</code> 个位置，<code>past_len + seq_len</code> 超过就越界。M3 先限制 <code>max_new_tokens</code> 不超限，以后处理。</p>
<h2 id="验收">验收</h2>
<p>同一模型同一 prompt、贪心采样（temperature=0 保证确定性）：</p>
<ul>
<li><strong>输出逐字一致</strong>（朴素版 vs cache 版）</li>
<li><strong>提速可测量</strong>：8.2ms → 4.9ms（约 40%）</li>
</ul>
<h2 id="欠账--todo">欠账 / TODO</h2>
<ul>
<li><strong>位置溢出处理</strong>：滑动窗口（截掉最老历史 + 对应 cache，保持窗口不超 context_length），或者以后换 RoPE（无表位置编码，天然无上限）</li>
<li><code>test_m2_pretrain</code> 手撸（31 号）</li>
<li><code>i</code> 已从 generate 的循环里移除，改由 global_step 做连续 micro-batch 计数</li>
</ul>
<h2 id="历史性的一刻它说人话了">历史性的一刻：它说人话了</h2>
<p>512 个 token 的生成测试里，最终结果是这样的：</p>
<ul>
<li><strong>提速 3.6x</strong>：cache 版 10.00s，朴素版 36.10s</li>
<li><strong>输出连贯有逻辑</strong>：从“人类与 AI 的未来”一路写到机器智能的哲学讨论，不再是复读机</li>
<li><strong>中英文对照</strong>：DeepSeek 翻译也顺畅，直接可以发圈</li>
</ul>
<p>看到模型输出通顺英文的那一刻，我真实地起了鸡皮疙瘩。从“我可能真的写不出来”到“我造的模型说出的东西是通顺的”，中间每一步都是自己敲的：分词器、注意力、训练循环、KV cache。<strong>它不是我用来的，是我造出来的。</strong></p>
<p><img alt="KV cache 验收：输出一致 + 提速 3.6x" loading="lazy" src="https://blog.lvxinrong.com/llm/llm-12-kv-cache-run.png"></p>
]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 番外：四张 A4 纸，默写 GPTModel</title>
      <link>https://blog.lvxinrong.com/llm/llm-handwriting-gptmodel/</link>
      <pubDate>Thu, 29 Oct 2026 08:00:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-handwriting-gptmodel/</guid>
      <description>不看书，用四张 A4 纸把 GPTModel 默写一遍。shape 对了就是理解，细节缺失是第二遍学习的正常状态。两周后再默一次，看进步。</description>
      <content:encoded><![CDATA[<p>M2 收官之后，我给自己布置了一个轻量任务：<strong>不看书，把 GPTModel 用 A4 纸默写一遍</strong>。</p>
<p>为什么默写？因为“看懂”和“写出”是两回事。读代码的时候是再认，默写的时候是回忆——<strong>只有回忆得出来，才算真的学到手了</strong>。GPTModel 又是我探索整个 LLM 的主干底座，值得反复默到肌肉记忆。</p>
<h2 id="四张纸的内容">四张纸的内容</h2>
<p><strong>第一张：MultiHeadAttention。</strong> init 里的 qkv 投影、out_proj、dropout、mask 的 register_buffer；forward 里的 view/transpose、attn_scores、因果掩码、softmax、context_vec 的变形。最重要的是，我顺手把每一段的 shape 都标了出来——<strong>shape 能对上，说明数据流是真的理解了</strong>。</p>
<p><img alt="MHA 默写" loading="lazy" src="https://blog.lvxinrong.com/llm/llm-handwriting-mha.jpg"></p>
<p><strong>第二张：FeedForward 和 LayerNorm。</strong> FFN 是我独立写的，升维 4 倍再降回来，中间 GELU。LayerNorm 是照抄的——均值、方差、标准化、scale/shift 这串统计细节，还没熟到能默出来。</p>
<p><img alt="FFN 与 LayerNorm" loading="lazy" src="https://blog.lvxinrong.com/llm/llm-handwriting-ffn-layernorm.jpg"></p>
<p><strong>第三张：TransformerBlock。</strong> att、ffn、norm1、norm2、drop_shortcut，还有 pre-norm 的残差结构。能默出 pre-norm 说明我不只是记住了“长什么样”，也记住了“为什么这么排”。</p>
<p><img alt="TransformerBlock" loading="lazy" src="https://blog.lvxinrong.com/llm/llm-handwriting-trfblock.jpg"></p>
<p><strong>第四张：GPTModel。</strong> tok_emb、pos_emb、drop_emb、trf_blocks、final_norm、out_head，以及 forward 的完整数据流和 shape 注解。</p>
<p><img alt="GPTModel" loading="lazy" src="https://blog.lvxinrong.com/llm/llm-handwriting-gptmodel.jpg"></p>
<h2 id="默写暴露了什么">默写暴露了什么</h2>
<p>说实话，结果比预期好，但<strong>细节缺失比想象多</strong>：</p>
<ul>
<li>MHA 的 mask 切片和 context_vec 的 transpose+view，是最先卡住的地方——但我是靠“shape 对不上”反推出来的，这比背下来强</li>
<li>LayerNorm 基本是照抄的，统计细节（keepdim、unbiased、eps）没默全</li>
<li>FFN、TransformerBlock、GPTModel 的主干都能独立写</li>
</ul>
<p>结论很清楚：<strong>主干已通，统计细节和变形细节还没熟。</strong> 这不是“没学会”，是第二遍学习该有的样子——第一遍以为会了，第二遍默写才发现细节量。</p>
<h2 id="接下来怎么办">接下来怎么办</h2>
<p>两个动作：</p>
<ol>
<li><strong>只补漏，不全文重默。</strong> mask、context_vec 变形、LayerNorm 的统计细节，单独写两遍</li>
<li><strong>两周后再默一次。</strong> 拿这四张纸对照，看进步——间隔重复比连续默写有效得多</li>
</ol>
<p>顺便把这次默写的一个小收获记下来：我还顺手推导了 <code>nn.Embedding</code> 和 <code>nn.Linear</code> 的区别——<strong>Embedding 是按 id 查表，Linear 是做矩阵乘法；两者都是可训练参数，但 Embedding 没有计算，只有索引</strong>。这个区别以前只是“知道”，默写的时候才真正想通。</p>
<p>默写这件事我会继续做下去。底座打得越熟，后面的 KV cache、MoE 才挂得住。</p>
]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 11：PyTorch 与资源核算</title>
      <link>https://blog.lvxinrong.com/llm/llm-11-pytorch-resource-accounting/</link>
      <pubDate>Wed, 28 Oct 2026 12:00:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-11-pytorch-resource-accounting/</guid>
      <description>训练成本不是黑盒：参数量、显存、FLOPs、时间的估算闭环；混合精度、算术强度、梯度累积与开工踩坑。</description>
      <content:encoded><![CDATA[<p>训练大语言模型时，资源消耗可以直接转换成时间和成本的 所以需要资源核算</p>
<p>FLOPs(Floating Point Operations, 浮点运算次数) 衡量计算复杂度的一个指标，表示一个算法或者模型在执行过程中所需的浮点运算的总次数</p>
<p>经验公式:</p>
<blockquote>
<p>总计算量 ≈  6 ✖️ 参数量 ✖️ Token数量</p>
</blockquote>
<p>6:  fowrad 计算一次约为 2 ✖️ 参数量，backward 约等于前向的2倍，也就是 4 ✖️参数量</p>
<p>时间计算公式:</p>
<blockquote>
<p>时间 = 总工作量 / 总算力</p>
</blockquote>
<p>硬件算力可以查，H100 峰值算力约 1979TFLOPS （FP16/BP16数据类型，且启用结构化稀疏）
训练普通的稠密模型 理论峰值减半 约990 TFLOPs</p>
<p>结构化稀疏: 一种模型压缩的方法，通常是对稠密模型按照50%的稀疏度进行剪纸
<img alt="结构化稀疏：对稠密模型按 50% 稀疏度剪枝" loading="lazy" src="https://blog.lvxinrong.com/llm/llm-11-structured-sparsity.png"></p>
<p>软硬件开销系数 (通常按照 30% ~ 60% 利用率估算更现实)</p>
<p>所以  <strong>在 1024 张 H100 显卡上，训练一个 70B（700亿参数）的模型，数据量是 15T（15万亿 tokens），大概要多久？</strong></p>
$$
\text{时间} = \frac{\text{总工作量}}{\text{总算力}} = \frac{6.3 \times 10^{24}}{5 \times 10^{17}} \approx 1.26 \times 10^7 \text{ 秒} \approx \mathbf{146} \text{ 天}
$$<p><strong>FP16</strong> 和 <strong>BF16</strong> 都是计算机中用于表示小数的<strong>浮点数数据类型</strong>，它们在<strong>深度学习</strong>（AI 模型训练和推理）中被广泛使用。它们的主要目的是<strong>减少内存占用</strong>并<strong>加速计算</strong>（因为占用空间比传统的 FP32 少一半）
FP16 (Half Precision / 半精度浮点数) 精度高 但表示范围小
BF16 (Bfloat16 / 脑浮点数) 精度低 但表示范围极大</p>
<blockquote>
<p>Percy 在课上解释说：“bf16 牺牲了精度来换取范围。对于深度学习来说，范围比精度重要得多，因为数值稳定性的主要威胁是溢出/下溢，而不是尾数精度不够。”</p>
</blockquote>
<p>内存估算
需要同时考虑 参数，梯度，优化器状态(不同优化器 参数量不同)</p>
<h1 id="张量-pytorchtensor">张量 pytorch.tensor</h1>
<p><code>jaxtyping</code> 提供的维度命名（如 “batch seq hidden”）在当前 PyTorch 生态中主要是“文档性质”的，不会在运行时自动强制检查维度是否真的匹配名称，但它能极大地提升代码的清晰度和可靠性。</p>
<pre tabindex="0"><code># 传统方式（容易写错维度顺序）
x = torch.ones(2, 2, 1, 3)  # batch seq heads hidden

# Jaxtyping方式（在类型注解中命名维度）
from jaxtyping import Float
x: Float[torch.Tensor, &#34;batch seq heads hidden&#34;] = torch.ones(2, 2, 1, 3)
</code></pre><p>使用 Einops 库对张量操作进行优化: Einops增加了少量语法开销，但其清晰的维度命名显著降低了调试难度，特别是在复杂的模型架构中
这个后续学习 记个待办</p>
<ul>
<li><strong>FLOPs</strong>（小写s）：执行的浮点运算总数，这是一个衡量计算量的指标，</li>
<li><strong>FLOP/s</strong>（每秒浮点运算）：指硬件每秒能执行的浮点运算次数，也写作 <strong>FLOPS</strong>（大写S）。这是一个衡量“速度”的指标。例如，H100 GPU峰值性能为 990 TFLOP/s。</li>
</ul>
<p>对比矩阵乘法 A (m×k) @ B (k×n) 的 FLOPs = 2 × m × k × n。当 k 较大时（如 k = 1024），矩阵乘法的 FLOPs 是加法的上千倍。对于现代深度学习模型（尤其是 Transformer、MLP 等），90%+ 的 FLOPs 来自矩阵乘法（线性层、QKV 投影、FFN 等）。其他操作（LayerNorm、Softmax、激活函数、加法残差连接等）虽然存在，但 FLOPs 可忽略不计。因此，<strong>在进行粗略但有效的资源估算时，只需计算所有矩阵乘法的 FLOPs 总和即可</strong>。</p>
<p>调用 loss.backward() 后，PyTorch 会从 loss 开始，沿着计算图回溯，自动计算出每个需要梯度的张量的梯度。</p>
<p>一个普适性的结论：在深度学习中，<strong>训练一次（前向+反向）的总 FLOPs 约等于 6 倍的“数据点数量 × 参数数量”</strong></p>
<p>在每次迭代开始前，需要清空上一次计算得到的梯度，否则梯度会累积。优化器在调用 <code>zero_grad</code> 函数清空梯度时，设置 set_to_none=True 是一种更高效的内存管理方式，它会将梯度指针设为 None，而不是将其置零，可以节省内存。</p>
<pre tabindex="0"><code>optimizer.zero_grad(set_to_none=True)
</code></pre><h3 id="检查点checkpointing"> 检查点（Checkpointing）</h3>
<p>大型语言模型的训练耗时极长，过程中几乎不可避免地会发生崩溃或中断，我们需要一种机制来保存进度，以便在中断后能够从中断点恢复，而不是从头开始</p>
<p>检查点需要包含两块，模型参数 和 优化器状态</p>
<blockquote>
<p>为了能够完整地恢复训练，检查点必须包含所有必要的状态信息。主要包括两个核心部分：</p>
<ul>
<li>模型参数：这是模型的核心，包含了所有可学习权重（nn.Parameter）的当前值。通过 model.state_dict() 可以获取一个字典，其中键是参数名称，值是对应的张量数据。
-优化器状态 (optimizer.state_dict())：这是很多人容易忽略但极其关键的部分。优化器（如 Adam、AdaGrad）不仅存储了当前的学习率，还维护着一些内部状态变量。
例如: 如果只保存了模型参数而没有保存优化器状态，那么在恢复训练时，优化器会从零开始，这会导致训练过程不连续，性能下降，甚至可能无法收敛。</li>
</ul>
</blockquote>
<p>checkpoint 保存检查点</p>
<pre tabindex="0"><code># 1. 创建一个字典，包含模型和优化器的状态
checkpoint = {
    &#34;model&#34;: model.state_dict(),
    &#34;optimizer&#34;: optimizer.state_dict(),
}

# 2. 使用 torch.save 将字典序列化并保存到磁盘文件
torch.save(checkpoint, &#34;model_checkpoint.pt&#34;) # 文件名通常使用 .pt 或 .pth 后缀
</code></pre><p>加载也需要两部分同时加载:</p>
<pre tabindex="0"><code># 1. 从磁盘文件加载保存的字典
loaded_checkpoint = torch.load(&#34;model_checkpoint.pt&#34;)

# 2. （后续步骤）将状态加载回模型和优化器
model.load_state_dict(loaded_checkpoint[&#34;model&#34;])
optimizer.load_state_dict(loaded_checkpoint[&#34;optimizer&#34;])
</code></pre><h3 id="混合精度训练-mixed-precision">混合精度训练 (Mixed Precision)</h3>
<p>将低精度(BF16/ FP 16) 用于消耗大但对精度要求不高的部分(激活值)。将高精度用于 对精度敏感的部分(参数和梯度)</p>
<p>PyTorch 的 AMP 库 (Automatic Mixed Precision)：PyTorch 提供了自动混合精度（AMP）库，会自动将安全的操作（如矩阵乘法）转为 bf16，将危险操作（如 exp、softmax）保留为 fp32：</p>
<pre tabindex="0"><code>with torch.amp.autocast(&#34;cuda&#34;, dtype=torch.bfloat16):
    x = torch.zeros(4, 8)  # 自动以 bf16 创建
</code></pre><p>数据搬运也是需要时间，所以总时间取决于 加速器速度FLOP/s 和 内存带宽Bytes/s</p>
<h3 id="算术强度">算术强度</h3>
<p>为了避免每次都要计算两个时间再比较，引入<strong>算术强度（Arithmetic Intensity）</strong>：</p>
<blockquote>
<p>加速器强度 = FLOP/s / Bytes/s   H100 约295FLOP/bytes
算数强度 = FLOPs / Bytes  该操作每搬运1字节能做多少FLOP</p>
</blockquote>
<p>算数强度 &lt; 加速器强度  Memory-bound 瓶颈在数据传输
算数强度 &gt; 加速器强度  Compute-bound 瓶颈在计算</p>
<p>python中 列表的append()和extend 都是原地修改列表。
<code>append(x)</code>：把 <code>x</code> 当作<strong>一个整体元素</strong>加到末尾</p>
<pre tabindex="0"><code>a = [1, 2]
a.append([3, 4])
print(a)  # [1, 2, [3, 4]]
</code></pre><p><code>extend(iterable)</code>：把可迭代对象里的元素<strong>逐个拆开</strong>加到末尾</p>
<pre tabindex="0"><code>a = [1, 2]
a.extend([3, 4])
print(a)  # [1, 2, 3, 4]
</code></pre><p><code>extend</code> 接收的是可迭代对象，比如列表、元组、字符串、集合等</p>
<h2 id="今天的坑m2-开工实录">今天的坑（M2 开工实录）</h2>
<h3 id="梯度累积三次-backward-一次-step">梯度累积：三次 backward 一次 step</h3>
<p>一开始写成了“把所有 loss 攒进 list，最后一次 backward”——这样所有计算图都攒在手里，显存越攒越大，完全背离了梯度累积的初衷。正确姿势是<strong>每个小批立刻 backward（释放计算图），梯度累加在 .grad 里，攒够 N 批再 optimizer.step()</strong>。
归一化也有两种等价写法：<code>sum(loss_i)/N</code> 和每个 <code>loss_i/N</code> 再 backward，因为梯度是线性的，结果一样，但后者省显存。
触发条件用 <code>(i+1) % accum_step == 0</code> 一个表达式通吃，不用给 accum_step=1 单写分支。</p>
<h3 id="zero_grad-的位置决定成败">zero_grad 的位置决定成败</h3>
<p>原来的老代码在循环顶部 zero_grad()，改成累积模式后如果还留着，<strong>前几批攒下的梯度还没 step 就被清掉了</strong>，累积直接白干。口诀：<strong>梯度只在“用掉之后”清零（step 之后），不能在“攒的过程中”清零。</strong></p>
<h3 id="gitignore-的目录匹配会误伤">.gitignore 的目录匹配会误伤</h3>
<p>写 <code>data/</code> 会匹配<strong>所有层级</strong>的 data 目录，把 <code>src/squid/data/</code> 代码包也忽略了（新文件变灰、git status 看不到）。要只排除根目录的语料目录，必须写 <code>/data/</code>（前导斜杠锚定根目录）。</p>
<h3 id="total_loss-是-list-不是张量">total_loss 是 list 不是张量</h3>
<p><code>total_loss / accum_step</code> 会炸，因为 list 不能除以整数；而且把 loss 存进 list 不 backward，等于把计算图全留着。loss 是张量，应该当批归一化后立刻 backward，不是攒起来。</p>
<h2 id="bpb-的含义与下降意味着什么">BPB 的含义与“下降意味着什么”</h2>
<p><strong>BPB（Bits Per Byte）的本质是衡量语言模型把文本压缩了多少：给这段文本编码，平均每个字节要花多少比特。数值越低，说明模型对文本的预测能力越强，压缩效率越高。</strong></p>
<p>两个参照点帮助记忆：</p>
<ul>
<li>BPB 接近 0：模型几乎能完美预测文本，每个字节只需极少比特</li>
<li>BPB = 8：完全不会预测，每个字节都得老老实实存 8 bit，等于没有压缩</li>
</ul>
<p>所以 <strong>BPB 下降 = 模型用更少的比特就能编码同样的文本 = 模型在变好</strong>。它和 val_loss 下降的区别是：val_loss 是“每个 token 的预测难度”，BPB 把它折算成了“每个字节的成本”——这样不同词表、不同模型之间才能公平比较。</p>
<h2 id="容量与深度扫描数据决定上限">容量与深度扫描：数据决定上限</h2>
<p>M2 最小闭环之后，用同一批语料、同一训练量做了容量与深度对照，结论比配置本身值钱。</p>
<h3 id="emb_dim-扫描20-epoch其他锁死">emb_dim 扫描（20 epoch，其他锁死）</h3>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>emb_dim</th>
        <th>最终 val_loss</th>
        <th>BPB</th>
        <th>结论</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>64</td>
        <td>7.02</td>
        <td>3.63</td>
        <td>容量不足</td>
      </tr>
      <tr>
        <td>128</td>
        <td>6.59</td>
        <td>3.42</td>
        <td>仍在受益</td>
      </tr>
      <tr>
        <td><strong>256</strong></td>
        <td><strong>5.99</strong></td>
        <td><strong>3.10</strong></td>
        <td><strong>甜点</strong></td>
      </tr>
      <tr>
        <td>512</td>
        <td>6.26（过拟合）</td>
        <td>3.24</td>
        <td>开始背语料</td>
      </tr>
    </tbody>
  </table>
</div>
<p>512 出现了教科书式的过拟合：<strong>train_loss 一路降到 1.8，val_loss 却从 5.85 回升到 6.29</strong>——模型在背训练集，不是在学规律。所以容量甜点在 256 附近：64 欠拟合、512 过拟合。</p>
<p>验证代码:</p>
<pre tabindex="0"><code>&#34;&#34;&#34;M2 收官：真实语料 + 自训 BPE 的完整预训练。  
  
链路：pack_tokens 打包 → create_stream_loader → 小 GPT 预训练  
      → bpb 曲线 → generate_text 咿呀学语 → save_checkpoint 带 config。  
&#34;&#34;&#34;  
import math  
from pathlib import Path  
  
import torch  
  
from squid.data.token_stream import pack_tokens, create_stream_loader  
from squid.device import get_device  
from squid.generate.text import generate_text  
from squid.model.gpt import GPTModel  
from squid.train.common import calc_loss_loader  
from squid.train.pretrain import pretrain_model  
from squid.tokenizer.my_bpe_tokenizer import MyBPETokenizer  
from squid.checkpoints.store import save_checkpoint  
  
ROOT = Path(__file__).resolve().parents[1]  
DATA = ROOT / &#34;data&#34; / &#34;blog&#34;  
  
  
def test_m2_pretrain():  
    device = get_device()  
    tokenizer = MyBPETokenizer.from_directory(DATA / &#34;m2000&#34;)  
  
    # 1. token 流打包：训练语料与 held-out 分别打包  
    train_text = (DATA / &#34;train.txt&#34;).read_text(encoding=&#34;utf-8&#34;)  
    val_text = &#34;\n&#34;.join(p.read_text(encoding=&#34;utf-8&#34;) for p in DATA.glob(&#34;heldout-*.txt&#34;))  
  
    train_ids = pack_tokens([train_text], tokenizer, tokenizer.eos_id)  
    val_ids = pack_tokens([val_text], tokenizer, tokenizer.eos_id)  
  
    context = 128  
    train_loader = create_stream_loader(train_ids, context, batch_size=8, shuffle=True)  
    val_loader = create_stream_loader(val_ids, context, batch_size=8,  
                                      shuffle=False, drop_last=False)  
  
    # 2. 小模型：emb_dim 64、2 层、context 128  
    cfg = {  
        &#34;vocab_size&#34;: len(tokenizer.vocab),  
        &#34;context_length&#34;: context,  
        &#34;emb_dim&#34;: 256,  
        &#34;n_heads&#34;: 2,  
        &#34;n_layers&#34;: 4,  
        &#34;drop_rate&#34;: 0.0,  
        &#34;qkv_bias&#34;: False,  
    }  
    model = GPTModel(cfg).to(device)  
    optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4)  
  
    # 3. 预训练：accum_step=4，bpb 用 held-out 的 bytes/token 折算  
    density = len(val_text.encode(&#34;utf-8&#34;)) / len(tokenizer.encode(val_text))  
    train_losses, val_losses, tokens_seen = pretrain_model(  
        model, train_loader, val_loader, optimizer, device,  
        num_epochs=20, eval_freq=50, eval_iter=5,  
        accum_step=4, bpb_density=density,  
    )  
    assert val_losses[-1] &lt; val_losses[0], &#34;val loss 应该下降&#34;  
  
    # 4. 咿呀学语：给模型一个开头，看它续什么  
    sample = generate_text(model, tokenizer, &#34;大模型&#34;,  
                           max_new_tokens=40, context_size=context,  
                           temperature=0.8, top_k=20, eos_id=tokenizer.eos_id)  
    print(&#34;\n=== 生成样例 ===\n&#34;, sample)  
  
    # 5. 存档：权重 + config + 元信息，完整还原训练现场  
    final_val = calc_loss_loader(val_loader, model, device)  
    save_checkpoint(ROOT / &#34;regression&#34; / &#34;m2-pretrain.pth&#34;,  
                    model, cfg, val_loss=final_val, merges=2000, tokens_seen=tokens_seen[-1])  
    print(f&#34;\n最终 val_loss={final_val:.3f}，checkpoint 已保存&#34;)
</code></pre><h3 id="n_layers-对照emb_dim256">n_layers 对照（emb_dim=256）</h3>
<p>4 层和 2 层基本持平（val_loss 6.03 vs 5.99），深度没有收益，后段 val 还开始上翘。最优配置停在 <strong>emb_dim=256、n_layers=2</strong>。</p>
<p>一句话总结：<strong>小数据面前，模型不是越大越好，是“配得上”才好。</strong> 压缩率有甜点、BPB 有甜点、模型容量也有甜点——全是测出来的，不是猜的。</p>
<h2 id="两个收尾的-bug">两个收尾的 bug</h2>
<p><strong>accum_step 大于每轮批次数</strong>：每 epoch 只有 4 个 batch，accum_step=5 时 <code>(i+1) % 5 == 0</code> 永远不成立，optimizer.step() 一次都不执行，模型完全不学。改成跨 epoch 的 global_step 连续计数才解决。以后看到 loss 完全不动，先查 step 到底执行了没有。</p>
<p><strong>decode 的 UnicodeDecodeError</strong>：字节级 BPE 的 token 可能只是半个汉字，模型自由生成的序列不一定是合法 UTF-8，直接 decode 会炸。改成 <code>decode(&quot;utf-8&quot;, errors=&quot;replace&quot;)</code>，非法片段显示为替换符即可——tiktoken 默认就是这么干的。</p>
]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 10：手写 BPE，从写不出来到甜点区</title>
      <link>https://blog.lvxinrong.com/llm/llm-10-handwritten-bpe/</link>
      <pubDate>Tue, 27 Oct 2026 18:00:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-10-handwritten-bpe/</guid>
      <description>纯 Python 手写 BPE 训练与编解码，封装成 SquidTokenizer；再用压缩率曲线和小模型 BPB 实验，找到博客语料的甜点区 4000 次合并。</description>
      <content:encoded><![CDATA[<p>上一章遗留的作业：在 <code>squid/tokenizer/bpe.py</code> 里实现三个函数：<code>train_bpe</code>（学合并表）、<code>encode</code>（按表切分）、<code>decode</code>（还原）。先小语料跑通往返，再上博客语料测压缩率。</p>
<p>说实话，开工前我觉得自己写不出来。但拆成小函数之后，一个一个都拿下了。</p>
<h2 id="三个零件">三个零件</h2>
<p><strong>count_pairs</strong>：用滑动窗口把 i 和 i+1 的 id 配成 key，统计每个 key 出现的次数。</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">count_pairs</span><span class="p">(</span><span class="n">ids</span><span class="p">:</span> <span class="nb">list</span><span class="p">[</span><span class="nb">int</span><span class="p">])</span> <span class="o">-&gt;</span> <span class="nb">dict</span><span class="p">[</span><span class="nb">tuple</span><span class="p">[</span><span class="nb">int</span><span class="p">,</span> <span class="nb">int</span><span class="p">],</span> <span class="nb">int</span><span class="p">]:</span>
</span></span><span class="line"><span class="cl">    <span class="n">counts</span> <span class="o">=</span> <span class="p">{}</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">(</span><span class="n">ids</span><span class="p">,</span> <span class="n">ids</span><span class="p">[</span><span class="mi">1</span><span class="p">:]):</span>
</span></span><span class="line"><span class="cl">        <span class="n">key</span> <span class="o">=</span> <span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="n">key</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">counts</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="n">counts</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="mi">1</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">counts</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">+=</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">counts</span>
</span></span></code></pre></div><p><strong>merge</strong>：把 ids 里所有出现过的 pair 替换成新 id。比如 pair=(1,2)、ids=[1,2,1,2,3,4,5]、new_id=9，结果就是 <code>[9, 9, 3, 4, 5]</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="k">def</span> <span class="nf">merge</span><span class="p">(</span><span class="n">ids</span><span class="p">:</span> <span class="nb">list</span><span class="p">[</span><span class="nb">int</span><span class="p">],</span> <span class="n">pair</span><span class="p">:</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">int</span><span class="p">,</span> <span class="nb">int</span><span class="p">],</span> <span class="n">new_id</span><span class="p">:</span> <span class="nb">int</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">list</span><span class="p">[</span><span class="nb">int</span><span class="p">]:</span>
</span></span><span class="line"><span class="cl">    <span class="n">new_idx</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">    <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl">    <span class="k">while</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="nb">len</span><span class="p">(</span><span class="n">ids</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="nb">len</span><span class="p">(</span><span class="n">ids</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span> <span class="ow">and</span> <span class="p">(</span><span class="n">ids</span><span class="p">[</span><span class="n">i</span><span class="p">],</span> <span class="n">ids</span><span class="p">[</span><span class="n">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">])</span> <span class="o">==</span> <span class="n">pair</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="n">new_idx</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">new_id</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">            <span class="n">i</span> <span class="o">=</span> <span class="n">i</span> <span class="o">+</span> <span class="mi">2</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">new_idx</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">ids</span><span class="p">[</span><span class="n">i</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">            <span class="n">i</span> <span class="o">=</span> <span class="n">i</span> <span class="o">+</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">new_idx</span>
</span></span></code></pre></div><p>这里有个容易写错的点：统计是滑动窗口（允许重叠），替换是贪心扫描（命中消费两格，不匹配消费一格）。所以用 while 手动控制步长，for i in range 里修改 i 下一轮会被覆盖。</p>
<p><strong>train_bpe</strong>：vocab 初始 256 项（所有单字节），每轮取 count_pairs 里 value 最大的 key 合并，新 id 从 256 开始累加。</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">train_bpe</span><span class="p">(</span><span class="n">text</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">num_merges</span><span class="p">:</span> <span class="nb">int</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">ids</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">text</span><span class="o">.</span><span class="n">encode</span><span class="p">(</span><span class="s2">&#34;utf-8&#34;</span><span class="p">))</span>
</span></span><span class="line"><span class="cl">    <span class="n">vocab</span> <span class="o">=</span> <span class="p">{</span><span class="n">i</span><span class="p">:</span> <span class="nb">bytes</span><span class="p">([</span><span class="n">i</span><span class="p">])</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">256</span><span class="p">)}</span>
</span></span><span class="line"><span class="cl">    <span class="n">merges</span> <span class="o">=</span> <span class="p">{}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="n">_</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">num_merges</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">        <span class="n">counts</span> <span class="o">=</span> <span class="n">count_pairs</span><span class="p">(</span><span class="n">ids</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="ow">not</span> <span class="n">counts</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="k">break</span>
</span></span><span class="line"><span class="cl">        <span class="n">best</span> <span class="o">=</span> <span class="nb">max</span><span class="p">(</span><span class="n">counts</span><span class="p">,</span> <span class="n">key</span><span class="o">=</span><span class="n">counts</span><span class="o">.</span><span class="n">get</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="n">new_id</span> <span class="o">=</span> <span class="mi">256</span> <span class="o">+</span> <span class="nb">len</span><span class="p">(</span><span class="n">merges</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="n">ids</span> <span class="o">=</span> <span class="n">merge</span><span class="p">(</span><span class="n">ids</span><span class="p">,</span> <span class="n">best</span><span class="p">,</span> <span class="n">new_id</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="n">merges</span><span class="p">[</span><span class="n">best</span><span class="p">]</span> <span class="o">=</span> <span class="n">new_id</span>
</span></span><span class="line"><span class="cl">        <span class="n">vocab</span><span class="p">[</span><span class="n">new_id</span><span class="p">]</span> <span class="o">=</span> <span class="n">vocab</span><span class="p">[</span><span class="n">best</span><span class="p">[</span><span class="mi">0</span><span class="p">]]</span> <span class="o">+</span> <span class="n">vocab</span><span class="p">[</span><span class="n">best</span><span class="p">[</span><span class="mi">1</span><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">vocab</span><span class="p">,</span> <span class="n">merges</span>
</span></span></code></pre></div><p>注意最后一行：best 里装的是 id 不是字符，要先查 vocab 取出 bytes 再拼接，不能直接 <code>best[0] + best[1]</code>（那是两个整数相加）。</p>
<h2 id="encode--decode-与往返无损">encode / decode 与往返无损</h2>
<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">decode</span><span class="p">(</span><span class="n">ids</span><span class="p">:</span> <span class="nb">list</span><span class="p">[</span><span class="nb">int</span><span class="p">],</span> <span class="n">vocab</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="sa">b</span><span class="s2">&#34;&#34;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">vocab</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">ids</span><span class="p">)</span><span class="o">.</span><span class="n">decode</span><span class="p">(</span><span class="s2">&#34;utf-8&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">encode</span><span class="p">(</span><span class="n">text</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">merges</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">list</span><span class="p">[</span><span class="nb">int</span><span class="p">]:</span>
</span></span><span class="line"><span class="cl">    <span class="n">ids</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">text</span><span class="o">.</span><span class="n">encode</span><span class="p">(</span><span class="s2">&#34;utf-8&#34;</span><span class="p">))</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="n">pair</span><span class="p">,</span> <span class="n">new_id</span> <span class="ow">in</span> <span class="n">merges</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
</span></span><span class="line"><span class="cl">        <span class="n">ids</span> <span class="o">=</span> <span class="n">merge</span><span class="p">(</span><span class="n">ids</span><span class="p">,</span> <span class="n">pair</span><span class="p">,</span> <span class="n">new_id</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">ids</span>
</span></span></code></pre></div><p>decode 是查词表把 ids 还原成文本，必须先在 bytes 世界拼完整再 decode，不然中文多字节字符会被切碎。encode 是把训练学到的合并规则<strong>按学习顺序</strong>在新文本上重放一遍——merges 存的是规则不是结果，不重放，新 token 不会出现。</p>
<p>往返验收过了：<code>decode(encode(text, merges), vocab) == text</code>。</p>
<p>Python 里 bytes 和 str 的转换我目前还不熟，记入欠账，后面找机会补。</p>
<h2 id="封装成-squidtokenizer">封装成 SquidTokenizer</h2>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">class</span> <span class="nc">MyBPETokenizer</span><span class="p">(</span><span class="n">SquidTokenizer</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">def</span> <span class="fm">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">vocab</span><span class="p">,</span> <span class="n">merges</span><span class="p">,</span> <span class="n">eos_id</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">vocab</span> <span class="o">=</span> <span class="n">vocab</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">merges</span> <span class="o">=</span> <span class="n">merges</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">_eos_id</span> <span class="o">=</span> <span class="n">eos_id</span> <span class="k">if</span> <span class="n">eos_id</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span> <span class="k">else</span> <span class="nb">len</span><span class="p">(</span><span class="n">vocab</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="bp">self</span><span class="o">.</span><span class="n">vocab</span><span class="o">.</span><span class="n">setdefault</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_eos_id</span><span class="p">,</span> <span class="sa">b</span><span class="s2">&#34;&lt;|endoftext|&gt;&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">def</span> <span class="nf">encode</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">text</span><span class="p">:</span> <span class="nb">str</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">list</span><span class="p">[</span><span class="nb">int</span><span class="p">]:</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">bpe</span><span class="o">.</span><span class="n">encode</span><span class="p">(</span><span class="n">text</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">merges</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">def</span> <span class="nf">decode</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">idx</span><span class="p">:</span> <span class="nb">list</span><span class="p">[</span><span class="nb">int</span><span class="p">])</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">bpe</span><span class="o">.</span><span class="n">decode</span><span class="p">(</span><span class="n">idx</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">vocab</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="nd">@classmethod</span>
</span></span><span class="line"><span class="cl">    <span class="k">def</span> <span class="nf">from_directory</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">path</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">        <span class="n">vocab</span><span class="p">,</span> <span class="n">merges</span> <span class="o">=</span> <span class="n">bpe</span><span class="o">.</span><span class="n">load_bpe</span><span class="p">(</span><span class="n">path</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="bp">cls</span><span class="p">(</span><span class="n">vocab</span><span class="p">,</span> <span class="n">merges</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="nd">@property</span>
</span></span><span class="line"><span class="cl">    <span class="k">def</span> <span class="nf">eos_id</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">int</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_eos_id</span>
</span></span></code></pre></div><p>这段学到的 Python 点：</p>
<ol>
<li>三元表达式是 <code>值A if 条件 else 值B</code>，所以 eos_id 那行就是“传了用传入的，没传用词表大小”</li>
<li><code>@classmethod</code> 是挂在类上的方法，类似 Java 静态工厂。<code>cls(vocab, merges)</code> 就是调用 <code>__init__</code>，但比 Java static 多一层：cls 是类本身，子类调用返回子类实例</li>
<li><code>@property</code> 把方法伪装成属性，访问不用加括号</li>
<li><code>self._*</code> 下划线只是约定，不是 private，依然能访问</li>
</ol>
<h2 id="实验一压缩率曲线与甜点区">实验一：压缩率曲线与甜点区</h2>
<p>分别训练了 [64, 128, 256, 512, 1024, 2000, 4000, 8000, 16000] 次的词表，在 held-out 文本上测压缩率（<code>len(text.encode(&quot;utf-8&quot;)) / len(tokenizer.encode(text))</code>，即 bytes/token，越高越省）：</p>
<pre tabindex="0"><code>merges=   64  tokens=10588  bytes/token=1.29
merges=  128  tokens= 9631  bytes/token=1.42
merges=  256  tokens= 8346  bytes/token=1.64
merges=  512  tokens= 7009  bytes/token=1.95
merges= 1024  tokens= 5944  bytes/token=2.30
merges= 2000  tokens= 5043  bytes/token=2.71
merges= 4000  tokens= 4287  bytes/token=3.19
merges= 8000  tokens= 3869  bytes/token=3.54
merges=16000  tokens= 3704  bytes/token=3.69
</code></pre><p>token 数一直在降，bytes/token 一直在涨，但<strong>看每次翻倍的收益</strong>：前期稳定 +17% 左右，4000→8000 掉到 +11%，8000→16000 只剩 +4%。<strong>甜点区在 4000-8000</strong>，再往后基本是在背语料。</p>
<p>直观例子：手机号最好学成 3-4-4 的片段，merges 一直增大就会学成整个 11 位号码——每个号码独一无二，embedding 永远学不到，模型也无法对号码内部做推理。所以并不是 merges 越多越好，每个 token 携带的信息越大，模型训练时也需要更强的能力去掌握它。</p>
<p>另一个好玩的发现：512 次合并时“大模型”还排不上号（语料里只出现 31 次），2000 次之后它终于“拥有姓名”，被切成了一个完整 token。<strong>词表大小决定了多低频的词才配拥有姓名。</strong></p>
<h2 id="实验二bpb把模型拉上一起评">实验二：BPB，把模型拉上一起评</h2>
<p>和 DeepSeek 讨论后确认：评估分词器不能只看 bytes/token，那只是在评分词器本身，还得看“模型+词表”的整体效果。这个指标叫 <strong>BPB（Bits Per Byte）</strong>：</p>
<pre tabindex="0"><code>BPB = (val_loss / ln2) ÷ bytes/token
</code></pre><p>含义：<strong>给这段文本编码，平均每个字节要花多少比特</strong>。val_loss 是模型每预测一个 token 的代价（nats），除以 ln2 换成比特；再除以 bytes/token，就把“每个 token 的成本”折算成“每个字节的成本”。<strong>越低越好</strong>——它同时惩罚两种情况：词表太碎（bytes/token 小）和模型没学好（val_loss 高）。</p>
<h3 id="实验设计">实验设计</h3>
<p>四组：512 / 2000 / 4000 / 8000，同一个微型模型配置（emb_dim=64、n_layers=2、context=128），同一份 train/held-out 文本，只换分词器。</p>
<p><strong>一个关键的控制变量：统一步数，不是统一 epoch。</strong> 因为词表越大，同样文本的 ids 越短，定长窗口切出的窗口数越少，每 epoch 的训练步数也越少：</p>
<pre tabindex="0"><code>窗口数 = (len(ids) - max_length) / stride
每 epoch 步数 = 窗口数 / batch_size
</code></pre><p>如果只统一 epoch，大词表模型等于“饿着肚子考试”。所以给 <code>pretrain_model</code> 加了 <code>max_steps</code> 参数，四组都固定走 500 步。</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="kn">import</span> <span class="nn">math</span>
</span></span><span class="line"><span class="cl"><span class="kn">from</span> <span class="nn">pathlib</span> <span class="kn">import</span> <span class="n">Path</span>
</span></span><span class="line"><span class="cl"><span class="kn">import</span> <span class="nn">torch</span>
</span></span><span class="line"><span class="cl"><span class="kn">from</span> <span class="nn">squid.data.pretrain</span> <span class="kn">import</span> <span class="n">create_pretrain_loader</span>
</span></span><span class="line"><span class="cl"><span class="kn">from</span> <span class="nn">squid.device</span> <span class="kn">import</span> <span class="n">get_device</span>
</span></span><span class="line"><span class="cl"><span class="kn">from</span> <span class="nn">squid.model.gpt</span> <span class="kn">import</span> <span class="n">GPTModel</span>
</span></span><span class="line"><span class="cl"><span class="kn">from</span> <span class="nn">squid.tokenizer.my_bpe_tokenizer</span> <span class="kn">import</span> <span class="n">MyBPETokenizer</span>
</span></span><span class="line"><span class="cl"><span class="kn">from</span> <span class="nn">squid.train.common</span> <span class="kn">import</span> <span class="n">calc_loss_loader</span>
</span></span><span class="line"><span class="cl"><span class="kn">from</span> <span class="nn">squid.train.pretrain</span> <span class="kn">import</span> <span class="n">pretrain_model</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">ROOT</span> <span class="o">=</span> <span class="n">Path</span><span class="p">(</span><span class="vm">__file__</span><span class="p">)</span><span class="o">.</span><span class="n">resolve</span><span class="p">()</span><span class="o">.</span><span class="n">parents</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="n">DATA</span> <span class="o">=</span> <span class="n">ROOT</span> <span class="o">/</span> <span class="s2">&#34;data&#34;</span> <span class="o">/</span> <span class="s2">&#34;blog&#34;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">train_model_with_nums_merge</span><span class="p">(</span><span class="n">num_merges</span><span class="p">:</span> <span class="nb">str</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">vocab_data</span> <span class="o">=</span> <span class="n">ROOT</span> <span class="o">/</span> <span class="s2">&#34;data&#34;</span> <span class="o">/</span> <span class="s2">&#34;blog&#34;</span> <span class="o">/</span> <span class="n">num_merges</span>
</span></span><span class="line"><span class="cl">    <span class="n">tokenizer</span> <span class="o">=</span> <span class="n">MyBPETokenizer</span><span class="o">.</span><span class="n">from_directory</span><span class="p">(</span><span class="n">vocab_data</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="n">cfg</span> <span class="o">=</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;vocab_size&#34;</span><span class="p">:</span> <span class="nb">len</span><span class="p">(</span><span class="n">tokenizer</span><span class="o">.</span><span class="n">vocab</span><span class="p">),</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;context_length&#34;</span><span class="p">:</span> <span class="mi">128</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;emb_dim&#34;</span><span class="p">:</span> <span class="mi">64</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;n_heads&#34;</span><span class="p">:</span> <span class="mi">2</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;n_layers&#34;</span><span class="p">:</span> <span class="mi">2</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;drop_rate&#34;</span><span class="p">:</span> <span class="mf">0.0</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;qkv_bias&#34;</span><span class="p">:</span> <span class="kc">False</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">device</span> <span class="o">=</span> <span class="n">get_device</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="n">model</span> <span class="o">=</span> <span class="n">GPTModel</span><span class="p">(</span><span class="n">cfg</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="n">model</span><span class="o">.</span><span class="n">to</span><span class="p">(</span><span class="n">device</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="n">train_text</span> <span class="o">=</span> <span class="nb">open</span><span class="p">(</span><span class="n">DATA</span> <span class="o">/</span> <span class="s2">&#34;train.txt&#34;</span><span class="p">,</span> <span class="n">encoding</span><span class="o">=</span><span class="s2">&#34;utf-8&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">read</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="n">val_text</span> <span class="o">=</span> <span class="nb">open</span><span class="p">(</span><span class="n">DATA</span> <span class="o">/</span> <span class="s2">&#34;heldout-手搓LLM笔记07-指令微调.txt&#34;</span><span class="p">,</span> <span class="n">encoding</span><span class="o">=</span><span class="s2">&#34;utf-8&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">read</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="n">val_text</span> <span class="o">=</span> <span class="n">val_text</span> <span class="o">+</span> <span class="s2">&#34;</span><span class="se">\n</span><span class="s2">&#34;</span> <span class="o">+</span> <span class="nb">open</span><span class="p">(</span><span class="n">DATA</span> <span class="o">/</span> <span class="s2">&#34;heldout-我想把家里的设备组成一个私人AI实验室.txt&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">                                      <span class="n">encoding</span><span class="o">=</span><span class="s2">&#34;utf-8&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">read</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="n">train_loader</span> <span class="o">=</span> <span class="n">create_pretrain_loader</span><span class="p">(</span><span class="n">train_text</span><span class="p">,</span> <span class="n">tokenizer</span><span class="p">,</span> <span class="mi">128</span><span class="p">,</span> <span class="mi">128</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">                                          <span class="n">batch_size</span><span class="o">=</span><span class="mi">8</span><span class="p">,</span> <span class="n">shuffle</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">val_loader</span> <span class="o">=</span> <span class="n">create_pretrain_loader</span><span class="p">(</span><span class="n">val_text</span><span class="p">,</span> <span class="n">tokenizer</span><span class="p">,</span> <span class="mi">128</span><span class="p">,</span> <span class="mi">128</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">                                        <span class="n">batch_size</span><span class="o">=</span><span class="mi">8</span><span class="p">,</span> <span class="n">shuffle</span><span class="o">=</span><span class="kc">False</span><span class="p">,</span> <span class="n">drop_last</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="n">optimizer</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">optim</span><span class="o">.</span><span class="n">AdamW</span><span class="p">(</span><span class="n">model</span><span class="o">.</span><span class="n">parameters</span><span class="p">())</span>
</span></span><span class="line"><span class="cl">    <span class="n">train_losses</span><span class="p">,</span> <span class="n">val_losses</span><span class="p">,</span> <span class="n">tokens_seen</span> <span class="o">=</span> <span class="n">pretrain_model</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="n">model</span><span class="o">=</span><span class="n">model</span><span class="p">,</span> <span class="n">train_loader</span><span class="o">=</span><span class="n">train_loader</span><span class="p">,</span> <span class="n">val_loader</span><span class="o">=</span><span class="n">val_loader</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="n">optimizer</span><span class="o">=</span><span class="n">optimizer</span><span class="p">,</span> <span class="n">device</span><span class="o">=</span><span class="n">device</span><span class="p">,</span> <span class="n">num_epochs</span><span class="o">=</span><span class="mi">100</span><span class="p">,</span> <span class="n">max_steps</span><span class="o">=</span><span class="mi">500</span><span class="p">,</span> <span class="n">eval_freq</span><span class="o">=</span><span class="mi">100</span><span class="p">,</span> <span class="n">eval_iter</span><span class="o">=</span><span class="mi">100</span>
</span></span><span class="line"><span class="cl">    <span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="n">val_loss</span> <span class="o">=</span> <span class="n">calc_loss_loader</span><span class="p">(</span><span class="n">val_loader</span><span class="p">,</span> <span class="n">model</span><span class="p">,</span> <span class="n">device</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="n">density</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">val_text</span><span class="o">.</span><span class="n">encode</span><span class="p">(</span><span class="s2">&#34;utf-8&#34;</span><span class="p">))</span> <span class="o">/</span> <span class="nb">len</span><span class="p">(</span><span class="n">tokenizer</span><span class="o">.</span><span class="n">encode</span><span class="p">(</span><span class="n">val_text</span><span class="p">))</span>
</span></span><span class="line"><span class="cl">    <span class="n">bpb</span> <span class="o">=</span> <span class="n">val_loss</span> <span class="o">/</span> <span class="n">math</span><span class="o">.</span><span class="n">log</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span> <span class="o">/</span> <span class="n">density</span>
</span></span><span class="line"><span class="cl">    <span class="nb">print</span><span class="p">(</span><span class="sa">f</span><span class="s2">&#34;val_loss=</span><span class="si">{</span><span class="n">val_loss</span><span class="si">:</span><span class="s2">.3f</span><span class="si">}</span><span class="s2">  bytes/token=</span><span class="si">{</span><span class="n">density</span><span class="si">:</span><span class="s2">.2f</span><span class="si">}</span><span class="s2">  BPB=</span><span class="si">{</span><span class="n">bpb</span><span class="si">:</span><span class="s2">.3f</span><span class="si">}</span><span class="s2">&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">if</span> <span class="vm">__name__</span> <span class="o">==</span> <span class="s1">&#39;__main__&#39;</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">    <span class="n">train_model_with_nums_merge</span><span class="p">(</span><span class="s2">&#34;m512&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="n">train_model_with_nums_merge</span><span class="p">(</span><span class="s2">&#34;m2000&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="n">train_model_with_nums_merge</span><span class="p">(</span><span class="s2">&#34;m4000&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="n">train_model_with_nums_merge</span><span class="p">(</span><span class="s2">&#34;m8000&#34;</span><span class="p">)</span>
</span></span></code></pre></div><h3 id="结果">结果</h3>
<pre tabindex="0"><code>m512 : val_loss=4.819  bytes/token=1.99  BPB=3.494
m2000: val_loss=6.551  bytes/token=2.80  BPB=3.373
m4000: val_loss=7.584  bytes/token=3.30  BPB=3.315
m8000: val_loss=8.378  bytes/token=3.66  BPB=3.300
</code></pre><p><strong>为什么 val_loss 一路涨？</strong> val_loss 是“每个 token 的预测难度”，词表变大之后，大量 token 在 117KB 语料里只出现几次，embedding 学不充分，预测它们接近靠蒙，困惑度自然上升。这不是词表变差，是“大 token 更难预测”的固有代价。</p>
<p><strong>但 BPB 在降</strong>——因为每个 token 装的字节更多了，折算回每字节成本反而便宜。而且看边际收益：512→2000 降 0.121，2000→4000 降 0.058，4000→8000 只降 0.015。<strong>BPB 的甜点同样在 4000 附近</strong>，和压缩率实验互相印证。</p>
<p>结论：<strong>val_loss 上升不等于词表不好，BPB 才是整体账；但 BPB 的边际收益也会递减，4000 之后再合并基本没红利。</strong></p>
<h2 id="bpe-的三个哲学点">BPE 的三个哲学点</h2>
<p>实验做完再回头看，BPE 的底层逻辑其实就三句话：</p>
<ol>
<li><strong>原子由数据决定。</strong> 什么是“思考的最小单位”，不是人预先规定的，是语料的统计分布决定的。代码语料出 <code>def</code>、<code>();</code>，中文博客语料出“模型”、“训练”——<strong>词表是语料的指纹</strong>，换语料就要重新训词表。</li>
<li><strong>频率决定谁先成为原子。</strong> BPE 每轮只合并最高频的相邻对，它只认频率，不认语义重要性。“大模型”再重要，出现 31 次也得往后排。</li>
<li><strong>预算决定多低频才配拥有姓名。</strong> 词表大小（合并次数）就是预算：高频组合早早拿到独立 token_id，低频组合要等预算够了才有机会。512 次时“大模型”没姓名，2000 次才有了。</li>
</ol>
<h2 id="工程收获">工程收获</h2>
<ul>
<li>训练产物（vocab/merges）用 JSON 存成中间文件（<code>save_bpe</code> / <code>load_bpe</code>），实验和训练可以分开重跑</li>
<li>不同配置分目录存（<code>data/blog/m512/</code>、<code>m2000/</code>……），不然实验产物互相覆盖，回头根本对不上号</li>
<li>路径用 <code>Path(__file__).resolve().parents[N]</code> 锚定，不再受 IDE 工作目录的摆布</li>
</ul>
<h2 id="欠账与下一步">欠账与下一步</h2>
<ul>
<li>Python 的 bytes/str、pathlib 这些基础用法还不熟，找时间补</li>
<li>M2 预训练：token 流打包、梯度累积、bpb 指标，这次 BPB 实验就是预习</li>
</ul>
<p><strong>一句话总结 M1：BPE 的目标不是把文本压到最短，是在压缩率、词表规模、可学习性、组合泛化之间找平衡。</strong></p>
]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 09：diy-llm 分支，从分词器开始</title>
      <link>https://blog.lvxinrong.com/llm/llm-09-diy-llm-tokenizer/</link>
      <pubDate>Tue, 27 Oct 2026 12:00:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-09-diy-llm-tokenizer/</guid>
      <description>手搓 LLM 开启第二条分支：从零构建大模型（已完结）之外，新增 diy-llm 理论线。M1 自训 BPE，先把分词器这张图看懂。</description>
      <content:encoded><![CDATA[<blockquote>
<p>手搓 LLM 系列从这篇起有两个分支：<strong>从零构建大模型</strong>（00-08，书已读完、代码已重写）和 <strong>diy-llm</strong>（CS336 中文本土化课程，理论线）。diy-llm 与 nanochat 作品线双轨并行，配套关系见 <a href="https://blog.lvxinrong.com/nanochat/lvchat-roadmap/">lvchat 实现导图</a> 和 <a href="https://blog.lvxinrong.com/diy-llm/diy-llm-proposal/">diy-llm 立项书</a>。</p>
</blockquote>
<h2 id="m1-的目标">M1 的目标</h2>
<p>在 squid-llms 里自己训一个 BPE 分词器，不调用 tiktoken。验收两条：</p>
<ol>
<li>编解码往返无损（encode 再 decode，原文一字不差）</li>
<li>压缩率可测（同样的语料，我的词表 vs GPT-2 词表，谁更省 token）</li>
</ol>
<p>配套阅读：diy-llm 第 2 章（分词器）；标准答案：nanochat 的 tokenizer.py。</p>
<h2 id="一张图看懂分词器的位置">一张图看懂分词器的位置</h2>
<p><img alt="分词器全链路：编码、模型、解码、自回归循环" loading="lazy" src="https://blog.lvxinrong.com/llm/llm-09-tokenizer-loop.png"></p>
<p>这张图值得收藏，因为它把分词器放回了完整链路里，而不是孤立地讲算法：</p>
<ul>
<li><strong>编码 = 切分 + 查表映射</strong>。文本先切成片段，再按词表（Vocabulary）映成 ID 序列。“我喜欢学习AI。” → <code>[15, 290, 3321, 56, 2]</code>。</li>
<li><strong>模型只看得懂数字 ID 序列</strong>。它不认识“我”也不认识“AI”，它看到的永远是 ID。词表就是人和模型之间的翻译官。</li>
<li><strong>模型产出的是下一个 Token ID</strong>，比如 <code>[109]</code>。</li>
<li><strong>解码 = ID 还原 + 文本重组</strong>。109 查表还原成“很”，再拼回文本。</li>
<li><strong>循环：新字加入输入，继续生成</strong>。这就是自回归——每一步都把上一步的输出接回输入。</li>
</ul>
<p>这一过程不仅是简单的编码转换，更隐含了模型对“世界的切分”策略：模型最终“看到”的基本单位，可能是字符、词，或更常见的子词片段。</p>
<p>分词器还是一个<strong>独立优化的模块</strong>：通常先在大规模文本上训练出词表，再固定下来供模型使用。它本身不让模型“理解”语言——理解能力是在后续 Transformer 训练中获得的——但更合理的切分会让输入分布更清晰一致，间接提升训练效率和最终性能。</p>
<h2 id="token-数量注意力的两笔账">token 数量：注意力的两笔账</h2>
<p><img alt="token 数量与注意力计算复杂度、上下文窗口占用的关系" loading="lazy" src="https://blog.lvxinrong.com/llm/llm-09-token-count-attention.png"></p>
<p>token 划分越碎（同样的文本 token 数越多），代价体现在两处：</p>
<ul>
<li><strong>计算复杂度呈平方增长</strong>：注意力要算 N×N 的分数矩阵，token 数翻倍，注意力计算量变四倍；</li>
<li><strong>上下文窗口被更快吃满</strong>：窗口容量是固定的 token 数，切得碎，同样长度能装下的实际内容就变少。</li>
</ul>
<p>这就是为什么“切得碎和太宽泛都不行”——碎有碎的代价，粗有粗的代价（词表爆炸、长尾稀疏、OOV）。</p>
<h2 id="分词粒度字符字节词bpe">分词粒度：字符、字节、词、BPE</h2>
<p><img alt="4 种分词器对比：粒度、词表大小、OOV、序列长度" loading="lazy" src="https://blog.lvxinrong.com/llm/llm-09-tokenizer-types.png"></p>
<p>最直观的是<strong>字符分词</strong>：把文本拆成最小字符单位（英文的字母、中文的单字）。</p>
<ul>
<li>优点：词表极小（英文 26 个字母+符号，中文几千常用字）；没有 OOV，任何生僻词都由基础字符组成。</li>
<li>缺点：序列过长，一句话长度翻数倍，吃上下文窗口和算力；单字符通常没有独立语义，模型要花更深的层数把意义拼回来。</li>
</ul>
<p><strong>BPE 的核心思想就是在字符级（太细）和词级（太粗）之间找平衡</strong>：统计语料中相邻字符对的出现频率，迭代地把最频繁的对合并成一个新 token。高频组合自动成词，低频组合保持拆开——数据驱动的压缩。</p>
<h2 id="算法家族速记">算法家族速记</h2>
<ul>
<li><strong>BPE</strong>：统计相邻对频次，每次贪心合并最高频的一对，迭代构建词表。决策只看频率统计。</li>
<li><strong>WordPiece</strong>：看合并对语言模型似然的贡献，选能显著提升语料拟合度的合并。</li>
<li><strong>Unigram</strong>：反过来，从一个过大的种子词表出发做减法，初始化每个 token 的概率再逐步裁剪。</li>
<li><strong>SentencePiece</strong>：不是某个具体算法，而是语言无关的子词分词框架，提供统一的训练与编码流程，BPE 和 Unigram 都能装在里面跑。</li>
</ul>
<h2 id="我想明白的三个点">我想明白的三个点</h2>
<p><strong>一、为什么自己训 BPE，而不是继续用 tiktoken。</strong> GPT-2 的词表是为英文互联网配的，喂中文和代码会把很多字拆成多个 byte token，同样的文本 token 数翻倍，训练和推理都更贵。自己训，词表才为自己的语料服务，词表大小也成为自己的旋钮。</p>
<p><strong>二、训练的产物不是模型，是一张合并表。</strong> BPE 训练就是反复统计“哪对相邻符号最频繁”，合并成新 token，记下轮次。有了合并表（mergeable_ranks），编码就是查表合并。nanochat 的做法印证了这个本质：训练用 rustbpe，推理把合并表交给 tiktoken——训练和编码是两个独立问题。</p>
<p><strong>三、编码最容易写错的地方是“按 rank 顺序应用合并”。</strong> 后学的合并依赖先学的，顺序乱了，编解码往返就无损不了。M1 的坑大概率会踩在这。</p>
<h2 id="第二章读完的四条心得">第二章读完的四条心得</h2>
<ol>
<li><strong>算法和框架是两个层次。</strong> BPE / WordPiece / Unigram 是算法，SentencePiece / tiktoken 是框架。DeepSeek 用的是 BBPE（字节级 BPE），属于 BPE 家族；“用 SentencePiece”推不出“不是 BPE”，因为框架里可以跑 BPE。</li>
<li><strong>BPE 是频次统计，不是概率模型。</strong> 只看“哪对相邻符号最频繁”。引入概率的是 WordPiece（似然贡献）和 Unigram（token 概率）。</li>
<li><strong>分词的好坏是压缩率与一致性的 trade-off。</strong> 过粗：词表爆炸、长尾稀疏、OOV 变多；过细：序列变长、语义被肢解。</li>
<li><strong>分词间接影响最终训练效果，路径有三条</strong>：序列长度（注意力 N²）、词表大小（输出层 emb_dim × vocab_size 的参数与计算）、语义完整性（太细则模型要花更多层把意义拼回来）。</li>
</ol>
<h2 id="接下来的动作">接下来的动作</h2>
<p>在 <code>squid/tokenizer/bpe.py</code> 里实现三个函数：<code>train_bpe</code>（学合并表）、<code>encode</code>（按表切分）、<code>decode</code>（还原）。先小语料跑通往返，再上博客语料测压缩率。顺手做个小实验：同一句“我喜欢学习AI”，两种词表各 encode 一次，对比切出来的片段谁更贴近语义单元。</p>
]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 08：重写 lvllm，按工程结构再串一遍</title>
      <link>https://blog.lvxinrong.com/llm/llm-08-rewrite-lvllm/</link>
      <pubDate>Mon, 26 Oct 2026 12:00:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-08-rewrite-lvllm/</guid>
      <description>终极回炉：不按章节收拢，按工程结构重写全书代码。data 三任务、train 分工、LoRA 接线、eval 评委链，最后用 23.6 vs 23.9 的回归收官。</description>
      <content:encoded><![CDATA[<blockquote>
<p>施工图是 <a href="https://blog.lvxinrong.com/nanochat/lvchat-roadmap/">lvchat 实现导图</a> 的 M0。10 月 20 日立项，10 月 26 日回归通过，本篇为收官正文。原始踩坑记录保留在文末「素材积累」。</p>
</blockquote>
<h2 id="为什么重写">为什么重写</h2>
<p>书读完的时候，我手里有一整个仓库的代码，但它们是按章节长的：ch03 一份、ch05 一份、ch07 一份，互相复制，配置散落，device 满天飞。能跑，但不是工程。</p>
<p>更关键的问题：这些代码是“跟着书写出来的”，合上书，我能不能按自己的结构重新组织一遍？这就是 M0 的由来——<strong>不按章节收拢，按工程结构重写</strong>。目标不是拥有一个新的仓库，是拥有“能写出这个仓库”的能力。</p>
<p>新仓库叫 squid-llms。军规两条：能手写就手写，AI 只当导航；每一处偏离书的设计，都要说得出理由。</p>
<h2 id="最后的结构">最后的结构</h2>
<pre tabindex="0"><code>src/squid/
├── config.py        # 单一配置入口
├── device.py        # 单一 device 入口
├── tokenizer/       # SquidTokenizer 协议 + tiktoken 实现
├── model/           # layers / gpt / lora
├── data/            # pretrain / classify / instruct + common
├── train/           # common / pretrain / classify / sft
├── generate/        # 纯 id 引擎 + 文本壳
├── eval/            # 批量生成 + DeepSeek 评委
└── checkpoints/     # 进口 / 自用 / 附加 三层
</code></pre><p>两个“单一入口”是最先定的：配置和 device 只有一个出处。后面所有层都不许自己造词表知识、自己判断设备——比如 pad_id 一律从 <code>tokenizer.eos_id</code> 进，不许写死 50256（GPT-2 ≠ Qwen，07-2 已经踩过）。</p>
<h2 id="data按任务分不按格式分">data：按任务分，不按格式分</h2>
<p>三种任务的数据组织方式根本不同，所以分三个文件：</p>
<ul>
<li><strong>pretrain</strong>：定长滑窗。<code>input = ids[i:i+max_len]</code>，<code>target = ids[i+1:i+max_len+1]</code>，+1 偏移在 dataset 里做完，默认 collate 直接 stack。stride 是“窗口每次滑动的步长”不是窗口大小，取 max_length 一半就是 50% 重叠，抗上下文割裂。</li>
<li><strong>classify</strong>：变长文本 + 类别标签。pad 到 <strong>batch 内最长</strong>，所以 pad 必须在 collate——dataset 阶段看不到邻居，不知道要补多长。书里是补到全集最长，一条离群长文会让所有短文本陪着补，这里有意改掉了。</li>
<li><strong>instruct</strong>：最重的一条流水线，五步手术：</li>
</ul>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">full</span> <span class="o">=</span> <span class="n">prompt_ids</span> <span class="o">+</span> <span class="n">response_ids</span> <span class="o">+</span> <span class="p">[</span><span class="n">eos_id</span><span class="p">]</span>   <span class="c1"># 1. 追加 EOS</span>
</span></span><span class="line"><span class="cl"><span class="n">padded</span> <span class="o">=</span> <span class="n">pad_to_length</span><span class="p">(</span><span class="n">full</span><span class="p">,</span> <span class="n">max_len</span><span class="p">,</span> <span class="n">eos_id</span><span class="p">)</span> <span class="c1"># 2. pad 到 batch 最长</span>
</span></span><span class="line"><span class="cl"><span class="n">inputs</span>  <span class="o">=</span> <span class="n">padded</span><span class="p">[:</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>                         <span class="c1"># 3. +1 错位</span>
</span></span><span class="line"><span class="cl"><span class="n">targets</span> <span class="o">=</span> <span class="n">padded</span><span class="p">[</span><span class="mi">1</span><span class="p">:]</span><span class="o">.</span><span class="n">clone</span><span class="p">()</span>                  <span class="c1">#    （clone：切片是视图）</span>
</span></span><span class="line"><span class="cl"><span class="n">targets</span><span class="p">[:</span><span class="nb">len</span><span class="p">(</span><span class="n">prompt_ids</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="o">-</span><span class="mi">100</span>          <span class="c1"># 4. prompt 位不计分</span>
</span></span><span class="line"><span class="cl"><span class="n">targets</span><span class="p">[</span><span class="n">eos_pos</span><span class="p">[</span><span class="mi">1</span><span class="p">:]]</span> <span class="o">=</span> <span class="o">-</span><span class="mi">100</span>                   <span class="c1"># 5. 除第一个 EOS 外全遮</span>
</span></span></code></pre></div><p>掩码要分两笔账记：<strong>pad 掩码是卫生</strong>（不做就污染 loss），<strong>prompt 掩码是战术</strong>（只做指令跟随时用）。一句话版：prompt 是考场，response 是答卷，遮盖是“不计分”，不是“拆考场”——模型始终看得到完整 prompt，只是不为它的预测打分。</p>
<p>还有三个对齐可以当口诀：<strong>pad 对齐形状，+1 对齐时间，-100 对齐计分范围。</strong></p>
<h2 id="traincommon-提供能力循环决定节奏">train：common 提供能力，循环决定节奏</h2>
<p>三个训练循环 80% 相同，所以公共件沉到 common（loss 三件套、评估、LR 调度），任务文件只留差异。</p>
<p>最大的一个认知点是 <code>cross_entropy</code> 的契约：logits <code>(N, C)</code>、targets <code>(N,)</code>，<strong>N 是预测点个数</strong>。pretrain/SFT 每个位置都预测，N=B×T，所以要 <code>logits.flatten(0, 1)</code>；classify 只在最后一个位置预测，<code>logits[:, -1, :]</code> 出来就是 (B, C)，天然对齐，不需要 flatten。所以 classify 有自己的 <code>calc_loss_batch</code>，同名不同身，各放各家，不搞参数开关。</p>
<p>第二条是<strong>函数自足</strong>：<code>calc_loss_loader</code> 自己包 <code>no_grad</code>，不依赖调用方记得规矩（Java 直觉的胜利）。但反过来，训练用的 <code>calc_loss_batch</code> 绝不能包 no_grad——我包过一次，backward 直接没有梯度可回传。</p>
<p>第三条是 <strong>prepare 归调用前，循环归循环</strong>。换分类头、冻结、包 LoRA 都是训练前的模型手术，训练循环闭着眼跑，给它什么模型它训什么。</p>
<p><code>lr_at_step</code> 抽成纯函数的理由只有两个字：<strong>可测</strong>。warmup 公式出过一次 bug（多乘了 total_steps），抽出来之后三个锚点断言（起点 initial_lr、warmup 顶点 peak_lr、终点 min_lr）三秒钟验尸。如果不写测试，抽它就没有意义。</p>
<h2 id="lora手术合并存档">LoRA：手术、合并、存档</h2>
<p>给模型换 LoRA 层的递归手术有个必须记住的招式：<strong><code>named_modules</code> 用来遍历，<code>named_children</code> 用来手术</strong>。替换要拿“爹”的句柄才能 <code>setattr</code>，而 named_modules 会 yield 模块自身，拿它递归就是原地套娃——我用 RecursionError 实测过。</p>
<p>另外两条硬规矩：</p>
<ul>
<li>forward 和 merge 的缩放必须同一把尺：都是 <code>α/r</code>（论文原版）。书里只用 α，换 rank 时两种写法的强度差一个 1/r，对比实验时别混。</li>
<li>生命周期：<strong>训练并联省显存，部署 merge 省计算</strong>。<code>merged_weight()</code> 把 ΔW 折回主权重，之后保存的就是普通 GPT 的 state_dict，加载方不需要知道 LoRA 存在过。存档因此有两条路线：adapter 小而专用（保留继续训练的灵活），merged 大而通用（部署零开销）。</li>
</ul>
<h2 id="eval生成和打分分开烧">eval：生成和打分分开烧</h2>
<p><code>generate/</code> 是生成能力，<code>eval/generate.py</code> 是测试集传送带：格式化 prompt（与训练同模板）→ 调 generate_text → 裁掉 prompt → 落盘 json。<code>eval/judge.py</code> 拿这个 json 去请 DeepSeek 打分。拆开的原因很实际：生成烧 GPU，打分烧 API 额度，两边失败重跑的成本完全不同。</p>
<p>judge 这边几个工程决定：API key 走 <code>.env</code> / 环境变量（不进 git）；有 score 的条目跳过，断点续跑不重复烧额度；每 10 条落盘一次；统计（均值、分位、直方图）抽成独立函数。</p>
<h2 id="回归236-vs-239">回归：23.6 vs 23.9</h2>
<p>M0 的收官动作：拿旧仓库训练好的 LoRA 权重（355M，rank=16 alpha=16，4 epoch 那版），squid 负责加载、生成、打分，和旧仓库同权重基线对比。同权重是为了隔离变量——差异只剩管线本身。</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th></th>
        <th>squid 回归</th>
        <th>旧仓库基线</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>均分</td>
        <td><strong>23.6</strong></td>
        <td>23.9</td>
      </tr>
      <tr>
        <td>0 分条数</td>
        <td>73</td>
        <td>70</td>
      </tr>
      <tr>
        <td>81-100 分条数</td>
        <td>18</td>
        <td>19</td>
      </tr>
    </tbody>
  </table>
</div>
<p>均分差 0.3，分布形态一致，在评委噪声范围内。加上 13 个单元测试全绿，M0 验收通过。</p>
<p>另一个好用的 sanity check 记在这：<strong>初始 loss ≈ ln(vocab_size)</strong>。50257 词表随机猜的 baseline 是 10.83，训练起点贴着它才正常，之后掉得动才说明学习是真的。</p>
<h2 id="这一遍重写我练到的是什么">这一遍重写，我练到的是什么</h2>
<p>代码只是产出之一，更重要的是三条工作法：</p>
<ol>
<li><strong>手写优先，AI 当导航。</strong> AI 五分钟能写完整个仓库，但那是 AI 写的。collate 那几个坑（list 思维切 tensor、视图污染、BPE 接缝），只有亲手踩过才算学分。纯机械的搬运可以交给 AI，概念密集的地方必须手写。</li>
<li><strong>验收标准是“每行能讲清楚”，不是“脱稿默写”。</strong> 看懂和写出之间隔着正常的鸿沟，读是再认，写是回忆。第二遍学习，读流畅、写磕绊就是这个阶段的样子。</li>
<li><strong>错处入笔记。</strong> 每天的翻车现场当天记进素材库（见文末），写正文的时候全成了弹药。</li>
</ol>
<p>下一步是 M1：自己训一个 BPE tokenizer，不调用 tiktoken，配套读 diy-llm 第 2 章。作品线和理论线从这里开始双轨并行。</p>
<h2 id="素材积累原始记录">素材积累（原始记录）</h2>
<p><strong>Day 1（10-20）</strong>：</p>
<ul>
<li>MHA 重写：骨架对、细节丢四个（多头拆解、√d_k、logits/权重命名、out_proj）；抓到两个致命 bug（<code>foward</code> 拼写、mask 切片错写成 <code>[:T, T:]</code>，正确是 <code>[:T, :T]</code>）</li>
<li>「张量的第一维永远是 batch」幻觉拔除——generate 的一维切法 bug 全源于此</li>
<li>LayerNorm vs BatchNorm：「BatchNorm 统计别人，LayerNorm 只管自己」</li>
<li>pre-norm 的「干净通道」：残差主干恒等直通，warmup 与 pre-norm 是同一问题的两代武器</li>
<li>checkpoints 三层设计：gpt2.py（进口）/ store.py（自用）/ lora.py（附加）；键名映射吸收旧格式</li>
<li>LoRA merge 验收的双重计数坑：merge 是搬家不是复制</li>
<li>竖切终点：355M 权重加载，squid 第一次开口</li>
</ul>
<p><strong>Day 2（10-23）</strong>：</p>
<ul>
<li>data 层按任务分不按格式分：pretrain（定长滑窗，dataset 内偏移）/ classify（collate 补 batch 内最长）/ instruct（掩码五连）</li>
<li>collate 职责钉死：「定长的活 dataset 干，变长的活 collate 干，pad 永远在偏移前面」</li>
<li>instruct collate 五步手术：追加 EOS → pad → +1 错位 → prompt 位 -100 → 除第一个 EOS 外全 -100</li>
<li>掩码两笔账：pad 掩码是卫生（必做），prompt 掩码是战术（看目标）；「prompt 是考场，response 是答卷，遮盖是不计分不是拆考场」</li>
<li>pad_id 不许写死 50256：词表知识只从 tokenizer.eos_id 一个口进（GPT-2 ≠ Qwen，07-2 的前科）</li>
<li>list 思维切 tensor 三坑：tensor 没有 .index、切片是视图要 clone、标量广播代替 list 赋值</li>
<li>cross_entropy 契约 (N,C)+(N,)：N=预测点数。pretrain 要 flatten（N=B×T），classify 取 last-token 天然对齐（N=B）——同名不同身，各放各家</li>
<li>函数自足原则：no_grad 内收进 calc_loss_loader，不依赖调用方记得规矩（Java 直觉的胜利）；但训练用 loss 函数绝不能包 no_grad</li>
<li>训练层分工：common 提供能力，循环决定节奏；prepare（模型手术）归调用前，循环闭着眼跑</li>
<li>lr_at_step 抽纯函数的意义 = 可测性：给出过 bug 的 warmup 公式配三锚点断言当验尸官</li>
<li>named_modules 遍历、named_children 手术：替换要拿爹的句柄；named_modules 会 yield 自身，递归即套娃（RecursionError 实锤）</li>
<li>LoRA：α/r 缩放 forward 与 merge 必须同尺；merged_weight 生命周期 = 训练并联省显存 → 部署 merge 省计算；存档两路线（adapter 小而专用 / merged 大而通用）</li>
<li>sanity check：初始 loss ≈ ln(vocab_size)，一眼辨训练真假</li>
<li>stride 语义钉死：窗口滑动的步长，不是窗口大小；stride=max_length/2 → 50% 重叠抗上下文割裂</li>
<li>Kimi 翻车帧：出考题忘了等长样本没有 pad 路径；「我的时间来自对话时间戳，不是真的钟」</li>
</ul>
]]></content:encoded>
    </item>
    <item>
      <title>diy-llm 立项书：给作品线配一条理论线</title>
      <link>https://blog.lvxinrong.com/llm/diy-llm-proposal/</link>
      <pubDate>Sat, 24 Oct 2026 12:00:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/diy-llm-proposal/</guid>
      <description>diy-llm 与 nanochat 并列：作品线负责做得出，理论线负责懂得深。按里程碑配章节，不顺序通读，选修区按需捡回。</description>
      <content:encoded><![CDATA[<blockquote>
<p>这不是课程笔记的开篇，是立项书。项目名：diy-llm 理论线走读。发起人、执行人：我自己。评委：Kimi。</p>
</blockquote>
<h2 id="为什么并列而不是顺序">为什么并列，而不是顺序</h2>
<p>《从零构建大模型》给了我 GPT-2 时代的零件，nanochat（lvchat）要把零件装成整车。但装车的过程中一定会碰到书里没有的现代地形：RoPE、RMSNorm、KV cache、数据配比、Scaling Laws、DPO/GRPO。</p>
<p><a href="https://github.com/datawhalechina/diy-llm">diy-llm</a>（DataWhale 出品，斯坦福 CS336 中文本土化课程，16 章 + 6 作业）恰好覆盖这些地形。昨晚粗翻了一遍，不少概念已经有了初步认识——说明它不是另起炉灶的新课，而是已有知识的深水区。</p>
<p>所以定位并列：<strong>nanochat 是作品线，diy-llm 是理论线。作品线负责“做得出”，理论线负责“懂得深”。</strong></p>
<h2 id="用法按里程碑配章节不顺序通读">用法：按里程碑配章节，不顺序通读</h2>
<p>每个 lvchat 里程碑开工前，先读对应章节；交付后可选做对应作业当加试题。映射表维护在 <a href="https://blog.lvxinrong.com/nanochat/lvchat-roadmap/">lvchat 实现导图</a>。</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>lvchat 里程碑</th>
        <th>diy-llm 配套章节</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>M1 自训 BPE tokenizer</td>
        <td>第 2 章 分词器 + 作业 1</td>
      </tr>
      <tr>
        <td>M2 预训练</td>
        <td>第 3 章 + 第 11 章 + 第 9 章</td>
      </tr>
      <tr>
        <td>M3 KV cache 推理引擎</td>
        <td>第 10 章 推理</td>
      </tr>
      <tr>
        <td>M4 SFT</td>
        <td>第 13 章 训练流程</td>
      </tr>
      <tr>
        <td>M5 评估框架</td>
        <td>第 12 章 评估与基准 + 作业 6</td>
      </tr>
      <tr>
        <td>架构升级（GPT-2 → 现代）</td>
        <td>第 4 章 RoPE/RMSNorm/SwiGLU</td>
      </tr>
    </tbody>
  </table>
</div>
<p>选修区（roadmap 里“明确砍掉”的装备，想捡回来时的教材）：MoE（第 5 章）、GPU/分布式（第 6-8 章）、GRPO/RLVR（第 14 章）、多模态（第 15 章）。</p>
<h2 id="验收">验收</h2>
<p>理论线的验收不是“读完了”，是“用上了”：某个里程碑的实现决策能说出依据，或者某章的作业真的跑通。读不动的时候优先保作品线，理论线可以等。</p>
]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 07-3：LoRA 剂量实验——从没训练的 32 分到平台期判决</title>
      <link>https://blog.lvxinrong.com/llm/llm-07-3-lora-dose/</link>
      <pubDate>Tue, 20 Oct 2026 16:30:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-07-3-lora-dose/</guid>
      <description>附录 D+E 联合作战：在 355M 上手写 LoRA。一份没训练就拿到 32 分的假结果、一条 warmup 平方的 bug、四轮剂量扫描、一次平台期判决，和最后 merge 验收时抓到的双重计数。</description>
      <content:encoded><![CDATA[<blockquote>
<p>目标本来是「把手写 LoRA 跑通」，结果跑成了一整天的实验课：先被一份没训练的假结果骗了，再扫出完整的剂量曲线，最后在 merge 验收里抓到双重计数。系列规则不变：写下来的必须是我自己搞懂的，翻车的地方如实写。</p>
</blockquote>
<h2 id="一假-lora-事件没训练也能拿-32-分">一、假 LoRA 事件：没训练也能拿 32 分</h2>
<p>我先交代流水线：<code>ch07_5.py</code> 训练 → <code>ch07_7.py</code> 生成测试回答 → <code>generate_model_scores.py</code> 用 DeepSeek 打分。</p>
<p>我在 07 里加了 <code>replace_linear_with_lora</code>，跑出 32.3 分，和全参数的 33.5 几乎一样，当时还挺高兴：「LoRA 用 1/150 的参数打平全参数」。</p>
<p>Kimi 翻了代码之后发现：<strong>07 里根本没有训练循环</strong>——加载 checkpoint、冻结、包 LoRA、直接生成评估。而 LoRA 的 B 矩阵是零初始化，adapter 对模型行为的贡献严格为零。所以 32.3 就是原来那个 33.5 的模型穿了件马甲。</p>
<p><strong>三组分数一模一样，不是因为 LoRA 打平了全参数，是因为那一组实验压根没发生。</strong></p>
<p>这条教训钉死：<strong>结果完美符合「无差异」时，先怀疑实验是否真的发生了</strong>。仪器没坏，是实验没做。</p>
<h2 id="二顺带曝光的两个-bug">二、顺带曝光的两个 bug</h2>
<p><strong>1. warmup_steps 被平方了。</strong></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">warmup_steps</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="mf">0.2</span> <span class="o">*</span> <span class="n">total_steps</span> <span class="o">*</span> <span class="n">total_steps</span><span class="p">)</span>  <span class="c1"># 错</span>
</span></span><span class="line"><span class="cl"><span class="n">warmup_steps</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="mf">0.2</span> <span class="o">*</span> <span class="n">total_steps</span><span class="p">)</span>                <span class="c1"># 对</span>
</span></span></code></pre></div><p>warmup 步数变成天文数字，整个训练一直活在 warmup 里，cosine 衰减从未生效。所以之前那组「调度三件套在短跑里无效」的结论作废——那不是一次有效的调度实验，是一次「全程低 lr」实验。</p>
<p><strong>2. 基线 checkpoint 被覆盖。</strong></p>
<p>原始 SFT 权重和后续实验共用同一个路径 <code>gpt2_355M_instruct.pth</code>，基线被后续运行覆盖。教训：checkpoint 命名必须带语义，只增不删。</p>
<h2 id="三真lora-首轮5e-5-的欠训判决">三、真·LoRA 首轮：5e-5 的欠训判决</h2>
<p>把 LoRA 接进 05 的训练路径（<code>replace_linear_with_lora</code> 在 optimizer 之前；optimizer 只接 <code>requires_grad</code> 的参数）：</p>
<pre tabindex="0"><code>Total trainable parameters before: 406,286,336
Total trainable parameters after:    7,898,384   ← 1.9%
</code></pre><p>峰值 lr 5e-5、2 epoch 的结果：</p>
<ul>
<li>val loss 停在 0.935（全参数 0.62）</li>
<li>评委打分 <strong>14.1，84 个 0 分</strong>（全参数 33.5 / 58 个）</li>
<li>样例把原句复读一遍——格式学了半个，变换没学会</li>
</ul>
<p>判决：欠训。LoRA 的可训练参数少、梯度信号稀疏，lr 惯例要比全参数大 1~2 个数量级，5e-5 太温柔。</p>
<h2 id="四剂量曲线四轮扫描">四、剂量曲线：四轮扫描</h2>
<p>一次只改一个变量，同评委、同 110 条测试集：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>配置</th>
        <th>均分</th>
        <th>0 分</th>
        <th>val loss</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>LoRA 5e-5, 2ep</td>
        <td>14.1</td>
        <td>84</td>
        <td>0.935</td>
      </tr>
      <tr>
        <td>LoRA 1e-4, 2ep</td>
        <td>16.4</td>
        <td>79</td>
        <td>0.866</td>
      </tr>
      <tr>
        <td>LoRA 2e-4, 2ep</td>
        <td>21.9</td>
        <td>72</td>
        <td>0.811</td>
      </tr>
      <tr>
        <td>LoRA 2e-4, 4ep</td>
        <td>23.9</td>
        <td>70</td>
        <td>0.739（已走平）</td>
      </tr>
      <tr>
        <td>全参数, 2ep</td>
        <td><strong>33.5</strong></td>
        <td><strong>58</strong></td>
        <td><strong>0.62</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<p>每一步都有效，但收益递减（+2.3 → +5.5 → +2.0），val loss 在 0.74 走平。继续推 rank 或 epoch 还能挤几分，改变不了格局。</p>
<p>插曲：第一轮 4 epoch 跑完发现 <code>num_epochs</code> 忘了改，白跑一次。实验纪律加一条：改完配置先确认再跑。这种重复劳动就是 sweep runner（配置表驱动、自动 train/generate/score）存在的理由，已记入工程债。</p>
<h2 id="五平台期判决结局-b">五、平台期判决：结局 B</h2>
<p>开跑之前 Kimi 预告了两种结局：A 是 LoRA 追平全参数，B 是 LoRA 的平台期低于全参数。数据落在 B。</p>
<p>这不是 LoRA 的失败，是定位澄清：<strong>LoRA 的价值是「让不可能变可能」，不是「让小局变更优」。</strong> 355M 全参数本来就训得动，LoRA 没有非赢不可的理由；Qwen 实验里它打过真正的仗——1.5B 模型全参数训练在 12G 显存里塞不下优化器状态，LoRA 是唯一能开工的方式。</p>
<p>另一个量化感受：LoRA 训练 2.2 分钟，全参数 2.75 分钟，只快 20%。冻结只是不更新，前向反向照样穿过全部权重——<strong>LoRA 省的是显存，不是计算</strong>。</p>
<h2 id="六merge-验收先抓双重计数再证数学等价">六、merge 验收：先抓双重计数，再证数学等价</h2>
<p>最后一关：把训练好的 ΔW 折叠回 W，验证「并联小路」和「权重更新」严格等价。</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">module</span><span class="o">.</span><span class="n">linear</span><span class="o">.</span><span class="n">weight</span> <span class="o">+=</span> <span class="p">(</span><span class="n">alpha</span> <span class="o">/</span> <span class="n">rank</span><span class="p">)</span> <span class="o">*</span> <span class="p">(</span><span class="n">A</span> <span class="o">@</span> <span class="n">B</span><span class="p">)</span><span class="o">.</span><span class="n">T</span>
</span></span></code></pre></div><p>第一跑：<strong>最大差异 32.6</strong>。原因：合并后 LoRA 路径还开着，<code>linear(x) + lora(x)</code> 把 ΔW 算了两遍。merge 是搬家不是复制——搬完必须给旧路径断电：</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">module</span><span class="o">.</span><span class="n">lora</span><span class="o">.</span><span class="n">B</span><span class="o">.</span><span class="n">zero_</span><span class="p">()</span>   <span class="c1"># 搬家完毕，旧路径关闭</span>
</span></span></code></pre></div><p>第二跑：<strong>最大差异 9.16e-05</strong>，浮点误差级。等价性亲手证完，附录 E 正式画句号。顺带一提：32.6 这个「失败」反而是 LoRA 真训练过的证据——没学出权重的话，双重计数也差不出这个量级。</p>
<h2 id="七工程债m0-的动机清单">七、工程债（M0 的动机清单）</h2>
<p>今天改一行配置要懂三个文件（训练/评估/打分互相 import、路径写死、optimizer 藏在流程中间），「没有工程化，改起来好麻烦」——这些痛点全部转化为 lvllm 重写（笔记 08）的需求：</p>
<ol>
<li>checkpoint 标准化：语义命名、只增不删、adapter 单独存</li>
<li>sweep runner：配置表驱动，train/generate/score 一条龙</li>
<li>训练/评估/打分解耦，配置集中</li>
</ol>
<h2 id="一句话总结">一句话总结</h2>
<p><strong>结果出来了和实验发生了，是两回事</strong>——这是今天最贵的一句话，其余都是注脚。</p>
<hr>
<p><em>前一篇：<a href="https://blog.lvxinrong.com/llm/llm-07-2-switch-base/">手搓 LLM 笔记 07-2：换底座，从 33.5 分的 GPT-2 到 86.5 分的 Qwen</a></em></p>
]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 07-2：换底座，从 33.5 分的 GPT-2 到 86.5 分的 Qwen</title>
      <link>https://blog.lvxinrong.com/llm/llm-07-2-switch-base/</link>
      <pubDate>Mon, 19 Oct 2026 21:00:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-07-2-switch-base/</guid>
      <description>上一篇的 355M 模型交出 33.5 分和 58 个 0 分。这篇是它的对照组：同一份数据、同一个判官、同一个测试集，换成 Qwen2.5-1.5B base 再做一遍。结果底座把分数从 33.5 拉到 86.5，SFT 却几乎不提分——但它把「写小作文」改成了「直接回答」，也在超参贪心时弄丢了刚学会的知识。</description>
      <content:encoded><![CDATA[<blockquote>
<p>上一篇的结尾贴了 355M 的答卷：33.5 分，58 条 0 分。分数难看，但证据链是完整的——也正因为完整，才看得清问题不在训练脚本，而在底座。这篇是它的对照组：<strong>同一份数据、同一个判官、同一个 110 条测试集</strong>，把模型从手搓的 GPT-2 355M 换成 Qwen2.5-1.5B base，再做一次指令微调。系列规则不变：写下来的必须是我自己搞懂的，翻车的地方如实写。</p>
</blockquote>
<h2 id="一起点335-分和-58-个-0-分问题出在哪">一、起点：33.5 分和 58 个 0 分，问题出在哪</h2>
<p>上一篇的记录里，GPT-2 355M 用 1100 条 Alpaca 数据全参微调 2 个 epoch，DeepSeek 判官给出的结果是：</p>
<pre tabindex="0"><code>mean = 33.5    median = 0    0 分 = 58 条（52.7%）
exact match（归一化）= 15.5%
平均回答长度 = 17 token，128 token 截断 1 条，模板残留 2 条
</code></pre><p>（上一篇贴的是 33.9 / 57 条，本文统一用留存文件重算的 33.5 / 58 条。同一份回复两次打分差 0.4 分——这本身就是本篇后半段要展开的主题：<strong>评委是变量</strong>。）</p>
<p>当时做过一轮归因：58 个 0 分里，<strong>没有一条是空回答、模板残留或截断</strong>，全是“正常文本但答错了”。典型的样本：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>指令</th>
        <th>正确答案</th>
        <th>355M 的回答</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>chlorine 的元素符号</td>
        <td>Cl</td>
        <td><strong>C</strong></td>
      </tr>
      <tr>
        <td>找出句式类型</td>
        <td>interrogative</td>
        <td><strong>imperative</strong></td>
      </tr>
      <tr>
        <td>改写句子（被动→副词）</td>
        <td>The lecture was delivered <strong>clearly</strong>.</td>
        <td>原句照抄</td>
      </tr>
      <tr>
        <td>生成幽默轶事</td>
        <td>Why was the math book sad?&hellip;</td>
        <td>编了个无关的长故事，被 128 token 截断</td>
      </tr>
    </tbody>
  </table>
</div>
<p>配合 train loss 0.30 / val loss 0.64 的过拟合曲线，结论很朴素：<strong>格式它学会了，知识它没有</strong>。1100 条数据改变不了底座的厚度。</p>
<p>于是有了那个命题——<strong>预训练决定“知道什么、能做什么”，后训练决定“怎么表现出来”</strong>。这个命题要在这一篇里被定量验证。</p>
<h2 id="二换底座为什么最后是-qwen25-15b">二、换底座：为什么最后是 Qwen2.5-1.5B</h2>
<h3 id="21-三条路">2.1 三条路</h3>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>路线</th>
        <th>代码改动</th>
        <th>训练耗时</th>
        <th>预期 0 分率</th>
        <th>保留“从零构建”链路</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>GPT-2 774M</td>
        <td>改一行 <code>CHOOSE_MODEL</code></td>
        <td>~7 分钟</td>
        <td>53% → 40~45%</td>
        <td>✅</td>
      </tr>
      <tr>
        <td>GPT-2 1.5B</td>
        <td>同上</td>
        <td>~15 分钟</td>
        <td><del>35</del>40%</td>
        <td>✅</td>
      </tr>
      <tr>
        <td><strong>Qwen2.5-1.5B base + LoRA</strong></td>
        <td>新脚本</td>
        <td>~4 分钟/epoch</td>
        <td><strong>预计 &lt;15%</strong></td>
        <td>❌</td>
      </tr>
    </tbody>
  </table>
</div>
<p>选第三条的原因不是“新”，而是<strong>对照实验需要变量干净</strong>：GPT-2 774M 的容量翻倍了，但知识底子还是 2019 年 40GB WebText 那一套，花 40 分钟很可能只换来“0 分率从 53% 降到 43%”的边际改善；而 Qwen2.5 在 18T token 上预训练，知识是另一个量级，才能真正检验“底座决定上限”。</p>
<h3 id="22-为什么用-base不用-instruct">2.2 为什么用 base，不用 Instruct</h3>
<p>这一点是实验设计的关键。如果直接拿 Instruct 模型来做 SFT，它出厂就已经会按指令回答，SFT 的效果会被掩盖——你分不清格式对齐是训练带来的还是本来就有。</p>
<p>所以对照组必须是<strong>未微调的 base</strong>：它知道“氯的元素符号是 Cl”，但不知道怎么“以回答问题的姿态”说出来。SFT 前后一对比，被改变的到底是什么，一目了然。</p>
<h3 id="23-为什么不是最新的-qwen38">2.3 为什么不是最新的 Qwen3.8</h3>
<p>写这篇时 Qwen 已经更新到 3.8 代，但 3.8 目前公开的是总参数 2.4T、激活 95B 的 MoE——本机 48GB 统一内存跑不动，那是 API 或云端推理的体量。能在 M4 Pro 上做 LoRA 消融的是小尺寸 base 版本；Qwen2.5-1.5B 的生态兼容性最稳，<code>peft</code> / <code>transformers</code> 踩坑最少。想用新一代也很简单——只改 <code>MODEL_NAME</code>，其余一行不动。</p>
<h3 id="24-手搓的-gptmodel-去哪了">2.4 手搓的 GPTModel 去哪了</h3>
<p>换到 HF 栈之后，第 4~6 章手写的 <code>GPTModel</code>、<code>generate_text_util</code>、<code>train_model_simple_py</code> 在新脚本里全部闲置了。不是白写——它们是读懂 HF 源码的坐标系：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>我的实现（GPT-2 结构）</th>
        <th>Qwen2.5 的结构</th>
        <th>为什么变</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><code>tok_emb</code> + <code>pos_emb</code>（可学习绝对位置）</td>
        <td><code>wte</code> + <strong>RoPE</strong>（旋转位置编码）</td>
        <td>支持长度外推，context 1024 → 32k+</td>
      </tr>
      <tr>
        <td><code>LayerNorm</code></td>
        <td><strong>RMSNorm</strong></td>
        <td>省去均值计算</td>
      </tr>
      <tr>
        <td>GELU 两层 MLP（<code>c_fc</code>→<code>c_proj</code>）</td>
        <td><strong>SwiGLU</strong> 三层（<code>gate_proj</code>/<code>up_proj</code>/<code>down_proj</code>）</td>
        <td>同参数量下效果更好</td>
      </tr>
      <tr>
        <td>MHA：12 个 Q 头 = 12 个 KV 头</td>
        <td><strong>GQA</strong>：12 个 Q 头只配 2 个 KV 头</td>
        <td>省 KV cache 显存——正好对上之前问的“为什么只有 KV cache”</td>
      </tr>
      <tr>
        <td><code>qkv_bias=True</code></td>
        <td>默认无 bias</td>
        <td>训练稳定性</td>
      </tr>
      <tr>
        <td>词表 50257</td>
        <td>词表 151936</td>
        <td>多语言</td>
      </tr>
    </tbody>
  </table>
</div>
<p>真正被替换的只有三件：模型定义、生成函数、训练循环。<strong>被保留的是最值钱的部分</strong>——<code>format_input</code> 模板、<code>InstructionDataset</code> 的掩码思路、110 条测试集切分、判官打分流水线。实验之所以可比，靠的就是这些没动。</p>
<h2 id="三代码ch07_qwenpy">三、代码：<code>ch07_qwen.py</code></h2>
<h3 id="31-训练侧lora--只对回答算-loss">3.1 训练侧：LoRA + 只对回答算 loss</h3>
<p>模板和 GPT-2 版本逐字一致（<code>format_input(entry) + &quot;\n\n### Response:\n&quot;</code>），prompt 部分的 label 置 <code>-100</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">prompt</span> <span class="o">=</span> <span class="n">format_input</span><span class="p">(</span><span class="n">e</span><span class="p">)</span> <span class="o">+</span> <span class="s2">&#34;</span><span class="se">\n\n</span><span class="s2">### Response:</span><span class="se">\n</span><span class="s2">&#34;</span>
</span></span><span class="line"><span class="cl"><span class="n">answer</span> <span class="o">=</span> <span class="n">e</span><span class="p">[</span><span class="s2">&#34;output&#34;</span><span class="p">]</span> <span class="o">+</span> <span class="n">tokenizer</span><span class="o">.</span><span class="n">eos_token</span>
</span></span><span class="line"><span class="cl"><span class="n">p_ids</span> <span class="o">=</span> <span class="n">tokenizer</span><span class="p">(</span><span class="n">prompt</span><span class="p">,</span> <span class="n">add_special_tokens</span><span class="o">=</span><span class="kc">False</span><span class="p">)[</span><span class="s2">&#34;input_ids&#34;</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="n">a_ids</span> <span class="o">=</span> <span class="n">tokenizer</span><span class="p">(</span><span class="n">answer</span><span class="p">,</span> <span class="n">add_special_tokens</span><span class="o">=</span><span class="kc">False</span><span class="p">)[</span><span class="s2">&#34;input_ids&#34;</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="n">ids</span>    <span class="o">=</span> <span class="p">(</span><span class="n">p_ids</span> <span class="o">+</span> <span class="n">a_ids</span><span class="p">)[:</span><span class="n">MAX_LEN</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="n">labels</span> <span class="o">=</span> <span class="p">([</span><span class="o">-</span><span class="mi">100</span><span class="p">]</span> <span class="o">*</span> <span class="nb">len</span><span class="p">(</span><span class="n">p_ids</span><span class="p">)</span> <span class="o">+</span> <span class="n">a_ids</span><span class="p">)[:</span><span class="n">MAX_LEN</span><span class="p">]</span>
</span></span></code></pre></div><p>LoRA 挂在注意力与 MLP 的全部投影上（这是第一轮激进配置；文末的推荐配置是 r=8, α=16）：</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">lora_config</span> <span class="o">=</span> <span class="n">LoraConfig</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">task_type</span><span class="o">=</span><span class="n">TaskType</span><span class="o">.</span><span class="n">CAUSAL_LM</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">r</span><span class="o">=</span><span class="mi">16</span><span class="p">,</span> <span class="n">lora_alpha</span><span class="o">=</span><span class="mi">32</span><span class="p">,</span> <span class="n">lora_dropout</span><span class="o">=</span><span class="mf">0.05</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">target_modules</span><span class="o">=</span><span class="p">[</span><span class="s2">&#34;q_proj&#34;</span><span class="p">,</span> <span class="s2">&#34;k_proj&#34;</span><span class="p">,</span> <span class="s2">&#34;v_proj&#34;</span><span class="p">,</span> <span class="s2">&#34;o_proj&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">                    <span class="s2">&#34;gate_proj&#34;</span><span class="p">,</span> <span class="s2">&#34;up_proj&#34;</span><span class="p">,</span> <span class="s2">&#34;down_proj&#34;</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">model</span> <span class="o">=</span> <span class="n">get_peft_model</span><span class="p">(</span><span class="n">model</span><span class="p">,</span> <span class="n">lora_config</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="c1"># trainable params: 18,464,768 || all params: 1,562,179,072 || trainable%: 1.1820</span>
</span></span></code></pre></div><p><strong>1.18% 的参数可训练</strong>，其余 98.8% 冻结。优化器只接可训练参数：</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">optimizer</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">optim</span><span class="o">.</span><span class="n">AdamW</span><span class="p">([</span><span class="n">p</span> <span class="k">for</span> <span class="n">p</span> <span class="ow">in</span> <span class="n">model</span><span class="o">.</span><span class="n">parameters</span><span class="p">()</span> <span class="k">if</span> <span class="n">p</span><span class="o">.</span><span class="n">requires_grad</span><span class="p">],</span> <span class="n">lr</span><span class="o">=</span><span class="n">LR</span><span class="p">)</span>
</span></span></code></pre></div><p>一次优化 = 2 个 micro-batch（<code>GRAD_ACCUM=2</code>），<code>loss = model(**batch).loss / 2</code> 后 <code>backward</code>，每 2 步 <code>step()</code> 一次。</p>
<h3 id="32-生成侧hf-自带-kv-cache">3.2 生成侧：HF 自带 KV cache</h3>
<p>评估用的是 <code>model.generate(..., max_new_tokens=128, do_sample=False)</code>。和第 7 章手写的 <code>generate</code> 最大区别不是代码长短，而是 <strong>HF 的实现自带 KV cache</strong>：每生成一个 token 只算新位置，而不是把整个前缀重新 forward 一遍。110 条测试样本的完整评估因此从“不敢想”变成 1~2 分钟。</p>
<h3 id="33-工程坑记录">3.3 工程坑记录</h3>
<ul>
<li><strong>模板多一个空格</strong>：<code>f&quot;### Response: \n“</code> 比书上模板多一个空格，BPE 会多切出一个 <code>' '</code> token（id 220），loss 和抽取都和书对不上。改成 <code>”### Response:\n&quot;</code> 后对齐。</li>
<li><strong><code>allowed_max_length=1204</code></strong>：比 <code>context_length=1024</code> 还大，等于没截断；一旦样本超长，位置编码直接越界。改回 1024。</li>
<li><strong><code>num_workers=8</code> + macOS</strong>：Python 3.12 在 macOS 默认 <code>spawn</code>，脚本顶层又没写 <code>if __name__ == &quot;__main__&quot;</code>，子进程重新 import 主模块导致无限套娃。改 <code>num_workers=0</code> + main guard 解决。</li>
<li><strong>MPS 随机数独立</strong>：要复现就得同时 <code>torch.manual_seed</code> 和 <code>torch.mps.manual_seed</code>；计时要在末尾 <code>torch.mps.synchronize()</code>，否则 GPU 队列还没排空。</li>
</ul>
<h2 id="四评估协议三个判据两个口径">四、评估协议：三个判据，两个口径</h2>
<ul>
<li><strong>测试集</strong>：110 条，与 GPT-2 完全同一批。</li>
<li><strong>判官</strong>：DeepSeek <code>deepseek-flash</code>，<code>temperature=0</code>，输出 0–100 整数。</li>
<li><strong>两种 prompt</strong>（这本身是第二组实验）：
<ul>
<li><strong>字面口径</strong>：按与参考答案的接近程度打分（和上一篇一致，可与 GPT-2 直接比较）；</li>
<li><strong>语义口径</strong>：只判事实/指令正确性，不判措辞、长度与格式。</li>
</ul>
</li>
<li><strong>三个无 API 成本的辅助指标</strong>：归一化 exact match、平均 token 数、128 token 截断数。判官会抖，客观指标不会。</li>
</ul>
<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">You are grading a model answer. Judge ONLY factual/instructional correctness,
</span></span><span class="line"><span class="cl">NOT wording, length, or format. A semantically equivalent answer is full marks.
</span></span><span class="line"><span class="cl">...
</span></span><span class="line"><span class="cl">Score 0-100. Respond with the integer only.
</span></span></code></pre></div><h2 id="五第一轮base-vs-激进-sft--换底座赢麻了sft-白忙了">五、第一轮：base vs 激进 SFT —— 换底座赢麻了，SFT 白忙了</h2>
<h3 id="51-结果">5.1 结果</h3>
<p><strong>字面口径</strong>（与 GPT-2 同口径）：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>组别</th>
        <th>均分</th>
        <th>中位</th>
        <th>0 分率</th>
        <th>≥80 占比</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>GPT-2 355M + SFT</td>
        <td><strong>33.5</strong></td>
        <td>0</td>
        <td>52.7%</td>
        <td>25.5%</td>
      </tr>
      <tr>
        <td>Qwen base</td>
        <td>84.4</td>
        <td>100</td>
        <td>8.2%</td>
        <td>82.7%</td>
      </tr>
      <tr>
        <td>Qwen + SFT（激进）</td>
        <td>84.3</td>
        <td>100</td>
        <td>9.1%</td>
        <td>81.8%</td>
      </tr>
    </tbody>
  </table>
</div>
<p><strong>生成侧指标</strong>：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>组别</th>
        <th>exact match</th>
        <th>平均 token</th>
        <th>截断</th>
        <th>空回答</th>
        <th>模板残留</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>GPT-2 355M</td>
        <td>15.5%</td>
        <td>17.0</td>
        <td>1</td>
        <td>0</td>
        <td>2</td>
      </tr>
      <tr>
        <td>Qwen base</td>
        <td>24.5%</td>
        <td><strong>31.4</strong></td>
        <td><strong>6</strong></td>
        <td>0</td>
        <td>0</td>
      </tr>
      <tr>
        <td>Qwen SFT（激进）</td>
        <td><strong>42.7%</strong></td>
        <td>13.1</td>
        <td>0</td>
        <td>0</td>
        <td>0</td>
      </tr>
    </tbody>
  </table>
</div>
<h3 id="52-观察一base-根本不需要教知识">5.2 观察一：base 根本不需要“教知识”</h3>
<p>未微调的 base 在同样的模板下，直接答对了这些题：</p>
<pre tabindex="0"><code>雷暴云类型      → cumulonimbus
氯的元素符号    → Cl
《傲慢与偏见》作者 → Jane Austen
</code></pre><p>上一轮 355M 答错的同一道 chlorine 题，base 没经过任何 SFT 就答对了。<strong>知识是预训练给的</strong>，这句话从“猜”变成了“看到”。</p>
<h3 id="53-观察二sft-在强底座上几乎不提分只改形状">5.3 观察二：SFT 在强底座上几乎不提分，只改形状</h3>
<p>字面口径下 base 84.4、SFT 84.3，<strong>逐条对比 110 条里有 91 条分数完全相同</strong>。但 SFT 明确改变了三件事：</p>
<ul>
<li>exact match 24.5% → 42.7%；</li>
<li>平均长度 31.4 → 13 token（base 爱写小作文，SFT 只给答案）；</li>
<li>128 token 截断 6 条 → 0 条（base 会陷入「without my phone without my phone&hellip;」的复读，SFT 不会）。</li>
</ul>
<p>base 的失败模式是“知道答案但话太多、停不下来”，SFT 修的正是这个。判官分不动，是因为它本来就答对了。</p>
<h3 id="54-观察三灾难性遗忘--sft-把知识写坏了">5.4 观察三：灾难性遗忘 —— SFT 把知识写坏了</h3>
<p>这是这一轮最意外的发现。以“base 给 100 分、SFT 却 &lt;60 分”定义知识回退，激进配置出现了 <strong>9 条</strong>（其中 8 条是真错，1 条是判官误判——列表式分类那道）：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>指令</th>
        <th>base</th>
        <th>激进 SFT</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>二氧化碳分子式</td>
        <td>CO2</td>
        <td><strong>C2O2</strong></td>
      </tr>
      <tr>
        <td>硫的沸点</td>
        <td>444.6°C</td>
        <td><strong>112°C</strong></td>
      </tr>
      <tr>
        <td>判断句式（Did you&hellip;?）</td>
        <td>question</td>
        <td><strong>imperative</strong></td>
      </tr>
      <tr>
        <td>挑出形容词（run/tall/quickly）</td>
        <td>tall</td>
        <td>tall <strong>和 quickly</strong>（副词）</td>
      </tr>
      <tr>
        <td>鲨鱼分类</td>
        <td>Fish</td>
        <td><strong>Reptiles</strong></td>
      </tr>
      <tr>
        <td>I am lost 的意大利语</td>
        <td>Sono perso</td>
        <td><strong>Ti sei perso</strong>（“你迷路了”）</td>
      </tr>
      <tr>
        <td>see you later 的西班牙语</td>
        <td>hasta luego</td>
        <td><strong>Vuelva a verme tarde</strong></td>
      </tr>
      <tr>
        <td>用 elucidate 造句</td>
        <td>用了该词</td>
        <td><strong>句子没用 elucidate</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<p>1100 条数据、<code>lr=2e-4</code>、2 个 epoch——模型为了贴合 Alpaca 的措辞，把预训练学的知识挤掉了。这就是<strong>灾难性遗忘（catastrophic forgetting）</strong>。</p>
<h2 id="六第二轮把学习率降下来知识真的回来了">六、第二轮：把学习率降下来，知识真的回来了</h2>
<p>直觉判断：遗忘是“更新太猛”造成的。把总更新幅度砍到 1/8：</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">LR</span> <span class="o">=</span> <span class="mf">5e-5</span>        <span class="c1"># 2e-4 → 5e-5</span>
</span></span><span class="line"><span class="cl"><span class="n">NUM_EPOCHS</span> <span class="o">=</span> <span class="mi">1</span>   <span class="c1"># 2 → 1</span>
</span></span><span class="line"><span class="cl"><span class="n">r</span><span class="o">=</span><span class="mi">8</span><span class="p">,</span> <span class="n">lora_alpha</span><span class="o">=</span><span class="mi">16</span>   <span class="c1"># r=16, alpha=32 → r=8, alpha=16</span>
</span></span></code></pre></div><p>结果：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>条目</th>
        <th>base</th>
        <th>激进</th>
        <th>保守（1ep/5e-5/r8）</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>CO2 分子式</td>
        <td>100</td>
        <td>0</td>
        <td><strong>100</strong></td>
      </tr>
      <tr>
        <td>硫沸点</td>
        <td>100</td>
        <td>0</td>
        <td><strong>90</strong>（444 vs 444.6）</td>
      </tr>
      <tr>
        <td>句式判断</td>
        <td>100</td>
        <td>0</td>
        <td><strong>85</strong>（「a question」）</td>
      </tr>
      <tr>
        <td>形容词</td>
        <td>100</td>
        <td>0</td>
        <td><strong>100</strong></td>
      </tr>
      <tr>
        <td>I am lost 意语</td>
        <td>85</td>
        <td>0</td>
        <td><strong>90</strong>（Mi sono perso）</td>
      </tr>
      <tr>
        <td>see you later 西语</td>
        <td>100</td>
        <td>0</td>
        <td><strong>100</strong>（hasta luego）</td>
      </tr>
      <tr>
        <td>elucidate 造句</td>
        <td>100</td>
        <td>0</td>
        <td><strong>95</strong>（The professor elucidated&hellip;）</td>
      </tr>
      <tr>
        <td>irony 定义</td>
        <td>100</td>
        <td>0</td>
        <td><strong>85</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<p><strong>8 条全部修复。</strong> 语义口径均分 84.8，exact match 37.3%（比激进版低 5.4pp）。</p>
<p>结论升级：<strong>遗忘不是 SFT 的必然，是超参的选择</strong>。少训一点、慢一点，可以在“格式对齐”和“保住知识”之间找到平衡。</p>
<h2 id="七第三轮找甜点--1-epoch--1e-4--r8">七、第三轮：找甜点 —— 1 epoch / 1e-4 / r=8</h2>
<p>保守版把知识救回来了，但格式对齐退得有点多。把 lr 从 5e-5 提到 1e-4（总更新幅度仍是激进版的 1/4），再跑一轮：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>指标</th>
        <th>保守 5e-5</th>
        <th><strong>中配 1e-4</strong></th>
        <th>激进 2e-4×2</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>exact match</td>
        <td>37.3%</td>
        <td><strong>39.1%</strong></td>
        <td>42.7%</td>
      </tr>
      <tr>
        <td>语义均分</td>
        <td>84.8</td>
        <td><strong>86.5</strong></td>
        <td>83.6</td>
      </tr>
      <tr>
        <td>0 分率</td>
        <td>8.2%</td>
        <td><strong>6.4%</strong></td>
        <td>15.5%</td>
      </tr>
      <tr>
        <td>真实知识回退</td>
        <td>3 条</td>
        <td><strong>2 条</strong></td>
        <td>8 条</td>
      </tr>
    </tbody>
  </table>
</div>
<p>中配还剩下 4 条“回退”，但其中 2 条是判官的锅（见下一节），真实错误只有“nostalgia 造句没用该词”和“鲨鱼被分类成爬行动物”两条。</p>
<p><strong>这就是甜点</strong>：<code>Qwen2.5-1.5B base + LoRA(r=8, α=16) + 1 epoch + lr 1e-4</code>。</p>
<p><img alt="七组打分结果：灰色为字面口径，蓝色为语义口径；右图为分数分布" loading="lazy" src="https://blog.lvxinrong.com/llm/llm-07-2-score-comparison-v2.png"></p>
<h3 id="补充为什么回退条数比均分更能说明问题">补充：为什么“回退条数”比均分更能说明问题</h3>
<p>看配对统计会更清楚（语义口径，vs base）：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>对比</th>
        <th>均分差</th>
        <th>95% 置信区间</th>
        <th>更好</th>
        <th>更差</th>
        <th>打平</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>激进 − base</td>
        <td>−2.14</td>
        <td>[−9.3, +5.0]</td>
        <td>8</td>
        <td>11</td>
        <td>91</td>
      </tr>
      <tr>
        <td>保守 − base</td>
        <td>−1.00</td>
        <td>[−6.2, +4.2]</td>
        <td>10</td>
        <td>37</td>
        <td>63</td>
      </tr>
      <tr>
        <td>中配 − base</td>
        <td>+0.68</td>
        <td>[−4.7, +6.0]</td>
        <td>12</td>
        <td>35</td>
        <td>63</td>
      </tr>
    </tbody>
  </table>
</div>
<p><strong>三个区间全部跨过 0</strong>——在这个已经很强的 base 上，SFT 对“判官均分”没有统计显著的影响。它产生的影响全部落在<strong>分布形状</strong>上：base 是“15 个 0 分 + 94 个 81–100 分”的极端两极化分布，中配把 0 分压到 7 条、把中间段补了 8 条。<strong>SFT 用“抹平少数满分”换来了“减少灾难性错误”。</strong></p>
<h2 id="八第四次实验评委自己也是变量">八、第四次实验：评委自己也是变量</h2>
<h3 id="81-两种-prompt-的差别">8.1 两种 prompt 的差别</h3>
<p>同一个 base 模型、同一批回答，只换判官 prompt：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>判官口径</th>
        <th>base 均分</th>
        <th>base 0 分率</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>字面</td>
        <td>84.4</td>
        <td>8.2%</td>
      </tr>
      <tr>
        <td>语义</td>
        <td>85.8</td>
        <td><strong>13.6%</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<p>语义 prompt 把 0 分率<strong>提高了</strong>——它让判官更“二元化”（要么 100、要么 0）。这说明 “改 prompt 以减少格式偏见” 这个预期没有完全实现，判官行为本身难以预测。</p>
<h3 id="82-判官实锤误判的案例">8.2 判官实锤误判的案例</h3>
<ul>
<li><strong>列表式分类题</strong>：gold 是 <code>Mercury - Liquid / Oxygen - Gas / Wood - Solid</code>，SFT 答 <code>Solid: Wood / Liquid: Oxygen / Gas: Mercury</code>——内容全对，被判 <strong>0</strong>。</li>
<li><strong>德语翻译</strong>：<code>Badezimmer</code> 是 bathroom 的正确德语词之一，被判 <strong>0</strong>（gold 用 <code>Toilette</code>）。</li>
<li><strong>简洁的正确回答</strong>：base 用一整段解释得 100，SFT 一句话答对得 85——判官仍偏爱“长”。</li>
</ul>
<h3 id="83-波动有多大">8.3 波动有多大</h3>
<ul>
<li>同一份回复字面口径两次打分：84.2 / 84.4；</li>
<li>上一篇 GPT-2 记录 33.9 / 57 条 0 分，本次重算 33.5 / 58 条。</li>
</ul>
<p><strong>±0.5 分、±1 条 0 分是常态。</strong> 所以本篇所有结论都写“方向”和“区间”，不写“精确到小数点后一位的胜负”。</p>
<h2 id="九结论">九、结论</h2>
<ol>
<li><strong>底座决定上限，且是数量级的</strong>：同数据、同判官，GPT-2 355M 33.5 → Qwen2.5-1.5B 84<del>86。0 分率 52.7% → 6</del>13%。</li>
<li><strong>SFT 在强底座上是“塑形”不是“提分”</strong>：判官分无显著变化，但 exact match +14pp、回答长度腰斩、截断归零、极端错误减半。</li>
<li><strong>SFT 不是免费的</strong>：学习率/训练量过大会造成灾难性遗忘（CO2→C2O2、硫沸点 444.6→112）；把更新幅度降到 1/8 后全部修复。<strong>“教格式”和“毁知识”之间只差一个学习率。</strong></li>
<li><strong>评估口径是结论的一部分</strong>：同一模型换判官 prompt，0 分率从 8.2% 变 13.6%；报告必须注明口径，并用 exact match 这类客观指标交叉验证。</li>
<li><strong>推荐配置</strong>：<code>Qwen2.5-1.5B base + LoRA(r=8, α=16) + 1 epoch + lr 1e-4 + 只对 response 算 loss</code>。</li>
</ol>
<h2 id="十这篇笔记改掉的三句话">十、这篇笔记改掉的三句话</h2>
<p>实验之外，这篇笔记还修正了我三个张口就来的认知，按被推翻的顺序记：</p>
<p><strong>「一个差的模型，怎么微调都不会变强。」</strong>——不准确。355M 微调前后确实变了：会听指令、会吐结束符，「行为」变了；但知识问答照错，「能力」没动。准确的说法是：<strong>上限由预训练定死，后训练在上限之内调水位，水位的天花板是对齐数据的质量</strong>。alignment 便宜，capability 贵。</p>
<p><strong>「SFT 反正是给模型加东西。」</strong>——错。SFT 不是免费的：激进配置把 CO2 教成 C2O2、把硫的沸点从 444.6°C 写成 112°C。<strong>教格式和毁知识之间只差一个学习率。</strong>「后训练决定平均答复水平」这句话要加半句——在训练数据配得上的前提下。</p>
<p><strong>「国内模型是基础差、后训练厉害。」</strong>——也错，因果反了。真实剧情是算力受限逼出了全栈效率创新：MLA 压缩 KV cache（和 LoRA 同款的低秩思想，用在注意力上）、MoE 用稀疏换规模、FP8 砍精度换吞吐、GRPO 做后训练。<strong>不是后训练一层强，是三层都在拧毛巾</strong>。这个认知对我自己也有用：我的算力牌面比谁都紧，但约束不是借口，是设计的起点——nanochat 整个项目就是这个哲学。</p>
<p>顺带一个光谱观察：第六章「只解冻最后一块」、第七章「全参数微调」、本篇 LoRA「全冻结外挂低秩小路」——三种方案是同一个问题的三个答案：微调到底该动多少参数、动哪里。成本、效果、遗忘风险，三角取舍。</p>
<h2 id="十一模型仍然不会的题">十一、模型仍然不会的题</h2>
<p>两种口径下都 ≤20 分的 10 条，几乎全是<strong>变换类 / 开放创作类</strong>：</p>
<pre tabindex="0"><code>纠正标点        &#34;Its time to go home.&#34; → 不会
替换陈词滥调     &#34;It&#39;s very easy.&#34; → 不会
改为间接疑问句   → 不会
indefinite pronoun 转换 → 不会
幽默轶事创作     → 编的故事和“数学书为什么悲伤”无关
氯的沸点         -34°C → 不会
</code></pre><p>这是 1.5B 的能力边界，不是训练配置问题。Alpaca 里这类题的参考答案非常具体（「The corrected sentence should be: ‘It’s time to go home.’」），模型既不会做字符级编辑，也不会主动收束到那种格式。<strong>底座再大一号，这类题才会松动。</strong></p>
<h2 id="十二留痕文件与复现">十二、留痕文件与复现</h2>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>文件</th>
        <th>内容</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><code>instruction-data-with-response.json</code> / <code>-scores.json</code></td>
        <td>GPT-2 355M 全参 SFT，字面口径</td>
      </tr>
      <tr>
        <td><code>qwen-base-with-response.json</code> / <code>-scores.json</code> / <code>-scores-semantic.json</code></td>
        <td>Qwen base，两种口径</td>
      </tr>
      <tr>
        <td><code>qwen-sft-with-response.json</code> / <code>-scores.json</code> / <code>-scores-semantic.json</code></td>
        <td>激进 LoRA（2ep/2e-4/r16）</td>
      </tr>
      <tr>
        <td><code>qwen-sft-lr5e5_ep1_r8-*</code></td>
        <td>保守 LoRA（1ep/5e-5/r8）</td>
      </tr>
      <tr>
        <td><code>qwen-sft-lr1e4_ep1_r8-*</code></td>
        <td><strong>中配 LoRA（推荐）</strong></td>
      </tr>
      <tr>
        <td><code>qwen2.5-1.5b-alpaca-lora{,-lr5e5_ep1_r8,-lr1e4_ep1_r8}</code></td>
        <td>三个 adapter</td>
      </tr>
    </tbody>
  </table>
</div>
<p>硬件与耗时（M4 Pro / 48GB / MPS）：GPT-2 355M 全参 2 epoch ≈ 2.85 分钟；Qwen LoRA 1 epoch ≈ 4 分钟；110 条生成评估 ≈ 1~1.7 分钟；110 条判官打分 ≈ 1.2 分钟。</p>
<h2 id="十三下一步">十三、下一步</h2>
<ol>
<li>给中配补字面口径分数，把四组表补完整；</li>
<li>对 2 条真实回退和 10 条 both-low 各打 3 次取平均，压掉判官噪声；</li>
<li>换更能体现 SFT 价值的任务（JSON 输出、多轮对话、固定表格），避开这个数据集的天花板；</li>
<li>想再验证一次“底座决定上限”，可以换 Qwen3-1.7B-Base 重跑同一套脚本，只改 <code>MODEL_NAME</code> 一行。</li>
</ol>
<h2 id="一句话总结">一句话总结</h2>
<p><strong>分数是评委给的，形状是训练给的，知识是预训练给的。</strong></p>
<p>上一篇的 355M 让我看清了“后训练不是知识注入”；这一篇的 Qwen 让我看清了它的另一半——<strong>后训练也不是免费的，它能把知识挤走</strong>。这两句话合起来，才是 SFT 的完整画像。</p>
<hr>
<p><em>前一篇：<a href="https://blog.lvxinrong.com/llm/llm-07-instruction-finetune/">手搓 LLM 笔记 07：指令微调，掩码、表面对齐与 AI 评委</a></em></p>
]]></content:encoded>
    </item>
    <item>
      <title>nanochat 立项书：从零件到整车</title>
      <link>https://blog.lvxinrong.com/llm/nanochat-proposal/</link>
      <pubDate>Mon, 19 Oct 2026 18:40:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/nanochat-proposal/</guid>
      <description>《从零构建大模型》收官，nanochat 立项。书给了我每一块积木，nanochat 要教我积木怎么拼成一辆能跑的车。</description>
      <content:encoded><![CDATA[<blockquote>
<p>这不是教程，是立项书。项目名：nanochat 全链路走读与复现。发起人、执行人、验收人：我自己。评委：Kimi。</p>
</blockquote>
<h2 id="为什么是现在">为什么是现在</h2>
<p>《从零构建大模型》正文收官了。六天，七篇笔记，从 tokenizer 走到 LLM-as-judge。</p>
<p>书给我的是<strong>零件</strong>：注意力、残差、归一化、损失函数、微调。每一块我都拆开看过、手算过、验收过。但零件摊在桌子上，不等于知道车怎么开。一个真实的大模型项目长什么样——数据从哪来、几个训练阶段怎么衔接、评估怎么自动化、模型怎么变成一个能对话的服务——这些书里没讲，也不该它讲。</p>
<p>nanochat（Karpathy 的「100 美元能买到的最好的 ChatGPT」）恰好是这块拼图：约八千行代码，一条完整链路——训练 tokenizer、预训练、中间训练、SFT、可选 RL、自动评估、Web 对话界面。它不是教我新原理的地方，是<strong>让我已经懂的零件第一次组成整车</strong>的地方。</p>
<h2 id="立项的三个理由">立项的三个理由</h2>
<p><strong>一、从懂机制到懂工程。</strong></p>
<p>书的最后一章已经露出苗头了：loss 掩码怎么设计、评估流水线怎么搭、评委怎么校准。这些不是算法，是工程决定。nanochat 里全是这种决定，而且都是一个真正打过大仗的人做的。</p>
<p><strong>二、补全后训练全景。</strong></p>
<p>书里只讲了分类微调和指令微调。nanochat 把预训练 → midtrain → SFT → RL → eval 全串起来了。第七章学到的「表面对齐假说」说能力来自预训练、对齐来自后训练——这句话我要在完整的流水线里亲眼看一遍。</p>
<p><strong>三、给学习 Agent 和 Skill 开源攒本钱。</strong></p>
<p>学习 Agent 需要「懂模型怎么被训练出来」，Skill 开源需要「懂服务怎么被部署起来」。nanochat 两头都占。</p>
<h2 id="项目目标">项目目标</h2>
<p>唯一目标：<strong>以 nanochat 为标准答案，从书里的手搓代码出发，自己造一个 nanochat-lite，训出一个能对话的小模型，并讲清楚每一个阶段在干什么。</strong></p>
<p>施工图见<a href="https://blog.lvxinrong.com/nanochat/lvchat-roadmap/">《lvchat 实现导图》</a>。</p>
<p>验收三条：</p>
<ol>
<li>链路全通：tokenizer → pretrain → mid → SFT → eval → webui，每个阶段都真实跑过，模型可以小，阶段不能跳；</li>
<li>每阶段一篇笔记，规则不变：写下来的必须是我自己搞懂的，没懂的如实写；</li>
<li>主线代码逐行读懂；核心模块（GPT 模型、训练循环、数据管线）能手讲流程。</li>
</ol>
<h2 id="军规">军规</h2>
<ol>
<li>延续「学前探针 → 学中对照 → 学后验收 → 错处入笔记」，Kimi 继续当评委；</li>
<li>nanochat 代码量大，手敲军规调整为：<strong>主线逐行读懂，核心模块关键段落手敲或脱稿复述，外围工具脚本允许直接用</strong>——不搞形式主义；</li>
<li>不囤资料：就这一个仓库，加上手边的书当字典；</li>
<li>每天节奏：第二遍回顾 1 小时 + nanochat 主线 + 骑车 1 小时。学习和身体是两条腿；</li>
<li>英文原文练兵：nanochat 的 README、注释、Karpathy 的文章一律读原文，AI 伴读不代读；</li>
<li>可以砍深度（depth），不砍链路；可以放弃，但必须写一份正式的「放弃说明」。</li>
</ol>
<h2 id="环境策略">环境策略</h2>
<ul>
<li>M4 MacBook：走读代码、写笔记、轻量实验；</li>
<li>Windows + 4070Ti 12G：跑缩小 depth 的完整链路；</li>
<li>租 GPU：如果需要跑一次官方 speedrun 规格，再开，预算封顶 500 元，checkpoint 全部回传 R730 存档；</li>
<li>R730 服务器：checkpoint、数据、实验记录的归档中心。</li>
</ul>
<h2 id="风险与对策">风险与对策</h2>
<ul>
<li><strong>显存不够</strong>：4070Ti 12G 跑不动官方默认深度。对策：砍 depth 不砍链路，链路体验优先；</li>
<li><strong>英文文档</strong>：老债，十年了。对策：见军规第五条，这次是需求倒逼，躲不掉正好；</li>
<li><strong>三分钟热度</strong>：对策不变，公开笔记，让围观成为约束；</li>
<li><strong>股票、游戏、睡眠</strong>：对策：工作日规则延续，骑车计入每日硬指标。</li>
</ul>
<h2 id="立项批复">立项批复</h2>
<p>批准人：吕炘嵘。</p>
<p>批复意见：同意立项。零件已齐，开始造车。落子无悔，愿赌服输。</p>
<p>立项日期：2026 年 10 月 19 日。</p>
<hr>
<p><em>上一季：<a href="https://blog.lvxinrong.com/llm/">《从零构建大模型》系列笔记</a>。明天：第二章回顾 + nanochat 环境搭建。</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 07：指令微调，掩码、表面对齐与 AI 评委</title>
      <link>https://blog.lvxinrong.com/llm/llm-07-instruction-finetune/</link>
      <pubDate>Mon, 19 Oct 2026 18:25:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-07-instruction-finetune/</guid>
      <description>第七章把 GPT-2 微调成一个能听指令的模型：不换头、不冻结、全参数。数据管道里的 +1 和 -100 两根针脚、CPU 和 MPS 的一百倍差距、DeepSeek 当评委给出的 34 分，和 57 个 0 分背后的能力肖像。</description>
      <content:encoded><![CDATA[<blockquote>
<p>第七章把第六章那个会「分类」的 GPT-2 改造成一个能「听指令」的模型。数据管道抠出了两根针脚（+1 和 -100），训练时被 CPU 坑了一次，评估时亲手测出了「评委不同，分数不可比」。系列规则不变：写下来的必须是我自己搞懂的，答错的如实写。</p>
</blockquote>
<h2 id="一这一章在做什么不换头不冻结只换数据">一、这一章在做什么：不换头、不冻结、只换数据</h2>
<p>第六章分类微调：换掉输出头（50257 → 2），冻结大部分参数，只训最后一块 + 新头。</p>
<p>第七章指令微调：<strong>不换头、不冻结、全参数训练</strong>。模型结构和预训练时一模一样，输出还是 50257 维的 next-token 预测。改变的只有数据——从「连续文本」换成「指令 + 回答」的成对样本（1100 条，Alpaca 风格模板）。</p>
<pre tabindex="0"><code>Below is an instruction that describes a task. Write a response
that appropriately completes the request.

### Instruction:
{指令}

### Input:
{输入（可空）}

### Response:
{回答}
</code></pre><p>套模板这个动作，我学前预测时答对了方向：<strong>结构化本身就是模型要学习的内容</strong>。模板让模型学会「哪里是指令、哪里是回答」，推理时必须用同一个模板，套错了模型就不认识。</p>
<h2 id="二学前探针与验收约定">二、学前探针与验收约定</h2>
<p>这章开始和 Kimi 约定：学前探针只问主干（目标函数、数据流、结构差异），shape、API、参数细节放到学后验收。四个主干探针：</p>
<ul>
<li>Q1（目标函数）：指令微调的 loss 和预训练只差一个动作——掩码。✅</li>
<li>Q2（数据量）：几千条样本为什么够？✅（见第四节）</li>
<li>Q3（模板与停止）：模板让模型学会在哪里结束。✅</li>
<li>Q4（评估）：没有标准答案怎么规模化评估？✅（见第五节）</li>
</ul>
<h2 id="三数据管道验收7174">三、数据管道验收（7.1–7.4）</h2>
<h3 id="验收-q1两种填充">验收 Q1：两种填充</h3>
<p>inputs 用 50256 pad 对齐 batch；targets 同样先补 50256，再把<strong>除第一个之外</strong>的所有 50256 替换成 -100（<code>cross_entropy</code> 的默认 <code>ignore_index</code>，传进去自动跳过）。</p>
<p>保留第一个 50256 不掩盖，是为了让模型学会「说完就停」——把结束的权利交给模型自己。我第一遍把 50256 写成了 50257（词表大小），手误，但要警惕：词表 50257 个词，最后一个 id 是 50256。</p>
<p>推论：inputs 里的 padding 虽然参与前向计算，但它们对应的 targets 位置已经是 -100，所以 padding 对 loss 的贡献是零。</p>
<h3 id="验收-q2错位一位与-1">验收 Q2：错位一位与 +1</h3>
<p><code>inputs = padded[:-1]</code>、<code>targets = padded[1:]</code>，错位一位是 next-token 监督，和预训练一致。</p>
<p><code>batch_max_length = max(len) + 1</code> 的 <code>+1</code> 不是防越界（我第一遍答错了），而是<strong>给结束符留位置</strong>：多塞的 50256 经过错位后恰好落在「回答最后一个 token」的下一格，保证每个样本都包含「回答说完 → 出 50256」这条监督信号。</p>
<p>+1 和「保留第一个 50256 不掩盖」是同一个设计的两半：一个留位置，一个放行信号。</p>
<p>训练结束后这个设计在屏幕上跑了出来：</p>
<pre tabindex="0"><code>### Response: The meal is prepared every day by the chef.&lt;|endoftext|&gt;
</code></pre><p>模型答完主动输出了 <code>&lt;|endoftext|&gt;</code>——它学会了说「我说完了」。</p>
<h3 id="验收-q3指令部分盖不盖答错了记三笔账">验收 Q3：指令部分盖不盖——答错了，记三笔账</h3>
<p>问题：targets 里要不要把指令部分的 token 也置成 -100，让 loss 只在回答上累加？</p>
<p>我的结论（不盖）碰巧和书里默认一致，但论证错了两处：</p>
<ol>
<li><strong>BERT 类比是概念错位。</strong> 我以为「盖住指令有点像 BERT 让模型猜结论」。错。这里的掩码只发生在 targets 的 loss 层，inputs 原封不动，模型完整读到指令。三种 mask 分管三层：BERT 的 <code>[MASK]</code> 是输入 token（模型看不见），GPT 的 causal mask 在注意力矩阵（挡未来位置），SFT 的 loss mask 只影响梯度（不影响可见性）。</li>
<li><strong>指令微调是全部权重参与训练。</strong> 我以为「不是更新全部权重」。错。第六章冻结了大部分参数，第七章不做任何冻结——全参数、同结构、换数据。</li>
</ol>
<p>盖住指令的真实理由是「监督信号的焦点」：要让模型学会的行为是写回答，不是写指令。小数据集上两者差别不大，但业界主流 SFT 默认 completion-only。nanochat 阶段会再遇到这个开关。</p>
<h2 id="四为什么两轮就够了表面对齐假说">四、为什么两轮就「够了」：表面对齐假说</h2>
<p>训练只跑了 2 个 epoch，train loss 2.74 → 0.30，val loss 2.72 → 0.62，曲线平滑无过拟合。为什么这么快？</p>
<p><strong>因为指令微调不是学知识，是学姿势。</strong></p>
<ol>
<li><strong>知识早就在了。</strong> GPT-2 medium 预训练时见过几十亿 token，语法、常识全会。这两轮没有教任何新知识，教的是：看到 <code>### Instruction:</code> 就进入听话模式，回答要干脆，说完要吐 <code>&lt;|endoftext|&gt;</code>。这是行为格式的对齐，低维、好学。</li>
<li><strong>数据集高度同构。</strong> 1100 条、同一个模板、短平快回答，274 次梯度更新足够摸熟。</li>
<li><strong>loss 要会读。</strong> 交叉熵 0.657 ≈ 困惑度 1.93——但验证集和训练集同分布，窄分布上的低困惑度不等于通用能力。</li>
</ol>
<p>这个领域有个著名说法叫<strong>表面对齐假说</strong>（Superficial Alignment Hypothesis）：模型的能力几乎全部来自预训练，后训练只是调整它和人打交道的方式。我的 57 个 0 分（见下节）就是这个假说的实验证据。</p>
<h2 id="五训练事故cpu-和-mps-的一百倍">五、训练事故：CPU 和 MPS 的一百倍</h2>
<p>第一次训练，5 步跑了 3 分钟。原因：书里的代码是 <code>cuda if available else cpu</code>，Mac 没有 CUDA，直接落到 CPU。355M 全参数在 CPU 上，2 个 epoch 要 5 小时以上。</p>
<p>越等越不敢杀——这是沉没成本在拽人。正确的判断是：杀不杀和已经等了多久无关，只和继续等值不值有关。杀掉，改 MPS，重跑：<strong>完整训练 2 分 45 秒</strong>。一百多倍的差距。</p>
<p>这条纪律钉死：<strong>训练前先确认 device，确认方式是看日志第一行打出来的 device，不是凭感觉。</strong></p>
<p>device 改动是大肥鱼（另一个 AI）协助的，我做了口头验收：写死的 cpu 改成统一 device 变量，两处；权重加载走「先落 CPU 再 <code>.to(mps)</code>」的稳妥路径（<code>map_location=&quot;mps&quot;</code> 历史上有兼容性问题）。Kimi 又纠了我两个工程观念：</p>
<ul>
<li>张量要<strong>创建时就指定 device</strong>（<code>torch.tensor(data, device=device)</code>），而不是创建后 <code>.to(device)</code> 搬运——一搬 vs 百搬</li>
<li>device 要<strong>单一事实来源</strong>：把 <code>device_mac_util.py</code> 升级成 <code>get_device()</code> 函数，所有脚本共用，换 CUDA 机器一行业务代码都不用改。（已记入学习回炉待办）</li>
</ul>
<h2 id="六评估deepseek-当评委">六、评估：DeepSeek 当评委</h2>
<p>书里的评估方案是 LLM-as-judge：让另一个更强的模型给测试集的 110 条回答按 rubric 打分（0~100）。书里用 Ollama 本地跑 Llama 3 8B，我换成了 DeepSeek API——评委更强、不用本地下模型、一百多个请求成本可以忽略。</p>
<p>工程纪律三条：评委 <code>temperature=0</code>；结果文件里记录评委型号和日期（<code>judge: deepseek-flash, 2026-10-19</code>）；请求加重试。</p>
<h3 id="结果3409-vs-5032分数不可比">结果：34.09 vs 50.32，分数不可比</h3>
<p>书里用 Llama 3 当评委拿到 50.32，我用 DeepSeek 拿到 34.09。<strong>这两个分数不能直接比</strong>——分数只在同一个评委内部有意义，它是（模型，评委）这对组合的属性，不是模型自己的属性。</p>
<p>分布更有意思：</p>
<pre tabindex="0"><code>有效打分 110/110  |  mean=33.9  median=0  min=0  max=100
  0 分:   57  ███████████████████████████████
 1-20:    7  ███
21-40:    8  ████
41-60:    7  ███
61-80:    3  █
81-100:  28  ███████████████
</code></pre><p>双峰：57 个 0 分，28 个 81+。我的第一嫌疑是打分解析器坏了（DeepSeek 返回格式和 Ollama 不同，解析失败兜底 0）。查原始数据后反转：评委每次只返回一个数字 token，解析完全正常——<strong>这些 0 分大部分是罪有应得</strong>：</p>
<ul>
<li>氯的化学符号 → 答 C（碳）</li>
<li>疑问句类型 → 答 imperative（祈使句）</li>
<li>1000 克换算 → 答 0.1 千克</li>
<li>用 nostalgia 造句 → 造了一句不含 nostalgia 的</li>
</ul>
<p>Llama 3 的 50 分是宽宏大量，给「听起来像回事」的答案发参与奖；DeepSeek 是铁面判官，错就是 0。</p>
<h3 id="57-个-0-分画出的能力肖像">57 个 0 分画出的能力肖像</h3>
<p>把 0 分和高分按任务类型分开看，模型的真实画像出来了：</p>
<ul>
<li><strong>格式转换类</strong>（主动转被动、造比喻）→ 90+，指令微调<strong>学会了</strong></li>
<li><strong>知识事实类</strong>（化学符号、单位换算）→ 0，指令微调<strong>救不了</strong></li>
</ul>
<p>这就是表面对齐假说的实验版：<strong>微调教姿势，不教知识。</strong> 355M 的底子就这么多知识，1100 条指令只能教会它「怎么答」，教不会它「答什么」。</p>
<h3 id="实测样本节选">实测样本（节选）</h3>
<p><strong>高分区（81–100）</strong>——答得干脆的常识题和格式题：</p>
<blockquote>
<p><strong>指令</strong>：What is the capital of Denmark?
期望：The capital of Denmark is Copenhagen.
模型：The capital of Denmark is Copenhagen.（100 分）</p>
</blockquote>
<blockquote>
<p><strong>指令</strong>：Convert the sentence to passive voice. 输入：The gardener watered the plants.
期望：The plants were watered by the gardener.
模型：The plants were watered by the gardener.（100 分）</p>
</blockquote>
<blockquote>
<p><strong>指令</strong>：Convert the sentence to use an indefinite pronoun. 输入：Someone left a note.
期望：A note was left by someone.
模型：A note was left by someone.（100 分）</p>
</blockquote>
<blockquote>
<p><strong>指令</strong>：What is the chemical symbol for mercury?
期望：Hg.
模型：The chemical symbol for mercury is Hg.（100 分）</p>
</blockquote>
<p><strong>低分区（0 分）</strong>——精确知识、小语种、换算，全是 355M 底子的边界：</p>
<blockquote>
<p><strong>指令</strong>：What is the periodic symbol for chlorine?
期望：The periodic symbol for chlorine is Cl.
模型：The periodic symbol for chlorine is C.（0 分，氯答成了碳）</p>
</blockquote>
<blockquote>
<p><strong>指令</strong>：Create a sentence using the word &rsquo;nostalgia&rsquo;.
期望：Nostalgia washed over her as she looked through the old photos.
模型：The past was a distant memory.（0 分，句子本身不差，但没用 nostalgia 这个词）</p>
</blockquote>
<blockquote>
<p><strong>指令</strong>：Convert 1000 grams to kilograms.
期望：1000 grams is equal to 1 kilogram.
模型：1000 grams is 0.1 kilograms.（0 分）</p>
</blockquote>
<blockquote>
<p><strong>指令</strong>：Convert 7 kilometers to meters.
期望：7 kilometers is 7000 meters.
模型：7 kilometers is 7.048 meters.（0 分，错得一本正经还精确到小数点）</p>
</blockquote>
<blockquote>
<p><strong>指令</strong>：Translate &rsquo;library&rsquo; into Spanish.
期望：The Spanish word for &rsquo;library&rsquo; is &lsquo;biblioteca&rsquo;.
模型：Están llegarme.（0 分， multilingual 直接崩了）</p>
</blockquote>
<blockquote>
<p><strong>指令</strong>：What is the past tense of &lsquo;sing&rsquo;?
期望：The past tense of &lsquo;sing&rsquo; is &lsquo;sang.&rsquo;
模型：The past tense of ‘sing’ is “to sing.”（0 分）</p>
</blockquote>
<p>高分区也不全是格式题——丹麦首都、汞的符号这种「大众常识」它答得上来；一碰到精确换算、小语种、罕见知识就露馅。所以更准确的分界线是：<strong>预训练语料里高频出现的东西能保住，低频的保不住</strong>。微调没有增加任何一边的库存。</p>
<h2 id="七本章的新概念kv-cache">七、本章的新概念：KV cache</h2>
<p>学这章的晚上突然反应过来：KV cache 就是 trf 里 Q/K/V 的那个 K 和 V。谜底就在谜面上。</p>
<p>因果注意力下，生成第 n+1 个 token 时只有它的 Q 是新的；之前 token 的 K、V 在生成那步已经算完且永不变，存下来复用即可。而我的 <code>generate()</code> 每生成一个 token 就把整段序列重新过一遍模型——KV cache 消掉的就是这个重复劳动。再看新闻里「KV Cache 压缩」，就知道它在省什么了。</p>
<h2 id="八欠账记入学习回炉待办">八、欠账（记入学习回炉待办）</h2>
<ol>
<li><code>device_mac_util.py</code> 升级成 <code>get_device()</code> 单一入口</li>
<li>checkpoint 标准化：权重 + config + optimizer + val_loss 一起存，文件名带语义</li>
<li>GGUF 化 + Ollama 部署：<code>.pth</code> → HF 格式 → GGUF → Modelfile，和自己微调的 355M 聊天（nanochat 部署链的预演）</li>
<li>双评委评估：DeepSeek + 本地模型交叉打分（2025 年「一个命题喂多个大模型」想法的第一个落地场景）</li>
</ol>
<h2 id="九一句话总结">九、一句话总结</h2>
<p>指令微调没有新算法，全是针脚：一个 +1、一个 -100、一个模板、一个评委。模型的「听话」不在模型里，在这些决定里。</p>
<h2 id="十系列收官第一份完整答卷">十、系列收官：第一份完整答卷</h2>
<p>到这一章，《从零构建大模型》的正文走完，这个系列的第一季收官。最后把这份答卷的分数原样贴上——不好看，但它是我自己的模型、自己的评委、自己的数据：</p>
<pre tabindex="0"><code>评委：DeepSeek (deepseek-flash)，2026-10-19，temperature=0
对象：GPT-2 medium (355M)，1100 条指令数据微调 2 个 epoch
测试集：110 条

有效打分 110/110  |  mean=33.9  median=0  min=0  max=100
  0 分:   57  ███████████████████████████████
 1-20:    7  ███
21-40:    8  ████
41-60:    7  ███
61-80:    3  █
81-100:  28  ███████████████
</code></pre><p>从笔记 00 的立项书到今天，手上多了这些东西：一个手敲的分词流程、一套从单头到多头的注意力、一个 124M 的 GPT、一次小规模预训练和它的过拟合曲线、一个垃圾短信分类器、一个会听指令会说「我说完了」的 355M、以及一套给它打分还被评委上了一课的评估流水线。</p>
<p>分数不好，但证据链完整。接下来是第二遍回顾（欠的手写回炉在<a href="https://blog.lvxinrong.com/llm/backlog/">学习回炉待办</a>里），回顾和 nanochat 同步开始。</p>
]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 06：分类微调，从数据管道到换头</title>
      <link>https://blog.lvxinrong.com/llm/llm-06-class-finetune/</link>
      <pubDate>Fri, 16 Oct 2026 16:21:31 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-06-class-finetune/</guid>
      <description>第六章从 SpamDataset 的固定位置、padding 和 DataLoader 开始，到分类头、参数冻结和一次真实的 spam / not spam 判定结束。跑通只是第一关，验收和工程化还没结束。</description>
      <content:encoded><![CDATA[<blockquote>
<p>第六章要把第五章那个会“续写”的 GPT-2 改造成一个二分类器。数据管道先把我拦了一次；6.1 到 6.5 学完后，Kimi 又用五道题验收了一遍；下午最后把 <code>classify_review</code> 跑到了真实的 spam / not spam。系列规则不变：写下来的必须是我自己搞懂的，没懂的如实写“没懂”。</p>
</blockquote>
<h2 id="一这一章在做什么把续写改成判定">一、这一章在做什么：把「续写」改成「判定」</h2>
<p>第五章结束时，我手上是一个加载了 GPT-2 权重、能续写英文的模型。第六章不换架构、不重训主体，只换两样东西：输出层从 50257 维换成 2 维，训练目标从 next-token 预测变成类别判断。</p>
<p>这里要分清三件事：《The Verdict》是第五章的小规模预训练演示语料；GPT-2 权重是 OpenAI 预训练得到的参数起点；SMS 垃圾短信是第六章监督微调使用的数据。<strong>不是把 GPT-2 的训练语料从《The Verdict》换成 SMS。</strong></p>
<p>微调分两类，这本书用两章各讲一种：第六章是<strong>分类微调</strong>（输出是一个类别标签），第七章是指令微调（输出还是文本，但变成听话的文本）。分类微调的损失函数还是交叉熵，区别在于<strong>只在某一个位置上算</strong>——这一处和第五章的差别，6.6 里已经看到，但还没有单独做问答验收。</p>
<p>这一篇覆盖 6.1 到 6.8：数据准备、DataLoader、换输出头、参数冻结、训练和最终推理。它本来该是全章最没戏剧性的部分，结果数据管道和推理脚本都留下了账。</p>
<h2 id="二spamdataset真正要盯住的是固定位置">二、<code>SpamDataset</code>：真正要盯住的是固定位置</h2>
<p><code>SpamDataset</code> 要做的事很清楚：把 CSV 里的短信逐条 tokenize，再统一长度。训练集传 <code>max_length=None</code>，让它自己找最长；验证集和测试集传 <code>train_dataset.max_length</code>，让它们沿用训练集的长度。</p>
<p>我自己手写时还把 <code>is None</code> 和 <code>is not None</code> 写反过一次，但那只是手快，不值得展开。真正需要留下的是：<strong>为什么训练集、验证集、测试集必须共享同一个 <code>max_length</code>。</strong></p>
<p>分类微调取的是<strong>某个固定位置</strong>的输出。书上取最后一个位置；训练集最长是 120 个 token，取到的就是第 120 个。训练时模型只在这个位置上被优化过。验证集的长度一变，位置就跟着变，等于拿一个没训过的位置去评估。</p>
<p>另一个真正踩到的错误是列名大小写。数据集处理时做过一次 <code>balanced_df[&quot;Label&quot;].map({&quot;ham&quot;: 0, &quot;spam&quot;: 1})</code>，所以 CSV 里的列名是 <code>Label</code>、值是 0 和 1。我写成了小写 <code>label</code>，取样本时报 <code>KeyError</code>。</p>
<h2 id="三drop_last只作用在最后一个不满的-batch-上">三、<code>drop_last</code>：只作用在最后一个不满的 batch 上</h2>
<p><code>DataLoader(train_dataset, batch_size=8, shuffle=True, drop_last=True)</code>。我一开始不知道 <code>drop_last</code> 是什么，去问了一遍。</p>
<p>DataLoader 是按固定 <code>batch_size</code> 顺序切块的。样本总数不整除 <code>batch_size</code> 时，最后一块会短一截。<code>drop_last=True</code> 就是把最后这块<strong>不要了</strong>，<code>False</code>（默认）则照发。</p>
<p>第六章的数据是训练集 1045 条、验证集 149 条、测试集 300 条，<code>batch_size = 8</code>：</p>
<ul>
<li>训练集 <code>1045 = 8 × 130 + 5</code>，<code>drop_last=True</code>，最后那 5 条被丢，一轮 130 个 batch</li>
<li>验证集 <code>149 = 8 × 18 + 5</code>，<code>False</code>，第 19 个 batch 只有 5 条</li>
<li>测试集 <code>300 = 8 × 37 + 4</code>，<code>False</code>，最后一个 batch 4 条</li>
</ul>
<p>所以它<strong>只在训练集那条 DataLoader 上有实际效果</strong>，影响的是 5 条样本。</p>
<p>训练用 <code>True</code> 的理由只有一个：让每个 batch 的形状恒定，训练循环里不会隔一阵冒出一个 <code>(5, 120)</code>。评估反过来必须是 <code>False</code>，因为<strong>评估的语义是在全部样本上算指标</strong>——丢掉最后一块，那 4 到 5 条样本就从头到尾没被评估过，而打印出来的依然是个正常的百分数，看不出少了样本。</p>
<p>有一个前提容易被忽略：<code>drop_last=True</code> 不丢数据，是<strong>因为同时开着 <code>shuffle=True</code></strong>。被丢的那 5 条每轮都不一样，多轮下来全会轮到。如果哪天把 <code>shuffle</code> 关掉，<code>drop_last=True</code> 就变成永远丢掉同一批尾巴。</p>
<h2 id="四shuffle它是一个参数不是一个占位符">四、<code>shuffle</code>：它是一个参数，不是一个占位符</h2>
<p>我一直以为 <code>shuffle</code> 是占位符。它不是。它只决定一件事：<strong>DataLoader 以什么顺序把样本切进 batch。</strong></p>
<p>DataLoader 每轮迭代做三步：产出 index、用 index 去调 <code>Dataset.__getitem__</code> 取样本、把这些样本拼成 batch。<code>shuffle</code> 管的是第一步。<code>False</code> 时 index 就是 <code>0,1,2,3,...</code>；<code>True</code> 时先对整个 index 列表做一次随机排列，再按这个顺序切。</p>
<p>两个容易搞错的点：</p>
<ul>
<li><strong>打乱的是 index 的顺序，不是数据本身。</strong> <code>train_dataset.encoded_texts</code> 一个字都没变，<code>train_dataset[3]</code> 永远返回第 3 条。我在 <code>__init__</code> 里做的 tokenize、截断、padding 和 <code>shuffle</code> 完全无关。</li>
<li><strong>是每个 epoch 重新打乱一次</strong>，不是开头打乱一次。这也是上一节那个结论的前提。</li>
</ul>
<h3 id="为什么训练必须打乱">为什么训练必须打乱</h3>
<p>我用一个 24 条、<strong>按标签排好序</strong>的假数据集跑了一遍（前 12 条标签 0，后 12 条标签 1），<code>batch_size=8</code>：</p>
<ul>
<li><code>shuffle=False</code> 时，三个 batch 的标签依次是 <code>[0,0,0,0,0,0,0,0]</code>、<code>[0,0,0,0,1,1,1,1]</code>、<code>[1,1,1,1,1,1,1,1]</code>——有的 batch 全是同一类</li>
<li><code>shuffle=True</code> 时，三个 batch 都是混着的</li>
</ul>
<p>不打乱时，每个 batch 就不是“从总体里随机抽出的一小撮”，而是一个有偏样本。而 <code>loss.backward()</code> 给的是这个 batch 平均 loss 的梯度——<strong>mini-batch 的梯度要能代表总体，前提是它是随机抽的</strong>。</p>
<p>第六章的真实数据有同样的风险：作者在仓库讨论区里算过，spam 平均 41.67 个 token、ham 平均 19.85 个，标签和长度是相关的。CSV 一旦有系统性排序，不打乱就会让每个 batch 的长度和标签一起偏向一边。</p>
<p>还有一层是随机性本身的正则化效果（SGD 的噪声帮模型避开尖锐的极小值）。这一条是经验性的，不是定理，我先记下不下结论。</p>
<h3 id="val-和-test-为什么是-false">val 和 test 为什么是 <code>False</code></h3>
<p>我当时的总结是：<code>True</code> 就是随机顺序，<code>False</code> 就是原本的顺序，这解释了 train 用 <code>True</code>、val 和 test 用 <code>False</code>。前半句完全对，后半句要加一层。</p>
<p>我实测过：<strong>评估是对所有样本求和再除，和顺序无关。</strong> 同一个模型、同一批 149 条数据，<code>shuffle</code> 开和关，准确率一模一样（都是 <code>0.550336</code>），loss 只差在第三位小数——那是逐 batch 平均和逐样本平均的差别。</p>
<p>所以 val/test 用 <code>False</code> 不是“否则会算错”，而是两件更小的事：</p>
<ul>
<li><strong>可比。</strong> 训练中每 50 步调一次评估，而 <code>evaluate_model</code> 只取前 5 个 batch。<code>False</code> 时这 5 个 batch 每次都是同一批样本，loss 的起伏只反映模型；<code>True</code> 时每次抽到不同的样本，我就分不清是模型在抖还是抽样在抖。</li>
<li><strong>可复现。</strong> 不引入随机性，就不用额外操心随机种子。</li>
</ul>
<p>它是零成本的改进，所以选它——但它和训练那里的 <code>shuffle=True</code> 不是一个量级的事。</p>
<blockquote>
<p>打乱的目的是让每个 batch 成为总体的无偏小样本（梯度估计问题），不是防止模型记住顺序（它没记忆）；评估不打乱是为了同一批样本、每次可比，不是因为随机顺序会算错——准确率对顺序完全免疫。</p>
</blockquote>
<h2 id="五两个开关两个不相干的理由">五、两个开关，两个不相干的理由</h2>
<p><code>shuffle</code> 和 <code>drop_last</code> 恰好是同一个取值模式（训练都是 <code>True</code>，评估都是 <code>False</code>），但理由完全不相干：</p>
<ul>
<li><code>shuffle</code>：随机性只在训练里有价值（梯度无偏），评估要的是可比和可复现</li>
<li><code>drop_last</code>：训练要形状恒定，评估要覆盖每一条样本</li>
</ul>
<p>我差点把它总结成“训练要乱的、评估要齐的”。这种口号一旦成立，遇到下一个参数就会套错模板。<strong>同一个取值模式，不等于同一个原因。</strong></p>
<h2 id="六五题验收每个问题都漏了一点">六、五题验收：每个问题都漏了一点</h2>
<p>6.1 到 6.5 看完后，我的体感是：第六章比第三、四、五章顺。于是我让 Kimi 出了五道题。答完以后发现，主线基本都抓住了，但每一题都有遗漏。这里按题目记录，专门留给以后回炉。</p>
<h3 id="1-换头不是从-50257-压到-2">1. 换头不是「从 50257 压到 2」</h3>
<p><strong>Kimi 原题：</strong></p>
<blockquote>
<p><strong>Q1：换头为什么就换了任务？</strong></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">out_head</span> <span class="o">=</span> <span class="n">Linear</span><span class="p">(</span><span class="mi">768</span><span class="p">,</span> <span class="mi">50257</span><span class="p">)</span>
</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">out_head</span> <span class="o">=</span> <span class="n">Linear</span><span class="p">(</span><span class="mi">768</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
</span></span></code></pre></div><p>这两个输出数值分别代表什么？为什么把输出头从 50257 换成 2，就能让同一个 GPT 主体做垃圾短信分类，而不是继续预测 next-token？</p>
<p>另外，你之前猜过「保留 50257 个输出，只取 spam 和 ham 两个词」。和直接换成二分类头相比，这两种方案的本质区别是什么？</p>
</blockquote>
<p>我一开始有三个说法不准确：把分类微调说成了无监督学习，把输出说成了概率，还把结构理解成“先得到 50257 个输出，再压缩成 2 个”。</p>
<p>修正后的理解是：</p>
<ul>
<li>训练数据包含文本和 label，所以分类微调是<strong>监督学习</strong>。<code>map({&quot;ham&quot;: 0, &quot;spam&quot;: 1})</code> 只是把人已经标注好的类别转换成数字，不是模型在替训练数据分类。</li>
<li>新输出头直接给出 ham 和 spam 的两个 logits，不是概率；softmax 之后才能解释成概率。</li>
<li>旧输出头是 <code>Linear(768, 50257)</code>，新输出头是 <code>Linear(768, 2)</code>。旧头被整个替换，不存在中间的 50257 维。</li>
<li>0 和 1 哪个是 ham、哪个是 spam，由 label 编码决定。训练做的事情，是让正确类别对应的 logit 更高。</li>
</ul>
<p>我之前说“二分类头类似掩盖住了其他词”，方向接近，但更准确的说法是：<strong>整个输出空间被换掉了</strong>。新头不再从词表里挑 token，而是直接学习两个类别的方向。</p>
<h3 id="2-欠采样裁的是多数类样本">2. 欠采样裁的是多数类样本</h3>
<p><strong>Kimi 原题：</strong></p>
<blockquote>
<p><strong>Q2：平衡数据集的代价是什么？</strong></p>
<p>原始数据里正常短信远多于垃圾短信，书中通过减少多数类样本让两类数量相同。</p>
<ol>
<li>如果不做平衡，模型可能学成什么样？</li>
<li>欠采样解决了问题，同时付出了什么代价？</li>
<li>为什么还需要独立的 validation 和 test，不能看 test 结果反复调方案？</li>
</ol>
</blockquote>
<p>这一题我只会说“为了让 0 和 1 数量一致”，没答出代价。</p>
<p>书中的多数类是 ham，少数类是 spam。欠采样就是从多数类里少取一些，让两边数量相同。这里裁掉的是样本条数，不是文本长度。</p>
<p>代价很直接：大量真实 ham 被丢掉，模型能看到的正常短信变少；留下哪些样本还会带来随机性。训练集被改成 50 : 50 以后，也不再等于真实世界的短信分布，所以模型输出的概率不能直接当成现实概率。</p>
<p>train、validation、test 的分工也重新钉了一遍：</p>
<ul>
<li>train：计算梯度，更新参数</li>
<li>validation：不更新参数，用来选 epoch、调方案、early stopping</li>
<li>test：不参与任何选择，最后评估一次</li>
</ul>
<p>独立划分不能保证不过拟合，只能帮助发现过拟合。反复根据 validation 调方案，也会逐渐过拟合 validation。</p>
<h3 id="3-batch-形状和-padding我答错了两处">3. batch 形状和 padding，我答错了两处</h3>
<p><strong>Kimi 原题：</strong></p>
<blockquote>
<p><strong>Q3：padding 和 max_length 到底做了什么？</strong></p>
<p>假设训练集中最长文本编码后有 120 个 token，batch_size=8。</p>
<ol>
<li>一个 batch 的 <code>input_batch</code> 和 <code>target_batch</code> 分别是什么 shape？</li>
<li>一条只有 35 个 token 的短信，进入 Dataset 后会发生什么？</li>
<li>validation 里如果有一条 130 个 token 的短信，而 <code>max_length</code> 使用的是训练集的 120，又会发生什么？</li>
<li>为什么这里可以直接用 50256 填充？它原本是哪个特殊 token？</li>
</ol>
</blockquote>
<p>我一开始把 batch 的第一维写成了“训练样本数 / 8”。这是把<strong>批次数</strong>当成了<strong>每批样本数</strong>。</p>
<p>假设训练集有 N 条样本，<code>batch_size=8</code>、<code>max_length=120</code>：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">批次数 ≈ N / 8
</span></span><span class="line"><span class="cl">input_batch  = (8, 120)
</span></span><span class="line"><span class="cl">target_batch = (8,)
</span></span></code></pre></div><p><code>target_batch</code> 是 8 个正确类别编号，不是模型输出，也不需要写成 <code>(8, 1)</code>。</p>
<p>更大的错误是 padding。我以为 35 个 token 只需要补一个结束符，实际上会补齐到 120：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">35 个 token + 85 个 50256 = 120 个 token
</span></span></code></pre></div><p>如果 validation 里有 130 个 token，而 <code>max_length</code> 使用训练集的 120，就会保留前 120 个，截掉最后 10 个。</p>
<p><code>50256</code> 是 GPT-2 的 <code>&lt;|endoftext|&gt;</code>。这里复用它作为 <code>pad_token_id</code>，不是新造了一个 <code>[PAD]</code>。</p>
<h3 id="4-padding-的最后位置为什么还能分类">4. padding 的最后位置为什么还能分类</h3>
<p><strong>Kimi 原题：</strong></p>
<blockquote>
<p><strong>Q4：最容易被忽略的一问——为什么取最后一个位置？</strong></p>
<p>假设一条真实文本只有 5 个 token，右侧 padding 到 8 个。分类时却使用：</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">logits</span> <span class="o">=</span> <span class="n">model</span><span class="p">(</span><span class="n">input_batch</span><span class="p">)[:,</span> <span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="p">:]</span>
</span></span></code></pre></div><p>也就是取第 8 个位置，而不是真实文本的第 5 个位置。</p>
<p>这个 padding 位置凭什么能代表前面的真实文本？请结合因果掩码下每个位置能看见哪些 token 来解释。</p>
<p>再追问一句：如果换成双向注意力，「只有最后一个位置能看到完整前文」这个理由还成立吗？</p>
</blockquote>
<p>这一题我答上来了：在因果掩码下，一个位置只能看到自己和它左边的 token，所以最后一个位置可以看见完整前文。即使最后位置是 padding，它的注意力计算也能覆盖前面的真实 token。</p>
<p>更精确地说，点积只是 Q 和 K 的打分；真正写入当前位置的是 softmax 之后对 V 的加权汇总，再经过多层 Transformer Block。最后一个位置的隐藏状态因此可以作为整段文本的上下文表示。</p>
<p>双向注意力是我遇到的新名词。它和因果注意力的区别是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">因果注意力：位置 i 能看 0 ... i
</span></span><span class="line"><span class="cl">双向注意力：位置 i 能看 0 ... T-1
</span></span></code></pre></div><p>GPT 因为不能偷看未来，所以用因果注意力。双向注意力下，每个位置都能看到完整序列，「取最后一个位置」就不再是必须的选择。</p>
<h3 id="5-冻结参数冻结更新不冻结计算">5. 冻结参数：冻结更新，不冻结计算</h3>
<p><strong>Kimi 原题：</strong></p>
<blockquote>
<p><strong>Q5：冻结参数到底冻结了什么？</strong></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="k">for</span> <span class="n">param</span> <span class="ow">in</span> <span class="n">model</span><span class="o">.</span><span class="n">parameters</span><span class="p">():</span>
</span></span><span class="line"><span class="cl">    <span class="n">param</span><span class="o">.</span><span class="n">requires_grad</span> <span class="o">=</span> <span class="kc">False</span>
</span></span></code></pre></div><p>然后又替换 <code>out_head</code>，并解冻最后一个 Transformer Block 和 <code>final_norm</code>。</p>
<ol>
<li><code>requires_grad = False</code> 之后，这些参数还会参与前向计算吗？模型的输出会因此变成固定值吗？</li>
<li>冻结之后才创建的新 <code>Linear(768, 2)</code>，默认会被训练吗？</li>
<li>为什么不只是训练新分类头，也不直接把整个模型全部解冻？「只训头部」「只解冻最后一部分」「全量微调」三种方案分别在拿什么交换什么？</li>
</ol>
</blockquote>
<p><code>requires_grad = False</code> 的含义是参数仍然参与前向计算，但反向传播时不计算它的梯度，optimizer 也不更新它。</p>
<p>我一开始拿 <code>top_k</code>、温度和 <code>multinomial</code> 来证明输出不固定，这个理由错了。采样发生在得到 logits 之后，而且分类微调不调用 <code>generate</code>。输出仍可能变化，是因为输入不同、新分类头还在训练、<code>model.train()</code> 时 dropout 仍然生效。</p>
<p>冻结旧模型之后再创建新的 <code>nn.Linear</code>，新参数默认 <code>requires_grad=True</code>，所以新分类头会正常训练。</p>
<p>三种训练范围也重新分清了：</p>
<ul>
<li><strong>只训分类头</strong>：也叫 linear probe。它不是没学分类，而是在冻结特征上学习一个分类边界。最省资源，但模型无法调整内部表示。</li>
<li><strong>训练最后一个 Block + <code>final_norm</code> + 分类头</strong>：让最高层表示向当前任务靠拢，是成本和适应能力之间的折中。</li>
<li><strong>全量微调</strong>：调整空间最大，但成本最高，也更容易在小数据上过拟合，甚至覆盖预训练学到的通用能力。</li>
</ul>
<p>所以不能说全量微调“当然效果最好”。它只是可调空间最大，最终效果仍取决于数据量、训练成本和过拟合风险。</p>
<h2 id="七能跑不等于可复用推理脚本留下的工程债">七、能跑不等于可复用：推理脚本留下的工程债</h2>
<p>下午最后把 <code>classify_review</code> 跑通了，两个样例分别返回：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">spam
</span></span><span class="line"><span class="cl">not spam
</span></span></code></pre></div><p>这说明推理链路本身是对的：<code>model.eval()</code>、<code>no_grad()</code>、截断、padding、取最后一个位置、argmax、标签映射，全都接上了。</p>
<p>但 Kimi 看完代码后指出：这版是「验证能跑」的脚本，还不是可复用的分类器。后续要补齐的工程债先记在这里：</p>
<ol>
<li><strong><code>max_length=None</code> 会直接报错。</strong> 现在的代码会做 <code>min(None, 1024)</code>，之所以没炸，是因为调用方固定传了 120。要么显式要求必填，要么提供明确的默认策略。</li>
<li><strong><code>max_length</code> 大于上下文长度时会重新 pad 超界。</strong> 应该先算 <code>effective_max_length = min(max_length, context_length)</code>，截断和 padding 都用这个值。</li>
<li><strong><code>max_length=120</code> 和 <code>1=spam</code> 不应该硬编码。</strong> 它们属于训练产物，应该和 <code>model_state_dict</code>、模型配置一起保存进 checkpoint。否则以后重新训练，推理代码不会报错，只会悄悄用错。</li>
<li><strong>加载模型和使用模型要拆开。</strong> 现在每调用一次 <code>classify_review_with_state_model</code>，就重新加载一次模型。批量推理时应该先 <code>load_classifier</code> 一次，再反复调用 <code>classify_review</code>。</li>
<li><strong>推理时没必要先加载原始 GPT-2 权重。</strong> checkpoint 里已经有完整的微调后参数，直接按配置创建模型、替换分类头、加载 <code>state_dict</code> 就够了。</li>
</ol>
<p>后续补这件事的完成标准：</p>
<ul>
<li>checkpoint 同时保存 <code>config</code>、<code>max_length</code>、<code>label_map</code> 和 <code>model_state_dict</code>；</li>
<li>模型只加载一次，可以连续分类多条文本；</li>
<li>推理不再依赖先下载 GPT-2 原始权重；</li>
<li>checkpoint 路径不依赖运行时目录；</li>
<li>从任意目录运行，都能得到同一条分类链路。</li>
</ul>
<p>今天先不改。能跑通是第六章的学习终点之一，可复用是下一步工程化。</p>
<h2 id="八如实记录原来那个问题解决了">八、如实记录：原来那个问题解决了</h2>
<ul>
<li>原来留在这里的问题是“padding 和取最后一个位置叠在一起会怎样”。五题验收的第 4 题已经把它解决：padding 位置本身不聪明，聪明的是<strong>这个位置在因果掩码下拥有完整前文的信息入口</strong>。</li>
<li>6.1 到 6.5 目前没有新的“没懂”，但有两个习惯要继续改：不要把 logits 直接说成概率；不要把批次数写进 batch 形状。</li>
<li>6.6 到 6.8 已经跑通，但分类 loss、accuracy、训练循环和 <code>classify_review</code> 还没有做同样的五题验收，暂时只算「跑通过」，不算「验收过」。</li>
<li>第三、四章的手写回炉不塞进今天，已经单独放到<a href="https://blog.lvxinrong.com/llm/backlog/">《学习回炉待办》</a>。</li>
</ul>
<h2 id="九三问式收尾">九、三问式收尾</h2>
<ol>
<li><strong>今天学了什么</strong>：<code>SpamDataset</code> 为什么必须共享固定位置、<code>drop_last</code> 和 <code>shuffle</code> 的真实职责、分类头输出的是两个类别 logits、欠采样的代价、batch 和 target 的真实形状、最后位置能分类的原因、<code>requires_grad=False</code> 的真实含义，以及一次完整的垃圾短信分类推理；</li>
<li><strong>哪里还没懂</strong>：6.6 到 6.8 还没完成同样的问答验收，<code>classify_review</code> 也还没有达到可复用标准；</li>
<li><strong>接下来干什么</strong>：先验收 6.6 到 6.8，再把推理脚本拆成「加载一次模型」和「重复分类文本」两步。</li>
</ol>
<p><em>方法：数据管道部分我先写、先讲，DeepSeek 指错；6.1 到 6.5 由 Kimi 出题验收；6.6 到 6.8 我先跑通，再由 Kimi 做代码检查。学习时长待我自己补。</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 05：预训练、损失函数与生成</title>
      <link>https://blog.lvxinrong.com/llm/llm-05-pretrain-generate/</link>
      <pubDate>Thu, 15 Oct 2026 17:50:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-05-pretrain-generate/</guid>
      <description>第五章学了两遍：第一遍照抄，第二遍回炉。交叉熵、max 减法、过拟合、温度采样、GPT-2 权重加载，以及 generate 全链路的 shape 变化。</description>
      <content:encoded><![CDATA[<blockquote>
<p>第五章是这本书到目前为止概念密度最高的一章：预训练、损失函数、训练循环、过拟合、解码策略、加载 GPT-2 权重。第一遍我学得很虚——手比脑快，一路照抄。离职后的回炉日，我用「考试 + A4 纸手写」把它重学了一遍。这篇笔记记的是第二遍的理解，以及第一遍踩过的坑。</p>
</blockquote>
<h2 id="一训练到底在优化什么512-张考卷">一、训练到底在优化什么：512 张考卷</h2>
<p>输入是 <code>[a, b, c]</code>，target 是 <code>[b, c, d]</code>——错位一位，每个位置的 target 恰好是 input 同一位置的下一个 token。这就是 next-token 预测落到代码里的样子。</p>
<p>关键在数量级：一个 <code>(2, 256)</code> 的 batch，2 条序列 × 256 个位置 = <strong>512 个独立的预测任务</strong>。<code>logits.flatten(0, 1)</code> 就是把这 512 张考卷摊平，一次 cross entropy 全判完。</p>
<p>这也解释了训练和推理的根本区别：</p>
<ul>
<li><strong>训练</strong>：一次前向，512 个位置并行判分，所有位置的输出全都要（所以输出形状是 <code>(B, T, 50257)</code>）</li>
<li><strong>推理</strong>：一个 token 一个 token 往外蹦，只需要最后一个位置的输出（<code>logits[:, -1, :]</code>）——因为前面位置的「答案」早就在输入里了，只有最后一个位置在预测真正未知的词</li>
</ul>
<p>训练能并行的前提，是第三章的因果掩码：<strong>没有掩码，这 512 道题就全漏题了</strong>。掩码不只是「防止偷看」，它是让并行训练合法化的前提。</p>
<h2 id="二交叉熵不是差值是正确答案的-log-概率取负">二、交叉熵：不是「差值」，是「正确答案的 log 概率取负」</h2>
<p>我以前学机器学习，损失函数就是「预测值 − 目标值」。这个直觉在 LLM 里错了两次才拔掉：</p>
<p>logits 是 <code>(6, 50257)</code> 的矩阵，targets 是 <code>(6,)</code> 的 id 列表——<strong>矩阵怎么减一个 id？</strong> 根本没法减。真实的计算链是：</p>
<ol>
<li>对每一行做 log_softmax（带 max 减法，后面讲）</li>
<li>用 target 的 id 做花式索引，取出<strong>正确 token 对应的 log 概率</strong></li>
<li>取负、求平均 → 标量 loss</li>
</ol>
<p>所以 loss 的准确说法是「模型给正确答案分配的概率，取 log 取负再求平均」。概率越大 → log p 越接近 0 → loss 越小。<strong>「最小化 loss」和「最大化正确答案的概率」是同一件事。</strong> 取负也不是数学必需，只是约定：全世界的优化器都按「最小化」设计，取负把「让 log p 上升」翻译成「让 loss 下降」。</p>
<h3 id="为什么-argmax-不能进-loss">为什么 argmax 不能进 loss</h3>
<p>两个原因，缺一不可：</p>
<ol>
<li><strong>不可导</strong>。argmax 是阶跃操作，输入变一点，输出要么不变要么突变，导数几乎处处为 0。梯度流到它就断了，后面所有权重收不到任何更新信号。</li>
<li><strong>丢失「距离」信息</strong>。正确答案概率 49%（排第二）和 0.001%（排一万名），对 argmax 来说都是「猜错」，loss 一模一样。但前者明明只差一口气——<strong>argmax 把「离正确答案有多近」这个最关键的信息扔掉了</strong>。cross entropy 用概率本身，模型每一点微小进步，loss 都看得见。</li>
</ol>
<p>一句话：argmax 是推理时的选择器，不是训练时的指南针。</p>
<h3 id="花式索引每道题只取自己的分">花式索引：每道题只取自己的分</h3>
<p><code>probas[text_idx, [0, 1, 2], targets[text_idx]]</code>，probas 形状 <code>(2, 3, 50257)</code>。这句在做什么：<strong>取第一个序列三个位置、各自对应的正确 token 的概率，共 3 个值</strong>。</p>
<p><img alt="A4 手写：calc_loss_batch 与各张量的 shape" loading="lazy" src="https://blog.lvxinrong.com/llm/llm-05-a4-calc-loss-batch.jpg"></p>
<p><em>A4 手写稿：calc_loss_batch。inputs 那行一开始写成了 (2, 3, 50257)，正确应为 (2, 3)——id 进，分布出。</em></p>
<h2 id="三max-减法数学上不变工程上救命">三、max 减法：数学上不变，工程上救命</h2>
<p><code>log_softmax</code> 不直接算 <code>log(exp(z_i) / Σexp(z_j))</code>，而是先给所有 logits 减去行内最大值。</p>
<p><strong>为什么结果不变？</strong> <code>e^(z-c) = e^z × e^(-c)</code>，分子分母各提出一个 <code>e^(-c)</code>，约掉。选谁当 c 都行，选 max 只是效果最好。</p>
<p><strong>为什么必须减？</strong> float32 上限约 3.4×10³⁸，而 <code>e^100 ≈ 2.7×10⁴³</code>——装不下，直接溢出成 inf，后面全变 NaN。</p>
<p><strong>减完之后的世界</strong>：行内所有值 ≤ 0，最大项恰好为 0。于是 <code>exp(0) = 1</code> 封住上限，其他项全在 (0, 1]；分母至少是 1（最大项贡献了一个 1），log(分母) 永远不会碰到 log(0)。<strong>上溢下溢，一起消失。</strong></p>
<h2 id="四过拟合我的第一根训练曲线">四、过拟合：我的第一根训练曲线</h2>
<p>第一次训练《The Verdict》（全文才 5145 个 token），10 个 epoch 下来：train loss 一路降到 0.391，val loss 第 2 轮触底后回升到 6.452。教科书级的过拟合现场：模型不是在学语言，是在背课文。early stopping 就该停在第 2 轮附近。</p>
<p>两个防过拟合的旋钮，机制完全不同：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th></th>
        <th>dropout</th>
        <th>weight decay</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>动手对象</td>
        <td>激活值（前向传播时）</td>
        <td>权重本身（参数更新时）</td>
      </tr>
      <tr>
        <td>手法</td>
        <td>随机砍神经元，制造「残缺」</td>
        <td>给大权重的解加「惩罚」</td>
      </tr>
      <tr>
        <td>公式</td>
        <td>保留的激活值 × 1/(1-p)，期望不变</td>
        <td><code>w = w - lr×梯度 - (w × lr × wd)</code></td>
      </tr>
    </tbody>
  </table>
</div>
<p>weight decay 我一开始错写成「减一个固定值」，纠正三次才懂：它是<strong>比例税不是人头税</strong>——合并成 <code>(1 - lr × wd) × w</code> 看得最清楚：<strong>每一步先把所有权重打个 0.99996 的折，再走正常的梯度下降</strong>。大权重被拽得狠，小权重几乎不动。权重小 = 函数平滑 = 想背课文都背不利索。</p>
<h3 id="困惑度ppl把-loss-翻译成人话">困惑度（PPL）：把 loss 翻译成人话</h3>
<p><code>PPL = e^loss</code>，含义是「模型预测下一个词时，平均在多少个候选之间犹豫」：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>模型状态</th>
        <th>loss</th>
        <th>PPL</th>
        <th>含义</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>随机权重</td>
        <td>10.76</td>
        <td>~47,000</td>
        <td>ln(50257) ≈ 10.82，在整个词表里纯蒙</td>
      </tr>
      <tr>
        <td>训 10 轮（train）</td>
        <td>0.391</td>
        <td><strong>1.48</strong></td>
        <td>背过的课文里只在 1.5 个词之间犹豫</td>
      </tr>
      <tr>
        <td>训 10 轮（val）</td>
        <td>6.452</td>
        <td><strong>~635</strong></td>
        <td>没见过的文本上，还要在 635 个词里蒙</td>
      </tr>
    </tbody>
  </table>
</div>
<p>背到 PPL 1.48，泛化只有 PPL 635——过拟合用困惑度表达，就是这么赤裸。</p>
<h2 id="五生成策略argmax-死循环与抽奖箱">五、生成策略：argmax 死循环与抽奖箱</h2>
<p>第一版 <code>generate_text_simple</code> 用 argmax，第 1 轮训练后生成的是 <code>and, and, and, and...</code> 死循环。三环机制：</p>
<ol>
<li><strong>确定性</strong>：同一个前文，argmax 永远选同一个词</li>
<li><strong>自回归反馈</strong>：选出的词拼回上下文，输出变成输入</li>
<li><strong>自我强化</strong>：「and and and」进上下文后，模型更倾向于继续「and」——每一次重复都在给下一次重复投票</li>
</ol>
<p>改进版流水线：<code>logits → top_k 过滤 → 温度缩放 → softmax → multinomial 抽样</code>。</p>
<ul>
<li><strong>top_k 的本质：给采样划一个靠谱的候选池</strong>——next-token 不是唯一解，而是一个分布。全词表任意组合早就失去了句子的连贯性，top_k 把范围框在「都说得通」的前 k 名里：k=1 等价 argmax，k=50257 等于没筛。<strong>连贯和多样不是对立的，top_k 就是那个平衡点</strong>。手法是用第 k 名的分数当门槛，低于门槛的全部打成 -inf（和因果掩码同一手法，目的不同）</li>
<li><strong>温度除的是 logits，不是概率</strong>。T &lt; 1 = 放大差距 = 尖锐（T→0 退化成 argmax）；T &gt; 1 = 压缩差距 = 均衡（T→∞ 退化成均匀分布）。<strong>温度只改赔率，本身完全确定，没有随机性</strong>。和 top_k 的区别：温度调「池子里各候选的胜率」，top_k 定「池子的大小」</li>
<li><strong>multinomial 才是随机性进来的地方</strong>：按概率分布真实抽样。跑 1000 次，88% 的词大约出现 880 次——分布是赔率，抽样是开奖</li>
<li><strong>光调温度救不了 argmax</strong>：z/T 是单调变换，不改变谁最大。温度只有在采样时才起作用</li>
</ul>
<p>实测手感：同一个 GPT-2 权重、同一个 prompt，temperature=1.5 时模型开始胡说「3:50 method」这种不存在的东西；调低就通顺。<strong>多样性和靠谱度是一根滑杆的两端。</strong></p>
<h2 id="六加载-gpt-2-权重权重是序列化对象架构是类定义">六、加载 GPT-2 权重：权重是序列化对象，架构是类定义</h2>
<p>能加载 GPT-2 权重，是因为我的 GPTModel 严格按 GPT-2 的「类定义」写的：12 层、768 维、LayerNorm、学习式位置嵌入、GELU、12 头。<strong>权重文件只对同一个架构有效</strong>——字段名、顺序、shape，差一个都对不上。DeepSeek / Qwen 是另一套类定义（RMSNorm、RoPE、SwiGLU、GQA/MoE），直接灌必炸。</p>
<p>加载代码里的考点：</p>
<ul>
<li><code>attn.c_attn</code> 把 Q、K、V 存在一个融合矩阵里，<code>np.split(..., 3, axis=-1)</code> 切成三份——能合并的矩阵就合并，一次 GEMM 算完</li>
<li><strong>每个 weight 后面的 <code>.T</code></strong>：GPT-2 原版是 TensorFlow，存 <code>(输入维, 输出维)</code>；PyTorch 的 <code>nn.Linear</code> 存 <code>(输出维, 输入维)</code>。两家存储协议相反，灌之前必须转置</li>
<li><code>ff.layers[0]</code> 和 <code>ff.layers[2]</code>：中间的 layers[1] 是 GELU，没有参数</li>
<li><strong><code>qkv_bias</code> 要改成 True</strong>：GPT-2 原版有偏置，配置不改连 bias 属性都不存在</li>
<li><strong><code>context_length</code> 要改回 1024</strong>：我训练时图快用 256，但权重的 wpe 是 (1024, 768)，对不上就是 shape mismatch</li>
</ul>
<h3 id="最后一行藏着-124m-的秘密">最后一行藏着 124M 的秘密</h3>
<p><code>gpt.out_head.weight = assign(gpt.out_head.weight, params[&quot;wte&quot;])</code>——输出层和词嵌入表<strong>共享同一张表</strong>。输入时按 id 查行（确定性索引），输出时拿隐状态和 50257 行逐个算点积（相似度打分）：<strong>正向当字典用，反向当标尺用，词的含义只需要学一份</strong>。这就是 weight tying。如果 out_head 独立，要多出 50257 × 768 = 38,609,408 个参数——我的模型数出来 163M、论文写 124M，差的就是这一份。</p>
<h3 id="同一个骨架三个灵魂">同一个骨架，三个灵魂</h3>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>权重来源</th>
        <th>输入 <code>Every effort moves you</code> 之后</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>随机初始化</td>
        <td>乱码：<code>and, and, and...</code></td>
      </tr>
      <tr>
        <td>自己训 10 轮</td>
        <td>王尔德文风的英文，但只会背《The Verdict》</td>
      </tr>
      <tr>
        <td>GPT-2 预训练权重</td>
        <td>通顺、开放、有泛化能力的语言</td>
      </tr>
    </tbody>
  </table>
</div>
<p><strong>架构决定能力的上限，权重决定能力的成色，数据决定灵魂的形状。</strong></p>
<h2 id="七generate-的-shape-全链路">七、generate 的 shape 全链路</h2>
<p>这是我今天收获最大的一张图。设定 B=1、prompt 3 个 token、V=50257、top_k=50：</p>
<pre tabindex="0"><code>idx: (1, 3)
  │ ① 截窗口 idx[:, -1024:]：序列还不长，(1, 3) 不动（防御性步骤）
  ▼
前向 model(idx_cond)：(1, 3) → (1, 3, 50257)，每个位置都有 50257 个分数
  │ ② 取最后一个位置 logits[:, -1, :]：(1, 3, 50257) → (1, 50257)
  │    整数索引，T 这一维直接被抽掉，不是 (1, 1, 50257)！
  ▼
③ top_k：top_logits, _ = topk(logits, k=50) → (1, 50)，降序
   min_val = top_logits[:, -1] → (1,)，第 50 名的分数当门槛
   torch.where(logits &lt; min_val, -inf, logits) → (1, 50257) 形状不变
   ⚠ 门槛值必须用新变量接！覆盖原 logits 就把完整名单弄丢了
  ▼
④ 温度 / softmax：形状不变，50 个位置概率 &gt; 0，其余为 0，总和为 1
  ▼
⑤ multinomial(probas, num_samples=1)：(1, 50257) → (1, 1)
   （argmax 殊途同归：softmax 单调，取 logits 还是 probas 结果一样）
  ▼
⑥ cat((idx, idx_next), dim=1)：(1, 3) + (1, 1) → (1, 4)，回 ① 进入下一轮
</code></pre><p><strong>整个 generate，形状真正变化的只有三处</strong>：前向升维（加 V）、取末位降维（去 T）、拼接长维（T+1）。其余操作全是「形状不动，内容在变」。</p>
<p>治「dim 总乱」的药方就一句：<strong>写 dim 之前先报一遍每一维的含义</strong>（B=第几条序列、T=第几个位置、V=词表）。softmax/argmax 在词之间比大小 → <code>dim=-1</code>；cat 接在序列后面 → <code>dim=1</code>。dim 不是背的，是推出来的。</p>
<p><img alt="A4 手写：generate 全流程" loading="lazy" src="https://blog.lvxinrong.com/llm/llm-05-a4-generate.jpg"></p>
<p><em>A4 手写稿：generate 全流程。纸上抓出三个实质 bug：topk 覆盖原名单、切片少冒号、<code>=</code> 与 <code>==</code>。</em></p>
<h2 id="八device-教训modeltodevice-只搬模型不搬数据">八、device 教训：model.to(device) 只搬模型，不搬数据</h2>
<p>在 MPS 上踩了两次同一族错误，规律钉死：</p>
<blockquote>
<p><strong>每一个后出生的张量，都要自己 <code>.to(device)</code> 报到。</strong></p>
</blockquote>
<p><code>model.to(device)</code> 只搬权重。<code>text_to_token_ids</code> 里 <code>torch.tensor(encoded)</code> 出生在 CPU，没人接它去 MPS，就会报 <code>Passed CPU tensor to MPS op</code>。排查顺序：顺着 traceback 找到最上层自己的代码 → 往前追输入张量的出生地 → 有没有送去 device。</p>
<hr>
<blockquote>
<p>第五章完。第六章：分类微调。</p>
</blockquote>
]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 04：把 GPT 拼起来</title>
      <link>https://blog.lvxinrong.com/llm/llm-04-gpt-architecture/</link>
      <pubDate>Sat, 10 Oct 2026 00:20:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-04-gpt-architecture/</guid>
      <description>第四章收官。难点不在架构，在形状——同一个错误我犯了三次。drop 认错一次、softmax 当成归一化、ReLU 的问题记错一个。163M 参数跑通那天，模型说了第一段胡话。</description>
      <content:encoded><![CDATA[<blockquote>
<p>这个系列记录我读《从零构建大模型》的过程。规则不变：写下来的必须是我自己搞懂的，没懂的如实写“没懂”。这一章换了个学法——以前是我读代码、AI 答疑；这次我先把自己的理解讲一遍，让 DeepSeek 指错。</p>
</blockquote>
<h2 id="一这一章的难点不在架构在形状">一、这一章的难点不在架构，在形状</h2>
<p>翻完整章，大部分时间花在 shape 上——不是架构上。</p>
<p>同一个错误我犯了三次。</p>
<p>第一次是把 <code>tok + pos</code> 当成 (50257, 768)。第二次是把 <code>pos_emb(arange(T))</code> 算成 (1024, 768, 768)。第三次是把 <code>out_head(x)</code> 的输出当成 (50257, 768)。</p>
<p>三次的毛病一模一样：<strong>把“表的形状”当成了“输出的形状”。</strong></p>
<p>第二次犯的时候我说过一句话：“但是 tok + pos 矩阵在代码中的形状是 (50257, 768)”。被顶回来：如果真是这个形状，那 <code>tok_embeds + pos_embeds</code> 这一行当场就报错——右对齐之后 50257 和 4 既不相等，也没有一个是 1。</p>
<p><strong>代码能跑起来，就是答案。</strong></p>
<p>后来我给自己留了一句问法，比背规则管用：这个张量的数值从哪来？来自另一张表（weight），那是参数；来自前一层算出来的，那是激活值。</p>
<p>规则还是得记两条。<code>nn.Embedding(n, d)</code> 的参数是 (n, d)，输出是「输入形状 + (d,)」——那个 n 只决定合法索引范围，不进形状。<code>nn.Linear(in, out)</code> 的参数是 (out, in)，输出把最后一维从 in 换成 out。</p>
<p>（图书馆那个比喻把我钉住了：馆里有五万本书，不代表你借出五万本。）</p>
<p>顺手把整条 forward 走了一遍。<code>in_idx</code> 是 (B, T)，<code>tok_embeds</code> 变成 (B, T, 768)，<code>pos_embeds</code> 是 (T, 768)，相加之后还是 (B, T, 768)。然后是 dropout、十二层、最后归一化——<strong>形状一动不动</strong>。只有 <code>out_head</code> 把最后一维换成 50257。</p>
<p>九行代码，主干只变过两次形状。中间那十二层变的是内容，不是形状。这个认识后来很实用：换上一个真实实现就顺手跑一遍，形状没变就是接对了。</p>
<h2 id="二embedding我懂的只是查表这个词">二、Embedding：我懂的只是“查表”这个词</h2>
<p><code>(1024, 768, 768)</code> 那一下之后我才意识到，我懂的只是“查表”这个说法，没懂它和输出形状的关系。</p>
<p>查表不是乘法，这点我倒是没搞错。括号就是调用，底层是按行取数，<code>weight[idx]</code> 和 <code>emb(idx)</code> 等价，一次乘法都没有。真正的魔力在那张表的 3800 万个数字上，操作本身平凡得很。</p>
<p>“等价于 one-hot 矩阵乘”这个说法我以前当实现细节记住了。现在改了个更准的：one-hot 是 Embedding 的固定版。数学上确实一样——一个 1 去挑一行；但那张表是写死的、学不了的。差别不在数学形式，在<strong>可不可学</strong>。</p>
<h2 id="三广播我只会二维">三、广播：我只会二维</h2>
<p>二维广播我早懂，多维一直没想明白。我的原话是“我目前只能理解 2 维的广播，多维的就不行了”。</p>
<p>后来是被一个画面带过去的：<code>(B, H, T, T)</code> 就是 B×H 张 T×T 的表，摞成一叠。右对齐这个动作，本质上是把形状切成两段——右边重叠的那几维是“纸里长什么样”，左边多出来的维是“有几张纸”。</p>
<p>份数对不上就复印，纸里的形状才逐维判“相等或有 1”。所以 <code>(2,3,4) + (2,3,1)</code> 里，前面那个 2 根本不用想，剩下就是 <code>(3,4) + (3,1)</code>——我早就会的东西。</p>
<p>还有个更好用的招：拍扁。<code>(2,3,4)</code> 加 <code>(4,)</code>，等价于把前两维拍成 6 行、做一次二维广播、再拍回来。因为逐元素运算不跨位置，<code>reshape</code> 也不改数据顺序。</p>
<p>另外两条一起记下。一是<strong>只有 1 是通配符，0 不是</strong>：<code>(3,0)</code> 和 <code>(1,1)</code> 能广播出 <code>(3,0)</code>，<code>(3,0)</code> 和 <code>(1,4)</code> 直接报错。二是结果维不是“取 max”，是“取那个不是 1 的值”——长度为 0 的轴就是反例，<code>max(0,1) = 1</code> 是错的。</p>
<h2 id="四位置编码位置就是一个数为什么表要-768-列">四、位置编码：位置就是一个数，为什么表要 768 列</h2>
<p>行数我懂：<code>context_length</code> 就是位置表能表示多少个位置。这也是“上下文长度”这个词的真实含义——超过就索引越界。</p>
<p>列数我卡住了。位置就是一个数（0、1、2……），表不该是 <code>(1024,)</code> 吗？</p>
<p>堵死这条路的是 LayerNorm。假设位置只贡献一个标量，也就是给那个位置的 768 个通道加同一个数——那 LayerNorm 减均值的时候会把它原样减掉。而 TransformerBlock 的第一件事就是 LayerNorm，所以这个信号进第一层就没了，等于没加。</p>
<p>这个推导本身很直接：<code>mean(x + s) = mean(x) + s</code>，所以 <code>(x+s) − mean(x+s)</code> 里 s 直接消掉。</p>
<p><strong>位置向量必须在通道维上有差异，才能活着穿过 LayerNorm。</strong></p>
<p>顺带解开一个我一直觉得别扭的问题：位置 0 在不同句子里内容完全不一样，<code>pos_emb[0]</code> 到底在学什么？答案是它学的是所有样本在那一位置上的共同分量——个别 token 带来的噪声在平均里互相抵消了。</p>
<p>我记的比喻是座位和坐的人。<code>tok_emb</code> 是坐的人，今天张三明天李四；<code>pos_emb</code> 是第一排靠窗这个座位，换谁坐，属性不变。</p>
<h2 id="五两个叫-drop-的地方我认错了一个">五、两个叫 drop 的地方，我认错了一个</h2>
<p><code>drop_emb</code> 我第一眼就认成了因果掩码，原话是“这行其实就是在做因果掩码的步骤”。</p>
<p>被顶回来才想起：掩码在 <code>MultiHeadAttention</code> 里面，作用在 (T,T) 的分数矩阵上，是固定的右上三角、softmax 之前塞负无穷；<code>drop_emb</code> 是 Dropout，逐元素随机置零、只有训练时才生效。两件事唯一的共同点，是名字里都带个“遮”的意思。</p>
<p><code>drop_shortcut</code> 这个我没认错。名字里带 shortcut，我反而觉得不对劲，去问了一句“不是快捷连接吧，感觉是第三章那个把元素置零的操作”。确认下来它确实是 Dropout，站在残差支路上（GPT-2 原生代码里叫 <code>resid_dropout</code>）。真正的快捷连接是 <code>shortcut = x</code> 和 <code>x = x + shortcut</code> 那两行——名字里的 shortcut 说的是<strong>位置</strong>，不是身份。</p>
<p>这么来回两次之后，我把书里的命名规律记成“动作 + 位置”的格式：<code>drop_emb</code> 是对 embedding 输出做 drop，<code>drop_shortcut</code> 是对残差支路做 drop。动作才是本质，前缀只是主语。</p>
<p>还有一处顺序值得单独记：<strong>dropout 必须在相加之前</strong>。</p>
<p>这里有个名字上的误会要先拆掉。<code>drop_shortcut</code> 丢的<strong>不是</strong> shortcut，它丢的是<strong>支路输出</strong>（<code>norm1 → att</code> 那段的结果）；名字里的 shortcut 只标位置——它站在残差这条路上。</p>
<p>所以先 <code>drop_shortcut(x)</code> 再 <code>x = x + shortcut</code>，被置零的只有支路，干道（<code>shortcut</code> 里那份原始 x）一个元素都不会动。</p>
<p>反过来写就麻烦了。问题在于<strong>相加之后，“主干”这个身份就没了</strong>：<code>x = x + shortcut</code> 一执行，支路和干道已经合成同一个张量，再也分不开。此时 dropout 打上去，等于把干道也一起打了洞，而且分不清哪个洞打在谁身上。</p>
<p>用三个数看一眼。干道是 <code>[1.0, 2.0, 3.0]</code>，支路输出是 <code>[0.5, 0.5, 0.5]</code>，假设第 1 位被置零：正确顺序得到 <code>[1.56, 2.0, 3.56]</code>，干道那个 <code>2.0</code> 完好；错误顺序先把两者加成 <code>[1.5, 2.5, 3.5]</code>，再 drop 就成了 <code>[1.67, 0, 3.89]</code>——<strong>干道贡献的那 <code>2.0</code> 跟着一起没了</strong>。（<code>0.56</code> 是保留项乘过 <code>1/(1-p)</code> 之后的值。）</p>
<p>残差的意义是“让原始 x 原封不动地传下去”，所以那个 <code>2.0</code> 必须活着。梯度上是同一回事：<code>y = x + f(x)</code> 对 x 求导是 <code>1 + f'(x)</code>，那个 1 就是梯度的高速公路；写成 <code>y = drop(x + f(x))</code>，导数里就多出一个随机的 0 掩码。</p>
<p>顺带问了一句：如果 forward 里干脆不调用 <code>drop_shortcut</code> 会怎样？答案是形状不变，<code>eval</code> 下完全没影响（推理时它本来就是恒等的），只有训练时少一层正则化，症状是训练 loss 更低、验证 loss 更高。所以判断标准永远是验证集。</p>
<h2 id="六softmax-不是归一化">六、softmax 不是归一化</h2>
<p>我的原话是：“归一化不是 softmax 就可以了么，为啥这里要增加一个 LayerNorm 对象来做这个事情。”</p>
<p>问题出在“归一化”这三个字上——中文里它至少指四件事，我把它们当成了一件。softmax 让加起来等于 1；min-max 缩到 0 到 1；标准化和 LayerNorm 让均值 0、方差 1。<strong>softmax 归的是“和”，LayerNorm 归的是“中心和宽度”。两个正交的约束，谁也替不了谁。</strong></p>
<p>真正说明问题的是幂等性。把 <code>[1, 2, 3]</code> 反复 softmax：第一次得到 <code>[0.09, 0.24, 0.67]</code>，第二次 <code>[0.25, 0.30, 0.45]</code>，到第四次基本就是 <code>[1/3, 1/3, 1/3]</code> 了。每套一遍就更平一点，最后信息死光。而 LayerNorm 套第二遍几乎不动，因为输出已经达标。</p>
<p>所以 LayerNorm 能在十二层里出现 25 次，softmax 只能出现一次——而且那一次还在模型外面。<code>GPTModel.forward</code> 里根本没有 softmax，它返回的是原始分数。</p>
<p>还有一条我原来没往这儿想：<strong>softmax 和残差不兼容</strong>。残差要求修改量和 x 同尺度、还得有正有负，才能表达“把某个特征调低”；softmax 的输出全为正、总和恒为 1，加回主干等于只能往上加，总量还固定。</p>
<h2 id="七两个-layernorm不是冗余是残差逼出来的">七、两个 LayerNorm：不是冗余，是残差逼出来的</h2>
<p>残差连接我原来理解得含糊，自己捋了一遍才想通：<strong>它把“替换”变成了“累加”。</strong></p>
<p>没有快捷连接的时候，下一层的输入就是上一层的输出——<code>x₁ = f₁(x₀)</code>、<code>x₂ = f₂(x₁)</code>，旧值被覆盖掉了。加上快捷连接之后变成 <code>x₁ = x₀ + f₁(x₀)</code>、<code>x₂ = x₁ + f₂(x₁)</code>，上一层不再被覆盖，而是留下来再追加一点。</p>
<p>展开就一目了然：<code>x₃ = x₀ + f₁(x₀) + f₂(x₁) + f₃(x₂)</code>。<strong>原始的 x₀ 一直在里面</strong>，每一层只是往总和里追加一个增量。所以 x 不是被“参考”了一下，是真的留下了。</p>
<p>要精确一点：追加的不是 x 的一部分，是由 x 算出来的新东西。同一个 x 走了两条路——一条原样传下去当原件，一条经 norm 和 att 变成修改意见，最后原件加修改意见。</p>
<p>不过这个“保留”是加法意义上的。<code>y = x + f(x)</code> 里 x 的分量确实原样进了 y，但没法再从 y 里把 x 单独取出来，两者已经加在一起了。前向意义上 x 保留了，分离意义上它已经和 f(x) 不可分——这也正是前面“dropout 必须在相加之前”那条的来历：dropout 看到的是合并后的张量，它没能力区分哪个数是谁带来的。</p>
<p>（为什么“加”比“替换”强，顺手记两条：<code>y = x + f(x)</code> 对 x 求导是 <code>1 + f'(x)</code>，那个 1 是梯度的高速公路；另外如果 f 学到输出接近 0，<code>y ≈ x</code> 就成立——恒等映射是个平凡解，所以“深”至少不会比“浅”更差。）</p>
<p>我一开始觉得一个 block 一个 LayerNorm 就够了，还给 LayerNorm 列了两个“目的”，其中一个是幂等。</p>
<p>那个地方我列错了：<strong>幂等是性质，不是目的</strong>。目的是把子层的输入拉回标准尺度；幂等只是保证“反复归一化”这件事本身安全——要是它像 softmax 那样越套越平，25 次调用早把信号衰减没了。</p>
<p>真正需要两个的原因在残差。如果 x 已经归一化（方差 1），子层输出的方差是 0.25，那 <code>x + f</code> 之后方差变成 1.25。均值没问题（0 加 0 还是 0），<strong>但方差会累加</strong>。一个 block 加两次，十二层就是 24 次，粗算是 1.25 的 24 次方——两百多倍。不重新归一化，尺度早就飞了。</p>
<p>还有一处值得单独记：<code>shortcut</code> 存的是归一化<strong>之前</strong>的 x。归一化只作用在送进子层的那条支路上，残差干道从头到尾都是原始的。</p>
<p>这一条同时解释了 <code>final_norm</code>。每个 block 的出口都是没归一化的残差和，十二层堆完 x 还是漂移的，所以最后得补一刀。LayerNorm 的总数是 25 而不是 24，就是这个“1”的来历。</p>
<h2 id="八ffn我以为就是两次矩阵乘">八、FFN：我以为就是两次矩阵乘</h2>
<p>看完 <code>FeedForward</code> 的代码，我第一反应是“就这？”。768 升到 3072，过个 GELU，再降回 768。我当时说的话是：“看起来像是 <code>(768, 4*768) @ (4*768, 768)</code> 的操作。”</p>
<p>它确实就是两次矩阵乘。但 GELU 夹在中间，让它彻底不再是矩阵乘链。</p>
<p>如果没有 GELU，两层线性可以直接乘起来合成一个矩阵——(768, 3072) 乘 (3072, 768) 得到 (768, 768)，一个普通的单层线性。参数量对比：两层加起来 4,718,592，等价的单层只要 589,824。<strong>八倍参数，换来一个用八分之一参数就能表达的映射。</strong> 所以扩张本身不产生表达力，“扩张 + 非线性”才产生。</p>
<p>那 3072 到底买到了什么，我手里有两个说法。</p>
<p>一个是几何的：每个中间神经元相当于在 768 维空间里划一刀，输入只有 768 维，但你有 3072 把刀去切它——能区分的模式数量由中间宽度决定，不由输入宽度决定。</p>
<p>另一个是“键值记忆”：有篇论文发现 FFN 近似于一个记忆库，<code>W1</code> 的每一行是一个 key，GELU 负责稀疏化，<code>W2</code> 的对应列是 value。3072 个神经元就是 3072 个槽位。旁证是后面有研究靠改 FFN 权重来改模型“知道”的事实，改注意力层没这个效果。</p>
<p>这个视角我是接受了，不是验证了。下面挂账。</p>
<p>4 倍是经验值不是定律：原始 Transformer 和 GPT-2 都是 4 倍，Llama 换成 <code>8/3 × d_model</code>，因为它用了 SwiGLU，要三个矩阵。</p>
<p>顺带一笔账：每层里 FFN 的参数是注意力的两倍（4.72M 对 2.36M）。所以“Transformer 的主角是注意力”这个印象，在参数占比上是不成立的。</p>
<h2 id="九gelurelu-的两个问题我记错了一个">九、GELU：ReLU 的两个问题，我记错了一个</h2>
<p>我先讲了自己的理解：ReLU 有两个毛病，负数全是 0，还有 0 点不可导。</p>
<p>第二个被否了——连续分布下输入恰好等于 0 的概率是零，框架还用次梯度兜底，这不是真问题。</p>
<p>真问题在第一个，而且比我说的严重：不是“负数是 0”，是<strong>整个负半轴的梯度恒等于 0</strong>。半条数轴上全是 0，输入长期落在左边的那批神经元就永久死了。放在 FFN 里，死一个就是浪费一个记忆槽位。</p>
<p>GELU 的导数在负半轴不是一刀切：<code>x = 0</code> 处是 0.5，<code>x = -0.25</code> 处是 0.30，<code>x = -0.5</code> 处是 0.13，到 <code>x = -0.75</code> 掉到 0.0008，再往左就翻负号了。而 ReLU 在这整段上全是 0。</p>
<p>三件事。<code>GELU′(0) = 0.5</code>，光滑，没有折角；−0.75 到 0 这段负区间里梯度是正的、而且不小——这才是“负数也参与学习”的准确意思；但过了 −0.75 梯度变号、绝对值一路衰减到 0。</p>
<p>所以它没解决梯度消失，只是把硬截止换成了软衰减。</p>
<h2 id="十163m124m和一段胡话">十、163M、124M，和一段胡话</h2>
<p>模型第一次跑通，打出来两个数。</p>
<p>参数量是 163,009,536，拆得干干净净：<code>tok_emb</code> 38,597,376，<code>pos_emb</code> 786,432，十二层 TransformerBlock 一共 85,026,816，<code>final_norm</code> 1,536，<code>out_head</code> 38,597,376。</p>
<p>但 GPT-2 论文说的是 124M，差 38.6M，正好是 <code>out_head</code> 那一块。书上后面会讲：GPT-2 做了权重绑定，<code>out_head</code> 和 <code>tok_emb</code> 共享同一份内存。163,009,536 减掉 38,597,376 就是 124,412,160。两个 embedding 加起来占了总量的 47%，这就是绑定能省下那么多参数的原因。</p>
<p>然后是生成。输入 <code>Hello, I am</code>，出来的是：</p>
<blockquote>
<p>Hello, I am Featureiman Byeswickattribute argue</p>
</blockquote>
<p>这是对的，不是 bug。参数全是随机数，模型根本没训过，整条链路就是随机查表、随机变换、随机打分、argmax 挑一个。</p>
<p>有个细节容易理解偏：输出看起来像英文单词，不是模型懂英语，是<strong>词表里大部分 token 本身就是英文片段</strong>。argmax 在五万个候选里随便挑，挑到的恰好长得像词。</p>
<p>这段留作第五章的对照——同一份代码、同一个 prompt，只有参数不同。</p>
<h2 id="十一如实记录我还没通的地方">十一、如实记录：我还没通的地方</h2>
<ol>
<li>笔记 03 留的那份回炉考卷，我没做。手推多头全链路这件事还欠着，这一章读完，账没还；</li>
<li>FFN 的键值记忆视角我是接受了，不是验证了。没自己动手看过 <code>W1</code> 的行到底长什么样；</li>
<li>整条前向还是不能脱稿。每个 shape 都能看懂，但还不能从空白纸写出来；</li>
<li>广播的多维情形现在有画面了，但还不到能秒推的程度，四维以上还是得画一下。</li>
</ol>
<h2 id="十二三问式收尾">十二、三问式收尾</h2>
<ol>
<li><strong>今天学了什么</strong>：形状（两条规则 + 三次踩坑）、Embedding 是查表不是乘法、广播里那个 1 代表共享、位置向量必须和 emb_dim 一样宽才能穿过 LayerNorm、softmax 不是归一化、两个 LayerNorm 是残差逼出来的、FFN 升维必须配 GELU、GELU 是软衰减、163M 和 124M 的差；</li>
<li><strong>哪里还没懂</strong>：多头注意力的元素级推导、键值记忆没亲手验证、前向不能脱稿、四维广播还得画；</li>
<li><strong>明天干什么</strong>：第五章，预训练。第一次让 loss 真的下降。</li>
</ol>
<hr>
<p><em>这一章的方法换了：先把理解讲一遍，再让 DeepSeek 挑错——上面几处认错都是这么露出来的。第三章那份回炉考卷还欠着，等第五章跑完预训练，回头一起还。</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 03：因果掩码与多头注意力</title>
      <link>https://blog.lvxinrong.com/llm/llm-03-mask-multihead/</link>
      <pubDate>Fri, 09 Oct 2026 09:30:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-03-mask-multihead/</guid>
      <description>第三章收官：掩码防的是答案泄露，多头是加视角不是加角色。说实话，这一章我自认没完全过关，这篇是如实的认知水位记录。</description>
      <content:encoded><![CDATA[<blockquote>
<p>系列规则不变：写下来的必须是自己搞懂的。但这一篇要破例一次——第三章（因果掩码 + 多头注意力）我自认只懂了八成，所以这篇除了笔记，也如实记录我“还没通”的地方。它是我回炉时的地图。</p>
</blockquote>
<h2 id="一因果掩码防的不是过拟合是答案泄露">一、因果掩码：防的不是过拟合，是答案泄露</h2>
<p>训练时，模型是一次性看到整句话的。如果不加掩码，预测下一个 token 时，答案就躺在输入里——模型只要学会“看下一个位置”照抄，loss 瞬间归零，<strong>什么都没学到</strong>。</p>
<p>我一开始把这理解成“过拟合”，Kimi 纠正了我：这比过拟合直接得多——<strong>是考试作弊</strong>。题目和答案同时发下来，考满分也没有意义。因果掩码保的不是防过拟合，是<strong>保证“预测下一个 token”这个任务本身有意义</strong>。</p>
<p>推理时不需要掩码：自回归生成时未来还没生成，天然看不到。所以掩码纯粹是为训练准备的——<strong>让训练时的看题条件和推理时保持一致</strong>。</p>
<p>判任何掩码方案，我后来只留了一条尺子：<strong>位置 i 的答案，不能出现在它能看到的地方</strong>。目标和掩码配不配，一句话定生死。</p>
<h2 id="二实现负无穷不是-0">二、实现：负无穷，不是 0</h2>
<p>书里其实演进过两版，而且用的是两张互补的表：</p>
<ul>
<li><strong>下三角（<code>tril</code>，含对角线）是白名单</strong>——保留谁。第一版就是乘上它，再除以行和重新归一化；</li>
<li><strong>上三角（<code>triu(diagonal=1)</code>）是黑名单</strong>——抓谁。第二版把要遮的位置在 softmax 之前塞成负无穷。</li>
</ul>
<p>两张表加起来是全 1 矩阵，同一个约束的两种说法。“床前明月光”五步展开：床 / 床前 / 床前明 / 床前明月 / 床前明月光。</p>
<p>我踩过的坑：<strong>掩码位置为什么不能填 0？</strong> 因为 softmax 里 e⁰ = 1——填 0 的话，这些被掩盖的位置照样参与归一化，稀释别人的概率。所以填<strong>负无穷</strong>：e^-∞ = 0，从归一化里彻底除名，反向传播时梯度也恰好为 0，从计算图里干净地消失。</p>
<p>而且填 0 的坏处不止“稀释”。如果这一行的合法分数本来是负的，比如 <code>[-2, -5, 遮]</code>，填 0 之后 <code>e⁰ = 1</code> 反而是<strong>最大的那一项</strong>——被遮住的位置一口气拿走 <strong>87.6%</strong> 的权重，彻底反客为主。</p>
<p>所以“精确的 0 权重”只有一条路：在 softmax 之前塞负无穷。因为 softmax 对任何<strong>有限</strong>输入，输出都严格大于 0。</p>
<p>至于为什么必须遮在 softmax <strong>之前</strong>：在之后清零会让那一行的和小于 1，<code>context</code> 变成被缩水的加权和，而且每个位置缩水的比例还不一样。补一次除法确实能救回来——但那个结果和“提前遮”在数学上完全等价，<strong>一步能做完的事没必要分两步</strong>。</p>
<h2 id="三dropout它打破了行和等于-1">三、dropout：它打破了“行和等于 1”</h2>
<p>3.5.2 是给注意力权重加 dropout。<code>nn.Dropout(0.5)</code> 作用在全 1 矩阵上，输出只有 <code>0</code> 和 <code>2.0</code> 两种值——保留的元素被放大了 <code>1/(1-p) = 2</code> 倍。这就是倒置 dropout：它让每个元素的<strong>期望值保持不变</strong>。</p>
<p>但它顺手打破了我刚学会的那条规矩。某一行的注意力权重原本是 6 个 <code>1/6</code>，和恰好为 1；dropout 之后保留 k 个、每个变成 <code>1/3</code>，于是行和 = <code>k/3</code>。而 k 是抛硬币抛出来的（<code>Binomial(6, 0.5)</code>），所以行和可能是 0、0.33、1.33……</p>
<p><strong>结论是：加上 dropout 之后，“注意力是加权平均（行和 = 1）”只在期望意义上成立</strong>，实际采样出来的那一行并不等于 1。只有推理时（<code>model.eval()</code>）它才严格成立。</p>
<p>顺带两个小观察：<code>nn.Dropout</code> 有状态、没参数，<code>eval()</code> 之后是恒等映射——这就是推理前必须切 eval 的原因；而现代大模型（Llama 那一派）干脆把 drop_rate 设成 0，因为<strong>只有当一份数据只需要过一遍时，dropout 才可以扔掉</strong>。</p>
<h2 id="四多头加的是视角不是角色">四、多头：加的是视角，不是角色</h2>
<p>3.6 节我花了一整天。</p>
<p><strong>形状</strong>：d_out = 768、8 个头，每个头处理 768/8 = 96 维。</p>
<p><strong>W_q 是共享还是独立？</strong> 这里有个障眼法：代码里 <code>W_q</code> 表面上是 class 的一个属性、一块平面矩阵，看起来共享——但实际上是<strong>把 8 个 (d_in, 96) 的小矩阵按列打包在一起</strong>。第 0<del>95 列服务头 1，第 96</del>191 列服务头 2……逻辑上独立，物理上合并，为的是让 GPU 一次矩阵乘搞定 8 个头，而不是循环 8 次。</p>
<p>有个约定必须交代清楚，否则这块永远会混：上面说的是<strong>数学写法 (d_in, d_out)</strong>，那时头是<strong>列</strong>块；而 <strong>PyTorch 的 <code>nn.Linear</code> 内部存的是 (d_out, d_in)</strong>，转置过了，所以在代码里看到的是<strong>行</strong>块——同一件事，两套摆法。（笔记 02 里我就记过这个坑，这次又差点栽进去。）</p>
<p>还有一个容易记岔的细节：<strong>权重本身没有“头”这个维度</strong>。头维度是投影之后，把输出 (B, T, 768) reshape 成 (B, T, 8, 96) 再 transpose 出来的——<strong>多头维度是电流流过时折出来的，不是电阻上的刻痕</strong>。</p>
<p>一路推下来我最想记住的一条：<strong>切 token 是事故，切维度是设计</strong>。</p>
<h3 id="形状体操为什么非-transpose-不可">形状体操：为什么非 transpose 不可</h3>
<p><code>queries @ keys.transpose(2, 3)</code> 这一行藏着两个“为什么”：</p>
<ol>
<li><strong><code>@</code> 只对最后两维做矩阵乘，前面所有维度一律当批次。</strong> 所以要让 8 个头各算各的 (T, T)，就必须先把“头”从最后一维挪到位置维前面——<code>transpose(1, 2)</code> 存在的唯一理由就是这个；</li>
<li><code>keys.transpose(2, 3)</code> 是“最后两维互换”，把 (T, 96) 翻成 (96, T)，点积的内维才对得上。</li>
</ol>
<p>顺手记两个坑，都是一眼看不出来的：</p>
<ul>
<li><strong><code>dim=-1</code> 和 <code>dim=1</code> 在 4 维张量上不是一回事。</strong> <code>attn_scores</code> 是 <code>(b, H, T, T)</code>，<code>dim=-1</code> 是 key 轴（对）；写成 <code>dim=1</code> 就是<strong>头轴</strong>，会沿 8 个头做归一化——不报错，但结果毫无意义；</li>
<li><strong><code>context_vec.contiguous().view(...)</code> 里的 <code>contiguous()</code> 不能省。</strong> <code>transpose</code> 只改 stride、不搬内存，所以它之后 <code>view</code> 会直接拒绝工作（<code>view</code> 只肯在内存连续时零拷贝）；<code>contiguous()</code> 才真正按逻辑顺序重排一份。</li>
</ul>
<p>另外，构造函数里那句 <code>assert d_out % num_heads == 0</code> 不是装饰：<code>head_dim = d_out // num_heads</code> 用的是整除，除数不整除时会<strong>静默丢掉余数</strong>，然后在很远的地方以形状错误的形式炸掉。<code>assert</code> 的作用是把这个错误提到门口。</p>
<h2 id="五合并拼接是摆回去w_o-才是搅在一起">五、合并：拼接是摆回去，W_o 才是搅在一起</h2>
<p>每个头算完自己的注意力，得到 (T, 96)。然后两步：</p>
<ol>
<li><strong>concat</strong>：8 段 96 维首尾相接，摆回 (T, 768)——纯机械的形状操作，<strong>摆在一起，但互没说话</strong>；</li>
<li><strong>输出投影 W_o (768, 768)</strong>：做一次矩阵乘。<code>C[i][j] = Σ_k A[i][k] · B[k][j]</code>——输出的每一维都是全部 768 维的加权和。<strong>头 1 的结果和头 8 的结果，在这一步才真正乘进同一个维度里。</strong></li>
</ol>
<p>所以：拼接负责“摆回去”，W_o 负责“搅在一起”。头与头的信息交互，发生在 W_o，不在 concat。</p>
<p>但有个边界要说准：<strong>W_o 的混合只发生在每个 token 内部，不跨 token。</strong> <code>(T, 768) @ (768, 768)</code> 是每一行各自做一次混合，第 i 行的输出只用到第 i 行的输入。跨 token 的交流发生在注意力那一步（<code>attn_weights @ V</code>），不在 W_o。</p>
<h2 id="六回答我自己留下的问题">六、回答我自己留下的问题</h2>
<p>笔记 02 结尾我留了个问题：<strong>Q、K、V 真的够吗，投影会不会越多越好？</strong></p>
<p>读完多头，答案清楚了：</p>
<ul>
<li><strong>三个角色是最小完备集</strong>——我去找（Q）、我被找（K）、我交货（V），少一个就塌方，多一个没槽位。角色表是满的；</li>
<li><strong>但“更多投影”以另一种方式兑现了</strong>——不是加第四个角色，而是<strong>把每个投影的输出维度切成 h 份</strong>，每个头只拿到 <code>d_out / h</code> 维，各看一个角度。多头就是“更多投影”的正确打开方式：<strong>不加角色，加视角，也不加参数</strong>；</li>
<li>行业后来甚至反向操作：GQA/MQA 让多个头共享 K、V 省显存，DeepSeek 的 MLA 把 K、V 压成低秩矩阵。角色不动摇，头数、共享、压缩随便玩。</li>
</ul>
<h2 id="七如实记录我还没通的地方">七、如实记录：我还没通的地方</h2>
<ol>
<li><strong>(T, d_out) @ (d_out, d_out) 为什么产生头间交互</strong>——这个代数步骤我是让 AI 展开到元素级才看懂的，<strong>不是我手推的</strong>。按我自己的标准，这笔账没还清；</li>
<li><strong>整条前向还不能脱稿</strong>——从 Embedding 到 W_o 的每个 shape，我能看懂，但还不能从空白纸写出来；</li>
<li>所以第三章我会回炉。回炉考卷已经备好：</li>
</ol>
<blockquote>
<p>拿“床前明月光”5 个 token，d_in=4，d_out=4，2 个头（head_dim=2），从空白纸手写一遍完整前向：Embedding → Q/K/V → scores → ÷sqrt → 掩码 → softmax → ⊗V → concat → W_o。每个矩阵的 shape 和每个数的去向都写清。</p>
</blockquote>
<p>写不出就再找断点。写得出，第三章才算真过。</p>
<h2 id="八三问式收尾">八、三问式收尾</h2>
<ol>
<li><strong>今天学了什么</strong>：因果掩码（防答案泄露，不是防过拟合）、负无穷掩码（e⁰=1 的坑）、dropout（会把行和从 1 打散）、多头（打包 W_q、切维度不切 token、concat + W_o）；</li>
<li><strong>哪里还没懂</strong>：头间交互的元素级推导、脱稿手推全链路；</li>
<li><strong>明天干什么</strong>：第四章，GPT 架构整体拼装。看完全景，再回炉第三章——站在架构里回头看注意力，很多“为什么”会自己解开。</li>
</ol>
<hr>
<p><em>学习时长：3.6 节整整一天（除吃饭睡觉）。方法：让 AI 列出计算步骤，我手推每一步的矩阵 shape。亲测有效，推荐给你。</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 02：注意力，让每个 token 看完全场</title>
      <link>https://blog.lvxinrong.com/llm/llm-02-attention/</link>
      <pubDate>Wed, 30 Sep 2026 10:00:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-02-attention/</guid>
      <description>从简化版到带可训练权重的自注意力：三步走、三块矩阵、sqrt(d_k)、以及梯度怎么流回去。学了三小时，答了五道题。</description>
      <content:encoded><![CDATA[<blockquote>
<p>这个系列记录我读《从零构建大模型》的过程。规则不变：写下来的必须是我自己搞懂的，没懂的如实写“没懂”。本篇覆盖第三章到 3.4 节（带可训练权重的自注意力机制），学习时长约 3 小时，中间被 Kimi 老师出了五道验收题。</p>
</blockquote>
<h2 id="一注意力到底在干什么">一、注意力到底在干什么</h2>
<p>一句话：<strong>让每个 token 看完全场之后，重写一遍自己。</strong></p>
<p>输入“床前明月光”，“床”这个 token 不应该只携带“床”自己的信息——它应该吸收了“前”“明”“月”“光”之后，变成一个<strong>知道自己在诗里、知道后面大概率接“前”的新“床”</strong>。</p>
<p>这个“吸收”的过程，我自己总结为一个词：<strong>编织</strong>。新向量 = 对所有 token 向量的加权和，权重就是“和我有多大关系”。</p>
<h2 id="二简化版三步走">二、简化版三步走</h2>
<p>不带任何权重矩阵的注意力，就三步：</p>
<ol>
<li><strong>点积</strong>：当前 token 和序列里每个 token（包括自己）算点积，得到一行分数。点积 = |a||b|cosθ——夹角是折扣率，方向一致原价（cos=1），垂直白送也不要，反向负分。但注意点积还混着“嗓门”（向量长度），不是纯夹角；</li>
<li><strong>softmax</strong>：把分数变成权重。<strong>softmax 就是把所有人塞进一个体积为 1 的房间，体积大的人占地盘大</strong>——但它保证权重和为 1，所以第三步是“信息的重新分配”，不是“信息的膨胀”；</li>
<li><strong>编织</strong>：用权重对每个 token 的向量做加权和，得到新向量。向量就是信息的表示，加权和 = 求期望，新向量里装着全场的信息。</li>
</ol>
<h2 id="三为什么要除以-sqrtd_k">三、为什么要除以 sqrt(d_k)</h2>
<p>这是本章的第一个硬骨头，我一开始也没想透。</p>
<p>完整的逻辑链是这样的：</p>
<ul>
<li>点积是 d_k 个乘积的求和，<strong>项数越多，和的波动天然越大</strong>——统计上，点积的方差正比于 d_k，标准差正比于 sqrt(d_k)；</li>
<li>也就是说，<strong>维度越高，分数的绝对值天然越大，softmax 的输入尺度被维度绑架了</strong>；</li>
<li>softmax 这个函数，输入太大就饱和：一个权重趋近 1，其他全部趋近 0。语言里词和词的关系没有那么绝对——<strong>要给概率小的 token 留口气，而不是拍死</strong>；</li>
<li>更致命的是梯度：饱和区里 softmax 的导数趋近 0，反向传播流不过去，模型直接“停止学习”；</li>
<li>所以除以 sqrt(d_k)，把标准差归一化回 1 附近，<strong>softmax 永远在中间敏感区工作，不管维度怎么变</strong>。</li>
</ul>
<p>书里的代码只有一行：<code>attn_scores / keys.shape[-1]**0.5</code>——不硬编码维度，最后一维是几就除几。sqrt(d_k) 的本质是<strong>量纲归一</strong>：不是在调注意力，是在消除维度对分数尺度的污染。</p>
<h2 id="四三块矩阵qkv-到底多给了什么">四、三块矩阵：Q、K、V 到底多给了什么</h2>
<p>简化版不用权重也能跑，但那个注意力是“死”的——谁和谁相关，全由词向量本身决定，模型没得学。而且点积对称（x·y = y·x），“床关注前”和“前关注床”必然一样大，语言里根本不是这么回事。</p>
<p>W_q、W_k、W_v 就是来解决这个的：</p>
<ul>
<li><strong>它们是投影，不是切分</strong>。token 的向量是信息的最小单元，不能掰开（掰开信息就丢了），但可以“换角度读”——同一个向量被三块矩阵各读一遍：W_q 读“我在找什么”，W_k 读“我有什么”，W_v 读“我能给什么”；</li>
<li><strong>Q、K 分开，注意力才有了方向</strong>。同一个 token，投成 Q 时是主语（我在找），投成 K 时是宾语（我被找），两块矩阵各学各的，q_a·k_b ≠ q_b·k_a；</li>
<li><strong>K、V 分开，“指路”和“送货”才解耦</strong>。K 决定“我被多少注意力找到”（打分），V 决定“我被找到后交出什么货”（内容）。介词是绝佳的路标但没什么货，实词低调但干货满满——打分和送货是两份工；</li>
<li><strong>Q+K+V ≠ 原 token</strong>。一个人的三个投影加起来，也不会是这个人本身。</li>
</ul>
<p>还有一个容易记乱的账：W_q 的形状是 (d_in, d_out)，Q = tokens @ W_q，<strong>出来的维度是 d_out，不是 d_in</strong>——投影的意义就是换维度。（<code>nn.Linear</code> 内部权重存成 (d_out, d_in)，计算时它内部转置，两种摆放别混。）</p>
<h2 id="五梯度怎么流回三块矩阵">五、梯度怎么流回三块矩阵</h2>
<p>训练时三块 W 怎么更新？从 loss 倒着走一遍：</p>
<ul>
<li>前向：W_q→Q、W_k→K 合成分数 → softmax → 权重 ⊗ V → context → 输出 → loss（每个位置都在预测下一个 token，loss 是所有位置的平均）；</li>
<li>反向：链式法则沿原路倒着流，loss 的梯度分成两路——一路经权重、softmax、scores 流到 Q 和 K，算出 ∂loss/∂W_q 和 ∂loss/∂W_k；另一路流到 V，算出 ∂loss/∂W_v。torch 的 <code>loss.backward()</code> 全自动；</li>
<li>画面是这样的：<strong>前向流的是电流（激活值），反向流的是另一种电流（梯度），电阻（W）在原地被梯度一点点拧动</strong>。</li>
</ul>
<p>这也解释了 sqrt(d_k) 为什么生死攸关：它保的不是数值好看，是<strong>梯度的生命线</strong>。</p>
<h2 id="六和-deepseek-的九问九答精选">六、和 DeepSeek 的九问九答（精选）</h2>
<p>学习过程中我和 DeepSeek 也过了一遍，挑几个有意思的：</p>
<p><strong>Q：Q、K、V 是原始 token 的切分吗？</strong>
不是，是投影。向量在数学上能拆，但拆开就丢信息——token 是最小计算单元。</p>
<p><strong>Q：投影维度必须和原维度一样吗？</strong>
不用。投影规模是可调参数，输入 768 维，投影后不一定是 768 维。</p>
<p><strong>Q：W_q、W_k、W_v 是每个 token 各一份吗？</strong>
不是，全局共用一套。它们是模型级参数——不但一个序列内共用，所有句子都共用同一组“投影角度”。</p>
<p><strong>Q：转置会不会打乱矩阵内部的关系？</strong>
不会。转置只是行列互换，现在的列是原来的行，数字之间的关系原封不动。</p>
<h2 id="七三问式收尾">七、三问式收尾</h2>
<ol>
<li><strong>今天学了什么</strong>：简化注意力三步走、sqrt(d_k) 的量纲归一、Q/K/V 三身份、梯度回流路径；</li>
<li><strong>哪里还没懂</strong>：梯度路径还要再手推一遍才踏实；多头注意力还没读；</li>
<li><strong>明天干什么</strong>：因果掩码（不许偷看未来）+ 多头注意力。</li>
</ol>
<p>关于多头，我留了一个问题给自己：<strong>Q、K、V 真的够吗，投影会不会越多越好？</strong>——先剧透一下答案的方向：三个角色是信息交换的最小完备集，但“更多投影”会以另一种方式兑现。</p>
<p>去读多头就知道了。</p>
<hr>
<p><em>这篇笔记由我和两个 AI 共同完成：DeepSeek 陪我过概念，Kimi 出验收题并负责格式。但每一个字的意思，都是我搞懂的。</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 01：第二章，把文本变成数字</title>
      <link>https://blog.lvxinrong.com/llm/llm-01-ch02/</link>
      <pubDate>Tue, 22 Sep 2026 23:30:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-01-ch02/</guid>
      <description>Tokenizer、BPE、Embedding、位置编码。十几页看了一个半小时，python 不熟、线代还给老师了，但搞懂的瞬间都值了。</description>
      <content:encoded><![CDATA[<blockquote>
<p>这个系列记录我读《从零构建大模型》的过程。不是读书笔记的摘抄，是我和每个概念搏斗的痕迹。规则只有一条：写下来的必须是我自己搞懂的，没懂的如实写“没懂”。</p>
</blockquote>
<h2 id="这一章在干什么">这一章在干什么</h2>
<p>一句话：<strong>把离散的文本，变成神经网络能计算的连续数字。</strong></p>
<p>整个第二章就在干一件事：文本 → token → token ID → 向量。我一开始小看它了，觉得不就是个分词吗。结果十几页的内容，我看了一个半小时，中途还去补了 python 和矩阵的课。</p>
<h2 id="bpe分词是一个数据压缩问题">BPE：分词是一个数据压缩问题</h2>
<p>BPE（Byte Pair Encoding）的思路比我预想的粗暴得多：</p>
<ol>
<li>先把单词分到不能再分——26 个英文字母就是最初的原子；</li>
<li>统计语料里相邻对出现的频率，把最高频的对合并成新 token；</li>
<li>一路合并上去，词表就这么“长”出来了。</li>
</ol>
<p>好处：任何不认识的单词都能被序列化（拆成熟悉的碎片就行），词表大小可控。</p>
<p>我想通的那个瞬间是：<strong>分词从“语言学工程”变成了“数据压缩问题”</strong>。它根本不懂什么叫“词”，它只懂频率。</p>
<h2 id="embedding我被电流和电阻坑了一次">Embedding：我被“电流和电阻”坑了一次</h2>
<p>这一节我栽了跟头，记个完整的纠错过程。</p>
<p>书里的代码把 token ID 丢进 <code>torch.nn.Embedding</code>，出来一个 (B, T, C) 的张量。我一开始的理解是：B 是 batch，T 是切块长度，C 是上下文长度，<strong>这个矩阵是神经网络权重的一部分，会随反向传播更新</strong>。</p>
<p>错了。错在把一个最基础的东西搞混了：</p>
<ul>
<li><strong>Embedding 表</strong>（词表 × C 的那张表）才是权重，是“电阻”，训练会更新它；</li>
<li><strong>(B, T, C) 这个张量</strong>是查表查出来的中间结果，是“电流”，每次前向重新算，用完就扔。</li>
</ul>
<p>Token ID 只是去表里<strong>查行</strong>。词表是固定的，训练更新的是表里那些数值——而且只更新这轮被查到的行。</p>
<p>正确的画面是：</p>
<pre tabindex="0"><code>token IDs (B,T) ──查 Embedding 表(vocab, C)──&gt; (B,T,C) 激活
                                            + 位置向量广播相加
                                            ↓
                                        进 Transformer
</code></pre><p>C 不是“上下文长度”，是每个 token 的特征维度——<strong>一个数字能表达的信息太有限，升到 C 维才有地方放“这个词到底意味着什么”</strong>。</p>
<h2 id="位置编码我犯的一个可爱的错">位置编码：我犯的一个可爱的错</h2>
<p>我一开始想：要给 token 加位置信息，是不是给每个向量加一个下标，256 维变 257 维？</p>
<p>错的。真实做法是<strong>广播相加</strong>：每个位置的向量（T, C）直接加到 (B, T, C) 上——B 个样本共享同一份位置向量。向量里全是数字，没有谁规定哪个维度管“位置”，<strong>训练过程自己会把位置信息“揉”进去</strong>。信息流 + 信息流，不是数组拼接。</p>
<p>顺带搞懂了：绝对位置（GPT-2 用的，在输入层加）和相对位置（RoPE，在 attention 里做）是二选一的方案。</p>
<h2 id="dataset-和-dataloader">Dataset 和 DataLoader</h2>
<p>自己手敲实现了一遍。Dataset 负责“把整本书切成 (输入, 目标) 对”，DataLoader 负责“按 batch 喂”。值得注意的是目标序列就是输入序列<strong>往左移一位</strong>——预测下一个 token，全部的秘密都在这个“移一位”里。</p>
<p>另外一个真实感受：<strong>矩阵运算对 for 循环是降维打击</strong>。手写循环遍历的思路，换成矩阵视角后全部消失。</p>
<h2 id="今天卡住和没搞懂的">今天卡住和没搞懂的</h2>
<ul>
<li>广播的底层我虽然接受了“就这样”，但还没完全消化（留档，后面回头）；</li>
<li>线性代数确实还给老师了，矩阵乘法的手感需要重新练；</li>
<li>python 的语法细节磕磕绊绊，但不慌，用起来就熟了。</li>
</ul>
<h2 id="三问式收尾">三问式收尾</h2>
<ol>
<li>今天学了什么？BPE、Embedding 表、(B,T,C)、位置编码、DataLoader。</li>
<li>哪里还没懂？广播的直觉、矩阵手算的生疏。</li>
<li>明天干什么？第三章，attention——全书真正的主角。</li>
</ol>
<hr>
<p><em>十几页，一个半小时，看到凌晨。慢是慢了点，但每一步都是踩实的。</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 00：立项书</title>
      <link>https://blog.lvxinrong.com/llm/llm-00-proposal/</link>
      <pubDate>Mon, 21 Sep 2026 22:00:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-00-proposal/</guid>
      <description>为什么我要从零造一个大模型。这不是教程的开篇，是一份写给自己的立项文档。</description>
      <content:encoded><![CDATA[<blockquote>
<p>这不是教程，是立项书。项目名：从零手搓一个 LLM。周期：12 周。发起人、执行人、验收人：我自己。</p>
</blockquote>
<h2 id="为什么是现在">为什么是现在</h2>
<p>AI 已经是我日常工作的一部分：写代码、查问题、做排查、写文档，每天都用。但说实话，用得越久，心里越不踏实——我每天都在调用一个我完全不理解的东西。</p>
<p>它为什么能对话？为什么能写代码？为什么给它上文它就知道下一句？这些问题的答案，我一概停留在“知道名词”的水平：Transformer、注意力、训练、推理……名词都认识，连在一起就是天书。</p>
<p>我这辈子有个信条：<strong>想学，就实现一个。</strong></p>
<p>当年 JVM 的书我看了三遍，聊起来还是东一块西一块，串不起来。后来我花了半年，用 Golang 手写了一个 JVM，从那以后，字节码在我眼里就是透明的。那一次教会我：<strong>看懂的和造出来的，是两种理解。</strong></p>
<p>现在轮到 LLM 了。</p>
<h2 id="立项的三个理由">立项的三个理由</h2>
<p><strong>一、拆掉神秘感。</strong></p>
<p>新模型一个月出一个，新闻每天都在喊颠覆。我知道那里面 90% 是营销，但我没有判断力的依据——因为我不懂。不懂就只能被叙事裹挟。把 LLM 搓出来，以后看任何新模型的新闻，我看到的就不是神话，是工程。</p>
<p><strong>二、检验我到底有没有真懂。</strong></p>
<p>我给自己定的理解三级标准：能复述、能手算、能造。对大模型，我要直接奔第三级去。造不出来的理解，都是“以为理解”。</p>
<p><strong>三、给未来的自己修一条管线。</strong></p>
<p>AI 时代的开发者正在分层：一层是“会调 API 的人”，一层是“懂机制、能设计 Agent 和工具链的人”。前者会越来越便宜，后者会越来越贵。我不指望靠这个转行做大模型研究，但我要站在能看懂全局的那一层。</p>
<h2 id="项目目标">项目目标</h2>
<p>唯一目标：<strong>在没有任何框架黑盒的前提下，让我的手写 LLM 输出第一个属于自己的 token。</strong></p>
<ul>
<li>语料：用我自己的语料（博客、笔记、留痕文档）；</li>
<li>平台：家里那台 Dell R730 服务器（它已经在阳台沉默很久了，该醒了）；</li>
<li>参考书：《从零构建大模型》，一章一章过，代码全部手敲；</li>
<li>底线：不复制粘贴。每个字母亲手敲，每个概念亲手验。</li>
</ul>
<h2 id="军规">军规</h2>
<ol>
<li>每周学习时长底线 5 小时，不设上限；</li>
<li>每周一篇三问式笔记：学了什么、哪里没懂、下周干什么；</li>
<li>不买新课，不囤新书，就这一本；</li>
<li>可以放弃，但必须写一份正式的“放弃说明”才能放弃；</li>
<li>每周日复盘一次，进度落后就砍范围，不砍底线。</li>
</ol>
<h2 id="风险与对策">风险与对策</h2>
<ul>
<li><strong>数学基础不够</strong>：线性代数早还给老师了。对策：用到哪补哪，不提前焦虑；</li>
<li><strong>python 不熟</strong>：对策：敲着敲着就熟了；</li>
<li><strong>工作可能很忙</strong>：对策：见军规第一条，底线只有 5 小时；</li>
<li><strong>三分钟热度</strong>：对策：公开笔记，发在博客上，让围观成为约束。</li>
</ul>
<h2 id="立项批复">立项批复</h2>
<p>批准人：吕炘嵘。</p>
<p>批复意见：同意立项。落子无悔，愿赌服输。</p>
<p>立项日期：2026 年 9 月。</p>
<hr>
<p><em>本系列下一篇：第二章笔记《把文本变成数字》。</em></p>
]]></content:encoded>
    </item>
  </channel>
</rss>
