从零理解Transformer：让大模型听懂人话的技术底层

1
2
3
4
5

→ Transformer到底是什么
→ 它为什么比之前的模型（RNN/LSTM）强这么多
→ Self-Attention（自注意力）到底在"注意"什么
→ 大语言模型（LLM）是怎么用Transformer构建出来的
→ GPT、BERT、Claude之间的技术区别是什么

1
2
3
4
5

"我  今   天   去   北   京   游   玩"

 ↑
 从左到右，一个词一个词地处理
 某个词的含义，取决于前面所有词

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

RNN的问题1：无法并行
  → 第5个词的计算依赖第4个词的计算结果
  → 第4个词的计算依赖第3个词……
  → 必须一个一个来，GPU的并行能力完全发挥不出来

RNN的问题2：长距离依赖困难
  → 句子开头和结尾的词，如果有关联，RNN很难捕捉到
  → "今天天气很冷，我穿了很多衣服，但妈妈说还要再加一件"
  → "妈妈说"和开头"今天天气很冷"有关联，但距离太远，RNN记不住

RNN的问题3：梯度消失/爆炸
  → 序列太长时，反向传播过程中梯度要么变成0，要么变成无穷大
  → 训练不稳定

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

RNN的处理方式（串行）：
  词1 → 词2 → 词3 → 词4 → 词5 → ...
         ↓
  处理词3时，只能看到词1和词2

Transformer的处理方式（并行）：
  词1
  词2   → 同时处理所有词 → 每个词都能"看到"整个句子
  词3   → 哪个词重要，就多"注意"哪个
  词4
  词5

1
2
3

"苹果" → [0.23, -0.45, 0.87, 0.12, -0.33, ...] （假设512维向量）
"香蕉" → [0.18, -0.52, 0.76, 0.09, -0.28, ...]
"电脑" → [-0.11, 0.67, -0.23, 0.55, 0.41, ...]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

词向量的空间分布（简化示意）：

       水果类
     苹果 🍎
   香蕉 🍌    电脑 💻
              手机 📱
       科技类

"苹果"和"香蕉"在向量空间里距离很近（都是水果）
"电脑"和"手机"距离很近（都是科技）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

Transformer输入处理流程：

原始句子："今天天气很好"

    ↓ Tokenize（分词）
    ↓
["今", "天", "天", "气", "很", "好"]

    ↓ Embedding（词向量嵌入）
    ↓
[
  [0.23, -0.45, 0.87, ...],  # 今 → 512维向量
  [-0.11, 0.67, -0.23, ...],  # 天 → 512维向量
  [-0.11, 0.67, -0.23, ...],  # 天（同一个词，同一个向量）
  [0.55, 0.12, -0.78, ...],   # 气 → 512维向量
  [0.89, -0.34, 0.12, ...],   # 很 → 512维向量
  [0.34, 0.78, -0.45, ...],   # 好 → 512维向量
]
    ↓
6个512维的向量 → 送入Transformer Encoder/Decoder

1
2
3

"狗咬人" vs "人咬狗"
→ 词完全一样，顺序不同，意思相反
→ 如果不告诉机器词的位置，它无法区分这两个句子

1
2
3
4
5
6

第0个位置：PE = [sin(0), cos(0), sin(0), cos(0), ...]
第1个位置：PE = [sin(1), cos(1), sin(1/10000), cos(1/10000), ...]
第2个位置：PE = [sin(2), cos(2), sin(2/10000), cos(2/10000), ...]

每个位置的PE都是不同的！
而且PE是一个和词向量维度相同的向量，可以直接相加。

1
2
3
4
5

优点1：任意两个位置的PE可以"相加"得到中间位置的大致PE
  → 模型可以推断任意位置的相对位置关系
  → PE(pos+1) ≈ PE(pos) + 变化量

优点2：PE的值域在[-1, 1]，不会干扰词向量的数值范围

1
2
3
4
5

最终输入 = 词向量 + 位置编码

