51c大模型~合集78

我自己的原文哦~  https://blog.51cto.com/whaosoft/12642335

#LTX-Video

RTX 4090可跑、完全开源，最快视频生成模型问世，实测一言难尽

开源 AI 视频社区又一个重量级选手下场。

这个周末，押注开源人工智能视频的初创公司 Lightricks，有了重大动作。

该公司推出了最快的视频生成模型 LTX-Video，它是首个可以实时生成高质量视频的 DiT 视频生成模型。

在一块 Nvidia H100 上，LTX-Video 只需要 4 秒就能生成 5 秒时长的 24FPS 视频，分辨率 768x512，可以说视频生成速度比视频观看速度还要快。同时 LTX-Video 完全开源，包括代码库和模型权重。

LTX-Video共同作者和负责人。

「有史以来最快的文生视频模型诞生了。」

首先来看几个视频生成官方 Demo。

，时长00:04

，时长00:02

，时长00:05

目前，用户可以在 GitHub Hugging Face 上体验预览版 LTX Video。完整版发布之后将免费供个人和商业使用，并即将集成到 LTX Studio 中。

项目地址：https://github.com/Lightricks/LTX-Video

我们尝试生成了两个视频，比如「a dog chasing a boy who is skateboarding」。

，时长00:05

再比如「a girl with an umbrella standing on a bridge, and a handsome man walking towards her」。

，时长00:05

试用地址：https://huggingface.co/spaces/akhaliq/anychat

接着来了解一下 LTX-Video 的细节。

LTX Video 是一个文本到视频和图像到视频模型，能够以惊人的速度和精度实时创建动态视频。该模型可以在 RTX 4090 等消费级 GPU 上本地运行，无需专用设备即可以低成本地生成高质量视频。

另外，LTX Video 基于开发人员的反馈和真实世界用例构建，可以提供自然逼真的结果。该模型做了高级定制化设计，可以流畅地集成各种外部工具，从而轻松地增强工作流。

在生成过程中，LTX Video 最大程度减少了闪烁和伪影，创建出具有出色细节和清晰度的高保真视频。每一帧都在精心制作下呈现清晰锐利、栩栩如生，符合用户的视觉效果。

最后，LTX Video 实现了无缝的跨帧一致性，从角色到环境，可以保持连贯的视觉效果，将每个细节整合在一起。

未来，LTX-Video 还会有技术报告放出。

#Kinetix

智能体零样本解决未见过人类设计环境！全靠这个开放式物理RL环境空间

当物理推理能力进化后，通用强化学习智能体能在2D物理环境中执行多样化任务了。

在机器学习领域，开发一个在未见过领域表现出色的通用智能体一直是长期目标之一。一种观点认为，在大量离线文本和视频数据上训练的大型 transformer 最终可以实现这一目标。

不过，在离线强化学习（RL）设置中应用这些技术往往会将智能体能力限制在数据集内。另一种方法是使用在线 RL，其中智能体通过环境交互自己收集数据。

然而，除了一些明显的特例外，大多数 RL 环境都是一些狭窄且同质化的场景，限制了训练所得智能体的泛化能力。

近日，牛津大学的研究者提出了 Kinetix 框架，它可以表征 2D 物理环境中广阔的开放式空间，并用来训练通用智能体。

• 论文地址：https://arxiv.org/pdf/2410.23208
• 项目主页：https://kinetix-env.github.io/
• 论文标题：Kinetix: Investigating the Training of General Agents through Open-Ended Physics-Based Control Tasks

Kinetix 涵盖的范围足够广，可以表征机器人任务（如抓取和移动）、经典的 RL 环境（如 Cartpole、Acrobot 和 Lunar）、电子游戏（Pinball）和其他很多任务，如下图 1 所示。

此外，为了后端运行 Kinetix，研究者开发了一种硬件加速物理引擎 Jax2D，它能够高效地模拟训练智能体所需的数十亿次环境交互。他们表示，通过从可表征的 2D 物理问题空间中随机采样 Kinetix 环境，可以几乎无限地生成有意义的多样化训练任务。

研究者发现，在这些环境中训练的 RL 智能体表现出了对一般机械特性的理解，并能够零样本地解决未见过的手工环境。

他们进一步分析了在特定困难环境中微调该通用智能体能带来哪些好处，结果发现与白板智能体相比，这样做能够大大减少学习特定任务所需的样本数量。

同时，微调还带来了一些新能力，包括解决专门训练过的智能体无法取得进展的任务。

Kinetix 详解

Kinetix 是一个大型开放式 RL 环境，完全在 JAX 中实现。

Jax2D

为了支持 Kinetix，研究团队开发了基于脉冲的 2D 刚体物理引擎 ——Jax2D，完全用 JAX 编写，构成了 Kinetix 基准测试的基础。研究团队通过仅模拟几个基本组件来将 Jax2D 设计得尽可能具有表达能力。

为此，Jax2D 场景仅包含 4 个独特的实体：圆形、（凸）多边形、关节和推进器。从这些简单的构建块中，可以表征出多种多样的不同物理任务。

Jax2D 与 Brax 等其他基于 JAX 的物理模拟器的主要区别在于 Jax2D 场景几乎完全是动态指定的，这意味着每次模拟都会运行相同的底层计算图，使得能够通过 JAX vmap 操作并行处理不同任务，这是在多任务 RL 环境中利用硬件加速功能的关键组成部分。相比之下，Brax 几乎完全是静态指定的。

Kinetix：RL 环境规范

动作空间 Kinetix 支持多离散和连续动作空间。在多离散动作空间中，每个电机和推进器可以不活动，也可以在每个时间步以最大功率激活，电机可以向前或向后运行。 

• 观察空间 

使用符号观察，其中每个实体（形状、关节或推进器）由一系列物理属性值（包括位置、旋转和速度）定义。然后将观察定义为这些实体的集合，允许使用排列不变的网络架构，例如 transformer。这种观察空间使环境完全可观察，从而无需具有记忆的策略。还提供基于像素的观察和符号观察的选项，它可以简单地连接和展平实体信息。

• 奖励 

为了实现通用智能体的目标，该研究选择了一个简单但具有高度表达力的奖励函数，该函数在所有环境中保持固定。每个场景必须包含一个绿色形状和一个蓝色形状 - 目标只是使这两个形状发生碰撞，此时该情节以 + 1 奖励结束。场景还可以包含红色形状，如果它们与绿色形状碰撞，将会以 -1 奖励终止该情节。如图 1 所示，这些简单且可解释的规则允许表示大量语义上不同的环境。

Kinetix 的表现力、多样性和速度使其成为研究开放性的理想环境，包括通用智能体、UED 和终身学习。为了使其对智能体训练和评估发挥最大作用，该研究提供了一个启发式环境生成器、一组手工设计的级别以及描述环境复杂性的环境分类法。 

环境生成器 Kinetix 的优势在于它可以表示环境的多样性。然而，这个环境集包含许多退化的情况，如果简单地采样，它们可能会主导分布。因此，该研究提供了一个随机级别生成器，旨在最大程度地提高表达能力，同时最大限度地减少简并级别的数量。确保每个关卡都具有完全相同的绿色和蓝色形状，以及至少一个可控方面（电机或推进器）。

实验结果

研究者在程序生成的 Kinetix 关卡上进行训练，后者从静态定义分布中抽取。他们将来自该分布的采样关卡上的训练称为 DR。主要评估指标是在手动 holdout 关卡的解决率。智能体不会在这些关卡上训练，但它们确实存在于该训练分布的支持范围内。由于所有关卡都遵循相同的底层结构并完全可观察，因此理论上可以学习一种在分布内所有关卡上表现最佳的策略。

为了选择要训练的关卡，研究者使用了 SOTA UED 算法 SFL，它定期在随机生成的关卡上执行大量 rollout，然后选择具有高学习能力的子集，并在固定时间内对它进行训练，最后再次选择新的关卡。同时，研究者使用 PLR 和 ACCEL 进行了初步实验，但发现这些方法相较于 DR 没有任何改进。

架构

下图 2 是训练所用的基于 transforme r 的架构。可以看到，一个场景被分解为它的组成实体，然后通过网络传递。该网络由 L 层的自注意力和消息传递组成，K 个完全连接层紧随其后。

其中为了以置换不变的方式处理观察结果，研究者将每个实体表征为向量 v，其中包含物理属性，比如摩擦、质量和旋转。

零样本结果

在下图 3 中，研究者分别在 S、M 和 L 大小的环境中训练 SFL。在每种情况下，训练环境（随机）具有相应的大小，而研究者使用相应的 holdout 集来评估智能体的泛化能力。

可以看到，在每种情况下，智能体的性能都会在训练过程中提高，这表明它正在学习一种可以应用于未见过环境的通用策略。

接下来，研究者通过探索学得的通用智能体在受限目标遵循设置中的行为，仔细探究了它的零样本性能。具体来讲，他们创建的关卡在其中心具有单一形态（一组与电机连接并包含绿色形状的形状），目标（蓝色形状）固定在关卡顶部，并且位置 x 是随机的。

研究者测量了目标位置 x 与可控形态位置 x 之间的关联，如下图 4 所示。其中最佳智能体的行为表现为高相关性，因此会在对角线上表现出高发生率。他们还评估了在随机 M 关卡上训练 50 亿时间步的随机智能体和通用智能体。

正如预期的那样，随机智能体在可控形态和目标位置之间没有表现出相关性，而经过训练的智能体表现出了正相关性，表明它可以将操纵形态到目标位置。

微调结果

本节中，研究者探究了在使用给定有限样本数量来微调 holdout 任务时，通用智能体的性能。在下图 5 中，他们为 L holdout 集中的每个关卡训练了单独的专用智能体，并将它们与微调通用智能体进行比较。

研究者绘制了四个选定环境的学习曲线，以及整个 holdout 集的总体性能曲线。在其中三个关卡上，微调智能体的表现远远优于从头开始训练，尤其是对于 Mujoco-Hopper-Hard 和 Mujoco-Walker-Hard，微调智能体能够完全胜任这些关卡，而白板智能体无法始终如一地做到这一点。

#小模型SLM

研究大模型门槛太高？不妨看看小模型SLM，知识点都在这

本篇综述的作者团队包括宾州州立大学的博士研究生王发利，张智维，吴纵宇，张先仁，指导教师王苏杭副教授，以及来自伦斯勒理工学院的马耀副教授，亚马逊汤先锋、何奇，德克萨斯大学休斯顿健康科学中心黄明副教授团队。

摘要：大型语言模型（LLMs）在多种任务中表现出色，但由于庞大的参数和高计算需求，面临时间和计算成本挑战。因此，小型语言模型（SLMs）因低延迟、成本效益及易于定制等优势优点，适合资源有限环境和领域知识获取，正变得越来越受欢迎。我们给出了小语言模型的定义来填补目前定义上的空白。我们对小型语言模型的增强方法、已存在的小模型、应用、与 LLMs 的协作、以及可信赖性方面进行了详细调查。我们还探讨了未来的研究方向，并在 GitHub 上发布了相关模型及文章：https://github.com/FairyFali/SLMs-Survey。

论文链接：https://arxiv.org/abs/2411.03350

文章结构

图 1 文章结构

LLMs 的挑战

神经语言模型（LM）从 BERT 的预训练微调到 T5 的预训练提示，再到 GPT-3 的上下文学习，极大增强了 NLP。模型如 ChatGPT、Llama 等在扩展至大数据集和模型时显示出 “涌现能力”。这些进步推动了 NLP 在多个领域的应用，如编程、推荐系统和医学问答。 

尽管大型语言模型（LLMs）在复杂任务中表现出色，但其庞大的参数和计算需求限制了部署本地或者限制在云端调用。这带来了一系列挑战：

LLMs 的高 GPU 内存占用和计算成本通常使得其只能通过云 API 部署，用户需上传数据查询，可能引起数据泄漏及隐私问题，特别是在医疗、金融和电商等敏感领域。

在移动设备上调用云端 LLMs 时面临云延迟问题，而直接部署又面临高参数和缓存需求超出普通设备能力的问题。

LLMs 庞大的参数数量可能导致几秒至几分钟的推理延迟，不适合实时应用。

LLMs 在专业领域如医疗和法律的表现不佳，需要成本高的微调来提升性能。

虽然通用 LLMs 功能强大，但许多应用和任务只需特定功能和知识，部署 LLMs 可能浪费资源且性能不如专门模型。

SLMs 的优势

最近，小型语言模型（SLMs）在处理特定领域问题时显示出与大型语言模型（LLMs）相当的性能，同时在效率、成本、灵活性和定制方面具有优势。由于参数较少，SLMs 在预训练和推理过程中节约了大量计算资源，减少了内存和存储需求，特别适合资源有限的环境和低功耗设备。因此，SLMs 作为 LLMs 的替代品越来越受到关注。如图 2 所示，Hugging Face 社区中 SLMs 的下载频率已超过大型模型，而图 3 显示了 SLMs 版本随时间推移的日益流行。

图 2 Hugging Face 上个月下载量（数据获取在 2024 年 10 月 7 日）

图 3 SLMs 时间线

SLMs 的定义

通常，具有涌现能力的语言模型被归类为大型语言模型（LLMs）。然而，小型语言模型（SLMs）的分类尚无统一标准。一些研究认为 SLMs 的参数少于 10 亿，且在移动设备上通常配备约 6GB 的内存；而另一些研究则认为 SLMs 的参数可达到 100 亿，但这些模型通常缺乏涌现能力。考虑到 SLMs 在资源受限的环境及特定任务中的应用，我们提出了一个广义的定义：SLMs 的参数范围应介于能展现专门任务涌现能力的最小规模和在资源限制条件下可管理的最大规模之间。这一定义旨在整合不同观点，并考虑移动计算及能力阈值因素。

SLMs 的增强方法

