1
00:00:00,120 --> 00:00:01,560
那么我们该如何去做呢？

2
00:00:01,560 --> 00:00:02,560
我们如何开始？

3
00:00:02,600 --> 00:00:08,160
好吧，开始这些调用的地方总是从考虑提示开始。

4
00:00:08,280 --> 00:00:15,400
我们想要发送什么输入序列到 LM 以允许它生成令牌，这些序列最有可能是

5
00:00:15,400 --> 00:00:17,120
来完成我们的任务？

6
00:00:17,400 --> 00:00:21,560
好的，我们首先考虑系统提示和用户提示。

7
00:00:21,840 --> 00:00:24,040
所以这里我已经写了一个系统提示。

8
00:00:24,040 --> 00:00:25,880
我不会把它打出来，因为要打的东西会很多。

9
00:00:25,920 --> 00:00:29,720
我在这里给大家演示一下，通过系统提示来讲一下。

10
00:00:29,920 --> 00:00:35,040
您将获得在网页上找到的链接列表。

11
00:00:35,200 --> 00:00:41,400
您可以决定哪些链接最适合包含在有关该产品的手册中

12
00:00:41,400 --> 00:00:47,720
公司，例如关于页面或公司页面或职业职位页面的链接。

13
00:00:48,040 --> 00:00:54,440
您应该像本示例中那样以 JSON 格式进行响应，并且有一些 JSON。

14
00:00:54,440 --> 00:00:56,160
如果您不熟悉 JSON，请 Google 一下。

15
00:00:56,160 --> 00:00:56,840
我确信你是。

16
00:00:57,720 --> 00:01:02,090
所以有一些 JSON Jason，它有我刚刚发明的这种结构。

17
00:01:02,090 --> 00:01:05,770
我刚刚发明了这种带有链接键的结构。

18
00:01:05,770 --> 00:01:10,690
然后其中有一个列表，每个链接都有一个类似“关于页面”的类型和一个 URL。

19
00:01:10,690 --> 00:01:11,770
还有一个网址。

20
00:01:12,610 --> 00:01:14,770
那么我为什么要发明一些 Jason.

21
00:01:14,930 --> 00:01:16,050
嗯，事情是这样的。

22
00:01:16,370 --> 00:01:23,570
这些语言模型已经用大量数据进行了训练，并且大部分数据都适合

23
00:01:23,570 --> 00:01:24,650
三个类别。

24
00:01:24,770 --> 00:01:28,050
它要么只是简单的英语。

25
00:01:28,050 --> 00:01:31,330
他们接受过大量英语或外语培训。

26
00:01:31,370 --> 00:01:32,370
他们训练了很多语言。

27
00:01:32,410 --> 00:01:34,210
我的意思是很多自然语言。

28
00:01:34,210 --> 00:01:36,570
这是很多自然语言中的词。

29
00:01:36,730 --> 00:01:37,850
大量的它。

30
00:01:38,050 --> 00:01:40,970
其次，他们接受过大量降价训练。

31
00:01:41,370 --> 00:01:43,090
网站变成了降价。

32
00:01:43,090 --> 00:01:46,130
Markdown 就像 HTML 的基本简写。

33
00:01:46,250 --> 00:01:47,690
他们接受过大量降价训练。

34
00:01:47,690 --> 00:01:50,170
所以他们喜欢 Markdown，也喜欢生成 Markdown。

35
00:01:50,170 --> 00:01:52,010
他们非常非常了解 Markdown。

36
00:01:52,010 --> 00:01:54,170
这是他们非常熟悉的结构。

37
00:01:54,290 --> 00:01:56,130
所以 Markdown 是他们所知道的。

38
00:01:56,130 --> 00:01:59,100
第三，他们接受了大量 JSON 的训练。

39
00:01:59,140 --> 00:02:00,780
他们经常看到 JSON。

40
00:02:00,780 --> 00:02:07,020
因此，当您向 LLM 发送结构化信息时，JSON 是很自然的东西，如果

