基于pytorch搭建多特征LSTM时间序列预测代码详细解读（附完整代码）

文章目录

对于LSTM神经网络的概念想必大家也是熟练掌握了&＃xff0c;所以本文章不涉及对LSTM概念的解读&＃xff0c;仅解释如何使用pytorch使用LSTM进行时间序列预测&＃xff0c;复原使用代码实现的全流程。

数据获取与预处理

首先预览一下本次实验使用的数据集&＃xff0c;该数据集共有三个特征&＃xff0c;将最后一列的压气机出口温度作为标签预测&＃xff08;该数据集是我在git上收集到的&＃xff09;

定义一个xls文件读取的函数&＃xff0c;其中data.iloc()函数是将dataframe中的数据进行切片&＃xff0c;返回数据和标签

# 文件读取
def get_Data(data_path):
data&＃061;pd.read_excel(data_path)
data&＃061;data.iloc[:,:3] # 以三个特征作为数据
label&＃061;data.iloc[:,2:] # 取最后一个特征作为标签
print(data.head())
print(label.head())
return data,label


使用sklearn中的preprocessing模块中的归一化函数对数据进行归一化处理&＃xff0c;其中data&＃061;data.values函数是将dataframe中的数据从pd格式转换np数组&＃xff0c;删除轴标签&＃xff0c;fit_transform函数是fit&＃xff08;&＃xff09;和transform&＃xff08;&＃xff09;的组合&＃xff0c;是将fit和transform合并&＃xff0c;一步到位的结果&＃xff0c;最后返回data&＃xff0c;label和归一化的标签值

# 数据预处理
def normalization(data,label):
mm_x&＃061;MinMaxScaler() # 导入sklearn的预处理容器
mm_y&＃061;MinMaxScaler()
data&＃061;data.values # 将pd的系列格式转换为np的数组格式
label&＃061;label.values
data&＃061;mm_x.fit_transform(data) # 对数据和标签进行归一化等处理
label&＃061;mm_y.fit_transform(label)
return data,label,mm_y


我们将数据进行归一化之后&＃xff0c;数据是np数组格式&＃xff0c;我们需要将其转换成向量的格式存储在列表当中&＃xff0c;因此&＃xff0c;先创建两个空列表&＃xff0c;建立一个for循环将预处理过的数据最后按x.size(0),seq_length,features&＃xff09;的纬度输出至列表当中。其中seq_length代表的是时间步长&＃xff0c;x.size(0)则表示的是数据的第一维度&＃xff0c;features代表的是数据的特征数。打印x,y的维度并返回x,y。

# 时间向量转换
def split_windows(data,seq_length):
x&＃061;[]
y&＃061;[]
for i in range(len(data)-seq_length-1): # range的范围需要减去时间步长和1
_x&＃061;data[i:(i&＃043;seq_length),:]
_y&＃061;data[i&＃043;seq_length,-1]
x.append(_x)
y.append(_y)
x,y&＃061;np.array(x),np.array(y)
print(&＃039;x.shape,y.shape&＃061;\n&＃039;,x.shape,y.shape)
return x,y


将数据和标签都准备好之后即可分离数据&＃xff0c;将数据分离成训练集和测试集。定义split_data()函数&＃xff0c;其中split_ratio是设定的测试集比例&＃xff0c;本次实验设置的训练集与测试集之比为9:1&＃xff0c;即split_ratio&＃061;0.1。将分离好的数据分别装入Variable中封装好&＃xff0c;并且将array转换成tensor格式&＃xff0c;得到测试集和训练集。注意&＃xff0c;一定要使用Variable函数对数据集进行封装&＃xff0c;否则不支持后面torch的迭代。

# 数据分离
def split_data(x,y,split_ratio):
train_size&＃061;int(len(y)*split_ratio)
test_size&＃061;len(y)-train_size
x_data&＃061;Variable(torch.Tensor(np.array(x)))
y_data&＃061;Variable(torch.Tensor(np.array(y)))
x_train&＃061;Variable(torch.Tensor(np.array(x[0:train_size])))
y_train&＃061;Variable(torch.Tensor(np.array(y[0:train_size])))
y_test&＃061;Variable(torch.Tensor(np.array(y[train_size:len(y)])))
x_test&＃061;Variable(torch.Tensor(np.array(x[train_size:len(x)])))
print(&＃039;x_data.shape,y_data.shape,x_train.shape,y_train.shape,x_test.shape,y_test.shape:\n{}{}{}{}{}{}&＃039;
.format(x_data.shape,y_data.shape,x_train.shape,y_train.shape,x_test.shape,y_test.shape))
return x_data,y_data,x_train,y_train,x_test,y_test


将封装好的训练集和测试集装入torch支持的可迭代对象torch.utils.data.DataLoader中&＃xff0c;num_epochs是计算得到的迭代次数&＃xff0c;返回train_loader,test_loader,num_epochs&＃xff0c;这样&＃xff0c;数据集就预处理好了&＃xff0c;可以进行模型的搭建了。

# 数据装入
def data_generator(x_train,y_train,x_test,y_test,n_iters,batch_size):
num_epochs&＃061;n_iters/(len(x_train)/batch_size) # n_iters代表一次迭代
num_epochs&＃061;int(num_epochs)
train_dataset&＃061;Data.TensorDataset(x_train,y_train)
test_dataset&＃061;Data.TensorDataset(x_train,y_train)
train_loader&＃061;torch.utils.data.DataLoader(dataset&＃061;train_dataset,batch_size&＃061;batch_size,shuffle&＃061;False,drop_last&＃061;True) # 加载数据集,使数据集可迭代
test_loader&＃061;torch.utils.data.DataLoader(dataset&＃061;test_dataset,batch_size&＃061;batch_size,shuffle&＃061;False,drop_last&＃061;True)
return train_loader,test_loader,num_epochs


