1
00:00:00,120 --> 00:00:02,000
欢迎大家回来。

2
00:00:02,000 --> 00:00:09,120
Mac、PC、Linux 人员在我们的视频中重聚，我们现在开始处理我们的项目。

3
00:00:09,120 --> 00:00:10,240
您的环境已设置完毕。

4
00:00:10,240 --> 00:00:15,240
您应该在任何打开的窗口中看到光标看起来漂亮干净，就像这个 X 一样，

5
00:00:15,280 --> 00:00:17,200
让它看起来有点像我。

6
00:00:17,240 --> 00:00:20,240
然后在左边你会看到目录。

7
00:00:20,520 --> 00:00:26,520
这里的第一个基础代表了我们现在所处的第一周的目录。

8
00:00:26,560 --> 00:00:33,240
我们打开它，我希望您单击顶部出现的实验一。

9
00:00:33,240 --> 00:00:38,680
这里有一个小部分告诉您有关安装文件夹的信息，其中包含所有安装指南

10
00:00:38,880 --> 00:00:40,880
至此您应该已经涵盖了所有内容。

11
00:00:40,880 --> 00:00:41,920
所以应该没问题。

12
00:00:42,040 --> 00:00:46,160
然后指南文件夹中有一堆有用的指南。

13
00:00:46,160 --> 00:00:52,560
它有一些东西可以带你学习中级Python，也有初级Python。

14
00:00:52,560 --> 00:00:56,840
如果您是 Python 编码新手，那么它将引导您完成一些自学指南。

15
00:00:56,840 --> 00:00:59,160
如果你愿意这样做，我想它会的。

16
00:00:59,240 --> 00:00:59,730
会的。

17
00:00:59,730 --> 00:01:00,530
这需要一些时间。

18
00:01:00,530 --> 00:01:02,170
投资将是非常值得的。

19
00:01:02,170 --> 00:01:05,930
对于中级 Python 来说，也有一些重要的东西。

20
00:01:06,090 --> 00:01:07,610
有一堆东西。

21
00:01:07,650 --> 00:01:12,650
代理中经常出现的事情之一是使用异步代码。

22
00:01:12,690 --> 00:01:14,530
那里有异步的东西。

23
00:01:14,570 --> 00:01:20,370
还有一些关于生成器的事情非常重要，还有很多好的中间内容

24
00:01:20,370 --> 00:01:22,330
那里有Python级别的材料。

25
00:01:22,650 --> 00:01:28,330
如果您在编码方面也没有那么丰富的经验，那么将会有一些关于如何调试的内容

26
00:01:28,330 --> 00:01:29,610
进行调试。

27
00:01:29,730 --> 00:01:34,690
如果您遇到称为名称错误的情况，那么这种情况总是有办法在

28
00:01:34,690 --> 00:01:35,170
名称错误。

29
00:01:35,170 --> 00:01:36,650
所以这方面也有很好的细节。

30
00:01:36,690 --> 00:01:37,970
所以请务必查看指南。

31
00:01:37,970 --> 00:01:39,330
我已经在里面放了很多东西了。

32
00:01:39,370 --> 00:01:41,770
如果出现问题，还有故障排除指南。

33
00:01:41,810 --> 00:01:46,370
故障排除将引导您完成每一步，包括最后的一些重要诊断。

34
00:01:47,170 --> 00:01:52,610
然后这里的下一个小评论是说这些实验室认为它有点像

35
00:01:52,610 --> 00:01:53,210
电子书。

36
00:01:53,250 --> 00:01:57,090
它有内容和信息以及可以尝试的东西。

37
00:01:57,370 --> 00:02:01,670
你会发现，当我们经历这个过程时，你会看到的可能会有所不同。

38
00:02:01,710 --> 00:02:05,150
你所经历的可能与我现在经历的有所不同。

39
00:02:05,190 --> 00:02:06,430
你可能会说，这很烦人。

