1
00:00:00,080 --> 00:00:05,040
好吧，好吧，我们回到光标处，这是我最喜欢的地方之一。

2
00:00:05,280 --> 00:00:07,160
我们即将进入本周。

3
00:00:07,160 --> 00:00:08,600
左边有一个目录。

4
00:00:08,640 --> 00:00:11,040
请在此处检查 LM Engineering 的大写字母。

5
00:00:11,040 --> 00:00:13,320
所以您处于正确的项目中。

6
00:00:13,320 --> 00:00:17,600
然后进入第二天，这就是我们现在所处的位置。

7
00:00:17,800 --> 00:00:23,120
我需要提醒您，在您执行任何操作之前，您必须转到右上角显示“选择”的位置

8
00:00:23,120 --> 00:00:24,240
内核给你。

9
00:00:24,280 --> 00:00:25,280
你点击那个。

10
00:00:25,280 --> 00:00:27,240
单击“Python 环境”选项。

11
00:00:27,240 --> 00:00:30,240
您选择的第一个选项是点虚拟机。

12
00:00:30,440 --> 00:00:35,120
这是与此虚拟机匹配的 Python 3.12。

13
00:00:35,440 --> 00:00:37,920
这意味着你的内核已经设置好了。

14
00:00:37,960 --> 00:00:39,800
欢迎来到第二天的实验室。

15
00:00:40,160 --> 00:00:45,880
因此，在我们开始之前，我只想提一下，我的主页上有一个资源页面，

16
00:00:45,880 --> 00:00:46,920
我已经链接到这里了。

17
00:00:46,960 --> 00:00:48,840
我会尝试不断添加有用的资源。

18
00:00:48,840 --> 00:00:50,200
因此，请保留该书签。

19
00:00:50,240 --> 00:00:52,360
如果您愿意的话，您现在就可以去那里查看。

20
00:00:52,920 --> 00:00:59,880
好吧好吧，我们现在要再次回到昨天所做的事情，但是稍微做一点

21
00:00:59,920 --> 00:01:00,840
多一点纪律。

22
00:01:00,840 --> 00:01:05,830
我想向您介绍这个称为“聊天完成 API”的东西。

23
00:01:06,110 --> 00:01:12,230
这就是您称呼法学硕士（尤其是前沿法学硕士）最简单的方式。

24
00:01:12,510 --> 00:01:17,990
它被称为聊天完成，因为它是对你实际正在做的事情的认可。

25
00:01:17,990 --> 00:01:25,390
当你打电话给法学硕士时，你正在给它一个到目前为止的对话，并且你要求它预测

26
00:01:25,390 --> 00:01:28,350
接下来最有可能出现的消息。

27
00:01:28,470 --> 00:01:31,670
您可以将其视为完成聊天。

28
00:01:31,710 --> 00:01:33,510
这就是法学硕士认为它正在做的事情。

29
00:01:33,510 --> 00:01:35,830
它就像预测文本。

30
00:01:35,830 --> 00:01:39,230
它只是试图预测接下来最有可能出现的单词。

31
00:01:39,390 --> 00:01:44,830
作为其副作用，它恰好非常擅长回答所提出的任何问题。

32
00:01:44,830 --> 00:01:50,670
但它实际上想做的只是预测接下来最有可能出现的几个单词，或者正如我们很快就会看到的那样

33
00:01:50,670 --> 00:01:53,190
解释一下，最有可能的下一个标记。

34
00:01:53,590 --> 00:01:57,790
好吧，实际上就是这个聊天完成 API。

35
00:01:57,830 --> 00:02:01,750
这种方法首先是由 OpenAI 发明的。

36
00:02:01,750 --> 00:02:08,100
但它是如此受欢迎，这种类型的请求的结构和风格变得如此流行，以至于它已经成为

37
00:02:08,100 --> 00:02:09,060
无处不在。

38
00:02:09,180 --> 00:02:12,660
所有提供商都提供聊天完成 API。

39
00:02:12,820 --> 00:02:17,220
这是与法学硕士互动的标准方式。

40
00:02:17,300 --> 00:02:19,620
我们将从 OpenAI 重新开始。

41
00:02:19,660 --> 00:02:23,380
我知道你们中的一些人急于摆脱 OpenAI 并使用免费模型。

42
00:02:23,580 --> 00:02:25,500
你的时间随时都会到来。

43
00:02:25,540 --> 00:02:29,140
如果您不想使用 OpenAI，请观看此内容，我们会立即联系您。

44
00:02:29,460 --> 00:02:30,180
好的。