Embedding(词向量)    [0.23, -0.45, 0.87, ...]  ← 词的语义
+  Position(位置)    [0.13,  0.87, 0.15, ...]  ← 词的位置
=  Input Vector      [0.36,  0.42, 1.02, ...]  ← 语义 + 位置 = 最终输入

1
2
3

Query（查询）："我在找什么" → 我这个词，想去"匹配"句子里的哪些词
Key（键）："我是什么"      → 代表每个词的"身份"，用来被Query匹配
Value（值）："如果匹配上了，我贡献多少信息" → 实际要读取的信息

1
2
3
4
5
6

Q = X · W_Q   （Query矩阵）
K = X · W_K   （Key矩阵）
V = X · W_V   （Value矩阵）

X = [x1, x2, x3, ...]  所有词的输入向量堆叠在一起
W_Q, W_K, W_V = 可学习的权重矩阵（模型训练出来的）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

以"我 爱 学 习"为例（简化版，假设向量维度=4）：

词"我"的Query:   Q_我 = [1.0, 0.5, 0.2, 0.1]
词"爱"的Key:     K_爱 = [0.9, 0.3, 0.1, 0.2]
词"学"的Key:     K_学 = [0.1, 0.8, 0.6, 0.3]
词"习"的Key:     K_习 = [0.2, 0.7, 0.5, 0.4]

相似度计算（点积）：

Score_我→爱 = Q_我 · K_爱 = 1.0×0.9 + 0.5×0.3 + 0.2×0.1 + 0.1×0.2 = 1.05
Score_我→学 = Q_我 · K_学 = 1.0×0.1 + 0.5×0.8 + 0.2×0.6 + 0.1×0.3 = 0.71
Score_我→习 = Q_我 · K_习 = 1.0×0.2 + 0.5×0.7 + 0.2×0.5 + 0.1×0.4 = 0.75

→ "我"和"爱"的相似度最高（1.05），"我"和"学习"次之
→ 说明"我"在找"爱"这个词

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

d_k = 向量维度 = 4
缩放：Score = Score / √d_k = Score / 2

Scaled_我→爱 = 1.05 / 2 = 0.525
Scaled_我→学 = 0.71 / 2 = 0.355
Scaled_我→习 = 0.75 / 2 = 0.375

Softmax归一化（所有值变成概率，和为1）：

exp(0.525) / [exp(0.525) + exp(0.355) + exp(0.375)] = 0.397
exp(0.355) / [exp(0.525) + exp(0.355) + exp(0.375)] = 0.303
exp(0.375) / [exp(0.525) + exp(0.355) + exp(0.375)] = 0.300

→ "我"对"爱"的注意力权重：39.7%
→ "我"对"学"的注意力权重：30.3%
→ "我"对"习"的注意力权重：30.0%

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

注意力权重：["爱": 0.397, "学": 0.303, "习": 0.300]

V_爱 = [0.5, 0.2, 0.8, 0.1]   ← "爱"的Value向量
V_学 = [0.3, 0.6, 0.4, 0.9]   ← "学"的Value向量
V_习 = [0.4, 0.5, 0.3, 0.7]   ← "习"的Value向量

"我"的输出 = 0.397 × V_爱 + 0.303 × V_学 + 0.300 × V_习

= [0.397×0.5 + 0.303×0.3 + 0.300×0.4,
   0.397×0.2 + 0.303×0.6 + 0.300×0.5,
   0.397×0.8 + 0.303×0.4 + 0.300×0.3,
   0.397×0.1 + 0.303×0.9 + 0.300×0.7]

= [0.1985 + 0.0909 + 0.1200,
   0.0794 + 0.1818 + 0.1500,
   0.3176 + 0.1212 + 0.0900,
   0.0397 + 0.2727 + 0.2100]

= [0.409, 0.411, 0.529, 0.522]

1
2
3
4

