【时序预测完整教程】以气温预测为例说明论文组成及PyTorch代码管道构建

---

Intuition

博客之前发布了一些时间序列分类和时间序列相关的教程，但是代码不够规范，比较适合入门。为了更加系统地进行时间序列预测任务的研究，本文介绍了撰写一篇时间序列预测论文应具有的部分，以及Pytorch框架下构建模型进行实验的代码仓库构建。

为了提高灵活性和可复现性，代码遵循开源代码规范，并且尽可能使用通用术语。代码放到一下仓库：https://github.com/datamonday/TimeSeriesMoonlightBox。目前只更新了LSTM，GRU和LSTNet模型，之后会增加更多的模型，也会更新TensorFlow2 Pipeline。如有问题，欢迎指正。时间序列预测交流群：1028633890。

由于这学期的课程都是基于PyTorch的，所以决定从一直使用的TensorFlow转PyTorch。通过简单地对比发现，二者之间的差异主要在管道的构建上。TensorFlow封装得更好，训练更加方便，但是难以扩展。PyTorch的灵活性更好，但对于初学者可能有些无从下手。最近阅读了LSTNet，Informer，Autoformer以及Baidu KDD Cup22 的baseline的论文和代码库，非常推荐阅读他们的论文。通过这三个仓库，基本理清了torch框架下构建时间序列预测管道的流程，解决了之前的一些困惑，故总结在此，希望能给需要的同学提供帮助。这些论文的翻译也在之前的博客分享过了，感兴趣的可以在主页搜索。

本文内容包括：首先介绍撰写一篇时间序列预测论文应该考虑的部分，最后介绍代码仓库的搭建。

--------------------------- Paper Component ---------------------------

1. Abstract

摘要部分。不需要标号。

---

2. Introduction

本文以气温预测为例，说明在torch框架下构建时间序列预测建模的流程。更具体地：

• 模型：LSTM，GRU，LSTNet
• 领域：时间序列预测（气温预测）
• 预测范围：单步预测，多步预测
• 预测变量：单变量预测，多变量预测
• 预测方式：直接预测，递归（滚动）预测
• 预测任务：多变量输入单变量预测，多变量输入多变量预测，单变量输入单变量预测等等

说明：本文研究的问题仅适用于同质数据建模。简单地说，比如一个监测站收集的历年气温数据（一个csv文件或者可以无歧义地合并为一个csv文件）。对于多个监测站的异质数据或者说多个域（domain）的数据，应该考虑用GNN或者其他方式建模，将在后续的文章讨论，本文暂不涉及。

---

3. Time-Series Forecasting

3.1 Forecasting Horizon

对于预测范围（horizon），一般分为单步预测和多步预测。

• 单步预测（single-step forecasting）：例如预测下一时刻的气温。
• 多步预测（multi-step forecasting）：例如预测未来H个时间步（timestamp）的气温。

3.2 Forecasting Variable

对于预测变量，一般分为单变量预测和多变量预测。

• 单变量预测（single-variable forecasting）：即预测一个变量，例如只预测气温。
• 多变量预测（multi-variable forecasting）：即预测多个变量，例如预测气温，风速，风向等。

对于多变量预测的情况，从之前博客的评论区来看，疑问比较多的是如何构建数据的标签。一般有两种处理方式：使用滚动预测方式，模型在训练时的输出维度是 [batch size, feature num] ，在进行预测的时候，使用滚动预测的方式，可以参考LSTNet的源码。第二种方式是将多个变量的多个时间步进行flatten操作，将向量拼接为新的维度 [batch size, feature num * multi steps]，在得到预测结果之后，重新解释为各个变量的多步预测结果。

3.3 Forecasting Method

对于预测方法，一般分为直接预测和递归（滚动）预测。这常常是在多步预测场景下使用。

• 直接预测（direct forecasting）：一次性输出H个时间步的预测值。现在更为常用。
• 滚动预测（rolling forecasting）：递归预测，上一时刻的预测值当做下一时刻的输入，直到预测到第H个输出。这可能造成误差累计。

3.4 Forecasting Task

对于预测任务，可以根据上述三种情景，进行组合，常用的有：

