1
00:00:00,280 --> 00:00:07,920
好的，现在是时候评估谁做得最好了，还有什么更好的方法来评估谁做得最好？

2
00:00:07,920 --> 00:00:09,480
使用 LM 来完成此任务。

3
00:00:09,520 --> 00:00:12,000
必须阅读所有这些内容并做出决定，这将是乏味的。

4
00:00:12,200 --> 00:00:13,760
首先，让我们了解一下我们现在所处的位置。

5
00:00:13,760 --> 00:00:15,440
所以我们有两个清单。

6
00:00:15,440 --> 00:00:19,040
一种称为竞争对手，一种称为答案。

7
00:00:19,320 --> 00:00:20,760
我喜欢光标的方式。

8
00:00:20,760 --> 00:00:25,040
所以我们可以将它们打印出来，我们会看到我们已经得到了这两个列表。

9
00:00:25,160 --> 00:00:25,600
他们就在那里。

10
00:00:25,640 --> 00:00:26,840
这些是我们的竞争对手。

11
00:00:26,880 --> 00:00:28,160
我希望你能认出他们。

12
00:00:28,160 --> 00:00:30,000
这些就是他们的答案。

13
00:00:30,480 --> 00:00:35,440
所以现在要做的一件事很好，如果能够将它们配对起来会更好

14
00:00:35,440 --> 00:00:37,320
并说出哪个是哪个。

15
00:00:37,480 --> 00:00:42,920
有一个非常有用的 Python 函数，名为 zip，值得了解。

16
00:00:42,920 --> 00:00:49,640
它就像一个专业的东西使用，你可以像这样一起迭代这两个集合

17
00:00:49,640 --> 00:00:55,120
我可以说看看哈哈，我在这里做什么？

18
00:00:55,160 --> 00:00:56,160
我只是按 Tab 键。

19
00:00:56,440 --> 00:00:59,400
您可以为竞争对手说出并回答。

20
00:00:59,400 --> 00:01:03,410
这是我们希望通过竞争对手和答案进行迭代的两个问题。

21
00:01:03,450 --> 00:01:09,290
如果您说 zip 竞争对手的答案，那么它只会一起迭代这两个列表。

22
00:01:09,290 --> 00:01:12,850
竞争对手和答案将各有其一。

23
00:01:12,850 --> 00:01:13,930
并且它已经写好了所有的代码。

24
00:01:13,930 --> 00:01:15,650
对我来说，这正是我想做的。

25
00:01:15,650 --> 00:01:20,970
因此，如果我现在这样做，您会看到它正在依次打印每个竞争对手及其答案。

26
00:01:21,010 --> 00:01:21,850
很不错。

27
00:01:22,250 --> 00:01:26,810
好的，但是让我们将它们组合成一个字符串，称为 Together。

28
00:01:27,410 --> 00:01:30,290
我还想在这里展示另一个称为枚举的结构。

29
00:01:30,290 --> 00:01:36,570
如果您有一个类似答案的列表，一个事物列表，并且您想要迭代它们，但您也

30
00:01:36,610 --> 00:01:42,290
想要像你一样跟踪索引号，你可能喜欢不了解枚举的人

31
00:01:42,330 --> 00:01:44,290
通常有一种计数等于零。

32
00:01:44,330 --> 00:01:46,330
在循环中计数加等于一。

33
00:01:46,370 --> 00:01:47,010
不需要。

34
00:01:47,050 --> 00:01:53,730
枚举是一个很好的小技巧，你可以用索引、逗号、枚举答案中的答案来表示，然后

35
00:01:53,730 --> 00:01:55,090
您只需迈出一步即可。

36
00:01:55,290 --> 00:01:57,650
所以我们会说竞争对手的回应。

37
00:01:57,650 --> 00:02:02,620
我们将在索引中添加一个，以便第一个是第一名竞争对手，而不是

38
00:02:02,660 --> 00:02:05,020
零号竞争对手，这听起来不太好。

