1、應(yīng)用現(xiàn)狀

長短期記憶神經(jīng)網(wǎng)絡(luò)（LSTM）是一種特殊的循環(huán)神經(jīng)網(wǎng)絡(luò)(RNN)。原始的RNN在訓(xùn)練中，隨著訓(xùn)練時間的加長以及網(wǎng)絡(luò)層數(shù)的增多，很容易出現(xiàn)梯度爆炸或者梯度消失的問題，導(dǎo)致無法處理較長序列數(shù)據(jù)，從而無法獲取長距離數(shù)據(jù)的信息。

LSTM主要用于處理序列數(shù)據(jù)，廣泛應(yīng)用于自然語言處理（NLP）、時間序列預(yù)測、語音識別、機(jī)器翻譯、生成圖像描述和視頻標(biāo)記等領(lǐng)域。具體來說，LSTM在以下任務(wù)中表現(xiàn)出色：

• 語言模型：預(yù)測序列中的下一個詞或字符。
• 文本生成：根據(jù)輸入生成相應(yīng)的文本序列。
• 時間序列預(yù)測：如股票價格、氣象數(shù)據(jù)的預(yù)測。
• 語音識別：將語音信號轉(zhuǎn)化為文本。
• 機(jī)器翻譯：將一種語言翻譯成另一種語言。

2009年, 應(yīng)用LSTM搭建的神經(jīng)網(wǎng)絡(luò)模型贏得了ICDAR手寫識別比賽冠軍。

2015年以來，在機(jī)械故障診斷和預(yù)測領(lǐng)域，相關(guān)學(xué)者應(yīng)用LSTM來處理機(jī)械設(shè)備的振動信號。

2016年, 谷歌公司應(yīng)用LSTM來做語音識別和文字翻譯，其中Google翻譯用的就是一個7-8層的LSTM模型。

2016年, 蘋果公司使用LSTM來優(yōu)化Siri應(yīng)用。

2、發(fā)展歷史

1997年，Sepp Hochreiter 和 Jürgen Schmidhuber[1]提出了長短期記憶神經(jīng)網(wǎng)絡(luò)(LSTM)，有效解決了RNN難以解決的人為延長時間任務(wù)的問題，并解決了RNN容易出現(xiàn)梯度消失的問題。

1999年，Felix A. Gers等人[2]發(fā)現(xiàn)[1]中提出的LSTM在處理連續(xù)輸入數(shù)據(jù)時，如果沒有重置網(wǎng)絡(luò)內(nèi)部的狀態(tài)，最終會導(dǎo)致網(wǎng)絡(luò)崩潰。因此，他們在文獻(xiàn)[1]基礎(chǔ)上引入了遺忘門機(jī)制，使得LSTM能夠重置自己的狀態(tài)。

2000年，Felix A. Gers和Jiirgen Schmidhuber[3]發(fā)現(xiàn)，通過在LSTM內(nèi)部狀態(tài)單元內(nèi)添加窺視孔（Peephole）連接，可以增強(qiáng)網(wǎng)絡(luò)對輸入序列之間細(xì)微特征的區(qū)分能力。

2005年，Alex Graves和Jürgen Schmidhuber[4]在文獻(xiàn)[1] [2] [3]的基礎(chǔ)上提出了一種雙向長短期記憶神經(jīng)網(wǎng)絡(luò)（BLSTM），也稱為vanilla LSTM，是當(dāng)前應(yīng)用最廣泛的一種LSTM模型。

2005年-2015年期間，相關(guān)學(xué)者提出了多種LSTM變體模型，此處不多做描述。

2016年，Klaus Greff 等人[5]回顧了LSTM的發(fā)展歷程，并比較分析了八種LSTM變體在語音識別、手寫識別和弦音樂建模方面的能力，實驗結(jié)果表明這些變體不能顯著改進(jìn)標(biāo)準(zhǔn)LSTM體系結(jié)構(gòu)，并證明了遺忘門和輸出激活功能是LSTM的關(guān)鍵組成部分。在這八種變體中，vanilla LSTM的綜合表現(xiàn)能力最佳。另外，還探索了LSTM相關(guān)超參數(shù)的設(shè)定影響，實驗結(jié)果表明學(xué)習(xí)率是最關(guān)鍵的超參數(shù)，其次是網(wǎng)絡(luò)規(guī)模（網(wǎng)絡(luò)層數(shù)和隱藏層單元數(shù)），而動量梯度等設(shè)置對最終結(jié)果影響不大。

下圖展示了Simple RNN（圖左）和vanilla LSTM（圖右，圖中藍(lán)色線條表示窺視孔連接）的基本單元結(jié)構(gòu)圖[5]：

在眾多LSTM變體中，2014年Kyunghyun Cho等人[6]提出的變體引起了眾多學(xué)者的關(guān)注。Kyunghyun Cho等人簡化了LSTM架構(gòu)，稱為門控遞歸單元（GRU）。GRU擺脫了單元狀態(tài)，基本結(jié)構(gòu)由重置門和更新門組成。LSTM和GRU的基本結(jié)構(gòu)單元如下圖（具體可參考：Illustrated Guide to LSTM’s and GRU’s: A step by step explanation）。

在GRU被提出后，Junyoung Chung等人[7]比較了LSTM和GRU在復(fù)音音樂和語音信號建模方面的能力，實驗結(jié)果表明GRU和LSTM表現(xiàn)相當(dāng)。

GRU被提出至今（2019年），也只有幾年時間，關(guān)于它的一些應(yīng)用利弊到目前還未探索清楚。不過，相對于LSTM架構(gòu)，GRU的的參數(shù)較少，在數(shù)據(jù)量較大的情況下，其訓(xùn)練速度更快。

