Dual Attention Network for Scene Segmentation，CVPR2019

论文地址：https://arxiv.org/abs/1809.02983

项目地址：GitHub - junfu1115/DANet: Dual Attention Network for Scene Segmentation (CVPR2019)

参考博客：DANet论文及代码阅读笔记_IronLavender的博客-CSDN博客_danet

?DANet（双重注意力融合网络）_Nick Blog的博客-CSDN博客_danet

DANet，两条分支并联使用空间注意力和通道注意力，增强特征表示。?

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

Architecture：（DANet）

PAM

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

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

特征图A(C×H×W)首先分别通过3个卷积层得到3个特征图B,C,D,然后将B,C,D reshape为C×N，其中N=H×W。
之后将reshape后的B的转置(NxC)与reshape后的C(CxN)相乘，再通过softmax得到spatial attention map S(N×N)。
接着在reshape后的D(CxN)和S的转置(NxN)之间执行矩阵乘法，再乘以尺度系数α，再reshape为原来形状，最后与A相加得到最后的输出E。
其中α初始化为0，并逐渐的学习得到更大的权重。

CAM

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

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

分别对A做reshape(CxN)和reshape与transpose(NxC)。
将得到的两个特征图相乘，再通过softmax得到channel attention map X(C×C)。
接着把X的转置(CxC)与reshape的A(CxN)做矩阵乘法，再乘以尺度系数β，再reshape为原来形状，最后与A相加得到最后的输出E。
其中β初始化为0，并逐渐的学习得到更大的权重。
?

代码

# https://github.com/junfu1115/DANet/blob/master/encoding/models/sseg/danet.py

# 调用方式： 
# self.head = DANetHead(2048,nclass,norm_layer) # norm_layer默认 nn.BatchNorm2d
# features = self.head(x) # x 输入特征 [b,c,h,w]

class DANetHead(nn.Module):
    def __init__(self, in_channels, out_channels, norm_layer):
        super(DANetHead, self).__init__()
        inter_channels = in_channels // 4
        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())

        self.conv6 = nn.Sequential(nn.Dropout2d(0.1, False), nn.Conv2d(inter_channels, out_channels, 1))
        self.conv7 = nn.Sequential(nn.Dropout2d(0.1, False), nn.Conv2d(inter_channels, out_channels, 1))

        self.conv8 = nn.Sequential(nn.Dropout2d(0.1, False), nn.Conv2d(inter_channels, out_channels, 1))

    def forward(self, x):
        feat1 = self.conv5a(x)
        sa_feat = self.sa(feat1)
        sa_conv = self.conv51(sa_feat)
        sa_output = self.conv6(sa_conv)

        feat2 = self.conv5c(x)
        sc_feat = self.sc(feat2)
        sc_conv = self.conv52(sc_feat)
        sc_output = self.conv7(sc_conv)

        feat_sum = sa_conv+sc_conv
        
        sasc_output = self.conv8(feat_sum)

        output = [sasc_output]
        output.append(sa_output)
        output.append(sc_output)
        return tuple(output)

Fully Attentional Network for Semantic Segmentation，AAAI2022

论文地址：https://arxiv.org/abs/2112.04108

项目地址：https://github.com/Ilareina/FullyAttentional

参考博客：【语义分割】Fully Attentional Network for Semantic Segmentation_呆呆的猫的博客-CSDN博客

精读Fully Attentional Network for Semantic Segmentation_格里芬阀门工的博客-CSDN博客

出发点&动机：以往的注意力机制，要么只关注同一空间不同通道的信息，要么只关注不同空间同一通道的信息，这会导致模型容易忽略小的对象，并错误分割较大的对象。本文提出了一种新的注意力机制，综合考虑两方面的信息。

具体来说，non-local （NL）的方法起到了很好了捕捉 long-range 信息的作用，大致可分为 Channel non-local 和 Spatial non-local 两种变种。但是他们却同时有一个问题——attention missing。

