u2net添加CA注意力机制

最新推荐文章于 2025-03-14 11:44:02 发布
最新推荐文章于 2025-03-14 11:44:02 发布
阅读量350 收藏 4
点赞数 7
文章标签： 深度学习 人工智能 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pious222222/article/details/143301331
版权

        u2net是unet的改进版本，编码器由多个小型unet组成的RSU模块，本文介绍了u2net添加CA注意力机制（坐标注意力），并且通过修改RSU的最后一个模块，引入深度可分离卷积以及空洞卷积减少模型参数量，并且提升模型特征提取能力

具体实现代码如下：

class RSU7(nn.Module):
    def __init__(self, n_channels=3, mid_ch=12, n_classes=4):
        super(RSU7, self).__init__()

        self.rebnconvin = REBNCONV(n_channels, n_classes, dirate=1)

        self.rebnconv1 = REBNCONV(n_classes, mid_ch, dirate=1)
        self.pool1 = nn.MaxPool2d(2, stride=2, ceil_mode=True)

        self.rebnconv2 = REBNCONV(mid_ch, mid_ch, dirate=1)
        self.pool2 = nn.MaxPool2d(2, stride=2, ceil_mode=True)

        self.rebnconv3 = REBNCONV(mid_ch, mid_ch, dirate=1)
        self.pool3 = nn.MaxPool2d(2, stride=2, ceil_mode=True)

        self.rebnconv4 = REBNCONV(mid_ch, mid_ch, dirate=1)
        self.pool4 = nn.MaxPool2d(2, stride=2, ceil_mode=True)

        self.rebnconv5 = REBNCONV(mid_ch, mid_ch, dirate=1)
        self.pool5 = nn.MaxPool2d(2, stride=2, ceil_mode=True)

        self.rebnconv6 = REBNCONV(mid_ch, mid_ch, dirate=1)

        self.rebnconv7 = REBNCONV(mid_ch, mid_ch, dirate=2)

        self.rebnconv6d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
        self.rebnconv5d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
        self.rebnconv4d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
        self.rebnconv3d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
        self.rebnconv2d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
        self.rebnconv1d = REBNCONV(mid_ch * 2, n_classes, dirate=1)

        # 使用通道注意力
        self.coordinate_attention = coordinate_attention(n_classes, n_classes)

    def forward(self, x):
        hx = x
        hxin = self.rebnconvin(hx)

        hx1 = self.rebnconv1(hxin)
        hx = self.pool1(hx1)

        hx2 = self.rebnconv2(hx)
        hx = self.pool2(hx2)

        hx3 = self.rebnconv3(hx)
        hx = self.pool3(hx3)

        hx4 = self.rebnconv4(hx)
        hx = self.pool4(hx4)

        hx5 = self.rebnconv5(hx)
        hx = self.pool5(hx5)

        hx6 = self.rebnconv6(hx)

        hx7 = self.rebnconv7(hx6)

        hx6d = self.rebnconv6d(torch.cat((hx7, hx6), 1))
        hx6dup = _upsample_like(hx6d, hx5)

        hx5d = self.rebnconv5d(torch.cat((hx6dup, hx5), 1))
        hx5dup = _upsample_like(hx5d, hx4)

        hx4d = self.rebnconv4d(torch.cat((hx5dup, hx4), 1))
        hx4dup = _upsample_like(hx4d, hx3)

        hx3d = self.rebnconv3d(torch.cat((hx4dup, hx3), 1))
        hx3dup = _upsample_like(hx3d, hx2)

        hx2d = self.rebnconv2d(torch.cat((hx3dup, hx2), 1))
        hx2dup = _upsample_like(hx2d, hx1)

        hx1d = self.rebnconv1d(torch.cat((hx2dup, hx1), 1))
        # print('h1:{}'.format(hx1d.shape))
        # 使用坐标注意力
        hx1d = self.coordinate_attention(hx1d)
        # print('h2:{}'.format(hx1d.shape))

        """
        del hx1, hx2, hx3, hx4, hx5, hx6, hx7
        del hx6d, hx5d, hx3d, hx2d
        del hx2dup, hx3dup, hx4dup, hx5dup, hx6dup
        """

        return hx1d + hxin


