1
00:00:00,080 --> 00:00:01,920
Okay, let's run an experiment.
好吧，让我们来做一个实验。

2
00:00:01,920 --> 00:00:05,440
So we come in now to the implementation folder.
现在我们进入实现文件夹。

3
00:00:05,440 --> 00:00:10,080
This is where we're going to live now because all we need to change is either the ingest approach or
这就是我们现在要生活的地方，因为我们需要改变的只是摄取方法或

4
00:00:10,080 --> 00:00:11,120
the answer approach.
答案的方法。

5
00:00:11,120 --> 00:00:14,360
We don't need to change anything else and then rerun evaluation.
我们不需要更改任何其他内容，然后重新运行评估。

6
00:00:14,640 --> 00:00:16,160
So let's go into ingest.
那么让我们进入摄取。

7
00:00:16,160 --> 00:00:19,760
So first thing you often go to is chunking.
所以你经常要做的第一件事就是分块。

8
00:00:19,960 --> 00:00:22,640
Good old chunking that that big old hack.
很好的老分块，那个大老黑客。

9
00:00:22,880 --> 00:00:27,400
So we're currently chunking into chunk size of 1000 characters give or take.
因此，我们目前正在将块大小划分为 1000 个字符的块大小。

10
00:00:27,640 --> 00:00:29,840
Let's let's just try changing that to 500.
我们尝试将其更改为 500。

11
00:00:29,880 --> 00:00:31,560
Let's have smaller chunks.
让我们有更小的块。

12
00:00:31,800 --> 00:00:35,280
Uh, now that means we'll have like twice as many chunks.
呃，现在这意味着我们将拥有两倍的块。

13
00:00:35,440 --> 00:00:42,600
Now, when we do this, uh, it's worth remembering that we're surfacing five chunks each time.
现在，当我们这样做时，呃，值得记住的是，我们每次都会显示五个块。

14
00:00:42,720 --> 00:00:48,440
And it seems to me that if we're going to have smaller chunks, it's only fair if we surface more chunks.
在我看来，如果我们要拥有更小的块，那么只有我们表面上有更多的块才公平。

15
00:00:48,600 --> 00:00:51,360
Uh, otherwise there's less context overall.
呃，否则整体上下文就更少了。

16
00:00:51,360 --> 00:00:51,600
So.
所以。

17
00:00:51,600 --> 00:00:56,600
So if we go to answer pie at the top here, retrieval k is five.
因此，如果我们去回答顶部的饼图，检索 k 就是 5。

18
00:00:56,760 --> 00:01:02,380
That's saying that we always try and and collect five relevant documents you see right here.
这就是说，我们总是尝试收集您在此处看到的五份相关文件。

19
00:01:02,460 --> 00:01:05,340
K is five when we call retriever dot invoke.
当我们调用检索器点调用时，K 为 5。

20
00:01:05,500 --> 00:01:06,860
So let's make that ten.
所以让我们把这个数字定为十。

21
00:01:07,020 --> 00:01:15,060
So instead of five documents of 1000 characters we're now going to surface ten documents of 500 characters.
因此，我们现在将显示 10 个 500 个字符的文档，而不是 5 个 1000 个字符的文档。

22
00:01:15,140 --> 00:01:16,060
That seems fair.
这看起来很公平。

23
00:01:16,220 --> 00:01:19,300
Uh, so now same amount of context will use up in both cases.
呃，现在这两种情况都会用掉相同数量的上下文。

24
00:01:19,340 --> 00:01:19,700
All right.
好的。

25
00:01:19,700 --> 00:01:20,260
That's good.
那挺好的。

26
00:01:20,300 --> 00:01:21,980
Let's let's go and test this out.
让我们来测试一下。

27
00:01:22,020 --> 00:01:22,380
Okay.
好的。

28
00:01:22,420 --> 00:01:25,020
So I'm going to bring up a new terminal.
所以我要打开一个新的终端。

29
00:01:25,020 --> 00:01:26,620
I'm going to go into week five.
我将进入第五周。

30
00:01:26,740 --> 00:01:28,900
I'm going to go into implementation.
我要进入实施阶段。

31
00:01:28,900 --> 00:01:29,700
And then I'm going to do.
然后我就去做。

32
00:01:29,740 --> 00:01:31,740
You've run ingest dot pi.
您已经运行了摄取 dot pi。

33
00:01:31,780 --> 00:01:35,500
Remember this rebuilds the the vectors.
请记住，这会重建向量。

