LSTM长短时神经网络预测航班序列
本文通过LSTM长短时记忆神经网络，来预测航班信息。
航班数据集来自https://github.com/mwaskom/seaborn-data的flights.csv
本文讨论最多的问题：
1、本数据集分割存在数据泄漏。代码取data_X, data_Y = create_dataset(dataset)，根据设定的lookback可以获得数据量为len(dataset)-lookback。然后代码中对data_X和data_Y取70%做训练；确实代码伪装的很好，在于数据集的分割问题；在测试集中，[t1,t2]=>t3中，t1和t2是被泄露的。因为现实情况的t1和t2也需要模型进行预测；所以绘图的效果会很好；
2、关于input_size和seq_len的问题，您说的是对的；本文的特征数为1，即当月的航班预订人数；seq_len为2，是用了2天的数据。即特征数（input_size）为1，seq_len为2。
3、模型预测效果存在一小段的偏移，这是由lookback决定的；这个问题也是时间序列问题的痛点；
库导入
导入pytorch库函数和散点图库
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
导入数据并可视化
将航班数据导入，注意usecols=[1]，选择第2列数据。
data_csv = pd.read_csv('./data.csv',usecols=[1])
plt.plot(data_csv)
数据预处理
数据预处理，将数据中null或者缺项的列删除。对数据集进行归一化处理，首先设置数据集为浮点类型，然后取数据集最大和最小项差值为放缩尺度，对每一个数据集数值进行归一化。
# 数据预处理
data_csv = data_csv.dropna() # 滤除缺失数据
dataset = data_csv.values # 获得csv的值
dataset = dataset.astype('float32')
max_value = np.max(dataset) # 获得最大值
min_value = np.min(dataset) # 获得最小值
scalar = max_value - min_value # 获得间隔数量
dataset = list(map(lambda x: x / scalar, dataset)) # 归一化
设置数据集
设置X,Y数据集。以look_back=2为准，取第一个和第二个为数组，形成data_X,取第三个作为预测值，形成data_Y，完成训练集的提取。
def create_dataset(dataset, look_back=2):
dataX, dataY = [], []
for i in range(len(dataset) - look_back):
a = dataset[i:(i + look_back)]
dataX.append(a)
dataY.append(dataset[i + look_back])
return np.array(dataX), np.array(dataY)
# 创建好输入输出
data_X, data_Y = create_dataset(dataset)
设置训练集和测试集
取数据集的前70%作为训练集，后30%做为测试集。
# 划分训练集和测试集，70% 作为训练集
train_size = int(len(data_X) * 0.7)
test_size = len(data_X) - train_size
train_X = data_X[:train_size]
train_Y = data_Y[:train_size]
test_X = data_X[train_size:]
test_Y = data_Y[train_size:]
设置LSTM模型数据类型形状
设置LSTM能识别的数据类型，形成tran_X的一维两个参数的数组，train_Y的一维一个参数的数组。并转化为tensor类型
import torch
train_X = train_X.reshape(-1, 1, 2)
train_Y = train_Y.reshape(-1, 1, 1)
test_X = test_X.reshape(-1, 1, 2)
train_x = torch.from_numpy(train_X)
train_y = torch.from_numpy(train_Y)
test_x = torch.from_numpy(test_X)
建立LSTM模型
建立LSTM模型，第一层为LSTM神经网络，第二层为一个全连接层。
from torch import nn
from torch.autograd import Variable
class lstm(nn.Module):
def __init__(self,input_size=2,hidden_size=4,output_size=1,num_layer=2):
super(lstm,self).__init__()
self.layer1 = nn.LSTM(input_size,hidden_size,num_layer)
self.layer2 = nn.Linear(hidden_size,output_size)
def forward(self,x):
x,_ = self.layer1(x)
s,b,h = x.size()
x = x.view(s*b,h)
x = self.layer2(x)
x = x.view(s,b,-1)
return x
model = lstm(2, 4,1,2)
建立损失函数和优化器
设置交叉熵损失函数和自适应梯度下降算法
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-2)
模型训练
# 开始训练
for e in range(1000):
var_x = Variable(train_x)
var_y = Variable(train_y)
# 前向传播
out = model(var_x)
loss = criterion(out, var_y)
# 反向传播
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (e + 1) % 100 == 0: # 每 100 次输出结果
print('Epoch: {}, Loss: {:.5f}'.format(e + 1, loss.data[0]))
训练结果
Epoch: 100, Loss: 0.00785
Epoch: 200, Loss: 0.00641
Epoch: 300, Loss: 0.00518
Epoch: 400, Loss: 0.00356
Epoch: 500, Loss: 0.00248
Epoch: 600, Loss: 0.00429
Epoch: 700, Loss: 0.00226
Epoch: 800, Loss: 0.00231
Epoch: 900, Loss: 0.00210
Epoch: 1000, Loss: 0.00213
模型预测
model = model.eval() # 转换成测试模式
data_X = data_X.reshape(-1, 1, 2)
data_X = torch.from_numpy(data_X)
var_data = Variable(data_X)
pred_test = model(var_data) # 测试集的预测结果
# 改变输出的格式
pred_test = pred_test.view(-1).data.numpy()
预测序列可视化
# 画出实际结果和预测的结果
plt.plot(pred_test, 'r', label='prediction')
plt.plot(dataset, 'b', label='real')
plt.legend(loc='best')
