深入解析B,T,C向量多头注意力机制：从原理到工程实践

1次阅读

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

多头注意力机制（Multi-Head Attention）是 Transformer 架构的核心组件，广泛应用于自然语言处理、计算机视觉等领域。它的核心思想是通过多个注意力头（Attention Heads）并行计算，捕捉输入序列中不同位置的依赖关系。然而，在实际应用中，开发者常常面临三个维度的计算挑战：

Batch（B）：批量处理数据时，显存占用会随着批量大小的增加而线性增长。
Sequence Length（T）：长序列会导致注意力矩阵（T×T）的显存占用呈平方级增长。
Channel（C）：特征通道数（通常为模型维度）的增加会显著影响计算复杂度。

这三个维度的交互使得多头注意力的实现容易遇到内存溢出和计算效率低下的问题，尤其是在处理长序列或大模型时。

为了优化 B、T、C 维度的计算，可以采用以下技术：

张量重塑（Tensor Reshaping）：将输入张量从形状（B, T, C）重塑为（B * num_heads, T, head_dim），其中 head_dim = C / num_heads。这种重塑操作可以将计算分散到多个注意力头上，从而降低单个头的计算负担。
矩阵分块（Matrix Partitioning）：对于长序列（T 较大），可以将注意力矩阵分块计算，避免一次性生成完整的 T×T 矩阵。例如，可以使用滑动窗口（Sliding Window）或局部注意力（Local Attention）来限制每个位置只能关注邻近的若干位置。
内存优化：通过使用原地操作（In-place Operations）和梯度检查点（Gradient Checkpointing）等技术，减少显存占用。

多头注意力的计算可以分解为以下步骤：

线性变换：将输入张量分别投影到查询（Q）、键（K）、值（V）空间。
注意力分数计算：通过矩阵乘法计算 Q 和 K 的点积，然后缩放并应用 Softmax。
加权求和：将注意力分数与 V 相乘，得到输出张量。

通过分块和重塑，可以将上述计算分解为更小的矩阵乘法，从而降低显存和计算复杂度。

以下是一个高效的 PyTorch 实现示例：

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

class MultiHeadAttention(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, "embed_dim must be divisible by num_heads"

        self.qkv_proj = nn.Linear(embed_dim, 3 * embed_dim)
        self.out_proj = nn.Linear(embed_dim, embed_dim)

    def forward(self, x, mask=None):
        B, T, C = x.shape

        # Project to Q, K, V
        qkv = self.qkv_proj(x)
        q, k, v = qkv.chunk(3, dim=-1)

        # Reshape to (B * num_heads, T, head_dim)
        q = q.view(B, T, self.num_heads, self.head_dim).transpose(1, 2).reshape(B * self.num_heads, T, self.head_dim)
        k = k.view(B, T, self.num_heads, self.head_dim).transpose(1, 2).reshape(B * self.num_heads, T, self.head_dim)
        v = v.view(B, T, self.num_heads, self.head_dim).transpose(1, 2).reshape(B * self.num_heads, T, self.head_dim)

        # Compute attention scores
        attn_scores = torch.bmm(q, k.transpose(1, 2)) / (self.head_dim ** 0.5)

        if mask is not None:
            attn_scores = attn_scores.masked_fill(mask == 0, float('-inf'))

        attn_weights = F.softmax(attn_scores, dim=-1)

        # Weighted sum
        out = torch.bmm(attn_weights, v)

        # Reshape back to (B, T, C)
        out = out.view(B, self.num_heads, T, self.head_dim).transpose(1, 2).reshape(B, T, C)

        # Final projection
        out = self.out_proj(out)
        return out

多头注意力的计算复杂度和内存占用主要取决于以下因素：