1
00:00:00,080 --> 00:00:01,920
好吧，让我们来做一个实验。

2
00:00:01,920 --> 00:00:05,440
现在我们进入实现文件夹。

3
00:00:05,440 --> 00:00:10,080
这就是我们现在要生活的地方，因为我们需要改变的只是摄取方法或

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

5
00:00:11,120 --> 00:00:14,360
我们不需要更改任何其他内容，然后重新运行评估。

6
00:00:14,640 --> 00:00:16,160
那么让我们进入摄取。

7
00:00:16,160 --> 00:00:19,760
所以你经常要做的第一件事就是分块。

8
00:00:19,960 --> 00:00:22,640
很好的老分块，那个大老黑客。

9
00:00:22,880 --> 00:00:27,400
因此，我们目前正在将块大小划分为 1000 个字符的块大小。

10
00:00:27,640 --> 00:00:29,840
我们尝试将其更改为 500。

11
00:00:29,880 --> 00:00:31,560
让我们有更小的块。

12
00:00:31,800 --> 00:00:35,280
呃，现在这意味着我们将拥有两倍的块。

13
00:00:35,440 --> 00:00:42,600
现在，当我们这样做时，呃，值得记住的是，我们每次都会显示五个块。

14
00:00:42,720 --> 00:00:48,440
在我看来，如果我们要拥有更小的块，那么只有我们表面上有更多的块才公平。

15
00:00:48,600 --> 00:00:51,360
呃，否则整体上下文就更少了。

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

17
00:00:51,600 --> 00:00:56,600
因此，如果我们去回答顶部的饼图，检索 k 就是 5。

18
00:00:56,760 --> 00:01:02,380
这就是说，我们总是尝试收集您在此处看到的五份相关文件。

19
00:01:02,460 --> 00:01:05,340
当我们调用检索器点调用时，K 为 5。

20
00:01:05,500 --> 00:01:06,860
所以让我们把这个数字定为十。

21
00:01:07,020 --> 00:01:15,060
因此，我们现在将显示 10 个 500 个字符的文档，而不是 5 个 1000 个字符的文档。

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

23
00:01:16,220 --> 00:01:19,300
呃，现在这两种情况都会用掉相同数量的上下文。

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

25
00:01:19,700 --> 00:01:20,260
那挺好的。

26
00:01:20,300 --> 00:01:21,980
让我们来测试一下。

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

28
00:01:22,420 --> 00:01:25,020
所以我要打开一个新的终端。

29
00:01:25,020 --> 00:01:26,620
我将进入第五周。

30
00:01:26,740 --> 00:01:28,900
我要进入实施阶段。

31
00:01:28,900 --> 00:01:29,700
然后我就去做。

32
00:01:29,740 --> 00:01:31,740
您已经运行了摄取 dot pi。

33
00:01:31,780 --> 00:01:35,500
请记住，这会重建向量。

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

35
00:01:36,700 --> 00:01:38,340
所以之前我们有 400 之类的。

36
00:01:38,340 --> 00:01:44,260
所以现在我们期望创建 8 或 900 个左右的向量并将其放入我们的数据存储中。

37
00:01:44,500 --> 00:01:45,100
我们就这样吧。

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

39
00:01:47,340 --> 00:01:50,860
因为存在重叠，您预计会有超过一倍的重叠。

40
00:01:51,020 --> 00:01:52,820
呃，所以我们就有了。

41
00:01:52,980 --> 00:01:56,180
嗯，很多矢量，970 个。

42
00:01:56,180 --> 00:01:59,520
现在让我们重新运行评估。

43
00:01:59,560 --> 00:02:04,480
实际上，如果你的屏幕仍然在运行之前，你必须退出并创建

44
00:02:04,480 --> 00:02:07,320
一个新的，因为我们已经重新生成了数据库。

45
00:02:07,320 --> 00:02:09,720
因此，您需要启动一个新的 Gradio 应用程序。

46
00:02:09,720 --> 00:02:11,280
那么我们现在就开始吧。

47
00:02:11,280 --> 00:02:13,840
然后让我们运行一次评估吧。

48
00:02:13,880 --> 00:02:21,800
所以我做 CD 向上，直到第五周，现在我做你已经运行了 evaluator.py。

