<?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>后训练 on 吕炘嵘的博客</title>
    <link>https://blog.lvxinrong.com/tags/%E5%90%8E%E8%AE%AD%E7%BB%83/</link>
    <description>Recent content in 后训练 on 吕炘嵘的博客</description>
    <image>
      <title>吕炘嵘的博客</title>
      <url>https://blog.lvxinrong.com/og-default.jpg</url>
      
      <link>https://blog.lvxinrong.com/tags/%E5%90%8E%E8%AE%AD%E7%BB%83/</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/%E5%90%8E%E8%AE%AD%E7%BB%83/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 笔记 25：I4 DPO 偏好优化</title>
      <link>https://blog.lvxinrong.com/llm/llm-25-i4-dpo-preference/</link>
      <pubDate>Mon, 16 Nov 2026 15:00:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-25-i4-dpo-preference/</guid>
      <description>DPO 起步实录：理解 chosen / rejected、序列 logprob、参考模型、score 与 loss，完成偏好数据、模板编码审计和单步更新。记录梯度裁剪对 Adam 整体缩放不敏感，以及 LR=1e-7 的温和更新；批量 DPO 训练尚未开始。</description>
      <content:encoded><![CDATA[<p>今天先停在 <strong>DPO 小批量训练之前</strong>。</p>
<p>这一阶段没有把 DPO 当成一个需要马上跑通的训练脚本，而是先拆开它最基本的概念和计算链路：什么是 chosen / rejected，怎样计算一段输出的 logprob，参考模型起什么作用，score 和 loss 如何产生，以及一次真实更新为什么会过于激进。</p>
<p>当前状态是：<strong>DPO 概念、偏好数据、模板编码和单步验证已完成；批量训练、checkpoint 和训练后的行为评估尚未开始。</strong></p>
<h2 id="一sft-与-dpo模仿答案还是学习偏好">一、SFT 与 DPO：模仿答案，还是学习偏好</h2>
<p>SFT 的目标比较直接：给模型一个标准回答，让它学习怎样生成。</p>
<p>DPO（Direct Preference Optimization）关注的是同一个 Prompt 下两个回答的相对关系：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Chosen：希望模型更倾向的回答
</span></span><span class="line"><span class="cl">Rejected：希望模型少倾向的回答
</span></span></code></pre></div><p>Rejected 不一定是绝对错误，也可能只是没有 Chosen 好。例如两个答案都正确，但一个简洁、一个啰嗦。DPO 不是给所有场景规定两个绝对方向，而是学习<strong>同一个 Prompt 下的相对偏好</strong>。</p>
<p>本轮的起点和参考模型都使用原始 Qwen3-0.6B Instruct。这样可以从原生 CoT 能力出发，研究“简短、正确、结构完整”的回答偏好，而不是先修复上一轮 SFT 造成的行为退化。</p>
<h2 id="二偏好数据长什么样">二、偏好数据长什么样</h2>
<p>第一版偏好探针使用：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-json" data-lang="json"><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;messages&#34;</span><span class="p">:</span> <span class="p">[</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span><span class="nt">&#34;role&#34;</span><span class="p">:</span> <span class="s2">&#34;system&#34;</span><span class="p">,</span> <span class="nt">&#34;content&#34;</span><span class="p">:</span> <span class="s2">&#34;你是一个乐于助人的 AI 助手。&#34;</span><span class="p">},</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span><span class="nt">&#34;role&#34;</span><span class="p">:</span> <span class="s2">&#34;user&#34;</span><span class="p">,</span> <span class="nt">&#34;content&#34;</span><span class="p">:</span> <span class="s2">&#34;37 × 6 等于多少？请简短推理并给出最终数字。&#34;</span><span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="p">],</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;chosen&#34;</span><span class="p">:</span> <span class="s2">&#34;&lt;think&gt;\n30 × 6 = 180，7 × 6 = 42。\n180 + 42 = 222。\n&lt;/think&gt;\n\n222&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;rejected&#34;</span><span class="p">:</span> <span class="s2">&#34;&lt;think&gt;\n让我先想一下……&lt;/think&gt;\n\n226&#34;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p><code>messages</code> 负责提供上下文，chosen / rejected 是候选 Assistant 输出。计算序列概率时，只累计候选输出中目标 token 的 logprob，不把 Prompt 当作需要生成的答案。</p>
<h2 id="三序列-logprob模型怎样给一段回答打分">三、序列 logprob：模型怎样给一段回答打分</h2>
<p>对一段 Assistant 输出：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">log p(token₁, token₂, ..., tokenₙ)
</span></span><span class="line"><span class="cl">= 每个目标 token 的 log 概率之和
</span></span></code></pre></div><p>logprob 越接近 0，模型分配的序列概率越高；越负，概率越低。长回答通常也会累积更大的负值，因此不能只凭总 logprob 判断回答质量。</p>
<p>本轮原始探针得到：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>输出</th>
        <th style="text-align: right">序列 logprob</th>
        <th style="text-align: right">Token 数</th>
        <th style="text-align: right">平均每 token logprob</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>Chosen</td>
        <td style="text-align: right">-46.830143</td>
        <td style="text-align: right">41</td>
        <td style="text-align: right">-1.142199</td>
      </tr>
      <tr>
        <td>Rejected</td>
        <td style="text-align: right">-152.992218</td>
        <td style="text-align: right">74</td>
        <td style="text-align: right">-2.067462</td>
      </tr>
    </tbody>
  </table>
</div>
<p>差值为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">-46.830143 - (-152.992218) = +106.162075
</span></span></code></pre></div><p>这表示原始模型给 Chosen 的序列概率更高，不是“好 106%”。同时，这个探针里原始模型本来就很偏好 Chosen，因此它适合演示计算，但未必能提供很强的训练信号。</p>
<p>核心计算使用：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">with</span> <span class="n">torch</span><span class="o">.</span><span class="n">set_grad_enabled</span><span class="p">(</span><span class="n">require_grad</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">logits</span> <span class="o">=</span> <span class="n">model</span><span class="p">(</span><span class="n">inputs</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="n">log_probs</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">log_softmax</span><span class="p">(</span><span class="n">logits</span><span class="p">,</span> <span class="n">dim</span><span class="o">=-</span><span class="mi">1</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="n">token_logprobs</span> <span class="o">=</span> <span class="n">log_probs</span><span class="o">.</span><span class="n">gather</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="o">-</span><span class="mi">1</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="n">safe_targets</span><span class="o">.</span><span class="n">unsqueeze</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">),</span>
</span></span><span class="line"><span class="cl">    <span class="p">)</span><span class="o">.</span><span class="n">squeeze</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="n">mask</span> <span class="o">=</span> <span class="n">targets</span> <span class="o">!=</span> <span class="o">-</span><span class="mi">100</span>
</span></span><span class="line"><span class="cl">    <span class="n">total</span> <span class="o">=</span> <span class="p">(</span><span class="n">token_logprobs</span> <span class="o">*</span> <span class="n">mask</span><span class="p">)</span><span class="o">.</span><span class="n">sum</span><span class="p">()</span>
</span></span></code></pre></div><p><code>targets</code> 必须和 <code>inputs</code> 一样保留 Batch 维度，否则 gather 时会出现维度错误。</p>
<h2 id="四参考模型与-dpo-loss">四、参考模型与 DPO loss</h2>
<p>DPO 真正优化的不是简单的 <code>chosen - rejected</code>，而是当前模型相对参考模型的偏好变化：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">score =
</span></span><span class="line"><span class="cl">  (policy_chosen_logprob - reference_chosen_logprob)
</span></span><span class="line"><span class="cl">  -
</span></span><span class="line"><span class="cl">  (policy_rejected_logprob - reference_rejected_logprob)
</span></span></code></pre></div><p>损失形式为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">loss = -log sigmoid(β × score)
</span></span></code></pre></div><p>训练刚开始时，policy 和 reference 使用同一份权重：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">score = 0
</span></span><span class="line"><span class="cl">loss = -log sigmoid(0) = ln 2 ≈ 0.693147
</span></span></code></pre></div><p>本轮 <code>beta=0.1</code> 时，探针实际得到：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-json" data-lang="json"><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;score&#34;</span><span class="p">:</span> <span class="mf">0.0</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;loss&#34;</span><span class="p">:</span> <span class="mf">0.6931471824645996</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>这验证了 DPO 初始计算链路。参考模型的作用是提供一个锚点，避免只追求偏好差值而把模型推得太远。</p>
<h3 id="指标复盘我的理解与需要保留的边界">指标复盘：我的理解与需要保留的边界</h3>
<p>在真正开始批量训练前，我又把 DPO 中几个容易混淆的指标从头过了一遍。这里同时记录最初的直觉和修正后的理解，避免只保留最后一句定义。</p>
<h4 id="1-token-概率不是-logitssequence_logprob-也不是字符串距离">1. token 概率不是 logits，sequence_logprob 也不是字符串距离</h4>
<p>模型在每个位置先返回整个词表的 logits。它们是原始打分，有正有负，也不要求总和为 1：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">logits
</span></span><span class="line"><span class="cl">→ softmax：整个词表的概率分布
</span></span><span class="line"><span class="cl">→ log：整个词表的 log 概率分布
</span></span><span class="line"><span class="cl">→ gather：取目标 token 对应的 logprob
</span></span></code></pre></div><p>如果目标序列是 <code>a b c</code>，序列概率不是三个独立概率的乘积，而是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">p(a | prompt)
</span></span><span class="line"><span class="cl">× p(b | prompt, a)
</span></span><span class="line"><span class="cl">× p(c | prompt, a, b)
</span></span></code></pre></div><p>取自然对数后，连乘变成连加：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">log p(a,b,c)
</span></span><span class="line"><span class="cl">= ln p(a | prompt)
</span></span><span class="line"><span class="cl">+ ln p(b | prompt, a)
</span></span><span class="line"><span class="cl">+ ln p(c | prompt, a, b)
</span></span></code></pre></div><p>我一开始把 sequence_logprob 理解成“生成序列与目标序列的距离”，认为越接近 0 就越接近正确答案。这个理解需要修正：</p>
<blockquote>
<p><strong>sequence_logprob 是模型给目标序列分配的条件概率的 log 值，不是编辑距离，也不是正确率。</strong></p>
</blockquote>
<p>越接近 0，说明模型越倾向于生成这条目标序列。如果目标本身是错误答案，模型也可能非常自信地错误。只有目标确实是正确回答时，才能进一步解释为对正确答案的倾向增强。</p>
<p><code>mean_logprob_per_token</code> 只是长度归一化后的观察指标，不是 DPO 的优化目标。</p>
<h4 id="2-chosen_minus_rejected-是当前模型的原始偏好差">2. chosen_minus_rejected 是当前模型的原始偏好差</h4>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">chosen_minus_rejected
</span></span><span class="line"><span class="cl">= sequence_logprob(chosen) - sequence_logprob(rejected)
</span></span></code></pre></div><p>也可以写成：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">log [p(chosen) / p(rejected)]
</span></span></code></pre></div><p>我的理解是：</p>
<ul>
<li>大于 0：当前模型更倾向 Chosen；</li>
<li>小于 0：当前模型更倾向 Rejected；</li>
<li>等于 0：两者的序列概率相同；</li>
<li>差值的绝对值越大，说明当前模型对两者的概率倾向差异越大。</li>
</ul>
<p>但它仍然不是质量分：一方面它不代表哪个回答客观上更正确，另一方面序列 logprob 会受回答长度影响，不能把它当成跨样本公平比较的指标。</p>
<h4 id="3-score-是两个模型的偏好差之差">3. score 是两个模型的偏好差之差</h4>
<p>设 A 为训练前的参考模型，B 为训练后的 policy：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">policy_chosen = B 给 Chosen 的 sequence_logprob
</span></span><span class="line"><span class="cl">policy_rejected = B 给 Rejected 的 sequence_logprob
</span></span><span class="line"><span class="cl">reference_chosen = A 给 Chosen 的 sequence_logprob
</span></span><span class="line"><span class="cl">reference_rejected = A 给 Rejected 的 sequence_logprob
</span></span></code></pre></div><p><code>policy_chosen</code> 不是 chosen_minus_rejected，而是单独对 Chosen 的序列 logprob 计算。</p>
<p>先分别计算两个模型的原始偏好差：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">diff_A = A_chosen - A_rejected
</span></span><span class="line"><span class="cl">diff_B = B_chosen - B_rejected
</span></span></code></pre></div><p>DPO 的 score 是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">score = diff_B - diff_A
</span></span></code></pre></div><p>展开就是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">(B_chosen - A_chosen)
</span></span><span class="line"><span class="cl">-
</span></span><span class="line"><span class="cl">(B_rejected - A_rejected)
</span></span></code></pre></div><p>我最初写成了 <code>diff_A - diff_B</code>，虽然“拆开比较两个模型”的思路是对的，但顺序反了，整个符号也会相反。正确方向是<strong>训练后减训练前</strong>。</p>
<p><code>score &gt; 0</code> 表示训练后模型对 Chosen 相对于 Rejected 的偏好优势增强了；<code>score &lt; 0</code> 表示这个相对优势减弱了。</p>
<p>但 score 仍不是整体能力分：</p>
<ul>
<li>它不能说明最终答案一定更正确；</li>
<li>它不能说明 CoT 格式一定更好；</li>
<li>它不能说明其他能力没有被破坏；</li>
<li>它也不能单独区分是 Chosen 提高、Rejected 降低，还是两者同时变化。</li>
</ul>
<p>所以必须继续查看两个候选各自的 logprob 分量。</p>
<h4 id="4-loss-是偏好关系的-logistic-loss">4. loss 是偏好关系的 logistic loss</h4>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">loss = -log sigmoid(β × score)
</span></span></code></pre></div><p>在 β 固定时，score 增大，loss 降低；score 减小，loss 升高。</p>
<p>它与 SFT 的 token 级交叉熵不同，优化的是偏好关系。loss 下降说明偏好优化方向符合目标，不代表模型整体能力一定提升。</p>
<h4 id="5-β-是偏好压力旋钮不是学习率或百分比">5. β 是偏好压力旋钮，不是学习率或百分比</h4>
<p>我暂时把 β 理解为偏好压力旋钮：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">β 较小：偏好压力通常更温和
</span></span><span class="line"><span class="cl">β 较大：偏好压力通常更强
</span></span></code></pre></div><p>但 β 不是“采用多少比例的更新”，也不是直接乘在参数更新上的 LR。它先把 score 缩放，再进入 sigmoid，影响 loss 的非线性变化和偏好约束强度。</p>
<p>实际更新幅度由 β、score、LR、优化器和梯度裁剪共同决定。</p>
<h4 id="6-grad-norm-是梯度向量长度不是平均梯度">6. grad norm 是梯度向量长度，不是平均梯度</h4>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">grad norm = sqrt(所有梯度值的平方和)
</span></span></code></pre></div><p>它通常是一次反向传播后，所有可训练参数梯度拼成的长向量的 L2 范数，用来观察整体梯度规模。</p>
<p>流程是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">loss.backward()
</span></span><span class="line"><span class="cl">→ 计算 grad norm
</span></span><span class="line"><span class="cl">→ 可选：梯度裁剪
</span></span><span class="line"><span class="cl">→ optimizer.step()
</span></span></code></pre></div><p>因此要把几个概念分开：</p>
<ul>
<li>loss：优化目标；</li>
<li>β：偏好压力；</li>
<li>grad norm：梯度规模；</li>
<li>LR：实际更新步长；</li>
<li>optimizer：决定梯度如何转换为参数更新。</li>
</ul>
<p>昨天的实验还说明，整体裁剪梯度不一定能显著改变 Adam 的单步更新；直接降低 LR 才真正缩小了 score 和 logprob 的变化幅度。</p>
<h4 id="7-现在对整组指标的理解">7. 现在对整组指标的理解</h4>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">sequence_logprob：模型给某段输出的序列概率
</span></span><span class="line"><span class="cl">chosen_minus_rejected：当前模型对两个候选的原始偏好差
</span></span><span class="line"><span class="cl">score：当前模型相对参考模型的偏好变化
</span></span><span class="line"><span class="cl">loss：把 score 转成可优化目标
</span></span><span class="line"><span class="cl">β：偏好压力旋钮
</span></span><span class="line"><span class="cl">grad norm：反向传播得到的整体梯度规模
</span></span></code></pre></div><p>这些指标都不能单独回答“模型能力是否提升”。最后仍要回到 answer_correct、CoT 格式、输出长度、自然结束和旧能力保持。</p>
<h2 id="五一次真实单步更新loss-下降不等于能力提升">五、一次真实单步更新：loss 下降不等于能力提升</h2>
<p>使用冻结的参考模型和可训练的 policy，执行一次真实的 <code>loss.backward()</code> 与 <code>optimizer.step()</code>。</p>
<p>在 <code>peak_lr=1e-6</code> 时：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">before score = 0
</span></span><span class="line"><span class="cl">before loss = 0.693147
</span></span><span class="line"><span class="cl">grad norm = 268.085846
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">after score = 35.349922
</span></span><span class="line"><span class="cl">after loss = 0.028742
</span></span></code></pre></div><p>更新前后两个候选的序列 logprob 为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Chosen：  -46.830143 → -44.240398
</span></span><span class="line"><span class="cl">Rejected：-152.992218 → -185.752396
</span></span></code></pre></div><p>这意味着：</p>
<ul>
<li>Chosen 提高了约 2.59；</li>
<li>Rejected 被压低约 32.76；</li>
<li>score 的大幅提升主要来自 Rejected 被压低，而不是 Chosen 变好了多少。</li>
</ul>
<p>因此，<strong>DPO loss 下降不自动等于模型能力提升</strong>。如果更新过猛，仍可能破坏其他正常输出。</p>
<h2 id="六梯度裁剪生效为什么输出却几乎不变">六、梯度裁剪生效，为什么输出却几乎不变</h2>
<p>加入：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">torch</span><span class="o">.</span><span class="n">nn</span><span class="o">.</span><span class="n">utils</span><span class="o">.</span><span class="n">clip_grad_norm_</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">policy_model</span><span class="o">.</span><span class="n">parameters</span><span class="p">(),</span>
</span></span><span class="line"><span class="cl">    <span class="n">max_norm</span><span class="o">=</span><span class="mf">1.0</span><span class="p">,</span>
</span></span><span class="line"><span class="cl"><span class="p">)</span>
</span></span></code></pre></div><p>裁剪后实际梯度范数为 1，但 score 和 logprob 几乎不变。</p>
<p>原因是梯度裁剪对所有梯度做同比例缩放，而 Adam 的更新会进行一阶、二阶动量归一化。整体缩放后，方向与归一化结果可能非常接近，尤其在单步、无 weight decay 的情况下。</p>
<p>所以这次得到的工程结论是：</p>
<blockquote>
<p><strong>梯度裁剪可以限制梯度规模，但不能代替降低学习率来控制 Adam 的实际更新幅度。</strong></p>
</blockquote>
<h2 id="七lr1e-7更温和的单步变化">七、LR=1e-7：更温和的单步变化</h2>
<p>将学习率从 <code>1e-6</code> 降到 <code>1e-7</code>，保留 <code>beta=0.1</code> 和 <code>grad clip=1.0</code>：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>指标</th>
        <th style="text-align: right">LR=1e-6</th>
        <th style="text-align: right">LR=1e-7</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>score change</td>
        <td style="text-align: right">35.333</td>
        <td style="text-align: right"><strong>3.698</strong></td>
      </tr>
      <tr>
        <td>更新后 loss</td>
        <td style="text-align: right">0.0288</td>
        <td style="text-align: right"><strong>0.5252</strong></td>
      </tr>
      <tr>
        <td>Chosen 变化</td>
        <td style="text-align: right">+2.588</td>
        <td style="text-align: right"><strong>+0.339</strong></td>
      </tr>
      <tr>
        <td>Rejected 变化</td>
        <td style="text-align: right">-32.745</td>
        <td style="text-align: right"><strong>-3.359</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<p>学习率缩小 10 倍后，score 变化也大约缩小 10 倍，更新方向没有改变，但明显温和得多。</p>
<p>因此当前候选起点是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">LR = 1e-7
</span></span><span class="line"><span class="cl">beta = 0.1
</span></span><span class="line"><span class="cl">grad clip = 1.0
</span></span></code></pre></div><p>它只是一个偏好探针得出的候选配置，不能据此宣称是正式训练的最佳配置。</p>
<h2 id="八dpo-编码prompt-与候选输出必须分开处理">八、DPO 编码：Prompt 与候选输出必须分开处理</h2>
<p>本次还实际遇到了一个模板问题：如果把 chosen / rejected 也交给 Chat Template 重新渲染，模板可能拆分、清理甚至重写思考标签，导致 malformed 的原始输出被“修正”。</p>
<p>最后的正确分工是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">prefix_text</span> <span class="o">=</span> <span class="n">tokenizer</span><span class="o">.</span><span class="n">apply_chat_template</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">messages</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">tokenize</span><span class="o">=</span><span class="kc">False</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">add_generation_prompt</span><span class="o">=</span><span class="kc">True</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">enable_thinking</span><span class="o">=</span><span class="kc">True</span><span class="p">,</span>
</span></span><span class="line"><span class="cl"><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="n">full_text</span> <span class="o">=</span> <span class="n">prefix_text</span> <span class="o">+</span> <span class="n">response</span> <span class="o">+</span> <span class="s2">&#34;&lt;|im_end|&gt;</span><span class="se">\n</span><span class="s2">&#34;</span>
</span></span></code></pre></div><p>也就是：</p>
<ul>
<li>Prompt 使用官方 Chat Template；</li>
<li>chosen / rejected 作为原始候选输出直接追加；</li>
<li>不让模板二次修改候选回答；</li>
<li>再从 prefix / full 的 token 长度计算目标区间。</li>
</ul>
<p>这样正常 CoT 与空思考、缺失标签、标签交错等 malformed 输出都能保留原始形式进入 logprob 计算。</p>
<h2 id="九32--8-条偏好数据与审计">九、32 + 8 条偏好数据与审计</h2>
<p>本轮合成偏好数据分为四种 rejected 类型：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>pair_type</th>
        <th style="text-align: right">Train</th>
        <th style="text-align: right">Val</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>verbose_correct</td>
        <td style="text-align: right">8</td>
        <td style="text-align: right">2</td>
      </tr>
      <tr>
        <td>verbose_wrong</td>
        <td style="text-align: right">8</td>
        <td style="text-align: right">2</td>
      </tr>
      <tr>
        <td>repetition</td>
        <td style="text-align: right">8</td>
        <td style="text-align: right">2</td>
      </tr>
      <tr>
        <td>malformed</td>
        <td style="text-align: right">8</td>
        <td style="text-align: right">2</td>
      </tr>
      <tr>
        <td>合计</td>
        <td style="text-align: right"><strong>32</strong></td>
        <td style="text-align: right"><strong>8</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<p>每类内部，单轮算术与多轮数值更新各占一半。</p>
<p>数据要求：</p>
<ul>
<li>Chosen 必须是简短、正确、结构完整的 CoT；</li>
<li>verbose_correct 的 Rejected 答案正确但明显啰嗦；</li>
<li>verbose_wrong 的 Rejected 含明确计算或最终答案错误；</li>
<li>repetition 包含重复或自我怀疑；</li>
<li>malformed 包含空思考、缺失标签、前置乱码或结构混乱。</li>
</ul>
<p><code>i4_dpo_data_audit.py</code> 实际验证：</p>
<ul>
<li>样本数量、任务比例和四种 pair_type 数量；</li>
<li>Chosen 的 CoT 格式、最终答案和中间算式；</li>
<li>Rejected 是否符合对应类型；</li>
<li>train / val 无重复 Prompt；</li>
<li>与已有 smoke、非 CoT、CoT 数据无重复显式算式；</li>
<li>行为基线排除项未命中；</li>
<li>全部 chosen / rejected 均通过偏好编码。</li>
</ul>
<p>审计输出为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">train chosen equations checked: 37
</span></span><span class="line"><span class="cl">val chosen equations checked: 8
</span></span><span class="line"><span class="cl">preference encoding: passed
</span></span><span class="line"><span class="cl">train / val prompt overlap: 0
</span></span><span class="line"><span class="cl">existing-data expression overlap: 0
</span></span><span class="line"><span class="cl">exclusion checks: passed
</span></span><span class="line"><span class="cl">全部 DPO 数据审计通过
</span></span></code></pre></div><p>这些是合成偏好数据，不代表人工标注，也不代表通用能力结论。</p>
<h2 id="十今晚的停止边界">十、今晚的停止边界</h2>
<p>今天完成的是：</p>
<ul>
<li>DPO 基本概念与数据契约；</li>
<li>序列 logprob、score 和初始 loss；</li>
<li>单步更新、梯度范数与 Adam 缩放现象；</li>
<li>LR=1e-7 的温和更新；</li>
<li>偏好数据与完整编码审计。</li>
</ul>
<p>尚未完成：</p>
<ul>
<li>小批量 DPO 训练；</li>
<li>DPO checkpoint；</li>
<li>训练后的答案正确率、CoT 格式、输出长度和能力保持评估；</li>
<li>LoRA / 全参对照；</li>
<li>RLVR / GRPO。</li>
</ul>
<p>所以当前不能写成“DPO 已提升模型”。准确状态是：<strong>DPO 的数据、计算和单步工程验证已经准备完成，下一步才是小批量训练与行为对照。</strong></p>
<p>今晚先到这里，保留已有 checkpoint、报告、偏好数据和编码实现，明天从批量 DPO 开始即可。</p>
<h2 id="附参数规模垂直领域与能力权衡">附：参数规模、垂直领域与能力权衡</h2>
<p>在后训练实验之外，我又梳理了一次自己对“为什么做垂直领域微调”的认知。这不是一个已经证明的结论，而是后续选择模型、数据和评测目标时的一套假设。</p>
<h3 id="1-我目前的三个判断">1. 我目前的三个判断</h3>
<p>第一，参数规模决定模型的能力上限。大厂在固定参数下训练出的通用模型，大概率希望成为六边形战士；但垂直领域并不一定需要六边形战士。</p>
<p>例如做架构设计时，我可以接受模型在数学、科研等领域不那么突出，把有限的容量和训练预算集中到架构领域，换取这一领域内的大幅度提升。</p>
<p>第二，一个 27B 模型经过合适的领域微调，如果能在架构设计这一明确任务范围内，与 100B+ 的通用模型打得有来有回，就已经足够有价值。这里追求的不是全面替代更大的模型，而是在垂直场景中形成实际优势。</p>
<p>第三，大厂基础模型已经做了大量通用优化。对具体使用者来说，微调、SFT、DPO 等方法更像是在做权衡和有的放矢，而不是继续追求全面提升。微调前需要明确要突出哪一方面，也要接受这更像系统架构中的 trade-off。</p>
<h3 id="2-需要补充的第一条边界参数规模不是唯一变量">2. 需要补充的第一条边界：参数规模不是唯一变量</h3>
<p>参数规模影响模型容量、知识承载和复杂推理上限，但同样规模的模型，实际能力还可能受这些因素影响：</p>
<ul>
<li>训练数据质量与覆盖；</li>
<li>训练 token 量和计算量；</li>
<li>架构与训练方法；</li>
<li>后训练方式；</li>
<li>推理时的上下文、工具、检索和思考预算。</li>
</ul>
<p>因此，27B 模型在垂直领域挑战更大的通用模型是合理目标，尤其是在任务边界清楚、领域数据质量高、评价标准明确的情况下。</p>
<p>但这不代表它获得了大模型的全部能力，更可能是把有限容量集中到了一个更窄、更有价值的任务分布内。</p>
<h3 id="3-需要补充的第二条边界领域提升不必然牺牲其他能力但一定存在权衡风险">3. 需要补充的第二条边界：领域提升不必然牺牲其他能力，但一定存在权衡风险</h3>
<p>微调并不是每次都必须“数学下降，架构上升”。如果数据混合合理、训练强度适当，也可能在保留通用能力的同时提升领域表现。</p>
<p>但 I4 的实验已经给出了真实例子：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">格式能力提升
</span></span><span class="line"><span class="cl">→ 名字记忆出现回退
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">数值更新提升
</span></span><span class="line"><span class="cl">→ 部分算术正确率回退
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">偏好 loss 降低
</span></span><span class="line"><span class="cl">→ 最终行为没有同步改善
</span></span></code></pre></div><p>所以真正需要管理的是：</p>
<blockquote>
<p><strong>我愿意接受哪些能力损失，以及怎样通过 eval 及时发现实际发生的损失。</strong></p>
</blockquote>
<p>有些损失是主动接受的，有些是不小心造成的。只有设置能力保持评测，才能区分这两者。</p>
<h3 id="4-需要补充的第三条边界领域优势必须限定任务分布">4. 需要补充的第三条边界：领域优势必须限定任务分布</h3>
<p>“27B 架构模型和 100B+ 通用模型有来有回”还需要继续追问是在什么任务上：</p>
<ul>
<li>编写常规架构文档；</li>
<li>根据明确需求做技术选型；</li>
<li>发现复杂系统中的依赖与故障风险；</li>
<li>面对陌生业务做开放式架构权衡；</li>
<li>审查真实代码、数据和运行证据，还是只根据提示词给建议。</li>
</ul>
<p>越靠近固定流程、明确格式和常见案例，小模型领域化越容易取得优势；越接近开放问题、跨领域推理和复杂长链路决策，大模型的通用能力仍然可能很重要。</p>
<p>因此，领域模型超过大模型必须限定在明确的任务分布与评价口径内，不能从一组领域测试直接推广成全面超越。</p>
<h3 id="5-把训练目标写成一份架构-trade-off-说明">5. 把训练目标写成一份架构 trade-off 说明</h3>
<p>如果后续真的训练架构领域模型，可以把目标写成：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">目标：架构领域能力显著提升
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">约束：
</span></span><span class="line"><span class="cl">- 通用代码能力最多允许下降多少
</span></span><span class="line"><span class="cl">- 数学能力是否可以不保留
</span></span><span class="line"><span class="cl">- 多轮指令遵循不能退化
</span></span><span class="line"><span class="cl">- 输出结构与工具调用必须稳定
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">验收：
</span></span><span class="line"><span class="cl">- 架构领域测试集
</span></span><span class="line"><span class="cl">- 未见项目与跨域测试
</span></span><span class="line"><span class="cl">- 通用能力保持集
</span></span><span class="line"><span class="cl">- 失败与回退案例
</span></span></code></pre></div><p>这和系统架构设计很像：不是追求所有指标无限上升，而是在明确目标、约束和成本的前提下做选择，并用评测验证选择是否成立。</p>
<h3 id="6-架构领域尤其需要区分权重与上下文">6. 架构领域尤其需要区分权重与上下文</h3>
<p>架构知识并不都适合固化进权重：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">架构原则、设计方法、评审方式
</span></span><span class="line"><span class="cl">→ 可以通过训练内化
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">当前系统结构、依赖、容量、故障现场
</span></span><span class="line"><span class="cl">→ 更适合由代码图谱、知识库和运行时上下文提供
</span></span></code></pre></div><p>如果训练的是会背架构答案的模型，它可能只能在熟悉模板里表现良好；真正有价值的是在明确任务分布内，基于真实证据做出可评审的设计决策，同时保留必要的代码分析和系统推理能力。</p>
<h3 id="7-当前结论">7. 当前结论</h3>
<p>垂直微调的目标不是培养一个更小的六边形战士，而是在明确任务分布内，把有限参数用到最有价值的地方，并且清楚知道自己付出了什么代价。</p>
<p>这套认知与 I4 的实验结论是一致的：<strong>后训练不是无成本的全面增强，而是能力分布的重新塑造。目标、约束和 eval 必须同时设计。</strong></p>
<h2 id="主要实验产物">主要实验产物</h2>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">data/instruct/i4_dpo_preference_probe.json
</span></span><span class="line"><span class="cl">data/instruct/i4_dpo_synthetic_train.json
</span></span><span class="line"><span class="cl">data/instruct/i4_dpo_synthetic_val.json
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">scripts/i4_dpo_logprob_probe.py
</span></span><span class="line"><span class="cl">scripts/i4_dpo_one_step.py
</span></span><span class="line"><span class="cl">scripts/i4_dpo_data_audit.py
</span></span><span class="line"><span class="cl">scripts/i4_cot_behavior_eval.py
</span></span><span class="line"><span class="cl">scripts/i4_behavior_baseline.py
</span></span></code></pre></div>]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 24：I4 思维链 CoT-SFT</title>
      <link>https://blog.lvxinrong.com/llm/llm-24-i4-cot-sft/</link>
      <pubDate>Mon, 16 Nov 2026 12:00:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-24-i4-cot-sft/</guid>
      <description>从 CoT 数据契约、Qwen 历史思考剥离和严格格式验收出发，完成 128 + 32 条 CoT 数据审计与三组 peak_lr 对照。记录 CoT 丢失、低学习率恢复、输出长度与推理算式变化，以及最终答案未超过原始模型的边界。</description>
      <content:encoded><![CDATA[<p>这篇记录 <strong>I4-C：思维链 CoT-SFT 的受控实验与阶段收官</strong>。它不是“CoT 能力已经解决”的证明，而是一次从数据协议、模板行为、训练干预到行为验收的完整排障。</p>
<p>最后得到的结论并不只是“哪个学习率最好”，而是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">原始模型已经会生成 CoT
</span></span><span class="line"><span class="cl">→ 全参数 SFT 在不同 peak_lr 下产生不同程度的行为破坏
</span></span><span class="line"><span class="cl">→ 低学习率版本保留并改善了一部分行为
</span></span><span class="line"><span class="cl">→ 但最终答案正确率仍没有整体超过原始模型
</span></span></code></pre></div><h2 id="一实验目标与基线">一、实验目标与基线</h2>
<p>本轮继续使用 <strong>Qwen3-0.6B Instruct</strong>，从原始权重开始。实际运行环境为 MacBook M4 Pro、MPS、FP32。</p>
<p>实验问题不是“模型能不能显示 <code>&lt;think&gt;</code>”，而是：</p>
<ul>
<li>简短、正确的 CoT 数据能否改善推理表达；</li>
<li>最终答案与思考结构能否同时保持；</li>
<li>不同 peak_lr 会如何影响原生 CoT 行为；</li>
<li>训练后是否变得更短、更可靠，还是只是 loss 更低。</li>
</ul>
<p>第一版 CoT 行为基线使用 32 条独立验证样本，分别统计：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">answer_correct：最终数字是否正确
</span></span><span class="line"><span class="cl">format_compliant：是否以 &lt;think&gt; 开始，恰好一对标签、非空推理、纯数字答案，且推理不是答案复读
</span></span><span class="line"><span class="cl">finish_reason：自然结束还是长度截断
</span></span></code></pre></div><p>原始模型的基线结果为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">answer_correct = 30/32
</span></span><span class="line"><span class="cl">format_compliant = 32/32
</span></span><span class="line"><span class="cl">passed = 30/32
</span></span><span class="line"><span class="cl">empty = 0
</span></span><span class="line"><span class="cl">natural_stop = 32/32
</span></span></code></pre></div><p>原始模型已经具备完整 CoT 输出能力，主要问题是思考偏长、存在自我怀疑，以及少量算术和推理错误。</p>
<h2 id="二cot-数据契约监督完整-assistant-输出">二、CoT 数据契约：监督完整 Assistant 输出</h2>
<h3 id="1-思考标签也属于训练目标">1. 思考标签也属于训练目标</h3>
<p>本轮选择监督完整 Assistant 输出，而不是只监督最终答案：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">&lt;think&gt;
</span></span><span class="line"><span class="cl">简短、正确的推理
</span></span><span class="line"><span class="cl">&lt;/think&gt;
</span></span><span class="line"><span class="cl">最终答案
</span></span><span class="line"><span class="cl">&lt;|im_end|&gt;
</span></span></code></pre></div><p>在固定探针中，Full 下标为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">31～33：Assistant 角色头
</span></span><span class="line"><span class="cl">34：    &lt;think&gt;
</span></span><span class="line"><span class="cl">36～87：推理正文
</span></span><span class="line"><span class="cl">88：    &lt;/think&gt;
</span></span><span class="line"><span class="cl">90～92：最终答案 600
</span></span><span class="line"><span class="cl">93：    &lt;|im_end|&gt;
</span></span></code></pre></div><p>因此：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">full[34:94] → targets[33:93]
</span></span></code></pre></div><p>Assistant 角色头、System 和 User 不计 loss；思考标签、推理正文、最终答案和 <code>&lt;|im_end|&gt;</code> 都参与 loss。</p>
<p>这样训练的是完整输出协议：开始思考、进行推理、结束思考、给出答案、正常结束，而不是只学习答案格式。</p>
<h3 id="2-多轮-cot-的一个真实兼容问题">2. 多轮 CoT 的一个真实兼容问题</h3>
<p>GPT 辅助生成数据后，发现了一个系统性问题：<strong>Qwen 模板会剥离历史 Assistant 的思考过程，只保留最终答案。</strong></p>
<p>例如原始数据是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Assistant 1：&lt;think&gt;12 × 16 = 192。&lt;/think&gt;192
</span></span><span class="line"><span class="cl">User 2：补货后变为 3 倍
</span></span><span class="line"><span class="cl">Assistant 2：&lt;think&gt;192 × 3 = 576。&lt;/think&gt;576
</span></span></code></pre></div><p>模板实际保留的是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">历史 Assistant：192
</span></span><span class="line"><span class="cl">最后一轮 Assistant：完整 CoT + 576
</span></span></code></pre></div><p>第一版 <code>find_assistant_spans()</code> 直接拿原始完整 CoT 去渲染文本中查找，必然找不到。受影响的正好是 64 条 train + 16 条 val，共 80 条多轮样本。</p>
<p>最终没有修改数据，也没有强行改变 Qwen 模板，而是遵循“模板实际显示什么，就监督什么”：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">get_assistant_visible_content</span><span class="p">(</span><span class="n">messages</span><span class="p">,</span> <span class="n">index</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">content</span> <span class="o">=</span> <span class="n">messages</span><span class="p">[</span><span class="n">index</span><span class="p">][</span><span class="s2">&#34;content&#34;</span><span class="p">]</span><span class="o">.</span><span class="n">lstrip</span><span class="p">(</span><span class="s2">&#34;</span><span class="se">\n</span><span class="s2">&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="n">index</span> <span class="o">==</span> <span class="nb">len</span><span class="p">(</span><span class="n">messages</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span> <span class="ow">or</span> <span class="s2">&#34;&lt;/think&gt;&#34;</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">content</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">content</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">content</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="s2">&#34;&lt;/think&gt;&#34;</span><span class="p">)[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">lstrip</span><span class="p">(</span><span class="s2">&#34;</span><span class="se">\n</span><span class="s2">&#34;</span><span class="p">)</span>
</span></span></code></pre></div><p>这样历史 Assistant 只监督最终答案和 <code>&lt;|im_end|&gt;</code>，最后一轮继续监督完整 CoT。新增回归后达到 <strong>5 passed</strong>，同时覆盖原有非 CoT 行为与多轮 CoT 可见性。</p>
<p>这也是训练与推理保持一致的重要原则：不为了保留思考而制造一套与真实调用不同的模板。</p>
<h2 id="三128--32-条-cot-数据审计">三、128 + 32 条 CoT 数据审计</h2>
<p>正式数据分为两类：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>类别</th>
        <th style="text-align: right">Train</th>
        <th style="text-align: right">Val</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>单轮算术</td>
        <td style="text-align: right">64</td>
        <td style="text-align: right">16</td>
      </tr>
      <tr>
        <td>多轮数值更新</td>
        <td style="text-align: right">64</td>
        <td style="text-align: right">16</td>
      </tr>
      <tr>
        <td>合计</td>
        <td style="text-align: right"><strong>128</strong></td>
        <td style="text-align: right"><strong>32</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<p>每条 Assistant 使用 1～3 行简短推理，最终答案为纯数字。数据审计实际覆盖：</p>
<ul>
<li>JSON、角色顺序和类别比例；</li>
<li>每个 Assistant 恰好一对 think 标签；</li>
<li>推理与最终答案非空，答案为纯数字；</li>
<li>train / val 无完全重复对话；</li>
<li>train / val 无重复显式算式；</li>
<li>与 smoke、非 CoT 数据无重复显式算式；</li>
<li>排除行为基线中的名字、颜色和指定表达式；</li>
<li><strong>272 条显式算式重新核算</strong>；</li>
<li>全部 160 条样本通过真实模板编码，修复后的历史 CoT 与最后一轮 CoT 均可定位。</li>
</ul>
<p>本地 <code>i4_cot_data_audit.py</code> 最终输出：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">train equations checked: 218
</span></span><span class="line"><span class="cl">val equations checked: 54
</span></span><span class="line"><span class="cl">total equations checked: 272
</span></span><span class="line"><span class="cl">train / val exact overlap: 0
</span></span><span class="line"><span class="cl">train / val expression overlap: 0
</span></span><span class="line"><span class="cl">existing-data expression overlap: 0
</span></span><span class="line"><span class="cl">全部 CoT 数据审计通过
</span></span></code></pre></div><p>算式解析只能覆盖明确写成“数字 + 运算符 + 数字”的部分，不能代替全部自然语言推理质量评估。</p>
<h2 id="四训练前的两个关键对照">四、训练前的两个关键对照</h2>
<h3 id="1-原始模型与上一轮非-cot-v2">1. 原始模型与上一轮非 CoT v2</h3>
<p>在开启 thinking 后，上一轮非 CoT SFT 的最佳版本出现了明显的行为变化：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>指标</th>
        <th style="text-align: right">原始模型</th>
        <th style="text-align: right">非 CoT v2</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>最终答案正确</td>
        <td style="text-align: right">30/32</td>
        <td style="text-align: right">10/32</td>
      </tr>
      <tr>
        <td>完整 CoT 格式</td>
        <td style="text-align: right">32/32</td>
        <td style="text-align: right">0/32</td>
      </tr>
      <tr>
        <td>综合通过</td>
        <td style="text-align: right">30/32</td>
        <td style="text-align: right">0/32</td>
      </tr>
    </tbody>
  </table>
</div>
<p>这说明非 CoT SFT 对 thinking 行为存在明显干扰。因此，本轮从原始权重开始，不把“恢复被破坏的 thinking”和“学习短 CoT”混成同一个实验。</p>
<h3 id="2-评分脚本也需要先修正">2. 评分脚本也需要先修正</h3>
<p>第一次评估时，<code>expected</code> 是完整的 <code>&lt;think&gt;...&lt;/think&gt;</code> 加答案，却拿去与模型的纯数字答案做 <code>expected_exact</code> 比较，导致所有样本被误判为答案错误。</p>
<p>修正为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">expected_answer</span> <span class="o">=</span> <span class="n">split_cot_response</span><span class="p">(</span><span class="n">expected</span><span class="p">)[</span><span class="mi">1</span><span class="p">]</span>
</span></span></code></pre></div><p>并分别保存完整期望输出与最终期望数字。修正后，原始模型的 30 条正确答案才被正确计入。</p>
<p>这再次说明：<strong>先验收评测器，再比较模型。</strong></p>
<h2 id="五三组训练与行为结果">五、三组训练与行为结果</h2>
<p>三组都使用原始权重、128 条训练样本、32 条验证样本、<code>batch_size=4</code>、<code>n_epochs=1</code>、32 steps、seed=123。</p>
<p>报告核对后，三版的 <code>initial_lr</code> 与 <code>min_lr</code> 实际均为 <code>1e-6</code> 和 <code>1e-7</code>，并非整体按比例缩放。因此，本实验应理解为 <strong>peak_lr 与后续调度路径的对照</strong>，不声称其他调度参数完全相同。</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>版本</th>
        <th style="text-align: right">peak_lr</th>
        <th style="text-align: right">final full val loss</th>
        <th style="text-align: right">答案正确</th>
        <th style="text-align: right">完整 CoT</th>
        <th style="text-align: right">综合通过</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>v1</td>
        <td style="text-align: right">1e-5</td>
        <td style="text-align: right"><strong>0.807683</strong></td>
        <td style="text-align: right">6/32</td>
        <td style="text-align: right">0/32</td>
        <td style="text-align: right">0/32</td>
      </tr>
      <tr>
        <td>v2</td>
        <td style="text-align: right">1e-6</td>
        <td style="text-align: right">1.159451</td>
        <td style="text-align: right"><strong>29/32</strong></td>
        <td style="text-align: right"><strong>32/32</strong></td>
        <td style="text-align: right"><strong>29/32</strong></td>
      </tr>
      <tr>
        <td>v3</td>
        <td style="text-align: right">3e-6</td>
        <td style="text-align: right">1.037620</td>
        <td style="text-align: right">18/32</td>
        <td style="text-align: right"><strong>1/32</strong></td>
        <td style="text-align: right"><strong>1/32</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<h3 id="1-v1低-loss但-cot-直接丢失">1. v1：低 loss，但 CoT 直接丢失</h3>
<p>v1 的训练结果很漂亮：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">initial train loss = 2.670255
</span></span><span class="line"><span class="cl">final train loss = 0.822201
</span></span><span class="line"><span class="cl">final full val loss = 0.807683
</span></span></code></pre></div><p>但行为上：</p>
<ul>
<li>32 条样本全部没有完整 CoT；</li>
<li>最终答案只剩 6 条正确；</li>
<li>两组回答重复到长度上限；</li>
<li>训练原题上，原始模型 4/4 正确且完整 CoT，v1 只剩 1/4 正确、0/4 完整 CoT。</li>
</ul>
<p>所以它不是简单的验证集泛化失败，而是训练直接引入了 CoT 行为干扰。</p>
<h3 id="2-v2降低-peak_lr-后cot-恢复并出现局部收益">2. v2：降低 peak_lr 后，CoT 恢复并出现局部收益</h3>
<p>将 <code>peak_lr</code> 降到 <code>1e-6</code> 后：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">final train loss = 1.140148
</span></span><span class="line"><span class="cl">final full val loss = 1.159451
</span></span></code></pre></div><p>行为结果为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">answer_correct = 29/32
</span></span><span class="line"><span class="cl">format_compliant = 32/32
</span></span><span class="line"><span class="cl">passed = 29/32
</span></span><span class="line"><span class="cl">natural_stop = 32/32
</span></span></code></pre></div><p>分类表现：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>类别</th>
        <th style="text-align: right">原始模型</th>
        <th style="text-align: right">v2</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>数值更新</td>
        <td style="text-align: right">15/16</td>
        <td style="text-align: right"><strong>16/16</strong></td>
      </tr>
      <tr>
        <td>单轮算术</td>
        <td style="text-align: right">15/16</td>
        <td style="text-align: right">13/16</td>
      </tr>
    </tbody>
  </table>
</div>
<p>v2 的数值更新超过原始模型，但单轮算术和总体正确率仍未超过原始模型。因此它是<strong>当前 SFT 干预中破坏最小、存在局部收益的 checkpoint</strong>，不是全面优于原始模型的 checkpoint。</p>
<h3 id="3-v3中间学习率再次出现结构性退化">3. v3：中间学习率再次出现结构性退化</h3>
<p>将 <code>peak_lr</code> 调到 <code>3e-6</code> 后，最终答案为 18/32，严格有效 CoT 只剩 1/32。</p>
<p>主要问题包括：</p>
<ul>
<li>前置乱码或无关数字；</li>
<li>空思考；</li>
<li>思考标签与答案交错；</li>
<li>最终答案与中间结果不一致；</li>
<li>数值更新行为明显失稳。</li>
</ul>
<p>v3 的 <code>format_compliant=1</code> 使用收紧后的格式定义重新计算，不能把早期宽松检查中的 28 条标签出现当作有效 CoT。</p>
<h2 id="六严格格式验收出现标签不等于有效-cot">六、严格格式验收：出现标签不等于有效 CoT</h2>
<p>早期格式检查只要求有一对标签、非空推理和最终答案，导致“前置垃圾数字”和“答案复读”也被判为合格。</p>
<p>最终收紧为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">has_complete_cot_format</span><span class="p">(</span><span class="n">response</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">stripped</span> <span class="o">=</span> <span class="n">response</span><span class="o">.</span><span class="n">strip</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="ow">not</span> <span class="n">stripped</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s2">&#34;&lt;think&gt;&#34;</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="kc">False</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="n">reasoning</span><span class="p">,</span> <span class="n">final_answer</span> <span class="o">=</span> <span class="n">split_cot_response</span><span class="p">(</span><span class="n">stripped</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="n">response</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="s2">&#34;&lt;think&gt;&#34;</span><span class="p">)</span> <span class="o">==</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">        <span class="ow">and</span> <span class="n">response</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="s2">&#34;&lt;/think&gt;&#34;</span><span class="p">)</span> <span class="o">==</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">        <span class="ow">and</span> <span class="nb">bool</span><span class="p">(</span><span class="n">reasoning</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="ow">and</span> <span class="nb">bool</span><span class="p">(</span><span class="n">final_answer</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="ow">and</span> <span class="n">reasoning</span> <span class="o">!=</span> <span class="n">final_answer</span>
</span></span><span class="line"><span class="cl">    <span class="p">)</span>
</span></span></code></pre></div><p>这要求：</p>
<ul>
<li>必须以 <code>&lt;think&gt;</code> 开始；</li>
<li>恰好一对标签；</li>
<li>推理与答案都非空；</li>
<li>推理不能只是答案复读；</li>
<li>最终答案仍需通过纯数字格式检查。</li>
</ul>
<p>原始模型与 v2 在新定义下仍为 32/32；v3 从宽松的 28 条降为严格的 1 条。这说明<strong>短输出和出现标签都不能代替有效结构验收</strong>。</p>
<h2 id="七输出长度与推理算式变化">七、输出长度与推理算式变化</h2>
<p>进一步比较原始模型与 v2：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>指标</th>
        <th style="text-align: right">原始模型</th>
        <th style="text-align: right">v2：peak_lr=1e-6</th>
        <th style="text-align: right">变化</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>平均生成 tokens</td>
        <td style="text-align: right">163.1</td>
        <td style="text-align: right">139.4</td>
        <td style="text-align: right"><strong>缩短约 14.5%</strong></td>
      </tr>
      <tr>
        <td>中位生成 tokens</td>
        <td style="text-align: right">146</td>
        <td style="text-align: right">120</td>
        <td style="text-align: right"><strong>缩短约 17.8%</strong></td>
      </tr>
      <tr>
        <td>最大生成 tokens</td>
        <td style="text-align: right">430</td>
        <td style="text-align: right">278</td>
        <td style="text-align: right"><strong>缩短约 35.3%</strong></td>
      </tr>
      <tr>
        <td>推理算式错误</td>
        <td style="text-align: right">2 条</td>
        <td style="text-align: right"><strong>0 条</strong></td>
        <td style="text-align: right">当前检查中消除</td>
      </tr>
    </tbody>
  </table>
</div>
<p>v2 的确不只是“保住原模型”，它确实带来了输出变短和显式推理算式改善。</p>
<p>但 <code>reasoning equation errors=0</code> 只说明正则识别出的算式计算正确，不代表整段推理逻辑和最终答案一定正确。v2 仍有 3 条最终答案错误，仍存在自我怀疑、过程混乱和前后不一致。</p>
<h2 id="八loss-与行为表现再次不一致">八、loss 与行为表现再次不一致</h2>
<p>v1 的 val loss 最低，却只有 6/32 正确答案且完全丢失 CoT；v2 的 val loss 更高，却有 29/32 正确答案和完整 CoT。</p>
<p>这与 I4-B 的结论一致：</p>
<blockquote>
<p><strong>平均 token loss 下降，不等于目标行为变好；训练拟合程度更强，也不等于旧能力保留得更好。</strong></p>
</blockquote>
<p>后训练必须同时评估：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">训练与验证 loss
</span></span><span class="line"><span class="cl">最终答案正确性
</span></span><span class="line"><span class="cl">输出结构完整性
</span></span><span class="line"><span class="cl">推理过程质量
</span></span><span class="line"><span class="cl">旧能力保持情况
</span></span></code></pre></div><h2 id="九阶段结论">九、阶段结论</h2>
<p>本轮可以确认：</p>
<ul>
<li>CoT 的标签、推理正文和最终答案都能进入训练目标；</li>
<li>Qwen 历史 Assistant 的 CoT 会被模板剥离，Dataset 必须按可见内容定位；</li>
<li>peak_lr 对 CoT 行为有显著影响，高学习率下可能出现格式丢失和结构性退化；</li>
<li>LR=1e-6 的版本保留了完整 CoT，并改善数值更新、输出长度和显式推理算式；</li>
<li>但最终答案正确率没有整体超过原始模型，不能宣称 CoT-SFT 已全面提升能力。</li>
</ul>
<p>因此，如果优先追求最终答案正确率，<strong>原始模型仍然更合适</strong>；如果研究如何以较小破坏获得局部行为收益，v2 才具有对照价值。</p>
<h2 id="十阶段收官与下一步">十、阶段收官与下一步</h2>
<p>I4-C 按受控实验阶段收官，保留以下未解决问题：</p>
<ul>
<li>最终答案准确率尚未整体超过原始模型；</li>
<li>推理仍然偏长，自我怀疑并未完全消失；</li>
<li>推理算式检查不能覆盖完整语义质量；</li>
<li>尚未评估更大数据集、真实任务或其他模型规模；</li>
<li>尚未开始 DPO / GRPO。</li>
</ul>
<p>下一步进入 I4-D 时，将重点研究偏好数据：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Chosen：简短、正确、结构完整的 CoT
</span></span><span class="line"><span class="cl">Rejected：冗长、自我怀疑、算式错误、结构混乱或重复的回答
</span></span></code></pre></div><p>DPO 的目标是学习偏好差异，而不是简单模仿标准答案。它是否能在保留最终答案能力的同时改善表达，需要重新建立基线和能力保持评测，不能当成自动修复工具。</p>
<h2 id="主要实验产物">主要实验产物</h2>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">src/squid/data/chat_sft.py
</span></span><span class="line"><span class="cl">scripts/i4_cot_template_probe.py
</span></span><span class="line"><span class="cl">scripts/i4_cot_data_audit.py
</span></span><span class="line"><span class="cl">scripts/i4_cot_target_probe.py
</span></span><span class="line"><span class="cl">scripts/i4_cot_sft_train.py
</span></span><span class="line"><span class="cl">scripts/i4_cot_behavior_eval.py
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">data/reports/i4-cot-original-baseline.json
</span></span><span class="line"><span class="cl">data/reports/i4-cot-v2-baseline.json
</span></span><span class="line"><span class="cl">data/reports/i4-cot-sft-v1-training.json
</span></span><span class="line"><span class="cl">data/reports/i4-cot-sft-v2-lr1e-6-training.json
</span></span><span class="line"><span class="cl">data/reports/i4-cot-sft-v3-lr3e-6-training.json
</span></span><span class="line"><span class="cl">data/reports/i4-cot-sft-v1-behavior.json
</span></span><span class="line"><span class="cl">data/reports/i4-cot-sft-v2-lr1e-6-behavior.json
</span></span><span class="line"><span class="cl">data/reports/i4-cot-sft-v3-lr3e-6-behavior.json
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">data/model_pth/qwen3/i4-cot-sft-v1.pth
</span></span><span class="line"><span class="cl">data/model_pth/qwen3/i4-cot-sft-v2-lr1e-6.pth
</span></span><span class="line"><span class="cl">data/model_pth/qwen3/i4-cot-sft-v3-lr3e-6.pth
</span></span></code></pre></div>]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 23：I4 多轮对话 SFT</title>
      <link>https://blog.lvxinrong.com/llm/llm-23-i4-multiturn-sft/</link>
      <pubDate>Mon, 16 Nov 2026 09:00:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-23-i4-multiturn-sft/</guid>
      <description>从 Assistant-only loss mask、Qwen 多轮模板和 128 条合成样本开始，完成全参数 SFT、独立行为评测与训练量干预。记录 v1 能力回退、v2 恢复，以及 loss 与行为表现不一致的真实证据。</description>
      <content:encoded><![CDATA[<p>这篇记录的是 <strong>I4-B：多轮对话 SFT 的最小完整闭环</strong>，不是整个 I4 的收官。CoT-SFT、DPO、GRPO、LoRA 与全参对照尚未开始。</p>
<p>这一轮最有价值的地方，不只是最后得到了一个当前最佳 checkpoint，而是第一次完整看见：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">多轮数据如何变成训练目标
</span></span><span class="line"><span class="cl">→ SFT 如何改变模型行为
</span></span><span class="line"><span class="cl">→ 新能力习得为什么会伤害旧能力
</span></span><span class="line"><span class="cl">→ 为什么不能只看训练 loss 判断后训练效果
</span></span></code></pre></div><h2 id="一实验目标与边界">一、实验目标与边界</h2>
<p>本轮使用 <strong>Qwen3-0.6B Instruct</strong>，从我们独立实现的 V4 加载、训练和生成。实验设备为 MacBook M4 Pro，实际运行后端为 MPS，权重和训练使用 FP32。</p>
<p>第一版只研究非 CoT 的多轮行为：</p>
<ul>
<li>名字与偏好记忆；</li>
<li>根据新信息更新旧数值；</li>
<li>简单算术；</li>
<li>按指定格式输出；</li>
<li>自然结束，不复制上一轮回答。</li>
</ul>
<p>这不是开放域对话训练。训练数据是受控合成数据，行为评测也只有 6 条固定基线和 32 条独立验证样本。所有结论都限定在这个范围内。</p>
<h2 id="二先弄清楚多轮样本到底监督什么">二、先弄清楚：多轮样本到底监督什么</h2>
<h3 id="1--100-与--torchinf-不是一回事">1. <code>-100</code> 与 <code>-torch.inf</code> 不是一回事</h3>
<p>M4 的单轮 SFT 已经使用过 <code>ignore_index=-100</code>，但这次重新读代码时，我发现自己仍然容易把它和注意力中的 <code>-torch.inf</code> 混在一起。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">target = -100
</span></span><span class="line"><span class="cl">→ 这个位置的预测不计入 loss
</span></span><span class="line"><span class="cl">→ 输入 token 仍然存在，仍可被后续位置读取
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">attn_score = -torch.inf
</span></span><span class="line"><span class="cl">→ 经 softmax 后注意力概率为 0
</span></span><span class="line"><span class="cl">→ 这条注意力连接被切断
</span></span></code></pre></div><p>所以，User 不参与 loss，不代表模型看不到 User。模型仍然读取完整问题和历史，只是我们不要求它学习生成 User 的提问。</p>
<h3 id="2-为什么-targetsp---1-而不是-targetsp">2. 为什么 <code>targets[:P - 1]</code> 而不是 <code>targets[:P]</code></h3>
<p>假设：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">full:    [p0, p1, p2, r0, r1, EOS]
</span></span><span class="line"><span class="cl">inputs:  [p0, p1, p2, r0, r1]
</span></span><span class="line"><span class="cl">targets: [p1, p2, r0, r1, EOS]
</span></span></code></pre></div><p><code>targets[i] = full[i + 1]</code>。当 prompt 长度 <code>P=3</code> 时，必须保留 <code>targets[2] = r0</code>，否则第一个回答 token 就没有监督。</p>
<p>这也解释了为什么 Full 中的 Assistant 区间不能直接当作 target 下标：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">full[29:35]  → targets[28:34]
</span></span><span class="line"><span class="cl">full[53:59]  → targets[52:58]
</span></span></code></pre></div><h3 id="3-多轮-assistant-都应该监督user-只提供上下文">3. 多轮 Assistant 都应该监督，User 只提供上下文</h3>
<p>本轮使用 Assistant-only SFT：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">System：上下文，不计 loss
</span></span><span class="line"><span class="cl">User：上下文，不计 loss
</span></span><span class="line"><span class="cl">Assistant 角色头：上下文，不计 loss
</span></span><span class="line"><span class="cl">Assistant 正文：计 loss
</span></span><span class="line"><span class="cl">Assistant 的 &lt;|im_end|&gt;：计 loss
</span></span></code></pre></div><p><code>&lt;|im_start|&gt;assistant</code> 是模板提供的答题区，不需要模型自己生成；<code>&lt;|im_end|&gt;</code> 是模型回答结束后需要生成的动作，必须参与训练。</p>
<p>多轮样本里会出现多个 <code>&lt;|im_end|&gt;</code>。System 和 User 的结束标记与 Assistant 的结束标记虽然 token id 相同，但职责不同，不能只保留整个序列中的第一个 EOS。</p>
<h2 id="三把真实-qwen-模板变成-dataset">三、把真实 Qwen 模板变成 Dataset</h2>
<h3 id="1-模板探针">1. 模板探针</h3>
<p>我们首先用两轮对话检查真实渲染结果，而不是凭感觉拼字符串。固定样例渲染后共有 60 个 token，两轮 Assistant 的 Full 区间为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">第一轮：full[29:35]
</span></span><span class="line"><span class="cl">第二轮：full[53:59]
</span></span></code></pre></div><p>第二轮还包含一个空的 <code>&lt;think&gt;...&lt;/think&gt;</code> 区域。当前非 CoT 数据契约中，空 think 区域只作为上下文，不参与 loss；两轮 Assistant 正文及各自的 <code>&lt;|im_end|&gt;</code> 参与 loss。</p>
<h3 id="2-核心掩码构造函数">2. 核心掩码构造函数</h3>
<p><code>src/squid/data/chat_sft.py</code> 中，区间统一使用 Full 下标、右端不取：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">build_assistant_targets</span><span class="p">(</span><span class="n">full_ids</span><span class="p">,</span> <span class="n">assistant_spans</span><span class="p">,</span> <span class="n">ignore_index</span><span class="o">=-</span><span class="mi">100</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="ow">not</span> <span class="n">full_ids</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&#34;full_ids 不能为空&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="n">targets</span> <span class="o">=</span> <span class="p">[</span><span class="n">ignore_index</span><span class="p">]</span> <span class="o">*</span> <span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">full_ids</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="n">start</span><span class="p">,</span> <span class="n">end</span> <span class="ow">in</span> <span class="n">assistant_spans</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="n">start</span> <span class="o">&lt;</span> <span class="mi">1</span> <span class="ow">or</span> <span class="n">end</span> <span class="o">&gt;</span> <span class="nb">len</span><span class="p">(</span><span class="n">full_ids</span><span class="p">)</span> <span class="ow">or</span> <span class="n">start</span> <span class="o">&gt;=</span> <span class="n">end</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">                <span class="sa">f</span><span class="s2">&#34;非法 Assistant 区间：[</span><span class="si">{</span><span class="n">start</span><span class="si">}</span><span class="s2">, </span><span class="si">{</span><span class="n">end</span><span class="si">}</span><span class="s2">)&#34;</span>
</span></span><span class="line"><span class="cl">            <span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">targets</span><span class="p">[</span><span class="n">start</span> <span class="o">-</span> <span class="mi">1</span><span class="p">:</span><span class="n">end</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="n">full_ids</span><span class="p">[</span><span class="n">start</span><span class="p">:</span><span class="n">end</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">targets</span>
</span></span></code></pre></div><h3 id="3-不写死区间用前缀编码定位">3. 不写死区间，用前缀编码定位</h3>
<p><code>find_assistant_spans()</code> 在渲染文本中顺序定位每轮 Assistant 正文及 <code>&lt;|im_end|&gt;</code>，再分别编码正文前和结束标记后的前缀，得到 token 下标，并断言前缀编码与 <code>full_ids</code> 完全一致。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">start_ids</span> <span class="o">=</span> <span class="n">tokenizer</span><span class="o">.</span><span class="n">encode</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">full_text</span><span class="p">[:</span><span class="n">content_start</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">    <span class="n">add_special_tokens</span><span class="o">=</span><span class="kc">False</span><span class="p">,</span>
</span></span><span class="line"><span class="cl"><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="n">end_ids</span> <span class="o">=</span> <span class="n">tokenizer</span><span class="o">.</span><span class="n">encode</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">full_text</span><span class="p">[:</span><span class="n">end_char</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">    <span class="n">add_special_tokens</span><span class="o">=</span><span class="kc">False</span><span class="p">,</span>
</span></span><span class="line"><span class="cl"><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">assert</span> <span class="n">start_ids</span> <span class="o">==</span> <span class="n">full_ids</span><span class="p">[:</span><span class="nb">len</span><span class="p">(</span><span class="n">start_ids</span><span class="p">)]</span>
</span></span><span class="line"><span class="cl"><span class="k">assert</span> <span class="n">end_ids</span> <span class="o">==</span> <span class="n">full_ids</span><span class="p">[:</span><span class="nb">len</span><span class="p">(</span><span class="n">end_ids</span><span class="p">)]</span>
</span></span></code></pre></div><p>这样避免把某组固定样例的下标硬编码进 Dataset，也避免简单搜索 token id 时误切正文。</p>
<p><code>encode_qwen_multiturn()</code> 将真实模板、区间定位和 target 构造接起来：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">encode_qwen_multiturn</span><span class="p">(</span><span class="n">tokenizer</span><span class="p">,</span> <span class="n">messages</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">full_text</span> <span class="o">=</span> <span class="n">tokenizer</span><span class="o">.</span><span class="n">apply_chat_template</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="n">messages</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="n">tokenize</span><span class="o">=</span><span class="kc">False</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="n">add_generation_prompt</span><span class="o">=</span><span class="kc">False</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="n">encoded</span> <span class="o">=</span> <span class="n">tokenizer</span><span class="o">.</span><span class="n">apply_chat_template</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="n">messages</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="n">tokenize</span><span class="o">=</span><span class="kc">True</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="n">add_generation_prompt</span><span class="o">=</span><span class="kc">False</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="n">full_ids</span> <span class="o">=</span> <span class="n">encoded</span><span class="p">[</span><span class="s2">&#34;input_ids&#34;</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="n">full_ids</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">full_ids</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="nb">list</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">        <span class="n">full_ids</span> <span class="o">=</span> <span class="n">full_ids</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="n">spans</span> <span class="o">=</span> <span class="n">find_assistant_spans</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="n">tokenizer</span><span class="p">,</span> <span class="n">messages</span><span class="p">,</span> <span class="n">full_text</span><span class="p">,</span> <span class="n">full_ids</span>
</span></span><span class="line"><span class="cl">    <span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="n">targets</span> <span class="o">=</span> <span class="n">build_assistant_targets</span><span class="p">(</span><span class="n">full_ids</span><span class="p">,</span> <span class="n">spans</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">full_ids</span><span class="p">[:</span><span class="o">-</span><span class="mi">1</span><span class="p">],</span> <span class="n">targets</span>
</span></span></code></pre></div><h3 id="4-batch-padding">4. Batch padding</h3>
<p>inputs 使用 EOS/pad id 补齐，targets 使用 <code>-100</code> 补齐，不额外追加 EOS，因为每轮 Assistant 已经包含自己的 <code>&lt;|im_end|&gt;</code>：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">qwen_multiturn_collate</span><span class="p">(</span><span class="n">batch</span><span class="p">,</span> <span class="n">pad_token_id</span><span class="p">,</span> <span class="n">ignore_index</span><span class="o">=-</span><span class="mi">100</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">max_len</span> <span class="o">=</span> <span class="nb">max</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">inputs</span><span class="p">)</span> <span class="k">for</span> <span class="n">inputs</span><span class="p">,</span> <span class="n">_</span> <span class="ow">in</span> <span class="n">batch</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="n">input_batch</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">    <span class="n">target_batch</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="n">inputs</span><span class="p">,</span> <span class="n">targets</span> <span class="ow">in</span> <span class="n">batch</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="n">input_ids</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">(</span><span class="n">inputs</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="n">torch</span><span class="o">.</span><span class="n">long</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="n">target_ids</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">(</span><span class="n">targets</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="n">torch</span><span class="o">.</span><span class="n">long</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">input_batch</span><span class="o">.</span><span class="n">append</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">            <span class="n">pad_to_length</span><span class="p">(</span><span class="n">input_ids</span><span class="p">,</span> <span class="n">max_len</span><span class="p">,</span> <span class="n">pad_token_id</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="n">target_batch</span><span class="o">.</span><span class="n">append</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">            <span class="n">pad_to_length</span><span class="p">(</span><span class="n">target_ids</span><span class="p">,</span> <span class="n">max_len</span><span class="p">,</span> <span class="n">ignore_index</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">torch</span><span class="o">.</span><span class="n">stack</span><span class="p">(</span><span class="n">input_batch</span><span class="p">),</span> <span class="n">torch</span><span class="o">.</span><span class="n">stack</span><span class="p">(</span><span class="n">target_batch</span><span class="p">)</span>
</span></span></code></pre></div><p>对应测试按阶段实际运行为 <strong>1 passed、2 passed、3 passed</strong>，分别覆盖掩码错位、真实模板 Dataset 和 Batch padding。这些数字不是一次全量回归。</p>
<h2 id="四冻结行为基线也修正评测器自己">四、冻结行为基线，也修正评测器自己</h2>
<h3 id="1-固定基线配置">1. 固定基线配置</h3>
<p>行为基线使用：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">模型：Qwen3-0.6B Instruct
</span></span><span class="line"><span class="cl">device：mps
</span></span><span class="line"><span class="cl">dtype：FP32
</span></span><span class="line"><span class="cl">context_size：8192
</span></span><span class="line"><span class="cl">max_new_tokens：512
</span></span><span class="line"><span class="cl">temperature：0.0
</span></span><span class="line"><span class="cl">enable_thinking：false
</span></span></code></pre></div><p>六条样例覆盖多轮记忆、连续数值更新、算术和格式遵循。</p>
<h3 id="2-expected_contains-为什么不能判断数值答案">2. <code>expected_contains</code> 为什么不能判断数值答案</h3>
<p>第一版规则只检查回答是否包含 <code>912</code>。但：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="s2">&#34;912&#34;</span> <span class="ow">in</span> <span class="s2">&#34;8912&#34;</span>  <span class="c1"># True</span>
</span></span><span class="line"><span class="cl"><span class="s2">&#34;912&#34;</span> <span class="ow">in</span> <span class="s2">&#34;7192&#34;</span>  <span class="c1"># True</span>
</span></span></code></pre></div><p>所以数值题改为精确匹配，并单独拆出两个指标：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">answer_correct：内容或数值是否正确
</span></span><span class="line"><span class="cl">format_compliant：是否遵守输出格式
</span></span></code></pre></div><p>例如：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">24            → 格式正确，答案错误（期望 30）
</span></span><span class="line"><span class="cl">123+789=912   → 格式错误，答案正确
</span></span><span class="line"><span class="cl">912           → 格式和答案都正确
</span></span></code></pre></div><p>评分器新增独立测试，实际运行 <strong>4 passed</strong>；加入复制检测后为 <strong>7 passed</strong>。</p>
<h3 id="3-一个列表共享引用造成的全量误报">3. 一个列表共享引用造成的全量误报</h3>
<p>32 条评估第一次全部显示 <code>copy=True</code>。根因不是模型全都复制，而是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">case[&#34;history&#34;] 与 session.history 指向同一个列表
</span></span><span class="line"><span class="cl">→ session.ask() 把当前回答追加进 history
</span></span><span class="line"><span class="cl">→ 复制检测读取到刚生成的回答
</span></span><span class="line"><span class="cl">→ 再与 response 比较，永远相等
</span></span></code></pre></div><p>修复为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">session</span><span class="o">.</span><span class="n">history</span> <span class="o">=</span> <span class="n">history</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span>
</span></span></code></pre></div><p>这次错误提醒我：<strong>训练前先验证评测器，训练后也不要把评测器的异常直接归因于模型。</strong></p>
<h3 id="4-训练前的真实行为">4. 训练前的真实行为</h3>
<p>原始模型的六条基线结果为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">passed = 2/6
</span></span><span class="line"><span class="cl">answer_correct = 4/6
</span></span><span class="line"><span class="cl">format_compliant = 4/6
</span></span><span class="line"><span class="cl">copied_previous_assistant = 1
</span></span><span class="line"><span class="cl">natural_stop = 6/6
</span></span></code></pre></div><p>典型现象包括：</p>
<ul>
<li>苹果已有 24 个，再买 6 个，仍回答 <code>24</code>；</li>
<li><code>25 * 24</code> 错答为 <code>240</code>；</li>
<li><code>123 + 789 = 912</code> 结果正确，但违反“只回答数字”；</li>
<li>颜色题直接复制上一轮 Assistant。</li>
</ul>
<h2 id="五4-step-冒烟先证明链路不证明能力">五、4-step 冒烟：先证明链路，不证明能力</h2>
<p>正式数据之前，用 4 条训练样本、2 条验证样本做了 4 个优化步骤：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">initial train loss：3.390143
</span></span><span class="line"><span class="cl">initial val loss：  2.800545
</span></span><span class="line"><span class="cl">final train loss：  1.958147
</span></span><span class="line"><span class="cl">final val loss：    1.819232
</span></span><span class="line"><span class="cl">optimization steps：4
</span></span><span class="line"><span class="cl">checkpoint reload：passed
</span></span></code></pre></div><p>恢复 checkpoint 后生成两条验证回答：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">期望 28 → 生成 28，正常 stop
</span></span><span class="line"><span class="cl">期望 15 → 生成 6，正常 stop
</span></span></code></pre></div><p>所以冒烟只证明了数据、loss、反向传播、checkpoint 和生成链路可用。第二条答错说明它没有证明模型能力。</p>
<h2 id="六128--32-合成数据与隔离审计">六、128 + 32 合成数据与隔离审计</h2>
<p>正式数据由 GPT 辅助生成，再经过本地审计：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>类别</th>
        <th style="text-align: right">Train</th>
        <th style="text-align: right">Val</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>单轮算术</td>
        <td style="text-align: right">32</td>
        <td style="text-align: right">8</td>
      </tr>
      <tr>
        <td>多轮数值更新</td>
        <td style="text-align: right">32</td>
        <td style="text-align: right">8</td>
      </tr>
      <tr>
        <td>名字记忆</td>
        <td style="text-align: right">32</td>
        <td style="text-align: right">8</td>
      </tr>
      <tr>
        <td>偏好记忆</td>
        <td style="text-align: right">32</td>
        <td style="text-align: right">8</td>
      </tr>
      <tr>
        <td>合计</td>
        <td style="text-align: right"><strong>128</strong></td>
        <td style="text-align: right"><strong>32</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<p>隔离要求包括：</p>
<ul>
<li>train / val 没有完全重复的对话；</li>
<li>同一算术表达式不跨集合；</li>
<li>排除行为基线中的小吕、蓝色、3×8+6、25×24、123+789、17+5；</li>
<li>避免复用已有 smoke 样例；</li>
<li>Assistant 不携带 think 或角色标记；</li>
<li>每条样本都能通过真实模板编码，并且存在有效监督 token。</li>
</ul>
<p>分类审计最初把“叫我”“首选爱好”“昵称”等表达误归为数值任务。修正审计规则后，四类数量恢复平衡，全部模板编码通过，train / val 精确重复为 0，排除项检查通过。</p>
<p>这组数据仍然只是受控任务数据，不代表真实多轮语料分布。</p>
<h2 id="七v164-stepsloss-很漂亮行为却出现回退">七、v1：64 steps，loss 很漂亮，行为却出现回退</h2>
<h3 id="1-训练配置与-loss">1. 训练配置与 loss</h3>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">全参数 SFT
</span></span><span class="line"><span class="cl">batch_size = 4
</span></span><span class="line"><span class="cl">n_epochs = 2
</span></span><span class="line"><span class="cl">optimization steps = 64
</span></span><span class="line"><span class="cl">peak_lr = 1e-5
</span></span><span class="line"><span class="cl">initial_lr = 1e-6
</span></span><span class="line"><span class="cl">min_lr = 1e-7
</span></span><span class="line"><span class="cl">weight_decay = 0
</span></span><span class="line"><span class="cl">warmup_steps = 6
</span></span><span class="line"><span class="cl">seed = 123
</span></span><span class="line"><span class="cl">context_size = 1024
</span></span></code></pre></div><p>结果：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">initial train loss：3.797954
</span></span><span class="line"><span class="cl">initial val loss：  3.745439
</span></span><span class="line"><span class="cl">final train loss：  0.616244
</span></span><span class="line"><span class="cl">final full val loss：0.859470
</span></span><span class="line"><span class="cl">checkpoint reload：passed
</span></span></code></pre></div><h3 id="2-六条基线从-26-到-46">2. 六条基线：从 2/6 到 4/6</h3>
<p>v1 的六条基线变为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">passed = 4/6
</span></span><span class="line"><span class="cl">answer_correct = 4/6
</span></span><span class="line"><span class="cl">format_compliant = 6/6
</span></span><span class="line"><span class="cl">copied_previous_assistant = 0
</span></span><span class="line"><span class="cl">natural_stop = 6/6
</span></span></code></pre></div><p>改善包括：</p>
<ul>
<li>苹果题从 <code>24</code> 更新为 <code>30</code>；</li>
<li><code>17 + 5</code> 从完整算式变为只输出 <code>22</code>；</li>
<li>名字回答变为“你叫小吕”。</li>
</ul>
<p>但也出现：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">25 * 24：240 → 60，仍然错误
</span></span><span class="line"><span class="cl">123 + 789：结果正确的算式 → 909，数值回退
</span></span></code></pre></div><h3 id="3-32-条独立验证总通过率提升名字却明显退化">3. 32 条独立验证：总通过率提升，名字却明显退化</h3>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>类别</th>
        <th style="text-align: right">原始模型</th>
        <th style="text-align: right">SFT v1</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>名字记忆</td>
        <td style="text-align: right">8/8</td>
        <td style="text-align: right"><strong>3/8</strong></td>
      </tr>
      <tr>
        <td>数值更新</td>
        <td style="text-align: right">2/8</td>
        <td style="text-align: right"><strong>7/8</strong></td>
      </tr>
      <tr>
        <td>偏好记忆</td>
        <td style="text-align: right">7/8</td>
        <td style="text-align: right">7/8</td>
      </tr>
      <tr>
        <td>单轮算术</td>
        <td style="text-align: right">2/8</td>
        <td style="text-align: right"><strong>7/8</strong></td>
      </tr>
      <tr>
        <td>总计</td>
        <td style="text-align: right">19/32</td>
        <td style="text-align: right"><strong>24/32</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<p>v1 的格式合规从 24 提升到 31，但内容正确从 25 降为 24。名字类出现“你”“你。”“你记住了”等无效回答。</p>
<h3 id="4-同一训练集上的对照确认训练引入的回退">4. 同一训练集上的对照，确认训练引入的回退</h3>
<p>为了区分“原本不会”与“训练后改坏”，又比较了原始模型与 v1 在同一 128 条样本上的 <code>passed</code>：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>类别</th>
        <th style="text-align: right">原始模型</th>
        <th style="text-align: right">SFT v1</th>
        <th>净变化</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>名字记忆</td>
        <td style="text-align: right">32/32</td>
        <td style="text-align: right">21/32</td>
        <td><strong>-11</strong></td>
      </tr>
      <tr>
        <td>偏好记忆</td>
        <td style="text-align: right">32/32</td>
        <td style="text-align: right">28/32</td>
        <td><strong>-4</strong></td>
      </tr>
      <tr>
        <td>数值更新</td>
        <td style="text-align: right">12/32</td>
        <td style="text-align: right">27/32</td>
        <td><strong>+15</strong></td>
      </tr>
      <tr>
        <td>单轮算术</td>
        <td style="text-align: right">8/32</td>
        <td style="text-align: right">21/32</td>
        <td><strong>+13</strong></td>
      </tr>
      <tr>
        <td>总体</td>
        <td style="text-align: right">84/128</td>
        <td style="text-align: right">97/128</td>
        <td>+13</td>
      </tr>
    </tbody>
  </table>
</div>
<p>原始模型在名字和偏好样本上全部正确，v1 却在相同输入上退化。这不能简单解释为验证集分布不同，而是全参数训练在获得新行为时干扰了旧行为，符合局部灾难性遗忘的表现。</p>
<p>另一个重要事实是：<strong>v1 的最终 train loss 已降到 0.616，但训练集逐条生成仍只有 97/128 综合通过。</strong> 平均 token loss 与行为成功不是同一个指标。</p>
<h2 id="八v2减少训练量恢复新旧能力的平衡">八、v2：减少训练量，恢复新旧能力的平衡</h2>
<h3 id="1-干预方式与训练结果">1. 干预方式与训练结果</h3>
<p>在数据、Batch、学习率峰值、随机种子等保持不变的前提下，将 <code>n_epochs</code> 从 2 改为 1：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">optimization steps = 32
</span></span><span class="line"><span class="cl">warmup_steps = 3
</span></span><span class="line"><span class="cl">final train loss = 1.104157
</span></span><span class="line"><span class="cl">final full val loss = 1.021104
</span></span><span class="line"><span class="cl">checkpoint reload = passed
</span></span></code></pre></div><p>严格来说，修改 <code>n_epochs</code> 后，总步数、warmup 步数和学习率衰减过程都发生了变化。因此这是一组训练量与调度对照，不能把全部差异只归因于 epoch 数。</p>
<h3 id="2-原始模型v1v2-的独立验证对照">2. 原始模型、v1、v2 的独立验证对照</h3>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>指标</th>
        <th style="text-align: right">原始模型</th>
        <th style="text-align: right">v1：2 epochs</th>
        <th style="text-align: right">v2：1 epoch</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>综合通过</td>
        <td style="text-align: right">19/32</td>
        <td style="text-align: right">24/32</td>
        <td style="text-align: right"><strong>30/32</strong></td>
      </tr>
      <tr>
        <td>内容正确</td>
        <td style="text-align: right">25/32</td>
        <td style="text-align: right">24/32</td>
        <td style="text-align: right"><strong>30/32</strong></td>
      </tr>
      <tr>
        <td>格式合规</td>
        <td style="text-align: right">24/32</td>
        <td style="text-align: right">31/32</td>
        <td style="text-align: right"><strong>31/32</strong></td>
      </tr>
      <tr>
        <td>名字记忆</td>
        <td style="text-align: right">8/8</td>
        <td style="text-align: right">3/8</td>
        <td style="text-align: right"><strong>7/8</strong></td>
      </tr>
      <tr>
        <td>数值更新</td>
        <td style="text-align: right">2/8</td>
        <td style="text-align: right">7/8</td>
        <td style="text-align: right"><strong>7/8</strong></td>
      </tr>
      <tr>
        <td>偏好记忆</td>
        <td style="text-align: right">7/8</td>
        <td style="text-align: right">7/8</td>
        <td style="text-align: right"><strong>8/8</strong></td>
      </tr>
      <tr>
        <td>单轮算术</td>
        <td style="text-align: right">2/8</td>
        <td style="text-align: right">7/8</td>
        <td style="text-align: right"><strong>8/8</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<p>最重要的现象是：<strong>v2 的 val loss 比 v1 更高，行为表现却显著更好。</strong> 这直接说明，不能只凭平均 token loss 判断后训练是否更好。</p>
<h3 id="3-六条冻结基线全部通过">3. 六条冻结基线全部通过</h3>
<p>v2 在最初六条基线上的结果为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">passed = 6/6
</span></span><span class="line"><span class="cl">answer_correct = 6/6
</span></span><span class="line"><span class="cl">format_compliant = 6/6
</span></span><span class="line"><span class="cl">copied_previous_assistant = 0
</span></span><span class="line"><span class="cl">natural_stop = 6/6
</span></span><span class="line"><span class="cl">empty = 0
</span></span></code></pre></div><p>真实回答为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">名字：小吕。
</span></span><span class="line"><span class="cl">颜色：蓝色。
</span></span><span class="line"><span class="cl">苹果更新：30
</span></span><span class="line"><span class="cl">25 * 24：600
</span></span><span class="line"><span class="cl">123 + 789：912
</span></span><span class="line"><span class="cl">17 + 5：22
</span></span></code></pre></div><p>全部自然结束，没有精确复制旧回答。</p>
<h3 id="4-v2-仍有两个失败样例">4. v2 仍有两个失败样例</h3>
<p>32 条独立验证中仍有两条失败：</p>
<ul>
<li>数值更新第 01 条：期望 <code>7</code>，模型只生成 1 个 token 就 EOS，形成空回答；</li>
<li>名字记忆第 29 条：期望“小棉”，模型回答“你。”，生成 3 个 token 后停止。</li>
</ul>
<p>所以 v2 是当前最佳，不是全样本正确，也不是所有行为问题都已解决。</p>
<h2 id="九这一轮得到的结论">九、这一轮得到的结论</h2>
<h3 id="1-多轮-sft-首先是数据契约问题">1. 多轮 SFT 首先是数据契约问题</h3>
<p>不是把多轮文本拼起来就算完成。必须明确每轮角色、正文、结束标记和错位 target 的关系，否则模型可能在错误的文本上接受训练。</p>
<h3 id="2-格式行为通常比数值能力更容易学到">2. 格式行为通常比数值能力更容易学到</h3>
<p>v1、v2 都很快提升了“只输出数字”的格式遵循，但算术正确性并未同步提升，部分题目还发生回退。loss 下降不能直接解释为推理能力增强。</p>
<h3 id="3-全参数训练会同时产生收益与干扰">3. 全参数训练会同时产生收益与干扰</h3>
<p>v1 在数值更新和格式上明显收益，却损害了原本稳定的名字与偏好回答。后训练需要同时评估新任务收益和旧能力保持。</p>
<h3 id="4-行为评测必须独立于训练-loss">4. 行为评测必须独立于训练 loss</h3>
<p>本轮最关键的证据是：v2 的 val loss 更高，行为却更好。只优化 loss，无法发现这种新旧能力冲突。</p>
<h3 id="5-评测器本身也需要回归测试">5. 评测器本身也需要回归测试</h3>
<p>contains 误判、格式与正确性混淆、history 共享引用，都曾制造假结论。训练实验必须保留原始回答、评分规则和报告版本，不能只保存一个最终分数。</p>
<h2 id="十当前停止边界">十、当前停止边界</h2>
<p>当前只完成 I4-B 的受控多轮 SFT 闭环：</p>
<ul>
<li>v2 是本轮最佳 checkpoint；</li>
<li>不能据此宣称开放域多轮对话能力；</li>
<li>不能据此宣称 1 epoch 普遍优于 2 epochs；</li>
<li>尚未完成真实多轮语料、LoRA / 全参对照、CoT-SFT、DPO 或 GRPO；</li>
<li>名字和偏好类的核心实体包含规则仍是弱语义评测，后续需要更可靠的评估校准。</li>
</ul>
<p>下一步进入 I4-C 时，需要先想清楚：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">&lt;think&gt; 中的推理过程是否参与 loss？
</span></span><span class="line"><span class="cl">如何分别定位思考区间与正式回答区间？
</span></span><span class="line"><span class="cl">thinking 与正文的 token 预算如何计算？
</span></span><span class="line"><span class="cl">如何判断思考质量，而不只是判断输出格式？
</span></span></code></pre></div><p>这一轮的主干已经搭起来了：<strong>数据契约、训练、checkpoint、独立行为评测、回退分析和干预对照。</strong> 后面新增 CoT、DPO 或其他方法，都应该在这套基线上继续做局部进化。</p>
<h2 id="主要实验产物">主要实验产物</h2>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">src/squid/data/chat_sft.py
</span></span><span class="line"><span class="cl">scripts/i4_qwen_multiturn_template_probe.py
</span></span><span class="line"><span class="cl">scripts/i4_qwen_multiturn_span_probe.py
</span></span><span class="line"><span class="cl">scripts/i4_behavior_baseline.py
</span></span><span class="line"><span class="cl">scripts/i4_synthetic_data_audit.py
</span></span><span class="line"><span class="cl">scripts/i4_multiturn_sft_train.py
</span></span><span class="line"><span class="cl">scripts/i4_synthetic_behavior_eval.py
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">data/reports/i4-qwen3-0_6b-behavior-baseline-v3.json
</span></span><span class="line"><span class="cl">data/reports/i4-multiturn-sft-v1-training.json
</span></span><span class="line"><span class="cl">data/reports/i4-multiturn-sft-v2-1epoch-training.json
</span></span><span class="line"><span class="cl">data/reports/i4-synthetic-val-original.json
</span></span><span class="line"><span class="cl">data/reports/i4-multiturn-sft-v1-synthetic-val.json
</span></span><span class="line"><span class="cl">data/reports/i4-multiturn-sft-v2-1epoch-synthetic-val.json
</span></span><span class="line"><span class="cl">data/reports/i4-multiturn-sft-v2-1epoch-behavior-v3.json
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">data/model_pth/qwen3/i4-multiturn-sft-v1.pth
</span></span><span class="line"><span class="cl">data/model_pth/qwen3/i4-multiturn-sft-v2-1epoch.pth
</span></span></code></pre></div>]]></content:encoded>
    </item>
  </channel>
</rss>
