1
00:00:00,080 --> 00:00:06,680
所以当抹布真正流行起来时，就像我猜一年前，一年半前，就变成了这样

2
00:00:06,680 --> 00:00:13,600
家庭手工业的抹布技术，你可以做的事情，涉及抹布以使其变得更好。

3
00:00:14,000 --> 00:00:17,360
许多术语都是围绕这些技术发展起来的。

4
00:00:17,360 --> 00:00:22,200
有很多不同的术语和词语，它们听起来都非常科学。

5
00:00:22,360 --> 00:00:25,800
在我看来，这有点伪科学。

6
00:00:25,840 --> 00:00:27,920
我确实想向你澄清这一点。

7
00:00:28,280 --> 00:00:36,120
我认为这些术语试图将一些非常老套、非常非常的东西形式化。

8
00:00:36,120 --> 00:00:37,120
实验性的。

9
00:00:37,120 --> 00:00:42,640
有点尝试这个，尝试重做这个，并尝试组织这一切来解决这个问题

10
00:00:42,680 --> 00:00:45,760
我提到过的痣，就是你做了某事但效果不太好。

11
00:00:45,760 --> 00:00:49,120
你会想，好吧，让我们尝试一下，让我们以不同的方式进行分块。

12
00:00:49,120 --> 00:00:50,080
让我们以不同的方式来做这件事。

13
00:00:50,080 --> 00:00:51,200
让我们尝试一下不同的做法。

14
00:00:51,560 --> 00:00:53,320
他们每个人都是不同的实验。

15
00:00:53,320 --> 00:00:59,920
我经常收到学生的提问，这些不同的抹布技术中哪一种

16
00:00:59,920 --> 00:01:00,640
适用于我吗？

17
00:01:00,680 --> 00:01:02,050
我应该尝试哪一个？

18
00:01:02,210 --> 00:01:08,170
你知道人们喜欢说，在这个行业里，不存在糟糕的问题，

19
00:01:08,170 --> 00:01:10,050
所有问题都是好问题。

20
00:01:10,250 --> 00:01:14,050
但我来这里是想告诉你，不，我不是那些人中的一员。

21
00:01:14,050 --> 00:01:15,610
我认为这是一个糟糕的问题。

22
00:01:15,650 --> 00:01:21,250
我会这么说，因为正如你所知，我会说这是一个糟糕的问题，因为没有

23
00:01:21,250 --> 00:01:22,090
神奇的答案。

24
00:01:22,090 --> 00:01:27,090
我不能告诉你重新排名就是你所需要的，或者你需要这个编码器或类似的东西。

25
00:01:27,090 --> 00:01:34,570
答案是设置一个指标，设置你的评估，运行实验，然后发现没有捷径

26
00:01:34,570 --> 00:01:35,450
实验。

27
00:01:35,570 --> 00:01:36,010
这些。

28
00:01:36,050 --> 00:01:38,090
这是伪科学。

29
00:01:38,130 --> 00:01:42,410
这些不像真正的建筑或类似的东西。

30
00:01:42,410 --> 00:01:47,930
这些只是不同的实验性尝试，不同类型的业务用例和不同的

31
00:01:47,930 --> 00:01:51,290
使用不同的技术，数据集往往会做得更好。

32
00:01:51,290 --> 00:01:56,250
并且，您唯一能做的就是尝试并使用评估来查看和测试它。

33
00:01:56,250 --> 00:01:58,050
因此，我将简要介绍十种技巧。

34
00:01:58,050 --> 00:02:01,610
毫无疑问，我不会提及您最喜欢的一些技术。

35
00:02:01,610 --> 00:02:03,060
别因此而恨我。

36
00:02:03,100 --> 00:02:05,860
您可以通过 Google 搜索或查找其中任何一个。

37
00:02:05,900 --> 00:02:08,140
它们都是从同一块布上剪下来的。

38
00:02:08,300 --> 00:02:09,340
其中很多。

39
00:02:09,340 --> 00:02:11,460
但第一个是你已经知道的。

40
00:02:11,460 --> 00:02:17,100
我们已经做到了，这是对分块的研发，尝试不同的分块策略。

41
00:02:17,100 --> 00:02:22,460
例如，如果你看一下朗格，在我们正在玩的那个包中，有很多不同的

42
00:02:22,500 --> 00:02:26,540
文本拆分器的类型，有时称为拆分器，有时称为分块器。

