位置编码系列(NLP and CV领域)

NLP中的位置编码

转载:让研究人员绞尽脑汁的Transformer位置编码

总体结构

Bert问世后瞬间引爆了NLP领域,同时也让Transformer火了起来,Transformer中特征提取的方式不是传统的CNN,RNN等,而是用attention的形式,这种模式被用在AI的各个领域中,包括CV和语音等。attention提取特征的效果非常好,可以非常有效的提取到上下文的信息,但是在NLP中会有个问题:attention提取特征的时候,当前这个字对上下文的其他字的关联性可以很好的体现出来,但是其他字的位置在哪里都可以,在这个字的前面、后面都可以,间隔的距离也没有要求。但其实这跟我们平时表达的语言肯定是矛盾的,于是在Transformer中加入了位置编码。

虽然说起来主要就是绝对位置编码和相对位置编码两大类,但每一类其实又能衍生出各种各样的变种,为此研究人员可算是煞费苦心、绞尽脑汁了,此外还有一些不按套路出牌的位置编码。本文就让我们来欣赏一下研究人员为了更好地表达位置信息所构建出来的“八仙过海,各显神通”般的编码方案。

绝对位置编码

形式上来看,绝对位置编码是相对简单的一种方案,但即便如此,也不妨碍各路研究人员的奇思妙想,也有不少的变种。一般来说,绝对位置编码会加到输入中:在输入的第k个向量  \(xk\)中加入位置向量  \(pk\)变为\(xk+pk\),其中\(pk\)只依赖于位置编号k。

训练式

很显然,绝对位置编码的一个最朴素方案是不特意去设计什么,而是直接将位置编码当作可训练参数,比如最大长度为512,编码维度为768,那么就初始化一个512×768的矩阵作为位置向量,让它随着训练过程更新。现在的BERT、GPT等模型所用的就是这种位置编码,事实上它还可以追溯得更早,比如2017年Facebook的《Convolutional Sequence to Sequence Learning》就已经用到了它。

对于这种训练式的绝对位置编码,一般的认为它的缺点是没有外推性,即如果预训练最大长度为512的话,那么最多就只能处理长度为512的句子,再长就处理不了了。当然,也可以将超过512的位置向量随机初始化,然后继续微调。但笔者最近的研究表明,通过层次分解的方式,可以使得绝对位置编码能外推到足够长的范围,同时保持还不错的效果,因此,其实外推性也不是绝对位置编码的明显缺点。

三角式

三角函数式位置编码,一般也称为Sinusoidal位置编码,是Google的论文《Attention is All You Need》所提出来的一个显式解:

递归式

原则上来说,RNN模型不需要位置编码,它在结构上就自带了学习到位置信息的可能性(因为递归就意味着我们可以训练一个“数数”模型),因此,如果在输入后面先接一层RNN,然后再接Transformer,那么理论上就不需要加位置编码了。同理,我们也可以用RNN模型来学习一种绝对位置编码,比如从一个向量p0出发,通过递归格式pk+1=f(pk)来得到各个位置的编码向量。

ICML 2020的论文《Learning to Encode Position for Transformer with Continuous Dynamical Model》把这个思想推到了极致,它提出了用微分方程(ODE)dpt/dt=h(pt,t)的方式来建模位置编码,该方案称之为FLOATER。显然,FLOATER也属于递归模型,函数h(pt,t)可以通过神经网络来建模,因此这种微分方程也称为神经微分方程,关于它的工作最近也逐渐多了起来。

理论上来说,基于递归模型的位置编码也具有比较好的外推性,同时它也比三角函数式的位置编码有更好的灵活性(比如容易证明三角函数式的位置编码就是FLOATER的某个特解)。但是很明显,递归形式的位置编码牺牲了一定的并行性,可能会带速度瓶颈。

相乘式

刚才我们说到,输入xk与绝对位置编码pk的组合方式一般是xk+pk,那有没有“不一般”的组合方式呢?比如xk⊗pk(逐位相乘)?我们平时在搭建模型的时候,对于融合两个向量有多种方式,相加、相乘甚至拼接都是可以考虑的,怎么大家在做绝对位置编码的时候,都默认只考虑相加了?

很抱歉,笔者也不知道答案。可能大家默认选择相加是因为向量的相加具有比较鲜明的几何意义,但是对于深度学习模型来说,这种几何意义其实没有什么实际的价值。最近笔者看到的一个实验显示,似乎将“加”换成“乘”,也就是xk⊗pk的方式,似乎比xk+pk能取得更好的结果。具体效果笔者也没有完整对比过,只是提供这么一种可能性。关于实验来源,可以参考《中文语言模型研究:(1) 乘性位置编码》

相对位置编码

相对位置并没有完整建模每个输入的位置信息,而是在算Attention的时候考虑当前位置与被Attention的位置的相对距离,由于自然语言一般更依赖于相对位置,所以相对位置编码通常也有着优秀的表现。对于相对位置编码来说,它的灵活性更大,更加体现出了研究人员的“天马行空”。

经典式

相对位置编码起源于Google的论文《Self-Attention with Relative Position Representations》,华为开源的NEZHA模型也用到了这种位置编码,后面各种相对位置编码变体基本也是依葫芦画瓢的简单修改。

一般认为,相对位置编码是由绝对位置编码启发而来,考虑一般的带绝对位置编码的Attention:

XLNET式

XLNET式位置编码其实源自Transformer-XL的论文《Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context》,只不过因为使用了Transformer-XL架构的XLNET模型并在一定程度上超过了BERT后,Transformer-XL才算广为人知,因此这种位置编码通常也被冠以XLNET之名。

T5式

T5模型出自文章《Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer》,里边用到了一种更简单的相对位置编码。思路依然源自展开式(7)(7),如果非要分析每一项的含义,那么可以分别理解为“输入-输入”、“输入-位置”、“位置-输入”、“位置-位置”四项注意力的组合。如果我们认为输入信息与位置信息应该是独立(解耦)的,那么它们就不应该有过多的交互,所以“输入-位置”、“位置-输入”两项Attention可以删掉,而piWQW⊤Kp⊤j⊤实际上只是一个只依赖于(i,j)的标量,我们可以直接将它作为参数训练出来,即简化为

说白了,它仅仅是在Attention矩阵的基础上加一个可训练的偏置项而已,而跟XLNET式一样,在vj上的位置偏置则直接被去掉了。包含同样的思想的还有微软在ICLR 2021的论文《Rethinking Positional Encoding in Language Pre-training》中提出的TUPE位置编码。

DeBERTa式

DeBERTa也是微软搞的,去年6月就发出来了,论文为《DeBERTa: Decoding-enhanced BERT with Disentangled Attention》,最近又小小地火了一把,一是因为它正式中了ICLR 2021,二则是它登上SuperGLUE的榜首,成绩稍微超过了T5。

其实DeBERTa的主要改进也是在位置编码上,同样还是从展开式(7)(7)出发,T5是干脆去掉了第2、3项,只保留第4项并替换为相对位置编码,而DeBERTa则刚刚相反,它扔掉了第4项,保留第2、3项并且替换为相对位置编码(果然,科研就是枚举所有的排列组合看哪个最优):

不过,DeBERTa比较有意思的地方,是提供了使用相对位置和绝对位置编码的一个新视角,它指出NLP的大多数任务可能都只需要相对位置信息,但确实有些场景下绝对位置信息更有帮助,于是它将整个模型分为两部分来理解。以Base版的MLM预训练模型为例,它一共有13层,前11层只是用相对位置编码,这部分称为Encoder,后面2层加入绝对位置信息,这部分它称之为Decoder,还弄了个简称EMD(Enhanced Mask Decoder);至于下游任务的微调截断,则是使用前11层的Encoder加上1层的Decoder来进行。

SuperGLUE上的成绩肯定了DeBERTa的价值,但是它论文的各种命名真的是让人觉得极度不适,比如它自称的“Encoder”、“Decoder”就很容易让人误解这是一个Seq2Seq模型,比如EMD这个简称也跟Earth Mover’s Distance重名。虽然有时候重名是不可避免的,但它重的名都是ML界大家都比较熟悉的对象,相当容易引起误解,真不知道作者是怎么想的…

其他位置编码

绝对位置编码和相对位置编码虽然花样百出,但仍然算是经典范围内,从上述介绍中我们依然可以体会到满满的套路感。除此之外,还有一些并不按照常规套路出牌,它们同样也表达了位置编码。

CNN式

尽管经典的将CNN用于NLP的工作《Convolutional Sequence to Sequence Learning》往里边加入了位置编码,但我们知道一般的CNN模型尤其是图像中的CNN模型,都是没有另外加位置编码的,那CNN模型究竟是怎么捕捉位置信息的呢?

如果让笔者来回答,那么答案可能是卷积核的各项异性导致了它能分辨出不同方向的相对位置。不过ICLR 2020的论文《How Much Position Information Do Convolutional Neural Networks Encode?》给出了一个可能让人比较意外的答案:CNN模型的位置信息,是Zero Padding泄漏的!

我们知道,为了使得卷积编码过程中的feature保持一定的大小,我们通常会对输入padding一定的0,而这篇论文显示该操作导致模型有能力识别位置信息。也就是说,卷积核的各向异性固然重要,但是最根本的是zero padding的存在,那么可以想象,实际上提取的是当前位置与padding的边界的相对距离。

不过,这个能力依赖于CNN的局部性,像Attention这种全局的无先验结构并不适用,如果只关心Transformer位置编码方案的读者,这就权当是扩展一下视野吧。

复数式

复数式位置编码可谓是最特立独行的一种位置编码方案了,它来自ICLR 2020的论文《Encoding word order in complex embeddings》。论文的主要思想是结合复数的性质以及一些基本原理,推导出了它的位置编码形式(Complex Order)为:

代表词j的三组词向量。你没看错,它确实假设每个词有三组跟位置无关的词向量了(当然可以按照某种形式进行参数共享,使得它退化为两组甚至一组),然后跟位置k相关的词向量就按照上述公式运算。

你以为引入多组词向量就是它最特立独行的地方了?并不是!我们看到式(11)(11)还是复数形式,你猜它接下来怎么着?将它实数化?非也,它是将它直接用于复数模型!也就是说,它走的是一条复数模型路线,不仅仅输入的Embedding层是复数的,里边的每一层Transformer都是复数的,它还实现和对比了复数版的Fasttext、LSTM、CNN等模型!这篇文章的一作是Benyou Wang,可以搜到他的相关工作基本上都是围绕着复数模型展开的,可谓复数模型的铁杆粉了~

融合式

无偶独有,利用复数的形式,笔者其实也构思了一种比较巧的位置编码,它可以将绝对位置编码与相对位置编码融于一体,分享在此,有兴趣的读者欢迎一起交流研究。

简单起见,我们先假设qm,kn是所在位置分别为m,n的二维行向量,既然是二维,那么我们可以将它当作复数来运算。我们知道,Attention关键之处在于向量的内积,用复数表示为

来赋予[x,y]绝对位置信息,那么在Attention运算的时候也等价于相对位置编码。如果是多于二维的向量,可以考虑每两维为一组进行同样的运算,每一组的θ可以不一样。

这样一来,我们得到了一种融绝对位置与相对位置于一体的位置编码方案,从形式上看它有点像乘性的绝对位置编码,通过在q,k中施行该位置编码,那么效果就等价于相对位置编码,而如果还需要显式的绝对位置信息,则可以同时在v上也施行这种位置编码。总的来说,我们通过绝对位置的操作,可以达到绝对位置的效果,也能达到相对位置的效果,初步实验显示它是可以work的,但还没有充分验证,欢迎大家尝试交流。

模型压缩

最近在做的yolo网络硬件加速项目,需要去对原始网络进行压缩,因此记录下相关知识:

相关综述:

A Survey of Model Compression and Acceleration for Deep Neural Networks

《A Comprehensive Survey on Model Compression and Acceleration》

目前,在模型压缩和加速方面常用的方法大致可以分为四类:剪枝与量化(parameter pruning and quantization)、低秩因子分解(low-rank factorization)、迁移/压缩卷积滤波器(transferred/compact convolutional filters)、蒸馏学习(knowledge distillation)。

模型压缩方法

背景

近年来,深度神经网络(deep neural networks,DNN)逐渐受到各行各业的关注。它是指具有更深层(不止一个隐藏层)的神经网络,是深度学习的基础。很多实际的工作通常依赖于数百万甚至数十亿个参数的深度网络,这样复杂的大规模模型通常对计算机的CPU和GPU有着极高的要求,并且会消耗大量内存,产生巨大的计算成本。随着一些便携式设备(如移动电话)的快速发展,如何将这些复杂的计算系统部署到资源有限的设备上就成为了需要应对的全新挑战。这些设备通常内存有限,而且计算能力较低,不支持大模型的在线计算。因此需要对模型进行压缩和加速,以求在基本不损失模型精度的条件下,节约参数并降低其计算时间。

剪枝与量化主要针对模型中的冗余参数进行删减;低秩因子分解使用张量分解的方法来估计神经网络的参数;迁移/压缩卷积滤波器则是设计了一个特殊结构的卷积滤波器,能够减少参数空间并且节约内存;蒸馏学习是先训练一个较大的模型,再训练一个较小的神经网络以达到跟大模型同样的效果。其中,低秩因子分解和迁移/压缩卷积滤波器两种方法提供了端到端的管道,可以在CPU/GPU环境中轻松实现;而剪枝与量化使用二进制及稀疏约束等方法来实现目标。此外,剪枝与量化和低秩因子分解方法可以从预训练的模型中提取或者是从头开始训练,而另外两种方法仅支持从头开始的训练。这四种方法大多是独立设计的,但又相互补充,在实际应用中常常可以一起使用,实现对模型进一步的压缩或加速。接下来将分别对这四种方法进行介绍。

剪枝与量化(parameter pruning and quantization)

早期的研究表明,对构建的网络进行剪枝和量化在降低网络复杂性以及解决过拟合问题方面是有效的(Gong et al. 2014)。同剪枝与量化有关的方法可以进一步分为三个子类:量化与二值化(quantization and binarization)、网络剪枝(network pruning)、结构矩阵(structural matrix)。

1.量化与二值化(quantization and binarization)

在DNN中,权重通常是以32位浮点数的形式(即32-bit)进行存储,量化法则是通过减少表示每个权重需要的比特数(the number of bits)来压缩原始网络。此时权重可以量化为16-bit、8-bit、4-bit甚至是1-bit(这是量化的一种特殊情况,权重仅用二进制表示,称为权重二值化)。8-bit的参数量化已经可以在损失小部分准确率的同时实现大幅度加速(Vanhoucke et al. 2011)。图2展示了基于修剪、量化和编码三个过程的压缩法:首先修剪小权重的连接,然后使用权重共享来量化权重,最后将哈夫曼编码应用于量化后的权重和码本上。

