(轉)零基礎入門深度學習(6) - 長短時記憶網絡(LSTM)

無論即將到來的是大數據時代還是人工智能時代，亦或是傳統行業使用人工智能在雲上處理大數據的時代，作為一個有理想有追求的程序員，不懂深度學習（Deep Learning）這個超熱的技術，會不會感覺馬上就out了？現在救命稻草來了，《零基礎入門深度學習》系列文章旨在講幫助愛編程的你從零基礎達到入門級水平。零基礎意味着你不需要太多的數學知識，只要會寫程序就行了，沒錯，這是專門為程序員寫的文章。雖然文中會有很多公式你也許看不懂，但同時也會有更多的代碼，程序員的你一定能看懂的（我周圍是一群狂熱的Clean Code程序員，所以我寫的代碼也不會很差）。

 

文章列表

零基礎入門深度學習(1) - 感知器 
零基礎入門深度學習(2) - 線性單元和梯度下降 
零基礎入門深度學習(3) - 神經網絡和反向傳播算法 
零基礎入門深度學習(4) - 卷積神經網絡 
零基礎入門深度學習(5) - 循環神經網絡 
零基礎入門深度學習(6) - 長短時記憶網絡(LSTM) 
零基礎入門深度學習(7) - 遞歸神經網絡

 

往期回顧

在上一篇文章中，我們介紹了循環神經網絡以及它的訓練算法。我們也介紹了循環神經網絡很難訓練的原因，這導致了它在實際應用中，很難處理長距離的依賴。在本文中，我們將介紹一種改進之后的循環神經網絡：長短時記憶網絡(Long Short Term Memory Network, LSTM)，它成功的解決了原始循環神經網絡的缺陷，成為當前最流行的RNN，在語音識別、圖片描述、自然語言處理等許多領域中成功應用。但不幸的一面是，LSTM的結構很復雜，因此，我們需要花上一些力氣，才能把LSTM以及它的訓練算法弄明白。在搞清楚LSTM之后，我們再介紹一種LSTM的變體：GRU (Gated Recurrent Unit)。 它的結構比LSTM簡單，而效果卻和LSTM一樣好，因此，它正在逐漸流行起來。最后，我們仍然會動手實現一個LSTM。

 

長短時記憶網絡是啥

我們首先了解一下長短時記憶網絡產生的背景。回顧一下零基礎入門深度學習(5) - 循環神經網絡中推導的，誤差項沿時間反向傳播的公式：

 

 

 

 

我們可以根據下面的不等式，來獲取的模的上界（模可以看做對中每一項值的大小的度量）：

 

 

 

 

我們可以看到，誤差項從t時刻傳遞到k時刻，其值的上界是的指數函數。分別是對角矩陣和矩陣W模的上界。顯然，除非乘積的值位於1附近，否則，當t-k很大時（也就是誤差傳遞很多個時刻時），整個式子的值就會變得極小（當乘積小於1）或者極大（當乘積大於1），前者就是梯度消失，后者就是梯度爆炸。雖然科學家們搞出了很多技巧（比如怎樣初始化權重），讓的值盡可能貼近於1，終究還是難以抵擋指數函數的威力。

梯度消失到底意味着什么？在零基礎入門深度學習(5) - 循環神經網絡中我們已證明，權重數組W最終的梯度是各個時刻的梯度之和，即：

 

 

 

 

假設某輪訓練中，各時刻的梯度以及最終的梯度之和如下圖：

我們就可以看到，從上圖的t-3時刻開始，梯度已經幾乎減少到0了。那么，從這個時刻開始再往之前走，得到的梯度（幾乎為零）就不會對最終的梯度值有任何貢獻，這就相當於無論t-3時刻之前的網絡狀態h是什么，在訓練中都不會對權重數組W的更新產生影響，也就是網絡事實上已經忽略了t-3時刻之前的狀態。這就是原始RNN無法處理長距離依賴的原因。

既然找到了問題的原因，那么我們就能解決它。從問題的定位到解決，科學家們大概花了7、8年時間。終於有一天，Hochreiter和Schmidhuber兩位科學家發明出長短時記憶網絡，一舉解決這個問題。

其實，長短時記憶網絡的思路比較簡單。原始RNN的隱藏層只有一個狀態，即h，它對於短期的輸入非常敏感。那么，假如我們再增加一個狀態，即c，讓它來保存長期的狀態，那么問題不就解決了么？如下圖所示：