34
00:01:35,740 --> 00:01:36,700
Uh re-ingest.
呃，重新摄取。

35
00:01:36,700 --> 00:01:38,340
So before we had 400 and something.
所以之前我们有 400 之类的。

36
00:01:38,340 --> 00:01:44,260
So now we're expecting 8 or 900 or so vectors to be created and put in our data store.
所以现在我们期望创建 8 或 900 个左右的向量并将其放入我们的数据存储中。

37
00:01:44,500 --> 00:01:45,100
And there we go.
我们就这样吧。

38
00:01:45,140 --> 00:01:47,340
970 vectors.
970 个向量。

39
00:01:47,340 --> 00:01:50,860
Because there's overlap that you would expect there to be more than double.
因为存在重叠，您预计会有超过一倍的重叠。

40
00:01:51,020 --> 00:01:52,820
Uh, so so there we have it.
呃，所以我们就有了。

41
00:01:52,980 --> 00:01:56,180
Um, lots of vectors, 970 of them.
嗯，很多矢量，970 个。

42
00:01:56,180 --> 00:01:59,520
Now let's go and rerun the evaluation now.
现在让我们重新运行评估。

43
00:01:59,560 --> 00:02:04,480
Actually, if you've got your screen still running from before, you have to to quit that and create
实际上，如果你的屏幕仍然在运行之前，你必须退出并创建

44
00:02:04,480 --> 00:02:07,320
a new one because we've regenerated the database.
一个新的，因为我们已经重新生成了数据库。

45
00:02:07,320 --> 00:02:09,720
So you will need to to launch a new Gradio app.
因此，您需要启动一个新的 Gradio 应用程序。

46
00:02:09,720 --> 00:02:11,280
So let's go and do that right now.
那么我们现在就开始吧。

47
00:02:11,280 --> 00:02:13,840
And then let's, let's run an eval okay.
然后让我们运行一次评估吧。

48
00:02:13,880 --> 00:02:21,800
So I do CD up up I go up to week five and now I do you've run evaluator.py.
所以我做 CD 向上，直到第五周，现在我做你已经运行了 evaluator.py。

49
00:02:22,120 --> 00:02:24,080
It's going to bring up our evaluator.
它将调出我们的评估器。

50
00:02:24,280 --> 00:02:28,920
The MRI that we're comparing with is 0.7298.
我们所比较的 MRI 为 0.7298。

51
00:02:29,080 --> 00:02:30,320
That's what we have to beat.
这就是我们必须击败的。

52
00:02:30,360 --> 00:02:31,800
Let's press run evaluation.
让我们按运行评估。

53
00:02:31,800 --> 00:02:32,880
Let's see what we get.
让我们看看我们得到了什么。

54
00:02:32,920 --> 00:02:34,080
Drumroll please.
请击鼓。

55
00:02:34,360 --> 00:02:36,120
And we do do better.
我们确实做得更好。

56
00:02:36,160 --> 00:02:39,440
Smaller chunks mean that we do better.
更小的块意味着我们做得更好。

57
00:02:39,680 --> 00:02:41,280
Uh interesting.
呃有趣。

58
00:02:41,560 --> 00:02:42,120
Okay.
好的。

59
00:02:42,160 --> 00:02:44,400
Let's let's take a note of that.
让我们记下这一点。

60
00:02:44,400 --> 00:02:46,480
It's all all gone, gone yellow.
一切都消失了，变黄了。

61
00:02:46,720 --> 00:02:50,160
Uh, I'm just just for to keep us focused on one thing.
呃，我只是为了让我们专注于一件事。

62
00:02:50,160 --> 00:02:50,440
Both.
两个都。

63
00:02:50,440 --> 00:02:53,520
Both MRI and all three metrics have improved.
MRI 和所有三个指标均有所改善。

64
00:02:53,520 --> 00:02:58,380
We've gone right into the green with keyword coverage with more smaller chunks.
我们已经通过更小块的关键字覆盖率进入了绿色阶段。

65
00:02:58,660 --> 00:03:00,300
Let's we're going to try bigger chunks.
让我们尝试更大的块。

66
00:03:00,300 --> 00:03:01,620
But let me take a note of this.
但让我记下这一点。

67
00:03:01,620 --> 00:03:04,180
So this is with 500 I'm keeping a little note tab.
所以对于 500，我保留了一个小注释标签。

68
00:03:04,180 --> 00:03:06,980
And so should you try and try and write this down so we don't lose track.
所以你应该尝试把它写下来，这样我们就不会迷失方向。

