Google Calendar 定定出現歹物仔

最近, 我的 Google Calendar 定定出現莫名其妙的 "活動", 點入去親像按呢:

這文字看無， 共 "Вам поступил перевод " kok-pì (Copy) 起來, 貼入去 Google 翻譯，知影伊是露西阿 (Russia) 文。

當當我共伊揭挕捒，隔轉工伊閣出現，有時陣一出現就是規個月三十工滿滿，真齷齪，刣袂離。就愛想一个辦法來解決。

原來這活動是透過 Gmail 添入來个。Gmail 有一个功能是: 若有人寄邀請予你，伊就會自動添一个活動去 Google 曆日。就算我已經共彼張批擲入去糞埽桶(Trash) 抑是設做糞埽批(垃圾郵件) 嘛無路用。

後來揣著方法是按呢，這干焦會使踮桌面版的 Google 曆日設，袂使佇手機版的 Ep (App)

1. 揤正手頂懸，六齒的 Gí-a icon，出現 Mé-nìu (Menu) 了後，入去 一般設定 這个 Thé-phù (Tab)
2. 揣 "自動新增邀請"，共伊揤落，改做 "不, 只顯示我已經回覆的邀請"
3. 切過去 "畫面顯示設定"，揣 "顯示已拒絕的活動"，佇頭前的四角框，若是有一个勾勾仔，就共伊揤落去，予勾仔無--去。

毋過，我感覺上好的辦法是: 直接佇 Gmail ，設定 --> 篩選器和封鎖的地址 中方，共彼个電批 (Email) 的地址封鎖--起來。

倒退攄的煞鼓 -- 佮伊佮做伙

←前一篇 

到今，咱已經共所有倒退攄所需要的倒退攄攏搜揣出來，這馬是時機來共伊佮做伙。咱先來看伊的圖:

一棧一棧的實作，是囥佇 layers.py。

伊主要的程式，是囥佇 two_layer_net.py。

咱來斟酌解說一个:

    def __init__(self, input_size, hidden_size, output_size, weight_init_std = 0.01):
        # 開始攢好勢
        self.params = {}
        self.params['W1'] = weight_init_std * np.random.randn(input_size, hidden_size)
        self.params['b1'] = np.zeros(hidden_size)
        self.params['W2'] = weight_init_std * np.random.randn(hidden_size, output_size) 
        self.params['b2'] = np.zeros(output_size)

        # 共伊一棧一棧疊khi
        self.layers = OrderedDict()
        self.layers['Affine1'] = Affine(self.params['W1'], self.params['b1'])
        self.layers['Relu1'] = Relu()
        self.layers['Affine2'] = Affine(self.params['W2'], self.params['b2'])

        self.lastLayer = SoftmaxWithLoss()

這前半段佮神經網路的學習相siâng。

第二段是使用一个特別的資料結構: OrderedDict 來共一棧一棧整--起來。

啥乜是 OrderedDict 咧? 簡單講，伊是一款字典 (Dictionary)，毋過伊會共添入去的資料照順序排予好勢。原在字典內面的資料，是用 Khí(Key) 來揣出來，伊是無順序，由在 Python 家己去安排。按呢有啥乜好處? 小等你就知。

向前行

主程式是 gradient()，一開始就呼 (khoo/call) self.loss(x, t)，

    def gradient(self, x, t):
        # forward
        self.loss(x, t)

        # backward
        dout = 1
        dout = self.lastLayer.backward(dout)
        
        layers = list(self.layers.values())
        layers.reverse()
        for layer in layers:
            dout = layer.backward(dout)

        # 設定
        grads = {}
        grads['W1'], grads['b1'] = self.layers['Affine1'].dW, self.layers['Affine1'].db
        grads['W2'], grads['b2'] = self.layers['Affine2'].dW, self.layers['Affine2'].db

        return grads

這 loss() 就是共向前行(Forward propagation)，softmax 和 error function 一擺做到底。

    # x:入力データ, t:教師データ
    def loss(self, x, t):
        y = self.predict(x)
        return self.lastLayer.forward(y, t)

loss() 分兩步: predict() 佮 lastLayer.forward()，也就是共上尾彼 SoftmaxWithLoss() 另外做。

    def predict(self, x):
        for layer in self.layers.values():
            x = layer.forward(x)
        
        return x

