LLM 基础原理详解
更新: 5/15/2026 字数: 0 字 时长: 0 分钟
1. Transformer 架构
1.1 为什么 Transformer 能成功
在 Transformer 之前，处理序列数据（文本、代码）主要用 RNN/LSTM：
RNN 的问题：
输入: "用户 点击 按钮 触发 网络 请求"
处理: 用户 → 点击 → 按钮 → 触发 → 网络 → 请求
↑ 串行处理，一个一个来
→ 慢（不能并行）
→ 长距离依赖丢失（处理"请求"时已经忘了"用户"）
Transformer 的方式：
输入: "用户 点击 按钮 触发 网络 请求"
处理: 所有词同时处理，每个词都能直接看到其他所有词
→ 快（完全并行）
→ 长距离依赖保留（"请求"能直接关注到"用户"）1.2 核心组件
Transformer 的结构（以 GPT 类模型为例，只用 Decoder）：
输入 Token 序列
↓
Token Embedding（把 Token 变成向量）+ Position Embedding（加上位置信息）
↓
┌─────────────────────────────────┐
│ Transformer Block × N 层 │ ← GPT-3 有 96 层，GPT-4 更多
│ │
│ ┌───────────────────────────┐ │
│ │ Masked Self-Attention │ │ ← 核心：每个 Token 关注其他 Token
│ └───────────────────────────┘ │
│ ↓ │
│ ┌───────────────────────────┐ │
│ │ Feed-Forward Network │ │ ← 两层全连接网络
│ └───────────────────────────┘ │
│ ↓ │
│ （每层都有 Layer Norm + 残差连接）│
└─────────────────────────────────┘
↓
Linear + Softmax
↓
输出：下一个 Token 的概率分布1.3 Self-Attention（自注意力）
这是 Transformer 最核心的机制。直觉理解：
句子："The cat sat on the mat because it was tired"
当模型处理 "it" 这个词时，需要知道 "it" 指的是什么
Self-Attention 让 "it" 去关注句子中的每个词，计算相关度：
"it" 关注 "cat" → 相关度 0.7（高！it 指的是 cat）
"it" 关注 "mat" → 相关度 0.1（低）
"it" 关注 "sat" → 相关度 0.05（低）
"it" 关注 "tired" → 相关度 0.1
...
通过这种方式，"it" 的表示中融入了 "cat" 的信息
模型就理解了 "it = cat"数学上的实现：
每个 Token 生成三个向量：
Q（Query）：我在找什么？
K（Key）：我能提供什么？
V（Value）：我的实际内容
计算过程：
1. 每个 Token 的 Q 和所有 Token 的 K 做点积 → 得到注意力分数
2. 分数除以 √d（缩放）→ Softmax 归一化 → 得到注意力权重
3. 用权重对所有 Token 的 V 加权求和 → 得到输出
公式：Attention(Q, K, V) = softmax(QK^T / √d) × V具体例子（简化为 2 维向量）：
Token: "cat" "sat" "it"
Q: [1, 0] [0, 1] [1, 0.5]
K: [1, 0] [0, 1] [0.5, 0.5]
V: [0.8, 0.2] [0.1, 0.9] [0.5, 0.5]
计算 "it" 对其他 Token 的注意力：
"it" 的 Q = [1, 0.5]
Q · K_cat = [1,0.5] · [1,0] = 1.0 ← 高分，it 关注 cat
Q · K_sat = [1,0.5] · [0,1] = 0.5 ← 中等
Q · K_it = [1,0.5] · [0.5,0.5] = 0.75
Softmax([1.0, 0.5, 0.75]) = [0.42, 0.24, 0.34]
"it" 的输出 = 0.42 × V_cat + 0.24 × V_sat + 0.34 × V_it
= 0.42 × [0.8,0.2] + 0.24 × [0.1,0.9] + 0.34 × [0.5,0.5]
= [0.53, 0.47]
→ "it" 的表示融合了 cat 的信息（权重最高）1.4 Multi-Head Attention（多头注意力）
一个注意力头只能关注一种关系。多头注意力让模型同时关注多种关系：
Head 1：关注语法关系（"it" → "cat"，代词指代）
Head 2：关注位置关系（"it" → "was"，相邻词）
Head 3：关注语义关系（"tired" → "cat"，谁累了）
...
每个 Head 独立计算 Attention，最后拼接起来：
MultiHead = Concat(Head1, Head2, ..., HeadN) × W_O
GPT-3 有 96 个 Head，能同时捕捉 96 种不同的关系1.5 Masked Self-Attention（因果注意力）
GPT 类模型生成文本时，只能看到前面的 Token，不能看到后面的：
生成 "The cat sat on" 时：
"The" 只能看到: [The]
"cat" 只能看到: [The, cat]
"sat" 只能看到: [The, cat, sat]
"on" 只能看到: [The, cat, sat, on]
通过 Mask 矩阵实现：
The cat sat on
The [ 1 0 0 0 ] ← The 只看自己
cat [ 1 1 0 0 ] ← cat 看 The 和自己
sat [ 1 1 1 0 ] ← sat 看前三个
on [ 1 1 1 1 ] ← on 看所有前面的
0 的位置在 Softmax 前设为 -∞，Softmax 后变成 0（完全不关注）1.6 Position Embedding（位置编码）
Self-Attention 本身不知道词的顺序（"cat sat" 和 "sat cat" 对它来说一样），需要额外加上位置信息：
Token Embedding: "cat" → [0.8, 0.2, 0.5, ...]
Position Embedding: pos=2 → [0.1, -0.3, 0.2, ...]
最终输入: [0.9, -0.1, 0.7, ...] ← 相加
现代模型（如 LLaMA）用 RoPE（旋转位置编码）：
不是加法，而是对 Q 和 K 做旋转变换
优点：能更好地表示相对位置，支持外推到更长的序列2. Token 与分词
2.1 什么是 Token
模型不直接处理文字，而是处理 Token（子词片段）：
英文分词（BPE 算法）：
"unhappiness" → ["un", "happiness"] ← 2 个 Token
"Hello world" → ["Hello", " world"] ← 2 个 Token
"ChatGPT" → ["Chat", "G", "PT"] ← 3 个 Token
中文分词：
"你好世界" → ["你", "好", "世", "界"] ← 4 个 Token（每个字一个）
"人工智能" → ["人工", "智能"] ← 2 个 Token（常见词合并）
代码分词：
"System.out.println" → ["System", ".", "out", ".", "print", "ln"] ← 6 个 Token
"getUserById" → ["get", "User", "By", "Id"] ← 4 个 Token2.2 BPE（Byte Pair Encoding）分词算法
训练过程（在大量文本上统计）：
1. 初始词表：所有单个字符 [a, b, c, ..., z, A, B, ..., 空格, 换行, ...]
2. 统计相邻字符对的频率：
"th" 出现 10000 次 → 合并为 "th"，加入词表
"he" 出现 8000 次 → 合并为 "he"，加入词表
"the" 出现 7000 次 → 合并为 "the"，加入词表
...
3. 重复直到词表达到目标大小（如 50000）
结果：高频词是一个 Token，低频词被拆成多个 Token
"the"（超高频）→ 1 个 Token
"Transformer"（中频）→ 2-3 个 Token
"xyzzy"（罕见）→ 5 个 Token（逐字符）2.3 Context Window（上下文窗口）
模型一次能处理的最大 Token 数：
GPT-3.5: 4K / 16K Token
GPT-4: 8K / 32K / 128K Token
Claude 3.5: 200K Token
Claude 4: 200K Token
1K Token ≈ 750 个英文单词 ≈ 500 个中文字
Context Window 的限制：
输入 + 输出 的总 Token 数不能超过窗口大小
超过了就需要截断或压缩
为什么有限制：
Self-Attention 的计算量 = O(n²)，n 是序列长度
128K Token 的注意力矩阵 = 128K × 128K = 160 亿个元素
需要大量 GPU 显存3. 训练三阶段
3.1 预训练（Pre-training）
目标：学习语言的通用知识
数据：互联网上的海量文本（万亿 Token）
方法：预测下一个 Token（自回归）
训练过程：
输入: "The capital of France is"
目标: "Paris"
损失: 模型预测的概率分布 vs 真实的下一个 Token
输入: "public static void main(String[]"
目标: "args"
重复几万亿次...
结果：模型学会了语法、常识、代码模式、推理能力等
但它只是一个"补全机器"，不会对话预训练的规模：
GPT-3: 175B 参数，300B Token，数千张 GPU 训练数月
LLaMA 3: 405B 参数，15T Token
训练成本：数千万到上亿美元3.2 监督微调（SFT - Supervised Fine-Tuning）
目标：让模型学会对话格式
数据：人工标注的对话数据（几万到几十万条）
训练数据示例：
User: "解释一下 Android 的 Handler 机制"
Assistant: "Handler 是 Android 的消息传递机制..."
User: "写一个单例模式"
Assistant: "```kotlin\nobject Singleton { ... }\n```"
结果：模型从"补全机器"变成了"对话助手"
知道什么时候该回答、什么格式回答3.3 RLHF（Reinforcement Learning from Human Feedback）
目标：让模型的回答更符合人类偏好
方法：
1. 收集人类偏好数据：
给同一个问题生成多个回答，人类标注哪个更好
问题: "什么是协程？"
回答 A: "协程是一种轻量级线程..." ← 人类标注：好
回答 B: "协程就是 coroutine..." ← 人类标注：差
2. 训练奖励模型（Reward Model）：
学习人类的偏好标准
输入一个回答 → 输出一个分数（越高越好）
3. 用 PPO 算法优化 LLM：
LLM 生成回答 → 奖励模型打分 → 调整 LLM 参数使得高分回答更可能被生成
结果：模型回答更有帮助、更安全、更符合人类期望4. 推理过程（Inference）
4.1 自回归生成
LLM 生成文本是一个 Token 一个 Token 地生成：
输入: "写一个 Android 的"
↓
第 1 步: 模型计算 → 概率最高的下一个 Token 是 "单"
当前序列: "写一个 Android 的单"
↓
第 2 步: 模型计算 → 概率最高的下一个 Token 是 "例"
当前序列: "写一个 Android 的单例"
↓
第 3 步: 模型计算 → "模"
当前序列: "写一个 Android 的单例模"
↓
第 4 步: "式"
...
↓
第 N 步: 生成 <EOS>（结束标记）→ 停止
每一步都要把整个序列重新过一遍 Transformer
所以生成越长的文本越慢4.2 采样策略
模型每一步输出的是概率分布，怎么从中选一个 Token：
模型输出（下一个 Token 的概率）：
"模" → 0.35
"例" → 0.25
"类" → 0.15
"方" → 0.10
"的" → 0.05
...
Greedy（贪心）：永远选概率最高的 → "模"
确定性输出，但可能单调重复
Temperature（温度）：
T < 1.0：概率分布更尖锐（更确定，更保守）
"模" → 0.60, "例" → 0.25, "类" → 0.10, ...
T > 1.0：概率分布更平坦（更随机，更有创意）
"模" → 0.25, "例" → 0.22, "类" → 0.18, ...
T = 0：等于 Greedy
Top-p（核采样）：
只从累积概率达到 p 的 Token 中采样
p = 0.9：从 "模"(0.35) + "例"(0.25) + "类"(0.15) + "方"(0.10) + "的"(0.05) = 0.90 中随机选
排除了概率极低的 Token，避免生成离谱的内容
Top-k：
只从概率最高的 k 个 Token 中采样
k = 5：从前 5 个 Token 中随机选4.3 KV Cache
每生成一个新 Token，都要重新计算所有之前 Token 的注意力。KV Cache 缓存之前的计算结果：
没有 KV Cache：
生成第 100 个 Token 时，重新计算前 99 个 Token 的 K 和 V
→ O(n²) 计算量
有 KV Cache：
前 99 个 Token 的 K 和 V 已经缓存了
只需要计算第 100 个 Token 的 Q，和缓存的 K、V 做注意力
→ O(n) 计算量
代价：需要大量 GPU 显存存储缓存
每层每个 Token 缓存 K 和 V 两个向量
GPT-3（96 层，12288 维）：每个 Token 的 KV Cache ≈ 4.7MB
128K 上下文 ≈ 600GB KV Cache（需要多张 GPU）5. 模型参数与规模
"175B 参数"是什么意思：
Transformer 中的参数 = 所有权重矩阵中的数字
Attention 的 Q/K/V 投影矩阵
Feed-Forward 的两层全连接矩阵
Embedding 矩阵
Layer Norm 的参数
175B = 1750 亿个浮点数
FP16 存储：175B × 2 字节 = 350GB
需要多张 80GB 的 A100 GPU 才能加载
模型越大：
能力越强（涌现能力：推理、代码、数学）
推理越慢（更多计算）
成本越高（更多 GPU）
常见模型规模：
7B（LLaMA 7B）：单张消费级 GPU 可运行
13B：单张 A100 可运行
70B：需要多张 GPU
175B+：需要 GPU 集群