新增加的狀態c，稱為單元狀態(cell state)。我們把上圖按照時間維度展開：

上圖僅僅是一個示意圖，我們可以看出，在t時刻，LSTM的輸入有三個：當前時刻網絡的輸入值、上一時刻LSTM的輸出值、以及上一時刻的單元狀態；LSTM的輸出有兩個：當前時刻LSTM輸出值、和當前時刻的單元狀態。注意、、都是向量。

LSTM的關鍵，就是怎樣控制長期狀態c。在這里，LSTM的思路是使用三個控制開關。第一個開關，負責控制繼續保存長期狀態c；第二個開關，負責控制把即時狀態輸入到長期狀態c；第三個開關，負責控制是否把長期狀態c作為當前的LSTM的輸出。三個開關的作用如下圖所示：

接下來，我們要描述一下，輸出h和單元狀態c的具體計算方法。

 

長短時記憶網絡的前向計算

前面描述的開關是怎樣在算法中實現的呢？這就用到了門（gate）的概念。門實際上就是一層全連接層，它的輸入是一個向量，輸出是一個0到1之間的實數向量。假設W是門的權重向量，是偏置項，那么門可以表示為：

 

 

 

 

門的使用，就是用門的輸出向量按元素乘以我們需要控制的那個向量。因為門的輸出是0到1之間的實數向量，那么，當門輸出為0時，任何向量與之相乘都會得到0向量，這就相當於啥都不能通過；輸出為1時，任何向量與之相乘都不會有任何改變，這就相當於啥都可以通過。因為（也就是sigmoid函數）的值域是(0,1)，所以門的狀態都是半開半閉的。

LSTM用兩個門來控制單元狀態c的內容，一個是遺忘門（forget gate），它決定了上一時刻的單元狀態有多少保留到當前時刻；另一個是輸入門（input gate），它決定了當前時刻網絡的輸入有多少保存到單元狀態。LSTM用輸出門（output gate）來控制單元狀態有多少輸出到LSTM的當前輸出值。

我們先來看一下遺忘門：

 

 

式

 

上式中，是遺忘門的權重矩陣，表示把兩個向量連接成一個更長的向量，是遺忘門的偏置項，是sigmoid函數。如果輸入的維度是，隱藏層的維度是，單元狀態的維度是（通常），則遺忘門的權重矩陣維度是。事實上，權重矩陣都是兩個矩陣拼接而成的：一個是，它對應着輸入項，其維度為；一個是，它對應着輸入項，其維度為。可以寫為：

 

 

 

 

下圖顯示了遺忘門的計算：

接下來看看輸入門：

 

 

式

 

上式中，是輸入門的權重矩陣，是輸入門的偏置項。下圖表示了輸入門的計算：

接下來，我們計算用於描述當前輸入的單元狀態，它是根據上一次的輸出和本次輸入來計算的：

 

 

式

 

下圖是的計算：

現在，我們計算當前時刻的單元狀態。它是由上一次的單元狀態按元素乘以遺忘門，再用當前輸入的單元狀態按元素乘以輸入門，再將兩個積加和產生的：

 

 

式

 

符號表示按元素乘。下圖是的計算：

這樣，我們就把LSTM關於當前的記憶和長期的記憶組合在一起，形成了新的單元狀態。由於遺忘門的控制，它可以保存很久很久之前的信息，由於輸入門的控制，它又可以避免當前無關緊要的內容進入記憶。下面，我們要看看輸出門，它控制了長期記憶對當前輸出的影響：

 

 

式

 

下圖表示輸出門的計算：

LSTM最終的輸出，是由輸出門和單元狀態共同確定的：

 

 

式

 

下圖表示LSTM最終輸出的計算：

式1到式6就是LSTM前向計算的全部公式。至此，我們就把LSTM前向計算講完了。

 

長短時記憶網絡的訓練

熟悉我們這個系列文章的同學都清楚，訓練部分往往比前向計算部分復雜多了。LSTM的前向計算都這么復雜，那么，可想而知，它的訓練算法一定是非常非常復雜的。現在只有做幾次深呼吸，再一頭扎進公式海洋吧。

 

LSTM訓練算法框架

LSTM的訓練算法仍然是反向傳播算法，對於這個算法，我們已經非常熟悉了。主要有下面三個步驟：