### RSU-6 ###
class RSU6(nn.Module):  # UNet06DRES(nn.Module):
    def __init__(self, n_channels=3, mid_ch=12, n_classes=4):
        super(RSU6, self).__init__()

        self.rebnconvin = REBNCONV(n_channels, n_classes, dirate=1)

        self.rebnconv1 = REBNCONV(n_classes, mid_ch, dirate=1)
        self.pool1 = nn.MaxPool2d(2, stride=2, ceil_mode=True)

        self.rebnconv2 = REBNCONV(mid_ch, mid_ch, dirate=1)
        self.pool2 = nn.MaxPool2d(2, stride=2, ceil_mode=True)

        self.rebnconv3 = REBNCONV(mid_ch, mid_ch, dirate=1)
        self.pool3 = nn.MaxPool2d(2, stride=2, ceil_mode=True)

        self.rebnconv4 = REBNCONV(mid_ch, mid_ch, dirate=1)
        self.pool4 = nn.MaxPool2d(2, stride=2, ceil_mode=True)

        self.rebnconv5 = REBNCONV(mid_ch, mid_ch, dirate=1)

        self.rebnconv6 = REBNCONV(mid_ch, mid_ch, dirate=2)

        self.rebnconv5d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
        self.rebnconv4d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
        self.rebnconv3d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
        self.rebnconv2d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
        self.rebnconv1d = REBNCONV(mid_ch * 2, n_classes, dirate=1)
        self.coordinate_attention = coordinate_attention(n_classes, n_classes)

    def forward(self, x):
        hx = x

        hxin = self.rebnconvin(hx)

        hx1 = self.rebnconv1(hxin)
        hx = self.pool1(hx1)

        hx2 = self.rebnconv2(hx)
        hx = self.pool2(hx2)

        hx3 = self.rebnconv3(hx)
        hx = self.pool3(hx3)

        hx4 = self.rebnconv4(hx)
        hx = self.pool4(hx4)

        hx5 = self.rebnconv5(hx)

        hx6 = self.rebnconv6(hx5)

        hx5d = self.rebnconv5d(torch.cat((hx6, hx5), 1))
        hx5dup = _upsample_like(hx5d, hx4)

        hx4d = self.rebnconv4d(torch.cat((hx5dup, hx4), 1))
        hx4dup = _upsample_like(hx4d, hx3)

        hx3d = self.rebnconv3d(torch.cat((hx4dup, hx3), 1))
        hx3dup = _upsample_like(hx3d, hx2)

        hx2d = self.rebnconv2d(torch.cat((hx3dup, hx2), 1))
        hx2dup = _upsample_like(hx2d, hx1)

        hx1d = self.rebnconv1d(torch.cat((hx2dup, hx1), 1))
        hx1d = self.coordinate_attention(hx1d)

        """
        del hx1, hx2, hx3, hx4, hx5, hx6
        del hx5d, hx4d, hx3d, hx2d
        del hx2dup, hx3dup, hx4dup, hx5dup
        """

        return hx1d + hxin


