1
00:00:00,120 --> 00:00:00,600
好的。

2
00:00:00,600 --> 00:00:01,120
你准备好了吗？

3
00:00:01,120 --> 00:00:02,280
这真的很重要。

4
00:00:02,280 --> 00:00:07,280
这个系统消息和用户消息是整个系统最重要的系统消息和用户消息。

5
00:00:07,280 --> 00:00:07,960
课程。

6
00:00:07,960 --> 00:00:10,600
所以我们更好，我们更好，我们更好地关注这里。

7
00:00:10,880 --> 00:00:11,960
系统消息。

8
00:00:12,000 --> 00:00:18,120
您可以使用您的工具找到特价产品的超值优惠，并通知用户最优惠的价格。

9
00:00:18,640 --> 00:00:19,320
很公平。

10
00:00:19,640 --> 00:00:21,680
我们将处理该用户消息。

11
00:00:21,680 --> 00:00:25,160
首先，使用您的工具在互联网上扫描特价商品。

12
00:00:25,160 --> 00:00:28,880
然后，对于每笔交易，使用您的工具来估计真实价值。

13
00:00:29,040 --> 00:00:34,280
然后选择最引人注目的交易，其价格远低于估计的真实价值，

14
00:00:34,280 --> 00:00:36,920
并使用您的工具通知用户。

15
00:00:37,040 --> 00:00:40,800
然后回复ok就表示成功了。

16
00:00:41,520 --> 00:00:42,320
就是这样。

17
00:00:42,440 --> 00:00:43,960
这是我们的指示。

18
00:00:44,840 --> 00:00:46,280
让我们将其放入一些消息中。

19
00:00:46,280 --> 00:00:48,000
我们只看一下消息。

20
00:00:50,600 --> 00:00:51,360
就在那里。

21
00:00:51,560 --> 00:00:53,760
这和我刚才读给你们听的内容是一样的。

22
00:00:54,120 --> 00:00:56,600
这是我们的系统消息和用户提示。

23
00:00:57,560 --> 00:00:58,400
好的。

24
00:00:58,920 --> 00:00:59,920
看看这个。

25
00:01:00,320 --> 00:01:05,850
关于这段代码需要注意的一点是，有一行是非常重要的

26
00:01:05,850 --> 00:01:09,050
线，那条线就是这里的这条线。

27
00:01:09,690 --> 00:01:10,810
我们说完成是假的。

28
00:01:10,810 --> 00:01:12,890
然后我们说，虽然还没有完成。

29
00:01:13,570 --> 00:01:14,930
为什么这很重要？

30
00:01:14,930 --> 00:01:16,570
你可能认为你是。

31
00:01:17,490 --> 00:01:18,570
考虑一下。

32
00:01:18,890 --> 00:01:22,250
这很重要，因为这是我们的代理循环。

33
00:01:22,450 --> 00:01:26,610
这就是这意味着我们满足定义，因为我们有一个循环。

34
00:01:26,810 --> 00:01:34,090
这是一个带有代理的循环，它会四处走动，它有工具，它是一个配备了代理的代理

35
00:01:34,090 --> 00:01:34,970
用工具。

36
00:01:35,130 --> 00:01:40,490
当它响应时，呃，表明成功，它不会调用工具。

37
00:01:40,490 --> 00:01:42,130
一切都会结束。

38
00:01:42,290 --> 00:01:44,130
这意味着完成是正确的。

39
00:01:44,130 --> 00:01:45,690
目标达到了。

40
00:01:45,730 --> 00:01:51,650
因此，这是一个与实现目标的工具循环结合的法学硕士。

41
00:01:51,930 --> 00:01:56,010
它所拥有的工具就是我们在这里传递的这些工具集。

42
00:01:56,290 --> 00:02:01,140
这些工具是我们在那里编写的三个假函数。

43
00:02:01,140 --> 00:02:05,700
他们所做的就是打印一些东西，然后返回虚拟数据。

44
00:02:06,020 --> 00:02:10,780
这样我就可以运行这个，它会让那个变成假的。

45
00:02:10,820 --> 00:02:15,660
它将真正使用此系统消息和用户提示武装

46
00:02:15,700 --> 00:02:21,700
具有这些假函数的LM，据它所知，认为它们是真正的工具。

47
00:02:21,700 --> 00:02:23,180
我们将看看它会做什么。

48
00:02:23,300 --> 00:02:23,900
好的。

49
00:02:23,940 --> 00:02:24,620
开始了。

