第 5 课：逐层解剖一个模型｜第一性原理大模型课程

第 5 课：逐层解剖一个模型

前面三节课我们学了 Transformer 的原理、五大改造、Tokenization。现在把所有这些拼起来——以 Llama 2 7B 为标本，从 Embedding 到 LM Head，一层一层拆开看 tensor 形状和计算量。

🎯 学完这 6 步你将能够：

① 画出 Llama 7B 的完整架构图，标注每一层的 tensor 输入输出形状
② 手工推算 Attention 层和 FFN 层的参数量和 FLOPs
③ 从"你好"两个 token 开始，追踪它们经过 32 层后的完整变化过程

🗺 本节推理链（6 步逐层递进：从"算清每个 tensor"到"拼出一次前向的 FLOPs"）

1要做显存估算和 FLOPs 核算，必须先把 整体结构 拆开算清参数量（Embedding → 32×Block → LM Head）—— 只记住"7B"一个总数，就说不清 96% 的参数压在哪里。

↓

2整体结构的第一笔账落在 Embedding 查表 上：32000×4096 的矩阵占 131M（约 2%），这就要求先把它和后面的矩阵乘法分开——它只按 token ID 取整行，不做乘加。

↓

3向量离开 Embedding 查表后进入 Block，第一个子层是 Attention，要回答"谁该看谁"——所有关系挤在一条 4096 维通道里学不出多样模式，因此拆成 32 头×128 维各自算注意力（4 个 4096×4096 = 67M）。

↓

432 头的 Attention 只负责在 token 之间搬运信息，"这些信息意味着什么"没人回答，于是补上 SwiGLU（用门控控制信息通过量的前馈网络） FFN（gate/up/down 三个矩阵，135M，占每层 2/3）；否则模型只是一台搬运机。

↓

5SwiGLU FFN 再强，32 层也叠不起来：少了归一化数值会逐层放大、少了残差梯度衰减到第 1 层就没了，因此每层加 2 个 RMSNorm（各 4096 参数）+ 两条 RMSNorm 与残差捷径，把主干直通下去。

↓

6RMSNorm 与残差捷径把每层接成主干后，把上面全部串起来跑一次前向：Embedding→32×[Norm→Attn→Res→Norm→FFN→Res]→Final Norm→LM Head，于是得每层约 400M FLOPs、32 层约 12.8G（单 token 前向约 13.5 GFLOPs）、生成 100 token ≈ 1.35T——这就是推理成本的全部来源。

LlamaEmbeddingAttentionSwiGLURMSNormParameters

如果拆开一个 Llama 7B 模型，里面到底有几层？每层在干什么？

提示：先想清楚"哪些参数在 32 层里各来一份、哪些只在首尾出现"——把结构拆成 Embedding、Block、输出三部分，再逐块估大小，答案自然浮现。

▾

知识背景

Llama 7B 的结构：1 个 Embedding 层 + 32 个 Transformer Block + 1 个 LM Head。参数量 = 6.74B（四舍五入为"7B"）。每层 Block ≈ 202M（Attention 67M + FFN 135M）。Embedding 仅 131M（约 2%）。同系列的 LLaMA-13B 在多数基准上超过了 GPT-3（175B），参数量不到它的十分之一（Touvron et al., Meta, 2023）。

Llama 2 7B 的架构由三部分组成：Embedding 层 → 32 个 Transformer Block → LM Head。每个 Block 内部又分成 Attention 和 FFN 两个子层，每个子层前后各有一个 RMSNorm。

可以把这一结构类比成一条装配线：首尾各有一个工位，中间几十个工位做完全相同的加工——Transformer 里这些"工位"叫 Block，只是重复了很多次。

🧮 Llama 2 7B 完整参数拆解

Step 1：全局架构 — 3 大部分，32 层

组件	包含什么	参数	占比
Token Embedding	32000 × 4096 的查表矩阵	131.1M	1.95%
32 × Transformer Block	每层 = Attention + FFN + 2×RMSNorm	32 × 202.4M = 6,476M	96.1%
LM Head + Final RMSNorm	输出投影（独立矩阵，不与 Embedding 共享）+ 最后的归一化	131.1M + 4K	1.95%

总计：131.1M + 6,476M + 131.1M ≈ 6.74B，与宣布的 7B 接近（差异来自模型配置细节）。

Step 2：一个 Transformer Block 的内部结构

子层	操作	参数
Input RMSNorm	对输入做 RMS 归一化	4096（仅 γ 参数）
Attention	QKV 投影(3×[4096×4096]) + O 投影([4096×4096])	4 × 16.78M = 67.1M
Post-Attention RMSNorm	对残差加和后的结果归一化	4096
FFN (SwiGLU)	gate([4096×11008]) + up([4096×11008]) + down([11008×4096])	3 × 45.1M = 135.3M

每层总参数：67.1M(Attention) + 135.3M(FFN) + 8K(2×RMSNorm) ≈ 202.4M。32 层 ≈ 6.48B，绝大部分参数在 Attention 和 FFN 里。

