# Transformer 下面这份讲义按经典 Transformer 架构图来讲。重点围绕原始论文 *Attention Is All You Need* 的 Encoder-Decoder Transformer。原论文提出 Transformer 完全基于 attention，去掉了循环和卷积结构，并强调其更容易并行训练。 # 0. 先用一句话抓住 Transformer 之前的RNN（循环神经网络）、LSTM（长短期记忆网路）、GRU（门控循环单元）都有一个缺点: ``` 1.循环结构串行计算，训练慢 2、长距离依赖衰减：链式法则与传统的非线性激活函数导致：梯度消失（网络难以学习到较早相关联的信息）梯度爆炸（网络无法收敛） ``` Transformer 本质上是在做一件事： > 把一串 token 先变成向量，然后让每个 token 通过 attention 去“观察”其他 token，更新自己的表示；Encoder 负责理解输入序列，Decoder 负责一边看已经生成的输出，一边参考 Encoder 的结果，逐步预测下一个 token。 *** # 1. Transformer 整体架构图怎么读？ ![0.40](http://www.uml.org.cn/ai/images/2024102241.png) 左边是 **Encoder**： ```text Input tokens → Input Embedding → Positional Encoding → N 个 Encoder Layer （原始论文中是6个层堆叠） → Encoder memory （Encoder的最终输出，形状[B,L,D]） ``` 右边是 **Decoder**： ```text Output tokens shifted right → Output Embedding → Positional Encoding → N 个 Decoder Layer → Linear → Softmax → Output probabilities ``` ![1.00](blob:http://47.95.236.184/efac0ad2-a4b6-4f16-9feb-1c8417a5fe7f) 其中： ```text batch_size = 一批样本数量 src_len = 输入序列长度 tgt_len = 输出序列长度 d_model = token 向量维度，原论文 base 模型是 512 vocab_size = 词表大小 ``` *** # 2. Input Embedding + Positional Encoding ![0.66](http://www.uml.org.cn/ai/images/2024102242.png) 由上图，可以看到Transformer由Encoder和Decoder两个部分组成，而且编码器和解码器都包含6层（原论文中是默认6个层）。下面以机器翻译（由中文我爱你翻译为英文I love you）为例来讲解Transformer的运作机理整个工作流程： ``` 原始文本 → 字符串形式的 tokens → Token IDs 整数列表 → embedding 向量 → Transformer ``` ## 2.0预处理：输入与分词对于上图整个模型的输入是中文我爱你，我们的目标是将其翻译成英文的I love you，但是对于中文我爱你模型是无法训练的，我们需要将其数值化再送入模型当中。 ### 2.0.1词表 **什么是词表：** 从数据结构上看，词表是一个\*\*“字符串（Token）到整数索引（ID）”的双向映射字典\*\*。 * **正向映射**：遇到单词 `"playing"`，查词表得到 ID `3562`。 * **反向映射**：模型输出 ID `3562`，查词表解码为文本 `"playing"`。 | 单词 (Token) | 编号 (ID) | | :--------- | :------ | | `I` | 1024 | | `love` | 3456 | | `you` | 7890 | | `` | 1 | | `` | 2 | | `...` | ... | > 这里注意：分词时每个Token不一定是一个单词，这里只是举例 **词表是如何构建的：** 词表不是凭空捏造的，而是通过**数据驱动**的方式从训练语料库中统计出来的。具体步骤如下： **第一步：收集海量语料** 首先需要一个巨大的文本数据集（例如维基百科、Common Crawl、书籍等）。比如 GPT-3 的训练数据包含了数千亿个单词。 **第二步：分词（Tokenization）** 这是最关键的一步。原始文本需要被切分成一个个独立的单元（Tokens）。这里有两种主要策略： * **按单词切分（Word-level）**： * 直接把空格分开。 * **缺点**：如果语料库很大，词表会无限膨胀（因为人类语言有无穷多的变体、拼写错误、生僻词）。而且无法处理未登录词（OOV, Out-of-Vocabulary）。 * *例子*：`["I", "love", "unbelievable"]` * 被切分的这些最小单元就是**token** * **按子词切分（Sub-word / Byte-Pair Encoding - BPE）**： * 这是目前主流的方法（如 BERT, GPT, T5 都用）。 * **原理**：先统计所有字符组合的频率，把最常见的双字符组合合并成一个新 token。重复这个过程，直到达到预设的词表大小。 * **优点**：既能覆盖大部分常用词，又能通过拆分处理生僻词。 * *例子*：如果词表里没有 "unbelievable"，它可能会被拆成 `["un", "believe", "able"]` 或者 `["un", "believ", "able"]`。这样即使遇到没见过的词，模型也能通过已知部分组合出意义。 **第三步：筛选与截断** 由于语料库太大，不可能把所有出现过的词都放进词表。通常采用以下规则： 1. **频率阈值**：只保留出现次数超过一定阈值的词（例如出现至少 2 次的词）。 2. **固定大小限制**：强制将词表大小控制在某个数值（如 32k）。超出这个数量的低频词会被忽略，或者归入一个特殊的 `` (Unknown) 标记。 **第四步：添加特殊标记** 最后，人工加入一些对模型运行至关重要的特殊标记： * ``：用于填充序列长度（让所有句子一样长）。 * ``：未知词汇的占位符。 * `` / ``：表示句子开始和结束。 * `[CLS]` / `[SEP]`：BERT 特有的分类标记和分隔标记。 ### 2.0.2分词 Transformer的标准流程中，**第一步绝对就是将原始输入文本根据词表进行分词（Tokenization）** 这是数据进入模型之前的**预处理**阶段，由`Tokenizer`（分词器）组件完成。 * **输入**：原始字符串，比如 `"I love AI!"` * **执行**：根据词表（Vocabulary），按照BPE等算法进行子词切分。 * **输出**：一个整数列表（***Token IDs***）。例如：`[42, 189, 3412, 0]`（对应 "I", " love", " AI", "!"） * 其中每一个数字就是一个***Token ID*** * **关键点**：**这一步完全是“查字典”的硬匹配过程，没有任何数学运算，也不涉及神经网络。** 此时文本变成了数字，但这些数字只是索引，还不具备语义。 * 流程： * 比如一句话： ``` I love machine learning. ``` 经过 tokenizer （分词器）以后，可能先被切成字符串 ***token***： ``` ["I", "love", "machine", "learning", "."] ``` 或者在 BPE / WordPiece 中可能切成子词： ``` ["I", "love", "machine", "learn", "##ing", "."] ``` 然后 tokenizer 会根据词表，把这些 token 映射成整数编号，也就是 ***Token IDs***： ``` [40, 1567, 3329, 4083, 2075, 13] ``` 真正送进 Transformer 的，一般不是字符串，而是这个***整数列表 Token IDs***。因为模型本身不能直接理解 `"love"` 这种字符串，它只能处理数字。所以每个整数 ID 会去 embedding table 里查对应的向量： ``` 1567 → 一个 d 维向量，这个向量叫做token embedding/token embedding vector/词嵌入向量 3329 → 一个 d 维向量 ... ``` 最后 Transformer 实际处理的是这些 embedding 向量。 * 这些向量就叫做：***token embedding / token embedding vector / 词嵌入向量*** ![1.00](data:image/png;base64,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 "如图，是一句话分词后的结果，即Token ID序列，也就是Token IDs") ![](blob:http://47.95.236.184/b28e6c03-2bcf-493e-9a57-9c80c8af395e) ## 2.1 Input Embedding 模型不能直接处理单词、汉字、子词这种符号，所以第一步是把 token id 变成***词嵌入向量***（即***token embeding***）。例如： ```text "我" → token id 1256 → 一个 d_model 维词嵌入向量 ``` 一个 **Token ID 变成 D 维词嵌入向量**，本质上是通过一个叫 **Embedding Table / 词嵌入矩阵** 的东西完成的。可以先记住一句话： > **Token ID 本身只是编号，embedding 层会根据这个编号去一张大表里“查一行”，这一行就是该 token 的 D 维向量。** ### 2.1.1 Embedding Table （词嵌入矩阵）是什么？想象你有一个巨大的表格（矩阵），我们称之为 **Embedding Matrix（嵌入矩阵）**。 * **行（Rows）**：对应词表中的每一个 Token ID。 * 假设有 V个词（例如 V=30,000），那么就有 30,000 行。 * **列（Columns）**：对应向量的维度 D 。 * 假设模型维度是 D=512 ，那么每一行有 512 个数字（列）。 **矩阵中的数字是随机初始化的，然后在训练过程中“学”出来的。** **阶段一：初始化 (Initialization)** 在模型开始训练前，这个巨大的矩阵（ V×D*V*×*D* ）里的所有数字都是**随机生成的**（通常服从高斯分布或均匀分布）。 * 此时，Token ID 42 对应的向量是一堆毫无意义的乱码。 * Token ID 43 对应的向量也是另一堆乱码。 * 它们之间没有任何语义关系。 **阶段二：训练 (Training)** 当模型开始学习（比如做机器翻译、预测下一个词）时： 1. 模型会利用这些随机的向量进行计算（Attention, FFN等）。 2. 如果模型预测错了（比如把“我爱你”翻译成 "I hate you"），它会计算**损失（Loss）**。 3. 通过**反向传播（Backpropagation）和**梯度下降（Gradient Descent），模型会微调这个 Embedding Matrix 里的数值。 * 它会让表示“我”的向量和表示“爱”的向量在空间中靠得更近。 * 它会让表示“猫”的向量和表示“狗”的向量在某些特征上相似（因为它们的上下文经常类似）。 * 它会让表示“苹果”的向量和表示“香蕉”的向量与表示“汽车”的向量距离很远。 **阶段三：收敛 (Convergence)** 训练结束后，这个矩阵里的数字就不再是随机的了。 * **每个向量都蕴含了该词的语义信息**。 * 如果你用降维工具（如 t-SNE）把这些向量画出来，你会发现相似的词会自动聚成一类。 ### 2.1.1 Token ID 如何变成词嵌入向量：查表整个过程其实就是查表，即根据ID找到某一行，将某一行的所有数取出假设某个 token 的 ID 是： ``` 1567 ``` 那么 embedding 层做的事情就是： ``` 去 embedding table 中取第 1567 行 ``` 这一行可能长这样： ``` [0.12, -0.35, 0.08, ..., 0.44] ``` 从数学的角度来看，查表的过程，也可以看作是矩阵乘法： ``` Token ID = 2 可以表示成 one-hot 向量： [0, 0, 1, 0, 0] 然后用它乘 embedding table：[0,0,1,0,0]×E 结果就是取出 E 的第 2 行。所以 embedding 本质上等价于： one-hot 向量 × embedding 矩阵但实际代码里不会真的创建巨大的 one-hot 向量，因为太浪费。实际实现就是直接根据 ID 查表。 ``` ![1.00](http://www.uml.org.cn/ai/images/2024102243.png "如图，就是Token IDs转化为词嵌入向量的结果。这就是input embeding的过程") 所有的词嵌入向量合起来形成一个矩阵，这个矩阵就是词嵌入矩阵 *** ## 2.2 Positional Encoding Self-Attention 本身不天然知道顺序。也就是说，如果只看 attention： ```text 我爱你你爱我 ``` 它看到的是一堆 ***token embeding***（即***词嵌入向量***），顺序信息不够明确。所以 Transformer 要把“位置信息”加进 token 表示中。经典做法是：**逐元素相加** ```text 最终输入向量 = token embedding + positional encoding ``` ![1.00](http://www.uml.org.cn/ai/images/2024102245.png) 原论文使用正弦、余弦位置编码：偶数维用 `sin`，奇数维用 `cos`。位置编码维度和 embedding 相同，所以可以直接相加。**同时注意：正余弦位置编码是不可学习的！！！** ### 2.1.1 正余弦位置编码原始 Transformer 论文中使用的是这种方式，叫： > **sinusoidal positional encoding**\ > **正弦余弦位置编码** 它不是训练出来的，而是用公式算出来的（当然这个位置编码是可学习的）。公式是这个： ![1.00](data:image/png;base64,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) 你不用一开始死背公式，先理解它在干什么： * pos：当前位置，比如第 0 个、第 1 个、第 2 个 token * i：向量中的第几个维度 * dmodel：向量总维度，比如 512、768 * 偶数维用 sin * 奇数维用 cos 所以每一个位置都会生成一个 D 维向量。比如： ``` 第 0 个位置 → P_0 = [sin(...), cos(...), sin(...), cos(...), ...] 第 1 个位置 → P_1 = [sin(...), cos(...), sin(...), cos(...), ...] 第 2 个位置 → P_2 = [sin(...), cos(...), sin(...), cos(...), ...] ``` 每个位置都有自己独特的“位置指纹”。可以理解成： > **第几个位置，就用公式生成第几个位置专属的 D 维向量。** ### 2.2.2. 为什么用 sin 和 cos？因为 sin、cos 有几个好处： **第一，它们可以表示不同位置** 不同位置 pos 代入公式后，会得到不同的位置向量。也就是： ``` P_1 ≠ P_2 ≠ P_3 ``` 这样模型就能知道： ``` 这个 token 在第 1 个位置那个 token 在第 2 个位置 ``` *** **第二，它们可以表达相对距离** sin、cos 有周期性和数学规律，所以模型更容易学到： ``` 位置 5 和位置 6 很近位置 5 和位置 20 比较远 ``` 也就是不仅知道“这是第几个”，还能够感知“两个 token 距离多远”。 *** **第三，它可以泛化到更长序列** 因为它是公式生成的，所以理论上可以继续算更靠后的位置。比如训练时最多见过长度 512，但公式仍然能算出第 513、514、1000 个位置的位置编码。当然实际效果不一定无限好，但它至少具备这种外推能力。 ### 2.2.3可学习的位置编码另一种方式叫： > **learned positional embedding**\ > **可学习位置嵌入** 这种方式和 token embedding 很像，也是一张表（即一个矩阵）。比如最大长度是 512，维度是 768：这张表中： ``` 第 0 行 → 第 0 个位置的位置向量第 1 行 → 第 1 个位置的位置向量第 2 行 → 第 2 个位置的位置向量 ... ``` 如果一个 token 在第 5 个位置，就取第 5 行的位置向量加到它的 token embedding 上。这类位置编码不是用公式算的，而是： > **随机初始化，然后通过训练学出来。** BERT、GPT 系列早期很多都使用过类似的可学习绝对位置嵌入。 *** ## 4. 举个小例子假设一句话是： ``` I love you ``` 分词后有 3 个 token： ``` ["I", "love", "you"] ``` 它们的 token embedding 是： ``` E_I E_love E_you ``` 位置编码是： ``` P_0 P_1 P_2 ``` 那么输入 Transformer 的向量是： ``` X_0 = E_I + P_0 X_1 = E_love + P_1 X_2 = E_you + P_2 ``` 如果换成： ``` You love I ``` 虽然 token 还是这几个，但位置不同了： ``` X_0 = E_you + P_0 X_1 = E_love + P_1 X_2 = E_I + P_2 ``` 这样模型就能区分： ``` I love you ``` 和： ``` You love I ``` 顺序信息就进来了。
*** # 3. Scaled Dot-Product Attention：注意力的最小核心这里先整理并复习一下前面的整个过程：首先，一段文本（例如“我爱你”）会经过分词器的处理，被切分成最小的语义单元Token： ``` [“我”，“爱”，“你”] ``` 同时每个Token都对应一个数字，即Token ID： ``` “我”：1；“爱”：2；“你”：3 ``` 最终整段文本会可以被表示为一串整数列表，即Token IDs： ``` Token IDs：[1,2,3] ``` 将所有的Token送入模型时会经过input embeding，每个token根据其对应的token ID会被表示为一个D维的词嵌入向量，并最终加上一个位置编码： ``` “爱” -> 1 -> [0.12,0.59,0.36....] + E_pos ``` 最终整段文本被表示为多个词嵌入向量： ``` [[0.23,0.67,0.58....], [0.12,0.45,0.23], [0.39,0.47,0.64]] ``` 如果你把**两句话**（例如 `"我爱你"` 和 `"他恨你"`）打包成一个批次（Batch）同时送入模型，那么最终的张量会再**套一层**，变成**三维张量**： text ``` [ [ [0.23,0.67,0.58], [0.12,0.45,0.23], [0.39,0.47,0.64] ], ← 第1句话 [ [0.11,0.22,0.33], [0.44,0.55,0.66], [0.77,0.88,0.99] ] ← 第2句话 ] ``` **形状：** `[Batch=2, L序列长度=3, D嵌入维度=3]` * Batch（B）：简单理解就是有几句话 * 序列维度（L）：简单理解就是一句话（一个Batch）里有多少个Token（通常会与最长句子做pedding对齐） * 嵌入维度（D）：简单理解就是一个Token的维度 ## 3.0 Q、K、V 是什么？ Attention 的核心是： ```text Query：我想找什么？ Key：我有什么特征可以被别人匹配？ Value：如果别人关注我，我提供什么信息？ ``` 对一个 token 来说： ```text Q 用来主动查询别人 K 用来被别人匹配 V 是真正被加权汇总的信息 ``` 举一个白话例子： ```text Query = 我现在想理解“苹果” Key = 每个词暴露出来的“可匹配标签” Value = 每个词真正携带的语义内容 ``` 如果句子是： ```text 我买了苹果手机 ``` “苹果”的 Query 可能会和“手机”的 Key 很匹配，于是“苹果”的新表示会更多吸收“手机”的 Value，模型就倾向于理解为 Apple，而不是水果。 ## 3.1 Q、K、V怎么来的 ![1.00](http://www.uml.org.cn/ai/images/2024102243.png "如图，就是Token IDs转化为input embeedings的结果。这就是input embeding的过程") ### 3.1.0 权重矩阵我们知道Encoder一共有6层（每一层都包含多头注意力子层和前馈神经网络子层）对于每一层来说，其三个权重矩阵都是相同的（即对该层的所有Token来说都是共享的） ### 3.1.1 关于单个词嵌入向量的Q、K、V 每一个词嵌入向量（**大小为1 ×D**），都会乘以三个可学习的权重矩阵W\_q , W\_k , W\_v（**其大小为D ×D\_k**），最终得到Q、K、V三个向量(**大小为1 ×D\_k** ) > 注意：多头注意力机制中，为了降低计算量，我们会将每一个向量压缩为D\_k维 > > 其中D\_k = D / h (h是头的数量) > > * 如果每个头都是 `D × D`，那么 8 个头的参数量就是 `8 × (512×512)`，计算量巨大。 > > * 通过压缩为 `D × (D/h)`，**总参数量不变**（8 个头 × 512×64 = 512×512），但让每个头在更小的子空间（64 维）中学习不同的“关注模式”。 ### 3.1.2 关于batch的Q计算下面是一个batch的词嵌入向量，分别对应“我”、“爱”、“你”三个Token ``` [ [0.23,0.67,0.58], [0.12,0.45,0.23], [0.39,0.47,0.64] ], ← 第1句话 ``` 输入矩阵 **X** 的形状是：`[L, D]`（L行，每行是一个Token的D维向量）此时，计算 Q、K、V 就是**最标准的矩阵乘法**： Q = X⋅WQ * X 形状：`[L, D]` * W^Q 形状：`[D, d_k]` * **结果 Q 形状**：`[L, d_k]` ### 3.1.3 关于多个Batch的计算现在把 **Batch\_Size = B** 加进来。此时输入矩阵 **X** 变成了**三维张量**： ``` [ [ [0.23,0.67,0.58], [0.12,0.45,0.23], [0.39,0.47,0.64] ], ← 第1句话 [ [0.11,0.22,0.33], [0.44,0.55,0.66], [0.77,0.88,0.99] ] ← 第2句话 ] ``` 形状为：`[B, L, D]`，即： `[Batch size=2, 序列长度=3, 嵌入维度=D]` * B = 批次里有几个句子 * L = 每个句子的长度（通常固定，或做 Padding 对齐） * D = 词嵌入维度 **把 Batch 里的 B 个句子分别独立地做** `[L, D] × [D, d_k]` **的矩阵乘法**，得到 B 个 `[L, d_k]` 的结果，最后再堆叠起来。 * **输入 X**：`[B, L, D]` * **权重 W^Q**：`[D, d_k]` * **输出 Q**：`[B, L, d_k]`
最终： **每一个词嵌入向量（每一个Token）都会最终对应生成一个 Q 向量、一个 K 向量、一个 V 向量** ![1.00](/api/storage/attachments/attachment-1782714688668-6e3f76/content) *** ## 3.2 Attention 公式 Scaled Dot-Product Attention 的公式是： ![1.00](data:image/png;base64,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) 原论文描述 attention 时说：Query、Key、Value 都是向量；输出是 Value 的加权和，权重由 Query 和 Key 的匹配程度计算得到。Scaled Dot-Product Attention 会先计算 `QK^T`，再除以 `sqrt(d_k)`，然后 softmax 得到权重。以一个Batch为例：由上面可知Q、K、V矩阵，然后我们利用Q和K相乘得到不同词之间的注意力分数 ![1.00](http://www.uml.org.cn/ai/images/20241022411.png) 为了提高并行度，我们利用矩阵进行运算，将Q和K的转置相乘，这样就会得到一个方型矩阵，矩阵的每个元素代表每个词对其它词的注意力分数。这个矩阵叫：“***注意力分数矩阵***” 同时该矩阵中的每一个元素需要同时除以一个根号下d\_k ![1.00](http://www.uml.org.cn/ai/images/20241022412.png) 然后我们会对得到的注意力分数进行Softmax操作来归一化，这样每一行的分数加起来就为1。假设： ```python Q: [batch_size, seq_len, d_k] K: [batch_size, seq_len, d_k] V: [batch_size, seq_len, d_v] ``` 那么： ```python QK^T: [batch_size, seq_len, seq_len] ``` 这个矩阵的含义是： ```text 第 i 行第 j 列 = 第 i 个 token 对第 j 个 token 的关注分数即：我爱你我 [ 5.0, 3.0, 0.5 ] 爱 [ 2.5, 6.0, 2.0 ] 你 [ 0.3, 2.5, 4.5 ] ``` softmax 后（**每一行归一化为概率**）： ```text 第 i 行 = 第 i 个 token 对所有 token 的注意力分布即：我爱你我 [ 0.65, 0.30, 0.05 ] → "我"的注意力分布：65%给自己，30%给"爱"，5%给"你" 爱 [ 0.15, 0.70, 0.15 ] → "爱"的注意力分布：15%给"我"，70%给自己，15%给"你" 你 [ 0.05, 0.30, 0.65 ] → "你"的注意力分布：5%给"我"，30%给"爱"，65%给自己 ``` ![1.00](http://www.uml.org.cn/ai/images/20241022413.png) 最后乘 V： ```text 每个 token 得到一个“融合上下文之后的新向量” ``` *** ## 3.3 为什么要除以 sqrt(d\_k)？因为 `Q · K` 是多个维度相乘再相加。如果 `d_k` 很大，点积值容易变大，softmax 会变得特别尖锐，导致 softmax 梯度趋近于 0。除以 `sqrt(d_k)` 是为了缩放分数，让 softmax 更稳定。白话版： ```text 不除的话，分数太激动；除一下，让它冷静点。 ``` *** # 4. Multi-Head Attention：多头注意力 ## 4.1 为什么需要多头？单头 attention 只能在一个表示空间里计算关系。多头 attention 的想法是： ```text 把 d_model 切成 h 份，每个头在自己的子空间里做 attention。 ``` 比如： ```text head 1 关注语法关系 head 2 关注指代关系 head 3 关注局部搭配 head 4 关注长距离依赖 ``` 当然这只是直觉解释，模型不会乖乖告诉你“我是语法头”，它只是在训练中自己学。小脑袋们开会，最后 concat 汇总，像一个多部门联合办公现场。原始 Transformer 中，Multi-Head Attention 会把 Q、K、V 线性投影多次，在不同子空间并行做 attention，然后拼接各个 head 的结果，再做一次线性变换。 *** ## 4.2 多头注意力的形状变化设： ```text d_model = 512 num_heads = 8 d_k = d_model / num_heads = 64 ``` 输入： ```python x: [batch_size, seq_len, d_model] ``` 经过线性层得到： ```python Q, K, V: [batch_size, seq_len, d_model] ``` 拆成多个头： ```python Q: [batch_size, seq_len, num_heads, d_k] ``` 再转置： ```python Q: [batch_size, num_heads, seq_len, d_k] ``` 做 attention： ```python context: [batch_size, num_heads, seq_len, d_k] ``` 转回来并拼接： ```python context: [batch_size, seq_len, num_heads, d_k] context: [batch_size, seq_len, d_model] ``` 最后输出线性层： ```python output: [batch_size, seq_len, d_model] ```
*** # 5. Mask：Transformer 里最容易糊的地方 Transformer 常见两种 mask： ```text Padding Mask：挡住 padding token Subsequent Mask / Causal Mask：挡住未来 token ``` ## 5.1 Padding Mask 如果一个 batch 里句子长度不同，就会补 ``：每一句 ```text 我爱你今天天气很好 ``` 但是它没有实际意义，模型不应该关注 ``，所以要 mask 掉。就需要使用Padding Mask来遮住它在注意力分数矩阵中，我们需要加 Padding Mask ，把 PAD 位置改成 `-∞` > softmax(-∞) ≈ 0 ### 5.1.1 Padding Mask 的形状如果输入是： ``` X.shape = [B, L, D] ``` 其中： ``` B = batch size L = sequence length D = embedding dimension ``` 比如： ``` B = 2 L = 4 ``` 输入 token 是： ``` [ [I, love, you, PAD], [I, love, deep, learning] ] ``` Padding Mask 可以是： ``` [ [1, 1, 1, 0], [1, 1, 1, 1] ] ``` 形状是： ``` [B, L] ``` 但是注意力分数矩阵形状通常是： ``` [B, num_heads, L, L] ``` 所以 Padding Mask 在实际使用时，常常会被扩展成： ``` [B, 1, 1, L] ``` 这样它可以广播到每一个 head、每一个 Query 位置上。你可以理解成： ``` 每个句子都有自己的 PAD 位置；每个注意力头都要遵守这个 PAD 屏蔽规则。 ``` ### 5.1.2 Attention score 为什么是 `[B, num_heads, L, L]`？假设： ``` B = 2 batch 里有 2 个句子 num_heads = 3 多头注意力有 3 个头 L = 4 每个句子长度补齐到 4 ``` 那么 attention score 的形状是： ``` [B, num_heads, L, L] = [2, 3, 4, 4] ``` 含义是： ``` [第几个句子, 第几个注意力头, Query位置, Key位置] ``` 重点是最后两个 `L, L`。对于一个句子、一个 head 来说，attention score 是一个 `4 × 4` 矩阵： ``` Key位置 0 1 2 3 Query 0 ? ? ? ? Query 1 ? ? ? ? Query 2 ? ? ? ? Query 3 ? ? ? ? ``` **行表示当前是谁在看别人，也就是 Query。**\ **列表示被看的对象是谁，也就是 Key。** 所以： ``` 第 0 行：第 0 个 token 在看所有 token 第 1 行：第 1 个 token 在看所有 token 第 2 行：第 2 个 token 在看所有 token 第 3 行：第 3 个 token 在看所有 token ``` *** ### 5.1.3 为什么要从 `[B, L]` 扩展成 `[B, 1, 1, L]`？因为 attention score 是： ``` [B, num_heads, L, L] ``` 而 padding mask 原本是： ``` [B, L] ``` 维度数量对不上。所以我们要把它扩展成： ``` [B, 1, 1, L] ``` 这四个维度分别对应： ``` [B, 1, 1, L] ↓ ↓ ↓ ↓ 句子 head Query Key ``` 也就是： ``` [第几个句子, 所有head共用, 所有Query位置共用, Key位置] ``` 为什么中间两个是 `1`？因为 **Padding Mask 对所有 head 都一样，对所有 Query 位置也一样。** *** ### 5.1.4 最关键：为什么是 `[B, 1, 1, L]`，不是 `[B, 1, L, 1]`？因为我们要屏蔽的是 **Key 位置上的 PAD**。也就是 attention score 矩阵里的 **列**。比如句子： ``` [I, love, you, PAD] ``` mask 是： ``` [1, 1, 1, 0] ``` 意思是： ``` 第 3 列是 PAD，所有 Query 都不能看它。 ``` 所以它要作用在矩阵的列上： ``` Key位置 I love you PAD Query I ? ? ? mask Query love ? ? ? mask Query you ? ? ? mask Query PAD ? ? ? mask ``` 也就是： ``` 最后一列全部屏蔽。 ``` 所以 mask 的最后一维必须对应 Key 位置： ``` [B, 1, 1, L] ``` 最后这个 `L` 就是 Key 长度。 *** ### 5.1.5 用一句话理解 `[B, 1, 1, L]` ``` [B, 1, 1, L] ``` 可以读成： ``` 对于 batch 中每一个句子，这个 mask 不区分 head，也不区分 Query 位置，只标记 Key 位置中哪些是 PAD。 ``` 也就是： ``` [B, 1, 1, L] = [每个句子, 所有头共用, 所有查询位置共用, 每个被关注位置是否可看] ``` *** ### 5.1.6 为什么不用直接做成 `[B, num_heads, L, L]`？当然也可以，但没必要。比如原始 mask 是： ``` [B, L] ``` 真正完整展开后会变成： ``` [B, num_heads, L, L] ``` 但是这样会重复存很多一样的东西。因为： ``` 每个 head 用的是同一个 padding mask 每个 Query 行也用的是同一个 padding mask ``` 所以用 `[B, 1, 1, L]` 就够了，框架会自动广播。这就像你不用给全班每个人发一张一模一样的课表，你只要在黑板上写一张，大家一起看就行。小小 mask，打工全场，属于 Transformer 里的“省流大师”。 *** ### 5.1.7 最后用一个完整小例子收一下输入： ``` 句子1: [I, love, you, PAD] ``` Padding Mask： ``` [1, 1, 1, 0] ``` Attention score： ``` Key I love you PAD Query I 2 1 3 4 Query love 1 5 2 6 Query you 3 2 4 7 Query PAD 1 1 1 8 ``` 加 mask 后，PAD 那一列变成 `-∞`： ``` Key I love you PAD Query I 2 1 3 -∞ Query love 1 5 2 -∞ Query you 3 2 4 -∞ Query PAD 1 1 1 -∞ ``` 然后 softmax 后： ``` PAD 那一列的注意力权重变成 0 ``` 所以模型不会关注 PAD。 *** ### 5.1.8 你可以这样记 **attention score 是** **`[B, H, L, L]`：** ``` B：第几个句子 H：第几个注意力头第一个 L：谁在看，也就是 Query 第二个 L：看谁，也就是 Key ``` **padding mask 是** **`[B, 1, 1, L]`：** ``` B：每个句子有自己的 PAD 位置第一个 1：所有 head 共用第二个 1：所有 Query 共用 L：屏蔽 Key 位置上的 PAD ``` 最核心的一句话： **Padding Mask 是贴在 attention score 的“列”上的，因为 PAD 作为 Key 时不应该被任何 token 关注。** ### 5.1.9 个人理解首先，Pading Mask它的含义是在某一个Batch Size中，要屏蔽的是哪一列（即屏蔽哪一个Key位置），因此它的形状是\[B, L] 它作用于注意力分数矩阵，而注意力分数矩阵的形状是\[B, N, L, L]，维度不匹配，因此我们需要拓展Pading Mask的形状以适配注意力分数矩阵的形状由Pading Mask的形状及含义可知，它只关注在哪一个Batch Size中的哪一列，它对于哪一个头以及哪一行（query位置）不关心，即对于所有的头和行来说都是一样的因此我们只需拓展为\[B, 1, 1, L]，即可自动复制到Head 维度与Query 维度 *** ## 5.2 Causal Mask：为什么 Decoder 要遮住未来？训练时，目标句子是完整给模型的。比如： ```text 我爱你 ``` 如果不加 mask，当预测“我”的时候，它可能偷看后面的“爱”“你”。这就像考试的时候答案就放在旁边，模型一边偷看一边说“我学会了”。不行，抓起来。所以 Decoder 的 self-attention 要保证： ```text 第 i 个位置只能看见 0 到 i 的位置，不能看见未来。 ``` 例如 `size = 4`： ```text 允许看的位置： 1 0 0 0 1 1 0 0 1 1 1 0 1 1 1 1 ``` *** # 6. Add & Norm：残差连接 + LayerNorm ![0.40](http://www.uml.org.cn/ai/images/2024102241.png) 在经典图中，你会看到很多： ```text Add & Norm ``` 它代表： ```text 输出 = LayerNorm(x + Sublayer(x)) ``` 这里的 `x` 是子层输入，`Sublayer(x)` 是 attention 或 FFN 的输出。原论文使用残差连接包住每个子层，并接 LayerNorm；为了残差连接可行，所有子层输出维度都保持 `d_model`。 ## 6.1 为什么需要残差连接？ **核心解决：梯度消失问题** 如果层数很深，信息和梯度容易在传播中变弱。残差连接提供一条“直通通道”： ```text 新信息 = 原始信息 + 子层加工后的信息 H（x） = F（x）+ x ——————> F（x） = H（x）- x ``` 这可以缓解深层网络训练困难。 **"更重要的是，反向传播时，梯度通过这个直通通道可以直接传回浅层，而不需要逐层乘以权重矩阵。"** ## 6.2 为什么需要 LayerNorm？ LayerNorm 对每个 token 的特征维度做归一化，让训练更稳定。注意一个面试细节： ```text 原始 Transformer 图是 Post-LN：LayerNorm(x + Sublayer(x)) 现代大模型常用 Pre-LN：x + Sublayer(LayerNorm(x)) ``` 面试时如果手撕经典 Transformer，写 Post-LN 更贴近原图；如果问现代 LLM 稳定训练，Pre-LN 更常见。 *** # 7. Position-wise Feed Forward Network：逐位置前馈网络 FFN 位于 Encoder 和 Decoder 每一层的后半部分。它对每个位置单独做同一个 MLP： ```text FFN(x) = Linear2(ReLU(Linear1(x))) ``` 原始 Transformer 的 FFN 是层线性变换，中间 ReLU；输入输出维度是 `d_model = 512`，中间层维度是 `d_ff = 2048`。形状变化： ```python x: [batch_size, seq_len, d_model] Linear1: [batch_size, seq_len, d_ff] ReLU Linear2: [batch_size, seq_len, d_model] ``` 为什么叫 **position-wise**？因为它不会混合不同 token 的位置。不同 token 之间的信息交换已经由 self-attention 完成了；FFN 只负责对每个 token 自己的表示做非线性加工。也就是说： ```text Attention：负责 token 之间交流 FFN：负责每个 token 内部加工 ``` *** # 8. Encoder Layer：编码器的一层现在把 Encoder 的一层拼起来。经典 Encoder Layer： ```text x → Multi-Head Self-Attention → Add & Norm → Feed Forward → Add & Norm ``` 在 Encoder self-attention 中： ```python Q = K = V = x ``` 因为它是在输入序列内部做自注意力。代码： ```python class EncoderLayer(nn.Module): def __init__( self, d_model: int, num_heads: int, d_ff: int, dropout: float = 0.1, ): super().__init__() self.self_attn = MultiHeadAttention(d_model, num_heads, dropout) self.ffn = PositionwiseFeedForward(d_model, d_ff, dropout) self.add_norm1 = AddNorm(d_model, dropout) self.add_norm2 = AddNorm(d_model, dropout) def forward(self, x: torch.Tensor, src_mask: torch.Tensor) -> torch.Tensor: """ x: [batch_size, src_len, d_model] src_mask: [batch_size, 1, 1, src_len] """ # 1. Self-Attention attn_output = self.self_attn(x, x, x, src_mask) x = self.add_norm1(x, attn_output) # 2. Feed Forward ffn_output = self.ffn(x) x = self.add_norm2(x, ffn_output) return x ``` 这个 Encoder Layer 的核心理解： ```text 第一步：每个输入 token 看输入句子里的所有 token，得到上下文表示。第二步：每个 token 单独经过 FFN 加工。第三步：残差和归一化稳定训练。 ``` *** # 9. Encoder：N 层 Encoder Layer 堆叠 Encoder 不是一层，而是多层堆叠。原始论文是 `N=6`。citeturn484409view0 ```python class Encoder(nn.Module): def __init__( self, vocab_size: int, d_model: int, num_heads: int, d_ff: int, num_layers: int, dropout: float = 0.1, max_len: int = 5000, ): super().__init__() self.token_embedding = TokenEmbedding(vocab_size, d_model) self.positional_encoding = PositionalEncoding(d_model, max_len, dropout) self.layers = nn.ModuleList([ EncoderLayer(d_model, num_heads, d_ff, dropout) for _ in range(num_layers) ]) def forward(self, src: torch.Tensor, src_mask: torch.Tensor) -> torch.Tensor: """ src: [batch_size, src_len] src_mask: [batch_size, 1, 1, src_len] return: memory: [batch_size, src_len, d_model] """ x = self.token_embedding(src) x = self.positional_encoding(x) for layer in self.layers: x = layer(x, src_mask) return x ``` Encoder 的输出通常叫： ```text memory ``` 它保存了输入句子的上下文表示，后面 Decoder 会通过 cross-attention 去读取它。 *** # 10. Decoder Layer：解码器的一层 Decoder Layer 比 Encoder Layer 多一个 attention。经典 Decoder Layer： ```text x → Masked Multi-Head Self-Attention → Add & Norm → Encoder-Decoder Attention / Cross-Attention → Add & Norm → Feed Forward → Add & Norm ``` ## 10.1 Masked Self-Attention 这里： ```python Q = K = V = decoder_x ``` 但要加 `tgt_mask`，防止看到未来 token。作用： ```text 让 Decoder 学会根据已经生成的 token 预测下一个 token。 ``` *** ## 10.2 Cross-Attention Cross-Attention 是 Decoder 和 Encoder 之间的桥。这里： ```python Q = decoder_x K = encoder_memory V = encoder_memory ``` 含义： ```text Decoder 当前每个位置拿着自己的 Query，去 Encoder 输出的 memory 中查找相关信息。 ``` 例如翻译时，Decoder 正在生成“爱”，它可以去源句子的 Encoder memory 里关注 “love”。原论文中 Decoder 的第二个 attention 子层会让 Decoder 的每个位置 attend 到输入序列所有位置。citeturn484409view0 代码： ```python class DecoderLayer(nn.Module): def __init__( self, d_model: int, num_heads: int, d_ff: int, dropout: float = 0.1, ): super().__init__() self.self_attn = MultiHeadAttention(d_model, num_heads, dropout) self.cross_attn = MultiHeadAttention(d_model, num_heads, dropout) self.ffn = PositionwiseFeedForward(d_model, d_ff, dropout) self.add_norm1 = AddNorm(d_model, dropout) self.add_norm2 = AddNorm(d_model, dropout) self.add_norm3 = AddNorm(d_model, dropout) def forward( self, x: torch.Tensor, memory: torch.Tensor, src_mask: torch.Tensor, tgt_mask: torch.Tensor, ) -> torch.Tensor: """ x: [batch_size, tgt_len, d_model] memory: [batch_size, src_len, d_model] src_mask: [batch_size, 1, 1, src_len] tgt_mask: [batch_size, 1, tgt_len, tgt_len] """ # 1. Masked Self-Attention self_attn_output = self.self_attn(x, x, x, tgt_mask) x = self.add_norm1(x, self_attn_output) # 2. Cross-Attention # Q 来自 Decoder，K/V 来自 Encoder memory cross_attn_output = self.cross_attn(x, memory, memory, src_mask) x = self.add_norm2(x, cross_attn_output) # 3. Feed Forward ffn_output = self.ffn(x) x = self.add_norm3(x, ffn_output) return x ``` Decoder Layer 的核心理解： ```text 第一步：看自己已经生成的内容，但不能看未来。第二步：看 Encoder 对输入句子的理解结果。第三步：每个位置单独经过 FFN 加工。 ``` *** # 11. Decoder：N 层 Decoder Layer 堆叠 ```python class Decoder(nn.Module): def __init__( self, vocab_size: int, d_model: int, num_heads: int, d_ff: int, num_layers: int, dropout: float = 0.1, max_len: int = 5000, ): super().__init__() self.token_embedding = TokenEmbedding(vocab_size, d_model) self.positional_encoding = PositionalEncoding(d_model, max_len, dropout) self.layers = nn.ModuleList([ DecoderLayer(d_model, num_heads, d_ff, dropout) for _ in range(num_layers) ]) def forward( self, tgt: torch.Tensor, memory: torch.Tensor, src_mask: torch.Tensor, tgt_mask: torch.Tensor, ) -> torch.Tensor: """ tgt: [batch_size, tgt_len] memory: [batch_size, src_len, d_model] src_mask: [batch_size, 1, 1, src_len] tgt_mask: [batch_size, 1, tgt_len, tgt_len] return: x: [batch_size, tgt_len, d_model] """ x = self.token_embedding(tgt) x = self.positional_encoding(x) for layer in self.layers: x = layer(x, memory, src_mask, tgt_mask) return x ``` *** # 12. Linear + Softmax：输出词表概率 Decoder 最后输出： ```python decoder_output: [batch_size, tgt_len, d_model] ``` 但我们要预测下一个 token，它应该是词表里的某一个词，所以需要映射到： ```python logits: [batch_size, tgt_len, vocab_size] ``` 代码： ```python class Generator(nn.Module): def __init__(self, d_model: int, vocab_size: int): super().__init__() self.proj = nn.Linear(d_model, vocab_size) def forward(self, x: torch.Tensor) -> torch.Tensor: # x: [batch_size, tgt_len, d_model] # logits: [batch_size, tgt_len, vocab_size] return self.proj(x) ``` 训练时一般不需要手动写 softmax，因为： ```python nn.CrossEntropyLoss() ``` 内部已经包含： ```text log_softmax + negative log likelihood ``` 所以训练时喂 logits 即可，不要先 softmax。这个也是面试小坑。 *** # 13. 完整 Transformer 手撕代码现在把 Encoder、Decoder、Generator 合起来。 ```python class Transformer(nn.Module): def __init__( self, src_vocab_size: int, tgt_vocab_size: int, d_model: int = 512, num_heads: int = 8, d_ff: int = 2048, num_layers: int = 6, dropout: float = 0.1, max_len: int = 5000, pad_idx: int = 0, ): super().__init__() self.pad_idx = pad_idx self.encoder = Encoder( vocab_size=src_vocab_size, d_model=d_model, num_heads=num_heads, d_ff=d_ff, num_layers=num_layers, dropout=dropout, max_len=max_len, ) self.decoder = Decoder( vocab_size=tgt_vocab_size, d_model=d_model, num_heads=num_heads, d_ff=d_ff, num_layers=num_layers, dropout=dropout, max_len=max_len, ) self.generator = Generator(d_model, tgt_vocab_size) def make_src_mask(self, src: torch.Tensor) -> torch.Tensor: return make_pad_mask(src, self.pad_idx) def make_tgt_mask(self, tgt: torch.Tensor) -> torch.Tensor: return make_tgt_mask(tgt, self.pad_idx) def forward(self, src: torch.Tensor, tgt: torch.Tensor) -> torch.Tensor: """ src: [batch_size, src_len] tgt: [batch_size, tgt_len] return: logits: [batch_size, tgt_len, tgt_vocab_size] """ src_mask = self.make_src_mask(src) tgt_mask = self.make_tgt_mask(tgt) memory = self.encoder(src, src_mask) decoder_output = self.decoder(tgt, memory, src_mask, tgt_mask) logits = self.generator(decoder_output) return logits ``` *** # 14. 训练流程：为什么 Output Embedding 下面写 shifted right？经典图右下角写： ```text Outputs shifted right ``` 这个非常重要。假设目标句子是： ```text 我爱你 ``` 训练 Decoder 时，输入不是完整目标本身，而是右移后的版本： ```text decoder 输入：我爱你预测目标：我爱你 ``` 也就是： ```python tgt_input = tgt[:, :-1] tgt_label = tgt[:, 1:] ``` 训练代码大概是： ```python criterion = nn.CrossEntropyLoss(ignore_index=pad_idx) src = torch.tensor([ [5, 8, 9, 0, 0], [4, 3, 7, 2, 1], ]) tgt = torch.tensor([ [1, 6, 7, 2, 0], [1, 9, 4, 3, 2], ]) # 输入给 decoder 的部分 tgt_input = tgt[:, :-1] # 要预测的标签 tgt_label = tgt[:, 1:] logits = model(src, tgt_input) # logits: [batch_size, tgt_len - 1, tgt_vocab_size] loss = criterion( logits.reshape(-1, logits.size(-1)), tgt_label.reshape(-1) ) ``` 这里 `ignore_index=pad_idx` 的作用是： ```text pad 位置不参与 loss 计算。 ``` *** # 15. 推理流程：逐 token 生成训练时可以一次性输入整个右移目标序列，因为有 causal mask，不会偷看未来。但推理时没有标准答案，只能一个 token 一个 token 生成。 ```python def greedy_decode( model: Transformer, src: torch.Tensor, bos_idx: int, eos_idx: int, max_len: int, ) -> torch.Tensor: """ src: [batch_size, src_len] return: generated: [batch_size, <= max_len] """ model.eval() batch_size = src.size(0) device = src.device generated = torch.full( (batch_size, 1), bos_idx, dtype=torch.long, device=device, ) with torch.no_grad(): for _ in range(max_len - 1): logits = model(src, generated) # 取最后一个位置的预测 next_token_logits = logits[:, -1, :] next_token = torch.argmax(next_token_logits, dim=-1, keepdim=True) generated = torch.cat([generated, next_token], dim=1) if torch.all(next_token.squeeze(-1) == eos_idx): break return generated ``` 推理过程： ```text 第 1 步：输入，预测 token1 第 2 步：输入 token1，预测 token2 第 3 步：输入 token1 token2，预测 token3 …… ``` 训练并行，推理自回归。这个区别面试也很喜欢问。 *** # 16. 用一个小例子走完整形状假设： ```python batch_size = 2 src_len = 5 tgt_len = 4 d_model = 512 num_heads = 8 d_k = 64 src_vocab_size = 10000 tgt_vocab_size = 12000 ``` 输入： ```python src: [2, 5] tgt: [2, 4] ``` Encoder： ```text src embedding: [2, 5] → [2, 5, 512] positional encoding: [2, 5, 512] → [2, 5, 512] encoder self-attention: Q/K/V: [2, 5, 512] 拆头后: [2, 8, 5, 64] attention scores: [2, 8, 5, 5] attention output: [2, 8, 5, 64] concat: [2, 5, 512] FFN: [2, 5, 512] → [2, 5, 2048] → [2, 5, 512] memory: [2, 5, 512] ``` Decoder： ```text tgt embedding: [2, 4] → [2, 4, 512] masked self-attention: scores: [2, 8, 4, 4] cross-attention: Q from decoder: [2, 8, 4, 64] K/V from encoder: [2, 8, 5, 64] scores: [2, 8, 4, 5] output: [2, 4, 512] FFN: [2, 4, 512] → [2, 4, 2048] → [2, 4, 512] generator: [2, 4, 512] → [2, 4, 12000] ``` 重点看两个 attention score： ```text Encoder self-attention: [B, H, src_len, src_len] Decoder masked self-attention: [B, H, tgt_len, tgt_len] Decoder cross-attention: [B, H, tgt_len, src_len] ``` 把这三个形状背熟，Transformer 的架构图就不再吓人了。 *** # 17. 面试高频问题总结 ## 17.1 Transformer 为什么比 RNN 更容易并行？ RNN 按时间步递归： ```text h1 → h2 → h3 → h4 ``` 后一个 hidden state 依赖前一个，所以不好并行。 Transformer 的 self-attention 可以一次性计算所有 token 两两之间的关系： ```text QK^T 一次矩阵乘法得到所有位置的注意力分数 ``` 所以训练阶段更容易并行。原论文摘要也强调 Transformer 相比循环/卷积序列模型更可并行、训练时间更少。citeturn631262view0 *** ## 17.2 Self-Attention 的时间复杂度是多少？对于长度为 `n` 的序列： ```text QK^T: [n, d] @ [d, n] → [n, n] ``` 所以 attention 的复杂度主要是： ```text O(n^2 · d) ``` 瓶颈来自 `n × n` 的注意力矩阵。 *** ## 17.3 Multi-Head Attention 参数量是不是增加很多？如果 `d_model=512, heads=8`，每个 head 的维度是 64。多头不是给每个 head 都保留完整 512 维，而是把 512 维拆成 8 个 64 维子空间。核心线性层仍然是： ```text W_Q: 512 × 512 W_K: 512 × 512 W_V: 512 × 512 W_O: 512 × 512 ``` 所以参数量并不会因为 8 个头直接变成 8 倍。 *** ## 17.4 Encoder self-attention、Decoder self-attention、Cross-attention 有什么区别？ ```text Encoder self-attention: Q = K = V = encoder input 可以看整个输入序列 Decoder masked self-attention: Q = K = V = decoder input 只能看当前位置及之前的位置 Cross-attention: Q 来自 Decoder K/V 来自 Encoder memory Decoder 根据当前生成状态去读取输入句子信息 ``` 一句话记忆： ```text Encoder 看输入全文； Decoder 先看已生成内容； Decoder 再看 Encoder 理解出来的输入信息。 ``` *** ## 17.5 为什么训练 Decoder 要 shifted right？因为要让模型学习： ```text 根据前面的 token 预测下一个 token ``` 例如： ```text 输入：我爱预测：我爱你 ``` 如果不 shifted right，模型可能直接看到自己要预测的 token。 *** ## 17.6 为什么 CrossEntropyLoss 前不要 softmax？因为 PyTorch 的： ```python nn.CrossEntropyLoss() ``` 内部已经做了： ```text log_softmax + NLLLoss ``` 如果你提前 softmax，会导致数值稳定性变差。 *** # 18. 手撕 Transformer 最小背诵版面试时如果让你手撕 Transformer，不一定要完整写一大坨。最常考的是这几个模块： ## 第一优先级：Attention ```python def attention(q, k, v, mask=None): d_k = q.size(-1) scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(d_k) if mask is not None: scores = scores.masked_fill(mask == 0, -1e9) attn = torch.softmax(scores, dim=-1) out = torch.matmul(attn, v) return out ``` ## 第二优先级：Multi-Head Attention ```python class MHA(nn.Module): def __init__(self, d_model, heads): super().__init__() assert d_model % heads == 0 self.heads = heads self.d_k = d_model // heads self.d_model = d_model self.wq = nn.Linear(d_model, d_model) self.wk = nn.Linear(d_model, d_model) self.wv = nn.Linear(d_model, d_model) self.wo = nn.Linear(d_model, d_model) def forward(self, q, k, v, mask=None): B = q.size(0) q = self.wq(q).view(B, -1, self.heads, self.d_k).transpose(1, 2) k = self.wk(k).view(B, -1, self.heads, self.d_k).transpose(1, 2) v = self.wv(v).view(B, -1, self.heads, self.d_k).transpose(1, 2) scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(self.d_k) if mask is not None: scores = scores.masked_fill(mask == 0, -1e9) attn = torch.softmax(scores, dim=-1) out = torch.matmul(attn, v) out = out.transpose(1, 2).contiguous().view(B, -1, self.d_model) return self.wo(out) ``` ## 第三优先级：Encoder Layer ```python class SimpleEncoderLayer(nn.Module): def __init__(self, d_model, heads, d_ff, dropout=0.1): super().__init__() self.attn = MHA(d_model, heads) self.ffn = nn.Sequential( nn.Linear(d_model, d_ff), nn.ReLU(), nn.Dropout(dropout), nn.Linear(d_ff, d_model), ) self.norm1 = nn.LayerNorm(d_model) self.norm2 = nn.LayerNorm(d_model) self.dropout = nn.Dropout(dropout) def forward(self, x, mask=None): attn_out = self.attn(x, x, x, mask) x = self.norm1(x + self.dropout(attn_out)) ffn_out = self.ffn(x) x = self.norm2(x + self.dropout(ffn_out)) return x ``` 把这三个写熟，Transformer 面试题你已经能拿下很大一块。后面 Decoder 只是多了： ```text masked self-attention + cross-attention ``` 不是新物种，只是多了一只小触手。 *** # 19. 你学习时的建议路线你可以按这个顺序练： ```text 第 1 遍：只看整体流程，不纠结代码第 2 遍：重点理解 Q/K/V 和 attention 公式第 3 遍：手撕 scaled dot-product attention 第 4 遍：手撕 multi-head attention 第 5 遍：手撕 EncoderLayer 第 6 遍：再补 DecoderLayer 和完整 Transformer ``` 最关键的是：**不要一上来背完整代码**。先把张量形状走通，再写代码。Transformer 不怕难，怕的是 shape 乱飞。只要 shape 稳了，它就从“怪兽”变成“积木”。