69
00:03:06,980 --> 00:03:09,660
Because if we're going to be scientific we might as well be scientific.
因为如果我们要科学化，我们不妨也科学化。

70
00:03:09,700 --> 00:03:09,980
Okay.
好的。

71
00:03:10,020 --> 00:03:12,860
Now let's go and make bigger chunks and try again okay.
现在让我们去制作更大的块，然后再试一次好吗。

72
00:03:12,900 --> 00:03:15,420
So I'm going to I'm going to close that.
所以我要结束它。

73
00:03:15,580 --> 00:03:23,500
I'm now going to go back to ingest I am going to uh change the chunk size.
我现在要返回摄取，我要呃改变块大小。

74
00:03:23,500 --> 00:03:28,660
We're going to go up and I'm not going to double its 2000, I'm going to go to like one, six, six,
我们要上升，我不会将 2000 翻倍，我会上升到一、六、六，

75
00:03:28,700 --> 00:03:29,340
seven.
七。

76
00:03:29,540 --> 00:03:30,260
And you're like, why?
你会想，为什么？

77
00:03:30,300 --> 00:03:31,340
Why are you doing that?
你为什么要这么做？

78
00:03:31,420 --> 00:03:32,620
Uh, why such a weird number?
呃，为什么这么奇怪的数字？

79
00:03:32,620 --> 00:03:38,420
Because I want to stay true to filling up the same amount of context space I'm going to go to to answer
因为我想忠实地填充我要回答的相同数量的上下文空间

80
00:03:38,420 --> 00:03:46,580
dot pi and say, let's go down to three, K is three, because three of one, six, six, seven will
点 pi 并说，让我们减到三，K 是三，因为一、六、六、七中的三将

81
00:03:46,580 --> 00:03:51,620
come to the same number to, to uh, to 10,000, which means sorry to 5000.
达到相同的数字到，呃，到 10,000，这意味着对不起 5000。

82
00:03:51,740 --> 00:03:52,460
Uh, is that right?
呃，是吗？

83
00:03:52,460 --> 00:03:52,900
Yes.
是的。

84
00:03:53,540 --> 00:03:56,480
Three times one six, six, six seven 6667 would be 5000.
三乘一六、六、六七 6667 就是 5000。

85
00:03:56,520 --> 00:03:58,880
So we are now filling up the same amount of context.
所以我们现在正在填充相同数量的上下文。

86
00:03:58,880 --> 00:04:05,080
So basically it's three bigger chunks versus the five chunks that we had to start with versus the ten
所以基本上它是三个更大的块与我们必须开始的五个块与十个块

87
00:04:05,120 --> 00:04:06,840
chunks of much smaller.
块小得多。

88
00:04:06,840 --> 00:04:08,400
So we've got consistency there.
所以我们在那里保持了一致性。

89
00:04:08,640 --> 00:04:09,280
Okay.
好的。

90
00:04:09,320 --> 00:04:10,760
So we're comparing apples and apples.
所以我们正在比较苹果和苹果。

91
00:04:10,760 --> 00:04:11,040
All right.
好的。

92
00:04:11,040 --> 00:04:17,440
We need to rerun ingest CBD implementation run ingest dot pi.
我们需要重新运行 ingest CBD 实现 run ingest dot pi。

93
00:04:19,080 --> 00:04:19,920
Off it goes.
关了就走了。

94
00:04:21,240 --> 00:04:22,120
Let it do its thing.
让它做它该做的事。

95
00:04:22,160 --> 00:04:28,960
We're expecting fewer much fewer now uh 235 vectors okay.
我们预计现在呃 235 个向量会更少。

96
00:04:29,360 --> 00:04:34,640
And now we're going to go to uh upper directory to the parent directory.
现在我们要转到上层目录到父目录。

97
00:04:34,640 --> 00:04:38,200
And we're going to do you've run evaluator dot pi.
我们将让您运行评估器 dot pi。

98
00:04:38,360 --> 00:04:41,760
And it will bring up a fresh interface for us to to run with.
它将为我们带来一个新的运行界面。

99
00:04:42,600 --> 00:04:45,160
And we'll see what you have to make a bet.
我们会看看你必须下注什么。

100
00:04:45,200 --> 00:04:45,720
What do you think.
你怎么认为。

101
00:04:45,720 --> 00:04:47,000
Better or worse, better or worse.
好还是坏，好还是坏。

102
00:04:47,000 --> 00:04:48,240
We'll soon find out.
我们很快就会知道。