Step 3：数据流动方向 — "你好"两个字走一遍

位置	操作	tensor 形状
① Tokenizer 输出	"你好" → BPE 编码 → token IDs	[1, 2]（batch=1, seq_len=2）
② Embedding	查表：每个 ID 取一行 4096 维向量	[1, 2, 4096]
③ Block 1..32	每层进出形状不变：Attention→残差→FFN→残差	[1, 2, 4096] → 32次 → [1, 2, 4096]
④ Final RMSNorm	归一化最后一层的输出	[1, 2, 4096]
⑤ LM Head	× W_out^T（独立输出矩阵）得到词表概率分布	[1, 2, 32000]

🎯 关键认知

7B 参数的 96% 在 32 个 Transformer Block 里。每个 Block 又分配为：Attention 占 33%（67M/202M），FFN 占 67%（135M/202M）。FFN 矩阵是模型"知识存储"的主体——这也是为什么 FFN 比 Attention 大两倍。

AI 助教

👋 对 Llama 的架构有疑问？比如"为什么 FFN 比 Attention 参数多？""不同大小的模型（7B/13B/70B）每层参数一样吗？"

我会用具体数字帮你算。

从"你好"两个字到一堆 4096 维向量——Embedding 层到底做了什么运算？

提示：Embedding 层本质上就是一个巨大的查表操作——32000 行的矩阵，每行是一个 4096 维的向量。拿到 token ID 后，直接取对应行。

▾

知识背景

Embedding 矩阵 = V × d = 32000 × 4096 = 131M 参数。本质：一个巨大查找表——取 token ID 对应行的 4096 维向量。Weight Tying（权重绑定）：让 Embedding 和 LM Head 共享同一个矩阵，省下一份参数。原论文《Attention Is All You Need》(2017) 第 3.4 节已采用；Inan et al.（2016）与 Press & Wolf（2017）分别系统讨论了它的收益与做法（GPT-2 等沿用）。但 Llama 2 并未使用——它的 LM Head 是一个独立的 131M 输出矩阵。

上一张卡片我们看完了 Llama 的整体结构（Embedding → 32 Blocks → LM Head）。现在聚焦第一站：Embedding 层的数学极其简单——矩阵查表。有一个 32000×4096 的矩阵 W_embed，token ID 为 t 时，输出就是 W_embed 的第 t 行。

这一步就像查一本字典：token ID 是页码，翻到那一页整行搬走，不需要做任何乘加——Embedding 层的运算只有取行这一步。

🧮 "你好"的 Embedding 查表，每一步的数值

Step 1：Tokenizer 输出 — "你好" → 两个 token ID

字	Token ID（示意）	说明
你	12845	常见单字 token，词表中独立存在
好	6721	常见单字 token，词表中独立存在

输入 tensor：[[12845, 6721]]，形状 [1, 2]（batch_size=1, seq_len=2）。

Step 2：Embedding 查表 — 取 W_embed 的第 12845 行和第 6721 行

Token	前 4 维数值（示意）	完整维度
"你"	[0.032, -0.015, 0.078, -0.041, ...]	4096 维
"好"	[0.056, 0.023, -0.012, 0.067, ...]	4096 维

输出 tensor：[[[0.032,-0.015,...], [0.056,0.023,...]]]，形状 [1, 2, 4096]。

Step 3：显存计算 — Embedding 矩阵有多大？

项目	计算	结果
参数数量	32000 × 4096	131,072,000（131M）
fp16 显存	131M × 2 bytes	262 MB
fp32 显存	131M × 4 bytes	524 MB
推理时实际占用	fp16 加载 + 输入 batch 查表临时内存	~270 MB（含临时 buffer，估算，依实现而异）

262MB 的 Embedding 矩阵在推理时一直驻留在 GPU 显存中。对于 24GB 的消费级显卡，它占约 1%。

🎯 Embedding 矩阵与 LM Head 是两个独立矩阵

Llama 2 的 Embedding 矩阵 W_embed（[32000, 4096]）负责把 token ID 映射为向量；最后的输出投影 LM Head 是一块独立的 [4096, 32000] 矩阵 W_out，把最后一层的 [1, 2, 4096] 映射回 [1, 2, 32000] 词表概率。二者并不共享权重（tie_word_embeddings=False）——6.74B 这个总数里已经分别算了这两块各 131M。Weight Tying（共享）是 GPT-2 等模型的做法，可省一份参数，但 Llama 2 没有采用。

AI 助教

👋 对 Embedding 层有疑问？比如"能不能用更小的 Embedding 维度？""ALiBi 和 RoPE（按位置给词向量拧一个旋转角度）的位置编码在哪一步加进去？"

我会用具体数字帮你算。

一个 Attention Head 里，Q、K、V 到底是怎么从输入一步步算出来的？

提示：先想 Q/K/V 从哪来——输入分别乘三个权重矩阵得到；再想那 4096 维怎么分给 32 个头，每个头算的注意力维度是多少？