41
00:02:07,020 --> 00:02:13,100
你使用 JSON，它会变得连贯，它会识别它并且它会计算

42
00:02:13,100 --> 00:02:14,220
知道你在做什么。

43
00:02:14,380 --> 00:02:20,780
这就是为什么要给它一个漂亮、令人愉悦的 JSON 结构，让人感觉有条理并代表

44
00:02:20,780 --> 00:02:22,340
以我们想要的方式获取信息。

45
00:02:22,380 --> 00:02:24,500
我想要每个链接都有一个类型。

46
00:02:24,540 --> 00:02:27,220
这是另一件难以想象的编码事情。

47
00:02:27,220 --> 00:02:33,060
您如何编写一种方法来为每种链接设置标题，然后在该链接的 URL 处设置标题

48
00:02:33,060 --> 00:02:33,540
关联。

49
00:02:34,340 --> 00:02:41,460
因此，表达您想要返回的信息的一个好方法是为其提供 JSON 结构。

50
00:02:41,620 --> 00:02:46,900
在过去，人们常常尝试说，你知道，用这个和第一颗子弹来回复

51
00:02:46,900 --> 00:02:49,260
一些信息，第二个项目符号包含一些信息。

52
00:02:49,260 --> 00:02:54,420
试图描述某种布置数据的方式确实很做作。

53
00:02:54,460 --> 00:02:56,870
使用 JSON 更好。

54
00:02:57,030 --> 00:03:02,150
在第八周，我们将使用一种称为结构化输出的东西，这为我们提供了一种方法

55
00:03:02,190 --> 00:03:08,630
强制 JSON 专注于特定规范，满足模式。

56
00:03:09,030 --> 00:03:09,950
我们不会在这里讨论这个。

57
00:03:09,950 --> 00:03:11,230
我们现在就先介绍一下。

58
00:03:11,230 --> 00:03:19,150
仅仅给出一个例子并给出可能答案的例子有时被称为一次性提示。

59
00:03:19,150 --> 00:03:21,350
如果你举一个例子，那就是一击。

60
00:03:21,390 --> 00:03:27,150
如果你给出多个例子，理论上来说就是多重提示，要严格正确地做到这一点，

61
00:03:27,150 --> 00:03:31,350
多次提示是指您给出一个示例问题，然后给出一个很好的答案。

62
00:03:31,350 --> 00:03:33,790
然后是另一个问题，然后是一个很好的答案。

63
00:03:33,830 --> 00:03:37,750
仅仅给出多个答案基本上也类似于多次提示。

64
00:03:37,750 --> 00:03:40,070
所以在这种情况下，我们正在进行单次提示。

65
00:03:40,070 --> 00:03:41,630
我们举一个例子。

66
00:03:41,630 --> 00:03:47,390
我们的意思是，鉴于这个例子，从中学习，复制它，那就会好起来的

67
00:03:47,390 --> 00:03:47,910
在它。

68
00:03:48,070 --> 00:03:53,350
请记住，它所做的就是将其作为输入并生成最有可能的

69
00:03:53,350 --> 00:03:54,960
接下来的令牌。

70
00:03:54,960 --> 00:04:01,120
碰巧接下来最有可能出现的代币基本上都是实际的东西

71
00:04:01,120 --> 00:04:02,520
我们确实希望它接下来出现。

72
00:04:02,520 --> 00:04:07,720
它将解析我们的输入并得出此信息作为输出。

73
00:04:07,760 --> 00:04:08,160
好的。

74
00:04:08,200 --> 00:04:10,760
这就是我们的系统提示链接系统提示。

75
00:04:10,760 --> 00:04:12,400
这叫没事。

76
00:04:12,440 --> 00:04:14,320
现在不用担心，我马上就可以输入一些内容。

77
00:04:14,320 --> 00:04:16,640
如果你想为什么他没有我会的类型，我会的。

78
00:04:16,640 --> 00:04:19,320
接下来是用户提示。

