Stanford-CS224N

1. Lecture 1

1.1 独热编码

每个不同的向量代表一个单词，例如:

motel = [0 0 0 0 0 0 1]  
hotel = [0 0 0 0 0 1 0]

这个方案的缺点很明显: 没法判断每个向量之间的相似性，虽然上面motel和hotel代表的向量是正交的，但它们之间相互有关联；其次这些one-bot vector的维度会非常大，因为词汇表中往往有几十万的单词。

1.2 词向量

基于单词的上下文获得它的含义，通过学习各个单词的含义得到更加密集的词向量。

expect = [
          0.286,
          0.792
          ...
         ]

1.3 Word2vec

重要假设：文本中里的最近的词语相似度越高

• CBOW: 用中心词预测上下文词
• skip-gram: 用上下文词预测中心词

上下文词的数量取决于窗口大小，中心词是每次遍历的词语。实战中除了用上下文来预测中心词，还需要用到负样本词，也就是非上下文词，具体用多少或者是否采用，取决于语料库大小。

对于每一个中心词，我们给其他词出现的概率定义为：

假设j是窗口大小，对于每个中心词，它上下文词语出现的概率即为：

我们希望P(上下文词∣中心词) 越高,这样就说明我们预测越准确。

对于单个中心词的似然函数是：

假设玩一个预测游戏,中心词是 “猫”，窗口内上下文词有两个：[“在”, “睡觉”]。模型预测：“在”出现的概率 = 0.8，“睡觉”出现的概率 = 0.9，同时猜对两个词的概率就是：0.8×0.9=0.72，乘起来，就是“两个词都预测对的概率”。

整个语料库的似然函数/目标损失函数就是：

一般使用两个技巧来优化 Loss:

1. 一般都是最小化而不是最大化，所以对Loss取负数，之后采用梯度下降
2. 采用取对数减小数字大小，方便计算

最后的目标损失函数即为：

给定中心词预测上下文词的公式如下：

1. 通过中心词和上下文词的内积，计算他们之间的相似度
2. 通过exp取指数，它保证输出是正数。概率需要是正数
3. 通过归一化使得它是0-1的小数，也就是说$P(w_o \mid w_i) = \frac{\text{该词在上下文i中的得分}}{ \text{所有词在上下文i中的得分}}$

那前面说的中心词和上下文词的向量是如何得到的呢？一开始模型会为这些词随机一个向量，然后在梯度下降的过程中优化这些向量。

Word2Vec的目标函数/损失函数与深度学习中回归问题的损失函数有所不同。

• 回归问题通常是用对已知值和预测值的差进行拟合
• Word2Vec只是要求模型“预测的概率分布”尽量让真实上下文词的概率高

Word2Vec 的思想是“最大化概率”，它不直接比较预测值和真实值，而是要求模型“预测的概率分布”尽量让真实上下文词的概率高。

即：

回归问题是希望"预测值-真实值"尽可能小，而Word2Vec是希望概率尽可能大（取负数之后尽可能小），也可以看做是一个Loss Function。

2. Lecture 2

2.1 梯度下降

传统梯度下降算法的缺点在于：

1. 计算成本大：$J(\theta) = \frac{1}{N} \sum_{i=1}^{N} L(x_i, y_i; \theta)$，这意味着每一次计算梯度都需要全部样本参与计算，开销很大
2. 容易陷入局部最小值

2.2 随机梯度下降

仅仅在全部数据集中选取一个很小的子集，例如16或32个数据，用这些数据充当完整的数据集来计算损失函数和优化梯度

在深度学习中出现噪声经常会有更好的效果

2.3 跳字负采样

Skip-Gram用的是Softmax概率:

也就是说会计算整个Corpus的分母，计算量非常大。

负采样的思想是，不再计算整个词表的概率，而是单单判断正样本（上下文）和负样本（随机采样的非上下文词）

对于一个中心词$w_i$和一个上下文词$w_o$以及负样本集K，目标函数是：

2.4 共现矩阵

回顾之前提到的构造词向量的方法：one-hot编码和word2vec思想，还有一种更简单的表示思路。让相邻的词的向量表示相似，直接统计哪些词是经常一起出现的。下面图片就是CS224N课程中举的例子，根据三个句子的语料库构造的共现矩阵。

这样的表示明显优于one-hot表示，因为它的每一维都有含义——共现次数，因此这样的向量表示可以求词语之间的相似度。
但是这样表示还有有一些问题：

1. 维度=词汇量大小，还是太大了
2. 还是太过于稀疏，在做下游任务的时候依然不够方便。

对于第一个问题可以采用SVD奇异值分解的方法，它可以将任意矩阵分解为三个矩阵的乘积。为了减少尺度同时尽量保存有效信息，保留对角矩阵的最大的k个值，并将矩阵U，V 的相应的行列保留。

2.5 GloVe

GloVe=Global+Vector，它的核心理念是：如果两个词在语料库中经常出现在相似的上下文中，它们的词向量就应该相似。

但不同于 Word2Vec 的「预测式」学习，GloVe 是一个「统计式」模型，直接利用共现矩阵的全局统计信息。

2.5.1 共现概率

人为的定义共现概率：

• $X_{ij}$是词j出现在词i上下文的总次数
• $X_i=\sum_kX_{ik}$，也就是词i的上下文总数

举个例子，Corpus中有下面两个句子，并且我们需要计算P(I,like)：

I like A
I like B

那我们可以得到共现矩阵:

根据公式可以得到：

从共现矩阵可以看到，$X_{I,like}=2$。假设窗口大小为1，那么$X_I=2$，$P(I,like)=1$；假设窗口大小为2，那么$P(I,like)=\frac{1}{2}$

GloVe 的一个非常直观的出发点是：

某些词之间的意义差异可以通过共现概率比值体现。

那么就认为red比green相对apple更有意义.

于是GloVe希望学习到一个函数能够近似概率比值:

经过一系列数学推导(下文会计算)，词向量的点乘可以近似于:

此时损失函数就变成了拟合这个关系，我们希望他们尽可能相等，也就是

尽可能等于0

得到目标函数/损失函数的表达式后的操作就很简单了，对式子求偏导进行梯度下降，优化随机生成的词向量$w_i$和$w_j$

