信息论·熵

从「惊讶」到比特 —— 一个关于「不知道」的度量

信息论# 信息论# 熵# 交叉熵# KL散度# 困惑度# 语言模型# 训练

1948 年,香农在《通信的数学理论》里做了一件当时看来相当古怪的事:他给「不知道」定了一个单位。

在此之前,「这条消息有多少信息」是一句没法讨论的话——它是修辞,不是量。此后它变成了一个可以算的数,单位叫比特。

这篇要回答三件事:熵到底在度量什么,它为什么长成那个样子,以及为什么今天每一块 GPU 上下降的那条曲线,本质上都是它在起作用。

必要的背景知识

主要涉及的数学学科:

  • 概率论(随机变量、分布、期望、条件概率)
  • 微积分(对数函数、Jensen 不等式、拉格朗日乘子)

常用的前置知识点:

需要的直觉只有一条:对数是把乘法变成加法的工具。凡是出现「多个独立的东西叠加起来」的场合,对数都会自己冒出来,熵也不例外。

二十个问题

一次提问能砍掉多少可能

我心里想了一个 1 到 8 之间的整数,你来猜。每次我只能回答「是」或「不是」。

最优策略是二分:先问「大于 4 吗」,把 8 种可能砍成 4 种;再砍成 2 种;最后 1 种。三次必中。

如果是 1 到 1024,十次。如果是 1 到 n,\lceil \log_2 n \rceil 次。

这不是巧合。一次「是/否」回答只能落在两个结果之一,所以任何一次提问最多把候选集砍掉一半。k 次提问最多区分 2^k 种情况,反过来,区分 n 种等可能的情况,最少要 \log_2 n 次提问。

这就是「1 比特」的由来:一次公平的抛硬币,正好够回答一个二元问题。

但如果这八个数字不是等概率的呢?假设我心里的数字服从一个奇怪的偏好:选 1 的概率是 50%,其余七个数平分另外 50%。那你第一问就不该问「大于 4 吗」,而该问「是 1 吗」——一半的概率一次就中。平均下来,你的提问次数会远少于 3。

「采用最优提问策略时,平均需要问多少次」,这个数就是熵。

它衡量的是:在你还没被告知答案之前,你对答案的「不知道」究竟有多大。

一条新闻值多少

换一个角度。假设明天早上你看到两条新闻:

  1. 「太阳从东边升起。」
  2. 「你中了五百万。」

哪条信息量大?

显然是第二条。但为什么?不是因为第二条字数多,也不是因为它更重要,而是因为它在听到之前几乎不可能。第一条在你读它之前就已经知道了,读完之后你知道的东西没有增加;第二条把一件概率约为 1/17721088 的事情变成了事实,一下子排除了两千万种「本来可能」的世界。

所以信息量与概率反向相关:一件事越不可能,它发生时携带的信息越多。

把这句话写成函数。设事件 x 的概率为 p(x),定义它的自信息(self-information):

I(x) = -\log p(x)

概率为 1 的必然事件,自信息为 0——太阳升起的那条新闻,价值是零比特。概率为 1/2 的事件,自信息为 1 比特。双色球中头奖的自信息是 \log_2 17721088 \approx 24.08 比特:这个信息量相当于一次性猜中 24 枚公平硬币的全部结果。

三条公理与一个对数

为什么是 -\log p 而不是别的?因为只要你对「信息量」这件事有三条几乎无法拒绝的期待,函数形式就被钉死了。

公理一(只依赖概率)。 信息量只由事件发生的概率决定,与其他任何属性无关。记作 I(p)。

公理二(单调)。 概率越小,信息量越大。即 I 是 p 的严格递减函数。

公理三(独立可加)。 两个相互独立的事件同时发生,其信息量等于各自信息量之和:

I(p_1 p_2) = I(p_1) + I(p_2)

第三条是全部要害。它说的其实是「信息应该像长度一样可以相加」:如果你先被告知 A,再被告知 B,而你从 A、B 各自学到的量分别是 I_A、I_B,那么合起来学到的就应该是 I_A + I_B。独立事件的联合概率恰好是 p_1 p_2,而只有对数能把乘法变成加法。

严格一点。令 f(p) = I(p),公理三给出 f(pq) = f(p) + f(q)。做变量替换 p = e^{-s}、q = e^{-t},令 g(u) = f(e^{-u}),则

g(s + t) = g(s) + g(t)

这是柯西函数方程。它需要补一条「g 连续」的温和假设才能唯一求解——否则在实数上可以构造出病态的 Hamel 基解,那不是我们能用的函数。补上连续性后,解只剩线性函数 g(u) = ku。代回去:

I(p) = f(p) = g(-\ln p) = -k \ln p

k 是一个正常数,选它就等于选单位。信息量的函数形式不是被发明的,是被「可加性」逼出来的。

顺便说一句,这条推导解释了为什么熵的公式里必然出现对数:不是因为对数好算,而是因为世界是可加的,而概率是可乘的。

底数:比特、奈特与哈特利

k 取什么,只影响单位:

底数单位换算常见场合
\log_2比特(bit)1 bit通信、压缩、编码
\ln奈特(nat)1 nat = 1/\ln 2 \approx 1.4427 bit机器学习框架的默认值
\log_{10}哈特利(dit)1 dit \approx 3.3219 bit早期电话工程

这个细节在工程里非常重要:PyTorch 的 cross_entropy 输出的单位是奈特,所以困惑度要用 exp 而不是 2 **。混用底数是新手最常见的量纲事故,后面还会专门讲。

熵:平均惊讶

定义

自信息描述的是「某一个结果」,而一个随机变量有很多可能的结果。我们希望有一个数描述整个分布有多难猜,最自然的做法是取期望:

H(X) = \mathbb{E}_{x \sim p}\big[-\log p(x)\big] = -\sum_{x} p(x) \log p(x)

这就是信息熵,简称熵。用大白话说:熵是这个分布下「平均每得到一个结果,你会被惊讶多少」。

三个约定俗成的细节:

  • 0 \log 0 = 0。概率为零的事件不发生,也就不贡献惊讶。
  • 连续情形换成积分 h(X) = -\int p(x)\log p(x)\,\mathrm{d}x,叫微分熵,它可以为负(例如 U(0, 1/2) 的微分熵是 -1 奈特)。离散熵永远非负,微分熵不是——这是两套体系的分界。
  • 熵是分布的泛函,不是随机变量的函数。同一个随机变量换个分布,熵就变。

几个例子

把数字摆出来,直觉会立刻清晰:

分布熵(比特)直觉
公平硬币 p=0.51.000一个二元问题
偏硬币 p=0.90.469连一次抛硬币都不值
公平骰子 1/62.585两次二分不够,三次绰绰有余
极偏硬币 p=0.9990.0114要抛近一百次,才够攒出一次「意外」
均匀分布 $1..1000$9.966十次二分,几乎正好

