【pytorch】现代循环神经网络-1

1 门控循环单元（GRU）

1.1 门控隐状态

重置门和更新门

把它们设计成(0, 1)区间中的向量。重置门允许我们控制“可能还想记住”的过去状态的数量；更新门将允许我们控制新状态中有多少个是旧状态的副本。

输入是由当前时间步的输入和前一时间步的隐状态给出。两个门的输出是由使用sigmoid激活函数的两个全连接层给出。
假设输入是一个小批量 Xt ∈ Rn×d （样本个数n，输入个数d），上一个时间步的隐状态是 Ht−1 ∈ Rn×h （隐藏单元个数h）。那么，重置门Rt ∈ Rn×h和更新门Zt ∈ Rn×h的计算如下所示：

候选隐状态

将重置门Rt 与常规隐状态更新机制集成，得到在时间步t的候选隐状态:

符号⊙是Hadamard积（按元素乘积）运算符。使用tanh非线性激活函数来确保候选隐状态中的值保持在区间(−1, 1)中。
Rt和Ht−1 的元素相乘可以减少以往状态的影响。每当重置门Rt中的项接近1时，我们恢复一个普通的循环神经网络。对于重置门Rt中所有接近0的项，候选隐状态是以Xt作为输入的多层感知机的结果。因此，任何预先存在的隐状态都会被重置为默认值。

隐状态

需要结合更新门Zt的效果。这一步确定新的隐状态Ht ∈ Rn×h 在多大程度上来自旧的状态Ht−1和新的候选状态H˜t。了门控循环单元的最终更新公式：

每当更新门Zt接近1时，模型就倾向只保留旧状态。此时，来自Xt的信息基本上被忽略，从而有效地跳过了依赖链条中的时间步t。相反，当Zt接近0时，新的隐状态Ht就会接近候选隐状态H˜t。

门控循环单元具有以下两个显著特征：
• 重置门有助于捕获序列中的短期依赖关系；
• 更新门有助于捕获序列中的长期依赖关系。

1.2 从零开始实现

首先，我们读取时间机器数据集：

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)

初始化模型参数。 我们从标准差为 0.01 的高斯分布中提取权重， 并将偏置项设为 0 ，超参数num_hiddens定义隐藏单元的数量， 实例化与更新门、重置门、候选隐状态和输出层相关的所有权重和偏置。

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

定义隐状态的初始化函数init_gru_state。 此函数返回一个形状为（批量大小，隐藏单元个数）的张量，张量的值全部为零。

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

定义门控循环单元模型， 模型的架构与基本的循环神经网络单元是相同的， 只是权重更新公式更为复杂。

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,)

训练和预测。训练结束后，我们分别打印输出训练集的困惑度，以及前缀“time traveler”和“traveler”的预测序列上的困惑度。

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)

1.3 简洁实现

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)

2 长短期记忆网络（LSTM）

2.1 门控记忆元

普遍认为记忆元是隐状态的一种特殊类型，它们与隐状态具有相同的形状，其设计目的是用于记录附加的信息。
为了控制记忆元，我们需要许多门。其中一个门用来从单元中输出条目，我们将其称为输出门（output gate）。另外一个门用来决定何时将数据读入单元，我们将其称为输入门（inputgate）。我们还需要一种机制来重置单元的内容，由遗忘门（forget gate）来管理。

输入门、忘记门和输出门

这三个门的值都在(0, 1)的范围内。三个门的计算方式如下：

候选记忆元

候选记忆元（candidate memory cell）C˜t ∈ Rn×h。它的计算与上面描述的三个门的计算类似，但是使用tanh函数作为激活函数，函数的值范围为(−1, 1)。

记忆元

输入门It控制采用多少来自C˜t的新数据，而遗忘门Ft控制保留多少过去的记忆元Ct−1 ∈ Rn×h的内容。使用按元素乘法，得出：

隐状态

在长短期记忆网络中，它仅仅是记忆元的tanh的门控版本。这就确保了Ht的值始终在区间(−1, 1)内：

2.2 从零开始实现

首先加载时光机器数据集:

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)

初始化模型参数， 我们按照标准差 0.01 的高斯分布初始化权重，并将偏置项设为 0 。

def get_lstm_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_xi, W_hi, b_i = three()  # 输入门参数
    W_xf, W_hf, b_f = three()  # 遗忘门参数
    W_xo, W_ho, b_o = three()  # 输出门参数
    W_xc, W_hc, b_c = three()  # 候选记忆元参数
    # 输出层参数
    W_hq = normal((num_hiddens, num_outputs))
    b_q = torch.zeros(num_outputs, device=device)
    # 附加梯度
    params = [W_xi, W_hi, b_i, W_xf, W_hf, b_f, W_xo, W_ho, b_o, W_xc, W_hc,
              b_c, W_hq, b_q]
    for param in params:
        param.requires_grad_(True)
    return params

定义模型，长短期记忆网络的隐状态需要返回一个额外的记忆元， 单元的值为0，形状为（批量大小，隐藏单元数）。 因此，我们得到以下的状态初始化。

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

def lstm(inputs, state, params):
    [W_xi, W_hi, b_i, W_xf, W_hf, b_f, W_xo, W_ho, b_o, W_xc, W_hc, b_c,
     W_hq, b_q] = params
    (H, C) = state
    outputs = []
    for X in inputs:
        I = torch.sigmoid((X @ W_xi) + (H @ W_hi) + b_i)
        F = torch.sigmoid((X @ W_xf) + (H @ W_hf) + b_f)
        O = torch.sigmoid((X @ W_xo) + (H @ W_ho) + b_o)
        C_tilda = torch.tanh((X @ W_xc) + (H @ W_hc) + b_c)
        C = F * C + I * C_tilda
        H = O * torch.tanh(C)
        Y = (H @ W_hq) + b_q
        outputs.append(Y)
    return torch.cat(outputs, dim=0), (H, C)

训练和预测

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_lstm_params,
                            init_lstm_state, lstm)
d2l.train_ch8(model, train_iter, vocab, lr, num_epochs, device)

2.3 简洁实现

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

3 深度循环神经网络（DRNN）

一个具有L个隐藏层的深度循环神经网络，每个隐状态都连续地传递到当前层的下一个时间步和下一层的当前时间步。

3.1 函数依赖关系

假设在时间步t有一个小批量的输入数据 Xt ∈ Rn×d （样本数：n，每个样本中的输入数：d）。同时，将lth隐藏层（l = 1, . . . , L）的隐状态设为H(tl)∈ Rn×h （隐藏单元数：h），输出层变量设为Ot ∈ Rn×q （输出数：q）。设置H(0)t = Xt，第l个隐藏层的隐状态使用激活函数ϕl，则：

最后，输出层的计算仅基于第l个隐藏层最终的隐状态：

其中，权重Whq ∈ Rh×q和偏置bq ∈ R1×q都是输出层的模型参数。

3.2 简洁实现

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)

通过num_layers的值来设定隐藏层数

vocab_size, num_hiddens, num_layers = len(vocab), 256, 2
num_inputs = vocab_size
device = d2l.try_gpu()
lstm_layer = nn.LSTM(num_inputs, num_hiddens, num_layers)
model = d2l.RNNModel(lstm_layer, len(vocab))
model = model.to(device)

训练与预测

num_epochs, lr = 500, 2
d2l.train_ch8(model, train_iter, vocab, lr*1.0, num_epochs, device)