LSTM是深度學(xué)習(xí)技術(shù)中的一員，其基本結(jié)構(gòu)比較復(fù)雜，計算復(fù)雜度較高，導(dǎo)致較難進(jìn)行較深層次的學(xué)習(xí)，例如谷歌翻譯也只是應(yīng)用7-8層的LSTM網(wǎng)絡(luò)結(jié)構(gòu)。另外，在訓(xùn)練學(xué)習(xí)過程中有可能會出現(xiàn)過擬合，可以通過應(yīng)用dropout來解決過擬合問題（這在Keras等框架中均有實現(xiàn)，具體可參考：LSTM原理與實踐，原來如此簡單）。

LSTM在當(dāng)前應(yīng)用比較的結(jié)構(gòu)是雙向LSTM或者多層堆疊LSTM，這兩種結(jié)構(gòu)的實現(xiàn)在Keras等框架中均有對應(yīng)的API可以調(diào)用。

下圖展示一個堆疊兩層的LSTM結(jié)構(gòu)圖（來源：運用TensorFlow處理簡單的NLP問題）：

下圖展示了一個雙向LSTM的結(jié)構(gòu)圖（來源：雙向LSTM）

3、基本原理

本節(jié)首先講解一下RNN的基本結(jié)構(gòu)，然后說明LSTM的具體原理（下面要介紹的LSTM即為vanilla LSTM）。

循環(huán)神經(jīng)網(wǎng)絡(luò)（下面簡稱RNN）可以通過不停的將信息循環(huán)操作，保證信息持續(xù)存在。原始的RNN基本結(jié)構(gòu)圖如下圖所示（原圖來源：Understanding LSTM Networks）。

可以看出A是一組神經(jīng)網(wǎng)絡(luò)（可以理解為一個網(wǎng)絡(luò)的自循環(huán)），它的工作是不停的接收Xt并且輸出ht。從上圖左中可以看出A允許將信息不停的再內(nèi)部循環(huán)，這樣使得它可以保證每一步的計算都保存以前的信息。

將RNN的自循環(huán)結(jié)構(gòu)展開，像是將同一個網(wǎng)絡(luò)復(fù)制并連成一條線的結(jié)構(gòu)，將自身提取的信息傳遞給下一個繼承者，RNN展開后（上圖右）由多個相同的單元連續(xù)連接。RNN的實際結(jié)構(gòu)和上圖左邊的結(jié)構(gòu)所示，是一個自我不斷循環(huán)的結(jié)構(gòu)。隨著輸入數(shù)據(jù)的不斷增加，上述自我循環(huán)的結(jié)構(gòu)把上一次的狀態(tài)傳遞給當(dāng)前輸入，一起作為新的輸入數(shù)據(jù)進(jìn)行當(dāng)前輪次的訓(xùn)練和學(xué)習(xí)，一直到輸入或者訓(xùn)練結(jié)束，最終得到的輸出即為最終的預(yù)測結(jié)果。

一般來說，RNN的輸入和輸出都是一個序列，分別記為seqin={x1,x2,...,xn}和?seqout={o1,o2,...,on}，同時ot的取值不僅與xt有關(guān)還與序列中更早的輸入有關(guān)(序列中的第t個元素我們叫做序列在time_step=t時的取值)。更直觀的理解可看下圖：

把上圖用公式表達(dá)就是：

S[t]=f(U?X[t]+W?S[t?1]),Ot=g(V?S[t])?

有時候我們需要利用近期的信息來執(zhí)行來處理當(dāng)前的任務(wù)。例如，考慮用一個語言模型通過利用以前的文字信息來預(yù)測下一個文字。如果我們需要預(yù)測“the clouds are in the sky”這句話的最后一個字，我們不需要其他的信息，通過前面的語境就能知道最后一個字應(yīng)該是sky。在這種情況下，相關(guān)信息與需要該信息的位置距離較近，RNNs能夠?qū)W習(xí)利用以前的信息來對當(dāng)前任務(wù)進(jìn)行相應(yīng)的操作。如下圖所示通過輸入的X1、X2信息來預(yù)測出h3。

假設(shè)現(xiàn)在有個更為復(fù)雜的任務(wù)，考慮到下面這句話“I grew up in France… I speak fluent French.”，現(xiàn)在需要語言模型通過現(xiàn)有以前的文字信息預(yù)測該句話的最后一個字。通過以前文字語境可以預(yù)測出最后一個字是某種語言，但是要猜測出French，要根據(jù)之前的France語境。這樣的任務(wù)，不同之前，因為這次的有用信息與需要進(jìn)行處理信息的地方之間的距離較遠(yuǎn)，這樣容易導(dǎo)致RNNs不能學(xué)習(xí)到有用的信息，最終推導(dǎo)的任務(wù)可能失敗。如下圖所示。

理論上RNN是能夠處理這種“長依賴”問題的。通過BPTT去優(yōu)化、或調(diào)參來解決這種問題。但是在實踐過程中RNN無法學(xué)習(xí)到這種特征。但是當(dāng)序列過長時很容易引起梯度爆炸或梯度消失現(xiàn)象。

LSTM是一種特殊的RNN，兩者的區(qū)別在于普通的RNN單個循環(huán)結(jié)構(gòu)內(nèi)部只有一個狀態(tài)。而LSTM的單個循環(huán)結(jié)構(gòu)(又稱為細(xì)胞)內(nèi)部有四個狀態(tài)。相比于RNN，LSTM循環(huán)結(jié)構(gòu)之間保持一個持久的單元狀態(tài)不斷傳遞下去，用于決定哪些信息要遺忘或者繼續(xù)傳遞下去。

包含三個連續(xù)循環(huán)結(jié)構(gòu)的RNN如下圖，每個循環(huán)結(jié)構(gòu)只有一個輸出：

包含三個連續(xù)循環(huán)結(jié)構(gòu)的LSTM如下圖，每個循環(huán)結(jié)構(gòu)有兩個輸出，其中一個即為單元狀態(tài)：

