从 RNN 到 Transformer，再到 RWKV：语言模型到底在学什么？

最近这一串问题，其实核心都围绕一个东西：

模型怎么处理“历史信息”。

语言模型要做的事看起来很简单：给它一段前文，让它预测下一个 token。但不同架构的区别就在于：它们到底怎么保存、读取、压缩和利用前面的内容。

1. RNN：带记忆的函数

普通神经网络一般是：

1

输入 x -> 输出 y

RNN 不一样。它多了一个隐藏状态，也就是 memory：

1
2

当前输入 x_t + 上一次记忆 h_{t-1}
-> 当前输出 y_t + 新记忆 h_t

公式上可以写成：

1

h_t = f(x_t, h_{t-1})

这个 h_t 就是 RNN 的核心。

它不是保存完整历史文本，而是把前面读过的内容压缩成一个向量。

比如一句话：

1

我 今天 晚上 想 吃 火锅

RNN 会一个 token 一个 token 地读：

1
2
3
4
5
6

读到“我”      -> 更新记忆
读到“今天”    -> 更新记忆
读到“晚上”    -> 更新记忆
读到“想”      -> 更新记忆
读到“吃”      -> 更新记忆
读到“火锅”    -> 更新记忆

所以 RNN 的本质是：

1

状态机 + 神经网络

它强在省。无论前面有多少 token，它理论上只需要保留一个 state。

但问题也在这里：压缩会丢信息。

如果开头说：

1

小明最讨厌香菜。

中间隔了很多内容，最后问：

1

小明吃火锅不要加什么？

普通 RNN 只能指望那个 h_t 还记得“香菜”。但如果前面内容太长，它很容易忘。

这就是 RNN 的老问题：

1
2
3

长期依赖困难
梯度消失
梯度爆炸

后来 LSTM 和 GRU 出现，本质上就是给 RNN 加了门控机制，让它学会：

1
2
3
4

哪些旧信息要保留
哪些旧信息要忘掉
哪些新信息要写入
当前输出要读多少记忆

所以 LSTM / GRU 不是推翻 RNN，而是改良 RNN 的记忆机制。

2. Transformer：用显存换“可回看历史”

Transformer 和 RNN 最大的区别是：

它不把所有历史压缩成一个 state，而是让当前位置可以直接看历史 token。

RNN 是：

1

所有过去 -> 压缩成 h_t -> 预测下一个

Transformer 是：

1

当前位置 -> 通过 attention 直接访问前面的 token -> 预测下一个

所以 Transformer 更像随身带完整笔记本，需要的时候可以翻前文。

这也是它强的地方。

比如：

1
2

第 1 句：小明讨厌香菜。
第 200 句：他吃火锅时不要加什么？

Transformer 可以通过 attention 直接关注到前面的“香菜”。

RNN 只能靠压缩 state 记住。

但是 Transformer 的代价也很明显：推理时要保存 KV Cache。

每输入一个 token，Transformer 会为它算出：

1
2

Key
Value

然后把这些 K/V 缓存起来。

所以推理时的状态大概是：

1
2
3
4
5

模型参数
+
当前激活
+
KV Cache

上下文越长，KV Cache 越大。

RNN / RWKV 则更像：

1
2
3

模型参数
+
当前 state

这就是区别。

所以你说“Transformer 保留了历史状态，模型更大”，大方向对，但要拆开：

Transformer 不一定参数更多，真正贵的是推理时保存每个历史 token 的 KV Cache。

也就是说：

1
2
3
4
5
6
7
8
9

Transformer:
历史记忆 = 每个 token 都存一份
优点 = 精确回看，不容易忘
缺点 = 贵，KV cache 吃显存

RNN:
历史记忆 = 压缩成一个 state
优点 = 省，适合流式
缺点 = 容易丢细节

3. Transformer 怎么变成语言模型？

