第15章 LLM工作原理：大模型到底是怎么“思考“的
第15章 LLM工作原理：大模型到底是怎么"思考"的
一句话点题： 大模型的本质就是"接龙"——根据前面的文字猜下一个字。但这简单到不可思议的机制，在千亿参数规模下，产生了令人震惊的智能涌现。
15.1 先说结论：大模型在干什么
用一句话概括所有大模型（GPT、Qwen、LLaMA、Claude）的工作原理：
给一段文字的前半部分，预测下一个最可能出现的词。
就这样。没有数据库查询，没有知识检索，没有推理引擎。就是猜下一个词。
你跟 ChatGPT 聊天，它每次只生成一个 Token（大约半个词），生成完再加到前面，继续猜下一个——如此循环，直到结束。
你问: "中国的首都是哪里？"
模型内部过程:
输入: "中国的首都" → 预测下一个词: "是"
输入: "中国的首都是" → 预测下一个词: "北"
输入: "中国的首都是北" → 预测下一个词: "京"
输入: "中国的首都是北京" → 预测下一个词: "<结束>"
这叫 Next Token Prediction（下一词预测），也叫自回归生成（Autoregressive Generation）。
听起来简单到幼稚，但当模型参数达到千亿级别，训练数据达到万亿 Token 时，这个"接龙"游戏产生了质变——模型开始能写代码、做数学题、理解指令、甚至展现出推理能力。
这章就是要把这个过程掰开揉碎讲清楚。
15.2 第一步：Tokenization——把文字切成块
大模型不直接处理文字，它处理的是数字。第一步就是把输入文本切成 Token，再把 Token 映射成数字 ID。
什么是 Token
Token 不完全等于"词"，也不完全等于"字"，而是介于两者之间的一种文本单元。
英文中：
"Hello world" → ["Hello", " world"] → 2个Token
"unbelievable" → ["un", "believ", "able"] → 3个Token
中文中：
"你好世界" → ["你", "好", "世", "界"] → 4个Token（也可能2个，取决于分词器）
"大语言模型" → ["大", "语言", "模型"] → 3个Token
为什么不直接按字切分
如果按字切分，词表大小固定但丢失了"词"的语义信息（"语"和"言"分开看不如"语言"整体看）。如果按词切分，词表会爆炸（中文几十万个词）。
Tokenization 是两者的平衡：高频词整体作为一个 Token，低频词拆成子词或单字。
主流分词算法：BPE
目前主流大模型用的是 BPE（Byte Pair Encoding，字节对编码）：
- 先把所有文本拆成单字符
- 统计哪两个相邻字符出现最多，合并成一个新 Token
- 重复这个过程，直到达到预设词表大小
这样高频组合（如 “tion”、“ing”、“ing”）会自动合并成一个 Token，低频的保持拆分。
不同模型的 Tokenizer 不同
| 模型 | 词表大小 | 分词器 | 中文效率 |
|---|---|---|---|
| GPT-4 | ~100K | tiktoken (BPE) | 一般（1个汉字≈2-3 Token） |
| Qwen2 | 152K | tiktoken (BPE) | 好（1个汉字≈1-2 Token） |
| LLaMA 3 | 128K | SentencePiece (BPE) | 中等 |
| GLM-4 | 151K | SentencePiece | 好 |
为什么中文 Token 效率重要？ 因为大模型按 Token 收费。同样一段中文，GPT-4 可能用 100 个 Token，Qwen 可能只用 50 个——成本差一倍，速度也差一倍。
代码体验
# 用 OpenAI 的 tokenizer 体验
from transformers import AutoTokenizer
# Qwen2 的分词器
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-1.5B")
text = "大语言模型是怎么工作的"
tokens = tokenizer.tokenize(text)
ids = tokenizer.encode(text)
print(f"原文: {text}")
print(f"分词: {tokens}")
print(f"Token ID: {ids}")
print(f"Token数量: {len(ids)}")
# 输出示例:
# 原文: 大语言模型是怎么工作的
# 分词: ['大', '语言', '模型', '是', '怎么', '工作', '的']
# Token ID: [3923, 86523, 78344, 14, 28934, 45678, 9]
# Token数量: 7
15.3 第二步：Embedding——把 Token 变成向量
Token ID 只是一个编号，没有语义信息（"好"的 ID 是 8，"坏"的 ID 是 9，数字大小不代表相似性）。模型需要把 ID 转成有语义的向量——这就是 Embedding。
Embedding 的直觉
Embedding 的目标是：让语义相近的词，向量也相近。
经过训练后：
"猫" 的向量: [0.2, -0.5, 0.8, ...]
"狗" 的向量: [0.3, -0.4, 0.7, ...] ← 和"猫"很近（都是宠物）
"汽车"的向量: [-0.8, 0.9, -0.3, ...] ← 和"猫"很远
向量的每个维度代表某种语义特征，虽然人类无法直接理解每个维度的含义，但模型通过这些向量"理解"词义。
经典案例：词向量可以做"语义运算"
向量("国王") - 向量("男人") + 向量("女人") ≈ 向量("女王")
向量("北京") - 向量("中国") + 向量("日本") ≈ 向量("东京")
向量("苹果公司") - 向量("iPhone") + 向量("搜索") ≈ 向量("谷歌")
这说明 Embedding 空间中真的编码了语义关系。
大模型的 Embedding 层
大模型的 Embedding 是一个巨大的查找表：
词表大小 × 向量维度
GPT-3: 50,257 × 12,288 = 6.2亿参数（仅Embedding层）
Qwen-72B: 152,000 × 8,192 = 12.4亿参数
每个 Token ID 对应表中的一行向量，这一行向量就是这个 Token 的"语义表示"。这些向量是训练学出来的——一开始是随机初始化，通过海量文本训练，逐渐学到了语义。
从 Token 向量到上下文向量
单纯的 Token Embedding 只知道"这个词是什么意思"，但不知道"在这个语境下是什么意思"。
比如"苹果"这个词：
- “我吃了一个苹果” → 水果
- “苹果发布了新手机” → 公司
Transformer 的 Self-Attention 层负责解决这个问题：让每个 Token 和上下文中所有 Token 交互，生成包含上下文信息的"新向量"。这就是第13章讲的内容。
15.4 第三步：预训练——读遍互联网
预训练在干什么
预训练就是让模型"读"海量文本，练习 Next Token Prediction：
训练样本1: "中国的首都" → 目标: "是"
训练样本2: "import torch.nn as nn\n\nclass" → 目标: " Model"
训练样本3: "床前明月光" → 目标: "疑"
训练样本4: "function add(a, b) {\n return" → 目标: " a"
几万亿个这样的样本，模型反复训练，逐渐学会了：
- 语法规则（什么词搭配什么词）
- 世界知识（北京是中国首都、水在100度沸腾）
- 编程能力（代码的语法和模式）
- 推理模式（因为A所以B）
- 多语言能力（中英文互译）
预训练数据长什么样
| 数据来源 | 占比 | 内容 |
|---|---|---|
| 网页爬虫 | 40-60% | Common Crawl、维基百科、百度百科 |
| 代码 | 10-20% | GitHub 仓库、Stack Overflow |
| 书籍 | 10-15% | 电子书、教材 |
| 论文 | 5-10% | 学术论文（arXiv 等） |
| 对话 | 5-10% | 论坛、问答、Reddit |
GPT-3 训练了约 5000 亿 Token，LLaMA 2 训练了约 2 万亿 Token，LLaMA 3 训练了约 15 万亿 Token。数据量每代增长一个数量级。
预训练的计算量
训练一个大模型的计算量可以用一个粗略公式估算：
总计算量 ≈ 6 × 参数量 × Token数
以 Qwen-72B 为例（72亿参数，训练约 3.5 万亿 Token）：
计算量 ≈ 6 × 72×10⁹ × 3.5×10¹² = 1.5 × 10²⁴ FLOPs
一张 A100 GPU 每秒约 312 TFLOPS = 3.12 × 10¹⁴ FLOPS：
需要时间 ≈ 1.5×10²⁴ / 3.12×10¹⁴ ≈ 4.8×10⁹ 秒 ≈ 152 GPU年
也就是说，1 张 A100 要跑 152 年。所以需要上千张 GPU 并行训练，几个月才能跑完。
Scaling Law（缩放定律）
2020 年 OpenAI 发表了一篇重要论文，揭示了一个惊人的规律：
模型性能（Loss）与参数量、数据量、计算量呈幂律关系——只要增加这三者，性能就会持续提升，没有明显的饱和点。
这意味着什么？只要你有更多数据、更大模型、更多算力，模型就会持续变强。这个发现直接推动了"军备竞赛"——各家都在疯狂堆参数、堆数据、堆算力。
后来 DeepMind 的 Chinchilla 论文进一步指出：最优训练策略是数据量和参数量按比例增长，大约每个参数需要训练 20 个 Token。过度堆参数但数据不够，效率会很低。
15.5 第四步：SFT——教模型"听人话"
预训练完的模型只会"接龙"——你输入"中国的首都"，它输出"是北京"。但你输入"请告诉我中国的首都"，它可能输出"请告诉我日本的首都"——因为它不知道你在"提问"。
SFT（Supervised Fine-Tuning，监督微调） 就是教模型学会"对话格式"：
SFT 的训练数据
输入: "用户: 请解释什么是递归\n助手:"
目标: "递归是指一个函数在执行过程中调用自身的编程技巧..."
每条数据是"问-答"对，模型学习在"助手:"后面生成有价值的回答，而不是继续接龙。
SFT 的效果
经过 SFT 后，模型的行为发生了质变：
- 理解指令：知道"请解释"“请翻译”"请写代码"是不同的任务要求
- 角色意识：知道自己是"助手"，应该有帮助地回答问题
- 格式化输出：能按要求的格式输出（Markdown、JSON、代码块等）
SFT 数据量 vs 预训练数据量
| 阶段 | 数据量 | 数据类型 |
|---|---|---|
| 预训练 | 万亿 Token | 互联网文本（自动收集） |
| SFT | 几万到几十万条 | 高质量人工标注的问答对 |
SFT 数据量远小于预训练，但效果显著——因为模型在预训练中已经"学会了知识"，SFT 只是教它"怎么用这些知识回答问题"。
类比：预训练像读完了整个图书馆，SFT 像学会了怎么跟人交流。
SFT 数据的质量比数量重要
研究表明，少量高质量的 SFT 数据（如 LIMA 模型只用 1000 条精选数据）效果就能超过大量低质量数据。这和人类学习一样——精读一篇好文章比泛读一百篇水文更有收获。
15.6 第五步：RLHF——让模型"懂规矩"
SFT 之后的模型已经能对话了，但还有一个问题：模型不知道什么是"好回答"。
它可能：
- 回答很啰嗦，不着重点
- 生成有害内容（如教人做危险的事）
- 看起来正确但实际上有错误（幻觉）
- 不拒绝不合理的要求
RLHF（Reinforcement Learning from Human Feedback，基于人类反馈的强化学习） 就是解决这个问题。
RLHF 三步走
第一步：训练奖励模型（Reward Model）
让人类标注员对模型的多个回答打分排序：
问题: "怎么学编程？"
回答A: "建议从Python开始，先学基础语法，然后做小项目..." ← 评分: 8分
回答B: "编程很难，你还是放弃吧。" ← 评分: 1分
回答C: "去看书。" ← 评分: 3分
用这些打分数据训练一个"奖励模型"——它能自动给任何回答打分。
第二步：用强化学习优化大模型
让大模型生成回答，奖励模型打分，大模型根据分数调整自己的生成策略——分数高的行为多出现，分数低的少出现。
具体算法通常是 PPO（Proximal Policy Optimization），这是 OpenAI 搞强化学习的看家算法。
第三步：反复迭代
生成→打分→优化→再生成→再打分→再优化……循环多轮，模型的回答质量逐步提升。
RLHF 的效果
| 能力维度 | SFT 后 | RLHF 后 |
|---|---|---|
| 指令遵循 | 基本能听懂 | 精准执行复杂指令 |
| 回答质量 | 有信息但可能啰嗦 | 简洁有条理 |
| 安全性 | 可能生成有害内容 | 主动拒绝有害请求 |
| 诚实性 | 容易自信地胡说 | 不确定时会说"我不知道" |
| 用户体验 | 像在跟百科全书对话 | 像在跟一个靠谱的助手对话 |
RLHF 的替代方案：DPO
RLHF 虽然效果好，但流程复杂（要训练奖励模型 + PPO 训练），工程难度大。2023 年出现了 DPO（Direct Preference Optimization，直接偏好优化），跳过奖励模型，直接用偏好数据优化大模型。
DPO 的优势：
- 流程简单（不需要单独训练奖励模型）
- 训练稳定（PPO 容易不稳定）
- 效果接近 RLHF
目前很多开源模型（如 LLaMA-3、Qwen2）的后期对齐都用 DPO 或其变体。
15.7 完整训练流程总结
一个大模型从无到有，经历四个阶段：
┌─────────────────────────────────────────────────────────────┐
│ 大模型训练全流程 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 阶段1: 预训练 (Pre-training) │
│ ───────────────────────────── │
│ 数据: 万亿 Token 互联网文本 │
│ 目标: Next Token Prediction │
│ 成本: 数千张 GPU, 数月训练 │
│ 结果: 会"接龙", 有知识但不会对话 │
│ 类比: 读完整个图书馆的学生 │
│ ↓ │
│ 阶段2: SFT (Supervised Fine-Tuning) │
│ ───────────────────────────── │
│ 数据: 几万~几十万条问答对 │
│ 目标: 学习对话格式, 听懂指令 │
│ 成本: 几张~几十张 GPU, 几天训练 │
│ 结果: 能对话, 但回答质量不够好 │
│ 类比: 学会了跟人交流的礼仪 │
│ ↓ │
│ 阶段3: RLHF / DPO (对齐) │
│ ───────────────────────────── │
│ 数据: 人类偏好排序数据 │
│ 目标: 让回答更符合人类期望 │
│ 成本: 需要大量人工标注 + 训练 │
│ 结果: 回答质量高, 安全, 有帮助 │
│ 类比: 经验丰富的导师调教 │
│ ↓ │
│ 阶段4: 持续迭代 │
│ ───────────────────────────── │
│ 数据: 用户反馈, 新数据 │
│ 目标: 修复缺陷, 增加能力 │
│ 成本: 持续投入 │
│ 结果: 越来越强 │
│ 类比: 在工作中持续成长 │
│ │
└─────────────────────────────────────────────────────────────┘
各阶段参数变化
| 阶段 | 训练的参数 | 数据量 | 训练时间 |
|---|---|---|---|
| 预训练 | 全部参数 | 万亿 Token | 数月 |
| SFT | 全部参数或部分参数 | 几万~几十万条 | 几天 |
| RLHF/DPO | 全部参数或部分参数 | 几万~几十万条 | 几天 |
| 后续微调 | 通常只微调部分参数（LoRA） | 视任务而定 | 几小时~几天 |
15.8 “背答案"还是"真理解”——大模型的认知之谜
这是 AI 领域最激烈的争论之一：大模型到底是在"背答案"还是在"真正理解"？
"背答案"派的论点
- 训练数据包含了答案：互联网上到处都是"中国的首都是北京"，模型只是记住了
- 没有真正的推理：模型只是模式匹配，不是逻辑推理
- 幻觉问题：如果模型真"理解"了，为什么还会一本正经地胡说八道？
- 没有世界模型：模型只学到了文字的统计规律，不理解文字背后的物理世界
"真理解"派的论点
- 泛化能力：模型能回答训练数据中从未出现过的问题，说明不只是"背诵"
- 涌现能力：模型规模到一定程度后突然展现出新能力（如做数学推理），这些能力不是靠背诵能解释的
- 上下文学习：模型能从 Prompt 中的几个例子学习新任务，这需要某种程度的"理解"
- 内部表示：研究发现模型内部确实形成了对概念的结构化表示
我的观点：既不是"背答案"也不是"人类式的理解"
大模型的认知方式跟人类根本不同。它不是在"背答案"（因为参数量远小于训练数据量，不可能全部记住），也不是在"真正理解"（因为它没有身体、没有感官、没有因果推理能力）。
更准确的说法是：大模型学到了语言中的统计规律，而这些规律在足够大的规模上，恰好近似了某些"理解"的行为。
打个比方：你不懂国际象棋规则，但看了几百万盘棋的对局记录后，你能"预测"出下一步该怎么走——你的走法可能跟大师一样好，但你并不"理解"为什么这么走。大模型就是那个"看了几百万盘棋"的旁观者。
这对开发者意味着什么
- 别指望模型100%正确：它是在"猜"最可能的答案，不是在"查"正确答案
- 幻觉是特性不是bug：模型天生就会"编"看起来合理的内容，必须在系统层面做防护
- Prompt 很重要：因为你给的上下文直接影响模型"猜"的方向
- 验证不可省：模型输出的任何关键信息，都必须由系统或人工验证
15.9 Temperature 和 Top-P：控制"猜"的方式
模型每次预测下一个 Token 时，输出的不是一个词，而是一个概率分布——词表中每个词都有个概率值。
Temperature（温度）
Temperature 控制概率分布的"陡峭"程度：
原始概率: ["是": 0.85, "在": 0.05, "有": 0.03, ...]
Temperature = 0.1 (低温): ["是": 0.99, ...] ← 几乎只选最高概率的词
Temperature = 1.0 (默认): ["是": 0.85, ...] ← 原始概率
Temperature = 2.0 (高温): ["是": 0.30, "在": 0.15, "有": 0.10, ...] ← 概率更平均
温度低 → 输出确定性强、保守、重复性高。适合：代码生成、事实问答、数据提取
温度高 → 输出更多样、有创意、但可能跑偏。适合：创意写作、头脑风暴、对话
Top-P（核采样）
Top-P 是另一种采样策略：只从概率累计超过 P 的词中采样。
P = 0.9: 只考虑概率累计达到90%的词，剩下的低概率词全部排除
P = 0.1: 只考虑概率最高的几个词（可能只有1-2个）
Top-K
Top-K 更简单：只从概率最高的 K 个词中采样。
K = 1: 每次只选概率最高的词（等价于 Greedy Decoding）
K = 50: 从概率最高的50个词中采样
实际建议
| 场景 | Temperature | Top-P | Top-K |
|---|---|---|---|
| 代码生成 | 0.0-0.2 | 0.9 | 40 |
| 事实问答 | 0.0-0.3 | 0.8 | 40 |
| 摘要/翻译 | 0.3-0.5 | 0.9 | 40 |
| 对话/聊天 | 0.7-0.9 | 0.9 | 50 |
| 创意写作 | 0.9-1.2 | 0.95 | 50 |
注意： Temperature 和 Top-P 通常不同时调，调一个就够了。大多数场景 Temperature=0.7 + Top-P=0.9 是安全默认值。
15.10 上下文窗口：模型的"记忆力"
什么是上下文窗口
上下文窗口是模型一次能"看到"的最大 Token 数量。超过这个长度，前面的内容就"看不见"了。
[用户的历史对话] + [当前问题] + [模型生成的回答] ≤ 上下文窗口大小
各模型上下文窗口
| 模型 | 上下文窗口 | 大约等于 |
|---|---|---|
| GPT-3 (2020) | 2K | 1.5页纸 |
| GPT-3.5 | 4K-16K | 3-12页 |
| GPT-4 Turbo | 128K | 一本小说 |
| GPT-4o | 128K | 一本小说 |
| Claude 3 | 200K | 两本小说 |
| Qwen2 | 128K | 一本小说 |
| Gemini 1.5 Pro | 1M-2M | 十几本小说 |
上下文窗口的影响
上下文窗口直接决定了模型能处理的任务复杂度：
- 4K：简单问答、短文本处理
- 32K：长文档摘要、多轮对话
- 128K：整本书分析、代码库理解、长报告生成
- 1M+：超长文档处理、视频理解、大规模代码分析
上下文越长越好吗
不一定。研究表明：
- “Lost in the Middle”：模型对上下文中间的内容注意力会下降，开头和结尾的内容更容易被关注
- 成本随长度增长：Attention 计算量是 O(N²)，128K 上下文的成本是 4K 的 1024 倍
- 有效信息更重要：与其塞满 128K 上下文，不如用 RAG 精准检索最相关的几段内容
15.11 推理过程：从输入到输出的完整流程
把前面所有步骤串起来，看看你发一条消息给大模型后，发生了什么：
用户输入: "什么是递归？请用Python举例。"
Step 1: Tokenization
"什么是递归？请用Python举例。" → [Token1, Token2, ..., TokenN]
Step 2: Embedding
每个Token ID → 查Embedding表 → 得到向量矩阵 (N × d_model)
Step 3: 加位置编码
向量矩阵 + 位置编码 → 带位置信息的向量矩阵
Step 4: Transformer层处理 (重复N层)
每层: Self-Attention (词和词交互) → FFN (非线性变换) → Add&Norm
输入: (N × d_model) → 输出: (N × d_model)
Step 5: 取最后一个位置的输出
最后一个Token的向量 → 包含了整个句子的"理解"
Step 6: 映射到词表
最后一个向量 × 输出矩阵 → 词表大小的logits
Step 7: Softmax + 采样
logits → Softmax → 概率分布 → 按Temperature/Top-P采样 → 得到下一个Token
Step 8: 自回归循环
把新Token加到输入末尾 → 重复Step 1-7 → 生成下一个Token
直到遇到<结束符>或达到长度限制
实际输出: "递归是指一个函数调用自身。例如:\n\n```python\ndef factorial(n):\n if n <= 1:\n return 1\n return n * factorial(n-1)\n```\n..."
推理的KV Cache
Step 4 中，每生成一个新 Token，前面所有 Token 的 K 和 V 向量不变。把它们缓存起来，下次只计算新 Token 的 K/V——这就是 KV Cache。
没有 KV Cache：生成第 N 个 Token 需要重新计算前面所有 Token → O(N²) 计算量
有 KV Cache：生成第 N 个 Token 只需计算新 Token → O(N) 计算量
这就是为什么大模型"第一个词慢，后面的词快"——第一个词要计算所有 Token 的 K/V，后面的词用缓存。
推理的显存占用
推理时显存主要有三部分：
总显存 = 模型参数 + KV Cache + 激活值
模型参数: 参数量 × 精度字节数
FP16: 参数量 × 2字节
INT4: 参数量 × 0.5字节
KV Cache: 2 × 层数 × 序列长度 × 向量维度 × 精度字节数
例如 72B模型, 80层, 8192维度, FP16, 4096 Token:
2 × 80 × 4096 × 8192 × 2 ≈ 10.7 GB
这就是为什么长上下文推理需要大量显存——KV Cache 随序列长度线性增长，很容易超过模型本身的参数占用。
15.12 涌现能力：量变到质变
什么是涌现
当模型规模（参数量、数据量、计算量）跨过某个阈值后，模型突然展现出之前完全没有的能力——这叫"涌现能力"（Emergent Abilities）。
就像水温从 99°C 到 100°C，突然从液态变成气态——量变引起质变。
已观测到的涌现能力
| 能力 | 出现规模 | 表现 |
|---|---|---|
| 指令遵循 | ~1B 参数 | 能理解"请翻译""请总结"等指令 |
| 上下文学习 | ~10B 参数 | 从Prompt中的例子学习新任务 |
| 逐步推理 | ~60B 参数 | 能做多步数学推理 |
| 代码生成 | ~30B 参数 | 能写完整可运行的代码 |
| 角色扮演 | ~10B 参数 | 能模拟特定角色和风格 |
| 工具使用 | ~30B 参数 | 能学习调用外部API |
涌现的争议
有研究者认为"涌现"可能只是评估指标的假象——如果用连续指标（而非"全对/全错"的二分指标）来衡量，能力提升可能是平滑的而非突变的。
不管怎样，有一点是确定的：模型越大，能力越强。至少在目前的规模范围内，这个趋势没有停止的迹象。
15.13 为什么大模型会"幻觉"
幻觉（Hallucination）是大模型最大的问题——它有时会一本正经地编造不存在的事实。
幻觉的原因
原因一：训练目标决定的
Next Token Prediction 的目标是"最可能"的下一个词，不是"最正确"的下一个词。有时候"最可能"的词恰好是错的——比如模型不确定某个事实时，它会生成一个看起来合理但实际上不正确的内容。
原因二：训练数据本身有错
互联网上有大量错误信息，模型把它们也学进去了。
原因三：没有"不知道"的概念
模型没有被显式训练说"我不知道"，它倾向于给出某种回答——即使不确定。
原因四：上下文干扰
用户的问题措辞可能引导模型往错误方向"猜"。
减少幻觉的方法
| 方法 | 原理 | 效果 |
|---|---|---|
| RAG | 给模型外挂知识库，让它"开卷考试" | 最有效，后面专门讲 |
| 系统提示 | “如果你不确定，请说不知道” | 有一定效果 |
| 多轮验证 | 让模型自我检查回答 | 减少明显错误 |
| 温度调低 | 减少随机性，更保守 | 减少创造性幻觉 |
| 微调 | 用高质量数据微调 | 针对特定领域有效 |
| 引用标注 | 要求模型标注信息来源 | 便于人工验证 |
关键认知：幻觉不能完全消除
只要大模型基于 Next Token Prediction 工作，幻觉就不可能完全消除。系统设计必须把幻觉当作"已知的不可避免风险"来处理，而不是期望模型永远正确。
15.14 本章小结
核心知识点回顾
| 概念 | 一句话总结 |
|---|---|
| Next Token Prediction | 大模型的本质——根据前文猜下一个词 |
| Tokenization | 把文本切成Token，BPE是主流算法 |
| Embedding | 把Token变成有语义的向量 |
| 预训练 | 读万亿Token文本，练习接龙 |
| SFT | 教模型听懂指令、学会对话格式 |
| RLHF/DPO | 让模型回答更符合人类期望 |
| Temperature/Top-P | 控制输出的随机性和创造性 |
| 上下文窗口 | 模型一次能"看到"的最大长度 |
| KV Cache | 推理加速，缓存已计算的K/V |
| 涌现能力 | 规模到一定程度突然出现的新能力 |
| 幻觉 | 模型编造不存在的事实，无法完全消除 |
大模型训练的"四步曲"
预训练（学知识）→ SFT（学对话）→ RLHF/DPO（学规矩）→ 持续迭代
最重要的一句话
大模型不是数据库，不是搜索引擎，不是推理引擎。它是一个超级强大的"文字接龙器"——但在千亿参数和万亿数据的加持下，这个接龙器展现出了接近"理解"和"推理"的能力。理解这个本质，才能正确使用它、不误用它。
下一步
本章讲清了大模型"怎么训练出来的"和"怎么工作的"。接下来的章节进入应用层面：
- 第16章：主流开源模型对比选型（Qwen/LLaMA/ChatGLM/Mistral 怎么选）
- 第17章：Prompt 工程（同样的模型，问法不同效果天差地别）
- 第18章：模型微调（LoRA/QLoRA，什么场景该微调）
- 第19章：模型量化部署（vLLM/Ollama，让大模型跑起来）
- 第20章：模型评估（怎么证明你的模型确实变好了）
延伸阅读：
- Language Models are Few-Shot Learners (GPT-3论文, Brown et al., 2020)
- Training language models to follow instructions with human feedback (InstructGPT论文, 2022)
- Direct Preference Optimization (DPO论文, 2023)
- Scaling Laws for Neural Language Models (Kaplan et al., 2020)
- Training Compute-Optimal Large Language Models (Chinchilla论文, 2022)
更多推荐
5
0- 0
已为社区贡献9条内容
所有评论(0)