第三行值得多看一眼:骰子的熵是 2.585 而不是 3。因为三次二元提问能区分 8 种情况,而骰子只有 6 种,最优策略的平均提问次数会略低于 3——它不需要每次都把候选集用满。

第四行的 0.0114 也值得琢磨:抛 88 次这种硬币的总信息量才勉强到 1 比特。反过来,如果有人连续 88 次都猜错,那才叫奇迹——概率只有 0.001^{88} \approx 10^{-264},比连中两次头奖还离谱。熵小,意味着「出错的方式」本身就极其稀有。

熵不是样本的属性

这里要划一条界线,因为它是最常见的混淆源。

熵描述的是分布,不是样本。给定一个分布,熵是一个确定的数;给定一个具体的观测序列,你没有「这个序列的熵」这种东西——你只有它的自信息-\log p(x),也就是这个具体结果有多令人惊讶。

工程上经常出现「经验熵」:拿一批样本统计频率 \hat{p},再算 -\sum \hat{p}\log\hat{p}。那是对分布的估计,不是样本本身的属性。样本量不够时,这个估计会系统性偏低(见后文的误解清单)。

熵的五张面孔

同一样东西,从五个方向看,会看到五种完全不同的样子。这五张面孔彼此等价,但每一张都打开一扇不同的门。

flowchart TD P["概率分布 p(x)"] --> H["熵 H(p)"] H --> A["统计视角<br/>平均惊讶 E[-log p]"] H --> B["编码视角<br/>最优平均码长"] H --> C["几何视角<br/>典型集的对数体积"] H --> D["物理视角<br/>S = k ln W"]

第一张面孔:平均惊讶

这是定义本身,前面已经说了。它的用处是算:拿到一个分布,直接代公式。

第二张面孔:不确定性的体积

熵度量的是「你还不知道的东西有多少」。这句话在两种极端下最清楚:

  • 如果你已经知道答案(分布退化成一点),熵是 0:你的「不知道」是空的。
  • 如果所有答案等可能,熵是 \log n:你的「不知道」有 n 个面。

中间状态就是「知道一点,但不多」。熵把「不多」量化了。

有一个容易被忽略的推论:熵不是你面对的系统固有属性,而是「你」与「系统」之间关系的属性。同一枚硬币,对一个已经看过结果的观察者来说熵是 0,对你来说熵是 1 比特。这个视角是贝叶斯学派的立场(Jaynes 尤其坚持),后文「尾声」还会回到它。

第三张面孔:最短码长

假设你要把大量英文文本压成二进制。你有一套字母表,需要给每个字符分配一串 0/1。

如果 26 个字母等可能,那最省事的办法是等长编码,每个字母 \lceil \log_2 26\rceil = 5 比特。但英文字母并不等可能:e 出现频率约 12.7%,z 只有 0.07%。于是你可以让 e 用 3 比特,让 z 用 11 比特,平均下来就能低于 5 比特。

那么,平均码长的下界是多少?

香农的回答是熵。信源编码定理(无噪声编码定理):对服从分布 p 的符号做前缀编码,最优的平均码长 L 满足

H(p) \le L < H(p) + 1

下界不能突破,上界由 Huffman 编码达到(最多浪费 1 比特);算术编码则能把这个差距压到任意小。

这就是熵被称为「压缩极限」的原因。它不是一个抽象的不确定性度量,而是一个物理上不能突破的比特数。

拿英文做个标定。26 个字母等概率时熵是 \log_2 26 \approx 4.7 比特/字符;按真实字母频率算是 4.1 比特;考虑二元组降到 3.3;而香农 1951 年让人做预测实验,估计出真实英文的熵大约在 0.6 到 1.3 比特/字符之间。也就是说,一个 100 万字符的英文文本,理论上可以压到 100 KB 上下——而 1951 年没有任何压缩软件能做到这一点,因为达到这个极限需要「理解」英文。这句话在七十年后会变成一个惊人的预言,后文会讲。

第四张面孔:典型集

换一个几何角度。

抛 1000 次偏硬币(正面概率 0.9)。总共有 2^{1000} \approx 10^{301} 种可能的结果序列。这个数字大得荒唐,但绝大多数序列都不会出现——因为「正面大约占 90%」这件事几乎必然成立。

更精确地说:所有序列里,正面比例接近 0.9 的那些序列占了压倒性的概率质量,它们的个数约为

2^{nH(p)} = 2^{1000 \times 0.469} \approx 2^{469} \approx 10^{141}

于是出现了一个奇观:理论上可能的世界有 10^{301} 个,实际会发生的只有 10^{141} 个。熵就是**「实际会发生的那些世界」的对数体积**。

这个结论叫渐近均分性(AEP):对独立同分布的序列,几乎所有概率都集中在「典型集」上,而典型集的大小是 2^{nH}。

它有两个直接后果:

  1. 压缩为什么可能:你不需要为 10^{301} 种序列准备编码,只需为 10^{141} 种准备,剩下的可以随便糊弄——它们不会出现。压掉的 160 个数量级,就是熵的功劳。
  2. 为什么「高维空间是空的」:在 n 维的超立方体里,概率质量并不均匀铺开,而是缩在一个低维的薄壳上。机器学习里的流形假设(《智械起源》讲过)在信息论里的对应物,就是典型集。

第五张面孔:物理熵

1865 年克劳修斯引入熵,1877 年玻尔兹曼给出统计解释:

S = k_B \ln W

W 是宏观状态对应的微观状态数。这个公式和信息熵长得几乎一模一样:

H = -\sum_i p_i \ln p_i

当分布均匀(p_i = 1/W)时,H = \ln W——两者只差一个常数 k_B。这不是巧合,而是同一个数学结构在两个领域的投影:都是在数「有多少种等价的实现方式」。

两者的差别在于解释:

  • 物理熵是系统的属性,描述的是「这个宏观状态对应多少微观排列」;
  • 信息熵是观察者的属性,描述的是「我对这个系统的知识还剩多少缺口」。

这两个视角在 20 世纪被一系列思想实验缝合起来,最著名的是麦克斯韦妖:一个足够聪明的妖能分辨快慢分子,只放快的往一边去,于是不做功就把系统分成了冷热两半——第二定律似乎被打破了。

破解的关键在 1961 年由 Landauer 给出:擦除 1 比特信息,至少要耗散 k_B T \ln 2 的能量。室温下这个数是 2.87 \times 10^{-21} 焦耳,小得可以忽略,但它不是零。妖要持续工作,就必须不断擦除记忆,而擦除的代价正好抵消它「赚」到的熵减。信息不是免费的,它有物理价格。

这条线索今天还在延伸:可逆计算、Landauer 极限下的芯片功耗、以及「信息是物理的」这一整套观点,都是从「熵」这个字出发的。

熵的性质

四条性质,后面反复要用。

非负与上界

离散熵恒非负:

H(X) \ge 0

等号成立当且仅当分布是确定性的(某个结果概率为 1)。

上界是「均匀分布」:

H(X) \le \log |\mathcal{X}|

等号成立当且仅当 p 在支撑集上均匀。

