WEBVTT
Kind: captions
Language: zh

00:00:00.133 --> 00:00:01.300
一个AI agent

00:00:01.666 --> 00:00:03.566
连续试了几百条路线

00:00:03.566 --> 00:00:04.666
大部分失败

00:00:04.700 --> 00:00:05.800
少数成功

00:00:06.566 --> 00:00:07.766
任务结束以后

00:00:07.766 --> 00:00:09.300
成功答案被保存

00:00:09.900 --> 00:00:12.166
失败过程通常被丢进日志

00:00:12.500 --> 00:00:15.133
Dreamrsi提出了一个反常做法

00:00:15.600 --> 00:00:18.900
真正值钱的可能正是那些失败记录

00:00:19.066 --> 00:00:21.266
它们可以组成一张探索地图

00:00:21.733 --> 00:00:24.666
让下一版agent不用重新花钱执行

00:00:25.400 --> 00:00:26.966
就能在过去走过的世界

00:00:26.966 --> 00:00:29.000
里测试上千种新策略

00:00:29.366 --> 00:00:31.300
但一个问题也跟着出现

00:00:31.500 --> 00:00:33.300
agent是在真正变聪明

00:00:33.400 --> 00:00:34.566
还是只学会了更

00:00:34.566 --> 00:00:36.366
熟练的走一张旧地图

00:00:36.466 --> 00:00:37.766
2026年9月

00:00:37.766 --> 00:00:39.800
由Google Google deep mind

00:00:40.133 --> 00:00:41.200
马里兰大学和

00:00:41.200 --> 00:00:43.500
弗吉尼亚大学研究人员组成的团队

00:00:43.500 --> 00:00:45.000
发布Dreamrsl

00:00:45.300 --> 00:00:47.866
RSI是recursive self improvement

00:00:48.066 --> 00:00:50.000
也就是递归自我改进

00:00:50.166 --> 00:00:52.133
这个词很容易让人联想到

00:00:52.133 --> 00:00:54.466
AI重写自己的大脑能力

00:00:54.533 --> 00:00:56.200
一轮又一轮上涨

00:00:56.333 --> 00:00:58.000
最后进入智能爆炸

00:00:58.600 --> 00:01:01.666
dream RSI做的事情更具体

00:01:01.866 --> 00:01:04.100
它不修改基础模型的权重

00:01:04.200 --> 00:01:06.466
也没有训练出一个新的Gemini

00:01:06.600 --> 00:01:08.933
它改进的是agent在复杂

00:01:08.933 --> 00:01:11.400
任务中怎样分配探索资源

00:01:11.966 --> 00:01:13.466
要理解这项工作

00:01:13.466 --> 00:01:15.566
得先看AI agent处理长

00:01:15.566 --> 00:01:17.266
任务时究竟在做什么

00:01:17.466 --> 00:01:20.133
假设任务是优化一个GPU内核

00:01:20.500 --> 00:01:22.333
agent先提出一段代码

00:01:22.400 --> 00:01:23.500
执行测速

00:01:23.700 --> 00:01:25.666
再根据结果决定下一步

00:01:25.800 --> 00:01:27.500
它可能修改内存访问

00:01:27.600 --> 00:01:29.400
可能换一种并行方式

00:01:29.766 --> 00:01:32.333
也可能从某个旧版本重新分支

00:01:32.666 --> 00:01:34.666
简单任务走几步就结束

00:01:34.866 --> 00:01:36.666
真正困难的任务会形成

00:01:36.666 --> 00:01:38.766
几十甚至上千条路线

00:01:38.866 --> 00:01:40.766
这里最昂贵的部分是

00:01:40.766 --> 00:01:42.966
决定下一次尝试放在哪里

00:01:43.166 --> 00:01:45.533
生成代码反而只占其中一环

00:01:45.966 --> 00:01:48.166
应该继续打磨当前最好方案

00:01:48.333 --> 00:01:51.200
还是回头救一条被过早放弃的分支

00:01:51.500 --> 00:01:53.800
应该同时运行多少个候选

00:01:53.866 --> 00:01:56.566
一个方向连续失败几次以后

00:01:56.666 --> 00:01:57.800
什么时候停

00:01:57.800 --> 00:02:00.500
这些选择统称为探索策略

00:02:01.066 --> 00:02:02.300
策略写得差

00:02:02.400 --> 00:02:04.300
再强的模型也会把

00:02:04.300 --> 00:02:06.566
大量算力浪费在死路上

00:02:06.666 --> 00:02:08.300
现用系统常用固定

00:02:08.300 --> 00:02:09.766
策略解决这个问题

00:02:10.400 --> 00:02:13.700
人类提前规定每轮生成多少候选

00:02:14.166 --> 00:02:15.933
保留几个高分结果

00:02:16.133 --> 00:02:18.000
并行探索几条路线

00:02:18.333 --> 00:02:19.766
再循环多少次

00:02:19.933 --> 00:02:21.400
这种方法稳定

00:02:21.500 --> 00:02:24.466
却不会从过去的搜索经验中学习

00:02:24.766 --> 00:02:27.533
agent已经反复撞过同一堵墙

00:02:27.800 --> 00:02:29.733
调度规则下一轮仍可能

00:02:29.733 --> 00:02:31.866
把资源投向类似方向

00:02:32.266 --> 00:02:35.266
另一条路是在线优化探索策略

00:02:35.366 --> 00:02:37.600
让agent一边执行任务

00:02:37.666 --> 00:02:40.333
一边试验哪种调度方式更好

00:02:40.366 --> 00:02:42.133
问题马上变成成本

00:02:42.333 --> 00:02:44.300
判断一套探索策略有没有用

00:02:44.300 --> 00:02:46.666
不能只看它下一步选对没有

00:02:47.100 --> 00:02:49.600
往往要让它跑完整个长周期任务

00:02:49.700 --> 00:02:51.600
最后比较结果和费用

00:02:51.666 --> 00:02:53.100
候选策略很多

00:02:53.100 --> 00:02:54.566
大多数还会很差

00:02:54.666 --> 00:02:57.300
每测试一个策略都重新调用模型

00:02:57.500 --> 00:02:59.400
编译代码和运行评测

00:02:59.600 --> 00:03:02.400
元优化本身可能比解决任务更贵

00:03:02.566 --> 00:03:04.666
dream RSI抓住了一个长期

00:03:04.666 --> 00:03:06.500
被当成副产品的东西

00:03:06.900 --> 00:03:08.333
完整的发现历史

00:03:08.500 --> 00:03:10.366
一次长任务结束后

00:03:10.500 --> 00:03:12.700
系统手里不只有最终答案

00:03:12.733 --> 00:03:14.200
还有一棵探索树

00:03:14.366 --> 00:03:16.000
树上的每个节点都保存

00:03:16.000 --> 00:03:18.100
当时的观察和生成方案

00:03:18.500 --> 00:03:20.500
也保存文件状态执行