某些词（比如 “the”）出现太多，会让损失被它们主导。所以 GloVe 加了一个权重函数$f(X_{ij})$。$f(x)$ 越大，代表词的重要性越高。

与Word2Vec的目标函数相比，GloVe的损失函数更像回归问题

Glove 的作者认为，单词词向量空间是一个线性结构，例如 “man” - “women” 的差与 “king” - “queen” 的差很相近.

作者假设存在一个函数：

并且假设F是一个点乘的计算即：

这个式子可以化简为:

从中可以看到存在这样的关系：

即：

我们可以抽象出一般的形式,$b_i$和$\tilde{b_k}$是偏置，吸收了$\log(X_i)$和其他常数：

值得注意的是，在 GloVe 中，每个词都有两个向量：

词向量 $w_i$ — 表示这个词本身

上下文向量 $\tilde{w_j}$ — 表示当这个词出现在别的词的上下文中时的“角色”

并不是每次出现的上下文词直接拿句子里的其他词的向量，而是每个词都有一个固定的上下文向量，用来参与 共现对的预测。

最后训练结束词向量一般直接用$w_i$或者取$w_i$和$\tilde{w_i}$的平均值

2.6 评估

3. Lecture 3

3.1 矩阵微积分

3.2 雅克比行列式

可以得到:

3.3 反向传播

• 前向传播就是单纯的计算
• 反向传播是根据梯度进行学习

单输入单输出的情况下,下游梯度就是局部梯度与上游梯度的乘积。

多输入的情况下仍然遵循链式法则。

如图是一种错误的计算反向传播的方式，如果依次计算$\frac{\partial{s}}{\partial{W}}$和$\frac{\partial{s}}{\partial{b}}$，那么会有一部分计算是重复的，就导致反向传播的效率下降。正确的方式应该是先计算公共部分，然后再计算单独的部分，这可以通过拓扑排序来实现。

3.4 demo实现

class multiplyGate():
    def forward(x, y):
        self.x = x
        self.y = y
        return x*y
    def backward(dz):
        dx = self.y * dz  # dz/dx * dL/dz
        dy = self.x * dz
        return [dx, dy]

4. Lecture 4

4.1 依存语法

传统的传统句法（如短语结构语法）认为句子是由短语组成的层级结构。以I saw a cat under the table为例子

• table是名词
• the table 组成名词短语
• under 是介词
• under the table 组成介词短语
• a cat under the table 又组成一个名词短语…..

而依存语法的出发点不同，它提出了一个非常重要的假设：

句子的结构由词与词之间的依存关系（dependency）决定。

以 “I like you” 举例:

like -> I    (nsubj)
like -> you  (obj)

• 一般动词都是一个句子的核心
• I 依赖于 like，依赖关系是主语(nsubj)
• you 依赖于 like， 依赖关系是宾语(obj)

4.2 依存句法分析

Dependency Parsing = 给句子中的每个词，确定它依赖于哪个词，也就是预测词之间的依存关系。

当我们预测句子中词与词的依存关系时，模型应该考虑哪些信息来源?

1. Bilexical affinities: 两个具体词之间的亲和度
2. Dependency distance: 依存关系之间的距离
3. Intervening material: 依存关系通常不会跨越动词或标点等强结构边界
4. Valency of heads: 一个中心词一般有规定数量和方向的依存词，例如happy通常只修饰一个名词

为了保证结果合法，依存分析通常要满足一些约束：

1. Only one word is dependent of ROOT 整个句子只有一个核心动词（一个 root）
2. No cycles (A→B, B→A) 不允许形成环，否则依存树不成立
3. Dependencies form a tree 所有依存边连通、无环，每个节点只有一个入边

箭头是否可以交叉？

• Projective tree（投射句法）：所有依存边都不交叉 → 典型的英语句子结构
• Non-projective tree（非投射句法）：有交叉依存 → 常见于自由语序语言（如德语、俄语、中文）

4.3 依存分析方法

• 动态规划
• 图算法
• 约束满足法
• 转移系统：维护一个 Stack + Buffer。由于变成一个线性的计算过程，所以时间复杂度也是线性的，相较于其他两种方法低很多。

4.4 依存关系和深度学习

转移系统（Transition-based Dependency Parsing） 是依存句法分析中最直观、工程上最常用的一类算法。它维护了两个数据结构：Stack和Buffer，并且只进行三个操作：Shift，Left-Arc，Right-Arc。

以句子"I eat apples"为例：

1.Initial
Stack = [ROOT]
Buffer = [I, eat, apples]
Arcs = []

2.Shift
Stack = [ROOT, I]
Buffer = [eat, apples]
Arcs = []

3.Shift
Stack = [ROOT, I, eat]
Buffer = [apples]
Arcs = []

4.Left-Arc
Stack = [ROOT, eat]
Buffer = [apples]
Arcs = [(eat, I)]

5.Shift
Stack = [ROOT, eat, apples]
Buffer = []
Arcs = [(eat, I)]

6.Right-Arc
Stack = [ROOT, eat]
Buffer = []
Arcs = [(eat, I), (eat, apples)]

7.Right-Arc
Stack = []
Buffer = []
Arcs = [(eat, I), (eat, apples), (ROOT, eat)]

依存树:
ROOT
 └── eat
      ├── I
      └── apples

从中可以看出，对于深度学习模型它需要做的就是判断每次需要进行哪个操作，三选一。

4.5 评价指标

在深度学习中训练模型需要有一个损失函数，根据梯度进行优化，也就是说我们需要一个指标来评价预测的依存关系的好与坏。

Gold:                  Parsed:
1  2 She     nsubj     1  2 She     nsubj
2  0 saw     root      2  0 saw     root
3  5 the     det       3  4 the     det
4  5 video   nn        4  5 video   nsubj
5  2 lecture obj       5  2 lecture ccomp

1. UAS \( UAS=\frac{正确预测的head词数}{总词数}=\frac{4}{5}=80\% \)
2. LAS \( LAS=\frac{head和label都预测正式的词数}{总词数}=\frac{2}{5}=40\% \)

4.6 神经网络依存分析

在用神经网络对依存分析的每一步操作进行预测的时候，需要当前状态的一个输入值，这个输入的向量应该怎么得到呢？

很显然我们目前有Stack和Buffer还有Arcs三个状态，但是如果把全部的信息一股脑的输入给神经网络就冗余了，它只需要其中的几个关键信息：

