---
tags: [AI, LLM, llama2, 架构]
阶段: 05-Transformer与LLM原理
难度: ★★★
created: 2026-10-18
related: "[[Transformer架构详解]], [[分组查询注意力GQA]], [[位置编码-正弦与RoPE]], [[对齐-RLHF]]"
---

# Llama-2架构复盘

## 定义

**Llama 2** 是 Meta 于 2023 年发布权重的一组仅解码器（decoder-only）自回归语言模型，已发布规模为 7B、13B、70B；每个模型由 $L$ 个结构相同的解码器层堆叠，每层以 Pre-Norm 方式组合因果自注意力子层与 SwiGLU 前馈子层，位置信息由旋转位置编码（rotary position embedding，RoPE）施加在查询与键上，序列末端经 RMSNorm 与线性投影输出下一个 token 在词表上的条件分布。

本篇符号约定如下。

| 符号 | 含义 |
|---|---|
| $L$ | 解码器层数 |
| $d$ | 残差流维度，即 $d_{\text{model}}$ |
| $h$ | 查询头数 |
| $h_{kv}$ | 键值头数，$h_{kv}\le h$ |
| $d_{\text{head}}$ | 单个头的维度，$d_{\text{head}}=d/h$ |
| $d_{\text{ff}}$ | SwiGLU 的中间维度 |
| $V$ | 词表大小 |
| $T$ | 序列长度 |
| $\epsilon$ | RMSNorm 分母中的数值稳定项 |
| $\boldsymbol{\gamma}$ | RMSNorm 的逐维缩放参数 |
| $\mathbf{W}_{Q},\mathbf{W}_{K},\mathbf{W}_{V},\mathbf{W}_{O}$ | 注意力的查询、键、值、输出投影矩阵 |
| $\mathbf{W}_{g},\mathbf{W}_{u},\mathbf{W}_{d}$ | SwiGLU 的门控、上投影、下投影矩阵 |
| $\theta_{i}$ | RoPE 第 $i$ 个维度对的旋转角频率 |
| $\mathbf{x}_{l}$ | 第 $l$ 层输入的残差流，形状 $(T,d)$ |

其余术语在首次出现处定义。**Pre-Norm** 指先对子层输入做归一化、再把子层输出加回残差流；**RMSNorm** 指仅按均方根缩放、不做均值中心化也不含偏置的归一化；**SwiGLU** 指以 Swish 激活的门控线性单元前馈网络；**RoPE** 指把位置信息编码为查询与键的旋转相位；**分组查询注意力**（grouped-query attention，GQA）指多个查询头共享一组键值头的注意力；**因果掩码**指把位置 $j>i$ 的注意力分数置为 $-\infty$ 的上三角掩码。

## 为什么重要

Llama 2 是 2023 年之后开源权重模型最常用的对照基线。它的组件组合（RMSNorm、SwiGLU、RoPE、GQA）被 Mistral、Qwen、DeepSeek 等模型族广泛采用，读懂它的每个子层，就覆盖了当前多数仅解码器模型的结构组成。反过来，若把它当作原始 Transformer 的直接复制，会在参数量、显存与训练稳定性三方面同时算错。

具体到每项改动的必要性。

第一，深度。7B 有 32 层，70B 有 80 层。Post-LN 结构中，反向传播要穿过每层的 LayerNorm 雅可比，层数增加时梯度尺度的方差累积，必须依赖精细的学习率预热；Pre-Norm 把归一化移到子层入口，残差路径上保留恒等映射，梯度可以沿恒等路径直接回传，这是 80 层可以稳定训练的结构前提。详见 [[Transformer架构详解]] 对两种排列的梯度展开。

第二，归一化开销。RMSNorm 去掉均值中心化与平移参数，每层少一次沿特征维的归约和一次减法，参数量从 $2d$ 降到 $d$。在 80 层、每层两次归一化的模型里，这项开销随层数线性累加，而 Llama 2 的所有线性层不含偏置，使放弃平移不变性的代价很小。

第三，前馈网络的参数效率。若沿用 ReLU 前馈网络并取 $d_{\text{ff}}=4d$，7B 的 FFN 参数量为 $8d^{2}=1.342\times 10^{8}$；SwiGLU 用三个投影，把宽度压到 $\tfrac{8}{3}d$ 后参数量几乎相同，但在同等计算预算下语言建模困惑度更低（Shazeer 2020 的报告）。这意味着同等参数量下每个参数承担了更有效的非线性。

第四，位置编码的外推与实现。学习式绝对位置嵌入把每个位置绑定到一个向量，位置数固定；RoPE 把相对位移编码为旋转角差，注意力分数只依赖 $m-n$，不需要位置嵌入表，也不增加参数。4096 的上下文长度由训练时的序列长度决定，而非结构上限。

第五，解码期显存。70B 若使用 64 个键值头的多头注意力，单 token 的 KV 缓存为 $2\cdot 80\cdot 64\cdot 128\cdot 2$ 字节 $=2.5$ MiB；批 32、上下文 4096 时约 320 GiB，单机无法容纳。GQA 把键值头降到 8 个，同一配置降到约 40 GiB。这不是精度取舍，而是 70B 能否以合理批量在线服务的前提，显存公式见 [[KV缓存]]。

在本库中的位置：本篇承接 [[Transformer架构详解]] 的层结构与 [[位置编码-正弦与RoPE]] 的旋转推导，把组件替换为 Llama 2 的具体配置，并给出可与公布权重逐位核对的参数量算法；下游是 [[预训练-微调-对齐pipeline]]，该篇说明这套结构如何被 2T token 的预训练与 RLHF 使用。对应学习目标中的“懂原理”（每个改动的动机与公式）、“能复现”（可运行的模块与参数核对）、“会评估”（规格表与显存、计算量的量级判断）。

## 原理与推导

### 1 模型规格

论文表 2 给出 7B、13B、34B、70B 四个配置，其中 34B 未发布权重。已发布三个规模的规格如下。

