這篇是 ICLR 上用 TCN 來做一般的時間序列分析的論文，在 Rebuttal 之后的分數(shù)為 888，算得上是時間序列領域相關的論文中最高分那一檔了。本文提出了一個 ModernTCN 的模型，實現(xiàn)起來也很簡單，所以我后面附上了模型的代碼實現(xiàn)。

論文標題：

ModernTCN: A Modern Pure Convolution Structure for General Time Series Analysis

論文鏈接：

https://openreview.net/forum?id=vpJMJerXHU

Key Point

1.1 Motivation

作者發(fā)現(xiàn)，在時間序列領域，最近基于 TCN/CNN 的模型效果沒有基于Transformer 或 MLP 的模型效果好，而一些現(xiàn)代的 CNN 比如 ConvNeXt、SLaK 的性能都超過了 Vision Transformer。因此，作者想探究卷積是不是可以在時間序列分析領域獲得更好的性能。為此，有兩點可以改善 TCN 模型的地方。

首先是要提升感受野。在 CV 領域，現(xiàn)代卷積都有著很大的卷積核。作者發(fā)現(xiàn)在時間序列領域差不多，可以看下圖：

SCINet 和 MICN 是兩個基于 TCN 的預測模型，它們的感受野都很小。作者發(fā)現(xiàn) ModernTCN 中采用大的卷積核所對應的感受野要大很多。

其次是充分利用卷積可以捕獲跨變量依賴性，也就是多變量時間序列中變量之間的關系。在 PatchTST 等最近的時間序列預測文章中，很多方法采用了通道獨立策略，這種策略直接將多變量序列預測中變量之間關系忽略了，反而取得了更好的效果。作者認為，變量之間關系仍然重要，但是要精心設計模型結(jié)構(gòu)來捕獲。

1.2 從CV中汲取靈感（現(xiàn)代卷積結(jié)構(gòu)）

在 CV 中，很多人發(fā)現(xiàn) Transformer 之所以成功，可能是因為架構(gòu)比較好。比如下圖左側(cè)，self-attention 負責 token 之間的混合，F(xiàn)FN 負責通道之間的混合，兩者分離開。同樣的，把混合 token 的結(jié)構(gòu)替換為深度分離卷積（depth-wise 卷積，DWConv），把 FFN 換為完全等價的 ConvFFN（由兩個 point-wise Conv 加 GeLU 激活組成）。

不熟悉 depth-wise 卷積的可以去了解一下，它其實就是對每個通道采用獨立的核，這樣就不會混合通道，只會混合 token，大卷積核來獲取大感受野也是在這里用的。

然而，作者發(fā)現(xiàn)采用上圖（b）的結(jié)構(gòu)構(gòu)建的模型效果也不是特別好，這是因為這個現(xiàn)代卷積結(jié)構(gòu)中并沒有專門為時間序列設計的一些特殊的東西，一個重要的就是如何建模跨變量依賴性。注意，在這里要區(qū)分通道和變量之間的關系。變量是指多變量序列中每個變量，通道是指每個變量映射到的隱空間維度（而 PatchTST 中提到的通道獨立則是變量之間獨立，這個不要混淆）。ConvFFN 可以建模通道間關系，但無法建模變量間關系。

1.3 適用于時間序列的改動（變量間建模）

首先，在 embedding 的過程中，cv 一般是直接混合 RGB 變量。而在時間序列中，這種方式不適用，因為一個簡單的 embedding 顯然無法充分建模變量間關系。如果在 embedding 時就已經(jīng)把變量混合了起來，那后續(xù)對變量間的建模則是混亂的。

因此，作者提出了變量無關 embedding，也是用了分 patch 的方法，對每個變量獨立分 patch 進行 embedding。具體在代碼實現(xiàn)上，作者是采用有 stride 的卷積，在這里我給出了代碼實現(xiàn)，先介紹下代碼相關的注釋：