此方法的缺点是,在处理大型CNN(如GoogleNet)时,二值网络的精度明显降低。此外,现有的二值化方法大多基于简单的矩阵近似,忽略了二值化对精度损失产生的影响。

2.网络剪枝(network pruning)

剪枝是指通过修剪影响较小的连接来显著减少DNN模型的存储和计算成本,目前比较主流的剪枝方法主要有以下几种:

  • 权重剪枝(weight pruning):此方法主要应用于对不重要的连接权重进行修剪。如果连接权重低于预先设定的某个阈值,则该连接权重将会被修剪(Han et al. 2015)。
  • 神经元剪枝(neuron pruning):此方法与逐个修剪权重的方法不同,它直接移除某个冗余的神经元。这样一来,该神经元的所有传入和传出连接也将被移除(Srinivas and Babu 2015)。
  • 卷积核剪枝(filter pruning):此方法依据卷积核的重要程度将其进行排序,并从网络中修剪最不重要/排名最低的卷积核。卷积核的重要程度可以通过或范数或一些其他方法计算(Li et al. 2016)。
  • 层剪枝(layer pruning):此方法主要应用于一些非常深度的网络,可以直接修剪其中的某些层(Chen and Zhao 2018)。

按照剪枝的对象分类,可以分为在全连接层上剪枝和在卷积层上剪枝两种。DNN中的全连接层是存储密集的,对全连接层中的参数进行剪枝能够显著降低存储成本。对于卷积层而言,每个卷积层中都有许多卷积核,从卷积层修剪不重要的卷积核也能够减少计算成本并加速模型。

在全连接层上剪枝:考虑一个输入层、隐藏层和输出层分别具有3、2和1个神经元的前馈神经网络,如图3所示。

其中, x1​、x2​、x3​ 是网络的输入, wijl​ 是从当前层中节点 i 的层 l 到下一层中的节点 j 的权重。从图3(a)可以清楚地看出,目前总共有8个连接权重,如果删除两个橙色(虚线)的连接,那么总连接权重将减少到6个。类似地,从图3(b)中,如果移除红色神经元,那么其所有相关的连接权重(虚线)也将被移除,导致总连接权重减少到4个(参数数量减少50%)。

  • 在卷积层上剪枝: 在卷积神经网络中, 卷积核 WRh×w×ic×f 应用于每个输入的图像 I,IRm×n×ic, 并且经过卷积操作后输出特征映射 T,TRp×q×f 。其中, h 和 w 是卷积核的尺寸, ic 是输入图像中输入通道的数量, f 是应用的卷积核 的数量, m 和 n 是输入图像的尺寸, p 和 q 是结果特征映射的输出尺寸。输出特征映射的形状计算如下:

其中, s 为步长 (stride), p 为填充(padding)。图4显示了最简单的CNN形式,其 中输入图像的大小为 4×4×3, 应用的卷积核大小为 3×3×3×2 (2是卷积核的数 量)。

受到早期剪枝方法和神经网络过度参数化问题的启发,Han et al.(2015)提出了三步法来进行剪枝。其思想是,首先修剪激活小于某个预定义阈值的所有连接权重(不重要的连接),随后再识别那些重要的连接权重。最后,为了补偿由于修剪连接权重而导致的精度损失,再次微调/重新训练剪枝模型。这样的剪枝和再训练过程将重复数次,以减小模型的大小,将密集网络转换为稀疏网络。这种方法能够对全连接层和卷积层进行修剪,而且卷积层比全连接层对修剪更加敏感。

从卷积层修剪一些不重要的卷积核能够直接减少计算成本并且加速模型。但是,使用网络剪枝方法同样存在着一些问题。首先,使用或正则化进行剪枝比常规方法需要更多的迭代次数才能收敛。其次,所有的剪枝都需要手动设置神经网络层的灵敏度,这需要对参数进行微调,在某些应用中可能会十分复杂。最后,网络剪枝虽然通常能够使大模型变小,但是却不能够提高训练的效率。

3.结构矩阵(structural matrix)

神经网络各层之间使用的是非线性变换 f(x,N)=σ(Mx), 这里的 σ(⋅) 是对每个 元素特异的非线性算子, x 是输入向量, M 代表 m×n 维的参数矩阵, 此时的运算复 杂度为 O(mn) (V. Sindhwani et al. 2015) 。一个直观的剪枝方法就是使用参数化的 结构矩阵。一个大小为 m×n, 但是参数量却小于 mn 的矩阵就叫做结构矩阵。Cheng et al. ( 2015 ) 提 出了一种 基于循环预测的简单方法, 对于一个向量 r=(r0​,r1​,⋯,r(d−1)​), 其对应的 d×d 维循环矩阵定义如下:

这样一来存储的成本就从O (d2) 变成了O (d) 。给定 d 维 r 向量的条件下, 上式中的 一层循环神经网络的时间复杂度为 O(dlogd) 。

结构矩阵不仅能够降低内存成本,而且能够通过矩阵向量和梯度计算大幅度加快训练的速度。但是这种方法的缺点在于,结构约束通常会给模型带来偏差,从而损害模型的性能。再者,如何找到合适的结构矩阵也是一个难题,目前还没有理论上的方法能够推导出结构矩阵。

低秩因子分解(low-rank factorization)

低秩分解的思想是, 如果原始权重矩阵具有维数 m×n 和秩 r, 则满秩矩阵可以分 解为一个 m×r 的权重矩阵和一个 r×n 的权重矩阵。该方法通过将大矩阵分解为小矩 阵, 以减小模型的尺寸。CNN通常由许多层组成, 每层都有一组权重矩阵, 这些权重可以用张量 (Tensor) 来表示。图5展示了一个维数为 X×Y×Z 的三维张量。

给定一个维数为 N×N×D, 且有 K 个卷积核的卷积层, 其权重矩阵 W 可以表示为一个 N×N×D×K 维的张量 (Granés and Santamaria 2017) 。对于全连接层而言, W 可以用矩阵 (2阶张量) 来表示。因此对权重矩阵进行分解就是对张量进行分解。张量分解指的是, 用标量 (O阶张量) 、向量 (1阶张量) 、矩阵 (2阶张量) 和一些其他高阶的张量来表示原始张量的方法。对矩阵可以应用满秩分解 (full-rank decomposition) 和奇异值分解 (singular value decomposition, SVD), 对三维及三维以上张量可以应用 Tucker 分解和 CP分解 (Canonical Polyadic) (Deng et al.2020) 。

1.对矩阵的分解

  • 满秩分解。对任何给定的矩阵 AR(m×n), 其秩 rmin(m,n), 则 A 的满秩分解可以表示为 A=WH, 其中 WR(m×r),HR(r×n) 。如果 r 远小于 m 或 n,我们称 A 为低秩矩阵 (low-rank matrix) 。通过满秩分解可以将空间复杂度从O(mn) 显著减小到 O(r(m+n)) 。特别地, 当 m 和 n 非常接近, 并且原始矩阵是行(或列) 满秩时, 这种减小空间复杂度的作用会失效。满秩分解方法对于全连接层十分有效, 特别是当两层之间的神经元数量相差很大或权重矩阵低秩稀疏时。给定一个较小的正整数 k<r, 可以通过如下的式子求解最优的 WR(m×k),HR(k×n), 其中, F 表示Frobenius范数。
  • SVD。SVD是一种将原始权重矩阵分解为三个较小的矩阵以替换原始权重矩阵的 方法。对于任意的矩阵 AR(m×n), 存在分解 A=USVT, 其中, UR(m×r), SR(r×r),VTR(r×n) 。 U 和 V 是正交矩阵, S 是对角线上只有奇异值的对角矩 阵, 其中的每一个元素都比其下一个对角线上的元素大。这种方法可以使空间复 杂度从 O(mn) 减小到 O(r(m+n+1)) 。实际应用中, 可以用更小的 k 替换 r, 这 种方法称为截断奇异值分解 (truncated SVD, TSVD) 。在前馈神经网络和卷积神 经网络中, SVD是一种常用的分解方法, 主要用于减少参数的个数。

2.对三维及三维以上张量的分解

  • Tucker分解。该方法是将TSVD方法中的对角矩阵扩展为张量的一种方法。TSVD和Tucker分解之间的关系可以用图来表示:
  • CP分解。该分解是Tucker分解的一种特殊形式。如果Tucker分解中的每个 ri​ 等于正 整数 rC​, 并且核张量 K 满足, 除了 K(x1​,x2​,…,xd​),x1​=x2​=⋯=xd​ 之外 的所有元素都是 0 , 此时Tucker分解就成为了CP分解。与Tucker分解相比, CP分解 常用于解释数据的组成成分, 而前者主要用于数据压缩。图7展示了三阶张量 xR(I×J×K) 被 R 个组成部分分解的过程, 这个过程也可以用如下的公式来表示, 其中, ar​∈RI,br​∈RJ,cr​∈RK (Marcella Astrid and Seung- and Ik Lee 2018)。

基于低秩近似的方法虽然是模型压缩和加速的前沿,然而具体实现却并非易事。因为这涉及到分解操作,需要付出高昂的计算成本。此外,当前的方法仍集中于逐层执行低秩近似,因此无法执行全局的参数压缩。但全局的参数压缩十分重要,因为不同的层包含不同的信息。最后,与原始的模型相比,因子分解需要对大量的模型进行再训练以实现收敛。

迁移/压缩卷积滤波器(transferred/compact convolutional filters)

Cohen and Welling (2016) 提出了使用卷积滤波器压缩CNN模型的想法, 并在 研究中引入了等变群理论 (the equivariant group theory)。让 x 作为输入, Φ(⋅) 作为 一个神经网络或者网络层, Γ(⋅) 作为迁移矩阵, 则等价的概念定义如下:Γ′(Φ(x))=Φ(Γ(x))

这样的定义指的是, 迁移矩阵 Γ(⋅) 先对输入x进行变换, 再将其传输到 Φ(⋅) 所得到 的结果应该跟先将输入 x 映射到神经网络 Φ(⋅) 上再做变换 Γ(⋅) 得到的结果相同。值得注 意的是, Γ(⋅) 和 Γ′(⋅) 不一定相同, 因为它们作用在不同的对象上。根据这样的理论, 通过将变换应用于层或者滤波器 Φ(⋅) 来压缩整个网络模型就十分合理。从经验来看, 使用一组大的卷积滤波器也对深层CNN有益, 具体方法是将一些变换 Γ(⋅) 应用于一组 充当模型正则化器的小型基滤波器上。

沿着这一研究方向, 近期的许多研究提出了从一组基滤波器出发构建卷积层的思 想。它们的共同点是, 迁移矩阵 Γ(⋅) 是只在卷积滤波器的空间域中操作的一类函数。 例如, Shang et al. (2016) 发现, CNN的较低卷积层通过学习㐌余的滤波器来提取 输入信号的正负相位信息, 并将 Γ(⋅) 定义为简单的否定函数:

其中, Wx​ 是基础的卷积滤波器, Wx−​是由激活与 Wx​ 相反的移位 (shift) 构成的滤波 器, 并且这些移位是在最大池 (max-pooling) 操作后选择的。通过这样操作, 就可以 很容易的实现在所有卷积层上的二倍压缩率。它还表明, 否定变换作为一个强大的正 则化方法, 能够用以提高分类精度。一种直观的理解是, 具有成对正负约束的学习算 法可以产生实用而不是冗余的的卷积滤波器。此外, Zhai et al. (2016) 将 Γ(⋅) 定义为 应用于 2 维滤波器的平移函数集:Γ′Φ(x)=T(⋅,x,y)x,y∈{−k,…,k},(x,y)=(0,0)

其中, T(⋅,x,y) 表示第一个操作数沿其空间维度平移 (x,y), 并在边界处进行适当的零 填充以保持形状。提出的框架可用于公式 (1) 改善分类精度的问题, 进而作为 maxout网络的正则化版本。

对于将变换约束应用于卷积滤波器的方法,还有几个问题需要解决。首先,这些方法可以在宽/平的架构(如VGGNet,AlexNet)上实现有竞争力的性能,但是在窄/深的架构(如ResNet)上则不行。其次,迁移假设有时太强,无法指导学习过程,导致得到的结果在某些情况下不稳定。此外,使用紧凑的卷积滤波器虽然可以直接降低计算成本,但关键思想是要用紧凑的块替换松散的和过度参数化的滤波器以提高计算速度。

蒸馏学习(knowledge distillation)

蒸馏学习(knowledge distillation,KD)是指通过构建一个轻量化的小模型,利用性能更好的大模型的监督信息,来训练这个小模型,以期达到更好的性能和精度。KD与迁移学习(transfer learning)不同,在迁移学习中,我们使用相同的模型体系结构和学习的权重,仅根据应用的要求使用新层来替换部分全连接层。而在KD中,通过在大数据集上训练的更大的复杂网络(也称之为教师模型(teacher model))学习到的知识可以迁移到一个更小、更轻的网络上(也称之为学生模型(student model))。前一个大模型可以是单个的大模型,也可以是独立训练模型的集合。KD方法的主要思想是通过softmax函数学习课堂分布输出,将知识从大型教师模型转换为一个更小的学生模型。从教师模型训练学生模型的主要目的是学习教师模型的泛化能力。

在现有的KD方法中,学生模型的学习依赖于教师模型,是一个两阶段的过程。Lan et al.(2018)提出了实时本地集成(On-the-fly Native Ensemble,ONE),这是一种高效的单阶段在线蒸馏学习方法。在训练期间,ONE添加辅助分支以创建目标网络的多分支变体,然后从所有分支中创建本地集成教师模型。对于相同的目标标签约束,可以同时学习学生和每个分支。每个分支使用两个损失项进行训练,其中最常用的就是最大交叉熵损失(softmax cross-entropy loss)和蒸馏损失(distillation loss)。

在网络压缩这一步,可以使用深度神经网络方法来解决这个问题。Romero et al.(2015)提出了一种训练薄而深的网络的方法,称为FitNets,用以压缩宽且相对较浅(但实际上仍然很深)的网络。该方法扩展了原来的思想,允许得到更薄、更深的学生模型。为了学习教师网络的中间表示,FitNet让学生模仿老师的完全特征图。然而,这样的假设太过于严格,因为教师和学生的能力可能会有很大的差别。

基于蒸馏学习的方法可以使模型的深度变浅,并且能够显著降低计算成本。然而,这个方法也存在一些弊端。其中之一是KD方法只能应用于具有softmax损失函数的任务中。再者就是,与其他类型的方法相比,基于蒸馏学习的方法往往具有较差的竞争性能。

面临的问题

