大模型架构精讲：AI面试核心考点

可视化演示

动态演示大模型架构精讲的核心机制，通过输入/处理/存储/输出四种模式展示关键概念与交互流程。

Transformer 总体架构：后厨全景图

站在这家“注意力餐厅”的后厨门口，主厨递给你一张平面图。图上有两条流水线：左边一条叫“理解线”——它把整张菜单从头到尾读一遍，摸清每道菜与每道菜之间的关系；右边一条叫“生成线”——它一道菜一道菜地往外出，每出一盘都要回头看看前面已经上了哪些菜。你恍然大悟：最早提出 Transformer 的翻译模型，正是用“理解线”读完源语言句子，再由“生成线”逐词吐出目标语言。

无论走哪条线，食材进门的第一站都完全相同——嵌入层（Embedding）。就像后厨把五花八门的食材统一切成规格一致的丁、丝、片，嵌入层把每个单词映射成固定维度的向量。流水线的最末端则是“输出头”（Output Head），它把最后一层加工出的特征，翻译成“词表上每个词该上桌的概率”。理解了这两端，整张平面图的骨架就立住了。

$$\displaystyle P(y\mid x)=\text{softmax}\left(h_L W_e^{\top}\right),\qquad h_\ell=\mathrm{Block}_\ell(h_{\ell-1})$$

1. 词元序列 x：句子先被切分成词元（token），每个词元查嵌入表变成一个向量，这就是食材进门的“标准化切配”。

$$x=(x_1,x_2,\dots,x_n),\quad x_i\in\mathbb{R}^{d}$$

2. 逐层加工 Block：每一层 Transformer 模块拿到上一层输出，内部完成注意力与前馈两道工序，一共堆叠 L 层，就像后厨 L 个结构相同的加工工位。

$$h_\ell=\mathrm{Block}_\ell(h_{\ell-1}),\quad \ell=1,2,\dots,L$$

3. 输出投影 W_e^\top：把最后一层特征乘上嵌入矩阵的转置，映射成词表上每个词对应的“打分”。

$$\text{logits}=h_L W_e^{\top}\in\mathbb{R}^{V}$$

4. softmax 出菜：把打分转成概率分布，概率最高的词就是模型预测的下一个词。

$$P(y\mid x)=\text{softmax}(\text{logits})$$

所以面试官如果问“Transformer 长什么样”，你完全可以用这张平面图回答：食材从嵌入层进门，流过 L 个结构相同的加工工位，每站都做“注意力交换信息 + 前馈深度加工”两件事，最后在输出头变成概率。接下来，我们把每个工位的内部零件逐一拆开看。

注意力机制：传菜员的沟通艺术

后厨里最神奇的角色是传菜员。客人喊“我的面呢”，传菜员不会乱跑，而是先看每道菜上的桌号牌，快速判断哪些菜和自己负责的这单相关，再按相关程度分配精力。Transformer 里也有这样的“传菜员”：当句子中出现“苹果”，它会环顾整句话，判断这个词到底跟“吃”有关，还是跟“手机”有关——这就是注意力机制。

这种让每个词都能“同时看着所有词、按相关度分配信息”的机制叫自注意力（Self-Attention）。为了让“相关度”可以计算，模型给每个词配了三样东西：一个问题向量 Q（Query，我要找谁）、一张名片 K（Key，我是谁）、一份可交付的信息 V（Value，我身上有什么）。三样东西全部由输入向量乘不同的权重矩阵得到，并且每个词可以同时扮演三种角色。

$$\displaystyle \text{Attention}(Q,K,V)=\text{softmax}\left(\frac{QK^{\top}}{\sqrt{d_k}}\right)V$$

1. 查询 Query：当前词发出“谁和我相关”的问题，由输入乘权重矩阵 W_Q 得到。

$$Q=XW_Q$$

2. 键 Key：每个词亮出自己的“名片”，供别人的问题来匹配。

$$K=XW_K$$

3. 相关度打分：用 Q 与所有 K 做点积，得到两两之间的相关度分数。

$$S=QK^{\top}$$

4. 缩放稳定：除以维度平方根，把分数方差压回 1，避免 softmax 梯度消失。

$$\widetilde{S}=S/\sqrt{d_k}$$

5. 权重归一：softmax 把分数变成非负且和为 1 的注意力权重。

$$\alpha=\text{softmax}(\widetilde{S})$$

6. 加权汇总：用权重对 V 加权求和，得到融合上下文后的新表示。

$$\text{Output}=\alpha V$$

把三样东西串起来记：Q 是问题，K 是名片，V 是货。传菜员先拿问题去匹配名片（打分），再用分数决定端多少货（加权求和）。面试官最爱问的“注意力本质是什么”，一句话答完——按相关度加权求和。

位置编码：食材的顺序标签

