时序预测方法

发表于 |

TFT时序框架

内容来自Lim, B., Arık, S. Ö., Loeff, N., & Pfister, T. (2021). Temporal fusion transformers for interpretable multi-horizon time series forecasting. International Journal of Forecasting.

过往研究的不足之处

预测方法

多步时序预测可以用下图表示

以风速预测为例，输入分为四部分

Past Targets就是过去的风速真实值

Observed Inputs是过去的观察值，比如温度之类，这一类数据无法提前知晓

Known Inputs是类似月份，季节这种虽然也随着时间变化，但是我们可以提前知晓的

Static Covariates是静态不变的，如风电场的海拔，位置

再以某商店内商品的销量预测为例，在时序预测中，所有的变量都大体划分为两大类：静态和动态，即随着时间改变和不随时间改变

静态变量再细分又可以分为离散和连续，离散的静态变量如商店的位置，所处的城市，商品的大类等

连续的静态变量如去年商品A在双十一的销量等等

动态变量也分为动态时变和动态时不变变量两种，这两种的区别是动态时变变量我们无法提前知晓，而动态时不变变量我们可以很容易推出来

举个例子就明白了——星期几就是一个典型的动态时不变变量，它虽然随时间变化，但是我们很容易推出来

讲完了输入变量和变量的分类，具体的预测方法如下图：

这个图，我先按照https://zhuanlan.zhihu.com/p/461795429是思路去拆解

输入层

大体上是一个双输入的结构，就是静态变量 + 动态特征

静态变量中的离散成分要接embedding再和连续成分concat，之后输入

embedding直译为嵌入，实际上是化离散为连续的过程——可以用一个embedding neural network来做，把离散的值映射到连续的空间中，并且一定程度上保留它们原本的特征

动态特征对离散值的处理也一样，区别在于t时刻(包括)之前的是所有的动态特征，t时刻之后的仅有动态时不变特征

VSN(Variable Selection Network)

之后就是一个varibale selection，顾名思义是变量提取，或者说，特征选择

GLU 门控线性单元

一般形式为输入X，输出：

1
h(X) = (XW + b) * σ(XV + c)

σ是sigmoid函数

如果在训练过程中，某个因素影响微弱，会使得值sigmoid之后趋于0，起到软性的特征选择作用

(原理未知)

GRN

Gate对应的是上面的GLU，ELU是一个激活函数，其函数值如下：

a和c先经过一个线性变换(第一个Dense)，之后经过ELU，再经过一个线性变换+Dropdout后进GLU，得到的结果和初始的a相加，再进行normalization

之所以使用ELU作为激活函数，原因是：

ELU这个激活函数可以取到负值，相比于Relu这让单元激活均值可以更接近0，类似于Batch Normalization的效果但是只需要更低的计算复杂度。同时在输入取较小值时具有软饱和的特性，提升了对噪声的鲁棒性

(这些话我明白意思，但是，我不懂为什么)

a加上去是虚线，原因是为了让维度一致。同时a加上去本身是为了抑制非线性变化的速度。因为有些维度比较低比较简单的模型可能不太需要复杂的非线性变换，所以就相当于把a直接normalization了然后输出

选择

我不太明白这里的特征指的是什么，应该就是输入吧

每个特征都过一下GRN，提取信息，之后再来一个从flattened inputs中得出的权重

我认为这样做的原因是为了让模型能够综合考虑所有特征的信息，而不是只依赖于单个特征的输出。通过拼接所有特征的输出向量，再应用一个GRN，可以让模型学习到一个高层次的特征表示，从而更好地判断每个特征对于输出的贡献。这也可以看作是一种注意力机制，让模型关注更重要的特征，忽略不相关的特征

所谓注意力机制，就是忽略不重要的，学习重要的，基于这种思想，给所有输入一个动态的权重

LSTM

他这里直接调的LSTM模板

Attention

首先讲一下什么是attention机制

attention就是要实现从关注全部到关注重点的一个转换

就像是我们看一张照片，可能不会发现照片的背景上有什么细节，但照片里的人我们会一眼就注意到

基于这个思想，attention机制最早出现在图像识别领域，真正将其发扬光大的则是在NLP领域