在文章的最后一部分,作者总结了现有的这些模型压缩和加速的方法仍然面临的一些问题与挑战,主要有以下几个方面:

  1. 当前的大多数先进方法建立在精心设计的CNN模型之上,这些模型限制了更改配置的自由度(例如,网络架构、超参数等)。为了处理更复杂的任务,未来应该提供更加合理的方法来配置压缩模型。
  2. 各种小型平台(例如移动设备、机器人、自动驾驶汽车等)的硬件限制仍然是阻碍深层CNN扩展的主要问题。如何充分利用有限的计算资源以及如何为这些平台设计特殊的压缩方法仍然是需要解决的问题。
  3. 剪枝是压缩和加速CNN的有效方法。目前的剪枝技术大多是为了修剪神经元之间的连接而设计的。此外,对通道进行剪枝能够直接减少特征映射的宽度并压缩模型。这种方法虽然很有效,但是修剪通道可能会显著地改变下一层的输入,因此也存在挑战性。
  4. 如前所述,结构矩阵和迁移卷积滤波器的方法必须使模型具有人类的先验知识,这将会显著影响模型的性能和稳定性。研究如何控制强加这些先验知识带来的影响至关重要。
  5. 蒸馏学习的方法具有很多的优点,比如无需特定的硬件就能够直接加速模型。开发基于KD的更多方法并且探索如何提高其性能是未来主要的发展方向。
  6. 尽管这些压缩方法取得了巨大的成就,但是黑箱机制(black box mechanism)仍然是其应用的关键障碍。比如,某些神经元/连接被修剪的原因尚不清楚。探索这些方法的解释能力仍然是一个重大挑战。

AI 文本生成图片工具汇总

1、https://openai.com/dall-e-2/

2、 https://imagen.research.google/

3、https://github.com/alembics/disco-diffusion

试玩: https://colab.research.google.com/github/alembics/disco-diffusion/blob/main/Disco_Diffusion.ipynb

4、https://github.com/jina-ai/discoart

5、https://replicate.com/nightmareai/disco-diffusion(API)

6、https://midjourney.gitbook.io/docs/(app)

7、https://www.midjourney.com/showcase/

7、https://blog.tiamat.ai/about/

Few-Shot Learning (FSL): 小样本学习简介及其应用

摘自: https://research.aimultiple.com/few-shot-learning/

论文 :A Survey on Few-Shot Learning: https://arxiv.org/abs/1904.05046

wss介绍视频:https://www.youtube.com/c/ShusenWang

课件:https://github.com/wangshusen/DeepLearning

  如果手机需要成千上万张照片来训练才能进行人脸识别解锁,这是很不友好的。在机器学习应用领域,小样本学习(Few-shot Learning)(在刚刚描述的情况下称为单样本学习(one-shot learning))是一个热门话题,它能够基于少量的训练样本去预测。本文将讨论以下几个方面:

  • 什么是少样本学习(FSL)?
  • 它为什么如此重要?
  • 少样本学习有哪些应用?
  • 它是如何工作的?
  • 少样本学习和零样本学习有什么区别?
  • 少样本学习有哪些不同的方法?
  • 它是如何在 Python 中实现的?
  • 机器学习的未来

case:以相似度函数来进行图片分类:

训练:可以在大规模数据集中学习不同类别的相似性,使得同一类的相似度高,不同类别相似度低。

测试:输入query(测试图片)和 surport set(带标签的图片,要进行比较的不同类别的数据集不等于训练集)目的就是要让模型识别query和 surport set 中那个更相似。

1. 什么是小样本学习?

        小样本学习(Few-shot learning, FSL),在少数资料中也被称为low-shot learning(LSL)。小样本学习是一种训练数据集包含有限信息的机器学习问题。

        对于机器学习应用来说,通常的做法是提供尽可能多的数据。这是因为在大多数机器学习应用中,输入更多的数据训练能使模型的预测效果更好。然而,小样本学习的目标是使用数量较少的训练集来构建准确的机器学习模型。由于输入数据的维度是一个决定资源消耗成本(如,时间成本,计算成本等)的因素,我们可以通过使用小样本学习来降低数据分析/机器学习消耗成本。

2. 小样本学习为什么重要 ?

  • 类似人的学习方式:人在看过少量例子后就可以认出手写字符之间的不同。然而,计算机需要大量的数据去“分类”它看到的东西,并识别出手写字符之间的不同。小样本学习是一种test base的方法,我们期望它能像人一样从少量的样本中学习。
  • 稀有样本学习:小样本学习能用于稀有样本的学习。例如,当对动物图片进行分类时,用小样本学习训练的机器学习模型,在只得到少量的先验信息后,可以正确地对稀有样本的图像进行分类。
  • 降低数据收集和计算成本:由于小样本学习仅需要少量的数据来训练模型,消除了数据收集和标记相关的高成本。训练数据量少意味着训练数据集的维数低,这可以显着降低计算成本。

3. 小样本学习(Few-shot Learning)和零样本学习(Zero-shot Learning)的区别 

  小样本学习的目的是在有少量训练数据的情况下能获得准确分类测试样本的模型。零样本学习的目的是预测训练数据集中没有出现过的类别。零样本学习和小样本学习有很多共同的应用,例如:

  • 图像分类(image classification)
  • 语义分割(semantic segmentation)
  • 图像生成(image generation)
  • 目标检测(object detection)
  • 自然语言处理(natural language processing)

还有一种叫单样本学习(one-shot learning)的,它经常会和零样本学习混在一起。单样本学习是小样本学习问题的一个特例,它的目的是从一个训练样本或图片中学习到有关物体类别的信息。单样本学习的一个例子是,智能手机中使用的人脸识别技术。

4. 小样本学习的方法

5. 小样本学习的应用

5.1 计算机视觉:计算机视觉探索如何从数字图像或视频中获得高级理解。小样本学习在计算机视觉中主要用于处理以下问题:

5.2 自然语言处理:小样本学习使自然语言处理应用程序能够用很少的文本数据样本来完成任务。例如:

5.3 机器人:为了让机器人的行为更像人类,它们应该能够从少量的示例中归纳出信息。因此,小样本学习在训练机器人完成特定任务中扮演了一个关键角色,例如:

  • 通过模仿一个动作来学习该动作-learning a movement by imitating a single demonstration。IEEE****
  • 从少量示例中学习操作动作-learning manipulation actions from a few demonstrations。IEEE*****
  • 视觉导航-visual navigation。PMLR
  • 连续控制-continuous control。NIPS*****

5.4 声信号处理:包含有关声音信息的数据可以通过声信号处理进行分析,小样本在该方向的应用有:

5.5 其它应用

6. Python实现

机器学习的未来

IBM研究表明,机器学习在未来将围绕以下领域发展:

  • 经典机器学习:一次处理一个数据集、一个任务和一个繁重训练的问题
  • 基于小样本的机器学习:处理大量的离线训练,然后在类似的任务上轻松学习
  • 发展中的机器学习:持续学习各种任务。

🤗 Huggingface Transformers

Huggingface Transformers 是基于一个开源基于 transformer 模型结构提供的预训练语言库,它支持 Pytorch,Tensorflow2.0,并且支持两个框架的相互转换。框架支持了最新的各种NLP预训练语言模型,使用者可以很快速的进行模型的调用,并且支持模型further pretraining 和 下游任务fine-tuning。 

该库是使用 BERT 等预训练模型的最常用的库,甚至超过了google等开源的源代码。它的设计原则保证了它支持各种不同的预训练模型,并且有统一的合理的规范。使用者可以很方便的进行模型的下载,以及使用。同时,它支持用户自己上传自己的预训练模型到Model Hub中,提供其他用户使用。对于NLP从业者,可以使用这个库,很方便地进行自然语言理解(NLU) 和 自然语言生成(NLG)任务的SOTA模型使用。

特色:

  • 超级 简单快速上手
  • 适合于所有人 – NLP研究员,NLP应用人员,教育工作者
  • NLU/NLG SOTA 模型支持
  • 减少预训练成本,提供了30+预训练模型,100+语言 – 支持Pytorch 与 Tensorflow2.0 转换。
  • 以下为部分整合的预训练语言模型, ref: Transformers Github

🤗 Transformers 提供了数以千计的预训练模型,支持 100 多种语言的文本分类、信息抽取、问答、摘要、翻译、文本生成。它的宗旨让最先进的 NLP 技术人人易用。

🤗 Transformers 提供了便于快速下载和使用的API,让你可以把预训练模型用在给定文本、在你的数据集上微调然后通过 model hub 与社区共享。同时,每个定义的 Python 模块均完全独立,方便修改和快速研究实验。

🤗 Transformers 支持三个最热门的深度学习库: JaxPyTorch and TensorFlow — 并与之无缝整合。你可以直接使用一个框架训练你的模型然后用另一个加载和推理。

在线演示

你可以直接在模型页面上测试大多数 model hub 上的模型。 我们也提供了 私有模型托管、模型版本管理以及推理API

这里是一些例子:

快速上手

我们为快速使用模型提供了 pipeline (流水线)API。流水线聚合了预训练模型和对应的文本预处理。下面是一个快速使用流水线去判断正负面情绪的例子:

>>> from transformers import pipeline

# 使用情绪分析流水线
>>> classifier = pipeline('sentiment-analysis')
>>> classifier('We are very happy to introduce pipeline to the transformers repository.')
[{'label': 'POSITIVE', 'score': 0.9996980428695679}]

第二行代码下载并缓存了流水线使用的预训练模型,而第三行代码则在给定的文本上进行了评估。这里的答案“正面” (positive) 具有 99 的置信度。

许多的 NLP 任务都有开箱即用的预训练流水线。比如说,我们可以轻松的从给定文本中抽取问题答案:

>>> from transformers import pipeline

# 使用问答流水线
>>> question_answerer = pipeline('question-answering')
>>> question_answerer({
...     'question': 'What is the name of the repository ?',
...     'context': 'Pipeline has been included in the huggingface/transformers repository'
... })
{'score': 0.30970096588134766, 'start': 34, 'end': 58, 'answer': 'huggingface/transformers'}

除了给出答案,预训练模型还给出了对应的置信度分数、答案在词符化 (tokenized) 后的文本中开始和结束的位置。你可以从这个教程了解更多流水线API支持的任务。

要在你的任务上下载和使用任意预训练模型也很简单,只需三行代码。这里是 PyTorch 版的示例:

>>> from transformers import AutoTokenizer, AutoModel

>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
>>> model = AutoModel.from_pretrained("bert-base-uncased")

>>> inputs = tokenizer("Hello world!", return_tensors="pt")
>>> outputs = model(**inputs)

这里是等效的 TensorFlow 代码:

>>> from transformers import AutoTokenizer, TFAutoModel

>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
>>> model = TFAutoModel.from_pretrained("bert-base-uncased")

>>> inputs = tokenizer("Hello world!", return_tensors="tf")
>>> outputs = model(**inputs)

词符化器 (tokenizer) 为所有的预训练模型提供了预处理,并可以直接对单个字符串进行调用(比如上面的例子)或对列表 (list) 调用。它会输出一个你可以在下游代码里使用或直接通过 ** 解包表达式传给模型的词典 (dict)。

模型本身是一个常规的 Pytorch nn.Module 或 TensorFlow tf.keras.Model(取决于你的后端),可以常规方式使用。 这个教程解释了如何将这样的模型整合到经典的 PyTorch 或 TensorFlow 训练循环中,或是如何使用我们的 Trainer 训练器)API 来在一个新的数据集上快速微调。

为什么要用 transformers?

  1. 便于使用的先进模型:
    • NLU 和 NLG 上表现优越
    • 对教学和实践友好且低门槛
    • 高级抽象,只需了解三个类
    • 对所有模型统一的API
  2. 更低计算开销,更少的碳排放:
    • 研究人员可以分享亿训练的模型而非次次从头开始训练
    • 工程师可以减少计算用时和生产环境开销
    • 数十种模型架构、两千多个预训练模型、100多种语言支持
  3. 对于模型生命周期的每一个部分都面面俱到:
    • 训练先进的模型,只需 3 行代码
    • 模型在不同深度学习框架间任意转移,随你心意
    • 为训练、评估和生产选择最适合的框架,衔接无缝
  4. 为你的需求轻松定制专属模型和用例:
    • 我们为每种模型架构提供了多个用例来复现原论文结果
    • 模型内部结构保持透明一致
    • 模型文件可单独使用,方便魔改和快速实验

什么情况下我不该用 transformers?

  • 本库并不是模块化的神经网络工具箱。模型文件中的代码特意呈若璞玉,未经额外抽象封装,以便研究人员快速迭代魔改而不致溺于抽象和文件跳转之中。
  • Trainer API 并非兼容任何模型,只为本库之模型优化。若是在寻找适用于通用机器学习的训练循环实现,请另觅他库。
  • 尽管我们已尽力而为,examples 目录中的脚本也仅为用例而已。对于你的特定问题,它们并不一定开箱即用,可能需要改几行代码以适之。

了解更多

章节描述
文档完整的 API 文档和教程
任务总结🤗 Transformers 支持的任务
预处理教程使用 Tokenizer 来为模型准备数据
训练和微调在 PyTorch/TensorFlow 的训练循环或 Trainer API 中使用 🤗 Transformers 提供的模型
快速上手:微调和用例脚本为各种任务提供的用例脚本
模型分享和上传和社区上传和分享你微调的模型
迁移从 pytorch-transformers 或 pytorch-pretrained-bert 迁移到 🤗 Transformers

Transformers model hub

Transformers model hub 提供了不同的预训练语言模型,包含了常见的Robert/BERT/XLNET/以及BART 等,几乎所有的最新模型都可以在上面找到。用户可以很方便地对模型进行调用,只需要一个模型的名字,就可以获取模型文件。

model = AutoModel.from_pretrained(model_name)

设计原则 Design Principles

Transformers 的设计是为了:

  • 研究者可以进行拓展
  • 单个modeling的文件,直接在一个文件中就可以修改模型所需要的所有部分,最小化的模块设计。
  • 算法工程师可以轻松使用 – 可以使用 pipeline 直接调用,获取开箱即用的任务体验,例如情感分析的任务等。可以使用trainers 进行训练,支持fp16,分布式等
  • 工业实践中可以快速部署且鲁棒性良好
  • CPU/GPU/TPU支持,可以进行优化,支持torchscript 静态图,支持ONNX格式

库设计 Library Design

transformers 库包含了机器学习相关的主要三个部分:数据处理process data, 模型应用 apply a model, 和做出预测make predictions。分别对应的如下三个模块:Tokenizer,Transformers,以及 Head。

  • Tokenizers 分词器,支持不同的分词。主要作用是将输入进行分词化后,并转化为相应模型需要的embedding。