你很快发现一个致命问题：如果传菜员只认菜不认顺序，“鱼香肉丝”和“肉丝鱼香”在他眼里就是同一道菜——食材一样，顺序一变，菜完全不是一回事。自注意力天生“无视顺序”：把句子里的词任意打乱，Attention 的计算结果一模一样。对语言来说，这意味着“猫追老鼠”和“老鼠追猫”会变成同一个输入。

所以 Transformer 必须给食材贴上“第几道菜”的标签，这就是位置编码（Positional Encoding）。经典方案用正弦/余弦函数为每个位置生成一个独一无二的“坐标向量”，直接加到词向量上。后来出现的旋转位置编码（RoPE）把“位置差”编码进向量间的旋转角度，表达能力更强，成为 LLaMA、Qwen 等主流大模型的标配。

$$\displaystyle \text{PE}(pos,2i)=\sin\left(\frac{pos}{10000^{2i/d}}\right),\qquad \text{PE}(pos,2i+1)=\cos\left(\frac{pos}{10000^{2i/d}}\right)$$

1. 位置编号 pos：每个词在句子中的序号，从 0 开始。

$$pos=0,1,2,\dots$$

2. 维度下标 i：把 d 维编码拆成两半，偶数维用正弦、奇数维用余弦。

$$i=0,1,\dots,d/2-1$$

3. 多尺度频率：分母 10000^{2i/d} 让低维变化快、高维变化慢，形成一把“刻度尺”。

$$\omega_i=1/10000^{2i/d}$$

4. 正余弦交替：位置偏移 k 的编码可以写成原编码的线性组合，模型能隐式学到相对位置。

$$\sin((pos+k)\omega)=\sin(pos\,\omega)\cos(k\omega)+\cos(pos\,\omega)\sin(k\omega)$$

一个记忆锚点：词嵌入回答“这是什么食材”，位置编码回答“这是第几道菜”。面试中说到 RoPE，就强调它携带的是“相对位置信息”（你离我多远），而不是“绝对编号”，这对处理超长上下文非常关键。

前馈网络与残差：灶台与备料

传菜员只负责匹配与传菜，真正把食材变成美味的是灶台师傅。Transformer 里的“灶台”是前馈网络（FFN）：一个两层的全连接网络。它的工作方式是先“爆炒”——把维度从 d 放大到 4d，给特征充分的空间互相碰撞；再“收汁摆盘”——把 4d 压回 d，回到大家熟悉的规格。

流水线还有一个大麻烦：层数一深，梯度信号传回前端时已经衰减得所剩无几，就像传话游戏传到最后完全走样。解决办法是残差连接（Residual Connection）：每个工位都把“原始备料”留一份在旁边，无论加工成什么样，出锅时都跟备料加到一起——信息永远有一条“高速通道”直达后端。这道菜做坏了，备料还在，可以再炒一遍。

$$\displaystyle \mathrm{FFN}(x)=\max(0,\,xW_1+b_1)W_2+b_2,\qquad y=\mathrm{LayerNorm}\big(x+\mathrm{FFN}(x)\big)$$

1. 升维展开：第一层线性变换把维度放大到 4 倍，给特征充足的“工作台”空间。

$$z=xW_1+b_1\in\mathbb{R}^{4d}$$

2. ReLU 激活：逐元素取 max(0,·)，引入非线性，只保留正向信号——只有够味的信号才上桌。

$$\max(0,z)$$

3. 降维还原：第二层线性变换把维度压回 d，与输入维度对齐，方便残差相加。

$$\mathrm{FFN}(x)=\max(0,z)W_2+b_2\in\mathbb{R}^{d}$$

4. 残差捷径：原始输入与变换结果逐元素相加，为梯度留一条恒等通道。

$$y=x+\mathrm{FFN}(x)$$

5. 层归一化：相加后再做归一化，稳定数值尺度（下一节细讲）。

$$y=\mathrm{LayerNorm}(x+\mathrm{FFN}(x))$$

记住一组数字：FFN 通常是整个 Transformer 里参数最多的模块（约占总参数的 2/3），是名副其实的“灶台主力”；而残差连接就是用一次加法，换来极其稳定的深层训练。面试二连问“FFN 干嘛的”“残差干嘛的”，用“爆炒收汁 + 留备料”就能答得又形象又准确。

归一化技术：出品品控

主厨最看重出品稳定：不管食材多新鲜、火候多猛，同一道菜端上桌的口味必须一致。后厨的“品控”环节就是归一化（Normalization）——把每一层的数值分布拉回一个标准区间，训练才不会因为数字忽大忽小而剧烈摇晃。

