Transformer 架构图（上）

1 课程概览

本课详细讲解 Transformer 架构图上半部分。总流程：输入文字 → 词嵌入层 → 位置编码 → 编码器（多层加工）→ 解码器（多层加工）→ 线性层 → Softmax → 输出概率选词。重点讲解输入部分（Input Embedding + Positional Encoding）。

2 核心概念与定义

Input Embedding：原文本嵌入层，将文字转为词向量。
Positional Encoding：位置编码，给词向量加位置信息。
Multi-Head Attention：多头注意力。
Add & Norm：残差连接 + 层规范化。
Feed Forward：前馈全连接层。

3 模型与算法详解

Transformer 总流程

输入文字 → 词嵌入层 → 位置编码 → 编码器（多层加工）→ 解码器（多层加工）→ 线性层 → Softmax → 输出概率选词

输入部分

第一层：Input Embedding（原文本嵌入层）

作用：将输入的文字（如单词）转成数值向量（词向量）
白话：计算机看不懂的文字转成看懂的
示例："你好" → [1.1, -0.3, 0.21, ...]

第二层：Positional Encoding（位置编码）

作用：给词向量加位置信息
原因：Transformer 本身不明白词的顺序
示例：
- "我打你" 和 "你打我" 字一样，顺序不同意思不同
- 词向量相同，但位置不同
白话：Transformer 本身不明白词的顺序

编码器部分

编码器多层加工：注意力 + 前馈 + 残差 + 规范化

编码器层结构（2 个子层）

子层1：Multi-Head Attention → Add & Norm
子层2：Feed Forward → Add & Norm

Multi-Head Attention（多头注意力）

多个关注点
QKV 运算

Add & Norm（残差连接 + 层规范化）

Add：残差连接，$x + \text{Sublayer}(x)$
Norm：层规范化

Feed Forward（前馈全连接层）

两层全连接网络
中间有 ReLU 激活

编码器总结

Input Embedding → Positional Encoding
                          ↓
    ┌─────────────────────────────────┐
    │  编码器层 × 6                    │
    │  ┌───────────────────────────┐  │
    │  │ Multi-Head Attention      │  │
    │  │ Add & Norm                 │  │
    │  │ Feed Forward               │  │
    │  │ Add & Norm                 │  │
    │  └───────────────────────────┘  │
    └─────────────────────────────────┘
              ↓
        编码器输出

4 数学原理与推导

词嵌入

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

位置编码

$$\text{PE}(pos, 2i) = \sin\left(\frac{pos}{10000^{2i/d}}\right)$$ $$\text{PE}(pos, 2i+1) = \cos\left(\frac{pos}{10000^{2i/d}}\right)$$ $$\text{input} = \text{embedded} + \text{PE}$$

多头注意力

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

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
import math


class PositionalEncoding(nn.Module):
    """位置编码"""
    def __init__(self, d_model, max_len=5000):
        super().__init__()
        
        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, d_model, 2).float() * 
                            (-math.log(10000.0) / d_model))
        
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        
        self.register_buffer('pe', pe.unsqueeze(0))
    
    def forward(self, x):
        # 给词向量加位置信息
        x = x + self.pe[:, :x.size(1)]
        return x


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
        
        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):
        # 线性变换
        Q = self.W_q(Q)
        K = self.W_k(K)
        V = self.W_v(V)
        
        # 注意力计算
        scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
        attn = torch.softmax(scores, dim=-1)
        output = torch.matmul(attn, V)
        
        return self.W_o(output)


class FeedForward(nn.Module):
    """前馈全连接层"""
    def __init__(self, d_model, d_ff=2048):
        super().__init__()
        self.linear1 = nn.Linear(d_model, d_ff)
        self.linear2 = nn.Linear(d_ff, d_model)
    
    def forward(self, x):
        return self.linear2(torch.relu(self.linear1(x)))


class EncoderLayer(nn.Module):
    """编码器层"""
    def __init__(self, d_model, n_heads):
        super().__init__()
        self.attention = MultiHeadAttention(d_model, n_heads)
        self.norm1 = nn.LayerNorm(d_model)
        self.ffn = FeedForward(d_model)
        self.norm2 = nn.LayerNorm(d_model)
    
    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