模型构建

使用torch构建模型无非就是定义一个类&＃xff0c;在这个类中定义一个模型实例和前向传播函数&＃xff0c;就这么简单&＃xff0c;接下来让我们来看看。

# 定义一个类
class Net(nn.Module):
def __init__(self,input_size,hidden_size,num_layers,output_size,batch_size,seq_length) -> None:
super(Net,self).__init__()
self.input_size&＃061;input_size
self.hidden_size&＃061;hidden_size
self.num_layers&＃061;num_layers
self.output_size&＃061;output_size
self.batch_size&＃061;batch_size
self.seq_length&＃061;seq_length
self.num_directions&＃061;1 # 单向LSTM
self.lstm&＃061;nn.LSTM(input_size&＃061;input_size,hidden_size&＃061;hidden_size,num_layers&＃061;num_layers,batch_first&＃061;True) # LSTM层
self.fc&＃061;nn.Linear(hidden_size,output_size) # 全连接层
def forward(self,x):
# e.g. x(10,3,100) 三个句子&＃xff0c;十个单词&＃xff0c;一百维的向量,nn.LSTM(input_size&＃061;100,hidden_size&＃061;20,num_layers&＃061;4)
# out.shape&＃061;(10,3,20) h/c.shape&＃061;(4,b,20)
batch_size, seq_len &＃061; x.size()[0], x.size()[1] # x.shape&＃061;(604,3,3)
h_0 &＃061; torch.randn(self.num_directions * self.num_layers, x.size(0), self.hidden_size)
c_0 &＃061; torch.randn(self.num_directions * self.num_layers, x.size(0), self.hidden_size)
# output(batch_size, seq_len, num_directions * hidden_size)
output, _ &＃061; self.lstm(x, (h_0, c_0)) # output(5, 30, 64)
pred &＃061; self.fc(output) # (5, 30, 1)
pred &＃061; pred[:, -1, :] # (5, 1)
return pred


首先定义一个实例&＃xff0c;其中包括必须参数input_size,hidden_size,num_layers,output_size,batch_size,seq_length。将self.num_directions设置为1代表这是一个单项的LSTM&＃xff0c;然后再添加一个lstm层和一个全连接层fc&＃xff0c;lstm层输入维度为(input_size&＃061;input_size,hidden_size&＃061;hidden_size,num_layers&＃061;num_layers)&＃xff0c;设置了,batch_first&＃061;True则代表shape&＃061;&＃xff08;batch_size&＃xff0c;seq_size,hidden_size&＃xff09;&＃xff0c;fc层的参数为(hidden_size,output_size)&＃xff0c;返回pred

训练与测试

训练模型&＃xff0c;初始化i,(batch_x, batch_y)&＃xff0c;将train_loader设置为枚举类型&＃xff0c;optimizer.zero_grad() 代表将每次传播时的梯度累积清除&＃xff0c;torch中如果不声明optimizer.zero_grad()则会一直累积计算梯度&＃xff0c;设置每100次输入打印一次损失

# train
iter&＃061;0
for epochs in range(num_epochs):
for i,(batch_x, batch_y) in enumerate (train_loader):
outputs &＃061; moudle(batch_x)
optimizer.zero_grad() # 将每次传播时的梯度累积清除
# print(outputs.shape, batch_y.shape)
loss &＃061; criterion(outputs,batch_y) # 计算损失
loss.backward() # 反向传播
optimizer.step()
iter&＃043;&＃061;1
if iter % 100 &＃061;&＃061; 0:
print("iter: %d, loss: %1.5f" % (iter, loss.item()))


最后几次损失如下

iter: 2400, loss: 0.00331
iter: 2500, loss: 0.00039
...
iter: 4400, loss: 0.00332
iter: 4500, loss: 0.00022
iter: 4600, loss: 0.00380
iter: 4700, loss: 0.00032


将最后训练集和测试集的MAE/RMSE画出&＃xff0c;得到最终结果。

def result(x_data, y_data):
moudle.eval()
train_predict &＃061; moudle(x_data)
data_predict &＃061; train_predict.data.numpy()
y_data_plot &＃061; y_data.data.numpy()
y_data_plot &＃061; np.reshape(y_data_plot, (-1,1))
data_predict &＃061; mm_y.inverse_transform(data_predict)
y_data_plot &＃061; mm_y.inverse_transform(y_data_plot)
plt.plot(y_data_plot)
plt.plot(data_predict)
plt.legend((&＃039;real&＃039;, &＃039;predict&＃039;),fontsize&＃061;&＃039;15&＃039;)
plt.show()
print(&＃039;MAE/RMSE&＃039;)
print(mean_absolute_error(y_data_plot, data_predict))
print(np.sqrt(mean_squared_error(y_data_plot, data_predict) ))
result(x_data, y_data)
result(x_test,y_test)


最终结果&＃xff1a;训练集&＃xff1a;MAE/RMSE&＃xff1a;35.114613\75.8706
测试集&＃xff1a;MAE/RMSE:213.30313\213.31061
本文仅作示范pytorch构建lstm的用法&＃xff0c;预测结果不是很准确&＃xff0c;像dropout等都没加&＃xff0c;仅供参考。
完整代码见我的github:https://github.com/Tuniverj/Pytorch-lstm-forecast