AI基石 | 大模型基石：Transformer 架构 —— GPT 是如何“读懂”你的？

前言

欢迎来到“AI 自学路线”的第二阶段：大模型核心技术！

在上一阶段，我们学习了逻辑回归和 SVM。它们像精密的瑞士手表，处理表格数据得心应手，但面对复杂的语言（比如理解双关语、写代码、写诗），它们就束手无策了。

2017 年，Google 团队发表了一篇神级论文 《Attention Is All You Need》，提出了 Transformer 架构。

这一刻，AI 的历史被改写了。

BERT、GPT、T5、Llama……如今所有叱咤风云的大模型，身体里流淌的都是 Transformer 的血。

今天，我们要拆解这个庞然大物，搞懂那个让 AI 产生“智能”的核心秘密 —— 自注意力机制 (Self-Attention)。

---

一、 为什么要抛弃 RNN？（时代的眼泪）

在 Transformer 出现之前，处理语言主要靠 RNN (循环神经网络)。

RNN 像一个阅读速度极慢的人，它必须一个字一个字地读：读了“我”，记下来；再读“爱”，把“我”和“爱”结合；再读“北京”……

RNN 的两大死穴：

1. 无法并行：必须等读完上一个字，才能读下一个字。训练巨慢，无法利用 GPU 的并行能力。
2. 健忘：读到文章结尾时，往往已经忘了开头讲什么（长距离依赖问题）。

Transformer 的出现，就是为了解决这两个问题：

• 它能一口气读完整篇文章（并行计算）。
• 它能瞬间看清文章中任意两个字之间的关系（全局注意力）。

---

二、 核心灵魂：自注意力机制 (Self-Attention)

Transformer 的心脏，就是 Self-Attention。

简单说，就是让模型在处理每一个字时，都看看句子里的其他字，以此来确定这个字的真实含义。

1. 直觉理解：Q、K、V 的舞会

想象你在读这句话：“苹果发布了新手机。” vs “我也想吃苹果。”

• 第一句的“苹果”应该关注“手机”、“发布”（科技公司）。
• 第二句的“苹果”应该关注“吃”（水果）。

为了实现这种关注，Transformer 给每个字都分配了三个角色（向量）：

• Query (Q)：查询向量。像是你在拿着麦克风问：“我该和谁搭配？”
• Key (K)：索引向量。像是每个字胸前的号码牌，用来被 Q 寻找。
• Value (V)：内容向量。如果不被关注，我原本的含义是什么。

过程就像一场配对舞会：

1. “苹果”拿着自己的 $Q$，去和句子里所有字的 $K$ 进行匹配（点积运算）。
2. 如果 $Q$ 和某个 $K$ 很像（比如“苹果”和“吃”），它们的匹配分（Attention Score）就很高。
3. 根据分数高低，把所有字的 $V$ 加权融合，就得到了“苹果”在这个语境下的新表示。

2. 数学公式（面试必考）

$$Attention(Q,K,V)=\text{softmax}\left(\frac{Q{K}^T}{\sqrt{d_k}}\right)V$$

• $Q{K}^T$：计算相似度（注意力分数）。

• $\sqrt{d_k}$：缩放因子，防止分数太大导致梯度消失。

• $\text{softmax}$：归一化，把分数变成概率（和为 1）。

• 乘 $V$：根据概率提取信息。

---

三、 进阶模块：多头注意力与位置编码

1. 多头注意力 (Multi-Head Attention)

如果只用一组 Q、K、V，可能只能捕捉到一种关系（比如语法关系）。

为了更强，Transformer 搞了 8 个头（8 heads），就像让 8 个人同时读一句话：

• 头 1 关注语法（主谓宾）。

• 头 2 关注指代（“它”指谁）。

• 头 3 关注情感（褒义/贬义）。

  最后把 8 个人的理解拼起来，就得到了极其丰富的语义信息。

2. 位置编码 (Positional Encoding)

因为 Transformer 是一口气读完句子的，它本身不知道“我爱你”和“你爱我”的区别（词序丢失）。 所以，我们必须人为地给每个字加上一个位置标记，告诉模型谁在第一位，谁在第二位。

---

四、 PyTorch 代码实战：注意力

手撸 Self-Attention

Talk is cheap，我们直接用 PyTorch 实现最核心的 Self-Attention 层。 这行代码价值连城，请仔细阅读注释。

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

class SelfAttention(nn.Module):
    def __init__(self, d_model, d_k):
        super().__init__()
        self.d_k = d_k
        self.d_model = d_model
        
        # 定义 Wq, Wk, Wv 矩阵，用于生成 Q, K, V
        self.W_q = nn.Linear(d_model, d_k)
        self.W_k = nn.Linear(d_model, d_k)
        self.W_v = nn.Linear(d_model, d_k)
        
        # 最终输出的线性层
        self.W_o = nn.Linear(d_k, d_model)

    def forward(self, x):
        # x shape: [batch_size, seq_len, d_model]
        
        # 1. 生成 Q, K, V
        Q = self.W_q(x)
        K = self.W_k(x)
        V = self.W_v(x)
        
        # 2. 计算注意力分数 (QK^T / sqrt(d_k))
        # transpose(-2, -1) 是把 K 的最后两个维度转置
        scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
        
        # 3. Softmax 归一化
        attention_weights = F.softmax(scores, dim=-1)
        
        # 4. 加权求和 (Score * V)
        output = torch.matmul(attention_weights, V)
        
        # 5. 输出
        return self.W_o(output)