一層LSTM是由單個循環(huán)結(jié)構(gòu)結(jié)構(gòu)組成，既由輸入數(shù)據(jù)的維度和循環(huán)次數(shù)決定單個循環(huán)結(jié)構(gòu)需要自我更新幾次，而不是多個單個循環(huán)結(jié)構(gòu)連接組成（此處關(guān)于這段描述，在實際操作的理解詳述請參考：Keras關(guān)于LSTM的units參數(shù)，還是不理解? ），即當(dāng)前層LSTM的參數(shù)總個數(shù)只需計算一個循環(huán)單元就行，而不是計算多個連續(xù)單元的總個數(shù)。

在解釋LSTMs的詳細(xì)結(jié)構(gòu)時先定義一下圖中各個符號的含義，符號包括下面幾種：

圖中黃色類似于CNN里的激活函數(shù)操作，粉色圓圈表示點操作，單箭頭表示數(shù)據(jù)流向，箭頭合并表示向量的合并（concat）操作，箭頭分叉表示向量的拷貝操作。

LSTMs的核心是細(xì)胞狀態(tài)，用貫穿細(xì)胞的水平線表示。細(xì)胞狀態(tài)像傳送帶一樣。它貫穿整個細(xì)胞卻只有很少的分支，這樣能保證信息不變的流過整個RNN。細(xì)胞狀態(tài)如下圖所示L：

LSTM網(wǎng)絡(luò)能通過一種被稱為門的結(jié)構(gòu)對細(xì)胞狀態(tài)進(jìn)行刪除或者添加信息。

門能夠有選擇性的決定讓哪些信息通過。其實門的結(jié)構(gòu)很簡單，就是一個sigmoid層和一個點乘操作的組合。如下圖所示：

因為sigmoid層的輸出是0-1的值，這代表有多少信息能夠流過sigmoid層。0表示都不能通過，1表示都能通過。一個LSTM里面包含三個門來控制細(xì)胞狀態(tài)。

下面將由一組圖來詳細(xì)結(jié)構(gòu)LSTM細(xì)胞的基本組成和實現(xiàn)原理。LSTM細(xì)胞由輸入門、遺忘門、輸出門和單元狀態(tài)組成。

• 輸入門：決定當(dāng)前時刻網(wǎng)絡(luò)的輸入數(shù)據(jù)有多少需要保存到單元狀態(tài)。
• 遺忘門：決定上一時刻的單元狀態(tài)有多少需要保留到當(dāng)前時刻。
• 輸出門：控制當(dāng)前單元狀態(tài)有多少需要輸出到當(dāng)前的輸出值。

此外，LSTM還有一個記憶單元（Cell State），用于保存跨時間步長的信息。通過這些門控機(jī)制，LSTM能夠在時間步長之間靈活地存儲和刪除信息，從而有效解決了長時間依賴問題。

LSTM的第一步就是決定細(xì)胞狀態(tài)需要丟棄哪些信息。這部分操作是通過一個稱為忘記門的sigmoid單元來處理的。它通過查看h_(t-1)和x_t信息來輸出一個0-1之間的向量，該向量里面的0-1值表示細(xì)胞狀態(tài)中的哪些信息保留或丟棄多少。0表示不保留，1表示都保留。忘記門如下圖所示,?展示了應(yīng)用上一個時刻的輸出h_(t-1)和當(dāng)前的數(shù)據(jù)輸入x_t，通過遺忘門得到f_t的過程。（下面的一組原圖來源：Understanding LSTM Networks）

下一步是決定給細(xì)胞狀態(tài)添加哪些新的信息。這一步又分為兩個步驟，首先，利用h_(t-1)和x_t通過一個稱為輸入門的操作來決定更新哪些信息。然后利用h_(t-1)和x_t通過一個tanh層得到新的候選細(xì)胞信息C~t，這些信息可能會被更新到細(xì)胞信息中。這兩步描述如下圖所示，展示了應(yīng)用上一個時刻的輸出h_(t-1)和當(dāng)前的數(shù)據(jù)輸入x_t，通過輸入門得到i_t，以及通過單元狀態(tài)得到當(dāng)前時刻暫時狀態(tài)C~t的過程。

下面將更新舊的細(xì)胞信息C_(t-1)，變?yōu)樾碌募?xì)胞信息C_t。更新的規(guī)則就是通過忘記門選擇忘記舊細(xì)胞信息的一部分，通過輸入門選擇添加候選細(xì)胞信息C~t的一部分得到新的細(xì)胞信息C_t。更新操作如下圖所示，展示了應(yīng)用上一個細(xì)胞結(jié)構(gòu)的單元狀態(tài)C_(t-1)、遺忘門輸出f_t、輸入門輸出i_t以及單元狀態(tài)的輸出C~t，得到當(dāng)前細(xì)胞的狀態(tài)C_t的過程。

更新完細(xì)胞狀態(tài)后需要根據(jù)輸入的h_(t-1)和x_t來判斷輸出細(xì)胞的哪些狀態(tài)特征，這里需要將輸入經(jīng)過一個稱為輸出門的sigmoid層得到判斷條件，然后將細(xì)胞狀態(tài)經(jīng)過tanh層得到一個-1~1之間值的向量，該向量與輸出門得到的判斷條件相乘就得到了最終該RNN單元的輸出。該步驟如下圖所示，展示了應(yīng)用上一個時刻的輸出h_(t-1)和當(dāng)前的數(shù)據(jù)輸入x_t，通過輸出門得到o_t的過程，以及結(jié)合當(dāng)前細(xì)胞的單元狀態(tài)C_t和o_t得到最終的輸出h_t的過程。

拿語言模型來舉例說明，在預(yù)測動詞形式的時候，我們需要通過輸入的主語是單數(shù)還是復(fù)數(shù)來推斷輸出門輸出的預(yù)測動詞是單數(shù)形式還是復(fù)數(shù)形式。?

