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

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

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

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

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

$ pip install pytorch

技术提升

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

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

方式①、添加微信号:pythoner666,备注:来自 CSDN + python
方式②、微信搜索公众号:Python学习与数据挖掘,后台回复:加群

数据集和问题定义

我们将使用的数据集是Python Seaborn库中内置的。让我们首先导入所需的库,然后再导入数据集:

import torch
import torch.nn as nn

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

让我们打印出Seaborn库中内置的所有数据集列表:

sns.get_dataset_names()

输出

['anscombe',
 'attention',
 'brain_networks',
 'car_crashes',
 'diamonds',
 'dots',
 'exercise',
 'flights',
 'fmri',
 'gammas',
 'iris',
 'mpg',
 'planets',
 'tips',
 'titanic']

我们将使用的数据集是航班数据集。让我们将数据集加载到我们的应用程序中,看看它的样子:

flight_data = sns.load_dataset("flights")
flight_data.head()

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

flight_data.shape

## (144, 3)

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

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

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

fig_size = plt.rcParams["figure.figsize"]
fig_size[0] = 15
fig_size[1] = 5
plt.rcParams["figure.figsize"] = fig_size

接下来的脚本绘制了乘客数量每月出现的频率:

plt.title('Month vs Passenger')
plt.ylabel('Total Passengers')
plt.xlabel('Months')
plt.grid(True)
plt.autoscale(axis='x',tight=True)
plt.plot(flight_data['passengers'])

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

数据预处理

我们数据集中的列类型是对象,如下代码所示:

flight_data.columns
## output
Index(['year', 'month', 'passengers'], dtype='object')

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

all_data = flight_data['passengers'].values.astype(float)

现在,如果您打印 all_data numpy数组,您应该会看到以下浮点类型值:

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.]

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

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

test_data_size = 12

train_data = all_data[:-test_data_size]
test_data = all_data[-test_data_size:]

现在让我们打印测试集和训练集的长度:

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

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

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

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

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

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler(feature_range=(-1, 1))
train_data_normalized = 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之间。

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

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

train_data_normalized = torch.FloatTensor(train_data_normalized).view(-1)

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

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

train_window = 12

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

def create_inout_sequences(input_data, tw):
    inout_seq = []
    L = len(input_data)
    for i in range(L-tw):
        train_seq = input_data[i:i+tw]
        inout_seq.append((train_seq ,train_label))
    return inout_seq

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

train_inout_seq = create_inout_sequences(train_data_normalized, train_window)

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

现在让我们打印 train_inout_seq 列表的前5项:

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]))]

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

创建LSTM模型

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

class LSTM(nn.Module):
    def __init__(self, input_size=1, hidden_layer_size=100, output_size=1):
        super().__init__()
        self.hidden_layer_size = hidden_layer_size

        self.lstm = nn.LSTM(input_size, hidden_layer_size)

        self.linear = nn.Linear(hidden_layer_size, output_size)

    def forward(self, input_seq):
        lstm_out, self.hidden_cell = self.lstm(input_seq.view(len(input_seq) ,1, -1), self.hidden_cell)
        predictions = self.linear(lstm_out.view(len(input_seq), -1))
        return predictions[-1]

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

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

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

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

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

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

model = LSTM()
loss_function = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

让我们打印我们的模型:

print(model)

## output
LSTM(
  (lstm): LSTM(1, 100)
  (linear): Linear(in_features=100, out_features=1, bias=True)
)

训练模型

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

epochs = 150

for i in range(epochs):
    for seq, labels in train_inout_seq:
        optimizer.zero_grad()
        model.hidden_cell = (torch.zeros(1, 1, model.hidden_layer_size),
                        torch.zeros(1, 1, model.hidden_layer_size))

        y_pred = model(seq)

        single_loss = loss_function(y_pred, labels)
        single_loss.backward()
        optimizer.step()

    if i%25 == 1:
        print(f'epoch: {i:3} loss: {single_loss.item():10.8f}')

