1
00:00:00,000 --> 00:00:02,160
不管你平常有沒有在深入研究AI

2
00:00:02,160 --> 00:00:03,700
你很可能都動過這個念頭

3
00:00:03,700 --> 00:00:05,100
能不能幫自己或團隊

4
00:00:05,100 --> 00:00:06,700
做一個隨問隨答的第二大腦

5
00:00:06,700 --> 00:00:07,940
或是幫你的AI agent

6
00:00:07,940 --> 00:00:09,800
接上一整個專屬的知識庫

7
00:00:10,240 --> 00:00:11,500
只要你想做這件事

8
00:00:11,500 --> 00:00:13,500
就一定會碰上RAG這個觀念

9
00:00:14,000 --> 00:00:15,640
如果你平常就很關注AI

10
00:00:15,640 --> 00:00:16,700
可能會覺得奇怪

11
00:00:16,700 --> 00:00:17,800
都2026年了

12
00:00:17,800 --> 00:00:19,000
為什麼還在講RAG

13
00:00:19,400 --> 00:00:21,200
但對於在意公司資料隱私的人

14
00:00:21,200 --> 00:00:23,200
或是想打造個人知識庫的人來說

15
00:00:23,200 --> 00:00:24,160
RAG的價值在於

16
00:00:24,160 --> 00:00:26,500
你可以只為給模型你自己認證過的資料

17
00:00:26,500 --> 00:00:28,700
讓他盡可能從這些資料裡回答問題

18
00:00:28,700 --> 00:00:31,000
而不是像通用的ChatGPT一樣

19
00:00:31,000 --> 00:00:33,000
給出每個人都拿得到的答案

20
00:00:33,400 --> 00:00:35,500
如果你累積了幾十年的產業經驗

21
00:00:35,500 --> 00:00:38,000
想讓這些知識在公司內部流通傳承

22
00:00:38,000 --> 00:00:40,200
或者你有建立個人知識庫的習慣

23
00:00:40,200 --> 00:00:41,900
希望你的agent在回答時

24
00:00:41,900 --> 00:00:44,000
以你的知識庫作為最主要的依據

25
00:00:44,000 --> 00:00:45,900
就會用到RAG這個技術

26
00:00:45,900 --> 00:00:47,500
所以今天這支影片

27
00:00:47,500 --> 00:00:48,700
就算你是RAG小白

28
00:00:48,700 --> 00:00:50,200
我也會帶你搞懂這個技術

29
00:00:50,200 --> 00:00:51,500
讓你知道RAG是什麼

30
00:00:51,500 --> 00:00:53,400
如果你已經有在實作自己的RAG

31
00:00:53,400 --> 00:00:55,700
我也會分享實作時最容易踩到的坑

32
00:00:55,700 --> 00:00:58,400
以及該怎麼一步一步把一個RAG做對

33
00:00:58,400 --> 00:00:59,100
做好

34
00:00:59,100 --> 00:01:00,400
那我們直接開始

35
00:01:00,900 --> 00:01:03,200
那我們一樣用一個生活化的例子來介紹RAG

36
00:01:03,200 --> 00:01:04,600
這樣可能會比較好理解

37
00:01:04,600 --> 00:01:06,200
假設你是一位價值投資人

38
00:01:06,200 --> 00:01:07,400
而巴菲特是你的偶像

39
00:01:07,400 --> 00:01:09,900
你想要把他投資的整套方法論都學過來

40
00:01:10,400 --> 00:01:11,900
過去你只能看看他的書

41
00:01:11,900 --> 00:01:12,900
聽聽他的訪談

42
00:01:12,900 --> 00:01:15,200
自己慢慢領悟巴菲特的投資邏輯

43
00:01:15,200 --> 00:01:16,600
但現在有了AI

44
00:01:16,600 --> 00:01:18,300
你開始幻想自己是否有能力

45
00:01:18,300 --> 00:01:19,400
讓手邊的這個AI

46
00:01:19,400 --> 00:01:21,100
變成巴菲特的數位分身

47
00:01:21,100 --> 00:01:23,100
這樣我之後在做任何投資決策

48
00:01:23,100 --> 00:01:24,700
或是看不懂一家公司的時候

49
00:01:24,700 --> 00:01:25,700
就可以直接問他了

50
00:01:26,200 --> 00:01:28,200
那麼第一步你會怎麼做

51
00:01:28,200 --> 00:01:30,100
你學過怎麼寫好一份提示詞

52
00:01:30,100 --> 00:01:32,100
所以你明白定義角色的重要性

53
00:01:32,100 --> 00:01:33,800
所以你直接打開了ChatGPT

54
00:01:33,800 --> 00:01:36,000
跟他說請扮演古神巴菲特

55
00:01:36,000 --> 00:01:38,100
並用他的思維回答我以下的問題

56
00:01:39,000 --> 00:01:40,300
剛開始效果還不錯

57
00:01:40,300 --> 00:01:42,300
畢竟大語言模型本來就學過很多

58
00:01:42,300 --> 00:01:44,400
巴菲特的經典名言和投資原則

59
00:01:44,400 --> 00:01:46,400
問什麼護城河 安全編輯

60
00:01:46,400 --> 00:01:47,800
他都能講得頭頭是道

61
00:01:48,400 --> 00:01:50,000
但聊著聊著你就會發現

62
00:01:50,000 --> 00:01:51,500
只要你問得稍微深一點

63
00:01:51,500 --> 00:01:52,100
細一點

64
00:01:52,100 --> 00:01:53,700
模型就開始出現幻覺

65
00:01:53,700 --> 00:01:55,600
有時候會一本正經的胡說八道

66
00:01:55,600 --> 00:01:57,600
給出完全錯誤的年份或數字

67
00:01:57,600 --> 00:02:00,500
甚至引用了巴菲特從來沒有說過的話

68
00:02:00,500 --> 00:02:01,500
這時候你就想

69
00:02:01,500 --> 00:02:03,800
那我乾脆把巴菲特所有的資料全部載下來

70
00:02:03,800 --> 00:02:05,800
當作檔案附件直接喂給AI

71
00:02:05,800 --> 00:02:07,200
讓AI看著資料回答

72
00:02:07,200 --> 00:02:08,100
總不會錯了吧

73
00:02:08,500 --> 00:02:09,100
於是

74
00:02:09,100 --> 00:02:11,000
你把巴菲特60年的股東信

75
00:02:11,000 --> 00:02:12,700
30幾年的股東會逐字稿

76
00:02:12,700 --> 00:02:13,800
全部下載下來

77
00:02:13,800 --> 00:02:15,000
打包成一個大檔案

78
00:02:15,000 --> 00:02:17,200
然後拖進對話框並按下送出

79
00:02:17,600 --> 00:02:18,700
結果下一秒

80
00:02:18,700 --> 00:02:20,400
畫面立刻跳出一行紅字

81
00:02:20,400 --> 00:02:22,200
跟你說檔案內容超過上限

82
00:02:22,200 --> 00:02:23,800
請縮減資料後再試

83
00:02:24,300 --> 00:02:25,500
這是你撞到的第一個牆

84
00:02:25,500 --> 00:02:28,200
Context Window也就是模型在一次對話裡

85
00:02:28,200 --> 00:02:29,800
能容納的記憶上限

86
00:02:29,800 --> 00:02:30,900
你的問題

87
00:02:30,900 --> 00:02:32,200
你貼給他的資料

88
00:02:32,200 --> 00:02:33,700
再加上他要回答的字數

89
00:02:33,700 --> 00:02:35,400
全部都要算在這個上限裡

90
00:02:35,400 --> 00:02:38,000
如果今天巴菲特只寫過薄薄一本書

91
00:02:38,000 --> 00:02:39,800
你整包丟進去確實沒問題

92
00:02:39,800 --> 00:02:40,900
簡單又省事

93
00:02:40,900 --> 00:02:42,300
你甚至不需要學RAC