43
00:02:27,100 --> 00:02:28,740
你可以和他们一起玩。

44
00:02:28,780 --> 00:02:33,300
它们有不同的参数变化，改变你使用的参数并改变参数和

45
00:02:33,300 --> 00:02:36,500
现在进行实验是一件很棒的事情。

46
00:02:36,500 --> 00:02:40,620
当你这样做时，如果你不只是猜测，那总是好的，即使我将其描述为

47
00:02:40,660 --> 00:02:44,140
就像反复试验一样，但你是以一种明智的方式这样做的。

48
00:02:44,300 --> 00:02:49,860
就像通常你会发现一些不适合你的抹布工艺的东西，那就是

49
00:02:49,860 --> 00:02:51,540
导致错误的答案。

50
00:02:51,540 --> 00:02:56,140
然后你尝试改变你的分块策略来解决这个问题。

51
00:02:56,180 --> 00:03:00,860
您还可以在一定程度上进行研发探索，尝试不同的事情

52
00:03:00,860 --> 00:03:01,700
看看会发生什么。

53
00:03:01,900 --> 00:03:08,680
但有一个特定的问题或一个你想要解决或改进的假设通常是件好事

54
00:03:08,880 --> 00:03:11,960
通过改变分块，然后你可以测量它并看看会发生什么。

55
00:03:11,960 --> 00:03:14,280
所以这与分块研发非常相似。

56
00:03:14,280 --> 00:03:20,240
您可能知道我会说编码器根据您的测试选择最佳编码器模型

57
00:03:20,240 --> 00:03:22,040
设定并基于您的业务目标。

58
00:03:22,200 --> 00:03:24,720
人们经常问我有关图像的问题。

59
00:03:25,080 --> 00:03:29,600
你经常想用知识库提出问题，而不仅仅是文本，

60
00:03:29,680 --> 00:03:31,440
它还有图像。

61
00:03:31,440 --> 00:03:33,080
并且有不同的策略。

62
00:03:33,080 --> 00:03:40,600
确实有一些编码器擅长获取图像和文本并将它们映射到一致的

63
00:03:40,600 --> 00:03:43,880
向量空间，你会在句子转换器中找到它们。

64
00:03:43,880 --> 00:03:48,600
如果你看他们的文档和拥抱脸，你会发现他们有专门设计的模型

65
00:03:48,600 --> 00:03:49,160
为此。

66
00:03:49,520 --> 00:03:54,080
但我不得不说，我，我确实倾向于找到它们，呃，碰碰运气。

67
00:03:54,320 --> 00:04:01,680
还有一种不同的、更无聊的策略，你首先使用模型来编写

68
00:04:01,720 --> 00:04:07,930
某事，以最有可能成为问题的方式为图像编写标题

69
00:04:07,930 --> 00:04:08,730
会匹配的。

70
00:04:08,730 --> 00:04:14,690
然后你对该文本进行矢量化，因为你更有可能能够映射图像

71
00:04:14,690 --> 00:04:18,290
在我看来，找到正确的查询，然后对其进行查询。

72
00:04:18,290 --> 00:04:19,890
但这实际上取决于用例。

73
00:04:19,890 --> 00:04:22,250
当然，你不应该相信我的意见。

74
00:04:22,250 --> 00:04:25,650
你应该尝试一下，看看这是否是你正在做的事情。

75
00:04:25,650 --> 00:04:33,530
因此，使用编码器来尝试不同类型的文档，呃，这是高级的重要组成部分

76
00:04:33,530 --> 00:04:34,570
抹布工具包。

77
00:04:34,610 --> 00:04:36,210
所以我在这里还要再说一件事。

78
00:04:36,210 --> 00:04:41,850
人们经常问我有关 PDF 和 Word 文档之类的问题，好吧，

79
00:04:41,890 --> 00:04:43,810
那么我们如何对其进行矢量化呢？

80
00:04:44,050 --> 00:04:46,330
呃，我可能会再说一遍同样的话。

81
00:04:46,530 --> 00:04:50,690
呃，我想说，首先，有一些模型是注定的，例如，

82
00:04:50,730 --> 00:04:57,450
擅长，呃，尝试对 PDF 进行编码，但我不推荐它，因为它是一个二进制对象，并且

83
00:04:57,450 --> 00:04:58,970
它不是为此而设计的。

84
00:04:58,970 --> 00:05:07,260
我想说的是，使用将 PDF 转换为 markdown 的东西，然后对 markdown 进行矢量化，

