终于把 Transformer 中的注意力机制搞懂了！！_ttransformer为什么要使用6层注意力机智-CSDN博客

本文链接：https://blog.csdn.net/Code1994/article/details/143417191

注意力机制是深度学习领域中广泛应用的技术，特别是在自然语言处理和计算机视觉任务中。它使模型能够有选择地关注输入数据的特定部分，以此提升模型的性能。

想象一下，当你读到 “The cat sat on the mat” 这句话时，人类可以立即理解单词之间的关系，可以知道 “sat” 与 “cat” 的关系比与“mat”的关系更密切。

注意力机制使机器能够捕捉类似的关系，帮助它们专注于输入数据的特定部分。

Transformer 中的注意力机制

在 Transformer 模型中，注意力机制是其核心组件，它使得模型可以在处理输入序列的过程中关注到最重要的信息，从而大幅提高了模型在长序列中的表现。

自注意力机制

在自注意力机制中，每个输入向量可以“关注”同一序列中的其他向量，这使得模型能够灵活地关注整个序列的不同部分。

自注意力机制的计算过程包括以下几个步骤。

查询（Query）、键（Key）和值（Value）向量

对输入序列 X 进行线性变换，生成查询（Query）、键（Key）、和值（Value）三组向量

其中、、是可学习的权重矩阵
计算注意力得分

使用点积来衡量查询和键之间的相似性，以得到注意力得分

其中是缩放因子，用于避免得分值过大引起梯度不稳定。
归一化

将注意力得分输入到 Softmax 函数中，得到每个位置的注意力权重，使得这些权重总和为 1。

注意力权重可以理解为“当前位置对其他位置的关注程度”
加权求和

最后，用归一化的注意力权重对值矩阵 V 进行加权求和，得到最终的自注意力输出。

下面，我们一起来看一下如何使用代码来实现上述过程。

import numpy as np

word_embeddings = {
    'she':    np.array([0.2, 0.9, 0.1, 0.5]),
    'likes':  np.array([0.8, 0.3, 0.7, 0.2]),
    'coffee': np.array([0.4, 0.6, 0.3, 0.9])
}

X = np.vstack([word_embeddings['she'], 
               word_embeddings['likes'], 
               word_embeddings['coffee']])
               
W_q = np.array([[0.9, 0.1, 0.1, 0.1],
                [0.1, 0.9, 0.1, 0.1],
                [0.1, 0.1, 0.9, 0.1],
                [0.1, 0.1, 0.1, 0.9]])

W_k = np.array([[0.9, 0.1, 0.1, 0.1],
                [0.1, 0.9, 0.1, 0.1],
                [0.1, 0.1, 0.9, 0.1],
                [0.1, 0.1, 0.1, 0.9]])
W_v = np.array([[0.8, 0.2, 0.1, 0.1],
                [0.2, 0.8, 0.2, 0.1],
                [0.1, 0.2, 0.8, 0.1],
                [0.1, 0.1, 0.1, 0.9]])
                
Q = np.dot(X, W_q)
K = np.dot(X, W_k)
V = np.dot(X, W_v)

scores = np.dot(Q, K.T)

d_k = K.shape[1]
scaled_scores = scores / np.sqrt(d_k)

exp_scores = np.exp(scaled_scores)
attention_weights = exp_scores / exp_scores.sum(axis=1, keepdims=True)

output = np.dot(attention_weights, V)

print(output)

多头注意力机制（Multi-Head Attention）

多头注意力机制进一步扩展了自注意力的表达能力。

通过设置多个注意力头（head），每个头从不同的子空间中获取信息，最后将各头的结果拼接起来并进行线性变换。

这样模型可以更好地捕捉多维度的依赖关系，使其在复杂任务中表现更为优异。

多头注意力的计算流程

多头计算

输入经过多个注意力头的处理，每个头使用一组独立的参数，生成多组不同的查询、键和值。
并行执行自注意力

各个头并行执行自注意力操作，每个头得到的输出向量表示了该头对输入的不同“关注”。
拼接输出并线性变换

所有头的输出被拼接在一起，通过线性变换映射到输出空间。

其中每个是各个头的自注意力输出，是线性变换矩阵。

多头注意力机制增加了模型的灵活性，能让模型从不同角度学习到序列中词汇间的关系。

class MultiHeadAttention(nn.Module):    
    
    def __init__(self, d_model, num_heads):
        super(MultiHeadAttention, self).__init__()
        # Ensure that the model dimension (d_model) is divisible by the number of heads
        assert d_model % num_heads == 0 
        
        # Initialize dimensions
        self.d_model = d_model # Model's dimension
        self.num_heads = num_heads # Number of attention heads
        self.d_k = d_model // num_heads # Dimension of each head's key, query, and value
        
        # Linear layers for transforming inputs
        self.W_q = nn.Linear(d_model, d_model) # Query transformation
        self.W_k = nn.Linear(d_model, d_model) # Key transformation
        self.W_v = nn.Linear(d_model, d_model) # Value transformation
        self.W_o = nn.Linear(d_model, d_model) # Output transformation
    
    # 缩放点积注意力机制
    def scaled_dot_product_attention(self, Q, K, V, mask=None):
        # Calculate attention scores
        attn_scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
        
        # Apply mask if provided (useful for preventing attention to certain parts like padding)
        if mask is not None:
            attn_scores = attn_scores.masked_fill(mask == 0, -1e9)
        
        # Softmax is applied to obtain attention probabilities
        attn_probs = torch.softmax(attn_scores, dim=-1)
        
        # Multiply by values to obtain the final output
        output = torch.matmul(attn_probs, V)
        return output
        
    def split_heads(self, x):
        # Reshape the input to have num_heads for multi-head attention
        batch_size, seq_length, d_model = x.size()
        return x.view(batch_size, seq_length, self.num_heads, self.d_k).transpose(1, 2)
        
    def combine_heads(self, x):
        # Combine the multiple heads back to original shape
        batch_size, _, seq_length, d_k = x.size()
        return x.transpose(1, 2).contiguous().view(batch_size, seq_length, self.d_model)
        
    def forward(self, Q, K, V, mask=None):
        # Apply linear transformations and split heads
        Q = self.split_heads(self.W_q(Q))
        K = self.split_heads(self.W_k(K))
        V = self.split_heads(self.W_v(V))
        
        # Perform scaled dot-product attention
        attn_output = self.scaled_dot_product_attention(Q, K, V, mask)
        
        # Combine heads and apply output transformation
        output = self.W_o(self.combine_heads(attn_output))
        return output