证明只有一行,用的就是 Jensen 不等式:

H(X) = \sum_x p(x) \log \frac{1}{p(x)} \le \log \sum_x p(x)\cdot\frac{1}{p(x)} = \log |\mathcal{X}|

(Jensen 不等式:\log 是凹函数,所以 \mathbb{E}[\log Y] \le \log \mathbb{E}[Y]。)等号条件也一目了然:只有 1/p(x) 恒为常数,即 p 均匀。

也可以反过来用拉格朗日乘子做:在约束 \sum p_i = 1 下最大化 -\sum p_i \ln p_i,构造

\mathcal{L} = -\sum_i p_i \ln p_i + \lambda\left(\sum_i p_i - 1\right)

对 p_i 求偏导并令其为零,得 -\ln p_i - 1 + \lambda = 0,即所有 p_i 相等。这与「直觉上最不可猜的分布就是均匀分布」完全一致。

凹性

熵是分布的凹函数:

H\big(\lambda p + (1-\lambda) q\big) \ge \lambda H(p) + (1-\lambda) H(q)

直觉:把两副偏好不同的骰子按比例混合,你会更难猜结果。混合让分布更平坦,平坦就是熵更大。

这条性质解释了一个常见的工程现象:集成(ensemble)与专家混合(MoE)的输出分布,倾向于比单个成员更高熵。不是因为它们更「聪明」,而是因为它们把多个猜测平均了,平均会摊平概率。

可加性

若 X \perp Y,则

H(X, Y) = H(X) + H(Y)

因为 p(x,y) = p(x)p(y),对数把它拆成两项之和,期望再拆开。

这条性质是熵之所以叫「熵」而不是「某种指数」的根本原因:它可加。两个独立系统的总不确定性,等于各自不确定性之和。

一个表格总结

性质数学形式直觉
非负H \ge 0「不知道」不能是负数
上界H \le \log|\mathcal{X}|最不可猜的是均匀
确定性为 0p=\delta_x \Rightarrow H=0已知的事没有惊讶
凹性H(\lambda p + (1-\lambda)q) \ge \lambda H(p)+(1-\lambda)H(q)混合让事情更难猜
独立可加X \perp Y \Rightarrow H(X,Y)=H(X)+H(Y)两个独立的谜语,难度相加

从一到多:联合、条件与互信息

现实里的随机变量很少孤零零。熵理论真正的力量,在于它能描述「多个变量之间共享了多少信息」。

链式法则

联合熵定义为

H(X, Y) = -\sum_{x,y} p(x,y)\log p(x,y)

把 p(x,y) = p(x)p(y|x) 代进去,用对数的乘法转加法,立刻得到链式法则:

H(X, Y) = H(X) + H(Y \mid X) = H(Y) + H(X \mid Y)

其中条件熵定义为

H(Y \mid X) = \sum_x p(x) H(Y \mid X = x) = -\sum_{x,y} p(x,y)\log p(y|x)

读法是:先花 H(X) 比特描述 X,再花 H(Y|X) 比特描述「已知 X 之后 Y 还剩的不确定性」,两者相加就是联合熵。

互信息

既然 H(X,Y) 有两种拆分方式,把两式相减就得到一个对称的量:

I(X; Y) = H(X) - H(X \mid Y) = H(X) + H(Y) - H(X, Y)

这就是互信息:知道 Y 之后,关于 X 的不确定性减少了多少。也就是「Y 里含有多少关于 X 的信息」。

三个性质:

  • 对称:I(X;Y) = I(Y;X)。信息是双向的,没有「谁告诉谁」的方向。
  • 非负:I(X;Y) \ge 0,等号当且仅当 X 与 Y 独立。知道点什么总比什么都不知道强——至少不会更差。
  • 有界:I(X;Y) \le \min\{H(X), H(Y)\}。共享的信息不可能超过任何一方自身的不确定性。

用维恩图记最方便:把 H(X)、H(Y) 画成两个圆,交集是 I(X;Y),并集是 H(X,Y),左边月牙是 H(X|Y),右边月牙是 H(Y|X)。

区域含义公式
左圆X 的不确定性H(X)
右圆Y 的不确定性H(Y)
交集共享的信息I(X;Y)
并集两者合起来的不确定性H(X,Y)
左月牙只有 X 知道、Y 不知道的H(X\mid Y)
右月牙只有 Y 知道、X 不知道的H(Y\mid X)

数据处理不等式

这是信息论里最重要的一条「守恒律」。

若 X \to Y \to Z 构成马尔可夫链(给定 Y 时,Z 与 X 条件独立),则

I(X; Z) \le I(X; Y)

读法:对数据做的任何处理,都不会增加关于原始变量的信息,只会损失。 特征提取、降维、量化、加噪、压缩、模型前向传播——全都在这条不等式的管辖之下。

这解释了很多经验:

  • 为什么「特征工程」不能凭空创造信息,只能把已有的信息重新排列得更易于提取;
  • 为什么再深的网络也无法恢复被预处理毁掉的信息(如过度归一化、过度下采样);
  • 为什么「信息瓶颈」方法有效:它显式地在「保留 I(X;Z)」与「压缩 I(Y;Z)」之间做权衡。

一个反直觉的细节

「条件作用降低熵」是平均意义上的结论:

H(X \mid Y) \le H(X)

但对某一次具体观测,后验熵完全可能高于先验熵。

举个能算的例子。设 X 以 0.9 的概率取 0、0.1 的概率取 1,先验熵是 0.469 比特。现在有一个很弱的报警器 Y:X=0 时误报率 1%,X=1 时命中率 9%。报警发生的概率只有 1.8%。

一旦报警真的响了,算一下后验:

P(X=0 \mid Y=1) = \frac{0.9 \times 0.01}{0.9\times 0.01 + 0.1 \times 0.09} = 0.5

后验变成了 0.5/0.5,熵是 1 比特——比先验的 0.469 还高。因为这台报警器太不可靠:它一响,反而把「大概率是 0」这个先验抹平了,你对 X 的认知变得更模糊。

但把两种观测加权平均:

H(X \mid Y) = 0.018 \times 1.0 + 0.982 \times 0.445 = 0.455 < 0.469

平均下来熵还是降了。这就是「信息」的诚实之处:单个观测可能误导你,但平均而言,观测不会让你更无知。 这也是为什么评价一个信号要看整体而非个例。

交叉熵:当分布猜错时

前面所有内容都假设你知道真实分布 p。但现实是:你不知道 p,你只有对 p 的猜测 q。

这就是机器学习的处境。模型输出的是 q,世界运行的是 p。问题变成:用错误的分布 q 去描述真实的 p,代价是多少?

定义

交叉熵:

H(p, q) = -\sum_x p(x) \log q(x) = \mathbb{E}_{p}\big[-\log q(x)\big]

注意两个分布的分工:期望在 p 上取,对数在 q 里算。这行公式的含义是:「世界按 p 出牌,而你按 q 下注,平均每次要付出多少惊讶。」