1. Stack栈顶和次栈顶的元素: s1, s2
2. Buffer最前面马上要被处理的词: b1
3. 在Arcs中s1, s2, b1的左右孩子

需要Arcs中元素对的原因是：假如一个词已经拥有了主语就不可能再有一个主语了

知道了模型输入需要的全部信息，接下来就要考虑怎么把它传输给模型。

对于每个被选中的词（如 s1、s2、b1 及其子节点），我们可以取它的词向量（word embedding），同时拼接其他特征的向量，如：

• 词性（POS）嵌入
• 依存关系标签嵌入（对已建立的弧）
• 是否是根节点、是否已有父节点等布尔特征

最终，这些向量会被拼接成一个大的状态表示向量：

5. Lecture 5

5.1 语言模型

1. LM可以通过一句话的前n个词，计算出下一个词是某个词的概率。

2. LM可以计算出某句话出现的概率

5.2 N-gram

N-gram 指的是一堆连续的词，而 N 指的是这一堆词的个数。一个 N-gram 的 LM 就可以根据前 N-1 个词，预测出第 N 个词的概率。

对于一个N-gram的LM，我们需要做一个假设：某个词出现的概率只由其前N-1个词决定。

假如我们有一个 3-gram 的 LM，要根据“今天天气怎么样”来预测下一个词，那么只能使用“怎么样”来预测，而不看之前的字。

• 等式1就是根据之前的假设得到的
• 等式2是通过条件概率计算得到的
• 概率用语料库中出现的频率来估计

稀疏性问题

1. 当分子在语料中不存在的时候，可以采用一个很小的数补上，例如0.25
2. 当分母在语料中不存在的时候，我们可以采用 backoff 的策略，统计(N-2)-gram的个数。

存储问题

虽然这种基于计数的LM的很简单，但是我们必须穷举出预料中所有可能的N-gram，并逐一去计数、保存，N一旦大起来的话，模型的大小就会陡增。

对于文本生成来说，这种基于计数的LM则有很大问题了。这里拿CS224N的PPT上的一个例子来说明：

5.3 循环神经网络 RNN

RNN 的设计思路如下：

1. 传入文本的 one-hot 编码
2. 在嵌入层中取出每个词对应的 embedding
3. 开始循环处理：首先初始化一个矩阵 $w_0$，每次循环用一个矩阵$w_i$和词向量相乘，再与上一个矩阵相加得到新矩阵，循环往复。
4. 最后进行 softmax

但是 RNN 的缺点也很明显：

1. 循环的次数和文本长度有关，效率低
2. 长文本难以捕捉相互关系

训练过程

我们把序列作为输入，输入到RNN网络中，每一步都可以得到一个输出，这个输出即为当前步的下一个词的概率分布。我们使用这个概率分布可以和真实的概率分布计算一个损失。明确了损失函数，我们就很容易去训练了。

以上图为例，首先输入the，得到下一个词的概率分布，与students计算损失。之后输入第二字词students与正确的opened计算损失。最后将损失相加计算平均损失。

在大训练文本上通常会固定大小切割一次，不会考虑语言细节。并且这个好处在于可以组合成为矩阵方便输入。

6. Lecture 6

6.1 梯度消失&梯度爆炸

RNN 在进行反向传播，计算第 j 步的损失对前面的一步梯度的时候，需要运用链式法则：

根据 RNN 的公式$h_t=tanh(Wx \cdot x_t + W_h \cdot h_{t-1} + b_h)$，将激活函数忽略可以得到，$h_t$对$h_{t-1}$的偏导就是 W，所以我们可以近似得到：

可以看出，当 W 很小或者很大，同时 i 和 j 相差很远的时候，由于公式里有一个指数运算，这个梯度就会出现异常，变得超大或者超小，也就是所谓的“梯度消失/梯度爆炸”问题。

梯度爆炸的解决办法很暴力很简单，就是当梯度超过一个阈值时候，将它裁剪成阈值大小：

6.2 LSTM

LSTM 在 RNN 的基础上很好的解决了长距离详细传递的问题，它引入了 Cell State 和三个门 Forget Gate, Input Gate 和 Output Gate 来传输记忆和决定哪些记忆是需要的，哪些不需要。

• 遗忘门：根据$h^{t-1}$和$x^t$判断 Cell State 哪一些需要遗忘
• 输入门：根据$h^{t-1}$和$x^t$判断需要向 Cell State 传入哪些当前信息
• 输出门：根据$h^{t-1}$和$x^t$判断需要从 Cell State 中输出哪些信息

以 Forget Gate 举例：

sigmoid 激活函数会将计算结果隐射到 0-1 的区间，然后与 $c^{t-1}$相乘。值越接近于 1，历史记忆就保留；相反值趋于 0，历史记忆就遗忘。

为什么 LSTM 相对于 RNN 能够记忆更长的记忆？

我们回顾一下 RNN 的公式：

由于参数矩阵是固定的，所以进行反向传播时候，梯度要么会非常大要么会非常小。

但是对于 LSTM，它的三个门控机制可以选择每次保留 or 遗忘记忆，使得历史记忆可以长期保存。举一个极端的例子，遗忘门总是为 1，输入门总是为 0，那么历史记忆就能一直在 Cell State 上流通。

实际上，LSTM 不光是解决了长距离依赖的问题，它的各种门，使得模型的学习潜力大大提升，各种门的开闭的组合，让模型可以学习出自然语言中各种复杂的关系。比如遗忘门的使用，可以让模型学习出什么时候该把历史的信息给忘掉，这样就可以让模型在特点的时候排除干扰。

7. Lecture 7

7.1 BLEU 评估指标

BLEU 是机器翻译中最经典的自动评价指标之一，用来衡量模型生成的译文（candidate）和 人工参考译文（reference）之间的相似度。

BLEU 的核心思想: N-gram（词序列）有多少和参考译文匹配。匹配越多，得分越高。

计算过程

candidate: the cat the cat on the mat
reference: the cat is on the mat

1. Step 1: unigram precision

• total clipped = 5
• total candidate unigram = 8
• unigram precision = 5/8

Step 2：bigram precision

• total clipped = 3
• total candidate bigram = 6
• bigram precision = 3/6

同理计算 p3 和 p4。

Step 3：长度惩罚