QK^T            → 第一步：计算所有Query和Key的相似度矩阵
/ √d_k          → 第二步：缩放，防止梯度消失
softmax(...)    → 第三步：归一化，变成概率分布
× V             → 第四步：用概率对Value加权求和

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

Self-Attention在做的事情：

→ 给句子里的每个词，发一张"调查问卷"
→ "你是谁？你和其他词有什么关系？"
→ 每个词给出自己的Query（我在找什么）、Key（我是什么）、Value（我携带什么信息）
→ 通过Query和Key的匹配，找出谁和谁关系近
→ 用匹配结果（注意力权重）对Value加权
→ 每个词的输出 = 融合了"所有词的信息"，融合比例由"关系远近"决定

"我 爱 学 习"这句话里：
→ "我"的输出，重点融合了"爱"的信息（因为"我"在找"爱"）
→ "学"的输出，重点融合了"习"的信息（因为"学习"是一个整体）
→ 每个词都在"看"整个句子，而不是只看到前面的词

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

"苹果 是 一 家 好 公司"

"苹果"这个词，在这个句子里有多种关系：

关系1（语义关系）：
  "苹果"和"公司"关系近 → 说的是Apple Inc.

关系2（主语谓语关系）：
  "苹果"和"是"关系近 → "苹果"是主语

关系3（情感关系）：
  "苹果"和"好"关系近 → 正面评价

关系4（语境关系）：
  整个句子的语境都在暗示"苹果"=公司

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

Multi-Head Attention的结构：

输入X
    ↓
分成h个头（假设h=8，即8组Q/K/V）
    ↓
每组独立计算Self-Attention
    ↓
8个输出向量拼接（Concat）
    ↓
乘以一个输出权重矩阵 W_O
    ↓
最终输出

每组Q/K/V是通过不同的 W_Q_i, W_K_i, W_V_i 得到的
这些权重矩阵都是可学习的

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

单头Attention：一个人从窗户看世界，只看到一个角度
多头Attention：八个人从八个窗户同时看世界，信息更全面

比如看一张人脸：
  头1：看眼睛的大小和形状
  头2：看鼻子的高低
  头3：看嘴巴的形状
  头4：看整体轮廓
  ……
  八个头的结论拼起来 = 对这张脸的完整理解

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

Transformer（完整版）：Encoder + Decoder
  → 用于：机器翻译（先理解源语言，再生成目标语言）
  → 论文原图就是这种结构

Encoder-Only（仅编码器）：
  → 用于：文本分类、情感分析、文本理解
  → BERT就是这个架构

Decoder-Only（仅解码器）：
  → 用于：文本生成（从左到右，一个词一个词预测）
  → GPT系列就是这种架构

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

Encoder层：
  ├── 子层1：Multi-Head Self-Attention
  │   → 每个词看整个句子，理解词与词的关系
  │   ↓
  │   + Add & Layer Norm（残差连接 + 层归一化）
  │
  └── 子层2：Feed-Forward Network（前馈网络）
      → 对每个词独立做一个非线性变换
      → 全连接层 + ReLU/GELU激活函数
      ↓
      + Add & Layer Norm

多个Encoder层堆叠（Transformer原论文：N=6层）

1
2
3

输出 = Sublayer(输入) + 输入
  → 梯度可以顺畅地传回去
  → 训练深层网络成为可能

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

Decoder层：
  ├── 子层1：Masked Multi-Head Self-Attention
  │   → "掩码"未来信息，确保只能看到前面的词
  │   ↓
  │   + Add & Layer Norm
  │
  ├── 子层2：Multi-Head Cross-Attention（交叉注意力）
  │   → Decoder的Query 和 Encoder的 Key/Value 做Attention
  │   → 理解源语言和目标语言的对应关系
  │   ↓
  │   + Add & Layer Norm
  │
  └── 子层3：Feed-Forward Network
      ↓
      + Add & Layer Norm

多个Decoder层堆叠（N=6层）

1
2
3
4
5
6
7

Masked Attention示意（预测第4个词时）：

