多步预测架构是什么多变量多步预测

转载

网络安全守护神 2023-10-09 05:54:35

文章标签 多步预测架构是什么 tensorflow lstm 时间序列预测负荷预测 文章分类 架构后端开发

II. 单步滚动预测

比如前10个预测后3个：我们首先利用[1…10]预测[11’]，然后利用[2…10 11’]预测[12’]，最后再利用[3…10 11’ 12’]预测[13’]，也就是为了得到多个预测输出，我们直接预测多次，并且在每次预测时将之前的预测值带入。这种方法的缺点是显而易见的：由于每一步的预测都有误差，将有误差的预测值带入进行预测后往往会造成更大的误差，让误差传递。利用这种方式预测到后面通常预测值就完全不变了。

III. 代码实现

3.1 数据处理

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

3.2 模型搭建

模型和之前的文章一致：

class LSTM(keras.Model):
    def __init__(self, args):
        super(LSTM, self).__init__()
        self.lstm = Sequential()
        for i in range(args.num_layers):
            self.lstm.add(layers.LSTM(units=args.hidden_size, input_shape=(args.seq_len, args.input_size),
                                      activation='tanh', return_sequences=True))
        self.fc1 = layers.Dense(64, activation='relu')
        self.fc2 = layers.Dense(args.output_size)

    def call(self, data, training=None, mask=None):
        x = self.lstm(data)
        x = self.fc1(x)
        x = self.fc2(x)

        return x[:, -1:, :]

3.3 模型训练/测试

模型训练代码和之前一致，模型滚动测试代码如下：

def ss_rolling_test(args, Dte, path, M):
    if args.bidirectional:
        model = BiLSTM(args)
    else:
        model = LSTM(args)
    model.load_weights(path)
    pred = []
    y = []
    Dte = [x for x in iter(Dte)]
    Dte = list_of_groups(Dte, args.pred_step_size)
    for sub_item in tqdm(Dte):
        sub_pred = []
        for seq_idx, (seq, label) in enumerate(sub_item, 0):
            label = label.numpy().flatten().tolist()
            y.extend(label)
            if seq_idx != 0:
                seq = seq.cpu().numpy().tolist()[0]
                if len(sub_pred) >= len(seq):
                    for t in range(len(seq)):
                        seq[t][0] = sub_pred[len(sub_pred) - len(seq) + t]
                else:
                    for t in range(len(sub_pred)):
                        seq[len(seq) - len(sub_pred) + t][0] = sub_pred[t]
            else:
                seq = seq.cpu().numpy().tolist()[0]
            seq = [seq]
            seq = tf.data.Dataset.from_tensor_slices(seq)
            seq = seq.batch(1, drop_remainder=False).shuffle(1).prefetch(1)
            seq = [x for x in iter(seq)][0]
            y_pred = model(seq)
            y_pred = y_pred.numpy().flatten().tolist()
            sub_pred.extend(y_pred)

        pred.extend(sub_pred)

    y, pred = np.array(y), np.array(pred)
    m, n = M[0], M[1]
    y = (m - n) * y + n
    pred = (m - n) * pred + n
    mape = get_mape(y, pred)
    plot(y, pred)
    print('mape:', mape)

简单解释一下上述滚动测试的代码：由于我们是前24个时刻预测未来12个时刻，数据的batch_size我们可以设置为1，然后每12个batch的数据放到一组：

Dte = [x for x in iter(Dte)]
Dte = list_of_groups(Dte, args.pred_step_size)

其中list_of_groups：

def list_of_groups(data, sub_len):
    groups = zip(*(iter(data),) * sub_len)
    end_list = [list(i) for i in groups]
    count = len(data) % sub_len
    end_list.append(data[-count:]) if count != 0 else end_list
    return end_list

list_of_groups的作用是将列表data中的数据每seq_len划分为一组，对应到本文中就是每12个batch的数据为一组。

正式预测时分为两种情况：如果预测的是每组（共12个样本）的第一个样本，那么直接预测，并将预测值保存到sub_pred中。如果不是预测第一个样本且之前已经预测了len个样本，那么就将当前样本对应的后len个负荷值替换为sub_pred中的值：

for sub_item in tqdm(Dte):
    sub_pred = []
    for seq_idx, (seq, label) in enumerate(sub_item, 0):
        label = label.numpy().flatten().tolist()
        y.extend(label)
        if seq_idx != 0:
            seq = seq.cpu().numpy().tolist()[0]
            # 如果当前预测长度已经大于seq，直接用sub_pred的后几个将seq中每个数组的第一个数字替换掉
            if len(sub_pred) >= len(seq):
                for t in range(len(seq)):
                    seq[t][0] = sub_pred[len(sub_pred) - len(seq) + t]
            else:
            	# 否则, seq的后几个用sub_pred代替
                for t in range(len(sub_pred)):
                    seq[len(seq) - len(sub_pred) + t][0] = sub_pred[t]
        else:
        	# 直接预测
            seq = seq.cpu().numpy().tolist()[0]