predict() 嘛是有影簡單。一个 for 箍輾，照步來，去呼 layers 內面，逐棧的 forward() 函式。照頂懸 __init__() 所指定，就是照 Affine1， ReLU1, Affine2，一个一个呼伊的 forward()，共逐棧的輸出，成做會一棧的輸入。

這就是 OrderedDict 好用的所在，我毋免一个一个寫出來，用 for loop 就好。

倒退攄

佇 gradient() 內底，dout = 1 做參數開始，先呼上尾棧 lastLayer 的 backward()。紲落來這幾逝嘛是用  OrderedDict 的奇巧:

        layers = list(self.layers.values())
        layers.reverse()
        for layer in layers:
            dout = layer.backward(dout)

因為伊是照順序，我共伊的值捎出來，共伊顛倒反 (layers.revers())，閣用 for 箍輾，伊就是倒退攄囉。

結束了後，咱欲愛的 W1 和 W2 的改變，是囥佇 Affine layer 內底 (參考 layers.py 的 Affine Clase)， 所以愛共伊掠出來:

        grads['W1'], grads['b1'] = self.layers['Affine1'].dW, self.layers['Affine1'].db
        grads['W2'], grads['b2'] = self.layers['Affine2'].dW, self.layers['Affine2'].db

擲轉去。

轉去 20181028 這工

 20181028 這工是咱頭一擺來訓練神經網路。gradient() 就是囥佇 train_neuralnet.py 內面使用，咱得著的 grads, 是予伊用來改變 network_parameters: 

    grad = network.gradient(x_batch, t_batch)
    for key in ('W1', 'b1', 'W2', 'b2'):
        network.params[key] -= learning_rate * grad[key]

紲落來才閣進行下一擺的訓練。

uì 20181028 講到今嘛年外，講甲落落長，伊上重要的觀念就是共正港的數學微分，伊的運算方式，改用倒退攄的方法。倒退攄，其實就是共微分个運算拍破，分解做上基本的神經元有法度算。按呢生會使予會算數速度加有夠緊，按呢才有實用的價值。

寫到遮，應該共神經網路上基本的原理講到一个崁站矣。這个系列嘛欲踮遮到煞鼓矣。這本書: 

Deep Learning｜用Python進行深度學習的基礎理論實作 

後半段閣有袂少內容。毋過，完全共人用心血寫落來的書囥佇網路頂予人免費看，按呢嘛無好。向望逐家若是有興趣，會當去共伊交關一咧。

因為是利用做工課掠外，有閒的時間才寫，有當時閣會懶屍，所以進度真慢。總是，佇寫的時陣，才會了解台語欲寫專業的物件，會拄著啥乜困難，解決的方向是佗一爿? 加一个行業有人用台語寫作，就加一个行業的專有名詞會生--出來。各行各業攏有人用台語寫，台語才會健康生湠落去。特別是上新个智識，咱莫共家己母語限制佇厝內，抑是懷舊爾爾。

←前一篇 

Python Deep Learning 深學筆記 - Softmax 佮 Loss 的倒退攄

←前一篇     後一篇→

上尾, 咱欲討論輸出棧的倒退攄。

 uì 輸出棧 ê 一寡討論，知影分類問題用 softmax (Sòo-hu-mak-su)函數。所致，咱愛揣出 softmax 的倒退攄函式。
上尾，閣愛用 Loss 函式來算出精差是偌濟，親像這張圖:

因為這數學較複雜, 咱直接看伊的結果:

綠色是向前行, 藍色是倒退攄。
看著倒退攄是遐呢仔簡單的 y - t, 佮向前行 ê 時陣彼款複雜的算式比起來, 是夭壽簡單。會得著遮爾媠氣的結果，當然是揀著好用的 Cross Entropy Error 函式，佮 Softmax 會貼峇的結果。若有興趣，會當參考原書的附錄 A。

根據這結果，咱來看 Python 的 code 按怎寫, 參考 layers.py  中方的 class SoftmaxWithLoss:

