DL_Notebook 4.2_RNN进阶/GRU/LSTM

最新推荐文章于 2022-11-09 13:00:26 发布

Edeeen1

最新推荐文章于 2022-11-09 13:00:26 发布

阅读量195

点赞数

分类专栏： Pytorch深度学习文章标签：自然语言处理深度学习 python

本文链接：https://blog.csdn.net/weixin_43124455/article/details/104463119

版权

Pytorch深度学习专栏收录该内容

15 篇文章 0 订阅

订阅专栏

文章目录

循环神经网络进阶

循环神经网络进阶

GRU Gated Recurrent Units

GRU：门控循环神经网络
RNN存在的问题：梯度较容易出现衰减或爆炸（BPTT）。当时间步数比较大或者比较小的时候，循环神经网络的梯度容易出Vanishing or explosion，虽然裁剪梯度clip gradient可以应对explosion，但是无法应对Vanishing。
门控循环神经网络：捕捉时间序列中时间步距离较大的依赖关系

也是讲GRU的：人人都能看懂的GRU
RNN:

在这里插入图片描述
$H_{t} = ϕ(X_{t}W_{xh} + H_{t-1}W_{hh} + b_{h})$
GRU:

$R_{t} = σ(X_tW_{xr} + H_{t−1}W_{hr} + b_r)\\ Z_{t} = σ(X_tW_{xz} + H_{t−1}W_{hz} + b_z)\\ \widetilde{H}_t = tanh(X_tW_{xh} + (R_t ⊙H_{t−1})W_{hh} + b_h)\\ H_t = Z_t⊙H_{t−1} + (1−Z_t)⊙\widetilde{H}_t$
可以看到 $R_t$ 、 $Z_t$ 与 $H_{t−1}$ 是按元素乘，所以很容易理解 $R_t$ 、 $Z_t$ 和 $\widetilde{H}_t$ 与 $H_{t−1}$ 形状一样。
• 重置门有助于捕捉时间序列里短期的依赖关系；（重置门=0时，候选隐藏状态 $\widetilde{H}_t$ 就只包含输入 $X_t$ ）
• 更新门有助于捕捉时间序列里长期的依赖关系。

载入数据集

import os
os.listdir('/home/kesci/input')

out: [‘d2lzh1981’, ‘houseprices2807’, ‘jaychou_lyrics4703’, ‘d2l_jay9460’]

import numpy as np
import torch
from torch import nn, optim
import torch.nn.functional as F

import sys
sys.path.append("../input/")
import d2l_jay9460 as d2l
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

(corpus_indices, char_to_idx, idx_to_char, vocab_size) = d2l.load_data_jay_lyrics()

初始化参数

需要初始化的参数：红色下划线9个； $H_{-1}$ （初始化为0）；以及隐藏层H到输出O的权重 $\boldsymbol{W}_{hq}$ 和偏置 $\boldsymbol{b}_q$ ( $\boldsymbol{O}_t = \boldsymbol{H}_t \boldsymbol{W}_{hq} + \boldsymbol{b}_q$ )
在这里插入图片描述

num_inputs, num_hiddens, num_outputs = vocab_size, 256, vocab_size
print('will use', device)

def get_params():  
    def _one(shape):
        ts = torch.tensor(np.random.normal(0, 0.01, size=shape), device=device, dtype=torch.float32) #正态分布
        return torch.nn.Parameter(ts, requires_grad=True)
    def _three():
        return (_one((num_inputs, num_hiddens)),
                _one((num_hiddens, num_hiddens)),
                torch.nn.Parameter(torch.zeros(num_hiddens, device=device, dtype=torch.float32), requires_grad=True))
     
    W_xz, W_hz, b_z = _three()  # 更新门参数
    W_xr, W_hr, b_r = _three()  # 重置门参数
    W_xh, W_hh, b_h = _three()  # 候选隐藏状态参数
    
    # 输出层参数
    W_hq = _one((num_hiddens, num_outputs))
    b_q = torch.nn.Parameter(torch.zeros(num_outputs, device=device, dtype=torch.float32), requires_grad=True)
    return nn.ParameterList([W_xz, W_hz, b_z, W_xr, W_hr, b_r, W_xh, W_hh, b_h, W_hq, b_q])

def init_gru_state(batch_size, num_hiddens, device):   #隐藏状态初始化，H_{-1}
    return (torch.zeros((batch_size, num_hiddens), device=device), ) 
    # 一个batch里面，每一个样本都需要一个H_{-1}

GRU模型

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(torch.matmul(X, W_xz) + torch.matmul(H, W_hz) + b_z)
        R = torch.sigmoid(torch.matmul(X, W_xr) + torch.matmul(H, W_hr) + b_r)
        H_tilda = torch.tanh(torch.matmul(X, W_xh) + R * torch.matmul(H, W_hh) + b_h)
        H = Z * H + (1 - Z) * H_tilda
        Y = torch.matmul(H, W_hq) + b_q
        outputs.append(Y)
    return outputs, (H,)  # 还要返回最后一个隐层(H,)