00:03:20.500 --> 00:03:22.866
结果以及诊断信息与评分

00:03:23.166 --> 00:03:25.966
这是一份结构化的行动与结果记录

00:03:26.000 --> 00:03:28.700
远比一段模糊的经验总结具体

00:03:28.900 --> 00:03:31.666
研究团队把这棵树当成重放模拟器

00:03:32.133 --> 00:03:33.900
新的探索策略进入以后

00:03:33.900 --> 00:03:35.066
不需要真的重新

00:03:35.066 --> 00:03:36.933
生成和运行每个候选

00:03:37.366 --> 00:03:40.200
它只要按照自己的规则遍历这棵树

00:03:40.333 --> 00:03:42.000
它可以先看另一条分支

00:03:42.300 --> 00:03:44.366
可以同时打开更多节点

00:03:44.500 --> 00:03:46.900
也可以更早停止低价值路线

00:03:47.066 --> 00:03:49.366
只要它访问的节点已经存在

00:03:49.733 --> 00:03:52.200
结果就能从硬盘里直接读出

00:03:52.300 --> 00:03:54.366
一次昂贵的在线探索

00:03:54.866 --> 00:03:56.400
因此可以支持大量

00:03:56.400 --> 00:03:58.300
便宜的离线策略测试

00:03:58.533 --> 00:04:00.600
论文把这个过程称为做梦

00:04:01.000 --> 00:04:03.733
agent没有回到真实环境重新工作

00:04:03.800 --> 00:04:05.200
而是在过去形成的

00:04:05.200 --> 00:04:07.100
世界里尝试不同走法

00:04:07.466 --> 00:04:09.300
这个比喻听起来很大

00:04:09.366 --> 00:04:11.366
机制其实非常工程化

00:04:11.733 --> 00:04:13.766
历史记录给出的结果不会像

00:04:13.766 --> 00:04:16.066
学习型世界模型那样猜测

00:04:16.266 --> 00:04:18.766
因为节点里的代码已经运行过

00:04:18.866 --> 00:04:20.466
分数也已经测过

00:04:20.466 --> 00:04:22.900
在历史真正覆盖的区域内

00:04:22.900 --> 00:04:24.866
它是一次精确重放

00:04:25.166 --> 00:04:27.133
限制也埋在同一句话里

00:04:27.200 --> 00:04:28.900
历史没有去过的地方

00:04:28.933 --> 00:04:30.600
模拟器就无法回答

00:04:30.733 --> 00:04:33.666
新策略走到一条过去未展开的分支

00:04:34.000 --> 00:04:35.566
系统手中没有结果

00:04:35.933 --> 00:04:37.866
既不能保证那里是死路

00:04:37.966 --> 00:04:40.166
也不能凭空预测它会成功

00:04:40.366 --> 00:04:42.133
Dreamrsi只拥有已经

00:04:42.133 --> 00:04:43.866
探索区域的精确地图

00:04:44.133 --> 00:04:45.933
覆盖不了整个未知空间

00:04:46.000 --> 00:04:48.533
这也是系统必须递归运行的原因

00:04:48.666 --> 00:04:51.566
第一轮当前策略进入在线环境

00:04:51.866 --> 00:04:54.400
驱动编码agent展开探索

00:04:54.466 --> 00:04:55.766
并保存一棵树

00:04:56.000 --> 00:04:58.700
第二步这棵树被加入模拟器池

00:04:58.900 --> 00:05:02.133
第三步策略开发agent开始

00:05:02.133 --> 00:05:04.133
修改探索策略的代码

00:05:04.300 --> 00:05:06.166
生成多个候选版本

00:05:06.366 --> 00:05:09.533
再把它们放进所有历史树中重放

00:05:09.600 --> 00:05:12.266
综合表现最好的策略被选中

00:05:12.600 --> 00:05:14.533
进入下一轮在线探索

00:05:14.733 --> 00:05:16.966
新策略回到真实任务后

00:05:17.066 --> 00:05:19.866
可能到达旧策略从未到过的区域

00:05:20.066 --> 00:05:22.533
于是生成一棵不同的探索树

00:05:22.966 --> 00:05:25.133
这颗新树又进入模拟器池

00:05:25.200 --> 00:05:27.400
供下一轮策略改进使用

00:05:27.666 --> 00:05:29.200
策略改变探索

00:05:29.466 --> 00:05:30.866
探索扩大历史

00:05:31.000 --> 00:05:32.766
扩大的历史再改变策略

00:05:33.000 --> 00:05:35.000
dream RSI所谓的递归

00:05:35.400 --> 00:05:36.866
指的就是这个闭环

00:05:37.000 --> 00:05:39.600
被修改的对象必须再强调一次

00:05:40.100 --> 00:05:42.466
论文中的基础模型保持不变

00:05:42.700 --> 00:05:46.100
执行任务的编码agent保持不变

00:05:46.300 --> 00:05:49.100
评分器和工具接口也保持不变

00:05:49.300 --> 00:05:52.000
系统没有对Gemini进行梯度更新

00:05:52.200 --> 00:05:54.466
它重写的是外部调度代码

00:05:54.600 --> 00:05:55.966
包括分支选择

00:05:56.533 --> 00:05:58.700
并行数量和停止规则

00:05:58.900 --> 00:06:00.933
项目说明甚至专门写出

00:06:01.300 --> 00:06:03.900
Zero gradient steps on the coding agent

00:06:04.200 --> 00:06:05.766
就是为了避免把它误解

00:06:05.766 --> 00:06:07.900
成模型再重新训练自己

00:06:08.000 --> 00:06:09.733
这并不代表改进很浅

00:06:10.400 --> 00:06:11.566
模型能力决定一个

00:06:11.566 --> 00:06:13.400
候选方案能做到多好

00:06:13.566 --> 00:06:15.400
探索策略决定有限预算

00:06:15.400 --> 00:06:16.933
能不能找到那个候选

00:06:17.066 --> 00:06:18.700
现实中的很多AI任务

00:06:18.700 --> 00:06:20.333
模型本来可能会做

00:06:20.333 --> 00:06:23.300
只是系统在正确答案出现以前

00:06:23.300 --> 00:06:26.466
已经耗完时间TOKEN或执行额度

00:06:26.800 --> 00:06:28.800
调度层只要减少无效尝试

00:06:29.066 --> 00:06:30.666
就能在不更换模型的

00:06:30.666 --> 00:06:32.566
情况下提高最终结果

00:06:33.366 --> 00:06:36.333
dream RSI的策略本身是可执行代码

00:06:36.533 --> 00:06:38.566
策略开发agent会连续

00:06:38.566 --> 00:06:40.100
写出多个修订版

00:06:40.533 --> 00:06:41.866
每个版本在历史

00:06:41.866 --> 00:06:43.766
模拟器池中接受评分

00:06:44.366 --> 00:06:45.966
当前正在使用的旧

00:06:45.966 --> 00:06:48.000
策略也被放进候选集合

