[TIL] Effective way for git rebase

Before start to rebase:

git fetch origin

Pull latest code and start rebase:

git rebase origin/master

Start rebase

git rebase –continue … modify code. git add your_changed_code

Force push because tree different:

git push -f origin HEAD

To modify your commit to sq

git rebase -i origin

[Coursera] Deep Learning Specialization: Neural Networks and Deep Learning (三)

總算完成 deeplearning.ai 第一階段課程 “Neural Networks and Deep Learning”

真的相當有趣的基礎課程,基本上上完了就等於把o’reilly deep learning 的整本書都上完.並且有實際透過 numpy 寫完部分的 DNN 的分類器的作業.

起源

本來就想把 Deep Learning 學一下, 因緣際會下看到這一篇 Coursera 學習心得 試讀了七天,除了提供 Jupyter Notebook 之外,作業也都相當有趣,就開始繼續學了. 目前進度到 Week2 相當推薦有程式設計一點點基礎就可以來學.裡面的數學應該還好. 學習的過程中還可以學會 Python 裡面的 numpy 如何使用,因為裡面主要就是要教導你如何使用 numpy 來兜出 Neural Network .

課程鏈結: 這裡

學習鏈結:

課程內容:

第四週: Deep Neural Networks

基本符號解釋:

  • Deep Neural Network 的 Layer 數,不包括輸入層.有包括隱藏曾與輸出層.
  • 代表第幾層裡面的個數.
  • (輸入層) 通常也可以表示成

那麼簡單的式子可以表達成以下的方式:

其中別忘記

透過這樣,可以簡化成:

Where

Hyperparameters

用來決定 的都算是 hyperparameter ,舉凡:

  • Learning rate
  • Hidden layer and hidden Unit
  • Choice of activation function

關於 DNN 的 Layer 與 weight 的 shape

透過這張圖,其實有不少關於 Deep Neural Network 可以談的:

  • 這個 NN 總共有 5 Layer,其中有 4 Layer 是 Hidden Layer.不包括輸入層.
  • 每一層的 Neural 數為:
    • A^0 = 2
    • A^1 = 3
    • A^2 = 5
    • A^3 = 4
    • A^4 = 2
    • A^5 = 1
  • 其中 W 的 shape 個數分別為:
    • W1=(3,2)
    • W2=(5,3)
    • W3=(4,5)
    • W4=(2,4)
    • 推導出來表現方式為

舉個例子是:

推倒的式子為: Z1 = W1 * X + B1 [3,1] = W1 * X[2,1] + B1 (先假設 B1 = 0) => W1 * [2,1] = [3,1] => W1 –> [3, 2] –> [3, 2] * [2, 1] –> [3, 1] => W1 * X + B1 => B1.shape = W1*B1 = [3, 1]

總複習:

Init Parameter:
  • Init and
  • could not be zero, because it is hard to moving to balance.
    • shape:
      • W1: (input hidden layer size, input layer size)
      • WW: (output layer size, input hidden layer size)
      • ((l-1)layer dim, l layer dim)
  • suggest using zero for init values.
    • shape:
      • B1: (input hidden layer size, 1)
      • B2: (output layer size, 1)
Init deep parameters:
  • You need init every layer (W, B) as well.
Linear forward:
  • Caculate Z= WX + b
  • Need cache parameter cache = A, W, b
  • Need return Z, cache as wll
Linear Activation forward

use sigmoid or relu to transform your Z to activation (denoe: A).

use A_prev (A from previous layer) to get Z and transform to A.

L model forward
  • Caculate each hidden layer with relu activation function.
  • Use sigmoid as output layer activation
Compute cost

cost (J) = - 1/m \sum\limits_{i = 1}^{m} (y^{(i)}\log\left(a^{[L] (i)}\right) + (1-y^{(i)})\log\left(1- a^{L}\right)) \tag{7}$$

Backward propagation - Linear backward.

dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))

L-Model backward

dZ^[] = dA^[l] * g'(Z^[l])

