自注意力机制（Self-AttentionMechanism）是Transformer模型的核心组件，它允许模型在处理序列数据时捕捉全局依赖关系。这种机制通过计算输入序列中每个元素与整个序列的关联性来工作，而不是简单地将序列视为固定大小的块。这大大增强了模型对上下文信息的理解和利用能力。 在简单的Transformer模型中，我们首先定义一个编码器层，该层接收输入序列并输出一个固定长度的编码向量。然后，我们使用解码器层，该层接收编码向量作为输入，并输出序列的预测值。在这两个层之间，我们插入了自注意力层，用于计算输入序列中每个元素与整个序列的关联性。 自注意力层的计算过程如下： 1.对于输入序列中的每个元素，计算其与整个序列的关联性得分。这通常通过计算元素的余弦相似度或点积来实现。 2.根据关联性得分，选择与当前元素最相关的其他元素，并计算这些元素的加权和。权重通常根据它们的相关性得分来确定。 3.将加权和与当前元素的原始值相乘，得到新的元素值。 4.将新元素值与当前元素一起，组成一个新的元素向量，并将其传递给下一个时间步长。 通过这种方式，自注意力机制能够捕捉到序列数据的全局依赖关系，从而使得Transformer模型在处理复杂任务时表现出色。

在自然语言处理、计算机视觉等领域，Transformer模型通过使用自注意力机制取得了显著的成果。

本文将介绍如何实现一个简单的Transformer模型，并通过代码示例展示其工作原理。

首先，让我们了解一下什么是自注意力机制。

自注意力机制是一种计算序列中每个元素与其他元素之间关系的机制。

它可以帮助我们理解序列中的每个元素在整个序列中的重要性和相关性。

与传统的循环神经网络（RNN）或卷积神经网络（CNN）相比，自注意力机制可以更好地捕捉长距离依赖关系，并且不需要显式地定义序列的顺序。

下面是一个简化版的Transformer模型的实现，我们将重点放在自注意力机制上：

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)
        keys = self.keys(keys)
        queries = self.queries(queries)

        # Perform scaled dot-product attention
        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

这个类接受输入值、键和查询，并计算它们之间的注意力权重。

注意力权重是通过缩放点积注意力计算得到的，然后应用了一个掩码来忽略某些位置的信息。

最后，我们通过加权求和得到输出。

现在，让我们来看一个更完整的Transformer模型的实现，包括多头自注意力、前馈神经网络和层归一化等组件：

lass TransformerBlock(nn.Module):
    def __init__(self, embed_size, heads, dropout, forward_expansion):
        super(TransformerBlock, self).__init__()
        self.attention = SelfAttention(embed_size, heads)
        self.norm1 = nn.LayerNorm(embed_size)
        self.norm2 = nn.LayerNorm(embed_size)

        self.feed_forward = nn.Sequential(
            nn.Linear(embed_size, forward_expansion * embed_size),
            nn.ReLU(),
            nn.Linear(forward_expansion * embed_size, embed_size),
        )

        self.dropout = nn.Dropout(dropout)

    def forward(self, value, key, query, mask):
        attention = self.attention(value, key, query, mask)

        # Add a skip connection and apply layer normalization
        x = self.dropout(self.norm1(attention + query))
        forward = self.feed_forward(x)
        out = self.dropout(self.norm2(forward + x))
        return out

接下来，我们通过前馈神经网络进行进一步的处理，并将结果与之前的输出相加并进行层归一化。

最后，我们应用dropout以减少过拟合的风险。

这只是一个简单的Transformer模型实现，实际应用中还需要考虑更多的细节，如位置编码、多层堆叠、词嵌入等。

然而，通过这个简化版的实现，我们可以更好地理解自注意力机制是如何工作的，以及它是如何帮助Transformer模型捕捉序列数据中的全局依赖关系的。

Transformer中的自注意力机制详解与代码实现 - 集智数据集