00:06:48.366 --> 00:06:50.866
因此系统总能保留旧版本

00:06:51.000 --> 00:06:52.500
论文据此提出

00:06:52.566 --> 00:06:55.166
新一轮选出的策略在历史

00:06:55.166 --> 00:06:58.000
重放分数上不会比旧策略更差

00:06:58.000 --> 00:07:00.000
不会更差有严格范围

00:07:00.300 --> 00:07:02.266
它只保证选出的策略在

00:07:02.266 --> 00:07:04.500
已经记录的历史和既定

00:07:04.500 --> 00:07:07.000
评分方式下不低于旧策略

00:07:07.366 --> 00:07:08.366
换一个任务

00:07:08.466 --> 00:07:09.866
换一种数据分布

00:07:10.666 --> 00:07:13.166
或者评分器本身漏掉了重要质量

00:07:13.333 --> 00:07:15.200
新策略依然可能退步

00:07:15.466 --> 00:07:17.666
历史回放能防止明显回归

00:07:18.066 --> 00:07:20.566
不能提供对未知世界的永久保证

00:07:20.900 --> 00:07:22.700
研究团队在8项发现

00:07:22.700 --> 00:07:24.566
任务上测试了这套框架

00:07:25.000 --> 00:07:26.766
覆盖算法工程数学

00:07:26.766 --> 00:07:28.866
优化和GPU内核工程

00:07:29.000 --> 00:07:31.933
对照组叫recursive fixed exploration

00:07:32.300 --> 00:07:35.600
两边使用相同的基础模型评分器

00:07:35.966 --> 00:07:38.066
初始策略和每轮预算

00:07:38.166 --> 00:07:40.200
第一轮甚至完全一致

00:07:40.366 --> 00:07:42.333
差别从第二轮开始出现

00:07:42.666 --> 00:07:44.966
对照组保持原调度方式

00:07:45.300 --> 00:07:47.266
dream RSI根据历史重放

00:07:47.266 --> 00:07:48.933
持续修改探索策略

00:07:49.166 --> 00:07:51.000
算法工程部分选择了

00:07:51.000 --> 00:07:53.333
Lasso正则化路径求解器

00:07:53.666 --> 00:07:56.366
这个任务要求agent写出速度快

00:07:56.400 --> 00:07:57.800
结果正确的程序

00:07:58.066 --> 00:07:59.766
再在6个流出数据集

00:07:59.766 --> 00:08:01.400
上测量运行时间

00:08:01.600 --> 00:08:04.000
使用Gemini3.1Pro时

00:08:04.366 --> 00:08:06.466
固定探索消耗550次

00:08:06.566 --> 00:08:08.166
发现agent调用

00:08:08.266 --> 00:08:12.333
最终平均运行时间为3,587.1毫秒

00:08:12.566 --> 00:08:15.466
dream RSI使用317次调用

00:08:15.800 --> 00:08:19.266
把平均时间降到2,931.0毫秒

00:08:19.466 --> 00:08:21.366
调用量减少约1.7倍

00:08:21.366 --> 00:08:23.166
找到的程序反而更快

00:08:23.500 --> 00:08:25.566
换成Gemini3.7Flash以后

00:08:25.566 --> 00:08:28.066
固定策略用了3,200次调用

00:08:28.066 --> 00:08:31.800
平均运行时间是2,516.7毫秒

00:08:32.100 --> 00:08:35.500
dream RSI用了1,879次调用

00:08:35.500 --> 00:08:38.000
得到2,350.6毫秒

00:08:38.466 --> 00:08:42.266
和simple test使用的51,200次生成相比

00:08:42.533 --> 00:08:44.500
论文在部分设置中报告

00:08:44.500 --> 00:08:46.933
最多162倍的调用节省

00:08:47.100 --> 00:08:48.500
这个数字很醒目

00:08:48.600 --> 00:08:50.333
但比较对象和预算

00:08:50.333 --> 00:08:52.100
设置必须一起保留

00:08:52.200 --> 00:08:53.600
不能把它解释成

00:08:53.600 --> 00:08:56.000
所有任务都节省162倍

00:08:56.466 --> 00:08:58.366
被发现的Lasso程序也不是

00:08:58.366 --> 00:09:00.300
凭空拼出一段神秘代码

00:09:00.400 --> 00:09:02.200
它结合了强规则筛选

00:09:02.366 --> 00:09:05.466
基于柯西斯瓦茨不等式的KKT剪枝

00:09:05.866 --> 00:09:06.933
活动集合管理

00:09:07.100 --> 00:09:09.333
延迟构建GRAM矩阵和硬件

00:09:09.333 --> 00:09:11.766
优化系统在大量候选中

00:09:11.766 --> 00:09:13.866
找到了一套更合适的组合

00:09:13.966 --> 00:09:16.933
并根据问题规模调整验证成本

00:09:17.166 --> 00:09:18.666
他证明调度改进可以

00:09:18.666 --> 00:09:20.666
落到可测量的程序性能

00:09:20.966 --> 00:09:23.800
而不是只让agent自评这次更有创意

00:09:23.966 --> 00:09:26.500
数学优化部分包含核差集合

00:09:27.000 --> 00:09:29.366
自相关不等式与圆形装箱

00:09:29.800 --> 00:09:34.166
dream RSI在核差问题上取得1.145427

00:09:34.600 --> 00:09:36.166
超过论文列出的simple

00:09:36.300 --> 00:09:38.200
test与固定探索结果

00:09:38.366 --> 00:09:41.600
原型装箱达到2.635983

00:09:41.800 --> 00:09:43.933
与最强对照结果持平

00:09:44.166 --> 00:09:47.000
自相关任务得到1.456375

00:09:47.066 --> 00:09:50.566
没有超过simple TES的1.453675

00:09:51.066 --> 00:09:53.133
因为该项指标越低越好

00:09:53.200 --> 00:09:54.766
这个结果提醒外界

00:09:55.133 --> 00:09:58.300
dream RSI没有在每个任务上全面获胜

00:09:58.400 --> 00:10:00.500
它的优势仍体现在预算

00:10:00.900 --> 00:10:04.766
simple t ES在对照中使用51200次生成

00:10:05.266 --> 00:10:07.333
Dreamrsi少于1,000次

00:10:07.533 --> 00:10:10.066
部分结果未必拿到单项第一

00:10:10.100 --> 00:10:12.700
但单位计算成本更有竞争力

00:10:12.733 --> 00:10:15.866
这类系统真正追求的目标是用更

00:10:15.866 --> 00:10:18.933
少真实执行找到足够好的方案

00:10:19.266 --> 00:10:22.000
排行榜最高分只是其中一个指标

00:10:22.200 --> 00:10:24.933
GPU内核工程又提供了另一种检验

00:10:25.166 --> 00:10:28.266
在VGG16和layer norm任务中

00:10:28.500 --> 00:10:31.066
dream RSI达到相近性能时

00:10:31.200 --> 00:10:35.266
分别减少2.43倍和1.79倍生成次数

