<?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>PyTorch on 吕炘嵘的博客</title>
    <link>https://blog.lvxinrong.com/tags/pytorch/</link>
    <description>Recent content in PyTorch on 吕炘嵘的博客</description>
    <image>
      <title>吕炘嵘的博客</title>
      <url>https://blog.lvxinrong.com/og-default.jpg</url>
      
      <link>https://blog.lvxinrong.com/tags/pytorch/</link>
    </image>
    <generator>Hugo</generator>
    <language>zh-CN</language>
    <lastBuildDate>Tue, 10 Nov 2026 14:55:19 +0800</lastBuildDate>
    <atom:link href="https://blog.lvxinrong.com/tags/pytorch/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>手搓 LLM 笔记 19：I2，训练加速与显存压榨</title>
      <link>https://blog.lvxinrong.com/llm/llm-19-i2-environment-probe/</link>
      <pubDate>Tue, 10 Nov 2026 14:55:19 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-19-i2-environment-probe/</guid>
      <description>从 Mac/MPS 环境探针，到 FP32/FP16/BF16、SDPA、torch.compile 与 Activation Checkpointing 的重复对照实验；同时记录正确性、吞吐、内存和结论边界。</description>
      <content:encoded><![CDATA[<blockquote>
<p>I2 不直接从修改训练代码开始。优化之前先确认当前设备究竟支持什么，避免把 CUDA 教程里的能力直接套到 Mac/MPS 上。</p>
</blockquote>
<h2 id="一i2-0-的目标是什么">一、I2-0 的目标是什么？</h2>
<p>当前目标是建立训练加速的环境与基线，不是马上让模型提速。</p>
<p>本次环境探针覆盖：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">FP16 / BF16 原生矩阵乘法
</span></span><span class="line"><span class="cl">→ FP16 / BF16 autocast
</span></span><span class="line"><span class="cl">→ SDPA
</span></span><span class="line"><span class="cl">→ torch.compile
</span></span></code></pre></div><p>源码：<code>scripts/i2_environment_probe.py</code>。</p>
<p>输出报告：<code>data/reports/i2-environment.json</code>。</p>
<p>这一步只回答“当前环境能否运行这些能力”，不证明完整模型训练稳定，也不证明任何优化已经产生收益。</p>
<h2 id="二run_probe统一管理执行与异常">二、run_probe：统一管理执行与异常</h2>
<p>环境探针使用了一个统一入口：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">run_probe</span><span class="p">(</span><span class="n">function</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">try</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="n">result</span> <span class="o">=</span> <span class="n">function</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;supported&#34;</span><span class="p">:</span> <span class="kc">True</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;result&#34;</span><span class="p">:</span> <span class="nb">str</span><span class="p">(</span><span class="n">result</span><span class="p">),</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">except</span> <span class="ne">Exception</span> <span class="k">as</span> <span class="n">exc</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;supported&#34;</span><span class="p">:</span> <span class="kc">False</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;error&#34;</span><span class="p">:</span> <span class="sa">f</span><span class="s2">&#34;</span><span class="si">{</span><span class="nb">type</span><span class="p">(</span><span class="n">exc</span><span class="p">)</span><span class="o">.</span><span class="vm">__name__</span><span class="si">}</span><span class="s2">: </span><span class="si">{</span><span class="n">exc</span><span class="si">}</span><span class="s2">&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span></code></pre></div><p>它接收一个可调用对象，在内部真正执行，并统一整理成功或失败结果。</p>
<p>这是一种<strong>高阶函数</strong>（Higher-order Function）的用法：函数接收另一个函数作为参数。也可以把它看成一个手写 wrapper（包装器），有点类似 Java/AOP 里的环绕通知，但这里不需要引入框架。</p>
<p>它解决了两个问题：</p>
<ol>
<li>把实际执行统一放进 <code>try/except</code>，一个探针失败不会阻止其他探针执行；</li>
<li>所有探针使用相同的结果结构，方便汇总成 JSON。</li>
</ol>
<p>但它只证明“没有抛异常”，不等于结果正确。具体正确性仍由探针内部的断言或结果检查负责。</p>
<p>在正式测试中不能随意吞掉所有异常；这里适合使用，是因为环境盘点的目标是完整收集支持与不支持项。</p>
<h2 id="三位置参数与关键字参数">三、位置参数与关键字参数</h2>
<p><code>*args</code> 和 <code>**kwargs</code> 的区别：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">*args   → 接收位置参数，只传值，收集成 tuple
</span></span><span class="line"><span class="cl">**kwargs → 接收 key=value 参数，收集成 dict
</span></span></code></pre></div><p>例如：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">example</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">,</span> <span class="n">device</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="o">...</span>
</span></span></code></pre></div><p>调用：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">example</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="n">device</span><span class="o">=</span><span class="s2">&#34;mps&#34;</span><span class="p">)</span>
</span></span></code></pre></div><p>在一个通用包装器里：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">run_probe</span><span class="p">(</span><span class="n">function</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">function</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">)</span>
</span></span></code></pre></div><p>再这样调用：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">run_probe</span><span class="p">(</span><span class="n">example</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="n">device</span><span class="o">=</span><span class="s2">&#34;mps&#34;</span><span class="p">)</span>
</span></span></code></pre></div><p>就等价于原调用。</p>
<p><code>args</code> 和 <code>kwargs</code> 只是约定俗成的变量名，真正让收集与展开生效的是 <code>*</code> 和 <code>**</code>。</p>
<h2 id="四lambda把调用包装成稍后再执行的函数">四、lambda：把调用包装成稍后再执行的函数</h2>
<p>当前代码里：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">run_probe</span><span class="p">(</span><span class="k">lambda</span><span class="p">:</span> <span class="n">dtype_probe</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">float16</span><span class="p">))</span>
</span></span></code></pre></div><p>等价于：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">temporary_function</span><span class="p">():</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">dtype_probe</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">float16</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">run_probe</span><span class="p">(</span><span class="n">temporary_function</span><span class="p">)</span>
</span></span></code></pre></div><p><code>lambda</code> 是创建匿名函数的关键字，基本格式为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">lambda</span> <span class="n">参数</span><span class="p">:</span> <span class="n">返回值表达式</span>
</span></span></code></pre></div><p>例如：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span> <span class="o">*</span> <span class="mi">2</span>
</span></span></code></pre></div><p>等价于：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">double</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">x</span> <span class="o">*</span> <span class="mi">2</span>
</span></span></code></pre></div><p>当前 lambda 冒号前没有参数，所以它是一个无参数函数。</p>
<h3 id="为什么不直接调用">为什么不直接调用？</h3>
<p>如果写成：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">run_probe</span><span class="p">(</span><span class="n">dtype_probe</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">float16</span><span class="p">))</span>
</span></span></code></pre></div><p>Python 会先执行 <code>dtype_probe(torch.float16)</code>，再把结果传给 <code>run_probe()</code>。如果探针出错，异常发生在进入 <code>run_probe()</code> 之前，内部的 <code>try/except</code> 就接不住。</p>
<p>使用 lambda 后：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">创建 lambda，但不执行探针
</span></span><span class="line"><span class="cl">→ 把 lambda 传给 run_probe
</span></span><span class="line"><span class="cl">→ run_probe 内部执行 function()
</span></span><span class="line"><span class="cl">→ 这时才执行 dtype_probe(torch.float16)
</span></span><span class="line"><span class="cl">→ 异常由 run_probe 统一捕获
</span></span></code></pre></div><p>这里的“延迟执行”不是异步、定时或懒加载，也不是等到保存 report 时才执行。它只是<strong>相对于直接调用，推迟到包装器内部执行</strong>。</p>
<h3 id="为什么-sdpa-和-compile-不使用-lambda">为什么 SDPA 和 compile 不使用 lambda？</h3>
<p>因为它们本身已经是没有参数的函数：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">run_probe</span><span class="p">(</span><span class="n">sdpa_probe</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="n">run_probe</span><span class="p">(</span><span class="n">compile_probe</span><span class="p">)</span>
</span></span></code></pre></div><p>传函数名而没有括号，就还没有执行。<code>run_probe()</code> 内部的 <code>function()</code> 才会真正调用它们。</p>
<p>需要记住：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">run_probe</span><span class="p">(</span><span class="n">sdpa_probe</span><span class="p">)</span>   <span class="c1"># 传函数对象，尚未执行</span>
</span></span><span class="line"><span class="cl"><span class="n">run_probe</span><span class="p">(</span><span class="n">sdpa_probe</span><span class="p">())</span> <span class="c1"># 先执行，再把结果传进去</span>
</span></span></code></pre></div><p>所以规则是：</p>
<blockquote>
<p>无参数函数直接传函数名；需要参数的函数，可以用 lambda 或 partial 提前绑定参数，再交给统一执行器。</p>
</blockquote>
<h2 id="五闭包内部函数使用外层的-device">五、闭包：内部函数使用外层的 device</h2>
<p>几个探针定义在 <code>main()</code> 内部，并直接使用：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">device</span><span class="o">=</span><span class="n">device</span>
</span></span></code></pre></div><p>这里没有显式给 <code>sdpa_probe()</code> 传 <code>device</code>，是因为内部函数可以读取外层函数作用域中的变量。这属于<strong>闭包</strong>（closure）的使用。</p>
<p>它不是 Python 自动推断参数，也不是自动注入；只是函数沿作用域找到了外层已经定义的 <code>device</code>。</p>
<h2 id="六item把单元素-tensor-转成-python-数字">六、item()：把单元素 Tensor 转成 Python 数字</h2>
<p>原生精度探针使用：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">result</span> <span class="o">=</span> <span class="p">(</span><span class="n">x</span> <span class="o">@</span> <span class="n">x</span><span class="p">)</span><span class="o">.</span><span class="n">sum</span><span class="p">()</span><span class="o">.</span><span class="n">item</span><span class="p">()</span>
</span></span></code></pre></div><p>拆开是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">x @ x       → 得到一个矩阵
</span></span><span class="line"><span class="cl">.sum()      → 对所有元素求和，得到单元素 Tensor
</span></span><span class="line"><span class="cl">.item()     → 转成普通 Python float
</span></span></code></pre></div><p><code>item()</code> 是 number of elements 为 1 时才能使用的取值方式：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">(</span><span class="mf">2.0</span><span class="p">)</span><span class="o">.</span><span class="n">item</span><span class="p">()</span>        <span class="c1"># 可以</span>
</span></span><span class="line"><span class="cl"><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mf">1.0</span><span class="p">])</span><span class="o">.</span><span class="n">item</span><span class="p">()</span>      <span class="c1"># 可以</span>
</span></span><span class="line"><span class="cl"><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mf">1.0</span><span class="p">,</span> <span class="mf">2.0</span><span class="p">])</span><span class="o">.</span><span class="n">item</span><span class="p">()</span> <span class="c1"># 报错</span>
</span></span></code></pre></div><p>它常用于打印 loss、写 JSON 或取单个数值。</p>
<p>但需要注意：</p>
<ul>
<li><code>loss.item()</code> 后得到的是普通数字，不能再参与反向传播；</li>
<li>在 GPU/MPS 上，<code>item()</code> 会把结果同步回 CPU，频繁调用可能影响性能测量。</li>
</ul>
<h2 id="七autocast在指定作用域内自动选择部分算子的精度">七、autocast：在指定作用域内自动选择部分算子的精度</h2>
<p>代码：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">with</span> <span class="n">torch</span><span class="o">.</span><span class="n">autocast</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">device_type</span><span class="o">=</span><span class="n">device</span><span class="o">.</span><span class="n">type</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">dtype</span><span class="o">=</span><span class="n">dtype</span><span class="p">,</span>
</span></span><span class="line"><span class="cl"><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">result</span> <span class="o">=</span> <span class="n">x</span> <span class="o">@</span> <span class="n">x</span>
</span></span></code></pre></div><p><code>autocast</code> 是自动混合精度/自动类型转换，不是参数匹配。</p>
<p>其中：</p>
<ul>
<li><code>device_type</code>：设备类型，例如当前 <code>&quot;mps&quot;</code>；</li>
<li><code>dtype</code>：目标计算精度，例如 FP16 或 BF16；</li>
<li><code>with</code>：只在这个代码块作用域内启用。</li>
</ul>
<p>它不会把所有模型参数永久转换，也不会无差别转换所有运算。符合规则的算子会按 autocast 策略选择计算精度，离开 <code>with</code> 后恢复默认行为。</p>
<p>探针中还检查了：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">assert</span> <span class="n">result</span><span class="o">.</span><span class="n">dtype</span> <span class="o">==</span> <span class="n">dtype</span>
</span></span></code></pre></div><p>防止“语法上写了 autocast，实际输出 dtype 却完全没变化”的空操作被误判为支持。</p>
<h3 id="fp32fp16-与-bf16-的位分配">FP32、FP16 与 BF16 的位分配</h3>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>格式</th>
        <th style="text-align: right">总位数</th>
        <th style="text-align: right">指数位</th>
        <th style="text-align: right">尾数位</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>FP32</td>
        <td style="text-align: right">32</td>
        <td style="text-align: right">8</td>
        <td style="text-align: right">23</td>
      </tr>
      <tr>
        <td>FP16</td>
        <td style="text-align: right">16</td>
        <td style="text-align: right">5</td>
        <td style="text-align: right">10</td>
      </tr>
      <tr>
        <td>BF16</td>
        <td style="text-align: right">16</td>
        <td style="text-align: right">8</td>
        <td style="text-align: right">7</td>
      </tr>
    </tbody>
  </table>
