深度学习RNNLSTMGRU 网络使用教程

Posted 2021-10-31 ZSYL

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

• 前言
• 1. 数据处理
• 2. 定义网络结构
• 3. 定义损失函数
• 4. 定义优化器
• 5. 模型训练&验证

前言

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

1. 数据处理

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

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

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

在 RNN实战-姓名分类 实战中定义的RNN网络模型，输入的文本张量的one-hot表示形式。

class RNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size, num_layers=1):
        """
        :param input_size:代表RNN输入的最后一个维度
        :param hidden_size:代表RNN隐藏层的最后一个维度
        :param output_size:代表RNN网络最后线性层的输出维度
        :param num_layers:代表RNN网络的层数
        """
        super(RNN, self).__init__()
        self._input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.num_layers = num_layers

        # 实例化预定义的RNN，三个参数分别是input_size，hidden_size，num_layers
        self.rnn = nn.RNN(input_size, hidden_size, num_layers)
        # 实例化全连接线形层，作用是将RNN的输出维度转化成指定的输出维度
        self.linear = nn.Linear(hidden_size, output_size)
        # 实例化nn中预定义的softmax层，用于从输出层中获得类别的结果
        self.softmax = nn.LogSoftmax(dim=-1)

    def forward(self, input1, hidden):
        # input1：代表人名分类器中的输入张量，形状是 1 * n_letters
        # hidden：代表RNN的隐藏层张量，形状是 self.num_layers * 1 * self.hidden_size
        # 注意：输入到RNN中的张量要求是三维张量，所以要用unsqueeze()函数扩充维度
        input1 = input1.unsqueeze(0)
        # 将input1和hidden输入到RNN的实例化对象中，如果num_layers=1，rr恒等于hn
        rr, hn = self.rnn(input1, hidden)
        # 将从RNN中获得的结果通过线形层的变换和softmax层的处理，最终返回
        return self.softmax(self.linear(rr)), hn

    def initHidden(self):
        # 本函数的作用是用来初始化一个全零的隐藏层张量，维度是3
        return torch.zeros(self.num_layers, 1, self.hidden_size)

本文中选取的案例是 用 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()

2. 定义网络结构

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

3. 定义损失函数

loss_func = nn.MSELoss()

4. 定义优化器

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

5. 模型训练&验证

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

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

模型效果：

可以看到，即使对于变长的序列，模型的预测随着不断迭代越来越符合真实数据。

原文链接：Link

---

加油!

感谢!

努力!