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

关注

原创最新推荐文章于 2026-03-11 02:35:48 发布 1.2k 阅读 AI 写同款· GEO 优化 ›

大模型核心技术原理: Transformer架构详解四是，通用语言模型，如 GLM，该模型结合了自回归和自编码两种形式的模型，举个例子，“123456”是一串输入的序列，现在把 “3”、“5”、“6” 挖空，让模型去学习，那么，挖空以后换成一个 “ mask token” 告诉模型这个地方遮掉了一些内容，现在需要去预测出来遮掉的内容。一是，自编码模型，如 BERT，简单讲就是给到一句话，然后把这句话的内容挖空，当问及挖空的内容时，就把内容填回去，这其实是典型地用来做一个自然语言理解的任务，但做生成任务是非常弱的；本文由博客一文多发平台。阅读详情

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 的两大死穴：

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

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

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

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

Transformer 的心脏，就是 Self-Attention。

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

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

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

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

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

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

过程就像一场配对舞会：

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

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

$\text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V$

$QK^T$ ：计算相似度（注意力分数）。
$dk\sqrt{d_k}$ ：缩放因子，防止分数太大导致梯度消失。
$softmax\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()