▾

知识背景

Attention 层内部包含 4 个权重矩阵：W_Q、W_K、W_V、W_O（各 4096×4096 = 16.8M → 共 67M）。流程：输入 × W_Q/W_K/W_V → 拆 32 头（每头 128 维）→ RoPE 旋转 → QK^T/√128 → Softmax → ×V → 拼接 → ×W_O。每头独立学习一种关系模式。

上一张卡片我们把"你好"变成了两个 4096 维向量。现在它们进入 Attention 层——Transformer 的核心计算单元。输入 [1, 2, 4096]，经过 QKV 投影 → 注意力计算 → O 投影，输出还是 [1, 2, 4096]。

用图书馆借书来类比：Q 是手里的索书号，K 是书脊上的分类标签，V 是书页里的正文——拿 Q 去和每张 K 比对，谁最像就借走谁的 V。

🧮 完整走查：一个 Attention Block 的 5 步计算

Step 1：QKV 投影 — 输入 × 三个权重矩阵

操作	计算	输出形状	参数量
Q = X × W_Q	[1,2,4096] × [4096,4096]	[1, 2, 4096]	16.78M
K = X × W_K	[1,2,4096] × [4096,4096]	[1, 2, 4096]	16.78M
V = X × W_V	[1,2,4096] × [4096,4096]	[1, 2, 4096]	16.78M

QKV 投影合计 3 × 16.78M = 50.3M 参数。每个投影就是一次矩阵乘法。

Step 2：拆头 — 4096 维 → 32 个头 × 128 维

张量	拆分前	拆分后
Q	[1, 2, 4096]	[1, 32, 2, 128]（batch, heads, seq, dim）
K	[1, 2, 4096]	[1, 32, 2, 128]
V	[1, 2, 4096]	[1, 32, 2, 128]

"你好"只有 2 个 token，所以 seq_len=2。每个头拿到的是 2×128 的子矩阵。

Step 3：注意力分数 — Q × K^T / √128

头编号	计算	注意力矩阵形状	含义
Head 1	Q₁ × K₁^T / √128	[1, 2, 2]	2个字之间的两两注意力分数
Head 1 数值	例（已除以 √128 的缩放后分数，示意）：Q₁[0]·K₁[0]/√128=0.43, Q₁[0]·K₁[1]/√128=0.18 Q₁[1]·K₁[0]/√128=0.15, Q₁[1]·K₁[1]/√128=0.52	[[0.43, 0.18], [0.15, 0.52]]	"你"更关注自己(0.43)，"好"也更关注自己(0.52)

√128 ≈ 11.31 是缩放因子——防止点积太大导致 softmax 梯度消失。

Step 4：Softmax + 加权求和 — 每个位置的输出是 V 的加权组合

步骤	Head 1 的计算
Softmax(QK^T/√128)	行1: softmax([0.43,0.18]) = [0.56, 0.44] 行2: softmax([0.15,0.52]) = [0.41, 0.59]
输出 = 注意力权重 × V	位置1输出 = 0.56×V₁[0] + 0.44×V₁[1] 位置2输出 = 0.41×V₁[0] + 0.59×V₁[1]

Step 5：合并头 + O 投影 — 32 个头拼回 4096 维，再乘 W_O

操作	输入形状	输出形状
合并 32 个头	[1, 32, 2, 128]	[1, 2, 4096]
O = concat × W_O	[1, 2, 4096] × [4096, 4096]	[1, 2, 4096]

Attention 层总参数：QKV(50.3M) + O(16.78M) = 67.1M。输入/输出形状不变 [1,2,4096]→[1,2,4096]。

🎯 为什么用 32 个头？

多头注意力的关键是让不同头关注不同的语义关系。研究者发现（Clark et al., 2019），训练后的模型里某些头倾向于关注"主语-谓语"关系，另一些头关注"形容词-名词"修饰，还有些头关注位置相邻性（哪一头对应哪种关系并无固定编号，此处为示意说明）。如果只有一个头（4096 维直接做 Attention），所有关系会混在一起，模型学不出这么多样的注意力模式。32 个头 = 32 种不同的"视角"同时看同一句话。

AI 助教

👋 对 Attention 计算有疑问？比如"GQA（把多个 Query 头分成几组、每组共享同一份 K/V）是怎么减少 KV 头的？""如果不用 √d_k 缩放会怎样？"

我会用具体数字帮你走一遍。

一个 token 走完 32 层 Llama 2 7B，到底要算多少次浮点运算？

提示：先想一件事——每一次权重参与运算，要花几次浮点操作？把这个数乘以参数量，会得到什么？

▾

知识背景

