本科生学深度学习-史上最容易懂的RNN文章，小白也能看得懂

def getHidenS(x,w,prevS):
        return x * u + prevS*w
def getOutput(s):
        return s * v
复制代码

def getHidenS(x, w, prevS):
   return x * u + prevS * w
def getOutput(s,v):
   return s * v
sentance = [1,2,3]
for x in sentance:
   prevS = getHidenS(x,u,prevS)
   o = getOutput(prevS,v)
   print('隐藏层的值：'+ str(prevS))
   print('输出层的值 ：'+str(o))
   print('----------------------')
复制代码

import torch
from torch import nn
import numpy as np
import matplotlib.pyplot as plt
# https://www.cnblogs.com/lokvahkoor/p/12263953.html
# torch.manual_seed(1)    # reproducible
# 超参数定义
TIME_STEP = 10  # rnn time step
INPUT_SIZE = 1  # rnn input size
LR = 0.02  # 学习率
HIDDEN_SIZE = 32# 隐藏层神经元个数
EPOCH = 100
# 横向坐标，产出100个float点
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)
# 输入的参数是sin的序列，输出是余弦序列
plt.plot(steps, y_np, 'r-', label='target (cos)')
plt.plot(steps, x_np, 'b-', label='input (sin)')
plt.legend(loc='best')
plt.show()
input("请回车：")
class RNN(nn.Module):
    def __init__(self):
        super(RNN, self).__init__()
        self.rnn = nn.RNN(
            input_size=INPUT_SIZE,
            hidden_size=HIDDEN_SIZE,  # 隐藏神经元的数量
            num_layers=1,  # 一层rnn
            batch_first=True,  # input & output will has batch size as 1s dimension. e.g. (batch, time_step, input_size)
        )
        self.out = nn.Linear(HIDDEN_SIZE, 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)
        out, h_state = self.rnn(x, h_state)
        out = out.view(-1, HIDDEN_SIZE) #(10,32)
        out = self.out(out) #(10,1)
        out = out.unsqueeze(dim=0) # (1,10,1) -> (n_layers, batch, hidden_size)
        return out, h_state
rnn = RNN()
print(rnn)
optimizer = torch.optim.Adam(rnn.parameters(), lr=LR)  # 优化器
loss_func = nn.MSELoss()  # 损失函数
h_state = None  # 隐藏层的输出值
plt.figure(1, figsize=(12, 5))
plt.ion()  # continuously plot
for step in range(EPOCH):
    # 每次生成新的数据，整体的趋势是拟合成cos函数曲线
    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)
    # np.newaxis的功能:插入新维度,(1,10,1)
    # shape (batch, time_step, input_size)
    # 表示每一批送进去一个
    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.data  # repack the hidden state, break the connection from last iteration
    loss = loss_func(prediction, y)  # 计算误差
    optimizer.zero_grad()  # 清除之前的梯度
    loss.backward()  # 反向传播
    optimizer.step()  # 优化参数
    # 开始画图
    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()
复制代码