第3篇 · S1·上：什么是大语言模型 + Transformer 架构深讲

这一篇剥掉大模型的神秘外衣：LLM 的概率本质、能力与边界，以及 Decoder-only Transformer 的完整架构与注意力推导。它是整个学习篇（S1-S10）的地基，后续训练（第 6-7 篇）、微调（第 8-9 篇）、推理优化（第 10-11 篇）都踩在这块地基上。 学完你应该能看懂任何主流 LLM 的架构图，把注意力计算对应到自己熟悉的分布式/数据概念上，面试能默写注意力公式并讲清 √d_k。 每节按 原理 -> 关键推导 -> 前端/后端/大数据映射 -> 实操要点 -> 误区 走。遇到公式不要跳：转 AI 的工程师一旦把数学对应到自己熟悉的概念上，就再也忘不掉。本篇含自注意力、多头、RoPE、RMSNorm/SwiGLU 的手撕伪代码；Transformer 的重大架构演进 MoE 稀疏激活放在第 5 篇专题讲。

---

1. 什么是大语言模型

1.1 本质：一个学了海量条件概率的函数

别把 LLM 神秘化。剥到底，LLM 是一个超大参数的函数 f，输入一段文本，输出"下一个 token 的概率分布"：

P(下一个token | 前面的token序列)

它通过"读遍互联网文本"学到了语言的统计规律。所谓"生成"，就是反复执行：用当前序列预测下一个 token 的概率分布 -> 按某种策略采样出一个 token -> 拼到序列尾部 -> 再预测下一个......循环到结束。这叫自回归（autoregressive）生成。

关键认知：LLM 不是"理解了语义"再生成，而是"根据学到的概率分布续写"。它擅长的是"像人那样说话"，不等于"知道事实"。这一条认知决定了后面所有工程决策（为什么要 RAG、为什么会幻觉、为什么不能当数据库用）。

1.2 能力与边界

• 能：语言理解与生成、代码、推理（一定范围内）、风格迁移、指令遵循（经对齐训练后）。

• 不能（直接）：实时事实（训练后才有）、精确计算、确定性查询、访问你的私有数据、执行动作（需 Agent）。

• 能力随规模"涌现"：小模型不会的，大到一定程度突然会（如多步推理）。但涌现不可预测，不能指望。

后端/大数据映射

• LLM = 一个学了大量条件概率的函数：就像你训练的推荐/风控模型是"学了特征到 label 映射的函数"，LLM 是"学了上文到下文分布的函数"。区别只是输入输出是 token 序列、参数量大几个数量级。

• 自回归生成 = 状态机逐态转移：每生成一个 token 就是状态机走一步，当前状态=已生成序列，转移函数=LLM。这和你在流处理里"当前状态 + 新事件 -> 新状态"同构。

• "概率分布而非事实" = 模型输出是概率不是查询结果：就像推荐模型给的是"点击概率排序"不是"用户一定点哪个"，LLM 给的是"最可能的续写"不是"正确答案"。所以关键事实要外挂（RAG/工具），不能纯靠概率。

实操要点

用任意 API 或开源模型，让它"续写"而非"问答"，你会直观看到它的概率本质：给它 "中国的首都是"，它几乎必然续 "北京"（高概率）；给它 "1+1="，续 "2"；但给它冷僻事实，它会"编一个最像的"。

误区

• ❌ "LLM 是一个搜索引擎/知识库" -> 它是概率模型，"记忆"是统计规律不是精确存储。

• ❌ "参数越大越准" -> 能力涌现非线性，且事实准确性受训练数据时效限制，与参数量不成正比。

---

2. Transformer 架构

现代主流 LLM（GPT/Claude/Qwen/GLM/Llama）几乎都是 Decoder-only Transformer。把它搞懂，后面训练/微调/推理全有支点。

2.1 从 RNN 到 Transformer：为什么要并行

RNN/LSTM 按序列逐 token 处理，第 t 步依赖第 t-1 步的隐状态，无法并行。训练一个大模型要喂海量 token，串行处理慢到不可接受。