39
00:02:05,220 --> 00:02:11,180
所以我们运行它，然后呃，我为什么不直接向你展示它是什么样子呢？

40
00:02:11,180 --> 00:02:12,860
但我确信你相信我。

41
00:02:13,940 --> 00:02:16,940
看起来像这样。

42
00:02:17,180 --> 00:02:20,740
如果我打印它，我们会发现它看起来比那更令人愉快。

43
00:02:21,340 --> 00:02:22,260
干得好。

44
00:02:22,540 --> 00:02:24,060
这样你就可以看到响应。

45
00:02:24,100 --> 00:02:24,700
哦，看看那个。

46
00:02:24,700 --> 00:02:25,820
有一个错误。

47
00:02:26,660 --> 00:02:27,140
也罢。

48
00:02:27,140 --> 00:02:28,020
我确实打印了，不是吗？

49
00:02:28,020 --> 00:02:30,100
这就是打印这些东西的好处。

50
00:02:30,100 --> 00:02:33,460
你这样做，然后你就会看到，呃，看看发生了什么。

51
00:02:33,500 --> 00:02:33,900
哇。

52
00:02:34,980 --> 00:02:35,620
好的。

53
00:02:35,820 --> 00:02:36,900
我希望你能抓住这一点。

54
00:02:36,900 --> 00:02:37,740
那就尴尬了。

55
00:02:37,740 --> 00:02:38,900
但我想我会保留它。

56
00:02:38,900 --> 00:02:44,420
所以你会发现，呃，人们不仅会犯错误，而且这为你提供了一种很好的方法

57
00:02:44,460 --> 00:02:46,700
检查正在发生的事情并看看发生了什么。

58
00:02:46,900 --> 00:02:50,140
因此，当我现在打印该内容时，我们会看到竞争对手一的回应。

59
00:02:50,460 --> 00:02:53,700
大概在下面它会得到第二个竞争对手的回应。

60
00:02:54,380 --> 00:02:55,220
好的。

61
00:02:55,540 --> 00:02:58,020
现在我们将有一段新的文本。

62
00:02:58,060 --> 00:03:01,820
你正在评判这么多竞争对手之间的竞争。

63
00:03:02,020 --> 00:03:04,380
每个模型都被提出了这个问题。

64
00:03:04,900 --> 00:03:07,740
您的工作是评估每个回复。

65
00:03:07,740 --> 00:03:09,060
还有就是。

66
00:03:09,380 --> 00:03:17,940
我们说我们希望您以 JSON 格式且仅以 JSON 格式进行响应，并遵循此格式的 JSON 以及结果和

67
00:03:17,940 --> 00:03:22,460
然后是竞争对手编号、第二最佳竞争对手编号、第三最佳竞争对手编号，依此类推。

68
00:03:23,060 --> 00:03:24,700
这是竞争对手的结果。

69
00:03:24,700 --> 00:03:29,820
现在用 JSON 响应竞争对手的排名顺序。

70
00:03:29,820 --> 00:03:30,860
没有别的了。

71
00:03:30,900 --> 00:03:33,780
请勿包含数字格式或代码块。

72
00:03:34,500 --> 00:03:36,460
关于这一点，有几点需要指出。

73
00:03:36,620 --> 00:03:40,740
首先，你可能对三重引号不熟悉。

74
00:03:40,780 --> 00:03:46,500
如果在 Python 字符串中使用三引号，则无需使用三引号即可获得整个文本块

75
00:03:46,500 --> 00:03:48,420
很多引号和优点之类的东西。

76
00:03:48,420 --> 00:03:51,220
所以对于文本块来说这是一个很好的技巧。

77
00:03:51,260 --> 00:03:55,420
当然，它也用于 for for 文档字符串，所以我相信您以前已经遇到过它。

78
00:03:55,980 --> 00:04:01,430
另一件需要知道的事情是，我假设您以前熟悉 f 字符串，但有一个很好的

79
00:04:01,430 --> 00:04:07,990
要知道的技巧是，如果您确实想在字符串中包含大括号，那么您可以这样做

