G-Eval 源码深读:裁判模型打出的 2.894 分,到底是什么

读 DeepEval 的 G-Eval 源码:为什么分数是概率加权期望而不是整数档位,criteria/steps/rubric/strict_mode 四旋钮各控制什么,以及倒序扫 logprob、滤 <1% token、重归一化的三层防抖。

一个裁判模型给两份摘要打分,两份都”最可能是 3 分”。可 G-Eval 最后交出的却是 2.894 和 2.863 两个不同的小数。这 0.03 的差不是凭空来的——是它把裁判心里那点”3 分很稳 / 3 分有点悬”的犹豫也算了进去。这不取最大概率、而取概率加权期望的一小步,就是 G-Eval 和”让模型随便打个分”的分水岭。

这篇不打算复述文档用法(那是二手),我直接读 DeepEval 的 G-Eval 源码,讲清楚它到底怎么算出这个分数,以及为什么只能这么算。

名词速查

术语一句话解释
LLM-as-a-Judge让一个模型当裁判,给另一个模型的输出打分
CoT(思维链)先让模型写出一串推理步骤,再让它下结论,比直接作答更准
logprob模型给某个 token 的对数概率,是负值,越大代表它越有把握
rubric评分量表:把 0–10 分成几档,给每档配一句”什么情况算这档”的描述
argmax在一堆概率里挑最大的那个,丢掉其它候选
evaluation_params裁判打分时能”看到”的测试用例字段(输入、输出、期望输出等)

这篇主角是 DeepEval 里最通用的自定义指标 GEval。它是 G-Eval 论文 的实现,文档原话是”能以接近人的精度评估几乎任何用例”。

心智模型:G-Eval 是在”雇一个带先验的语文老师”

先立一个可迁移的模型,后面所有细节都往它身上挂。

它解决什么问题? 开放生成(写摘要、客服回复、方案解释)没有可枚举的标准答案,BLEU 那种”数相同词语”的指标在语义改写面前失灵。想评它,只能雇一个”人”来看——在代码里就是雇一个裁判模型。

它在一个什么样的系统里? 它不是独立打分器,而是插在你的测试循环里:输入一条 LLMTestCase,输出一个 score 和一段 reason,跟 threshold 一比决定这条用例过不过。

盯住哪几个活动部件(旋钮)? 我读源码后把它归结为四个旋钮:

旋钮它控制什么拧错了会怎样
criteria / evaluation_steps打分步骤谁说了算:给 criteria 让模型自己生成步骤,给死 steps 就跳过生成用 criteria 每次都重新生成步骤 → 同一条用例分数抖动
rubric分数刻度围栏:没给就在 0–10 里自由发挥,给了就锁死在指定档位档位重叠会直接 ValueError(源码强制检查)
strict_mode是否二进制过/不过:True 时分数强制 0/1阈值被覆盖成 1,很严格
evaluation_params裁判能看哪些字段塞了 criteria 没提到的字段 → 喂无关上下文、拉低分数

拧一个旋钮会发生什么? 这是理解 G-Eval 的钥匙:

  • 步骤从”模型自生成”改成”你写死” → 从灵活变成可复现(代价是少探索)。
  • 加上 rubric → 分数从”自由飘”收敛到”固定档”,但可能误伤真实差异。
  • 开 strict_mode → 从连续分变成过/不过门,适合做门禁。
  • 增减 evaluation_params → 裁判的”视野”变宽变窄,直接影响打分准不准。

把 G-Eval 想象成雇语文老师批作文:你要决定给他一张多详细的打分细则(steps)、把分数压成几个档(rubric)、还是要他只要判”过不过”(strict_mode)、以及让他只看哪些东西(evaluation_params)。普通”让模型打 1-5 分”只动了最后一个旋钮,而且用的是最粗糙的取整方式。

走一遍:两阶段算法 + 一个概率尾巴

源码里 g_eval.py 的流程可以压成三步(我读 measure() → _a_evaluate() 主干简化而来):