Transformer 的革命：用注意力机制让每个 token 一次性"看到"序列里所有 token，整层计算可以并行（矩阵乘法）。训练效率提升几个数量级，这才是"大模型"可行的前提。

2.2 整体结构：Encoder-Decoder -> Decoder-only

原始 Transformer（2017《Attention Is All You Need》）是 Encoder + Decoder（机器翻译用：Encoder 编码源语言，Decoder 生成目标语言）。演进：

• Encoder-only（BERT）：理解为主，双向注意力，适合分类/抽取。

• Decoder-only （GPT 系列、现代主流 LLM）：生成为主，单向掩码注意力（只能看前面的 token），适合续写/对话。

• 现代通用大模型几乎都选 Decoder-only，因为它和"预测下一个 token"的自回归目标天然契合，且 scaling 表现最好。

2.3 自注意力机制（Self-Attention）

这是 Transformer 的心脏。直觉：序列里每个 token 要"决定该关注其他哪些 token"，把相关信息加权聚合成自己的新表示。

三步：

1. 每个 token 的向量 x 经三个线性投影，得到 Query（查询） 、Key（键） 、Value（值） 三个向量：

   Q = x · W_Q,   K = x · W_K,   V = x · W_V

   • 类比：数据库检索。Q 是"我在找什么"，K 是"每条记录的标签"，V 是"每条记录的内容"。用 Q 和所有 K 算相似度，按相似度加权取 V。

2. 用 Q 和所有 K 算点积相似度，softmax 归一化得注意力权重，加权求和 V：

   Attention(Q, K, V) = softmax(Q · K^T / √d_k) · V

   其中 d_k 是 Key 向量维度。

3. 输出就是该 token 融合了全序列信息后的新表示。

为什么除以 √d_k？ 这是最容易被问、也最该懂的推导：

• 点积 Q·K 的方差与 d_k 成正比（假设 Q、K 各分量独立、均值 0、方差 1，则点积 Q·K = Σ q_i·k_i，方差为 d_k）。

• d_k 很大时（如 64/128），点积数值很大，softmax 会进入饱和区->梯度趋零->训练不动。

• 除以 √d_k 把方差缩回 1 附近，让 softmax 处在梯度健康的区间。

• 一句话：√d_k 是数值稳定性的缩放因子，防点积过大导致 softmax 饱和。

掩码注意力（Masked Attention）：Decoder-only 要保证预测第 t 个 token 时只能看前 t-1 个（否则偷看答案）。用一个下三角掩码把"未来"位置的注意力权重置为 -∞（softmax 后变 0）实现。

手撕伪代码（面试可默写，含张量形状）：

# X: [B, S, d_model]  B=batch, S=序列长度
Q = X @ W_Q                       # [B, S, d_k]
K = X @ W_K                       # [B, S, d_k]
V = X @ W_V                       # [B, S, d_v]
scores = Q @ K.transpose(-2,-1) / sqrt(d_k)   # [B, S, S]  每 token 对所有人的相似度
mask = torch.tril(torch.ones(S, S))           # 下三角=1（Decoder 单向掩码）
scores = scores.masked_fill(mask == 0, float('-inf'))   # 未来位置置 -inf
attn = softmax(scores, dim=-1)                # [B, S, S]  归一化注意力权重
out = attn @ V                                # [B, S, d_v]  加权求和

映射：scores = Q@Kᵀ = 笛卡尔积 JOIN（每 token 配对所有 token）；softmax(dim=-1) = 按行 reduce 归一化；out = attn@V = reduceByKey 聚合 V。

2.4 多头注意力（Multi-Head Attention）

单个注意力只能学一种"关注模式"。多头：把 Q/K/V 拆成 h 份（每份维度 d_k/h），各自独立做注意力，最后拼接投影：

MultiHead = Concat(head_1, ..., head_h) · W_O

• 直觉：不同头关注不同关系（有的看语法、有的看指代、有的看语义）。

