week38 iTransformer

摘要

本周阅读了题为iTransformer: Inverted Transformers Are Effective for Time Series Forecasting的论文。考虑到多元时间序列的特点，该文提出了iTransformer，它在不修改任何原生模块的情况下反转了Transformer的结构。 iTransformer 将独立序列视为变量标记，通过注意力捕获多元相关性，并利用层归一化和前馈网络来学习序列表示。在实验上，iTransformer 实现了最先进的性能，并在有前景的分析的支持下展现了卓越的框架通用性。然后，本文展示了iTransoformer的关键代码。最后，本文基于pytorch以及MNIST数据集实现了GAN绘制手写数字。

Abstract

This week read the paper titled “iTransformer: Inverted Transformers Are Effective for Time Series Forecasting”. Considering the characteristics of multivariate time series, we propose iTransformer that inverts the structure of Transformer without modifying any native modules. iTransformer regards independent series as variate tokens to capture multivariate correlations by attention and utilize layer normalization and feed-forward networks to learn series representations. Experimentally, iTransformer achieves state-of-the-art performance and exhibits remarkable framework generality supported by promising analysis. And then, Then, this article shows the key code of iTransoformer. Finally, based on PyTorch and the MNIST dataset, this article implements GANs to generate hand-written digits.

一、文献阅读

1. 题目

标题：iTransformer: Inverted Transformers Are Effective for Time Series Forecasting

作者：Yong Liu, Tengge Hu, Haoran Zhang, Haixu Wu, Shiyu Wang, Lintao Ma, Mingsheng Long

期刊名：ICLR2024

链接：https://openreview.net/forum?id=JePfAI8fah

2. abstract

该文提出 iTransformer，它简单地将注意力和前馈网络应用于反转维度。具体来说，各个系列的时间点被嵌入到变量标记中，注意力机制利用变量标记来捕获多元相关性；同时，前馈网络应用于每个变量标记来学习非线性表示。 iTransformer 模型在具有挑战性的现实世界数据集上达到了最先进的水平，这进一步增强了 Transformer 系列的性能、跨不同变量的泛化能力，以及更好地利用任意回溯窗口，使其成为基础模型的一个不错的替代方案。

This article proposes iTransformer that simply applies the attention and feed-forward network on the inverted dimensions. Specifically, the time points of individual series are embedded into variate tokens which are utilized by the attention mechanism to capture multivariate correlations; meanwhile, the feed-forward network is applied for each variate token to learn nonlinear representations. The iTransformer model achieves state-of-the-art on challenging real-world datasets, which further empowers the Transformer family with promoted performance, generalization ability across different variates, and better utilization of arbitrary lookback windows, making it a nice alternative as the fundamental backbone of time series forecasting.

3. 网络架构

在多元时间序列预测中，给定历史观测值 $X=x_1,\dots ,x_T\in {\mathbb{R}}^{T\times N}$ 具有 T 个时间步长和 N 个变量，预测未来的 S 个时间步长 $Y=x_{T+1},\dots ,x_{T+S}\in {\mathbb{R}}_{S\times N}$。为了方便起见，将 $X_{t,:}$ 表示为步骤 t 处同时记录的时间点，将 $X_{:,n}$ 表示为以 n 为索引的每个变量的整个时间序列。值得注意的是，由于数据集中变量之间存在系统时间滞后，$X_{t,:}$可能不包含本质上反映现实场景中同一事件的时间点。此外，$X_{t,:}$ 的元素在物理测量和统计分布上可以彼此不同，为此变量 $X_{:,n}$​​​​ 通常共享这些变量。

总体框架如下

各层操作简述：

1. embedding：首先将不同变量的原始序列独立嵌入为token，然后嵌入变量token
2. multivariate attention：令token经过一层多变量注意力层
3. layernorm：层归一化
4. feed-forward：前馈网络，将数据输入全连接层后Activate并drop，然后再输入全连接层
5. layernorm：层归一化，$\hat{x}=\frac{x-\mu }{\sigma }$

伪码如下

转置Embedding：

将单个变量的整个时间序列视为一个Token

iTransformer将不同的变量分开考虑，将一个变量的整个时间序列，独立Embedding为一个token，然后再通过一个linear层进行Embedding。

