目录

  • I. 前言
  • II. seq2seq
  • III. 代码实现
  • 3.1 数据处理
  • 3.2 模型搭建
  • 3.3 模型训练/测试
  • 3.4 实验结果
  • IV. 源码及数据


I. 前言

系列文章：

  1. 深入理解PyTorch中LSTM的输入和输出（从input输入到Linear输出）
  2. PyTorch搭建LSTM实现时间序列预测（负荷预测）
  3. PyTorch中利用LSTMCell搭建多层LSTM实现时间序列预测
  4. PyTorch搭建LSTM实现多变量时间序列预测（负荷预测）
  5. PyTorch搭建双向LSTM实现时间序列预测（负荷预测）
  6. PyTorch搭建LSTM实现多变量多步长时间序列预测（一）：直接多输出
  7. PyTorch搭建LSTM实现多变量多步长时间序列预测（二）：单步滚动预测
  8. PyTorch搭建LSTM实现多变量多步长时间序列预测（三）：多模型单步预测
  9. PyTorch搭建LSTM实现多变量多步长时间序列预测（四）：多模型滚动预测
  10. PyTorch搭建LSTM实现多变量多步长时间序列预测（五）：seq2seq
  11. PyTorch中实现LSTM多步长时间序列预测的几种方法总结（负荷预测）
  12. PyTorch-LSTM时间序列预测中如何预测真正的未来值
  13. PyTorch搭建LSTM实现多变量输入多变量输出时间序列预测（多任务学习）
  14. PyTorch搭建ANN实现时间序列预测（风速预测）
  15. PyTorch搭建CNN实现时间序列预测（风速预测）
  16. PyTorch搭建CNN-LSTM混合模型实现多变量多步长时间序列预测（负荷预测）
  17. PyTorch搭建Transformer实现多变量多步长时间序列预测（负荷预测）
  18. PyTorch时间序列预测系列文章总结（代码使用方法）
  19. TensorFlow搭建LSTM实现时间序列预测（负荷预测）
  20. TensorFlow搭建LSTM实现多变量时间序列预测（负荷预测）
  21. TensorFlow搭建双向LSTM实现时间序列预测（负荷预测）
  22. TensorFlow搭建LSTM实现多变量多步长时间序列预测（一）：直接多输出
  23. TensorFlow搭建LSTM实现多变量多步长时间序列预测（二）：单步滚动预测
  24. TensorFlow搭建LSTM实现多变量多步长时间序列预测（三）：多模型单步预测
  25. TensorFlow搭建LSTM实现多变量多步长时间序列预测（四）：多模型滚动预测
  26. TensorFlow搭建LSTM实现多变量多步长时间序列预测（五）：seq2seq
  27. TensorFlow搭建LSTM实现多变量输入多变量输出时间序列预测（多任务学习）
  28. TensorFlow搭建ANN实现时间序列预测（风速预测）
  29. TensorFlow搭建CNN实现时间序列预测（风速预测）
  30. TensorFlow搭建CNN-LSTM混合模型实现多变量多步长时间序列预测（负荷预测）
  31. PyG搭建图神经网络实现多变量输入多变量输出时间序列预测
  32. PyTorch搭建GNN-LSTM和LSTM-GNN模型实现多变量输入多变量输出时间序列预测
  33. PyG Temporal搭建STGCN实现多变量输入多变量输出时间序列预测
  34. 时序预测中Attention机制是否真的有效？盘点LSTM/RNN中24种Attention机制+效果对比

II. seq2seq

seq2seq由两部分组成：Encoder和Decoder。seq2seq的输入是一个序列，输出也是一个序列，经常用于时间序列预测。关于seq2seq的具体原理可以参考：DL入门(3)：循环神经网络（RNN）。

III. 代码实现

3.1 数据处理

我们根据前24个时刻的负荷以及该时刻的环境变量来预测接下来12个时刻的负荷（步长pred_step_size可调）。

数据处理代码和前面的直接多输出预测一致。

3.2 模型搭建

模型搭建分为三个步骤：编码器、解码器以及seq2seq。

首先是Encoder：

class Encoder(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, batch_size):
        super().__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.num_directions = 1
        self.batch_size = batch_size
        self.lstm = nn.LSTM(self.input_size, self.hidden_size, self.num_layers, batch_first=True, bidirectional=False)

    def forward(self, input_seq):
        batch_size, seq_len = input_seq.shape[0], input_seq.shape[1]
        h_0 = torch.randn(self.num_directions * self.num_layers, batch_size, self.hidden_size).to(device)
        c_0 = torch.randn(self.num_directions * self.num_layers, batch_size, self.hidden_size).to(device)
        output, (h, c) = self.lstm(input_seq, (h_0, c_0))
        
        return h, c

一般来讲编码器采用的就是RNN网络，这里采用了LSTM将原始数据进行编码，然后将LSTM的最后的隐状态和单元状态返回。

接着是解码器Decoder：

class Decoder(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, output_size, batch_size):
        super().__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.output_size = output_size
        self.num_directions = 1
        self.batch_size = batch_size
        self.lstm = nn.LSTM(input_size, self.hidden_size, self.num_layers, batch_first=True, bidirectional=False)
        self.linear = nn.Linear(self.hidden_size, self.input_size)

    def forward(self, input_seq, h, c):
        # input_seq(batch_size, input_size)
        input_seq = input_seq.unsqueeze(1)
        output, (h, c) = self.lstm(input_seq, (h, c))
        # output(batch_size, seq_len, num * hidden_size)
        pred = self.linear(output.squeeze(1))  # pred(batch_size, 1, output_size)

        return pred, h, c

解码器同样也由LSTM组成，不过解码器的初始的隐状态和单元状态是编码器的输出。此外，解码器每次输入都是上次的输出。

最后定义seq2seq：

class Seq2Seq(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, output_size, batch_size):
        super().__init__()
        self.input_size = input_size
        self.output_size = output_size
        self.Encoder = Encoder(input_size, hidden_size, num_layers, batch_size)
        self.Decoder = Decoder(input_size, hidden_size, num_layers, output_size, batch_size)

    def forward(self, input_seq):
        target_len = self.output_size  # 预测步长
        batch_size, seq_len, _ = input_seq.shape[0], input_seq.shape[1], input_seq.shape[2]
        h, c = self.Encoder(input_seq)
        outputs = torch.zeros(batch_size, self.input_size, self.output_size).to(device)
        decoder_input = input_seq[:, -1, :]
        for t in range(target_len):
            decoder_output, h, c = self.Decoder(decoder_input, h, c)
            outputs[:, :, t] = decoder_output
            decoder_input = decoder_output

        return outputs[:, 0, :]

seq2seq的整体结构如下：

Python lstm 多变量预测 pytorch多变量预测_深度学习


seq2seq中，target_len=output_size，即预测步长。首先，我们利用输入得到图中的编码c(h and c)：

h, c = self.Encoder(input_seq)

接着，解码器的第一个输入为最后一个时间步的输出：

decoder_input = input_seq[:, -1, :]

然后开始循环：

decoder_output, h, c = self.Decoder(decoder_input, h, c)
outputs[:, :, t] = decoder_output
decoder_input = decoder_output

需要注意的是，为了输入输出匹配，这里decoder_output包含了所有变量未来一个步长的预测值，最后我们只需要取第一个也就是负荷的预测值即可：

return outputs[:, 0, :]

3.3 模型训练/测试

模型训练和测试同前文一致。

3.4 实验结果

前24个预测未来12个，每个模型训练50轮，MAPE为9.09%，还需要进一步完善。

IV. 源码及数据

后面将陆续公开~