len(candidate) > len(reference) 所以没有惩罚，BP=1

Step 4：综合 BLEU

在这个例子中，假如翻译的句子 candidate=the，那么它在 1-gram 中就能得到很高的分数，避免预测过短的句子就会采用惩罚机制：当预测长度>参考长度则不惩罚，BP=1；当预测长度<参考长度，BP=exp(1 - r/c)

机器翻译很怕高阶 n-gram 全不匹配

举个例子：

candidate: the the the the the the
reference: the cat is on the table

对于 2-gram 有:

candidate bigram: "the the", "the the", ...
reference bigram: "the cat", "cat is", ...

总 clipped=0, 总 can bigram=5, 得到 p(2)=0。
计算 BLEU 分数时：$geo\_mean = exp(\frac{1}{4}( \log(p_1) + \log(p_2) + \log(p_3) + \log(p_4)))$

由于 log(0) 等于负无穷，所以取对数之后 BLEU 分数为 0。

7.2 注意力机制

7.2.1 经典点积注意力

• $S^T$ 是 Decoder 在当前时间步的隐藏状态 dec_hidden
• $h_i$ 是 Encoder 的第 i 个 token 对应的隐藏状态 enc_hidden_i
• $s^Th_i$ 就能得到 Decoder 当前 token 和 Encoder 第 i 个 token 的注意力分数，对 Encoder 的每一个注意力分数进行 softmax 就能得到注意力权重

这个就是最早提出的 Bahdanau 注意力，但是这个算法的问题在于：$h_i$ 这个向量包含了完整信息，也就是有太多不需要的信息了。

7.2.2 乘法注意力

乘法注意力的解决方法就是：在两个向量之间乘一个矩阵，这个矩阵可以学习隐藏状态哪一部分是有用的

7.2.3 低秩乘法注意力

乘法注意力的问题在于，当隐藏状态长度很大时，中间矩阵的参数量就会非常大。解决办法是把大方阵拆为两个低秩的矩阵，它们有一样的效果。

8. Lecture 8

8.1 Self-Attention

8.1.1 Key, Query, Value

从单条文本来看，矩阵 $x=Ew_t$ 形状为 [SeqLen, EmbeddingSize]。

1. 用权重矩阵 Q,K,V 转换词向量

为了提高计算效率，可以把 Q,K,V 合并为一个大矩阵和 x 相乘，然后再把各个部分取出来，类似 BiLSTM 中四个门控计算合并到一个 [4*H, B] 的大矩阵，然后再通过 .chunk 分开。

2. 用输入 x 去查询其他 token 的 Key

用词向量的 Query 去查询其他词向量的 Key 得到它们的相似度，具体数学运算就是向量的点积，最后对每个 token 的相似度做z softmax 就能得到相似权重。

我们把 $e_{ij}$ 拆开来看:

Q：为什么不把 $Q^TK$ 直接用一个矩阵表示呢，还有乘两次这么麻烦？
A：因为提前把它们合并成一个矩阵，那么这个矩阵的大小也会变成 [SeqLen, SeqLen] 意味着矩阵大小依赖于输入序列的长度，参数矩阵可能会变得非常大。

Q：为什么采用点积计算两个向量的相似度？不采用余弦相似度其他的？

Q：这种拆解矩阵的低秩表示会不会对最终结果有影响？ A：实验证明模型并不需要高秩的注意力矩阵，低秩反而是归纳偏置，有助于泛化。

3. 计算 x 的输出

将每个 token 的权重乘上它对应的 Value 得到加权和就是最后 x 的输出，这个输出值代表 x 在句子中的上下文含义：

8.1.2 自注意力机制的问题和解决方法

1. 不知道文本顺序

自注意力机制和 RNN 或者 LSTM 不同，RNN 是从左到右或者右到左来更新隐藏状态矩阵的，而自注意力机制各个 token 之间不相互依赖，可以进行并行操作，但带来的缺点就是 模型不知道 token 之间的先后关系，例如: I love you 和 You love me 在它看来是一样的。

解决方案是：

正余弦位置编码

• 优点: 不需要学习，可以泛化到更长的序列,例如模型只训练到 512 长度，推理时给 4096 → 仍可用
• 缺点：表达能力有限

可学习位置编码

定义一个和 x 大小相同的可训练矩阵，类似:

self.position_embedding = nn.Embedding(seqlen, embedding_size)

直接把 x 和 position_embedding 叠加，让模型训练学习位置信息。缺点在于无法extrapolation，训练 max_len=512，推理时来个 2048 没 embedding 只能报错。

2. 没有非线性因素

可以在 self-attention 层计算各个 token 注意力分数之后通过一个前馈网络 MLP:

3. 不能窥视后续文本

以 “I love you” 生成 “我爱你” 为例， 在 Encoder 上生成 “爱” 的时候，我们只能看到之前的 “<sta>"；在生成 “爱” 的时候只能看到之前的 “<sta>我”，之后的 token 对当前 token 来说应该是 invisible 的。但是之前的自注意力机制中计算注意力分数，我们直接整个矩阵相乘了，也就是说任意 token 都能窥视之后的信息，解决办法就是利用掩码：

这样经过 softmax 之后，掩码位置都会变成 0，和 Value 相乘就不会影响模型。

8.2 Transformer

8.2.1 多头注意力

多头注意力的出现是为了解决单头注意力机制的表达能力瓶颈。

人处理语言时会同时从多个角度去看的：

• 一个角度看语法结构（主语-谓语关系）
• 一个角度看语义相似度
• 一个角度看指代消解
• 一个角度看世界常识

单头必须把这所有线索压缩到一个 $d_k$ 维的空间里去学太勉强了，容易学偏或者学模糊。

多头注意力就是把 $d_k$（比如 512）维分成 h=8 份，每份 64 维，让 8 个空间各自专心学一种关注模式，例如：

• Head 1：专门学语法结构（比如主语更关注谓语）
• Head 2：专门学短距离依赖（相邻词关注多一些）
• Head 3：专门学长距离依赖（句首和句尾关注）
• Head 4：专门学指代关系
• Head 5：专门学情感极性

每个 head 都在一个低维子空间（64维）里独立学习一种“关注策略”，互不干扰。最后再把 8 个 head 的结果拼接起来，经过一个线性层融合，就相当于模型同时从 8 个不同角度理解了这个句子。

