1
00:00:00,100 --> 00:00:06,432
本内容改编自小山学堂《学 AI 产品，从入门到精通》，为二次演绎配音版。

2
00:00:06,382 --> 00:00:13,942
这一集要解决的工程问题是，智能体把一段代码交到你手上，你凭什么判断它能不能上线。

3
00:00:13,942 --> 00:00:17,596
你不必自己写得出来，但你必须看得穿。

4
00:00:17,596 --> 00:00:22,680
这一集给你两副眼镜，一副看它怎么搜，一副看它怎么存。

5
00:00:22,680 --> 00:00:28,221
戴上之后，一段代码是能跑通还是能上线，差别立刻现形。

6
00:00:28,221 --> 00:00:31,274
为什么这件事现在变重要了。

7
00:00:31,274 --> 00:00:37,944
因为写代码的成本已经降到近乎为零，而判断代码好坏的成本一点没降。

8
00:00:37,944 --> 00:00:44,939
真正的瓶颈从生产端移到了验收端，谁掌握验收能力，谁才握着方向盘。

9
00:00:44,939 --> 00:00:46,911
这一集分三步走。

10
00:00:46,911 --> 00:00:56,045
先看搜索，智能体在你的代码库里找东西时用的是哪套策略，以及这套策略怎么决定了模型的选词性格。

11
00:00:56,045 --> 00:01:00,156
再看结构，它把数据放在哪、为什么放在那。

12
00:01:00,156 --> 00:01:07,211
最后把这些合成一张验收清单，你可以直接拿去对着任何一次交付逐条提问。

13
00:01:07,372 --> 00:01:09,894
先从一个具体场景切入。

14
00:01:09,844 --> 00:01:15,300
你让智能体去查一个登录报错，它要在几百个文件夹里翻代码。

15
00:01:15,300 --> 00:01:16,526
往哪儿翻。

16
00:01:16,526 --> 00:01:20,949
先扫完这一层再往下，还是抓住一条线索钻到底。

17
00:01:20,949 --> 00:01:23,534
这是两种截然不同的性格。

18
00:01:23,534 --> 00:01:27,079
第一种叫广度优先，一层层往外泡。

19
00:01:27,079 --> 00:01:37,981
它把离起点一步、两步、三步的格子全占住，代价是这一大片都得记在内存里，换来的是撞到目标的那一刻，路径一定最短。

20
00:01:37,981 --> 00:01:45,661
走迷宫的数据很直观，它访问了七十七个格子才碰到终点，但走出来的路径只有二十三格。

21
00:01:45,661 --> 00:01:49,219
第二种叫深度优先，一条道走到黑。

22
00:01:49,219 --> 00:02:00,649
内存里只需要记住当前这一条路，常常更快碰到解，只访问了四十四个格子就到了，但它走出来的路是三十七格，比最短路径绕了将近一倍。

23
00:02:00,649 --> 00:02:06,647
运气不好还会一头扎进死胡同再倒出来，那个倒出来的动作叫回溯。

24
00:02:06,647 --> 00:02:09,916
没有谁全面胜出，只有场景匹配。

25
00:02:09,916 --> 00:02:15,324
要最短、最近、最相关，用广度优先，接受内存开销。

26
00:02:15,324 --> 00:02:21,502
要先找到一个能用的解、内存又紧张，用深度优先，接受路径可能绕。

27
00:02:21,502 --> 00:02:24,435
这两件事在你身边到处都是。

28
00:02:24,435 --> 00:02:37,259
智能体找代码，通常先列一遍顶层目录，这是扫一层，快速建立全局感，发现某个文件夹最可疑，就一头钻进去逐层深挖，切换成一条道走到黑。

29
00:02:37,259 --> 00:02:43,305
真实系统都是混合策略，先广后深，还会用全文检索直接跳跃。

30
00:02:43,305 --> 00:02:54,976
网络爬虫是另一个例子，从首页出发先抓完首页链出的所有页面，再抓链接的链接，这就是一层层泡，保证离首页近的重要页面先入库。

31
00:02:54,976 --> 00:03:01,959
要是反过来一条道走到黑，可能顺着一条链接链钻进某个论坛的第九百九十九页出不来。

32
00:03:01,959 --> 00:03:12,211
社交软件里你可能认识的人也是同一套，从你出发走两层，第一层是你的好友，第二层是好友的好友，层数本身就是亲疏。

33
00:03:12,364 --> 00:03:15,979
搜索讲完，我们往模型内部走一步。

