基于PyTorch+LSTM进行时间序列预测（附完整源码）

时间序列数据&＃xff0c;顾名思义是一种随时间变化的数据类型。

例如&＃xff0c;24小时内的温度、一个月内各种产品的价格、某家公司一年内的股票价格等。深度学习模型如长短期记忆网络&＃xff08;LSTM&＃xff09;能够捕捉时间序列数据中的模式&＃xff0c;因此可以用于预测未来趋势。

在本文中&＃xff0c;您将看到如何使用 LSTM 算法利用时间序列数据进行未来预测&＃xff0c;使用的是 PyTorch 库&＃xff0c;这是最常用于深度学习的Python库之一。

在继续之前&＃xff0c;确保已安装了 PyTorch 库。同时掌握基本机器学习和深度学习概念会有所帮助。如果尚未安装PyTorch&＃xff0c;则可以使用以下pip命令进行安装&＃xff1a;

$ pip install pytorch


技术提升

技术要学会分享、交流&＃xff0c;不建议闭门造车。一个人走的很快、一堆人可以走的更远。

完整代码、数据、技术交流提升&＃xff0c; 均可加知识星球交流群获取&＃xff0c;群友已超过2000人&＃xff0c;添加时切记的备注方式为&＃xff1a;来源&＃43;兴趣方向&＃xff0c;方便找到志同道合的朋友。

方式①、添加微信号&＃xff1a;pythoner666&＃xff0c;备注&＃xff1a;来自 CSDN &＃43; python
方式②、微信搜索公众号&＃xff1a;Python学习与数据挖掘&＃xff0c;后台回复&＃xff1a;加群

数据集和问题定义

我们将使用的数据集是Python Seaborn库中内置的。让我们首先导入所需的库&＃xff0c;然后再导入数据集&＃xff1a;

import torch
import torch.nn as nnimport seaborn as sns
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline


让我们打印出Seaborn库中内置的所有数据集列表&＃xff1a;

sns.get_dataset_names()


输出

[&＃39;anscombe&＃39;,&＃39;attention&＃39;,&＃39;brain_networks&＃39;,&＃39;car_crashes&＃39;,&＃39;diamonds&＃39;,&＃39;dots&＃39;,&＃39;exercise&＃39;,&＃39;flights&＃39;,&＃39;fmri&＃39;,&＃39;gammas&＃39;,&＃39;iris&＃39;,&＃39;mpg&＃39;,&＃39;planets&＃39;,&＃39;tips&＃39;,&＃39;titanic&＃39;]


我们将使用的数据集是航班数据集。让我们将数据集加载到我们的应用程序中&＃xff0c;看看它的样子&＃xff1a;

flight_data &＃61; sns.load_dataset("flights")
flight_data.head()


数据集有三列&＃xff1a;年份、月份和乘客数。乘客列包含指定月份旅行的总人数。让我们绘制数据集的形状&＃xff1a;

flight_data.shape## (144, 3)


您可以看到数据集中有144行和3列&＃xff0c;这意味着该数据集包含乘客12年的旅行记录。

任务是基于前132个月预测最近12个月旅行的乘客人数。请记住&＃xff0c;我们有144个月的记录&＃xff0c;这意味着来自前132个月的数据将用于训练我们的LSTM模型&＃xff0c;而模型性能将使用最后12个月的值进行评估。

让我们绘制每月旅行乘客数量的频率。以下脚本增加了默认图形大小&＃xff1a;

fig_size &＃61; plt.rcParams["figure.figsize"]
fig_size[0] &＃61; 15
fig_size[1] &＃61; 5
plt.rcParams["figure.figsize"] &＃61; fig_size


接下来的脚本绘制了乘客数量每月出现的频率&＃xff1a;

plt.title(&＃39;Month vs Passenger&＃39;)
plt.ylabel(&＃39;Total Passengers&＃39;)
plt.xlabel(&＃39;Months&＃39;)
plt.grid(True)
plt.autoscale(axis&＃61;&＃39;x&＃39;,tight&＃61;True)
plt.plot(flight_data[&＃39;passengers&＃39;])