FLOPs（Floating Point Operations，浮点运算次数：衡量计算量的单位，一次浮点乘或一次浮点加各算 1 次）是算力核算的通用货币。经验规则：前向 FLOPs ≈ 2 × 参数量——因为每个权重在一次前向里做一次「乘 + 加」= 2 FLOPs。训练再按 3 倍算（前向 2N + 反向 4N = 6N），就是 Kaplan et al.《Scaling Laws for Neural Language Models》（arXiv:2001.08361, 2020）与 Hoffmann et al.《Training Compute-Optimal Large Language Models》（Chinchilla, arXiv:2203.15556, 2022）反复使用的 C ≈ 6ND 口径。痛点：光知道「7B」这一个数，算不出它的单 token 计算量——而这条 2N 规则把它变成能口算的估算器。

上一张卡片我们逐步跑完了 Attention 的 5 步计算；这一张换个问法——不再问「怎么算」，而是问「一共要算多少次」。要把一个 token 走完 32 层的计算量压成一个数，只需要一条经验规则：一次前向里，每个权重都恰好做一次「乘 + 加」，也就是 2 次浮点运算（FLOP，Floating Point Operation，一次浮点乘或浮点加）。先把三种口径说清（同一颗权重，按数哪些运算区分）：
① 只数乘法（乘一次算 1）：前向 ≈ 1N = 6.7 GFLOPs；
② 只计前向、乘和加都数（每权重 2 FLOPs）：前向 ≈ 2N = 13.5 GFLOPs；
③ 前向 + 反向（反向约是前向的 2 倍）：训练 ≈ 6N = 40.4 GFLOPs。
本课前向采用口径 ②、训练采用口径 ③，两者口径统一（②×3 = ③）。

把这条规则套到参数量上，就得到本课要记住的 2N 规则：前向 FLOPs ≈ 2 × 参数量。它就像一条「流水线计件工资」的口算公式——每个权重是一名工人，每过一次前向固定领 2 次浮点操作，把工人总数（参数量）乘 2 就是这一趟的总工时。

🧮 从 2N 到 6ND：一条能口算的算力公式

Step 1：2N 从哪来——每个权重 2 次浮点操作

操作	每个权重做什么	FLOPs
乘	权重 w 乘上激活 x	1
加	把乘积累加进这一路的输出	1
合计	一次前向里每个权重固定贡献	2

所以一个 [4096, 4096] 矩阵（16.78M 参数）单独跑一次就要 2 × 16.78M ≈ 33.6M FLOPs。

Step 2：套到 Llama 2 7B——单 token 的前向 / 反向 / 训练

阶段	计算	结果
参数量 N	—	6.74B
单 token 前向	2 × N = 2 × 6.74e9	13.5 GFLOPs
单 token 反向	4 × N = 4 × 6.74e9	27.0 GFLOPs
单 token 训练（前向 + 反向）	6 × N = 6 × 6.74e9	40.4 GFLOPs

6.74B 参数本身就横跨 32 层（32 × 202.38M ≈ 6.48B），所以 2N 已经把「走完全部 32 层」的账算进去了——不必再单独乘 32。

Step 3：训练总算力 C = 6ND 的来历

项	计算	结果
每 token 训练 FLOPs	2N（前向）+ 4N（反向）= 6N	40.4 GFLOPs
训练 1T token	6 × 6.74e9 × 1e12	4.04 × 10²² FLOPs
训练 2T token	6 × 6.74e9 × 2e12	8.09 × 10²² FLOPs

把 6N 换成 6ND（D = 训练 token 数），就是训练总算力公式 C = 6ND。

Step 4：一个例子——1000 token 的输入要多少算力

场景	计算	结果
prefill 1000 token（一次前向过 1000 个 token）	1000 × 2 × 6.74e9	13.5 TFLOPs
生成 100 token	100 × 2 × 6.74e9	1.35 TFLOPs

示意口径：这里只乘 2N，忽略了 attention 的 O(L²) 项——短上下文（几百 token）下它相对很小，上下文极长时才会显著长大。

🎯 关键认知：2N 是一个可以口算的估算器

记住 2N 这一条，看到任何模型都能立刻估出它的单 token 前向算力：Llama 2 7B ≈ 13.5 GFLOPs、13B ≈ 26 GFLOPs、70B ≈ 140 GFLOPs。训练时换成 6N，再乘训练 token 数，就得到总训练算力 C = 6ND——这是各大团队规划预算时用的口径。它忽略 attention 的 O(L²) 项，短上下文下误差很小；上下文极长时这一项才会盖过 2N。

AI 助教

👋 对 FLOPs 和 2N 规则有疑问？比如「为什么是 2N 而不是 N？」「训练为什么是 6N？」「上下文很长时 attention 那一项有多大？」

我会用具体数字帮你算。

🤔 学生最可能追问的 5 个问题

1.为什么是 2N 而不是 N？一个权重不就用一次吗？▾

一次权重参与包含「乘」和「加」两步，各算 1 次浮点操作，所以每个权重固定 2 FLOPs。

操作	作用	FLOPs
乘	w × x	1
加	累加进输出	1
合计	每权重每次前向	2

套到 Llama 2 7B：6.74e9 × 2 = 1.348e10 ≈ 13.5 GFLOPs/token。反过来，单个 [4096, 4096] 矩阵 16.78M 参数 → 2 × 16.78M ≈ 33.6M FLOPs。

