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

往期回顧

在上一篇文章中，咱們介紹了循環神經網絡以及它的訓練算法。咱們也介紹了循環神經網絡很難訓練的緣由，這致使了它在實際應用中，很難處理長距離的依賴。在本文中，咱們將介紹一種改進以後的循環神經網絡：長短時記憶網絡(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沒法處理長距離依賴的緣由。

既然找到了問題的緣由，那麼咱們就能解決它。從問題的定位到解決，科學家們大概花了七、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的算法，所以理解這些變體比較容易，所以本文就再也不贅述了。

 

長短時記憶網絡的實現

完整代碼請參考GitHub: https://github.com/hanbt/learn_dl/blob/master/lstm.py (python2.7)

在下面的實現中，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。在下一篇文章中，咱們將介紹遞歸神經網絡和它的訓練算法。如今，漫長的燒腦暫告一段落，休息一下吧:)

 

參考資料

1. CS224d: Deep Learning for Natural Language Processing
2. Understanding LSTM Networks
3. LSTM Forward and Backward Pass
4. 轉載自：https://zybuluo.com/hanbingtao/note/581764