Pytorch RNN 用sin預測cos

RNN簡單介紹

什么是RNN

RNN的全稱是Recurrent Neural Network，中文名稱是循環(huán)神經(jīng)網(wǎng)絡。它的一大特點就是擁有記憶性，并且參數(shù)共享，所以它很適合用來處理序列數(shù)據(jù)，比如說機器翻譯、語言模型、語音識別等等。

它的結構

它的更新公式

(Pytorh 文檔里的 https://pytorch.org/docs/stable/generated/torch.nn.RNN.html?highlight=rnn#torch.nn.RNN）

sin to cos

我們這里采用的是一個seq2seq的模型，也就是，首先生成區(qū)間（a,b)的等距采樣點steps=[s0,s1,s2,...sn],然后再算出x = [x0,x1,x2,...xn], xn = sin(sn),和y = [y0, y1,y2,...,yn], yn = cos(sn)。
RNN要做的是，把序列x轉變成序列y，也即是從sin到cos（下圖中藍色到紅色）

可以知道，y0只受到x0的影響，而y2則同時受到[x0,x0,x1,x2]的影響，同理yn則受到[x0,...xn]的影響。

代碼

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

steps = np.linspace(0, np.pi*2, 100, dtype=np.float32)
input_x = np.sin(steps)
target_y = np.cos(steps)
plt.plot(steps, input_x, 'b-', label='input:sin')
plt.plot(steps, target_y, 'r-', label='target:cos')

plt.legend(loc='best')
plt.show()


class RNN(nn.Module):
    def __init__(self, input_size, hidden_size):
        super(RNN, self).__init__()
        
        self.hidden_size = hidden_size 
        self.rnn = nn.RNN(
            input_size = input_size,
            hidden_size = hidden_size,
            batch_first = True,
        )
        
        self.out = nn.Linear(hidden_size, 1)
        
    
    def forward(self, input, hidden):
        output, hidden = self.rnn(input, hidden)
        output = self.out(output)
        return output,hidden
    
    def initHidden(self):
        hidden = torch.randn(1, self.hidden_size)
        return hidden
    

rnn = RNN(input_size = 1, hidden_size = 20)

hidden = rnn.initHidden()

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

plt.figure(1, figsize=(12, 5))
plt.ion() # 開啟交互模式

loss_list = []
for step in range(800):
    start, end = step * np.pi, (step + 1) * np.pi
    steps = np.linspace(start, end, 100, dtype=np.float32)
    x_np = np.sin(steps)
    y_np = np.cos(steps)
    #(100, 1) 不加batch_size
    x = torch.from_numpy(x_np).unsqueeze(-1)
    y = torch.from_numpy(y_np).unsqueeze(-1)
    
    y_predict, hidden = rnn(x, hidden)
    hidden = hidden.data # 重新包裝數(shù)據(jù)，斷掉連接，不然會報錯
    loss = loss_func(y_predict, y)
    optimizer.zero_grad() # 梯度清零
    loss.backward()  # 反向傳播
    optimizer.step() # 梯度下降
    loss_list.append(loss.item())
    if step % 10 == 0 or step % 10 == 1:
        plt.plot(steps, y_np.flatten(), 'r-')
        plt.plot(steps, y_predict.data.numpy().flatten(), 'b-')
        plt.draw();
        plt.pause(0.05)
    

plt.ioff()
plt.show()

plt.plot(loss_list)