1. 前向計算每個神經元的輸出值，對於LSTM來說，即、、、、五個向量的值。計算方法已經在上一節中描述過了。
2. 反向計算每個神經元的誤差項值。與循環神經網絡一樣，LSTM誤差項的反向傳播也是包括兩個方向：一個是沿時間的反向傳播，即從當前t時刻開始，計算每個時刻的誤差項；一個是將誤差項向上一層傳播。
3. 根據相應的誤差項，計算每個權重的梯度。

 

關於公式和符號的說明

首先，我們對推導中用到的一些公式、符號做一下必要的說明。

接下來的推導中，我們設定gate的激活函數為sigmoid函數，輸出的激活函數為tanh函數。他們的導數分別為：

 

 

 

 

從上面可以看出，sigmoid和tanh函數的導數都是原函數的函數。這樣，我們一旦計算原函數的值，就可以用它來計算出導數的值。

LSTM需要學習的參數共有8組，分別是：遺忘門的權重矩陣和偏置項、輸入門的權重矩陣和偏置項、輸出門的權重矩陣和偏置項，以及計算單元狀態的權重矩陣和偏置項。因為權重矩陣的兩部分在反向傳播中使用不同的公式，因此在后續的推導中，權重矩陣、、、都將被寫為分開的兩個矩陣：、、、、、、、。

我們解釋一下按元素乘符號。當作用於兩個向量時，運算如下：

 

 

 

 

當作用於一個向量和一個矩陣時，運算如下：

 

 

 

 

當作用於兩個矩陣時，兩個矩陣對應位置的元素相乘。按元素乘可以在某些情況下簡化矩陣和向量運算。例如，當一個對角矩陣右乘一個矩陣時，相當於用對角矩陣的對角線組成的向量按元素乘那個矩陣：

 

 

 

 

當一個行向量右乘一個對角矩陣時，相當於這個行向量按元素乘那個矩陣對角線組成的向量：

 

 

 

 

上面這兩點，在我們后續推導中會多次用到。

在t時刻，LSTM的輸出值為。我們定義t時刻的誤差項為：

 

 

 

 

注意，和前面幾篇文章不同，我們這里假設誤差項是損失函數對輸出值的導數，而不是對加權輸入的導數。因為LSTM有四個加權輸入，分別對應、、、，我們希望往上一層傳遞一個誤差項而不是四個。但我們仍然需要定義出這四個加權輸入，以及他們對應的誤差項。

 

 

 

 

 

誤差項沿時間的反向傳遞

沿時間反向傳遞誤差項，就是要計算出t-1時刻的誤差項。

 

 

 

 

我們知道，是一個Jacobian矩陣。如果隱藏層h的維度是N的話，那么它就是一個矩陣。為了求出它，我們列出的計算公式，即前面的式6和式4：

 

 

 

 

顯然，、、、都是的函數，那么，利用全導數公式可得：

 

 

式

 

下面，我們要把式7中的每個偏導數都求出來。根據式6，我們可以求出：

 

 

 

 

根據式4，我們可以求出：

 

 

 

 

因為：

 

 

 

 

我們很容易得出：

 

 

 

 

將上述偏導數帶入到式7，我們得到：

 

 

式

 

根據、、、的定義，可知：

 

 

式式式式

 

式8到式12就是將誤差沿時間反向傳播一個時刻的公式。有了它，我們可以寫出將誤差項向前傳遞到任意k時刻的公式：

 

 

式

 

 

將誤差項傳遞到上一層

我們假設當前為第l層，定義l-1層的誤差項是誤差函數對l-1層加權輸入的導數，即：

 

 

 

 

本次LSTM的輸入由下面的公式計算：

 

 

 

 

上式中，表示第l-1層的激活函數。

因為、、、都是的函數，又是的函數，因此，要求出E對的導數，就需要使用全導數公式：

 

 

式

 

式14就是將誤差傳遞到上一層的公式。

 

權重梯度的計算

對於、、、的權重梯度，我們知道它的梯度是各個時刻梯度之和（證明過程請參考文章零基礎入門深度學習(5) - 循環神經網絡），我們首先求出它們在t時刻的梯度，然后再求出他們最終的梯度。

我們已經求得了誤差項、、、，很容易求出t時刻的、的、的、的：

 

 

 

 

將各個時刻的梯度加在一起，就能得到最終的梯度：

 

 

 

 