Transformer 本身只是一个序列特征处理器。它变成语言模型，需要接上几个东西：

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

原始文本
-> tokenizer
-> token ID
-> embedding
-> position information
-> causal Transformer blocks
-> hidden state
-> vocab head
-> logits
-> softmax
-> next-token probability
-> cross entropy loss

假设训练句子是：

1

我 今天 晚上 想 吃 火锅

训练时会错开一位：

1
2
3
4
5

输入：
我 今天 晚上 想 吃

目标：
今天 晚上 想 吃 火锅

模型每个位置都要预测下一个 token：

1
2
3
4
5

看到“我”              -> 预测“今天”
看到“我 今天”         -> 预测“晚上”
看到“我 今天 晚上”    -> 预测“想”
看到“我 今天 晚上 想” -> 预测“吃”
看到“我 今天 晚上 想 吃” -> 预测“火锅”

GPT 类模型用的是 causal mask，也就是每个位置只能看自己和前面的 token，不能偷看未来。

比如：

1
2
3
4

位置1 只能看 1
位置2 可以看 1,2
位置3 可以看 1,2,3
位置4 可以看 1,2,3,4

没有 causal mask，模型训练时就会直接看到答案，推理就废了。

所以 GPT 可以理解成：

1

GPT = Decoder-only Transformer + Causal Mask + Next Token Prediction

最终，模型输出的是词表上每个 token 的概率。

比如上下文是：

1

我 今天 晚上 想 吃

模型可能输出：

1
2
3
4

火锅：0.31
烧烤：0.19
面条：0.14
代码：0.0008

然后通过采样或贪心选择一个 token，再把它接回上下文，继续预测下一个。

这就是自回归生成。

4. 训练目标：不是背训练集，而是学条件概率分布

语言模型的训练目标通常是：

1

最大化 P(真实下一个 token | 前文上下文)

也就是：

1

给前面的 token，预测下一个 token

训练时用交叉熵 loss：

1
2

正确 token 概率越高 -> loss 越低
正确 token 概率越低 -> loss 越高

关键点是：

训练目标不是“输出和训练集最像的完整句子”，而是在每个上下文后面，给正确下一个 token 更高概率。

这就是为什么模型能输出训练集中没有的句子。

因为它不是从训练集里抽一整句出来，而是逐 token 生成。

训练集中可能有：

1
2
3
4

我喜欢吃苹果
我喜欢吃香蕉
她喜欢吃火锅
他讨厌吃香菜

模型可以生成训练集中未必出现过的：

1

我喜欢吃火锅

因为它学到了组合规律：

1

我喜欢 + 吃 + 火锅

语言是组合系统。有限 token 可以组合出无限句子。

所以 LLM 更像：

1

概率压缩器

而不是：

1

训练集复印机

当然，实话说，模型也会记忆一部分训练数据。尤其是：

1
2
3
4
5
6

高频重复文本
短而固定的事实
代码片段
许可证文本
名言
模板化网页

所以它不是完全不记忆，而是：

1
2

主要学分布和模式
少量记忆具体样本

5. 内插和外推：泛化是有范围的

模型能生成训练集之外的内容，是因为它学会了模式重组。

但这个能力不是无限的。

大概可以分三层：

1
2
3

训练分布内：稳
分布边缘：看模型能力和上下文
分布外：容易胡说

内插 interpolation 是在训练数据覆盖过的区域之间组合。

比如模型见过：

1
2
3
4

Rust
CLI 工具
文件读取
错误处理

你让它写一个：

1

Rust 命令行批量重命名文件工具

这通常比较稳。因为这些东西都在它熟悉的分布附近。

外推 extrapolation 是把学过的规律往未知区域延伸。

比如：

1
2
3
4
5

刚发布的新 API
公司内部业务规则
小众 beta 框架
真实实验结果
最新政策

这种模型就容易把旧模式硬套上去。

幻觉很多时候就是这样来的：

1
2