94
00:02:42,300 --> 00:02:43,700
但巴菲特的資料量

95
00:02:43,700 --> 00:02:45,500
光是英文單字就有幾百萬字

96
00:02:45,500 --> 00:02:47,000
換算成AI的計算單位

97
00:02:47,000 --> 00:02:48,500
Token也是高達兩三百萬

98
00:02:48,500 --> 00:02:50,700
現在主流模型就算胃口再大

99
00:02:50,700 --> 00:02:52,700
上限頂多也就一百萬Token左右

100
00:02:52,700 --> 00:02:53,700
而你手上的資料

101
00:02:53,700 --> 00:02:55,300
足足是他的兩到三倍

102
00:02:55,300 --> 00:02:57,700
而且這還不只是Token太多

103
00:02:57,700 --> 00:02:58,700
塞不下的問題

104
00:02:58,700 --> 00:03:00,400
就算你退一步

105
00:03:00,400 --> 00:03:03,000
把資料砍到剛好塞得進模型的上下文

106
00:03:03,000 --> 00:03:05,200
也會立刻碰上另外兩個現實問題

107
00:03:05,200 --> 00:03:06,900
那就是回答又慢又貴

108
00:03:06,900 --> 00:03:08,100
為什麼

109
00:03:08,100 --> 00:03:10,400
因為大語言模型本質上是Stayless的

110
00:03:10,400 --> 00:03:12,600
也就是根本不會記住你未給他的檔案

111
00:03:12,600 --> 00:03:14,000
你每問一個新問題

112
00:03:14,000 --> 00:03:16,400
這一整大包資料就要重頭重新讀一遍

113
00:03:16,400 --> 00:03:17,100
你問10題

114
00:03:17,100 --> 00:03:18,300
他就重讀10次

115
00:03:18,300 --> 00:03:21,100
所以你每問一句他都要重新消化幾十萬字

116
00:03:21,100 --> 00:03:22,000
慢得要死

117
00:03:22,000 --> 00:03:24,000
頂級模型每讀一次上百萬Token

118
00:03:24,000 --> 00:03:25,400
就要幾塊甚至20美金

119
00:03:25,400 --> 00:03:26,600
隨便問個10題

120
00:03:26,600 --> 00:03:27,900
你的額度就扛不住了

121
00:03:27,900 --> 00:03:29,000
資料越多

122
00:03:29,000 --> 00:03:29,900
你就等得越久

123
00:03:29,900 --> 00:03:30,700
花得越多

124
00:03:30,700 --> 00:03:32,500
繞了一圈你會發現

125
00:03:32,500 --> 00:03:34,100
問題的盲點到底在哪裡

126
00:03:34,100 --> 00:03:35,600
就是我們每一次

127
00:03:35,600 --> 00:03:37,400
都逼AI把全部的資料

128
00:03:37,400 --> 00:03:38,400
從頭啃一遍

129
00:03:38,400 --> 00:03:40,000
可是你想想看

130
00:03:40,000 --> 00:03:42,000
你問巴菲特怎麼看待護城河

131
00:03:42,000 --> 00:03:43,200
真正用得上的內容

132
00:03:43,200 --> 00:03:44,800
往往就只有那兩三段而已

133
00:03:44,800 --> 00:03:46,600
那我們何不換個思路

134
00:03:46,600 --> 00:03:49,200
先把真正用得上的那兩三段找出來

135
00:03:49,200 --> 00:03:51,000
只交給AI讀不就好了

136
00:03:51,000 --> 00:03:52,300
這個做法

137
00:03:52,300 --> 00:03:53,100
就是RAG

138
00:03:53,100 --> 00:03:56,500
它其實完全符合我們人類自己查資料的直覺

139
00:03:56,500 --> 00:03:58,600
你想知道巴菲特怎麼講護城河

140
00:03:58,600 --> 00:04:01,600
你絕不可能把60年的信從第一封讀到最後一封

141
00:04:01,600 --> 00:04:03,300
你一定會打開搜尋框

142
00:04:03,300 --> 00:04:04,300
輸入護城河

143
00:04:04,300 --> 00:04:06,800
把那幾段翻出來讀完再整理出答案

144
00:04:06,800 --> 00:04:09,600
RAG只是讓AI也照這個方式做事而已

145
00:04:09,600 --> 00:04:11,400
RAG這三個字母

146
00:04:11,400 --> 00:04:13,100
正好對應這三個動作

147
00:04:13,100 --> 00:04:14,500
R是Retrieval

148
00:04:14,500 --> 00:04:15,100
檢索

149
00:04:15,100 --> 00:04:16,200
也就是打開搜尋

150
00:04:16,200 --> 00:04:17,600
把相關段落找出來

151
00:04:17,600 --> 00:04:19,000
A是Augmented

152
00:04:19,000 --> 00:04:19,500
增強

153
00:04:19,500 --> 00:04:21,700
把找到的段落跟你的問題拼在一起

154
00:04:21,700 --> 00:04:23,000
攤在AI眼前

155
00:04:23,000 --> 00:04:24,200
G是Generation

156
00:04:24,200 --> 00:04:24,800
生成

157
00:04:24,800 --> 00:04:27,000
讓AI看著這幾段精準寫出答案

158
00:04:27,000 --> 00:04:29,600
中文翻成檢索增強生成

159
00:04:29,600 --> 00:04:30,900
聽起來像學術論文

160
00:04:30,900 --> 00:04:32,300
但說穿了就一句話

161
00:04:32,300 --> 00:04:33,900
先查資料再回答

162
00:04:33,900 --> 00:04:35,300
既然RAG的本質是

163
00:04:35,300 --> 00:04:36,700
先查資料再回答

164
00:04:36,700 --> 00:04:38,900
那我們真的要動手做一個巴菲特的RAG

165
00:04:38,900 --> 00:04:40,000
整個流程就直接照

166
00:04:40,000 --> 00:04:41,800
RAG這三個字母走

167
00:04:41,800 --> 00:04:43,100
R是把資料整理好

168
00:04:43,100 --> 00:04:44,100
建好鎖印

169
00:04:44,100 --> 00:04:45,100
讓系統找得到

170
00:04:45,100 --> 00:04:46,400
A是從找到的東西裡

171
00:04:46,400 --> 00:04:47,700
挑出最好的幾張

172
00:04:47,700 --> 00:04:49,600
拼成一份乾淨的小鈔遞給AI

173
00:04:49,600 --> 00:04:50,800
G是調教AI

174
00:04:50,800 --> 00:04:53,100
讓他看著小鈔把答案寫對

175
00:04:53,100 --> 00:04:54,300
這三步裡最長

176
00:04:54,300 --> 00:04:55,500
也最容易被忽略的

177
00:04:55,500 --> 00:04:56,600
就是R

178
00:04:56,600 --> 00:04:58,000
而R又分成兩半

179
00:04:58,000 --> 00:04:59,500
前半是把書架整理好

180
00:04:59,500 --> 00:05:00,000
後半才


1
00:05:00,000 --> 00:05:01,280
甚至去書架上找書

2
00:05:01,800 --> 00:05:04,360
很多人做RAC第一步就跳去調向量資料庫

3
00:05:04,360 --> 00:05:05,880
或是寫檢索演算法

4
00:05:05,880 --> 00:05:07,420
但後面很多AI找不到答案

5
00:05:07,420 --> 00:05:08,700
或者回答鬼打牆的問題

6
00:05:08,700 --> 00:05:11,000
九成以上的根源通通都在資料本身

7
00:05:11,000 --> 00:05:13,320
也就是整理書架的這前半段

8
00:05:14,080 --> 00:05:15,360
回到我們手上的東西

9
00:05:15,360 --> 00:05:17,660
你現在有巴菲特60年的股東信

10
00:05:17,660 --> 00:05:19,200
30幾年的股東會逐字稿