4、LSTM變種

?之前描述的LSTM結(jié)構(gòu)是最為普通的。在實際的文章中LSTM的結(jié)構(gòu)存在各種變式，雖然變化都不會太大，但是也值得一提。

其中一種比其他形式變化更為顯著的LSTM變式是由?Cho, et al. (2014)提出的門循環(huán)單元（GRU）。它將忘記門和輸入門合并成一個新的門，稱為更新門。GRU還有一個門稱為重置門。如下圖所示：

其中重置門為上圖中前面那個門，決定了如何將新的輸入信息與前面的記憶相結(jié)合。更新門為上圖中后面那個門，定義了前面記憶保存到當(dāng)前時間步的量。由于該變式的簡單有效，后來被廣泛應(yīng)用。

這里介紹的只是一些較為有名的LSTM變式，關(guān)于LSTM的變式其實還有很多種，像 Yao, et al. (2015)提出的Depth Gated RNNs。還有其他用于解決長依賴問題的方法，如由 Koutnik, et al. (2014)提出的 Clockwork RNNs。

5、LSTM的優(yōu)缺點

優(yōu)點：

• 解決長時依賴問題：相比于傳統(tǒng)RNN，LSTM能夠更好地捕捉序列中的長時依賴關(guān)系。
• 適用性廣泛：LSTM可以處理不同類型的序列數(shù)據(jù)，如文本、語音、時間序列等。
• 在復(fù)雜任務(wù)中的表現(xiàn)更好：如機(jī)器翻譯、圖像字幕生成等任務(wù)。

缺點：

• 計算開銷大：LSTM結(jié)構(gòu)復(fù)雜，計算量大，訓(xùn)練時間較長。
• 難以調(diào)參：LSTM模型包含多個超參數(shù)，如層數(shù)、隱藏單元數(shù)量等，調(diào)參較為復(fù)雜。
• 容易過擬合：由于模型復(fù)雜，訓(xùn)練時容易發(fā)生過擬合，需要加入正則化手段。

6、示例

5.1、簡單的LSTM示例代碼

以下是一個使用Python和Keras庫實現(xiàn)LSTM的簡單示例代碼，來完成一個基本的時間序列預(yù)測任務(wù)：

import numpy as np
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import LSTM, Dense# 生成示例數(shù)據(jù)
def generate_data(seq_length=100, num_samples=1000):X = []y = []for _ in range(num_samples):start = np.random.rand()seq = np.sin(np.linspace(start, start + 2*np.pi, seq_length))X.append(seq[:-1])y.append(seq[-1])return np.array(X), np.array(y)# 數(shù)據(jù)集
seq_length = 50
X, y = generate_data(seq_length)# 調(diào)整形狀以符合LSTM輸入要求
X = np.expand_dims(X, axis=2)# 構(gòu)建LSTM模型
model = Sequential()
model.add(LSTM(50, activation='tanh', input_shape=(seq_length-1, 1)))
model.add(Dense(1))
model.compile(optimizer='adam', loss='mse')# 訓(xùn)練模型
model.fit(X, y, epochs=20, batch_size=32)# 測試模型
test_seq = np.sin(np.linspace(0, 2*np.pi, seq_length-1))
test_seq = np.expand_dims(test_seq, axis=0)
test_seq = np.expand_dims(test_seq, axis=2)
predicted = model.predict(test_seq)# 顯示結(jié)果
plt.plot(np.linspace(0, 2*np.pi, seq_length), np.sin(np.linspace(0, 2*np.pi, seq_length)), label='True')
plt.plot(np.linspace(0, 2*np.pi, seq_length-1), test_seq.flatten(), label='Input')
plt.scatter([2*np.pi], predicted, color='red', label='Predicted')
plt.legend()
plt.show()

代碼解釋
數(shù)據(jù)生成：generate_data函數(shù)生成了一些模擬的正弦波數(shù)據(jù)作為訓(xùn)練集。
LSTM模型：模型包含一個LSTM層和一個Dense層，用于輸出預(yù)測值。
模型訓(xùn)練：使用MSE（均方誤差）作為損失函數(shù)，Adam優(yōu)化器進(jìn)行訓(xùn)練。
測試和可視化：用訓(xùn)練好的模型對一個完整的正弦波進(jìn)行預(yù)測，并與真實值進(jìn)行對比。
這個示例展示了LSTM如何被應(yīng)用于一個簡單的時間序列預(yù)測任務(wù)中。根據(jù)任務(wù)的復(fù)雜度，LSTM模型的層數(shù)、單元數(shù)以及其他超參數(shù)可以進(jìn)行調(diào)整。

5.2、基于Keras框架的手寫數(shù)字識別實驗

本節(jié)應(yīng)用Keras提供的API，比較和分析Simple RNN、LSTM和GRU在手寫數(shù)字mnist數(shù)據(jù)集上的預(yù)測準(zhǔn)確率。

應(yīng)用Simple RNN進(jìn)行手寫數(shù)字預(yù)測訓(xùn)練的代碼如下：

import keras from keras.layers 
import LSTM , SimpleRNN, GRU from keras.layers 
import Dense, Activation from keras.datasets 
import mnist from keras.models 
import Sequential from keras.optimizers 
import Adam
learning_rate = 0.001 
training_iters = 20 
batch_size = 128 
display_step = 10 
n_input = 28 
n_step = 28 
n_hidden = 128 
n_classes = 10 
(x_train, y_train), (x_test, y_test) = mnist.load_data() 
x_train = x_train.reshape(-1, n_step, n_input) 
x_test = x_test.reshape(-1, n_step, n_input) 
x_train = x_train.astype('float32') 
x_test = x_test.astype('float32') 
x_train /= 255 
x_test /= 255 
y_train = keras.utils.to_categorical(y_train, n_classes) 
y_test = keras.utils.to_categorical(y_test, n_classes) 
model = Sequential() 
model.add(SimpleRNN(n_hidden, batch_input_shape=(None, n_step, n_input), unroll=True)) model.add(Dense(n_classes)) 
model.add(Activation('softmax')) 
adam = Adam(lr=learning_rate) 
model.summary() 
model.compile(optimizer=adam, loss='categorical_crossentropy', metrics=['accuracy']) history = model.fit(x_train, y_train, batch_size=batch_size, epochs=training_iters, verbose=1, validation_data=(x_test, y_test)) 
scores = model.evaluate(x_test, y_test, verbose=0) 
print('Simple RNN test score(loss value):', scores[0]) 
print('Simple RNN test accuracy:', scores[1])