attention的三大优势，一是参数少，二是速度快，三是效果好，都是很好理解的——你把一张图片大部分都去掉了，只关注重点部分，可不是参数少了，速度快了。同时你的模型更加“专注”了，从而忽略掉了干扰项，效果也就好了

速度快还有一个原因——attention可以并行计算，这一点因为我对attention内部实现还了解不深，所以仅仅把它放在这

attention用于解决机器翻译问题，常常与Encoder Decoder框架结合使用

机器翻译的attention

单凭词语的替换是解决不了机器翻译问题的，比如早上好翻译成英文是Good morning，而不是morning good

为此，使用了一个Encoder-Decoder机制，将原始文本读入转换到隐藏层，从而获取文字的含义，再将隐藏层输出

但这样做又会存在一个问题：当我们翻译大段大段的文字时，往往会出现隐藏层所能存储的信息不够了，通俗来说，就是模型有点“记不住”了

怎么会记不住了呢？一般隐藏层就是一个长度恒定的向量，既然是恒定的，它所能存储的信息就是有限的。我让它翻译一句话可以，我让它翻译一本书，可不就是记不住了吗

那我把一本书看成一句话，一句一句地翻译不就行了？

我猜测很多模型就是这样做的(因为用的很多翻译软件就是这样，丝毫没有上下文信息)

这不够好，尤其是复杂的文字——可能每句话之间有很强的逻辑联系或者有上下文关系。或者这个词是多义词，在当前语境下的翻译要考虑上下文等

这就需要attention出马了。在现实中我们也是这么做的——如果有人跟我们说话，我们往往只能根据几个关键词就能理解他的意思。如果我们去读书，可能根据几个关键词就能看懂某个章节

上图给出了一种翻译框架，Encoder中的隐藏层是ht，Decoder中的是Ht

可以看到的是，每个Ht以前一时刻隐藏层Ht-1和输出值yt-1为输入

写成式子就是Ht = f(Ht-1, yt-1)

这里，我们再引入一个C值，并且在每个时刻C值不一样，即在t时刻，我们引入Ct

Ht = f(Ht-1, yt-1, Ct)

这个Ct就是上下文向量，把它定义为原文隐藏层ht的加权平均

注意：每个Decoder隐藏层Hk都有一套完全不同的权重αk，这个权重就体现了应该对原文的注意力分配

又叫全局对齐权重

为了说明注意力的演变，举一个将法语句子“L’accord sur l’Espace économique européen a été signé en août 1992.” 翻译成英语句子“The agreement on the European Economic Area was signed in August 1992.”时，每一个输出英文词汇的α构成的对齐矩阵：

于是乎，该如何计算权重αk呢？似乎很复杂，所以我们用一个小的神经网络把它计算出来

αk的目的是想要知道，面对Hk-1时，应该给hk分配多少权重

score有很多种，如：

从Hhc到QKV

上述加性模型和乘法模型我们都好理解，无非就是通过优化参数，得到最好的注意力权重

那么点积模型是什么？连个参数都没有，我们该如何理解呢？

我们再回到最初的Encoder和Decoder，H是做什么用的？H是解码器的隐藏层，相当于根据之前的输出 + 编码器的隐藏层，得到当前的输出

再想想的话，就是说h相当于我要翻译的这句话的全部信息，H只不过起到一个查询的作用，对于不同的Ht-1，我根据h给出Ht，仅此而已

此时H就承担了权重的工作，此时我相当于取消了解码器的隐藏层——原本是用来存放待解码的信息用的

问题是，我需要存放这个信息吗？我有了编码器的隐藏层，我已经知道全部的信息了

所以H就变了，由一个存放信息的层变成了单纯表示权重的层

那再进一步想，我把h看做是包含了全部信息的图书馆，把H当成是一种查询或者寻址，以便于我找到应该输出的答案。那么原先的H就是查询Q，h就是键值K，输出就是答案Value

之前的NLP模型中，Q和V是相同的，都带着要输出的信息，无非一个是隐藏层，一个已经被解码了而已，但self-attention里Q和V是不同的

self-attention

K和V不同的话，我们相当于按照K去分配权重，然后利用这个权重来把V加权平均

score的值我们要同时根据k和q来计算(完全可以直接点乘)