85
00:05:07,260 --> 00:05:09,340
这是模型接受大量训练的东西。

86
00:05:09,500 --> 00:05:10,380
你知道吗？

87
00:05:10,420 --> 00:05:14,580
我不会使用法学硕士将 PDF 转换为 Markdown。

88
00:05:14,580 --> 00:05:17,620
这是对 LLM 的可怕滥用。

89
00:05:17,620 --> 00:05:18,860
这不是他们擅长的。

90
00:05:18,900 --> 00:05:21,300
你知道 Python 代码有什么好处吗？

91
00:05:21,300 --> 00:05:23,420
请记住，我们曾经是软件开发人员。

92
00:05:23,460 --> 00:05:29,660
您可以通过 pip 安装或在我们的案例中添加大量库，这些库非常适合

93
00:05:29,660 --> 00:05:36,420
解析 PDF，您可以将它们转换为 Markdown 或仅转换为文本或任何有意义的内容

94
00:05:36,420 --> 00:05:37,460
适合您的业务案例。

95
00:05:37,700 --> 00:05:40,740
不同文件格式之间的转换是一个已解决的问题。

96
00:05:40,740 --> 00:05:43,580
你不需要人工智能来为你做这件事。

97
00:05:43,580 --> 00:05:44,940
您可以使用 Python 来完成。

98
00:05:44,940 --> 00:05:45,860
所以你应该这样做。

99
00:05:46,260 --> 00:05:47,540
这就是我的建议。

100
00:05:47,540 --> 00:05:52,860
在这种情况下，如果您有不同的文件格式，我建议使用软件将其转换为

101
00:05:52,900 --> 00:05:57,500
对于法学硕士来说会很有效，有可能通过法学硕士将其转化为某种东西

102
00:05:57,500 --> 00:06:01,140
这对于查询非常有用，然后将其转换为向量。

103
00:06:01,420 --> 00:06:01,900
好的。

104
00:06:01,940 --> 00:06:03,500
关于编码器就足够了。

105
00:06:03,500 --> 00:06:04,380
让我们继续吧。

106
00:06:04,380 --> 00:06:09,310
接下来是一个明显的问题，听起来确实是在按照提示进行操作。

107
00:06:09,350 --> 00:06:14,470
听起来太明显了，甚至不能作为一种先进技术在这里提及，但它确实有很大的不同。

108
00:06:14,470 --> 00:06:20,630
人们在钻研许多听起来很复杂的方法时常常会忽略显而易见的事情。

109
00:06:20,630 --> 00:06:27,110
但请记住，这块内容是为了提供相关的上下文，而且通常是静态的、相关的

110
00:06:27,110 --> 00:06:31,310
您可以将其放入每个提供基本信息的提示中。

111
00:06:31,750 --> 00:06:36,110
而且每次浪费几百个代币什么的也没什么关系。

112
00:06:36,150 --> 00:06:40,870
这并不是一笔大数目的钱，尤其是如果它能让你建立良好的联系的话。

113
00:06:40,870 --> 00:06:46,670
因此，开发良好的提示，您可以将其视为固定的上下文，并执行以下标准技巧

114
00:06:46,670 --> 00:06:48,790
确保将当前日期放在那里。

115
00:06:48,830 --> 00:06:49,550
为什么不呢？

116
00:06:49,590 --> 00:06:54,310
如果这能以某种方式帮助它理解你在说什么，任何相关的上下文

117
00:06:54,310 --> 00:06:58,950
和对话历史记录并正确处理，只需按照提示进行操作就可以做出这样的

118
00:06:58,950 --> 00:06:59,310
不同之处。

119
00:06:59,310 --> 00:07:02,710
这并不是一项先进的技术，但却是人们经常忘记的。

120
00:07:03,310 --> 00:07:05,470
好吧，这是一项先进的技术。

121
00:07:05,470 --> 00:07:08,400
因此，请对此进行文档预处理。

122
00:07:08,680 --> 00:07:14,040
这是说，好吧，当我们拿走我们的文件并准备将它们放在一起时

123
00:07:14,040 --> 00:07:21,360
进入我们的矢量数据存储，也许首先我们可以以这样的方式重写我们的文档

124
00:07:21,360 --> 00:07:24,400
将使它们更适合数据存储。

125
00:07:24,640 --> 00:07:30,160
例如，如果我们有一张从一个地点到另一个地点旅行的票价表，