### RSU-5 ###
class RSU5(nn.Module):  # UNet05DRES(nn.Module):
    def __init__(self, n_channels=3, mid_ch=12, n_classes=4):
        super(RSU5, self).__init__()

        self.rebnconvin = REBNCONV(n_channels, n_classes, dirate=1)

        self.rebnconv1 = REBNCONV(n_classes, mid_ch, dirate=1)
        self.pool1 = nn.MaxPool2d(2, stride=2, ceil_mode=True)

        self.rebnconv2 = REBNCONV(mid_ch, mid_ch, dirate=1)
        self.pool2 = nn.MaxPool2d(2, stride=2, ceil_mode=True)

        self.rebnconv3 = REBNCONV(mid_ch, mid_ch, dirate=1)
        self.pool3 = nn.MaxPool2d(2, stride=2, ceil_mode=True)

        self.rebnconv4 = REBNCONV(mid_ch, mid_ch, dirate=1)

        self.rebnconv5 = REBNCONV(mid_ch, mid_ch, dirate=2)

        self.rebnconv4d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
        self.rebnconv3d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
        self.rebnconv2d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
        self.rebnconv1d = REBNCONV(mid_ch * 2, n_classes, dirate=1)
        self.coordinate_attention = coordinate_attention(n_classes, n_classes)

    def forward(self, x):
        hx = x

        hxin = self.rebnconvin(hx)

        hx1 = self.rebnconv1(hxin)
        hx = self.pool1(hx1)

        hx2 = self.rebnconv2(hx)
        hx = self.pool2(hx2)

        hx3 = self.rebnconv3(hx)
        hx = self.pool3(hx3)

        hx4 = self.rebnconv4(hx)

        hx5 = self.rebnconv5(hx4)

        hx4d = self.rebnconv4d(torch.cat((hx5, hx4), 1))
        hx4dup = _upsample_like(hx4d, hx3)

        hx3d = self.rebnconv3d(torch.cat((hx4dup, hx3), 1))
        hx3dup = _upsample_like(hx3d, hx2)

        hx2d = self.rebnconv2d(torch.cat((hx3dup, hx2), 1))
        hx2dup = _upsample_like(hx2d, hx1)

        hx1d = self.rebnconv1d(torch.cat((hx2dup, hx1), 1))
        hx1d = self.coordinate_attention(hx1d)

        """
        del hx1, hx2, hx3, hx4, hx5
        del hx4d, hx3d, hx2d
        del hx2dup, hx3dup, hx4dup
        """

        return hx1d + hxin


### RSU-4 ###
class RSU4(nn.Module):  # UNet04DRES(nn.Module):
    def __init__(self, n_channels=3, mid_ch=12, n_classes=4):
        super(RSU4, self).__init__()

        self.rebnconvin = REBNCONV(n_channels, n_classes, dirate=1)

        self.rebnconv1 = REBNCONV(n_classes, mid_ch, dirate=1)
        self.pool1 = nn.MaxPool2d(2, stride=2, ceil_mode=True)

        self.rebnconv2 = REBNCONV(mid_ch, mid_ch, dirate=1)
        self.pool2 = nn.MaxPool2d(2, stride=2, ceil_mode=True)

        self.rebnconv3 = REBNCONV(mid_ch, mid_ch, dirate=1)

        self.rebnconv4 = REBNCONV(mid_ch, mid_ch, dirate=2)

        self.rebnconv3d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
        self.rebnconv2d = REBNCONV(mid_ch * 2, mid_ch, dirate=1)
        self.rebnconv1d = REBNCONV(mid_ch * 2, n_classes, dirate=1)
        self.coordinate_attention = coordinate_attention(n_classes, n_classes)
    def forward(self, x):
        hx = x

        hxin = self.rebnconvin(hx)

        hx1 = self.rebnconv1(hxin)
        hx = self.pool1(hx1)

        hx2 = self.rebnconv2(hx)
        hx = self.pool2(hx2)

        hx3 = self.rebnconv3(hx)

        hx4 = self.rebnconv4(hx3)

        hx3d = self.rebnconv3d(torch.cat((hx4, hx3), 1))
        hx3dup = _upsample_like(hx3d, hx2)

        hx2d = self.rebnconv2d(torch.cat((hx3dup, hx2), 1))
        hx2dup = _upsample_like(hx2d, hx1)

        hx1d = self.rebnconv1d(torch.cat((hx2dup, hx1), 1))
        hx1d = self.coordinate_attention(hx1d)

        """
        del hx1, hx2, hx3, hx4
        del hx3d, hx2d
        del hx2dup, hx3dup
        """

        return hx1d + hxin