</div>
<p>三种格式都由符号位、指数位和尾数位组成。指数位决定数值范围，尾数位决定有效数字的精度：</p>
<ul>
<li>FP16 指数位较少，范围较小；尾数位比 BF16 多，精度细节更多；</li>
<li>BF16 指数位与 FP32 相同，范围接近 FP32；尾数位较少，精度更粗；</li>
<li>FP32 同时具备更多有效数字和足够大的数值范围，适合作为数值基线。</li>
</ul>
<p>这不是通过“小数点靠前或靠后”实现的。浮点数都可以近似理解为“有效数字 × 2^指数”，指数决定数量级，尾数决定保留多少有效数字。</p>
<h2 id="八sdpa统一注意力入口不是单一后端算法">八、SDPA：统一注意力入口，不是单一后端算法</h2>
<p>SDPA 全称 Scaled Dot-Product Attention，缩放点积注意力。</p>
<p>调用：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">result</span> <span class="o">=</span> <span class="n">F</span><span class="o">.</span><span class="n">scaled_dot_product_attention</span><span class="p">(</span><span class="n">q</span><span class="p">,</span> <span class="n">q</span><span class="p">,</span> <span class="n">q</span><span class="p">)</span>
</span></span></code></pre></div><p>这里的 <code>F</code> 是 <code>torch.nn.functional</code> 的别名，不是 function 的缩写。</p>
<p>三个 <code>q</code> 分别作为 Q、K、V。真实模型中它们通常来自不同 Linear 投影；探针里复用同一个随机张量，只是为了验证调用链路。</p>
<p>随机张量形状：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">(1, 2, 8, 16)
</span></span><span class="line"><span class="cl">= (B=1, H=2, T=8, D=16)
</span></span></code></pre></div><p>输出形状仍为 <code>(1, 2, 8, 16)</code>。</p>
<p>SDPA 完成的数学过程仍然是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Q × Kᵀ
</span></span><span class="line"><span class="cl">→ 除以 √head_dim
</span></span><span class="line"><span class="cl">→ 按需添加 mask
</span></span><span class="line"><span class="cl">→ softmax
</span></span><span class="line"><span class="cl">→ × V
</span></span></code></pre></div><p>与手写 eager 的区别是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">eager：逐步生成 scores、weights 和输出
</span></span><span class="line"><span class="cl">SDPA：交给 PyTorch 统一算子，由后端选择具体实现
</span></span></code></pre></div><p>PyTorch 可能根据版本、设备、dtype、形状和 mask 等条件，选择普通 math、memory-efficient 或其他优化路径。SDPA 不等于 FlashAttention，后者只是可能的后端之一。</p>
<p>这也解释了之前官方对照中的数值差异：数学公式相同，但不同后端的运算顺序、融合与舍入路径可能不同。</p>
<h2 id="九torchcompile优化计算执行方式">九、torch.compile：优化计算执行方式</h2>
<p>当前探针：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">function</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">x</span> <span class="o">*</span> <span class="mi">2</span> <span class="o">+</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">compiled</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">compile</span><span class="p">(</span><span class="n">function</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="n">result</span> <span class="o">=</span> <span class="n">compiled</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mf">1.0</span><span class="p">,</span> <span class="mf">2.0</span><span class="p">],</span> <span class="n">device</span><span class="o">=</span><span class="n">device</span><span class="p">))</span>
</span></span></code></pre></div><p><code>torch.compile(function)</code> 不会立即执行函数，而是返回一个新的可编译优化对象。传入输入后，由它完成实际计算。</p>
<p>本例中：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">1 × 2 + 1 = 3
</span></span><span class="line"><span class="cl">2 × 2 + 1 = 5
</span></span></code></pre></div><p>输出为 <code>[3.0, 5.0]</code>。</p>
<p>compile 的目标是把逐步执行的 PyTorch 代码转换成更适合优化的计算图，再由后端生成更高效的执行路径。它不改变数学公式或模型权重。</p>
<p>首次调用通常有编译成本，后续稳态执行才可能体现收益。微小函数通过探针，不等于完整 model_v3 编译后一定更快。</p>
<h3 id="与-java-jit-的类比">与 Java JIT 的类比</h3>
<p>Java HotSpot JVM 中，热点代码会经过 JIT（Just-In-Time，即时编译）优化：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Java 源码
</span></span><span class="line"><span class="cl">→ javac 生成字节码
</span></span><span class="line"><span class="cl">→ JVM 执行并收集运行时信息
</span></span><span class="line"><span class="cl">→ JIT 将热点字节码编译成优化后的原生机器码
</span></span></code></pre></div><p>这里不是修改或重新实现原字节码，而是把热点代码编译成当前 CPU 可直接执行的原生机器码。</p>
<p>常见名词包括 HotSpot、热点代码、分层编译、C1/C2 编译器和去优化。</p>
<p>与 PyTorch 的对应关系：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Java JIT：热点字节码 → 优化后的 CPU 机器码
</span></span><span class="line"><span class="cl">torch.compile：张量计算图 → 优化后的设备内核
</span></span></code></pre></div><p>一个重要区别是：Java JIT 会依据运行时热点自动优化，而 <code>torch.compile()</code> 是我们显式选择要编译的函数或模型。</p>
<p>两者都不是改变程序语义，而是在保持逻辑的前提下优化执行方式。</p>
<h2 id="十当前真实环境结果">十、当前真实环境结果</h2>
<p>当前环境：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Python 3.12.12
</span></span><span class="line"><span class="cl">PyTorch 2.14.1
</span></span><span class="line"><span class="cl">macOS arm64
</span></span><span class="line"><span class="cl">device = MPS
</span></span><span class="line"><span class="cl">CUDA 不可用
</span></span></code></pre></div><p>探针结果：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>能力</th>
        <th>结果</th>
        <th>实际输出</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>FP16 原生矩阵乘法</td>
        <td>通过</td>
        <td>sum=4096.0</td>
      </tr>
      <tr>
        <td>BF16 原生矩阵乘法</td>
        <td>通过</td>
        <td>sum=4096.0</td>
      </tr>
      <tr>
        <td>FP16 autocast</td>
        <td>通过</td>
        <td>输出 dtype 为 FP16</td>
      </tr>
      <tr>
        <td>BF16 autocast</td>
        <td>通过</td>
        <td>输出 dtype 为 BF16</td>
      </tr>
      <tr>
        <td>SDPA</td>
        <td>通过</td>
        <td>输出形状 <code>(1, 2, 8, 16)</code></td>
      </tr>
      <tr>
        <td>torch.compile</td>
        <td>通过</td>
        <td>输出 <code>[3.0, 5.0]</code></td>
      </tr>
    </tbody>
  </table>
</div>
<p>这些结果证明的是<strong>当前微探针可执行</strong>，不是完整训练优化已经通过。</p>
<p>尚未证明：</p>
<ul>
<li>完整 model_v3 在 FP16/BF16 下训练稳定；</li>
<li>长训练的 loss 与 checkpoint 行为正确；</li>
<li>compile 后的完整模型获得真实吞吐收益；</li>
<li>当前 Mac 支持 FlashAttention；</li>
<li>任何速度、显存或 MFU 改善。</li>
</ul>
<p>下一步才是建立固定输入、固定模型、固定步数的 FP32 训练基线，然后逐项引入混合精度、SDPA/compile 和 Activation Checkpointing，并同时记录正确性与资源指标。</p>
<h2 id="十一思考大模型时代还需要-dropout-吗">十一、思考：大模型时代还需要 Dropout 吗？</h2>
<p>在环境探针之外，我还注意到了另一个问题：当前 GPTModel 里似乎在多个位置都放了 Dropout，Embedding、Attention 权重和残差分支都有。但现代大模型又经常直接使用 <code>drop_rate=0.0</code>，这些传统正则化手段是否已经过时？</p>
<p>我的原始直觉是：大模型是在用海量数据拟合世界，训练样本一直增加，过去为了解决小样本过拟合而设计的 Dropout，放在今天可能显得有些生硬。</p>
<p>这个直觉有一部分是对的。大模型从零预训练时，数据规模很大，很多语料只训练一次或少数几次，算力本身就是主要瓶颈，模型甚至还没有充分拟合训练集。此时主要矛盾往往是训练不足、算力和数据效率，而不是过拟合。Dropout 的正则化收益可能不明显，还会增加额外计算与训练噪声。</p>
<p>但“过拟合的本质就是样本不足”并不完整。更准确的定义是：</p>
<blockquote>
<p>过拟合是模型在训练数据上的表现，明显好于它在同分布未见数据上的表现。</p>
</blockquote>
<p>样本数量只是其中一个因素。数据重复程度、多样性、模型容量、训练步数、epoch、学习率，以及训练分布与真实使用分布是否一致，都会影响过拟合。</p>
<p>即使数据总量很大，也可能因为重复、污染或分布差异而过拟合；小数据也不一定必然过拟合，需要看 train 与 held-out 的真实差距。</p>
<p>放到当前个人博客语料上，结论又会变化。当前训练 token store 只有约 117,890 tokens，如果后续 midtrain 时反复进行多轮 epoch，模型容量较大、训练步数较多，Dropout、学习率、训练步数、数据混合和 early stopping 都可能重新变得重要。</p>
<p>因此，不是“过去的方法在大模型时代失效”，而是：</p>
<blockquote>
<p>大规模预训练常常不需要 Dropout；小语料微调、midtrain 和反复训练时，它仍然可能有用。是否启用，应由训练场景和 train/held-out 表现决定，而不是仅凭“这是大模型”。</p>
</blockquote>
<p>另外，Dropout 也不是一个单纯的性能开关。关闭后即使更快，也可能改变训练行为与正则化强度，不能直接写成 I2 的“免费性能优化”。如果以后做对照，需要固定模型、数据、初始化和训练预算，同时比较训练吞吐、train/held-out loss、BPB 与行为表现。</p>
<h2 id="十二思考val-loss-下降能否直接解决泛化问题">十二、思考：val loss 下降能否直接解决泛化问题？</h2>
<p>顺着 Dropout 的讨论，我又产生了一个想法：既然目标是泛化，是否应该准备一个小样本 val 数据集，通过 val loss 下降来解决，而不是通过 Dropout 这种随机方式？</p>
<p>这里需要把训练手段与评估证据分开。</p>
<blockquote>
<p>val loss 下降是评估结果，不是训练手段。验证集可以测量和选择模型，但本身不会直接让模型学会泛化。</p>
</blockquote>
<p>Validation 的作用是：</p>
<ul>
<li>测量模型在未参与训练的数据上的表现；</li>
<li>帮助选择 checkpoint、学习率、Dropout 和训练步数；</li>
<li>在 val loss 开始恶化时考虑 early stopping；</li>
<li>检查某种训练方法是否可能改善了泛化。</li>
</ul>
<p>如果“用 val loss 选择最佳 checkpoint 或 early stopping”，这是合理的；但它只是从已有训练结果中做选择，不是直接提升模型的泛化能力。</p>
<p>Dropout 与验证集工作在两个阶段：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Dropout：
</span></span><span class="line"><span class="cl">训练时随机屏蔽部分激活
</span></span><span class="line"><span class="cl">→ 减少对特定神经通路的依赖
</span></span><span class="line"><span class="cl">→ 尝试改善训练后的泛化表现
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">Validation：
</span></span><span class="line"><span class="cl">测量 held-out loss / BPB
</span></span><span class="line"><span class="cl">→ 判断这种训练方式是否有效
</span></span></code></pre></div><p>所以它们不是互相替代的两种方案，而是训练方法与评估方法的关系。</p>
<h3 id="loss-下降也不能直接等于学会了">loss 下降也不能直接等于“学会了”</h3>
<p>即使是 val loss 下降，也只是泛化改善的证据之一：</p>
<ul>
<li>小验证集可能有较大的偶然性；</li>
<li>平均 loss 可能被少数样本主导；</li>
<li>模型可能只学到表面模式，行为测试仍然失败；</li>
<li>反复根据 val 结果调参，也可能产生对验证集的适应性过拟合。</li>
</ul>
<p>因此更稳妥的划分是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">train：用于梯度更新
</span></span><span class="line"><span class="cl">val：用于调参、选 checkpoint 和 early stopping
</span></span><span class="line"><span class="cl">test：保持隔离，用于最终验收
</span></span></code></pre></div><p>同时再配合固定行为测试、BPB 和生成样例，而不是只盯着一个 loss 数字。</p>
<p>如果未来比较 <code>dropout=0.0 / 0.05 / 0.1</code>，应该同时观察 train loss、val loss、train/val 差距、固定行为表现以及最终 test 结果。只有当这些证据共同支持时，才能说某种配置在这次实验中可能改善了泛化。</p>
<p>这两个思考最后收敛成同一句话：</p>
<blockquote>
<p><strong>Dropout 是可能改善泛化的训练手段，val/test 是检验泛化的证据；loss 下降本身不会直接解决泛化问题。真正需要建立的是可复现的训练对照和独立的评估证据。</strong></p>
</blockquote>
<h2 id="十三数学回炉从-logitssoftmax-到交叉熵的--lnp">十三、数学回炉：从 logits、Softmax 到交叉熵的 -ln(p)</h2>
<p>在 Activation Checkpointing 的正确性测试中，我又回炉了一个看似早就理解、其实一直说得不够准确的地方：交叉熵到底怎样从模型输出变成 loss？</p>
<h3 id="1-logits-与-target-分别是什么">1. logits 与 target 分别是什么？</h3>
<p>假设一次有 <code>N</code> 个位置需要预测，词表大小为 <code>V</code>：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">logits：(N, V)
</span></span><span class="line"><span class="cl">targets：(N,)
</span></span></code></pre></div><p><code>logits</code> 中每一行都是当前位置对整个词表的预测分数；<code>targets</code> 中每个值则是该位置的正确 token ID。</p>
<p>例如 <code>N=1、V=6</code>：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">logits</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mf">1.</span><span class="p">,</span> <span class="mf">2.</span><span class="p">,</span> <span class="mf">3.</span><span class="p">,</span> <span class="mf">4.</span><span class="p">,</span> <span class="mf">5.</span><span class="p">,</span> <span class="mf">6.</span><span class="p">]])</span>
</span></span><span class="line"><span class="cl"><span class="n">target</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">4</span><span class="p">])</span>
</span></span></code></pre></div><p>这里 <code>target=4</code> 表示正确类别的下标是 4，不是“target 的概率就是 1”。如果要写成理想的 one-hot 目标分布，才是 <code>[0, 0, 0, 0, 1, 0]</code>。</p>
<h3 id="2-softmax-不会减少维度也不会替训练取-argmax">2. Softmax 不会减少维度，也不会替训练取 argmax</h3>
<p>经过 <code>log_softmax</code> 后，形状仍然是 <code>(N, V)</code>。它只是把每个位置上的一组 logits 转换成概率分布。</p>
<p>训练时不会取“概率最大的 token”，而是使用 target 中已知的正确 token ID，取出它对应的对数概率：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">log_probs</span> <span class="o">=</span> <span class="n">F</span><span class="o">.</span><span class="n">log_softmax</span><span class="p">(</span><span class="n">logits</span><span class="p">,</span> <span class="n">dim</span><span class="o">=-</span><span class="mi">1</span><span class="p">)</span>  <span class="c1"># (N, V)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">loss_per_token</span> <span class="o">=</span> <span class="o">-</span><span class="n">log_probs</span><span class="p">[</span>
</span></span><span class="line"><span class="cl">    <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="n">N</span><span class="p">),</span>
</span></span><span class="line"><span class="cl">    <span class="n">targets</span><span class="p">,</span>
</span></span><span class="line"><span class="cl"><span class="p">]</span>  <span class="c1"># (N,)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">loss</span> <span class="o">=</span> <span class="n">loss_per_token</span><span class="o">.</span><span class="n">mean</span><span class="p">()</span>  <span class="c1"># 标量</span>
</span></span></code></pre></div><p>所以交叉熵不是 <code>(N, V)</code> 与 <code>(N,)</code> 的直接逐元素比较，而是“根据正确类别下标取概率，再计算负对数”。</p>
<p>取概率最大的 token 属于生成/预测阶段的 argmax，不是交叉熵训练。</p>
<h3 id="3-为什么-flatten-后就能计算-loss">3. 为什么 flatten 后就能计算 loss？</h3>
<p>语言模型输出是 <code>(B, T, V)</code>，target 是 <code>(B, T)</code>：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">logits</span><span class="o">.</span><span class="n">flatten</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>  <span class="c1"># 合并 B 和 T，保留 V，得到 (B*T, V)</span>
</span></span><span class="line"><span class="cl"><span class="n">targets</span><span class="o">.</span><span class="n">flatten</span><span class="p">()</span>     <span class="c1"># 展开所有维度，得到 (B*T,)</span>
</span></span></code></pre></div><p><code>flatten(0, 1)</code> 中的 0 和 1 是维度编号，不是取第 0 个和第 1 个元素。</p>
<p>logits 不能直接使用 <code>flatten()</code>，否则会把词表维度也展开，破坏每个位置的类别分布。</p>
<h3 id="4--lnp-到底在计算什么">4. -ln(p) 到底在计算什么？</h3>
<p>当正确 token 经过 Softmax 后的概率为 <code>p</code>，它的交叉熵损失是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">loss = -ln(p)
</span></span></code></pre></div><p>这不是 <code>100 - 百分比概率</code>，而是正确 token 概率的负自然对数：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">p = 0.40 → loss = -ln(0.40) ≈ 0.9163
</span></span><span class="line"><span class="cl">p = 0.99 → loss = -ln(0.99) ≈ 0.01005
</span></span><span class="line"><span class="cl">p = 1.00 → loss = 0
</span></span></code></pre></div><p>正确 token 的概率越高，loss 越小；概率越接近 0，loss 越大。</p>
<p>这里的“值越大 loss 越小”，指的是<strong>正确 token 的概率 p 越大</strong>，不是任意错误 token 的 logit 越大。</p>
<h3 id="5-lnp-的数学含义">5. ln(p) 的数学含义</h3>
<p><code>ln(p)</code> 是以自然常数 <code>e</code> 为底的对数：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">ln(p) = logₑ(p)
</span></span><span class="line"><span class="cl">e ≈ 2.71828
</span></span></code></pre></div><p>它可以理解为指数函数的反函数：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">y = ln(p)  ⇔  eʸ = p
</span></span></code></pre></div><p>也就是：e 的多少次方等于 p，这个次数就是 ln(p)。</p>
<p>例如：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">ln(1) = 0，因为 e⁰ = 1
</span></span><span class="line"><span class="cl">ln(e) = 1，因为 e¹ = e
</span></span><span class="line"><span class="cl">ln(0.5) ≈ -0.6931
</span></span></code></pre></div><p><code>ln</code> 是自然对数，不是 <code>log10</code>，并且要求 <code>p &gt; 0</code>，所以 <code>ln(0)</code> 没有定义。</p>
<p>当 <code>0 &lt; p &lt; 1</code> 时，<code>ln(p)</code> 是负数；交叉熵前面的负号再把它变成非负的损失值。</p>
<h3 id="6-与-bpb-的连接">6. 与 BPB 的连接</h3>
<p>PyTorch 交叉熵默认使用自然对数，单位是 nats。之前计算 BPB 时除以 <code>ln(2)</code>，就是把 nats 转成 bits，再按实际评估文本的 UTF-8 bytes 归一化。</p>
<p>因此，从模型输入到评估指标可以这样串起来：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">token IDs
</span></span><span class="line"><span class="cl">→ 模型输出 logits
</span></span><span class="line"><span class="cl">→ log_softmax
</span></span><span class="line"><span class="cl">→ 取正确 token 的对数概率
</span></span><span class="line"><span class="cl">→ -ln(p) 得到交叉熵 loss
</span></span><span class="line"><span class="cl">→ nats 转 bits
</span></span><span class="line"><span class="cl">→ 按原始文本 bytes 归一化得到 BPB
</span></span></code></pre></div><p>这次回炉让我再次意识到：能写出 <code>F.cross_entropy()</code> 不等于已经讲清它。高数和数学直觉丢了很久也不需要逃避，但暂时不需要另开一门庞大的数学主线；先把当前公式与代码、数值例子和实际指标对应起来，就是有效的补充。</p>
<h3 id="7-后续数学回炉online-softmax">7. 后续数学回炉：Online Softmax</h3>
<p>阅读 FlashAttention 时遇到了 Online Softmax。当前只保留一个核心印象：<strong>它可以把 Softmax 的计算拆成多个块，渐进式处理输入，而不需要一次性生成并保存完整的注意力概率矩阵。</strong></p>
<p>为了避免和 memmap 混淆，这里不写成“渐进式加载”，而写成“<strong>分块渐进计算</strong>”。</p>
<p>当前理解是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">分块读取并计算当前分数
</span></span><span class="line"><span class="cl">→ 用 m、l、acc 保存累计状态
</span></span><span class="line"><span class="cl">→ 如果出现新的最大值，用缩放系数修正旧的累计状态
</span></span><span class="line"><span class="cl">→ 所有块处理完后，再统一完成归一化
</span></span></code></pre></div><p>其中：</p>
<ul>
<li><code>m</code>：目前见过的最大值；</li>
<li><code>l</code>：当前累计分母；</li>
<li><code>acc</code>：当前累计分子，在注意力中还包括对 V 的加权结果；</li>
<li>新最大值出现时，旧累计状态使用 <code>exp(旧 m - 新 m)</code> 进行修正。</li>
</ul>
<p>它不是每来一个新块，就把前面所有元素的概率重新计算一遍；也不是在中途反复生成最终概率，而是先累计，最后统一归一化。</p>
<p><code>acc</code> 和 <code>l</code> 也不是用来保存“每个元素各自的概率”。如果确实需要某个元素的最终概率，仍然要用它的分数、最终最大值和最终分母计算；FlashAttention 的价值恰恰在于不需要显式生成并保存完整的 <code>T × T</code> 概率矩阵。</p>
<p><strong>当前掌握边界</strong>：对 Online Softmax 有大致直觉，但数学推导和代码细节仍然比较晕。后续统一安排数学回炉，再把最大值修正、累计分子分母和注意力输出推导清楚。当前不因此阻塞 I2，也不要求今天把公式背下来。</p>
<h2 id="十四今日实验结果汇总">十四、今日实验结果汇总</h2>
<p>以下结果都来自当前 Mac/MPS、同一小型 model_v3 配置：<code>batch_size=2</code>、<code>context_length=128</code>、2 步 warmup、10 步正式测量，共 2560 个正式测量 tokens。模型初始化、数据顺序和训练步数保持固定，性能测量在计时边界调用设备 <code>synchronize()</code>。</p>
<p>每种配置至少重复 3 次，使用 tokens/s 中位数判断主要趋势，不只挑最快的一次。原始逐次报告保存在 <code>data/reports/i2-*.json</code>，下表是汇总，不覆盖原始记录。</p>
<h3 id="1-fp32--bf16--fp16-混合精度对照">1. FP32 / BF16 / FP16 混合精度对照</h3>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>精度</th>
        <th style="text-align: right">第 1 次 tokens/s</th>
        <th style="text-align: right">第 2 次 tokens/s</th>
        <th style="text-align: right">第 3 次 tokens/s</th>
        <th style="text-align: right">中位数</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>FP32</td>
        <td style="text-align: right">11001.65</td>
        <td style="text-align: right">10980.90</td>
        <td style="text-align: right">11187.75</td>
        <td style="text-align: right"><strong>11001.65</strong></td>
      </tr>
      <tr>
        <td>BF16</td>
        <td style="text-align: right">9729.78</td>
        <td style="text-align: right">9951.59</td>
        <td style="text-align: right">9942.47</td>
        <td style="text-align: right"><strong>9942.47</strong></td>
      </tr>
      <tr>
        <td>FP16</td>
        <td style="text-align: right">9789.83</td>
        <td style="text-align: right">9903.21</td>
        <td style="text-align: right">9892.09</td>
        <td style="text-align: right"><strong>9892.09</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<p>当前结果：</p>