8.2.2 缩放点积注意力

注意力机制存在一个问题就是：当模型规模变大之后，向量的点积也会随之变得很大

数学证明：

首先我们要明确 Softmax 是一个 n → n 的函数，所以它的梯度不是一个数而是一个雅可比矩阵：

根据链式法则有:

给定输入向量:

softmax 之后得到输出的第 i 个分量为:

求偏导得到:

当 softmax 的输入某个 $x_i$ 特别大的时候，经过 softmax 就会变得接近 one-hot 编码，这时候最大项的梯度 $p_i(1-p_i)=0$ ，其他项梯度 $p_ip_j=0$，最后累加起来就是 0 了。

解决办法：缩放点积注意力

把 $QK^T$ 除以 $\sqrt{d_k}$，能把它的方差重新拉回到一个合理的范围（大约接近 1）。

8.2.3 残差连接

梯度回传时候，链式计算可能会乘非常多的偏导。如果之间的偏导都是小于 1 的数，就有可能导致最后梯度接近于 0；反之梯度有可能非常大。梯度爆炸比较好解决，超过一定值的时候就把它裁剪掉。ResNet 的残差连接和 $1*1$ 卷积，可以解决梯度消失这个问题。

残差连接解决的是退化问题:

从数学上看，假设一个浅层网络（比如 10 层）已经能很好地拟合一个函数 H(x)，我们希望再把网络加深 40 层得到更好的性能。假如我们让加深 40 层后的网络性能保持不变，那么这最少 40 词的非线性嵌套做的事就是学会一个恒等映射，这样准确率才不会下降。但是作为一个深层结构参数间高度耦合的网络，它很难学会恒等映射

因为你要让几十层参数全部精确地抵消成“什么都不干”太难了，优化器几乎做不到。所以我们退而求其次，希望能学会这样一个函数:

这样让模型学会把输出变成全 0，比学会把输出精确等于输入 x 容易很多。

8.2.4 层归一化

先明确一点，Lay Normalization 是在最后一个维度进行归一化。换句话说，在 Transformer 中 Lay Norm 是对每个 token 对应的隐藏状态向量 $h_i$ 进行归一化，它是不依赖于 Batch Size 或者 Sequence Size 的。

Attention 机制在归一化阶段希望“先让每个 token 自己内部整洁”，再去交流。

Q：为什么需要对 feature 维度进行归一化 A：feature 数值差太大 → 在线性层中被放大或压缩

假设你有输入特征向量：$x = [1000,\; 0.1]$，经过一个线性层：$y = Wx$。其中

计算：

不管权重 $w_2$ 多努力，最终贡献都会被 $1000 * w_1$ 盖掉。

8.2.5 源码解析

一、Transformer

class Transformer(nn.Module):
    def __init__(self):
        super(Transformer, self).__init__()
        self.encoder = Encoder().cuda()
        self.decoder = Decoder().cuda()
        self.projection = nn.Linear(d_model, tgt_vocab_size, bias=False).cuda()
    def forward(self, enc_inputs, dec_inputs):
        '''
        enc_inputs: [batch_size, src_len]
        dec_inputs: [batch_size, tgt_len]
        '''
        enc_outputs, enc_self_attns = self.encoder(enc_inputs)
        dec_outputs, dec_self_attns, dec_enc_attns = self.decoder(dec_inputs, enc_inputs, enc_outputs)
        dec_logits = self.projection(dec_outputs) # dec_logits: [batch_size, tgt_len, tgt_vocab_size]
        return dec_logits.view(-1, dec_logits.size(-1)), enc_self_attns, dec_self_attns, dec_enc_attns

整体来说 Transformer 包含 Encoder、Decoder 和投影三部分，Encoder 负责学习输入，Deocder 负责生成输出，最后把输出向量投影到期望的空间。

注意！！！

因为 PyTorch 的交叉熵损失要求输入形状如下：

input:    [N, C]
target:   [N]

其中：

• N = 样本数量
• C = 类别数量 = vocab_size

而 Transformer 解码器输出的 logits 是：[B, T, V]，所以需要展平到二维。

二、Encoder

class Encoder(nn.Module):
    """
    - Word Embedding
    - Position Embedding
    - MultiEncoderLayer
    """    
    def __init__(self, vocal_size: int,  d_model: int,  layer_nums: int,  max_len: int,  hidden_size: int, n_heads: int = 8, p: float = 0.1):
        super(Encoder, self).__init__()
        self.word_embedding = nn.Embedding(vocal_size, d_model)
        self.pos_embedding = PositionEmbedding(max_len, d_model, p)
        self.layers = nn.ModuleList([EncoderLayer(d_model, n_heads, hidden_size, p) for _ in range(n_layers)])
        
        
    def forward(self, x):
        attns = []
        enc_masks = padding_mask(x, x)
        enc_embed = self.word_embedding(x)
        enc_embed = self.pos_embedding(enc_embed)
        
        enc_output = enc_embed
        for layer in self.layers:
            enc_output, enc_attn = layer(enc_output, enc_masks)
            attns.append(enc_attn)

        return enc_output, attns

Encoder 包含 Word Embedding、Position Embedding 和多头注意力层，矩阵形状变化如下:

1. 输入为 batch_size 行文本，文本长度固定为 seq_len：[batch_size, seq_len]
2. 通过词嵌入之后得到: [batch_size, seq_len, d_model]
3. Position Embedding 大小和输入相同直接叠加: [batch_size, seq_len, d_model]
4. 多头注意力机制不改变矩阵形状，最后还是 [batch_size, seq_len, d_model]

严格来说 Encoder 和 Decoder 返回注意力权重 attn 没有什么用，不过它可以让我们查看模型在翻译时关注了源句子的哪些词。

1. Word Embedding

词嵌入就是简单的使用了 torch.nn.Embedding 这个自学习矩阵，它的形状是 [src_vocal_size, d_modal]，根据输入文本 token 的索引就能从中取出对应的词向量。

2. Position Embedding

class PositionalEncoding(nn.Module):
    def __init__(self, d_model, dropout=0.1, max_len=5000):
        super(PositionalEncoding, self).__init__()
        self.dropout = nn.Dropout(p=dropout)

        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        pe = pe.unsqueeze(0).transpose(0, 1)
        self.register_buffer('pe', pe)

    def forward(self, x):
        x = x + self.pe[:x.size(0), :]
        return self.dropout(x)