40
00:02:06,430 --> 00:02:07,590
我希望一切都一样。

41
00:02:07,590 --> 00:02:08,550
但事情是这样的。

42
00:02:08,550 --> 00:02:13,430
原因是因为我喜欢不断添加更多东西，使其成为最新的。

43
00:02:13,470 --> 00:02:16,670
当我添加新内容时，我会尝试说得非常清楚。

44
00:02:16,710 --> 00:02:22,310
我会引入额外的信息以使其保持最新状态，当人们陷入困境并遇到问题时

45
00:02:22,510 --> 00:02:25,910
或者他们需要更好的解释，我可以把它放在那里。

46
00:02:25,950 --> 00:02:30,790
这意味着每个人都可以从某些人陷入困境或我没有解释的事情中受益。

47
00:02:30,790 --> 00:02:32,110
嗯，我可以把它添加到那里。

48
00:02:32,110 --> 00:02:33,990
所以对我来说，这样做非常重要。

49
00:02:34,270 --> 00:02:39,310
我之所以没有回来录制所有视频，因为我做得很好，首先，这会

50
00:02:39,310 --> 00:02:43,350
花费很多时间，我宁愿花时间更新它。

51
00:02:43,590 --> 00:02:49,750
但也因为这会抹掉人们通过观看视频取得的一些进步。

52
00:02:49,750 --> 00:02:53,870
如果你正在看一个系列节目，然后视频在下面发生变化，这可能会很不和谐。

53
00:02:53,870 --> 00:02:54,150
你。

54
00:02:54,350 --> 00:03:00,280
因此，尽可能让这些实验室保持最新状态对我来说确实效果更好。

55
00:03:00,320 --> 00:03:02,720
因此，请像对待资源一样对待实验室。

56
00:03:02,720 --> 00:03:08,560
我建议你和我一起工作的方式是观看我通过实验室的视频。

57
00:03:08,600 --> 00:03:10,280
我会详细说明，我会解释。

58
00:03:10,280 --> 00:03:11,520
我会执行事情。

59
00:03:11,640 --> 00:03:15,840
我不一定建议你和我同时做，因为那不是真正的

60
00:03:15,840 --> 00:03:16,400
观点。

61
00:03:16,440 --> 00:03:22,200
重点是，一旦我完成了一个实验，你就回来并自己一步一步地完成它，

62
00:03:22,360 --> 00:03:27,320
你可以用它来构建学习、添加打印语句等等。

63
00:03:28,040 --> 00:03:29,680
好吧，对此还有几句话要说。

64
00:03:29,880 --> 00:03:36,520
我在这里使用称为笔记本的东西，它们是一种特殊类型的 Python 代码，经过组织

65
00:03:36,520 --> 00:03:38,280
以这种方式进入细胞。

66
00:03:38,400 --> 00:03:42,600
如果您不熟悉的话，将会有一个关于如何使用这样的笔记本的指南

67
00:03:42,600 --> 00:03:43,240
和他们在一起。

68
00:03:43,240 --> 00:03:48,120
我知道很多有工程背景的人一开始都会像这样感到有点沮丧

69
00:03:48,120 --> 00:03:50,560
因为他们宁愿只使用 Python 代码。

70
00:03:50,800 --> 00:03:52,760
我们也将使用 Python 代码。

71
00:03:52,760 --> 00:03:57,490
我们将同时使用两者，但这种笔记本有其用武之地。

72
00:03:57,490 --> 00:04:03,330
它对于研究和开发非常有用，这是成为人工智能工程师的重要组成部分。

73
00:04:03,610 --> 00:04:09,210
它也非常适合学习，因为你可以逐步运行、实验、调整、放置

74
00:04:09,210 --> 00:04:10,810
打印报表并学习。

75
00:04:10,850 --> 00:04:13,370
所以这也有一个好处。