| 规格 | 7B | 13B | 70B |
|---|---|---|---|
| 层数 $L$ | 32 | 40 | 80 |
| $d$ | 4096 | 5120 | 8192 |
| 查询头数 $h$ | 32 | 40 | 64 |
| 键值头数 $h_{kv}$ | 32 | 40 | 8 |
| $d_{\text{head}}$ | 128 | 128 | 128 |
| $d_{\text{ff}}$ | 11008 | 13824 | 28672 |
| 上下文长度 | 4096 | 4096 | 4096 |
| 词表 $V$ | 32000 | 32000 | 32000 |
| 参数量（含嵌入） | 6.74B | 13.02B | 69.0B |
| 训练 token | 2.0T | 2.0T | 2.0T |
| 峰值学习率 | $3.0\times10^{-4}$ | $3.0\times10^{-4}$ | $1.5\times10^{-4}$ |
| GQA | 否 | 否 | 是 |
| $\epsilon$ | $10^{-5}$ | $10^{-5}$ | $10^{-5}$ |
| RoPE base | $10^{4}$ | $10^{4}$ | $10^{4}$ |

三个规模的 $d_{\text{head}}$ 都等于 128。这是有意固定：头维度恒定时，注意力分数的数值尺度、RoPE 的频率表与 FlashAttention 的块大小都可以跨规模复用。

$d_{\text{ff}}$ 不直接取 $4d$，而按“参数量对齐 + 256 的整数倍”确定：

$$
d_{\text{ff}}=256\cdot\left\lceil\frac{\tfrac{8}{3}\,d\,m}{256}\right\rceil ,
$$

其中 $m$ 为论文的 `ffn_dim_multiplier`，7B 与 13B 取 1，70B 取 1.3。代入可得：7B 为 $256\cdot\lceil 42.67\rceil=11008$；13B 为 $256\cdot\lceil 53.33\rceil=13824$；70B 按 $m=1.3$ 得 $256\cdot\lceil 110.93\rceil=28416$。发布的 70B 权重实际使用 $28672=112\times 256$，比公式值高一个 256 的档位；以权重配置为准时，参数总量才与论文公布的 69.0B 吻合（第 8 节核对）。这一点说明公式是实现约定，发布配置才是最终事实。

词表 32000，来自 SentencePiece 实现的 BPE，数字被拆成单个数字，未知 UTF-8 字符回退到字节。分词细节见 [[Tokenizer与BPE]]。

### 2 与原始 Transformer 解码器的逐项差异

原始解码器层为 $\mathbf{x}\leftarrow\mathrm{LayerNorm}(\mathbf{x}+\mathrm{MHA}(\mathbf{x}))$、$\mathbf{x}\leftarrow\mathrm{LayerNorm}(\mathbf{x}+\mathrm{FFN}(\mathbf{x}))$，位置信息由正弦编码或学习式嵌入在入口相加，多头注意力的键值头数等于查询头数，线性层带偏置。

| 项目 | 原始 Transformer 解码器 | Llama 2 |
|---|---|---|
| 归一化位置 | Post-LN | Pre-Norm |
| 归一化函数 | LayerNorm（均值 + 方差，含 $\boldsymbol{\beta}$） | RMSNorm（仅均方根，仅 $\boldsymbol{\gamma}$） |
| 前馈网络 | $\mathrm{ReLU}(\mathbf{x}\mathbf{W}_{1})\mathbf{W}_{2}$，$d_{\text{ff}}=4d$ | $\bigl(\mathrm{Swish}(\mathbf{x}\mathbf{W}_{g})\odot(\mathbf{x}\mathbf{W}_{u})\bigr)\mathbf{W}_{d}$，$d_{\text{ff}}\approx\tfrac{8}{3}d$ |
| 位置编码 | 正弦或学习式，在嵌入层相加 | RoPE，施加在每层的 $\mathbf{Q},\mathbf{K}$ 上 |
| 注意力头配置 | 多头，$h_{kv}=h$ | 7B/13B 为多头，70B 为 GQA（$h=64,h_{kv}=8$） |
| 线性层偏置 | 有 | 全部无 |
| 注意力输出之后 | 通常接 dropout | 无 dropout |
| 嵌入与输出投影 | 可共享权重 | 不共享 |
| 结构范围 | 编码器-解码器，含交叉注意力 | 仅解码器，无交叉注意力 |
| 训练上下文 | 512（原论文）至 1024（GPT-2） | 4096 |

这些差异可以归到两类。第一类改变参数化方式：RMSNorm、SwiGLU、RoPE、无偏置、权重不共享，它们改变的是每个参数的形状与梯度通路。第二类改变计算与显存：GQA、无 dropout、FlashAttention 式融合核。两类都不改变训练目标，目标仍是因果语言建模的交叉熵。

### 3 Pre-Norm 与 RMSNorm

设第 $l$ 层的子层函数为 $F_{l}$，Post-LN 与 Pre-Norm 的递推分别为

$$
\mathbf{x}_{l+1}=\mathrm{Norm}\bigl(\mathbf{x}_{l}+F_{l}(\mathbf{x}_{l})\bigr),\qquad
\mathbf{x}_{l+1}=\mathbf{x}_{l}+F_{l}\bigl(\mathrm{Norm}(\mathbf{x}_{l})\bigr).
$$

对 Pre-Norm 求导：

$$
\frac{\partial\mathbf{x}_{L}}{\partial\mathbf{x}_{l}}=\prod_{k=l}^{L-1}\left(\mathbf{I}+\frac{\partial F_{k}\bigl(\mathrm{Norm}(\mathbf{x}_{k})\bigr)}{\partial\mathbf{x}_{k}}\right).
$$

展开后含一个恒等项 $\mathbf{I}$ 与若干个雅可比乘积。即使每个 $\partial F_{k}/\partial\mathbf{x}_{k}$ 的谱范数略小于 1，恒等项保证梯度不会连乘衰减到零；Post-LN 的乘积中没有这个恒等项，梯度必须穿过每层的归一化雅可比。代价是 Pre-Norm 的残差流范数随深度增长，因此 Llama 2 在最后一层之后、输出投影之前再加一次 RMSNorm，否则 logits 的尺度随 $L$ 漂移。