# B：batch size
# M：多變量序列的變量數(shù)
# L：過去序列的長度
#T:預測序列的長度
#N:分Patch后Patch的個數(shù)
# D：每個變量的通道數(shù)
# P：kernel size of embedding layer
# S：stride of embedding layer

classEmbedding(nn.Module):
def__init__(self,P=8,S=4,D=2048):
super(Embedding,self).__init__()
self.P=P
self.S=S
self.conv=nn.Conv1d(
in_channels=1,
out_channels=D,
kernel_size=P,
stride=S
)

defforward(self,x):
#x:[B,M,L]
B=x.shape[0]
x=x.unsqueeze(2)#[B,M,L]->[B,M,1,L]
x=rearrange(x,'bmrl->(bm)rl')#[B,M,1,L]->[B*M,1,L]
x_pad=F.pad(
x,
pad=(0,self.P-self.S),
mode='replicate'
)#[B*M,1,L]->[B*M,1,L+P-S]

x_emb=self.conv(x_pad)#[B*M,1,L+P-S]->[B*M,D,N]
x_emb=rearrange(x_emb,'(bm)dn->bmdn',b=B)#[B*M,D,N]->[B,M,D,N]

returnx_emb#x_emb:[B,M,D,N]

上圖中 DWconv 用來建模時間關系，第一個 ConvFFN 用來建模通道關系，第二個 ConvFFN 用來建模變量關系。下面介紹具體的實現(xiàn)，注意看上圖中 shape 在每一個模塊的前后變化。

首先，希望用 DWConv 來建模時間上的關系，但又不希望它參與到通道間和變量間的建模上。因此，作者將 M 和 D 這兩個表示變量和通道的維度 reshape 在一起，再進行深度可分離卷積。

其次，希望獨立建模通道和變量。因此，作者采用了兩個組卷積，其中一個組卷積的 Group 數(shù)為 M（表示每 D 個通道構(gòu)成一個組，因此用來建模通道間關系），另一個組卷積的 Group 數(shù)為 D（表示每 M 個變量構(gòu)成一個組，因此用來建模變量間關系）。注意，兩個組卷積之間存在著 reshape 和 permute 操作，這是為了正確的分組，最后會再 reshape 和 permute 回去。

最后，整體再用一個殘差連接，即可得到最終的 ModernTCN block。ModernTCN block 的代碼實現(xiàn)在最后，堆疊多個 block 即可得到 ModernTCN 模型。

綜上所述，作者將時間上、通道上、變量上的三種關系解耦建模，用三種組卷積來巧妙地進行實現(xiàn)（深度可分離卷積其實也是組數(shù)等于深度數(shù)的組卷積），既簡單又有效。

實驗

作者也是在各種時間序列任務上進行了實驗，如下圖，又快又好的五邊形戰(zhàn)士：

代碼實現(xiàn)

importtorch
importtorch.nnasnn
importtorch.nn.functionalasF
fromeinopsimportrearrange

# B：batch size
# M：多變量序列的變量數(shù)
# L：過去序列的長度
#T:預測序列的長度
#N:分Patch后Patch的個數(shù)
# D：每個變量的通道數(shù)
# P：kernel size of embedding layer
# S：stride of embedding layer

classEmbedding(nn.Module):
def__init__(self,P=8,S=4,D=2048):
super(Embedding,self).__init__()
self.P=P
self.S=S
self.conv=nn.Conv1d(
in_channels=1,
out_channels=D,
kernel_size=P,
stride=S
)

defforward(self,x):
#x:[B,M,L]
B=x.shape[0]
x=x.unsqueeze(2)#[B,M,L]->[B,M,1,L]
x=rearrange(x,'bmrl->(bm)rl')#[B,M,1,L]->[B*M,1,L]
x_pad=F.pad(
x,
pad=(0,self.P-self.S),
mode='replicate'
)#[B*M,1,L]->[B*M,1,L+P-S]

x_emb=self.conv(x_pad)#[B*M,1,L+P-S]->[B*M,D,N]
x_emb=rearrange(x_emb,'(bm)dn->bmdn',b=B)#[B*M,D,N]->[B,M,D,N]

