从一条直线到大模型输出一个token（九）：输出矩阵与多层堆叠

建议先看：从一条直线到大模型输出一个token（八）：残差连接与前馈网络

上一篇走完了单个 Block 的六步。这一篇把 Block 复制 32 份串起来------不同层的 Block 各学什么，2024-2025 各家大模型到底堆了多少层，然后用 6 个 token 实地观察"浅→中→深"到底改了什么------这是理解"下一个 token 如何诞生"的关键一环。

从一条直线到大模型输出一个token（九）：输出矩阵与多层堆叠

从一条直线到大模型输出一个token（九）：输出矩阵与多层堆叠
- [1. 堆叠：把 Block 串成 32 层](#1. 堆叠：把 Block 串成 32 层)
- - [1.1 串联规则：出口接入口](#1.1 串联规则：出口接入口)
  - [1.2 一行代码的深度](#1.2 一行代码的深度)
  - [1.3 32 套独立权重 + 接口统一](#1.3 32 套独立权重 + 接口统一)
- [2. 分层：不同层的 Block 在做什么](#2. 分层：不同层的 Block 在做什么)
- - [2.1 三个实验证据](#2.1 三个实验证据)
  - [2.2 三级分工：以「西安」为例](#2.2 三级分工：以「西安」为例)
  - [2.3 提醒：统计倾向而非严格分工](#2.3 提醒：统计倾向而非严格分工)
- [3. 各家堆了多少层](#3. 各家堆了多少层)
- - [3.1 三条观察](#3.1 三条观察)
  - [3.2 宽与深的取舍](#3.2 宽与深的取舍)
- [4. 输出矩阵：6 个 token 的逐层演变](#4. 输出矩阵：6 个 token 的逐层演变)
- - [4.1 定义](#4.1 定义)
  - [4.2 逐层看 6 个 token 的变化](#4.2 逐层看 6 个 token 的变化)
  - [4.3 一句话总结 6 个 token 的浅中深命运](#4.3 一句话总结 6 个 token 的浅中深命运)
  - [4.4 嵌入 vs 输出矩阵：出厂设置 vs 现场理解](#4.4 嵌入 vs 输出矩阵：出厂设置 vs 现场理解)
- [5. 参数总账收官：80.4 亿](#5. 参数总账收官：80.4 亿)
- - [5.1 最后一块拼图：lm_head](#5.1 最后一块拼图：lm_head)
  - [5.2 230B 去哪了：不是偷换，是对账基准的选择](#5.2 230B 去哪了：不是偷换，是对账基准的选择)
  - [5.3 权重共享题外话（tied embeddings）](#5.3 权重共享题外话（tied embeddings）)
  - [5.4 完整闭环：230B → 1 → 80.4 亿](#5.4 完整闭环：230B → 1 → 80.4 亿)
- 小结
- 下一篇预告

1. 堆叠：把 Block 串成 32 层

1.1 串联规则：出口接入口

上一篇我们把单个 Block 的六步拆完：①归一化 → ②注意力 → +残差 → ③归一化 → ④FFN → +残差，入口矩阵 6×4096，出口矩阵还是 6×4096。

多 Block 堆叠的规则只有一条：上一个 Block 的出口 = 下一个 Block 的入口。所以第 2 层把第 1 层加工完的 6×4096 接着加工，再产出 6×4096；第 3 层再接；......一直到第 32 层。整条数据流如图 9-1 所示。

图9-1 多层堆叠：32 个 Block 串联，形状始终 6×4096

1.2 一行代码的深度

在工程实现里，"堆 32 层"其实就是 4 行代码的事：

复制代码

```python
x = 嵌入矩阵            # 6×4096，篇3 的查表结果
for block in blocks:    # 32 个 Block
    x = block(x)        # 每层内部 = 篇5 的六步
输出矩阵 = x            # 还是 6×4096，但已被深度加工
```

这四行干的事是：把嵌入矩阵塞进第一个 Block，加工完塞进第二个，依此 32 次------32 层的"深度"，代码上就是一个 for 循环。看起来简单，但每跑一次就过一遍 4096 维的复杂计算，32 次叠加出来的语义深度惊人。

1.3 32 套独立权重 + 接口统一

注意一个关键细节：32 个 Block 的权重不共享 。Block 1 的 W Q \mathbf{W}_Q WQ 和 Block 2 的 W Q \mathbf{W}_Q WQ 是两套完全独立的矩阵（各自初始化、各自训练）。所以 32 层不是把同一个 Block 复制 32 份------而是 32 个不同的"加工车间"，每个车间学到了不同的加工模式。

这也意味着参数量随层数线性增长：1 套 Block 的参数 × 32 = 32 套 Block 的参数。这正是 Transformer 越来越大的物理来源之一。

接口统一的设计巧思 ：每个 Block 的入口、出口形状都是 6×4096，完全相同。这个设计让层数可以随意增减------想训 36 层就用 36 个 Block（Qwen3-8B 就是 36 层），想训 94 层就用 94 个 Block（Qwen3-235B 就是 94 层），结构无需改动。这正是"Block"模块化设计的威力。

那这 32 个 Block 都在做同样的事吗？还是说"浅层、中层、深层各管一段"？下一节展开。

2. 分层：不同层的 Block 在做什么

LLaMA-3-8B 堆了 32 层，那这 32 层是各干各的，还是干同样的事？学术界已经有不少研究，统计学上的结论是：浅层、中层、深层确实在分工------只是分工是倾向性的，不是硬性的。

2.1 三个实验证据

关于"层间分工"，学术界有三项代表性研究，结论高度一致：

证据一：BERT 红线实验------Tenney, Das & Pavlick《BERT Rediscovers the Classical NLP Pipeline》（ACL 2019）。在 BERT 14 层上做"层间探针"（probing）实验：每一层的向量接到一个简单的分类器上做词性标注、句法分析、语义角色标注。结果发现：

浅层（1-4 层）：词性标注准确率已经很高（词性是表面特征，浅层就够）
中层（5-9 层）：句法关系解析能力强（主谓宾等结构）
深层（10-14 层）：语义角色、指代消解等"高阶任务"才达标

论文标题直译就是"BERT 重新发现了经典 NLP 流水线"------层间分工复刻了传统 NLP 的"词法→句法→语义"流水线。

证据二：语言学知识分层累积------Jawahar, Gurumurthy, Šaibabu, Pai & Goyal《What Does BERT Learn about the Structure of Language?》（ACL 2019，BERT 团队自家分析）。用探针实验证明：浅层编码短语级信息（"西安"是个名词短语），深层编码长距离依赖（"怎么样"跨越四个词指向"天气"）。

证据三：logit lens 实验 ------nostalgebraist《Interpreting GPT: the logit lens》（2020，LessWrong 博客，后被 Belrose et al. 2023《Eliciting Latent Predictions from Transformers with the Tuned Lens》系统化验证）。做法：把 Transformer 中间层的向量直接接到输出层 lm_head 上（跳过剩余层）看预测的下一个 token。在 GPT-2 上做：

浅层：预测的 token 完全是乱的（"the the the"这种）
中层：开始出现语法正确的词，但语义不对
深层：预测越来越准，最终层的预测就是真实输出

这说明浅层向量里"还看不出要预测什么"，深层向量已经为预测下一个 token 专门服务了。

2.2 三级分工：以「西安」为例

把这两类研究综合起来，层间分工可以归纳为三段：词法→句法→任务。以贯穿案例的"西安"为例，看它在 L1、L16、L32 三个层级分别变成了什么样（图 9-2）。

图9-2 浅、中、深：32 层各学什么（以「西安」为例）

浅层 L1-L10（词法·表面特征）：「西安」是个两字地名。这个阶段更多处理"这个词是啥"，向量里主要存着表层的字面信息。L1 出口「西安」行的 d3（正向特征）= 1.667，是 4 维中最大值。
中层 L11-L22（句法·语义关系）：「西安」是「天气」的描述对象，被「怎么样」提问。词之间的关系开始浮现------主谓宾结构、修饰关系、询问对象。L16「西安」行 d3 升到 2.05（关系特征开始聚集）。
深层 L23-L32（任务·预测）：整句在问天气，答案该往「晴/雨/温度」走。深层的特征表示直接服务于"预测下一个 token"------L32「西安」行 d3 升到 2.62（"被询问的城市"这一任务级身份彻底成型）。

关键观察 ：「西安」行的 4 个数值不是单调涨或单调跌，而是特征在重新组合、逐渐聚焦到最该表达的那个维度。L1 时 d1=-1.046（位置/结构特征）、d3=1.667（表面特征）互相对比；L32 时 d1=-0.68、d3=2.62------两端的"主角"地位被强化，中间维度被稀释。

2.3 提醒：统计倾向而非严格分工

这不是硬性分工。具体某一层可能在做"中层的事"，下一层又在做"浅层的事"------分工是统计意义上的倾向，不是逐层硬切。深度学习不神秘也不死板，每层都在"做自己该做的事"，但什么是"该做的"是训练自然学出来的，不是人规定的。

工程上的结论是：堆 32 层不是浪费------浅层在打基础、中层在搭结构、深层在做任务，缺一不可。十几层的小模型能干不少事，九十几层的旗舰模型能干多得多的事------深度是能力的来源之一。

那各家具体堆了多少层？是否越大堆得越多？下一节展开。

3. 各家堆了多少层

层数选多少，是大模型设计的关键决策。统计 2024-2025 年十个主流模型如表 9-1 所示。

表9-1 主流模型的层数与隐藏宽度（2024-2025）

模型	发布	参数量	d_model	层数
LLaMA-3 8B（系列基准）	2024-04	8B	4096	32
Qwen3-8B	2025-04	8B	4096	36
gpt-oss-120b	2025-08	117B（MoE，5.1B 激活）	2880	36
GLM-4-9B	2024-06	9B	4096	40
Gemma-3-12B	2025-03	12B	3840	48
DeepSeek-V3 / R1	2024-12 / 2025-01	671B（MoE，37B 激活）	7168	61
Kimi K2	2025-07	1T（MoE，32B 激活）	7168	61
Gemma-3-27B	2025-03	27B	5376	62
Qwen3-32B	2025-04	32B	5120	64
Qwen3-235B-A22B	2025-04	235B（MoE，22B 激活）	4096	94

视觉化对比见图 9-3。

图9-3 各家堆了多少层：2024-2025 十个主流模型的深度统计

3.1 三条观察

从这张图能读出三条观察：

观察一：同尺寸，新一代在加深。 LLaMA-3-8B（2024-04）32 层 → Qwen3-8B（2025-04）36 层------同样 8B 体量、同样 4096 宽度，一年后多堆了 4 层。Gemma-3-12B 48 层、Gemma-3-27B 62 层，相对各自的宽度也都是"深配"。

观察二：参数大头在宽度，不在深度。 参数量粗略公式：参数 ≈ 层数 × 宽度²。所以同样 10 倍参数，全加深度只需 ×2.5（每层参数不变），全加宽度要 ×3.2（每层参数 ×10）。模型变大优先加宽度 ------更划算。经验甜点位：8B 级层数 ≈ d_model/128（4096/128=32 恰好是 LLaMA-3-8B，3840/128=30 而 Gemma-3-12B 堆到 48 层）------新一代普遍超配深度。

观察三：MoE 把省下的计算换成深度。 最典型的是 Qwen3-235B-A22B：宽度 4096 与 8B 版完全相同 ，却堆到 94 层------因为 MoE 每 token 只激活 22B 参数，计算量省下来就砸进深度。gpt-oss-120b 更极端：宽度只有 2880（比 8B 模型还窄），36 层 + 128 专家取 4，单 token 激活仅 5.1B。"窄而深 + MoE"是 2025 年的新偏好。

3.2 宽与深的取舍

为什么不无限加深？两个原因：

收益递减：32 层到 64 层效果好（深一点语义更丰富），64 层到 128 层效果就没那么明显了------同样的语义能力，深一点但没深很多。
推理延迟：Transformer Block 是严格串行的------每生成一个 token 都要重新过 32 层，层数翻倍就翻倍串行时间。生产环境 8B 模型 32 层是延迟、效果、成本的综合平衡点。

MoE 架构是破局的第三条路：DeepSeek-V3 61 层、Qwen3-235B 94 层，比同体量稠密模型更深，但每 token 只激活一小部分专家------深度上去了，延迟没跟着上去。这正是篇1 埋下的"230B 总参数 vs 23B 激活"悬念的工程实现。

现在我们回到贯穿案例，亲眼看一遍"32 层加工"对 6 个 token 做了什么。

4. 输出矩阵：6 个 token 的逐层演变

4.1 定义

第 32 层 Block 的出口，就是输出矩阵------本篇的主角。它的形状仍然是 6×4096，但每一行的 4096 个数已经和篇3 查表得来的原始嵌入天差地别。

强调一遍：本篇的"输出矩阵"= 模型主干（32 层 Block 堆叠）的最终输出，形状 6×4096。篇10 还会再讲一个"输出层"（lm_head），那是把这个 6×4096 翻译成词表分数的最后一步------和这里的"输出矩阵"是两个东西，别混淆。

4.2 逐层看 6 个 token 的变化

第 2 节讲了"不同层的 Block 做什么"是统计倾向，那对贯穿案例的 6 个 token 来说，这种倾向真的存在吗？我们在 L1（真算）、L16（示意）、L32（输出矩阵，示意）三处抓快照，让数字说话，如图 9-4 所示。

图9-4 从 Block 1 到输出矩阵：6 个 token 的逐层演变（红色 = 每行最大值）

先交代机制再读数字：每一层的加工都是篇5 的六步------注意力把别的 token 的信息混进来（篇6-7），FFN 逐行深加工（篇8），残差保底不让信息丢失（篇8）。三个力合在一起，推动"对预测下一个 token 有用"的特征逐层放大。下面逐 token 解读。

「今天」------时间限定，浅层最亮，深层让位

浅层 L1：d3=3.685，全场 24 个数里的最大值。查表嵌入的"时间词"特征经过第一轮 FFN 深加工就冲到最高------浅层对"这个词是什么"最敏感
中层 L16：d3=3.450，开始回落。注意力把"今天"的时间信息和"西安/天气"逐步绑定，它不再是独立主角
深层 L32：d3=3.120，继续降。深层知道回答时要带时间限定（"今天"），但它只是状语，不是答案焦点
对下一个 token 的意义：答案被限定在"今天"的语境里------模型不会答"西安冬天下雪吗"，只会答当下的天气

「西安」------主角识别，逐层聚焦

浅层 L1：d3=1.667，"两字地名"的表面特征，只是"一个词"
中层 L16：d3=2.050。篇7 算过的注意力在起作用------「西安」吸收了「天气」22.3%、「怎么样」25.9% 的信息，"被描述对象"的关系特征开始聚集
深层 L32：d3=2.620。"被询问天气的城市"这一任务级身份彻底成型
对下一个 token 的意义：答案的主体锁定为西安的天气------模型不会答北京的天气

「的」------结构胶水，全程低调

浅层 L1：d3=2.504，助词的词性特征其实不弱（浅层擅长识别"这是个结构词"）
中层 L16：d3=2.350。它建立起「西安的天气」定中关系，把两个实词黏在一起
深层 L32：d3=2.150。关系交付完毕后功成身退，数值缓降但红标稳定------胶水不需要抢戏
对下一个 token 的意义：几乎没有直接贡献，但中层建立的"定中结构"决定了答案的主语是"西安的天气"而不是别的组合

「天气」------红标迁移（d3→d4），领域锁定

浅层 L1：d3=2.024 > d4=1.827，红标在 d3------"被询问对象"的语义位暂时压制了气象位
中层 L16：d4=2.35 反超 d3=1.75，红标完成迁移------"气象招牌"特征在中层崛起
深层 L32：d4=2.95 vs d3=1.42，拉开一倍差距------答案的领域特征彻底聚焦
对下一个 token 的意义 ：领域锁定。这一行的 d4 通道就是篇10 预测往"晴/雨/温度/风"方向走的直接推力------问句的核心宾语已经把答案的类别圈死了

「怎么样」------疑问语气，单调登顶

浅层 L1：d4=2.534，疑问副词的语气特征从嵌入起就强
中层 L16：d4=2.780，"询问状态"的任务持续强化
深层 L32：d4=3.050，全场新的最大值------「怎么样」在深层成为整句信息最富集的 token
对下一个 token 的意义 ：词性锁定。"怎么样"要求答案是对状态的描述------决定了首 token 倾向于形容词性或描述性开头（"晴""多云"），而不是动词或名词开头

「？」------红标迁移（d3→d1），任务接管（全篇最重要）

浅层 L1：d3=2.102 > d1=2.005，红标在 d3------问号还停留在"句末标点"的句法身份
中层 L16：d1=2.42 反超 d3=2.00，红标迁移------"问完了"的任务特征开始接管
深层 L32：d1=2.85 vs d3=1.90，全面接管------"该作答了"
对下一个 token 的意义 ：这就是输出矩阵最后一行 。d1 通道的持续强化就是"结束输入、开始输出"的开关信号------篇10 里，这 4096 个数（演示 4 个）将送进 lm_head，产生 129,280 个候选分数，最终吐出首 token。「？」行是全系列的接力棒：前面 8 篇的所有加工，最终都沉淀在这一行里

4.3 一句话总结 6 个 token 的浅中深命运

今天限定了时间、西安锁定了主体、的黏合了结构、天气圈死了领域、怎么样 规定了词性、**？**按下了开始的开关------6 个 token 在 32 层里各就各位，整句话的"任务意图"层层聚焦，最终全部沉淀到输出矩阵的最后一行。下一个 token 的一切约束条件，在这张 6×4096 的矩阵里已经准备完毕。

4.4 嵌入 vs 输出矩阵：出厂设置 vs 现场理解

	篇5 归一化后入口	篇9 输出矩阵
是什么	词表查表 + 归一化	32 层加工
信息量	单个词的"出厂设置"	整句话的"现场理解"
西安的 d3	1.257（地名向量）	2.62（被询问的地名）
？的 d1	1.265（问号静态特征）	2.85（任务级特征接管）

关键洞察 ：嵌入是"这个词是啥"（西安=地名），输出矩阵是"这个词在这句话里意味着啥"（西安=被询问天气的城市）。从篇3 到篇9，整个 Transformer 主干做的工作就是"出厂设置→现场理解"------这中间走过位置编码、注意力、FFN、32 层堆叠，每一步都在朝"理解"这个目标加工。

但输出矩阵还不是答案。要把 6×4096 的理解变成下一个 token，还差最后一步------lm_head（输出层），把 4096 维向量投影到词表 129,280 个候选上。这部分留到篇10。

5. 参数总账收官：80.4 亿

篇1 把 230B 参数压成 1 个参数走通了原理实验，篇3 嵌入表 + 5.3 亿，篇6 加 0.42 亿/层注意力，篇8 加 1.76 亿/层 FFN，× 32 层后是 75.1 亿（篇8 时点）。还差最后一块拼图：输出层 lm_head。

5.1 最后一块拼图：lm_head

lm_head 是什么？篇3 讲过，词表大小是 129,280（DeepSeek-V3 口径）。要把一个 4096 维向量"翻译"成 129,280 个候选 token 的分数，需要一个 4096×129,280 的矩阵：

129,280 × 4,096 = 529,530,880 ≈ 5.3 亿

加上这个 5.3 亿，参数账就完结：

75.1 亿（篇8 末）+ 5.3 亿（lm_head）= 80.4 亿 ≈ LLaMA-3-8B 官方 8.03B

对账成功。篇1 的"从 1 加回到 8B"完整闭环，如图 9-5 所示。

图9-5 参数总账收官：从 1 个参数加回到 80.4 亿（对数坐标）

5.2 230B 去哪了：不是偷换，是对账基准的选择

写到这里必须坦诚回答一个疑问------篇1 的起点是豆包 Seed-1.6 的 230B ，加回来的却是 LLaMA-3-8B 的 80.4 亿，中间是不是偷换了模型？

没有偷换，但确实换了对账基准，这里说清楚：

篇1 为什么用 230B：那是个思想实验的起点------"一个真实大模型有 230B 个参数，把它们全砍掉只剩 1 个会发生什么"。选 Seed-1.6 是因为它把"总参数 vs 激活参数"的两个数字（230B vs 23B）拉开了，最能体现 MoE 时代的规模感。

加法路径为什么换成 LLaMA-3-8B ：逐篇加参数需要一个每个部件都能精确对账 的基准。稠密的 LLaMA-3-8B 结构公开、参数透明------嵌入 5.3 亿 + 32 层 × 2.18 亿 + lm_head 5.3 亿 = 80.4 亿，和官方 8.03B 一分不差。而 Seed-1.6 的 230B 里混着 256 个专家、路由器、共享专家------参数账复杂到没法逐篇手算。选 8B 不是因为它更强，而是因为它小而完整、可以精确对账。

两者是同一套原理 ：Seed-1.6 的每个 Block 和 LLaMA-3-8B 的每个 Block 长得一样------都是注意力 + FFN + 残差 + 归一化。区别只在三个旋钮：更宽（7168 vs 4096）、更深（61 层 vs 32 层）、MoE 化（每层 256 个专家挑 8 个干活）。学会了 8B 的账本，就看懂了 230B 的骨架------这也是第 3 节表格里那些 MoE 旗舰和稠密模型放在一起比较的原因。

一句话：篇1 用 230B 说明"参数有多大"，篇3-9 用 80.4 亿说清"参数怎么构成"------一个是规模感，一个是原理账。篇10 结尾我们还会回到 230B，把 MoE 的最后一环补完。

5.3 权重共享题外话（tied embeddings）

多说一个工程细节：很多 Transformer 模型的 lm_head 和嵌入表共享同一份权重（tied embeddings）------嵌入表是 129,280×4096，lm_head 是 4096×129,280，转置一下正好对齐。如果共享，就能省下 5.3 亿参数，模型瘦身约 7%。

GPT-2 系列共享 （省 5.3 亿），LLaMA 系列不共享（保留独立 lm_head 提升效果上限）。我们算的 80.4 亿是 LLaMA-3-8B 口径（含独立 lm_head），和官方 8.03B 几乎完全吻合。

5.4 完整闭环：230B → 1 → 80.4 亿

把这条线画完：

篇1：230B（Seed-1.6，MoE）→ 1（过原点直线）------规模感起点
篇1 末：1 + 截距 = 2
篇3：+ 嵌入表 = 5.3 亿
篇6：+ 注意力（×1 层）= 5.7 亿
篇8：+ FFN（×1 层）= 7.5 亿
篇8 末：× 32 层 = 75.1 亿
篇9 末：+ lm_head = 80.4 亿 ≈ LLaMA-3-8B 官方 8.03B ✅------原理账终点

80.4 亿。这就是"从 1 个参数一路加回来"到本篇为止的全部家当------也是篇10 即将登场的首 token 预测的"输入"。

小结

这一篇把 Block 从 1 个复制到 32 个，分层、层数、输出矩阵、参数账全部收官：

堆叠机制：上 Block 出口 = 下 Block 入口；一行 for 循环串 32 次；32 套独立权重；接口统一所以层数可任意增减
分层：浅层 L1-10 学词法表面（"西安=地名"）、中层 L11-22 学句法语义（"西安=被询问对象"）、深层 L23-32 学任务预测（"该答天气了"）；证据：Tenney et al. 2019（ACL）、Jawahar et al. 2019（ACL）、logit lens（2020）；统计倾向而非严格分工
层数统计（2024-2025 新模型）：同尺寸在加深（LLaMA-3-8B 32 层 → Qwen3-8B 36 层）；参数大头在宽度（≈ 层数 × 宽度²）；MoE 把省下的计算换成深度（Qwen3-235B 宽度与 8B 相同却堆 94 层；gpt-oss-120b 宽 2880 + 36 层 + 5.1B 激活）
输出矩阵 + 6 token 逐层三级解读 ：「今天」限定时间（浅层最亮 3.685 → 深层让位）；「西安」锁定主体（d3 单调 1.667→2.05→2.62）；「的」黏合结构（低调缓降）；「天气」圈死领域（红标 d3→d4 迁移，气象特征 1.827→2.35→2.95）；「怎么样」规定词性（d4 单调登顶 3.05 全场最高）；「？」按下开关（红标 d3→d1 迁移，任务特征 2.005→2.42→2.85 全面接管）------输出矩阵最后一行就是篇10 预测首 token 的全部原料
参数账收官：+ lm_head 5.3 亿 → 80.4 亿 ≈ LLaMA-3-8B 官方 8.03B；篇1 的 230B（Seed-1.6）是规模感起点、80.4 亿是原理账终点------不是偷换，是对账基准的选择，两者共享同一套 Block 原理

下一篇预告

输出矩阵最后一行（"？"的 4096 维向量）就是预测下一个 token 的全部原料。下一篇把它送进 lm_head，得到词表上 129,280 个候选的分数，再过 Softmax 变成概率，最后采样出一个 token------首字诞生。然后自回归生成第二字、KV-Cache 优化......

系列目录：

从一条直线到高维空间

分词与 token 表

隐藏层与嵌入

位置编码 RoPE

Transformer Block 全景与层归一化

QKV 三剑客

注意力权重与多头机制

残差连接与前馈网络

输出矩阵与多层堆叠（当前篇）

首 token 诞生与 KV-Cache

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。