49
00:02:22,120 --> 00:02:24,080
它将调出我们的评估器。

50
00:02:24,280 --> 00:02:28,920
我们所比较的 MRI 为 0.7298。

51
00:02:29,080 --> 00:02:30,320
这就是我们必须击败的。

52
00:02:30,360 --> 00:02:31,800
让我们按运行评估。

53
00:02:31,800 --> 00:02:32,880
让我们看看我们得到了什么。

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

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

56
00:02:36,160 --> 00:02:39,440
更小的块意味着我们做得更好。

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

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

59
00:02:42,160 --> 00:02:44,400
让我们记下这一点。

60
00:02:44,400 --> 00:02:46,480
一切都消失了，变黄了。

61
00:02:46,720 --> 00:02:50,160
呃，我只是为了让我们专注于一件事。

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

63
00:02:50,440 --> 00:02:53,520
MRI 和所有三个指标均有所改善。

64
00:02:53,520 --> 00:02:58,380
我们已经通过更小块的关键字覆盖率进入了绿色阶段。

65
00:02:58,660 --> 00:03:00,300
让我们尝试更大的块。

66
00:03:00,300 --> 00:03:01,620
但让我记下这一点。

67
00:03:01,620 --> 00:03:04,180
所以对于 500，我保留了一个小注释标签。

68
00:03:04,180 --> 00:03:06,980
所以你应该尝试把它写下来，这样我们就不会迷失方向。

69
00:03:06,980 --> 00:03:09,660
因为如果我们要科学化，我们不妨也科学化。

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

71
00:03:10,020 --> 00:03:12,860
现在让我们去制作更大的块，然后再试一次好吗。

72
00:03:12,900 --> 00:03:15,420
所以我要结束它。

73
00:03:15,580 --> 00:03:23,500
我现在要返回摄取，我要呃改变块大小。

74
00:03:23,500 --> 00:03:28,660
我们要上升，我不会将 2000 翻倍，我会上升到一、六、六，

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

76
00:03:29,540 --> 00:03:30,260
你会想，为什么？

77
00:03:30,300 --> 00:03:31,340
你为什么要这么做？

78
00:03:31,420 --> 00:03:32,620
呃，为什么这么奇怪的数字？

79
00:03:32,620 --> 00:03:38,420
因为我想忠实地填充我要回答的相同数量的上下文空间

80
00:03:38,420 --> 00:03:46,580
点 pi 并说，让我们减到三，K 是三，因为一、六、六、七中的三将

81
00:03:46,580 --> 00:03:51,620
达到相同的数字到，呃，到 10,000，这意味着对不起 5000。

82
00:03:51,740 --> 00:03:52,460
呃，是吗？

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

84
00:03:53,540 --> 00:03:56,480
三乘一六、六、六七 6667 就是 5000。

85
00:03:56,520 --> 00:03:58,880
所以我们现在正在填充相同数量的上下文。

86
00:03:58,880 --> 00:04:05,080
所以基本上它是三个更大的块与我们必须开始的五个块与十个块

87
00:04:05,120 --> 00:04:06,840
块小得多。

88
00:04:06,840 --> 00:04:08,400
所以我们在那里保持了一致性。

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

90
00:04:09,320 --> 00:04:10,760
所以我们正在比较苹果和苹果。

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

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

93
00:04:19,080 --> 00:04:19,920
关了就走了。

94
00:04:21,240 --> 00:04:22,120
让它做它该做的事。

95
00:04:22,160 --> 00:04:28,960
我们预计现在呃 235 个向量会更少。

96
00:04:29,360 --> 00:04:34,640
现在我们要转到上层目录到父目录。

97
00:04:34,640 --> 00:04:38,200
我们将让您运行评估器 dot pi。

98
00:04:38,360 --> 00:04:41,760
它将为我们带来一个新的运行界面。

99
00:04:42,600 --> 00:04:45,160
我们会看看你必须下注什么。

100
00:04:45,200 --> 00:04:45,720
你怎么认为。

101
00:04:45,720 --> 00:04:47,000
好还是坏，好还是坏。

102
00:04:47,000 --> 00:04:48,240
我们很快就会知道。

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

104
00:04:50,240 --> 00:04:54,040
我们发现这很有趣。

105
00:04:54,260 --> 00:04:54,740
怎么样？