在iTransformer中，基于回溯序列$X_{:,n}$预测每个特定变量$\hat{Y}:,n$的未来序列的过程简单地表述如下：
$$\begin{gathered} h_n^0=\text{Embedding}(X_{:,n}), \\ {\mathbf{H}}^{l+1}=\text{TrmBlock}({\mathbf{H}}^l),l=0,\dots ,L-1, \\ \hat{\mathbf{Y}}=\text{Projection}(h_n^L) \end{gathered}$$

LayerNorm（层归一化）

原本Transforer中的LayerNorm会对相同时间戳的变量作归一化，使得变量之间的区分度下降。同时当各个变量的时间点没有对齐时，还会产生“交互噪声”。这种每个变量的归一化还会让模型拟合过于“平滑”，使得模型无法有效地区分不同的特征或模式从而造成过拟合。

在提出iTransforer****的中，归一化被应用于作为下述方程的每单个变量的级数表示，让所有变量的特征通道都处于相对统一的分布下。此外，由于所有变量的特征表示都被归一化到正态分布，由变量取值范围不同造成的差异可以减弱。
LayerNorm ( H ) = { ∣ h n − Mean ( h n ) Var ( h n ) ∣ n = 1 , … , N } \text{LayerNorm}(\mathbf H)=\{|\frac{h_n-\text{Mean}(h_n)}{\sqrt{\text{Var}(h_n)}}|n=1,\dots,N\} LayerNorm(H)={∣Var(hn​) ​hn​−Mean(hn​)​∣n=1,…,N}

Feed-forward network（前馈网络）

传统Transformer对同一时间戳下的变量编码，形成token的同一时间戳的多个变量可能发生错位，并且过于局部化，无法揭示足够的信息用于预测。在iTransforer中，FFN被用于每个Variate Token的序列表示，可以用于复杂的时间序列。

FNN包含激活函数层和两层Conv1d（第一层是对历史时间数据编码，第二层是解码进行预测），这里的FNN是计算序列内的全局表示。通过反向块的堆叠，致力于对观测到的时间序列进行编码，并使用密集的非线性连接对未来序列的表示进行解码。

Multivariate-Attention（多变量注意力机制）

注意力图可以在一定程度上揭示变量的相关性，以前的Transformer预测器通常采用注意力机制来促进时间依赖性建模，但iTransformer模型通过转置编码将一个变量的整个系列视为一个单独的过程，因此自注意力机制就可以促进不同变量之间的依赖了。

自注意力模块全面提取时间序列表示，采用线性投影获取Q、K、V的值，计算前Softmax分数，揭示变量之间的相关性，而原本的Transformer的注意力机制中的Q和K计算的是时间序列的相关性。在Softmax加权操作中，高度相关的变量将在与其Value向量的交互中获得更大的权重，更自然地建模了多变量时序数据的关联。

4. 文献解读

4.1 Introduction

提出问题：基于 Transformer 的预测器的现有结构可能不适合多元时间序列预测。如图 2 顶部所示，值得注意的是，同一时间步长的点基本上代表了由不一致的测量记录的完全不同的物理意义，这些点被嵌入到一个具有消除多元相关性的标记中。虽然序列变化会受到序列顺序的很大影响，但在时间维度上不正确地采用了排列不变注意机制。因此，Transformer 捕获基本序列表示和描绘多元相关性的能力被削弱，限制了其对不同时间序列数据的容量和泛化能力。

处理方法：对时间序列采取倒置的观点，并将每个变量的整个时间序列独立地嵌入到（变量）标记中，这是修补的极端情况。通过反转，嵌入的令牌聚合了系列的全局表示，这些表示可以更加以变量为中心，并通过蓬勃发展的多变量关联注意力机制更好地利用。

通过实验，所提出的 iTransformer 在图 1 所示的现实世界预测基准上实现了最先进的性能，并且令人惊讶地解决了基于 Transformer 的预测器的痛点。

4.2 创新点

这项工作设计了一种模型iTransformer。主要贡献总结如下：

1. 对 Transformer 的架构进行了反思，并细化了原生 Transformer 组件在多元时间序列上的能力尚未得到充分开发。
2. 提出iTransformer，将独立时间序列视为令牌，通过自注意力捕获多元相关性，并利用层归一化和前馈网络模块来学习更好的序列全局表示以进行时间序列预测。
3. 通过实验，iTransformer 在实际基准测试中达到了最先进的水平。广泛分析了倒置模块和架构选择，为基于 Transformer 的预测器的未来改进指明了一个有希望的方向。

4.3 实验过程

4.3.1 数据集

在实验中使用了7个真实世界的数据集，包括ECL、ETT（4个子集）、Exchange、Traffic、Autoformer使用的天气，LSTNet中提出的太阳能数据集和SCINet中评价的PEMS（4个子集）。以及市场实验（6个子集），它记录了支付宝在线交易应用程序的分钟采样服务器负载，具有数百个变量。

4.3.2 基线模型

选择了10个公认的预测模型作为我们的基准，包括：

（1）基于Transfomer的方法：Autoformer（2021）、FEDformer（2022）、固定（2022 ）、Crossformer（2023）、PatchTST（2023）;

（2）基于线性的方法：DLinear（2023）、TiDE（2023）、RLinear（2023）;

（3）基于TCN的方法：SCINet（2022）、TimesNet（2023）。

4.3.3 实验结果

1. 通过与基准模型对比实验，证明iTransformer预测高维时间序列预测能力。

将基准模型与研究模型在多个数据集上进行对比实验，多变量时间序列预测基准结果如下表所示，红色与蓝色分别表示最优与次优结果。MSE/MAE越低，预测结果越准确。从综合预测结果可以看出，与其他预测器相比，iTransformer特别擅长预测高维时间序列。作为明确捕获多变量相关性的代表，Crossformer的性能仍然低于iTransformer，这表明来自不同多变量的时间未对齐的补丁的相互作用将为预测带来不必要的噪声。因此，本地Transformer组件能够胜任时间建模和多变量相关，并且所提出的倒置架构可以有效地处理真实世界的时间序列预测场景。

2. 证明提出的转置框架能够获得的性能提升

其变体来评估iTransformer，其通常解决自我注意力机制的二次复杂性，表明简单的倒置视角可以提高基于Transformer的预测器的性能，提高效率，对未知变量进行泛化，并更好地利用历史观测。提出的反转框架获得包括平均性能和相对MSE降低的性能提升。此外，由于注意力机制在我们的反向结构中的变量维度上被采用，因此具有线性复杂度的有效注意力的引入本质上解决了由于众多变量而导致的计算问题。因此，iTransformer的想法可以广泛应用于基于Transformer的预测器，以更好利用高效注意力机制。

3. 验证iTransformers模型对未知变量的泛化性能

将每个数据集的变量划分到五个文件夹中，用20%的变量训练模型，并使用部分训练的模型来预测所有品种。如下图所示，每个条形图显示了所有文件夹的平均结果。CI-Transformers在推理过程中需要很长时间来逐个预测每个变量，而iTransformers直接预测所有变量，并且通常呈现较小的增加，这表明FFN能够学习可转移的时间序列表示。

5. 结论

考虑到多元时间序列的特点，该文提出了iTransformer，它在不修改任何原生模块的情况下反转了Transformer的结构。 iTransformer 将独立序列视为变量标记，通过注意力捕获多元相关性，并利用层归一化和前馈网络来学习序列表示。在实验上，iTransformer 实现了最先进的性能，并在有前景的分析的支持下展现了卓越的框架通用性。未来，我们将探索大规模预训练和更多时间序列分析任务。

二、实验代码

上述文章提出了iTransformer，以下为其部分代码: https://github.com/thuml/iTransformer.

第一层：Enbedding层

iTransformer的Embedding将整个输入都做转置，将每个特征的时间序列整个作为一个Embedding的Token，故而没有了原本的Positional Embedding，就将时间序列根据不同粒度分解作x_mark，也是将各个维度的变量作整个输入变为1个Embedding Token，不再使用Temporal Embedding。

