循环神经网络-单变量序列预测详解（pytorch）

参考博客

（1）导入所需要的包

import torch
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler

（2）读取数据并展示

data_csv =pd.read_csv("data/data.csv", usecols=[1])
plt.plot(data_csv)
print(data_csv.shape)

（3）数据预处理

缺失值，转化成numpy.ndarray类型，转化成float类型，归一化处理

data_csv = data_csv.dropna()
dataset = data_csv.values
dataset = dataset.astype("float32")
scaler = MinMaxScaler()
dataset = scaler.fit_transform(dataset)

（4）划分训练集和测试集

用30个预测一个
1-30：31
2-31：32
…
94-143:144
需要注意a = [dataset[i: (i + look_back)]],而不是a = dataset[i: (i + look_back)]

look_back = 30
def create_dataset(dataset, look_back):
    dataX, dataY = [], []
    for i in range(len(dataset) - look_back):
        a = [dataset[i: (i + look_back)]]
        dataX.append(a)
        dataY.append(dataset[i + look_back])
        
    return np.array(dataX), np.array(dataY)

dataX, dataY = create_dataset(dataset, look_back)

dataX.shape,dataY.shape,type(dataX),type(dataY),dataX.dtype,dataY.dtype

对于 dataX，它的形状为 (114, 1, 30, 1)。其中 114 表示样本数量，1 表示特征数量，30 表示历史时间步的数量，1 表示每个时间步的特征数量。

输出部分dataX和dataY的值

print(dataX[:2],dataY[:2])

数据集搭好之后，对数据集进行7：3的划分

train_size=int(len(dataX)*0.7)
test_size=len(dataX)-train_size

train_x=dataX[:train_size]
train_y=dataY[:train_size]

test_x=dataX[train_size:]
test_y=dataY[train_size:]

print(train_size)

train_x=torch.from_numpy(train_x)
train_x=train_x.squeeze(3)
train_y=torch.from_numpy(train_y)

test_x=torch.from_numpy(test_x)
test_y=torch.from_numpy(test_y)
print(train_x.shape,test_x.shape)

对以上代码进行解释：

• 将numpy.ndarray类型的转化成Tensor类型
• 即将 NumPy 数组 train_x 转换为 PyTorch 张量
• 转换之后神经网络才能计算
• sequeeze（3）是将train_x从（[79,1,30,1]）变为（[79,1,30]）
• test_x不需要sequeeze（3）的原因是：在pytorch中，卷积池化等操作需要输入的是四维张量（样本数，时间步长，特征数，1 ）**（有待考究）**test在后面没用到

（5）构建RNN回归模型

class rnn_reg(torch.nn.Module):
    def __init__(self,input_size,hidden_size,out_size=1,num_layers=2)->None:
        super(rnn_reg,self).__init__()
        self.rnn=torch.nn.RNN(input_size,hidden_size,num_layers)
        self.reg=torch.nn.Linear(hidden_size,out_size)
    
    def forward(self,x):
        x,_=self.rnn(x)
        seq,batch_size,hidden_size=x.shape
        x=x.reshape(seq*batch_size,hidden_size)
        x=self.reg(x)
        x.reshape(seq,batch_size,-1)
        return x
    
net=rnn_reg(look_back,16)
criterion=torch.nn.MSELoss()
optimizer=torch.optim.Adam(net.parameters(),lr=1e-2)

对以上代码进行解释：

• rnn_reg 的子类，继承torch.nn.Module，用于创建自定义的神经网络模型

• __ init__是rnn_reg 类构造函数,用于初始化模型的参数
  

• super(rnn_reg, self).__init__(): 调用父类 torch.nn.Module 的构造函数

• self.rnn = torch.nn.RNN(input_size, hidden_size, num_layers): 创建了一个 RNN 层。input_size 表示输入特征的维度，hidden_size 表示隐藏状态的维度，num_layers 表示 RNN 的层数。

• self.reg = torch.nn.Linear(hidden_size, out_size): 创建了一个线性层（全连接层），用于将 RNN 的隐藏状态映射到输出特征维度。

• def forward(self, x): 这是 rnn_reg 类的前向传播方法。它接受输入 x，并定义了模型的前向计算过程。
  -