class SoftmaxWithLoss:
    def __init__(self):
        self.loss = None
        self.y = None # softmax 的輸出
        self.t = None # 正確的答案

    def forward(self, x, t):
        self.t = t
        self.y = softmax(x)
        self.loss = cross_entropy_error(self.y, self.t)
        
        return self.loss

    def backward(self, dout=1):
        batch_size = self.t.shape[0]
        if self.t.size == self.y.size: # 這是 one-hot vector
            dx = (self.y - self.t) / batch_size
        else:
            dx = self.y.copy()
            dx[np.arange(batch_size), self.t] -= 1
            dx = dx / batch_size
        
        return dx

backward() 的 if 條件式內面, 就是 (y1 - t1), (y2 - y2), ... 的實做。毋過遮爾清氣的結果, 是佇
t 是 one-hot 的條件之下。啥乜是 one hot 呢? 咱來回想 MNIST 資料集中方, load_mnist() 介紹有紹介.

若是 else 彼爿就較複雜, 我現此時嘛毋知影。因為咱目前用的 MNIST 資料是 one hot, 就先按呢行落去。

上尾愛講予斟酌的所在是: backward(self, dout=1). dout = 1, 是因為當當咱算出 dL (delta L), 成做倒退攄的輸入的時陣，若是 dL 大, 就表示離標準答案差較遠。dL 細, 就較倚標準答案。所以咱會向望 dL 大的時陣，倒退攄的輸入嘛愛大，予伊刺激較強。所以根據得著的 dL，咱會用 dL/dL = 1 來做為倒退攄的輸入。

←前一篇     後一篇→

Python Deep Learning 深學筆記 - Affine 棧佮 Sigmoid

←前一篇    後一篇→

咱了解倒退攄演算法, 其實就是利用計算圖來共一个點的計算分拆, 成做上基本的數學式, 現此時就是愛共這寡基本運算的倒退攄公式揣出來, 才閣共 in 合起來。前一篇是分析，這篇是欲討論佮做伙。

A-hainn棧 (Affine Layer) 的觀念

Affine (華語: 仿射, 台語暫時用音譯: A-hainn) 是幾何學的名詞，Affine transformation 就是共一組點, 線, 抑是平面，對一個空間, 轉換到另一個空間。

這兩個空間是有關係的。

簡單舉一个例: 日落山的時陣，日頭光共你的影炤甲長ló-ló。嘛共你身軀邊的愛人的影炤甲長長長。日頭就是彼个 A-hainn  函式，共你佮你的愛人, 活佇真實世界的人，成做 (transform) 平面的影。

影佮你是有關係, 你振動, 伊嘛振動。你兩个徛做伙，影嘛黏牢牢。

影佮你是無仝--ê。伊無面無喙，干焦深淺無仝的烏，佇平面活動。

普通 A-hainn 運算，是矩陣 (Matrix)運算。

對另一個角度來講，就是共一組數字，透過固定的方式 (function, 函式), 成做另一組數字。

所以，神經網路對輸入，一棧一棧, 向前行的演算法，做 dot 運算閣加法:

X ● W1 + B1 = A1
h(A1) = Y

這款矩陣 Dot 運算, 也就是一種 A-hainn 運算。

Dot 運算的計算圖

加法真簡單, 咱來看  X* W = Y 就好.
透過計算圖來分拆:

伊的倒退攄是:

其中

• Δ 是 diff 的意思。因為數學符號僫拍, 有時用字母 d 代替.
• 細个 T 佇 W 抑是 X 的正手爿較懸, 是Matrix 的斜倒反(Transpose, 音譯: Tsuán-su-pho-su, 簡單寫做 Tsuán-su-pho)。有時為著簡單拍字, 嘛寫做 ^T.

愛注意: 佇 Dot 運算, 順序是要緊的. X ● W 袂使寫做 W ●  X. 當然, 你欲做甲真幼, 來推算 Dot 的倒退攄嘛是會使。彼是滿滿的數學.

啥乜是斜倒反咧? 咱回想 2 維陣列 ê 運算是有維度个, 準講 2x3 的 Mé-tshuì, 伊的倒反就是:

沿伊的對角線共伊反--過來, 成做 3x2 的 Mé-tshuì。

