深入解析Transformer架构：从Attention机制到上下文窗口优化

1次阅读

没有评论

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

Transformer 架构自 2017 年由 Google 团队提出以来，彻底改变了自然语言处理（NLP）领域的格局。与传统 RNN 和 LSTM 相比，Transformer 具有三大突破性优势：

完全基于注意力机制，彻底解决了长距离依赖问题
并行计算能力使得训练速度大幅提升
模型可扩展性极强，为后续 BERT、GPT 等大模型奠定了基础

输入序列 X 经过三个不同的线性变换层，分别生成 Query(Q)、Key(K) 和 Value(V) 矩阵
每个矩阵的维度为：[序列长度, 头数, 每头维度]
这些变换使模型能够学习不同的表示空间

Q 和 K 矩阵进行矩阵乘法，得到原始注意力分数
分数经过缩放（除以√dk）防止梯度消失
应用 softmax 归一化得到注意力权重
权重与 V 矩阵相乘得到最终输出

数学表达式：

Attention(Q,K,V) = softmax(QK^T/√dk)V

将原始文本分割为有意义的子词单元
常用算法：Byte Pair Encoding(BPE)、WordPiece
需要平衡词典大小和 OOV 问题

使用正弦余弦函数生成位置信息
偶数位置用正弦，奇数位置用余弦
允许模型学习相对位置关系

公式：

PE(pos,2i) = sin(pos/10000^(2i/dmodel))
PE(pos,2i+1) = cos(pos/10000^(2i/dmodel))

传统 Transformer 的复杂度是序列长度的平方
长序列导致内存爆炸和计算效率低下
信息衰减问题：远端 token 难以影响当前预测

稀疏注意力 ：
只计算局部或特定模式的注意力
如 Longformer 的滑动窗口注意力
内存压缩 ：
使用低秩近似（Linformer）
聚类压缩（Reformer）
分块处理 ：
将长序列切分为多个块
块间使用全局 token 连接

import torch
import torch.nn as nn
import math

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

        # 初始化 QKV 变换矩阵
        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)
        self.W_o = nn.Linear(d_model, d_model)

    def forward(self, x):
        batch_size = x.size(0)

        # 生成 QKV [batch, seq_len, d_model]
        Q = self.W_q(x)
        K = self.W_k(x)
        V = self.W_v(x)

        # 多头切分 [batch, seq_len, n_heads, d_k]
        Q = Q.view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2)
        K = K.view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2)
        V = V.view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2)

        # 计算注意力分数 [batch, n_heads, seq_len, seq_len]
        scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
        attn_weights = torch.softmax(scores, dim=-1)

        # 加权求和 [batch, n_heads, seq_len, d_k]
        output = torch.matmul(attn_weights, V)

        # 合并多头 [batch, seq_len, d_model]
        output = output.transpose(1, 2).contiguous()
        output = output.view(batch_size, -1, self.d_model)

        return self.W_o(output)