正余弦编码的公式是：

通过数学性质：

所以有：

为什么要把 position 从 [max_len] 扩展到 [max_len, 1]?

从公式来看，我们要做的事就是把每条句子的奇数和偶数位置的值替换掉，通过 pytorch 的切片操作 tensor[:, 0::2] 就可以用一个 [seq_len, d_model/2] 形状的矩阵替换掉偶数位置的值。同时利用 pytorch 的广播机制，把 position 扩展到 [seq_len, 1] 和 div_term [d_model/2] 相乘就能得到 [seq_len, d_model/2] 的新矩阵。

PS: 我感觉这个计算方法真的很诡异，div_term 的维度是 [d_model/2, ]，我们可以看做是一个长为 d_model/2 的行向量。然后和 position 主元素相乘之后，广播到 [seq_len, d_model/2] ，这时候可以看做 d_model/2 的行向量进行了一个转置变长 d_model/2 的列向量，然后水平方向扩展为 [seq_len, d_model/2] 的矩阵。

用一个实际数字例子看广播计算

假设 position（5×1）:

[[0],
 [1],
 [2],
 [3],
 [4]]

div_term（视为 1×3）：

[ a  b  c ]

计算 position * div_term：

[[0*a, 0*b, 0*c],
 [1*a, 1*b, 1*c],
 [2*a, 2*b, 2*c],
 [3*a, 3*b, 3*c],
 [4*a, 4*b, 4*c]]

最后前向计算中也是利用到了广播机制，x 的形状是 [seq_len, batch_size, d_model], pe 的形状是 [seq_len, 1, d_model]， 保持 x 的形状不变。

Pytorch 的广播机制为：如果两个张量维度不一致，则在较短张量前面补 1。如果维度一致，则从右往左对比，如果两个维度一致或者有一个为 1 则可以广播。例如 [1, 2, 3] 和 [3, 2, 1]，从右往左：有一个 1，两个都是 2，有一个 1，最后广播为 [3, 2, 3], 每个维度是两个 shape 各自的最大值。

3. EncoderLayer

class EncoderLayer(nn.Module):
    
    def __init__(
        self,
        d_model: int,
        n_heads: int,
        hidden_size: int,
        dropout: float = 0.1,
        pre_norm: bool = True
    ):
        super(EncoderLayer, self).__init__()
        self.mha = MultiHeadAttention(d_model, n_heads, dropout)
        self.ff = FeedForwardNet(d_model, hidden_size, dropout)
        
        self.attn_norm = nn.LayerNorm(d_model)
        self.ff_norm = nn.LayerNorm(d_model)
        self.dropout = nn.Dropout(p=dropout)
        
        self.pre_norm = pre_norm
    
    def forward(self, x, attn_masks=None):
        
        if self.pre_norm:
            # Pre-LN: norm -> sublayer -> dropout -> residual
            norm_x = self.attn_norm(x)
            context, attn = self.mha(norm_x, norm_x, norm_x, attn_masks)
            x = self.dropout(context) + x
            
            norm_x = self.ff_norm(x)
            ff_out = self.ff(norm_x)
            x = self.dropout(ff_out) + x
            
            return x, attn
        else:
            # Post-LN: sublayer -> dropout -> residual -> norm
            context, attn = self.mha(x, x, x, attn_mask)
            x = self.attn_norm(x + self.dropout(context))

            ff_out = self.ff(x)
            x = self.ff_norm(x + self.dropout(ff_out))
            return x, attn

• pre_norm 模型一般比 post_norm 更稳定，易于训练。这在深层Transformer中尤为明显。
• post_norm 在较浅层时效果尚可，但模型越深，梯度消失或爆炸问题可能更严重。

4. MultiHeadAttention

class MultiHeadAttention(nn.Module):
    
    def __init__(self, d_model: int, n_heads: int, p: float = 0.1):
        super(MultiHeadAttention, self).__init__()
        assert d_model % n_heads == 0, "d_model must be divisible by n_heads"
        self.n_heads = n_heads
        self.d_model = d_model
        self.d_k = d_model // n_heads
        

        self.W_Q = nn.Linear(d_model, n_heads * d_k)
        self.W_K = nn.Linear(d_model, n_heads * d_k)
        self.W_V = nn.Linear(d_model, n_heads * d_k)
        self.fc = nn.Linear(n_heads * d_k, d_model)
        
        # self.norm = nn.LayerNorm() Laynorm 统一放在 EncoderLayer
        self.attn_dropout = nn.Dropout(p)
        self.proj_dropout = nn.Dropout(p)
        
    def forward(self, q, k, v, masks = None):
        batch_size, seq_len, _ = q.size()
        Q = self.W_Q(q).view(batch_size, seq_len, self.n_heads, self.d_k).transpose(1, 2)
        K = self.W_K(k).view(batch_size, seq_len, self.n_heads, self.d_k).transpose(1, 2)
        V = self.W_V(v).view(batch_size, seq_len, self.n_heads, self.d_k).transpose(1, 2)
        
        scores = torch.matmul(Q, K.transpose(-1, -2)) / np.sqrt(self.d_k)
        
        if mask:
            scores = scores.masked_fill(mask, float('-inf'))
        
        
        attn = nn.Softmax(scores, dim=-1)
        attn = self.attn_dropout(attn)
        
        
        context = torch.matmul(attn, V).transpose(1, 2)
        context = context.reshape(batch_size, seq_len, self.n_heads * self.d_k)
        context = self.fc(context)
        context = self.proj_dropout(context)
        
        # return self.norm(context + q, -1), attn
        return context, attn

前馈计算中的形状变化

1. 输入的 q,k,v 形状都是三维矩阵 [batch_size, seq_len, d_model]
2. 经过自学习矩阵 W_Q,W_K,W_V 变化之后得到 Q,K,V [batch_size, seq_len, n_heads*d_k]

其实形状没变，因为 Transformer 论文中规定 $d_{model}=n\_heads \times d_k$

