LLM评估指标：困惑度（Perplexity, PPL）

原创已于 2025-06-17 14:11:47 修改 · 1k 阅读

19 ·

CC 4.0 BY-SA版权

文章标签：

#人工智能 #算法 #机器学习

于 2025-06-17 11:43:57 首次发布

自然语言处理与大语言模型专栏收录该内容

21 篇文章

订阅专栏

定义： 困惑度衡量的是一个概率模型预测样本（通常是一段文本序列）的好坏程度。对于语言模型来说，它衡量的是该模型预测下一个词的不确定性有多大。

直观理解：

想象一下，语言模型在阅读文本时，每一步都在预测下一个最可能出现的词。
如果模型非常确定下一个词是什么（即分配给正确词的概率非常高），那么困惑度就低。
如果模型对下一个词是什么感到很“困惑”，不确定哪个词会出现（即概率分布比较平坦，或者分配给正确词的概率很低），那么困惑度就高。
因此，困惑度越低越好。 较低的困惑度意味着模型对数据（文本）的预测能力更强，对语言的掌握更准确。

数学定义： 困惑度是基于测试集的概率计算得出的。对于一个包含N个词（token）的测试序列，语言模型赋予该序列的概率为 $P\left ( W \right )$ 。困惑度定义为：

$PP\left ( W \right )=P\left ( w_1,w_2...w_N \right )^{-\frac{1}{N}}$

其中N为序列长度。更常见和实用的形式是利用交叉熵 来定义。交叉熵是衡量模型预测分布与真实数据分布之间差异的标准指标。在语言模型中，通常用平均负对数似然来近似计算：

$H\left ( W \right )=-\frac{1}{N}log_2\left ( P\left ( w_1,w_2...w_N \right ) \right )$

困惑度就是交叉熵的指数形式：

$PP\left ( W \right )=2^{H\left ( W \right )}$

这个公式揭示了困惑度与交叉熵的紧密联系：交叉熵越低，困惑度越低，模型越好。

如何计算困惑度？

（1）需要一个训练好的语言模型。

（2）需要一个未参与训练的测试数据集。这个数据集应该是模型之前没见过的，代表模型将要处理的实际语言数据。

（3）计算测试集的总概率： 模型需要计算整个测试序列的概率。根据概率的链式法则：

$P\left ( w_1,w_2...w_N \right )=P\left ( w_1 \right )P\left ( w_2|w_1 \right )P\left ( w_3|w_1,w_2 \right )...P\left ( w_N|w_1,w_2...w_{N-1} \right )$

即，序列的概率是其所有词在给定前面词的条件概率的乘积。

（4）计算平均对数概率（或交叉熵）： 取上述概率的对数（通常是自然对数或2为底的对数），然后取平均：

$H\left ( W \right )=-\frac{1}{N}\sum_{i}^{}logP\left ( w_i|w_1,w_2...w_{i-1} \right )$

这里的 $logP\left ( w_i|w_1,w_2...w_{i-1} \right )$ 是模型在给定前(i-1)个词后，预测第 i 个词的条件概率。

（5）取指数： 将平均对数概率（即交叉熵）代入指数公式得到困惑度：
$PP\left ( W \right )=e^{H\left ( W \right )}$ (如果使用自然对数ln)
$PP\left ( W \right )=2^{H\left ( W \right )}$ (如果使用以2为底的对数log₂)

两者在比较模型时是等价的，因为指数函数是单调的。但以2为底时，困惑度有一个直观的解释：平均分支因子。

假设困惑度 = PP(W)。
这可以理解为：在模型预测的每个位置上，模型觉得平均有 PP(W) 个词是同样可能出现的。
例子：
- 如果困惑度是 1，表示模型绝对确定下一个词是什么（概率为1），没有任何不确定性。这是理想但不可能达到的情况。
- 如果困惑度是 2，表示模型平均觉得有 2 个词同样可能是下一个词（比如抛硬币决定）。
- 如果困惑度是 100，表示模型平均觉得有 100 个词同样可能是下一个词，说明它非常不确定。

为什么困惑度重要？

内部评估的金标准： 在模型开发和研究阶段，困惑度是衡量语言模型建模语言能力最核心、最常用的内部指标。它直接反映了模型预测未知文本（测试集）的概率质量。
模型比较： 它是比较不同语言模型架构、超参数设置、训练策略（如预训练目标、微调方法）或训练数据量效果的强有力工具。在相同测试集上，困惑度更低的模型通常被认为在捕捉语言统计规律方面做得更好。
预训练监控： 在大型语言模型预训练过程中，困惑度常被用作监控训练进度的主要指标。训练损失（通常是交叉熵）的下降直接对应着验证集困惑度的下降。
领域适应性： 可以计算模型在特定领域文本上的困惑度，评估模型对该领域的熟悉程度。领域内文本的困惑度通常远低于域外文本。
模型选择与轻量化： 在模型压缩（如知识蒸馏、剪枝、量化）过程中，困惑度是衡量压缩后模型性能保持情况的关键指标。
理论意义： 与信息论中的熵和压缩率有直接联系。较低的困惑度意味着模型能更高效地“压缩”或表示语言信息。

困惑度的局限性

与最终任务目标不完全一致： 困惑度衡量的是模型预测下一个词的能力，但这不一定直接转化为下游任务（如机器翻译、问答、文本摘要、情感分析）的性能。一个困惑度低的模型在特定任务上可能表现不如一个困惑度稍高但架构更适合该任务的模型。因此，最终评估还需看具体任务指标。
依赖词表： 困惑度受模型使用的词表大小和粒度（字、子词、词）影响。词表越大，模型预测的“分支”自然越多，困惑度可能相对更高（即使模型能力相同）。比较不同词表的模型时需要谨慎。
无法评估语义、事实性或一致性： 困惑度只关注词序列的表面统计规律。它无法判断模型生成的内容是否：
- 事实正确（可能自信地生成错误信息）。
- 逻辑连贯/自洽（可能生成局部概率高但整体矛盾的内容）。
- 符合人类偏好（可能生成概率高但无聊、有害或不恰当的文本）。
对概率估计敏感： 困惑度严重依赖模型输出的校准过的概率。如果模型输出的概率置信度不准确（过于自信或不够自信），即使预测能力相同，困惑度也会失真。
数据分布依赖： 困惑度只在所使用的测试集上有意义。模型在不同类型或领域的测试集上表现差异可能很大。

举例

假设场景：

词表 (Vocabulary): 假设我们的语言模型词表非常小，只包含3个词：[猫, 睡, 吃]。我们用索引表示：猫 -> 0, 睡 -> 1, 吃 -> 2。
测试句子 (Test Sequence): 我们要评估的句子是：猫睡 (即 [0, 1])。这个句子包含 N = 2 个词。
语言模型 (Language Model): 假设我们有一个非常简单的语言模型，它根据前面的词预测下一个词的概率。模型给出的概率如下：
- 起始标记 <s> 后的第一个词：
  - P(猫 | <s>) = 0.6
  - P(睡 | <s>) = 0.3
  - P(吃 | <s>) = 0.1
- 给定第一个词是 猫 后，预测第二个词：
  - P(睡 | 猫) = 0.7
  - P(吃 | 猫) = 0.2
  - P(猫 | 猫) = 0.1 (注意：虽然“猫猫”不常见，但为了计算我们假设这个概率)
- 模型假设： 我们假设模型只依赖前一个词（这是一个 bigram 模型）。

目标： 计算语言模型在测试句子 猫睡 ([0, 1]) 上的困惑度。

计算步骤：

计算句子的联合概率 P(W)：
使用概率的链式法则，句子 W = (w1=猫, w2=睡) 的概率等于：
P(W) = P(w1=猫 | <s>) * P(w2=睡 | w1=猫)
代入模型给出的概率：
P(W) = P(猫 | <s>) * P(睡 | 猫) = 0.6 * 0.7 = 0.42
计算平均负对数似然 (即交叉熵 H(W)):
困惑度是基于交叉熵计算的。交叉熵 H(W) 定义为句子概率的对数的平均值的负数。通常使用自然对数 (ln) 或以 2 为底的对数 (log₂)。这里我们使用自然对数 (ln) 进行计算，结果是一样的，因为指数函数是单调的。
H(W) = - (1/N) * ln(P(W))
其中 N = 2 (句子长度)。
代入 P(W) = 0.42：
H(W) = - (1/2) * ln(0.42)
首先计算 ln(0.42)。我们知道 ln(0.42) ≈ -0.8675 (可以使用计算器或查表)。
所以：
H(W) = - (1/2) * (-0.8675) = - (-0.43375) = 0.43375
（如果使用 log₂，log₂(0.42) ≈ -1.2515，则 H(W) = - (1/2) * (-1.2515) = 0.62575）
计算困惑度 PP(W)：
困惑度是交叉熵的指数（如果使用自然对数）或 2 的交叉熵次方（如果使用以 2 为底的对数）。
使用自然对数 (ln) 的结果：
PP(W) = exp(H(W)) = exp(0.43375) ≈ 1.543
使用以 2 为底的对数 (log₂) 的结果：
PP(W) = 2^{H(W)} = 2^{0.62575} ≈ 1.543
两种方法计算结果一致：困惑度 PP(W) ≈ 1.543

解读结果：

我们计算出的困惑度大约是 1.543。
直观理解 (平均分支因子)： 这个值非常接近 1。意味着模型在预测这个句子 猫睡 中的每一个词时，平均只感觉到大约 1.54 个可能的选择是同样合理的。这表明模型对这个特定句子的预测非常确定，不确定性很低。
为什么这么低？
- 模型认为句子开头最可能出现的词是 猫 (P=0.6)，而实际第一个词就是 猫。
- 当看到 猫 之后，模型认为最可能的下一个词是 睡 (P=0.7)，而实际第二个词就是 睡。
- 因此，模型赋予这个正确序列 猫睡 的概率很高 (0.42)，导致计算出的对数概率值（负对数似然）较小（绝对值较小），最终困惑度很低。

关键点回顾：