50
00:02:24,660 --> 00:02:26,300
深呼吸并奔跑。

51
00:02:27,820 --> 00:02:31,980
于是它立即调用了fake函数来扫描互联网。

52
00:02:31,980 --> 00:02:34,060
这会返回一组硬编码的交易。

53
00:02:34,060 --> 00:02:34,780
看看这个。

54
00:02:34,820 --> 00:02:38,700
它只是被称为假函数来估计真实值四次。

55
00:02:38,900 --> 00:02:43,220
它只是创建了一个假函数来通知用户交易，然后就返回了。

56
00:02:43,220 --> 00:02:47,980
好吧，它比我评论的速度还要快。

57
00:02:47,980 --> 00:02:49,300
这就是刚刚发生的事情。

58
00:02:49,340 --> 00:02:54,220
它们都是假函数，但它调用了它们，并且自动调用了它们。

59
00:02:54,260 --> 00:02:59,140
它调用了所有这些工具，因为它认为当时调用这些工具是正确的。

60
00:02:59,140 --> 00:03:04,230
当然，正如你所知，尝试以一种人类的方式来思考这一点总是很诱人的。

61
00:03:04,230 --> 00:03:04,870
就像这样。

62
00:03:04,910 --> 00:03:10,590
发生的事情是这些 LM 调用正在生成令牌、最有可能的下一个令牌以及那些

63
00:03:10,590 --> 00:03:17,350
最有可能的下一个标记涉及进行工具调用，因每个工具调用而停止

64
00:03:17,390 --> 00:03:22,070
这些工具按照此 JSON blob 的描述连续调用一个。

65
00:03:22,070 --> 00:03:28,190
在这里，它知道首先调用该工具，然后针对每笔交易调用该工具。

66
00:03:28,190 --> 00:03:30,630
然后最后通知用户。

67
00:03:30,950 --> 00:03:36,150
我认为它达成了五笔交易，并且决定只询问价格。

68
00:03:36,150 --> 00:03:37,830
这就是它的选择。

69
00:03:37,950 --> 00:03:41,710
呃，呃，它就在那里做出了自主决定。

70
00:03:41,750 --> 00:03:44,070
这就是自治的力量。

71
00:03:44,230 --> 00:03:48,750
嗯，所以即使我们相当规范，你也可以尝试不那么规范，

72
00:03:48,790 --> 00:03:50,950
你可以在这里尝试一些非常非常短的东西。

73
00:03:51,070 --> 00:03:53,830
呃，我们非常明确我们想要它做什么。

74
00:03:53,990 --> 00:03:57,150
它仍然对其中一些做出了自己的决定。

75
00:03:57,150 --> 00:03:59,710
但它的结论都是正确的。

76
00:04:00,800 --> 00:04:03,640
但问题是它调用了假函数。

77
00:04:03,640 --> 00:04:05,000
这不是我们想要的。

78
00:04:05,040 --> 00:04:07,200
我们希望它能够真正呼叫其他代理。

79
00:04:07,320 --> 00:04:08,560
那么我们将如何做到这一点呢？

80
00:04:08,600 --> 00:04:12,440
好吧，您可能已经意识到这一点，但这将非常容易。

81
00:04:12,520 --> 00:04:17,280
我们几乎不需要做任何 LM 或计划者 LM 在这里的事情。

82
00:04:17,800 --> 00:04:19,920
它不知道这些功能是假的。

83
00:04:19,960 --> 00:04:21,040
它只是调用这些工具。

84
00:04:21,040 --> 00:04:24,400
它正在调用我们刚刚在其中包含打印语句的函数。

85
00:04:24,400 --> 00:04:29,560
但该函数调用本身可能只是对另一个代理进行调用。

86
00:04:29,600 --> 00:04:33,000
它可以只是说像边境代理价格或类似的东西。

87
00:04:33,040 --> 00:04:35,920
如何实现该功能完全取决于我们。

88
00:04:36,240 --> 00:04:39,080
这正是我所做的。

89
00:04:39,440 --> 00:04:48,240
因此，如果我们在这里查看自主规划代理，这是一个类，基本上当

90
00:04:48,240 --> 00:04:55,760
它，当它被创建时，当它被实例化时，它会创建一个扫描仪代理和整体

91
00:04:55,760 --> 00:04:57,760
代理和消息代理。

92
00:04:57,800 --> 00:05:00,320
它创建每个的实例。

93
00:05:00,660 --> 00:05:07,780
然后它具有扫描互联网寻找便宜货的功能，该功能称为扫描仪扫描。