# 伪代码,对应 g_eval.py 的 measure()/_a_measure() 主干
def measure(test_case):
    # 阶段一:定打分步骤(CoT)
    steps = self.evaluation_steps or generate_steps(self.criteria)  # 给死就用死的
    # 阶段二:填表打分
    prompt = build_prompt(steps, test_case_params, rubric)           # 把参数字段拼进 prompt
    g_score, reason = ask_judge(prompt)                              # 裁判输出 score + reason
    # 阶段三:归一化到 0-1
    self.score = (g_score - score_range[0]) / score_range_span       # 默认 range=(0,10)

三个阶段对应三个设计决策:

阶段一:criteria 和 steps 二选一。 源码里 validate_criteria_and_evaluation_steps 明确禁止两者同时为空,也建议只传一个(文档的 FAQ 也强调”never both”)。给 criteria 时,模型用 schema.py 里的 Steps(steps: List[str])生成一列打分步骤——这就是论文说的 Auto-CoT。给 evaluation_steps 则跳过生成,分数更稳定。判据:探索期用 criteria(让模型替你起草步骤),定稿期锁死 steps(可复现)。

阶段二:填表打分。 把 evaluation_params 里声明的字段拼进 prompt(例如 Actual Output: ...、Expected Output: ...),要求裁判用 schema ReasonScore 输出 reason + score。

阶段三:归一化。 g_eval.py:145 把裁判的原始分(默认 0–10)线性压到 0–1:

self.score = (float(g_score) - self.score_range[0]) / self.score_range_span

这段我从源码照抄的(非 strict 分支)。默认 get_score_range 返回 (0, 10),所以没有 rubric 时就是裸的”原始分除以 10”。

关键:分数不是 argmax,是概率加权期望

前面三步都只是”让模型打分”的工程化,真正值得深挖的是这一步——它不取裁判最有把握的整数,而是取所有分数档位的概率加权期望。这也是论文里那句”probability-weighted summation”落地的样子。

源码在 utils.py:340 calculate_weighted_summed_score:

# utils.py 里的核心逻辑(我按可读性整理,语句与源码一致)
lin = {score: math.exp(logprob) for token 的 top_logprobs}   # 还原线性概率
total = sum(lin.values())
weighted = sum(score * prob for score, prob in lin.items()) / total

公式就是:加权分 = Σ(分数 × 该分数概率) ÷ Σ概率。除的那一下是重归一化:因为过滤后剩下的概率加起来不是 1。

我拿论文例子里那份概率分布手算过(这是我自己验算的,脚本一次性通过):

用例p(1)p(2)p(3)p(4)p(5)argmax加权分
S1(忠实通顺)0.00.1150.8760.0090.032.894
S2(语序略乱)0.00.1370.8630.00.032.863
S3(事实错误)0.5450.4460.0090.00.011.464

S1、S2 的 argmax 都是 3,同分;但加权后 S1=2.894 > S2=2.863,拉开差距了。S1 的 3 分更”笃定”(0.876),S2 有更多概率分给 2 分(0.137),所以理应更低。这一分差的本质是:argmax 把裁判的犹豫丢掉了,加权期望把它捡回来。

类比:老师心里”A 学生几乎稳 3 分,B 学生介于 2 和 3 之间”。写成绩单只写”最可能的分数”,两个人都记成 3;加权期望就是把”B 可能只有 2 分”这层犹豫也算进排名。

我踩过的一个坑(手算必须验算)

第一次验算我直接把概率当成 logprob 又做了一次 exp(指数套指数),S1 算出了 2.98 这个错数,比对的判断直接反了。排查才发现 calculate_weighted_summed_score 的输入是模型返回的 logprob,必须 exp 还原成线性概率、而且分号不是 1.0 时要归一化。这个错误反过来印证了写作准绳里那条”手算数字先验算”——顺手算最容易在 log/exp 这里翻车。验证脚本我放在文末”五分钟实验”里,你可以自己重跑。

源码里三层”防抖”(文档没写的细节)

如果只读文档,你看到的只是”用概率加权求和”。但源码里藏着三个过滤/归一化动作,每一个都是工程上被噪声打疼过才加的:

1. 倒序找分数 token(utils.py:348):

for token_logprobs in reversed(generated_logprobs):
    if token_logprobs.token == str(raw_score):
        score_logprobs = token_logprobs; break

