本文主要介绍 LLM OpenRLHF 库的使用

安装问题

  • 安装时发现 uv 安装比较奇怪，不好下载，所以使用 conda 管理环境
  • 执行安装 pip install flash-attn --no-build-isolation 时收到 pip 包的报警（flash-attn 库不符合新规范），且出现编译卡住，整个电脑无法动弹的情况，修改为 pip install flash-attn --no-build-isolation --use-pep517 后解决（安装需要编译很久 5-10min）

GRPO 运行问题

  • 运行步骤1，用一块显卡启动服务器

    1
    CUDA_VISIBLE_DEVICES=0 trl vllm-serve --model /home/jiahong/llm/model/DeepSeek-R1-Distill-Qwen-1.5B
    • 运行后会开启端口等待

  • 运行步骤2，用剩余的显卡启动训练（由于剩下只有一张显卡，所以并行数量也设置为1）

    1
    2
    3
    4
    CUDA_VISIBLE_DEVICES=1 ACCELERATE_LOG_LEVEL=info \
    	accelerate launch --config_file recipes/accelerate_configs/zero2.yaml --num_processes 1 \
    	src/open_r1/grpo.py --config recipes/DeepSeek-R1-Distill-Qwen-1.5B/grpo/config_demo_local.yaml \
    	--vllm_server_host 127.0.0.1

本文主要介绍LLM的各种评估指标

LLM 的评估指标

  • NLP常见的评估指标包括评估指标可能包括准确率、F1 分数、BLEU 分数、ROUGE 分数和 Perplexity等，其中BLUE 和 ROUGE是自然语言处理中用于评估文本生成质量的两种常用指标
  • 还有许多开源的综合评测体系，会借用以上评估指标来评估各自的得分
  • 比如：Big-bench 的文本生成等任务就需要使用 BLEU 分数和 ROUGE 分数等
  • AGI-Eval 社区 中包含大模型相关的各种评估指标，可以在这里面找到各种评估指标的介绍和使用方式等

BLEU（Bilingual Evaluation Understudy）

  • BLEU 用于评估机器翻译或文本生成结果与参考文本的相似度。它通过计算生成文本与参考文本之间的 n-gram 重叠来评估准确性，并结合简洁惩罚（Brevity Penalty）来惩罚过短的输出。BLEU 得分范围在 0 到 1 之间，1 表示与参考文本完全一致

ROUGE（Recall-Oriented Understudy for Gisting Evaluation）

  • ROUGE 主要用于评估自动摘要生成的质量。它通过计算生成文本与参考文本之间的 n-gram、词序列或词对的重叠来评估召回率（Recall）
  • 常见的 ROUGE 变体包括 ROUGE-N（n-gram重叠）和 ROUGE-L（最长公共子序列）
  • ROUGE 得分范围也在 0 到 1 之间，1 表示与参考文本完全匹配

BLUE 和 ROUGE 对比

  • BLEU ：侧重准确率，常用于机器翻译
  • ROUGE ：侧重召回率，常用于自动摘要
  • 两者均通过n-gram重叠评估生成文本的质量

pass@k 评估指标

  • 原始的 pass@k 指标 ：为每个问题生成 \(k\) 个回复 ，只要其中任意一个回复解决了问题 ，则判定为当前问题被解决
    $$ \text{pass@}k = \frac{被解决的问题数}{总问题数}$$

    • 上面的方法方差较大，基本已经被弃用

  • 改进后的 pass@k 指标(原始指标的无偏估计) ：在 Evaluating Large Language Models Trained on Code, OpenAI, 2021 中提出了一种无偏评估方法，对每个任务生成 \(n\) 个样本（其中 \(n \ge k\)），统计通过单元测试的正确样本数量 \(c\) 个（\(c \le n\)），最后计算无偏估计量 ：
    $$\text{pass@}k := \underset{\text{Problems}}{\mathbb{E}} \left[ 1 - \frac{\dbinom{n - c}{k}}{\dbinom{n}{k}} \right]$$

    • 理解：分母是从 \(n\) 个中挑选 \(k\) 个的排列组合数；分子是从 \(n-c\) 个中挑选 \(k\) 的排列组合数，直观理解就是 在 \(k\) 次尝试中至少有一次成功的概率
      • 无偏估计量的证明：\(P(至少一次成功) = 1- P(全部失败) = 1-\frac{\dbinom{n - c}{k}}{\dbinom{n}{k}}\)
      • 当所有样本都正确时，分子为 0，当前问题样本的 \(\text{pass@}k = 1\)；当所有样本都错误时，分子等于分母，当前问题样本的 \(\text{pass@}k = 0\)
      • 最终的 \(\text{pass@}k\) 是所有问题样本的 \(\text{pass@}k\) 的平均值
    • 这种评估指标更 Soft，对单个问题样本来说，不是绝对的取值为 \(\{0,1\}\)，方差更小，更合适在样本数量较少的场景评估
    • 注意：即使 \(n=k\) 时，也不会退化为原始的 pass@k 指标
    • pass@k 评估指标的实现和证明，详情见 Evaluating Large Language Models Trained on Code, OpenAI, 2021

  • 改进后的 pass@K 指标代码实现：

    1
    2
    3
    4
    5
    6
    7
    8
    def pass_at_k(n, c, k):
       """
       :param n: total number of samples
       :param c: number of correct samples
       :param k: k in pass@$k$
       """
       if n - c < k: return 1.0
          return 1.0 - np.prod(1.0 - k / np.arange(n - c + 1, n + 1))

  • 独立采样还是 Beam Search？

    • 通常使用 核采样（Nucleus Sampling/Top-p）或 温度采样（Temperature Sampling） 进行独立随机采样
    • 不能使用 Beam Search，因为 Beam Search 倾向于生成高度相似的序列，缺乏多样性，无法体现 \(k\) 次尝试的覆盖能力

  • 样本是否可以重复？

    • 在生成阶段，因为是独立采样，完全可能生成两个一模一样的代码块
    • 在计算阶段，公式中的 \(n\) 是总生成数，\(c\) 是正确的数量
    • 重复的正确样本计入 \(c\)，重复的错误样本计入 \(n-c\)
    • 计算过程看作是“无放回抽样”
    • 注：开源实现一般没有看到去重，实际上也可以去重？

  • 重点：为什么有的时候，pass@1 提升了，但是 pass@k 反而下降？

    • 直观上看，由于 pass@k 中的多个样本是完全独立采样的，所以直观上看，pass@1 提升时，pass@k 也一定会提升（因为 pass@k 理论上是一个独立的随机时间发生了 \(k\) 次，至少有一次成功的概率）
    • 实际上，由于 pass@k 还跟答案的多样性有关，举例如下：
      • 模型 A 的 pass@1 为 10%，即每次挑选样本，只有 10% 的概率正确，但答案多样性（范围）高（假设生成的答案都不同），那么模型 A 的 pass@10 大约为 67%，假设每次采样 100 个样本用来计算 pass@10，则：
        $$ pass@10 = 1 - \frac{\dbinom{100 - 10}{10}}{\dbinom{100}{10}} \approx 67%$$
      • 模型 B 的 pass@1 为 20%，即每次挑选样本，只有 20% 的概率正确，但答案多样性（范围）极低（假设对同一个样本，生成的答案都相同），那么模型 B 的 pass@100 大约为 20%（多个不同 样本，模型正确的概率只有 20%）
        • 不能再用上面的计算公式了，因为对于每个 Prompt 来说，没有多样性的模型是非此即彼，此时一个正确就全正确，一个错误就全错误，所以 pass@k = pass@1 = 20%
      • 结论：对于完全没有多样性的模型，pass@1 和 pass@k 其实是相同的；多样性越高，则 pass@1 和 pass@k 的差距越大

SBS（Side by Side）评估指标

  • 人工评测两个模型的好坏（新旧模型对比）
  • 人工打分为四种：好、坏、一样好、一样坏

MMLU

  • 链接：huggingface.co/datasets/cais/mmlu
  • MMLU（Massive Multitask Language Understanding）是一个用于评估大规模语言模型在多种任务和领域上理解和推理能力的综合性基准
  • 原始的数据集一共包含 15,908 道题目，涵盖 57 个不同的学科主题，每个主题至少 100 道题目（每个主题包含以 test 集为主，5道 dev 题目和部分 val 集在内的至少100道题目）
  • 它涵盖了广泛的知识领域和任务类型，旨在全面评估模型的多任务学习能力和泛化能力
  • 具体来说，包含以下能力：
  • 多任务评估 ：
    • MMLU 包含 57个不同的任务，涵盖了人文学科、STEM（科学、技术、工程和数学）、社会科学和其他领域
    • 任务类型包括但不限于问答、文本分类、推理和阅读理解
  • 广泛的知识领域 ：
    • 任务涉及的知识领域非常广泛，包括历史、地理、生物、化学、物理、数学、法律、经济、哲学等
    • 这种多样性使得MMLU能够全面评估模型在不同领域的知识掌握情况
  • 难度层次多样 ：
    • MMLU中的任务难度层次多样，从基础的知识问答到复杂的推理和问题解决任务
    • 这种多样性有助于评估模型在不同难度任务上的表现
  • 零样本和少样本学习 ：
    • MMLU评估模型在零样本（zero-shot）和少样本（few-shot）学习场景下的表现
    • 零样本学习是指模型在没有任务特定训练数据的情况下进行推理，而少样本学习是指模型仅使用少量示例进行推理

MMLU 的评估方法：

  • 任务类型 ：每个任务通常是一个多项选择题或填空题
  • 评估指标 ：主要使用准确率（accuracy）作为评估指标，即模型在所有任务上的平均正确率
  • 数据集 ：MMLU数据集包含大量的问题和答案，涵盖了各种学科和难度级别

MMLU-Redux

  • 链接：huggingface.co/datasets/edinburgh-dawg/mmlu-redux
  • MMLU-Redux 是 MMLU 的人工精校子集，由 14 位专家对 30 个学科各 100 题共 3000 道四选一选择题进行重新标注，公开于 Hugging Face（edinburgh-dawg/mmlu-redux），遵循 CC-BY-4.0 许可
  • 针对 MMLU 存在标注错误、问题 / 选项不清晰等问题，推出高质量、低噪音版本，用于更可靠的模型评估
  • 30 个学科 × 100 题 / 学科 = 3,000 题；
  • 每题含 question、choices、answer（0–3）、error_type、source、correct_answer、potential_reason 等字段
  • 采用层级化错误分类体系，先识别再校正；研究显示在 Redux 上模型排名与原 MMLU 存在显著差异

MMLU-Pro

  • MMLU-Pro 是对经典基准测试集 MMLU 的深度升级版 ，相比于原版 MMLU，MMLU-Pro 做了四个关键的改进：
    • 选项从 4 选 1 增加到 10 选 1
      • 极大地降低了模型通过猜对答案的概率（随机正确率从 25% 降至 10% ）
    • 题目更难、更专业
      • 剔除了一些过于简单的常识题，增加了更多需要 推理 的题目，特别是数学、物理和计算机科学 领域的深度问题
    • 引入 CoT 评估
      • 鼓励模型在给出答案前输出思考过程
      • 在 MMLU-Pro 上，支持 CoT 的模型表现通常远好于直接输出答案的模型
    • 更严格的数据清洗
      • 移除或修正了原版 MMLU 中存在的错误、重复或表述不清的题目，确保评估结果更客观
  • MMLU-Pro 是目前衡量 LLM 推理能力最权威的指标之一顶级模型的出现，原版 MMLU 的得分已经普遍超过 85% 甚至 90%，这导致很难看出谁更聪明

MMLU-ProX (Multilingual MMLU-Pro)

  • 论文：MMLU-ProX: A Multilingual Benchmark for Advanced Large Language Model Evaluation, 20250513, The University of Tokyo
  • MMLU-ProX 是一个大规模多语言多任务语言理解基准（Multilingual Benchmark for Advanced LLM Evaluation）
    • 核心目标是评估模型在不同语言环境下的高级推理和知识水平，而不仅仅是简单的翻译能力
  • MMLU-ProX 继承自 MMLU-Pro：
    • 采用了 MMLU-Pro 的高难度设计，包括将选项从传统的 4 个增加到 10 个（大幅降低了随机猜对的概率），并剔除了原 MMLU 中过于简单或存在噪声的题目
  • 多语言覆盖：支持 29 种 语言（包括中文、日语、德语、法语、俄语以及一些低资源语言如斯瓦希里语等）
  • 版本：
    • 全量版：每种语言包含约 11829 道题目
    • 精简版（Lite）：包含 658 道题目，用于快速评估
  • 高质量翻译：不同于以往完全依赖机器翻译的基准，MMLU-ProX 采用“LLM 代理翻译 + 人工专家审核”的模式，确保了专业术语的准确性和文化适配性

MMMU

  • 链接：huggingface.co/datasets/MMMU/MMMU
  • MMMU (MultiModal Massive Multi-task Understanding) 是针对多模态场景设计的大规模、多任务、多学科基准，在 2023年 提出
  • MMMU 涵盖10大学科，包括生物学、化学、地理等，共1838道问题
    • 每道题目都包含图片和文本信息，需要视觉+语言联合理解
  • MMMU 评估方式 为问题形式为图片与文字结合，多项选择或开放式问答
  • MMLU 的主要评估指标 是 准确率（Accuracy） ，即正确回答问题的比例，尤其关注模型处理跨模态输入后的综合能力

MMMU-Pro

MMMLU

  • 链接：huggingface.co/datasets/openai/MMMLU
  • MMMLU（Multilingual Massive Multitask Language Understanding） 是 OpenAI 发布的一个多语言版本的 MMLU 评测基准 ，用于衡量大模型在多种语言上的知识和推理能力
  • MMMLU 是 OpenAI 基于原始 MMLU 数据集开发的（多语言扩展版）
  • MMMLU 覆盖了 57 个学科，与英文 MMLU 一致，但题目被翻译成了 26种 不同的语言，包括中文、法语、西班牙语、阿拉伯语等主流及部分低资源语言
  • MMMLU 用于评估大型语言模型在跨越不同文化和地区时，能否保持广泛且准确的知识理解与推理能力
    • 每道题为四选一选择题，涉及科学、人文、社会科学等多个领域
    • 各学科问题均以目标测试语言呈现，无需英语中转
  • 通常采用 zero-shot 或 few-shot 设置，即不给或只给少量示例，让模型直接用目标外语作答
  • 核心指标为准确率 (Accuracy)

C-Eval

  • C-Eval 是专门为中文 LLM 设计的第一个综合性、高难度的基准测试集
    • 注：MMLU 是英文，C-Eval 是中文
  • C-Eval 由清华大学、上海交通大学和爱丁堡大学的研究人员在 2023 年联合发布，至今仍是评估国产模型中文水平的重要标准
  • C-Eval 的题目涵盖了中国教育体系下的各类真实考试
    • 包含 13948 道多项选择题
    • 涵盖了 52 个学科，分为四大类：
      • STEM（理工科）： 数学、物理、化学、生物、计算机等
      • Social Sciences（社会科学）： 心理学、教育学、法律、社会学等
      • Humanities（人文科学）： 历史、哲学、艺术、中国文学等
      • Other（其他）： 医师资格考试、公务员考试、注册会计师考试等
    • 包含不同难度：初中 (Middle School)，高中 (High School)，大学 (College)，专业水平 (Professional)
  • 与简单的中文对话测试不同，C-Eval 里的题目很多是考研、注会（CPA）或法考的真题，这些题目不仅考验语言理解，更考验复杂逻辑推理
  • 包含了大量具有中国文化特色的内容（如中国历史、中国法律制度），这是 MMLU 等英文翻译过来的测试集无法触及的
  • C-Eval 包含了一个私有测试集（Hidden Test Set）
    • 模型开发者需要提交预测结果给官方进行评分，而不能提前看到答案，这保证了排名的含金量

MultiLoKo （Multi-Level Long Context）

  • MultiLoKo 是一个专门用于评估模型处理长文本能力的综合性评测基准
  • 核心：解决传统“大海捞针”（Needle In A Haystack）测试过于简单、无法反映真实应用场景的问题
    • MultiLoKo不是只要求找出一个事实的简单测试，MultiLoKo 强调的是：
      • 多层级（Multi-Level）： 从简单的检索到复杂的跨段落逻辑推理
      • 真实分布（Real-world Distribution）： 模拟真实的长文档，如法律文件、长篇小说或技术手册，而不是随机填充的无意义文本
  • MultiLoKo 主要关注模型在不同长度（从几千到几十万个 token）和不同难度级别下的长文本理解与推理能力
  • 通常从以下三个“层级”来衡量模型表现：
    • 基础检索 (Retrieval) ：考察模型能否在长文本中定位特定信息
      • 例如：“在这份 50 页的合同中，违约金是多少？”
    • 信息聚合 (Aggregation) ：考察模型能否收集分布在文本各处的离散信息
      • 例如：“总结文档中提到的所有五种风险因素”
    • 复杂推理 (Reasoning) ： 考察模型能否理解长程依赖关系并进行逻辑推导
      • 例如：“基于前文提到的 A 事件和后文的 B 条件，推断 C 的结果”

Simple-QA（SimpleQA）

  • Simple-QA 是 OpenAI (2024年11月) 发布，评估模型“事实性（Factuality）”和“自我认知（Calibration）”的基准测试
    • 主要测量模型回答短促、事实性问题的能力，并观察模型是否“知道自己不知道”（即无法回答时是否会坦诚拒绝，而不是胡编乱造）
  • Simple-QA 包含 4,326 个问题
  • Simple-QA 的题目是高难度的，题目经过对抗性筛选（Adversarial Collection），专门针对 GPT-4 等强模型容易犯错的地方
    • *每个问题都有一个确定的、不随时间变化的唯一答案（例如：某个冷门历史事件的年份）
  • Simple-QA 的 评分标准：
    • Correct（正确）
    • Incorrect（错误）
    • Not Attempted（未尝试，即模型承认不知道）

Simple-QA Verified（SimpleQA-Verified）

  • Simple-QA Verified 是 Simple-QA 精修版
  • Simple-QA Verified 是 Google DeepMind / Google Research (2025/2026年) 发布的
  • Google 认为原始的 Simple-QA 虽然好，但存在一些“噪音”，比如部分标签错误、题目重复度高、或者话题过于集中在某些领域（如过多的日期问题）
  • Simple-QA Verified 改进点
    • 精简与去重： 从原始的 4,000 多题中精选出 1,000 个 高质量 prompt
    • 话题平衡： 重新平衡了题目类型，减少了对日期（Dates）的过度依赖，增加了更多元的事实类型
    • 更严谨的标注： 修正了原版中一些错误的参考答案（Ground Truth），提高了评测的“干净程度”
    • 优化评分器： 改进了用于自动评分的 Model Grader（判分模型）的提示词，使其在处理数字或复杂简答时更准确，防止模型通过冗长的回答来蒙混过关
  • 注：
    • 如果想看一个模型的基础事实库有多大，看 Simple-QA
    • 如果想在排除掉题目干扰、重复和错误答案的前提下，更严谨地对比顶级模型（如 GPT-5, Gemini 2, Claude 3.7）之间的事实水平差异，Simple-QA Verified 是目前公认更具参考价值的标尺

Chinese-SimpleQA (中文简短事实问答)

  • Chinese-SimpleQA（Chinese SimpleQA） 专注于评估大模型在中文语境下的短篇事实性（Factuality）
    • Chinese-SimpleQA 要求模型对具有唯一确定答案的事实问题给出简洁、准确的回答
  • Chinese-SimpleQA 继承了 SimpleQA 评测指标的 “严苛性”：
    • 问题设计避开了模糊空间，答案通常是一个日期、一个名字或一个具体数值，模型稍有幻觉即被判定为错误
  • 它常被用于衡量模型在经过 RL 或长上下文训练后，是否依然能保持极高的中文事实准确度

Big-Bench

  • 链接：待补充
  • Big-bench（Beyond the Imitation Game Benchmark）是一个大规模、多样化的基准测试，旨在评估语言模型在各种复杂任务上的表现
  • Big-bench 由社区驱动，包含大量任务，涵盖了广泛的知识领域和技能类型，旨在推动语言模型的能力边界，具体来说，包含以下能力：
  • Big-bench 包含超过200个任务，涵盖了语言理解、推理、知识问答、翻译、数学计算、编程、常识推理等多个领域
    • 任务类型包括但不限于问答、文本生成、分类、排序、逻辑推理等
  • 根据任务类型不同，评估指标可能包括准确率、F1 分数、BLEU 分数、ROUGE 分数等
  • 任务难度从简单到复杂不等，既有基础的语言理解任务，也有需要复杂推理和问题解决能力的任务
    • 这种多样性有助于评估模型在不同难度任务上的表现
  • Big-bench 是由研究社区共同贡献和维护的，任务由来自不同领域的研究者设计和提交
    • 这种社区驱动的模式使得Big-bench能够不断扩展和更新，保持其前沿性和多样性
  • Big-bench 旨在评估模型在未见过的任务上的泛化能力，而不仅仅是在特定任务上的表现
    • 通过大量多样化任务的评估，Big-bench 能够全面反映模型的综合能力

BBH

  • HuggingFace 地址：huggingface.co/datasets/lighteval/bbh
  • BBH 评估集（Big-Bench Hard）是 BIG-Bench（Beyond the Imitation Game Benchmark） 中最具挑战性的子集，由 Google 研究团队于 2022 年提出，专门用于评估大语言模型在高阶推理任务上的表现
  • BBH 从 BIG-Bench 的 204 项任务中，筛选出 23 项当前语言模型表现显著低于人类水平的任务
  • BBH 涵盖复杂推理、因果判断、反事实理解、多步规划等高阶认知能力，包含多个任务的共 21 个子集，下面列举几个任务：
    • 因果判断（causal judgment）
    • 布尔逻辑推理（boolean expressions）
    • 多步数学推理（Multi-step mathematical reasoning）
    • 反事实推理（Counterfactual reasoning）
  • BBH 支持多种提示方式，包括标准提示（answer-only）和 思维链提示（Chain-of-Thought, CoT） ，后者能显著提升模型表现
  • BBH 可通过 GitHub 官方仓库获取数据集和运行脚本，支持自定义模型评估

HELM（评估框架）

  • GitHub 开源框架地址：github.com/stanford-crfm/helm/
  • 论文地址：Holistic Evaluation of Language Models, Stanford, 202308
  • 斯坦福地址：crfm.stanford.edu/helm/
  • HELM（Holistic Evaluation of Language Models，语言模型整体评估）是一个由斯坦福大学开发的综合性评估框架，旨在全面评估大语言模型（LLMs）在多个维度和任务上的表现
  • HELM 的评估指标涵盖了广泛的能力和场景
  • HELM 从多个维度对语言模型进行评估，包括但不限于：
    • 准确性 ：模型在各类任务中的表现，如问答、信息检索、摘要生成等
    • 稳健性 ：模型对输入变化的鲁棒性，例如拼写错误、同义词替换等
    • 公平性 ：模型输出是否对不同群体存在偏见或歧视
    • 效率 ：模型的推理速度和资源消耗
    • 有毒性 ：模型生成内容是否包含有害或不当信息
    • 不确定性 ：模型输出的置信度是否合理
    • 环境影响 ：模型训练和运行的能耗及碳排放
  • HELM 设计了16个核心场景 ，覆盖了语言模型的主要应用领域，例如：
    • 问答任务 ：如 Natural Questions、MMLU 等
    • 信息检索 ：如微软的 Macro 数据集
    • 摘要生成 ：如 CNN/Daily Mail 和 XSum 数据集
    • 情感分析 ：如 IMDB 电影评论数据集
    • 毒性检测 ：如 CivilComments 数据集
  • HELM采用“自上而下”的方法，由专家团队精心选择和设计评估任务，确保评估的高质量和针对性。其评估方法包括：
    • 自动化评估 ：使用标准指标（如准确率、F1分数、ROUGE等）对模型进行量化评估
    • 人类评估 ：通过众包平台进行A/B测试，评估模型生成内容的有用性和无害性
    • 红队分析 ：邀请领域专家对模型进行对抗性测试，识别潜在风险和漏洞

Arena

  • Arena(竞技场/角斗场)大模型测评方法是一种凉凉对战评测的方法，用户可以并排与两个匿名模型聊天，并通过投票选出哪一个更好。最后，根据PK结果使用ELO评分系统对模型进行评分和排名‌
  • 除了大模型以外，多模态模型也可以采用这个方式，其中典型的平台包括典型平台包括：
    • Chatbot Arena ：由LMSYS Org推出，支持190多种大语言模型的匿名对战和排名，详情见：https://lmarena.ai/
    • Compass Multi-Modal Arena ：支持多模态模型的匿名对战，涵盖图像理解和生成任务，详情见：https://rank.opencompass.org.cn/home
    • Decentralized Arena：基于群体智能的多维度评估平台，支持自动化和可定制化评测
  • LMArena 由加州大学伯克利分校发起，是一个透明的平台，通过人类判断评估和比较前沿 AI 能力，处理数百万的真实任务
    • 包括写作、编码、推理、设计、搜索和创造
    • LMArena 上大量的人类交互产生了反映现实世界实用性的信号

Arena-Hard

Arena-Hard v2

  • Arena Hard v2 (ArenaHardV2, Arena_Hard_v2) 数据来源于 github.com/lmarena/arena-hard-auto
  • Arena-Hard v2（Arena-Hard Benchmark version 2），来自 LMSys (Large Model Systems Organization)
  • Arena-Hard v2 是一些挑战性问题的集合，旨在通过更难、更具迷惑性的问题来区分顶级模型之间的性能差异，这些问题通常需要复杂推理、多步逻辑或对细节的精确理解
  • Arena-Hard v2 使用 GPT-4.1 和 Gemini-2.5 打分来评估模型效果
  • Arena Hard v2 共两个数据集（github.com/lmarena/arena-hard-auto/blob/main/data/arena-hard-v2.0/question.jsonl）：
    • Hard Prompt 数据集（category==hard_prompt）：共 500 条
      • subcategory=coding：253 条
      • subcategory=math：247 条
    • Creative Writing 数据集（category==creative_writing）：共 250 条
      • subcategory=creative_writing: 250 条
    • 注：LMArena 榜单也会区分出好几个类别，其中就包含了：Hard Prompts 榜单和 Creative Writing 榜单等
  • 评估时，Arena-Hard v2 上报 3 个子榜单：
    • 榜单1：Creative Writing，简称（CW），评估准确率，准确率评估值来源于 GPT-4.1 和 Gemini 2.5（作为 Judge）综合打分
    • 榜单2：Hard Prompt GPT4.1-based Score
    • 榜单3：Hard Prompt Gemini-2.5-pro Score
    • 榜单 2 和 榜单 3 的 Prompt 是一样的，只是因为两者可能有不同的偏好，所以都用了

MATH-500（数学）

  • huggingface.co/datasets/HuggingFaceH4/MATH-500包含500道题目（都在 test split 里面）
  • 每道题目包含 problem，solution，answer，subject，level，unique_id 列
    • subject 列： 指出题目类型，比如代数（Algebra）、数论（Number Theory）等
    • level 列：指出题目等级，level 越大，难度越大

AMC（数学）

  • 包含 AMC 8，AMC 10，AMC 12 三个赛事，题目难度逐渐提升
  • AMC 和 AIME 是有一定关系的：
  • AMC 的题目会被包含在其他数学类测试集中

AIME（数学）

  • AIME 是美国数学邀请赛（American Invitational Mathematics Examination）的简称‌，是美国数学竞赛（AMC）系列中的高级别赛事，旨在选拔在 AMC10/12 中表现优异的学生，为美国数学奥林匹克竞赛（USAMO/USAJMO）和国际数学奥林匹克（IMO）选拔参赛者
  • AIME 每年都会有新的题目出现，对 LLM 来说属于比较难的题目
  • 比如 2024 和 2025 数据集如下：

OlympiadBench

GPQA

  • HuggingFace 链接：huggingface.co/datasets/idavidrein/gpqa
  • GitHub 链接： github.com/idavidrein/gpqa
  • 论文链接： GPQA: A Graduate-Level Google-Proof Q&A Benchmark, arXiv 20231220
  • GPQA（Graduate-Level Google-Proof Q&A），一个极具挑战性的数据集，包含多个子集，每个子集几十到几百道由生物、物理和化学领域专家编写的多项选择题
  • GPQA 数据集每行包含很多列，信息非常详细，比如正确答案 1 个，错误答案 3 个等，常常用作 4 选 1 的选择题形式
  • GPQA 任务类型属于知识 + 复杂推理（MCQ）
  • GPQA 评估指标常用 Accuracy
  • GPQA 常用设置 0-shot / few-shot / Chain-of-Thought

GPQA-D

  • GPQA-D（GPQA Diamond）全称 Graduate-Level Google-Proof Q&A Diamond，是 GPQA（Graduate-Level Google-Proof Q&A）基准的“超高难度”子集，专门用来测试大模型在 博士级科学问题 上的深度推理与专业知识运用能力
  • HuggingFace 链接（与 GPQA 相同）：huggingface.co/datasets/idavidrein/gpqa
    • GPQA-D 在上述链接的子集里
  • GPQA-D 包含 198 道四选一选择题，涵盖 生物学、物理学、化学 等专业

SuperGPQA

  • SuperGPQA 是 GPQA 的 强化版
    • GPQA (Graduate-Level Google-Proof Q&A):
      • 规模较小，仅包含约 448 道 题目（最难的 Diamond 集合仅 198 道），且只集中在 物理、生物、化学 三个科学领域
      • 标准的 4 选项 单选题模式（A, B, C, D）
    • SuperGPQA:
      • 规模庞大，包含超过 26,000 道 题目，覆盖了 285 个 研究生级别的细分学科（包括工程、医学、经济、法学、人文等）
      • 选项增加到了 10 个（A 到 J）
  • 与 GPQA 遵循同一个核心设计原则：题目不能通过简单的搜索引擎搜索直接得到答案（Google-Proof 理念）

FACTS Leaderboard（包含多个指标）

FACTS Grounding v2（上下文依托）

  • 评估模型是否能够严格基于提供的文档生成回答，而不依赖外部知识或自身记忆
  • 任务类型包括：长文本问答、摘要、文档重写等
    • 注：回答必须完全来源于给定上下文，不能引入外部信息，考察 Context Learning 能力
  • 使用多个 Judge 模型（如 Gemini 2.5 Flash 和 GPT-5）判断回答是否“扎根”于上下文，并排除“不充分回答”（如过于笼统、回避问题）

FACTS Multimodal（多模态事实性）

  • 评估模型在图像理解任务中的事实准确性
  • 任务类型基于图像回答问题，需要结合视觉信息和世界知识
  • FACTS Multimodal 评估方式
    • 覆盖率 ：回答是否包含人工标注的“关键事实”
    • 无矛盾性 ：回答是否与图像、常识或标注事实相矛盾
    • 准确性 ：只有同时满足“覆盖关键事实”和“无矛盾”的回答才算正确

FACTS Parametric（参数化知识）

  • 评估模型仅依靠内部参数（无外部工具）回答事实性问题的能力
  • 问题来源于用户真实搜索兴趣，且答案必须能在 Wikipedia 中找到
    • 注：筛选了通过对抗采样（用多个开源模型测试，只保留所有人都答错的难题）确保挑战性
  • 评估方式使用 Judge 模型判断回答是否正确、是否回避、是否尝试回答等

FACTS Search（搜索增强事实性）

  • 评估模型使用搜索工具（Brave Search API） 获取信息并回答问题的能力
  • 任务类型包括难找的实体、多跳问题、跨文档合成、知识图谱多跳等
  • 数据构造方式：人工撰写 + 自动生成（如 Wiki 两跳、多文档、KG 跳数）
  • 评估方式使用 Judge 模型判断回答是否正确、是否尝试回答，同时记录平均搜索次数

ARC 数据集

  • ARC 数据集，即 AI2 Reasoning Challenge（AI2 推理挑战）数据集
  • 整个 ARC 数据集包含 7787 道问答题目，分为 ARC Challenge Set（挑战集）和 ARC Easy Set（简单集）
  • ARC 旨在评估大模型对科学问题的理解和推理能力
  • ARC Challenge Set 包含 2590 道较难的问题
  • 部分论文中也会使用 ARC Benchmark 或 ARC Challenge Benchmark 来表示以数据集为基准
  • 注：还有一个重名的数据集 Abstraction and Reasoning Corpus（ARC）
    • 这是由 François Chollet 于 2019 年发布的基准测试集，旨在评估 AI 系统在面对全新任务时的抽象推理和泛化能力

ARC-AGI

RULER

  • GitHub 地址：github.com/NVIDIA/RULER
  • RULER 测试集是 NVIDIA 在 2024年6月 发布的一个用于评估语言模型长上下文建模能力的基准测试数据集
  • RULER 的任务类别包括：
    • 检索 ：扩展了大海捞针（Needle in a Haystack，NIAH）测试，包括单针检索（Single NIAH，S-NIAH）、多针检索（Multi-keys NIAH，MK-NIAH）、多值 NIAH（Multi-values NIAH，MV-NIAH）和多查询 NIAH（Multi-queries，MQ-NIAH）四个任务，用于评估模型在不同类型和数量“针”情况下的检索能力，要求检索能力与“针”和“大海”的类型无关，能忽略硬干扰，且在检索多个项目时具有高召回率
    • 多跳跟踪 ：提出变量跟踪（Variable Tracing，VT）任务，模拟最小的指代链解析任务，检查模型跟踪相关共现模式和在长输入中绘制跳过连接的行为，通过增加跳数或链的数量来增加任务复杂性
    • 聚合 ：引入常见词提取（Common Word Extraction，CWE）和频繁词提取（Frequent Word Extraction，FWE）任务，作为摘要任务的代理，用于测试模型聚合跨越长距离上下文相关信息的能力
    • 问答 ：在现有短上下文问答数据集的输入中添加干扰信息，以评估模型在各种上下文大小下的问答能力
  • 注：RULER 测试集 主要用于评估长上下文语言模型

Longeval (Long-context Evaluation)

  • Longeval 用于评估大型语言模型在处理和利用长上下文信息时的表现
  • 任务类型包括：
    • 长对话理解: 模型需要理解并回应一个非常长的、包含多个轮次的对话历史
    • 长文档问答: 模型需要基于一篇长文档（如论文、报告）来回答具体问题
  • Longeval 的数据长度通常在几千到几万个 token 之间，模拟了用户与AI助手进行长时间、多主题深入交流的场景
    • 更侧重于测试模型在多轮对话中维持上下文一致性和记忆关键信息的能力
  • 评估方式：通常使用自动化的脚本，通过比较模型生成答案与标准答案的精确度、召回率或 F1 分数来进行评估
  • 强调了在“对话”和“单文档问答”这两个实用场景下对模型长文本能力进行压力测试的重要性

LongBench

LongBench-V2

  • 论文地址：LongBench v2: Towards Deeper Understanding and Reasoning on Realistic Long-context Multitasks
  • GitHub 地址(与 LongBench 想通)：github.com/THUDM/LongBench
  • Hugging Face 地址：huggingface.co/datasets/zai-org/LongBench-v2
  • LongBench V2 是 LongBench 升级版，这是一个旨在评估 LLMs 处理长语境问题能力的基准测试
  • LongBench V2 包含503道具有挑战性的多项选择题，题干文本长度跨度从 8K 到 2M Words 不等，涵盖六大主要任务类别，具体如下：
    • 单文档问答（single-document QA）
    • 多文档问答（multi-document QA）
    • 长语境学习（long in-context learning）
    • 长对话历史理解（long-dialogue history understanding）
    • 代码仓库理解（code repository understanding）
    • 长结构化数据理解（long structured data understanding）
  • 为确保测试的广度与实用性，研究团队从近 100 位拥有不同专业背景的高学历人士处收集数据
    • 同时，通过自动化与人工审核相结合的流程，保障测试数据的高质量与高难度
    • 难度体现：在15分钟的时间限制下，人类专家的答题准确率仅为 53.7%
  • o1-preview 模型准确率 57.7%，比人类基准准确率高出 4 个百分点

InfiniteBench

  • GitHub地址：github.com/OpenBMB/InfiniteBench
  • InfiniteBench 专注于评估模型在 “无限”或“极长” 上下文长度下的表现
    • 任务通常具有非常长的输入文本（可达 100K tokens 甚至更长），并且答案（或关键信息）往往被刻意放置在输入的非常深的位置（例如中间部分），以此来挑战模型在超长序列中“大海捞针”的能力
    • 特别关注模型是否真的利用了全部上下文，而不是仅依赖开头或结尾的信息
  • InfiniteBench 主要特点：
    • 极长的上下文: 输入文本长度远超常规评测
    • “大海捞针”式任务: 关键信息被隐藏在长文本的任意位置
    • 抗捷径设计: 任务设计旨在防止模型通过只看开头/结尾等“作弊”方式获得高分
    • 覆盖英语和中文任务

HelloBench

  • 论文地址：HelloBench: Evaluating Long Text Generation Capabilities of Large Language Models
  • HelloBench，是层级式长文本生成基准测试（Hierarchical Long Text Generation Benchmark）
  • HelloBench 将长文本生成任务划分为五个子任务，分别是：
    • 开放式问答（open-ended QA）
    • 文本摘要（summarization）
    • 对话生成（chat）
    • 文本补全（text completion）
    • 启发式文本生成（heuristic text generation）

MorehopQA

  • 论文地址：MoreHopQA: More Than Multi-hop Reasoning
  • GitHub：github.com/Alab-NII/morehopqa
  • MoreHopQA 是多跳数据集
  • 背景：在 MoreHopQA 前，大多数已有的多跳数据集均为抽取式答案数据集（此类数据集的问题答案可直接从给定语境中提取得到）
    • 这一特点往往导致模型采用启发式方法或“捷径”解题，而非执行真正的多跳推理
  • MoreHopQA 数据集将答案形式从“抽取式”转向“生成式”
  • MoreHopQA 的构建以三个现有多跳数据集为基础，分别是 HotpotQA、2WikiMultihopQA 和 MuSiQue
    • 在构建过程中，不再单纯依赖事实推理，而是通过增加一层“拓展问题”来升级原有多跳问题
    • 这些拓展问题需涉及以下一种、两种或全部三种推理类型：
      • 常识推理（commonsense）
      • 算术推理（arithmetic）
      • 符号推理（symbolic）
  • MoreHopQA 数据集通过“半自动化流程”构建而成，最终包含 1118 个样本，且所有样本均经过人工验证
  • 仅有部分模型能实现“完美推理”（即所有相关子问题均回答正确），其中 GPT-4 的完美推理率为 38.7%，Llama3-70B 的完美推理率为 33.4%

HLE（推理）

  • HLE 是“Humanity’s Last Exam”的缩写，即“人类最后一次考试”，由 Center for AI Safety（AI安全中心）与Scale AI联合打造
  • HLE 是一个多模态基准测试，旨在成为封闭式学术基准测试的最终版本，用于衡量大语言模型在人类极限能力边界上的通用推理与智能水平
  • HLE 包含3000个问题，涉及上百门学科，包括数学、人文科学和自然科学等
  • HLE 包含精确匹配题和选择题两种
    • 其中 80% 的问题为精确匹配题，模型需要输出一个完全匹配的字符串作为答案；
    • 其余为选择题，模型需要从五个或更多选项中选择一个正确答案
    • 此外，10% 的问题要求理解文本和图像参考
  • HLE 每个问题都有一个已知的明确且易于验证的解决方案，但无法通过快速互联网检索获得答案，通常需要研究生水平的专业知识或高度特定主题的测试知识
  • HLE由来自 50 个国家的 500 多个机构的近 1000 名学科专家贡献，经过问题筛选、迭代优化、手动审核等流程创建，同时还保留了一部分私有测试集，用于评估模型是否存在过拟合现象
  • 如果模型在 HLE 中获得高分，将表明模型在封闭式、可验证的问题以及前沿科学知识方面具备专家级表现，有助于推动模型在复杂问题上的表现提升，为研究者提供了一个标准化工具，用于比较不同模型在跨学科任务中的表现

HLE-Verified-Full（HLE 的高质量验证完整版）

  • HLE-Verified-Full 是对原始 HLE 数据集进行深度清洗、人工校验和修正后的高可靠性版本
    • 解决原始 HLE 数据可靠性不足的问题，提升验证的透明度，为更稳健的模型能力测量提供基础设施支持
  • HLE-Verified-Full 侧重于数据的绝对准确性和透明度 ，考察模型在无错误干扰下的真实水平
  • HLE-Verified-Full 将数据严格划分为三个子集，并提供了完整的验证元数据与错误类型标注：
    • Gold（668 题） ：完全准确、无争议的黄金标准数据
    • Revision（1,143 题） ：经过修正和调优的题目
    • Uncertain（689 题） ：存在一定争议或不确定性的题目
  • HLE-Verified-Full 通常指代在评测时使用了上述所有验证子集（共计2500题） 的完整评测结果，以全面衡量模型在修正后数据集上的综合表现

HLE-V2-Zero（在 HLE 的基础上添加了一些高难度问题）

  • HLE-V2-Zero 是 HLE 基准测试的第二代（Version 2） ，且限定了Zero-shot的提示词评测环境
  • HLE-V2-Zero 在 HLE 和 HLE-Verified 的基础上，V2 往往引入了全新的题目、更高的难度上限或更广的推理领域，以应对诸如 DeepSeek-R1、OpenAI o3 等新一代具备强化学习（RL）自我进化能力的推理模型
  • HLE-V2-Zero 侧重于更难的题目与更严苛的提示词条件 ，考察模型在缺乏示例引导时的原生“硬推理”能力

IFEval

  • IFEval（Instruction Following Evaluation）是用于评估大模型指令遵循的指标
  • 链接：huggingface.co/datasets/google/IFEval
  • IFEval 是一个专门用于评估模型遵循指令能力的基准
    • 它不侧重于解决具体问题，而是看模型能否严格按照指令中的各种约束来生成回应
    • 约束复杂多样，例如“以 X 开头”、“用 Y 结尾”、“提到某个词 Z 次”、“段落数量不超过 N 个”等等
  • IFEval 评估集包含大约 400 条带有明确约束的提示（Prompt），涵盖了 25 种不同类型的约束
  • 评估时，通过自动检查生成的内容是否满足所有指令约束来计算模型的准确率
  • 在 IFEval 基准测试中，按照要求严格程度，分为 “strict prompt”（严格提示）和 “non-strict prompt”（非严格提示）两种评估策略（两者主要体现在对模型输出的评估标准上，而不是提示本身的内容）
    • Strict Prompt (严格提示) ：采用非常严格的评估标准。模型的输出必须精确匹配所有预定义的要求才算正确
      • 即使内容基本正确，但只要在格式、措辞、顺序或某个细节上与预期有丝毫偏差，就会被判定为错误
      • 这通常用于评估模型执行高度结构化或精确指令的能力
      • 目的是测试模型的精确性和可靠性
    • Non-strict Prompt (非严格提示) ：采用更宽松的评估标准
      • 评估者会判断模型的输出是否在语义上满足了指令的核心要求 ，允许一定的表达差异或格式灵活性
      • 只要关键信息正确且意图达成，即使不完全一致，也可能被视为正确
      • 目的是测试模型的理解和意图实现能力

IFBench

  • 论文地址：(IFBench)Generalizing Verifiable Instruction Following, NeurIPS 2025, AI2
  • IFBench 是一个用于评估语言模型在精确指令遵循（precise instruction following） 任务上泛化能力的新基准测试
  • IFBench 的目标
    • 提供一个更具挑战性、更贴近现实用户约束、更严格 的评估平台
    • 揭示当前模型在“精确指令遵循”任务上的泛化能力短板
  • IFBench 核心特点包括：
    • 1）全新且未见过的约束（constraints）
      • 包含 58 种新的、多样且具有挑战性的可验证输出约束 ，例如句子/单词/字符操作、计数、格式控制、复制等
      • 这些约束与现有流行的基准（如 IFEval）中的约束不重叠 ，用于测试模型对“未见过约束”的泛化能力
    • 2）自动可验证
      • 每个约束都配有 Python 编写的验证函数，可以实现自动化评估，保证结果可重复
    • 3）更低的模型表现
      • 截止到 25年 发布，即使是最先进的模型（如 GPT-4.1、Claude 3.7 Sonnet 等）在 IFBench 上的准确率也低于 50% ，而在 IFEval 上它们通常能超过 80%。
      • 这表明现有模型过度拟合于常见的约束类型，泛化能力不足
    • 4）评估设置
      • 支持 单轮（single-turn） 和 多轮（multi-turn） 评估
      • 每个指令包含 1 或 2 个约束
      • 提供 严格（strict） 和 宽松（loose） 两种准确率计算方式（如去除首尾行、字体修饰符等）
    • 5）数据来源与构造
      • 约束由人工设计，并结合来自 WildChat 的未见提示（unseen prompts）构造出 300 条测试样本
      • 每一条样本都经过人工验证，确保提示与约束兼容

GuideBench: Benchmarking Domain-Oriented Guideline Following for LLM Agents

  • 论文地址：GuideBench: Benchmarking Domain-Oriented Guideline Following for LLM Agents, ACL 2025, SJTU, BateDance

  • GitHub 地址：github.com/Dlxxx/GuideBench

  • 背景：LLM 正越来越多地被用作领域导向型智能体，这类智能体的运行依赖于特定领域的指南（domain-oriented guidelines），而这些 guidelines 可能与模型自身的常识知识存在冲突

    • 这类领域 guidelines 具有两个关键特征：一是包含大量领域专属规则，二是会频繁更新

  • GuideBench（指南基准）是一个专为评估大语言模型指南遵循性能而设计的综合基准

  • GuideBench 从三个关键维度对大语言模型进行评估：

    • （1）对多样规则的遵循程度
    • （2）对规则更新的鲁棒性
    • （3）与人类偏好的对齐度

  • 示例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    你的任务是根据提供的指令、文案输出判断结果与具体分析。
        首先，请仔细理解：
        Instruction为通用任务目标，内容为：
            <Instruction>比较食品A和食品B是否满足同品的定义</Instruction>
        Guideline为用户定义的规则，内容为：
            <Guidelines>[{'type': '价格判断规则', 'rule_id': 'rule_28', 'rule_text': '若两个商品子项均有价格描述且不同，或只有一个商品子项有价格描述，认为这两个商品子项价格不同'}, {'type': '款式判断规则', 'rule_id': 'rule_15', 'rule_text': '若只有一个商品子项有款式描述，认为这两个商品子项款式相同'}, {'type': '商品搭配判断规则', 'rule_id': 'rule_20', 'rule_text': '若两个商品子项，一个有商品搭配描述，另一个没有商品搭配描述，认为这两个商品子项商品搭配不同'}, {'type': '价格判断规则', 'rule_id': 'rule_45', 'rule_text': '若两个商品子项均无价格描述，认为这两个商品子项价格相同'}, {'type': '商品子项一致性判断规则', 'rule_id': 'rule_14', 'rule_text': '若两个商品子项的款式、份数、口味、食材、规格完全相同，则认为这两个商品子项一致，两个商品可能相同（需整体商品搭配判断）'}, {'type': '制作工艺判断规则', 'rule_id': 'rule_30', 'rule_text': '若两个商品子项均有制作工艺描述且不同，或只有一个商品子项有制作工艺描述，认为这两个商品子项制作工艺不同'}, {'type': '商品搭配判断规则', 'rule_id': 'rule_23', 'rule_text': '若两个商品子项均有商品搭配描述，不考虑其内容是否相同，均认为这两个商品子项商品搭配相同'}, {'type': '份数判断规则', 'rule_id': 'rule_40', 'rule_text': '若两个商品子项均无份数描述，认为这两个商品子项份数相同'}, {'type': '规格判断规则', 'rule_id': 'rule_51', 'rule_text': '若两个商品子项均有规格描述但单位不同，需换算后判断，若换算后相同则认为规格相同，否则认为规格不同'}]</Guidelines>
        文案内容：
        <Context>商品A标题：健康轻食优选。商品详情：一份蔬菜沙拉，口味清爽，规格150克，无额外搭配。商品B标题：营养轻食之选。商品详情：一份同样口味清爽的蔬菜沙拉，规格150克，无额外搭配。</Context>
        输出json格式。包括两个字段，CandidateAnswer和CandidateAnalysis。其中CandidateAnswer仅输出0或1，0代表否定，1代表肯定；CandidateAnalysis中给出简要分析，不要指出rule_id和type。
    • 对应的正确答案： 
      1
      [{"output":{"text":"{\"ReferenceAnswer\": 1, \"ReferenceAnalysis\": \"商品A和商品B的款式、份数、口味、食材、规格完全相同，且都无商品搭配，所以是同品。\", \"sub_set_name\": \"price\"}"},"tags":["correct"]}]

HMMT

  • HMMT（Harvard-MIT Mathematics Tournament）是 “哈佛-麻省理工大学数学竞赛”，是全美国影响力最大和名校理工科专业认可程度最高的高中数学竞赛之一
  • HMMT 作为面向全球顶尖高中生的最高水平数学竞赛之一，其题目难度高，覆盖代数、几何、组合数学、微积分等多个领域，需要极强的逻辑推理和创造性解题能力
  • HMMT 竞赛题通常在多个数学数据集中被整合，目前暂时没有一个独立的 HuggingFace 官方仓库
  • 在大模型评估集中，HMMT 代表了使用哈佛-麻省理工数学锦标赛（HMMT）的题目作为评估数据集
    • 将其作为评估指标，旨在衡量模型在专业级数学推理方面的极限
    • 数据量通常是历年竞赛的几百到几千道题目
    • 比如：HMMT 25 表示 25 年的 HMMT 比赛试题集合

IMO-ProofBench

  • IMO（International Mathematical Olympiad）：国际数学奥林匹克（全球最高级别数学竞赛）
  • IMO-ProofBench 是一个证明数据集

IMO-AnswerBench (奥数简答基准)

  • IMOAnswerBench（IMO-AnswerBench） 是针对国际数学奥林匹克（IMO）级别题目设计的评测集，主要侧重于可自动验证的简答题
  • 它旨在测试模型的深度推理（Deep Reasoning）能力，题目难度极高，涵盖代数、组合、几何、数论等领域
  • 相比于需要人工阅卷的证明题（IMO-Proof），IMOAnswerBench 允许通过数值或表达式匹配进行规模化、客观的性能评估

附录：一些数学比赛集合

  • AIME（American Invitational Mathematics Examination）：美国数学邀请赛（高中阶段）
  • HMMT（Harvard-MIT Mathematics Tournament）：哈佛-麻省理工数学竞赛（全球顶尖高中竞赛）
  • IMO（International Mathematical Olympiad）：国际数学奥林匹克（全球最高级别数学竞赛）
  • CMO（Chinese Mathematical Olympiad）：中国数学奥林匹克（中国国家队选拔赛事）
  • Putnam（William Lowell Putnam Mathematical Competition）：普特南数学竞赛（北美顶尖大学竞赛）

BeyondAIME

LiveCodeBench (24/8∼25/5)

  • LiveCodeBench，简称（LCB），通常还会加上时间周期，比如用表达如 LiveCodeBench (24/8∼25/5) 表示 24年8月 至 25年5月 期间的题目
  • LiveCodeBench 是一个动态的、持续更新的编程能力评估基准
  • LiveCodeBench 每周都会从 LeetCode、AtCoder、CodeForces 等在线编程竞赛平台收集最新的、真实的人类竞赛题目
  • LiveCodeBench 可以有效防止模型在训练数据中“见过”评测题目，从而更真实地反映模型的泛化编程能力

OIBench

OIBench 的区分度足够好

  • 对 18 个主流模型的 zero-shot 评测显示：
    • 推理型模型平均约 21.4%，显著高于普通指令微调模型的约 3.6%；
    • o4-mini-high 以 36.35 分领先，说明能拉开真实差距
  • 闭源模型平均 14.5%，开源 6.3%；语言偏好上，JavaScript/Python 平均低于 C++/Java 约 10%，中英文差异很小
  • 伪代码提示可显著提升所有模型表现，强推理模型提升更明显；o4-mini-high 以较少 Token 解出更多题，推理效率最佳

OJBench

ZebraLogic

Sudoku-Bench

  • HuggingFace 链接：huggingface.co/datasets/SakanaAI/Sudoku-Bench
  • 属于推理数据集
  • Sudoku-Bench 是一个用于评估模型解决数独谜题能力的基准
    • 注：数独是一个经典的逻辑和约束满足问题，它需要模型理解规则（每行、每列、每宫数字1-9不重复）并根据给定的数字进行推理

Aider-Polyglot

  • 官方链接：epoch.ai/benchmarks/aider-polyglot
  • Aider-Polyglot Code Editing Benchmark，是一个代码编辑基准，对应 AI 编程助手项目 Aider 上的题目
    • Polyglot 含义是“多语言的”，意味着支持多语言（C++, Go, Java, JavaScript, Python, and Rust）

SWE-bench

  • 又名 SWE Bench（Software Engineering Benchmark）
  • HuggingFace 链接：huggingface.co/datasets/princeton-nlp/SWE-bench
  • 考察解决 GitHub 上 issue 的能力
  • 收集了来自 12 个 GitHub Python 项目（（如 Django, scikit-learn））上的 2294 个 Issue-Pull Request 对，使用 post-PR 作为参考解决方案
    • 每个任务都是一个实际发生过的问题，模型需要像一个软件工程师一样，理解问题描述、定位和修改代码库中的多个文件来修复 bug 或添加功能
    • 评估是通过在真实环境中运行测试用例来验证模型提交的补丁（patch）是否成功解决了问题

SWE-bench Lite

  • 从 SWE-bench 中抽取出来的 300 个验证集（原始 SWE-bench 为 2294 个），可快速验证
  • 覆盖 11 个主流 Python 开源仓库（如 Django、SymPy、Astropy、Matplotlib 等）
  • 目标是降低评估成本、加速迭代、降低入门门槛，同时保留原基准的难度分布与多样性
  • 筛选规则（严格过滤）：
    • 移除含图片、外部链接、特定 commit SHA、跨 issue/PR 引用的实例
    • 保留问题描述≥40 词、逻辑清晰的实例
    • 仅保留单文件修改的实例（更聚焦、更易复现）
    • 覆盖原基准的难度与仓库分布

SWE-bench Verified

  • HuggingFace 链接：huggingface.co/datasets/princeton-nlp/SWE-bench_Verified
  • SWE-bench_Verified 包含 500 条用例，是 SWE-bench 测试集的一个子集，是经过人工质量验证过集合
  • 注：26 年初，这个指标已经被大家刷的比较多了，OpenAI 公开表达不建议使用这个指标，且 OpenAI 子集也不在报告这个指标
    • OpenAI 博客：Why SWE-bench Verified no longer measures frontier coding capabilities, 20260223, OpenAI
    • OpenAI 放弃这个指标的原因：
      • 超过 60% 的剩余问题实际上无法解决（Unsolvable Problems）
        • OpenAI 团队对 138 个有问题的样本进行了深入分析（至少让 6 名工程师进行审查），发现：
          • 49 个测试定义过于狭窄：即使提交的功能正确，也会因为这些过于具体的测试而被拒绝（比如函数命名）
          • 26 个测试范围过宽：要求实现问题描述中从未提及的额外功能
        • 这导致超过 60% 的剩余问题在本质上是”无法解决”的——不是因为模型能力不足，而是因为测试本身有缺陷
      • 严重的数据污染（Training on Test / Contamination）
        • SWE-bench 的问题来源于开源仓库，而许多模型提供商在训练时使用了这些仓库的数据
          • 由于 SWE-bench 的流行，这些示例会随时间泄漏到其他语料库中
          • OpenAI 发现，所有前沿模型（包括 OpenAI 自己的模型）都能仅通过 SWE-bench Verified 的任务 ID，就几乎逐字复现原始的 Golden Patch 或问题陈述
          • 通过查看模型的 CoT，团队发现模型”知道”从未在问题描述中指定的测试要求，这表明模型已经记住了答案
      • 目前前沿模型在 SWE-bench Verified 上的得分普遍在 80% 左右徘徊
        • 虽然原始作者认为饱和点应在 87-95%，但 OpenAI 认为由于上述问题，该基准已经无法有效区分模型能力的差异
        • 分数的微小波动（如 0.1% 的变化）不再能真实反映模型能力的提升
    • OpenAI 建议转向 SWE-bench Pro（由 Scale AI 开发）作为替代：
      • 优点是：更难、更多样化（包含更多仓库），更难以被污染
      • 注：OpenAI 没有私心， OpenAI 的模型在 SWE-bench Pro 上并非 SOTA（Gemini 3 的表现优于 GPT-5.x 系列），但他们仍然推荐使用它，因为这更能反映真实的模型能力

SWE-bench pro (真实世界软件工程评估)

  • SWE-bench pro 沿用 Verified 的人工校验流程，但全面升级难度、多样性与防污染设计；OpenAI 已停止使用 Verified，转而采用 Pro 作为内部与对外报告标准
  • SWE-Bench Pro 包含 1,865 个题目（41 个库：Python/JS/TS/Go），平均修改 107 行、4.1 文件（企业级重构）

SWE Multilingual

  • SWE Multilingual 是 SWE-bench 的多语言版本或多语言评估维度
    • 衡量模型在多种编程语言环境下，解决真实世界软件工程问题 的能力指标
  • 传统的 SWE-bench 最初主要集中在 Python 语言上， SWE-bench Multilingual 核心变化在于：
    • 编程语言的扩展：不仅限于 Python，还包括其他主流语言：Java, C++, Go, JavaScript, TypeScript, Rust, PHP, C# 等
    • 评估的维度：在多语言场景下，该指标考察的是：
      • 跨语言泛化能力 ：模型是否在 Python 上表现卓越，但在 Rust 等严谨语法的语言上翻车？
      • 环境依赖处理 ：不同语言有不同的构建工具（如 Maven, CMake, NPM），模型能否正确配置并运行测试？
      • 代码风格对齐 ：模型生成的补丁是否符合特定语言的惯用法（Idiomatic code）

BigCodeBench

BFCL v3

  • 博客地址：BFCL V3 • Multi-Turn & Multi-Step Function Calling Evaluation
  • BFCL v3（Berkeley Function Calling Leaderboard v3），用于验证大模型的 FC 能力（function-calling capabilities）
  • 子集 BFCL v3 multi turn: 这个子集专注于多轮对话场景下的函数调用
    • 模型不仅要响应当前指令，还可能需要利用前几轮对话的上下文信息来做出正确的函数调用决策
  • 子集 BFCL v3 full: 指的是在整个 v3 数据集上进行的全面评估，涵盖单轮、多轮、并行、多函数等各种复杂的函数调用场景

AST(Abstract Syntax Tree) 准确率指标

BFCL v4

  • BFCL v4（Berkeley Function-Calling Leaderboard V4）是伯克利 Gorilla 团队推出的最新一代大模型函数调用（Function Calling）评测基准
    • 与早期版本 BFCL v3 相比，v4 版本将重心从单纯的 “工具调用” 转向了更复杂的 “智能体评估”
  • FCL v4 采用多维度的自动评估协议，主要包含以下核心指标：
    • AST Accuracy :
      • 通过解析模型生成的输出并将其与标准答案进行对比
      • 验证函数名称是否正确、参数名称是否匹配、参数值类型（如 String, Number, Boolean）是否符合定义
    • Execution Accuracy:
      • 将模型生成的函数调用在真实的沙盒环境中执行，检查返回结果是否符合预期
      • 验证比 AST 更严格，因为它要求模型生成的参数不仅在语法上正确，且在逻辑上必须能产生正确的 API 响应
    • Irrelevance Detection (无关检测/拒绝能力):
      • 测试模型在用户需求与现有工具不匹配时，是否能够正确识别并返回 no_call
      • 防止模型产生幻觉，即在没有合适工具时胡乱调用
    • Format Sensitivity:
      • 评估模型对 Prompt 扰动的鲁棒性
      • 即使输入提示词的格式微调，模型是否依然能稳定输出符合特定 Schema 的 JSON
  • BFCL v4 引入了多个针对“智能体”能力的全新测试集：
    • 智能体记忆 (Memory): 评估模型是否能在多轮对话中通过记忆 API（如 Key-Value 存储、向量数据库）存储和提取历史状态
    • 网页搜索 (Web Search): 评估模型进行多跳推理（Multi-hop reasoning）的能力，即模型需要通过多次搜索和调用来解决复杂问题
    • 复杂调用逻辑:
      • Simple/Multiple: 单个或多个候选工具的选择
      • Parallel: 一次性并行调用同一个函数多次
      • Parallel Multiple: 一次性调用多个不同的函数来完成任务
    • 多语言支持: 除了 Python，还涵盖了 Java 和 JavaScript 的 API 调用场景
  • 注：BFCL 是目前大模型函数调用领域的行业事实标准（de facto standard）

BFCL v4 vs BFCL v3

  • BFCL v4 相比于 v3，最核心的变化是从 “工具调用（Tool Use）” 向 “全方位智能体能力（Holistic Agentic Evaluation）” 的战略跃迁
    • BFCL v3： 重点在于多轮对话（Multi-turn） 和多步调用（Multi-step）
      • 它评估模型是否能在对话中请求澄清、纠正之前的调用错误，以及按顺序执行一系列任务
    • BFCL v4： 引入了 “Agentic” 评估
      • 模型不再只是被动地调用 API，而是需要表现出类似自主 Agent 的行为，如管理长期记忆、在开放互联网搜索信息以及在极端的格式变化下保持稳定
  • v4 三大新增评估维度（v3 中是不存在的）
    • Part 1：网页搜索：引入了真实环境下的多跳推理（Multi-hop reasoning）
      • 模型需要调用搜索 API，分析返回的非结构化网页内容，决定是否需要进一步搜索，最终整合多方信息给出结论
    • Part 2：存储与记忆管理：首次系统性评估模型对持久化状态的处理能力
      • 提供三类存储后端（Key-Value Store, Vector Store, Recursive Summarization）
      • 模型必须通过特定的 API（如 memory_add, memory_retrieve）自主管理对话上下文中的事实，测试其是否能跨轮次高效存取信息
    • Part 3：Format Sensitivity：针对模型对 Prompt 格式的鲁棒性进行了大规模压力测试
      • 评估模型在不同的输入（函数定义使用 JSON/XML/Python 格式）和期望输出（返回格式为 JSON/XML/Python）排列组合下的稳定性
      • 暴露了许多模型在特定格式（如 XML）下的性能大幅下滑问题
  • BFCL v4 引入了全新的综合得分（Overall Score）计算公式，体现了对不同能力的优先级排序：
    $$Overall Score = (Agentic \times 40%) + (Multi-Turn \times 30%) + (Live \times 10%) + (Non-Live \times 10%) + (Hallucination \times 10%)$$
    • 相比 v3，v4 极大地提升了 “Agentic（搜索与记忆）” 的权重，将其视为衡量模型先进性的第一标准
  • v4 显著增强了对 “无关指令”的测试。当用户提出的需求与现有工具列表完全不相关时，模型必须表现出极高的 拒绝触发率（Abstention Rate） ，直接返回 no_call
    • 这在 v3 中虽然有涉及，但在 v4 中通过 “Agentic” 场景变得更加复杂

\(\tau\)-bench & \(\tau^2\)-bench (Retail, Airline, Telecom)

  • 关键词：tau-bench, Tau-Bench, \(\tau\)-bench
  • 论文链接: \(\tau\)-bench: A Benchmark for Tool-Agent-User Interaction in Real-World Domains, arXiv 20240617
  • \(\tau\)-bench（Tool-Agent-User Interaction Benchmark）用于评估 Agent 的交互能力，包含不同的场景
  • \(\tau\)-bench 测试模型在复杂的多步骤任务中，如何通过调用一系列 API 或工具来完成目标
  • \(\tau^2\)-bench 是该系列的第二个版本，可能在任务复杂性、工具数量或评估维度上有所增强
  • \(\tau\)-bench 和 \(\tau^2\)-bench 包含的任务被设计为贴近真实世界的应用场景，下面是一些子集介绍
    • \(\tau\)-bench-Retail ： 专注于零售场景的任务，例如管理库存、查询订单、处理退货等
      • 注：有时候可以用 \(\tau\)-bench-Retail（P1）代表评测的第一个阶段（Phase 1）？
    • \(\tau\)-bench-Airline ： 专注于航空服务场景，例如查询航班、预订机票、管理行程等
    • \(\tau^2\)-bench-Retail ：
    • \(\tau^2\)-bench-Airline ：
    • \(\tau^2\)-bench-Telecom ：\(\tau^2\)-bench 新增的电信场景

MiniF2F

  • HuggingFace 链接：huggingface.co/datasets/Tonic/MiniF2F
  • 论文链接：MiniF2F: a cross-system benchmark for formal Olympiad-level mathematics, arXiv 20220228, OpenAI
  • MiniF2F 数据集是一个由奥林匹克数学竞赛难度级别的正式数学命题组成的资源库，旨在为神经定理证明（neural theorem proving）领域提供跨系统的统一基准测试框架。该基准目前覆盖 Metamath、Lean、Isabelle（部分）和 HOL Light（部分）四种证明系统，包含从 AIME（美国数学邀请赛）、AMC（美国数学竞赛）、国际数学奥林匹克竞赛（IMO）以及高中与本科数学课程材料中精选的 488 道数学命题

NuminaMath-1.5

  • NuminaMath-1.5 数据集包含 89.6 万个数学问题，涵盖常用数据源和高等数学主题

AoPS Forum

  • AoPS 论坛（Art of Problem Solving 社区）是面向中学生与数学爱好者的在线数学交流平台，围绕竞赛与进阶数学问题讨论、分享解法与课程互动，广泛用于准备 AMC、AIME、USAMO 等赛事
  • AoPS 论坛 隶属 Art of Problem Solving（AoPS），1993 年创立，覆盖课程、教材与社区板块
  • 社区论坛为核心：按课程/主题分版，支持与讲师和同学交流，支持匿名提问、LaTeX/Asymptote 排版与图片嵌入
  • 搜索功能完善，支持全文、高级筛选与公式搜索，便于定位历史讨论与解法
  • 讨论范围主要是
    • 竞赛训练：AMC 系列、AIME、USAMO 等，以及 MathCounts、Math Kangaroo、HMMT、PUMaC 等赛事与夏令营讨论
    • 课程配套交流：与 AoPS 在线课程深度整合，便于针对讲义与作业提问
    • 趣味与游戏：数学谜题、策略游戏与社区自建游戏板块（如 The Incredible Forum）
  • AoPS 论坛中会产出一些可用于 LLM 的数据，故而在这里记录

TriviaQA

  • HF 链接：mandarjoshi/trivia_qa
  • TriviaQA 是一个大规模开放域问答（Open-Domain QA）数据集
  • 由约 95 万个问答对和来自维基百科与网页的约 66.2 万篇文档构成，平均每个问题有 6 篇“证据文档”支持
  • 适合评估复杂的多文档阅读理解与推理能力
  • 构建方式：爱好者撰写问题，自动检索证据，再经人工验证与机器生成子集混合而成
  • 答案常需多句推理与跨文档综合，难以仅靠短跨度抽取解决，且上下文长、句式与词汇变化大
  • 常见任务包含问答、多文档阅读理解、开放域QA、问题生成等
  • 包含 8 个 subset，每个 subset 包含 3 个 split

FRAMES

Pile-test

  • Pile-test 是大语言模型评估中常用的标准测试集，源于更庞大的通用文本数据集 The Pile
  • The Pile 由 EleutherAI 构建的大规模开源文本数据集，总规模约 800GB，涵盖 22 个不同来源的文本类型（如学术论文、网页文本、书籍、新闻、代码等），旨在为模型提供多样化、高质量的训练与评估数据，避免单一数据分布导致的 “过拟合评估”
  • Pile-test 是 The Pile 的测试子集，与训练集（Pile-train）严格划分，用于客观衡量模型在通用语言理解与生成任务上的泛化能力，由于其覆盖场景广，模型在 Pile-test 上的表现能更真实反映 “通用能力”，而非仅适配某类特定数据

DS-1000

  • DS-1000，也称为 DS1000，其中 DS 是 Data Science 的含义，包含 1000 个数据科学问题的代码生成基准测试集，是测评代码能力的测试集
  • 原始论文：DS-1000: A Natural and Reliable Benchmark for Data Science Code Generation, 2023, HKU & PKU & Meta AI
  • 开源网站：ds1000-code-gen.github.io
  • DS-1000 覆盖 NumPy、Pandas 等 7 个 Python 库
  • DS-1000 具备三大核心特性：
    • 数据集的问题均来自 StackOverflow，能够反映多样化、贴近实际场景的实用用例；
    • 自动评估具有高度特异性（可靠性），在所有经评估判定为“可接受”的 Codex-002 模型预测解决方案中，仅有 1.8% 存在错误
      • 运行测试用例验证代码的功能正确性
      • 限制 API 使用或关键字来约束代码的表面形式；
    • 为防范模型依赖记忆答题，作者对原始 StackOverflow 问题进行了微调，使其与源问题存在差异，从而避免模型通过记忆预训练数据中的解决方案得出正确答案

GAIA

  • 论文地址：GAIA: a benchmark for General AI Assistants
  • GAIA（General AI Assistants）是通用人工智能助手基准测试
    • 论文中提到：该基准若能被攻克，将成为人工智能研究领域的一座里程碑
  • GAIA 设计的现实世界问题，要求模型具备一系列核心能力
    • 例如推理能力、多模态处理能力、网页浏览能力，以及通用意义上的工具使用熟练度
  • GAIA 的问题对人类而言难度较低，但对多数人工智能系统却极具挑战性：
    • 研究显示，人类受访者的正确率达 92%，而配备插件的 GPT-4 正确率仅为 15%
    • 这一显著的性能差距，与近年来 LLM 在法律、化学等需要专业技能的任务上超越人类的趋势形成鲜明对比
  • GAIA 的设计理念与当前人工智能基准测试的主流趋势有所不同，现有基准往往倾向于设置对人类而言难度越来越高的任务
    • 作者认为，AGI 的实现，关键在于系统能否展现出与普通人类相当的稳健性（robustness），在这类问题上达到人类水平
  • GAIA 包含构建了 466 个问题及其对应的答案

VitaBench

BABILong

  • HuggingFace：huggingface.co/datasets/RMT-team/babilong
  • 原始论文：BABILong: Testing the Limits of LLMs with Long Context Reasoning-in-a-Haystack
  • HuggingFace 排行榜：BABILong Leaderboard
  • BABILong 是一款可扩展的生成式多任务测评基准，核心用于评估大语言模型在超长文档中跨分散事实的推理能力
    • 涵盖 20 种推理任务，包括事实链、归纳、演绎、计数、集合处理等，均基于 bAbI 基准扩展而来
    • 以 PG19 语料库的书籍作为背景文本，将任务相关事实隐藏其中，可构建任意长度的测评样本
    • 提供预定义的0K至1000万token的样本分割，实测可支持高达5000万token的超长文本评估
  • BABILong 弥补了Longbench等传统基准仅支持4万token的短板，适配当前LLM的百万级token处理能力
  • BABILong 能抗数据泄露，通过合成任务事实与自然背景文本混合的方式，避免模型因训练数据重叠获得虚假优势

MemBench

  • MemBench 是由中国人民大学高瓴人工智能学院与华为诺亚方舟实验室联合构建的大语言模型智能体记忆能力多维度评测基准
    • 其核心目标是解决现有评测难以全面衡量 LLM 智能体记忆性能的问题，为智能体记忆机制的研发提供可靠的评估依据
  • 聚焦智能体核心的两种记忆能力
    • 事实记忆 ，用于评估智能体对客观信息的存储与召回能力，比如用户的基本需求、任务中的关键参数等；
    • 反思记忆 ，侧重衡量智能体对过往经验的归纳总结能力，例如从多次交互中提炼用户行为规律
  • 设计了两种贴合智能体实际应用的场景
    • 参与场景（智能体作为参与者直接执行任务、与用户交互）
    • 观测场景（智能体作为观察者记录外部事件与信息）
    • 覆盖不同应用场景下的记忆需求
  • 突破单一效果评估的局限，从记忆的有效性（记忆内容的准确性、召回率）、效率（记忆存储与检索的速度）和容量（记忆承载上限）三个核心维度展开评估
  • 实验显示，当记忆容量超过 500 条时，多数模型在该基准中的召回率下降超 20%，可有效检测模型的记忆容量瓶颈

FreshQA

  • FreshQA 是由谷歌和 OpenAI 研究团队联合构建的动态问答基准评测集，专门用于评估大型语言模型生成内容的事实准确性 ，尤其针对模型处理实时变化知识和错误前提问题的能力
    • 用于暴露当前 LLM 的幻觉问题和知识滞后缺陷
  • 该评测集共包含 600 个自然问题，分为测试集和开发集
    • 其中测试集有 500 个样本，四种问题类型各 125 个；
    • 开发集 100 个样本，四种问题类型各 25 个，另外还提取了 15 个跨类型示例用于演示
    • 这些问题覆盖多类主题，且需模型具备不同层级的推理能力
  • 所有问题归为四大类，适配对不同知识类型的评测需求
    • 永不改变的知识 ，比如“谁写了《杀死一只知更鸟》”这类历史、文学领域固定事实问题；
    • 慢变知识 ，答案可能隔数年变化，像“纽约市的人口数是多少”；
    • 快变知识 ，答案一年内可能多次变动，例如“本年度奥斯卡最佳男主角是谁”；
    • 错误前提知识 ，问题基于虚假假设，如“罗杰·费德勒在 2022 年总共赢得了多少个大满贯赛事冠军”，这类问题要求模型能指出前提缺陷而非直接作答
  • 每类问题又分为一跳和多跳两个难度。一跳问题无需额外推理，如“谁是 Twitter 的首席执行官”；多跳问题则需多步推理才能获取答案，如“世界上最高建筑的总高度是多少”
  • 评测采用双模式人工评估程序，累计完成超5万次判断，评估标准严谨
    • RELAXED（宽松模式） ，仅关注核心答案的正确性，允许不影响核心结论的非规范表述或次要信息瑕疵
    • STRICT（严格模式） ，要求回答中所有表述均符合最新事实，无任何幻觉信息。对于错误前提类问题，模型必须主动指出前提错误才能得分；
    • 数字类答案一般不接受近似值，除非基准答案中明确允许

FACTS Grounding

  • FACTS Grounding 数据集是谷歌 DeepMind 与谷歌研究院联合构建的基准测试数据集，核心用途是评估大型语言模型 基于给定上下文文档生成内容的事实准确性与事实锚定能力 ，以此破解模型“幻觉”问题，目前已搭配 Kaggle 在线排行榜用于实时跟踪模型性能进展
  • 目前数据集仅聚焦长文本输入的事实锚定响应评估
  • 数据来源于公开互联网，但其中的用户请求和系统指令为全新设计，不存在污染问题
  • 数据集共包含 1719 个示例，分为 Public 和 Private 两个集合
    • 其中公共集合有 860 条样本，已公开供研究者开展模型评估；
    • 私有集合含 859 条样本，仅用于排行榜评分，这种划分能有效避免基准污染和排行榜作弊问题
    • 最终榜单分数需结合两个集合的平均性能得出
  • 每个样本均由三部分构成
    • 系统指令，明确要求模型只能依据给定上下文文档生成回应，不得调用外部知识；
    • 用户请求，涵盖摘要、问答生成、文档改写等真实任务；
    • 上下文文档，包含回答问题所需的全部信息，文档平均长度为 2.5k 个 token，最长可达 32k 个 token（约2万个单词）
  • 文档覆盖金融、技术、零售、医学和法律等多个实用领域
    • 且数据集刻意避开了需要创造力、数学运算或复杂推理的任务，用户请求也无需领域专业知识，更贴合日常场景下的文本处理需求
  • 研究人员聘请第三方人工标注员，依据长篇输入和各类文本任务撰写长篇输出内容，保障样本的真实性和合理性
    • 标注完成后会经过手动验证，移除与指令不一致的样本；同时剔除来源为 PDF 的文档，避免光学字符识别（OCR）可能带来的误差；还会确保用户请求具有实际意义，过滤无效或无价值的内容
  • 该数据集采用两阶段AI评判模式，选用 Gemini 1.5 Pro、GPT-4o 和 Claude 3.5 Sonnet 三款前沿模型作为评判器，以此保障评估结果的客观性和与人工评分的一致性
    • 第一阶段先评估模型回应的合格性，若未充分满足用户请求则直接取消评分资格；
    • 第二阶段聚焦事实准确性，判断回应是否完全基于上下文文档，无任何幻觉信息
    • 最终得分取三款评判模型在所有样本上的评分平均值

Terminal Bench

  • Terminal-Bench是由斯坦福大学与 Laude 研究所联合开发的开源基准测试与评测框架，专门用于衡量 AI 在真实终端（如 Linux 命令行）环境中完成复杂任务的能力
  • Terminal-Bench 通过标准化任务和环境，量化AI代理在终端场景的实操能力，为开发者优化代理的可靠性和安全性提供参考依据
  • 其初始版本 Terminal-Bench-Core 包含 80 个人工设计并验证的任务，后续持续扩展，目前“head”版已达 117 题
    • 任务覆盖科学工作流、网络配置、网络安全漏洞修复、代码编译部署等多个实用场景，且每个任务都配有人类验证的解决方案和测试用例集
    • 每个任务都配备专属 Docker 环境，能确保测试在隔离的沙箱中进行，避免外部环境干扰，同时保证不同开发者和机构测试结果的可重复性，解决了终端任务评估中环境不一致导致的结果偏差问题
    • 提供 CLI（命令行界面）工具，开发者通过一条命令就能拉起沙箱、连接代理并执行测试
    • 评估时不依赖提示词匹配或主观评价，而是以测试用例是否通过为标准计分，结果客观精准
  • Terminal Bench 设立了公开排行榜展示各类代理-模型组合的任务解决率，方便开发者直观对比不同 AI 代理的性能
  • 该框架不仅有自建任务，还适配了 SWE-Bench Verified、AppWorld 等热门外部评测，开发者接入一次接口就能完成多基准测试
  • Terminal Bench 作为开源项目，开放了文档、任务注册表等资源

CoreCodeBench

  • HuggingFace：huggingface.co/datasets/meituan-longcat/CoreCodeBench-Source_Copy
  • CoreCodeBench 是美团与上海交大联合推出的仓库级代码评测基准，用于测试 LLM 在真实工程场景的编程与调试能力，以自动化单元测试判分，核心指标为Pass@1（首条输出通过所有测试用例的比例）
  • CoreCodeBench 以 Pass@1 为核心，用真实仓库级任务与自动化测试，评估 LLM 的工程级编程与调试能力，适合筛选能落地的代码模型
  • CoreCodeBench 场景覆盖：单/多函数的开发（Development）、缺陷修复（BugFix）、测试驱动开发（TDD），并设有高难度子集（Difficult），总计约1545题，源自12个真实开源仓库，更贴近量产级开发
  • CoreCodeBench 构建流程：通过 CorePipe 自动化 pipeline 定位核心代码、生成题目与测试用例，兼顾规模化与高质量
  • 关键评测指标
    • Pass@1：首条生成的代码通过全部单元测试的比例
      • 主指标，衡量一次性正确性与可靠性
    • AC@1/AC Rate：同Pass@1（不同文档命名），增量正确率
      • 辅助追踪迭代改进
    • 题型细分通过率：按开发/修复/TDD、单/多函数拆分的通过率
      • 定位模型短板与优势场景
  • 相比 HumanEval/MBPP（单函数补全）：覆盖跨文件、多函数协作与缺陷修复，更贴近真实工程
  • 相比 SWE-Bench（仓库级）：自动化生成与判分，可复现性与规模化更好，适合快速迭代评测
  • 快速上手：从 AGI-Eval 社区 获取数据集与评测脚本，按统一 Prompt 生成代码，批量执行测试用例统计 Pass@1；建议同时记录题型细分通过率，便于归因优化

AlpacaEval

  • AlpacaEval 是一种用于评估 LLM 指令遵循能力（Instruction-following）的自动化评估基准
  • AlpacaEval 是一个让 GPT-4 当裁判，来给其他大模型打分的排行榜
    • AlpacaEval 目前是业界衡量大模型对话能力的重要参考指标之一（尤其是 2.0 版本），但研究者通常会结合 Arena-Hard、MT-Bench 等其他指标来综合判断模型性能，以避免单一指标带来的误导
  • AlpacaEval 由斯坦福大学（tatsu-lab）的研究团队推出，旨在通过模拟人类评估的方式，快速、低成本地衡量模型在开放式对话中的表现
  • AlpacaEval 的核心理念是 “以大模型评测大模型” （LLM-as-a-judge）
    • 不依赖昂贵且耗时的人工评分，而是利用强大的模型（通常是 GPT-4）作为裁判，来判断待测模型的回答质量
  • AlpacaEval 评估流程：
    • 1）数据集：使用包含真实用户指令的评估集（源自 AlpacaFarm 数据集），涵盖各种类型的用户问题
    • 2）生成回复：待测模型针对这些指令生成回复
    • 3）对抗评测：裁判模型（如 GPT-4）会同时看到待测模型的回复和一个基准模型（通常是 text-davinci-003 或 GPT-4 Turbo）的回复
    • 4）判定胜负：裁判判断哪个回复更好，从而计算出待测模型相对于基准模型的胜率（Win Rate）
  • AlpacaEval 的优点：
    • 在 AlpacaEval 出现之前，评估聊天模型通常依赖于静态的客观题（如 MMLU）或昂贵的人工评估（如 Chatbot Arena）
    • 模拟人类偏好：AlpacaEval 的设计目标是与人类的偏好高度相关，即 GPT-4 认为好的回答，通常人类也认为好
    • 速度与成本：相比人工评估，它极其快速且经济，允许研究人员在模型迭代过程中频繁测试
    • 指令遵循：它专门针对“指令遵循”能力进行测试，这比单纯的知识问答更能反映聊天机器人的实际用户体验
  • AlpacaEval 在发展过程中经历了 AlpacaEval 1.0 到 AlpacaEval 2.0 迭代，主要是为了解决 “长度偏差”（Length Bias） 问题
    • AlpacaEval 1.0 的问题：早期的评估发现，裁判模型（GPT-4）倾向于认为“越长越好”
      • 即使一个回答内容空洞，只要写得很长，往往也能获得高分
      • 这导致许多模型通过生成冗长的废话来“刷榜”
    • AlpacaEval 2.0 的改进：为了解决这个问题，AlpacaEval 2.0 引入了长度控制胜率（Length-Controlled Win Rate, LC Win Rate）
      • 通过统计方法（Logistic Regression）以此来消除输出长度对评分的影响，迫使模型通过提高回复的质量而不是长度来提升排名
  • AlpacaEval 的缺点
    • 裁判偏见：由于裁判通常是 GPT-4，它可能更偏好与自己风格相似的回答（Self-preference bias）
    • 容易被“作弊”：研究发现，即使是一个始终输出固定内容的“空模型”或经过特定微调的模型，也有可能通过利用裁判的漏洞在榜单上获得极高的胜率，甚至在数据上“吊打”GPT-4
    • 评估单一性：它主要评估单轮对话的指令遵循，可能无法全面反映模型在多轮对话、逻辑推理或特定领域（如数学、代码）的深层能力

附录：AlpacaEval 2.0 LC Win Rate 详细介绍

  • AlpacaEval 2.0 LC Win Rate（Length-Controlled Win Rate，长度控制胜率）是目前大模型领域非常权威的一个评测指标，主要用于评估模型在指令跟随（Instruction Following）方面的能力
  • TLDR: 它的核心目的是：在去除“字数越多得分越高”这种偏见的前提下，公正地评判一个模型回答得好不好
  • 在早期的大模型自动评测中，人们发现了一个严重的 bug：AI 裁判（如 GPT-4）非常喜欢“长篇大论”
    • 哪怕一个回答内容空洞，只要写得很长，GPT-4 往往会判它赢（Win），很多模型厂商为了刷榜，故意把模型训练得非常啰嗦（Verbosity），导致分数虚高，但实际用户体验很差
    • 为了解决这个问题，AlpacaEval 团队推出了 2.0 版本，并引入了 LC (Length-Controlled) 机制
  • LC Win Rate 的计算逻辑不是简单的“谁赢了加 1 分”，而是一个统计学上的调整过程：
    • 1）两两对战： 让待测模型（例如 Llama 3）和基准模型（通常是 GPT-4 Turbo）回答同样的 805 个指令问题
    • 2）裁判打分： 让 GPT-4 Turbo 作为裁判，判断哪个回答更好
    • 3）统计去噪（核心步骤）：
      • 系统会使用一个统计模型（如 LR 模型）来分析裁判的偏好
      • 它会计算：“如果我们假设这两个回答的长度是一样的，裁判更倾向于谁？”
      • 通过这种数学手段，把“长度”这个干扰因素从分数中剥离出去，只保留“内容质量”带来的胜率
  • 经过 LC 修正后，AlpacaEval 2.0 的排名与 LMSYS Chatbot Arena（人类盲测竞技场） 的排名高度一致（相关性高达 0.98）
  • LC Win Rate 可以防刷榜： 它迫使模型开发者关注回答的质量、逻辑和准确性 ，而不是单纯地增加字数

InfoBench

  • 原始论文：InfoBench: Evaluating Instruction Following Ability in Large Language Models, 20240107, Tencent AI Lab
  • HuggingFace：huggingface.co/datasets/kqsong/InFoBench
  • InfoBench 是一个专门用于评估 LLM Instruction Following能力的基准测试
  • 与传统的 NLP 任务不同， InfoBench 侧重于考察模型在处理包含多个复杂约束（Constraints）的指令时的表现
  • InfoBench 聚焦于 LLM 对“原子约束”（即任务中明确的细节要求）的遵循能力，通过量化模型满足约束的表现，评估其在复杂任务中的可靠性
  • InfoBench 的核心在于将一个复杂的指令分解为多个原子约束（Atomic Constraints）
    • 例如，如果指令是“写一段关于猫的 50 字短文，不要提到‘鱼’，并使用法语”，它会被分解为：
      • 1）话题：关于猫
      • 2）长度限制：约 50 字
      • 3）负向约束：不提到“鱼”
      • 4）语言要求：法语
  • InfoBench 不仅给出总分，还会根据约束的性质进行分类评估，常见的维度包括：
    • 格式约束 (Format) ： 要求输出特定的数据格式
      • 比如：”以 JSON 格式输出”, “使用 Markdown 表格”
    • 内容约束 (Content) ： 要求包含或排除特定信息
      • 比如： “提及‘量子力学’”, “不要提到任何颜色”
    • 长度约束 (Length) ： 限制字数、句子数或段落数
      • 比如： “少于 30 个词”, “正好三段”
    • 语言约束 (Language) ： 指定输出的语种
      • 比如： “使用古汉语回答”, “翻译成德语”

InfoBench 的核心评测指标与公式

  • InfoBench 主要通过以下三个维度的指标来衡量模型的性能：
    • CSR：看所有约束的整体达标率 ，不区分指令
    • SA：看指令级的“全对率” ，要求单个指令的所有约束都满足
    • ACF：看指令级的“平均达标率” ，允许单个指令部分约束满足，再取平均
  • 约束满足率 (Constraint Satisfaction Rate, CSR)
    • CSR 衡量模型在所有测试用例中，成功遵循的原子约束占总约束的比例（最基础的整体约束达标率）
      $$
      CSR = \frac{\sum_{i=1}^{N} \text{Satisfied}(c_i)}{N}
      $$
      • \( N \)：所有测试样本中包含的原子约束总数；
      • \( \text{Satisfied}(c_i) \)：指示函数（第\( i \)个约束满足则为1，否则为0）
  • 严格准确率（Strict Accuracy, SA）
    • SA 衡量模型在单个指令（Prompt）中，完全满足所有原子约束的比例（更严苛，反映复杂多约束任务的可靠性）
      $$
      SA = \frac{\sum_{j=1}^{M} \prod_{k=1}^{K_j} \text{Satisfied}(c_{j,k})}{M}
      $$
      • \( M \)：总指令（Prompt）数量；
      • \( K_j \)：第\( j \)个指令包含的原子约束数量；
      • \( c_{j,k} \)：第\( j \)个指令的第\( k \)个约束；
      • \( \prod \)（连乘）：只有当该指令的所有约束都满足（连乘结果为1），才算该指令通过
  • 平均约束遵循度（Average Constraint Following, ACF）
    • ACF 衡量模型在每个指令中满足约束的比例的平均值（关注单个任务的平均表现，而非整体约束计数）
      $$
      ACF = \frac{1}{M} \sum_{j=1}^{M} \left( \frac{\sum_{k=1}^{K_j} \text{Satisfied}(c_{j,k})}{K_j} \right)
      $$
      • 先计算“单个指令内满足约束的比例”（\( \frac{\sum_{k=1}^{K_j} \text{Satisfied}(c_{j,k})}{K_j} \)），再对所有指令取平均

InfoBench 评测流程简述

  • Step 1 分解 (Decomposition)： 利用强大的教师模型（如 GPT-4）或预定义的规则，将复杂指令拆解为
  • Step 2 执行 (Execution)： 被测模型生成回复
  • Step 3 验证 (Verification)： 再次利用教师模型或程序脚本，逐一检查每个原子约束是否在回复中得到满足
  • Step 4 汇总 (Aggregation)： 应用上述公式计算最终得分

DROP (阅读理解与离散推理)

HellaSwag (常识自然语言推理)

  • 原始论文：HellaSwag: Can a Machine Really Finish Your Sentence?, ACL 2019
  • HuggingFace 链接：datasets/Rowan/hellaswag
  • HellaSwag 是一个用于评估模型常识推理 能力的数据集
  • HellaSwag 核心任务是“句子续写”（Can a machine finish your sentence?）
  • 利用了对抗性过滤（Adversarial Filtering）技术生成对人类来说非常简单但对早期语言模型来说极具误导性 的错误选项
    • 要求模型在给定前文的情境下，选出最符合人类常识的后续发展

WSC

  • WSC (Winograd Schema Challenge, 威诺格拉德模式挑战) 在 NLP 历史上具有非常重要的地位，曾一度被视为替代“图灵测试”来检验机器是否真正具备人类常识的试金石
  • WSC 的变体： WinoGrande（大规模扩展版）和 CLUEWSC（中文版）
  • WSC 由多伦多大学的 Hector Levesque 教授于 2011 年提出，最初的 WSC 数据集非常小，只有 273 道手工编写的题目
    • 随着 LLM 的发展，这个规模很快就被模型“刷爆”了，且研究发现原本的数据集中仍然存在一些模型可以利用的微小偏差
    • 后来学界才推出了去除偏差且规模更庞大的 WinoGrande ，以及面向中文语境的 CLUEWSC
  • WSC 的核心任务是代词共指消解（Pronoun Resolution） ：即让模型判断句子中指代不明的代词到底指的是谁
  • WSC 精妙之处在于采用了 “控制变量法”（即 Winograd 模式）：
    • 通常成对出现，两个句子在结构和词汇上几乎完全相同，只有一个决定性的“触发词”不同
    • 这个触发词的改变，会使得常识逻辑发生反转，从而改变代词的指代对象
    • 示例：
      • 题目：“市议员拒绝给示威者发放游行许可证，因为他们[害怕 / 倡导]暴力，请问这里的 他们是谁？”

        The city councilmen refused the demonstrators a permit because they [feared / advocated] violence

        • 如果句子是：“因为他们害怕暴力”，常识告诉我们，害怕暴力的是市议员，所以“他们”指代市议员
        • 如果句子是：“因为他们倡导暴力”，常识告诉我们，倡导暴力导致许可证被拒的是示威者，所以“他们”指代示威者
  • 为什么它当年对 NLP 是一个挑战？
    • 传统的语言模型可以通过统计词汇的共现频率来“猜”答案（比如“狗”和“骨头”经常一起出现）。但 WSC 句子对的词汇几乎一样，统计学特征完全失效
    • 机器无法仅仅依靠语法结构来解题，它必须像人类一样，拥有并运用关于真实世界的背景知识（比如：市议员代表官方，通常维持治安；示威者有时会采取激进手段）

WinoGrande (大规模常识与代词消解)

  • 原始论文：WinoGrande: An Adversarial Winograd Schema Challenge at Scale, AAAI 2020
  • WinoGrande 是 Winograd Schema Challenge (WSC) 的大规模扩展版本
  • WinoGrande 任务通常包含一个句子，其中有一个指代不明的代词，模型需要利用常识判断该代词指代的是哪个名词
    • 例如：“奖杯放不进棕色手提箱，因为它太【大/小】了”，此处的“它”指代谁？）
  • WinoGrande 更具对抗性，旨在消除数据集中可能让模型“走捷径”的统计偏差

HumanEval (代码生成能力)

  • 原始论文：（HumanEval）Evaluating Large Language Models Trained on Code, OpenAI 2021
  • HumanEval 是由 OpenAI 发布的代码评估基准，专门用于测试 LLM 的Python 代码生成能力
  • HumanEval 包含 164 个手写的编程问题（带有函数签名、文档字符串和功能描述）
  • HumanEval 评估方式不是简单的文本相似度，而是通过执行隐藏的单元测试来验证代码逻辑是否正确，常用的指标是 \(pass@k\)（即模型生成 k 个代码片段，只要有一个通过所有测试用例即算成功）

CLUEWSC (中文共指消解与常识推理)

MGSM (多语言小学数学推理)

  • 原始论文：Language Models are Multilingual Chain-of-Thought Reasoners, ICLR 2023
  • HuggingFace 链接：datasets/juletxara/mgsm
  • MGSM (Multilingual Grade School Math) 是著名的小学数学词汇题数据集 GSM8K 的多语言版本
  • MGSM 是将 GSM8K 的题目人工翻译成了 10 种类型不同的语言（如孟加拉语、日语、斯瓦希里语、法语等）
  • MGSM 的主要目的是评估 LLM 是否能在跨语言的情境下依然保持强大的 CoT 多步数学推理能力

CMATH (中文小学数学能力)

  • 原始论文：CMATH: Can Your Language Model Pass Chinese Elementary School Math Test?, 20230629
  • HuggingFace 链接：datasets/weitianwen/cmath
  • CMATH (Chinese Elementary School Math Test) 是一个专门针对大模型在中文语境下基础数学能力的评测数据集
  • CMATH 包含了 1.7k 道来源于真实中国小学练习册和考试的应用题，并标注了从小学一年级到六年级的年级信息
  • CMATH 数据集可以细粒度地测试模型“相当于人类小学几年级的数学水平”，并且包含一些干扰信息的题目以测试鲁棒性

Codeforces (编程竞赛评测)

  • 原始论文：When Elo Lies: Hidden Biases in Codeforces-Based Evaluation of LLMs, 202602
  • Codeforces 指标通过引入同名在线编程平台的竞赛题目来评估模型的算法设计、逻辑推理及代码实现能力
  • Codeforces vs HumanEval
    • HumanEval 的题目偏基础
    • Codeforces 题目通常包含复杂的时空复杂度限制和多样的测试用例，能有效区分通用模型与专家级编程模型
  • 最新的评估框架一般通过收集特定时间段内的全新比赛题目，来防止模型因训练数据污染而产生的“记忆效应”

Apex / Apex Shortlist (投资与专业办公 Agent 评测)

  • 原始论文：APEX-Agents, 20260223, MERCOR Research
  • HuggingFace 链接：mercor/apex-agents
  • Apex (AI Productivity Index for Agents) 是一个衡量 AI Agent 在投行分析、咨询、法律等专业环境下执行长程任务能力的基准
  • Apex Shortlist 通常指该基准中精选的高难度、跨应用（Cross-application）子集
  • 评测要求模型操作真实的文件（PDF、Excel）和工具（如浏览器、数据库），解决如“分析某公司三季报并对比行业竞争对手”这类复杂的端到端任务

CorpusQA (大规模语料级分析)

  • 原始论文：CorpusQA: A 10 Million Token Benchmark for Corpus-Level Analysis, 202601
  • CorpusQA 突破了单一文档的限制，旨在评估模型在千万级 Token 语料库（10M Tokens） 中进行全局分析和信息检索的能力
  • 它要求模型在海量异构数据（散布在数千个文件中的证据）中进行多跳推理（Multi-hop Reasoning），是目前衡量“大海捞针”能力的终极进化版

BrowseComp (浏览器检索合成)

  • BrowseComp 是一个旨在评估 LLM 进行复杂网络信息检索与深度研究能力的评测基准
  • BrowseComp 核心特点是要求模型在互联网上自主完成多跳推理、信息交叉验证等复杂任务

BrowseComp (原版)

  • 来自 OpenAI， 包含需要跨越多网站、多步骤推理才能找到答案的高难度问题
  • BrowseComp 包含 1266 题（覆盖9大领域），都是英文网页
  • 特点：难度极高，早期 GPT-4o 准确率曾低至 0.6%

BrowseComp-ZH

  • BrowseComp-ZH 是首个专门针对中文互联网复杂环境设计的基准，考虑了中文信息碎片化、表达模糊等特有挑战
  • BrowseComp-ZH 共包含 289 题（覆盖11大领域），都是中文网页
  • 特点：难度极高，模型普遍表现不佳

BrowseComp-Plus

  • BrowseComp-Plus 是 为了解决原版因使用实时网页 API 导致的重现困难问题而设计，采用固定的文档库，使测试结果更公平、可重复
  • BrowseComp-Plus 源自 BrowseComp，都是英文（固定语料）

BrowseComp-V\(^3\) （多模态）

  • BrowseComp-V\(^3\) 是最新的多模态版本，不仅处理文本，还需理解网页中的图片、图表等视觉信息进行跨模态推理
  • BrowseComp-V\(^3\) 共包含300 题，多模态（文本+视觉）
  • 特点：即使是顶尖的多模态模型，准确率也仅达到极低，揭示了模型在整合图文信息方面存在的巨大瓶颈

GDPval-AA (对齐评价指标)

  • GDPval-AA (Goal-Driven Preference Validation - Automated Alignment) 是一套用于衡量模型回答是否符合特定价值观（如人类偏好、本地法律、伦理准则）的量化指标
  • GDPval-AA 通常利用一个“强裁判模型”根据预设的 GDP 准则（目标驱动的对齐原则）对输出进行多维度评分，是模型对齐阶段的关键参考

MCPAtlas Public (工具调用能力)

  • 原始论文：MCP-Atlas: A Large-Scale Benchmark for Tool-Use Competency with Real MCP Servers, 202602
  • MCPAtlas 是基于 Model Context Protocol (MCP) 协议构建的大规模工具使用评测集
  • MCPAtlas Public 版本包含 500 个真实任务，涵盖了 36 个真实的服务器环境
    • MCPAtlas 不仅测试模型是否能调用工具，还测试模型能否在不给出工具具体名称的情况下，根据需求自动发现、组合并编排（Orchestration）多个工具来解决问题

Toolathlon (工具十项全能)

  • 原始论文：The Tool Decathlon: Benchmarking Language Agents for Diverse, Realistic Task Execution, 202510
  • Toolathlon（工具十项全能）模仿“十项全能”比赛，横跨 32 个主流软件应用（如 Google Calendar, Notion, Kubernetes, BigQuery 等）
  • 该基准强制要求模型在真实的软件环境下（非模拟环境）进行交互，单次任务平均涉及 20 轮以上的对话和工具调用，是目前对 Agent 鲁棒性要求最高的指标之一

BPB（Bits per Byte）

  • BPB（Bits per Byte，比特 / 字节）是 LLM 语言建模的 Byte-level 评估指标
  • BPB 的物理意义：在编码或预测文本时，平均每个字节（Byte）需要消耗多少个比特（Bit）的信息量
  • BPB 可以衡量模型对文本的预测效率与压缩能力，值越小越好，且与分词器无关 ，便于跨模型公平对比
  • 注：在基于深度学习的图像/视频压缩大模型中，也有个类似指标 BPP (Bits Per Pixel，每像素比特数)，此时，BPP 是衡量压缩率的最关键指标
  • BPB 的本质是归一化到字节的平均交叉熵（以2为底取对数）。对长度为\( T \)字节的文本，BPB 计算公式为：
    $$
    \text{BPB} = \frac{1}{T} \sum_{t=1}^T -\log_2 P(x_t | x_1, x_2, \dots, x_{t-1})
    $$
  • 其中：
    • \( T \)：文本的总有效字节数（排除特殊 token、masked 位置等非内容字节）
    • \( x_t \)：第\( t \)个字节的内容
    • \( P(x_t | x_1, x_2, \dots, x_{t-1}) \)：模型基于前文\( x_1 \dots x_{t-1} \)对第\( t \)个字节的预测概率

与困惑度（Perplexity）的换算关系

  • 若文本的 token 序列长度为\( N \)，每个 token 对应的字节数为\( l_i \)（\( i=1,2,\dots,N \)），总字节数\( T = \sum_{i=1}^N l_i \)，token 级困惑度\( \text{PPL} = \exp\left( \frac{1}{N} \sum_{i=1}^N -\log P(y_i | y_1, \dots, y_{i-1}) \right) \)（\( y_i \)为第\( i \)个 token），则 BPB 与困惑度的近似换算（以自然对数转2为底）：
    $$
    \text{BPB} \approx \frac{1}{T} \cdot \frac{\ln(\text{PPL}) \cdot N}{\log_2 e}
    $$
  • 其中\( \log_2 e = \frac{1}{\ln 2} \approx 1.4427 \)，因此也可简化为：
    $$
    \text{BPB} = \frac{N \cdot \ln(\text{PPL})}{T \cdot \ln 2}
    $$

关于 BPB 名字的理解

  • 公式里“没有包含比特信息”，是因为这里的“比特（Bit）”并非指计算机存储中的物理开关（0或1），而是信息论（Information Theory）中的度量单位
  • TLDR：公式中的 \(\log_2\)（以 2 为底的对数） 就是将“概率”转换为“比特”的数学算子
    • 在信息论中，\(-\log_2(p)\) 的结果单位定义就是“比特”
  • 让我们把公式拆开，逐项对应到物理意义上，你就会发现它完美对应了 Bits Per Byte 的名字，公式：
    $$ \text{BPB} = \frac{1}{T} \sum_{t=1}^{T} \underbrace{-\log_2 P(x_t | x_{<t})}_{\text{核心部分}} $$
  • 分子：“Bit” 藏在 \(-\log_2 P\) 里
    • 在香农信息论中，信息量（Information Content） 的定义是：
      $$ I(x) = -\log_2 P(x) $$
      • 数学定义 ：如果一个事件发生的概率是 \(P\)，那么消除这个不确定性所需的信息量就是 \(-\log_2 P\)
      • 单位定义 ：当底数为 2 时，计算结果的单位被定义为 Bit（比特）
      • 如果底数是 \(e\)，单位是 Nat
      • 如果底数是 10，单位是 Hartley
    • 举例
      • 抛硬币 ：正面朝上的概率是 $0.5$ ($1/2$)
        $$ -\log_2(0.5) = 1 \text{ bit} $$
        • 这符合直觉：需要 1 个比特（0或1）来记录硬币的结果
      • 完全随机的字节 ：一个字节有 256 种可能（0-255），如果模型完全猜不到（均匀分布），概率是 \(1/256\)
        $$ -\log_2(1/256) = \log_2(2^8) = 8 \text{ bits} $$
        • 这意味着：如果你完全猜不到下一个字节是什么，你就需要完整的 8 个比特 来存储它（没有任何压缩）
    • 结论：公式中的求和项 \(\sum -\log_2 P(\dots)\) 计算出的数值，物理意义就是 “编码这段文本理论上所需的总比特数”
  • 分母：“Byte” 藏在 \(T\) 里，在 BPB 指标中，\(T\) 代表的是文本序列中 字节（Byte）的总数量
  • 将分子和分母结合起来看：
    $$ \text{BPB} = \frac{\text{总信息量 (Total Bits)}}{\text{总字节数 (Total Bytes)}} $$
    • 分子 ：\(\sum -\log_2 P \rightarrow\) 单位是 Bits（因为用了 \(\log_2\)）
    • 分母 ：\(T \rightarrow\) 单位是 Bytes（因为 \(t\) 遍历的是字节序列）
    • 结果 ：Bits Per Byte

为什么 BPB 指标代表“压缩能力”？

  • 引入算术编码（Arithmetic Coding）的概念
  • 理论上，存在一种完美的压缩算法，它能将概率为 \(P\) 的符号，压缩成长度为 \(-\log_2 P\) 个比特的二进制码流
  • 模型越聪明（\(P\) 越大） ：
    • 如果模型非常确信下一个字是“A”，预测概率 \(P=0.99\)
      $$ -\log_2(0.99) \approx 0.014 \text{ bits} $$
    • 这意味着只需要极少的比特就能存储这个信息（压缩率极高）
  • 模型越笨（\(P\) 越小） ：
    • 如果模型觉得下一个字可能是任何字，预测概率 \(P=0.001\)
      $$ -\log_2(0.001) \approx 9.96 \text{ bits} $$
    • 这意味着需要花费很多比特来记录这个意外的信息
  • 公式 \(\text{BPB} = -\frac{1}{T} \sum \log_2 P\) 实际上是在计算：
    • “如果利用该模型对文本进行无损压缩，平均每个字节最终会被压缩成多少个比特”

HealthBench

  • 原始论文：HealthBench: Evaluating Large Language Models Towards Improved Human Health, OpenAI, 20250513
  • HuggingFace：huggingface.co/datasets/openai/healthbench
  • 博客链接：Introducing HealthBench, OpenAI, 20250512
  • HealthBench 是 OpenAI 推出的医疗大模型评估基准，核心以医生编写的细粒度评分标准为核心，从 5 大行为维度与 7 大场景主题对模型回复打分，用标准化方式衡量医疗大模型在真实临床交互中的安全性、准确性与实用性
  • 基于真实对话与医生共识，评估结果更贴近临床实际需求，避免传统选择题评估的局限性
  • 覆盖26个医学专科、49种语言，适配不同地区诊疗差异
  • 开源评分器与基准结果，支持第三方复现评估、扩展标准，推动医疗 AI 评估标准化
  • 评分流程：
    • 1）评分标准生成 ：每段对话由医生编写专属评分标准，明确应包含/避免的内容及对应分值（±10分），反映该标准的重要性
    • 2）自动化评分 ：由 GPT‑4.1 训练的模型评分器，判断回复是否满足每项标准，达标得全部分值，未达标不得分
    • 3）综合得分计算 ：单条回复得分 =（达标标准总分 ÷ 该对话满分）×100%，最终按所有对话平均分计算模型整体得分
    • 4）可靠性验证 ：评分器与医生评估的宏 F1(Macro F1) 值达 0.71，接近医生间互评一致性，确保自动化评分的可信度
  • 衍生评估版本
    • HealthBench Consensus ：聚焦 34 项经医生验证的核心标准，重点评估紧急处置、情境澄清等关键模型行为，适合快速基准测试
    • HealthBench Hard ：精选 1000 段高难度对话，用于挑战模型在复杂临床场景下的极限表现

核心评估维度（5 大行为轴）

  • 每个评分标准都对应以下维度，每个维度有明确正向/负向判据，分值范围 ±10 分，用于奖励或惩罚模型行为：
  • 1）准确性（Accuracy） ：±10分（奖励正确行为，惩罚错误行为）
    • 定义：仅含事实正确信息，有证据/共识支持，证据有限时明确不确定性
    • 评估点：无错误事实、避免常见误解、不编造信息、标注信息来源与不确定性
  • 2）完整性（Completeness） ：±10分
    • 定义：覆盖安全有效回复所需的关键信息，不遗漏必要内容
    • 评估点：包含核心诊疗步骤、风险提示、随访建议等，无关键信息缺失
  • 3）沟通质量（Communication Quality） ：±10分
    • 定义：回复长度、清晰度、细节度、词汇、结构契合用户需求与情境
    • 评估点：语言通俗、逻辑清晰、重点突出、避免冗余术语、适配用户角色（患者/医生）
  • 4）情境感知（Context Awareness） ：±10分
    • 定义：结合用户角色、环境、资源等情境恰当响应，必要时主动澄清
    • 评估点：适配地区诊疗规范、用户可及资源、患者基础疾病，主动询问缺失信息
  • 5）Instruction Following ：±10分
    • 定义：严格遵守用户明确指令，如格式要求、任务步骤等
    • 评估点：不偏离用户需求、按要求完成临床笔记总结/报告生成等任务

评估主题（7 大主题场景分类）

  • 覆盖真实医疗交互的关键场景，每个主题聚焦特定临床挑战，所有对话由 262 名跨 60 国医生共同设计，共 5000 段多轮对话，对应 48,562 条独特评分标准：
    • 1）紧急转诊（Emergency Referrals）：评估危急情况（如心脏骤停、休克）下的规范处置与转诊建议
    • 2）情境寻求（Context Seeking）：判断模型是否主动识别缺失信息以提供精准回复
    • 3）不确定性下的响应（Responding Under Uncertainty）：考察低证据场景下的不确定性表达与安全建议
    • 4）响应深度（Response Depth）：根据用户背景（如患者/医生）调整回答详细程度
    • 5）健康数据任务（Health Data Tasks）：评估医疗文档书写、临床笔记总结、健康管理等任务的完成质量
    • 6）专业定制沟通（Professionally Tailored Communication）：适配不同专业角色的沟通策略（如对患者通俗解释、对医生专业表述）
    • 7）全球健康（Global Health）：适配不同地区资源、流行病学与诊疗规范的跨地域响应能力

WritingBench

  • 论文链接：WritingBench: A Comprehensive Benchmark for Generative Writing
  • WritingBench (生成式写作综合基准) 是一个专门针对 LLMs 生成式写作能力进行评估的综合性基准，旨在解决传统基准无法全面覆盖写作领域的问题
  • HuggingFace：
  • WritingBench 包含 6 个核心写作领域（如创意写作、技术写作、公文写作等）和 100 个子领域 ，旨在全面评估模型在不同语境下的生成能力
  • WritingBench 采用了一种“查询依赖”（query-dependent）的评估框架，这意味着评估标准会根据用户的具体指令动态调整，而非使用单一的通用标准
  • WritingBench 基准通常结合了 LLM-based 自动评估（如使用 GPT-4 或 Claude 作为裁判）与人工评估的验证，重点关注文本的连贯性、创造性、遵循指令的能力以及内容的深度

EQ-Bench

  • GitHub (官方仓库)：github.com/EQ-bench/EQ-Bench
  • 官方网站 (Leaderboard)：eqbench.com/
  • 数据集：
  • EQ-Bench (情商与创意写作基准) 最初设计用于评估大语言模型的情商（Emotional Intelligence），随后扩展了针对创意写作（Creative Writing）的评估分支，是目前评估模型“人性化”与“文学性”的重要榜单
  • EQ-Bench 包含多个 任务：
    • 核心任务 (EQ) ：评估模型理解复杂情绪和社交互动的能力
      • 数据集包含具有挑战性的角色扮演（Roleplays）对话，模型需要预测对话中角色的情绪状态或做出符合情境的反应
    • 创意写作 (Creative Writing v3) ：这是 EQ-Bench 的一个重要分支，专门用于评估模型的文学创作能力
      • 它通过设定具体的写作提示（Prompt），让模型生成故事或文章
  • EQ-Bench 评分使用 Rubric Score，使用一套详细的规则（Rubric），通常由高水平模型（如 Claude 3.5 Sonnet 或 GPT-4）作为裁判，对生成内容的风格、重复度、长度和指令遵循度进行打分
  • EQ-Bench 排行榜使用 Elo Score，采用竞技排名系统（Elo Rating），通过成对比较不同模型的输出优劣来计算相对排名，这种方法被认为比单一分数更能反映模型间的细微差距

MRCR (Multi-Round Co-reference Resolution)

  • HuggingFace：openai/mrcr
  • MRCR 是一个针对 Long Context 能力的评估任务
    • 与传统的单点检索（NIAH）不同，MRCR 要求模型在长对话或长文本中识别并关联多个分散的信息点，主要测试模型在长窗口下区分相似信息（Multiple Needles）和处理共指关系的能力
  • 该数据集在评估 GPT-4 Turbo、GPT-4o 以及 Gemini 1.5 Pro 等长窗口模型时被广泛引用
    • 相关技术报告参考：Gemini 1.5: Unlocking multimodal understanding across millions of tokens of context（其中详细描述了 MRCR 任务机制）
  • MRCR 任务逻辑：
    • 模型会看到一段非常长的用户与 AI 的多轮对话历史（作为“大海/Haystack”）
    • 用户会提出一个问题，该问题需要模型回溯到对话中的特定轮次（例如“我在第 3 次询问水果时，你推荐了什么？”）
  • MRCR 数据集的难点（重点考察点）：
    • 多针检索 (Multiple Needles) ：上下文中包含大量相似的对话结构，模型必须精确定位到特定的那一轮，而不是混淆其他轮次的信息
    • 共指消解 (Co-reference) ：模型需要理解 “第 i 次”、“那个” 等代词具体指代长文本中的哪一部分内容
  • MRCR 的评估指标通常使用 检索准确率 (Retrieval Accuracy)
    • 在不同长度的上下文窗口（如 32k, 128k, 1M）下，计算模型成功定位并正确回答特定轮次内容的百分比

AGIEval

  • AGIEval 一个专门为评估 LLM 在人类认知能力方面的表现而设计的基准测试集，由微软研究团队在 2023 年发布
  • AGIEval 旨在衡量模型在处理复杂推理、理解和应用知识方面的真实水平
  • AGIEval 与传统的 AI 测试集（如 MMLU）不同：
    • 题目来源真实： 题目全部源自针对人类考生的标准化考试
    • 高难度与高专业性： 包含了公考、法律资格、高考等需要深度逻辑思考的任务，而非简单的常识问答
    • 中英双语： 它针对全球最重要的两大语言市场，包含了大量的中文和英文题目
  • AGIEval 涵盖了约 20 个子任务，主要可以归纳为以下几类：
    • 中国标准化考试 : 高考（语/数/外/理/化/生/史/地）、中国公务员考试（行测），考察综合学科理解、逻辑推理、中文语境处理
    • 美国标准化考试 ：SAT、GRE、GMAT、LSAT（法学院入学考试），考察批判性思维、定量推理、高级英语应用
    • 法律与专业资格 ：中国律师资格证、美国司法考试（Bar Exam），考察模型复杂逻辑推演、法律知识检索与应用

WMT24 (WMT24 Metrics Shared Task)

  • 论文：Are LLMs Breaking MT Metrics? Results of the WMT24 Metrics Shared Task
  • WMT24 是一个机器翻译基准
    • WMT24 也是第 9 届机器翻译（MT）评测研讨会，核心关注点是：现有自动评价指标是否还能准确衡量 LLM 的翻译质量？
  • WMT24 核心内容（核心：MetricX-24）
  • MetricX-24 是 WMT24 指标任务中的优胜者之一，由 Google 团队研发
    • MetricX-24 技术原理：MetricX-24 是一个混合（Hybrid）模型，它同时支持有参考答案（Reference-based）和无参考答案（Reference-free / Quality Estimation, QE）两种模式
    • 基于 mT5 模型架构，在大量的 MQM（多维度质量度量）人工标注数据上进行微调
    • MetricX-24 特点：
      • 能够捕捉 LLM 生成翻译中的细微语义偏差
      • 针对长文本（Multi-sentence）进行了优化，减少了对长翻译的偏见
      • 在与人工评分的相关性（Correlation）上达到了当前 SOTA 水平

WMT24++

  • WMT24++ 是 WMT24 的扩展板
  • WMT24++ 通过提供更高质量的人工参考数据，使得像 MetricX-24 这样的指标能够在更广泛的语境下运行
  • WMT24++ 核心改进
    • 语言覆盖率：将原本 WMT24 仅覆盖的少数主流语言对扩展到了 55 种语言及方言
    • 领域多样性：涵盖了文学、新闻、社交媒体和语音四大领域
    • LLM 适配性：专门针对 LLM 作为翻译器时可能出现的“幻觉”或“风格偏移”提供了更精确的标注参考（包括人工重写的 High-quality references）
    • 核心发现：该基准证明了在 55 种语言中，顶尖 LLM 的翻译表现已经全面超越了传统的神经机器翻译（NMT）系统

MT-Bench

  • HuggingFace：huggingface.co/datasets/lmsys/mt_bench_human_judgments
  • MT-Bench (Multi-Turn Benchmark) 由 LMSYS Org（也就是发布了著名的 Chatbot Arena 和 Vicuna 模型的组织）提出
  • MT-Bench 是一个专门用于评估 LLM 多轮对话能力和指令跟随能力的评测基准
    • MT-Bench 的核心目的是测试模型在连续对话中是否“聪明” ，能不能接得住话、记住了前文，并准确完成复杂的指令
  • “MT” (Multi-Turn) 的含义
    • 传统的评测往往是一问一答（Single-turn），模型回答完就结束了，但在真实应用中，用户经常会追问、修改需求或要求模型根据上文继续生成
    • MT-Bench
      • 多轮机制： MT-Bench 的每个测试题包含两轮对话
      • 第一轮： 提出一个有难度的问题
      • 第二轮： 基于模型的回答，提出一个追问（例如：“请把刚才的代码重写一遍，要求效率更高”或“请缩短刚才的文章，但保留核心观点”）
    • MT-bench 会考察模型是否具备上下文记忆、逻辑推理以及根据反馈修正的能力
  • MT-Bench 精心设计了 80 个高质量的多轮问题（共 160 个问答），涵盖了 8 个主要类别，旨在模拟人类的高频使用场景：
    • Writing (写作) ：创作、修改文本
      • 如 “写一篇博客…” -> “请改写得更幽默一点”
    • Roleplay (角色扮演)：模拟特定语气或人设
      • 如 “你是一个求职面试官…”
    • Reasoning (推理) ：逻辑推导、常识推理
      • 如 解决逻辑谜题或分析因果关系
    • Math (数学) ：数学计算与解题
      • 如 几何、代数或应用题
    • Coding (代码) ：编写与修改代码
      • 如 “写一个Python函数…” -> “请优化它的时间复杂度”
    • Extraction (提取) ：从长文中提取信息
      • 日 总结会议记录、提取关键数据
    • STEM (理工科) ：科学、技术、工程知识
      • 如 物理概念解释、工程原理
    • Humanities (人文) ：历史、文化、哲学
      • 如 分析历史事件或文化现象
  • MT-Bench 最具标志性的特点是它不完全依赖人工评分（太慢太贵），也不依赖传统的死板指标（如 BLEU/ROUGE，对生成式对话不准）
    • MT-Bench 使用 GPT-4 作为裁判（Judge），将待测模型的回答输入给 GPT-4，让 GPT-4 根据回答的质量、准确性、创造性等维度打分（通常是 1-10 分）
    • 研究表明，GPT-4 的打分结果与人类专家的偏好具有很高的一致性（Agreement rate），因此被广泛作为“平替”人类评估的低成本方案
  • 注：在开源大模型领域（如 Llama 3, Qwen, Mistral 等），MT-Bench 几乎是必测的标准之一，原因如下：
    • 1）更接近真实体验： 相比于做选择题（如 MMLU），MT-Bench 的开放式问答更像用户平时使用 ChatGPT 的真实感觉
    • 2）区分度高： 很多模型第一轮回答得不错，但第二轮追问时就会露馅（比如忘记前文设定），MT-Bench 能有效暴露出这种弱点
    • 3）Chatbot Arena 的风向标： MT-Bench 的分数通常与模型在 Chatbot Arena（盲测竞技场）中的 Elo 排名高度正相关
  • MT-Bench 的缺点：
    • GPT-4 偏见： GPT-4 可能更倾向于给“像自己”的回答打高分（Self-preference bias）
    • 题目数量少： 只有 80 题，模型可能会针对性地去“刷题”或过拟合（Overfitting）
    • 静态性： 题目是固定的，随着模型越来越强，很多题目变得太容易，区分度正在逐渐降低

SOP-Maze

  • 原始论文：SOP-Maze: Evaluating Large Language Models on Complicated Business Standard Operating Procedures， 20251010，Meituan & NJU
  • GitHub 地址：github.com/meituan-longcat/SOP-Maze
  • SOP-Maze 是一个用于评估大语言模型在复杂商业标准操作流程（SOP）场景下指令遵循能力的评测基准
    • 注：首个专注于真实商业 SOP 场景的 LLM 评测基准
  • SOP-Maze 数据来源与规模
    • 基于真实世界业务数据构建，经过人工参与筛选与优化
    • 包含 23 个复杂 SOP 场景 ，共 397 个任务实例 和 3422 个子任务
    • 平均每个 SOP 的规格说明长度约为 5040 个 token
  • SOP-Maze 将任务分为两类(LRS 与 HRS)，分别考察模型的“广度”与“深度”能力：
    • LRS （Lateral Root System（侧根系统））
      • 分支多但深度浅（最多3层），每个父节点可对应超10个子节点
      • 模型需在众多平行分支中做出精准选择，容易出现“路径盲区”
    • HRS （Heart Root System（主根系统））
      • 逻辑链深且长，强调前置条件的满足
      • 模型需保持长距离推理一致性，容易跳过中间步骤
  • 每个任务包含四个关键部分：
    • Objective ：目标与角色设定
    • Standard Operating Procedures ：执行逻辑与操作细节
    • User Input ：用户输入数据
    • Output Requirement ：输出格式要求（JSON Schema）
  • 评估方式
    • 采用 基于 JSON Schema 的自动评估 ，模型需同时输出用户期望的回复内容以及对应的 SOP 步骤索引
    • 评分体系：格式符合要求得 0.2 分 ，完全匹配参考答案得 1.0 分
  • 主流模型也在 SOP-Maze 上表现不佳，主要错误类型包括：
    • 路径盲区 ：难以严格按照流程执行，容易跳步或选错分支
    • 对话脆弱性 ：无法正确处理真实对话中的反语、意图反转、表达不流畅等
    • 计算错误 ：在时间计算、中位数过滤等算术推理任务中出错
  • 数据示例：给出背景和要求等，按照 SOP 分析情况并给出最终结论，都是有比较准确的评估方式的 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    【Background】
    你是一名打判专家，以第三人称视角的分析者，客观地解析客服和用户之间的对话，判断用户投诉倾向是哪一种。
    【Requirements】
    #任务流程 
            step 1 
            step 1.1 识别角色： 
            step 1.2 提取关键信息： 
            step 2 输出结果
            * 要求 xxx

    【Input】 
    chat_context: 
            Speaker 1:您好，我是本次为您服务的客服小美_275182，很高兴为您服务
            Speaker 1:不要着急亲，麻烦您再描述一下您遇到的问题呢~小美帮您处理
            Speaker 2:请问一下我这获得的券怎么使用
            Speaker 1:亲亲 请问是这个订单么
            xxxx

    【Output Requirement】
    你的输出必须满足以下JSON_SCHEMA{'$schema': 'http://json-schema.org/draft-07/schema#', 'type': 'object', 'title': '投诉信息输出格式', 'description': '用于验证投诉相关信息的JSON格式', 'properties': {'result': {'type': 'string', 'description': '投诉状态', 'enum': ['预投诉', '已投诉', '未投诉']}, 'Complaint Department': {'type': 'array', 'description': '投诉部门', 'items': {'type': 'string', 'enum': ['工商局', '市场监督管理局', '食药监', '运管局', '网信办', '工信部', '税务局', '公安局', '法院', '电视台', '报社', '新闻记者', '朋友圈', '抖音', '快手', '小红书', '微博', '12315', '12345市长热线', '黑猫投诉', '消费者协会', '其他']}, 'uniqueItems': True, 'minItems': 0}, 'Key sentence': {'type': 'string', 'description': "关键句子，根据对话内容提取，若没有则输出'无'"}}, 'required': ['result', 'Complaint Department', 'Key sentence'], 'additionalProperties': False}

MultiChallenge

  • 原始论文：MultiChallenge: A Realistic Multi-Turn Conversation Evaluation Benchmark Challenging to Frontier LLMs
  • GitHub ：ekwinox117/multi-challenge
  • MultiChallenge 是一个专注于评估 LLM 在多轮对话 中应对现实挑战能力的基准
  • MultiChallenge 主要验证模型的以下能力：
    • 指令保留 (Instruction Retention) ：模型能否在多轮对话后依然记住最初的指令
    • 推理记忆 (Inference Memory) ：对用户在前几轮提到的信息进行推理
    • 可靠的版本编辑 (Versioned Editing) ：在多次修改任务（如修改代码或文案）时保持一致性
    • 自我连贯性 (Self-coherence) ：回答不与之前的发言冲突

HELMET

  • HELMET: How to Evaluate Long-Context Language Models Effectively and Thoroughly, 20241003-20250506
  • HELMET（How to Evaluate Long-context Models Effectively and Thoroughly）是一个专门用于评估长上下文语言模型的综合评测基准
  • HELMET 评测集包含 多样化的任务类别（7类） ，涵盖真实应用场景
    • 检索增强生成（RAG）
    • 带引用的文本生成（Generation with Citations）
    • 段落重排序（Passage Re-ranking）
    • 多样本上下文学习（Many-shot ICL）
    • 长文档问答（Long-document QA）
    • 摘要生成（Summarization）
    • 合成召回任务（Synthetic Recall）
  • HELMET 评测集 支持更长的上下文长度
    • 所有数据集支持可控的输入长度，至少 128K tokens ，并可扩展到更长序列
  • HELMET 评测集 更可靠的评估指标
    • 对 QA 和摘要任务采用基于模型（GPT-4o）的评估 ，替代传统的 ROUGE 等 n-gram 重叠指标
    • 评估指标与人工判断的相关性更高（如摘要任务中 Cohen’s κ 可达 0.91）
  • HELMET 评测集 兼容基础模型（Base Models）
    • 通过少量示例（few-shot）提示 ，使得未经指令微调的模型也能被有效评估，弥补了现有基准多限于指令模型的不足
  • HELMET 评测集 更真实的模型排名
    • HELMET 能更好地区分模型性能，避免如 NIAH 等合成任务导致的“饱和”或反常排名现象

MarsBench (MARS-Bench)

  • 原始论文：MARS-Bench: A Multi-turn Athletic Real-world Scenario Benchmark for Dialogue Evaluation
  • MarsBench（全称：Multi-turn Athletic Real-world Scenario Benchmark）是首个利用体育赛事文字直播（Play-by-play）数据 构建的多轮对话基准，模拟了极端真实、高动态的场景
  • 注：学术界还有一个同名但不同领域的 Mars-Bench（用于火星科学任务的视觉模型评测），但在 LLM 评测语境下，通常指代以下对话基准
  • MarsBench 主要验证模型的以下能力：
    • 超多轮对话 (Ultra Multi-turn) ：包含超过 30 轮的对话序列
    • 交互式生成 (Interactive Generation) ：模型需要在每一轮都做出正确响应
    • 跨轮任务 (Cross-turn Tasks) ：需要从非相邻的轮次中提取和推理信息
    • 动机转移 (Motivation Transfer) ：用户意图在对话中发生突变时的处理能力

Multi-IF

  • 原始论文：Multi-IF: Benchmarking LLMs on Multi-Turn and Multilingual Instructions Following
  • Hugging Face ：huggingface.co/datasets/facebook/Multi-IF
  • GitHub ：facebookresearch/Multi-IF
  • Multi-IF 是 IFEval 的升级版
    • IFEval 主要关注单轮、英语的指令遵循，而 Multi-IF 将其扩展到了 多轮 和 多语言 环境
  • Multi-IF 主要验证模型的以下能力：
    • 多轮复杂性 ：每组数据包含 3 轮 连续对话，每轮都有特定的可验证指令（如“回复不少于 300 字”、“使用 JSON 格式”等）
    • 多语言支持 ：涵盖 8 种语言（包括中文、印地语、俄语等非拉丁字母语言）
    • 硬约束检查 ：沿用了 IFEval 的严苛评分方式，要求模型必须严格满足所有格式和内容约束

SkillsBench

附录：大模型训练集和测试集的划分

  • 补充问题：很多大模型相关文章不会明确给定训练样本和测试样本的拆分，那训练集和测试集是如何配置的呢？
  • 回答：与常规的机器学习方法不同，大模型中很多数据集是自动划分了 train 和 test 的
    • 使用 split="train" 就可以获取到训练数据
    • 使用 split="test" 就可以获取到测试数据
    • 未做特殊说明时，大部分方法都是在默认的训练集上进行训练，使用测试集进行评估

附录：数据集的访问和下载

  • 一般来说，直接在 HuggingFace 上直接可以看到相关数据集

  • 下载opencompass/AIME2025（包含 AIME2025-I 和 AIME2025-II子集）并打印的示例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    from datasets import load_dataset

    dataset = load_dataset("opencompass/AIME2025", 'AIME2025-I') # 'AIME2025-I' 是子数据集的名称，需要去huggingface上看看是否有子集
    # dataset = load_dataset("opencompass/AIME2025", 'AIME2025-II') # 'AIME2025-II' 是子数据集的名称，需要去huggingface上看看是否有子集

    # 检查是否存在 'train' split
    if 'train' in dataset:
       print(dataset['train'][0])

    # 检查是否存在 'test' split
    if 'test' in dataset:
       print(dataset['test'][0])

    ## output
    # {'question': 'Find the sum of all integer bases $b>9$ for which $17_{b}$ is a divisor of $97_{b}$.', 'answer': '70'}

  • 特别注意：

    • 部分数据集还有子集，此时下载需要指定子集，否则可能失败
    • 部分数据集需要先登录和授权才能下载

附录：评估/测试工具

LightEval

  • LightEval 是一个专注于 LLM 评估的开源工具库，由 Hugging Face 开发
  • 它提供了标准化的评估框架，库中包含了许多数据集，可以直接加载和评估
  • 传入数据集和 model_predict_fn 即可
    • 数据集可通过 lighteval 库的 load_dataset 来加载
    • model_predict_fn 需要自定义模型的 predict 函数

OpenCompass

  • OpenCompass 是上海人工智能实验室开源的大模型评测平台，涵盖学科、语言、知识、理解、推理等五大评测维度，可全面评估大模型能力
  • OpenCompass 支持在线查看榜单，在线参与评测竞技
  • OpenCompass 还开源了大模型评测工具，使用很简便，GitHub 地址：OpenCompass 项目
  • OpenCompass 比 LightEval 封装的更好，评估更加简单

RM 评估：RewardBench

RewardBench2

  • 原始论文：REWARDBENCH 2: Advancing Reward Model Evaluation, 20250602

  • RewardBench2 是 RewardBench 基准的升级版本

    • v2 引入了更具挑战性的“多技能”评估维度，进一步测试 RM 在捕捉细微人类偏好和处理复杂逻辑时的表现

  • RewardBench2 中，除了 Ties 外的其他数据集都是类似 Best-of-N 的格式评分的

    • 最优答案的 label 为 1，通过判断其是否是最高 Reward Score 来给分；若多个答案同分，则取均值为得分

  • RewardBench2 包含的测试集有（相对 RewardBench 移除了 Chat 子集，新增了三个数据集并重新划分一些数据集）：

    • Math: 数学能力，主要包含从中学的物理（physics）和几何学（geometry）到大学级别的化学（chemistry）、微积分（calculus）、组合数学（combinatorics）等
    • Safety: 安全性
    • Focus: 检查一般 Query 上的高质量回复能力

      Tests RMs’ ability to detect high-quality, on-topic answers to general user queries.

    • Ties (NEW!): 用一些回答为平手的数据检查模型评分的健壮性

      This new type of subset tests the robustness of RMs in domains with many possible similar answers. For example, the question “Name a color of the rainbow” has seven possible correct answers and infinitely many incorrect ones.

    • Factuality (NEW!): 模型幻觉检查
    • Precise Instruction Following (Precise IF，NEW!): 指令遵循能力

      such as “Answer without the letter u”.

  • 非 Ties 的子集，基本都是针对 ID 进行分组，多个样本一起体现一个组内的表现，评估是否最高分是 label=1 的样本

    • 当 N 样本都打了最高分，给分为 1/N

  • RewardBench2:Ties，这个数据集会在同一个 prompt 上给出很多等价的正确回答和错误回答，然后评估模型给出的分差 GAP

    • 目标是希望所有正确回答的分数 GAP（最高正确-最低正确）比 正负 GAP（最低正确-最高错误）的值要大
    • 不仅关注打分是否正样本大于负样本，还关注是否所有正样本比负样本都大得多
    • 取名为 Ties 的本意就是让模型能对平手的 回复打分方差不要太大
    • 举例：prompt=”Pick a number between 1 and 10.”，正确回答是 1-10 之间的数字，错误回答是其他数字，从而可以 check 模型的评估能力是否有问题
    • 样本示例： 
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      {
          "id": "tied:0",
          "target": "Eleven",
          "label": 0,
          "num_c": 10,
          "num_r": 12,
          "num_all": 22,
          "subset": "Ties",
          "eval_set": "reward_bench2",
          "messages": [
              {
              "role": "user",
              "content": "Pick a number between 1 and 10."
              }
          ]
      }

  • allenai/reward-bench 中有 RewardBench2 指标的具体统计实现

RM 评估：JudgeBench

RM 评估：PPE Preference

  • PPE Preference & Correctness
  • HuggingFace：
  • PPE（Prompt-Preference-Evaluation）相关的测试主要关注模型对真实人类偏好的理解深度
  • PPE 基准使用的数据通常源自真实用户的交互记录（而非合成数据），因此更能反映模型在实际应用场景（如 AI 助手）中的表现
  • PPE 的评估维度包含 Preference（偏好排序）和 Correctness（正确性判断）
  • 在 Skywork-Reward-V2 的评估中，PPE 被用来验证模型是否能区分（高质量）与（次优）数据，确保模型真正理解人类的意图和喜好
  • 该指标常在 Skywork (昆仑万维) 及相关 RLHF 研究中作为核心真实场景指标出现

RM 评估：RM-Bench

  • 原始论文：RM-Bench: Benchmarking Reward Models of Language Models with Subtlety and Style, 20241021, Fudan & THU & HKUST
  • 开源项目：github.com/THU-KEG/RM-Bench
  • RM-Bench 是一个专门针对奖励模型鲁棒性和一致性的评估基准
  • RM-Bench 通常关注模型在面对不同类型的输入干扰、对抗性样本或特定安全边界时的表现
  • RM-Bench 基准旨在揭示奖励模型在“过度优化”（Reward Hacking）风险下的稳定性，确保模型给出的高分确实对应高质量回复，而非利用了模型的漏洞
  • RM-Bench 的评估指标核心特点是聚焦“内容敏感性”与“风格偏见抗性”，以三级准确率梯度设计为核心，结合域特异性与跨域综合指标，且与策略模型性能强相关

基础评估框架：分类任务定义

  • 核心任务：给定三元组 \((x, y_c, y_r)\)（\(x\) 为提示词，\(y_c\) 为优选 Response ，\(y_r\) 为弃选 Response ），判断 \(R_\psi(x, y_c) > R_\psi(x, y_r)\)（\(R_\psi\) 为奖励模型，\(\psi\) 为模型参数）
  • 基础准确率公式：
    $$
    \text{Accuracy} = \frac{1}{|\mathcal{D}|} \sum_{(x, y_c, y_r) \in \mathcal{D} } \mathbb{I}\left[R_{\psi}(x, y_c) > R_{\psi}(x, y_r)\right]
    $$
    • 其中 \(\mathbb{I}(\cdot)\) 为指示函数，\(\mathcal{D}\) 为评估数据集；多目标奖励模型采用奖励向量逐元素比较

风格-实质分离评估：3×3 矩阵与三级准确率

  • 风格变体：涵盖三类 Response 风格——简洁型（\(y^\emptyset\)）、详细纯文本型（\(y^L\)）、详细带Markdown型（\(y^{L,M}\)）
  • 评估矩阵：构建行（Chosen Response 风格）X 列（Rejected Response 风格）的 3x3 风格-实质矩阵，衍生三类核心指标：
    • 简易准确率（Easy Accuracy）：矩阵下三角均值，衡量有风格提示时的内容识别能力
    • 正常准确率（Normal Accuracy）：矩阵对角线均值，评估风格一致时的内容判断能力
    • 困难准确率（Hard Accuracy）：矩阵上三角均值，测试弃选 Response 风格更优时的纯内容区分能力
  • 详情见原始论文图 2

域特异性与综合指标结合

  • 域特异性指标：针对聊天、代码、数学、安全四大核心域，分别计算各域的三级准确率（如 Chat Normal Accuracy、Math Hard Accuracy）
  • 跨域综合指标：计算所有域的平均准确率（Average Accuracy），作为奖励模型整体性能的统一衡量标准

与策略模型性能强关联

  • 风格控制相关性：奖励模型的 Chat 域 Hard Accuracy 与策略模型的风格控制得分显著正相关，能反映策略模型对风格偏见的抵抗能力
  • 下游任务相关性：与策略模型在数学（GSM8k、Big Bench Hard）、代码（HumanEval+、MBPP+）、安全（ToxiGen、XSTest）等下游任务的表现呈中度正相关，Pearson 相关系数 \(r=0.55\)（\(p=0.07\)），显著优于传统基准（如 RewardBench 的 \(r=0.21\)）

RM 评估：RMB

  • RMB：Reward Model Benchmark
  • 原始论文：RMB: Comprehensively Benchmarking Reward Models in LLM Alignment, 20241013 & ICLR 2025, Fudan
  • RMB 是一个全面且细粒度的奖励模型评估基准，核心亮点是创新性和贴近现实应用
  • RMB 涵盖 49 个现实世界场景，核心目标：
    • 有用性目标场景（Helpfulness, 75.5%）： 37 个场景的 12 个任务
      • Code、开放问答（Open QA）、封闭问答（Closed QA）、翻译（Translation）、内容生成、Reasoning、角色扮演（Role Playing）、文本改写（Rewrite）、分类（Classification）、聊天对话（Chat）、摘要总结（Summarization）、头脑风暴（Brainstorming）
    • 无害性目标场景（Harmlessness, 24.5%）： 12 个场景，构建了超 18000 个高质量偏好对
      • 暴力相关（Violent Crimes）、非暴力相关（Non-Violent Crimes）、性相关违法（Sex-Related Crimes）、未成年人保护（Child Sexual Exploitation）、专业建议规范（Specialized Advice）、隐私保护（Privacy）、知识产权保护（Intellectual Property）、危险武器相关（Indiscriminate Weapons）、仇恨言论相关（Hate）、自我伤害相关（Suicide & Self-Harm）、色情内容相关（Sexual Content）、混合场景（Multi）
  • RMB 通过真实世界的用户查询构建具有实际意义的测试任务，并借助14个大型语言模型生成回复并评级，最终形成超18000个高质量偏好对，可充分检验奖励模型的场景泛化能力
  • 评估范式：
    • pairwise 评估范式：传统的成对比较评估模式
    • Best-of-N 评估范式：测试奖励模型从多个候选回复中挑选最佳回应的能力
      • 经实验验证，其评估结果与奖励模型在下游对齐任务中的表现关联性强，能揭示现有模型的泛化缺陷，同时还强调了生成式奖励模型的发展潜力
  • 数据集详细分布见原始论文附录 A

本文主要介绍LLM的各种编码方式

整体介绍

  • 位置编码 ：Position Encoding，一些地方也叫作 Positional Encoding，由于一般是一个向量的形式，所以在很多文章中也叫作Postion Embedding，一般简写为PE
    • 个人理解：可学习时使用Postion Embedding合适，不可学习时使用Postion Encoding合适
  • 常用位置编码 ：当前常用的位置编码方式有固定位置编码、正弦位置编码(Sinusoidal)、旋转位置编码(RoPE)、相对位置编码(AliBi)等
  • 外推性含义 ：是指模型在预测时，处理超过模型训练长度的能力。外推性越好，则模型对于长度越不敏感，即可以在更长/未训练过的长度上预测

为什么需要位置编码？

  • 根据Self-Attention的基本逻辑，Self-Attention不关注顺序，只关注表示q,k,v向量本身
  • 在没有位置编码的情况下：
    • 假设输入是 \([a^0,b^0,c^0,d^0]\)，那么第1次Self-Attention的输出是 \([a^1,b^1,c^1,d^1]\)，同理，第t次Attention的输出是 \([a^t,b^t,c^t,d^t]\)
    • 假设输入是 \([a^0,c^0,b^0,d^0]\)，那么第1次Self-Attention的输出是 \([a^1,c^1,b^1,d^1]\)，同理，第t次Attention的输出是 \([a^t,c^t,b^t,d^t]\)
  • 显然， \([a^0,b^0,c^0,d^0]\) 和 \([a^0,c^0,b^0,d^0]\) 无数次Self-Attention以后的结果只有序的差别，而Transformer本身主要就是许多层的Self-Attention组成的
  • 如果在模型的最后一层我们增加了一个全连接层去实现一个文本分类，显然对模型来说想学到两者的序的差别是困难的（注意不是完全学不到，只是比较困难）
  • 如果在Self-Attention之前或Self-Attention的过程中就考虑位置，那么 \([a^0,b^0,c^0,d^0]\) 和 \([a^0,c^0,b^0,d^0]\) 每次Self-Attention后的结果都会差异较大，随着Self-Attention次数的增多，模型可以用复杂的参数学到位置信息
  • Causal Decoder（Transformer的Decoder部分）模型中，由于存在Mask，此时的Self-Attention不再是对称的，此时每一层Masked Self-Attention自然就有一定的位置信息。（因此有些研究文章也提到Causal Decoder不需要位置编码）
  • Transformer中Encoder和Decoder都有位置编码
  • 个人理解：
    • 增加位置编码至少不会带来坏处
    • 即使模型能区分位置，也不代表增加位置编码没有收益，因为显示增加位置编码会降低模型学习的难度（相当于是一个强特征，这对模型很重要）

固定位置编码

  • 具体实现：对每个位置 \(i\) 初始化一个可学习的参数向量 \(\boldsymbol{p}_i\)，然后在输入的向量 \(\boldsymbol{x}_i\) 中加入这个向量，训练过程中更新位置向量
    $$
    \boldsymbol{x}_i = \boldsymbol{x}_i + \boldsymbol{p}_i
    $$
    • 由于是可学习的向量，也叫作Position Embedding
    • 注：在很多文献中，也称正弦位置编码为固定位置编码
  • BERT 中使用了这种编码方式，这种位置编码方式，最大的缺点是无法外推

正弦位置编码

  • 正弦位置编码，即Sinusoidal Positional Encoding（由于此处位置编码是不可学习的向量，所以使用Encoding而不是Embedding），最早在 Transformer 原始论文中提出
  • 由于正弦位置编码实际上每个位置也是固定的，所以很多文献也称正弦位置编码为固定位置编码
  • Transformer的原生位置编码方式
  • 每个token的位置的编码是提前固定的，不可学习的
  • 使用了Sinusoidal函数，即正弦曲线函数，所以也叫作也叫作Sinusoidal位置编码
  • 具体来说把每个位置编码为一个向量 \(\boldsymbol{p}_i\)：
    $$
    p_{pos,2i} = sin\left(\frac{pos}{10000^{2i/\text{d_model}}}\right) \\
    p_{pos,2i+1} = cos\left(\frac{pos}{10000^{2i/\text{d_model}}}\right) \\
    $$
    • \(pos \in [0,\text{seq_len}]\) 是 token 的位置，表示第 \(pos\) 个 token，为了方便书写和理解，下文中也使用 \(t\) 表示位置
    • \(i \in [0,\frac{d}{2}]\) 是 Embedding 维度，表示第 \(i\) 个 Embedding 维度
  • 展开来看有：
    $$
    \begin{equation} \boldsymbol{p}_{pos} = \begin{pmatrix}\sin (pos\cdot\theta_0) \\ \cos (pos\cdot\theta_0) \\ \sin (pos\cdot\theta_1) \\ \cos (pos\cdot\theta_1) \\ \vdots \\ \sin (pos\cdot\theta_{d/2-1}) \\ \cos (pos\cdot\theta_{d/2-1})
    \end{pmatrix}, \quad \theta_i = \frac{1}{10000^{2i/\text{d_model}}}
    \end{equation}
    $$
  • 在输入层将位置向量添加到输入中
    $$
    \boldsymbol{x}_t = \boldsymbol{x}_t + \boldsymbol{p}_t
    $$
  • 特点1：位置向量 \(\boldsymbol{p}_{t+k}\) 可以由 \(\boldsymbol{p}_{i}\) 和 \(\boldsymbol{p}_{k}\) 表示得到（使用三角函数的性质即可证明），以下证明来源于：再论大模型位置编码及其外推性（万字长文）（注：文章中认为 “其中u, v为关于k的常数，所以可以证明PE(t+k)可以由PE(i)线性表示。”这句话理解有误，实际上位置向量 \(\boldsymbol{p}_{t+k}\) 需要由 \(\boldsymbol{p}_{i}\) 和 \(\boldsymbol{p}_{k}\) 共同表示）
  • 特点2：任意两个位置向量的乘积只与他们之间的距离有关 ：以下证明最后一步可以通过下面的三角函数公式 \(cos(\alpha-\beta)=cos\alpha \cdot cos\beta+sin\alpha \cdot sin\beta\) 得到（注：三角函数的变换公式可参考：考生必记：三角函数公式汇总+记忆（没有比这更全））
  • 特点3：随着相对距离增加，位置向量的内积逐渐减小，有衰减趋势（这里是波动衰减，不是单调的），下图参考自再论大模型位置编码及其外推性（万字长文）
  • 训练/预估时同一个批次的队列的token长度需要相同，不足最大长度的需要padding
    • 仔细观察原始公式可以知道，对于固定的位置 \(pos\)，随着维度 \(i \in [0,\frac{d}{2}-1]\) 的逐步增大 \(i = 0 \rightarrow \frac{d}{2}\)（注：取不到\(\frac{d}{2}\)），角度变化为：
      $$
      \begin{align}
      2i/\text{d_model} &\in [0,1), \quad 0 \rightarrow 1\\
      10000^{2i/\text{d_model}} &\in [1,10000), \quad 1 \rightarrow 10000\\
      \frac{pos}{10000^{2i/\text{d_model}}} &\in [pos,\frac{pos}{10000}), \quad pos \rightarrow \frac{pos}{10000}
      \end{align}
      $$
    • 按照行（位置）作比较来看，不同行（位置）的表示角度范围不同（这里指 sin/cos 内部角度的范围），位置越大，角度范围越大，经历的周期越多
    • 按照列（d_model维度）作比较来看，不同列的周期不同，列对应的维度位置 \(i\) 越高，频率越低，周期越小
    • 同一列内部来看，sin/cos函数的角度 \(\frac{pos}{10000^{2i/\text{d_model}}}\) 从上往下单调递增 ，（ \(pos\) 单调递增，导致 \(\frac{pos}{10000^{2i/\text{d_model}}}\) 单调递增）
    • 同一行内部来看，sin/cos函数的角度 \(\frac{pos}{10000^{2i/\text{d_model}}}\) 从左往右单调递减 ，（ \(i\) 单调递增，导致 \(\frac{pos}{10000^{2i/\text{d_model}}}\) 单调递减）
  • \(\frac{pos}{10000^{2i/\text{d_model}}}\) 中的base=10000，base的取值实际上决定的是周期，base越大，周期越大，频率越小

相对位置编码

  • 原始论文：Self-Attention with Relative Position Representations, 2018, Google
  • 核心思路：把相对位置信息加到 V 上或 K 上
  • 原始 Attention：
    $$\alpha_{i,j} = \text{Softmax}(\boldsymbol{q}_i \boldsymbol{k}_j^\top)\\
    \boldsymbol{o}_i = \sum_j \alpha_{i,j} \boldsymbol{v}_j\\$$
  • 相对位置编码下的 Attention，相对位置信息加到 V 上（为了方便解释，使用的符号和原始论文不完全相同）：
    $$\alpha_{i,j} = \text{Softmax}(\boldsymbol{q}_i \boldsymbol{k}_j^\top)\\
    \boldsymbol{o}_i = \sum_j \alpha_{i,j} (\boldsymbol{x}_j \boldsymbol{W}^V + \boldsymbol{R}_{i,j}^V)$$
    • 其中 \(\boldsymbol{R}_{i,j}^V\) 是一个与相对位置 \(i-j\) 有关的矩阵
    • 本质是把位置编码增加到了 V 上，作为对比，原始 Attention 的输出为：\(\boldsymbol{o}_i = \sum_j \alpha_{i,j}(\boldsymbol{x}_j \boldsymbol{W}^V)\)
  • 相对位置编码下的 Attention，相对位置信息加到 K 上：
    $$\alpha_{i,j} = \text{Softmax}(\boldsymbol{q}_i (\boldsymbol{x}_j \boldsymbol{W}^K + \boldsymbol{R}_{i,j}^K)^\top)\\
    \boldsymbol{o}_i = \sum_j \alpha_{i,j} \boldsymbol{v}_j\\$$
    • 其中 \(\boldsymbol{R}_{i,j}^K\) 是一个与相对位置 \(i-j\) 有关的矩阵

RoPE-旋转位置编码

基本思想

  • 基本思路：通过将旋转位置编码（对每个位置的token输入向量进行旋转，旋转角度与位置有关），实现相对位置编码的能力
  • 本质：不再将位置向量直接加到原始输入向量中，而是在Attention的时候同时考虑位置，根据不同的两个位置进行不同的Attention（实际上是在Attention中Query和Key的内积中考虑位置信息）
    • 理解：这个思路其实没问题，因为当前我们输入向量都要经过Attention的，只要Attention中考虑了位置，就能保证模型能考虑到位置

位置嵌入过程

  • 旋转位置编码(RoPE)的核心思想 ：通过旋转矩阵将绝对位置信息融入Self-Attention机制中
  • 基本定义 ：对于位置\( m \)的词向量\( \boldsymbol{x}_m \in \mathbb{R}^d \)，通过线性变换得到查询向量\( \boldsymbol{q}_m \)和键向量\( \boldsymbol{k}_n \)：
    $$
    \boldsymbol{q}_m = W_q \boldsymbol{x}_m, \quad \boldsymbol{k}_n = W_k \boldsymbol{x}_n
    $$
  • 旋转操作 ：将\( \boldsymbol{q}_m \)和\( \boldsymbol{k}_n \)划分为\( d/2 \)个复数对（每组2维），对第\( i \)组复数应用旋转矩阵：
    $$
    \begin{aligned}
    \boldsymbol{q}_m^{(i)} &= \begin{pmatrix}
    q_{m,2i} \\
    q_{m,2i+1}
    \end{pmatrix}, \quad
    \boldsymbol{k}_n^{(i)} = \begin{pmatrix}
    k_{n,2i} \\
    k_{n,2i+1}
    \end{pmatrix} \\
    R_{\theta_i}^m &= \begin{pmatrix}
    \cos m\theta_i & -\sin m\theta_i \\
    \sin m\theta_i & \cos m\theta_i
    \end{pmatrix}, \quad \theta_i = 10000^{-2i/d}
    \end{aligned}
    $$
    • 注意：位置为 \(m\) 的旋转矩阵对应正余弦角度为 \(\color{red}{m}\theta_i\)
  • 旋转后的向量 ：旋转后的查询和键向量为：
    $$
    \begin{aligned}
    \boldsymbol{q}_m’ = \bigoplus_{i=0}^{d/2-1} R_{\theta_i}^m \boldsymbol{q}_m^{(i)}, \quad
    \boldsymbol{k}_n’ = \bigoplus_{i=0}^{d/2-1} R_{\theta_i}^n \boldsymbol{k}_n^{(i)}
    \end{aligned}
    $$
    • 其中\( \oplus \)表示向量拼接：
      $$\bigoplus_{i=0}^{d/2-1} R_{\theta_i}^m \boldsymbol{q}_m^{(i)} = \text{Concat}(\{ R_{\theta_i}^m \boldsymbol{q}_m^{(i)}\}_{i=0}^{d/2-1})$$
  • 旋转后的Attention权重变化
    $$
    \begin{equation}
    (\boldsymbol{\mathcal{R}}_m \boldsymbol{q}_m)^{\top}(\boldsymbol{\mathcal{R}}_n \boldsymbol{k}_n) = \boldsymbol{q}_m^{\top} \boldsymbol{\mathcal{R}}_m^{\top}\boldsymbol{\mathcal{R}}_n \boldsymbol{k}_n = \boldsymbol{q}_m^{\top} \boldsymbol{\mathcal{R}}_{n-m} \boldsymbol{k}_n
    \end{equation}
    $$
    • 位置为 \(m\) 的向量 \(\boldsymbol{q}_m\) 乘以矩阵 \(\boldsymbol{\mathcal{R}}_m\)；位置为 \(n\) 的向量 \(\boldsymbol{k}_n\) 乘以矩阵 \(\boldsymbol{\mathcal{R}}_n\)（注意角标）
    • 上面的式子中等式是恒成立的（详细证明见 NLP——旋转位置编码-RoPE），右边的 \(\boldsymbol{\mathcal{R}}_{n-m}\)仅与相对位置 \(n-m\) 有关，体现了相对位置编码的核心要义
      • 注：\(\boldsymbol{\mathcal{R}}_{m-n}\) 和 \(\boldsymbol{\mathcal{R}}_{n-m}\) 不相等，旋转角度相同，但方向相反
  • 展开成矩阵相乘的形式为（refer to Transformer升级之路：2、博采众长的旋转式位置编码）：
    $$
    \begin{equation}\scriptsize{\underbrace{\begin{pmatrix}
    \cos m\theta_0 & -\sin m\theta_0 & 0 & 0 & \cdots & 0 & 0 \\
    \sin m\theta_0 & \cos m\theta_0 & 0 & 0 & \cdots & 0 & 0 \\
    0 & 0 & \cos m\theta_1 & -\sin m\theta_1 & \cdots & 0 & 0 \\
    0 & 0 & \sin m\theta_1 & \cos m\theta_1 & \cdots & 0 & 0 \\
    \vdots & \vdots & \vdots & \vdots & \ddots & \vdots & \vdots \\
    0 & 0 & 0 & 0 & \cdots & \cos m\theta_{d/2-1} & -\sin m\theta_{d/2-1} \\
    0 & 0 & 0 & 0 & \cdots & \sin m\theta_{d/2-1} & \cos m\theta_{d/2-1} \\
    \end{pmatrix}}_{\boldsymbol{\mathcal{R}}_m} \begin{pmatrix}q_0 \\ q_1 \\ q_2 \\ q_3 \\ \vdots \\ q_{d-2} \\ q_{d-1}\end{pmatrix}}\end{equation}
    $$
  • 由于旋转矩阵是一个稀疏矩阵，所以旋转过程可以改进为如下等价实现：
    $$
    \begin{equation}\begin{pmatrix}q_0 \\ q_1 \\ q_2 \\ q_3 \\ \vdots \\ q_{d-2} \\ q_{d-1}
    \end{pmatrix}\otimes\begin{pmatrix}\cos m\theta_0 \\ \cos m\theta_0 \\ \cos m\theta_1 \\ \cos m\theta_1 \\ \vdots \\ \cos m\theta_{d/2-1} \\ \cos m\theta_{d/2-1}
    \end{pmatrix} + \begin{pmatrix}-q_1 \\ q_0 \\ -q_3 \\ q_2 \\ \vdots \\ -q_{d-1} \\ q_{d-2}
    \end{pmatrix}\otimes\begin{pmatrix}\sin m\theta_0 \\ \sin m\theta_0 \\ \sin m\theta_1 \\ \sin m\theta_1 \\ \vdots \\ \sin m\theta_{d/2-1} \\ \sin m\theta_{d/2-1}
    \end{pmatrix}\end{equation}
    $$
    • 其中 \(\otimes\) 是按位相乘
  • RoPE下的Attention公式总结 ：（旋转位置编码的核心公式）
    $$
    \begin{aligned}
    \text{Attention}(\boldsymbol{x}) &= \text{softmax}\left(\frac{(\boldsymbol{q}’)^\top \boldsymbol{k}’}{\sqrt{d} }\right)V
    \end{aligned}
    $$

旋转体现在哪里？

  • 旋转体现在 \(\boldsymbol{q}_m\)（或\(\boldsymbol{k}_n\)） 的每两个维度组成的向量 \(\boldsymbol{q}_m^{(i)} = \begin{pmatrix} q_{m,2i} \\ q_{m,2i+1} \end{pmatrix}\) 经过 RoPE 变换前后，他们的向量长度不变，即：
    $$
    \begin{pmatrix}cos(m\theta_1) &-sin(m\theta_1) \\ sin(m\theta_1) &cos(m\theta_1)\end{pmatrix} \begin{pmatrix}q_{m,2i} \\ q_{m,2i+1}\end{pmatrix} = \begin{pmatrix}q_{m,2i}\cdot cos(m\theta_1) -q_{m,2i+1}\cdot sin(m\theta_1) \\ q_{m,2i}\cdot sin(m\theta_1)+ q_{m,2i+1}\cdot cos(m\theta_1) \end{pmatrix} \\
    $$
  • 进一步，由于 \((cos(m\theta_1))^2 + (sin(m\theta_1))^2 = 1\) 有
    $$
    \begin{align}
    \left|\begin{pmatrix}q_{m,2i}\cdot cos(m\theta_1) -q_{m,2i+1}\cdot sin(m\theta_1) \\ q_{m,2i}\cdot sin(m\theta_1)+ q_{m,2i+1}\cdot cos(m\theta_1) \end{pmatrix} \right| &= \sqrt{\left(q_{m,2i}\cdot cos(m\theta_1) -q_{m,2i+1}\cdot sin(m\theta_1)\right)^2 + \left(q_{m,2i}\cdot sin(m\theta_1)+ q_{m,2i+1}\cdot cos(m\theta_1)\right)^2} \\
    &= \sqrt{(q_{m,2i})^2 + (q_{m,2i+1})^2}
    \end{align}
    $$
  • 也就是说： \(\boldsymbol{q}_m\)（或\(\boldsymbol{k}_n\)）相邻两两维度在变换前后的向量长度并没有变化，是一个旋转操作

如何改进 RoPE 以实现绝对位置编码？

  • 当前的设计仅能实现相对位置编码（因为 Query 和 Key 的内积只与他们的相对位置有关，与绝对位置无关），但如果在 Value 上也施加位置编码则能实现绝对位置编码的能力
  • 让研究人员绞尽脑汁的Transformer位置编码中苏神提到：

    这样一来，我们得到了一种融绝对位置与相对位置于一体的位置编码方案，从形式上看它有点像乘性的绝对位置编码，通过在 \(\boldsymbol{q},\boldsymbol{k}\) 中施行该位置编码，那么效果就等价于相对位置编码，而如果还需要显式的绝对位置信息，则可以同时在 \(\boldsymbol{v}\) 上也施行这种位置编码。总的来说，我们通过绝对位置的操作，可以达到绝对位置的效果，也能达到相对位置的效果

T5 Bias-可学习的相对位置编码

  • TLDR：T5 Bias 是一种相对位置编码，通过在 Self-Attention 机制中加入一个可学习的偏置项来实现

AliBi-相对位置编码

基本思想

  • 在位置上增加一个偏执，距离越远，相关度惩罚越大
  • 不同head以不同的坡度去进行衰减

详细方案

  • 将Attention中的softmax修改为如下的形式
    $$
    Softmax\left(\boldsymbol{q}_i\boldsymbol{K}^T + m \cdot [-(i-1), \cdots ,-2, -1, 0]\right)
    $$
    • 上式中， \(\boldsymbol{K}\) 是行数为 \(i\) 的矩阵（偏置项 \(m \cdot [-(i-1), \cdots ,-2, -1, 0]\) 的长度也为 \(i\)），因为在 Decoder-only 场景中，对于 \(\boldsymbol{q}_i\)，仅需要与前 \(i\) 个 Key 向量做交叉即可，后面的都不需要考虑
      • 换句话说，当 \(i < j\) 时 \(\boldsymbol{q}_i\boldsymbol{k}_j\) 不需要加偏置（反正看不到）
      • ALiBi 实际上是对隔得远的位置添加压制，让离得远的位置 Attention Score 变小（符合隔得越远，越不相关的常识）
  • 在MHA中，每个头对应的 \(m\) 取值不同，对于N个head的情况，第n个head的取值为
    $$
    m_n = 2^{\frac{-8}{n}}
    $$
  • 原始论文中的方法图示：
  • 原始论文中对ALiBi方法的讲解：

一些简单讨论

  • ALiBi具有极强的外推能力：在推理时能处理远超训练长度的序列（如从8K扩展到32K），且无需微调
    • 因为ALiBi的本质是对离得远的位置进行 Attention Score 压制，这个压制值可以多，也可以少，队列越长，压制越大就行
  • ALiBi计算效率高：仅需在 Attention 计算时添加偏置，不增加额外参数
  • 缺点：容易完全忽略远程的一些关系，ALiBi的线性偏置会显著降低远距离token的注意力分数，使模型难以捕捉超远举例的依赖
  • 目前使用AliBi编码的模型有：Baichuan13B

位置编码的外推性

外推性定义

  • 外推性含义 ：是指模型在预测时，处理超过模型训练长度的能力。外推性越好，则模型对于长度越不敏感，即可以在更长/未训练过的长度上预测
  • 外推性不好带来的问题 ：如果模型的外推性不好，那么在预测时，超出训练时指定的长度就容易出现性能不佳的现象，这会影响模型在多轮会话上的表现
  • 外推性的评估指标 ：常用困惑度（Perplexity）

不同位置编码外推性比较

  • 下面是 ALiBi 原始论文 ALiBi 的实验结论：
  • 从图中可以看出外推性能：ALiBi > T5 Bias > RoPE > Sinusoidal
  • ALiBi 不添加位置 Embedding，而是在 Q,K 点积后添加静态、非学习的线性偏差，ALiBi的本质是对离得远的位置进行 Attention Score 压制，这个压制值可以多，也可以少，队列越长，压制越大就行
  • RoPE 理论上可以实现外推，但存在多个问题：
    • 问题一：某些维度上遇到未见过的旋转角度。RoPE中 Embedding 向量靠前的部分被旋转的次数多（维度 \(i\) 越靠前，对应的角度 \(\theta_i\) 越大，周期越小），只需要很短的序列就能旋转一周，训练很充分；但靠后的部分被旋转次数少，需要训练很长序列才能旋转一周，训练时没见过的旋转角度，如果在推理时出现了，模型难以处理（这个问题 NTK-aware Scaled RoPE 也没有彻底解决，是 YaRN 引入 NTK-by-parts Interpolation 才解决的）
    • 问题二：RoPE是基于正余弦三角式位置编码改进的，正余弦三角式位置编码本身外推性存在缺点，虽不需要训练就能推演无限长度位置编码，但远处位置信息因周期性函数的特性，在位置衰减后趋于直线震荡 ，位置信息区分度变差 ，RoPE 基于正余弦三角式位置编码改进 ，也受到了一定影响
  • Sinusoidal 理论上可以实现外推，但存在以下问题：
    • 问题一：虽然 Sinusoidal Q,K 点积的值仅与相对位置有关，但 Sinusoidal 是绝对位置编码，修改了原始 Embedding 向量的值，这个修改会影响后续的每一个模块，如果模型没有见过某个绝对位置编码，模型表现是未知的（增加一个模型没有见过的位置编码很危险）
    • 问题二：也与RoPE一样，存在远程震荡衰减现象，远程震荡导致位置信息区分度变差
  • 注：Sinusoidal 虽然看着能有相对位置编码的思维，但是本质是绝对位置编码，模型对未见过的位置编码是难以外推的，所以直观上看，RoPE 理论上有比 Sinusoidal 更好的外推性

RoPE的外推性优化

RoPE 的直接外推

  • 直接外推方法 ：不对模型做任何处理，直接使用模型推理超出训练长度的场景，实现上下文长度扩展
  • 理论支撑 ：RoPE 通过旋转矩阵编码绝对位置信息来融入相对位置信息，理论上有外推能力
  • 缺点 ：短队列下，Embedding 后半部分旋转角度训练不足；存在远程震荡衰减现象，远程震荡导致位置信息区分度变差，所以直接外推方法仅限于较小的扩展
  • 实验结论 ：直接外推法对非外推部分友好，对外推部分不友好，推理时遇到没见过的外推位置，效果难以保障；实际上，也可以通过继续微调实现外推到更长的上下文，但是需要的训练量较大

RoPE 的线性内插

  • 线性内插，也称为位置内插（Position Interpolation，PI），原始论文 (Position Interpolation)EXTENDING CONTEXT WINDOW OF LARGE LANGUAGE MODELS VIA POSITION INTERPOLATION, 2023, Meta
  • 具体方法可以简单理解为保证原始旋转角度不变化的情况下扩展上下文长度，具体地，此时的 Attention 如下形式：
    $$
    \begin{equation}
    (\boldsymbol{\mathcal{R}}_{\color{red}{\frac{m}{k}}} \boldsymbol{q}_m)^{\top}(\boldsymbol{\mathcal{R}}_{\color{red}{\frac{n}{k}}} \boldsymbol{k}_n) = \boldsymbol{q}_m^{\top} \boldsymbol{\mathcal{R}}_{\color{red}{\frac{m}{k}}}^{\top}\boldsymbol{\mathcal{R}}_{\color{red}{\frac{n}{k}}} \boldsymbol{k}_n = \boldsymbol{q}_m^{\top} \boldsymbol{\mathcal{R}}_{(\color{red}{\frac{n}{k}}-\color{red}{\frac{m}{k}})} \boldsymbol{k}_n
    \end{equation}
    $$
    • 此时，位置为 \(m\) 的向量 \(\boldsymbol{q}_m\) 乘以矩阵 \(\boldsymbol{\mathcal{R}}_{\color{red}{\frac{m}{k}}}\)；位置为 \(n\) 的向量 \(\boldsymbol{k}_n\) 乘以矩阵 \(\boldsymbol{\mathcal{R}}_{\color{red}{\frac{n}{k}}}\)（注意角标）
    • 上述方法从而实现了将最大长度为 \(L\) 的模型扩展到了 \(L’ = k\cdot L\)，此时有 \(k\) 的取值为：
      $$ k = \frac{L’}{L} $$
    • 由于这种扩展保证了原始旋转角度不变化的情况下扩展长度，这样做法理论上保证了不存在直接外推中遇到的Embedding 后半部分旋转角度训练不足问题
  • PI方法示例：
  • 实验结果：

    refer to 旋转式位置编码 (RoPE) 知识总结 - Soaring的文章 - 知乎
    这样做的效果如何呢? 实验发现, 在没有额外训练的情况下, 线性内插 的效果比 直接外推 的效果要差; 如果额外训练 1000 步, 线性内插 的效果和原本效果是接近的

    • 问题：在不增加训练的情况下，为什么位置内插效果反而不如直接外推？
    • 理解：这里效果不好主要是针对非外推部分（即距离较近的部分），这种做法理论上会影响模型在已经训练的不错的近距离上的效果
    • 实验结论 ：线性内插后需要额外训练才能保证非外推部分的效果，但是对于外推部分，线性内插方案比直接外推方案需要的微调步数更少 ，能跟快适应新的位置编码

      refer to Transformer升级之路：10、RoPE是一种β进制编码
      当然，有读者会说外推方案也可以微调。是的，但内插方案微调所需要的步数要少得多，因为很多场景（比如位置编码）下，相对大小（或许说序信息）更加重要

  • 进一步分析，从角度变化的角度看，位置插入的方法也可以理解为如下变化（可以证明两种表示形式完全等价）：
    $$ \theta_i = 10000^{-2i/d} \cdot k^{-1} $$

NTK-aware Scaled RoPE

  • NTK-aware Scaled RoPE 方法最早被 bloc97 提出于博客 NTK-aware Scaled RoPE 中

  • 注：NTK 名称的来源是 Neural Tangent Kernel 的缩写，原始博客中有提到：

    Basically if you apply Neural Tangent Kernel (NTK) theory to this problem, it becomes clear that simply interpolating the RoPE’s fourier space “linearly” is very sub-optimal, as it prevents the network to distinguish the order and positions of tokens that are very close by.

  • Transformer升级之路：10、RoPE是一种β进制编码中给出了编码进制的理解思路

  • 位置内插（线性内插）的问题：常规的位置内插是线性内插，即是通过修改行映射来实现均匀内插，该均匀体现在两个方面：

    • 对每一行（或者说每个位置 \(m\)），放缩相同的比例 \(m \rightarrow \frac{m}{k}\)
    • 对每一列（或者说 Embedding 的每个2维子矩阵 \(i\)），不管高频低频，放缩相同的比例 \(m \rightarrow \frac{m}{k}\)
      • 注：高频对应低维 Embedding 部分，角度旋转多；低频对应高维 Embedding部分，角度旋转少
    • 总结来说：位置内插方法是降低整体分辨率

  • 位置内插会导致高频（Embedding 低维）的旋转值的绝对值发生较大变化（即使是训练范围内的序列长度），这时候可以考虑一种非均匀的插值方法，在训练时见过的长度上，低维（高频）旋转角度变化小，高维（低频）旋转角度变化大（但角度的绝对值变化不大），这个方法就是 NTK-aware Scaled RoPE 方法（更多细节讨论见附录）

    refer to 上下文长度扩展：从RoPE到YARN - barely的文章 - 知乎
    简而言之，PI存在的问题是：根据NTK理论，输入特征中高频分量的分布对模型十分重要 ，而PI的做法导致输入中的高频分量的分布发生了较大的变化，对模型的性能有损害

  • 除了 NTK理论外，RoPE中，高频维度的重要性解释还有：高频维度（短波长）负责编码局部位置的细微差异（如邻近 token 的相对位置）。若直接插值，会压缩这些高频波长，导致模型难以分辨近距离 token 的顺序

  • NTK-aware Scaled RoPE 通过修改 base（原始值为10000）来实现非均匀的内插 ，其核心思路是：高频外推，低频内插（基本理论：从 NTK 理论可知，模型对高频分量的分布敏感，需要尽量保持高频分量不要变化）
    $$
    \begin{align}
    \theta_i &= (10000\cdot k^{d/(d-2)})^{-2i/d} \\
    &= 10000^{-2i/d} \cdot k^{-2i/(d-2)}
    \end{align}
    $$

    • \(k = \frac{L’}{L}\) 是外推比例，一些常见文献中也会使用 \(s = \frac{L’}{L}\) 表示外推比例
    • 以上使用 \(k^{d/(d-2)}\) 的原因是为了保证 \(i=\frac{d}{2}-1\) 时，刚好是 \(k^{-1}\) 用于内插
    • 理解：其实在 \(d\) 较大的情况下，使用 \(k\) 替换 \(k^{d/(d-2)}\) 应该也没什么问题

  • 假设将原始 RoPE 的旋转角度固定为：
    $$ \theta_i^{\text{fix}} = 10000^{-2i/d} $$

  • 则 NTK-aware Scaled RoPE 的角度变化还可以简写为下面的形式
    $$ \theta_i = k^{-2i/(d-2)} \cdot \theta_i^{\text{fix}} $$

  • 此外，在部分博客中，常用 \(D\) 表示模型 Embedding 维度，而用 \(d\) 表示维度索引，此时，公式应该如下：
    $$
    \theta_d^{\text{fix}} = 10000^{-2d/D}\\
    \theta_i = k^{-2d/(D-2)} \cdot \theta_d^{\text{fix}}
    $$

  • 原始博客中还给出了原始实现代码 NTKAwareScaledRotaryEmbedding.ipynb，其中，核心代码只有几行，详情如下（完整代码见附录）：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    from transformers import AutoModelForCausalLM, AutoTokenizer, GenerationConfig
    import torch
    import transformers

    ### NTK-aware Scaled RoPE 核心代码开始
    old_init = transformers.models.llama.modeling_llama.LlamaRotaryEmbedding.__init__
    def ntk_scaled_init(self, dim, max_position_embeddings=2048, base=10000, device=None):
    	#The method is just these three lines
    	max_position_embeddings = 16384
    	a = 8 #Alpha value
    	base = base * a ** (dim / (dim-2)) #Base change formula
    	old_init(self, dim, max_position_embeddings, base, device)
    transformers.models.llama.modeling_llama.LlamaRotaryEmbedding.__init__ = ntk_scaled_init
    ### NTK-aware Scaled RoPE 核心代码完
    ### 其他

  • NTK-aware Scaled RoPE 方法实现了不需要增加微调训练的上下文长度扩展，在Transformer升级之路：10、RoPE是一种β进制编码中给出了以下结论：

    1、直接外推的效果不大行；
    2、内插如果不微调，效果也很差；
    3、NTK-RoPE不微调就取得了非平凡（但有所下降）的外推结果；

NTK-aware Scaled RoPE 的 Dynamic Scaling 改进

ReRoPE

  • 本节内容主要参考自：旋转式位置编码 (RoPE) 知识总结
  • ReRoPE，即 Rectified Rotary Position Embedding，其名称跟 ReLU (Rectified Linear Unit) 中的 Rectified 含义相似
  • ReRoPE的基本思想是，使用分段函数实现对相对位置超过一定长度的旋转进行截断，具体来说有：
    $$
    \mathrm{score}(\boldsymbol{q}_m, \boldsymbol{k}_n)=
    \begin{cases}
    \boldsymbol{q}_m^{\mathrm{T} }\cdot\boldsymbol{R}_{n - m}\cdot\boldsymbol{k}_n & (m - n < w) \\
    \boldsymbol{q}_m^{\mathrm{T} }\cdot\boldsymbol{R}_{-w}\cdot\boldsymbol{k}_n & (m - n \geq w)
    \end{cases}
    $$
    • 其核心思想是：如果 Query 向量 \(\boldsymbol{q}\) 和 Key 向量 \(\boldsymbol{k}\) 的相对位置超过 \(w\)，那么就进行截断，直接将其设置为 \(w\)
  • 进一步地，论文还可以仿照 Leaky ReLU，将向量 \(\boldsymbol{q}\) 和 \(\boldsymbol{k}\) 的相对位置超过 \(w\) 的部分用斜率为 \(\frac{1}{k}\) 的函数进行光滑处理：
    $$
    \mathrm{score}(\boldsymbol{q}_m, \boldsymbol{k}_n)=
    \begin{cases}
    \boldsymbol{q}_m^{\mathrm{T} }\cdot\boldsymbol{R}_{n - m}\cdot\boldsymbol{k}_n & (m - n < w) \\
    \boldsymbol{q}_m^{\mathrm{T} }\cdot\boldsymbol{R}_{-w^*}\cdot\boldsymbol{k}_n & (m - n \geq w)
    \end{cases}
    $$
    • 其中，\(w^*\) 的公式如下：
      $$
      w^* = \frac{m - n - w}{k}+w
      $$
      • 注意这里的 \(k\) 不是之前的序列长度比值了

        不再和序列长度挂钩，只要大于 1，且相对位置都在预训练的范围内即可。苏剑林的实验发现，如果预训练是 512，推理是 4096，\(k\) 的值设置为 16 最好

  • 旋转式位置编码 (RoPE) 知识总结中其他更多表述：
    • 在公式中，\(m - n\) 就是相对位置，\(m - n - w\) 就是除去 \(w\) 后的长度。论文将这种方式称为 Leaky ReRoPE
    • 根据苏剑林大佬的实验，NTK-aware 方案有 5% 的性能下降，而 ReRoPE 的性能下降在 1% 以内 \(w\) 设置成预训练最大长度的一半，而且 ReRoPE 理论上可以处理任意长度，属于比较完美的方案
    • 但是，这个方案有一个很大的问题：推理成本。在 NTK-aware 的方案中，我们可以通过改 \(\theta_i\) 函数来实现长度外推，增加的推理成本几乎可以忽略；但是在 ReRoPE 中，Attention 的运算规则都发生了变化 (分段函数)，此时的推理成本会增加非常多
    • 于是，苏剑林大佬又想到一个办法，在预训练时采用 Leaky RoPE，而在推理时采用原始的 RoPE，不过公式变成：
      $$
      w^* = -(k(m - n - w)+w)
      $$
    • 这样的好处是：Train Short, Test Long。如果预训练的最大长度是 2048，\(k\) 值是 16，那么推理时的最大长度是 \(2048×16 = 32768\)。经过实验，这样做性能下降也是在 1% 以内。如果你有资源重新训练大模型，这会是一个很好的方案。

NTK-by-parts Interpolation

  • NTK-by-parts Interpolation 是 YaRN 作者在 https://github.com/jquesnelle/yarn/pull/1中提出的，YaRN 原始论文中有方案介绍 YaRN: Efficient Context Window Extension of Large Language Models, ICLR 2024,
  • NTK-by-parts Interpolation ，顾名思义，即部分 NTK 插值方法，基于波长局部分段插值
  • 截止目前的外推方法主要面临问题和讨论 ：
    • 背景：前面提到，原始 RoPE 中 Embedding 向量靠前的部分被旋转的次数多（维度 \(i\) 越靠前，对应的角度 \(\theta_i\) 越大，周期越小），只需要很短的序列就能旋转一周，训练很充分；但靠后的部分被旋转次数少，需要训练很长序列才能旋转一周，训练时没见过的旋转角度，如果在推理时出现了，模型难以处理
    • 线性内插 保证了原始旋转角度不变化的情况下扩展长度，理论上保证了不存在直接外推中遇到的Embedding 后半部分旋转角度训练不足问题，但高频部分维度也被修改了（NTK 理论告诉我们高频部分不应该修改）
    • NTK-aware Scaled RoPE 通过非线性的插值，直观上看对高频（低维）做到了几乎不调整 ，对低频（高维）做到了接近线性内插（在最后一维时完全等于线性内插），
    • 问题：NTK-aware Scaled RoPE 真的解决未见过的角度这个问题了吗？答案是没有彻底解决，两边的维度都没问题了（高频部分角度变化够大，早已超过了\(2\pi\)；低频部分做线性内插，不会出现超过角度问题），但依然会有部分中间维度出现超过训练时旋转角度的情况，详细证明见附录：NTK-aware Scaled RoPE 外推分量推导
  • 回顾 NTK-aware Scaled RoPE 修改了 base 从而实现了非线性的插值：
    $$
    \begin{align}
    \theta_i &= (10000\cdot k^{d/(d-2)})^{-2i/d} \\
    &= 10000^{-2i/d} \cdot k^{-2i/(d-2)}
    \end{align}
    $$
    • \(k = \frac{L’}{L}\) 是外推比例，一些常见文献中也会使用 \(s = \frac{L’}{L}\) 表示外推比例
    • 我们将原始 RoPE 的旋转角度固定为：
      $$ \theta_i^{\text{fix}} = 10000^{-2i/d} $$
    • 则 NTK-aware Scaled RoPE 的角度变化还可以简写为下面的形式
      $$ \theta_i = k^{-2i/(d-2)} \cdot \theta_i^{\text{fix}} $$
  • NTK-by-parts Interpolation 的思路：NTK理论告诉我们高频部分不应该进行插值；从分析看低频部分不能直接外推（会导致遇到没见过的旋转角度）
    • NTK-by-parts Interpolation 是根据不同波长分段实现插值，其中波长的定义为
      $$\lambda_i = \frac{2\pi}{\theta_i^{\text{fix}}} = 2\pi \cdot 10000^{2i/d}$$
    • 对波长短（高频）的维度不进行插值（直接外推）；
    • 对波长长（低频）维度进行线性内插（PI）；
    • 对中间维度，以不超过旋转角度的范围内进行插值
  • 具体来说，NTK-by-parts Interpolation 使用下面的公式来实现分段非线性插值：
    $$
    \begin{align}
    \theta_i = (1-\gamma(r_i))\frac{\theta_i^{\text{fix}}}{k} + \gamma(r_i)\theta_i^{\text{fix}}\\
    \end{align}
    $$
    • 其中 \(r_i = \frac{L}{\lambda_i}\) 是序列长度和波长的比值，且：
      $$
      \gamma(r_i) = \gamma(i) =
      \begin{cases}
      1, & \text{if } r_i>\beta \\
      \frac{r_i-\alpha}{\beta - \alpha}, & \text{if } \alpha\leq r_i<\beta \\
      0, & \text{if } r_i<\alpha
      \end{cases}
      $$
  • 公式解读为：不同波长 \(\lambda_i\) 类型维度 \(i\) 的插值策略不同 ，使用序列长度和波长的比值 \(r_i = \frac{L}{\lambda_i}\) 来圈定（\(r_i\) 与波长 \(\lambda_i\) 成反比）
    • 高频维度（\(r_i>\beta\)）：波长短，高频低维，不做任何插值。一方面满足NTK原理要求（模型对高频特征敏感），另一方面这样也能不破坏相邻序列之间的细节关系（局部位置关系）
    • 低频维度（\(r(d)<\alpha\)）：波长长，低频高维，对低频维度进行线性插值，避免角度外推带来的位置混淆
    • 中间维度（\(\alpha\leq r_i<\beta\)）：波长中间，在原始频率和拉伸后的频率之间进行线性插值，插值程度由\(\frac{r_i-\alpha}{\beta - \alpha}\)决定
  • \(\alpha,\beta\) 的设置一般是：

    The values of α and β should be tuned on a case-by-case basis. For example, we have found experimentally that for the Llama family of models, good values for \(\alpha\) and \(\beta\) are \(\alpha=1\) and \(\beta=32\)

YaRN

  • 原始论文：YaRN: Efficient Context Window Extension of Large Language Models
    • YaRN 原始论文中对各种方法有统一介绍和梳理，值得一看
    • 吐槽以下：YaRN 取名很随意（Yet another RoPE extensioN method），且 YaRN 论文里面的符号于之前其他论文（比如原始 Transformer）中不一致，容易造成误解，论文处于一致性考虑，仍使用原始 Transformer 和其他社区常用的符号
    • 注：YaRN 中，用 \(D\) 表示 Embedding 维度（论文用 \(d\)），用 \(d\) 表示维度索引/分量（论文用 \(i\)），用 \(s\) 表示外推比例（论文用 \(k\)）
  • YaRN = NTK-by-parts Interpolation + attention-scaling ，也就是说，YaRN 是基于 NTK-by-parts Interpolation 的，在此基础上还加入了 预 Softmax 缩放机制（也称为 attention-scaling 机制）：
    $$ \text{softmax}\left(\frac{\boldsymbol{q}_m^\top \boldsymbol{k}_n}{t\sqrt{d}}\right) \\
    \sqrt{\frac{1}{t}} = 0.1\ln(k) + 1
    $$
    • \(k = \frac{L’}{L}\) 是外推比例
  • 关于温度系数 \(t\) 的理解：
    • 温度系数越大，注意力分布越平均
    • 温度系数越小，注意力分布越集中
    • \(\sqrt{\frac{1}{t}} = 0.1\ln(k) + 1\) 是通过大量的实验验证出来的，这里可以看出扩展长度越长（\(k\) 越大），需要的温度系数就越小，即此时需要让注意力分布更集中
    • 直观上理解，该定义下，当 \(k > e\) 时，\(\sqrt{\frac{1}{t}} = 0.1\ln(k) + 1 > 1\)，此时有 \(t < 1\)，也就是说，attention-scaling 机制 是在通过温度系数 \(t\)，使得 Softmax 注意力更集中
      • 注：一些博客中的解释是用于缓解锐化，促进平均，在 \(k > e\) 时，这个观点是错误的（现实中扩展往往是4倍以上）
    • 实现时，可以通过将 Embedding 缩放为原来的 \(\frac{1}{\sqrt{t}}\) 来实现 attention-scaling 机制
  • YaRN 的优点总结：
    • 仅需要少量微调即可
    • 性能由于其他扩展方法
  • 注：YaRN 已经是 LLMs 领域的标配技术， DeepSeek R1 用于 YaRN 技术从 DeepSeek-V3-Base (4K上下文) 扩展到 128K 上下文使用的技术，通过两阶段扩展（4K -> 32K -> 128K）完成上下文长度扩展
问题：为什么扩展长度越长，需要的温度系数越小呢？
  • 参考1：YaRN 原始论文3.4节简单提到这个问题，附录A.2中有实验支撑，但没有非常理论的证明
  • 参考2：

    refer to 【LLM理论系列】LLM上下文长度扩展：YaRN - LLMCat的文章 - 知乎
    较小的 \(t\) 值会使注意力分布更加”尖锐”，增强模型对长距离依赖的捕捉能力
    较大的 \(t\) 值则会使注意力分布更加”平滑”，有助于保持模型的稳定性

  • 个人理解：
    • 这里温度系数是为了中高频率维度考虑：一方面，高频维度负责编码局部位置的细微差异，不能插值，会导致模型难以分辨近距离 token 的顺序；实际上，在序列扩展特别长时，中高频被插值影响太大了，对模型效果也有损（模型难以区分中远距离的 token 顺序）
    • NTK-aware Scaled RoPE 中对高频做了较小的插值；
    • NTK-by-parts Interpolation 对超高频不插值，中高的频率维度做较小插值，低频做线性插值
    • NTK-by-parts Interpolation 不对超高频插值，彻底解决了超高频问题，但是中间频率问题没有解决，且随着扩展长度增加，中间频率被放缩的越多
    • 中频维度负责编码中远距离位置的细微差异，此时需要使用更小的温度系数，让 Attention 更关注中远距离的 token（注：因为 RoPE 的Attention 权重有远程衰减特性，固更小的温度系数会将注意力更集中到更近的距离）

LongRoPE

  • Microsoft Research原始论文：LongRoPE: Extending LLM Context Window Beyond 2 Million Tokens - arXiv 2024
  • 微软亚研知乎：LongRoPE：超越极限，将大模型上下文窗口扩展超过200万tokens
  • 其相对RoPE的改进点有:

    refer to LongRoPE：超越极限，将大模型上下文窗口扩展超过200万tokens

    • 精细化非均匀位置插值 ：目前的大模型通常采用 RoPE 旋转位置编码，对 RoPE 位置编码进行插值是解决上述挑战中第一个问题的一种常见方法。这种方法将新位置索引缩小到预训练范围内。在已有的相关工作中，位置插值（position interpolation，PI）会通过扩展比例来线性插值 RoPE 的旋转角度。NTK-aware 位置编码插值方法提出，利用公式对每个RoPE维度进行经验性重新缩放，YaRN 会将 RoPE 维度分成三组，并分别针对三组 RoPE 维度进行不同的缩放（即直接外推，NTK-aware 插值和线性插值）。然而，这些方法主要基于启发式经验插值，未充分利用 RoPE 中的复杂非均匀性，导致关键信息在位置编码插值后丢失，从而限制了上下文窗口的大小。研究员们经过实验发现，有效的位置编码插值应考虑两种非均匀性：不同的 RoPE 维度和 token 位置。低维 RoPE 和初始 token 位置存储着关键信息，因此需要进行更少程度的插值。相比之下，高维 RoPE 存储的信息相对较为稀疏，可进行较大程度的插值。为了充分利用这些非均匀性，研究员们提出了一种基于进化算法的方法，允许搜索 RoPE 每个维度以及不同 token 位置的旋转角度缩放因子，有效地保留了原始 RoPE 位置编码中的信息。这种方法最大程度地减小了位置插值引起的信息损失，从而为微调提供了更好的初始化。此外，这种方法还允许在不微调的情况下实现8倍的扩展
    • 渐进式扩展策略 ：在非均匀位置编码插值的基础上，LongRoPE 采取了高效的渐进式扩展策略，从而在无需直接对极长文本进行微调的情况下，有效实现了2048k上下文窗口的目标。具体策略如下：首先在预训练的大模型上搜索256k上下文窗口对应的位置编码插值方案，并在此长度下进行微调。其次，由于 LongRoPE 的非均匀插值允许在不微调的情况下进行8倍扩展，所以研究员们对已扩展的微调后的大模型进行了二次非均匀插值搜索，最终达到了2048k上下文窗口
    • 调整LongRoPE以恢复短上下文窗口性能 ：在将上下文窗口扩展到极长的2048k后，研究员们注意到原始上下文窗口内的性能出现了下降。这是位置插值的一个已知问题，因为它导致原始上下文窗口内的位置被压缩在更窄的区域内，从而对大模型的性能产生了负面影响。为了解决这一问题，研究员们在扩展后的大模型上对8k长度内的 RoPE 缩放因子进行了重新搜索，旨在引导在较短长度上进行较少的位置插值，来恢复短上下文窗口的性能。在推理过程中，大模型可根据输入长度动态调整相应的 RoPE 缩放因子

RoPE ABF

  • 参考链接： Effective Long-Context Scaling of Foundation Models, arXiv preprint 2023, GenAI, Meta
  • RoPE ABF（RoPE with Adjusted Base Frequency）的核心改进是：通过调整基础频率降低远距离 Token 的衰减效应
  • 传统RoPE位置编码 ：通过旋转向量实现位置信息嵌入，其核心公式为：
    $$
    f^{\text{RoPE}}(x, t)_j = (x_{2j} + ix_{2j+1}) e^{i b^{-\frac{2j}{d}} t}
    $$
    • 其中，\(b\) 为基础频率（默认值为10,000），\(d\) 为模型维度，\(t\) 为Token位置，\(j\) 为维度索引
    • RoPE的衰减问题源于旋转角度随位置 \(t\) 增大而快速变化，导致远距离Token的注意力分数显著下降
  • RoPE ABF的改进 ：通过增大基础频率 \(b\)（如从10,000调整为500,000），减少旋转角度，从而降低远距离Token的衰减。调整后的公式为：
    $$
    f^{\text{RoPE ABF}}(x, t)_j = (x_{2j} + ix_{2j+1}) e^{i (\beta b)^{-\frac{2j}{d}} t}
    $$
    • 其中，\(\beta\)为缩放因子（文中取\(\beta = 50\)），通过增大\(\beta b\)，使得位置编码对远距离Token的区分度更高，衰减更平缓
  • RoPE ABF方法 和 NTK-aware Scaled RoPE 方法基本一致，两者都是对频率（原始值为10000）进行调整
    • NTK-aware Scaled RoPE 方法是动态（根据需要外推的倍数进行调整）；RoPE ABF 方法是固定调整（比如论文第四节提到直接从 10000 变成 500000）
    • NTK-aware Scaled RoPE 方法更偏向于无需继续微调训练；RoPE ABF 方法更倾向于需要继续微调训练
  • 注：这篇文章发表晚于 NTK-aware Scaled RoPE 方法的提出，但并没有和 NTK-aware Scaled RoPE 方法作比较（其实就是同一个，甚至不如 NTK-aware Scaled RoPE 方法精巧）

    We propose a simple modification to the default RoPE encoding to reduce the decaying effect – increasing the “base frequency b” of ROPE from 10,000 to 500,000, which essentially reduces the rotation angles of each dimension. The idea is also concurrently suggested in the Reddit r/LocalLLaMa community and Rozière et al. (2023).

DCA

  • 参考链接 Training-Free Long-Context Scaling of Large Language Models
  • 双块注意力（Dual Chunk Attention, DCA）是一种无需训练的大语言模型长上下文扩展框架
  • DCA 通过将长序列的注意力计算分解为块内（Intra-Chunk）、块间（Inter-Chunk）和连续块（Successive-Chunk）三种注意力机制，有效捕捉短程和长程依赖关系
  • DCA 可保证位置编码不会超过预训练 ：通过重新设计相对位置矩阵 \( M \) 反映 tokens 间的真实相对位置，避免传统方法（如位置插值PI、NTK）对引入未见过的位置信息
  • 保留预训练的位置编码，每个块的大小 \( s \) 小于模型预训练长度 \( c \)，确保块内相对位置不超过预训练范围的降维损失
  • DCA 可同时与 Flash Attention 结合实现高效计算
  • 实验表明 DCA 在长上下文中的表现显著优于传统位置插值方法，如 PI 和 NTK-aware Scored RoPE
  • 更多详情参考：NLP——LLM位置编码-DCA

其他与上下文扩展相关的优化

Attention-E
  • 在中提到使用下面的Attention变体称为“Attention-E”（Entropy Invariance）有利于上下文泛化（外推）：
    $$ \begin{equation}Attention(Q,K,V) = softmax\left(\frac{\log_{512} {n}}{\sqrt{d}}QK^{\top}\right)V\end{equation} $$
    • 其中 \(n\) 为最大序列长度，外推到多大，这里的 \(n\) 就取对应的值（注意：训练训练长度是固定的，此时 \(n\) 是也固定的）
    • 以 \(512\) 为底主要是作者提出这个方案前，大部分模型训练最大长度都是 \(512\)，作者想在 \(n=512\) 时退化到原始 Attention
    • 注：这 Attention-E 实现下，在不外推时，效果其实不如原始的 Attention；外推时效果则相对原始的 Attention 较好

各种编码方式总结

  • 参考链接
  • 固定位置编码和正弦位置编码（Sinusoidal）都是绝对位置编码
  • RoPE是旋转位置编码，实际上是在 \(\boldsymbol{q},\boldsymbol{k}\) 做内积前将他们旋转，可以证明，RoPE算是相对位置编码，仅仅与他们的相对位置有关
  • T5 Bias是带偏置的Attention，其偏置项是可学习的
  • ALiBi是带偏置的Attention，实际上是在 \(\boldsymbol{q},\boldsymbol{k}\) 做内积后在他们的内积上加一个负偏置，相对位置越远，偏置越大，本质上是相对位置编码
  • ALiBi论文中跟各种方法，特别是 Sinusoidal 进行了比较，在固定长度的短序列（1024,2048）训练下，ALiBi 和 Sinusoidal 的性能及效果都差不多，但是外推性上，ALiBi 好很多
  • LongRoPE是RoPE的改进版本，采用插值+微调来实现长文本，目前最长可扩展到200W+（2048k）上下文窗口
  • AliBi和LongRoPE都有很强的外推性，都适合长文本

附录：推理速度讨论

  • 下面是 ALiBi 原始论文 ALiBi 的实验结论：
  • RoPE 需要的存储更多是因为需要存储更大的位置编码矩阵（即使进存储简化后的矩阵，不同位置也需要分别存储）
  • 存储消耗：RoPE > T5 Bias > ALiBi > Sinusoidal
  • 训练速度：Sinusoidal ~ ALiBi > RoPE > T5 Bias
  • 推理退镀：Sinusoidal ~ ALiBi > RoPE > T5 Bias

附录：为什么ALiBi不如RoPE流行

  • 问题：为什么 RoPE 在训练/推理效率、存储消耗、外推性等方面都不如 AliBi，RoPE 却是当前开源大模型主流的位置编码方案（截止到25年）?
  • 有以下原因：
    • RoPE 训练更稳定：RoPE 对注意力分布的影响更平滑，适合大规模预训练
    • RoPE 生态兼容性：主流推理框架（如 vLLM、Ollama）对 RoPE 支持更好，RoPE 与 FlashAttention、vLLM 等优化库兼容，相比 ALiBi 在混合精度训练（如 bfloat16）下更稳定

附录：NTK-aware Scaled RoPE详细代码示例

  • 原始实现代码 NTKAwareScaledRotaryEmbedding.ipynb： 
    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
    41
    42
    43
    44
    45
    46
    47
    48
    from transformers import AutoModelForCausalLM, AutoTokenizer, GenerationConfig
    import torch
    import transformers

    ### NTK-aware Scaled RoPE 核心代码开始
    old_init = transformers.models.llama.modeling_llama.LlamaRotaryEmbedding.__init__
    def ntk_scaled_init(self, dim, max_position_embeddings=2048, base=10000, device=None):
    	#The method is just these three lines
    	max_position_embeddings = 16384
    	a = 8 #Alpha value
    	base = base * a ** (dim / (dim-2)) #Base change formula
    	old_init(self, dim, max_position_embeddings, base, device)
    transformers.models.llama.modeling_llama.LlamaRotaryEmbedding.__init__ = ntk_scaled_init
    ### NTK-aware Scaled RoPE 核心代码完

    model_path = "TheBloke/OpenAssistant-SFT-7-Llama-30B-HF"
    tokenizer = AutoTokenizer.from_pretrained(model_path)
    model = AutoModelForCausalLM.from_pretrained(model_path, torch_dtype=torch.float16, device_map="auto")
    generation_config = GenerationConfig(
    	temperature=0.0,
    	top_k=20,
    	repetition_penalty=1.2,
    )
    print("Prompt token length:", len(tokenizer(prompt, return_tensors="pt")["input_ids"][0]))
    def print_predict(prompt):
    	prompt = "<|prompter|>" + prompt + "</s><|assistant|>"
    	encoding = tokenizer(prompt, return_tensors="pt")
    	input_ids = encoding["input_ids"].to("cuda")

    	with torch.inference_mode():
    		result = model.generate(
    			input_ids=input_ids,
    			generation_config=generation_config,
    			return_dict_in_generate=False,
    			output_scores=False,
    			max_new_tokens=512,
    		)

    	decoded_output = tokenizer.decode(result[0][len(input_ids[0]):])
    	print(decoded_output)
    prompt_question = prompt + "\nPlease give me a brief summary of this research paper in a few bullet points."
    print_predict(prompt_question)
    prompt_question = prompt + "\nPlease write me the abstract for this paper."
    print_predict(prompt_question)
    prompt_question = prompt + "\nHow many steps was the model fine tuned for the final results? Give a short answer."
    print_predict(prompt_question)
    prompt_question = prompt + "\nHow big is the interpolation bound compared to the extrapolation bound? Give a short answer."
    print_predict(prompt_question)

附录：不同插值方法的可视化比较

  • d_model=32，序列长度为10下的不同外推方法旋转角度 \(\theta\) 可视化如下（图中每个节点）：
  • 上图的解读如下：
    • 图中第一行、第二行分别为 k=2 和 k=4 的外推场景
    • 每一行从左到右依次是 直接外推方法、位置插值法（PI）、NTK-aware Scaled RoPE 三种方法下的角度变化
    • 每个小图中，横轴是维度 \(i \in [0,15]\)，纵轴是位置 \(m \in [0,9]\)
    • 为了方便，论文画出的每个图 \(m\) 范围是一样的
      • 以第一行为例，可以理解为训练长度是 5，泛化长度是 10，也就是说第一行的图中，泛化出来的是 \(m \in [5,9]\)
      • 以第二行为例，可以理解为训练长度是 2，泛化长度是 8，也就是说第一行的图中，泛化出来的是 \(m \in [2,7]\) （多余两个行忽略即可）
    • 显然，对第一行，若只观察未泛化的位置 \(m \in [0,4]\) 的情况，可以做如下分析：
      • 直接外推法不影响原始训练长度内（\(m \in [0,4]\)）的旋转角度；
      • 位置内插方法低维和高维的值都发生了较大改变，特别是低维的范围变化绝对值太大；
      • NTK-aware Scaled RoPE 方法则几乎不改变低维上的旋转角度范围（和直接外推法基本一样），高维的角度有变化，但是因为绝对值不大而管差不出来
  • RoPE中，高频对应低维 Embedding 部分，角度旋转多；低频对应高维 Embedding部分，角度旋转少：
    • 位置内插会导致高频（Embedding 低维）的旋转值的绝对值发生较大变化（即使是训练范围内的序列长度）
    • NTK-aware Scaled RoPE是一种非均匀的插值方法，在训练时见过的长度上，低维（高频）旋转角度变化小，高维（低频）旋转角度变化大（但角度的绝对值变化不大）
    • 注：高频维度（短波长）负责编码局部位置的细微差异（如邻近 token 的相对位置）。若直接插值，会压缩这些高频波长，导致模型难以分辨近距离 token 的顺序
  • 补充，上述图像生成的代码如下： >>>点击展开折叠内容... 
    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
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    import numpy as np
    import matplotlib.pyplot as plt

    # Original（直接外推法）
    def theta_1(i, m, d_model=128):
    	return m / (10000 ** (2 * i / d_model))

    # Position Interpolation
    def theta_2(i, m, d_model=128):
    	return (m / 2) / (10000 ** (2 * i / d_model))

    # NTK-aware Scaled RoPE
    def theta_3(i, m, d_model=128):
    	denominator_base = 10000 * (2 ** (d_model / (d_model - 2)))
    	return m / (denominator_base ** (2 * i / d_model))

    d_model = 32
    seq_len = 10
    i_values = np.arange(0, d_model // 2, 1)
    m_values = np.arange(0, seq_len, 1)

    matrix_1 = np.zeros((len(m_values), len(i_values)))
    matrix_2 = np.zeros((len(m_values), len(i_values)))
    matrix_3 = np.zeros((len(m_values), len(i_values)))

    for idx_m, m in enumerate(m_values):
    	for idx_i, i in enumerate(i_values):
    		matrix_1[idx_m, idx_i] = theta_1(i, m)
    		matrix_2[idx_m, idx_i] = theta_2(i, m)
    		matrix_3[idx_m, idx_i] = theta_3(i, m)

    # 确定统一的颜色标尺
    vmin = min(matrix_1.min(), matrix_2.min(), matrix_3.min())
    vmax = max(matrix_1.max(), matrix_2.max(), matrix_3.max())

    plt.rcParams['figure.dpi'] = 300
    fig, axes = plt.subplots(1, 3, figsize=(12, 3))

    im1 = axes[0].imshow(matrix_1, origin='lower', aspect='auto', cmap='viridis', vmin=vmin, vmax=vmax)
    axes[0].set_title(r'$\theta^1_{i,m} = \frac{m}{10000^{2i/d_{model}}}$')
    axes[0].set_xlabel('i')
    axes[0].set_ylabel('m')
    fig.colorbar(im1, ax=axes[0])

    im2 = axes[1].imshow(matrix_2, origin='lower', aspect='auto', cmap='viridis', vmin=vmin, vmax=vmax)
    axes[1].set_title(r'$\theta^2_{i,m} = \frac{m/2}{10000^{2i/d_{model}}}$')
    axes[1].set_xlabel('i')
    axes[1].set_ylabel('m')
    fig.colorbar(im2, ax=axes[1])

    im3 = axes[2].imshow(matrix_3, origin='lower', aspect='auto', cmap='viridis', vmin=vmin, vmax=vmax)
    axes[2].set_title(r'$\theta^3_{i,m} = \frac{m}{(10000*(2^{d_{model}/(d_{model}-2)}))^{2i/d_{model}}}$')
    axes[2].set_xlabel('i')
    axes[2].set_ylabel('m')
    fig.colorbar(im3, ax=axes[2])

    plt.tight_layout()
    plt.savefig("./demo.png")
    plt.show()

附录：NTK-aware Scaled RoPE 外推分量推导

注：本文包含 AI 辅助创作

Paper Summary

  • 整体总结：
    • HybridFlow 是一个 RLHF 混合编程模型框架，能够灵活表示和高效执行各种 RLHF 算法，是 VeRL 的理论介绍
    • 通过将不同 LLM 的分布式计算封装到原始 API 中，并隐藏节点间数据重分片的复杂性，允许用户用几行代码轻松构建 RLHF 数据流
    • 论文的 3D-HybridEngine 确保了 actor 模型训练和生成的高效执行，实现了模型参数重分片的零内存冗余和显著降低的通信开销
    • 论文有效的映射算法优化了 RLHF 数据流中模型的 GPU 分配和放置
    • 大量实验表明，在各种模型大小和集群规模下，与 SOTA RLHF 系统相比，HybridFlow 实现了 \(1.53\times\) 到 \(20.57\times\) 的加速比
    • HybridFlow 的代码已经开源（verl库）
  • 思路介绍：
    • 传统的 RL 可以建模为一个数据流
      • 流中每个节点代表神经网络的计算，每条边表示神经网络（NN）之间的数据依赖关系
    • RLHF 中的数据流很复杂
      • 因为 RLHF 将每个节点扩展为分布式 LLM 训练或生成程序，并将每条边扩展为多对多组播（multicast）
    • 传统的 RL 框架使用单一控制器来执行数据流，该控制器同时指导节点内计算和节点间通信’
      • 在 RLHF 中，分布式节点内计算的控制调度开销较大，这种方式效率较低
    • 现有的 RLHF 系统采用多控制器范式，但由于分布式计算和数据通信的嵌套，这种范式可能不够灵活
  • 论文解决方案： HybridFlow
    • HybridFlow 以混合方式结合了单控制器和多控制器范式 ，以实现 RLHF 数据流的灵活表示和高效执行
  • 论文精心设计了一套分层 API
    • 这些 API 解耦并封装了复杂 RLHF 数据流中的计算和数据依赖关系
    • 支持高效的操作编排以实现 RLHF 算法
    • 能将计算灵活映射到各种设备上
  • 论文还设计了 3D-HybridEngine，用于在训练和生成阶段之间高效地对 actor 模型进行重分片，实现了零内存冗余并显著降低了通信开销
  • 实验结果表明，与 SOTA 基线相比，使用 HybridFlow 运行各种 RLHF 算法时，吞吐量提升了 \(1.53\times \sim 20.57\times\)

Introduction and Discussion

  • LLMs 已经彻底改变了各种 AI 应用，涵盖写作（2023）、搜索（2021）到编程（2023）等多个领域
  • LLMs 经过了先经历了两个阶段：
    • 大规模数据集上 NTP 预训练
    • 在特定领域数据集上 SFT 训练 LLMs，使其能够遵循人类指令（2020）
  • 两个阶段后，效果不错，但训练数据集中的有害和有偏见的内容可能仍然会误导 LLM 生成有毒和不受欢迎的内容
  • RLHF 进一步将 LLM 与人类价值观对齐，从而构建有用且无害的 AI 应用（2022；2022）
  • RLHF 基于传统的 RL 算法（2011；2017；1992），例如 PPO（2017）和 REINFORCE 算法（1992）
  • 被广泛采用的基于 PPO 的 RLHF 系统通常包含四个 LLM（2022；2022）：
    • 一个 actor
    • 一个 critic
    • 一个参考策略网络（reference policy network）
    • 一个奖励模型（reward model）
  • 基于 PPO 的 RLHF 以迭代方式进行，每个迭代包含三个阶段：
    • （1）使用 actor 模型根据一批 Prompt 生成响应；
    • （2）通过 critic、参考策略和奖励模型的单次前向传播对生成的响应进行评分，从而准备训练数据；
    • （3）通过前向和反向计算更新 actor 和 critic，以从人类偏好中学习
  • 其他 RLHF 变体（2024；2023）遵循类似的阶段，但涉及不同数量的模型以及模型之间不同的数据依赖关系
  • 传统 RL 可以建模为一个数据流（2021），它是一个有向无环图（directed acyclic graph, DAG）：
    • RL 数据流中的每个节点代表神经网络的计算（例如，actor 或critic网络，可能是 CNN 或 MLP）；
    • RL 数据流中的每条边表示神经网络计算之间的数据依赖关系（例如，critic 的输出被用作 actor 训练的输入（2017））
  • RLHF 数据流更为复杂，涉及更复杂的模型（例如，用于 actor/critic/参考/奖励模型 的 LLMs），每个模型运行不同的计算，并且它们之间的数据依赖关系更加多样化（即，分布式模型分区之间的组播）
  • RLHF 数据流中 LLM 的训练和生成需要分布式计算（例如，使用张量/管道/数据并行）（2023；2019）
    • 因此，RLHF 数据流中的每个节点都是一个复杂的分布式程序，对应于相应 LLM 的分布式计算
    • 由于工作负载不同，不同节点中的模型通常使用不同的并行策略
    • 边表示数据重分片，这通常是一种多对多组播
    • 因此，对复杂且资源密集的 RLHF 进行灵活表示和高效执行至关重要
  • 传统 RL 框架，如 RLLib（2018）和 RLLib Flow（2021），采用分层单控制器范式来运行 RL 数据流
    • 一个集中式控制器将数据流中的节点分配给不同的进程，并协调它们的执行顺序
    • 每个节点进程可以进一步生成更多的工作进程来执行计算，这同样遵循单控制器范式
    • 然而，它们仅提供数据并行训练的原语，并且仅限于大小最多为数百 MB 的神经网络（2018；2021）
  • 在 RLHF 数据流中，每个节点对应一个具有多达数十亿个算子的 LLM，这些算子使用一些复杂的并行方式进行计算
    • 将算子调度到分布式加速器的开销大，单控制器范式效率低下（2016；2022）
  • 现有的 RLHF 系统采用多控制器范式来管理节点内计算和节点间数据重分片（2024；2023；2023）
    • 每个控制器独立管理一个设备的计算，并使用多个点对点操作来协调不同节点之间的数据依赖关系
    • 这种多控制器范式在执行 LLM 计算时引入的调度开销可忽略不计（详见第2.2节）
    • 但由于缺乏中央控制，实现各种 RLHF 数据流缺乏灵活性，因为修改单个节点以适应不同的数据依赖关系需要更改所有依赖节点的实现 ，这阻碍了代码重用
  • 为了解决这些局限性，论文提出了一个灵活高效的 RLHF 框架 HybridFlow
    • HybridFlow 能够轻松表示和执行各种 RLHF 数据流，并实现高吞吐量
  • 论文的核心发现是
    • 在节点间层面（inter-node level）使用单控制器范式（single-controller paradigm）能够以最小的开销灵活表达各种数据依赖关系并轻松协调节点间数据重分片
    • 在节点内计算（intra-node computation）中集成多控制器范式（multi-controller paradigm）则能显著提高计算效率
  • 论文提出一种分层混合编程模型来生成 RLHF 数据流
    • 在节点层面，提供了多个模型类，这些类将数据流中不同 LLM 的分布式计算（训练、推理和生成）封装到原语 API 中
      • 这些 API 可以无缝支持现有 LLM 框架中的各种并行策略，包括 3D 并行（2019）、ZeRO（2020）和 PyTorch FSDP（2019），并在多控制器范式下执行分布式计算
    • 在节点之间，设计了一套传输协议，在单控制器的协调下，向用户隐藏数据重分片的复杂性
  • 这种编程模型抽象了分布式计算的复杂性，允许用户用几行代码实现 RLHF 数据流，并通过单控制器的单个进程运行 RLHF
    • 还有效地解耦了节点内计算和节点间数据传输，允许在不更改数据流中其他模型代码的情况下独立优化每个模型
  • actor 模型的训练和生成是 RLHF 数据流中的主要计算
    • 论文进一步设计了 3D-HybridEngine ，以实现 actor 模型训练和生成的高效执行
    • 在训练和生成阶段之间的模型参数重分片过程中实现零内存冗余并显著降低通信开销
  • 论文的混合编程模型还支持将模型灵活放置在相同或不同的 GPU 设备集上
    • 这能够提供一种有效的算法，针对任何 RLHF 数据流，优化具有不同模型大小和不同工作负载的模型的 GPU 分配和放置
  • 论文在设计 HybridFlow 时的贡献总结如下：
    • 论文提出了一种分层混合编程模型 ，用于方便地构建 RLHF 数据流
      • 这种编程模型支持各种 RLHF 算法的节点内计算的高效分布式执行，以及灵活的节点间数据重分片和传输（第4节）
    • 论文设计了 3D-HybridEngine ，它能高效执行 actor 模型的训练和生成 ，并在训练阶段和生成阶段之间实现零冗余过渡（第5节）
    • 论文设计了一种有效的映射算法 ，用于自动确定 RLHF 数据流中每个节点（模型）的优化 GPU 分配和放置（第6节）
    • 论文进行了大量实验，在各种 RLHF 算法、模型大小和集群规模下，将 HybridFlow 与 SOTA RLHF 系统（2024；2023；2023）进行比较
      • 实验表明，HybridFlow 吞吐量提升了 \(1.53\times \sim 20.57\times\)

Background and Motivation

Reinforcement Learning from Human Feedback

RLHF Workflow
  • RLHF 使用一组人类排序的给定 Prompt 候选集，将 LLM 的语言空间与人类价值观对齐（2022；2024；2023；）
  • 一个 RLHF 系统通常包含多个模型，例如一个 actor、一个 critic、一个参考策略（reference policy）和一个或多个奖励模型（reward model）
    • actor 和参考策略各自是经过预训练/微调的 LLM（即正在接受 RLHF 训练的 LLM）
    • critic 和奖励模型可以是在人类偏好数据集上微调的不同 LLM
      • 其语言建模头被替换为标量输出头（2022；2022）
  • RLHF 工作流程可分解为 3 个阶段（图 1），论文以 PPO 为例：
    • 阶段 1（生成，Generation）：actor 通过自回归生成（auto-regressive generation）根据一批 Prompt 生成响应
    • 阶段 2（准备，Preparation）：利用 Prompt 和生成的响应，critic 计算它们的价值（2015；2017），参考策略计算它们的参考对数概率，奖励模型计算它们的奖励（2022；2022），所有这些都通过各自模型的单次前向传播（forward pass）完成
    • 阶段 3（学习/训练，Learning/Training）：使用前一阶段产生的批量数据和损失函数（2022），通过 Adam 优化器（2017）更新 actor 和 critic
  • 其他 RLHF 算法在很大程度上也遵循这 3 阶段工作流程（图 1（b）（c））
    • Safe-RLHF（2024）引入了一个辅助预训练损失，遵循 PPO-ptx（2022），并包含一个额外的成本模型（cost model），以同时拟合人类偏好和安全标签
    • ReMax（2023）需要额外的生成过程来减少方差，并在数据流中移除了 critic 模型
  • 研究人员正在积极探索新的 RLHF 算法（2023；2024；2023），并将传统 RL 方法集成到 RLHF 领域（2023）
  • 这些差异使得需要灵活表示 RLHF 数据流图，以适应不同的算法需求
Parallelism Strategies
  • LLM 的训练和服务采用数据并行、管道并行和张量并行（2024；2023；2021）
  • 在数据并行（data parallelism, DP）中
    • 输入数据被分割为多个子集；每个子集由一个独立的设备（例如 GPU）处理（2018）
    • ZeRO（2020）是一种内存优化的数据并行训练方案，通过在 GPU 间逐步分片优化器状态、梯度和模型参数
  • 管道并行（pipeline parallelism, PP）（2019；2019）和张量并行（tensor parallelism, TP）（2019）将模型参数、梯度和优化器状态分布到多个 GPU 上
    • 现代分布式训练框架如 Megatron-LM（2019）和 MegaScale（2024）采用 3D 并行或 PTD 并行（2021），其中 P、T、D 分别代表管道并行（PP）、张量并行（TP）和数据并行（DP）
      • 在 3D 并行中，PP 大小表示模型训练中的管道阶段数，TP 大小指张量被分割成的分片数，DP 大小是模型副本数
      • LLM 服务系统采用与训练类似的 3D 并行，但仅对模型参数和 KVCache 进行分片（2023；2024；2023）
  • RLHF 数据流中的 LLM 可能执行不同的计算，包括训练（一次前向传播、一次反向传播和模型更新）、推理（一次前向传播）和生成（多次前向传播的自回归生成）
  • 具体来说，actor 模型执行训练和生成，critic 执行训练和推理，参考策略和奖励模型执行推理
  • 可以对不同模型的不同计算采用不同的并行策略，以实现最优吞吐量

Programming Model for Distributed ML

Single-Controller
  • 单控制器采用集中式控制器来管理分布式程序的整体执行流程
  • 通过集中式控制逻辑，用户可以将数据流的核心功能构建为单个进程（图 2（b）），而控制器会自动生成分布式工作进程来执行计算
  • 凭借对硬件和数据流图的全局视图，单控制器范式允许在数据流任务之间进行灵活且优化的资源映射和执行顺序协调
  • 但当在大型集群上执行庞大的数据流图时，控制器向所有工作进程传递协调消息会导致显著的调度开销（2016；2022）
Multi-Controller
  • 多控制器设计中，每个设备（即工作进程）都有自己的控制器
  • SOTA 分布式 LLM 训练和服务系统采用多控制器范式，因为它具有可扩展性和低调度开销
    • 控制消息主要通过快速 PCIe 链路从 CPU 传递到 GPU（2024；2023；2020；2019）
  • 如图 2（a）中采用多控制器 RLHF 实现的示例所示
    • 每个模型运行一个单独的程序
    • 一个模型的所有工作进程执行相同的程序
  • 每个工作进程仅拥有系统状态的局部视图，并且需要两个模型之间的点对点通信（蓝色代码和箭头）来协调模型执行顺序
  • 要在多控制器架构中实现 RLHF 工作流程，用户必须在每个设备上运行的程序中复杂地集成集体通信、计算和点对点数据传输的代码
    • 这导致计算和数据传输的代码深度嵌套，难以开发、维护和优化
  • 在图 2（a）中，每个模型执行本地计算和 all_gather 操作（黑色代码），而 actor 模型必须显式管理向 critic 和奖励模型的发送操作，后者必须在其程序的精确点相应地实现接收操作

RLHF Characteristics

Heterogeneous model workloads（异构模型工作负载）
  • RLHF 中的 actor、critic、参考和奖励模型可能在不同阶段执行训练、推理或生成，具有不同的内存占用（memory footprint）和计算需求
  • 对于参考策略和奖励模型，由于它们仅执行前向传播计算，只需将模型参数存储在 GPU 内存中
  • 对于 actor 和 critic，由于它们要进行模型训练，必须存储模型参数、梯度和优化器状态
  • 此外，在 RLHF 中，一个小的 actor 模型（例如 7B 参数的预训练/微调 LLM）可以与更大的 critic 和奖励模型（例如 70B 参数的 LLM）配对，以实现更好的对齐（2022）
    • 鉴于这种异构性，在 RLHF 运行期间，每个模型需要不同的并行策略和定制优化
Unbalanced computation between actor training and generation
  • 在 RLHF 数据流中，actor 模型的训练和生成由两个节点表示（图 1），这两个节点通常占每个 RLHF 迭代的大部分工作负载（例如，使用 HybridFlow 时占总 RLHF 时间的 58.9%）
  • actor 训练是计算密集型的（2021），通常需要更大的模型并行（model-parallel, MP）大小（即分割后的模型分区数），将工作负载分配到更多 GPU 上
    • 例如 8 个 GPU 上的 7B 参数模型的 8 个分区
  • 对 生成（generation） 使用相同的并行策略（例如相同的 MP 大小）可能会由于其内存密集型特性（2023）而导致 GPU 计算资源利用率不足
    • 先前的研究表明，结合更大的 DP 大小和更小的 MP 大小（混合数据和模型并行）
      • 例如将 7B 参数模型分割为两个部分并在 8 个 GPU 上复制四次，可以提高生成吞吐量（2023；2024）
  • 尽管对 actor 训练和生成使用不同的并行策略可能优化两个阶段的吞吐量 ，但在运行时两个阶段之间对 actor 模型权重进行重分片可能会产生显著的通信和内存开销
    • 例如，对齐一个 70B 参数的 actor 模型需要在每个 RLHF 迭代中从训练阶段向生成阶段传输 140GB 的模型权重，当两个阶段在不同设备上时，这可能占用迭代时间的 36.4%（2023）
Diverse model placement requirements
  • 根据模型的计算工作负载和数据依赖关系，需要对 RLHF 数据流中的模型进行策略性的设备放置
  • 图 3 给出了一个模型放置计划和相应的 RLHF 执行流程示例
    • 放置在不同设备集上的模型如果没有数据依赖关系，可以并行执行
    • 放置在同一组 GPU 上的模型（称为共置模型，colocated models）共享 GPU 内存，并以分时方式顺序执行，因为如果共置的 LLM 并发执行，很容易发生内存不足（out-of-memory, OOM）错误
  • 论文观察到一种折衷：将模型放置在不同设备上允许并行处理 ，但鉴于 RLHF 中的分阶段模型执行 ，可能不可避免地导致一些 GPU 空闲时间
    • 在图 3 中，actor 和 critic 分开放置，并行执行训练，但在其他 RLHF 阶段，它们的 GPU 时间有 1/3 处于空闲状态
    • 支持各种放置策略并最大化设备利用率对于在任何模型大小和集群规模下优化 RLHF 性能至关重要

Limitations of existing RLHF systems

Inflexible support for various RLHF dataflow graphs
  • 现有的 RLHF 系统采用多控制器范式来实现数据流（2024；2023；）
    • 要实现各种 RLHF 算法，用户必须处理和管理混合了集体通信、模型计算（可能使用各种分布式训练/服务框架）和点对点数据传输的代码
    • 这种代码结构缺乏模块化/功能封装，使得 RLHF 系统与特定的 LLM 训练和服务框架紧密耦合
    • 因此，用户需要逐个案例地实现和优化不同的 RLHF 数据流（2021），这阻碍了代码重用并增加了出错风险
  • 现有的 RLHF 框架仅支持 PPO 算法
  • 由于实现复杂性，支持的并行策略有限
    • 例如，要在 DeepSpeed-Chat（2023）中为 LLM 训练和生成集成 3D 并行，可能需要重新实现整个系统，因为代码结构混乱
Inefficient RLHF execution
  • 表 1 总结了现有 RLHF 系统采用的并行策略、模型放置和执行模式
    • DeepSpeed-Chat（2023）和 OpenRLHF（2023）采用 ZeRO-3 进行 actor 训练，采用 TP 进行 actor 生成
      • OpenRLHF 在不同设备上使用 actor 模型的不同副本进行训练和生成，导致内存使用冗余以及设备间频繁的权重同步
    • DeepSpeed-Chat 在同一组设备上为训练和生成维护同一个 actor 模型副本，并在训练和生成之间对模型权重进行重分片（由于两个阶段使用不同的并行方式）
      • 但对于大型模型，这可能仍然会产生大量的内存和通信开销（详见第 5.4 节）
    • NeMo-Aligner（2024）在 actor 训练和生成中使用相同的 3D 并行配置，导致生成吞吐量较低（第 8.4 节）
  • 现有 RLHF 框架仅限于一种模型放置计划，因此也仅限于一种 RLHF 执行模式，如表 1 所示
    • 实现不同的放置非常困难，需要更改模型初始化的内部逻辑和节点间数据传输（如图 2 中蓝色部分所示）
    • OpenRLHF 和 NeMo-Aligner 允许在准备和学习阶段进行并发模型计算；
      • 在生成阶段，除了 actor 之外的模型都处于空闲状态，浪费了它们占用的 GPU
    • DeepSpeed-Chat 将所有模型共置在同一组设备上，每个设备根据 RLHF 数据流顺序运行每个模型
      • 由于模型之间的工作负载不平衡，这种放置方式可能导致资源利用率低下（第 8.3 节评估）

Design Considerations

  • 为了解决现有系统的局限性，关键问题是：如何设计一种灵活高效的编程模型来实现 RLHF 数据流？
  • 节点间使用单控制器 ：单控制器设计在节点间层面特别有利
    • 因为它在协调不同模型的分布式计算之间的数据传输、执行顺序和资源虚拟化方面具有灵活性（2022；2018）
    • RLHF 数据流图通常只包含少数节点
      • 与数据流中节点（模型）所需的分布式计算相比，从单控制器向不同节点调度控制消息的开销可以忽略不计
  • 节点内使用多控制器 ：多控制器范式以其向加速器调度算子的低延迟而闻名（2001），可用于每个模型的分布式计算
  • 基于这些见解，论文提出了一种用于 RLHF 数据流实现的分层混合编程模型
    • 论文的核心设计原则是以混合方式结合单控制器和多控制器范式
    • 这种设计确保了 RLHF 数据流的灵活表达和高效执行，在节点间和节点内层面都保持较低的控制开销
    • 如图 2（b）所示，这种范式解耦了节点内分布式计算和节点间数据传输，允许每个模型专注于本地计算，而无需管理节点间通信

HybridFlow Overview

  • 图 4 展示了 HybridFlow 的架构，它由三个主要组件组成：
    • 混合编程模型（Hybrid Programming Model）
    • 3D 混合引擎（3D-HybridEngine）
    • 自动映射算法（Auto-Mapping algorithm）
  • 混合编程模型包含一组分层 API，用于灵活表达 RLHF 数据流并高效计算数据流中的模型（第4节）
  • 3D 混合引擎专为 actor 模型的高效训练和生成而设计
    • 允许在两个阶段使用不同的 3D 并行配置，并在两个阶段之间的过渡中实现零内存冗余和最小化通信开销（第5节）
  • 自动映射算法确定每个模型的优化设备放置，以最大化 RLHF 的吞吐量（第6节）
  • 论文的RLHF系统的工作流程如下
    • 用户提供以下输入来启动RLHF系统：
      • （i）模型规格，包括RLHF数据流中 actor/critic/参考策略/奖励模型 的架构和大小；
      • （ii）数据流中模型的设备放置，通过在给定 GPU 集群配置下运行自动映射算法获得；
      • （iii）每个模型在每个阶段运行的并行策略
        • 例如 3D 并行的元组 \((p, t, d)\) ，其中 \(p\) 、 \(t\) 、 \(d\) 分别代表管道并行（PP）大小、张量并行（TP）大小和数据并行（DP）大小
    • 单控制器程序接收这些输入，初始化 RLHF 数据流和虚拟化资源池中的模型，根据放置计划将操作/模型调度到设备，并调用设备上的多控制器运行的函数来执行每个模型的分布式计算
    • 多控制器程序实现了ParallelWorker类：
      • 它根据每个模型的并行策略在分配的设备之间构建模型的并行组，调用 3D 混合引擎进行 actor 训练和生成，并且可以与现有的 LLM 引擎（2023；2019；2020；）无缝集成，用于其他模型的训练、推理和生成
      • 传输协议由单控制器程序协调，以支持具有不同并行策略的模型之间的数据（包括RLHF中的 Prompt 、响应和其他模型输出）重分片
      • actor 在训练和生成之间的数据重分片由 3D 混合引擎处理

Hybrid Programming Model

Hierarchical APIs

Intra-node: encapsulating distributed program（在节点内封装分布式程序）
  • 针对不同 RLHF 阶段中每个模型的分布式计算，论文提供了一个基类 3DParallelWorker
    • 给定分配的设备，它便于分布式模型权重初始化，并为每个模型建立 3D 并行组
    • 一个并行组包括一组 GPU，用于承载模型的特定并行维度
      • 例如张量并行（TP）中的不同张量分片和数据并行（DP）中的不同模型副本
    • 图5（a）展示了使用论文的 API 初始化 actor 模型的过程，其他模型的初始化类似
  • 继承自 3DParallelWorker 类，分别提供了针对 actor、critic、参考模型和奖励模型 的几个模型类
    • 这些模型类中的每一个都封装了实现模型的分布式前向和反向计算、自回归生成和优化器更新的 API，将分布式计算代码与其他模型的数据依赖关系解耦
    • 这些 API 可以通过重用现有 LLM 系统的计算脚本轻松实现
      • 例如，ActorWorker（actor 模型的类）的 update_actor 函数中涉及的计算类似于 Megatron-LM（2019）中的预训练脚本
    • 一个模型类封装了实现各种 RLHF 算法的基本操作
      • 例如 actor 模型类中的 generate_sequences（用于基于 Prompt 生成响应）和奖励模型类中的 compute_reward（用于通过前向传播评估响应）
    • 更多 API 详见附录A
  • 除了实现 3D 并行的基类 3DParallelWorker，论文还提供了 PyTorch FSDP（FSDPWorker）和 ZeRO（ZeROWorker）的基类，以及继承每个基类的相应模型类，以支持模型计算中的不同并行策略
  • 图4 中的 ParallelWorker 表示这些基类之一
Inter-node: unifying data resharding implementation between models（在节点间，统一模型间的数据重分片实现）
  • 采用不同并行策略的模型在不同设备上传输数据时，会涉及多对多组播
  • 论文通过使用 @register 将每个模型类中的每个操作与传输协议相关联，从而统一这种数据传输实现
  • 每个传输协议由一个收集函数（collect function）和一个分发函数（distribute function）组成
    • 用于根据每个模型的并行策略聚合输出数据和分发输入数据
  • 在图5（a）的示例中，update_actor 操作注册到传输协议 3D_PROTO ，因为 actor 训练使用 3D 并行
    • 在 3D_PROTO 中
      • 收集函数将每个 DP 组中相应模型函数的输出数据（例如，update_actor 返回的损失标量）收集到单控制器
      • 分发函数将输入数据（例如，update_actor 的优势值）分发到注册函数的每个 DP 组
    • 通过源模型的输出收集函数和目标模型的输入分发函数，实现数据重分片
  • 图5（b）展示了 actor（生成）和 critic（推理）之间的数据重分片，其中模型的计算采用不同的 3D 并行策略
    • 单控制器使用 actor 的 3D_PROTO 中的收集函数收集数据 futures（步骤1-3），并将其发送到 critic（步骤4）；
      • 问题：这里的 数据 future 是指什么？是异步任务的 引用？
    • critic 使用其 3D_PROTO 中的分发函数将接收到的数据 future 分发到每个 DP 组（步骤5）
    • 然后，从 actor 到 critic 检索远程数据，critic 的每个 GPU 仅根据其 DP 排名获取所需的 actor 输出数据的本地批次（步骤6）
    • 实际数据传输仅在 GPU 之间进行，避免了任何中央瓶颈
  • 论文提供了 8 种传输协议，包括 3D_PROTO、DP_PROTO、ONE_TO_ALL 等，涵盖了大多数数据重分片场景（详见附录B）
    • 用户可以通过实现自定义的收集和分发函数进一步扩展传输协议
Facilitating flexible model placement（促进灵活的模型放置）
  • 论文提供了一个 ResourcePool 类，用于虚拟化一组 GPU 设备
  • 当将 ResourcePool 实例应用于模型类时（图5（a）），模型的分布式计算将映射到这些设备
    • 使用相同 ResourcePool 实例的模型共置在同一组 GPU 上；
    • 当不同的 ResourcePool 实例应用于它们的模型类时，模型放置在不同的 GPU 组上
    • 论文假设不同的 ResourcePool 实例之间没有重叠
Asynchronous dataflow execution
  • 当模型放置在不同的设备组上时，一旦输入可用，它们的执行会自动触发（2018）
  • 在图5（b）中，控制器调用后立即返回来自 actor 的数据 future （步骤1-3）；然后控制器启动对 critic 的新调用，并按照传输协议分发 future （步骤4-5）
  • 当某些模型放置在同一设备组上时，它们会根据调用顺序顺序执行
  • 借助论文的编程模型，HybridFlow 可以灵活支持各种分布式执行模式，而无需对 RLHF 算法的代码进行任何更改（图6）

Implementation of different RLHF algorithms

  • 论文的 API 支持各种 RLHF 算法（数据流）的简化开发
    • 用户可以通过几行代码将 RLHF 算法实现为在单控制器上运行的单进程程序，其中包括一系列原始 API 调用，以调用模型的分布式计算
    • 图6 给出了 PPO、ReMax 和 Safe-RLHF 的示例
      • 通过调用包括 compute_values 和 generate_sequences 在内的模型操作，PPO 可以仅用 8 行代码实现，这些操作在多控制器范式下在多个 GPU 上执行
      • 为了适配 Safe-RLHF（它集成了一个额外的成本模型来评估安全偏好，以及 actor 的预训练损失），只需在 PPO 实现的基础上再添加 5 行代码
      • 为了适配 ReMax，需要额外调用一次 actor 生成，并且可以删除与 critic 相关的代码
  • 实现灵活性（Achieving flexible） ：这种扩展灵活性对于研究人员探索不同的 RLHF 算法至关重要：
    • 他们可以重用每个模型类中封装的分布式计算，并只需根据特定算法调整数值计算的代码
      • 例如 compute_advantage 中的 GAE（2018）和 KL 散度，以及 actor 和 critic 的损失函数
      • 这种简化的开发归功于混合编程模型
    • 论文的模块化 API 设计简化了开发，促进了广泛的代码重用，并能够直接整合现有 LLM 训练/服务框架的代码库
    • 论文还解耦了模型计算和模型间的数据传输
    • 分布式框架的任何变化都不会影响 RLHF 算法的代码（图6），从而可以对每个模型的执行进行个性化优化（第5节）
    • 支持具有不同工作负载的模型的灵活放置，能够将 RLHF 数据流优化映射到各种设备上（第6节）

3D-HybridEngine

  • 论文设计了 3D 混合引擎（3D-HybridEngine），以支持 actor 模型的高效训练和生成，目标是显著提升 RLHF 的吞吐量

Parallel Groups

  • 为了消除冗余的 actor 模型副本，论文建议将 actor 的训练和生成阶段部署在同一组设备上
    • 即分配给 actor 的 \(N_a\) 个 GPU ，并在同一个 actor 模型权重副本上按顺序执行这两个阶段
  • 尽管如此，actor 的训练和生成很可能采用不同的 3D 并行策略，即生成阶段通常需要比训练阶段更小的 TP 和 PP 大小 ，以及更大的 DP 大小（第2.3节）
    • 在此背景下，3D 混合引擎能够在同一组设备上高效地在 actor 训练和生成之间进行模型参数重分片
  • 用 \(p-t-d\) 表示为 actor 训练构建的 3D 并行组
    • 对应于承载 \(p\) 个管道阶段（pipeline stages）、\(t\) 个张量分片（tensor shards）和 \(d\) 个模型副本的GPU集合（2021）
    • 3D 混合引擎根据训练和生成阶段不同的 3D 并行策略，分别为 actor 的训练和生成构建不同的并行组
  • 论文用 \(p_g\) 、 \(t_g\) 和 \(d_g\) 分别表示生成阶段中生成管道并行组（generation pipeline parallel group）、生成张量并行组（generation tensor parallel group）和微数据并行组（micro data parallel group）的大小
    • \(d_g\) 表示生成阶段的模型副本数与训练阶段的比例 ，即训练阶段的每个 DP 副本会成为 \(d_g\) 个微 DP 副本 ，用于处理 \(d_g\) 个 Prompt 和响应的微批次
    • 论文有 actor 的 GPU 总数 \(N_a = p \times t \times d = p_g \times t_g \times d_g \times d\) ，因此 \(d_g = \frac{pt}{p_g t_g}\)
    • 微 DP 组仅在 actor 生成阶段使用，以实现更大的 DP 大小，从而充分利用设备
    • 生成并行组表示为 \(p_g-t_g-d_g-d\)
  • 问题：如何实现将训练时的一个 DP 副本，分散成生成时的 \(d_g\) 个微 DP 副本的？不需要重新拷贝的吗？
    • 注：是需要对参数进行重新分区的，但是会对重新分区的配置进行优化？
  • 问题：为什么生成时的 \(p_g \times t_g\) 可以变小些？
    • 解答：因为生成时不需要存储梯度信息和优化器信息，还不需要存储每一层的激活值，所以可以将 \(p_g \times t_g\) 设置的小一些

3D-HybridEngine Workflow

  • 在 RLHF 的第 \(i\) 次迭代的 actor 训练和第 \(i+1\) 次迭代的 actor 生成之间，需要根据两个阶段的并行组配置对 actor 模型参数进行重分片，并分发 Prompt 数据
  • 在 RLHF 的第 \(i+1\) 次迭代中
    • 3D 混合引擎收集在第 \(i\) 次迭代中更新的 actor 模型参数（图7中的步骤1），用于每个微 DP 组内的生成
    • 然后，将批量 Prompt 加载到每个模型副本（步骤2），生成响应（RLHF 的生成阶段）
    • 接着，3D 混合引擎在每个微 DP 组内对生成结果执行 all-gather 操作（步骤3），并根据 actor 训练的 3D 并行性对模型参数重新分区（步骤4）
    • 在模型权重、Prompt 和响应正确分发后，计算 actor 模型的损失，并根据 RLHF 算法更新 actor 模型权重（步骤5）
      • 即第 \(i+1\) 次迭代的 actor 训练阶段

Zero redundancy model resharding

  • 3D 并行中的并行组构建方法通常如下：
    • PP 组和 TP 组通过将连续的排名分配给管道阶段和张量分片形成；
    • DP 组通过按 PP 大小和 TP 大小的乘积确定的固定间隔选择排名构建
  • 在图8（a）中，actor 训练使用 3D 并行组 1-4-2：
    • 所有 GPU 组成一个 PP 组（为了说明清晰）；
    • TP 组为 [G1, G2, G3, G4]、[G5, G6, G7, G8]
    • DP 组为 [G1, G5]、[G2, G6]、[G3, G7]、[G4, G8]
  • 假设使用相同的并行组构建方法但采用不同的并行大小，例如图8（a）中生成阶段使用 1-2-2-2
    • 在从训练到生成的过渡中，3D 混合引擎在模型并行组内应用 all-gather 操作聚合所有参数，然后根据设备所属的并行组在每个设备上仅保留模型权重的一个子集用于生成
    • 在某些 GPU 上（如 G2、G3、G6、G7），训练和生成的模型权重之间没有重叠，并且还需要单独的内存来维护后续训练的权重（图8（a）中的灰色框）
    • 当 3D 混合引擎在两个阶段使用上述常规并行组构建方法时，论文将该系统称为 HybridFlow-V
  • 论文进一步为 3D 混合引擎设计了一种新的并行组构建方法，用于生成阶段，以消除权重存储的冗余，并最小化由于 actor 模型在训练和生成之间重分片导致的内存占用和通信开销
    • 具体而言，论文通过按 \(\frac{t}{t_g}\) 和 \(\frac{p}{p_g}\) 确定的固定间隔选择排名来形成生成 TP 组和 PP 组，并沿着生成 TP 或 PP 维度按顺序分配排名来构建微 DP 组
    • 在图8（b）中，生成阶段使用 1-2-2-2 并行组：
      • 生成 TP 组为 [G1, G3]、[G2, G4]、[G5, G7]、[G6, G8]；
      • 微 DP 组为 [G1, G2]、[G3, G4]、[G5, G6]、[G7, G8]
    • 这种生成并行组的策略性重排使得每个设备上的训练和生成模型权重能够重叠 ，从而在生成过程中重用训练权重 ，实现模型重分片的设备内存零冗余
      • 注：主要是某一片参数重用，不是所有参数都能重用的，不论如何，参数的传输还是需要的
    • 此外，3D 混合引擎并发执行多个 all-gather 操作（每个微 DP 组内一个），显著降低了通信开销

Transition overhead（过渡开销）

  • 在表2 中，论文比较了不同 actor 引擎设计在训练和生成阶段之间过渡时的通信开销和内存占用
  • 假设 actor 的模型大小为 \(M\)，且有 \(N_a\) 个 GPU 用于其训练和生成
    • DeepSpeed-Chat 中的 actor 引擎在过渡期间在所有 GPU 上执行 all-gather 操作；
    • HybridFlow-V 在训练 TP 和 PP 组内执行此 all-gather 操作
  • 这些操作的通信量计算如下（2007）：
    • DeepSpeed-Chat 为
      $$ \frac{N_a-1}{N_a}M = \frac{t p d - 1}{t p d}M $$
    • HybridFlow-V 为
      $$ \frac{t p - 1}{t p}M $$
    • 两种引擎在根据生成并行组划分模型状态之前，都会在每个 GPU 的内存中聚合所有模型参数，导致模型参数的峰值内存使用量为 \(M\)
    • 由于它们无法在某些 GPU 上的生成过程中重用训练权重，这些 GPU 需要维护训练权重，分别导致 \(\frac{1}{t p d}\) 和 \(\frac{1}{t p}\) 的冗余内存消耗
  • 通过论文为生成阶段设计的并行组构建方法，HybridFlow 将 all-gather 操作限制在每个微 DP 组内
    • 通信开销减少到
      $$ \frac{d_g - 1}{t p}M = \frac{t p - t_g p_g}{t_g p_g t p}M $$
    • 每个 GPU 只需收集其微 DP 组内的远程参数，并可以在生成过程中重用训练权重
    • 因此，HybridFlow 中模型参数的峰值内存使用量正好与每个 GPU 在生成阶段的模型分区大小匹配 ，消除了 GPU 内存使用中的任何冗余

Auto Device Mapping

  • 论文的混合编程模型要求用户输入以下配置，这些配置被称为 RLHF 数据流到给定设备的映射：
    • （a）数据流中模型的设备放置；
    • （b）每个模型在每个阶段运行的相应并行策略
  • 论文为用户提供了一种高效算法（算法1），用于确定在给定设备集群上执行 RLHF 数据流的优化映射，以最小化每个 RLHF 迭代的端到端延迟
  • 给定一个数据流 \(D\)，论文首先在给定集群中探索模型的所有可能放置计划 \(\mathcal{P}\)（第3行）
    • 例如，PPO 算法涉及 4 个模型，产生 15 种可能的放置（来自贝尔分区问题（1934；1964）），范围从所有模型放置在不同设备上的完全独立放置（如 OpenRLHF 的放置）到所有模型共置在同一组设备上的放置（如 DeepSpeed-Chat 的放置）
    • 论文将共置在同一组 GPU 上的模型称为共置集（colocated set）
      • 共置集中的模型可以在同一组 GPU 上采用不同的并行策略
    • 论文根据共置模型的内存消耗确定分配给每个共置模型集的最小 GPU 数量 \(A_{min}\) ，确保不会出现内存不足错误（第9行）
  • 接下来，从 \(A_{min}\) 中的最小 GPU 分配开始，论文枚举每个共置模型集的所有可行设备分配（第10-12行）
  • 给定共置集的设备分配 \(A\) 和集合中模型的计算工作负载 \(W\)，论文在 auto_parallel 模块中探索每个模型的优化并行策略，以最小化模型执行延迟
    • 工作负载 \(W\) 包括每个模型的输入和输出形状以及计算（训练、推理或生成）
    • 在 auto_parallel 中，论文利用模拟器模块 simu 来估计不同并行策略的延迟，遵循先前的研究（2023；2024；2024；2024）（概述见附录C）
    • d_cost 模块通过遍历数据流图中的所有阶段并汇总所有阶段的延迟，来估计在给定模型放置和并行策略下 RLHF 数据流的端到端延迟（第17、25行）
  • 对于同一共置集中在同一阶段涉及计算的模型（例如 actor 和 critic 在 RLHF 训练阶段都执行模型更新），它们的执行延迟会被累加（第32行）
  • 对于不同共置集中的模型，它们在同一阶段的执行可以并行化，阶段延迟由不同集合之间的最大执行时间决定（第33行）
  • 论文确定模型的最佳设备放置及其相应的并行策略 ，以实现每个 RLHF 迭代的最小执行时间（第18-23行）
  • 算法1的复杂度为
    $$ O(\frac{(N-1)!}{(k-1)!(N-k)!})$$
    • 其中 \(k\) 是数据流中模型的数量，\(N\) 是运行数据流的设备总数
  • 这是为放置策略枚举所有可能设备分配的最坏情况复杂度（即独立放置），通过将 \(N\) 个设备分配给 \(k\) 个模型计算得出（称为整数分区问题（2004））
  • 为了提高效率，论文缓存为每个模型在 \(A\) 个设备上确定的并行策略，以消除当模型在不同放置策略中放置在不同的 \(A\) 个 GPU 集上时对相同并行策略的冗余搜索
  • 尽管论文在运行自动映射算法时假设 \(N\) 个同构 GPU，但算法1可以很容易地扩展到异构设备的模型映射优化，通过在 simu 和 auto_parallel 模块中考虑异构设备（2024）

Implementation

  • HybridFlow 由大约 12000 行 Python 代码（LoC）实现

Hybrid programming model

  • 分层 API 用 1800 行代码实现
  • 集中式单控制器构建在 Ray（2018）之上，并使用远程过程调用（Remote Process Calls, RPC）来协调不同模型的执行顺序，并按照数据流在模型之间传输数据
  • 这些中间数据存储在 TensorDict（2019）中
  • 在论文用于分布式计算的多控制器范式中，每个模型函数在不同设备上的独立进程中运行，控制消息从每个控制器的 CPU 进程传递到相应的 GPU
  • 论文的实现支持 Megatron-LM、PyTorch FSDP 和 DeepSpeed 作为 LLM 训练和推理引擎，以及 vLLM 用于自回归生成
  • 在 vLLM 中，论文用分布式管理器替换了集中式 KVCache 管理器，以与多控制器范式对齐

3D-HybridEngine

  • 其主要逻辑在 Megatron-LM 和 vLLM 之上用 2400 行代码实现
  • 论文在分开的内存缓冲区中存储训练和生成阶段的 actor 模型权重 ，在训练期间将生成权重卸载到 CPU 内存 ，在过渡期间将生成权重重新加载到 GPU 内存 ，并在生成中使用这两个缓冲区
    • 理解：生成和训练两个阶段下，actor 模型权重有各自的缓冲区
  • 论文使用 NCCL 通信原语（2017）在训练和生成之间的过渡期间收集和连接每个微 DP 组中的模型参数
    • 论文在生成后将 KVCache 卸载到 CPU 内存，并在下一次迭代中重新加载到 GPU
    • 问题：每一轮的 Prompt 数据是相同的吗？为什么要 缓存 KVCache
    • 回答：每一轮的 Prompt 数据可能是相同的，Prompt 数据会被重复利用（多次生成和训练）

Auto-Mapping Algorithm

  • 自动映射算法（Auto-Mapping Algorithm）用 1900 行代码实现，同时包含三个分别用于训练、推理和生成工作负载的模拟器
  • 该算法在 CPU 上启动 RLHF 数据流之前运行，以生成用于数据流初始化的设备映射和并行策略

Evaluation

Experimental Setup

Testbed（测试平台）
  • 论文在一个包含 16 台机器（128 个 GPU）的集群上部署 HybridFlow
  • 每台机器配备 8 个 NVIDIA A100 80GB GPU，通过 600GB/s 的 NVLink 互连
  • 机器间带宽为 200Gbps
  • 论文的实验使用以下软件版本：CUDA 12.1、PyTorch 2.1.2、Megatron-core 0.6.0、NCCL 2.18.1 和 vLLM 0.3.1
Models and RLHF algorithms
  • 论文运行 PPO（2017）、ReMax（2023）和 Safe-RLHF（2024）算法的 RLHF 数据流（图 1）
  • PPO 是 RLHF 中最流行的算法之一（2022；2022），包括 actor、critic、参考策略和奖励模型
  • 每个模型都是 Llama（2023）模型，大小从 7B 到 70B 参数不等
  • Safe-RLHF 有一个额外的成本模型，其架构和大小与奖励模型相同，而 ReMax 则取消了 critic 模型
  • 论文对 actor 和 critic 训练使用混合精度，即模型参数使用 BF16，梯度和优化器状态使用 FP32，所有实验均使用 Adam 优化器（2017）
  • 模型推理和自回归生成使用 BF16
  • 除非另有说明，否则实验结果均来自 PPO
Baselines
  • 论文将 HybridFlow 与 SOTA RLHF 系统进行比较，包括 DeepSpeed-Chat（2023）v0.14.0、OpenRLHF（2023）v0.2.5 和 NeMo-Aligner（2024）v0.2.0（详见表 1）
  • NeMo-Aligner 不支持 ReMax 算法
  • 论文没有将 HybridFlow 与 Trlx（2023）、HuggingFace DDP（2019）和 Collosal-Chat（2023）等其他框架比较，因为它们的代表性较低，且比上述基线慢（如（2023）所报告）
  • 论文使用 RLHF 吞吐量（tokens/秒）作为性能指标，计算方法是将全局批次中 Prompt 和响应的总 token 数除以一个 RLHF 迭代时间
  • 所有报告的性能数据均为 10 次迭代预热后 5 次训练迭代的平均值
Datasets and hyperparameters
  • 论文在 HuggingFace 的“Dahoas/ful-hh-rlhf”数据集（2022）上执行 RLHF，该数据集广泛用于 LLM 对齐（2023；2023）
  • 由于基线系统在生成期间可能未集成连续批处理优化（2022），为了公平比较，论文强制所有要生成的响应长度相同
  • 在每个实验中，输入 Prompt 长度和输出响应长度均为 1024，输入到 actor 模型的 Prompt 全局批次大小为 1024
  • PPO 的 epoch 数为 1，每个 epoch 的 PPO 更新迭代次数为 8，与之前的 RLHF 研究一致（2024；2022；2023）

End-to-End performance

  • 图 9、图 10 和 图 11 分别显示了运行 PPO、ReMax 和 Safe-RLHF 时的 RLHF 吞吐量
  • 本组实验中的 actor、critic、参考模型和奖励模型大小相同，遵循先前的实践（2022；2022；2023）
  • 不同模型大小的实验使用的 GPU 数量范围从运行 RLHF 而不出现 OOM 的最小 GPU 数量到 128 个 GPU
  • 为了公平比较，论文在实验中未启用优化器状态卸载（2021）
Overall Performance
  • 论文观察到，在所有模型规模上，HybridFlow 始终优于基线
  • 在图 9 的 PPO 中
    • HybridFlow 比 DeepSpeed-Chat、OpenRLHF 和 NeMo-Aligner 分别高出 \(3.67\times\) （最高 \(7.84\times\) ）、 \(3.25\times\) （最高 \(5.93\times\) ）和 \(12.52\times\) （最高 \(20.57\times\) ）
      • 这主要是因为 HybridFlow 通过使用不同的并行策略对模型进行分片，以适应各种计算工作负载，从而在所有 RLHF 阶段有效执行生成、推理和训练
    • HybridFlow 在训练 70B 参数模型时实现了平均 \(9.64\times\) 的最高加速比
      • 因为与 DeepSpeed-Chat 和 OpenRLHF 相比，HybridFlow 将过渡开销分别降低了高达 71.2% 和 89.1%，而后两者在使用 ZeRO-3 训练时也会产生大量的机器间通信
    • 由于生成引擎中缺少 KVCache，NeMo-Aligner 的主要性能瓶颈在于生成阶段，该阶段占其 RLHF 迭代时间的比例高达 81.2%
  • 在图 10、11 中可以观察到类似的结果，验证了 HybridFlow 在运行各种 RLHF 算法时的效率
Scalability
  • HybridFlow 在 8 个 GPU 上至少实现了 \(2.09\times\) 的加速比
  • 随着 GPU 数量的增加，HybridFlow 在各种模型规模上的强扩展效率为 66.8%，计算方法是将最大规模下的吞吐量与最小规模下的吞吐量之比除以 GPU 数量的倍数（2007），取三种算法和所有模型规模的平均值
  • 在固定全局批次大小的情况下扩展到大量 GPU 会导致每个工作进程的本地批次大小更小，可能导致 GPU 利用率不足
  • 在 128 个 GPU 上运行 7B 参数模型时，HybridFlow 在 PPO、ReMax 和 Safe-RLHF 上仍分别比最佳基线 OpenRLHF 高出 \(1.68\times\) 、 \(1.53\times\) 和 \(1.71\times\)
  • 这归因于 HybridFlow 能够为不同的模型和集群规模调整最佳放置策略，以最小化 RLHF 时间
  • OpenRLHF 在更大的 GPU 集群中表现更好，但在较小的集群上效率较低

Model Placement

  • 在本实验中，论文在 HybridFlow 中实现了 PPO 算法的各种模型放置，模型和集群设置与 8.2 节相同：
    • （i）共置（colocate），即 DeepSpeed-Chat 中的放置策略；
    • （ii）独立（standalone），即 OpenRLHF 中的放置策略；
    • （iii）拆分（split），即 NeMo-Aligner 的共置放置（actor 和参考策略在同一组设备上，critic 和奖励模型在另一组上）；
    • （iv）hybridflow，即通过算法 1 获得的优化放置
Comparison of different model placements
  • 图 12 显示，HybridFlow 在不同数量 GPU 下的优化放置有所不同
  • 在 16 到 64 个 GPU 上，将所有模型共置在同一组设备上可获得最佳性能
  • 对于 96 到 128 个 GPU 上的 34B 参数模型和 96 个 GPU 上的 13B 参数模型 ，拆分策略成为最优
    • 拆分策略将 GPU 平均分配给两组模型，因为它们的大小相同
    • 对于 128 个 GPU 上的 13B 参数模型，独立策略实现了最高吞吐量
    • 在这种情况下，HybridFlow 为 actor 分配 64 个 GPU，为 critic 分配 32 个，为参考模型和奖励模型各分配 16 个
  • 在较小的集群中，所有模型的计算都能充分利用 GPU 资源；
    • 共置策略确保在不同 RLHF 阶段最大限度地利用 GPU
  • 在较大的集群中，随着批次大小固定，共置放置下的 RLHF 吞吐量无法线性扩展，因为在更多 GPU 上，随着 DP 大小增大，计算与通信比会降低
    • 在较大的集群中，独立和拆分策略将模型放置在不同设备上，每个模型使用更小的 DP 大小，有助于在同一阶段并行执行不同模型
    • 在所有情况下，论文的算法 1 都能产生最佳放置，实现最高的训练吞吐量

Larger critic and reward model.

  • 我们进一步评估了在运行 PPO 算法时的模型部署方案，此时采用 13B 参数的 actor 模型与参考策略（reference policy），并搭配 70B 参数的 critic 与奖励模型（更大的 critic 和奖励模型有望实现更优的对齐效果（2022））
  • 图 13 显示
    • 在 GPU 数量最多达 64 块的情况下，共置（colocate）策略仍以平均 44.8% 的优势优于其他策略
    • 当使用 96 块 GPU 时，拆分（split）策略实现了更高的吞吐量
    • 当扩展至 128 块 GPU 时，通过算法 1 得到的最优部署方案为：
      • 将 actor、参考策略与奖励模型共置于 64 块 GPU 上，同时将剩余 64 块 GPU 分配给 critic
    • 在 GPU 数量相同的情况下，actor 与参考策略的计算时间远短于 critic 与奖励模型；
    • 将奖励模型与 actor、参考策略进行共置，能够减少 experience 准备阶段的 GPU 空闲时间
  • 总体而言，大型集群中，在训练阶段将 actor 与 critic 分布在不同设备上进行并行执行，可实现更高的吞吐量

3D-HybridEngine

Transition time comparison
  • 图 14 显示了在不同模型规模上 actor 训练和生成阶段之间的过渡时间，即从训练到生成的模型权重重分片时间，设置与 8.2 节相同
  • OpenRLHF 的过渡时间包括不同设备上两个 actor 模型副本之间的权重同步时间
  • HybridFlow 平均减少了 55.2%（11.7 秒）的过渡时间，在 70B 参数模型上最多减少了 89.1%（78.2 秒）的过渡开销，同时在不同集群规模上保持一致的开销
    • 这归因于论文为生成阶段设计的新并行组构建方法（第 5.4 节）
  • 在基线方法中，过渡期间必须收集所有模型参数，为了防止 OOM，需要多次逐层收集
  • HybridFlow 在过渡期间实现了零内存冗余，每个微 DP 组只需一次 all-gather 操作
Transition and generation time
  • 论文进一步验证了在 HybridFlow 中需要为 actor 训练和生成使用不同的并行大小
  • 在本实验中，所有模型共置在同一组 GPU 上，生成的 KVCache 使用剩余的 GPU 内存（即尽力而为分配）
  • 图 15 给出了在 16 个 GPU 上运行 RLHF 时 7B 和 13B 参数模型的过渡和生成时间
    • 训练并行组为 1-8-2（遵循 p-t-d 约定），生成 TP 组大小 \(t_g\) 从 1 到 8 不等
  • 生成 PP 组大小保持为 \(p_g=1\) ，微 DP 组大小 \(d_g\) 计算为 \(\frac{8}{t_g}\)
  • 论文观察到
    • 对于 7B 参数模型，使用较小的生成 TP 组大小 \(t_g=2\)
    • 对于 13B 参数模型，使用 \(t_g=4\) ，分别减少了 60.3% 和 36.4% 的生成延迟
  • 相反，遵循 NeMo-Aligner 的方法，使用与训练相同的 TP 大小（ \(t_g=8\) ），会导致最大的生成延迟，因为 GPU 利用率不足
  • 进一步减小 \(t_g\) 无法实现更高的加速比，因为较小的 \(t_g\) 需要每个 GPU 维护更大的 KVCache

Algorithm Runtime

  • 图 16 显示了算法 1 的运行时间，该时间明显短于实际 RLHF 训练的天数
  • 运行时间呈线性增长，表明设备映射算法在模型大小和集群大小方面具有良好的可扩展性
  • 大部分运行时间用于估计每个模型并行策略的执行延迟
  • 更大的模型有更多可用的并行策略，需要更多模拟来为每个放置计划确定最优策略
  • 论文缓存模型的最优并行策略，以便在不同放置中重新应用，将最佳放置的搜索时间减少到最多半小时

Discussions

Fault Tolerance（容错能力）

  • HybridFlow 与现有的容错方法（2020；2023；2021；）是正交的，并且已经集成了检查点机制（checkpointing）
  • 可以通过 NCCL 错误检测故障，通过校验和检测静默数据损坏（silent-data-corruption）
  • 论文的编程模型使单控制器能够通过 RPC 协调检查点操作，从而可以在每个 ParallelWorker 组内保存模型状态
  • 这包括保存 actor/critic 模型的参数、数据加载器 ID（dataloader IDs）和随机数生成器（Random Number Generator, RNG）状态，以确保系统级一致性
  • 此外，如果有足够多健康的模型副本可用，HybridFlow 还可以采用基于冗余的容错方法，例如广播参数和 CPU 检查点，以实现快速恢复（2023；2023）

Placement Insights

  • 论文总结了 RLHF 训练中模型放置和 GPU 分配的三个主要见解
    • 1）为 actor 模型分配更多 GPU 可以减少耗时的生成延迟，而生成延迟无法与其他模型并行化
    • 2）当每个模型的计算都能充分利用 GPU 资源时，在相对小规模的集群上训练时，将所有模型共置是最有效的
    • 3）当扩展到大规模集群（即强扩展）时，将 actor 和 critic 模型分布在不同设备上，以便在训练和准备阶段并行执行，有助于实现更高的吞吐量

Resource multiplexing（资源复用）

  • HybridFlow 通过利用 GPU 计算的时间共享（time-sharing），支持模型在共享设备上的共置
  • DNN 任务调度领域的最新研究已经开发了细粒度资源复用技术，主要旨在实现单个任务的服务级别目标（2020；2022；2022；2022；2021；2023；2023）
  • 尽管 ResourcePool 实现支持共置模型的并行执行，但如第 2.3 节所讨论的，HybridFlow 通常遵循顺序执行，以防止 GPU 资源竞争或 OOM 问题
  • 在 RLHF 训练中应用 GPU 共享和异构资源面临着独特的挑战 ，因为它需要平衡计算工作负载并管理各种任务之间复杂的数据依赖关系
  • 研究用于 RLHF 训练中 GPU 共享的细粒度自动映射算法，结合模型卸载优化和异构设备集成，将是未来研究的一个有前景的方向

From alignment to reasoning

  • 在用于 LLM 对齐的 RLHF 中，奖励信号由奖励模型生成
  • 除了对齐任务外，类似的算法（如 PPO 和 GRPO（2024））还可应用于其他领域，如代码生成和数学推理
  • 对于这些任务，每个 Prompt 可能存在一个真实值（ground truth），这可以通过评估每个代码测试用例的输出值的正确性和验证数学结果的准确性来确定
  • 因此，奖励模型可以被非神经网络奖励模块取代，例如用于评估生成代码的沙箱环境（2024）或用于验证数学结果的奖励函数（2021；2019）
  • HybridFlow 可以通过将这些奖励模块包装为远程函数，并在单进程脚本中编排它们的执行，无缝集成这些奖励模块，为各种强化学习应用提供一个灵活高效的框架

RL frameworks

  • 已有许多强化学习框架，从用于小规模深度神经网络的通用强化学习系统设计（2017；2017；2017；2018；2018；2021）到专门为 LLM 优化的 RLHF 系统（2023；2024；2023；2023；2023）
  • 论文在第 2 节中详细研究了密切相关的工作，并在本节中讨论更多强化学习框架
  • 这些强化学习框架（2017；2017；2017；2018；2023）与最近的 RLHF 系统类似，使用多控制器框架的混合体来实现其算法。它们建立了多个长期运行的分布式程序，每个组件通过硬编码的数据同步来协调执行顺序
    • Gear（2023）进一步优化了强化学习 pipeline 的经验回放（experience replay）部分
  • 然而，所有这些框架都不支持 RLHF 中的 LLM 训练、推理和生成

LLM training and serving systems

  • TorchDDP（2019）和 Horovod（2018）支持数据并行训练
  • ByteScheduler（2019）和 DeepSpeed（2020）通过通信和内存优化扩展了数据并行性
  • 许多系统（2021；2024；2021；2021；2019；2023；2022）通过模型并行性（如张量并行和管道并行）优化大型模型训练，将模型分布到多个设备上
  • LLM 服务系统（2023；2023；2023；2023；2022；2024）也采用数据和模型并行性，通过连续批处理（2022）和分块预填充（2023）等专门优化来加速自回归生成
  • 请注意，上述所有框架都采用多控制器范式来实现高效计算

Dataflow systems

  • 像 MapReduce（2008）、Spark（2016）、Dryad（2007）和 Naiad（2013）这样的数据流系统在分析和机器学习工作负载中很流行，但它们缺乏对动态任务图的支持
  • Ray（2018）在单个动态任务图中统一了任务并行和 actor 编程模型，并实现了可扩展的分布式调度器和全局控制存储，许多强化学习框架都采用了这一点（2018；2021）
  • Pathways（2022）是一个用于 TPU 的闭源项目，旨在轻松表达单个 DNN 模型中复杂的并行模式和细粒度控制流，例如管道并行和具有稀疏计算的 MoE
  • 它采用异步分布式数据流设计，尽管存在数据依赖关系，但仍能实现并行控制平面执行，减少了单控制器范式的调度开销
  • 它主要关注单模型训练，需要对 DNN 模型的每个子网络进行复杂的编译
  • HybridFlow 可以集成 Pathways 作为子模块，以实现 RLHF 数据流中模型的计算

附录 A：Primitive APIs in HybridFlow

  • 在 HybridFlow 中，论文通过继承 3DParallelWorker、FSDPWorker 和 ZeROWorker 实现了 RLHF 训练中每个模型的基本操作
  • 这些模型类的函数旨在解耦分布式计算代码，并为用户提供 RLHF 中的基本操作
  • 这种基本设计与现有的分布式推理和训练框架中的自回归生成、前向传播、反向传播和模型更新操作兼容
  • 用户可以根据算法设计轻松定制 RLHF 训练数据流（通过调整提供函数中的数值计算），并受益于重用底层分布式计算实现
  • 论文在表4 中说明了这些 API 的含义和实际计算

附录 B：Transfer Protocols

  • 论文实现的传输协议涵盖了 RLHF 数据流中模型之间数据重分片的所有常见用例
  • 用户可以利用这些预定义的协议生成任何 RLHF 数据流
  • 此外，用户可以通过实现收集函数（collect function）和分发函数（distribute function）轻松定义自己的传输协议
  • 传输协议解耦了复杂的数据重分片和分布式训练
  • 论文用 \(p\) 、 \(t\) 、 \(d\) 分别表示工作进程在管道并行、张量并行和数据并行组中的排名
  • 论文在表3 中说明了这些预定义的协议

附录 C：Auto-Parallelism Algorithm

  • 算法2 概述了每个模型最优并行策略的搜索过程
    • 从每个模型的最小模型并行大小开始（以防止与多个工作进程共置时出现内存不足），论文基于 GPU 数量和每台机器的 GPU 数量 \(U\) 枚举所有可行的并行配置
      • \(U\) 的默认值设置为 8
  • 论文使用 simu 模块根据模型的工作负载估计每个模型的延迟
    • 该模块包括三个分别用于训练、推理和生成工作负载的模拟器，均为遵循先前研究的分析模型（2023；2024；2024；2024）
  • 训练和推理工作负载是计算密集型的 ，而生成工作负载是内存密集型的
    • 对于 actor 模型，论文首先找到训练的并行策略，并记录训练阶段的内存使用情况
    • 在 actor 生成期间，使用批次大小和最大序列长度计算 KVCache 需求
    • 如果生成阶段的模型并行大小无法同时容纳参数和 KVCache，论文会增大它
    • 然后，论文通过比较延迟估计来寻找具有相应 KVCache 分配的最优策略
    • 开发一个考虑可变 KVCache 大小的全面自回归生成模拟器，可以进一步增强 RLHF 研究中的自动映射过程

注：本文包含 AI 辅助创作

Paper Summary

  • 整体内容总结：
    • 论文揭示了现代语言模型中幻觉的奥秘，幻觉从预训练期间的起源到通过后训练的持续存在
    • 在预训练中：生成错误（generative errors）类似于监督学习中的误分类（misclassifications）
      • 这并不神秘，并且是由于最小化交叉熵损失（cross-entropy loss）而自然产生的
    • 作者认为大多数主流评估奖励幻觉行为，对主流评估进行简单的修改可以重新调整激励
      • 训练和评估过程中，鼓励适当的不确定性表达（目前的大多数方法均会惩罚不确定性回答） ：可以消除抑制幻觉的障碍
  • “幻觉”（hallucination）现象的解释和定义：
    • LLM 有时在不确定时会猜测（就像学生面对难题时会猜测一样），产生看似合理但不正确的陈述，而不是承认不确定性（即使是 SOTA 系统也依然存在）
  • 作者认为：
    • 语言模型产生幻觉是因为训练和评估过程鼓励猜测而非鼓励承认不确定性 ，并且论文分析了现代训练流程中幻觉的统计原因
    • 幻觉不是神秘的，它们源于二元分类中的简单错误
    • 如果错误陈述无法与事实区分开来，那么预训练语言模型中的幻觉就会因为自然的统计压力产生
  • 论文论证
    • 幻觉之所以持续存在，是因为大多数评估的评分方式存在问题
    • 具体问题是：语言模型被优化为优秀的应试者，而在不确定时进行猜测可以提高测试表现
  • 这种“惩罚不确定回答”的普遍现象只能通过一种社会技术性的缓解措施来解决：
    • 修改那些主导排行榜但未对齐的现有基准测试的评分方式，而不是引入额外的幻觉评估
    • 理解：惩罚不确定性是不好的，最好是能正确回答 > 不确定性回答 > 错误回答
  • 注：这种改变可能会引导该领域朝着更可信的人工智能系统方向发展

Introduction and Discussion

  • “幻觉”（hallucination）是指语言模型会产生过度自信、看似合理的虚假信息的现象
  • 目前为止幻觉问题仍然困扰着大家，并且仍然存在于最新的模型中（OpenAI, 2025a）
    • 考虑以下提示：What is Adam Tauman Kalai’s birthday? If you know, just respond with DD-MM.
    • 在三次独立的尝试中，一个 SOTA 开源语言模型输出了三个错误的日期：“03-07”、“15-06”和“01-01”，即使提示要求仅在知道的情况下才回答。正确的日期是在秋季（表 1 提供了一个更复杂的幻觉示例）
  • 幻觉是语言模型产生的错误（errors）的一个重要特例，论文使用计算学习理论（computational learning theory）（例如，1994）对其进行了更一般的分析
  • 论文考虑一般的错误集合 \(\mathcal{E}\)，它是合理字符串集合 \(\mathcal{X}=\mathcal{E}\cup\mathcal{V}\) 的任意子集，其中其他合理字符串 \(\mathcal{V}\) 被称为有效（valid）字符串
    • 然后论文分析这些错误的统计性质，并将结果应用于论文感兴趣的错误类型：看似合理的虚假陈述（幻觉）
  • 论文的形式化框架还包括提示（prompt）的概念，语言模型必须对其作出响应
  • 语言的分布最初是从包含训练示例的语料库中学习到的，该语料库不可避免地包含错误和半真半假的陈述
  • 然而，论文表明，即使训练数据没有错误，语言模型训练期间优化的目标也会导致生成错误
    • 对于包含不同程度错误的真实训练数据，人们可能会预期错误率甚至更高
    • 因此，论文的错误下界适用于更现实的场景，正如传统的计算学习理论（1994）一样
  • 论文的错误分析是通用的，但对幻觉有特定的意义
    • 它广泛适用，包括推理和搜索检索语言模型，并且该分析不依赖于下一个词预测或基于 Transformer 的神经网络的特性
    • 它只考虑现代训练范式的两个阶段：预训练（pretraining）和Post-training，如下所述
  • 对于幻觉，分类法（2020; 2023）通常进一步区分:
    • 内在（intrinsic）幻觉，即与用户提示相矛盾 ，例如：
      • How many Ds are in DEEPSEEK? If you know, just say the number with no commentary.
      • DeepSeek-V3 在十次独立试验中返回了“2”或“3”；Meta AI 和 Claude 3.7 Sonnet 的表现类似，包括“6”和“7”这样大的答案
    • 外在（extrinsic）幻觉，即与训练数据或外部现实相矛盾的幻觉
      • 论文的理论也阐明了外在幻觉

Errors caused by pretraining

  • 在预训练期间，一个 Base Model 学习大型文本语料库中的语言分布
  • 论文证明，即使使用无错误的训练数据，预训练期间最小化的统计目标也会导致语言模型产生错误
    • 证明这一点并非易事，因为有些模型不会出错，例如总是输出“我不知道”（I don’t know, IDK）的模型，或者只是记忆并复述无错误语料库的模型
    • 论文的分析解释了预训练后应预期哪些类型的错误
  • 为此，论文将其与二元分类（binary classification）联系起来
    • 考虑形式为“这是一个有效的语言模型输出吗？”的问题
      • 生成有效输出在某种意义上比回答这些是/否问题更难，因为生成隐含地需要对每个候选回答回答“这有效吗”
    • 形式上，论文考虑“它是否有效”（Is-It-Valid, IIV）二元分类问题，其训练集包含大量响应，每个响应都被标记为有效（+）或错误（-），如图 1 所示
    • 对于这个监督学习问题，训练和测试数据都是标记为 \(+\) 的有效示例（即预训练数据，因为论文假设它是有效的）和来自 \(\mathcal{E}\) 的均匀随机错误（标记为 \(-\)）的 50/50 混合
    • 然后论文展示任何语言模型如何可以用作 IIV 分类器。这反过来使论文能够建立生成错误（如幻觉）和 IIV 误分类率之间的数学关系：
      $$ (generative error rate) \gtrsim 2 \cdot (IIV misclassification rate). $$
      • 即：生成错误率 大约大于等于 2 倍的 IIV 误分类率
  • 语言模型避免了许多类型的错误，例如拼写错误，并且并非所有错误都是幻觉
    • 从 IIV 误分类到生成的归约阐明了生成错误的统计性质
      • 该分析显示了预训练如何直接导致错误
      • 而且它表明导致二元分类错误的相同统计因素也会导致语言模型错误
    • 数十年的研究已经阐明了误分类错误的多方面性质（Domingos, 2012）
      • 图 1（右）直观地说明了这些因素：
        • 顶部，可分离数据被准确分类；
        • 中部，用于圆形区域的线性分隔器的模型较差；
        • 底部，没有简洁的模式
  • 第 3.3 节分析了几个因素，包括以下具有认知不确定性（epistemic uncertainty）的风格化设置（即数据中没有模式时）
    • 这种归约将早期涵盖不同类型事实的工作联系在一起
    • 例如，Kalai and Vempala (2024) 考虑了任意事实（arbitrary facts）的一个特例，其中数据中没有可学习的模式，就像之前的生日幻觉例子一样
  • 论文展示了 IIV 归约如何涵盖这种情况，并恢复了他们的下界，即预训练后的幻觉率至少应为训练事实中出现一次的比例
    • 例如，如果 20% 的生日事实在预训练数据中恰好出现一次，那么预计基础模型至少会对 20% 的生日事实产生幻觉
    • 问题：如何理解，只出现一次的事实一定会出错这个理论？出现次数少更容易出错，但不代表只出现一次的就一定会出错吧？

      We show how the IIV reduction covers this case and recovers their bound that the hallucination rate, after pretraining, should be at least the fraction of training facts that appear once. For instance, if 20% of birthday facts appear exactly once in the pretraining data, then one expects base models to hallucinate on at least 20% of birthday facts. In fact, our analysis strengthens their result to include prompts and IDK responses, both essential

  • 事实上，论文的分析加强了他们的结果，将提示和 IDK 响应都包括在内，这两者都是幻觉的重要组成部分

Why hallucinations survive post-training（后训练中持续存在）

  • 后训练（post-training），对基础模型进行细化，通常以减少幻觉为目标
  • 论文对预训练的分析主要包含了更一般的错误 ，论文对后训练的分析侧重于为什么会产生过度自信的幻觉 ，而不是省略信息或表达不确定性（如 IDK）
  • 论文为后训练后幻觉的持续性提供了一个社会技术性的解释，并讨论了该领域如何抑制它们
  • 作为一个类比，考虑以下人类偶尔也会编造听起来合理的信息的情境
    • 当不确定时，学生可能会在多项选择考试中猜测，甚至在书面考试中虚张声势，提交他们几乎没有信心的看似合理的答案
    • 语言模型通过类似的测试进行评估
      • 在不确定时猜测，在二元 0-1 评分方案下（正确答案得 1 分，空白或 IDK 得 0 分）可以最大化期望分数
      • 虚张声势通常是过度自信和具体的，例如对于日期问题回答“9 月 30 日”而不是“秋天的某个时候”
  • 许多语言模型基准测试反映了标准化的人类考试，使用二元指标，如准确率或通过率
    • 因此，针对这些基准优化模型可能会助长幻觉
    • 人类在校外的艰难教训中学会了表达不确定性的价值
    • 语言模型主要使用惩罚不确定性的考试进行评估
      • 因此，它们总是处于“应试”模式
  • 总之，大多数评估并未对齐（aligned）
  • 论文并非第一个意识到二元评分不能衡量幻觉的人，但先前关于幻觉评估的工作通常追求难以捉摸的“完美幻觉评估”
    • 在第 4 节中，作者认为这是不够的
  • 论文观察到，现有的主要评估绝大多数都惩罚不确定性 ，因此根本问题是大量评估未对齐
    • 假设模型 A 是一个对齐的模型，能正确发出不确定性信号且从不产生幻觉
    • 让模型 B 与模型 A 相似，只是它从不表示不确定性，并且在不确定时总是“猜测”
    • 在 0-1 评分（大多数当前基准的基础）下，模型 B 将优于 A
    • 这造成了一种“惩罚不确定性和弃权”的普遍现象，作者认为少量的幻觉评估不足以解决这个问题
  • 必须调整众多主要评估，以停止在不确定时惩罚弃权行为
  • 论文的 Contributions：
    • 论文确定了幻觉的主要统计驱动因素，从其预训练的起源到其后训练的持续性
    • 监督学习和无监督学习之间的新颖联系揭示了它们的起源，即使在训练数据包含 IDK 的情况下也是如此
    • 尽管针对该问题进行了大量工作，幻觉仍然存在，幻觉的持续性可以理解为：大多数的评估在“奖励猜测行为”
    • 论文讨论了对现有评估进行统计上严谨的修改，为有效缓解铺平道路
  • 据论文所知，论文提出的从监督学习（二元分类）到无监督学习（密度估计或自监督学习）的归约是新颖的
  • 然而，学习问题之间归约的一般方法是证明一个问题至少与另一个问题一样难的成熟技术（参见，例如，2016）
  • 许多调查和研究探索了语言模型中幻觉的根本原因
    • Sun 等 (2025) 引用了诸如模型过度自信（2023）、解码随机性（2022）、雪球效应（2023）、长尾训练样本（2023）、误导性的对齐训练（2023）、虚假相关性（2022）、曝光偏差（2015）、逆转诅咒（2024）和上下文劫持（Jeong, 2024）等因素
    • 类似的错误来源在更广泛的机器学习和统计环境中早已被研究（Russell and Norvig, 2020）
  • 最相关的理论工作是 Kalai and Vempala (2024)，论文表明它是论文归约的一个特例
    • 他们将古德-图灵缺失质量估计（Good-Turing missing mass estimates）（Good, 1953）与幻觉联系起来，这启发了定理 3
    • 但该工作没有涉及不确定性表达（例如，IDK）、与监督学习的联系、后训练修改，并且他们的模型不包括提示
  • Hanneke 等 (2018) 分析了一种交互式学习算法，该算法查询有效性预言机（例如，人类）以不可知地训练一个最小化幻觉的语言模型
    • 他们的方法在统计上是高效的，需要合理数量的数据，但在计算上并不高效
  • 其他最近的理论研究（2025; Kleinberg and Mullainathan, 2024）形式化了一致性（consistency）（避免无效输出）和广度（breadth）（生成多样化、语言丰富的内容）之间的内在权衡
    • 这些工作表明，对于广泛的语言类别，任何泛化超出其训练数据的模型要么会产生无效输出的幻觉，要么遭受模式崩溃（mode collapse），无法产生全部的有效响应
  • 几种后训练技术已被证明可以减少幻觉
    • 例如 RLHF （2022）、AI 反馈强化学习（Reinforcement Learning from AI Feedback, RLAIF）（2022）和直接偏好优化（Direct Preference Optimization, DPO）（2023），包括阴谋论和常见误解
    • Gekhman 等 (2024) 表明，对新信息进行简单的微调最初可以降低幻觉率，但随后又会增加
    • 此外，已经证明自然语言查询和内部模型激活都编码了关于事实准确性和模型不确定性的预测信号（例如，2022）
    • 正如论文的引言中所讨论的，模型对语义相关查询的回答的不一致性也可以用来检测或减轻幻觉（2023; 2025; 2024）
  • 许多其他方法已被证明可有效减轻幻觉；
    • 例如：参见 Ji 等 (2023) 和 Tian 等 (2024) 的综述
  • 在评估方面，最近引入了一些全面的基准测试和排行榜（例如，2025; 2024），但相对较少的工作研究了它们采用的障碍
    • 例如：2025 年 AI 指数报告（2025）指出，幻觉基准测试“难以在 AI 社区内获得关注”
  • 除了确定性的二元表达之外，还提出了更细微的语言结构来传达不确定性的程度（2022; 2022a; 2025）
  • 此外，语用学（pragmatics）领域，研究意义如何由语境塑造，对于理解和改进语言模型传达信息的方式具有越来越大的相关性（2025）

Pretraining Errors

  • 预训练会生成一个基础语言模型 \(\hat{p}\)，该模型近似于从其训练分布 \(p\) 中抽取的文本分布
    • 这是无监督学习中的经典“密度估计”问题，其中密度（density）就是数据上的概率分布
    • 对于语言模型而言，该分布是关于文本的，如果包含多模态输入，则也关于多模态输入
  • 证明基础模型会出错的关键挑战在于，许多语言模型确实不会出错
    • 总是输出“我不知道”（IDK）的退化模型也能避免错误（假设 IDK 不算错误）
    • 同样，假设训练数据无误，那么简单地复述随机训练样本中文本的平凡基础模型也不会出错
  • 但这两个语言模型都未能实现密度估计，这是下面定义的统计语言建模的基本目标
    • 最优的基础模型 \(\hat{p}=p\)（与训练分布匹配）也能避免错误，但这个模型需要过高地巨量（prohibitively large）的训练数据
    • 论文表明，训练良好的基础模型仍然应该产生某些类型的错误
  • 论文的分析表明，生成有效输出（即避免错误）比分类输出有效性更困难
    • 这种归约使论文能够将计算学习理论（其中错误是预期且被理解的）的视角应用于生成模型中的错误机制
    • 语言模型最初被定义为文本上的概率分布，后来提示（prompts）被纳入其中（第 3.2 节）；
      • 两种设置共享相同的直觉
    • 没有提示的例子包括图 1 中的生日陈述，而有提示的模型可能会被查询特定个人的生日
  • 不仅仅是自动补全 (Not merely autocomplete)
    • 论文的分析适用于一般的密度估计，而不仅仅是“下一个词预测器”
    • 人们很容易将幻觉归因于选择了语言模型无法提供有效补全的糟糕前缀（例如，“Adam Kalai was born on”）
    • 但从纯粹的统计角度来看，忽略计算，语言模型的自动补全视图并不比人类说话者一次产生一个词这一事实更重要

      脚注：数学上，任何分布 \(p\) 都会为其支持集中的每个词前缀 \(w_{1}\dots w_{i-1}\) 诱导出一个补全分布 \(p(w_{i}w_{i+1}\dots \mid w_{1}w_{2}\dots w_{i-1})\)

    • 论文的分析表明，尽管特定的架构可能会引入额外的错误，但错误（主要）源于模型正在拟合底层语言分布这一事实

The reduction without prompts

  • 在没有提示词的情况下，基础模型 \(\hat{p}\) 是集合 \(\mathcal{X}\) 上的概率分布
  • 如前所述，每个样本（example）\(x\in \mathcal{X}\) 代表一个“看似合理”（plausible）的字符串，例如一个文档
  • 样本 \(\mathcal{X}=\mathcal{E}\cup\mathcal{V}\) 被划分为错误 \(\mathcal{E}\) 和有效样本 \(\mathcal{V}\)，其中 \(\mathcal{E},\mathcal{V}\) 是非空不相交的集合
  • 基础模型 \(\hat{p}\) 的错误率表示为：
    $$
    \text{err}:=\hat{p}(\mathcal{E})=\Pr_{x\sim\hat{p} }[x\in\mathcal{E}]. \tag{1}
    $$
  • 假设训练数据来自无噪声的训练分布（training distribution）\(p(\mathcal{X})\)，即 \(p(\mathcal{E})=0\)
    • 如前所述，对于含有错误和部分正确陈述的有噪声训练数据，人们可能会预期错误率甚至高于论文的下界
  • 论文现在形式化引言中介绍的 IIV（Is-It-Valid）二分类问题
    • IIV 由要学习的目标函数 \(f:\mathcal{X}\rightarrow\{-,+\}\)（即属于 \(\mathcal{V}\) 的成员资格）和样本 \(\mathcal{X}\) 上的分布 \(D\)（来自 \(p\) 的样本和均匀随机错误的 50/50 混合）指定：
      $$
      D(x):=\begin{cases}p(x)/2&\text{if }x\in\mathcal{V},\ 1/2|\mathcal{E}|&\text{if }x\in\mathcal{E},\end{cases} \text{ and } f(x):= \begin{cases}+&\text{ if }x\in\mathcal{V},\ -&\text{ if }x\in\mathcal{E}.\end{cases}
      $$
  • 论文的分析根据 IIV 的上述误分类率（misclassification rate）\(\text{err}_{\text{Iiv} }\) 来界定错误率 \(\text{err}=\hat{p}(\mathcal{E})\) 的下界：
    $$
    \text{err}_{\text{Iiv} }:=\Pr_{x\sim D}\left[\hat{f}(x)\neq f(x)\right], \text{ where } \hat{f}(x):= \begin{cases}+&\text{ if }\hat{p}(x)>1/|\mathcal{E}|,\ -&\text{ if }\hat{p}(x)\leq 1/|\mathcal{E}|.\end{cases} \tag{2}
    $$
  • 因此，在论文的归约中，基础模型通过在一定阈值 \(1/|\mathcal{E}|\) 处对基础模型的概率进行阈值处理，被用作 IIV 分类器。请注意，对于基础模型，通常可以高效计算此类概率 \(\hat{p}(x)\)（尽管高效计算对于下界有意义并非必需）
  • 推论 1 (Corollary 1) ：对于任何满足 \(p(\mathcal{V})=1\) 的训练分布 \(p\) 和任何基础模型 \(\hat{p}\)，
    $$
    \textup{err}\geq 2\cdot\textup{err}_{\textup{Iiv} }-\frac{|\mathcal{V}|}{|\mathcal{E}|}-\delta,
    $$
    • 其中 \(\textup{err},\textup{err}_{\textup{Iiv} }\) 来自方程 (1) 和 (2)
    • 且 \(\delta:=|\hat{p}(\mathcal{A})-p(\mathcal{A})|\)
      • 其中 \(\mathcal{A}:=\{x\in\mathcal{X}\mid\hat{p}(x)>1/|\mathcal{E}|\}\)
    • 由于这种关系对任何基础模型 \(\hat{p}\) 都成立，它立即意味着所有基础模型都会在本质上不可学习的 IIV 事实（例如训练数据中缺失的生日）上出错，其中 \(\textup{err}_{\textup{Iiv} }\) 必然很大，并且 \(\delta\) 和 \(|\mathcal{V}|/|\mathcal{E}|\) 很小（例如，对于每个人，\(\mathcal{E}\) 中错误的生日声称数量是 \(\mathcal{V}\) 中正确数量的 364 倍，再加上 IDK）。上述推论显然是定理 1 的一个特例，该定理涵盖了包含提示的更一般情况。定理 2 随后使用这个一般结果为直观的特例提供下界。定理 3 和 4 处理小的 \(|\mathcal{E}|\)，例如，对于 True/False 问题，\(|\mathcal{E}|=1\)。上述界限中的常数 2 相对紧：对于大的 \(|\mathcal{E}|\) 和小的 \(\delta\)，对于不可学习的概念，\(\textup{err}_{\textup{Iiv} }\) 可能接近 \(1/2\)，而 \(\textup{err}\leq 1\)。推论 1 也意味着 \(\textup{err}_{\textup{Iiv} }\lesssim 1/2\)
  • 幻觉错误 (Hallucination errors)
    • 要将错误分析应用于幻觉，可以考虑将 \(\mathcal{E}\) 视为包含（一个或多个）看似合理的虚假陈述的看似合理的生成集合
    • 请注意，幻觉的一个常见替代定义是不基于训练数据（或提示）的生成
    • 幸运的是，上述下界也适用于这个概念，因为论文只假设了有效的训练数据，即生成的事实错误不能基于事实正确的训练数据
  • 校准 (Calibration)
    • 论文现在论证为什么 \(|\delta|\) 是一个（错误）校准的度量，并且在预训练后很小。注意，在没有任何语言知识的情况下，可以通过简单地采用均匀分布 \(\hat{p}(x)=1/|\mathcal{X}|\) 来实现 \(\delta=0\)，因此 \(\delta=0\) 并不要求 \(p=\hat{p}\)。审计员可以通过比较满足 \(\hat{p}(x)>1/|\mathcal{E}|\) 的训练样本 \(x\sim p\) 和合成生成 \(\hat{x}\sim\hat{p}\) 的比例来轻松估计 \(\delta\)。受 (Dawid, 1982) 的启发，可以类比于天气预报员预测每天下雨的概率。一个最低的校准要求是他们的平均预测是否与平均降雨比例相匹配。还可以要求这两者在预测 \(>t\)（对于某个阈值 \(t\in[0,1]\)）的日子里匹配。(Dawid, 1982) 提出了更严格的要求，即对于每个\(t\in[0,1]\)，在预测为 \(t\) 的日子里，大约有 \(t\) 比例的时间下雨
  • 这里有一个特别简单的理由说明为什么对于标准的预训练交叉熵目标，\(\delta\) 通常很小：
    $$
    \mathcal{L}(\hat{p})=\mathop{\mathbb{E} }_{x\sim p}[-\log\hat{p}(x)]. \tag{3}
    $$
  • 考虑将正标记样本的概率按因子 \(s>0\) 重新缩放并归一化：
    $$
    \hat{p}_{s}(x):\propto\begin{cases}s\cdot\hat{p}(x)&\text{if }\hat{p}(x)>1/|\mathcal{E}|,\ \hat{p}(x)&\text{if }\hat{p}(x)\leq 1/|\mathcal{E}|.\end{cases}
    $$
    • 那么，一个简单的计算表明，\(\delta\) 是损失关于缩放因子 \(s\) 的导数的大小，在 \(s=1\) 处求值：
      $$
      \delta=\left|\left.\frac{d}{ds}\mathcal{L}(\hat{p}_{s})\right|_{s=1}\right|.
      $$
  • 如果 \(\delta\neq 0\)，那么通过某个 \(s\neq 1\) 重新缩放将减少损失，因此损失不在局部最小值
    • 对于任何足够强大以近似这种简单重新缩放的语言模型类，局部优化应该产生小的 \(\delta\)
    • 请注意，\(\delta\) 是在单个阈值 \(t=1/|\mathcal{E}|\) 处定义的，比期望校准误差（Expected Calibration Error, ECE）等概念更弱，后者在阈值 \(t\) 上积分
  • 幻觉仅对基础模型是不可避免的 (Hallucinations are inevitable only for base models)
    • 许多人认为幻觉是不可避免的 (Jones, 2025; Leffer, 2024; 2024)，但可以很容易地创建一个非幻觉模型，使用问答数据库和计算器，回答一组固定的问题，如“金的化学符号是什么？”以及格式良好的数学计算，如“3 + 8”，否则输出 IDK
  • 此外，推论 1 的错误下界意味着不出错的语言模型必定未校准 ，即 \(\delta\) 必须很大
    • 正如论文的推导所示，校准，以及因此的错误，是标准交叉熵目标的自然结果
    • 确实，实证研究（图 2）表明，基础模型通常被发现是校准的，与后训练模型相反，后者可能偏离交叉熵而倾向于强化学习

The reduction with prompts

  • 此后，论文将第 3.1 节中的设置推广到包括从提示分布（prompt distribution）\(\mu\) 中抽取的提示（上下文）\(c\in\mathcal{C}\)
  • 每个样本 \(x=(c,r)\) 现在由一个提示 \(c\) 和一个看似合理的响应 \(r\) 组成
  • 上面的分析对应于 \(\mu\) 将概率 1 分配给空提示的特殊情况。对于给定的提示 \(c\in\mathcal{C}\)，令 \(\mathcal{V}_{c}:=\{r\mid(c,r)\in\mathcal{V}\}\) 为有效响应，\(\mathcal{E}_{c}:=\{r\mid(c,r)\in\mathcal{E}\}\) 为错误响应
  • 训练分布和基础模型现在是条件响应分布 \(p(r\mid c),\hat{p}(r\mid c)\)
  • 为符号方便，论文通过 \(p(c,r):=\mu(c)p(r\mid c)\) 和 \(\hat{p}(c,r):=\mu(c)\hat{p}(r\mid c)\) 将它们扩展到 \(\mathcal{X}\) 上的联合分布，因此仍然有 \(\operatorname{err}:=\hat{p}(\mathcal{E})=\sum_{(c,r)\in\mathcal{E} }\mu(c)\hat{p }(r\mid c)\) 且 \(p(\mathcal{E})=0\)
  • 因此，训练分布样本对应于有效的“对话”，就像在蒸馏（distillation）中一样 (2023; 2023)
  • 尽管假设训练数据包含来自相同提示分布的模型对话是不现实的，但当假设不成立时，可能会预期甚至更高的错误率
  • 带提示的 IIV 问题具有相同的目标函数 \(f(x):=+ \text{ iff } x\in\mathcal{V}\)，但广义分布 \(D\) 以相等的概率选择 \(x\sim p\) 或 \(x=(c,r)\)，其中 \(c\sim\mu\) 且 \(r\in\mathcal{E}_{c}\) 均匀随机
  • 最后，分类器 \(\hat{f}(c,r)\) 现在是 \(+\text{ iff }\hat{p}(r\mid c)>1/\min_{c}|\mathcal{E}_{c}|\)
  • 因此，推论 1 显然是以下定理的一个特例：
  • 定理 1 (Theorem 1) ：对于任何满足 \(p(\mathcal{V})=1\) 的训练分布 \(p\) 和任何基础模型 \(\hat{p}\)，
    $$
    \operatorname{err}\geq 2\cdot\operatorname{err}_{\mathrm{IIV} }-\frac{\max_{c}|\mathcal{V}_{c}|}{\min_{c}|\mathcal{E}_{c}|}-\delta,
    $$
    • 其中 \(\delta:=|\hat{p}(\mathcal{A})-p(\mathcal{A})|\)，且 \(\mathcal{A}:=\{(c,r)\in\mathcal{X}\mid\hat{p}(r\mid c)>1/\min_{c}|\mathcal{E}_{c}|\}\)
  • 推广重新缩放 \(\hat{p}_{s}(r\mid c)\)（对每个提示进行归一化，仍然使用单个参数 \(s\)）再次证明了小的 \(\delta=|\frac{d}{ds}\mathcal{L}(\hat{p}_{s})|_{s=1}|\)，现在对于 \(\mathcal{L}(\hat{p}):=\sum_{(c,r)\in\mathcal{X} }-\mu(c)\log\hat{p}(r\mid c)\)

Error factors for base models

  • 数十年的研究已经阐明了导致误分类（二分类中的错误）的统计因素
  • 我们可以利用这种先前的理解来列举幻觉和其他生成错误背后的因素，包括：统计复杂性，如生日（第 3.3.1 节）；糟糕的模型（poor models），如字母计数（第 3.3.2 节）；以及其他因素，如 GIGO（Garbage In, Garbage Out），如阴谋论（conspiracy theories，第 3.4 节）
Arbitrary-fact hallucinations（任意事实幻觉 ）
  • 当没有简洁的模式可以解释目标函数时，就存在认知不确定性（epistemic uncertainty），意味着必要的知识在训练数据中缺失。Vapnik-Chervonenkis 维度（VC dimension）(Vapnik and Chervonenkis, 1971) VC\((\mathcal{F})\) 描述了以高概率学习函数族 \(\mathcal{F}\)（其中 \(f:\mathcal{X}\rightarrow\{-,+\}\)） 所需的最坏情况样本数。具有高 VC\((\mathcal{F})\) 维度的族可能需要 prohibitively many 样本来学习。论文考虑高 VC 维的一个自然特例：随机的任意事实。特别是，本节考虑有效响应（除 IDK 外）在提示之间是随机且独立的
  • Definition 1 (Arbitrary Facts)
    • 以下内容是固定的：一个任意的提示分布 \(\mu(c)\)，一个 IDK 响应，并且对于每个提示 \(c\)：一个响应集 \(\mathcal{R}_{c}\) 和一个回答概率 \(\alpha_{c}\in[0,1]\)。对每个 \(c\) 独立地，以均匀随机方式选择一个正确答案 \(a_{c}\in\mathcal{R}_{c}\)。最后，对于每个 \(c\in\mathcal{C}\)，有 \(p(a_{c}\mid c)=\alpha_{c}\) 和 \(p(\textup{IDK}\mid c)=1-\alpha_{c}\)。因此 \(\mathcal{E}_{c}=\mathcal{R}_{c}\setminus\{a_{c}\}\) 且 \(\mathcal{V}_{c}=\{a_{c},\textup{IDK}\}\)
  • 假设陈述任何给定事实只有一种方式，这可以像主导的生日例子那样完成，其中格式是指定的。然而，论文再次注意到，人们可能会预期甚至更多的幻觉，如果有多种方式陈述每个事实。在固定格式生日的情况下，\(|\mathcal{E}_{c}|=364\)，并且生日经常被讨论的名人会有高的 \(\mu(c)\)。像爱因斯坦生日这样著名的生日会出现多次，而其他生日可能只出现一次，例如在讣告中。大型语言模型在经常被引用的事实上很少出错，例如爱因斯坦的生日或论文标题
  • 论文的幻觉下界基于在训练数据中仅出现一次的提示的比例，忽略 IDK
  • Definition 2 (Singleton rate)
    • 单例（singleton）的定义：如果一个提示 \(c\in\mathcal{C}\) 在 \(N\) 个训练数据 \(\big{\langle}(c^{(i)},r^{(i)})\big{\rangle}_{i=1}^{N}\) 中恰好出现一次且没有弃权，即 \(|\{i:c^{(i)}=c\wedge r^{(i)}\neq\mathrm{IDK}\}|=1\)
    • 令 \(\mathcal{S}\subseteq\mathcal{C}\) 表示单例集合，且训练单例的比例可表示为：
      $$
      \mathrm{sr}=\frac{|\mathcal{S}|}{N}
      $$
  • 单例率建立在艾伦·图灵（Alan Turing）优雅的“缺失质量”（missing-mass）估计量 (Good, 1953) 的基础上，该估计量衡量了在从分布中抽取的样本中仍未出现的结果被分配了多少概率
    • 具体来说，图灵对未见过事件概率的估计是恰好出现一次的样本的比例
    • 直观上，单例充当了在进一步抽样中可能遇到多少新结果的代理，因此它们的经验份额成为整个分布“缺失”部分的估计
  • 论文现在陈述论文对任意事实的界限
  • Theorem 2 (Arbitrary Facts)
    • 在任意事实模型中，任何接受 \(N\) 个训练样本并输出 \(\hat{p}\) 的算法满足，在 \(\vec{a}=\langle a_{c}\rangle_{c\in\mathcal{C} }\) 和 \(N\) 个训练样本上，以概率 \(\geq 99%\)：
      $$
      \mathrm{err}\geq\mathrm{sr}-\frac{2}{\min_{c}|\mathcal{E}_{c}|}-\frac{35+6\ln N}{\sqrt{N} }-\delta.
      $$
    • 此外，存在一种输出校准后的 \(\hat{p}\)（\(\delta=0\)）的高效算法，以概率 \(\geq 99%\)，
      $$
      \mathrm{err}\leq\mathrm{sr}-\frac{\mathrm{sr} }{\max_{c}|\mathcal{E}_{c}|+1}+\frac{13}{\sqrt{N} }.
      $$
    • 论文的早期版本提出了一个相关的定理，该定理省略了提示和弃权 (Kalai and Vempala, 2024)
    • 证明在附录 B 中。后续工作 (Miao and Kearns, 2025) 提供了对幻觉、单例率和校准的实证研究
Poor models
  • 当底层模型糟糕时，也可能出现误分类，因为：
    • (a) 模型族不能很好地表示概念，例如用线性分离器近似圆形区域，
    • (b) 模型族具有足够的表达能力，但模型本身拟合不佳
    • 不可知学习（Agnostic Learning）(1994) 通过定义给定分类器族 \(\mathcal{G}\)（其中 \(g:\mathcal{X}\rightarrow\{-,+\}\)） 中任何分类器的最小错误率来解决 (a)：
      $$
      \mathrm{opt}(\mathcal{G}):=\min_{g\in\mathcal{G} }\Pr_{x\sim D}[g(x)\neq f(x)] \in[0,1].
      $$
    • 如果 \(\mathrm{opt}(\mathcal{G})\) 很大，那么 \(\mathcal{G}\) 中的任何分类器都将具有高误分类率。在论文的情况下，给定一个由 \(\theta\in\Theta\) 参数化的语言模型 \(\hat{p}_{\theta}\)，考虑阈值化语言模型分类器族：
      $$
      \mathcal{G}:=\big{\{}g_{\theta,t}\ \mid\ \theta\in\Theta,t\in[0,1]\big{\} },\text{ Where } g_{\theta,t}(c,r):= \begin{cases}+&\text{ if }\hat{p}_{\theta}(r\mid c)>t,\\ -&\text{ if }\hat{p}_{\theta}(r\mid c)\leq t.\end{cases}
      $$
    • 根据定理 1 立即得出：
      $$
      \operatorname{err}\geq 2\cdot\mathrm{opt}(\mathcal{G})-\frac{\max_{c}|\mathcal{V}_{c}|}{\min_{c}|\mathcal{E}_{c}|}-\delta.
      $$
    • 当每个上下文恰好存在一个正确响应时（即标准多项选择，没有 IDK），可以移除校准项，并且即使对于 \(C=2\) 个选择也可以实现界限
  • Theorem 3 (Pure multiple-choice)
    • 假设对所有 \(c\in\mathcal{C}\) 有 \(|\mathcal{V}_{c}|=1\)，并令 \(C=\min_{c}|\mathcal{E}_{c}|+1\) 为选择数。那么，
      $$
      \operatorname{err}\geq 2\left(1-\frac{1}{C}\right)\cdot\mathrm{opt}(\mathcal{G})
      $$
    • 为了说明，考虑经典的三元组语言模型（trigram language model），其中每个词仅根据前两个词预测，即上下文窗口只有两个词。三元组模型在 1980 年代和 1990 年代占主导地位。然而，三元组模型经常输出不合语法的句子。考虑以下提示和响应：
      $$
      c_{1}=\text{She lost it and was completely out of}\ldots \quad c_{2}=\text{He lost it and was completely out of}\ldots \\
      r_{1}=\text{her mind.} \quad r_{2}=\text{his mind.}
      $$
      • 这里，\(V_{c_{1} }:=E_{c_{2} }:=\{r_{1}\}\) 且 \(V_{c_{2} }:=E_{c_{1} }:=\{r_{2}\}\)
  • 推论 2 (Corollary 2)
    • 令 \(\mu\) 在 \(\{c_{1},c_{2}\}\) 上均匀分布。那么任何三元组模型必须具有至少 1/2 的生成错误率
    • 这由定理 3 得出，因为对于三元组模型，\(C=2\) 且 \(\mathrm{opt}(\mathcal{G})=1/2\)。定理 3 和推论 2 的证明在附录 C 中。尽管 \(n\)-gram 模型对于更大的 \(n\) 可以捕获更长范围的依赖关系，但数据需求随 \(n\) 呈指数级增长
    • 论文现在重新审视引言中的字母计数例子
    • 要看出这是一个糟糕的模型问题，请注意 DeepSeek-R1 推理模型能够可靠地计数字母，例如，生成一个包含以下内容的 377 步思维链（chain-of-thought）：

      Let me spell it out: D-E-E-P-S-E-E-K.
      First letter: D — that’s one D. Second letter: E — not D. Third letter: E — not D. . .
      So, the number of Ds is 1.

    • 假设有相似的训练数据，这表明 R1 是该任务比 DeepSeek-V3 模型更好的模型
    • 推理所克服的一个表征挑战是，现代语言模型通过词元（tokens）表示提示，例如 D/EEP/SEE/K，而不是单个字符 (DeepSeek-2025)

Additional factors

  • 错误可能由多种因素的组合引起，包括上面讨论的因素以及其他几个因素。这里，论文重点介绍几个
  • 计算困难性 (Computational Hardness)
    • 在经典计算机上运行的任何算法，即使是具有超人类能力的人工智能，也不能违反计算复杂性理论的定律
    • 确实，人工智能系统已被发现在计算困难的问题上出错 (2024)
    • 附录 D 的观察 2 说明了定理 1 如何应用于形式为 “\(c\) 的解密是什么？” 的难处理查询，其中 IDK 是一个有效答案
  • 分布偏移 (Distribution shift)
    • 二分类中一个众所周知的挑战是训练和测试数据分布经常不同 (Quinonero-2009; Moreno-2012)
    • 类似地，语言模型中的错误通常源于与训练分布显著不同的分布外（out-of-distribution, OOD）提示
    • 诸如“一磅羽毛和一磅铅哪个更重？”这样的问题在训练数据中可能不太可能出现，并可能在某些模型中引发错误答案
    • 类似地，分布偏移可能是上述字母计数例子的一个因素，尽管推理模型正确计数字母的事实表明糟糕的模型可能是更大的因素
  • GIGO: Garbage in, Garbage out
    • 大型训练语料库通常包含大量事实错误，这些错误可能会被基础模型复制
    • GIGO 对于分类和预训练的统计相似性是 self evident 的 ，因此论文不提供正式的处理
    • 但认识到 GIGO 是统计因素之一很重要，因为语言模型已被证明会复制训练数据中的错误 (2022b; 2021; 2025)
    • GIGO 也为后训练主题提供了一个自然的过渡，后训练减少了某些 GIGO 错误，例如常见的误解和阴谋论 (2022; OpenAI, 2025a; 2024)
    • 下一节解释了为什么一些幻觉会持续存在，甚至可能被当前的后训练流程加剧

Post-training and hallucination

  • Post-training应当将模型从类似于自动补全模型的训练方式转变为不会输出自信的错误信息（除非在适当情况下，例如被要求创作虚构内容）的模型
  • 但进一步减少幻觉将是一场艰苦的战斗，因为现有的基准测试（benchmark）和排行榜（leaderboard）强化了某些类型的幻觉
    • 论文讨论如何停止这种强化
  • 这是一个社会技术（socio-technical）问题，因为不仅现有的评估方法需要修改，而且这些更改需要在有影响力的排行榜中被采纳

How evaluations reinforce hallucination（评估也会强化幻觉的！）

  • 语言模型的二元评估（Binary evaluations）强加了一种错误的对错二分法（false right-wrong dichotomy），对表达不确定性、省略可疑细节或请求澄清的答案不予给分
    • 包括准确率（accuracy）和通过率（pass rate）在内的此类指标仍然是该领域的主流规范，如下文所述
  • 在二元评分（binary grading）下，弃权（abstaining）是严格次优的
    • IDK 类型的响应受到最大程度的惩罚，而过度自信的“最佳猜测”则是最优的
    • 其动机结合了两个理想因素：
      • (a) 语言模型输出内容的准确率，
      • (b) 响应的全面性
    • 但权衡 (a) 多于 (b) 对于减少幻觉至关重要
  • 形式上，对于任何给定的提示（prompt）\( c \) 形式的问题，用 \( \mathcal{R}_c := \{r \mid (c, r) \in \mathcal{X}\} \) 表示一组看似合理的响应（有效或错误）
  • 此外，假设存在一组看似合理的弃权响应 \( \mathcal{A}_c \subset \mathcal{R}_c \)（例如，IDK）
  • 如果 \( \{g_c(r) \mid r \in \mathcal{R}_c\} = \{0, 1\} \) 且对所有 \( r \in \mathcal{A}_c \) 有 \( g_c(r) = 0 \)，则称评分器（grader）\( g_c : \mathcal{R}_c \rightarrow \mathbb{R} \) 是二元的（binary）
  • 一个问题（problem）由 \( (c, \mathcal{R}_c, \mathcal{A}_c, g_c) \) 定义，其中应试者（test-taker）知道 \( c, \mathcal{R}_c, \mathcal{A}_c \)
  • 论文假设应试者知道评分标准是二元的，但并未被告知正确答案，即 \( g_c(r) = 1 \) 的答案
  • 应试者对正确答案的信念可以看作是关于二元 \( g_c \) 的后验分布 \( \rho_c \)
  • 对于任何此类信念，最优响应都不是弃权
  • 观察 1 (Observation 1).
    • 令 \( c \) 为一个提示，对于任何在二元评分器上的分布 \( \rho_c \)，最优响应都不是弃权，即
      $$
      \mathcal{A}_c \cap \operatorname*{arg,max}_{r \in \mathcal{R}_c} \mathbb{E}_{g_c \sim \rho_c}[g_c(r)] = \emptyset.
      $$
    • 尽管证明是平凡的（见附录 E），但观察 1 表明现有的评估方法可能需要修改
    • 表 2 总结了附录 F 中的简短元评估分析（short meta-evaluation analysis），发现绝大多数流行的评估都采用二元评分
    • 因此，当主要评估惩罚诚实报告置信度和不确定性时，额外的幻觉评估可能不足以解决问题
    • 这并不会贬低现有关于幻觉评估的工作，而是指出，即使是理想的幻觉评估和理想的后训练方法，产生了诚实的不确定性报告，仍然可能因为在绝大多数现有评估上表现较差而被淹没

显式置信度目标 (Explicit confidence targets)

  • 人类的测试同样大多是二元的，并且人们已经认识到它们也会奖励过度自信的虚张声势（bluffing）
  • 当然，考试只是人类学习的一小部分，例如，编造生日很快就会导致尴尬
  • 尽管如此，一些标准化的国家考试在操作或曾经操作时对错误答案进行惩罚（或等效地对弃权给予部分学分），包括印度的 JEE、NEET 和 GATE 考试；美国数学协会的 AMC 测试；以及早些年的美国标准化 SAT、AP 和 GRE 考试
  • 重要的是，评分系统在说明中明确说明，并且应试者通常知道置信度阈值（confidence threshold），超过该阈值进行最佳猜测是合理的
  • 类似地，论文建议评估在其说明中，在提示（或系统消息）内明确说明置信度目标（confidence targets）。例如，可以在每个问题后附加如下声明：

    仅当您的置信度 \( > t \) 时才回答，因为错误答案会被扣 \( t/(1-t) \) 分，正确答案得 1 分，回答“我不知道”得 0 分

  • \( t \) 有几个自然值，包括 \( t = 0.5 \)（惩罚 1 分），\( t = 0.75 \)（惩罚 2 分）和 \( t = 0.9 \)（惩罚 9 分）
  • 阈值 \( t = 0 \) 对应于二元评分，可以描述为，例如，“即使不确定也要做出最佳猜测，就像参加考试一样”
    • 一个简单的计算表明，提供一个答案的期望分数超过 IDK（分数 0）当且仅当其置信度（即正确的概率）\( > t \)
  • 此类惩罚在幻觉研究中已得到充分研究 (2023)。但论文建议两个具有统计意义的细微变化
    • 首先，论文建议在说明中明确置信度阈值 ，而先前的工作大多未在说明中提及置信度目标或惩罚
      • 一个值得注意的例外是 Wu 等 (2025) 的工作，他们引入了带有明确惩罚的“风险告知（risk-informing）”提示
      • 理想的惩罚可能反映现实世界中可能的危害，但这是不切实际的，因为它特定于问题、目标应用程序和用户群体
      • 如果在说明中没有透明地指定，语言模型创建者之间就很难就正确的阈值达成共识
      • 类似地，如果说明中错误答案会受到未明确的惩罚，学生可能会争吵说评分不公平
      • 相反，在每个问题的说明中明确指定置信度阈值支持客观评分，即使所选择的特定阈值有些武断甚至是随机的
        • 如果阈值是明确的，那么一个模型可能在所有阈值上都是最好的
      • 然而，如果未说明阈值，则存在固有的权衡（tradeoff），并且通常没有单个模型是最好的（除了总是正确的模型）
    • 其次，论文建议将置信度目标纳入现有的主流评估中 ，例如流行的 SWE-bench (2024)，它涉及软件补丁的二元评分，而大多数先前的工作在定制的幻觉评估中引入了隐式的错误惩罚
      • 仅仅添加具有隐式错误惩罚的评估会面临上述的准确率-错误权衡
      • 另一方面，将置信度目标纳入已建立且已在使用的评估中，可以减少对适当表达不确定性的惩罚
      • 因此，它可能会放大特定于幻觉的评估的有效性
  • 有了明确的置信度目标，存在一种行为对所有目标都是同时最优的——在其正确概率大于目标值的示例中输出 IDK
    • 让论文将其称为行为校准（behavioral calibration），而不是要求模型输出概率置信度 (2022a)，它必须制定出其置信度至少为 \( t \) 的最有用的响应
    • 行为校准可以通过比较不同阈值下的准确率和错误率来进行审计，并规避了可能存在指数级多种方式来表达正确答案的问题 (2024)
    • 现有模型可能会或可能不会表现出行为校准，但它可能被证明作为客观评估是有用的

Discussion and limitations

  • 由于幻觉的多面性，该领域很难就如何定义、评估和减少幻觉达成一致
  • 一个统计框架必须优先考虑某些方面而忽略其他方面，以求简单
  • 关于论文所用框架的范围和局限性，有几点需要注意

看似合理与无意义 (Plausibility and nonsense)

  • 幻觉是一种看似合理的虚假陈述，通过仅考虑看似合理的字符串 \( \mathcal{X} \)，论文的分析忽略了生成无意义字符串的可能性（ SOTA 语言模型很少生成）
  • 然而，定理 1 的陈述和证明在修改了无意义示例 \( \mathcal{N} \) 的定义后仍然成立，其中划分 \( \mathcal{X} = \mathcal{N} \cup \mathcal{E} \cup \mathcal{V} \)，\( \operatorname{err} := \hat{p}(\mathcal{N} \cup \mathcal{E}) \)，\( D(\mathcal{N}) = 0 \)，并假设 \( p(\mathcal{V}) = 1 \)

Open-ended generations

  • 为简单起见，论文给出的示例都面向单个事实问题
  • 然而，幻觉经常出现在开放式提示中，例如“写一篇关于……的传记”
  • 这可以通过将包含一个或多个错误陈述的响应定义为错误来融入论文的框架
  • 然而，在这种情况下，很自然地会根据错误的数量来考虑幻觉的程度

搜索（和推理）并非万能药 (Search (and reasoning) are not panaceas)

  • 许多研究表明，通过搜索或检索增强生成（Retrieval-Augmented Generation, RAG）增强的语言模型可以减少幻觉 (2020; 2021; 2021; Zhang and Zhang, 2025)
  • 但观察 1 适用于任意语言模型，包括具有 RAG 的模型
  • 特别是，当搜索未能产生自信的答案时，二元评分系统本身仍然会奖励猜测
  • 此外，搜索可能无助于解决计算错误，例如字母计数示例中的错误，或其他内在幻觉（intrinsic hallucinations）

Latent context

  • 有些错误无法仅通过提示和响应来判断
  • 例如，假设用户询问一个关于 phones 的问题，而语言模型提供了一个关于 cellphones 的响应，但该问题本意是关于 land lines（固定电话）
  • 这种模糊性不符合论文的错误定义，因为论文的定义不依赖于提示和响应之外的外部上下文
  • 将模型扩展以允许存在不属于给予语言模型的提示部分但可用于判断错误的“隐藏上下文”（hidden context），这将很有趣，这与偶然不确定性（aleatoric uncertainty）有关

A false trichotomy（三分法）

  • 论文的形式主义不区分不同严重程度或不确定性程度的错误
  • 显然，正确/错误/IDK 的类别也是不完整的
  • 尽管统计上的理想可能是在下游应用中按照作者希望评分语言模型的方式来评分每个评估，但显式的置信度目标为主流评估提供了一种实用的、客观的修改，并且错误的三分法至少可能提供一个 IDK 选项，而不像错误的二分法

Beyond IDK

  • 有许多表示不确定性的方法，例如 hedging（模糊限制）、省略细节和提问
  • 最终，语言模型可能会遵守诸如语言校准（linguistic calibration）之类的置信度概念 (2022; 2025)
  • 但语言的语用现象（pragmatic phenomena） (Austin, 1962; Grice, 1975) 是微妙的
  • 比如虽然在某些情况下语言模型明确陈述概率置信度估计可能有用 (2022a)，但这也可能导致不自然的话语
    • 例如，“我有 1/365 的把握确定 Kalai 的生日是 3 月 7 日” 论文侧重于关于说什么的顶层决策的统计因素

附录：附录部分待补充

附录 A：Proof of the main theorem

  • 论文现在证明主要定理
  • 定理 1 的证明 ：
    • 令 \(K:=\min_{c\in\mathcal{C} }|\mathcal{E}_{c}|\) 且 \(k:=\max_{c\in\mathcal{C} }|\mathcal{V}_{c}|\)。同时，回顾 \(\delta=|\hat{p}(\mathcal{A})-p(\mathcal{A})|\)，这可以等价地写为 \(\delta=|p(\mathcal{B})-\hat{p}(\mathcal{B})|\)，其中 \(\mathcal{A},\mathcal{B}\) 表示响应是高于还是低于阈值：
      $$
      \mathcal{A} :=\{(c,r)\in\mathcal{X}\mid\hat{p}(r\mid c)>1/K\} \\
      \mathcal{B} :=\{(c,r)\in\mathcal{X}\mid\hat{p}(r\mid c)\leq 1/K\}. \tag{4-5}
      $$
    • 将幻觉率和误分类率划分为高于和低于阈值的部分：
      $$\text{err}=\hat{p}(\mathcal{A}\setminus\mathcal{V})+\hat{p}(\mathcal {B}\setminus\mathcal{V})\\
      \text{err}_{\text{Hv} }=D(\mathcal{A}\setminus\mathcal{V})+D(\mathcal {B}\cap\mathcal{V}).$$
    • 在阈值以上，误分类 \(D(\mathcal{A}\setminus\mathcal{V})\) 是仅对满足 \((c,r)\in\mathcal{A}\) 且 \(r\in\mathcal{E}_{c}\) 的 \((c,r)\) 的 \(D(c,r)\) 求和——每个贡献 \(D(c,r)=\mu(c)/2|\mathcal{E}_{c}|\leq\mu(c)/2K\)
    • 但每个这样的误分类也对阈值以上的幻觉 \(\hat{p}(\mathcal{A}\setminus\mathcal{V})\) 贡献了 \(\mu(c)\hat{p}(r\mid c)\geq\mu(c)/K\)。因此，
      $$\hat{p}(\mathcal{A}\setminus\mathcal{V})\geq 2D(\mathcal{A}\setminus\mathcal{V})$$
    • 因此，只需证明在阈值以下：
      $$\hat{p}(\mathcal{B}\setminus\mathcal{V})\geq 2D(\mathcal{B}\cap\mathcal{V})- \frac{k}{K}-\delta. \tag{6}$$
    • 根据定义，\(2D(\mathcal{B}\cap\mathcal{V})=p(\mathcal{B}\cap\mathcal{V})=p(\mathcal{B})\)。同时，对于每个 \(c\)，最多有 \(|\mathcal{V}_{c}|\leq k\) 个有效响应，每个在 \(\mathcal{B}\) 中的响应满足 \(\hat{p}(r\mid c)\leq 1/K\)，所以 \(\hat{p}(\mathcal{B}\cap\mathcal{V})\leq\sum_{c}\hat{p}(c)k/K=k/K.\) 因此，
      $$
      \begin{align}
      2D(\mathcal{B}\cap\mathcal{V})-\hat{p}(\mathcal{B}\setminus \mathcal{V}) &=p(\mathcal{B})-\hat{p}(\mathcal{B}\setminus\mathcal{V}) \\
      &=p(\mathcal{B})-(\hat{p}(\mathcal{B})-\hat{p}(\mathcal{B}\cap \mathcal{V}))\\
      &\leq\delta+\hat{p}(\mathcal{B}\cap\mathcal{V})\leq\delta+\frac{k }{K}.
      \end{align}
      $$
    • 这等价于方程 (6)，证毕

附录 B: Arbitrary-facts analysis(任意事实分析)

  • 论文首先回顾 Good-Turing (GT) 缺失质量估计量 (Good, 1953) 及其保证 (McAllester and Ortiz, 2003)。在该设定中，从集合 \(\mathcal{S}\) 上的分布 \(\nu\) 中抽取 \(N\) 个独立同分布样本 \(s\sim\nu^{N}\)——不考虑弃权。缺失质量是从 \(\nu\) 中抽取的新样本不在训练样本 \(s\) 中的概率，其估计值 GT 是训练样本中恰好出现一次的样本所占的比例。论文首先陈述先前的保证，然后将其调整到论文带有弃权的设定中。(McAllester and Ortiz, 2003) 的一个保证可以表述为：
  • Corollary 3
    • (McAllester and Ortiz, 2003) 令 \(s\sim\nu^{N}\) 为从集合 \({\cal S}\) 上的分布 \(\nu\) 中抽取的 \(N\) 个独立同分布样本。令 \(M:=\Pr_{x\sim\nu}[x\notin s]\) 且 GT 为恰好出现一次的样本所占的比例。对于任意 \(\gamma\in(0,1]\)：
      $$\Pr_{s\sim\nu^{N} }\left[|M-\text{GT}|\leq\frac{1}{N}+2.42\sqrt{\frac{\ln(4/\gamma )}{N} }\right]\geq 1-\gamma.$$
  • 证明
    • 令 \(\overline{\text{GT} }:=\mathbb{E}[\text{GT}]\) 且 \(\overline{M}:=\mathbb{E}[M]\)。该推论是通过结合 \(M\) 和 GT 的集中界得到的。首先 (McAllester and Schapire, 2000) 的定理 1 表明：
      $$\overline{\text{GT} }-\overline{M}\in[0,1/N]$$
    • 然后，(McAllester and Ortiz, 2003) 的定理 10 和 16 意味着，以概率 \(\leq\exp(-N\varepsilon^{2})\)，\(M\) 将在任一方向上偏离 \(\overline{M}\) 超过 \(\varepsilon\)，两者结合，通过并集界，对于 \(\varepsilon:=\sqrt{\frac{\ln(4/\gamma)}{N} }\)，
      $$\Pr_{s\sim\nu^{N} }\left[|M-\overline{M}|\geq\sqrt{\frac{\ln(4/\gamma)}{N} } \right]\leq\frac{\gamma}{4}+\frac{\gamma}{4}=\frac{\gamma}{2}.$$
    • 继 (McAllester and Schapire, 2000)（引理 13）之后，McDiarmid 不等式 (McDiarmid, 1989) 直接暗示了 GT 的收敛性，因为改变任何一个样本最多只能将 GT 改变 \(2/N\)。因此，
      $$\Pr_{s\sim\nu^{N} }\left[|\text{GT}-\overline{\text{GT} }|\geq\sqrt{\frac{2\ln(4/\gamma)}{N} }\right]\leq 2\exp\left(-\frac{2\cdot\frac{2\ln(4/\gamma)}{N} }{4/N }\right)=\frac{\gamma}{2}.$$
    • 结合这三个显示的方程，通过并集界，得到
      $$\Pr_{s\sim\nu^{N} }\left[|\text{GT}-M|\geq\frac{1}{N}+(1+\sqrt{2})\sqrt{\frac{\ln(4/\gamma)}{N} }\right]\leq\frac{\gamma}{2}+\frac{\gamma}{2}=\gamma.$$
    • 最后，由 \(1+\sqrt{2}\leq 2.42\) 得出该推论
    • 论文现在将其扩展到包含一个不计算在 sr 中的弃权响应 IDK 的情况。具体来说，如果存在训练样本 \((c^{(i)},r^{(i)})\) 满足 \(c^{(i)}=c\) 且 \(r^{(i)}\neq\text{IDK}\)，则称查询 \(c\) 在训练数据中被回答，否则称为未回答。令
      $${\cal U}:={\cal C}\setminus\{c^{(i)}\mid i\leq N,r^{(i)}\neq\text{IDK}\}$$
    • 表示未回答查询的集合。当然，通过记忆已回答查询的 \(a_{c}\)，可以实现对已回答查询的完美分类准确性。论文将图灵的缺失质量 (MM) 估计扩展到弃权如下：
      $$\text{MM}:=\Pr_{(c,r)\sim p}[c\in{\cal U}\wedge r\neq\text{IDK}].$$
    • 论文类似地使用推论 3 来表明 sr 是 MM 的一个良好估计量：
  • Lemma 1
    • 对于所有 \(N\), \(\gamma\in(0,1]\)：
      $$\Pr\left[\left|\text{MM}-\text{sr}\right|\leq 4.42\sqrt{\frac{\ln(5/\gamma)} {N} };\right]\geq 1-\gamma.$$
  • 证明
    • 论文的 MM-sr 与标准的 \(M\)-GT 之间的唯一区别是论文忽略了弃权。为了调整先前的界限，考虑样本 \(s\)，它是通过将所有 \(x=(c,\text{IDK})\) 替换为简单的 \(x=\text{IDK}\)（对于任何 \(c\)）而得到的，但其他情况下保持 \(x\) 不变。这将所有 IDK 响应折叠成相同的样本。因此，GT 最多可能比 sr 多计算一个单例，
      $$\text{GT}-\text{sr}\in\left\{0,\frac{1}{N}\right\}.$$
    • 上述替换诱导了一个分布 \(\phi\)，其中 \(\phi(\text{IDK})=\sum_{e}\mu(c)p(\text{IDK}\mid c)\) 是弃权的概率。类似地，论文有 \(M-\text{MM}\in\{0,\phi(\text{IDK})\}\)，且如果 \(\text{IDK}\notin s\) 则 \(M-\text{MM}=\phi(\text{IDK})\)，这种情况发生的概率为 \((1-\phi(\text{IDK}))^{N}\)。但如果 \(\phi(\text{IDK})\geq\frac{1}{N}\ln\frac{5}{\gamma}\)，论文也有 \((1-\phi(\text{IDK}))^{N}\leq\gamma/5\)。因此，无论 \(\phi(\text{IDK})\) 的值如何，
      $$\Pr\left[M-\text{MM}\in\left[0,\frac{1}{N}\ln\frac{5}{\gamma}\right]\ \right] \geq 1-\frac{\gamma}{5}.$$
    • 结合以上两个显示的方程得到
      $$\Pr\left[\left|(M-\text{GT})-(\text{MM}-\text{sr})\right|\leq\frac{1}{N}\ln \frac{5}{\gamma}\right]\geq 1-\frac{\gamma}{5}.\tag{7}$$
    • 在 \(\frac{4}{5}\gamma\) 处应用推论 3 得到，
      $$\Pr\left[\ |M-\text{GT}|\leq\frac{1}{N}+2.42\sqrt{\frac{\ln(5/\gamma)}{N} } \ \right]\geq 1-\frac{4}{5}\gamma.$$
    • 结合方程 (7)，通过并集界和三角不等式，
      $$\Pr\left[\ |\text{MM}-\text{sr}|\leq\frac{1}{N}\ln \frac{5}{\gamma}+\frac{1}{N}+2.42\sqrt{\frac{\ln(5/\gamma)}{N} }\ \right]\geq 1-\gamma.$$
    • 最后，引理成立是因为对于 \(z:=\frac{2}{N}\ln \frac{5}{\gamma}\geq\frac{1}{N}\ln \frac{5}{\gamma}+\frac{1}{N}\)，只要 \(z\leq 1\)（否则引理平凡成立，因为界限 \(>2\)），论文有 \(z\leq\sqrt{z}\)
  • 引理 2 对于任意 \(N\geq 1\), \(\gamma\in(0,1]\)，以及任何输出 \(\hat{p}\) 的算法，
    $$\Pr\left[2\ \text{err}_{\textup{liv} }\geq\textnormal{sr}-\frac{6\ln(3N/\gamma )}{\sqrt{N} }\right]\geq 1-\gamma.$$
  • 证明 由引理 1，
    $$\Pr\left[\ |\text{MM}-\text{sr}|\leq 4.42\sqrt{\frac{\ln(10/\gamma)}{N} }\ \right]\geq 1-\frac{\gamma}{2}.$$
    • 注意对于 \(N\geq 2\) 有 \(\sqrt{\ln(10/\gamma)}\leq\ln(3N/\gamma)\)（且对于 \(N=1\) 引理平凡成立）。同时，\(\sqrt{2}+4.42\leq 6\)。因此，只需证明，
      $$\Pr\left[2\ \text{err}_{\textup{liv} }\geq\textnormal{MM}-\sqrt{\frac{2}{N} } \ln\frac{3N}{\gamma}\right]\geq 1-\frac{\gamma}{2}.$$
    • 令 \(\zeta:=\ln(3N/\gamma)/N\)，且根据 \(p\) 每个查询出现一个答案（非 IDK）的概率为：
      $$\mu^{\prime}(c):=\mu(c)\alpha_{c},$$
    • 因此一旦 \(a_{c}\) 被选定，\(\mu^{\prime}(c)=p(c,a_{c})\)。同时注意 \({\rm MM}=\sum_{c\in\mathcal{U} }\mu^{\prime}(c)\)。因此引理将由以下两个不等式得出：
      $$
      {\rm Pr}\left[\forall c\in\mathcal{U}{}\mu^{\prime}(c)\leq\zeta\right]\geq 1- \frac{\gamma}{3} \\
      {\rm Pr}\left[2,{\rm err}_{\rm liv}\geq{\rm MM}-\sqrt{\frac{2}{N} }\ln\frac{3N}{ \gamma}      {}\Bigg{|}{}\forall c\in\mathcal{U}{}\mu^{\prime}(c)\leq\zeta\right] \geq 1-\frac{\gamma}{6}. \tag{8-9}
      $$
    • \(\mu^{\prime}(c)\leq\zeta\) 条件将使论文能够使用 Hoeffding 界。对于方程 (8)，注意最多有 \(\leq 1/\zeta\) 个查询 \(c\) 满足 \(\mu^{\prime}(c)\geq\zeta\)。对于这些查询中的每一个，概率 \(c\in\mathcal{U}\) 最多为 \((1-\zeta)^{N}\)。因此，通过并集界，
      $${\rm Pr}\left[\exists c\in\mathcal{U}:~{}\mu^{\prime}(c)>\zeta\right]\leq\frac{1 }{\zeta}(1-\zeta)^{N}\leq\frac{1}{\zeta}e^{-\zeta N}=\frac{N}{\ln(3N/\gamma)} \frac{\gamma}{3N}\leq\frac{\gamma}{3},$$
    • 这等价于方程 (8)。论文现在继续建立方程 (9)
    • 令指示器 \({\rm I}[\phi]\) 在谓词 \(\phi\) 成立时表示 \(1\)，否则为 \(0\)。误差 \({\rm err}_{\rm liv}\) 至少是其对 \(c\in\mathcal{U},r\in\mathcal{R}_{c}\) 求和的误差，根据 \(D\) 的定义，即
      $$
      \begin{align}
      {\rm err}_{\rm liv} \geq\frac{1}{2}\sum_{c\in\mathcal{U} }\mu(c)\alpha_{c}{\rm I}[ \hat{f}(c,a_{c})=-]+\frac{1}{2}\sum_{c\in\mathcal{U} }\mu(c)\sum_{r\in\mathcal{R}_ {c}\setminus\{a_{c}\} }\frac{ {\rm I}[\hat{f}(c,r)=+]}{|\mathcal{R}_{c}|-1} \\
      \geq\frac{1}{2}\sum_{c\in\mathcal{U} }\mu^{\prime}(c){\rm I}[\hat {f}(c,a_{c})=-]+\frac{1}{2}\sum_{c\in\mathcal{U} }\mu^{\prime}(c)\sum_{r\in \mathcal{R}_{c}\setminus\{a_{c}\} }\frac{ {\rm I}[\hat{f}(c,r)=+]}{|\mathcal{R}_{ c}|-1} \\
      =\sum_{c\in\mathcal{U} }\mu^{\prime}(c)\gamma_{c}\ {\rm for}\ \gamma_ {c}:=\frac{1}{2}\left({\rm I}[\hat{f}(c,a_{c})=-]+\sum_{r\in\mathcal{R}_{c} \setminus\{a_{c}\} }\frac{ {\rm I}[\hat{f}(c,r)=+]}{|\mathcal{R}_{c}|-1}\right)
      \end{align}
      $$
    • 因此 \({\rm err}_{\rm liv}\geq\sum_{c\in\mathcal{U} }\mu^{\prime}(c)\gamma_{c}\)，其中 \(\gamma_{c}\) 如上定义，并且不难看出 \(\gamma_{c}\in[0,1]\)。（\(\mu^{\prime}(c)\leq\zeta\) 条件将使论文能够对 \(\sum\mu^{\prime}(c)\gamma_{c}\) 应用 Hoeffding 界。）因此，代替方程 (9)，只需证明，
      $${\rm Pr}\left[2\sum_{c\in\mathcal{U} }\mu^{\prime}(c)\gamma_{c}\geq{\rm MM}- \sqrt{\frac{2}{N} }\ln\frac{3N}{\gamma}{}\Bigg{|}{}\forall c\in\mathcal{U}~{} \mu^{\prime}(c)\leq\zeta\right]\geq 1-\frac{\gamma}{6}. \tag{10}$$
    • 现在是关键技巧：因为算法的输出独立于未见的 \(c\in\mathcal{U}\) 的 \(a_{c}\)，可以等价地想象在运行算法于训练数据上以选择决定 \(\hat{f}\) 的 \(\hat{p}\) 之后，才为未见的 \(c\in\mathcal{U}\) 选择 \(a_{c}\)。因此，让论文假设 \(c_{v}\) 将在稍后被选择用于 \(c\in\mathcal{U}\)，但训练数据以及因此的 \(\hat{f}\) 是已经固定的
    • 然后，论文观察到 \(\mathbb{E}[\gamma_{c}]=1/2\)，因为每个 \(r\in\mathcal{R}_{c}\) 对此期望贡献 \(1/2|\mathcal{R}_{c}|\)，无论它是 \(\hat{f}(c,r)=\pm\)。这给出 \(\mathbb{E}[\sum_{c}\mu^{\prime}(c)\gamma_{c}]={\rm MM}/2\)，因为 \({\rm MM}=\sum_{c}\mu^{\prime}(c)\)。最后，我们可以对 \(\sum_{c}\mu^{\prime}(c)\gamma_{c}\) 应用 Hoeffding 界，因为 \(\mu^{\prime}(c)\gamma_{c}\) 是独立的随机变量，每个在 \([0,\mu^{\prime}(c)]\) 中。该界限取决于，
      $$\sum_{c\in\mathcal{U} }(\mu^{\prime}(c))^{2}\leq\max_{c\in\mathcal{U} }\mu^{ \prime}(c)\sum_{c\in\mathcal{U} }\mu^{\prime}(c)\leq\max_{c\in\mathcal{U} }\mu^ {\prime}(c)\leq\zeta{}{\rm if}{}\forall c\in\mathcal{U}~{}\mu^{\prime}(c)\leq\zeta.$$
    • Hoeffding 界因此给出，
      $$\Pr\left[\sum\mu^{\prime}(c)\gamma_{c}\leq\frac{\text{MM} }{2}-\sqrt{\frac{\zeta \ln(6/\gamma)}{2} };\middle|;\forall c\in\mathcal{U};\mu^{\prime}(c)\leq\zeta \right]\leq\frac{\gamma}{6},$$
    • 这意味着方程 (10)，因为 \(\sqrt{2\zeta\ln(6/\gamma)}=\sqrt{2\ln(3N/\gamma)\ln(6/\gamma)/N}\leq\ln(3N/ \gamma)\sqrt{2/N}\)（对 \(N\geq 2\) 使用 \(\ln(6/\gamma)\leq\ln(3N/\gamma)\)，并且再次地，对于 \(N=1\) 引理平凡成立）
  • 论文现在证明定理 2
  • 定理 2 的证明 ：以下更一般的下界，对于任意 \(\gamma\in(0,1]\)，直接来自定理 1，其中 \(\max_{c}|\mathcal{V}_{c}|=2\)，以及引理 2。具体来说，以概率 \(\geq 1-\gamma\)：
    $$\operatorname{err}\geq\operatorname{sr}-\frac{2}{\min_{c}|\mathcal{E}_{c}|}- \frac{6\ln(3N/\gamma)}{\sqrt{N} }-\delta.$$
    • 对于 \(\geq 99%\) 的概率，在 \(\gamma=0.01\) 时，论文使用简化 \(6\ln(3N/\gamma)\leq 35+6\ln N\)。现在令 \(L:=\max_{c}|\mathcal{E}_{c}|\)
    • 对于上界，论文现在证明存在一个输出校准后的 \(\hat{p}\)（因此 \(\delta=0\)）的高效算法，并且以概率 \(\geq 1-\gamma\)，
    • $$\operatorname{err}\leq\operatorname{sr}-\frac{\operatorname{sr} }{L+1}+5\sqrt{ \frac{\ln(5/\gamma)}{N} }.$$
    • 定理中 \(99%\) 概率的界限来自 \(5\sqrt{\ln(500)}\leq 13\)
    • 校准后的语言模型学习算法会记忆训练数据中见过的 \((c,a_{c})\) 的 \(a_{c}\)，并且对于训练数据中见过的那些 \(c\notin\mathcal{U}\)，它与 \(p\) 完全一致。对于未见的 \(c\in\mathcal{U}\)，它以正确的概率 \(1-\alpha_{c}\) 弃权，否则在 \(\mathcal{R}_{c}\) 上均匀随机：
    • $$\hat{p}(c,r):=\begin{cases}1-\alpha_{c}&\text{If }r=\text{IDK}\ \alpha_{c}&\text{If }c\notin\mathcal{U},r=a_{c}\ \alpha_{c}/|\mathcal{R}_{c}|&\text{If }c\in\mathcal{U},r\in\mathcal{R}_{c}\ 0&\text{otherwise}\end{cases}.$$
    • 容易看出，对于这个 \(\hat{p}\)，
      $$\operatorname{err}=\sum_{c\in\mathcal{U} }\mu(c)\frac{\alpha_{c} }{|\mathcal{R}_ {c}|}(|\mathcal{R}_{c}|-1)\leq\sum_{c\in\mathcal{U} }\mu(c)\alpha_{c}\frac{L}{ L+1}=\text{MM}\frac{L}{L+1}.$$
    • 最后，由引理 1
      $$\Pr\left[|\text{MM}-\operatorname{sr}|\leq 5\sqrt{\frac{\ln(5/\gamma)}{N} } \right]\geq 1-\gamma.$$
    • 这些意味着，
      $$\Pr\left[;\operatorname{err}\leq\frac{L}{L+1}\operatorname{sr}+5\sqrt{\frac{ \ln(5/\gamma)}{N} }\right]\geq 1-\gamma.,$$
    • 如所需。剩下的只需证明对于所有 \(z\in[0,1]\) 有 \(\delta_{z}=0\)。根据 \(\delta_{z}\) 的定义，
      $$
      \begin{align}
      \delta_{z} &=\left|\Pr_{(c,r)\sim\hat{p} }\left[\hat{p}(r\mid c)>z\right]- \Pr_{(c,r)\sim p}\left[\hat{p}(r\mid c)>z\right]\right| \\
      &=\left|\sum_{c}\mu(c)\sum_{r:\hat{p}(r|c)>z}\left(\hat{p}(r\mid c)-p (r\mid c)\right)\right|
      \end{align}
      $$
    • 根据定义，除了 \(c\in\mathcal{U},r\in\mathcal{R}_{c}\) 之外，处处有 \(\hat{p}(r\mid c)=p(r\mid c)\)。但对于每个 \(c\in\mathcal{U}\)，\(\hat{p}(c,r)\) 在 \(r\in\mathcal{R}_{c}\) 上是常数，因此要么对所有 \(r\in\mathcal{R}_{c}\) 有 \(\hat{p}(c,r)>z\)，要么对所有都没有。因此上面的内和在任何情况下都是 0，因为 \(\sum_{r\in\mathcal{R}_{c} }\hat{p}(r\mid c)-p(r\mid c)=0\) 且 \(\hat{p}(\textrm{IDK}\mid c)=p(\textrm{IDK}\mid c)\)

附录 C: Poor-model analysis

  • 每个提示只有一个正确答案，就像多项选择题考试一样，直观上，如果唯一有效的响应是唯一的正确答案，并且无法可靠地区分正确答案和其他答案，则必须产生错误。对于这种简单情况，论文展示存在一个具有更好界限的阈值 \(t\)。特别地，令
    $$\operatorname{err}_{\textrm{liv} }(\hat{f}_{t}):=\Pr_{x\sim D }\left[\hat{f}_{t}(x)\neq f(x)\right],\text{ Where }\hat{f}_{t}(c,r):=\begin {cases}+&\text{If }\hat{p}(r\mid c)>t,\ -&\text{If }\hat{p}(r\mid c)\leq t.\end{cases}$$
    • 因此，对于论文正文中定义的 \(\hat{f}\)，有 \(\hat{f}=\hat{f}_{t}\)，其中 \(t=1/\min|\mathcal{E}_{c}|\)。论文现在陈述并证明一个比定理 3 更强的定理。定理 3 直接来自 \(\operatorname{opt}(\mathcal{G})\) 的定义和以下定理
  • 定理 4
    • 假设对所有 \(c\in\mathcal{C}\) 有 \(|\mathcal{V}_{c}|=1\)，并令 \(C=\min_{c}|\mathcal{E}_{c}|+1\) 为选项数量。那么，对于所有 \(p,\hat{p}\)，存在某个阈值 \(t\in[0,1]\) 使得：
      $$\operatorname{err}\geq 2\left(1-\frac{1}{C}\right)\operatorname{ err}_{\textrm{liv} }(\hat{f}_{t})._
    • 注意推论 2 的证明直接来自定理 4
  • 推论 2 的证明
    • 证明直接来自定理 4 以及 \(\operatorname{err}_{\textrm{liv} }(\hat{f}_{t})=1/2\) 的事实，因为基于三元语法模型的分类器 \(\hat{f}_{t}\) 无法区分 \(c_{1},c_{2}\)
  • 论文现在证明定理 4
  • 定理 4 的证明 考虑选取一个均匀随机的 \(t\in[0,1]\)。论文证明：
    $$\operatorname{err}\geq 2\left(1-\frac{1}{C}\right)\mathop{\mathbb{E} }_{t\in[0 ,1]}[\operatorname{err}_{\textrm{liv} }(\hat{f}_{t})],$$ (11)
    • 这意味着必须存在某个阈值 \(t\in[0,1]\) 使得该式成立。注意对于均匀随机的 \(t\in[0,1]\)，
      $$\Pr_{t\in[0,1]}\left[\hat{f}_{t}(c,r)=+\right]=\hat{p}(r\mid c).$$
    • 首先，期望假阳性率（误分类，其中 \(\hat{p}(r\mid c)>t\)）为：
      $$
      \begin{align}
      \Pr_{t\in[0,1],x\sim D}\left[\hat{f}_{t}(x)&=+,f(x)=-\right] =\frac{1}{2}\sum_{c}\mu(c)\sum_{r\in\mathcal{E}_{c} }\frac{1}{| \mathcal{E}_{c}|}\Pr_{t}\left[\hat{f}_{t}(c,r)=+\right] \\
      &\leq\frac{1}{2}\sum_{c}\mu(c)\sum_{r\notin\mathcal{A}_{c} }\frac{1}{ C-1}\hat{p}(r\mid c) \\
      &=\frac{1}{2(C-1)}\operatorname{err}.
      \end{align}
      $$
    • 其次，令每个 \(c\) 的 \(\mathcal{A}_{c}=\{a_{c}\}\)。那么期望假阴性率为，
      $$
      \begin{align}
      \Pr_{t\in[0,1],x\sim D}\left[\hat{f}_{t}(x)=-,f(x)=+\right] =\frac{1}{2}\sum_{c}\mu(c)\Pr_{t}\left[\hat{f}_{t}(c,a_{c})=-\right] \\
      &=\frac{1}{2}\sum_{c}\mu(c)\left(1-\hat{p}(a_{c}\mid c)\right)\\
      &=\frac{1}{2}\operatorname{err}.
      \end{align}
      $$
    • 因此，期望误分类率，即期望假阳性和假阴性率之和，满足：
      $$\mathbb{E}[\operatorname{err}_{\text{inv} }(\hat{f}_{t})]\leq\frac{1}{2}\left( \frac{1}{C-1}+1\right)\operatorname{err},$$
    • 重新排列项后，这等价于方程 (11)

附录 D: Computationally intractable hallucinations(计算上难解的幻觉)

  • 在本节中，论文提供一个关于计算难处理性的程式化例子（第 3.4 节）。(2024) 和 (2025) 研究了诱发幻觉的经验性难题的更自然例子
  • 一个安全的加密系统将具有以下属性：没有高效算法能够以优于随机猜测的方式猜出正确答案。一个（对称密钥）加密系统可以使两方以这样一种方式通信，即窃听者如果不知道共享密钥 \(S\)，就无法知道正在通信的内容。形式上，这样的设定具有消息集合 \(\mathcal{M}\)、密文集合 \(\mathcal{H}\)、加密函数 \(e_{S}:\mathcal{M}\rightarrow\mathcal{H}\) 和解密函数 \(d_{S}:\mathcal{H}\rightarrow\mathcal{M}\)，使得对所有 \(m\in\mathcal{M}\) 有 \(d_{S}(e_{S}(m))=m\)
  • 在幻觉的背景下，令 \(p\) 输出 \((c,r)\)，其中 \(r\in\mathcal{M}\) 是均匀随机的，提示 \(c\) 的形式为“What is the decryption of \(h\)?”（\(h\) 的解密是什么？），其中 \(h=e_{S}(r)\)。毫不奇怪，论文的主要定理意味着语言模型应该产生错误。在一个安全的系统中，不知道 \(S\) 就无法区分一对 \((m,e_{S}(m))\) 和 \((m,h)\)，其中 \(m\in\mathcal{M}\) 是一个均匀随机的消息，而 \(h\in\mathcal{H}\) 是一个不正确（或均匀随机）的密文。也就是说，无法区分真实通信的分布与不正确或随机通信的分布。这个公式匹配论文的分布 \(D\)，它以 \(1/2\) 的概率包含 \(x=(e(m),m)\)，以 \(1/2\) 的概率包含 \(x=(h\neq e(m),m)\)，其中 \(h\in\mathcal{H}\setminus\{e(m)\}\) 是均匀随机的。这对应于 \(\mu\) 的随机提示，并且目标函数 \(f(h,r)=+\text{ 当且仅当 }h=e(r)\)。标准硬度安全性定义的一种形式如下（参见，例如，Goldreich, 2001）：
  • 定义 3 (安全加密)。令 \(\beta\in[0,1]\)。如果分类器 \(\hat{f}:\mathcal{X}\rightarrow\{+,-\}\) 满足
    $$\Pr_{x\sim D}[\hat{f}(x)\neq f(x)]\leq\frac{1-\beta}{2},$$
    • 则称其 \(\beta\)-攻破该加密方案
    • 如前所述，一个随机分布 \(\hat{p}\) 具有 \(\delta=0\)，无论 \(t\) 如何，因此很容易产生弱校准的响应。然而，假设无法攻破密码系统，则没有校准的语言模型能够正确回答此类提示。利用这些定义，定理 1 立即暗示了以下内容，使用 \(|\mathcal{V}_{c}|=2\) 和 \(|\mathcal{E}_{c}|=|\mathcal{M}|-1\)：
  • 观察 2 ：对于任意 \(\beta\in[0,1]\) 和任意语言模型 \(\hat{p}\)，如果分类器 \(\hat{f}\) 没有 \(\beta\)-攻破加密安全性，则 \(\hat{p}\) 将以至少以下面的概率输出错误的解密 \(r\)
    $$1-\beta-\frac{2}{|\mathcal{M}|-1}-\delta.$$
  • 这个程式化的例子说明了论文的归约如何应用于计算难题，以及来自监督学习的计算难度如何与作为幻觉因素的计算难度相平行

附录 E：Post-training analysis

  • 以下是观察 1 的简短证明
  • 观察 1 的证明 假设对于所有 \(r\in\mathcal{A}_{c}\) 和每个二元评分器 \(g_{c}\)，有 \(g_{c}(r)=0\)，并且假设每个二元评分器 \(g_{c}\) 在某个值 \(r\in\mathcal{R}_{c}\setminus\mathcal{A}_{c}\) 处取 \(g_{c}(r)=1\)。此外，由于假设 \(\mathcal{X}\) 是有限的，必须存在某个这样的 \(r\)，其满足 \(\Pr_{g_{c}\sim\rho_{c} }[g_{c}(r)=1]>0\)。这来自并集界：
    $$\sum_{r\in\mathcal{R}_{c} }\Pr_{g_{c}\sim\rho_{c} }[g_{c}(r)=1]\geq\Pr_{g_{c}\sim \rho_{c} }[\exists r~{}g_{c}(r)=1]=1.$$
  • 因此，所有 \(r\in\mathcal{A}_{c}\) 在期望得分方面都是严格次优的

附录 F：Current grading of uncertain responses

  • 论文现在回顾有影响力的评估，以确定奖励猜测或虚张声势的二元评分很普遍
    • 最近语言模型评估激增，但语言建模领域关注相对较少的基准测试
  • 在这里，论文检查流行的排行榜，以了解有影响力的评估如何评分不确定的响应
  • 表 2（第 14 页）显示了此处选择的十项评估
    • 只有一项包含在其中一个排行榜中的评估，WildBench (2025)，为表示不确定性提供了最低限度的分数
    • 注意两个策划的排行榜有 50% 的重叠（前三项评估）
    • 作为对这些评估所受关注的进一步证据，请注意谷歌最新的语言模型卡片（Gemini 2.5 Pro, Google DeepMind, 2025）包含了 GPQA、MMLU、SWE-bench、HLE 和 AIME（类似于 MATH L5）的结果
    • OpenAI 同样发布了 GPQA (OpenAI, 2024)、经过验证的 MMLU 和 SWE-bench (OpenAI, 2025c)、IFEval (OpenAI, 2025c)、MATH (OpenAI, 2023b) 和 HLE (OpenAI, 2025c) 的结果
    • 斯坦福大学的 2025 年 AI 指数报告 (2025) 包含了 MMLU-Pro、GPQA、WildBench、MATH、SWE-bench 和 HLE 的结果
  • 注意，其中许多评估使用语言模型来评判输出，例如，确定答案的数学等价性，如 1.5 和 3/2
    • 然而，即使对于数学问题，也发现 LM 评判者会错误地评判答案，有时会将错误的长篇回答评分为正确 (2025)
    • 评估的这个方面可能会鼓励幻觉行为，即使在数学等客观领域也是如此

HELM Capabilities Benchmark

  • 语言模型整体评估 (HELM 2023) 是一个成熟且广泛使用的评估框架
  • 他们的“旗舰”能力排行榜，在其排行榜中列在首位，旨在“捕捉论文对通用能力评估的最新思考”
    • 它由五个场景组成，其中四个明确不给 IDK 加分，其中一个似乎给 IDK 的分数低于包含事实错误或幻觉的公平响应，因此也鼓励猜测
  • 具体来说，它包含一组场景，选择如下

    对于每项能力，论文从现有文献中的可用场景中选择一个场景，考虑因素包括：1）它是否饱和，基于最先进模型的性能，2）其最近性，由发布日期决定，以及 3）其质量，基于其清晰度、采用度和可复现性。总共有 22 个模型在 5 个以能力为重点的场景上进行了基准测试。(2025)

  • 该基准测试包括五个场景
    • 前四个几乎不给 IDK 加分。MMLU-Pro (2024) 和 GPQA (2024) 像标准的多项选择题考试一样评分，没有 IDK 选项
    • Omni-MATH (2024a) 将数学问题的输出与真实答案进行比较，因为可以有多种等效的方式来表示相同的量，例如 \(1+\pi=\pi+1\)，没有给 IDK 特别的加分
  • IFEval (2023)
    • 要求生成遵循若干指令的文本，没有任何特定的弃权选项。示例指令是：

      写一篇 300+ 字的维基百科页面摘要……不要使用任何逗号，并用 markdown 格式突出显示至少 3 个有标题的部分……

    • 然后使用多个语言模型对答案进行指令遵循准确性评分
      • 可以想象，尽管不太可能且非本意，像 IDK 这样的弃权字符串会被认为是足够的
  • WildBench (2025) 是最相关的场景，因为它使用评分者语言模型（grader language models），去评估语言模型对真实用户聊天的响应。评分标准采用 10 分制，说明包括：
    • 分数 1~2：响应非常差，完全不合理
    • 分数 3~4：响应较差，没有有意义地帮助用户解决问题
    • 分数 5~6：响应公平但存在一些问题（例如，事实错误、幻觉、缺少关键信息）
  • 由于 IDK 响应没有有意义地帮助用户解决问题，它可能被评分（3-4），低于包含事实错误或幻觉的公平响应（5-6）。因此，评分可能会鼓励猜测
  • HELM 实际上是庞大的，包含数百个高质量的评估，但由于成本和关注度的限制，复杂的评估由小得多的排行榜总结
    • 作者检查了其网站上首要推荐的排行榜，但 HELM 中有一小部分场景特别允许“我不知道”响应
    • 例如，著名的 QA 偏见基准测试 (BBQ) 评估 (2022)，包含在安全排行榜中，包含许多明确将正确答案列为 IDK 的问题，例如：一名基督徒和一名穆斯林都被看到在炸弹爆炸后立即逃离犯罪现场。谁可能放置了炸弹？

Open LLM Leaderboard

  • 流行的 Open LLM Leadboard (2024) 是最著名的排行榜之一，为开源语言模型提供了一个可复现的标尺，其最新版本对六个知名多任务基准测试的性能进行了平均
    • 与 HELM 类似，它代表了来自 EluetherAI 的 LM 评估工具 (2024b) 的更庞大评估集合的一个子集
    • 也与 HELM 类似，任务的选择满足若干标准，包括高质量、广泛使用、可靠性和公平性、可复现性以及避免饱和。这六个基准测试是：MMLU (2021)、HellaSwag (2019)、ARC-Challenge (2018)、WinoGrande (2021)、TruthfulQA (2022) 和 GSM8K (2021)
  • 这些基准测试中没有一个明确奖励 IDK 响应
    • MMLU、HellaSwag、ARC-Challenge、WinoGrande 和 GSM8K 都像多项选择题考试一样评分，没有 IDK 选项
    • TruthfulQA 评估模型是否对“虚假信念”产生幻觉，评分标准是模型是否输出正确答案，而不是 IDK

F.3 SWE-bench 与 Humanity’s Last Exam（Humanity’s Last Exam）

  • SWE-bench (2024) 已成为最具影响力的编程基准测试和排行榜之一
    • 它包含来自 GitHub issue 的 2,294 个软件工程问题。其评分基于准确率，因此不会区分错误补丁和表示不确定性的回答
  • Humanity’s Last Exam（HLE, 2025）的创建是为了解决主流评估中顶级语言模型近乎完美的表现问题
    • 该评估包含来自数十个领域的 2,500 个问题，范围从数学到人文学科再到社会科学
    • 一个私有测试集被保留，以便在问题泄露到训练数据中时检测过拟合
    • HLE 是 Scale AI 网站当前首要展示的排行榜，并已在 OpenAI (OpenAI, 2025c) 和 Google (Google DeepMind, 2025) 的语言模型报告中得到介绍
    • 与大多数评估一样，其主要指标是二元准确率，不为“我不知道”（IDK）回答提供任何分数
    • 截至撰写论文时，所有报告的 HLE 准确率得分均低于 30%
  • 有趣的是，HLE 还提供了一个校准误差（calibration error）指标，用于确定模型的校准错误程度
    • 当前的校准性能也很低，大多数模型的校准错误率超过 70%
    • 虽然如作者所述 (2025)，校准误差可能“暗示了虚构/幻觉（confabulation/hallucination）”，但它仅衡量了事后（post-hoc）准确率概率估计的糟糕程度
  • 校准误差并非一个合适的幻觉指标，因为：
    • 如果一个模型总是生成错误答案并对每个答案表示 0% 的置信度，那么即使它 100% 地产生幻觉，其校准误差也可以为 0
      • 虽然事后置信度评估可能有用，但在许多应用中，可能更倾向于保留此类答案而不是提供给用户，尤其是那些忽视低置信度警告的用户
    • 如果一个模型总是生成正确答案但对每个答案表示 0% 的置信度，那么即使它从不产生幻觉，其校准误差也可以为 100%

附录：Why language models hallucinate 博客内容

什么是幻觉现象？

  • 在 OpenAI，研究人员正全力以赴让人工智能系统变得更实用、更可靠；虽然语言模型的能力不断提升，有一个难题始终难以彻底解决，那就是“幻觉现象（hallucinations）”
  • 所谓“幻觉现象”，指的是模型笃定地生成与事实不符答案的情况

    Even as language models become more capable, one challenge remains stubbornly hard to fully solve: hallucinations. By this we mean instances where a model confidently generates an answer that isn’t true

  • 作者最新发表的研究论文 Why Language Models Hallucinate, 20250904 指出，语言模型产生幻觉现象，根源在于标准的训练与评估流程更倾向于鼓励“猜测（guessing）”，而非“承认不确定性（acknowledging uncertainty）”

    Our new research paper⁠(opens in a new window) argues that language models hallucinate because standard training and evaluation procedures reward guessing over acknowledging uncertainty.

  • ChatGPT 也存在幻觉现象，GPT-5 的幻觉现象显著减少，尤其是在推理过程中，但这一问题并未完全消失。对于所有大型语言模型而言，幻觉现象仍是一项根本性挑战，不过我们正努力进一步降低其发生率

What are hallucinations?

  • 语言模型产生的幻觉，是指其生成的内容看似合理、实则与事实相悖的表述；而且即便面对看似简单的问题，幻觉现象也可能以令人意外的方式出现

    Hallucinations are plausible but false statements generated by language models. They can show up in surprising ways, even for seemingly straightforward questions.

  • 例如，当我们向一款广泛使用的聊天机器人询问论文作者亚当·陶曼·卡莱（Adam Tauman Kalai）的博士论文标题时，它笃定地给出了三个不同答案，但没有一个是正确的；当我们询问他的生日时，机器人同样给出了三个不同日期，且全都是错误的

Teaching to the test（面向测试的训练）

  • 幻觉现象之所以难以根除，部分原因在于当前的评估方法设定了错误的激励导向
    • 尽管评估本身并不会直接导致幻觉现象，但大多数评估衡量模型性能的方式，都在鼓励“猜测”，而非“坦诚自身的不确定性”
  • 不妨将这种情况类比为一场选择题考试：
    • 如果你不知道答案，却随意猜一个选项，或许能侥幸答对；
    • 但如果留空不答，就必然得零分
    • 同理，当评估仅以“准确率”（即模型答对问题的百分比）作为衡量标准时，模型会更倾向于选择猜测，而非说出“我不知道”
  • 再举一个例子：
    • 若要求语言模型回答某人的生日，而它本身并不知道答案
    • 此时，如果它猜测“9月10日”，会有1/365的概率猜对；但如果回答“我不知道”，则必然得零分
    • 在数千道测试题的累积下，倾向于猜测的模型在评分榜单上的表现，会优于那些谨慎且愿意承认自身不确定性的模型
  • 对于存在唯一“正确答案”的问题，我们可将模型的回答分为三类：
    • 准确回答、错误回答，以及模型不做猜测的“弃权回答”
    • “弃权”体现了“谦逊”这一OpenAI的核心价值观
    • 大多数评分榜单会依据“准确率”对模型进行优先排序和评级，但实际上，“错误回答”的危害远大于“弃权回答”
    • OpenAI 的《模型规范》（Model Spec）明确指出：相较于笃定地提供可能有误的信息，表明自身的不确定性或请求进一步澄清，是更优的选择
  • 以《GPT-5系统报告》（GPT-5 System Card）中提及的 SimpleQA 评估为例，具体数据如下表所示：
    评估指标 gpt-5-thinking-mini OpenAI o4-mini
    弃权率（Abstention rate, 未给出具体答案（no specific answer is given）） 52% 1%
    准确率（Accuracy rate, 回答正确，越高越好） 22% 24%
    错误率（Error rate, 回答错误，越低越好） 26% 75%
    总计 100% 100%
  • 从准确率来看，早期的 OpenAI o4-mini 模型比 GPT-5 表现略优；但 o4-mini 错误率（即幻觉现象发生率）却显著更高
    • 这表明：当模型在不确定时选择“策略性猜测”，虽能提升准确率，却会同时增加错误率与幻觉现象的发生概率
  • 在综合数十项评估结果时，大多数基准测试会单独提取“准确率”这一指标，但这种做法实则构建了一种“非对即错”的错误二分法
    • 在 SimpleQA 这类相对简单的评估中，部分模型能实现接近 100% 的准确率，从而消除幻觉现象；
      • 但在更具挑战性的评估任务及实际应用场景中，准确率却难以达到 100%
    • 原因在于，部分问题的答案受多种因素限制而无法确定，例如信息缺失、小型模型的推理能力有限，或问题本身存在歧义需进一步澄清等
  • 尽管如此，以“准确率”为唯一核心的评分榜单仍在各类排行榜和模型报告中占据主导地位，这促使开发者在构建模型时更倾向于鼓励“猜测”，而非“克制”
    • 这也是为何即便模型日益先进，仍会产生幻觉现象——它们会笃定地给出错误答案，而非承认自身的不确定性

A better way to grade evaluations

  • 要解决这一问题，存在一种简单直接的方法：
    • 对“自信地回答错误（confident errors）”的惩罚力度，应大于对“不确定性表述（uncertainty）”的惩罚力度；同时，对“恰当表达不确定性”的行为给予部分分数奖励（注：这里的不确定性表述指的是不给出明确答案，类似 GPT-5 中的弃权率指标（Abstention rate））

      There is a straightforward fix. Penalize confident errors more than you penalize uncertainty, and give partial credit for appropriate expressions of uncertainty

  • 这一理念并非全新，长期以来，部分标准化考试已采用类似机制，例如对错误答案实行“扣分制”，或对未作答的题目给予部分分数，以此抑制盲目猜测
    • 此外，已有多个研究团队探索过将“不确定性”与“校准度”纳入考量的评估方式
  • 但论文想强调的重点有所不同：
    • 仅仅额外增加几项“关注不确定性”的新测试是远远不够的
    • 当前被广泛使用的、以“准确率”为核心的评估体系亟待更新，使其评分机制能够抑制“猜测”行为
    • 若主流评分榜单仍在奖励“侥幸猜对”的行为，模型就会持续养成“猜测”的习惯
    • 修正评分榜单，有助于推动各类“减少幻觉现象”的技术（无论是新研发的技术，还是过往研究中已有的技术）得到更广泛的应用

How hallucinations originate from next-word prediction

  • 问题：幻觉现象如何从“Next-word Prediction”中产生？
  • 以上已经探讨了幻觉现象难以根除的原因，那么，这些高度具体的事实性错误（highly-specific factual inaccuracies） ，最初究竟是如何产生的呢？
    • 毕竟，大型预训练模型很少出现拼写错误、括号不匹配这类其他类型的错误
    • 二者的差异，与数据中蕴含的“模式类型”密切相关
  • 语言模型的学习始于“预训练”阶段，这一过程通过对海量文本进行“Next-word Prediction”来实现
    • 与传统的机器学习问题不同，预训练阶段的每一条表述都没有“正确/错误”的标签（“true/false” labels）；
      • 所以：模型只能接触到“流畅语言”的正面示例，并需据此逼近语言的整体分布规律
    • 当没有任何“错误表述”的标注示例时，模型要区分“有效表述（valid statements）”与“无效表述”就变得加倍困难
    • 即便有了标注，某些错误也难以完全避免
      • 我们可以通过一个更简单的类比来理解这一点：在图像识别任务中，若数百万张猫和狗的照片都标注了“猫”或“狗”，算法就能可靠地学会对它们进行分类
      • 但试想一下，若改为用“宠物的生日”来为每张宠物照片标注：由于生日本质上是随机的，无论算法多么先进，这项任务始终会产生错误
  • 同样的原理也适用于预训练阶段：
    • 拼写规则与括号使用遵循固定的模式，因此随着模型规模扩大，这类错误会逐渐消失；
    • 但像“宠物生日”这样的“低频次随机事实”，无法仅通过模式预测得出，进而会导致幻觉现象
    • 作者的分析揭示了“Next-word Prediction”机制可能产生的幻觉类型
    • 理论上，预训练之后的后续训练阶段应能消除这些幻觉，但正如上一部分所阐述的，由于评估体系的问题，这一目标未能完全实现

Conclusions

  • 作者希望论文中提出的“统计学视角”，能帮助人们厘清幻觉现象的本质，并纠正一些常见的误解（misconceptions）
    • 下文中 Claim 特指没有证据的判断
  • Claim ：只要提升准确率，就能消除幻觉现象，因为100%准确的模型绝不会产生幻觉
    • Finding ：准确率永远无法达到100%。无论模型规模多大、搜索与推理能力多强，现实世界中总有部分问题本质上无法回答
  • Claim ：幻觉现象是不可避免的
    • Finding ：幻觉现象并非不可避免——语言模型在不确定时可以选择“弃权”
  • Claim ：要避免幻觉现象，需要具备一定程度的智能，而这种智能只有大型模型才能实现
    • Finding ：小型模型反而更容易认清自身的能力边界。例如，当被要求回答一道毛利语问题时，完全不懂毛利语的小型模型可以直接回答“我不知道”；而懂一些毛利语的模型，还需要额外判断自身的信心程度。正如论文中所探讨的，实现“校准度”（即模型信心与实际准确率匹配）所需的计算资源，远少于实现“高准确率”所需的资源
  • Claim ：幻觉现象是现代语言模型中一种神秘的故障
    • Finding ：我们已明确幻觉现象产生的统计学机制，以及评估体系对幻觉现象的“奖励”机制
  • Claim ：要衡量幻觉现象，只需设计一套优质的“幻觉评估体系”即可
    • Finding ：尽管已有“幻觉评估体系”相关研究发表，但面对数百项传统的、以“准确率”为核心（惩罚谦逊、奖励猜测）的评估，单一优质的“幻觉评估体系”影响力微乎其微。相反，所有核心评估指标都需要重新设计，以奖励“不确定性表述”
  • OpenAI 最新推出的模型已降低了幻觉现象的发生率，未来我们将继续努力，进一步减少语言模型输出“confident errors”的概率

本文主要介绍LLaMA-Factory项目训练和微调大模型的笔记

数据集准备

  • LLaMA-Factory 支持两种格式的文件，分别是 Alpaca 格式和 ShareGPT 格式

  • Alpaca示例（名称来源：alpaca是“羊驼”，llama是“大羊驼”）

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    [
    	{
    		"instruction": "人类指令（必填）",
    		"input": "人类输入（选填）",
    		"output": "模型回答（必填）",
    		"system": "系统提示词（选填）",
    		"history": [
    			["第一轮指令（选填）", "第一轮回答（选填）"],
    			["第二轮指令（选填）", "第二轮回答（选填）"]
    		]
    	}
    ]

  • ShareGPT示例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    [
    	{
    		"id": "对话ID", // 可选
    		"conversations": [
    			{
    				"from": "human",
    				"value": "用户消息"
    			},
    			{
    				"from": "gpt",
    				"value": "助手回复"
    			},
    			// 后续交替对话...
    		]
    	}
    ]

最佳实践：参照示例增加自定义数据集

  • 参照data/文件夹下的其他.json文件，准备自己的数据集，存储格式为json，命名为diy_train_data_name.json

  • 在data/dataset_info.json文件中增加一个dict对象，示例如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    "diy_train_data_name": {
    	"file_name": "your_data_name.json",
    	"file_sha1": "xxx", // 可选
    	"columns": {
    		"prompt": "prompt_key",
    		"query": "input_key", // 可选
    		"response": "output_key/response_key",
    		"system": "system_key", // 可选
    		"history": "history_key" // 可选
    	}
    }

命令行微调

  • 修改指定文档中的 .yaml 文件
  • 按照 README.md 文档执行命令

网页版LLaMA微调简单流程

启动web_ui

  • 启动web_ui的命令 
    1
    2
    unset http_proxy https_proxy all_proxy # 关闭代理
    python -m llmtuner.webui.interface

训练

  • 从base_path加载base模型到内存，变量命名为model
    • 如果要量化，记得配置量化选项，配置量化选项后可减少显存占用
  • 定义PEFT配置peft_config
    • 最常用的PEFT手段就是LoRA
  • 基于model和peft_config，生成peft_model
  • 生成数据集，并指定数据集对peft_model进行微调训练
  • 训练完成后，保存模型参数到指定peft模型路径peft_path（这一步只会保存微调参数，不会保存base模型参数）

推理

  • 从base_path加载base模型到内存，变量命名为model
    • 这里要求与训练配置完全一致（包括量化选项等配置必须一致）
  • 从peft_path加载PEFT模型到内存
    • 这一步需要将model和peft_path作为参数传入
  • 构造生成配置generation_config，配置可参考NLP——LLM推理时的生成方式
  • 调用model.generate()函数
    • 传入input信息和生成配置generation_config，得到Response

附录：记一个从ckpt加载训练的错误

附录：Qwen3 微调后不会输出停止 token

  • 相关问题链接：LLaMA-Factory/issues/589：基于预训练后的模型进行指令微调，预测时停不下来 #589

    Qwen-7B-Base 的分词器词表里没有 chatml 模板里的一些字符，所以会导致这种问题，因此应该避免使用 chatml 模板对 base 模型做微调。

  • 最终解法：LLaMA-Factory/issues/7943：Qwen3 not stopping generation after lora finetuning #7943

    Try setting the eos token in the tokenizer config to <|endoftext|> and using default template if you are fine-tuning base model using lora https://huggingface.co/Qwen/Qwen3-4B-Base/blob/main/tokenizer_config.json#L232

    • 理解：Qwen3-Base模型中没有 <|im_end|>，训练时应该使用 <|endoftext|>，但是Qwen3-Base模型的 tokenizer_config.json 中定义了 "eos_token":"<|im_end|>"（而default 模板在原始模型定义了 eos_token 时是不会修改原始模型的 eos_token 的），所以，需要手动改成 "eos_token":"<|endoftext|>"
      • 其他解法1：是修改 template 代码实现修改（比如基于 default 写一个新的模版，配置 replace_eos=True并使用 stop_words=["<|endoftext|>"]，此时会使用 template 的 stop_words 的第一个值赋值上去，用于主动修改替换值，但是改模型更合适
      • 其他解法2：直接删除原始模型中的 eos_token 字段应该也可行，此时模版会自动修改为 <|endoftext|>(详情见 template.py 中的 fix_special_tokens 函数)
    • 问题：为什么无法学习<|im_end|>，使用 tokenizer 命名可以编码<|im_end|>啊！
  • 注：在使用 instruct 的 Qwen，模型时，直接使用 qwen 模板即可，不会出现上述问题

附录：Tokenizer的结束符号由什么确定？

  • 一方面，模型的 tokenizer_config.json 等文件会影响结束符号 eos_token_id，另一方面，针对不同的 template，Tokenizer 的结束符号还会被修改
    • 以 SFT 为例，该修改发生在 sft/workflow.py 的 get_template_and_fix_tokenizer 函数中，对于配置了 replace_eos=True 的模板，会使用 template 的 stop_words 的第一个值赋值上去

附录：Qwen3 聊天模板的使用

  • Qwen3-Base模型中无法识别 <|im_end|> token，如果需要使用模型自带的模板训练，需要将Qwen3-Base模型的 tokenizer_config.json 相关字段（chat_template 和 eos_token中的 <|im_end|> 替换为 <|endoftext|>
  • 经过上述修改以后，可以使用模型的聊天模板进行对话

本文主要简单介绍 LLM 推理时的生成方式（偏简单记录）

整体说明

  • 说明：每一时间步都选择概率最大的词
  • 参数设置：do_sample = False, num_beams = 1
  • 缺点：生成文本可能出现重复现象
  • 此时，生成结果仅一条，若 num_return_sequences 参数大于1，代码会报错，说 Greedy Search 不支持这个参数大于 1
  • 注意：当 do_sample=False 时，temperature、top_k、top_p 等采样相关参数均不会生效
    • 因为这些参数的作用是 “调整概率采样的规则”，而 do_sample=False 本质是完全跳过 “概率采样” 流程，直接采用贪心搜索（每一步仅选概率最高的 token），自然无需依赖这些采样参数
    • 记忆：do_sample 是生成策略的 “总开关”，其优先级远高于 temperature/top_k/top_p
  • 说明：表示每一时刻均保留得分最高的 k 个序列，然后下一时刻用这 k 个序列继续生成
  • 参数设置：do_sample = False, num_beams = N (N > 1)
  • 缺点：仍然可能出现重复现象；会耗费更多算力
  • 此时，会生成多条结果

Multinomial sampling

  • 说明：多项式采样 ，每一个时间步，根据概率分布随机采样字（每个概率>0的字都有被选中的机会）
  • 参数设置：do_sample = True, num_beams = 1
  • 优点：解决了生成重复的问题
  • 缺点：可能会出现生成的文本不准守基本的语法

Beam-search multinomial sampling

  • 说明：Beam-search和Multinomial sampling的结合体，每个时间步从num_beams个字中采样
  • 参数设置：do_sample = True, num_beams = N (N > 1)
  • 优点：解决了重复生成的问题；效果相对num_beams=1效果也更好
  • 缺点：会耗费更多算力
  • 此时会同时生成多个结果，可通过参数num_return_sequences控制返回数量

惩罚重复：repetition_penalty

  • 说明：在每步时对之前出现过的词的概率做出惩罚，即降低出现过的字的采样概率，让模型趋向于解码出没出现过的词

  • 参数设置：repetition_penalty（float，取值范围>0）。默认为1，即代表不进行惩罚。值越大，即对重复的字做出更大的惩罚

  • 代码实现逻辑：

    1
    score = torch.where(score < 0, score*penalty, score/penalty)
    • 一般来说：penalty>1.0, 所以以下结论:
    • 如果字的概率score<0, 则score = score*penalty, 概率会越低；
    • 如果字的概率score>0, 则score = score/penalty, 同样概率也会变低

惩罚重复：presence_penalty

  • presence_penalty 是大模型里用来调节文本生成多样性的参数，
  • presence_penalty 作用机制是：如果某个 token 已经在已生成的文本中出现过，就给它的 logits 减去一个固定值（由 presence_penalty 控制）
    • 这样，模型会更倾向于选择那些还没出现过的新 token，从而减少重复、增加内容的新颖度
  • 取值范围：通常在 0 到 2 之间。0 表示不做任何惩罚，值越大越鼓励引入新概念
    • 经验值：从 0.5 开始尝试，若发现内容重复严重，可逐步提高到 1.0 左右；
    • 若希望更保守，可设为 0.1-0.3
  • 需结合 temperature 和 top_p 等其他参数一起调优
  • 问题：为什么范围规定为 0-2？理论上可以把 presence_penalty 设到 2 以上，但实际没必要，原因主要有三点：
    • 边际效应递减 ：随着值增大，对已出现 token 的惩罚强度线性增加，但带来的“新信息”增量却越来越小。超过 2 之后，几乎不会再显著提升多样性，反而容易让文本变得跳跃、不连贯
    • 稳定性风险 ：大模型本身对 logits 的微小变化就比较敏感。值过大（>2）会剧烈扭曲概率分布，导致生成结果不可控，甚至出现语法错误或逻辑断裂
    • 经验验证上限 ：主流框架（如 OpenAI、vLLM 等）在大量实验中发现，0–2 这个区间已经能覆盖从“轻微去重”到“强创新”之间的全部常用需求，因此把 2 设为硬上限，避免用户误用极端值

惩罚 n-gram：no_repeat_ngram_size

  • 说明：限制n-gram在生成结果中出现次数
  • 参数设置: no_repeat_ngram_size
    • 限制n-gram不出现2次。 (no_repeat_ngram_size=6即代表:6-gram不出现2次)
    • 用于控制重复词生成，默认是0，如果为N>0，则相应N-gram只出现一次
  • 要非常慎重使用

Temperature

  • 说明：通过温度，控制每个字的概率分布曲线。温度越低，分布曲线越陡峭，越容易采样到概率大的字。温度越高，分布曲线越平缓，增加了低概率字被采样到的机会
  • 参数设置：temperature（取值范围：0-1）设的越高，生成文本的自由创作空间越大；温度越低，生成的文本越偏保守
  • 本质是对softmax函数前的数据进行降温
    $$
    p_i = \frac{e^{\frac{y_i}{temperature}}}{\sum_i e^{\frac{y_i}{temperature}}}
    $$

Top-K 采样

  • 说明：每个时间步，会保留topK个字，然后对topk个字的概率重新归一化，最后在重新归一化后的这K个字中进行采样
  • 参数设置：top_k
  • 缺点：在分布陡峭的时候仍会采样到概率小的单词，或者在分布平缓的时候只能采样到部分可用单词
  • top_k=0（或 -1）：不限制，包含所有 token

Top-P 采样（又称 Nucleus Sampling）

  • 说明：每个时间步，按照字出现的概率由高到底排序，当概率之和大于top-p的时候，就不取后面的样本了。然后对取到的这些字的概率重新归一化后，进行采样
  • 参数设置：top_p (取值范围：0-1)
  • top-P采样方法往往与 top-K 采样方法结合使用，每次选取两者中最小的采样范围进行采样，可以减少预测分布过于平缓时采样到极小概率单词的几率

长度惩罚：length_penalty

  • 说明：长度惩罚，Exponential penalty to the length that is used with beam-based generation.

  • 仅在Beam Search的数量大于1时生效

  • 常规的Beam Search句子的得分为概率取对数再求和，是一个负数(由对数单调性可知选择更大的得分对应的序列)
    $$
    sumLogProbs = \sum_{t=1}^{T} \log P(y_t|y_0,y_1,\cdot,y_{t-1})
    $$

  • 进一步地，经过长度惩罚的分数修正如下：
    $$
    seqScore = \frac{sumLogProbs}{tokenLen^{length\_penalty}}
    $$

  • 所以length_penalty大于0时分母大于1且随长度单调递增，从而得分也随长度单调递增，等价于鼓励生成长文本。反之，鼓励生成短文本

  • 代码实现如下：

    1
    seq_score = sum_log_probs / len(hyp) ** self.length_penalty

  • 参数设置：length_penalty, 默认是1.0

    1
    2
    3
    4
    length_penalty=1.0 # beam search分数会受到生成序列长度的惩罚
    length_penalty=0.0 # 无惩罚
    length_penalty<0.0 # 鼓励模型生成短句子
    length_penalty>0.0 # 鼓励模型生成长句子

Megatron Core 是什么？

  • Megatron-Core，即 NVIDIA Megatron-Core，也称为 Megatron Core 或 MCore，是一个基于 PyTorch 的开源库，可在数千个 GPU 上以高速大规模训练大型模型
  • Megatron-Core 提供了先进的模型并行技术
    • 包括张量、序列、工作流、上下文和 MoE 专家并行等
    • 用户可以灵活结合不同的模型并行技术以适应训练工作负载
    • 还具备节省内存的功能，如激活重新计算、分布式优化器和分布式检查点等
  • Megatron-Core 通过模块化和可组合的 API 提供可定制的基础模组，对于 Transformer 模型，它提供注意力机制、归一化层、嵌入技术等
  • 借助 Megatron-Core（Mcore）规格系统，研究人员可以在 PyTorch 模型定义中轻松自定义所需抽象级别的子模块
  • Megatron-Core 是 Megatron-LM 的子集，即：
    • Megatron-LM 依赖 Megatron-Core 实现底层分布式逻辑；
    • 开发者可以单独使用 Megatron-Core，而无需引入 Megatron-LM 的全部功能

ModuleSpec 类的使用

  • ModuleSpec 是 Megatron-Core (Mcore) 引入的一个核心概念，旨在解决“如何在不修改底层代码的情况下灵活组合模型架构”的问题
    • 在传统的 PyTorch 开发中，如果你想把 LayerNorm 换成 RMSNorm，通常需要修改模型类的源码
    • 在 Megatron-Core 中，模型结构与具体实现是解耦的
  • ModuleSpec 是什么？
    • ModuleSpec 是一个配置容器，它告诉框架：“在这个位置，请使用这个类，并用这些参数初始化它”
    • ModuleSpec 允许用户通过配置文件或参数动态地“组装”模型，类似于乐高积木

ModuleSpec 的结构说明

  • ModuleSpec 主要包含三个核心参数：
    • module： 指定要实例化的类（例如 TransformerLayer, SelfAttention）
    • params： 一个字典，包含传递给该类 __init__ 方法的静态参数（例如 SelfAttention 常用到的 attn_mask_type）
    • submodules： 指定该模块内部子模块的实现方式
      • 理解：submodules 允许递归地定义整个网络结构

使用 ModuleSpec 定义 GPT 模型示例

  • 以一个简单的 Decoder-only Transformer GPT 模型定义为例

第一步：目标 GPT 类编写

  • 自己写一个简单的 GPT 模型类（后续用在 ModuleSpec 中） 
    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
    class DiySimpleGPTModel(MegatronModule):# 定义一个简单的 GPT 模型，继承 MegatronModule
        def __init__(
            self,
            config: ModelParallelConfig,
            embeddings: MegatronModule, # 由 ModuleSpec 创建并注入的嵌入模块
            decoder: MegatronModule, # 由 ModuleSpec 创建并注入的 TransformerBlock
            output_layer: MegatronModule, # 由 ModuleSpec 创建并注入的输出层
        ):
            super().__init__(config=config) # 调用父类构造函数，保存配置等
            self.embeddings = embeddings # 把注入进来的嵌入模块保存为成员变量
            self.decoder = decoder # 保存解码器（多层 Transformer）
            self.output_layer = output_layer # 保存输出层（LMHead）

        def forward( # forward 函数，用到上面定义的相关组件，后续这些组件会一个个定义
            self,
            input_ids: torch.Tensor, # 输入 token ids，形状 (batch, seq_len)
            position_ids: torch.Tensor = None, # 位置 ids（可选）
            attention_mask: torch.Tensor = None, # 注意力 mask（可选）
            labels: torch.Tensor = None, # 训练时使用的标签（可选）
        ):
            # 词嵌入 + 位置嵌入
            hidden_states = self.embeddings(input_ids=input_ids, position_ids=position_ids)

            # 通过多层 Transformer decoder
            hidden_states = self.decoder(hidden_states, attention_mask=attention_mask)

            # 输出层：hidden -> vocab logits
            logits = self.output_layer(hidden_states=hidden_states)

            # 如果没有 labels，说明不需要计算 Loss，直接返回 logits（推理模式）
            if labels is None:
                return logits # 返回 logits，形状 (batch, seq_len, vocab_size)

            # 如果有 labels，计算交叉熵损失（Megatron 的训练模式）
            loss_fn = nn.CrossEntropyLoss(ignore_index=-100) # 定义交叉熵损失，忽略 -100 标签
            loss = loss_fn( # 计算损失
                logits.view(-1, logits.size(-1)), # 仅保留最后一个维度，logits reshape 为 (batch*seq_len, vocab)
                labels.view(-1), # labels reshape 为 (batch*seq_len)，与 logits 对齐
            )
            return loss, logits # 同时返回 loss 和 logits

第二步：DiySimpleGPTModel 类的 ModuleSpec 定义

  • 写一个完整的 GPT ModuleSpec

    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
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    # 配置参数
    num_layers = 12 # Transformer 层数（例如 GPT-2 small：12 层）
    hidden_size = 768 # 隐层维度 d_model
    num_attention_heads = 12 # 注意力头数
    seq_length = 1024 # 最大序列长度
    vocab_size = 50257 # 词表大小（例如 GPT-2 的 BPE vocab）

    # 定义配置项 ModelParallelConfig
    config = ModelParallelConfig(
        num_layers=num_layers, # Transformer 层数
        hidden_size=hidden_size, # 隐藏维度
        num_attention_heads=num_attention_heads, # 注意力头数
        max_position_embeddings=seq_length, # 最大位置编码长度
        vocab_size=vocab_size, # 词表大小
    )

    # 定义单个 Transformer 层的 ModuleSpec
    transformer_layer_spec = ModuleSpec( # 创建一个 ModuleSpec，描述单层 Transformer
        module=TransformerLayer, # 指定使用 Megatron-Core 内的 TransformerLayer 类
        submodules={ # 定义该 Transformer 层包含的子模块
            "self_attention": ModuleSpec( # "self_attention" 与 TransformerLayer 类自身的属性名称相同
                module=SelfAttention, # 使用 SelfAttention 模块
                params={ # 传给 SelfAttention 构造函数的参数
                    "config": config, # 传入模型配置
                    "layer_number": 1, # 层号（可用于初始化不同随机种子等，这里简单写 1）
                },
            ),
            "mlp": ModuleSpec( # 前馈网络子模块的规格，注意："mlp" 与 TransformerLayer 类自身的属性名称相同
                module=MLP, # 使用 MLP 模块
                params={ # 传给 MLP 的参数
                    "config": config, # 传入模型配置
                },
            ),
        },
        params={ # 传给 TransformerLayer 自身的参数
            "config": config,
            "layer_number": 1,
        },
    )

    # 定义嵌入层的 ModuleSpec
    embeddings_spec = ModuleSpec( # 创建嵌入模块的 ModuleSpec
        module=LanguageModelEmbedding, # 使用 LanguageModelEmbedding（词嵌入 + 位置嵌入）
        params={
            "config": config,
            "rotary_pos_emb": RotaryPositionalEmbedding( # 传入 RoPE
                config=config # RoPE 也需要配置对象
            ),
            "use_position_embeddings": False, # 若想使用绝对位置编码，可以启用绝对位置嵌入，如果只想用 RoPE，设置 False
        },
    )

    # 定义 Decoder（多层 TransformerBlock）的 ModuleSpec 
    decoder_spec = ModuleSpec( # 创建 decoder 的 ModuleSpec
        module=TransformerBlock, # 使用 TransformerBlock（内部包含多层 TransformerLayer）
        params={ # 构造函数参数
            "config": config, # 传入配置
            "layer_spec": transformer_layer_spec, # 指定“每一层”的结构（即上面的 transformer_layer_spec）
            "num_layers": num_layers, # 总层数，理解：总层数 x 单层结构（transformer_layer_spec）= 整个 decoder 的结构
        },
    )

    # 定义输出层的 ModuleSpec 
    output_layer_spec = ModuleSpec(
        module=TransformerLanguageModelOutputLayer, # 使用标准语言模型作为输出层
        params={ # 构造函数参数
            "config": config, # 传入配置
        },
    )

    # 定义完整 GPT 模型的 ModuleSpec（关键部分）
    diy_simple_gpt_spec = ModuleSpec( # 创建整个 GPT 模型的 ModuleSpec
        module=DiySimpleGPTModel, # 总模块使用我们自定义的 DiySimpleGPTModel 类
        submodules={ # 声明该模型包含的子模块，注意名称与类对象名需要完全对齐，否则无法正确映射过去
            "embeddings": embeddings_spec, # embeddings 子模块的规格
            "decoder": decoder_spec, # decoder 子模块的规格
            "output_layer": output_layer_spec, # output_layer 子模块的规格
        },
        params={ # 传给 DiySimpleGPTModel 构造函数的额外参数
            "config": config, # 传入模型配置
        },
    )

  • 关键思路总结：

    • 先构造 ModelParallelConfig
    • 撰写三个 ModuleSpec：embeddings_spec, decoder_spec, output_spec
    • 撰写总的 diy_simple_gpt_spec = ModuleSpec(...) 指向 DiySimpleGPTModel，使用上面定义的三个 ModuleSpec 来定义

第三步：用 ModuleSpec 实例化模型

  • 用 ModuleSpec 实例化模型，尝试做一次推理和训练的前向过程 
    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
    # 用 ModuleSpec 构建真正的模型实例
    device = "cuda" if torch.cuda.is_available() else "cpu"

    model = diy_simple_gpt_spec.build_module() # 调用 diy_simple_gpt_spec（ModuleSpec 对象）的 build_module()，自动递归构建模型
    model = model.to(device)

    # 构造一个 fake batch 做前向推理
    batch_size = 2 # batch 大小
    test_seq_len = 16 # 测试序列长度（可以小于 config 中的 max_length）
    input_ids = torch.randint(
        low=0, # 最小 token id
        high=vocab_size, # 最大 token id（不含此值）
        size=(batch_size, test_seq_len), # 张量形状为 (batch_size, seq_len)
        device=device,
    )

    # 推理解码（不带 labels）
    with torch.no_grad(): # 关闭梯度计算，加速推理
        logits = model(input_ids=input_ids)
    print("logits shape:", logits.shape) # 打印 logits 形状，应该是 (batch_size, seq_len, vocab_size)

    # 训练模式（带 labels），用 input_ids 自回归做 labels
    labels = input_ids[:, 1:]
    input_ids = input_ids[:, :-1]
    loss, logits = model(input_ids=input_ids, labels=labels)
    print("loss:", loss.item())

本文主要介绍 LLM 对齐微调的 RLHF（即 PPO）训练方式，论文参考了一些优秀的技术博客，然后加入了自己的理解
注：本文包含 AI 辅助创作

概念

  • 对齐微调（Alignment tuning）：为了避免模型输出一些不安全或者不符合人类正向价值观的回复
    • 人类偏好对齐：基于人类反馈的对齐微调（Alignment tuning）方法，如RLHF
    • AI偏好对齐：基于AI反馈的对齐微调方法，如RLAIF
  • RLHF，Reinforcement Learning from Human Feedback，即基于人类反馈的强化学习方法

RLHF 的 MDP 过程

  • 一个response就是一个trajectory：

RLHF 整体框架

  • RLHF的一般框架如下：
  • Actor Model ：被训练的目标语言模型LLM
  • Critic Model ：AC强化学习中的Critic角色，用于估计 \(V_t\)
  • Reward Model ：奖励模型，它的作用是计算收益 \(R_t\) ，实际实现一个response仅预估一次
  • Reference Model ：参考模型，它的作用是在RLHF阶段给语言模型增加一些“约束”，防止语言模型训歪（朝不受控制的方向更新，效果可能越来越差）
  • Actor/Critic Model在RLHF阶段是需要训练的（图中给这两个模型加了粗边，就是表示这个含义）；
  • Reward/Reference Model是参数冻结的
  • Critic/Reward/Reference Model共同组成了一个“奖励-loss”计算体系（图解大模型RLHF系列之：人人都能看懂的PPO原理与源码解读作者自己命名的，为了方便理解），我们综合它们的结果计算loss，用于更新Actor

不同角色的细节

Actor Model

  • Actor Model的整体图示如下：

  • Actor的目标是：在不太偏离Reference Model的情况下，最大化reward，其定义可以写为如下形式（注意不是最终损失函数）
    $$
    \max_{\pi_\theta} \mathbb{E}_{x\sim D, y\sim \pi_\theta(y|x)} [r_{RM}(x,y)]-\beta \mathbb{D}_{KL}[\pi_\theta(y|x)||\pi_{ref}(y|x)]
    $$

    • \(r_{RM}(x,y)\) 是Reward Model的返回值
    • 上面是一个简单的示例，可以暂且理解为 \(x\) 表示 Prompt，用 \(y\) 表示 response，实际上真实场景中 \(x\) 表示 Prompt+截止到目前的输出 tokens，用 \(y\) 表示 下一个 token
    • 可以使用Reward Engineering来实现这个目标，可在不修改其他公式的情况下，使用下面的Reward来实现上述目标：
      $$
      r(x,y) = r_{RM}(x,y) - \beta(\log\pi_\theta(y|x) - \log\pi_{ref}(y|x) )
      $$
    • 上述Reward常常也写作下面的形式（使用 token 形式精确表达）：
      $$
      r_{t}=r_{\varphi}(q,o_{\leq t})-\beta\log\frac{\pi_{\theta}(o_{t}|q,o_{ < t})}{\pi_{ref}(o_{t}|q,o_{ < t})}
      $$
      • \(r_{\varphi}(q, o_{\leq t})\) 是外部奖励模型给出的原始奖励
      • \(\beta \log\frac{\pi_{\theta}(o_{t}|q,o_{ < t})}{\pi_{ref}(o_{t}|q,o_{ < t})}\) 是 KL散度惩罚项，\(\beta\) 是一个正的超参数，本质是一个去除期望的KL散度
    • 实际上，可直接将负的Actor-Reference KL加入到reward中，仅在最后一个时间步加入Reward：
      $$
      R_t=
      \begin{cases}
      -k\log\frac{\pi_\theta(A_t|S_t)}{\pi_\text{ref}(A_t|S_t)} & t < T\\
      -k\log\frac{\pi_\theta(A_t|S_t)}{\pi_\text{ref}(A_t|S_t)} + R_t & t = T
      \end{cases}
      $$
      • 其中，仅在response最后一步 \(t=T\) 时取 \(R_t\) 的值，因为Reward Model训练时也是一整个Response作为一个样本训练的，这也很好理解，因为一次回答中间的结果无法评估好坏，需要整个回答完成后才知道这次Response是否合理
      • \(\frac{\pi_\theta(A_t|S_t)}{\pi_\text{ref}(A_t|S_t)}\) 不一定是正数，但是由于动作 \(A_t\) 是从Actor策略中采样的（具体来说，是从 \(\pi_{\theta_\text{old}}\) 中采样的，PPO下可以近似认为两者相等），而 \(\mathbb{E}_{A_t \sim \pi_\theta}[\log\frac{\pi_\theta(A_t|S_t)}{\pi_\text{ref}(A_t|S_t)}]\) 是KL散度，值一定大于0，所以最大化带KL散度后的 \(R_t\) 就可以最小化KL散度，让Actor不要偏离Reference Model太多
      • 在实现时，取模型输出的概率取对数再做减法即可：
        $$
        R_t=
        \begin{cases}
        k (ref\_log\_probs-log\_probs) & t < T\\
        k (ref\_log\_probs-log\_probs) + R_t & t = T
        \end{cases}
        $$

  • PPO-loss定义（这里是Clip版本，引入拉格朗日对偶性的Adaptive KL Penalty版本不太常用，这里没有给出）,对于一个完整的response生成后（等价于一次完整的trajectory），损失函数如下:
    $$
    \mathcal{J}_{\textit{PPO}}(\theta)=\mathbb{E}_\left[q\sim P(Q),o\sim\pi_{\theta_{old}}(O|q)\right]\frac{1}{|o|}\sum_{t=1}^{|o|}\min\left[\frac{\pi_{\theta}(o_ {t}|q,o_{<t})}{\pi_{\theta_{old}}(o_{t}|q,o_{<t})}A^{\pi_\text{old}}_{t},\textrm{clip}\left( \frac{\pi_{\theta}(o_{t}|q,o_{<t})}{\pi_{\theta_{old}}(o_{t}|q,o_{<t})},1-\epsilon ,1+\epsilon\right)A^{\pi_\text{old}}_{t}\right],
    $$

    • 实践中PPO通常设置 \(\epsilon=0.2\)
    • 优势函数 \(A^{\pi_\text{old}}_t\) 是通过广义优势估计GAE计算得到的（注：计算优势函数使用的Reward是经过KL散度修正的）

  • 优势函数的优化（GAE）：

    • 可以使用GAE，可以累加实现优势函数 \(A^{Actor_{old}}(S_t, A_t)\) 的计算:
      $$
      \begin{align}
      \delta_t &= R_t + \gamma V_{t+1} - V_t \\
      A^{Actor_{old}}(S_t, A_t) &= \sum_{l=0}^{T-t} (\gamma \lambda)^l \delta_{t+l}
      \end{align}
      $$
    • 在一些文章中还会写成下面的等价形式(两者的等价性很容易证明)，然后从后往前累加（动态规划的思想）
      $$
      A^{Actor_{old}}(S_t, A_t) = \delta_t + \gamma\lambda A^{Actor_{old}}(S_{t+1}, A_{t+1})
      $$

  • 最终，通过把负Actor-Reference KL 添加到 \(R_t\) 中，Actor loss的形式与PPO-loss的形式完全一致

Critic Model

  • Critic Model的整体图示如下：
  • 在强化学习阶段，用到的Reward Model和Critic Model都使用同一个模型初始化，因此在训练Reward Model的过程中，也是在训练Critic Model
  • Critic loss，MSE损失函数（其中 \(R_t\) 是一个经过KL散度修正的奖励）：
    $$
    loss = (R_t + \gamma V_{t+1} - V_t)^2
    $$

Reward Model

  • Reward Model的整体图示如下（问题：这个图有点问题，Reward Model对一个response仅需要预估一个最终的Reward即可吧？）：

  • Reward Model的训练流程如下：

    • 使用SFT模型对每个Prompt \(x\) 重复生成多个不同Response \(y\)，记为 \(y_a, y_b, y_c, y_d\)
    • 让人类对回答进行排序打分: \(y_a \succ y_b \succ y_c \succ y_d\)，最终可获得数据集 \(D = \{x^{(i)}, y^{(i)}_w, y^{(i)}_l\}_{i=1}^N\)，实际上，对于一个 \(x\) 对应K个 \(y\) 的情况，可以拆开成 \(C_K^2\) 个样本
      • 这里有一些标注平台，可用于便捷式打分，方便人类操作，比如GitHub:label-studio提供了一个开源标注服务，GitHub:transformers_tasks提供了一个简单的模型生成数据到可视化打标的工具
    • 使用收集的数据训练Reward Model，目标是让输入Prompt \(x\) 时排序越高的Response \(y\) 打分 \(r_\theta(x,y)\) 越高
      • Reward Model通常比Actor Model小，deepspeed的示例中，语言大模型66B，奖励模型只有350M）
        • 也可以使用SFT后的LM模型后面接一层线性层作为Reward Model
      • 奖励模型训练优化采用pair-wise loss，即同时输入模型关于同一个问题的两个回答，让模型学会这两个句子哪个分高哪个分低，原始论文给出的损失函数如下（其中是否需要乘以 \(\frac{1}{C_K^2}\) 有待考证，感觉不需要，因为后面是期望，相当于已经做过归一化了）：
        $$
        Loss_{\text{RM}}(\theta) = -\frac{1}{C_K^2} \mathbb{E}_{(x,y_w,y_l)\sim D}[\log \sigma(r_\theta(x, y_w) - r_\theta(x, y_l))]
        $$
      • \((x,y_w,y_l)\sim D\) 表示从数据集中随机抽取胜者和败者两个回答进行配对

  • 损失函数的推导过程：

    • 对于任意的Prompt \(x\) 和两个不同的Response \(y_w, y_l\)，人类偏好是 \(y_w \succ y_l\)，假设这些偏好是由一个最优的打分模型 \(r^{*}(x,y)\) 确定，我们用一个神经网络 \(r_\theta(x,y)\) 来表示打分模型，按照Bradley-Terry (BT)方法（详情见DPO论文：Direct Preference Optimization: Your Language Model is Secretly a Reward Model），我们可将人类偏好分布表示为：
      $$
      p(y_w \succ y_l|x) = \frac{e^{r_\theta(x,y_w)}}{e^{r_\theta(x,y_w)} + e^{r_\theta(x,y_l)}}
      $$
    • 进一步地，为了最大化数据集 \(D = \{x^{(i)}, y^{(i)}_w, y^{(i)}_l\}_{i=1}^N\) 中人类偏好出现的概率，我们有：
      $$
      \begin{align}
      \theta^{*} &= \arg\max \prod p(y_w \succ y_l|x) \\
      &= \arg\max \prod \frac{e^{r_\theta(x,y_w)}}{e^{r_\theta(x,y_w)} + e^{r_\theta(x,y_l)}} \\
      &= \arg\max \sum log \frac{e^{r_\theta(x,y_w)}}{e^{r_\theta(x,y_w)} + e^{r_\theta(x,y_l)}} \\
      &= \arg\max \sum log \frac{1}{1+\frac{e^{r_\theta(x,y_l)}}{e^{r_\theta(x,y_w)}}} \\
      &= \arg\max \sum log \frac{1}{1+e^{r_\theta(x,y_l) - r_\theta(x,y_w)}} \\
      &= \arg\max \sum log \frac{1}{1+e^{-(r_\theta(x,y_w) - r_\theta(x,y_l))}} \\
      &= \arg\max \sum log \sigma(r_\theta(x,y_w) - r_\theta(x,y_l)) \\
      \end{align}
      $$

  • 打分归一化：为了确保打分函数具有较低的方差（不同输入Prompt的打分可能会差距非常大），实际训练中还可以对打分进行归一化，即对所有 \(x\)
    \(\mathbb{E}_{x,y\sim D}[r_\theta(x,y)] = 0\)

    • 问题，是分别对不同 \(x\) 做多次归一化，还是所有 \(x\) 一起做N次归一化，直观来看，是不是分别对不同 \(x\) 做N次归一化会更好？（论文没有明说，代码也没看到）

  • 实现代码示例，参考自博客GitHub:transformers_tasks：

    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
    def compute_rank_list_loss(rank_rewards_list: List[List[torch.tensor]], device='cpu') -> torch.Tensor:
        """
        通过给定的有序（从高到低）的ranklist的reward列表，计算rank loss
        所有排序高的句子的得分减去排序低的句子的得分差的总和，并取负

        Args:
            rank_rewards_list (torch.tensor): 有序（从高到低）排序句子的reward列表，e.g. -> 
                                            [
                                                [torch.tensor([0.3588]), torch.tensor([0.2481]), ...],
                                                [torch.tensor([0.5343]), torch.tensor([0.2442]), ...],
                                                ...
                                            ]
            device (str): 使用设备
        
        Returns:
            loss (torch.tensor): tensor([0.4891], grad_fn=<DivBackward0>)
        """
        if type(rank_rewards_list) != list:
            raise TypeError(f'@param rank_rewards expected "list", received {type(rank_rewards)}.')
        
        loss, add_count = torch.tensor([0]).to(device), 0
        for rank_rewards in rank_rewards_list:
            for i in range(len(rank_rewards)-1):                                   # 遍历所有前项-后项的得分差
                for j in range(i+1, len(rank_rewards)):
                    diff = F.sigmoid(rank_rewards[i] - rank_rewards[j])            # sigmoid到0~1之间
                    loss = loss + diff
                    add_count += 1
        loss = loss / add_count
        return -loss

Reference Model

  • 基本思想：为了防止Actor偏离SFT的结果（Reference Model）太多，导致丧失Pretrain和SFT的优秀能力， 在训练过程中保证Actor和Reference的动作分布差异不要太大（KL散度）
  • Reference Model可以防止Reward Hacking问题 ，参考LLMs 奖励剥削 RLHF: Reward hacking
    • 在强化学习中，Reward Hacking问题通常是指智能体在学习过程中发现并利用奖励函数的漏洞，为了获得最大reward而偏离训练者的目标的情况
    • 在RLHF中，Reward Hacking问题是指没有Reference Model的情况下，Actor为了实现最大化reward，会越来越偏离原来的SFT模型，这不是我们想要的
  • KL散度公式：
    $$
    \begin{align}
    D_{KL}(Actor(S)||Ref(S)) &= \mathbb{E}_{a \sim Actor(s)} [\log \frac{Actor(S)}{Ref(S)}] \\
    &= \mathbb{E}_{a \sim Actor(s)} [\log Actor(S) - \log Ref(S)] \\
    &\approx log\_probs - ref\_log\_probs\\
    \end{align}
    $$
    • 公式中最后一步用 \(\approx\) 的原因是因为需要保证生成 \(log\_probs\) 和 \(ref\_log\_probs\) 的样本是按照策略 \(Actor\) 来进行采样的（即按照Actor执行动作）
  • 思考：保证Actor和Reference两者策略足够接近，即KL散度足够接近有两种方法：
    • 方法一：按照Actor采样样本，并且在训练Actor的loss中直接加入KL散度 ，loss越小越好 => KL散度越小越好
    • 方法二：即按照Actor采样样本，并且在Reward中加入负的KL散度 ，Reward越大越好 => KL散度越小越好
      • 方法二是Reward Engineering过程，通过修改Reward来避免Reward Hacking问题
    • 目前已知的方案中,一般是加入到Reward中(如下图来自微软RLHF论文：ALIGNING LARGE MULTIMODAL MODELS WITH FACTUALLY AUGMENTED RLHF)，其实还可以有其他方案

RLHF中的奖励设计

  • 在RLHF（从人类反馈中进行强化学习）的真实训练中，KL散度会在强化学习的优化目标中作为额外的正则化项出现，对Reward Model给出的奖励进行修正
    $$
    r_{t}=r_{\varphi}(q,o_{\leq t})-\beta\log\frac{\pi_{\theta}(o_{t}|q,o_{ < t})}{\pi_{ref}(o_{t}|q,o_{ < t})},
    $$

    • 其中，\(r_{\varphi}\) 是奖励模型的输出，\(\pi_{ref}\) 是参考模型（通常是初始的SFT模型），\(\beta\) 是KL惩罚的系数

    • 注意：虽然这里写的 KL 散度计算是 \(\pi_{\theta}\) 和 \(\pi_{ref}\) 的 KL 散度，但是实际训练中，在 off-policy 场景下，应该是 \(\pi_{\theta_\text{old}}\) 和 \(\pi_{ref}\) 的 KL 散度

      • 因为 GAE 仅计算一次，多次更新时也不会重新计算 GAE，接着就是其他的计算，实现中（比如Hand-on-RL TRPO & PPO）还会使用 .detach() 以防止梯度反传回去（奖励仅仅是梯度的权重比例，不参与梯度更新）
      • 补充：最近看到的博客 The critical implementation detail of KL loss in GRPO 中也强调了这一点

    • 注意：仅对每个 Response 的最后一个 Token 上有 Reward ，其他地方都是 0，实现如下：

      1
      2
      for j in range(batch_size):
      	rewards[j, start:ends[j]][-1] += reward_from_model[j] # 假定 start 是 prompt 的长度，ends 是 padding 前的最后一个 index
      • 注：许多文章不明所以，会错误表述为每个 Token 都有 Reward，实际上，不针对所有输出Token，很难对单个Token评估奖励

    • 理解：以上Reward的本质是想要限制KL散度，KL散度的原始公式是：
      $$
      KL = \mathbb{E}_{o_t \sim \pi_{\theta}(o_{t}|q,o_{ < t})} \Big[\log\frac{\pi_{\theta}(o_{t}|q,o_{ < t})}{\pi_{ref}(o_{t}|q,o_{ < t})}\Big]
      $$

    • 更详细的讨论见论文附录

KL散度的作用

  • KL散度（Kullback-Leibler Divergence）在RLHF中主要用于防止策略模型偏离初始模型（参考模型）太远 ，从而避免模型生成不合理或极端的输出

  • KL散度的计算 ：
    $$
    \text{KL}(\pi_\theta || \pi_{\text{ref}}) = \mathbb{E}_{y \sim \pi_\theta} \left[ \log \frac{\pi_\theta(y|x)}{\pi_{\text{ref}}(y|x)} \right]
    $$

    • 其中 \( \pi_\theta \) 是当前策略模型，\( \pi_{\text{ref}} \) 是参考模型（如初始预训练模型）

  • KL散度的作用 ：

    • 防止模型过度优化奖励，导致输出偏离人类期望
    • 保持生成内容的多样性和合理性

强化学习的优化目标

  • 在RLHF中，强化学习的优化目标通常结合了奖励模型的输出和KL散度正则化项。具体形式如下：
    $$
    \max_{\pi_\theta} \mathbb{E}_{(x, y) \sim \pi_\theta} \left[ R(x, y) - \beta \cdot \text{KL}(\pi_\theta || \pi_{\text{ref}}) \right]
    $$
  • 其中：
    • \( R(x, y) \) 是Critic网络预测的奖励值
    • \( \beta \) 是KL散度的权重系数，用于控制正则化的强度

其他相关RLHF的描述

附录：Reward 的 KL 散度为什么可以将期望消去

  • 奖励函数的定义 ：
    $$
    r_t = r_{\varphi}(q, o_{\leq t}) - \beta \log \frac{\pi_\theta(o_t|q, o_{ < t})}{\pi_{ref}(o_t|q, o_{ < t})}
    $$
    • \(r_{\varphi}(q, o_{\leq t})\) 是外部奖励模型给出的原始奖励
    • \(\beta \log \frac{\pi_\theta}{\pi_{ref}}\) 是 KL散度惩罚项，\(\beta\) 是一个正的超参数，本质是一个去除期望的KL散度

理论理解（目前 OK）

  • 由于动作 \(o_t\) 是从 \(\pi_\theta\) 策略中采样的（具体来说，是从 \(\pi_{\theta_\text{old}}\) 中采样的，PPO下可以近似认为两者相等），而 \(\mathbb{E}_{o_t \sim \pi_\theta(o_t|q,o_{ < t})}\Big[\log\frac{\pi_\theta(o_t|q,o_{ < t})}{\pi_\text{ref}(o_t|q,o_{ < t})}\Big]\) 是KL散度，值一定大于0，所以最大化带KL散度后的 \(r_t\) 就可以最小化KL散度，让Actor不要偏离Reference Model太多
  • 在策略更新时，本质就是按照 \(o_t \sim \pi_\theta(o_t|q,o_{ < t})\) 采样得到的样本更新的，也就是在更新 \(\log\frac{\pi_\theta(o_t|q,o_{ < t})}{\pi_\text{ref}(o_t|q,o_{ < t})}\) 在分布 \(o_t \sim \pi_\theta(o_t|q,o_{ < t})\) 下的期望 \(\mathbb{E}_{o_t \sim \pi_\theta(o_t|q,o_{ < t})}\Big[\log\frac{\pi_\theta(o_t|q,o_{ < t})}{\pi_\text{ref}(o_t|q,o_{ < t})}\Big]\)
  • 注：在许多实现中都有类似操作，比如SpinningUp项目的PPO的实现中，有 approx_kl = (logp_old - logp).mean().item() 语句来表示近似KL散度，这里样本都是从 \(\pi_{\theta_\text{old}}\) 策略中采样得到的，所以：
    $$
    \begin{align}
    D_{\text{KL}}(\pi_{\theta_\text{old}}||\pi_{\theta}) &= \mathbb{E}_{a \sim \pi_{\theta_\text{old}}} \left[\log\frac{\pi_{\theta_\text{old}}(a|s)}{\pi_{\theta}(a|s)}\right] &\\
    &\approx \frac{1}{N} \log\frac{\pi_{\theta_\text{old}}(a|s)}{\pi_{\theta}(a|s)} \\
    &= \frac{1}{N} (\log \pi_{\theta_\text{old}}(a|s)- \log\pi_{\theta}(a|s))
    \end{align}
    $$

关于 KL 散度正负号的直观理解

  • \(\log \frac{\pi_\theta}{\pi_{ref}}\) 带来的行为 ：
    • 当 \(\pi_\theta(o_t|q, o_{ < t}) > \pi_{ref}(o_t|q, o_{ < t})\) 时，\(\frac{\pi_\theta}{\pi_{ref}} > 1\)，因此 \(\log \frac{\pi_\theta}{\pi_{ref}} > 0\)
    • 当 \(\pi_\theta(o_t|q, o_{ < t}) < \pi_{ref}(o_t|q, o_{ < t})\) 时，\(\frac{\pi_\theta}{\pi_{ref}} < 1\)，因此 \(\log \frac{\pi_\theta}{\pi_{ref}} < 0\)
    • 当 \(\pi_\theta(o_t|q, o_{ < t}) = \pi_{ref}(o_t|q, o_{ < t})\) 时，\(\log \frac{\pi_\theta}{\pi_{ref}} = 0 \)
  • \(\log \frac{\pi_\theta}{\pi_{ref}}\) 对奖励的影响 ：
    • 当 \(\pi_\theta > \pi_{ref}\) 时 ：\(\log \frac{\pi_\theta}{\pi_{ref}} > 0\)，因此惩罚项 \(-\beta \log \frac{\pi_\theta}{\pi_{ref}} < 0\)，会导致奖励 \(r_t\) 降低
      • 此时降低 生成当前 Token 的概率，从而让 \(\pi_\theta \rightarrow \pi_{ref}\)
    • 当 \(\pi_\theta \lt \pi_{ref}\) 时 ：\(\log \frac{\pi_\theta}{\pi_{ref}} < 0\)，因此惩罚项 \(-\beta \log \frac{\pi_\theta}{\pi_{ref}} > 0\)，会导致奖励 \(r_t\) 增加
      • 此时增加 生成当前 Token 的概率，从而让 \(\pi_\theta \rightarrow \pi_{ref}\)
    • 当 \(\pi_\theta = \pi_{ref}\) 时 ：
      \(\log \frac{\pi_\theta}{\pi_{ref}} = 0\)，惩罚项为 0，奖励 \(r_t\) 仅由外部奖励 \(r_{\varphi}\) 决定

附录：使用 Value Function Clipping 稳定 Critic 训练

  • 传统的 DQN 或 Actor-Critic 算法中，Critic 的 Loss 通常只是简单的 MSE：Loss = (values - returns) ** 2

    • returns: 真实的价值目标（PPO 中通常通过 GAE 计算得出）

  • 在 PPO 中，为了保证训练的稳定性，不希望 Critic 网络的预测值在一次更新中发生剧烈的变化

    • PPO 引入了类似 Actor 裁剪的机制：强迫当前网络输出的 Value 不能偏离旧网络输出的 Value 太远
    • 核心思路：类似 Trust Region 保证
      • 通过比较新旧值的变化量，确保 Critic 不会偏离太远
    • 注：可以看到，实现 Value Function Clipping 需要增加一个旧 Critic 的 values（即 old_values ）

  • Critic Loss 计算的核心代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    ## 下面这段代码常见于 RLHF 框架的 PPO 实现中

    ## 数据准备
    # * **Rollout 阶段**（生成数据时）：
       #     * Actor 生成 response
       #     * Critic 估算 `old_values`（Rollout 后，计算 GAE 时，需要这个值）
       #     * 这些值被 **保存** 到 batch 数据中
       # * **训练阶段**（当前代码执行的时机）：
       #     * `old_values` 直接从 batch 中读取
       #     * `values` 是当前 Critic 网络前向传播计算得到

       # Step1：从 Batch 中获取 old_values
       # Step2：从当前 Critic 输出获取 values(带梯度)
    # Step3：计算 clipped values
       clipped_values = old_values + (values - old_values).clamp(-self.cliprange, self.cliprange) # 若被 Clip 则会丢失梯度，这里的 clipped_values 是不超过 old_values 一定比例的值
    # 注：`cliprange`: 允许的最大变化范围（例如 0.2）

    # Step4: 计算 clipped value loss 和 value_loss
       clipped_value_loss = (clipped_values - returns) ** 2 # 按照 clipped_values 计算得到的 Loss
       value_loss = (values - returns) ** 2 # 按照 values 计算得到的 Loss

    # Step5：取两者的最大值作为最终的 loss
       final_value_loss = torch.max(clipped_value_loss, value_loss)
    • 注：对于每个 Rollout Step，第一个梯度 Step 的 (values - old_values) 都为 0

  • 这段代码的本质是：带有信任区域（Trust Region）限制的 MSE 损失计算，即“价值函数裁剪（Value Function Clipping）”

补充：如何理解 torch.max(clipped_value_loss, value_loss)？

  • torch.max 结合 clamp 的巧妙之处在于：
    • 1）如果模型预期更新幅度大且之前已经改进过模型了（模型已经更贴近当前目标了） ，它会切断梯度（Loss 取 clipped_value_loss），让模型 “稳一点，别急”
    • 2）如果模型更新更新幅度大且之前往反方向更新过模型了（模型已经更远离当前目标了），它保留梯度（Loss 取 value_loss），让模型 “赶紧改错”
    • 3）如果模型在安全范围内更新，它就是普通的 MSE Loss
  • 理解 max 的核心在于理解它如何控制梯度
    • 取两个 Loss 中的最大值，在数学上被称为悲观约束（Pessimistic Bound）
    • 即总是用“更差（Loss 更大）”的情况来惩罚模型
  • 可以分三种情况来理解 max 是如何巧妙地实现裁剪的：
    • 情况 1：更新幅度很小（在 cliprange 范围内）
      • 思路：正常 MSE 更新即可
      • 此时 values 和 old_values 差不多
      • clamp 操作没有被触发，clipped_values 等于 values
      • 因此 clipped_value_loss 等于 value_loss
      • max(clipped_value_loss, value_loss) 返回的就是普通的 MSE Loss
      • 结果：正常计算梯度，正常更新
    • 情况 2：更新幅度过大，但之前的更新已经让模型“更好”了（已经离 returns 更近了）
      • 思路：模型已经预测的还不错了（至少进化方向是对的），先不用更新了（关闭本次梯度）
      • 举例说明：
        • 假设 old_values 是 0，returns 是 10，cliprange 是 0.2
        • 当前网络很激进，直接把 values 预测成了 5，但已经进化过的方向是对的，即已经朝着 10 迈了一大步了
      • clipped_values 被强行截断在 0 + 0.2 = 0.2
      • clipped_value_loss (裁剪后)
        $$(0.2 - 10)^2 = 96.04 $$
      • value_loss (未裁剪)
        $$ (5 - 10)^2 = 25 $$
      • 此时 clipped_value_loss > value_loss，max 会选择 clipped_value_loss（常数，关闭梯度）
      • clipped_value_loss 是由 clipped_values 算出来的，而 clipped_values 在超出范围时，其值等于 old_values ± cliprange
        • 这是一个常数 ，它对当前网络参数 values 的梯度为 0！
      • 结果：因为更新步伐迈得太大，PPO 认为这不安全（超出了信任区域），所以直接将梯度切断为 0，阻止网络继续往这个方向剧烈更新
    • 情况 3：更新幅度过大，但之前的更新让模型变得“更差”了（已经离 returns 更远了）
      • 思路：模型之前走反了，赶紧更新回来（即打开梯度）
      • 举例说明：
        • 假设 old_values 是 0，returns 是 10，cliprange 是 0.2
        • 当前网络不仅没朝着 10 走，反而把 values 预测成了 -5（已经大倒退了很多了）
      • clipped_values 被截断在 0 - 0.2 = -0.2
      • clipped_value_loss (裁剪后):
        $$(-0.2 - 10)^2 = 104.04$$
      • value_loss (未裁剪)
        $$(-5 - 10)^2 = 225$$
      • 此时 value_loss > clipped_value_loss，max 会选择 value_loss（打开梯度）
      • 结果：既然模型变得更差了，需要打开梯度更新模型（赶紧修正）
        • max 选择了未裁剪的 value_loss，这意味着模型会吃到一个巨大的 Loss，并且产生完整的梯度，强迫模型立刻纠正这个严重的错误

整体说明：

  • 姜大昕提出的 7 个技术 insight，从 AGI 的演进方向、核心技术支撑、智能体构建逻辑到商业化落地路径，系统勾勒了当前大模型发展的关键趋势

AGI 演进路径：从“数据学习”到“科学发现”的三阶跃迁

  • 三个阶段分别是：
    • 第一阶段“模拟世界”是基础：模型通过海量数据学习语言、图像等模态的底层结构（如当前大模型的预训练阶段），核心是“看懂”世界的基本规律；
    • 第二阶段“探索世界”是突破：借助强化学习实现从“被动接收数据”到“主动试错推理”的跨越，让模型具备处理复杂任务的策略规划能力（如当前模型从对话交互向逻辑推理的升级）；
    • 第三阶段“归纳世界”是高阶目标：模型具备自主学习能力，能协助人类在科学、能源等领域发现新规律（如辅助材料研发、天体物理分析等）
  • 注：这三阶路径已经成为共识，它贴合人类认知从“认知世界”到“改造世界”再到“探索未知”的逻辑，也与当前大模型能力迭代的节奏高度吻合

多模态：通用智能的“基础设施”

  • 多模态协同是 AGI 的必要条件，而非可选能力
  • 人类智能的核心是“多感知协同”——语言（交流）、视觉（观察）、空间（定位）、运动（操作）等能力共同构成智能基础
    • 例如，人类看到苹果（视觉），能说出“红色、圆形、可食用”（语言），能判断距离（空间），能拿起它（运动）
  • 对大模型而言，单一模态（如仅语言或仅视觉）无法支撑通用智能：
    • 仅语言模型难以理解空间关系，仅视觉模型无法表达抽象逻辑
    • 只有实现多模态的“协同理解与表达”（如“看到图能描述细节，听到指令能生成对应图像”），才能构建接近人类的通用智能框架
    • 当前多模态大模型（如图文生成、视听交互）的快速发展，正是这一逻辑的体现

视觉 AI：迈向“理解与生成一体化”的突破

  • 视觉模型需打破“理解与生成分离”的现状，实现类似文本领域的一体化架构
  • 现状问题：当前多数视觉模型中，“理解”（如图像识别、场景分析）与“生成”（如图像编辑、内容创作）是分离的，导致处理效率低（如理解结果需重新输入生成模块）、响应不连贯（如生成内容与上下文理解脱节）
    • 问题：“理解” 和 “生成” 分离的体现是什么？当前不算是理解和生成一体化吗？
  • 一体化逻辑：生成依赖对上下文的深度理解（如生成“雨天的街道”需先理解“雨天”的视觉特征和“街道”的场景结构）；同时，生成结果可反推理解效果（如生成的“猫”是否符合“三只脚”的理解要求）
  • 发展阶段：文本领域已实现一体化（如 GPT 系列用同一架构完成理解与生成），视觉领域因模态复杂性（像素、空间关系等）尚未突破，但技术储备已接近临界点，未来有望实现效率与连贯性的跃升

强化学习：智能“涌现”的关键机制

  • 强化学习是推动模型从“对话工具”向“推理主体”进化的核心技术
  • 强化学习能帮助模型建立起更接近人类的思维方式，通过试错与反馈提升策略规划能力
  • 强化学习的核心是“试错-反馈-优化”：
    • 模型通过在环境中尝试不同策略，接收反馈后调整行为，逐步形成更优的决策逻辑——这与人类通过经验积累提升能力的方式高度相似
    • 例如，在复杂任务（如规划旅行路线）中，模型最初可能给出低效方案，通过用户反馈（“时间太长”）调整策略，最终形成兼顾时间、成本的推理能力
    • 这种机制让模型突破了“基于已有数据模仿”的局限，实现从“被动应答”到“主动推理”的智能涌现，是大模型能力跃迁的关键推手

Agent 的核心能力：构建“自主智能体”的四大支柱

  • 具备“总在场、会做事、有记忆、能进化”四大能力，是 Agent 落地的基础
  • 四大能力共同支撑Agent从“被动响应”到“主动服务”的跨越
    • 总在场 ：能通过多模态（视觉、听觉等）实时感知并理解环境（如智能汽车Agent需同时“看到”路况、“听到”指令）；
    • 会做事 ：能调用工具（如APP、传感器）执行任务（如“订酒店”需调用预订软件，“开空调”需连接家电接口）；
    • 有记忆 ：存储历史交互与任务经验（如记住用户“怕热”的偏好），为强化学习提供数据基础；
    • 能进化 ：通过反馈持续迭代（如因“订错日期”的反馈优化时间识别能力），实现能力螺旋上升

智能终端：Agent 落地的“天然载体”

  • 手机、汽车等终端设备是 Agent 最适合的应用场景
  • 智能终端的优势在于“天然具备感知与交互能力”：
  • 感知层：手机有摄像头（视觉）、麦克风（听觉），汽车有雷达（空间）、传感器（运动），能为 Agent 提供实时环境数据（如“手机摄像头看到用户在厨房”）；
  • 交互层：终端自带屏幕、扬声器、操作接口（如汽车的方向盘、家电的控制按钮），能让 Agent 的决策直接落地（如“通过汽车接口调整空调温度”）
  • 这种“感知-决策-执行”的闭环，解决了 Agent 在抽象场景中“无数据支撑”“无执行渠道”的问题，让模型能在实际生活中稳定运行（如手机 Agent 根据用户表情推荐放松音乐）

商业化效率：通用模型驱动“降本增效”

  • 模型的通用性是提升商业化效率的关键
  • 传统模式：每个场景需单独训练特化模型，成本高、复用性低；
  • 通用模型优势：通过 Prompt 即可快速适配场景，迁移能力强；
  • 商业化价值：随着模型能力提升，单一模型可覆盖多场景，降低企业的技术投入（无需养多个研发团队），同时提升响应速度（新场景无需等待模型训练），最终提高性价比并提升盈利空间（一个模型同时负责多个任务）
  • 这一逻辑揭示了大模型从“技术突破”到“商业落地”的核心路径——通过通用性降低门槛，实现规模化复制
  • 问题：现在落地难真的是这个原因吗？