LSTM：在Python中使用PyTorch使用LSTM进行时间序列预测

最新推荐文章于 2024-09-18 12:21:11 发布

科技那些事儿

最新推荐文章于 2024-09-18 12:21:11 发布

阅读量9.4k

点赞数 3

原文链接：https://juejin.cn/post/7096316708008230920

版权

PyTorch LSTM 时间序列预测数据预处理序列化

关键词由CSDN通过智能技术生成

时间序列数据，顾名思义，是一种随着时间改变的数据。例如，24小时气温数据，一个月得分产品价格数据，某一公司股票价格年度数据。高级深度学习模型，比如长短期记忆网络（LSTM），能够捕获到时间序列数据中的变化模式，进而能够预测数据的未来趋势。在这篇文章中，你将会看到如何利用LSTM算法来对时间序列数据进行预测。

在我早些时候的文章中，我展示了如何运用Keras库并利用LSTM进行时间序列分析，以预测未来的股票价格。将使用PyTorch库，它是最常用的深度学习的Python库之一。

在你继续之前，假定你对Python编程语言有中级水平的熟练度，并且你已经安装了PyTorch库。此外，对基本的机器学习概念和深度学习概念的了解也会有所帮助。如果你还没有安装PyTorch，你可以通过以下pip命令来安装。

$ pip install pytorch
复制代码

数据集和问题定义

我们将使用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']
复制代码

由于众所周知的原因，大家可以在Github上先下载整个数据包。

我们将使用flights数据集。如果没有网络问题可以用如下代码导入：

flight_data = sns.load_dataset("flights")
flight_data.head()
复制代码

数据集有3列：年，月和乘客数量。乘客数量一列描述了单月内航班乘客总数。数据集的形状：

flight_data.shape

output:
(144,3)
复制代码

可以看到，一共有144行和3列数据，即数据集包含12年的乘客记录。我们的任务是利用前132个月的数据预测最后12个月乘客数。也就是说前132个月的数据用作训练，最后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'])
复制代码

如图所示，多年来，乘飞机旅行的平均人数增加了。一年内旅行的乘客数量是波动的，这是有道理的，因为在夏季或冬季休假期间，旅行的乘客数量比一年中的其他时间增加。

数据处理

数据集中列的类型是 object，如下面的代码所示:

flight_data.columns
复制代码

输出：

Index(['year', 'month', 'passengers'], dtype='object')
复制代码

数据处理的第一步是将乘客数量一列的数据类型转换为float

all_data = flight_data['passengers'].values.astype(float)
复制代码

现在，如果你打印all_data numpy数组，你应该看到以下float类型的值。

[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:]
复制代码

我们的数据集目前还没有被规范化（normalization）。最初几年的乘客总数与后来几年的乘客总数相比要少得多。对于时间序列预测来说，将数据标准化是非常重要的。我们将对数据集进行最小/最大缩放，使数据在一定的最小值和最大值范围内正常化。我们将使用sklearn.preprocessing模块中的MinMaxScaler类来扩展我们的数据。关于最小/最大缩放器实现的进一步细节，请访问这个链接。

下面的代码使用最小/最大标度器对我们的数据进行标准化处理，最小值和最大值分别为-1和1。

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler(feature_range=(-1, 1))
train_data_normalized = scaler.fit_transform(train_data .reshape(-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个月内旅行的乘客数量，第二个元组元素将包含一个项目，即12+1个月内的乘客数量。

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]
        train_label = input_data[i+tw:i+tw+1]
        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个项目组成，第二个元组元素包含相应的标签