如果 q 在某个 p 有质量的地方给出接近 0 的概率,-\log q 会爆炸——这就是「自信地错」的代价。它没有上界。

KL 散度(相对熵)则度量「多付了多少」:

D_{\mathrm{KL}}(p \,\|\, q) = \sum_x p(x) \log \frac{p(x)}{q(x)} = \mathbb{E}_p\left[\log \frac{p(x)}{q(x)}\right]

两者只差一个熵:

H(p, q) = H(p) + D_{\mathrm{KL}}(p \,\|\, q)

推导一行:

H(p,q) = -\sum p\log q = -\sum p\log p + \sum p\log\frac{p}{q} = H(p) + D_{\mathrm{KL}}(p\|q)

Gibbs 不等式

KL 散度非负,这是信息论的基石之一:

D_{\mathrm{KL}}(p \,\|\, q) \ge 0, \qquad \text{等号当且仅当 } p = q

证明用 Jensen(\log 凹):

-D_{\mathrm{KL}}(p\|q) = \sum_x p(x)\log\frac{q(x)}{p(x)} \le \log \sum_x p(x)\cdot\frac{q(x)}{p(x)} = \log \sum_x q(x) = 0

所以 D_{\mathrm{KL}} \ge 0。等号条件是 q(x)/p(x) 在 p 的支撑集上为常数,配合归一化即得 p=q。

由此立刻得到交叉熵的下界:

H(p, q) \ge H(p)

任何猜测都不会比真相本身更省惊讶。 等号当且仅当猜对。

这条不等式还有一个漂亮的解释:H(p) 是「数据本身的熵」,也就是任何模型都无法突破的损失下界。语言模型再强,loss 也不会低于语料的真实熵。

为什么是交叉熵而不是 KL

既然 H(p,q) = H(p) + D_{\mathrm{KL}},而 H(p) 与模型参数无关,最小化交叉熵与最小化 KL 在数学上等价。那为什么工程上普遍写交叉熵?

三个理由:

  1. 数据侧不需要知道 p 的熵。 你只有样本,没有解析的 p。交叉熵可以直接用样本估计(就是负对数似然的平均),KL 则需要先估 H(p)——多一层估计,多一层误差。
  2. one-hot 标签下两者完全相同。 分类任务里 p 是 one-hot,H(p)=0,所以 H(p,q) = D_{\mathrm{KL}}(p\|q) = -\log q(y)。这是最常见的情形,此时两个名字指的是同一个数。
  3. 与最大似然等价。 设数据集给出经验分布 \hat{p},最小化 H(\hat{p}, q_\theta) 就是最大化 \sum_i \log q_\theta(x_i),即最大似然。最大似然 = 最小交叉熵 = 最小 KL 到经验分布,这三个说法是同一件事的三种语言。

第三点值得强调:它把「统计学」和「信息论」缝在了一起。统计学家说「最大似然」,信息论者说「最小交叉熵」,几何学家说「把模型分布推向经验分布」——同一座山,三条上山的路。

不对称的两个方向

KL 不是距离。它不对称:

D_{\mathrm{KL}}(p \,\|\, q) \ne D_{\mathrm{KL}}(q \,\|\, p)

也正因如此,它不满足三角不等式,不能叫「距离」。这个不对称不是缺陷,而是一个语义开关。

想象真实分布 p 是双峰的(比如「猫」和「狗」两类样本),而你只能用单峰的高斯 q 去拟合。

前向 KLD_{\mathrm{KL}}(p\|q):在 p 有质量的地方,q 必须也有质量,否则 \log(p/q) 会爆炸。于是 q 会把两个峰都覆盖住,落在两峰之间、把概率摊平——它不敢漏掉任何一个模式。这叫 mean-seeking(质量中心化)。

反向 KLD_{\mathrm{KL}}(q\|p):在 q 有质量的地方,p 必须也有质量。于是 q 会收缩到其中一个峰上,绝不敢横跨两个峰之间的低概率谷地。这叫 mode-seeking(模式寻求)。

同一个双峰问题,两个方向给出完全不同的答案:

方向惩罚什么行为典型用途
D_{\mathrm{KL}}(p|q)q 漏掉 p 的质量覆盖所有模式,摊平最大似然、变分推断、监督学习
D_{\mathrm{KL}}(q|p)q 在 p 无质量处放质量锁定单个模式,锐利变分推断的另一种写法、RL 策略约束

这个区别在生成模型里至关重要:用前向 KL 训出来的模型倾向于「面面俱到但每样都不精」,用反向 KL 训出来的模型倾向于「抓住一样,说得斩钉截铁」。人味与多样性之间的取舍,从损失函数的方向就决定了。

梯度的形状

交叉熵最漂亮的地方在梯度。

设模型输出 logits z,概率 q = \mathrm{softmax}(z),真实标签是 y(one-hot)。损失

L = -\log q_y = -z_y + \log \sum_j e^{z_j}

对 z_j 求偏导:

\frac{\partial L}{\partial z_j} = -\,\mathbb{1}[j = y] + \frac{e^{z_j}}{\sum_k e^{z_k}} = q_j - \mathbb{1}[j = y]

写成向量形式:

\nabla_z L = q - y

梯度就是「预测减真值」。 没有额外的因子,没有饱和区,形式简单到令人愉快。