126
00:07:30,160 --> 00:07:31,920
它就像一张数字表。

127
00:07:31,920 --> 00:07:35,840
当你把它变成一个向量时，它不会很好，因为它就像，

128
00:07:35,880 --> 00:07:37,240
这是一张数字表。

129
00:07:37,640 --> 00:07:42,640
但如果你首先通过法学硕士并说，嘿，这是我知识库的一部分，可以

130
00:07:42,640 --> 00:07:47,080
您以最适合查询的格式重写它？

131
00:07:47,240 --> 00:07:53,640
然后它可以出色地将其转换为文本，这将与向量查找相匹配。

132
00:07:54,000 --> 00:07:56,400
嗯，所以这真是一个很棒的技巧。

133
00:07:56,640 --> 00:08:01,400
一个非常相似的事情是我实际上没有提到的第一件事，那就是当你分块时，

134
00:08:01,400 --> 00:08:06,780
有一种称为语义分块的分块，即当您不仅仅基于相似的分块时

135
00:08:06,820 --> 00:08:12,660
随机地将事物分成不同的部分，但基于每个块的含义

136
00:08:12,660 --> 00:08:13,180
文本。

137
00:08:13,220 --> 00:08:18,820
尝试以一种有意义的方式划分页面，从而使文档被分解

138
00:08:18,820 --> 00:08:23,940
分成不同的部分，反映某人职业生涯的不同阶段或不同方面

139
00:08:23,940 --> 00:08:25,580
产品或类似的东西。

140
00:08:25,820 --> 00:08:29,340
因此，语义分块是一种非常强大的分块策略。

141
00:08:29,340 --> 00:08:33,780
事实上，我认为有一个语义分块器，它是开箱即用的，带有 lang 链

142
00:08:33,780 --> 00:08:35,180
实验包。

143
00:08:35,300 --> 00:08:41,340
呃，但更简单的是作为第四部分的一部分，作为文档预处理的一部分，

144
00:08:41,380 --> 00:08:44,700
通过法学硕士传递它并说，嘿，这是一份文件。

145
00:08:44,700 --> 00:08:51,300
您能否将其分成有意义的块，从意义的角度来看是有意义的，

146
00:08:51,540 --> 00:08:57,620
这样问题将与 1 或 2 个块相关，然后重写它们并以某种方式分割它们

147
00:08:57,620 --> 00:08:59,940
这对于知识库来说是最好的。

148
00:09:00,020 --> 00:09:02,540
所以这实际上是一和四的结合。

149
00:09:02,540 --> 00:09:04,380
这是一项专业技术。

150
00:09:04,580 --> 00:09:10,150
这就是文档预处理，有时也称为纪录片写作，这是真正的一件事。

151
00:09:10,150 --> 00:09:15,350
有一个反面，称为查询重写，这几乎是同一件事。

152
00:09:15,350 --> 00:09:18,870
当用户提出问题时，用户提出问题。

153
00:09:18,870 --> 00:09:25,910
也许这个问题并不完全适合进行基于抹布的查找，或者可能指向一个问题

154
00:09:25,910 --> 00:09:28,070
我们几天前面临的问题。

155
00:09:28,190 --> 00:09:32,870
这个问题可能是之前问题的后续问题，并且要进行完全正确的查找，

156
00:09:32,870 --> 00:09:36,830
你可能想以某种巧妙的方式将其与我们之前所说的结合起来。

157
00:09:37,110 --> 00:09:38,830
而这对于代码来说确实很难做到。

158
00:09:38,830 --> 00:09:39,670
但你猜怎么着？

159
00:09:39,990 --> 00:09:41,910
LLMS 对此很轻松。

160
00:09:41,910 --> 00:09:46,270
因此，使用法学硕士，致电法学硕士并说用户已经问过这个问题。

161
00:09:46,270 --> 00:09:52,470
请以最适合查询知识库的方式重写此代码，并且它

162
00:09:52,470 --> 00:09:54,030
可以做得很好。

163
00:09:54,030 --> 00:09:58,670
您可以传递历史记录并让它做一些反映问题上下文的事情，如下所示

164
00:09:58,670 --> 00:09:59,150
出色地。

165
00:09:59,150 --> 00:10:01,550
这就是所谓的查询重写。

166
00:10:01,550 --> 00:10:03,830
有时也称为查询预处理。

167
00:10:03,990 --> 00:10:08,790
与文档预处理一起，这两者是一对强大的组合。