【机器学习】自然语言处理（NLP）领域革命性突破的模型——Transformer

自注意力机制是一种强大的工具，它允许模型在序列内部的不同位置间直接建立关系，从而提高了模型的性能和灵活性。通过计算注意力权重并生成加权和表示，自注意力机制能够捕捉到序列中的重要长距离依赖关系，并在各种NLP任务中表现出色。概念自注意力机制是一种特殊的注意力机制，主要关注于输入序列本身，允许模型在序列内部的不同位置间直接建立关系。它通过将序列中的每个位置视为查询（Query），同时作为键（Key）和

小乌龟不会飞

2699人浏览 · 2024-06-25 08:00:00

小乌龟不会飞 · 2024-06-25 08:00:00 发布

个人主页：东洛的克莱斯韦克-CSDN博客

👀引言

👀在自然语言处理领域，传统的循环神经网络和长短时记忆网络虽然取得了一定的成果，但在处理长序列时会出现梯度消失或梯度爆炸的问题，这限制了它们的性能。

👀为了解决这些问题，谷歌提出了Transformer模型。该模型采用自注意力机制进行信息的交互与传递，具有高效的计算效率和强大的表示能力。

🧠自注意力机制介绍🧠

🧠自注意力机制是一种强大的工具，它允许模型在序列内部的不同位置间直接建立关系，从而提高了模型的性能和灵活性。通过计算注意力权重并生成加权和表示，自注意力机制能够捕捉到序列中的重要长距离依赖关系，并在各种NLP任务中表现出色。

概念

🧠自注意力机制是一种特殊的注意力机制，它通过将序列中的每个位置视为查询（Query），同时作为键（Key）和值（Value），来计算注意力权重并生成加权和表示。

核心组件

🧠查询（Query）、键（Key）、值（Value）：输入序列中的每个元素首先被转换为这三个向量。查询向量用于与键向量进行匹配，值向量则用于生成加权和表示。

🧠注意力权重：通过计算查询向量和键向量的点积（或其他相似度度量），然后经过softmax归一化得到注意力权重。这些权重表示了输入序列中不同位置之间的依赖关系。

生成Query、Key和Value向量

🧠对于序列中的每个嵌入向量，我们会生成对应的Query、Key和Value向量。这通常是通过将嵌入向量与三个不同的权重矩阵（Wq, Wk, Wv）相乘来实现的。这些权重矩阵是随机初始化的，并在训练过程中进行更新。在这个例子中，假设权重矩阵的维度是(64, 512)，因此生成的Query、Key和Value向量的维度是64维。生成Query、Key和Value向量

🧠以单词"Games"为例，假设其嵌入向量为X，则：

q = X * Wq

k = X * Wk

v = X * Wv

计算注意力权重

🧠接下来，对于序列中的每个单词（作为Query），我们计算它与序列中其他所有单词（作为Key）之间的相似度。这通常是通过点积（dot product）来实现的，即计算Query向量和Key向量的点积。然后，这些点积值经过softmax函数进行归一化，得到注意力权重。

🧠以单词"Games"为例，当处理它时，我们会计算它与"The"、"2022"、"Beijing"、"Winter"等单词的注意力权重。

加权求和

🧠最后，我们使用注意力权重对Value向量进行加权求和，得到最终的表示向量。这个表示向量将考虑到序列中所有单词与当前单词的相关性。

🧠以单词"Games"为例，其最终的表示向量将是序列中所有单词的Value向量的加权和，其中权重是单词"Games"与这些单词之间的注意力权重。

🧠为了理解自注意力机制，如下是PyTorch框架来编写的一个简单的示例代码

import torch  
import torch.nn as nn  
import torch.nn.functional as F  
  
class SelfAttention(nn.Module):  
    def __init__(self, embed_size, heads):  
        super(SelfAttention, self).__init__()  
        self.embed_size = embed_size  
        self.heads = heads  
        self.head_dim = embed_size // heads  
          
        assert (self.head_dim * heads == embed_size), "Embedding size needs to be divisible by heads"  
          
        self.values = nn.Linear(self.head_dim, self.head_dim, bias=False)  
        self.keys = nn.Linear(self.head_dim, self.head_dim, bias=False)  
        self.queries = nn.Linear(self.head_dim, self.head_dim, bias=False)  
        self.fc_out = nn.Linear(heads * self.head_dim, embed_size)  
          
    def forward(self, values, keys, query, mask):  
        N = query.shape[0]  
        value_len, key_len, query_len = values.shape[1], keys.shape[1], query.shape[1]  
          
        # Split the embedding into self.heads different pieces  
        values = values.reshape(N, value_len, self.heads, self.head_dim)  
        keys = keys.reshape(N, key_len, self.heads, self.head_dim)  
        queries = query.reshape(N, query_len, self.heads, self.head_dim)  
          
        values = self.values(values)   # (N, value_len, heads, head_dim)  
        keys = self.keys(keys)   # (N, key_len, heads, head_dim)  
        queries = self.queries(queries)  # (N, query_len, heads, head_dim)  
          
        # Einsum does matrix multiplication for query, key and then sum the last two dimensions.  
        # query shape: (N, query_len, heads, head_dim), key shape: (N, key_len, heads, head_dim)  
        # output shape: (N, heads, query_len, key_len)  
        energy = torch.einsum("nqhd,nkhd->nhqk", [queries, keys])  
          
        if mask is not None:  
            energy = energy.masked_fill(mask == 0, float("-1e20"))  
          
        attention = torch.softmax(energy / (self.embed_size ** (1/2)), dim=3)  
          
        out = torch.einsum("nhql,nlhd->nqhd", [attention, values]).reshape(N, query_len, self.heads * self.head_dim)  
        out = self.fc_out(out)  
          
        return out  
  
# 示例输入  
# 假设有3个序列，每个序列长度为5，嵌入维度为10，头数为2  
embed_size = 10  
heads = 2  
batch_size = 3  
seq_len = 5  
  
# 随机初始化嵌入向量  
values = torch.randn(batch_size, seq_len, embed_size)  
keys = torch.randn(batch_size, seq_len, embed_size)  
query = torch.randn(batch_size, seq_len, embed_size)  
  
# 假设没有mask（在实际应用中，mask通常用于处理填充token）  
mask = None  
  
# 实例化自注意力层  
attention = SelfAttention(embed_size, heads)  
  
# 前向传播  
output = attention(values, keys, query, mask)  
  
print(output.shape)  # 应该输出 (batch_size, seq_len, embed_size)