输出结果显示&＃xff0c;多年来乘坐飞机旅行的平均乘客人数增加了。一年内旅行的乘客数量波动&＃xff0c;这是有道理的&＃xff0c;因为在暑假或寒假期间&＃xff0c;与其他时间相比旅行乘客数量会增加。

数据预处理

我们数据集中的列类型是对象&＃xff0c;如下代码所示&＃xff1a;

flight_data.columns
## output
Index([&＃39;year&＃39;, &＃39;month&＃39;, &＃39;passengers&＃39;], dtype&＃61;&＃39;object&＃39;)


第一个预处理步骤是将乘客列的类型更改为浮点数。

all_data &＃61; flight_data[&＃39;passengers&＃39;].values.astype(float)


现在&＃xff0c;如果您打印 all_data numpy数组&＃xff0c;您应该会看到以下浮点类型值&＃xff1a;

print(all_data)


[112. 118. 132. 129. 121. 135. 148. 148. 136. 119. 104. 118. 115. 126.141. 135. 125. 149. 170. 170. 158. 133. 114. 140. 145. 150. 178. 163.172. 178. 199. 199. 184. 162. 146. 166. 171. 180. 193. 181. 183. 218.230. 242. 209. 191. 172. 194. 196. 196. 236. 235. 229. 243. 264. 272.237. 211. 180. 201. 204. 188. 235. 227. 234. 264. 302. 293. 259. 229.203. 229. 242. 233. 267. 269. 270. 315. 364. 347. 312. 274. 237. 278.284. 277. 317. 313. 318. 374. 413. 405. 355. 306. 271. 306. 315. 301.356. 348. 355. 422. 465. 467. 404. 347. 305. 336. 340. 318. 362. 348.363. 435. 491. 505. 404. 359. 310. 337. 360. 342. 406. 396. 420. 472.548. 559. 463. 407. 362. 405. 417. 391. 419. 461. 472. 535. 622. 606.508. 461. 390. 432.]


接下来&＃xff0c;我们将把数据集分成训练集和测试集。LSTM算法将在训练集上进行训练。然后&＃xff0c;该模型将用于在测试集上进行预测。预测结果将与测试集中的实际值进行比较&＃xff0c;以评估已训练模型的性能。

前132条记录将用于训练模型&＃xff0c;而最后12条记录将用作测试集。以下脚本将数据分成训练集和测试集。

test_data_size &＃61; 12train_data &＃61; all_data[:-test_data_size]
test_data &＃61; all_data[-test_data_size:]


现在让我们打印测试集和训练集的长度&＃xff1a;

print(len(train_data))
print(len(test_data))
##
132
12


如果您现在打印测试数据&＃xff0c;您将看到它包含了all_data numpy数组中的最后12条记录&＃xff1a;

我们的数据集目前尚未标准化。最初几年的乘客总数远远少于后来几年的乘客总数。对于时间序列预测&＃xff0c;将数据进行标准化非常重要。我们将在数据集上执行 min/max 缩放&＃xff0c;该方法可以使数据在一定范围内归一化到最小值和最大值之间。

我们将使用 sklearn.preprocessing 模块中的 MinMaxScaler 类来缩放我们的数据。

以下代码使用最小值为-1&＃xff0c;最大值为1 的 min/max 缩放器对我们的数据进行了标准化处理&＃xff1a;

from sklearn.preprocessing import MinMaxScalerscaler &＃61; MinMaxScaler(feature_range&＃61;(-1, 1))
train_data_normalized &＃61; scaler.fit_transform(train_data .reshape(-1, 1))


让我们现在打印出归一化训练数据的前5条和后5条记录。

print(train_data_normalized[:5])
print(train_data_normalized[-5:])## output
[[-0.96483516][-0.93846154][-0.87692308][-0.89010989][-0.92527473]]
[[1. ][0.57802198][0.33186813][0.13406593][0.32307692]]


你可以看到数据集的值现在在-1和1之间。

这里需要强调的是&＃xff0c;数据归一化仅应用于训练数据&＃xff0c;而不应用于测试数据。如果对测试数据进行归一化&＃xff0c;则有可能会将某些信息从训练集泄漏到测试集中。