訓(xùn)練結(jié)果：

_________________________________________________________________ Layer (type) Output Shape Param # ================================================================= simple_rnn_1 (SimpleRNN) (None, 128) 20096 _________________________________________________________________ dense_1 (Dense) (None, 10) 1290 _________________________________________________________________ activation_1 (Activation) (None, 10) 0 ================================================================= Total params: 21,386 Trainable params: 21,386 Non-trainable params: 0 _________________________________________________________________ Train on 60000 samples, validate on 10000 samples Epoch 1/20 60000/60000 [==============================] - 3s 51us/step - loss: 0.4584 - acc: 0.8615 - val_loss: 0.2459 - val_acc: 0.9308 Epoch 2/20 60000/60000 [==============================] - 3s 47us/step - loss: 0.1923 - acc: 0.9440 - val_loss: 0.1457 - val_acc: 0.9578 Epoch 3/20 60000/60000 [==============================] - 3s 47us/step - loss: 0.1506 - acc: 0.9555 - val_loss: 0.1553 - val_acc: 0.9552 Epoch 4/20 60000/60000 [==============================] - 3s 47us/step - loss: 0.1326 - acc: 0.9604 - val_loss: 0.1219 - val_acc: 0.9642 Epoch 5/20 60000/60000 [==============================] - 3s 47us/step - loss: 0.1184 - acc: 0.9651 - val_loss: 0.1014 - val_acc: 0.9696 Epoch 6/20 60000/60000 [==============================] - 3s 47us/step - loss: 0.1021 - acc: 0.9707 - val_loss: 0.1254 - val_acc: 0.9651 Epoch 7/20 60000/60000 [==============================] - 3s 47us/step - loss: 0.0987 - acc: 0.9708 - val_loss: 0.0946 - val_acc: 0.9733 Epoch 8/20 60000/60000 [==============================] - 3s 47us/step - loss: 0.0959 - acc: 0.9722 - val_loss: 0.1163 - val_acc: 0.9678 Epoch 9/20 60000/60000 [==============================] - 3s 47us/step - loss: 0.0888 - acc: 0.9742 - val_loss: 0.0983 - val_acc: 0.9718 Epoch 10/20 60000/60000 [==============================] - 3s 47us/step - loss: 0.0833 - acc: 0.9750 - val_loss: 0.1199 - val_acc: 0.9651 Epoch 11/20 60000/60000 [==============================] - 3s 47us/step - loss: 0.0814 - acc: 0.9750 - val_loss: 0.0939 - val_acc: 0.9722 Epoch 12/20 60000/60000 [==============================] - 3s 47us/step - loss: 0.0767 - acc: 0.9773 - val_loss: 0.0865 - val_acc: 0.9761 Epoch 13/20 60000/60000 [==============================] - 3s 47us/step - loss: 0.0747 - acc: 0.9778 - val_loss: 0.1077 - val_acc: 0.9697 Epoch 14/20 60000/60000 [==============================] - 3s 47us/step - loss: 0.0746 - acc: 0.9779 - val_loss: 0.1098 - val_acc: 0.9693 Epoch 15/20 60000/60000 [==============================] - 3s 47us/step - loss: 0.0671 - acc: 0.9799 - val_loss: 0.0776 - val_acc: 0.9771 Epoch 16/20 60000/60000 [==============================] - 3s 47us/step - loss: 0.0639 - acc: 0.9810 - val_loss: 0.0961 - val_acc: 0.9730 Epoch 17/20 60000/60000 [==============================] - 3s 47us/step - loss: 0.0701 - acc: 0.9792 - val_loss: 0.1046 - val_acc: 0.9713 Epoch 18/20 60000/60000 [==============================] - 3s 47us/step - loss: 0.0600 - acc: 0.9822 - val_loss: 0.0865 - val_acc: 0.9767 Epoch 19/20 60000/60000 [==============================] - 3s 47us/step - loss: 0.0635 - acc: 0.9813 - val_loss: 0.0812 - val_acc: 0.9790 Epoch 20/20 60000/60000 [==============================] - 3s 47us/step - loss: 0.0579 - acc: 0.9827 - val_loss: 0.0981 - val_acc: 0.9733 Simple RNN test score(loss value): 0.09805978989955037 Simple RNN test accuracy: 0.9733

可知Simple RNN在測試集上的最終預(yù)測準(zhǔn)確率為97.33%。

只需修改下方代碼中Simple RNN為LSTM，即可調(diào)用LSTM進(jìn)行模型訓(xùn)練：

model.add(SimpleRNN(n_hidden, batch_input_shape=(None, n_step, n_input), unroll=True))

改變?yōu)?#xff1a;

model.add(LSTM(n_hidden, batch_input_shape=(None, n_step, n_input), unroll=True))

訓(xùn)練結(jié)果：

