1
00:00:00,080 --> 00:00:04,240
好吧，希望你和我一样对此感到满意。

2
00:00:04,400 --> 00:00:07,360
我确实发现这些可视化效果真的很酷。

3
00:00:07,440 --> 00:00:08,520
把它弄大一点。

4
00:00:08,520 --> 00:00:09,160
为什么不呢？

5
00:00:09,360 --> 00:00:11,200
并关闭那个边车。

6
00:00:11,240 --> 00:00:11,680
我们开始吧。

7
00:00:11,680 --> 00:00:13,560
现在我们真正得到了它的全部荣耀。

8
00:00:13,760 --> 00:00:15,520
所有不同的点都在那里。

9
00:00:15,640 --> 00:00:22,440
我希望您已经花点时间真正深入研究这个数据可视化，但也许

10
00:00:22,440 --> 00:00:25,320
我们还可以做一些更酷的事情。

11
00:00:25,360 --> 00:00:30,880
您可能不会忘记，正如我之前提到的，我们人类能够走得更远一点

12
00:00:30,880 --> 00:00:31,480
比二维。

13
00:00:31,560 --> 00:00:39,120
我们可以以 3D 方式查看事物，如果我没有为您带来 3D 表示，我就无法完成我的工作

14
00:00:39,120 --> 00:00:40,040
这也是如此。

15
00:00:40,200 --> 00:00:45,720
t-SNE 只需传递多个组件（三个而不是两个）即可做到这一点。

16
00:00:45,880 --> 00:00:52,600
呃，我们可以将 384 维空间投影到 3D，看看效果如何。

17
00:00:52,600 --> 00:00:54,080
那么让我们来看看吧。

18
00:00:54,280 --> 00:00:56,240
就在这里，它马上就出现了。

19
00:00:56,280 --> 00:00:56,880
嘭！

20
00:00:57,200 --> 00:01:05,250
我在那里向您展示，呃，我们的点是 3D 空间中显示的 400 个块。

21
00:01:05,250 --> 00:01:06,250
我听到了。

22
00:01:06,290 --> 00:01:10,610
你可能会说，哦，乍一看，这看起来有点乱。

23
00:01:10,730 --> 00:01:12,410
呃，我更喜欢2D版本。

24
00:01:12,450 --> 00:01:17,730
呃，但是等等，呃，你可以，首先，将鼠标悬停在这些点上以获取它们的描述

25
00:01:17,730 --> 00:01:19,730
像这样看看它们在空间中的位置。

26
00:01:19,970 --> 00:01:26,650
而且，你还可以像这样旋转整个空间，检查一下并获得真正的感觉

27
00:01:26,690 --> 00:01:26,850
你。

28
00:01:26,850 --> 00:01:31,090
真正更好地理解那些蓝色，虽然它们有点位于红色的中间，

29
00:01:31,130 --> 00:01:33,610
他们在某种程度上属于自己的集群。

30
00:01:33,730 --> 00:01:36,650
嗯，黄色也有自己的分布。

31
00:01:36,810 --> 00:01:41,450
呃，你真的可以通过像这样放大来磨练。

32
00:01:41,610 --> 00:01:45,090
检查一下，进来探索不同的点。

33
00:01:45,090 --> 00:01:49,370
因此，尽管这些黄色看起来更接近红色，但它们看起来确实不一样

34
00:01:49,410 --> 00:01:50,050
在它。

35
00:01:50,090 --> 00:01:52,690
现在您可以看到它们的分布方式如何不同。

36
00:01:52,930 --> 00:01:59,370
因此，即使 2D 比 3D 更容易查看，您也可以探索和研究

37
00:01:59,370 --> 00:02:02,890
3D 的功能还有很多，我鼓励您享受其中的乐趣。

38
00:02:02,930 --> 00:02:07,130
当然，正确使用它的方式是发现异常情况。

39
00:02:07,170 --> 00:02:07,890
现货如何？

40
00:02:07,890 --> 00:02:11,890
嗯，呃，不同的文档按照相似性进行分组。

41
00:02:12,010 --> 00:02:17,890
深入挖掘并尝试发现错误，并为您提供有关如何使用不同编码器的线索。

