Interview Prep · ML Infra

模型架构：
从 N-gram 到 Transformer

先用一条时间线看每一种架构在解决上一种的什么问题，然后把 Transformer 拆成十步，每一步都有图，attention 可以亲手算。后面有形状和参数量、对比表、Staff 级的面试题、一个能跑的练习和一页速查表。

时间线

从数数到 attention，每一步在解决上一步的什么问题

1. 1950 年代起N-gram 语言模型统计数一数前几个词后面最常跟什么词。▼
2. 1990RNN循环一个词一个词地读，用一个隐藏状态记住读过的内容。▼
3. 1997 / 2014LSTM / GRU循环给 RNN 加上「门」，让信息能原样传得更远。▼
4. 2012 / 2015CNN 和 ResNet卷积图像这条线。它留给 Transformer 的是残差连接。▼
5. 2013Word2Vec表示把每个词变成一个向量，意思相近的词向量也相近。▼
6. 2014Seq2Seq 和 Attention循环一个 RNN 读、一个 RNN 写；attention 让写的时候能回头看原文。▼
7. 2017Transformer注意力去掉 RNN，只用 attention，所有位置同时算。▼

   出处

   Google，论文《Attention Is All You Need》，Vaswani 等八位作者

   它要解决的问题

   RNN 不能并行，训练慢；远处的词之间信息要一步步传。当时的任务是机器翻译。

   • 输入每个 token 一个向量
   • 第一个子层
     • Norm
     • masked self-attention每个位置只能看自己和前面
     • 加回输入残差连接
   • 第二个子层
     • Norm
     • MLP先放大到 4 倍宽，再缩回来
     • 加回输入残差连接
   • 输出形状和输入一样，交给下一层

   怎么工作

   • self-attention：每个词直接看句子里所有的词，按相关程度把它们的信息加权拿过来。任意两个词之间只隔一步。
   • 所有位置的计算互不依赖，可以一次算完，适合 GPU。
   • attention 本身不知道词的顺序，所以要给每个位置加上位置编码。
   • 每一层是：attention，然后一个 MLP。两者外面都有残差连接和 LayerNorm。
   • 原始论文是 encoder 加 decoder。base 模型 6 层，向量 512 维，8 个头，约 6500 万参数。

   训练的过程

   1. 把一段文本的所有位置一次送进去。
   2. 用 mask 保证每个位置看不到后面。
   3. 每个位置都预测下一个词。
   4. 把所有位置的误差加起来，更新参数。

   推理的过程

   1. 把已有的文本送进去，得到最后一个位置对下一个词的概率。
   2. 按概率选一个词。
   3. 把它接到末尾，再算一次。
   4. 之前算过的 key 和 value 存在缓存里，不用重算。

   优点

   • 所有位置同时算，训练能充分利用 GPU。
   • 任意两个词之间只隔一步，长距离依赖容易学。
   • 结构统一，模型和数据越大效果越好。

   缺点

   • attention 的计算量和序列长度的平方成正比，长文本很贵。
   • 没有内置的顺序概念，要靠位置编码补。
   • 它自带的假设少，需要大量数据才能发挥出来。在图像上，数据少的时候不如 CNN。

   用在哪里，现在还在哪里用

   现在几乎所有的大语言模型、多数视觉和语音模型。

   被什么取代，为什么

   没有被取代。新的结构多数是在它上面改，或者和它混合使用。

   面试时，一句话

   只用 attention 的序列模型：并行计算，任意两个位置直接相连。

   面试时，两分钟

   Transformer 把 RNN 拿掉，只用 self-attention。每个词直接看所有其他的词，按相关程度取信息，所以任意两个词之间只隔一步，而且所有位置可以同时算。因为 attention 不知道顺序，要另外加位置编码。每一层是 attention 加 MLP，外面有残差连接和归一化。代价是计算量和长度的平方成正比。它成为主流，是因为并行让它能在大数据上训练，而它的效果随规模持续变好。

   值得补一句的

   下面有一整节把它拆开讲。面试里最常被追问的是三件事：为什么要除以根号 d，为什么需要位置编码，以及计算量为什么是平方。

8. 2018BERT注意力只用 encoder，两个方向都能看，擅长理解。▼
9. 2018GPT注意力只用 decoder，只能看前面，擅长生成。现在的大模型都是这一支。▼
10. 2019–2024现代 LLM 的改动注意力骨架还是 2017 年的，但几乎每个零件都换过。▼
11. 2020ViT注意力把图片切成小块当成词，直接用 Transformer。▼
12. 2020 / 2022Diffusion 和 DiT生成从一团噪声开始，一步步去噪，得到图片。▼
13. 2023Mamba（状态空间模型）新一代计算量和长度成正比，想在长序列上替代 attention。▼

先懂这五个概念