假如我们的问题不再是翻译，而是想知道在一段话中处理某个词时，应该对其它的词分配多大的权重

假设这段文本中的每个词Wi经过词嵌入变成了Xi∈R，用三个矩阵Wk，Wv，Wq分别乘Xi得到三个表征

之后取出查询Q，对每个Ki计算全局对齐权重，最后把v按照该权重求和得到attention值

这里的dk是K向量的大小，将其缩小一定倍数的原因是防止SoftMax函数梯度过小

Transformer

说完了attention，就要谈谈transformer，Transformer类似一个CNN，可以在同一时间计算所有输入单词，并得到这些单词各自的表征向量。重要的是，这一次性的处理中得到的每一个表征向量都是在考虑到整句话语境信息以后的结果！这使得Transformer不再需要像RNN一样按照序列顺序处理信息，一来解决了长期依赖问题，而来也使得训练速度加快

而它正是基于self-attention机制的

其实相当于把一种数据翻译成另一种数据——我觉得应该可以用来做时序预测的特征提取

内部结构如下：

一般情况下包含六个编码器和六个解码器(我糙啊，为啥要六个，一个不够吗)

所谓feed forward(前馈网络)，就是最简单的一个线性层 + 一个激活函数

说实话，怎么加入的attention我不懂

multi-head attention

多头attention，看完之后和我预想的不一样

我以为是对于多个查询分别训练出特定的”头”，实际上仅仅是增加了很多个Wq，Wv和Wk，每个x都乘这些Wq，Wv和Wk，因为有多组，所以会得到多组不同的q，v和k，然后最终结果也不一样，拼接起来线性转换成一个最终结果

我不明白这样的多头有什么好处呢，网上说多头的好处是能够关注的更加全面，捕捉不同的注意力

标准化

其实我感觉不是特别重要

Dense

multi-head attention之后再来个全连接层，其实就是一个前馈网络(FFN)

除此之外呢，还加入了残差连接

Decoder

Decoder的结构如上图

除了和encoder一样的部分外，又加入了Encoder-Decoder Attention层

这是干什么的呢？

Encoder 6会输出A，我们把它乘个矩阵得到K和V，这个矩阵在每一次进入不同的Decoder时都是不一样的

然后呢，Q是上一次Decoder的输出

(这样好像没啥可解释性)

回到文章中

该文章只是使用了一个多头注意力机制，其中的V矩阵是所有头共享的(Wv)

分位数回归

其实就是换了个损失函数

TFT框架的代码

看这是个库，还以为实现起来不会很难，没想到到处都是坑，干脆还是看教程好了

如果教程里面也有坑的话，我也只能无能狂怒，问候他亲娘了

导入包

1
2
3
4
5
6
import os
import warnings

warnings.filterwarnings("ignore")  # avoid printing out absolute paths

os.chdir("../../..")

导入了两个包，这里的warning.filterwarnings我是明白的，因为后面老是报让我ignore的warning，无视掉免得心烦

os.chdir我就不明白了，注释掉

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import copy
from pathlib import Path
import warnings

import lightning.pytorch as pl
from lightning.pytorch.callbacks import EarlyStopping, LearningRateMonitor
from lightning.pytorch.loggers import TensorBoardLogger
import numpy as np
import pandas as pd
import torch

from pytorch_forecasting import Baseline, TemporalFusionTransformer, TimeSeriesDataSet
from pytorch_forecasting.data import GroupNormalizer
from pytorch_forecasting.metrics import MAE, SMAPE, PoissonLoss, QuantileLoss
from pytorch_forecasting.models.temporal_fusion_transformer.tuning import optimize_hyperparameters

依然是导入了一堆库，在后面应该用得上

读入数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
from pytorch_forecasting.data.examples import get_stallion_data

data = get_stallion_data()

# add time index
data["time_idx"] = data["date"].dt.year * 12 + data["date"].dt.month
data["time_idx"] -= data["time_idx"].min()

# add additional features
data["month"] = data.date.dt.month.astype(str).astype("category")  # categories have be strings
data["log_volume"] = np.log(data.volume + 1e-8)
data["avg_volume_by_sku"] = data.groupby(["time_idx", "sku"], observed=True).volume.transform("mean")
data["avg_volume_by_agency"] = data.groupby(["time_idx", "agency"], observed=True).volume.transform("mean")