Tokenizer 类支持从预训练模型中进行加载或者直接手动配置。这些类存储了 token 到 id 的字典,并且可以对输入进行分词,和decode。huggingface transformers 已经提供了如下图的相关tokenizer 分词器。用户也可以很轻松的对tokenizer 里的特殊字符进行更换,例如CLS/SEP。或者是对Tokenizer模型的字典进行大小修改等。

Tokenizer 提供了很多有用的方法,例如padding,truncating,用户可以很方便的对其进行使用。

Transformer transformers 指的是各种基于transformer结构的预训练语言模型,例如BERT,GPT等。它将输入的sparse的序列,转化为上下文感知的的 contextual embedding。

encoder 模型的计算图通常就是对模型输入进行一系列的 self-attention 操作,然后得到最后的encoder的输出。通常情况下,每个模型都是在一个文件中被定义完成的,这样方便用户进行更改和拓展。

针对不同的模型结构,都采用相同的API,这使得用户可以快速地使用不同的其他模型。transformers 提供 一系列的Auto classes,使得快速进行模型切换非常方便。

model = AutoModel.from_pretrained(model_name)
  • Head 不同于attention的head,这边的 head 指的是下游任务的输出层,它将模型的contextual embedding 转化为特定任务的预测值,包含如下的不同的head:
    • Pretraining Head
      • Casual Language Modeling(普通自回归的语言模型):GPT, GPT-2,CTRL
      • Masked Language Modeling(掩码语言模型):BERT, RoBERTa
      • Permuted Language Modeling(乱序重排语言模型):XLNet
    • Fine-tuning Head
      • Language Modeling:语言模型训练,预测下一个词。主要用于文本生成
      • Sequence Classification:文本分类任务,情感分析任务
      • Question Answering:机器阅读理解任务,QA
      • Token Classification:token级别的分类,主要用于命名实体识别(NER)任务,句法解析Tagging任务
      • Multiple Choice:多选任务,主要是文本选择任务
      • Masked LM:掩码预测,随机mask一个token,预测该 token 是什么词,用于预训练
      • Conditional Generation:条件生成任务,主要用于翻译以及摘要任务。

这些模型的head,是在模型文件集中上,包装的另外一个类,它提供了额外的输出层,loss函数等。 这些层的命名规范也很一致,采用的是: XXXForSequenceClassification

其中 XXX 是模型的下游任务(fine-tuning) 或者与训练 pretraining 任务。一些head,例如条件生成(conditional generation),支持额外的功能,像是sampling and beam search。

下图解释了每个head 的输入和输出以及数据集。

下面的代码展示了如何使用 transformers 进行下游的文本分类任务:

from transformers import AutoModelForSequenceClassification

model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)

Huggingface Transformer 使用方法(教程)

Transformers提供了数以千计针对于各种任务的预训练模型模型,开发者可以根据自身的需要,选择模型进行训练或微调,也可阅读api文档和源码, 快速开发新模型。

0、Setup

1)安装一个非常轻量级的 Transformers

!pip install transformers

然后

import transformers

2)建议安装开发版本,几乎带有所有用例需要的依赖项

!pip install transformers[sentencepiece]

一、模型简介 Transformer models

1. pipelines 简单的小例子

Transformers 库中最基本的对象是pipeline()函数。它将模型与其必要的预处理和后处理步骤连接起来,使我们能够直接输入任何文本并获得答案

当第一次运行的时候,它会下载预训练模型和分词器(tokenizer)并且缓存下来。

from transformers import pipeline

classifier = pipeline("sentiment-analysis")  # 情感分析
classifier("I've been waiting for a HuggingFace course my whole life.")

# 输出
# [{'label': 'POSITIVE', 'score': 0.9598047137260437}]

也可以传几句话:

classifier(
    ["I've been waiting for a HuggingFace course my whole life.", "I hate this so much!"]
)

# 输出
'''
[{'label': 'POSITIVE', 'score': 0.9598047137260437},
 {'label': 'NEGATIVE', 'score': 0.9994558095932007}]
'''

目前可用的一些pipeline 有:

feature-extraction 特征提取:把一段文字用一个向量来表示
fill-mask 填词:把一段文字的某些部分mask住,然后让模型填空
ner 命名实体识别:识别文字中出现的人名地名的命名实体
question-answering 问答:给定一段文本以及针对它的一个问题,从文本中抽取答案
sentiment-analysis 情感分析:一段文本是正面还是负面的情感倾向
summarization 摘要:根据一段长文本中生成简短的摘要
text-generation文本生成:给定一段文本,让模型补充后面的内容
translation 翻译:把一种语言的文字翻译成另一种语言
zero-shot-classification

这些pipeline的具体例子可见:Transformer models – Hugging Face Course

2. 各种任务的代表模型

二、 使用 Using Transformers

1. Pipeline 背后的流程

Pipeline 背后的流程

在接收文本后,通常有三步:Tokenizer、Model、Post-Processing。

1)Tokenizer

与其他神经网络一样,Transformer 模型不能直接处理原始文本,故使用分词器进行预处理。使用AutoTokenizer类及其from_pretrained()方法。

from transformers import AutoTokenizer

checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)

若要指定我们想要返回的张量类型(PyTorch、TensorFlow 或普通 NumPy),我们使用return_tensors参数

raw_inputs = [
    "I've been waiting for a HuggingFace course my whole life.",
    "I hate this so much!",
]
inputs = tokenizer(raw_inputs, padding=True, truncation=True, return_tensors="pt")
print(inputs)

PyTorch 张量的结果:

输出本身是一个包含两个键的字典,input_idsattention_mask

{
    'input_ids': tensor([
        [  101,  1045,  1005,  2310,  2042,  3403,  2005,  1037, 17662, 12172, 2607,  2026,  2878,  2166,  1012,   102],
        [  101,  1045,  5223,  2023,  2061,  2172,   999,   102,     0,     0,     0,     0,     0,     0,     0,     0]
    ]), 
    'attention_mask': tensor([
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    ])
}

2)Model

Transformers 提供了一个AutoModel类,它也有一个from_pretrained()方法:

from transformers import AutoModel

checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
model = AutoModel.from_pretrained(checkpoint)

如果我们将预处理过的输入提供给我们的模型,我们可以看到:

outputs = model(**inputs)
print(outputs.last_hidden_state.shape)

# 输出 
# torch.Size([2, 16, 768])
preview

Transformers 中有许多不同的架构可用,每一种架构都围绕着处理特定任务而设计,清单:

*Model (retrieve the hidden states)
*ForCausalLM
*ForMaskedLM
*ForMultipleChoice
*ForQuestionAnswering
*ForSequenceClassification
*ForTokenClassification
and others

3)Post-Processing

模型最后一层输出的原始非标准化分数。要转换为概率,它们需要经过一个SoftMax层(所有 Transformers 模型都输出 logits,因为用于训练的损耗函数一般会将最后的激活函数(如SoftMax)与实际损耗函数(如交叉熵)融合 。

import torch

predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
print(predictions)

2. Models

1)创建Transformer

from transformers import BertConfig, BertModel

# Building the config
config = BertConfig()

# Building the model from the config
model = BertModel(config)

2)不同的加载方式

from transformers import BertModel

model = BertModel.from_pretrained("bert-base-cased")

3)保存模型

model.save_pretrained("directory_on_my_computer")

4)使用Transformer model

sequences = ["Hello!", "Cool.", "Nice!"]
encoded_sequences = [
    [101, 7592, 999, 102],
    [101, 4658, 1012, 102],
    [101, 3835, 999, 102],
]

import torch

model_inputs = torch.tensor(encoded_sequences)

3. Tokenizers

1)Loading and saving

from transformers import BertTokenizer

tokenizer = BertTokenizer.from_pretrained("bert-base-cased")
tokenizer("Using a Transformer network is simple")

# 输出
'''
{'input_ids': [101, 7993, 170, 11303, 1200, 2443, 1110, 3014, 102],
 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0],
 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1]}
'''

# 保存
tokenizer.save_pretrained("directory_on_my_computer")

2)Tokenization

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")

sequence = "Using a Transformer network is simple"
tokens = tokenizer.tokenize(sequence)

print(tokens) # 输出 : ['Using', 'a', 'transform', '##er', 'network', 'is', 'simple']

#  从token 到输入 ID
ids = tokenizer.convert_tokens_to_ids(tokens)
print(ids) # 输出:[7993, 170, 11303, 1200, 2443, 1110, 3014]

3) Decoding

decoded_string = tokenizer.decode([7993, 170, 11303, 1200, 2443, 1110, 3014])
print(decoded_string) # 输出:'Using a Transformer network is simple'

4. 处理多个序列 Handling multiple sequences

1) 模型需要一批输入 Models expect a batch of inputs

将数字列表转换为张量并将其发送到模型:

import torch
from transformers import AutoTokenizer, AutoModelForSequenceClassification

checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
model = AutoModelForSequenceClassification.from_pretrained(checkpoint)

sequence = "I've been waiting for a HuggingFace course my whole life."

tokens = tokenizer.tokenize(sequence)
ids = tokenizer.convert_tokens_to_ids(tokens)

input_ids = torch.tensor([ids])
print("Input IDs:", input_ids)

output = model(input_ids)
print("Logits:", output.logits)

# 输出
'''
Input IDs: [[ 1045,  1005,  2310,  2042,  3403,  2005,  1037, 17662, 12172,  2607, 2026,  2878,  2166,  1012]]
Logits: [[-2.7276,  2.8789]]
'''

2) 填充输入 Padding the inputs

model = AutoModelForSequenceClassification.from_pretrained(checkpoint)

sequence1_ids = [[200, 200, 200]]
sequence2_ids = [[200, 200]]
batched_ids = [
    [200, 200, 200],
    [200, 200, tokenizer.pad_token_id],
]

print(model(torch.tensor(sequence1_ids)).logits)
print(model(torch.tensor(sequence2_ids)).logits)
print(model(torch.tensor(batched_ids)).logits)

# 输出
'''
tensor([[ 1.5694, -1.3895]], grad_fn=<AddmmBackward>)
tensor([[ 0.5803, -0.4125]], grad_fn=<AddmmBackward>)
tensor([[ 1.5694, -1.3895],
        [ 1.3373, -1.2163]], grad_fn=<AddmmBackward>)
'''

5. 总结 Putting it all together

我们已经探索了分词器的工作原理,并研究了分词 tokenizers、转换为输入 ID conversion to input IDs、填充 padding、截断 truncation和注意力掩码 attention masks。Transformers API 可以通过高级函数为我们处理所有这些。

from transformers import AutoTokenizer

checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)

sequence = "I've been waiting for a HuggingFace course my whole life."

model_inputs = tokenizer(sequence)
# 可以标记单个序列
sequence = "I've been waiting for a HuggingFace course my whole life."
model_inputs = tokenizer(sequence)

# 还可以一次处理多个序列
sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"]
model_inputs = tokenizer(sequences)
# 可以根据几个目标进行填充
# Will pad the sequences up to the maximum sequence length
model_inputs = tokenizer(sequences, padding="longest")

# Will pad the sequences up to the model max length
# (512 for BERT or DistilBERT)
model_inputs = tokenizer(sequences, padding="max_length")

# Will pad the sequences up to the specified max length
model_inputs = tokenizer(sequences, padding="max_length", max_length=8)
# 还可以截断序列
sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"]

# Will truncate the sequences that are longer than the model max length
# (512 for BERT or DistilBERT)
model_inputs = tokenizer(sequences, truncation=True)

# Will truncate the sequences that are longer than the specified max length
model_inputs = tokenizer(sequences, max_length=8, truncation=True)
# 可以处理到特定框架张量的转换,然后可以将其直接发送到模型。
sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"]

# Returns PyTorch tensors
model_inputs = tokenizer(sequences, padding=True, return_tensors="pt")

# Returns TensorFlow tensors
model_inputs = tokenizer(sequences, padding=True, return_tensors="tf")

# Returns NumPy arrays
model_inputs = tokenizer(sequences, padding=True, return_tensors="np")

Special tokens

分词器在开头添加特殊词[CLS],在结尾添加特殊词[SEP]。

sequence = "I've been waiting for a HuggingFace course my whole life."

model_inputs = tokenizer(sequence)
print(model_inputs["input_ids"])

tokens = tokenizer.tokenize(sequence)
ids = tokenizer.convert_tokens_to_ids(tokens)
print(ids)

# 输出
'''
[101, 1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012, 102]
[1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012]
'''

print(tokenizer.decode(model_inputs["input_ids"]))
print(tokenizer.decode(ids))

# 输出
'''
"[CLS] i've been waiting for a huggingface course my whole life. [SEP]"
"i've been waiting for a huggingface course my whole life."
'''
# 总结:从分词器到模型
import torch
from transformers import AutoTokenizer, AutoModelForSequenceClassification

checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"]

tokens = tokenizer(sequences, padding=True, truncation=True, return_tensors="pt")
output = model(**tokens)

Huggingface Transformers库学习笔记(二):使用Transformers(上)(Using Transformers Part 1): https://blog.csdn.net/u011426236/article/details/115460564

YOLOv7来临:论文详读和解析+训练自己数据集

2022年7月,YOLOv7来临,

论文链接:https://arxiv.org/abs/2207.02696

代码链接:https://github.com/WongKinYiu/yolov7

文章摘自https://mp.weixin.qq.com/s/5qK1FIU7qp0Sv3IE49-t_w

在v7论文挂出不到半天的时间,YOLOv3和YOLOv4的官网上均挂上了YOLOv7的链接和说明,由此看来大佬们都比较认可这款检测器。

官方版的YOLOv7相同体量下比YOLOv5精度更高,速度快120%(FPS),比 YOLOX 快180%(FPS),比 Dual-Swin-T 快1200%(FPS),比 ConvNext 快550%(FPS),比 SWIN-L快500%(FPS)。在5FPS到160FPS的范围内,无论是速度或是精度,YOLOv7都超过了目前已知的检测器,并且在GPU V100上进行测试, 精度为56.8% AP的模型可达到30 FPS(batch=1)以上的检测速率,与此同时,这是目前唯一一款在如此高精度下仍能超过30FPS的检测器。另外,YOLOv7所获得的成果不止于此,例如:

  • YOLOv7-e6 (55.9% AP, 56 FPS V100 b=1) by +500% FPS faster than SWIN-L Cascade R-CNN (53.9% AP, 9.2 FPS A100 b=1)
  • YOLOv7-e6 (55.9% AP, 56 FPS V100 b=1) by +550% FPS faster than ConvNeXt-RCNN (55.2% AP, 8.6 FPS A100 b=1)
  • YOLOv7-w6 (54.6% AP, 84 FPS V100 b=1) by +120% FPS faster than YOLOv5-X6-v6.1 (55.0% AP, 38 FPS V100 b=1)
  • YOLOv7-w6 (54.6% AP, 84 FPS V100 b=1) by +1200% FPS faster than Dual-Swin-RCNN (53.6% AP, 6.5 FPS V100 b=1)
  • YOLOv7 (51.2% AP, 161 FPS V100 b=1) by +180% FPS faster than YOLOX-X (51.1% AP, 58 FPS V100 b=1)