#转置之后的Enbedding层
class DataEmbedding_inverted(nn.Module):
  
    def __init__(self, c_in, d_model, embed_type='fixed', freq='h', dropout=0.1):
        super(DataEmbedding_inverted, self).__init__()
        #用于设置网络中的全连接层，c_in输入维度，d_model为模型的维度
        self.value_embedding = nn.Linear(c_in, d_model)
        #p为保留概率，对于每个输入元素，以概率p置0
        self.dropout = nn.Dropout(p=dropout)
 
    def forward(self, x, x_mark):
        #将指定的矩阵维度进行重新排序，将第1维和第2维进行互换
        x = x.permute(0, 2, 1)
        # x: [Batch Variate Time]
        if x_mark is None:
            #标记不为空则进行编码
            x = self.value_embedding(x)
        else:
            #将协变量（如时间戳）作为标记的可能性
            x = self.value_embedding(torch.cat([x, x_mark.permute(0, 2, 1)], 1))
        #返回正则化后的结果
        return self.dropout(x)

第二层：注意力层

将每个变量token都复制三分，通过不同的线性层分别作为Q、K、V，形状变成了[Batch Variate n_head d_model]，将Q、K相乘缩放以当做相关性的度量，Softmax化后乘以Values得到不同变量之间的相关性权重，从而得到全局的Attention map。