103
00:04:48,280 --> 00:04:49,600
Running evaluation.
运行评价。

104
00:04:50,240 --> 00:04:54,040
And we find it is interesting.
我们发现这很有趣。

105
00:04:54,260 --> 00:04:54,740
How about that?
怎么样？

106
00:04:54,740 --> 00:04:56,140
Were you expecting that?
你期待吗？

107
00:04:56,260 --> 00:04:57,060
Because I wasn't.
因为我不是。

108
00:04:57,580 --> 00:04:57,980
It's.
它是。

109
00:04:58,020 --> 00:04:59,860
I was thinking it was going to be worse, but it's not.
我以为情况会更糟，但事实并非如此。

110
00:04:59,900 --> 00:05:01,700
It's slightly better.
稍微好一点了。

111
00:05:01,700 --> 00:05:03,140
So let's review.
那么我们来回顾一下。

112
00:05:03,260 --> 00:05:16,020
So having a chunk size of, um, uh, of one six, six seven, um, is, is uh, .7475.
因此，块大小为，嗯，呃，一六，六七，嗯，是，是呃，0.7475。

113
00:05:16,060 --> 00:05:18,700
That is the MRI, which is better.
那是MRI，效果更好。

114
00:05:18,700 --> 00:05:26,380
So having a chunk size of 1667, a bigger chunk size is better than a chunk size of 1000, and having
因此，块大小为 1667 时，较大的块大小优于块大小 1000，并且具有

115
00:05:26,380 --> 00:05:28,980
a chunk size of 500 is better than either of them.
500 的块大小比它们中的任何一个都要好。

116
00:05:28,980 --> 00:05:29,940
That's best of all.
这是最好的。

117
00:05:30,300 --> 00:05:33,620
So there's clearly more experiments to be had here.
所以这里显然还有更多的实验要做。

118
00:05:33,620 --> 00:05:39,620
You can get better numbers by continuing to experiment with it, and it's important to try and keep
通过继续试验，您可以获得更好的数字，并且尝试并保持这一点很重要

119
00:05:39,660 --> 00:05:41,100
keep all things being equal.
保持一切平等。

120
00:05:41,100 --> 00:05:46,060
Assume that you want to try and keep roughly the same amount of information in the context window,
假设您想尝试在上下文窗口中保留大致相同数量的信息，

121
00:05:46,060 --> 00:05:48,380
so that you're only varying one parameter.
这样你就只改变一个参数。

122
00:05:48,380 --> 00:05:52,960
If you're willing to have more in the context window, that that would change the picture a bit.
如果您愿意在上下文窗口中显示更多内容，那么情况会有所改变。

123
00:05:53,000 --> 00:05:53,520
All right.
好的。

124
00:05:53,520 --> 00:05:54,680
Well, that was interesting.
嗯，这很有趣。

125
00:05:54,680 --> 00:05:56,720
You should do many more experiments.
你应该做更多的实验。

126
00:05:56,720 --> 00:05:58,200
This stuff is fascinating.
这东西很有趣。

127
00:05:58,200 --> 00:06:02,000
But now we're going to try different kinds of of chunking strategy.
但现在我们将尝试不同类型的分块策略。

128
00:06:02,040 --> 00:06:09,480
Now one of the reasons people love Lang chain, and I totally see it is that it comes with so much stuff.
现在人们喜欢郎链的原因之一，我完全明白它是因为它配备了这么多的东西。

129
00:06:09,520 --> 00:06:14,160
It's a real, what they call a batteries included kind of framework that has lots of things that come
这是一个真正的，他们所谓的包含电池的框架，有很多东西

130
00:06:14,160 --> 00:06:20,320
along with the mix, and one of them is a ton of different types of splitter things that can divide
随着混合，其中之一是大量不同类型的分离器，可以将

131
00:06:20,320 --> 00:06:21,960
up your chunks in different ways.
以不同的方式增加你的块。

132
00:06:21,960 --> 00:06:26,240
And in our case, our knowledge base is actually made up of markdown documents.
在我们的例子中，我们的知识库实际上是由 Markdown 文档组成的。

133
00:06:26,240 --> 00:06:31,800
And it turns out, would you believe it, that there is a markdown text splitter that is designed for
事实证明，你相信吗，有一个 Markdown 文本分割器是为

134
00:06:31,800 --> 00:06:33,240
splitting markdown documents?
拆分 Markdown 文档？

135
00:06:33,240 --> 00:06:34,480
There's actually two of them.
实际上有两个。

