AI开发 - GPT之魂用Python 演示chatGPT的自注意力机制

自注意力机制（Self-Attention）就是让模型在处理每个词时，学会“关注重点”，而不是平均地对每个词一视同仁。这种机制让 GPT 能更聪明地理解句子的上下文和语义之间的关系。

自注意力机制是 GPT 的核心，它帮助模型在理解句子时关注到重要的词或信息。

2017年，Google机器翻译团队发表的《Attention is all you need》中大量使用了自注意力（self-attention）机制来学习文本表示。

这篇论文的地址在这里：https://arxiv.org/abs/1706.03762

Self-Attention可以称之为 GPT之魂，因为：

核心作用：自注意力机制（Self-Attention）是Transformer架构的核心，而Transformer正是GPT系列模型的基础。自注意力机制使得模型能够在处理文本时，考虑到序列中所有位置的信息，从而捕捉到更加丰富的上下文关系。这种能力是GPT能够理解和生成高质量文本的根本所在。因此，形容它为“GPT之魂”突出了它在GPT模型中的重要性。
理解上下文的能力：自注意力机制使模型能够在生成每个词语时，依据输入序列的所有其他词语的关系来调整自己的输出。这种全局视野和动态的上下文感知能力是GPT模型强大语言理解和生成能力的基础。可以说，它赋予了GPT模型对语言的“生命力”和深度理解。
灵活性与表达力：与传统的RNN或LSTM等序列模型相比，Transformer和自注意力机制的引入，使得模型可以并行处理序列中的所有词语，并且能够灵活地捕捉长程依赖关系，这种高效的表达能力正是GPT系列能够处理复杂语言任务的原因。

这张图展示了一个注意力机制（Attention Mechanism）的例子，特别关注于长距离依赖（Long-Distance Dependencies）在编码器自注意力（Encoder Self-Attention）中的表现。具体来说，这是在第5层（共6层）的注意力机制的示例。

图中展示了一段文本，其中每个单词都被标注了颜色，这些颜色代表了不同的注意力头（Attention Heads）。注意力头是注意力机制的一部分，它们帮助模型关注输入序列中的不同部分，以更好地理解上下文。

在这张图中，注意力机制特别关注了动词“making”，并完成了短语“making...more difficult”。图中只展示了“making”这个词的注意力分布。不同的颜色代表了不同的注意力头，这些头在处理输入序列时关注了不同的部分。

这种机制对于处理自然语言处理任务中的长距离依赖关系非常重要，因为它允许模型在处理文本时考虑更远的上下文信息，而不仅仅是相邻的单词。

自注意力机制的通俗解释

假设你在阅读一段文字，遇到一句话：

"猫跳过篱笆后，开始追逐一只蝴蝶。"

你想弄清楚“追逐”的主语是谁。这时候，你会把注意力集中到“猫”这个词上，而不是“篱笆”或“蝴蝶”。这种集中注意力的行为，就是“注意力”的核心。

自注意力扩展了这种思想：对于一句话中的每个词，模型会同时关注这句话中所有其他词的相关性，从而决定该词的意义。例如，“追逐”这个词可能会特别关注“猫”和“蝴蝶”，因为它们与动作直接相关，而对“篱笆”的关注较少。

自注意力的核心步骤

表示词的特征：用向量表示每个词。
计算相似性（注意力分数）：用词与词之间的内积表示它们的相关性。
分配权重：用 Softmax 把相关性分数转为概率。
计算加权表示：用权重对每个词的特征进行加权求和，得到新的特征表示。

Python演示：简易自注意力模型

我们是否可以用Python来演示一个最简单的自注意力机制呢？

当然可以，以下是步骤：

下面逐行解释你提供的代码：

1. 导入库

import numpy as np

import numpy as np：导入 NumPy 库并使用 np 作为别名。NumPy 是一个强大的科学计算库，提供了支持大规模、多维数组和矩阵运算的功能。我们在这里使用它来处理词向量和矩阵运算。

2. 模拟输入：三个词的特征表示 (向量大小为4)

words = np.array([
    [1, 0, 1, 0],  # Word 1
    [0, 1, 0, 1],  # Word 2
    [1, 1, 1, 1],  # Word 3
])

words：这是一个形状为 (3,4)(3, 4) 的 NumPy 数组，表示三个词的特征向量，每个词用 4 维向量表示。
- 第一行 [1, 0, 1, 0] 代表词 1。
- 第二行 [0, 1, 0, 1] 代表词 2。
- 第三行 [1, 1, 1, 1] 代表词 3。
每个词向量是一个 4 维向量，特征表示了词的某些特性（例如词义、词性等，具体取决于向量化方法）。这里只是手动定义的简化示例。
你可以把1 2 3 想象成任何词汇，它在这里只代表某个句子中的三个词。

3. 计算相似性分数 (点积)

attention_scores = np.dot(words, words.T)  # shape: (3, 3)

np.dot(words, words.T)：计算 words 矩阵和其转置 words.T 的点积。words.T 的形状是 (4,3)(4, 3)，因此 attention_scores 的形状是 (3,3)(3, 3)。
- 这个点积操作会生成一个 3×33 \times 3 的相似性矩阵，表示句子中每对词之间的相关性（相似性分数）。
- 点积的结果是通过计算词向量之间的内积得到的，内积越大表示两个词越相似。
- 例如，attention_scores[0][1] 就表示词 1 和词 2 之间的相似性。

