大家好~
咱们今天再来聊聊 Transformer ~
首先，用非常简单的语言描述，保证入门同学也能听懂。
Transformer 是一种“超级大脑”，它能处理像句子、歌词、文章这样的连续数据。它非常擅长这些任务，因为它能记住和理解一个句子里的每个单词是如何关联的。这就好比，你和朋友聊天时，不仅要记住朋友说的每句话，还要理解每句话在整个对话中的意思。
1. 理解单词的关系
假设我们有一个句子“猫坐在毯子上”。Transformer 需要知道“猫”和“毯子”之间的关系，比如“猫”是“坐”在“毯子”上，而不是“毯子”坐在“猫”上。这个过程就像一个超级智能的助手，不断观察并理解单词之间的关系。
2. 给单词打分
为了理解单词之间的关系，Transformer 会给每个单词的每个位置打一个分数。这些分数表示一个单词在句子中有多重要。比如，在句子“猫坐在毯子上”中，“猫”对“坐”的重要性可能很高，因为它是行动的主体。Transformer 通过这种打分方式来判断哪些单词对整个句子的意义影响最大。
3. 多个小助手一起工作
Transformer 不只是一个“助手”，它有一群“助手”，每个“助手”都专注于不同方面的信息。比如，一个“助手”可能关注“猫”和“毯子”的关系，另一个“助手”则可能关注“坐在”这个动词。这群“助手”一起工作，就能更好地理解句子的整体意思。
4. 把每个小助手的工作结合起来
在每个“助手”都完成了自己的工作后，Transformer 会把这些信息结合起来，形成对整个句子的完整理解。这就像是你和几个朋友讨论电影情节时，每个人都提出自己的观点，最后大家一起得出结论。
5. 处理更多的句子
Transformer 不仅能处理一个句子，它还能处理很多句子，并且能不断从中学习。这使得它能完成各种任务，比如翻译句子、生成新的句子，甚至回答问题。
最后，想象你是一个侦探，正在调查一个案件。你有一些线索（单词）：“猫”、“坐”、“毯子”、“上”。每个线索看起来很普通，但你需要搞清楚这些线索是怎么关联的。
-
你可能想知道“猫”在哪里。你发现“毯子”这个线索好像和“猫”有点关系。 -
你还注意到“坐”这个线索好像说明了一种行为。 -
最后，你得出结论：哦，原来“猫”是“坐”在“毯子”上。
这就是 Transformer 做的事情。它根据线索理解事情的来龙去脉。
总之，Transformer 是一种用于处理序列数据的深度学习模型，最初用于自然语言处理（NLP）。简而言之，它是一种能够“理解”语言或序列数据，并进行翻译、生成文本、回答问题等任务的工具。相比传统的模型（如 RNN 和 LSTM），Transformer 的效率更高，因为它可以并行处理数据，并且在捕捉长距离依赖关系方面表现更好。
基本原理
Transformer 的核心概念是 自注意力机制（Self-Attention Mechanism），它允许模型在处理每个输入时“关注”输入序列的不同部分。这种机制让模型能够理解每个单词或符号与其他单词或符号之间的关系，而不是逐个地线性处理输入。
Transformer 主要由两个部分组成：
-
编码器（Encoder）：将输入序列转换为一个隐表示（向量表示）。 -
解码器（Decoder）：从隐表示生成输出序列。
编码器 和 解码器 都由多个 层（layers） 组成，每层都包括一个 自注意力机制 和一个 前馈神经网络（Feed-Forward Neural Network, FFN）。
核心公式
为了更好地理解 Transformer 的内部工作机制，我们需要深入了解几个关键公式：
3.1 自注意力机制
对于输入序列 ，每个元素 首先被投影到三个不同的向量：
-
查询向量（Query） -
键向量（Key） -
值向量（Value）
这些向量的计算公式如下：
其中， 是可学习的权重矩阵。
自注意力 的核心公式是计算每个查询向量与所有键向量之间的相似度：
这里， 是缩放因子，用于避免相似度值过大。 函数将相似度转换为权重，最后乘以 得到加权的值向量。
3.2 多头注意力机制（Multi-Head Attention）
为了让模型捕捉到不同子空间的特征，多头注意力机制 将上述注意力机制应用多个头（head）：
其中，每个 是一个独立的自注意力机制：
3.3 前馈神经网络（Feed-Forward Network）
每个编码器和解码器层还包括一个前馈神经网络：
这是一个两层的全连接网络，其中 是 ReLU 激活函数。
案例代码
使用 PyTorch 实现一个小型 Transformer 模型，并在一个简单的数据集上进行训练。
import torch
import torch.nn as nn
import torch.optim as optim
# 定义自注意力机制
class SelfAttention(nn.Module):
def __init__(self, d_model, num_heads):
super(SelfAttention, self).__init__()
self.num_heads = num_heads
self.d_k = d_model // num_heads
self.query = nn.Linear(d_model, d_model)
self.key = nn.Linear(d_model, d_model)
self.value = nn.Linear(d_model, d_model)
self.fc_out = nn.Linear(d_model, d_model)
def forward(self, x):
N, seq_length, d_model = x.shape
Q = self.query(x)
K = self.key(x)
V = self.value(x)
Q = Q.reshape(N, seq_length, self.num_heads, self.d_k)
K = K.reshape(N, seq_length, self.num_heads, self.d_k)
V = V.reshape(N, seq_length, self.num_heads, self.d_k)
energy = torch.einsum("nqhd,nkhd->nhqk", [Q, K])
attention = torch.softmax(energy / (self.d_k ** 0.5), dim=3)
out = torch.einsum("nhql,nlhd->nqhd", [attention, V])
out = out.reshape(N, seq_length, d_model)
return self.fc_out(out)
# 定义 Transformer 编码器层
class TransformerBlock(nn.Module):
def __init__(self, d_model, num_heads, dropout):
super(TransformerBlock, self).__init__()
self.attention = SelfAttention(d_model, num_heads)
self.norm1 = nn.LayerNorm(d_model)
self.norm2 = nn.LayerNorm(d_model)
self.ff = nn.Sequential(
nn.Linear(d_model, d_model * 4),
nn.ReLU(),
nn.Linear(d_model * 4, d_model)
)
self.dropout = nn.Dropout(dropout)
def forward(self, x):
attn_output = self.attention(x)
x = self.norm1(attn_output + x)
ff_output = self.ff(x)
x = self.norm2(ff_output + x)
return self.dropout(x)
# 定义 Transformer 编码器
class TransformerEncoder(nn.Module):
def __init__(self, input_dim, d_model, num_layers, num_heads, dropout):
super(TransformerEncoder, self).__init__()
self.layers = nn.ModuleList([
TransformerBlock(d_model, num_heads, dropout)
for _ in range(num_layers)])
self.embed = nn.Linear(input_dim, d_model)
def forward(self, x):
x = self.embed(x)
for layer in self.layers:
x = layer(x)
return x
# 示例数据集
data = torch.rand(10, 5, 8) # (batch_size, seq_length, input_dim)
# 模型实例
model = TransformerEncoder(input_dim=8, d_model=32, num_layers=2, num_heads=4, dropout=0.1)
# 前向传播
output = model(data)
print(output.shape)
在上面代码中：
-
SelfAttention 定义了自注意力机制。 -
TransformerBlock 包含自注意力机制和前馈神经网络。 -
TransformerEncoder 是多个 Transformer 层的堆叠，用于处理输入数据。
下面，给大家展示如何为 Transformer 的以下部分生成图示：
-
自注意力机制（Self-Attention Mechanism） -
多头注意力机制（Multi-Head Attention） -
Transformer 编码器层（Transformer Block） -
Transformer 编码器（Transformer Encoder）
我们将展示如何计算 Query、Key、Value 以及自注意力权重。
自注意力机制
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
# 示例数据
d_model = 8
seq_length = 5
num_heads = 2
# 模拟 Query, Key, Value
np.random.seed(42)
Q = np.random.rand(seq_length, d_model)
K = np.random.rand(seq_length, d_model)
V = np.random.rand(seq_length, d_model)
# 计算能量值
energy = np.dot(Q, K.T)
# 计算注意力权重
attention_weights = np.exp(energy) / np.sum(np.exp(energy), axis=1, keepdims=True)
# 绘制注意力权重图
plt.figure(figsize=(10, 8))
sns.heatmap(attention_weights, annot=True, cmap="viridis", xticklabels=range(seq_length), yticklabels=range(seq_length))
plt.title("Self-Attention Weights")
plt.xlabel("Key Positions")
plt.ylabel("Query Positions")
plt.show()
这个热图展示了 Query 与 Key 的相似度及其通过 softmax 转换的注意力权重。
多头注意力机制图示
# 示例多头数据
num_heads = 4
d_k = d_model // num_heads
# 模拟多头 Query, Key, Value
Q_heads = np.random.rand(seq_length, num_heads, d_k)
K_heads = np.random.rand(seq_length, num_heads, d_k)
V_heads = np.random.rand(seq_length, num_heads, d_k)
attention_heads = []
for i in range(num_heads):
energy_head = np.dot(Q_heads[:, i, :], K_heads[:, i, :].T)
attention_head = np.exp(energy_head) / np.sum(np.exp(energy_head), axis=1, keepdims=True)
attention_heads.append(attention_head)
# 绘制每个头的注意力权重
fig, axes = plt.subplots(1, num_heads, figsize=(20, 5))
for i, attention_head in enumerate(attention_heads):
sns.heatmap(attention_head, annot=True, cmap="viridis", ax=axes[i], xticklabels=range(seq_length), yticklabels=range(seq_length))
axes[i].set_title(f"Head {i + 1}")
plt.suptitle("Multi-Head Attention Weights")
plt.show()
每个子图展示了不同头的注意力权重，说明模型如何在不同子空间中计算注意力。
Transformer 编码器层
展示通过自注意力机制和前馈神经网络处理数据。
# 模拟数据
x = np.random.rand(seq_length, d_model)
# 模拟自注意力输出
attn_output = np.random.rand(seq_length, d_model)
# 模拟前馈网络输出
ff_output = np.random.rand(seq_length, d_model)
# 绘制Transformer Block处理过程
plt.figure(figsize=(12, 6))
plt.subplot(1, 3, 1)
sns.heatmap(x, annot=True, cmap="Blues")
plt.title("Input Sequence")
plt.subplot(1, 3, 2)
sns.heatmap(attn_output, annot=True, cmap="Greens")
plt.title("Self-Attention Output")
plt.subplot(1, 3, 3)
sns.heatmap(ff_output, annot=True, cmap="Reds")
plt.title("Feed-Forward Output")
plt.suptitle("Transformer Block Processing")
plt.show()
左侧为输入序列，中间为自注意力机制处理后的输出，右侧为前馈神经网络处理后的输出。
Transformer 编码器图示
展示整个编码器的流程，包括嵌入层和多个编码器层。
# 模拟输入数据
x = np.random.rand(seq_length, d_model)
num_layers = 3
# 模拟每层的输出
layer_outputs = [np.random.rand(seq_length, d_model) for _ in range(num_layers)]
# 绘制整个 Transformer Encoder 过程
fig, axes = plt.subplots(1, num_layers + 1, figsize=(18, 6))
sns.heatmap(x, annot=True, cmap="Blues", ax=axes[0])
axes[0].set_title("Input Sequence")
for i, layer_output in enumerate(layer_outputs):
sns.heatmap(layer_output, annot=True, cmap="Purples", ax=axes[i + 1])
axes[i + 1].set_title(f"Layer {i + 1} Output")
plt.suptitle("Transformer Encoder Layers")
plt.show()
第一个子图是输入序列，后续子图展示了经过每层编码器后的输出。
最后
Transformer 模型的核心在于其自注意力机制和多头注意力机制，通过这些机制，模型能够有效地理解并处理序列数据中的复杂关系。虽然其公式和实现细节可能略显复杂，但 Transformer 提供了一种强大而灵活的框架来处理各种自然语言处理任务。