DANet论文及代码阅读笔记

最新推荐文章于 2024-06-02 12:29:25 发布

IronLavender

最新推荐文章于 2024-06-02 12:29:25 发布

阅读量2.7w

点赞数 46

分类专栏：图像分割文章标签：图像分割注意力

本文链接：https://blog.csdn.net/wumenglu1018/article/details/95949039

版权

图像分割专栏收录该内容

0 篇文章 1 订阅

订阅专栏

《Dual Attention Network for Scene Segmentation》

文章：https://arxiv.org/pdf/1812.03904.pdf

代码：https://github.com/junfu1115/DANet/

存在的问题

为提高像素级识别特征表示的辨别能力：①利用多尺度上下文融合，结合不同的膨胀卷积和池化操作，来聚合多尺度上下文。②使用分解结构增大卷积核尺寸或在网络顶部引入有效的编码层，来捕获更丰富的全局信息。③编码器-解码器结构来融合中级和高级语义特征。④使用RNN捕捉长程依赖关系，从而提高分割精度。

而①②③中，虽然上下文融合有助于捕获不同比例的对象，但却无法利用全局视图中对象之间的关系。④中，使用RNN隐含地捕捉全局关系，但其有效性很大程度上依赖于长期记忆的学习结果。

本文提出的解决方案

为解决上述问题，本文提出了双注意力网络（DANet），基于自注意力机制来分别捕获空间维度和通道维度中的特征依赖关系。具体而言，本文在dilated FCN上附加了2种注意力模块，分别对空间维度和通道维度上的语义依赖关系进行建模。

其中position attention module使用自注意力机制捕获特征图在任意两个位置之间的空间依赖关系，通过加权求和对所有位置的特征进行聚合更新，权重是由对应两个位置的特征相似性决定的。
Channel attention module使用自注意力机制来捕获任意两个通道图之间的通道依赖关系，并使用所有通道图的加权，和更新每个通道图。
这两个注意力模块的输出进行融合，进一步增强了特征表示。

因此本文方法更有效更灵活：①选择性地聚合不起眼物体的相似特征，突出它们的特征表示，避免了突出物体的影响。②从全局的角度自适应地集成任何尺度上地相似特征。③明确地考虑空间和通道的关系，这样场景理解可以利用长期依赖关系。

DANet

因为卷积操作产生的是局部感受野，导致相同标签的像素对应特征可能不同，这种差异会进而导致类内的不一致性，影响识别的准确率。所以本文提出：在特征，之间使用注意力机制建立关联以获取全局上下文信息。

（1）Position Attention Module

观察：传统FCNs生成的特征会导致对物体的错误分类。

解决：引入位置注意模块在局部特征上建立丰富的上下文关系，将更广泛的上下文信息编码为局部特征，进而增强他们的表示能力。

Spatial attention map的计算：，sji度量第i个位置对第j个位置的影响，也就是第i个位置和第j个位置之间的关联程度/相关性，越大越相似。

Output的计算：，α表示尺度系数，初始化为0，并逐渐地学习分配到更大的权重。每个位置的结果特征E，是所有位置和原始位置的加权和。因此它具有全局上下文视图，并能根据空间注意力图有选择地聚合上下文。

（2）Channel Attention Module

观察：每个high level特征的通道图都可以看作是一个特定于类的响应，通过挖掘通道图之间的相互依赖关系，可以突出相互依赖的特征图，提高特定语义的特征表示。

解决：建立一个通道注意力模块来显式地建模通道之间的依赖关系。

Channel attention map的计算：，xji度量第i个通道对第j个通道的影响。

Output的计算：，β表示尺度系数，初始化为0，并逐渐地学习分配到更大的权重。每个通道的结果特征E，是所有通道特征和原始特征的加权和。实现了对特征图之间的长程语义依赖关系建模，有助于提高特征的辨别性。

（3）Attention Module Embedding with Networks

为了充分利用长程上下文信息，所以将这2个注意力模块的特征进行了聚合。即通过卷积层对两个注意力模块的输出进行转换，并执行一个element-wise的求和来实现特征融合。最后接一个卷积得到最后的预测特征图。

该注意力模块很简单，可以直接插入到现在的FCN中。而且它们不会增加太多参数，还能有效地增强特征表示。

实验分析

实验表明：①位置注意模块能够捕捉到清晰的语义相似性和长程关系。②当通道注意模块增强后，特定语义的响应是明显的。③DANet使用注意力模块，可以更有效地捕获全局依赖关系和长程上下文信息，在场景分割中学到更好的特征表示。

总结

