devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

时间序列预测模型实战案例(十)(个人创新模型)通过堆叠CNN、GRU、LSTM实现多元预测和单元预测_gru时间序列预测模型

作者：weixin_40725706 | 2024-02-18 17:13:22

赞

踩

gru时间序列预测模型

本文介绍

本篇博客为大家讲解的是通过组堆叠CNN、GRU、LSTM个数，建立多元预测和单元预测的时间序列预测模型，其效果要比单用GRU、LSTM效果好的多，其结合了CNN的特征提取功能、GRU和LSTM用于处理数据中的时间依赖关系的功能。通过将它们组合在一起，模型可以同时考虑输入数据的空间和时间特征，以更好地进行预测。本篇实战案例中包括->详细的参数讲解、数据集介绍、模型框架原理、训练你个人数据集的教程、以及结果分析。本篇文章的讲解流程为->

​

预测类型->多元预测、单元预测

开源代码->文末有完整代码块复制粘贴即可运行

适用人群->时间序列建模的初学者、时间序列建模的工作者

先上预测效果图~

 

模型框架原理 

首先我们来简单介绍一下本模型所用的框架原理，是为什么能够根据输入来预测出未来的值的，也就是数据的输入到数据的输出在我们的模型内部到底经过了一个什么样的处理这样一个过程的讲解。首先我们要知道三个概念，也就是本文所用到的CNN、GRU、LSTM三个主要处理结构，下面我们来简单的进行分别介绍。

CNN

CNN我相信大家都已经非常了解了这里只是简单介绍一下其在时间序列预测也就是在数据是一维(1-D)时候的作用机制。

CNN：在时间序列预测中，CNN可以用于提取时间序列数据中的局部模式或特征。通过卷积操作，CNN可以捕捉时间序列数据中的局部相关性，并通过激活函数的非线性变换，提取出高层次的特征表示。

可以看到其和2-D、3-D时候的作用是一样的主要做到的是一个特征提取的工作，唯一的区别可能就是我们的输入数据是一维的所以他会沿着时间序列顺序执行，下面我们来看一个图片来理解其工作原理。 

总结->这个图片代表着一个stride分别为1、2、4和卷积核=3的1维度卷积处理结果，可以看到其是顺序执行不想2-D、3-D卷积哪样需要换行的操作。 

GRU

门控循环单元（GRU）是一种循环神经网络（RNN）单元，用于处理序列数据。GRU相对于传统的RNN单元具有改进的结构，旨在更好地处理长期依赖关系和消除梯度消失问题。

GRU的结构由以下几个关键单元组成：

  1. 更新门（Update Gate）：更新门控制着前一时刻的隐藏状态（或记忆）保留多少信息传递到当前时刻的隐藏状态中。它通过观察当前输入和前一时刻的隐藏状态，决定更新的程度。更新门具有一个范围从0到1的值，其中0表示完全忘记先前的隐藏状态，1表示完全保留先前的隐藏状态。

  2. 重置门（Reset Gate）：重置门决定如何使用前一时刻的隐藏状态来刷新当前时刻的隐藏状态。它通过控制前一时刻的隐藏状态在当前时刻的作用程度来帮助模型忘记不重要的信息。通过观察当前输入和前一时刻的隐藏状态，重置门输出一个范围从0到1的值，用于调整隐藏状态的刷新程度。

  3. 候选隐藏状态：候选隐藏状态（Candidate Hidden State）是一个候选的更新后的隐藏状态。它是根据当前输入和重置门的输出计算得到的。候选隐藏状态捕捉了当前输入和过去隐藏状态的相关性，并在一定程度上更新了隐藏状态。

  4. 新的隐藏状态（Updated Hidden State）：新的隐藏状态由更新门、候选隐藏状态和前一时刻的隐藏状态组合而成。它被用作当前时刻的隐藏状态，并在下一个时刻传递下去。

总结->GRU的关键点是，它通过更新门控制了有关隐藏状态的信息流动，可以决定保留多少过去的信息。而重置门有助于捕捉当前输入和过去隐藏状态之间的相关性，并在一定程度上刷新隐藏状态。这种门控机制允许GRU更好地处理长期依赖关系，并减轻了梯度消失问题，使其能够更有效地处理序列数据。

下面的图片是一个完整的GRU的结构图片。

LSTM 

LSTM在我之前的博客中以及详细的讲过，如果有需要的可以看我之前的博客，这里只做一个间的回顾和概念介绍。

时间序列预测模型实战案例(三)(LSTM)(Python)(深度学习)时间序列预测(包括运行代码以及代码讲解)

LSTM（长短期记忆，Long Short-Term Memory）是一种用于处理序列数据的深度学习模型，属于循环神经网络（RNN）的一种变体,其使用一种类似于搭桥术结构的RNN单元。相对于普通的RNN，LSTM引入了门控机制，能够更有效地处理长期依赖和短期记忆问题，是RNN网络中最常使用的Cell之一，其网络结构如下图。

模型执行流程

