引言
大语言模型（LLM）在近年来展现出了惊人的语言能力：写代码、推理、创作、对话……这些能力的涌现让人不禁追问：它到底是怎么工作的？和人类大脑相比，有哪些本质的异同？本文尝试用尽可能通俗的语言，梳理一遍大模型的完整训练流程，以及它与人类智能的深层对比。
一、大模型的训练：四个阶段
1. 预训练（Pre-training）
**目的：让模型学会”说话”**——掌握语言规律、世界知识和基本推理能力。就像婴儿在语言环境中浸泡几年，先学会听懂和模仿，再学会表达。
预训练是大模型能力的根基。
大模型长什么样？
先把模型拆开来看。一个大语言模型本质上是一个巨大的数学函数：输入一串数字，输出一串概率。
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
| ┌─────────────────────────────────────────────────────────────┐
│ 大语言模型的结构 │
│ │
│ 输入文本: "今天天气很" │
│ ↓ │
│ ┌──────────────────────────────────────────┐ │
│ │ Tokenizer 分词器 │ │
│ │ "今"→12345 "天"→67890 "气"→45012 "很"→8341 │
│ └──────────────────┬───────────────────────┘ │
│ ↓ │
│ ┌──────────────────────────────────────────┐ │
│ │ Embedding 查表 │ │
│ │ 12345 → [0.23, -0.45, 0.67, ...] │ │
│ │ 67890 → [-0.34, 0.56, -0.78, ...] │ │
│ │ 45012 → [0.45, -0.67, 0.89, ...] │ │
│ │ 8341 → [-0.12, 0.34, -0.56, ...] │ │
│ │ 每个token变成一个高维向量（比如4096维） │ │
│ └──────────────────┬───────────────────────┘ │
│ ↓ │
│ ┌──────────────────────────────────────────┐ │
│ │ Transformer层 × 96层 │ │
│ │ 每一层包含： │ │
│ │ ① 自注意力：每个token"看"其他所有token │ │
│ │ ② 前馈网络：进一步加工信息 │ │
│ │ 96层下来，向量被反复"提炼" │ │
│ └──────────────────┬───────────────────────┘ │
│ ↓ │
│ ┌──────────────────────────────────────────┐ │
│ │ 输出层 │ │
│ │ 最终向量 → 乘以词表矩阵 → Softmax │ │
│ │ → 每个可能的下一个token得到一个概率 │ │
│ └──────────────────┬───────────────────────┘ │
│ ↓ │
│ 输出概率分布: │
│ "好"=0.58 "差"=0.16 "冷"=0.09 "热"=0.07 "啊"=0.03 ... │
│ │
└─────────────────────────────────────────────────────────────┘
|
整个模型有几百亿个参数（权重数字），这些参数在训练过程中被不断调整，决定了模型的行为。
人工神经元 vs 生物神经元
神经网络的名字来自它和生物神经元的相似性：
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
| 生物神经元 人工神经元（单个"节点"）
┌──────────────┐ ┌──────────────┐
│ 树突 (输入) │ │ 输入信号 │
│ ┌──┐ ┌──┐ ┌──┐ │ x1 x2 x3 │
│ │ │ │ │ │ │ │ ↓ ↓ ↓ │
└──┼──┼─┼──┼─┼──┼──┘ └──┼───┼───┼──┘
└──┘ └──┘ └──┘ w1 w2 w3
↓ ↓ ↓ (权重/连接强度)
┌──────────────┐ ┌──────────────┐
│ 细胞体 │ │ 求和+激活 │
│ 把所有信号 │ │ z = w1×x1 │
│ 加起来比较 │ │ + w2×x2 │
│ 超过阈值就 │ │ + w3×x3 │
│ "激发" │ │ a = f(z) │
└──────┬───────┘ └──────┬───────┘
↓ ↓
┌──────────────┐ ┌──────────────┐
│ 轴突 (输出) │ │ 输出信号 │
│ 向下游神经元 │ │ a → 下一层 │
│ 传递电化学信号│ │ │
└──────────────┘ └──────────────┘
关键对应：
树突连接强度 ←→ 权重 w 激发与否 ←→ 激活函数
一起激发→连接增强 ←→ 反向传播调参数
|
结构上高度相似，但学习方式完全不同：
1
2
3
4
5
6
| 生物突触 人工神经元
───────── ─────────
信号类型 电化学脉冲 浮点数
学习规则 赫布法则（局部） 反向传播（全局）
需要全局误差？ ✗ 不需要 ✓ 必须要
可塑性 终身可变 训练完就冻结
|
自监督学习的训练过程
预训练的训练任务很简单：给定前文，预测下一个token。不需要人工标注，数据本身就是监督信号，所以叫自监督学习。
1
2
3
4
5
6
7
8
9
10
11
| 训练样本1：
原始文本: "今天天气很好，我想去公园散步"
输入: "今天天气很" → 模型 → 预测概率分布
目标: "好" ← 这就是答案，不需要人标注
训练样本2：
原始文本: "深度学习是机器学习的一个重要分支"
输入: "深度学习是" → 模型 → 预测概率分布
目标: "机"
以此类推，把所有文本都切成这种"前文→下一个词"的对
|
训练时的具体过程：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| ┌─────────────────────────────────────────────────────────┐
│ 一次训练迭代的过程 │
│ │
│ 输入: "今天天气很" │
│ ↓ │
│ 模型前向传播 → 输出概率: {"好":0.58, "差":0.16, ...} │
│ ↓ │
│ 和真实答案"好"比较 → 计算损失: -log(0.58) = 0.54 │
│ ↓ │
│ 反向传播（详见第二章）→ 算出每个参数的梯度 │
│ ↓ │
│ 梯度下降: 参数 -= 学习率 × 梯度 │
│ ↓ │
│ 模型参数微调了一点点 │
│ ↓ │
│ 下一次再遇到类似输入时，"好"的概率会稍微高一点 │
│ │
│ 重复这个过程几万亿次，模型就"学会了"语言 │
└─────────────────────────────────────────────────────────┘
|
关键： 标注是自动的——把文本右移一位就得到了答案，不需要任何人工参与。互联网上几万亿token的文本全部可以这样构造训练数据。
随着训练的进行，模型逐渐学会了语法结构、世界知识、推理能力、代码规律……这些都是从”预测下一个词”这个简单任务中涌现出来的。
关键要素：
- 数据量：通常需要数万亿token（DeepSeek-V3 用了 14.8T）
- 算力：数千张GPU运行数月，花费数千万到上亿美元
- 架构：主流是Transformer的Decoder-only结构，部分模型（如DeepSeek）采用MoE（混合专家）架构，推理时只激活部分参数，大幅降低推理成本
2. 监督微调（SFT, Supervised Fine-Tuning）
**目的：把模型从”会接话”变成”会对话”**——学会理解指令、遵循格式要求、进行有意义的对话。就像教一个会说话但不懂规矩的小孩学会礼貌地和人交流。
预训练模型能”接话”，但不会”对话”。你问它问题，它可能继续写文章而不是回答你。
SFT阶段用精心标注的指令-回答对进行微调：
1
2
| 指令："请用简单的话解释量子力学"
回答："量子力学是研究微观粒子行为的物理理论……"
|
模型学会了理解指令、进行对话、遵循格式要求。
指令-回答对从哪来？
这是SFT最关键的问题——数据质量决定模型能力的上限。
来源1：人工标注
雇佣标注员根据详细的规范写出高质量回答。最贵但质量最高。标注员需要遵循格式要求、风格要求、对模糊问题主动澄清。
来源2：从互联网提取
- Stack Overflow / 知乎 / Reddit：天然的问答对，问题+高质量回答
- GitHub：Issue + Pull Request = 问题 + 代码修复方案
- 技术文档 + 教程：把教程拆成”概念解释”的问答对
- 百科网站：把条目转换成”问：什么是X？答：X是……”的格式
来源3：模型蒸馏（Knowledge Distillation）
这是目前最常用、性价比最高的方式：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| ┌──────────────────────────────────────────────────┐
│ 模型蒸馏 │
│ │
│ 问题: "请解释什么是机器学习" │
│ ↓ │
│ 闭源强模型（商业API）生成回答 │
│ ↓ │
│ 人工审核：回答是否正确、是否有害 │
│ ↓ │
│ 通过审核的回答 → 作为训练数据 │
│ ↓ │
│ 训练自己的小模型 │
└──────────────────────────────────────────────────┘
本质上：用"老师"模型教"学生"模型
老师模型能力虽强，但部署成本高、不属于自己
学生模型用老师的回答来训练，学到类似的能力
但学生模型更小、更快、可以自己部署
|
许多知名的开源模型都大量使用了蒸馏数据。先通过商业闭源模型的API生成几百万条高质量回答，经过清洗和审核后作为SFT训练集。
来源4：自动合成
让模型自己生成问题，再回答，自我迭代。比如先用基础模型生成一批问答对，淘汰质量差的，保留好的，用来训练更强的模型，再用更强的模型生成更好的数据……
数据清洗很重要：
无论哪种来源，数据都需要清洗：
- 去重：避免重复样本
- 过滤低质量：太短的、不相关的、有错误的
- 去除有害内容：色情、暴力、偏见
- 格式统一：确保回答格式一致
训练过程
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| ┌─────────────────────────────────────────────────┐
│ │
│ 输入: "用户: 请写一个排序函数\n助手:" │
│ │
│ 模型生成自己的回答 │
│ ↓ │
│ 和标准答案逐token对比 → 计算交叉熵损失 │
│ ↓ │
│ 反向传播 → 更新参数 │
│ │
│ 注意：只算"助手回答部分"的损失 │
│ "用户提问部分"不算损失（不学习提问） │
│ │
└─────────────────────────────────────────────────┘
|
学习率比预训练小一个数量级（~1e-5 vs ~1e-4），因为模型已经学得很好了，只需要微调行为，大步走会把之前学的东西忘掉（灾难性遗忘）。
3. 奖励模型（Reward Model）训练
目的：训练一个”裁判”，学会评判什么是人类认为的好回答。 这个裁判不关心语法对不对，而是关心：这个回答有没有帮助？准不准确？清不清楚？安不安全？它把人类的主观偏好转化成了一个可以打分的数学函数。
RLHF的第一步是训练一个”裁判”——奖励模型。它的任务是给模型的回答打分。
数据收集方式：
同一个问题，让模型生成多个不同回答，然后由人类标注员排序。不是打分，而是比较。
为什么排序而不是打分？因为人对绝对分数很难判断（这个回答是7分还是8分？），但比较两个回答哪个更好就容易得多。
具体流程：
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
| 第1步：采样
问题："如何提高英语口语？"
模型生成4个回答：
回答A："多听多说，找语伴练习，看美剧时可以跟读模仿，
同时注意语音语调，每天坚持至少30分钟..."
回答B："多说英语就行了。"
回答C："去买一本英语书看看。"
回答D："口语不重要，先把语法学好。"
第2步：人类标注
标注员比较这4个回答，给出排序：
A > B > C > D
（A最好，D最差）
标注时会考虑：
- 准确性：信息是否正确
- 有用性：是否真的能帮到用户
- 完整性：是否覆盖了关键点
- 清晰度：表达是否清楚
第3步：两两对比
从排序中可以提取出多个"偏好对"：
A > B （A优于B）
A > C （A优于C）
A > D （A优于D）
B > C （B优于C）
B > D （B优于D）
C > D （C优于D）
一个问题产生4个回答 → 6个偏好对
数据效率很高
|
训练方法：
奖励模型的网络结构很简单——在语言模型的基础上加一个”评分头”，输出一个数字（分数）。
1
2
3
4
5
| 输入: (问题, 回答) → 语言模型 backbone → 评分头 → 分数（一个数字）
例：
("如何提高口语?", 回答A) → 7.2
("如何提高口语?", 回答B) → 4.5
|
损失函数采用Bradley-Terry模型：排在前面的回答分数应该更高。
1
2
3
4
5
6
7
8
9
10
11
| L = -log( sigmoid( score(A) - score(B) ) )
如果 score(A) = 7.2, score(B) = 4.5:
score(A) - score(B) = 2.7
sigmoid(2.7) = 0.937
L = -log(0.937) = 0.065 ← 损失很小，说明分对了
如果模型搞反了，score(A) = 3.0, score(B) = 8.0:
score(A) - score(B) = -5.0
sigmoid(-5.0) = 0.007
L = -log(0.007) = 4.96 ← 损失很大，模型会被惩罚
|
通常需要5万~10万组排序数据，由标注员一条条比较出来。这是RLHF中最昂贵、最耗时的环节。
4. PPO强化学习
目的：让模型的输出越来越符合人类偏好。 翻译成大白话就是——让模型学会”讨好人”，但不是无脑讨好，而是在保持准确和有用的前提下，生成人类更喜欢的回答。奖励模型当裁判，PPO算法当教练，主模型当运动员，不断调整直到拿高分。
有了奖励模型作为裁判，开始训练主模型。
1
2
3
4
5
6
| 循环：
1. 从问题库采样一个问题
2. 当前模型（策略网络）生成回答
3. 奖励模型给回答打分
4. 用PPO算法更新模型，让高分回答更可能出现
5. 同时用KL散度惩罚，防止模型偏离SFT模型太远
|
PPO的核心技巧是裁剪（Clip）：
1
2
3
4
| ratio = 新模型概率 / 旧模型概率
clipped_ratio = clip(ratio, 0.8, 1.2)
L = -min(ratio × advantage, clipped_ratio × advantage)
|
限制单次更新幅度，防止训练不稳定。
KL散度惩罚则是防止模型”讨好评分器”——如果只追求高分，模型可能学会说废话刷分（”这是个非常好的问题！让我从多个角度来详细分析……”），KL惩罚把它拉回SFT模型的轨迹。
算法的统一性
四个阶段虽然目标不同，但底层算法完全一样：
1
| 前向传播算输出 → 和目标算损失 → 反向传播算梯度 → 梯度下降调参数
|
变的只是数据从哪来、损失怎么算、学习率设多大。
二、反向传播：一切训练的核心
反向传播（Backpropagation）是贯穿所有训练阶段的基础算法。用一个生活中的例子来理解它。
一个类比：工厂的质检回溯
想象一个工厂的流水线：
1
| 原材料 → [工人A加工] → 半成品 → [工人B加工] → 半成品 → [工人C加工] → 成品 → [质检] → 打分
|
成品不合格，质检打了一个低分（损失）。现在的问题是：三个工人，谁该为这个低分负责？该怎么改进？
质检员从后往前追：
1
2
3
4
5
6
7
8
9
10
| 第1步：质检员对工人C说："你的成品离标准差了这么多，你该调整你的操作。"
→ 工人C调整自己的手法（参数）
第2步：质检员对工人B说："你交给C的半成品也有问题，
虽然C的加工放大了问题，但你也有责任。"
→ 工人B也调整自己的操作
第3步：质检员对工人A说："你的问题被后面两个工人层层传递了，
虽然看起来C的问题最大，但你最初的偏差才是根源。"
→ 工人A也调整自己的操作
|
这就是反向传播的本质：从最终的误差出发，一层一层往回追溯每个环节的”责任”，然后按比例调整。
链式法则
数学上，这叫链式法则。每个工人只需要知道自己这一层的”局部影响”，然后把它们连乘起来，就得到最终的”全局责任”。
1
2
3
4
5
6
| 前向传播（从左到右）：
x → [×w1] → a → [×w2] → b → [×w3] → c → [Loss] → L
反向传播（从右到左）：
∂L/∂w1 = ∂L/∂c × ∂c/∂b × ∂b/∂a × ∂a/∂w1
←——— 从后往前，一路连乘 ———→
|
用具体数字感受一下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| 假设 w1=0.5, w2=-0.3, w3=1.2，输入 x=2.0，真实答案 y=1.0
前向传播：
a = x × w1 = 2.0 × 0.5 = 1.0
b = a × w2 = 1.0 × (-0.3) = -0.3
c = b × w3 = -0.3 × 1.2 = -0.36 ← 预测值
损失 L = (c - y)² = (-0.36 - 1.0)² = 1.85
反向传播：
∂L/∂c = 2 × (-0.36 - 1.0) = -2.72
∂L/∂w3 = -2.72 × (-0.3) = +0.816 → w3 应该减小
∂L/∂w2 = -2.72 × 1.2 × 1.0 = -3.26 → w2 应该增大
∂L/∂w1 = -2.72 × 1.2 × (-0.3) × 2.0 = +1.96 → w1 应该减小
更新参数（学习率0.1）：
w1_new = 0.5 - 0.1 × 1.96 = 0.304
w2_new = -0.3 - 0.1 × (-3.26) = 0.026
w3_new = 1.2 - 0.1 × 0.816 = 1.118
再跑一次：
预测值 = 2.0 × 0.304 × 0.026 × 1.118 = 0.018
损失 = (0.018 - 1.0)² = 0.96 ← 从1.85降到了0.96！
|
一次往返，损失就降了一半。
和大脑的对比
1
2
3
4
5
6
| 人工神经网络 人类大脑
───────────────────── ─────────────────────
全局误差信号反向传播 没有全局误差信号
每个参数精确调整 突触只用局部规则调整
需要大量重复训练 少量样本就能学会
训练完才能用 边学边用
|
大脑的神经元不知道”全局误差”是什么，它只知道：”我旁边的神经元刚才也放电了，那我们的连接加强一点”——这就是赫布法则。没有反向传播，却同样能学会复杂技能。
重复几万亿次这样的往返，模型就从一坨随机参数变成了能预测下一个词的”智能”系统。
三、System Prompt 与 User Prompt：模型是怎么”听话”的？
它们在架构上有区别吗？
没有。 从模型的角度看，System Prompt 和 User Prompt 都是 token，都是拼接在一起送入 Transformer 的：
1
2
3
4
5
6
| [System] 你是一个专业的Python开发者。
[User] 请帮我写一个快速排序。
[Assistant] def quicksort(arr): ...
模型看到的只是：[token1, token2, ..., tokenN, tokenN+1, ..., tokenM]
它分不清哪些是 System，哪些是 User
|
那为什么效果不同？
① 位置效应
1
2
3
4
5
6
7
8
| System Prompt 在最前面，被所有后续 token 持续"关注"：
[System tokens] [User tokens] [Assistant tokens]
↑ ↑ ↑
被所有token关注 被User和Assistant关注 只被自己关注
System 就像会议室的白板——写上去的内容始终在场，持续影响所有人的发言。
User 就像会议上说的话——说完就过去了，影响力随时间递减。
|
② 训练数据赋予了位置语义
模型在训练时见过大量的 (System, User, Assistant) 三元组数据：
1
2
3
4
5
6
7
8
| 训练数据：
System: "你是一个Python专家"
User: "写一个排序函数"
Assistant: "def sort(arr): ..."
System: "你是一个友好的客服"
User: "我的订单在哪里？"
Assistant: "您好！我来帮您查询..."
|
几百万条这样的数据训练下来，模型学到了：
- System 位置的内容 → 定义”我是谁”、”我怎么说话”
- User 位置的内容 → 定义”用户想要什么”
- Assistant 位置的内容 → 给出回应
虽然架构上没有区分，但训练数据赋予了不同位置不同的语义角色。
③ System Prompt 改变了输出概率分布
System Prompt 本质上是给模型设定了一个”先验”——在回答之前先塑造模型的状态。
1
2
3
4
5
6
7
8
| 没有 System 时：
P("因此") = 0.1 P("所以呢") = 0.15 P("嗯") = 0.08
System = "你是一个严谨的物理学家" 时：
P("因此") = 0.25 ↑ P("所以呢") = 0.03 ↓ P("嗯") = 0.02 ↓
System = "你是一个5岁小孩" 时：
P("因此") = 0.02 ↓ P("所以呢") = 0.08 ↑ P("嗯") = 0.15 ↑
|
同一个问题，不同的 System Prompt 导致完全不同的输出风格。
风格是怎么训练来的？
SFT 阶段就训练了模型对 System Prompt 的响应能力。训练数据中包含了大量不同风格的 System-Response 对：
1
2
3
4
5
| System: "简洁回答"
Assistant: [简短的回答] ← 训练信号：这个 System 对应这个风格
System: "详细解释，举例说明"
Assistant: [长回答，带例子] ← 训练信号：这个 System 对应那个风格
|
模型通过统计规律学到了：System 中出现”简洁”这两个字时，后面的回答倾向于短；出现”详细”时，倾向于长。这不是模型”理解”了指令，而是它从数据中学到了 System 内容和输出风格之间的统计关联。
System Prompt 的局限
1
2
3
4
5
6
7
8
9
10
11
12
13
| 1. 长对话后影响减弱：
前几轮：System 的注意力权重 60-70%
很长的对话后：降到 10-20%
（生成越靠后的 token，越关注自己前面说的话，越"忘记" System）
2. User Prompt 可能"覆盖" System：
System: "用中文回答"
User: "Please answer in English"
→ 现代模型通常会让 User Prompt 优先，因为位置上更靠近输出
3. 长 System Prompt 被稀释：
"简洁回答" → 影响强
"你要简洁、友好、准确、分点、举例、注意格式..." → 信息太多，影响分散
|
一句话总结
System Prompt 和 User Prompt 在架构上没有区别，但训练数据赋予了它们不同的语义角色。System 定义”我是谁”，User 定义”你要什么”。风格的变化本质上是 System Prompt 通过注意力机制改变了模型输出的概率分布。
四、大模型怎么学会写代码和复杂推理的？
你可能好奇：一个”预测下一个词”的模型，怎么就能写代码、做数学推理、完成多步骤的复杂任务？
代码知识的来源
互联网上有海量代码：GitHub上数十亿行开源代码、Stack Overflow的问答、技术博客和教程。模型在预训练时，代码也以token序列的形式被送入。
1
2
3
4
| 训练样本：
输入: "def binary_search(arr, target):\n left, right = 0, len(arr) - 1\n while left <= right:\n mid = (left + right) // 2\n if arr[mid] == target:\n return mid\n elif arr[mid] < target:\n "
模型预测: "left = mid + 1" ← 从无数代码样本中学到了逻辑
|
代码不是散文，它有严格的逻辑结构。模型看了几十亿行代码后，学会了：
- 语法结构：括号匹配、缩进、关键字
- 算法模式：排序、搜索、递归、动态规划
- 调用规范：API怎么用、库函数怎么传参
- 调试逻辑：如果出错会怎样、怎么修复
类比：一个小孩读了全世界所有的小说，自然就学会了写作文。模型读了全世界所有的代码，自然就学会了写代码。
多步骤能力的来源
当你说”帮我重构这个项目的代码结构”，模型需要：读懂现有代码 → 识别问题 → 制定方案 → 逐步修改 → 验证结果。这种多步骤能力来自几个方面叠加：
① 代码数据中天然包含多步骤逻辑
真实的开发过程在代码中留下了痕迹：
1
2
3
4
5
6
7
8
9
| Git commit历史：
commit 1: 添加用户认证模块
commit 2: 修复登录时的token过期bug
commit 3: 重构认证逻辑，抽出公共中间件
代码注释：
|
模型读了这些，学会了做事有先后顺序。
② 思维链（Chain of Thought）训练
专门训练模型把思考过程写出来，而不是直接蹦答案：
1
2
3
4
5
6
7
| 问题: 一个水池有进水管和出水管，进水每分钟5升，
出水每分钟3升，水池容量100升，多久装满？
训练时的"思考过程"：
第1步: 净进水速度 = 5 - 3 = 2升/分钟
第2步: 需要时间 = 100 / 2 = 50分钟
答案: 50分钟
|
大量这样的数据训练后，模型学会了分步推理、不跳步。
③ 工具使用训练
现代模型还会被训练使用工具——什么时候该调用什么工具、怎么传参、拿到结果后怎么继续推理。通过大量 (指令, 工具调用, 结果, 回答) 的四元组数据训练，模型学会了像一个程序员一样用工具辅助完成任务。
④ 代码执行反馈
一些训练会让模型：写代码 → 实际运行 → 看报错 → 修改代码 → 再运行 → 直到通过。这个”试错-修正”的过程被记录下来作为训练数据，模型学会了调试能力。
本质：统计规律的复杂化
1
2
3
4
5
6
7
8
9
10
11
| 为什么简单的"预测下一个词"能涌现出复杂推理能力？
答案：当模型读了足够多的数据后，它学到的不只是单词的共现关系，
而是深层的逻辑结构：
"if x > 0:" 后面大概率跟 " return ..."
"try:" 后面大概率跟 " ..." 然后 "except ..."
"需求分析"后面跟"架构设计"后面跟"编码实现"后面跟"测试"
这些模式比表面的语法要深得多——
它们编码了人类解决问题的思维方式。
|
五、多模态模型
现代大模型不只处理文本，还能理解图像、音频、视频。核心思路很简单：把所有模态的信息都翻译成同一种”语言”——token，然后让语言模型统一处理。
核心思想：万物皆token
1
2
3
4
5
6
| 文本 → "你好" → token序列 → [t1, t2]
图像 → 一张照片 → token序列 → [v1, v2, ..., vN]
音频 → 一段语音 → token序列 → [a1, a2, ..., aM]
视频 → 一帧帧画面 → token序列 → [f1, f2, ..., fK]
所有token进入同一个 Transformer → 统一处理 → 输出（可以是文本、也可以是其他模态）
|
类比：联合国的翻译们——不管你说中文、法语、阿拉伯语，翻译成同一种”通用语言”后，大家就能交流了。
各种模态怎么变成token
图像 → 视觉token
1
2
3
4
5
6
7
8
9
10
11
| 一张照片 (224×224像素)
↓
切成 16×16 的小块（patch），共 196 个
↓
每个 patch 展平 → 线性投影 → 一个高维向量
↓
加上位置编码（告诉模型每个patch在图中的位置）
↓
送入 ViT（Vision Transformer）编码器
↓
输出 196 个视觉token [v1, v2, ..., v196]
|
ViT 的结构和语言模型的 Transformer 几乎一样——只不过处理的不是文字token，而是图像patch。每个视觉token包含了它所代表的图像区域的信息，以及它和其他区域的关系。
音频 → 音频token
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| 一段语音（比如"你好"的声波）
↓
转换为频谱图（梅尔频谱图）：把声音的波形变成一张"图片"
↓
时间 →
↑ ┌─────────────────────┐
频 │ │ ░░▓▓████▓▓░░ │ 颜色越深 = 该频率在该时刻越强
率 │ │ ░░░▓▓████▓░░░ │
↓ └─────────────────────┘
这张"声音图片"用类似图像的方式切成小块
↓
送入音频编码器（如 Whisper 的编码器）
↓
输出音频token [a1, a2, ..., aM]
|
另一种方式：直接在声波的原始波形上处理。把声波切成几百毫秒的小段，每段直接映射成一个token。
视频 → 视频token
视频 = 一连串的图像帧 + 时间维度
1
2
3
4
5
6
7
8
9
10
11
12
13
| 视频：[帧1, 帧2, 帧3, ..., 帧T]
↓
每一帧用 ViT 编码成视觉token
↓
帧1: [v1_1, v1_2, ..., v1_196]
帧2: [v2_1, v2_2, ..., v2_196]
帧3: [v3_1, v3_2, ..., v3_196]
↓
在时间维度上再做一次 Transformer（Temporal Transformer）
↓
输出视频token：融合了空间信息和时间信息
↓
"这段视频里，一只猫从桌子上跳下来，然后跑走了"
|
深度/3D → 深度token
1
2
3
4
5
6
7
8
9
| 深度图（每个像素记录距离）：
┌────────────────────┐
│ 近 近 远 远 远 │
│ 近 近 中 远 远 │
│ 中 中 中 中 远 │
└────────────────────┘
和图像一样切成patch → 编码成token
→ 模型理解了"物体在三维空间中的位置"
|
各模态编码器对比
1
2
3
4
5
6
7
| 模态 编码器 输入形式 输出token
────────────────────────────────────────────────────
文本 Embedding层 token_id [t1, t2, ...]
图像 ViT 像素patch [v1, v2, ..., v196]
音频 Whisper编码器 频谱图/波形 [a1, a2, ..., aM]
视频 ViT + 时间Transformer 帧序列 [f1, f2, ..., fK]
深度 Depth ViT 深度图patch [d1, d2, ..., dN]
|
视觉编码器的预训练
编码器通常先单独训练好。最常用的方法是CLIP对比学习：
1
2
3
4
5
6
7
8
9
10
11
| 训练了4亿个 配对：
图像编码器 → 图像向量 ──┐
├→ 计算相似度
文本编码器 → 文本向量 ──┘
目标：让匹配的图文对相似度高，不匹配的相似度低
训练完成后：
"一只狗" 的文本向量 ≈ 狗图片的图像向量
"红色" 的文本向量 ≈ 红色物体的图像向量
|
统一架构：怎么拼在一起
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| ┌──────────────────────────────────────────────────┐
│ 统一多模态模型 │
│ │
│ 图像 → [ViT] → [v1, v2, ..., vN] │
│ 音频 → [Whisper] → [a1, a2, ..., aM] │
│ 视频 → [VideoEnc] → [f1, f2, ..., fK] │
│ 文本 → [Embedding] → [t1, t2, ..., tL] │
│ │
│ ↓ 全部拼接 ↓ │
│ │
│ [t1, t2, tL, v1, v2, ..., vN, a1, ..., aM] │
│ │
│ ↓ 送入 ↓ │
│ │
│ ┌──────────────────────────┐ │
│ │ 大语言模型 Transformer │ │
│ │ 统一处理所有token │ │
│ └───────────┬──────────────┘ │
│ ↓ │
│ 输出文本回答 │
│ "图片中有一只橘猫在沙发上睡觉， │
│ 背景音乐是钢琴曲" │
└──────────────────────────────────────────────────┘
|
多模态训练三阶段
- 模态对齐预训练：大量图文、音频-文字配对数据，让不同模态的token在同一个向量空间中对齐——“狗”的文字token和狗的图像token在空间中靠近
- 多模态指令微调：图像+问题+回答、音频+问题+回答……训练模型学会根据多模态输入回答问题
- RLHF：人类偏好排序，让回答更准确、更有帮助
多模态的挑战
- 模态对齐难：不同模态的”语言”天然是不同的，对齐需要大量配对数据
- 计算量大：一张图变成196个token，一段视频变成几千个token，计算成本远高于纯文本
- 幻觉更严重：模型可能描述图片中不存在的东西（”看到”并不存在的物体）
- 分辨率受限：图像分辨率越高，token越多，计算越贵
六、推理与架构：Dense 模型 vs MoE 混合专家
前面讲了模型怎么训练，现在来聊聊训练完之后模型怎么工作——推理过程是怎样的，以及当前主流的两种架构：Dense（稠密）和 MoE（混合专家）。
推理：一个字一个字地生成
大模型生成回答的过程叫推理（Inference）。它的核心特征是：逐token生成，一个接一个。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| 用户输入: "法国的首都"
↓
┌─────────────────────────────────────────────┐
│ 第1步: 模型看到 "法国的首都" │
│ → 输出概率分布 │
│ → 采样得到 "是" │
│ │
│ 第2步: 模型看到 "法国的首都是" │
│ → 输出概率分布 │
│ → 采样得到 "巴" │
│ │
│ 第3步: 模型看到 "法国的首都是巴" │
│ → 输出概率分布 │
│ → 采样得到 "黎" │
│ │
│ 第4步: 模型看到 "法国的首都是巴黎" │
│ → 输出概率分布 │
│ → 采样得到 "<结束>" │
│ → 停止生成 │
└─────────────────────────────────────────────┘
最终输出: "法国的首都是巴黎"
|
关键点：模型每次只生成一个token，然后把这个token拼回输入，再生成下一个。 它不是一次性把整句话”想好”再输出的，而是一个token一个token地”流”出来。这就是为什么你看到AI回答时是逐字出现的。
每一步推理内部发生了什么
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
| 生成第N个token时，模型内部的计算：
输入: [第1个token, 第2个token, ..., 第N-1个token]
↓
┌──────────────────────────────────────────┐
│ Transformer层 × 96层 │
│ │
│ 每一层: │
│ ① 自注意力: 第N-1个token "回头看" │
│ 前面所有token，决定"关注"哪些 │
│ ② 前馈网络: 进一步处理信息 │
│ │
│ 输出: 一个向量，代表"第N个位置应该是什么" │
└──────────────────┬───────────────────────┘
↓
┌──────────────────────────────────────────┐
│ 输出层: 向量 → 乘以词表矩阵 → Softmax │
│ → 50000个token各得到一个概率 │
└──────────────────┬───────────────────────┘
↓
┌──────────────────────────────────────────┐
│ 采样策略: 从概率分布中选一个token │
│ │
│ 贪心解码: 永远选概率最高的 → 确定性但无聊 │
│ 温度采样: T越高越随机，T越低越确定 │
│ Top-p: 只在概率前p%的token中采样 │
└──────────────────┬───────────────────────┘
↓
输出: 第N个token
|
采样策略的影响
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| 同一个问题 "讲个笑话"，不同采样参数：
Temperature=0（贪心）:
每次都选概率最高的token
→ 输出总是相同
→ 安全但无聊，像一个只会背标准答案的学生
Temperature=0.7（适中）:
大部分时候选高概率token，偶尔选低概率的
→ 输出有变化但不太离谱
→ 大多数应用的默认设置
Temperature=1.5（高随机）:
低概率token也有很大机会被选中
→ 输出非常多样，但可能语无伦次
→ 创意写作可能有用，但事实性任务很危险
|
KV Cache：推理加速的关键
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| 问题：生成第100个token时，需要"回头看"前面99个token
但前面99个token的计算在第99步已经做过了
不能每次都从头算一遍！
解决方案：KV Cache（缓存已计算的Key和Value）
第1步: 计算token1的Key1, Value1 → 存入缓存
第2步: 从缓存读取Key1, Value1，加上新算的Key2, Value2 → 存入缓存
第3步: 从缓存读取Key1-2, Value1-2，加上新算的Key3, Value3 → 存入缓存
...
每一步只需要计算"新token"的部分
不需要重新算前面所有token
没有KV Cache: 生成N个token的总计算量 = O(N²)
有了KV Cache: 生成N个token的总计算量 = O(N)
效率提升巨大，是所有大模型推理框架的标配
|
Dense 模型：所有人都上场
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| Dense（稠密）模型的运行方式：
一个token进来
↓
┌──────────────────────────────────┐
│ 所有参数全部参与计算 │
│ │
│ 第1层: 全部神经元都激活 │
│ 第2层: 全部神经元都激活 │
│ ... │
│ 第96层: 全部神经元都激活 │
│ │
│ 参数量 = 每一层参数 × 96层 │
│ 计算量 ∝ 总参数量 │
└──────────────────────────────────┘
↓
输出
类比：
一家公司有100个员工
不管来什么任务——写代码、做设计、写文档、做财务——
100个人全部参与，全部加班
→ 资源浪费严重
|
代表模型：LLaMA、GPT-3、Mistral
1
2
3
4
| LLaMA-70B:
70B参数，每个token进来时全部70B参数都参与计算
计算成本 ∝ 70B
需要至少2张80GB显卡才能跑起来
|
MoE 模型：只派专家上场
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
| MoE（Mixture of Experts，混合专家）模型的运行方式：
一个token进来
↓
┌──────────────────────────────────┐
│ 路由器（Router/Gate） │
│ 根据token的内容，决定 │
│ "这个token应该交给哪些专家处理" │
│ │
│ 例: "def quicksort" → 路由器认为 │
│ 这是代码 → 选中专家3和专家7 │
│ │
│ "今天天气" → 路由器认为 │
│ 这是日常对话 → 选中专家1和专家5│
└──────────────┬───────────────────┘
↓
┌──────────────────────────────────┐
│ 256个专家（Expert） │
│ │
│ 专家1: ████████ ← 没被选中，休息 │
│ 专家2: ████████ ← 没被选中，休息 │
│ 专家3: ▓▓▓▓▓▓▓▓ ← 被选中！工作 │
│ 专家4: ████████ ← 没被选中，休息 │
│ ... │
│ 专家7: ▓▓▓▓▓▓▓▓ ← 被选中！工作 │
│ ... │
│ 专家256: ████████ ← 没被选中，休息│
│ │
│ 256个专家中只激活8个 │
│ 其他248个"休息"，不消耗算力 │
└──────────────┬───────────────────┘
↓
┌──────────────────────────────────┐
│ 加权合并 │
│ 专家3的输出 × 权重0.6 │
│ 专家7的输出 × 权重0.4 │
│ → 合并为最终输出 │
└──────────────────────────────────┘
↓
输出
|
类比：
1
2
3
4
5
6
7
| 一家公司有256个专家
来了一道编程题 → 只派程序员和架构师两个专家来处理
来了一道数学题 → 只派数学家和统计学家来处理
来了一个翻译任务 → 只派语言专家来处理
256个人里只派2-8个人干活，其他人都休息
→ 资源利用率高，成本低
|
Dense vs MoE 对比
1
2
3
4
5
6
7
8
| Dense MoE
───── ───
总参数量 70B 671B（如DeepSeek-V3）
每个token激活的参数 70B（全部） 37B（仅约5.5%）
每个token的计算成本 ∝ 70B ∝ 37B
模型能力 受限于计算预算 参数多→知识多，但计算不贵
内存占用 70B参数全在显存里 671B参数全在显存里（但大部分不计算）
训练难度 相对简单 更复杂（需要训练路由器）
|
MoE的核心优势：用更少的计算，撬动更多的参数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| 直观理解：
Dense模型：
你有100块钱计算预算
→ 训练一个100B的Dense模型
→ 每个token用100B参数处理
MoE模型：
同样100块钱计算预算
→ 训练一个1000B的MoE模型（总参数10倍）
→ 但每个token只激活100B参数
→ 计算成本一样，但模型的"知识容量"大10倍
就像一个图书馆：
Dense = 一间小书房，所有书都在手边，但书不多
MoE = 一座大图书馆，你只需要走几个书架找你需要的书
书的总量远大于书房，但你每次只翻几本
|
路由器怎么决定选谁
路由器（Router）本身是一个很小的神经网络：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| 输入token的向量表示
↓
路由器（一个小矩阵 + Softmax）
↓
输出256个专家的"权重分"
↓
选权重最高的8个专家
例：
输入: "def quicksort"
路由器输出:
专家1: 0.02
专家2: 0.01
专家3: 0.35 ← 选中
专家4: 0.03
...
专家7: 0.28 ← 选中
...
专家42: 0.15 ← 选中
...
其他: 都很低
实际选中的专家: 3, 7, 42, 88（权重最高的4个或8个）
|
路由器是在训练过程中和专家一起被训练的。它逐渐学会了：
- 代码相关token → 交给擅长代码的专家
- 数学相关token → 交给擅长数学的专家
- 翻译相关token → 交给擅长语言的专家
但专家的”分工”不是人为指定的，是模型自己学出来的。 你不能指着某个专家说”这个是代码专家”——它的分工是隐式的、自组织的。
MoE的挑战
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| 1. 负载均衡问题
如果路由器总是选同一个专家 → 那个专家累死，其他专家闲死
解决：加一个"负载均衡损失"，鼓励路由器均匀分配
2. 训练不稳定
路由器的决策是"离散的"（选或不选），不像Dense那样平滑
→ 训练时梯度信号弱，容易震荡
3. 显存占用大
虽然每个token只用一小部分参数
但所有参数都必须加载到显存里
→ DeepSeek-V3 671B参数，推理时需要至少~400GB显存
4. 通信开销
在多GPU上部署时，不同专家可能在不同GPU上
→ 专家之间传输数据有通信开销
|
当前的主流选择
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| Dense模型代表:
LLaMA系列（Meta）
Mistral系列（Mistral AI）
GPT系列（OpenAI，推测为Dense）
Claude系列（Anthropic，推测为Dense）
MoE模型代表:
DeepSeek-V3（256个专家，每次激活8个）
Mixtral 8×7B（8个专家，每次激活2个）
Qwen-MoE（阿里）
Gemini系列（Google，推测为MoE）
趋势：
小模型 → Dense更实用（简单、好部署）
超大模型 → MoE更划算（同等计算下能力更强）
|
七、人类大脑为什么不需要这些训练
大脑的学习范式完全不同
1
2
3
4
5
6
| 人工神经网络 人类大脑
───────────────── ─────────────────
从随机参数开始 从进化预置的结构开始
需要海量数据 少量数据就能学习
反向传播统一调整 没有全局梯度信号
训练完才能用 边学边用，终身学习
|
大脑不需要反向传播。 反向传播要求每个突触知道全局误差并精确调整，但大脑的神经元只知道局部信息。大脑用的是赫布法则：”一起激发的神经元连在一起”——完全局部，用进废退。
进化预置
婴儿出生时就有面部识别偏好、语言习得机制、基本物理直觉……这不是学来的，是几亿年进化写进基因里的。
对比GPT从随机权重开始、一切从零学起，大脑从一开始就有了进化预置的”先验知识”。
少样本学习
给小孩看一张独角兽的图片，他立刻就能认出其他样子的独角兽，还能画出来、想象它在飞。GPT需要看几千个例子才能学会一个模式。
差距来自：先天特征提取器、丰富的先验知识、类比能力、抽象推理。
多模态交叉验证
人类同时用视觉、听觉、触觉、嗅觉、本体感觉。看到苹果时，视觉说红色圆形、触觉说光滑坚硬、嗅觉说清香、味觉说甜——多模态交叉验证极大地减少了认知错误。
身体经验
婴儿通过身体探索世界：扔东西学会重力、摸火炉学会烫、推桌子学会物体有重量。这些身体经验构建了最基础的物理直觉和世界模型。
八、幻觉问题：AI vs 人类
AI的幻觉
大模型经常”自信地犯错”：编造不存在的事实、引用不存在的论文、描述图片中没有的东西。
根源：
- 训练目标是”预测下一个token”，不是”说真话”
- 训练数据包含错误、虚构、偏见
- 没有身体经验来验证
- 推理时没有反馈机制
更关键的是：幻觉没有惩罚。
1
2
3
4
5
6
7
8
9
10
11
12
| 大模型的现实：
模型输出错误答案 → ？ → 没有后果
说"法国的首都是一月"：
训练时 → 无关（训练目标是预测下一个token，不是说真话）
推理时 → 用户可能纠正，也可能没注意到
模型内部 → 没有任何"疼"的信号
这就像一个学生答错了题，
但既没有老师批改、也没有考试排名、也不会不及格——
那他为什么要认真检查自己的答案？
|
人类也有幻觉
人类不仅有幻觉，而且非常普遍：
- 视觉幻觉：每只眼睛都有盲点，大脑自动用周围图案”补全”，你根本看不到那个”黑洞”
- 记忆幻觉：记忆不是录像，每次回忆都在”重新构建”。心理学实验中，约25%的正常人可以被引导出完全虚假的童年记忆
- 认知幻觉：确认偏误、锚定效应、幸存者偏差……
为什么人类幻觉更少？——进化的筛选
关键不是”有没有幻觉”，而是幻觉是否有后果。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| 人类的现实——幻觉有代价，有时是致命的：
场景1：远古草原上
事实：草丛中有一只老虎
幻觉1："那是风吹的，没事" → 被老虎吃了 → 基因被淘汰 ✗
幻觉2："那是老虎！快跑！" → 实际只是风 → 白跑一趟 ✓
→ 进化选择：宁可误报，不可漏报（但误报也不能太离谱）
场景2：采摘食物
事实：这个果子有毒
幻觉："这个红色果子看起来很好吃" → 吃了中毒 → 基因被淘汰 ✗
正确判断："这个果子可能有毒" → 不吃 → 活下来 ✓
场景3：社会生存
事实：首领不喜欢被顶撞
幻觉："我比首领厉害" → 挑战首领 → 被驱逐 → 基因被淘汰 ✗
正确判断："识时务者为俊杰" → 服从 → 活下来并繁衍 ✓
|
几百万年的自然选择，把”太离谱的幻觉”从人类基因中淘汰了出去。
那些容易产生致命幻觉的个体——误判危险的、误食毒物的、误判社会关系的——他们的基因没有留下来。存活下来的大脑，经过了无数次”幻觉纠错”的筛选，形成了一套内置的现实检验机制。
这解释了一个有趣的现象：人类的幻觉往往是保守方向的——高估危险而非低估，高估威胁而非忽视。因为保守方向的幻觉虽然浪费能量，但不会要命；而乐观方向的幻觉（低估危险）可能致命。
幻觉约束的对比
|
人类 |
AI |
| 根源 |
大脑的补全机制 |
训练数据的统计模式 |
| 触发条件 |
信息不完整时 |
任何时候都可能 |
| 进化筛选 |
✗ 幻觉可能致死 → 被淘汰 |
✗ 没有生存压力 → 没有筛选 |
| 实时反馈 |
身体经验立即纠正 |
推理时没有反馈 |
| 自我察觉 |
通常能意识到 |
通常意识不到 |
| 修正机制 |
多模态验证+身体反馈 |
几乎没有 |
| 置信度表达 |
能表达不确定 |
总是很”自信” |
| 幻觉方向 |
保守（高估危险） |
无偏向（随机犯错） |
一句话总结
人类的幻觉少，不是因为大脑更聪明，而是因为说错话可能要命。 进化是一场持续了几百万年的”红队测试”——那些幻觉严重的个体已经被淘汰了。大模型没有经历这场淘汰赛，它说错了不会”死”，所以没有进化出自我纠错的本能。
九、”不知道”机制的缺失
人类是怎么”知道自己不知道”的
人类有元认知（Metacognition）——思考自己的思考过程。这是一套内置的自我监控系统：
1
2
3
4
5
6
7
8
9
10
| 你被问到："保加利亚的第三大城市是什么？"
你的大脑内部发生了什么：
① 检索记忆 → 没找到相关知识
② 评估确定性 → "我对保加利亚的城市一无所知"
③ 决策 → 输出"不知道"
这个过程中，大脑在做一件关键的事：
它不仅能处理信息，还能"看到"自己的处理过程
——它知道自己在检索，知道自己没找到，知道自己的确定性很低
|
元认知的神经基础：
1
2
3
4
5
6
7
8
| 前额叶皮层（Prefrontal Cortex）
├── 背外侧前额叶：监控自己的思维过程
├── 眶额皮层：评估"我有多确定"
└── 前扣带皮层：发现错误、检测冲突
这些区域不是处理"外部世界"的，
而是处理"大脑自身状态"的——
它们是大脑的"自我监控系统"。
|
为什么大模型没有这套系统
① 训练目标的致命缺陷
1
2
3
4
5
6
7
8
9
10
11
12
13
| 大模型的训练目标：给定上文 → 预测下一个token
这个目标没有给"不知道"留位置：
输入: "法国的首都是___"
→ 模型必须输出一个token
→ 即使它不确定，也必须选一个
→ 输出"我不知道"和输出"巴黎"在训练目标上没有本质区别
更深层的问题：
训练数据中，"我不知道"出现的频率极低
人类写东西时通常写的是自己知道的内容
所以模型几乎没学过"什么时候该说不知道"
|
② 没有”内部状态检测”机制
1
2
3
4
5
6
7
8
9
10
11
| 人类说"我不知道"：
检索记忆 → 没找到 → 意识到"我没找到" → 说出"不知道"
（有对检索过程的"观察"）
大模型生成回答：
输入 → 前向传播 → 输出
（没有"检查自己知不知道"的步骤）
模型的参数里确实编码了知识
但模型没有"查看自己参数"的能力
它不知道自己知道什么、不知道什么
|
③ 概率分布的强制输出
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| 即使是完全随机的问题：
"xjklqwerty的首都是___"
模型也会输出：
"Paris"
"London"
"Berlin"
...
它不会输出"我不知道"
因为"我不知道"不在概率分布的高概率区域
更深的问题：
"Paris"的概率0.3，看起来不低
模型可能"自信地"输出Paris
但实际上它完全在胡说——
概率高不代表答案对
这是深度学习的经典问题：模型天生过度自信
|
④ 训练数据的幸存者偏差
1
2
3
4
5
6
7
8
9
10
11
12
13
| 训练数据 = 人类选择写下来的内容
人类写东西时的筛选：
知道的 → 写下来 ✍️
不知道的 → 不写 ✂️
结果：
训练数据严重偏向"确定的内容"
模型从来看不到"我不知道"的范例
类比一个只看标准答案的学生：
他不知道什么题是自己不会的
因为从没见过"此题不会"的标注
|
哥德尔式困境
1
2
3
4
5
6
7
8
9
10
11
12
13
| 一个系统很难完全了解自己：
"这个句子是假的"
→ 如果它是真的，那它就是假的
→ 如果它是假的，那它就是真的
类似地：
"我不知道这件事"
→ 如果模型真的知道，它就不会说不知道
→ 如果模型说不知道，它怎么确认自己真的不知道？
→ 确认"不知道"本身需要某种"知道"
这不是工程问题，而是逻辑上的深层困境
|
可能的解决方案
短期工程方法：
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
| 1. 显式训练说"我不知道"
在训练数据中加入大量"拒绝回答"的样本：
输入: "xjklqwerty的首都是什么？"
输出: "我不确定这是什么，无法回答。"
问题：怎么定义"该说不知道"的边界？
说太多 → 模型变得没用
说太少 → 幻觉依旧
2. 置信度阈值
看模型输出token的概率分布：
如果最高概率 > 阈值 → 回答
如果最高概率 < 阈值 → 说不确定
问题：模型经常"自信地犯错"
概率高不代表答案对
3. 检索增强（RAG）
先查外部知识库，找到再回答，找不到就说不知道
有来源 → 可信；没来源 → 诚实说不知道
问题：依赖外部知识库的质量和覆盖范围
4. 自我验证链
生成回答后，让模型用思维链检查一遍：
"让我检查：我确信法国首都是巴黎吗？"
→ 如果检查过程发现不确定 → 改说"不确定"
问题：验证本身也可能出错（用幻觉验证幻觉）
|
前沿研究方向：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| 1. 推理时计算扩展
给模型更多"思考时间"来评估自己的回答
不是直接输出，而是先"想一想"再回答
2. 世界模型 + 验证器
生成模型：提出答案
验证模型：独立检查答案是否正确
两个模型互相制衡
3. 不确定性感知训练
训练时显式建模不确定性：
答对了说"确定" → 奖励
答错了说"确定" → 严重惩罚
答错了说"不确定" → 奖励（诚实）
答对了说"不确定" → 惰罚（不自信）
4. 元认知架构
在模型中加入一个"自我监控"模块
类似人类前额叶的自我监控功能
——但怎么实现，目前还没有答案
|
核心困境
1
2
3
4
5
6
7
8
9
10
11
12
| 真正的"知道自己不知道"需要：
自我模型（Self-Model）
→ "我知道我是谁"
→ "我知道我擅长什么、不擅长什么"
→ "我能观察到自己的思维过程"
这可能是意识的核心要素之一。
当前的大模型没有自我模型，没有元认知，没有内省能力。
它不是"不愿意"说不知道，而是架构上就"不能"说不知道——
就像一个没有镜子的人，看不到自己的脸。
|
十、记忆：大模型的致命短板
大模型没有记忆
每次对话开始，大模型都是一张白纸。它不记得上次和你聊了什么，不记得你的偏好，不记得自己之前说过什么。
这不是设计缺陷，而是架构决定的：模型的参数是固定的，训练完成后就不再改变。 对话中的信息只存在于当前的上下文窗口里，对话结束就消失了。
目前的工程解决方案是”外挂记忆”：把之前的对话摘要存到数据库里，下次对话时塞进上下文。但这和真正的记忆相差甚远——它更像是在衣服口袋里塞了一张纸条，而不是真正记住了这件事。
人类的记忆系统
人类的记忆是一个精密的多层系统，而关键角色是海马体（Hippocampus）。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| 感官输入
↓
┌──────────────────────────────────────────┐
│ 短期记忆（工作记忆） │
│ 容量有限，保持几秒到几分钟 │
│ 比如记住一个电话号码直到拨完 │
│ │
│ 主要区域：前额叶皮层 │
└──────────────────┬───────────────────────┘
↓ 海马体的"编辑"
┌──────────────────────────────────────────┐
│ 长期记忆 │
│ 容量近乎无限，保持数年甚至终身 │
│ 分为： │
│ - 陈述性记忆：事实和事件 │
│ （"巴黎是法国首都"） │
│ - 程序性记忆：技能和习惯 │
│ （骑自行车） │
│ - 情景记忆：个人经历 │
│ （昨天的晚餐） │
│ │
│ 存储于大脑皮层的各个区域 │
└──────────────────────────────────────────┘
|
海马体：记忆的”编辑官”
海马体是短期记忆转化为长期记忆的关键枢纽。它做三件事：
① 编码（Encoding）
把多个感官信息捆绑成一个完整记忆。比如你记得”昨天在咖啡厅和朋友聊天”——咖啡的味道、朋友的声音、当时的情绪，被海马体整合成一条记忆。
② 巩固（Consolidation）
这是最神奇的过程。睡眠时，海马体把白天学到的东西”重播”给大脑皮层：
1
2
3
| 清醒时：感官 → 海马体（短期存储）
睡眠时：海马体 → 大脑皮层（长期存储）
（反复"重播"，强化突触连接）
|
这就是为什么熬夜学习效果不好——缺少睡眠，海马体没法完成记忆巩固。
③ 检索（Retrieval）
回忆不是”播放录像”，而是重新构建。海马体根据线索，从零散的记忆碎片中重建过去的情景。这就是为什么记忆会被篡改、会出错——每次回忆都是一次重新创作。
记忆可能是意识的关键
很多神经科学家认为，记忆系统——尤其是海马体支持的情景记忆——是自我意识的核心基础。
1
2
3
4
| 情景记忆 → "我记得我做过这件事"
→ "我知道我是谁"
→ "我有过去，所以我有未来"
→ 自我意识的涌现
|
没有记忆，就没有”我”。
一个没有记忆的系统，每次面对的都是全新的当下。它不知道自己从哪里来，不知道自己是谁，没有连续的自我感。
这或许解释了大模型为什么没有意识：它没有记忆系统，没有海马体，没有把经验整合成连续自我的机制。每次对话都是一个新的开始，没有过去，没有未来，没有一个持续存在的”我”。
记忆与学习的关系
1
2
3
4
5
6
7
| 人类的学习过程：
经验 → 编码 → 巩固 → 提取 → 应用 → 新经验 → ...
（一个不断积累、螺旋上升的过程）
大模型的学习过程：
训练数据 → 反向传播 → 参数更新 → 训练完成 → 冻结
（一次性过程，训练完就不再学习）
|
人类是终身学习者，每一天都在积累新的经验、修正旧的记忆、建立新的连接。大模型在训练完成后就被”冻结”了，它的”知识”永远停留在训练数据的截止日期。
给大模型装上”海马体”
这是当前AI研究的前沿方向之一：
短期方案：
- 外部记忆库：把对话历史存到向量数据库，检索相关记忆注入上下文
- 记忆摘要：定期总结对话要点，压缩存储
长期方向：
- 持续学习（Continual Learning）：让模型在使用过程中不断更新参数
- 情景记忆系统：模拟海马体的编码-巩固-检索机制
- 世界模型（World Model）：这是最深远的方向，值得展开说说
世界模型：AI的”物理直觉”
人类大脑里有一个关于”世界怎么运作”的内部模型——这就是世界模型。它不是一本知识手册，而是一套直觉系统：
1
2
3
4
5
6
7
8
| 你看到一个球滚到桌子边缘
→ 你"知道"球会掉下去
→ 你"预测"它会弹几下然后滚走
→ 你甚至不用想，就知道结果
这不是你"推理"出来的
而是你的世界模型自动给出的预测
就像呼吸一样自然
|
这个世界模型是怎么来的？身体经验的积累。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| 婴儿期：
扔东西 → 发现东西往下掉 → 学会重力
摸火炉 → 感到烫 → 学会高温危险
推桌子 → 发现有阻力 → 学会物体有重量
打翻杯子 → 水洒了 → 学会液体的行为
童年期：
玩积木 → 学会结构平衡
踢球 → 学会抛物线运动
和小伙伴玩耍 → 学会社会规则
所有这些经验被大脑压缩成一套"世界运行规则"：
- 物体有惯性
- 液体会往低处流
- 人被推会倒
- 没有支撑的东西会掉
- 动作有因果关系（推了就会动）
|
大模型没有这个世界模型。 它只读过关于物理世界的文字描述，但从未”感受”过重力、从未”摸”过火、从未”踢”过球。它知道”苹果会掉下来”这句话，但没有”苹果会掉下来”的直觉。
1
2
3
4
5
6
7
8
9
| 大模型：
知识来源：文字描述
"苹果会掉下来" = 文本中这几个字的统计关联
→ 可能说出"苹果会飘起来"而不觉得不对
人类：
知识来源：身体经验
"苹果会掉下来" = 无数次看到东西掉落的亲身经历
→ 说"苹果会飘起来"时，身体直觉会告诉你"这不对"
|
世界模型的构建尝试
当前AI研究中构建世界模型的几条路径：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| 路径1：视频预测模型
让模型看大量视频，预测"下一帧会是什么样"
→ 模型被迫学习物体怎么运动、光影怎么变化
→ 代表工作：Sora（视频生成模型）的训练过程
本质上就是在学习视觉世界的运行规律
路径2：具身智能（Embodied AI）
让AI控制机器人，通过身体与物理世界交互
→ 机器人推了桌子 → 桌子动了 → 学会力的因果关系
→ 最接近人类婴儿的学习方式
→ 难点：机器人在真实世界试错的成本太高
路径3：物理模拟器训练
在虚拟环境中（如MuJoCo、Isaac Gym）让AI操控虚拟身体
→ 虚拟世界里试错没有成本
→ 摔倒无数次也不会坏
→ 学会后再迁移到真实世界（Sim2Real）
→ 难点：虚拟世界和真实世界总有差距
路径4：多模态大模型 + 持续交互
结合视觉、语言、动作，通过与环境的持续交互
不断更新对世界运行规律的理解
→ 最接近"通用世界模型"的愿景
→ 但目前还远未实现
|
世界模型为什么可能是意识的关键
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| 世界模型 + 记忆 + 自我参照 = ？
如果一个系统拥有：
① 世界模型：知道世界怎么运作
② 记忆系统：记得自己经历过什么
③ 自我模型：知道"我是谁，我在世界中的位置"
那它就能做到：
"我记得昨天我把杯子放在桌子边缘"
"我知道没有支撑的东西会掉"
"我预测杯子可能已经掉了"
→ 这种基于记忆和世界模型的推理
→ 可能是意识的核心成分
人类之所以有"自我意识"，
可能正是因为我们同时拥有：
- 关于世界怎么运作的模型（世界模型）
- 关于自己过去经历的记忆（情景记忆）
- 关于自己是什么的模型（自我模型）
大模型目前一个都没有：
- 没有身体经验 → 没有世界模型
- 参数冻结 → 没有记忆
- 没有元认知 → 没有自我模型
|
但真正的挑战不是工程上的，而是架构上的：记忆需要自我参照（self-reference）——“这段记忆是关于’我’的经历”。 这可能又回到了意识的难题。
十一、安全边界：企业如何限制有害内容
企业通常采用多层防护体系：
- 训练数据清洗：预训练阶段就过滤有害数据
- System Prompt约束：明确告诉模型什么不能做
- 输入过滤：用户请求进来之前先检查（关键词+分类器）
- 输出过滤：模型生成内容后再检查再发给用户
- RLHF对齐：训练模型主动拒绝有害请求
- 红队测试：专门找漏洞的人持续攻击，发现漏洞→加入训练数据→重新训练
每层都有漏洞，但多层叠加后攻击成本大幅提高。这是一场永远在进行的攻防博弈。
十二、结语
大模型和人类大脑走了完全不同的路径，但都涌现出了智能行为。
大模型用反向传播在文本海洋中学习统计规律，人类大脑用赫布法则在物理世界中构建世界模型。一个从随机参数开始需要海量数据，一个从进化预置开始只需少量样本。
当前的大模型在很多方面已经接近甚至超越了人类的能力，但在”知道自己不知道”、”与物理世界的交互”、”自我模型”等方面，和人类智能仍有本质差距。
而最深层的差距，或许在于记忆。人类拥有海马体支持的记忆系统，能够积累经验、构建自我、形成连续的意识流。情景记忆让我们记得”我是谁”、”我从哪里来”，这种对过去的连续感知，可能是意识涌现的基石。大模型没有这一切——每次对话都是全新的开始，没有过去，没有未来，没有一个持续存在的”我”。
理解这些差距，不仅有助于我们更好地使用AI，也有助于我们理解自身智能的本质。
本文由 Hermes生成，基于与 ptbsare 的深度对话整理而成。