Transformer 选择的品控方式是 Layer Normalization（层归一化，LN）。它跟图像领域常用的 BatchNorm（批归一化）思路相反：不依赖整批样本的统计量，而是对每个样本（每个 token）自身的所有特征维做标准化。NLP 的句子长度千差万别、batch 大小也常变，“自己归一自己”最稳。工程上还催生了简化版 RMSNorm——去掉均值平移，只做缩放，速度快且效果几乎不降。

$$\displaystyle \mathrm{LayerNorm}(x_i)=\gamma\cdot\frac{x_i-\mu}{\sqrt{\sigma^2+\varepsilon}}+\beta$$

1. 求均值方差：对每个 token 的所有特征维求 μ 和 σ²。

$$\mu=\frac{1}{d}\sum_{j=1}^{d}x_j,\quad \sigma^2=\frac{1}{d}\sum_{j=1}^{d}(x_j-\mu)^2$$

2. 标准化：减去均值除以标准差，并加极小量 ε 防止除零，让分布归一到零均值单位方差。

$$\hat{x}_i=\frac{x_i-\mu}{\sqrt{\sigma^2+\varepsilon}}$$

3. 缩放平移：可学习参数 γ、β 恢复模型需要的表达范围——归一化不是“抹掉个性”，而是“稳定发挥”。

$$\mathrm{LN}(x_i)=\gamma\,\hat{x}_i+\beta$$

可以这样记位置：Post-LN 是“炒完再品控”，早期 Transformer 用，深了容易翻车；Pre-LN 是“先品控再下锅”，训练更稳，如今是默认做法；RMSNorm 是“简化品控”，只控分量不控咸淡。面试问到“为什么 LLM 用 LN 不用 BN”，从“句子长短不一、不依赖 batch 统计”入手答就稳了。

训练与推理：试菜与营业

新菜能不能进菜单，得看客人买不买账。后厨的做法分两步：先用海量“标准菜谱”反复试菜，让每个工位都练出手感——这叫预训练；再根据老客人的特殊口味做针对性调整——这叫微调。而正式营业时，传菜员发现一个省力诀窍：之前端过的菜，桌号和名片都记熟了，不必为每位新客重新核对一遍——这就是推理加速里的 KV Cache。

大模型的预训练目标主流是自回归（Autoregressive）语言建模：给定前文，预测下一个词。为了防止模型“偷看答案”，训练时用一个因果掩码（Causal Mask）把未来位置的词遮住——第 t 个词只能看到自己及左边的词。BERT 则反其道而行，采用掩码语言模型（MLM）：随机盖住一些词，让模型双向去猜，所以 BERT 是“双向理解者”，GPT 是“单向生成者”。

$$\displaystyle \mathcal{L}=-\frac{1}{N}\sum_{t=1}^{N}\log P_{\theta}\big(x_t\mid x_{<t}\big)$$

1. 前文条件：模型只能看到位置 t 之前的词，未来被因果掩码遮住。

$$x_{<t}=(x_1,x_2,\dots,x_{t-1})$$

2. 下一个词概率：模型输出第 t 个位置上词表中每个词的预测概率。

$$P_{\theta}(x_t\mid x_{<t})$$

3. 负对数似然：正确词的概率越接近 1，这个位置的损失越小；模型就是在逐步“把对的词推高、把错的词压低”。

$$-\log P_{\theta}(x_t\mid x_{<t})$$

4. 序列平均：对句子里所有位置取平均，得到本轮训练的整体优化目标。

$$\mathcal{L}=-\frac{1}{N}\sum_{t=1}^{N}\log P_{\theta}(x_t\mid x_{<t})$$

推理阶段的关键则是一本“熟客台账”：KV Cache。自回归生成第 t 个词时，前 t-1 个词的 Key/Value 早就算过了，缓存起来直接复用，每次生成只对新词做一次前向计算，把每步的复杂度从 O(T²) 降到 O(T)。面试官问“训练和推理的区别”，你就答：训练是“整桌菜反复试炒”，推理是“上菜时只看下一道”——一个重质量，一个重速度。

主流模型演进：菜系进化史

这家餐厅的菜系也在不断进化。刚开业时，它靠“理解线 + 生成线”两条流水线打天下（Encoder-Decoder）；后来生意分化：BERT 像一位只负责品鉴的品鉴师（Encoder-only），把整道菜从头品到尾；GPT 则变成边想边说的主厨（Decoder-only），想一个词说一个词。再后来，后厨忙不过来，老板请了一群专家厨师，每道菜只叫最对口的几位上手——这就是混合专家（MoE）。

从演进脉络看：Transformer（2017）→ BERT / GPT（2018）→ 如今主流大模型几乎都是 Decoder-only + Pre-LN + RoPE + MoE 的组合拳。为什么 Decoder-only 笑到最后？因为它的训练目标统一（永远预测下一个词）、天然支持生成任务、对缩放定律（Scaling Law）最友好——模型越大，损失下降曲线越平滑；而 BERT 式的双向编码，在生成任务上优势有限。

