寫給程序員的機器學習入門 (五) - 遞歸模型 RNN，LSTM 與 GRU

遞歸模型的應用場景

在前面的文章中我們看到的多層線性模型能處理的輸入數量是固定的，如果一個模型能接收兩個輸入那么你就不能給它傳一個或者三個。而有時候我們需要根據數量不一定的輸入來預測輸出，例如文本就是數量不一定的輸入，“這部片非常好看” 有 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=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。下一篇將會介紹更多實用的例子，包括自然語言處理和趨勢預測等，同時也會講解如何使用雙向遞歸模型。

最后喊一句口號😡：中國加油，中國必勝！