### RSU-4F ###
class RSU4F(nn.Module):
    def __init__(self, n_channels=3, mid_ch=12, n_classes=4):
        super(RSU4F, self).__init__()

        # 使用普通的深度可分离卷积
        self.rebnconvin = DepthwiseSeparableConv(n_channels, n_classes, dw_kernel_size=3, dw_padding=1,
                                                 pw_kernel_size=1, pw_padding=0)

        # 使用空洞卷积替换原始卷积层
        self.rebnconv1 = DilatedDepthwiseSeparableConv(n_classes, mid_ch, dw_kernel_size=3, dw_padding=2, dilation=2)
        self.rebnconv2 = DilatedDepthwiseSeparableConv(mid_ch, mid_ch, dw_kernel_size=3, dw_padding=2,
                                                       dilation=2)  # 空洞卷积，dilation=2
        self.rebnconv3 = DilatedDepthwiseSeparableConv(mid_ch, mid_ch, dw_kernel_size=3, dw_padding=4,
                                                       dilation=4)  # 空洞卷积，dilation=4

        # 更深的空洞卷积
        self.rebnconv4 = DilatedDepthwiseSeparableConv(mid_ch, mid_ch, dw_kernel_size=3, dw_padding=8,
                                                       dilation=8)  # 空洞卷积，dilation=8

        # 逆向卷积部分同样使用空洞卷积
        self.rebnconv3d = DilatedDepthwiseSeparableConv(mid_ch * 2, mid_ch, dw_kernel_size=3, dw_padding=4,
                                                        dilation=4)  # 空洞卷积，dilation=4
        self.rebnconv2d = DilatedDepthwiseSeparableConv(mid_ch * 2, mid_ch, dw_kernel_size=3, dw_padding=2,
                                                        dilation=2)  # 空洞卷积，dilation=2
        self.rebnconv1d = DilatedDepthwiseSeparableConv(mid_ch * 2, n_classes, dw_kernel_size=3, dw_padding=2,
                                                        dilation=2)
        self.coordinate_attention = coordinate_attention(n_classes, n_classes)

    def forward(self, x):
        hx = x

        hxin = self.rebnconvin(hx)

        hx1 = self.rebnconv1(hxin)
        hx2 = self.rebnconv2(hx1)
        hx3 = self.rebnconv3(hx2)

        hx4 = self.rebnconv4(hx3)

        hx3d = self.rebnconv3d(torch.cat((hx4, hx3), 1))
        hx2d = self.rebnconv2d(torch.cat((hx3d, hx2), 1))
        hx1d = self.rebnconv1d(torch.cat((hx2d, hx1), 1))
        # print('h3:{}'.format(hx1d.shape))
        hx1d = self.coordinate_attention(hx1d)
        # print('h4:{}'.format(hx1d.shape))
        return hx1d + hxin