# --- 测试代码 ---
if __name__ == "__main__":
    # 模拟输入: Batch=1, 句子长度=5, 每个词向量维度=512
    x = torch.randn(1, 5, 512)
    
    # 初始化 Self-Attention 层
    attention_layer = SelfAttention(d_model=512, d_k=64)
    
    output = attention_layer(x)
    print(f"输入形状: {x.shape}")
    print(f"输出形状: {output.shape}")
    # 输出形状应与输入保持一致，但内部已经融合了全局信息
    # 输入形状: torch.Size([1, 5, 512])
    # 输出形状: torch.Size([1, 5, 512])

可视化 AI 的“注意力”

光看公式太抽象，直接写代码，并画出注意力热力图。你会亲眼看到单词之间是如何“眉来眼去”的。

import torch
import torch.nn as nn
import torch.nn.functional as F
import math
import matplotlib.pyplot as plt
import seaborn as sns

class SelfAttention(nn.Module):
    def __init__(self, d_model, d_k):
        super().__init__()
        self.d_k = d_k
        self.W_q = nn.Linear(d_model, d_k)
        self.W_k = nn.Linear(d_model, d_k)
        self.W_v = nn.Linear(d_model, d_k)
        self.W_o = nn.Linear(d_k, d_model)

    def forward(self, x):
        # 1. 生成 Q, K, V
        Q = self.W_q(x)
        K = self.W_k(x)
        V = self.W_v(x)
        
        # 2. 计算注意力分数 (QK^T / sqrt(d_k))
        scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
        
        # 3. Softmax 归一化 -> 得到“注意力权重”
        # 这就是我们要可视化的核心！
        attention_weights = F.softmax(scores, dim=-1)
        
        # 4. 加权求和
        output = torch.matmul(attention_weights, V)
        return self.W_o(output), attention_weights

# --- 可视化实战 ---
if __name__ == "__main__":
    # 假设我们有一句话，包含4个单词
    sentence = ["I", "love", "AI", "technology"]
    
    # 模拟每个单词的词向量 (4个词, 维度64)
    x = torch.randn(1, 4, 64) 
    
    # 初始化模型
    attention_layer = SelfAttention(d_model=64, d_k=64)
    
    # 前向传播
    output, weights = attention_layer(x)
    
    # --- 画出热力图 ---
    # 移除 batch 维度，变成 (4, 4) 的矩阵
    attn_map = weights[0].detach().numpy()
    
    plt.figure(figsize=(6, 5))
    sns.heatmap(attn_map, annot=True, cmap='Reds',
                xticklabels=sentence, yticklabels=sentence)
    plt.title("Self-Attention Heatmap: Who is looking at whom?")
    plt.xlabel("Key (Source)")
    plt.ylabel("Query (Target)")
    plt.show()

🧐 图解：你会看到什么？

运行上述代码，你会得到一张红色的热力图（Heatmap）。

• 对角线：通常颜色最深。表示单词最关注自己（“I” 关注 “I”）。
• 非对角线：如果有颜色较深的块，比如 “AI” 这一行对应的 “technology” 这一列颜色很深，说明模型认为这两个词关系紧密。
• 这就是“理解”的物理形态。GPT 所谓的“读懂”，本质上就是在算这张图。

---

五、 家族图谱：Encoder 与 Decoder 的分道扬镳

Transformer 提出了 Encoder-Decoder（编码器-解码器） 结构，但后来的大模型们各取所需，分成了三派：

1. Encoder-only (BERT 家族)

• 特点：只用 Transformer 的左半边（编码器）。
• 能力：**“双向理解”**能力极强。能同时看到上下文。
• 用途：文本分类、情感分析、完形填空。
• 代表：BERT, RoBERTa。

2. Decoder-only (GPT 家族)

• 特点：只用 Transformer 的右半边（解码器）。
• 能力：“单向生成”。只能看到上文，猜下一个字。这是最符合人类说话逻辑的。
• 用途：文本生成、聊天机器人。
• 代表：GPT-3, GPT-4, Llama。

3. Encoder-Decoder (T5 家族)

• 特点：完整保留原版结构。
• 用途：翻译任务（读一段英文，生成一段中文）。
• 代表：T5, BART。

---

六、 结语：引擎已备，只欠燃料

今天，我们拆解了大模型的“心脏”——Transformer。

• 它抛弃了循环，拥抱了并行。
• 它通过 QKV 机制，让机器拥有了“理解上下文”的能力。
• 它演化出了 BERT 和 GPT 两大门派。

但是，光有一个精妙的架构（未训练的模型）只是一具空壳，它的参数是随机初始化的。

要想让它变聪明，必须给它喂海量的书本、网页、代码，让它进行预训练 (Pre-training)。

下一篇预告：

它是如何读完整个互联网的？为什么说“预训练”是通往通用的唯一路径？

《大模型训练范式：从预训练(Pre-training)到微调(SFT) —— ChatGPT 是如何炼成的？》

---

📚 建议阅读

• 论文：Attention Is All You Need (2017) —— 必读神作。
• 博客：The Illustrated Transformer (Jay Alammar) —— 全网最通俗的图解。