Attention Free Transformer 入门指南：从原理到实现

1次阅读

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

Transformer 架构在自然语言处理和计算机视觉等领域取得了巨大成功，但其核心的注意力机制存在计算复杂度高的问题。传统 Transformer 的自注意力计算复杂度为 O(n²)，其中 n 是序列长度，这限制了其在长序列任务中的应用。

Attention Free Transformer (AFT) 应运而生，旨在通过简化注意力机制来降低计算复杂度。AFT 的核心思想是使用更高效的方式来捕捉序列中的长距离依赖关系，同时保持模型的表达能力。

与传统 Transformer 相比，AFT 在以下几个方面有显著改进：

计算复杂度：AFT 的计算复杂度降低到 O(n)，使其更适合处理长序列
内存占用：AFT 的内存需求显著减少，特别是在长序列场景下
训练稳定性：AFT 通常表现出更好的训练稳定性

量化比较（序列长度 =1024）：

指标	Transformer	AFT
FLOPs	1.0x	0.3x
内存占用	1.0x	0.5x
训练时间	1.0x	0.7x

AFT 的核心是使用位置相关的权重矩阵来代替传统的注意力机制。具体来说，给定输入序列 X ∈ ℝ^{n×d}，AFT 的计算可以表示为：

Y = σ(Q) ⊙ (K^T V)

其中：
– Q, K, V 是通过线性变换得到的查询、键和值矩阵
– σ 是 sigmoid 函数
– ⊙ 表示逐元素乘法

这个公式消除了传统注意力中的 softmax 计算，大大降低了计算复杂度。

以下是 AFT 层的 PyTorch 实现：

import torch
import torch.nn as nn

class AFTLayer(nn.Module):
    def __init__(self, d_model, n_heads):
        super().__init__()
        self.d_model = d_model
        self.n_heads = n_heads
        self.head_dim = d_model // n_heads

        # 初始化投影矩阵
        self.Wq = nn.Linear(d_model, d_model)
        self.Wk = nn.Linear(d_model, d_model)
        self.Wv = nn.Linear(d_model, d_model)
        self.Wo = nn.Linear(d_model, d_model)

        # 位置权重参数
        self.position_weights = nn.Parameter(torch.randn(n_heads, 1, 1))

    def forward(self, x):
        """
        输入:
            x: [batch_size, seq_len, d_model]
        输出:
            out: [batch_size, seq_len, d_model]
        """
        batch_size, seq_len, _ = x.shape

        # 计算 Q,K,V
        Q = self.Wq(x)  # [batch, seq, d_model]
        K = self.Wk(x)  # [batch, seq, d_model]
        V = self.Wv(x)  # [batch, seq, d_model]

        # 多头切分
        Q = Q.view(batch_size, seq_len, self.n_heads, self.head_dim)
        K = K.view(batch_size, seq_len, self.n_heads, self.head_dim)
        V = V.view(batch_size, seq_len, self.n_heads, self.head_dim)

        # 计算注意力自由变换
        sig_q = torch.sigmoid(Q)  # [batch, seq, heads, head_dim]
        weighted = sig_q * (K.transpose(1,2) @ V)  # [batch, heads, seq, head_dim]

        # 应用位置权重
        weighted = weighted * self.position_weights

        # 合并多头
        weighted = weighted.transpose(1,2).contiguous()
        weighted = weighted.view(batch_size, seq_len, self.d_model)

        # 输出投影
        out = self.Wo(weighted)
        return out

在 WikiText-103 数据集上的初步实验结果（测试环境：NVIDIA V100, batch_size=32）：