# we want to encode special days as one variable and thus need to first reverse one-hot encoding
special_days = [
    "easter_day",
    "good_friday",
    "new_year",
    "christmas",
    "labor_day",
    "independence_day",
    "revolution_day_memorial",
    "regional_games",
    "fifa_u_17_world_cup",
    "football_gold_cup",
    "beer_capital",
    "music_fest",
]
data[special_days] = data[special_days].apply(lambda x: x.map({0: "-", 1: x.name})).astype("category")
data.sample(10, random_state=521)

进入loaddata，这个data在pytorch的dataexample里，就很棒，减少了很多下载和格式之类的麻烦

我收回上面的话，因为我运行了一下发现它只是在内部下载而已，但我的代码被great wall挡住了，md

所以我又额外花了半小时的时间去下载数据集

下面是tutorial的翻译

1
2
3
4
5
6
7
首先，我们需要将时间序列转换为pandas数据框架，其中每一行都可以用一个时间步长和一个时间序列来标识。幸运的是，大多数数据集已经是这种格式了

在本教程中，我们将使用来自Kaggle的Stallion数据集来描述各种饮料的销售。我们的任务是通过库存单位(SKU)来预测六个月的销售量，SKU是指由一个代理机构，也就是一个商店销售的产品

大约有21000个月的历史销售记录。除了历史销售，我们有关于销售价格的信息，代理商的位置，特殊的日子，如假期，和销售量在整个行业

数据集的格式已经正确，但是缺少一些重要的特性。最重要的是，我们需要添加一个时间索引，每个时间步加1。此外，添加日期特征是有益的，在这种情况下，这意味着从日期记录中提取月份。

我需要在下载下来的几个文件夹中，找到所谓的饮料销售数据集

然后我发现，这些都是饮料数据集，只不过每个表是一部分，比如我找到了一个calendar文件，明显在说每个月份里有什么节日

我现在的思路是去找读入这些数据集的代码

然后找到了Kaggle大赛的介绍，看了一眼，除了这个大赛里面有很多厉害的人，没什么有价值的信息

只能自己写了，我要给它一个pandas数据框

先看这个数据集里面有什么：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
price_sales_promotion.csv: 
不同的代理商在不同时间销售不同饮料的价格，促销价格，和促销力度(价格-促销价格)

weather.csv
不同代理商在不同时间的温度

event_calendar.csv
每个时间点是否是特殊日子，非时序

historical_volume.csv
每个销售商在不同时间销售不同饮料的销量(显然这是target了)

demographics.csv
每个销售商所在地点的人口统计资料，包含了人口数量和年收入，非时序

industry_volume.csv&industry_soda_sales.csv
总啤酒/汽水销量

另外一个文件夹中的文件是用来提交结果的

看完之后，我们需要读入这些数据，先使用read_csv读入试试

1
2
3
data = pd.read_csv(r'.\train_OwBvO8W\historical_volume.csv')

print(data)

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
          Agency     SKU  YearMonth      Volume
0      Agency_22  SKU_01     201301    52.27200
1      Agency_22  SKU_02     201301   110.70000
2      Agency_58  SKU_23     201301     0.00000
3      Agency_48  SKU_07     201301    28.32000
4      Agency_22  SKU_05     201301   238.53870
...          ...     ...        ...         ...
20995  Agency_60  SKU_05     201709  1776.99525
20996  Agency_60  SKU_23     201709     1.26000
20997  Agency_60  SKU_04     201709  1142.59575
20998  Agency_32  SKU_02     201709  3456.43200
20999  Agency_32  SKU_05     201709  4174.97025

[21000 rows x 4 columns]

之后考虑怎么合并，再读一个price_sales_promotion.csv进来：

1
2
3
4
5
data1 = pd.read_csv(r'.\train_OwBvO8W\historical_volume.csv')
data2 = pd.read_csv(r'.\train_OwBvO8W\price_sales_promotion.csv')

data = pd.merge(data1, data2, on=['Agency', 'SKU', 'YearMonth'], how='outer')
print(data)