94
00:05:07,780 --> 00:05:12,100
这就是我们几天前进行的扫描的开始。

95
00:05:12,460 --> 00:05:14,140
它有估计真实价值。

96
00:05:14,180 --> 00:05:15,100
所以我们昨天就这么做了。

97
00:05:15,140 --> 00:05:20,060
它得到了估计的真实值，称为自点集合点价格。

98
00:05:20,100 --> 00:05:23,260
它调用价格函数，然后价格函数将调用所有其他价格函数。

99
00:05:23,540 --> 00:05:25,660
然后我们通知用户交易。

100
00:05:25,820 --> 00:05:33,340
这会调用 Messenger 通知，而后者又调用了与我们昨天相同的函数。

101
00:05:33,700 --> 00:05:36,460
然后我得到了相同的 JSON blob。

102
00:05:36,900 --> 00:05:42,980
现在，在句柄工具调用中，我调用上面的这些函数之一。

103
00:05:42,980 --> 00:05:45,100
其实这次我写得好一点了。

104
00:05:45,100 --> 00:05:51,260
我有一个映射字典，可以从文本映射到函数本身，所以我不做

105
00:05:51,260 --> 00:05:51,500
那。

106
00:05:51,500 --> 00:05:52,860
讨厌的全局变量。

107
00:05:53,020 --> 00:05:55,620
我不知道你认为这是优雅的还是黑客的，但我不会这样做。

108
00:05:55,620 --> 00:05:57,460
我正在做一些更防弹的事情。

109
00:05:57,460 --> 00:06:03,670
本着这种生产化代码的精神，可以很好地部署

110
00:06:03,670 --> 00:06:04,070
精心制作的。

111
00:06:04,070 --> 00:06:08,430
因此要更加小心，但系统消息和用户提示相同。

112
00:06:08,430 --> 00:06:12,630
这里我们有我们的代理循环。

113
00:06:12,830 --> 00:06:16,150
我们做了虚假的事，却没有做完。

114
00:06:16,430 --> 00:06:22,110
然后每次调用工具时都会循环，直到确定我用完为止。

115
00:06:22,150 --> 00:06:28,310
没有更多的工具可以调用，然后它接受响应，并表示它已完成此回复。

116
00:06:28,510 --> 00:06:32,350
这将是我们的自主规划代理。

117
00:06:32,350 --> 00:06:39,110
这是完全相同的事情，除了不是空函数，而是假函数，我们实际上

118
00:06:39,110 --> 00:06:42,070
给其他特工打电话。

119
00:06:42,310 --> 00:06:44,230
好吧，时间到了。

120
00:06:44,230 --> 00:06:45,110
让我们这样做吧。

121
00:06:45,470 --> 00:06:48,390
所以，呃，我们将再次打开日志记录。

122
00:06:48,510 --> 00:06:51,470
我们将掌握我们的数据库。

123
00:06:51,510 --> 00:06:53,070
手边有那个。

124
00:06:53,310 --> 00:06:53,630
好的。

125
00:06:53,710 --> 00:06:59,710
现在我要说的是从代理点我们从代理自主规划代理导入。

126
00:06:59,750 --> 00:07:03,840
我们当时正在查看的东西让我们创建它。

127
00:07:04,080 --> 00:07:06,880
Agent是自主规划的Agent集合。

128
00:07:07,160 --> 00:07:07,520
好的。

129
00:07:07,560 --> 00:07:08,440
让我们这样做吧。

130
00:07:08,440 --> 00:07:10,760
所以我们要创建这个代理。

131
00:07:10,760 --> 00:07:15,440
当我们创建规划代理时，它将创建它所依赖的其他代理。

132
00:07:15,440 --> 00:07:17,080
所以我们会看看这里会发生什么。

133
00:07:17,520 --> 00:07:18,680
即将设置完毕。

134
00:07:18,680 --> 00:07:20,600
当然，它会进行大量进口。

135
00:07:22,120 --> 00:07:23,160
看看那个。

136
00:07:23,160 --> 00:07:26,720
有些颜色有些颜色一堆事情正在发生。

137
00:07:26,920 --> 00:07:30,840
自主规划代理正在初始化扫描仪代理，扫描仪代理已准备就绪。

138
00:07:30,880 --> 00:07:32,320
乐团代理。

139
00:07:32,560 --> 00:07:35,520
专业代理正在连接至模态。

140
00:07:35,760 --> 00:07:37,240
一切都在发生。

141
00:07:37,240 --> 00:07:39,720
代理将加载其权重。