RMSNorm 的定义为

$$
\mathrm{RMSNorm}(\mathbf{x})=\frac{\mathbf{x}}{\sqrt{\tfrac{1}{d}\sum_{i=1}^{d}x_{i}^{2}+\epsilon}}\odot\boldsymbol{\gamma},
$$

其中 $\odot$ 为逐元素乘，$\boldsymbol{\gamma}\in\mathbb{R}^{d}$ 初始化为全 1，$\epsilon$ 加在均方内部、开方之前。记 $\mathrm{RMS}(\mathbf{x})=\sqrt{\mathrm{mean}(x_{i}^{2})}$，则输出满足 $\mathrm{mean}\bigl((\mathrm{RMSNorm}(\mathbf{x})/\boldsymbol{\gamma})^{2}\bigr)=1$（忽略 $\epsilon$），即每个 token 的表示被缩放到固定均方根。

与 LayerNorm 的差异有四项，逐项可检验。

| 项目 | LayerNorm | RMSNorm |
|---|---|---|
| 统计量 | 均值 $\mu$ 与方差 $\sigma^{2}$ | 仅均方值 $\mathrm{mean}(x^{2})$ |
| 中心化 | 减去 $\mu$ | 不减 |
| 可学习参数 | $\boldsymbol{\gamma},\boldsymbol{\beta}$，共 $2d$ | $\boldsymbol{\gamma}$，共 $d$ |
| 平移不变性 | 有：$\mathrm{LN}(\mathbf{x}+c\mathbf{1})=\mathrm{LN}(\mathbf{x})$ | 无 |
| 缩放不变性 | 有 | 有 |
| 每 token 归约次数 | 两次（均值、方差） | 一次（均方） |

论文给出的假设是：LayerNorm 的平移不变性对层内优化并非必要，重中心化主要抵消前一层偏置的影响；当所有线性层不含偏置时，这一项收益下降，而两次归约的同步开销在深层网络中不可忽略。Zhang 与 Sennrich 报告在若干任务上 RMSNorm 的训练与推理更快且效果不降。

实现上有两个细节必须与权重对齐。其一，$\epsilon$ 在开方之内：$1/\sqrt{\mathrm{mean}(x^{2})+\epsilon}$，不是 $1/(\sqrt{\mathrm{mean}(x^{2})}+\epsilon)$。其二，混合精度训练时均方应在 fp32 中累加，否则 fp16 下 $x^{2}$ 容易上溢。

### 4 SwiGLU 前馈网络

原始前馈网络为

$$
\mathrm{FFN}_{\text{ReLU}}(\mathbf{x})=\mathrm{ReLU}(\mathbf{x}\mathbf{W}_{1})\mathbf{W}_{2},\quad
\mathbf{W}_{1}\in\mathbb{R}^{d\times d_{\text{ff}}},\ \mathbf{W}_{2}\in\mathbb{R}^{d_{\text{ff}}\times d},
$$

参数量 $2dd_{\text{ff}}$，取 $d_{\text{ff}}=4d$ 时为 $8d^{2}$。

SwiGLU 为

$$
\mathrm{FFN}_{\text{SwiGLU}}(\mathbf{x})=\bigl(\mathrm{Swish}(\mathbf{x}\mathbf{W}_{g})\odot(\mathbf{x}\mathbf{W}_{u})\bigr)\mathbf{W}_{d},
$$

其中 $\mathrm{Swish}(z)=z\cdot\sigma(z)$，$\sigma$ 为 logistic 函数；$\mathbf{W}_{g},\mathbf{W}_{u}\in\mathbb{R}^{d\times d_{\text{ff}}}$，$\mathbf{W}_{d}\in\mathbb{R}^{d_{\text{ff}}\times d}$，参数量 $3dd_{\text{ff}}$。

为使 SwiGLU 的参数量与 $d_{\text{ff}}=4d$ 的 ReLU 前馈网络相同，令

$$
3dd_{\text{ff}}=8d^{2}\ \Longrightarrow\ d_{\text{ff}}=\frac{8}{3}d .
$$

7B 的 $d=4096$，$\tfrac{8}{3}d=10922.67$，向上取 256 的整数倍得 11008；此时 FFN 参数量为 $3\cdot 4096\cdot 11008=135{,}266{,}304$，而 $8d^{2}=134{,}217{,}728$，相对差 $+0.78\%$，来自取整。

门控的作用是让中间维的每个通道获得一个由另一组投影计算的、依赖输入的缩放系数：$\mathrm{Swish}(\mathbf{x}\mathbf{W}_{g})$ 的第 $j$ 个分量乘到 $\mathbf{x}\mathbf{W}_{u}$ 的第 $j$ 个分量上，等价于对 $\mathbf{W}_{u}$ 的每个输出通道施加输入相关的增益。ReLU 前馈网络的非线性只由逐元素阈值提供，通道之间不交互；门控在参数量相同的约束下多引入一个投影，把宽度压窄，从而在同一预算内改变“宽度换深度”的分配。

Llama 2 的实现顺序是固定的：先对 `gate_proj` 的输出做 SiLU，再与 `up_proj` 的输出逐元素相乘，最后过 `down_proj`。`gate_proj` 与 `up_proj` 形状相同、可互换位置，但互换会改变函数值，因为激活只作用于其中一支。

### 5 RoPE 位置编码

RoPE 不把位置向量加到嵌入上，而是对每一层的查询与键按位置做旋转。把 $d_{\text{head}}$ 维的查询向量划分为 $d_{\text{head}}/2$ 个二维对，第 $i$ 对的旋转角为 $m\theta_{i}$，$m$ 为位置，频率

$$
\theta_{i}=10000^{-2i/d_{\text{head}}},\qquad i=0,1,\dots,\frac{d_{\text{head}}}{2}-1 .
$$

对二维对 $(x_{2i},x_{2i+1})$：