76
00:04:13,490 --> 00:04:19,010
所以即使你不习惯这些类型的笔记本，我向你保证有好东西

77
00:04:19,010 --> 00:04:19,490
这里也有。

78
00:04:19,530 --> 00:04:23,770
我们还将使用普通模块进行一些 Python 编码。

79
00:04:24,250 --> 00:04:25,010
好的。

80
00:04:25,010 --> 00:04:27,730
所有细节到此结束。

81
00:04:27,930 --> 00:04:30,330
让我们开始运行第一个实验室。

82
00:04:31,450 --> 00:04:31,970
好的。

83
00:04:32,010 --> 00:04:36,650
第一步是转到右上角，您可以在此处看到选择内核。

84
00:04:36,690 --> 00:04:41,090
单击此处，您必须选择您的 Python 环境。

85
00:04:41,090 --> 00:04:44,890
执行此操作的方法是在此处键入 Python 环境。

86
00:04:44,890 --> 00:04:49,770
第一个这里的星星写着“Venv”。

87
00:04:49,810 --> 00:04:50,890
说的是推荐。

88
00:04:50,890 --> 00:04:52,810
它就在这个目录中。

89
00:04:52,930 --> 00:04:54,870
这就是你想要选择的那个。

90
00:04:55,110 --> 00:05:00,990
希望您能真正清楚地了解 Python 3.12 位于顶部。

91
00:05:01,030 --> 00:05:03,550
完成后，它将在此处设置。

92
00:05:03,550 --> 00:05:06,990
当你来到一个新的实验室时，你总是需要这样做。

93
00:05:07,030 --> 00:05:10,270
因此，请记住这一点才能发挥作用。

94
00:05:10,550 --> 00:05:11,110
好的。

95
00:05:11,510 --> 00:05:18,190
然后，就像最后一件小事一样，呃，又多了一个指向我 LinkedIn 的链接

96
00:05:18,190 --> 00:05:23,350
如果此时你还没有屈服，请记住你可以随时将他们与我联系起来。

97
00:05:23,510 --> 00:05:24,230
好的。

98
00:05:24,590 --> 00:05:30,310
所以现在我们要做的就是来到第一个单元格。

99
00:05:30,350 --> 00:05:32,990
这些东西都被称为单元，这些代码单元。

100
00:05:32,990 --> 00:05:34,830
我们将进行进口。

101
00:05:34,830 --> 00:05:36,110
我们要做什么导入？

102
00:05:36,110 --> 00:05:39,310
好吧，我们将从 dot env 进行导入。

103
00:05:40,150 --> 00:05:47,030
你可以看到光标已经建议我们现在可以做什么 from dot env import load

104
00:05:47,030 --> 00:05:48,030
点环境。

105
00:05:49,030 --> 00:05:53,480
我希望您熟悉从模块导入函数的含义，但如果不熟悉，那么

106
00:05:53,480 --> 00:05:57,000
请查看指南以复习一下。

107
00:05:57,000 --> 00:06:02,320
但我现在只需按 Shift 键，然后按 Return 或 Enter 即可运行此代码单元。

108
00:06:02,320 --> 00:06:04,600
执行单元格就完成了。

109
00:06:05,080 --> 00:06:07,160
所以我们接下来要做的就是使用这个函数。

110
00:06:07,160 --> 00:06:08,200
我们就是这样做的。

111
00:06:08,240 --> 00:06:11,800
我们说加载点环境，我已经收到提示了。

112
00:06:11,800 --> 00:06:12,240
就在那里。

113
00:06:12,680 --> 00:06:14,480
环境覆盖等于 true。

114
00:06:14,680 --> 00:06:15,680
那么这有什么作用呢。

115
00:06:16,040 --> 00:06:19,560
Dot env 只是一个实用函数，它执行一些非常具体的操作。

116
00:06:19,760 --> 00:06:26,040
它在项目根目录中查找具有非常特定名称的文件。