80
00:04:07,990 --> 00:04:11,590
通过在 F 字符串中包含两个花括号来实现。

81
00:04:11,590 --> 00:04:17,870
这就是为什么这里有两个大括号，因为我们实际上希望一个大括号出现在

82
00:04:17,870 --> 00:04:18,990
字符串本身。

83
00:04:18,990 --> 00:04:19,350
我们不是。

84
00:04:19,350 --> 00:04:21,670
我们不希望我们不希望它被解释为代码。

85
00:04:22,350 --> 00:04:23,070
好的。

86
00:04:23,310 --> 00:04:30,270
因此，如果我打印这个来告诉你我到底在喋喋不休，你应该做什么

87
00:04:30,270 --> 00:04:33,510
看看您正在评判六名参赛者之间的比赛。

88
00:04:33,510 --> 00:04:35,470
每个模型都被提出了这个问题。

89
00:04:35,630 --> 00:04:37,430
你的工作是评估。

90
00:04:37,710 --> 00:04:40,670
以下是如何向我们提供结果。

91
00:04:40,670 --> 00:04:42,750
以下是每个人的回应。

92
00:04:42,950 --> 00:04:49,070
你在那里看到了，我还要提到你在最后看到的，我说不包括

93
00:04:49,070 --> 00:04:51,670
Markdown 格式或代码块。

94
00:04:51,710 --> 00:04:52,910
这样做总是值得的。

95
00:04:52,910 --> 00:04:58,720
否则，这些模型喜欢在事物周围添加一些额外的 JSON 标签。

96
00:04:58,720 --> 00:05:03,440
因此，如果您使用此文本，那么您将确保获得纯 JSON。

97
00:05:03,480 --> 00:05:08,760
好的，现在我们已经完成了所有设置，我们将把它放入消息中。

98
00:05:08,760 --> 00:05:11,880
然后我们将调用 LM 并获取结果。

99
00:05:12,040 --> 00:05:12,880
让我们这样做吧。

100
00:05:13,440 --> 00:05:13,880
好的。

101
00:05:13,920 --> 00:05:15,000
审判时间到了。

102
00:05:15,000 --> 00:05:21,960
因此，我们将像往常一样将这个判断文本放入具有正常结构的消息列表中。

103
00:05:22,240 --> 00:05:24,680
现在让我们选择一位法官。

104
00:05:24,680 --> 00:05:29,600
因此，我认为 O3 mini 比其他一些产品贵一点。

105
00:05:29,640 --> 00:05:31,120
所以他们应该检查牛皮纸排行榜。

106
00:05:31,120 --> 00:05:33,680
您可能只想选择便宜的。

107
00:05:33,880 --> 00:05:37,200
就像使用 GPT 4 或 mini 一样。

108
00:05:37,200 --> 00:05:41,120
我会选择 O3 mini，因为我们会尝试做一些真正引人注目的东西

109
00:05:41,120 --> 00:05:41,640
对此。

110
00:05:41,640 --> 00:05:48,280
现在，我意识到列表中的第一个竞争对手是 GPT 4 mini，所以它有点 - 那

111
00:05:48,280 --> 00:05:50,920
一些相同的 OpenAI 模型正在自我评价。

112
00:05:50,960 --> 00:05:55,440
看看它是否认为来自自己家族的模型是赢家将会很有趣，

113
00:05:55,480 --> 00:06:00,090
我们不会告诉它型号名称，我们只会给它一个排名号码，所以它不会

114
00:06:00,130 --> 00:06:00,450
知道。

115
00:06:00,450 --> 00:06:02,330
那么我们来看看第一名的票价如何。

116
00:06:02,370 --> 00:06:04,130
事实上，一号的答案看起来确实很好。

117
00:06:04,170 --> 00:06:05,450
所以它可能会做得很好。

118
00:06:05,450 --> 00:06:06,170
我们会看到。

119
00:06:06,450 --> 00:06:09,930
但我们让 O3 mini 来决定。