class AttentionLayer(nn.Module):
    def __init__(self, attention, d_model, n_heads, d_keys=None,
                 d_values=None):
        super(AttentionLayer, self).__init__()
 
        d_keys = d_keys or (d_model // n_heads)
        d_values = d_values or (d_model // n_heads)
 
        self.inner_attention = attention
        #采用线性投影获取Q、K、V的值
        self.query_projection = nn.Linear(d_model, d_keys * n_heads)
        self.key_projection = nn.Linear(d_model, d_keys * n_heads)
        self.value_projection = nn.Linear(d_model, d_values * n_heads)
        self.out_projection = nn.Linear(d_values * n_heads, d_model)
        self.n_heads = n_heads
 
     #这里和Transformer中的的self-attention一样，对embedding的输出分别做3个线性转换，获得queries，keys，values
    def forward(self, queries, keys, values, attn_mask, tau=None, delta=None):
        B, L, _ = queries.shape
        _, S, _ = keys.shape
        H = self.n_heads
 
        queries = self.query_projection(queries).view(B, L, H, -1)
        keys = self.key_projection(keys).view(B, S, H, -1)
        values = self.value_projection(values).view(B, S, H, -1)
 
        out, attn = self.inner_attention(
            queries,
            keys,
            values,
            attn_mask,
            tau=tau,
            delta=delta
        )
        #将out的维度进行转换
        out = out.view(B, L, -1)
 
        return self.out_projection(out), attn

第三层：前馈神经网络

FNN包含激活函数层和两层Conv1d，第一层是对历史时间数据编码，第二层是解码进行预测。注意：这里的FNN是计算序列内的全局表示。

class FullAttention(nn.Module):
    def __init__(self, mask_flag=True, factor=5, scale=None, attention_dropout=0.1, output_attention=False):
        super(FullAttention, self).__init__()
        self.scale = scale
        self.mask_flag = mask_flag
        self.output_attention = output_attention
        self.dropout = nn.Dropout(attention_dropout)
 
    def forward(self, queries, keys, values, attn_mask, tau=None, delta=None):
        B, L, H, E = queries.shape
        _, S, _, D = values.shape
        scale = self.scale or 1. / sqrt(E)
 
        scores = torch.einsum("blhe,bshe->bhls", queries, keys)
 
        if self.mask_flag:
            if attn_mask is None:
                attn_mask = TriangularCausalMask(B, L, device=queries.device)
 
            scores.masked_fill_(attn_mask.mask, -np.inf)
 
        A = self.dropout(torch.softmax(scale * scores, dim=-1))
        V = torch.einsum("bhls,bshd->blhd", A, values)
 
        if self.output_attention:
            return V.contiguous(), A
        else:
            return V.contiguous(), None

Encoder

这部分就完全和Transformer中的Encoder部分一样了，包含两层Conv1d和LayerNorm，以及一层激活函数和Dropout防止全连接层过拟合，最后将一个线性层作为decoder，得到未来n个时间段的预测值。

class EncoderLayer(nn.Module):
    def __init__(self, attention, d_model, d_ff=None, dropout=0.1, activation="relu"):
        super(EncoderLayer, self).__init__()
        d_ff = d_ff or 4 * d_model
        self.attention = attention
        self.conv1 = nn.Conv1d(in_channels=d_model, out_channels=d_ff, kernel_size=1)
        self.conv2 = nn.Conv1d(in_channels=d_ff, out_channels=d_model, kernel_size=1)
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.dropout = nn.Dropout(dropout)
        self.activation = F.relu if activation == "relu" else F.gelu
 
    def forward(self, x, attn_mask=None, tau=None, delta=None):
        new_x, attn = self.attention(
            x, x, x,
            attn_mask=attn_mask,
            tau=tau, delta=delta
        )
        x = x + self.dropout(new_x)
        y = x = self.norm1(x)
        y = self.dropout(self.activation(self.conv1(y.transpose(-1, 1))))
        y = self.dropout(self.conv2(y).transpose(-1, 1))
 
        return self.norm2(x + y), attn

三、实现GAN

1. 任务要求

使用pytorch实现GAN网络，并使用MNIST数据库训练GAN，GAN绘制手写数字图片。其中，GAN使用MLP构建

2. 实验结果

GAN进行十九次迭代后的绘制效果

3.实验代码

3.1数据准备

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt
import torchvision
from torchvision import transforms

# 数据准备

# 对数据做归一化 （-1， 1）
transform = transforms.Compose([
    transforms.ToTensor(),         # 将数据转换成Tensor格式，channel, high, witch,数据在（0， 1）范围内
    transforms.Normalize(0.5, 0.5) # 通过均值和方差将数据归一化到（-1， 1）之间
])

# 下载数据集
train_ds = torchvision.datasets.MNIST('data',
                                      train=True,
                                      transform=transform,
                                      download=True)
                                      
# 设置dataloader
dataloader = torch.utils.data.DataLoader(train_ds, batch_size=64, shuffle=True)

# 返回一个批次的数据
imgs, _ = next(iter(dataloader))

# imgs的大小
imgs.shape

3.2 模型构建

# 定义生成器

# 输入是长度为 100 的 噪声（正态分布随机数）
# 输出为（1， 28， 28）的图片
# linear 1 :   100----256
# linear 2:    256----512
# linear 2:    512----28*28
# reshape:     28*28----(1, 28, 28)

class Generator(nn.Module): #创建的 Generator 类继承自 nn.Module
    def __init__(self): # 定义初始化方法
        super(Generator, self).__init__() #继承父类的属性
        self.main = nn.Sequential( #使用Sequential快速创建模型
                                  nn.Linear(100, 256),
                                  nn.ReLU(),
                                  nn.Linear(256, 512),
                                  nn.ReLU(),
                                  nn.Linear(512, 28*28),
                                  nn.Tanh()                     # 输出层使用Tanh()激活函数，使输出-1, 1之间
        )
    def forward(self, x):              # 定义前向传播 x 表示长度为100 的noise输入
        img = self.main(x)
        img = img.view(-1, 28, 28) #将img展平，转化成图片的形式，channel为1可写可不写
        return img
    
# 定义判别器

## 输入为（1， 28， 28）的图片  输出为二分类的概率值，输出使用sigmoid激活 0-1
# BCEloss计算交叉熵损失

# nn.LeakyReLU   f(x) : x>0 输出 x， 如果x<0 ,输出 a*x  a表示一个很小的斜率，比如0.1
# 判别器中一般推荐使用 LeakyReLU

class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.main = nn.Sequential(
                                  nn.Linear(28*28, 512), #输入是28*28的张量，也就是图片
                                  nn.LeakyReLU(), # 小于0的时候保存一部分梯度
                                  nn.Linear(512, 256),
                                  nn.LeakyReLU(),
                                  nn.Linear(256, 1), # 二分类问题，输出到1上
                                  nn.Sigmoid()
        )
    def forward(self, x):
        x = x.view(-1, 28*28)
        x = self.main(x)
        return x

3.3 展示函数

# 绘图函数

def gen_img_plot(model, epoch, test_input):
    prediction = np.squeeze(model(test_input).detach().cpu().numpy())
    fig = plt.figure(figsize=(4, 4))
    for i in range(16):
        plt.subplot(4, 4, i+1)
        plt.imshow((prediction[i] + 1)/2) # 确保prediction[i] + 1)/2输出的结果是在0-1之间
        plt.axis('off')
    plt.show()
    
test_input = torch.randn(16, 100, device=device)

3.4 训练过程

# GAN的训练

# 保存每个epoch所产生的loss值
D_loss = []
G_loss = []

# 训练循环
for epoch in range(20): #训练20个epoch
   d_epoch_loss = 0 # 初始损失值为0
   g_epoch_loss = 0
   # len(dataloader)返回批次数，len(dataset)返回样本数
   count = len(dataloader)
   # 对dataloader进行迭代
   for step, (img, _) in enumerate(dataloader): # enumerate加序号
       img = img.to(device) #将数据上传到设备
       size = img.size(0) # 获取每一个批次的大小
       random_noise = torch.randn(size, 100, device=device)  # 随机噪声的大小是size个
       
       d_optim.zero_grad() # 将判别器前面的梯度归0
       
       real_output = dis(img)      # 判别器输入真实的图片，real_output是对真实图片的预测结果 
       
       # 得到判别器在真实图像上的损失
       # 判别器对于真实的图片希望输出的全1的数组，将真实的输出与全1的数组进行比较
       d_real_loss = loss_fn(real_output, 
                             torch.ones_like(real_output))      
       d_real_loss.backward() # 求解梯度
       
       
       gen_img = gen(random_noise)    
       # 判别器输入生成的图片，fake_output是对生成图片的预测
       # 优化的目标是判别器，对于生成器的参数是不需要做优化的，需要进行梯度阶段，detach()会截断梯度，
       # 得到一个没有梯度的Tensor，这一点很关键
       fake_output = dis(gen_img.detach()) 
       # 得到判别器在生成图像上的损失
       d_fake_loss = loss_fn(fake_output, 
                             torch.zeros_like(fake_output))      
       d_fake_loss.backward() # 求解梯度
       
       d_loss = d_real_loss + d_fake_loss # 判别器总的损失等于两个损失之和
       d_optim.step() # 进行优化
       
       g_optim.zero_grad() # 将生成器的所有梯度归0
       fake_output = dis(gen_img) # 将生成器的图片放到判别器中，此时不做截断，因为要优化生成器
       # 生层器希望生成的图片被判定为真
       g_loss = loss_fn(fake_output, 
                        torch.ones_like(fake_output))      # 生成器的损失
       g_loss.backward() # 计算梯度
       g_optim.step() # 优化
       
       # 将损失累加到定义的数组中，这个过程不需要计算梯度
       with torch.no_grad():
           d_epoch_loss += d_loss
           g_epoch_loss += g_loss
     
   # 计算每个epoch的平均loss，仍然使用这个上下文关联器
   with torch.no_grad():
       # 计算平均的loss值
       d_epoch_loss /= count
       g_epoch_loss /= count
       # 将平均loss放入到loss数组中
       D_loss.append(d_epoch_loss.item())
       G_loss.append(g_epoch_loss.item())
       # 打印当前的epoch
       print('Epoch:', epoch)
       # 调用绘图函数
       gen_img_plot(gen, epoch, test_input)

小结

本周阅读的文献提出了iTransformer，其将不同来源的数据分别进行编码后输入网络，该网络使用残差操作、多头注意力层、层归一化等操作处理数据，对于该模型的具体分析如下：

1. 对 Transformer 的架构进行了反思，并细化了原生 Transformer 组件在多元时间序列上的能力尚未得到充分开发。
2. 提出iTransformer，将独立时间序列视为令牌，通过自注意力捕获多元相关性，并利用层归一化和前馈网络模块来学习更好的序列全局表示以进行时间序列预测。
3. 通过实验，iTransformer 在实际基准测试中达到了最先进的水平。广泛分析了倒置模块和架构选择，为基于 Transformer 的预测器的未来改进指明了一个有希望的方向。

参考文献

[1] Yong Liu, Tengge Hu, Haoran Zhang, Haixu Wu, Shiyu Wang, Lintao Ma, [Mingsheng Long](, “iTransformer: Inverted Transformers Are Effective for Time Series Forecasting” [C], https://openreview.net/forum?id=JePfAI8fah