79
00:04:19,320 --> 00:04:23,160
所以这一次我只是把它作为一个变量，因为它总是准确无误

80
00:04:23,160 --> 00:04:23,760
同样的事情。

81
00:04:23,800 --> 00:04:24,880
链接系统提示。

82
00:04:24,880 --> 00:04:31,120
我将这个作为一个函数，因为每次传递 URL 时我们都会生成一个用户提示

83
00:04:31,120 --> 00:04:31,480
在。

84
00:04:31,720 --> 00:04:34,280
因此，将会出现一个 URL，我们将发出用户提示。

85
00:04:34,280 --> 00:04:35,360
这就是它要说的。

86
00:04:35,760 --> 00:04:40,720
以下是网站 URL 上的链接列表。

87
00:04:41,080 --> 00:04:46,520
请确定其中哪些是与该公司宣传册相关的网页链接。

88
00:04:46,560 --> 00:04:51,480
使用 JSON 格式的完整 https url 进行响应。

89
00:04:51,520 --> 00:04:55,570
请勿包含服务条款、隐私和电子邮件链接。

90
00:04:55,970 --> 00:04:58,050
这是不该做的事情的一个例子。

91
00:04:58,090 --> 00:05:02,330
几乎与一击提示相反，这些都是糟糕的答案。

92
00:05:02,530 --> 00:05:06,370
你可以想象我把它放在那里是因为它包括了他们。

93
00:05:06,410 --> 00:05:07,490
这很常见。

94
00:05:07,530 --> 00:05:13,210
我的意思是，也许你在整个课程中学到的最重要的事情就是

95
00:05:13,250 --> 00:05:16,970
从法学硕士获得好的结果就是实验和迭代。

96
00:05:17,050 --> 00:05:19,330
这都是关于实验的。

97
00:05:19,330 --> 00:05:22,130
这就是成为一名优秀的法学硕士工程师所需要的。

98
00:05:22,130 --> 00:05:25,930
这是关于成为一名优秀的数据科学家以及成为一名优秀的工程师。

99
00:05:26,090 --> 00:05:31,730
数据科学就是实验，要获得良好的结果，没有比保持数据更好的方法了。

100
00:05:31,730 --> 00:05:33,130
完善您的提示。

101
00:05:33,130 --> 00:05:38,930
因此，如果您这样做并且它开始生成隐私政策作为它认为是相关的链接，您

102
00:05:38,970 --> 00:05:41,970
回来后你说不包括隐私政策。

103
00:05:41,970 --> 00:05:44,970
你迭代、改进、添加示例。

104
00:05:44,970 --> 00:05:46,890
这就是获得伟大成果的方法。

105
00:05:47,330 --> 00:05:52,450
所以我当然会调用获取网站链接。

106
00:05:52,450 --> 00:05:55,930
这就是我刚刚向您展示的获取此 URL 的所有链接的函数。

107
00:05:55,930 --> 00:06:01,610
然后在这个用户提示中我添加每个链接，这就是我返回的内容。

108
00:06:01,650 --> 00:06:03,370
好吧，让我们运行这个。

109
00:06:03,370 --> 00:06:05,570
让我们运行获取链接用户提示。

110
00:06:05,850 --> 00:06:09,170
让我们为爱德华·康姆做这件事吧。

111
00:06:09,210 --> 00:06:10,890
让我们看看用户提示什么。

112
00:06:10,890 --> 00:06:12,450
再说一次，我们还没有召集法学硕士。

113
00:06:12,450 --> 00:06:13,690
这里不涉及人工智能。

114
00:06:13,690 --> 00:06:17,890
我们只是烘焙一个用户提示，然后我们将用 LLM 调用该提示。

115
00:06:17,930 --> 00:06:18,730
让我们看看它怎么说。

116
00:06:18,730 --> 00:06:21,490
它说这是网站上的链接列表。

117
00:06:22,610 --> 00:06:26,130
请决定其中哪些与公司宣传册相关。