45
00:02:30,300 --> 00:02:37,220
首先，我将重复上次使用的称为加载点 EMV 的内容，

46
00:02:37,380 --> 00:02:44,860
这将加载我们的 EMV 文件中的机密并检查我们是否已设置 OpenAI 密钥。

47
00:02:45,020 --> 00:02:50,780
所以这个加载 EMV 函数可以加载你保存在你的文件中的任何东西。

48
00:02:50,780 --> 00:02:51,220
电磁势。

49
00:02:51,340 --> 00:02:53,580
然后我们将检查密钥是否良好。

50
00:02:53,620 --> 00:02:56,500
它说 API 密钥已找到，到目前为止看起来不错。

51
00:02:56,500 --> 00:02:58,660
如果你的没有这么说，那么你知道该怎么做。

52
00:02:58,700 --> 00:03:04,690
检查 EMV，检查所有内容，然后查看故障排除中的外观，然后问我是否得到

53
00:03:04,690 --> 00:03:05,170
卡住。

54
00:03:05,850 --> 00:03:08,770
好吧，我们来谈谈终点。

55
00:03:08,810 --> 00:03:12,610
现在，我想你们大多数人都知道终点是什么。

56
00:03:12,610 --> 00:03:14,770
这是人们经常挂在嘴边的词之一。

57
00:03:14,770 --> 00:03:15,610
但你可能不会。

58
00:03:15,610 --> 00:03:18,450
对于不了解的人，您应该尽快了解。

59
00:03:18,450 --> 00:03:21,690
我在技术基础指南中解释了这一切。

60
00:03:21,730 --> 00:03:23,890
终点没有什么特别的。

61
00:03:23,890 --> 00:03:31,290
这是一个 http url，您可以调用 to to 来通过点击某个网址来发出 API 请求。

62
00:03:31,290 --> 00:03:34,090
该网址将被称为端点。

63
00:03:34,090 --> 00:03:35,850
这是您拥有 API 的一种方式。

64
00:03:36,010 --> 00:03:40,090
但如果 API 和端点等内容对您来说是新的，那么请阅读该指南。

65
00:03:40,530 --> 00:03:41,130
好的。

66
00:03:41,530 --> 00:03:46,370
有一个端点可能会让您特别感兴趣，我现在想向您展示。

67
00:03:46,370 --> 00:03:50,290
它是一个端点，一个由开放人工智能提供的 API 端点。

68
00:03:50,490 --> 00:03:54,890
因此，为了调用这个端点（我将这样做），我们首先必须设置一些内容

69
00:03:54,930 --> 00:03:57,290
对于任何 HTTP 请求来说都很常见。

70
00:03:57,490 --> 00:04:01,250
有 HTTP 标头，即该请求中的标头。

71
00:04:01,290 --> 00:04:05,400
如果您对网络请求有所了解，那么您通常可能会这样做。

72
00:04:05,400 --> 00:04:09,600
您指定什么内容类型，您想要返回什么类型的内容。

73
00:04:09,600 --> 00:04:12,680
这就是说，我希望杰森回来，拜托。

74
00:04:13,000 --> 00:04:20,720
这是一种相当标准的方式，在授权的 HTTP 消息中发送秘密

75
00:04:20,720 --> 00:04:27,080
你，你放入一个名为“授权”的标头以及该标头的值，其中有“承载者”一词

76
00:04:27,080 --> 00:04:31,960
然后是一个空格，然后是一些可以向第三方识别您身份的秘密。

77
00:04:32,120 --> 00:04:36,440
在本例中，我们将填充 OpenAI API 密钥。

78
00:04:36,480 --> 00:04:40,240
我刚刚得到的东西，我们将把它塞到标题中。

79
00:04:40,720 --> 00:04:42,880
然后我这里有一个叫做有效负载的东西。

80
00:04:42,880 --> 00:04:44,960
有效负载只是一块 JSON。

81
00:04:45,120 --> 00:04:48,960
它将是一本字典，一本有两个键的字典。

82
00:04:48,960 --> 00:04:55,320
其中之一是模型，它将是 GPT 5 nano，即 GPT 5 的微型版本。

83
00:04:55,480 --> 00:04:58,840
最新型号，目前地球上最强大的型号之一。

84
00:04:59,240 --> 00:05:03,480
然后这个字典中的第二个字段有一个消息键。

85
00:05:03,880 --> 00:05:09,350
其值是，你知道，这是一个字典列表。

86
00:05:09,350 --> 00:05:10,630
这是一个您可以在那里看到的列表。