42
00:02:18,130 --> 00:02:25,010
但它也很有趣，并且它为拥有这些向量意味着什么提供了很好的直觉。

43
00:02:25,050 --> 00:02:29,930
同样，您可以将其想象为我们将这些向量可视化为色度。

44
00:02:29,970 --> 00:02:35,210
请始终记住，我们实际上正在可视化这些向量，因为它们已存储在色度中。

45
00:02:35,210 --> 00:02:37,570
但矢量不是由色度创建的。

46
00:02:37,610 --> 00:02:43,770
这些向量是由拥抱脸句子转换器模型或迷你 lm、l6 v2 创建的。

47
00:02:44,010 --> 00:02:50,450
这就是将 400 个左右的块转变为 304 维空间中的这些点的原因。

48
00:02:50,730 --> 00:02:52,850
现在我的下一个技巧。

49
00:02:53,730 --> 00:03:00,490
呃，我想深入探讨这个想法，即编码器决定这些点的位置

50
00:03:00,490 --> 00:03:01,690
在太空中。

51
00:03:01,690 --> 00:03:06,770
还有什么比尝试不同的编码器更好的方法来说明这一点呢？

52
00:03:07,010 --> 00:03:12,570
那么让我们回去尝试不同的编码器。

53
00:03:12,610 --> 00:03:18,090
回到这里，我将注释掉我们设置嵌入模型的位置。

54
00:03:18,290 --> 00:03:25,930
在这里，我们首先看一下来自 OpenAI 的文本嵌入三个小模型。

55
00:03:26,090 --> 00:03:27,570
让我们看看这个。

56
00:03:27,810 --> 00:03:28,810
让我们运行这个。

57
00:03:28,810 --> 00:03:31,210
你记住的这段代码将删除我的数据库。

58
00:03:31,210 --> 00:03:34,690
创建一个包含 413 个文档的新数据库。

59
00:03:34,730 --> 00:03:36,890
再次放入相同的块。

60
00:03:37,050 --> 00:03:38,050
让我们再运行一​​次。

61
00:03:38,050 --> 00:03:42,850
请记住，您可以在这里看到我们之前有 384 个维度。

62
00:03:42,890 --> 00:03:49,290
从拥抱脸模型我们现在有 1536 个维度。

63
00:03:49,290 --> 00:03:51,450
因为我们使用不同的嵌入模型。

64
00:03:51,450 --> 00:03:52,650
我们用的是付费的。

65
00:03:52,650 --> 00:03:54,730
但 OpenAI 的价格非常非常便宜。

66
00:03:54,890 --> 00:03:56,570
文本嵌入三个小。

67
00:03:56,570 --> 00:03:56,860
全部。

68
00:03:57,180 --> 00:03:59,780
好吧，让我们再回去想象一下。

69
00:03:59,820 --> 00:04:02,220
我们将做前期工作来获取我们的文件。

70
00:04:02,420 --> 00:04:03,420
现在我们到了。

71
00:04:03,460 --> 00:04:09,700
因此，在运行此单元之前，让我们再看一下它之前的样子。

72
00:04:09,900 --> 00:04:11,380
这是以前的样子。

73
00:04:11,500 --> 00:04:18,780
我们现在将运行它并生成新向量的新可视化，因为它们来自

74
00:04:18,780 --> 00:04:21,180
改为 OpenAI 小模型。

75
00:04:21,180 --> 00:04:21,540
好的。

76
00:04:21,540 --> 00:04:22,140
你准备好了吗？

77
00:04:22,140 --> 00:04:23,060
请牢记这一点。

78
00:04:23,100 --> 00:04:24,260
继续保留那张照片。

79
00:04:24,300 --> 00:04:27,300
如果你有过目不忘的记忆力，希望它就在那里。

80
00:04:27,340 --> 00:04:29,460
让我们再次运行一下，看看现在是什么样子。

81
00:04:30,140 --> 00:04:30,540
好的。

82
00:04:30,580 --> 00:04:31,380
它发生了。

83
00:04:31,420 --> 00:04:32,500
我们就有了。

84
00:04:32,780 --> 00:04:33,420
好的。