pandas.merge这里使用的是一个多行的外连接(并)

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
          Agency     SKU  YearMonth      Volume        Price        Sales  Promotions
0      Agency_22  SKU_01     201301    52.27200  1168.903668  1069.166193   99.737475
1      Agency_22  SKU_02     201301   110.70000  1167.000000  1067.257500   99.742500
2      Agency_58  SKU_23     201301     0.00000     0.000000     0.000000    0.000000
3      Agency_48  SKU_07     201301    28.32000  1143.503390  1143.503390    0.000000
4      Agency_22  SKU_05     201301   238.53870  1310.176057  1203.875711  106.300346
...          ...     ...        ...         ...          ...          ...         ...
20995  Agency_60  SKU_05     201709  1776.99525  1901.705090  1438.932004  462.773086
20996  Agency_60  SKU_23     201709     1.26000  4256.796429  4256.796429    0.000000
20997  Agency_60  SKU_04     201709  1142.59575  2217.266046  1920.172302  297.093744
20998  Agency_32  SKU_02     201709  3456.43200  1662.640914  1370.792395  291.848519
20999  Agency_32  SKU_05     201709  4174.97025  1927.262426  1469.799613  457.462813

[21000 rows x 7 columns]

太好了，快都合并了吧

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
data = pd.merge(
    pd.merge(
        pd.merge(
            pd.merge(
                pd.merge(
                    pd.merge(data1, data2, on=['Agency', 'SKU', 'YearMonth'], how='inner'), 
                    data3, 
                    on=['Agency', 'YearMonth'], 
                    how='inner'
                    ), 
                data4, 
                on=['Agency'],
                how='inner'
            ), 
            data5, 
            on=['YearMonth'], 
            how='inner'
        ),
        data6, 
        on=['YearMonth'], 
        how='inner'
    ),
    data7, 
    on=['YearMonth'], 
    how='inner'
)

人为给加上一个时间索引

1
2
3
data['time_idx'] = data['YearMonth'] // 100 * 12 + data['YearMonth'] % 100
data['time_idx'] -= data['time_idx'].min()
data['month'] = data['YearMonth'] % 100

之后去掉不必要的YearMonth和Promotions

1
data = data.drop(columns=['YearMonth', 'Promotions'])

然后我就想摆烂了，我就拿着我现在的数据集往下走

创建dataset和dataloader

1
下一步是将数据框转换为PyTorch Forecasting TimeSeriesDataSet。除了告诉数据集哪些特征是分类的，哪些是连续的，哪些是静态的，哪些是随时间变化的，我们还必须决定如何规范化数据。在这里，我们分别对每个时间序列进行标准缩放，并表明值总是正的。通常，EncoderNormalizer会在训练过程中对每个编码器序列进行动态缩放，它可以避免由归一化引起的前视偏差。但是，如果您难以找到一个相当稳定的规范化，例如，因为您的数据中有很多零，那么您可能会接受前瞻性偏差。或者你期望在推理中有一个更稳定的规范化。在后一种情况下，您可以确保不会学习到在运行推理时不会出现的“奇怪”跳跃，从而在更真实的数据集上进行训练

接下来的代码，我们一点一点来看

1
2
3
max_prediction_length = 6
max_encoder_length = 24
training_cutoff = data["time_idx"].max() - max_prediction_length

什么是max_prediction_length？其实就是模型能向前预测的最大步数

那max_encoder_length是什么呢？是模型输入的历史数据点的数量

training_cutoff是最大的时间戳减去预测长度，很好理解

1
2
3
training = TimeSeriesDataSet(
    XXXXXXXXXXXXXXXXXXXXXXXX
)

上面的代码构建了一个timeseries，我们还是拆开来看

1
2
3
4
5
6
7
8
data[lambda x: x.time_idx <= training_cutoff],
    time_idx="time_idx",
    target="Volume",
    group_ids=["Agency", "SKU"],
    min_encoder_length=max_encoder_length // 2,  # keep encoder length long (as it is in the validation set)
    max_encoder_length=max_encoder_length,
    min_prediction_length=1,
    max_prediction_length=max_prediction_length,

lambda表达式是很有意思的东西，这里的x.time_idx < training_cutoff指的是所有time_idx在训练范围内的data