训练模型

num_epochs, num_steps, batch_size, lr, clipping_theta = 160, 35, 32, 1e2, 1e-2
pred_period, pred_len, prefixes = 40, 50, ['分开', '不分开']

d2l.train_and_predict_rnn(gru, get_params, init_gru_state, num_hiddens,
                          vocab_size, device, corpus_indices, idx_to_char,
                          char_to_idx, False, num_epochs, num_steps, lr,
                          clipping_theta, batch_size, pred_period, pred_len,
                          prefixes)

epoch 40, perplexity 149.271885, time 1.17 sec
-分开我想我不不我想你的让我你想我的让我你想我不想我想你我想想想想想你想你的可爱人坏我的让我
-不分开我想你我不想你不我我想你的爱爱我想你的让我我想你我想想想想想想你的可爱人坏我的让我我
epoch 160, perplexity 1.427383, time 1.16 sec
-分开我已带口你已已是不起让你知没面对我甩散球我满腔的怒火我想揍你已经很久别想躲说你眼睛看着
-不分开整过是你开的玩笑想通却又再考倒我说散你想很久了吧? 败给你的黑色幽默说散你想很久了吧

简洁实现

不需要自己写GRU代码，只需要调用nn.GRU() 得到gru_layer，放到d2l.RNNModel里面生成model，放到工具函数d2l.train_and_predict里面，最终得到测试结果。

num_hiddens=256
num_epochs, num_steps, batch_size, lr, clipping_theta = 160, 35, 32, 1e2, 1e-2
pred_period, pred_len, prefixes = 40, 50, ['分开', '不分开']

lr = 1e-2 # 注意调整学习率
gru_layer = nn.GRU(input_size=vocab_size, hidden_size=num_hiddens)
model = d2l.RNNModel(gru_layer, vocab_size).to(device)
d2l.train_and_predict_rnn_pytorch(model, num_hiddens, vocab_size, device,
                                corpus_indices, idx_to_char, char_to_idx,
                                num_epochs, num_steps, lr, clipping_theta,
                                batch_size, pred_period, pred_len, prefixes)

LSTM(long short-term memory)

LSTM 即长短期记忆。
可看人人都能看懂的LSTM
在这里插入图片描述 $I_t = σ(X_tW_{xi} + H_{t−1}W_{hi} + b_i) \\ F_t = σ(X_tW_{xf} + H_{t−1}W_{hf} + b_f)\\ O_t = σ(X_tW_{xo} + H_{t−1}W_{ho} + b_o)\\ \widetilde{C}_t = tanh(X_tW_{xc} + H_{t−1}W_{hc} + b_c)\\ C_t = F_t ⊙C_{t−1} + I_t ⊙\widetilde{C}_t\\ H_t = O_t⊙tanh(C_t)$
遗忘门、输入门、输出门都是由 $H_{t-1}$ 和 $X_t$ 组成，再通过sigmoid函数，控制其范围在0~1之间。

遗忘门 $F_t$ :控制上一时间步的记忆细胞。如果遗忘门全部是0，就忘记了记忆细胞 $C_{t-1}$ ， $C_{t}$ 与 $C_{t-1}$ 无关。
输入门 $I_t$ :控制当前时间步的输入。候选记忆细胞 $\widetilde{C}_t$ 这个信息输入多少到 $C_t$ 中，是由输入门决定。如果输入门=1，则 $\widetilde{C}_t$ 中的信息全部输入到 $C_t$ 。
输出门 $O_t$ :控制从记忆细胞到隐藏状态。决定 $C_t$ 输出多少到 $H_{t}$
记忆细胞：⼀种特殊的隐藏状态的信息的流动

初始化参数

需要初始化的参数：
$\boldsymbol {C}_{-1}$ 、 $\boldsymbol {H}_{-1}$ 、红色下划线标注的12个(参数形状上方备注了： $\times h, h \times h, h$ )、以及隐藏层H到输出O的权重 $\boldsymbol{W}_{hq}$ 和偏置 $\boldsymbol{b}_q$ ( $\boldsymbol{O}_t = \boldsymbol{H}_t \boldsymbol{W}_{hq} + \boldsymbol{b}_q$ )
在这里插入图片描述

num_inputs, num_hiddens, num_outputs = vocab_size, 256, vocab_size
print('will use', device)

def get_params():
    def _one(shape):
        ts = torch.tensor(np.random.normal(0, 0.01, size=shape), device=device, dtype=torch.float32)
        return torch.nn.Parameter(ts, requires_grad=True)
    def _three():
        return (_one((num_inputs, num_hiddens)),
                _one((num_hiddens, num_hiddens)), 
                torch.nn.Parameter(torch.zeros(num_hiddens, device=device, dtype=torch.float32), requires_grad=True))
    
    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 = _one((num_hiddens, num_outputs))
    b_q = torch.nn.Parameter(torch.zeros(num_outputs, device=device, dtype=torch.float32), requires_grad=True)
    return nn.ParameterList([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])