142
00:07:41,800 --> 00:07:43,320
好吧，现在就这样。

143
00:07:43,760 --> 00:07:45,080
现在时机已到。

144
00:07:45,400 --> 00:07:47,320
快到跑步的时间了。

145
00:07:47,640 --> 00:07:48,160
代理人。

146
00:07:50,560 --> 00:07:51,120
代理人。

147
00:07:51,120 --> 00:07:51,680
计划。

148
00:07:51,880 --> 00:07:52,840
你准备好了吗？

149
00:07:52,840 --> 00:07:53,960
让我们开始吧。

150
00:07:54,360 --> 00:07:58,400
好吧，它说自主规划代理正在开始运行。

151
00:07:58,440 --> 00:08:00,400
它正在调用扫描仪。

152
00:08:00,560 --> 00:08:03,050
这就是规划代理的绿色部分。

153
00:08:03,090 --> 00:08:05,570
现在扫描仪的颜色为青色。

154
00:08:05,810 --> 00:08:09,290
扫描仪即将从 RSS 源中获取交易。

155
00:08:09,290 --> 00:08:13,810
所以它就是这样做的，收集了 30 笔交易。

156
00:08:13,850 --> 00:08:16,170
或者，如果你把它调大，它可能会收集更多。

157
00:08:16,410 --> 00:08:20,730
现在它正在调用具有结构化输出的 OpenAI。

158
00:08:20,730 --> 00:08:27,650
它使用结构化输出，以便我们获得将非结构化数据转换为结构化数据的格式

159
00:08:27,650 --> 00:08:28,170
数据。

160
00:08:28,410 --> 00:08:34,530
作为该结构化输出的一部分，它从 OpenAI 收到了五笔精选交易。

161
00:08:34,530 --> 00:08:39,010
现在它又回到规划代理那里来弄清楚下一步要做什么。

162
00:08:39,290 --> 00:08:42,370
好吧，它会想做一些事情。

163
00:08:42,690 --> 00:08:49,450
首先，它将首先运行集成代理来估计某物的真实价值。

164
00:08:49,450 --> 00:08:57,170
集成代理首先通过 light LM 调用，我已将其设置为使用 OpenAI GPT 操作系统

165
00:08:57,210 --> 00:09:05,420
20 对文本进行预处理，将其变成带有标题、类别和所有内容的文本，

166
00:09:05,420 --> 00:09:09,820
以便我们的 LMS 处于估算价格的最佳状态。

167
00:09:10,100 --> 00:09:12,820
然后就交给了专业代理。

168
00:09:12,860 --> 00:09:14,780
这是我们的前沿模型。

169
00:09:14,940 --> 00:09:17,620
所以并不是所有前沿模型专家模型都运行在模态上。

170
00:09:17,620 --> 00:09:20,260
花了 30 秒来热身，结果确实如此。

171
00:09:20,580 --> 00:09:22,460
现在，前沿模型正在运行。

172
00:09:22,460 --> 00:09:23,820
现在对我来说太快了。

173
00:09:23,860 --> 00:09:26,580
现在你可以看到紫色是前沿模型。

174
00:09:26,620 --> 00:09:28,580
蓝色的是前沿型号。

175
00:09:28,580 --> 00:09:30,780
所以紫色是神经网络代理。

176
00:09:30,820 --> 00:09:34,060
我们现在有五种产品已经定价。

177
00:09:34,180 --> 00:09:41,700
现在它又回来了，呃，呃，它又回到了，嗯，呃，推送通知。

178
00:09:42,140 --> 00:09:45,660
现在它刚刚做出了推动就到了。

179
00:09:45,660 --> 00:09:46,540
你听到了吗？

180
00:09:46,540 --> 00:09:47,700
那是我的手机。

181
00:09:47,700 --> 00:09:49,020
我刚刚收到一条消息。

182
00:09:49,100 --> 00:09:49,620
惊人的。

183
00:09:49,620 --> 00:09:49,900
交易。

184
00:09:49,900 --> 00:09:50,180
警报。

185
00:09:50,180 --> 00:09:52,980
购买戴尔 16 plus ultra 5。

186
00:09:53,220 --> 00:09:54,300
我收到了交易提醒。

187
00:09:54,300 --> 00:09:55,500
我抓住了。

188
00:09:55,820 --> 00:09:56,740
它发生了。

189
00:09:56,860 --> 00:10:00,060
我们刚刚运行了代理框架。

190
00:10:00,260 --> 00:10:01,620
那不是很神奇吗？