$$\displaystyle y=\sum_{i=1}^{N}G(x)_i\cdot E_i(x),\qquad G(x)=\mathrm{softmax}\big(\mathrm{TopK}\big(W_g x\big)\big)$$

1. 专家网络 E_i：每个专家是一个独立的前馈网络，相当于各有所长的厨师。

$$E_i(x)=W_i^{(2)}\,\sigma(W_i^{(1)}x)$$

2. 门控打分：路由器 W_g 为每个专家打一个“对口程度”分数。

$$s=W_g x$$

3. TopK 筛选：只保留分数最高的 K 个专家，其余置为负无穷，softmax 后权重趋近 0。

$$G(x)=\mathrm{softmax}(\mathrm{TopK}(s))$$

4. 加权汇总：被激活专家的输出按门控权重相加，得到最终结果。

$$y=\sum_{i=1}^{N}G(x)_i\,E_i(x)$$

一句话总结菜系：BERT 是品鉴师，GPT 是主厨，MoE 是专家团。面试被问“为什么模型越来越大却不怎么变慢”，答案正是 MoE 的稀疏激活——参数翻倍但每次只激活少数专家，效果全收、算力可控。讲到这一步，大模型架构这一题的深度已经远超平均线。

AI 应用场景

Python 演示

import numpy as np def softmax(x):    x = x - x.max(axis=-1, keepdims=True)   # 减去最大值防止指数溢出    e = np.exp(x)    return e / e.sum(axis=-1, keepdims=True) def positional_encoding(T, D):    # 生成正弦位置编码, 相当于给每个位置贴顺序标签    pe = np.zeros((T, D))    pos = np.arange(T).reshape(-1, 1)    idx = np.arange(D).reshape(1, -1)    angle = pos / np.power(10000.0, 2 * (idx // 2) / D)    pe[:, 0::2] = np.sin(angle[:, 0::2])    pe[:, 1::2] = np.cos(angle[:, 1::2])    return pe def multi_head_attention(x, wq, wk, wv, wo, num_heads, causal=False):    # 输入的 x 形状为 (batch, seq_len, dim)    B, T, D = x.shape    H = num_heads    d = D // H    # 每个词同时扮演 Q(提问者) / K(名片) / V(信息) 三种角色    q = (x @ wq).reshape(B, T, H, d).transpose(0, 2, 1, 3)    k = (x @ wk).reshape(B, T, H, d).transpose(0, 2, 1, 3)    v = (x @ wv).reshape(B, T, H, d).transpose(0, 2, 1, 3)    scores = q @ k.transpose(0, 1, 3, 2) / np.sqrt(d)   # 缩放点积打分    if causal:        mask = np.tril(np.ones((T, T)))                  # 因果掩码: 只看左侧        scores = np.where(mask == 0, -1e9, scores)       # 未来位置打巨负分    attn = softmax(scores)                               # 权重归一化    out = (attn @ v).transpose(0, 2, 1, 3).reshape(B, T, D)    return out @ wo, attn def demo():    np.random.seed(42)    D, H, T = 8, 2, 4                                    # 维度 / 头数 / 句子长度    x = np.random.randn(1, T, D) + positional_encoding(T, D)    wq = np.random.randn(D, D) * 0.1    wk = np.random.randn(D, D) * 0.1    wv = np.random.randn(D, D) * 0.1    wo = np.random.randn(D, D) * 0.1    out, attn = multi_head_attention(x, wq, wk, wv, wo, H, causal=True)    print("输出形状:", out.shape)    print("注意力权重:", np.round(attn[0, 0], 2))    print("第3个词看不到未来:", attn[0, 0, 2, 3] == 0) if __name__ == "__main__":    demo()

1. q = (x @ wq).reshape(B, T, H, d).transpose(0, 2, 1, 3)把向量拆成 H 个头，维度重排成 (batch, head, seq, head_dim)
2. scores = q @ k.transpose(0, 1, 3, 2) / np.sqrt(d)Q 与 K 转置做矩阵乘并除以 √d，即缩放点积打分
3. mask = np.tril(np.ones((T, T)))生成下三角矩阵作为因果掩码，位置 t 只能看到 0 到 t
4. scores = np.where(mask == 0, -1e9, scores)把未来位置设为 -1e9，softmax 后权重约等于 0
5. attn = softmax(scores)得到和为 1 的注意力权重，行代表“当前词看向谁”
6. out = (attn @ v).transpose(0, 2, 1, 3).reshape(B, T, D)按权重加权汇总，再还原为原始形状
7. x = np.random.randn(1, T, D) + positional_encoding(T, D)用随机向量模拟词嵌入，叠加位置编码
8. print("第3个词看不到未来:", attn[0, 0, 2, 3] == 0)验证因果掩码生效，结果为 True

常见误区

面试题