上面以及经过了三个主要结构的基本原理和结构，这里主要讲一下在模型中其它的结构如何搭配三个主要的结构(CNN、GRU、LSTM)实现回归问题的解决(时间序列预测就是一个回归问题)

  • 模型的数据输入首先是经过卷积神经网络（CNN）。它从输入数据开始，进行卷积操作，并使用 ReLU 激活函数进行非线性变换。然后对卷积输出进行一个 reshape 操作，将维度重新排列。所有输出被添加到输出列表中，最后使用 `Concat` 操作将它们在维度 2 上连接起来。连接后的结果经过一个 dropout 操作，生成最终的特征输出。
  • 接下来经过GRU层。首先将堆叠的所有循环单元按顺序连接在一起，并在每个循环单元之后添加一个 dropout 操作，将结果进行输出。
  • 再下面是LSTM层。同样将循环单元按顺序连接在一起，并在每个循环单元之后添加 dropout 操作。这一部分与之前的GRU 类似。
  • 接着是自回归（Autoregressive）组件。它对输入数据 `X` 的每个特征维度分别进行全连接操作，将维度减小到 1。
  • 最后定义了预测组件的代码。通过一个全连接层将输入的维度变换为与输入特征向量的维度相同。然后将该输出与自回归组件的输出进行相加，得到最终的模型输出。使用线性回归损失函数计算模型输出与标签的损失。
  • 最终，函数返回损失值，输入数据的名称列表以及标签数据的名称列表。

模型的结构图下->

上述的过程讲述的就是模型中如下的代码流程可以参考着讲解和代码进行阅读。

  1. def sym_gen(train_iter, q, filter_list, num_filter, dropout, rcells, skiprcells, seasonal_period, time_interval):
  2.  
  3.     input_feature_shape = train_iter.provide_data[0][1]
  4.     X = mx.symbol.Variable(train_iter.provide_data[0].name)
  5.     Y = mx.sym.Variable(train_iter.provide_label[0].name)
  6.  
  7.     # reshape data before applying convolutional layer (takes 4D shape incase you ever work with images)
  8.     conv_input = mx.sym.reshape(data=X, shape=(0, 1, q, -1))
  9.  
  10.     ###############
  11.     # CNN Component
  12.     ###############
  13.     outputs = []
  14.     for i, filter_size in enumerate(filter_list):
  15.         # pad input array to ensure number output rows = number input rows after applying kernel
  16.         padi = mx.sym.pad(data=conv_input, mode="constant", constant_value=0,
  17.                           pad_width=(0, 0, 0, 0, filter_size - 1, 0, 0, 0))
  18.         convi = mx.sym.Convolution(data=padi, kernel=(filter_size, input_feature_shape[2]), num_filter=num_filter)
  19.         acti = mx.sym.Activation(data=convi, act_type='relu')
  20.         trans = mx.sym.reshape(mx.sym.transpose(data=acti, axes=(0, 2, 1, 3)), shape=(0, 0, 0))
  21.         outputs.append(trans)
  22.     cnn_features = mx.sym.Concat(*outputs, dim=2)
  23.     cnn_reg_features = mx.sym.Dropout(cnn_features, p=dropout)
  24.  
  25.     ###############
  26.     # GRU Component
  27.     ###############
  28.     stacked_rnn_cells = mx.rnn.SequentialRNNCell()
  29.     for i, recurrent_cell in enumerate(rcells):
  30.         stacked_rnn_cells.add(recurrent_cell)
  31.         stacked_rnn_cells.add(mx.rnn.DropoutCell(dropout))
  32.     outputs, states = stacked_rnn_cells.unroll(length=q, inputs=cnn_reg_features, merge_outputs=False)
  33.     rnn_features = outputs[-1] #only take value from final unrolled cell for use later
  34.  
  35.     ####################
  36.     # LSTM Component
  37.     ####################
  38.     stacked_rnn_cells = mx.rnn.SequentialRNNCell()
  39.     for i, recurrent_cell in enumerate(skiprcells):
  40.         stacked_rnn_cells.add(recurrent_cell)
  41.         stacked_rnn_cells.add(mx.rnn.DropoutCell(dropout))
  42.     outputs, states = stacked_rnn_cells.unroll(length=q, inputs=cnn_reg_features, merge_outputs=False)
  43.  
  44.     # Take output from cells p steps apart
  45.     p = int(seasonal_period / time_interval)
  46.     output_indices = list(range(0, q, p))
  47.     outputs.reverse()
  48.     skip_outputs = [outputs[i] for i in output_indices]
  49.     skip_rnn_features = mx.sym.concat(*skip_outputs, dim=1)
  50.  
  51.     ##########################
  52.     # Autoregressive Component
  53.     ##########################
  54.     auto_list = []
  55.     for i in list(range(input_feature_shape[2])):
  56.         time_series = mx.sym.slice_axis(data=X, axis=2, begin=i, end=i+1)
  57.         fc_ts = mx.sym.FullyConnected(data=time_series, num_hidden=1)
  58.         auto_list.append(fc_ts)
  59.     ar_output = mx.sym.concat(*auto_list, dim=1)
  60.  
  61.     ######################
  62.     # Prediction Component
  63.     ######################
  64.     neural_components = mx.sym.concat(*[rnn_features, skip_rnn_features], dim=1)
  65.     neural_output = mx.sym.FullyConnected(data=neural_components, num_hidden=input_feature_shape[2])
  66.     model_output = neural_output + ar_output
  67.     loss_grad = mx.sym.LinearRegressionOutput(data=model_output, label=Y)
  68.     return loss_grad, [v.name for v in train_iter.provide_data], [v.name for v in train_iter.provide_label]