整条时间线都在这几件事上做取舍

token 和 embedding

文本先切成 token（词或者词的一部分），每个 token 查表变成一个向量。

模型只能算数字。之后所有的计算都在这些向量上进行，模型的「宽度」d_model 就是这个向量的维数。

上下文能看多远

预测一个词的时候，模型能用到多远以前的信息。

N-gram 是几个词，RNN 理论上无限但实际记不住，Transformer 是整个上下文窗口。这条线贯穿了整个时间线。

能不能并行

一句话里的各个位置，是必须一个接一个算，还是可以同时算。

GPU 擅长同时算很多东西。RNN 必须顺序算，Transformer 可以同时算，这是它能用上大数据的直接原因。

残差连接

每一层的输出 = 这一层的输入 + 这一层算出来的修改量。

它给梯度留了一条直通路，没有它，几十层的网络训练不起来。可以把整个模型想成一条主线，每层往上面加一点东西。

自回归

一次生成一个 token，把它接到输入后面，再生成下一个。

这是 GPT 类模型生成文本的方式，也是它输出越长越慢、需要 KV cache 的原因。

重点 · 先看论文里那张图

2017 年的经典结构：encoder 加 decoder

这是《Attention Is All You Need》的图 1，面试和教材里说「Transformer 的结构」，指的通常就是它。当时的任务是翻译：左边的 encoder 读原文，右边的 decoder 写译文。图从下往上看。

图比较宽，可以左右滑动。

论文的原图里，每个 Add & Norm 旁边还画了一条绕过子层的线，那就是残差连接。这里为了清楚没有画，写在了方框的说明里。

翻译一句话，数据怎么走

1. 原文「我 爱 猫」从左下角进去，变成向量，加上位置编码。
2. 经过 6 层 encoder。每层先做 self-attention（三个词互相看），再过一个 MLP。出来的是三个向量，每个词一个，已经带上了整句话的信息。encoder 只算这一次。
3. decoder 从右下角开始。第一步的输入只有一个「开始」符号。
4. 每层 decoder 做三件事：先在已经写出来的词之间做 self-attention，带 mask，只能看前面；再做 cross-attention，回头看 encoder 输出的那三个向量；最后过 MLP。6 层 decoder 看的都是 encoder 最后一层的输出。
5. 最上面的 Linear 和 Softmax 给出下一个词的概率，从中选出「I」。论文里用的是 beam search，同时保留几个候选，不是每一步只取概率最大的。
6. 把「I」接到 decoder 的输入后面，重复第 4、5 步，直到输出结束符号。

cross-attention 和 self-attention 的区别

公式完全一样，区别只在 Q、K、V 从哪来。self-attention 里三者来自同一串词。cross-attention 里，Q 来自 decoder 这一层里每个位置的向量（刚做完带 mask 的 self-attention），K 和 V 来自 encoder 的输出。意思是：decoder 拿着「我现在要写什么」去原文里找相关的词。这就是 2014 年那个 attention 的 Transformer 版本，下面「追问」的第 4 条有动图。

图里的每个零件，在下面哪一步讲

把这张图的左半边和 decoder 中间那个 attention 去掉，剩下的就是现在大语言模型的骨架，零件的改动见上表。下面的十步按这个精简后的结构来讲，因为零件更少，而且是现在实际在用的形状。每一步讲的零件和这张图里的是同一个。

重点 · Transformer 拆开看

十步，从一句话到下一个 token

四个追问

时间线里一句话带过的地方，展开讲

形状走一遍

一句 5 个 token 的话，在 GPT-2 small 里变成什么形状

面试时能把每一步的形状说对，说明真的懂了。GPT-2 small：12 层，d_model 是 768，12 个 head，词表 50,257。

注意 attention 权重那一行：它是 5×5。句子长度变成 n，它就是 n×n。这就是「计算量和长度的平方成正比」的来源。

参数量

参数都在哪里

选一个型号，看参数怎么分布。这个公式算出来的四个型号，和用 Hugging Face 的 GPT-2 实现数出来的参数量完全一致，small 是 124,439,808。OpenAI 最初报的 117M 是数错了。

心算的办法：每一层大约是 12 × d²（attention 4 个 d×d 的矩阵，MLP 相当于 8 个），再加上词表 × d 的 embedding。

为什么是它赢了

和 RNN、CNN 放在一起比

这张表来自原始论文。n 是序列长度，d 是向量宽度，k 是卷积窗口的大小。

后两列是关键。「必须顺序做的步数」是 1，说明可以并行；「最远隔几步」是 1，说明再远的两个词也能直接互相影响。代价在第一列：n 很大时，self-attention 的计算量会超过 RNN 和卷积。卷积那一行的 log_k(n) 指的是带空洞的卷积；普通卷积要叠 n/k 层才能让最远的两个词相遇。