117
00:06:26,240 --> 00:06:31,440
正如您可能猜到的那样，该文件名恰好是名称点 e。

118
00:06:32,440 --> 00:06:37,880
假设这就是您设置一些您想要的环境变量的地方

119
00:06:37,880 --> 00:06:39,520
用于该项目。

120
00:06:39,520 --> 00:06:44,600
它只是一个查看该文件、解释它并将环境变量设置为的实用程序

121
00:06:44,600 --> 00:06:45,040
一个结果。

122
00:06:45,040 --> 00:06:46,080
这就是它的全部作用。

123
00:06:46,200 --> 00:06:51,130
默认情况下， override is true 只是一个值得了解的小技巧。

124
00:06:51,170 --> 00:06:51,730
加载。

125
00:06:51,970 --> 00:06:52,290
环境。

126
00:06:52,330 --> 00:06:58,410
如果您已经设置了环境变量（也许是您的配置文件），那么它会优先。

127
00:06:58,410 --> 00:06:59,050
但它不会。

128
00:06:59,090 --> 00:07:00,290
它不会覆盖它。

129
00:07:00,450 --> 00:07:02,730
这可能是一个令人讨厌的小问题。

130
00:07:02,810 --> 00:07:07,890
因为如果您过去设置了一个开放的 AI API 密钥并且您已经将其存储在全球某个地方

131
00:07:07,890 --> 00:07:12,850
在你的计算机上，这会优先，你将无法弄清楚 OpenAI 到底为什么

132
00:07:12,850 --> 00:07:14,050
正在拒绝您的密钥。

133
00:07:14,610 --> 00:07:18,330
事实证明，正如您可以想象的那样，这在过去是一个常见问题。

134
00:07:18,330 --> 00:07:23,210
而且我已经学会告诉人们总是把 override 等于 true，这意味着里面的内容

135
00:07:23,210 --> 00:07:25,490
env 文件优先。

136
00:07:25,690 --> 00:07:27,730
我们通过按 Shift Enter 来运行它。

137
00:07:27,890 --> 00:07:30,810
现在我们的环境变量将被设置。

138
00:07:31,130 --> 00:07:32,610
那么让我们检查一下。

139
00:07:33,370 --> 00:07:35,610
下一个单元执行导入操作系统。

140
00:07:35,890 --> 00:07:42,810
然后我们寻找一个名为 OpenAI API key 的环境变量，这正是我们命名的

141
00:07:42,810 --> 00:07:44,410
它在 env 文件中。

142
00:07:44,650 --> 00:07:50,870
如果它存在，我们将打印它存在并开始并给出前几个字母。

143
00:07:50,910 --> 00:07:53,070
不然会说没有设置。

144
00:07:53,110 --> 00:07:54,950
请参阅故障排除指南。

145
00:07:54,990 --> 00:07:57,350
我按 Shift 并 Enter 来运行它。

146
00:07:57,350 --> 00:07:58,230
我们就这样吧。

147
00:07:58,270 --> 00:08:00,110
OpenAI 密钥已存在。

148
00:08:00,230 --> 00:08:02,070
它开始于 scmproj。

149
00:08:02,670 --> 00:08:05,750
一切都好，我希望一切对你也好。

150
00:08:05,910 --> 00:08:07,910
如果没有，请转至故障排除指南。

151
00:08:08,790 --> 00:08:09,310
好的。

152
00:08:09,350 --> 00:08:12,110
现在我们有一个非常重要的导入声明。

153
00:08:12,110 --> 00:08:15,990
从 OpenAI 导入 OpenAI 看起来像这样。

154
00:08:16,710 --> 00:08:21,270
所以，如果这对你来说很奇怪，为什么一个是小写的，而另一个不是这样的？

155
00:08:21,270 --> 00:08:22,670
再次，转到指南。

156
00:08:22,670 --> 00:08:26,750
我将解释类和模块以及其他所有内容之间的区别。