数据集介绍

上面简单的介绍了模型的原理，下面的部分就是开始正式的实战讲解了，首先介绍的是我本次实战中举例用到的数据集部分截图如下，其主要预测列为OT列代表的含义是油温。

​

参数讲解

下面我来介绍模型的主要参数，如果你想要使用自己的数据集进行预测，那么这个过程需要自信的看其中一些参数的讲解会涉及到如何替换个人数据集的介绍。

首先先列出所有参数后进行讲解，参数如下->

  1. parser = argparse.ArgumentParser(description="CNN-GRU-LSTM for multivariate time series forecasting",
  2.                                  formatter_class=argparse.ArgumentDefaultsHelpFormatter)
  3. parser.add_argument('--data-dir', type=str, default='./', help='relative path to input data')
  4. parser.add_argument('--data_name',type=str, default='ETTh1-Test.csv', help='Input Model File Name')
  5. parser.add_argument('--max-records', type=int, default=None, help='total records before data split')
  6. parser.add_argument('--q', type=int, default=24*7, help='number of historical measurements included in each training example')
  7. parser.add_argument('--horizon', type=int, default=4, help='number of measurements ahead to predict')
  8. parser.add_argument('--splits', type=str, default="0.6,0.2", help='fraction of data to use for train & validation. remainder used for test.')
  9. parser.add_argument('--batch-size', type=int, default=128, help='the batch size.')
  10. parser.add_argument('--filter-list', type=str, default="6,12,18", help='unique filter sizes')
  11. parser.add_argument('--num-filters', type=int, default=100, help='number of each filter size')
  12. parser.add_argument('--recurrent-state-size', type=int, default=100, help='number of hidden units in each unrolled recurrent cell')
  13. parser.add_argument('--seasonal-period', type=int, default=24, help='time between seasonal measurements')
  14. parser.add_argument('--time-interval', type=int, default=1, help='time between each measurement')
  15. parser.add_argument('--gpus', type=str, default='', help='list of gpus to run, e.g. 0 or 0,2,5. empty means using cpu. ')
  16. parser.add_argument('--optimizer', type=str, default='adam', help='the optimizer type')
  17. parser.add_argument('--lr', type=float, default=0.001, help='initial learning rate')
  18. parser.add_argument('--dropout', type=float, default=0.2, help='dropout rate for network')
  19. parser.add_argument('--num-epochs', type=int, default=100, help='max num of epochs')
  20. parser.add_argument('--save-period', type=int, default=20, help='save checkpoint for every n epochs')
  21. parser.add_argument('--model_prefix', type=str, default='electricity_model', help='prefix for saving model params')

上面的就是本模型用到的所有参数，下面来分别进行讲解。

CNN-GRU-LSTM模型参数详解
参数名称参数类型参数讲解
1data-dirstr数据数据集的目录，注意不要到具体的文件要都文件的目录名称！
2data-namestr文件的具体名称。
3max-recordsint数据分割之前的总记录数，可以选择仅使用部分数据进行训练和评估，默认为None表示使用全部数据。
4qint每个训练样本中包含的历史测量值的数量
5horizonint预测的未来测量值的数量，默认为4，这个就是你预测未来多少个点的数据
6splitsstr数据集划分的比例，用于训练、验证和测试集的分割，默认为"0.6,0.2"，表示60%的数据用于训练，20%用于验证，剩余部分用于测试。
7batch-sizeint一次往模型里输入多少个数据
8filter-liststr这个是CNN的卷积核大小，默认为"6,12,18"，表示使用6、12和18的卷积核大小，这个可以根据你数据集的间隔来，如果你觉得你数据集的数据比较平缓可以设置大一点如果比较极端那么设置就小一点，如果你不知道也可以看我末尾推荐的文章里面有详细讲解。
9num-filtersint每个过滤器大小的滤波器数量，默认为100。
10recurrent-state-sizeint每个未滚动展开循环单元中隐藏单位的数量，默认为100。
11seasonal-periodint季节性测量之间的时间间隔，默认为24，表示每24小时进行一次季节性测量。这个数据也很重要就是你数据具有的季节性。这个参数不同的数据集都不一样，如果你想知道如何测量你数据中的季节性、周期性等因素可以看我的其它博客文章的末尾会分享里面有详细的讲解。
12time-intervalint每个测量之间的时间间隔，默认为1。
13gpusstr要使用的GPU列表，例如"0"或"0,2,5"，为空表示使用CPU。
14optimizerstr优化器的类型，默认为"adam"。
15lrfloat初始学习率，默认为0.001。
16dropoutfloat网络的dropout率，默认为0.2。
17num-epochsint最大的训练轮数，默认为100。
18svae-periodint每隔n个训练轮保存一次模型检查点，默认为20。
19model-prefixstr保存模型参数的前缀，默认为"electricity_model"。