$$
\begin{pmatrix}x'_{2i}\\ x'_{2i+1}\end{pmatrix}
=
\begin{pmatrix}\cos m\theta_{i} & -\sin m\theta_{i}\\ \sin m\theta_{i} & \cos m\theta_{i}\end{pmatrix}
\begin{pmatrix}x_{2i}\\ x_{2i+1}\end{pmatrix}.
$$

记该 $2\times2$ 旋转为 $\mathbf{R}(m\theta_{i})$，整头旋转矩阵 $\mathbf{R}_{m}$ 为这些块的直和。旋转矩阵满足 $\mathbf{R}(a)^{\top}\mathbf{R}(b)=\mathbf{R}(b-a)$，于是

$$
\mathbf{q}_{m}^{\top}\mathbf{k}_{n}
=\bigl(\mathbf{R}_{m}\mathbf{q}\bigr)^{\top}\bigl(\mathbf{R}_{n}\mathbf{k}\bigr)
=\mathbf{q}^{\top}\mathbf{R}_{n-m}\mathbf{k},
$$

即点积只依赖相对位移 $n-m$，与绝对位置无关。这是 RoPE 与学习式绝对位置嵌入的本质差别：后者需要为每个绝对位置学习一个向量，位置数受训练长度限制；前者由旋转的群结构给出相对性，且不增加任何参数。

Llama 2 的工程约定有三点。其一，base 固定为 $10^{4}$，三个规模相同；频率表在训练前算好并按最大长度缓存 cos/sin。其二，旋转只作用于 $\mathbf{Q}$ 与 $\mathbf{K}$，不作用于 $\mathbf{V}$；值向量不参与打分，旋转它只会改变输出基。其三，Hugging Face 实现采用“前后两半配对”而非“相邻配对”：维度 $i$ 与 $i+64$ 配对，角度仍为 $\theta_{i}$。两种配对方式相差一个固定的维度置换，在权重按同一约定训练时结果一致，混用则等价于打乱频率与维度的对应关系。

上下文长度 4096 由训练序列长度决定。RoPE 本身不限制长度，但外推到训练长度之外时，高频维度的相位差超出训练分布，注意力分数失真；[[超长上下文-无限注意力]] 讨论的插值与压缩方法正是针对这一点。

### 6 分组查询注意力

多头注意力为每个头各自计算 $\mathbf{Q},\mathbf{K},\mathbf{V}$，$h_{kv}=h$。多查询注意力把 $\mathbf{K},\mathbf{V}$ 压到 1 组，所有查询头共享，显存最省但表达受限。GQA 取中间：把 $h$ 个查询头分成 $h_{kv}$ 组，每组共享一组 $\mathbf{K},\mathbf{V}$。

70B 的配置为 $h=64$、$h_{kv}=8$、$d_{\text{head}}=128$，组大小 $h/h_{kv}=8$。查询头 $i$ 使用键值头

$$
j=\left\lfloor \frac{i}{h/h_{kv}}\right\rfloor ,
$$

即查询头 0 至 7 使用键值头 0，8 至 15 使用键值头 1，依此类推。投影矩阵形状随之为 $\mathbf{W}_{Q}\in\mathbb{R}^{8192\times8192}$、$\mathbf{W}_{K},\mathbf{W}_{V}\in\mathbb{R}^{8192\times1024}$、$\mathbf{W}_{O}\in\mathbb{R}^{8192\times8192}$。

KV 缓存的显存为

$$
M_{\text{kv}}=2\cdot L\cdot h_{kv}\cdot d_{\text{head}}\cdot T\cdot B\cdot b\ \text{字节},
$$

其中因子 2 对应键与值，$B$ 为批大小，$b$ 为每元素字节数。70B 在 fp16（$b=2$）下，单 token 单序列为 $2\cdot80\cdot8\cdot128\cdot2=327{,}680$ 字节 $=320$ KiB；$T=4096$、$B=32$ 时为 $320\ \text{KiB}\times4096\times32=40$ GiB。若改为 64 个键值头，同一配置为 320 GiB。7B 使用 32 个键值头，单 token 为 512 KiB，同配置为 64 GiB，反而高于 70B 的 GQA 配置。

GQA 的代价是每组内的查询头共享同一组键值表示，键值子空间的秩上限从 $h d_{\text{head}}$ 降到 $h_{kv}d_{\text{head}}$。论文报告在同等规模下 GQA 的精度接近多头注意力，而解码吞吐显著提升；[[分组查询注意力GQA]] 给出更细的消融与实现。

### 7 无偏置线性层与因果掩码

Llama 2 的全部线性层（$\mathbf{W}_{Q},\mathbf{W}_{K},\mathbf{W}_{V},\mathbf{W}_{O}$、三个 FFN 投影、输出投影）都不含偏置项。以 7B 计，若加回偏置，单层增加 $4\cdot4096+3\cdot11008=49{,}408$ 个参数，32 层增加约 $1.58\times10^{6}$，相对 6.74B 可以忽略，因此这不是参数量的考虑。主要原因是：RMSNorm 已经移除了均值中心化，偏置提供的平移在归一化后大部分被消除；去掉偏置后线性层可以融合为单个矩阵乘，且残差流中不引入可加常数，数值范围更稳定。

因果掩码在 softmax 之前以加性 $-\infty$ 加入：

$$
\mathbf{A}=\mathrm{softmax}\left(\frac{\mathbf{Q}\mathbf{K}^{\top}}{\sqrt{d_{\text{head}}}}+\mathbf{M}\right),\qquad
M_{ij}=\begin{cases}0,& j\le i\\ -\infty,& j>i\end{cases}.
$$

掩码形状为 $(T,T)$，广播到 $(B,h,T,T)$。工程实现中通常不显式构造 $-\infty$ 矩阵，而由 FlashAttention 的因果开关在块内跳过上三角块；数学上等价。若在 softmax 之后置零，行和不再为 1，输出尺度错误；若掩码转置，模型会看到未来。训练时的样本打包（packing）还需在文档边界额外加掩码，否则后一文档的 token 会注意前一文档。

