遞回模型的應用場景
在前面的文章中我們看到的多層線性模型能處理的輸入數量是固定的，如果一個模型能接收兩個輸入那么你就不能給它傳一個或者三個，而有時候我們需要根據數量不一定的輸入來預測輸出，例如文本就是數量不一定的輸入，“這部片非常好看” 有 7 個字，“這部片很無聊” 有 6 個字，如果我們想根據文本判斷是正面評價還是負面評價，那么就需要使用支持不定長度 (即可以接收 6 個又可以接收 7 個) 輸入的模型，時序性的資料數量也是不一定的，例如一個運動中的球，從某個時間點開始的第 0 秒在位置 1，第 1 秒在位置 3，第 2 秒在位置 5，那么正確的模型應該可以預測出第 3 秒在位置 7，如下圖所示，當然，時序性的資料可以固定一個視窗（例如最近的 5 條資料）來處理，這樣輸入數量就是一定的，但靈活性就降低了，視窗設定過小可能會導致沒有足夠的資訊用于預測輸出，過大則會影響性能，
遞回模型 (Recursive Model) 可以用于處理不定長度的輸入，用法是一次只傳固定數量的輸入給模型，可以分多次傳，傳的次數根據資料而定，以上述例子來說，“這部片非常好看” 每次傳一個字需要傳 7 次，“這部片很無聊” 每次傳一個字需要傳 6 次，而遞回模型每收到一次輸入都會回傳一次輸出，有的場景只會使用最后一次輸出的結果 (例如這個例子)，而有的場景則會使用每一次輸出的結果，
換成代碼可以這樣理解：
model = MyRecursiveModel()
model('這')
model('部')
model('片')
model('非')
model('常')
model('好')
last_output = model('看')
print(last_output)
接下來我們看看幾個經典的遞回模型是怎么實作的，
最簡單的遞回模型 - 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 作為激活函式生成新的隱藏值，隱藏值會當作每一次的輸出使用，
如果你覺得文本難以理解，可以看展開以后的公式：
可以看到每次的輸出結果都會根據之前的輸入計算，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=https://www.cnblogs.com/zkweb/p/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=), 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=)
# 把連在一起的輸出解壓到一個 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=)
# 提取最后一個輸出 (根據業務而定)
# 提取后的維度是 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=)
# 把 RNN 模型回傳的隱藏值傳給 Linear 模型，得出預測輸出
>>> predicted = linear_model(last_hidden)
>>> predicted
tensor([[[0.1553]],
[[0.1431]]], grad_fn=)
之后根據實際輸出計算誤差，然后根據自動微分調整引數即可進行訓練，
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，下一篇將會介紹更多實用的例子，包括自然語言處理和趨勢預測等，同時也會講解如何使用雙向遞回模型，
最后喊一句口號??：中國加油，中國必勝！
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/24867.html
標籤：其他
上一篇：運行提示串列索引超范圍 ，但是我沒看出來為什么超范圍。求助
下一篇：萌新求助