模型训练

到此为止模型的准备工作以及全部做好了，经过参数的讲解和数据集的准备，可以开始训练模型了。

环境介绍

在正式开始训练之前介绍一下本模型用到的模块版本如下->

python=3.6

mxnet

numpy

pandas

tqdm

训练代码讲解

我们的程序入口代码汇总如下->

  1. if __name__ == '__main__':
  2.     # parse args
  3.     args = parser.parse_args()
  4.     args.splits = list(map(float, args.splits.split(',')))
  5.     args.filter_list = list(map(int, args.filter_list.split(',')))
  6.  
  7.     # Check valid args
  8.     if not max(args.filter_list) <= args.q:
  9.         raise AssertionError("no filter can be larger than q")
  10.     if not args.q >= math.ceil(args.seasonal_period / args.time_interval):
  11.         raise AssertionError("size of skip connections cannot exceed q")
  12.  
  13.     # Build data iterators
  14.     train_iter, val_iter, test_iter = build_iters(args.data_dir, args.max_records, args.q, args.horizon, args.splits, args.batch_size)
  15.  
  16.     # Choose cells for recurrent layers: each cell will take the output of the previous cell in the list
  17.     rcells = [mx.rnn.GRUCell(num_hidden=args.recurrent_state_size)]
  18.     skiprcells = [mx.rnn.LSTMCell(num_hidden=args.recurrent_state_size)]
  19.  
  20.     # Define network symbol
  21.     symbol, data_names, label_names = sym_gen(train_iter, args.q, args.filter_list, args.num_filters,
  22.                                               args.dropout, rcells, skiprcells, args.seasonal_period, args.time_interval)
  23.  
  24.  
  25.     Train = True
  26.     # train cnn model
  27.     if Train:
  28.         module = train(symbol, train_iter, val_iter, data_names, label_names)
  29.  
  30.     predict(symbol, train_iter, val_iter, test_iter, data_names, label_names)

下面对其中的代码分别进行讲解！！！

  1.     args = parser.parse_args()
  2.     args.splits = list(map(float, args.splits.split(',')))
  3.     args.filter_list = list(map(int, args.filter_list.split(',')))
  4.  
  5.     # Check valid args
  6.     if not max(args.filter_list) <= args.q:
  7.         raise AssertionError("no filter can be larger than q")
  8.     if not args.q >= math.ceil(args.seasonal_period / args.time_interval):
  9.         raise AssertionError("size of skip connections cannot exceed q")

这一部分就是一些参数的解析部分了，检测参数是否有一些不符合规定的输入，不涉及到代码的流程，没什么好讲的给大家。

  1. # Build data iterators
  2.     train_iter, val_iter, test_iter = build_iters(args.data_dir, args.max_records, args.q, args.horizon, args.splits, args.batch_size)

这是构建训练集、验证集、测试集的数据加载器，需要注意的是时间序列是以滚动的形式构建数据加载器的。

  1.     # Choose cells for recurrent layers: each cell will take the output of the previous cell in the list
  2.     rcells = [mx.rnn.GRUCell(num_hidden=args.recurrent_state_size)]
  3.     skiprcells = [mx.rnn.LSTMCell(num_hidden=args.recurrent_state_size)]

这里是定义GRU和LSTM的地方如果你想要修改其它的RNN单元就可以在这里修改进行其它尝试，毕竟GRU和LSTM以及存在许多年了现在有许多更高效效果更好的RNN单元存在。

  1.     # Define network symbol
  2.     symbol, data_names, label_names = sym_gen(train_iter, args.q, args.filter_list, args.num_filters,
  3.                                               args.dropout, rcells, skiprcells, args.seasonal_period, args.time_interval)

这一步就是构建网络结构了，其中sym_gen是我们定义的方法。

  1.     Train = True
  2.     # train cnn model
  3.     if Train:
  4.         module = train(symbol, train_iter, val_iter, data_names, label_names)
  5.         
  6.     predict(symbol, train_iter, val_iter, test_iter, data_names, label_names)

进行训练和预测，Train=True时进行训练和预测，Train=False时候只进行预测不训练模型。 

训练模型 

下面我们开始正式的训练，运行程序文件，控制台进行输出如下。

训练完成后，模型会自动保存在该目录下->

​

模型预测

我们进行模型的预测主要观察我们想看的特征列"OT"列预测结果如下。

同时会将所有的结果和真实值输出到控制台并生成csv文件。

 保存到同级目录下的输出结果和折线图如下->

​

结果分析

可以说结果还可以接受，这个模型的设计还是算成功的，当然精度还有待提升，后续的话可以更改一些结构，或者添加一些其它的网络层，这里我们再来展示一下其它几列的预测结果。

