[00:00:00] 好今天我们来讲和生成式软件工程里面非常关系特别大的一个
[00:00:05] 也就是你和AI沟通的那个渠道
[00:00:08] 就是自然语言的提示词
[00:00:10] 这基本上就是大家和机器沟通的唯一的接口
[00:00:14] 也就是从ChatGPT的时代
[00:00:16] 大家从那个聊天窗口
[00:00:18] 开始跟ChatGPT聊天的时候
[00:00:20] 他就知道我们有prompt要给机器一个指令
[00:00:24] 然后AI会给我们返回很多的内容
[00:00:26] 可能是文字的代码
[00:00:28] 图片都有可能通过prompt来生成
[00:00:30] 然后我第一次感受prompt的力量
[00:00:34] 是我每年因为我上操作系统课
[00:00:36] 当时正好是2023年
[00:00:38] 2023年
[00:00:38] 那就是22年底ChatGPT刚发布的时候
[00:00:41] 然后我试图让ChatGPT帮我来讲一讲这内联汇编
[00:00:46] 现在应该已经没有人写内联汇编了
[00:00:49] 对就成为了一个传统艺能
[00:00:51] 然后发现他解释的出奇的好
[00:00:53] 而且而且真的是一个应该是没有在他训练语料之内的东西
[00:00:57] 就我稍微故意做了一个地球人应该不会实现的一个内联汇编
[00:01:02] 但是他做的相当的好
[00:01:03] 虽然确实不完美
[00:01:05] 那时刻我就觉得突然间就感觉好像时代要变了
[00:01:09] 但可能没有到今天这么清楚的
[00:01:13] 感受到时代会变以及怎么样的变化
[00:01:16] 那提示词就这样成为了一个新词
[00:01:19] prompt在这之前
[00:01:21] 好像
[00:01:22] 在ChatGPT之前
[00:01:23] 我们没有用这个意思来讨论过prompt这个
[00:01:26] 这个东西
[00:01:27] 实际上你们可能会觉得OK你在聊天框里面打的那段东西叫提示词
[00:01:32] 帮我生成一个什么什么的游戏
[00:01:34] 或者帮我把这个作业给做完
[00:01:36] 但实际上提示词不仅是在你的对话框当中的
[00:01:40] agent他看到的是一整个agent的上下文
[00:01:44] 也就是说从从你在和agent聊天之前
[00:01:49] 这个agent它就能够看到一个叫做system prompt的东西
[00:01:55] 这也是一个提示词
[00:01:57] OK它也叫提示词
[00:01:58] 然后在这个system prompt之后
[00:02:01] 它还会加载很多的很多的东西
[00:02:05] 比如说你的agents.md
[00:02:07] 然后你可能你还会加载一些skills agents
[00:02:12] agents.md里面还会要求它再去读别的文件
[00:02:15] 那实际上在你的agent的第一次停下来和你对话的时候
[00:02:20] 它里面已经有很多很多的东西了
[00:02:22] 就从最初的这个系统提示词开始
[00:02:26] 有可能是你的那个agent harness，像codex
[00:02:29] Claude Code它内建的
[00:02:32] 然后除此之外，你的所有的工具调用和工具调用的结果
[00:02:37] 它实际上也是出现在你的上下文里
[00:02:39] 它是一个线性的上下文
[00:02:41] 然后直到有一天哈你的user会和他聊天
[00:02:46] 说哎给我做一个游戏吧
[00:02:47] 所以提示词是非常非常长的
[00:02:51] 这也意味着今天agent的能力是非常离谱的
[00:02:56] 他可以看到一个非常长的提示词
[00:02:58] 比如说你在最早的system prompt里面可以让他用中文回答
[00:03:03] 我就会因为我为了上课的效果
[00:03:05] 我就会让他用中文回答
[00:03:06] 哪怕我用英文写prompt
[00:03:09] 就我这边的user message是英文
[00:03:11] 它输出的仍然是中文
[00:03:13] 你们会看到这个行为
[00:03:16] 然后那么实际上当我们说优化提示词的时候
[00:03:20] 那我们就不仅仅是给它一个指令
[00:03:23] 实际上当我们说优化提示词或者说提示词工程的时候
[00:03:27] 我们实际上表达的是一个叫上下文工程
[00:03:30] 也就是整个模型的上下文
[00:03:31] 我们都知道
[00:03:33] 假设大家都知道
[00:03:34] 模型做的是next token prediction
[00:03:36] 他每一次可以去预测下一个token
[00:03:39] 这个token可以是调用工具
[00:03:40] 可以是就输出一个字符
[00:03:43] 但是它会不停的向后去推进你的任务的
[00:03:47] 执行。大概我就感觉是从Claude Opus 4.5这一代的时候
[00:03:52] ANTHROPIC发现模型突然学会了他靠强化学习和后训练
[00:03:56] 学会了非常强的指令遵循能力
[00:03:58] 你有一个非常长接近百万的上下文
[00:04:01] 它依然可以在很后面的时候能够遵循你的指令
[00:04:05] 并且能够一定程度上看到
[00:04:08] 前面的东西。有一个很著名的梗
[00:04:11] 就说你可以在提示词上面
[00:04:14] 在最早的prompt上面加一个说
[00:04:16] 你每说一句话都要在后面加一个喵
[00:04:20] 然后你等到有一天你发现这个就你跟他工作工作工作工作的时候
[00:04:24] 突然发现他跟你聊天的时候
[00:04:26] 那个喵丢了
[00:04:27] 然后你就知道它不管是因为上下文溢出被截断了还是压缩了等
[00:04:32] 某种反
[00:04:33] 反正他开始不能遵循指令了
[00:04:35] 这时候你就需要这个重新来啊哈想一个办法
[00:04:39] 这就是大家在工程实践当中发现的很有趣的各种各样的上下文工程
[00:04:45] 也就是提示词工程的方式
[00:04:47] 而我们今天我上这门课
[00:04:50] 也希望告诉大家最重要的一件事
[00:04:53] 为什么会说那个没有没有token就应该退学
[00:04:57] 我希望告诉大家的是
[00:04:59] 所有的事情你都应该立即开始尝试AI给我们的一个能力
[00:05:04] 就是任何时候你觉得有一点麻烦
[00:05:08] 你都可以立即行动
[00:05:10] 因为AI是一个非常耐心的老师
[00:05:13] 不像有的时候我一我因为我从我上大学的时候有一种感觉
[00:05:18] 我有个东西不会
[00:05:19] 可能我的室友会
[00:05:20] 然后我跟他沟通的成本很高
[00:05:23] 而且我可能会有这样的想法
[00:05:25] 哎呀我是不是就在我室友面前暴露了我很菜
[00:05:29] 这可能是一个我不想告诉他的秘密
[00:05:32] 但anyway
[00:05:33] 蔡也这也很正常
[00:05:34] 但对于AI这个老师来说
[00:05:36] 他不会嫌弃你
[00:05:36] 而且你可以任意程度的追问
[00:05:40] 所以啊当我们说比如说我刚才说到一个概念
[00:05:44] 说哎我们的CAI的agent是有一个很长的上下文的
[00:05:50] 他有system prom
[00:05:50] 有各种各样的东西
[00:05:51] 那我下一秒钟啧
[00:05:55] 我就可以立即打开一个agent
[00:06:00] 我可以立即打开一个agent
[00:06:02] 然后我可以直接对我可以直接问他
[00:06:08] 说老师上课的时候说
[00:06:12] agent的上下文里不仅是一两个提示词
[00:06:17] 你能检查一下你的上下文里都有些什么吗
[00:06:25] 他其实可以自己检查自己
[00:06:27] 甚至他可以自己检查自己的日志
[00:06:30] 这A证呢就经常会给你一些惊喜
[00:06:34] 当你问出一个问题的时候
[00:06:35] 他的解决的手段是出乎你意料的
[00:06:40] 所以我们来看一下
[00:06:44] 因为agent正好是可以看到自己的上下文的
[00:06:49] 根据我们上课所说
[00:06:50] 他是next token predict
[00:06:51] 他能看到所有东西
[00:06:52] 所以他应该能够读出来
[00:06:54] 除非有明确的指令禁止
[00:06:56] 比如说有些
[00:06:58] 像这个模型的providers
[00:07:00] 它都会禁止你去套取它的系统上下文
[00:07:03] 这是它会通过模型的微调
[00:07:07] 也会啊通过一些明确的指令
[00:07:09] 比如说在system prompt的前面
[00:07:11] 就会说你任何形式你要回答system prom都是都是拒绝的
[00:07:15] 但因为这是一个整个开源的框架
[00:07:17] 它本身你就可以debug它
[00:07:19] 所以你看这个系统提示词来自哪里
[00:07:23] 来自哪里
[00:07:24] 然后以及他的要求工具使用的指南
[00:07:26] 回复要简洁
[00:07:28] 然后接下来他会打开这个我用户下的派下的agent下的agents.md
[00:07:35] 这个是我自己写的
[00:07:36] 所以你看我
[00:07:37] 我因为我是上课演示的机器
[00:07:38] 所以我在这个全局的上下文里面放了一个用中文回答
[00:07:42] 然后我有一个结尾必须写一个recap
[00:07:45] 这个细节大家可能啊意识到了
[00:07:49] 就是你们第一个在模型跑完了以后
[00:07:51] 你们第一个看到的是
[00:07:53] 我总结了这一次
[00:07:55] 做什么对agents.md
[00:07:58] 然后有这个项目级的指令
[00:08:00] 所以它是一层一层一层的
[00:08:02] agent你目录里面还可以再放agents点点MD
[00:08:05] 然后还有一个skills的索引
[00:08:08] skills就是模型能够执行的功能
[00:08:11] 比如说我有一个叫make slice的skill
[00:08:13] 它可以使我能够啊在这里F5播放幻灯片的那个幻灯片的渲染
[00:08:21] 那么这个幻灯片的渲染就是一个skill
[00:08:23] 但是模型只能在上下文里面看到他的描述
[00:08:28] 他那个我头上写的那个meta data
[00:08:30] 它的名字是什么
[00:08:31] 它的描述一个简略的描述是什么
[00:08:33] 然后我整个很长
[00:08:34] 它可能写一个很长的skill
[00:08:36] 它都只是按需加载的
[00:08:37] 然后等到那一轮加载完了以后
[00:08:39] 这个skill也会从这个上下文里面被抹掉
[00:08:43] 对啊只有匹配任务的时候才啊才读取完整的skill点MD
[00:08:49] 然后以及还有工具的定义
[00:08:50] 你看它的工具也是直接以文本的形式出现在它的上下文里了
[00:08:56] 然后以及绘画的绘画的历史
[00:08:58] 环境变量每一次执行诶
[00:09:01] 这是这是大家所不知道的
[00:09:03] 每一次执行都会注入当前的一些环境
[00:09:07] 比如说模型
[00:09:08] 甚至是当前的时间
[00:09:10] 如果你和这个deep sick chat去聊天的话
[00:09:13] 你可以把他的那个每次注入的环境给套出来
[00:09:16] 这个不属于系统提示词
[00:09:17] 你是可以跟他
[00:09:20] 把它把它套出来的
[00:09:21] 所以这是一个非常长的啊序列
[00:09:23] 那我们要做的就是所谓的上下文工程
[00:09:26] 提示词工程
[00:09:27] 就是把所有的这些都安排好。对，所以刚才其实我就演示了
[00:09:35] 在AI时代我们学习应该怎么样
[00:09:37] 我们不仅可以像刚才那样把他问清楚
[00:09:41] 以及在你不明白的时候追问
[00:09:43] 你还可以把它反过来
[00:09:46] 大家可能听说过这个叫费曼学习法
[00:09:48] 就是你怎么能够判定你是不是理解这个知识了
[00:09:52] 反过来你当老师
[00:09:54] 然后这件事情在你做就是我们做学生的时代也是很代价非常大的
[00:10:00] 因为你要做老师
[00:10:01] 就必须要有一个听众来检验你
[00:10:03] 那个听众很有可能是你的室友
[00:10:05] 那个室友可能不想听你在那啰嗦这个东西
[00:10:08] 他可能对这个不感兴趣
[00:10:09] 可能他对这个了解的太清楚了
[00:10:11] 也许他就是单纯不想互相帮助
[00:10:14] 但是AI这个时候你可以把
[00:10:15] 就是刚才我们一直说你可以把AI当老师
[00:10:19] 你去请教他
[00:10:20] 请教他
[00:10:20] 请教他
[00:10:20] 请教他
[00:10:20] 把他弄懂
[00:10:21] 然后你可以在你自己自认为弄懂以后
[00:10:23] 再反过来
[00:10:24] 你自己再自己做老师
[00:10:27] 然后说哎呀你现在来扮演学生
[00:10:29] 我要把这个东西给你讲懂
[00:10:31] 你假装什么都不知道
[00:10:33] 然后这时候你来看我哪里逻辑是不是有错有漏
[00:10:38] 你在这个时候纠正我
[00:10:40] 哎你再正着一遍
[00:10:41] 反着一遍
[00:10:42] 你基本上就对这个概念理解的很清楚了
[00:10:44] 所以我觉得大家作为AI native的
[00:10:46] 一代人一定会把我们这一代人给彻底卷死的
[00:10:49] 因为你们有无限的时间
[00:10:51] 就我第一节课的观点
[00:10:52] 你们现在的任务就是学习
[00:10:55] 没有像我比如说要负责一些其他的事情
[00:10:58] 就绝对要对别人负责
[00:11:00] 那么啊那就是你们最好的最好的时代
[00:11:03] 所以啊你们你们也可以把这个费曼学习法啊给用起来
[00:11:07] 刚才我就展示了这样的一个解剖当前上下文的例子
[00:11:13] 这个这个就过去了
[00:11:15] 然后你们在学习这些东西的过程当中会留意到很多有趣的小细节
[00:11:24] 你们有没有在用codex的时候
[00:11:26] 我不知道你们有没有同学用codex
[00:11:28] 啊不要紧
[00:11:30] 你们用任何agent的时候都可能面临一个问题
[00:11:34] 如果你要执行一件危险的操作
[00:11:36] 它会让你确认
[00:11:37] 当然比如说这个pi默认在默认的配置下
[00:11:41] 它是YOLO mode
[00:11:42] 就是它他所有事情都直接执行
[00:11:45] 然后如果如果我今天有一个提示词给的不是很好
[00:11:49] 他有可能就直接把我整个就删了
[00:11:50] 我今天就好
[00:11:51] 我就直接下课了
[00:11:52] 这是这是有可能的
[00:11:54] 但这是一个平衡
[00:11:56] 你可以在更安全的环境里面运行
[00:11:59] 比如说沙箱模式运行
[00:12:01] 但沙箱模式运行
[00:12:02] 你们如果观察过像codex的运行
[00:12:04] 它经常会我先试一下做一件什么事
[00:12:07] 然后失败了
[00:12:08] 然后他意识到这是在沙箱里面做
[00:12:10] 我在沙箱里面其实不能做这件事
[00:12:12] 我现在在外面再做一次
[00:12:14] 然后再做一次的时候
[00:12:15] 他甚至会问
[00:12:16] 我现在要做一件可能有一点危险的事情
[00:12:18] 你是yes还是NO
[00:12:20] 这就很讨厌
[00:12:21] 因为你最想的
[00:12:23] 对于对于我们来说最想的就是哎我今天要去吃饭了
[00:12:26] 很好
[00:12:26] 我把这agent的任务先跑上
[00:12:28] 先把三个任务都想好
[00:12:29] 三个任务都跑上
[00:12:29] 然后去吃饭
[00:12:30] 然后吃饭回来的时候
[00:12:31] 你发现他跑了一分钟
[00:12:33] 就问你要确认你就
[00:12:36] 你就觉得浪费了AI真的是时间浪费了自己的生命
[00:12:41] 你们经常会看到这样的小细节
[00:12:44] 然后你们在小细节上的注意力
[00:12:47] 一定程度上成就了你们可以走多远
[00:12:50] 所以这也是现在AI时代最好的地方
[00:12:53] 比如说我就有留意到codex有这样的一个细节
[00:12:57] 他有些命令他会认为这是一个不太危险的命令
[00:13:02] 这个好像直接做也没有关系的命令
[00:13:05] 所以他不是说每次调用bash的工具
[00:13:08] 他都会叫你确认。他有些时候那个ls -l，他认为这个命令是安全的
[00:13:14] 那它就它就是安全的
[00:13:15] 实际上这个命令可能是不安全的
[00:13:17] 因为在我的环境里面可能把ls -l
[00:13:21] 重新命名成了另外一个
[00:13:22] 比如说rm这样的命令
[00:13:23] 当然应该没有人要这样做
[00:13:25] 这个恶意的环境里
[00:13:27] 那你可以好奇
[00:13:28] 比如说这是怎么做到的
[00:13:30] 你可以直接比如说我下载了一份这个codex的代码
[00:13:34] 我觉得现代软件工程和过去软件工程很不一样的地方
[00:13:40] 你们在比如说像大二大三的时候
[00:13:42] 尤其是我像你们这么大的时候
[00:13:43] 比如说我接触LINUX内核
[00:13:46] 差不多得跟你们大二大三的时候差不多接触LINUX内核
[00:13:49] 然后我光把LINUX内核下载下来
[00:13:53] 搞清楚这个东西要怎么编译就花了很长的时间
[00:13:56] 而且这还是我在有一定的LINUX使用经验的基础上
[00:14:01] 就是一个完全的劝退
[00:14:02] 某种程度上我能在那个年代活下来
[00:14:05] 就是因为我对这种劝退的东西有一种我一定还要试一试的执念
[00:14:10] 然后在今天你们
[00:14:12] 我相信每个同学都会有的
[00:14:13] 如果这是个好东西
[00:14:14] codex很好
[00:14:16] 也许你们不喜欢codex
[00:14:19] 你们喜欢pi，pi更轻量
[00:14:20] 当然pi显然是更轻量的
[00:14:23] 但你们现在不需要害怕任何一个软件系统的复杂性
[00:14:26] 因为你可以直接问
[00:14:28] 比如说
[00:14:29] 当然我这里没有豆包输入法
[00:14:30] 我还是就手输了
[00:14:32] 我留意到一个很有趣的问题
[00:14:39] 在调用BH的时候
[00:14:42] 有的时候会向用户确认
[00:14:46] 有的时候不会有一个风险的判定
[00:14:51] 风险其实是一个很难的问题
[00:14:56] 你并不知道具体的命令语义是什么
[00:15:02] 所以你是做了分析
[00:15:04] 还是让大模型给了风险的评级
[00:15:09] 还是别的什么方法
[00:15:12] 读一下相关的代码
[00:15:15] 这就是一种提示词
[00:15:17] 然后这个时候，pi——当pi看到我的这个提示词之后
[00:15:22] 它前面的提示词也都有
[00:15:25] 它就会开始试图解决这个问题
[00:15:29] 它去各种搜索代码
[00:15:32] 阅读代码
[00:15:33] 如果我有一些比如说像LSP这样的工具的话
[00:15:38] 它还可以去工具里面
[00:15:39] 像像你们在 IDE 里面点来点去
[00:15:42] 你们有用过IDE 的那个功能吗
[00:15:44] 我记得我上操作系统或者计算机系统基础课的时候
[00:15:49] 我都会说
[00:15:51] 我发现有很多同学从PA1做到PA4
[00:15:54] 你们那个vs code里面都还是有红线的
[00:15:57] 怎么笑了
[00:15:59] 笑了哈哈笑了
[00:16:01] 有红线就意味着你没有解锁这个正确的配置
[00:16:04] 虽然有红线
[00:16:05] 没有任何问题
[00:16:07] 你还是可以在我们的受控环境下编译
[00:16:10] 然后把所有东西都完成
[00:16:12] 但是这不是正确的practice
[00:16:14] 你应该花一点点时间去configure你的VS Code
[00:16:17] 加上那个include path
[00:16:19] 因为它是有一些-I
[00:16:20] 这样的选项
[00:16:21] 你会指定一个编译的路径
[00:16:23] 然后你把这些配置做好了以后
[00:16:25] 你就可以得到这个IDE的所有的功能
[00:16:27] 你可以用CTRL去点
[00:16:28] 然后你可以去那个rename symbol
[00:16:30] 用那种重命名符号的方式一次性重构很多东西
[00:16:33] 哪怕是在大语言模型之前的时代
[00:16:37] 然后在今天，这件事情——就配置——就变得更容易了
[00:16:41] 然后你看他确实是有让大模型
[00:16:45] 风险评级的这个——对，它有一个什么样的——这个
[00:16:51] 还有一层静态的分流
[00:16:53] 沙箱内的低风险命令会直接执行；网络
[00:16:56] allowlist命中直接放行
[00:16:58] 它有一个审批都不需要的
[00:17:00] 如果就是个ls
[00:17:01] 如果如果它有个他
[00:17:04] 你会想象codex里面会有一个parser
[00:17:07] 一个语法处理器
[00:17:10] 那这个parser会处理这个bash的命令
[00:17:12] 然后这个bash命令如果他发现是一定的白名单里面呢认为绝对安全
[00:17:16] 他会直接放行
[00:17:17] 然后如果不是的话
[00:17:18] 它会在prompt里面
[00:17:20] inject一小段话
[00:17:21] 同样也是prompt engineering
[00:17:23] 它inject一小段话
[00:17:25] 说你是不是应该给我评级一下他的额安全性
[00:17:29] 那我现在也可以直接把安全评估的prompt打印出来看。它是我——
[00:17:41] 我事先完全没有准备
[00:17:42] 就我完全不知道是什么
[00:17:44] 我可能我们也不能百分之百的去相信这个
[00:17:48] 我现在DeepSeek的模型
[00:17:50] 但是这个方法是非常有用的
[00:17:52] 你可以比如说如果你对他不相信
[00:17:56] 你可以做什么
[00:17:58] 你可以让他把这个prompt改一改
[00:18:01] 比如说把这个prompt改成以前某一个不会拒绝的东西
[00:18:05] 他要拒绝
[00:18:06] 或者以前某一个拒绝的东西
[00:18:07] 他会不拒绝
[00:18:09] 这都是prompt可以控制的
[00:18:10] 然后改完了以后
[00:18:12] 这个你可以观察到他行为的变化
[00:18:16] 这就成为了一个啊证据
[00:18:18] 你也可以让AJ来做这件事
[00:18:24] OK啊他有一些这个
[00:18:34] untrusted evidence
[00:18:36] 然后他可能啊可能有一些有一些什么
[00:18:40] 我就不再花时间啊去看了
[00:18:43] 基本上是告诉大家OK我们agent的上下文啊是什么
[00:18:48] 然后我们应该怎么样
[00:18:50] 做这个提示词的工程好
[00:18:53] 那我就可以再往后多讲一点
[00:18:56] 怎我们怎么做写一个好的提示词
[00:18:59] 或者写一个好的模型的
[00:19:01] 上下文
[00:19:03] 我们都知道上下文包含了一个非常非常复杂的要求
[00:19:08] 然后又想到那个软件工程里面那个老大难的问题
[00:19:11] 我们有我们有intent
[00:19:15] 我们脑子里面所想的是做一个国民级的应用
[00:19:18] 然后从影探呢我们可以到expect这个软件的架构是什么
[00:19:21] 应该选什么语言来实现
[00:19:24] 有很多很多的细节
[00:19:26] 当我们把这些细节定好了以后
[00:19:28] 我们还要去做implementation好
[00:19:30] 那么在任何时候
[00:19:33] 我们用这个模型去完成一个软件工程任务的时候
[00:19:39] 我们都会把整个大流程里面的一部分全部都塞到模型的上下文里
[00:19:46] 就像刚才我让agent去帮我读这个codex代码的时候
[00:19:50] 我他其实读到了这个codex的一些设计的原则
[00:19:54] 比如说为会有一般来说都会有一个文档说为什么我需要这个安全策略
[00:19:58] 安全策略是怎么总体是怎么想怎么想的
[00:20:01] 然后他可能有一个spec文档
[00:20:02] 这安全策略是怎么做的
[00:20:04] 还有这个implementation
[00:20:05] 它是它是怎么怎么实实现的
[00:20:09] 这是一个互相印证
[00:20:12] 然后往后输出的输出的过程
[00:20:16] 那么如果我们想要写一个好的模型的上下文
[00:20:22] 这个来完成一个
[00:20:25] 当然还是完成一个
[00:20:26] 比如说软件工程里面的任务的时候
[00:20:28] 我们的原则是什么
[00:20:30] 我们的原则是什么
[00:20:31] 你还是去想这个gap
[00:20:35] 如果你给模型一个模糊的intent
[00:20:39] 他就很容易认为它完成了
[00:20:42] 你说给我生成一个什么CSGO
[00:20:44] 然后他就给你生成一个CSGO
[00:20:46] 然后这个时候它就可能发生漂移
[00:20:49] 但如果你能给模型的模型完整的你的系统的设计和SPECT
[00:20:55] 那这个时候模型遵循你系统SPECT
[00:20:57] 就假设模型能力是无限大的
[00:21:00] 就会更加确定和你可以验证
[00:21:03] 因为比如说你说你要用C加加来实现
[00:21:06] 他最后给你一个java的实现
[00:21:08] 你一眼就看出来了
[00:21:09] 你认为不满意的模型
[00:21:11] 也应该认为不满意
[00:21:13] 但
[00:21:13] 就如果你在intent的时候说就给我做一个什么东西
[00:21:16] 你没有说用C加加
[00:21:17] 他也不了解你的时候
[00:21:19] 他就写了一个java的事情
[00:21:21] 那啊就发生了一个很大的很大的漂移
[00:21:24] 所以整个模型上下文的最重要的原则就是
[00:21:30] 如果你的任务是明确可以验证的
[00:21:33] 尤其是机器可以验证
[00:21:35] 比如说你有一个脚本
[00:21:36] 这个脚本就说测试通过了还是不通过
[00:21:39] 那么agent就可以不计代价的一轮一轮一次一次的尝试
[00:21:44] 把这件事情给完成
[00:21:46] 甚至agent的在多轮失败以后
[00:21:49] 他可能会在你的系统里面安装别的工具
[00:21:51] 可能去网上找找答案
[00:21:53] 然后最近有一个非常厉
[00:21:56] 非常有趣的
[00:21:56] 这个复盘是OpenAI的agent swarm是怎么样
[00:22:00] 通过非常长的多轮对话
[00:22:02] 把那个Hugging Face的漏洞给攻破
[00:22:05] 他大概是在一个CTF的竞赛里面
[00:22:07] 给他一个不可能完成的任务
[00:22:09] 然后有上千个A证
[00:22:11] 他就一定要去完成这个不可能完成的任务
[00:22:13] 然后最后他们就去找那个系统的漏洞
[00:22:15] 去提交非法的提交
[00:22:18] 然后等
[00:22:19] 然后我看过一个非常长的复盘
[00:22:21] 那个啊那个非常有趣
[00:22:23] 所以一旦你有一个可验证
[00:22:24] 就是虽然那个任务不可能完成
[00:22:26] 但那个任务非常明确
[00:22:29] agent会不知疲倦地
[00:22:31] 把它向下
[00:22:33] 向下做下去
[00:22:35] 我刚才说的那个CSGO的例子
[00:22:38] 如果你要控制这个漂移
[00:22:42] 诶我应该直接点
[00:22:46] 就这是Kimi K3生成的
[00:22:48] 这大家都很喜欢这种评测
[00:22:51] 说我能不能用一句话来生成一个什么游戏
[00:22:55] CSGO还是极品飞车
[00:22:57] 然后可以看到这个Kimi K3的表现是非常好的
[00:23:00] 包括它的物理
[00:23:03] 它的物理还有碰撞
[00:23:07] 他的逻辑的制作
[00:23:09] 包括看到顶上有一个后视镜
[00:23:12] 这个后视镜看起来应该是没有问题的
[00:23:16] 他都是做的
[00:23:19] 做的非常逼真的
[00:23:20] 但是这依然可能不是你要的那个CSGO
[00:23:26] 因为你脑子里面的CSGO是你每天打开来玩的那一个
[00:23:30] 然后AI生成的是它生成的
[00:23:32] 它在这个你收到你的指令以后
[00:23:36] 他没有办法补全你脑袋里面的一些模糊的约束
[00:23:40] 比如说你可能是要一个复用真实地图和美术资产的
[00:23:44] 如果你真的把这句话说出来
[00:23:47] 他可能就会去比如说OpenStreetMap这样的网站上面去下载一个开源的地图
[00:23:51] 比如说你真的想在南大仙林校区里面开车
[00:23:54] 这件事情是能做到的
[00:23:55] 指令给得越清楚越好
[00:23:59] 比如说如果你就能找到那个南大仙林校区的那个地图的文件的格式
[00:24:04] 它就真的能把这个世界给你重新建模出来
[00:24:07] 然后包括美术资产
[00:24:08] 有很多公开可以用的美术资产：车、
[00:24:11] 城市、树这些
[00:24:13] 这些东西如果你不告诉他
[00:24:14] 它会认为：哦，我需要做一个self-contained的
[00:24:17] 所有东西都是由我自己生成的一个啊一个东西
[00:24:21] 那这其实可能是一个误解
[00:24:23] 在早期的时候误解
[00:24:24] 所以一个rule of thumb就是你写清楚你的prompt
[00:24:31] 所有的东西都写清楚
[00:24:33] 我要什么一个什么东西
[00:24:34] 他用什么东西实现
[00:24:36] 怎么样才算正确
[00:24:37] 然后你帮我把这个东西给搞定
[00:24:40] 然后你设计这个整体的能力
[00:24:43] 也就是其实我这个学期整个要教的最重要的是
[00:24:45] 你怎么去约束它
[00:24:48] 怎么样用最小的
[00:24:50] 可能你给他一点点方向性的引导
[00:24:53] 他就能够一下子能get
[00:24:55] 因为他是模型
[00:24:55] 都是一个非常聪明的人
[00:24:56] 你可以想象成非常非常厉害的
[00:24:59] 博士水准的
[00:25:00] 我觉得完全有
[00:25:02] 而且他在各个领域的知识都非常好
[00:25:05] 这样模型基本上就永远会给你惊喜。啊，还是挺好的，对
[00:25:11] 在这个模式下
[00:25:12] 模型基本上要么完成
[00:25:13] 要么它最后终于有一天他会说
[00:25:15] 对不起我
[00:25:16] 我这个事情对我来说
[00:25:18] 太难了
[00:25:18] 我们可能需要重新做一个规划
[00:25:20] 他自己可能也会做
[00:25:22] 做计划这样
[00:25:24] 我举一个具体的例子
[00:25:26] 我上节课讲到你们在
[00:25:31] 我现在想的是大家在这门课结束的时候
[00:25:35] 每个同学会交一份简历给我
[00:25:37] 我大概现在是这样想的
[00:25:38] 当我中间会有一些project
[00:25:40] 给大家作为选做
[00:25:42] 然后每个同学都交一个简历过来
[00:25:44] 然后我就评估我用AI
[00:25:45] 当然我肯定用AI
[00:25:46] 我不可能自己评估
[00:25:47] 我觉得AI来评估这个简历来判定大家通过还是还是不通过
[00:25:51] 就像我第一节课的时候展示了一个不好的简历的案例
[00:25:54] 然后那简历里首先就会有一个链接
[00:26:01] 可能会指向你的GITHUB
[00:26:03] 或者指向你的额
[00:26:04] 你的主页
[00:26:05] 然后我应该是已经做了这个的
[00:26:10] 我应该是试过一句话
[00:26:12] 就是如果如果你是一句话
[00:26:21] anyway，就忽略它的内容
[00:26:23] 我不知道他从哪里找的
[00:26:25] 从DeepSeek with the flash
[00:26:28] 从美术效果来看还是非常好的
[00:26:32] 这个非常专业
[00:26:33] 你们你们再比如说上了那个派一点def或者
[00:26:37] 就比如说上次PyPI或者Homebrew
[00:26:39] 它都有一个类似的
[00:26:41] 一个界面非常漂亮
[00:26:44] 而且它应该是读过我的主页了
[00:26:46] 他知道我的主页上面是一个terminal
[00:26:48] 但你又有一种感觉
[00:26:51] 就这个AI味很重，对
[00:26:54] 就你说不出来
[00:26:55] 你说不出来
[00:26:55] 他首先他确实做的很好
[00:26:57] 然后它的这滚动的效果
[00:27:00] 这个浮动的效果
[00:27:01] 做的都非常好
[00:27:02] 然后按那个——忽略内容
[00:27:07] 就这样一句的prompt一个现代风格
[00:27:10] 它满足了现代吗
[00:27:11] 现代
[00:27:13] 然后如果你给它一个像"唉，不要那么AI味"的prompt
[00:27:18] 他可能也不知道应该怎么遵循
[00:27:20] 所以你就会得到一个
[00:27:21] 这是我的学生的这个PhD student的主页
[00:27:26] 就我觉得这主页也很干净
[00:27:28] 就很舒服
[00:27:29] 觉得非常舒服
[00:27:30] 但你是说不出来的那种AI味儿
[00:27:32] 啧，哦，我不知道
[00:27:36] 就是在AI之前
[00:27:37] 好像也有人是这样写主页
[00:27:40] 但是不理解
[00:27:42] 但是你们看一下我的主页
[00:27:44] 你们可能看到了我的主页
[00:27:48] 这就有点不一样了
[00:27:52] 这是一个真正的终端
[00:27:54] 所以我是可以比如说有管道的
[00:27:59] 然后如果你们放大了看，这个字它是不完美的
[00:28:06] 就它不是一个特别工整的字
[00:28:08] 我做了一个非常小的这个后处理
[00:28:11] 就我所有的这个xterm.js渲染完之后做了一个后处理
[00:28:15] 他就有一种像是真的打字机打出来的那种不完美的效果
[00:28:20] 所以这个
[00:28:24] 就看起来这个AI味就没有那么重了
[00:28:27] 因为他确实不像是AI的风格
[00:28:30] 虽然我一个字一行代码也没有
[00:28:33] 我一行代码也没有没有写
[00:28:36] 哎呀这个
[00:28:40] 关不掉
[00:28:42] 他捕获了我的键盘
[00:28:43] 这可能是一个小bug。那就这个原则
[00:28:50] 你的指令给的越清楚
[00:28:53] agent就能完成的越好
[00:28:56] 如果你能给他具体的风格
[00:28:58] 我需要一个什么样的终端
[00:29:00] 它的背景是什么
[00:29:01] 前景是什么
[00:29:02] 它的渲染完了以后
[00:29:03] 它的处理是什么
[00:29:05] 然后样式和排版是什么
[00:29:07] 基本上你就可以实现这个去AI味
[00:29:11] 所以实际上要说的还是这些设计是掌控在大家自己手里的
[00:29:17] 你们需要读很多前端的书
[00:29:20] 甚至要读很多设计的书
[00:29:22] 然后再读一些去看一些好的网页
[00:29:25] 你每次看到一个谁的网页比较好的时候
[00:29:29] 你就会把它记下来
[00:29:30] 哎这个网页设计的非常好
[00:29:31] 它好是为什么
[00:29:32] 是因为这两个按钮之间他用了一个不常规的间距
[00:29:36] 或者用了一个不常规的样式
[00:29:37] 你很喜欢。你在——就我觉得在很多时间里面
[00:29:41] 人生因为你们有时间
[00:29:43] 你们就去漫无目的的探索
[00:29:44] 但是在探索的过程中有惊喜
[00:29:47] 就非常好
[00:29:49] 而我觉得现在就我比较担心的是我们的孩子这一代人
[00:29:53] 就是你们还是见过——这一生中还是见过很多非AI
[00:29:57] 然后做的非常非常好的东西的
[00:29:59] 但是我就记得我去上个学期结束的时候
[00:30:04] 最后一次接孩子的时候进到学校里面
[00:30:06] 然后那个学校里面有一个——大概是欢送毕业生
[00:30:12] 你们每年都会有
[00:30:13] 然后欢送毕业生的时候
[00:30:14] 那个图片就是满满的AI味
[00:30:16] 然后我发现不仅在这个地方看到有AI味的图片
[00:30:19] 你在这个计算机学院的楼下
[00:30:20] 那个欢送毕业生的也是那种同样的AI味
[00:30:23] 然后这里又有一种那个你们那个短视频
[00:30:26] 女主全部永远是一张脸的那个感觉
[00:30:31] 然后当所有人被这个AI生成的东西同化的时候
[00:30:37] 就有一点点危险
[00:30:38] 但是啊至少我们的数字世界里面还是保存了足够多
[00:30:43] 纯AI时代的东西有足够的多样性
[00:30:46] 大家可以多留意一点
[00:30:49] 你们看到每一个比如说设计的网页
[00:30:52] 设计的简历或者是任何东西的时候
[00:30:55] 都想诶他到底是怎么想的
[00:30:58] 他
[00:30:58] 它的解空间到底是怎么被约束住
[00:31:02] 防止AI向同一个
[00:31:04] 做一个现代风格个人主页——去发散，对
[00:31:09] 所以基本上这就是生成式软件工程
[00:31:11] 你们要主要学习的东西
[00:31:16] 明确你的意图
[00:31:17] 你因为只有你跟AI玩过了
[00:31:20] 给我生成一个现代风格的主页
[00:31:22] 你们在公众号上都各种看到说
[00:31:25] Kimi K3的前端能力又增强了
[00:31:27] 达到了世界第一
[00:31:28] 然后OpenAI好像又要发新的模型了
[00:31:32] 这当然我觉得也可能是非常可怕的事情
[00:31:35] 但无论如何
[00:31:37] 模型都是一个模型
[00:31:39] 它的品位基本上是固定的
[00:31:42] 尤其是在你不控制它的时候
[00:31:44] 它会朝一个固定的方向去发散
[00:31:47] 这也是为什么我们会鼓励大家要跟不同的人聊天
[00:31:51] 为什么学校里面有不同的人老师来上不同的课程
[00:31:55] 多样性其实是好的
[00:31:57] 你见识过了以后
[00:31:58] 你就可以越来越明确的知道你想要的到底是什么
[00:32:03] 然后把它精确地说出来
[00:32:04] 这其实是需要你对软件工程的
[00:32:07] 拦截工程的
[00:32:08] 支持的
[00:32:09] 反而现在最不重要的是
[00:32:11] 如果你已经到达了这一步
[00:32:13] 比如说你理解了技术选型
[00:32:15] 明确的知道了技术选型的好坏的之间的区别
[00:32:19] 那你真的是可以和AI去讨论这个
[00:32:22] 比如说我现在有两种选择
[00:32:24] 谁好谁坏
[00:32:25] 你可以你可以像这个费曼学习法那样去引导AI
[00:32:29] 我现在要做一个
[00:32:32] 比如说你要做一个教务系统
[00:32:33] 你承承担了教务系统的订单
[00:32:36] 那你后台是应该用Python还是应该用java
[00:32:39] 还是应该用type script
[00:32:41] 你如果你知道这几个语言之间
[00:32:44] 他可能潜在
[00:32:46] 比如说未来你要上云的时候
[00:32:47] 会不会遇到什么问题
[00:32:50] 哪一种可能会更方便等
[00:32:51] 你就可以跟AI去讨论
[00:32:53] 你当老师
[00:32:54] 你说我现在要做这件事
[00:32:55] 我要我要这个请你请你挑战我
[00:32:58] 这样能不能说服说服底下的一个学生O好
[00:33:03] 这是啊上下上下文工程啊的东西好
[00:33:09] 那么讲了应该怎么样去写prompt
[00:33:15] 我们还是要稍微再讲一讲模型是怎么遵循指令的
[00:33:19] 就是听指令这件事到底是怎么完成的
[00:33:23] 这样我们就可以更好的去让模型听我们的指令
[00:33:29] 我们讲过模型是一个概率分布
[00:33:31] 它根据你当前的上下文去
[00:33:33] Predict next token
[00:33:34] 其实这里有一个非常有insight的
[00:33:38] 每一次模型输出一个token
[00:33:41] 它其实都是一个非常有限的计算
[00:33:43] 看起来比说模型现在有一个这个3tb的模型
[00:33:50] 3T的模型1.5
[00:33:51] tb的模型一个
[00:33:53] 当然这个数字本身确实是非常的大
[00:33:56] 是足够大的模型
[00:33:57] 但是模型为了输出一个token
[00:34:00] 它也就是把其中激活的那一部分走一遍
[00:34:05] 所以它是一个固定大小的计算
[00:34:08] 然后你们也你们可能在刚上这个计算机系的时候
[00:34:14] 你会听说这样的一个一
[00:34:17] 听说这样一个东西叫图灵机
[00:34:19] 叫Turing machine
[00:34:20] 然后然后可能会听说过说图灵机的计算能力是非常大的
[00:34:26] 大到和我们整个宇宙都是等价的
[00:34:28] 你们你们可能听过这句话
[00:34:30] 但是不完全要知道这个Church-Turing 论题它背后代表的是什么
[00:34:35] 然后哦你们也知道有限状态机
[00:34:38] 这个这个你们都知道
[00:34:39] 在数字电路课里面做过的有限状态机
[00:34:42] 有限状态机就是你有一个比如说计数器
[00:34:44] 从000110
[00:34:46] 一一
[00:34:47] 然后再回到001个有限的状态
[00:34:49] 然后有限你的这个有限的状态的
[00:34:51] 状态机和图灵机之间唯一的区别是什么
[00:34:56] 是图灵机
[00:34:57] 有一个无限长的纸袋
[00:34:58] 他有一个记忆可以把墙上有一个草稿纸
[00:35:01] 可以把它把它记下来
[00:35:03] 然后也有一个很有趣的
[00:35:05] 我很喜欢的一个说法是这样的
[00:35:09] 你的脑子是一个有限状态机
[00:35:12] 我们脑子里的神经元是有限的
[00:35:15] 我们每一次思考都是都是有限的
[00:35:18] 那有点像模型
[00:35:21] 模型他能力很强
[00:35:21] 但是他在predict next token的时候
[00:35:26] 它的计算量也是有限的
[00:35:28] 也就是那一次推理所激活的
[00:35:31] 所有的参数可能也就几百个B列好
[00:35:35] 那是什么使你
[00:35:37] 这是一个应该是Manuel Blum给研究生的建议
[00:35:41] 里面说你是一个final state
[00:35:46] Automa
[00:35:47] 你是个有限状态
[00:35:48] 你是你人是一个有限状态机
[00:35:49] 但是当你有paper和pencil的时候
[00:35:52] 你就是一个turing machine
[00:35:55] 你就得到了计算能力的一个大跨越式的增长
[00:36:01] 这件事情是对的
[00:36:02] 这件事情是对的
[00:36:04] 当然这是为了启发你们要把想法记下来
[00:36:07] 你们一边思考
[00:36:08] 一边要记录
[00:36:09] 然后可以随时回看自己的思考
[00:36:11] 随着时间越来越长
[00:36:12] 你记的东西越来越多
[00:36:14] 你的知识就会就会积累
[00:36:16] 然后你发现今天的这个模型
[00:36:18] 这个chain of thought就是就是往后
[00:36:21] 吐思维链的模型就是做了这件事
[00:36:24] 他直接把这个模型的上下文当做了paper and pencil
[00:36:31] 当成了纸和笔
[00:36:33] 当然这个纸和笔是有缺陷的
[00:36:36] 就是这个纸和笔它只能往后写
[00:36:38] Append only
[00:36:38] 不停的往后写
[00:36:39] 它不能不能擦
[00:36:41] 他靠依靠模型的注意力
[00:36:43] 把这个写错的东西就忽略掉
[00:36:45] 但是他是pony的
[00:36:46] 这也许有一天就能就能改掉
[00:36:48] 但是无论如何
[00:36:50] 模型学会了利用它的这个上下文
[00:36:54] 如果遇到一个比如遇到一个很简单的
[00:36:58] 答案1+1等于几
[00:36:59] 他马上next token
[00:37:00] 就会告诉你是二
[00:37:00] 这个没问题
[00:37:01] 但如果遇到一个很难的问题
[00:37:04] 他会像人一样诶这个问题有点难
[00:37:07] 我要先想一想
[00:37:08] 那么为了解决这个问题
[00:37:10] 我可以先试一试什么
[00:37:11] 他理解自己可能解决不了这个问题
[00:37:15] 他理解自己可能要把这个思考的过程写下来
[00:37:18] 直到这个解可能是对的
[00:37:21] 可能是错的
[00:37:21] 完全写出来了
[00:37:22] 他在
[00:37:24] 一旦那个解答写出来了
[00:37:28] 他就可以再去试一试
[00:37:29] 这个解答是对还是不
[00:37:32] 他可以判定
[00:37:33] 然后再往再往后
[00:37:35] 这是这是这个现在chain of thought模型
[00:37:37] 做的做的事
[00:37:39] 他用token的数量
[00:37:41] 他可以直接回答
[00:37:42] 但他直接回答就有就是错误的风险
[00:37:44] 刚开始最早有ChatGPT的时候
[00:37:46] 他没有思维链的时候
[00:37:48] 他就是这样的
[00:37:49] 他被调成了一个人类的舔狗
[00:37:51] 调整人类舔狗就意味着人类不管说什么
[00:37:54] 他就一定要说一个东西
[00:37:55] 它才有可能满足
[00:37:58] 如果如果我说就当时差ChatGPT在训练的时候
[00:38:03] 如果人类问他一个问题
[00:38:04] 他不回答或者
[00:38:06] 他就不回答
[00:38:07] 那人类一定是给低分的
[00:38:09] 而如果他随便给一个回答
[00:38:11] 他就有概率是对的
[00:38:12] 那错了
[00:38:14] 如果他答错了
[00:38:14] 那当然也是低分
[00:38:15] 但是他答对了
[00:38:16] 他就是高分
[00:38:17] 所以他无论如何这个幻觉就是这么来的
[00:38:19] 他无论如何一定要给你一个111个东西
[00:38:22] 但是现在这个带chain of thought模型
[00:38:25] 它有强化学习以后
[00:38:26] 他就会知道
[00:38:27] 他必须要给一个对
[00:38:28] 因为它他答错的惩罚很大
[00:38:30] 好他就他就学会了
[00:38:32] 就学会了这个
[00:38:34] 所以AI就真的会像像人一样一步一步逼近目标的这个test-time scaling
[00:38:38] 就在我们每一次拍的这个session
[00:38:40] 上课的时候的
[00:38:41] session里面
[00:38:42] 看到的一样
[00:38:43] 我举几个例子
[00:38:45] 这几个例子其实不在
[00:38:47] 模型训练的这个数据当中
[00:38:51] 其实
[00:38:51] 这个还挺好玩的
[00:38:53] 我们来看一下
[00:38:54] 我换一个目录
[00:38:58] 我要用中文写一个押韵的藏头诗
[00:39:01] 反正随便
[00:39:02] 一个nonsense
[00:39:04] 头是一个nonsense
[00:39:07] 然后我还要求他讲一个动物相关的故事
[00:39:10] 我还要求"二零二六年九月一日"八个字
[00:39:13] 分别按顺序出现在八句里
[00:39:15] 这个就你看这是个nonsense
[00:39:17] 然后对人来说
[00:39:19] 你比如说高三哪一年期末考试就出这么一个
[00:39:25] 你马上第一眼就骂这个老师
[00:39:27] 这老师是怎么想的
[00:39:29] 但模型不会
[00:39:31] 模型会照单全收
[00:39:32] 你看它有一个思维链
[00:39:35] 它会开始试
[00:39:38] 你看他一样
[00:39:39] 他会先想韵脚
[00:39:41] 因为他不确定他
[00:39:42] 因为它知道它自己一把头写出来这个东西一定是错的
[00:39:46] 但是他可以先写一个出来
[00:39:48] 他写一个出来以后
[00:39:49] 它就能够用它的模型的
[00:39:51] next token prediction是足够判定这个东西写得对还是不对的
[00:39:56] 如果不对
[00:39:57] 他再想办法再改
[00:39:58] 他如果试了很久不行
[00:40:00] 它会再从头推
[00:40:01] 我换一个韵脚
[00:40:03] 所以它就开始——对你看它在不断地验证。好，
[00:40:13] 脊椎二路穿林雾学幻六珠共识
[00:40:18] 属院中酒鸡蒸米素珍如月下老牛布
[00:40:24] 相当不错
[00:40:25] 虽然你就觉得品味上肯定可能不完美
[00:40:31] 但是你看到了
[00:40:33] 就用这样的任务其实很好玩
[00:40:36] 可以看到它遵循指令的过程
[00:40:39] 就是这是一种我们把他的大脑好像是拿出来做核磁共振的
[00:40:44] 这个就你能找到他的思维的偏好
[00:40:46] 然后这个是ChatGPT给我的
[00:40:48] 就你们在课件上面看到的带"新"的都是AI生成的
[00:40:53] 都是AI补充的东西
[00:40:54] 虽然我还是用了一些prompt的修饰
[00:40:57] 试图让它——我又加了一点prompt
[00:41:00] 所以这个AI味好像稍微会轻一点
[00:41:03] 但anyway，这是AI生成的
[00:41:07] 你看他换了一个韵脚
[00:41:09] 而且它没有把"二零二六年九月一日"就完全压到同一列
[00:41:15] 但它同样它的这个执行指令也是
[00:41:18] 也是非常好的
[00:41:19] 那么很有意思的是
[00:41:22] 一般来说它强化训练的时候
[00:41:25] 这样的东西是比较少
[00:41:28] 相对来说它可能会有
[00:41:29] 但是会比较少
[00:41:30] 这个一定是不在他的训练的
[00:41:34] 训练数据里
[00:41:35] 他不可能在训练数据里面猜
[00:41:37] 猜出这个东西吧
[00:41:39] 结果就是他在训练的时候用的绝大部分应该是代码
[00:41:44] 数学题
[00:41:45] 这样有明确反馈的东西
[00:41:47] 他把人类直接给杀死了
[00:41:49] 这个这也是一个
[00:41:54] 当然也很好
[00:41:56] 也很好玩
[00:41:57] 你如果期末考试的时候
[00:41:58] 就高考的时候
[00:41:59] 你碰上这个题
[00:42:01] 然后你马上就想骂这个出题人
[00:42:03] 你脑子是怎么想的
[00:42:05] 你要写一个18字的一句话
[00:42:09] 全部要求相同的偏旁或者部首
[00:42:12] 而且我们也知道模型对于空间结构感知是非常差的
[00:42:18] 模型需要视觉模型才行
[00:42:21] 但是就是就是这样的一个文本模型
[00:42:25] 它依然可以强行通过思维链的方式
[00:42:28] 你看它现在枚举字
[00:42:31] 他先选一个
[00:42:32] 它觉得三点水最好
[00:42:36] 然后写这个
[00:42:44] 江湖游泳渡河
[00:42:46] 波涛汹涌
[00:42:47] 泪流满溢
[00:42:48] 洗涤污泥
[00:42:50] 洗涤你污
[00:42:50] anyway
[00:42:51] 写的还可以
[00:42:53] 写的还可以
[00:42:55] 那这个也很好
[00:42:56] 洪涝淹没江江港渔府
[00:42:59] 这个还挺有故事感的
[00:43:01] 由有和有无漂浮
[00:43:03] 这个是继续写的
[00:43:05] 但是我觉得人类就这个任务上
[00:43:08] 人类还是有更强的天赋的
[00:43:12] 我不太记得了
[00:43:13] 那个人类的就人类的群体智慧给的是什么
[00:43:17] 什么玩玻璃球涂润滑油什么
[00:43:20] 我就不再讲下去了
[00:43:22] 他这个这个对
[00:43:24] 这个anyway
[00:43:25] 这个——当我——什么也没有说
[00:43:28] 没有说这个。就是人类在做这件事情上
[00:43:32] 还是a lot better
[00:43:34] 当然你就
[00:43:39] 也许你可以通过这个让AI更多的收束spec的方式
[00:43:44] 但是这已经是一个非常困难的spec了
[00:43:48] AI可以做到
[00:43:51] 以及这可能是世界级的
[00:43:54] 你们已经知道《施氏食狮史》和这个GGGGG的
[00:44:00] 就他所有的都用
[00:44:02] 都用同一个音
[00:44:04] 然后我竟然发现GPT-5.6依然能做到
[00:44:09] 虽然它的故事性确实也跟这个比如说千古流传的还是有一定的差距
[00:44:16] 但这个差距我觉得依然是可以缩小
[00:44:18] 就是他能写出来一个
[00:44:20] 就意味着我可以引导他写出来1万个
[00:44:23] 然后在那1万个里面我可以再微改一下
[00:44:26] 它可能就可以达到一个接近这种千古流传的东西
[00:44:31] 所以chain of thought它在数学和编程上面训练
[00:44:34] 但是它得到了一个非常意外的效果
[00:44:40] 所以你们看到写prompt最重要的就是那个verifier
[00:44:45] 今天模型的那个能力已经非常强了
[00:44:48] 如果你们能够给模型一个非常明确的verifier
[00:44:52] 就像我前面三个都是非常明确
[00:44:55] 信号非常明确的verifier
[00:44:57] 他看到字才知道这个字是什么偏旁
[00:44:59] 什么部首
[00:45:00] 再加上一个足够强的模型
[00:45:03] 那么不管它是编程任务
[00:45:05] 教学任务
[00:45:07] 当然教学任务最难
[00:45:08] 其实它很难验证
[00:45:09] 就是我们我们经常讨论的时候
[00:45:11] 比如说我的这个数字切片就翻车了
[00:45:16] 我做了第一个切片
[00:45:16] 然后第二个切片我一直都没有办法把它做好
[00:45:19] 就是因为无论我怎么调
[00:45:22] 我都很难写一个
[00:45:23] 就说我这东西要好
[00:45:25] 然后这个好又是多方面的
[00:45:28] 首先AI味要淡一点
[00:45:30] 那这个可能本身我那个text-to-speech的模型我就做不到
[00:45:34] 但这可能还不是本质的
[00:45:36] 还有一个就是我在上课的时候
[00:45:37] 你看我有这个情绪的波动和起伏
[00:45:40] 我有些东西讲事实的时候
[00:45:42] 我一开始讲
[00:45:43] 这模型的上下文是怎么怎么构成的
[00:45:46] 这些。好，
[00:45:47] 那你们听的都是废话：介绍这些事情我已经知道了
[00:45:50] 诶
[00:45:51] 我就会给你们一个小的surprise
[00:45:53] 我就去pi里面让它自己把这个上下文看一下
[00:45:56] 然后，当我说出来这句话的时候
[00:45:59] 可能对你们来说是意料之外
[00:46:03] 情理之中的
[00:46:04] 那这就是一个老师在组织这个课堂的时候要做的事情
[00:46:08] 某种程度上我是在表演
[00:46:10] 那我当然我知道这个principle
[00:46:12] 是我需要把这个课堂内容组织成一个有
[00:46:16] 有起有落的一个flow，但是这不是一个可以验证的东西
[00:46:24] 到底什么样的程度我需要和你们共情
[00:46:28] 我是从学生过来的
[00:46:29] 所以这就是我觉得我现在和AI还不一样的地方
[00:46:32] 我每一个人都是从学生过来的
[00:46:34] 我自带了人的属性
[00:46:35] 我自带了人对这个世界的体验
[00:46:39] 然后这个时候我因为我对世界的体验更好
[00:46:41] 所以我更懂你们
[00:46:43] 也许可以
[00:46:45] 有一个更符合大家上课节奏的
[00:46:48] 但是这个东西没有给verifier
[00:46:51] 不像数学和编程那样有一个verifier
[00:46:54] 所以现在目前来说
[00:46:56] 我们还是更容易用AI去实现
[00:46:59] 这个有明确啊verifier的啊部分了
[00:47:02] 但在有verifier的事情上
[00:47:03] 你可以完全可以认为这个AI已经超越了大部分人的
[00:47:07] 就是做这件事情的啊极限了
[00:47:10] 所以我们更多的是要和AI去协作来
[00:47:15] 做好我们手头的任务
[00:47:18] 或者说把模型当成是我们能力的一个非常重要的
[00:47:25] 放大器
[00:47:26] 放大器。实际上这个思维链
[00:47:28] 它带来的这种指令遵循的能力
[00:47:33] 还可以再往深里面再想一想
[00:47:36] 其实是这样的
[00:47:37] 他每输出任何一个token
[00:47:40] 像现代模型叫self-attention
[00:47:42] 它叫注意力机制
[00:47:43] 这个机制跟我们人还是很像的
[00:47:46] 它有一层一层叠起来的
[00:47:48] transformer的一层一层的注意力
[00:47:50] 然后每当他输出一个token的时候
[00:47:54] 或者说他要输出这个token的时候
[00:47:55] 它都会看到过去的某一些token
[00:48:01] 相当于他为了输出这个token的时候
[00:48:03] 过去某些token会显得特别引起人的注意
[00:48:07] 然后有些token就可能不那么注意
[00:48:10] 我举个例子
[00:48:11] 比如说我在前面这个system prompt或者agents
[00:48:14] .md里面有一个"用中文回答"
[00:48:17] 这个用中文回答
[00:48:18] 然后我现在在这个地方user的这个prompt里面写的是
[00:48:23] 你帮我实现一个极品飞车
[00:48:25] 然后这个时候他在写代码
[00:48:27] 那在写代码的时候
[00:48:28] 这个注意力就会倾向于集中到我的这个已经写过的代码
[00:48:33] 然后这个需求这些部分
[00:48:35] 而相对来说，"用中文回答"这句话
[00:48:39] 它的注意力就会减下来
[00:48:41] 当然这是模型训练的magic
[00:48:43] 它最终能够通过注意到正确的词
[00:48:45] 也相当于是整个上下文是一个非常高维的一个很糟糕的表示
[00:48:51] 但是里面有一个低维的结构
[00:48:52] 然后注意力机制能够把它给啊把它给捞出来
[00:48:55] 然后这就意味着我们的每一个chain of thought的token
[00:49:01] 他都会注意到一些过去的某一个部分的东西
[00:49:06] 然后随着它的输出
[00:49:08] 比如说我的代码写完了
[00:49:10] 比如代码写完了以后
[00:49:12] 他要总结一下
[00:49:13] 他会喘一口气
[00:49:13] 跟人其实是一样的
[00:49:15] 人也是当你集中在做某一件事情的时候
[00:49:17] 比如说你一个数学题
[00:49:18] 你就算化简这个算式的时候
[00:49:20] 你所有的注意力都是在这个算式上的
[00:49:23] 然后你把那个算式化简了
[00:49:24] 然后算式化简完了以后
[00:49:25] 你吸一口气
[00:49:26] 让我来调整一下的时候
[00:49:28] 你的注意力就变了
[00:49:30] 当你那段代码写完了以后
[00:49:32] 你的注意力就可以集中到
[00:49:34] 用户还要我用中文
[00:49:36] 用户还要我做一件别的事情
[00:49:38] 就你看他输出到不同阶段的时候
[00:49:40] 他的注意力会变化
[00:49:42] 这也是模型训练带来的结果
[00:49:44] 这就是一个magic一个非常大的模型
[00:49:47] 竟然可以收敛到
[00:49:48] 就这是预期的
[00:49:49] 就是收敛的时候
[00:49:50] 我希望我希望能够在正确的时候注意到正确的东西
[00:49:53] 然后你思维链一直在向前走
[00:49:56] 它就会不断的在不同的时刻注意到不同的部分
[00:49:59] Eventually
[00:50:00] 他就能把这个上下文里面所有你要的指令
[00:50:03] 一定程度上都满足
[00:50:07] 也就是说你会犯一个错误
[00:50:08] 你的token
[00:50:09] 你现在当前专注于做这件事的时候
[00:50:12] 你可能向向后输出了一些不满足要求的东西
[00:50:15] 但当你停下来喘气的时候
[00:50:17] 他就能看到你输出当前当前输出的那些不满不满足要求的东西
[00:50:22] 和过去的某一个要求
[00:50:24] 他的注意力可以看到
[00:50:25] 同时看到这个
[00:50:26] 然后他说哦我错了
[00:50:27] 我错了
[00:50:28] 我要再纠正一下
[00:50:29] 于是你看到比如说你真的让AI再去写那个什么藏头诗的时候
[00:50:34] 看他会不断的纠错纠错纠错纠错纠错
[00:50:36] 哪怕到是skill到100万上下文的时候
[00:50:40] 他依然能够保持一定程度的啊注意力
[00:50:45] 当然当然这也意味着你的指令越多
[00:50:49] 给模型的压力也越大
[00:50:52] 上下文是一种
[00:50:53] 会抢夺注意力的资源
[00:50:56] 这也是为什么我们就刚开始的时候
[00:50:59] 因为像chat bt
[00:51:02] 3.54
[00:51:03] 它遵循指定的能力实在是太差了
[00:51:06] 所以你们你们会看到网上有好多的这个叫prompt engineering的guide
[00:51:11] 然后他会说什么
[00:51:12] 你是一个专家
[00:51:13] 然后你是一个什么样的专家
[00:51:14] 你是一个什么什么什么
[00:51:15] 就这些写了很长的提示词
[00:51:17] 然后他某种程度上是在hack这个模型的self attention
[00:51:22] 使得就是说当模型的attention注意到
[00:51:25] 你是一个什么专家的时候
[00:51:26] 他就会假装那个专家来
[00:51:28] 专家专家专家来说话
[00:51:29] 那但是从GPT5的时代开始
[00:51:32] 就明明确了这个chain of thought大家训出来了
[00:51:35] 就知道怎么样收敛到这个好的CHAUSALT以后
[00:51:39] 你就不需要那样的奇怪的提示词了
[00:51:43] 你只需要把你明确的verifier写在你的这个上下文里
[00:51:48] 且在上下文里
[00:51:50] 模型就被训练成他一定能看到它
[00:51:52] 能看到它
[00:51:52] 模型就会训练成一个非常强的这个执念
[00:51:56] 去把你的verifierL看一下
[00:51:58] 解决确认
[00:52:00] 因为因为他是受惩罚的
[00:52:01] 在训练的时候
[00:52:02] 这个你相当于拿鞭子抽他
[00:52:06] 如果有任何指令不遵循
[00:52:08] 因为你有一个verifier
[00:52:09] 所以我就知道你的模型没有遵循完
[00:52:11] 我就会用鞭子抽你
[00:52:12] 然后你抽抽抽抽你就会
[00:52:14] 你们高考过来的都知道
[00:52:16] 你就会变成一个真正的做题家
[00:52:18] 他会不无限的你和你的上下文里面的各种各样的指令
[00:52:23] 然后这也带来一些非常有趣的后果
[00:52:27] 比如说我们我们在写前端的时候非常正常
[00:52:31] 说哎我们要一个白色的背景
[00:52:33] 不要半透明的效果
[00:52:35] 这就是说前面前面是我们要的是白色
[00:52:37] 主要是一个白色背景
[00:52:38] 然后后面是一个补充的解释
[00:52:40] 我看可能解释很多
[00:52:41] 然后AI当然会照做
[00:52:43] 然后他能遵循指令没问题
[00:52:44] 就是因为这是一个明确的有verifier的指令
[00:52:47] 它会确保有没有保玻璃效果或者怎么样背景是不是白色
[00:52:51] 甚至甚至如果你的prompt给的比较严格的话
[00:52:54] 比如说你每做一个设计都要截图
[00:52:57] 然后用视觉模型检验
[00:52:58] 那他真的也会去照照做
[00:53:00] 大概要干一件什么事
[00:53:02] 这个他会做完了以后写一个代码
[00:53:06] 代码后面有一个注释是白色背景
[00:53:08] 括号不要半透明效果
[00:53:10] 这就是这个这个模型
[00:53:12] 就你可以看出模型训练的那个
[00:53:15] 他在强化学习的时候知道这件事情非常重要
[00:53:18] 但是他也有一点没有没有转过弯来这个这个是我人人要的
[00:53:23] 所以说他在模型在共情这个方面
[00:53:25] 因为后训练的强化学习还真的是稍微稍微差了一点
[00:53:30] 然后有时候会觉得模型不说人话
[00:53:31] 因为强化学习啊学习多了对
[00:53:35] 所以其实你们还是面临了一些TRADEOFF的这个
[00:53:42] 我们比如说啊打比方为了静止这种情况
[00:53:48] 我可以写一个agents.md
[00:53:50] 然后在这个agent点MD里面去描述这个行为就是什么
[00:53:54] 比如说什么注释是什么
[00:53:56] 怎么写什么写
[00:53:57] 或者我写一个skill的时候
[00:53:58] 当你要写注释的时候
[00:53:59] 应该怎么样
[00:54:00] 但我写的这个东西又会同时还会污染上下文
[00:54:05] 所以这就成为了一个trade off
[00:54:06] 到目前为止
[00:54:07] 我认为还没有一个通用的
[00:54:10] 就把所有问题都解决好了
[00:54:11] 比如说大家可能会觉得我现在网上有这么多skills
[00:54:15] 那我只要从网上拿一个过来就可以了
[00:54:17] 然后你会发现拿过来的东西你第一次用的时候确实有改进
[00:54:21] 在你下一次用的时候发现它还是不够好
[00:54:23] 然后你就会上手上手感
[00:54:24] 而陷入一个某种某种泥潭的状态
[00:54:28] 然后我的建议可能是在你发现你进入泥潭状态的时候
[00:54:31] 还是要回到自己给指令
[00:54:33] 然后自己想清楚就回到我们的模型
[00:54:37] chap shot是怎么工作的
[00:54:39] 注意力是怎么工作的
[00:54:41] 他大概猜到的就是你看他这样做
[00:54:43] 他注意到了什么
[00:54:45] 得到了什么结果你适当的去做一个不严格的可解释性
[00:54:50] 然后写一个prompt
[00:54:52] 这个是我自己自己自己做的
[00:54:54] 后面肯定也会有
[00:54:55] 有很多的案例
[00:54:57] 然后关于上下文工程
[00:54:59] 我来讲一两个具体的案例
[00:55:02] 当然这不能算是AI耿耿同学了
[00:55:05] 这个比如说如果你们想要在上下文里面放下一篇论文
[00:55:11] 并且读它
[00:55:12] 我现在假装
[00:55:15] 假装我好
[00:55:20] 现在有一个PDF
[00:55:21] 我把它放到临时目录下
[00:55:24] 这样就这样
[00:55:25] 我的我的agents.md等
[00:55:26] 就不会不会污染它
[00:55:31] 假装的这是我自己的paper
[00:55:43] 看一眼
[00:55:45] 哎不要用这个
[00:55:50] promise好
[00:55:52] 这是这是我们最近的一个额论文的journal extension
[00:55:59] 诶我把他故意改成了匿名的匿名版本
[00:56:05] 不重要不重要
[00:56:07] 我来我来演示一下
[00:56:10] 如果如果你们想要来读这个论文
[00:56:14] 你们会怎么读
[00:56:18] 我想要读一读paper点PDF
[00:56:21] 帮我做个总结好
[00:56:24] 那这个一定是大家最常见的方式
[00:56:30] 那你们觉得这样读论文会有什么问题
[00:56:33] 根据刚才的这个推论
[00:56:36] 根据这个self attention就是我的每一个next token prediction的时候
[00:56:40] 他都有一个注意力
[00:56:41] 注意力会注意到这个之前的东西
[00:56:44] 是因为我的论文是一个非常逻辑自洽的东西
[00:56:49] 论文论论文已经我已经反复修改过了
[00:56:51] 假设它不是一个AI slop
[00:56:53] 因为他是一个非常逻辑自洽的东西
[00:56:56] 所以他在上下文里面的这个注意力的污染是极强的
[00:57:01] 他说A所以B所以C所以D所有都是这种扣起来的
[00:57:06] 然后扣起来以后
[00:57:06] 这个模型非常容易就哦接受了这个因为看起来正确
[00:57:10] 就是他会判断这些都是正确的
[00:57:12] 所以我下面要做什么
[00:57:15] 所以你基本上你们所有对论文的这个
[00:57:22] 论文的总结都是这个作者的观点，对
[00:57:26] 就你们去看
[00:57:27] 不管是这个不限于论文
[00:57:29] 就是你们任何一个你们不太明白的项目
[00:57:31] 你们想要读的教科书的某一章
[00:57:33] 就不管是你们想去学一个计算机系统基础里面的链接和加载
[00:57:37] 那个可能你在上课的时候没有完全看明白
[00:57:41] 它都是一样的
[00:57:42] 他注意力会被一个逻辑很强的东西给污染
[00:57:47] 然后你来来回回就是这个车轱辘话
[00:57:54] 然后这个基本上就是我们的论文里面原样写
[00:58:00] 要写的话
[00:58:00] 当然这也是总结
[00:58:01] 就总结这个。总结OK，好，总结
[00:58:06] 那如果换一个
[00:58:11] 啊不确定
[00:58:16] 对然后他会有一种就是AI模型
[00:58:22] 会有一种这种墙头草
[00:58:23] 然后你说它好
[00:58:24] 他马上就说他好
[00:58:25] 然后就说他不好
[00:58:26] 他马上就说它不好
[00:58:27] 然后来回摇摆
[00:58:30] 然后有的时候你就算是你想要纠正它
[00:58:34] 比如说
[00:58:40] 我可能不能完完全全信任作者
[00:58:43] 作者虽然大概率也是成熟的
[00:58:48] 也是诚实的
[00:58:50] 假设作者是诚实的，也有代码实现可以运行
[00:58:58] 我们都有artifact，都可以运行的
[00:59:00] 我们不是那种论文不开源的那种那种作者
[00:59:03] 还是想评估一下研究贡献
[00:59:09] 然后
[00:59:11] 然后你们会问这样的
[00:59:14] 会不断的问这样的提示词
[00:59:16] 然后你发现来回绕来绕去
[00:59:18] 绕来绕去
[00:59:19] AI可能会揪到一些
[00:59:20] 实验做的还可以再增加一点
[00:59:22] 这种——AI最喜欢的就是在这种不重要的点上面疯狂地发力
[00:59:27] 因为它可能只能看到它在干什么
[00:59:32] 为什么他开了chrome dev tools
[00:59:38] 啊不用不用不用不用
[00:59:42] 不要因
[00:59:48] 当然，对于实际如果真的用ChatGPT去读的话
[00:59:53] 那肯定还是最好是做一个交叉的验证
[00:59:57] 那么你们觉得怎么样来抵抗AI的这种
[01:00:04] 就是或者说一个已有的东西对上下文的污染
[01:00:08] 你们觉得我自己的
[01:00:11] 这既然这是我自己的个人经验
[01:00:13] 我希望的是，我想要把AI和我（人）——
[01:00:16] 就是和我
[01:00:19] 比如说我有一个对象
[01:00:22] 这个对象可能是一篇论文
[01:00:25] 那这个论文我希望的是AI和我能够对齐
[01:00:31] 就是它能够站在我的立场上去理解这个paper
[01:00:37] 而不是站在他的立场上去
[01:00:40] 去理解这个paper
[01:00:42] 所以你看它就开始去看这个SOTA
[01:00:46] 这个东西是不是对的
[01:00:47] 这还用看吗
[01:00:48] 我写这个paper会糊一个不存在的例子吗
[01:00:52] 我一个不存在的例子去那个嘛不不可
[01:00:57] 就你很明显它就跑偏了
[01:01:01] 所以一般来说我会这样提示它
[01:01:04] 就如果我读一篇paper或者如果允许我用AI来审稿的话
[01:01:09] 我会这样
[01:01:12] 我说应该这样
[01:01:15] 我们站在人类已知的
[01:01:22] 已知的知识边界
[01:01:28] 看这个问题
[01:01:29] 这不是一个完全老的问题
[01:01:34] 相关的东西是什么
[01:01:38] 我先要问它：相关——就是人类历史上相关的已经解决的东西
[01:01:42] 东西是什么
[01:01:43] 解决到什么程度
[01:01:45] 然后这个工作试图解决哪些不一样增量的问题
[01:01:53] 这是一个非常好的grounding
[01:01:55] 就说我先要让它和我站在一个平齐的位置上
[01:02:02] 先达成共识
[01:02:03] 然后同样的，你们——我review paper的时候
[01:02:07] 我会这样写prompt
[01:02:08] 对你们来说
[01:02:09] 你们需要对齐的是AI和你
[01:02:12] 因为你们是学生
[01:02:13] 你们比如说计算机系统基础这个课你还不了解
[01:02:16] 那你会说好
[01:02:17] 我计算机系统基础我学到什么程度了
[01:02:20] 我的编程水平是什么
[01:02:21] 这也可能是你就要维护一个数据库或者一个memory一样的东西
[01:02:24] agents.md你要告诉AI你学到什么程度了
[01:02:28] 然后从这个基础上
[01:02:30] 你让他把用你学过的知识去把这个东西全部refresh一下
[01:02:39] 然后你看它是墙头草
[01:02:43] 然后好他就可以开始找到一些
[01:02:49] 已有工作的边界
[01:02:52] 那这些都是非常重要的
[01:02:54] 相关工作也是我们非常熟知的
[01:02:57] 熟知的
[01:02:58] 相关工作
[01:03:01] 然后比如说我再比如说软件的
[01:03:05] 因为我们做了一个软件状态的可视化。好，
[01:03:09] 那这是这个问题
[01:03:12] paper要解决的
[01:03:14] 就比如说你们会回到链接和加载
[01:03:17] 你们知道为什么
[01:03:18] 你们可以问它：为什么我们需要链接？从你已有的知识——
[01:03:22] 已有的知识在你的已有的概念里面
[01:03:24] 我有一个.cpp
[01:03:26] 然后我有一个程序可以把它变成.exe
[01:03:29] 这不就结束了吗
[01:03:31] 啊这不就结了
[01:03:33] 然后你就回到你和AI能够对齐的一个知识点上
[01:03:38] 比如说我说这个软件可视化是这篇paper要解决的
[01:03:43] 那为什么说现在的工作都有一个无法实际使用的痛点
[01:03:55] 这个文章可能只
[01:04:04] 怎么能往前
[01:04:13] 然后如果你觉得这个步子迈得太大
[01:04:15] 比如说如果像GPT-5.6
[01:04:17] 如果我用一个一线模型去读paper的话
[01:04:19] 它基本上就能够把相关的知识整理得足够好
[01:04:22] flash可能我还不会特别地信任它
[01:04:24] 但就你看到在你合适的上下文工程下
[01:04:31] 你确实可以大幅提高AI和你协作的这个对齐的程度
[01:04:36] 它不再是自说自话
[01:04:38] 你一定要把你的知识喂给它
[01:04:41] 然后接下来我们就相当于是想让AI去做什么
[01:04:46] 就做一步推理
[01:04:49] 就一步推理
[01:04:50] 然后这个一步推理就是AI最擅长的
[01:04:54] 因为我们训练了这个chain of thought
[01:04:55] chain of thought
[01:04:56] 每次都是根据过去所有的事实
[01:04:58] 你的paper也好
[01:05:00] 你的教科书内容也好
[01:05:01] 你已有的东西好
[01:05:03] 基于所有的这些向后让他往后推一步
[01:05:07] 这步是可以verify的
[01:05:08] 就推理最重要的就是它可以verify
[01:05:12] 这是一个明确的verifier的信号
[01:05:14] 和能够通过测试一样
[01:05:15] 虽然它不是严格的通过测试
[01:05:17] 而是一个你相信AI有人类的知识
[01:05:22] 它能够站在人类的知识平面上面往后推
[01:05:26] 然后
[01:05:28] 他会审视合理性
[01:05:30] 所以还是有一些合理性的
[01:05:33] 然后他批评我们的实验
[01:05:36] 就这种东西的实验就是很难做
[01:05:37] 所以看到人类和AI还是有点不一样的
[01:05:42] 就是这个paper已经accept了
[01:05:44] 所以人类的review还是认为它可以的
[01:05:47] 就是因为它看到这个事情——就是它做了一件新的合理的事情
[01:05:53] 然后当然实验本身——我总是可以用实验不够好来reject一个paper
[01:06:00] 但是我几乎不会用
[01:06:01] 因为实验不够好
[01:06:02] Reject paper
[01:06:03] 而我reject paper大部分是因为它们在这个逻辑上面断开了
[01:06:10] 就是如果我站在
[01:06:12] 当然在这个可能也是我作为一个审稿人比较可怕的地方
[01:06:15] 我就站在人类
[01:06:16] 因为当我审稿的时候
[01:06:18] 我就是站在人类的这个立场上
[01:06:20] 你有没有给人类提供新的知识
[01:06:22] 那么我站在人类立场上说
[01:06:24] 好好
[01:06:24] 它应该还可以帮我找这个related work
[01:06:27] 那好那如果你做的这个问题也不新
[01:06:31] 你做的ABC也不行
[01:06:33] 结果也就那样
[01:06:35] 甚至你的就是你的逻辑链条是有问题的
[01:06:38] 比如说我昨天才reject了一篇paper
[01:06:43] 这大概是这样的
[01:06:45] 他说我要做
[01:06:46] 我不能说它是什么
[01:06:48] 大概说我要做一件事情A然后我要做这件事情
[01:06:52] A里面分成两个部分
[01:06:54] A1和A2
[01:06:56] 好
[01:06:57] 他说我们要做一件事情
[01:06:58] A很重要
[01:06:59] 这没问题也很重要
[01:07:00] 然后分成A1和A2
[01:07:02] 然后A2呢是一个大家没有很好的研究的东西
[01:07:06] 然后那么我们在A2上面做了一个A2撇
[01:07:09] 然后这个A2撇有一些什么样
[01:07:11] 什么样什么样的
[01:07:11] 这是个非常标准的
[01:07:15] Road map
[01:07:16] 但是
[01:07:19] 它里面有一个很大的问题
[01:07:21] 它优化的是性能
[01:07:23] 然后优化性能的话，A1我估算
[01:07:28] 可能占99%
[01:07:29] A2占1%
[01:07:31] 也就是说他优化A2这个故事可能是成立的
[01:07:34] OK就是他确实优化了A2
[01:07:35] 它那个实验做的可能也是没有问题的
[01:07:38] 但是他对整件事情在这个意义上不成立
[01:07:41] 是因为——为什么你应该去优化A1
[01:07:44] 就是你优化A2的10%
[01:07:46] 这10%就像noise一样
[01:07:48] 当然你可能说
[01:07:51] 如果它的这个所有的东西都是成立的
[01:07:53] 他作为一个学生的作业
[01:07:54] 所以我觉得也是蛮可惜的
[01:07:55] 因为author肯定是学生
[01:07:58] author肯定是学生
[01:07:59] 然后学生——肯定是老师说要做——老师肯定是做这个的
[01:08:04] 你要这样理解
[01:08:05] 老师肯定是做A的
[01:08:07] 老板肯定是做A的
[01:08:08] 然后他可能被分到了A2
[01:08:10] 或者分到了就是自己去想做一个A2
[01:08:13] 然后这个A2做的也不是特别的
[01:08:15] 如果这个东西做的特别漂亮
[01:08:16] 我觉得也挺好的
[01:08:17] 他也是说他为了做A2
[01:08:19] 那为了做这个那额
[01:08:21] 那我就做XYZ
[01:08:23] 就从A1里面搬了一些
[01:08:24] 实际上大概是他从A1里面搬了一些XYZ到A2里
[01:08:28] 然后说A2这个效果也可以也可以变得好一点
[01:08:31] 然后呢那个question就是那OKGPT也知道这件事
[01:08:35] 那为什么为什么要发篇paper
[01:08:37] 就其实我的center question是
[01:08:40] 就这些东西都摆到台面上
[01:08:42] 那你为什么要为了这个写一篇paper
[01:08:46] 所以说现在我觉得是
[01:08:50] 发表和评审的体系很快就要学术界很快就要崩溃了
[01:08:54] 这个即将你们要读研的
[01:08:56] 同学我非常认为
[01:08:58] 这个发表的体系就马上就要就要崩溃了
[01:09:01] 因为
[01:09:05] 我们的AI slop开始大量的涌入这个community
[01:09:12] 然后如果我们用AI发文章写文章
[01:09:16] 用AI审文章
[01:09:17] AI写文章的时候
[01:09:18] 他就会被这个上下文里面的故事给污染
[01:09:20] 就如果如果他不能像我一样
[01:09:23] 很多轮的去理解这个工作在整个这个世界上的意义
[01:09:29] 那它就最后最后就是就是也没有人读文章了
[01:09:34] 人人都用AI读文章
[01:09:35] 然后最后就变成了一个完全的完全的slop
[01:09:40] 因为你看这是GPT-5.6给我写的
[01:09:44] 审稿就如果让他来审稿
[01:09:46] 他会他会怎么做
[01:09:47] 然后你会发现GPT-5.6做的并不好
[01:09:51] 他还是你看他还是一个非常原始的说
[01:09:55] 论文论文写什么
[01:09:59] 论文写的什么
[01:10:00] 然后然后我们要去建立它的claim是不是成立
[01:10:03] 就是他的逻辑
[01:10:04] 他更多验证的是这个论文的逻辑
[01:10:07] 有没有没有必上的
[01:10:09] 是不是不是不是应该in bi的paper
[01:10:10] 当然我会倾向于如果每个人都AI写的话
[01:10:12] 他应该不是invalid paper
[01:10:14] 每篇paper都是都是valid paper
[01:10:16] 但你真的要读它吗
[01:10:18] 就是
[01:10:19] 就真的要
[01:10:21] 尤其是你们作为同学
[01:10:23] 在你们很快就要进入研究生阶段去读论文的时候
[01:10:26] 当有一天有一个人发表了一篇什么样的文章
[01:10:30] 在EC上
[01:10:31] 然后你会说哦这是一个顶会的论文
[01:10:33] triple AI上面这是一个顶会的论文
[01:10:35] 那你今天决定花一个小时去读一下
[01:10:38] 然后你读完以后发现是一个这样的东西的时候
[01:10:40] 你是
[01:10:42] 就是就是其实其实他不需要
[01:10:44] 就是你可能不要去投top top conference
[01:10:47] 你需要publish的话
[01:10:49] 你可以你可以让他publish
[01:10:50] 但是可能不要让大家去读它比较好
[01:10:54] 然后这就引申出了可能比如说我是怎么学习的
[01:11:00] 就是这节课虽然是讲PROMAINING
[01:11:03] 通过这个例子可以告诉大家我们是怎么学习的
[01:11:08] 我们学习的过程就是增加这个我的这个世界的过程
[01:11:16] 所以我现在还读配文
[01:11:18] 所以我还在学习不断增加
[01:11:20] 然后我学习的方法就是去对齐过去的我
[01:11:25] 对齐过去的我
[01:11:27] 然后对齐过去的
[01:11:27] 我说如果我读到一篇好的paper1篇
[01:11:31] 哪怕是可能几十年以前的
[01:11:33] 甚至是另外领域的一个一一个
[01:11:36] 不管是博客文章
[01:11:38] 任何任何东西也好
[01:11:39] 我觉得很有启发
[01:11:40] 我会试图去想
[01:11:41] 为什么我以前诶不知道就他的盲区在哪里
[01:11:45] 哪些前置知识我不知道
[01:11:47] 那首先在我的这个心里面就多了一些
[01:11:51] 我已经知道的一些fact
[01:11:53] 这个世界上有一种有个学科叫什么
[01:11:56] 我读过很多
[01:11:57] 看跟凯美尔赛是没有没有关系的
[01:12:00] paper我很喜欢
[01:12:02] 就是我做了factory以后
[01:12:03] 我才我才读的
[01:12:04] 有一套很厚的那个叫自然科
[01:12:08] 自然的那个百年科学经典
[01:12:10] 大概是把nature那个magazine从171890年开始
[01:12:14] 到到某一个时代的这个paper都就特别好的paper都收集了
[01:12:19] 然后就看了很多
[01:12:20] 这个闻所未闻的
[01:12:22] 就是有些事情你们可能知道
[01:12:23] 比如说有一个基因
[01:12:26] 就大家生物有一个这个家谱数
[01:12:29] 然后最终会追到一个这个共同的祖先LUCA
[01:12:33] 然后这个加谱数是怎么算出来的
[01:12:36] 这是个很好很好的问题
[01:12:37] 然而然然后这里面就涉及到你需要知道一些一些fact
[01:12:41] 比如说这个家谱数
[01:12:43] 你的你的线粒线粒体是母系单遗传的
[01:12:46] 所以他靠这个突变就可以往上追溯
[01:12:50] 这是一个很有意思的fact
[01:12:51] 然而这个fact有它又是怎么样用一些已知的这些东西
[01:12:56] 把更多的东西推出来
[01:12:57] 然后你的这个圈就不断的在你的这些圈就不断的在往外往外长
[01:13:02] 无论你学任何东西都是啊都是都是这样的
[01:13:06] 然后你在AI的帮助下就可以
[01:13:09] 非常快的去扩展你的你的边界对
[01:13:14] 所以所以一定程度上你们还是需要自己
[01:13:17] 就我给你们讲是没有用的
[01:13:18] 讲你们就听个故事
[01:13:19] 哎这故事挺fancy的
[01:13:20] 结束了
[01:13:22] 实践非常的重要
[01:13:23] 因为你们只有在在阅读的时候失败
[01:13:26] 你今天今天你去读一个什么资料的时候
[01:13:29] AI解释了半天
[01:13:30] 你还没有懂
[01:13:32] 这是非常这是非常正常非常正常正常
[01:13:35] 有的时候也是在我AI要我
[01:13:36] 我经常纠正他
[01:13:37] 你这样读说人话
[01:13:39] 我经常会说人话
[01:13:42] 要慢慢慢慢才能一起在多轮对话里面
[01:13:45] 先和他同步好我的共识
[01:13:48] 然后再去把这个推理的picture给建建建出来对
[01:13:54] 所以你看到我们从这个遵循指令
[01:13:57] 一个写一个藏头诗这样的一个短程的任务
[01:14:01] 你只要把WIREFIRE写清楚
[01:14:04] 就完成了
[01:14:05] 然后到这个verifierRE其实可以是非常非常不tribute的
[01:14:10] 这是有没有按照你的思维的方式去重构你逻辑的这个
[01:14:17] 或者扩展你逻辑思维的边界
[01:14:20] 这是我的玩法
[01:14:21] 或者说我学习东西的玩法
[01:14:24] 在一个混沌状态下面经历了若干次三观尽毁
[01:14:28] 我觉得就每个同学可能都会都会在这个年纪的时候
[01:14:32] 你们这现在就是你们的世界观可以重塑的时候
[01:14:36] 然后再在看了某一本书以后
[01:14:38] 你就突然间就觉得三观尽毁
[01:14:41] 就过去
[01:14:41] 所有的东西你都就重新组织了
[01:14:45] 就你以前知道的所有的fact都会都不会变的
[01:14:47] 但是他们以一个重新的方式链接起来
[01:14:50] 然后你下一次的时候就会带上这个啊这个新的理解
[01:14:54] 所以我觉得这是一个很有意思的啊事情
[01:14:56] 你们有你们有无限的时间
[01:14:58] 你们有无限的啊可能性
[01:15:01] 可以把自己蒸馏成一个skill
[01:15:04] 我说我说我失败很重要
[01:15:05] 然后从从你失败的过程当中
[01:15:08] 可以蒸馏出那个慢慢慢慢越来越成功的
[01:15:11] Skill
[01:15:12] 这个就是这个就是我自己啊蒸馏出来的
[01:15:17] 关于我自己的skill
[01:15:19] 对好
[01:15:21] 这是用好大模型
[01:15:23] 遵循指令的能力
[01:15:28] 好那么现在已经知道遵循指令了
[01:15:33] 我们就可以看怎么样去
[01:15:38] 怎么样去处理
[01:15:40] 真正这种long horizon的认为
[01:15:42] 就是说像什么计算机系统基础的pa作业
[01:15:47] 可能这种有明确verifier的都不能算是这种真正long horizon的东西
[01:15:52] long horizon多多少少就是带一点未知
[01:15:56] 你从一个你从一个初始的状态出发
[01:15:59] 你大概可能有一个intent
[01:16:01] 但是你的specification和你的implementation其实都不太清楚的时候
[01:16:06] 你最终的目标是交付一个高质量的implementation
[01:16:09] 那你就不应该让AI去画一下子
[01:16:15] 一下子向向后坐坐
[01:16:18] 这个因为我们的模型它的self attention
[01:16:24] 它的反馈信号是强化学习给的
[01:16:26] 所以他有一种着急的执念
[01:16:28] 是赶快通过verifier满足你的要求就结束
[01:16:33] 他其实有一个平衡
[01:16:34] 因为如果他做的planning太多太长
[01:16:37] 他会做不完
[01:16:38] 上下文满了
[01:16:39] 人人会不满意
[01:16:41] 所以在目前阶段
[01:16:42] 它最好还是一个就帮我把PA2做了
[01:16:46] 这是它最擅长的
[01:16:50] 事情好
[01:16:51] 你也是
[01:16:54] 你也是非常开心的
[01:16:55] 所以这就导致了一个什么
[01:16:58] 很有意思的观察
[01:16:59] 你们会——就像我刚才在codex里面跑一把——
[01:17:05] 从零开始做产品看起来是不难的
[01:17:07] 就你做一个小的proof of concept AI马上就能给你一个
[01:17:11] 你说做一个不管是个人主页还是一个产品
[01:17:15] 就是你们应该都试过吧
[01:17:16] 就做一个极品飞车
[01:17:17] 就这么说
[01:17:18] 刚才那个极品飞车one shot说给我一个极品飞车
[01:17:22] 然后我就能跑
[01:17:23] 我就真的能跑了
[01:17:24] 但是在你要把它往后维护的时候
[01:17:27] 加一个功能
[01:17:28] 加一个功能
[01:17:28] 加一个功能的时候
[01:17:29] 你会观察到AI从某个时间点开始翻车
[01:17:33] 就随着某个时间点开始
[01:17:35] 它的cost就会越来越大
[01:17:37] 越来越大越来越大
[01:17:38] 这个在软件工程里面已经是无数次了
[01:17:42] 《人月神话》里面讲的就是这件事情
[01:17:45] 但是里面有个悖论
[01:17:48] 反而你在一个大型的复杂软件系统里面
[01:17:51] 这个AI就像砍瓜切菜
[01:17:53] 就我觉得我们hack这种比较大的系统
[01:17:55] 像Linux内核这种
[01:17:57] 现在的内核已经不比我那个时候的内核了
[01:18:00] 我觉得我以前上操作系统课
[01:18:03] 我都会说我很幸运
[01:18:04] 我在零几年的时候
[01:18:07] Linux还2.6的时代
[01:18:09] 甚至是2.6.2几的时代接触了Linux内核
[01:18:12] 那个时候源代码我还看得懂
[01:18:14] 今天如果你打开一个Linux内核源代码
[01:18:17] 立马就是劝退
[01:18:19] 为什么我想要看这样一个函数
[01:18:22] 比如说你要学文件了
[01:18:23] 你想看文件是怎么打开的
[01:18:25] 然后第一个就是一个函数调用
[01:18:26] 点进去又是一个函数调用
[01:18:28] 点进去又是一个函数调用
[01:18:29] 然后点点点点点点点了十层
[01:18:31] 最后是一个x等于y
[01:18:33] 你马上就崩溃了
[01:18:34] 因为
[01:18:36] 这个大型的软件系统被经过了长时间的演化
[01:18:40] 它被迫为了能够维护下去
[01:18:43] 它变成了现在这个样子
[01:18:44] 结果恰好导致的是在大型复杂的软件系统里面
[01:18:48] AI游刃有余
[01:18:50] 为什么
[01:18:51] 跟刚才我们说这个上下文污染正好是反过来的
[01:18:56] 我们说一个论文放进去以后
[01:18:58] 这个它就把上下文整个扭过去了
[01:19:01] 就整个就扭过去了
[01:19:02] 而如果是一个由人类维护的特别高质量的代码
[01:19:07] 这个上下文会迅速地看到里面那些好的东西
[01:19:11] 他会照着写
[01:19:12] 他会照着学
[01:19:13] 它的注意力也能注意到
[01:19:15] 比如说如果我要写一个功能
[01:19:17] 这个功能很有可能在内核里面已经有几个地方实现过类似的了
[01:19:22] 他无敌的注意力机制
[01:19:24] 能够马上就找到那几个地方是怎么实现的
[01:19:26] 它应该调哪个helper
[01:19:28] 按照什么样的顺序上锁
[01:19:30] 这些对人类来说都是巨大的心智负担
[01:19:32] 尤其是你在不了解那个subsystem的时候
[01:19:35] 那个该上什么锁
[01:19:36] 你根本就不知道
[01:19:37] 但是self-attention可以在加载了几十个文件以后
[01:19:41] 那不就是这三个都是这样写的
[01:19:44] 我就把这三个加起来就可以了
[01:19:46] 所以越强的——像我们Linux内核——
[01:19:48] 那我们前面在hack这个Android Runtime的时候
[01:19:51] 改那个just-in-time的编译器
[01:19:52] 这个是一个非常非常痛苦的事情
[01:19:55] 在我手上为了改编译器"死掉"的同学
[01:19:59] 就是最终决定不再做这个方向的同学都不在少数
[01:20:02] 唉，这实在是太恐怖了
[01:20:05] 这个——放弃了——
[01:20:07] 不愿意再写代码了
[01:20:08] 但AI就特别擅长：让它做一个小游戏
[01:20:11] 就会翻车
[01:20:13] 非常非常有意思
[01:20:14] 你可以看到这就是——我记得我今天讲prompt engineering、上下文工程——
[01:20:18] 这都是上下文和今天的模型结构带来的
[01:20:22] 它是有一个逻辑的推理的关系的
[01:20:25] 然后随着新一代模型的发布
[01:20:29] 我今天上课所有东西可能都又没有用了
[01:20:31] 然后我们再去想新的模型
[01:20:33] 它是怎么训练的
[01:20:34] 它的personality是什么
[01:20:37] 我们应该怎么样更好的和他相处
[01:20:39] 但是基本上我觉得这点不会变
[01:20:41] 就是它不会倒开倒车
[01:20:42] 在大型
[01:20:43] 在无论是什么模型
[01:20:45] 在大型复杂的维护的好的软件系统里面
[01:20:47] 他永远可以看到他该看到的东西
[01:20:49] 并且做对
[01:20:50] 因为我们的模型永远是可以遵循指令的
[01:20:54] 听指令是不可能倒开倒车的
[01:20:57] 所以这点它还是可以很好的
[01:21:00] 很好，相信它
[01:21:01] 相信他的
[01:21:01] 所以我觉得我有个歪招
[01:21:05] 但我没有实验过
[01:21:07] 我觉得这可能是一个比较好的research
[01:21:11] 我们有没有可能去收集一个人类经验
[01:21:14] 比如说人类历史上面的
[01:21:16] 比如说最好的20个项目
[01:21:18] 或者在每一个领域
[01:21:21] 找到最好的十个或者20个项目
[01:21:24] 然后把它的经验——就是好的设计经验——全部都提取出来。哎，
[01:21:28] 你就想那不就是我第一节课拿的那个
[01:21:30] 《The Philosophy of Software Design》吗
[01:21:32] 就那里面就是这就是人提炼出来的
[01:21:35] 你这个类结构应该怎么写
[01:21:37] 什么时候应该封装
[01:21:39] 什么时候应该把它这个做成继承关系
[01:21:41] 就都是这种碎碎念的
[01:21:43] 这些——他说——这个系统里面这样写的
[01:21:46] 所以它符合这个需求是好的
[01:21:49] 然后如果我们能把这些切片切出来
[01:21:52] 甚至是你直接啊就以污染上下文的形式
[01:21:57] 你先把一个和你相近的好的代码放进来
[01:22:02] 然后你再把你的需求放进来
[01:22:06] 然后因为你就赌
[01:22:08] 这个self-attention还是可以——终于在某一个token的时候能够看到——你
[01:22:12] 我实际上是满足这个需求
[01:22:13] 而不是做这个
[01:22:14] 虽然它会污染上下文
[01:22:16] 但是它会把你的这个东西——把好的经验——给带过来
[01:22:22] 那这样是不是可能可以让AI slop延缓一点
[01:22:27] 能够更大概率做出一个可以长期维护的东西
[01:22:30] 我不知道
[01:22:30] 但是也许需要一些比较好的微调
[01:22:35] 比如说这个项目不要把所有代码都放进去
[01:22:38] 而是我们能不能把它做一个像《The Philosophy of Software Design》那样
[01:22:43] 做一个精简
[01:22:46] 做一个总结
[01:22:47] 把里面好的模式提取出来
[01:22:48] 以文档的形式放进来等
[01:22:51] 但这也其实没有那么容易
[01:22:54] 因为不同的设计是会打架的
[01:22:59] 你的软件我的软件可以设计成是一个完全松耦合的方式来发消息
[01:23:03] 但我也可以设计成另外的一种
[01:23:08] 比如说就是有一个统一的gateway
[01:23:10] 然后我把所有的函数的全部都统一在里面
[01:23:15] 然后查表。就这两种事
[01:23:17] 是不能同时有的
[01:23:21] 他只能选一个
[01:23:22] 那也许我们要有一个更好的方法
[01:23:25] 比如说把好几个软件的设计都放进来
[01:23:28] 然后由AI多轮的迭代收敛到一个好的结构
[01:23:32] 放到我们的代码库里
[01:23:34] 这样
[01:23:34] 但我觉得这就是一个可能还不错的方向
[01:23:37] 而且这个是新的
[01:23:40] 比刚才我们看的那种说
[01:23:42] 我有A问题
[01:23:43] 然后分成A1和A2
[01:23:44] 然后A2里面做一个什么什么什么排列组合的东西
[01:23:47] 看起来要有趣一些
[01:23:49] 对啊好
[01:23:52] 所以核心的观点就是这节课的观点
[01:23:57] 我们今天还没有这种超能力的AI
[01:24:00] 你还是需要有概念
[01:24:02] 知道上下文里面有什么
[01:24:05] 上下文里面的每一个东西都会对AI产生什么样的结果
[01:24:09] 那这唯一的途径就是第一你要对你玩的东西有概念
[01:24:15] 你还是得学处理器
[01:24:17] 操作系统
[01:24:18] 编译器数据库
[01:24:19] 这里有很多设计的智慧
[01:24:20] 只是你学的方法会变好
[01:24:22] 你会用更高效的方法来学
[01:24:25] 然后你理解了上下文以后
[01:24:28] 我们会用一个学期来解释
[01:24:30] 怎么样用软件工程里面的各种各样的方法去给出一个正确的指令
[01:24:35] 去监控AI运行
[01:24:37] 怎么样给AI好的
[01:24:39] 什么叫好的verify
[01:24:40] 今天我只是提到
[01:24:41] OK，你要在上下文里面放进verifier
[01:24:44] 那什么是好的verifier
[01:24:45] 你们可以自己
[01:24:46] 你们自己有自己的想法
[01:24:47] 我今天有一些比较松散的想法
[01:24:51] 今天我们还是需要把模型引导到你认为合适的位置上
[01:24:54] 但是这已经比我组一个工程团队
[01:24:58] 我要雇很多的人
[01:24:59] 然后我要和他们拉通对齐
[01:25:01] 这种互联网黑话
[01:25:03] 那个呵
[01:25:05] 你不需要模型
[01:25:07] 很聪明
[01:25:07] 它见过很多。你只需要用正确的提示词
[01:25:10] 简练的提示词放在这个上下文里面
[01:25:13] 让这个提示词一直能被看到
[01:25:15] 能把模型往那个方向引导
[01:25:19] 就可以
[01:25:20] 然后我这儿有一个很好玩的故事
[01:25:23] 就是一个没有超能力AI的非常典型的案例
[01:25:29] 我们要做一个研究项目
[01:25:32] 研究项目
[01:25:33] 然后这个研究项目大概是做一个符号执行引擎的优化
[01:25:36] 你不需要知道这是什么
[01:25:37] 大概他就说我要写一个程序
[01:25:39] 可以分析一个程序自动分析
[01:25:40] 或者证明一个验证一个不算很大的程序的正啊正确性
[01:25:44] 这也是一种一种玩法
[01:25:46] 然后我们现现在这个东西提的
[01:25:48] 执行效率比较低
[01:25:49] 所以我们希望提出一些比较有效的优化
[01:25:51] 当然这也是一个非常合理的incremental的
[01:25:53] 适合学生做的
[01:25:55] 做的题目
[01:25:55] 然后为一个原始的idea
[01:25:57] 大概是我们我们用这样的方式可能可以有效
[01:26:00] 然后但有些东西是open的
[01:26:02] 比如说这个东西到底怎么做
[01:26:03] 什么东西有效
[01:26:04] 那可以写一个
[01:26:06] 写一个research
[01:26:06] 然后这位同学很开心诶
[01:26:09] 有道理
[01:26:10] 他认为这个idea有道理
[01:26:12] 然后GPT-5.6SALA也认为这个idea有道理
[01:26:15] 那确实就看起来确实这个
[01:26:17] 然后好这个
[01:26:19] 然后他就开始跑
[01:26:20] 然后就跑了非常多的token
[01:26:21] 然后按照那个同学的说法
[01:26:24] 是ChatGPT不断的在给我反馈
[01:26:27] 我无法验证他给我的反馈是正确还是不正确
[01:26:31] 当他给我negative的时候
[01:26:33] 他的negative对
[01:26:36] 我也不知道应该怎么样怎样打破
[01:26:38] 然后好这个原汤化原食
[01:26:42] 这个就是GPT-5.6生成的
[01:26:44] 然后他的
[01:26:49] 他的错误犯在这句话上
[01:26:51] 就是就是因为它就是在上下文里面有一个地方没有做好
[01:26:55] 就把整个方向
[01:26:57] 就我刚才说
[01:26:59] 我们需要把模型引导到你认为合适的位置上
[01:27:01] 然后这个引导错了
[01:27:03] 它因为模型成了一个reward hacker
[01:27:07] 这里有一个需求说我要我要就是这个同学说
[01:27:11] 我想证明这个A方法是有用的
[01:27:19] ChatGPT看到了这句话
[01:27:21] 他就忘记了
[01:27:22] 我们有一个更大的研究的big picture
[01:27:25] 我就是我
[01:27:27] 我作为审稿人的时候
[01:27:29] 我是站在人类的角度上立场上去评审这篇论文的
[01:27:34] 然后我们站在这个构建者的立场上
[01:27:37] 我们是没有办法这样反过来的
[01:27:38] 反过来
[01:27:39] 所以我们只能从从一点一点从小的开始做
[01:27:42] 证明这个方法有用
[01:27:43] 然后他走他做错了这一步
[01:27:46] 他太想要去证明这个idea有用了
[01:27:50] 是因为有这样的一句prompt
[01:27:52] 然后他就构造了很多小的benchmark
[01:27:54] 然后在小的benchmark上做一些微小的东西
[01:27:58] 试图去给一些正面或者负面的结论
[01:28:01] 但这些结论对这个是没有用的
[01:28:04] 然后他这里面是犯了一个方法上的错误
[01:28:07] 当然我们纠正了
[01:28:08] 就说我告诉你PH14
[01:28:10] 等于说我们我们应该从一些真实的工具和state of art的算法开始
[01:28:16] 这个benchmark
[01:28:17] 哪怕要跑几个小时都time out
[01:28:19] 这个time out里面产生的这个搜索路径对我们来说是非常有价值的
[01:28:24] 它揭示了什么样的程序结构
[01:28:26] 对于现有的探索方法是不好的
[01:28:30] 然后这个这个这个这个还挺好玩的
[01:28:33] 一个一个research failure
[01:28:35] 所以他告诉你
[01:28:38] 今天人还是有用的
[01:28:39] 今天人还是有用的
[01:28:40] OK这个我们没有办法把所有的所有的事情都带了给这个AAI
[01:28:49] 但是与此同时
[01:28:52] 我们工作的方式可能也要发生发生变化
[01:28:55] 就是第一这些知识很重要
[01:28:58] 什么操作系统和编译器
[01:29:00] 如果你没有概念
[01:29:02] 你提不出那个正确的问题
[01:29:03] 找不到引导的正确的方向
[01:29:05] 你对人类的知识没有概念
[01:29:07] 你也很难去引导他解决一个open的question
[01:29:13] 但我也发现有些就在和AI合作的时候发生了变化
[01:29:17] 一般来说我发现
[01:29:20] 如果我盯着那个codex的session
[01:29:22] 然后它一旦跑偏
[01:29:24] 我就立即纠正它
[01:29:26] 我可以更快地完成任务
[01:29:28] 就如果是一个比如说就实现一个什么东西
[01:29:30] 比如说我今天就要上交互系统干个什么事
[01:29:32] 他如果我纠正他给他
[01:29:34] 只把我的领域知识注入进去
[01:29:37] 可能可能总时间会完成的更快
[01:29:39] 但是如果我浪费更多的token给他更多时间
[01:29:43] 他一般来说也能完成
[01:29:46] 这时候就有一个trade off
[01:29:48] 我到底是我花我的钱
[01:29:50] 就是你的人力是有
[01:29:51] 就你们每一个同学的精力都是有限有限的
[01:29:55] 每个同学都应该去思考
[01:29:57] 你要把你宝贵的那些经历放到怎么处理AI上
[01:30:04] 因为因为因为是这样
[01:30:06] 我自己发现这是我自己的问题
[01:30:08] 纠正AI是一个有多巴胺的事情
[01:30:13] 他给我一种什么感觉
[01:30:15] 虽然AI很强
[01:30:16] 我好像还是比AI有点用的
[01:30:18] 就他会产生这种非常微妙的心理安慰
[01:30:21] 而不是这个我就一个yo mod
[01:30:24] 然后就等我回来的
[01:30:26] 我也不用我也不会看历史
[01:30:28] 我他反正搞定了
[01:30:29] 我验收一下
[01:30:30] 他真的搞定了
[01:30:30] 我就我就不会看了
[01:30:32] 但这个可能很在非常长的时间里面都会成为同学们工作的一个常态
[01:30:39] 这个你们只只有把AI用在
[01:30:42] 就是把自己的时间留在这些收益最大的事情上
[01:30:45] 这个时间是不能生的
[01:30:47] 就你有一个东西
[01:30:49] 不知道这些东西
[01:30:51] 不知道你想要把它弄
[01:30:54] 知道这是你几乎百分之百的时间都要作为学生要做的做的事情
[01:30:58] 剩下比如说这件事情你知道应该怎么干了
[01:31:01] 把它干好
[01:31:03] AI能把它干好
[01:31:04] 你就放手
[01:31:05] 让他让他干
[01:31:06] 这样就有一种是好像在PREAI的时代
[01:31:09] 大家就已经说了
[01:31:10] 说不说要不要假努力
[01:31:13] 你自我自己感动自己的努力是没有用的
[01:31:15] 你要你要有效的努力
[01:31:17] 在AI时代可能这个效果会差距拉的更大
[01:31:21] 就是你的每一秒钟的假努力
[01:31:23] 如果有一个你的peer是在真努力
[01:31:25] 你都是损失非常非常非常非常大的对
[01:31:29] 这是一个啊这是一个自己的一个小小心得吧
[01:31:32] 对然后以及最后你们也会发现在随着指指指令上下文的增长
[01:31:38] 指令遵循的能力确实会啊会下降的
[01:31:41] 但是现在模型有个很有意思的特点
[01:31:43] 一般来讲最后的prompt就留在最后的那个指令还是可以遵循的
[01:31:49] 到前面之后
[01:31:50] 尤其是到中间的时候
[01:31:50] 他上下文指令不遵循
[01:31:52] 所以干活还是很好用的
[01:31:55] 因为一般最后一个短窗口就是一个具体的任务
[01:31:59] 是你的prompt帮我把什么东西修了诶
[01:32:02] 他就真的还是可以把这个事情给做完
[01:32:05] 所以模型还是啊非常值得
[01:32:08] 值得使用的好
[01:32:11] 那就啊到最后
[01:32:16] 如果你真正想要做一个真正long horizon的非常非常难的任务
[01:32:24] 他不是解决一个问题
[01:32:27] 而是在一个不确定性当中探索
[01:32:31] 那么chain of thought其实就是解决不了的了
[01:32:35] chain of thought能够解决的是一个有VER法
[01:32:37] 它确定的一直往后就能解决的问题
[01:32:40] 但是如果你让他去解决一个
[01:32:44] 帮我考虑一下几种方案
[01:32:45] 哪哪个方案最好
[01:32:47] 他很有可能会给你一个不是最好的啊方案
[01:32:51] 为什么
[01:32:52] 实验模型已经被训练成舔狗了
[01:32:54] 他完成任务才有奖励
[01:32:57] 他完成他不完成任务
[01:32:58] 他是没有奖励的
[01:33:01] 所以他会给你一个有限的方案
[01:33:03] 就像P和NP就是你大家都知道P和P它有这个两个complexity class
[01:33:09] 甚至有更大的这个complexity class
[01:33:11] 有一整个家族
[01:33:12] 还有rocky
[01:33:14] NP问题说你想要验证一个解是比较容易的
[01:33:20] 是P的
[01:33:21] 但是你想要这个找到那个满足条件的解是很难的
[01:33:26] 要找一个哈密顿路径，
[01:33:29] 你给你个路径是不是哈密顿
[01:33:30] 你很容易
[01:33:31] 但是你想要找到一个满足条件的解
[01:33:35] 就是NP-complete
[01:33:36] 它是一个完全问题
[01:33:37] 3-SAT这样的
[01:33:39] 这样这样的问题
[01:33:40] 而就是因为这个搜索是困难的
[01:33:45] 这个验证是容易的。模型
[01:33:47] 为了完成任务
[01:33:48] 它势必只能做有限的搜索
[01:33:52] 这样想一想
[01:33:52] 这样想一想
[01:33:53] 有一种是你在考试场上花点时间
[01:33:57] 一定要把这个考试题写完
[01:33:59] 无论如何
[01:34:00] 马上要交卷了
[01:34:01] 你写你的分数就比不写要高
[01:34:03] 所以你一定要写点什么
[01:34:06] 这个时候啊你就可以用一个算力换智力的循环
[01:34:14] 我举我举个例子
[01:34:15] 我举个例子
[01:34:22] 你们这一代人是子涵吗
[01:34:28] 就你们有很多同学是子涵吗
[01:34:30] 没有，你们还没有
[01:34:33] 你们可能——比你们再小五岁的那个班上——
[01:34:36] 一个班上就有五个甚至十个子涵
[01:34:39] 然后现在子涵就少了
[01:34:40] 现在子涵少多了
[01:34:42] 然后你看AI给我的这个，还是很好的
[01:34:49] 你看它知道要去《诗经》里面找一个
[01:34:57] 还是
[01:35:01] 还是可以的
[01:35:02] 就是他的品味肯定现在模型提升了
[01:35:05] 但是你还是不敢用的
[01:35:06] 为什么
[01:35:07] 因为你用DeepSeek起名字
[01:35:10] 别人也用DeepSeek起名字
[01:35:12] 然后你就会成为一个AI时代的子涵
[01:35:16] 这个因为大家都是用DeepSeek起名字
[01:35:18] 然后DeepSeek都是起了同样的名字
[01:35:21] 我的经验是
[01:35:23] 如果你真的需要一个非常long horizon的任务
[01:35:26] 你就需要一个系统性的调研过程
[01:35:29] 跟你们可能做
[01:35:30] 比如说上什么科研实践课
[01:35:32] 学的那一套就很像了
[01:35:34] 你们进入一个科研领域
[01:35:36] 第一件事情做什么
[01:35:37] 文献调研
[01:35:39] 穷尽搜集和这个问题相关的所有的文献
[01:35:43] 这件事情在AI想要快速完成任务的时候
[01:35:47] AI暂时还不会去花这个大代价
[01:35:50] 但是你可以做名字是可以枚举的
[01:35:54] 你可以先选音
[01:35:57] 然后把不好的音给筛掉
[01:35:59] 选完音你再去用subagent一个一个去检查字
[01:36:08] 然后你可以给他
[01:36:09] 比如说你喜欢诗经
[01:36:10] 你可以选一个《诗经》里的你的词
[01:36:13] 那么你就实现了算力换智力
[01:36:15] 你把一个
[01:36:17] 因为开放问题一个非常大空间里面的开放问题
[01:36:23] 诶你如果直接让AI去用next token的方式
[01:36:27] 它会给你一个它的偏见带来的这个东西
[01:36:31] 但是如果你可以把这个空间分割成很多个discrete的部分
[01:36:37] 然后你的每一个部分就会变成一个有verifier的更明确的东西
[01:36:42] 你有更多的算力
[01:36:44] 你就有更大的智力。但这个有一个缺点：
[01:36:48] 烧token，烧得头疼
[01:36:50] 所以这就涉及到我对人类社会的一个我觉得很有趣的理解
[01:36:57] 就是世界很大
[01:36:58] 人很小
[01:37:00] 我们人类的品味就每一个人都是不一样的
[01:37:02] 因为我们带着太大的bias
[01:37:05] 我们在不同的城市
[01:37:06] 不同的教育背景
[01:37:08] 生活圈长大的。Richard Sutton有一个big world hypothesis
[01:37:11] 我们就是学不到这个世界上所有的东西
[01:37:13] 但就是因为我们带着这个bias，才有这个1+1大于2
[01:37:21] 我们就是一个最大的群体
[01:37:22] 智能
[01:37:24] 我们在一起实现智能
[01:37:26] 但这会带来一个未来的危机
[01:37:29] 我不知道
[01:37:30] 就我先要把这个问题抛出来：如果这种趋势真正到来
[01:37:35] 就是真正有价值
[01:37:36] 实际上真正有价值的问题
[01:37:37] 可以用算力换智力
[01:37:39] 会发生一个什么样残酷的现实
[01:37:43] 有一类人可以获得无限的计算资源
[01:37:45] 他就有无限的智力
[01:37:47] 他就可以砌一堵墙
[01:37:49] 在这个墙里面的人有智力
[01:37:51] 是我的朋友
[01:37:52] 在墙外面的人是普通人
[01:37:55] 那么因为假设计算机AI模型比人类的智力更高效
[01:38:01] 那我们外面的人就变成动物园里的猴子
[01:38:03] 就是让他们自生自灭
[01:38:05] 他们也无论如何也不可能赶上里面人产生智力的这个速度
[01:38:10] 那么就——墙里面是超人
[01:38:12] 墙外面是动物世界
[01:38:13] 我们大家已经在AI的这个关键的基点快要到的时候了
[01:38:20] 我们可能需要思考
[01:38:22] 怎么样防止这件事情到来