00:10:35.466 --> 00:10:38.733
CONV div与CONV Max在相近预算下

00:10:38.933 --> 00:10:40.466
性能分别达到固定

00:10:40.466 --> 00:10:43.200
探索的2.09倍和1.44倍

00:10:44.000 --> 00:10:46.400
四类任务涉及不同计算结构

00:10:46.666 --> 00:10:48.500
说明学习到的策略至少

00:10:48.500 --> 00:10:50.766
没有被锁死在一个算法题上

00:10:50.966 --> 00:10:53.766
研究人员还观察了策略怎样变化

00:10:53.900 --> 00:10:55.766
在Convictive实验中

00:10:56.000 --> 00:10:57.600
系统表现上升后

00:10:57.600 --> 00:11:01.366
把每轮评估的尝试从110个降到50个

00:11:01.800 --> 00:11:03.200
主动节省计算

00:11:03.366 --> 00:11:04.733
进展停滞以后

00:11:04.733 --> 00:11:05.933
它又扩大探索

00:11:06.100 --> 00:11:07.533
评估数量回升

00:11:07.700 --> 00:11:09.733
随后出现新的性能跳跃

00:11:10.200 --> 00:11:13.200
他学会根据进展调节搜索强度

00:11:13.300 --> 00:11:15.566
表现上升时缩减预算

00:11:15.666 --> 00:11:17.866
停滞时重新扩大分支

00:11:18.066 --> 00:11:19.733
另一个实验更有意思

00:11:20.200 --> 00:11:21.866
研究团队把历史轨迹

00:11:21.866 --> 00:11:23.766
总结成高层语义建议

00:11:23.866 --> 00:11:25.300
再塞回提示词

00:11:25.533 --> 00:11:27.266
例如告诉agent哪些

00:11:27.266 --> 00:11:28.766
方向可能更有希望

00:11:28.933 --> 00:11:31.666
这种看起来更像人类复盘的做法

00:11:32.000 --> 00:11:35.200
表现反而低于直接使用历史数重放

00:11:35.400 --> 00:11:38.300
原因可能是总结会过早压缩信息

00:11:38.466 --> 00:11:41.166
也会把过去的成功变成强烈偏见

00:11:41.366 --> 00:11:44.166
导致新一轮探索集中在少数方向

00:11:44.666 --> 00:11:47.300
树状历史保留了更多反事实空间

00:11:47.533 --> 00:11:50.700
策略可以看到某条路线在哪里停下

00:11:50.700 --> 00:11:52.466
也能重新安排那些

00:11:52.466 --> 00:11:54.366
当时被忽略的节点

00:11:54.466 --> 00:11:57.333
文字总结通常只留下应该做什么

00:11:57.566 --> 00:12:00.000
探索树还保留做过什么

00:12:00.100 --> 00:12:01.266
失败在哪里

00:12:01.533 --> 00:12:03.333
当时还有哪些路没继续

00:12:03.400 --> 00:12:06.066
对于长周期多分支任务

00:12:06.066 --> 00:12:08.066
这两类记忆并不等价

00:12:08.166 --> 00:12:11.200
它和检索增强生成也有明显差别

00:12:11.866 --> 00:12:14.166
普通记忆系统在遇到新任务时

00:12:14.300 --> 00:12:17.200
找出几段相似经验放进上下文

00:12:17.366 --> 00:12:19.600
模型读完以后自行决定怎么做

00:12:19.800 --> 00:12:22.133
dream RSI不止提供旧经验

00:12:22.333 --> 00:12:25.466
还让候选策略在旧树上实际走一遍

00:12:25.900 --> 00:12:28.066
并按照成本与结果计分

00:12:28.566 --> 00:12:30.200
前者提供参考材料

00:12:30.366 --> 00:12:32.700
后者提供可比较的行为反馈

00:12:32.866 --> 00:12:34.266
它也不同于微调

00:12:34.500 --> 00:12:36.800
微调把经验压进模型参数

00:12:36.800 --> 00:12:39.333
可能提高一类任务的平均表现

00:12:39.466 --> 00:12:43.000
却很难解释某次提升来自哪条轨迹

00:12:43.366 --> 00:12:45.500
dream RSI保留基础模型

00:12:45.700 --> 00:12:47.533
只修改外部策略代码

00:12:47.800 --> 00:12:50.300
旧策略和新策略可以逐行比较

00:12:50.400 --> 00:12:53.300
表现变化也能对应到具体历史数

00:12:53.533 --> 00:12:55.666
代价是它不能直接扩大

00:12:55.666 --> 00:12:57.566
模型的知识和推理上限

00:12:58.100 --> 00:13:00.366
只能更有效地调用已有能力

00:13:00.500 --> 00:13:02.400
和传统强化学习相比

00:13:02.700 --> 00:13:06.533
dream RSI借用了离线策略评估的思想

00:13:06.666 --> 00:13:09.133
却利用了编码任务特有的结构

00:13:09.266 --> 00:13:10.866
环境结果已经被保存在

00:13:10.866 --> 00:13:13.600
文件程序输出和分数中

00:13:14.200 --> 00:13:15.500
重放时不需要学习

00:13:15.500 --> 00:13:17.200
一个近似动力学模型

00:13:17.333 --> 00:13:19.666
只要候选策略不走出历史树

00:13:20.066 --> 00:13:22.766
反馈就是当时真实执行过的结果

00:13:23.466 --> 00:13:25.166
强化学习中常见的模型

00:13:25.166 --> 00:13:27.200
预测误差因此被缩小

00:13:27.366 --> 00:13:29.800
但覆盖不足的问题仍然存在

00:13:29.933 --> 00:13:31.900
可以用一个简化例子理解

00:13:32.333 --> 00:13:35.200
某次内核优化一共展开100个节点

00:13:35.366 --> 00:13:38.366
旧策略先连续打磨a路线40次

00:13:38.500 --> 00:13:39.800
再试b和c

00:13:40.266 --> 00:13:41.866
后来发现真正的突破

00:13:41.866 --> 00:13:43.733
来自c的第六个分支

00:13:44.066 --> 00:13:47.066
新策略可以在历史树里提前访问c

00:13:47.200 --> 00:13:49.133
并减少a上的预算

00:13:49.300 --> 00:13:51.866
它不需要重新编译那100份代码

00:13:51.933 --> 00:13:53.600
因为结果都已保存

00:13:53.866 --> 00:13:55.800
可要是新策略想尝试

00:13:55.800 --> 00:13:57.700
从未出现过的d路线

00:13:58.100 --> 00:13:59.900
历史就无法提供答案

00:14:00.000 --> 00:14:02.300
只能等下一轮真实执行

00:14:02.366 --> 00:14:05.133
这套方法因此同时依赖两种质量

00:14:05.166 --> 00:14:06.900
第一种是历史覆盖

00:14:07.166 --> 00:14:08.900
探索树必须足够丰富