157
00:08:26,750 --> 00:08:32,390
但我们现在要执行此操作，如果这给您带来任何问题，那么这可能表明

158
00:08:32,390 --> 00:08:35,550
您的紫外线环境故障排除指南有问题。

159
00:08:35,550 --> 00:08:38,950
如果您遇到任何困难，请随时联系我。

160
00:08:38,990 --> 00:08:40,590
我是来给你解开束缚的

161
00:08:40,990 --> 00:08:41,750
好的。

162
00:08:41,910 --> 00:08:46,030
所以我们现在要做的就是创建这个类的一个实例。

163
00:08:46,070 --> 00:08:48,040
现在我倾向于总是这样做。

164
00:08:48,080 --> 00:08:48,680
开放人工智能。

165
00:08:48,720 --> 00:08:49,880
等于 OpenAI。

166
00:08:50,120 --> 00:08:55,000
这可能会让人们感到有点困惑，因为当我们使用同一个词 OpenAI 时，

167
00:08:55,000 --> 00:08:57,720
正确的称呼方式是 OpenAI 之类的。

168
00:08:58,160 --> 00:09:00,280
Python 客户端。

169
00:09:00,320 --> 00:09:05,000
因为我们正在做的是创建 Python 客户端库的实例。

170
00:09:05,000 --> 00:09:08,280
但我称之为 OpenAI，因为它更简单、更短。

171
00:09:08,280 --> 00:09:10,120
但这就是它所代表的意义。

172
00:09:10,160 --> 00:09:13,640
我们正在创建该类的一个实例，现在就运行它。

173
00:09:14,000 --> 00:09:18,240
值得记住的是，有些人认为当你这样做时，你正在创造一些东西

174
00:09:18,240 --> 00:09:23,280
与本地实际的 GPT 大语言模型有关，但你不是。

175
00:09:23,480 --> 00:09:31,480
OpenAI 是一个轻量级库，用于连接到 OpenAI 云上的端点。

176
00:09:31,600 --> 00:09:34,960
所以这就是人们有时所说的客户端库。

177
00:09:34,960 --> 00:09:42,640
它只是一个围绕端点的简单包装库，它调用 HTTP 端点来调用 API

178
00:09:42,640 --> 00:09:43,640
在云端运行。

179
00:09:43,640 --> 00:09:44,920
仅此而已。

180
00:09:44,960 --> 00:09:49,530
这是一个简单的轻量级类，仅用于此目的。

181
00:09:49,970 --> 00:09:52,170
那么，让我们继续前进。

182
00:09:52,930 --> 00:09:57,370
我们现在要做的是创建一个名为“消息”的列表。

183
00:09:57,370 --> 00:10:00,570
我希望你们大多数人都非常熟悉这种格式。

184
00:10:00,690 --> 00:10:03,610
在我的 LM 工程课程中，我们一直在做这件事。

185
00:10:03,930 --> 00:10:06,130
如果你不这样做，我会向这些人吹嘘一些额外的东西。

186
00:10:06,130 --> 00:10:10,610
我现在不打算解释太多，但是与大型语言模型的对话是

187
00:10:10,610 --> 00:10:16,130
通常以 OpenAI 发明的这种格式表示，并且已经无处不在。

188
00:10:16,370 --> 00:10:20,970
字典列表，其中每个字典都有一个角色和内容。

189
00:10:20,970 --> 00:10:23,410
在这种情况下，我们说角色是用户。

190
00:10:23,450 --> 00:10:27,410
内容就是这个简单的问题二加二等于多少？

191
00:10:27,730 --> 00:10:34,330
所以我们运行它，现在我们将实际调用 OpenAI 并检查一切是否正常

192
00:10:35,170 --> 00:10:35,770
好的。

193
00:10:35,810 --> 00:10:39,650
现在我们要来这里输入代码来调用 OpenAI。

194
00:10:39,770 --> 00:10:42,250
光标将使我们变得非常容易。