以 channel attention 为例：channel attention 能够找到每个通道和其他通道的关联，在计算的过程中，spatial 特征被整合了起来，缺失了不同位置之间的联系。
以 spatial attention 为例：spatial attention 能够找到每个位置之间的关系，但所有channel 的特征也都被整合了起来，缺失了不同 channel 之间的联系。

attention missing 问题会削弱三维上下文信息的存储，这两种 attention 方法都有各自的弊端。?

论文也经过实验得出：

channel NL 在大目标上表现好，spatial NL在小目标或细长目标表现较好。
简单堆叠两个注意力（并联，DANet（Dual NL）或串联，channel-spatial NL（CS NL）），能一定程度上提升整体性能。但相较而言，Dual NL在大尺寸目标上性能有所下降，CS NL在细长目标上IoU较差。
简单的复合attention结构，只能通过channel和spatial attention中的某一方来获得性能提升，所以，attention missing问题损害了特征的表示能力。
于是，论文提出了一个新的 non-local 模块——Fully Attention block（FLA）来在所有维度上进行有效的 attention 特征保留。?

在这里插入图片描述

全文的基本思路在于：

在计算 channel attention map 时，使用全局上下文特征来保存空间响应特征，这能够使得在一个单一的 attention 中实现充分的注意并具有高的计算效率，图 1c 为整体结构。

首先，让每个空间位置来捕捉全局上下文的特征响应
之后，使用 self-attention 机制来捕捉两个 channel 之间和相应空间位置的全注意力相似度
最后，使用全注意力相似度来对 channel map 进行 re-weight。

① channel NL 的过程如图1a所示，生成的 attention map 为 C × C 大小，也就是每个通道和其他所有通道的注意力权重。

② spatial NL 的过程如图1b所示，生成的 attention map 为 H W × H W大小，也就是每个点和其他所有像素点的注意力权重。

③ FLA 的过程如图 1c 所示，生成的 attention map 为 ( C × C ) ( H + W )，其中 C × C?还是通道注意力权重，(H+W) 是每行（共H行）和每列（共W列）的注意力权重。

Architecture：Fully Attentional Block（FLA）

部分实验结果

?代码

# https://github.com/Ilareina/FullyAttentional/blob/main/model.py

# 调用
# self.fully = FullyAttentionalBlock(512)
# full_feats = self.fully(x) # x,输入特征 [b,c,h,w]

class FullyAttentionalBlock(nn.Module):
    def __init__(self, plane, norm_layer=SyncBatchNorm):
        super(FullyAttentionalBlock, self).__init__()
        self.conv1 = nn.Linear(plane, plane)
        self.conv2 = nn.Linear(plane, plane)
        self.conv = nn.Sequential(nn.Conv2d(plane, plane, 3, stride=1, padding=1, bias=False),
                                  norm_layer(plane),
                                  nn.ReLU())

        self.softmax = nn.Softmax(dim=-1)
        self.gamma = nn.Parameter(torch.zeros(1))

    def forward(self, x):
        batch_size, _, height, width = x.size()

        feat_h = x.permute(0, 3, 1, 2).contiguous().view(batch_size * width, -1, height)
        feat_w = x.permute(0, 2, 1, 3).contiguous().view(batch_size * height, -1, width)
        encode_h = self.conv1(F.avg_pool2d(x, [1, width]).view(batch_size, -1, height).permute(0, 2, 1).contiguous())
        encode_w = self.conv2(F.avg_pool2d(x, [height, 1]).view(batch_size, -1, width).permute(0, 2, 1).contiguous())

        energy_h = torch.matmul(feat_h, encode_h.repeat(width, 1, 1))
        energy_w = torch.matmul(feat_w, encode_w.repeat(height, 1, 1))
        full_relation_h = self.softmax(energy_h)  # [b*w, c, c]
        full_relation_w = self.softmax(energy_w)

        full_aug_h = torch.bmm(full_relation_h, feat_h).view(batch_size, width, -1, height).permute(0, 2, 3, 1)
        full_aug_w = torch.bmm(full_relation_w, feat_w).view(batch_size, height, -1, width).permute(0, 2, 1, 3)
        out = self.gamma * (full_aug_h + full_aug_w) + x
        out = self.conv(out)
        return out