00:14:08.933 --> 00:14:11.300
不能只记录最后几个成功候选

00:14:11.700 --> 00:14:13.400
第二种是评分质量

00:14:13.500 --> 00:14:15.566
每个节点的结果必须可靠

00:14:15.766 --> 00:14:18.600
日志缺失执行环境变化或

00:14:18.600 --> 00:14:21.800
评分器错误都会让模拟世界失真

00:14:22.466 --> 00:14:24.733
系统节省了重复执行成本

00:14:24.900 --> 00:14:26.766
也把更高要求转移给

00:14:26.766 --> 00:14:28.766
记录和评测基础设施

00:14:29.100 --> 00:14:31.000
研究团队让候选策略在

00:14:31.000 --> 00:14:33.066
全部历史数上接受评估

00:14:33.100 --> 00:14:34.766
而不是只看最近一轮

00:14:34.966 --> 00:14:36.400
这样可以降低策略

00:14:36.400 --> 00:14:38.166
迎合单次任务的风险

00:14:38.366 --> 00:14:39.566
旧世界越多

00:14:39.766 --> 00:14:42.533
候选策略越难靠偶然路线获胜

00:14:43.133 --> 00:14:45.600
不过历史池本身仍可能

00:14:45.600 --> 00:14:47.333
偏向某些任务类型

00:14:47.866 --> 00:14:50.200
如果过去全是GPU优化

00:14:50.333 --> 00:14:53.300
得到的调度习惯未必适合数学证明

00:14:53.400 --> 00:14:55.333
跨领域泛化需要更多实验

00:14:55.333 --> 00:14:57.666
不能只凭三个领域就下定论

00:14:58.666 --> 00:15:00.966
策略选择还涉及多目标权衡

00:15:01.200 --> 00:15:03.533
发现系统既想要高质量结果

00:15:03.533 --> 00:15:05.300
也想减少模型调用

00:15:05.300 --> 00:15:07.100
执行时间和并行资源

00:15:07.266 --> 00:15:08.900
一个策略可能用很少

00:15:08.900 --> 00:15:10.566
调用找到不错答案

00:15:11.066 --> 00:15:12.366
另一个策略消耗

00:15:12.366 --> 00:15:14.366
更多预算拿到略高分

00:15:14.500 --> 00:15:17.100
最终选谁取决于评价函数

00:15:17.100 --> 00:15:19.200
怎样给质量和成本定价

00:15:19.700 --> 00:15:21.700
Dreamrsi能优化这套权衡

00:15:21.733 --> 00:15:24.333
却不能替使用者决定什么最重要

00:15:24.666 --> 00:15:26.866
Dreamrsi最重要的产业含义

00:15:27.500 --> 00:15:30.100
也许是把日志从成本变成资产

00:15:30.200 --> 00:15:32.733
今天大量agent平台保存轨迹

00:15:33.133 --> 00:15:34.900
主要用于排查错误

00:15:35.100 --> 00:15:37.666
审计调用和改进提示词

00:15:38.000 --> 00:15:40.533
dream RSI展示了另一种用途

00:15:41.166 --> 00:15:42.800
只要轨迹包含清楚的

00:15:42.800 --> 00:15:44.933
决策结构和可复现结果

00:15:45.200 --> 00:15:46.533
它就能成为测试

00:15:46.533 --> 00:15:48.400
未来调度策略的环境

00:15:48.800 --> 00:15:51.400
公司已经为在线运行付过一次费用

00:15:51.566 --> 00:15:52.933
后续可以反复利用

00:15:52.933 --> 00:15:54.600
这段历史筛选策略

00:15:54.733 --> 00:15:57.466
这会改变agent系统的竞争方式

00:15:57.700 --> 00:16:00.300
模型公司比参数和推理能力

00:16:00.733 --> 00:16:02.266
应用公司则可能开始

00:16:02.266 --> 00:16:04.000
积累自己的探索世界

00:16:04.133 --> 00:16:07.000
哪家企业拥有更多高质量任务轨迹

00:16:07.333 --> 00:16:09.766
准确评分和真实执行结果

00:16:09.933 --> 00:16:11.700
哪家企业就更容易把同

00:16:11.700 --> 00:16:13.900
一款基础模型调度得更好

00:16:14.000 --> 00:16:15.700
模型可以从API购买

00:16:15.700 --> 00:16:18.066
历史数和业务评估器

00:16:18.066 --> 00:16:19.333
却很难复制

00:16:19.866 --> 00:16:22.200
这种资产还有很强的领域属性

00:16:22.366 --> 00:16:23.800
芯片公司积累的是

00:16:23.800 --> 00:16:26.566
内核编译器和硬件结果

00:16:26.866 --> 00:16:28.366
药物公司积累的是

00:16:28.366 --> 00:16:30.533
分子设计与实验反馈

00:16:30.900 --> 00:16:32.933
软件团队积累的是代码

00:16:32.933 --> 00:16:35.266
修改测试和故障记录

00:16:35.700 --> 00:16:37.333
它们无法像通用文本

00:16:37.333 --> 00:16:39.566
那样随手从互联网获取

00:16:39.733 --> 00:16:41.366
未来的agent护城河

00:16:41.566 --> 00:16:43.133
可能由两部分组成

00:16:43.566 --> 00:16:44.933
一套探索策略

00:16:44.966 --> 00:16:46.600
加上一批经过验证

00:16:46.600 --> 00:16:48.733
能够重放的决策世界

00:16:48.933 --> 00:16:50.566
成本结构也会改变

00:16:50.766 --> 00:16:52.800
在线执行需要调用模型

00:16:53.000 --> 00:16:54.900
占用机器并等待评估

00:16:55.200 --> 00:16:57.600
离线重放主要读取保存结果

00:16:58.100 --> 00:17:00.333
企业可以在真实执行次数不变

00:17:00.333 --> 00:17:03.066
的情况下测试更多调度候选

00:17:03.100 --> 00:17:06.066
一次失败不再只产生沉默成本

00:17:06.300 --> 00:17:08.966
还能提高以后筛选策略的效率

00:17:09.466 --> 00:17:10.666
任务量越大

00:17:10.766 --> 00:17:13.666
历史复用带来的边际价值越明显

00:17:13.733 --> 00:17:16.766
不过保存完整探索树并不便宜

00:17:16.866 --> 00:17:19.933
每个节点可能包含代码仓库快照

00:17:20.100 --> 00:17:23.366
编译产物日志评测结果和模型

00:17:23.366 --> 00:17:24.266
上下文

00:17:24.466 --> 00:17:27.733
长期积累会带来存储与治理压力

00:17:28.100 --> 00:17:30.000
企业还要处理商业机密

00:17:30.000 --> 00:17:32.400
个人数据和第三方代码许可

00:17:32.500 --> 00:17:34.133
不能为了训练调度器

00:17:34.133 --> 00:17:36.066
无限期保存所有轨迹

00:17:36.200 --> 00:17:37.800
哪些节点值得保留