3. 将 n_heads 从矩阵第三维拉出来 [batch_size, seq_len, n_heads, d_k]
4. 我们拉出 n_heads 是为了利用矩阵的形状同时计算多个注意力头，所以把 “头” 的维度拉到前面 [batch_size, n_heads, seq_len, d_k]
5. 根据公式 $softmax({\frac{QK^T}{\sqrt{d_k}}})V$ 计算得到 [batch_size, n_heads, seq_len, d_k]
6. 最后将形状变回去 [batch_size, seq_len, n_heads, d_k] -> [batch_size, seq_len, n_heads * d_k] -> [batch_size, seq_len, d_model]

对形状变化还是不理解的可以考虑一下朴素版本通过 for 循环实现多头注意力，每个注意力头得到 [batch_size, seq_len, d_k] 然后 n_heads 个头的结果拼接在一起得到 [batch_size, seq_len, n_heads * d_k]

view 和 shape 都是对矩阵形状做变化，有什么区别？

• view 只能对连续存储的张量进行形状变化，例如 self.W_Q(input_Q) 得到的张量通常是连续的。
• reshape 可以对任意张量进行形状变化，但是性能不如 view。Q,K,V 通过 transpose 转置后不能保证在内存中连续，所以用 reshape 安全。

为啥注意力机制计算结束还要加一个全连接？

多头注意力机制最早出现在 Transformer 模型中（论文《Attention is All You Need》），它的定义明确包含了最后的线性变换层：

MultiHead(Q, K, V) = Concat(head_1, head_2, ..., head_h) * W_O

它的好处是前面的拼接只是机械地将每个头的输出放在一起，维度虽然匹配，信息却没有经过进一步的处理，并且拼接是无参数的，而 Linear 层引入了可学习的权重 W_o，让模型能够根据任务动态调整每个头的贡献。

为什么要把张量拆成四维并调整维度顺序呢？

在单头自注意力中，输入形状为 $[B, L, H]$。
我们可以直接计算注意力得分：

对于多头注意力，我们首先将输入从 $[B, L, H]$ 映射为 $[B, L, n\_\text{heads} \times d_k]$。这表示第三个维度已经包含了所有头的投影结果。

接着，我们把这一维拆分成两维：

再通过 permute 调整维度顺序：

此时可以将其理解为：每个 batch 里有 $n\_\text{heads}$ 个独立的注意力头，每个头对应一个 $[L, d_k]$ 的投影空间，相当于单头时的$[L, H]$ 但维度较小（$d_k$​）。

四维矩阵如何进行乘法的？

在本科的线性代数课上，我们学过了二维矩阵的乘法 $[a, b] \times [b, c] = [a, c]$，那四维矩阵呢？

对于超过二维的张量，torch.matmul 会把张量的前几个维度（称为“批次维度”）看作独立的批次，对每个批次单独执行二维矩阵乘法。最后两维被视为矩阵的行和列，进行标准的矩阵乘法。

• 假设两个张量 A 和 B：
  • A 的形状：[batch_dim1, batch_dim2, m, n]。
  • B 的形状：[batch_dim1, batch_dim2, n, p]。
• 前面的批次维度 [batch_dim1, batch_dim2] 必须匹配。
• 最后两维 [m, n] 和 [n, p]按二维矩阵乘法规则计算。
• 结果形状：[batch_dim1, batch_dim2, m, p]。

5. FeedforwardNet

class FeedForwardNet(nn.Module):
    
    def __init__(self, d_model: int, hidden_size: int, p: float = 0.1):
        super(FeedForwardNet, self).__init__()
        self.fc1 = nn.Linear(d_model, hidden_size)
        self.fc2 = nn.Linear(hidden_size, d_model)
        self.relu = nn.ReLU()
        # self.norm = nn.LayerNorm()
        self.dropout = nn.Dropout(p)
        
    def forward(self, x):
        output = self.fc1(x)
        output = self.relu(output)
        output = self.fc2(output)
        output = self.dropout(output)
        # return self.norm(x + output, -1)
        return output

三、Decoder

Transformer Decoder 和 Encoder 稍有不同，它也包含 Word Embedding 和 Position Embedding，不过 DecoderLayer 每一层中是 MaskedMultiHeadAttention 和 CrossMultiHeadAttention。

class Decoder(nn.Module):
    
    def __init__(
        self,
        vocal_size: int,
        d_model: int,
        max_len: int,
        layer_nums: int,
        hidden_size: int,
        p: float = 0.1
    ):
        super(Decoder, self).__init__()
        self.word_embedding = nn.Embedding(vocal_size, d_model)
        self.position_embedding = PositionEmbedding(max_len, d_model, p)
        self.layers = nn.ModuleList([DecoderLayer(d_model, n_heads, hidden_size, p) for _ in range(layer_nums)])
        self.attn_norm = nn.LayerNorm(d_model)
        
    def forward(self, x, enc_x, enc_context):
        self_attns, cross_attns = [], []
        batch_size, seq_len = x.size()
        dec_embed = self.word_embedding(x)
        dec_embed = self.position_embedding(dec_embed)
        
        dec_padding_mask = padding_mask(x, x)  # [batch_size, seq_len, seq_len]
        cross_mask = padding_mask(enc_x, x)
        
        # 对 dec_masks 应用 Future Mask
        future_mask = torch.triu(torch.ones(seq_len, seq_len, dtype=torch.bool), diagonal=1)
        future_mask = future_mask.unsqueeze(0).expand(batch_size, seq_len, seq_len)
        self_mask = dec_padding_mask.bool() | future_mask
        
        
        dec_output = dec_embed
        for layer in self.layers:
            context, dec_self_attn, dec_cross_attn = layer(dec_output, enc_context, self_mask, cross_mask)
            self_attns.append(dec_self_attn)
            cross_attns.append(dec_cross_attn)
        
        return context, self_attns, cross_attns

1. Mask

Mask 掩码分为两种，一种是使 Sequence 固定长度用于掩盖空位的掩码，另一种是在 Transformer Decoder 中用于掩盖未来 token 的掩码。

Padding Mask

在 Transformer Encoder 的多头注意力机制中，我们用每个 token 的 Query 去查询其他 token 的 Key，得到了每个 token 在 源输入中的注意力权重 [seq_len, seq_len]，其中第一个维度代表有多少 token，第二个维度代表每个 token 对其他 token 的注意力权重，所以我们应该应用 Mask 在第二个维度。在 Decoder 的交叉多头注意力机制中，我们用 Decoder 的每一个 token 去查询 Encoder 的 token，也就是说这时候产生的注意力权重形状是 [enc_len, dec_len]。