后面的含义都比较明显了，列出来主要是要明白时序预测需要指定什么

接着就是划分了，大体分为6类——static还是time_varying，然后categoricals还是reals。最后time_varying中又分为known和unknown

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
static_categoricals=["Agency", "SKU"],
static_reals=["Avg_Population_2017", "Avg_Yearly_Household_Income_2017"],
time_varying_known_categoricals=[],
time_varying_known_reals=[
        "Easter Day", 
        "Good Friday", 
        "New Year", 
        "Christmas", 
        "Labor Day", 
        "Independence Day", 
        "Revolution Day Memorial", 
        "Regional Games ", 
        "FIFA U-17 World Cup", 
        "Football Gold Cup", 
        "Beer Capital",	
        "Music Fest",
        "time_idx", 
        "month", 
        ],
time_varying_unknown_categoricals=[],
time_varying_unknown_reals=["Volume", "Price", "Sales", "Avg_Max_Temp", "Industry_Volume", "Soda_Volume"],

后面这个time_varying_known_categoricals我不太明白，因为既然是special_days这种，是不是得搞个公式来计算啊

后来才回过味来，觉得自己想多了，只需要告诉模型就是了，模型又不是不会读后面的

至于为什么是reals，因为我没做节日的分类

1
2
3
target_normalizer=GroupNormalizer(
        groups=["Agency", "SKU"], transformation="softplus"
    ),  # use softplus and normalize by group

显然是在Agency和SKU组内进行数据的正则化

1
2
3
add_relative_time_idx=True,
    add_target_scales=True,
    add_encoder_length=True,

这三项分别说，将时间跨度，输入尺度和编码长度纳入输入特征，是提高模型性能的，就直接用了

1
2
3
4
5
6
7
8
# create validation set (predict=True) which means to predict the last max_prediction_length points in time
# for each series
validation = TimeSeriesDataSet.from_dataset(training, data, predict=True, stop_randomization=True)

# create dataloaders for model
batch_size = 128  # set this between 32 to 128
train_dataloader = training.to_dataloader(train=True, batch_size=batch_size, num_workers=0)
val_dataloader = validation.to_dataloader(train=False, batch_size=batch_size * 10, num_workers=0)

生成验证集和dataloader，突然觉得这training_cutoff好短，分的有问题啊

不过先这么着吧

创建基准模型

1
2
3
# calculate baseline mean absolute error, i.e. predict next value as the last available value from the history
baseline_predictions = Baseline().predict(val_dataloader, return_y=True)
MAE()(baseline_predictions.output, baseline_predictions.y)

没问题，不愧是tutorial

TFT

终于到了重头戏

1
2
3
4
5
6
7
8
# configure network and trainer
pl.seed_everything(42)
trainer = pl.Trainer(
    accelerator="cpu",
    # clipping gradients is a hyperparameter and important to prevent divergance
    # of the gradient for recurrent neural networks
    gradient_clip_val=0.1,
)

pl.seed_everything(42)是将所有的随机种子设为42，这是为了让结果具有可重复性

gradient_clip_val=0.1则是对梯度进行一番控制，如果梯度的范数超过了0.1，将会把梯度调节到范数为0.1，这是为了防止梯度过大引起模型不收敛等问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
tft = TemporalFusionTransformer.from_dataset(
    training,
    # not meaningful for finding the learning rate but otherwise very important
    learning_rate=0.03,
    hidden_size=8,  # most important hyperparameter apart from learning rate
    # number of attention heads. Set to up to 4 for large datasets
    attention_head_size=1,
    dropout=0.1,  # between 0.1 and 0.3 are good values
    hidden_continuous_size=8,  # set to <= hidden_size
    loss=QuantileLoss(),
    optimizer="Ranger"
    # reduce learning rate if no improvement in validation loss after x epochs
    # reduce_on_plateau_patience=1000,
)
print(f"Number of parameters in network: {tft.size()/1e3:.1f}k")

这里是定义了一个tft模型，打印了它内部的参数数量

1
2
3
4
5
6
Global seed set to 42
GPU available: False, used: False
TPU available: False, using: 0 TPU cores
IPU available: False, using: 0 IPUs
HPU available: False, using: 0 HPUs
Number of parameters in network: 21.5k