你若閣有印象, 伊略略仔有成乘法的倒退攄: 就是對輸入 X 來講, 攄轉來的變化，是受著另一爿輸入 W 的影響(乘法時是乘以 W 倍, Dot 運算時是 dot)。仝理, W 嘛是受著 X 的影響。咱就無閣詳細分拆這過程。咱注心來看為啥物欲有這个 Transpose。
其實，這是 uì 陣列的 dot 運算，算倒轉來需要个: 咱回想 Dot 運算的這張圖:

咱若是欲算轉來, uì [ [50, 68], [122, 167]] 顛倒反算轉來 [[1, 2, 3], [4, 5, 6]] 欲按怎做呢? Mé-tshuì 無除法, 伊的逆運算是揣出一个 Mé-tshuì, 共結果 dot 這个 Mé-tshuì 會當得著原來的 Mé-tshuì，彼个型是:

X 的維度是偌濟呢? 咱 uì Matrix ê Dot 運算知影: 

• dot 倒手爿Mé-tshuì 幾逝 (row)  , 等號 (=) 算出來的 Mé-tshuì  就幾逝

• dot 正手爿Mé-tshuì 幾欄(column),  等號 (=) 算出來的 Mé-tshuì  就幾欄

所致，咱會當推算出來 X 的型是 2x3:

拄好就是原在 3x2 的斜倒反。當然，a1~a3, b1~b3 和原來的數字無仝，這你會使一个一个去算。
重點是: 咱佇遮欲解說的是: 倒退攄uì顛倒頭算轉來，因為輸入佮輸出的維度攏愛維持，中方使用著的 Mé-tshuì 就愛共伊對角反過來，這我共伊號做 "斜倒反(tshiâ-tó-ping)".


伊的寫法, 就是佇 layers.py 內面的 class Affine。

Softmax 的倒退攄

這若是學過微積分 (Calculus), 就會曉知按怎共伊算出來. 咱佇遮共伊直接寫落來:

閣小可整理一个, 就成做:

當然, y, 就是佇遮寫過个 y = 1/(1+exp(-x))。為啥物欲做這款的變化? 因為按呢較簡單算。y 的值佇向前行 (forward propagation) 就算出來矣, 咱倒退攄時，干焦做乘法當然比平方(pîng-hong) 閣指數(kí-sòo) 加真簡單。參考 layers.py 的 class Sigmoid 的 backward() 函式, 是毋是真屧貼?

←前一篇    後一篇→

Python Deep Learning 深學筆記 - 基本運算个倒退攄

←前一篇    後一篇→

咱uì前一篇知影倒退攄演算法个概念，透過計算圖, 咱會當知影目的就是揣出 +, dot, sigmoid (抑是其他戛火函式) 个倒退攄運算。毋過, 事事項項攏愛uì上基本个所在來起造. 比如講: dot 運算本身乘(*)佮加(+) 整--起來.  這就是 "分而治之" 的手路.

加法倒退攄

若是  z = x + y:

伊的微分是 dz/dx = 1， dz/dy = 1。也都是 x 變 1, z 嘛綴伊仝款變 1. x (抑是 y) 變偌濟, z 就變偌濟。顛倒頭講, z  變偌濟 ，x (抑是 y) 就變偌濟,  所以伊的倒退攄是:

乘法倒退攄

若是 z = x * y, 伊的計算圖 :

伊的偏微分:   ∂z/∂x = y,  ∂z/∂y = x, 所以, 伊的倒退攄算法是:

咱會使按呢來了解: uì x 這爿來講, 伊小可變化, 對輸出个影響是會有 y 倍。仝款个道理, y 小可變化, 會有  x 倍个變化。咱舉一个實際个例, 比如講: 10 * 2 = 20:

咱若是用  1 來做倒退攄个輸入, 照咱推理模型:

x 爿是 2, y 爿是 10. 這意思是講:

若是 x 變做 10 + 1 = 11, z 會成做 20 + 2 = 22
若是 y 添 1 成做 2 + 1 = 3, z 會變做 20 + 10 = 30.

按呢敢著咧? 咱看覓: 本底 10 * 2 = 20

(10 + 1) * 2 = 11 * 2 = 22 = 20 + 2
10 * (2+1) = 10 * 3   = 30 = 20 + 10

這是完全對同。

到今咱會當了解: 倒退攄演算法, 窮實就是先共基本運算个微分模型算出來。

