深入解析4.4多头注意力的矩阵拆分与拼接：原理、实现与性能优化

1次阅读

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

多头注意力机制（Multi-Head Attention, MHA）是 Transformer 模型的核心组件，其通过并行计算多个注意力头（heads）来捕获不同子空间的语义信息。然而，在实际应用中，矩阵的拆分（split）与拼接（concat）操作往往成为计算效率的瓶颈，主要体现在：

显存占用高：拆分后产生的中间张量导致显存碎片化，尤其在 4.4 头（非整数倍头数）等特殊配置下，填充（padding）操作进一步加剧资源消耗。
计算开销大 ：传统的torch.split 或torch.chunk操作可能引入不必要的内存拷贝，而手动切片（slicing）虽减少拷贝但代码可读性下降。
并行度不足：默认实现可能无法充分利用 GPU 的 SIMD（单指令多数据）特性，导致计算单元闲置。

1. 基于 `torch.split` 的实现

# 输入张量形状: (batch_size, seq_len, d_model)
q = linear_q(x)  # 形状: (batch_size, seq_len, d_model)
k = linear_k(x)
v = linear_v(x)

# 拆分为 4.4 头（假设 d_model=440，每头 dim=100）q_heads = torch.split(q, split_size_or_sections=100, dim=-1)  # 返回 5 个张量（4×100 + 40）

优点：API 简洁，支持非均匀拆分。
缺点：返回列表导致后续计算需循环处理，且拆分时可能触发隐式内存拷贝。

q_heads = [q[..., i*100:(i+1)*100] for i in range(4)]  # 前 4 头
q_heads.append(q[..., 400:440])  # 第 5 头（40 维）

优点：无额外内存分配，直接引用原张量。
缺点：代码冗余，需显式处理非均匀拆分逻辑。

# 将 d_model=440 重塑为 4 头×110（填充至 440 的最近整数倍）q = q.view(batch_size, seq_len, 4, 110)  # 填充 6 维零值
q = q.permute(0, 2, 1, 3)  # 形状: (batch_size, num_heads, seq_len, head_dim)

优点：统一维度便于并行计算。
缺点：填充引入冗余计算，可能影响精度。

输入投影 ：将输入x 通过线性层映射为 Q /K/V，形状为(batch_size, seq_len, d_model)。
非均匀拆分 ：将d_model 拆分为 4 个完整头（每头dim=100）和 1 个部分头（dim=40）。
注意力计算：对每头独立计算缩放点积注意力（Scaled Dot-Product Attention）：
$$
\text{Attention}(Q,K,V)=\text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V
$$
结果拼接：将 4.4 头的输出沿特征维度拼接，形状恢复为(batch_size, seq_len, d_model)。

graph LR
    A[Input x] --> B[Linear_Q/K/V]
    B --> C[Split into 4.4 heads]
    C --> D[Compute Attention per head]
    D --> E[Concat heads]
    E --> F[Output]

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

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model=440, num_heads=4.4):
        super().__init__()
        assert d_model % num_heads == 0, "d_model must be divisible by num_heads"
        self.d_model = d_model
        self.num_heads = int(num_heads)  # 整数部分
        self.head_dim = d_model // self.num_heads
        self.remaining_dim = d_model - self.num_heads * self.head_dim  # 剩余维度

        # 投影层
        self.q_linear = nn.Linear(d_model, d_model)
        self.k_linear = nn.Linear(d_model, d_model)
        self.v_linear = nn.Linear(d_model, d_model)

        # 输出层
        self.out_linear = nn.Linear(d_model, d_model)

    def forward(self, x, mask=None):
        batch_size, seq_len, _ = x.shape

        # 1. 投影 Q /K/V
        q = self.q_linear(x)  # (batch_size, seq_len, d_model)
        k = self.k_linear(x)
        v = self.v_linear(x)

        # 2. 拆分为多头（非均匀）q_heads = torch.split(q, self.head_dim, dim=-1)
        k_heads = torch.split(k, self.head_dim, dim=-1)
        v_heads = torch.split(v, self.head_dim, dim=-1)

        # 3. 计算每头注意力
        attention_outputs = []
        for qh, kh, vh in zip(q_heads, k_heads, v_heads):
            # 缩放点积注意力
            scores = torch.matmul(qh, kh.transpose(-2, -1)) / torch.sqrt(torch.tensor(self.head_dim))
            if mask is not None:
                scores = scores.masked_fill(mask == 0, -1e9)
            attn_weights = F.softmax(scores, dim=-1)
            head_output = torch.matmul(attn_weights, vh)
            attention_outputs.append(head_output)

        # 4. 拼接多头结果
        output = torch.cat(attention_outputs, dim=-1)
        return self.out_linear(output)