106
00:04:54,740 --> 00:04:56,140
你期待吗？

107
00:04:56,260 --> 00:04:57,060
因为我不是。

108
00:04:57,580 --> 00:04:57,980
它是。

109
00:04:58,020 --> 00:04:59,860
我以为情况会更糟，但事实并非如此。

110
00:04:59,900 --> 00:05:01,700
稍微好一点了。

111
00:05:01,700 --> 00:05:03,140
那么我们来回顾一下。

112
00:05:03,260 --> 00:05:16,020
因此，块大小为，嗯，呃，一六，六七，嗯，是，是呃，0.7475。

113
00:05:16,060 --> 00:05:18,700
那是MRI，效果更好。

114
00:05:18,700 --> 00:05:26,380
因此，块大小为 1667 时，较大的块大小优于块大小 1000，并且具有

115
00:05:26,380 --> 00:05:28,980
500 的块大小比它们中的任何一个都要好。

116
00:05:28,980 --> 00:05:29,940
这是最好的。

117
00:05:30,300 --> 00:05:33,620
所以这里显然还有更多的实验要做。

118
00:05:33,620 --> 00:05:39,620
通过继续试验，您可以获得更好的数字，并且尝试并保持这一点很重要

119
00:05:39,660 --> 00:05:41,100
保持一切平等。

120
00:05:41,100 --> 00:05:46,060
假设您想尝试在上下文窗口中保留大致相同数量的信息，

121
00:05:46,060 --> 00:05:48,380
这样你就只改变一个参数。

122
00:05:48,380 --> 00:05:52,960
如果您愿意在上下文窗口中显示更多内容，那么情况会有所改变。

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

124
00:05:53,520 --> 00:05:54,680
嗯，这很有趣。

125
00:05:54,680 --> 00:05:56,720
你应该做更多的实验。

126
00:05:56,720 --> 00:05:58,200
这东西很有趣。

127
00:05:58,200 --> 00:06:02,000
但现在我们将尝试不同类型的分块策略。

128
00:06:02,040 --> 00:06:09,480
现在人们喜欢郎链的原因之一，我完全明白它是因为它配备了这么多的东西。

129
00:06:09,520 --> 00:06:14,160
这是一个真正的，他们所谓的包含电池的框架，有很多东西

130
00:06:14,160 --> 00:06:20,320
随着混合，其中之一是大量不同类型的分离器，可以将

131
00:06:20,320 --> 00:06:21,960
以不同的方式增加你的块。

132
00:06:21,960 --> 00:06:26,240
在我们的例子中，我们的知识库实际上是由 Markdown 文档组成的。

133
00:06:26,240 --> 00:06:31,800
事实证明，你相信吗，有一个 Markdown 文本分割器是为

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

135
00:06:33,240 --> 00:06:34,480
实际上有两个。

136
00:06:34,480 --> 00:06:39,040
有一个 Markdown 文本分割器可以解决这个问题，还有一个叫做 Markdown 标题文本

137
00:06:39,040 --> 00:06:42,040
splitter 当您指定您希望它如何执行操作时。

138
00:06:42,040 --> 00:06:43,600
但我们将选择一个简单的。

139
00:06:43,800 --> 00:06:48,080
所以基本上我们找到了递归字符文本分割器。

140
00:06:48,280 --> 00:06:50,320
我们将注释掉这一行。

141
00:06:50,480 --> 00:06:55,700
相反，我们会说文本分割器是看那个。

142
00:06:55,740 --> 00:06:57,100
它已经帮我们填好了。

143
00:06:57,100 --> 00:06:59,220
但我认为你甚至不需要指定这一点。

144
00:06:59,220 --> 00:07:02,940
我认为我们可以这样做，它会自己解决的。

145
00:07:03,060 --> 00:07:04,700
就是这样就好了。

146
00:07:04,700 --> 00:07:05,860
那么让我们看看我是否正确。

147
00:07:05,860 --> 00:07:14,460
让我们运行 UV run ingest.py，呃，我们会看看它是否只运行并且只执行一些、一些文档

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

149
00:07:15,780 --> 00:07:18,100
它已经完成了 109 个向量。

150
00:07:18,140 --> 00:07:19,420
我们去测试一下他们吧。