對於偏置項、、、的梯度，也是將各個時刻的梯度加在一起。下面是各個時刻的偏置項梯度：

 

 

 

 

下面是最終的偏置項梯度，即將各個時刻的偏置項梯度加在一起：

 

 

 

 

對於、、、的權重梯度，只需要根據相應的誤差項直接計算即可：

 

 

 

 

以上就是LSTM的訓練算法的全部公式。因為這里面存在很多重復的模式，仔細看看，會發覺並不是太復雜。

當然，LSTM存在着相當多的變體，讀者可以在互聯網上找到很多資料。因為大家已經熟悉了基本LSTM的算法，因此理解這些變體比較容易，因此本文就不再贅述了。

 

長短時記憶網絡的實現

在下面的實現中，LSTMLayer的參數包括輸入維度、輸出維度、隱藏層維度，單元狀態維度等於隱藏層維度。gate的激活函數為sigmoid函數，輸出的激活函數為tanh。

 

激活函數的實現

我們先實現兩個激活函數：sigmoid和tanh。

 

1. class SigmoidActivator(object):
2. def forward(self, weighted_input):
3. return 1.0 / (1.0 + np.exp(-weighted_input))
5. def backward(self, output):
6. return output * (1 - output)
9. class TanhActivator(object):
10. def forward(self, weighted_input):
11. return 2.0 / (1.0 + np.exp(-2 * weighted_input)) - 1.0
13. def backward(self, output):
14. return 1 - output * output

 

LSTM初始化

和前兩篇文章代碼架構一樣，我們把LSTM的實現放在LstmLayer類中。

根據LSTM前向計算和方向傳播算法，我們需要初始化一系列矩陣和向量。這些矩陣和向量有兩類用途，一類是用於保存模型參數，例如、、、、、、、；另一類是保存各種中間計算結果，以便於反向傳播算法使用，它們包括、、、、、、、、、、，以及各個權重對應的梯度。

在構造函數的初始化中，只初始化了與forward計算相關的變量，與backward相關的變量沒有初始化。這是因為構造LSTM對象的時候，我們還不知道它未來是用於訓練（既有forward又有backward）還是推理（只有forward）。

 

1. class LstmLayer(object):
2. def __init__(self, input_width, state_width,
3. learning_rate):
4. self.input_width = input_width
5. self.state_width = state_width
6. self.learning_rate = learning_rate
7. # 門的激活函數
8. self.gate_activator = SigmoidActivator()
9. # 輸出的激活函數
10. self.output_activator = TanhActivator()
11. # 當前時刻初始化為t0
12. self.times = 0
13. # 各個時刻的單元狀態向量c
14. self.c_list = self.init_state_vec()
15. # 各個時刻的輸出向量h
16. self.h_list = self.init_state_vec()
17. # 各個時刻的遺忘門f
18. self.f_list = self.init_state_vec()
19. # 各個時刻的輸入門i
20. self.i_list = self.init_state_vec()
21. # 各個時刻的輸出門o
22. self.o_list = self.init_state_vec()
23. # 各個時刻的即時狀態c~
24. self.ct_list = self.init_state_vec()
25. # 遺忘門權重矩陣Wfh, Wfx, 偏置項bf
26. self.Wfh, self.Wfx, self.bf = (
27. self.init_weight_mat())
28. # 輸入門權重矩陣Wfh, Wfx, 偏置項bf
29. self.Wih, self.Wix, self.bi = (
30. self.init_weight_mat())
31. # 輸出門權重矩陣Wfh, Wfx, 偏置項bf
32. self.Woh, self.Wox, self.bo = (
33. self.init_weight_mat())
34. # 單元狀態權重矩陣Wfh, Wfx, 偏置項bf
35. self.Wch, self.Wcx, self.bc = (
36. self.init_weight_mat())
38. def init_state_vec(self):
39. '''
40. 初始化保存狀態的向量
41. '''
42. state_vec_list = []
43. state_vec_list.append(np.zeros(
44. (self.state_width, 1)))
45. return state_vec_list
47. def init_weight_mat(self):
48. '''
49. 初始化權重矩陣
50. '''
51. Wh = np.random.uniform(-1e-4, 1e-4,
52. (self.state_width, self.state_width))
53. Wx = np.random.uniform(-1e-4, 1e-4,
54. (self.state_width, self.input_width))
55. b = np.zeros((self.state_width, 1))
56. return Wh, Wx, b

 

前向計算的實現