2.训练时为什么是 6N，而不是 2N？▾

反向传播要额外算两类梯度：对权重求梯度 ≈ 2N，向下游层传梯度 ≈ 2N，合计约 4N；加上前向的 2N，就是 6N。

阶段	每个参数 FLOPs	Llama 2 7B 单 token
前向	2	13.5 GFLOPs
反向	4	27.0 GFLOPs
合计	6	40.4 GFLOPs

再乘训练 token 数 D，就是 C = 6ND：6 × 6.74e9 × 1e12 ≈ 4.04 × 10²² FLOPs。

3.这条 2N 规则算得准吗？忽略了什么？▾

它只统计权重矩阵的乘加，忽略 attention 的 O(L²) 项、激活函数和归一化。短上下文下误差小，上下文越长 attention 项越大。

计算项	2N 是否计入	何时变大
权重矩阵乘加	计入	始终是主项
attention 打分与加权（∝ L²）	未计入	上下文越长越大
激活 / 归一化	未计入	占比很小

经验上（估算，需人工核实）：L 为几百 token 时两者相差不到 10%；L 到数千时 attention 项开始追上 2N。

4.一次 1000 token 的 prompt，prefill 要花多少算力？和逐 token 生成比呢？▾

prefill 把 1000 个 token 一次性过前向，按 2N 算就是 1000 倍的单 token 算力；decode 每步只算 1 个新 token。

场景	计算	结果
prefill 1000 token	1000 × 2 × 6.74e9	13.5 TFLOPs
生成 100 token	100 × 2 × 6.74e9	1.35 TFLOPs

所以长 prompt 的首 token 延迟（prefill）通常远大于后续每个 token 的生成延迟——这也是「首 token 时间」和「每 token 时间」要分开测的原因。

5.换个模型怎么口算？7B、13B、70B 差多少？▾

把参数量代进 2N（前向）或 6N（训练）即可，规模线性放大。

模型	参数量 N	单 token 前向 2N	单 token 训练 6N
Llama 2 7B	6.74e9	13.5 GFLOPs	40.4 GFLOPs
Llama 2 13B	13e9	26.0 GFLOPs	78.0 GFLOPs
Llama 2 70B	70e9	140 GFLOPs	420 GFLOPs

注意 2N/6N 是量级估算，未计入 attention 的 O(L²) 项与各层结构差异；70B 用的是 GQA（Grouped-Query Attention，分组查询注意力：多个 Query 头共享一组 K、V），KV 头更少，但 2N 估算仍然成立。

FFN 的中间维是 11008——这个怪数字到底是怎么定出来的？

提示：先看标准 FFN 用几个矩阵、中间维取多少；再看 SwiGLU 用几个矩阵。要让两者的参数量相当，中间维该怎么变？

▾

知识背景

FFN（Feed-Forward Network，前馈网络：每个 Block 里负责「记忆」的子层）的中间维惯例取 4d——标准 FFN 用 2 个矩阵，中间维是模型维度 d 的 4 倍（原论文 d_model=512 → 中间维 2048）。SwiGLU（Swish-Gated Linear Unit，用 SiLU 做门控的 GLU 变体，由 Shazeer《GLU Variants Improve Transformer》, arXiv:2002.05202, 2020 提出）改用 3 个矩阵（gate/up/down）。3 个矩阵要凑出与标准 FFN 相同的参数量，中间维就必须缩到 2/3——这正是 11008 的来历。

上一张卡片我们用 2N 规则算出了单 token 的算力，也看到参数量几乎都压在 FFN 里；现在回到「这些参数从哪来」这一侧，把 FFN 那个 11008 拆开看。它不是随手取的整数，而是「参数量守恒」倒推出来的结果。先看两种更省事的做法，恰好都不成立：一是不升维（中间维取 d），两个矩阵只有 2 × 4096² ≈ 33.6M，是 4d 版本 134.2M 的约 1/4；二是省掉一个矩阵（gate/up/down 只留两个），配 11008 只剩 2 × 4096 × 11008 ≈ 90.2M，比守恒点 135.3M 少 45.1M/层。而 FFN 正是每层参数的大头（约 2/3），这两刀都会直接砍在「知识存储」的容量上。

道理就像把一份工作量分给不同人数：标准 FFN 是 2 个人干活（2 个矩阵），SwiGLU 是 3 个人干（3 个矩阵）——想让总工作量不变，每个人（每个矩阵的中间维）就得按比例缩到原来的 2/3。

🧮 从「2 个矩阵」到「3 个矩阵」：11008 的推导

Step 1：标准 FFN 的账——2 个矩阵，中间维 4d

矩阵	形状	参数
W1（升维）	[d, 4d]	4d²
W2（降维）	[4d, d]	4d²
合计	2 × d × 4d = 8d²	8 × 4096² = 134.2M

d = 4096 时，标准 FFN 每层 8d² = 134.2M 参数——这就是 SwiGLU 要「对齐」的目标。