85
00:04:34,060 --> 00:04:35,420
它看起来完全不同。

86
00:04:35,420 --> 00:04:39,540
所以首先，它全部旋转的事实并不意味着什么。

87
00:04:39,540 --> 00:04:43,580
请记住，实际的 x 和 y 坐标没有任何意义。

88
00:04:43,580 --> 00:04:48,380
重要的是文档的分离程度。

89
00:04:48,580 --> 00:04:52,420
看看 OpenAI 的模型做得有多好。

90
00:04:52,420 --> 00:04:56,180
看看员工的证件都在这里了。

91
00:04:56,430 --> 00:05:00,510
看看，呃，合同是怎么在这里的。

92
00:05:00,630 --> 00:05:05,510
现在您可以看到，这些产品处于完全不同的位置。

93
00:05:05,670 --> 00:05:08,310
呃，除了这里的一些文件。

94
00:05:08,310 --> 00:05:14,030
如果你仔细研究一下，你会发现，这些部分是特别的

95
00:05:14,030 --> 00:05:16,030
围绕产品的特点。

96
00:05:16,030 --> 00:05:21,430
这与这里的文本非常相似，这是合同的一部分

97
00:05:21,430 --> 00:05:22,870
与特征有关。

98
00:05:22,870 --> 00:05:28,150
所以你会发现，当你使用像 OpenAI 这样的模型时，它真的非常好。

99
00:05:28,190 --> 00:05:31,670
OpenAI 嵌入模型和关联含义。

100
00:05:31,670 --> 00:05:35,870
在这里你会看到公司的东西都在这里。

101
00:05:35,870 --> 00:05:40,590
在此条带中，您会看到这里有几条员工记录。

102
00:05:40,590 --> 00:05:45,270
这些将是员工记录的一部分，似乎与有关该信息的信息相关。

103
00:05:45,270 --> 00:05:45,870
公司。

104
00:05:45,950 --> 00:05:48,630
呃，如果你深入研究，我希望你会发现这一点。

105
00:05:49,150 --> 00:05:57,030
但是现在让我们返回并进行另一项更改并将其更改为大型模型，然后

106
00:05:57,030 --> 00:05:58,150
看看看起来怎么样。

107
00:05:58,150 --> 00:06:04,150
因此，我回到嵌入模型部分，我们将进行文本嵌入三个大的。

108
00:06:04,310 --> 00:06:05,510
让我们运行这个。

109
00:06:05,910 --> 00:06:12,750
现在我们希望将 413 个文档转换为更大的向量。

110
00:06:12,750 --> 00:06:13,710
那么大多少呢。

111
00:06:13,710 --> 00:06:14,550
我们来看看吧。

112
00:06:14,550 --> 00:06:24,470
之前我们有 1536 个与每个向量相关的维度，现在我们有 3072 个维度，3072

113
00:06:24,470 --> 00:06:29,430
向量存储中与 413 个块相关的维度。

114
00:06:29,750 --> 00:06:31,910
好吧，是时候想象一下了。

115
00:06:31,950 --> 00:06:33,150
记住它的样子。

116
00:06:33,150 --> 00:06:35,590
这就是小版本的外观。

117
00:06:35,630 --> 00:06:37,950
让我们看看大版本。

118
00:06:38,190 --> 00:06:39,990
呃，就在这里。

119
00:06:40,390 --> 00:06:41,030
好的。

120
00:06:41,470 --> 00:06:44,790
呃，又是一步。

121
00:06:44,790 --> 00:06:49,070
更好地再次看看，首先，像以前一样，员工在左边。

122
00:06:49,070 --> 00:06:50,230
现在没关系。

123
00:06:50,510 --> 00:06:56,720
除了这两部分之外，它们显然是非常独立的，嗯，你可以

124
00:06:56,720 --> 00:06:58,840
看看这两个词中都有“确保”一词。

125
00:06:58,840 --> 00:07:04,040
因此，这些是员工文件中似乎最能说明公司的两个片段：

126
00:07:04,040 --> 00:07:04,680
一个整体。

127
00:07:04,840 --> 00:07:09,360
现在您可以看到蓝色和红色之间的分离更加明显。