forward方法實現了LSTM的前向計算：

 

1. def forward(self, x):
2. '''
3. 根據式1-式6進行前向計算
4. '''
5. self.times += 1
6. # 遺忘門
7. fg = self.calc_gate(x, self.Wfx, self.Wfh,
8. self.bf, self.gate_activator)
9. self.f_list.append(fg)
10. # 輸入門
11. ig = self.calc_gate(x, self.Wix, self.Wih,
12. self.bi, self.gate_activator)
13. self.i_list.append(ig)
14. # 輸出門
15. og = self.calc_gate(x, self.Wox, self.Woh,
16. self.bo, self.gate_activator)
17. self.o_list.append(og)
18. # 即時狀態
19. ct = self.calc_gate(x, self.Wcx, self.Wch,
20. self.bc, self.output_activator)
21. self.ct_list.append(ct)
22. # 單元狀態
23. c = fg * self.c_list[self.times - 1] + ig * ct
24. self.c_list.append(c)
25. # 輸出
26. h = og * self.output_activator.forward(c)
27. self.h_list.append(h)
29. def calc_gate(self, x, Wx, Wh, b, activator):
30. '''
31. 計算門
32. '''
33. h = self.h_list[self.times - 1] # 上次的LSTM輸出
34. net = np.dot(Wh, h) + np.dot(Wx, x) + b
35. gate = activator.forward(net)
36. return gate

從上面的代碼我們可以看到，門的計算都是相同的算法，而門和的計算僅僅是激活函數不同。因此我們提出了calc_gate方法，這樣減少了很多重復代碼。

 

反向傳播算法的實現

backward方法實現了LSTM的反向傳播算法。需要注意的是，與backword相關的內部狀態變量是在調用backward方法之后才初始化的。這種延遲初始化的一個好處是，如果LSTM只是用來推理，那么就不需要初始化這些變量，節省了很多內存。

 

1. def backward(self, x, delta_h, activator):
2. '''
3. 實現LSTM訓練算法
4. '''
5. self.calc_delta(delta_h, activator)
6. self.calc_gradient(x)

算法主要分成兩個部分，一部分使計算誤差項：

 

1. def calc_delta(self, delta_h, activator):
2. # 初始化各個時刻的誤差項
3. self.delta_h_list = self.init_delta() # 輸出誤差項
4. self.delta_o_list = self.init_delta() # 輸出門誤差項
5. self.delta_i_list = self.init_delta() # 輸入門誤差項
6. self.delta_f_list = self.init_delta() # 遺忘門誤差項
7. self.delta_ct_list = self.init_delta() # 即時輸出誤差項
9. # 保存從上一層傳遞下來的當前時刻的誤差項
10. self.delta_h_list[-1] = delta_h
12. # 迭代計算每個時刻的誤差項
13. for k in range(self.times, 0, -1):
14. self.calc_delta_k(k)
16. def init_delta(self):
17. '''
18. 初始化誤差項
19. '''
20. delta_list = []
21. for i in range(self.times + 1):
22. delta_list.append(np.zeros(
23. (self.state_width, 1)))
24. return delta_list
26. def calc_delta_k(self, k):
27. '''
28. 根據k時刻的delta_h，計算k時刻的delta_f、
29. delta_i、delta_o、delta_ct，以及k-1時刻的delta_h
30. '''
31. # 獲得k時刻前向計算的值
32. ig = self.i_list[k]
33. og = self.o_list[k]
34. fg = self.f_list[k]
35. ct = self.ct_list[k]
36. c = self.c_list[k]
37. c_prev = self.c_list[k-1]
38. tanh_c = self.output_activator.forward(c)
39. delta_k = self.delta_h_list[k]
41. # 根據式9計算delta_o
42. delta_o = (delta_k * tanh_c *
43. self.gate_activator.backward(og))
44. delta_f = (delta_k * og *
45. (1 - tanh_c * tanh_c) * c_prev *
46. self.gate_activator.backward(fg))
47. delta_i = (delta_k * og *
48. (1 - tanh_c * tanh_c) * ct *
49. self.gate_activator.backward(ig))
50. delta_ct = (delta_k * og *
51. (1 - tanh_c * tanh_c) * ig *
52. self.output_activator.backward(ct))
53. delta_h_prev = (
54. np.dot(delta_o.transpose(), self.Woh) +
55. np.dot(delta_i.transpose(), self.Wih) +
56. np.dot(delta_f.transpose(), self.Wfh) +
57. np.dot(delta_ct.transpose(), self.Wch)
58. ).transpose()
60. # 保存全部delta值
61. self.delta_h_list[k-1] = delta_h_prev
62. self.delta_f_list[k] = delta_f
63. self.delta_i_list[k] = delta_i
64. self.delta_o_list[k] = delta_o
65. self.delta_ct_list[k] = delta_ct