Step 2：SwiGLU 有 3 个矩阵，中间维要缩到 8/3·d

矩阵	形状	参数
gate_proj	[d, d_ff]	d·d_ff
up_proj	[d, d_ff]	d·d_ff
down_proj	[d_ff, d]	d_ff·d
合计	3 × d × d_ff	待定

令 3·d·d_ff = 8d²，解得 d_ff = 8/3·d = 8/3 × 4096 ≈ 10922.7。

Step 3：实际取 11008——向上对齐到 256 的整数倍

步骤	计算	结果
2/3 规则	8/3 × 4096	10922.7
除以 256	10922.7 / 256	42.67
向上取整再乘回	43 × 256	11008
每层 FFN 参数	3 × 4096 × 11008	135.3M

对齐到 256 的整数倍（43 × 256 = 11008）是为切分粒度留余量——这一点属工程惯例，需人工核实（不要把它理解成"256 = 头数 × 每头维度"，那是 4096）。

Step 4：算一笔对比账——为什么不能随便改这个数

方案	每层 FFN 参数	与 11008 之差	32 层合计
3 矩阵 × 11008（实际）	3 × 4096 × 11008 = 135.3M	基准	4.33B
3 矩阵 × 16384（若用 4d）	3 × 4096 × 16384 = 201.3M	+66.0M	6.44B
2 矩阵 × 11008（少一个矩阵）	2 × 4096 × 11008 = 90.2M	−45.1M	2.89B

取 4d 会让 32 层多花 2.11B 参数；少一个矩阵又会少 45.1M/层、参数量不再守恒。11008 正好卡在「3 个矩阵 × 2/3 中间维」这一点上。

🎯 关键认知：11008 是「参数量守恒」倒推出来的

它 = 4096 × 8/3 再向上对齐到 256 的整数倍，目的只有一个：让 SwiGLU 的 3 个矩阵加起来（3·d·d_ff ≈ 8d²）与标准 FFN 的 2 个矩阵（2·d·4d = 8d²）持平。同一套账换个模型照样套——把 d 换掉重算即可；不同实现会在此基础上调（如 Llama 3 8B 用 14336，比 8/3·d 更大，以换取更强表达力）。

AI 助教

👋 对 FFN 中间维有疑问？比如「为什么是 8/3 而不是 4？」「11008 为什么对齐到 256 的倍数？」「Llama 3 为什么用 14336？」

我会用具体数字帮你算。

🤔 学生最可能追问的 5 个问题

1.标准 FFN 的中间维为什么惯例取 4d？▾

这是原论文沿用的惯例：中间维取模型维度 d 的 4 倍，2 个矩阵配 4d 中间维，每层参数 = 2·d·4d = 8d²。

d_model	中间维 4d	每层 FFN（2 矩阵）
512（原论文）	2048	2×512×2048 = 2.10M = 8×512²
4096（Llama 2 7B）	16384	2×4096×16384 = 134.2M = 8×4096²

两个规模下都满足 8d²，说明 4d 是「按 d 等比缩放」的惯例，不是固定常数。

2.8/3 这个系数是怎么推出来的？▾

设中间维为 m·d，让 SwiGLU（3 矩阵）的参数与标准 FFN（2 矩阵、4d）相等即可解出 m。

结构	每层 FFN 参数
标准 FFN（2 矩阵）	2·d·4d = 8d²
SwiGLU（3 矩阵）	3·d·(m·d) = 3md²
令两者相等	3m = 8 → m = 8/3 ≈ 2.67

所以中间维 = 8/3·d。d = 4096 时 = 10922.7。这正是 Shazeer 论文里「把中间维缩到 2/3」那句话的来源（原文：reduce the number of hidden units d_ff by a factor of 2/3）。

3.为什么实际取 11008，而不是 10922.7？▾

因为要向上对齐到 256 的整数倍，方便张量并行把中间维切成整齐的块。

值	计算	结果
2/3 规则	8/3 × 4096	10922.7
除以 256	10922.7 / 256	42.67
向上取整再乘回	43 × 256	11008
多出来的	11008 − 10922.7	85.3（约占 0.8%）

「对齐到 256 是为了切分方便」属工程惯例（需人工核实）；但 11008 = 43 × 256 这个整除关系是确定的。

4.如果中间维直接取 4d = 16384，会多多少参数？▾

会明显变胖：3 个矩阵配 4d 中间维，每层比 11008 多 66.0M，32 层多 2.11B。

中间维	每层 FFN（3 矩阵）	32 层合计
11008	3×4096×11008 = 135.3M	4.33B
16384（4d）	3×4096×16384 = 201.3M	6.44B
差额	66.0M	2.11B

2.11B 约占整个 6.74B 的 31%——直接用 4d 会让模型「虚胖」近三分之一，这也是为什么要按 2/3 缩中间维。

5.为什么不能只用两个矩阵配 11008？▾

