<?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>SFT on 吕炘嵘的博客</title>
    <link>https://blog.lvxinrong.com/tags/sft/</link>
    <description>Recent content in SFT on 吕炘嵘的博客</description>
    <image>
      <title>吕炘嵘的博客</title>
      <url>https://blog.lvxinrong.com/og-default.jpg</url>
      
      <link>https://blog.lvxinrong.com/tags/sft/</link>
    </image>
    <generator>Hugo</generator>
    <language>zh-CN</language>
    <lastBuildDate>Tue, 17 Nov 2026 00:00:00 +0000</lastBuildDate>
    <atom:link href="https://blog.lvxinrong.com/tags/sft/index.xml" rel="self" type="application/rss+xml" />
    <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 笔记 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 笔记 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 笔记 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>手搓 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>
  </channel>
</rss>
