Popular Posts

[R]散佈圖...

[SAS]L...

[SAS][...

[R]Log...

[SAS] ...

[SAS]線...

[SAS]存...

[SAS]迴...

機器學習

Convolutional Neural network 卷積神經網路(part1)

by wenwu

Convolutional Neural network 卷積神經網路(part1)

今日的課程來自於: https://youtu.be/5BJDJd-dzzg (0-33分)

為什麼要使用CNN 於影像處理?

CNN vs DNN

我們當然可以使用一般的neural network 來做影像處理，不一定要用CNN。但是我們會遇到一個問題，每一個就是在處理影像辨別時，使用fully connetcted 的 feedforward network來做圖像處裡時，往往需要太多數據。

舉例來說，一張100*100的彩色圖片，他的辨別率才100*100，將他拉成一個vector，他總共有100*100*3(彩色需要三個value)=三萬維了。如果input 是三萬為，假設hidden layer 有1000個neuron，那僅僅是第一層hidden layer的參數就已經有30000*1000個了，這樣太多了。

所以CNN做得事情其實是，用簡化這個neural network的架構，我們根據自己的知識和對圖像處裡的理解，一開始就把某些實際上用不到的參數給過濾掉，我們一開始就使用較少的參數來處理，所以CNN其實是比一般的DNN還要簡單的

雖然CNN看起來比較複雜，但事實上他的模型比DNN還要簡單，我們就是用prior knowledge，去把原來fully conected 的layer 裡面的一些參數拿掉，就變成CNN

Why can we discard some parameters?

為什麼可以減少一些參數呢? 為什麼可以減少參數還可以做圖像處裡?
下面有三點對影像處裡的觀察:

1. Some pattens are much smaller than the whole image

在影像處理中，如果在network的第一層hidden layer裡，那些neuron要做的就是偵測有沒有一種特定的patten出現。所以並不需要看整張image，只需要看這張image 的一小部分，就可以解決這件事情了

舉例來說，假設現在我們有一張鳥的圖片，那第一層的hidden layer的某一個neuron的工作是，偵測有沒有鳥嘴。其實不需要看整張圖片，只需要給neuron看重點就可以了。每一個neuron其實只要連接到一個小塊的區域就好，它不需要連接到整張完整的圖，因此也對應更少的參數

2. The same patterns appear in different regions

同樣的patten，可能會出現在image的不同部位，但是他們有同樣的形狀，因此可以用同樣的neuron，同樣的參數，被同一個detector檢測出來。

舉例來說，圖片中可能有一個處於圖左上角與中間的鳥嘴，這時不需要訓練兩個不同的detector去專門偵測左上角有沒有鳥嘴和中間有沒有鳥嘴，我們需要cost down(降低成本)，所以我們可以要求這些功能幾乎一致的neuron共用一組參數，他們share同一組參數就可以減少參數的量

3. Subsampling the pixels will not change the object

我們可以對一張image 做subsampling( 二次抽樣)，將image 抽掉奇數行、偶數列拿掉，變成原來的十分之一。這不會影響我們對圖片的理解，因此我們可以利用subsampling 這個概念把image 變小，從而減少需要用到的參數量

CNN的架構

整個CNN的架構是這樣的，收到一張圖片之後，重複 Concolution和max pooling (這兩個步驟可以進行多次，重複次數需要先決定)，這個過程就是network的架構，就像network會有好幾層一樣。
之後要做的是Flatten(將矩陣拉直)，在將flatten output丟到一般的Fully connected network，最終得到影像辨識的結果。

我們基於之前提到三個對影像處理的觀察:

  1. 偵測不需要整張image，只需要一部分
  2. 同樣的patten會出現在一張圖片的不同區域，可以使用同樣的參數
  3. 我們可以對整張image做subsampling

前面兩點的特性是用convolution 的layer來處理的，最後的特性是用max pooling 來處理

Convolution

假設現在我們network的input是一張6*6的image。圖片是黑白的，所以每個pixel只需要一個value來表示。而在convolution layer裡面，有一堆Filter，這裡的每一個Fliter，其實就等同於是Fully connected layer 裡的一個neuron

Property1

每一個Fliter 就是一個matrix ，這個matrix 裡面每一個element的值，就跟那些neuron的weight和bias一樣，是network的parameter，他們都是通過training data學出來的，而不是人去設計的

所以每個Fliter裡面的值是甚麼，要做什麼事情，都是自動學出來的，下圖中的filter是3*3的size，意味著他在偵測一個3*3的patten。當她偵測的時候，並不會去看整張image，他只看一個3*3裡的pixel，就可以判斷某一個patten有沒有出現，這就是考慮property 1 了

Property 2

這個filter是從image的左上角開始，做一個slide window，每次向右移動一個距離，這個距離就叫做stride，由你自己設定，每次filter停下來的是侯就跟對應的3*3matrix做一個內積。這裡設定stride=1 ，那麼我們的filter每次移動一格，到最右邊就從下一行最左邊重複進行上述操作，經過一整個convolution的process，最終得到下圖所示的4*4 matrix

觀察上圖的filter 1 ，它的斜對角是1,1,1，所以這個fliter的工作就是找出有沒有連續的從左上角到右下角的1,1,1出現在這個image裡面。 檢測到的結果已在上左圖用藍色標示出來，此時fliter得到的和積在左上和左下得到最大的值。這就是說，該fliter所要偵測的pattern出現在image的左上角和左下角

同一個pattern出現在image左上角的位置和左下角的位置，並不需要用到不同的filter，我們用filter1就可以偵測出來，這就考慮property 2

Feature map

在一個convolution的layer裡面，他會有一堆filter，每一個filter做完會得到一個4*4matrix，將所有的filter做完之後，就會得到很多個4*4matrix，將這些matrix合起來，就叫做Feature Map

CNN 對不同scale的相同pattern的處理上存在一定的困難，因為現在每一個filter size都是一樣的。這意味著，如果有同一個pattern，它有不同的size，但CNN並不夠自動處裡這個問題；DeepMind曾經發過一篇paper，上面提到當你input一張image的時候，他在CNN面前，再接到另一個network，這個network做的事情是，他會output一些scalar，告訴你這個image的裡面的那些位置要做旋轉or縮放，再丟到CNN裡面，這樣你其實會得到比較好的performance

Colorful image

剛剛的例子是黑白的image，所以你input的是一個matrix，如果今天是彩色的image就必須由RGB組成。所以彩色的image就是好幾個matrix疊再一起，是一個立方體，如果今天要處理彩色的image，要怎麼做呢?

這個時候你的filter 就不在是一個matrix了，他也會是一個立方體，如果你今天是RGB這三個顏色來表示一個pixel的話，那你的input就是6*6*3，你的filter 就是3*3*3，你的filter 的高就是3，你在做convolution的時候，就是把這個filter的9個值跟這個image裡面的9個值最內積，可以想像成filter的每一層都分別跟image的三層做內積，得到的也是一個三層的output，每一個filter同時就考慮了不同顏色所代表的channel

Convolution vs Fully Connected

filter 是特殊的 ”neuron”

convolution 跟 fully connected 有什麼關係。其實convolution就是一個neural network。
convolution這件事情，其實就是fully connected 的layer把一些weight拿掉而已，下圖的綠色方框標示出的feature map 的output ，其實就是hidden later 的 neuron的output ( 可以將矩陣拉直，沒有使用的weight 給零)

每個 “neuton” 只檢測 image的部分區域

比照fully connected 的neuron是必須連接到所有36個input上的，但是我們現在只用連接9 個input ，因為我們知道要detect一個patten，不用看整張image，看9個input pixel就夠了，所以當我們這麼做的時候，就用了比較少的參數

“neuton” 之間共享參數

在fully connected layer裡面，每一個neuron應該都有自己獨立的weight。但是當我們做這個convolution的時候，首先我們把每一個neuron前面連接的weight減少了，然後我們強迫某些neuron 要共享一組weight，雖然這兩個neuron連接到的pixel對象各不相同，但他們的weight都必須是一樣的，等於filter裡面的元素值，就叫做weight share。
當我們做這件事的時候，用的參數又比之前更少。

conclusion

因此我們可以這樣想，有這樣一些特殊的neuron，它們只連接著9條帶weight的線。當filter在image matrix上移動做convolution的時候，每次移動做的事情實際上是去檢測這個地方有沒有某一種pattern，對於Fully connected layer來說，它是對整張image做detection的，因此每次去檢
測image上不同地方有沒有pattern其實是不同的事情，所以這些neuron都必須連接到整張image的所有pixel上，並且不同neuron的連線上的weight都是相互獨立的。

那對於 convolution layer來說，首先它是對 image的一部分做 detection的，因此它的 neuron只需要連接到 image的部分 pixel上，對應連線所需要的 weight參數就會減少；其次由於是用同一個 filter去檢測不同位置的 pattern，所以這對 convolution layer來說，其實是同一件事情，因此不同的 neuron，雖然連接到的 pixel對象各不相同，但是在”做同一件事情”的前提下，也就是用同一個 filter的前提下，這些 neuron所使用的 weight參數都是相同的，通過這樣一張 weight share的方式，再次減少 network所需要用到的 weight參數

CNN的本質，就是減少參數的過程

Max pooling

operation of max pooling

相較於convolution，max pooling是比較簡單的，它就是做subsampling，根據filter 1，我們得到一個4*4的matrix，根據filter 2，你得到另外一個4*4的matrix，接下來，我們要做什麼事呢？

我們把output四個分為一組，每一組裡面通過選取平均值或最大值的方式，把原來4個value合成一個 value，這件事情相當於在image每相鄰的四塊區域內都挑出一塊來檢測，這種subsampling的方式就可以讓你的image縮小!

講到這裡你可能會有一個問題，如果取Maximum放到network裡面，不就沒法微分了嗎？ max這個東西，感覺是沒有辦法對它微分的啊，其實是可以的，後面的章節會講到Maxout network，會告訴你怎麼用微分的方式來處理它

Convolution + Max pooling

做完一次convolution加一次max pooling，我們就把原來6*6的image，變成了一個2*2的image；至於這個2*2的image，它每一個pixel的深度，也就是每一個pixel用幾個value來表示，就取決於你有幾個filter。幾個filter 代表深度有幾維。
所以，這是一個新的比較小的image，它表示的是不同區域上提取到的特徵，實際上不同的filter檢測的是該image同一區域上的不同特徵屬性，所以每一層channel(通道)代表的是一種屬性，一塊區域有一種不同的屬性，就有一層不同的channel，對應的就會有一個不同的filter對其進行convolution操作。

這件事情可以重複很多次，可以把得到的這個比較小的image，再次進行convolution 和 max pooling ，得到更小的image ，以此類推

這裡有一個問題: 假設我第一個convolution有25個filter ，通過這些filter得到25個feature map ，然後repeat的時候第二個convolution也有25個filter，那麼做完之後是不是會得到25² 個feature map ?

其實不是這樣的，你這邊做完一次convolution，得到25個feature map 之後再做一次convolution，還是會得到25個feature map，因為convolution在考慮input的時候，是會考慮深度的，他並不是每一個channel分開考慮，而是一次考慮所有的channel，所以你 convolution這邊有多少個 filter，再次output就會有多少個 channel

因此你這邊有25個 channel，經過含有25個 filter 的 convolution之後 output還會是25個 channel，只是這邊的每一個 channel，他都是一個cubic，他的高有25個 value這麼高

Flatten

做完convolution 和 max pooling 之後，就是Flattne 和 Fully connected Feedforward 的部分

Flatten 的意思是，把左邊的feature map 拉直，然後丟進一個 Fully connected Feedforward network，然後就結束了。也就是說，我們之前通過CNN提出了image的feature，他相較於原先一整個image的vector，少了很大一部分的內容，因此需要的參數也大量的減少了，但最終，也還是要丟到一個Fully connected 的network中去做最後的分類工作

CNN in Keras

內容簡介

接下來就來講一下，如何用Keras來implement CNN，實際上在compile、training和fitting的部分，內容和DNN是一樣的。對CNN來說，唯一需要改變的是network structure，以及input的format

本來在DNN裡，input是一個由image拉直展開而成的vector，但現在如果是CNN的話，他會考慮input image的幾何空間的，所以不能直接input一個vector，而是imput一個tensor給他(tensor就是高維的vector)，這裡你要給他一個三維的vector，一個image的長寬各式一維，如果是彩色的話，RGB就是第三維，所以你要assign一個三維的matrix，這個高維的matrix就叫做tensor

怎麼implement一個convolution的layer呢?

model12.add( Convolution2D (25,3,3, input_shape=(28,28,1)))

還是用model.add增加CNN的layer，將原先的Dense改成Convolution2D，參數25代表你有25個 filter，參數3,3代表你的filter都是3*3的matrix，此外你還需要告訴model，你input的image的shape是什麼樣的，假設我現在要做手寫數字識別，input就是28*28的image，又因為它的每一個pixel都只有單一顏色，因此input_shape的值就是(28,28,1)，如果是RGB的話，1就要改成3
然後增加一層Max Pooling的layer

model12.add( Maxpooling2D(2,2))

這裡參數(2,2)指的是，我們把通過convolution得到的feature map，按照2*2的方式分割成一個個區域，每次選取最大的那個值，並將這些值組成一個新的比較小的image，作為subsampling的結果

過程描述

  • 假設我們input是一個1*28*28的image
  • 通過25個filter的convolution layer以後你得到的output，會有25個channel，又因為filter的size是3*3，因此如果不考慮image邊緣處的處理的話，得到的channel會是26*26的，因此通過第一個convolution得到25*26*26的cubic image(這裡把這張image想像成長寬為26，高為25的cubic)
  • 接下來就是做Max pooling，把2*2的pixel分為一組，然後從裡面選一個最大的組成新的image，大小為25*13*13(cubic長寬各被砍掉一半)
  • 再做一次convolution，假設這次選擇50個filter，每個filter size是3*3的話，output的channel就變成有50個，那13*13的image，通過3*3的filter，就會變成11*11，因此通過第二個convolution得到50*11*11的image(得到一個新的長寬為11，高為50的cubic)
  • 再做一次Max Pooling，變成50*5*5

在第一個convolution裡面，每一個filter都有9個參數，它就是一個3*3的matrix；但是在第一個convolution layer裡面，雖然每一個filter都是3*3，但它其實不是3*3個參數，因為它的input是一個
25*13*13的cubic，這個cubic的channel有25個，所以要用同樣高度的cubic filter對它進行卷積，於是我們的filter實際上是一個25*3*3的cubic，所以這邊每個filter共有225個參數(225=3*3*25

通過兩次convolution和max pooling的組合，最終的image變成了50*5*5的size，然後使用Flatten將這個image拉直，變成一個1250維的vector，再把它丟到一個Fully Connected Feedforward network
裡面，network structure就搭建完成了

一個重要的問題

看到這裡，你可能會有一個疑惑，第一次convolution的input是25*13*13的cubic，且50個3*3的filter卷積後，得到的輸出時應該是50個cubic，且每個cubic的尺寸為25*11*11，那麼max pooling把長寬各砍掉一半後就是50層25*5*5的cubic，那flatten後不應該就是50*25*5*5嗎？

其實不是這樣的，在第一次做convolution的時候，我們是用25*3*3的cubic filter對25*13*13的cubic input進行卷積操作的，filter的每一層和input cubic中對應的每一層(也就是每一個channel)，它們進行內積後，還要把cubic的25個channel的內積值進行求和，作為這個“neuron”的output，它是一個scalar，這個cubic filter對整個cubic input做完一遍卷積操作後，得到的是一層scalar，然後有50個cubic filter，對應著50層scalar，因此最終得到的output是一個50*11*11的cubic！

這裡的關鍵是filter和image都是cubic，每個cubic filter有25層高，它和同樣有25層高的cubic image做卷積，並不是單單把每個cubic對應的channel進行內積，還會把這些內積求和！ ！ ！最終變為1層，因此兩個矩陣或者tensor做了卷積後，不管之前的維數如何，都會變為一個scalor！ ，故如果有50個Filter，無論input是什麼樣子的，最終的output還會是50層

0 comment
0 FacebookTwitterPinterestEmail
機器學習

機器學習自學筆記09: Keras2.0

by wenwu

機器學習自學筆記09: Keras2.0

今日的課程來自於: https://youtu.be/5BJDJd-dzzg
參考筆記:https://github.com/Sakura-gh/ML-notes/blob/master/ML-notes-pdf/10_Keras.pdf

Keras 介紹

Tensorflow 是目前最流行的machine learning庫之一。但是他沒有這麼好用tensorflow 和另一個功能相近的toolkit theano，這兩個都非常flexible ，可以做很多事情，deep learning 或是只做微分也行，也可以算gradient descent等等，但是這麼flexble 的toolkit 學起來是一定有難度的，沒辦法在半小時內學會。

Keras 是很容易學習且有足夠的彈性的，可以用來implement 一個自己的deep learning, Keras 其實是tensorflow和theano 的interface，所以用Keras 就等於在用tensorflow，只是有人幫你把操作tensorflow 這件事情幫妳寫好了。

多數想得到的nerwork，在 Keras 都有現成的function可以使用；因為它背後就是tensorflow or theano，所以如果你想要精進自己的能力的話，你永遠可以去改Keras背後的tensorflow 的code，然後做更厲害的事情

Keras 實作

現在Keras已經成為Tensorflow 的官方API，就像樂高一樣簡單
使用的data是MNIST的Data：http://yann.lecun.com/exdb/mnist/
Keras提供了自動下載MNIST data的function：http://keras.io/datasets/

接下來就依照之前machine learning 的三個步驟 :

首先要先導入keras套件：

from keras.models import Sequential

Step 1: define a set of function — neural network

先建立一個model

model=Squential()
  • 第一層 hidden layer

之後我們要決定neural network要長甚麼樣子: 假設我們想建立的有兩個hidden layer，每個hidden layer 都有500個neuron

model.add(Dense(input_dim=28*28,units=500,activation='sigmoid'))

Dense 表示加一個Fully connected 的layer ( 也可以加別的layer)
input_dim=28*28 表示輸入的是一個28*28=784長度的vector，表示image
units=500 表示該層的hidden layer 要有500個neuron
activation=’sigmoid’ 表示激活函數使用sigmoid function ( 還可以選其他activation function，比如softplus, softsign, relu, tanh, hard_sigmoid, linear …)

  • 第二層 hidden layer

如果要在model裡再加一個layer，就用model.add增加一個dense 全連接層，包誇units和activation參數

model.add(Dense(units=500,activation='sigmoid'))

這裡不用設定input_dim，因為新增的layer的input就等於前一個layer 的output
所以直接設定新加的layer有500的neuron就好了

  • 最後一層 output layer

最後，我們希望的output為10維，所以units=10

model.add(Dense(units=10,activation='softmax'))

如果把output layer當作一個Multi-class classifier 的話，那activation function就用softmax(這樣可以讓output每一維的機率和為1)

Step 2: goodness of function — cross entropy

使用model.compile 去定義你的loss function 是甚麼
比如你要用cross entropy 的話，那你的loss 參數就是 categorical_crossentropy(keras 裡的寫法)

model.compile(loss='categorical_crossentropy',optimizer='adam',metrics=['accuracy'])

Step 3: pick the best function

  • configuration(決定好怎麼做gradient descent)

在training之前，你要先下一些configuration 告訴她training 的時候，你打算要怎麼做

你要定義的第一個東西是optimizer，也就是說你要用什麼樣的方式來找最好的function，雖然optimizer後面可以皆不同的方式，但是這些不同的方式，其實都是gradient descent 類似的方法

有一些方法machine 會自動的，根據經驗決定learning rate的值應該是多少，所以這些方法是不需要給它 learning rate的

model.compile(loss='categorical crossentropy',optimizer='adam',metrics=['accuracy'])

optimizer 也可以使用: SGD(gradient descent), RMSprop, Adagrad, Adadelta, Adam, Adamax, Nadam 等方法，這些都是gradient descent

  • training

決定好怎麼做gradient descent 之後，就是實際去做training 了
跑gradient descent 找最優參數，這裡使用的是model.fit 的方法，要給他4個input (假設我們給了10000張image做 Training data )

model.fit(x_train, y_train, batch_size=100, nb_epoch=20)
  1. x_train ( training data)
    在這個case裡，Training data 就是一張一張的image，需要把它存到numpy array裡面，這個numpy array 是兩個維度的matrix。第一個維度，表示有多少個example；第二個維度，表示你的image有多大，有幾個pixel。
    所以這裡面前的狀況是，有一萬個image 做training data，並且每個image有28*28=784個pixel = 10000行*784列
  2. y_train (training data 對應的label)
    我們期望這些image經過training ，機器可以跟我們說這張image 是0~9所對應其中的一個數字，所以y_train的第一個維度應該是example的數量(也就是10000)，第二個維度是output的維度(也就是10)
  3. batch_size (告訴Keras我們的batch要多大)
    這裡 batch_size=100 ，表示我們要把100張隨機選擇的image放到一個batch裡面，然後把所有的image分成一個個不同的batch，Keras 會自動幫你完成隨機選擇image的過程，不需要自己coding
  4. nb_epoch (對所有batch的訓練要做幾次)
    這裡 nb_epoch=20，表示要對所有的batch進行20遍gradient descent 的訓練。每看到一個batch就update一次參數，假設現在每一個epoch裡面有100個batch，就對應著update 100 次參數，20個epoch就是update 2000 次參數。

下面有更仔細的batch & epoch的介紹

注意: 若batch_size=1，那就是Stochastic Gradient Descent (隨機梯度下降法)，這個在gradint descent有提到，就是每次拿到一個樣本點就update一次參數，而不是每次拿到一批樣本點的error之後才去update參數，因此stochastic gradient descent的好處就是速度比較快，雖然每次update參數的方向是不穩定的，但是天下武功，唯快不破，在別人出一拳的時候，它就已經出了100拳，所以它是比較強的。

Mini-batch

這裡有一個秘密，就是我們在做deep learing 的gradient descent 的時候，並不會真的去minimize total loss，那我們做的是什麼呢? 我們會把Training data分成一個一個的batch，比如training data 有10000張image，每次random選100張image作為一個batch

  • 像gradient descent 一樣，先隨機initialize network的參數
  • 選第一個batch出來，然後計算這個batch裡面的所有element的total loss L’，接下來根據 L’ 去update參數，也就是計算 L’ 對所有參數的偏微分，然後update參數
  • 在選第二個batch出來，現在這個batch 的 total loss 為 L’’ ，接下來根據 L’’ 對所有參數的偏微分，然後update參數
  • 反覆做上面的動作，直到所有的batch都選過一次。所以假設你有100個batch的話，你就把這個參數update 100次，把所有的batch看過一次，這就叫做一個 epoch (全部的batch 為一個epoch)
  • 重複epoch的過程，所以你在train network 的時候，你會需要好幾個epoch，而不是只有一個epoch

整個訓練的過程類似於stochastic gradient descent ，不是將所有數據讀完才開始做gradient descent 的，而是拿到一部份數據就做一次gradient descent

Batch size and Training Speed

接下來來討論設定batch size對training speed 的影響

batch size 太小會導致不穩定，速度上也沒有優勢

前面提到stochastic gradient descent，速度快，表現好。那為何還要使用Mini-batch? 這就提到了一些操作上的問題，我們必須使用Mini-batch

舉例來說現在有50000個example，分成兩種狀況。
如果 batch size = 1 ，也就是stochastic gradient descent，那在一個epoch裡面，就會update 50000次參數。
如果 batch size = 10 ，在一個epoch裡面，就會update 5000次參數。

看起來stochastic gradient descent的速度會比較快，實際上batch size 設置不一樣的話，一個epoch需要的時間是不一樣的。以GTX 980 為例，下圖是對總是為50000筆的training data 設置不同的batch size時，每一個epoch所需的花費時間

  • case1: 如果batch size=1，也就是stochastic gradient descent，一個epoch要花費166秒
  • case2: 如果batch size=10，一個epoch要花費17秒

而第二個需要跑10個epoch ，花費時間約為170秒。如果不同batch size的情況，update參數的次數幾乎是一樣的。

在這個case中，會更傾向選擇 batch size=10，因為會比batch size=1 更穩定(較穩，又update次數多)。因為由更大的數據集計算的梯度能更好的代表樣本總體，從而更準確的朝向極值所在的方向。

Batch size 會受到GPU平行加速的限制，太大可能導致在train的時候卡住

上面的例子的現象產生的原因是我们用了GPU，用了平行運算，所以batch size=10，這十個example是同時運算的，所以你在一個batch裡算10個example的時間跟算一個example的時間幾乎可以是一樣的

那你可能會問，既然batch size越大，它會越穩定，-而且還可以平行運算，那為什麼不把batch size變得超級大呢？這兩有兩個說明：

  1. 如果你把batch開到很大，最終GPU會無法平行運算，它是有極限的。
    也就是說同時考慮10個example和1個example的時間是一樣的。但是跑10000個就不可能跟一個example一樣。因為batch size 需要考慮到硬件限制。
  2. 如果把batch size設的很大，在train gradient descent 的時候，可能跑兩下network就卡住了，就縣道saddle point 或者local minimal
    因為在neural network的error surface 上面，如果你把loss 的圖像可視化出來，它並不是一個convex的optimization problem，不會像理想中那麼光滑
    如果batch size 很大，甚至是full batch，那你走過的路徑會是比較平滑連續的，可能這一條平滑的曲線在走向最低點的過程中就會在坑洞或緩坡上卡住了；如果batch size沒有這麼大，意味著你走的路線沒有這麼光滑，有些步伐是隨機性的，路徑會有一些曲折和波動
    可能在你走的過程中，它的曲折和波動剛好使得你“繞過”了那些saddle point或是local minima的地方；或者當你陷入不是很深的local minima或者没有遇到特别麻煩的saddle point的時候，它步伐的隨機性就可以幫你跳出這個gradient接近於0的區域，於是你更有可能真的走向global minima 的地方

對於 Full batch 的情况，它的路徑是没有隨機性的，是穩定朝著目標下降的，因此在這個時候去 train neural network 其實是有問題的，可能 update兩三次参數就會卡住，所以mini batch是有必要的

不同batch size在梯度下降上的表現

如下圖，左邊是full batch( 全部的training data 做一個batch) 的梯度下降效果，可以看到每一次跌代成本函數都呈現下降趨勢，這是好的現象，說明我們的w和b的設定一直再減少誤差，這樣一直跌代下去就可以找到最佳解；右邊是mini batch的梯度下降效果，它是上下波動的，成本函數的值有時高有時低，但總體還是呈現下降的趨勢，這個也是正常的，因為我們每一次梯度下降都是在mini batch上跑的而不是在整個數據集上，數據的差異可能會導致這樣的波動，但沒關係，因為它整體是呈下降趨勢的。

把下圖看做是梯度下降空間：藍色部分是full batch而紫色部分是mini batch，就像上面所说的mini batch不是每次迭代損失函數都會減少，所以看上去好像走了很多彎路，不過整體還是朝著最優解迭代的，而且由於mini batch 一個 epoch就走了5000步(5000次梯度下降)，而 full batch一個epoch只有一步，所以雖然 mini batch走了彎路但還是會快很多

mini batch在update的過程中，步伐具有隨機性，因此紫色的路徑可以在一定程度上繞過或跳出 saddle point、local minima 這些gradient 趨近於0的地方；而藍色的路徑因為缺乏隨機性，只能按照既定的方式朝著目標前進，很有可能就在中途被卡住，永遠也跳不出来了

當然，就像之前討論的一樣，如果batch size太反而會造成速度不僅没有加快反而會導致下降的曲線更加不穩定的情况產生

因此batch size既不能太大，因為它會受到硬體GPU平行加速的限制，導致update次數過於緩慢，並且由於缺少隨機性而很容易在梯度下降的過程中卡在saddle point或是local minima的地方(極端情况是Full batch)；而且batch size也不能太小，因為它會導致速度優勢不明顯的情况下，梯度下降曲線過於不穩定，算法可能永遠也不會收斂(極端情况是Stochastic gradient descent)

GPU是如何平行加速的

整個network，不管是Forward pass還是Backward pass，都可以看做是一連串的矩陣運算的结果

那今天我們就可以比較 batch size等於1(stochastic gradient descent)和10(mini batch)的差别

如下圖所示，stochastic gradient descent就是對每一個 input x 進行單獨運算；而 mini batch，則是把同一個 batch 裡面的input全部集合起来，假設現在我們的 batch size是2，那mini batch每一次運算的 input就是把黃色的vector和綠色的vector拼接起來變成一個matrix，再把這個 matrix乘上w1 ，你就可以直接得到 z¹ 和 z²

這兩件事在理論上運算量是一樣多的，但是在實際操作上，對GPU來說，在矩陣裡面相乘的每一個 element都是可以平行運算的，所以圖中stochastic gradient descent 運算的時間反而會變成下一mini batch使用GPU運算速度的兩倍，這就是為甚麼我們要使用mini batch的原因

Save and Load Models

Keras 也是可以幫你save 和load model 的，你可以把train好的 model 存起來，以後再用另一個程式讀出來，它也可以幫你做testing

那要如何用neural network去testing 呢? 有兩個case:

  • case1: Evaluation。比如今天有一組testing set，testing set的答案也是已知的，那 Keras 就可以幫你算現在的正確率有多少。
    這個model.evaluates有兩個input，就是testing的image(x_test) 和testing 的label(y_test)
score = model.evaluation(x_test, y_test)
print('Total loss on Testing Set:',score[0])
print('Accuracy of Testing Set',score[1])
  • case2: Predicion。這個時候model.perdict 函數的input 只有image data 而沒有任何的 label data，output就直接是分類結果
result = model.predict(x_test)
0 comment
1 FacebookTwitterPinterestEmail
SAS

[SAS]Logistic regression 羅吉斯迴歸 單變項與多變項羅吉斯迴歸

by wenwu

[SAS]Logistic regression 羅吉斯迴歸 單變項與多變項羅吉斯迴歸

在去年十月時寫了[R]Logistic regression，文章中提到Logistic 的使用條件，Logistic regression(羅吉斯迴歸) vs Linear regression(線性迴歸)的差別，介紹什麼是勝算比，最後有R 的logistic regression 的範例

今天補上SAS版的Logistic regression範例，順便介紹單變項(univariate logistic regression)與多變項(multivariate logistic regression)的不同
如果要看羅吉斯迴歸的使用時機，記得先去看這一篇喔

多變項羅吉斯迴歸(multivariate logistic regression)

上次[R]Logistic regression的文章中，示範的就是多變項羅吉斯迴歸
這次我們也用相同的資料，用SAS做一次示範

example for SAS 
這次我們使用同樣的資料，也就是768位病人的糖尿病資料[資料在這裡]
每一項變數的意思如下：

1.懷孕次數
2.口服葡萄糖耐量測試中2小時的血漿葡萄糖濃度
3.舒張壓（mm Hg）
4.三頭肌皮膚褶皺厚度（毫米）
5. 2小時血清胰島素（mu U / ml）
6.體重指數（體重（千克）/（身高（米））²）
7.糖尿病譜系功能
8.年齡（年）
9.糖尿病（0或1）

第九個糖尿病為二元的類別變項，1表示病人有糖尿病，0表示沒有

程式範例

首先是讀資料，將資料複製下來，存在txt文字檔裡面之後，將第一行換成:
pregnant,glucose,blood_pressure,triceps,serum_insulin,mass,pedigree,age,diabetes，就可以用SAS來讀資料了

/*read data */
PROC IMPORT
DATAFILE="C:\20200609_SAS_logistic.txt" /*記得換成你的txt文字檔位置*/
OUT=MYDATA /*data name */
DBMS=DLM
REPLACE;
DELIMITER=","; /*資料以逗點為分隔*/
GETNAMES=YES;
RUN;

同樣我們的目標是使用 pregnant 、glucose、triceps、mass 欄位預測 diabetes，

proc logistic data=MYDATA plots=(ROC);
model diabetes(event='1')=       /*這是我們的依變項(Y)*/
pregnant glucose triceps mass / CLODDS=wald;  /*放入有興趣的變項*/
/*如果有類別變項可以使用class，記得給參考組(括號內為參考組)*/
/*class AGE_GP(param=ref ref='1');*/
run;

首先可以看到Model information，依變項(Y)(Response Variable)是diabetes，資料個數為768，diabetes=0共有500位，diabetes=1共有268位

再來可以看到(下圖)model 的表現，Model Fit Statistics中有不同的criterion，方便與不同的模型比較(ex: AIC 越小越好)

Testing Global Null Hypothesis 中，可以看到Likelihood ratio 的p-value < 0.0001，表示拒絕H0虛無假設，模型是有效的

最後可以看到下圖中最後一個表格: Analysis of Maximum Likelihood Estimates ，分別列出每個變項的估計值與p-value
intercept (截距)\ pregnant \ glucose \ triceps \ mass 的估計值分別為:
-8.1542 \ 0.1357 \ 0.0342 \ -0.00429 \ 0.0854 (可以發現跟上一篇文章 使用R的估計值是一樣的喔)

而我們可以將邏輯迴歸模式寫為下:
logit(p)=-8.1542+0.1357 pregnant +0.0342 glucose -0.00429 triceps+ 0.0854 mass

並且可以看到p-value，也是只有triceps 沒有顯著，其他三個變項都有顯著，代表這三個變項與Y有關係

而勝算比(OR)=exp(b)

而勝算比SAS已經算好給我們了，在最後一個表格中(Odds Ratio Estimates and Wald Confidence Intervals ) 分別有pregnant \ glucose \ triceps \ mass的Odds Ratio，並且有Odds Ratio的95%信賴區間

就 pregnant 而言，勝算比=exp(0.1357)=1.145
表示每增加一次懷孕次數，得到糖尿病的勝算提高1.145倍；
就 glucose而言，勝算比=exp(0.0342)=1.035 
表示每增加一血漿葡萄糖濃度，得到糖尿病的勝算提高1.035倍；
就 mass 而言，勝算比=exp(0.0854)=1.089
表示每增加一體重指數，得到糖尿病的勝算提高1.089倍；

好~ 多變項的羅吉斯迴歸就講到這裡，接下來要介紹單變項的羅吉斯迴歸

單變項羅吉斯迴歸(univariate logistic regression)

使用同樣的資料，這次我們想要看 pregnant \ glucose \ triceps \ mass 這幾個變項單獨對資料的影響

其實只要將資料單獨丟到proc logistic 就可以了，但這邊當然不會這邊簡單

下面的程式使用macro ，macro 在SAS中可以執行重複的程式，這樣就可以省一點程式，看起來也比較乾淨喔

macro 的第一句和最後一句，必須放上 %macro 和%mend; 
%macro 後的uni1 為macro 的名字，var 為變項(在程式中的var前面要加 &var 喔)

%macro uni1(var);
proc logistic data=MYDATA ;
model diabetes(event='1')=&var/CLODDS=wald;
run;
%mend;

寫好macro 之後，就可以使用了，執行macro時，記得前面要加%喔

%uni1(pregnant);
%uni1(glucose);
%uni1(triceps);
%uni1(mass);

這邊就只印出 %uni1(pregnant); 的結果，與上面一樣的就不重複印出來了

如果只有一個變項(pregnant)在模型中，intercept (截距)\ pregnant 的估計值分別為:-1.1766 \ 0.1371 ，並且pregnant是顯著的(因為p-value <0.0001)

pregnant的Odds Ratio 是1.147 ，95%CI = (1.097,1.200)
就 pregnant 而言，勝算比=exp(0.1371)=1.147
表示每增加一次懷孕次數，得到糖尿病的勝算提高1.147倍

單變項羅吉斯迴歸 vs 多變項羅吉斯迴歸

(univariate logistic regression vs multivariate logistic regression)

有發現嗎? 其實將變項單獨丟到proc logistic 就可以算單變項的羅吉斯迴歸了，[R]也是一樣的方式 (將單獨的變項都到模型裡面，就可以算了)

那位什麼需要做單變項或多變項的羅吉斯迴歸呢?

第一，單變項羅吉斯迴歸可以看到單個變項對自變項(Y)的影響，還有Odds ratio (勝算比)
第二，可以利用多變項羅吉斯迴歸看到所有變項互相影響後對自變項(Y)的影響與Odds ratio (勝算比)

最後，我們可以知道單個變項與多個變項對於自變項(Y)的影響，這當然有利我們挑選模型，可以做stepwise 等等相關的logistic regression

好了，今天的[SAS] logistic regression就講到這裡，也順帶講到了單變項羅吉斯迴歸 vs 多變項羅吉斯迴歸，如果這篇反映不錯的話，之後可以來介紹如何使用stepwise的羅吉斯迴歸

謝謝收看

1 comment
2 FacebookTwitterPinterestEmail
機器學習

機器學習自學筆記08: Backpropagation

by wenwu

機器學習自學筆記08: Backpropagation

今日的課程來自於: https://youtu.be/CXgbekl66jc
參考筆記:https://github.com/Sakura-gh/ML-notes/blob/master/ML-notes-pdf/8_Deep%20Learning.pdf

Backpropagation(反向傳播)是一種 gradient descent，也是一種演算法。Backpropagation 就是告訴我們用 gradient 吃來 train一個 neural network 的時候該怎麼做，他只是求微分的一種方式，而不是一種新的算法。

我們在使用 gradient descent 的時候可能會用到上千萬筆的參數，而我們可以使用backpropagation有效率的算出來。backpropagation並不是一個和gradient descent 不同的方法，他就是gradient descent ，他只是一個比較有效率的算法。

Chain Rule

backpropagation裡面並沒有什麼高深的數學，只需要記得的就是chain rule
對整個neural network，我們定義一個 loss function: L(θ) 等於所有的training data的loss總和

對L(θ)偏微之後，可以得到下面的式子:

接下來我們就不用計算 ∂L(θ)/∂w ，可以計算所有的∂l^n(θ)/∂w ，最後再總和起來

而現在的問題是∂l/∂w 該怎麼算，我們可以把它拆成兩項: ∂l/∂w=∂z/∂w * ∂l/∂z

前面這項比較簡單 (∂z/∂w) ，方法叫做Forward pass; 而求後面這項的方法比較複雜(∂l/∂z)，稱之為Backward pass

Forward pass

∂l/∂w=∂z/∂w * ∂l/∂z 中，考慮前面這項∂z/∂w，他的結果可以馬上算出來。因為 z=x1w1+x2w2+b，所以z的偏微是: ∂z/∂w1 = x1，∂z/∂w2 = x2。

其實他有一個規律，就是∂z/∂w=w前面連結的input值。

(好了 forward pass 講完了)

Backward pass

再考慮∂l/∂z這一項，它是比較複雜的，這裡假設activation function 是sigmoid function

在下圖中，z 通過 activation function 得到 a ，這個neuron的output 是 a = σ(z)，a 乘上 weight w3 得到 z’，a 乘上 weight w4 得到 z’’

我們想要求的 ∂l/∂z可以寫成 : ∂l/∂z = ∂a/∂z*∂l/∂a 
 ∂a/∂z 實際上就是 activation function 的微分(在這裡就是sigmoid function 的微分)。a = σ(z)，而 ∂a/∂z = σ’(z) ，而σ’(z) 就是一個常數。

再來就是求∂l/∂a ，因為 a 會影響 z’ 和 z’’，z’ 和 z’’會影響 l ，所以通過chain rule 可以得到

這裡的 ∂z’/∂a =w3，∂z’’/∂a =w4，而 ∂l/∂z’ 和 ∂a/∂z’’ 就要再最後面解釋了。假設我們知道∂l/∂z’ 和 ∂a/∂z’’，就可以將 ∂l/∂z寫成下面的形式 :

最後我們需要解決的問題是: ∂l/∂z’ 和 ∂a/∂z’’這兩項 ，假設兩種不同的case

Case1: output layer

假設藍色的neuron已經是hidden layer 的最後一層了，也就是說連接在z’ 和 z’’ 後的這兩個紅色的neuron已經是output layer ，它的output就已經是整個network 的output 了，這時候就會比較簡單。

因為最後的output 為 y1 & y2 ，所以可以將∂l/∂z’ 寫成∂y1/∂z’ * ∂l/∂y1 
其中，∂y1/∂z’ 就是output layer 的activation function (softmax) 對 z’ 的偏微分
而∂l/∂y1就是loss 對 y1的偏微分，他取決於你的loss function是怎麼定義的，也就是你的output和target之間是怎樣evaluate 的，你可以用cross entropy，也可以用mean square error ，用不同的定義，∂l/∂y1的值就不一樣。

這時我們已經可以算出l對w1 &w2 的偏微分值了

Case2: Not Output Layer

假設現在紅色的neuron並不是整個network的output，那 z’ 經過紅色neuron的activation function 得到 a’ ，然後 a’ 乘上w5、w6，得到 za、zb ，如下圖所示:

和先前的方法類似，如果知道 ∂l/∂za 和 ∂l/∂zb，我們就可以計算∂l/∂z’。並且知道z’和z’’就可以知道z ……，這個過程反覆進行下去，直到找到output layer 就可以算出確切的值，在一層一層反推回去

聽起來很驚人，要一層一層算要算到何時??

只要算一個方向，從output layer 的 ∂l/∂z 開始算，你就會發現它的運算輛跟原來的network的Feedforward path 其實是一樣的

Example

假設我們現在有6個neuron，每一個neuron的activation function的 input 分別為 z1~ z6，我們要計算 l 對這些 z 的偏微分，按照原來的思路，我們想知道z1 的偏微分，要去算z3 和 z4 的偏微分，想要知道z3 和 z4 的偏微分，就要在算z5 和 z6 的偏微分才能知道z1 的偏微分

反觀，若是先計算z5 和 z6 的偏微分，這個過程就變得有效率了。我們先計算z5 和 z6 的偏微分，就可以算出z3 和 z4 的偏微分，最後就可以得到z1 和 z2 的偏微分。這一整個過程，就像下圖:

在做backward pass 的時候，實際上的做法就是件另一個neural network，本來正向neural network 裡面的activation function 都是sigmoid function，而現在backward pass 的時候，就是建一個反向的neural network ，它的activation function就是一個運算放大器op-amp，每一個反向neuron的input 是loss l 對後面一層layer的z 的偏微分 ∂l/∂z ，output則是loss l 對這個neuron的z 的偏微分 ∂l/∂z，做Backward pass 就是通過這樣一個反向neural network 的運算，把loss l 對每一個neuron的z 的偏微分∂l/∂z 都給算出來

Summary

最後，我們總結一下Backpropagation 是怎麼做的，Backpropagation分成兩個步驟:

Forward pass 每一個neuron 的activation function 的output，就是他所連結的weight 的 ∂z/∂w

Backward pass 建一個與原來方向相反的neural network，它的三角形neuron的output 就是 ∂l/∂z，把通過forward pass 得到的 ∂z/∂w 和通過backward pass 得到的 ∂l/∂z 乘起來就可以得到 l 對 w 的偏微分 ∂l/∂w

今天的筆記就到這裡，我覺得老師講的很清楚

0 comment
0 FacebookTwitterPinterestEmail
機器學習

機器學習自學筆記07: Deep Learning

by wenwu

機器學習自學筆記07: Deep Learning

今日的課程來自於: https://youtu.be/CXgbekl66jc
參考筆記:https://github.com/Sakura-gh/ML-notes/blob/master/ML-notes-pdf/8_Deep%20Learning.pdf

實際上，Deep learning跟machine learning一樣，也是“大象放進冰箱”的三個步驟：在Deep learning的step1 和 define的function，就是neural network

Neural Network

把多個Logistic Regression前後連結在一起，然後把一個Logistic Regression稱之為neuron，整個稱之為neural network
我們可以用不同的方法連接這些neuron，就可以得到不同的structure，neural network里的每一個 Logistic Regression 都有一組weight和bias，這些weight和bias集合起来，就是這個network的 parameter，我們用θ來描述

Fully Connect Feedforward Network

該怎麼把他們連接起來呢? 這是需要你手動去設計的，最常見的連接方法叫做Fully Connect Feedforward Network (全連接前饋網路)

如果一個neural network的參數weight和bias已知的話，它就是一個function，它的input是一個 vector，output是另一個 vector，這個 vector裡面放的是樣本點的feature，vector的dimension就是feature的個數

如果今天我們還不知道參數，只是定出了這個 network的structure，只是決定好這些 neuron該怎麼連接在一起，這樣的一個 network structure其實是define了一個 function set(model)，我們给這個 network設不同的参数，它就變成了不同的function，把這些可能的function集合起來，我們就得到了一個function set

只不過我们用neural network決定 function set的時候，這個 function set是比較大的，它包含了很多原來你做 Logistic Regression、做linear Regression所没有辦法包含的function

上圖中，每一排表示一個layer ，每一個球都代表一個neuron

  • layer 和 layer 之間 neuron是兩兩互相連接的，layer 1的neuron output 會連接给 layer 2的每一個 neuron作為 input
  • 對整個 neural network 來說 ，它需要一個 input，這個 input就是一個feature的vector，而對 layer 1的每一個 neuron來說 ，它的input就是input layer的每一個 dimension
  • 最後的layer L，由於它後面没有接其它東西了，所以它的output就是整個network的output
  • 每一個layer 都是有名子的，最前面叫做 input layer ，中間的叫hidden layer ，最後面叫做output layer
  • 每一個neuron裡面的sigmoid function ，在deep learning 被稱為activation function (激勵函數)(事實上不一定是sigmoid function ，還可以是其他function)
  • 很多層layers 的neural network，被稱為DNN(deep neural network)

Fully connected 的network : layer和layer 之間，所有的neuron都是兩兩相接
Feedforward network : 傳遞的方向是從layer 1→2→3 ，由後往前傳

Matrix Operation

network的運作過程，我們通常會用matirx operation來表示，以下圖為例，假設第一層 hidden layers 的兩個 neuron，它們的 weight 分别是w1=1, w2=-2 ,w1’=-1, w2’=1，那就可以把它們排成一個 2*2 matrix
而我們的input 又是一個 2*1的vector：[1,-1]’ ，將w和x相乘，再加上bias的vector：[1,0]’ ，就可以得到這一層的vector z，再經過activation function得到這一層 的output：

(activation function可以是很多類型的function，這裡還是用Logistic Regression遷移過來的sigmoid function作為運算)

這裡我們把所有的變量都以matrix的形式表示出来，注意W^i的matrix，每一行對應的是一個neuron的weight，行數就是neuron的個數，而input x，bias b和output y都是一個列向量，行數就是feature的個數(也是neuron的個數，neuron的本質就是把feature transform到另一個 space)

把這件事情寫成矩陣運算的好處是，可以用GPU加速，GPU對matrix的運算是比CPU要來的快的，所以寫neural network的時候，習慣把它寫成matrix operation，然后call GPU來加速它

Output Layer (Multi-class classifier)vs Hidden Layer (feature extractor)

我們可以把 hidden layers看做是feature extractor(特徵提取器)，feature extractor就取代了我們之前手動做feature engineering or feature transformation，經過這個feature extractor得到的就可以被當作一組新的feature

output layer做的事情，其實就是把它當做一個Multi-class classifier，它是拿經過feature extractor轉換後的那一組比較好的feature(能夠被很好地分類)進行方類的，由於我們把output layer看做是一個Multi-class classifier，所以我們會在最後一個 layer加上softmax

Example Application

Handwriting Digit Recognition

這裡舉一個手寫數字識別的例子，input是一張圖片，對機器來說一張image實際上就是一個 vector，假設這是一張16*16的image，那它有256個pixel，對machine来说，它是一個256维的vector，圖中的每一個都對應到vector中的一個dimension，簡單來說，我們把黑色的pixel的值設為1，白色的pixel的值設為0

而neural network的output，如果在output layer使用了softmax，那它的output就是一個突出極大值的Probability distribution，假設我們的output是10維的話(10個數字，0~9)，這個output的每一維都對應到它可能是某一個數字的機率，實際上這個neural network的作用就是計算這張image成為10個數字的機率各自有多少，機率最大(softmax突出極大值的意義所在)的那個數字，就是機器的預測值

在這個手寫字體識別的demo裡，我們唯一需要的就是一個function，這個function的input是一個256維的vector，output是一個10維的vector，這個function就是neural network(這裡我們用簡單的Feedforward network)

input固定為256維，output固定為10維的feedforward neural network，實際上這個network structure就已經確定了一個function set(model)的形狀，在這個 function set 裡的每一個 function 都可以拿來做手寫數字識別，接下来我們要做的事情是用gradient descent去計算出一組參數，挑一個最適合拿来做手寫數字識別的function

input、output的dimension，加上 network structure，就可以確定一個model的形狀，前兩個是容易知道的，而決定這個 network的structure則是整個Deep Learning中最關鍵的步驟

如果你的network structure設計的很差，這個function set裡面根本就没有好的function，那就會像大海撈針一樣，結果針並不在海裡

Step 1: Neural Network

input 256維，output 10維，以及自己design的network structure →function set(model)

Step 2: Goodness of function

定義一個function的好壞，由於現在我們做的是一個Multi-class classification，所以image為數字1的 label “1”告訴我們，現在的target是一個10維的vector，只有在第一維對應數字1的地方，它的值是1，其他都是0

input這張image的256個pixel，通過這個neural network之后，會得到一個output，稱為y；而從這張image的label中轉化而來的target，稱為y^，有了output y 和target y^ 之後，要做的事情是計算它們之間的cross entropy(交叉熵)，這個做法跟我們之前做Multi-class classification的時候是一樣的

Step 3: Pick the best function

接下來就去調整參數，讓這個cross entropy越小越好，當然整個training data裡面不會只有一筆data，你需要把所有data的cross entropy都sum起来，得到一個total loss L ，得到loss function之後你要做的事情是找一組network的parameters： θ*，它可以minimize這個total loss，這組 parameter對應的function就是我們最終訓練好的model

那怎麼去找這個使total loss minimize的呢？使用的方法就是我們的老朋友 — — Gradient Descent
實際上在deep learning裡面用gradient descent，跟在linear regression裡面使用完全没有什麼差别，只是function和parameter變得更複雜了而已，其他事情都是一模一樣的

现在你的θ裡面是一大堆的weight、bias參數，先random找一個初始值，接下来去計算每一個參數對 total loss 的偏微分，把這些偏微分全部集合起来，就叫做gradient，有了這些偏微分以後，你就可以更新所有的參數，都減掉learning rate乘上偏微分的值，這個process反覆進行下去，最終找到一组好的參數，就做完deep learning的training了

Why Deep?

為什麼我們要deep learnings呢?一個很直覺的答案是，越deep，performance就越好，一般來說，隨著deep learning中的layers數量增加，error率不斷降低

結果是可想而知的，因為本來model的parameter越多，它cover的function set就越多，它的bias就越小，如果今天你有足夠多的training data去控制它的 variance，一個比較複雜、參數越多的model，它performance比較好，是很正常的，那變deep有什麼特别了不起的地方?

甚至有一個理論是這樣說的，任何連續的function，它input是一個N維的vector，output是一個M維的vector，它都可以用一個hidden layer的neural network來表示，只要你這個hidden layer的neuron夠多，它可以表示成任何的function，既然一個hidden layer的neural network可以表示成任何的function，而我們在做machine learning的時候，需要的東西就只是一個function而已，那做deep有什麼特殊的意義呢？

所以有人說，deep learning就只是一個噱頭而已，因為做deep感覺比較潮，如果你只是增加neuron把它變寬，變成 fat neural network，那就感覺太“虛弱”了，所以我们要做deep learning，给它增加 layers而不是增加 neuron：DNN(deep) is better than FNN(fat)

真的是這樣嗎? 後面的章節会解釋這件事情

Design network structure V.s. Feature Engineering

最後李宏毅老師與我們討論 Design network structure V.s. Feature Engineering的經驗談

其實network structure的design是一件蠻難的事情，我們到底要怎麼決定layer的數量和每一個layer的 neuron的數目呢?
其實這個只能夠憑著經驗和直覺、多方面的嘗試，有時候甚至會需要一些domain knowledge(專業領域的知識)，從非deep learning的方法到deep learning的方法，並不是說 machine learning比較簡單，而是我們把一個問題轉化成了另一個問題

本來不是deep learning的model，要得到一個好的結果，往往需要做feature engineering(特徵工程)，也就是做feature transform，然後找一組好的feature；一開始學習deep learning的時候，好像會覺得 deep learning的layers之間也是在做feature transform，但實際上在做deep learning的时候，往往不需要一個好的feature ，比如說在做影像辨識的時候，你可以把所有的pixel直接丢進去，但是在過去做圖像識別，你是需要對圖像抽取出一些人定的feature出來的，這件事情就是feature transform，但是有了deep learning之後，你完全可以直接丢pixel進去硬做

但是，今天deep learning製造了一個新的問題，它所製造的問題就是，你需要去design network的structure，所以你的問題從本來的如何抽取feature轉化成怎麼 design network structure，所以deep learning是不是真的好用，取決於你覺得哪一個問題比較容易

0 comment
0 FacebookTwitterPinterestEmail
機器學習

什麼? 一連串的Logistic regression 就是類神經網路(Neural Network)，也就是Deep Learning !

by wenwu

什麼? 一連串的Logistic regression 就是類神經網路(Neural Network)，也就是Deep Learning !

好吧! 原諒我下的標題，但這就是我剛剛聽完 這堂課logistic regression 的反應。

寫了文章快一年，版上最受歡迎的文章就屬於 [R]Logistic Regression 羅吉斯迴歸 ，相信有很多想學習Logistic regression 並且想了解如何應用它
如果你已經學會了Logistic regression，那麼代表你很有可能已經會使用Deep Learning 了 !

在 機器學習自學筆記06: Logistic regression 中提到該如何使用 Logistic regression 進行Machine Learning 的三個步驟，如果你會Logistic regression的話，就可以使用Machine Learning並進行分類

但是Logistic regression 是無法用在每一種情形的，我們知道Logistic regression 劃出來會是一條直線，很自然我們可以用這條線來分類，但是如果資料長的像下面這樣，可以使用Logistic regression 嗎?

Class 1 剛好在右下和左上， Class 2 剛好在左下和右上，我們無法找到一條”直線”來將這些資料分類。

但是想一想，可能剛好這組資料的feature 不方便我們使用，我們可以tranform 一下 !!

假設新的x1′ 是原本的點到 [ 0, 0] 的距離，x2′ 是原本的點到 [ 1, 1] 的距離，重新映射之後如下圖右側(紅色兩點重疊)，此時就可以用Logistic regression 來分類

有了新的feature，是不是就可以用 Logistic regression 來分類了

但麻煩的是，我們並不知道怎麼做feature transformation，如果在這上面花費太多時間就太可惜了，於是我們會希望這個 Transformation是機器自己產生的，怎麼讓機器自己產生呢?
我們可以讓很多 Logistic regression cascade (連接)起來

我們讓一個input x 的兩個feature x1、x2 經過兩個logistic regression的 transform ，得到新的feature x1’、x2′ ，在這個新的feature space 上， class 1 和 class 2 是可以用一條直線分開的，那麼最後只要再接上另外一個logistic regression 的 model ，根據最新的feature ，就可以將 class 1 和 class 2分類

因此這整個流程是，先用n個 logistic regression 做feature Transformation(n 為每個樣本點的feature數量) ，生成 n 個新的feature，最後再用一個logistic regression做分類

下圖是二維feature 的例子，分別表示四個點經過transformation之後的 x1’、x2’，在新的feature space 中可以通過最後logistic regression分類

通過上面的例子，我們發現: 多個 Logistic Regression連接起来會產生powerful的效果
我們把每一個 Logistic Regression叫做一個 neuron(神經元)
把這個 Logistic Regression串起來所形成的 network，就叫做 Neural Network
就是類神經網路，而這個東西 就是Deep Learning！

原來 一連串相連的 Logistic regression 就是 Deep Learning !!

不知道大家看完有什麼想法呢? 歡迎與我分享 
也可以參考我之前寫的 [R]Logistic Regression 羅吉斯迴歸
或是這篇文章的出處 機器學習自學筆記06: Logistic regression

0 comment
0 FacebookTwitterPinterestEmail
Load More Posts