### U^2-Net small ###
class self_net(nn.Module):
    def __init__(self, n_channels=3, n_classes=4):
        super(self_net, self).__init__()

        self.stage1 = RSU7(n_channels, 16, 64)
        self.pool12 = nn.MaxPool2d(2, stride=2, ceil_mode=True)

        self.stage2 = RSU6(64, 16, 64)
        self.pool23 = nn.MaxPool2d(2, stride=2, ceil_mode=True)

        self.stage3 = RSU5(64, 16, 64)
        self.pool34 = nn.MaxPool2d(2, stride=2, ceil_mode=True)

        self.stage4 = RSU4(64, 16, 64)
        self.pool45 = nn.MaxPool2d(2, stride=2, ceil_mode=True)

        self.stage5 = RSU4F(64, 16, 64)
        self.pool56 = nn.MaxPool2d(2, stride=2, ceil_mode=True)

        self.stage6 = RSU4F(64, 16, 64)

        # decoder
        self.stage5d = RSU4F(128, 16, 64)
        self.stage4d = RSU4(128, 16, 64)
        self.stage3d = RSU5(128, 16, 64)
        self.stage2d = RSU6(128, 16, 64)
        self.stage1d = RSU7(128, 16, 64)

        self.side1 = nn.Conv2d(64, n_classes, 3, padding=1)
        self.side2 = nn.Conv2d(64, n_classes, 3, padding=1)
        self.side3 = nn.Conv2d(64, n_classes, 3, padding=1)
        self.side4 = nn.Conv2d(64, n_classes, 3, padding=1)
        self.side5 = nn.Conv2d(64, n_classes, 3, padding=1)
        self.side6 = nn.Conv2d(64, n_classes, 3, padding=1)

        self.outconv = nn.Conv2d(6 * n_classes, n_classes, 1)

    def forward(self, x):
        hx = x

        # stage 1
        hx1 = self.stage1(hx)
        hx = self.pool12(hx1)

        # stage 2
        hx2 = self.stage2(hx)
        hx = self.pool23(hx2)

        # stage 3
        hx3 = self.stage3(hx)
        hx = self.pool34(hx3)

        # stage 4
        hx4 = self.stage4(hx)
        hx = self.pool45(hx4)

        # stage 5
        hx5 = self.stage5(hx)
        hx = self.pool56(hx5)

        # stage 6
        hx6 = self.stage6(hx)
        hx6up = _upsample_like(hx6, hx5)

        # decoder
        hx5d = self.stage5d(torch.cat((hx6up, hx5), 1))
        hx5dup = _upsample_like(hx5d, hx4)

        hx4d = self.stage4d(torch.cat((hx5dup, hx4), 1))
        hx4dup = _upsample_like(hx4d, hx3)

        hx3d = self.stage3d(torch.cat((hx4dup, hx3), 1))
        hx3dup = _upsample_like(hx3d, hx2)

        hx2d = self.stage2d(torch.cat((hx3dup, hx2), 1))
        hx2dup = _upsample_like(hx2d, hx1)

        hx1d = self.stage1d(torch.cat((hx2dup, hx1), 1))

        # side output
        d1 = self.side1(hx1d)

        d2 = self.side2(hx2d)
        d2 = _upsample_like(d2, d1)

        d3 = self.side3(hx3d)
        d3 = _upsample_like(d3, d1)

        d4 = self.side4(hx4d)
        d4 = _upsample_like(d4, d1)

        d5 = self.side5(hx5d)
        d5 = _upsample_like(d5, d1)

        d6 = self.side6(hx6)
        d6 = _upsample_like(d6, d1)

        d0 = self.outconv(torch.cat((d1, d2, d3, d4, d5, d6), 1))

        """
        del hx1, hx2, hx3, hx4, hx5, hx6
        del hx5d, hx4d, hx3d, hx2d, hx1d
        del hx6up, hx5dup, hx4dup, hx3dup, hx2dup
        """

        return d0, d1, d2, d3, d4, d5, d6
        # return torch.softmax(d0, dim=1), torch.softmax(d1, dim=1), \
        #        torch.softmax(d2, dim=1), torch.softmax(d3, dim=1), \
        #        torch.softmax(d4, dim=1), torch.softmax(d1, dim=1), torch.softmax(d5, dim=1)

CA注意力机制：