120
00:06:09,970 --> 00:06:11,570
让我们看看它是如何实现的。

121
00:06:12,770 --> 00:06:13,530
关了就走了。

122
00:06:13,530 --> 00:06:14,730
它正在考虑这个问题。

123
00:06:15,450 --> 00:06:16,730
这需要时间。

124
00:06:16,770 --> 00:06:17,850
它正在做一些推理。

125
00:06:17,850 --> 00:06:19,370
这就是答案。

126
00:06:19,370 --> 00:06:24,730
所以它并没有把呃 GPT 4 mini 放在首位。

127
00:06:24,770 --> 00:06:25,850
它把型号放在第三位。

128
00:06:25,850 --> 00:06:31,210
你可能还记得第二号人工智能模型是呃，第三号人类模型，我忘了。

129
00:06:31,210 --> 00:06:32,130
这是深度联盟吗？

130
00:06:32,170 --> 00:06:33,450
我们很快就会知道。

131
00:06:33,490 --> 00:06:40,290
所以我们现在要，呃，加载这个，它已经按照我们想要的那样以完美的 JSON 形式返回。

132
00:06:40,290 --> 00:06:42,130
我们将把它加载到字典中。

133
00:06:42,130 --> 00:06:44,010
我们将提取结果。

134
00:06:44,010 --> 00:06:45,690
所以现在我们要得到这个。

135
00:06:45,730 --> 00:06:50,010
我们将再次使用这种枚举方法来迭代它。

136
00:06:50,170 --> 00:06:59,060
对于每一个，我们都会查看这个字符串，然后减去一，然后在竞争对手列表中查找

137
00:06:59,060 --> 00:07:00,220
并打印结果。

138
00:07:00,220 --> 00:07:06,700
所以如果你关注我的话，这只会从最好到最差打印出模型的名称

139
00:07:06,700 --> 00:07:07,860
在我们的结果中。

140
00:07:07,900 --> 00:07:09,220
请打鼓。

141
00:07:09,540 --> 00:07:10,420
开始了。

142
00:07:10,860 --> 00:07:13,300
所以这是双子座二零闪。

143
00:07:13,340 --> 00:07:14,300
那是我们的赢家。

144
00:07:14,540 --> 00:07:16,540
GPT 4 mini 排名第二。

145
00:07:16,740 --> 00:07:21,060
Llama 3.3 位居第三，然后是 Deep Seek，然后是 Claude 3.7。

146
00:07:21,060 --> 00:07:24,780
但排名垫底的是“flailing llama 3.2”。

147
00:07:24,820 --> 00:07:26,100
就这样半途而废了。

148
00:07:26,300 --> 00:07:31,100
所以出现了我们判断的不科学的结果。

149
00:07:31,140 --> 00:07:35,620
当然，如果你能够以更科学的方式尝试这一点，将会非常有趣。

150
00:07:35,660 --> 00:07:40,660
例如，您可以让每个不同的竞争对手给出排名，然后使用

151
00:07:40,660 --> 00:07:42,020
取平均值。

152
00:07:42,020 --> 00:07:46,700
这种评估方式比简单地使用更有趣

153
00:07:46,700 --> 00:07:48,700
无论《哦三迷你》告诉我们什么。

154
00:07:48,780 --> 00:07:56,110
所以无论如何，这是一个非常有趣的实验，旨在向您展示如何在

155
00:07:56,110 --> 00:07:56,790
学习管理系统。

156
00:07:57,630 --> 00:08:02,430
所以希望你在这堂课和上一堂课中都集中注意力，并且你已经能够识别出

157
00:08:02,590 --> 00:08:07,950
本示例中使用了哪些代理工作流程模式。

158
00:08:07,990 --> 00:08:09,150
图案还是图案？

159
00:08:09,350 --> 00:08:10,630
可能有一对。

160
00:08:10,670 --> 00:08:14,510
如果您不确定，请回顾一下并思考并回顾图表。

161
00:08:14,510 --> 00:08:19,750
它可能是其中几个与适合您的练习之间的某种混合体或大杂烩。

