PyTorch搭建CNN-LSTM混合模型实现多变量多步长时间序列预测（负荷预测）

目录

I. 前言

关于LSTM的具体原理可以参考：人工智能教程。除了LSTM以外，这个网站还囊括了其他大多机器学习以及深度学习模型的具体讲解，配图生动，简单易懂。

前面已经写了很多关于时间序列预测的文章：

1. 深入理解PyTorch中LSTM的输入和输出（从input输入到Linear输出）
2. PyTorch搭建LSTM实现时间序列预测（负荷预测）
3. PyTorch搭建LSTM实现多变量时间序列预测（负荷预测）
4. PyTorch搭建双向LSTM实现时间序列预测（负荷预测）
5. PyTorch搭建LSTM实现多变量多步长时间序列预测（一）：直接多输出
6. PyTorch搭建LSTM实现多变量多步长时间序列预测（二）：单步滚动预测
7. PyTorch搭建LSTM实现多变量多步长时间序列预测（三）：多模型单步预测
8. PyTorch搭建LSTM实现多变量多步长时间序列预测（四）：多模型滚动预测
9. PyTorch搭建LSTM实现多变量多步长时间序列预测（五）：seq2seq
10. PyTorch中实现LSTM多步长时间序列预测的几种方法总结（负荷预测）
11. PyTorch-LSTM时间序列预测中如何预测真正的未来值
12. PyTorch搭建LSTM实现多变量输入多变量输出时间序列预测（多任务学习）
13. PyTorch搭建ANN实现时间序列预测（风速预测）
14. PyTorch搭建CNN实现时间序列预测（风速预测）
15. PyTorch搭建CNN-LSTM混合模型实现多变量多步长时间序列预测（负荷预测）

上面所有文章一共采用了LSTM、ANN以及CNN三种模型来分别进行时间序列预测。众所周知，CNN提取特征的能力非常强，因此现在不少论文将CNN和LSTM结合起来进行时间序列预测。本文将利用PyTorch来搭建一个简单的CNN-LSTM混合模型实现负荷预测。

II. CNN-LSTM

CNN-LSTM模型搭建如下：

classCNN_LSTM(nn.Module):def__init__(self, args):super(CNN_LSTM, self).__init__()
        self.args = args
        self.relu = nn.ReLU(inplace=True)# (batch_size=30, seq_len=24, input_size=7) ---> permute(0, 2, 1)# (30, 7, 24)
        self.conv = nn.Sequential(
            nn.Conv1d(in_channels=args.in_channels, out_channels=args.out_channels, kernel_size=3),
            nn.ReLU(),
            nn.MaxPool1d(kernel_size=3, stride=1))# (batch_size=30, out_channels=32, seq_len-4=20) ---> permute(0, 2, 1)# (30, 20, 32)
        self.lstm = nn.LSTM(input_size=args.out_channels, hidden_size=args.hidden_size,
                            num_layers=args.num_layers, batch_first=True)
        self.fc = nn.Linear(args.hidden_size, args.output_size)defforward(self, x):
        x = x.permute(0,2,1)
        x = self.conv(x)
        x = x.permute(0,2,1)
        x, _ = self.lstm(x)
        x = self.fc(x)
        x = x[:,-1,:]return x

可以看到，该CNN-LSTM由一层一维卷积+LSTM组成。

通过PyTorch搭建CNN实现时间序列预测（风速预测）我们知道，一维卷积的原始定义如下：

nn.Conv1d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)

本文模型的一维卷积定义：

nn.Conv1d(in_channels=args.in_channels, out_channels=args.out_channels, kernel_size=3)

这里in_channels的概念相当于自然语言处理中的embedding，因此输入通道数为7，表示负荷+其他6个环境变量；out_channels的可以随意设置，本文设置为32；kernel_size设置为3。

PyTorch中一维卷积的输入尺寸为：

input(batch_size, input_size, seq_len)=(30,7,24)

而经过数据处理后得到的数据维度为：

input(batch_size, seq_len, input_size)=(30,24,7)

因此，我们需要进行维度交换：

x = x.permute(0,2,1)

交换后的输入数据将符合CNN的输入。

一维卷积中卷积操作是针对seq_len维度进行的，也就是(30, 7, 24)中的最后一个维度。因此，经过：

nn.Conv1d(in_channels=args.in_channels, out_channels=args.out_channels, kernel_size=3)

后，数据维度将变为：

(30,32,24-3+1)=(30,32,22)

第一维度的batch_size不变，第二维度的input_size将由in_channels=7变成out_channels=32，第三维度进行卷积变成22。

然后经过一个最大池化变成：

(30,32,22-3+1)=(30,32,20)

此时的(30, 32, 20)将作为LSTM的输入。由于在LSTM中我们设置了batch_first=True，因此LSTM能够接收的输入维度为：

input(batch_size, seq_len, input_size)