之后为了找到最优的学习率

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# find optimal learning rate
from lightning.pytorch.tuner import Tuner

res = Tuner(trainer).lr_find(
    tft,
    train_dataloaders=train_dataloader,
    val_dataloaders=val_dataloader,
    max_lr=10.0,
    min_lr=1e-6,
)

print(f"suggested learning rate: {res.suggestion()}")
fig = res.plot(show=True, suggest=True)
fig.show()

不懂就问，这不是已经在训练了吗

0.17782794100389226是最好的学习率

训练模型

我拿到学习率之后，把上面的代码删了

之后由于有个日志，我需要下载tensorboard和tensorboardX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# configure network and trainer
pl.seed_everything(42)
early_stop_callback = EarlyStopping(monitor="val_loss", min_delta=1e-4, patience=10, verbose=False, mode="min")
lr_logger = LearningRateMonitor()  # log the learning rate
logger = TensorBoardLogger("lightning_logs")  # logging results to a tensorboard

trainer = pl.Trainer(
    max_epochs=50,
    accelerator="cpu",
    enable_model_summary=True,
    gradient_clip_val=0.1,
    limit_train_batches=50,  # coment in for training, running valiation every 30 batches
    # fast_dev_run=True,  # comment in to check that networkor dataset has no serious bugs
    callbacks=[lr_logger, early_stop_callback],
    logger=logger,
)

tft = TemporalFusionTransformer.from_dataset(
    training,
    learning_rate=0.17782794100389226,
    hidden_size=16,
    attention_head_size=2,
    dropout=0.1,
    hidden_continuous_size=8,
    loss=QuantileLoss(),
    log_interval=10,  # uncomment for learning rate finder and otherwise, e.g. to 10 for logging every 10 batches
    optimizer="Ranger",
    reduce_on_plateau_patience=4,
)
print(f"Number of parameters in network: {tft.size()/1e3:.1f}k")

trainer.fit(
    tft,
    train_dataloaders=train_dataloader,
    val_dataloaders=val_dataloader,
)

查看日志的命令

1
tensorboard --logdir=lightning_logs/

风速预测并画图

仿照上面的写了代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
import os
import warnings

warnings.filterwarnings("ignore")  # avoid printing out absolute paths

# os.chdir("../../..")

import copy
from pathlib import Path
import warnings

import datetime as dt
import lightning.pytorch as pl
from lightning.pytorch.callbacks import EarlyStopping, LearningRateMonitor
from lightning.pytorch.loggers import TensorBoardLogger
import numpy as np
import pandas as pd
import torch

from pytorch_forecasting import Baseline, TemporalFusionTransformer, TimeSeriesDataSet
from pytorch_forecasting.data import GroupNormalizer
from pytorch_forecasting.metrics import MAE, SMAPE, PoissonLoss, QuantileLoss
from pytorch_forecasting.models.temporal_fusion_transformer.tuning import optimize_hyperparameters

from pytorch_forecasting.data.examples import get_stallion_data
import matplotlib.pyplot as plt
import pandas as pd 

data = pd.read_excel(r'./data.xlsx')

t = []
for i in data['time']:
    tt = i - dt.datetime.strptime("2020-01-01 00:00:00", "%Y-%m-%d %H:%M:%S")
    tt = int(tt.total_seconds()) // 900
    t.append(tt)
    
data['time_idx'] = t
data['time_idx'] -= data['time_idx'].min()

t_time_idx = []
t_speed = []

for i in range(len(data['time_idx']) - 1):
    cur = data['time_idx'][i]
    nxt = data['time_idx'][i + 1]
    
    if cur + 1 < nxt:
        t_time_idx.append(cur)
        t_speed.append(data['speed'][i])
        l = data['speed'][i]
        r = data['speed'][i + 1]
        for j in range(cur + 1, nxt):
            t_time_idx.append(j)
            t_speed.append((l * (j - cur) + r * (nxt - j)) / (nxt - cur))
    elif cur + 1 > nxt:
        continue
    else:
        t_time_idx.append(cur)
        t_speed.append(data['speed'][i])