1. 单变量输入-单变量输出-单步-直接预测
2. 单变量输入-单变量输出-多步-直接预测
3. 单变量输入-单变量输出-多步-滚动预测
4. 多变量输入-单变量输出-单步-直接预测
5. 多变量输入-单变量输出-多步-直接预测
6. 多变量输入-单变量输出-多步-滚动预测
7. 多变量输入-多变量输出-单步-直接预测
8. 多变量输入-多变量输出-多步-直接预测
9. 多变量输入-多变量输出-多步-滚动预测

---

4. Forecasting Methodology

本部分概述了目前用于时间序列预测建模的常用模型。

4.1 Statistical Model

常用的统计模型有AR，ARMA，ARIMA等。

4.2 Tree-based Model

常用的树模型有XGBoost，CatBoost，LightGBM等。

4.3 Probability Model

常用概率模型有DeepAR，DeepState，MQ-RNN，Prophet等。

4.4 RNN-based Model

基于RNN的模型有RNN，LSTM，GRU。

4.5 CNN-Based Model

基于CNN的模型有WaveNet。最开始用于语音识别，使用空洞因果卷积增大关注的输入序列长度。

4.6 RNN and CNN-Based Model

基于CNN和RNN的模型有：CNN-LSTM，LSTM-CNN，LSTM-RNN，ConvLSTM，LSTNet等。

4.7 Seq2Seq-Baed Model

基于序列到序列的模型，其组成通常包括Encoder，Decoder及注意力机制。

4.8 Transformer-Based Model

与之前的注意力不同，Transformer引入了多头自注意力（Self-Attention）机制。基于Transformer的模型有：Transformer，LogSparseTransformer，Informer，Autoformer，SpaceTimeformer等。

4.9 BERT-Based Model

原生BERT只使用了Transformer的编码器部分，并且是双向的，用于NLP任务。其贡献主要在于自监督（Self-Supervised）的预训练和微调（Pretrain and Fine-Tune）的训练方式，提高了模型性能。

4.10 GNN-Based Model

对于空间上有关联性的预测问题，常常使用图神经网络（Graphic Neural Network）建模。根据输入数据的不同，可以分为同质（homogeneous）图和异质（heterogeneous）图。

4.11 Transfer Learning Model

基于迁移学习的模型常常用于多个域的数据建模。例如不同气象数据监测站。常用的方法是域适应（Domain Adaptation）和域泛化（Domain Generalization），这也是目前比较火热的研究方向。

4.12 Multimodal-Based Model

基于多模态数据的模型不仅仅使用表格数据，还通常结合图片、音频等数据，模型中分别使用不同的网络提取特征，然后进行特征融合，最后将提取得到特征输入到下游预测网络以进行预测。

---

5. Evaluation Metrics

本部分介绍时间序列预测任务中常用的评估指标。

5.1 MAE

5.2 MSE

5.3 MAPE

5.4 RMSE

5.5 RMSLE

此外，还有一些针对具体任务的评估指标，此处不再介绍。

---

6. Data Preprocessing

本部分介绍数据预处理方法。

6.1 Data Cleaning

为提高模型鲁棒性，一般先要处理数据中的异常值和填充缺失值。

6.2 Feature Selection

为了降低特征共线性，降低过拟合风险，通常先选择模型输入特征。关于特征选择方法的原理和代码，在之前的博文已经介绍过了，感兴趣的可以下主页搜索特征选择方法。

6.4 Standardize and Normalize

关于数据标准化和归一化需要注意的是只能使用训练集计算均值、方差或者最大值、最小值，然后将其应用到验证集和测试集上，以防止数据泄露。

6.5 Sliding Window

滑动窗口是常用的时间序列预测样本构建方法的原理和代码，在之前的博客也已经介绍过了，感兴趣的可以主页搜索滑动窗口。

---

7. Experiments

实验部分一般需要给出训练配置，数据介绍以及对预测任务及结果给出合理的分析。

---

8. Ablation Study

消融研究一般用于探索模型的鲁棒性，更充分地证明模型的优异性能。常有的包括，多个数据集对比，预测步长的影长，序列长度的影响，模型超参数的影响，网络架构的影响等等。

---

9. Conclusion

结论部分。

10. Acknowledgement

致谢部分。不需要标号。感谢基金支持、研究者的帮助等。

---

Appendix