34
00:03:15,929 --> 00:03:22,456
你看过模型逐词元续写时脑子里那排候选概率条，也调过温度那个旋钮。

35
00:03:22,456 --> 00:03:26,278
当时是体感，现在给它一个算法学的名字。

36
00:03:26,278 --> 00:03:29,607
每一步都挑概率最大的，叫贪心。

37
00:03:29,607 --> 00:03:32,612
按概率掷骰子的，叫采样。

38
00:03:32,612 --> 00:03:35,833
贪心的特点是跑一万次都一样。

39
00:03:35,833 --> 00:03:39,860
同一个开头点三次，生成的句子一字不差。

40
00:03:39,860 --> 00:03:45,304
它快、稳、可复现，适合做实验、写代码、抽数据。

41
00:03:45,304 --> 00:03:50,713
但它有个致命盲点，每一步的局部最优加起来不一定是整体最优。

42
00:03:50,713 --> 00:03:55,052
第一步挑了最顺口的词，可能把整句话带进死路。

43
00:03:55,052 --> 00:03:57,840
生活里你见过这种性格。

44
00:03:57,840 --> 00:04:08,754
去吃自助餐，每一轮都直奔当下最贵的菜，三文鱼、牛排、帝王蟹一路夹过去，最后肚子没了，主打的现切和牛一口没吃上。

45
00:04:08,754 --> 00:04:14,427
每步最优不等于整体最优，胃是有限的，上下文窗口也是。

46
00:04:14,427 --> 00:04:16,266
采样是另一回事。

47
00:04:16,266 --> 00:04:20,016
它用确定性换多样性，按概率掷骰子。

48
00:04:20,016 --> 00:04:27,456
大概率的词还是常被选中，所以句子依然通顺，小概率的词偶尔翻身，所以有惊喜。

49
00:04:27,456 --> 00:04:34,643
温度就是拨给惊喜的额度，温度越高，那排概率条被压得越平，冷门词越敢冒头。

50
00:04:34,643 --> 00:04:36,651
那句话可以背下来。

51
00:04:36,651 --> 00:04:47,624
温度等于零的时候就是贪心解码，输出完全确定，温度越高，分布越平坦，模型越敢选低概率词，多样性和胡来的风险一起上升。

52
00:04:47,624 --> 00:04:49,788
所以怎么选看任务。

53
00:04:49,788 --> 00:04:54,547
复现实验、写代码、抽取数据，温度调到零。

54
00:04:54,547 --> 00:04:58,526
头脑风暴、写文案、要创意，往上调。

55
00:04:58,526 --> 00:05:04,066
你在界面上拨的那颗旋钮，拨的就是贪心和采样之间的位置。

56
00:05:04,204 --> 00:05:06,281
贪心那个坑怎么填。

57
00:05:06,231 --> 00:05:12,914
办法朴素得可爱，别急着定，多留几条候选路一起往前走，走完再比总分。

58
00:05:12,914 --> 00:05:14,789
这就是束搜索。

59
00:05:14,789 --> 00:05:17,036
词格上的对比很清楚。

60
00:05:17,036 --> 00:05:22,289
开头固定是这家店的，往右走四步，每步三个候选词。

61
00:05:22,289 --> 00:05:29,909
贪心第一步就抓住了概率零点五的菜，后面的路却越走越窄，整条路累计只有零点零七二。

62
00:05:29,909 --> 00:05:39,620
束宽等于二的时候同时养两条路，被淘汰的变灰，最后让第一步只有零点三的性价比笑到了最后，累计零点零九八。

63
00:05:39,620 --> 00:05:47,120
束宽等于三更狠，连第一步只有零点二的装修都保下来，挖出了全场最优的零点一零一。

64
00:05:47,120 --> 00:05:54,055
但你再看右下角的计数器，计算量从十二个候选到二十一个再到三十个，翻了近三倍。

65
00:05:54,055 --> 00:05:56,519
这就是这颗旋钮的账本。

66
00:05:56,519 --> 00:06:05,979
束宽等于一时它就退化成贪心，束宽无穷大就是穷举所有路，所以束搜索是贪心和穷举之间的滑杆。

67
00:06:05,979 --> 00:06:08,959
实际工程里的取值是有共识的。

68
00:06:08,959 --> 00:06:15,329
翻译系统常用四到十，再往上，质量提升越来越少，账单却线性上涨。

69
00:06:15,329 --> 00:06:21,399
所以真正的问题从来不是要不要更优，而是这点更优值不值这些算力。