195
00:10:42,250 --> 00:10:47,710
我们只需输入响应等于 OpenAI 点。

196
00:10:48,030 --> 00:10:52,550
这是一个聊天点完成点创建的。

197
00:10:52,550 --> 00:10:55,310
您可以看到光标已经为我们填充了该内容。

198
00:10:55,310 --> 00:10:58,510
我只需按 Tab 键，它就会立即完成。

199
00:10:58,710 --> 00:11:01,670
它会说该型号是 GPT 4 mini。

200
00:11:01,670 --> 00:11:03,110
消息就是消息。

201
00:11:03,110 --> 00:11:04,110
那很完美。

202
00:11:04,310 --> 00:11:06,790
并且它也会接受响应。

203
00:11:06,830 --> 00:11:10,070
取出第一个选择的点消息内容并打印它。

204
00:11:10,070 --> 00:11:11,990
这正是我们想做的。

205
00:11:12,310 --> 00:11:15,910
OpenAI 的这种结构现在很常见。

206
00:11:15,910 --> 00:11:20,070
如果您是新手，请看一下，我将尝试在指南中介绍一些内容。

207
00:11:20,070 --> 00:11:25,710
但熟悉这一点的人会认为这是一种非常简单的调用 OpenAI 的方法。

208
00:11:25,710 --> 00:11:29,990
如果我们运行这个，我们会得到对二加二是多少？这个问题的回答。

209
00:11:30,030 --> 00:11:32,150
我们得到二加二等于四。

210
00:11:32,350 --> 00:11:37,350
所以我们知道我们已经连接到 OpenAI，而且到目前为止一切顺利。

211
00:11:38,150 --> 00:11:41,230
希望您现在对我们都可以调用 OpenAI 感到满意。

212
00:11:41,270 --> 00:11:42,270
我们可以获得回应。

213
00:11:42,270 --> 00:11:48,560
我们可以使用非常标准的聊天完成 API 结构，如果我们

214
00:11:48,560 --> 00:11:49,680
永远忘记它是什么。

215
00:11:50,000 --> 00:11:52,600
但现在让我们问一个更难的问题。

216
00:11:52,600 --> 00:11:55,200
我们是时候变得有点代理了。

217
00:11:55,200 --> 00:11:58,240
我们将把一只脚踏入特工阵营。

218
00:11:58,280 --> 00:12:02,760
这更像是一个工作流程，而不是一个代理的我，但它仍然到达那里。

219
00:12:02,960 --> 00:12:04,600
我们要问一个问题。

220
00:12:04,640 --> 00:12:09,360
请提出一个困难的、具有挑战性的问题来评估某人的智商。

221
00:12:09,520 --> 00:12:12,240
仅回答问题。

222
00:12:12,240 --> 00:12:13,760
这就是我们的问题。

223
00:12:13,760 --> 00:12:17,800
我们将把它放入标准消息结构中。

224
00:12:18,280 --> 00:12:19,920
现在我们要问它。

225
00:12:19,920 --> 00:12:23,800
所以我们再次说响应，它已经为我们填充了。

226
00:12:23,800 --> 00:12:25,280
我们按 Tab 来完成。

227
00:12:25,280 --> 00:12:26,280
我们按 Tab 键。

228
00:12:26,320 --> 00:12:27,960
但我们只是要稍微改变一下。

229
00:12:27,960 --> 00:12:34,600
我们将使这个答复等于也许我应该使这个像问题等于一样。

230
00:12:34,600 --> 00:12:37,600
所以我们要收回那些回来的东西，我们要对其提出质疑。

231
00:12:37,600 --> 00:12:39,800
然后我们将再次打印问题。

232
00:12:39,800 --> 00:12:41,080
光标将其填充。

233
00:12:41,120 --> 00:12:42,450
让我们运行一下吧。

234
00:12:42,450 --> 00:12:43,250
我们开始吧。

