莫烦pytorch RNN循环神经网络（回归）

RNN回归可以用来及时预测时间序列

训练数据
我们要用sin的曲线预测出cos的曲线。

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

torch.manual_seed(1)

TIME_STEP = 10
INPUT_SIZE = 1
LR = 0.02
DOWNLOAD_MNIST = False

RNN模型
这一次的RNN，我们对每一个r_out都得放到Linear中去计算出预测的output，所以我们能用一个for loop来循环计算。这点是Tensorflow做不到的。

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_size=True,
		)
		self.out = nn.Linear(32, 1)
	
	def forward(self, x, h_state):
		r_out, h_state = 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()
print(rnn)

结果：

torch.stack(sequence, dim=0)

沿着一个新维度对输入张量序列进行连接。序列中所有的张量都应该为相同形状。
参数：
# sequence(Sequence) - 待连接的张量序列
# dim(int) - 插入的维度。必须介于0与待连接的张量序列数之间

"""
RNN (
  (rnn): RNN(1, 32, batch_first=True)
  (out): Linear (32 -> 1)
)
"""

函数剖析：

forward过程中的对每个时间点求输出还有一招使得计算量比较小的。不过上面的内容主要是为了呈现pytorch在动态构图上的优势，所以我用了一个for loop来搭建那套输出系统。下面介绍一个替换方式。使用reshape的方式整批计算。

def forward(self, x, h_state):
	r_out, h_state = self.rnn(x, h_state)
	r_out = r_out.view(-1, 32)
	outs = self.out(r_out)
	return outs.view(-1, 32, TIME_STEP), h_state

训练

我们使用x作为输入的sin值，然后y作为想要拟合的输出，cos值。因为他们两条曲线是存在某种关系的，所以我们就能用sin来预测cos。rnn会理解他们的关系，并用里面的参数分析出来这个时刻sin曲线上的点如何对应cos曲线上的点。

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

h_state = None

for step in range(100):
	start, end = step * np.pi, (step+1)*np.pi
	steps = np.linspace(start, end, 10, dtype=np.float32)
	x_np = np.sin(steps) #float32 for converting torch FloatTensor
	y_np = np.cos(steps)

	x = torch.from_numpy(x_np[np.newaxis, :, np.newaxis]) #shape(batch, time_step, input_size)
	y = torch.from_numpy(y_np[np.newaxis, :, np.newaxis])

	prediction, h_state = rnn(x, h_state)
	h_state = h_state.data
	loss = loss_func(prediction, y)
	optimizer.zero_grad()
	loss.backward()
	optimizer.step()

全部代码：

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

# torch.manual_seed(1)    # reproducible

# Hyper Parameters
TIME_STEP = 10      # rnn time step
INPUT_SIZE = 1      # rnn input size
LR = 0.02           # learning rate

# show data
steps = np.linspace(0, np.pi*2, 100, dtype=np.float32)  # float32 for converting torch FloatTensor
x_np = np.sin(steps)
y_np = np.cos(steps)
plt.plot(steps, y_np, 'r-', label='target (cos)')
plt.plot(steps, x_np, 'b-', label='input (sin)')
plt.legend(loc='best')
plt.show()


class RNN(nn.Module):
    def __init__(self):
        super(RNN, self).__init__()

        self.rnn = nn.RNN(
            input_size=INPUT_SIZE,
            hidden_size=32,     # rnn hidden unit
            num_layers=1,       # number of rnn layer
            batch_first=True,   # input & output will has batch size as 1s dimension. e.g. (batch, time_step, input_size)
        )
        self.out = nn.Linear(32, 1)

    def forward(self, x, h_state):
        # x (batch, time_step, input_size)
        # h_state (n_layers, batch, hidden_size)
        # r_out (batch, time_step, hidden_size)
        r_out, h_state = self.rnn(x, h_state)

        outs = []    # save all predictions
        for time_step in range(r_out.size(1)):    # calculate output for each time step
            outs.append(self.out(r_out[:, time_step, :]))
        return torch.stack(outs, dim=1), h_state

        # instead, for simplicity, you can replace above codes by follows
        # r_out = r_out.view(-1, 32)
        # outs = self.out(r_out)
        # outs = outs.view(-1, TIME_STEP, 1)
        # return outs, h_state
        
        # or even simpler, since nn.Linear can accept inputs of any dimension 
        # and returns outputs with same dimension except for the last
        # outs = self.out(r_out)
        # return outs

rnn = RNN()
print(rnn)

optimizer = torch.optim.Adam(rnn.parameters(), lr=LR)   # optimize all cnn parameters
loss_func = nn.MSELoss()

h_state = None      # for initial hidden state

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

for step in range(100):
    start, end = step * np.pi, (step+1)*np.pi   # time range
    # use sin predicts cos
    steps = np.linspace(start, end, TIME_STEP, dtype=np.float32, endpoint=False)  # float32 for converting torch FloatTensor
    x_np = np.sin(steps)
    y_np = np.cos(steps)

    x = torch.from_numpy(x_np[np.newaxis, :, np.newaxis])    # shape (batch, time_step, input_size)
    y = torch.from_numpy(y_np[np.newaxis, :, np.newaxis])

    prediction, h_state = rnn(x, h_state)   # rnn output
    # !! next step is important !!
    h_state = h_state.data        # repack the hidden state, break the connection from last iteration

    loss = loss_func(prediction, y)         # calculate loss
    optimizer.zero_grad()                   # clear gradients for this training step
    loss.backward()                         # backpropagation, compute gradients
    optimizer.step()                        # apply gradients

    # plotting
    plt.plot(steps, y_np.flatten(), 'r-')
    plt.plot(steps, prediction.data.numpy().flatten(), 'b-')
    plt.draw(); plt.pause(0.05)

plt.ioff()
plt.show()