back to index

【機器學習2021】卷積神經網路 (Convolutional Neural Networks, CNN)


link |
00:00.000
我們要來講Network的架構,我們開始探討Network的架構設計。
link |
00:08.000
那我第一個要跟大家講的Network架構的變形呢,是Convolutional的Neural Network,它的縮寫呢就是CNN。
link |
00:17.000
那這個CNN呢,它是專門被用在影像上的。
link |
00:23.000
那我希望透過CNN這個例子,來讓你知道說Network的架構,它的設計有什麼樣的想法。
link |
00:31.000
那為什麼設計Network的架構可以讓我們的Network結果做得更好。
link |
00:39.000
好,那我們接下來呢,要講的例子是跟影像有關的。
link |
00:44.000
我們今天就想像說,我們要做影像的分類。
link |
00:48.000
也就是給機器一張圖片,它要去決定說這張圖片裡面有什麼樣的東西。
link |
00:55.000
那怎麼做呢?我們已經跟大家講過怎麼做分類這件事情。
link |
01:00.000
在以下的討論裡面,我們都假設我們的模型輸入的圖片大小是固定的。
link |
01:08.000
舉例來說,它固定輸入的圖片大小都是100x100的解析度。
link |
01:15.000
我們假設說不會突然出現大小不一的照片。
link |
01:19.000
其實今天一般在做影像辨識的時候,往往都有這樣子的假設。
link |
01:24.000
就算是今天這個Deep Learning已經這麼的popular,我們往往都還是需要假設說一個模型輸入的影像大小都是一樣的。
link |
01:34.000
那你說圖片可能有大有小啊,而且不是所有圖片都是正方形,當然有長方形的怎麼辦。
link |
01:39.000
今天常見的處理方式,丟進影像辨識系統的處理方式就是把所有圖片都先rescale成大小一樣,再丟到影像的辨識系統裡面。
link |
01:50.000
那我們的模型的輸出應該是什麼呢?我們模型的目標是分類。
link |
01:57.000
所以我們會把每一個類別表示成一個one-hot的vector,我們的目標就叫做white hat。
link |
02:05.000
那在這個one-hot的vector裡面,假設我們現在的類別是一個貓的話,貓所對應的dimension數值就是1,其他的東西所對應的dimension數值就是0。
link |
02:17.000
那這個dimension的長度就決定了你現在的模型可以辨識出多少不同種類的東西。
link |
02:26.000
如果你這個像量的長度是2000,就代表說你這個模型可以辨識出2000種不同的東西。
link |
02:34.000
那今天比較強的影像辨識系統往往可以辨識出1000種以上的東西,甚至到上萬種不同的object。
link |
02:43.000
那如果你今天希望你的影像辨識系統可以辨識上萬種object,那你的label就會是一個上萬維,維度是上萬的one-hot vector。
link |
02:54.000
那我們的模型的輸出,通過softmax以後,輸出是Wi-Fi,然後我們就會希望Wi-Fi跟white hat,他們的cross entropy越小越好。
link |
03:05.000
那有關這個cross entropy的部分,我們已經跟大家講過了,所以相信這個地方大家不是問題。
link |
03:11.000
接下來的問題是,怎麼把一張影像當作一個模型的輸入呢?
link |
03:17.000
那我們先來看一下對電腦來說,一張影像是什麼樣的東西。
link |
03:24.000
那其實對一個machine來說,一張圖片其實是一個三維的tensor。
link |
03:31.000
那什麼叫做tensor呢?如果不知道tensor是什麼的話,你就想成它是維度大於二的矩陣,就是tensor。
link |
03:39.000
矩陣是二維的嘛,那二維以上的、超過二維的矩陣,你就叫它tensor。
link |
03:46.000
一張圖片,它是一個三維的tensor。那三維呢,其中一維代表圖片的寬,另外一維代表圖片的高,還有一維代表圖片的channel的數目。
link |
04:01.000
這個所謂的channel是什麼意思呢?一張彩色的圖片,今天它每一個pixel都是由RGB三個顏色所組成的。
link |
04:12.000
所以這三個channel就代表了RGB三個顏色。那長跟寬就代表了今天這張圖片的解析度,代表這張圖片裡面有的pixel,有的像素的數目。
link |
04:26.000
那接下來我們就要把這一個三維的tensor把它拉直,把它拉直以後就可以丟到一個network裡面去了。
link |
04:38.000
記得嗎?到目前為止我們所講的network,它的輸入其實都是一個向量。
link |
04:43.000
所以我們只要能夠把一張圖片變成一個向量,我們就可以把它當作是network的輸入。
link |
04:49.000
但是怎麼把這個三維的tensor變成一個向量呢?最直覺的方法就是直接拉直它。
link |
04:56.000
一個三維的tensor裡面有幾個數字呢?在這個例子裡面有100x100x3個數字。
link |
05:03.000
所以一張圖片是由100x100x3個數字所組成的,把這些數字通通拿出來排成一排就是一個巨大的向量,這個向量可以作為network的輸入。
link |
05:15.000
而這個向量裡面,每一維它裡面存的數值其實就是某一個pixel,某一個顏色的強度。
link |
05:26.000
每一個pixel有RGB三個顏色所組成,每個顏色都有一個數值代表說這個顏色的強度。
link |
05:33.000
在這個向量裡面,每一維它的數值就代表了某一個位置的某一個顏色的強度。
link |
05:40.000
這個向量我們可以把它當作是一個network的輸入。
link |
05:45.000
我們到目前為止只講過了fully connected的network。
link |
05:50.000
如果我們把這個向量當作network的輸入,那我們input這邊這個feature vector它的長度就是100x100x3,非常長的一個vector。
link |
06:00.000
假設我們現在第一層的neuron的數目有1000個,那你能計算一下這邊第一層總共有多少個weight嗎?
link |
06:12.000
我們每一個neuron它跟輸入的向量的每一個數值都會有一個weight。
link |
06:19.000
所以如果輸入的向量的長度是100x100x3有1000個neuron,那我們現在第一層的weight就有1000x100x100x3也就是3x10的7次方,是一個非常巨大的數目。
link |
06:33.000
如果參數越多會有什麼樣的問題呢?
link |
06:37.000
當然隨著參數的增加,我們可以增加模型的彈性,我們可以增加它的能力,但是我們也增加了overfitting的風險。
link |
06:49.000
有關什麼叫模型的彈性,到底overfitting怎麼產生的,下週吳慧媛老師會從數學上給大家非常清楚的證明。
link |
06:57.000
我們這邊就講概念上,如果模型的彈性越大就越容易overfitting,那我們怎麼減少在做影像辨識的時候,怎麼避免使用這麼多的參數呢?
link |
07:10.000
考慮到影像辨識這個問題本身的特性,其實我們並不一定需要fully connected這件事。
link |
07:19.000
考慮影像本身的特性,我們其實不需要每一個neuron跟input的每一個dimension都有一個weight。
link |
07:27.000
怎麼說呢?接下來就是對影像辨識這個問題,對影像本身的特性的一些觀察。
link |
07:35.000
第一個觀察是對影像辨識這個問題而言,假設我們想要知道說這張圖片裡面有一隻動物,這個動物是一個鳥,要怎麼做呢?
link |
07:48.000
也許對一個影像辨識的系統而言,對一個影像辨識的neuron,對一個影像辨識的內神經網路裡面的神經元而言,
link |
07:58.000
它要做的就是偵測說現在這張圖片裡面有沒有出現一些特別重要的pattern,而這些pattern是代表了某種物件。
link |
08:10.000
舉例來說,如果現在有某一個neuron說它看到鳥嘴這個pattern,有某一個neuron又說它看到眼睛這個pattern,
link |
08:19.000
又有某一個neuron說它看到鳥爪這個pattern,也許看到這些pattern綜合起來就代表說我們看到了一隻鳥。
link |
08:28.000
內神經網路就可以告訴你說,因為看到這些pattern,所以它看到了一隻鳥。
link |
08:34.000
也許你會覺得說看pattern然後決定它是什麼,這件事情好像沒有很聰明。
link |
08:40.000
那你仔細想想,人是不是也是用同樣的方法來看一張圖片中有沒有一隻鳥呢?
link |
08:46.000
舉例來說,這一個例子。
link |
08:49.000
你有沒有看到這裡面有什麼樣的動物?
link |
08:52.000
你看這邊有一個鳥嘴,這邊有一個眼睛,看起來它是一個烏鴉,但是它其實是一隻貓。
link |
08:59.000
如果你看到它是一隻鳥的話,那你就應該放下酒杯了,因為這是一隻貓。
link |
09:05.000
所以其實就算是人,我們在判斷一個物件的時候,往往也是抓最重要的特徵,
link |
09:11.000
然後看到這些特徵以後,你很直覺地就會覺得說你看到了某種物件。
link |
09:17.000
對機器來說,也許這也是一個有效的判斷影像中有什麼物件的方法。
link |
09:23.000
但是假設我們現在要neuron做的事情,其實就是判斷說現在有沒有某種pattern出現,
link |
09:30.000
那也許我們並不需要每一個neuron都去看一張完整的圖片。
link |
09:37.000
因為這些重要的pattern,比如說鳥嘴、眼睛、鳥爪,並不需要看整張完整的圖片才能夠得到這些資訊。
link |
09:47.000
只要知道說這邊有沒有一個鳥嘴,你其實只要看非常小的範圍就知道了,並不需要看整張圖片。
link |
09:55.000
所以這些neuron也許根本就不需要把整張圖片當作輸入,
link |
10:00.000
他們只需要把圖片的一小部分當作輸入,就足以讓他們偵測某些特別關鍵的pattern有沒有出現了。
link |
10:08.000
這是第一個觀察。
link |
10:10.000
根據這個觀察,我們就可以做第一個簡化。
link |
10:15.000
怎麼簡化呢?本來我們每一個neuron,他要看完整的圖片。
link |
10:20.000
把圖片裡面的每一個pixel,每一個pixel都還有三個數字,
link |
10:24.000
把一張圖片裡面所有的資訊都丟給一個neuron,然後讓他產生好分。
link |
10:29.000
這是fully connected network做的事情。
link |
10:32.000
但是現在我們已經觀察到說,也許不需要讓一個neuron看完整的圖片,
link |
10:37.000
只要讓他看圖片的一小部分就足夠了。
link |
10:41.000
那怎麼透過這個觀察來設計我們的neuron network呢?
link |
10:46.000
在CNN裡面有一個這樣的做法,我們會設定一個區域叫做receptive field。
link |
10:54.000
每一個neuron都只關心自己的receptive field裡面發生的事情就好了。
link |
11:01.000
舉例來說,你會先定義說這個藍色的neuron,他的守備範圍就是這個receptive field。
link |
11:09.000
這個receptive field裡面有3乘以3乘以3的數值。
link |
11:15.000
這個小的立方體裡面有3乘以3乘以3的數值。
link |
11:19.000
對這個藍色的neuron來說,他只需要關心這一個小範圍就好了,
link |
11:24.000
不需要在意整張圖片裡面有什麼東西,只在意他自己的receptive field裡面發生的事情就好。
link |
11:31.000
那這個neuron怎麼考慮這個receptive field裡面有發生什麼樣的事情呢?
link |
11:36.000
他要做的事情就是把這3乘以3乘以3的數值拉直,變成一個長度是3乘以3乘以3,
link |
11:44.000
也就是27維的向量,再把這27維的向量作為這個neuron的輸入,
link |
11:49.000
這個neuron會給27維的向量的每一個dimension一個weight,
link |
11:54.000
所以這個neuron有3乘以3乘以3,27個weight,再加上bias得到一個輸出,
link |
11:58.000
這個輸出再送給下一層的neuron當作輸入。
link |
12:03.000
所以每一個neuron他只考慮自己的receptive field。
link |
12:08.000
那這個receptive field要怎麼決定出來呢?
link |
12:13.000
那這個就要問你自己了。
link |
12:15.000
你可以說這邊有個藍色的neuron,他就看左上角這個範圍,這是他的receptive field。
link |
12:21.000
另外又有另外一個黃色的neuron,他是看右下角這個3乘以3乘以3的範圍,
link |
12:26.000
這個立體的部分我們就畫不出來了,我們這邊畫一個正方形代表3乘以3乘以3的範圍,
link |
12:32.000
這個是黃色這個neuron的receptive field。
link |
12:36.000
那receptive field彼此之間也可以是重疊的,
link |
12:40.000
比如說我現在畫一個receptive field在這個地方,
link |
12:44.000
他是綠色的neuron的守備範圍,
link |
12:46.000
他跟藍色的跟黃色的都有一些重疊的空間,這樣也是可以的。
link |
12:52.000
所以receptive field彼此之間是可以重疊的,
link |
12:56.000
你可以說兩個人的守備範圍彼此是有重疊的,
link |
12:59.000
那你甚至可以兩個不同的neuron他們守備同樣的範圍,
link |
13:03.000
也許一個範圍只用一個neuron來守備,你沒有辦法偵測所有的pattern,
link |
13:08.000
所以同一個範圍可以有多個不同的neuron,
link |
13:11.000
所以同一個receptive field他們可以有多個neuron,
link |
13:17.000
他們可以去守備同一個receptive field。
link |
13:21.000
那接下來你就會浮想連篇,有各式各樣的想法,
link |
13:24.000
舉例來說,那我可不可以receptive field有大有小呢?
link |
13:29.000
因為畢竟pattern有的比較小有的比較大嘛,
link |
13:32.000
有的pattern也許在3x3的範圍內就可以被偵測出來,
link |
13:35.000
有的pattern也許要11x11的範圍才能被偵測出來,
link |
13:39.000
那我可不可以receptive field有大有小呢?
link |
13:42.000
這個算是常見的招式了,
link |
13:44.000
我可不可以receptive field只考慮某些channel呢?
link |
13:49.000
我們這邊看起來我們的receptive field是RGB三個channel都考慮,
link |
13:54.000
但也許有些pattern只在紅色的channel會出現,
link |
13:58.000
也許有些pattern只在藍色的channel會出現,
link |
14:01.000
我可不可以有的neuron只考慮一個channel呢?
link |
14:05.000
可以,其實之後在講到network compression的時候,
link |
14:09.000
會講到這種network的架構。
link |
14:11.000
在一般CNN裡面你不常這樣子考慮,
link |
14:14.000
但是有這樣子的做法。
link |
14:16.000
有人會問說,這邊的receptive field通通都是正方形的,
link |
14:21.000
你剛才舉的例子裡面3x3 11x11也都是正方形的,
link |
14:25.000
可不可以是長方形的呢?
link |
14:27.000
可以,可以是長方形的,
link |
14:29.000
這完全都是你自己設計的,
link |
14:31.000
receptive field是你自己定義的,
link |
14:33.000
你完全可以根據你對這個問題的理解,
link |
14:36.000
決定你覺得receptive field應該要長什麼樣子。
link |
14:40.000
當然這邊還可以有各式各樣怪怪的想法,
link |
14:43.000
你可能會說receptive field的範圍一定要相連嗎?
link |
14:50.000
我們可不可以說有一個neuron,
link |
14:53.000
它的receptive field就是影像的左上角跟右上角?
link |
14:56.000
理論上可以,但是你就要想想看為什麼你要這麼做嗎?
link |
15:00.000
會不會有什麼pattern是
link |
15:02.000
你要看一個圖片的左上角跟右下角才能夠找到的?
link |
15:06.000
也許沒有,如果沒有的話,這種receptive field就沒什麼用。
link |
15:09.000
我們之所以receptive field都是一個相連的領地,
link |
15:13.000
就是因為我們覺得要偵測一個pattern,
link |
15:15.000
那這個pattern它就出現在整個圖片裡面的某一個位置,
link |
15:18.000
而不是分成好幾部分出現在圖片裡面的不同的位置。
link |
15:22.000
所以receptive field通常見到的都是相連的領地。
link |
15:26.000
但如果你說你要設計很奇怪的receptive field
link |
15:29.000
去解決很特別的問題,那完全是可以的,
link |
15:32.000
這都是你自己決定的。
link |
15:35.000
雖然receptive field你可以任意設計,
link |
15:38.000
但這邊要跟大家講一下最經典的receptive field的安排方式。
link |
15:45.000
那最經典的安排方式是什麼呢?
link |
15:47.000
第一個就是會看所有的channel,
link |
15:51.000
一般在做影像辨識的時候,
link |
15:53.000
你可能不會覺得有些pattern只出現在某一個channel裡面,
link |
15:57.000
所以會看全部的channel。
link |
16:00.000
所以既然會看全部的channel,
link |
16:02.000
我們在描述一個receptive field的時候,
link |
16:05.000
只要講它的高跟寬就好了,
link |
16:08.000
就不用講它的深度,反正深度一定是考慮全部的channel。
link |
16:11.000
而這個高跟寬合起來叫做kernel size,
link |
16:16.000
舉例來說在這個例子裡面,
link |
16:18.000
我們的kernel size就是3x3,
link |
16:21.000
那一般我們這個kernel size其實不會設太大,
link |
16:25.000
你在影像辨識裡面往往做個3x3的kernel size就足夠了,
link |
16:30.000
如果你說設個7x7、9x9,那這算是蠻大的kernel size,
link |
16:36.000
一般往往都做3x3。
link |
16:38.000
那講到這邊你就會問說,
link |
16:40.000
那如果kernel size都是3x3,
link |
16:42.000
意味著說我們覺得在做影像辨識的時候,
link |
16:45.000
重要的pattern都只在3x3這麼小的範圍內就可以被偵測出來囉,
link |
16:50.000
聽起來好像怪怪的,
link |
16:51.000
有些pattern也許很大啊,也許3x3的範圍沒辦法偵測出來啊,
link |
16:55.000
等一下我們會再回答這個問題。
link |
16:58.000
那我現在先告訴你說,
link |
17:00.000
常見的resetting field設定方式就是kernel size是3x3,
link |
17:05.000
然後一般同一個resetting field會有一組neuron去守備這個範圍,
link |
17:14.000
所以你畫一個resetting field以後,
link |
17:16.000
不會只有一個neuron去關照它,不會只有一個neuron去守備它,
link |
17:19.000
往往會有一組、一排neuron去守備它,
link |
17:22.000
比如說64個或者是128個neuron去守備一個resetting field的範圍。
link |
17:28.000
到目前為止我們講的都是一個resetting field,
link |
17:32.000
那各個不同resetting field之間的關係是怎麼樣呢?
link |
17:36.000
你會把你在最左上角的這個resetting field往右移一點,
link |
17:42.000
然後就製造一個新的守備範圍,製造另外一個resetting field。
link |
17:48.000
那這個移動的範圍、移動的量叫做stride,
link |
17:53.000
像在這個例子裡面stride就等於2,
link |
17:57.000
那stride是一個你自己決定的參數、決定的hyperparameter你要自己調的,
link |
18:03.000
那這個stride你往往不會設太大,往往設1或2就可以了,
link |
18:07.000
因為你希望這些resetting field跟resetting field之間是有重疊的。
link |
18:13.000
為什麼我們希望resetting field之間是有重疊的呢?
link |
18:16.000
因為假設resetting field完全沒有重疊,
link |
18:19.000
那有一個pattern就正好出現在兩個resetting field的交界上面,
link |
18:23.000
那就會變成沒有任何neuron去偵測它,
link |
18:26.000
那你可能就會miss掉這個pattern。
link |
18:28.000
所以我們會希望resetting field彼此之間有高度的重疊。
link |
18:33.000
那假設我們設stride等於2,那第一個resetting field就在這邊,
link |
18:37.000
那第二個就在這邊,那第三個就再往右移兩格,
link |
18:42.000
再往右移兩格就放在這邊。
link |
18:44.000
那這邊就遇到一個問題了,它超出了影像的範圍,怎麼辦呢?
link |
18:51.000
那有人可能會說那就不要在這邊擺resetting field,
link |
18:54.000
那你這樣就漏掉了影像的邊邊的地方啊,
link |
18:57.000
有一個pattern出現在邊邊的地方,
link |
18:59.000
你就沒有neuron去觀照那些pattern啦,
link |
19:01.000
沒有neuron去偵測出現在邊邊的pattern啦。
link |
19:04.000
所以一般邊邊的地方也會考慮的,
link |
19:07.000
但超出範圍了怎麼辦呢?
link |
19:09.000
超出範圍你就做padding。
link |
19:12.000
什麼叫padding? Padding就是補0。
link |
19:15.000
所以如果你今天resetting field有一部分超出影像的範圍之外了,
link |
19:19.000
那就當作那個裡面的值都是0。
link |
19:22.000
其實也有別的補值的方法啦,padding就是補值的意思,
link |
19:26.000
有別的補值的方法,比如說有人會說我這邊不要補0好不好,
link |
19:29.000
我補整張圖片裡面所有value的平均。
link |
19:33.000
可以,或者你說我把邊邊的這些數字拿出來補,
link |
19:37.000
在這個沒有值的地方可不可以?
link |
19:39.000
可以,有各種不同的padding的方法。
link |
19:43.000
好,那你除了這個橫著移動,
link |
19:46.000
你也會這個直著移動,
link |
19:48.000
你也會有這個垂直方向上的移動。
link |
19:51.000
那在這邊呢,我們一樣垂直方向的stride也是設2,
link |
19:55.000
所以你有一個resetting field在這邊,
link |
19:57.000
垂直方向移動兩個,就有一個resetting field在這個地方。
link |
20:01.000
你就會按照這個方式掃過整張圖片。
link |
20:05.000
所以整張圖片裡面每一寸土地
link |
20:09.000
都是有被某一個resetting field覆蓋的,
link |
20:13.000
也就是圖片裡面每一個位置都有一群neuron
link |
20:17.000
在偵測那個地方有沒有出現某些padding。
link |
20:21.000
好,那這個是第一個簡化Fully Connected Network的方式。
link |
20:27.000
那第二個觀察是什麼呢?
link |
20:30.000
第二個觀察就是同樣的padding,
link |
20:33.000
它可能會出現在圖片的不同區域裡面。
link |
20:37.000
比如說鳥嘴這個padding,
link |
20:39.000
它可能出現在圖片的左上角,
link |
20:41.000
也可能出現在圖片的中間。
link |
20:43.000
雖然它們的形狀都是一樣的,都是鳥嘴,
link |
20:45.000
但是它們可能出現在圖片裡面的不同的位置。
link |
20:49.000
按照我們剛才的討論,
link |
20:51.000
同樣的padding出現在圖片的不同的位置
link |
20:54.000
似乎也不是太大的問題,
link |
20:56.000
因為出現在左上角的鳥嘴,
link |
20:59.000
它一定落在某一個resetting field裡面,
link |
21:02.000
resetting field是蓋滿整個圖片的,
link |
21:04.000
所以圖片裡面沒有任何地方
link |
21:06.000
不是在某個neuron的守備範圍內。
link |
21:09.000
所以這個地方一定是某一個neuron的resetting field,
link |
21:13.000
那假設在那個resetting field裡面有一個neuron,
link |
21:16.000
它的工作就是偵測鳥嘴的話,
link |
21:18.000
那鳥嘴就會被偵測出來。
link |
21:20.000
所以就算鳥嘴出現在中間也沒有關係,
link |
21:23.000
假設這邊一定是在某一個resetting field的範圍裡面,
link |
21:26.000
那個resetting field一定有一組neuron在照顧,
link |
21:29.000
那假設其中有一個neuron它可以偵測鳥嘴的話,
link |
21:32.000
那鳥嘴出現在圖片的中間也會被偵測出來。
link |
21:36.000
那這邊的問題是,
link |
21:38.000
這些偵測鳥嘴的neuron,
link |
21:41.000
它們做的事情其實是一樣的,
link |
21:44.000
只是它們守備的範圍是不一樣的。
link |
21:49.000
那既然它們做的事情是一樣的,
link |
21:51.000
守備範圍是不一樣的,
link |
21:53.000
我們真的需要每一個守備範圍
link |
21:56.000
都去放一個偵測鳥嘴的neuron嗎?
link |
21:59.000
它們做的事情根本就是重複的啊,
link |
22:01.000
只是它們的守備範圍不一樣啊。
link |
22:03.000
如果不同的守備範圍都要有一個偵測鳥嘴的neuron,
link |
22:06.000
那你的參數量不會太多了嗎?
link |
22:09.000
這個概念就好像是,
link |
22:11.000
為什麼教務處希望可以推大型的課程一樣。
link |
22:15.000
假設說每一個科系其實都需要程式相關的課程,
link |
22:19.000
或每一個科系都需要機器學習相關的課程,
link |
22:22.000
那到底需不需要在每一個系所
link |
22:26.000
都開機器學習的課程,
link |
22:27.000
還是說開一個比較大班的課程,
link |
22:29.000
讓所有系所的人都可以修課。
link |
22:31.000
這個就是教務處推動大型課程的想法。
link |
22:36.000
那如果放在影像處理上的話是怎麼樣呢?
link |
22:41.000
如果放在影像處理上的話,
link |
22:44.000
我們能不能夠讓不同receptive field的neuron,
link |
22:49.000
他們共享參數,也就是做parameter sharing,
link |
22:54.000
就是共享參數。
link |
22:56.000
那共享參數是什麼意思呢?
link |
22:59.000
這邊舉得更具體一點。
link |
23:01.000
所謂共享參數就是,
link |
23:03.000
這兩個neuron,他們的weight完全是一樣的。
link |
23:08.000
這邊特別用顏色來告訴你說,
link |
23:11.000
他們的weight完全是一樣的。
link |
23:14.000
上面這個neuron的第一個weight叫做W1,
link |
23:17.000
下面這個neuron的第一個weight也是W1,
link |
23:20.000
他們是同一個weight,我們都用黃色來表示。
link |
23:23.000
上面這個neuron的第二個weight是W2,
link |
23:25.000
下面這個neuron的第二個weight也是W2,
link |
23:27.000
他們都用黃色來表示。
link |
23:30.000
上面這個neuron跟下面這個neuron,
link |
23:33.000
他們首輩的receptive field是不一樣的,
link |
23:36.000
但是他們的參數是一模一樣的。
link |
23:41.000
那有人可能就會問說,
link |
23:43.000
他的參數是一模一樣,
link |
23:45.000
他會不會輸出永遠都是一樣的?
link |
23:48.000
不會,為什麼?
link |
23:49.000
因為他們的輸入是不一樣的。
link |
23:51.000
這兩個neuron的參數一模一樣,
link |
23:53.000
但是他們照顧的範圍是不一樣的。
link |
23:55.000
所以上面這個neuron,我們說他的輸入是X1、X2,
link |
23:58.000
下面這個neuron,我們說他的輸入是X1'、X2'。
link |
24:02.000
那他們的輸出是什麼呢?
link |
24:03.000
上面這個neuron的輸出就是X1W1加X2W2,
link |
24:07.000
全部加加加,再加bias,
link |
24:09.000
然後透過activation function得到輸出。
link |
24:12.000
下面這個neuron雖然也有W1、W2,
link |
24:15.000
但W1跟W2是乘以X1'、X2',
link |
24:20.000
所以他的輸出不會跟上面這個neuron一樣。
link |
24:23.000
因為輸入不一樣的關係,
link |
24:25.000
所以就算是兩個neuron共用參數,
link |
24:27.000
他們的輸出也不會是一樣的。
link |
24:30.000
那你可以想見說,
link |
24:32.000
你不會讓兩個首輩一模一樣
link |
24:35.000
receptive field的neuron共用參數,
link |
24:38.000
如果今天兩個首輩一樣的區域的neuron共用參數的話,
link |
24:43.000
他們的輸出就一定都固定會是一樣的。
link |
24:46.000
那如果兩個neuron首輩的範圍不一樣,
link |
24:48.000
就算他們的參數一樣,
link |
24:49.000
他們的輸出也不會是一樣的。
link |
24:52.000
所以這是第二個簡化,
link |
24:56.000
我們讓一些neuron可以共用參數。
link |
24:59.000
那至於要怎麼共用,
link |
25:01.000
你完全可以自己決定,
link |
25:02.000
這個是你可以自己決定的事情。
link |
25:04.000
但是接下來還是要告訴大家常見的
link |
25:08.000
在影像辨識上面的共享方法是怎麼設定的。
link |
25:12.000
那我們剛才已經講說,
link |
25:14.000
每一個receptive field
link |
25:16.000
他都有一組neuron在負責首輩,
link |
25:19.000
比如說64個neuron。
link |
25:21.000
所以這個receptive field有64個neuron,
link |
25:24.000
這個receptive field也有64個neuron。
link |
25:28.000
那他們彼此之間會怎麼共用參數呢?
link |
25:32.000
我們這邊有一樣的顏色就代表說
link |
25:34.000
這兩個neuron共享一樣的參數。
link |
25:36.000
所以其實每一個receptive field
link |
25:39.000
都只有一組參數而已。
link |
25:41.000
就是這個receptive field的第一個neuron
link |
25:43.000
會跟這個receptive field的第一個neuron
link |
25:45.000
共用參數。
link |
25:46.000
他的第二個neuron跟他的第二個neuron
link |
25:48.000
共用參數。
link |
25:49.000
他的第三個neuron跟他的第三個neuron
link |
25:51.000
共用參數。
link |
25:52.000
所以每一個receptive field
link |
25:55.000
都只有一組參數而已。
link |
25:57.000
那這些參數有一個名字叫做filter。
link |
26:01.000
所以這兩個neuron
link |
26:03.000
他們共用同一組參數,
link |
26:04.000
這組參數就叫filter1。
link |
26:06.000
這兩個neuron他們共用同一組參數,
link |
26:08.000
這組參數就叫filter2,
link |
26:10.000
叫filter3,叫filter4,
link |
26:12.000
以此類推。
link |
26:14.000
這是第二個簡化的方法。
link |
26:18.000
我們目前已經講了兩個簡化的方法,
link |
26:21.000
那我們來整理一下我們學到了什麼。
link |
26:24.000
這是fully connected的network,
link |
26:26.000
它是彈性最大。
link |
26:29.000
我們說因為不需要看整張圖片,
link |
26:32.000
也許只要看圖片的一小部分
link |
26:34.000
就可以偵測出重要的pattern,
link |
26:36.000
所以我們有了receptive field的概念。
link |
26:39.000
當我們強制一個neuron
link |
26:41.000
只能看一張圖片裡面的一個範圍的時候,
link |
26:44.000
它的彈性是變小的。
link |
26:46.000
如果是fully connected的network,
link |
26:48.000
它可以決定它要看整張圖片
link |
26:50.000
還是只看一個範圍。
link |
26:52.000
如果它只想只看一個範圍,
link |
26:53.000
就把很多weight設成0,
link |
26:55.000
就只看一個範圍。
link |
26:56.000
所以fully connected layer
link |
26:57.000
它自己決定它要看整張圖片
link |
26:59.000
還是一個小範圍。
link |
27:01.000
但加上receptive field的概念以後,
link |
27:04.000
意思就是說沒得選了,
link |
27:05.000
就只能夠看一個小範圍,
link |
27:07.000
反正我們覺得看一個小範圍就夠了,
link |
27:09.000
所以只能看一個小範圍。
link |
27:11.000
所以加receptive field以後,
link |
27:13.000
你的network的彈性是變小的。
link |
27:16.000
好,那接下來呢?
link |
27:18.000
接下來我們還有參數共享這件事。
link |
27:20.000
參數共享這件事又更進一步
link |
27:23.000
限制了network的彈性。
link |
27:25.000
本來在learning的時候,
link |
27:26.000
它可以決定說
link |
27:28.000
這兩個network的參數要是什麼。
link |
27:30.000
每一個neuron
link |
27:31.000
可以各自有不同的參數,
link |
27:32.000
它們可以正好
link |
27:33.000
學出一模一樣的參數,
link |
27:35.000
也可以有不一樣的參數。
link |
27:36.000
但是加入參數共享以後
link |
27:38.000
就意味著說某一些neuron
link |
27:40.000
無論如何參數
link |
27:41.000
就是要一模一樣的,
link |
27:42.000
也沒得選了,
link |
27:43.000
參數要一模一樣,
link |
27:44.000
所以這又更增加了
link |
27:46.000
對neuron的限制。
link |
27:48.000
而receptive field
link |
27:49.000
加上parameter sharing
link |
27:51.000
就是convolutional layer,
link |
27:54.000
就是大家常常聽到的
link |
27:56.000
convolutional layer。
link |
27:58.000
那有用convolutional layer的network
link |
28:01.000
就叫convolutional neural network,
link |
28:03.000
就是CNN。
link |
28:05.000
所以從這個圖上
link |
28:06.000
你可以很明顯的知道說
link |
28:08.000
其實CNN它的bias比較大,
link |
28:12.000
它的model的bias比較大。
link |
28:14.000
那你可能會想說
link |
28:15.000
有model bias比較大
link |
28:16.000
不是一件壞事嗎?
link |
28:18.000
model bias大不一定是壞事,
link |
28:21.000
因為當model bias小,
link |
28:22.000
model的flexibility很高的時候
link |
28:25.000
它比較容易overfitting。
link |
28:28.000
Fully connected layer
link |
28:29.000
它可以做各式各樣的事情,
link |
28:31.000
它可以有各式各樣的變化,
link |
28:33.000
但是它可能沒有辦法
link |
28:35.000
在任何特定的任務上做好。
link |
28:37.000
而convolutional layer
link |
28:38.000
它是專門為影像設計的,
link |
28:41.000
剛才講的receptive field
link |
28:42.000
參數共享這些觀察
link |
28:44.000
都是為影像設計的。
link |
28:46.000
那因為convolutional layer
link |
28:47.000
是特別為影像設計的,
link |
28:49.000
所以它在影像上
link |
28:51.000
仍然可以做得好,
link |
28:53.000
雖然它的model bias很大,
link |
28:54.000
但這個在影像上不是問題,
link |
28:56.000
但是如果它用在影像之外的任務,
link |
29:00.000
那你就要很小心了,
link |
29:01.000
你就要仔細想想
link |
29:02.000
那些任務有沒有我們剛才講的
link |
29:05.000
影像有的可信。
link |
29:09.000
那其實剛才是CNN的
link |
29:13.000
某一種介紹方式,
link |
29:15.000
那現在我們要講
link |
29:16.000
另外一種介紹方式。
link |
29:17.000
第二種介紹方式
link |
29:18.000
跟剛才講的介紹方式
link |
29:20.000
是一模一樣的,
link |
29:22.000
只是同一個故事
link |
29:24.000
用不同的版本來說明,
link |
29:27.000
那你看看你比較喜歡哪一個版本。
link |
29:29.000
那這個第二個版本是
link |
29:30.000
你比較常見的說明CNN的方式,
link |
29:33.000
那第二個版本的故事
link |
29:34.000
跟第一個版本的故事
link |
29:35.000
是一模一樣的。
link |
29:36.000
所以假設第一個版本
link |
29:37.000
你聽得有點迷迷糊糊的話,
link |
29:39.000
那我們來聽第二個版本。
link |
29:41.000
第二個版本是這樣的,
link |
29:42.000
什麼叫做convolutional layer?
link |
29:46.000
convolutional layer就是
link |
29:48.000
裡面有很多的filter,
link |
29:52.000
這些filter他們的大小
link |
29:55.000
是3x3xchannel的size,
link |
29:59.000
那所謂channel就是
link |
30:01.000
如果今天是彩色圖片的話,
link |
30:04.000
那就是RGB三個channel,
link |
30:06.000
如果是黑白的圖片的話,
link |
30:08.000
它的channel就W1,
link |
30:10.000
那一個convolutional layer裡面
link |
30:13.000
裡面就是有一排的filter,
link |
30:16.000
每一個filter它都是一個
link |
30:18.000
3x3xchannel這麼大的tensor,
link |
30:22.000
那每一個filter的作用
link |
30:24.000
就是要去圖片裡面
link |
30:26.000
抓取某一個pattern,
link |
30:28.000
但這些pattern要在3x3xchannel
link |
30:30.000
那麼小的範圍內,
link |
30:32.000
那才能夠被這些filter抓出來。
link |
30:35.000
那這些filter
link |
30:36.000
怎麼去圖片裡面抓pattern呢?
link |
30:39.000
我們現在舉一個實際的例子,
link |
30:41.000
那在等一下的例子裡面,
link |
30:42.000
我們假設channel是1,
link |
30:44.000
也就是說我們圖片是黑白的圖片,
link |
30:46.000
那我們假設這些filter的參數
link |
30:49.000
是已知的,filter就是
link |
30:51.000
一個一個的tensor,
link |
30:52.000
這個tensor裡面的數值
link |
30:54.000
我們都已經知道了,
link |
30:56.000
但實際上這些tensor裡面的數值
link |
30:58.000
其實就是model裡面的parameter,
link |
31:01.000
這些filter裡面的數值
link |
31:03.000
其實是未知的,
link |
31:04.000
它是要透過歸顛decent
link |
31:06.000
去找出來的,
link |
31:08.000
那我們現在已經假設說
link |
31:09.000
這些filter裡面的數值
link |
31:11.000
已經找出來了,
link |
31:12.000
我們來看看說這些filter
link |
31:14.000
是怎麼跟一張圖片進行運作,
link |
31:17.000
怎麼去圖片上面
link |
31:18.000
把pattern偵測出來的。
link |
31:21.000
這是我們的圖片,
link |
31:22.000
它是一個6x6的大小的圖片,
link |
31:26.000
那這些filter
link |
31:27.000
怎麼在這個圖片上面
link |
31:28.000
去偵測pattern呢?
link |
31:30.000
它的做法就是這樣,
link |
31:31.000
先把filter放在圖片的左上角,
link |
31:35.000
然後把filter裡面所有的值,
link |
31:37.000
在這邊有9個值,
link |
31:38.000
把這9個值
link |
31:40.000
跟左上角這個範圍內的9個值
link |
31:43.000
做相乘,
link |
31:45.000
也就是把filter裡面的9個值
link |
31:47.000
跟這個範圍裡面的9個值
link |
31:49.000
做inner product,
link |
31:51.000
做完是多少呢?
link |
31:52.000
先算是3,
link |
31:54.000
接下來這個filter
link |
31:55.000
本來放在左上角,
link |
31:56.000
接下來就往右移一點,
link |
31:58.000
那這個移動的距離
link |
32:00.000
叫做stripe,
link |
32:02.000
那在剛才講
link |
32:03.000
前一個版本的故事的時候
link |
32:04.000
我們stripe是設2,
link |
32:06.000
那在這個版本的故事裡面
link |
32:08.000
stripe就設為1,
link |
32:10.000
那往右移一點,
link |
32:12.000
然後再把這個filter
link |
32:14.000
跟這個範圍裡面的數值
link |
32:16.000
算inner product,
link |
32:17.000
算出來是多少呢?
link |
32:18.000
清算算出來是
link |
32:20.000
-1嗎?
link |
32:22.000
這個太簡單了,
link |
32:23.000
太簡單的數學,
link |
32:24.000
把它再往右移一點,
link |
32:26.000
這邊有1,
link |
32:27.000
這邊有1,
link |
32:28.000
這邊-1,
link |
32:29.000
算出來是多少?
link |
32:30.000
-3,
link |
32:31.000
然後就以此類推,
link |
32:32.000
再往右移一點,
link |
32:33.000
再算一下,
link |
32:34.000
然後這邊全部掃完以後
link |
32:36.000
再往右移一點,
link |
32:38.000
再算一下,
link |
32:39.000
以此類推,
link |
32:40.000
一直到把這個filter
link |
32:41.000
放在右下角,
link |
32:42.000
算出一個數值,
link |
32:43.000
它是多少?
link |
32:44.000
這邊111,
link |
32:45.000
這邊-1,
link |
32:46.000
-1,
link |
32:47.000
答案就是-1,
link |
32:48.000
就這樣。
link |
32:49.000
那這個filter
link |
32:50.000
怎麼說它在偵測pattern呢?
link |
32:51.000
你看這個filter裡面
link |
32:52.000
它對角線的地方
link |
32:53.000
都是1,
link |
32:54.000
所以它看到image裡面
link |
32:55.000
出現什麼東西的時候
link |
32:56.000
它的值會最大,
link |
32:57.000
看到image裡面
link |
32:58.000
也出現連三個1的時候
link |
33:01.000
它的數值會最大。
link |
33:03.000
所以你會發現說呢,
link |
33:05.000
這邊的輸出裡面
link |
33:06.000
左上角的地方的值最大,
link |
33:08.000
左下角的地方的值最大,
link |
33:10.000
就告訴我們說
link |
33:11.000
這個圖片裡面
link |
33:12.000
左上角有出現這個pattern,
link |
33:17.000
左下角有出現這個
link |
33:19.000
三個1連在一起的pattern,
link |
33:22.000
這個是第一個filter。
link |
33:24.000
那接下來呢,
link |
33:25.000
我們把每一個filter
link |
33:27.000
都做重複的process,
link |
33:29.000
比如說這邊有第二個filter,
link |
33:30.000
第二個filter很明顯
link |
33:31.000
它就在偵測
link |
33:32.000
1排成一直線的時候的狀況,
link |
33:34.000
我們就把第二個filter
link |
33:35.000
先從左上角開始掃起,
link |
33:37.000
得到一個數值,
link |
33:38.000
往右移一點,
link |
33:39.000
再得到一個數值,
link |
33:40.000
再往右移一點,
link |
33:41.000
再得到一個數值,
link |
33:42.000
反覆同樣的process,
link |
33:43.000
反覆同樣的操作,
link |
33:44.000
直到把整張圖片都掃完,
link |
33:47.000
我們又得到另外一群數字。
link |
33:50.000
所以每一個filter
link |
33:51.000
都會給我們一群數字,
link |
33:53.000
紅色的filter
link |
33:54.000
給我們一群數字,
link |
33:55.000
藍色的filter
link |
33:56.000
給我們一群數字,
link |
33:57.000
如果我們有64個filter,
link |
33:59.000
我們就得到64群的數字了。
link |
34:04.000
那這一群數字
link |
34:05.000
它又有一個名字,
link |
34:07.000
它叫做feature map,
link |
34:09.000
所以當我們把一張圖片
link |
34:11.000
通過一個convolutional的layer
link |
34:14.000
裡面有一堆filter的時候,
link |
34:15.000
我們產生出來了一個feature map,
link |
34:18.000
那假設這個convolutional的layer裡面
link |
34:21.000
它有64個filter,
link |
34:22.000
那我們產生出來的feature map
link |
34:26.000
就有64組數字,
link |
34:28.000
每一組在這個例子裡面
link |
34:29.000
是4乘以4,
link |
34:31.000
第一個filter產生4乘以4的數字,
link |
34:33.000
第二個filter也產生4乘以4的數字,
link |
34:35.000
第三個也產生4乘以4的數字,
link |
34:37.000
乃至到64個filter
link |
34:39.000
都產生4乘以4的數字。
link |
34:42.000
那這個feature map
link |
34:43.000
可以看成是什麼呢?
link |
34:44.000
這個feature map
link |
34:45.000
你可以看成是
link |
34:46.000
另外一張新的圖片,
link |
34:48.000
只是這個圖片的channel
link |
34:50.000
不是RGB這個圖片的channel,
link |
34:53.000
有64個,
link |
34:54.000
每一個channel
link |
34:55.000
就對應到一個filter。
link |
34:57.000
本來一張圖片
link |
34:58.000
它三個channel,
link |
35:00.000
通過一個convolution,
link |
35:01.000
它變成一張新的圖片
link |
35:03.000
有64個channel。
link |
35:07.000
那這個convolutional的layer
link |
35:09.000
當然是可以疊很多層的,
link |
35:11.000
當然是疊了第一層,
link |
35:13.000
那如果疊了第二層
link |
35:14.000
會發生什麼事呢?
link |
35:15.000
第二層的convolution裡面
link |
35:17.000
也有一堆的filter,
link |
35:22.000
那每一個filter
link |
35:23.000
它的大小
link |
35:24.000
我們這邊也設3x3,
link |
35:27.000
那它的高度呢?
link |
35:28.000
它的高度必須設為64,
link |
35:31.000
為什麼?
link |
35:32.000
我們知道說filter的高度
link |
35:35.000
就是它要處理的影像的channel,
link |
35:40.000
所以跟剛才第一層的convolution
link |
35:42.000
假設輸入的影像
link |
35:43.000
是黑白的channel是1,
link |
35:44.000
那我們的filter的高度就是1,
link |
35:46.000
輸入的影像
link |
35:47.000
如果是彩色的channel是3,
link |
35:49.000
那filter的高度就是3,
link |
35:51.000
那在第二層裡面
link |
35:53.000
我們也會得到一張影像,
link |
35:55.000
對第二個convolutional的layer來說
link |
35:57.000
它的輸入也是一張圖片,
link |
35:59.000
那這個圖片的channel是多少?
link |
36:01.000
這個圖片的channel是64,
link |
36:03.000
這64整來
link |
36:04.000
這個64是前一個convolutional layer的filter數目,
link |
36:09.000
前一個convolutional layer
link |
36:10.000
它filter數目64,
link |
36:12.000
那輸出以後
link |
36:13.000
就是64個channel,
link |
36:14.000
所以第二層
link |
36:15.000
假設你想要把這個圖片當作輸入,
link |
36:17.000
那你的filter的高度
link |
36:19.000
也得是64,
link |
36:21.000
所以第二層也有一把filter,
link |
36:24.000
只是這把filter
link |
36:25.000
它們的高度是64。
link |
36:28.000
好,那接下來要回答一個問題就是
link |
36:31.000
如果我們的filter的大小
link |
36:33.000
一直設3x3,
link |
36:35.000
會不會讓我們的network
link |
36:37.000
沒有辦法看比較大範圍的pattern呢?
link |
36:41.000
其實不會的,
link |
36:42.000
因為你想想看,
link |
36:43.000
如果我們在第二層convolutional的layer,
link |
36:47.000
我們的filter的大小
link |
36:48.000
一樣設3x3的話,
link |
36:50.000
會發生什麼事情呢?
link |
36:53.000
如果我們一樣設3x3的話,
link |
36:55.000
當我們看最左上角這個數值的時候,
link |
36:58.000
最左上角這個數值在影像上
link |
37:01.000
其實是對應到這個範圍,
link |
37:03.000
右下角的數值在影像上
link |
37:05.000
其實是對應到這個範圍,
link |
37:06.000
所以當我們看這3x3的範圍的時候,
link |
37:10.000
看第一個convolutional layer的輸出的
link |
37:13.000
這個feature map的3x3的範圍的時候,
link |
37:16.000
我們在原來的影像上
link |
37:18.000
其實是考慮了一個5x5的範圍,
link |
37:20.000
所以雖然我們的filter只有3x3,
link |
37:22.000
但是在影像上考慮的範圍
link |
37:24.000
是比較大的是5x5,
link |
37:25.000
所以今天你的network疊得越深,
link |
37:28.000
同樣是3x3的大小的filter,
link |
37:31.000
它看的範圍就會越來越大,
link |
37:34.000
所以network夠深,
link |
37:35.000
你不用怕你偵測不到
link |
37:36.000
比較大的pattern,
link |
37:37.000
它還是可以偵測到
link |
37:38.000
比較大的pattern。
link |
37:40.000
好,剛才我們講了
link |
37:42.000
兩個版本的故事了,
link |
37:44.000
那這兩個版本的故事
link |
37:45.000
是一模一樣的。
link |
37:48.000
我們在第一個版本的故事裡面
link |
37:50.000
說到了有一些neuron,
link |
37:51.000
這些neuron會共用參數,
link |
37:53.000
這些共用的參數
link |
37:55.000
就是第二個版本故事裡面的filter。
link |
38:00.000
我們這邊這組參數
link |
38:01.000
有3x3x3個,
link |
38:03.000
這個filter裡面
link |
38:04.000
有3x3x3個數字。
link |
38:07.000
我這邊特別還用顏色
link |
38:09.000
把這些數字圈起來告訴你說,
link |
38:11.000
這個weight就是這個數字,
link |
38:12.000
這個weight就是這個數字,
link |
38:14.000
這個weight可能就是這個數字
link |
38:16.000
以此類推。
link |
38:17.000
那這邊我把bias去掉了,
link |
38:20.000
那neuron這個是有bias的,
link |
38:22.000
這個filter有沒有bias呢?
link |
38:24.000
其實有的,
link |
38:25.000
只是在剛才的故事裡面
link |
38:26.000
沒有提到,
link |
38:27.000
在一般的實作上
link |
38:29.000
你的CNN的這些filter
link |
38:31.000
其實都還是有bias的數值的。
link |
38:35.000
然後在剛才
link |
38:36.000
第一個版本的故事裡面
link |
38:38.000
我們說不同的neuron
link |
38:40.000
它們可以share weight
link |
38:42.000
然後去守備不同的範圍。
link |
38:45.000
而share weight這件事
link |
38:47.000
其實就是我們把filter
link |
38:51.000
掃過一張圖片。
link |
38:53.000
那把filter掃過一張圖片
link |
38:55.000
這件事其實就是convolution。
link |
38:59.000
這就是為什麼convolution layer
link |
39:01.000
要叫convolution layer的關係。
link |
39:03.000
因為把filter掃過一張圖片
link |
39:04.000
這件事情其實就是convolution。
link |
39:07.000
所謂的把filter掃過圖片
link |
39:09.000
這件事情其實就是
link |
39:11.000
不同的receptive field
link |
39:13.000
neuron可以共用參數。
link |
39:15.000
而這種共用的參數
link |
39:16.000
就叫做一個filter。
link |
39:19.000
我們今天特別從
link |
39:20.000
兩個不同的面向
link |
39:22.000
跟你講CNN這個東西
link |
39:24.000
希望可以幫助你對CNN
link |
39:26.000
有更深的了解。
link |
39:28.000
所以我們說
link |
39:29.000
為什麼用CNN是基於兩個觀察
link |
39:32.000
第一個觀察是
link |
39:33.000
我們不需要看整張圖片
link |
39:34.000
那對neuron的故事版本
link |
39:36.000
對第一個故事而言就是
link |
39:37.000
neuron只看圖片一小部分
link |
39:39.000
對filter的故事而言就是
link |
39:41.000
我們有一組filter
link |
39:42.000
每個filter只看一個小範圍
link |
39:44.000
他只偵測小的pattern
link |
39:45.000
然後我們說
link |
39:46.000
同樣的pattern可能出現在
link |
39:48.000
圖片的不同的地方
link |
39:49.000
所以neuron間可以共用參數
link |
39:52.000
對filter的故事而言就是
link |
39:53.000
一個filter要掃過整張圖片
link |
39:57.000
這個就是convolution layer。
link |
40:01.000
那convolution layer
link |
40:02.000
在做影像辨識的時候
link |
40:04.000
其實還有第三個常用的東西
link |
40:08.000
這個東西叫做pooling
link |
40:11.000
那pooling是怎麼來的呢?
link |
40:13.000
pooling來自於
link |
40:14.000
另外一個觀察
link |
40:15.000
這個觀察是
link |
40:16.000
我們把一張比較大的圖片
link |
40:18.000
做sub-sampling
link |
40:20.000
舉例來說
link |
40:21.000
你把偶數的colon都拿掉
link |
40:24.000
奇數的row都拿掉
link |
40:25.000
圖片變為原來的四分之一
link |
40:27.000
但是不會影響
link |
40:28.000
裡面是什麼東西
link |
40:30.000
把一張大的圖片縮小
link |
40:31.000
這是一隻鳥
link |
40:32.000
這張小圖片
link |
40:33.000
看起來還是一隻鳥
link |
40:36.000
所以有了pooling這樣的設計
link |
40:39.000
那pooling是怎麼運作的呢?
link |
40:41.000
pooling這個東西
link |
40:42.000
它本身沒有參數
link |
40:45.000
所以它不是一個layer
link |
40:48.000
它裡面沒有weight
link |
40:49.000
它沒有要認的東西
link |
40:51.000
所以有人會告訴你說
link |
40:52.000
pooling比較像是一個
link |
40:54.000
activation function
link |
40:55.000
比較像是sigmoid、relu那些
link |
40:57.000
因為它裡面是
link |
40:58.000
沒有要認的東西的
link |
41:00.000
它就是一個operator
link |
41:02.000
它的行為都是固定好的
link |
41:04.000
沒有要根據data學任何東西
link |
41:07.000
那pooling其實也有
link |
41:08.000
很多不同的版本
link |
41:09.000
我們這邊講的是maxpooling
link |
41:12.000
maxpooling是怎麼運作的呢?
link |
41:14.000
我們剛才說
link |
41:15.000
每一個filter都產生一把數字
link |
41:17.000
每一個filter都產生一把數字
link |
41:20.000
要做pooling的時候
link |
41:21.000
我們就把這些數字
link |
41:23.000
幾個幾個一組
link |
41:25.000
比如說在這個例子裡面
link |
41:26.000
就是2x2x1組
link |
41:29.000
2x2x1組
link |
41:30.000
2x2x1組
link |
41:31.000
每一組裡面選一個代表
link |
41:34.000
在maxpooling裡面
link |
41:36.000
我們選的代表
link |
41:37.000
就是最大的那一個
link |
41:40.000
那你可能會問說
link |
41:41.000
為什麼是選最大的那一個呢?
link |
41:42.000
你不一定要選最大的那一個
link |
41:44.000
這個是你自己可以決定的
link |
41:46.000
maxpooling這一個方法
link |
41:48.000
是選最大的那一個
link |
41:49.000
但是也有minpooling
link |
41:50.000
minpooling就是選平均
link |
41:52.000
我還看過選幾何平均的
link |
41:54.000
所以有各式各樣的pooling的方法
link |
41:57.000
那你說這邊一定要
link |
41:58.000
2x2x1組嗎?
link |
41:59.000
也不一定
link |
42:00.000
這個也是你自己決定的
link |
42:01.000
你要3x3x4x4
link |
42:03.000
也可以
link |
42:04.000
這個是你自己決定的
link |
42:06.000
所以我們做完convolution以後
link |
42:09.000
往往後面還會搭配pooling
link |
42:12.000
那pooling做的事情
link |
42:14.000
就是把圖片變小
link |
42:16.000
做完convolution以後
link |
42:17.000
我們會得到一張圖片
link |
42:19.000
這張圖片裡面
link |
42:20.000
有很多的channel
link |
42:21.000
那做完pooling以後
link |
42:23.000
我們就是把這張圖片的channel不變
link |
42:25.000
本來64個channel
link |
42:26.000
還是64個channel
link |
42:27.000
但是我們會把圖片
link |
42:28.000
變得比較小 長一點
link |
42:30.000
在剛才的例子裡面
link |
42:31.000
本來4x4的圖片
link |
42:33.000
如果我們把
link |
42:34.000
這個output的數值
link |
42:37.000
2x2個一組的話
link |
42:38.000
那4x4的圖片
link |
42:40.000
就會變成2x2的圖片
link |
42:42.000
那這個就是pooling所做的事情
link |
42:45.000
那一般在實作上
link |
42:46.000
往往就是convolution
link |
42:48.000
跟pooling交替使用
link |
42:50.000
就是你可能做幾次convolution
link |
42:52.000
做一次pooling
link |
42:53.000
比如兩次convolution一次pooling
link |
42:54.000
兩次convolution一次pooling
link |
42:57.000
不過你可以想見說
link |
42:58.000
pooling對於你的performance
link |
43:01.000
還是可能會帶來一點傷害
link |
43:03.000
因為假設你今天要偵測的是
link |
43:05.000
非常微細的東西
link |
43:06.000
那你隨便做subassembly
link |
43:08.000
performance可能會稍微差一點
link |
43:10.000
所以近年來你會發現
link |
43:11.000
很多影像辨識的network的設計
link |
43:14.000
往往也開始把pooling丟掉
link |
43:16.000
他會做這種
link |
43:17.000
for convolution的neural network
link |
43:19.000
就整個network裡面
link |
43:20.000
通通都是convolution
link |
43:21.000
完全都不用pooling
link |
43:23.000
那是因為近年來
link |
43:24.000
運算能力越來越強
link |
43:26.000
那pooling最主要的理由
link |
43:27.000
是為了減少運算量
link |
43:29.000
做subassembly
link |
43:30.000
把影像變少
link |
43:31.000
減少運算量
link |
43:32.000
那如果你今天
link |
43:33.000
你的運算資源足夠支撐你
link |
43:35.000
不做pooling的話
link |
43:36.000
很多network架構的設計
link |
43:38.000
往往今天就不做pooling
link |
43:40.000
全convolution
link |
43:41.000
convolution從頭到尾
link |
43:43.000
然後看看做不做得起來
link |
43:44.000
看看能不能夠做得更好
link |
43:47.000
那一般以後
link |
43:48.000
你的架構就是convolution加pooling
link |
43:50.000
那我剛才講過說
link |
43:51.000
pooling是可有可無啦
link |
43:53.000
今天很多人可能會選擇
link |
43:54.000
不用pooling
link |
43:55.000
那如果你做完幾次convolution
link |
43:57.000
以後接下來呢
link |
43:58.000
最終怎麼得到最後的結果呢
link |
44:02.000
你會把pooling的output
link |
44:04.000
做一件事情叫做flatten
link |
44:06.000
flatten這個字眼
link |
44:07.000
剛才在作業2裡面
link |
44:08.000
助教其實也有提到
link |
44:09.000
所謂flatten的意思就是
link |
44:11.000
把這個影像裡面
link |
44:14.000
本來排成矩陣的樣子的東西
link |
44:17.000
拉直
link |
44:18.000
把所有的數值拉直
link |
44:19.000
變成一個向量
link |
44:20.000
再把這個向量
link |
44:21.000
丟進fully connected的layer裡面
link |
44:24.000
最終你可能還要過個softmax
link |
44:26.000
然後最終得到
link |
44:27.000
影像辨識的結果
link |
44:29.000
這就是一個
link |
44:30.000
經典的影像辨識的network
link |
44:32.000
它可能有的樣子
link |
44:34.000
就是長這樣
link |
44:35.000
裡面有convolution
link |
44:36.000
有pooling
link |
44:37.000
有flatten
link |
44:38.000
最後再通過幾個
link |
44:39.000
fully connected的layer
link |
44:41.000
過softmax
link |
44:42.000
最終得到影像辨識的結果
link |
44:45.000
那我們在作業3
link |
44:46.000
就是會做一個影像辨識的題目
link |
44:50.000
那除了影像辨識以外
link |
44:52.000
你可能聽過CNN
link |
44:53.000
另外一個最常見的
link |
44:54.000
最耳熟能詳的應用
link |
44:56.000
就是用來下圍棋
link |
44:59.000
那今天呢
link |
45:00.000
如果講個機器學習的課
link |
45:01.000
沒有提到alpha go
link |
45:02.000
大家就覺得
link |
45:03.000
你什麼都沒有講對不對
link |
45:04.000
所以我們來提一下alpha go
link |
45:06.000
好 怎麼用這個CNN來下圍棋呢
link |
45:10.000
我們說下圍棋
link |
45:11.000
其實就是一個分類的問題
link |
45:13.000
你的network的輸入
link |
45:15.000
是棋盤上黑子跟白子的位置
link |
45:19.000
你的輸出
link |
45:20.000
就是下一步應該要落子的位置
link |
45:24.000
可是我們今天已經知道說
link |
45:25.000
network的輸入就是一個向量啊
link |
45:28.000
那怎麼把棋盤表示成一個向量呢
link |
45:31.000
完全沒有問題
link |
45:33.000
棋盤上就是有19x19個位置嘛
link |
45:37.000
那我們就把一個棋盤
link |
45:38.000
表示成一個19x19圍的向量
link |
45:42.000
在這個向量裡面
link |
45:43.000
如果某一個位置有一個黑子
link |
45:46.000
那那個位置我們就填1
link |
45:48.000
如果白子我們就填-1
link |
45:50.000
如果沒有子我們就填0
link |
45:52.000
那我們就可以告訴network說
link |
45:54.000
我們就可以告訴network說
link |
45:55.000
現在棋盤上的盤勢長什麼樣子
link |
45:58.000
我們可以用一個19x19圍的向量
link |
46:01.000
來描述一個棋盤
link |
46:02.000
當然這不一定是要這麼做啦
link |
46:04.000
不一定要黑子是1 白子是-1
link |
46:05.000
然後沒有子就是0
link |
46:07.000
這只是一個可能的表示方式而已
link |
46:09.000
你可以想出其他更神奇的表示方式
link |
46:12.000
總之我們有辦法把棋盤上的盤勢
link |
46:15.000
用一個向量來描述
link |
46:16.000
把這個向量輸到一個network裡面
link |
46:18.000
然後你就可以把下圍棋
link |
46:20.000
當作一個分類的問題
link |
46:22.000
叫這個network去預測
link |
46:23.000
下一步應該落子的位置
link |
46:25.000
落在哪裡最好
link |
46:27.000
所以下圍棋就是一個
link |
46:29.000
有19x19個類別的分類的問題
link |
46:33.000
network會output說
link |
46:35.000
在這19x19個類別裡面
link |
46:37.000
哪一個類別是最好的
link |
46:38.000
應該要選擇下一步落子的位置
link |
46:41.000
應該在哪裡
link |
46:42.000
那這個問題完全可以用一個
link |
46:45.000
fully connected的network來解決
link |
46:47.000
但是用CNN的效果更好
link |
46:52.000
為什麼用CNN的效果更好呢
link |
46:54.000
首先你完全可以把一個棋盤
link |
46:57.000
看作是一張圖片
link |
47:00.000
一個棋盤可以看作是一個
link |
47:02.000
解析度19x19的圖片
link |
47:05.000
一般圖片很大
link |
47:06.000
一般圖片可能都
link |
47:08.000
100x100的解析度
link |
47:09.000
都是很小的圖片啦
link |
47:10.000
但是棋盤是一個更小的圖片
link |
47:13.000
它的解析度只有19x19
link |
47:16.000
這個圖片裡面
link |
47:17.000
每一個像素每一個pixel
link |
47:19.000
就代表棋盤上一個可以落子的位置
link |
47:23.000
那channel呢
link |
47:24.000
一般圖片的channel就是RGB嘛
link |
47:26.000
RGB代表一個顏色
link |
47:28.000
那棋盤上每一個pixel的channel
link |
47:31.000
應該是什麼呢
link |
47:33.000
在AlphaGo的原始論文裡面
link |
47:35.000
它告訴你說
link |
47:36.000
每一個棋盤的位置
link |
47:38.000
每一個棋盤上的pixel
link |
47:40.000
它是用48個channel來描述
link |
47:44.000
也就是說棋盤上的每一個位置
link |
47:46.000
它都用48個數字
link |
47:49.000
來描述那個位置發生了什麼事
link |
47:52.000
那至於為什麼是這48個
link |
47:54.000
那這個顯然是圍棋高手設計出來的
link |
47:56.000
那48個位置包括
link |
47:58.000
比如說這個位置是不是要被叫吃了
link |
48:00.000
這個位置旁邊有沒有
link |
48:02.000
顏色不一樣的紙等等
link |
48:04.000
就是這樣子描述每一個位置
link |
48:07.000
所以你用48個數字
link |
48:08.000
來描述棋盤上的一個位置
link |
48:11.000
這一個棋盤
link |
48:12.000
它就是19x19的解析度的圖片
link |
48:15.000
它的channel就是48
link |
48:19.000
但是為什麼CNN可以用在下圍棋上呢
link |
48:22.000
我們剛才就有強調說CNN
link |
48:24.000
其實並不是你隨便用都會好的
link |
48:26.000
它是為影像設計的
link |
48:28.000
所以如果一個問題
link |
48:29.000
它跟影像沒有什麼共通的特性的話
link |
48:32.000
你其實不該用CNN
link |
48:34.000
所以今天既然在下圍棋可以用CNN
link |
48:36.000
那意味著什麼
link |
48:37.000
那意味著圍棋跟影像有共同的特性
link |
48:41.000
什麼樣共同的特性呢
link |
48:43.000
我們剛才講說在影像上的第一個觀察是
link |
48:47.000
很多重要的pattern
link |
48:49.000
你只需要看小範圍就知道了
link |
48:52.000
下圍棋是不是也是一樣呢
link |
48:54.000
舉例來說
link |
48:55.000
這個pattern
link |
48:56.000
你就算不用看整個棋盤的盤勢
link |
48:58.000
你都知道說這邊發生了什麼事
link |
49:00.000
這個就是白紙被黑紙圍住了嘛
link |
49:03.000
那接下來黑紙如果放在這邊
link |
49:05.000
就可以把白紙提走
link |
49:06.000
那白紙要放在這邊才可以接
link |
49:10.000
這個白紙才不會被提走
link |
49:12.000
那其實在AlphaGo裡面
link |
49:14.000
它的第一層的layer
link |
49:16.000
它的filter的大小就是5x5
link |
49:18.000
所以顯然在設計這個network的人覺得說
link |
49:21.000
棋盤上很多重要的pattern
link |
49:23.000
也許看5x5的範圍就可以知道了
link |
49:27.000
再來我們說影像上的第二個觀察是
link |
49:30.000
同樣的pattern可能會出現在不同的位置
link |
49:34.000
在下圍棋裡面是不是也是一樣呢
link |
49:36.000
這個教師的pattern
link |
49:39.000
它可以出現在棋盤上的任何位置
link |
49:41.000
它可以出現在左上角
link |
49:42.000
也可以出現在右下角
link |
49:44.000
所以從這個觀點來看
link |
49:46.000
影像跟下圍棋有很多共同之處
link |
49:51.000
但是讓人想不透的地方是
link |
49:53.000
在做影像的時候
link |
49:55.000
我們說我們都會做pooling
link |
49:57.000
也就是一張影像做sub-sampling以後
link |
50:00.000
並不會影響我們對影像中物件的判讀
link |
50:03.000
但是棋盤是這個樣子嗎
link |
50:05.000
你可以把棋盤上的奇數行跟偶數列拿掉
link |
50:09.000
還是同一個棋局嗎
link |
50:11.000
聽起來好像不是對不對
link |
50:13.000
下圍棋這麼精細的任務
link |
50:15.000
你隨便拿掉一個column 拿掉一個row
link |
50:17.000
整個局勢就不一樣了
link |
50:19.000
怎麼可能拿掉一個row 拿掉一個column
link |
50:21.000
還會沒有問題呢
link |
50:23.000
所以有人就會說
link |
50:25.000
CNN裡面就是要有pooling
link |
50:27.000
然後影像辨識都是用pooling
link |
50:29.000
所以AlphaGo也一定有用pooling
link |
50:31.000
這代表AlphaGo很爛
link |
50:33.000
針對pooling這個弱點去攻擊它
link |
50:35.000
一定就可以把它打爆
link |
50:37.000
真的是這樣嗎
link |
50:39.000
可是AlphaGo這麼強
link |
50:41.000
顯然它沒有這麼顯而易見的弱點
link |
50:43.000
所以這個問題就讓我有點困擾
link |
50:45.000
後來我就去仔細讀了一下
link |
50:47.000
AlphaGo那篇paper
link |
50:49.000
其實AlphaGo在Natural上的paper
link |
50:51.000
其實沒有多長
link |
50:53.000
大概就五六頁而已
link |
50:55.000
所以你一下子就可以看完
link |
50:57.000
而且在這個文章的正文裡面
link |
50:59.000
是什麼樣子
link |
51:01.000
它沒有講內握架構的細節
link |
51:03.000
這個細節在哪裡呢
link |
51:05.000
這個細節在附件裡面
link |
51:07.000
所以我就仔細讀了一下附件
link |
51:09.000
看看說AlphaGo的網路結構
link |
51:11.000
長什麼樣子
link |
51:13.000
我們就來看一下
link |
51:15.000
這個附件裡面是怎麼描述
link |
51:17.000
AlphaGo的類神經網路結構的
link |
51:19.000
它先說我們把一個棋盤
link |
51:21.000
看作19x19x48那麼大小的
link |
51:23.000
這我們剛才講過了
link |
51:25.000
把棋盤看作是一個圖片
link |
51:27.000
接下來它說
link |
51:29.000
它有做Zero Padding
link |
51:31.000
Padding這件事我們有講嘛
link |
51:33.000
就是你的filter如果超出影像的範圍
link |
51:35.000
就補0
link |
51:37.000
Zero Padding就是超出範圍就補0
link |
51:39.000
它說它的filter的大小
link |
51:41.000
kernel size就是filter的大小
link |
51:43.000
是5x5
link |
51:45.000
然後有K的filter
link |
51:47.000
K是多少
link |
51:49.000
K是192
link |
51:51.000
這大概是試出來的啦
link |
51:53.000
它也試了128跟256
link |
51:55.000
11層,然後stride等於1
link |
51:57.000
stride是什麼我們剛才也解釋過了
link |
51:59.000
然後這邊有用了rectifier
link |
52:01.000
non-linearity
link |
52:03.000
這個就是redu
link |
52:05.000
然後在第2層
link |
52:07.000
到第12層
link |
52:09.000
都有做
link |
52:11.000
Zero Padding
link |
52:13.000
然後kernel size都是3x3
link |
52:15.000
一樣是K的filter
link |
52:17.000
也就是每一層都是192個filter
link |
52:19.000
stride一樣是1
link |
52:21.000
就這樣疊了很多層以後
link |
52:23.000
因為是一個分類的問題
link |
52:25.000
最後加上了一個
link |
52:27.000
sortmax
link |
52:29.000
讀完以後你有發現什麼玄機嗎
link |
52:31.000
你發現
link |
52:33.000
它沒有用boolean啊
link |
52:35.000
所以這給我們一個很好的例子
link |
52:37.000
就是類神經網路的設計
link |
52:39.000
這個應用之道
link |
52:41.000
純乎一新啊
link |
52:43.000
你不要看影像上面都有用boolean
link |
52:45.000
就覺得boolean一定是好的
link |
52:47.000
在下圍棋的時候就是不適合用boolean
link |
52:49.000
所以你要想清楚說
link |
52:51.000
我這個network的架構
link |
52:53.000
到底代表什麼意思
link |
52:55.000
它適不適合用在我現在這個任務上
link |
52:57.000
而CNN呢
link |
52:59.000
除了下圍棋還有影像以外
link |
53:01.000
近年來也用在
link |
53:03.000
語音上也用在
link |
53:05.000
文字處理上
link |
53:07.000
這邊我們就不再細講
link |
53:09.000
但是呢
link |
53:11.000
如果你真的想把CNN用在語音上
link |
53:13.000
用在文字處理上
link |
53:15.000
你要仔細看一下文獻上的方法
link |
53:17.000
這個在影像
link |
53:19.000
在語音上
link |
53:21.000
在文字上
link |
53:23.000
那個receptive field的設計
link |
53:25.000
這個參數共享的設計
link |
53:27.000
跟影像上不是一樣的
link |
53:29.000
所以你要想清楚
link |
53:31.000
那些receptive field
link |
53:33.000
語音用在文字上的設計
link |
53:35.000
跟影像上不是一樣
link |
53:37.000
是考慮了語音跟文字的特性後所設計的
link |
53:39.000
所以你不要以為在影像上的CNN
link |
53:41.000
直接套到語音上可以work
link |
53:43.000
可能是不work的
link |
53:45.000
你要想清楚說語音有什麼樣的特性
link |
53:47.000
你要怎麼設計合適的
link |
53:49.000
receptive field
link |
53:51.000
好,那有人會說
link |
53:53.000
CNN啊
link |
53:55.000
其實CNN啊
link |
53:57.000
它沒有辦法處理影像放大縮小
link |
53:59.000
或者是旋轉的問題
link |
54:01.000
怎麼說呢
link |
54:03.000
假設今天你給CNN看的狗
link |
54:05.000
都是這個大小
link |
54:07.000
它可以辨識說這是一隻狗
link |
54:09.000
當你把這個圖片放大的時候
link |
54:11.000
它可以辨識說
link |
54:13.000
它還是一隻狗嗎
link |
54:15.000
可能是不行的
link |
54:17.000
你可能會想說怎麼會不能夠辨識呢
link |
54:19.000
這兩個形狀不是一模一樣啊
link |
54:21.000
怎麼放大就不能辨識呢
link |
54:23.000
CNN這麼笨嗎
link |
54:25.000
它就是這麼笨
link |
54:27.000
對它來說這兩張圖片
link |
54:29.000
雖然這個形狀是一模一樣的
link |
54:31.000
但是如果你把它拉長成像量的話
link |
54:33.000
它裡面的數值就是不一樣的啊
link |
54:35.000
所以對CNN來說
link |
54:37.000
雖然你人眼一看覺得它形狀很像
link |
54:39.000
但對CNN內握來說
link |
54:41.000
它是非常不一樣的
link |
54:43.000
它並不能夠處理影像放大縮小
link |
54:45.000
或者是旋轉的問題
link |
54:47.000
當它今天在
link |
54:49.000
某種大小的影像上
link |
54:51.000
假設你裡面的物件都是比較小的
link |
54:53.000
它在上面學會做影像辨識
link |
54:55.000
你把物件放大
link |
54:57.000
它就會整個慘掉
link |
54:59.000
所以CNN並沒有你想像的那麼強
link |
55:01.000
那就是為什麼我們在做影像辨識的時候
link |
55:03.000
往往都要做Data Augmentation
link |
55:05.000
所謂Data Augmentation的意思就是說
link |
55:07.000
你把你的訓練資料
link |
55:09.000
每張圖片都
link |
55:11.000
裡面截一小塊出來放大
link |
55:13.000
讓CNN有看過不同大小的Pattern
link |
55:15.000
然後把圖片旋轉
link |
55:17.000
讓它有看過某一個物件旋轉以後
link |
55:19.000
長什麼樣子
link |
55:21.000
CNN才會做到好的結果
link |
55:23.000
那你說CNN不能夠處理
link |
55:25.000
Scaling跟Rotation的問題啊
link |
55:27.000
那有沒有什麼內握架構
link |
55:29.000
是可以處理這個問題呢
link |
55:31.000
其實有的,有一個架構叫
link |
55:33.000
Special Transformer Layer
link |
55:35.000
我們不會講它,我們就把
link |
55:37.000
錄影的連結放在這邊