因为两矩阵配 11008 就不再与标准 FFN 的 8d² 守恒了：每层只有 90.2M，比 135.3M 少 45.1M。

结构	每层 FFN 参数	折合
2 矩阵 × 4d（标准 FFN）	134.2M	8d²（基准）
2 矩阵 × 11008	2×4096×11008 = 90.2M	≈5.38d²
3 矩阵 × 11008（SwiGLU）	3×4096×11008 = 135.3M	≈8.06d²

少一个矩阵就少 45.1M/层——门控（gate）提供「选择性通过」的能力正是靠这个额外矩阵换来的。所以「怪数字」11008 本质上是为了让 3 个矩阵的总参数回到 8d² 这个守恒点。

人人都说「7B 模型」——这个 7,000,000,000 到底是怎么一块一块加出来的？

提示：别盯着总数看。先把模型拆成首尾两张表 + 中间 32 层，每层再拆成 Attention 和 FFN 两块——数一数每一块是几×几的矩阵，再把它们加起来，总数自己就浮出来了。

▾

知识背景

Llama 2 由 Meta 于 2023 年 7 月发布（Touvron et al., 2023）。7B 版本公布的配置是：hidden_size（隐藏层维度，每个 token 向量的长度）=4096、32 层、32 个注意力头、FFN（Feed-Forward Network，每层负责「记忆」的前馈子层）中间维 11008、词表 32000；官方标称参数量 6.74B，四舍五入就叫「7B」。痛点：做显存估算时只知道「7B」这一个总数远远不够——你会算不清这 6.74B 到底压在哪些矩阵上、哪一块动一下总账就跟着动。

上一张卡片我们把 32 层 Block 接成了一条主干；现在走到整条流水线的最后一步——把 [1, 2, 4096] 的隐藏向量变成下一个词的预测，这一步靠 LM Head（把隐藏向量投影成词表概率分布的输出层）。

这一节不数 tensor 形状，而是回答一个更实在的问题：所谓「7B」，就是把这些矩阵一笔一笔乘出来再加总——首尾各一张 32000×4096 的大表，加上中间 32 层的 Attention 和 FFN。可以把它类比成装修算总价：首尾两张表是门和窗（各算一张），32 层 Block 是 32 间房，每间房里再分「Attention 区」和「FFN 区」，把单间用料乘以 32 再加门窗，就是总数。

🧮 把 6.74B 一块一块乘出来加总

Step 1：先摆出 Llama 2 7B 的全部超参

参数	值	含义
hidden_size（d）	4096	每个 token 的向量长度
num_hidden_layers	32	Block 层数
num_attention_heads	32	注意力头数
num_key_value_heads	32	等于头数 → 用的是 MHA（Multi-Head Attention，多头注意力：每个 Q 头都配一份独立的 K、V，不降维）
intermediate_size	11008	FFN 中间维
vocab_size	32000	词表大小
官方参数量	6.74B	本文要逐块加出来的目标数

注意：Llama 2 的 7B 用的是 MHA（kv 头 = 32，K/V 不降维）；改用 GQA（Grouped-Query Attention，分组查询注意力：多个 Q 头共享一组 K、V）的是 34B / 70B。

Step 2：每层 Attention — 4 个 4096×4096 矩阵

矩阵	形状	参数
W_q	4096 × 4096	16.78M
W_k	4096 × 4096	16.78M
W_v	4096 × 4096	16.78M
W_o	4096 × 4096	16.78M
合计	4 × 4096×4096 = 4 × 16.78M	67.11M

4096 × 4096 = 16,777,216 ≈ 16.78M。因为是 MHA，K、V 也保持满维 4096，所以是 4 个同样大的矩阵。

Step 3：每层 FFN — SwiGLU 的 3 个矩阵

矩阵	形状	参数
gate_proj	4096 × 11008	45.09M
up_proj	4096 × 11008	45.09M
down_proj	11008 × 4096	45.09M
合计	3 × 4096×11008 = 3 × 45.09M	135.27M

SwiGLU（门控前馈网络：用一个 gate 分支控制信息通过量）用三个矩阵，所以 FFN 比 Attention 更「胖」。

Step 4：每层合计，乘 32 层

账目	计算	参数
每层 Attention	—	67.11M
每层 FFN	—	135.27M
每层合计	67.11M + 135.27M	202.38M
32 层	202.38M × 32	6,476.01M

Step 5：再加上首尾两张词表，对账 6.74B

账目	计算	参数
32 层 Block	202.38M × 32	6,476.01M
Embedding	32000 × 4096	131.07M
LM Head	32000 × 4096	131.07M
RMSNorm	32×2×4096 + 4096	0.27M
总计	6,476.01M + 131.07M + 131.07M + 0.27M	6,738.42M ≈ 6.74B
两张表占比	(131.07M + 131.07M) / 6,738.42M	≈ 3.9%
若共享省下	131.07M / 6,738.42M	≈ 1.9%

6.74B 不是估的：它 = 32 层的 Attention + FFN，加上首尾两张各 131.07M 的词表，再加可忽略的 RMSNorm。