136
00:06:34,480 --> 00:06:39,040
There's a markdown text splitter that just figures it out, and there's one called markdown header text
有一个 Markdown 文本分割器可以解决这个问题，还有一个叫做 Markdown 标题文本

137
00:06:39,040 --> 00:06:42,040
splitter when you specify how you want it to do it.
splitter 当您指定您希望它如何执行操作时。

138
00:06:42,040 --> 00:06:43,600
But we're going to go with a simple one.
但我们将选择一个简单的。

139
00:06:43,800 --> 00:06:48,080
So basically we find our recursive character text splitter.
所以基本上我们找到了递归字符文本分割器。

140
00:06:48,280 --> 00:06:50,320
And we will comment this line out.
我们将注释掉这一行。

141
00:06:50,480 --> 00:06:55,700
And instead of that we will say text splitter is look at that.
相反，我们会说文本分割器是看那个。

142
00:06:55,740 --> 00:06:57,100
It's filled it in for us.
它已经帮我们填好了。

143
00:06:57,100 --> 00:06:59,220
But I don't think you even need to specify this.
但我认为你甚至不需要指定这一点。

144
00:06:59,220 --> 00:07:02,940
I think we can just do it like that and it will just figure it out itself.
我认为我们可以这样做，它会自己解决的。

145
00:07:03,060 --> 00:07:04,700
That's that's how good it is.
就是这样就好了。

146
00:07:04,700 --> 00:07:05,860
So let's see if I'm right.
那么让我们看看我是否正确。

147
00:07:05,860 --> 00:07:14,460
Let's do UV run ingest.py, uh, and we'll see if that just runs and just does some, some documents
让我们运行 UV run ingest.py，呃，我们会看看它是否只运行并且只执行一些、一些文档

148
00:07:14,460 --> 00:07:15,220
splitting.
分裂。

149
00:07:15,780 --> 00:07:18,100
It's done it 109 vectors.
它已经完成了 109 个向量。

150
00:07:18,140 --> 00:07:19,420
Let's go test them.
我们去测试一下他们吧。

151
00:07:19,420 --> 00:07:25,700
And I should say that I'm going to leave this uh answered py with k is three because these are clearly
我应该说我要离开这个呃回答 py k 是 3 因为这些显然是

152
00:07:25,700 --> 00:07:27,580
bigger chunks with fewer vectors.
用更少的向量得到更大的块。

153
00:07:27,580 --> 00:07:31,740
So just to roughly try and have apples and apples will keep retrieval k at three.
因此，只要粗略地尝试吃苹果，就会将检索 k 保持为 3。

154
00:07:31,940 --> 00:07:40,740
And we will now go into the parent directory and do uv run evaluator.py evaluator.py.
现在我们将进入父目录并执行 uv run evaluator.py evaluator.py。

155
00:07:40,980 --> 00:07:43,220
Up comes our evaluation framework.
我们的评估框架就出来了。

156
00:07:43,220 --> 00:07:48,460
And we'll see whether this markdown splitter does a better job or not.
我们将看看这个降价分割器是否做得更好。

157
00:07:48,660 --> 00:07:49,460
Here it is.
这里是。

158
00:07:49,460 --> 00:07:50,680
Run a valuation.
进行评估。

159
00:07:51,720 --> 00:07:52,680
Off it goes.
关了就走了。

160
00:07:52,960 --> 00:07:56,720
And we get 0.738 is aha.
我们得到 0.738 啊哈。

161
00:07:57,080 --> 00:08:05,200
So it does better than our original MRR when we had simple character splitting at the 1000 chunks.
因此，当我们在 1000 个块上进行简单的字符分割时，它比我们原来的 MRR 效果更好。

162
00:08:05,200 --> 00:08:08,680
But it's worse than either of our of our subsequent ones.
但这比我们后续的任何一个都更糟糕。

163
00:08:08,680 --> 00:08:14,920
So for whatever reason going with the the markdown splitter has not worked out well.
因此，无论出于何种原因，使用 markdown splitter 效果并不好。

164
00:08:14,960 --> 00:08:17,600
And it's not for whatever reason we can tell exactly what's going on.
无论出于何种原因，我们都无法确切地知道发生了什么。

165
00:08:17,600 --> 00:08:22,200
What's happening is that when we just focus on the headings now, our chunks are way too big.
发生的情况是，当我们现在只关注标题时，我们的块太大了。