另一部分是計算梯度：

 

1. def calc_gradient(self, x):
2. # 初始化遺忘門權重梯度矩陣和偏置項
3. self.Wfh_grad, self.Wfx_grad, self.bf_grad = (
4. self.init_weight_gradient_mat())
5. # 初始化輸入門權重梯度矩陣和偏置項
6. self.Wih_grad, self.Wix_grad, self.bi_grad = (
7. self.init_weight_gradient_mat())
8. # 初始化輸出門權重梯度矩陣和偏置項
9. self.Woh_grad, self.Wox_grad, self.bo_grad = (
10. self.init_weight_gradient_mat())
11. # 初始化單元狀態權重梯度矩陣和偏置項
12. self.Wch_grad, self.Wcx_grad, self.bc_grad = (
13. self.init_weight_gradient_mat())
15. # 計算對上一次輸出h的權重梯度
16. for t in range(self.times, 0, -1):
17. # 計算各個時刻的梯度
18. (Wfh_grad, bf_grad,
19. Wih_grad, bi_grad,
20. Woh_grad, bo_grad,
21. Wch_grad, bc_grad) = (
22. self.calc_gradient_t(t))
23. # 實際梯度是各時刻梯度之和
24. self.Wfh_grad += Wfh_grad
25. self.bf_grad += bf_grad
26. self.Wih_grad += Wih_grad
27. self.bi_grad += bi_grad
28. self.Woh_grad += Woh_grad
29. self.bo_grad += bo_grad
30. self.Wch_grad += Wch_grad
31. self.bc_grad += bc_grad
32. print '-----%d-----' % t
33. print Wfh_grad
34. print self.Wfh_grad
36. # 計算對本次輸入x的權重梯度
37. xt = x.transpose()
38. self.Wfx_grad = np.dot(self.delta_f_list[-1], xt)
39. self.Wix_grad = np.dot(self.delta_i_list[-1], xt)
40. self.Wox_grad = np.dot(self.delta_o_list[-1], xt)
41. self.Wcx_grad = np.dot(self.delta_ct_list[-1], xt)
43. def init_weight_gradient_mat(self):
44. '''
45. 初始化權重矩陣
46. '''
47. Wh_grad = np.zeros((self.state_width,
48. self.state_width))
49. Wx_grad = np.zeros((self.state_width,
50. self.input_width))
51. b_grad = np.zeros((self.state_width, 1))
52. return Wh_grad, Wx_grad, b_grad
54. def calc_gradient_t(self, t):
55. '''
56. 計算每個時刻t權重的梯度
57. '''
58. h_prev = self.h_list[t-1].transpose()
59. Wfh_grad = np.dot(self.delta_f_list[t], h_prev)
60. bf_grad = self.delta_f_list[t]
61. Wih_grad = np.dot(self.delta_i_list[t], h_prev)
62. bi_grad = self.delta_f_list[t]
63. Woh_grad = np.dot(self.delta_o_list[t], h_prev)
64. bo_grad = self.delta_f_list[t]
65. Wch_grad = np.dot(self.delta_ct_list[t], h_prev)
66. bc_grad = self.delta_ct_list[t]
67. return Wfh_grad, bf_grad, Wih_grad, bi_grad, \
68. Woh_grad, bo_grad, Wch_grad, bc_grad

 

梯度下降算法的實現

下面是用梯度下降算法來更新權重：

 

1. def update(self):
2. '''
3. 按照梯度下降，更新權重
4. '''
5. self.Wfh -= self.learning_rate * self.Whf_grad
6. self.Wfx -= self.learning_rate * self.Whx_grad
7. self.bf -= self.learning_rate * self.bf_grad
8. self.Wih -= self.learning_rate * self.Whi_grad
9. self.Wix -= self.learning_rate * self.Whi_grad
10. self.bi -= self.learning_rate * self.bi_grad
11. self.Woh -= self.learning_rate * self.Wof_grad
12. self.Wox -= self.learning_rate * self.Wox_grad
13. self.bo -= self.learning_rate * self.bo_grad
14. self.Wch -= self.learning_rate * self.Wcf_grad
15. self.Wcx -= self.learning_rate * self.Wcx_grad
16. self.bc -= self.learning_rate * self.bc_grad

 