Update parameters

W^[l+1] = W^[l+1] - learning_rate * dW^[l+1]

b^[l+1] = b^[l+1] - learning_rate * db^[l+1]

[Coursera] Deep Learning Specialization: Neural Networks and Deep Learning (二)

第三週拖得有點久,因為被抓去專心寫 code 啦 (吃手手

第三週的課程其實很有趣,學到了 back-propagation 也學到了一些 NN 的技巧

  • 如何有效設置初始權重
  • Activation function 該如何挑選

當然 Jupyter Notebook 也相當的好玩啊…

最後的大師採訪,是訪問 GAN 的發明者 Ian Goodfellow

起源

本來就想把 Deep Learning 學一下, 因緣際會下看到這一篇 Coursera 學習心得 試讀了七天,除了提供 Jupyter Notebook 之外,作業也都相當有趣,就開始繼續學了. 目前進度到 Week2 相當推薦有程式設計一點點基礎就可以來學.裡面的數學應該還好. 學習的過程中還可以學會 Python 裡面的 numpy 如何使用,因為裡面主要就是要教導你如何使用 numpy 來兜出 Neural Network .

課程鏈結: 這裡

學習鏈結:

課程內容:

第三週: Shallow neural networks

關於多個 Neural Network 的表達方式:

第一層:

第一層輸出:

第二層:

第二層輸出:

下標代表的是第幾個 Neuron

不同的輸入訓練資料 $ 1 … m $$

for i = range(1, m):
	#第一層
	#第一層輸出
	#第二層
	#第二層輸出

關於 Activation Function 的選用部分

這邊有篇文章很推薦”26种神经网络激活函数可视化“對於 Activation Function 有很多的著墨,在此筆記一下:

  • Sigmoid 對於二元分類監督是學習(也就是學習是不是某種物品,比如說是不是貓) 相當的有用.因為出來的數值是 0~1 的數值,你可以根據學習狀況給予一定的 Threshold
  • Tanh 會出現一個 -1~1 之間的數值,這樣學習可以變得更快.也可以但是對於二元分類的監督式學習不會比較好,於是也越來越多人將 Tanh 取代 Sigmoid

關於權重 (weight) 的初始化

在 NN 中,當你具有一個以上的 hidden layer 時,就必須要慎重的初始化你的起始權重 (w1) . 因為如果你的起始權重不是使用”亂數” 來作為初始化的話. 你的 hidden layer 的意義就不大,那是因為:

  • W1 = [0, 0, …] 那麼 A1 = X1 * W1 +b1 , A2=A1*W2 + b2 –> 當你的 b1, b2 也是 0 時.就會得到 A1=A2

  • 在做 back-propagation 也會沒有差別,造就整個 hidden layer 就沒有它存在的意義.

關於 Peer Assignment

這次的作業是做一個具有 back-propagation 並且具有一個 hidden layer 的 NN (當然依舊是使用 numpy )

但是跟之前不太一樣的部分是除了要完成 forward-propagation 之外,也必須要完成 back-propagation . 並且在 forward-propagation 中除了之前用過的 activation function (sigmoid) 之外也有使用到 (tanh) 的 activation function

採訪的部分 - GAN 發明者 Ian Goodfellow

這一篇訪問其實相當有趣,訪問到最近相當熱門的 GAN (生成對抗網路) 的提出者 Ian Goodfellow 來討論.當然, Ian 也是 Andrew Ng 的學生之一(原來大家都跟 Andrew 有關係)

裡面有提到, GAN 是他們在偶然討論中想出來的理論.但是 Ian 卻用一個晚上就把相關代碼準備好了.不過他自己也表示說,雖然 GAN 代碼可以很快完成,但是需要一個穩定的 GAN 卻是花費不少時間來讓他論文完整.

此外,大家應該也很好奇在那麼年輕就提出了 GAN ,並且寫了一本 Deep Learning 的書籍(就叫 “Deep Learning”),他的下一步會是什麼?

Ian 提到,他對於 Security on NN 相當有興趣.也就是如何避免使用一些假資料(或是惡意的資料)來讓 NN 失去準確度甚至是被惡意的判別錯誤.

很有趣的訪問,很推薦一看.

[TIL] Summarize about Mesos and Kubernetes

A slide to summarized some features comparison about Mesos and Kubernetes.

[TIL] Kubernetes Device Plugin

NVIDIA 官方 REPO: Kubernetes Device Plugin

說明:

Kubernetes 在設計上有著相當程度的擴充性,在當初有 plugin 的架構就可以看出來. 比如說: Network Plugin 讓 CNI 可以輕鬆地整合. 1.8 版剛開放 alpha 的新功能 “Device Plugin” 更強,可以讓 GPU, 高效能網卡, FPGAs 甚至是 InfiniBand 輕鬆的整合在 Kubernetes 之中

原本在 Kubernetes 內預設只能抓取到 CPU 與 Memory 的狀態(不然,就得很辛苦.. 你懂的) 但是透過了 Device Plugin 你就做以下的事情:

  • 輕易的讓 Kubernetes 內所有的 container 可以存取該裝置
  • 輕易抓取到 GPU (或是高效率網卡) 的訊息
  • 透過 Kubernetes 的 Health check 來檢查裝置狀態

有興趣的可以再看看 Kubernetes 文件: https://kubernetes.io/docs/concepts/cluster-administration/device-plugins/

[Coursera] Deep Learning Specialization: Neural Networks and Deep Learning (一)

起源

本來就想把 Deep Learning 學一下, 因緣際會下看到這一篇 Coursera 學習心得 試讀了七天,除了提供 Jupyter Notebook 之外,作業也都相當有趣,就開始繼續學了. 目前進度到 Week2 相當推薦有程式設計一點點基礎就可以來學.裡面的數學應該還好. 學習的過程中還可以學會 Python 裡面的 numpy 如何使用,因為裡面主要就是要教導你如何使用 numpy 來兜出 Neural Network .

課程鏈結: 這裡

學習鏈結:

課程內容:

第一週: Introduction to deep learning

  • 基本上就介紹 Machine Learning 與 Deep Learning 的基本常識. 比如說 (ReLU activation functionReLU activation function
  • 介紹了近幾年 Deep Learning 會如此發展快速的原因 (計算速度的進展..)
  • 最後有採訪 Geoffrey Everest Hinton (也就是將 Backpropagation 導入了 Deep learning 的人,並且發明了 Boltzmann machine ) .
    • 有不少有趣的事情,比如作者認為自己作出的 Boltzmann machine 很美麗,但是無法實作.
    • 所以後來作者加上了一些限制後,衍生出 restricted Boltzmann machine ,該系統就被 Netflix 拿來使用.

第二週: Neural Networks Basics

  • 從頭開始教,一開始就教導你什麼是 binary-classification .
    • 透過簡單的影像判斷是不是貓,來教導.
    • 透過不同的資料(R, G, B) 來判斷是不是貓.
  • 教導一些 Deep Learning 的基本:
    • Logistic Regression
    • Ligistic Regression Cost Function
    • Gradient Descent
    • Dervatives
  • 透過一個 Jupyter Notebook 來教導你如何透過 numpy 來寫一個簡單的二元分類器 (classifier) 來分辨輸入的圖片是不是貓. 實際流程是:
    • 先做一個 sigmoid function
    • 再來實作 propagate function.
      • 拿到 X
      • 做出 forward propagate:
        • 算出 A = sigmoid($$w^TX+b)
        • 再來算出 cost function J =
      • 再來做出 backward propagate:
        • 計算出 dw 與 db.
    • 再來要做 optimize function
      • 透過 gradient descent algorithm 來優化 w, b
      • 透過 iteration 的 loop
        • 透過 propagate 來找出新版的 dw, db
        • 透過 dw, db 來修正目前的 w, b
        • 進行下一回合的 propagate
    • 再來就要透過計算出來的 w, b 來預測 (predict) 是否是貓
      • 透過
      • 如果 A > 0.5 (threshold) 我們就認為這張圖片是貓
    • 整個 Model 的部分,就是做以下的事情:
      • 初始化 w, b (在此是設定為 0, 其實有更好的方式)
      • optimize 找出 w, b
      • 透過 w, b 來跑 predict
      • 作 training accuracy 鑑驗

我必須得說,最後這個 Jupyter Notebook 真的太有趣了…

NN 的常用符號解釋:

  • : 表示所有的訓練資料個數 (traning set)
  • : 每一個資料集中所具有的資料量
  • 並且
  • 代表是結果
    • (0: 代表不是, 1: 代表是)

關於一些 numpy 的基礎教學

由於這次課程不會用到比較複雜的 NN (Neural Network) 套件,而是直接使用 numpy 來打造一個 NN ,這裡有不少的 numpy 教學部份.有提到一些類似於:

import numpy as np

  • numpy 的 a=np.random.randn(5) 產生出來不是一個具有 transporm matrix 的 array 而是一個 a.shape = (5,)
    • 要正確產生一個 5,1 的 array 需要輸入 a=np.random.randn(5,1)
    • 建議加上 assert(a.shape==(5,1)) 作為檢查,確認沒有漏打.

透過 numpy 與 math 來學 sigmoid

import math

def basic_sigmoid(x):
    sig = 1 / (1 + math.e ** -x)
    return sig

由於 math 不能直接處理 array ,要改成 numpy

import numpy as np

def np_sigmoid(x):
    sig = 1 / (1 + np.exp(-x))
    return sig

usig numpy for norm

x_norm = np.linalg.norm(x, axis=1, keepdims=True)
normalize_x = x/x_norm

Softmax implement by numpy

def softmax(x):
    exp_x = np.exp(x)
    sum = np.sum(exp_x, axis=1, keepdims=True)
    s = exp_x/sum
    return s  
    

numpy 的效能評比

針對 vector 比較大量的時候,其實 numpy 的效能反而比起直接透過 for-loop 來運算快得多.並且整個代碼都清楚多了.

L1, L2 loss implement by numpy

def l1(yhat, y):
    loss= np.sum(np.abs(y-yhat))
    return loss
    
def l2(yhat, y):
    loss2= np.sum(np.dot(y-yhat, y-yhat))
    return loss2

記住 np.dot 是將兩個矩陣相乘,所有要求平方就是自己跟自己相乘.

使用 numpy 來做 propagate

# GRADED FUNCTION: propagate

def propagate(w, b, X, Y):
    m = X.shape[1]
    A = sigmoid( np.dot(np.transpose(w),X) + b )                                   # compute activation
    cost = -1 / m * np.sum( np.multiply(Y, np.log(A)) + np.multiply(1-Y, np.log(1-A)))
    
    dw = 1/m * np.dot(X, np.transpose(A-Y))
    db = 1/m * np.sum(A-Y)

    assert(dw.shape == w.shape)
    assert(db.dtype == float)
    cost = np.squeeze(cost)
    assert(cost.shape == ())
    
    grads = {"dw": dw,
             "db": db}
    
    return grads, cost

Numpy 裡面處理 matrix 需要注意的部分

  • 加法可以直接處理 [3,2] + [3,1]
  • 關於乘法(*) (跟 np.multiply 相同) 第一個維度需要相同
    • [4,3]*[3,1] –> Error
    • [4,3]*[4,1] –> [4,3]
      • 註解: 此狀況會產生 broadcasting
  • np.dot(): 注意第一個的第二維度需要跟第二個的第一維度相同(矩陣相乘)
    • np.dot([4,3], [3,1]) –> [4,1]
    • np.dot([4,3], [4,1]) –> Error

Interview with Pieter Abbeel

Pieter Abbeel 是處理 Deep Reinforcement Learning 的專家,這篇有提到他如何進行相關研究.