11
00:05:19,200 --> 00:05:20,740
整整一大包純文字

12
00:05:21,000 --> 00:05:23,560
如果要讓它變成AI可以查閱的專屬知識庫

13
00:05:23,560 --> 00:05:24,840
下一步應該怎麼做

14
00:05:25,080 --> 00:05:26,620
答案就是清洗資料

15
00:05:26,620 --> 00:05:29,180
但清洗資料不是單純的順手改改錯字

16
00:05:29,180 --> 00:05:32,260
文本清洗的兩個核心目標是拉高資訊密度

17
00:05:32,260 --> 00:05:33,780
以及確保語意獨立

18
00:05:33,780 --> 00:05:35,060
接下來我們一個一個講

19
00:05:35,580 --> 00:05:37,120
第一是拉高資訊密度

20
00:05:37,120 --> 00:05:38,900
你抓下來的逐字稿和檔案

21
00:05:38,900 --> 00:05:40,960
裡面充滿了大量檢索不需要的雜訊

22
00:05:40,960 --> 00:05:43,260
像是PDF轉檔留下的夜首夜尾

23
00:05:43,260 --> 00:05:44,280
主持人的寒暄

24
00:05:44,280 --> 00:05:45,060
現場笑聲

25
00:05:45,060 --> 00:05:47,360
或是請下一位股東到3號麥克風提問

26
00:05:47,360 --> 00:05:48,380
這種過場廢話

27
00:05:48,380 --> 00:05:49,660
如果不把這些清掉

28
00:05:49,660 --> 00:05:51,460
AI到時候就很容易撈出垃圾

29
00:05:51,460 --> 00:05:53,500
白白浪費模型的上下文空間

30
00:05:54,020 --> 00:05:55,540
第二是確保語意完整

31
00:05:55,540 --> 00:05:57,340
口語對話通常非常破碎

32
00:05:57,340 --> 00:05:59,140
巴菲特講話常常省略主詞

33
00:05:59,140 --> 00:06:00,940
或者蒙格在旁邊插一句話

34
00:06:01,440 --> 00:06:03,240
如果你沒有把這段話是誰說的

35
00:06:03,240 --> 00:06:05,280
他到底在回答哪個問題整理清楚

36
00:06:05,280 --> 00:06:07,080
這段文字一旦被單獨抽出來

37
00:06:07,080 --> 00:06:08,860
AI根本看不懂前因後果

38
00:06:08,860 --> 00:06:09,900
甚至會張冠禮帶

39
00:06:10,660 --> 00:06:11,940
清洗的真正目的

40
00:06:11,940 --> 00:06:14,500
就是把原本混亂破碎的原始素材

41
00:06:14,500 --> 00:06:17,580
整理成每一段都自帶完整脈絡的高濃度知識

42
00:06:18,080 --> 00:06:20,640
那面對幾十萬上百萬字的逐字稿

43
00:06:20,640 --> 00:06:22,440
具體在工程上到底該怎麼洗

44
00:06:22,440 --> 00:06:24,480
你總不可能人工一行一行去修吧

45
00:06:24,740 --> 00:06:26,780
目前業界最成熟的best practice

46
00:06:26,780 --> 00:06:28,840
其實是一套自動化的兩階段管線

47
00:06:29,600 --> 00:06:32,420
第一階段用deterministic的腳本做物理掃除

48
00:06:32,940 --> 00:06:33,960
把SRT時間戳

49
00:06:34,220 --> 00:06:34,720
格式亂碼

50
00:06:34,980 --> 00:06:35,760
現場笑聲

51
00:06:36,000 --> 00:06:36,260
以及

52
00:06:36,520 --> 00:06:37,040
嗯啊

53
00:06:37,040 --> 00:06:37,280
那個

54
00:06:37,540 --> 00:06:38,820
這種無意義的口語墜字

55
00:06:39,080 --> 00:06:39,840
全部自動剔除

56
00:06:40,620 --> 00:06:42,920
第二階段交給便宜又快速的小模型

57
00:06:43,180 --> 00:06:44,460
像是GPT mini系列

58
00:06:44,720 --> 00:06:45,740
幫你做語意整理

59
00:06:46,500 --> 00:06:47,520
這裡最關鍵的一步

60
00:06:47,780 --> 00:06:49,060
叫做代名詞還原

61
00:06:49,320 --> 00:06:50,340
口語聊天常常說

62
00:06:50,340 --> 00:06:51,360
它那時候很便宜

63
00:06:51,620 --> 00:06:52,900
那家公司護程盒很深

64
00:06:53,160 --> 00:06:54,700
小模型會根據上下文脈絡

65
00:06:54,960 --> 00:06:56,480
自動把它替換回可口可樂

66
00:06:56,480 --> 00:06:59,300
同時它會把現場混在一起的多人講話

67
00:06:59,560 --> 00:07:00,580
標清楚誰是發問者

68
00:07:00,840 --> 00:07:01,340
誰是回答者

69
00:07:01,600 --> 00:07:03,140
整理成乾淨的一問一答

70
00:07:03,900 --> 00:07:05,180
這一步關鍵的原因是

71
00:07:05,440 --> 00:07:07,240
就算這段話之後被單獨切開

72
00:07:07,480 --> 00:07:08,760
它依然自帶完整的脈絡

73
00:07:09,020 --> 00:07:10,040
AI隨時抽出來看

74
00:07:10,300 --> 00:07:11,840
都完全讀得懂它在講什麼

75
00:07:12,600 --> 00:07:13,640
資料清洗完之後呢

76
00:07:13,880 --> 00:07:15,160
因為RAG的核心目標是

77
00:07:15,420 --> 00:07:17,220
精準投為AI所需要的資訊

78
00:07:17,480 --> 00:07:18,500
當你問一個問題時

79
00:07:18,760 --> 00:07:21,320
系統只要挑出最關鍵的那兩三段給AI就夠了

80
00:07:21,320 --> 00:07:23,360
而不是又把幾十萬字整包塞進去

81
00:07:23,620 --> 00:07:25,920
不然那樣又會回到前面又慢又貴的噩夢

82
00:07:26,440 --> 00:07:26,700
所以

83
00:07:26,960 --> 00:07:28,740
我們必須把這份龐大的檔案

84
00:07:29,000 --> 00:07:30,280
拆解成一個一個獨立

85
00:07:30,540 --> 00:07:31,820
好搜尋的知識卡片

86
00:07:32,320 --> 00:07:34,640
這個步驟在技術上就叫做chunking

87
00:07:34,880 --> 00:07:35,660
中文叫切塊

88
00:07:35,920 --> 00:07:37,440
切出來的每一塊就叫一個chunk

89
00:07:37,960 --> 00:07:39,760
常見的chunking策略通常有兩種

90
00:07:40,780 --> 00:07:42,320
第一種是固定字數切塊

91
00:07:42,820 --> 00:07:44,620
顧名思義就像拿彼此量長度一樣

92
00:07:44,880 --> 00:07:45,900
不管話說完了沒

93
00:07:46,160 --> 00:07:47,680
沒滿500字就無情切一刀

94
00:07:48,720 --> 00:07:50,760
這個方法最大的優勢就是簡單通用

95
00:07:50,760 --> 00:07:51,520
不需要動腦

96
00:07:52,300 --> 00:07:53,580
不管你會給他什麼格式的文件

97
00:07:53,840 --> 00:07:55,360
完全不需要花時間分析結構

98
00:07:55,620 --> 00:07:56,900
幾行程式碼就能快速切完

99
00:07:57,420 --> 00:07:58,700
而且每個chunk的大小都一樣

100
00:07:58,960 --> 00:08:00,240
非常好控制token的成本

101
00:08:01,000 --> 00:08:01,760
但他的問題

102
00:08:02,020 --> 00:08:03,560
就是完全無視與意邊界

103
00:08:04,080 --> 00:08:04,840
一刀切下去