模型到了分布外
但仍然继续输出“看起来像答案”的 token

它不会天然知道自己不知道。因为底层训练目标是预测下一个 token，不是严格判断真伪。

所以：

1
2
3

内插：把学过的东西重新组合
外推：把学过的规律往未知区域延伸
幻觉：外推失败但语言形式还很像真的

这也是为什么 LLM 解释经典概念、写常见代码、改文案很强；但查最新 API、判断冷门事实、做医疗法律金融决策时，需要工具、数据和验证。

6. RWKV：把 attention 的思想压进 RNN 形式

RWKV 可以理解成：

1
2

像 RNN 一样推理
像 Transformer 一样训练

它全称是：

1

Receptance Weighted Key Value

它想解决的问题是：

1
2

Transformer 强，但 KV Cache 贵
RNN 省，但记忆太糙

所以 RWKV 走中间路线。

普通 RNN 是：

1

h_t = f(x_t, h_{t-1})

它把当前输入和旧记忆混在一起，更新成新状态。

RWKV 更像：

1
2
3
4

当前 token 产生 K / V / R
历史信息按时间衰减累计
R 决定当前要读多少历史
输出 = 门控后的加权历史 value

几个核心组件：

1
2
3
4

R = Receptance，接收门，控制读多少历史
W = Weight / time decay，控制历史信息怎么衰减
K = Key，决定当前信息的重要性
V = Value，真正被累积的内容

所以 RWKV 不是老式 RNN 复活，而是：

1

把 attention 改造成可以递归更新的状态形式

普通 RNN 的历史是：

1

history -> 一个 h

RWKV 的历史更像：

1

history -> 带时间衰减的 K/V 累积状态

这比普通 RNN 更细。

它能让不同通道学习不同的记忆长度：

1
2
3
4

有些信息短期有效
有些信息需要保留很久
有些通道衰减快
有些通道衰减慢

这就像一堆不同半衰期的记忆槽。

所以 RWKV 比普通 RNN 强，主要不是因为“循环”变厉害了，而是因为它的 state 更新方式更像 attention。

7. RWKV 和 Transformer / RNN 的位置

可以这么对比：

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

普通 RNN:
历史被压缩进一个 hidden state
省，但容易忘

LSTM / GRU:
加入门控机制
比普通 RNN 更会保留和遗忘

Transformer:
保留每个历史 token 的 K/V cache
强，但贵

RWKV:
用可学习时间衰减 + K/V 累积 + Receptance 门控
把 attention 思想压缩进 RNN state
推理省，训练又能并行

RWKV 的卖点是：

1
2
3
4
5

无传统 KV Cache
推理 state 小
适合流式生成
适合长上下文低显存场景
训练可以并行化

但也别神化。

RWKV 没有 Transformer 那种 full attention 的精确回看能力。对于需要精确检索某个很早 token 的任务，纯 RWKV 可能不如 Transformer 稳。

所以本质取舍是：

1
2
3
4
5

Transformer:
用显存换精确历史访问

RNN / RWKV:
用压缩 state 换推理效率

8. 最终心智模型

可以把这几类模型放在一张图里：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

RNN:
我只保留一份滚动摘要

Transformer:
我保留完整历史笔记，需要时直接翻

RWKV:
我也只保留滚动摘要
但这个摘要是 attention 风格的 K/V 衰减状态
比普通 RNN 精细很多

训练目标在 LLM 里基本都一样：

1

给前文，预测下一个 token

差别不是目标，而是：

1
2
3
4
5

历史怎么保存
历史怎么读取
训练能不能并行
推理成本多高
长上下文是否稳定

一句话总结：

RNN 是状态压缩，Transformer 是历史直连，RWKV 是 attention 化的状态压缩。语言模型不是在复印训练集，而是在学习训练数据里的 token 条件概率分布；它能组合出新内容，但内插强、外推弱，越出训练分布越需要验证。