精华内容
下载资源
问答
  • 论文基于注意力机制的卷积神经网络模型源代码 要求 python2.7 keras 2.0 斯克莱恩 麻木 keras后端= theano 论文中提出一种基于注意力机制的卷积神经网络模型 文件说明: 先生:电影评论数据集,分为两个文件,一个...
  • 基于层次注意力机制神经网络模型的虚假评论识别.pdf
  • 注意力神经网络基本原理和实现 1、 图神经网络(GNN)综述 1.1、图结构 图是计算机中的一种数据结构,图的基本构成单元是顶点 和边。一个图是由多个顶点和多条边所构成的,对于图中的任意两个顶点,如果两个点之间的...

    图注意力神经网络基本原理和代码解读

    1、 图注意力神经网络(GAT)基本原理

    1.1、图结构

    是计算机中的一种数据结构,图的基本构成单元是顶点。一个图是由多个顶点和多条边所构成的,对于图中的任意两个顶点,如果两个点之间的边是有方向的边,则称为有向图,如果边没有方向,则称为无向图。
    在现实生活中,无论是我们的社交网络和目前非常热门的知识图谱,其抽象的结构都是一个图结构。

    1.2 图注意力神经网络(GAT)

    图注意力神经网络 顾名思义,就是以图结构为基础的,在图上运行的一种神经网络结构。图注意力网络在图神经网络(GNN)的基础上引入了注意力机制。

    1.2.1 图注意力网络的输入

    在图注意力网络中,其节点的特征表示和普通的图神经网络中的节点的特征表示是类似的,都是采用embedding的方式对节点的特征表示进行向量化。对于图注意力神经网络而言,其初始的输入也是各个节点的特征组合。用公式表示就是:

    h = h 1 , h 2 , h 3 , . . . . . . h n , h i ∈ R F h = {h1,h2,h3,......hn},hi∈R^F h=h1,h2,h3,......hn,hiRF

    其中n表示图中节点的数量。F表示的是每一个节点的特征表示的数量。

    1.2.2 图注意网络的输出

    基本图示为:
    在这里插入图片描述

    图注意力网络中,在输入图中节点的特征之后,经过神经网络内部的运算,特神经网络对于下一层输出仍然是一系列的特征,用公式表达是:

    h ′ = h 1 ′ , h 2 ′ , . . . . . . h n ′ h i ′ ∈ R F ′ h' = {h_1',h_2',......h_n'} h_i'∈R^{F'} h=h1,h2,......hnhiRF
    ,其中F‘输出的节点的特征数量,n表示节点的数量。

    1.2.3 图注意力网络的计算过程

    首先,根据特征数量F向特征数量F’的转换过程,则只是需要一个特征转换的矩阵W,完成这种特征的转换。
    所以,首先定义一个权重矩阵 W ∈ R F ′ ∗ F W∈R^{F' * F} WRFF,用来完成所有节点的特征转换过程。变换公式为:

    z j = W h j z_j = Wh_j zj=Whj

    其次,我们引入的是注意力机制,在GAT中,使用的是自注意力机制(self-attention),使用一个共享的注意力计算函数α,其计算公式为:
    e i j = α ( W ( h i ∣ ∣ h j ) ) e_{ij} = α(W(h_i||h_j)) eij=α(W(hihj))

    这表示节点j的特征对于节点i贡献度。在整个计算的过程中,需要计算节点i的每一个邻居节点k对i的贡献度。注意"||"表示向量的拼接。
    然后,我们将这种权重转换成对应的权重,也就是对于各个邻接节点k的贡献度进行归一化。其计算公式为:
    a i j = s o f t m a x ( e i j ) = e x p ( e i j ) / ∑ k ∈ N i e x p ( e i k ) a_{ij} = softmax(e_{ij}) = exp(e_{ij})/∑_{k∈Ni}exp(e_{ik}) aij=softmax(eij)=exp(eij)/kNiexp(eik)

    对于线性层的运算,一般情况下都要对其进行非线性函数的激活,在论文中采用的是LeakyRelu激活函数,斜率为0.2。则最终的注意力计算公式为
    a i j = s o f t m a x ( l e a k y R e l u ( e i j ) ) = e x p ( e i j ) / ∑ k ∈ N i e x p ( l e a k y ( e i k ) ) a_{ij} = softmax(leakyRelu(e_{ij})) = exp(e_{ij})/∑_{k∈Ni}exp(leaky(e_{ik})) aij=softmax(leakyRelu(eij))=exp(eij)/kNiexp(leaky(eik))

    最终,在计算完i节点的每一个相邻节点的贡献度之后,根据权重,对i节点得所有相邻节点进行特征求和更新。作为i节点的最终输出,其计算公式为:

    h i ′ = σ ( ∑ j ∈ n i a i j z j ) h_i' = σ(∑_{j ∈n_i }a_{ij}z_j) hi=σ(jniaijzj)

    多头注意力机制的改进:为了稳定注意力机制学习的过程,这里采用多头注意力机制的改进,则对应点的计算公式为:
    在这里插入图片描述
    其中||表示的是连接,也就是对每一个注意力机制下的计算结果进行连接。
    多头注意力的进一步改进:在这里,我们将这种多头注意力机制作用在最后一层,也就是将原来的向量拼接改为向量均值。对应的计算公式为:
    在这里插入图片描述
    至此,根据注意力机制,各个节点的特征计算完成。

    2、代码解析

    layers.py

    import numpy as np
    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    
    class GraphAttentionLayer(nn.Module):
    	'''
    	带有attention计算的网络层
    	'''
        def __init__(self, in_features, out_features, dropout, alpha, concat=True):
        '''
        参数:in_features 输入节点的特征数F
        参数:out_features 输出的节点的特征数F'
        参数:dropout 
        参数:alpha LeakyRelu激活函数的斜率
        参数:concat
        '''
            super(GraphAttentionLayer, self).__init__()
            self.dropout = dropout
            self.in_features = in_features #输入特征数
            self.out_features = out_features #输出特征数
            self.alpha = alpha # 激活斜率 (LeakyReLU)的激活斜率
            self.concat = concat #用来判断是不是最有一个attention
    
            self.W = nn.Parameter(torch.zeros(size=(in_features, out_features))) #建立一个w权重,用于对特征数F进行线性变化
            nn.init.xavier_uniform_(self.W.data, gain=1.414) #对权重矩阵进行初始化
            self.a = nn.Parameter(torch.zeros(size=(2*out_features, 1))) #计算函数α,输入是上一层两个输出的拼接,输出的是eij,a的size为(2*F',1)
            nn.init.xavier_uniform_(self.a.data, gain=1.414) #对a进行初始化
            self.leakyrelu = nn.LeakyReLU(self.alpha) #激活层
         #前向传播过程
        def forward(self, input, adj):
        '''
        参数input:表示输入的各个节点的特征矩阵
        参数adj :表示邻接矩阵
        '''
        	#线性变化特征的过程,h的size为(N,F'),N表示节点的数量,F‘表示输出的节点的特征的数量
            h = torch.mm(input, self.W) 
            #获取当前的节点数量
            N = h.size()[0] 
            #下面是self-attention input ,构建自我的特征矩阵
            #参数的计算过程如下:
            #h.repeat(1,N)将h的每一行按列扩展N次,扩展后的size为(N,F'*N)
            #.view(N*N,-1)对扩展后的矩阵进行重新排列,size为(N*N,F')每N行表示的都是同一个节点的N次重复的特征表示。
            #h.repeat(N,1)对当前的所有行重复N次,每N行表示N个节点的特征表示
            #torch.cat对view之后和repeat(N,1)的特征进行拼接,每N行表示一个节点的N次特征重复,分别和其他节点做拼接。size为(N*N,2*F')
            #.view(N,-1,2*self.out_features)表示将矩阵整理为(N,N,2*F')的形式。第一维度的每一个表示一个节点,第二个维度表示上一个节点对应的其他的所有节点,第三个节点表示特征拼接
            a_input = torch.cat([h.repeat(1, N).view(N * N, -1), h.repeat(N, 1)], dim=1).view(N, -1, 2 * self.out_features)
            #每一行是一个词与其他各个词的相关性值
            #matmul(a_input,self.a) 的size为(N,N,1)表示eij对应的数值,最后对第二个维度进行压缩
            #e的size为(N,N),每一行表示一个节点,其他各个节点对该行的贡献度
            e = self.leakyrelu(torch.matmul(a_input, self.a).squeeze(2))
            
            #生成一个矩阵,size为(N,N)
            zero_vec = -9e15*torch.ones_like(e)
            #对于邻接矩阵中的元素,>0说明两种之间有变连接,就用e中的权值,否则表示没有变连接,就用一个默认值来表示
            attention = torch.where(adj > 0, e, zero_vec)
            #做一个softmax,生成贡献度权重
            attention = F.softmax(attention, dim=1)
            #dropout操作
            attention = F.dropout(attention, self.dropout, training=self.training)
            #根据权重计算最终的特征输出。
            h_prime = torch.matmul(attention, h)
    
            if self.concat:
                return F.elu(h_prime) #做一次激活
            else:
                return h_prime
        #打印输出类名称,输入特征数量,输出特征数量
        def __repr__(self):
            return self.__class__.__name__ + ' (' + str(self.in_features) + ' -> ' + str(self.out_features) + ')'
    
    
    class SpecialSpmmFunction(torch.autograd.Function):
        """Special function for only sparse region backpropataion layer.
           对稀疏区域的反向传播函数
        """
        @staticmethod
        def forward(ctx, indices, values, shape, b):
            assert indices.requires_grad == False 
            a = torch.sparse_coo_tensor(indices, values, shape)
            ctx.save_for_backward(a, b)
            ctx.N = shape[0]
            return torch.matmul(a, b)
    
        @staticmethod
        def backward(ctx, grad_output):
            a, b = ctx.saved_tensors
            grad_values = grad_b = None
            if ctx.needs_input_grad[1]:
                grad_a_dense = grad_output.matmul(b.t())
                edge_idx = a._indices()[0, :] * ctx.N + a._indices()[1, :]
                grad_values = grad_a_dense.view(-1)[edge_idx]
            if ctx.needs_input_grad[3]:
                grad_b = a.t().matmul(grad_output)
            return None, grad_values, None, grad_b
    
    class SpecialSpmm(nn.Module): 
        def forward(self, indices, values, shape, b):
            return SpecialSpmmFunction.apply(indices, values, shape, b)
    
    class SpGraphAttentionLayer(nn.Module):
        """
        Sparse version GAT layer, similar to https://arxiv.org/abs/1710.10903
        """
    
        def __init__(self, in_features, out_features, dropout, alpha, concat=True):
            super(SpGraphAttentionLayer, self).__init__()
            self.in_features = in_features
            self.out_features = out_features
            self.alpha = alpha
            self.concat = concat
    
            self.W = nn.Parameter(torch.zeros(size=(in_features, out_features)))
            nn.init.xavier_normal_(self.W.data, gain=1.414)
                    
            self.a = nn.Parameter(torch.zeros(size=(1, 2*out_features)))
            nn.init.xavier_normal_(self.a.data, gain=1.414)
    
            self.dropout = nn.Dropout(dropout)
            self.leakyrelu = nn.LeakyReLU(self.alpha)
            self.special_spmm = SpecialSpmm()
    
        def forward(self, input, adj):
            dv = 'cuda' if input.is_cuda else 'cpu'
    
            N = input.size()[0]
            edge = adj.nonzero().t()
    
            h = torch.mm(input, self.W)
            # h: N x out
            assert not torch.isnan(h).any()
    
            # Self-attention on the nodes - Shared attention mechanism
            edge_h = torch.cat((h[edge[0, :], :], h[edge[1, :], :]), dim=1).t()
            # edge: 2*D x E
    
            edge_e = torch.exp(-self.leakyrelu(self.a.mm(edge_h).squeeze()))
            assert not torch.isnan(edge_e).any()
            # edge_e: E
    
            e_rowsum = self.special_spmm(edge, edge_e, torch.Size([N, N]), torch.ones(size=(N,1), device=dv))
            # e_rowsum: N x 1
    
            edge_e = self.dropout(edge_e)
            # edge_e: E
    
            h_prime = self.special_spmm(edge, edge_e, torch.Size([N, N]), h)
            assert not torch.isnan(h_prime).any()
            # h_prime: N x out
            
            h_prime = h_prime.div(e_rowsum)
            # h_prime: N x out
            assert not torch.isnan(h_prime).any()
    
            if self.concat:
                # if this layer is not last layer,
                return F.elu(h_prime)
            else:
                # if this layer is last layer,
                return h_prime
    
        def __repr__(self):
            return self.__class__.__name__ + ' (' + str(self.in_features) + ' -> ' + str(self.out_features) + ')'
    
    

    model.py

    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    from layers import GraphAttentionLayer, SpGraphAttentionLayer
    
    class GAT(nn.Module):
        def __init__(self, nfeat, nhid, nclass, dropout, alpha, nheads):
            """
               参数1 :nfeat   输入层数量
               参数2: nhid    输出特征数量
               参数3: nclass  分类个数
               参数4: dropout dropout 斜率
               参数5: alpha  激活函数的斜率
               参数6: nheads 多头部分
            
            """
            super(GAT, self).__init__()
            self.dropout = dropout
            #根据多头部分给定的数量声明attention的数量
            self.attentions = [GraphAttentionLayer(nfeat, nhid, dropout=dropout, alpha=alpha, concat=True) for _ in range(nheads)]
            #将多头的各个attention作为子模块添加到当前模块中。
            for i, attention in enumerate(self.attentions):
                self.add_module('attention_{}'.format(i), attention)
            #最后一个attention层,输出的是分类
            self.out_att = GraphAttentionLayer(nhid * nheads, nclass, dropout=dropout, alpha=alpha, concat=False)
        #前向传播过程
        def forward(self, x, adj):
            #参数x:各个输入的节点得特征表示
            #参数adj:邻接矩阵表示
            x = F.dropout(x, self.dropout, training=self.training)
            #对每一个attention的输出做拼接
            x = torch.cat([att(x, adj) for att in self.attentions], dim=1)
            x = F.dropout(x, self.dropout, training=self.training)
            # self.out_att(x,adj)
            #输出的是带有权重的分类特征
            x = F.elu(self.out_att(x, adj))
            #各个分类的概率归一化
            return F.log_softmax(x, dim=1)
    
    
    class SpGAT(nn.Module):
        def __init__(self, nfeat, nhid, nclass, dropout, alpha, nheads):
            """Sparse version of GAT."""
            super(SpGAT, self).__init__()
            self.dropout = dropout
    
            self.attentions = [SpGraphAttentionLayer(nfeat, 
                                                     nhid, 
                                                     dropout=dropout, 
                                                     alpha=alpha, 
                                                     concat=True) for _ in range(nheads)]
            for i, attention in enumerate(self.attentions):
                self.add_module('attention_{}'.format(i), attention)
    
            self.out_att = SpGraphAttentionLayer(nhid * nheads, 
                                                 nclass, 
                                                 dropout=dropout, 
                                                 alpha=alpha, 
                                                 concat=False)
    
        def forward(self, x, adj):
            x = F.dropout(x, self.dropout, training=self.training)
            x = torch.cat([att(x, adj) for att in self.attentions], dim=1)
            x = F.dropout(x, self.dropout, training=self.training)
            x = F.elu(self.out_att(x, adj))
            return F.log_softmax(x, dim=1)
    
    
    
    展开全文
  • 作为一种代表性的图卷积网络,Graph Attention Network (GAT) 引入了注意力机制来实现更好的邻居聚合。通过学习邻居的权重,GAT 可以实现对邻居的加权聚合。因此,GAT 不仅对于噪音邻居较为鲁棒,注意力机制也赋予了...
  • 行业分类-作业装置-一种基于注意力机制神经网络的腹部淋巴结分区方法.7z
  • 为了提高低照度图像的清晰度和避免颜色失真,提出了基于注意力机制和卷积神经网络(CNN)的低照度图像增强算法,以改善图像质量。首先根据Retinex模型合成训练数据,将原始图像从RGB (red-green-blue)颜色空间变换到HSI ...
  • 神经网络注意力机制

    千次阅读 2020-09-19 00:47:14
    神经网络来处理大量的输入信息时,也可以借助人脑的注意力机制,只选择一些关键的信息输入进行处理,用来提高神经网络的效率。在目前的神经网络模型中,可以将max pooling和gating机制近似地看作是自下而上的基于...
    1. 概述
      当神经网络来处理大量的输入信息时,也可以借助人脑的注意力机制,只选择一些关键的信息输入进行处理,用来提高神经网络的效率。在目前的神经网络模型中,可以将max pooling和gating机制近似地看作是自下而上的基于显著性的注意力机制。此外,自上而下的聚焦式注意力也是一种有效的信息选择方法。例如:给定一篇很长的文章,然后就此文章的内容进行提问,提出的问题只和文章中某个段落中的一两个句子相关,其余都无关的。为了减小神经网络的计算代价,只需要把相关的片段挑选出来让后续的神经网络来处理,而不需要把所有文章内容都输入到神经网络中。

    2. 为什么要引入Attention机制?
      计算能力的限制:当要记住很多“信息“,模型就要变得更复杂,然而目前计算能力依然是限制神经网络发展的瓶颈。
      优化算法的限制:虽然局部连接、权重共享以及pooling等优化操作可以让神经网络变得简单一些,有效缓解模型复杂度和表达能力之间的矛盾;但是,如循环神经网络中的长距离以来问题,信息“记忆”能力并不高。可以借助人脑处理信息过载的方式,例如Attention机制可以提高神经网络处理信息的能力。

    3. Attention机制基础知识
      X X X = [ x1 , ⋯ , xN ] 表示 N N N 组输入信息,其中每个向量 xi , i ∈ [1, N N N ]都表示一组输入信息。为了节省计算资源,不需要将所有的信息都输入到神经网络中,只需要从X中选择一些和任务相关的信息。注意力机制的计算可以分为两步:
      (1)在所有输入信息上计算注意力分布;
      (2)根据注意力分布来计算输入信息的加权平均

    • 3.1 注意力分布
      • 为了从 N N N 个输入向量 [x1 , ⋯ , xN ] 中选择出与某个特定任务相关的信息,需要引入一个和任务相关的表示,称为查询向量 q,并通过一个打分函数来计算每个输入向量和查询向量之间的相关性。

      • 给定一个和任务相关的查询向量q,用注意力变量 z z z ∈ [1, N N N] 来表示被选择信息的索引位置,即 z = i z=i z=i表示选择了第 i i i 个输入向量。为了方便计算,下面首先介绍Soft Attention注意力机制。首先计算在给定 q q q X X X 下,选择第i个输入向量的概率 α i \alpha_{i} αi

        α i = p ( z = i ∣ X , q ) = s o f t m a x ( s ( x i , q ) ) = e x p ( s ( x i , q ) ) ∑ j = 1 N e x p ( s ( x j , q ) ) \alpha_{i}=p(z=i|X,q)=softmax(s(x_{i},q))=\frac{exp(s(x_{i},q))}{\sum_{j=1}^{N}exp(s(x_{j},q))} αi=p(z=iX,q)=softmax(s(xi,q))=j=1Nexp(s(xj,q))exp(s(xi,q))
        其中 α i \alpha_{i} αi称为注意力分布, S ( x i , q ) S\left(\mathbf{x}_{i}, \mathbf{q}\right) S(xi,q)是注意力打分函数,可以使用下面的几种方法来计算:

      • 加性模型 s ( x i , q ) = v T tanh ⁡ ( W x i + U q ) s\left(\mathbf{x}_{i}, \mathbf{q}\right)=\mathbf{v}^{\mathrm{T}} \tanh \left(W \mathbf{x}_{i}+U \mathbf{q}\right) s(xi,q)=vTtanh(Wxi+Uq)

      • 点积模型 s ( x i , q ) = x i T q s\left(\mathbf{x}_{i}, \mathbf{q}\right)=\mathbf{x}_{i}^{\mathrm{T}} \mathbf{q} s(xi,q)=xiTq

      • 缩放点积模型 s ( x i , q ) = x i T q d s\left(\mathbf{x}_{i}, \mathbf{q}\right)=\frac{\mathbf{x}_{i}^{\mathrm{T}} \mathbf{q}}{\sqrt{d}} s(xi,q)=d xiTq

      • 双线性模型 s ( x i , q ) = x i T W q s\left(\mathbf{x}_{i}, \mathbf{q}\right)=\mathbf{x}_{i}^{\mathrm{T}} W \mathbf{q} s(xi,q)=xiTWq

    • 上式中 W W W U U U v v v是可学习的参数, d d d 是输入向量的维度。理论上,加性模型和点积模型的复杂度差不多,但是点积模型在实现上可以更好地利用矩阵乘积,从而计算效率更高。但当输入向量的维度d比较高,点积模型的值通常有较大的方差,从而导致softmax函数的梯度比较小。因此,缩放点积模型可以很好地解决这个问题。双线性模型可以看做是一种泛化的点积模型。
    • 加权平均
      注意力分布 α i \alpha_{i} αi可以解释为在给定任务相关的查询q时,第i个输入向量受注意的程度。下面采用一种软性的信息选择机制对输入信息进行汇总。
      a t t ( X , q ) = ∑ i = 1 N α i x i = E z ∼ p ( z ∣ X , q ) [ x z ] att(X, q)=\sum_{i=1}^{N}\alpha_{i}x_{i}=E_{z\sim p(z|X,q)}[x_{z}] att(X,q)=i=1Nαixi=Ezp(zX,q)[xz]
      上式称为软注意力机制(Soft Attention Mechanism)。下图给出了软注意力机制的示例图:
      在这里插入图片描述
      上图键值对模式就是普通模式的推广。
    展开全文
  • 注意力机制神经网络中的应用 0. 前言 这篇是我在一门专业选修课上的结课论文,当时的认识还是太过浅薄。 最近开始系统学习NLP相关知识,先将这篇小论文发出来,之后会写关于2017年谷歌发布的《Attention Is All ...

    注意力机制在神经网络中的应用


    0. 前言

    这篇是我在一门专业选修课上的结课论文,当时的认识还是太过浅薄。
    最近开始系统学习NLP相关知识,先将这篇小论文发出来,之后会写关于2017年谷歌发布的《Attention Is All You Need》的笔记,还有Transformer的代码实现。鼓励自己学习,欢迎大家批评指正。


    1. 相关认知神经科学的实验结果

    注意力视觉同认识神经科学的联系是在视觉方面,我们经常说的注意力不集中都是体现在我们使用眼睛去看的过程。对于注意力机制的研究,早在上世纪九十年代就有人研究,但是在本世纪才出现了对于注意力机制在视觉领域和自然语言处理方面的应用。

    2014年,Google Deep Mind发表了题为《Recurrent Models of Visual
    Attention》的论文,第一次将注意力机制应用在计算机视觉领域,该研究组织将注意力机制引入到RNN模型当中,提出了RAM(The
    Recurrent Attention
    Model)模型按照时间顺序处理输入,一次在一张图像中处理不同位置,结合信息以建立一个同环境相关的动态间隔表示,该模型可以基于过去的信息和任务需要选择下一个位置进行处理,可以摆脱源文件的大小约束。

    RAM(The Recurrent Attention Model)模型

    同年,Bahdanau[1]等人发表论文《Neural Machine Translation by Jointly Learning to Align and Translate》,在这篇文章中,将类似注意力机制应用在了NLP(Neural Language Processing,自然语言处理)领域,其采用Seq2Seq+Attention模型来进行机器翻译,效果得到显著提升,之后,基于Attention的RNN模型被广泛应用到各种NLP任务中。

    2015年,Minh-Thang Luong[2]发表论文《Effective Approaches to Attention-based Neural Machine Translation》,本篇论文极大促进了后续各种基于attention机制的模型在NLP领域的应用,在该篇文章中,提出了全局注意力机制和局部注意力机制。

    Attention机制的研究重要节点是2017年,Google的机器翻译团队在NIPS
    2017发表《Attention is All You Need》[3],该研究中,完全摆脱了RNN和CNN等现有网络结构的束缚,仅仅采用了Attention机制来完成机器翻译任务,提出了Transformer网络结构,Transformer在NLP、CV(Computer Vision, 计算机视觉)领域都得到充分应用。

    Transformer网络结构
    2018年,Google进一步发展Transformer网络,发布《Pre-training of Deep
    Bidirectional Transformers for Language
    Understanding》[4],BERT模型是基于Transformer发展而来,对Attention机制的应用更加充分,成功在11项NLP任务中取得优秀成果,在自然语言处理领域得到不少赞声。


    2. 算法的基本原理

    人工智能这个学科的出现,便是人们对机器拟人态的追求,Attention机制便是对人的感知方式和注意力原理的应用。

    人类视觉领域的注意力机制是人类视觉特有的信号处理机制,人大脑视觉领域可以通过快速扫描图像局部,获取需要重点关注的目标区域,集中注意力。对于判断为无关的区域,将给予极少的和注意力,这样的视觉原理使得人类可以利用有限的注意力资源从大量信息中筛选得到高价值的信息,极大提高了人类视觉处理信息的效率,同时保证了准确性,下图很好的表示了人类对于注意力的合理安排。

    在这里插入图片描述

    人类将更多的注意力分配到人脸、文字等具有极高辨识度的区域,而对文章中的空白背景等不具有特征的部分则不会倾注太多注意力[7]。

    注意力机制便是将该原理应用到机器学习中,计算机视觉领域就是使机器训练识别关注点,从而忽略其他不重要的部分,在机器中的操作是使其模糊化。而在自然语言处理领域,则是采取提取关键字的方式来集中机器注意力。

    对于Attention机制原理的阐述离不开encoder-decoder模型,最初注意力机制便是在这个模型中得到使用,而且目前大多数注意力模型也都是依赖于encoder-decoder框架下。

    该框架可以看作是一种研究模式,抽象框架中,我们是先将源语言输入encoder中进行编码,得到语义编码c传递给decoder中进行解码,从而实现语言间的翻译。

    在这里插入图片描述
    在这里插入图片描述

    这种传统的encoder-decoder框架是没有体现出注意力的重要性的,它属于注意力不集中的分心模型,在这样的框架下的翻译,对每个词翻译时,其他单词都对翻译产生一样的影响,而实际上我们在翻译特定词时,这个单词本身应该占有很大的权重,这样才能在翻译长句子时也保证准确性。

    在分配了不同的权重之后,encoder-decoder框架中间的予以编码C换成根据当前翻译单词基于注意力模型来调整得到的变化的Ci变量[7]。

    在这里插入图片描述
    在这里插入图片描述

    公式中,针对不同的待翻译元素,Ci取到不同的值,同时,语义编码的过程中还要考虑到其他元素对于翻译产生的影响。在不同权重比的影响下,机器对单词的翻译的准确度得到提高,短句对齐效果更好。

    基于上面对于encoder-decoder框架的解释,我们下面介绍Attention机制的本质思想。我们可以将源语言中的词汇想象成是由一系列键值对<Key,
    Value>构成,譬如在英语中,dance这样的实义动词和yeah这样的语气词会具有不同的Value,然后我们给定目标语言中某个元素Query,然后进行如下三步操作。

    在这里插入图片描述

    第一步是要先计算Q和K的相似程度,公式如下:

    第二步是将得到的相似度进行Softmax操作,实现归一化。

    最后一步是需要将得到的归一化权重,同键值对中的Value计算加权和,得到我们需要的Attention向量。
    在这里插入图片描述

    由Attention向量的计算过程,我们可以体会到注意力机制的核心思想,即将有限的注意力放到少量重要信息上,忽略大部分不重要的信息,而重要性的判断则是依靠Value值,Value值越大代表其带给我们的信息越重要。

    这种Attention类型称之为Soft Attention[6],软性注意力机制的关注相对发散,实际应用中将元素归一化为0~1之间的元素。与之相对性的Hard
    Attention在实际应用中只输出一个0或1二元变量。

    举一个简单的NLP例子,我们将一句“我爱中国。”,翻译的结果应该是“I love
    China.”如果采用硬性注意力机制,翻译“我”,归一化结果为[1,0,…],即在当前时刻,模型只关注于当前单词的翻译,而完全忽略其他单词。按照语言的一般化规律,我们无法对这样的强模型进行优化。

    而使用Soft Attention,便不会忽略其他元素对翻译的影响,在翻译“我”的时候,归一化得到的权重可能为[0.6,0,1,0.3],当前时刻,对“我”的翻译,它便占了大权重,而下一时刻模型翻译“爱”时,权重可能更新为[0.2,0.7,0.1],这样的一个变化,使得我们在关注到当前翻译元素的同时,也不会完全忽略其他词带来的信息影响。


    3. 算法的应用领域和效果

    注意力机制的应用主要是NLP自然语言处理和CV计算机视觉两个领域。

    3.1 注意力机制在NLP领域的应用

    Attention机制在NLP领域的典型代表是在《Neural Machine Translation by Jointly Learning to Align and Translate》[1]论文中,这篇论文是第一次在NLP领域使用attention机制。

    论文中以NLP中机器翻译来举例子,图4中是经典的神经网络机器翻译encoder-decoder模型[5]。

    在这里插入图片描述

    传统的NMT模型使用两个RNN神经网络,第一个RNN模型对源语言进行编码,将源语言编码到一个固定的维度的中间向量,然后使用另一个RNN模型进行解码翻译,翻译成目标语言。而图5中添加了Attention机制的NMT模型,它把源语言端的每个词的表达都学到,然后和预测翻译的词建立联系,这种联系的可靠性就是依靠Attention机制提供保证,训练完毕后,根据得到的attention矩阵,我们就可以实现源语言和目标语言的对齐。

    在这里插入图片描述

    《Effective Approaches to Attention-based Neural Machine Translation》[2]中,Global类型的attention同上一篇论文中的机器翻译模型思路相差不多,都是对源语言所有词进行处理,只不过在这篇论文中,作者提出了几种计算attention矩阵的简单扩展版本。

    在这里插入图片描述

    在NLP领域具有重要意义的是作者在这篇论文中提到的local类型的attention模型,这个类型的主要思路是为减少attention计算耗费,在计算attention矩阵时,并不是考虑到源语言端的所有元素,而是根据一个预测函数,确定一个大致的范围,论文中提出local-m和local-p两种方式。

    在这里插入图片描述

    这篇论文启示了大家如何在自然语言处理领域应用attention机制,如何进行相对应的扩展,还有就是引入了局部attention方法。

    Attention机制引入NLP领域实际上是起到了短句对齐的一个功能,传统的短句对齐准确度不高,翻译效果不好。2016年,Google部署了他们基于神经网络的机器翻译系统,在这个系统,引入了Attention机制,相比传统模型翻译效果有大幅提升,翻译错误率下降了60%,效果十分可观。

    在这里插入图片描述
    目前Attention在NLP中已经有广泛的应用。它有一个很大的优点就是可以可视化attention矩阵来告诉大家神经网络在进行任务时关注了哪些部分。不过在NLP中的attention机制和人类的attention机制还是有所区别,它基本还是需要计算所有要处理的对象,并额外用一个矩阵去存储其权重,其实增加了开销。而不是像人类一样可以忽略不想关注的部分,只去处理关注的部分。

    3.2 注意力机制在CV领域的应用

    计算机视觉中一种经典的应用就是图片描述,即我们输入一幅图画,模型通过不同的注意力集中机制,根据图片中的不同元素,输出一句描述当前图片的语句,是实现图文结合的经典实例,类似于我们在英语或语文学习中做过的看图说话。

    图片描述任务依然需要用到encoder-decoder框架,此时encoder编码器需要输入一张图片,而decoder解码器需要输出一句描述语句。在encoder处选用CNN神经网络对图片进行特征提取,在解码器部分需要使用RNN或者LSTM等NLP任务经典的模型输出描述语句。

    在注意力机制加入后的翻译过程可以用带有MASK的模糊图来展示这一过程。

    在这里插入图片描述

    最终我们根据图片得到的描述语句为“A person is standing on a beach with a
    surfboard”。

    注意力机制的短句对齐优势体现在,如果我们选择语句中的一个单词,它可以确定该单词表述的大致图片范围是哪里,这也为我们做该问题的逆问题——语句与图片的匹配提供的思路,具体表现在下面的四个例子中体现出来。

    在这里插入图片描述


    4. 算法的优点和缺点讨论

    Attention机制的引入,主要是处于Attention机制的三个优点

    4.1 算法优点分析

    • 参数少。引入Attention之后的模型复杂度同CNN、RNN等经典模型相比,复杂度更小,参数也更少。模型对于计算机的算力要求也就更小。

    • 速度快。RNN模型中,不能进行并行计算,而Attention机制每一步计算都不依赖于上一步的计算结果,因此Attention机制可以实现和CNN一样的并行处理操作。

    • 效果好。Attention机制引入之前,研究人员面临一个令人烦恼的问题:长距离的信息会被弱化,就好比记忆能力弱的人对于过去较为久远的记不太起来。 而Attention机制是模型挑重点,在处理长文本的时候,Attention机制可以从中间抓住重点,避免重要信息丢失。

    4.2 算法缺点分析

    算法应用至今,对其缺点的描述不是很多。如果分析注意力机制的缺点,那可能是由于发展不充分导致的。

    注意力机制选择区域并不能完全模仿人的视觉机制进行,模仿人的视觉原理可能是算法的最终目标。但就目前来看,尽管提出了Soft Attention和Self Attention去拟人化,但是本质上还是给图画分配权重。这方面可能还需要认识神经科学领域的研究进一步加深。


    5. 参考文献

    1. Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. ICLR, 2015. Neural Machine Translation by Jointly Learning to Align and Translate.
    2. Minh-Thang Luong, Hieu Pham, and Christopher D Manning. EMNLP, 2015.Effective approaches to attention-based neural machine translation.
    3. Ashish Vaswani, et al. NIPS, 2017. Attention Is All You Need.
    4. Devlin J , Chang M W , Lee K , et al. BERT: Pre-training of Deep
      Bidirectional Transformers for Language Understanding[J]. 2018.
    5. Robert_ai.注意力机制(Attention Mechanism)在自然语言处理中的应用.https://www.cnblogs.com/robert-dlut/p/5952032.html
    6. super灬睿.注意力机制(Attention Mechanism)浅谈.https://zhuanlan.zhihu.com/p/364819787
    7. 张俊林.深度学习中的注意力机制(2017版).https://blog.csdn.net/malefactor/article/details/78767781
    展开全文
  • 针对全卷积孪生(SiamFC)网络算法在相似目标共存和目标外观发生显著变化时跟踪失败的问题,提出一种基于注意力机制的在线自适应孪生网络跟踪算法(AAM-Siam)来增强网络模型的判别能力,实现在线学习目标外观变化并抑制...
  • 神经网络注意力机制(Attention)

    千次阅读 2020-10-16 14:34:27
    注意力机制也称为:“神经网络的注意力”,或者更简单的:“注意力”。 人脑在工作时,其实是由一定的注意力的,比如我们在浏览器上搜索时,大部分的注意力都集中在搜索结果的左上角,这说明大脑在处理信号的时候是...

    1 注意力的简介

    注意力机制也称为:“神经网络的注意力”,或者更简单的:“注意力”。

    人脑在工作时,其实是由一定的注意力的,比如我们在浏览器上搜索时,大部分的注意力都集中在搜索结果的左上角,这说明大脑在处理信号的时候是有一定权重划分的,而注意力机制的提出正是模仿了大脑的这种特性。

    神经网络的注意力就是说,神经网络具有将注意力集中到一部分输入(或特征)的能力。

    (1)为什么引入注意力机制呢?

    • 计算能力的限制:目前计算能力依然是限制神经网络发展的瓶颈,当输入的信息过多时,模型也会变得更复杂,通过引入注意力,可以减少处理的信息量,从而减小需要的计算资源。
    • 优化算法的限制:虽然局部连接、权重共享以及 pooling 等优化操作可以让神经网络变得简单一些,有效缓解模型复杂度和表达能力之间的矛盾;但是,如循环神经网络中的长序列输入,信息“记忆”能力并不高。

    (2)注意力机制的分类

    注意力机制一般分为两种:

    • 聚焦式(Focus)注意力:是一种自上而下的有意识的注意力,“主动注意” 是指有预定目的、依赖任务的、主动有意识地聚焦于某一对象的注意力;
    • 显著性(Saliency-Based)注意力:是一种自下而上的无意识的注意力,“被动注意” 是基于显著性的注意力,是由外界刺激驱动的注意,不需要主动干预,也和任务无关;池化(Max Pooling)门控(Gating) 可以近似地看作是自下而上的基于显著性的注意力机制。

    2 注意力机制的流程

    注意力机制一般可以分为三步:一是信息输入;二是计算注意力分布;三是根据计算的注意力分布来对输入信息进行处理。

    令:

    • x ∈ R d x\in R^d xRd 为输入向量
    • X = [ x 1 , x 2 , ⋯   , x N ] X=[x_1, x_2, \cdots, x_N] X=[x1,x2,,xN] N N N 个输入样本
    • q ∈ R k q\in R^k qRk 为查询向量或特征向量
    • z ∈ [ 1 , N ] z\in[1,N] z[1,N] 为注意力变量,表示被选择信息的位置,比如 z = i z=i z=i 表示选择了第 i i i 个输入向量

    3 不同形式的注意力

    3.1 软性注意力(Soft Attention)

    软性注意力(Soft Attention)是指在选择信息的时候,不是从 N N N 个信息中只选择1个,而是计算 N N N 个输入信息的加权平均,再输入到神经网络中计算。

    (1)计算注意力分布 α i \alpha_i αi

    在给定 q q q X X X 下,选择第 i i i 个输入向量的概率 α i \alpha_i αi 为:

    α i = p ( z = i ∥ X , q ) = s o f t m a x ( s ( x i , q ) ) = e x p ( s ( x i , q ) ) ∑ j = 1 N e x p ( s ( x i , q ) ) \begin{aligned} \alpha_i &= p(z=i\| X,q)\\ & = softmax(s(x_i,q)) \\ & = \frac{exp(s(x_i,q))}{\sum_{j=1}^N exp(s(x_i,q))} \end{aligned} αi=p(z=iX,q)=softmax(s(xi,q))=j=1Nexp(s(xi,q))exp(s(xi,q))

    其中:

    • α i \alpha_i αi 称为是注意力分布
    • s ( x i , q ) s(x_i,q) s(xi,q) 是注意力打分函数

    常见的注意力打分函数 s ( x i , q ) s(x_i,q) s(xi,q) 包括:

    • 加性模型: s ( x i , q ) = v T tanh ⁡ ( W x i + U q ) s(x_i,q)=v^T \tanh (Wx_i+Uq) s(xi,q)=vTtanh(Wxi+Uq) W , U W,U W,U 为可学习的网络参数
    • 点积模型: s ( x i , q ) = x i T q s(x_i,q)=x_i^Tq s(xi,q)=xiTq
    • 缩放点模型: s ( x i , q ) = x i T q d s(x_i,q)=\frac{x_i^Tq}{\sqrt{d}} s(xi,q)=d xiTq d d d 为输入向量的维度
    • 双线性模型: s ( x i , q ) = x i T W q s(x_i,q)=x_i^TWq s(xi,q)=xiTWq W W W 为可学习的网络参数

    (2)加权平均

    注意力分布 α i \alpha_i αi 可以解释为给定查询 q q q 时,第 i i i 个输入向量关注的程度,软性注意力选择机制是对它们进行汇总:

    a t t ( X , q ) = ∑ i = 1 N α i x i = E z ∼ p ( z ∣ X , p ) [ x ] \begin{aligned} att(X,q) &= \sum_{i=1}^N \alpha_ix_i \\ & = E_{z\sim p(z|X,p)}[x] \end{aligned} att(X,q)=i=1Nαixi=Ezp(zX,p)[x]

    3.2 硬性注意力(Hard Attention)

    硬性注意力(Hard Attention)是指只选择输入序列某一个位置上的信息

    硬性注意力有两种实现方式:

    (1)选取最高概率的输入信息

    a t t ( X , q ) = x j ,   w h e r e    j = a r g max ⁡ i = 1 N α i att(X,q) = x_j, \ where \ \ j =arg \max_{i=1}^N \alpha_i att(X,q)=xj, where  j=argi=1maxNαi

    (2)另一种硬性注意力是通过在注意力分布式上随机采样的方式实现

    硬性注意力的缺点:

    硬性注意力基于最大采样或者随机采样的方式选择信息,导致最终的损失函数与注意力分布之间的函数关系不可导,因此无法在反向传播时进行训练。

    3.3 键值对注意力

    比如我们使用键值对 key-value pair 的格式来表示输入信息,其中键用来计算注意力分布 α i \alpha_i αi,值用来计算聚合信息,比如 Self Attention。

    ( K , V ) = [ ( k 1 , v 1 ) , ⋯   , ( k N , v N ) ] (K,V)=[(k_1,v_1),\cdots,(k_N,v_N)] (K,V)=[(k1,v1),,(kN,vN)] 来表示 N N N 组输入信息,给定任务相关的查询向量 q q q 时,注意力函数为:

    a t t ( X , q ) = ∑ i = 1 N α i x i = ∑ i = 1 N e x p ( s ( k i , q ) ) ∑ j e x p ( s ( k i , q ) ) v i \begin{aligned} att(X,q) &= \sum_{i=1}^N \alpha_ix_i \\ & = \sum_{i=1}^N \frac{exp(s(k_i,q))}{\sum_j exp(s(k_i,q))}v_i \end{aligned} att(X,q)=i=1Nαixi=i=1Njexp(s(ki,q))exp(s(ki,q))vi

    显然,当 K = V K=V K=V 时,键值对就等价于普通的注意力机制

    3.4 多头注意力(Multi-Head Attention)

    多头注意力是利用多个查询 Q = [ q 1 , q 2 , ⋯   , q M ] Q=[q_1,q_2,\cdots,q_M] Q=[q1,q2,,qM],来平行地计算从输入信息中选取多组信息。每个注意力关注输入信息的不同部分。

    a t t ( ( K , V ) , Q ) = a t t ( ( K , V ) , q 1 ) ⨁ ⋯ ⨁ a t t ( ( K , V ) , q M ) att((K,V),Q)=att((K,V),q_1) \bigoplus \cdots \bigoplus att((K,V),q_M) att((K,V),Q)=att((K,V),q1)att((K,V),qM)

    其中, ⨁ \bigoplus 表示向量的拼接。

    【参考】

    • https://zhuanlan.zhihu.com/p/53682800
    • http://akosiorek.github.io/ml/2017/10/14/visual-attention.html
    展开全文
  • 一种基于注意力机制的卷积神经网络剪枝方法,汪枭杰,姚文斌,卷积神经网络剪枝技术可以有效减少神经网络的内存占用和运行耗时,有利于神经网络在资源有限的设备上部署。剪枝研究中,如何衡量
  • 你要的最全、最详细的神经网络注意力机制就在这里!吐血大放送,大总结! 注意力机制(Attention Mechanism)在自然语言处理中的应用 强烈推荐:http://www.cnblogs.com/robert-dlut/p/5952032.html 深度学习...
  • Implementations for a whole family of attention-mechanisms, tailored for many-to-one sequence tasks and compatible with TensorFlow 2.0 with Keras integration.
  • Attention:注意力机制在Keras当中的实现 目录 所需环境 tensorflow-gpu==1.13.1 keras==2.1.5 LSTM中的注意力机制 在本库中,我将注意力机制施加在LSTM的Step上,目的是注意输入进来的样本,每一个Step的重要程度。...
  • 基于注意力机制的混合神经网络关系分类方法.pdf
  • 卷积神经网络中的注意力机制

    千次阅读 2019-07-09 10:48:38
    视觉注意力机制:视觉注意力机制是人类视觉所特有的大脑信号处理机制。人类视觉通过快速扫描全局图像,获得需要重点关注的目标区域,也就是一般所说的注意力焦点,而后对这一区域投入更多注意力资源,以获取更多所...
  • http://akosiorek.github.io/ml/2017/10/14/visual-attention.html这篇博文主要介绍神经网络中的注意力机制,代码实现了两个 soft visual attentionWhat is Attention? 首先来看看 注意力机制是什么? Infor
  • 神经网络中的注意力机制总结及PyTorch实战

    万次阅读 多人点赞 2019-07-08 15:04:29
    神经网络来处理大量的输入信息时,也可以借助人脑的注意力机制,只选择一些关键的信息输入进行处理,用来提高神经网络的效率。在目前的神经网络模型中,可以将max pooling和gating机制近似地看作是自下而上的基于...
  • Attention, 神经网络中的注意力机制

    千次阅读 2017-12-25 11:43:01
    人的注意力机制: 拿到一篇文章时, 会重点关注标题和段落首句, 期望快速得到关键信息. 人群中看到心动女生时, 虽然周围熙熙攘攘的人群都映在了在你的眼帘里, 但你关注的只有那位在意的人, 其他的人仿佛视而不见. ...
  • attention方法是一种注意力机制,很明显,是为了模仿人的观察和思维方式,将注意力集中到关键信息上,虽然还没有像人一样,完全忽略到不重要的信息,但是其效果毋庸置疑,本篇我们来总结注意力机制的不同方法。...
  • 基于卷积神经网络注意力机制的图像检索.pdf
  • 基于注意力机制的GRU神经网络安全态势预测方法.pdf
  • 针对上述问题,提出了一种基于神经网络注意力机制的中文文本校对方法.利用双向门控循环神经网络层获取文本信息并进行特征提取,并引入注意力机制层增强词间语义逻辑关系的捕获能力.在基于Keras深度学习框架下对...
  • Abstract 非线性自回归外生(NARX)模型是根据一个时间序列以前的值以及多个驱动(外生)...针对这两个问题,本文提出了一种基于双阶段注意力机制的递归神经网络(DA-RNN)。在第一个阶段,我们引入一个输入注意机制,...
  • 神经网络到底在关注哪里?注意力机制与Transformer

    千次阅读 多人点赞 2021-08-04 10:31:34
    注意力机制与Transformer 1 注意力机制介绍 PART1 浅谈注意力 注意力(attention)是人类学习中必不可少的要素,比如我们去阅读一个文章,或者试着去理解一本书中作者想表达的意思,我们通常在阅读过程中会把注意...
  • 针对这些问题,提出了一种基于注意力机制的特征融合算法。该算法利用注意力机制来融合不同尺度的特征,通过对每个通道的特征进行权重分配来学习不同通道间特征的相关性。将基于注意力机制的特征融合算法与YOLO V3相...
  • 循环神经网络+注意力机制概述

    千次阅读 2019-01-24 20:57:34
    总结了最近学的循环神经网络注意力机制,最近很火的东西。基础知识部分很大程度上参考了邱锡鹏老师的《神经网络与深度学习》这本书。 参考文献: 邱锡鹏 《神经网络与...
  • 融合图卷积神经网络注意力机制的PM2.5小时浓度多步预测.pdf
  • 集成注意力机制和深度神经网络以检测DGA域名
  • 为什么需要视觉注意力计算机视觉(computervision)中的注意力机制(attention)的基本思想就是想让系统学会注意力——能够忽略无关信息而关注重点信息。为什么要忽略无关信息呢?注意力分类与基本概念神经网络中的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 25,923
精华内容 10,369
关键字:

注意力机制神经网络