优点：DANet使用2个注意力模块，可以更有效地捕获全局依赖关系和长程上下文信息，在场景分割中学到更好的特征表示，使得分割结果更加准确。

缺点：矩阵计算使得算法的计算复杂度较高？模型的鲁棒性？缺少和DeepLab v3+的比较（可能没有DeepLab v3+的效果好）？

【猜测】selectively和adaptively应该体现在：公式(2)和公式(4)中，S和X矩阵表示的权重上，softmax后大的值作用更大，对乘积的贡献也就越大。

代码阅读

两个注意力模块的代码在：DANet-master\encoding\nn\attention.py

###########################################################################
# Created by: CASIA IVA
# Email: jliu@nlpr.ia.ac.cn
# Copyright (c) 2018
###########################################################################

import numpy as np
import torch
import math
from torch.nn import Module, Sequential, Conv2d, ReLU,AdaptiveMaxPool2d, AdaptiveAvgPool2d, \
    NLLLoss, BCELoss, CrossEntropyLoss, AvgPool2d, MaxPool2d, Parameter, Linear, Sigmoid, Softmax, Dropout, Embedding
from torch.nn import functional as F
from torch.autograd import Variable
torch_ver = torch.__version__[:3]

__all__ = ['PAM_Module', 'CAM_Module']