151
00:07:19,420 --> 00:07:25,700
我应该说我要离开这个呃回答 py k 是 3 因为这些显然是

152
00:07:25,700 --> 00:07:27,580
用更少的向量得到更大的块。

153
00:07:27,580 --> 00:07:31,740
因此，只要粗略地尝试吃苹果，就会将检索 k 保持为 3。

154
00:07:31,940 --> 00:07:40,740
现在我们将进入父目录并执行 uv run evaluator.py evaluator.py。

155
00:07:40,980 --> 00:07:43,220
我们的评估框架就出来了。

156
00:07:43,220 --> 00:07:48,460
我们将看看这个降价分割器是否做得更好。

157
00:07:48,660 --> 00:07:49,460
这里是。

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

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

160
00:07:52,960 --> 00:07:56,720
我们得到 0.738 啊哈。

161
00:07:57,080 --> 00:08:05,200
因此，当我们在 1000 个块上进行简单的字符分割时，它比我们原来的 MRR 效果更好。

162
00:08:05,200 --> 00:08:08,680
但这比我们后续的任何一个都更糟糕。

163
00:08:08,680 --> 00:08:14,920
因此，无论出于何种原因，使用 markdown splitter 效果并不好。

164
00:08:14,960 --> 00:08:17,600
无论出于何种原因，我们都无法确切地知道发生了什么。

165
00:08:17,600 --> 00:08:22,200
发生的情况是，当我们现在只关注标题时，我们的块太大了。

166
00:08:22,360 --> 00:08:27,040
呃，所以，这就是，呃，这就是为什么我们看到，呃，性能受到影响。

167
00:08:27,120 --> 00:08:32,280
但很高兴知道我们已经有了这个奇特的降价分割器，如果我们愿意的话。

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

169
00:08:32,840 --> 00:08:34,800
你现在对实验感到厌倦了吗？

170
00:08:34,840 --> 00:08:35,720
你玩够了吗？

171
00:08:36,160 --> 00:08:37,120
嗯，我没有。

172
00:08:37,160 --> 00:08:38,600
我才刚刚开始。

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

174
00:08:39,480 --> 00:08:41,480
还有一组实验要做。

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

176
00:08:42,120 --> 00:08:42,760
这是什么。

177
00:08:42,760 --> 00:08:44,680
这就是工程学的全部内容。

178
00:08:44,680 --> 00:08:46,320
这是关于实验的。

179
00:08:46,520 --> 00:08:52,340
所以，呃，我已将所有内容重置回块大小 500。

180
00:08:52,380 --> 00:08:54,300
递归字符文本分割器。

181
00:08:54,340 --> 00:08:55,940
这是我们迄今为止最好的结果。

182
00:08:56,060 --> 00:08:59,260
我们现在要更改嵌入模型，即编码器。

183
00:08:59,260 --> 00:09:02,340
所以我们一直在使用all mini Ml6 v2。

184
00:09:02,540 --> 00:09:06,260
因此，让我们导入 OpenAI 嵌入。

185
00:09:06,260 --> 00:09:07,860
让我们进行嵌入。

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

187
00:09:09,620 --> 00:09:14,100
我们将使用嵌入三个小文本的小文本作为模型。

188
00:09:14,300 --> 00:09:15,900
我会对此发表评论。

189
00:09:15,940 --> 00:09:17,740
请注意这里的一件小事。

190
00:09:17,740 --> 00:09:24,220
如果您这样做，请确保在加载点 EMV 后执行此操作，以便您的 OpenAI 密钥

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

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

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

194
00:09:28,060 --> 00:09:30,020
让我们过去回答点pi。

195
00:09:30,060 --> 00:09:32,940
我们还必须更改此处的嵌入。

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

197
00:09:34,220 --> 00:09:35,180
我已经这么做了。

198
00:09:35,220 --> 00:09:39,540
我们不妨注释掉上面的行并确保我们正在导入。

199
00:09:39,540 --> 00:09:41,380
是的，我们正在这里导入它。

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

201
00:09:42,460 --> 00:09:43,500
我们的状态很好。

202
00:09:43,500 --> 00:09:44,540
这就是所需要的一切。

203
00:09:44,580 --> 00:09:48,100
我们现在应该能够尝试使用 OpenAI 的嵌入模型。