实验过程中，重要程度较低、不适合放到正文中的一些实验结果分析或者具体地说明。

---

--------------------------- PyTorch Pipeline ---------------------------

I. 运行环境

• OS：Windows 11
• Python：3.8.0
• PyTorch：1.11.0

具体地，可查看 requirements.txt。

---

II. 数据集

• 名称：Jena Climate Dataset
• 地址：Weather Station, Max Planck Institute for Biogeochemistry in Jena, Germany
• 范围：Jan 10, 2009 - December 31, 2016
• 下载：https://www.bgc-jena.mpg.de/wetter/
• 分辨率：10分钟间隔采样
• 数据量：42万条记录
• 特征数量：14个变量
• 目标变量：'T (degC)'

数据集概览：

---

III. LSTNet

• 模型介绍：LSTNet详解
• 论文翻译：LSTNet：结合 CNN、RNN 以及 AR 的时间序列预测模型
• 开源代码：https://github.com/laiguokun/LSTNet

IV. 代码说明

代码文件结构如下图所示：

文件说明：

• checkpoints/：检查点文件
• dataset/：存放数据集
  • data_cleaning_and_processing.ipynb：数据预处理脚本，包括：填充缺失值，替换异常值
• data_box/：数据处理相关代码
  • data_loader.py：数据标准化，滑动窗口生成样本
• experiments/：训练、测试循环代码，类似于TF的train和predict
  • exp_basic.py：训练基类
  • exp_main.py：训练主类
• models/：模型库
  • ModelGRU.py：GRU模型架构
  • ModelLSTM.py：LSTM模型架构
  • ModelLSTNet.py：LSTNet模型架构
• results/：存放训练结果
• test_results/：存放测试结果
• utils/：通用工具
  • args_parser.py：参数配置
  • metrics.py：模型评估指标定义
  • plot_utils.py：绘图函数
  • train_utils.py：训练工具，包括学习率调整，earlystopping等
• main.py：开始训练和测试
• run_exp.sh：运行不同配置实验的脚本文件

V. 运行流程

模型的运行流程，可以在 exp_main.py 的 Experiment 类窥见一斑。

进一步抽象为：

运行试验：

• 命令行运行：./run_exp.sh
• IDE运行：
  
  运行状态：
  

---

VI. 一些小问题

数据处理部分

data_loader.py 中的 Data2Sample 类继承自PyTorch中的 torch.utils.data.Dataset 类，其有一个 __read_data__ 方法和 __getitem__ 方法。其结合 DataLoader 类可以实现迭代器批次读取操作，降低内存占用。类似TensorFlow中的 Data.Dataset 类。

在 Data2Sample 类的 __getitem__(self, index) 方法中，返回的样本和样本标签的特征数量是一样的，这与常规的Python直接处理方式不同，容易引起困惑，比如在多变量输入单变量输出的预测问题中。其实这样适用范围更广，实际使用的时候，可以对批次数据进行截取，比如只截取一维特征列用于单变量预测问题。在本文代码的实现中，截取操作位于 exp_main.py 中的 Experiment 类的 process_one_batch(self, batch_x, batch_y) 方法中。如以下代码所示：

    def __getitem__(self, index):
        # start and end index of a single sample data_boxes.
        s_begin = index
        s_end = s_begin + self.seq_len

        # start and end index of a single sample label. The label_len param can be set zero.
        r_begin = s_end - self.label_len
        r_end = r_begin + self.label_len + self.pred_len

        # shape: two dim without batch size, [seq_len, n_feats]
        seq_x = self.data_x[s_begin:s_end]
        #  shape: two dim without batch size, [pred_len, n_feats]
        seq_y = self.data_y[r_begin:r_end]
        # print(f'seq_x.shape: {seq_x.shape}, seq_y.shape: {seq_y.shape}.')
		
		return seq_x, seq_y

    def process_one_batch(self, batch_x, batch_y):
        batch_x = batch_x.float().to(self.device)
        batch_y = batch_y.float()
        # model prediction values
        prediction = self.model(batch_x)

        # which dimension(variable) to forecast
        f_dim = -1 if self.args.task == 'MISO' else 0

        batch_y = batch_y[:, -self.args.pred_len:, f_dim:].float().to(self.device)
        prediction = prediction[..., :, f_dim:].float()

        return prediction, batch_y