### 8 参数量逐项计算

以 7B 为例，按组件逐项列出。注意力部分：$\mathbf{W}_{Q}$ 为 $4096\times4096$，$\mathbf{W}_{K},\mathbf{W}_{V}$ 因 $h_{kv}=h=32$ 也是 $4096\times4096$，$\mathbf{W}_{O}$ 为 $4096\times4096$。

| 组件 | 形状 | 参数量 |
|---|---|---|
| `q_proj` | $4096\times4096$ | 16,777,216 |
| `k_proj` | $4096\times4096$ | 16,777,216 |
| `v_proj` | $4096\times4096$ | 16,777,216 |
| `o_proj` | $4096\times4096$ | 16,777,216 |
| `gate_proj` | $4096\times11008$ | 45,088,768 |
| `up_proj` | $4096\times11008$ | 45,088,768 |
| `down_proj` | $11008\times4096$ | 45,088,768 |
| 两个 RMSNorm | $4096\times2$ | 8,192 |
| 单层合计 | | 202,383,360 |
| 32 层合计 | | 6,476,267,520 |
| token 嵌入 | $32000\times4096$ | 131,072,000 |
| 输出投影 | $4096\times32000$ | 131,072,000 |
| 末端 RMSNorm | 4096 | 4,096 |
| 总计 | | 6,738,415,616 |

总计 $6.738\times10^{9}$，与论文公布的 6.74B 及发布权重的参数个数逐位一致。不含嵌入与输出投影的参数量为 $6{,}476{,}271{,}616$，用于计算量估算。

同一算法代入 13B 与 70B：

| 规模 | 单层参数量 | 层数 | 层合计 | 嵌入、输出与末端归一化 | 总计 | 公布值 |
|---|---|---|---|---|---|---|
| 7B | 202,383,360 | 32 | 6,476,267,520 | 262,148,096 | 6,738,415,616 | 6.74B |
| 13B | 317,204,480 | 40 | 12,688,179,200 | 327,685,120 | 13,015,864,320 | 13.02B |
| 70B | 855,654,400 | 80 | 68,452,352,000 | 524,296,192 | 68,976,648,192 | 69.0B |

70B 的一层为：注意力 $8192^{2}+2\cdot8192\cdot1024+8192^{2}=150{,}994{,}944$，FFN $3\cdot8192\cdot28672=704{,}643{,}072$，两个 RMSNorm $16{,}384$，合计 $855{,}654{,}400$。若把 $d_{\text{ff}}$ 误取公式值 28416，总计降为 $68.21$B，与公布值相差 $0.8$B，这个偏差可以作为配置是否读对的检验。

### 9 训练数据、token 规模与优化配置

Llama 2 使用 2.0T token 的预训练语料，上下文长度 4096。论文说明语料来自公开来源，排除了已知收集个人信息的站点，并对事实性强的来源做了上采样；未披露逐项配比。三个规模使用同一 token 预算，因此每参数 token 数为：7B 约 297，13B 约 154，70B 约 29。作为对照，Chinchilla 的计算最优比例约为 20，见 [[预训练-微调-对齐pipeline]] 的推导：Llama 2 的 7B 与 13B 明显“过训练”，用更多 token 换更小的模型，以降低推理成本；70B 接近计算最优点。

优化配置：AdamW，$\beta_{1}=0.9$、$\beta_{2}=0.95$、$\epsilon=10^{-5}$，权重衰减 0.1，梯度裁剪 1.0，批大小 4M token，预热 2000 步，余弦衰减到峰值学习率的 10%。7B 与 13B 峰值 $3.0\times10^{-4}$，70B 峰值 $1.5\times10^{-4}$。论文未解释 70B 降低峰值的原因；从优化角度看，更深的网络在同等学习率下产生更大的复合更新，降低峰值可以避免预热末期的损失尖峰。

按 $C\approx6ND$ 估算 7B 的训练计算量，$N$ 取非嵌入参数量 $6.476\times10^{9}$：

$$
C=6\times6.476\times10^{9}\times2.0\times10^{12}=7.77\times10^{22}\ \text{FLOPs}.
$$

若实际消耗约 $1.7\times10^{5}$ 张 A100-80GB 卡时（BF16 稠密算力约 $312$ TFLOPS），则

$$
\text{MFU}=\frac{7.77\times10^{22}}{1.7\times10^{5}\times3600\times312\times10^{12}}\approx0.41 .
$$

$0.41$ 的模型算力利用率对大模型预训练属于常见区间，也说明 $6ND$ 估算与实际账单可以对上。论文报告全部模型累计约 330 万 A100 卡时，其中 70B 约 170 万。

### 10 Llama-2-Chat 的 RLHF 流程

基座模型只做下一 token 预测，不保证按指令回答。Llama-2-Chat 在基座之上做三轮处理。

第一步，监督微调。使用约 27,540 条人工撰写的指令-回答对，对回答部分做因果语言建模。数据规模比预训练小五个数量级，作用是改变输出的条件分布形状，而不是注入新知识。

第二步，奖励模型。对同一提示采样多个回答，由标注者做二元比较，用 Bradley-Terry 模型拟合

$$
P(y_{w}\succ y_{l}\mid x)=\sigma\bigl(r_{\phi}(x,y_{w})-r_{\phi}(x,y_{l})\bigr),
$$

损失为 $-\log\sigma\bigl(r_{\phi}(x,y_{w})-r_{\phi}(x,y_{l})-m(x)\bigr)$，其中 $m(x)$ 是间隔项，用于拉开相似回答的分数。Llama 2 训练了两个奖励模型，分别对应有用性与安全性。

第三步，偏好优化。先用拒绝采样微调：对每个提示采样多个回答，按奖励模型选最优者做 SFT；再用 PPO 优化

$$
\max_{\pi_{\theta}}\ \mathbb{E}_{x\sim\mathcal{D},\,y\sim\pi_{\theta}(\cdot\mid x)}\bigl[r_{\phi}(x,y)\bigr]-\beta\,\mathrm{KL}\bigl(\pi_{\theta}(\cdot\mid x)\,\Vert\,\pi_{\text{ref}}(\cdot\mid x)\bigr),
$$