<ul>
<li>FP32 在这组对照中稳定最快；</li>
<li>BF16 与 FP16 中位数只差约 0.5%，三次区间存在重叠，不能说 FP16 明显强于 BF16，更合理的是两者基本同档；</li>
<li>当前 Mac/MPS、小模型和短序列训练下，混合精度没有体现吞吐收益；</li>
<li>三组 loss 均没有 NaN/Inf，但短训练 loss 波动不被解释为模型质量变化。</li>
</ul>
<p>这次重复测量也纠正了单次实验的直觉：第一次看到 FP16 高于 BF16，不代表差异稳定；需要重复测量才能判断。</p>
<h3 id="2-eager-与-sdpa-对照">2. eager 与 SDPA 对照</h3>
<p>首先通过 <code>tests/test_sdpa_attention.py</code>，在同权重、同输入的小模型 CPU 测试中，eager 与 SDPA 的完整 prefill 和逐 token decode 数值对照通过：<code>1 passed</code>。</p>
<p>训练吞吐结果：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>配置</th>
        <th style="text-align: right">第 1 次 tokens/s</th>
        <th style="text-align: right">第 2 次 tokens/s</th>
        <th style="text-align: right">第 3 次 tokens/s</th>
        <th style="text-align: right">中位数</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>eager + FP32</td>
        <td style="text-align: right">11001.65</td>
        <td style="text-align: right">10980.90</td>
        <td style="text-align: right">11187.75</td>
        <td style="text-align: right"><strong>11001.65</strong></td>
      </tr>
      <tr>
        <td>SDPA + FP32</td>
        <td style="text-align: right">10943.51</td>
        <td style="text-align: right">10613.57</td>
        <td style="text-align: right">9803.70</td>
        <td style="text-align: right"><strong>10613.57</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<p>SDPA 中位数比 eager 低约 <strong>3.53%</strong>，当前小模型/MPS 场景没有体现吞吐收益。这个结果不推广到 CUDA、大模型或长上下文，也不证明 FlashAttention 已被使用。</p>