三种用法

2017 年的原版和现在的 LLM

横向对比

同样的几个维度，放在一起看

业界最新的方向 · 2026 年 10 月核对

现在大家在做什么

• MoE 成了大模型的常见做法

  把每层的 MLP 换成很多个专家，每个 token 只走其中几个。总参数可以很大，每次计算用到的却不多。DeepSeek-V3 和 Qwen3 里最大的 235B 模型都是这种结构。

• attention 和线性代价的层混合使用

  为了更长的上下文，一些模型不再每层都用完整的 attention，而是大部分层用线性代价的结构，隔几层放一层完整的 attention。Sebastian Raschka 在 2026 年 6 月的论文清单里说，这种交替的混合结构是当年比较流行的方向；他 2025 年 11 月的文章里举的例子是 Qwen3-Next 和 Kimi Linear：三层线性 attention 配一层完整 attention。

• 让 attention 本身更省

  GQA 让多个头共用 key 和 value，缩小 KV cache。FlashAttention 不把整个 attention 矩阵写进显存。这些不改变平方这个量级，但让长上下文在工程上可行。

• 用 diffusion 生成文本

  自回归一次只出一个 token。diffusion 语言模型想一次并行地生成很多 token，再反复修改。它还没有取代自回归，是一个活跃的研究方向。

常见误解

这几句话听起来对，其实不对

• 误解：Transformer 发明了 attention。

  attention 在 2014 年就用在了 RNN 的机器翻译上。Transformer 的贡献是把 RNN 去掉，只用 attention。

• 误解：attention 的权重就是模型的解释，权重大就说明那个词重要。

  权重只说明这一层这一个头从哪里取了信息。一个模型有很多层、很多头，后面还有 MLP 和残差，单看一个头的权重不能当作模型决策的解释。

• 误解：Transformer 能并行，所以生成也是并行的。

  并行说的是训练，以及处理已经给定的输入。生成时仍然是一个 token 一个 token 来，每个 token 依赖前一个。

• 误解：BERT 和 GPT 是两种不同的架构。

  它们用的是同一种层。区别在于 attention 能不能看到后面的词，以及训练任务是完形填空还是预测下一个词。

• 误解：Diffusion 是 Transformer 的替代品。

  一个是生成的方法，一个是网络的结构。DiT 就是用 Transformer 做 diffusion 里的去噪网络。

• 误解：参数主要在 attention 里。

  标准的层里，MLP 的参数大约是 attention 的两倍：attention 是 4 个 d×d 的矩阵，MLP 相当于 8 个。

• 误解：位置编码是加在输入上的一个固定向量。

  原始论文是这样。现在的主流是 RoPE：不加在输入上，而是在每一层的 attention 里旋转 query 和 key。

Staff 级面试题

先自己答，再点开看

动手练习 · 约 5 分钟

用 NumPy 写一遍 self-attention

需要 Python 和 NumPy。把下面的代码存成 attention.py 再运行。核心只有四行。

import numpy as np

np.set_printoptions(precision=3, suppress=True)

tokens = ["小猫", "追", "老鼠", "它"]

# 每个词的 query、key、value 向量。这里是手写的 2 维向量，方便心算；
# 真实模型里它们由 embedding 乘以三个训练出来的矩阵得到。
Q = np.array([[1, 0], [1, 1], [0, 1], [2, 0.5]])
K = np.array([[2, 0], [0, 1], [1, 1], [0, 0.5]])
V = np.array([[1, 0], [0, 1], [0.5, 0.5], [0, 0]])


def softmax(x):
    e = np.exp(x - x.max(axis=-1, keepdims=True))
    return e / e.sum(axis=-1, keepdims=True)


def attention(Q, K, V, causal):
    d = K.shape[-1]
    scores = Q @ K.T / np.sqrt(d)          # 第 1 步：每个 query 和每个 key 算相似度
    if causal:                              # 第 2 步：只能看自己和前面的词
        hidden = np.triu(np.ones_like(scores), k=1).astype(bool)
        scores = np.where(hidden, -np.inf, scores)
    weights = softmax(scores)               # 第 3 步：每一行变成加起来等于 1 的权重
    return weights, weights @ V             # 第 4 步：按权重把 value 加起来


weights, output = attention(Q, K, V, causal=False)
print("不加 mask 的权重（每一行是一个词在看谁）")
print(weights)
print("「它」这一行:", dict(zip(tokens, weights[3].round(3).tolist())))
print("「它」的输出向量:", output[3])

weights, output = attention(Q, K, V, causal=True)
print("\n加上 causal mask 的权重")
print(weights)
print("每一行的和:", weights.sum(axis=1))

在 NumPy 1.26 上的实际输出：

