- 在 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()
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()
模型效果:
可以看到,随着模型的迭代,模型的预测越来越符合真实数据,说明模型的训练是有价值的。
- 下面我们改变网络结构中的 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()
模型效果:
可以看到,即使对于变长的序列,模型的预测随着不断迭代越来越符合真实数据。