class PAM_Module(Module):
    """ Position attention module"""
    #Ref from SAGAN
    def __init__(self, in_dim):
        super(PAM_Module, self).__init__()
        self.chanel_in = in_dim

        # 先经过3个卷积层生成3个新特征图B C D （尺寸不变）
        self.query_conv = Conv2d(in_channels=in_dim, out_channels=in_dim//8, kernel_size=1)
        self.key_conv = Conv2d(in_channels=in_dim, out_channels=in_dim//8, kernel_size=1)
        self.value_conv = Conv2d(in_channels=in_dim, out_channels=in_dim, kernel_size=1)
        self.gamma = Parameter(torch.zeros(1))  # α尺度系数初始化为0，并逐渐地学习分配到更大的权重

        self.softmax = Softmax(dim=-1)  # 对每一行进行softmax
    def forward(self, x):
        """
            inputs :
                x : input feature maps( B × C × H × W)
            returns :
                out : attention value + input feature
                attention: B × (H×W) × (H×W)
        """
        m_batchsize, C, height, width = x.size()
        # B -> (N,C,HW) -> (N,HW,C)
        proj_query = self.query_conv(x).view(m_batchsize, -1, width*height).permute(0, 2, 1)
        # C -> (N,C,HW)
        proj_key = self.key_conv(x).view(m_batchsize, -1, width*height)
        # BC，空间注意图 -> (N,HW,HW)
        energy = torch.bmm(proj_query, proj_key)
        # S = softmax(BC) -> (N,HW,HW)
        attention = self.softmax(energy)
        # D -> (N,C,HW)
        proj_value = self.value_conv(x).view(m_batchsize, -1, width*height)
        # DS -> (N,C,HW)
        out = torch.bmm(proj_value, attention.permute(0, 2, 1))  # torch.bmm表示批次矩阵乘法
        # output -> (N,C,H,W)
        out = out.view(m_batchsize, C, height, width)

        out = self.gamma*out + x
        return out


class CAM_Module(Module):
    """ Channel attention module"""
    def __init__(self, in_dim):
        super(CAM_Module, self).__init__()
        self.chanel_in = in_dim


        self.gamma = Parameter(torch.zeros(1))  # β尺度系数初始化为0，并逐渐地学习分配到更大的权重
        self.softmax  = Softmax(dim=-1)  # 对每一行进行softmax
    def forward(self,x):
        """
            inputs :
                x : input feature maps( B × C × H × W)
            returns :
                out : attention value + input feature
                attention: B × C × C
        """
        m_batchsize, C, height, width = x.size()
        # A -> (N,C,HW)
        proj_query = x.view(m_batchsize, C, -1)
        # A -> (N,HW,C)
        proj_key = x.view(m_batchsize, C, -1).permute(0, 2, 1)
        # 矩阵乘积，通道注意图：X -> (N,C,C)
        energy = torch.bmm(proj_query, proj_key)
        # 这里实现了softmax用最后一维的最大值减去了原始数据，获得了一个不是太大的值
        # 沿着最后一维的C选择最大值，keepdim保证输出和输入形状一致，除了指定的dim维度大小为1
        # expand_as表示以复制的形式扩展到energy的尺寸
        energy_new = torch.max(energy, -1, keepdim=True)[0].expand_as(energy)-energy
        
        attention = self.softmax(energy_new)
        # A -> (N,C,HW)
        proj_value = x.view(m_batchsize, C, -1)
        # XA -> （N,C,HW）
        out = torch.bmm(attention, proj_value)
        # output -> (N,C,H,W)
        out = out.view(m_batchsize, C, height, width)
        
        out = self.gamma*out + x
        return out

'''
if __name__ == '__main__':
    module = CAM_Module()
    in_data = torch.randint(0, 255, (2, 3, 7, 7), dtype=torch.float32)
    print(module(in_data).size())
'''

模块融合的代码在：DANet-master\encoding\models\danet.py

class DANetHead(nn.Module):
    def __init__(self, in_channels, out_channels, norm_layer):
        super(DANetHead, self).__init__()
        inter_channels = in_channels // 4  # in_channels=2018，通道数缩减为512
        
        self.conv5a = nn.Sequential(nn.Conv2d(in_channels, inter_channels, 3, padding=1, bias=False), norm_layer(inter_channels), nn.ReLU())       
        self.conv5c = nn.Sequential(nn.Conv2d(in_channels, inter_channels, 3, padding=1, bias=False), norm_layer(inter_channels), nn.ReLU())

        self.sa = PAM_Module(inter_channels)  # 空间注意力模块
        self.sc = CAM_Module(inter_channels)  # 通道注意力模块
        
        self.conv51 = nn.Sequential(nn.Conv2d(inter_channels, inter_channels, 3, padding=1, bias=False), norm_layer(inter_channels), nn.ReLU())
        self.conv52 = nn.Sequential(nn.Conv2d(inter_channels, inter_channels, 3, padding=1, bias=False), norm_layer(inter_channels), nn.ReLU())
        
        # nn.Dropout2d(p,inplace)：p表示将元素置0的概率；inplace若设置为True，会在原地执行操作。
        self.conv6 = nn.Sequential(nn.Dropout2d(0.1, False), nn.Conv2d(512, out_channels, 1))  # 输出通道数为类别的数目
        self.conv7 = nn.Sequential(nn.Dropout2d(0.1, False), nn.Conv2d(512, out_channels, 1))
        self.conv8 = nn.Sequential(nn.Dropout2d(0.1, False), nn.Conv2d(512, out_channels, 1))

    def forward(self, x):
        # 经过一个1×1卷积降维后，再送入空间注意力模块
        feat1 = self.conv5a(x)
        sa_feat = self.sa(feat1)  
        # 先经过一个卷积后，再使用有dropout的1×1卷积输出指定的通道数
        sa_conv = self.conv51(sa_feat)
        sa_output = self.conv6(sa_conv)  

        # 经过一个1×1卷积降维后，再送入通道注意力模块
        feat2 = self.conv5c(x)
        sc_feat = self.sc(feat2)
        # 先经过一个卷积后，再使用有dropout的1×1卷积输出指定的通道数
        sc_conv = self.conv52(sc_feat)
        sc_output = self.conv7(sc_conv)

        feat_sum = sa_conv+sc_conv  # 两个注意力模块结果相加       
        sasc_output = self.conv8(feat_sum)  # 最后再送入1个有dropout的1×1卷积中
 
        output = [sasc_output]
        output.append(sa_output)
        output.append(sc_output)
        return tuple(output)  # 输出模块融合后的结果，以及两个模块各自的结果

补充

这一段来自https://www.cnblogs.com/ziytong/p/10685860.html

文中的注意力模块中的位置注意力模块, 基本上与何凯明的<X. Wang, R. Girshick, A. Gupta, and K. He. Non-Local Neural Networks. In CVPR , 2018>提出的Non-Local结构是一致的。

而该自注意力的思路主要来源于google的一份工作（Attention Is All You Need）: https://arxiv.org/abs/1706.03762

在Goodfellow的这篇文章中使用了 <H. Zhang, I. J. Goodfellow, D. N. Metaxas, and A. Odena. Self-attention generative adversarial networks. CoRR, abs/1805.08318, 2018> 类似的结构.https://arxiv.org/abs/1805.08318

其他参考来源

：

https://blog.csdn.net/mieleizhi0522/article/details/83111183

https://zhuanlan.zhihu.com/p/48056789

IronLavender

关注

46
点赞
踩
278

收藏

觉得还不错? 一键收藏
25
评论
DANet论文及代码阅读笔记

《Dual Attention Network for Scene Segmentation》文章：https://arxiv.org/pdf/1812.03904.pdf代码：https://github.com/junfu1115/DANet/存在的问题为提高像素级识别特征表示的辨别能力：①利用多尺度上下文融合，结合不同的膨胀卷积和池化操作，来聚合多尺度上下文。②使用分解...
复制链接

扫一扫