print(f'epoch: {i:3} loss: {single_loss.item():10.10f}')

输出

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 神经网络默认情况下会随机初始化权重,因此您可能会得到不同的值。

进行预测

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

fut_pred = 12

test_inputs = 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个值进行比较。

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

以下脚本用于进行预测:

model.eval()

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

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

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]

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

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

actual_predictions = 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]]

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

x = np.arange(132, 144, 1)
print(x)

## output 
[132 133 134 135 136 137 138 139 140 141 142 143]

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

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

plt.title('Month vs Passenger')
plt.ylabel('Total Passengers')
plt.grid(True)
plt.autoscale(axis='x', tight=True)
plt.plot(flight_data['passengers'])
plt.plot(x,actual_predictions)
plt.show()

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

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

plt.title('Month vs Passenger')
plt.ylabel('Total Passengers')
plt.grid(True)
plt.autoscale(axis='x', tight=True)

plt.plot(flight_data['passengers'][-train_window:])
plt.plot(x,actual_predictions)
plt.show()

结论

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

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

  • 18
    点赞
  • 211
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
基于PyTorch LSTM(长短期记忆网络)进行时间序列预测的代码如下所示: ```python import torch import torch.nn as nn import numpy as np # 定义LSTM模型 class LSTM(nn.Module): def __init__(self, input_size, hidden_size, num_layers, output_size): super(LSTM, self).__init__() self.hidden_size = hidden_size self.num_layers = num_layers self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True) self.fc = nn.Linear(hidden_size, output_size) def forward(self, x): h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(device) c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(device) out, _ = self.lstm(x, (h0, c0)) out = self.fc(out[:, -1, :]) return out # 设置随机种子,以便复现结果 torch.manual_seed(42) # 超参数 input_size = 1 hidden_size = 32 num_layers = 2 output_size = 1 num_epochs = 100 learning_rate = 0.001 # 创建数据集(假设我们有一个包含100个数据点的时间序列) data = np.sin(np.arange(0, 10*np.pi, 0.1)) data = data[:, None] # 划分训练集和测试集 train_size = int(len(data) * 0.8) test_size = len(data) - train_size train_data = data[:train_size, :] test_data = data[train_size:, :] # 将数据集转化为PyTorch的张量 train_data = torch.Tensor(train_data).float() test_data = torch.Tensor(test_data).float() # 定义设备 device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # 初始化模型 model = LSTM(input_size, hidden_size, num_layers, output_size).to(device) # 定义损失函数和优化器 criterion = nn.MSELoss() optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) # 训练模型 for epoch in range(num_epochs): model.train() # 前向传播和计算损失 output = model(train_data) loss = criterion(output, train_data) # 反向传播和优化 optimizer.zero_grad() loss.backward() optimizer.step() if (epoch+1) % 10 == 0: print(f"Epoch: {epoch+1}, Loss: {loss.item()}") # 在测试集上进行预测 model.eval() with torch.no_grad(): # 训练数据结果 train_result = model(train_data).detach().numpy() # 测试数据结果 test_result = model(test_data).detach().numpy() # 绘制结果图 import matplotlib.pyplot as plt plt.figure(figsize=(12, 8)) plt.plot(train_data.numpy(), label='Original data') plt.plot(range(train_size, len(data)), train_result, label='Train prediction') plt.plot(range(train_size, len(data)), test_result, label='Test prediction') plt.legend() plt.show() ``` 上述代码首先定义了一个LSTM模型,然后设置了超参数,创建了一个包含100个数据点的时间序列,并将其划分为训练集和测试集。接下来,将数据转换为PyTorch张量,并定义了设备(CPU或GPU)。 然后,初始化模型,并定义损失函数和优化器。在训练过程中,进行前向传播、计算损失、反向传播和优化,然后将损失打印出来。 在测试阶段,使用训练好的模型对训练集和测试集进行预测,并将结果可视化显示出来。最后,使用matplotlib库绘制了原始数据、训练预测和测试预测的图形。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值