深入解析Transformer架构：从理论到实践

1次阅读

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

Transformer 架构由 Google 在 2017 年的论文《Attention Is All You Need》中首次提出，彻底改变了自然语言处理（NLP）领域的格局。它摒弃了传统的循环神经网络（RNN）和卷积神经网络（CNN），完全依赖注意力机制来处理序列数据。这种架构的优势在于能够并行处理输入序列，大大提高了训练效率，并且在长距离依赖建模上表现出色。

Transformer 的出现直接催生了 BERT、GPT 等划时代的模型，成为现代 NLP 技术的基石。理解 Transformer 的架构不仅对学术研究至关重要，也是工业界实际应用的基础。

自注意力机制是 Transformer 的核心创新。它允许模型在处理每个词时，能够关注输入序列中的所有其他词，动态地计算它们的重要性权重。这种机制解决了传统 RNN 在长距离依赖上的局限性。

自注意力的计算公式为：

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

其中 Q、K、V 分别代表查询 (Query)、键(Key) 和值 (Value) 矩阵，d_k 是键向量的维度。

为了捕捉不同子空间的特征信息，Transformer 采用了多头注意力机制。它将 Q、K、V 投影到 h 个不同的子空间，分别计算注意力后拼接结果：

MultiHead(Q,K,V) = Concat(head_1,...,head_h)W^O

其中每个 head_i 都是独立的注意力计算结果。

由于 Transformer 不包含循环结构，需要显式地加入位置信息。位置编码使用正弦和余弦函数生成：

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

这种编码方式能让模型学习到相对位置信息。

每个 Transformer 层包含一个前馈网络(FFN)，它由两个线性变换和一个 ReLU 激活函数组成：

FFN(x) = max(0,xW_1 + b_1)W_2 + b_2

FFN 独立地应用于每个位置，用于处理自注意力层的输出。

层归一化 (LayerNorm) 用于稳定深层网络的训练。它沿着特征维度进行归一化：

LayerNorm(x) = γ*(x-μ)/σ + β

其中 μ 和 σ 是均值和标准差，γ 和 β 是可学习的参数。

Transformer 的整体架构如下图所示（图示说明）：

输入序列经过词嵌入层和位置编码后进入编码器
编码器由 N 个相同的层堆叠而成，每层包含自注意力机制和前馈网络
解码器同样由 N 个相同的层堆叠，额外包含编码器 - 解码器注意力机制
最终输出经过线性层和 softmax 得到预测概率

以下是使用 PyTorch 实现的简化版 Transformer 编码器层：

import torch
import torch.nn as nn
import math

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

        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, q, k, v, mask=None):
        batch_size = q.size(0)

        # 线性变换并分头
        q = self.W_q(q).view(batch_size, -1, self.num_heads, self.d_k).transpose(1,2)
        k = self.W_k(k).view(batch_size, -1, self.num_heads, self.d_k).transpose(1,2)
        v = self.W_v(v).view(batch_size, -1, self.num_heads, self.d_k).transpose(1,2)

        # 计算注意力分数
        scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(self.d_k)
        if mask is not None:
            scores = scores.masked_fill(mask == 0, -1e9)
        attention = torch.softmax(scores, dim=-1)

        # 计算输出
        output = torch.matmul(attention, v)
        output = output.transpose(1,2).contiguous().view(batch_size, -1, self.d_model)
        return self.W_o(output)

class TransformerEncoderLayer(nn.Module):
    def __init__(self, d_model, num_heads, d_ff, dropout=0.1):
        super().__init__()
        self.self_attn = MultiHeadAttention(d_model, num_heads)
        self.ffn = nn.Sequential(nn.Linear(d_model, d_ff),
            nn.ReLU(),
            nn.Linear(d_ff, d_model)
        )
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x, mask=None):
        # 自注意力子层
        attn_output = self.self_attn(x, x, x, mask)
        x = x + self.dropout(attn_output)
        x = self.norm1(x)

        # 前馈子层
        ffn_output = self.ffn(x)
        x = x + self.dropout(ffn_output)
        x = self.norm2(x)
        return x