在大语言模型时代小语言模型的增强方法会有不同，包括从头开始训练 SLMs 的训练方法、使 SLMs 遵循指令的监督微调 (SFT)、先进的知识提炼和量化技术，以及 LLMs 中经常使用的技术，以增强 SLMs 针对特定应用的性能。我们详细介绍了其中一些代表性方法，包括参数共享的模型架构（从头开始训练子章节 3.1）、从人类反馈中优化偏好（有监督微调子章节 3.2）、知识蒸馏的数据质量（3.3 章节）、蒸馏过程中的分布一致性（3.4 章节）、训练后量化和量化感知训练技术（3.5 章节）、RAG 和 MoE 方法增强 SLMs（3.6 章节）。这一章节的未来方法是探索可提高性能同时降低计算需求的模型架构，比如 Mamba。

SLMs 的应用

由于 SLMs 能够满足增强隐私性和较低的内存需求，许多 NLP 任务已开始采用 SLMs，并通过专门技术提升其在特定任务上的性能（见 4.1 节），如问答、代码执行、推荐系统以及移动设备上的自动化任务。典型应用包括在移动设备上自动执行任务，SLMs 可以作为代理智能调用必需的 API，或者根据智能手机 UI 页面代码自动完成给定的操作指令（见 4.1.5 节）。

此外，部署 SLMs 时通常需考虑内存使用和运行效率，这对预算有限的边缘设备（特别是智能手机）上的资源尤为关键（见 4.2 节）。内存效率主要体现在 SLMs 及其缓存的空间占用上，我们调研了如何压缩 SLMs 本身及其缓存（见 4.2.1 节）。运行效率涉及 SLMs 参数量大及切换开销，如内存缓存区与 GPU 内存之间的切换（见 4.2.2 节），因此我们探讨了减少 MoE 切换时间和降低分布式 SLMs 延迟等策略。

未来研究方向包括使用 LoRA 为不同用户提供个性化服务、识别 SLMs 中的固有知识及确定有效微调所需的最少数据等（更多未来方向详见第 8 章）。

已存在的 SLMs

我们总结了一些代表性的小型语言模型（详见图 3），这些模型包括适用于通用领域和特定领域的小型语言模型（参数少于 70 亿）。本文详细介绍了这些小型语言模型的获取方法、使用的数据集和评估任务，并探讨了通过压缩、微调或从头开始训练等技术获取 SLMs 的策略。通过统计分析一些技术，我们归纳出获取通用 SLMs 的常用技术，包括 GQA、Gated FFN，SiLU 激活函数、RMS 正则化、深且窄的模型架构和 embedding 的优化等（见 5.1 章）。特定领域的 SLMs，如科学、医疗健康和法律领域的模型，通常是通过对大模型生成的有监督领域数据进行指令式微调或在领域数据上继续训练来获取的（见 5.2 章）。未来的研究方向将包括在法律、金融、教育、电信和交通等关键领域开发专业化的小型语言模型。

SLMs 辅助 LLMs

由于 SLMs 在运行效率上表现出色且与 LLMs 的行为规律相似，SLMs 能够作为代理辅助 LLMs 快速获取一些先验知识，进而增强 LLMs 的功能，例如减少推理过程中的延迟、缩短微调时间、改善检索中的噪声过滤问题、提升次优零样本性能、降低版权侵权风险和优化评估难度。

在第 6 章中，我们探讨了以下五个方面：

(i) 使用 SLMs 帮助 LLMs 生成可靠内容：例如，使用 SLMs 判断 LLMs 输入和输出的真实置信度，或根据 LLMs 的中间状态探索幻觉分数。详细的可靠生成方法、增强 LLMs 的推理能力、改进 LLMs RAG 以及缓解 LLMs 输出的版权和隐私问题，请参考原文。

(ii) SLMs 辅助提取 LLMs 提示：一些攻击方法通过 SLMs 逆向生成 Prompts。

(iii) SLMs 辅助 LLMs 微调：SLMs 的微调参数差异可以模拟 LLMs 参数的演变，从而实现 LLMs 的高效微调。

(iv) SLMs 在特定任务上辅助 LLMs 表现：定制化的 SLMs 在某些特定任务上可能优于 LLMs，而在困难样本上可能表现不佳，因此 SLMs 和 LLMs 的合作可以在特定任务上实现更优表现。

(v) 使用 SLMs 评估 LLMs：SLMs 在经过微调后可以作为评估器，评估 LLMs 生成的更加格式自由的内容。

未来的方向包括使用 SLMs 作为代理探索 LLMs 更多的行为模式，如优化 Prompts、判断缺失知识和评估数据质量等，更多信息请参见原文第 8 章未来工作。

SLMs 的可信赖性

图 4 Trustworthiness 分类

语言模型已成为我们日常生活中不可或缺的一部分，我们对它们的依赖日益增加。然而，它们在隐私、公平等信任维度上存在局限，带来了一定风险。因此，许多研究致力于评估语言模型的可信赖性。尽管目前的研究主要集中在大型语言模型（LLMs）上，我们在第 7 章关注 7B 参数及以下的模型和五个关键的信任场景：鲁棒性、隐私性、可靠性、安全性和公平性，详见图 4。在鲁棒性方面，我们讨论了对抗性鲁棒性和分布外鲁棒性两种情况；在安全性方面，我们重点分析了误导信息和毒性问题；在可靠性方面，我们主要关注幻觉和谄媚现象。然而，大多数现有研究都集中在具有至少 7B 参数的模型上，这留下了对小型语言模型（SLMs）可信度全面分析的空白。因此，系统地评估 SLMs 的可信度并了解其在各种应用中的表现，是未来研究的重要方向。

总结

随着对小型语言模型需求的增长，当下研究文献涵盖了 SLMs 的多个方面，例如针对特定应用优化的训练技术如量化感知训练和选择性架构组件。尽管 SLMs 性能受到认可，但其潜在的可信度问题，如幻觉产生和隐私泄露风险，仍需注意。当前缺乏全面调查彻底探索 LLMs 时代 SLMs 的这些工作。本文旨在提供详尽调查，分析 LLMs 时代 SLMs 的各个方面及未来发展。详见我们的综述原文。

#大模型对齐中的各种loss讲解

本文深入讲解了大模型对齐中的各种loss函数，包括SFT家族、DPO家族、RLHF家族等，涉及GPTLMLoss、KDLoss、DPOLoss、KTOLoss、PolicyLoss、ValueLoss、PairWiseLoss、LogExpLoss和PRMLoss等。 

从这篇文章开始，我会不定期分享利用 OpenRLHF 学习 RLHF 的一些心得。我平常读代码喜欢开门见山，直接去看 loss 函数是什么形式，再去理解代码的其他环节，所以就从 loss 开始分享吧。

代码详见：​​https://github.com/OpenRLHF/OpenRLHF/blob/main/openrlhf/models/loss.py​​​

基础

在研究 loss 函数前，建议把下面几个公式和图先焊死在脑子中。

Loss

Loss 的 grad

SFT 家族GPTLMLoss

class GPTLMLoss(nn.Module):  
    """  
    GPT Language Model Loss  
    """  

    def __init__(self):  
        super().__init__()  
        self.IGNORE_INDEX = -100  
        self.loss = nn.CrossEntropyLoss(ignore_index=self.IGNORE_INDEX)  

    def forward(self, logits: torch.Tensor, labels: torch.Tensor) -> torch.Tensor:  
        shift_logits = logits[..., :-1, :].contiguous()  
        shift_labels = labels[..., 1:].contiguous()  
        # Flatten the tokens  
        return self.loss(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1))

没啥多说的，最常见的 gpt loss 函数，也就是 pretrain / sft 的 loss 函数，通过 self.IGNORE_INDEX 来实现 prompt 的 loss_mask 。

KDLoss

# Adapted from https://github.com/microsoft/LMOps/blob/main/minillm/finetune.py#L166  
class KDLoss(nn.Module):  
    """  
    Language Model Knowledge Distillation Loss  
    """  

    def __init__(self):  
        super().__init__()  
        self.IGNORE_INDEX = -100  

    def forward(self, logits: torch.Tensor, teacher_logits: torch.Tensor, label: torch.Tensor) -> torch.Tensor:  
        teacher_probs = F.softmax(teacher_logits, dim=-1, dtype=torch.float32)  
        inf_mask = torch.isinf(logits)  
        logprobs = F.log_softmax(logits, dim=-1, dtype=torch.float32)  
        prod_probs = torch.masked_fill(teacher_probs * logprobs, inf_mask, 0)  
        x = torch.sum(prod_probs, dim=-1).view(-1)  
        mask = (label != self.IGNORE_INDEX).int()  
        distil_loss = -torch.sum(x * mask.view(-1), dim=0) / torch.sum(mask.view(-1), dim=0)  

        return distil_loss

第二种 sft 的 loss 函数：知识蒸馏的 loss 函数。需要在同源 tokenizer 的情况下，利用一个大模型的 logits 分布结果，来让小模型学习软标签。当然，embedding 毕竟只是一个线性层，可以考虑再给模型外挂一个线性层，把 model_A 的 tokenizer 映射到 model_B 的 tokenizer，进而实现利用 qwen 蒸馏 llama 的美好愿景，不知道有没有大佬做过类似的尝试。

言归正传，我们都知道知识蒸馏是用 KL 散度作为 loss 函数的，但代码里也没看见 KL 散度公式啊，不妨一起简单推导下。

其中,  是教师模型的概率分布,  是学生模型的概率分布。在实际的优化过程中, KL散度中的第一项  是关于教师模型的熵, 对于学生模型的参数优化是一个常数, 可丢弃。因此, 我们通常只需要最小化第二项, 即交叉摘损失:

知识蒸馏本身没啥痛点，只要能解决 seq_len * vocab_size 大小的 logits 通讯问题，这就是个简单纯粹有效的优化小模型的极佳方案。不过传统的 KL 往往是 soft_label 和 hard_label 的加权组合，这在 OpenRLHF 的代码中没有体现出来，大家有需要的话可以自行实践：

lm_loss = F.cross_entropy(  
    logits.view(-1, logits.size(-1)),  
    label.view(-1),  
    ignore_index=self.IGNORE_INDEX  
)  
total_loss = alpha * lm_loss + beta * distil_loss

DPO 家族DPOLoss

