RNN、LSTM、GRU 网络使用教程 (一)

作者: 自由调优师_大废废 | 来源:发表于2019-12-26 15:10 被阅读0次

「深度学习」循环神经网络 RNN 学习笔记
RNN，LSTM，GRU
RNN、LSTM、GRU 网络使用教程 (一)
02-25：RNN算法
RNN、LSTM、GRU 网络使用教程 (二)
自然语言模型评估
RNN 循环神经网络分类
rnn seq2seq attention transforme
机器翻译seq2seq+Attention（理论+代码）
吴恩达深度学习-序列模型 1.10 LSTM长短期记忆网络

在 RNN实战-姓名分类中介绍了最基础 RNN 网络结构的搭建，个人感觉对 RNN 网络结构的理解与使用远远不够，缺乏普遍性。
本文将对 pytorch 中的 RNN 网络结构的使用进行介绍，力求在代码逻辑层面达到普遍性。
本文暂不涉及网络结构的数学理论基础，后续单独补。

Step1-数据处理

无论是 RNN、LSTM、GRU 的哪一种网络结构，它们对于输入都有统一的要求，输入的数据都是序列数据。格式必须是 (batch, time_step, input_size) 。

batch：该批次样本数，可以为1.
time_step: 样本的序列长度。(对于 pytorch, 不同样本之间，序列长度可以不相同，这点后面会说)
input_size: 样本每条序列的特征数目。(无论是样本还是序列之间，input_size 必须相同)

由于它对于输入数据格式的特殊性，个人感觉这也是使用 RNN 的一个难点，我们要想办法把我们的训练数据处理成 RNN 网络能够接收的格式。对于这点，会在后面的实战教程中具体操作，仅供参考。

本文中选取的案例是用 sin 的曲线预测出 cos 的曲线.

import torch
from torch import nn
import numpy as np
import matplotlib.pyplot as plt

# rnn time step
TIME_STEP = 10 
# rnn input size
INPUT_SIZE = 1     
LR = 0.02   
steps = np.linspace(0, np.pi*2, 100, dtype=np.float32)
# input data
x = np.sin(steps)
# output data
y = np.cos(steps)
plt.plot(steps, x, 'b-', label='input (sin)')
plt.plot(steps, y, 'r-', label='output (cos)')
plt.legend(loc='best')
plt.show()

image.png

Step2 - 定义网络结构

(所有返回结果)

class RNN(nn.Module):
    def __init__(self):
        super(RNN, self).__init__()
        self.rnn = nn.RNN(
            input_size=1,
            hidden_size=32,
            num_layers=1,
            batch_first=True
        )
        self.out = nn.Linear(32,1)

    def forward(self, x, h_state):
        r_out, h_state = self.rnn(x, h_state)
        """这里我们选取输出的所有返回结果，后面也会有选取最后一个预测结果的情况"""
        outs = []
        for time_step in range(r_out.size(1)):
            outs.append(self.out(r_out[:, time_step, :]))
        return torch.stack(outs, dim=1), h_state

rnn = RNN()

Step3 - 定义损失函数

loss_func = nn.MSELoss()

Step4 - 定义优化器

optimizer = torch.optim.Adam(rnn.parameters(), lr=LR)

Step5 - 模型训练 & Step6 - 验证模型效果

这里，我们把模型的训练和模型效果验证放在一起执行。

plt.figure(1, figsize=(12, 5))
plt.ion()

h_state = None

for step in range(100):
    # 开始，结束的范围
    start, end = step * np.pi, (step+1)*np.pi
    # 生成 input 数据和 output 数据， TIME_STEP为10  
    steps = np.linspace(start, end, TIME_STEP, dtype=np.float32, endpoint=False)
    x_np = np.sin(steps)
    y_np = np.cos(steps)
    x = torch.from_numpy(x_np[np.newaxis, :, np.newaxis])
    y = torch.from_numpy(y_np[np.newaxis, :, np.newaxis])
    # 这里的 prediction 在前面定以网络结构时返回的是一系列结果，也就是一个 step 就会输出一个结果，所以这里 prediction 的就是 10 个结果。
    prediction, h_state = rnn(x, h_state)
    # 注意 这里要把 h_state 传回下一次的迭代
    h_state = h_state.data 
    
    # 计算损失函数
    loss = loss_func(prediction, y) 
    # 梯度清零
    optimizer.zero_grad()  
    # 反向传播
    loss.backward()     
    # 更新参数
    optimizer.step()

    # 可视化训练过程
    plt.plot(steps, y.flatten(), 'r-')
    plt.plot(steps, prediction.data.numpy().flatten(), 'b-')