而经卷积池化后得到的数据维度为：

input(batch_size=30, input_size=32, seq_len=20)

因此，同样需要进行维度交换：

x = x.permute(0,2,1)

然后就是比较常规的LSTM输入输出的，不再细说。

因此，完整的forward函数如下所示：

defforward(self, x):
    x = x.permute(0,2,1)
    x = self.conv(x)
    x = x.permute(0,2,1)
    x, _ = self.lstm(x)
    x = self.fc(x)
    x = x[:,-1,:]return x

III. 代码实现

3.1 数据处理

我们根据前24个时刻的负荷以及该时刻的环境变量来预测接下来4个时刻的负荷，这里采用了直接多输出策略，调整output_size即可调整输出步长。

代码实现：

defnn_seq(args):
    seq_len, B, num = args.seq_len, args.batch_size, args.output_size
    print('data processing...')
    dataset = load_data()# split
    train = dataset[:int(len(dataset)*0.6)]
    val = dataset[int(len(dataset)*0.6):int(len(dataset)*0.8)]
    test = dataset[int(len(dataset)*0.8):len(dataset)]
    m, n = np.max(train[train.columns[1]]), np.min(train[train.columns[1]])defprocess(data, batch_size, step_size):
        load = data[data.columns[1]]
        data = data.values.tolist()
        load =(load - n)/(m - n)
        load = load.tolist()
        seq =[]for i inrange(0,len(data)- seq_len - num, step_size):
            train_seq =[]
            train_label =[]for j inrange(i, i + seq_len):
                x =[load[j]]for c inrange(2,8):
                    x.append(data[j][c])
                train_seq.append(x)for j inrange(i + seq_len, i + seq_len + num):
                train_label.append(load[j])

            train_seq = torch.FloatTensor(train_seq)
            train_label = torch.FloatTensor(train_label).view(-1)
            seq.append((train_seq, train_label))# print(seq[-1])
        seq = MyDataset(seq)
        seq = DataLoader(dataset=seq, batch_size=batch_size, shuffle=False, num_workers=0, drop_last=False)return seq

    Dtr = process(train, B, step_size=1)
    Val = process(val, B, step_size=1)
    Dte = process(test, B, step_size=num)return Dtr, Val, Dte, m, n

3.2 模型训练/测试

和前面一致：

deftrain(args, Dtr, Val, path):
    model = CNN_LSTM(args).to(args.device)
    loss_function = nn.MSELoss().to(args.device)
    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)print('training...')
    epochs =50
    min_epochs =10
    best_model =None
    min_val_loss =5for epoch inrange(epochs):
        train_loss =[]for batch_idx,(seq, target)inenumerate(Dtr,0):
            seq, target = seq.to(args.device), target.to(args.device)
            optimizer.zero_grad()
            y_pred = model(seq)
            loss = loss_function(y_pred, target)
            train_loss.append(loss.item())
            loss.backward()
            optimizer.step()# validation
        val_loss = get_val_loss(args, model, Val)if epoch +1>= min_epochs and val_loss < min_val_loss:
            min_val_loss = val_loss
            best_model = copy.deepcopy(model)print('epoch {:03d} train_loss {:.8f} val_loss {:.8f}'.format(epoch, np.mean(train_loss), val_loss))
        model.train()

    state ={'model': best_model.state_dict(),'optimizer': optimizer.state_dict()}
    torch.save(state, path)deftest(args, Dte, path, m, n):print('loading model...')
    model = CNN_LSTM(args).to(args.device)
    model.load_state_dict(torch.load(path)['model'])
    model.eval()
    pred =[]
    y =[]for batch_idx,(seq, target)inenumerate(Dte,0):
        seq = seq.to(args.device)with torch.no_grad():
            target =list(chain.from_iterable(target.tolist()))
            y.extend(target)
            y_pred = model(seq)
            y_pred =list(chain.from_iterable(y_pred.data.tolist()))
            pred.extend(y_pred)

    y, pred = np.array(y), np.array(pred)

    y =(m - n)* y + n
    pred =(m - n)* pred + n
    print('mape:', get_mape(y, pred))# plot
    x =[i for i inrange(1,151)]
    x_smooth = np.linspace(np.min(x), np.max(x),900)
    y_smooth = make_interp_spline(x, y[150:300])(x_smooth)
    plt.plot(x_smooth, y_smooth, c='green', marker='*', ms=1, alpha=0.75, label='true')

    y_smooth = make_interp_spline(x, pred[150:300])(x_smooth)
    plt.plot(x_smooth, y_smooth, c='red', marker='o', ms=1, alpha=0.75, label='pred')
    plt.grid(axis='y')
    plt.legend()
    plt.show()

3.3 实验结果

前24个时刻预测未来4个时刻，MAPE为7.41%：

IV. 源码及数据

后续考虑公开~