87
00:05:10,630 --> 00:05:11,550
这是一个清单。

88
00:05:11,790 --> 00:05:19,750
每个字典，让我们把它放在另一行，都有一个关键角色，价值用户有一个关键内容。

89
00:05:19,750 --> 00:05:24,350
价值在于告诉我一个有趣的事实。

90
00:05:24,390 --> 00:05:25,350
这里没什么特别的。

91
00:05:25,350 --> 00:05:26,390
让我们看看这个。

92
00:05:26,670 --> 00:05:29,710
呃，有有效负载 JSON。

93
00:05:29,710 --> 00:05:31,150
这就是我说的。

94
00:05:31,230 --> 00:05:35,990
模型 GPT 五个纳米消息、字典列表、角色用户内容。

95
00:05:36,030 --> 00:05:37,550
告诉我一个有趣的事实。

96
00:05:37,710 --> 00:05:39,470
好的，这是一段 JSON。

97
00:05:39,950 --> 00:05:41,270
呃，标头和有效负载。

98
00:05:41,270 --> 00:05:44,430
我们现在要做的是将其发送到端点。

99
00:05:44,750 --> 00:05:47,110
这是端点 API。

100
00:05:49,590 --> 00:05:50,470
V1。

101
00:05:54,110 --> 00:05:56,230
这是聊天完成。

102
00:05:56,430 --> 00:06:02,190
有时，当您发出 Post 请求时，人们会认为这就像为以下内容创建新资源：

103
00:06:02,190 --> 00:06:04,230
喜欢休息的人，休息的人。

104
00:06:04,350 --> 00:06:06,550
呃，这有时称为创建资源。

105
00:06:06,550 --> 00:06:12,780
因此，您可以将其视为聊天完成创建一些熟悉的内容。

106
00:06:12,900 --> 00:06:15,220
呃，所以聊天完成创建了。

107
00:06:15,220 --> 00:06:17,780
我们使用 API 密钥传递标头。

108
00:06:17,780 --> 00:06:21,420
有效负载就是这里的 JSON blob。

109
00:06:21,580 --> 00:06:23,340
那么让我们运行一下吧。

110
00:06:23,700 --> 00:06:26,020
返回的是一堆 JSON。

111
00:06:26,020 --> 00:06:27,780
我们要求返回 JSON。

112
00:06:27,820 --> 00:06:28,900
让我们看看我们得到了什么。

113
00:06:28,900 --> 00:06:30,100
让我们看看我们得到了什么样的 JSON。

114
00:06:30,100 --> 00:06:30,660
这里是。

115
00:06:30,980 --> 00:06:35,460
嗯，所以它是一块 JSON，就像一个 ID 对象，各种各样的东西。

116
00:06:35,460 --> 00:06:39,020
然后它有一个称为选择和选择的字段。

117
00:06:39,020 --> 00:06:42,060
在此响应中，选择是一个列表。

118
00:06:42,260 --> 00:06:49,380
索引为零的选项的第一项是具有字段消息的内容。

119
00:06:49,980 --> 00:06:53,860
该消息本身就是一个 JSON 字典。

120
00:06:54,020 --> 00:06:59,060
这里面有一个叫做内容的东西，这是一个有趣的事实。

121
00:06:59,100 --> 00:07:04,340
可能有独特的游戏，比可观察到的原子还多的可能的独特国际象棋游戏

122
00:07:04,340 --> 00:07:05,300
宇宙。

123
00:07:05,500 --> 00:07:09,890
大约是 10 的 120 次方 有一个有趣的事实。

124
00:07:09,890 --> 00:07:15,970
因此，我们调用 GPT 5 到该端点的 JSON 响应中返回了一个有趣的事实，即

125
00:07:15,970 --> 00:07:17,970
我刚刚给你的网址。

126
00:07:17,970 --> 00:07:20,170
显然我还有另一种方法可以做到这一点。

127
00:07:20,170 --> 00:07:21,530
让我在这里得到一个新的代码。

128
00:07:21,530 --> 00:07:26,330
假设，呃，嗯，我们说的是响应 JSON。

129
00:07:26,330 --> 00:07:29,450
这就是我们刚刚在此处查看的 JSON。

130
00:07:29,770 --> 00:07:31,170
呃，我的回复拼写错误。

131
00:07:31,330 --> 00:07:34,530
如果你让我输入 Response.json，这就是你得到的结果。

132
00:07:34,530 --> 00:07:38,690
所以我们可以说，好吧，让我们看看选择字段。