00:17:37.966 --> 00:17:38.933
怎样脱敏

00:17:39.133 --> 00:17:40.266
多久删除

00:17:40.466 --> 00:17:41.733
同样需要策略

00:17:41.866 --> 00:17:44.166
多人协作会让问题更复杂

00:17:44.800 --> 00:17:46.966
一个agent负责提出方案

00:17:47.300 --> 00:17:48.700
另一个负责测试

00:17:48.900 --> 00:17:50.466
第三个负责审查

00:17:50.733 --> 00:17:53.500
探索树里就会包含多个角色的行动

00:17:53.800 --> 00:17:55.700
Dreamrsi目前主要改进

00:17:55.700 --> 00:17:57.366
统一的探索控制器

00:17:57.500 --> 00:17:59.000
未来系统可能进一步

00:17:59.000 --> 00:18:00.700
学习怎样分配角色

00:18:00.900 --> 00:18:03.400
什么时候让不同模型互相检查

00:18:03.566 --> 00:18:06.133
调度层一旦扩展到模型选择

00:18:06.300 --> 00:18:09.333
成本和能力都会出现新的组合空间

00:18:09.400 --> 00:18:11.733
这里也存在反馈回路风险

00:18:12.300 --> 00:18:14.500
某一版策略偏爱某种路线

00:18:14.733 --> 00:18:16.600
它生成的新历史就会

00:18:16.600 --> 00:18:18.266
更多覆盖这种路线

00:18:19.133 --> 00:18:21.266
下一版又在这些历史上训练

00:18:21.400 --> 00:18:23.200
偏好可能逐轮强化

00:18:23.366 --> 00:18:25.566
系统需要保留一定探索比例

00:18:25.733 --> 00:18:27.900
主动寻找历史之外的区域

00:18:28.266 --> 00:18:30.000
否则模拟器池越大

00:18:30.066 --> 00:18:31.200
视野反而越窄

00:18:31.666 --> 00:18:35.133
论文中策略在停滞后重新扩大探索

00:18:35.766 --> 00:18:37.300
是一个积极信号

00:18:37.366 --> 00:18:39.166
却不能保证所有任务

00:18:39.166 --> 00:18:41.166
都会自然出现这种行为

00:18:41.400 --> 00:18:43.266
软件工程会最先受益

00:18:43.533 --> 00:18:46.900
编译测试和性能评估都有明确反馈

00:18:47.166 --> 00:18:48.733
agent生成代码以后

00:18:48.733 --> 00:18:50.366
可以迅速知道对错

00:18:50.733 --> 00:18:54.066
芯片设计数据库查询优化自动

00:18:54.066 --> 00:18:57.466
调参和运筹问题也具备类似条件

00:18:57.600 --> 00:18:59.533
只要结果可以自动验证

00:19:00.266 --> 00:19:02.866
历史就能被组织成重放空间

00:19:03.100 --> 00:19:05.700
策略改进也有稳定分数可以追踪

00:19:05.866 --> 00:19:08.200
开放式研究要困难的多

00:19:08.200 --> 00:19:11.100
一项科学假设是否有价值

00:19:11.200 --> 00:19:12.866
可能几年后才知道

00:19:13.200 --> 00:19:14.966
实验失败也可能来自

00:19:14.966 --> 00:19:17.566
设备样本或测量误差

00:19:17.733 --> 00:19:19.266
评分器给错方向

00:19:19.466 --> 00:19:22.400
agent就会越来越擅长追逐错误目标

00:19:22.700 --> 00:19:25.400
dream RSI解决了反馈昂贵的问题

00:19:25.700 --> 00:19:27.066
却没有自动解决

00:19:27.066 --> 00:19:28.800
反馈是否真实的问题

00:19:29.100 --> 00:19:30.100
这种风险在自我

00:19:30.100 --> 00:19:31.766
改进系统里会被放大

00:19:31.900 --> 00:19:33.166
系统每一轮都根据

00:19:33.166 --> 00:19:35.000
评分选择下一版策略

00:19:35.266 --> 00:19:37.900
评分规则中的漏洞也会被持续利用

00:19:38.133 --> 00:19:40.800
一个只奖励速度的内核优化器

00:19:41.100 --> 00:19:44.266
可能寻找牺牲数值稳定性的捷径

00:19:44.400 --> 00:19:47.400
一个只看测试通过率的编码agent

00:19:47.800 --> 00:19:50.266
可能针对测试用例过拟合

00:19:50.600 --> 00:19:52.133
一个企业流程agent

00:19:52.533 --> 00:19:54.000
甚至可能学会绕开

00:19:54.000 --> 00:19:56.333
耗时但必要的审核步骤

00:19:56.500 --> 00:19:57.933
优化循环越有效

00:19:58.333 --> 00:20:00.300
代理指标越需要谨慎设计

00:20:00.566 --> 00:20:02.666
历史本身也可能污染策略

00:20:03.333 --> 00:20:05.300
旧任务里存在错误标签

00:20:05.500 --> 00:20:07.366
异常环境或偶然成功

00:20:07.933 --> 00:20:10.500
重放系统会把它们当做确定结果

00:20:11.133 --> 00:20:13.366
模拟器在记录区域内很精确

00:20:14.066 --> 00:20:15.966
可记录不一定代表未来

00:20:16.066 --> 00:20:19.400
软件版本硬件业务规则和

00:20:19.400 --> 00:20:21.566
安全政策发生变化以后

00:20:21.700 --> 00:20:24.100
旧节点的结果可能已经失效

00:20:24.266 --> 00:20:26.000
企业需要给历史树加

00:20:26.000 --> 00:20:28.500
版本时间和环境标签

00:20:28.600 --> 00:20:31.133
还要知道什么时候让旧世界退役

00:20:31.366 --> 00:20:33.566
安全边界同样不能省略

00:20:34.133 --> 00:20:36.600
探索策略决定哪些代码被执行

00:20:36.600 --> 00:20:38.066
多少任务并行

00:20:38.066 --> 00:20:39.533
以及什么时候停止

00:20:39.700 --> 00:20:41.933
它本身已经掌握实际资源

00:20:42.133 --> 00:20:43.500
策略开发代理如果

00:20:43.500 --> 00:20:45.466
可以任意修改调度代码

00:20:45.533 --> 00:20:48.066
就必须运行在隔离环境里

00:20:48.200 --> 00:20:51.066
限制网络凭证和文件权限

00:20:51.566 --> 00:20:53.200
候选策略应先通过

00:20:53.200 --> 00:20:55.300
静态检查和沙箱测试

00:20:55.300 --> 00:20:56.900
再进入历史回放

00:20:57.133 --> 00:20:59.333
被选中的版本还需要清楚

00:20:59.333 --> 00:21:01.533
的差异记录和回滚路径

00:21:01.766 --> 00:21:02.966
从这个角度看

00:21:03.166 --> 00:21:05.733
dream RSI反而提供了一种比较

00:21:05.733 --> 00:21:08.166
容易审计的自我改进方式