t_time_idx.append(data['time_idx'][len(data['time_idx']) - 1])
t_speed.append(data['speed'][len(data['speed']) - 1])

data = pd.DataFrame({"time_idx":t_time_idx, "speed":t_speed, "group":["1" for _ in range(len(t_speed))]})

print("导入数据成功")

max_encoder_length = 24
max_prediction_length = 1
training_cutoff = 366 * 96 - max_prediction_length - 1

training = TimeSeriesDataSet(
    data[lambda x: x.time_idx <= training_cutoff], 
    time_idx="time_idx", 
    target="speed", 
    group_ids=["group"], 
    static_categoricals=['group'], 
    static_reals=[], 
    time_varying_known_categoricals=[], 
    time_varying_known_reals=['time_idx'], 
    time_varying_unknown_categoricals=[], 
    time_varying_unknown_reals=['speed'], 
    min_encoder_length=max_encoder_length // 2, 
    max_encoder_length=max_encoder_length, 
    min_prediction_length=max_prediction_length, 
    max_prediction_length=max_encoder_length, 
    target_normalizer=GroupNormalizer(
        groups=['group'], 
        transformation='softplus', 
    ), 
)

# create validation set (predict=True) which means to predict the last max_prediction_length points in time
# for each series
validation = TimeSeriesDataSet.from_dataset(training, data, predict=True, stop_randomization=True)

# create dataloaders for model
batch_size = 128  # set this between 32 to 128
train_dataloader = training.to_dataloader(train=True, batch_size=batch_size, num_workers=0)
val_dataloader = validation.to_dataloader(train=False, batch_size=batch_size, num_workers=0)

# configure network and trainer
pl.seed_everything(42)
early_stop_callback = EarlyStopping(monitor="val_loss", min_delta=1e-4, patience=10, verbose=False, mode="min")
lr_logger = LearningRateMonitor()  # log the learning rate
logger = TensorBoardLogger("lightning_logs")  # logging results to a tensorboard

# calculate baseline mean absolute error, i.e. predict next value as the last available value from the history
baseline_predictions = Baseline().predict(val_dataloader, return_y=True)
MAE()(baseline_predictions.output, baseline_predictions.y)

trainer = pl.Trainer(
    max_epochs=100,
    accelerator="cpu",
    enable_model_summary=True,
    gradient_clip_val=0.1,
    limit_train_batches=50,  # coment in for training, running valiation every 30 batches
    # fast_dev_run=True,  # comment in to check that networkor dataset has no serious bugs
    callbacks=[lr_logger, early_stop_callback],
    logger=logger,
)

tft = TemporalFusionTransformer.from_dataset(
    training,
    learning_rate=0.17,
    hidden_size=48,
    attention_head_size=6,
    dropout=0.1,
    hidden_continuous_size=36,
    loss=QuantileLoss(),
    log_interval=10,  # uncomment for learning rate finder and otherwise, e.g. to 10 for logging every 10 batches
    optimizer="Ranger",
    reduce_on_plateau_patience=4,
)
print(f"Number of parameters in network: {tft.size()/1e3:.1f}k")

trainer.fit(
    tft,
    train_dataloaders=train_dataloader,
    val_dataloaders=val_dataloader,
)

# load the best model according to the validation loss
# (given that we use early stopping, this is not necessarily the last epoch)
best_model_path = trainer.checkpoint_callback.best_model_path
best_tft = TemporalFusionTransformer.load_from_checkpoint(best_model_path)

# raw predictions are a dictionary from which all kind of information including quantiles can be extracted
raw_predictions = best_tft.predict(val_dataloader, mode="raw", return_x=True)

best_tft.plot_prediction(raw_predictions.x, raw_predictions.output, idx=0, add_loss_to_title=True)

plt.show()

画出长时间的图

存储模型

虽然调好了，但是很遗憾的是，预测的结果看上去并没有那么理想，loss值也一直维持在0.6左右无法进一步下降

mape倒是挺低的，但是我却看不懂

然后我也不知道该怎么用这个模型做预测啊，我根本不知道他这个predict到底输入输出是个啥

输入我还算能理解，这个输出怎么会那么多

为了能够加快效率，免得每次调试一遍还得先训练，我得先学会怎么把模型存起来才行