• 映射：多头 = 多视角特征提取，像 CNN 的多通道卷积核，或特征工程里多组不同视角的特征。

手撕伪代码（reshape/transpose 是手写最易错点）：

# 拆 h 个头，每头 d_h = d_model / h
B, S, d = X.shape
Q = (X @ W_Q).reshape(B, S, h, d_h).transpose(1, 2)   # [B, h, S, d_h]
K = (X @ W_K).reshape(B, S, h, d_h).transpose(1, 2)   # [B, h, S, d_h]
V = (X @ W_V).reshape(B, S, h, d_h).transpose(1, 2)   # [B, h, S, d_h]
attn_out = attention(Q, K, V)             # 各头独立做 §2.3 注意力 -> [B, h, S, d_h]
# 合并多头：transpose 回来再 reshape
concat = attn_out.transpose(1, 2).reshape(B, S, d)   # [B, S, d_model]
out = concat @ W_O                                    # [B, S, d_model]

映射：多头 = 按 head 分区（mapPartitions）各算各的再 union 合并；reshape/transpose = 重分区/调整数据布局。

2.5 位置编码（Positional Encoding）

注意力本身是"集合操作"：它对 token 的顺序无感（打乱序列顺序，注意力结果只是对应重排）。但语言顺序重要（"狗咬人"≠"人咬狗"）。所以要给每个 token 加位置信息。

• 绝对位置编码（原始 Transformer）：用固定的 sin/cos 函数生成每个位置的向量，加到 embedding 上。

• 旋转位置编码（RoPE）（现代主流：Llama/Qwen/GLM 等都用）：把位置信息"旋转"进 Q/K，相对位置体现在 Q·K 的点积里。

  • RoPE 的优势：相对位置天然编码、外推性更好（训练 4k 可延展到更长）、无需额外参数。

• 映射：位置编码 = 给无序集合加上"序"的元信息，像你在数据里给无序事件流加 event_time/offset 字段。

手撕伪代码（RoPE 旋转，现代 LLM 必考）：

def rope(q, m, base=10000):
    # 对位置 m 的 Q 向量，按二维一组旋转 θ_k = m · base^(-2k/d)
    d = q.shape[-1]
    theta = m * base ** (-(torch.arange(0, d, 2).float() / d))   # [d/2]
    cos, sin = theta.cos(), theta.sin()
    q_even, q_odd = q[..., 0::2], q[..., 1::2]    # 拆奇偶配对 (q_{2k}, q_{2k+1})
    q_rot_even = q_even * cos - q_odd * sin       # 二维旋转
    q_rot_odd  = q_even * sin + q_odd * cos
    return torch.stack([q_rot_even, q_rot_odd], dim=-1).flatten(-2)
# 对 Q 和 K 都做 RoPE（V 不做）；Q_m · K_n 内含相对位置 (m-n)，无需存位置表

映射：RoPE = 按位置打"时间戳"做旋转变换，不存表、不增参数；相对位置 (m-n) 自动出现在 Q·K 里，像流处理按 event_time 偏移对齐。

2.6 FFN / 残差连接 / LayerNorm

每个 Transformer 层 = [注意力子层 + 残差 + LayerNorm] + [FFN 子层 + 残差 + LayerNorm]。

• FFN（前馈网络）：两层全连接 + 激活（ReLU->现多用 SwiGLU）。注意力负责"token 间信息聚合"，FFN 负责"token 内特征变换"。现代 LLM 的参数量大头其实在 FFN（占比约 2/3）。

• 残差连接（Residual） ：output = x + Sublayer(x)，缓解深层网络梯度消失，让几十上百层可训。你做深层网络/ResNet 早就懂。

• LayerNorm：对每个 token 的特征维做归一化，稳定训练。

  • Pre-Norm vs Post-Norm ：现代 LLM 几乎都用 Pre-Norm（先 LayerNorm 再进子层），因为深层训练更稳定；原始 Transformer 是 Post-Norm。

手撕伪代码（RMSNorm + SwiGLU，现代 LLM 实际用的，区别于教科书 LayerNorm+ReLU）：

