1
00:00:00,080 --> 00:00:00,560
好的。

2
00:00:00,560 --> 00:00:01,760
所以我们进入第八周。

3
00:00:01,800 --> 00:00:03,000
我们进入第三天。

4
00:00:03,360 --> 00:00:06,640
欢迎来到“价格合适”的下一部分。

5
00:00:06,840 --> 00:00:10,240
我们已经建立了我们的专业代理，我们的整体代理。

6
00:00:10,280 --> 00:00:13,920
现在我们要构建我们的扫描仪，我运行一些导入。

7
00:00:14,200 --> 00:00:18,680
现在，这是我编写的一些代码，用于抓取 RSS 提要并解析结果。

8
00:00:18,680 --> 00:00:20,640
让我开始吧，然后展示给你看。

9
00:00:20,680 --> 00:00:22,360
这是一些基本的东西。

10
00:00:22,400 --> 00:00:24,080
没有什么关于它的。

11
00:00:24,320 --> 00:00:25,120
这是在交易中。

12
00:00:25,120 --> 00:00:26,440
点 py 就在这里。

13
00:00:26,920 --> 00:00:29,360
首先指定一些 RSS 提要。

14
00:00:29,360 --> 00:00:34,920
我从 DealNews.com 购买了一份电子产品、电脑和智能家居优惠。

15
00:00:35,040 --> 00:00:37,480
这是汽车和家庭卫士的另一对夫妇。

16
00:00:37,480 --> 00:00:39,040
如果你愿意的话，你也可以加入。

17
00:00:39,080 --> 00:00:41,080
您还可以添加任何您想要的 RSS 提要。

18
00:00:41,240 --> 00:00:48,040
我使用一个名为 Feedparser 的库，这是一个解析 RSS 提要的开源库，非常简单

19
00:00:48,040 --> 00:00:48,920
读入它们。

20
00:00:49,120 --> 00:00:51,760
我只取每一项中的前十项。

21
00:00:51,760 --> 00:00:56,280
如果你想要更多的话，你可以把这个数字提出来，但这似乎是一个不错的选择

22
00:00:56,280 --> 00:00:56,800
要做的事。

23
00:00:57,160 --> 00:01:03,470
呃，然后我读了它们，然后我还访问了实际描述该交易的网站，

24
00:01:03,470 --> 00:01:06,390
我也从中吸取了尽可能多的数据。

25
00:01:06,390 --> 00:01:12,750
所以我们最终得到了一些与这笔交易相关的非结构化数据，这就是我们所得到的，

26
00:01:12,910 --> 00:01:14,030
呃，在这里。

27
00:01:14,230 --> 00:01:18,670
嗯，它已加载并运行这三个 RSS 提要。

28
00:01:18,870 --> 00:01:23,270
如果我看一下这个，我们有 30 笔交易，因为这是三组，每组 10 笔交易。

29
00:01:23,270 --> 00:01:26,150
如果我随机选择一个，让我们看看第十笔交易。

30
00:01:26,350 --> 00:01:27,110
这里是。

31
00:01:27,270 --> 00:01:34,430
这是戴尔网络星期一游戏优惠，有大量相关内容以及优惠本身的链接。

32
00:01:34,590 --> 00:01:37,510
呃，这就是我们刮下来的。

33
00:01:37,550 --> 00:01:38,190
好的。

34
00:01:38,630 --> 00:01:42,630
这里就是肉发生的地方。

35
00:01:43,030 --> 00:01:44,510
我有系统提示。

36
00:01:45,230 --> 00:01:50,270
您通过选择交易，等等，从列表中识别并总结五个最详细的交易，

37
00:01:50,270 --> 00:01:50,910
巴拉，巴拉，巴拉。

38
00:01:51,190 --> 00:01:56,030
我告诉它要小心那些被描述为有一定折扣或减少的产品。

39
00:01:56,070 --> 00:02:02,630
这不是您需要回复的实际价格，等等等等以及非常相似的用户提示，我是

40
00:02:02,630 --> 00:02:08,750
告诉它，你会得到一个项目列表，你需要用五个最有前途的交易来回应。