下一步是将我们的数据集转换为张量&＃xff0c;因为 PyTorch 模型使用张量进行训练。要将数据集转换为张量&＃xff0c;我们只需将其传递给FloatTensor对象的构造函数即可&＃xff0c;如下所示&＃xff1a;

train_data_normalized &＃61; torch.FloatTensor(train_data_normalized).view(-1)


最后的预处理步骤是将我们的训练数据转换为序列和相应的标签。

您可以使用任何序列长度&＃xff0c;这取决于领域知识。然而&＃xff0c;在我们的数据集中&＃xff0c;由于我们有每月的数据且一年有12个月&＃xff0c;因此使用序列长度为12是方便的。如果我们有每日数据&＃xff0c;则更好的序列长度将是365&＃xff0c;即一年中的天数。因此&＃xff0c;我们将设置训练输入序列长度为12。

train_window &＃61; 12


接下来&＃xff0c;我们将定义一个名为create_inout_sequences的函数。该函数将接受原始输入数据&＃xff0c;并返回一个元组列表。在每个元组中&＃xff0c;第一个元素将包含12个项目的列表&＃xff0c;对应于12个月内旅行的乘客数量&＃xff0c;第二个元素将包含一项即第13个月的乘客数量。

def create_inout_sequences(input_data, tw):inout_seq &＃61; []L &＃61; len(input_data)for i in range(L-tw):train_seq &＃61; input_data[i:i&＃43;tw]inout_seq.append((train_seq ,train_label))return inout_seq


执行以下脚本以创建用于训练的序列和相应标签&＃xff1a;

train_inout_seq &＃61; create_inout_sequences(train_data_normalized, train_window)


如果您打印 train_inout_seq 列表的长度&＃xff0c;您会发现它包含120个项目。这是因为尽管训练集包含132个元素&＃xff0c;但序列长度为12&＃xff0c;这意味着第一个序列由前12个项目组成&＃xff0c;而第13个项目是第一个序列的标签。同样&＃xff0c;第二个序列从第二项开始&＃xff0c;并在第13项结束&＃xff0c;而第14项是第二个序列的标签等等。

现在让我们打印 train_inout_seq 列表的前5项&＃xff1a;

train_inout_seq[:5]
## output
[(tensor([-0.9648, -0.9385, -0.8769, -0.8901, -0.9253, -0.8637, -0.8066, -0.8066,-0.8593, -0.9341, -1.0000, -0.9385]), tensor([-0.9516])),(tensor([-0.9385, -0.8769, -0.8901, -0.9253, -0.8637, -0.8066, -0.8066, -0.8593,-0.9341, -1.0000, -0.9385, -0.9516]),tensor([-0.9033])),(tensor([-0.8769, -0.8901, -0.9253, -0.8637, -0.8066, -0.8066, -0.8593, -0.9341,-1.0000, -0.9385, -0.9516, -0.9033]), tensor([-0.8374])),(tensor([-0.8901, -0.9253, -0.8637, -0.8066, -0.8066, -0.8593, -0.9341, -1.0000,-0.9385, -0.9516, -0.9033, -0.8374]), tensor([-0.8637])),(tensor([-0.9253, -0.8637, -0.8066, -0.8066, -0.8593, -0.9341, -1.0000, -0.9385,-0.9516, -0.9033, -0.8374, -0.8637]), tensor([-0.9077]))]


你可以看到每个项目都是一个元组&＃xff0c;其中第一个元素包含序列的12个项目&＃xff0c;第二个元组元素包含相应的标签。

创建LSTM模型

我们已经预处理了数据&＃xff0c;现在是训练模型的时候了。我们将定义一个类LSTM&＃xff0c;它继承自PyTorch库的nn.Module类。

class LSTM(nn.Module):def __init__(self, input_size&＃61;1, hidden_layer_size&＃61;100, output_size&＃61;1):super().__init__()self.hidden_layer_size &＃61; hidden_layer_sizeself.lstm &＃61; nn.LSTM(input_size, hidden_layer_size)self.linear &＃61; nn.Linear(hidden_layer_size, output_size)def forward(self, input_seq):lstm_out, self.hidden_cell &＃61; self.lstm(input_seq.view(len(input_seq) ,1, -1), self.hidden_cell)predictions &＃61; self.linear(lstm_out.view(len(input_seq), -1))return predictions[-1]