def padding_mask(enc_seq: torch.Tensor, dec_seq: torch.Tensor, pad_idx: int = 0):
    batch_size, enc_len = enc_seq.size()
    batch_size, dec_len = dec_seq.size()
    
    mask = dec_seq.detach().eq(pad_idx).unsqueeze(1)  # [batch_size, 1, dec_len]
    return mask.expand(batch_size, enc_len, dec_len)

Future Mask

Future Mask 的原理前文介绍过了，主要就是为了使 Decoder 不能窥视后续文本。我们仍然是在注意力权重矩阵中应用 Mask，它的形状是 [batch_size, seq_len, seq_len]，对这个矩阵的上三角部分掩盖即可。

    future_masks = torch.triu(torch.ones(seq_len, seq_len, dtype=torch.bool), diagonal=1)
    future_masks = future_masks.unsqueeze(0).expand(batch_size, seq_len, seq_len)
    dec_masks = dec_masks | future_masks

我们生成一个上三角全是 True, 主对角和下三角为 False 的矩阵，然后和 Padding Mask 相与。

2. DecoderLayer

class DecoderLayer(nn.Module):
    
    def __init__(
        self,
        d_model: int,
        n_heads: int,
        hidden_size: int,
        dropout: float = 0.1,
    ):
        super(DecoderLayer, self).__init__()
        self.self_mha = MultiHeadAttention(d_model, n_heads, dropout)
        self.cross_mha = MultiHeadAttention(d_model, n_heads, dropout)
        self.ff = FeedForwardNet(d_model, hidden_size, dropout)
        
        self.cross_norm = nn.LayerNorm(d_model)
        self.self_norm = nn.LayerNorm(d_model)
        self.ff_norm = nn.LayerNorm(d_model)
    
        self.dropout = nn.Dropout(p=dropout)
    
    def forward(self, x, enc_output, self_mask, cross_mask):
        norm_x = self.self_norm(x)
        self_context, dec_self_attn = self.self_mha(norm_x, norm_x, norm_x, self_mask)
        x = self.dropout(self_context) + x
        
        norm_x = self.cross_norm(x)
        cross_context, dec_cross_attn = self.cross_mha(norm_x, enc_output, enc_output, cross_mask)
        x = self.dropout(cross_context) + x       
        
        norm_x = self.ff_norm(x)
        ff_output = self.ff(norm_x)
        
        return self.dropout(ff_output) + x, dec_self_attn, dec_cross_attn

DecoderLayer 依次应用掩码多头注意力，交叉多头注意力和前馈神经网络，为了让 CrossMultiHeadAttention 可以服用多头注意力的代码，我们只需要把输入 x 区分为 input_q, input_k, input_v。用掩码多头注意力得到的 Query 去查询 Encoder 输出的 Key就行了。

9. Lecture 9

9.1 Subword Modeling

在过去的实践中，我们处理文本会先进行分词，然后把一个个 token 转换为其对应的 idx 索引，在用它去进行词嵌入。但这样的做法有一个问题，在测试集中我们遇到没见过的词语就把他用 <UNK> 来替换，这样会丢失大量的信息。

现代 NLP 模型不会直接把完整单词当作基本单位，而是把单词拆成若干 subwords（子词）来表示。

• 出现非常频繁的词（如 hat、learn）会被当作 完整的词 放进词表，少见词、奇怪词、新造词会被拆成多个子词。
• 如果是特别奇怪的词、根本没见过、字母组合很怪，模型可能把每个字符都拆开。

• 常用词：例如 hat, learn 等词语，Embedding 会完整学习不拆分。
• 变体：例如 taaaaast，会把词语拆为常见的 Subword 和常用词的组合 taa##aaa##sty。
• 拼写错误：laern，模型没见过于是拆分为 la##ern，模型没见过这个错词，所以分成多个子词。
• 新词 / 自创词：Transformerify 拆为 Transformer## ify。

这些拆分后的 Subword 会得到多个 Embedding，我们可以取最后一个 Embedding，对 Embedding 进行平均，或者用 RNN 等模型对其进行学习。

9.2 Pretraining

9.2.1 三种预训练架构

Pretraining 干的事情就是给模型安排一个非常困难的任务，迫使它在数据中尽可能的学习。

• Encoder Only：几乎只能用 MLM / 替换 token 检测等，因为它没有生成能力。
• Decoder Only：几乎只能用 next-token prediction（因为它看不到未来），或者说 TeachForcing。
• Encoder-Decoder：传统的带对齐的翻译（supervised），Next-token prediction（纯自回归），Span corruption（T5 式）

Bert 就是 Encoder Only Pretaining 的典型代表，它的训练方式包括：

• 随机遮掉 15% 的 Subword
• 随机替换 15% 的 Subword
• 随机选择 15% 的 Subword 不替换，但还是让它预测
• 判断两个句子是否相邻

对于不同的任务会选择不同的预训练方法：例如 Bert 更适合为文档选择一个 Tag，它不适合进行文本生成的任务。

一个 Misunderstanding

经典的 Transformer（Vaswani et al., 2017 那篇 “Attention is All You Need”）本身不是一种，而是一个“积木盒子”。 它同时提供了三种可拼装的部件：

1. Transformer Encoder 块（双向注意力，允许看未来）
2. Transformer Decoder 块（带 masked self-attention，只能看过去）
3. Cross-attention（Decoder 看 Encoder 的输出）

根据你怎么拼这三个积木，就自然得到了刚才 PPT 里的三种预训练架构：

9.3 Prefix-Tunning

Prefix Tuning 是一种参数高效微调 (PEFT) 技术。它保持预训练语言模型（如 GPT, BERT）的参数完全冻结，只在Transformer的每一层输入前添加一小段可训练的连续向量（即 Prefix）。

以 Decoder Only 的模型进行参数微调为例，我们会初始化一部分可训练参数 prefix_k 和 prefix_v。假如 Decoder 每一层的 Q, K, V 形状为 [batch_size, seq_len, d_model]，那么 prefix_k 和 prefix_v 的形状就是 [batch_size, prefix_len, d_model]。我们将 prefix_k 和 K 矩阵在第 2 个维度进行拼接，得到新的 K 和 V，形状为 [batch_size, prefix_len+seq_len, d_model]。