本文做出的贡献如下:

  1. 设计了几种可训练的bag-of-freebies,使实时检测器可以在不提高推理成本的情况下大大提高检测精度;
  2. 对于目标检测的发展,作者发现了两个新的问题,即模块重参化如何高效替代原始模块,以及动态标签分配策略如何处理好不同输出层的分配。因此在本文中提出了方法进行解决。
  3. 作者为实时探测器提出了“扩展”和“复合缩放”(extend” and “compound scaling”)方法,可以更加高效地利用参数和计算量,同时,作者提出的方法可以有效地减少实时探测器50%的参数,并且具备更快的推理速度和更高的检测精度。(这个其实和YOLOv5或者Scale YOLOv4的baseline使用不同规格分化成几种模型类似,既可以是width和depth的缩放,也可以是module的缩放)

2.1 实时检测器

目前最先进的实时探测器主要基于YOLO和FCOS,如果需要研发更先进的实时检测器,通常需要具备以下特征:

  • (1)更快和更高效的网络架构;
  • (2)更有效的特征积分方法;
  • (3)更准确的检测方法;
  • (4)更鲁棒的损失函数;
  • (5)更有效的标签分配方法;
  • (6)更有效的训练方式。

2.2 模型重参化

模型重参化策略在推理阶段将多个模块合并为一个计算模块,可以看作是一种集成技术(model ensemble,其实笔者觉得更像是一种基于feature的distillation),可以将其分为模块级集成和模型级集成两类。对于模型级重新参数化有两种常见的操作:

  • 一种是用不同的训练数据训练多个相同的模型,然后对多个训练模型的权重进行平均。
  • 一种是对不同迭代次数下模型权重进行加权平均。

模块重参化是近年来一个比较流行的研究课题。这种方法在训练过程中将一个整体模块分割为多个相同或不同的模块分支,但在推理过程中将多个分支模块集成到一个完全等价的模块中。然而,并不是所有提出的重参化模块都可以完美地应用于不同的架构。考虑到这一点,作者开发了新的重参数化模块,并为各种架构设计了相关的应用程序策略。下图是作者使用重参化实现构建的多个module,按照分组数不同进行排列,为什么作者会选择32的分组数,应该搞过部署的佬们会清楚一些,模块参考:https://github.com/WongKinYiu/yolov7/blob/main/models/common.py~

2.3 模型缩放

模型缩放通过扩大或缩小baseline,使其适用于不同的计算设备。模型缩放方法通常包括不同的缩放因子,如:

  • input size(输入图像大小)
  • depth(层数)
  • width(通道数)
  • stage(特征金字塔数量)

从而在网络的参数量、计算量、推理速度和精度方面实现很好的权衡。网络架构搜索(NAS)也是目前常用的模型缩放方法之一

三、模型设计架构

3.1 高效的聚合网络

在大多数关于设计高效网络的论文中,主要考虑的因素是参数量、计算量和计算密度。但从内存访存的角度出发出发,还可以分析输入/输出信道比、架构的分支数和元素级操作对网络推理速度的影响(shufflenet论文提出)。在执行模型缩放时还需考虑激活函数,即更多地考虑卷积层输出张量中的元素数量。

图2(b)中CSPVoVNet是VoVNet的一个变体。除了考虑上述几个设计问题外,CSPVoVNet的体系结构还分析了梯度路径,使不同层能够学习更多样化的特征。上面描述的梯度分析方法还能使推理速度更快、模型更准确(看下图!其实和Resnext有点像,但比它复杂一些)。

  • 图2(c)中的ELAN出于以下设计考虑——“如何设计一个高效的网络?”得出结论是:通过控制最短最长梯度路径,更深的网络可以有效地进行学习并更好地收敛。
  • 因此,在本文中,作者提出了基于ELAN的扩展版本E-ELAN,其主要架构如图2(d)所示。在大规模ELAN中,无论梯度路径长度和计算模块数量如何,都达到了稳定的状态。但如果更多计算模块被无限地堆叠,这种稳定状态可能会被破坏,参数利用率也会降低。本文提出的E-ELAN采用expand、shuffle、merge cardinality结构,实现在不破坏原始梯度路径的情况下,提高网络的学习能力。

在体系结构方面,E-ELAN只改变了计算模块中的结构,而过渡层的结构则完全不变。作者的策略是利用分组卷积来扩展计算模块的通道和基数,将相同的group parameter和channel multiplier用于计算每一层中的所有模块。然后,将每个模块计算出的特征图根据设置的分组数打乱成G组,最后将它们连接在一起。此时,每一组特征图中的通道数将与原始体系结构中的通道数相同。最后,作者添加了G组特征来merge cardinality。除了维护原始的ELAN设计架构外,E-ELAN还可以指导不同的分组模块来学习更多样化的特性。(难以置信,要是在CPU上运行,分分钟可能爆)

3.2 基于连接的模型的模型缩放

缩放这个就不说了,和YOLOv5、Scale YOLOv4、YOLOX类似。要不就depth and width,要不就module scale,可参考scale yolov4的P4、P5、P5结构。

四、可训练的赠品礼包(bag-of-freebies)

4.1 卷积重参化

尽管RepConv在VGG上取得了优异的性能,但将它直接应用于ResNet和DenseNet或其他网络架构时,它的精度会显着降低。作者使用梯度传播路径来分析不同的重参化模块应该和哪些网络搭配使用。通过分析RepConv与不同架构的组合以及产生的性能,作者发现RepConv中的identity破坏了ResNet中的残差结构和DenseNet中的跨层连接,这为不同的特征图提供了梯度的多样性(题外话,之前在YOLOv5 Lite上做过此类实验,结果也是如此,因此v5Lite-g的模型也是砍掉了identity,但分析不出原因,作者也没给出具体的分析方案,此处蹲坑)。

基于上述原因,作者使用没有identity连接的RepConv结构。图4显示了作者在PlainNet和ResNet中使用的“计划型重参化卷积”的一个示例。

4.2 辅助训练模块

深度监督是一种常用于训练深度网络的技术,其主要概念是在网络的中间层增加额外的辅助头,以及以辅助损失为指导的浅层网络权重。即使对于像ResNet和DenseNet这样收敛效果好的网络结构,深度监督仍然可以显着提高模型在许多任务上的性能(这个和Nanodet Plus相似,按笔者理解可以当成是深层局部网络的ensemble,最后将辅助头和检测头的权重做融合)。图5(a)和(b)分别显示了“没有”和“有”深度监督的目标检测器架构,在本文中,作者将负责最终的输出头称为引导头,将用于辅助训练的头称为辅助头。

接下来讨论标签分配的问题。在过去,在深度网络的训练中,标签分配通常直接指的是ground truth,并根据给定的规则生成hard label(未经过softmax)。然而近年来,以目标检测为例,研究者经常利用网络预测的质量分布来结合ground truth,使用一些计算和优化方法来生成可靠的软标签(soft label)。例如,YOLO使用bounding box预测和ground truth的IoU作为软标签。

在本文中,作者将网络预测结果与ground truth一起考虑后再分配软标签的机制称为“标签分配器”。无论辅助头或引导头,都需要对目标进行深度监督。那么,‘’如何为辅助头和引导头合理分配软标签?”,这是作者需要考虑的问题。目前最常用的方法如图5(c)所示,即将辅助头和引导头分离,然后利用它们各自的预测结果和ground truth执行标签分配。

本文提出的方法是一种新的标签分配方法,通过引导头的预测来引导辅助头以及自身。换句话说,首先使用引导头的prediction作为指导,生成从粗到细的层次标签,分别用于辅助头和引导头的学习,具体可看图5(d)和(e)。