118
00:06:26,170 --> 00:06:27,450
使用完整的 https 进行响应。

119
00:06:27,450 --> 00:06:27,770
不要。

120
00:06:27,810 --> 00:06:29,250
这正是我们刚才看到的。

121
00:06:29,250 --> 00:06:31,250
这里是列出的链接。

122
00:06:31,290 --> 00:06:32,170
这就是我所做的一切。

123
00:06:32,170 --> 00:06:37,450
我已经构建了这个字符串，构建该字符串的代码位于此函数获取链接用户提示中。

124
00:06:37,650 --> 00:06:41,970
所以我们现在有链接系统提示和获取链接用户提示。

125
00:06:41,970 --> 00:06:46,370
所以我们终于准备好进行我们的第一次人工智能通话了。

126
00:06:46,370 --> 00:06:47,770
这将是这个功能。

127
00:06:47,770 --> 00:06:50,580
选择相关链接。

128
00:06:50,740 --> 00:06:52,420
好吧，让我们这样做吧。

129
00:06:52,420 --> 00:06:56,220
这就是聊天完成 API。

130
00:06:56,540 --> 00:07:02,060
所以请记住你这样做的方式是你从我们需要确保我们实际上已经创建了一个

131
00:07:02,060 --> 00:07:03,220
OpenAI 的实例。

132
00:07:03,260 --> 00:07:04,540
我们在这儿做过吗？

133
00:07:04,540 --> 00:07:07,140
让我们检查一下 Python 客户端库。

134
00:07:07,180 --> 00:07:10,140
一路往回走，一路往回走。

135
00:07:10,180 --> 00:07:10,940
是的，我们做到了。

136
00:07:10,940 --> 00:07:12,140
这就是 OpenAI。

137
00:07:12,140 --> 00:07:13,780
我们已经有了这个变量模型。

138
00:07:13,980 --> 00:07:19,100
这样我们就可以得到一个 Python 客户端库的实例了。

139
00:07:19,260 --> 00:07:26,620
所以我们可以说响应等于 OpenAI Python 客户端库点聊天点完成。

140
00:07:26,860 --> 00:07:28,540
然后我们调用create。

141
00:07:28,580 --> 00:07:31,380
我们正在向该端点发布帖子。

142
00:07:31,700 --> 00:07:32,460
好的。

143
00:07:32,660 --> 00:07:34,380
现在你还记得我们必须传递什么吗？

144
00:07:34,380 --> 00:07:35,860
我们必须传递两件事。

145
00:07:35,860 --> 00:07:40,660
我们必须传入模型，模型可以像光标一样填充它。

146
00:07:40,980 --> 00:07:42,500
和消息。

147
00:07:43,020 --> 00:07:46,100
现在的消息当然是字典列表。

148
00:07:46,100 --> 00:07:50,510
所以它是两个字典的列表，在我们的例子中是第一个字典。

149
00:07:50,510 --> 00:07:50,910
开始了。

150
00:07:50,950 --> 00:07:55,590
角色将是系统和内容。

151
00:07:55,630 --> 00:07:56,510
哦，看到了，我们走了。

152
00:07:56,550 --> 00:07:59,270
内容将是谢谢。

153
00:07:59,270 --> 00:07:59,670
光标。

154
00:07:59,710 --> 00:08:01,150
链接系统提示。

155
00:08:01,190 --> 00:08:03,590
在光标泄露游戏之前快速按 Esc 键。

156
00:08:03,590 --> 00:08:04,310
这并不好玩。

157
00:08:05,550 --> 00:08:07,430
好的，这就是我们的链接系统提示。

158
00:08:07,470 --> 00:08:16,270
现在下一项的角色是用户，内容还可以。

159
00:08:16,310 --> 00:08:16,550
好的。

160
00:08:16,590 --> 00:08:18,030
用户提示是什么？

161
00:08:18,070 --> 00:08:19,230
我们没有一个常数。

162
00:08:19,310 --> 00:08:25,710
现在我们需要调用我刚刚编写的函数，即获取链接用户提示。