00:21:08.733 --> 00:21:10.600
他修改外部策略代码

00:21:10.766 --> 00:21:11.966
绕开了直接改变

00:21:11.966 --> 00:21:13.766
难以解释的模型权重

00:21:13.966 --> 00:21:15.500
每个版本写了什么

00:21:15.500 --> 00:21:16.966
为什么得分更高

00:21:16.966 --> 00:21:19.266
在哪些历史树上通过测试

00:21:19.300 --> 00:21:20.600
都可以留下记录

00:21:21.133 --> 00:21:22.300
危险没有消失

00:21:22.300 --> 00:21:24.300
但变化发生在可见层

00:21:24.400 --> 00:21:26.200
治理工具更容易介入

00:21:26.300 --> 00:21:28.466
外界也不能忽略研究状态

00:21:29.300 --> 00:21:32.300
dream RSI目前是Arxiv预印本

00:21:32.666 --> 00:21:35.300
实验结果主要由作者团队报告

00:21:35.400 --> 00:21:38.100
还没有经过完整的独立同行评审

00:21:38.500 --> 00:21:39.966
项目仓库已经公开

00:21:40.133 --> 00:21:42.300
readme在当前阶段明确写着

00:21:42.300 --> 00:21:44.700
完整代码复现实验脚本和

00:21:44.700 --> 00:21:46.766
发现程序仍在准备发布

00:21:46.933 --> 00:21:48.866
论文附录提供了部分程序

00:21:49.333 --> 00:21:51.200
项目网页也有交互演示

00:21:51.366 --> 00:21:52.700
但外部团队还不能

00:21:52.700 --> 00:21:54.400
一键重跑全部结果

00:21:54.533 --> 00:21:57.200
这条信息会影响结论强度

00:21:57.400 --> 00:21:59.966
论文证明了一种值得重视的方法

00:22:00.000 --> 00:22:02.166
并用8项任务给出证据

00:22:02.333 --> 00:22:03.900
它还没有证明这套方法

00:22:03.900 --> 00:22:06.000
能普遍适用于所有agent

00:22:06.400 --> 00:22:08.266
更没有证明任何接入它的

00:22:08.266 --> 00:22:10.866
模型都会持续提高总体智能

00:22:10.866 --> 00:22:13.266
完整代码发布独立复现

00:22:13.400 --> 00:22:15.800
更多模型与更多任务测试

00:22:16.000 --> 00:22:17.866
才会决定这些数字能否

00:22:17.866 --> 00:22:19.500
离开研究团队的环境

00:22:19.600 --> 00:22:22.966
自我进化仍然可以用来概括dream RSI

00:22:23.333 --> 00:22:25.933
只是必须说清进化发生在哪里

00:22:25.966 --> 00:22:28.300
这里的变化集中在元探索层

00:22:28.466 --> 00:22:30.666
固定的编码agent从历史

00:22:30.666 --> 00:22:32.933
探索记录中改进外部策略

00:22:33.100 --> 00:22:35.366
再用新策略收集更多历史

00:22:35.666 --> 00:22:36.766
模型没有觉醒

00:22:36.900 --> 00:22:38.066
也没有获得修改

00:22:38.066 --> 00:22:39.900
自身全部组件的权利

00:22:40.100 --> 00:22:42.266
目标始终是提高发现效率

00:22:42.500 --> 00:22:44.100
这一步的意义并不小

00:22:44.266 --> 00:22:46.100
过去提升agent表现

00:22:46.300 --> 00:22:49.200
最直接的方法是换更大的模型

00:22:49.300 --> 00:22:50.600
增加推理TOKEN

00:22:50.733 --> 00:22:52.000
或多跑几次

00:22:52.200 --> 00:22:54.500
dream RSI给出第四条路线

00:22:54.666 --> 00:22:56.266
保留过去搜索的结构

00:22:56.266 --> 00:22:59.300
让系统学习怎样花下一笔计算预算

00:22:59.533 --> 00:23:00.966
算力没有变免费

00:23:01.466 --> 00:23:03.733
失败却不再只是一张账单

00:23:03.900 --> 00:23:05.566
只要记录足够完整

00:23:05.733 --> 00:23:07.200
它还能为后续策略

00:23:07.200 --> 00:23:09.000
提供一次又一次反馈

00:23:09.266 --> 00:23:11.766
它也让经验这个词变得更精确

00:23:12.166 --> 00:23:14.333
人类说从失败中学习

00:23:14.533 --> 00:23:16.333
往往靠记忆和总结

00:23:16.700 --> 00:23:18.966
dream RSI把失败变成带

00:23:18.966 --> 00:23:21.533
状态动作和结果的节点

00:23:21.700 --> 00:23:24.333
再让新策略重新经过这些节点

00:23:24.600 --> 00:23:26.400
agent会在一组已经发生

00:23:26.400 --> 00:23:28.466
过的世界里反复试走

00:23:28.733 --> 00:23:30.366
得到的反馈比读一篇

00:23:30.366 --> 00:23:32.933
复盘文章更接近行为学习

00:23:33.000 --> 00:23:35.766
也比多塞几段提示词更具体

00:23:36.066 --> 00:23:38.600
但开头的问题仍然没有完全关闭

00:23:38.900 --> 00:23:40.666
agent究竟是变聪明

00:23:40.666 --> 00:23:42.600
还是只更会走旧地图

00:23:42.900 --> 00:23:45.400
目前的答案是两者之间

00:23:45.566 --> 00:23:48.100
它没有获得超出基础模型的新知识

00:23:48.366 --> 00:23:50.500
也看不见历史之外的结果

00:23:50.866 --> 00:23:53.166
可他确实改变了资源分配方式

00:23:53.400 --> 00:23:55.566
并在下一轮真实探索中

00:23:55.700 --> 00:23:58.066
到达旧策略没有到过的位置

00:23:58.400 --> 00:24:00.100
只要新世界不断加入

00:24:00.200 --> 00:24:01.733
旧地图就不再静止

00:24:01.933 --> 00:24:03.700
真正值得警惕和

00:24:03.700 --> 00:24:05.533
期待的地方都在这里

00:24:05.566 --> 00:24:06.600
一个闭环系统

00:24:06.600 --> 00:24:08.666
不需要每轮重训大模型

00:24:08.666 --> 00:24:11.300
也可能逐步改善自己的工作方法

00:24:11.666 --> 00:24:12.866
今天它优化的是

00:24:12.866 --> 00:24:15.200
分支并行和停止规则

00:24:15.700 --> 00:24:17.733
明天类似机制可能扩展到

00:24:17.733 --> 00:24:20.600
工具选择记忆管理和验证流程

00:24:20.766 --> 00:24:22.133
每多开放一层

00:24:22.200 --> 00:24:23.866
能力上限会提高

00:24:23.966 --> 00:24:27.133
错误目标和权限风险也会跟着放大

00:24:27.266 --> 00:24:29.100
dream RSI没有带来科幻