104
00:08:05,100 --> 00:08:06,120
很容易剛好把一句話

105
00:08:06,380 --> 00:08:08,680
或是把問題和回答硬生生砍成兩半

106
00:08:09,200 --> 00:08:10,720
單獨拿出來看根本不知所云

107
00:08:11,760 --> 00:08:13,540
拿巴菲特的股東會逐字稿來說

108
00:08:13,800 --> 00:08:14,560
假設有股東問

109
00:08:14,820 --> 00:08:16,360
你當年為什麼買可口可樂

110
00:08:16,620 --> 00:08:17,900
巴菲特回答了400多字

111
00:08:18,160 --> 00:08:19,680
講到一半剛好滿500字

112
00:08:19,680 --> 00:08:20,960
刀就落下來了

113
00:08:21,480 --> 00:08:23,000
結果前一張卡片的結尾是

114
00:08:23,260 --> 00:08:24,800
我們當時看到最大的優勢是

115
00:08:25,320 --> 00:08:26,340
後一張卡片的開頭是

116
00:08:26,600 --> 00:08:27,620
它可以年年漲價

117
00:08:27,880 --> 00:08:28,900
消費者還是照買

118
00:08:29,400 --> 00:08:30,680
後面這張卡單獨拿出來

119
00:08:30,940 --> 00:08:31,960
根本不知道它是誰

120
00:08:32,220 --> 00:08:33,760
你之後搜可口可樂護城河

121
00:08:34,020 --> 00:08:35,560
這張最關鍵的卡片就撈不到了

122
00:08:36,580 --> 00:08:36,840
所以

123
00:08:37,080 --> 00:08:38,120
為了彌補硬切的缺點

124
00:08:38,360 --> 00:08:40,420
大家通常會設定一點重疊區間

125
00:08:40,680 --> 00:08:41,440
也就是overlap

126
00:08:42,200 --> 00:08:42,980
設定重疊的目的

127
00:08:43,240 --> 00:08:44,260
就是為了防止關鍵句子

128
00:08:44,520 --> 00:08:45,280
剛好落在刀口上

129
00:08:45,540 --> 00:08:46,820
讓後一張卡片的開頭

130
00:08:46,820 --> 00:08:48,860
多包含前一張卡的最後幾十個字

131
00:08:49,120 --> 00:08:49,640
買個保險

132
00:08:49,900 --> 00:08:51,680
避免重要的上下文直接斷掉

133
00:08:52,200 --> 00:08:53,480
但這依然治標不治本

134
00:08:53,740 --> 00:08:54,760
這個方法的最大硬傷

135
00:08:55,020 --> 00:08:56,300
依然是羽翼容易被腰斬

136
00:08:57,060 --> 00:08:58,860
第二種策略是按自然結構切塊

137
00:08:59,100 --> 00:09:00,140
這也是比較適合我們手上

138
00:09:00,380 --> 00:09:01,660
巴菲特資料的chunking策略

139
00:09:02,700 --> 00:09:03,200
具體怎麼做

140
00:09:03,460 --> 00:09:04,740
它的資料剛好就分兩種

141
00:09:05,260 --> 00:09:05,760
第一種是

142
00:09:06,020 --> 00:09:06,520
股東信

143
00:09:07,040 --> 00:09:09,080
巴菲特每年都寫得很清楚的小標題

144
00:09:09,340 --> 00:09:11,400
實務上就直接照markdown小標題切

145
00:09:11,640 --> 00:09:12,680
一個標題一張卡片

146
00:09:12,920 --> 00:09:14,460
每一張都是一個完整的投資觀點

147
00:09:15,240 --> 00:09:15,740
第二種是

148
00:09:16,000 --> 00:09:16,760
股東會逐字稿

149
00:09:17,280 --> 00:09:18,820
這本質上是一場問答馬拉松

150
00:09:19,080 --> 00:09:20,860
所以我們可以用每一輪問答為單位

151
00:09:21,120 --> 00:09:22,140
我們可以把股東提問

152
00:09:22,400 --> 00:09:22,920
巴菲特回答

153
00:09:23,160 --> 00:09:24,200
加上蒙格的補充

154
00:09:24,440 --> 00:09:25,480
整組打包成一個chunk

155
00:09:26,500 --> 00:09:27,000
這樣切

156
00:09:27,260 --> 00:09:28,800
問題跟答案永遠綁在一起

157
00:09:29,060 --> 00:09:30,080
上下文也就完整

158
00:09:30,840 --> 00:09:33,160
今天我先講最常見的兩種chunking策略

159
00:09:33,160 --> 00:09:35,720
如果你想深入瞭解更進階的切塊架構

160
00:09:35,980 --> 00:09:37,260
我在GaryAI實在營中

161
00:09:37,520 --> 00:09:38,800
會有一支影片專門講解

162
00:09:39,300 --> 00:09:42,380
有興趣的朋友可以在影片下方資訊欄找到加入連結

163
00:09:43,140 --> 00:09:44,420
那每一個chunk都切好之後

164
00:09:44,680 --> 00:09:46,220
我們就可以直接拿去搜尋了嗎

165
00:09:46,720 --> 00:09:47,240
還不行

166
00:09:47,760 --> 00:09:49,800
如果你直接光靠卡片裡的文字本身

167
00:09:50,060 --> 00:09:51,340
做搜尋依然會翻車

168
00:09:52,360 --> 00:09:53,640
因為AI在做搜尋的時候

169
00:09:53,900 --> 00:09:56,460
通常是比對問題和卡片的意思接不接近

170
00:09:57,220 --> 00:09:58,500
如果你聽不太懂的話沒關係

171
00:09:58,760 --> 00:09:59,780
等一下我們會再細講


1
00:10:00,000 --> 00:10:01,880
但讓AI純粹比對意思

2
00:10:01,880 --> 00:10:03,140
會有一個嚴重的盲點

3
00:10:03,140 --> 00:10:04,640
舉個例子

4
00:10:04,640 --> 00:10:06,980
如果使用者問巴菲特在2020年之後

5
00:10:06,980 --> 00:10:07,940
是怎麼談通膨的

6
00:10:07,940 --> 00:10:10,180
如果你這時候純靠內文的語義搜尋

7
00:10:10,180 --> 00:10:11,060
就很容易出問題

8
00:10:11,060 --> 00:10:13,740
因爲模型比較看得懂通膨這個概念

9
00:10:13,740 --> 00:10:16,740
他對2020年之後這種時間邊界非常不敏感

10
00:10:16,740 --> 00:10:19,960
很可能把1980年代講的非常精彩的通膨段落

11
00:10:19,960 --> 00:10:21,060
直接撈出來交差

12
00:10:21,060 --> 00:10:24,240
這就是爲什麼每張卡片都必須附上metadata

13
00:10:24,240 --> 00:10:25,500
中文叫原資料

14
00:10:25,500 --> 00:10:27,940
metadata其實就是這個段落的標籤

15
00:10:27,940 --> 00:10:29,460
以這個例子來說

16
00:10:29,460 --> 00:10:32,040
我會在metadata裏面放上發生的年份

17
00:10:32,040 --> 00:10:33,040
出自哪一封信

18
00:10:33,040 --> 00:10:34,540
或是影片的時間戳記

19
00:10:34,540 --> 00:10:36,320
有了這些標籤

20
00:10:36,320 --> 00:10:38,260
當用戶問帶有條件的問題時

21
00:10:38,260 --> 00:10:41,040
系統就能先利用metadata做精準的條件過濾

22
00:10:41,040 --> 00:10:43,240
先把時間範圍鎖定再去找內容

23
00:10:43,240 --> 00:10:44,720
這樣一方面比較準確

24
00:10:44,720 --> 00:10:46,100
另一方面又比較快

25
00:10:46,100 --> 00:10:48,460
如果你在做的是公司知識庫