裁判推理(CoT)里可能已经写过”3”,那不是最终分数。倒序扫确保取到的是最后一个等于分数的 token——即真正输出的分数,而不是推理过程里的同款数字。这个细节文档完全没提,是源码里实打实的防错处理。

2. 过滤掉 <1% 概率的 token(utils.py:356):min_logprob = math.log(0.01),低于这个的直接跳过。logprob 是稀疏的、带大量噪声尾部,不滤的话那些 0.0001 级别的杂音会污染期望。

3. 过滤非纯数字 token + 重归一化(utils.py:364 和 :385):if not token_logprob.token.isdecimal(): continue 挡掉”3.”、“3.0”这类解析会炸的 token;最后 weighted_summed_score = sum_of_weighted_scores / sum_linear_probability 把过滤后剩下的概率重新归一化到和为 1。论文原式是加权求和,deepeval 多加了一除,变成加权平均——保证分数稳稳落在 [min_score, max_score] 区间内。

这三层合起来的意思很直白:裁判输出的 logprob 是脏数据,不能直接拿来算期望,必须先”找到对的 token → 滤掉杂音 → 归一化”,期望才有意义。

边界:什么时候这套会失灵

G-Eval 不是万能尺,我读完源码和文档,边界至少四层:

  1. 非确定性。同一个 case 跑两遍,分数可能不一样(尤其用 criteria 让模型自己生成步骤时)。要确定性,DeepEval 自己都建议换 DAGMetric(LLM 决策树,每个分支仍调模型,但分数是写死的常量)。文档原话:“G-Eval is NOT deterministic.”
  2. 裁判模型自带偏差。G-Eval 的分数上限就是裁判模型判断力的上限。位置偏差、长度偏好、自我增强这些坑在 MT-Bench 那篇里挖过,我在这篇整理过——G-Eval 一个都没躲掉。
  3. 它跟”参照物”的关系是”裁判判断”,不是”数相同”。即使你传了 expected_output,G-Eval 也不是在做 BLEU 那种字符串比对,而是让裁判”看了参考答案后判断像不像”。我另一篇讲过:所有评测本质都是选参照物,G-Eval 选的是”裁判模型的先验 + 你写的 criteria”。
  4. 别塞无关字段。文档 Danger 提示:evaluation_params 只能放 criteria/steps 里真正提到的字段,多塞一个 expected_output 而步骤从不提它,就会给裁判喂无关上下文、拉低分数。

小结:一句话根本约束

G-Eval 的分数之所以必须是一个带小数的加权期望、而不是一个整数档位,是因为开放生成没有可枚举的标准答案——没有 ground truth,就只能把打分委托给一个带先验的裁判模型;而裁判的整数打分会把”犹豫”的信息丢光,于是用 logprob 加权期望把它捡回来。

反着验证这句话:假如这个约束不存在(比如选择题,标准答案就那么几个),你根本不需要 G-Eval,直接 == 比对字符串就行。正是”开放任务答案不可枚举”这个约束,逼出了”雇裁判 + 概率加权”这套设计。而裁判输出是 logprob 这种脏数据,才又逼出了”倒序找 token、滤 <1%、滤非法字符、重归一化”这四层防抖。

五分钟实验:自己算一次加权分

不用装任何东西,复制下面这段到 python 跑一下(需要 math,标准库就有,约 2 分钟读懂、3 分钟跑完):

import math
def weighted(logprob_by_score):            # 输入 {分数: logprob}
    lin = {s: math.exp(lp) for s, lp in logprob_by_score.items()}
    total = sum(lin.values())
    return sum(s * p for s, p in lin.items()) / total
# 裁判对一份摘要给分:3 分最可能,但也可能 2 分
probs = {2: 0.115, 3: 0.876, 4: 0.009}
logprobs = {s: math.log(p) for s, p in probs.items()}
print(argmax := max(probs, key=probs.get), weighted(logprobs))
# 输出:3  2.894 —— 同一份,argmax=3,加权 2.894

把 probs 换成文末”手算表”里的 S1/S2/S3,就能复现 2.894 / 2.863 / 1.464 三个值。亲手跑一次,比读十遍文档更能记住”加权期望 ≠ argmax”。

参考来源

工程实践

arXiv 论文