128
00:07:09,400 --> 00:07:16,360
更智能的模型在理解之间的不同语义方面做得更好

129
00:07:16,360 --> 00:07:17,200
这些块。

130
00:07:17,360 --> 00:07:23,400
嗯，在这里你会发现这确实仍然是关于

131
00:07:23,440 --> 00:07:27,520
似乎最属于合同的功能。

132
00:07:27,520 --> 00:07:29,520
所以你可以看到这就是它这样做的原因。

133
00:07:29,680 --> 00:07:32,960
再看看这里，它是产品的一部分。

134
00:07:32,960 --> 00:07:37,040
这是合同中与产品有关的部分，这就是为什么它们无处不在

135
00:07:37,040 --> 00:07:38,200
同一领土。

136
00:07:38,200 --> 00:07:40,200
绝对令人着迷。

137
00:07:40,200 --> 00:07:43,840
您可以看到大型模型做得更好。

138
00:07:43,840 --> 00:07:49,600
所以我们真的看到了我们如何，我们已经在小拥抱脸模型之间迈出了一步，然后

139
00:07:49,600 --> 00:07:57,560
OpenAI 的小版本，仍然很大，然后是 3072 尺寸的大版本

140
00:07:57,560 --> 00:08:00,760
以及如何将数据如此分离。

141
00:08:00,760 --> 00:08:06,600
值得指出的是，人们很容易认为大模型更好的原因

142
00:08:06,600 --> 00:08:08,840
是因为它有更多的维度。

143
00:08:08,960 --> 00:08:14,080
通常情况下，像更大的模型会产生向量嵌入

144
00:08:14,080 --> 00:08:19,240
更高的维度，让它能够以更多的自由度来表达事物。

145
00:08:19,240 --> 00:08:20,520
但情况并非总是如此。

146
00:08:20,520 --> 00:08:22,080
但事实并非必须如此。

147
00:08:22,080 --> 00:08:29,160
重要的是它是一个更先进的转换器，能够更好地捕捉文本的含义，

148
00:08:29,160 --> 00:08:33,200
我认为，能够在更多维度上表达这一点，会赋予它更多的力量来做到这一点。

149
00:08:33,200 --> 00:08:35,320
所以它们往往有一定的相关性。

150
00:08:35,320 --> 00:08:41,760
但我们确实在大约 400 个维度之间移动，最初是拥抱脸模型的 384 个维度，现在是大约 1000 个维度

151
00:08:41,760 --> 00:08:44,480
尺寸，1005到大约3000尺寸。

152
00:08:44,480 --> 00:08:50,000
当我们研究这三个嵌入模型时，我知道，我确切地知道你在等我什么

153
00:08:50,000 --> 00:08:50,160
去做。

154
00:08:50,200 --> 00:08:52,360
你等着我制作 3D 情节。

155
00:08:52,400 --> 00:08:54,160
我也在想。

156
00:08:54,200 --> 00:08:56,360
让我们这样做然后进去吧。

157
00:08:56,400 --> 00:08:57,800
还记得旧的 3D 情节吗？

158
00:08:57,840 --> 00:09:00,160
这是旧款，带有抱脸模型。

159
00:09:00,360 --> 00:09:01,280
有点乱。

160
00:09:01,400 --> 00:09:04,000
现在让我们创建一个新的 3D 绘图。

161
00:09:04,040 --> 00:09:05,440
我知道这就是你在等待的。

162
00:09:05,480 --> 00:09:06,240
这里是。

163
00:09:06,440 --> 00:09:09,880
嗯，你知道，它仍然有点混乱，因为这些 3D 绘图可能会很混乱。

164
00:09:09,880 --> 00:09:11,240
但看看这个。

165
00:09:11,280 --> 00:09:14,120
看看如果我操纵我们会发生什么。

166
00:09:14,160 --> 00:09:18,040
看看这四个斑点是多么清晰地分开。

167
00:09:18,280 --> 00:09:22,400
同样，合同和产品之间存在一些重叠。

168
00:09:22,400 --> 00:09:25,680
这是因为这些类型的文档存在一些重叠。

