back to index

[DLHLP 2020] Speech Recognition (7/7) - Language Modeling


link |
00:00.000
我們接下來要講語音辨識的最後一段
link |
00:04.680
我們講一下怎麼把Language Model放在語音辨識裡面
link |
00:09.880
講完這一段,我們就進入Voice Conversion
link |
00:14.120
為什麼我們會需要Language Model這個東西在語音辨識裡面呢?
link |
00:20.520
我們先來看一下所謂的Language Model指的是什麼
link |
00:24.920
Language Model我們常常縮寫成LM
link |
00:28.920
它要做的事情是去估測一串Token Sequence出現的機率
link |
00:36.200
過去在文獻上比較常講說Language Model就是估測Word Sequence出現的機率
link |
00:42.920
不過今天我們文字的Sequence不一定是Word Sequence
link |
00:47.200
因為我們不見得拿Word當作單位嘛
link |
00:49.200
我們可能是拿Character當作單位
link |
00:51.200
我們可能是拿Morphing當作單位
link |
00:54.000
所以我這邊用Token Sequence來代表Language Model
link |
00:58.960
所以我們說Language Model是在估測Token Sequence的機率
link |
01:03.160
我們有一個Token Sequence大Y Language Model
link |
01:06.760
就是想要估測這個大Y這一個Sequence它出現的機率有多少
link |
01:12.560
那我們為什麼會需要估測這個機率呢?
link |
01:15.760
在Hidden Mark of Model裡面,估測Language Model的機率這件事情是非常必然的
link |
01:23.120
因為我們說Hidden Mark of Model把Decoding的這個式子寫成這樣
link |
01:30.400
我們要找一個Y,讓P of X given Y乘上P of Y的值最大
link |
01:36.200
而P of Y就是Language Model
link |
01:40.200
而今天我們進入了這種Deep Learning Base的
link |
01:44.200
全Deep Learning End-to-End語音辨識的模型以後
link |
01:48.040
好像就不需要Language Model了
link |
01:50.320
因為這種全Deep Learning的語音辨識模型
link |
01:54.440
它Decoding的式子寫成這個樣子
link |
01:56.560
我們是要找一個Token Sequence Y,讓P of Y given X越大越好
link |
02:02.360
這裡面似乎沒有Language Model存在的空間
link |
02:06.360
但神奇的地方是啊
link |
02:08.880
你可以直接把Decoding這個式子寫成P of Y given X乘上P of Y
link |
02:15.840
這個P of Y就是Language Model
link |
02:17.840
你直接把Decoding的式子寫成P of Y given X乘上P of Y
link |
02:23.360
會讓你的Performance變好
link |
02:26.120
這個聽起來有點奇怪
link |
02:27.720
就是這邊好像不太需要乘上P of Y啊
link |
02:32.160
如果是Hidden Mark of Model乘上P of Y
link |
02:34.840
合理的,它本來就需要P of Y
link |
02:37.680
但P of Y given X又乘上P of Y
link |
02:40.760
就不知道在幹什麼,在機率上面不好解釋
link |
02:45.720
在機率上面不知道為什麼要乘一個P of Y上來
link |
02:49.360
但是啊,為什麼這邊乘一個P of Y往往還是會有用呢?
link |
02:54.880
為什麼就算是今天進入了全Deep Learning的語音辨識
link |
03:00.400
加上Language Model還是會有用呢?
link |
03:03.480
那是因為啊,通常這個P of Y given X跟P of Y
link |
03:07.640
我們可以從不同的來源來估測
link |
03:10.960
就是說這個P of Y given X啊
link |
03:13.600
你如果要估測這一項,你需要成對的資料
link |
03:17.640
而收集成對的資料的成本是比較高的
link |
03:21.960
而如果你要估測P of Y,你只需要收集大量的文字
link |
03:25.800
你就可以估測P of Y
link |
03:27.960
所以收集需要估測P of Y的資料的成本是比較低的
link |
03:32.600
你可以收集到比較多的資料
link |
03:35.320
來幫我們估測出P of Y
link |
03:38.200
所以P of Y given X
link |
03:40.200
你比較不容易估的好
link |
03:42.040
但P of Y你比較容易估的好
link |
03:44.920
所以讓比較容易估的好的P of Y來這邊
link |
03:48.120
乘上P of Y given X
link |
03:49.640
讓這個式子看起來奇奇怪怪的
link |
03:52.920
但是往往還是有用的
link |
03:55.640
那像這樣的招數啊
link |
03:57.640
這個使用Language Model的招數啊
link |
04:00.200
不是只會用在語音辨識裡面
link |
04:03.400
在很多其他的Application裡面都會用到
link |
04:06.840
基本上如果你今天要Learn一個End-to-End的Model
link |
04:09.960
它的輸出就是文字
link |
04:12.120
往往加上Language Model就有用
link |
04:14.520
就我們在這個開學第一堂課的時候
link |
04:17.320
就有講說我們這門課呢
link |
04:18.920
就是要講六種Model
link |
04:21.960
就有可能是音不語音或文字
link |
04:24.760
有可能是輸出語音或文字
link |
04:26.760
如果你今天輸出的是文字
link |
04:28.760
加上這種Language Model往往就有用
link |
04:31.080
比如說如果你要做Translation
link |
04:33.080
從一種語言翻譯成另外一種語言
link |
04:35.400
你可以加上Language Model
link |
04:37.240
你要做這個摘要
link |
04:40.360
輸入一篇文章
link |
04:41.880
輸出這篇文章的標題
link |
04:44.360
讓機器自動下標題
link |
04:45.720
加上Language Model也往往會有用
link |
04:48.680
所以像這樣加入Language Model的技巧
link |
04:51.320
就算是今天在Deep Learning的時代
link |
04:53.720
仍然被廣泛的被使用
link |
04:57.880
好那這邊呢稍微給大家一個數字
link |
05:00.600
讓你知道說
link |
05:01.880
如果是這種成對的資料
link |
05:03.960
跟這種沒有成對的資料
link |
05:05.720
大概他們的可以收集到的量級
link |
05:08.520
有多大的差距
link |
05:10.040
好我們來看一下這個成對的資料
link |
05:13.400
Google說他們的語音辨識系統
link |
05:17.240
當然這個是文獻上的數字啦
link |
05:19.640
那實際上系統用的數字
link |
05:21.160
一定是遠比這個大的多
link |
05:22.600
他們在文獻上說
link |
05:23.960
他們用了一萬多個小時的
link |
05:26.840
有工讀生標上文字的語音
link |
05:30.280
來訓練來找出P of Y given X
link |
05:34.040
來訓練他們的end-to-end model
link |
05:37.240
好那這個這樣子長度的語音
link |
05:40.200
它裡面包含的詞彙的數量有多少呢
link |
05:45.720
一萬兩千五百個小時裡面
link |
05:48.360
有多少分鐘呢
link |
05:49.640
我們乘60就知道說有多少分鐘
link |
05:52.920
那一個人一分鐘會說多少個詞彙呢
link |
05:56.920
一個人一分鐘平均
link |
05:59.000
是說大概130個詞彙
link |
06:01.880
所以我們把12500乘60乘上130
link |
06:05.400
就知道說這麼長的聲音訊號裡面
link |
06:07.880
大概有多少個詞彙
link |
06:09.800
那一萬多個小時的聲音訊號裡面
link |
06:11.720
有多少個詞彙呢
link |
06:13.400
可能有一億個詞彙左右
link |
06:16.840
那一億其實是一個
link |
06:18.600
其實是一個非常大的數量
link |
06:20.840
為什麼它是一個很大的數量呢
link |
06:22.840
這個哈利波特全套啊
link |
06:25.080
從這個神秘的魔法石
link |
06:29.480
到死神的聖物全部大概一百萬個詞彙
link |
06:34.280
一百萬個詞
link |
06:35.400
所以今天在學這個
link |
06:37.480
機器在學這個語音辨識的時候
link |
06:39.720
這個一億是一百萬的一百倍啊
link |
06:42.280
所以機器等於是看了
link |
06:44.040
一百套哈利波特全集那麼多的文字
link |
06:49.720
然後他知道怎麼把語音轉成文字
link |
06:54.200
他怎麼知道
link |
06:55.080
他知道怎麼寫出合法的文字
link |
06:57.800
這個是如果你要蒐集成對資料的case
link |
07:02.280
那講到這邊我就想說
link |
07:04.600
這個一個人平均每分鐘是說一百三十個字
link |
07:08.680
但是人類最快一分鐘可以說多少個字呢
link |
07:11.720
我就google了一下啦
link |
07:13.640
這個金氏世界紀錄啊
link |
07:15.720
一個人最快一分鐘
link |
07:17.960
可以說超過六百個詞彙
link |
07:20.520
那這一個先生呢
link |
07:21.880
他是金氏世界紀錄說話最快的紀錄保持人
link |
07:26.440
他說話是這個樣子
link |
07:57.400
你就知道說一個人如果說話很快的話
link |
07:59.400
大概是什麼樣子了
link |
08:00.920
不過在後面的訪問裡面呢
link |
08:03.080
那這個金氏世界紀錄的保持人有說
link |
08:05.800
他在節目裡面啊
link |
08:07.480
說話的時候其實是刻意放慢速度的
link |
08:09.880
如果他想的話其實是可以講得更快的
link |
08:13.160
不過多數人講話都沒有辦法那麼快就是了
link |
08:17.560
那這個是成對資料的部分
link |
08:21.400
那如果是不成對的資料呢
link |
08:24.600
如果你今天只是單純想收集文字
link |
08:27.640
你可以收集到多少的文字呢
link |
08:31.240
我們來看一個東西叫做BERT
link |
08:33.720
那之後我們會再詳細講到BERT啦
link |
08:36.280
那今天你只要知道說BERT
link |
08:38.280
是一個巨大的language model就好了
link |
08:41.160
那如果你現在就想知道BERT是什麼的話
link |
08:43.720
之前我們在機器學習的課其實有稍微提到BERT
link |
08:47.240
你可以參考這一段影片的連結
link |
08:50.680
那BERT啊
link |
08:51.960
他在使用他在訓練的時候
link |
08:54.360
用了30億個以上的詞彙
link |
08:57.880
其實BERT用來訓練
link |
08:59.720
所使用的文字的資料並不是最多的
link |
09:01.880
很多後來更大的模型
link |
09:03.160
用來訓練的文字資料都是更多的
link |
09:05.560
但是BERT他使用的訓練資料
link |
09:08.600
所包含的詞彙的數目
link |
09:10.680
已經是語音的30倍以上
link |
09:15.400
所以這邊想要跟大家顯示的是說
link |
09:17.720
你其實可以輕易收集到大量資料
link |
09:19.960
去把py估的比較準
link |
09:21.960
而你比較不容易收集到資料
link |
09:24.280
把py given x估的準
link |
09:26.280
這就是為什麼我們需要加入py這個東西
link |
09:30.760
怎麼估測一個token sequence
link |
09:33.160
它的機率呢
link |
09:34.760
過去最常用的
link |
09:36.120
在還沒有deep learning的技術之前
link |
09:38.120
常用的技術叫做
link |
09:40.200
N-Gram的language model
link |
09:42.520
什麼是N-Gram的language model呢
link |
09:45.160
如果我們要估測一個token sequence的機率
link |
09:47.960
最直覺的方法
link |
09:48.920
當然是收集非常非常大量的文字
link |
09:51.880
然後在這堆文字裡面就看說
link |
09:54.280
這個token sequence出現的次數
link |
09:57.320
出現的機率有多高
link |
09:59.320
但問題是
link |
10:01.160
人類的句子非常非常的複雜
link |
10:03.960
所以隨便給你一個句子
link |
10:05.800
隨便給你一個token sequence
link |
10:07.640
它在你的訓練資料裡面
link |
10:09.080
出現的次數都是零
link |
10:10.680
但是你不會說這個句子出現的機率
link |
10:13.080
都是零
link |
10:13.800
你直接說這個句子出現的機率
link |
10:15.720
你直接說一個句子
link |
10:16.600
就因為沒有出現在訓練資料裡面
link |
10:19.000
它出現的機率就是零
link |
10:21.000
這件事是不合理的
link |
10:22.600
所以就有了N-Gram language model的想法
link |
10:25.960
N-Gram language model是把
link |
10:27.880
這整個token的機率
link |
10:30.440
拆解成比較小的機率相乘
link |
10:34.440
你會把P of Y1到Yn的機率
link |
10:37.320
拆解成Y1放在聚首的機率乘上
link |
10:40.680
Y1後面接Y2的機率
link |
10:42.440
一直乘到Yn-1後面接Yn的機率
link |
10:47.080
舉例來說假設你要算recognize speech這個句子的機率
link |
10:52.520
那為什麼舉recognize speech這個句子當作例子呢
link |
10:56.120
那因為recognize speech這個句子
link |
10:58.600
跟語音辨識的英文正好發音一模一樣
link |
11:04.040
就語音辨識是recognize speech
link |
11:07.480
跟破壞一個好的海灘recognize speech
link |
11:11.720
它們的發音正好是一模一樣的
link |
11:13.880
所以在講語音辨識
link |
11:14.920
在提到language model的時候
link |
11:16.600
做語音的往往就舉這個例子
link |
11:19.160
這個recognize speech
link |
11:21.560
如果你用N-Gram的想法的話
link |
11:23.320
你不會直接估測這個token sequence的機率
link |
11:25.960
你會估測rec放在聚首的機率
link |
11:28.200
rec後面接er的機率
link |
11:29.800
er後面接nice的機率
link |
11:31.080
nice後面接beach的機率
link |
11:32.760
這個是N-Gram的language model
link |
11:35.480
那這邊每一項機率要怎麼估測呢
link |
11:38.360
舉例來說怎麼估測nice後面接beach的機率呢
link |
11:41.640
那這個也很直覺
link |
11:42.840
你直接去你的訓練資料裡面計算說
link |
11:45.480
nice這個詞會出現幾次
link |
11:47.480
nice跟beach這個片語出現幾次
link |
11:51.240
你把nice後面接beach出現的次數
link |
11:54.120
除掉nice出現的次數
link |
11:55.720
你就知道nice後面接beach的機率了
link |
11:58.760
那這種given一個詞彙
link |
12:01.560
看下一個詞彙出現的機率
link |
12:04.360
這樣子的language model
link |
12:06.200
是5-Gram的language model
link |
12:08.520
那你可以把5-Gram的language model
link |
12:11.080
擴展到3-Gram
link |
12:12.600
擴展到4-Gram
link |
12:14.120
那3-Gram就是given兩個詞彙
link |
12:16.680
統計下一個詞彙出現的機率
link |
12:19.080
4-Gram就是given三個詞彙
link |
12:21.080
統計下一個詞彙出現的機率
link |
12:23.880
那你可以輕易的從5-Gram
link |
12:25.880
擴展到3-Gram
link |
12:27.480
擴展到4-Gram
link |
12:29.480
這是N-Gram的language model
link |
12:31.480
那N-Gram的language model有什麼問題呢
link |
12:34.600
他的問題是說
link |
12:35.880
就算是我們今天已經把整個token sequence的機率
link |
12:40.760
拆成很多項N-Gram,很多項小的component
link |
12:45.080
相乘以後的結果
link |
12:46.680
我們收集的訓練資料
link |
12:48.920
仍然遠遠不夠
link |
12:51.160
讓我們準確的計算出一個句子的出現的機率
link |
12:55.640
為什麼呢
link |
12:56.760
就假設這是你的訓練資料
link |
12:59.080
你的訓練資料裡面收集的句子裡面有說
link |
13:01.720
狗在跑
link |
13:03.240
然後有貓在跳
link |
13:06.040
那如果根據你收集到訓練資料
link |
13:10.040
狗後面有一定的機率會接跑
link |
13:12.280
貓後面有一定的機率會接跳
link |
13:14.280
但狗後面會接跳的機率是0
link |
13:16.920
貓後面會接跑的機率也是0
link |
13:19.160
所以根據你的訓練資料
link |
13:20.680
你就會得到結論說狗是不可能會跑的貓
link |
13:23.480
狗是不可能會跳的貓是不可能會跑的
link |
13:26.120
但這個是不合理的
link |
13:27.880
這顯然是不切實際的
link |
13:30.040
就算是某一種N-Gram
link |
13:32.280
他在你的訓練資料裡面一次都沒有出現
link |
13:35.160
但並不代表他出現的機率就完全是0
link |
13:39.160
所以為了要解決這個問題
link |
13:41.160
N-Gram的Language Model
link |
13:42.920
必須要搭配一個叫做
link |
13:44.920
Language Model Moving的技巧
link |
13:47.560
也就是說
link |
13:48.600
有一些N-Gram雖然統計出來機率是0
link |
13:51.480
你不要直接給他機率0
link |
13:52.840
因為他不是0他只是出現的機率很低而已
link |
13:55.560
所以你不要給他機率0
link |
13:57.240
你應該給他一個小小的機率
link |
13:59.240
那至於這個小小的機率應該是多少
link |
14:02.120
就有非常非常多不同的技術來告訴你說
link |
14:04.840
這個小小的機率應該要是多少
link |
14:07.640
那這個技術叫做Language Model的Smoothing
link |
14:11.240
他有非常非常多的變形
link |
14:13.240
如果你想要知道細節的話
link |
14:14.760
可以參考李靈山老師的數位語音處理這門課
link |
14:19.160
好那後來就逐漸的進入了Deep Learning的時代
link |
14:23.160
在進入Deep Learning的時代之前
link |
14:25.720
人們是怎麼處理Language Model Smoothing這個問題的呢
link |
14:29.720
有一個神秘的技術
link |
14:31.720
叫做Continuous的Language Model
link |
14:35.240
這Continuous Language Model
link |
14:37.240
他是一個超展開
link |
14:39.240
他是從推薦系統來的一個靈感
link |
14:43.640
所以我們超展開一下突然跳來講推薦系統
link |
14:47.080
本來在講語音辨識突然超展開要講推薦系統
link |
14:50.840
那推薦系統是怎麼一回事呢
link |
14:53.240
推薦系統就是說
link |
14:54.440
現在假設有一個動漫的網站
link |
14:58.040
比如說NicoNico
link |
14:59.640
然後現在有五個使用者在看NicoNico上的四部動畫
link |
15:05.160
然後有一些使用者會給某些動畫打個分數
link |
15:09.640
那你現在想要推薦動畫給使用者B
link |
15:14.120
你知道使用者B曾經給過涼宮春日很高的分數
link |
15:18.200
那他會不會喜歡超電磁炮呢
link |
15:22.120
他會不會喜歡玉板美琴呢
link |
15:24.600
那你就可以從其他的使用者的行為去推估出來
link |
15:29.560
那就發現說喜歡涼宮春日的人也會喜歡超電磁炮
link |
15:35.400
那可能是因為涼宮春日跟玉板美琴背後都有同樣的屬性
link |
15:40.760
就是傲嬌的屬性
link |
15:42.440
所以喜歡涼宮春日的人就會喜歡玉板美琴
link |
15:45.480
所以你就可以推測說B喜歡涼宮春日
link |
15:48.280
所以他也可能是喜歡玉板美琴的
link |
15:51.800
那這件事情實際上要怎麼做出來呢
link |
15:55.560
有一個技術叫做Matrix Factorization
link |
15:59.640
Matrix Factorization可以幫你把這個table裡面
link |
16:03.800
沒有填上數值的部分把它估測出來
link |
16:08.600
然後就有人想到說把這個技術用在Language Model上
link |
16:14.440
這個技術怎麼用在Language Model上呢
link |
16:17.640
你做一個一樣的表格
link |
16:19.560
只是現在這個表格不是使用者跟要推薦給使用者看的動畫
link |
16:25.640
而是兩邊都是文字
link |
16:28.520
這個表格的縱軸跟橫軸是你vocabulary
link |
16:33.400
你的這個詞典裡面所有的詞彙
link |
16:37.000
就是你所有可能的token
link |
16:40.680
這個表格裡面橫軸跟縱軸就是你所有可能的token
link |
16:47.000
而這個表格裡面填的值是什麼呢
link |
16:49.240
這個表格裡面填的值是
link |
16:51.240
某一個token後面接另外一個token
link |
16:54.440
在我們訓練資料裡面統計出來的次數
link |
16:57.800
比如說狗後面接跑出現兩次
link |
17:01.880
貓後面接跑出現三次
link |
17:04.360
小孩後面接跑出現一次
link |
17:06.680
然後狗後面接跳出現零次
link |
17:10.120
貓後面接跳出現兩次
link |
17:12.760
然後小孩後面接哭出現三次
link |
17:15.000
小孩後面接笑出現三次
link |
17:17.400
但貓不會哭 貓不會笑 狗不會哭 狗不會笑
link |
17:21.000
這樣等等
link |
17:22.200
好 那你建出這樣一個table以後
link |
17:24.360
接下來啊
link |
17:25.320
這邊填零的東西
link |
17:27.320
就是在你的訓練資料裡面沒有出現
link |
17:29.560
但我們想要估測這些填零的位置
link |
17:32.280
到底實際上的值應該是什麼
link |
17:35.320
這時候你就可以用到
link |
17:37.480
很常被用在推薦系統裡面的
link |
17:40.120
metric factorization的技術
link |
17:42.040
來解這個問題
link |
17:44.200
好 怎麼做呢
link |
17:45.960
怎麼做呢
link |
17:47.960
每一個詞彙啊
link |
17:49.800
後面都有一個對應的向量
link |
17:53.480
所以這邊的每一個詞彙
link |
17:56.200
或者說每一個token
link |
17:57.720
它背後都有一個vector
link |
17:59.880
我們叫它h
link |
18:01.240
那狗後面有h1
link |
18:03.080
貓後面有h2
link |
18:05.400
那這邊的每一個token
link |
18:07.080
它背後有一個向量
link |
18:08.360
我們用v來表示它
link |
18:09.720
跑後面有v1
link |
18:10.920
jump後面有v2
link |
18:11.960
cry後面有v3
link |
18:13.480
笑後面有v4等等
link |
18:16.120
那這個h1跟v啊
link |
18:18.760
這個h跟v啊
link |
18:20.360
它代表的是這個詞彙的屬性
link |
18:24.840
這個詞彙的屬性
link |
18:26.280
那這個h跟v
link |
18:27.960
是要從訓練資料裡面
link |
18:30.360
根據這個表格把它估算出來的
link |
18:34.520
怎麼估算這個h跟v呢
link |
18:36.600
我們假設這個表格裡面的每一個數值
link |
18:40.040
我們用n來表示
link |
18:42.440
n1 1代表狗它對應h1
link |
18:46.200
這一個token
link |
18:47.240
後面接跑後面對v1的token
link |
18:50.760
然後n2 2代表cat後面接跳
link |
18:54.600
的出現的次數
link |
18:55.880
h2所對應的token
link |
18:58.200
接v2所對應的token出現的次數
link |
19:01.240
那我們假設這邊的這個次數啊
link |
19:03.880
就等於這些vector的和
link |
19:07.000
也就是n1 2
link |
19:08.520
就是不是vector的和
link |
19:10.200
是vector的inner product
link |
19:15.320
所以n1 2就是v1跟h2的inner product
link |
19:18.920
n2 1就是v2跟h1的inner product
link |
19:22.440
所以接下來你就可以寫出這個
link |
19:24.840
你要去learn的這個loss function
link |
19:28.440
你會去找出一個v
link |
19:30.520
找出一個h
link |
19:31.560
你去找出一組h
link |
19:33.080
找出一組v
link |
19:34.200
這組h跟這組v
link |
19:36.040
可以讓這個loss function的值越小越好
link |
19:39.480
因為這邊假設說vi跟hj做inner product
link |
19:45.000
跟nij要越接近越好
link |
19:48.760
nij是我們可以觀察到的東西
link |
19:51.960
這個table裡面的數值
link |
19:53.960
某一個詞彙接
link |
19:54.920
某一個詞彙出現的次數
link |
19:56.680
是我們可以觀察到的東西
link |
19:58.520
我們觀察不到的東西
link |
20:00.760
是h跟v求出來的
link |
20:03.640
那我們假設說h跟v
link |
20:05.400
做inner product以後
link |
20:06.440
就會得到nij
link |
20:07.480
nij我們是知道的
link |
20:09.000
我們就可以藉由minimize這個loss function
link |
20:11.560
把所有的word背後對應的h
link |
20:13.880
所有的詞彙
link |
20:15.240
所有的token背後對應的v
link |
20:17.240
通通給它找出來
link |
20:19.480
那這個只需要用gradient descent
link |
20:21.800
就可以把v跟h通通都找出來了
link |
20:26.120
好那找出來以後怎麼樣呢
link |
20:28.440
找出來以後
link |
20:29.960
我們今天在計算
link |
20:31.960
某一個詞彙後面接另外一個詞彙
link |
20:34.440
某一個token後面接
link |
20:35.560
另外一個token的次數的時候
link |
20:37.560
我們就不是直接看table裡面統計的結果了
link |
20:41.320
我們會直接把某一個詞彙
link |
20:43.720
所對應的向量
link |
20:44.920
乘上另外一個詞彙所對應的向量
link |
20:47.160
代表我們估計出來的
link |
20:49.880
這兩個詞彙會被接在一起的
link |
20:53.720
可能的次數會被接在一起的可能性
link |
20:57.800
那這樣做有什麼好處呢
link |
21:00.120
假設狗跟貓
link |
21:02.200
他們有同樣的屬性
link |
21:03.800
所以他們背後這個對應的向量很像
link |
21:06.600
h上標狗跟h上標貓
link |
21:09.080
這兩個向量很像
link |
21:10.280
那如果在訓練資料裡面
link |
21:12.760
我們已經觀察到說
link |
21:14.760
貓後面常常接jump
link |
21:17.960
貓常常跳在你的訓練資料裡面
link |
21:20.120
貓是常常跳的
link |
21:21.400
也就是貓的h這個向量
link |
21:24.200
跟跳的這個v這個向量
link |
21:26.440
他們做inner product以後
link |
21:28.040
他們的值通常都很大
link |
21:30.920
那今天就算是狗後面接跳的次數很少
link |
21:36.040
但是狗跟貓的向量很像
link |
21:37.960
狗跟貓的h很像
link |
21:39.640
那狗的h乘上jump的v
link |
21:42.360
他們做inner product以後
link |
21:43.960
值也會跟著很大
link |
21:45.080
雖然實際上你沒有看到太多
link |
21:47.240
狗後面接跳的這樣子的狀況
link |
21:50.360
出現在你的訓練資料裡面
link |
21:51.800
那可能只是你的訓練資料不夠大
link |
21:53.720
根據我們今天估測出來的h跟v
link |
21:56.280
因為狗跟貓有同樣的屬性
link |
21:58.280
所以貓竟然後面常常會接跳
link |
22:00.360
那狗後面也常常會接跳
link |
22:03.560
那這個就是一個
link |
22:06.200
自動認出來的
link |
22:08.200
language model smoothing的方法
link |
22:09.800
那傳統language model smoothing的方法
link |
22:11.720
是heuristic
link |
22:13.000
是人定的人想出來的
link |
22:14.920
但是可以在continuous language model裡面
link |
22:17.480
我們自動做到了language model smoothing
link |
22:20.360
他是透過learning的方法認出來的
link |
22:24.440
那continuous language model
link |
22:26.200
在10年11年的時候
link |
22:28.360
曾經紅極一時
link |
22:30.040
然後那時候他們覺得說這個方法
link |
22:32.280
太潮了 神展開啊 超展開啊
link |
22:35.320
把這個推薦系統的方法
link |
22:37.240
用到language model裡面啊
link |
22:38.920
太神了 就太厲害了
link |
22:40.600
可以解決language model smoothing的問題
link |
22:43.160
當然後來這樣的方法
link |
22:45.000
也逐漸被deep learning取代掉了
link |
22:48.040
不過你記不記得我們之前在講
link |
22:49.720
hidden Markov model的時候
link |
22:50.920
我們有講說
link |
22:51.880
這個hidden Markov model
link |
22:53.480
有一個stay time的問題
link |
22:55.320
然後有一個終極的解決
link |
22:57.080
stay time的方法叫做suspect CNN
link |
23:00.280
那他也曾經紅極一時
link |
23:02.920
不過deep learning
link |
23:04.280
他是一個更直覺的解決stay time的問題
link |
23:08.840
他是一個更直覺的
link |
23:09.880
讓所有stay都共用一個model方法
link |
23:12.040
所以就逐漸把suspect CNN淘汰掉了
link |
23:15.480
那其實language model也是一樣
link |
23:17.480
continuous language model乍看之下
link |
23:19.800
好像跟deep learning沒有很直覺的關係
link |
23:22.520
但是在下一頁投影片
link |
23:24.120
我會告訴你說
link |
23:25.320
其實你可以把continuous language model
link |
23:27.720
想成是deep learning based language model的
link |
23:31.080
一個略化版
link |
23:33.400
所以你會發現說
link |
23:35.000
你就在到多數人的印象裡面
link |
23:36.760
可能覺得說deep learning
link |
23:37.960
引入一個領域是
link |
23:39.240
不知道怎麼回事
link |
23:40.280
有天突然冒出來一個deep learning
link |
23:42.120
他很強大
link |
23:42.840
他是一個invader
link |
23:43.720
然後把所有人通通都打死這樣
link |
23:45.800
但其實從原來的技術變到deep learning
link |
23:48.680
他中間是有一個
link |
23:50.120
我覺得是漸變的過程
link |
23:52.760
人們已經知道說
link |
23:54.280
現有技術有什麼問題
link |
23:55.960
想一些方法來解決
link |
23:57.880
跟deep learning有點像
link |
23:59.160
像有點像是deep learning的略化版
link |
24:01.640
然後才進入deep learning
link |
24:03.080
就像我們從hidden Markov model
link |
24:05.000
到suspect GNN
link |
24:06.200
最後進入deep learning
link |
24:07.640
原來的N-Gram based language model
link |
24:09.560
有smoothing的問題
link |
24:10.600
所以有了一個continuous language model
link |
24:13.480
然後接下來進入deep learning based language model
link |
24:18.440
而continuous language model
link |
24:20.200
我們可以這樣子表示
link |
24:22.440
我有狗的像量
link |
24:24.760
狗的像量這個h上標狗
link |
24:27.240
然後把狗的像量呢
link |
24:28.760
乘上rand V的vector
link |
24:31.800
就得到狗後面接rand估計出來的次數
link |
24:36.440
我把h狗乘上V seat
link |
24:39.000
就知道seat估計出來的次數
link |
24:42.040
那我們在訓練的時候
link |
24:43.640
我們有一個training的target
link |
24:45.320
因為從training data裡面
link |
24:46.600
我們可以實際估測出
link |
24:48.200
狗後面接跑的次數可能是三次
link |
24:51.240
狗坐下來的次數可能是兩次
link |
24:53.960
那我們會希望說把h跟這個V相乘以後
link |
24:57.320
它得到的結果
link |
24:58.440
跟你的訓練目標越接近越好
link |
25:01.240
這就是我們右上角這個loss function寫的事情
link |
25:05.800
那這個東西啊
link |
25:06.920
我們可以把它當成一個簡單的neural network來看
link |
25:10.760
這個neural network只有一個hidden layer
link |
25:14.040
這個hidden layer裡面沒有activation function
link |
25:17.160
它是linear的hidden layer
link |
25:20.520
然後今天如果你要找出h狗的時候
link |
25:23.400
怎麼做呢
link |
25:24.360
你先把所有的word h
link |
25:26.760
當作是這個neural network的第一個layer的參數
link |
25:30.680
你把所有的h
link |
25:31.880
當作是這個network的第一個layer的參數
link |
25:34.440
如果今天你要找出h dog
link |
25:36.680
你就輸入一個one-half vector
link |
25:38.920
所謂one-half vector的意思是說
link |
25:40.920
只有狗對應到的那個維度是1
link |
25:43.960
其他維度都是0
link |
25:45.240
這個輸入的相量的長度
link |
25:46.840
跟你的token的數目是一樣多的
link |
25:50.360
那只有對應到狗的那一維是1
link |
25:52.680
其他都是0
link |
25:53.400
把這個相量丟進去
link |
25:54.920
中間hidden layer的輸出就是h dog
link |
25:57.720
然後在城上這邊的每一個v
link |
26:00.120
你就可以估測出這個狗後面接
link |
26:03.400
每一個token估測出來的次數有多少
link |
26:06.280
那訓練的時候
link |
26:07.400
你有quantum
link |
26:08.360
那你要去minimize一個loss function
link |
26:11.240
所以continuous language model
link |
26:13.000
可以看作是一個只有一個hidden layer的
link |
26:16.040
簡單的deep network
link |
26:18.200
那既然這是一個deep network
link |
26:20.520
那我們就可以直接拓展到
link |
26:23.320
一個更深的network
link |
26:25.320
一個general的neural network
link |
26:27.800
所以有了NN-based language model
link |
26:30.680
NN-based language model
link |
26:32.200
就逐漸的流行起來
link |
26:34.600
那NN-based language model
link |
26:35.960
訓練是這個樣子的
link |
26:37.080
你先蒐集一大堆訓練資料
link |
26:39.320
然後NN-based language model
link |
26:41.560
他最早是想要取代
link |
26:43.960
N-grain的language model
link |
26:46.200
他做的事情
link |
26:47.240
跟N-grain的language model很像
link |
26:49.160
N-grain的language model是given幾個詞彙
link |
26:52.120
比如說trigger language model
link |
26:53.640
就是given兩個詞彙
link |
26:54.680
問你下一個詞彙的機率是多少
link |
26:56.680
估測下一個詞彙的機率是多少
link |
26:58.760
那neural network也是一樣
link |
27:00.680
你給他
link |
27:02.040
比如說如果你要用你的NN-based language model
link |
27:05.240
去取代trigger的話
link |
27:06.600
那你就trigger neural network
link |
27:08.200
給他兩個詞彙
link |
27:09.320
然後學習的時候
link |
27:11.000
叫他去學預測下一個詞彙
link |
27:13.720
叫他跟他在學的時候
link |
27:15.800
蒐集到一個句子叫做草水退了
link |
27:17.560
就知道誰沒穿褲子
link |
27:19.240
那你的NN就要學說
link |
27:21.240
看到草水跟退了
link |
27:22.920
接下來就要輸出舊
link |
27:24.440
看到退了跟舊
link |
27:25.800
接下來就要輸出知道
link |
27:27.240
看到舊跟知道
link |
27:28.600
接下來就要輸出誰
link |
27:30.440
然後下去
link |
27:31.560
你就有一個NN-based language model
link |
27:35.480
有了這個東西以後
link |
27:36.760
你就可以把原來的N-grain
link |
27:39.480
把它取代掉
link |
27:40.440
原來N-grain算機率這件事情
link |
27:42.680
就可以用NN-based language model
link |
27:45.320
所計算出來的機率把它取代掉
link |
27:47.640
你今天本來recognize speech
link |
27:49.880
是一連串的by-grain乘起來的結果
link |
27:52.920
現在這些by-grain裡面的機率
link |
27:55.320
都可以換成是NN輸出的機率
link |
27:59.160
那具體而言是這樣
link |
28:00.600
就你訓練訓練好一個neural network
link |
28:03.400
這個neural network是
link |
28:04.760
給定之前已經出現的詞彙
link |
28:06.840
他會去預測下一個詞彙出現的機率
link |
28:10.600
他會預測說下一個詞彙是
link |
28:12.920
某個詞彙的機率是多少
link |
28:15.320
他的輸出的dimension
link |
28:17.080
就是你的這個token的size
link |
28:19.880
就是你現在要幾個token
link |
28:21.480
輸出的dimension就有多大
link |
28:23.160
你丟進去過去已經出現的詞彙
link |
28:25.160
他輸出就是
link |
28:26.440
下一個詞彙應該是某一個token的機率
link |
28:29.480
他會給每一個token一個機率
link |
28:31.080
代表下一個詞彙
link |
28:32.440
應該是這個token的機率
link |
28:34.840
所以你訓練好一個NN-based language model
link |
28:37.560
你要算recognize speech的機率
link |
28:39.960
你就把一個代表據手的token
link |
28:41.800
丟到這個network裡面
link |
28:43.320
然後讓這個network預測
link |
28:45.080
rec出現的機率
link |
28:46.520
把rec丟進去看看er出現的機率
link |
28:49.560
把er丟進去看看nice出現的機率
link |
28:52.200
把nice丟進去看看beech出現的機率
link |
28:54.360
把所有機率乘起來
link |
28:55.720
你就得到這個token sequence
link |
28:57.640
這個句子出現的機率
link |
28:59.400
這是NN-based language model
link |
29:02.520
那事實上NN-based language model
link |
29:05.240
它的實際上的出現
link |
29:07.480
是比continuous language model還要早的
link |
29:10.680
只是它在語音的領域
link |
29:12.840
一時沒有引起非常大的重視
link |
29:15.640
直到continuous language model熱潮過了以後
link |
29:18.600
continuous language model崛起以後
link |
29:20.840
然後才有人把NN-based language model
link |
29:23.640
再找出來使用
link |
29:25.400
那直到今天NN-based language model
link |
29:27.640
變成一個非常主流的想法
link |
29:30.680
好,那NN-based language model
link |
29:32.280
它最早的起源
link |
29:33.800
我目前可以找到最早的文獻
link |
29:35.960
應該是Benjo在03年
link |
29:38.520
哇,這個超過15年前發表的文章
link |
29:41.960
那我大學的時候是讀過這一篇文章的
link |
29:44.760
當時留給我一個非常深刻的印象
link |
29:47.800
因為我覺得哇,這個方法太神了
link |
29:50.360
用NN來估測一個機率
link |
29:52.520
用NN來取代language model
link |
29:54.440
自動做smoothing
link |
29:55.640
感覺好像很厲害
link |
29:56.920
不過他的paper最後實驗
link |
29:58.600
這個詳細的數字我忘了
link |
30:00.120
他paper裡面寫了一個實驗
link |
30:01.960
讓我覺得我大概一輩子都沒辦法做
link |
30:03.560
他想說什麼用30張GPU
link |
30:05.960
訓練了三週以後
link |
30:07.320
好像沒有訓練完
link |
30:08.520
但是大概也只能做到這邊了
link |
30:10.360
然後就把結果寫成paper
link |
30:12.600
所以當時我就覺得說
link |
30:13.880
當時身為大學生的
link |
30:15.480
我覺得說應該是沒辦法做這個實驗
link |
30:18.280
不過今天NN-based language model
link |
30:20.520
當然已經是滿地都是了
link |
30:23.000
那這篇paper還有一個神奇的地方
link |
30:24.600
就是它裡面居然有提到
link |
30:27.880
word embedding
link |
30:29.240
我們知道說word embedding
link |
30:31.080
大家通常是覺得說是
link |
30:32.840
Thomas Mikhailov在13年、14年的時候發明的
link |
30:36.440
但在這篇文章裡面
link |
30:37.880
是有提到word embedding的概念
link |
30:40.760
他有把這個network裡面的
link |
30:43.480
later representation拿出來visualize
link |
30:46.600
然後看起來就跟今天
link |
30:48.280
我們大家所熟知的word embedding
link |
30:51.160
word vector得到的結果
link |
30:53.000
是非常類似的
link |
30:55.080
所以這是一個穿越時空的paper
link |
31:00.920
接下來就進入了
link |
31:02.760
RNN-based language model
link |
31:05.240
那為什麼要有RNN-based language model呢
link |
31:08.280
因為你可能會想看非常長的history
link |
31:14.040
決定下一個word出現的基地
link |
31:16.760
那如果你今天不是用RNN
link |
31:19.000
只是一般的NN的話
link |
31:20.760
那你的輸入會變得非常長
link |
31:23.160
輸入非常長
link |
31:24.280
你就會需要非常多的參數
link |
31:27.400
所以怎麼辦
link |
31:28.360
引入一個recurrent的network
link |
31:30.680
用recurrent的network
link |
31:32.040
把W1到WT讀進去
link |
31:34.840
然後最後一個hidden layer
link |
31:36.680
輸出一個representation ht
link |
31:39.320
再把這個ht乘上每一個word所對應的V
link |
31:43.640
然後去估測下一個word應該出現的基地
link |
31:47.480
所以如果用RNN-based language model
link |
31:50.040
你就可以考慮非常長的NN
link |
31:53.000
RNN-based language model
link |
31:54.280
等於是可以讓你考慮非常長的NN
link |
31:56.520
過去如果是一般的NN language model
link |
31:59.000
你勸個tri-NN差不多是主流
link |
32:01.960
4NN你要很大的運算資源 5NN
link |
32:04.920
不是每個人都可以做
link |
32:05.960
多數人都不能做
link |
32:06.840
也許只有Google可以做
link |
32:08.040
但是今天如果有RNN-based language model
link |
32:11.000
你就可以考慮非常長的NN
link |
32:13.800
要考慮多長的NN都可以
link |
32:15.880
看你的劇走多長
link |
32:17.160
RNN-based language model
link |
32:18.600
就考慮了多長的NN
link |
32:23.320
RNN有各式各樣不同的變形
link |
32:25.800
曾經一度人們的想法是
link |
32:28.280
我就是做個最複雜的RNN
link |
32:32.360
裡面有非常複雜的operation
link |
32:35.000
看能不能夠做出非常強的NN
link |
32:38.920
比如說有一個同學
link |
32:40.120
他用Neural Turing Machine
link |
32:42.200
他把Neural Turing Machine改一改
link |
32:44.040
當作NN
link |
32:45.480
看起來非常非常複雜
link |
32:47.000
就像我想講你也不想知道就是了
link |
32:49.480
不過近年來人們開始發現說
link |
32:51.640
其實如果你用一般常用的
link |
32:54.520
language model的RNN-based的模型
link |
32:58.520
比如說LSTM
link |
33:00.040
你只要好好的做Optimization
link |
33:02.680
好好的做Regularization
link |
33:04.680
其實就可以得到非常非常好的結果
link |
33:08.280
其實不見得需要用
link |
33:09.800
非常神妙的奇蹟銀條
link |
33:12.120
好遠一般的LSTM好好train
link |
33:14.600
就可以得到很好的結果了
link |
33:18.920
這些language model
link |
33:21.720
怎麼跟今天的Deep Learning Based的
link |
33:26.200
這些N-to-N的model結合起來呢
link |
33:28.760
我們這邊用LAS當作例子
link |
33:31.480
看Neural Network Based的language model
link |
33:34.520
怎麼跟LAS把它結合起來呢
link |
33:39.640
這個結合的方法有很多
link |
33:42.840
所以在文篇上
link |
33:44.200
你就可以看到比如說有Shallow Fusion
link |
33:47.400
有Deep Fusion
link |
33:49.160
有Code Fusion
link |
33:51.160
那這些Fusion的方法
link |
33:53.160
我們可以根據
link |
33:54.520
怎麼把language model跟LAS結合
link |
33:58.280
分成兩類
link |
33:59.160
我們也可以根據它什麼時候結合
link |
34:02.360
分成兩類
link |
34:04.360
什麼叫做怎麼結合呢
link |
34:06.360
這個等一下我們會講得更清楚一點
link |
34:08.360
什麼叫做怎麼結合呢
link |
34:09.800
就如它今天你可以在
link |
34:11.640
兩個model的輸出端結合
link |
34:14.040
也可以在兩個model的hidden layer結合
link |
34:17.240
什麼叫做什麼時候結合呢
link |
34:19.720
你可以先把language model跟LAS
link |
34:23.320
train好以後再結合
link |
34:25.320
也可以把language model先train好
link |
34:28.520
先不train LAS
link |
34:29.960
先把train好language model
link |
34:31.560
加上沒有train好的LAS
link |
34:33.320
再去訓練LAS
link |
34:35.320
那以下呢
link |
34:36.920
我們就跟大家看一下
link |
34:38.760
Shallow Fusion Deep Fusion
link |
34:40.280
跟Code Fusion分別是怎麼做的
link |
34:42.600
先看Shallow Fusion
link |
34:44.840
Shallow Fusion的做法是這樣
link |
34:46.840
我們有一個deep learning based
link |
34:50.040
end-to-end的model
link |
34:51.000
我們有一個LAS已經train好的
link |
34:54.040
我們有一個language model
link |
34:56.040
也已經透過大量的文字先訓練好了
link |
34:59.080
現在我們要把這兩個
link |
35:01.080
已經訓練好的model把它結合起來
link |
35:03.560
怎麼結合起來呢
link |
35:05.000
這個想法是非常直覺的
link |
35:07.000
今天LAS output一個probability distribution
link |
35:10.360
我們叫它PLAS
link |
35:12.360
那language model output一個
link |
35:14.360
probability distribution叫做PLN
link |
35:17.160
你就把這兩個probability distribution
link |
35:20.360
log相加或者是相乘
link |
35:22.360
log相加就是相乘以後
link |
35:24.360
得到最終的probability distribution
link |
35:27.160
那這邊前面呢
link |
35:28.760
往往會需要乘上一個weight
link |
35:31.400
那這個就是一個你要調的參數
link |
35:33.960
你要把它當做hyperparameter
link |
35:35.800
用depth set來決定這個參數是多少
link |
35:37.800
看你要相信language model多一點
link |
35:40.200
還是相信你的LAS多一點
link |
35:42.680
這兩者之間你是需要取得一個平衡的
link |
35:46.200
然後接下來
link |
35:48.200
decode的方法就跟我們之前講的都一樣
link |
35:51.720
那你可能會需要用bin search
link |
35:54.200
反正就從這個機率裡面
link |
35:56.200
或者假設你不用bin search的話
link |
35:58.200
你就從這個加好的機率
link |
35:59.800
已經fuse好的機率
link |
36:01.240
得到看機率最大work是什麼
link |
36:04.040
機率最大token是什麼
link |
36:06.040
就當做你的輸出
link |
36:08.040
同樣的process同樣的fusion process
link |
36:10.520
就反覆進行下去
link |
36:12.520
那直接在輸出的地方
link |
36:14.280
沒做什麼特別的技術
link |
36:15.560
就直接把它log相加
link |
36:17.880
或者是相乘起來
link |
36:19.320
這個叫做shallow fusion
link |
36:21.720
shallow fusion是直接在輸出的地方相加
link |
36:25.960
或者是log相加
link |
36:27.960
或者是不是log相加
link |
36:29.160
沒有取log的話就是相乘了
link |
36:31.160
那deep fusion呢
link |
36:32.680
是在hidden的部分
link |
36:34.840
hidden layer的輸出
link |
36:36.600
就把它們integrate起來
link |
36:39.640
就把它們混起來
link |
36:41.400
那怎麼在hidden的地方
link |
36:43.240
就把這兩個model混起來呢
link |
36:45.240
所以你今天有一個train好的language model
link |
36:47.720
你有一個train好的LAS
link |
36:49.160
你會把他們的hidden layer的輸出
link |
36:50.920
把它接近拉出來
link |
36:52.600
你會把他們hidden layer的輸出拉出來
link |
36:54.760
然後丟到一個neural network裡面去
link |
36:58.120
然後再由這個network
link |
36:59.640
去決定最終output的distribution
link |
37:02.520
應該長什麼樣子
link |
37:04.920
那可是這個network是怎麼來的呢
link |
37:07.080
這個network最終也是需要
link |
37:09.720
透過訓練得到的
link |
37:11.320
所以你訓練好一個language model
link |
37:13.080
訓練好一個LAS
link |
37:14.680
如果你要做deep fusion
link |
37:16.200
你還必須再準備一些訓練資料
link |
37:18.920
再準備一些訓練資料
link |
37:20.680
來訓練這個network
link |
37:22.680
來訓練這個灰色的block
link |
37:24.760
然後讓它輸出最終可以得到
link |
37:27.320
你要的結果
link |
37:28.920
這個叫做deep fusion
link |
37:31.880
那如果你是把hidden layer接出來
link |
37:34.200
你其實會遇到一個問題
link |
37:35.560
這個問題是
link |
37:36.920
你不能夠任意換你的language model
link |
37:40.280
如果你今天想要把language model抽換掉
link |
37:42.920
你覺得這個language model不是你要的
link |
37:44.760
你要把它抽換掉
link |
37:46.360
那不行
link |
37:47.080
因為你要把它抽換掉
link |
37:48.440
你得重train你的neural network才行
link |
37:51.080
你每次要抽換掉這個language model
link |
37:53.480
你得重train你的neural network
link |
37:55.800
如果你是把hidden layer拉出來
link |
37:58.680
直接丟到這個network裡面的話
link |
38:01.240
那你可能會問說
link |
38:02.520
什麼時候我們會需要
link |
38:03.720
常常抽換language model呢
link |
38:05.800
今天當你要換domain的時候
link |
38:09.160
你可能就會想要抽換你的language model
link |
38:13.160
什麼意思呢
link |
38:14.280
因為很多詞彙啊
link |
38:15.960
它的發音其實是一樣的
link |
38:19.080
舉例來說
link |
38:20.200
這個city這個城市
link |
38:23.560
city跟城市語言的城市programming
link |
38:27.880
他們的發音是一模一樣的
link |
38:30.120
所以如果有一個人說
link |
38:31.560
我喜歡城市
link |
38:32.920
你不知道他喜歡的是city
link |
38:34.280
還是喜歡寫城市這樣子
link |
38:36.760
那怎麼辦呢
link |
38:38.360
你可能要根據domain的不同
link |
38:40.600
選不同的language model
link |
38:42.120
因為對LAS來說
link |
38:43.560
有一個人說我喜歡城市的時候
link |
38:46.200
可能city的機率
link |
38:48.040
跟programming的機率
link |
38:49.640
對這個LAS的model來說是差不多的
link |
38:52.440
那我們需要language model來決定說
link |
38:54.360
到底應該是city還是programming
link |
38:57.560
那language model
link |
38:59.960
可以隨著不同的domain
link |
39:01.560
你就train不同的language model
link |
39:03.240
你可能有一個
link |
39:04.360
一般人使用的language model
link |
39:06.040
如果是一般人使用的language model的話
link |
39:08.520
那可能城市的機率
link |
39:10.360
city的機率就高一點
link |
39:12.120
那如果是電子學院的同學
link |
39:14.440
使用的language model的話
link |
39:16.360
那可能programming的機率就高一點
link |
39:19.320
所以你可以透過換language model
link |
39:21.800
來達到個人化
link |
39:23.480
每個人都有一個不同的language model
link |
39:25.800
可以把它常用的詞彙辨識的比較好
link |
39:29.640
那可是如果是deep fusion的方法的話
link |
39:32.280
你不能夠輕易的拔掉你的language model
link |
39:35.080
你拔掉你的language model換一個新的進來
link |
39:37.480
你這個network
link |
39:38.440
你這個灰色的block得重train才行
link |
39:41.720
那怎麼辦呢
link |
39:43.240
有一招是這樣
link |
39:44.760
你把你的language model
link |
39:47.720
不要把它的hidden layer接進來
link |
39:50.280
你把你的language model跑到最後
link |
39:52.520
那通常不過softmax
link |
39:53.960
你跑到最後softmax之前
link |
39:56.040
得到一個它的這個dimension
link |
39:58.440
跟你的token的size一樣大的向量
link |
40:02.040
把這個跟token size一樣大的向量
link |
40:05.000
丟到你的network裡面去
link |
40:08.040
那這麼做有什麼好處呢
link |
40:11.640
這麼做好處就是
link |
40:13.000
你其實可以任意更換language model
link |
40:16.200
而不見得需要重train灰色的這個block
link |
40:20.200
為什麼呢
link |
40:21.400
因為這個灰色的block可能就是學到說
link |
40:25.320
今天看到這邊有什麼樣的token
link |
40:28.200
它要怎麼跟這個hidden layer把它整合起來
link |
40:31.160
你今天就算是換了language model
link |
40:33.800
它還是output一個token的distribution
link |
40:37.000
對一個language model來說
link |
40:38.920
在這一個vector裡面
link |
40:40.840
在這個vocabulary size的這個vector裡面
link |
40:43.880
每一個dimension的意義都是一樣的
link |
40:46.520
對不同的language model來說
link |
40:48.520
你的hidden layer的每一個dimension
link |
40:50.760
你train了兩個不同的language model
link |
40:53.000
它的同一個hidden layer
link |
40:54.760
它的同一個hidden layer的同一個dimension
link |
40:57.000
它的意義不會一樣
link |
40:58.200
它代表意思不會一樣
link |
40:59.800
但是如果你最終把它跑到
link |
41:02.360
token的這個層級
link |
41:03.960
同一個token
link |
41:05.000
對應到的就是同樣的東西
link |
41:07.000
就算是不同的language model
link |
41:08.600
output同樣的token的時候
link |
41:09.880
可能就是同代表同樣的
link |
41:11.800
代表同樣的意思代表同樣的東西
link |
41:14.040
所以你就可以任意的替換你的language model
link |
41:16.680
而不見得需要重train灰色的這個block
link |
41:20.440
好那這個是deep fusion
link |
41:22.600
那這麼做其實還有一個好處
link |
41:24.360
這麼做當然有個壞處就是
link |
41:26.040
假設你的vocabulary size很大
link |
41:28.040
你的token是以word為當作單位
link |
41:30.440
那你就不太好這麼做
link |
41:32.280
因為這個向量的維度太高了
link |
41:34.200
但如果你這邊不是
link |
41:35.880
用word當作token
link |
41:37.480
是用比較小的單位當作token
link |
41:39.320
也許你就可以真的考慮使用這樣子的方式
link |
41:42.280
那這樣還有一個好處是
link |
41:44.440
如果你今天是要把hidden layer
link |
41:46.760
接到這個network裡面來
link |
41:48.360
那你的language model
link |
41:49.480
一定得是NN-based的才行
link |
41:52.200
但是如果你今天是把一個
link |
41:55.400
這個對每一個token給它一個機率
link |
41:58.360
這樣子的向量丟進來
link |
42:00.600
那NN-based的language model
link |
42:03.160
傳統的NN-based的language model
link |
42:05.240
也有辦法產生一個這樣子的向量
link |
42:08.040
它也有辦法給每一個token一個機率
link |
42:10.360
你也可以把傳統NN-based的language model
link |
42:13.480
輸出接到這個network裡面來
link |
42:16.760
好那這個是deep fusion
link |
42:20.760
那接下來呢我們講code fusion
link |
42:23.560
code fusion相較於前面那兩個方法
link |
42:26.520
它不同的地方是
link |
42:27.880
我們什麼時候把language model加進來
link |
42:32.600
對code fusion而言
link |
42:34.120
它的狀況是
link |
42:35.400
我們先有一個已經訓練好的language model
link |
42:39.880
然後呢我們有一個LAS的model
link |
42:43.160
但是它是還沒有訓練的
link |
42:45.080
它的參數還是random initialized
link |
42:47.560
我們先把這兩個model接在一起
link |
42:50.520
然後在end to end去把這個部分訓練出來
link |
42:56.040
這樣做有什麼好處呢
link |
42:57.880
這樣可以加快你的LAS的訓練速度
link |
43:01.000
那LAS的訓練其實是還蠻耗費資源的
link |
43:04.840
在作業裡面呢
link |
43:06.200
我們就沒有讓大家做一個真正的語音辨識系統
link |
43:09.160
我們做出來的語音辨識系統只有一個speaker
link |
43:12.360
然後輸出只是對應符號
link |
43:14.440
為什麼這樣做呢
link |
43:15.560
那是因為助教試了很久很久以後
link |
43:17.640
我就我要求說我們這個作業
link |
43:20.120
要用這個colab在一個半小時內做出來
link |
43:25.000
所以助教調了很久很久以後
link |
43:27.000
終於產生一個閹割的版本
link |
43:28.840
讓大家作業一可以做得比較順利一點
link |
43:31.560
好 那個如果是用confusion的話
link |
43:33.720
它的好處是說
link |
43:35.080
因為你已經有一個language model了
link |
43:37.480
所以你的LAS就不需要去學
link |
43:40.680
language model就可以解的問題
link |
43:43.320
它只需要專注在聲音和文字之間的關係就好
link |
43:47.320
文字跟文字之間的關係
link |
43:48.760
反正language model已經train好了
link |
43:50.760
LAS就不要去學這件事
link |
43:53.560
那你可以讓你的訓練比較快一點
link |
43:56.600
那它的壞處就是
link |
43:57.880
這次你真的就不能夠隨便換language model了
link |
44:00.600
這邊如果一換language model
link |
44:02.360
那這個LAS它就孤掌難鳴
link |
44:04.920
這個LAS它在訓練的時候
link |
44:06.920
它是跟某一個language model
link |
44:09.720
couple在一起的
link |
44:10.920
他們是好兄弟
link |
44:12.280
他們是夥伴
link |
44:13.160
訓練的時候LAS一出生的時候
link |
44:15.480
這個language model就在了
link |
44:17.160
他們兩個是黏在一起的
link |
44:18.760
如果把這個language model拔掉
link |
44:20.200
換了一個language model
link |
44:21.160
這個LAS它本身很爛的
link |
44:22.840
它可能整個就會慘掉
link |
44:24.840
所以如果是用co-fusion
link |
44:26.360
你真的就不能夠隨便換language model了
link |
44:29.000
好 那有同學問說
link |
44:30.920
這個co-fusion跟前頁的deep fusion有什麼不同
link |
44:35.320
那這個這一頁的co-fusion的圖
link |
44:38.360
不就是從前頁的deep fusion直接copy過來的嗎
link |
44:41.720
對哦
link |
44:42.840
那co-fusion跟deep fusion有什麼不同呢
link |
44:45.640
它們不同的地方是說
link |
44:47.320
在做co-fusion的時候
link |
44:48.920
language model已經train了
link |
44:51.240
我們才train LAS
link |
44:52.920
但是在deep fusion的時候
link |
44:54.760
你的language model跟LAS都已經train好了
link |
44:58.680
然後才接在一起
link |
45:00.520
好 那以上呢
link |
45:01.960
就是常見的三種language model加LAS的方式
link |
45:05.800
shallow fusion
link |
45:06.760
deep fusion
link |
45:07.640
跟co-fusion
link |
45:09.160
好 那我們就看看大家有沒有什麼問題
link |
45:11.400
然後我們就下課休息一下