时间序列预测模型实战案例(三)(LSTM)(Python)(深度学习)时间序列预测(包括运行代码以及代码讲解)

目录

引言

LSTM的预测效果图

LSTM机制

了解LSTM的结构

忘记门

输入门

输出门

LSTM的变体

只有忘记门的LSTM单元

独立循环(IndRNN)单元

双向RNN结构(LSTM)

运行代码

代码讲解

---

引言

LSTM（Long Short-Term Memory）是一种常用的循环神经网络（RNN）模型，用于处理序列数据，具有记忆长短期的能力。在时间序列预测中，LSTM既可以多元预测机制又可以作为单元预测机制使用。

作为多元预测机制，LSTM可以处理多个相关变量的历史数据，从而可以预测这些变量的未来值。具体地，我们可以将多个变量的历史数据作为LSTM的输入，将多个变量的未来值作为LSTM的输出。在训练过程中，我们可以使用误差反向传播算法来更新LSTM的参数，从而优化模型的预测性能。

作为单元预测机制，LSTM可以预测单一变量的未来值，例如股票价格、销售量等。在单元时间序列预测中，我们需要对历史数据进行分析，确定趋势、季节性和周期性等因素，并使用这些因素来预测未来的值。LSTM可以通过学习历史数据中的模式和规律，来预测未来的值。

LSTM作为多元预测机制和单元预测机制的优点是可以处理序列数据中的长期依赖关系，从而可以捕捉到数据中的复杂模式和规律。它可以自适应地学习和调整模型参数，从而提高模型的预测性能和泛化能力。

总的来说，LSTM作为多元预测机制和单元预测机制的应用广泛，可以用于预测股票价格、气象数据、交通流量等多个领域的数据。

(文末有复制粘贴即可运行的代码)

LSTM的预测效果图

这里先给大家展示一下LSTM的预测效果图(这里的预测指的是预测未知的数据并不是在测试集或者验证集上的预测)，其中MAE误差为0.15,ME误差为-0.03。

其误差损失图为,其为MAE的误差图

LSTM机制

LSTM（长短期记忆，Long Short-Term Memory）是一种用于处理序列数据的深度学习模型，属于循环神经网络（RNN）的一种变体,其使用一种类似于搭桥术结构的RNN单元。相对于普通的RNN，LSTM引入了门控机制，能够更有效地处理长期依赖和短期记忆问题，是RNN网络中最常使用的Cell之一。

了解LSTM的结构

LSTM通过刻意的设计来实现学习序列关系的同时，又能够避免长期依赖的问题。它的结构示意图如下所示。

在LSTM的结构示意图中，每一条黑线传输着一整个向量，从一个节点的输出到其他节点的输入。其中“+”号代表着运算操作(如矢量的和)，而矩形代表着学习到的神经网络层。汇合在一起的线表示向量的连接，分叉的线表示内容被复制，然后分发到不同的位置。

如果上面的LSTM结构图你看着很难理解,但是其实LSTM的本质就是一个带有tanh激活函数的简单RNN，如下图所示。

LSTM这种结构的原理是引入一个称为细胞状态的连接。这个状态细胞用来存放想要的记忆的东西(对应简单LSTM结构中的h，只不过这里面不再只保存上一次状态了，而是通过网络学习存放那些有用的状态)，同时在加入三个门,分别是。

        忘记门:决定什么时候将以前的状态忘记。

        输入门：决定什么时候将新的状态加进来。

        输出门：决定什么时候需要把状态和输入放在一起输出。

从字面上可以看出，由于三个门的操作，LSTM在状态的更新和状态是否要作为输入，全部交给了神经网络的训练机制来选择。

下面分别来介绍一下三个门的结构和作用。

忘记门

下图所示为忘记门的操作，忘记门决定模型会从细胞状态中丢弃什么信息。

忘记门会读取前一序列模型的输出

在上图的LSTM的忘记门中，