235
00:12:43,250 --> 00:12:45,730
这里我们有一个来自 OpenAI 的问题。

236
00:12:46,290 --> 00:12:50,570
如果一列火车以每小时 60 英里的速度离开车站，另一列火车则在不同的车站，

237
00:12:50,570 --> 00:12:53,490
120英里外同时行驶90英里。

238
00:12:53,610 --> 00:12:56,290
两列火车会在距离第一站多远的地方相遇？

239
00:12:56,330 --> 00:12:58,810
这是一个不错的脑筋急转弯。

240
00:12:59,570 --> 00:13:03,450
所以我们现在要做的就是回答这个问题，然后再提出第二个问题

241
00:13:03,450 --> 00:13:06,410
致电法学硕士来回答问题。

242
00:13:06,410 --> 00:13:11,490
这就是为什么我将其描述为代理模式，因为它正在发出多个调用。

243
00:13:11,490 --> 00:13:16,090
我们正在协调对 llms 的多次调用来解决更大的问题。

244
00:13:16,090 --> 00:13:18,410
所以这将相对容易。

245
00:13:18,450 --> 00:13:22,210
我们只需再次发出另一条消息来继续此操作。

246
00:13:22,250 --> 00:13:26,370
看看光标如何为我们以用户角色填充消息。

247
00:13:26,370 --> 00:13:28,490
内容就是那个问题。

248
00:13:28,490 --> 00:13:29,130
伟大的。

249
00:13:29,130 --> 00:13:30,170
让我们运行一下吧。

250
00:13:30,330 --> 00:13:31,450
那就是现在的消息。

251
00:13:31,450 --> 00:13:34,330
现在我们要再次询问 OpenAI。

252
00:13:34,490 --> 00:13:39,570
所以我们会说响应是 OpenAI 创建的。

253
00:13:39,770 --> 00:13:43,670
再次，光标将其全部填满并填满答案。

254
00:13:43,670 --> 00:13:48,430
它甚至足够聪明地建议我们将其称为答案而不是问题。

255
00:13:48,750 --> 00:13:50,150
老实说，这太不可思议了。

256
00:13:50,390 --> 00:13:52,430
这正是我们想要做的。

257
00:13:52,470 --> 00:13:58,110
我们对 OpenAI 的聊天完成 API 进行同样类型的调用。

258
00:13:58,150 --> 00:14:01,150
在云端调用OpenAI的最简单方法。

259
00:14:01,430 --> 00:14:06,110
现在我们正在获取问题的答案，我们将打印该答案。

260
00:14:06,110 --> 00:14:09,350
我认为我们正在寻找的答案是 48。

261
00:14:09,550 --> 00:14:10,310
让我们来看看。

262
00:14:10,510 --> 00:14:12,150
所以我们会把它打印出来。

263
00:14:12,710 --> 00:14:14,070
我们开始吧。

264
00:14:14,310 --> 00:14:20,670
这里有一堆信息，最后写着 48。

265
00:14:21,710 --> 00:14:22,870
你可能已经知道这一点了。

266
00:14:22,910 --> 00:14:26,710
您认识到这已以降价形式回归。

267
00:14:26,710 --> 00:14:31,430
它里面有一些 Markdown 的东西，LLM 喜欢用 Markdown 来谈论。

268
00:14:31,430 --> 00:14:37,070
我们可以在这里添加一些代码，然后我们就可以从那里开始操作。

269
00:14:37,990 --> 00:14:38,510
哈哈。

270
00:14:38,510 --> 00:14:38,640
啊。

271
00:14:38,920 --> 00:14:40,120
是不是很恐怖？

272
00:14:40,240 --> 00:14:46,280
有时，光标在 IPython 显示、导入 markdown 和显示中执行此操作的方式令人毛骨悚然。

273
00:14:46,280 --> 00:14:49,040
然后光标告诉我们要写的下一行。

