# transformer

天才在左 (BERT)，疯子在右 (GPT)

transformer 最初由 Google 于 2017 年提出，并且发了一篇经典论文 (attention is all you need)，最开始用于机器翻译任务，后续发现在图像，视频，音频上都十分有效。是继 CNN，RNN 后另一 nb 模型。

对于 RNN 来说，计算隐藏状态 $$h_t$$ 必须依赖于上一个状态 $$h_{t-1}$$, 使得并行度较差。可能会丢弃很早期的 ht 信息。

https://arxiv.org/html/1706.03762v7

https://github.com/tensorflow/tensor2tensor

Transformer 是一种避免重复出现的模型架构，而是完全依赖注意力机制来绘制输入和输出之间的全局依赖关系。Transformer 允许显著提高并行化水平，并且在 8 个 P100 GPU 上经过短短 12 小时的训练后，就可以达到翻译质量的新水平。

Transformer 是第一个完全依赖自我注意来计算其输入和输出的表示，而不使用序列对齐 RNN 或卷积的转导模型。

先科普一些前置知识～

# 矩阵运算

**1、** 转置

2、运算

$$\mathbf{x}_1 = \mathbf{E}_1 + \mathbf{P}_1 = \begin{bmatrix}1 \\ 0 \\ 0 \\ 0\end{bmatrix} + \begin{bmatrix}0.0 \\ 0.1 \\ 0.2 \\ 0.3\end{bmatrix} = \begin{bmatrix}1.0 \\ 0.1 \\ 0.2 \\ 0.3\end{bmatrix}$$

$$x_1 = \begin{bmatrix} 0.5 & 0.2 & 0.0 & 1.0 \\ 1.0 & 0.0 & 0.2 & 0.1 \end{bmatrix} \begin{bmatrix} 1.0 \\ 0.1 \\ 0.2 \\ 0.3 \end{bmatrix} = \begin{bmatrix}0.5\cdot1.0 + 0.2\cdot0.1 + 0.0\cdot0.2 + 1.0\cdot0.3 \\1.0\cdot1.0 + 0.0\cdot0.1 + 0.2\cdot0.2 + 0.1\cdot0.3 \end{bmatrix} = \begin{bmatrix}0.82 \\ 1.07\end{bmatrix}$$

矩阵乘法 $$(m\times n)\cdot (n\times k) => (m\times k)$$ ，上图例子 2 行 4 列矩阵 点乘 4 行 1 列矩阵，结果是 2 行 1 列的矩阵。如果第一个矩阵的列数不等于第二个矩阵的行数，那么无法执行点乘操作。

# softmax

假设输入向量为 $$(\mathbf {z} = [z_1, z_2, \cdots, z_k])$$，其中 k 是向量的维度

$$\sigma(z_i) = \frac{e^{z_i}}{\sum_{j=1}^{k} e^{z_j}} \quad \text{for } i = 1, 2, \cdots, k$$

