<?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>Attention on 吕炘嵘的博客</title>
    <link>https://blog.lvxinrong.com/tags/attention/</link>
    <description>Recent content in Attention on 吕炘嵘的博客</description>
    <image>
      <title>吕炘嵘的博客</title>
      <url>https://blog.lvxinrong.com/og-default.jpg</url>
      
      <link>https://blog.lvxinrong.com/tags/attention/</link>
    </image>
    <generator>Hugo</generator>
    <language>zh-CN</language>
    <lastBuildDate>Fri, 09 Oct 2026 09:30:00 +0800</lastBuildDate>
    <atom:link href="https://blog.lvxinrong.com/tags/attention/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>手搓 LLM 笔记 03：因果掩码与多头注意力</title>
      <link>https://blog.lvxinrong.com/llm/llm-03-mask-multihead/</link>
      <pubDate>Fri, 09 Oct 2026 09:30:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-03-mask-multihead/</guid>
      <description>第三章收官：掩码防的是答案泄露，多头是加视角不是加角色。说实话，这一章我自认没完全过关，这篇是如实的认知水位记录。</description>
      <content:encoded><![CDATA[<blockquote>
<p>系列规则不变：写下来的必须是自己搞懂的。但这一篇要破例一次——第三章（因果掩码 + 多头注意力）我自认只懂了八成，所以这篇除了笔记，也如实记录我“还没通”的地方。它是我回炉时的地图。</p>
</blockquote>
<h2 id="一因果掩码防的不是过拟合是答案泄露">一、因果掩码：防的不是过拟合，是答案泄露</h2>
<p>训练时，模型是一次性看到整句话的。如果不加掩码，预测下一个 token 时，答案就躺在输入里——模型只要学会“看下一个位置”照抄，loss 瞬间归零，<strong>什么都没学到</strong>。</p>
<p>我一开始把这理解成“过拟合”，Kimi 纠正了我：这比过拟合直接得多——<strong>是考试作弊</strong>。题目和答案同时发下来，考满分也没有意义。因果掩码保的不是防过拟合，是<strong>保证“预测下一个 token”这个任务本身有意义</strong>。</p>
<p>推理时不需要掩码：自回归生成时未来还没生成，天然看不到。所以掩码纯粹是为训练准备的——<strong>让训练时的看题条件和推理时保持一致</strong>。</p>
<p>判任何掩码方案，我后来只留了一条尺子：<strong>位置 i 的答案，不能出现在它能看到的地方</strong>。目标和掩码配不配，一句话定生死。</p>
<h2 id="二实现负无穷不是-0">二、实现：负无穷，不是 0</h2>
<p>书里其实演进过两版，而且用的是两张互补的表：</p>
<ul>
<li><strong>下三角（<code>tril</code>，含对角线）是白名单</strong>——保留谁。第一版就是乘上它，再除以行和重新归一化；</li>
<li><strong>上三角（<code>triu(diagonal=1)</code>）是黑名单</strong>——抓谁。第二版把要遮的位置在 softmax 之前塞成负无穷。</li>
</ul>
<p>两张表加起来是全 1 矩阵，同一个约束的两种说法。“床前明月光”五步展开：床 / 床前 / 床前明 / 床前明月 / 床前明月光。</p>
<p>我踩过的坑：<strong>掩码位置为什么不能填 0？</strong> 因为 softmax 里 e⁰ = 1——填 0 的话，这些被掩盖的位置照样参与归一化，稀释别人的概率。所以填<strong>负无穷</strong>：e^-∞ = 0，从归一化里彻底除名，反向传播时梯度也恰好为 0，从计算图里干净地消失。</p>
<p>而且填 0 的坏处不止“稀释”。如果这一行的合法分数本来是负的，比如 <code>[-2, -5, 遮]</code>，填 0 之后 <code>e⁰ = 1</code> 反而是<strong>最大的那一项</strong>——被遮住的位置一口气拿走 <strong>87.6%</strong> 的权重，彻底反客为主。</p>
<p>所以“精确的 0 权重”只有一条路：在 softmax 之前塞负无穷。因为 softmax 对任何<strong>有限</strong>输入，输出都严格大于 0。</p>
<p>至于为什么必须遮在 softmax <strong>之前</strong>：在之后清零会让那一行的和小于 1，<code>context</code> 变成被缩水的加权和，而且每个位置缩水的比例还不一样。补一次除法确实能救回来——但那个结果和“提前遮”在数学上完全等价，<strong>一步能做完的事没必要分两步</strong>。</p>
<h2 id="三dropout它打破了行和等于-1">三、dropout：它打破了“行和等于 1”</h2>
<p>3.5.2 是给注意力权重加 dropout。<code>nn.Dropout(0.5)</code> 作用在全 1 矩阵上，输出只有 <code>0</code> 和 <code>2.0</code> 两种值——保留的元素被放大了 <code>1/(1-p) = 2</code> 倍。这就是倒置 dropout：它让每个元素的<strong>期望值保持不变</strong>。</p>
<p>但它顺手打破了我刚学会的那条规矩。某一行的注意力权重原本是 6 个 <code>1/6</code>，和恰好为 1；dropout 之后保留 k 个、每个变成 <code>1/3</code>，于是行和 = <code>k/3</code>。而 k 是抛硬币抛出来的（<code>Binomial(6, 0.5)</code>），所以行和可能是 0、0.33、1.33……</p>
<p><strong>结论是：加上 dropout 之后，“注意力是加权平均（行和 = 1）”只在期望意义上成立</strong>，实际采样出来的那一行并不等于 1。只有推理时（<code>model.eval()</code>）它才严格成立。</p>
<p>顺带两个小观察：<code>nn.Dropout</code> 有状态、没参数，<code>eval()</code> 之后是恒等映射——这就是推理前必须切 eval 的原因；而现代大模型（Llama 那一派）干脆把 drop_rate 设成 0，因为<strong>只有当一份数据只需要过一遍时，dropout 才可以扔掉</strong>。</p>
<h2 id="四多头加的是视角不是角色">四、多头：加的是视角，不是角色</h2>
<p>3.6 节我花了一整天。</p>
<p><strong>形状</strong>：d_out = 768、8 个头，每个头处理 768/8 = 96 维。</p>
<p><strong>W_q 是共享还是独立？</strong> 这里有个障眼法：代码里 <code>W_q</code> 表面上是 class 的一个属性、一块平面矩阵，看起来共享——但实际上是<strong>把 8 个 (d_in, 96) 的小矩阵按列打包在一起</strong>。第 0<del>95 列服务头 1，第 96</del>191 列服务头 2……逻辑上独立，物理上合并，为的是让 GPU 一次矩阵乘搞定 8 个头，而不是循环 8 次。</p>
<p>有个约定必须交代清楚，否则这块永远会混：上面说的是<strong>数学写法 (d_in, d_out)</strong>，那时头是<strong>列</strong>块；而 <strong>PyTorch 的 <code>nn.Linear</code> 内部存的是 (d_out, d_in)</strong>，转置过了，所以在代码里看到的是<strong>行</strong>块——同一件事，两套摆法。（笔记 02 里我就记过这个坑，这次又差点栽进去。）</p>
<p>还有一个容易记岔的细节：<strong>权重本身没有“头”这个维度</strong>。头维度是投影之后，把输出 (B, T, 768) reshape 成 (B, T, 8, 96) 再 transpose 出来的——<strong>多头维度是电流流过时折出来的，不是电阻上的刻痕</strong>。</p>
<p>一路推下来我最想记住的一条：<strong>切 token 是事故，切维度是设计</strong>。</p>
<h3 id="形状体操为什么非-transpose-不可">形状体操：为什么非 transpose 不可</h3>
<p><code>queries @ keys.transpose(2, 3)</code> 这一行藏着两个“为什么”：</p>
<ol>
<li><strong><code>@</code> 只对最后两维做矩阵乘，前面所有维度一律当批次。</strong> 所以要让 8 个头各算各的 (T, T)，就必须先把“头”从最后一维挪到位置维前面——<code>transpose(1, 2)</code> 存在的唯一理由就是这个；</li>
<li><code>keys.transpose(2, 3)</code> 是“最后两维互换”，把 (T, 96) 翻成 (96, T)，点积的内维才对得上。</li>
</ol>
<p>顺手记两个坑，都是一眼看不出来的：</p>
<ul>
<li><strong><code>dim=-1</code> 和 <code>dim=1</code> 在 4 维张量上不是一回事。</strong> <code>attn_scores</code> 是 <code>(b, H, T, T)</code>，<code>dim=-1</code> 是 key 轴（对）；写成 <code>dim=1</code> 就是<strong>头轴</strong>，会沿 8 个头做归一化——不报错，但结果毫无意义；</li>
<li><strong><code>context_vec.contiguous().view(...)</code> 里的 <code>contiguous()</code> 不能省。</strong> <code>transpose</code> 只改 stride、不搬内存，所以它之后 <code>view</code> 会直接拒绝工作（<code>view</code> 只肯在内存连续时零拷贝）；<code>contiguous()</code> 才真正按逻辑顺序重排一份。</li>
</ul>
<p>另外，构造函数里那句 <code>assert d_out % num_heads == 0</code> 不是装饰：<code>head_dim = d_out // num_heads</code> 用的是整除，除数不整除时会<strong>静默丢掉余数</strong>，然后在很远的地方以形状错误的形式炸掉。<code>assert</code> 的作用是把这个错误提到门口。</p>
<h2 id="五合并拼接是摆回去w_o-才是搅在一起">五、合并：拼接是摆回去，W_o 才是搅在一起</h2>
<p>每个头算完自己的注意力，得到 (T, 96)。然后两步：</p>
<ol>
<li><strong>concat</strong>：8 段 96 维首尾相接，摆回 (T, 768)——纯机械的形状操作，<strong>摆在一起，但互没说话</strong>；</li>
<li><strong>输出投影 W_o (768, 768)</strong>：做一次矩阵乘。<code>C[i][j] = Σ_k A[i][k] · B[k][j]</code>——输出的每一维都是全部 768 维的加权和。<strong>头 1 的结果和头 8 的结果，在这一步才真正乘进同一个维度里。</strong></li>
</ol>
<p>所以：拼接负责“摆回去”，W_o 负责“搅在一起”。头与头的信息交互，发生在 W_o，不在 concat。</p>
<p>但有个边界要说准：<strong>W_o 的混合只发生在每个 token 内部，不跨 token。</strong> <code>(T, 768) @ (768, 768)</code> 是每一行各自做一次混合，第 i 行的输出只用到第 i 行的输入。跨 token 的交流发生在注意力那一步（<code>attn_weights @ V</code>），不在 W_o。</p>
<h2 id="六回答我自己留下的问题">六、回答我自己留下的问题</h2>
<p>笔记 02 结尾我留了个问题：<strong>Q、K、V 真的够吗，投影会不会越多越好？</strong></p>
<p>读完多头，答案清楚了：</p>
<ul>
<li><strong>三个角色是最小完备集</strong>——我去找（Q）、我被找（K）、我交货（V），少一个就塌方，多一个没槽位。角色表是满的；</li>
<li><strong>但“更多投影”以另一种方式兑现了</strong>——不是加第四个角色，而是<strong>把每个投影的输出维度切成 h 份</strong>，每个头只拿到 <code>d_out / h</code> 维，各看一个角度。多头就是“更多投影”的正确打开方式：<strong>不加角色，加视角，也不加参数</strong>；</li>
<li>行业后来甚至反向操作：GQA/MQA 让多个头共享 K、V 省显存，DeepSeek 的 MLA 把 K、V 压成低秩矩阵。角色不动摇，头数、共享、压缩随便玩。</li>
</ul>
<h2 id="七如实记录我还没通的地方">七、如实记录：我还没通的地方</h2>
<ol>
<li><strong>(T, d_out) @ (d_out, d_out) 为什么产生头间交互</strong>——这个代数步骤我是让 AI 展开到元素级才看懂的，<strong>不是我手推的</strong>。按我自己的标准，这笔账没还清；</li>
<li><strong>整条前向还不能脱稿</strong>——从 Embedding 到 W_o 的每个 shape，我能看懂，但还不能从空白纸写出来；</li>
<li>所以第三章我会回炉。回炉考卷已经备好：</li>
</ol>
<blockquote>
<p>拿“床前明月光”5 个 token，d_in=4，d_out=4，2 个头（head_dim=2），从空白纸手写一遍完整前向：Embedding → Q/K/V → scores → ÷sqrt → 掩码 → softmax → ⊗V → concat → W_o。每个矩阵的 shape 和每个数的去向都写清。</p>
</blockquote>
<p>写不出就再找断点。写得出，第三章才算真过。</p>
<h2 id="八三问式收尾">八、三问式收尾</h2>
<ol>
<li><strong>今天学了什么</strong>：因果掩码（防答案泄露，不是防过拟合）、负无穷掩码（e⁰=1 的坑）、dropout（会把行和从 1 打散）、多头（打包 W_q、切维度不切 token、concat + W_o）；</li>
<li><strong>哪里还没懂</strong>：头间交互的元素级推导、脱稿手推全链路；</li>
<li><strong>明天干什么</strong>：第四章，GPT 架构整体拼装。看完全景，再回炉第三章——站在架构里回头看注意力，很多“为什么”会自己解开。</li>
</ol>
<hr>
<p><em>学习时长：3.6 节整整一天（除吃饭睡觉）。方法：让 AI 列出计算步骤，我手推每一步的矩阵 shape。亲测有效，推荐给你。</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>手搓 LLM 笔记 02：注意力，让每个 token 看完全场</title>
      <link>https://blog.lvxinrong.com/llm/llm-02-attention/</link>
      <pubDate>Wed, 30 Sep 2026 10:00:00 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-02-attention/</guid>
      <description>从简化版到带可训练权重的自注意力：三步走、三块矩阵、sqrt(d_k)、以及梯度怎么流回去。学了三小时，答了五道题。</description>
      <content:encoded><![CDATA[<blockquote>
<p>这个系列记录我读《从零构建大模型》的过程。规则不变：写下来的必须是我自己搞懂的，没懂的如实写“没懂”。本篇覆盖第三章到 3.4 节（带可训练权重的自注意力机制），学习时长约 3 小时，中间被 Kimi 老师出了五道验收题。</p>
</blockquote>
<h2 id="一注意力到底在干什么">一、注意力到底在干什么</h2>
<p>一句话：<strong>让每个 token 看完全场之后，重写一遍自己。</strong></p>
<p>输入“床前明月光”，“床”这个 token 不应该只携带“床”自己的信息——它应该吸收了“前”“明”“月”“光”之后，变成一个<strong>知道自己在诗里、知道后面大概率接“前”的新“床”</strong>。</p>
<p>这个“吸收”的过程，我自己总结为一个词：<strong>编织</strong>。新向量 = 对所有 token 向量的加权和，权重就是“和我有多大关系”。</p>
<h2 id="二简化版三步走">二、简化版三步走</h2>
<p>不带任何权重矩阵的注意力，就三步：</p>
<ol>
<li><strong>点积</strong>：当前 token 和序列里每个 token（包括自己）算点积，得到一行分数。点积 = |a||b|cosθ——夹角是折扣率，方向一致原价（cos=1），垂直白送也不要，反向负分。但注意点积还混着“嗓门”（向量长度），不是纯夹角；</li>
<li><strong>softmax</strong>：把分数变成权重。<strong>softmax 就是把所有人塞进一个体积为 1 的房间，体积大的人占地盘大</strong>——但它保证权重和为 1，所以第三步是“信息的重新分配”，不是“信息的膨胀”；</li>
<li><strong>编织</strong>：用权重对每个 token 的向量做加权和，得到新向量。向量就是信息的表示，加权和 = 求期望，新向量里装着全场的信息。</li>
</ol>
<h2 id="三为什么要除以-sqrtd_k">三、为什么要除以 sqrt(d_k)</h2>
<p>这是本章的第一个硬骨头，我一开始也没想透。</p>
<p>完整的逻辑链是这样的：</p>
<ul>
<li>点积是 d_k 个乘积的求和，<strong>项数越多，和的波动天然越大</strong>——统计上，点积的方差正比于 d_k，标准差正比于 sqrt(d_k)；</li>
<li>也就是说，<strong>维度越高，分数的绝对值天然越大，softmax 的输入尺度被维度绑架了</strong>；</li>
<li>softmax 这个函数，输入太大就饱和：一个权重趋近 1，其他全部趋近 0。语言里词和词的关系没有那么绝对——<strong>要给概率小的 token 留口气，而不是拍死</strong>；</li>
<li>更致命的是梯度：饱和区里 softmax 的导数趋近 0，反向传播流不过去，模型直接“停止学习”；</li>
<li>所以除以 sqrt(d_k)，把标准差归一化回 1 附近，<strong>softmax 永远在中间敏感区工作，不管维度怎么变</strong>。</li>
</ul>
<p>书里的代码只有一行：<code>attn_scores / keys.shape[-1]**0.5</code>——不硬编码维度，最后一维是几就除几。sqrt(d_k) 的本质是<strong>量纲归一</strong>：不是在调注意力，是在消除维度对分数尺度的污染。</p>
<h2 id="四三块矩阵qkv-到底多给了什么">四、三块矩阵：Q、K、V 到底多给了什么</h2>
<p>简化版不用权重也能跑，但那个注意力是“死”的——谁和谁相关，全由词向量本身决定，模型没得学。而且点积对称（x·y = y·x），“床关注前”和“前关注床”必然一样大，语言里根本不是这么回事。</p>
<p>W_q、W_k、W_v 就是来解决这个的：</p>
<ul>
<li><strong>它们是投影，不是切分</strong>。token 的向量是信息的最小单元，不能掰开（掰开信息就丢了），但可以“换角度读”——同一个向量被三块矩阵各读一遍：W_q 读“我在找什么”，W_k 读“我有什么”，W_v 读“我能给什么”；</li>
<li><strong>Q、K 分开，注意力才有了方向</strong>。同一个 token，投成 Q 时是主语（我在找），投成 K 时是宾语（我被找），两块矩阵各学各的，q_a·k_b ≠ q_b·k_a；</li>
<li><strong>K、V 分开，“指路”和“送货”才解耦</strong>。K 决定“我被多少注意力找到”（打分），V 决定“我被找到后交出什么货”（内容）。介词是绝佳的路标但没什么货，实词低调但干货满满——打分和送货是两份工；</li>
<li><strong>Q+K+V ≠ 原 token</strong>。一个人的三个投影加起来，也不会是这个人本身。</li>
</ul>
<p>还有一个容易记乱的账：W_q 的形状是 (d_in, d_out)，Q = tokens @ W_q，<strong>出来的维度是 d_out，不是 d_in</strong>——投影的意义就是换维度。（<code>nn.Linear</code> 内部权重存成 (d_out, d_in)，计算时它内部转置，两种摆放别混。）</p>
<h2 id="五梯度怎么流回三块矩阵">五、梯度怎么流回三块矩阵</h2>
<p>训练时三块 W 怎么更新？从 loss 倒着走一遍：</p>
<ul>
<li>前向：W_q→Q、W_k→K 合成分数 → softmax → 权重 ⊗ V → context → 输出 → loss（每个位置都在预测下一个 token，loss 是所有位置的平均）；</li>
<li>反向：链式法则沿原路倒着流，loss 的梯度分成两路——一路经权重、softmax、scores 流到 Q 和 K，算出 ∂loss/∂W_q 和 ∂loss/∂W_k；另一路流到 V，算出 ∂loss/∂W_v。torch 的 <code>loss.backward()</code> 全自动；</li>
<li>画面是这样的：<strong>前向流的是电流（激活值），反向流的是另一种电流（梯度），电阻（W）在原地被梯度一点点拧动</strong>。</li>
</ul>
<p>这也解释了 sqrt(d_k) 为什么生死攸关：它保的不是数值好看，是<strong>梯度的生命线</strong>。</p>
<h2 id="六和-deepseek-的九问九答精选">六、和 DeepSeek 的九问九答（精选）</h2>
<p>学习过程中我和 DeepSeek 也过了一遍，挑几个有意思的：</p>
<p><strong>Q：Q、K、V 是原始 token 的切分吗？</strong>
不是，是投影。向量在数学上能拆，但拆开就丢信息——token 是最小计算单元。</p>
<p><strong>Q：投影维度必须和原维度一样吗？</strong>
不用。投影规模是可调参数，输入 768 维，投影后不一定是 768 维。</p>
<p><strong>Q：W_q、W_k、W_v 是每个 token 各一份吗？</strong>
不是，全局共用一套。它们是模型级参数——不但一个序列内共用，所有句子都共用同一组“投影角度”。</p>
<p><strong>Q：转置会不会打乱矩阵内部的关系？</strong>
不会。转置只是行列互换，现在的列是原来的行，数字之间的关系原封不动。</p>
<h2 id="七三问式收尾">七、三问式收尾</h2>
<ol>
<li><strong>今天学了什么</strong>：简化注意力三步走、sqrt(d_k) 的量纲归一、Q/K/V 三身份、梯度回流路径；</li>
<li><strong>哪里还没懂</strong>：梯度路径还要再手推一遍才踏实；多头注意力还没读；</li>
<li><strong>明天干什么</strong>：因果掩码（不许偷看未来）+ 多头注意力。</li>
</ol>
<p>关于多头，我留了一个问题给自己：<strong>Q、K、V 真的够吗，投影会不会越多越好？</strong>——先剧透一下答案的方向：三个角色是信息交换的最小完备集，但“更多投影”会以另一种方式兑现。</p>
<p>去读多头就知道了。</p>
<hr>
<p><em>这篇笔记由我和两个 AI 共同完成：DeepSeek 陪我过概念，Kimi 出验收题并负责格式。但每一个字的意思，都是我搞懂的。</em></p>
]]></content:encoded>
    </item>
  </channel>
</rss>