可以看到的词：  ✓ ✓ ✓ ✓ ✗ ✗ ✗ ✗
                 1   2   3   4   5   6   7   8

→ 不能作弊（不能提前看到答案）
→ 这就是为什么Decoder是"自回归"生成（Auto-regressive）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

输入："我 爱 学 习"（中文翻译成英文）

Encoder部分：
  Input Embedding + Positional Encoding
    ↓
  ×6层 Encoder
    ↓
  Encoder Output（编码了"我 爱 学 习"的所有信息）

Decoder部分：
  Output Embedding + Positional Encoding（已经翻译的部分）
    ↓
  Masked Self-Attention（只看已经翻译的词）
    ↓
  Cross-Attention（参考Encoder的输出）
    ↓
  ×6层 Decoder
    ↓
  Linear + Softmax → 下一个词的概率分布

逐步生成：
  → 生成第1个词："I"
  → 生成第2个词："love"
  → 生成第3个词："learning"
  → 生成第4个词：<EOS>（句子结束符）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

GPT的工作方式（自回归生成）：

用户输入："今天天气很好，"
  ↓
模型逐词预测下一个词：
  → "适合" ← 概率最高的词
  → "适合" + "出门" ← 继续预测
  → "适合出门" + "散步" ← 继续预测
  → …… ← 直到遇到< EOS >（句子结束符）

本质上：给定前文，预测下一个词的概率分布

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

第一阶段：预训练（Pre-training）
  → 在海量互联网文本上做"语言模型"训练
  → 目标：给定前N-1个词，预测第N个词
  → 学习语言规律、世界知识、推理能力
  → GPT-3在约3000亿个词上训练

第二阶段：微调（Fine-tuning）
  → 在特定任务的数据上微调（问答、对话、代码等）
  → SFT（监督微调）：用人工标注的问答对训练
  → RLHF（人类反馈强化学习）：
      → 让模型生成多个回答
      → 人工排序哪个回答更好
      → 用排序结果训练Reward模型
      → 用Reward模型优化生成策略
  → ChatGPT就是用了RLHF

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

BERT vs GPT 的核心区别：

BERT（理解）：
  → "我 爱 学 习" → 同时看全部5个词
  → 适合：文本分类、情感分析、实体识别、问答理解

GPT（生成）：
  → "我 爱 学" → 只能看"我 爱 学"，预测"习"
  → 适合：文本生成、对话、代码补全

BERT的创新点：MLM（Masked Language Model，掩码语言模型）
  → 随机遮住15%的词
  → 让模型根据上下文预测被遮住的词
  → 这样每个词都能"看到"左右两边的上下文

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

GPT-1（2018）：1.17亿参数，12层，BooksCorpus数据集
GPT-2（2019）：15亿参数，48层，Reddit链接网页
GPT-3（2020）：1750亿参数，96层，3000亿Token
  → 涌现能力（Emergent Abilities）开始出现
  → 突然能做一些训练时没有专门教过的任务
GPT-3.5（2022）：在GPT-3基础上加入RLHF
  → ChatGPT的基础
GPT-4（2023）：参数规模未公开（估计万亿级）
  → 多模态（接受图像输入）
  → 更强的推理能力
  → 更长的上下文窗口（128K Token）
GPT-4o / Claude 3.5 / Gemini 2.0（2024-2025）
  → 原生多模态
  → 实时语音和视频理解
  → 更强的Agent能力

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

Scaling Law的发现：

当模型的参数量、数据量、计算量增加时，
模型的能力会系统性地提升。

具体规律：
  → 参数量翻倍 → 性能大致线性提升
  → 数据量翻倍 → 性能大致线性提升
  → 计算量（参数量×数据量）翻倍 → 性能可预测地提升

这意味着：只要不断增大模型，就能不断提升能力。
这就是为什么大模型公司都在"烧钱"拼规模。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

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