169
00:09:25,720 --> 00:09:31,880
合同中包含一些与产品相关的信息，如果您深入研究这些文档，您就会看到这一点。

170
00:09:31,880 --> 00:09:35,080
但总的来说，这真是令人惊奇。

171
00:09:35,120 --> 00:09:41,240
它真的让你这个、这个、这个很好地理解文档的含义，

172
00:09:41,280 --> 00:09:43,760
将其转化为空间向量。

173
00:09:43,960 --> 00:09:47,640
我希望您喜欢它，并且我鼓励您更多地探索这一点。

174
00:09:47,640 --> 00:09:49,200
现在继续解决这个问题。

175
00:09:49,200 --> 00:09:51,800
查看有靠近的点的不同点。

176
00:09:51,930 --> 00:09:57,570
让自己确信这些块的内容是相似的，并很好地了解它是什么

177
00:09:57,570 --> 00:10:02,250
模型需要将一些数据放置在向量空间中的某个位置。

178
00:10:02,250 --> 00:10:04,930
这就是这个伟大日子的总结。

179
00:10:04,970 --> 00:10:08,370
我希望您同意我的介绍是真实的。

180
00:10:08,530 --> 00:10:10,050
今天很有趣。

181
00:10:10,210 --> 00:10:12,930
这些矢量可视化，这就是它的全部内容。

182
00:10:13,090 --> 00:10:17,770
呃，我非常鼓励你现在尝试不同的编码器。

183
00:10:17,810 --> 00:10:19,770
去吧，去尝试一些不同的嵌入模型。

184
00:10:19,770 --> 00:10:21,850
你可以查找它们，你可以做不同的开源的。

185
00:10:21,850 --> 00:10:26,490
或者，如果您有 Gemini 帐户，您也可以尝试像 Gemini 那样操作。

186
00:10:26,530 --> 00:10:29,090
对它们进行实验，然后查看可视化效果。

187
00:10:29,090 --> 00:10:35,010
使用编码器模型非常有趣，并且可以获得良好的感觉，良好的直觉

188
00:10:35,050 --> 00:10:36,930
它们如何以不同的方式表示信息。

189
00:10:37,210 --> 00:10:43,330
无论如何，回顾一下，此时您可以使用前沿模型、助手生成文本和代码

190
00:10:43,330 --> 00:10:46,050
和工具、开源模型、拥抱变形金刚。

191
00:10:46,050 --> 00:10:50,010
您可以使用基准排行榜为您的项目选择正确的模型。

192
00:10:50,010 --> 00:10:57,980
您可以解释 Rag 如何使用矢量嵌入和矢量数据存储将文本转换为文档，

193
00:10:57,980 --> 00:11:03,420
成块，将块转换成向量，将向量放入数据存储中，向量就像

194
00:11:03,420 --> 00:11:05,140
索引到数据中。

195
00:11:05,380 --> 00:11:10,300
我们使用了开源数据库 chroma，它可能是您现在使用的第一个矢量数据库

196
00:11:10,300 --> 00:11:11,820
已在您的计算机上运行。

197
00:11:11,820 --> 00:11:12,740
极好的。

198
00:11:13,020 --> 00:11:18,700
下次，下次我们真正构建Rag管道时，我们使用Lang Chain来构建Rag管道。

199
00:11:18,700 --> 00:11:19,780
超级简单。

200
00:11:19,820 --> 00:11:26,220
我们像一个基于破布的专家问答者一样提供服务，您将能够做到，我们将创建类似

201
00:11:26,260 --> 00:11:32,060
一个基于 Gradio 的聊天机器人应用程序，不仅会显示问题的答案，而且还能够

202
00:11:32,060 --> 00:11:34,180
显示它使用的文档。

203
00:11:34,220 --> 00:11:37,260
这是帮助它回答问题的参考。

204
00:11:37,260 --> 00:11:40,820
我们的 Rag 管道呈现了相关的背景。

205
00:11:40,820 --> 00:11:42,740
我们将在明天完成所有这些工作。

206
00:11:42,940 --> 00:11:49,540
此时，您已完成 55% 成为 LLM 工程师的任务。

207
00:11:50,020 --> 00:11:50,900
明天见。