PS->需要注意的是我的训练数据只用了三百多条能达到这个精度我还是比较满意的。

LULL特征预测结果如下图->

LUFL特征预测结果如下-> 

训练个人数据集所需修改

下面来讲一下训练你个人数据集需要什么修改，其实主要修改的主要是参数部分，大部分的代码Bug我以及修复好了，所以下面来讲一下。

  1. parser.add_argument('--data-dir', type=str, default='./', help='relative path to input data')
  2. parser.add_argument('--data_name',type=str, default='ETTh1-Test.csv', help='Input Model File Name')
  3. parser.add_argument('--q', type=int, default=24*7, help='number of histrical measurements included in each training example')
  4. parser.add_argument('--filter-list', type=str, default="6,12,18", help='unique filter sizes')
  5. parser.add_argument('--seasonal-period', type=int, default=24, help='time between seasonal measurements')
  6. parser.add_argument('--time-interval', type=int, default=1, help='time between each measurement')

这个是模型中需要你修改的参数部分，具体的修改和修改意见我在参数讲解部分以及提到了，大家可以回去参照这修改之后就可以运行该模型训练自己的数据集了。 

项目完整代码分析 

项目的完整代码如下->大家可以进行复制运行即可。 

  1. import argparse
  2. import logging
  3. import math
  4. import os
  5. import matplotlib.pyplot as plt
  6. import mxnet as mx
  7. import numpy as np
  8. import pandas as pd
  9. from tqdm import tqdm
  10.  
  11. # 将matplotlib的日志级别设置为警告级别
  12. mpl_logger = logging.getLogger('matplotlib')
  13. mpl_logger.setLevel(logging.WARNING)
  14. logging.basicConfig(level=logging.DEBUG)
  15.  
  16.  
  17. # 参数设置部分
  18. parser = argparse.ArgumentParser(description="CNN-GRU-LSTM for multivariate time series forecasting",
  19.                                  formatter_class=argparse.ArgumentDefaultsHelpFormatter)
  20. parser.add_argument('--data-dir', type=str, default='./', help='relative path to input data')
  21. parser.add_argument('--data_name', type=str, default='ETTh1-Test.csv', help='Input Model File Name')
  22. parser.add_argument('--max-records', type=int, default=None, help='total records before data split')
  23. parser.add_argument('--q', type=int, default=24 * 7,
  24.                     help='number of histrical measurements included in each training example')
  25. parser.add_argument('--horizon', type=int, default=4, help='number of measurements ahead to predict')
  26. parser.add_argument('--splits', type=str, default="0.6,0.2",
  27.                     help='fraction of data to use for train & validation. remainder used for test.')
  28. parser.add_argument('--batch-size', type=int, default=128, help='the batch size.')
  29. parser.add_argument('--filter-list', type=str, default="6,12,18", help='unique filter sizes')
  30. parser.add_argument('--num-filters', type=int, default=100, help='number of each filter size')
  31. parser.add_argument('--recurrent-state-size', type=int, default=100,
  32.                     help='number of hidden units in each unrolled recurrent cell')
  33. parser.add_argument('--seasonal-period', type=int, default=24, help='time between seasonal measurements')
  34. parser.add_argument('--time-interval', type=int, default=1, help='time between each measurement')
  35. parser.add_argument('--gpus', type=str, default='',
  36.                     help='list of gpus to run, e.g. 0 or 0,2,5. empty means using cpu. ')
  37. parser.add_argument('--optimizer', type=str, default='adam', help='the optimizer type')
  38. parser.add_argument('--lr', type=float, default=0.001, help='initial learning rate')
  39. parser.add_argument('--dropout', type=float, default=0.2, help='dropout rate for network')
  40. parser.add_argument('--num-epochs', type=int, default=100, help='max num of epochs')
  41. parser.add_argument('--save-period', type=int, default=20, help='save checkpoint for every n epochs')
  42. parser.add_argument('--model_prefix', type=str, default='electricity_model', help='prefix for saving model params')
  43.  
  44.  
  45. def rse(label, pred):
  46.     """computes the root relative squared error (condensed using standard deviation formula)"""
  47.     numerator = np.sqrt(np.mean(np.square(label - pred), axis=None))
  48.     denominator = np.std(label, axis=None)
  49.     return numerator / denominator
  50.  
  51.  
  52. def rae(label, pred):
  53.     """computes the relative absolute error (condensed using standard deviation formula)"""
  54.     numerator = np.mean(np.abs(label - pred), axis=None)
  55.     denominator = np.mean(np.abs(label - np.mean(label, axis=None)), axis=None)
  56.     return numerator / denominator
  57.  
  58.  
  59. def corr(label, pred):
  60.     """computes the empirical correlation coefficient"""
  61.     numerator1 = label - np.mean(label, axis=0)
  62.     numerator2 = pred - np.mean(pred, axis=0)
  63.     numerator = np.mean(numerator1 * numerator2, axis=0)
  64.     denominator = np.std(label, axis=0) * np.std(pred, axis=0)
  65.     return np.mean(numerator / denominator)
  66.  
  67.  
  68. def get_custom_metrics():
  69.     """
  70.     :return: mxnet metric object
  71.     """
  72.     _rse = mx.metric.create(rse)
  73.     _rae = mx.metric.create(rae)
  74.     _corr = mx.metric.create(corr)
  75.     return mx.metric.create([_rae, _rse, _corr])
  76.  
  77.  
  78. def evaluate(pred, label):
  79.     return {"RAE": rae(label, pred), "RSE": rse(label, pred), "CORR": corr(label, pred)}
  80.  
  81.  
  82. def build_iters(data_dir, max_records, q, horizon, splits, batch_size):
  83.     """
  84.     Load & generate training examples from multivariate time series data
  85.     :return: data iters & variables required to define network architecture
  86.     """
  87.     # Read in data as numpy array
  88.     df = pd.read_csv(os.path.join(data_dir, "ETTh1-Test.csv"), sep=",", )
  89.     feature_df = df.iloc[:, 1:].fillna(0).astype(float)
  90.     x = feature_df.values
  91.     x = x[:max_records] if max_records else x
  92.  
  93.     # Construct training examples based on horizon and window
  94.     x_ts = np.zeros((x.shape[0] - q, q, x.shape[1]))
  95.     y_ts = np.zeros((x.shape[0] - q, x.shape[1]))
  96.     for n in range(x.shape[0]):
  97.         if n + 1 < q:
  98.             continue
  99.         elif n + 1 + horizon > x.shape[0]:
  100.             continue
  101.         else:
  102.             y_n = x[n + horizon, :]
  103.             x_n = x[n + 1 - q:n + 1, :]
  104.         x_ts[n - q] = x_n
  105.         y_ts[n - q] = y_n
  106.  
  107.     # Split into training and testing data
  108.     training_examples = int(x_ts.shape[0] * splits[0])
  109.     valid_examples = int(x_ts.shape[0] * splits[1])
  110.     x_train, y_train = x_ts[:training_examples], \
  111.         y_ts[:training_examples]
  112.     x_valid, y_valid = x_ts[training_examples:training_examples + valid_examples], \
  113.         y_ts[training_examples:training_examples + valid_examples]
  114.     x_test, y_test = x_ts[training_examples + valid_examples:], \
  115.         y_ts[training_examples + valid_examples:]
  116.  
  117.     # build iterators to feed batches to network
  118.     train_iter = mx.io.NDArrayIter(data=x_train,
  119.                                    label=y_train,
  120.                                    batch_size=batch_size)
  121.     val_iter = mx.io.NDArrayIter(data=x_valid,
  122.                                  label=y_valid,
  123.                                  batch_size=batch_size)
  124.     test_iter = mx.io.NDArrayIter(data=x_test,
  125.                                   label=y_test,
  126.                                   batch_size=batch_size)
  127.     return train_iter, val_iter, test_iter
  128.  
  129.  
  130. def sym_gen(train_iter, q, filter_list, num_filter, dropout, rcells, skiprcells, seasonal_period, time_interval):
  131.     input_feature_shape = train_iter.provide_data[0][1]
  132.     X = mx.symbol.Variable(train_iter.provide_data[0].name)
  133.     Y = mx.sym.Variable(train_iter.provide_label[0].name)
  134.  
  135.     # reshape data before applying convolutional layer (takes 4D shape incase you ever work with images)
  136.     conv_input = mx.sym.reshape(data=X, shape=(0, 1, q, -1))
  137.  
  138.     ###############
  139.     # CNN Component
  140.     ###############
  141.     outputs = []
  142.     for i, filter_size in enumerate(filter_list):
  143.         # pad input array to ensure number output rows = number input rows after applying kernel
  144.         padi = mx.sym.pad(data=conv_input, mode="constant", constant_value=0,
  145.                           pad_width=(0, 0, 0, 0, filter_size - 1, 0, 0, 0))
  146.         convi = mx.sym.Convolution(data=padi, kernel=(filter_size, input_feature_shape[2]), num_filter=num_filter)
  147.         acti = mx.sym.Activation(data=convi, act_type='relu')
  148.         trans = mx.sym.reshape(mx.sym.transpose(data=acti, axes=(0, 2, 1, 3)), shape=(0, 0, 0))
  149.         outputs.append(trans)
  150.     cnn_features = mx.sym.Concat(*outputs, dim=2)
  151.     cnn_reg_features = mx.sym.Dropout(cnn_features, p=dropout)
  152.  
  153.     ###############
  154.     # GRU Component
  155.     ###############
  156.     stacked_rnn_cells = mx.rnn.SequentialRNNCell()
  157.     for i, recurrent_cell in enumerate(rcells):
  158.         stacked_rnn_cells.add(recurrent_cell)
  159.         stacked_rnn_cells.add(mx.rnn.DropoutCell(dropout))
  160.     outputs, states = stacked_rnn_cells.unroll(length=q, inputs=cnn_reg_features, merge_outputs=False)
  161.     rnn_features = outputs[-1]  # only take value from final unrolled cell for use later
  162.  
  163.     ####################
  164.     # LSTM Component
  165.     ####################
  166.     stacked_rnn_cells = mx.rnn.SequentialRNNCell()
  167.     for i, recurrent_cell in enumerate(skiprcells):
  168.         stacked_rnn_cells.add(recurrent_cell)
  169.         stacked_rnn_cells.add(mx.rnn.DropoutCell(dropout))
  170.     outputs, states = stacked_rnn_cells.unroll(length=q, inputs=cnn_reg_features, merge_outputs=False)
  171.  
  172.     # Take output from cells p steps apart
  173.     p = int(seasonal_period / time_interval)
  174.     output_indices = list(range(0, q, p))
  175.     outputs.reverse()
  176.     skip_outputs = [outputs[i] for i in output_indices]
  177.     skip_rnn_features = mx.sym.concat(*skip_outputs, dim=1)
  178.  
  179.     ##########################
  180.     # Autoregressive Component
  181.     ##########################
  182.     auto_list = []
  183.     for i in list(range(input_feature_shape[2])):
  184.         time_series = mx.sym.slice_axis(data=X, axis=2, begin=i, end=i + 1)
  185.         fc_ts = mx.sym.FullyConnected(data=time_series, num_hidden=1)
  186.         auto_list.append(fc_ts)
  187.     ar_output = mx.sym.concat(*auto_list, dim=1)
  188.  
  189.     ######################
  190.     # Prediction Component
  191.     ######################
  192.     neural_components = mx.sym.concat(*[rnn_features, skip_rnn_features], dim=1)
  193.     neural_output = mx.sym.FullyConnected(data=neural_components, num_hidden=input_feature_shape[2])
  194.     model_output = neural_output + ar_output
  195.     loss_grad = mx.sym.LinearRegressionOutput(data=model_output, label=Y)
  196.     return loss_grad, [v.name for v in train_iter.provide_data], [v.name for v in train_iter.provide_label]
  197.  
  198.  
  199. def train(symbol, train_iter, val_iter, data_names, label_names):
  200.     devs = mx.cpu() if args.gpus is None or args.gpus is '' else [mx.gpu(int(i)) for i in args.gpus.split(',')]
  201.     module = mx.mod.Module(symbol, data_names=data_names, label_names=label_names, context=devs)
  202.     module.bind(data_shapes=train_iter.provide_data, label_shapes=train_iter.provide_label)
  203.     module.init_params(mx.initializer.Uniform(0.1))
  204.     module.init_optimizer(optimizer=args.optimizer, optimizer_params={'learning_rate': args.lr})
  205.  
  206.     for epoch in tqdm(range(1, args.num_epochs + 1), desc="Epochs"):
  207.         train_iter.reset()
  208.         val_iter.reset()
  209.         for batch in tqdm(train_iter, desc="Batches", leave=False):
  210.             module.forward(batch, is_train=True)  # compute predictions
  211.             module.backward()  # compute gradients
  212.             module.update()  # update parameters
  213.  
  214.         train_pred = module.predict(train_iter).asnumpy()
  215.         train_label = train_iter.label[0][1].asnumpy()
  216.         print('\nMetrics: Epoch %d, Training %s' % (epoch, evaluate(train_pred, train_label)))
  217.  
  218.         val_pred = module.predict(val_iter).asnumpy()
  219.         val_label = val_iter.label[0][1].asnumpy()
  220.         print('Metrics: Epoch %d, Validation %s' % (epoch, evaluate(val_pred, val_label)))
  221.  
  222.         if epoch % args.save_period == 0 and epoch > 1:
  223.             module.save_checkpoint(prefix=os.path.join("../models/", args.model_prefix), epoch=epoch,
  224.                                    save_optimizer_states=False)
  225.         if epoch == args.num_epochs:
  226.             module.save_checkpoint(prefix=os.path.join("../models/", args.model_prefix), epoch=epoch,
  227.                                    save_optimizer_states=False)
  228.  
  229.     return module
  230.  
  231.  
  232. def predict(symbol, train_iter, val_iter, test_iter, data_names, label_names):
  233.     devs = mx.cpu() if args.gpus is None or args.gpus is '' else [mx.gpu(int(i)) for i in args.gpus.split(',')]
  234.     module = mx.mod.Module(symbol, data_names=data_names, label_names=label_names, context=devs)
  235.     module.bind(data_shapes=train_iter.provide_data, label_shapes=train_iter.provide_label)
  236.     module.init_params(mx.initializer.Uniform(0.1))
  237.     module.init_optimizer(optimizer=args.optimizer, optimizer_params={'learning_rate': args.lr})
  238.  
  239.     # 加载模型参数
  240.     params_file = "../models/electricity_model-0100.params"  # 参数文件的路径
  241.     module.load_params(params_file)
  242.  
  243.     # 将模型转换为评估模式
  244.     test_iter.reset()
  245.     test_pred = module.predict(test_iter).asnumpy()
  246.     test_label = test_iter.label[0][1].asnumpy()
  247.     pre_results = []
  248.     real_results = []
  249.     for i in range(len(test_pred)):
  250.         # 这里你想看那个列的图形就画出那个列的即可
  251.         pre_results.append(test_pred[i][4])
  252.         real_results.append(test_label[i][4])
  253.     print("预测值：", pre_results)
  254.     print("真实值：", real_results)
  255.     df = pd.DataFrame({'real': real_results, 'forecast': pre_results})
  256.  
  257.     df.to_csv('results.csv', index=False)
  258.     # 创建一个新的图形
  259.     plt.figure(figsize=(10, 6))
  260.  
  261.     # 绘制预测值曲线，使用蓝色实线
  262.     plt.plot(pre_results, color='blue', linestyle='-', linewidth=2, label='Predicted')
  263.  
  264.     # 绘制真实值曲线，使用红色虚线
  265.     plt.plot(real_results, color='red', linestyle='--', linewidth=2, label='True')
  266.  
  267.     # 添加标题和轴标签
  268.     plt.title('Predicted vs True Values', fontsize=16)
  269.     plt.xlabel('Time', fontsize=12)
  270.     plt.ylabel('Value', fontsize=12)
  271.  
  272.     # 添加图例
  273.     plt.legend(loc='upper left')
  274.  
  275.     # 显示网格线
  276.     plt.grid(True, linestyle='--', alpha=0.5)
  277.  
  278.     # 保存图形
  279.     plt.savefig('line_plot.png')
  280.  
  281.     # 显示图形
  282.     plt.show()
  283.     print(test_label, test_pred)
  284.  
  285.  
  286. if __name__ == '__main__':
  287.     # parse args
  288.     args = parser.parse_args()
  289.     args.splits = list(map(float, args.splits.split(',')))
  290.     args.filter_list = list(map(int, args.filter_list.split(',')))
  291.  
  292.     # Check valid args
  293.     if not max(args.filter_list) <= args.q:
  294.         raise AssertionError("no filter can be larger than q")
  295.     if not args.q >= math.ceil(args.seasonal_period / args.time_interval):
  296.         raise AssertionError("size of skip connections cannot exceed q")
  297.  
  298.     # Build data iterators
  299.     train_iter, val_iter, test_iter = build_iters(args.data_dir, args.max_records, args.q, args.horizon, args.splits,
  300.                                                   args.batch_size)
  301.  
  302.     # Choose cells for recurrent layers: each cell will take the output of the previous cell in the list
  303.     rcells = [mx.rnn.GRUCell(num_hidden=args.recurrent_state_size)]
  304.     skiprcells = [mx.rnn.LSTMCell(num_hidden=args.recurrent_state_size)]
  305.  
  306.     # Define network symbol
  307.     symbol, data_names, label_names = sym_gen(train_iter, args.q, args.filter_list, args.num_filters,
  308.                                               args.dropout, rcells, skiprcells, args.seasonal_period,
  309.                                               args.time_interval)
  310.  
  311.     Train = True
  312.     # train cnn model
  313.     if Train:
  314.         module = train(symbol, train_iter, val_iter, data_names, label_names)
  315.  
  316.     predict(symbol, train_iter, val_iter, test_iter, data_names, label_names)