_________________________________________________________________ Layer (type) Output Shape Param # ================================================================= lstm_1 (LSTM) (None, 128) 80384 _________________________________________________________________ dense_2 (Dense) (None, 10) 1290 _________________________________________________________________ activation_2 (Activation) (None, 10) 0 ================================================================= Total params: 81,674 Trainable params: 81,674 Non-trainable params: 0 _________________________________________________________________ Train on 60000 samples, validate on 10000 samples Epoch 1/20 60000/60000 [==============================] - 10s 172us/step - loss: 0.5226 - acc: 0.8277 - val_loss: 0.1751 - val_acc: 0.9451 Epoch 2/20 60000/60000 [==============================] - 8s 133us/step - loss: 0.1474 - acc: 0.9549 - val_loss: 0.1178 - val_acc: 0.9641 Epoch 3/20 60000/60000 [==============================] - 8s 133us/step - loss: 0.1017 - acc: 0.9690 - val_loss: 0.0836 - val_acc: 0.9748 Epoch 4/20 60000/60000 [==============================] - 8s 133us/step - loss: 0.0764 - acc: 0.9764 - val_loss: 0.0787 - val_acc: 0.9759 Epoch 5/20 60000/60000 [==============================] - 8s 133us/step - loss: 0.0607 - acc: 0.9811 - val_loss: 0.0646 - val_acc: 0.9813 Epoch 6/20 60000/60000 [==============================] - 8s 133us/step - loss: 0.0542 - acc: 0.9834 - val_loss: 0.0630 - val_acc: 0.9801 Epoch 7/20 60000/60000 [==============================] - 8s 133us/step - loss: 0.0452 - acc: 0.9859 - val_loss: 0.0603 - val_acc: 0.9803 Epoch 8/20 60000/60000 [==============================] - 8s 133us/step - loss: 0.0406 - acc: 0.9874 - val_loss: 0.0531 - val_acc: 0.9849 Epoch 9/20 60000/60000 [==============================] - 8s 133us/step - loss: 0.0345 - acc: 0.9888 - val_loss: 0.0540 - val_acc: 0.9834 Epoch 10/20 60000/60000 [==============================] - 8s 132us/step - loss: 0.0305 - acc: 0.9901 - val_loss: 0.0483 - val_acc: 0.9848 Epoch 11/20 60000/60000 [==============================] - 8s 133us/step - loss: 0.0281 - acc: 0.9913 - val_loss: 0.0517 - val_acc: 0.9843 Epoch 12/20 60000/60000 [==============================] - 8s 133us/step - loss: 0.0256 - acc: 0.9918 - val_loss: 0.0472 - val_acc: 0.9847 Epoch 13/20 60000/60000 [==============================] - 8s 133us/step - loss: 0.0229 - acc: 0.9929 - val_loss: 0.0441 - val_acc: 0.9874 Epoch 14/20 60000/60000 [==============================] - 8s 133us/step - loss: 0.0204 - acc: 0.9935 - val_loss: 0.0490 - val_acc: 0.9855 Epoch 15/20 60000/60000 [==============================] - 8s 133us/step - loss: 0.0192 - acc: 0.9938 - val_loss: 0.0486 - val_acc: 0.9851 Epoch 16/20 60000/60000 [==============================] - 8s 133us/step - loss: 0.0203 - acc: 0.9937 - val_loss: 0.0450 - val_acc: 0.9866 Epoch 17/20 60000/60000 [==============================] - 8s 133us/step - loss: 0.0160 - acc: 0.9948 - val_loss: 0.0391 - val_acc: 0.9882 Epoch 18/20 60000/60000 [==============================] - 8s 133us/step - loss: 0.0147 - acc: 0.9955 - val_loss: 0.0544 - val_acc: 0.9834 Epoch 19/20 60000/60000 [==============================] - 8s 133us/step - loss: 0.0147 - acc: 0.9953 - val_loss: 0.0456 - val_acc: 0.9880 Epoch 20/20 60000/60000 [==============================] - 8s 133us/step - loss: 0.0153 - acc: 0.9952 - val_loss: 0.0465 - val_acc: 0.9867 LSTM test score(loss value): 0.046479647984029725 LSTM test accuracy: 0.9867

可知LSTM在測試集上的最終預(yù)測準(zhǔn)確率為98.67%。

采用同樣的思路，把Simple RNN改為GRU，即可調(diào)用GRU進(jìn)行模型訓(xùn)練。

訓(xùn)練結(jié)果：