plt.ioff()
plt.show()

模型效果：

image.png

可以看到，随着模型的迭代，模型的预测越来越符合真实数据，说明模型的训练是有价值的。

下面我们改变网络结构中的 forward ，每次只返回最后的一个结果。

Step2 - 定义网络结构

(最后一条返回结果)

class RNN(nn.Module):
    def __init__(self):
        super(RNN, self).__init__()
        self.rnn = nn.RNN(
            input_size=1,
            hidden_size=32,
            num_layers=1,
            batch_first=True
        )
        self.out = nn.Linear(32,1)

    def forward(self, x, h_state):
        r_out, h_state = self.rnn(x, h_state)
        """这里我们选取最后一个预测结果"""
        out = self.out(r_out[:,-1,:])
        return out, h_state
    
rnn = RNN()

这里的损失函数和优化器不变

Step5 - 模型训练 & Step6 - 验证模型效果

h_state = None

for step in range(100):
    # 开始，结束的范围
    start, end = step * np.pi, (step+1)*np.pi
    # 生成 input 数据和 output 数据， TIME_STEP 为 10  
    steps = np.linspace(start, end, TIME_STEP, dtype=np.float32, endpoint=False)
    x_np = np.sin(steps)
    y_np = np.cos(steps)

    x = torch.from_numpy(x_np[np.newaxis, :, np.newaxis]) 
    # 注意这里因为我们定位网络时只要最后一个结果，所以这里真实数据也只要最后一个数据。
    y = torch.from_numpy(y_np[np.newaxis, -1, np.newaxis])
    
    prediction, h_state = rnn(x, h_state)
    # 注意 这里要把 h_state 传回下一次的迭代
    h_state = h_state.data 
    
    # 计算损失函数
    loss = loss_func(prediction, y) 
    # 梯度清零
    optimizer.zero_grad()  
    # 反向传播
    loss.backward()     
    # 更新参数
    optimizer.step()
    
    print(loss.item())

我们可以根据输出的 loss 观察模型的训练效果，这里没有展示输出结果，事实上 loss 会随着模型的迭代不断的降低。

在前面的模型训练中输入的序列长度都是一样的 (10)。对于 pytorch 来说，它还可以更好的变长序列。下面我们改变输入的序列长度，观察模型的训练效果。

变长序列处理

这里使用的是第一种网络结构，选取所有返回结果，我们需要改一下模型训练的代码，使输入的序列长度是动态的。

plt.figure(1, figsize=(12, 5))
plt.ion()

h_state = None

for i in range(100):
    # 随机序列长度
    dynamic_steps = np.random.randint(1, 4)
    # 开始，结束的范围
    start, end = step * np.pi, (step + dynamic_steps)*np.pi
    step = step + dynamic_steps
    # 生成 input 数据和 output 数据， TIME_STEP为 dynamic_steps * TIME_STEP
    steps = np.linspace(start, end, dynamic_steps * TIME_STEP, dtype=np.float32, endpoint=False)
    print(len(steps))
    x_np = np.sin(steps)
    y_np = np.cos(steps)
    x = torch.from_numpy(x_np[np.newaxis, :, np.newaxis])
    y = torch.from_numpy(y_np[np.newaxis, :, np.newaxis])

    prediction, h_state = rnn(x, h_state)
    # 注意 这里要把 h_state 传回下一次的迭代
    h_state = h_state.data 
    
    # 计算损失函数
    loss = loss_func(prediction, y) 
    # 梯度清零
    optimizer.zero_grad()  
    # 反向传播
    loss.backward()     
    # 更新参数
    optimizer.step()

    # 可视化训练过程
    plt.plot(steps, y.flatten(), 'r-')
    plt.plot(steps, prediction.data.numpy().flatten(), 'b-')
   
plt.ioff()
plt.show()

模型效果: