I. 前言

前面已經(jīng)寫了很多關(guān)于時間序列預(yù)測的文章：

1. 深入理解PyTorch中LSTM的輸入和輸出（從input輸入到Linear輸出）
2. PyTorch搭建LSTM實現(xiàn)時間序列預(yù)測（負(fù)荷預(yù)測）
3. PyTorch中利用LSTMCell搭建多層LSTM實現(xiàn)時間序列預(yù)測
4. PyTorch搭建LSTM實現(xiàn)多變量時間序列預(yù)測（負(fù)荷預(yù)測）
5. PyTorch搭建雙向LSTM實現(xiàn)時間序列預(yù)測（負(fù)荷預(yù)測）
6. PyTorch搭建LSTM實現(xiàn)多變量多步長時間序列預(yù)測（一）：直接多輸出
7. PyTorch搭建LSTM實現(xiàn)多變量多步長時間序列預(yù)測（二）：單步滾動預(yù)測
8. PyTorch搭建LSTM實現(xiàn)多變量多步長時間序列預(yù)測（三）：多模型單步預(yù)測
9. PyTorch搭建LSTM實現(xiàn)多變量多步長時間序列預(yù)測（四）：多模型滾動預(yù)測
10. PyTorch搭建LSTM實現(xiàn)多變量多步長時間序列預(yù)測（五）：seq2seq
11. PyTorch中實現(xiàn)LSTM多步長時間序列預(yù)測的幾種方法總結(jié)（負(fù)荷預(yù)測）
12. PyTorch-LSTM時間序列預(yù)測中如何預(yù)測真正的未來值
13. PyTorch搭建LSTM實現(xiàn)多變量輸入多變量輸出時間序列預(yù)測（多任務(wù)學(xué)習(xí)）
14. PyTorch搭建ANN實現(xiàn)時間序列預(yù)測（風(fēng)速預(yù)測）
15. PyTorch搭建CNN實現(xiàn)時間序列預(yù)測（風(fēng)速預(yù)測）
16. PyTorch搭建CNN-LSTM混合模型實現(xiàn)多變量多步長時間序列預(yù)測（負(fù)荷預(yù)測）
17. PyTorch搭建Transformer實現(xiàn)多變量多步長時間序列預(yù)測（負(fù)荷預(yù)測）
18. PyTorch時間序列預(yù)測系列文章總結(jié)（代碼使用方法）
19. TensorFlow搭建LSTM實現(xiàn)時間序列預(yù)測（負(fù)荷預(yù)測）
20. TensorFlow搭建LSTM實現(xiàn)多變量時間序列預(yù)測（負(fù)荷預(yù)測）
21. TensorFlow搭建雙向LSTM實現(xiàn)時間序列預(yù)測（負(fù)荷預(yù)測）
22. TensorFlow搭建LSTM實現(xiàn)多變量多步長時間序列預(yù)測（一）：直接多輸出
23. TensorFlow搭建LSTM實現(xiàn)多變量多步長時間序列預(yù)測（二）：單步滾動預(yù)測
24. TensorFlow搭建LSTM實現(xiàn)多變量多步長時間序列預(yù)測（三）：多模型單步預(yù)測
25. TensorFlow搭建LSTM實現(xiàn)多變量多步長時間序列預(yù)測（四）：多模型滾動預(yù)測
26. TensorFlow搭建LSTM實現(xiàn)多變量多步長時間序列預(yù)測（五）：seq2seq
27. TensorFlow搭建LSTM實現(xiàn)多變量輸入多變量輸出時間序列預(yù)測（多任務(wù)學(xué)習(xí)）
28. TensorFlow搭建ANN實現(xiàn)時間序列預(yù)測（風(fēng)速預(yù)測）
29. TensorFlow搭建CNN實現(xiàn)時間序列預(yù)測（風(fēng)速預(yù)測）
30. TensorFlow搭建CNN-LSTM混合模型實現(xiàn)多變量多步長時間序列預(yù)測（負(fù)荷預(yù)測）
31. PyG搭建圖神經(jīng)網(wǎng)絡(luò)實現(xiàn)多變量輸入多變量輸出時間序列預(yù)測
32. PyTorch搭建GNN-LSTM和LSTM-GNN模型實現(xiàn)多變量輸入多變量輸出時間序列預(yù)測
33. PyG Temporal搭建STGCN實現(xiàn)多變量輸入多變量輸出時間序列預(yù)測
34. 時序預(yù)測中Attention機(jī)制是否真的有效？盤點(diǎn)LSTM/RNN中24種Attention機(jī)制+效果對比
35. 詳解Transformer在時序預(yù)測中的Encoder和Decoder過程：以負(fù)荷預(yù)測為例
36. (PyTorch)TCN和RNN/LSTM/GRU結(jié)合實現(xiàn)時間序列預(yù)測
37. PyTorch搭建Informer實現(xiàn)長序列時間序列預(yù)測
38. PyTorch搭建Autoformer實現(xiàn)長序列時間序列預(yù)測

其中有2篇講分別講述了如何利用Encoder-Only和Encoder-Decoder的Transformer進(jìn)行時間序列預(yù)測。

然而，Transformer存在一系列的問題，使其不能用于長序列時間序列預(yù)測，如和序列長度平方成正比的時間復(fù)雜度，高內(nèi)存使用量和Encoder-Decoder體系結(jié)構(gòu)固有的局限性。為了解決上述問題，文章《Informer: Beyond Efficient Transformer for Long Sequence Time-Series Forecasting》中提出了一種超越Transformer的長序列時序預(yù)測模型Informer。

II. Informer

Informer在Transformer基礎(chǔ)上主要做了三點(diǎn)改進(jìn)：

1. Transformer計算self-attention時時間復(fù)雜度和序列長度的平方成正比，即$O(L^2)$，為此，Informer中提出了一種ProbSparse self-attention，將時間復(fù)雜度和內(nèi)存使用都壓縮到了$O(L?\log L)$。
2. 傳統(tǒng)Transformer將多個編碼和解碼層進(jìn)行堆疊，帶來的復(fù)雜度是累加的，這限制了模型在接收長序列輸入時的可擴(kuò)展性。為此，Informer在每個注意力層之間都添加了蒸餾操作，通過將序列的shape減半來突出主要注意力，使得模型可以接受更長的序列輸入，并且可以降低內(nèi)存和時間損耗。
3. 傳統(tǒng)Transformer的Decoder階段輸出是step-by-step，一方面增加了耗時，另一方面也會給模型帶來累計誤差。因此Informer提出應(yīng)該直接得到所有步長的預(yù)測結(jié)果。

更具體的原理就不做講解了，網(wǎng)上已經(jīng)有了很多類似的文章，這篇文章主要講解代碼的使用，重點(diǎn)是如何對作者公開的源代碼進(jìn)行改動，以更好地適配大多數(shù)人自身的數(shù)據(jù)，使得讀者只需要改變少數(shù)幾個參數(shù)就能實現(xiàn)數(shù)據(jù)集的更換。

III. 代碼

3.1 輸入編碼

傳統(tǒng)Transformer中在編碼階段需要進(jìn)行的第一步就是在原始序列的基礎(chǔ)上添加位置編碼，而在Informer中，輸入由三部分組成。我們假設(shè)輸入的序列長度為(batch_size, seq_len, enc_in)，如果用過去96個時刻的所有13個變量預(yù)測未來時刻的值，那么輸入即為(batch_size, 96, 13)。

3.1.1 Token Embedding

Informer輸入的第1部分是對原始輸入進(jìn)行編碼，本質(zhì)是利用一個1維卷積對原始序列進(jìn)行特征提取，并且序列的維度從原始的enc_in變換到d_model，代碼如下：

class TokenEmbedding(nn.Module):def __init__(self, c_in, d_model):super(TokenEmbedding, self).__init__()padding = 1 if torch.__version__ >= '1.5.0' else 2self.tokenConv = nn.Conv1d(in_channels=c_in, out_channels=d_model,kernel_size=3, padding=padding, padding_mode='circular')for m in self.modules():if isinstance(m, nn.Conv1d):nn.init.kaiming_normal_(m.weight, mode='fan_in', nonlinearity='leaky_relu')def forward(self, x):x = self.tokenConv(x.permute(0, 2, 1)).transpose(1, 2)return x

輸入x的大小為(batch_size, seq_len, enc_in)，需要先將后兩個維度交換以適配1維卷積，接著讓數(shù)據(jù)通過tokenConv，由于添加了padding，因此經(jīng)過后seq_len維度不改變，經(jīng)過TokenEmbedding后得到大小為(batch_size, seq_len, d_model)的輸出。

3.1.2 Positional Embedding

Informer輸入的第2部分是位置編碼，這點(diǎn)與Transformer無異，代碼如下：

class PositionalEmbedding(nn.Module):def __init__(self, d_model, max_len=5000):super(PositionalEmbedding, self).__init__()# Compute the positional encodings once in log space.pe = torch.zeros(max_len, d_model).float()pe.require_grad = Falseposition = torch.arange(0, max_len).float().unsqueeze(1)div_term = (torch.arange(0, d_model, 2).float() * -(math.log(10000.0) / d_model)).exp()pe[:, 0::2] = torch.sin(position * div_term)pe[:, 1::2] = torch.cos(position * div_term)pe = pe.unsqueeze(0)self.register_buffer('pe', pe)def forward(self, x):return self.pe[:, :x.size(1)]

位置編碼同樣返回大小為(batch_size, seq_len, d_model)的輸出。

3.1.3 Temporal Embedding

Informer輸入的第3部分是對時間戳進(jìn)行編碼，即年月日星期時分秒等進(jìn)行編碼。作者提出了兩種編碼方式，我們依次解析。第一種編碼方式TemporalEmbedding代碼如下：

class TemporalEmbedding(nn.Module):def __init__(self, d_model, embed_type='fixed', freq='h'):super(TemporalEmbedding, self).__init__()minute_size = 4hour_size = 24weekday_size = 7day_size = 32month_size = 13Embed = FixedEmbedding if embed_type == 'fixed' else nn.Embeddingif freq == 't':self.minute_embed = Embed(minute_size, d_model)self.hour_embed = Embed(hour_size, d_model)self.weekday_embed = Embed(weekday_size, d_model)self.day_embed = Embed(day_size, d_model)self.month_embed = Embed(month_size, d_model)def forward(self, x):x = x.long()minute_x = self.minute_embed(x[:, :, 4]) if hasattr(self, 'minute_embed') else 0.hour_x = self.hour_embed(x[:, :, 3])weekday_x = self.weekday_embed(x[:, :, 2])day_x = self.day_embed(x[:, :, 1])month_x = self.month_embed(x[:, :, 0])return hour_x + weekday_x + day_x + month_x + minute_x

TemporalEmbedding的輸入要求是(batch_size, seq_len, 5),5表示每個時間戳的月、天、星期（星期一到星期七）、小時以及刻鐘數(shù)（一刻鐘15分鐘）。代碼中對五個值分別進(jìn)行了編碼，編碼方式有兩種，一種是FixedEmbedding，它使用位置編碼作為embedding的參數(shù)，不需要訓(xùn)練參數(shù)；另一種就是torch自帶的nn.Embedding，參數(shù)是可訓(xùn)練的。

更具體的，作者將月、天、星期、小時以及刻鐘的范圍分別限制在了13、32、7、24以及4。即保證輸入每個時間戳的月份數(shù)都在0-12，天數(shù)都在0-31，星期都在0-6，小時數(shù)都在0-23，刻鐘數(shù)都在0-3。例如2024/04/05/12:13，星期五，輸入應(yīng)該是(4, 5, 5, 13, 0)。注意12:13小時數(shù)應(yīng)該為13，小于等于12:00但大于11:00如11:30才為12。

對時間戳進(jìn)行編碼的第二種方式為TimeFeatureEmbedding：

class TimeFeatureEmbedding(nn.Module):def __init__(self, d_model, embed_type='timeF', freq='h'):super(TimeFeatureEmbedding, self).__init__()freq_map = {'h': 4, 't': 5, 's': 6, 'm': 1, 'a': 1, 'w': 2, 'd': 3, 'b': 3}d_inp = freq_map[freq]self.embed = nn.Linear(d_inp, d_model)def forward(self, x):return self.embed(x)

