深入解析cabm自注意力机制：从原理到新手实践指南

1次阅读

共计 2672 个字符，预计需要花费 7 分钟才能阅读完成。

自注意力机制作为 Transformer 架构的核心组件，在各种 NLP 任务中展现出强大的性能。但对于刚接触这一领域的开发者来说，理解并实现 cabm 自注意力机制可能会遇到不少挑战。本文将从基础原理出发，逐步解析 cabm 自注意力的实现细节，并提供可直接运行的代码示例，帮助大家快速掌握这一关键技术。

cabm 自注意力机制的核心思想是通过计算序列中每个元素与其他元素的相关性，动态地为每个位置分配不同的注意力权重。其数学表达如下：

[Attention(Q,K,V)=softmax(\frac{QK^T}{\sqrt{d_k}})V]

其中：
– Q(Query)表示查询向量
– K(Key)表示键向量
– V(Value)表示值向量
– d_k 是键向量的维度

线性变换：
首先对输入序列 X 进行三个不同的线性变换，得到 Q、K、V 矩阵：
[Q = XW_Q, K = XW_K, V = XW_V]
注意力分数计算：
计算 query 和 key 的点积，并除以√d_k 进行缩放：
[S = \frac{QK^T}{\sqrt{d_k}}]
softmax 归一化：
对注意力分数进行 softmax 操作，得到注意力权重：
[A = softmax(S)]
加权求和：
用注意力权重对 value 进行加权求和，得到最终输出：
[O = AV]

下面是一个完整的 cabm 自注意力机制的 PyTorch 实现，包含 masked attention 功能：

import torch
import torch.nn as nn
import torch.nn.functional as F

class CABMAttention(nn.Module):
    def __init__(self, embed_dim, num_heads):
        super().__init__()
        self.embed_dim = embed_dim
        self.num_heads = num_heads
        self.head_dim = embed_dim // num_heads

        assert self.head_dim * num_heads == embed_dim, "Embedding dim must be divisible by num_heads"

        self.q_proj = nn.Linear(embed_dim, embed_dim)
        self.k_proj = nn.Linear(embed_dim, embed_dim)
        self.v_proj = nn.Linear(embed_dim, embed_dim)
        self.out_proj = nn.Linear(embed_dim, embed_dim)

    def forward(self, x, mask=None):
        batch_size, seq_len, embed_dim = x.size()

        # 线性变换得到 Q,K,V
        q = self.q_proj(x)  # [batch_size, seq_len, embed_dim]
        k = self.k_proj(x)
        v = self.v_proj(x)

        # 多头切分
        q = q.view(batch_size, seq_len, self.num_heads, self.head_dim).transpose(1, 2)
        k = k.view(batch_size, seq_len, self.num_heads, self.head_dim).transpose(1, 2)
        v = v.view(batch_size, seq_len, self.num_heads, self.head_dim).transpose(1, 2)

        # 计算注意力分数
        attn_scores = torch.matmul(q, k.transpose(-2, -1)) / torch.sqrt(torch.tensor(self.head_dim, dtype=torch.float32))

        # 应用 mask(如果有)
        if mask is not None:
            attn_scores = attn_scores.masked_fill(mask == 0, float('-inf'))

        # softmax 归一化
        attn_weights = F.softmax(attn_scores, dim=-1)

        # 加权求和
        output = torch.matmul(attn_weights, v)

        # 合并多头
        output = output.transpose(1, 2).contiguous().view(batch_size, seq_len, embed_dim)

        # 最终线性变换
        output = self.out_proj(output)

        return output, attn_weights

自注意力机制的内存消耗主要来自以下几个方面：