26
00:10:48,460 --> 00:10:49,460
這點更是關鍵

27
00:10:49,460 --> 00:10:52,380
有些敏感資訊不能讓所有人隨意存取

28
00:10:52,380 --> 00:10:54,780
這時候你就能利用metadata在程式端

29
00:10:54,780 --> 00:10:56,640
先做一層確定性的權限過濾

30
00:10:56,640 --> 00:10:58,700
確保不會有人看到它不該看的資料

31
00:10:58,700 --> 00:11:01,700
現在你手上終於有幾萬張切好

32
00:11:01,700 --> 00:11:03,460
且貼好標籤的知識卡片了

33
00:11:03,460 --> 00:11:04,920
R的前半段整理書架

34
00:11:04,920 --> 00:11:06,180
到這裏也告一個段落

35
00:11:06,180 --> 00:11:08,600
接下來是R的後半段

36
00:11:08,600 --> 00:11:09,240
找書

37
00:11:09,240 --> 00:11:10,860
也就是說用戶提問的時候

38
00:11:10,860 --> 00:11:12,340
我們要怎麼讓AI去撈出

39
00:11:12,340 --> 00:11:13,640
最相關的資訊來回答

40
00:11:13,640 --> 00:11:15,060
在RAG裏

41
00:11:15,060 --> 00:11:16,820
AI具體到底是用什麼方式

42
00:11:16,820 --> 00:11:18,360
去搜尋這幾萬張卡片的

43
00:11:18,360 --> 00:11:19,840
其實主要就兩種做法

44
00:11:19,840 --> 00:11:21,300
第一種做法

45
00:11:21,300 --> 00:11:23,120
是大家最熟悉的關鍵字搜尋

46
00:11:23,120 --> 00:11:24,560
英文是keyword search

47
00:11:24,560 --> 00:11:26,700
這就像你在文件裏按Ctrl F

48
00:11:26,700 --> 00:11:27,960
直接比對你輸入的字

49
00:11:27,960 --> 00:11:29,080
有沒有出現在卡片裏

50
00:11:29,080 --> 00:11:31,020
這種方法在抓特定人名

51
00:11:31,020 --> 00:11:31,740
公司代號

52
00:11:31,740 --> 00:11:33,340
或是專有名詞時非常準

53
00:11:33,340 --> 00:11:34,900
但它的致命傷

54
00:11:34,900 --> 00:11:36,300
就是完全不懂同一詞

55
00:11:36,300 --> 00:11:37,920
比方說巴菲特講話

56
00:11:37,920 --> 00:11:39,640
不可能每次都照你的劇本走

57
00:11:39,640 --> 00:11:41,860
以護城河這個常見的名詞來說

58
00:11:41,860 --> 00:11:43,700
它可能會用不同的方式表達

59
00:11:43,700 --> 00:11:45,500
像是長期的競爭優勢

60
00:11:45,500 --> 00:11:47,140
或者別人很難搶走的生意

61
00:11:47,140 --> 00:11:49,100
這時候如果你輸入護城河

62
00:11:49,100 --> 00:11:49,880
然後去搜尋

63
00:11:49,880 --> 00:11:51,420
這些含金量極高的段落

64
00:11:51,420 --> 00:11:52,480
就會被全部漏掉

65
00:11:52,480 --> 00:11:54,340
所以就有了第二種做法

66
00:11:54,340 --> 00:11:55,360
叫做語意搜尋

67
00:11:55,360 --> 00:11:56,780
英文是semantic search

68
00:11:56,780 --> 00:11:58,820
它不看字面有沒有完全吻合

69
00:11:58,820 --> 00:12:00,660
而是去看背後的意思一不一樣

70
00:12:00,660 --> 00:12:02,420
對於技術小白來說

71
00:12:02,420 --> 00:12:03,240
你可能會好奇

72
00:12:03,240 --> 00:12:04,660
語意搜尋到底是怎麼知道

73
00:12:04,660 --> 00:12:05,900
兩句話意思相近的

74
00:12:05,900 --> 00:12:07,700
最簡單的理解方式就是

75
00:12:07,700 --> 00:12:08,740
這背後靠的是一種

76
00:12:08,740 --> 00:12:09,880
叫做embedding的模型

77
00:12:09,880 --> 00:12:12,160
它會把每一張卡片的文字

78
00:12:12,160 --> 00:12:13,620
換算成一串數字

79
00:12:13,620 --> 00:12:15,160
而這串數字就叫向量

80
00:12:15,160 --> 00:12:15,660
vector

81
00:12:15,660 --> 00:12:17,940
你可以把向量想象成

82
00:12:17,940 --> 00:12:19,120
語意地圖上的座標

83
00:12:19,120 --> 00:12:21,020
比如說護城河三個字

84
00:12:21,020 --> 00:12:22,700
會被換算成一組數字座標

85
00:12:22,700 --> 00:12:24,320
這組座標在數學上

86
00:12:24,320 --> 00:12:25,820
會跟長期的競爭優勢

87
00:12:25,820 --> 00:12:26,760
這個語意上

88
00:12:26,760 --> 00:12:28,500
跟護城河比較相似的區塊

89
00:12:28,500 --> 00:12:29,280
靠得非常近

90
00:12:29,280 --> 00:12:30,660
而跟晚餐是什麼

91
00:12:30,660 --> 00:12:31,740
這種和護城河

92
00:12:31,740 --> 00:12:32,800
沒什麼關聯的名詞

93
00:12:32,800 --> 00:12:33,560
距離遙遠

94
00:12:33,560 --> 00:12:35,080
有了向量之後

95
00:12:35,080 --> 00:12:36,340
系統就可以把你的問題

96
00:12:36,340 --> 00:12:37,420
也換算成一個座標

97
00:12:37,420 --> 00:12:38,960
接着去計算問題座標

98
00:12:38,960 --> 00:12:40,300
跟資料庫裏每張卡片

99
00:12:40,300 --> 00:12:41,880
在數學上的距離

100
00:12:41,880 --> 00:12:43,320
距離最近的那幾張卡片

101
00:12:43,320 --> 00:12:44,840
就是意思最接近的內容

102
00:12:44,840 --> 00:12:46,500
抓出來餵給AI之後

103
00:12:46,500 --> 00:12:47,740
他就能精準回答

104
00:12:47,740 --> 00:12:49,620
聽起來很完美對吧

105
00:12:49,620 --> 00:12:50,920
但純用語意搜尋

106
00:12:50,920 --> 00:12:52,200
其實藏着一個巨大的坑

107
00:12:52,200 --> 00:12:53,780
他記住的是宏觀大意

108
00:12:53,780 --> 00:12:55,660
很容易把專有名詞忽略掉

109
00:12:55,660 --> 00:12:57,240
比如你問

110
00:12:57,240 --> 00:12:59,040
巴菲特爲什麼買喜事糖果

111
00:12:59,040 --> 00:13:00,620
系統用語意去找

112
00:13:00,620 --> 00:13:01,520
找回來的卡片

113
00:13:01,520 --> 00:13:02,800
可能全都在講可口可樂

114
00:13:02,800 --> 00:13:03,900
或者講好品牌

115
00:13:03,900 --> 00:13:04,800
有漲價的權利

116
00:13:04,800 --> 00:13:05,920
這些概念很像

117
00:13:05,920 --> 00:13:07,660
但都沒有提到喜事糖果本身

118
00:13:07,660 --> 00:13:09,620
那這時候AI回答出來

119
00:13:09,620 --> 00:13:10,820
就會直接答非所問

120
00:13:10,820 --> 00:13:11,960
甚至開始瞎掰

121
00:13:11,960 --> 00:13:13,400
硬把可口可樂的邏輯

122
00:13:13,400 --> 00:13:14,400
套到喜事頭上

123
00:13:14,400 --> 00:13:16,080
這是因爲專有名詞

124
00:13:16,080 --> 00:13:17,140
放進一整段話裏