70
00:06:21,399 --> 00:06:27,962
你会发现，前面迷宫里广度优先和深度优先的争论，本质上是同一道选择题。

71
00:06:27,962 --> 00:06:31,111
顺便说一个可能让你意外的关联。

72
00:06:31,111 --> 00:06:36,652
现在那些会先想再答的推理模型，和束搜索是同一套哲学。

73
00:06:36,652 --> 00:06:43,947
回答之前先生成一段长长的思考过程，试几条思路，自我否定，再挑最好的落笔。

74
00:06:43,947 --> 00:06:53,142
区别在于推理模型用自然语言探路，灵活得多，但算力换质量这笔账，和词格上那三个计数器是同一笔。

75
00:06:53,284 --> 00:06:56,611
到这里，算法这条线可以收网了。

76
00:06:56,561 --> 00:07:02,534
整个篇章其实只讲了五类思想，每一类在人工智能里都有一个真身。

77
00:07:02,534 --> 00:07:11,609
第一类问数据翻十倍会怎样，答案是注意力是平方级复杂度，上下文越长，计算量按平方涨，账单也按平方涨。

78
00:07:11,609 --> 00:07:20,191
第二类是有序就砍半、乱序先排好，真身是检索增强里的重排序，先把候选段落粗排一遍再精排。

79
00:07:20,191 --> 00:07:28,015
第三类是大事拆成同一件小事，真身是上下文压缩，长对话切段、各自摘要、再合并。

80
00:07:28,015 --> 00:07:35,215
第四类就是刚才的图搜索，真身是智能体在代码库里遍历目录、顺着引用链深挖。

81
00:07:35,215 --> 00:07:40,996
第五类是每步挑最大还是按概率掷骰子，真身是温度和束搜索。

82
00:07:40,996 --> 00:07:42,919
定位比解题重要。

83
00:07:42,919 --> 00:07:48,676
真实工作里没人告诉你这是二分题，也没人告诉你这是束搜索题。

84
00:07:48,676 --> 00:07:55,539
你只需要看到问题时先认出这是哪类思想的地盘，具体解法智能体会给你。

85
00:07:55,684 --> 00:07:59,143
现在换第二副眼镜，看数据放在哪。

86
00:07:59,093 --> 00:08:04,766
前面讲的收纳方式都是一排排的，现在换个维度，一层套一层。

87
00:08:04,766 --> 00:08:12,495
衣柜里有格子，格子里有盒子，盒子里有袋子，这种层级加包含的关系，在编程里叫树。

88
00:08:12,495 --> 00:08:16,533
而智能体抬眼望去，你的项目里全是树。

89
00:08:16,533 --> 00:08:19,201
同一个项目可以看成三棵。

90
00:08:19,201 --> 00:08:26,437
文件目录是一棵，一笔订单的数据结构是一棵，点单页面的文档对象模型也是一棵。

91
00:08:26,437 --> 00:08:32,026
三样东西看着完全不同，形状却一模一样，都是一个根往下分叉。

92
00:08:32,026 --> 00:08:40,644
所以智能体只要学会读树这一门手艺，就能同时看懂你的项目骨架、接口返回的数据和整个网页。

93
00:08:40,644 --> 00:08:47,687
顺手记三个词，最顶上那个叫根，有孩子的叫父节点，再也展不开的末端叫叶子。

94
00:08:47,687 --> 00:08:50,247
就这三个，够用一辈子。

95
00:08:50,247 --> 00:08:53,865
树最厉害的一次出场是在代码本身。

96
00:08:53,865 --> 00:09:00,451
一行算总价的代码，在你眼里是一串文字，在智能体眼里是一棵语法树。

97
00:09:00,451 --> 00:09:06,040
它自下而上长出来，叶子是变量，往上是运算符，一直长到根。

98
00:09:06,040 --> 00:09:10,079
这就是智能体改代码能改得这么准的秘密。

99
00:09:10,079 --> 00:09:21,221
你说把乘号右边的变量改个名，它不是在一堆文字里搜乘号这两个字，它是在树上先找到那个乘法节点，再取它的右孩子，指哪打哪。

100
00:09:21,221 --> 00:09:25,427
改完再把树打印回文字，一个空格都不会错位。

101
00:09:25,427 --> 00:09:33,853
重命名变量、抽取函数、批量重构，靠的全是在这棵树上做手术，而不是碰运气的文本替换。

102
00:09:33,853 --> 00:09:36,209
还有一层更实用的认知。

