Transformer 架构介绍 - 文字版

1 课程概览

本课介绍 Transformer 架构。基于 Seq2Seq 架构，由四部分组成：输入部分、编码器、解码器、输出部分。一个编码器由 6 个编码器层组成，一个编码器层由 2 个子层组成。可用于机器翻译、文本生成等任务，也可构建预训练模型用于迁移学习。

2 核心概念与定义

输入部分：Input Embedding + Positional Encoding。
编码器：由 6 个编码器层组成。
解码器：由 6 个解码器层组成。
输出部分：Linear + Softmax。
Input Embedding：词嵌入层，将文字转为词向量。
Positional Encoding：位置编码，给词向量加位置信息。
Multi-Head Attention：多头注意力。
Add & Norm：残差连接 + 层规范化。
Feed Forward：前馈全连接层。

3 模型与算法详解

Transformer 四部分

部分	组成
输入部分	Input Embedding + Positional Encoding
编码器	6 个编码器层
解码器	6 个解码器层
输出部分	Linear + Softmax

编码器结构

编码器 = 6 个编码器层
编码器层 = 2 个子层
子层1：Multi-Head Attention + Add & Norm
子层2：Feed Forward + Add & Norm

解码器结构

解码器 = 6 个解码器层
解码器层 = 3 个子层
子层1：Masked Multi-Head Attention + Add & Norm
子层2：Multi-Head Attention + Add & Norm
子层3：Feed Forward + Add & Norm

各层作用

层	作用
Input Embedding	将输入文字转为词向量
Positional Encoding	给词向量加位置信息
Multi-Head Attention	多头注意力，多个关注点
Add & Norm	残差连接 + 层规范化
Feed Forward	前馈全连接层
Masked Multi-Head Attention	掩码多头注意力，防止偷看未来词
Linear	线性层
Softmax	输出概率分布

位置编码的作用

Transformer 本身不明白词的顺序。

示例：

"我爱你" 和 "你爱我" 字一样，顺序不同，意思不同
"一把把把把住了" 都是"把"字，顺序不同意思不同

作用：给词向量加位置信息，让模型懂得词的顺序。

任务应用

任务	说明
机器翻译	一种语言到另一种语言
文本生成	生成文本
迁移学习	预训练模型直接加载使用

4 数学原理与推导

词嵌入

$$\text{embedded} = \text{Embedding}(x)$$

位置编码

$$\text{input} = \text{embedded} + \text{positional_encoding}$$

多头注意力

$$\text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, ..., \text{head}_h)W^O$$ $$\text{head}_i = \text{Attention}(QW_i^Q, KW_i^K, VW_i^V)$$

Add & Norm

$$\text{output} = \text{LayerNorm}(x + \text{Sublayer}(x))$$

Feed Forward

$$\text{FFN}(x) = \max(0, xW_1 + b_1)W_2 + b_2$$

5 代码示例

import torch
import torch.nn as nn


class Transformer(nn.Module):
    """Transformer 架构"""
    def __init__(self, input_size, output_size, hidden_size, n_heads, n_layers):
        super().__init__()
        # 输入部分
        self.input_embedding = nn.Embedding(input_size, hidden_size)
        self.positional_encoding = PositionalEncoding(hidden_size)
        
        # 编码器
        self.encoder = Encoder(hidden_size, n_heads, n_layers)
        
        # 解码器
        self.decoder = Decoder(hidden_size, n_heads, n_layers)
        
        # 输出部分
        self.linear = nn.Linear(hidden_size, output_size)
        self.softmax = nn.LogSoftmax(dim=-1)
    
    def forward(self, src, trg):
        # 输入部分
        src_embedded = self.input_embedding(src)
        src_embedded = self.positional_encoding(src_embedded)
        
        # 编码器
        encoder_output = self.encoder(src_embedded)
        
        # 解码器
        decoder_output = self.decoder(trg, encoder_output)
        
        # 输出部分
        output = self.softmax(self.linear(decoder_output))
        
        return output


class EncoderLayer(nn.Module):
    """编码器层：2 个子层"""
    def __init__(self, hidden_size, n_heads):
        super().__init__()
        self.attention = MultiHeadAttention(hidden_size, n_heads)
        self.norm1 = nn.LayerNorm(hidden_size)
        self.ffn = FeedForward(hidden_size)
        self.norm2 = nn.LayerNorm(hidden_size)
    
    def forward(self, x):
        # 子层1：Multi-Head Attention + Add & Norm
        attn_output = self.attention(x, x, x)
        x = self.norm1(x + attn_output)
        
        # 子层2：Feed Forward + Add & Norm
        ffn_output = self.ffn(x)
        x = self.norm2(x + ffn_output)
        
        return x