精华内容
下载资源
问答
  • 时间卷积网络
    千次阅读
    2020-06-12 18:06:43

    TCN时间卷积网络

    参考使用的benchmark:
    https://github.com/locuslab/TCN

    包含多种分类、预测样例,基于pytorch环境。

    Introduction

    通常序列模型问题都是使用循环神经网络解决的,然而最近一些结果发现卷积神经网络在序列问题上可以实现超过循环神经网络的结果。一般在研究的时候都会把循环神经网络作为一个序列模型任务的起始点,但是现在我们要选择卷积神经网络。于是就产生了一个问题:卷积序列模型的成功是否和特定的应用领域有关,序列处理和循环网络之间的关联是否可以重新考虑。

    论文作者通过在一系列序列模型任务上进行对卷积结构和循环结构的比较解决了这一问题。这些任务包括音乐模型、语言模型和合成测试等。作者使用时序卷积模型TCN和LSTMs GRU等模型进行比较,结果显示TCN模型超过了这些循环神经网络结构。这也证明了卷积结构最近在音频处理上的成果不代表其只适用于该领域。

    Temporal Convolutional Networks

    我们从一个卷积序列预测的一般架构开始。这个模型被称为时间卷积网络,这个概念指的不是一个架构,而是一种类型的架构。TCN网络的特性包括:1. 卷积中的关系是因果关系,意味着不存在从未来到过去的信息。2. 这个架构可以用任意长的序列作为输入并映射到相同长度的输出上,就像RNN一样。此外,作者强调了如何构建一个长且有效的历史大小,使用残差层和空洞卷积的技术。

    sequence modeling

    在定义网络结构之前,我们先解释一下序列模型任务。假设我们被给定了一个输入序列并且想要预测对应的结果。核心的制约是,预测一个输出的时候,我们只能使用这个时间之前的观察。一个序列模型网络通常指的是能产生以下映射的一个函数: y ^ 0 , . . . , y ^ T = f ( x 0 , . . . , x T ) \hat{y}_0,...,\hat{y}_T=f(x_0,...,x_T) y^0,...,y^T=f(x0,...,xT)
    目标是找到一个网络最小化真实输出和预测之间的损失,其中输入序列和输出都遵循某个分布。这个形式包括了多种设置,比如自回归预测,目标输出是将输入平移一步得到的。而这种不适合机器翻译或者序列-序列预测,因为输入的序列中包含了“未来”状态。

    causal convolutions

    TCN是基于两个原则的:网络产生和输入一样长的输出,不存在从未来到现在的信息。为了实现这一点,TCN使用了1维全卷积网络架构,每个隐藏层和输入层长度都一样,并加入了padding来保持后续层的长度。

    简单来说:TCN=1D FCN + causal convolutions

    这个设计的主要缺点是为了实现长而有效的历史记录,我们需要一个特别深的网络或者非常大的滤波器,在这个模型刚提出来的时候以上两点都不能实现,因此接下来的部分会介绍帮助TCN模型达成这两个点的技巧。

    dilated convolutions

    一个简单的因果卷积只能够回顾和网络深度呈线性关系的大小的历史。这使得上述的因果卷积在序列任务上遇到挑战,尤其在要求比较长的历史记录的时候。
    作者的解决办法,使用了具有扩大感受野能力的空洞卷积。对于一个1维的序列,和一个滤波器,空洞卷积在序列中每个元素s上的操作可以定义为: F ( s ) = ( x ∗ d f ) ( s ) = ∑ i = 0 k − 1 f ( i ) ∗ x s = d ∗ i F(s)=(x*_df)(s)=\sum^{k-1}_{i=0}f(i)*x_{s=d*i} F(s)=(xdf)(s)=i=0k1f(i)xs=di
    d在这里是空洞因子,k是滤波器大小,s-d*i指示了过去的方向。具体不讲了空洞卷积也算是个常识。这就给了我们两个方法来提高感受野:1. 选择较大的核,2. 提供空洞因子。一个这样一层对应的有效历史是(k-1)d长,当使用空洞卷积时,这个d可以随着网络的深度指数型增长。

    residual connections

    一个残差块包含了一个指向transformation操作的分支F,他的输出和原始输入相加: o = A c t i v a t i o n ( x + F ( x ) ) o=Activation(x+F(x)) o=Activation(x+F(x))

    这句话意思理解了但是翻译不出来-this effectively allows layers to learn modifications to the identity mapping rather than entire transformation, which has repeatedly been shown to benefit very deep networks. 大致意思就是加上输入后对学习的过程有帮助。

    TCN的感受野由网络深度n核核大小k和空洞因子d,对更深和更大的TCN来说稳定性是十分重要的。比如,在预测结果依赖于2的12次方大小的历史和一个高维输入序列时,需要一个12层的网络。并且每一层都有用来提取特征的多个滤波器。在TCN中输入和输出大小不一样,所以我们用了 1x1卷积使得它们具有相同的大小。

    Discussion

    我们列出了我们的TCN在序列模型上应用的一些优点和缺点。
    以下部分是优点

    1. parallelism:
      不像RNN对后面时间戳的预测需要等前面的步骤都完成,CNN可以平行地进行,因为每一层用的是一样的滤波器。因此一个长序列可以当作一个整体进行处理,而不是像在RNN中一样按顺序进行。
    2. flexible receptive field size:
      一个TCN能够用多种方法改变它的感受野大小,比如:堆叠更多的空洞卷积层,使用更大的空洞因子,提高滤波器大小。因此TCN也能够更好的控制模型的内存大小并应用到多个领域。
    3. stable gradients:
      不像循环结构,TCN具有一个和序列时间方向不同的bp路径,因此TCN可以避免梯度爆炸梯度消失等问题,而这是RNN的主要问题之一。
    4. low memory requirement for training:
      尤其对于长序列,LSTM和GRU需要使用大量的内存来存储中间结果,然而在TCN中滤波器是共享的,bp路径只和网络的深度有关系。因此我们发现RNN通常内存占用要比TCN多几倍。
    5. variable length inputs:
      像RNN可以用变长序列作为输入,TCN也可以将任意长序列作为属于通过滑动1D卷积核。这意味着TCN可以取代RNN用来处理任意长度的有序数据。

    以下部分是缺点

    1. data storage during evaluation:
      在验证或测试阶段,RNNs只需要保证隐藏层状态和一个当前输入来产生一个预测,换句话说只需要一个对历史的总结,而实际的观察到的序列是可以忽略的。相反的,TCN需要放入所有的序列,因此可能需要更多的内存。
    2. potential parameter change for a transfer of domain:
      不同的领域对模型的历史的量有不同的要求,因此模型在对内存要求不一致的不同领域转换时,TCN表现可能会比较差。
    更多相关内容
  • SCI论文中所用代码,数据加程序,使用时间卷积网络建立预测模型进行预测,比LSTM、CNN等效果精确。
  • 使用卷积神经网络处理时间序列,属于最新的处理模型,非常适合处理时间序列
  • 时域卷积网络(TCN)案例模型,tcn时间卷积网络,Python源码.zip.zip
  • 在实际应用中,RNN 在内部设计上存在一个严重的问题:由于网络一次只能处理一个时间步长,后一步必须等前一步处理完才能进行运算。这意味着 RNN 不能像 CNN 那样进行大规模并行处理,特别是在 RNN/LSTM 对文本进行...

    1 前言

            实验表明,RNN 在几乎所有的序列问题上都有良好表现,包括语音/文本识别、机器翻译、手写体识别、序列数据分析(预测)等。

            在实际应用中,RNN 在内部设计上存在一个严重的问题:由于网络一次只能处理一个时间步长,后一步必须等前一步处理完才能进行运算。这意味着 RNN 不能像 CNN 那样进行大规模并行处理,特别是在 RNN/LSTM 对文本进行双向处理时。这也意味着 RNN 极度地计算密集,因为在整个任务运行完成之前,必须保存所有的中间结果。

            CNN 在处理图像时,将图像看作一个二维的“块”(m*n 的矩阵)。迁移到时间序列上,就可以将序列看作一个一维对象(1*n 的向量)。通过多层网络结构,可以获得足够大的感受野。这种做法会让 CNN 非常深,但是得益于大规模并行处理的优势,无论网络多深,都可以进行并行处理,节省大量时间。这就是 TCN 的基本思想。

    1.1 RNN的问题

    LightRNN:高效利用内存和计算的循环神经网络_曼陀罗彼岸花的博客-CSDN博客

    将RNN内存占用缩小90%:多伦多大学提出可逆循环神经网络:将RNN内存占用缩小90%:多伦多大学提出可逆循环神经网络 - 知乎

             循环神经网络(RNN)在处理序列数据方面取得了当前最佳的性能表现,但训练时需要大量内存需要存储隐藏状态

            最近,循环神经网络(RNN)已被用于处理多种自然语言处理(NLP)任务,例如语言建模、机器翻译、情绪分析和问答。有一种流行的 RNN 架构是长短期记忆网络(LSTM),其可以通过记忆单元(memory cell)和门函数(gating function)建模长期依赖性和解决梯度消失问题。因为这些元素,LSTM 循环神经网络在当前许多自然语言处理任务中都实现了最佳的表现,尽管它的方式几乎是从头开始学习。

            虽然 RNN 越来越受欢迎,但它也存在一个局限性:当应用于大词汇的文本语料库时,模型的体量将变得非常大。比如说,当使用 RNN 进行语言建模时,词首先需要通过输入嵌入矩阵(input-embedding matrix)从 one-hot 向量(其维度与词汇尺寸相同)映射到嵌入向量。然后为了预测下一词的概率,通过输出嵌入矩阵(output-embedding matrix)将顶部隐藏层投射成词汇表中所有词的概率分布。当该词汇库包含数千万个不同的词时(这在 Web 语料库中很常见),这两个嵌入矩阵就会包含数百亿个不同的元素,这会使得 RNN 模型变得过大,从而无法装进 GPU 设备的内存。以 ClueWeb 数据集为例,其词汇集包含超过 1000 万词。如果嵌入向量具有 1024 个维度并且每个维度由 32 位浮点表示,则输入嵌入矩阵的大小将为大约 40GB。进一步考虑输出嵌入矩阵和隐藏层之间的权重,RNN 模型将大于 80GB,这一数字远远超出了市面上最好的 GPU 的能力。

             即使 GPU 的内存可以扩容,用于训练这样体量模型的计算复杂度也将高到难以承受。在 RNN 语言模型中,最耗时的运算是计算词汇表中所有词的概率分布,这需要叠乘序列每个位置处的输出嵌入矩阵和隐藏状态。简单计算一下就可以知道,需要使用目前最好的单 GPU 设备计算数十年才能完成 ClueWeb 数据集语言模型的训练。此外,除了训练阶段的难题,即使我们最终训练出了这样的模型,我们也几乎不可能将其装进移动设备让它进入应用。

    1.2 TCN背景

            到目前为止,深度学习背景下的序列建模主题主要与递归神经网络架构(如LSTM和GRU)有关。S.  Bai等人(*)认为,这种思维方式已经过时,在对序列数据进行建模时,应该将卷积网络作为主要候选者之一加以考虑。他们能够表明,在许多任务中,卷积网络可以取得比RNNs更好的性能,同时避免了递归模型的常见缺陷,如梯度爆炸/消失问题或缺乏内存保留。此外,使用卷积网络而不是递归网络可以提高性能,因为它允许并行计算输出。他们提出的架构称为时间卷积网络(TCN),将在下面的部分中进行解释。

              TCN是指时间卷积网络,一种新型的可以用来解决时间序列预测的算法。

              该算法于2016年由Lea等人首先提出,当时他们在做视频动作分割的研究,一般而言此常规过程包括两个步骤:首先,使用(通常)对时空信息进行编码的CNN来计算低级特征,其次,将这些低级特征输入到使用(通常是)捕获高级时域信息的分类器中)RNN。这种方法的主要缺点是需要两个单独的模型。

             TCN提供了一种统一的方法来分层捕获所有两个级别的信息。

             自从TCN提出后引起了巨大反响,有人认为:时间卷积网络(TCN)将取代RNN成为NLP或者时序预测领域的王者。

             DataScienceCentral 的编辑主任William Vorhies给出的原因如下:

              RNN耗时太长,由于网络一次只读取、解析输入文本中的一个单词(或字符),深度神经网络必须等前一个单词处理完,才能进行下一个单词的处理。这意味着 RNN 不能像 CNN 那样进行大规模并行处理;并且TCN的实际结果也要优于RNN算法。

             TCN可以采用一系列任意长度并将其输出为相同长度。在使用一维完全卷积网络体系结构的情况下,使用因果卷积。一个关键特征是,时间t的输出仅与t之前发生的元素卷积。

    TCN特点

    TCN 模型以 CNN 模型为基础,并做了如下改进:

    1. 适用序列模型:因果卷积(Causal Convolution)
    2. 记忆历史:空洞卷积/膨胀卷积(Dilated Convolution),残差模块(Residual block)

    下面将分别介绍 CNN 的扩展技术。

    TCN的特点

    1. 因果卷积网络
    2. 膨胀卷积方式(扩张卷积、空洞卷积)Dilated Causal Convolution
    3. 残差块
    4. 激活函数
    5. 规范化
    6. 正则化
    7. Dropout

    2.1 因果卷积(Causal Convolution)

      

             因果卷积可以用上图直观表示。 即对于上一层t时刻的值,只依赖于下一层t时刻及其之前的值。和传统的卷积神经网络的不同之处在于,因果卷积不能看到未来的数据,它是单向的结构,不是双向的。也就是说只有有了前面的因才有后面的果,是一种严格的时间约束模型,因此被成为因果卷积。

    因果卷积有两个特点:

    1. 不考虑未来的信息。给定输入序列 ,预测 。但是在预测 时,只能使用已经观测到的序列 ,而不能使用  
    2. 追溯历史信息越久远,隐藏层越多。上图中,假设我们以第二层隐藏层作为输出,它的最后一个节点关联了输入的三个节点,即  ;假设以输出层作为输出,它的最后一个节点关联了输入的五个节点。

    2.2 空洞卷积/膨胀卷积(Dilated Convolution)

            单纯的因果卷积还是存在传统卷积神经网络的问题,即对时间的建模长度受限于卷积核大小的,如果要想抓去更长的依赖关系,就需要线性的堆叠很多的层。标准的 CNN 可以通过增加 pooling 层来获得更大的感受野,而经过 pooling 层后肯定存在信息损失的问题。

            空洞卷积是在标准的卷积里注入空洞,以此来增加感受野。空洞卷积多了一个超参数 dilation rate,指的是 kernel 的间隔数量(标准的 CNN 中 dilatation rate 等于 1)。空洞的好处是不做 pooling 损失信息的情况下,增加了感受野,让每个卷积输出都包含较大范围的信息。下图展示了标准 CNN (左)和 Dilated Convolution (右),右图中的 dilatation rate 等于 2 。 

     

             和传统卷积不同的是,膨胀卷积允许卷积时的输入存在间隔采样,采样率受图中的d控制。 最下面一层的d=1,表示输入时每个点都采样,中间层d=2,表示输入时每2个点采样一个作为输入。一般来讲,越高的层级使用的d的大小越大。所以,膨胀卷积使得有效窗口的大小随着层数呈指数型增长。这样卷积网络用比较少的层,就可以获得很大的感受野。

    • d:空洞卷积的参数
    • k:层数

             因为研究对象是时间序列,TCN 采用一维的卷积网络。上图是 TCN 架构中的因果卷积与空洞卷积,可以看到每一层  时刻的值只依赖于上一层  时刻的值,体现了因果卷积的特性;而每一层对上一层信息的提取,都是跳跃式的,且逐层 dilated rate 以 2 的指数增长,体现了空洞卷积的特性。由于采用了空洞卷积,因此每一层都要做 padding(通常情况下补 0),padding 的大小为  。 

    2.3  残差模块(Residual block)

             残差链接被证明是训练深层网络的有效方法,它使得网络可以以跨层的方式传递信息。本文构建了一个残差块来代替一层的卷积。如上图所示,一个残差块包含两层的卷积和非线性映射,在每层中还加入了WeightNorm和Dropout来正则化网络。

    3 TCN时间卷积网络的预测

           给定input_length, kernel_size, dilation_base和覆盖整个历史所需的最小层数,基本的TCN网络看起来像这样:

            到目前为止,我们只讨论了‘输入序列’和‘输出序列’,而没有深入了解它们之间是如何相互关联的。在预测方面,我们希望预测未来时间序列的下一个条目。为了训练我们的TCN网络进行预测,训练集将由给定时间序列的等大小子序列对(输入序列、目标序列)组成。

            即 input series = target series

            目标序列将是相对于其各自的输入序列向右移动一定数量output_length的序列。这意味着长度input_length的目标序列包含其各自输入序列的最后(input_length - output_length)元素作为第一个元素,位于输入序列最后一个条目之后的output_length元素作为它的最后一个元素。在预测方面,这意味着该模型所能预测的最大预测视界等于output_length。使用滑动窗口的方法,许多重叠的输入和目标序列可以创建出一个时间序列。

     4 TCN 进行序列建模的几个优点和缺点

    优点

    1. 并行性(Parallelism)。与在 RNN 中对后续时间步的预测必须等待其前任完成的情况不同,卷积可以并行完成,因为每一层都使用相同的滤波器。因此,在训练和评估中,长输入序列可以在 TCN 中作为一个整体进行处理,而不是像在 RNN 中那样按顺序处理。
    2. 灵活的感受野大小(Flexible receptive field size)。TCN 可以通过多种方式改变其感受野大小。例如,堆叠更多扩张(因果)卷积层、使用更大的膨胀因子或增加滤波器大小都是可行的选择(可能有不同的解释)。因此,TCN 可以更好地控制模型的内存大小,并且易于适应不同的领域。
    3. 稳定的梯度(Stable gradients)。与循环架构不同,TCN 的反向传播路径与序列的时间方向不同。因此,TCN 避免了梯度爆炸/消失的问题,这是 RNN 的一个主要问题,并导致了 LSTM、GRU、HF-RNN(Martens & Sutskever,2011)等的发展。
    4. 训练时内存要求低。特别是在输入序列较长的情况下,LSTM 和 GRU 很容易占用大量内存来存储它们的多个单元门的部分结果。而在 TCN 中,滤波器跨层共享,反向传播路径仅取决于网络深度。因此,在实践中,我们发现门控 RNN 可能比 TCN 使用更多的内存。
    5. 可变长度输入。就像 RNN 以循环方式对可变长度的输入进行建模一样,TCN 也可以通过滑动 1D 卷积核来接收任意长度的输入。这意味着 TCN 可以作为 RNN 的替代品,用于任意长度的序列数据。

    使用 TCN 也有两个明显的缺点

    1. 评估期间的数据存储。在评估/测试中,RNN 只需保持隐藏状态并获取当前输入 xt 即可生成预测。换句话说,整个历史的“摘要”由一组固定长度的向量 ht 提供,而实际观察到的序列可以被丢弃。相比之下,TCN 需要接收到有效历史长度的原始序列,因此在评估期间可能需要更多内存。
    2. 域迁移的潜在参数变化(Potential parameter change for a transfer of domain)。不同领域对模型预测所需的历史数量可能有不同的要求。因此,当将模型从只需要很少内存的域(即小 k 和 d)转移到需要更长内存的域(即大得多的 k 和 d)时,TCN 可能会因为没有足够大的感受野。

     论文《An Empirical Evaluation of Generic Convolutional and Recurrent Networks for Sequence Modeling》:https://arxiv.org/pdf/1803.01271.pdf

    TCN 时间卷积网络:TCN 时间卷积网络 - 知乎

    时域卷积网络TCN详解:使用卷积进行序列建模和预测:时域卷积网络TCN详解:使用卷积进行序列建模和预测_deephub的博客-CSDN博客_tcn时间卷积网络

    时空卷积网络TCN时空卷积网络TCN - USTC丶ZCC - 博客园

    Darts实现TCN(时域卷积网络): https://blog.csdn.net/liuhaikang/article/details/119704701?spm=1001.2014.3001.5501

    TCN-时间卷积网络:https://blog.csdn.net/qq_27586341/article/details/90751794?utm_medium=distribute.pc_relevant.none-task-blog-2~default~BlogCommendFromMachineLearnPai2~default-4.base&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2~default~BlogCommendFromMachineLearnPai2~default-4.base

    多变量时间序列、预训练模型和协变量:

    多变量时间序列、预训练模型和协变量_liuhaikang的博客-CSDN博客_多变量时间序列模型

    展开全文
  • TCN-时间卷积网络

    万次阅读 多人点赞 2019-06-03 14:42:01
    二、时序卷积神经网络 2.1 因果卷积(Causal Convolution) 2.2 膨胀卷积(Dilated Convolution) 2.3 残差链接(Residual Connections) 三、讨论和总结 1. TCN的优点 2. TCN的缺点 参考论文:An Empirical ...

    目录

    一、引言

    二、时序卷积神经网络

    2.1 因果卷积(Causal Convolution)

    2.2 膨胀卷积(Dilated Convolution)

    2.3 残差链接(Residual Connections)

    三、讨论和总结

    1. TCN的优点

    2. TCN的缺点


    参考论文:An Empirical Evaluation of Generic Convolutional and Recurrent Networks for Sequence Modeling

    Github:https://github.com/LOCUSLAB/tcn

    参考链接:

           序列建模之时间卷积网络TCN - 杨镒铭的文章 - 知乎

          TCN时间卷积网络 - 剪水作花飞的文章 - 知乎

           时间卷积网络(TCN)在 NLP 多领域发光,RNN 或将没落

    一、引言

           时序问题的建模大家一般习惯性的采用循环神经网络(RNN)来建模,这是因为RNN天生的循环自回归的结构是对时间序列的很好的表示。传统的卷积神经网络一般认为不太适合时序问题的建模,这主要由于其卷积核大小的限制,不能很好的抓取长时的依赖信息。 但是最近也有很多的工作显示,特定的卷积神经网络结构也可以达到很好的效果,比如Goolgle提出的用来做语音合成的wavenet,Facebook提出的用来做翻译的卷积神经网络。这就带来一个问题,用卷积来做神经网络到底是只适用于特定的领域还是一种普适的模型? 本文就带着这个问题,将一种特殊的卷积神经网络——时序卷积网络(Temporal convolutional network, TCN)与多种RNN结构相对比,发现在多种任务上TCN都能达到甚至超过RNN模型。

    二、时序卷积神经网络

    2.1 因果卷积(Causal Convolution)

                        preview

            因果卷积可以用上图直观表示。 即对于上一层t时刻的值,只依赖于下一层t时刻及其之前的值。和传统的卷积神经网络的不同之处在于,因果卷积不能看到未来的数据,它是单向的结构,不是双向的。也就是说只有有了前面的因才有后面的果,是一种严格的时间约束模型,因此被成为因果卷积。

    2.2 膨胀卷积(Dilated Convolution)

           单纯的因果卷积还是存在传统卷积神经网络的问题,即对时间的建模长度受限于卷积核大小的,如果要想抓去更长的依赖关系,就需要线性的堆叠很多的层。为了解决这个问题,研究人员提出了膨胀卷积。如下图所示。

                                    preview

            和传统卷积不同的是,膨胀卷积允许卷积时的输入存在间隔采样,采样率受图中的d控制。 最下面一层的d=1,表示输入时每个点都采样,中间层d=2,表示输入时每2个点采样一个作为输入。一般来讲,越高的层级使用的d的大小越大。所以,膨胀卷积使得有效窗口的大小随着层数呈指数型增长。这样卷积网络用比较少的层,就可以获得很大的感受野。

    2.3 残差链接(Residual Connections)

                    preview

            残差链接被证明是训练深层网络的有效方法,它使得网络可以以跨层的方式传递信息。本文构建了一个残差块来代替一层的卷积。如上图所示,一个残差块包含两层的卷积和非线性映射,在每层中还加入了WeightNorm和Dropout来正则化网络。

    三、讨论和总结

           总体来讲,TCN模型上的创新并不是很大,因果卷积和扩展卷积也并不是本论文提出来,本文主要是将TCN的结构梳理了一下,相比于wavenet中的结构,去掉了门机制,加入了残差结构,并在很多的序列问题上进行了实验。实验效果如下:

                  

    在多个任务上,都比标准的LSTM、GRU等效果好。

    1. TCN的优点

        (1)并行性。当给定一个句子时,TCN可以将句子并行的处理,而不需要像RNN那样顺序的处理。

        (2)灵活的感受野。TCN的感受野的大小受层数、卷积核大小、扩张系数等决定。可以根据不同的任务不同的特性灵活定制。

        (3)稳定的梯度。RNN经常存在梯度消失和梯度爆炸的问题,这主要是由不同时间段上共用参数导致的,和传统卷积神经网络一样,TCN不太存在梯度消失和爆炸问题。

        (4)内存更低。RNN在使用时需要将每步的信息都保存下来,这会占据大量的内存,TCN在一层里面卷积核是共享的,内存使用更低。

    2. TCN的缺点

        (1)TCN 在迁移学习方面可能没有那么强的适应能力。这是因为在不同的领域,模型预测所需要的历史信息量可能是不同的。因此,在将一个模型从一个对记忆信息需求量少的问题迁移到一个需要更长记忆的问题上时,TCN 可能会表现得很差,因为其感受野不够大。

        (2)论文中描述的TCN还是一种单向的结构,在语音识别和语音合成等任务上,纯单向的结构还是相当有用的。但是在文本中大多使用双向的结构,当然将TCN也很容易扩展成双向的结构,不使用因果卷积,使用传统的卷积结构即可。

        (3)TCN毕竟是卷积神经网络的变种,虽然使用扩展卷积可以扩大感受野,但是仍然受到限制,相比于Transformer那种可以任意长度的相关信息都可以抓取到的特性还是差了点。TCN在文本中的应用还有待检验。

    展开全文
  • 1、TCN(时域卷积网络、时间卷积网络)是干嘛的,能干嘛 主要应用方向: 时序预测、概率预测、时间预测、交通预测 2、TCN的由来 ps:在了解TCN之前需要先对CNN和RNN有一定的了解。 处理问题: 是一种能够处理...

    TCN 从“阿巴阿巴”到“巴拉巴拉”

    • TCN的概念(干嘛来的!能解决什么问题)
    • TCN的父母(由来)
    • TCN的原理介绍
    • 上代码!

    1、TCN(时域卷积网络、时间卷积网络)是干嘛的,能干嘛

    • 主要应用方向:

    时序预测、概率预测、时间预测、交通预测

    2、TCN的由来

    ps:在了解TCN之前需要先对CNN和RNN有一定的了解。

    • 处理问题:

    是一种能够处理时间序列数据的网络结构,在特定条件下,效果优于传统的神经网络(RNN、CNN等)。

    3、TCN的原理介绍

    TCN 的网络结构

    请添加图片描述

    一、TCN的网络结构主要由上图构成。本文分为左边和右边两部分,首先是左边

    Dilated Causal Conv ---> WeightNorm--->ReLU--->Dropout--->Dilated Causal Conv ---> WeightNorm--->ReLU--->Dropout
    

    很明显这个可以分为

    (Dilated Causal Conv ---> WeightNorm--->ReLU--->Dropout)*2
    

    ok,下面我们对这四个逐个进行讲解,如有了解可以选择跳读

    1、Dilated Gausal Conv

    中文名:膨胀因果卷积

    膨胀因果卷积可以分为膨胀因果卷积三部分。

    卷积是指 CNN中的卷积,是指卷积核在数据上进行的一种滑动运算操作;

    膨胀是指 允许卷积时的输入存在间隔采样,其和卷积神经网络中的stride有相似之处,但也有很明显的区别

    图片说明:

    请添加图片描述

    因果是指 第i层中t时刻的数据,只依赖与(i-1)层t时刻及其以前的值的影响。因果卷积可以在训练的时候摒弃掉对未来数据的读取,是一种严格的时间约束模型。

    图片说明:

    请添加图片描述

    ​ (ps:没有加入膨胀卷积)

    2、WeightNorm

    权重归一化

    对权重值进行归一化,如果有想仔细研究归一化过程&归一化公式的,可以点击链接进行学习

    点击

    优点:

    1、时间开销小,运算速度快!

    2、引入更少的噪声

    3、WeightNorm是通过重写深度网络的权重来进行加速的,没有引入对minibatch的依赖

    3、ReLU()

    激活函数的一种

    优点:

    1、可以使网络的训练速度更快

    2、增加网络的非线性,提高模型的表达能力

    3、防止梯度消失,

    4、使网络具有稀疏性等

    公式:

    在这里插入图片描述

    概述图:

    ReLU 函数

    4、Dropout()

    Dropout是指在深度学习网络的训练过程中,对于神经网络单元,按照一定的概率将其暂时从网络中丢弃。

    优点:防止过拟合,提高模型的运算速度

    二、最后是右边-残差连接

    右边是一个1*1的卷积块儿,不仅可以使网络拥有跨层传递信息的功能,而且可以保证输入输出的一致性。

    三、TCN的优点:

    1、并行性

    2、可以很大程度上避免梯度消失和梯度爆炸

    3、感受野更大,学习到的信息更多

    4、从零coding

    import os
    import sys
    import paddle
    import paddle.nn as nn
    import numpy as np
    import pandas as pd
    import seaborn as sns
    from pylab import rcParams
    import matplotlib.pyplot as plt
    from matplotlib import rc
    import paddle.nn.functional as F
    from paddle.nn.utils import weight_norm
    from sklearn.preprocessing import MinMaxScaler
    from pandas.plotting import register_matplotlib_converters
    from sourceCode import TimeSeriesNetwork
    sys.path.append(os.path.abspath(os.path.join(os.getcwd(), "../..")))
    
    class Chomp1d(nn.Layer):
        def __init__(self, chomp_size):
            super(Chomp1d, self).__init__()
            self.chomp_size = chomp_size
    
        def forward(self, x):
            return x[:, :, :-self.chomp_size]
    
    
    class TemporalBlock(nn.Layer):
        def __init__(self,
                     n_inputs,
                     n_outputs,
                     kernel_size,
                     stride,
                     dilation,
                     padding,
                     dropout=0.2):
            super(TemporalBlock, self).__init__()
            self.conv1 = weight_norm(
                nn.Conv1D(
                    n_inputs,
                    n_outputs,
                    kernel_size,
                    stride=stride,
                    padding=padding,
                    dilation=dilation))
            # Chomp1d is used to make sure the network is causal.
            # We pad by (k-1)*d on the two sides of the input for convolution,
            # and then use Chomp1d to remove the (k-1)*d output elements on the right.
            self.chomp1 = Chomp1d(padding)
            self.relu1 = nn.ReLU()
            self.dropout1 = nn.Dropout(dropout)
    
            self.conv2 = weight_norm(
                nn.Conv1D(
                    n_outputs,
                    n_outputs,
                    kernel_size,
                    stride=stride,
                    padding=padding,
                    dilation=dilation))
            self.chomp2 = Chomp1d(padding)
            self.relu2 = nn.ReLU()
            self.dropout2 = nn.Dropout(dropout)
    
            self.net = nn.Sequential(self.conv1, self.chomp1, self.relu1,
                                     self.dropout1, self.conv2, self.chomp2,
                                     self.relu2, self.dropout2)
            self.downsample = nn.Conv1D(n_inputs, n_outputs,
                                        1) if n_inputs != n_outputs else None
            self.relu = nn.ReLU()
            self.init_weights()
    
        def init_weights(self):
            self.conv1.weight.set_value(
                paddle.tensor.normal(0.0, 0.01, self.conv1.weight.shape))
            self.conv2.weight.set_value(
                paddle.tensor.normal(0.0, 0.01, self.conv2.weight.shape))
            if self.downsample is not None:
                self.downsample.weight.set_value(
                    paddle.tensor.normal(0.0, 0.01, self.downsample.weight.shape))
    
        def forward(self, x):
            out = self.net(x)
            res = x if self.downsample is None else self.downsample(x) # 让输入等于输出
            return self.relu(out + res)
    
    
    class TCNEncoder(nn.Layer):
        def __init__(self, input_size, num_channels, kernel_size=2, dropout=0.2):
            # input_size : 输入的预期特征数
            # num_channels: 通道数
            # kernel_size: 卷积核大小
            super(TCNEncoder, self).__init__()
            self._input_size = input_size
            self._output_dim = num_channels[-1]
    
            layers = nn.LayerList()
            num_levels = len(num_channels)
            # print('print num_channels: ', num_channels)
            # print('print num_levels: ',num_levels)
            # exit(0)
            for i in range(num_levels):
                dilation_size = 2 ** i
                in_channels = input_size if i == 0 else num_channels[i - 1]
                out_channels = num_channels[i]
                layers.append(
                    TemporalBlock(
                        in_channels,
                        out_channels,
                        kernel_size,
                        stride=1,
                        dilation=dilation_size,
                        padding=(kernel_size - 1) * dilation_size,
                        dropout=dropout))
    
            self.network = nn.Sequential(*layers)
    
        def get_input_dim(self):
            return self._input_size
    
    
    
        def get_output_dim(self):
            return self._output_dim
    
        def forward(self, inputs):
            inputs_t = inputs.transpose([0, 2, 1])
            output = self.network(inputs_t).transpose([2, 0, 1])[-1]
            return output
    
    
    class TimeSeriesNetwork(nn.Layer):
    
        def __init__(self, input_size, next_k=1, num_channels=[256]):
            super(TimeSeriesNetwork, self).__init__()
    
            self.last_num_channel = num_channels[-1]
    
            self.tcn = TCNEncoder(
                input_size=input_size,
                num_channels=num_channels,
                kernel_size=3,
                dropout=0.2
            )
    
            self.linear = nn.Linear(in_features=self.last_num_channel, out_features=next_k)
    
        def forward(self, x):
            tcn_out = self.tcn(x)
            y_pred = self.linear(tcn_out)
            return y_pred
    '''
    我努力把自己塑造成悲剧里面的男主角,
    把一切过错推到你的身上,
    让你成为万恶的巫婆,
    丧心病狂
    可是我就是一个正常的人,
    有悲有喜,
    有错有对,
    走到今天这个地步,
    我们都有责任,
    直到现在我还没有觉得我失去了你
    你告诉我,我失去你了么?
    '''
    def config_mtp():
        sns.set(style='whitegrid', palette='muted', font_scale=1.2)
        HAPPY_COLORS_PALETTE = ["#01BEFE", "#FFDD00", "#FF7D00", "#FF006D", "#93D30C", "#8F00FF"]
        sns.set_palette(sns.color_palette(HAPPY_COLORS_PALETTE))
        rcParams['figure.figsize'] = 14, 10
        register_matplotlib_converters()
    
    def read_data():
        df_all = pd.read_csv('./data/time_series_covid19_confirmed_global.csv')
        # print(df_all.head())
    
        # 我们将对全世界的病例数进行预测,因此我们不需要关心具体国家的经纬度等信息,只需关注具体日期下的全球病例数即可。
    
        df = df_all.iloc[:, 4:]
        daily_cases = df.sum(axis=0)
        daily_cases.index = pd.to_datetime(daily_cases.index)
        # print(daily_cases.head())
    
        plt.figure(figsize=(5, 5))
        plt.plot(daily_cases)
        plt.title("Cumulative daily cases")
        # plt.show()
    
        # 为了提高样本时间序列的平稳性,继续取一阶差分
        daily_cases = daily_cases.diff().fillna(daily_cases[0]).astype(np.int64)
        # print(daily_cases.head())
    
        plt.figure(figsize=(5, 5))
        plt.plot(daily_cases)
        plt.title("Daily cases")
        plt.xticks(rotation=60)
        plt.show()
        return daily_cases
    
    def create_sequences(data, seq_length):
        xs = []
        ys = []
        for i in range(len(data) - seq_length + 1):
            x = data[i:i + seq_length - 1]
            y = data[i + seq_length - 1]
            xs.append(x)
            ys.append(y)
        return np.array(xs), np.array(ys)
    
    def preprocess_data(daily_cases):
        TEST_DATA_SIZE,SEQ_LEN = 30,10
        TEST_DATA_SIZE = int(TEST_DATA_SIZE/100*len(daily_cases))
        # TEST_DATA_SIZE=30,最后30个数据当成测试集,进行预测
        train_data = daily_cases[:-TEST_DATA_SIZE]
        test_data = daily_cases[-TEST_DATA_SIZE:]
        print("The number of the samples in train set is : %i" % train_data.shape[0])
        print(train_data.shape, test_data.shape)
    
        # 为了提升模型收敛速度与性能,我们使用scikit-learn进行数据归一化。
        scaler = MinMaxScaler()
        train_data = scaler.fit_transform(np.expand_dims(train_data, axis=1)).astype('float32')
        test_data = scaler.transform(np.expand_dims(test_data, axis=1)).astype('float32')
    
        # 搭建时间序列
        # 可以用前10天的病例数预测当天的病例数,为了让测试集中的所有数据都能参与预测,我们将向测试集补充少量数据,这部分数据只会作为模型的输入。
        x_train, y_train = create_sequences(train_data, SEQ_LEN)
        test_data = np.concatenate((train_data[-SEQ_LEN + 1:], test_data), axis=0)
        x_test, y_test = create_sequences(test_data, SEQ_LEN)
    
        # 尝试输出
        '''
        print("The shape of x_train is: %s"%str(x_train.shape))
        print("The shape of y_train is: %s"%str(y_train.shape))
        print("The shape of x_test is: %s"%str(x_test.shape))
        print("The shape of y_test is: %s"%str(y_test.shape))
        '''
        return x_train,y_train,x_test,y_test,scaler
    
    # 数据集处理完毕,将数据集封装到CovidDataset,以便模型训练、预测时调用。
    class CovidDataset(paddle.io.Dataset):
        def __init__(self, feature, label):
            self.feature = feature
            self.label = label
            super(CovidDataset, self).__init__()
    
        def __len__(self):
            return len(self.label)
    
        def __getitem__(self, index):
            return [self.feature[index], self.label[index]]
    
    def parameter():
        LR = 1e-2
    
        model = paddle.Model(network)
    
        optimizer = paddle.optimizer.Adam(
            learning_rate=LR, parameters=model.parameters())
    
        loss = paddle.nn.MSELoss(reduction='sum')
        model.prepare(optimizer, loss)
    
    
    
    config_mtp()
    data = read_data()
    x_train,y_train,x_test,y_test,scaler = preprocess_data(data)
    train_dataset = CovidDataset(x_train, y_train)
    test_dataset = CovidDataset(x_test, y_test)
    network = TimeSeriesNetwork(input_size=1)
    
    # 参数配置
    LR = 1e-2
    
    model = paddle.Model(network)
    
    optimizer = paddle.optimizer.Adam(learning_rate=LR, parameters=model.parameters()) # 优化器
    
    loss = paddle.nn.MSELoss(reduction='sum')
    model.prepare(optimizer, loss) # Configures the model before runing,运行前配置模型
    
    # 训练
    USE_GPU = False
    TRAIN_EPOCH = 100
    LOG_FREQ = 20
    SAVE_DIR = os.path.join(os.getcwd(),"save_dir")
    SAVE_FREQ = 20
    
    if USE_GPU:
        paddle.set_device("gpu")
    else:
        paddle.set_device("cpu")
    
    model.fit(train_dataset,
        batch_size=32,
        drop_last=True,
        epochs=TRAIN_EPOCH,
        log_freq=LOG_FREQ,
        save_dir=SAVE_DIR,
        save_freq=SAVE_FREQ,
        verbose=1 # The verbosity mode, should be 0, 1, or 2.   0 = silent, 1 = progress bar, 2 = one line per epoch. Default: 2.
        )
    
    
    
    
    # 预测
    preds = model.predict(
            test_data=test_dataset
            )
    
    # 数据后处理,将归一化的数据转化为原数据,画出真实值对应的曲线和预测值对应的曲线。
    true_cases = scaler.inverse_transform(
        np.expand_dims(y_test.flatten(), axis=0)
    ).flatten()
    
    predicted_cases = scaler.inverse_transform(
      np.expand_dims(np.array(preds).flatten(), axis=0)
    ).flatten()
    print(true_cases.shape, predicted_cases.shape)
    # print (type(data))
    # print(data[1:3])
    # print (len(data), len(data))
    # print(data.index[:len(data)])
    mse_loss = paddle.nn.MSELoss(reduction='mean')
    print(paddle.sqrt(mse_loss(paddle.to_tensor(true_cases), paddle.to_tensor(predicted_cases))))
    
    print(true_cases, predicted_cases)
    
    

    如果需要数据欢迎下方评论,同时也可以私信获取。

    千万不要忘了点赞、评论、收藏,对我真的很重要偶~

    展开全文
  • 五、 参考链接: TCN-时间卷积网络 https://blog.csdn.net/qq_27586341/article/details/90751794 TCN 时间卷积网络 https://zhuanlan.zhihu.com/p/51246745?utm_source=wechat_session&utm_medium=social&s_r=0...
  • 数据预测分析 | Matlab实现TCN时间卷积网络数据预测分析 目录数据预测分析 | Matlab实现TCN时间卷积网络数据预测分析基本介绍数据下载程序设计参考资料致谢 基本介绍 此示例说明如何使用通用时间卷积网络 (TCN) 对...
  • TCN是指时间卷积网络,一种新型的可以用来解决时间序列预测的算法。在这一两年中已有多篇论文提出,但是普遍认为下篇论文是TCN的开端。 论文名称: An Empirical Evaluation of Generic Convolutional and ...
  • 基于循环时间卷积网络的序列流推荐算法.pdf
  • 基于时间卷积网络的深度聚类说话人语音分离.pdf
  • 时间卷积网络(TCN):结构+pytorch代码

    万次阅读 多人点赞 2019-08-29 10:40:44
    文章目录TCNTCN结构1-D FCN的结构因果卷积(Causal Convolutions)膨胀因果卷积(Dilated Causal Convolutions)膨胀非因果卷积(Dilated Non-Causal Convolutions)残差块结构pytorch代码讲解 TCN   TCN(Temporal ...
  • TCN时间卷积网络介绍

    万次阅读 2018-12-11 20:20:08
    TCN, Temporal Convolutional Network,时间卷积网络,是一种能够处理时间序列数据的网络结构,论文还评为2018年10大论文。 1. 模型 输入: x0,x1,...,xt{x_0, x_1,..., x_t}x0​,x1​,...,xt​; 输出:y0,y1,...,...
  • 论文代码
  • 【时间序列】时间卷积神经网络

    千次阅读 2021-05-20 00:16:48
    在深度学习的知识宝库中,除了前面文章中介绍的RNN,还有一个重要的分支:卷积神经网络(CNN),其广泛应用于视觉,视频等二维或者多维的图像领域。卷积网络具有深度,可并行等多种特性,这种技术...
  • 论文链接TCN: https://arxiv.org/pdf/1803.01271.pdfp.s. TCN stands for Temporal Convolutional Network. 它是除了 RNN architecture 之外的第二种可以分析时间性数据的架构前言RNN 从最一开始发展以来,经过不断...
  • 写在前面下面这篇文章首先主要简单介绍了目前较为先进的时间序列预测方法——时间卷积神经网络(TCN)的基本原理,然后基于TCN的开源代码,手把手教你如何通过时间卷积神经网络来进行股价预测,...
  • 其中卷积序列模块主要包括以下几个部分: 1、时间卷积网络 训练时间卷积网络预测输入时间序列的下 个值时,假设输入序列为 ,希望预测一些相应的输出 ,它的值等于输入值向前移动 个单位。在进行预测的时候主要...
  • 我们提出了一种新的神经网络,称为时间增强卷积网络(T-CN),用于基于视频的人员识别。 对于人的每个视频序列,首先将空间卷积子网应用于每个帧以表示外观信息,然后将时间卷积子网链接到连续帧的较小范围,以提取...
  • 时序预测 | MATLAB实现CNN(卷积神经网络)时间序列预测(完整源码和数据) 数据为一维时序列数据,运行环境MATLAB2018b及以上。
  • 本文回顾了 Shaojie Bai、J. Zico Kolter 和 Vladlen Koltun 撰写的论文:An Empirical Evaluation of Generic Convolutional and Recurrent Networks for Sequence Modeling... 然而,论文表明 TCN(时间卷积网络)可
  • 时间卷积网络TCN:时间序列处理的新模型

    万次阅读 多人点赞 2020-08-21 09:00:45
    Lea等人(2016)的开创性工作首次提出了用于基于视频的动作分割的时间卷积网络(tns)。这个传统的过程包括两个步骤:第一,使用(通常)编码时空信息的CNN计算低级特征;第二,使用(通常)RNN将这些低级特征输入到一
  • 卷积神经网络(ConvolutionalNeuralNetwork,CNN)最初是为解决图像识别等问题设计的,CNN现在的应用已经不限于图像和视频,也可用于时间序列信号,比如音频信号和文本数据等。CNN作为一个深度学习架构被提出的最初...
  • 时序卷积网络 | Python实现TCN时序卷积网络数据预测 目录时序卷积网络 | Python实现TCN时序卷积网络数据预测基本介绍工作原理程序设计参考资料 基本介绍 本文绍时序卷积网络TCN(Temporal Convolutional Network)...
  • LHCnn:一种利用卷积神经网络的新型高效多元时间序列预测框架
  • 提出一种基于多特征时空图卷积网络(MFSTGCN,multi-feature spatio-temporal graph convolution network)的预测方法,解决了水运交通中通航密度的预测问题。MFSTGCN方法从通航量、船舶平均航速和船舶密度3个特征...
  • 本文实例为大家分享了Tensorflow实现AlexNet卷积神经网络的具体实现代码,供大家参考,具体内容如下 之前已经介绍过了AlexNet的网络构建了,这次主要不是为了训练数据,而是为了对每个batch的前馈(Forward)和反馈...
  • 首先使用双流卷积神经网络提取视频的特征序列,然后使用TAG (Temporal Actionness Grouping)生成行为提议,为了构建高质量的行为提议,将行为提议送入边界回归网络中修正边界,使之更为贴近真实数据,再将行为提议...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 84,480
精华内容 33,792
关键字:

时间卷积网络

友情链接: waveenhance.rar