关于时间序列预测
你可能经常会遇到这样的问题，给你一个数据集，要你预测下一个时刻的值是多少？如下图所示，这种数据往往并没有规律可言，也不可能用一个简单的n阶模型去拟合。老实说，以前我遇到这种问题都是直接上灰色模型，但是用的多了就感觉会有点问题。其它还有一些模型比方说ARAM、ARIRM我没有试过。这篇文章主要讲解用LSTM如何进行时间序列预测
数据
数据直接放在代码里，省去了下载文件并读取的麻烦。这组数据是首都国际机场1949-01~1960-12这12年来的客流量，一共12*12=144个月。我们选取前9年的数据（75%）作为Train Data，后3年的数据（25%）作为Test Data。本来还需要Val Data的，但由于数据量比较少，而且不用搞得那么麻烦，所以就不做Validation了。由于我观察到的客流量变化周期是一年的，因为我为客流数据加上了年、月这两个维度的标记
def load_data():
# passengers number of international airline, 1949-01~1960-12 per month
seq_number = np.array(
[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.], dtype=np.float32)
# plt.plot(seq_number)
# plt.ion()
seq_number = seq_number[:, np.newaxis] # add a new dimension
# 12 years
seq_year = np.arange(12)
# 12 month
seq_month = np.arange(12)
seq_year_month = np.transpose(
[np.repeat(seq_year, len(seq_month)),
np.tile(seq_month, len(seq_year))],
)
seq = np.concatenate((seq_number, seq_year_month), axis=1)
# normalization
seq = (seq - seq.mean(axis=0)) / seq.std(axis=0)
return seq
总的数据维度是(144, 3)，即144个月的[客流量，年份，月份]这3个维度的数据。并且我对数据进行了归一化处理
模型
我们希望输入前9年的数据，让LSTM预测后3年的客流，那么我们可以先用前9年中每个月的数据训练LSTM，让它根据前几个月预测下一个月的客流。等训练完成后，我们让LSTM根据前9年的数据预测出下一个月的客流，把刚刚输出的预测客流作为输入，迭代求得后3年的客流
请注意，通常情况下Tensor的第一个维度是批次大小batch size，但是PyTorch建议我们输入循环神经网络的时候，Tensor的第一个维度是序列长度seq len，第二个维度才是batch size
对于这个客流数据，seq_len指的是时间序列的长度，这里前9年，共108个月，则seq_len=108。input_dim指的是输入的维度，这里输入数据由三个维度构成，则input_dim=3
接下来我们就可以确定LSTM的结构了
lstm = nn.LSTM(input_dim, mid_dim, mid_layers)
# input_dim 指的是LSTM输入Tensor的维度，根据我们的数据已经确定了这个值是3
# mid_dim 指的是LSTM三个门(gaee)的网络宽度，也是LSTM输出Tensor的维度
# mid_layers 指的是LSTM内部各个gate使用的全连接层的数量，一般设为1或2
x = torch.randn(seq_len, batch_size, input_dim)
output = lstm(x)
assert output.size() == (seq_len, batch_size, mid_dim)
mid_layers一般设置为1或者2：理论上足够宽（神经元个数足够多），并且至少存在一层具有任何一种"挤压"性质的激活函数的2层全连接层就能拟合任何的连续函数
为了进行时间序列预测，我们在LSTM后面街上两层全连接层（1层也行），用于改变最终LSTM输出Tensor的维度。我们只需要预测客流量这一个值，因此out_dim=1
fc = nn.Sequential(
nn.Linear(mid_dim, mid_dim)
nn.ReLU(),
nn.Linear(mid_dim, out_dim),
)
x = output_of_LSTM
seq_len, batch_size, mid_dim = x.shape
x = x.view(-1, mid_dim)
output_of_fc = fc(x)
output_of_fc = output_of_fc.view(seq_len, batch_size, out_dim)
训练
同一批次中序列长度不同，需要使用from torch.nn.utils.rnn import pad_sequence
我们只有一组训练数据，即前9年的客流量。我们可以在同一批次中，训练LSTM预测不同月份的客流量。1~t月的输入对应了t+1月的客流量。由于同一批次里面训练序列长度不统一，直接在末尾补0的操作不优雅，所以我们需要借助torch 自带的工具 pad_sequence的协助，具体如下
var_x = torch.tensor(train_x, dtype=torch.float32, device=device)
var_y = torch.tensor(train_y, dtype=torch.float32, device=device)
batch_var_x = list()
batch_var_y = list()
for i in range(batch_size):
j = train_size - i
batch_var_x.append(var_x[j:])
batch_var_y.append(var_y[j:])
from torch.nn.utils.rnn import pad_sequence
batch_var_x = pad_sequence(batch_var_x)
batch_var_y = pad_sequence(batch_var_y)
放入pad_sequence的序列必须从长到短放置，随着反向传播的进行，PyTorch会逐步忽略完成梯度计算的短序列，具体解释请看PyTorch官网
criterion = nn.MSELoss() # L2_loss
for e in range(epochs):
out = net(batch_var_x)
loss = criterion(out, batch_var_y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
评估
就像前面所说的：使用前9年的数据作为输入，预测得到下一个与的客流，并将此预测结果加到输入序列中，从而逐步预测后3年的客流。就像修路一样，走在刚刚铺好的路面往前推进
最终完整代码
import numpy as np
import torch
from torch import nn
import matplotlib.pyplot as plt
def run_train_lstm():
inp_dim = 3
out_dim = 1
mid_dim = 8
mid_layers = 1
batch_size = 12 * 4
mod_dir = '.'
'''load data'''
data = load_data()
data_x = data[:-1, :] # 0~142
data_y = data[1:, 0] # 1~143
assert data_x.shape[1] == inp_dim
train_size = int(len(data_x) * 0.75)
train_x = data_x[:train_size]
train_y = data_y[:train_size]
train_x = train_x.reshape((train_size, inp_dim))
train_y = train_y.reshape((train_size, out_dim))
'''build model'''
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
net = RegLSTM(inp_dim, out_dim, mid_dim, mid_layers).to(device)
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(net.parameters(), lr=1e-2)
'''train'''
var_x = torch.tensor(train_x, dtype=torch.float32).to(device)
var_y = torch.tensor(train_y, dtype=torch.float32).to(device)
batch_var_x = list()
batch_var_y = list()
for i in range(batch_size):
j = train_size - i
batch_var_x.append(var_x[j:])
batch_var_y.append(var_y[j:])
from torch.nn.utils.rnn import pad_sequence
batch_var_x = pad_sequence(batch_var_x)
batch_var_y = pad_sequence(batch_var_y)
print("Training Start")
for e in range(500):
out = net(batch_var_x)
loss = criterion(out, batch_var_y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if e % 64 == 0:
print('Epoch: {:4}, Loss: {:.5f}'.format(e, loss.item()))
torch.save(net.state_dict(), '{}/net.pth'.format(mod_dir))
print("Save in:", '{}/net.pth'.format(mod_dir))
'''eval'''
net.load_state_dict(torch.load('{}/net.pth'.format(mod_dir), map_location=lambda storage, loc: storage))
net = net.eval()
test_x = data_x.copy()
test_x[train_size:, 0] = 0
test_x = test_x[:, np.newaxis, :]
test_x = torch.tensor(test_x, dtype=torch.float32, device=device)
eval_size = 1
zero_ten = torch.zeros((mid_layers, eval_size, mid_dim), dtype=torch.float32, device=device)
test_y, hc = net.output_y_hc(test_x[:train_size], (zero_ten, zero_ten))
test_x[train_size + 1, 0, 0] = test_y[-1]
for i in range(train_size + 1, len(data) - 2):
test_y, hc = net.output_y_hc(test_x[i:i + 1], hc)
test_x[i + 1, 0, 0] = test_y[-1]
pred_y = test_x[1:, 0, 0]
pred_y = pred_y.cpu().data.numpy()
diff_y = pred_y[train_size:] - data_y[train_size:-1]
l1_loss = np.mean(np.abs(diff_y))
l2_loss = np.mean(diff_y ** 2)
print("L1: {:.3f} L2: {:.3f}".format(l1_loss, l2_loss))
plt.plot(pred_y, 'r', label='pred')
plt.plot(data_y, 'b', label='real', alpha=0.3)
plt.plot([train_size, train_size], [-1, 2], color='k', label='train | pred')
plt.legend(loc='best')
plt.savefig('lstm_reg.png')
class RegLSTM(nn.Module):
def __init__(self, inp_dim, out_dim, mid_dim, mid_layers):
super(RegLSTM, self).__init__()
self.lstm = nn.LSTM(inp_dim, mid_dim, mid_layers) # lstm
self.fc = nn.Sequential(
nn.Linear(mid_dim, mid_dim),
nn.ReLU(),
nn.Linear(mid_dim, out_dim),
)
def forward(self, x):
y = self.lstm(x)[0] # y, (h, c) = self.lstm(x)
seq_len, batch_size, hid_dim = y.shape
y = y.view(-1, hid_dim)
y = self.fc(y)
y = y.view(seq_len, batch_size, -1)
return y
"""
Examples::
>>> rnn = nn.LSTM(10, 20, 2)
>>> input = torch.randn(5, 3, 10)
>>> h0 = torch.randn(2, 3, 20)
>>> c0 = torch.randn(2, 3, 20)
>>> output, (hn, cn) = rnn(input, (h0, c0))
"""
def output_y_hc(self, x, hc):
y, hc = self.lstm(x, hc) # y, (h, c) = self.lstm(x)
seq_len, batch_size, hid_dim = y.shape
y = y.view(-1, hid_dim)
y = self.fc(y)
y = y.view(seq_len, batch_size, -1)
return y, hc
def load_data():
# passengers number of international airline, 1949-01~1960-12 per month
seq_number = np.array(
[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.], dtype=np.float32)
# plt.plot(seq_number)
# plt.ion()
seq_number = seq_number[:, np.newaxis] # add a new dimension
# 12 years
seq_year = np.arange(12)
# 12 month
seq_month = np.arange(12)
seq_year_month = np.transpose(
[np.repeat(seq_year, len(seq_month)),
np.tile(seq_month, len(seq_year))],
)
seq = np.concatenate((seq_number, seq_year_month), axis=1)
# normalization
seq = (seq - seq.mean(axis=0)) / seq.std(axis=0)
return seq
if __name__ == '__main__':
torch.manual_seed(1)
run_train_lstm()