<h3 id="3-torchcompile-对照">3. torch.compile 对照</h3>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>配置</th>
        <th style="text-align: right">第 1 次 tokens/s</th>
        <th style="text-align: right">第 2 次 tokens/s</th>
        <th style="text-align: right">第 3 次 tokens/s</th>
        <th style="text-align: right">中位数</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>eager + FP32</td>
        <td style="text-align: right">11001.65</td>
        <td style="text-align: right">10980.90</td>
        <td style="text-align: right">11187.75</td>
        <td style="text-align: right"><strong>11001.65</strong></td>
      </tr>
      <tr>
        <td>compile + FP32</td>
        <td style="text-align: right">11564.11</td>
        <td style="text-align: right">11801.10</td>
        <td style="text-align: right">12208.14</td>
        <td style="text-align: right"><strong>11801.10</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<p>compile 中位数相对 eager 基线约提升 <strong>7.27%</strong>，是当前第一个看到明确正向收益的训练优化项。</p>
<p>但需要保留：</p>
<ul>
<li>三次结果从 11564 逐步升到 12208，波动比基线大，后续可以用更长测量继续验证；</li>
<li>warmup 排除了首次编译成本，因此这是稳态吞吐，不包含启动时间；</li>
<li><code>Not enough SMs to use max_autotune_gemm mode</code> 是当前没有足够 CUDA SM 使用对应 GEMM 自动调优的提示，不是编译失败，也不代表 MPS 获得了 CUDA 的全部优化。</li>
</ul>
<h3 id="4-activation-checkpointing-对照">4. Activation Checkpointing 对照</h3>
<p><code>tests/test_activation_checkpointing.py</code> 已通过：在同权重、同输入的小模型训练中，开启与关闭 checkpointing 的前向 logits、loss 和反向梯度一致，<code>1 passed</code>。</p>
<p>内存与吞吐对照使用<strong>单独一批带内存快照的 FP32 基线</strong>，不与其他实验批次的 FP32 数字混用：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>指标</th>
        <th style="text-align: right">不使用 checkpointing</th>
        <th style="text-align: right">使用 checkpointing</th>
        <th style="text-align: right">变化</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>训练吞吐中位数</td>
        <td style="text-align: right">11321.03 tokens/s</td>
        <td style="text-align: right">10714.24 tokens/s</td>
        <td style="text-align: right"><strong>下降约 5.36%</strong></td>
      </tr>
      <tr>
        <td>当前分配内存</td>
        <td style="text-align: right">320,780,800 bytes</td>
        <td style="text-align: right">320,780,800 bytes</td>
        <td style="text-align: right">不变</td>
      </tr>
      <tr>
        <td>驱动分配内存中位数</td>
        <td style="text-align: right">1,423,097,856 bytes</td>
        <td style="text-align: right">1,414,709,248 bytes</td>
        <td style="text-align: right"><strong>减少 8 MiB</strong></td>
      </tr>
    </tbody>
  </table>