项目的目录结构如下-> 

​

全文总结

到此本文已经全部讲解完成了，希望能够帮助到大家，在这里也给大家推荐一些我其它的博客的时间序列实战案例讲解，其中有数据分析的讲解就是我前面提到的如何设置参数的分析博客，最后希望大家订阅我的专栏，本专栏均分文章均分98。

时间序列预测中的数据分析-＞周期性、相关性、滞后性、趋势性、离群值等特性的分析方法

时间序列预测模型实战案例(八)(Informer)个人数据集、详细参数、代码实战讲解

时间序列预测模型实战案例(七)(TPA-LSTM)结合TPA注意力机制的LSTM实现多元预测

时间序列预测模型实战案例(六)深入理解机器学习ARIMA包括差分和相关性分析

时间序列预测模型实战案例(五)基于双向LSTM横向搭配单向LSTM进行回归问题解决

时间序列预测模型实战案例(四)(Xgboost)(Python)(机器学习)图解机制原理实现时间序列预测和分类(附一键运行代码资源下载和代码讲解)

时间序列预测模型实战案例(三)(LSTM)(Python)(深度学习)时间序列预测(包括运行代码以及代码讲解)

【全网首发】(MTS-Mixers)(Python)(Pytorch)最新由华为发布的时间序列预测模型实战案例(一)(包括代码讲解)实现企业级预测精度包括官方代码BUG修复Transform模型

时间序列预测模型实战案例(二)(Holt-Winter)(Python)结合K-折交叉验证进行时间序列预测实现企业级预测精度(包括运行代码以及代码讲解)

如果大家有不懂的也可以评论区留言一些报错什么的大家可以讨论讨论看到我也会给大家解答如何解决！

最后希望大家工作顺利学业有成！

​

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/109323
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号