133
00:07:39,010 --> 00:07:40,690
我想它知道我在这里做什么。

134
00:07:40,730 --> 00:07:43,010
查看其中的第一个元素。

135
00:07:43,010 --> 00:07:51,290
字段内容处的字段消息的元素索引为零，正常。

136
00:07:51,330 --> 00:07:51,970
你看到了。

137
00:07:51,970 --> 00:07:53,370
那就是你知道那会做什么。

138
00:07:53,410 --> 00:07:56,610
我们只需选择第一条消息内容。

139
00:07:56,730 --> 00:07:58,250
让我们看看打印了什么。

140
00:07:58,370 --> 00:08:03,370
它打印出那个非常有趣的事实，当然我们刚刚看了呃，更多可能的独特游戏

141
00:08:03,370 --> 00:08:05,370
国际象棋的数量比可观测宇宙中的原子数量还要多。

142
00:08:05,930 --> 00:08:07,730
好吧，但你知道吗？

143
00:08:07,850 --> 00:08:14,840
嗯，所以这是使用 HTTP 端点在云中调用 OpenAI 的完美方法。

144
00:08:14,840 --> 00:08:15,840
没关系。

145
00:08:15,840 --> 00:08:16,560
我们可以做到这一点。

146
00:08:16,600 --> 00:08:18,120
我们可以随时输入这个。

147
00:08:18,480 --> 00:08:25,000
但使用 JSON、在字典中查找键之类的东西有点混乱。

148
00:08:25,000 --> 00:08:31,480
这有点做作，如果每次我们想调用 GPT 或任何前沿，那将是一个真正的痛苦

149
00:08:31,520 --> 00:08:39,280
模型中，我们必须将这些 HTTP 请求拼接在一起，用帖子调用斜线聊天完成

150
00:08:39,320 --> 00:08:45,160
或者创建然后通过像这样的 JSON 对象来导航。

151
00:08:45,200 --> 00:08:46,360
这会很痛苦。

152
00:08:46,560 --> 00:08:48,600
如果有更好的方法就好了。

153
00:08:48,640 --> 00:08:50,440
是的，是的，我知道你明白这个笑话。

154
00:08:50,480 --> 00:08:51,600
你知道我要说什么吗？

155
00:08:51,640 --> 00:08:53,240
有一个更好的方法可以做到这一点。

156
00:08:53,440 --> 00:08:55,800
OpenAI 创造了这种更好的方式。

157
00:08:55,800 --> 00:09:02,840
他们制作了一个名为 OpenAI 的包，该包就是所谓的 Python 客户端库。

158
00:09:02,840 --> 00:09:06,760
Python 客户端库一点也不奇特。

159
00:09:06,800 --> 00:09:11,550
您经常在各处使用 API 的 Python 客户端库。

160
00:09:11,590 --> 00:09:15,270
将其命名为 API，用于发送电子邮件，用于 API 执行如此多的操作。

161
00:09:15,470 --> 00:09:22,270
嗯，这些东西通常是非常轻量级的库，它们向

162
00:09:22,270 --> 00:09:22,990
端点。

163
00:09:23,110 --> 00:09:28,830
返回的内容会转换为 Python 对象，这样你就不会乱搞了

164
00:09:28,830 --> 00:09:33,630
诸如此类的东西，嗯，在 JSON 字典中努力探索。

165
00:09:33,630 --> 00:09:40,430
但您可以编写一些漂亮、优雅的 Python 代码，这就是 OpenAI 库的全部功能。

166
00:09:40,550 --> 00:09:45,790
它是一个 Python 客户端库，包装了对 HTTP 端点的调用。

167
00:09:45,790 --> 00:09:47,150
这很简单。

168
00:09:47,270 --> 00:09:48,790
它是完全开源的。

169
00:09:48,790 --> 00:09:50,510
你可以打开它，看看它，看看所有的代码。

170
00:09:50,550 --> 00:09:52,150
这非常简单。

171
00:09:52,470 --> 00:09:56,510
有些人第一次遇到这个问题时，会认为在处理 OpenAI 时，

172
00:09:56,510 --> 00:10:02,590
对象和代码，不知何故我们正在运行 GPT，并且我们有一些来自 OpenAI 的奇特代码。

173
00:10:02,750 --> 00:10:03,710
一点也不。

174
00:10:03,750 --> 00:10:07,910
它是简单的代码，仅封装发出 Web 请求。

175
00:10:07,910 --> 00:10:11,790
我们现在将快速使用该代码，但您会更加熟悉它。