</div>
<p>这体现了“用额外计算换显存”的代价与收益：吞吐下降，驱动分配内存小幅减少，模型权重和当前分配内存不会因此消失。</p>
<p>当前 MPS 只提供 <code>current_allocated_memory()</code> 与 <code>driver_allocated_memory()</code>，没有使用峰值显存接口，因此不写成“峰值显存降低 8 MiB”。</p>
<p>边界仍是当前 Mac/MPS、2 层小模型、batch=2、context=128；不能推广为所有模型都固定节省 8 MiB 或固定慢 5.36%。</p>
<h3 id="5-实验结论边界">5. 实验结论边界</h3>
<p>今天的对照说明：</p>
<ul>
<li>AMP、SDPA、compile 和 Activation Checkpointing 不是同一种“加速开关”；</li>
<li>它们分别改变计算精度、注意力实现、执行图优化和激活保存策略；</li>
<li>性能收益必须与正确性、内存和额外代价一起评估；</li>
<li>当前结果只适用于已经列明的硬件、模型和测量配置。</li>
</ul>
<p>最终相关回归已于 2026-11-10 执行：<strong>16 passed in 33.02s</strong>。覆盖 Qwen 专项、SDPA 对照、Activation Checkpointing 的 logits/梯度对照、Markdown 清洗、token store 与 memmap Dataset，不调用外部评估 API。它证明当前改动通过了已有相关回归，但不等于所有性能验收项都已完成。</p>
<p>Windows + RTX 4070 Ti 的 CUDA 番外仍是后续计划，尚未产生实测结果。</p>
<p>经确认，I2 主线于 2026-11-10 按当前 Mac/MPS 实验范围收官；MFU、峰值显存与经典 GPT-2 / model_v3 训练吞吐对照移至 Windows + RTX 4070 Ti 番外，不把未测指标写成已完成。</p>
]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 11：PyTorch 与资源核算</title>
      <link>https://blog.lvxinrong.com/llm/llm-11-pytorch-resource-accounting/</link>
      <pubDate>Wed, 28 Oct 2026 12:00:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-11-pytorch-resource-accounting/</guid>
      <description>训练成本不是黑盒：参数量、显存、FLOPs、时间的估算闭环；混合精度、算术强度、梯度累积与开工踩坑。</description>
      <content:encoded><![CDATA[<p>训练大语言模型时，资源消耗可以直接转换成时间和成本的 所以需要资源核算</p>
<p>FLOPs(Floating Point Operations, 浮点运算次数) 衡量计算复杂度的一个指标，表示一个算法或者模型在执行过程中所需的浮点运算的总次数</p>
<p>经验公式:</p>
<blockquote>
<p>总计算量 ≈  6 ✖️ 参数量 ✖️ Token数量</p>
</blockquote>
<p>6:  fowrad 计算一次约为 2 ✖️ 参数量，backward 约等于前向的2倍，也就是 4 ✖️参数量</p>
<p>时间计算公式:</p>
<blockquote>
<p>时间 = 总工作量 / 总算力</p>
</blockquote>
<p>硬件算力可以查，H100 峰值算力约 1979TFLOPS （FP16/BP16数据类型，且启用结构化稀疏）
训练普通的稠密模型 理论峰值减半 约990 TFLOPs</p>
<p>结构化稀疏: 一种模型压缩的方法，通常是对稠密模型按照50%的稀疏度进行剪纸
<img alt="结构化稀疏：对稠密模型按 50% 稀疏度剪枝" loading="lazy" src="https://blog.lvxinrong.com/llm/llm-11-structured-sparsity.png"></p>
<p>软硬件开销系数 (通常按照 30% ~ 60% 利用率估算更现实)</p>
<p>所以  <strong>在 1024 张 H100 显卡上，训练一个 70B（700亿参数）的模型，数据量是 15T（15万亿 tokens），大概要多久？</strong></p>
$$
\text{时间} = \frac{\text{总工作量}}{\text{总算力}} = \frac{6.3 \times 10^{24}}{5 \times 10^{17}} \approx 1.26 \times 10^7 \text{ 秒} \approx \mathbf{146} \text{ 天}
$$<p><strong>FP16</strong> 和 <strong>BF16</strong> 都是计算机中用于表示小数的<strong>浮点数数据类型</strong>，它们在<strong>深度学习</strong>（AI 模型训练和推理）中被广泛使用。它们的主要目的是<strong>减少内存占用</strong>并<strong>加速计算</strong>（因为占用空间比传统的 FP32 少一半）
FP16 (Half Precision / 半精度浮点数) 精度高 但表示范围小
BF16 (Bfloat16 / 脑浮点数) 精度低 但表示范围极大</p>
<blockquote>
<p>Percy 在课上解释说：“bf16 牺牲了精度来换取范围。对于深度学习来说，范围比精度重要得多，因为数值稳定性的主要威胁是溢出/下溢，而不是尾数精度不够。”</p>
</blockquote>
<p>内存估算
需要同时考虑 参数，梯度，优化器状态(不同优化器 参数量不同)</p>
<h1 id="张量-pytorchtensor">张量 pytorch.tensor</h1>
<p><code>jaxtyping</code> 提供的维度命名（如 “batch seq hidden”）在当前 PyTorch 生态中主要是“文档性质”的，不会在运行时自动强制检查维度是否真的匹配名称，但它能极大地提升代码的清晰度和可靠性。</p>
<pre tabindex="0"><code># 传统方式（容易写错维度顺序）
x = torch.ones(2, 2, 1, 3)  # batch seq heads hidden

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

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

# 2. （后续步骤）将状态加载回模型和优化器
model.load_state_dict(loaded_checkpoint[&#34;model&#34;])
optimizer.load_state_dict(loaded_checkpoint[&#34;optimizer&#34;])
</code></pre><h3 id="混合精度训练-mixed-precision">混合精度训练 (Mixed Precision)</h3>
<p>将低精度(BF16/ FP 16) 用于消耗大但对精度要求不高的部分(激活值)。将高精度用于 对精度敏感的部分(参数和梯度)</p>
<p>PyTorch 的 AMP 库 (Automatic Mixed Precision)：PyTorch 提供了自动混合精度（AMP）库，会自动将安全的操作（如矩阵乘法）转为 bf16，将危险操作（如 exp、softmax）保留为 fp32：</p>
<pre tabindex="0"><code>with torch.amp.autocast(&#34;cuda&#34;, dtype=torch.bfloat16):
    x = torch.zeros(4, 8)  # 自动以 bf16 创建
</code></pre><p>数据搬运也是需要时间，所以总时间取决于 加速器速度FLOP/s 和 内存带宽Bytes/s</p>
<h3 id="算术强度">算术强度</h3>
<p>为了避免每次都要计算两个时间再比较，引入<strong>算术强度（Arithmetic Intensity）</strong>：</p>
<blockquote>
<p>加速器强度 = FLOP/s / Bytes/s   H100 约295FLOP/bytes
算数强度 = FLOPs / Bytes  该操作每搬运1字节能做多少FLOP</p>
</blockquote>
<p>算数强度 &lt; 加速器强度  Memory-bound 瓶颈在数据传输
算数强度 &gt; 加速器强度  Compute-bound 瓶颈在计算</p>
<p>python中 列表的append()和extend 都是原地修改列表。
<code>append(x)</code>：把 <code>x</code> 当作<strong>一个整体元素</strong>加到末尾</p>
<pre tabindex="0"><code>a = [1, 2]
a.append([3, 4])
print(a)  # [1, 2, [3, 4]]
</code></pre><p><code>extend(iterable)</code>：把可迭代对象里的元素<strong>逐个拆开</strong>加到末尾</p>
<pre tabindex="0"><code>a = [1, 2]
a.extend([3, 4])
print(a)  # [1, 2, 3, 4]
</code></pre><p><code>extend</code> 接收的是可迭代对象，比如列表、元组、字符串、集合等</p>
<h2 id="今天的坑m2-开工实录">今天的坑（M2 开工实录）</h2>
<h3 id="梯度累积三次-backward-一次-step">梯度累积：三次 backward 一次 step</h3>
<p>一开始写成了“把所有 loss 攒进 list，最后一次 backward”——这样所有计算图都攒在手里，显存越攒越大，完全背离了梯度累积的初衷。正确姿势是<strong>每个小批立刻 backward（释放计算图），梯度累加在 .grad 里，攒够 N 批再 optimizer.step()</strong>。
归一化也有两种等价写法：<code>sum(loss_i)/N</code> 和每个 <code>loss_i/N</code> 再 backward，因为梯度是线性的，结果一样，但后者省显存。
触发条件用 <code>(i+1) % accum_step == 0</code> 一个表达式通吃，不用给 accum_step=1 单写分支。</p>
<h3 id="zero_grad-的位置决定成败">zero_grad 的位置决定成败</h3>
<p>原来的老代码在循环顶部 zero_grad()，改成累积模式后如果还留着，<strong>前几批攒下的梯度还没 step 就被清掉了</strong>，累积直接白干。口诀：<strong>梯度只在“用掉之后”清零（step 之后），不能在“攒的过程中”清零。</strong></p>
<h3 id="gitignore-的目录匹配会误伤">.gitignore 的目录匹配会误伤</h3>
<p>写 <code>data/</code> 会匹配<strong>所有层级</strong>的 data 目录，把 <code>src/squid/data/</code> 代码包也忽略了（新文件变灰、git status 看不到）。要只排除根目录的语料目录，必须写 <code>/data/</code>（前导斜杠锚定根目录）。</p>
<h3 id="total_loss-是-list-不是张量">total_loss 是 list 不是张量</h3>
<p><code>total_loss / accum_step</code> 会炸，因为 list 不能除以整数；而且把 loss 存进 list 不 backward，等于把计算图全留着。loss 是张量，应该当批归一化后立刻 backward，不是攒起来。</p>
<h2 id="bpb-的含义与下降意味着什么">BPB 的含义与“下降意味着什么”</h2>
<p><strong>BPB（Bits Per Byte）的本质是衡量语言模型把文本压缩了多少：给这段文本编码，平均每个字节要花多少比特。数值越低，说明模型对文本的预测能力越强，压缩效率越高。</strong></p>
<p>两个参照点帮助记忆：</p>
<ul>
<li>BPB 接近 0：模型几乎能完美预测文本，每个字节只需极少比特</li>
<li>BPB = 8：完全不会预测，每个字节都得老老实实存 8 bit，等于没有压缩</li>
</ul>
<p>所以 <strong>BPB 下降 = 模型用更少的比特就能编码同样的文本 = 模型在变好</strong>。它和 val_loss 下降的区别是：val_loss 是“每个 token 的预测难度”，BPB 把它折算成了“每个字节的成本”——这样不同词表、不同模型之间才能公平比较。</p>
<h2 id="容量与深度扫描数据决定上限">容量与深度扫描：数据决定上限</h2>
<p>M2 最小闭环之后，用同一批语料、同一训练量做了容量与深度对照，结论比配置本身值钱。</p>
<h3 id="emb_dim-扫描20-epoch其他锁死">emb_dim 扫描（20 epoch，其他锁死）</h3>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>emb_dim</th>
        <th>最终 val_loss</th>
        <th>BPB</th>
        <th>结论</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>64</td>
        <td>7.02</td>
        <td>3.63</td>
        <td>容量不足</td>
      </tr>
      <tr>
        <td>128</td>
        <td>6.59</td>
        <td>3.42</td>
        <td>仍在受益</td>
      </tr>
      <tr>
        <td><strong>256</strong></td>
        <td><strong>5.99</strong></td>
        <td><strong>3.10</strong></td>
        <td><strong>甜点</strong></td>
      </tr>
      <tr>
        <td>512</td>
        <td>6.26（过拟合）</td>
        <td>3.24</td>
        <td>开始背语料</td>
      </tr>
    </tbody>
  </table>
</div>
<p>512 出现了教科书式的过拟合：<strong>train_loss 一路降到 1.8，val_loss 却从 5.85 回升到 6.29</strong>——模型在背训练集，不是在学规律。所以容量甜点在 256 附近：64 欠拟合、512 过拟合。</p>
<p>验证代码:</p>
<pre tabindex="0"><code>&#34;&#34;&#34;M2 收官：真实语料 + 自训 BPE 的完整预训练。  
  
链路：pack_tokens 打包 → create_stream_loader → 小 GPT 预训练  
      → bpb 曲线 → generate_text 咿呀学语 → save_checkpoint 带 config。  
&#34;&#34;&#34;  
import math  
from pathlib import Path  
  
import torch  
  
from squid.data.token_stream import pack_tokens, create_stream_loader  
from squid.device import get_device  
from squid.generate.text import generate_text  
from squid.model.gpt import GPTModel  
from squid.train.common import calc_loss_loader  
from squid.train.pretrain import pretrain_model  
from squid.tokenizer.my_bpe_tokenizer import MyBPETokenizer  
from squid.checkpoints.store import save_checkpoint  
  
ROOT = Path(__file__).resolve().parents[1]  
DATA = ROOT / &#34;data&#34; / &#34;blog&#34;  
  
  
def test_m2_pretrain():  
    device = get_device()  
    tokenizer = MyBPETokenizer.from_directory(DATA / &#34;m2000&#34;)  
  
    # 1. token 流打包：训练语料与 held-out 分别打包  
    train_text = (DATA / &#34;train.txt&#34;).read_text(encoding=&#34;utf-8&#34;)  
    val_text = &#34;\n&#34;.join(p.read_text(encoding=&#34;utf-8&#34;) for p in DATA.glob(&#34;heldout-*.txt&#34;))  
  
    train_ids = pack_tokens([train_text], tokenizer, tokenizer.eos_id)  
    val_ids = pack_tokens([val_text], tokenizer, tokenizer.eos_id)  
  
    context = 128  
    train_loader = create_stream_loader(train_ids, context, batch_size=8, shuffle=True)  
    val_loader = create_stream_loader(val_ids, context, batch_size=8,  
                                      shuffle=False, drop_last=False)  
  
    # 2. 小模型：emb_dim 64、2 层、context 128  
    cfg = {  
        &#34;vocab_size&#34;: len(tokenizer.vocab),  
        &#34;context_length&#34;: context,  
        &#34;emb_dim&#34;: 256,  
        &#34;n_heads&#34;: 2,  
        &#34;n_layers&#34;: 4,  
        &#34;drop_rate&#34;: 0.0,  
        &#34;qkv_bias&#34;: False,  
    }  
    model = GPTModel(cfg).to(device)  
    optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4)  
  
    # 3. 预训练：accum_step=4，bpb 用 held-out 的 bytes/token 折算  
    density = len(val_text.encode(&#34;utf-8&#34;)) / len(tokenizer.encode(val_text))  
    train_losses, val_losses, tokens_seen = pretrain_model(  
        model, train_loader, val_loader, optimizer, device,  
        num_epochs=20, eval_freq=50, eval_iter=5,  
        accum_step=4, bpb_density=density,  
    )  
    assert val_losses[-1] &lt; val_losses[0], &#34;val loss 应该下降&#34;  
  
    # 4. 咿呀学语：给模型一个开头，看它续什么  
    sample = generate_text(model, tokenizer, &#34;大模型&#34;,  
                           max_new_tokens=40, context_size=context,  
                           temperature=0.8, top_k=20, eos_id=tokenizer.eos_id)  
    print(&#34;\n=== 生成样例 ===\n&#34;, sample)  
  
    # 5. 存档：权重 + config + 元信息，完整还原训练现场  
    final_val = calc_loss_loader(val_loader, model, device)  
    save_checkpoint(ROOT / &#34;regression&#34; / &#34;m2-pretrain.pth&#34;,  
                    model, cfg, val_loss=final_val, merges=2000, tokens_seen=tokens_seen[-1])  
    print(f&#34;\n最终 val_loss={final_val:.3f}，checkpoint 已保存&#34;)
</code></pre><h3 id="n_layers-对照emb_dim256">n_layers 对照（emb_dim=256）</h3>
<p>4 层和 2 层基本持平（val_loss 6.03 vs 5.99），深度没有收益，后段 val 还开始上翘。最优配置停在 <strong>emb_dim=256、n_layers=2</strong>。</p>
<p>一句话总结：<strong>小数据面前，模型不是越大越好，是“配得上”才好。</strong> 压缩率有甜点、BPB 有甜点、模型容量也有甜点——全是测出来的，不是猜的。</p>
<h2 id="两个收尾的-bug">两个收尾的 bug</h2>
<p><strong>accum_step 大于每轮批次数</strong>：每 epoch 只有 4 个 batch，accum_step=5 时 <code>(i+1) % 5 == 0</code> 永远不成立，optimizer.step() 一次都不执行，模型完全不学。改成跨 epoch 的 global_step 连续计数才解决。以后看到 loss 完全不动，先查 step 到底执行了没有。</p>
<p><strong>decode 的 UnicodeDecodeError</strong>：字节级 BPE 的 token 可能只是半个汉字，模型自由生成的序列不一定是合法 UTF-8，直接 decode 会炸。改成 <code>decode(&quot;utf-8&quot;, errors=&quot;replace&quot;)</code>，非法片段显示为替换符即可——tiktoken 默认就是这么干的。</p>
]]></content:encoded>
    </item>
  </channel>
</rss>
