自回归模型与自注意力机制深度解析：原理对比与实战应用

1次阅读

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

自回归模型（AutoRegressive Model）和自注意力机制（Self-Attention Mechanism）是自然语言处理中两种核心架构，它们在计算范式上有显著差异。

自回归模型 ：
数学表示为：$P(x_t | x_{<t})$，即当前时刻的输出仅依赖于之前的输入。
典型代表：GPT 系列模型。
核心特点：链式条件概率计算，逐生成式预测。
自注意力机制 ：
数学表示为：$Attention(Q, K, V) = softmax(\frac{QK^T}{\sqrt{d_k}})V$。
典型代表：Transformer 架构。
核心特点：全局依赖建模，可并行计算。

通过计算图对比两种范式的差异：

并行性 ：
自回归模型：由于依赖前序输出，难以并行处理。
自注意力机制：可一次性计算所有位置的注意力权重，并行性强。
长程依赖处理 ：
自回归模型：长距离依赖易丢失，梯度消失问题显著。
自注意力机制：通过全局注意力权重，有效捕捉长距离依赖。
内存占用 ：
自回归模型：内存占用较低，适合生成任务。
自注意力机制：内存占用高，尤其是处理长序列时。

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

class MaskedSelfAttention(nn.Module):
    def __init__(self, embed_size, heads):
        super(MaskedSelfAttention, self).__init__()
        self.embed_size = embed_size
        self.heads = heads
        self.head_dim = embed_size // heads

        self.query = nn.Linear(embed_size, embed_size)
        self.key = nn.Linear(embed_size, embed_size)
        self.value = nn.Linear(embed_size, embed_size)
        self.fc_out = nn.Linear(embed_size, embed_size)

    def forward(self, x, mask):
        # x shape: (batch_size, seq_len, embed_size)
        batch_size = x.shape[0]
        seq_len = x.shape[1]

        Q = self.query(x)
        K = self.key(x)
        V = self.value(x)

        # Split into multiple heads
        Q = Q.view(batch_size, seq_len, self.heads, self.head_dim)
        K = K.view(batch_size, seq_len, self.heads, self.head_dim)
        V = V.view(batch_size, seq_len, self.heads, self.head_dim)

        # Compute attention scores
        energy = torch.einsum("bqhd,bkhd->bhqk", [Q, K]) / (self.head_dim ** 0.5)

        # Apply mask
        if mask is not None:
            energy = energy.masked_fill(mask == 0, float("-1e20"))

        attention = F.softmax(energy, dim=-1)
        out = torch.einsum("bhqk,bkhd->bqhd", [attention, V])
        out = out.reshape(batch_size, seq_len, self.embed_size)
        out = self.fc_out(out)
        return out

class SelfAttention(nn.Module):
    def __init__(self, embed_size, heads):
        super(SelfAttention, self).__init__()
        self.embed_size = embed_size
        self.heads = heads
        self.head_dim = embed_size // heads

        self.query = nn.Linear(embed_size, embed_size)
        self.key = nn.Linear(embed_size, embed_size)
        self.value = nn.Linear(embed_size, embed_size)
        self.fc_out = nn.Linear(embed_size, embed_size)

    def forward(self, x):
        # x shape: (batch_size, seq_len, embed_size)
        batch_size = x.shape[0]
        seq_len = x.shape[1]

        Q = self.query(x)
        K = self.key(x)
        V = self.value(x)

        # Split into multiple heads
        Q = Q.view(batch_size, seq_len, self.heads, self.head_dim)
        K = K.view(batch_size, seq_len, self.heads, self.head_dim)
        V = V.view(batch_size, seq_len, self.heads, self.head_dim)

        # Compute attention scores
        energy = torch.einsum("bqhd,bkhd->bhqk", [Q, K]) / (self.head_dim ** 0.5)

        attention = F.softmax(energy, dim=-1)
        out = torch.einsum("bhqk,bkhd->bqhd", [attention, V])
        out = out.reshape(batch_size, seq_len, self.embed_size)
        out = self.fc_out(out)
        return out