163
00:08:25,830 --> 00:08:26,790
出色的。

164
00:08:26,790 --> 00:08:28,310
就是这样。

165
00:08:28,510 --> 00:08:30,230
呃，摆脱你的光标。

166
00:08:30,230 --> 00:08:32,270
停止你的聪明才智。

167
00:08:32,590 --> 00:08:32,990
好的。

168
00:08:33,030 --> 00:08:34,470
那就是消息。

169
00:08:34,510 --> 00:08:38,430
现在，我之前告诉过你，我们只需在模型和消息中传递两件事。

170
00:08:38,430 --> 00:08:39,190
但我撒谎了。

171
00:08:39,190 --> 00:08:40,870
我们还要传递一件事。

172
00:08:40,870 --> 00:08:46,800
我们要使用一个额外的参数，呃，光标已经填好了，

173
00:08:46,800 --> 00:08:55,200
是一个响应下划线格式，响应下划线格式，这就是我们如何告诉API

174
00:08:55,200 --> 00:09:00,160
我们希望响应采用特定格式类型的 JSON 对象。

175
00:09:00,200 --> 00:09:00,960
我们开始吧。

176
00:09:01,440 --> 00:09:07,200
呃，现在快速提一下，对于那些我知道这一切的人来说，

177
00:09:07,200 --> 00:09:11,640
让我提一下你可能也知道但你可能不知道的事情，那就是其中之一

178
00:09:11,640 --> 00:09:17,160
这确实是非常偷偷摸摸的事情，不熟悉这一点的人会把你的

179
00:09:17,160 --> 00:09:18,320
用手捂住耳朵一会儿。

180
00:09:18,560 --> 00:09:24,480
其作用之一是在推理时间内限制模型的 GPT。

181
00:09:24,840 --> 00:09:31,040
当 GPT 是，呃，预测最有可能的下一个标记时，它的方式是它不会

182
00:09:31,040 --> 00:09:33,040
只是预测这是下一个令牌。

183
00:09:33,040 --> 00:09:37,480
它预测概率分布，即可能的下一个标记。

184
00:09:37,520 --> 00:09:40,240
它给出了每个可能的下一个标记的概率。

185
00:09:40,240 --> 00:09:46,730
通常，当我们不严格地说选择下一个标记时，我们的意思是选择下一个概率最高的标记

186
00:09:46,770 --> 00:09:50,890
基于概率或类似的东西的令牌或样本。

187
00:09:51,290 --> 00:09:54,970
嗯，因为这就是推理的工作原理，因为它是逐个标记地进行的。

188
00:09:55,170 --> 00:10:03,370
您还可以使用它来确保我们永远不会选择会导致无效 JSON 的令牌。

189
00:10:03,370 --> 00:10:09,730
我们基本上可以对其进行约束，以便它在推理时强制生成 JSON。

190
00:10:09,730 --> 00:10:14,810
LLM 可以预测它想要的任何概率，但我们实际选择的概率是

191
00:10:14,810 --> 00:10:18,050
成为格式良好的 JSON 的对象。

192
00:10:18,050 --> 00:10:19,530
这非常有趣。

193
00:10:19,530 --> 00:10:24,730
这就是为什么即使 LLM 不知道你的意思，如果你说你必须用 JSON 响应并且

194
00:10:24,770 --> 00:10:28,930
它知道你是否用英语说，但从技术上讲它不知道，但在推理时我们

195
00:10:28,930 --> 00:10:31,930
可以强制实施这样的技术限制。

196
00:10:31,970 --> 00:10:32,250
好的。

197
00:10:32,290 --> 00:10:33,930
现在每个人都可以把手拿开。

198
00:10:34,050 --> 00:10:34,970
呃，好吧。

199
00:10:35,170 --> 00:10:39,410
这就是，呃，这就是，呃，API 调用。

200
00:10:39,410 --> 00:10:43,050
现在是我们收回响应并利用它做一些事情的时候了。