寫給程序員的機器學習入門 (五) - 遞歸模型 RNN，LSTM 與 GRU
遞歸模型的應用場景
在前面的文章中咱們看到的多層線性模型能處理的輸入數量是固定的，若是一個模型能接收兩個輸入那麼你就不能給它傳一個或者三個。而有時候咱們須要根據數量不必定的輸入來預測輸出，例如文本就是數量不必定的輸入，「這部片很是好看」 有 7 個字，「這部片很無聊」 有 6 個字，若是咱們想根據文本判斷是正面評價仍是負面評價，那麼就須要使用支持不定長度 (便可以接收 6 個又能夠接收 7 個) 輸入的模型。時序性的數據數量也是不必定的，例如一個運動中的球，從某個時間點開始的第 0 秒在位置 1，第 1 秒在位置 3，第 2 秒在位置 5，那麼正確的模型應該能夠預測出第 3 秒在位置 7，以下圖所示。固然，時序性的數據能夠固定一個窗口（例如最近的 5 條數據）來處理，這樣輸入數量就是必定的，但靈活性就下降了，窗口設置太小可能會致使沒有足夠的信息用於預測輸出，過大則會影響性能。python
遞歸模型 (Recursive Model) 能夠用於處理不定長度的輸入，用法是一次只傳固定數量的輸入給模型，能夠分屢次傳，傳的次數根據數據而定。以上述例子來講，「這部片很是好看」 每次傳一個字須要傳 7 次，「這部片很無聊」 每次傳一個字須要傳 6 次。而遞歸模型每收到一次輸入都會返回一次輸出，有的場景只會使用最後一次輸出的結果 (例如這個例子)，而有的場景則會使用每一次輸出的結果。git
換成代碼能夠這樣理解：github
model = MyRecursiveModel()
model('這')
model('部')
model('片')
model('非')
model('常')
model('好')
last_output = model('看')
print(last_output)
接下來咱們看看幾個經典的遞歸模型是怎麼實現的。app
最簡單的遞歸模型 - RNN (tanh)
RNN tanh (Recurrent Neural Network - tanh) 是最簡單的遞歸模型，計算公式以下，數學很差的第一印象可能會以爲媽呀一看數學公式就頭昏腦脹了🙀，咱們先一個個參數來分析，H 是遞歸模型內部記錄的一個隱藏值矩陣，Ht 表明當前時序的值，而 H(t-1) 表明前一個時序的值，t 能夠置換到具體的數字，例如 Ht0 表明隱藏值矩陣最開始的狀態 (通常會使用 0 初始化)，Ht1 表明隱藏值矩陣第一次更新之後的狀態，Ht2 代筆隱藏值矩陣第二次更新之後的狀態，計算 Ht1 時 H(t-1) 表明 Ht0，計算 Ht2 時 H(t-1) 表明 Ht1；Wx 是針對輸入的權重值，Bx 是針對輸入的偏移值，Wh 是針對隱藏的權重值，Bh 是針對隱藏的偏移值；tanh 用於把實數轉換爲 -1 ~ 1 之間的範圍。這個公式和以前咱們看到的人工神經元很類似，只是把每一次的輸入和當前隱藏值通過計算後的值加在一塊兒，而後使用 tanh 做爲激活函數生成新的隱藏值，隱藏值會看成每一次的輸出使用。dom
若是你以爲文本難以理解，能夠看展開之後的公式：函數
能夠看到每次的輸出結果都會根據以前的輸入計算，tanh 用於非線性過濾和控制值範圍在 -1 ~ 1 之間。工具
你也能夠參考下面的計算圖來理解，圖中展現了 RNN tanh 模型如何計算三次輸入和返回三次輸出 (注意最後加了一層額外的線性模型用於把 RNN 返回的隱藏值轉換爲預測輸出)：性能
(看不清請在新標籤單獨打開圖片，或者另存爲到本地之後查看)學習
在 pytorch 中使用 RNN
由於遞歸模型支持不定長度的數據，而 pytorch 圍繞 tensor 來進行運算，tensor 的維度又是固定的，要在 pytorch 中使用遞歸模型須要很繁瑣的處理，下圖說明了處理的整個流程：測試
咱們再來看看怎樣在代碼裏面實現這個流程：
# 引用 pytorch 類庫
>>> import torch
# 準備數據集
>>> data1 = torch.tensor([1, 2, 3], dtype=torch.float)
>>> data2 = torch.tensor([3, 5, 7, 9, 11], dtype=torch.float)
>>> datalist = [data1, data2]
# 合併到一個 tensor 並填充數據集到相同長度
# 這裏使用 batch_first 指定第一維度爲批次數量
>>> padded = torch.nn.utils.rnn.pad_sequence(datalist, batch_first=True)
>>> padded
tensor([[ 1., 2., 3., 0., 0.],
[ 3., 5., 7., 9., 11.]])
# 另建一個 tensor 來保存各組數據的實際長度
>>> lengths = torch.tensor([len(x) for x in datalist])
>>> lengths
tensor([3, 5])
# 創建 RNN 模型，每次接收 1 個輸入，內部擁有 8 個隱藏值 (每次都會返回 8 個最新的隱藏值)
# 指定 num_layers 能夠在內部疊加 RNN 模型，這裏不疊加因此只指定 1
>>> rnn_model = torch.nn.RNN(input_size = 1, hidden_size = 8, num_layers = 1, batch_first = True)
# 創建 Linear 模型，每次接收 8 個輸入 (RNN 模型返回的隱藏值)，返回 1 個輸出
>>> linear_model = torch.nn.Linear(in_features = 8, out_features = 1)
# 改變 tensor 維度到 batch_size, input_size, step_size
# 即 批次數量, 輸入次數, 每次傳給模型的輸入數量
>>> x = padded.reshape(padded.shape[0], padded.shape[1], 1)
>>> x
tensor([[[ 1.],
[ 2.],
[ 3.],
[ 0.],
[ 0.]],
[[ 3.],
[ 5.],
[ 7.],
[ 9.],
[11.]]])
# 把數據 tensor 和長度 tensor 合併到一個結構體
# 這樣作的意義是能夠避免 RNN 計算填充的那些 0
# enforce_sorted 表示數據事先沒有排序過，若是不指定這個選項會出錯
>>> packed = torch.nn.utils.rnn.pack_padded_sequence(x, lengths, batch_first=True, enforce_sorted=False)
>>> packed
PackedSequence(data=tensor([[ 3.],
[ 1.],
[ 5.],
[ 2.],
[ 7.],
[ 3.],
[ 9.],
[11.]]), batch_sizes=tensor([2, 2, 2, 1, 1]), sorted_indices=tensor([1, 0]), unsorted_indices=tensor([1, 0]))
# 把結構體傳給模型
# 模型會返回各個輸入對應的輸出，維度是 實際處理的輸入數量, hidden_size
# 模型還會返回最新的隱藏值
>>> output, hidden = rnn_model(packed)
>>> output
PackedSequence(data=tensor([[-0.3055, 0.2916, 0.2736, -0.0502, -0.4033, -0.1438, -0.6981, 0.6284],
[-0.2343, 0.2279, 0.0595, 0.1867, -0.2527, -0.0518, -0.1913, 0.5276],
[-0.0556, 0.2870, 0.3035, -0.3519, -0.4015, 0.1584, -0.9157, 0.6472],
[-0.1488, 0.2706, 0.1115, -0.0131, -0.2350, 0.1252, -0.4981, 0.5706],
[-0.0179, 0.1201, 0.4751, -0.5256, -0.3701, 0.1289, -0.9834, 0.7087],
[-0.1094, 0.1283, 0.1698, -0.1136, -0.1999, 0.1847, -0.7394, 0.5756],
[ 0.0426, 0.1866, 0.5581, -0.6716, -0.4857, 0.0039, -0.9964, 0.7603],
[ 0.0931, 0.2418, 0.6602, -0.7674, -0.6003, -0.0989, -0.9991, 0.8172]],
grad_fn=<CatBackward>), batch_sizes=tensor([2, 2, 2, 1, 1]), sorted_indices=tensor([1, 0]), unsorted_indices=tensor([1, 0]))
>>> hidden
tensor([[[-0.1094, 0.1283, 0.1698, -0.1136, -0.1999, 0.1847, -0.7394,
0.5756],
[ 0.0931, 0.2418, 0.6602, -0.7674, -0.6003, -0.0989, -0.9991,
0.8172]]], grad_fn=<IndexSelectBackward>)
# 把連在一塊兒的輸出解壓到一個 tensor
# 解壓後的維度是 batch_size, input_size, hidden_size
# 注意第二個返回值是各組輸出的實際長度，等於以前的 lengths，因此咱們不須要
>>> unpacked, _ = torch.nn.utils.rnn.pad_packed_sequence(output, batch_first=True)
>>> unpacked
tensor([[[-0.2343, 0.2279, 0.0595, 0.1867, -0.2527, -0.0518, -0.1913,
0.5276],
[-0.1488, 0.2706, 0.1115, -0.0131, -0.2350, 0.1252, -0.4981,
0.5706],
[-0.1094, 0.1283, 0.1698, -0.1136, -0.1999, 0.1847, -0.7394,
0.5756],
[ 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
0.0000],
[ 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
0.0000]],
[[-0.3055, 0.2916, 0.2736, -0.0502, -0.4033, -0.1438, -0.6981,
0.6284],
[-0.0556, 0.2870, 0.3035, -0.3519, -0.4015, 0.1584, -0.9157,
0.6472],
[-0.0179, 0.1201, 0.4751, -0.5256, -0.3701, 0.1289, -0.9834,
0.7087],
[ 0.0426, 0.1866, 0.5581, -0.6716, -0.4857, 0.0039, -0.9964,
0.7603],
[ 0.0931, 0.2418, 0.6602, -0.7674, -0.6003, -0.0989, -0.9991,
0.8172]]], grad_fn=<IndexSelectBackward>)
# 提取最後一個輸出 (根據業務而定)
# 提取後的維度是 batch_size, hidden_size
# 能夠看到使用 RNN tanh 時最後一個輸出的值等於以前返回的 hidden
>>> last_hidden = unpacked.gather(1, (lengths - 1).reshape(-1, 1, 1).repeat(1, 1, unpacked.shape[2]))
>>> last_hidden
tensor([[[-0.1094, 0.1283, 0.1698, -0.1136, -0.1999, 0.1847, -0.7394,
0.5756]],
[[ 0.0931, 0.2418, 0.6602, -0.7674, -0.6003, -0.0989, -0.9991,
0.8172]]], grad_fn=<GatherBackward>)
# 把 RNN 模型返回的隱藏值傳給 Linear 模型，得出預測輸出
>>> predicted = linear_model(last_hidden)
>>> predicted
tensor([[[0.1553]],
[[0.1431]]], grad_fn=<AddBackward0>)
以後根據實際輸出計算偏差，而後根據自動微分調整參數便可進行訓練。
RNN 的簡單例子
如今咱們來經過一個簡單的例子實踐 RNN 模型，假設有一個球，球只能夠雙方向勻速移動，把某一點定作位置 0，點的右邊按必定間隔定作位置 1, 2, 3 ...，點的左邊按必定間隔定作位置 -1, -2, -3, 如今有球的移動位置數據，例如：
1,3,5,7,9
表示記錄了 5 次球的移動位置，每次球都移動了 2 個位置的距離，若是咱們要創建一個 RNN 模型根據球的歷史位置預測未來位置，那麼傳入 1,3,5,7 模型應該能夠返回 9，若是球向反方向運動，傳入 9,7,5,3 模型應該能夠返回 1。
我準備了 10000 條這樣的數據，能夠從 https://github.com/303248153/BlogArchive/tree/master/ml-05/ball.csv 下載。
如下是訓練和使用模型的代碼，跟上一篇文章介紹的代碼結構基本上相同，注意代碼會切分數據到輸入 (除了最後一個位置) 和輸出 (最後一個位置)：
import os
import sys
import torch
import gzip
import itertools
from torch import nn
from matplotlib import pyplot
class MyModel(nn.Module):
"""根據球的歷史位置預測未來位置的模型，假設球只能雙方向勻速移動"""
def __init__(self):
super().__init__()
self.rnn = nn.RNN(
input_size = 1,
hidden_size = 8,
num_layers = 1,
batch_first = True
)
self.linear = nn.Linear(in_features=8, out_features=1)
def forward(self, x, lengths):
# 附加長度信息，避免 RNN 計算填充的數據
packed = nn.utils.rnn.pack_padded_sequence(
x, lengths, batch_first=True, enforce_sorted=False)
# 使用遞歸模型計算，返回各個輸入對應的輸出和最終的隱藏狀態
# 由於 RNN tanh 直接把隱藏值做爲輸出，因此 output 的最後一個值提取出來會等於 hidden
# 平時爲了方即可以直接使用 hidden，但這裏爲了演示怎麼提取會使用 output
output, hidden = self.rnn(packed)
# output 內部會鏈接全部隱藏狀態，shape = 實際輸入數量合計, hidden_size
# 爲了接下來的處理，須要先整理 shape = batch_size, 每組的最大輸入數量, hidden_size
# 第二個返回值是各個 tensor 的實際長度，內容和 lengths 相同，因此能夠省略掉
unpacked, _ = nn.utils.rnn.pad_packed_sequence(output, batch_first=True)
# 提取最後一個輸入對應的輸出, shape = batch_size, 1, hidden_size
# 對於大部分遞歸模型, last_hidden 的值實際上會等於 hidden
last_hidden = unpacked.gather(1, (lengths - 1).reshape(-1, 1, 1).repeat(1, 1, unpacked.shape[2]))
# 傳給線性模型把隱藏值轉換到預測輸出
y = self.linear(last_hidden.reshape(last_hidden.shape[0], last_hidden.shape[2]))
return y
def save_tensor(tensor, path):
"""保存 tensor 對象到文件"""
torch.save(tensor, gzip.GzipFile(path, "wb"))
def load_tensor(path):
"""從文件讀取 tensor 對象"""
return torch.load(gzip.GzipFile(path, "rb"))
def prepare_save_batch(batch, pending_tensors):
"""準備訓練 - 保存單個批次的數據"""
# 整合長度不等的 tensor 列表到一個 tensor，不足的長度會填充 0
dataset_tensor = nn.utils.rnn.pad_sequence(pending_tensors, batch_first=True)
# 正規化數據，由於大部分數據都落在 -50 ~ 50 的區間中，這裏能夠所有除以 50
dataset_tensor /= 50
# 另外保存各個 tensor 的長度
lengths_tensor = torch.tensor([t.shape[0] for t in pending_tensors])
# 切分訓練集 (60%)，驗證集 (20%) 和測試集 (20%)
random_indices = torch.randperm(dataset_tensor.shape[0])
traning_indices = random_indices[:int(len(random_indices)*0.6)]
validating_indices = random_indices[int(len(random_indices)*0.6):int(len(random_indices)*0.8):]
testing_indices = random_indices[int(len(random_indices)*0.8):]
training_set = (dataset_tensor[traning_indices], lengths_tensor[traning_indices])
validating_set = (dataset_tensor[validating_indices], lengths_tensor[validating_indices])
testing_set = (dataset_tensor[testing_indices], lengths_tensor[testing_indices])
# 保存到硬盤
save_tensor(training_set, f"data/training_set.{batch}.pt")
save_tensor(validating_set, f"data/validating_set.{batch}.pt")
save_tensor(testing_set, f"data/testing_set.{batch}.pt")
print(f"batch {batch} saved")
def prepare():
"""準備訓練"""
# 數據集轉換到 tensor 之後會保存在 data 文件夾下
if not os.path.isdir("data"):
os.makedirs("data")
# 從 csv 讀取原始數據集，分批每次處理 2000 行
# 由於 pandas 不支持讀取動態長度的 csv 文件，這裏須要使用原始方法讀取
batch = 0
pending_tensors = []
for line in open('ball.csv', 'r'):
t = torch.tensor([int(x) for x in line.split(',')], dtype=torch.float)
pending_tensors.append(t)
if len(pending_tensors) >= 2000:
prepare_save_batch(batch, pending_tensors)
batch += 1
pending_tensors.clear()
if pending_tensors:
prepare_save_batch(batch, pending_tensors)
batch += 1
pending_tensors.clear()
def train():
"""開始訓練"""
# 建立模型實例
model = MyModel()
# 建立損失計算器
loss_function = torch.nn.MSELoss()
# 建立參數調整器
optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
# 記錄訓練集和驗證集的正確率變化
traning_accuracy_history = []
validating_accuracy_history = []
# 記錄最高的驗證集正確率
validating_accuracy_highest = 0
validating_accuracy_highest_epoch = 0
# 讀取批次的工具函數
def read_batches(base_path):
for batch in itertools.count():
path = f"{base_path}.{batch}.pt"
if not os.path.isfile(path):
break
yield load_tensor(path)
# 計算正確率的工具函數
def calc_accuracy(actual, predicted):
return 1 - ((actual - predicted).abs() / (actual.abs() + 0.0001)).mean().item()
# 劃分輸入和輸出的工具函數，輸出爲最後一個位置，輸入爲以前的位置
def split_batch_xy(batch, begin=None, end=None):
# shape = batch_size, input_size
batch_x = batch[0][begin:end]
# shape = batch_size, 1
batch_x_lengths = batch[1][begin:end] - 1
# shape = batch_size, 1
batch_y = batch_x.gather(1, batch_x_lengths.reshape(-1, 1))
# shape = batch_size, input_size, step_size = batch_size, input_size, 1
batch_x = batch_x.reshape(batch_x.shape[0], batch_x.shape[1], 1)
return batch_x, batch_x_lengths, batch_y
# 開始訓練過程
for epoch in range(1, 10000):
print(f"epoch: {epoch}")
# 根據訓練集訓練並修改參數
# 切換模型到訓練模式，將會啓用自動微分，批次正規化 (BatchNorm) 與 Dropout
model.train()
traning_accuracy_list = []
for batch in read_batches("data/training_set"):
# 切分小批次，有助於泛化模型
for index in range(0, batch[0].shape[0], 100):
# 劃分輸入和輸出
batch_x, batch_x_lengths, batch_y = split_batch_xy(batch, index, index+100)
# 計算預測值
predicted = model(batch_x, batch_x_lengths)
# 計算損失
loss = loss_function(predicted, batch_y)
# 從損失自動微分求導函數值
loss.backward()
# 使用參數調整器調整參數
optimizer.step()
# 清空導函數值
optimizer.zero_grad()
# 記錄這一個批次的正確率，torch.no_grad 表明臨時禁用自動微分功能
with torch.no_grad():
traning_accuracy_list.append(calc_accuracy(batch_y, predicted))
traning_accuracy = sum(traning_accuracy_list) / len(traning_accuracy_list)
traning_accuracy_history.append(traning_accuracy)
print(f"training accuracy: {traning_accuracy}")
# 檢查驗證集
# 切換模型到驗證模式，將會禁用自動微分，批次正規化 (BatchNorm) 與 Dropout
model.eval()
validating_accuracy_list = []
for batch in read_batches("data/validating_set"):
batch_x, batch_x_lengths, batch_y = split_batch_xy(batch)
predicted = model(batch_x, batch_x_lengths)
validating_accuracy_list.append(calc_accuracy(batch_y, predicted))
validating_accuracy = sum(validating_accuracy_list) / len(validating_accuracy_list)
validating_accuracy_history.append(validating_accuracy)
print(f"validating accuracy: {validating_accuracy}")
# 記錄最高的驗證集正確率與當時的模型狀態，判斷是否在 100 次訓練後仍然沒有刷新記錄
if validating_accuracy > validating_accuracy_highest:
validating_accuracy_highest = validating_accuracy
validating_accuracy_highest_epoch = epoch
save_tensor(model.state_dict(), "model.pt")
print("highest validating accuracy updated")
elif epoch - validating_accuracy_highest_epoch > 100:
# 在 100 次訓練後仍然沒有刷新記錄，結束訓練
print("stop training because highest validating accuracy not updated in 100 epoches")
break
# 使用達到最高正確率時的模型狀態
print(f"highest validating accuracy: {validating_accuracy_highest}",
f"from epoch {validating_accuracy_highest_epoch}")
model.load_state_dict(load_tensor("model.pt"))
# 檢查測試集
testing_accuracy_list = []
for batch in read_batches("data/testing_set"):
batch_x, batch_x_lengths, batch_y = split_batch_xy(batch)
predicted = model(batch_x, batch_x_lengths)
testing_accuracy_list.append(calc_accuracy(batch_y, predicted))
testing_accuracy = sum(testing_accuracy_list) / len(testing_accuracy_list)
print(f"testing accuracy: {testing_accuracy}")
# 顯示訓練集和驗證集的正確率變化
pyplot.plot(traning_accuracy_history, label="traning")
pyplot.plot(validating_accuracy_history, label="validing")
pyplot.ylim(0, 1)
pyplot.legend()
pyplot.show()
def eval_model():
"""使用訓練好的模型"""
# 建立模型實例，加載訓練好的狀態，而後切換到驗證模式
model = MyModel()
model.load_state_dict(load_tensor("model.pt"))
model.eval()
# 詢問輸入並預測輸出
while True:
try:
x = torch.tensor([int(x) for x in input("History ball locations: ").split(",")], dtype=torch.float)
# 正規化輸入
x /= 50
# 轉換矩陣大小，shape = batch_size, input_size, step_size
x = x.reshape(1, x.shape[0], 1)
lengths = torch.tensor([x.shape[1]])
# 預測輸出
y = model(x, lengths)
# 反正規化輸出
y *= 50
print("Next ball location:", y[0, 0].item(), "\n")
except Exception as e:
print("error:", e)
def main():
"""主函數"""
if len(sys.argv) < 2:
print(f"Please run: {sys.argv[0]} prepare|train|eval")
exit()
# 給隨機數生成器分配一個初始值，使得每次運行均可以生成相同的隨機數
# 這是爲了讓過程可重現，你也能夠選擇不這樣作
torch.random.manual_seed(0)
# 根據命令行參數選擇操做
operation = sys.argv[1]
if operation == "prepare":
prepare()
elif operation == "train":
train()
elif operation == "eval":
eval_model()
else:
raise ValueError(f"Unsupported operation: {operation}")
if __name__ == "__main__":
main()
執行如下命令便可準備數據集並訓練模型：
python3 example.py prepare python3 example.py train
最終輸出以下，驗證集和測試集正確度都達到了 92% (這個例子僅用於演示怎樣使用 RNN，若是你有興趣能夠試試怎樣提升正確度)：
epoch: 2351 training accuracy: 0.9427350702928379 validating accuracy: 0.9283818986266852 stop training because highest validating accuracy not updated in 100 epoches highest validating accuracy: 0.9284620460122823 from epoch 2250 testing accuracy: 0.9274853881448507
接下來執行如下命令便可使用模型：
python3 example.py eval
試試根據歷史位置預測未來位置，能夠看到預測值比較接近咱們預期的實際值🙂️：
History ball locations: 1,2,3 Next ball location: 3.8339991569519043 History ball locations: 3,5,7 Next ball location: 9.035120964050293 History ball locations: 9,7,5,3 Next ball location: 0.9755149483680725 History ball locations: 2,0,-2 Next ball location: -3.913722276687622 History ball locations: 0,-3,-6 Next ball location: -9.093448638916016
長短記憶模型 - LSTM
在看 RNN tanh 計算公式的時候，你可能會想起第三篇文章在介紹激活函數時提到的梯度消失 (Vanishing Gradient) 問題，若是給模型傳了 10 次輸入，那麼輸出就會疊加 10 次 tanh，這就致使前面的輸入對最終輸出的影響很是很是的小，例如 我對這部電視機很是滿意，便宜又清晰，我以前買的 LG 電視機常常失靈送去維修好幾回都沒有解決實在是太垃圾了，判斷這句話是正面評價仍是負面評價須要看前半部分，但 RNN tanh 的最終輸出受後半部分的影響更多，前半部分基本上會被忽略，因此沒法做出正確的判斷。把 tanh 函數換成 relu 函數必定程度上能夠緩解這個問題，但輸入的傳遞次數很是多的時候仍是沒法避免出現梯度消失。
爲了解決這個問題發明出來的就是長短記憶模型，略稱 LSTM (Long Short-Term Memory)。長短記憶模型的特徵是除了隱藏狀態 (Hidden State) 之外還有一個細胞狀態 (Cell State)，而且有輸入門 (Input Gate)，細胞門 (Cell Gate)，忘記門 (Forget Gate) 負責更新細胞狀態，和輸出門 (Output Gate) 負責從細胞狀態提取隱藏狀態，具體的計算公式以下：
若是你以爲公式難以理解能夠參考下面的計算圖，圖中展現了 LSTM 模型如何計算三次輸入和返回三次輸出 (注意最後加了線性模型用於轉換隱藏值到預測輸出)：
(看不清請在新標籤單獨打開圖片，或者另存爲到本地之後查看)
LSTM 模型的細胞狀態在疊加的過程當中只會使用乘法和加法，因此能夠避免梯度消失問題，而且輸入門能夠決定輸入是否重要，若是不重要則減小對細胞狀態的影響 (返回接近 0 的值)，忘記門能夠在遇到某些輸入的時候忘記細胞狀態中記錄的部分值，輸出門能夠根據輸入決定如何提取細胞狀態到隱藏值 (輸出)，這些門讓 LSTM 能夠學習更長的數據，而且能夠發揮更強的判斷能力，但同時也讓 LSTM 的計算量變大，須要使用更長的時間才能訓練成功。
簡化版長短記憶模型 - GRU
GRU (Gated Recurrent Unit) 是簡化版的長短記憶模型，去掉了細胞狀態而且只使用三個門，新增門負責計算更新隱藏狀態的值，重置門負責過濾部分更新隱藏狀態的值 (針對根據以前隱藏值計算的部分)，更新門負責計算更新比例，具體的計算公式以下：
若是你以爲公式難以理解能夠參考下面的計算圖，圖中展現了 GRU 模型如何計算三次輸入和返回三次輸出 (注意最後加了線性模型用於轉換隱藏值到預測輸出)：
(看不清請在新標籤單獨打開圖片，或者另存爲到本地之後查看)
能夠看到 GRU 模型的隱藏狀態在疊加的過程當中也是隻使用了乘法和加法，因此能夠避免梯度消失問題。GRU 模型比 LSTM 模型稍弱，可是計算量也相應減小了，給咱們多了一個不錯的中間選擇😼。
在 pytorch 中使用 LSTM 和 GRU
pytorch 幫咱們封裝了 LSTM 和 GRU 模型，基本上咱們只須要替換代碼中的 RNN 到 LSTM 或 GRU 便可，示例代碼以下：
>>> rnn_model = torch.nn.RNN(input_size = 1, hidden_size = 8, num_layers = 1, batch_first = True) >>> rnn_model = torch.nn.LSTM(input_size = 1, hidden_size = 8, num_layers = 1, batch_first = True) >>> rnn_model = torch.nn.GRU(input_size = 1, hidden_size = 8, num_layers = 1, batch_first = True)
寫在最後
這一篇着重介紹了 RNN tanh，LSTM 與 GRU 的計算方式，而且給出了一個很是簡單的例子說明如何在 pytorch 中應用 RNN。下一篇將會介紹更多實用的例子，包括天然語言處理和趨勢預測等，同時也會講解如何使用雙向遞歸模型。
最後喊一句口號😡：中國加油，中國必勝！
- 1. RNN,LSTM,GRU學習
- 2. RNN、LSTM、GRU
- 3. attention RNN LSTM Gru gate
- 4. RNN與LSTM模型
- 5. RNN - LSTM - GRU
- 6. 詳解RNN、LSTM、GRU
- 7. Lession5(RNN)--week1--LSTM,GRU
- 8. RNN&LSTM&GRU
- 9. 從RNN到LSTM、GRU、語言模型
- 10. RNN-LSTM-GRU學習筆記
- 更多相關文章...
- • Memcached入門教程 - NoSQL教程
- • Scala 遞歸函數 - Scala教程
- • YAML 入門教程
- • Kotlin學習（二）基本類型
-
每一个你不满意的现在，都有一个你没有努力的曾经。