注意上面代码块中 f_dim 即为截取的目标特征列，在进行数据处理的时候（Data2Sample 类）已经将目标特征列放到最后一列了，所以在单变量预测任务中，只截取最后一列是没有问题的。

---

模型输出

PyTorch的模型输出与TensorFlow不同，往往需要自己调整。模型通常通过类定义，前向传播在 forward 方法中完成。

    def forward(self, input_seq):
        # input shape: (batch_size, seq_len, input_size)
        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(self.device)
        c_0 = torch.randn(self.num_directions * self.num_layers, batch_size, self.hidden_size).to(self.device)
        # h_0 = torch.randn(self.num_directions * self.num_layers, batch_size, self.hidden_size)
        # c_0 = torch.randn(self.num_directions * self.num_layers, batch_size, self.hidden_size)

        # output shape: (batch_size, seq_len, num_directions * hidden_size)
        output, hidden = self.lstm(input_seq, (h_0, c_0))

        # pred shape: (batch_size, seq_len, output_size)
        pred = self.linear(output)
        # out_var=1 表示单变量预测
        pred = pred[:, -self.output_size:, -self.out_var:]  

        return pred

上述代码块中，模型输出的维度是 [batch_size, seq_len, output_size]，经过调整后输出的维度变为：pred[:, -self.output_size:, -self.out_var:] 。其中第二个所以表示截取预测序列长度个输出，第三个所以表示截取变量预测个数。

---

训练循环

在PyTorch中需要自己编写训练循环，这与TensorFlow不同。通常由两层for循环组成，外层处理epoch，内层处理batch。这部分就是触类旁通的，各个任务都是大同小异。

    def train(self, setting):
        train_data, train_loader = self.get_dataset(which_set='train')
        vali_data, vali_loader = self.get_dataset(which_set='val')
        test_data, test_loader = self.get_dataset(which_set='test')

        path = os.path.join(self.args.checkpoints, setting)
        if not os.path.exists(path):
            os.makedirs(path)

        time_now = time.time()

        train_steps = len(train_loader)
        early_stopping = EarlyStopping(patience=self.args.patience, verbose=True)

        model_optim = self.get_optimizer()
        criterion = self.get_criterion()

        for epoch in range(self.args.train_epochs):
            iter_count = 0
            train_loss = []

            self.model.train()
            epoch_time = time.time()

            for i, (batch_x, batch_y) in enumerate(train_loader):
                iter_count += 1
                model_optim.zero_grad()

                batch_pred, batch_truth = self.process_one_batch(batch_x, batch_y)

                loss = criterion(batch_pred, batch_truth)
                train_loss.append(loss.item())
                loss.backward()
                model_optim.step()

            if (i + 1) % 100 == 0:
                print("\titers: {0}, epoch: {1} | loss: {2:.7f}".format(i + 1, epoch + 1, loss.item()))
                speed = (time.time() - time_now) / iter_count
                left_time = speed * ((self.args.train_epochs - epoch) * train_steps - i)
                print('\tspeed: {:.4f}s/iter; left time: {:.4f}s'.format(speed, left_time))
                iter_count = 0
                time_now = time.time()

            print("Epoch: {} cost time: {}".format(epoch + 1, time.time() - epoch_time))
            train_loss = np.average(train_loss)
            vali_loss = self.vali(vali_data, vali_loader, criterion)
            test_loss = self.vali(test_data, test_loader, criterion)

            if self.args.verbose > 0:
                print("Epoch: {0}, Steps: {1} | Train Loss: {2:.7f} Vali Loss: {3:.7f} Test Loss: {4:.7f}".format(
                    epoch + 1, train_steps, train_loss, vali_loss, test_loss))

            early_stopping(vali_loss, self.model, path)
            if early_stopping.early_stop:
                print("Early stopping")
                break

            adjust_learning_rate(model_optim, epoch + 1, self.args)

        best_model_path = path + '/' + 'checkpoint.pth'
        self.model.load_state_dict(torch.load(best_model_path))

结语

具体地可以查看代码仓库，个人认为弄清楚数据处理步骤，模型输出和编写训练循环是入门的第一步。欢迎指出问题和提出意见，看到之后会第一时间解答。