166
00:08:22,360 --> 00:08:27,040
Uh, and so that's, that's, uh, that's why we're seeing, uh, performance suffering there.
呃，所以，这就是，呃，这就是为什么我们看到，呃，性能受到影响。

167
00:08:27,120 --> 00:08:32,280
But it's nice to know that we've got this fancy markdown splitter, should we wish it.
但很高兴知道我们已经有了这个奇特的降价分割器，如果我们愿意的话。

168
00:08:32,320 --> 00:08:32,800
Okay.
好的。

169
00:08:32,840 --> 00:08:34,800
Are you getting bored of experiments now?
你现在对实验感到厌倦了吗？

170
00:08:34,840 --> 00:08:35,720
Have you had enough?
你玩够了吗？

171
00:08:36,160 --> 00:08:37,120
Well, I haven't.
嗯，我没有。

172
00:08:37,160 --> 00:08:38,600
I'm only just getting started.
我才刚刚开始。

173
00:08:38,920 --> 00:08:39,160
I.
我。

174
00:08:39,480 --> 00:08:41,480
One more, one more set of experiments to do.
还有一组实验要做。

175
00:08:41,520 --> 00:08:42,120
This is fun.
这很有趣。

176
00:08:42,120 --> 00:08:42,760
This is what.
这是什么。

177
00:08:42,760 --> 00:08:44,680
This is what engineering is all about.
这就是工程学的全部内容。

178
00:08:44,680 --> 00:08:46,320
It's about the experiments.
这是关于实验的。

179
00:08:46,520 --> 00:08:52,340
So, uh, I have reset everything back to the chunk size of 500.
所以，呃，我已将所有内容重置回块大小 500。

180
00:08:52,380 --> 00:08:54,300
The recursive character text splitter.
递归字符文本分割器。

181
00:08:54,340 --> 00:08:55,940
That's our best result so far.
这是我们迄今为止最好的结果。

182
00:08:56,060 --> 00:08:59,260
We're now going to change the embedding model, the encoder.
我们现在要更改嵌入模型，即编码器。

183
00:08:59,260 --> 00:09:02,340
So we've been using the all mini Ml6 v2.
所以我们一直在使用all mini Ml6 v2。

184
00:09:02,540 --> 00:09:06,260
So instead of that let's import OpenAI embeddings.
因此，让我们导入 OpenAI 嵌入。

185
00:09:06,260 --> 00:09:07,860
And let's do embeddings.
让我们进行嵌入。

186
00:09:08,140 --> 00:09:09,620
Is OpenAI embeddings.
是 OpenAI 嵌入。

187
00:09:09,620 --> 00:09:14,100
We'll use as the model the small the text embedding three small.
我们将使用嵌入三个小文本的小文本作为模型。

188
00:09:14,300 --> 00:09:15,900
And I will comment that out.
我会对此发表评论。

189
00:09:15,940 --> 00:09:17,740
And notice one little tiny thing here.
请注意这里的一件小事。

190
00:09:17,740 --> 00:09:24,220
If you do this, be sure that you do this after you've loaded your dot EMV so that your OpenAI key is
如果您这样做，请确保在加载点 EMV 后执行此操作，以便您的 OpenAI 密钥

191
00:09:24,260 --> 00:09:25,500
set up.
设置。

192
00:09:25,980 --> 00:09:26,700
Okay.
好的。

193
00:09:26,860 --> 00:09:28,020
Copy that.
复制那个。

194
00:09:28,060 --> 00:09:30,020
Let's go over to answer dot pi.
让我们过去回答点pi。

195
00:09:30,060 --> 00:09:32,940
We also have to change the embeddings here as well.
我们还必须更改此处的嵌入。

196
00:09:33,260 --> 00:09:34,020
There we go.
我们开始吧。

197
00:09:34,220 --> 00:09:35,180
I've done that.
我已经这么做了。

198
00:09:35,220 --> 00:09:39,540
We might as well comment out the line above it and make sure that we are importing.
我们不妨注释掉上面的行并确保我们正在导入。

199
00:09:39,540 --> 00:09:41,380
Yes we are importing it right up here.
是的，我们正在这里导入它。

200
00:09:41,660 --> 00:09:42,460
Excellent.
出色的。

201
00:09:42,460 --> 00:09:43,500
We're in good shape.
我们的状态很好。

202
00:09:43,500 --> 00:09:44,540
That's all it should take.
这就是所需要的一切。

203
00:09:44,580 --> 00:09:48,100
We should now be able to try using OpenAI's embeddings model.
我们现在应该能够尝试使用 OpenAI 的嵌入模型。