《动手学——循环神经网络进阶、梯度消失、梯度爆炸以及Kaggle房价预测、过拟合、欠拟合及其解决方案》笔记

《动手学——循环神经网络进阶》笔记

GRU
时间步数较大或者较小时，循环神经网络梯度较容易出现梯度衰减/梯度爆炸。
虽然裁剪梯度可以应对梯度爆炸，但没法解决梯度衰减问题。
所以提出⻔控循环神经⽹络GRU，来捕捉时间序列中时间步距离较⼤的依赖关系
RNN存在的问题：梯度较容易出现衰减或爆炸（BPTT）
⻔控循环神经⽹络：捕捉时间序列中时间步距离较⼤的依赖关系
RNN:

Ht=ϕ(XtWxh+Ht−1Whh+bh)
GRU:
Rt=σ(XtWxr+Ht−1Whr+br)
Zt=σ(XtWxz+Ht−1Whz+bz)
Ht=tanh(XtWxh+(Rt⊙Ht−1)Whh+bh)
Ht=Zt⊙Ht−1+(1−Zt)⊙Ht

• 重置⻔有助于捕捉时间序列⾥短期的依赖关系；
• 更新⻔有助于捕捉时间序列⾥⻓期的依赖关系。

初始化参数

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_x=x*h, W_h=h*h, b=h（x输入个数，h隐藏单元个数）
# x=n*x（n批量大小，x输入个数）
#(1*x)(x*h)+(1*h)(h*h)+h = h

# 输出层参数
#输出到一个output，如果是分类器，q个类别，则输出到形状为q的tensor上
#Ht大小为h，output大小为q，则W_hq=h*q, b_q=q
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_size需要一个H-1，每个H-1都初始化为0
 
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:   #对input的每一个样本X
        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   #Y即需要的output
        outputs.append(Y)  
    return outputs, (H,)  #返回output和最后一个隐藏层H
 
训练模型
num_epochs, num_steps, batch_size, lr, clipping_theta = 160, 35, 32, 1e2, 1e-2
pred_period, pred_len, prefixes = 40, 50, ['分开', '不分开']
1
2
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)
                          #把第一个参数改成gru
 
简洁实现
num_hiddens=256
num_epochs, num_steps, batch_size, lr, clipping_theta = 160, 35,