125
00:13:17,140 --> 00:13:18,900
很容易被整體的大意稀釋掉

126
00:13:18,900 --> 00:13:20,960
所以這兩種檢索方法

127
00:13:20,960 --> 00:13:22,440
一個擅長抓精確字面

128
00:13:22,440 --> 00:13:23,880
一個擅長抓抽象意思

129
00:13:23,880 --> 00:13:24,900
在實物上

130
00:13:24,900 --> 00:13:27,060
成熟的RAG通常是兩者並行使用

131
00:13:27,060 --> 00:13:28,360
這就叫做混合搜尋

132
00:13:28,360 --> 00:13:29,580
也就是Hybrid Search

133
00:13:29,580 --> 00:13:31,200
那這些切好的卡片

134
00:13:31,200 --> 00:13:32,300
以及我們上面說

135
00:13:32,300 --> 00:13:34,140
通過Embedding模型生成出來的

136
00:13:34,140 --> 00:13:34,820
向量座標

137
00:13:34,820 --> 00:13:36,120
還有剛纔講的Metadata

138
00:13:36,120 --> 00:13:37,460
這時候會存進一個

139
00:13:37,460 --> 00:13:38,860
支援向量搜尋的資料庫

140
00:13:38,860 --> 00:13:40,500
向量資料庫支援開發者

141
00:13:40,500 --> 00:13:42,180
把這些文字向量和標籤

142
00:13:42,180 --> 00:13:43,640
分門別類存進去

143
00:13:44,400 --> 00:13:46,160
這個過程就叫做Indexing

144
00:13:46,160 --> 00:13:47,600
中文叫做建立索引

145
00:13:47,600 --> 00:13:49,960
當使用者一個問題問進來

146
00:13:49,960 --> 00:13:51,560
AI就可以透過Hybrid Search

147
00:13:51,560 --> 00:13:53,720
去這個支援向量搜尋的資料庫裏

148
00:13:53,720 --> 00:13:55,060
找相對應的資料卡片

149
00:13:55,060 --> 00:13:57,340
我們直接用巴菲特來模擬一次

150
00:13:57,340 --> 00:13:58,940
假設你問巴菲特

151
00:13:58,940 --> 00:14:00,120
爲什麼買下喜事糖果

152
00:14:00,120 --> 00:14:01,280
它的護城盒在哪裏

153
00:14:01,280 --> 00:14:03,320
系統這時候會兵分兩路

154
00:14:03,320 --> 00:14:04,880
一路是關鍵字搜尋

155
00:14:04,880 --> 00:14:06,360
它死咬着喜事糖果

156
00:14:06,360 --> 00:14:07,140
這個專有名詞

157
00:14:07,140 --> 00:14:09,140
把所有真的出現喜事的卡片

158
00:14:09,140 --> 00:14:10,100
精準撈出來

159
00:14:10,100 --> 00:14:11,200
但這些卡片裏

160
00:14:11,200 --> 00:14:12,740
可能沒有深談護城盒的理論

161
00:14:12,740 --> 00:14:14,200
另一路是語意搜尋

162
00:14:14,200 --> 00:14:16,600
它去抓收購邏輯和護城盒的意思

163
00:14:16,600 --> 00:14:18,160
撈出一堆談定價權

164
00:14:18,160 --> 00:14:19,260
品牌優勢的卡片

165
00:14:19,260 --> 00:14:22,340
接着系統把兩邊找到的名單合併

166
00:14:22,340 --> 00:14:24,820
挑出比方說前20張候選的Chunk

167
00:14:24,820 --> 00:14:25,980
走到這一步時

168
00:14:25,980 --> 00:14:27,520
RAG的R就告一段落了

169
00:14:27,520 --> 00:14:29,100
因爲我們已經把回答這個問題

170
00:14:29,100 --> 00:14:30,480
所需要的資料都抓回來了

171
00:14:30,480 --> 00:14:33,580
而下一步就是進到RAG的A Augmented

172
00:14:33,580 --> 00:14:35,160
這一步的工作只有一個

173
00:14:35,160 --> 00:14:37,520
決定到底要把什麼東西放在AI眼前

174
00:14:37,520 --> 00:14:40,040
你這時候可以直接把這20個Chunk

175
00:14:40,040 --> 00:14:41,540
全部一股腦丟給AI嗎

176
00:14:41,540 --> 00:14:42,320
最好不要

177
00:14:42,320 --> 00:14:44,520
因爲第一階段粗撈出來的名單

178
00:14:44,520 --> 00:14:46,580
裏面摻雜了許多半相關的雜訊

179
00:14:46,580 --> 00:14:47,900
如果硬塞給模型

180
00:14:47,900 --> 00:14:49,460
不僅資訊密度被稀釋

181
00:14:49,460 --> 00:14:51,240
模型還很容易被雜訊帶偏

182
00:14:51,240 --> 00:14:52,120
產生幻覺

183
00:14:52,120 --> 00:14:54,160
如果我們要讓回答更完美

184
00:14:54,160 --> 00:14:56,400
就必須把資料的密度再提煉出來

185
00:14:56,400 --> 00:14:58,540
所以A Augmented的第一道工序

186
00:14:58,540 --> 00:14:59,980
是用一個讀得更


1
00:15:00,000 --> 00:15:00,660
仔細的模型

2
00:15:00,660 --> 00:15:03,360
把這20張卡片跟問題一張一張對着讀

3
00:15:03,360 --> 00:15:04,500
重新排一次名

4
00:15:04,500 --> 00:15:06,500
把真正有用的卡片頂到前面

5
00:15:06,500 --> 00:15:08,260
這也就是大家常聽到的Reranking

6
00:15:08,260 --> 00:15:09,140
重新排序

7
00:15:09,140 --> 00:15:10,720
嚴格講的話

8
00:15:10,720 --> 00:15:12,960
Reranking在教科書裏算R的最後一步

9
00:15:12,960 --> 00:15:14,340
但我把它放在A的部分

10
00:15:14,340 --> 00:15:15,840
是因爲我覺得這樣比較好理解

11
00:15:15,840 --> 00:15:17,700
畢竟Reranking的工作不是去找

12
00:15:17,700 --> 00:15:20,680
而是決定哪幾張卡片有資格進到AI眼前

13
00:15:20,680 --> 00:15:23,100
這對我來說比較像是A在做的事

14
00:15:23,100 --> 00:15:25,460
而它到底屬於哪一個字母的階段

15
00:15:25,460 --> 00:15:26,420
其實也沒那麼重要

16
00:15:26,420 --> 00:15:28,840
重要的是能夠理解Rack是如何運作的

17
00:15:28,840 --> 00:15:30,380
排好名之後

18
00:15:30,380 --> 00:15:33,400
augmented這個階段最重要的就是把小超拼起來

19
00:15:33,400 --> 00:15:35,660
你可能會取前三到五張卡片

20
00:15:35,660 --> 00:15:37,180
連同卡片的metadata

21
00:15:37,180 --> 00:15:38,880
像是年份出處

22
00:15:38,880 --> 00:15:40,920
再加上你的問題還有一段指示

23
00:15:40,920 --> 00:15:43,880
像是隻能根據下面這幾段資料回答

24
00:15:43,880 --> 00:15:45,220
資料裏沒有的就說不知道

25
00:15:45,220 --> 00:15:48,060
全部組成一份最終的提示詞交給AI

26
00:15:48,060 --> 00:15:49,460
走到這裏

27
00:15:49,460 --> 00:15:50,800
我們快速回顧一下

28
00:15:50,800 --> 00:15:52,160
在retrieval這一段

29
00:15:52,160 --> 00:15:54,920
我們把巴菲特60年份的雜亂資料清洗乾淨

30
00:15:54,920 --> 00:15:55,820
切成卡片

31
00:15:55,820 --> 00:15:56,580
貼上標籤