参考策略 $\pi_{\text{ref}}$ 固定为 SFT 模型，KL 项限制策略偏移。整套流程迭代 5 轮，每轮补充新的偏好数据与安全数据。完整推导与 PPO 的四个模型见 [[对齐-RLHF]]，无需奖励模型的替代方案见 [[DPO与偏好优化]]。

### 11 与 GPT 架构的对照

GPT-3 175B 与 Llama 2 70B 同为仅解码器结构，但参数化方式不同。

| 项目 | GPT-3 175B | Llama 2 70B |
|---|---|---|
| 层数 | 96 | 80 |
| $d$ | 12288 | 8192 |
| 查询头数 | 96 | 64 |
| 键值头数 | 96 | 8 |
| $d_{\text{head}}$ | 128 | 128 |
| 前馈网络 | GELU，两层，$d_{\text{ff}}=49152$ | SwiGLU，三层，$d_{\text{ff}}=28672$ |
| 归一化 | LayerNorm，Pre-LN | RMSNorm，Pre-Norm |
| 位置编码 | 学习式绝对位置嵌入 | RoPE |
| 线性层偏置 | 有 | 无 |
| 上下文长度 | 2048 | 4096 |
| 词表 | 50257 | 32000 |
| 训练 token | 300B | 2.0T |
| 参数量 | 175B | 69B |

两表的差可以归结为时代取舍：GPT-3 沿用 2019 年的层结构与 BPE 词表，用 175B 参数和 300B token 达到当时的性能；Llama 2 用 GQA、RoPE 与 RMSNorm 使 69B 参数达到可用性能，并用 6.7 倍的 token 量补偿参数量的下降。GPT 系列的演进见 [[GPT系列架构]]。

## 关键直觉

> [!tip] Llama 2 的全部结构改动都服务于同一个约束：在固定的参数与显存预算下，提高每个参数的梯度质量与每个字节 KV 缓存的信息量。RMSNorm 去掉均值中心化，减少每层一次归约；SwiGLU 用门控替换阈值非线性，并按 $8/3$ 修正宽度使参数量不变；RoPE 把位置编码为查询与键的相对相位，使注意力分数只依赖位移且不占参数；GQA 让每 8 个查询头共享一组键值，把 70B 的解码期 KV 缓存压到多卡可容纳的范围。这些改动都不改变因果语言建模的目标函数，只改变参数化与计算图，因此它们与严格定义中的目标正交，可以独立替换、独立验证。

## 例子与代码

以下代码需要 PyTorch 2.1 及以上版本，CPU 即可运行，单个代码块均在秒级完成。第一个例子手算 RMSNorm 并与模块输出对照。

```python
import torch
import torch.nn as nn
import torch.nn.functional as F

torch.manual_seed(0)

class RMSNorm(nn.Module):
    """Llama 2 的 RMSNorm：只做均方根缩放，参数为 gamma，无偏置。"""

    def __init__(self, d_model: int, eps: float = 1e-5):
        super().__init__()
        self.eps = eps
        self.weight = nn.Parameter(torch.ones(d_model))   # gamma 初始化为 1

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # 在 fp32 中计算均方，避免 fp16 下 x^2 上溢；eps 加在开方之前
        ms = x.float().pow(2).mean(dim=-1, keepdim=True)
        x_norm = x.float() * torch.rsqrt(ms + self.eps)
        return (self.weight * x_norm).to(x.dtype)


x = torch.tensor([1.0, 2.0, 3.0, 4.0]).unsqueeze(0)   # 形状 (1, 4)
out = RMSNorm(4)(x)
print("RMSNorm:", ", ".join(f"{v:.4f}" for v in out[0].tolist()))
print("mean(x^2) =", x.pow(2).mean().item())
print("1/sqrt(7.5) =", (1.0 / 7.5 ** 0.5))
```

```text
RMSNorm: 0.3651, 0.7303, 1.0954, 1.4606
mean(x^2) = 7.5
1/sqrt(7.5) = 0.3651483716701107
```

手算过程：$\mathrm{mean}(x^{2})=(1+4+9+16)/4=7.5$，$1/\sqrt{7.5}=0.365148$，四个分量分别乘以该系数得到输出。若改用 LayerNorm，先减均值 $2.5$ 得 $(-1.5,-0.5,0.5,1.5)$，再除标准差 $1.118$，输出为 $(-1.3416,-0.4472,0.4472,1.3416)$，符号结构完全不同。这一对照说明 RMSNorm 保留符号与相对幅度，只统一尺度。

第二个例子实现 SwiGLU 与完整解码器层，并统计参数量。

```python
class SwiGLU(nn.Module):
    """三个无偏置投影：gate 过 SiLU 后与 up 逐元素相乘，再经 down 回到 d 维。"""

    def __init__(self, d_model: int, d_ff: int):
        super().__init__()
        self.gate_proj = nn.Linear(d_model, d_ff, bias=False)
        self.up_proj = nn.Linear(d_model, d_ff, bias=False)
        self.down_proj = nn.Linear(d_ff, d_model, bias=False)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        return self.down_proj(F.silu(self.gate_proj(x)) * self.up_proj(x))


def repeat_kv(x: torch.Tensor, n_rep: int) -> torch.Tensor:
    """把 (B, h_kv, T, dh) 的 K/V 复制为 (B, h_kv*n_rep, T, dh)，供 GQA 使用。"""
    if n_rep == 1:
        return x
    b, h_kv, t, dh = x.shape
    x = x[:, :, None, :, :].expand(b, h_kv, n_rep, t, dh)
    return x.reshape(b, h_kv * n_rep, t, dh)


print("repeat_kv:", tuple(repeat_kv(torch.zeros(1, 8, 3, 128), 8).shape))
```

```text
repeat_kv: (1, 64, 3, 128)
```