103
00:09:36,209 --> 00:09:50,451
你调用大模型接口时发的消息列表、检索回来的资料、智能体之间传的任务，几乎全打包成同一种结构化文本，因为它就是一棵用文字写出来的树，任何程序都能一层层拆开读。

104
00:09:50,451 --> 00:09:54,742
看懂树，就看懂了这个领域一大半的数据。

105
00:09:54,892 --> 00:09:59,024
树很规矩，每个节点只有一个爹，永远不绕圈。

106
00:09:58,974 --> 00:10:01,234
可现实世界乱多了。

107
00:10:01,234 --> 00:10:06,017
你的朋友互相也是朋友，公司、学校、人搅在一起。

108
00:10:06,017 --> 00:10:13,373
把每个节点只能有一个爹这条规矩撕掉，树就升级成图，节点加关系，想怎么连怎么连。

109
00:10:13,373 --> 00:10:15,837
第一个主场是知识图谱。

110
00:10:15,837 --> 00:10:24,996
圆点是实体，连线是关系，点一个节点，关系一圈圈扩散出去，一跳是直接认识的，两跳是朋友的朋友。

111
00:10:24,996 --> 00:10:30,320
为什么这重要，因为有些问题没有任何一段资料直接写着答案。

112
00:10:30,320 --> 00:10:39,347
比如问某位企业家母校的知名校友还有谁，沿着图走两跳就拼出来了，先走到学校，再从学校走到另一个校友。

113
00:10:39,347 --> 00:10:46,931
检索到一个节点还能顺藤摸瓜，这叫图检索增强，比单纯搜文本能回答更绕的问题。

114
00:10:46,931 --> 00:10:49,960
第二个主场是多智能体工作流。

115
00:10:49,960 --> 00:10:57,977
让一队智能体合写一份调研报告，每个方框是一个任务，箭头表示必须等前面的完成才能开工。

116
00:10:57,977 --> 00:11:08,578
你会看到两件事，没有互相依赖的任务会同时亮起，这就是并行提速的来源，每个任务都要等它的箭头来源全部变绿才动工。

117
00:11:08,578 --> 00:11:12,652
然后是最关键的一条，为什么必须是无环图。

118
00:11:12,652 --> 00:11:15,188
这不是黑话，是常识。

119
00:11:15,188 --> 00:11:19,082
任务的依赖箭头有方向，而且不能绕成圈。

120
00:11:19,082 --> 00:11:25,284
一旦有环，就成了你等我、我等他、他等你的三角债，谁也开不了工。

121
00:11:25,284 --> 00:11:34,503
所有编排框架在你提交工作流时都会先查一遍有没有环，查出来直接拒绝运行，就是为了避免这种集体卡死。

122
00:11:34,503 --> 00:11:41,318
所以验收时值得问一句，它编排的这张图，查过环吗，哪些步骤在并行。

123
00:11:41,476 --> 00:11:44,130
最后把它们摆上同一张桌子。

124
00:11:44,080 --> 00:11:49,056
八种收纳方式，每种都有最亮的强项和最疼的弱项。

125
00:11:49,056 --> 00:11:54,561
数组排排坐按号找，按位置直达，但中间插入要全体挪位。

126
00:11:54,561 --> 00:12:00,306
栈是后进先出，撤销和回溯少不了它，但只能动最上面那一个。

127
00:12:00,306 --> 00:12:05,270
队列先进先出，排队公平能削峰兜底，但不能插队。

128
00:12:05,270 --> 00:12:12,986
哈希表算一算位置就一步直达，查找去重快到不讲理，代价是没有顺序还要多花内存。

129
00:12:12,986 --> 00:12:19,116
缓存是算过的别再算，省时间也省钱，最难拿捏的是什么时候作废。

130
00:12:19,116 --> 00:12:23,815
树擅长表达嵌套与从属，但平级互连表达不了。

131
00:12:23,815 --> 00:12:28,803
图能表达任意多对多关系，代价是容易绕圈、遍历成本高。

132
00:12:28,803 --> 00:12:36,171
向量把语义变成坐标，按像不像找东西，代价是结果只是近似，还得配专门的索引。

133
00:12:36,171 --> 00:12:37,722
这么多怎么记。

134
00:12:37,722 --> 00:12:41,315
以后遇到任何数据场景只问两个问题。

135
00:12:41,315 --> 00:12:50,210
第一问怎么找，按位置找用数组，按键找用哈希，按层级找用树，按关系找用图，按相似找用向量。