returnx_emb#x_emb:[B,M,D,N]


classConvFFN(nn.Module):
def__init__(self,M,D,r,one=True):#oneisTrue:ConvFFN1,oneisFalse:ConvFFN2
super(ConvFFN,self).__init__()
groups_num=MifoneelseD
self.pw_con1=nn.Conv1d(
in_channels=M*D,
out_channels=r*M*D,
kernel_size=1,
groups=groups_num
)
self.pw_con2=nn.Conv1d(
in_channels=r*M*D,
out_channels=M*D,
kernel_size=1,
groups=groups_num
)

defforward(self,x):
#x:[B,M*D,N]
x=self.pw_con2(F.gelu(self.pw_con1(x)))
returnx#x:[B,M*D,N]


classModernTCNBlock(nn.Module):
def__init__(self,M,D,kernel_size,r):
super(ModernTCNBlock,self).__init__()
#深度分離卷積負責捕獲時域關系
self.dw_conv=nn.Conv1d(
in_channels=M*D,
out_channels=M*D,
kernel_size=kernel_size,
groups=M*D,
padding='same'
)
self.bn=nn.BatchNorm1d(M*D)
self.conv_ffn1=ConvFFN(M,D,r,one=True)
self.conv_ffn2=ConvFFN(M,D,r,one=False)

defforward(self,x_emb):
#x_emb:[B,M,D,N]
D=x_emb.shape[-2]
x=rearrange(x_emb,'bmdn->b(md)n')#[B,M,D,N]->[B,M*D,N]
x=self.dw_conv(x)#[B,M*D,N]->[B,M*D,N]
x=self.bn(x)#[B,M*D,N]->[B,M*D,N]
x=self.conv_ffn1(x)#[B,M*D,N]->[B,M*D,N]

x=rearrange(x,'b(md)n->bmdn',d=D)#[B,M*D,N]->[B,M,D,N]
x=x.permute(0,2,1,3)#[B,M,D,N]->[B,D,M,N]
x=rearrange(x,'bdmn->b(dm)n')#[B,D,M,N]->[B,D*M,N]

x=self.conv_ffn2(x)#[B,D*M,N]->[B,D*M,N]

x=rearrange(x,'b(dm)n->bdmn',d=D)#[B,D*M,N]->[B,D,M,N]
x=x.permute(0,2,1,3)#[B,D,M,N]->[B,M,D,N]

out=x+x_emb

returnout#out:[B,M,D,N]


classModernTCN(nn.Module):
def__init__(self,M,L,T,D=2048,P=8,S=4,kernel_size=51,r=1,num_layers=2):
super(ModernTCN,self).__init__()
#深度分離卷積負責捕獲時域關系
self.num_layers=num_layers
N=L//S
self.embed_layer=Embedding(P,S,D)
self.backbone=nn.ModuleList([ModernTCNBlock(M,D,kernel_size,r)for_inrange(num_layers)])
self.head=nn.Linear(D*N,T)

defforward(self,x):
#x:[B,M,L]
x_emb=self.embed_layer(x)#[B,M,L]->[B,M,D,N]

foriinrange(self.num_layers):
x_emb=self.backbone[i](x_emb)#[B,M,D,N]->[B,M,D,N]

#Flatten
z=rearrange(x_emb,'bmdn->bm(dn)')#[B,M,D,N]->[B,M,D*N]
pred=self.head(z)#[B,M,D*N]->[B,M,T]

returnpred#out:[B,M,T]


past_series=torch.rand(2,4,96)
model=ModernTCN(4,96,192)
pred_series=model(past_series)
print(pred_series.shape)
#torch.Size([2,4,192])

Comments

附錄很長，里面的消融實驗很充分，效果也很好，想法很合理，實現(xiàn)起來也很簡單，估計能中 oral。不過感覺在那幾個時間序列預測任務上的數(shù)據(jù)集都快刷爆了，性能快到瓶頸了，感覺之后很難再有大的效果提升了。