• 输出范围：输出的每个元素都在 $$(0, 1)$$ 区间内，因为指数函数 $$e^z_i}$$ 总是大于 0 的，并且分母 $$\sum_{j=1}【{k】 e^{z_j}$$ 是所有指数项的和，也大于 0。
• 总和为 1：$$\sum_i=1}【{k】 \sigma (z_i) = 1$$，这使得 Softmax 函数的输出可以被解释为概率分布。
• 单调递增：对于输入向量中的每个元素 $$z_i$$，$$\sigma (z_i)$$ 是关于 $$z_i$$ 的单调递增函数。也就是说，$$z_I$$ 越大，$$\sigma (z_i)$$ 的值就越大。

在神经网络的最后一层，通常会使用 Softmax 函数将网络的输出转换为概率分布，每个类别的概率表示样本属于该类别的可能性。然后可以选择概率最大的类别作为预测结果。

假设 $$z=[0.5,0.8,0.6]$$，$$\sigma (z_1)=\frace【{0.5】}e【{0.5】+e^0.8}+e【{0.6】} = P(y = 1|\vec{z}) $$

# Seq2Seq

序列到 **** 序列模型（Sequence-to-Sequence，Seq2Seq）的输入是一个序列，输出也是一个序列，这种模型在语音和语言领域的任务中非常常见，例如：

• 机器翻译：输入 “Deep learning”，输出 “深度学习”。
• 语音识别：输入 “一段音频声波信号”，输出一段文字，如 “深度学习”。
• 问答与对话：输入 “中国的首都是哪个城市？”，输出 “北京”。

Seq2Seq 模型的输入包括两部分数据：需要分类的评论语句 “这个行李箱不够结实，用几次轮子就坏了” 和人工加入的提示问题 “这个评论是正向还是负向？” 模型的输出是分类的标签 “负向”。由此可见，一个典型的文本分类问题，可以通过加提示词的方式编程一对问答，转化成了序列到序列的任务。

# 网络结构

Transformer 是一个基于多头自注意力的序列到序列的模型，包括编码器和解码器两部分，左边是编码器，右边是解码器，都是层次堆叠式的结构，图中的 Nx 代表有 N 个 encode layer 和 N 个 decode layer

对于 encode layer 和 decode layer 中的其他部分，我们可以先忽略不看，抽象出如下的结构。此时主要的结构就只剩四个部分，分别是：inputs，Nx encode layer，Nx decode layer，和 outputs。后面会逐一拆解这四个部分。

# 网络结构 - inputs

对于输入到 encode layer 中的 inputs，会经历两个步骤，即先进行 embedding，进行分词后获取特征向量，在根据位置编码，将 embedding 后的向量和位置编码叠加，得到最终的 encode layer 输入。一般称为这层为嵌入层。

举例，假设目前有一句话：“我爱机器学习”。分词之后，变为了 我 ， 爱 ， 机器 ， 学习 。这里的分词可以简单理解为 tokenizer，将文本分割成一个个独立单元，即 token。可以参考豆包的分词器 (https://console.volcengine.com/ark/region:ark+cn-beijing/tokenCalculator)。但是不同的模型有不同的分词器，会导致分词结果不一致。分词后，经过 embedding，这四个词分别对应了 $$x_1,x_2,x_3,x_4$$ 这四个特征向量

豆包 - 1.5 分词器

Deepseek-R1 分词器

# 网络结构 - outputs

transformer 的输出，是预测下一个词的概率。概率通过前文提到的 softmax 得出

举例，比如目前已经有的输出是 我爱 ，那么下一个词的概率预测可能如下。此时概率最高的为机器，选择概率最高的 Token 作为预测的下一个单词。当然这只是举例，实际会涉及到词表等其他内容。

# 网络结构 - encode-decode layer

Seq2Seq 模型往往采用编码器 - 解码器（Encoder-Decoder）的结构设计，主要应用于异步的序列到序列的深度学习任务。其中编码器负责理解和抽象输入序列的信息，然后传递给解码器生成输出序列。解码器生成输出序列时需要两部分信息输入：一是编码器传递过来的抽象了全局输入的信息；二是解码器在上一个阶段的输出信息。

基于编码器 - 解码器结构实现的机器翻译任务示意，模型的输入是 “Deep learning”，编码器会先将这个输入计算成向量表示，解码器则会逐字逐句的生成输出：深度学习。在这个过程中，当解码器生成 “度” 时，它的输入既包含编码器传递过来的向量表示，又包含解码器上一阶段生成的输出 “深”，依此类推。其中<BOS > 是一个特殊的向量，表示编码器启动工作。

Seq2Seq 模型使用完整的编码器 - 解码器结构完成模型构建，但编码器 - 解码器也经常单独使用。编码器常被用于语义提取任务，可以得到比 Word2Vec 模型更丰富的语义信息。

# 网络结构 - encode layer

Transformer 编码器由 N 个编码层堆叠而成，嵌入层输出的字符级别的特征表示首先被传入第一层的 Encoder Layer，经过自注意计算后，得到向量序列 [o1,o2,o3,o4]。这个输出会被作为输入，传递到上一层的 Encoder Layer，每层的 Encoder Layer 的计算逻辑是相同的，依此类推，最后一层的输出被视为 Transformer Encoder 输出的特征编码向量。

每个编码层包含四个模块：多头注意力层（Multi-Head Attention）、加与规范层（Add&Norm）、前馈层（Feed Forward）和加与规范层（Add&Norm）。其中多头注意力层的核心计算逻辑是自注意力机制

# 网络结构 - decode layer

与编码器基本一致，但是多头注意力会变为带掩码的多头注意力。带掩码的多头注意力只根据当前位置和之前的输入片段来计算影响力，会盖住后面的词。在生成模型的场景，我们还不知道后面会生成哪些内容，只知道之前生成了哪些内容。

其余内容和 encode layer 中基本一致，只是输出的时候加了线性变换和 softmax 输出了下一个词的概率。

到这里你已经是精通 transformer 的大佬啦，快休息一下吧 (

接下里，我们会深入拆解多头注意力这个模块，来解释为什么 attention is all you need

# 什么是多头注意力

# Q,K,V

自注意力模型（Self-Attention Model）的设计思想来源于解决循环神经网络在解决长序列数据时遇到的问题：

1）如何计算更全局的信息依赖，而不局限于距离的远近？

2）如何使得计算可以并行化，而不是只能串行进行？

为了解决如上两个问题，自注意力模型采用查询 - 键 - 值（Query-Key-Value，QKV）的模式。对于输入序列 $$\mathbf X=[\mathbfx}_1,…,\mathbf{x}_L]\in \mathbb{R}【{L\times D_{】}$$，每一个输入 $$x_i$$ 都有三个向量表示：查询向量 $$\mathbfq}_i\in \mathbb{R}【{D_{k】}$$、键向量 $$\mathbfk}_i\in \mathbb{R}【{D_{k】}$$ 和值向量 $$\mathbfv}_i\in \mathbb{R}【{D_{v】}$$。

# 计算 k，q，v

同样是上面的例子，我爱机器学习，分词后，四个 token 都变为向量，即 embedding 操作，假设这里维度为 4，那么可以得到 4 个 4*1 的矩阵。实际在 BERT 中，维度一般为 768。接着定义三个可学习的权重矩阵

• W_Q \in \mathbb{R}^{d_{model} \times d_k}$$：用于将输入转换为Q矩阵。这里$$d_{model} $$是指维度，此处为4。
• W_V \in \mathbb{R}^{d_{model} \times d_v}$$：用于将输入转换为V矩阵。

通过矩阵乘法将输入 $$\mathbf {X}$$ 分别与 $$W_Q$$、$$W_K$$ 、$$W_V$$ 相乘，得到 Q、K、V 矩阵：

• 计算 Q 矩阵：$$\mathbfQ} = \mathbf{X}W_Q \in \mathbb{R}【{n \times d_k】$$，$$n \times dk$$, 其中 n 代表矩阵的行数，$$d_k$$ 代表矩阵的列数 (即输入向量的维度)
• 计算 K 矩阵：$$\mathbfK} = \mathbf{X}W_K \in \mathbb{R}【{n \times d_k】$$
• 计算 V 矩阵：$$\mathbfV} = \mathbf{X}W_V \in \mathbb{R}【{n \times d_v】$$

这里的矩阵乘法是逐行进行的，即对于输入序列中的每个词向量，都与相应的权重矩阵相乘，得到对应的 Q、K、V 向量。

此时 我 对应 $$Q_1,K_1,V_1$$，同理 学习 对应 $$Q_4,K_4,V_4$$

# attention

其中 $$q_i$$ 和 $$k_i$$ 用来计算序列中其它输入对本输入的影响力，$$v_i$$ 是本输入的向量表示，输入 xj 对输入 xi 的影响力使用 $$q_j \cdot {k_i}$$ 表示。影响力越大，说明处理输入 xi 的时候需要重点考虑输入 xj 的信息。这样模型在处理当前输入时，它的注意力可以在整个输入序列上不受约束的扫描，从而得到对处理当前内容最有帮助的信息。

模型在处理输入 xi 时，先计算其它输入对 xi 的影响 $$(q_j \cdot k_i})$$，用 $$\alpha_{ij}$$ 表示；然后将 $$\alpha_{ij}$$ 经过 Softmax 后得到的值 $$\hat {\alpha}_{ij}$$ 与值向量 vi 相乘，就得到 xi 经过整个序列信息影响后的向量表示 zi，即 $$\mathbf {z}_i = \sum_{j = 1}【{L】 \hat{\alpha}_{ij} \mathbf{v}_j$$

那么为什么要缩放，为什么要乘以 k 的转置 (这两条看不懂可以直接跳过)

1、因为矩阵运算规则，第一个矩阵列数不等于第二个矩阵的行数的时候，不能计算点积

假设 Q 的维度是 $$(m, d_k)$$，K 的维度是 $$ (n, d_k)$$，$$K^T$$ 的维度就变为 $$(d_k, n)$$ ，那么 $$ (QK^T)$$ 得到的结果矩阵维度是 $$(m, n) $$。通过 $$(QK^T) $$ 计算，能衡量不同词之间的关联程度

2、除以 $$ \sqrt {d_k}$$ 主要是为了解决点积运算在高维空间中可能出现的数值不稳定问题

• 点积结果随维度增大而增大：在高维空间中，当 (Q) 和 (K) 的维度 (d_k) 较大时，(Q) 和 (K) 做点积 (QK^T) 后，结果的数值范围会随着维度的增大而增大。假设 (Q) 和 (K) 中的元素是独立同分布的随机变量，且均值为 0、方差为 1。根据方差的性质，两个向量点积的方差会随着向量维度 (d_k) 的增加而线性增大。也就是说，维度越高，点积的结果可能会变得非常大。
• Softmax 函数饱和：在计算注意力分数时，需要对 (QK^T) 的结果应用 Softmax 函数来得到注意力权重。Softmax 函数的表达式为 (\textsoftmax}(x_i) = \frac{e【{x_i】}\sum_{j=1}【{n】 e^x_j}}\)，当 \(x_i\) 的值非常大时，\(e【{x_i】) 会变得极其大，可能会导致数值溢出。即使没有溢出，Softmax 函数也会趋近于饱和状态，使得大部分权重集中在少数几个值上，其他值的权重几乎为 0。这样会使得注意力分布变得非常尖锐，模型难以学习到有效的信息。
• 梯度消失：在反向传播过程中，Softmax 函数的饱和会导致梯度变得非常小，使得模型的参数更新非常缓慢，甚至可能出现梯度消失的问题，从而影响模型的训练效果和收敛速度。

最后来看这张图，下半部分就能理解啦

# 位置编码

刚刚讲解 attention 的时候，一直没有提位置编码，只是说了位置编码和输入编码叠加后作为输入。

Transformer 编码器使用自注意力机制处理数据，虽然能够大幅度加强模型的并行计算能力，但是其忽略了文本序列中 token 之间的位置关系，从而导致建模的过程中出现偏差。因此需要使用位置编码（Position Embedding）进行校正，标记输入的文本序列中每个 token 的位置，这个信息对于理解语言是很关键的。例如在机器翻译中，“我喜欢你” 和 “你喜欢我” 词相同但顺序不同，语义迥异，位置编码能让模型感知这种顺序差异，正确翻译。

Transformer 使用三角函数（正弦或者余弦）来编码位置信息。假设位置编码的维度为 D，则每一维的值的计算公式为

其中 t 是指当前词在句子中的位置，$$0⩽i⩽\frac {D}{2}$$ 为编码向量的维数。在偶数维，使用正弦编码；在奇数维，使用余弦编码

其中 pos 表示位置索引（从 0 开始 ）， i 表示维度索引（从 0 开始 ） 。

只要输入序列长度不变，维度不变，那么生成的位置编码矩阵就是相同的。本质就是在输入向量的基础上加了一个行数列数相同的矩阵。

用 python 可以表示为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

import numpy as np

# 序列长度
n = 4
# 嵌入维度
d_model = 8

# 初始化位置编码矩阵
positional_encoding = np.zeros((n, d_model))

# 计算位置编码
for pos in range(n):
    for i in range(0, d_model, 2):
        # 偶数维度
        positional_encoding[pos, i] = np.sin(pos / (10000 ** (i / d_model)))
        # 奇数维度
        positional_encoding[pos, i + 1] = np.cos(pos / (10000 ** (i / d_model)))

# 打印位置编码矩阵
print(positional_encoding)

举个例子，仍然是我 爱 机器 学习，输入序列长度为 4，每个序列维度为 8，此时是 4 个 $$8 \times 1$$ 的矩阵

具体计算过程

• 计算 (pos = 0) 时的编码值：
  • 对于偶数维度 2i (i = 0 时， 2i = 0)：

$$PE(0, 0) = \sin\left(\frac{0}{10000^{2\times0/8}}\right) = \sin(0) = 0$$

• 对于奇数维度 2i + 1 (i = 0 时， 2i + 1 = 1)：

$$PE(0, 1) = \cos\left(\frac{0}{10000^{2\times0/8}}\right) = \cos(0) = 1$$

• 继续计算其他维度：

当 i = 1， 2i = 2 时，

$$PE(0, 2) = \sin\left(\frac{0}{10000^{2\times1/8}}\right) = \sin(0) = 0$$

当 i = 1 ， 2i + 1 = 3 时，

$$PE(0, 3) = \cos\left(\frac{0}{10000^{2\times1/8}}\right) = \cos(0) = 1$$

当 i = 2， 2i = 4 时，

$$PE(0, 4) = \sin\left(\frac{0}{10000^{2\times2/8}}\right) = \sin(0) = 0$$

当 i = 2 ， 2i + 1 = 5 时，

$$PE(0, 5) = \cos\left(\frac{0}{10000^{2\times2/8}}\right) = \cos(0) = 1$$

当 i = 3， 2i = 6 时，

$$PE(0, 4) = \sin\left(\frac{0}{10000^{2\times3/8}}\right) = \sin(0) = 0$$

当 i = 3， 2i + 1 = 7 时，

$$PE(0, 5) = \cos\left(\frac{0}{10000^{2\times3/8}}\right) = \cos(0) = 1$$

得到第一行 $$[\text {0 1 0 1 0 1 0 1}]$$

• 计算 pos = 1 时的编码值：
  • 对于偶数维度 2i （ i = 0 时， 2i = 0 ）：

$$PE(1, 0) = \sin\left(\frac{1}{10000^{2\times0/8}}\right) = \sin(1) \approx 0.84147$$

• 对于奇数维度 2i + 1 （ i = 0 时， 2i + 1 = 1 ）：

$$PE(1, 1) = \cos\left(\frac{1}{10000^{2\times0/8}}\right) = \cos(1) \approx 0.54030$$

• 当 i = 1 ， 2i = 2 时，

$$PE(1, 2) = \sin\left(\frac{1}{10000^{2\times1/8}}\right) \approx0.0998334$$

• 当 i = 1， 2i + 1 = 3 时，

$$PE(1, 3) = \cos\left(\frac{1}{10000^{2\times1/8}}\right) =0.99500$$

按照此方式，可计算出每个位置 (pos = 0, 1, 2, 3）在各个维度上的位置编码值，最终组成一个 $$4 \times 8$$ 的位置编码矩阵。 实际应用中，可借助 Python 等编程语言和相关科学计算库（如 NumPy ）实现上述计算过程，快速得到位置编码矩阵。

$$\begin{bmatrix} 0 & 1 & 0 & 1 & 0 & 1 & 0 & 1 \\ 0.84147 & 0.54030 & 0.09983 & 0.99500 & 0.01000 & 0.99995 & 0.00100 & 1.00000 \\ 0.90930 & -0.41615 & 0.19867 & 0.98007 & 0.02000 & 0.99980 & 0.00200 & 1.00000 \\ 0.14112 & -0.98999 & 0.29552 & 0.95534 & 0.03000 & 0.99955 & 0.00300 & 1.00000 \end{bmatrix}$$

不仅能体现绝对位置，还能有效捕捉元素间相对位置关系 。以正弦位置编码为例，通过特定频率的正弦和余弦函数计算编码值，不同位置的编码值存在数学关联，能反映相对距离等关系 。比如在文本摘要任务中，模型可依据位置编码判断句子中不同成分相对位置，识别关键信息与辅助信息相对位置，提炼摘要 。

# multi-head attention

通过 attention 章节，我们计算出了单个注意力机制。但实际 transformer 中使用了多组自注意力计算的组合，每组注意力计算被称为一个 "头"，不同组注意力的计算是相互独立的。

在多头注意力中，为每个头都定义一组独立的查询、键和值权重矩阵。例如，对于有 h 个头的多头注意力，会有 h 组权重矩阵 $$ (W_q^i)、(W_ki)、(W_v^i)$$，其中 $$(i = 1, 2, \cdots, h)$$。

将输入分别与每个头的查询、键和值权重矩阵相乘，得到每个头的查询、键和值向量。

对于每个头，按照单头注意力的计算方式，计算注意力得分，并通过 softmax 函数进行归一化，得到注意力权重。

注意力权重与对应头的值向量相乘，并进行加权求和，得到每个头的输出。

$$\mathbf{Z} = \text{MultiHeadAttention}(\mathbf{X}) \triangleq (\text{head}_1 \oplus \text{head}_2 \oplus \ldots \oplus \text{head}_H)\mathbf{W}$$

由于我们前面除了 h，为了保持输入的维度依然是原始的 $$ d_\text{model}}$$ 维【{(H\times】度【d_k)\ti】，或者是【mes】另一个特定的维度【d_{\text】。通过乘以矩阵【{model】$$ \mathbf{W}\in\mathbb{R}}}$$，可以将拼接后的 $$ H\times d_k$$ 维度的向量映射回 $$ d_{\text {model}}$$ 维度

假设输入序列长度为 3，嵌入维度 $$(d_{model} = 8)$$，每个头对应的维度 $$(d_k = d_v = 4)$$（因为有 2 个头，$$(8 \div 2 = 4)$$

定义权重矩阵

• 头 1 的权重矩阵：

  • $$W_Q^1 \in \mathbb{R}^{8\times4}$$

  • $$W_K^1 \in \mathbb{R}^{8\times4}$$

  • $$W_V^1 \in \mathbb{R}^{8\times4}$$

• 头 2 的权重矩阵：

  • $$W_Q^2 \in \mathbb{R}^{8\times4}$$

  • $$W_K^2 \in \mathbb{R}^{8\times4}$$

  • $$W_V^2 \in \mathbb{R}^{8\times4}$$

输出权重矩阵 $$W_O \in \mathbbR}【{8\times8】$$

计算每个头的 Q、K、V 矩阵

• 头 1：

  • \mathbf{Q}_1=\mathbf{X}W_Q^1 \\ \mathbf{K}_1=\mathbf{X}W_K^1 \\ \mathbf{V}_1=\mathbf{X}W_V^1 \\$$，结果是一个$$ 3\times4$$ 的矩阵。
  • \mathbf{Q}_2=\mathbf{X}W_Q^2 \\ \mathbf{K}_2=\mathbf{X}W_K^2 \\ \mathbf{V}_2=\mathbf{X}W_V^2 \\$$，结果是一个$$ 3\times4$$ 的矩阵。

• 计算注意力分数：$$\textAttention}(Q_1, K_1, V_1)=\frac{\mathbf{Q}_1\mathbf{K}_1【T】\sqrt{d_k}}=\frac{\mathbf{Q}_1\mathbf{K}_1【T】{\sqrt {4}}$$，这里得到的是一个 3*3 的矩阵。

• 对注意力分数应用 softmax 函数得到注意力权重：$$\mathbf {A}_1 = \text {softmax}(\text {Score}_1)$$。

• 计算头 1 的输出：$$\mathbf {Z}_1=\mathbf {A}_1\mathbf {V}_1$$，这是一个 3*4 的矩阵。

同理计算头 2 的输出 $$\mathbf {Z}_2=\mathbf {A}_2\mathbf {V}_2$$

将头 1 和头 2 的输出按列拼接起来，得到一个 $$3\times8 $$ 的矩阵 $$ \mathbf {Z}$$：

$$\mathbf{Z} = \begin{bmatrix} \mathbf{Z}_{11} & \mathbf{Z}_{12} & \mathbf{Z}_{13} & \mathbf{Z}_{14} & \mathbf{Z}_{21} & \mathbf{Z}_{22} & \mathbf{Z}_{23} & \mathbf{Z}_{24} \\ \mathbf{Z}_{21} & \mathbf{Z}_{22} & \mathbf{Z}_{23} & \mathbf{Z}_{24} & \mathbf{Z}_{31} & \mathbf{Z}_{32} & \mathbf{Z}_{33} & \mathbf{Z}_{34} \\ \mathbf{Z}_{31} & \mathbf{Z}_{32} & \mathbf{Z}_{33} & \mathbf{Z}_{34} & \mathbf{Z}_{41} & \mathbf{Z}_{42} & \mathbf{Z}_{43} & \mathbf{Z}_{44} \end{bmatrix}$$

线性变换得到最终输出

将拼接后的矩阵 Z 与输出权重矩阵 $$w_o $$ 相乘，得到最终的多头注意力输出 $$ \mathbf {O}$$：

x 是 FFN 层的输入，$$W_1,b_1$$ 是第一个线性变换的权重矩阵和偏置向量，$$W_2,b_2$$ 是第二个线性变换的权重矩阵和偏置向量 。

输出：经过上述计算后得到的输出，会传递到后续模块，如在 Transformer 编码器中，会接着进行层归一化（Layer Normalization）；在解码器中，会作为下一个模块的输入继续处理。

# linear

假设模型的隐藏维度 $$ d_{model}=512$$，词汇表大小 $$ V = 10000$$，那么线性层的权重矩阵形状为 $$(d_{model}, V)=(512, 10000)$$。通过矩阵乘法，将解码器层输出的 512 维特征向量映射为 10000 维的向量，每个维度对应词汇表中的一个单词。

虽然线性层本身只进行线性变换，但在后续通常会接一个非线性激活函数（如 softmax 函数），将线性层的输出转换为概率分布。这样可以使得模型能够对不同的输出类别进行概率估计，便于进行分类或生成任务。

举例：

输入是一个长度为 n = 3 的句子，模型的嵌入维度 $$d_{model}=4$$

1、输入数据

假设经过多头注意力层处理后的输出作为前馈神经网络层的输入 $$\mathbf {X}$$，它是一个 $$3\times4$$ 的矩阵：

$$\mathbf{X} = \begin{bmatrix} 1 & 2 & 3 & 4 \\ 5 & 6 & 7 & 8 \\ 9 & 10 & 11 & 12 \end{bmatrix}$$

2. 定义参数

• 第一个线性变换的权重矩阵 $$W_1$$ 是一个 $$4\times16$$ 的矩阵（这里假设将输入维度映射到 $$4d_{model}=16$$，偏置向量 $$b _1$$ 是一个长度为 16 的向量。
• 第二个线性变换的权重矩阵 $$W_2$$ 是一个 $$16\times4$$ 的矩阵（将高维空间映射回输入维度），偏置向量 $$ b_2$$ 是一个长度为 4 的向量。

为了方便计算，我们简单设定这些参数：

$$W_1 = \begin{bmatrix} 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 \end{bmatrix}$$

$$b_1 = \begin{bmatrix} 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \end{bmatrix}$$

$$W_2 = \begin{bmatrix} 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 \end{bmatrix}$$

$$b_2 = \begin{bmatrix} 0 & 0 & 0 & 0 \end{bmatrix}$$

3. 第一个线性变换

计算 $$\mathbf {x}_1 = \mathbf {X} W_1 + b_1$$

$$\mathbf{x}_1 = \begin{bmatrix} 1\times1 + 2\times1 + 3\times1 + 4\times1 & \cdots & 1\times1 + 2\times1 + 3\times1 + 4\times1 \\ 5\times1 + 6\times1 + 7\times1 + 8\times1 & \cdots & 5\times1 + 6\times1 + 7\times1 + 8\times1 \\ 9\times1 + 10\times1 + 11\times1 + 12\times1 & \cdots & 9\times1 + 10\times1 + 11\times1 + 12\times1 \end{bmatrix} = \begin{bmatrix} 10 & \cdots & 10 \\ 26 & \cdots & 26 \\ 42 & \cdots & 42 \end{bmatrix}$$

此时矩阵为 $$3\times4 \cdot 4 \times 16 = 3\times16$$

4. 应用 ReLU 激活函数

计算 $$\mathbf {x}_2 = \text {ReLU}(\mathbf {x}_1)$$，由于 $$\mathbf {x}_1$$ 中的元素都大于 0，所以 $$ \mathbf {x}_2 = \mathbf {x}_1$$。

5. 第二个线性变换

计算 $$ \mathbf {output} = \mathbf {x}_2W_2 + b_2$$：

$$\mathbf{output} = \begin{bmatrix} 10\times1 + \cdots + 10\times1 & 10\times1 + \cdots + 10\times1 & 10\times1 + \cdots + 10\times1 & 10\times1 + \cdots + 10\times1 \\ 26\times1 + \cdots + 26\times1 & 26\times1 + \cdots + 26\times1 & 26\times1 + \cdots + 26\times1 & 26\times1 + \cdots + 26\times1 \\ 42\times1 + \cdots + 42\times1 & 42\times1 + \cdots + 42\times1 & 42\times1 + \cdots + 42\times1 & 42\times1 + \cdots + 42\times1 \end{bmatrix} = \begin{bmatrix} 160 & 160 & 160 & 160 \\ 416 & 416 & 416 & 416 \\ 672 & 672 & 672 & 672 \end{bmatrix}$$

此时矩阵为 $$3\times 16 \cdot 16\times4 = 3\times4$$

经过两次变化，得到和输入一样行和列的矩阵

# 流程总述

最后，用一个集合版的例子，来说明 transformer 中每一层的输入和输出，来帮助理解这个简单的模型

# encode layer

仍然采用 ** 我 ， 爱 . 机器 ， 学习 ** 这个例子来举例，序列长度为 4，其中 embedding 后的维度为 4，采用二头注意力机制。

# 1、根据输入向量，得到 Q、K、V

需要将输入的四个词转换为嵌入向量。假设每个词会被映射为一个 4 维的向量。因此，输入可以表示为一个 $$4 \times 4$$ 的矩阵 $$\mathbf {X}$$，成为词嵌入向量。

假设 $$\mathbf {X} = \begin {bmatrix} 1 & 2 & 3 & 4 \ 5 & 6 & 7 & 8 \ 9 & 10 & 11 & 12 \ 13 & 14 & 15 & 16 \end {bmatrix}$$

此时位置矩阵为：$$\mathbf {P} = \begin {bmatrix} 0 & 1 & 1 & 1 \ 0.84147098 & 0.54030231 & 0.00999983 & 0.99995 \ 0.90929743 & -0.41614684 & 0.01999867 & 0.99980001 \ 0.14112001 & -0.9899925 & 0.0299955 & 0.99955003 \end {bmatrix}$$

此时嵌入层的输出为 $$M+P=\begin {bmatrix} 1 & 3 & 4 & 5 \ 5.84147098 & 6.54030231 & 7.00999983 & 8.99995 \ 9.90929743 & 9.58385316 & 11.01999867 & 12.99980001 \ 13.14112001 & 13.0100075 & 15.0299955 & 16.99955003 \end {bmatrix}$$

此时嵌入层结束，进入 attention 模块

定义头 1 和头 2 的权重矩阵

• 头 1 的权重矩阵：

  • $$W_Q^1 \in \mathbb{R}^{4\times2}$$

  • $$W_K^1 \in \mathbb{R}^{4\times2}$$

  • $$W_V^1 \in \mathbb{R}^{4\times2}$$

• 头 2 的权重矩阵：

  • $$W_Q^2 \in \mathbb{R}^{4\times2}$$

  • $$W_K^2 \in \mathbb{R}^{4\times2}$$

  • $$W_V^2 \in \mathbb{R}^{4\times2}$$

计算每个头的 Q、K、V 矩阵

• 头 1：
  • \mathbf{Q}_1=\mathbf{X}W_Q^1 \\ \mathbf{K}_1=\mathbf{X}W_K^1 \\ \mathbf{V}_1=\mathbf{X}W_V^1 \\$$，结果是一个$$ 4\times2$$ 的矩阵。
  • \mathbf{Q}_2=\mathbf{X}W_Q^2 \\ \mathbf{K}_2=\mathbf{X}W_K^2 \\ \mathbf{V}_2=\mathbf{X}W_V^2 \\$$，结果是一个$$ 4\times2$$ 的矩阵。

$$\mathbf{A}_2 = \text{softmax}(Attention(Q_2,K_2,V_2)))$$

计算头 1 的输出：$$\mathbf {Z}_1=\mathbf {A}_1\mathbf {V}_1$$ ，此时相当于一个概率 (0-1) 的数字 × 一个矩阵，$$Z_2$$ 同理，此时 $$Z_1,Z_2$$ 都是 4*2 的矩阵

将 Z1 和 Z2 拼接，得到 Z，$$\mathbf {Z} = \begin {bmatrix} z_{11} & z_{12} & z_{13} & z_{14} \ z_{21} & z_{22} & z_{23} & z_{24} \ z_{31} & z_{32} & z_{33} & z_{34} \ z_{41} & z_{42} & z_{43} & z_{44} \end {bmatrix}$$

最后将拼接后的矩阵 Z 与输出权重矩阵 $$w_o $$ 相乘，得到最终的多头注意力输出 $$ \mathbf {O}$$，$$w_o$$ 是一个 4*4 的矩阵

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import torch
import torch.nn as nn

# 序列长度
n = 4
# 头的数量
h = 2
# 每个头的特征维度
d_k = 2
# 模型的嵌入维度
d_model = 4

# 假设已经得到拼接后的矩阵 z
z = torch.randn(n, h * d_k)

# 定义权重矩阵 W0
W0 = nn.Linear(h * d_k, d_model)

# 矩阵 z 乘以权重矩阵 W0
Z_out = W0(z)

print("矩阵 z 的形状:", z.shape)
print("权重矩阵 W0 的形状:", W0.weight.shape)
print("最终输出 Z_out 的形状:", Z_out.shape)