136
00:12:50,210 --> 00:12:54,597
第二问怎么进出，先进先出是队列，后进先出是栈。

137
00:12:54,597 --> 00:12:59,837
再加一条横切的省钱心法，算过的别再算，那就是缓存。

138
00:12:59,837 --> 00:13:03,323
两问一心法，就是整章的全部骨架。

139
00:13:03,323 --> 00:13:08,299
落到验收动作上，三档任务按你能投入的时间挑一档。

140
00:13:08,299 --> 00:13:13,371
最轻的一档半小时就能做完，不看代码，先审口供。

141
00:13:13,371 --> 00:13:28,867
让智能体自己交代三件事，它用了什么结构存这些数据，为什么选它而不是别的，并且必须说出至少一个被它放弃的备选方案和放弃理由，最后，数据量翻一千倍会怎样，哪一行最先扛不住。

142
00:13:28,867 --> 00:13:35,382
你会发现，说不出放弃了什么的回答，基本等于它没做过选型，只是默认输出。

143
00:13:35,382 --> 00:13:50,093
第二档半天，让它用另一种结构把同一功能重写一遍，列出查询速度、插入速度、内存占用、代码可读性四个维度的对照表，但结论不要让它下，由你来判断哪版适合你的场景。

144
00:13:50,093 --> 00:13:57,798
说不出因为我的数据量是多少、最频繁的操作是什么所以选它，就说明判断还是它替你做的。

145
00:13:57,798 --> 00:14:07,978
第三档一周，给自己挑一个真实需求，先别问智能体，自己按刚才那两问一心法选一遍，再让智能体独立出一份方案，对答案。

146
00:14:07,978 --> 00:14:11,500
一致就互相验证，不一致就辩论。

147
00:14:11,500 --> 00:14:19,973
为什么顺序不能反，因为反过来的话，它的答案会瞬间覆盖你的思考，你永远不知道自己原本会怎么选。

148
00:14:19,973 --> 00:14:25,971
验收的眼力，就是在你的选择和它的选择不一致的那个缝隙里长出来的。

149
00:14:25,971 --> 00:14:28,735
还有三面红旗值得单独记。

150
00:14:28,735 --> 00:14:34,408
看到循环里套循环挨个比对，追问一句换成集合会不会更快。

151
00:14:34,408 --> 00:14:40,262
看到它在小数据上演示得飞快，永远追问数据翻一千倍会怎样。

152
00:14:40,262 --> 00:14:45,923
看到它只会夸当前选择、举不出被放弃的选项，多追问一轮。

153
00:14:46,060 --> 00:14:49,050
最后落成几条能直接用的原则。

154
00:14:49,000 --> 00:14:52,546
第一，先看它怎么搜，再看它怎么存。

155
00:14:52,546 --> 00:14:59,878
任何一次交付，先问数据放在哪，再问打算怎么处理，最后问数据翻一百倍会怎样。

156
00:14:59,878 --> 00:15:04,469
三个问题问下来，能跑通和能上线的差距就现形了。

157
00:15:04,469 --> 00:15:08,688
第二，验收从审口供开始，不要急着读代码。

158
00:15:08,688 --> 00:15:14,685
让它交代结构、理由和备选方案，比你自己逐行读更快暴露问题。

159
00:15:14,685 --> 00:15:17,342
第三，结论必须由你下。

160
00:15:17,342 --> 00:15:26,068
它负责摆事实列对照表，哪版适合我的场景这句话只能你说，说不出依据就等于判断权还在它手上。

161
00:15:26,068 --> 00:15:29,866
第四，永远追问数据翻一千倍会怎样。

162
00:15:29,866 --> 00:15:35,238
这是整章最值钱的一句话，也是区分演示级和生产级的分水岭。

163
00:15:35,238 --> 00:15:41,452
第五，看到多步决策的地方，问一句它是一次定死还是多留了几条路。

164
00:15:41,452 --> 00:15:46,657
束宽就是算力换质量的旋钮，取值背后必须有账单意识。

165
00:15:46,657 --> 00:15:51,344
第六，看到多个步骤协作的地方，先查有没有环。

166
00:15:51,344 --> 00:15:56,524
有环就是死锁，这在图上不是理论风险，是必然结果。

167
00:15:56,524 --> 00:16:07,222
这六条里，前三条决定你能不能看懂交付，中间两条决定你能不能判断成本，最后一条决定它在规模化之后会不会卡死。

168
00:16:07,222 --> 00:16:12,654
你可以拿它去对照任何一次智能体交付，看它究竟经得起几问。