_________________________________________________________________ Layer (type) Output Shape Param # ================================================================= gru_1 (GRU) (None, 128) 60288 _________________________________________________________________ dense_3 (Dense) (None, 10) 1290 _________________________________________________________________ activation_3 (Activation) (None, 10) 0 ================================================================= Total params: 61,578 Trainable params: 61,578 Non-trainable params: 0 _________________________________________________________________ Train on 60000 samples, validate on 10000 samples Epoch 1/20 60000/60000 [==============================] - 10s 166us/step - loss: 0.6273 - acc: 0.7945 - val_loss: 0.2062 - val_acc: 0.9400 Epoch 2/20 60000/60000 [==============================] - 8s 130us/step - loss: 0.1656 - acc: 0.9501 - val_loss: 0.1261 - val_acc: 0.9606 Epoch 3/20 60000/60000 [==============================] - 8s 130us/step - loss: 0.1086 - acc: 0.9667 - val_loss: 0.0950 - val_acc: 0.9697 Epoch 4/20 60000/60000 [==============================] - 8s 130us/step - loss: 0.0824 - acc: 0.9745 - val_loss: 0.0761 - val_acc: 0.9769 Epoch 5/20 60000/60000 [==============================] - 8s 130us/step - loss: 0.0644 - acc: 0.9797 - val_loss: 0.0706 - val_acc: 0.9793 Epoch 6/20 60000/60000 [==============================] - 8s 130us/step - loss: 0.0540 - acc: 0.9829 - val_loss: 0.0678 - val_acc: 0.9799 Epoch 7/20 60000/60000 [==============================] - 8s 130us/step - loss: 0.0479 - acc: 0.9854 - val_loss: 0.0601 - val_acc: 0.9811 Epoch 8/20 60000/60000 [==============================] - 8s 130us/step - loss: 0.0402 - acc: 0.9877 - val_loss: 0.0495 - val_acc: 0.9848 Epoch 9/20 60000/60000 [==============================] - 8s 130us/step - loss: 0.0346 - acc: 0.9895 - val_loss: 0.0591 - val_acc: 0.9821 Epoch 10/20 60000/60000 [==============================] - 8s 130us/step - loss: 0.0306 - acc: 0.9901 - val_loss: 0.0560 - val_acc: 0.9836 Epoch 11/20 60000/60000 [==============================] - 8s 130us/step - loss: 0.0290 - acc: 0.9910 - val_loss: 0.0473 - val_acc: 0.9857 Epoch 12/20 60000/60000 [==============================] - 8s 130us/step - loss: 0.0249 - acc: 0.9922 - val_loss: 0.0516 - val_acc: 0.9852 Epoch 13/20 60000/60000 [==============================] - 8s 130us/step - loss: 0.0222 - acc: 0.9930 - val_loss: 0.0448 - val_acc: 0.9863 Epoch 14/20 60000/60000 [==============================] - 8s 130us/step - loss: 0.0206 - acc: 0.9934 - val_loss: 0.0453 - val_acc: 0.9872 Epoch 15/20 60000/60000 [==============================] - 8s 130us/step - loss: 0.0178 - acc: 0.9944 - val_loss: 0.0559 - val_acc: 0.9833 Epoch 16/20 60000/60000 [==============================] - 8s 130us/step - loss: 0.0173 - acc: 0.9947 - val_loss: 0.0502 - val_acc: 0.9854 Epoch 17/20 60000/60000 [==============================] - 8s 130us/step - loss: 0.0150 - acc: 0.9955 - val_loss: 0.0401 - val_acc: 0.9880 Epoch 18/20 60000/60000 [==============================] - 8s 130us/step - loss: 0.0164 - acc: 0.9949 - val_loss: 0.0486 - val_acc: 0.9872 Epoch 19/20 60000/60000 [==============================] - 8s 130us/step - loss: 0.0133 - acc: 0.9960 - val_loss: 0.0468 - val_acc: 0.9882 Epoch 20/20 60000/60000 [==============================] - 8s 130us/step - loss: 0.0107 - acc: 0.9965 - val_loss: 0.0470 - val_acc: 0.9879 GRU test score(loss value): 0.04698457587567973 GRU test accuracy: 0.9879

可知GRU在測試集上的最終預(yù)測準(zhǔn)確率為98.79%。

由上述實驗結(jié)果可知，LSTM和GRU的預(yù)測準(zhǔn)確率要顯著高于Simple RNN，而LSTM和GRU的預(yù)測準(zhǔn)確率相差較小。

5.3、基于Pytorch的實戰(zhàn)

5.3.1、核心API

torch.nn.LSTM(*args,**kwargs)

其構(gòu)造器的參數(shù)列表如下：

• input_size?– 每個time step中其輸入向量xt的維度。
• hidden_size?– 每個time step中其隱藏狀態(tài)向量ht的維度。
• num_layers?– 每個time step中其縱向有幾個LSTM單元，默認(rèn)為1。如果取2，第二層的?xt是第一層的ht，有時也會加一個dropout因子。
• bias?– 如果為False，則計算中不用偏置，默認(rèn)為True。
• batch_first?–若為True，則實際調(diào)用時input和output張量格式為(batch, seq, feature)，默認(rèn)為False。
• dropout?– 是否加dropout，Default: 0。
• bidirectional?– 是否為雙向LSTM，Default: False。

定義了模型，實際調(diào)用按如下方式：

lstm = nn.LSTM(3, 3)# Inputs: input, (h_0, c_0) 
# Outputs: output, (h_n, c_n)
Outputs=lstm(Inputs)

注意上述代碼中：
1）h_0, c_0分別代表batch中每個元素的hidden state和cell state的初始化值。

2）h_n, c_n分別代表當(dāng)t = seq_len時，hidden state和cell state的值。

3）如果batch_first=False時，input格式為：(seq_len, batch=1, input_size)，output格式為：(seq_len, batch=1, num_directions * hidden_size)。但是當(dāng)batch_first=True時，input的格式變?yōu)?#xff1a;(batch_size, seq_len, input_size)，而output的格式變?yōu)?#xff1a;(batch_size, seq_len, num_directions * hidden_size)。

5.3.2、LSTM實戰(zhàn)

1）簡單demo

# simple demo
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optimtorch.manual_seed(1)lstm = nn.LSTM(3, 3)  # 一個詞的 input_size, hidden_state_size
inputs = [torch.randn(1, 3) for _ in range(5)] # 定義LSTM的輸入數(shù)據(jù)，此處不是mini batchhidden = (torch.randn(1, 1, 3),    # h_0(initial hidden state) of shape (num_layers * num_directions, batch, hidden_size)torch.randn(1, 1, 3))    # c_0(initial cell state) of shape (num_layers * num_directions, batch, hidden_size)for i in inputs:# Step through the sequence one element at a time: 此處一個sequence中實際只有一個word# out shape (seq_len, batch, num_directions * hidden_size): return (h_t) from the last layer of the LSTM, for each t# hidden=(hn,cn) when t = seq_len# h_n of shape (num_layers * num_directions, batch, hidden_size), c_n of shape (num_layers * num_directions, batch, hidden_size)out, hidden = lstm(i.view(1, 1, -1), hidden)print("i={},out={},hidden={}".format(i,out,hidden))# 接下來，我們把5個單詞全部放在一個sequence中進(jìn)行處理
inputs = torch.cat(inputs).view(len(inputs), 1, -1)  # 先轉(zhuǎn)為ndarray，把二維張量轉(zhuǎn)為三維張量
hidden = (torch.randn(1, 1, 3), torch.randn(1, 1, 3))  # clean out h0,c0
out, hn_cn = lstm(inputs, hidden)
print("\nout={},hn_cn={}".format(out,hn_cn))