class SelfAttention(nn.Module):
    """简化的Self-Attention实现"""

    def __init__(self, d_model, n_heads):
        super().__init__()
        self.d_model = d_model    # 词向量维度（如512）
        self.n_heads = n_heads    # 注意力头数（如8）
        self.d_k = d_model // n_heads  # 每个头的维度

        # Q/K/V的投影矩阵（可学习参数）
        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, X, mask=None):
        """
        X: [batch_size, seq_len, d_model]
        mask: [batch_size, seq_len, seq_len]  # 可选，用于遮住未来信息
        """

        batch_size, seq_len, _ = X.shape

        # 1. 线性变换得到Q, K, V
        Q = self.W_Q(X)  # [batch, seq_len, d_model]
        K = self.W_K(X)
        V = self.W_V(X)

        # 2. 分成多个头（把最后一个维度分成n_heads份）
        Q = Q.view(batch_size, seq_len, self.n_heads, self.d_k).transpose(1, 2)
        K = K.view(batch_size, seq_len, self.n_heads, self.d_k).transpose(1, 2)
        V = V.view(batch_size, seq_len, self.n_heads, self.d_k).transpose(1, 2)

        # 3. 计算注意力分数：Q · K^T / sqrt(d_k)
        scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
        # scores: [batch, n_heads, seq_len, seq_len]

        # 4. 应用掩码（Decoder时遮住未来信息）
        if mask is not None:
            scores = scores.masked_fill(mask == 0, -1e9)

        # 5. Softmax归一化
        attn_weights = F.softmax(scores, dim=-1)  # 每行和为1

        # 6. 加权求和：attn_weights · V
        context = torch.matmul(attn_weights, V)
        # context: [batch, n_heads, seq_len, d_k]

        # 7. 拼接多头
        context = context.transpose(1, 2).contiguous()
        context = context.view(batch_size, seq_len, self.d_model)

        # 8. 输出投影
        output = self.W_O(context)

        return output, attn_weights


# 使用示例
batch_size = 2
seq_len = 10
d_model = 512
n_heads = 8

attention = SelfAttention(d_model, n_heads)
X = torch.randn(batch_size, seq_len, d_model)
output, weights = attention(X)

print(f"输入形状: {X.shape}")
print(f"输出形状: {output.shape}")
print(f"注意力权重形状: {weights.shape}")
# 注意力权重矩阵：[batch, n_heads, seq_len, seq_len]
# 权重[i][j] = 第i个词对第j个词的注意力分数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

class TransformerBlock(nn.Module):
    """一个完整的Transformer Encoder块"""

    def __init__(self, d_model, n_heads, d_ff, dropout=0.1):
        super().__init__()

        # 子层1：Multi-Head Self-Attention
        self.attention = SelfAttention(d_model, n_heads)
        self.norm1 = nn.LayerNorm(d_model)

        # 子层2：前馈网络
        self.ff = nn.Sequential(
            nn.Linear(d_model, d_ff),   # 扩张维度（512 → 2048）
            nn.GELU(),                  # GPT-3之后常用GELU替代ReLU
            nn.Dropout(dropout),
            nn.Linear(d_ff, d_model),  # 收缩回原维度
            nn.Dropout(dropout)
        )
        self.norm2 = nn.LayerNorm(d_model)

        self.dropout = nn.Dropout(dropout)

    def forward(self, X, mask=None):
        # Self-Attention + 残差连接 + LayerNorm
        attn_output, _ = self.attention(X, mask)
        X = self.norm1(X + self.dropout(attn_output))

        # Feed-Forward + 残差连接 + LayerNorm
        ff_output = self.ff(X)
        X = self.norm2(X + self.dropout(ff_output))

        return X


# 一个Transformer Encoder由多个Block堆叠而成
class TransformerEncoder(nn.Module):
    def __init__(self, n_layers, d_model, n_heads, d_ff, dropout=0.1):
        super().__init__()
        self.layers = nn.ModuleList([
            TransformerBlock(d_model, n_heads, d_ff, dropout)
            for _ in range(n_layers)
        ])

    def forward(self, X, mask=None):
        for layer in self.layers:
            X = layer(X, mask)
        return X

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