32
00:15:56,580 --> 00:15:58,220
存進向量資料庫件索印

33
00:15:58,220 --> 00:16:00,800
再用hybrid search把20張候選撈回來

34
00:16:00,800 --> 00:16:02,100
而在augmented的階段

35
00:16:02,100 --> 00:16:04,180
我們用re-ranking挑出最準的幾張

36
00:16:04,180 --> 00:16:05,940
拼成一份乾淨的小超

37
00:16:05,940 --> 00:16:08,420
接着就要進入rack的最後一段

38
00:16:08,420 --> 00:16:09,840
g generation

39
00:16:09,840 --> 00:16:10,920
也就是生成

40
00:16:10,920 --> 00:16:12,440
讓AI看着這份小超

41
00:16:12,440 --> 00:16:13,220
寫出答案

42
00:16:13,220 --> 00:16:15,960
g在系統上其實是最單純的一步

43
00:16:15,960 --> 00:16:17,820
a把小超拼好之後

44
00:16:17,820 --> 00:16:20,300
g就是把這份提示詞送給大語言模型

45
00:16:20,300 --> 00:16:21,160
拿回答案

46
00:16:21,160 --> 00:16:23,100
程式上就是一次API呼叫

47
00:16:23,100 --> 00:16:25,580
你真正要決定的事情其實不多

48
00:16:25,580 --> 00:16:27,160
首先是用哪個模型

49
00:16:27,160 --> 00:16:29,300
知識庫問答不需要最貴的那一個

50
00:16:29,300 --> 00:16:31,380
中低階模型配上一份好小超

51
00:16:31,380 --> 00:16:32,100
通常就夠

52
00:16:32,100 --> 00:16:33,300
我自己蠻喜歡

53
00:16:33,300 --> 00:16:34,380
gevenite flash系列

54
00:16:34,380 --> 00:16:35,580
又快又便宜

55
00:16:35,580 --> 00:16:37,680
再來是在回答時的策略

56
00:16:37,680 --> 00:16:39,500
比方說要不要讓它附上出處

57
00:16:39,500 --> 00:16:40,500
用什麼語氣等

58
00:16:40,500 --> 00:16:42,040
而這些東西其實大多數

59
00:16:42,040 --> 00:16:43,420
就是用提示詞在控制

60
00:16:43,420 --> 00:16:45,460
我在實物上發現

61
00:16:45,460 --> 00:16:47,420
很多團隊的知識庫會遇到一個狀況

62
00:16:47,420 --> 00:16:48,800
同一個問題問兩次

63
00:16:48,800 --> 00:16:49,660
答案不一樣

64
00:16:49,660 --> 00:16:50,900
甚至還會自己加系

65
00:16:50,900 --> 00:16:51,640
開始腦補

66
00:16:51,640 --> 00:16:54,020
這時候你可以先去檢查

67
00:16:54,020 --> 00:16:55,020
你的模型temperature

68
00:16:55,020 --> 00:16:56,120
是不是設太高了

69
00:16:56,120 --> 00:16:57,800
temperature簡單來說

70
00:16:57,800 --> 00:16:59,320
就是控制AI隨機性

71
00:16:59,320 --> 00:17:00,420
跟創造力的旋鈕

72
00:17:00,420 --> 00:17:01,740
溫度設得越高

73
00:17:01,740 --> 00:17:03,240
AI就越想放飛自我

74
00:17:03,240 --> 00:17:04,640
用詞也會越多樣化

75
00:17:04,640 --> 00:17:05,560
而溫度越低

76
00:17:05,560 --> 00:17:06,460
它就越保守

77
00:17:06,460 --> 00:17:08,160
每次都只挑幾率最高

78
00:17:08,160 --> 00:17:08,980
最確定的字

79
00:17:08,980 --> 00:17:11,180
一般AI工具的預設溫度

80
00:17:11,180 --> 00:17:12,340
通常是0.7左右

81
00:17:12,340 --> 00:17:13,480
那是拿來寫文案

82
00:17:13,480 --> 00:17:14,600
激發靈感用的

83
00:17:14,600 --> 00:17:16,000
但在嚴肅的知識庫裏

84
00:17:16,000 --> 00:17:17,680
創造力往往就等於幻覺

85
00:17:17,680 --> 00:17:18,840
要解決這個問題

86
00:17:18,840 --> 00:17:20,720
就直接把temperature往下調就好

87
00:17:20,720 --> 00:17:22,020
走到這裏

88
00:17:22,020 --> 00:17:22,640
恭喜你

89
00:17:22,640 --> 00:17:24,020
你手上就已經擁有一個

90
00:17:24,020 --> 00:17:25,100
完整的RAG系統了

91
00:17:25,100 --> 00:17:26,980
現在你只要問一個問題

92
00:17:26,980 --> 00:17:28,080
R會在後臺

93
00:17:28,080 --> 00:17:29,800
把最相關的資料卡片撈出來

94
00:17:29,800 --> 00:17:31,220
A 把它們排好名

95
00:17:31,220 --> 00:17:32,240
拼成一份小抄

96
00:17:32,240 --> 00:17:35,160
G 再用你剛剛做條temperature的AI大腦

97
00:17:35,160 --> 00:17:36,840
生成出最後的嚴謹回答

98
00:17:36,840 --> 00:17:39,020
不過AI再怎麼說

99
00:17:39,020 --> 00:17:40,300
還是non-deterministic的

100
00:17:40,300 --> 00:17:40,960
也就是說

101
00:17:40,960 --> 00:17:42,320
每次都有一定的隨機性

102
00:17:42,320 --> 00:17:43,580
所以實際使用時

103
00:17:43,580 --> 00:17:44,420
一定還是有機會

104
00:17:44,420 --> 00:17:45,660
遇到分身答錯的時候

105
00:17:45,660 --> 00:17:47,540
這時候不要立刻就判斷

106
00:17:47,540 --> 00:17:48,520
是AI不夠聰明

107
00:17:48,520 --> 00:17:50,180
馬上換一個更貴的大模型

108
00:17:50,180 --> 00:17:51,640
因爲只要你搞懂了

109
00:17:51,640 --> 00:17:52,660
前面這一整套邏輯

110
00:17:52,660 --> 00:17:54,100
你就可以順着這個邏輯

111
00:17:54,100 --> 00:17:55,580
非常科學地去做排查

112
00:17:55,580 --> 00:17:57,140
譬如說你問他

113
00:17:57,140 --> 00:17:58,880
巴菲特哪一年買下喜事糖果

114
00:17:58,880 --> 00:18:00,620
正確答案是1972年

115
00:18:00,620 --> 00:18:02,520
分身卻回答1980年代

116
00:18:02,520 --> 00:18:04,380
順着RAG

117
00:18:04,380 --> 00:18:05,740
由前到後這樣查

118
00:18:05,740 --> 00:18:07,940
第一步看R的前半

119
00:18:07,940 --> 00:18:08,640
資料端

120
00:18:08,640 --> 00:18:10,720
講1972年收購的那段原文

121
00:18:10,720 --> 00:18:11,920
當初切chunk時

122
00:18:11,920 --> 00:18:13,080
有沒有被腰斬切壞

123
00:18:13,080 --> 00:18:14,720
或是字幕辨識錯字了

124
00:18:14,720 --> 00:18:16,600
如果小超一開始就印壞了

125
00:18:16,600 --> 00:18:17,760
AI當然不可能答對

126
00:18:17,760 --> 00:18:19,560
這時候的解決策略

127
00:18:19,560 --> 00:18:21,300
是回頭修復資料源

128
00:18:21,300 --> 00:18:22,800
或是調整切塊規則

129
00:18:22,800 --> 00:18:24,000
確保這段事實

130
00:18:24,000 --> 00:18:25,640
完整保留在一張卡片裏

131
00:18:25,640 --> 00:18:27,780
第二步看R的後半