41
00:02:08,950 --> 00:02:12,750
不要被那些说可以减 1,000 美元的东西分散注意力。

42
00:02:12,790 --> 00:02:15,230
重要的是实际价格本身。

43
00:02:15,510 --> 00:02:19,630
显然我这么说是因为我已经尝试过，我尝试过不同的提示。

44
00:02:19,630 --> 00:02:21,710
它在不同方面都存在不足。

45
00:02:21,710 --> 00:02:25,230
有时它会被用来混淆交易的折扣金额。

46
00:02:25,390 --> 00:02:26,750
我就是这样来到这里的。

47
00:02:26,750 --> 00:02:30,070
有时我将其呈现为好像这是我输入的第一件事。

48
00:02:30,070 --> 00:02:30,990
事实并非如此。

49
00:02:31,030 --> 00:02:36,030
对于此类项目非常重要，您愿意卷起袖子进行尝试

50
00:02:36,030 --> 00:02:38,910
按照提示进行操作，直到获得您想要的性能。

51
00:02:39,230 --> 00:02:43,630
好的，这就是系统提示符和用户提示符，呃，前缀。

52
00:02:43,950 --> 00:02:46,750
现在我要发出用户提示。

53
00:02:46,750 --> 00:02:48,590
这里会有这个前缀。

54
00:02:48,790 --> 00:02:54,350
然后它将是我们抓取的所有 30 条内容的内容。

55
00:02:54,470 --> 00:02:57,390
所以我们正在制作一个包含此说明的提示。

56
00:02:57,390 --> 00:02:58,710
然后它有这个指令。

57
00:02:58,710 --> 00:03:01,190
然后里面有 30 种不同的东西。

58
00:03:01,190 --> 00:03:05,700
然后在底部会说仅包含五笔交易，仅此而已。

59
00:03:05,940 --> 00:03:07,460
所以让我们加载它。

60
00:03:07,700 --> 00:03:11,100
现在我们来实现这个功能，呃，使用提示。

61
00:03:11,100 --> 00:03:12,580
那么让我向您展示它是什么样子的。

62
00:03:12,580 --> 00:03:15,820
我们将只显示它的前 2000 个字符。

63
00:03:16,020 --> 00:03:17,780
呃，它看起来是这样的。

64
00:03:17,940 --> 00:03:22,500
回应列表中最有希望的五笔交易，等等。

65
00:03:22,700 --> 00:03:24,060
这是优惠。

66
00:03:24,060 --> 00:03:27,380
到目前为止，每个人都拼写得很好。

67
00:03:27,860 --> 00:03:28,900
完全有道理，对吧？

68
00:03:28,900 --> 00:03:29,940
我们只是说说而已。

69
00:03:29,980 --> 00:03:32,420
我们希望您找到最有前途的五笔交易。

70
00:03:32,460 --> 00:03:34,940
还没有关于结构化输出的信息。

71
00:03:35,500 --> 00:03:36,340
好的。

72
00:03:36,340 --> 00:03:38,780
但现在是结构化输出。

73
00:03:39,220 --> 00:03:46,340
通常我会让 OpenAI 创建一些你现在非常了解的东西 OpenAI

74
00:03:47,460 --> 00:03:50,580
创建，但我没有，我有 OpenAI。

75
00:03:53,620 --> 00:03:55,180
有所不同。

76
00:03:55,180 --> 00:03:58,580
这就是您描述结构化输出的方式。

77
00:03:58,900 --> 00:04:06,900
在这个解析函数中，它有常用的参数、模型名称、消息、推理

78
00:04:06,900 --> 00:04:09,980
你从很久以前就记得说“最小”的努力。

79
00:04:10,380 --> 00:04:11,900
但还有其他事情。

80
00:04:11,940 --> 00:04:17,180
有响应格式，我们在交易选择中传递这个东西。

81
00:04:17,180 --> 00:04:17,860
那是什么？

82
00:04:17,900 --> 00:04:22,620
嗯，这实际上是我导入的东西，在这个交易点 pi 中也结束了。