在上面输入门的结构中，

再上图LSTM输入门的更新图中，

在LSTM的输出门结构图中，

双向RNN会比单项RNN多一个隐藏层，6个独特的权值在每一个时步被重复利用，6个权值分别对应：输入到向前和向后隐含层，隐含层到隐含层自身，向前和向后隐含层到输出层。

有关双向RNN(LSTM)我会在后续文章中讲到，这里只是大致介绍一下。 

(在大多数应用中，基于时间序列的分析和有关NLP中自动回答类的一些问题中，一般是以双向LSTM配合单向LSTM或RNN横向扩展来实现，效果非常好)

运行代码

下面的代码大家可以赋值到一个py文件中输入自己的文件预测文件即可运行，这只是一个简单LSTM模型搭建,其可以搭配许多其他模块进行组合例如:注意力机制(TPA)、其他的网络结构(GRU)、双向的RNN结构等。

1. import time
2. import numpy as np
3. import pandas as pd
4. import torch
5. import torch.nn as nn
6. from matplotlib import pyplot as plt
7. from sklearn.preprocessing import MinMaxScaler
9. np.random.seed(0)
12. def calculate_mae(y_true, y_pred):
13. # 平均绝对误差
14. mae = np.mean(np.abs(y_true - y_pred))
15. return mae
18. true_data = pd.read_csv('ETTh1-Test.csv') # 填你自己的数据地址
20. target = 'OT'
23. # 这里加一些数据的预处理, 最后需要的格式是pd.series
25. true_data = np.array(true_data['OT'])
27. # 定义窗口大小
28. test_data_size = 32
29. # 训练集和测试集的尺寸划分
30. test_size = 0.15
31. train_size = 0.85
32. # 标准化处理
33. scaler_train = MinMaxScaler(feature_range=(0, 1))
34. scaler_test = MinMaxScaler(feature_range=(0, 1))
35. train_data = true_data[:int(train_size * len(true_data))]
36. test_data = true_data[-int(test_size * len(true_data)):]
37. print("训练集尺寸:", len(train_data))
38. print("测试集尺寸:", len(test_data))
39. train_data_normalized = scaler_train.fit_transform(train_data.reshape(-1, 1))
40. test_data_normalized = scaler_test.fit_transform(test_data.reshape(-1, 1))
41. # 转化为深度学习模型需要的类型Tensor
42. train_data_normalized = torch.FloatTensor(train_data_normalized).view(-1)
43. test_data_normalized = torch.FloatTensor(test_data_normalized).view(-1)
46. def create_inout_sequences(input_data, tw, pre_len):
47. inout_seq = []
48. L = len(input_data)
49. for i in range(L - tw):
50. train_seq = input_data[i:i + tw]
51. if (i + tw + 4) > len(input_data):
52. break
53. train_label = input_data[i + tw:i + tw + pre_len]
54. inout_seq.append((train_seq, train_label))
55. return inout_seq
57. pre_len = 4
58. train_window = 16
59. # 定义训练器的的输入
60. train_inout_seq = create_inout_sequences(train_data_normalized, train_window, pre_len)
63. class LSTM(nn.Module):
64. def __init__(self, input_dim=1, hidden_dim=350, output_dim=1):
65. super(LSTM, self).__init__()
67. self.hidden_dim = hidden_dim
68. self.lstm = nn.LSTM(input_dim, hidden_dim, batch_first=True)
69. self.fc = nn.Linear(hidden_dim, output_dim)
71. def forward(self, x):
72. x = x.unsqueeze(1)
74. h0_lstm = torch.zeros(1, self.hidden_dim).to(x.device)
75. c0_lstm = torch.zeros(1, self.hidden_dim).to(x.device)
77. out, _ = self.lstm(x, (h0_lstm, c0_lstm))
78. out = out[:, -1]
79. out = self.fc(out)
81. return out
84. lstm_model = LSTM(input_dim=1, output_dim=pre_len, hidden_dim=train_window)
85. loss_function = nn.MSELoss()
86. optimizer = torch.optim.Adam(lstm_model.parameters(), lr=0.001)
87. epochs = 10
88. Train = True # 训练还是预测
90. if Train:
91. losss = []
92. lstm_model.train() # 训练模式
93. start_time = time.time() # 计算起始时间
94. for i in range(epochs):
95. for seq, labels in train_inout_seq:
96. lstm_model.train()
97. optimizer.zero_grad()
99. y_pred = lstm_model(seq)
101. single_loss = loss_function(y_pred, labels)
103. single_loss.backward()
104. optimizer.step()
105. print(f'epoch: {i:3} loss: {single_loss.item():10.8f}')
106. losss.append(single_loss.detach().numpy())
107. torch.save(lstm_model.state_dict(), 'save_model.pth')
108. print(f"模型已保存,用时:{(time.time() - start_time) / 60:.4f} min")
109. plt.plot(losss)
110. # 设置图表标题和坐标轴标签
111. plt.title('Training Error')
112. plt.xlabel('Epoch')
113. plt.ylabel('Error')
114. # 保存图表到本地
115. plt.savefig('training_error.png')
116. else:
117. # 加载模型进行预测
118. lstm_model.load_state_dict(torch.load('save_model.pth'))
119. lstm_model.eval() # 评估模式
120. results = []
121. reals = []
122. losss = []
123. test_inout_seq = create_inout_sequences(test_data_normalized, train_window, pre_len)
124. for seq, labels in train_inout_seq:
125. pred = lstm_model(seq)[0].item()
126. results.append(pred)
127. mae = calculate_mae(pred, labels.detach().numpy()) # MAE误差计算绝对值(预测值 - 真实值)
128. reals.append(labels.detach().numpy())
129. losss.append(mae)
131. print("模型预测结果：", results)
132. print("预测误差MAE:", losss)
134. plt.style.use('ggplot')
136. # 创建折线图
137. plt.plot(results, label='real', color='blue') # 实际值
138. plt.plot(reals, label='forecast', color='red', linestyle='--') # 预测值
140. # 增强视觉效果
141. plt.grid(True)
142. plt.title('real vs forecast')
143. plt.xlabel('time')
144. plt.ylabel('value')
145. plt.legend()
146. plt.savefig('test——results.png')