2）完整demo

###數(shù)據(jù)準(zhǔn)備
def prepare_sequence(seq, to_ix):idxs = [to_ix[w] for w in seq]return torch.tensor(idxs, dtype=torch.long)training_data = [("The dog ate the apple".split(), ["DET", "NN", "V", "DET", "NN"]),("Everybody read that book".split(), ["NN", "V", "DET", "NN"])
]
word_to_ix = {}
for sent, tags in training_data:for word in sent:if word not in word_to_ix:word_to_ix[word] = len(word_to_ix)
print(word_to_ix)
tag_to_ix = {"DET": 0, "NN": 1, "V": 2}# These will usually be more like 32 or 64 dimensional.
# We will keep them small, so we can see how the weights change as we train.
EMBEDDING_DIM = 6
HIDDEN_DIM = 6### 定義模型
class LSTMTagger(nn.Module):def __init__(self, embedding_dim, hidden_dim, vocab_size, tagset_size):super(LSTMTagger, self).__init__()self.hidden_dim = hidden_dimself.word_embeddings = nn.Embedding(vocab_size, embedding_dim)self.lstm = nn.LSTM(embedding_dim, hidden_dim)# The linear layer that maps from hidden state space to tag space，相當(dāng)于一個全連接層self.hidden2tag = nn.Linear(hidden_dim, tagset_size)def forward(self, sentence):embeds = self.word_embeddings(sentence)lstm_out, _ = self.lstm(embeds.view(len(sentence), 1, -1))tag_space = self.hidden2tag(lstm_out.view(len(sentence), -1))  # 把三維張量轉(zhuǎn)化為二級張量tag_scores = F.log_softmax(tag_space, dim=1)return tag_scores### 模型訓(xùn)練及預(yù)測
model = LSTMTagger(EMBEDDING_DIM, HIDDEN_DIM, len(word_to_ix), len(tag_to_ix))
loss_function = nn.NLLLoss()    # 調(diào)用時形式為：預(yù)測值(N*C),label(N)。其中N為序列中word數(shù)，C為label的類別數(shù)
optimizer = optim.SGD(model.parameters(), lr=0.1)# See what the scores are before training
# Note that element i,j of the output is the score for tag j for word i.
# Here we don't need to train, so the code is wrapped in torch.no_grad()
with torch.no_grad():inputs = prepare_sequence(training_data[0][0], word_to_ix)tag_scores = model(inputs)  # 此處的inputs只能是一個sequenceprint(tag_scores)for epoch in range(300):  # again, normally you would NOT do 300 epochs, it is toy datafor sentence, tags in training_data:# Step 1. Remember that Pytorch accumulates gradients.# We need to clear them out before each instancemodel.zero_grad()# Step 2. Get our inputs ready for the network, that is, turn them into# Tensors of word indices.sentence_in = prepare_sequence(sentence, word_to_ix)targets = prepare_sequence(tags, tag_to_ix)    #一個sequence對應(yīng)的詞性標(biāo)注list# Step 3. Run our forward pass.tag_scores = model(sentence_in)# Step 4. Compute the loss, gradients, and update the parameters by#  calling optimizer.step()loss = loss_function(tag_scores, targets)loss.backward()optimizer.step()# See what the scores are after training
with torch.no_grad():inputs = prepare_sequence(training_data[0][0], word_to_ix)tag_scores = model(inputs)# The sentence is "the dog ate the apple".  i,j corresponds to score for tag j# for word i. The predicted tag is the maximum scoring tag.# Here, we can see the predicted sequence below is 0 1 2 0 1# since 0 is index of the maximum value of row 1,# 1 is the index of maximum value of row 2, etc.# Which is DET NOUN VERB DET NOUN, the correct sequence!print("[result]tag_scores={}".format(tag_scores))

---

參考文獻(xiàn)

[1] S. Hochreiter and J. Schmidhuber, “Long Short-Term Memory,” Neural Comput, vol. 9, no. 8, pp. 1735–1780, Nov. 1997.

[2] F. A. Gers, J. Schmidhuber, and F. A. Cummins, “Learning to Forget: Continual Prediction with LSTM,” Neural Comput., vol. 12, pp. 2451–2471, 2000.

[3] F. A. Gers and J. Schmidhuber, “Recurrent nets that time and count,” Proc. IEEE-INNS-ENNS Int. Jt. Conf. Neural Netw. IJCNN 2000 Neural Comput. New Chall. Perspect. New Millenn., vol. 3, pp. 189–194 vol.3, 2000.

[4] A. Graves and J. Schmidhuber, “Framewise phoneme classification with bidirectional LSTM and other neural network architectures,” Neural Netw., vol. 18, no. 5, pp. 602–610, Jul. 2005.

[5] K. Greff, R. K. Srivastava, J. Koutník, B. R. Steunebrink, and J. Schmidhuber, “LSTM: A Search Space Odyssey,” IEEE Trans. Neural Netw. Learn. Syst., vol. 28, no. 10, pp. 2222–2232, Oct. 2017.

[6] K. Cho et al., “Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation,” ArXiv14061078 Cs Stat, Jun. 2014.

[7] J. Chung, C. Gulcehre, K. Cho, and Y. Bengio, “Empirical Evaluation of Gated Recurrent Neural Networks on Sequence Modeling,” ArXiv14123555 Cs, Dec. 2014.

參考鏈接：

長短期記憶神經(jīng)網(wǎng)絡(luò)（LSTM）介紹以及簡單應(yīng)用分析「建議收藏」-騰訊云開發(fā)者社區(qū)-騰訊云

LSTM原理及實戰(zhàn) - 知乎

LSTM--概念、作用、原理、優(yōu)缺點以及簡單的示例代碼_lstm一般用來處理什么數(shù)據(jù)-CSDN博客