不加 mask 的权重（每一行是一个词在看谁）
[[0.505 0.123 0.249 0.123]
 [0.352 0.174 0.352 0.122]
 [0.154 0.313 0.313 0.22 ]
 [0.666 0.056 0.231 0.047]]
「它」这一行: {'小猫': 0.666, '追': 0.056, '老鼠': 0.231, '它': 0.047}
「它」的输出向量: [0.782 0.171]

加上 causal mask 的权重
[[1.    0.    0.    0.   ]
 [0.67  0.33  0.    0.   ]
 [0.198 0.401 0.401 0.   ]
 [0.666 0.056 0.231 0.047]]
每一行的和: [1. 1. 1. 1.]

• 这里的数字和上面「亲手算一次 attention」里的完全一样，用的是同一组向量。可以对着那张表一格一格核对。
• 加上 mask 之后，矩阵的右上角全是 0：每个词只能看自己和前面的词。第一行只剩自己，所以权重是 1。
• 「它」是最后一个词，它后面没有词，所以加不加 mask 这一行都一样。
• 自己改一改：把除以 np.sqrt(d) 去掉，看「它」这一行会不会更集中在「小猫」上；把 Q 里「它」的向量改成 [0.5, 2]，看它转而去看谁。

速查表

考前十分钟过一遍

N-gram

数数。只看前几个词，词之间没有相似度。

Word2Vec

词变向量。一个词一个向量，不看上下文。

RNN

顺序读，一个隐藏状态。梯度消失，不能并行。

LSTM / GRU

加门和直通路，记得更远。还是不能并行。

Seq2Seq + Attention

encoder 读，decoder 写，attention 回头看原文。

ResNet

输出 = 输入 + 修改量。深层网络能训练的前提。

Transformer

只用 attention。并行，任意两个词一步直达，代价是计算量随长度的平方增长。

self-attention

softmax(QKᵀ / √d_k) · V。除以 √d_k 是为了不让 softmax 饱和、梯度消失。

BERT

encoder-only，双向，完形填空。理解和检索。

GPT

decoder-only，causal mask，预测下一个词。生成。

现代 LLM

Pre-Norm、RMSNorm、RoPE、SwiGLU、GQA、MoE、KV cache。

参数量

约 12 × 层数 × d² + 词表 × d。

Diffusion

逐步去噪。是生成方法，网络可以是 Transformer。

Mamba

计算量和长度成正比，状态按输入内容决定记什么。常和 attention 混用。

来源

「业界最新的方向」在 2026 年 10 月核对过，之后可能已经变化。页面里可以交互的数字（attention 的权重、位置编码、参数量）都是当场算出来的，没有写死。

• Attention Is All You Need（Vaswani 等，2017）
• Neural Machine Translation by Jointly Learning to Align and Translate（Bahdanau 等，2014）
• Sequence to Sequence Learning with Neural Networks（Sutskever 等，2014）
• Long Short-Term Memory（Hochreiter 和 Schmidhuber，1997）
• Efficient Estimation of Word Representations in Vector Space（Word2Vec，2013）
• Deep Residual Learning for Image Recognition（ResNet，2015）
• BERT（Devlin 等，2018）
• Improving Language Understanding by Generative Pre-Training（GPT，2018）
• GPT-2 的模型卡（参数量的出处，Hugging Face）
• An Image is Worth 16x16 Words（ViT，2020）
• LLaMA（Touvron 等，2023，Pre-Norm、SwiGLU、RoPE 的组合）
• RoFormer：Rotary Position Embedding（Su 等，2021）
• GQA：Grouped-Query Attention（Ainslie 等，2023）
• FlashAttention（Dao 等，2022）
• Denoising Diffusion Probabilistic Models（Ho 等，2020）
• Scalable Diffusion Models with Transformers（DiT，2022）
• Mamba（Gu 和 Dao，2023）
• DeepSeek-V3 技术报告（MoE）
• An Empirical Study of Smoothing Techniques for Language Modeling（Chen 和 Goodman，1998）
• On the difficulty of training recurrent neural networks（梯度裁剪，Pascanu 等，2013）
• Qwen3 技术报告
• Finding Structure in Time（Elman，1990）
• Learning to Forget：给 LSTM 加上遗忘门（Gers 等，2000）
• GRU 的出处（Cho 等，2014）
• ImageNet Classification with Deep Convolutional Neural Networks（AlexNet，2012）
• Google's Neural Machine Translation System（2016）
• Language Models are Unsupervised Multitask Learners（GPT-2，2019）
• RMSNorm（Zhang 和 Sennrich，2019）
• GLU Variants Improve Transformer（SwiGLU 的出处，Shazeer，2020）
• Attention is not Explanation（Jain 和 Wallace，2019）
• LLM Research Papers: The 2026 List（Sebastian Raschka，2026 年 6 月）
• Beyond Standard LLMs（Sebastian Raschka，2025 年 11 月）