132
00:18:27,780 --> 00:18:28,460
檢索端

133
00:18:28,460 --> 00:18:29,760
資料庫裏有這張卡片

134
00:18:29,760 --> 00:18:31,640
但第一輪出到候選名單時

135
00:18:31,640 --> 00:18:32,900
是不是把它給漏掉了

136
00:18:32,900 --> 00:18:33,980
這代表原始資料

137
00:18:33,980 --> 00:18:34,900
根本沒被找出來

138
00:18:34,900 --> 00:18:36,540
這時候的解決策略

139
00:18:36,540 --> 00:18:38,280
可能就是把Hybrid Search裏的

140
00:18:38,280 --> 00:18:39,400
關鍵字權重拉高

141
00:18:39,400 --> 00:18:40,620
或是把海選數量

142
00:18:40,620 --> 00:18:42,100
從20張放寬到50張

143
00:18:42,100 --> 00:18:43,940
把初撈的網子撒得更大一點

144
00:18:43,940 --> 00:18:45,700
第三步看A

145
00:18:45,700 --> 00:18:46,480
小超端

146
00:18:46,480 --> 00:18:47,420
卡片撈出來了

147
00:18:47,420 --> 00:18:48,380
但Reranking時

148
00:18:48,380 --> 00:18:49,720
是不是被排在第十幾名

149
00:18:49,720 --> 00:18:51,800
根本沒幾進送給AI的前三名

150
00:18:51,800 --> 00:18:53,120
這代表小超找到了

151
00:18:53,120 --> 00:18:54,240
但沒遞到他手裏

152
00:18:54,240 --> 00:18:55,540
這時候的解決策略

153
00:18:55,540 --> 00:18:57,520
可能是換一個更好的Reranking模型

154
00:18:57,520 --> 00:18:59,100
或是把送給AI的名額

155
00:18:59,100 --> 00:19:00,060
放寬到前五張

156
00:19:00,060 --> 00:19:01,980
讓正確小超能順利遞交

157
00:19:01,980 --> 00:19:03,480
第四步

158
00:19:03,480 --> 00:19:04,200
纔看G

159
00:19:04,200 --> 00:19:04,920
模型端

160
00:19:04,920 --> 00:19:06,660
如果寫着1972年的卡片

161
00:19:06,660 --> 00:19:08,300
明明端端正正放在他眼前

162
00:19:08,300 --> 00:19:09,380
他卻還是講錯

163
00:19:09,380 --> 00:19:10,980
這代表小超就在眼前

164
00:19:10,980 --> 00:19:12,020
他卻看花了眼

165
00:19:12,020 --> 00:19:13,560
這時候的解決策略

166
00:19:13,560 --> 00:19:15,200
才輪到去檢查System Prompt

167
00:19:15,200 --> 00:19:17,360
比如要求他先引用卡片中的年份

168
00:19:17,360 --> 00:19:17,880
再回答

169
00:19:17,880 --> 00:19:19,300
如果他依然理解錯誤

170
00:19:19,300 --> 00:19:21,240
這時才考慮升級更強的大模型

171
00:19:21,240 --> 00:19:23,160
實物上八成以上的翻車

172
00:19:23,160 --> 00:19:24,340
全都在前三步

173
00:19:24,340 --> 00:19:25,420
也就是R跟A

174
00:19:25,420 --> 00:19:26,540
根本輪不到模型

175
00:19:26,540 --> 00:19:28,240
背後的原因也很簡單

176
00:19:28,240 --> 00:19:29,740
有在用AI的人都知道

177
00:19:29,740 --> 00:19:32,020
當你把實則資訊放到AI眼前

178
00:19:32,020 --> 00:19:33,780
然後請他根據這實則資訊

179
00:19:33,780 --> 00:19:34,660
去回答你的問題

180
00:19:34,660 --> 00:19:36,000
他回答正確的幾率

181
00:19:36,000 --> 00:19:37,560
講道理是非常非常高的

182
00:19:37,560 --> 00:19:39,420
RAG也可以這樣去理解

183
00:19:39,420 --> 00:19:40,900
如果你有把正確的

184
00:19:40,900 --> 00:19:42,040
且真正關鍵的資訊

185
00:19:42,040 --> 00:19:42,980
擺到AI眼前

186
00:19:42,980 --> 00:19:44,280
其實那樣的資訊量

187
00:19:44,280 --> 00:19:46,060
並不足以讓他開始出現幻覺

188
00:19:46,060 --> 00:19:47,800
所以當回答不如預期時

189
00:19:47,800 --> 00:19:49,500
記得要按照RAG的資料

190
00:19:49,500 --> 00:19:50,680
流動管線去做排查

191
00:19:50,680 --> 00:19:51,740
纔不會亂槍打鳥

192
00:19:52,280 --> 00:19:54,340
就算你只是平常隨便玩完

193
00:19:54,340 --> 00:19:55,460
Codecode或Codex

194
00:19:55,460 --> 00:19:57,000
也沒有要幫自己或企業

195
00:19:57,000 --> 00:19:57,900
架一套RAG系統

196
00:19:59,740 --> 00:19:59,980
到AI


1
00:20:00,000 --> 00:20:03,580
畢竟RAG本質上其實就是在做一件事

2
00:20:03,580 --> 00:20:05,060
如何在有限的視窗裏

3
00:20:05,060 --> 00:20:08,020
把最高密度最正確的資料端到AI眼前

4
00:20:08,020 --> 00:20:10,000
確保它的回答是有機可循的

5
00:20:10,000 --> 00:20:12,000
搞懂RAG的原理之後

6
00:20:12,000 --> 00:20:13,980
當Cloud Code改成試碼改到迷路

7
00:20:13,980 --> 00:20:15,080
開始詭達強時

8
00:20:15,080 --> 00:20:16,940
你會知道該立刻清理上下文

9
00:20:16,940 --> 00:20:18,540
只精準指定核心檔案

10
00:20:18,540 --> 00:20:20,480
不讓多餘雜訊稀釋它的注意力

11
00:20:20,480 --> 00:20:22,300
當你在丟了幾十頁的報告

12
00:20:22,300 --> 00:20:23,760
卻被AI答非所問時

13
00:20:23,760 --> 00:20:25,860
你一眼就知道是格式被切碎了

14
00:20:25,860 --> 00:20:27,840
懂得改位帶有清楚小標題的markdown

15
00:20:27,840 --> 00:20:28,800
讓它精準抓取

16
00:20:28,800 --> 00:20:31,300
你不再是隻能期待AI別胡說八道

17
00:20:31,300 --> 00:20:32,440
看運氣的抽卡玩家

18
00:20:32,440 --> 00:20:35,160
而是能主動控制資料品質的context engineer

19
00:20:35,160 --> 00:20:37,580
RAG不只是一項工程技術

20
00:20:37,580 --> 00:20:38,980
背後的邏輯更是一套

21
00:20:38,980 --> 00:20:41,780
如何與AI高校協作的context engineering思維

22
00:20:41,780 --> 00:20:43,700
如果你正在學習AI

23
00:20:43,700 --> 00:20:44,980
想看更多實戰內容

24
00:20:44,980 --> 00:20:46,780
也希望有一羣能一起討論的夥伴

25
00:20:46,780 --> 00:20:48,500
或是直接跟我一對一問答

26
00:20:48,500 --> 00:20:50,520
歡迎加入我們的Gary AI實戰營

27
00:20:50,520 --> 00:20:52,680
連結我會放在影片下方的資訊欄

28
00:20:52,680 --> 00:20:54,780
那以上就是今天的內容

29
00:20:54,780 --> 00:20:56,500
喜歡的話記得幫我按贊

30
00:20:56,500 --> 00:20:57,600
追蹤加分享

31
00:20:57,600 --> 00:20:59,560
這是我持續創作下去的動力

32
00:20:59,560 --> 00:21:00,460
我們下次見