Lead head guided label assigner: 引导头引导“标签分配器”预测结果和ground truth进行计算,并通过优化(在utils/loss.py的SigmoidBin()函数中,传送门:https://github.com/WongKinYiu/yolov7/blob/main/utils/loss.py 生成软标签。这组软标签将作为辅助头和引导头的目标来训练模型。(之前写过一篇博客,【浅谈计算机视觉中的知识蒸馏】]https://zhuanlan.zhihu.com/p/497067556)详细讲过soft label的好处)这样做的目的是使引导头具有较强的学习能力,由此产生的软标签更能代表源数据与目标之间的分布差异和相关性。此外,作者还可以将这种学习看作是一种广义上的余量学习。通过让较浅的辅助头直接学习引导头已经学习到的信息,引导头能更加专注于尚未学习到的残余信息。

Coarse-to-fine lead head guided label assigner: Coarse-to-fine引导头使用到了自身的prediction和ground truth来生成软标签,引导标签进行分配。然而,在这个过程中,作者生成了两组不同的软标签,即粗标签和细标签,其中细标签与引导头在标签分配器上生成的软标签相同,粗标签是通过降低正样本分配的约束,允许更多的网格作为正目标(可以看下FastestDet的label assigner,不单单只把gt中心点所在的网格当成候选目标,还把附近的三个也算进行去,增加正样本候选框的数量)。原因是一个辅助头的学习能力并不需要强大的引导头,为了避免丢失信息,作者将专注于优化样本召回的辅助头。对于引导头的输出,可以从查准率中过滤出高精度值的结果作为最终输出。然而,值得注意的是,如果粗标签的附加权重接近细标签的附加权重,则可能会在最终预测时产生错误的先验结果。

4.3 其他可训练的bag-of-freebies

  1. Batch normalization:目的是在推理阶段将批归一化的均值和方差整合到卷积层的偏差和权重中。
  2. YOLOR中的隐式知识结合卷积特征映射和乘法方式:YOLOR中的隐式知识可以在推理阶段将计算值简化为向量。这个向量可以与前一层或后一层卷积层的偏差和权重相结合。
  3. EMA Model:EMA 是一种在mean teacher中使用的技术,作者使用 EMA 模型作为最终的推理模型。

五、实验

5.1 实验环境

作者为边缘GPU、普通GPU和云GPU设计了三种模型,分别被称为YOLOv7-Tiny、YOLOv7和YOLOv7-W6。同时,还使用基本模型针对不同的服务需求进行缩放,并得到不同大小的模型。对于YOLOv7,可进行颈部缩放(module scale),并使用所提出的复合缩放方法对整个模型的深度和宽度进行缩放(depth and width scale),此方式获得了YOLOv7-X。对于YOLOv7-W6,使用提出的缩放方法得到了YOLOv7-E6和YOLOv7-D6。此外,在YOLOv7-E6使用了提出的E-ELAN,从而完成了YOLOv7-E6E。由于YOLOv7-tincy是一个面向边缘GPU架构的模型,因此它将使用ReLU作为激活函数。作为对于其他模型,使用SiLU作为激活函数。

选择当前先进的检测器YOLOR作为基线。在相同设置下,表1显示了本文提出的YOLOv7模型和其他模型的对比。从结果中可以看出:

  • 与YOLOv4相比,YOLOv7的参数减少了75%,计算量减少了36%,AP提高了1.5%。
  • 与最先进的YOLOR-CSP相比,YOLOv7的参数少了43% ,计算量少了15%,AP高了0.4%。
  • 在小模型的性能中,与YOLOv4-tiny相比,YOLOv7-Tiny减少了39%的参数量和49%的计算量,但保持相同的AP。
  • 在云GPU模型上,YOLOv7模型仍然具有更高的AP,同时减少了19%的参数量和33%的计算量。

5.3 与sota算法的比较

本文将所提出的方法与通用GPU上或边缘GPU上最先进的的目标检测器进行了比较

  • 比较YOLOv7-Tiny-SiLU和YOLOv5-N(v6.1),YOLOv7-Tiny-SiLU在速度上快127帧,准确率提高10.7%。
  • YOLOv7在帧率为161帧时有51.4%的AP,而相同AP的PP-YOLOE-L只有78帧,且参数l少41%。
  • YOLOv7-X在114FPS时,比YOLOv5-L(v6.1)99FPS的推理速度更快,同时可以提高3.9%的AP。
  • YOLOv7-X与YOLOv5-X(v6.1)相比,YOLOv7-X的推理速度要快31fps。此外,在参数量和计算量方面,YOLOv7-X比YOLOv5-X(v6.1)减少了22%的参数和8%的计算量,但AP提高了2.2%。
  • 使用输入分辨率1280,YOLOv7与YOLOR进行比较,YOLOv7-W6的推理速度比YOLOR-P6快8FPS,检测率也提高了1%的AP。
  • 至于YOLOv7-E6和YOLOv5-X6(v6.1)比较时,前者的AP增益比后者高0.9%,但参数减少45%,计算量减少63%,推理速度提高了47%。
  • YOLOv7-D6的推理速度与YOLOR-E6接近,但AP提高了0.8%。
  • YOLOv7-E6E的推理速度与YOLOR-D6接近,但AP提高了0.3%。

六、结论

本文提出了一种新的实时检测器。在研究过程中,本文发现了重参化模块的替换问题和动态标签的分配问题。为了解决这一问题,提出了一种可训练的bag-of-freebies策略来提高目标检测的精度。基于此,本文开发的YOLOv7系列目标检测模型获得了最先进的结果。

训练自己数据:

数据集准备:准备coco类型数据 ,新建MyDataCoco.yaml

# COCO 2017 dataset http://cocodataset.org

# download command/URL (optional)
# download: bash ./scripts/get_coco.sh

# train and val data as 1) directory: path/images/, 2) file: path/images.txt, or 3) list: [path1/images/, path2/images/]
train:yolov7/data/train.txt  # 118287 images
val:yolov7/data/val.txt  # 5000 images
test:yolov7/data/test.txt  # 20288 of 40670 images, submit to https://competitions.codalab.org/competitions/20794

# number of classes
nc: 10

# class names
names: ['lighthouse',
'sailboat',
'buoy',
'railbar',
'cargoship',
'navalvessels',
'passengership',
'dock',
'submarine',
'fishingboat' ]

 results:

yolov6 又快又准的目标检测框架

多年来,YOLO 系列一直是高效目标检测的行业标准。YOLO 社区蓬勃发展,丰富了其在众多硬件平台和丰富场景中的使用。在这份技术报告力求将其极限推向新的高度,以坚定不移的行业应用心态向前迈进。

考虑到真实环境中对速度和准确性的不同要求,作者广泛研究了来自工业界或学术界的最新目标检测进展。具体来说,从最近的网络设计、训练策略、测试技术、量化和优化方法中大量吸收了一些想法。最重要的是,整合思想和实践,构建了一套不同规模的部署网络,以适应多样化的用例。

在 YOLO 作者的慷慨许可下,作者将其命名为 YOLOv6。作者也热烈欢迎用户和贡献者进一步增强。YOLOv6-N 在 NVIDIA Tesla T4 GPU 上以 1234 FPS 的吞吐量在 COCO 数据集上达到 35.9% 的 AP。YOLOv6-S 以 495 FPS 的速度达到 43.5% 的 AP,优于同规模的其他主流检测器(YOLOv5-SYOLOX-S 和 PPYOLOE-S)。

YOLOv6-S 量化版本甚至带来了 869 FPS 的最新 43.3% AP。此外,与具有相似推理速度的其他检测器相比,YOLOv6-M/L 还实现了更好的准确度性能(即 49.5%/52.3%)。

近日,美团视觉智能部研发了一款致力于工业应用的目标检测框架 YOLOv6,能够同时专注于检测的精度和推理效率。在研发过程中,视觉智能部不断进行了探索和优化,同时吸取借鉴了学术界和工业界的一些前沿进展和科研成果。在目标检测权威数据集 COCO 上的实验结果显示,YOLOv6 在检测精度和速度方面均超越其他同体量的算法,同时支持多种不同平台的部署,极大简化工程部署时的适配工作。特此开源,希望能帮助到更多的同学。

YOLOv6 是美团视觉智能部研发的一款目标检测框架,致力于工业应用。本框架同时专注于检测的精度和推理效率,在工业界常用的尺寸模型中:YOLOv6-nano 在 COCO 上精度可达 35.0% AP,在 T4 上推理速度可达 1242 FPS;YOLOv6-s 在 COCO 上精度可达 43.1% AP,在 T4 上推理速度可达 520 FPS。在部署方面,YOLOv6 支持 GPU(TensorRT)、CPU(OPENVINO)、ARM(MNN、TNN、NCNN)等不同平台的部署,极大地简化工程部署时的适配工作。

目前,项目已开源至Github,传送门:YOLOv6。欢迎有需要的小伙伴们Star收藏,随时取用。

精度与速度远超 YOLOv5 和 YOLOX 的新框架

目标检测作为计算机视觉领域的一项基础性技术,在工业界得到了广泛的应用,其中 YOLO 系列算法因其较好的综合性能,逐渐成为大多数工业应用时的首选框架。至今,业界已衍生出许多 YOLO 检测框架,其中以 YOLOv5[1]、YOLOX[2] 和 PP-YOLOE[3] 最具代表性,但在实际使用中,我们发现上述框架在速度和精度方面仍有很大的提升的空间。基于此,我们通过研究并借鉴了业界已有的先进技术,开发了一套新的目标检测框架——YOLOv6。该框架支持模型训练、推理及多平台部署等全链条的工业应用需求,并在网络结构、训练策略等算法层面进行了多项改进和优化,在 COCO 数据集上,YOLOv6 在精度和速度方面均超越其他同体量算法,相关结果如下图 1 所示:

图1-1 YOLOv6 各尺寸模型与其他模型性能对比
图1-1 YOLOv6 各尺寸模型与其他模型性能对比
图1-2 YOLOv6 与其他模型在不同分辨率下性能对比
图1-2 YOLOv6 与其他模型在不同分辨率下性能对比

图 1-1 展示了不同尺寸网络下各检测算法的性能对比,曲线上的点分别表示该检测算法在不同尺寸网络下(s/tiny/nano)的模型性能,从图中可以看到,YOLOv6 在精度和速度方面均超越其他 YOLO 系列同体量算法。

图 1-2 展示了输入分辨率变化时各检测网络模型的性能对比,曲线上的点从左往右分别表示图像分辨率依次增大时(384/448/512/576/640)该模型的性能,从图中可以看到,YOLOv6 在不同分辨率下,仍然保持较大的性能优势。

2. YOLOv6关键技术介绍

YOLOv6 主要在 BackBone、Neck、Head 以及训练策略等方面进行了诸多的改进:

  • 设计了更高效的 Backbone 和 Neck :受到硬件感知神经网络设计思想的启发,基于 RepVGG style[4] 设计了可重参数化、更高效的骨干网络 EfficientRep Backbone 和 Rep-PAN Neck。
  • 优化设计了更简洁有效的 Efficient Decoupled Head,在维持精度的同时,进一步降低了一般解耦头带来的额外延时开销。
  • 在训练策略上,我们采用Anchor-free 无锚范式,同时辅以 SimOTA[2] 标签分配策略以及 SIoU[9] 边界框回归损失来进一步提高检测精度。

将 YOLOv6 的主要方面总结如下:

  • 针对不同场景中的工业应用重新设计了一系列不同规模的网络。不同规模的架构各不相同,以实现最佳的速度和准确性权衡,其中小型模型具有简单的单路径主干,大型模型建立在高效的多分支块上。
  • 为 YOLOv6 注入了一种self-distillation策略,在分类任务和回归任务上都执行。同时,动态调整来自教师和标签的知识,以帮助学生模型在所有训练阶段更有效地学习知识。
  • 广泛验证标签分配、损失函数和数据增强技术的先进检测技术,并有选择地采用它们以进一步提高性能。
  • 在 RepOptimizer 和通道蒸馏的帮助下改进了检测的量化方案,这带来了具有 43.3% 的 COCO AP 和 869 FPS 的吞吐量的快速准确的检测器,批量大小为 32。

2.1 Hardware-friendly 的骨干网络设计

YOLOv5/YOLOX 使用的 Backbone 和 Neck 都基于 CSPNet[5] 搭建,采用了多分支的方式和残差结构。对于 GPU 等硬件来说,这种结构会一定程度上增加延时,同时减小内存带宽利用率。下图 2 为计算机体系结构领域中的 Roofline Model[8] 介绍图,显示了硬件中计算能力和内存带宽之间的关联关系。

图2 Roofline Model 介绍图
图2 Roofline Model 介绍图

于是,我们基于硬件感知神经网络设计的思想,对 Backbone 和 Neck 进行了重新设计和优化。该思想基于硬件的特性、推理框架/编译框架的特点,以硬件和编译友好的结构作为设计原则,在网络构建时,综合考虑硬件计算能力、内存带宽、编译优化特性、网络表征能力等,进而获得又快又好的网络结构。对上述重新设计的两个检测部件,我们在 YOLOv6 中分别称为 EfficientRep Backbone Rep-PAN Neck,其主要贡献点在于:

  1. 引入了 RepVGG[4] style 结构。
  2. 基于硬件感知思想重新设计了 Backbone 和 Neck。

RepVGG[4] Style 结构是一种在训练时具有多分支拓扑,而在实际部署时可以等效融合为单个 3×3 卷积的一种可重参数化的结构(融合过程如下图 3 所示)。通过融合成的 3×3 卷积结构,可以有效利用计算密集型硬件计算能力(比如 GPU),同时也可获得 GPU/CPU 上已经高度优化的 NVIDIA cuDNN 和 Intel MKL 编译框架的帮助。

实验表明,通过上述策略,YOLOv6 减少了在硬件上的延时,并显着提升了算法的精度,让检测网络更快更强。以 nano 尺寸模型为例,对比 YOLOv5-nano 采用的网络结构,本方法在速度上提升了21%,同时精度提升 3.6% AP。

图3 Rep算子的融合过程[4]
图3 Rep算子的融合过程[4]

EfficientRep Backbone:在 Backbone 设计方面,我们基于以上 Rep 算子设计了一个高效的Backbone。相比于 YOLOv5 采用的 CSP-Backbone,该 Backbone 能够高效利用硬件(如 GPU)算力的同时,还具有较强的表征能力。

下图 4 为 EfficientRep Backbone 具体设计结构图,将 Backbone 中 stride=2 的普通 Conv 层替换成了 stride=2 的 RepConv层。同时,将原始的 CSP-Block 都重新设计为 RepBlock,其中 RepBlock 的第一个 RepConv 会做 channel 维度的变换和对齐。另外,我们还将原始的 SPPF 优化设计为更加高效的 SimSPPF。

图4 EfficientRep Backbone 结构图
图4 EfficientRep Backbone 结构图

Rep-PAN:在 Neck 设计方面,为了让其在硬件上推理更加高效,以达到更好的精度与速度的平衡,我们基于硬件感知神经网络设计思想,为 YOLOv6 设计了一个更有效的特征融合网络结构。

Rep-PAN 基于 PAN[6] 拓扑方式,用 RepBlock 替换了 YOLOv5 中使用的 CSP-Block,同时对整体 Neck 中的算子进行了调整,目的是在硬件上达到高效推理的同时,保持较好的多尺度特征融合能力(Rep-PAN 结构图如下图 5 所示)。

图5 Rep-PAN 结构图
图5 Rep-PAN 结构图

2.2 更简洁高效的 Decoupled Head

在 YOLOv6 中,我们采用了解耦检测头(Decoupled Head)结构,并对其进行了精简设计。原始 YOLOv5 的检测头是通过分类和回归分支融合共享的方式来实现的,而 YOLOX 的检测头则是将分类和回归分支进行解耦,同时新增了两个额外的 3×3 的卷积层,虽然提升了检测精度,但一定程度上增加了网络延时。

因此,我们对解耦头进行了精简设计,同时综合考虑到相关算子表征能力和硬件上计算开销这两者的平衡,采用 Hybrid Channels 策略重新设计了一个更高效的解耦头结构,在维持精度的同时降低了延时,缓解了解耦头中 3×3 卷积带来的额外延时开销。通过在 nano 尺寸模型上进行消融实验,对比相同通道数的解耦头结构,精度提升 0.2% AP 的同时,速度提升6.8%。

图6 Efficient Decoupled Head 结构图
图6 Efficient Decoupled Head 结构图

2.3 更有效的训练策略

为了进一步提升检测精度,我们吸收借鉴了学术界和业界其他检测框架的先进研究进展:Anchor-free 无锚范式 、SimOTA 标签分配策略以及 SIoU 边界框回归损失。

Anchor-free 无锚范式

YOLOv6 采用了更简洁的 Anchor-free 检测方法。由于 Anchor-based检测器需要在训练之前进行聚类分析以确定最佳 Anchor 集合,这会一定程度提高检测器的复杂度;同时,在一些边缘端的应用中,需要在硬件之间搬运大量检测结果的步骤,也会带来额外的延时。而 Anchor-free 无锚范式因其泛化能力强,解码逻辑更简单,在近几年中应用比较广泛。经过对 Anchor-free 的实验调研,我们发现,相较于Anchor-based 检测器的复杂度而带来的额外延时,Anchor-free 检测器在速度上有51%的提升。

SimOTA 标签分配策略

为了获得更多高质量的正样本,YOLOv6 引入了 SimOTA [4]算法动态分配正样本,进一步提高检测精度。YOLOv5 的标签分配策略是基于 Shape 匹配,并通过跨网格匹配策略增加正样本数量,从而使得网络快速收敛,但是该方法属于静态分配方法,并不会随着网络训练的过程而调整。

近年来,也出现不少基于动态标签分配的方法,此类方法会根据训练过程中的网络输出来分配正样本,从而可以产生更多高质量的正样本,继而又促进网络的正向优化。例如,OTA[7] 通过将样本匹配建模成最佳传输问题,求得全局信息下的最佳样本匹配策略以提升精度,但 OTA 由于使用了Sinkhorn-Knopp 算法导致训练时间加长,而 SimOTA[4]算法使用 Top-K 近似策略来得到样本最佳匹配,大大加快了训练速度。故 YOLOv6 采用了SimOTA 动态分配策略,并结合无锚范式,在 nano 尺寸模型上平均检测精度提升 1.3% AP。

SIoU 边界框回归损失

为了进一步提升回归精度,YOLOv6 采用了 SIoU[9] 边界框回归损失函数来监督网络的学习。目标检测网络的训练一般需要至少定义两个损失函数:分类损失和边界框回归损失,而损失函数的定义往往对检测精度以及训练速度产生较大的影响。

近年来,常用的边界框回归损失包括IoU、GIoU、CIoU、DIoU loss等等,这些损失函数通过考虑预测框与目标框之前的重叠程度、中心点距离、纵横比等因素来衡量两者之间的差距,从而指导网络最小化损失以提升回归精度,但是这些方法都没有考虑到预测框与目标框之间方向的匹配性。SIoU 损失函数通过引入了所需回归之间的向量角度,重新定义了距离损失,有效降低了回归的自由度,加快网络收敛,进一步提升了回归精度。通过在 YOLOv6s 上采用 SIoU loss 进行实验,对比 CIoU loss,平均检测精度提升 0.3% AP。

3. 实验结果

经过以上优化策略和改进,YOLOv6 在多个不同尺寸下的模型均取得了卓越的表现。下表 1 展示了 YOLOv6-nano 的消融实验结果,从实验结果可以看出,我们自主设计的检测网络在精度和速度上都带来了很大的增益。

表1 YOLOv6-nano 消融实验结果
表1 YOLOv6-nano 消融实验结果

下表 2 展示了 YOLOv6 与当前主流的其他 YOLO 系列算法相比较的实验结果。从表格中可以看到:

表2 YOLOv6各尺寸模型性能与其他模型的比较
表2 YOLOv6各尺寸模型性能与其他模型的比较
  • YOLOv6-nano 在 COCO val 上 取得了 35.0% AP 的精度,同时在 T4 上使用 TRT FP16 batchsize=32 进行推理,可达到 1242FPS 的性能,相较于 YOLOv5-nano 精度提升 7% AP,速度提升 85%。
  • YOLOv6-tiny 在 COCO val 上 取得了 41.3% AP 的精度, 同时在 T4 上使用 TRT FP16 batchsize=32 进行推理,可达到 602FPS 的性能,相较于 YOLOv5-s 精度提升 3.9% AP,速度提升 29.4%。
  • YOLOv6-s 在 COCO val 上 取得了 43.1% AP 的精度, 同时在 T4 上使用 TRT FP16 batchsize=32 进行推理,可达到 520FPS 的性能,相较于 YOLOX-s 精度提升 2.6% AP,速度提升 38.6%;相较于 PP-YOLOE-s 精度提升 0.4% AP的条件下,在T4上使用 TRT FP16 进行单 batch 推理,速度提升 71.3%。

在海面图片(自己的训练集)上的训练:

is_coco: False
# Classes
nc: 10  # number of classes
names: ['lighthouse',
'sailboat',
'buoy',
'railbar',
'cargoship',
'navalvessels',
'passengership',
'dock',
'submarine',
'fishingboat']  # class names

yolov6s 结果: coco_detection_metrics ——COCO检测指标

Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.779
Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.992
Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.922
Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.661
Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.710
Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.817
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.697
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.801
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.813
Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.686
Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.740
Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.847

Average Precision (AP)和Average Recall (AR)等等这些都是啥意思?

  • IoU=0.50意味着IoU大于0.5被认为是检测到。
  • IoU=0.50:0.95意味着IoU在0.5到0.95的范围内被认为是检测到。
  • 越低的IoU阈值,则判为正确检测的越多,相应的,Average Precision (AP)也就越高。参考上面的第二第三行。
  • small表示标注的框面积小于32 * 32
  • medium表示标注的框面积同时小于96 * 96
  • large表示标注的框面积大于等于96 * 96
  • all表示不论大小,我都要。
  • maxDets=100表示最大检测目标数为100。

 Average Precision (AP)和Average Recall (AR)值里面有-1是什么情况?

参考:https://github.com/cocodataset/cocoapi/blob/master/PythonAPI/pycocotools/cocoeval.py#L52

标注里面没有此类型的目标框,则Average PrecisionAverage Recall值为-1。

Recall   召回率(查全率)。表示正确识别物体A的个数占测试集中物体A的总个数的百分数,即所有正例中预测正确的概率,Recall = tpr = TP / (TP+FN)

Precision 精确率(查准率)。表示正确识别物体A的个数占总识别出的物体个数n的百分数,即预测为正例中预测正确的概率,Precision = TP / (TP+FP)

以下12个指标用于表征COCO上物体检测器的性能:

Average Precision (AP):

AP                              % AP at IoU=0.50:0.05:0.95 (primary challenge metric)

APIoU=.50                   % AP at IoU=0.50 (PASCAL VOC metric)

APIoU=.75                   % AP at IoU=0.75 (strict metric)

AP Across Scales:

APsmall                       % AP for small objects: area < 322

APmedium                   % AP for medium objects: 322 < area < 962

APlarge                        % AP for large objects: area > 962

Average Recall (AR):

ARmax=1                     % AR given 1 detection per image

ARmax=10                   % AR given 10 detections per image

ARmax=100                 % AR given 100 detections per image

AR Across Scales:

ARsmall                       % AR for small objects: area < 322

ARmedium                   % AR for medium objects: 322 < area < 962

ARlarge                        % AR for large objects: area > 962

1)除非另有说明,否则AP和AR在多个交汇点(IoU)值上取平均值。具体来说,我们使用10个IoU阈值0.50:0.05:0.95。这是对传统的一个突破,其中AP是在一个单一的0.50的IoU上计算的(这对应于我们的度量APIoU=.50 )。超过均值的IoUs能让探测器更好定位(Averaging over IoUs rewards detectors with better localization.)。