def rmsnorm(x, gamma, eps=1e-6):
    # LayerNorm 去掉减均值，只按均方根缩放（Llama/Qwen/GLM 都用）
    rms = sqrt(mean(x ** 2, dim=-1, keepdim=True) + eps)
    return x / rms * gamma          # 无 β（无偏移项）
​
def swiglu_ffn(x, W_gate, W_up, W_down):
    return (silu(x @ W_gate) * (x @ W_up)) @ W_down   # silu(t)=t·σ(t)
# 对比传统 FFN：relu(x @ W1) @ W2（两矩阵）；SwiGLU 门控特征交叉，效果好但多 1/3 参数

映射：RMSNorm = z-score 去均值版（只缩放不居中，更省）；SwiGLU = 门控特征交叉（推荐里 FM/DeepFM：一门控通路控信息通过）。

后端/大数据映射（本节汇总）

• Transformer = 一个由算子组成的计算图：Attention/FFN/LayerNorm 都是张量算子，整层是 DAG。你用 Spark/TF 画计算图的概念直接对应，GPU 上就是一堆矩阵乘法 kernel。

• 注意力 = 动态路由 / 稀疏全连接：全连接是固定权重连所有，注意力是"权重由数据动态算出来的全连接"：每个 token 连哪些、权重多少，由 Q·K 实时决定。

• 多头 = 多通道/多视角特征；残差 = 流式处理里的状态传递（前一层信息不丢）；LayerNorm = 数据标准化（你做特征工程的 z-score）。

• Decoder-only 单向掩码 = 流处理只能用历史窗口：和你在 Flink 里"当前事件只能用过去状态"完全同构，不能偷看未来。

实操要点

不必从零写 Transformer（除非为学）。但要看一次可视化解剖：推荐 transformers 库打印某模型每层 shape，或用 tiktokenizer/BertViz 看注意力权重热力图。重点建立"一层的算子流和数据维度"的直觉。

误区

• ❌ "注意力就是加权平均" -> 它是数据相关的动态权重，权重由 Q·K 实时算出，这才是它能学复杂依赖的关键。

• ❌ "Transformer 有记忆" -> 单次前向无跨请求记忆，所谓"记忆"是上下文窗口里的文本，请求结束即失（这引出后文 Agent 记忆系统的设计，见本专栏第 17-18 篇）。

架构演进提示 ：以上是稠密 Transformer 的标准架构。2024-2025 顶配模型几乎都改用 MoE 混合专家做稀疏激活，这是 Transformer 架构的最大演进方向，放在第 5 篇《前沿架构》专题讲。

本篇小结

• LLM 本质是"输入上文、输出下一个 token 概率分布"的函数；生成即自回归续写，它给的是"最可能的续写"而非"事实"，所以关键事实要外挂（RAG/工具）。

• Transformer 用注意力换并行，训练效率比 RNN 高几个数量级；现代主流 LLM 几乎都是 Decoder-only + 单向掩码注意力。

• Attention = softmax(Q·K^T/√d_k)·V；√d_k 是数值稳定缩放因子：点积方差随 d_k 线性涨，不除会 softmax 饱和、梯度趋零。

• 多头 = 多视角特征提取（拆 h 份各自注意力再拼接）；RoPE 把相对位置旋进 Q/K，外推性好、零额外参数。

• FFN 占现代 LLM 参数约 2/3（SwiGLU 门控）；Pre-Norm + RMSNorm 是深层训练稳定的标配。

• 注意力是数据相关的动态权重，不是简单加权平均；Transformer 单次前向无跨请求记忆。

• 面试对应：注意力公式与 √d_k 推导、Decoder-only 为何胜出、RoPE，见本专栏第 43 篇（Vol.2）、第 33 篇（Vol.1·M1）。

---

上一篇 ：第1篇《开篇词》 ｜ 下一篇：第4篇《S1·中：Token 与 Tokenization、预训练 Scaling Law、推理机制、采样与幻觉》