`repeat_kv` 的结果形状说明：8 个键值头各复制 8 次，得到 64 个可用头，顺序是键值头 0 的 8 份在前、键值头 1 的 8 份在后，因此查询头 $i$ 对应键值头 $\lfloor i/8\rfloor$。这个顺序必须与训练时的分组一致；若用轮转方式（第 $i$ 个头取第 $i\bmod8$ 个键值头），形状仍然正确，但每个查询头读到的键值子空间被打乱，模型输出会退化。

第三个例子组装带 RoPE、GQA 与因果掩码的解码器层。

```python
def rope_cache(t: int, d_head: int, base: float = 10000.0, device=None):
    """返回 (cos, sin)，形状均为 (T, d_head/2)。"""
    inv_freq = 1.0 / (base ** (torch.arange(0, d_head, 2, device=device).float() / d_head))
    pos = torch.arange(t, device=device).float()
    freqs = torch.outer(pos, inv_freq)
    return freqs.cos(), freqs.sin()


def rotate_half(x: torch.Tensor) -> torch.Tensor:
    """前后两半配对：把 (x1, x2) 变为 (-x2, x1)。"""
    x1, x2 = x.chunk(2, dim=-1)
    return torch.cat((-x2, x1), dim=-1)


def apply_rope(x: torch.Tensor, cos: torch.Tensor, sin: torch.Tensor) -> torch.Tensor:
    cos = torch.cat([cos, cos], dim=-1)[None, None, :, :]   # (1,1,T,d_head)
    sin = torch.cat([sin, sin], dim=-1)[None, None, :, :]
    return x * cos + rotate_half(x) * sin


class LlamaBlock(nn.Module):
    def __init__(self, d_model=4096, n_heads=32, n_kv_heads=32, d_ff=11008, eps=1e-5):
        super().__init__()
        self.n_heads, self.n_kv_heads = n_heads, n_kv_heads
        self.head_dim = d_model // n_heads
        self.n_rep = n_heads // n_kv_heads
        self.attn_norm = RMSNorm(d_model, eps)
        self.wq = nn.Linear(d_model, n_heads * self.head_dim, bias=False)
        self.wk = nn.Linear(d_model, n_kv_heads * self.head_dim, bias=False)
        self.wv = nn.Linear(d_model, n_kv_heads * self.head_dim, bias=False)
        self.wo = nn.Linear(n_heads * self.head_dim, d_model, bias=False)
        self.ffn_norm = RMSNorm(d_model, eps)
        self.mlp = SwiGLU(d_model, d_ff)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        b, t, _ = x.shape
        h = self.attn_norm(x)
        q = self.wq(h).view(b, t, self.n_heads, self.head_dim).transpose(1, 2)
        k = self.wk(h).view(b, t, self.n_kv_heads, self.head_dim).transpose(1, 2)
        v = self.wv(h).view(b, t, self.n_kv_heads, self.head_dim).transpose(1, 2)
        cos, sin = rope_cache(t, self.head_dim, device=x.device)
        q, k = apply_rope(q, cos, sin), apply_rope(k, cos, sin)   # 只旋转 Q 与 K
        k = repeat_kv(k, self.n_rep)
        v = repeat_kv(v, self.n_rep)
        scores = q @ k.transpose(-2, -1) / self.head_dim ** 0.5
        mask = torch.triu(torch.full((t, t), float("-inf"), device=x.device), diagonal=1)
        attn = torch.softmax(scores + mask, dim=-1)               # 掩码在 softmax 之前
        out = (attn @ v).transpose(1, 2).reshape(b, t, -1)
        x = x + self.wo(out)                                      # 注意力残差
        x = x + self.mlp(self.ffn_norm(x))                        # FFN 残差
        return x


blk = LlamaBlock(d_model=256, n_heads=4, n_kv_heads=2, d_ff=688)
out = blk(torch.randn(2, 8, 256))
print("out:", tuple(out.shape))
print("block params:", sum(p.numel() for p in blk.parameters()))
```

```text
out: (2, 8, 256)
block params: 725504
```

小配置把 $d$ 缩到 256、头数缩到 4、键值头缩到 2，用于验证形状与参数量公式：注意力 $256^{2}+2\cdot256\cdot2\cdot64+256^{2}=196{,}608$，FFN $3\cdot256\cdot688=528{,}384$，两个 RMSNorm $512$，合计 $725{,}504$，与打印值一致。$d_{\text{ff}}=688$ 是按 $8/3\cdot256=682.67$ 向上取 16 的整数倍得到的，与 Llama 2 的取整规则同构。

第四个例子用解析公式复算三个规模的参数量，并与公布值对照。

```python
def llama_params(d, n_layers, n_heads, n_kv_heads, d_ff, vocab):
    head_dim = d // n_heads
    attn = d * d + 2 * d * n_kv_heads * head_dim + d * d
    ffn = 3 * d * d_ff
    per_layer = attn + ffn + 2 * d
    return per_layer * n_layers + 2 * vocab * d + d

configs = {
    "7B":  (4096, 32, 32, 32, 11008, 32000),
    "13B": (5120, 40, 40, 40, 13824, 32000),
    "70B": (8192, 80, 64, 8, 28672, 32000),
}
for name, cfg in configs.items():
    total = llama_params(*cfg)
    print(f"{name}: {total:,} ({total / 1e9:.2f}B)")
```

```text
7B: 6,738,415,616 (6.74B)
13B: 13,015,864,320 (13.02B)
70B: 68,976,648,192 (68.98B)
```

三个输出与论文的 6.74B、13.02B、69.0B 在三位有效数字内一致。若把 70B 的 $d_{\text{ff}}$ 改成 28416，输出变为 68,209,876,992（68.21B），偏差 0.77B，可直接判定配置读取错误。同理，若误把输出投影与嵌入共享，7B 会少算 131,072,000 个参数，变成 6.61B。

## 易错点