83
00:04:22,660 --> 00:04:24,460
让我们找到它的交易选择。

84
00:04:24,460 --> 00:04:26,940
它的名字叫呃，就在这里。

85
00:04:27,260 --> 00:04:29,660
它是基本模型的子类。

86
00:04:30,020 --> 00:04:34,300
这是一个只有一个领域交易的类别。

87
00:04:34,300 --> 00:04:38,940
该字段是交易对象的列表。

88
00:04:38,980 --> 00:04:43,540
所以 Deals 是 Deal Selection 有 Deals 的，它是 Deal 对象的列表。

89
00:04:43,540 --> 00:04:47,700
你会看到这里这是迂腐的，我是说它有一个叫做交易的字段。

90
00:04:47,700 --> 00:04:50,220
你可以用英语描述它。

91
00:04:50,220 --> 00:04:55,860
因此，我将描述您选择的具有最详细的高质量描述的五笔交易

92
00:04:55,860 --> 00:04:57,420
以及最清晰的价格。

93
00:04:57,460 --> 00:05:00,300
您应该确信价格反映了交易。

94
00:05:00,300 --> 00:05:02,900
有了清晰的描述就很好了。

95
00:05:03,300 --> 00:05:03,580
好的。

96
00:05:03,690 --> 00:05:05,810
那么这些交易对象分别是什么？

97
00:05:06,010 --> 00:05:10,730
每个都有产品描述、价格和 URL。

98
00:05:10,970 --> 00:05:14,570
它所说的产品描述清楚地表达了产品的摘要。

99
00:05:14,570 --> 00:05:17,090
描述为实际价格。

100
00:05:17,170 --> 00:05:18,970
一定要给出实际价格。

101
00:05:18,970 --> 00:05:19,330
进而。

102
00:05:19,330 --> 00:05:23,890
然后你就会知道，如果交易价格为 500 美元减 100 美元，那么你应该给出 400 美元。

103
00:05:24,050 --> 00:05:27,010
然后是提供的 URL。

104
00:05:27,490 --> 00:05:34,930
这就是我们如何定义一个迂腐的结构，一个包含交易的交易选择对象，其中

105
00:05:34,930 --> 00:05:38,970
是该对象的多个，包含描述、价格和 URL。

106
00:05:39,250 --> 00:05:44,690
这里要注意的关键是我们不仅描述了这个 JSON 模式，而且我们还得到了一些

107
00:05:44,690 --> 00:05:53,450
语言来解释如何填充每个字段，这就是我们现在能够

108
00:05:53,490 --> 00:05:56,370
进行此结构化输出调用。

109
00:05:56,410 --> 00:06:02,090
为了让这对你来说是真实的，我只是想向你展示如此优惠的选择，这就是这个

110
00:06:02,090 --> 00:06:03,130
是一个类。

111
00:06:03,330 --> 00:06:06,130
这是我在代理选择中定义的。

112
00:06:06,130 --> 00:06:07,330
我们只是看着它。

113
00:06:07,370 --> 00:06:10,690
这是因为它是一个迂腐的类，是基本模型的子类。

114
00:06:10,690 --> 00:06:13,050
它继承了一些功能。

115
00:06:13,090 --> 00:06:15,250
其中之一是我可以调用模型。

116
00:06:15,450 --> 00:06:16,370
模型。

117
00:06:16,490 --> 00:06:19,370
嗯，呃，抱歉。

118
00:06:19,410 --> 00:06:20,210
模型。

119
00:06:21,730 --> 00:06:24,610
呃，架构一下这个。

120
00:06:24,890 --> 00:06:32,770
现在，当我运行此命令时，我们可以看到关联的 JSON 模式的 JSON 描述

121
00:06:32,770 --> 00:06:33,730
与这个物体。

122
00:06:33,730 --> 00:06:39,770
系统提示中向 OpenAI 提供的正是这种模式，对 GPT 说

123
00:06:39,770 --> 00:06:41,490
你必须遵守这个模式。

124
00:06:41,610 --> 00:06:50,410
这就是当我们调用 OpenAI 解析并且我们说响应格式是交易选择时的方式，