TimeFeatureEmbedding的輸入為(batch_size, seq_len, d_inp)，d_inp有多達(dá)8種選擇。具體來說針對時間戳2024/04/05/12:13，以freq='h’為例，其輸入應(yīng)該是(月份、日期、星期、小時)，即(4, 5, 5, 13)，然后針對輸入通過以下函數(shù)將所有數(shù)據(jù)轉(zhuǎn)換到-0.5到0.5之間：

def time_features(dates, timeenc=1, freq='h'):"""> `time_features` takes in a `dates` dataframe with a 'dates' column and extracts the date down to `freq` where freq can be any of the following if `timeenc` is 0: > * m - [month]> * w - [month]> * d - [month, day, weekday]> * b - [month, day, weekday]> * h - [month, day, weekday, hour]> * t - [month, day, weekday, hour, *minute]> > If `timeenc` is 1, a similar, but different list of `freq` values are supported (all encoded between [-0.5 and 0.5]): > * Q - [month]> * M - [month]> * W - [Day of month, week of year]> * D - [Day of week, day of month, day of year]> * B - [Day of week, day of month, day of year]> * H - [Hour of day, day of week, day of month, day of year]> * T - [Minute of hour*, hour of day, day of week, day of month, day of year]> * S - [Second of minute, minute of hour, hour of day, day of week, day of month, day of year]*minute returns a number from 0-3 corresponding to the 15 minute period it falls into."""if timeenc == 0:dates['month'] = dates.date.apply(lambda row: row.month, 1)dates['day'] = dates.date.apply(lambda row: row.day, 1)dates['weekday'] = dates.date.apply(lambda row: row.weekday(), 1)dates['hour'] = dates.date.apply(lambda row: row.hour, 1)dates['minute'] = dates.date.apply(lambda row: row.minute, 1)dates['minute'] = dates.minute.map(lambda x: x // 15)freq_map = {'y': [], 'm': ['month'], 'w': ['month'], 'd': ['month', 'day', 'weekday'],'b': ['month', 'day', 'weekday'], 'h': ['month', 'day', 'weekday', 'hour'],'t': ['month', 'day', 'weekday', 'hour', 'minute'],}return dates[freq_map[freq.lower()]].valuesif timeenc == 1:dates = pd.to_datetime(dates.date.values)return np.vstack([feat(dates) for feat in time_features_from_frequency_str(freq)]).transpose(1, 0)

當(dāng)freq為’t’時，輸入應(yīng)該為[‘month’, ‘day’, ‘weekday’, ‘hour’, ‘minute’]，其他類似。當(dāng)通過上述函數(shù)將四個數(shù)轉(zhuǎn)換為-0.5到0.5之間后，再利用TimeFeatureEmbedding中的self.embed = nn.Linear(d_inp, d_model)來將維度從4轉(zhuǎn)換到d_model，因此最終返回的輸出大小也為(batch_size, seq_len, d_model)。

最終，代碼中通過一個DataEmbedding類來將三種編碼放在一起：

class DataEmbedding(nn.Module):def __init__(self, c_in, d_model, embed_type='fixed', freq='h', dropout=0.1):super(DataEmbedding, self).__init__()# 值編碼self.value_embedding = TokenEmbedding(c_in=c_in, d_model=d_model)# 位置編碼self.position_embedding = PositionalEmbedding(d_model=d_model)self.temporal_embedding = TemporalEmbedding(d_model=d_model, embed_type=embed_type,freq=freq) if embed_type != 'timeF' else TimeFeatureEmbedding(d_model=d_model, embed_type=embed_type, freq=freq)self.dropout = nn.Dropout(p=dropout)def forward(self, x, x_mark):x = self.value_embedding(x) + self.position_embedding(x) + self.temporal_embedding(x_mark)return self.dropout(x)

3.2 Encoder與Decoder

完整的Informer代碼如下：

class Informer(nn.Module):def __init__(self, args):super(Informer, self).__init__()self.args = argsself.pred_len = args.pred_lenself.attn = args.attnself.output_attention = Falseself.distil = Trueself.mix = True# Encodingself.enc_embedding = DataEmbedding(args.enc_in, args.d_model, args.embed, args.freq, args.dropout)self.dec_embedding = DataEmbedding(args.dec_in, args.d_model, args.embed, args.freq, args.dropout)# AttentionAttn = ProbAttention if args.attn == 'prob' else FullAttention# Encoderself.encoder = Encoder([EncoderLayer(AttentionLayer(Attn(False, args.factor, attention_dropout=args.dropout,output_attention=self.output_attention), args.d_model, args.n_heads, mix=False),args.d_model,args.d_ff,dropout=args.dropout,activation=args.activation) for l in range(args.e_layers)],[ConvLayer(args.d_model) for l in range(args.e_layers - 1)] if self.distil else None,norm_layer=torch.nn.LayerNorm(args.d_model))# Decoderself.decoder = Decoder([DecoderLayer(AttentionLayer(Attn(True, args.factor, attention_dropout=args.dropout, output_attention=False),args.d_model, args.n_heads, mix=self.mix),AttentionLayer(FullAttention(False, args.factor, attention_dropout=args.dropout, output_attention=False),args.d_model, args.n_heads, mix=False),args.d_model,args.d_ff,dropout=args.dropout,activation=args.activation,)for l in range(args.d_layers)],norm_layer=torch.nn.LayerNorm(args.d_model))# self.end_conv1 = nn.Conv1d(in_channels=label_len+out_len, out_channels=out_len, kernel_size=1, bias=True)# self.end_conv2 = nn.Conv1d(in_channels=d_model, out_channels=c_out, kernel_size=1, bias=True)self.projection = nn.Linear(args.d_model, args.c_out, bias=True)def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec,enc_self_mask=None, dec_self_mask=None, dec_enc_mask=None):enc_out = self.enc_embedding(x_enc, x_mark_enc)enc_out, attns = self.encoder(enc_out, attn_mask=enc_self_mask)dec_out = self.dec_embedding(x_dec, x_mark_dec)dec_out = self.decoder(dec_out, enc_out, x_mask=dec_self_mask, cross_mask=dec_enc_mask)dec_out = self.projection(dec_out)# dec_out = self.end_conv1(dec_out)# dec_out = self.end_conv2(dec_out.transpose(2,1)).transpose(1,2)if self.output_attention:return dec_out[:, -self.pred_len:, :], attnselse:return dec_out[:, -self.pred_len:, :]  # [B, L, D]

觀察forward，主要的輸入為x_enc, x_mark_enc, x_dec, x_mark_dec，下邊依次介紹：

1. x_enc: 編碼器輸入，大小為(batch_size, seq_len, enc_in)，在這篇文章中，我們使用前96個時刻的所有13個變量預(yù)測未來24個時刻的所有13個變量，所以這里x_enc的輸入應(yīng)該是(batch_size, 96, 13)。
2. x_mark_enc：編碼器的時間戳輸入，大小分情況，本文中采用頻率freq='h’的TimeFeatureEmbedding編碼方式，所以應(yīng)該輸入[‘month’, ‘day’, ‘weekday’, ‘hour’]，大小為(batch_size, 96, 4)。
3. x_dec，解碼器輸入，大小為(batch_size, label_len+pred_len, dec_in)，其中dec_in為解碼器輸入的變量個數(shù)，也為13。在Informer中，為了避免step-by-step的解碼結(jié)構(gòu)，作者直接將x_enc中后label_len個時刻的數(shù)據(jù)和要預(yù)測時刻的數(shù)據(jù)進(jìn)行拼接得到解碼器輸入。在本次實驗中，由于需要預(yù)測未來24個時刻的數(shù)據(jù)，所以pred_len=24，向前看48個時刻，所以label_len=48，最終解碼器的輸入維度應(yīng)該為(batch_size, 48+24=72, 13)。
4. x_mark_dec，解碼器的時間戳輸入，大小為(batch_size, 72, 4)。

為了方便理解編碼器和解碼器的輸入，給一個具體的例子：假設(shè)某個樣本編碼器的輸入為1-96時刻的所有13個變量，即x_enc大小為(96, 13)，x_mark_enc大小為(96, 4)，表示每個時刻的[‘month’, ‘day’, ‘weekday’, ‘hour’]；解碼器輸入為編碼器輸入的后label_len=48+要預(yù)測的pred_len=24個時刻的數(shù)據(jù)，即49-120時刻的所有13個變量，x_dec大小為(72, 13)，同理x_mark_dec大小為(72, 4)。

為了防止數(shù)據(jù)泄露，在預(yù)測97-120時刻的數(shù)據(jù)時，解碼器輸入x_dec中不能包含97-120時刻的真實數(shù)據(jù)，在原文中，作者用24個0或者24個1來代替，代碼如下：

if args.padding == 0:dec_input = torch.zeros([seq_y.shape[0], args.pred_len, seq_y.shape[-1]]).float().to(args.device)
elif args.padding == 1:dec_input = torch.ones([seq_y.shape[0], args.pred_len, seq_y.shape[-1]]).float().to(args.device)
else:raise ValueError('padding must be 0 or 1')
dec_input = torch.cat([seq_y[:, :args.label_len, :], dec_input], dim=1).float()

參數(shù)padding 可選，為0則填充0，否則填充1。

IV. 實驗

首先是數(shù)據(jù)處理，原始Informer中的數(shù)據(jù)處理和我之前寫的30多篇文章的數(shù)據(jù)處理過程不太匹配，因此這里重寫了數(shù)據(jù)處理過程，代碼如下：

def get_data(args):print('data processing...')data = load_data()# splittrain = data[:int(len(data) * 0.6)]val = data[int(len(data) * 0.6):int(len(data) * 0.8)]test = data[int(len(data) * 0.8):len(data)]scaler = StandardScaler()def process(dataset, flag, step_size, shuffle):# 對時間列進(jìn)行編碼df_stamp = dataset[['date']]df_stamp.date = pd.to_datetime(df_stamp.date)data_stamp = time_features(df_stamp, timeenc=1, freq=args.freq)data_stamp = torch.FloatTensor(data_stamp)# 接著歸一化# 首先去掉時間列dataset.drop(['date'], axis=1, inplace=True)if flag == 'train':dataset = scaler.fit_transform(dataset.values)else:dataset = scaler.transform(dataset.values)dataset = torch.FloatTensor(dataset)# 構(gòu)造樣本samples = []for index in range(0, len(dataset) - args.seq_len - args.pred_len + 1, step_size):# train_x, x_mark, train_y, y_marks_begin = indexs_end = s_begin + args.seq_lenr_begin = s_end - args.label_lenr_end = r_begin + args.label_len + args.pred_lenseq_x = dataset[s_begin:s_end]seq_y = dataset[r_begin:r_end]seq_x_mark = data_stamp[s_begin:s_end]seq_y_mark = data_stamp[r_begin:r_end]samples.append((seq_x, seq_y, seq_x_mark, seq_y_mark))samples = MyDataset(samples)samples = DataLoader(dataset=samples, batch_size=args.batch_size, shuffle=shuffle, num_workers=0, drop_last=False)return samplesDtr = process(train, flag='train', step_size=1, shuffle=True)Val = process(val, flag='val', step_size=1, shuffle=True)Dte = process(test, flag='test', step_size=args.pred_len, shuffle=False)return Dtr, Val, Dte, scaler

實驗設(shè)置：本次實驗選擇LSTM以及Transformer來和Informer進(jìn)行對比，其中LSTM采用直接多輸出方式，Transformer又分為Encoder-Only和Encoder-Decoder架構(gòu)。

使用前96個時刻的所有13個變量預(yù)測未來24個時刻的所有13個變量，只給出第一個變量也就是負(fù)荷這一變量的MAPE結(jié)果：

LSTM	Encoder-only	Encoder-Decoder	Informer
10.34%	8.01%	8.54%	7.41%

由于沒有進(jìn)行調(diào)參，實驗結(jié)果僅供參考。可以發(fā)現(xiàn)LSTM在長序列預(yù)測上表現(xiàn)不好，而Transformer和Informer表現(xiàn)都比較優(yōu)秀，其中Informer效果最好。