机器学习周报第三十八周 iTransformer

最新推荐文章于 2024-08-14 13:59:47 发布
最新推荐文章于 2024-08-14 13:59:47 发布
阅读量1.4k 收藏 38
点赞数 10
文章标签： 机器学习 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44162879/article/details/138763449
版权

文章目录

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

总体框架如下

image-20240511204832624

各层操作简述：

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

伪码如下

image-20240511205137438

8831eccd0817032cacc6c924392b478

500a0327c0091bb6ad17381c9b52b81

转置Embedding：

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

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

image-20240511223246503

在iTransformer中，基于回溯序列 X : , n X_{:,n} X:,n​预测每个特定变量 Y ^ : , n \hat Y{:,n} Y^:,n的未来序列的过程简单地表述如下：
h n 0 = Embedding ( X : , n ) , H l + 1 = TrmBlock ( H l ) , l = 0 , … , L − 1 , Y ^ = Projection ( h n L ) h^0_n=\text{Embedding}(X_{:,n}),\\ \mathbf H^{l+1}=\text{TrmBlock}(\mathbf H^l),l=0,\dots,L-1,\\ \mathbf {\hat Y}=\text{Projection}(h^L_n) hn0​=Embedding(X:,n​),Hl+1=TrmBlock(Hl),l=0,…,L−1,Y^=Projection(hnL​)

LayerNorm（层归一化）

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

image-20240511223421191

在提出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是计算序列内的全局表示。通过反向块的堆叠，致力于对观测到的时间序列进行编码，并使用密集的非线性连接对未来序列的表示进行解码。

image-20240511223707637

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

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

image-20240511223800770

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

4. 文献解读

4.1 Introduction

image-20240511201852371

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

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

image-20240511202140289

通过实验，所提出的 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组件能够胜任时间建模和多变量相关，并且所提出的倒置架构可以有效地处理真实世界的时间序列预测场景。

image-20240511224306989

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

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

image-20240511224401400

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

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

image-20240511224504129

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

