基于LSTM网络的时间序列分析

使用循环神经网络中的LSTM网络实现时间序列分析，使用的数据集为国际航班的月客流量，包括1949年到1960年每年12个月的数据。目标时预测国际航班未来1个月的客流量。

数据下载地址：暂时没有

import numpy as np
import pandas as pd
import torch.nn as nn
from torch.autograd import Variable
import torch
import matplotlib.pyplot as plt



data_csv = pd.read_csv(r'D:\Desktop\Code\Pytorch\airplane_data.csv', usecols=[1])
data_csv = data_csv.dropna()   #dataframe
dataset = data_csv.values    #dataframe to numpy array
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 - min_value) / scalar, dataset))


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)

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:]
print(type(train_x))


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)
print(type(train_x))
train_x1 = Variable(train_x)
print(type(train_x1))


class Net(nn.Module):

    def __init__(self, input_size, hidden_size, output_size=1, num_layers=2):
        super(Net, self).__init__()
        #LSTM
        self.RNN1 = nn.LSTM(input_size, hidden_size, num_layers)
        #reg
        self.reg = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        x, _ = self.RNN1(x)
        s, b, h = x.shape
        x = x.view(s*b, h)
        x = self.reg(x)
        x = x.view(s, b, -1)
        return x
    

net = Net(2, 4)
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(net.parameters(), lr=0.01)

net = net.train()
for e in range(1000):
    var_x = Variable(train_x)
    var_y = Variable(train_y)
    # forward
    out = net(var_x)
    loss = criterion(out, var_y)
    # backward
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if(e + 1) % 100 == 0:
        print('Epoch: {}, Loss: {:.5f}'.format(e + 1, loss))

net = net.eval()
data_x = data_x.reshape(-1, 1, 2)
data_x = torch.from_numpy(data_x)
data_x = Variable(data_x)
pred = net(data_x)

pred = pred.view(-1).data.numpy()

plt.plot(pred, 'r', label = 'pred')
plt.plot(dataset, 'b', label = 'real')
plt.legend(loc='best')
plt.show()