<?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>DataLoader on 吕炘嵘的博客</title>
    <link>https://blog.lvxinrong.com/tags/dataloader/</link>
    <description>Recent content in DataLoader on 吕炘嵘的博客</description>
    <image>
      <title>吕炘嵘的博客</title>
      <url>https://blog.lvxinrong.com/og-default.jpg</url>
      
      <link>https://blog.lvxinrong.com/tags/dataloader/</link>
    </image>
    <generator>Hugo</generator>
    <language>zh-CN</language>
    <lastBuildDate>Fri, 16 Oct 2026 16:21:31 +0800</lastBuildDate>
    <atom:link href="https://blog.lvxinrong.com/tags/dataloader/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>手搓 LLM 笔记 06：分类微调，从数据管道到换头</title>
      <link>https://blog.lvxinrong.com/llm/llm-06-class-finetune/</link>
      <pubDate>Fri, 16 Oct 2026 16:21:31 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-06-class-finetune/</guid>
      <description>第六章从 SpamDataset 的固定位置、padding 和 DataLoader 开始，到分类头、参数冻结和一次真实的 spam / not spam 判定结束。跑通只是第一关，验收和工程化还没结束。</description>
      <content:encoded><![CDATA[<blockquote>
<p>第六章要把第五章那个会“续写”的 GPT-2 改造成一个二分类器。数据管道先把我拦了一次；6.1 到 6.5 学完后，Kimi 又用五道题验收了一遍；下午最后把 <code>classify_review</code> 跑到了真实的 spam / not spam。系列规则不变：写下来的必须是我自己搞懂的，没懂的如实写“没懂”。</p>
</blockquote>
<h2 id="一这一章在做什么把续写改成判定">一、这一章在做什么：把「续写」改成「判定」</h2>
<p>第五章结束时，我手上是一个加载了 GPT-2 权重、能续写英文的模型。第六章不换架构、不重训主体，只换两样东西：输出层从 50257 维换成 2 维，训练目标从 next-token 预测变成类别判断。</p>
<p>这里要分清三件事：《The Verdict》是第五章的小规模预训练演示语料；GPT-2 权重是 OpenAI 预训练得到的参数起点；SMS 垃圾短信是第六章监督微调使用的数据。<strong>不是把 GPT-2 的训练语料从《The Verdict》换成 SMS。</strong></p>
<p>微调分两类，这本书用两章各讲一种：第六章是<strong>分类微调</strong>（输出是一个类别标签），第七章是指令微调（输出还是文本，但变成听话的文本）。分类微调的损失函数还是交叉熵，区别在于<strong>只在某一个位置上算</strong>——这一处和第五章的差别，6.6 里已经看到，但还没有单独做问答验收。</p>
<p>这一篇覆盖 6.1 到 6.8：数据准备、DataLoader、换输出头、参数冻结、训练和最终推理。它本来该是全章最没戏剧性的部分，结果数据管道和推理脚本都留下了账。</p>
<h2 id="二spamdataset真正要盯住的是固定位置">二、<code>SpamDataset</code>：真正要盯住的是固定位置</h2>
<p><code>SpamDataset</code> 要做的事很清楚：把 CSV 里的短信逐条 tokenize，再统一长度。训练集传 <code>max_length=None</code>，让它自己找最长；验证集和测试集传 <code>train_dataset.max_length</code>，让它们沿用训练集的长度。</p>
<p>我自己手写时还把 <code>is None</code> 和 <code>is not None</code> 写反过一次，但那只是手快，不值得展开。真正需要留下的是：<strong>为什么训练集、验证集、测试集必须共享同一个 <code>max_length</code>。</strong></p>
<p>分类微调取的是<strong>某个固定位置</strong>的输出。书上取最后一个位置；训练集最长是 120 个 token，取到的就是第 120 个。训练时模型只在这个位置上被优化过。验证集的长度一变，位置就跟着变，等于拿一个没训过的位置去评估。</p>
<p>另一个真正踩到的错误是列名大小写。数据集处理时做过一次 <code>balanced_df[&quot;Label&quot;].map({&quot;ham&quot;: 0, &quot;spam&quot;: 1})</code>，所以 CSV 里的列名是 <code>Label</code>、值是 0 和 1。我写成了小写 <code>label</code>，取样本时报 <code>KeyError</code>。</p>
<h2 id="三drop_last只作用在最后一个不满的-batch-上">三、<code>drop_last</code>：只作用在最后一个不满的 batch 上</h2>
<p><code>DataLoader(train_dataset, batch_size=8, shuffle=True, drop_last=True)</code>。我一开始不知道 <code>drop_last</code> 是什么，去问了一遍。</p>
<p>DataLoader 是按固定 <code>batch_size</code> 顺序切块的。样本总数不整除 <code>batch_size</code> 时，最后一块会短一截。<code>drop_last=True</code> 就是把最后这块<strong>不要了</strong>，<code>False</code>（默认）则照发。</p>
<p>第六章的数据是训练集 1045 条、验证集 149 条、测试集 300 条，<code>batch_size = 8</code>：</p>
<ul>
<li>训练集 <code>1045 = 8 × 130 + 5</code>，<code>drop_last=True</code>，最后那 5 条被丢，一轮 130 个 batch</li>
<li>验证集 <code>149 = 8 × 18 + 5</code>，<code>False</code>，第 19 个 batch 只有 5 条</li>
<li>测试集 <code>300 = 8 × 37 + 4</code>，<code>False</code>，最后一个 batch 4 条</li>
</ul>
<p>所以它<strong>只在训练集那条 DataLoader 上有实际效果</strong>，影响的是 5 条样本。</p>
<p>训练用 <code>True</code> 的理由只有一个：让每个 batch 的形状恒定，训练循环里不会隔一阵冒出一个 <code>(5, 120)</code>。评估反过来必须是 <code>False</code>，因为<strong>评估的语义是在全部样本上算指标</strong>——丢掉最后一块，那 4 到 5 条样本就从头到尾没被评估过，而打印出来的依然是个正常的百分数，看不出少了样本。</p>
<p>有一个前提容易被忽略：<code>drop_last=True</code> 不丢数据，是<strong>因为同时开着 <code>shuffle=True</code></strong>。被丢的那 5 条每轮都不一样，多轮下来全会轮到。如果哪天把 <code>shuffle</code> 关掉，<code>drop_last=True</code> 就变成永远丢掉同一批尾巴。</p>
<h2 id="四shuffle它是一个参数不是一个占位符">四、<code>shuffle</code>：它是一个参数，不是一个占位符</h2>
<p>我一直以为 <code>shuffle</code> 是占位符。它不是。它只决定一件事：<strong>DataLoader 以什么顺序把样本切进 batch。</strong></p>
<p>DataLoader 每轮迭代做三步：产出 index、用 index 去调 <code>Dataset.__getitem__</code> 取样本、把这些样本拼成 batch。<code>shuffle</code> 管的是第一步。<code>False</code> 时 index 就是 <code>0,1,2,3,...</code>；<code>True</code> 时先对整个 index 列表做一次随机排列，再按这个顺序切。</p>
<p>两个容易搞错的点：</p>
<ul>
<li><strong>打乱的是 index 的顺序，不是数据本身。</strong> <code>train_dataset.encoded_texts</code> 一个字都没变，<code>train_dataset[3]</code> 永远返回第 3 条。我在 <code>__init__</code> 里做的 tokenize、截断、padding 和 <code>shuffle</code> 完全无关。</li>
<li><strong>是每个 epoch 重新打乱一次</strong>，不是开头打乱一次。这也是上一节那个结论的前提。</li>
</ul>
<h3 id="为什么训练必须打乱">为什么训练必须打乱</h3>
<p>我用一个 24 条、<strong>按标签排好序</strong>的假数据集跑了一遍（前 12 条标签 0，后 12 条标签 1），<code>batch_size=8</code>：</p>
<ul>
<li><code>shuffle=False</code> 时，三个 batch 的标签依次是 <code>[0,0,0,0,0,0,0,0]</code>、<code>[0,0,0,0,1,1,1,1]</code>、<code>[1,1,1,1,1,1,1,1]</code>——有的 batch 全是同一类</li>
<li><code>shuffle=True</code> 时，三个 batch 都是混着的</li>
</ul>
<p>不打乱时，每个 batch 就不是“从总体里随机抽出的一小撮”，而是一个有偏样本。而 <code>loss.backward()</code> 给的是这个 batch 平均 loss 的梯度——<strong>mini-batch 的梯度要能代表总体，前提是它是随机抽的</strong>。</p>
<p>第六章的真实数据有同样的风险：作者在仓库讨论区里算过，spam 平均 41.67 个 token、ham 平均 19.85 个，标签和长度是相关的。CSV 一旦有系统性排序，不打乱就会让每个 batch 的长度和标签一起偏向一边。</p>
<p>还有一层是随机性本身的正则化效果（SGD 的噪声帮模型避开尖锐的极小值）。这一条是经验性的，不是定理，我先记下不下结论。</p>
<h3 id="val-和-test-为什么是-false">val 和 test 为什么是 <code>False</code></h3>
<p>我当时的总结是：<code>True</code> 就是随机顺序，<code>False</code> 就是原本的顺序，这解释了 train 用 <code>True</code>、val 和 test 用 <code>False</code>。前半句完全对，后半句要加一层。</p>
<p>我实测过：<strong>评估是对所有样本求和再除，和顺序无关。</strong> 同一个模型、同一批 149 条数据，<code>shuffle</code> 开和关，准确率一模一样（都是 <code>0.550336</code>），loss 只差在第三位小数——那是逐 batch 平均和逐样本平均的差别。</p>
<p>所以 val/test 用 <code>False</code> 不是“否则会算错”，而是两件更小的事：</p>
<ul>
<li><strong>可比。</strong> 训练中每 50 步调一次评估，而 <code>evaluate_model</code> 只取前 5 个 batch。<code>False</code> 时这 5 个 batch 每次都是同一批样本，loss 的起伏只反映模型；<code>True</code> 时每次抽到不同的样本，我就分不清是模型在抖还是抽样在抖。</li>
<li><strong>可复现。</strong> 不引入随机性，就不用额外操心随机种子。</li>
</ul>
<p>它是零成本的改进，所以选它——但它和训练那里的 <code>shuffle=True</code> 不是一个量级的事。</p>
<blockquote>
<p>打乱的目的是让每个 batch 成为总体的无偏小样本（梯度估计问题），不是防止模型记住顺序（它没记忆）；评估不打乱是为了同一批样本、每次可比，不是因为随机顺序会算错——准确率对顺序完全免疫。</p>
</blockquote>
<h2 id="五两个开关两个不相干的理由">五、两个开关，两个不相干的理由</h2>
<p><code>shuffle</code> 和 <code>drop_last</code> 恰好是同一个取值模式（训练都是 <code>True</code>，评估都是 <code>False</code>），但理由完全不相干：</p>
<ul>
<li><code>shuffle</code>：随机性只在训练里有价值（梯度无偏），评估要的是可比和可复现</li>
<li><code>drop_last</code>：训练要形状恒定，评估要覆盖每一条样本</li>
</ul>
<p>我差点把它总结成“训练要乱的、评估要齐的”。这种口号一旦成立，遇到下一个参数就会套错模板。<strong>同一个取值模式，不等于同一个原因。</strong></p>
<h2 id="六五题验收每个问题都漏了一点">六、五题验收：每个问题都漏了一点</h2>
<p>6.1 到 6.5 看完后，我的体感是：第六章比第三、四、五章顺。于是我让 Kimi 出了五道题。答完以后发现，主线基本都抓住了，但每一题都有遗漏。这里按题目记录，专门留给以后回炉。</p>
<h3 id="1-换头不是从-50257-压到-2">1. 换头不是「从 50257 压到 2」</h3>
<p><strong>Kimi 原题：</strong></p>
<blockquote>
<p><strong>Q1：换头为什么就换了任务？</strong></p>
<p>预训练时：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">out_head</span> <span class="o">=</span> <span class="n">Linear</span><span class="p">(</span><span class="mi">768</span><span class="p">,</span> <span class="mi">50257</span><span class="p">)</span>
</span></span></code></pre></div><p>分类微调时变成：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">out_head</span> <span class="o">=</span> <span class="n">Linear</span><span class="p">(</span><span class="mi">768</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
</span></span></code></pre></div><p>这两个输出数值分别代表什么？为什么把输出头从 50257 换成 2，就能让同一个 GPT 主体做垃圾短信分类，而不是继续预测 next-token？</p>
<p>另外，你之前猜过「保留 50257 个输出，只取 spam 和 ham 两个词」。和直接换成二分类头相比，这两种方案的本质区别是什么？</p>
</blockquote>
<p>我一开始有三个说法不准确：把分类微调说成了无监督学习，把输出说成了概率，还把结构理解成“先得到 50257 个输出，再压缩成 2 个”。</p>
<p>修正后的理解是：</p>
<ul>
<li>训练数据包含文本和 label，所以分类微调是<strong>监督学习</strong>。<code>map({&quot;ham&quot;: 0, &quot;spam&quot;: 1})</code> 只是把人已经标注好的类别转换成数字，不是模型在替训练数据分类。</li>
<li>新输出头直接给出 ham 和 spam 的两个 logits，不是概率；softmax 之后才能解释成概率。</li>
<li>旧输出头是 <code>Linear(768, 50257)</code>，新输出头是 <code>Linear(768, 2)</code>。旧头被整个替换，不存在中间的 50257 维。</li>
<li>0 和 1 哪个是 ham、哪个是 spam，由 label 编码决定。训练做的事情，是让正确类别对应的 logit 更高。</li>
</ul>
<p>我之前说“二分类头类似掩盖住了其他词”，方向接近，但更准确的说法是：<strong>整个输出空间被换掉了</strong>。新头不再从词表里挑 token，而是直接学习两个类别的方向。</p>
<h3 id="2-欠采样裁的是多数类样本">2. 欠采样裁的是多数类样本</h3>
<p><strong>Kimi 原题：</strong></p>
<blockquote>
<p><strong>Q2：平衡数据集的代价是什么？</strong></p>
<p>原始数据里正常短信远多于垃圾短信，书中通过减少多数类样本让两类数量相同。</p>
<ol>
<li>如果不做平衡，模型可能学成什么样？</li>
<li>欠采样解决了问题，同时付出了什么代价？</li>
<li>为什么还需要独立的 validation 和 test，不能看 test 结果反复调方案？</li>
</ol>
</blockquote>
<p>这一题我只会说“为了让 0 和 1 数量一致”，没答出代价。</p>
<p>书中的多数类是 ham，少数类是 spam。欠采样就是从多数类里少取一些，让两边数量相同。这里裁掉的是样本条数，不是文本长度。</p>
<p>代价很直接：大量真实 ham 被丢掉，模型能看到的正常短信变少；留下哪些样本还会带来随机性。训练集被改成 50 : 50 以后，也不再等于真实世界的短信分布，所以模型输出的概率不能直接当成现实概率。</p>
<p>train、validation、test 的分工也重新钉了一遍：</p>
<ul>
<li>train：计算梯度，更新参数</li>
<li>validation：不更新参数，用来选 epoch、调方案、early stopping</li>
<li>test：不参与任何选择，最后评估一次</li>
</ul>
<p>独立划分不能保证不过拟合，只能帮助发现过拟合。反复根据 validation 调方案，也会逐渐过拟合 validation。</p>
<h3 id="3-batch-形状和-padding我答错了两处">3. batch 形状和 padding，我答错了两处</h3>
<p><strong>Kimi 原题：</strong></p>
<blockquote>
<p><strong>Q3：padding 和 max_length 到底做了什么？</strong></p>
<p>假设训练集中最长文本编码后有 120 个 token，batch_size=8。</p>
<ol>
<li>一个 batch 的 <code>input_batch</code> 和 <code>target_batch</code> 分别是什么 shape？</li>
<li>一条只有 35 个 token 的短信，进入 Dataset 后会发生什么？</li>
<li>validation 里如果有一条 130 个 token 的短信，而 <code>max_length</code> 使用的是训练集的 120，又会发生什么？</li>
<li>为什么这里可以直接用 50256 填充？它原本是哪个特殊 token？</li>
</ol>
</blockquote>
<p>我一开始把 batch 的第一维写成了“训练样本数 / 8”。这是把<strong>批次数</strong>当成了<strong>每批样本数</strong>。</p>
<p>假设训练集有 N 条样本，<code>batch_size=8</code>、<code>max_length=120</code>：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">批次数 ≈ N / 8
</span></span><span class="line"><span class="cl">input_batch  = (8, 120)
</span></span><span class="line"><span class="cl">target_batch = (8,)
</span></span></code></pre></div><p><code>target_batch</code> 是 8 个正确类别编号，不是模型输出，也不需要写成 <code>(8, 1)</code>。</p>
<p>更大的错误是 padding。我以为 35 个 token 只需要补一个结束符，实际上会补齐到 120：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">35 个 token + 85 个 50256 = 120 个 token
</span></span></code></pre></div><p>如果 validation 里有 130 个 token，而 <code>max_length</code> 使用训练集的 120，就会保留前 120 个，截掉最后 10 个。</p>
<p><code>50256</code> 是 GPT-2 的 <code>&lt;|endoftext|&gt;</code>。这里复用它作为 <code>pad_token_id</code>，不是新造了一个 <code>[PAD]</code>。</p>
<h3 id="4-padding-的最后位置为什么还能分类">4. padding 的最后位置为什么还能分类</h3>
<p><strong>Kimi 原题：</strong></p>
<blockquote>
<p><strong>Q4：最容易被忽略的一问——为什么取最后一个位置？</strong></p>
<p>假设一条真实文本只有 5 个 token，右侧 padding 到 8 个。分类时却使用：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">logits</span> <span class="o">=</span> <span class="n">model</span><span class="p">(</span><span class="n">input_batch</span><span class="p">)[:,</span> <span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="p">:]</span>
</span></span></code></pre></div><p>也就是取第 8 个位置，而不是真实文本的第 5 个位置。</p>
<p>这个 padding 位置凭什么能代表前面的真实文本？请结合因果掩码下每个位置能看见哪些 token 来解释。</p>
<p>再追问一句：如果换成双向注意力，「只有最后一个位置能看到完整前文」这个理由还成立吗？</p>
</blockquote>
<p>这一题我答上来了：在因果掩码下，一个位置只能看到自己和它左边的 token，所以最后一个位置可以看见完整前文。即使最后位置是 padding，它的注意力计算也能覆盖前面的真实 token。</p>
<p>更精确地说，点积只是 Q 和 K 的打分；真正写入当前位置的是 softmax 之后对 V 的加权汇总，再经过多层 Transformer Block。最后一个位置的隐藏状态因此可以作为整段文本的上下文表示。</p>
<p>双向注意力是我遇到的新名词。它和因果注意力的区别是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">因果注意力：位置 i 能看 0 ... i
</span></span><span class="line"><span class="cl">双向注意力：位置 i 能看 0 ... T-1
</span></span></code></pre></div><p>GPT 因为不能偷看未来，所以用因果注意力。双向注意力下，每个位置都能看到完整序列，「取最后一个位置」就不再是必须的选择。</p>
<h3 id="5-冻结参数冻结更新不冻结计算">5. 冻结参数：冻结更新，不冻结计算</h3>
<p><strong>Kimi 原题：</strong></p>
<blockquote>
<p><strong>Q5：冻结参数到底冻结了什么？</strong></p>
<p>书中先执行：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">for</span> <span class="n">param</span> <span class="ow">in</span> <span class="n">model</span><span class="o">.</span><span class="n">parameters</span><span class="p">():</span>
</span></span><span class="line"><span class="cl">    <span class="n">param</span><span class="o">.</span><span class="n">requires_grad</span> <span class="o">=</span> <span class="kc">False</span>
</span></span></code></pre></div><p>然后又替换 <code>out_head</code>，并解冻最后一个 Transformer Block 和 <code>final_norm</code>。</p>
<ol>
<li><code>requires_grad = False</code> 之后，这些参数还会参与前向计算吗？模型的输出会因此变成固定值吗？</li>
<li>冻结之后才创建的新 <code>Linear(768, 2)</code>，默认会被训练吗？</li>
<li>为什么不只是训练新分类头，也不直接把整个模型全部解冻？「只训头部」「只解冻最后一部分」「全量微调」三种方案分别在拿什么交换什么？</li>
</ol>
</blockquote>
<p><code>requires_grad = False</code> 的含义是参数仍然参与前向计算，但反向传播时不计算它的梯度，optimizer 也不更新它。</p>
<p>我一开始拿 <code>top_k</code>、温度和 <code>multinomial</code> 来证明输出不固定，这个理由错了。采样发生在得到 logits 之后，而且分类微调不调用 <code>generate</code>。输出仍可能变化，是因为输入不同、新分类头还在训练、<code>model.train()</code> 时 dropout 仍然生效。</p>
<p>冻结旧模型之后再创建新的 <code>nn.Linear</code>，新参数默认 <code>requires_grad=True</code>，所以新分类头会正常训练。</p>
<p>三种训练范围也重新分清了：</p>
<ul>
<li><strong>只训分类头</strong>：也叫 linear probe。它不是没学分类，而是在冻结特征上学习一个分类边界。最省资源，但模型无法调整内部表示。</li>
<li><strong>训练最后一个 Block + <code>final_norm</code> + 分类头</strong>：让最高层表示向当前任务靠拢，是成本和适应能力之间的折中。</li>
<li><strong>全量微调</strong>：调整空间最大，但成本最高，也更容易在小数据上过拟合，甚至覆盖预训练学到的通用能力。</li>
</ul>
<p>所以不能说全量微调“当然效果最好”。它只是可调空间最大，最终效果仍取决于数据量、训练成本和过拟合风险。</p>
<h2 id="七能跑不等于可复用推理脚本留下的工程债">七、能跑不等于可复用：推理脚本留下的工程债</h2>
<p>下午最后把 <code>classify_review</code> 跑通了，两个样例分别返回：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">spam
</span></span><span class="line"><span class="cl">not spam
</span></span></code></pre></div><p>这说明推理链路本身是对的：<code>model.eval()</code>、<code>no_grad()</code>、截断、padding、取最后一个位置、argmax、标签映射，全都接上了。</p>
<p>但 Kimi 看完代码后指出：这版是「验证能跑」的脚本，还不是可复用的分类器。后续要补齐的工程债先记在这里：</p>
<ol>
<li><strong><code>max_length=None</code> 会直接报错。</strong> 现在的代码会做 <code>min(None, 1024)</code>，之所以没炸，是因为调用方固定传了 120。要么显式要求必填，要么提供明确的默认策略。</li>
<li><strong><code>max_length</code> 大于上下文长度时会重新 pad 超界。</strong> 应该先算 <code>effective_max_length = min(max_length, context_length)</code>，截断和 padding 都用这个值。</li>
<li><strong><code>max_length=120</code> 和 <code>1=spam</code> 不应该硬编码。</strong> 它们属于训练产物，应该和 <code>model_state_dict</code>、模型配置一起保存进 checkpoint。否则以后重新训练，推理代码不会报错，只会悄悄用错。</li>
<li><strong>加载模型和使用模型要拆开。</strong> 现在每调用一次 <code>classify_review_with_state_model</code>，就重新加载一次模型。批量推理时应该先 <code>load_classifier</code> 一次，再反复调用 <code>classify_review</code>。</li>
<li><strong>推理时没必要先加载原始 GPT-2 权重。</strong> checkpoint 里已经有完整的微调后参数，直接按配置创建模型、替换分类头、加载 <code>state_dict</code> 就够了。</li>
</ol>
<p>后续补这件事的完成标准：</p>
<ul>
<li>checkpoint 同时保存 <code>config</code>、<code>max_length</code>、<code>label_map</code> 和 <code>model_state_dict</code>；</li>
<li>模型只加载一次，可以连续分类多条文本；</li>
<li>推理不再依赖先下载 GPT-2 原始权重；</li>
<li>checkpoint 路径不依赖运行时目录；</li>
<li>从任意目录运行，都能得到同一条分类链路。</li>
</ul>
<p>今天先不改。能跑通是第六章的学习终点之一，可复用是下一步工程化。</p>
<h2 id="八如实记录原来那个问题解决了">八、如实记录：原来那个问题解决了</h2>
<ul>
<li>原来留在这里的问题是“padding 和取最后一个位置叠在一起会怎样”。五题验收的第 4 题已经把它解决：padding 位置本身不聪明，聪明的是<strong>这个位置在因果掩码下拥有完整前文的信息入口</strong>。</li>
<li>6.1 到 6.5 目前没有新的“没懂”，但有两个习惯要继续改：不要把 logits 直接说成概率；不要把批次数写进 batch 形状。</li>
<li>6.6 到 6.8 已经跑通，但分类 loss、accuracy、训练循环和 <code>classify_review</code> 还没有做同样的五题验收，暂时只算「跑通过」，不算「验收过」。</li>
<li>第三、四章的手写回炉不塞进今天，已经单独放到<a href="https://blog.lvxinrong.com/llm/backlog/">《学习回炉待办》</a>。</li>
</ul>
<h2 id="九三问式收尾">九、三问式收尾</h2>
<ol>
<li><strong>今天学了什么</strong>：<code>SpamDataset</code> 为什么必须共享固定位置、<code>drop_last</code> 和 <code>shuffle</code> 的真实职责、分类头输出的是两个类别 logits、欠采样的代价、batch 和 target 的真实形状、最后位置能分类的原因、<code>requires_grad=False</code> 的真实含义，以及一次完整的垃圾短信分类推理；</li>
<li><strong>哪里还没懂</strong>：6.6 到 6.8 还没完成同样的问答验收，<code>classify_review</code> 也还没有达到可复用标准；</li>
<li><strong>接下来干什么</strong>：先验收 6.6 到 6.8，再把推理脚本拆成「加载一次模型」和「重复分类文本」两步。</li>
</ol>
<p><em>方法：数据管道部分我先写、先讲，DeepSeek 指错；6.1 到 6.5 由 Kimi 出题验收；6.6 到 6.8 我先跑通，再由 Kimi 做代码检查。学习时长待我自己补。</em></p>
]]></content:encoded>
    </item>
  </channel>
</rss>