沽漓酒江
关注
Transformer模型 | iTransformer时序预测
算法如诗的博客
10-25 1751
Transformer模型 | iTransformer时序预测
[Python从零到壹] 十二.机器学习之回归分析万字总结全网首发（线性回归、多项式回归、逻辑回归）
杨秀璋的专栏
07-03 4万+
前一篇文章讲述了数据分析部分，主要普及网络数据分析的基本概念，讲述数据分析流程和相关技术，同时详细讲解Python提供的若干第三方数据分析库，包括Numpy、Pandas、Matplotlib、Sklearn等。本文介绍回归模型的原理知识，包括线性回归、多项式回归和逻辑回归，并详细介绍Python Sklearn机器学习库的LinearRegression和LogisticRegression算法及回归分析实例。进入基础文章，希望对您有所帮助。
iTransformer：用于时间序列预测的倒置Transformer
zuiyishihefang的博客
03-19 3379
文章信息论文题目为《ITRANSFORMER: INVERTED TRANSFORMERS ARE EFFECTIVE FOR TIME SERIES FORECASTING》，该文发表于2024ICLR会议上。文章提出了一种倒置Transformer，旨在解决Transformer在长时多变量时间序列预测所遇到的挑战。摘要最近线性预测模型在时间序列领域的发展对基于Transformer架构的改进...
Transformer模型解析（附案例应用代码）
最新发布
LIUMAO99的博客
08-14 3791
自注意力机制是Transformer模型的核心，它允许模型在编码每个单词时同时关注序列中的其他单词，从而捕捉到单词之间的依赖关系。位置编码的生成使用了正弦和余弦函数的不同频率，以确保编码在不同维度上具有不同的模式，从而使模型能够区分不同位置的单词。这样，每个头可以学习到序列的不同方面，最终的输出是所有头输出的连接和线性变换的结果。通过结合残差连接和层归一化，Transformer模型能够有效地训练深层网络，同时保持稳定的梯度流动和良好的特征分布，这对于理解和生成复杂的序列数据至关重要。
Transformer 模型详解
热门推荐
步入人工智能
05-29 27万+
本内容主要介绍 Transformer 模型的具体实现。
第四十六周：文献阅读+itransfomer
m0_66015895的博客
03-31 956
本周阅读的文献《Inverted Transformers are Effective for Time Series Forecasting》中，提出了一种更利于时间序列预测的转置transformer模型，即iTransformer。文章作者认为Transformer并非不适合于时间序列预测任务，而是没有“正确使用”Transformer。
Transformer模型详解
人无远虑，必有近忧
01-19 2万+
transformer结构是google在2017年的Attention Is All You Need论文中提出，在NLP的多个任务上取得了非常好的效果，可以说目前NLP发展都离不开transformer。最大特点是抛弃了传统的CNN和RNN，整个网络结构完全是由Attention机制组成。 由于其出色性能以及对下游任务的友好性或者说下游任务仅仅微调即可得到不错效果，在计算机视觉领域不断有人尝试将transformer引入，近期也出现了一些效果不错的尝试，典型的如目标检测领域的detr和可变形detr，分
一文彻底搞懂 Transformer（图解+代码手撕）
2201_75499313的博客
04-21 4127
Transformer 通过其捕捉上下文和理解语言的能力，彻底改变了自然语言处理（NLP）领域。通过注意力机制、编码器-解码器架构和多头注意力，它们使得诸如机器翻译和情感分析等任务得以在前所未有的规模上实现。随着我们继续探索诸如 BERT 和 GPT 等模型，很明显，Transformer 处于语言理解和生成的前沿。它们对 NLP 的影响深远，而与 Transformer 一起的发现之旅将揭示出该领域更多令人瞩目的进展。研究论文。
Transformer模型详细介绍
白话机器学习
03-08 1087
该框架在Transformer上实现了平均38.9%的提升，在Reformer上实现了36.1%的提升，在Informer上实现了28.5%的提升，在Flowformer上实现了16.8%的提升，在Flashformer上实现了32.2%的提升。前馈网络独立应用于变量标记，学习共享和转移的时间序列模式。我们在图5中评估了Transformers和iTransformer在增加回溯长度情况下的性能，发现利用MLP在时间维度上更合理，使得Transformers可以从扩展的回溯窗口中受益，进行更精确的预测。
国科大网安学院机器学习（周晓飞）202年期末考试题库
01-03
想要复习机器学习等一些知识的学生参考
《机器学习(周志华)》学习笔记.pdf
05-12
138页的内容，完整记录了学周志华西瓜书《机器学习》16个篇章的学习和体会。
基于机器学习的二型糖尿病预测系统完整源码+说明（django系统框架+半监督GMM算法处理+周报、月报和年报).zip
03-30
【资源说明】 1、该资源内项目代码都是经过测试运行成功，功能正常的...基于机器学习的二型糖尿病预测系统源码+说明（django系统框架+半监督GMM算法处理+最终统计数据按时间以周报、月报和年报的形式展示给用户).zip
时间序列机器学习论文：iTransformer
thorn_r的博客
11-10 2492
本文反思了为什么Transformer模型在时间序列预测的问题上没有传统的线性模型效果好。文章作者认为，Transformer并非不适合于时间序列预测任务，而是以往的研究者没有“正确使用”Transformer。在没有大改Transformer模型的情况下，通过将输入Embedding的进行转置，使得自注意力层与前向层所提取的特征进行了互换，经过试验发现无论是预测效果还是模型可解释性都大大提高了，论文具有一定指导意义，这个转置的技巧也可以用在以往的模型之中。
透彻理解大模型框架：Transformer模型原理详解与机器翻译
zql1009的博客
05-15 1万+
已知神经网络权重：W_q, W_k, W_v。
Transformer革新：Infini-Transformer在长文本处理中的突破
人工智能讲师分享前沿技术
06-18 1179
由于其注意力机制的二次方复杂度，随着输入序列的增长，所需的内存和计算资源呈指数级增加，这不仅限制了模型处理长文本的能力，也带来了巨大的经济成本。Infini-Transformer的记忆占用是固定的，这意味着它可以在不增加额外内存成本的情况下处理更长的输入序列。实验结果显示，Infini-Transformer不仅能够在极长的文本中准确地找到passkey，而且在经过微调后，其检索能力得到了显著提升，证明了Infini-attention在处理具有挑战性的长文本检索任务中的潜力。
Transformer 大模型详解——transformer模型
zhishi0000的博客
06-30 4399
解码器栈的输出是一个 float 向量。我们怎么把这个向量转换为一个词呢？通过一个线性层再加上一个 Softmax 层实现。线性层是一个简单的全连接神经网络，其将解码器栈的输出向量映射到一个更长的向量，这个向量被称为 logits 向量。现在假设我们的模型有 10000 个英文单词（模型的输出词汇表）。因此 logits 向量有 10000 个数字，每个数表示一个单词的分数。然后，Softmax 层会把这些分数转换为概率（把所有的分数转换为正数，并且加起来等于 1）。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值