2)AP是所有类别的平均值。传统上,这被称为“平均精确度”(mAP,mean average precision)。我们没有区分AP和mAP(同样是AR和mAR),并假定从上下文中可以清楚地看出差异。

3)AP(所有10个IoU阈值和所有80个类别的平均值)将决定赢家。在考虑COCO性能时,这应该被认为是最重要的一个指标

4)在COCO中,比大物体相比有更多的小物体。具体地说,大约41%的物体很小(面积<322),34%是中等(322 < area < 962)),24%大(area > 962)。测量的面积(area)是分割掩码(segmentation mask)中的像素数量。

5)AR是在每个图像中检测到固定数量的最大召回(recall),在类别和IoU上平均。AR与提案评估(proposal evaluation)中使用的同名度量相关,但是按类别计算。

6)所有度量标准允许每个图像(在所有类别中)最多100个最高得分检测进行计算。

7)除了IoU计算(分别在框(box)或掩码(mask)上执行)之外,用边界框和分割掩码检测的评估度量在所有方面是相同的。

测试速度:

img show:

Pytorch Image Models –timm快速使用

原文:Getting Started with PyTorch Image Models (timm): A Practitioner’s Guide – 2022.02.02

中文教程: https://www.aiuai.cn/aifarm1967.html

Github: rwightman/pytorch-image-models

PyTorch Image Models(timm) 是一个优秀的图像分类 Python 库,其包含了大量的图像模型(Image Models)、Optimizers、Schedulers、Augmentations 等等.里面提供了许多计算机视觉的SOTA模型,可以当作是torchvision的扩充版本,并且里面的模型在准确度上也较高。

timm 提供了参考的 training 和 validation 脚本,用于复现在 ImageNet 上的训练结果;以及更多的 官方文档 和 timmdocs project.

timm的安装

关于timm的安装,我们可以选择以下两种方式进行:

  1. 通过pip安装
pip install timm
  1. 通过git与pip进行安装
git clone https://github.com/rwightman/pytorch-image-models
cd pytorch-image-models && pip install -e .

如何查看预训练模型种类

  1. 查看timm提供的预训练模型 截止到2022.3.27日为止,timm提供的预训练模型已经达到了592个,我们可以通过timm.list_models()方法查看timm提供的预训练模型(注:本章测试代码均是在jupyter notebook上进行)
import timm
avail_pretrained_models = timm.list_models(pretrained=True)
len(avail_pretrained_models)
  1. 查看特定模型的所有种类 每一种系列可能对应着不同方案的模型,比如Resnet系列就包括了ResNet18,50,101等模型,我们可以在timm.list_models()传入想查询的模型名称(模糊查询),比如我们想查询densenet系列的所有模型。
all_densnet_models = timm.list_models("*densenet*")
all_densnet_models

我们发现以列表的形式返回了所有densenet系列的所有模型。

['densenet121',
 'densenet121d',
 'densenet161',
 'densenet169',
 'densenet201',
 'densenet264',
 'densenet264d_iabn',
 'densenetblur121d',
 'tv_densenet121']
  1. 查看模型的具体参数 当我们想查看下模型的具体参数的时候,我们可以通过访问模型的default_cfg属性来进行查看,具体操作如下
model = timm.create_model('resnet34',num_classes=10,pretrained=True)
model.default_cfg
{'url': 'https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/resnet34-43635321.pth',
 'num_classes': 1000,
 'input_size': (3, 224, 224),
 'pool_size': (7, 7),
 'crop_pct': 0.875,
 'interpolation': 'bilinear',
 'mean': (0.485, 0.456, 0.406),
 'std': (0.229, 0.224, 0.225),
 'first_conv': 'conv1',
 'classifier': 'fc',
 'architecture': 'resnet34'}

除此之外,我们可以通过访问这个链接 查看提供的预训练模型的准确度等信息。

使用和修改预训练模型

在得到我们想要使用的预训练模型后,我们可以通过timm.create_model()的方法来进行模型的创建,我们可以通过传入参数pretrained=True,来使用预训练模型。同样的,我们也可以使用跟torchvision里面的模型一样的方法查看模型的参数,类型/

import timm
import torch

model = timm.create_model('resnet34',pretrained=True)
x = torch.randn(1,3,224,224)
output = model(x)
output.shape
torch.Size([1, 1000])
  • 查看某一层模型参数(以第一层卷积为例)
model = timm.create_model('resnet34',pretrained=True)
list(dict(model.named_children())['conv1'].parameters())
[Parameter containing:
 tensor([[[[-2.9398e-02, -3.6421e-02, -2.8832e-02,  ..., -1.8349e-02,
            -6.9210e-03,  1.2127e-02],
           [-3.6199e-02, -6.0810e-02, -5.3891e-02,  ..., -4.2744e-02,
            -7.3169e-03, -1.1834e-02],
            ...
           [ 8.4563e-03, -1.7099e-02, -1.2176e-03,  ...,  7.0081e-02,
             2.9756e-02, -4.1400e-03]]]], requires_grad=True)]
            
  • 修改模型(将1000类改为10类输出)
model = timm.create_model('resnet34',num_classes=10,pretrained=True)
x = torch.randn(1,3,224,224)
output = model(x)
output.shape
torch.Size([1, 10])
  • 改变输入通道数(比如我们传入的图片是单通道的,但是模型需要的是三通道图片) 我们可以通过添加in_chans=1来改变
model = timm.create_model('resnet34',num_classes=10,pretrained=True,in_chans=1)
x = torch.randn(1,1,224,224)
output = model(x)

模型的保存

timm库所创建的模型是torch.model的子类,我们可以直接使用torch库中内置的模型参数保存和加载的方法,具体操作如下方代码所示

torch.save(model.state_dict(),'./checkpoint/timm_model.pth')
model.load_state_dict(torch.load('./checkpoint/timm_model.pth'))

使用示例

# replace
# optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

# with
optimizer = timm.optim.AdamP(model.parameters(), lr=0.01)

for epoch in num_epochs:
    for batch in training_dataloader:
        inputs, targets = batch
        outputs = model(inputs)
        loss = loss_function(outputs, targets)

        loss.backward()
        optimizer.step()
        optimizer.zero_grad()
        
        
#
optimizer = timm.optim.Adahessian(model.parameters(), lr=0.01)

is_second_order = (
    hasattr(optimizer, "is_second_order") and optimizer.is_second_order
)  # True

for epoch in num_epochs:
    for batch in training_dataloader:
        inputs, targets = batch
        outputs = model(inputs)
        loss = loss_function(outputs, targets)

        loss.backward(create_graph=second_order)
        optimizer.step()
        optimizer.zero_grad()

深度学习中的 Attention 机制总结与代码实现(2017-2021年)

转载自作者:mayiwei1998
本文转载自:GiantPandaCV
原文链接:
深度学习中的Attention总结

github地址:

https://github.com/xmu-xiaoma666/External-Attention-pytorch

1. External Attention

1.1. 引用

Beyond Self-attention: External Attention using Two Linear Layers for Visual Tasks.—arXiv 2021.05.05

论文地址:https://arxiv.org/abs/2105.02358

1.2. 模型结构

图片

1.3. 简介

这是五月份在arXiv上的一篇文章,主要解决的Self-Attention(SA)的两个痛点问题:(1)O(n^2)的计算复杂度;(2)SA是在同一个样本上根据不同位置计算Attention,忽略了不同样本之间的联系。因此,本文采用了两个串联的MLP结构作为memory units,使得计算复杂度降低到了O(n);此外,这两个memory units是基于全部的训练数据学习的,因此也隐式的考虑了不同样本之间的联系。

1.4. 使用方法

from attention.ExternalAttention import ExternalAttention
import torch


input=torch.randn(50,49,512)
ea = ExternalAttention(d_model=512,S=8)
output=ea(input)
print(output.shape)

2. Self Attention

2.1. 引用

Attention Is All You Need—NeurIPS2017

论文地址:https://arxiv.org/abs/1706.03762

2.2. 模型结构

2.3. 简介

这是Google在NeurIPS2017发表的一篇文章,在CV、NLP、多模态等各个领域都有很大的影响力,目前引用量已经2.2w+。Transformer中提出的Self-Attention是Attention的一种,用于计算特征中不同位置之间的权重,从而达到更新特征的效果。首先将input feature通过FC映射成Q、K、V三个特征,然后将Q和K进行点乘的得到attention map,再将attention map与V做点乘得到加权后的特征。最后通过FC进行特征的映射,得到一个新的特征。(关于Transformer和Self-Attention目前网上有许多非常好的讲解,这里就不做详细的介绍了)

2.4. 使用方法

from attention.SelfAttention import ScaledDotProductAttention
import torch

input=torch.randn(50,49,512)
sa = ScaledDotProductAttention(d_model=512, d_k=512, d_v=512, h=8)
output=sa(input,input,input)
print(output.shape)

3. Squeeze-and-Excitation(SE) Attention

3.1. 引用

Squeeze-and-Excitation Networks—CVPR2018

论文地址:https://arxiv.org/abs/1709.01507

3.2. 模型结构

图片

3.3. 简介

这是CVPR2018的一篇文章,同样非常具有影响力,目前引用量7k+。本文是做通道注意力的,因其简单的结构和有效性,将通道注意力掀起了一波小高潮。大道至简,这篇文章的思想可以说非常简单,首先将spatial维度进行AdaptiveAvgPool,然后通过两个FC学习到通道注意力,并用Sigmoid进行归一化得到Channel Attention Map,最后将Channel Attention Map与原特征相乘,就得到了加权后的特征。

3.4. 使用方法

from attention.SEAttention import SEAttention
import torch

input=torch.randn(50,512,7,7)
se = SEAttention(channel=512,reduction=8)
output=se(input)
print(output.shape)

4. Selective Kernel(SK) Attention

4.1. 引用

Selective Kernel Networks—CVPR2019

论文地址:https://arxiv.org/pdf/1903.06586.pdf

4.2. 模型结构

图片

4.3. 简介

这是CVPR2019的一篇文章,致敬了SENet的思想。在传统的CNN中每一个卷积层都是用相同大小的卷积核,限制了模型的表达能力;而Inception这种“更宽”的模型结构也验证了,用多个不同的卷积核进行学习确实可以提升模型的表达能力。作者借鉴了SENet的思想,通过动态计算每个卷积核得到通道的权重,动态的将各个卷积核的结果进行融合。

个人认为,之所以所这篇文章也能够称之为lightweight,是因为对不同kernel的特征进行通道注意力的时候是参数共享的(i.e. 因为在做Attention之前,首先将特征进行了融合,所以不同卷积核的结果共享一个SE模块的参数)。

本文的方法分为三个部分:Split,Fuse,Select。Split就是一个multi-branch的操作,用不同的卷积核进行卷积得到不同的特征;Fuse部分就是用SE的结构获取通道注意力的矩阵(N个卷积核就可以得到N个注意力矩阵,这步操作对所有的特征参数共享),这样就可以得到不同kernel经过SE之后的特征;Select操作就是将这几个特征进行相加。

4.4. 使用方法

from attention.SKAttention import SKAttention
import torch

input=torch.randn(50,512,7,7)
se = SKAttention(channel=512,reduction=8)
output=se(input)
print(output.shape)

5. CBAM Attention

5.1. 引用

CBAM: Convolutional Block Attention Module—ECCV2018

论文地址:https://openaccess.thecvf.com/content_ECCV_2018/papers/Sanghyun_Woo_Convolutional_Block_Attention_ECCV_2018_paper.pdf

5.2. 模型结构

图片
图片

5.3. 简介

这是ECCV2018的一篇论文,这篇文章同时使用了Channel Attention和Spatial Attention,将两者进行了串联(文章也做了并联和两种串联方式的消融实验)。

Channel Attention方面,大致结构还是和SE相似,不过作者提出AvgPool和MaxPool有不同的表示效果,所以作者对原来的特征在Spatial维度分别进行了AvgPool和MaxPool,然后用SE的结构提取channel attention,注意这里是参数共享的,然后将两个特征相加后做归一化,就得到了注意力矩阵。

Spatial Attention和Channel Attention类似,先在channel维度进行两种pool后,将两个特征进行拼接,然后用7×7的卷积来提取Spatial Attention(之所以用7×7是因为提取的是空间注意力,所以用的卷积核必须足够大)。然后做一次归一化,就得到了空间的注意力矩阵。