这个形式的含义是:模型在某个类上多给了 q_j 的概率,梯度就把它往下压 q_j;真值那一类少给了 1 - q_y,梯度就把它往上抬 1-q_y。误差信号的大小恰好等于错误的大小——这解释了为什么交叉熵配 softmax 是分类任务的标准配置,也解释了为什么它比「平方误差 + sigmoid」收敛快得多(后者的梯度里会多出一个 \sigma' 因子,在饱和区趋近于 0)。

实测一下(后面「算一遍」一节有完整代码):

texttext
softmax: tensor([0.8438, 0.1142, 0.0420])   # 模型预测grad   : tensor([0.8438, -0.8858, 0.0420])  # 梯度 = 预测 - onehot(1) 

第二项是 0.1142 - 1 = -0.8858,其余两项与预测完全相同。梯度直接告诉我们「该往哪个方向挪多少」。

训练场上的熵

前面六节都在讲「熵是什么」。从这一节开始,讲它在人工智能里到底在干什么。

一句话概括:今天几乎所有主流模型的训练目标,都可以写成某种形式的交叉熵;而所有关于「模型学到什么程度」的讨论,本质上都是在讨论它把数据的熵压到了多低。

语言模型:一个被摊平成分类的预测问题

自回归语言模型做的事情只有一件:给定上下文 c = (x_1, \dots, x_{t-1}),在词表 \mathcal{V} 上输出一个分布

q_\theta(\cdot \mid c) = \mathrm{softmax}\big(f_\theta(c)\big)

下一个 token 的真实值是 y。把 y 写成 one-hot 分布 p = \delta_y,损失就是这两个分布的交叉熵:

L = H(p, q_\theta) = -\sum_{v \in \mathcal{V}} p(v)\log q_\theta(v \mid c) = -\log q_\theta(y \mid c)

一个 |\mathcal{V}| = 6400 的分类问题,被压缩成了一个标量。对整个语料取平均:

\bar{L} = -\frac{1}{N}\sum_{i=1}^{N} \log q_\theta(y_i \mid c_i) = H(\hat{p}, q_\theta)

其中 \hat{p} 是语料的经验分布。这就是「训练 loss」的全部含义:模型分布与语料经验分布之间的交叉熵。

由此得到一个冷冰冰的结论:loss 有下界,而且这个下界是数据本身的熵 H(\hat{p})。 你不可能通过更好的架构、更多的数据、更久的训练,把 loss 压到语料的真实熵以下——除非你开始背答案(过拟合),那样训练集 loss 会掉下去,但它衡量的是记忆,不是理解。

loss 的绝对尺度:一个必须知道的基线

初学者最容易犯的错,是看到 loss 从 3.2 掉到 2.8 就以为模型在学,却不知道 3.2 到底是好是坏。

给一个绝对基线。如果模型对词表一无所知、输出均匀分布,那么

L_{\text{uniform}} = \ln |\mathcal{V}|
词表大小均匀基线的 loss(nat)折合比特
64008.7612.64
5025710.8215.62
15206411.9317.21

所以:一个 50257 词表的模型,训练开始时 loss 应该接近 10.82;如果它一开始就是 3 左右,那说明初始化把概率堆到了某些 token 上,而不是模型「已经学会了」。 反过来,loss 长期高于这个基线,说明训练根本没有启动。

我见过一次典型的初始化事故:词表 6400,理论上初始 loss 应该接近 8.76,实际训练曲线上第一行是 1824。

原因不复杂:embedding 与输出层共享权重(tied embedding),而权重用标准正态 N(0,1) 初始化。输入经过 d=512 维的点积后,logits 的标准差大约是 \sqrt{512} \approx 22.6。softmax 在这个尺度下已经尖得只剩一根针——模型几乎把 100% 的概率押在某一个 token 上。只要这个 token 不是正确答案,

-\log q(y) \approx 22 \sim 45

单步损失就已经是基线的数倍。而 1824 说明 logits 的尺度更大:某些位置的概率低到了 e^{-1824} 这种量级。

这个事故有三层教训,每一层都和熵有关:

  1. 交叉熵没有上界。 它可以用 -\log q 把「自信地错」惩罚到无穷。平方误差不会这样,所以它训练分类任务时反而更「温柔」,也更慢。
  2. loss 的绝对值必须先对照基线。 8.76 是 6400 词表的地板,1824 是 208 倍地板——这不是「模型差」,这是「数值坏了」。
  3. 初始化决定 logits 的尺度,logits 的尺度决定初始熵。 一个健康的初始化,应该让初始输出分布的熵接近 \ln|\mathcal{V}|(即「均匀地不知道」),而不是接近 0(即「自信地胡说」)。这就是为什么 GPT-2 在初始化时把残差层的权重按 1/\sqrt{N} 缩放、输出层再额外按 1/\sqrt{2N} 缩放(N 为残差层数):让残差累加后的方差保持在 1 附近,别让 logits 爆炸。

用信息论的语言说:好的初始化,是让模型一开始处于「最大熵」状态——对所有答案一视同仁。 训练做的事,是逐步把这份熵换成知识。

困惑度:模型在多少个词之间犹豫

困惑度(perplexity,PPL)是交叉熵的指数形式:

\mathrm{PPL} = \exp(\bar{L}) \quad (\bar{L} \text{ 以 nat 计}), \qquad \mathrm{PPL} = 2^{\bar{L}} \quad (\bar{L} \text{ 以 bit 计})

它有一个漂亮的解释:如果模型在每一步都在 k 个等概率的选项之间犹豫,那么它的困惑度就是 k。

验证一下:均匀分布在 |\mathcal{V}| 个 token 上,\bar{L} = \ln|\mathcal{V}|,\mathrm{PPL} = |\mathcal{V}|——完美对应「在全部词表里瞎猜」。而 \mathrm{PPL} = 1 意味着模型每次都以概率 1 猜中,即零困惑。

几个标定点:

交叉熵(nat)困惑度含义
8.7664006400 词表上完全随机
4.0054.6相当于在 55 个词里犹豫
2.3110.1相当于在 10 个词里犹豫
1.002.72大多数时候只有两三个候选
0.001.00完美预测

但困惑度有一个致命的工程缺陷:它依赖 tokenizer。同一个模型、同一段文本,换一套分词器,token 数变了,PPL 就变了。所以跨模型、跨分词器比较时,正确做法是换算成每字节比特数(bits per byte,BPB):

\mathrm{BPB} = \frac{\bar{L} \text{(nat)}}{\ln 2 \times \text{每 token 平均字节数}}

字节数不随分词器变化,所以 BPB 是可比的。这也是为什么严肃的模型报告(以及 Scaling Law 论文)通常同时给出 PPL 和 BPB——前者直观,后者可比。

温度:熵的旋钮

模型输出的 logits 可以人为缩放:

q_i(T) = \frac{e^{z_i / T}}{\sum_j e^{z_j / T}}

T 叫温度。它对熵的影响是单调的:

  • T \to 0:分布塌成 one-hot,H \to 0,模型永远选概率最大的那个;
  • T = 1:原始分布;
  • T \to \infty:分布趋于均匀,H \to \ln|\mathcal{V}|,模型开始胡说。

实测一组(logits 为 [2.0, 1.0, 0.5, 0.0],4 个候选,熵的上界是 2 bit):

温度 T熵(bit)最大概率
0.10.00071.0000
0.50.85850.8310
1.01.60110.5793
2.01.89550.4087
10.01.99600.2790
100.02.00000.2528

看第一行和最后一行:温度从 0.1 拉到 100,模型输出分布的熵从 0.0007 bit 涨到 2 bit,涨了三千倍。但模型的「知识」一点没变——softmax 是单调的,T 不改变 logits 的排序,只改变分布的平坦程度。温度不改变模型相信什么,只改变它敢不敢说。

这也解释了采样策略在干什么:

  • top-k:只保留概率最高的 k 个 token,其余置零。这是硬性降熵,把尾巴直接砍掉。
  • top-p(nucleus):保留累积概率达到 p 的最小集合。这是自适应降熵——模型确定时集合小,模型犹豫时集合大。
  • repetition penalty:把已出现 token 的 logits 压低。这不是降熵,是改变分布的形状,把质量从「重复」搬到「新鲜」。

顺带一个有用的观察:生成过程中,每个位置的熵是不一样的。 句首(「很久很久以前,」之后)熵很高——故事可以往任何方向走;而固定搭配处(「床前明月光」之后的「疑」)熵极低,模型几乎确定。把逐 token 的熵画成曲线,能直观看到模型在哪里「有把握」、在哪里「在编」。这也是用熵做幻觉检测的基本思路:高熵位置是模型最可能编造的地方。

知识蒸馏:把熵从教师搬到学生

一个训练好的大模型,输出分布里藏着比标签更多的信息。

如果一张图里是「狗」,硬标签只告诉学生「这是狗」,而教师的软输出可能说:狗 0.9、狼 0.08、猫 0.015、汽车 10^{-6}。「狼比汽车更像狗」这个结构,是硬标签里没有的——Hinton 把它叫做「暗知识」(dark knowledge)。

蒸馏的做法是让学生去拟合教师的分布:

L = D_{\mathrm{KL}}\big(p_t^{(T)} \,\|\, p_s^{(T)}\big) = \sum_v p_t^{(T)}(v)\log\frac{p_t^{(T)}(v)}{p_s^{(T)}(v)}

两个细节都和熵有关:

其一,为什么要升温。 教师 logits 为 [5, 2, 1] 时,T=1 下的分布是 [0.936, 0.047, 0.017]——后两类的概率小到梯度几乎没有信号,「2 比 1 更像 5」这条信息被埋掉了。而 T=4 下分布变成 [0.543, 0.257, 0.200],三类都在同一量级,负类之间的相对关系清晰可见。升温不是为了让分布「更平滑好看」,是为了把暗知识从概率的指数尾巴里捞出来。

其二,为什么梯度要乘 T^2。 对 logits 求导时,1/T 会从 softmax 里带出来,平方之后就是 1/T^2。为了让不同温度下的梯度尺度可比,标准实现会把损失乘以 T^2。这是个纯粹的工程细节,但漏掉它,蒸馏会莫名其妙地学不动。

还有一个方向问题:标准蒸馏用的是 D_{\mathrm{KL}}(p_t \| p_s),教师在前。按前面的分析,这是前向 KL,学生必须覆盖教师所有有质量的地方——它学的是「教师的完整信念」,而不是「教师最响亮的那个答案」。这与「学生要比教师小,但别丢太多」的直觉是一致的。

强化学习:熵奖励与熵坍缩

在策略梯度方法里,策略本身就是一个分布 \pi_\theta(a \mid s)。它的熵

H(\pi_\theta(\cdot \mid s)) = -\sum_a \pi_\theta(a\mid s)\log \pi_\theta(a \mid s)

衡量的是「这个策略有多犹豫」。于是熵变成了一个可以直接加进目标函数的东西:

J(\theta) = \mathbb{E}\left[\sum_t r_t + \beta H\big(\pi_\theta(\cdot \mid s_t)\big)\right]

这叫熵正则。\beta 是权重,它的作用是把「探索」写进优化目标:如果只按回报优化,策略会很快收敛到当前看起来最好的动作,然后不再尝试别的——过早收敛到局部最优。熵奖励相当于给「保持犹豫」发工资。

不加这一项会发生什么?熵坍缩(entropy collapse):策略分布越来越尖,最后变成确定性策略。此时梯度也趋于零(采样只出一条轨迹,优势估计的方差消失),训练彻底停滞。这是 RL 里最常见的失败模式之一,诊断方法就是盯着策略熵曲线——它应该是缓慢下降的,如果几十步之内就掉到 0.01 以下,那就是崩了。

几个具体位置:

  • SAC(Soft Actor-Critic)把最大熵写进了理论框架:目标不是最大化回报,而是最大化「回报 + 熵」,\alpha 还可以自适应调整。
  • PPO 里有一个 ent_coef 超参,通常取 0.01 左右,并随训练衰减。
  • RLHF 里则要区分两个东西:对参考模型的 KL 惩罚D_{\mathrm{KL}}(\pi_\theta \| \pi_{\text{ref}}) 不是熵奖励,它的作用是防止策略为了骗奖励模型而偏离得太远(reward hacking);而策略熵的下降是优化本身的自然结果,需要监控但不需要鼓励。

分清这两者很重要:KL 惩罚约束的是「离起点多远」,熵奖励鼓励的是「别太确定」。 一个管位置,一个管形状。

对比学习:InfoNCE 是互信息的下界

自监督学习里最核心的损失之一,形式是这样的:

L_{\text{InfoNCE}} = -\log \frac{\exp\big(\mathrm{sim}(q, k_+) / \tau\big)}{\sum_{j=1}^{N}\exp\big(\mathrm{sim}(q, k_j)/\tau\big)}

看起来像一个 softmax,它就是一个 softmax:把 N 个候选(1 个正样本 + N-1 个负样本)当成 N 类分类问题,正确答案是正样本,损失就是交叉熵。

它的信息论意义由 Oord 等人在 CPC 论文里给出:

I(q; k_+) \ge \log N - L_{\text{InfoNCE}}

也就是说,最小化 InfoNCE 就是在最大化互信息的下界。这解释了对比学习的几个经验事实:

  • batch 越大越好:N 越大,下界 \log N - L 越紧,估计越接近真实的互信息。
  • 温度 \tau 控制难度:\tau 小,分布尖锐,梯度集中在最难的负样本(hard negative)上;\tau 太小则容易数值不稳、训练崩塌。SimCLR 里 \tau = 0.07 是常用值。
  • 负样本的质量决定学到什么:负样本越「像」正样本,任务越难,能挤出的互信息越多。这与「熵越高越难猜」是同一件事的两面。

顺带说一句:MoCo 用队列维护大量负样本,本质上是在不增加 batch 的前提下把 N 做大,也就是把互信息下界收紧。

变分推断:ELBO 里的两项博弈

变分自编码器(VAE)与扩散模型的理论骨架都是同一条不等式。对观测 x 和隐变量 z:

\log p(x) = \underbrace{\mathbb{E}_{q(z\mid x)}\big[\log p(x\mid z)\big] - D_{\mathrm{KL}}\big(q(z\mid x)\,\|\,p(z)\big)}_{\text{ELBO}} + D_{\mathrm{KL}}\big(q(z\mid x)\,\|\,p(z\mid x)\big)

最后一项非负(Gibbs 不等式),所以 ELBO 是 \log p(x) 的下界。最大化 ELBO 就是最大化数据的对数似然——又一次回到「最小交叉熵」。

ELBO 的两项在打架:

  • 重建项要求 q(z|x) 携带足够多的信息,能把 x 还原出来;
  • KL 项要求 q(z|x) 靠近先验 p(z),也就是别携带太多信息。

这是一场关于「压缩率」的谈判:隐变量 z 的通道容量有限,多少比特用来记住 x 的细节,多少比特留给先验的规整性。\beta-VAE 就是给 KL 项乘一个 \beta 来调这个天平:\beta 大,压缩狠,学到的表示更解耦;\beta 太大,就出现 posterior collapse——KL 项被压到 0,q(z|x) 退化成先验,解码器干脆无视 z,模型退化成普通的自编码器。文本 VAE 尤其容易塌,因为自回归解码器太强,不需要 z 也能把文本重建出来。

扩散模型只是把「一层隐变量」换成了「一条马尔可夫链」,ELBO 变成对每一步去噪的求和。骨架没变:每一层都在用 KL 度量「我把分布挪了多远」。

决策树:信息增益就是互信息

回到最古典的机器学习。ID3 算法选择分裂特征的标准是信息增益:

\mathrm{IG}(Y, X) = H(Y) - H(Y \mid X)

眼熟吗?这就是互信息 I(X;Y)。「用特征 X 分裂,能让标签的不确定性减少多少」,等价于「X 与 Y 共享多少信息」。

这个视角解释了几件事:

  • 为什么信息增益偏好取值多的特征(比如「身份证号」能把每个样本单独分开,H(Y|X)=0,增益最大)——因为它把「样本量」当成了「信息量」。C4.5 用增益率(除以特征自身的熵 H(X))来惩罚这种偏好,本质上是给「分裂本身的代价」记账。
  • 为什么 CART 用 Gini 系数 G = 1 - \sum_k p_k^2 而不在乎「信息」的名义——因为 Gini 与熵在形状上高度相似(都在均匀处最大、确定性处为 0、都是凹函数),计算上省一个 \log。它是熵的一种廉价替身。
  • 为什么随机森林的「特征重要性」可以用平均不纯度减少来衡量——那本质上是在累计每个特征贡献的互信息。

诊断工具箱:几个可以直接用的熵指标

理论讲完,给一份能落地的清单。这些都是训练现场真会用到的:

指标定义看什么异常信号
训练/验证交叉熵-\frac{1}{N}\sum \log q(y)学习进度初始值远高于 \ln|\mathcal{V}|:初始化坏了;验证 loss 回升:过拟合
困惑度\exp(\bar{L})直观的「犹豫程度」跨 tokenizer 比较无意义,改用 BPB
BPB\bar{L}/(\ln 2 \cdot \text{字节/token})跨模型可比与同规模模型对比,差 0.1 就是明显差距
策略熵H(\pi(\cdot\mid s))探索是否还活着快速掉到 0:熵坍缩
注意力熵H(a_{t\cdot})注意力是否聚焦全部均匀(塌陷)或全部集中(attention sink)
路由熵(MoE)H(\text{gate})专家分工过低:少数专家垄断;过高:没有分工
平均自信息-\frac{1}{N}\sum\log p(x_i)数据的「惊讶度」某批数据异常高:分布漂移或脏数据
校准误差\lvert \text{confidence} - \text{accuracy}\rvert置信度是否可信高置信却错:过度自信,需要温度标定

最后一行值得展开一句:温度标定(temperature scaling)是校准模型置信度最常用的方法——在验证集上找一个标量 T,让 \mathrm{softmax}(z/T) 的负对数似然最小。它不改变预测结果(argmax 不变),只改变模型「说话的语气」。这与前面「温度不改变知识,只改变表达」是同一件事的工程应用。

数据侧的熵:重复、多样性与有效信息

训练数据也有熵,而且它决定了模型能学到多少。

重复会杀死熵。 同一段文本在语料里出现 100 次,不会让模型学到 100 倍的知识。相反,它把经验分布 \hat{p} 推向退化:某些序列的概率被人为抬高,其他序列被相对压低。模型会把容量花在记忆重复片段上,而不是学习规律。 这就是为什么严肃的预训练管线必须有去重步骤——去重不是为了省空间,是为了保住数据的有效熵。

多样性就是熵。 一个只有一种文风、一个领域、一种句式结构的数据集,其熵很低。在低熵数据上训练出来的模型,会在低熵分布上表现很好,然后在你真正关心的任务上崩掉。数据配比的本质,是在调配一个混合分布的熵。

困难样本是高自信息的样本。 用当前模型算每条样本的 -\log p(x),值特别高的那些,就是模型最「惊讶」的样本。主动学习(active learning)用这个信号挑标注对象,课程学习(curriculum learning)用它安排训练顺序——都是在对「熵」做调度。

tokenizer 也在做熵的事。 BPE 的贪心合并(每次合并最高频的相邻符号对)可以粗略理解为:把最常见的组合压成一个符号,从而降低序列上的符号数。它不改变文本的信息量,但改变了「每个 token 承载多少比特」——这正是为什么 PPL 不可跨 tokenizer 比较,而 BPB 可以。

压缩即理解

最后回到第三张面孔留下的那个伏笔。

香农说英文的熵大约是 1 比特/字符,而 1951 年没人能压到那个水平,因为达到极限需要「理解」英文。七十年后,这句话变成了一个可执行的命题:

给定一个模型 q,任何序列 x 都可以用算术编码压到大约 -\log_2 q(x) 比特。 于是「模型的交叉熵」直接就是一个压缩率。

具体地,如果模型对一段 1 MB 的文本给出平均 1.2 bit/byte 的交叉熵,那么这段文本可以被无损压到 150 KB。模型的 loss 越低,压缩得越狠。

这个等价关系引出了两个有意思的推论:

  1. 语言模型就是压缩器,而且是目前最好的通用压缩器。 用大模型做算术编码,在中英文文本上都能压过 gzip、xz、zstd 一大截。反过来说,一个能极致压缩文本的系统,必然「理解」了文本的结构——因为不理解结构就无法预测下一个字符。
  2. Scaling Law 里的 loss 曲线,就是一条压缩率曲线。 参数越多、数据越多,loss 按幂律下降,意思是:模型对世界的压缩越来越紧。 「智能」在信息论里的一个可能定义就是:用更短的描述解释更多的现象。

Hutter Prize 把这件事做成了竞赛:压缩 100 MB 的 enwik8 文本,每提升 1% 给奖金。它背后的信念是「压缩即智能」——一个能把维基百科压得最小的程序,必然包含了关于世界的知识。

当然,这个类比有边界:压缩衡量的是「对观测数据的预测能力」,而智能还包括行动、规划、因果。但作为一条下界,它是可靠的:一个无法压缩数据的东西,不可能理解数据。

算一遍

理论说完了,把数字跑一遍。下面这段代码可以直接运行,覆盖了熵、交叉熵、KL、困惑度、梯度与温度的全部关键关系。

pythonpython
import mathimport torchimport torch.nn.functional as F# ① 两个分布:p 是数据,q 是模型的猜测p = torch.tensor([0.5, 0.25, 0.125, 0.125])   # 熵正好 1.75 bitq = torch.tensor([0.4, 0.30, 0.20, 0.10])     # 猜得不太准H_p  = -(p * p.log()).sum()                   # 熵H_pq = -(p * q.log()).sum()                   # 交叉熵KL   = (p * (p.log() - q.log())).sum()        # KL 散度print(f"H(p)     = {H_p:.4f} nat = {H_p / math.log(2):.4f} bit")print(f"H(p, q)  = {H_pq:.4f} nat = {H_pq / math.log(2):.4f} bit")print(f"KL(p||q) = {KL:.4f} nat = {KL / math.log(2):.4f} bit")print(f"H + KL   = {H_p + KL:.4f} nat")       # 与交叉熵相等print(f"PPL      = {torch.exp(H_pq):.4f}")# ② 交叉熵的梯度 = 预测 - 真值z = torch.tensor([2.0, 0.0, -1.0], requires_grad=True)F.cross_entropy(z, torch.tensor(1)).backward()print("softmax:", F.softmax(z.detach(), -1))print("grad   :", z.grad)# ③ 温度是熵的旋钮logits = torch.tensor([2.0, 1.0, 0.5, 0.0])for T in (0.1, 0.5, 1.0, 2.0, 10.0):    pt = F.softmax(logits / T, -1)    H = -(pt * pt.log()).sum() / math.log(2)    print(f"T={T:<5} H={H:.4f} bit  p_max={pt.max():.4f}")

输出(本机实测,PyTorch 2.x):

texttext
H(p)     = 1.2130 nat = 1.7500 bitH(p, q)  = 1.2481 nat = 1.8007 bitKL(p||q) = 0.0351 nat = 0.0507 bitH + KL   = 1.2481 natPPL      = 3.4839softmax: tensor([0.8438, 0.1142, 0.0420])grad   : tensor([ 0.8438, -0.8858,  0.0420])T=0.1    H=0.0007 bit  p_max=1.0000T=0.5    H=0.8585 bit  p_max=0.8310T=1.0    H=1.6011 bit  p_max=0.5793T=2.0    H=1.8955 bit  p_max=0.4087T=10.0   H=1.9960 bit  p_max=0.2790 

这段代码验证了三件事:

  1. H(p,q) = H(p) + D_{\mathrm{KL}}:1.2130 + 0.0351 = 1.2481,与交叉熵完全相等。而且 H(p) = 1.75 比特不是巧合——这个分布是 \{1/2, 1/4, 1/8, 1/8\},正好是一个最优二分决策树的叶子分布,每一步都在砍半,平均 1.75 次提问。
  2. 梯度 = 预测 − 真值:第二项 -0.8858 = 0.1142 - 1,其余两项与预测完全相同。
  3. 温度单调抬熵:从 0.0007 到 2.0000,逼近 \log_2 4 = 2 的上界。

顺带一个观察:这个例子里 D_{\mathrm{KL}} 只有 0.05 比特,而交叉熵是 1.80 比特。KL 小不代表模型好——数据的熵本来就是 1.75,模型再怎么努力也不可能低于它。这就是为什么「loss 从 3.2 掉到 2.8」这种描述没有意义,必须知道地板在哪。

八个常见误解

最后清理一批流传很广的错误说法。

说法判定说明
「熵就是混乱程度」半对熵度量的是不确定性(可能性有多少),不是视觉上的「乱」。一副刚拆封、按花色排好序的扑克牌,和一副洗过的牌,如果你都不知道牌序,那么「下一张是什么」的熵完全一样——都是 \log_2 52! 那点东西。视觉上的「有序」与「混乱」在信息论里不是同一个概念,文学化用法掩盖了熵真正衡量的东西
「熵是样本的属性」错熵是分布的泛函。单个样本只有自信息-\log p(x),没有熵。把一批样本的统计频率代进公式得到的是经验熵,是对分布的估计
「交叉熵 loss 可以跨模型比较」错它依赖词表大小与分词器。6400 词表上的 8.76 和 50257 词表上的 10.82 都是「完全随机」。要比较请换成 BPB
「loss 越低模型越好」错训练 loss 低可能只是记住了训练集。真正的标准是验证集 loss,以及你关心的下游任务表现
「KL 散度是距离」错它不对称,不满足三角不等式。方向不同,优化出来的模型行为完全不同(见「不对称的两个方向」)
「困惑度就是候选词个数」半对它是几何平均意义下的等效候选数,不是整数,也不对应某一个具体位置的实际候选数
「温度会改变模型的知识」错softmax 是单调变换,温度不改变 logits 排序,只改变分布的平坦程度。它改变的是「敢不敢说」,不是「信什么」
「熵越大越好」错训练的目标是逼近数据的熵,不是最大化熵。最大化熵只在无约束推断(最大熵原理)中作为「最诚实的先验」出现,它与「学到东西」是相反的方向

尾声:熵是「不知道」的体积

回到开头那个问题。

熵是什么?它是「不知道」的体积。是你在被告知答案之前,心里那片空白的度量。二十个问题问出了它的单位,三条公理逼出了它的形式,五张面孔给了它五种读法。

但真正有意思的是它在人工智能里的位置。学习这件事,在信息论的语言里就是一句极其朴素的话:用数据换取熵的下降。 每一个训练步,模型都在做同一件事——把自己对下一个 token 的猜测,向着世界真实的分布挪一点。交叉熵就是这个「挪」的代价,梯度就是「差在哪」的方向。

这也给了我们一把尺子去衡量「模型有多聪明」。不是参数量,不是 benchmark 分数,而是:它对世界还剩多少不知道? 这个数字可以精确到比特。一个把英文压到 0.6 bit/字符的模型,比一个只能压到 1.2 bit/字符的模型,确实「懂得更多」——它省下的那 0.6 bit,就是它真正理解的那部分结构。

当然,这个度量有它的边界。熵只衡量「预测得准不准」,不衡量「说得对不对」;它奖励的是对数据的拟合,而不是对世界的责任。一个模型可以极其擅长压缩人类的文本,同时完全不懂文本在说什么。这是信息论管不到的地方,也是它诚实的地方:它只承诺度量「不知道」,从不承诺「知道」意味着什么。

从 1948 年到现在,这个度量几乎没有变过。变的是我们能用它压到多低。

除非特别说明,本站文章采用 CC BY-NC-SA 4.0 许可协议。

在 GitHub 编辑

相关阅读

4 阅读

C++ Standard Library List

C++标准库列表

截至 C++26(2026 年 3 月已定稿),标准库的组件非常庞大。下面按功能类别整理了一份核心标准库组件表格,覆盖从 C++11 到 C++26 的主要头文件及其作…

4 阅读

机器学习·智械起源

数字如何从0到1构造智能

从「观察 → 表示 → 预测 → 决策 → 行动 → 反馈 → 更新」的闭环出发,本文梳理机器学习的本质与流形假设,给出神经网络的标准数学模型与损失函数,再用…

机器学习# 神经网络# 反向传播# 流形假设# MNIST
14 阅读

How to Design an Elegant Agent System

从 cell.cpp 提炼的十条构造原则 —— 把不确定性关进确定性的笼子

Agent 框架越做越厚,但真正的问题只有一个 —— 如何让一个只会预测下一个 token 的东西,可靠地改变外部世界。我以单文件 C++ Agent「cell.cpp」为样…

工程# Agent# 系统设计# 工程哲学# LLM
1 阅读

最小系统的设计原理

如何优雅地设计一个极客风格的系统

一般而言,根据钱老的《工程控制论》思想,一个系统可以由以下部分组成: 其基本结构可表示为: 其中: 比较器:计算偏差,例如 e=r−ye=r−y; 控制器…

随笔# 随笔# 工程哲学

评论