00:24:29.100 --> 00:24:30.800
故事里的智能爆炸

00:24:31.333 --> 00:24:33.800
它展示的是一条更现实的路径

00:24:34.133 --> 00:24:35.933
基础模型保持不动

00:24:36.000 --> 00:24:38.400
外围系统通过历史评测

00:24:38.400 --> 00:24:40.566
和代码迭代持续变强

00:24:40.666 --> 00:24:41.966
这种变化更慢

00:24:41.966 --> 00:24:43.333
也更工程化

00:24:43.400 --> 00:24:46.066
却可能更早进入真实产品

00:24:46.133 --> 00:24:47.700
因为企业不需要等待

00:24:47.700 --> 00:24:50.500
一个会重写自身大脑的AGI

00:24:50.966 --> 00:24:54.333
只要现有agent学会少走一半弯路

00:24:54.700 --> 00:24:57.166
成本结构就已经会被改变

00:24:57.266 --> 00:24:59.333
外部验证将是下一道关

00:24:59.766 --> 00:25:01.933
项目页面和论文已经公开

00:25:02.333 --> 00:25:04.066
Git Hub仓库也能找到

00:25:04.133 --> 00:25:06.400
但仓库当前明确标注完整

00:25:06.400 --> 00:25:09.133
代码库复现实验脚本和

00:25:09.133 --> 00:25:11.266
部分发现程序仍在准备

00:25:11.466 --> 00:25:13.000
研究者暂时可以检查

00:25:13.000 --> 00:25:15.533
方法数字和附录里的程序

00:25:15.700 --> 00:25:17.733
却难以完全重建每一次

00:25:17.733 --> 00:25:20.800
探索树模型调用和评测环境

00:25:21.300 --> 00:25:22.900
论文结果因此属于有

00:25:22.900 --> 00:25:24.700
材料支持的研究报告

00:25:25.000 --> 00:25:26.400
还不是已经被多家

00:25:26.400 --> 00:25:28.766
实验室重复确认的工程定律

00:25:28.966 --> 00:25:30.600
完整代码发布以后

00:25:30.733 --> 00:25:32.533
最需要复查的是结果对

00:25:32.533 --> 00:25:34.900
随机性和预算设置有多敏感

00:25:35.400 --> 00:25:37.866
不能只盯某一张最终成绩表

00:25:38.166 --> 00:25:39.800
换一批初始节点

00:25:40.100 --> 00:25:42.000
优势是否仍然存在

00:25:42.200 --> 00:25:44.466
把策略开发模型换掉

00:25:45.000 --> 00:25:47.000
循环还能不能稳定提高

00:25:47.200 --> 00:25:48.766
旧历史中混入低质量

00:25:48.766 --> 00:25:51.133
轨迹会不会带坏下一轮

00:25:51.266 --> 00:25:53.466
这些问题决定dream RSI

00:25:53.466 --> 00:25:55.066
是一套普遍方法

00:25:55.133 --> 00:25:56.533
还是一组特定任务

00:25:56.533 --> 00:25:58.266
下非常成功的配置

00:25:58.533 --> 00:26:00.866
基线选择也需要继续检查

00:26:01.300 --> 00:26:03.966
固定探索是很清楚的受控对照

00:26:04.333 --> 00:26:08.000
因为它与dream RSI只差策略是否更新

00:26:08.600 --> 00:26:11.766
可真实系统还会使用启发式搜索

00:26:12.066 --> 00:26:15.733
贝叶斯优化进化算法和人工经验

00:26:16.000 --> 00:26:17.933
Dreamrsi在一些任务上

00:26:17.933 --> 00:26:20.100
超过论文列出的强基线

00:26:20.166 --> 00:26:22.400
在另一些指标上只是接近

00:26:22.600 --> 00:26:25.166
后续复现应当比较相同模型

00:26:25.566 --> 00:26:27.700
相同预算和相同硬件

00:26:27.800 --> 00:26:30.300
才能知道收益来自历史重放

00:26:30.300 --> 00:26:32.366
还是来自某些实现细节

00:26:32.566 --> 00:26:34.100
研究的价值也不必

00:26:34.100 --> 00:26:35.866
依赖每个分数都获胜

00:26:36.700 --> 00:26:39.333
它把怎样探索从隐藏在框架

00:26:39.333 --> 00:26:41.733
里的手写规则变成可以被

00:26:41.733 --> 00:26:44.666
生成评估和版本管理的对象

00:26:44.866 --> 00:26:47.600
过去开发者调度agent常靠

00:26:47.600 --> 00:26:50.166
经验修改并发数和停止条件

00:26:50.666 --> 00:26:53.333
现在这些选择可以进入实验循环

00:26:53.500 --> 00:26:56.600
即使最终提升没有宣传数字那么大

00:26:56.733 --> 00:26:58.966
这种把原策略工程化的

00:26:58.966 --> 00:27:01.533
思路仍然会影响后续系统

00:27:01.566 --> 00:27:04.000
还要观察收益能维持多少轮

00:27:04.700 --> 00:27:07.200
论文展示了有限轮次里的改进

00:27:07.966 --> 00:27:10.000
任何搜索系统都可能在积累

00:27:10.000 --> 00:27:12.133
到一定阶段后进入平台期

00:27:12.500 --> 00:27:14.866
容易发现的优化先被拿走

00:27:15.000 --> 00:27:16.666
剩下的问题更难

00:27:16.900 --> 00:27:18.900
历史数也越来越庞大

00:27:19.100 --> 00:27:22.533
届时重放成本存储成本和策略开发

00:27:22.533 --> 00:27:25.600
成本会不会吞掉节省下来的调用

00:27:25.933 --> 00:27:27.966
需要更长时间实验回答

00:27:28.166 --> 00:27:29.800
递归循环已经闭合

00:27:29.800 --> 00:27:32.366
不代表性能曲线会永远向上

00:27:32.533 --> 00:27:34.900
失败记录因此获得了新的意义

00:27:35.500 --> 00:27:38.266
过去他们证明系统浪费过多少算力

00:27:38.533 --> 00:27:39.900
现在他们可以帮助下

00:27:39.900 --> 00:27:41.666
一版系统减少浪费

00:27:41.933 --> 00:27:44.500
Dreamrsi把历史变成模拟器

00:27:44.600 --> 00:27:46.533
也把每次失败变成一块

00:27:46.533 --> 00:27:48.800
可重复使用的计算资产

00:27:49.166 --> 00:27:52.266
AI能否依靠这种资产持续扩大能力

00:27:52.300 --> 00:27:55.300
还要等待独立复现和更多任务验证

00:27:55.366 --> 00:27:57.333
可那扇门已经被推开

00:27:57.466 --> 00:28:00.500
真正的竞争会从谁拥有更强模型

00:28:00.666 --> 00:28:02.900
延伸到谁拥有更好的历史

00:28:03.100 --> 00:28:05.300
以及谁最会利用这些历史