伊代表个意義是: 輸入个一絲絲仔改變, 會造成輸出偌濟變化! 這就是微分个概念, 精差普通微分是對倒爿算到正爿, 倒退攄是對正爿算轉去倒爿!

動手用 Python 來實作

理論分析了, 咱參考 layer_naive.py: 伊用 class 來共向前行(forward propagation) 佮倒退攄(backward propagation) 敆做伙, 成做一棧: AddLayer() 是加法棧, MulLayer() 是乘法棧. 伊的寫法真直觀, 家己看就知.

因為 ReLU 佮 Sigmoid 的倒退攄攏是數學, 我就干焦共in的算式寫落來. 詳細按怎算, 你會使去看原作者的書, 抑是其他數學的冊。

ReLU 棧的倒退攄

y = x (if x > 0)

y = 0 (if x < 0)

伊的倒退攄是:

dy/dx = 1 (if x > 0)

dy/dx = 0 (if x < 0)

伊的 Python 實作參考 layers.py 的 Relu Class。

Sigmoid 棧的倒退攄

y = 1/(1+exp(-x))

伊的倒退攄是 (d表示 delta):

dx = y * ( 1 - y) * dL

中方  dL 是 y 彼爿的變化。當然，這咧公式較複雜，經過幾落改轉換。這寡轉換目的是愛佇最後，會使用 y 來表示。因為 y 是彼擺向前行算出來的值， 咱欲攄轉來的 dx 佮伊有關係。

伊的 Python 實作參考 layers.py 的 Sigmoid Class。

←前一篇    後一篇→

Python Deep Learning 深學筆記 - 倒退攄演算法簡介

←前一篇    後一篇→

倒退攄演算法 (Back Propagation) 是相對向前行演算法 (Forward Propagation) 个專有名詞. 伊是用來解決微分抑是梯度法傷過食時間个問題。

啥物是向前行演算法 (Forward Propagation)

向前行演算法, 就是咱一直講到今, uì 輸入, 第一棧, 第二棧, 到輸出个神經網路. 咱攏已經學過啊嘛奕過.

伊就是前一篇內面 predict() 函式做的代誌, 抑就是神經網路 uì 輸入 (input), 經過一棧一棧个神經元, 到輸出 (out) 這个過程, 咱若參考這篇: 

3 棧 ê 神經網路, 伊會使用這組函式來表示:

A1 = np.dot(X, W1) + B1
Z1 = sigmoid(A1)

A2 = np.dot(Z1, W2) + B2
Z2 = sigmoid(A2)

A3 = np.dot(Z2, W3) + B3
y = identity_function(A3)

當然, 後來 identity_function() 是用 softmax() 函式來取代. 伊是 uì 輸入 X 行到輸出 y.

若是畫圖, 是按呢生:

伊箭頭个方向, 攏是 uì 倒爿行到正手爿, 這就是向前行演算法會計算圖(computational graph).

咱會使看著, 逐个圓箍仔, 攏是確定个數學算式, dot, +, sigmoid 這寡運算 (operation).

倒退攄演算法是想欲tshòng啥物咧?

咱翻頭來想咱為啥貨欲學微分和梯度?

目的是當當(tng-tong) 咱uì一擺學習 X0 得著 Y0 這个結果. 咱若共 Y0, 變一屑屑仔, 咱共伊寫做 dY (delta Y), 閣揣出 dX (delta X), 咱就會得著 dY/dX  這个斜率/梯度. 咱就有法度決定對佇一个方向徙振動, 會予 Y 收縮, 行向咱想欲挃的值.

微分佮梯度是完全照數學理論, 干焦了解數學理論, 你就了解伊佇創啥貨. 毋過實際傷開時間, 無實用.

咱用另外一款思考, 有法度親像向前行演算法相siâng, 一節一節算過去, 按呢咧?

若有法度揣著內面逐點(圓箍仔) 个倒退攄个運算, 按呢咱是毋是就會當得著: dY/dX, dY/dW, dY/dB1, ..., 這寡微分/梯度咧? 當然, 咱上注心是 揣出 dW1, dW2 欲變uì佗位去.