数据格式 

运行上述代码需要只需要一列数据即可,并且最后数据需要是一个pd.series类型,大家可以在读取进来文件后面加一些数据的处理操作。

(需要注意的是大家的数据不要打乱时间顺序否则预测出来的结果可能不准) 

代码讲解

在上面的运行代码中,主要填写的是在下面填上你的数据目录,

true_data = pd.read_csv('') # 填你自己的数据地址

这里是定义了test_data_size是指根据过去多少条数据来预测未来的预测值

test_size和train_size代表训练集和测试集的尺寸划分。 

1. # 定义窗口大小
2. test_data_size = 350
3. # 训练集和测试集的尺寸划分
4. test_size = 0.15
5. train_size = 0.85

这里定义了数据加载器的操作 

1. def create_inout_sequences(input_data, tw):
2. inout_seq = []
3. L = len(input_data)
4. for i in range(L - tw):
5. train_seq = input_data[i:i + tw]
6. if (i + tw + 4) > len(input_data):
7. break
8. train_label = input_data[i + tw:i + tw + 1]
9. inout_seq.append((train_seq, train_label))
10. return inout_seq
13. train_window = 350
14. # 定义训练器的的输入
15. train_inout_seq = create_inout_sequences(train_data_normalized, train_window)

模型的本身其中包含一个LSTM层和一个全连接层进行结果的输出 

1. class LSTM(nn.Module):
2. def __init__(self, input_dim=1, hidden_dim=350, output_dim=1):
3. super(LSTM, self).__init__()
5. self.hidden_dim = hidden_dim
6. self.lstm = nn.LSTM(input_dim, hidden_dim, batch_first=True)
7. self.fc = nn.Linear(hidden_dim, output_dim)
9. def forward(self, x):
10. x = x.unsqueeze(1)
12. h0_lstm = torch.zeros(1, self.hidden_dim).to(x.device)
13. c0_lstm = torch.zeros(1, self.hidden_dim).to(x.device)
15. out, _ = self.lstm(x, (h0_lstm, c0_lstm))
16. out = out[:, -1]
17. out = self.fc(out)
19. return out

这里定义了模型损失函数和优化器,其中的Train代表着是否进行训练。 

1. lstm_model = LSTM()
2. loss_function = nn.MSELoss()
3. optimizer = torch.optim.Adam(lstm_model.parameters(), lr=0.001)
4. epochs = 20
5. Train = False # 训练还是预测

当Train为True时则开始训练并在最好将模型保存到本地,训练好模型之后我门将Train设置为False则开始评估模式。 

1. if Train:
2. losss = []
3. lstm_model.train() # 训练模式
4. for i in range(epochs):
5. start_time = time.time() # 计算起始时间
6. for seq, labels in train_inout_seq:
8. lstm_model.train()
9. optimizer.zero_grad()
11. y_pred = lstm_model(seq)
13. single_loss = loss_function(y_pred, labels)
14. losss.append(single_loss.detach().numpy())
15. single_loss.backward()
16. optimizer.step()
17. if i % 1 == 1:
18. print(f'epoch: {i:3} loss: {single_loss.item():10.8f}')
19. torch.save(lstm_model.state_dict(), 'save_model.pth')
20. print(f"模型已保存,用时:{(time.time() - start_time) / 60:.4f} min")
21. plt.plot(losss)
22. # 设置图表标题和坐标轴标签
23. plt.title('Training Error')
24. plt.xlabel('Epoch')
25. plt.ylabel('Error')
26. # 保存图表到本地
27. plt.savefig('training_error.png')
28. else:
29. # 加载模型进行预测
30. lstm_model.load_state_dict(torch.load('save_model.pth'))
31. lstm_model.eval() # 评估模式
32. results = []
33. losss = []
34. test_inout_seq = create_inout_sequences(test_data_normalized, train_window)
35. for seq, labels in test_inout_seq:
36. # 这里的pred = lstm_model(seq)[0].item()是结果的输出这里只保存了输出的第一个值如果想拿出更多的预测值可以修改数字0用切片的方式
37. pred = lstm_model(seq)[0].item()
38. results.append(pred)
39. mae = calculate_mae(pred, labels.detach().numpy()) # MAE误差计算绝对值(预测值 - 真实值)
40. losss.append(mae)
41. print("模型预测结果：", results)
42. print("预测误差MAE:", losss)

后期我也会讲一些最新的预测模型包括Informer，TPA-LSTM,ARIMA,XGBOOST,Holt-winter，移动平均法等等一系列关于时间序列预测的模型,包括深度学习和机器学习方向的模型我都会讲,你可以根据需求选取适合你自己的模型进行预测，如果有需要可以+个关注，包括本次模型我自己的代码大家有需要我也会放出百度网盘下载链接！！

其它时间序列预测模型的讲解！

--------------------------------------------------------MTS-Mixers---------------------------------------------------------

【全网首发】(MTS-Mixers)(Python)(Pytorch)最新由华为发布的时间序列预测模型实战案例(一)(包括代码讲解)实现企业级预测精度包括官方代码BUG修复Transform模型

 --------------------------------------------------------Holt-Winters--------------------------------------------------------

时间序列预测模型实战案例(二)(Holt-Winter)(Python)结合K-折交叉验证进行时间序列预测实现企业级预测精度(包括运行代码以及代码讲解)

如果大家有不懂的也可以评论区留言一些报错什么的大家可以讨论讨论看到我也会给大家解答如何解决！