5.4. 使用方法

from attention.CBAM import CBAMBlock
import torch

input=torch.randn(50,512,7,7)
kernel_size=input.shape[2]
cbam = CBAMBlock(channel=512,reduction=16,kernel_size=kernel_size)
output=cbam(input)
print(output.shape)

6. BAM Attention

6.1. 引用

BAM: Bottleneck Attention Module—BMCV2018

论文地址:https://arxiv.org/pdf/1807.06514.pdf

6.2. 模型结构

图片

6.3. 简介

这是CBAM同作者同时期的工作,工作与CBAM非常相似,也是双重Attention,不同的是CBAM是将两个attention的结果串联;而BAM是直接将两个attention矩阵进行相加。

Channel Attention方面,与SE的结构基本一样。Spatial Attention方面,还是在通道维度进行pool,然后用了两次3×3的空洞卷积,最后将用一次1×1的卷积得到Spatial Attention的矩阵。

最后Channel Attention和Spatial Attention矩阵进行相加(这里用到了广播机制),并进行归一化,这样一来,就得到了空间和通道结合的attention矩阵。

6.4.使用方法

from attention.BAM import BAMBlock
import torch

input=torch.randn(50,512,7,7)
bam = BAMBlock(channel=512,reduction=16,dia_val=2)
output=bam(input)
print(output.shape)

7. ECA Attention

7.1. 引用

ECA-Net: Efficient Channel Attention for Deep Convolutional Neural Networks—CVPR2020

论文地址:https://arxiv.org/pdf/1910.03151.pdf

7.2. 模型结构

图片

7.3. 简介

这是CVPR2020的一篇文章。

如上图所示,SE实现通道注意力是使用两个全连接层,而ECA是需要一个的卷积。作者这么做的原因一方面是认为计算所有通道两两之间的注意力是没有必要的,另一方面是用两个全连接层确实引入了太多的参数和计算量。

因此作者进行了AvgPool之后,只是使用了一个感受野为k的一维卷积(相当于只计算与相邻k个通道的注意力),这样做就大大的减少的参数和计算量。(i.e.相当于SE是一个global的注意力,而ECA是一个local的注意力)。

7.4. 使用方法:

from attention.ECAAttention import ECAAttention
import torch

input=torch.randn(50,512,7,7)
eca = ECAAttention(kernel_size=3)
output=eca(input)
print(output.shape)

8. DANet Attention

8.1. 引用

Dual Attention Network for Scene Segmentation—CVPR2019

论文地址:https://arxiv.org/pdf/1809.02983.pdf

8.2. 模型结构

图片
图片
图示, 示意图  描述已自动生成

8.3. 简介

这是CVPR2019的文章,思想上非常简单,就是将self-attention用到场景分割的任务中,不同的是self-attention是关注每个position之间的注意力,而本文将self-attention做了一个拓展,还做了一个通道注意力的分支,操作上和self-attention一样,不同的通道attention中把生成Q,K,V的三个Linear去掉了。最后将两个attention之后的特征进行element-wise sum。

8.4. 使用方法

from attention.DANet import DAModule
import torch

input=torch.randn(50,512,7,7)
danet=DAModule(d_model=512,kernel_size=3,H=7,W=7)
print(danet(input).shape)

9. Pyramid Split Attention(PSA)

9.1. 引用

EPSANet: An Efficient Pyramid Split Attention Block on Convolutional Neural Network—arXiv 2021.05.30

论文地址:https://arxiv.org/pdf/2105.14447.pdf

9.2. 模型结构

图片
图片

9.3. 简介

这是深大5月30日在arXiv上上传的一篇文章,本文的目的是如何获取并探索不同尺度的空间信息来丰富特征空间。网络结构相对来说也比较简单,主要分成四步,第一步,将原来的feature根据通道分成n组然后对不同的组进行不同尺度的卷积,得到新的特征W1;第二步,用SE在原来的特征上进行SE,从而获得不同的阿头疼托尼;第三步,对不同组进行SOFTMAX;第四步,将获得attention与原来的特征W1相乘。

9.4. 使用方法

from attention.PSA import PSAimport torchinput=torch.randn(50,512,7,7)psa = PSA(channel=512,reduction=8)output=psa(input)print(output.shape)

10. Efficient Multi-Head Self-Attention(EMSA)

10.1. 引用

ResT: An Efficient Transformer for Visual Recognition—arXiv 2021.05.28

论文地址:https://arxiv.org/abs/2105.13677

10.2. 模型结构

图片

10.3. 简介

这是南大5月28日在arXiv上上传的一篇文章。本文解决的主要是SA的两个痛点问题:(1)Self-Attention的计算复杂度和n(n为空间维度大小)呈平方关系;(2)每个head只有q,k,v的部分信息,如果q,k,v的维度太小,那么就会导致获取不到连续的信息,从而导致性能损失。这篇文章给出的思路也非常简单,在SA中,在FC之前,用了一个卷积来降低了空间的维度,从而得到空间维度上更小的K和V。

10.4. 使用方法

from attention.EMSA import EMSAimport torchfrom torch import nnfrom torch.nn import functional as Finput=torch.randn(50,64,512)emsa = EMSA(d_model=512, d_k=512, d_v=512, h=8,H=8,W=8,ratio=2,apply_transform=True)output=emsa(input,input,input)print(output.shape)

深度学习调参技巧

以下文章来源于AI算法与图像处理 ,作者AI_study

最近在跑模型,发现自己跑出来的性能总是跟论文里的有些差别,对于很多参数,学习率、批次大小等没啥概念。。。

训练深度神经网络是困难的。它需要知识和经验,以适当的训练和获得一个最优模型。在这篇文章中,我想分享我在训练深度神经网络时学到的东西。以下提示和技巧可能对你的研究有益,并可以帮助你加速网络架构或参数搜索。

  • 1、

在你开始建立你的网络体系结构,你需要做的第一件事是验证输入到网络的数据,确保输入(x)对应于一个标签(y)。在预测的情况下,确保真实标签(y)正确编码标签索引(或者one-hot-encoding)。否则,训练就不起作用。

  • 2、

决定是选择使用预模型还是从头开始训练你的网络?

如果问题域中的数据集类似于ImageNet数据集,则对该数据集使用预训练模型。使用最广泛的预训练模型有VGG net、ResNet、DenseNet或Xception等。有许多层架构,例如,VGG(19和16层),ResNet(152, 101, 50层或更少),DenseNet(201, 169和121层)。注意:不要尝试通过使用更多的层网来搜索超参数(例如VGG-19, ResNet-152或densen -201层网络,因为它在计算量很大),而是使用较少的层网(例如VGG-16, ResNet-50或densen -121层)。选择一个预先训练过的模型,你认为它可以用你的超参数提供最好的性能(比如ResNet-50层)。在你获得最佳超参数后,只需选择相同但更多的层网(如ResNet-101或ResNet-152层),以提高准确性。ImageNet:http://www.image-net.org/challenges/LSVRC/2012/VGG net :https://arxiv.org/abs/1409.1556ResNet:https://arxiv.org/abs/1512.03385DenseNet:https://arxiv.org/abs/1608.06993Xception :https://arxiv.org/abs/1610.02357

微调几层,或者如果你有一个小的数据集,只训练分类器,你也可以尝试在你要微调的卷积层之后插入Dropout层,因为它可以帮助对抗网络中的过拟合。Dropout:http://jmlr.org/papers/v15/srivastava14a.html

如果你的数据集与ImageNet数据集不相似,你可以考虑从头构建并训练你的网络。

  • 3、

在你的网络中始终使用归一化层(normalization layers)。如果你使用较大的批处理大小(比如10个或更多)来训练网络,请使用批标准化层(BatchNormalization)。否则,如果你使用较小的批大小(比如1)进行训练,则使用InstanceNormalization层。请注意,大部分作者发现,如果增加批处理大小,那么批处理规范化会提高性能,而当批处理大小较小时,则会降低性能。但是,如果使用较小的批处理大小,InstanceNormalization会略微提高性能。或者你也可以尝试组规范化(GroupNormalization)。BatchNormalization:https://arxiv.org/abs/1502.03167InstanceNormalization:https://arxiv.org/abs/1607.08022GroupNormalization:https://arxiv.org/abs/1803.08494

  • 4、SpatialDropout

如果你有两个或更多的卷积层(比如Li)对相同的输入(比如F)进行操作(参考下面的示意图理解),那么在特征连接后使用SpatialDropout。由于这些卷积层是在相同的输入上操作的,因此输出特征很可能是相关的。因此,SpatialDropout删除了那些相关的特征,并防止网络中的过拟合。注意: 它主要用于较低的层而不是较高的层。SpatialDropout:https://arxiv.org/abs/1411.4280

SpatialDropout是Tompson等人在图像领域提出的一种dropout方法。普通的dropout会随机地将部分元素置零,而SpatialDropout会随机地将部分区域置零,该dropout方法在图像识别领域实践证明是有效的。Dropout操作随机地将部分元素置零,并且对非零部分做了一个尺度变换。尺度变换的幅度跟初始化的drop_rate有关。
作用
一般,我们会将dropout理解为“一种低成本的集成策略”,这是对的,具体过程可以大概这样理解:
经过上述置零操作后,我们可以认为零的部分是被丢弃的,丢失了一部分信息。因而,逼着模型用剩下的信息去拟合目标。然而每次dropout是随机的。我们就不能侧重于某些节点,所以总的来说就是—每次逼着模型用少量的特征学习,每次被学习的特征又不同,那么就是说,每个特征都应该对
模型的预测有所贡献(而不是侧重于部分特征,导致过拟合)。

通的dropout会随机独立地将部分元素置零,而SpatialDropout1D会随机地对某个特定的纬度全部置零。因此SpatialDropout1D需要指定Dropout维度,即对应dropout函数中的参数noise_shape。

  • 5、

为了确定你的网络容量,尝试用一小部分训练例子来超载你的网络(andrej karpathy的提示)。如果它没有超载,增加你的网络容量。在过拟合后,使用正则化技巧如L1、L2、Dropout或其他技术来对抗过拟合。L1:https://keras.io/regularizers/L2:https://keras.io/regularizers/Dropout:http://jmlr.org/papers/v15/srivastava14a.html

  • 6、

另一种正则化技术是约束或限制你的网络权值。这也有助于防止网络中的梯度爆炸问题,因为权值总是有界的。与L2正则化相反,在你的损失函数中惩罚高权重,这个约束直接正则化你的权重。你可以在Keras中轻松设置权重约束

  • 7、

对数据进行均值减法有时会产生非常糟糕的效果,特别是对灰度图像进行减法(我个人在前景分割领域就遇到过这个问题)。

  • 8、在训练前和训练期间,确保打乱训练数据,以防你不能从时序数据中获取有用信息。这可能有助于提高您的网络性能。
  • 9、如果你的问题域与稠密预测(dense prediction)相关(如语义分割),我建议你使用膨胀残差网络作为预训练模型,因为它最适合稠密预测。Dilated Residual Networks:https://arxiv.org/abs/1705.09914
  • 10. 要捕获对象周围的上下文信息,可以使用多尺度特性的池化模块。该思想成功地应用于语义分割或前景分割中。semantic segmentation:https://arxiv.org/abs/1802.02611foreground segmentation:https://arxiv.org/abs/1808.01477
  • 11 、 Opt-out void labels(或模糊区域)从您的损失或精度计算,如果有。这可以帮助你的网络在预测时更有信心。
  • 12、如果你有高度不平衡的数据问题,在训练期间应用类别加权操作。换句话说,给稀少的类更多的权重,但给主要类更少的权重。使用sklearn可以很容易地计算类权重。或者尝试使用过采样和欠采样技术重新采样你的训练集。这也可以帮助提高预测的准确性。
  • 13、选择一个正确的优化器。有许多流行的自适应优化器,如Adam, Adagrad, Adadelta,或RMSprop等。SGD+动量被广泛应用于各种问题领域。有两件事需要考虑:第一,如果你关心快速收敛,使用自适应优化器,如Adam,但它可能会陷入局部极小,提供了糟糕的泛化(下图)。第二,SGD+momentum可以实现找到全局最小值,但它依赖于鲁棒初始化,而且可能比其他自适应优化器需要更长的时间来收敛(下图)。我建议你使用SGD+动量,因为它能达到更好的最佳效果。有三个学习率起点(即1e- 1,1e -3和1e-6)。如果您对预训练模型进行微调,请考虑小于1e-3(比如1e-4)的低学习率。如果您从头开始训练您的网络,请考虑一个大于或等于1e-3的学习率。您可以尝试这些起点,并调整它们,看看哪个是最好的,选择那个。还有一件事,您可以考虑通过使用 Learning Rate Schedulers来降低训练过程中的学习率。这也可以帮助提高网络性能。
  • 14、 除了Learning Rate Schedule 外,即在一定的次数后降低学习率,还有另一种方式,我们可以由一些因素减少学习率,如果验证损loss在某些epoch(比如5)停止改善,减小学习率和如果验证损失停止改善在某些epoch(比如10),停止训练过程。这可以通过在Keras中使用early stop的ReduceLROnPlateau很容易做到。
  • 15、如果您在dense prediction领域工作,如前景分割或语义分割,您应该使用跳过连接,因为对象边界或有用的信息会由于最大池化操作或strided convolutions而丢失。这也可以帮助您的网络轻松地学习特征空间到图像空间的特征映射,有助于缓解网络中的消失梯度问题。
  • 16、数据越多越好!总是使用数据增强,如水平翻转,旋转,缩放裁剪等。这可以帮助大幅度提高精确度。
  • 17、你必须要有一个高速的GPU来进行训练,但是这有点昂贵。如果你想使用免费的云GPU,我推荐使用谷歌Colab。如果你不知道从哪里开始,看看我之前的文章或者尝试各种云GPU平台,如Floydhub或Paperspace等。
  • 18、

在ReLU之前使用最大池化来节省一些计算。由于ReLU阈值的值为0:f(x)=max(0,x)和最大池化只有max激活:f(x)=max(x1,x2,…,xi),使用Conv > MaxPool > ReLU 而不是Conv > ReLU > MaxPool。例如,假设我们有两个从Conv来的激活值(即0.5和-0.5):因此MaxPool > ReLU = max(0, max(0.5,-0.5)) = 0.5和ReLU > MaxPool = max(max(0,0.5), max(0,-0.5)) = 0.5看到了吗?这两个操作的输出仍然是0.5。在这种情况下,使用MaxPool > ReLU可以节省一个max 操作。

19、 考虑采用深度可分离卷积运算,与常规的卷积运算相比,该运算速度快,且参数数量大大减少。Depthwise Separable Convolution:https://arxiv.org/abs/1610.02357