162
00:08:19,750 --> 00:08:21,030
首先，这样做。

163
00:08:21,030 --> 00:08:26,750
其次，请选择您感兴趣的模式之一并将其添加到此组合中。

164
00:08:27,070 --> 00:08:29,750
该实验室的目标是双重的。

165
00:08:29,750 --> 00:08:35,790
首先，尝试不同的 API，亲眼看看 OpenAI API 是如何使用的

166
00:08:35,790 --> 00:08:41,310
经常跨越许多模型，除了人择模型，并且还尝试使用

167
00:08:41,310 --> 00:08:43,030
基本 API 结构和提示。

168
00:08:43,270 --> 00:08:48,670
第二个目标是试验模型之间的这种编排，提出问题，

169
00:08:48,670 --> 00:08:55,430
多个模型回答，让另一个模型来评估输出所有这些都是关于交互的

170
00:08:55,430 --> 00:09:00,630
在模型之间，将一个更大的问题划分为更小的问题，并且在模型中具有一点自主权

171
00:09:00,630 --> 00:09:04,150
提出第一个模型想要提出的任何问题。

172
00:09:04,590 --> 00:09:08,950
所以，呃，是的，添加另一种代理设计模式。

173
00:09:08,950 --> 00:09:10,270
我很想看看。

174
00:09:10,270 --> 00:09:16,230
一旦你做到了这一点，就可以考虑做一个 PR 并将其放入社区贡献中。

175
00:09:16,230 --> 00:09:18,910
资源中会有关于如何执行此操作的说明。

176
00:09:18,950 --> 00:09:23,550
一个很好的提示是，请注意在执行此操作之前删除笔记本的输出。

177
00:09:23,550 --> 00:09:25,590
所以里面没有太多垃圾。

178
00:09:25,590 --> 00:09:29,150
并确保您只将内容推送到社区贡献文件夹中。

179
00:09:29,190 --> 00:09:30,110
会有指示的。

180
00:09:30,110 --> 00:09:35,550
看到你正在做的事情，并看到一些有趣的设计模式添加到其中，真是太棒了

181
00:09:35,590 --> 00:09:37,150
这种练习。

182
00:09:37,590 --> 00:09:41,470
该实验室的最终想法是商业影响。

183
00:09:41,470 --> 00:09:47,470
我确实想始终把它带回到你如何能够，如何在商业环境中思考这个问题。

184
00:09:47,630 --> 00:09:54,800
老实说，我很难在这里具体说明，因为这是普遍适用的。

185
00:09:55,000 --> 00:10:00,440
事实上，任何时候你想要生成一些东西，你都希望 LM 能够

186
00:10:00,480 --> 00:10:03,040
照顾这些类型的模式。

187
00:10:03,080 --> 00:10:09,480
能够向多个 LMS 发送相同的请求，然后能够评估响应，或者

188
00:10:09,520 --> 00:10:14,680
选择最好的或者可能选择几个最好的，或者用它来提供反馈。

189
00:10:14,920 --> 00:10:21,800
所有这些类型的模式都用于提高模型的鲁棒性和准确性，并

190
00:10:21,800 --> 00:10:24,520
能够解决越来越难的问题。

191
00:10:24,640 --> 00:10:28,520
正如我所说，这确实是普遍适用的。

192
00:10:28,520 --> 00:10:33,000
所以你应该能够选择你能想到的应用人工智能的任何商业问题，

193
00:10:33,280 --> 00:10:38,920
无论是总结型问题还是生成型问题，写一封电子邮件，构建一个

194
00:10:38,920 --> 00:10:41,360
文档，编写业务需求文档。

195
00:10:41,360 --> 00:10:44,760
您可以考虑如何应用这些技术。

196
00:10:44,800 --> 00:10:46,560
将请求发送到多个模型。

197
00:10:46,600 --> 00:10:48,480
投票选出最佳结果。

198
00:10:48,480 --> 00:10:52,040
您应该能够立即将其应用到您的项目中。