<?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>LoRA on 吕炘嵘的博客</title>
    <link>https://blog.lvxinrong.com/tags/lora/</link>
    <description>Recent content in LoRA on 吕炘嵘的博客</description>
    <image>
      <title>吕炘嵘的博客</title>
      <url>https://blog.lvxinrong.com/og-default.jpg</url>
      
      <link>https://blog.lvxinrong.com/tags/lora/</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/lora/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 笔记 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>
  </channel>
</rss>