链式计算概率： P(W) = P(w1) * P(w2|w1) * ... * P(wN|w1, w2, ..., wN-1)。例子中用了 bigram：P(猫睡) = P(猫|<s>) * P(睡|猫)。
取对数 & 平均： 计算句子概率的自然对数 ln(P(W)) (或 log₂(P(W)))，然后除以句子长度 N 并取负数，得到平均负对数似然 H(W) (交叉熵)。例子中 H(W) = - (1/2) * ln(0.42) ≈ 0.43375。
指数运算： 对 H(W) 取指数 exp(H(W)) (如果使用 ln) 或计算 2^{H(W)} (如果使用 log₂) 得到困惑度 PP(W)。例子中 PP(W) = exp(0.43375) ≈ 1.543。
数值意义： 困惑度越低越好。1.543 表示模型预测该句子时不确定性很小。

代码实现

上面的例子用代码实现如下：

import math

def calculate_perplexity(sentence, model_probs):
    """
    计算给定句子在语言模型上的困惑度
    
    参数:
    sentence: list[str] - 要计算的句子（词序列）
    model_probs: dict - 语言模型的概率分布
               格式: {(context, word): probability}
    
    返回:
    float: 句子的困惑度
    """
    # 初始化变量
    log_likelihood = 0.0  # 对数似然值
    num_predictions = 0   # 预测次数（序列长度N）
    
    # 遍历句子中的每个位置进行预测
    for i in range(len(sentence)):
        # 获取当前词
        current_word = sentence[i]
        
        # 确定上下文：
        # 第一个词使用起始标记<s>作为上下文
        # 后续词使用前一个词作为上下文
        context = "<s>" if i == 0 else sentence[i-1]
        
        # 获取模型预测的条件概率
        # 如果找不到对应的概率，使用一个极小值避免零概率问题
        prob = model_probs.get((context, current_word), 1e-10)
        
        # 累加对数似然（使用自然对数）
        log_likelihood += math.log(prob)
        num_predictions += 1
    
    # 计算平均负对数似然（交叉熵）
    avg_negative_log_likelihood = -log_likelihood / num_predictions
    
    # 计算困惑度（指数形式）
    perplexity = math.exp(avg_negative_log_likelihood)
    
    return perplexity

# ======================
# 语言模型定义
# ======================

# 定义词汇表
vocab = ["猫", "睡", "吃"]

# 定义语言模型的概率分布（使用bigram示例）
# 格式: {(context, word): probability}
model_probabilities = {
    # 起始标记后的第一个词概率
    ("<s>", "猫"): 0.6,
    ("<s>", "睡"): 0.3,
    ("<s>", "吃"): 0.1,
    
    # 给定"猫"后的下一个词概率
    ("猫", "睡"): 0.7,
    ("猫", "吃"): 0.2,
    ("猫", "猫"): 0.1,
    
    # 给定其他词的概率（简化处理）
    ("睡", "猫"): 0.4,
    ("睡", "睡"): 0.3,
    ("睡", "吃"): 0.3,
    
    ("吃", "猫"): 0.5,
    ("吃", "睡"): 0.3,
    ("吃", "吃"): 0.2,
}

# ======================
# 测试计算
# ======================

# 测试句子
test_sentence = ["猫", "睡"]

# 计算困惑度
perplexity = calculate_perplexity(test_sentence, model_probabilities)

# 打印结果
print(f"测试句子: {test_sentence}")
print(f"计算过程:")
print(f"1. P(猫|<s>) = {model_probabilities[('<s>', '猫')]}")
print(f"2. P(睡|猫) = {model_probabilities[('猫', '睡')]}")
print(f"联合概率 = {model_probabilities[('<s>', '猫')] * model_probabilities[('猫', '睡')]:.4f}")
print(f"对数似然 = ln({model_probabilities[('<s>', '猫')] * model_probabilities[('猫', '睡')]:.4f}) = {math.log(model_probabilities[('<s>', '猫')] * model_probabilities[('猫', '睡')]):.4f}")
print(f"平均负对数似然 = -({math.log(model_probabilities[('<s>', '猫')] * model_probabilities[('猫', '睡')]):.4f}) / 2 = {-math.log(model_probabilities[('<s>', '猫')] * model_probabilities[('猫', '睡')]) / 2:.4f}")
print(f"困惑度 = exp({-math.log(model_probabilities[('<s>', '猫')] * model_probabilities[('猫', '睡')]) / 2:.4f}) = {perplexity:.4f}")

# 验证手动计算
joint_prob = model_probabilities[('<s>', '猫')] * model_probabilities[('猫', '睡')]
manual_perplexity = math.exp(-math.log(joint_prob) / 2)
print(f"\n验证计算: exp(-ln({joint_prob:.4f})/2) = {manual_perplexity:.4f}")

输出结果：

测试句子: ['猫', '睡']
计算过程:
1. P(猫|<s>) = 0.6
2. P(睡|猫) = 0.7
联合概率 = 0.4200
对数似然 = ln(0.4200) = -0.8675
平均负对数似然 = -(-0.8675) / 2 = 0.4338
困惑度 = exp(0.4338) = 1.5430

验证计算: exp(-ln(0.4200)/2) = 1.5430