梯度檢查的實現

和RecurrentLayer一樣，為了支持梯度檢查，我們需要支持重置內部狀態：

 

1. def reset_state(self):
2. # 當前時刻初始化為t0
3. self.times = 0
4. # 各個時刻的單元狀態向量c
5. self.c_list = self.init_state_vec()
6. # 各個時刻的輸出向量h
7. self.h_list = self.init_state_vec()
8. # 各個時刻的遺忘門f
9. self.f_list = self.init_state_vec()
10. # 各個時刻的輸入門i
11. self.i_list = self.init_state_vec()
12. # 各個時刻的輸出門o
13. self.o_list = self.init_state_vec()
14. # 各個時刻的即時狀態c~
15. self.ct_list = self.init_state_vec()

最后，是梯度檢查的代碼：

 

1. def data_set():
2. x = [np.array([[1], [2], [3]]),
3. np.array([[2], [3], [4]])]
4. d = np.array([[1], [2]])
5. return x, d
7. def gradient_check():
8. '''
9. 梯度檢查
10. '''
11. # 設計一個誤差函數，取所有節點輸出項之和
12. error_function = lambda o: o.sum()
14. lstm = LstmLayer(3, 2, 1e-3)
16. # 計算forward值
17. x, d = data_set()
18. lstm.forward(x[0])
19. lstm.forward(x[1])
21. # 求取sensitivity map
22. sensitivity_array = np.ones(lstm.h_list[-1].shape,
23. dtype=np.float64)
24. # 計算梯度
25. lstm.backward(x[1], sensitivity_array, IdentityActivator())
27. # 檢查梯度
28. epsilon = 10e-4
29. for i in range(lstm.Wfh.shape[0]):
30. for j in range(lstm.Wfh.shape[1]):
31. lstm.Wfh[i,j] += epsilon
32. lstm.reset_state()
33. lstm.forward(x[0])
34. lstm.forward(x[1])
35. err1 = error_function(lstm.h_list[-1])
36. lstm.Wfh[i,j] -= 2*epsilon
37. lstm.reset_state()
38. lstm.forward(x[0])
39. lstm.forward(x[1])
40. err2 = error_function(lstm.h_list[-1])
41. expect_grad = (err1 - err2) / (2 * epsilon)
42. lstm.Wfh[i,j] += epsilon
43. print 'weights(%d,%d): expected - actural %.4e - %.4e' % (
44. i, j, expect_grad, lstm.Wfh_grad[i,j])
45. return lstm

我們只對做了檢查，讀者可以自行增加對其他梯度的檢查。下面是某次梯度檢查的結果：

 

GRU

前面我們講了一種普通的LSTM，事實上LSTM存在很多變體，許多論文中的LSTM都或多或少的不太一樣。在眾多的LSTM變體中，GRU (Gated Recurrent Unit)也許是最成功的一種。它對LSTM做了很多簡化，同時卻保持着和LSTM相同的效果。因此，GRU最近變得越來越流行。

GRU對LSTM做了兩個大改動：

1. 將輸入門、遺忘門、輸出門變為兩個門：更新門（Update Gate）和重置門（Reset Gate）。
2. 將單元狀態與輸出合並為一個狀態：。

GRU的前向計算公式為：

 

 

 

 

下圖是GRU的示意圖：

GRU的訓練算法比LSTM簡單一些，留給讀者自行推導，本文就不再贅述了。

 

小結

至此，LSTM——也許是結構最復雜的一類神經網絡——就講完了，相信拿下前幾篇文章的讀者們搞定這篇文章也不在話下吧！現在我們已經了解循環神經網絡和它最流行的變體——LSTM，它們都可以用來處理序列。但是，有時候僅僅擁有處理序列的能力還不夠，還需要處理比序列更為復雜的結構（比如樹結構），這時候就需要用到另外一類網絡：遞歸神經網絡(Recursive Neural Network)，巧合的是，它的縮寫也是RNN。在下一篇文章中，我們將介紹遞歸神經網絡和它的訓練算法。現在，漫長的燒腦暫告一段落，休息一下吧:)