• x, _ = self.rnn(x): 将输入 x 传递给 RNN 层进行前向计算。_ 表示隐藏状态，由于这里不需要使用隐藏状态，所以用下划线 _ 进行占位。

• seq, batch_size, hidden_size = x.shape: 获取 RNN 输出 x 的形状信息，其中 seq 表示序列长度，batch_size 表示批次大小，hidden_size 表示隐藏状态的维度。

• x = x.reshape(seq * batch_size, hidden_size): 将 x 重塑为形状 (seq * batch_size, hidden_size)，以便通过线性层进行映射。

• x = self.reg(x): 将重塑后的 x 传递给线性层 self.reg 进行映射操作。

• x.reshape(seq, batch_size, -1): 将输出 x 重塑为形状 (seq, batch_size, -1)，以便与输入保持相同的维度。

• return x: 返回最终的输出 x。

• net = rnn_reg(look_back, 16): 创建了一个 rnn_reg 类的实例 net。look_back 表示输入特征的维度，16 表示隐藏状态的维度。

• criterion = torch.nn.MSELoss(): 定义了损失函数，使用均方误差（MSE）作为损失函数。

• optimizer = torch.optim.Adam(net.parameters(), lr=1e-2): 定义了优化器，使用 Adam 优化算法来更新模型的参数，学习率为 1e-2。

输出一下设置的模型内的一些层数的维度：

for param_tensor in net.state_dict():
    print(param_tensor,'\t',net.state_dict()[param_tensor].size())

（6）构造训练函数

设置训练1000次，每100次输出一次损失

running_loss=0.0
for epoch in range(1000):
    var_x=train_x
    var_y=train_y
    out=net(var_x)
    loss=criterion(out,var_y)
    running_loss+=loss.item()
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    if(epoch+1)%100==0:
        print('Epoch:{},loss:{:.5f}'.format(epoch+1,running_loss/100))
        running_loss=0.0
        

对以上代码进行解释：

• running_loss，用于记录每个训练周期的累计损失。
• out=net(var_x)这个out就是红框标出的需要预测的预测值，即将输入数据 var_x 通过神经网络模型 net 进行前向传播，得到输出 out。
  
• loss = criterion(out, var_y): 计算模型输出 out 和目标标签 var_y 之间的损失，使用预先定义的损失函数 criterion（在代码中是均方误差）。
• loss.item() 方法用于获取 loss 的数值（标量），然后将其加到 running_loss 上。
• optimizer.zero_grad(): 清空优化器中之前的梯度信息，以便进行下一次的反向传播。
• loss.backward(): 执行反向传播，计算损失函数关于模型参数的梯度。
• optimizer.step(): 这行代码根据计算得到的梯度更新模型参数，使用优化器中定义的Adam优化算法
• print输出平均损失

（7）对整个数据集进行预测

net = net.eval() # 转换成测试模式
data_x = dataX.reshape(-1, 1, look_back)
data_x = torch.from_numpy(data_x).to(torch.float32)
var_data = data_x
pred_test = net(var_data) # 测试集的预测结果
pred_test = pred_test.view(-1).data.numpy()

对上述代码解释：

• data_x = torch.from_numpy(data_x).to(torch.float32): 这行代码将 NumPy 数组 data_x 转换为 PyTorch 的 Tensor 对象，并将数据类型设置为 torch.float32。这是为了与神经网络模型的数据类型匹配。
• pred_test = pred_test.view(-1).data.numpy(): 这行代码对预测结果进行处理，首先使用 view(-1) 将输出结果展平为一维张量，然后使用 data.numpy() 将结果转换为 NumPy 数组，以便后续的分析和可视化。

（8）可视化展示

这里因为用30个预测1个，所以dataset进行了切片（总共114）

plt.plot(pred_test, 'deeppink', label='prediction')
plt.plot(dataset[look_back:], 'green', label='real')
plt.legend(loc='best')

（9）MSE为评价指标

这里因为用30个预测1个，所以计算MSE的也不包括前30个数据，否则没法去计算

from sklearn.metrics import mean_squared_error
MSE = mean_squared_error(dataset[look_back:], pred_test)
print(MSE)