> [!warning] 以下五条均可在第 8 节的参数表或第 5 至 7 节的形状推导中直接检验。
> 1. RMSNorm 的 $\epsilon$ 位置写错：正确形式是 $\mathbf{x}\cdot\mathrm{rsqrt}(\mathrm{mean}(x^{2})+\epsilon)$；写成 $\mathbf{x}/(\sqrt{\mathrm{mean}(x^{2})}+\epsilon)$ 时，相对偏差约为 $\epsilon/(2\,\mathrm{mean}(x^{2}))$，在均方为 1 附近约为 $5\times10^{-6}$，数值上不易察觉，但权重加载后的首层输出与官方实现不再逐位一致，低精度推理时偏差放大；把 $\epsilon$ 加在 `rsqrt` 之外同样属于此类错误。
> 2. SwiGLU 门控顺序写反：正确顺序是 $\mathrm{SiLU}(\mathbf{W}_{g}\mathbf{x})\odot(\mathbf{W}_{u}\mathbf{x})$；写成 $\mathbf{W}_{g}\mathbf{x}\odot\mathrm{SiLU}(\mathbf{W}_{u}\mathbf{x})$ 形状相同、参数量相同，但函数不同，且与 `gate_proj`/`up_proj` 的权重名不再对应，加载官方权重后输出错误。另一种错误是忘记 `down_proj`，把中间维度直接当输出。
> 3. RoPE 作用对象或位置写错：RoPE 只作用于 $\mathbf{Q}$ 与 $\mathbf{K}$，不作用于 $\mathbf{V}$；必须在拆头之后、打分之前施加；带 KV 缓存解码时，位置索引必须用当前绝对位置，而不是缓存内的相对偏移。把 RoPE 加到嵌入层、或对 $\mathbf{V}$ 旋转，都会使注意力分数失去相对位移性质。
> 4. GQA 的键值头映射写错：查询头 $i$ 对应键值头 $\lfloor i/(h/h_{kv})\rfloor$；写成 $i\bmod h_{kv}$ 会得到轮转映射，形状与参数量全部正确，但每个查询头读到的键值子空间被打乱。另一类错误是 `repeat_kv` 沿批维而非头维复制，或复制后未保持“同一键值头的副本相邻”的顺序。
> 5. 参数量口径混用：把 7B 的 6.74B 与不含嵌入的 6.48B 混用会低估计算量约 4%；把 70B 的 $d_{\text{ff}}$ 取公式值 28416 会低估 0.77B；把嵌入与输出投影当作共享会少算一个 $Vd$。三种错误都会让 $6ND$ 估算与显存规划同时偏离。

## 关联笔记

- 前置 [[Transformer架构详解]]：本篇的层结构、Pre-LN 递推与掩码位置以该篇为基础，本篇只替换归一化函数、前馈网络与位置编码。
- 前置 [[位置编码-正弦与RoPE]]：RoPE 的旋转矩阵、相对位移性质与频率表由该篇给出完整推导，本篇补充 Llama 2 的 base 与配对约定。
- 对照 [[GPT系列架构]]：第 11 节的两表对照说明 LayerNorm/GELU/学习式位置嵌入与 RMSNorm/SwiGLU/RoPE 两组选择的差别。
- 后续 [[分组查询注意力GQA]]：第 6 节只给出 70B 的配置与显存结论，该篇给出 GQA 的消融、组大小选择与实现细节。
- 后续 [[预训练-微调-对齐pipeline]]：本篇的结构被 2T token 预训练与 RLHF 使用，该篇说明三阶段的数据、损失与成本。

## 达标检测

- [ ] 默写 7B、13B、70B 的层数、$d$、$h$、$h_{kv}$、$d_{\text{ff}}$、上下文长度与词表，并说明三个规模为何都取 $d_{\text{head}}=128$。
- [ ] 写出 RMSNorm 与 LayerNorm 的公式，逐项指出四处差异，并计算 $\mathbf{x}=(1,2,3,4)$ 在两种归一化下的输出。
- [ ] 从 $3dd_{\text{ff}}=8d^{2}$ 推出 $d_{\text{ff}}=8d/3$，并对 7B 计算取整前后的 FFN 参数量与相对偏差。
- [ ] 独立复算 7B 的参数量到个位（6,738,415,616），再算 70B 一层与总计，说明 $d_{\text{ff}}$ 取 28672 而非 28416 的依据。
- [ ] 推导 RoPE 的 $\mathbf{q}_{m}^{\top}\mathbf{k}_{n}=\mathbf{q}^{\top}\mathbf{R}_{n-m}\mathbf{k}$，并解释为什么它不需要位置嵌入表。
- [ ] 对 70B 计算 $T=4096$、$B=32$、fp16 时的 KV 缓存，与改用 64 个键值头的配置对比，给出 GiB 数值。
- [ ] 运行本篇四个代码块，报告 `block params` 与三个规模的参数量；把 70B 的 $d_{\text{ff}}$ 改为 28416、把键值头映射改成 $i\bmod h_{kv}$ 的轮转方式，分别说明输出为何偏离。

## 参考来源

- Touvron et al., "Llama 2: Open Foundation and Fine-Tuned Chat Models", arXiv:2307.09288 —— 对应第 1 节规格表、第 9 节训练配置与 token 规模、第 10 节 RLHF 流程与拒绝采样。
- Zhang & Sennrich, "Root Mean Square Layer Normalization", arXiv:1910.07467 —— 对应第 3 节 RMSNorm 的定义、与 LayerNorm 的四项差异及平移不变性讨论。
- Shazeer, "GLU Variants Improve Transformer", arXiv:2002.05202 —— 对应第 4 节 SwiGLU 的公式、门控结构与 $8/3$ 宽度修正。
- Su et al., "RoFormer: Enhanced Transformer with Rotary Position Embedding", arXiv:2104.09864 —— 对应第 5 节旋转矩阵、相对位移性质与频率设定。
- Ainslie et al., "GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints", arXiv:2305.13245 —— 对应第 6 节分组查询注意力的组划分、精度与吞吐权衡。
- Raschka, *Build a Large Language Model (From Scratch)*, 2024, 第 4 至 5 章 —— 对应第 2 节的层组装、第 8 节的参数量核对方法与第 7 节的掩码实现。