第一步：SFT（监督微调）
  → 收集人类写的"好答案"数据集
  → 用这些数据微调GPT
  → 模型学会了"什么样的回答是好的"

第二步：训练Reward模型
  → 让模型对同一个问题生成多个回答
  → 人工给这些回答排序（哪个更好）
  → 用排序数据训练一个Reward模型
  → Reward模型学会了"给回答打分"

第三步：PPO强化学习
  → 用Reward模型评估模型生成的回答
  → 用PPO算法更新GPT的参数
  → 目标是：生成更高Reward分数的回答
  → 反复迭代，越生成越好

1
2
3
4
5
6
7
8

没有RLHF的模型：
  → 目标是"预测下一个词"
  → 不关心回答是否有帮助、是否安全、是否真实

有RLHF的模型：
  → 目标变成了"最大化人类偏好"
  → 模型学会了隐式地"讨好"人类
  → 回答更有帮助、更安全、更符合对话习惯

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

局限1：计算复杂度随序列长度平方增长
  → Attention的计算量 = O(n² × d)
  → 序列越长，计算量增长越快
  → 10000个词的序列，计算量是1000个词的100倍

局限2：上下文窗口有限
  → 虽然现在有128K甚至1M的上下文
  → 但本质上还是有限的长度
  → 超出窗口的信息难以利用

局限3：幻觉问题
  → 模型会自信地生成错误信息
  → 本质上是"下一个词预测"的统计特性
  → RAG（检索增强生成）是当前主流的缓解方案

局限4：推理成本高
  → 1750亿参数的模型，推理一次耗电量惊人
  → 延迟是实际应用的瓶颈

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

状态空间模型（SSM）：
  → Mamba（2023）：选择性状态空间模型
  → 处理长序列时计算量是O(n)，而不是O(n²)
  → 在某些任务上接近Transformer性能
  → 但在复杂推理任务上仍不如Transformer

混合架构：
  → Hybrid Mamba-Transformer
  → 结合SSM的效率和Attention的能力
  → 一些大模型开始尝试这种架构

1
2
3
4
5
6
7
8
9

传统方法：
  → 图像 → CLIP编码 → 文本Token空间 → LLM处理
  → 多模态是"嫁接"上去的

原生多模态（如GPT-4o、Gemini 2.0）：
  → 图像、视频、音频、文本共用同一个Transformer处理
  → 音频直接转Token，不需要中间层
  → 端到端训练，所有模态一起优化
  → 延迟更低，理解更准确

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

Transformer解决的问题：

RNN的问题：
  ✗ 串行处理，无法并行
  ✗ 长距离依赖困难
  ✗ 梯度消失/爆炸

Transformer的解法：
  ✓ 完全并行处理
  ✓ 每个词都能直接"看到"所有其他词
  ✓ 通过残差连接和LayerNorm，训练深层网络成为可能

Transformer的核心组件：

1. Embedding：词 → 数字（让机器认识词）
2. 位置编码：位置信息 → 数字（让机器知道词的顺序）
3. Self-Attention：词 → 上下文感知（让每个词"看"整个句子）
4. Multi-Head：多角度理解（从不同维度理解词的关系）
5. Feed-Forward：非线性变换（增加表达能力）
6. Add & Norm：残差+归一化（让深层训练稳定）

从Transformer到大模型：

Transformer Base
    ↓ + 堆叠层数
Deep Transformer
    ↓ + 巨大规模（百亿/万亿参数）
LLM（大语言模型）
    ↓ + 海量数据预训练
Pre-trained LLM
    ↓ + SFT（监督微调）
Chat Model（ChatGPT类）
    ↓ + RLHF（人类反馈强化学习）
对齐人类偏好的助手模型（Claude/GPT-4）
    ↓ + Agent能力 + 多模态
现代AI助手（Claude/GPT-4o/Gemini）