groups按实际需求进行调整，一般设置为16、32
class coordinate_attention(nn.Module):
    def __init__(self, inp, oup, groups=4):
        super(coordinate_attention, self).__init__()
        self.pool_h = nn.AdaptiveAvgPool2d((None, 1))  # 适应性平均池化到 (H, 1)
        self.pool_w = nn.AdaptiveAvgPool2d((1, None))  # 适应性平均池化到 (1, W)

        mip = max(8, inp // groups)  # 中间通道数，防止通道数过小

        # 定义卷积层和批归一化
        self.conv1 = nn.Conv2d(inp, mip, kernel_size=1, stride=1, padding=0)
        self.bn1 = nn.BatchNorm2d(mip)
        self.conv2 = nn.Conv2d(mip, oup, kernel_size=1, stride=1, padding=0)
        self.conv3 = nn.Conv2d(mip, oup, kernel_size=1, stride=1, padding=0)
        self.relu = nn.ReLU()  # 或者 h_swish()，根据需求选择激活函数

    def forward(self, x):
        identity = x  # 保存输入以便于跳跃连接
        n, c, h, w = x.size()  # 获取输入的尺寸

        # 计算 x 方向和 y 方向的特征图
        x_h = self.pool_h(x)  # 在 H 维度上进行池化
        x_w = self.pool_w(x).permute(0, 1, 3, 2)  # 在 W 维度上进行池化并转置

        # 将两个方向的特征图拼接在一起
        y = torch.cat([x_h, x_w], dim=2)
        y = self.conv1(y)  # 经过卷积层
        y = self.bn1(y)    # 批归一化
        y = self.relu(y)   # 激活函数

        # 将拼接后的特征图分割回 H 和 W 方向
        x_h, x_w = torch.split(y, [h, w], dim=2)
        x_w = x_w.permute(0, 1, 3, 2)  # 恢复原始维度

        # 计算注意力权重
        x_h = self.conv2(x_h).sigmoid()  # x 方向的注意力
        x_w = self.conv3(x_w).sigmoid()  # y 方向的注意力
        x_h = x_h.expand(-1, -1, h, w)    # 扩展到原始尺寸
        x_w = x_w.expand(-1, -1, h, w)

        # 应用注意力权重
        y = identity * x_w * x_h

        return y

深度可分离卷积模块：

class DepthwiseSeparableConv(nn.Module):
    def __init__(self, n_channels, n_classes, dw_kernel_size, dw_padding, pw_kernel_size, pw_padding, dw_dilation=1,
                 pw_dilation=1):
        super(DepthwiseSeparableConv, self).__init__()
        self.depthwise_conv = nn.Conv2d(
            n_channels,
            n_channels,
            kernel_size=dw_kernel_size,
            padding=dw_padding,
            dilation=dw_dilation,
            groups=n_channels
        )
        self.pointwise_conv = nn.Conv2d(
            n_channels,
            n_classes,
            kernel_size=pw_kernel_size,
            padding=pw_padding,
            groups=1
        )

    def forward(self, x):
        out = self.depthwise_conv(x)
        out = self.pointwise_conv(out)
        return out

空洞可分离卷积模块：

class DilatedDepthwiseSeparableConv(nn.Module):
    def __init__(self, n_channels, n_classes, dw_kernel_size=3, dw_padding=1, dilation=1, pw_kernel_size=1,
                 pw_padding=0):
        super(DilatedDepthwiseSeparableConv, self).__init__()
        self.depthwise = nn.Conv2d(n_channels, n_channels, kernel_size=dw_kernel_size, padding=dw_padding,
                                   dilation=dilation, groups=n_channels)
        self.pointwise = nn.Conv2d(n_channels, n_classes, kernel_size=pw_kernel_size, padding=pw_padding)

    def forward(self, x):
        x = self.depthwise(x)
        x = self.pointwise(x)
        return x

pious222222
关注
UNet 改进：添加CoordAtt 注意力机制
Henry的博客
02-18 442
CoordAtt（Coordinate Attention）是一种轻量级的注意力机制，旨在增强卷积神经网络（CNN）的特征表达能力。CoordAtt的核心思想是利用水平和垂直方向的位置信息来生成注意力权重，从而更好地建模特征之间的长程依赖关系。：通过分解特征图的全局池化操作，分别提取水平和垂直方向的位置信息，从而更好地建模空间关系。：CoordAtt的计算开销较小，适合嵌入到现有的CNN架构中，而不会显著增加计算负担。：通过注意力机制动态调整特征图的权重，使网络能够更关注重要的空间位置。
UNet 改进(2)：深入解析带有坐标注意力机制(CA)的UNet网络
最新发布
2401_82355416的博客
04-06 134
本文详细解析了一个改进的UNet实现，重点介绍了坐标注意力机制如何增强传统UNet的性能。通过将空间注意力与经典的编码器-解码器结构相结合，这个网络能够更有效地捕捉位置敏感的特征，在各类分割任务中表现出色。代码结构清晰，模块化设计使其易于理解和扩展，为图像分割研究和应用提供了有力的工具。
U-Net网络模型改进（添加通道与空间注意力机制）---亲测有效，指标提升
weixin_40641178的博客
11-05 1903
这一段时间做项目用到了模型，但是原始的U-Net网络还有很大的改良空间，在卷积下采样的过程中加入了通道注意力和空间注意力网络模型结合之后代码。
【即插即用】CA注意力机制（附源码）
weixin_45694817的博客
03-31 928
最近的研究表明，在移动网络设计中，通道注意力对于提升模型性能非常有效。但现有的研究常常忽略了位置信息，这对于生成精确的空间注意力图来说是非常重要的。在本文中，我们提出了一种创新的注意力机制，我们称之为“坐标注意力”。这个机制将位置信息融入通道注意力中，从而提升了模型的感知能力。与常规通道注意力机制不同，坐标注意力并不是简单地将特征张量转换为一个特征向量。而是将其分解为两个一维的特征编码过程，这两个过程各自沿着不同的空间方向来聚合特征。
CA注意力机制 (附代码)
PLANTTHESON的博客
10-08 8678
CA注意力机制 (附代码)
Unet改进3：在不同位置添加NAMAttention注意力机制
AIcurator的博客
08-24 925
识别不太显著的特征是模型压缩的关键。然而，它在革命性的注意机制中尚未得到研究。在这项工作中，我们提出了一种新的基于归一化的注意力模块(NAM)，它抑制了较不显著的权重。它将权重稀疏性惩罚应用于注意力模块，从而使它们在保持类似性能的同时提高计算效率。与Resnet和Mobilenet上的其他三种注意机制的比较表明，我们的方法具有更高的准确性。
CVPR2021注意力机制：Coordinate Attention——源码
Ratib的博客
10-20 1万+
一句话总结CA注意力就是：在通道注意力的基础上兼顾其空间关系。 SE Module CBAM Module CA Module class CA(nn.Module): def __init__(self, inp, reduction): super(CA, self).__init__() # h:height(行) w:width(列) se...
目标检测YOLO实战应用案例100讲-基于机器视觉的输电线路小目标检测和缺 陷识别（下）
qq_36130719的博客
09-17 377
本实验以YOLOv5s在相同数据集上的目标检测性能作为基准，采用了增加 小目标预测头、增加基于Transformer编码器的预测头模块、增加基于卷积注意 力模型的注意力机制模块和加权双向特征金字塔网络的YOLOv5s改进网络进行 对比，同时增加基于Swin Transformer编码器的预测头作为补充实验，聚焦在对输电线路巡检图像所有尺寸目标的检测，根据数据集标注情况分为“线夹、玻璃绝缘子、复合绝缘子、金具”四类。
JavaEE知识体系
yuh2012的博客
07-11 2万+
1 1.文件上传下载 1.1 文件上传 1.1.1 文件上传的作用 例如网络硬盘！就是用来上传下载文件的。 在智联招聘上填写一个完整的简历还需要上传照片呢。 1.1.2 文件上传对页面的要求 1.必须使用表单，而不能是超链接； 2.表单的method必须是POST，而不能是GET； 3.表单的enctype必须是multipart/form-data； 4.在表单中添加file表
目标检测YOLO实战应用案例100讲-基于改进YOLOv4算法的自动驾驶场景 目标检测
qq_36130719的博客
11-02 2098
随着21世纪的到来，我国人民的生活水平不断提高，人们对高品质生活的渴望 不断增强，居民对于汽车的需求也逐年增加，汽车保有量呈上升趋势。据2022年中国 汽车工业协会发布汽车全年产业产销数据，分别完成2702.1万辆和2686.4万辆，同比 增长3.4%和2.1%，全年实现小幅增长。驾车出行确实可以带给人们方便，但也加剧 了交通堵塞以及尾气所带来的空气污染等问题，同时行车安全也考验着每一位驾驶员 的驾驶技术。根据中华人民共和国2022年国民经济和社会发展统计公报，道路交通事 故万车死亡人数1.46人。
工作中使用到的单词（软件开发）
热门推荐
sun0322
03-15 5万+
１．エイリアス 　　alias 别名 powershell使用 get-help 命令时，会得到与此命令 相关（别名）的命令 ２．プロキシ　proxy　代　理 ３．プロモート 　 promote 促进，提升 　　开发的系统新功能上线发布，有时会使用到这个词，比如 STプロモート 还有使用リリース这个词的。比如STリリース。个人认为两者含义相同。 ４．見逃し　み................................................................
工作记录笔记
逍遥飞鹤的专栏
04-16 7506
Java相关原理和深入学习：http://wiki.jikexueyuan.com/list/java/ RPC框架：         http://www.cnblogs.com/luxiaoxun/p/5272384.html https://my.oschina.net/huangyong/blog/361751 编程狂人周刊：http://www.tuicool.c
注意力机制及代码详解
qq_45528961的博客
03-05 2629
之后对平均池化和最大池化的结果，利用共享的全连接层进行处理，我们会对处理后的两个结果进行相加，然后取一个sigmoid，此时我们获得了输入特征层每一个通道的权值（0-1之间）。之后将这两个结果进行一个堆叠，利用一次通道数为1的卷积调整通道数，然后取一个sigmoid，此时我们获得了输入特征层每一个特征点的权值（0-1之间）。CBAM将通道注意力机制和空间注意力机制进行另一个结合，CBMA会对输入进来的特征层分别进行通道注意力机制的处理和空间注意力机制的处理。其重点是获得输入进来的特征层，每一个通道的权值。
注意力机制结合UNet，速度飙升98.82%！
2401_88556812的博客
03-14 803
Transformer 与 U-Net 结合：将 Transformer 的全局自注意力机制与 U-Net 的局部细节提取能力相结合，显著提升了分割性能（例如在 Synapse 数据集上，平均 DSC 提升至 77.48%，比传统 U-Net 提升了约 3.8%）。或在解码器阶段使用自注意力机制以建模像素间的全局关系。多尺度特征利用：通过多尺度特征图的门控操作，模型在不同数据集上均表现出良好的泛化能力，Dice 分数在 CT-82 数据集上达到了 83.1%，相比传统 U-Net 提升了约 1.1%。
UNet与U2Net
小白菜的博客
04-30 934
相对于UNet，U2Net采用了更深的网络结构，并引入了一个新的Attention U-Net模块，以更好地保留图像中的细节信息。U2Net是由Ningning Wang等人在2020年提出的一种语义分割网络，可以高效地提取图像中的。UNet是一种用于图像分割的深度学习模型，由Olaf Ronneberger等人在2015年提出。具有一种特殊的U形结构，可以将输入图像逐步缩小，然后再将其逐步放大，以产生分割结果。、自然图像分割等领域具有广泛的应用。UNet和U2Net都是。领域中的深度学习模型。
UNet、U2Net 和U2NetP
小白菜的博客
05-03 2231
其中，U2Net包括U2Net和U2NetP两个版本，前者基于纯卷积操作，后者则增加了轻量级的U形网络来进行特征提取。编码器通过多层卷积操作对输入图像进行特征提取和降采样，解码器则通过反卷积操作和跳跃连接对编码器输出的特征图进行上采样和重构。U2NetP：U2NetP是U2Net的改进版本，通过添加较少的参数和计算量来进一步提升分割效果和降低推理成本。U2NetP主要通过轻量级的编码器和解码器来实现，在保证分割效果的同时，能够较快地处理大型图像和批量数据。
CVPR 2021 | 即插即用！ CA：新注意力机制，助力分类/检测/分割涨点！
阿木寺的博客
03-07 4万+
点击下方卡片，关注“CVer”公众号AI/CV重磅干货，第一时间送达本文转载自：AI人工智能初学者Coordinate Attention for Efficient Mobile Net...
神经网络学习小记录78——Keras CA（Coordinate attention）注意力机制的解析与代码详解
Bubbliiiing的学习小课堂
02-17 7322
CA注意力机制是最近提出的一种注意力机制，全面关注特征层的空间信息和通道信息。
u2net加注意力机制
07-27
U2Net是一种基于深度学习的图像分割模型，它可以实现将输入图像分割成前景和背景两部分。而加注意力机制则是一种常用的技术，用于增强模型在处理任务时对特定区域的关注度。 在U2Net中，加入注意力机制可以帮助模型更好地理解图像中的重要区域，并将更多的注意力放在这些区域上。这样一来，U2Net就能更准确地进行图像分割，提高分割结果的质量和准确性。 具体而言，注意力机制可以通过两个关键步骤来实现。首先，需要计算图像中每个像素点的注意力权重。这通常可以通过卷积神经网络来实现，根据输入的特征图计算注意力权重。其次，根据计算得到的权重，将注意力权重与原始特征图相乘，得到加权后的特征图。这样，模型在进行分割时就会更加关注重要的区域。 总之，通过在U2Net中加入注意力机制，可以提升模型的性能，并使其更好地适应各种图像分割任务。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值