125
00:06:50,410 --> 00:06:54,370
它将返回一些符合该规范的 JSON。

126
00:06:54,770 --> 00:07:00,610
您已经习惯了我们看到的结果是响应点选择，零点消息内容。

127
00:07:00,770 --> 00:07:02,570
这不是我们这里所拥有的。

128
00:07:02,730 --> 00:07:05,360
这是响应零20...

129
00:07:06,760 --> 00:07:13,640
它的作用是获取内容和 JSON，并填充类型的对象

130
00:07:13,640 --> 00:07:15,800
处理选择。

131
00:07:15,800 --> 00:07:20,960
因此，如果我运行它，它就会将该 JSON 内容转换为某种模式。

132
00:07:21,120 --> 00:07:23,760
它正在调用 OpenAI 并显示此提示。

133
00:07:23,760 --> 00:07:24,320
确切地。

134
00:07:24,320 --> 00:07:29,840
此提示 OpenAI GPT 正在生成符合此架构的 JSON。

135
00:07:30,000 --> 00:07:38,160
返回的是一个交易选择对象，其中填充了返回的 JSON。

136
00:07:38,360 --> 00:07:43,400
所以如果你看这个东西，你会发现它是一个交易选择对象。

137
00:07:43,400 --> 00:07:46,600
它有一个叫做 Deals 的字段，每一个都是一笔交易。

138
00:07:46,600 --> 00:07:47,040
所以坚持住。

139
00:07:47,040 --> 00:07:56,960
如果我，如果我在这里添加一些代码，并且我说在结果点交易中进行交易，我们将完全执行光标的操作

140
00:07:56,960 --> 00:07:57,720
正在建议。

141
00:07:57,720 --> 00:07:58,520
看看这个。

142
00:07:58,520 --> 00:08:04,240
你可以看到我们有一个健身追踪器，呃，价格便宜得离谱，戴尔的

143
00:08:04,280 --> 00:08:06,880
16 加上这些东西中的每一个。

144
00:08:06,880 --> 00:08:11,040
这是一台售价 550 美元的戴尔笔记本电脑。

145
00:08:11,080 --> 00:08:12,520
看起来很划算。

146
00:08:12,720 --> 00:08:15,960
您可能会想，这款健身追踪器售价 15 美元。

147
00:08:15,960 --> 00:08:17,240
这听起来好得令人难以置信。

148
00:08:17,280 --> 00:08:18,560
好吧，我们可以仔细检查一下。

149
00:08:18,560 --> 00:08:20,440
这是 dealnews.com 的链接。

150
00:08:20,440 --> 00:08:23,520
这是我们的结构化输出中返回的 URL。

151
00:08:23,560 --> 00:08:25,680
让我们点击它，看看它出现了。

152
00:08:25,680 --> 00:08:26,520
确实是这样。

153
00:08:26,520 --> 00:08:29,680
这是我的 janky 代码抓取的网页。

154
00:08:29,680 --> 00:08:33,560
并且以非结构化格式将其发送到 GPT。

155
00:08:33,800 --> 00:08:36,600
我们发现它没有给我们 159。

156
00:08:36,600 --> 00:08:40,040
它给了我们 15 美元的超便宜价格。

157
00:08:40,120 --> 00:08:42,240
所以它完全正确。

158
00:08:42,280 --> 00:08:43,680
让我们在这里看看这个。

159
00:08:43,720 --> 00:08:47,560
550 美元确实是戴尔电脑的价格。

160
00:08:47,600 --> 00:08:49,680
出现很多卡顿的弹出窗口。

161
00:08:49,680 --> 00:08:51,600
所以效果很好。

162
00:08:51,600 --> 00:08:58,320
它解析了从互联网上抓取的非结构化数据，将其转化为迂腐的对象。

163
00:08:58,320 --> 00:09:01,280
它以符合架构的 JSON 进行响应。

164
00:09:01,320 --> 00:09:06,720
OpenAI 库将其变成了一个迂腐的对象，并且它已被正确填充。