內面逐點, 我加一个問號 "?", 就是咱紲落來个欲解決个問題: 除了用計算圖解說倒退攄演算法會用得, 閣愛一个一个揣出 dot, +, sigmoid, ... 等等个運算欲按怎倒退攄?

←前一篇    後一篇→

Python Deep Learning 深學筆記 - 完全照微分理論會拄著的問題

←前一篇    後一篇→

咱來走看覓

咱進前介紹个 5 个步序 ， 踮 two_layer_net.py  共伊分別實作予好, 佇 train_neuralnet.py 共這五个步事整起來, uì 頭迵到尾, 行看覓:

$ python3 train_neuralnet.py 
train acc, test acc | 0.0903, 0.0899
train acc, test acc | 0.7732833333333333, 0.7781
train acc, test acc | 0.87545, 0.879
train acc, test acc | 0.89705, 0.8995
train acc, test acc | 0.907, 0.9103
train acc, test acc | 0.9141, 0.9184
train acc, test acc | 0.9193333333333333, 0.9221
train acc, test acc | 0.9239666666666667, 0.9249
train acc, test acc | 0.9285666666666667, 0.9291
train acc, test acc | 0.9303, 0.9318
train acc, test acc | 0.9334, 0.9352
train acc, test acc | 0.9364833333333333, 0.9377
train acc, test acc | 0.9385, 0.939
train acc, test acc | 0.9416166666666667, 0.942
train acc, test acc | 0.9425666666666667, 0.9417
train acc, test acc | 0.9447, 0.9435
train acc, test acc | 0.94585, 0.9454

紲落來閣彈出來一張圖,  看來真順利.

若有認真看原始碼 (Source code)

毋過, 咱斟酌看 train_neuralnet.py , 中方有

    grad = network.gradient(x_batch, t_batch)

這敢是咱佇遮介紹規半晡个 numerical_gradient()? 毋是呢, 伊是 gradient(), 毋是 numerical_gradient().

歡喜傷早囉!

閣看 two_layer_net.py 內面有 numerical_gradient(), 嘛有  gradient() 函式. 按呢斟酌看來,
train_nerual_net.py 並無用咱的講規半晡个 numerical_gradient().

按呢毋是佇咧裝痟个?

共伊改轉來 numerical_gradient() 奕看覓

我kā train_neuralnet.py 的 graidient() 改轉來:

    grad = network.numerical_gradient(x_batch, t_batch)

行看覓, 等真久, 干焦出現一逝:

train acc, test acc | 0.09736666666666667, 0.0982

就袂振袂動，時間堅凍.

發生啥物代誌咧?  一開始我是懷疑程式有蟲 (bug), 是毋是愛毒蟲(thāu-thâng)?

後來, 我用 timeit Má-tsìo 來小可看覓 numerical_gradient() 開偌濟時間, 按呢寫:

import timeit      
...
time_start = timeit.default_timer()
grad = network.numerical_gradient(x_batch, t_batch)
print("grad cal: {}".format(timeit.default_timer() - time_start))

結果是:

iter_per_epoch=600.0
grad cal: 46.7133047870002
train acc, test acc | 0.09736666666666667, 0.0982

頭一逝是我另外kā iter_per_epoch 印出來. 咱佇遮看著:

行一遍 numerical_gradient() 愛四十五秒.

iter_per_epoch 是設定走幾輾, 印一擺 "train acc, test acc". 頭一擺先印, 紲落來就愛 600 擺 numerical_gradient() 了後才會閣印.

若是  45 * 600 = 27000 秒, 差不度是 7.5 點鐘才會印第二擺.

若是參考頂懸彼例使用  gradient(), 印 "train acc, test acc" 16 擺才收縮到滿意的程度 ，numerical_gradient() 就愛五工才有初步个結果。

以上个時間計算， 愛看你个電腦速度, 你算出來無一定佮我相仝 。

gradient()  佮 numerical_gradient() 這兩个方法，時間那會差遐爾濟?

gradient() 佮 numerical_gradient() 時間差蓋濟

咱若是仝款用 time_it 來算 gradient() 方法  (method) 个時間， 伊是量其約  0.01 秒, 和 45 比起來有 4000  外倍時間个精差.

gradient() 是按怎會遐爾仔緊, 伊就是用 倒退攄 (Back Propagation) 法啦!

←前一篇    後一篇→