4. 定义 Softmax 函数

def softmax(x):
    exp_x = np.exp(x - np.max(x))  # 防止溢出
    return exp_x / exp_x.sum(axis=-1, keepdims=True)

softmax(x)：定义了一个 Softmax 函数，用于将相似性分数转化为概率值，使得它们的和为 1。Softmax 函数广泛用于神经网络的输出层，常用于分类问题中的概率预测。
- np.exp(x - np.max(x))：对输入矩阵 x 做指数运算，并减去最大值 np.max(x) 来防止数值溢出（避免 exp 结果过大）。
- exp_x / exp_x.sum(axis=-1, keepdims=True)：将指数化的结果除以每行的总和，确保每行的元素和为 1。这样就得到了归一化后的注意力权重。

5. 计算注意力权重

attention_weights = softmax(attention_scores)

attention_weights：使用 softmax 函数对 attention_scores 进行归一化处理，得到每个词对于其他词的注意力权重。每个值表示一个词对另一个词的关注程度。通过 Softmax 函数，注意力分数被转化为权重，使得每个权重是一个介于 0 和 1 之间的数，且每行的权重和为 1。

6. 加权求和得到新的表示

new_representation = np.dot(attention_weights, words)

np.dot(attention_weights, words)：对 words 进行加权求和，即将每个词向量加权求和，得到新的表示。
- 加权求和：将每个词向量根据其对应的注意力权重进行加权求和，从而生成一个新的表示。
- attention_weights @ words：点积的计算方式等同于对每个词向量按照注意力权重进行加权平均，得到新的词表示。

完整的代码：

import numpy as np

# 模拟输入：三个词的特征表示 (向量大小为4)
words = np.array([
    [1, 0, 1, 0],  # Word 1
    [0, 1, 0, 1],  # Word 2
    [1, 1, 1, 1],  # Word 3
])

# 1. 计算相似性分数 (点积)
attention_scores = np.dot(words, words.T)  # shape: (3, 3)

# 2. 计算注意力权重 (Softmax)
def softmax(x):
    exp_x = np.exp(x - np.max(x))  # 防止溢出
    return exp_x / exp_x.sum(axis=-1, keepdims=True)

attention_weights = softmax(attention_scores)

# 3. 加权求和得到新的表示
# Attention applied: weights @ words
new_representation = np.dot(attention_weights, words)

print("原始词向量:")
print(words)
print("\n注意力分数:")
print(attention_scores)
print("\n注意力权重:")
print(attention_weights)
print("\n新的词表示:")
print(new_representation)

逻辑解释

输入表示：
- 模拟了一个简单的句子，包含三个词，每个词用 4 维向量表示。
相似性分数：
- 用点积计算每个词与其他词的相关性。
- attention_scores[i][j] 表示第 i 个词和第 j 个词的相关性。
注意力权重：
- 使用 Softmax 把分数归一化成概率形式，使得每行的权重之和为 1。
新的表示：
- 对每个词的向量进行加权求和，生成新的特征表示。
- 新的表示包含了全局上下文信息。

输出解读

注意力分数：展示了每个词与其他词的原始相似性。
注意力权重：归一化的分数，用于加权求和。
新的词表示：结合了全句上下文的信息，是“更聪明的词向量”。

通过这种方式，自注意力帮助模型理解词与词之间的关联，从而更好地理解句子整体语义！

我们还可以用一个更加直观的案例来演示：

我们可以用简单的词向量表示这个句子中的词，然后演示自注意力机制如何运作。以下是代码和解释：

句子与词向量

假设句子是：

"猫跳过篱笆后，开始追逐一只蝴蝶。"

为了简单起见，我们用手动定义的低维向量表示每个词（实际模型中用更复杂的嵌入，如 Word2Vec、BERT 等生成向量）。

Python代码实现

import numpy as np

# 模拟词向量 (每个词用 4 维向量表示)
words = {
    "猫": [1, 0, 0, 0],
    "跳过": [0, 1, 0, 0],
    "篱笆": [0, 0, 1, 0],
    "后": [0, 0, 0, 1],
    "开始": [1, 1, 0, 0],
    "追逐": [0, 1, 1, 0],
    "一只": [0, 0, 1, 1],
    "蝴蝶": [1, 0, 0, 1]
}

# 按句子顺序构造输入矩阵
sentence = ["猫", "跳过", "篱笆", "后", "开始", "追逐", "一只", "蝴蝶"]
input_vectors = np.array([words[word] for word in sentence])  # shape: (8, 4)

# 1. 计算相似性分数 (点积)
attention_scores = np.dot(input_vectors, input_vectors.T)  # shape: (8, 8)

# 2. 计算注意力权重 (Softmax)
def softmax(x):
    exp_x = np.exp(x - np.max(x))  # 防止溢出
    return exp_x / exp_x.sum(axis=-1, keepdims=True)

attention_weights = softmax(attention_scores)  # shape: (8, 8)

# 3. 加权求和得到新的表示
new_representations = np.dot(attention_weights, input_vectors)  # shape: (8, 4)

# 打印结果
print("原始词向量:")
for word, vec in zip(sentence, input_vectors):
    print(f"{word}: {vec}")

print("\n注意力分数矩阵 (部分):")
print(attention_scores)

print("\n注意力权重矩阵 (部分):")
print(attention_weights)

print("\n新的词表示:")
for word, vec in zip(sentence, new_representations):
    print(f"{word}: {vec}")