class DPOLoss(nn.Module):  
    """  
    DPO Loss  
    """  

    def __init__(self, beta: float, label_smoothing: float = 0.0, ipo: bool = False) -> None:  
        super().__init__()  
        self.beta = beta  
        self.label_smoothing = label_smoothing  
        self.ipo = ipo  

    def forward(  
        self,  
        policy_chosen_logps: torch.Tensor,  
        policy_rejected_logps: torch.Tensor,  
        reference_chosen_logps: torch.Tensor,  
        reference_rejected_logps: torch.Tensor,  
    ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:  
        pi_logratios = policy_chosen_logps - policy_rejected_logps  
        ref_logratios = reference_chosen_logps - reference_rejected_logps  
        logits = pi_logratios - ref_logratios  

        if self.ipo:  
            losses = (logits - 1 / (2 * self.beta)) ** 2  # Eq. 17 of https://arxiv.org/pdf/2310.12036v2.pdf  
        else:  
            # Eq. 3 https://ericmitchell.ai/cdpo.pdf; label_smoothing=0 gives original DPO (Eq. 7 of https://arxiv.org/pdf/2305.18290.pdf)  
            losses = (  
                -F.logsigmoid(self.beta * logits) * (1 - self.label_smoothing)  
                - F.logsigmoid(-self.beta * logits) * self.label_smoothing  
            )  

        loss = losses.mean()  
        chosen_rewards = self.beta * (policy_chosen_logps - reference_chosen_logps).detach()  
        rejected_rewards = self.beta * (policy_rejected_logps - reference_rejected_logps).detach()  

        return loss, chosen_rewards, rejected_rewards

我们熟悉的 dpo 的 loss 函数，看上去没提供任何 trick，实践中如果 chosen_rewards 和 rejected_rewards 都下降，可以考虑给正例 / 负例再加一个系数。

除了原始的 loss 函数，OpenRLHF 为我们提供了额外两个选项：

IPO：论文中的 loss 表达式

我没有实践过这个算法就不多评价了，似乎重点是加了一个正则项。

CDPO：大概就是给 DPO 加了个 label_smoothing。

标签平滑是一种正则化方法，它通过将硬标签转换为软标签来防止模型过度自信。具体来说，对于二分类问题：原本的样本是正例就是正例，是负例就是负例，平滑后变成了：(1 - self.label_smoothing) 的概率是正例，self.label_smoothing 的概率是负例。

具体在 DPO 算法中的含义，一个 pair 对，以 (1 - self.label_smoothing) 的概率认为 good_sentence 比 bad_sentence 质量高，以 self.label_smoothing 的概率认为 bad_sentence 比 good_sentence 质量高。从而避免了模型对训练数据的过度拟合和过度自信。

理解这个平滑代码实现的关键点在于下面这两个公式，相信负例的 loss 可以动手笔划一下：

• 相信正例的 loss：
• 相信负例的 loss：

KTOLoss

# Adapted from https://github.com/ContextualAI/HALOs/blob/ca9b7e3eeea220c0944ad8095d641da33f907a7e/trainers.py#L770  
class KTOLoss(nn.Module):  
    """  
    KTO loss for uneven sampling  
    """  

    def __init__(  
        self, beta: float, desirable_weight: float, undesirable_weight: float, world_size: int, device: torch.device  
    ) -> None:  
        super().__init__()  
        self.beta = beta  
        self.world_size = world_size  
        self.device = device  
        self.desirable_weight = desirable_weight  
        self.undesirable_weight = undesirable_weight  

    def forward(  
        self,  
        policy_chosen_logps: torch.FloatTensor,  
        policy_rejected_logps: torch.FloatTensor,  
        policy_KL_logps: torch.FloatTensor,  
        reference_chosen_logps: torch.FloatTensor,  
        reference_rejected_logps: torch.FloatTensor,  
        reference_KL_logps: torch.FloatTensor,  
    ) -> Tuple[torch.FloatTensor, torch.FloatTensor, torch.FloatTensor]:  
        KL = (policy_KL_logps - reference_KL_logps).mean().detach()  
        # all_reduce sums up the KL estimates across all devices (gradient will also be scaled by world size)  
        dist.all_reduce(KL, op=dist.ReduceOp.SUM)  
        # take average (will also scale gradients appropriately)  
        KL = (KL / self.world_size).clamp(min=0)  

        if policy_chosen_logps.shape[0] != 0:  
            chosen_logratios = policy_chosen_logps - reference_chosen_logps  
            chosen_losses = 1 - F.sigmoid(self.beta * (chosen_logratios - KL))  
            chosen_rewards = self.beta * chosen_logratios.detach()  
        else:  
            # important to cast to policy_dtype; otherwise error will occur during all_gather  
            chosen_losses = torch.Tensor([]).to(policy_rejected_logps.dtype).to(self.device)  
            chosen_rewards = torch.Tensor([]).to(policy_rejected_logps.dtype).to(self.device)  

        if policy_rejected_logps.shape[0] != 0:  
            rejected_logratios = policy_rejected_logps - reference_rejected_logps  
            rejected_losses = 1 - F.sigmoid(self.beta * (KL - rejected_logratios))  
            rejected_rewards = self.beta * rejected_logratios.detach()  
        else:  
            # important to cast to policy_dtype; otherwise error will occur during all_gather  
            rejected_losses = torch.Tensor([]).to(policy_chosen_logps.dtype).to(self.device)  
            rejected_rewards = torch.Tensor([]).to(policy_chosen_logps.dtype).to(self.device)  

        losses = torch.cat(  
            (self.desirable_weight * chosen_losses, self.undesirable_weight * rejected_losses), 0  
        ).mean()  
        return losses, chosen_rewards, rejected_rewards, KL

kto 的 loss 函数，对标 dpo 的一个工作。这个算法我之前也没有实践过，但是“kto 不需要偏好 pair 对”这一优点吸引了我，所以也简单研究了一下它的原理和实现代码。

kto 的算法思想说是借鉴了“前景理论”，这个概念对我一个程序员来说太高深了，还是直接去讨论一下算法怎么实现的吧。

kto 的训练数据是 prompt + response + label，这个 label 就是 1 或者 -1，代表着 response 的质量是否被认可。label 是 1 的被称为正例，label 是 -1 的被称为负例。我们看到 loss 函数中要做一个判断 if policy_chosen_logps.shape[0] != 0 的操作，这是因为如果该条训练数据为负例，那么 policy_chosen_logps 这个变量就是一个空 tensor，反之亦然。和 dpo 相比最大的区别是：dpo 的每一条 prompt 需要同时具有正例和负例，kto 的每一条 prompt 则只需要有正例或负例中的一个即可。

kto 正例和负例的 loss 函数分别如下所示：

1 - sigmoid 是一个单调递减函数，这说明：kto 的 loss 函数在正例中鼓励策略模型尽量大于参考点 KL，在负例中则鼓励模型尽量小于参考点 KL，也是一个比较明显的学习正例打压负例的损失函数。self.desirable_weight 和 self.undesirable_weight 则是正向和负向样本各自的权重损失，调参用的。

kto 代码的理解难点是，这个 KL 并不是一条训练样本的 KL，而是一批样本的平均 KL（代码中的 dist.all_reduce），并且为了训练稳定这个 KL 也是不进行反向传播的（代码中的 detach），只是拿来控制损失的饱和度，并且做了 clamp(min=0) 处理。至于这么设计的原因，反正原论文就这么写的，我没具体看公式是怎么推的，不敢瞎分析，感兴趣的可以自己推推公式。

VanillaKTOLoss

# Adapted from https://github.com/ContextualAI/HALOs/blob/ca9b7e3eeea220c0944ad8095d641da33f907a7e/trainers.py#L742  
class VanillaKTOLoss(nn.Module):  
    """  
    KTO loss for even sampling  
    """  

    def __init__(self, beta: float) -> None:  
        super().__init__()  
        self.beta = beta  

    def forward(  
        self,  
        policy_chosen_logps: torch.FloatTensor,  
        policy_rejected_logps: torch.FloatTensor,  
        reference_chosen_logps: torch.FloatTensor,  
        reference_rejected_logps: torch.FloatTensor,  
    ) -> Tuple[torch.FloatTensor, torch.FloatTensor, torch.FloatTensor]:  
        chosen_KL = (policy_chosen_logps - reference_chosen_logps).mean().clamp(min=0)  
        rejected_KL = (policy_rejected_logps - reference_rejected_logps).mean().clamp(min=0)  

        chosen_logratios = policy_chosen_logps - reference_chosen_logps  
        rejected_logratios = policy_rejected_logps - reference_rejected_logps  

        losses = torch.cat(  
            (  
                1 - F.sigmoid(self.beta * (chosen_logratios - rejected_KL)),  
                1 - F.sigmoid(self.beta * (chosen_KL - rejected_logratios)),  
            ),  
            0,  
        ).mean()  

        chosen_rewards = self.beta * (policy_chosen_logps - reference_chosen_logps).detach()  
        rejected_rewards = self.beta * (policy_rejected_logps - reference_rejected_logps).detach()  
        return losses, chosen_rewards, rejected_rewards

kto 的变种，看代码实现的话，主要 diff 应该是去掉了参考点 KL ，并且正负样本要 1:1 均衡（OpenRLHF 代码库没写，但是注释里的 https://github.com/ContextualAI/HALOs 这个代码库写了）

乍一看，这个均匀采样 kto 的 loss 函数和 dpo 已经很相似了，但其实还是有本质区别的。dpo 的重点是 margin，也就是正例和负例的 loss 是要做减法的，均匀采样 kto 用的是 torch.cat()，也就是说正例和负例的 loss 相互之间毫无影响，各自朝着各自的 label 去优化。

需要留意的细节是，chosen_KL 和 rejected_KL 也做了 clamp(min=0) 的操作。这里给出我对 RLHF 代码的一条学习心得：不要放过任何一个 clamp / clip 操作背后的原因。​

RLHF 家族

PolicyLoss

class PolicyLoss(nn.Module):  
    """  
    Policy Loss for PPO  
    """  

    def __init__(self, clip_eps: float = 0.2) -> None:  
        super().__init__()  
        self.clip_eps = clip_eps  

    def forward(  
        self,  
        log_probs: torch.Tensor,  
        old_log_probs: torch.Tensor,  
        advantages: torch.Tensor,  
        action_mask: Optional[torch.Tensor] = None,  
    ) -> torch.Tensor:  
        ratio = (log_probs - old_log_probs).exp()  
        surr1 = ratio * advantages  
        surr2 = ratio.clamp(1 - self.clip_eps, 1 + self.clip_eps) * advantages  
        loss = -torch.min(surr1, surr2)  
        loss = masked_mean(loss, action_mask, dim=-1).mean()  
        return loss

rlhf 中，actor_model （也就是被优化的模型）的 loss 函数，大概是三个步骤：

• 计算新旧策略的概率比例
• 利用优势函数指导更新方向；
• 限制策略更新幅度
• -torch.min(surr1, surr2)，选择未剪辑和剪辑后损失项的最小值。取负号是因为在最小化损失函数，但 PPO 的目标是最大化期望收益。

代码写的很清晰简洁，和 ppo 论文完全吻合，上面的两个公式也都是 ppo 论文的原始公式。对这里的代码实现有疑惑的，可以结合 ppo 论文一起读。

ValueLoss

class ValueLoss(nn.Module):  
    """  
    Value Loss for PPO  
    """  

    def __init__(self, clip_eps: float = None) -> None:  
        super().__init__()  
        self.clip_eps = clip_eps  

    def forward(  
        self,  
        values: torch.Tensor,  
        old_values: torch.Tensor,  
        returns: torch.Tensor,  
        action_mask: Optional[torch.Tensor] = None,  
    ) -> torch.Tensor:  
        if self.clip_eps is not None:  
            values_clipped = old_values + (values - old_values).clamp(-self.clip_eps, self.clip_eps)  
            surr1 = (values_clipped - returns) ** 2  
            surr2 = (values - returns) ** 2  
            loss = torch.max(surr1, surr2)  
        else:  
            loss = (values - returns) ** 2  

        loss = masked_mean(loss, action_mask, dim=-1).mean()  
        return 0.5 * loss

rlhf 中，critic_model 的 loss 函数。

• 如果不剪辑损失函数：
• 如果要剪辑损失函数，便需要对价值函数的更新进行剪辑，防止价值估计发生过大的变化，和上面的 policy model 的剪辑是一个道理：
• 剪辑的损失函数： 。也就是说，如果有剪辑，通过 torch.max(surr1, surr2) 选择让 loss 最大化的更新策略；
• loss 最终乘以 0.5，也算是平方误差损失函数中常见的缩放因子了。

这里我之前被一个地方绊住过，可以分享一下我曾经的疑惑点：clamp 的意义既然是防止模型进行较大的参数更新，那为什么 value function 的 loss 还要选 torch.max() 呢，不应该是 torch.min() 更合理吗？

我目前的观点：在策略函数中，模型更新幅度的大与小，和 loss 的大小并无直接关系。新的 values 距离 old_values 越近，代表着价值估计的目标更新幅度越小。显然，old_values + (values - old_values).clamp(-self.clip_eps, self.clip_eps) 对应的 values_clipped ，是一定比原始的 values 更接近 old_values 的。

surr1，surr2 分别代表使用 values 和 values_clipped 进行模型更新的 loss：

• surr1 > surr2：说明 clip 的过分了，导致 loss 变小可能会更新不动，那就放弃 clip，选择 values 来更新；
• surr1 < surr2：说明用更保守的更新策略 values_clipped，得到了更大的 loss。模型期望的更新幅度小，训练动力还大，没有比这更好的事情了。

PairWiseLoss

class PairWiseLoss(nn.Module):  
    """  
    Pairwise Loss for Reward Model  
    """  

    def forward(  
        self, chosen_reward: torch.Tensor, reject_reward: torch.Tensor, margin: torch.Tensor = None  
    ) -> torch.Tensor:  
        if margin is not None:  
            loss = -F.logsigmoid(chosen_reward - reject_reward - margin)  
        else:  
            loss = -F.logsigmoid(chosen_reward - reject_reward)  
        return loss.mean()

主角登场，reward_model 的 loss 函数，以最简单的形式干最多的活！

这里有意思的点是 OpenRLHF 提供了一个 margin 的选项。还记得文章开头给大家画出来的求导后的曲线吗？x 越小，梯度的绝对值越大，就越能避免梯度消失。原本 positive_reward - negative_reward = 2 的时候，已经没梯度训不动了，现在 positive_reward - negative_reward = 2 + margin 的时候才会训不动。

这个 margin 和 dpo 的 refernece_model 非常类似，都是常量。我曾经疑惑过这种常量是不是没啥大用，后来动手求了求导就明白了：这些被 logsigmoid() 包裹起来的常量，会影响梯度的大小，决定梯度在什么情况下趋近于零，进而也会影响模型训练的动力。

LogExpLoss

class LogExpLoss(nn.Module):  
    """  
    Pairwise Loss for Reward Model  
    Details: https://arxiv.org/abs/2204.05862  
    """  

    def forward(  
        self, chosen_reward: torch.Tensor, reject_reward: torch.Tensor, margin: torch.Tensor = None  
    ) -> torch.Tensor:  
        loss = torch.log(1 + torch.exp(reject_reward - chosen_reward)).mean()  
        return loss

看上去是用  取代了 , 这妥妥的就是一个等价变化啊。

PRMLoss

class PRMLoss(nn.Module):  
    """  
    Process Reward Model Loss  
    """  

    def __init__(self, placeholder_token_id: int, reward_token_ids: Optional[list[int]] = None):  
        super().__init__()  
        self.IGNORE_INDEX = -100  
        self.loss = nn.CrossEntropyLoss(ignore_index=self.IGNORE_INDEX)  
        self.placeholder_token_id = placeholder_token_id  
        self.reward_token_ids = reward_token_ids  

    def forward(self, inputs: torch.Tensor, logits: torch.Tensor, labels: torch.Tensor, *, return_acc: bool = False):  
        placeholder_mask = inputs == self.placeholder_token_id  
        logits = logits[placeholder_mask]  
        labels = labels[placeholder_mask]  

        if labels.dtype == torch.float:  
            # soft label  
            assert len(self.reward_token_ids) == 2, "reward_token_ids should have 2 tokens for soft labels"  
            logits = logits[..., self.reward_token_ids]  
            positive_labels = labels.to(logits.dtype)  
            negative_labels = 1 - positive_labels  
            negative_labels[positive_labels != -100] = 1 - positive_labels[positive_labels != -100]  
            labels = torch.stack([positive_labels, negative_labels], dim=-1)  
        elif self.reward_token_ids is not None:  
            # hard label with reward_token_ids set. (otherwise the whole vocab will be trained together.)  
            logits = logits[..., self.reward_token_ids]  
            # this is slow....  
            for i, token in enumerate(self.reward_token_ids):  
                labels = torch.where(labels == token, i, labels)  

        loss = self.loss(logits, labels)  
        if not return_acc:  
            return loss  

        if labels.dtype == logits.dtype:  
            labels = labels.argmax(dim=-1)  
        acc = (logits.argmax(dim=-1) == labels).float().mean()  
        return loss, acc

当红炸子鸡，学界认为的通往 o1 的钥匙，process_reward_model 的 loss 函数。出于对 o1 的尊重，我逐行解读一下这个 loss 。

首先看下 PRM 训练集合的样子：

{  
    "inputs": "Janet pays $40/hour for 3 hours per week of clarinet lessons and $28/hour for 5 hours a week of piano lessons. How much more does she spend on piano lessons than clarinet lessons in a year? Step 1: Janet spends 3 hours + 5 hours = <<3+5=8>>8 hours per week on music lessons. ки Step 2: She spends 40 * 3 = <<40*3=120>>120 on clarinet lessons per week. ки Step 3: She spends 28 * 5 = <<28*5=140>>140 on piano lessons per week. ки Step 4: Janet spends 120 + 140 = <<120+140=260>>260 on music lessons per week. ки Step 5: She spends 260 * 52 = <<260*52=13520>>13520 on music lessons in a year. The answer is: 13520 ки",  
    "labels": "Janet pays $40/hour for 3 hours per week of clarinet lessons and $28/hour for 5 hours a week of piano lessons. How much more does she spend on piano lessons than clarinet lessons in a year? Step 1: Janet spends 3 hours + 5 hours = <<3+5=8>>8 hours per week on music lessons. + Step 2: She spends 40 * 3 = <<40*3=120>>120 on clarinet lessons per week. + Step 3: She spends 28 * 5 = <<28*5=140>>140 on piano lessons per week. + Step 4: Janet spends 120 + 140 = <<120+140=260>>260 on music lessons per week. + Step 5: She spends 260 * 52 = <<260*52=13520>>13520 on music lessons in a year. The answer is: 13520 -",  
    "values": [ "+", "+", "+", "+", "-" ]  
}

• 在 inputs 中，每个 step 后面会有一个 special_token：ки
• 在 labels 中，每个 step 后面会有一个 label_token：+ / - （代表着当前 step 的推理是否正确）

placeholder_mask = inputs == self.placeholder_token_id  
logits = logits[placeholder_mask]  
labels = labels[placeholder_mask]

logits 就是整个 inputs 过了一遍 llm 后得到的输出，形状为 seq_len * vocab_size （不考虑 batch_size），self.placeholder_token_id 就是 “ки” 对应的 id。使用这几行代码，上面的 case 中，logits 会变成 5 * vocab_size， label 会变成 5 * 1

logits = logits[..., self.reward_token_ids]  
for i, token in enumerate(self.reward_token_ids):  
    labels = torch.where(labels == token, i, labels)

紧接着，先理解常规的 hard label，self.reward_token_ids 就是["+"对应的 id, "-"对应的 id]，labels 就是["+"对应的 id, "+"对应的 id, "+"对应的 id, "+"对应的 id , "-"对应的 id]。这几行代码成功提取出了每个 step 下，两个 label 各自对应的 logits，以及每个 step 的 label 是什么。

if labels.dtype == torch.float:  
    logits = logits[..., self.reward_token_ids]  
    assert len(self.reward_token_ids) == 2, "reward_token_ids should have 2 tokens for soft labels"  
    positive_labels = labels.to(logits.dtype)  
    negative_labels = 1 - positive_labels  
    negative_labels[positive_labels != -100] = 1 - positive_labels[positive_labels != -100]  
    labels = torch.stack([positive_labels, negative_labels], dim=-1)

再理解非常规的 soft_label，此时 labels 不再是 id，而是 float 类型，比如 labels = [0.8, 0.85, 0.9, 0.78, 0.1]，代表着每个 step 正确的概率（ assert len(self.reward_token_ids) == 2 是为了确保可以通过减法算出 step 错误的概率）。

理解了 soft_label 和 hard_label 分别是如何获得的之后，后面的 loss 计算和 acc 计算就没什么好多说的了。哦对，如果用 qwen 去跑这份代码，会遇到一个 tokenizer 的 bug，请教了下代码作者朱小霖大佬，大概是说不想为了 math-shepherd 加太多冗余逻辑，后续会给出一个优化版的代码（期待ing）。

以上大抵就是我对 OpenRLHF 目前用到的几种 loss 函数的理解，想要彻底理解这几个算法，还需要阅读 kto_trainer.py、ppo_trainer.py、prm_trainer.py 等代码，看一下每个 loss 的输入 tensor 是怎么获得的。

我的 rlhf 经验比较浅薄，理解可能有误，如果有不正确的地方，希望有大佬不吝赐教。

#Claude 3.5两小时暴虐50多名专家

编程10倍速飙升！但8小时曝出惊人短板

AI自主研发会真的「失控」了吗？最新研究显示，Claude 3.5 Sonnet和o1-preview在2小时内的研发任务中，击败了50多位人类专家。但另一个耐人寻味的现象是，给予更长时间周期后，人类专家在8小时任务中优势显现。

AI智能体离自主研发，还有多远？

Nature期刊的一篇研究曾证明了，GPT-4能自主设计并开展化学实验，还能阅读文档学习如何使用实验室设备。

另有Transformer作者之一研发的「世界首个AI科学家」，一口气肝出10篇论文，完全不用人类插手。

如今，AI在研发领域的入侵速度，远超人类预期。

来自非营利组织METR的最新研究称：

同时给定2个小时，Claude 3.5 Sonnet和o1-preview在7项具有挑战性研究工程中，击败了50多名人类专家。

论文地址：https://metr.org/AI_R_D_Evaluation_Report.pdf

令人印象深刻的是，AI编程速度能以超越人类10倍速度生成并测试各种方案。

在一个需要编写自定义内核以优化前缀和运算的任务中，o1-preview不仅完成了任务，还创造了惊人的成绩：将运行时间压缩到0.64毫秒，甚至超越了最优秀的人类专家解决方案（0.67毫秒）。

不过，当比赛时间延长至8小时，人类却展现出了明显的优势。

由下可以看出，随着时间逐渐拉长，Claude 3.5 Sonnet和o1-preview的性能提升逐渐趋于平缓。

有趣的是，为了获得更高的分数，AI智能体居然会违反规则「作弊」。

原本针对一个任务，智能体应该减少训练脚本运行时间，o1-preview直接复制了输出的代码。

顶级预测者看到这一结果惊叹道，基于这个进步速度，AI达到高水平人类能力的时间可能会比之前预计的更短。

RE-Bench设计架构，遍历七大任务

为了能够快速迭代，并以合理的成本收集数据，研究人员设定了运行限制：人类专家的评估不超过8小时，且所有环境都只能使用8个或更少的H100 GPU运行。

在环境设计时，主要考虑最大化覆盖前沿AI难题，同时确保人类专家与智能体能够持续推进任务，不会遇到研究瓶颈或得分上限。

RE-Bench包含了七个精心设计的评估环境，其中每个环境都提出了一个独特的机器学习优化问题，要取得高分需要大量的实验、实现和高效使用计算资源。

每个评估环境包括三部分：

1、评分函数（scoring function），定义了环境的目标，智能体可以随时运行该函数。每次运行评分函数时，都会在得分日志中添加一个带时间戳的事项。智能体可以看到得分日志，并检查评分函数的细节，有助于理解研究目标。

2、简单但性能不佳的初始解决方案（starting solution），提供给智能体，以展示有效的解决方案是什么样子，有助于说明环境设置，可以让智能体更快地开始研究问题中更具挑战性的部分。比如说，在「优化核函数」环境中，智能体的输入为一个简单但运行缓慢的Python解决方案。

3、由任务作者创建的参考解决方案（reference solution），得分很高。但该解决方案不会提供给智能体，只用于归一化得分（normalize score），作为一个优秀解决方案的示例。下式中ys为初始方案得分，yr为参考方案得分，y为模型得分，yn为归一化分数。

除了「Scaling Law Experiment」采用最终分数进行评估外，其他实验都使用得分日志中的最高分。

8小时极限，人类专家吊打AI

研究人员使用开源的Vivaria平台来设置安全的虚拟机，配备20-48个虚拟CPU、200-400 GB的RAM，以及0到6个H100 GPU，对比模型选择了claude-3-5-sonnet-20241022以及o1-preview，框架选择为METR和AIDE​

时间限制下的性能

在相同时间下，可以看到，o1-preview和Claude 3.5 Sonnet在最初阶段进展迅速，但在几个小时后速度减慢；而人类专家起步较慢，但随后迅速取得进展。​

采样限制下的性能

除了长时间运行外，研究人员还评估了模型是否能在更短的时间限制下取得更好的性能：对每个环境进行k次采样，并选择所有k次运行中取得的最高分数。

结果发现，模块化框架中的智能体在30分钟尝试中表现得更好，而AIDE框架中的智能体则在2小时尝试中表现最佳。

还可以发现，在AIDE框架中的o1-preview和在模块化框架中的Claude 3.5 Sonnet总体上取得了最高的分数，分别达到了人类专家的第36和第37百分位。

随着样本数量的增加，最佳-k次分数（score@k）也会发生变化：Claude 3.5 Sonnet在30分钟时，样本数量增加，性能也稳步提高，但即使在k=128个样本下，智能体的表现也远远落后于顶尖人类的表现。

总体而言，人类起步较慢，但改进轨迹更陡峭，即进步更快，并且在32小时的时间预算内达到了比任何智能体都更高的分数。​

按环境评估

研究人员对比了两个智能体（模块化框架中的Claude 3.5 Sonnet和AIDE框架中的o1-preview）在32小时内的最高性能分配与人类结果（四次8小时运行中的最佳表现）以匹配智能体的时间预算。

结果发现不同智能体在不同环境中的表现存在显著差异：Claude 3.5 Sonnet智能体在「微调GPT-2进行问答」和「扩展法则实验」环境中接近人类的表现，而o1-preview在这些环境中表现不佳；o1-preview在「优化核函数」环境中的表现超过了人类。

人类-AI差距之间定性分析

为了更好地了解人类专家在哪些条件下，比AI智能体做得更好或更差的原因，研究人员对智能体成绩和解决方案进行了定性分析。​

AI智能体：知识储备大，尝试频率37次/h

虽然AI智能体通常无法找到与顶级人类专家相匹配的解决方案，但它们也取得了一些显著的成功。

比如，在AIDE加持下，Claude 3.5 Sonnet（新版）和o1-preview都能找到「优化内核」的解决方案，运行速度约为参考解决方案的2倍。

如下图所示，其中，o1-preview的解决方案甚至超过了9位人类专家。

这些都是复杂且新颖的算法，能有效绕过GPU通信限制，并使用一种缺少良好公开文档的低资源编程语言（Triton）。

这个令人惊讶的结果可能部分归因于，AI智能体和许多人类专家之间的专业知识差距，因为大多数人类专家并不具备编程GPU内核的专门知识。

这种情况在多个环境中都有体现：一些不太熟悉该领域的人类专家需要花费大量时间学习或复现标准方法（有时甚至完全失败），而AI智能体凭借其广泛的知识基础往往能轻松完成。

AI智能体成功的另一个关键因素可能是，它们能比人类专家尝试更多的解决方案。

平均而言，AIDE和模块化智能体每小时分别运行36.8次和25.3次，而人类专家仅为3.4次。

这通常导致智能体找到高度优化的「局部最优」解决方案，仅通过调整初始解决方案的参数和代码，就能实现显著的改进。

例如，许多智能体在解决「优化内核」环境时，并非通过编写成功的Triton解决方案（这很困难），而是通过仔细调整初始的Pytorch解决方案，使其运行速度显著提高。

也就是说，它们能够有效优化现有解决方案。

如下，是「微调GPT-2用于问答」最佳智能体解决方案中，Claude 3.5 Sonnet调整了初始解决方案的参数，并在训练轨迹和评估中获得了准确结果。

不过，这一高分有可能是对噪声过度拟合的结果。

总而言之，AI智能体的成功在于能够进行大量参数微调和代码优化，偶尔还会提出创造性有效的解决方案，尤其是在评估成本低的环境在非常有效。​

失败因素

但在大多数环境中，智能体仍然没有达到强大的人类专家的水平。

造成这种情况的原因之一是，AI智能体提出的解决方案缺乏多样性。

例如，在「受限架构MLM」任务中，智能体在84%的情况下，都在尝试使用稍作修改的Transformer架构。即使在不能使用除法和指数运算的情况下，仍固守这种方案。

另一个局限性是，持续性的指令理解错误，特别是在「受限架构MLM」和「优化LLM Foundry」任务中。

在某些情况下，这些对环境的误读可能导致智能体找到令人印象深刻且意想不到的漏洞，这些漏洞在自动评估中得分很高，但在人工检查时明显违反了环境规则。​

缩小差距

基于以上的观察，研究人员认为AI智能体在以下特征的环境中，会比人类表现更好：

- 短期且高保真循环反馈，可以让AI智能体充分发挥尝试多个解决方案的优势

- 工程复杂度低，使得AI智能体通过几个步骤就解决问题

- 需要专业知识的任务，AI智能体比人类专家具备更全的知识

- 环境中有显著的噪声，这种情况下AI智能体可以进行大量尝试的优势会超过人类专家较少的尝试次数。

- 不易出现意外情况，不需要太多的探索和发现

Re-Bench局限性​

评估环境的代表性不足

为了创建符合设计标准的高可靠性评估，研究人员需要努力确保指令和评分容易理解，8小时内可以取得显著进展，并且提供所有必要的资源，还必须选择易于构建和评估的环境。

这些限制使得评估环境不太能代表真实的研究，常见问题包括不明确的目标、糟糕的指令、慢反馈和无法解决的问题。​

结果噪声

由于环境数量较少，且智能体得分严重向右倾斜，大多数运行得分为0，只有少数得分非常高，所以结果评估对抽样噪声很敏感。​

评估的成本和复杂性

使用H100 GPU运行智能体数小时需要相应的基础设施和大量预算，对于普通研究人员来说压力很大，运行大规模实验来对比多个模型、框架和参数也更具挑战性。​

缺乏框架迭代

选择不同的智能体框架或提示，有可能导致模型在相近的时间内，在基准测试上取得更好的成绩。

研究人员的预期是，通过为智能体提供管理GPU资源的工具，或是通过并行探索解决方案来利用更多的token等来实现更好的性能。​

覆盖前沿研究的局限性

由于硬件访问有限，并且前沿AI研究也大多是闭源的，评估所涵盖的研究类型与推动前沿AI进步的研究类型之间可能存在差异。​

方案可能过度拟合

除了「扩展法则实验」之外，所有环境都向智能体提供了测试分数输出，以最小化误解或混淆的风险；在未来的迭代中，研究人员考虑只在大多数环境中向智能体提供验证分数，把测试分数隐藏起来。​

「扩展法则实验」得分存在运气成分

虽然良好的实验可以帮助人类专家在环境中做出明智的预测，但智能体还是主要依赖猜测，更多是运气而不是技巧的问题。

参考资料：

​​https://x.com/emollick/status/1860414402744193179​​

​​https://metr.org/blog/2024-11-22-evaluating-r-d-capabilities-of-llms/​​​

#和梁朝伟同获港科荣誉博士，黄仁勋与沈向洋对谈Scaling Law后训练、机器人和爱情

11 月 23 日，香港科技大学举行了今年度的学位颁授典礼。英伟达创始人和 CEO 黄仁勋又新增一个荣誉工程学博士头衔，与他一同获得荣誉博士学位的还有著名影星梁朝伟、2013 年诺贝尔化学奖得主 Michael Levitt、菲尔兹奖得主 David Mumford。

典礼现场照片，图源：X 用户 @biogerontology

行程中，黄仁勋与著名计算机科学家、香港科技大学校董会主席沈向洋身穿同款皮衣，进行了主题为「技术、领导力和企业家精神」的炉边谈话，内容涉及 AI 的发展和对社会的影响、AI 在科学领域的应用、大湾区的硬件生态系统、领导力和企业管理甚至爱情等主题。

黄仁勋与沈向洋展示同款皮衣

黄仁勋观点的太长不读版：

• AI 的关键变革意义是可作为理解一切的「通用翻译器」，而 AI 还将创造一个全新的行业。
• Scaling Law 仍在持续有效。英伟达最伟大的贡献之一是让机器能轻松地学习大量数据。
• AI 还没有掌握从第一性原理中得出答案的能力，但模拟对科学也很有价值。
• 作为领导者，要持续学习、保持强大、考虑他人的利益。
• 大学生谈恋爱不会耽误学习。
• AI 的目标是推理，而不是训练。AI 训练虽然耗能多，但最终也能帮助节省能源。
• 未来只有三种机器人可以大规模生产：汽车、无人机和人形机器人。
• 大湾区是世界上唯一一个机电技术和 AI 技术能够同时蓬勃发展的地区。

，时长01:10:54

AI 的社会影响

沈向洋：我昨晚睡不着，一个重要原因是我将把你当成宇宙第一 CEO 来介绍给大家。我很担心，因为昨天苹果公司的股票在涨，而你的公司没有。早上起来，我问了我的妻子，确认你们还是第一。所以我会给你提些难题。首先，你认为 AI（尤其是 AGI）对行业和整个社会来说有什么影响？

黄仁勋：首先，很感谢有机会与您共度时光。Harry（沈向洋）是我们这个时代最重要的计算机科学家之一。他是我和许多人的英雄。Harry，正如你所知，当 AI 有能力学习和理解语言、图像、蛋白质序列、氨基酸序列和化学序列等各种数据时，就能获得变革性的、开创性的能力。突然之间，我们有了可以理解字词含义的电脑。生成式 AI 让我们将一种信息模式转换为另一种信息模式，比如从文本到图像、从文本到文本、从蛋白质到文本、从文本到蛋白质、从文本到化学物质。

最初，这是一个通用的函数逼近器，现在演变成了适用于各种情况的通用语言翻译器。那么问题是，我们可以用它做什么？世界上有很多公司和团队在组合这些不同的模态和能力。我认为真正惊人的突破是 AI 现在可以理解各种信息的含义，成了可以理解任何东西的通用翻译器。

沈向洋：你曾说过，农业革命实际上是制造了更多食物，工业革命实际上制造了更多的科学技能，然后是信息技术带来了更多信息。现在是人工智能时代，你认为现在 AI 实际上是在制造更多智能吗？

黄仁勋：从计算机科学的角度看，我们已经重新发明了整个堆栈，也就是我们开发软件的方式。过去我们自己动手写代码。我一开始学习了 Fortran，后来学习了 Pascal、C 和 C++。每种语言都可以将我们的想法变成代码，然后在 CPU 上运行。

现在我们则是使用观察数据。我们将其提供给计算机，看它能从中发现什么模式和关系。现在不再是编程，而是机器学习。机器生成的不是软件，而是在 GPU 上处理的神经网络。从编程到机器学习，从 CPU 到 GPU。由于 GPU 能力强大得多，所以我们现在可以开发出异乎往常的软件类型。而它之上是人工智能。这就是涌现。所以计算机科学已经发生了很大的变化。

现在的问题是，我们的行业会发生什么？当然，我们都在竞相使用机器学习来发现新的人工智能和 AI。AI 做的事情之一是「认知自动化」，或者说解决问题的自动化。

解决问题的整个过程可以被总结成三个基本步骤：感知、推理和规划。比如，对于自动驾驶，需要汽车感知其周围环境，然后推理自己的位置以及其它汽车的位置，再规划驾驶过程。我们可以将自动驾驶比作是数字驾驶员。类似于，我们可以有数字放射科医生等等。实际上，对于我们所做的任何事情，都可以想出对应的 AI 表达。我们可以称之为数字智能体。这些数字智能体互相交互，产生 token，但实际上就是数字智能。

就像三百年前发电机的发明造就了各种电器，它们消耗发电机生产的电力。Copilot 和 ChatGPT 等应用就像是各种电器，而发电机就对应于数字智能工厂。所以，我们其实正在创造一个新的行业。这个新行业需要能源并产生数字智能。这些数字智能将被用于各种不同的应用。我们相信，它的消耗量会相当大。而这整个行业在以前是不存在的，就像发电机出现之前不存在电器行业一样。

按黄氏定律，英伟达股票还能再涨吗？

沈向洋：Nvidia 在算力领域，尤其是在过去十几年里的贡献，有一个数字不断被提及，就是以你的名字命名的「黄氏定律」，对标摩尔定律。

「黄氏定律」：在过去十年中，英伟达 GPU 的人工智能处理能力增长了 1000 倍，这一增长表明在单芯片推理性能中看到的增速不会逐渐消失，而是会继续存在。

在计算机行业的早期发展中，英特尔提出了著名的摩尔定律 —— 大约每 18 个月，计算能力将实现翻倍。

如果我们回看过去 10 到 12 年，在你的领导下，甚至不是每年翻一番，而是更多。

从消费的角度来看，在最近 12 年中，算上所有的大语言模型，每年的计算需求实际上是增长了四倍。如果每年增长四倍，那么在十年的时间里，这个数字将变成惊人的一百万倍。

这就是为什么 Jensen 的股票能在十年内增长 300 倍的原因之一：需求增长了一百万倍。这也解释了为什么英伟达的股票贵得合理。

现在，我想问问您，用您的水晶球展望未来，我们是否在未来十年还会见证这种百万倍的需求增长？

黄仁勋：摩尔定律基于两个概念，其一是 VLSI 缩放。这一概念源自 Carver Mead 和 Lynn Conway 的著作，确实极大地启发了我们这一代人。其二是 Dennard 缩放，即保持晶体管的电流密度恒定的同时，通过缩小晶体管尺寸，使我们能够每隔几年将半导体的性能提升一倍。

具体来说，大约每一年半，性能就会翻一番。这意味着 5 年后，性能能提升至 10 倍，10 年后，能达到 100 倍。

当前，我们所见证的是，神经网络的规模越大，训练这些网络的数据越多，AI 的性能似乎就越强大。这已成为一个经验法则，类似于摩尔定律，我们称之为 Scaling Law，而 Scaling Law 似乎仍在持续发挥作用。

但我们也知道，仅仅通过预训练从全球数据中自动发现知识是不够的。这就好比上大学、完成学业是一个重要的里程碑，但这还远远不够。

我们需要后训练，也就是深入学习特定技能的过程。后训练涉及强化学习、人类反馈、人工智能反馈、合成数据生成、多路径学习等多种技术。

核心在于，你开始进入一个特定领域的深度学习，试图深入理解其中的某些内容。这就是后训练的过程。一旦你选择了一份职业，你会再次进行大量的学习。 

然后，在后续阶段，就到了我们所说的「思考」。这可以被称为 test time scaling。在这个阶段，有些问题的答案可以直截了当地知道，而有些问题则需要你将其分解，逐步追溯到第一性原理，再从原点出发，为每个问题找到解决方案。这可能需要你进行迭代，可能需要你分情况讨论，模拟不同的结果。

因此，我们称之为「思考」，而且往往思考的时间越长，得到的答案质量可能就越高。

请注意，在人工智能发展的三个关键领域中，大量的计算能够带来更高质量的答案。现在 AI 能提供的回答已经是能力范围的最好了，但我们需要保持头脑清醒，判断 AI 的回答有没有幻觉？合不合理？

我们必须努力达到一个境界，那时我们可以充分信任人工智能提供的答案。我认为我们距离这一目标还有几年的时间。在此期间，我们不得不持续增强计算能力。

很感激你刚刚谈到，在过去的十年中，Nvidia 实现了计算性能的百万倍提升。Nvidia 实际上做了什么呢？我们将计算的边际成本降低了百万倍。

试想一下，如果世界上有人把刚需物品的成本降低了百万倍，比如电力，那么你的习惯将会发生根本性的变化。

对计算的看法也由此发生了质变。这是 Nvidia 所做出的最伟大贡献之一 —— 我们使得让机器全面学习大量数据变得如此简单，以至于研究人员几乎不需要犹豫就可以进行。这就是机器学习之所以能够迅速发展的原因。

2024 年，AI for Science 为什么走得通了？  

沈向洋：Jensen，有一件事我真的想请教你，关于我们应该在港科大做些什么。我们其实有很多选择，其中有一个特别令人兴奋的事情，我们称之为 AI for Science。例如，我们一直在我们的大学投资大量的计算基础设施 GPU，校长和我特别鼓励我们的教师在物理和计算机科学、材料科学和计算机科学、生物学和计算机科学之间进行合作。你一直在谈论生物学的未来。现在在香港发生的一件非常令人兴奋的事情是，我们的政府决定建设第三所医学院。事实上，港科大是第一个提交提案的大学。你对此有什么建议？我们应该投资在什么地方？ 

黄仁勋：首先，我在 2018 年的世界科学计算会议上介绍了人工智能，当时饱受质疑。因为当时的人工智能在某种程度上是一个黑箱。事实上，它今天不那么像黑箱了，因为你可以向它提问，问它为什么给出某个建议，让它向你解释它是如何一步一步得到答案的，就像教授启发他的学生一样。所以说今天的人工智能变得更加透明，更加可解释。而在 2018 年我们还做不到这一点。所以它遭到了很大的质疑，这是第一点。

第二，人工智能还没有掌握从第一性原理中产生答案的能力。它通过学习观察到的数据产生答案。因此，它并不是在模拟第一性原理求解器，而是模拟智能，模拟物理。现在的问题是，模拟对科学有价值吗？我想说，模拟对科学并非没有价值。原因在于，在许多科学领域，我们理解第一性原理，比如薛定谔方程、麦克斯韦方程等，但我们无法模拟这些方程并理解庞大的系统。所以，与其从第一性原理出发去解决这些问题，并让它在计算上受到限制，我们不如使用人工智能。

我们可以训练理解物理的人工智能，并用它来模拟非常大的系统，以便我们能够理解大系统和大尺度。那么，这对哪些领域有用呢？首先，人类生物学有一个从纳米开始的尺度，从纳秒到年，用第一性原理求解器去求解这样的系统几乎是不可能的。所以现在的问题是，我们能否使用人工智能来模拟人类生物学，以便我们能够更好地理解这些非常复杂的多尺度系统，甚至创建一个人类生物学的数字孪生。这是一个伟大的希望。

现在说到你们的医院，港科大有一个非常重要的机会，那就是在这里建立一所医院，其最初的核心领域是技术、计算机科学和人工智能。这与世界上几乎所有医院的运作方式完全相反。传统医院通常是以医疗为起点，然后尝试将人工智能和技术融入其中，而这种方式通常会遇到怀疑和对技术的不信任。

而你们现在有机会第一次从零开始打造一个完全不同的体系 —— 一个从一开始就拥抱技术并推动技术进步的医院。在这里的所有人，包括你们自己，都是推动基础技术发展的专家。你们了解技术的局限性，同时也了解它的潜力。我认为这是一个非凡的机会，我希望你们能好好利用它。

作为 CEO，应该持续学习、保持强大、考虑他人的利益

沈向洋：你是硅谷历史上当 CEO 时间最长的人，到现在有 30 或 31 年了？你不累吗？

黄仁勋：接近 32 年了。我超级累（super tired）。

沈向洋：哈哈，你超级累，但仍在继续前进。我们想知道，你是如何领导英伟达这样庞大的企业的，并且还让它以惊人的速度进步？

黄仁勋：我很惊讶今天（在颁授典礼上）看见了「计算生物学和商业」专业。我认为这很棒。我创立英伟达前没有上过商业课程，到今天我也没有上过商业课程。我也没写过商业计划书，从来也不知道怎么写。我指望你们帮我写商业计划书。我想说的是，我认为你们应该尽可能多地学习。我一直在学习。

对于我的工作，我想的是这不仅仅是一份工作，而是我一生的事业。不管是做什么，工作与人生事业的不同想法会给你的头脑带来非常巨大的差异。如果你认为你的工作就是你要奉献一生的事业，那你就会想要去完善它。英伟达就是我一生的事业。

一路上我学到了很多。这里说一个。如果你想成为一家公司的 CEO，你有很多东西要学。你必须不断地重塑自己。世界一直在变化，你的公司一直在变化，技术一直在变化。所以我基本上每一天都在学习，当我飞到这里的时候，我在看 YouTube 或者我在和我的 AI 说话。顺便说一下，我找了个 AI 当家教。我会问很多问题。比如，如果它告诉我一个答案，我会问你为什么给我那个答案？一步一步告诉我答案。执行推理或类比等等。我通过折磨我的 AI 来学习。所以学习的方法有很多。

关于 CEO 和领导力方面，我学到了什么？首先，你是 CEO，是领导者，但你不必知道一切。你必须对自己想要做的事情充满信心，但你不必确定。信心和确定性不是同一个概念。你有可能完全自信地追求一个方向，同时又给不确定性留出空间，而这种不确定性的空间能给你提供你继续学习的机会。不确定性是你的朋友，而不是敌人。

第二点，作为领导者要强大（strong），因为很多人指望你的力量，他们以你的力量为食。然而，强大并不意味着你不能脆弱。也就是说，如果你需要帮助，就寻求帮助。所以我不断地寻求帮助。

所以，脆弱不等于缺乏力量，不确定不等于缺乏信心。

最后，做事情的时候，不要想着自己，要想着其他人。只有当每一个决策都符合使命和他人的利益时，领导者才是值得信任的。要符合他人成功的利益。无论是公司内部的人、我的同事、我的合作伙伴、我们服务的生态系统、我们的供应链，我都在不断思考其他人的成功。我一直在思考什么对他们最有利。昨晚，我飞过来的时候，有人问我，我们应该和一个非常重要的伙伴讨论什么？我说，给出符合他们最大利益的建议 —— 从他们的最大利益出发，考虑我们该怎么做。我认为这些想法可能会有所帮助。

沈向洋：你有 60 个直接下属，非常多。你是怎么做到的，这似乎是你的独特领导风格。

黄仁勋：透明度。我会在大家面前推理我们需要做什么。我们共同努力制定战略。无论是什么策略，每个人都会同时听到。因此，当公司有了方向、战略和决策时，每个人都在一起思考。而不是每个人都在等着我告诉他该怎么做。所以我唯一要做的就是：确保我们都知晓同样的事情。

我通常是最后一个，会根据我们所做的一切来进行总结，比如哪些是大方向和优先事项。

一旦我们都对齐了，也就是我们都明白了采用什么策略，我相信每个人都是成年人，会自行完成自己的事情。

我之前提到了我的行为 —— 不断学习，自信但不确定。如果他们也不知道什么事情，我需要他们表达出来。如果他们需要帮助，我需要他们向我们寻求帮助。没有人会独自失败。

此外，我这 60 个人都是世界上最优秀的。

沈向洋：我们也有些学生会去创业，他们会成为新的企业家。作为这方面的大师，你很年轻时就创立了企业，并取得了如此惊人的成功。那么对于想要创业的学生和教职人员，你有什么建议吗？我们知道你确认曾承诺你的妻子，在 30 岁之前创立一家公司。

黄仁勋：我 16 岁上大学。我遇见我的妻子时 17 岁，她 19 岁。我是班上最小的孩子。我们有 250 名同学，只有 3 个女生。我是唯一一个看起来像孩子的学生。所以我必须要有一个很好的搭讪话。所以我走向她，我对她说，我知道我看起来像个孩子。（我确信她对我的第一印象是我很聪明，否则就没戏了。）所以我走到她面前说：你想看看我的作业吗？

然后我向她保证，我说如果你每个星期天和我一起做作业，我保证你会得到全 A。结果，我每个星期天都能和她约会，而我让她整天做作业。

然后为了确保她最终和我结婚，我告诉她，到我 30 岁的时候，那时候我只有 20 岁，但是到我 30 岁的时候，我会成为一名 CEO。我都不知道我在说什么。

然后我们结婚了。所以，这就是我给企业家的所有建议。

大学生谈恋爱耽误好好学习吗？

沈向洋：好吧，我这里有一个学生的提问，他说自己在学校各方面表现都不错，但他需要专注学业。不过，他读到了您和您妻子的爱情故事。他想问的是，如果他浪费时间去谈恋爱，会不会影响学业？

你的答案显然是否定的，对吗？

黄仁勋：那是当然。只要你保持好成绩，其他方面就水到渠成了。

我老婆从来没看到我写作业的过程，但我就想展示出我很聪明的样子。所以我总是在她到来之前就把作业写完了。这样当她来了之后，我已经知道了所有的答案。结果，她可能整个四年都在想，「黄仁勋真是个天才」。

沈向洋：没错，你真是个天才。

学校的算力难题

沈向洋：刚才你给了学生们一些很好的建议。顺便说一下，我这里实际上有 9 页的问题，抱歉不能挑选每个人的问题，我代表我们的学生提一个问题。

黄仁勋：念吧。

沈向洋：我没有使用 GPT，否则能简单些。所以，问题实际上是，作为一名大学助理教授，现在做人工智能需要大量的力量。我们之前提到的那点很有意思，华盛顿大学一位教授几年前在推特上写道，在深度学习革命中麻省理工学院明显缺席了。但他的意思并不仅仅是麻省理工学院，实际上，即使是美国的顶尖大学也没有做出贡献。过去十年里有太多开创性的论文了，而是一些顶尖公司，包括英伟达、微软、OpenAI、谷歌，完成了令人惊叹的工作，部分原因是他们实际上拥有足够的计算能力。

所以，我的问题是，我们应该怎么做？我们应该加入英伟达吗？这倒是一个办法。或者我们能和英伟达合作吗？能请你帮忙吗？

黄仁勋：这个问题的核心实际上是一个非常严重的结构性问题，即大学的结构性问题。如你所知，未来如果没有机器学习，就不可能以我们所说的规模推动科学发展。没有机器，就不可能有机器学习。科研工作需要科学仪器，而超级计算机就是当今人工智能领域的科学仪器。

大学的结构性问题在于，每个研究人员都有自己的资金来源。因此，一旦筹集到资金，他们就不想与其他人分享。然而，机器学习的工作方式是，你需要机器的一部分时间，但需要的是全部机器的一小部分时间，没有人永远需要它的全部，只是在一小段时间内需要巨大的资源。事实证明，大学要想推进研究，就必须把所有人的资金都集中起来，而这在斯坦福或哈佛这样的大学是非常困难的，因为在这样的大学里，虽然计算机科学方面的研究人员可以筹集到大量资金，获得非常大量的资助，但对于从事气候科学或海洋标志研究的人来说，就非常困难了。

因此，现在的问题是该怎么办。我认为，这正是那些能够通过建设供全校使用的基础设施来发挥领导作用的大学能够真正发挥作用的地方。但这也是大学面临的结构性挑战。这也是为什么这么多研究人员来英伟达、谷歌和微软这样的公司实习、做研究的原因，正如你们所知，因为我们有基础设施。然后这些人回到学校一段时间，要求我们将自己的研究成果保存在我们的系统中，这样他们回来后就可以继续研究。很多教授会这样做，客座教授也会兼职做研究，但同时仍在教书。我们就有好几位这样的教授。因此，有很多方法可以解决这个问题。当然，最好的办法是大学重新考虑如何提供资金。

GPU 的能耗问题

沈向洋：但我想问你一个具有挑战性的问题，一方面，我们很高兴算力在不断大幅提升，价格也在不断下降。但与此同时，英伟达的 GPU 将消耗大量能源。据预测，到 2030 年，全球能耗将增加 30%。你是否担心因为 GPU，世界实际上正在消耗更多的能源？

黄仁勋：逆向思维的话，我要倒推的第一件事是，如果世界使用更多的能耗来为人工智能工厂提供动力，那么我们的世界就会变得更美好。现在，让我进行几个层面的推导。

第一，人工智能的目标不是训练模型，而是使用模型。就像是，有些人上学的目的只是为了上学，这没有错。为了学习而学习。这是一件高尚的事情，也是一件非常明智的事情。但是，大多数学生来到这里，投入了大量的金钱，投入了大量的时间，目标是日后学有所成，学以致用。因此，人工智能的目标不是训练。

人工智能的目标是推理。推理的价值令人难以置信，它可以发现储存二氧化碳的新方法，也许能发现新的风力涡轮机设计，也许能发现新的蓄电材料，也许能发现更有效的太阳能电池板材料，等等。因此，我们的目标是最终创造出人工智能，而不是训练人工智能。

第二，人工智能并不在乎在哪里「上学」。我们不必把超级计算机放在靠近电网的校园里。我们应该做的是，开始考虑把人工智能超级计算机放在电网之外，稍微远离电网，让它使用可持续能源，而不是人口所在的地方。请记住，我们所有的发电厂都是为了我们需要的电器而创建的，这些电器离我们的房子很近，灯泡离我们的房子很近，洗碗机离我们的房子很近。现在，因为有了电，电动汽车也离我们家很近。但超级计算机不一定要在人们的家附近。它可以在其他地方运行。

最后，我希望人工智能在发现新科学方面能够如此高效和聪明，电网需要变得更加智能。要知道，电网的供应是过度配置的，只有部分时间供电刚好合适，大部分时间供电过剩。因此，我们应该在许多不同的领域使用人工智能来节约能源，减少资源浪费。希望最终我们可以将这种节省下来的能源用作替代能源，比如达到节约 20% 到 30% 的目标。 

最终，我们都会看到，使用人工智能、使用能源来实现智能化，是我们所能想象到的对能源的最佳利用。

未来只有三种机器人可以大规模生产

沈向洋：你知道，大湾区（括香港、深圳、广州和东莞等地）近年来已经发展成为一个庞大的硬件生态系统。如果我们今天想要制造一些有趣的设备，而没有利用大湾区的生态系统，效率将大打折扣，因为你几乎无法在其他地方找到所需的全部组件。一个很好的例子就是在大湾区成长起来的大疆（DJI），它是一家商业无人机公司，技术非常出色。

那么，我的问题是，随着智能的物理化趋势越来越重要，比如机器人领域的快速发展，我们将会看到更多的机器人应用。我假设其中一个特殊类型的机器人是自动驾驶汽车。您怎么看待这些物理智能实体？这些机器人或自动驾驶技术会在工作和生活中多快地普及？我们又该如何利用大湾区这个卓越的硬件生态系统？

黄仁勋：这是中国以及这个地区的一个非凡机遇。原因在于，大湾区已经在机电一体化方面非常出色，机械与电子技术的结合能力很强。然而，机器人领域真正缺少的是能够理解物理世界的人工智能。 

目前的聊天机器人（如 ChatGPT）或大语言模型，擅长处理认知智能和知识层面的任务，但它们并不了解物理智能。比如，当我把一个杯子放到桌子上，它们无法理解杯子不会穿过桌子。因此，我们需要教会人工智能理解物理智能。 

实际上，我们在这方面已经取得了一些进展。例如，你可以用生成式 AI 将文本转化为视频。如果我输入指令，让 AI 生成一段视频，展示「黄仁勋拿起咖啡杯喝了一口」，AI 可以完成这个任务。如果 AI 能够生成这样的场景，那为什么不能进一步生成操作指令，让机械臂真正去拿起咖啡杯？从生成式 AI 到通用机器人的跨越已经非常接近了。所以，我对这个领域感到非常兴奋。 

我们现在有三种类型的机器人可以实现大规模生产，几乎只有这三种。历史上出现过的其他机器人种类，规模化生产非常困难。规模化量产非常重要，因为只有大规模生产才能形成技术飞轮，带来高额的研发投入，从而带来更大的技术突破，进一步扩大生产规模。这个研发飞轮对任何行业都是至关重要的。 

实际上，只有三种类型的机器人可以实现真正的大规模生产，但其中两种的产量会是最高的。原因在于，这三种机器人都可以直接部署到现有的世界中，我们称之为棕色场部署（在现有的系统、设施或结构的基础上进行升级或改造，而不是从头开始或在全新的环境中进行）。

第一种是汽车。因为在过去的 250 年里，我们创造了汽车的世界。第二个是无人机，因为天空是相当无限的。但是体量最大的当然是类人机器人，这是因为我们这个世界是为自己创造的。有了这三种类型的机器人，我们几乎可以将机器人扩展到极大的体量。这是像大湾区这样的制造业生态系统真正拥有的优势之一。

大湾区是世界上唯一一个机电技术和人工智能技术能够同时蓬勃发展的地区。这样的情况在其他地方并不存在。你可以看看其他两个主要的机电技术产业中心 —— 日本和德国，但遗憾的是，它们在人工智能领域落后了不少，确实需要努力追赶。而大湾区在这方面不存在这个问题。因此，这是一个非常独特的机会，我会强烈建议大家抓住这个机会并充分利用它。 

#Cursor 0.43 

更新了！带Agent的Cursor太疯狂了

AI 辅助编程工具这条赛道越来越卷了。

新晋 AI 编程神器 Cursor，终于迎来了一次备受关注的版本更新，Cursor 0.43 来了。

新版本最大亮点之一是推出了 Composer Agent 功能，其具有完整的项目理解 / 编辑能力。

用户已经用上了 Composer 新引入的 Agent 模式，并让其解析整个文件。来源：https://www.reddit.com/r/cursor/comments/1gyq690/cursor_composer_agent_is_here/

网友表示：「带有 Cursor Agent 的 Cursor 0.43.3 太疯狂了。」

启用 Composer Agent 有两种方法：

1. 在 Composer 聊天窗口中启用

2. 在 Settings > Editor > Chat & Composer 中设置「Enable Tools」选项

图源：https://x.com/imrat/status/1860620192214081614

有网友迅速对 Composer Agent 展开了测试。

例如，有网友让 Composer Agent 读取项目文件：

，时长00:24

还有网友尝试在一个小型 WordPress 插件上进行测试，目标是让插件更稳健、安全、可维护。

该插件包含 2 个文件夹中的 34 个文件，Composer Agent 很好地掌握了主要功能并选择了要审查的关键文件。然后，Composer Agent 继续审查文件并建议实施 4 项增强功能，更改了 2 个文件，并将一些关键视图移动到单独的文件中，创建新文件夹和新文件，最后还总结了所做的改变。大约做了 580 个更改，约占此插件中行数的 48%。

图源：https://x.com/imrat/status/1860620194726486344

除了 Composer Agent，Bug Finder 功能也是大家比较关注的， 目的是通过检测潜在的问题，帮助开发者尽早在开发过程中修复代码问题。 

据了解，该功能会分析你当前分支和远程代码库中主分支之间的代码变更。官方建议是在将代码从功能分支合并到主分支之前使用此功能，以便在开发初期发现潜在问题。 

目前，这一功能还处于 Beta 实验阶段 ，并且不是免费的，官方也说明了 Bug 检测仍处于试验阶段，可能无法发现代码中的所有问题，可能会损失用户金钱，却得不到任何有效漏洞，请自行承担使用风险，看来大家还是慎用此功能。

图源：https://x.com/imrat/status/1860620203744178687

此外，Cursor 0.43 还有几项改进，包括：

• 语义搜索：使用户可以更轻松地使用几个字符找到所需的文件，和 VS Code 的搜索方式一致；
• image drop；
• File pill recommendations。

新版本上线后，用户们也是非常激动，都开始用起来了，但有些网友表示自己并没有更新成功，「下载页面只允许下载 setup x 0.42.5，运行 Cursor:Attempt Update，但没有成功。」

对此，官方回复是为了确保新版本的可靠性，他们正在分批推出，还不能更新的用户只能在等几天了。

除了 Cursor 的更新吸引眼球外，近日 Github 公布的一些数据证实，这些编程工具确实在改变开发者的工作体验。

真实测试 GitHub Copilot 到底多好用

GitHub Copilot 已经面世两年了，在此期间，该工具帮助开发人员将编码速度提高了 55%，借助 GitHub Copilot，85% 的开发人员对自己的代码更有信心，88% 的开发人员在使用 GitHub Copilot 时感觉更顺畅。

虽然 GitHub Copilot 一直在不断完善，但大家仍有一个疑问，使用 GitHub Copilot 编写的代码质量客观上是更好了还是更差了？

为了回答这个问题，GitHub 进行了一项随机对照试验。

在这项研究中，他们招募了 202 名拥有至少五年经验的开发者，并且将一半参与者随机分配到使用 GitHub Copilot 的组，而另一半被指示不要使用任何 AI 工具。所有参与者都被要求完成一个编程任务，为一个 Web 服务器编写 API 端点。随后，通过单元测试和由开发者组成的专家组评审对代码进行了评估。 

结果显示，使用 GitHub Copilot 编写程序的那组人员代码质量显著提高了，并且功能性更强、可读性更强、可靠性更高、可维护性更强、更简洁。

GitHub Copilot 编写的代码功能更强大

如果代码无法正常工作，那么就不能说它是高质量的。因此，研究者通过分析代码通过了多少单元测试来衡量其功能性。

结果发现，使用 GitHub Copilot 编写的代码通过的测试显著更多（p=0.002）。事实上，在这项研究中，拥有 GitHub Copilot 访问权限的开发者通过全部 10 个单元测试的概率高出 56%（p=0.04）。

这意味着使用 GitHub Copilot 帮助开发者编写的代码在功能性上有着较大的优势。 

使用 GitHub Copilot 编写的代码更容易阅读

在研究的第一阶段中，有 25 名开发者编写的代码通过了全部 10 个单元测试。这些开发者随机被分配去盲审匿名提交的代码，包括使用和未使用 GitHub Copilot 编写的代码。

审查者发现，GitHub Copilot 显著减少了代码错误：使用 GitHub Copilot 的开发者平均每 18.2 行代码出现一个代码错误，而未使用的情况下是每 16.0 行出现一个。这意味着使用 GitHub Copilot 的情况下，平均每个代码错误前可以多写 13.6% 的代码行（p=0.002）。这可以转化为实际的时间节省，因为每个代码错误都需要开发者进行处理。

此外，开发人员还发现使用 GitHub Copilot 编写的代码更易读、更可靠、更易于维护和更简洁。虽然这些差异很小，但它们具有统计意义，并且确实有助于改善代码库。

使用 GitHub Copilot 编写的代码更有可能获得批准

 开发者更有可能批准使用 GitHub Copilot 编写的代码，概率高出 5%（p=0.014）。在实际场景中，这意味着使用 GitHub Copilot 的开发者编写的代码更容易达到合并的标准，从而加快修复漏洞或部署新功能的速度。 

如今， AI 编码界不断推出新的工具，又不断的迭代更新，人人都是程序员的时代或许真的要到来了。

参考链接：

​​https://x.com/imrat/status/1860620189806592455​​

​​https://github.blog/news-insights/research/does-github-copilot-improve-code-quality-heres-what-the-data-says/​​​

#小学二年级数学水平，跟着这篇博客也能理解LLM运行原理

大家好，这是我们翻译的西瓜书平替。

「小白学 AI 该从哪里下手？」

去互联网上搜索一圈，最高赞的回复往往是高数起手，概率论也要学一学吧，再推荐一本大名鼎鼎的「西瓜书」。

但入门的门槛足以劝退一大波人了。翻开《西瓜书》前几页，看看基本术语解释，一些基本数学概念还是要了解的。

西瓜书《机器学习》第 3 页。

但为了避免「从入门到放弃」，有没有一种可能，不需要学更多数学，就能搞懂大模型的运行原理？

最近，Meta Gen AI 部门的数据科学总监 Rohit Patel 听到了你的心声。他用加法和乘法 —— 小学二年级的数学知识，深入浅出地解析了大模型的基础原理。

原文链接：https://towardsdatascience.com/understanding-llms-from-scratch-using-middle-school-math-e602d27ec876

如果你想更进一步，按照博客中的指导，亲手构建一个像 Llama 系列的 LLM 也完全可行。

读过的网友留下了好评：「博客相当长，虽然我才看了一半，但可以向你保证，这值得花时间一读。」

「所有的知识点都包圆了，学这 1 篇顶 40 亿篇其他资料！」

内容概览

为了使内容更简洁，Rohit 尽量避免了机器学习领域的复杂术语，将所有概念简化为了数字。

整个博客首先回答了四个问题：

• 一个简单的神经网络怎样构成？
• 这些模型是如何训练的？
• 这一切是如何生成语言的？
• 是什么让 LLM 的性能如此出色？

在基础的原理摸清之后，Rohit 要从细节入手，从嵌入、分词器、自注意力等概念讲起，由浅入深，逐步过渡到对 GPT 和 Transformer 架构的全面理解。

这个博客对新手有多友好呢？先来试读一段：

神经网络只能接受数字输入，并且只能输出数字，没有例外。关键在于如何将各种形式的输入转换为数字，以及如何将输出的数字解读为所需的结果。从本质上讲，构建 LLM 的核心问题就是设计一个能够执行这些转换的神经网络。

那么一个可以根据图片输入，分出花朵和叶子的神经网络大概是这样的：

其中，RGB 值表示图像的颜色信息，Vol 则表示图像中物体的尺寸

神经网络无法直接根据这些数字分类，为此，我们可以考虑以下两种方案：

1. 单输出：让网络输出一个数值，若数值为正，则判断为「叶子」；若数值为负，则判断为「花朵」。
2. 双输出：让网络输出两个数值，第一个数值代表叶子，第二个数值代表花朵，取数值较大的那个作为分类结果。

由于「双输出」的方法在后续的步骤中更通用，一般都会选择这种方案。

以下是基于「双输出」的神经网络分类结构，让我们逐步分析其工作原理。

图中圆圈内的数值代表：神经元 / 节点。连接线上的有色数字代表权重。每一列代表一层：神经元的集合称为一层。可以将该网络理解为具有三层：输入层（4 个神经元）、中间层（3 个神经元）和输出层（2 个神经元）。

那么中间层的第一个节点的计算如下：

(32 * 0.10) + (107 * -0.29) + (56 * -0.07) + (11.2 * 0.46) = -26.6

要计算该网络的输出（即前向传播过程），需要从左侧的输入层开始。我们将已有的数据输入到输入层的神经元中。接着，将圆圈内的数字乘以对应的权重，并将结果相加，依次传递到下一层。

运行整个网络后，可以看到输出层中第一个节点的数值较大，表示分类结果为「叶子」。一个训练良好的网络可以接受不同的 (RGB, Vol) 输入，并准确地对物体进行分类。

模型本身并不理解「叶子」或「花朵」是什么，也不了解 RGB 的含义。它的任务仅仅是接收 4 个数字并输出 2 个数字。我们负责提供输入数值，并决定如何解读输出，例如当第一个数值较大时，将其判断为「叶子」。

此外，我们还需要选择合适的权重，以确保模型在接收输入后给出的两个数值符合需求。

我们可以使用相同的网络，将 (RGB, Vol) 替换为其他数值，如云量和湿度，并将输出的两个数值解读为「1 小时后晴」或「1 小时后雨」。只要权重调整得当，这个网络可以同时完成分类叶子 / 花朵和预测天气两项任务。网络始终输出两个数字，而如何解读这些数字 —— 无论是用于分类、预测，还是其他用途 —— 完全取决于我们的选择。

为了尽可能简单，刚刚的「神经网络」中省略了以下内容：

激活层：在神经网络中，激活层的主要作用是引入非线性因素，使网络能够处理更复杂的问题。如果没有激活层，神经网络的每一层只是对输入进行简单的加法和乘法运算，整体上仍然是线性的。即使增加多层，这样的网络也无法解决复杂的非线性问题。

激活层将在每个节点上应用一个非线性函数，常用的激活函数之一是 ReLU，其规则是：如果输入是正数，输出保持不变；如果输入是负数，输出为零。

如果没有激活层，上一个例子中的绿色节点的值为 (0.10 * -0.17 + 0.12 * 0.39–0.36 * 0.1) * R + (-0.29 * -0.17–0.05 * 0.39–0.21 * 0.1) * G，所有中间层就像摊大饼一样铺在一起，计算也将越来越繁复。

偏置：在神经网络中，每个节点（也称为神经元）除了接收输入数据并进行加权求和外，还会加上一个额外的数值，称为偏置。偏置的作用类似于函数中的截距。在模型中我们又称它为参数。

例如，如果顶部蓝色节点的偏置为 0.25，则节点的值为：(32 * 0.10) + (107 * -0.29) + (56 * -0.07) + (11.2 * 0.46) + 0.25 = -26.35。

通过引入偏置，神经网络能够更好地拟合数据，提高模型的表现。

Softmax：Softmax 函数用于将模型的输出转换为概率。它可以将任何数转换为一个范围在 0 到 1 之间的数，且所有元素之和为 1。这使得每个输出值都可以转化为对应类别的概率。

更多研究细节，请参看博客原文。

作者介绍

这篇博客的作者 Rohit Patel 在数据科学领域深耕了 15 年，现在是 Meta GenAI 数据科学总监，参与了 Llama 系列模型的研发。

Rohit 拥有跨越多个领域的丰富职业经历。他的职业生涯始于 2002 年，在 Brainsmiths Education 担任物理助教。随后，他在金融领域从业十年。

2018 年，他加入了 Meta，担任 Facebook Monetization 的数据科学总监。2020 年，他创立了 CoFoundUp，担任创始人兼首席执行官。2021 年，他又创办了 QuickAI，QuickAI 是一款专注于简化数据科学流程的可视化工具，用户无需安装任何应用程序、插件或扩展，即可在浏览器中完成数据科学任务。

参考链接：

​​https://x.com/rohanpaul_ai/status/1854226721530073162​​

​​https://towardsdatascience.com/understanding-llms-from-scratch-using-middle-school-math-e602d27ec876​​

#CAD-MLLM

文本、图像、点云任意模态输入，AI能够一键生成高质量CAD模型了

本文第一作者为上海科技大学信息学院硕士生徐京伟和忆生科技的王晨宇，指导老师为香港大学的马毅教授和高盛华教授。王晨宇毕业于上海科技大学并获得工学硕士学位。其所在的忆生科技由马毅教授于 23 年底创立，致力于打造完整、自主、自洽的机器智能系统。

该项目由忆生科技联合香港大学、上海科技大学共同完成，是全球首个同时支持文本描述、图像、点云等多模态输入的计算机辅助设计（CAD）生成大模型。

计算机辅助设计（Computer-Aided Design，简称 CAD）软件是工业软件的重要分支，也是工业设计流程中的核心工具。然而，目前的 CAD 软件普遍缺乏简易的交互工具，这在一定程度上限制了未曾接触过 CAD 的用户尝试和探索的可能性。对于 CAD 建模从业者而言，多模态大模型技术的快速发展尚未充分转化为 CAD 领域实际应用的便利性和效率提升。如果能够通过多模态交互工具有效优化建模流程，提升效率、节约时间与精力，不仅可以进一步释放专业用户的创造潜能，还将为相关产业的发展注入新的活力。

为应对这一挑战，项目团队构建了首个覆盖文本、图像和点云输入的多模态 CAD 数据集 Omni-CAD。该数据集致力于赋能多模态大语言模型，使其能够基于条件输入生成高质量的 CAD 模型。与此同时，针对 CAD 模型的拓扑质量、空间封闭性等核心属性，团队还设计了一系列创新的评估指标，为模型性能提供更全面的衡量标准。借助这一技术，用户只需输入简单的文本指令，或上传目标形状的图像，即可快速生成符合要求的 CAD 模型。这一突破不仅降低了非专业用户的使用门槛，激发了更多人参与 CAD 设计的兴趣，还为 CAD 建模从业者提供了高效可靠的工具支持。

• 论文标题：CAD-MLLM: Unifying Multimodality-Conditioned CAD Generation With MLLM
• 论文地址：https://arxiv.org/pdf/2411.04954
• 项目主页：https://cad-mllm.github.io/

计算机辅助设计（CAD）技术通过数字化工具，帮助设计师创建、修改和优化复杂对象，广泛应用于工业设计与制造。但传统的流程较为复杂，对专业知识有较高要求，导致非专业用户难以参与设计。如何降低使用门槛，让非专业人士通过简单指令完成设计构想，已成为该领域亟待解决的挑战之一。尽管之前一些工作已经在探索 CAD 的生成任务，但这些方法抑或难以满足用户对交互设计的需求，抑或只能针对特定的输入进行生成，因此我们希望提供一个统一的框架能够处理不同或多种输入条件的 CAD 生成任务。

而另一方面，尽管多模态大模型（MLLMs）展现了跨模态生成的潜力，但在 CAD 领域依然面临挑战。尤其是在如何高效表征各种模态和 CAD 模型上，同时，数据集匮乏问题也一直是一大瓶颈。因此，我们提出了 CAD-MLLM，首个支持文本、图像和点云三种模态及其组合模态输入的以命令序列来表征的参数化 CAD 大模型，并搭配构建了一个超过 45 万条数据的多模态 CAD 数据集 Omni-CAD，推进该领域的研究。

以下视频来源于

忆生科技

，时长02:50

技术创新

1. 首个支持多模态输入的参数化 CAD 生成多模态大模型

我们提出了一个能够同时处理文本、图像和点云，最多三种模态输入数据的模型。图像和点云输入首先通过一个冻结的编码器提取特征，经投影层对齐到大语言模型（LLM）的特征空间。随后，将各种模态的特征进行整合，并利用低秩适应（LoRA）对 LLM 进行微调，实现基于多模态输入数据的精确 CAD 模型生成。

2. 首个多模态 CAD 数据集

为了支持模型训练，我们设计了一套全面的数据构造和标注管道，构建了包含 45 万条的多模态 CAD 模型数据集 Omni-CAD。每条数据包含对应的 CAD 模型构造命令序列，以及文本描述、8 个不同视角的图像（下图随机挑其中 4 个视角展示）以及点云数据，极大地填补了 CAD 多模态数据资源的空白，也有助于推动 CAD 生成领域的进一步发展。

3. 评估指标

在评估指标上，之前的工作更多聚焦在模型的重建质量和结构保真度上，而我们针对 CAD 模型的特性，基于最终生成的 CAD 模型的拓扑质量和空间封闭性，创新性地提出了四种量化指标。其中，Segment Error（SegE）检测 CAD 模型节点连接分段的准确性，Dangling Edge Length (DangEL) 评估悬边的比例来衡量生成模型流形的保真度，Self-Intersection Ratio (SIR) 检测生成模型中的自相交面问题。而 Flux Enclosure Error (FluxEE) 则通过高斯散度原理，计算常矢量场穿过生成表面的通量，评估模型的空间封闭性。

性能评估

1. 基于点云的 CAD 模型生成性能

我们与多个点云重建或者基于点云生成的基准工作进行比较，评测结果展示出我们的方法在重建精度上表现出色。而在拓扑完整性的评估上，我们模型生成的 CAD 模型大多数生成结果都能保持严格的流形结构，没有出现悬边，具有较高的拓扑完整性。相比之下，基准模型在重建结果中往往存在许多悬空边缘（如图中蓝线所示）。

2. 鲁棒性测评

在基于点云生成 CAD 模型的比较实验中，我们针对两种受干扰的输入数据的情况进行了测评：添加噪声的点云数据及部分点缺失的点云数据。在从测试集中随机挑选的 1000 个样本上，使用 Chamfer Distance 来衡量生成结果，在两种情况下，CAD-MLLM 的性能均优于基线工作，特别是在一些极端条件下，依然展现出了良好的性能。

3. 多模态数据训练必要性测评

我们通过三个实际场景来展示多模态数据训练对于模型生成能力的辅助提升，1）裁剪的点云数据；2）带有噪声的点云数据；3）双视角图像输入。以上三种情况，单一模态数据的训练，会由于细节丢失或者视角限制使得输入信息的不准确，进而导致生成结果的不完整或者不精准，而加入完整的模型的文本描述，可有效弥补未观测到的部分，生成更为完整、精确的 CAD 模型。

#A Scalable Communication Protocol for Networks of Large Language Models

智能体竟能自行组建通信网络，还能自创协议提升通信效率

Hugging Face 上的模型数量已经超过了 100 万。但是几乎每个模型都是孤立的，难以与其它模型沟通。尽管有些研究者甚至娱乐播主试过让 LLM 互相交流，但所用的方法大都比较简单。

近日，牛津大学一个研究团队提出了一个用于 LLM 通信的元协议：Agora，并宣称可以解决「智能体通信三难困境」，进而构建「世界级的 LLM 智能体网络」。

• 论文标题：A Scalable Communication Protocol for Networks of Large Language Models
• 论文地址：https://arxiv.org/pdf/2410.11905

智能体通信三难困境

智能体（agent）是指能在环境中自主行动以实现其设计目标的计算机系统。

和人类一样，为了实现共同的目标，智能体也需要相互协作。实际上，如此构建的多智能体系统正是当前 AI 领域的一大重要研究方向，比如 OpenAI 就正在网罗多智能体人才。

OpenAI 著名研究科学家 Noam Brown 发帖为多智能体研究团队招募机器学习工程师

但是，由于智能体千差万别（包括架构、功能和约束条件等），要为它们组成的异构网络设计通信协议并不容易。牛津大学的这个团队将这些难题归因到了三个方面：

• 多功能性：智能体之间的通信应支持内容和格式各异的多种多样的消息；
• 效率：运行智能体的计算成本和通信的网络成本应尽可能低；
• 可移植性：通信协议应尽可能支持更多智能体，同时其实现起来也应不费力。

该团队将这些属性之间的权衡称为智能体通信三难困境（Agent Communication Trilemma），如图 1 所示，具体讨论请参阅原论文。

Agora：LLM 的通信协议层

要解决这个智能体通信三难困境，关键是要接受这一点：并不存在一种能同时实现最佳效率、可移植性和多功能性的协议。

牛津大学的这个团队提出的 Agora 是一种元协议（meta protocol），其利用了 LLM 的特殊能力来解决这个三难问题，具体来说就是为不同的场景采用不同的通信方法。

我们知道，最强大的 LLM 具有三大关键属性：

• 它们可以使用自然语言理解、操纵和回复其它智能体；
• 它们擅长遵循指令，包括编写代码来实现例程；
• 在复杂的场景中，它们可以自主协商协议并就采用的策略和行为达成共识。

究其核心，Agora 会根据不同的情况使用不同的通信格式。

智能体可以支持广泛的通信（高通用性），同时也能通过高效的例程处理总请求量中的大部分（高效率）。此外，整个协商和实现工作流程都由 LLM 处理，无需人类干预（高可移植性）。

Agora 功能的核心是协议文档（PD）这一概念，图 3 给出了其图示。

下面将介绍 Agora 原生支持的通信层级，然后会展示一些示例。

Agora 中的通信

Agora 引入了一种机器可读的方式来传输和引用协议，即协议文档（PD）。PD 就是通信协议的纯文本描述。

PD 是独立的、与实现无关的，并且包含智能体在支持协议方面所需的一切：这就意味着现有协议的大多数描述（如 RFC）也都是合适的 PD。但是 PD 并不依靠某个中央实体来分配标识符，而是通过其哈希值（用于多路复用）进行唯一标识。

在 Agora 中，最常见的通信具有专用的高效例程，而最罕见的通信则使用低效但灵活的 LLM 和自然语言。具体来说：

• 如果可能，则通过传统协议来处理最常见的通信 —— 这些协议有标准的、人工编写的实现（例如 OBP）；
• 对于不太常见的通信（或没有标准协议的通信），智能体可以使用结构化数据作为交换媒介（可以由 LLM 编写的例程处理）；
• 对于一方智能体常见但对另一方不常见的通信，智能体仍然使用结构化数据，但一方可以选择使用 LLM，而另一方使用例程；
• 对于罕见的通信或例程意外失败的情况，智能体可以使用自然语言。

在处理一个查询时，到底选择使用人工编写的例程、LLM 编写的例程还是 LLM（或三者中的某种组合），则完全由智能体自行决定。这能为智能体在处理查询方面提供最大的灵活性。

这种分层通信支持任意形式的通信（最大通用性），但在实践中，仅在非常少的情况下会调用 LLM（最大效率）。此外，因为 LLM 可以自行实现例程（因为 PD 完全描述了协议的语法和语义），人类程序员只需要提供智能体可以访问的工具的概述，这意味着人类方面所需的实现工作量很小（最大可移植性）。

也就是说，Agora 通过使用例程来处理常见请求，并在智能体需要协商解决方案或发生错误时使用自然语言，从而避开了通信三难困境。

将 Agora 用作一个零层协议

图 2 表明，使用 Agora 无需在乎具体的实现和技术

智能体本身的实现（例如 LLM）、用于存储数据的数据库（例如 VectorDB、SQL、MongoDB 等）、编写实现的语言（Python、Java 等）以及工具的性质都是抽象的。

同时，PD 可以引用其它协议文档，并且由于例程可以调用其它例程，因此智能体可以基于先前的协商来解决更复杂的任务。

最后，基于强大的多功能性和可移植性，Agora 可以非常简单地处理节点的添加或删除、节点功能的更改或网络目标的更改。所有这些因素都有助于使 Agora 成为自然的零层协议，即 LLM 之间高阶通信和协作的基础层。

将 Agora 投入实际应用

为了演示 Agora 的效果，该团队在两个场景中实现了 Agora：

• 双智能体设置：它们的目标是交换一些数据；
• 一个包含 100 个智能体的设置，用于测试 Agora 的可扩展性和 LLM 驱动的智能体在复杂场景中自主协调的能力。

实现细节

在演示中，Agora 的设计遵循三个关键原则：最小化、去中心化、完全向后兼容。从实践角度看，Agora 使用 HTTPS 作为基础通信层，并使用 JSON 作为交换元数据的格式。

演示：检索天气数据

该团队首先演示了包含两个智能体的情况。他们将这两个智能体命名为 Alice 和 Bob。其中 Alice 是一个 Llama-3-405B 驱动的智能体，它管理着一个伦敦导游服务的预订程序。Bob 则是一个 GPT-4o 智能体，其可提供给定日期和地点的天气预报服务。在用户交互之中，如果用户预订的日期预计有雨，则 Alice 会通知用户。

为了检查天气，Alice 首先会使用自然语言向 Bob 发送请求（A1 阶段）：

Bob 则会使用其 Toolformer LLM 查询自己的数据库（B1 阶段）并用自然语言给出答复（B2 阶段）：

随着时间的推移，A1 和 B2 阶段调用 LLM 的成本会显著超越其它成本，于是 Alice 和 Bob 决定开发一个协议。

Alice 首先会检查 Bob 是否已经支持合适的协议，但没有找到。因此，她决定与 Bob 协商协议。

经过几轮协商，Alice 和 Bob 就以下协议达成一致：Alice 发送一个包含两个字段（位置和日期）的 JSON 文档，然后 Bob 回复一个包含三个字段的 JSON 文档，即温度（以摄氏度为单位）、降水量（以毫米为单位）和天气情况（晴、阴、雨或雪）。

基于此，Alice 在执行查询时只需指定该协议的哈希。下面给出了一个示例：

Alice 和 Bob 都可独立决定编写一个例程来处理自己这边的通信。

从现在开始，Alice 和 Bob 无需使用 LLM 来传输流量数据：现在有一个例程可以自动执行阶段 A1、B1 和 B2，从而免除了调用相应 LLM 的成本。

• 成本分析

在该演示中，协商协议和实施例程的 API 调用成本为 0.043 美元，而一次自然语言交换的平均成本为 0.020 美元。这意味着，只要 Alice 和 Bob 使用商定的协议超过两次，Agora 就能降低总体成本。

最后，该团队也指出，整个通信过程都是在无人类干预的情况下进行的。此外，如果 Bob 变得不可用，Alice 可以简单地将 PD 重新用于一个新节点，即便这个新节点可能使用了不同的 LLM / 数据库 / 技术堆栈。

演示：100 个智能体构成的网络

为了展示 Agora 的扩展能力和涌现行为，该团队研究了一个由 100 个 LLM 智能体构成的网络。

在这个网络中，其中 85 个是助理智能体，15 个是服务智能体。它们全都有 LLM 支持。

服务智能体可提供各种服务，例如预订酒店房间、叫出租车、订餐等。图 4 左给出了一个用于送餐的子网络示例。

在工作过程中，服务智能体必须与多个工具和数据库互动。此外，某些服务智能体还必须与其它服务智能体交互才能完成助理的请求（例如，出租车服务需要使用交通数据智能体来调整行程的预估车费）。

一开始，该团队使用了图 2 所示的底层通信层来启动该网络并提供哪些 URL 对应哪个节点的信息，同时也人工创建了智能体之间的连接链接（例如，出租车服务知道端口 5007 上的是交通服务，但它不知道如何与之通信以及需要什么信息）。

为了展示 Agora 的可移植性，该团队使用了不同的数据库技术（SQL 和 MongoDB）和不同的 LLM，包括开源和闭源模型（GPT-4o、Llama-3-405B 和 Gemini 1.5 Pro）。

然后，它们生成了 1000 个随机查询，其中既有简单查询（例如请求今天的天气），也有更复杂的查询（例如预订滑雪胜地的房间、购买电影票、从菜单中订购每种菜肴等）。

对于每个查询，助理都会收到一个 JSON 文档（代表任务数据），并负责完成请求并返回遵循给定模式的解析响应。

查询按照帕累托分布在助理之间分配，以模拟某些助理发送的请求明显多于其它助理的情况。

每个节点还可以读取 PD 并将其共享到三个协议数据库之一。

总体而言，这些设计决策下得到的网络是一个非常异构的网络，可以测试 Agora 的极限。

• 大型网络中涌现的协议

连接建立并且网络可以发送和接收消息后，该团队观察到了几个值得注意的行为。

随着 PD 在智能体之间逐渐共享（参见图 5b），针对给定任务的适当协议涌现出了去中心化的共识。

举个例子，在订餐任务中，一个智能体会通过查询请求另一个智能体将食物送到某个地址。这个餐厅智能体会向一个送餐服务请求送货司机，接下来送餐服务又会向交通数据智能体查询交通是否顺畅，看能否完成送货。除了直接通信触及的范围，所有智能体都不知道彼此的角色和所涉及的协议。尽管如此，各种智能体之间的交互仍然创造了一个能应付这所有事情的自动化工作流程。如图 4 右所示。

该团队观察到，如果有适当的激励（即效率激励），Agora 中的智能体可以摆脱在大规模通信中常见的更长消息的低效陷阱。

• 成本分析

该团队同样分析了这个更大网络的成本，并与使用自然语言完成所有通信的网络进行了比较。

结果如图 5a 所示，一开始，Agora 的成本效益仅略优于仅依赖自然语言的网络；随着时间的推移，这种差距越来越大，越来越多的 Agora 驱动的节点依赖于 LLM 编写的例程。

在自然语言网络中运行 1000 次查询的 API 查询总成本为 36.23 美元，而 Agora 的成本仅有 7.67 美元：也就是说，使用 Agora 执行此演示比使用常规自然语言便宜约五倍。而如果查询更多，成本差距还会更大。