门控循环单元（GRU）

一、定义

0、其他：

        gru与lstm效果差不多，在实际中都可以用，但是看到弹幕说gru在lstm之后，有点子优化的感觉。

        Rnn处理不了过长的序列，因为序列信息会被放在隐藏状态里面，当时间很长的时候，隐藏状态就会累积的太多，前面很久以前的信息就不能很好地抽取出来。

1、Gru可以通过构建门控单元去选择重要的地方和不重要的地方

        更新门对应的就是重要的信息，需要更新我们的状态，重置门就是不重要的信息，就让我们的隐藏状态遗忘一些东西

2、更新门与重置门

        （1）输入是由当前时间步的输入和前一时间步的隐状态给出，两个门的输出是由使用sigmoid激活函数的两个全连接层给出

（2）公式

3、候选隐状态

        （1）Rt的长度为hiddensize，介于0到1，是可以学习的参数；

        （2）Rt在更新新的隐藏状态的时候，要用多少过去的隐藏状态的信息，在算真正的隐藏状态的时候，需要多少关于xt的信息占比。

（3）公式

        使用tanh非线性激活函数来确保候选隐状态中的值保持在区间(−1,1)中

        重置门𝑅𝑡中的项接近1时， 就像一个普通的循环神经网络；

         重置门𝑅𝑡中所有接近0的项， 就像一个多层感知机的结果，任何预先存在的隐状态都会被重置为默认值。

4、隐状态

（1）公式

 （2）zt更新控制了过去的状态和现在得到的状态占比进行更新

5、总结

（1）在训练时多了一倍多需要学习的参数

（2）门控循环单元具有以下两个显著特征：

        重置门有助于捕获序列中的短期依赖关系；

        更新门有助于捕获序列中的长期依赖关系。

（3）门控循环神经网络可以更好地捕获时间步距离很长的序列上的依赖关系。

（4）重置门打开时，门控循环单元包含基本循环神经网络；更新门打开时，门控循环单元可以跳过子序列。

二、代码

1、读取时间机器数据集

import torch
from torch import nn
from d2l import torch as d2l

batch_size, num_steps = 32, 35
train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps)

2、初始化模型参数

def get_params(vocab_size, num_hiddens, device):
    num_inputs = num_outputs = vocab_size

    def normal(shape):
        return torch.randn(size=shape, device=device)*0.01

    def three():
        return (normal((num_inputs, num_hiddens)),
                normal((num_hiddens, num_hiddens)),
                torch.zeros(num_hiddens, device=device))

    W_xz, W_hz, b_z = three()  # 更新门参数
    W_xr, W_hr, b_r = three()  # 重置门参数
    W_xh, W_hh, b_h = three()  # 候选隐状态参数
    # 输出层参数
    W_hq = normal((num_hiddens, num_outputs))
    b_q = torch.zeros(num_outputs, device=device)
    # 附加梯度
    params = [W_xz, W_hz, b_z, W_xr, W_hr, b_r, W_xh, W_hh, b_h, W_hq, b_q]
    for param in params:
        param.requires_grad_(True)
    return params

3、定义模型

（1）定义隐状态初始化函数

def init_gru_state(batch_size, num_hiddens, device):
    return (torch.zeros((batch_size, num_hiddens), device=device), )

（2）定义门控循环单元模型（只是权重更新公式变了）

def gru(inputs, state, params):
    W_xz, W_hz, b_z, W_xr, W_hr, b_r, W_xh, W_hh, b_h, W_hq, b_q = params
    H, = state
    outputs = []
    for X in inputs:
        Z = torch.sigmoid((X @ W_xz) + (H @ W_hz) + b_z)
        R = torch.sigmoid((X @ W_xr) + (H @ W_hr) + b_r)
        H_tilda = torch.tanh((X @ W_xh) + ((R * H) @ W_hh) + b_h)
        H = Z * H + (1 - Z) * H_tilda
        Y = H @ W_hq + b_q
        outputs.append(Y)
    return torch.cat(outputs, dim=0), (H,)

4、训练与预测

vocab_size, num_hiddens, device = len(vocab), 256, d2l.try_gpu()
num_epochs, lr = 500, 1
model = d2l.RNNModelScratch(len(vocab), num_hiddens, device, get_params,
                            init_gru_state, gru)
d2l.train_ch8(model, train_iter, vocab, lr, num_epochs, device)

三、简洁实现

num_inputs = vocab_size
gru_layer = nn.GRU(num_inputs, num_hiddens)
model = d2l.RNNModel(gru_layer, len(vocab))
model = model.to(device)
d2l.train_ch8(model, train_iter, vocab, lr, num_epochs, device)