274
00:14:49,200 --> 00:14:50,760
我在这里真的没有工作，是吗？

275
00:14:50,920 --> 00:14:53,720
显示降价，但唯一的问题是。

276
00:14:53,720 --> 00:14:55,000
谢天谢地，它出了点问题。

277
00:14:55,000 --> 00:14:58,400
我们真正想要显示的是答案，而不是问题。

278
00:14:58,400 --> 00:15:04,160
因此，如果我们这样做并运行它，那么我们会看到格式良好的答案。

279
00:15:04,160 --> 00:15:11,360
我会让你通读一下它的工作，它得出了 48 英里的结论。

280
00:15:11,640 --> 00:15:12,840
呃，我们就这样吧。

281
00:15:13,120 --> 00:15:20,120
这是我们的第一个半代理模式，只需几分钟即可构建。

282
00:15:20,200 --> 00:15:24,480
如果您不熟悉其中任何一个，请查看指南，尝试一下，看看它。

283
00:15:24,520 --> 00:15:26,920
正如我所说，恭喜你来到这里。

284
00:15:26,920 --> 00:15:30,560
但在本实验的最后有一个练习。

285
00:15:30,560 --> 00:15:34,040
我确实鼓励你做这些练习。

286
00:15:34,040 --> 00:15:37,810
这是你真正可以证明你已经做到了这一点的地方。

287
00:15:37,850 --> 00:15:43,010
你可能会想，好吧，这个项目没有太多商业广告，我确实想尝试一下

288
00:15:43,010 --> 00:15:48,250
并尽我所能编织商业角度，使其适用于商业。

289
00:15:48,370 --> 00:15:53,330
因此，我现在为您准备了一个练习，使其稍微适用于商业。

290
00:15:53,330 --> 00:16:02,010
因此，我们将尝试要求法学硕士首先选择一个可能值得探索的业务领域

291
00:16:02,010 --> 00:16:04,170
以获得人工智能机会。

292
00:16:04,690 --> 00:16:12,450
其次，要找出所决定的业务领域的痛点，然后就是

293
00:16:12,450 --> 00:16:15,130
需要明确解释的一项。

294
00:16:15,130 --> 00:16:19,290
对于代理解决方案来说可能成熟的挑战是什么？

295
00:16:19,290 --> 00:16:25,810
然后第三步将是针对该问题实际提出人工智能解决方案。

296
00:16:26,170 --> 00:16:34,050
所以我希望你在这个空单元格中，可能在光标的帮助下，呃，到，到浏览

297
00:16:34,050 --> 00:16:37,230
并通过三次调用 LMS 来实现这一点。

298
00:16:37,430 --> 00:16:43,430
首先，您在此消息中添加一些内容来解释您希望它选择一个业务部门。

299
00:16:43,910 --> 00:16:47,350
然后你会根据该响应得到响应。

300
00:16:47,470 --> 00:16:54,550
你阅读商业构想，然后你将重复这三个步骤以获得痛苦

301
00:16:54,550 --> 00:16:59,830
点，然后得到AI解决方案并将其全部打印出来。

302
00:16:59,830 --> 00:17:07,390
如果您愿意，可以以良好的格式打印它们，并用它作为实验的一种方式

303
00:17:07,390 --> 00:17:13,830
通过一些代理工作流程，实际上也是为了获得一些商业利益，也许是为了获得有趣的东西

304
00:17:13,830 --> 00:17:19,350
关于如何将人工智能应用于实际业务痛点的想法。

305
00:17:19,830 --> 00:17:20,510
好的。

306
00:17:20,510 --> 00:17:22,230
我希望你喜欢这个挑战。

307
00:17:22,230 --> 00:17:28,190
当然，如果您有任何问题，那么您可以从 ChatGPT 或光标获得帮助，

308
00:17:28,190 --> 00:17:34,990
或者给我留言，我会在第一天的最后一堂课上见。