# H_{-1}和C_{-1}初始化
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))

LSTM模型

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(torch.matmul(X, W_xi) + torch.matmul(H, W_hi) + b_i)
        F = torch.sigmoid(torch.matmul(X, W_xf) + torch.matmul(H, W_hf) + b_f)
        O = torch.sigmoid(torch.matmul(X, W_xo) + torch.matmul(H, W_ho) + b_o)
        C_tilda = torch.tanh(torch.matmul(X, W_xc) + torch.matmul(H, W_hc) + b_c)
        C = F * C + I * C_tilda
        H = O * C.tanh()
        Y = torch.matmul(H, W_hq) + b_q
        outputs.append(Y)
    return outputs, (H, C)

训练模型

num_epochs, num_steps, batch_size, lr, clipping_theta = 160, 35, 32, 1e2, 1e-2
pred_period, pred_len, prefixes = 40, 50, ['分开', '不分开']

d2l.train_and_predict_rnn(lstm, get_params, init_lstm_state, num_hiddens,
                          vocab_size, device, corpus_indices, idx_to_char,
                          char_to_idx, False, num_epochs, num_steps, lr,
                          clipping_theta, batch_size, pred_period, pred_len,
                          prefixes)

… 此处省略输出结果

简洁实现

num_hiddens=256
num_epochs, num_steps, batch_size, lr, clipping_theta = 160, 35, 32, 1e2, 1e-2
pred_period, pred_len, prefixes = 40, 50, ['分开', '不分开']

lr = 1e-2 # 注意调整学习率
lstm_layer = nn.LSTM(input_size=vocab_size, hidden_size=num_hiddens)
model = d2l.RNNModel(lstm_layer, vocab_size)
d2l.train_and_predict_rnn_pytorch(model, num_hiddens, vocab_size, device,
                                corpus_indices, idx_to_char, char_to_idx,
                                num_epochs, num_steps, lr, clipping_theta,
                                batch_size, pred_period, pred_len, prefixes)

深度循环神经网络

在这里插入图片描述
num_layers默认为1，更改=2以及更高，即可实现深度神经网络。

num_hiddens=256
num_epochs, num_steps, batch_size, lr, clipping_theta = 160, 35, 32, 1e2, 1e-2
pred_period, pred_len, prefixes = 40, 50, ['分开', '不分开']

lr = 1e-2 # 注意调整学习率

gru_layer = nn.LSTM(input_size=vocab_size, hidden_size=num_hiddens,num_layers=2)
model = d2l.RNNModel(gru_layer, vocab_size).to(device)
d2l.train_and_predict_rnn_pytorch(model, num_hiddens, vocab_size, device,
                                corpus_indices, idx_to_char, char_to_idx,
                                num_epochs, num_steps, lr, clipping_theta,
                                batch_size, pred_period, pred_len, prefixes)

双向循环神经网络

常用，尤其是在NLP中。双层可以考虑一个字的前后对它的影响，而单项就只考虑了前面对它的影响。
在这里插入图片描述
上图，X直接往右这层网络的时间方向如箭头所指， $X_1$ --> $X_T$ 进行运算

在这里插入图片描述
上图，“双向”中的另一向的时间顺序是 $X_T$ --> $X_1$ ，相当于 $X_T$ 作为 $X'_1$ 先进行运算。

代码：
其他与之前一样，只改动了nn.GRU的bidirectional=True这个参数

num_hiddens=128
num_epochs, num_steps, batch_size, lr, clipping_theta = 160, 35, 32, 1e-2, 1e-2
pred_period, pred_len, prefixes = 40, 50, ['分开', '不分开']

lr = 1e-2 # 注意调整学习率

gru_layer = nn.GRU(input_size=vocab_size, hidden_size=num_hiddens,bidirectional=True)
model = d2l.RNNModel(gru_layer, vocab_size).to(device)
d2l.train_and_predict_rnn_pytorch(model, num_hiddens, vocab_size, device,
                                corpus_indices, idx_to_char, char_to_idx,
                                num_epochs, num_steps, lr, clipping_theta,
                                batch_size, pred_period, pred_len, prefixes)

课后习题：
在这里插入图片描述

Edeeen1

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
DL_Notebook 4.2_RNN进阶/GRU/LSTM

文章目录循环神经网络进阶GRU Gated Recurrent Units载入数据集初始化参数GRU模型训练模型简洁实现LSTM(long short-term memory)循环神经网络进阶GRU Gated Recurrent UnitsGRU：门控循环神经网络RNN存在的问题：梯度较容易出现衰减或爆炸（BPTT）。当时间步数比较大或者比较小的时候，循环神经网络的梯度容易出Vani...
复制链接

扫一扫