🎯 关键认知

「7B」不是一个大概的数字，而是每一块矩阵乘出来加总的结果：32 层的 Attention + FFN 吃掉了约 96%，首尾两张词表各占 1.95%。其中 LM Head（把隐藏向量投影成词表概率的输出层）和 Embedding 是两张独立的大表——Llama 2 没有做 weight tying（权重绑定：让输入查表和输出投影共用同一份矩阵）；如果共享，就能省下 131.07M ≈ 1.9% 的参数。这也解释了工程上为什么要权衡「词表大小」和「是否共享」：词表越大，首尾两张表越贵。

AI 助教

👋 对「7B 到底怎么算出来」有疑问？比如「MHA 换成 GQA 会少多少参数？」「weight tying 省下的 1.9% 值不值？」「Llama 3 8B 的 8.03B 怎么来的？」

我会用具体数字帮你算。

🤔 学生最可能追问的 5 个问题

1.Llama 2 7B 用 MHA，为什么 34B/70B 改用 GQA？两者差多少参数？▾

MHA（Multi-Head Attention，多头注意力：每个 Q 头都配一份独立的 K、V）里 K、V 不降维，所以 7B 每层要 4 个 4096×4096 矩阵。

Step 1：7B（MHA，kv 头 = 32）

项	形状	参数
Q	4096×4096	16.78M
K	4096×4096	16.78M
V	4096×4096	16.78M
O	4096×4096	16.78M
合计	4 个满维矩阵	67.11M

Step 2：假设 7B 改成 kv 头 = 8 的 GQA（Grouped-Query Attention，分组查询注意力：多个 Q 头共享一组 K、V）

项	形状	参数
Q	4096×4096	16.78M
K	4096×1024（8 头 × 128）	4.19M
V	4096×1024	4.19M
O	4096×4096	16.78M
合计	K、V 各降 8 倍	41.94M

每层省 67.11M − 41.94M = 25.17M，32 层省约 805M。7B 坚持 MHA，是因为 GQA 的真正收益在推理时把 KV Cache（缓存历史 token 的 K、V 以免重算）压小，而不是省这点训练参数——所以它主要用在大模型上。

2.Embedding 和 LM Head 共享（weight tying）能省多少？6.74B 会变成多少？▾

weight tying（权重绑定：让 Embedding 和 LM Head 共用同一份矩阵，输入查表和输出投影共享参数）能省下整整一张 131.07M 的表。

方案	Embedding	LM Head	总参数
Llama 2 7B（不共享）	131.07M	131.07M	6.74B
假设共享	131.07M	0（复用）	6.61B
差额	—	省 131.07M	省约 1.9%

6,738.42M − 131.07M = 6,607.34M ≈ 6.61B；省下比例 131.07M / 6,738.42M ≈ 1.95% ≈ 1.9%。

3.为什么 FFN 中间维是 11008 而不是 8192？这一项差多少参数？▾

11008 来自 8/3 × 4096 ≈ 10923，再向上取整到 256 的整数倍。把它换成 8192 会明显缩水：

中间维	每层 FFN（3 个矩阵）	32 层合计
11008	3 × 4096 × 11008 = 135.27M	4.329B
8192	3 × 4096 × 8192 = 100.66M	3.221B
差额	34.60M	1.107B

每层差 135.27M − 100.66M = 34.60M，32 层差 1.107B——约占整个 6.74B 的 16%。FFN 是参数最重的地方，中间维一动，总账就跟着动。

4.官方的 6.74B 和我一块一块加出来的数对得上吗？差额去哪了？▾

对得上。逐块相加（M = 百万）：

账目	计算	参数
32 层 Block	202.38M × 32	6,476.01M
Embedding	32000 × 4096	131.07M
LM Head	32000 × 4096	131.07M
RMSNorm	32 × 2 × 4096 + 4096	0.27M
总计	—	6,738.42M ≈ 6.74B

6,476.01M + 131.07M + 131.07M + 0.27M = 6,738.42M = 6.738B，四舍五入 6.74B——与官方数字一致。「7B」不是估的，就是这些矩阵乘出来加总的结果。

5.换个大模型，这套加法变吗？比如 Llama 3 8B。▾

不变，只是每项的数字换掉。Llama 3 8B：d=4096、32 层、FFN=14336、词表 128256，而且用了 kv 头 = 8 的 GQA。

账目	计算	参数
每层 Attention（GQA）	2×4096×4096 + 2×4096×1024	41.94M
每层 FFN	3 × 4096 × 14336	176.16M
32 层	218.10M × 32	6,979.32M
Embedding + LM Head	2 × 128256 × 4096	1,050.67M
总计	—	8,029.99M ≈ 8.03B

6,979.32M + 1,050.67M = 8,029.99M ≈ 8.03B，正是官方公布的 Llama 3 8B 参数量。词表从 32000 涨到 128256 后，首尾两张表从 262M 涨到 1,050.67M——占比从约 3.9% 升到约 13%。