让我总结一下上面代码中发生的事情。LSTM 类的构造函数接受三个参数&＃xff1a;

• input_size&＃xff1a;对应于输入中特征的数量。虽然我们的序列长度为12&＃xff0c;但每个月只有1个值&＃xff0c;即乘客总数&＃xff0c;因此输入大小将为1。
• hidden_layer_size&＃xff1a;指定隐藏层的数量以及每层神经元的数量。我们将有一个100个神经元的隐藏层。
• output_size&＃xff1a;输出中项目的数量&＃xff0c;由于我们想要预测未来1个月内乘客人数&＃xff0c;因此输出大小将为1。

接下来&＃xff0c;在构造函数中创建变量 hidden_layer_size、lstm、linear 和 hidden_cell。

LSTM 算法接受三个输入&＃xff1a;先前隐藏状态、先前单元格状态和当前输入。hidden_cell 变量包含先前隐藏和单元格状态。lstm和linear层变量用于创建LSTM和线性层。

在 forward 方法内部&＃xff0c;input_seq 作为参数传递&＃xff0c;并首先通过lstm层传递。 lstm 层的输出是当前时间步长处的隐藏和 单元状态 &＃xff0c;以及输出 。从 lstm 层得到的输出会被传递到linear层 。预测出来的乘客人数存储在 predictions 列表 中最后一个项目中&＃xff0c;并返回给调用函数。

下一步是创建 LSTM() 类对象、定义损失函数和优化器。由于我们正在解决分类问题&＃xff0c;所以使用交叉熵损失。对于优化器函数&＃xff0c;我们将使用adam优化器。

model &＃61; LSTM()
loss_function &＃61; nn.MSELoss()
optimizer &＃61; torch.optim.Adam(model.parameters(), lr&＃61;0.001)


让我们打印我们的模型&＃xff1a;

print(model)## output
LSTM((lstm): LSTM(1, 100)(linear): Linear(in_features&＃61;100, out_features&＃61;1, bias&＃61;True)
)


训练模型

我们将训练我们的模型150个epochs。如果您愿意&＃xff0c;可以尝试更多的epochs。每25个epochs后会打印损失值。

epochs &＃61; 150for i in range(epochs):for seq, labels in train_inout_seq:optimizer.zero_grad()model.hidden_cell &＃61; (torch.zeros(1, 1, model.hidden_layer_size),torch.zeros(1, 1, model.hidden_layer_size))y_pred &＃61; model(seq)single_loss &＃61; loss_function(y_pred, labels)single_loss.backward()optimizer.step()if i%25 &＃61;&＃61; 1:print(f&＃39;epoch: {i:3} loss: {single_loss.item():10.8f}&＃39;)print(f&＃39;epoch: {i:3} loss: {single_loss.item():10.10f}&＃39;)


输出

epoch: 1 loss: 0.00517058
epoch: 26 loss: 0.00390285
epoch: 51 loss: 0.00473305
epoch: 76 loss: 0.00187001
epoch: 101 loss: 0.00000075
epoch: 126 loss: 0.00608046
epoch: 149 loss: 0.0004329932


由于 PyTorch 神经网络默认情况下会随机初始化权重&＃xff0c;因此您可能会得到不同的值。

进行预测

现在我们的模型已经训练好了&＃xff0c;我们可以开始进行预测。由于测试集包含过去 12 个月的乘客数据&＃xff0c;并且我们的模型是使用长度为 12 的序列来进行预测训练的。因此&＃xff0c;我们将首先从训练集中筛选出最后 12 个值&＃xff1a;

fut_pred &＃61; 12test_inputs &＃61; train_data_normalized[-train_window:].tolist()
print(test_inputs)output
[0.12527473270893097, 0.04615384712815285, 0.3274725377559662, 0.2835164964199066, 0.3890109956264496, 0.6175824403762817, 0.9516483545303345, 1.0, 0.5780220031738281, 0.33186814188957214, 0.13406594097614288, 0.32307693362236023]


您可以将上述值与train_data_normalized数据列表的最后12个值进行比较。

最初&＃xff0c;test_inputs 项目将包含12个项目。在for循环内部&＃xff0c;这些12个项目将用于对测试集中的第一个项目&＃xff08;即第133项&＃xff09;进行预测。然后&＃xff0c;预测值将附加到test_inputs列表中。在第二次迭代中&＃xff0c;再次使用最后12个项目作为输入&＃xff0c;并进行新的预测&＃xff0c;然后再次将其附加到test_inputs列表中。由于测试集中有12个元素&＃xff0c;因此for循环将执行12次。在循环结束时&＃xff0c;test_inputs列表将包含24个项目。最后12项是测试集的预测值。

以下脚本用于进行预测&＃xff1a;

model.eval()for i in range(fut_pred):seq &＃61; torch.FloatTensor(test_inputs[-train_window:])with torch.no_grad():model.hidden &＃61; (torch.zeros(1, 1, model.hidden_layer_size),torch.zeros(1, 1, model.hidden_layer_size))test_inputs.append(model(seq).item())


如果您打印test_inputs列表的长度&＃xff0c;您将看到它包含24个项目。最后12个预测项可以按如下方式打印&＃xff1a;

test_inputs[fut_pred:]


[0.4574652910232544,0.9810629487037659,1.279405951499939,1.0621851682662964,1.5830546617507935,1.8899496793746948,1.323508620262146,1.8764172792434692,2.1249167919158936,1.7745600938796997,1.7952896356582642,1.977765679359436]


需要再次提到的是&＃xff0c;根据用于训练 LSTM 的权重不同&＃xff0c;您可能会得到不同的值。

由于我们对数据集进行了归一化处理以进行训练&＃xff0c;因此预测值也被归一化。我们需要将归一化后的预测值转换为实际预测值。我们可以通过将归一化后的值传递给最小/最大缩放器对象的inverse_transform方法来实现这一点。

actual_predictions &＃61; scaler.inverse_transform(np.array(test_inputs[train_window:] ).reshape(-1, 1))
print(actual_predictions)## output
[[435.57335371][554.69182083][622.56485397][573.14712578][691.64493555][761.46355206][632.59821111][758.38493103][814.91857016][735.21242136][739.92839211][781.44169205]]


现在让我们将预测值与实际值绘制出来。请看以下代码&＃xff1a;

x &＃61; np.arange(132, 144, 1)
print(x)## output
[132 133 134 135 136 137 138 139 140 141 142 143]


在上面的脚本中&＃xff0c;我们创建了一个包含过去12个月数值的列表。第一个月的索引值为0&＃xff0c;因此最后一个月将在索引143处。

在下面的脚本中&＃xff0c;我们将绘制144个月的乘客总数以及最后12个月预测的乘客数量。

plt.title(&＃39;Month vs Passenger&＃39;)
plt.ylabel(&＃39;Total Passengers&＃39;)
plt.grid(True)
plt.autoscale(axis&＃61;&＃39;x&＃39;, tight&＃61;True)
plt.plot(flight_data[&＃39;passengers&＃39;])
plt.plot(x,actual_predictions)
plt.show()


我们的LSTM所做出的预测由橙色线条表示。您可以看到&＃xff0c;我们的算法并不是非常准确&＃xff0c;但仍然能够捕捉到过去12个月旅客总数上升趋势以及偶发波动。您可以尝试增加训练轮数和LSTM层中神经元数量来提高性能。

为了更好地查看输出结果&＃xff0c;我们可以按以下方式绘制过去12个月实际和预测乘客人数&＃xff1a;

plt.title(&＃39;Month vs Passenger&＃39;)
plt.ylabel(&＃39;Total Passengers&＃39;)
plt.grid(True)
plt.autoscale(axis&＃61;&＃39;x&＃39;, tight&＃61;True)plt.plot(flight_data[&＃39;passengers&＃39;][-train_window:])
plt.plot(x,actual_predictions)
plt.show()


结论

LSTM 是解决序列问题最广泛使用的算法之一。在本文中&＃xff0c;我们看到了如何使用 LSTM 对时间序列数据进行未来预测。

您还学会了如何使用 PyTorch 库实现 LSTM&＃xff0c;并将预测结果与实际值绘制在一起以查看训练好的算法表现如何。