UACANet分割模型搭建

最新推荐文章于 2024-08-29 22:40:32 发布
最新推荐文章于 2024-08-29 22:40:32 发布
阅读量374 收藏 1
点赞数 1
文章标签： 计算机视觉 人工智能 python 深度学习 图像处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56247038/article/details/129737522
版权
本文介绍了UACANet，一个基于Res2Net的编码解码器网络，其特色在于使用轴注意力（AxisAttention）模块，包括PAA_kernel、PAA_e和PAA_d，以增强特征学习和上下文信息处理。网络通过多尺度特征融合和注意力机制提高图像分割性能。
摘要由CSDN通过智能技术生成

原论文：https://arxiv.org/abs/2107.02368
源码：https://github.com/plemeri/UACANet

直接步入正题~~~

一、轴注意力

class self_attn(nn.Module):
    def __init__(self, in_channels, mode='hw'):
        super(self_attn, self).__init__()

        self.mode = mode

        self.query_conv = conv(in_channels, in_channels // 8, kernel_size=(1, 1))
        self.key_conv = conv(in_channels, in_channels // 8, kernel_size=(1, 1))
        self.value_conv = conv(in_channels, in_channels, kernel_size=(1, 1))

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

    def forward(self, x): # 例如输入x: bs 256 44 44
        batch_size, channel, height, width = x.size()

        axis = 1
        if 'h' in self.mode:
            axis *= height
        if 'w' in self.mode:
            axis *= width

        view = (batch_size, -1, axis)

        #bs 256 44 44 -- bs 32 44 44 -- bs 1408 44(bs 32*44 44) -- bs 44 1408
        projected_query = self.query_conv(x).view(*view).permute(0, 2, 1)
        #bs 256 44 44 -- bs 32 44 44 -- bs 1408 44
        projected_key = self.key_conv(x).view(*view)

        attention_map = torch.bmm(projected_query, projected_key) # bs 44 44
        attention = self.softmax(attention_map) # bs 44 44
        projected_value = self.value_conv(x).view(*view) #bs 256 44 44 -- bs 11264 44

        out = torch.bmm(projected_value, attention.permute(0, 2, 1)) # bs 11264 44
        out = out.view(batch_size, channel, height, width) #view为原始的形状：bs 256 44 44

        out = self.gamma * out + x #bs 256 44 44
        return out

参考：http://t.csdn.cn/Ag463 

二、PAA_kernel模块

class PAA_kernel(nn.Module):
    def __init__(self, in_channel, out_channel, receptive_size=3):
        super(PAA_kernel, self).__init__()
        self.conv0 = conv(in_channel, out_channel, 1)
        self.conv1 = conv(out_channel, out_channel, kernel_size=(1, receptive_size))
        self.conv2 = conv(out_channel, out_channel, kernel_size=(receptive_size, 1))
        self.conv3 = conv(out_channel, out_channel, 3, dilation=receptive_size)
        self.Hattn = self_attn(out_channel, mode='h')
        self.Wattn = self_attn(out_channel, mode='w')

    def forward(self, x): # 例如输入为：bs 32 44 44
        x = self.conv0(x) # bs 32 44 44
        x = self.conv1(x) # bs 32 44 44
        x = self.conv2(x) # bs 32 44 44
        # print(f'PAA_Kernel_x:{x.shape}')

        Hx = self.Hattn(x) # bs 32 44 44
        # print(f'PAA_Kernel_Hx:{Hx.shape}')
        Wx = self.Wattn(x) # bs 32 44 44
        # print(f'PAA_Kernel_Wx:{Wx.shape}')

        x = self.conv3(Hx + Wx) # bs 32 44 44
        # print(f'PAA_Kernel:{x.shape}')
        return x

三、PAA_e模块

class PAA_e(nn.Module):
    def __init__(self, in_channel, out_channel):
        super(PAA_e, self).__init__()
        self.relu = nn.ReLU(True)

        self.branch0 = conv(in_channel, out_channel, 1)
        self.branch1 = PAA_kernel(in_channel, out_channel, 3)
        self.branch2 = PAA_kernel(in_channel, out_channel, 5)
        self.branch3 = PAA_kernel(in_channel, out_channel, 7)

        self.conv_cat = conv(4 * out_channel, out_channel, 3)
        self.conv_res = conv(in_channel, out_channel, 1)

    def forward(self, x):  # 输入为 bs 512 44 44
        x0 = self.branch0(x) # bs 32 44 44
        # print(f'PAA_e_x0:{x0.shape}')
        x1 = self.branch1(x) # bs 32 44 44
        x2 = self.branch2(x) # bs 32 44 44
        x3 = self.branch3(x) # bs 32 44 44

        x_cat = self.conv_cat(torch.cat((x0, x1, x2, x3), 1)) # bs 32*4 44 44 -- bs 32 44 44
        x = self.relu(x_cat + self.conv_res(x)) # bs 32 44 44

        return x

tips: 这个结构类似于PraNet中的RFB模块！http://t.csdn.cn/cJfm2

四、PAA_d模块

class PAA_d(nn.Module):
    # dense decoder, it can be replaced by other decoder previous, such as DSS, amulet, and so on.
    # used after MSF
    def __init__(self, channel):
        super(PAA_d, self).__init__()
        self.conv1 = conv(channel * 3 ,channel, 3)
        self.conv2 = conv(channel, channel, 3)
        self.conv3 = conv(channel, channel, 3)
        self.conv4 = conv(channel, channel, 3)
        self.conv5 = conv(channel, 1, 3, bn=False)

        self.Hattn = self_attn(channel, mode='h')
        self.Wattn = self_attn(channel, mode='w')

        self.upsample = lambda img, size: F.interpolate(img, size=size, mode='bilinear', align_corners=True)
        
    def forward(self, f1, f2, f3):
        #f1：bs, 32, 11, 11   f2：bs, 32, 22, 22   f3：bs, 32, 44, 44
        f1 = self.upsample(f1, f3.shape[-2:]) #f1：bs, 32, 44, 44
        f2 = self.upsample(f2, f3.shape[-2:]) #f2：bs, 32, 44, 44
        f3 = torch.cat([f1, f2, f3], dim=1) #f3：bs, 32*3, 44, 44
        f3 = self.conv1(f3) #f3：bs, 32, 44, 44

        Hf3 = self.Hattn(f3) #f3：bs, 32, 44, 44
        Wf3 = self.Wattn(f3) #f3：bs, 32, 44, 44

        f3 = self.conv2(Hf3 + Wf3) #f3：bs, 32, 44, 44
        f3 = self.conv3(f3) #f3：bs, 32, 44, 44
        f3 = self.conv4(f3) #f3：bs, 32, 44, 44
        out = self.conv5(f3) #out：bs, 1, 44, 44

        return f3, out

五、UACA模块

class UACA(nn.Module):
    def __init__(self, in_channel, channel):
        super(UACA, self).__init__()
        self.channel = channel

        self.conv_query = nn.Sequential(conv(in_channel, channel, 3, relu=True),
                                        conv(channel, channel, 3, relu=True))
        self.conv_key = nn.Sequential(conv(in_channel, channel, 1, relu=True),
                                      conv(channel, channel, 1, relu=True))
        self.conv_value = nn.Sequential(conv(in_channel, channel, 1, relu=True),
                                        conv(channel, channel, 1, relu=True))

        self.conv_out1 = conv(channel, channel, 3, relu=True)
        self.conv_out2 = conv(in_channel + channel, channel, 3, relu=True)
        self.conv_out3 = conv(channel, channel, 3, relu=True)
        self.conv_out4 = conv(channel, 1, 1)

    def forward(self, x, map):
        b, c, h, w = x.shape
        
        # compute class probability  x:bs, 64, 11, 11  map:bs, 1, 44, 44
        map = F.interpolate(map, size=x.shape[-2:], mode='bilinear', align_corners=False) #map:bs, 1, 11, 11
        fg = torch.sigmoid(map) #:bs, 1, 11, 11
        
        p = fg - .5

        # clip函数将p限制到0到1之间，如果小于0则为0，大于0则为它本身
        fg = torch.clip(p, 0, 1) # foreground 前景
        bg = torch.clip(-p, 0, 1) # background 背景
        cg = .5 - torch.abs(p) # confusion area 不确定区域

        prob = torch.cat([fg, bg, cg], dim=1) #bs, 3, 11, 11

        # reshape feature & prob
        f = x.view(b, h * w, -1)  #bs, 121, 64
        prob = prob.view(b, 3, h * w) #bs, 3, 121
        
        # compute context vector
        context = torch.bmm(prob, f).permute(0, 2, 1).unsqueeze(3) #bs, 3, 64 -- bs, 64, 3 -- bs, 64, 3, 1

        # k q v compute
        query = self.conv_query(x).view(b, self.channel, -1).permute(0, 2, 1) #bs, 32, 11, 11 -- bs, 32, 121 -- bs, 121, 32
        key = self.conv_key(context).view(b, self.channel, -1) #bs, 64, 3, 1 -- bs, 32, 3, 1 -- bs, 32, 3
        value = self.conv_value(context).view(b, self.channel, -1).permute(0, 2, 1) #bs, 64, 3, 1 -- bs, 32, 3, 1 -- bs, 32, 3 -- bs, 3, 32

        # compute similarity map
        sim = torch.bmm(query, key) # bs, 121, 3
        sim = (self.channel ** -.5) * sim
        sim = F.softmax(sim, dim=-1) # bs, 121, 3

        # compute refined feature
        context = torch.bmm(sim, value).permute(0, 2, 1).contiguous().view(b, -1, h, w)  # bs, 121, 32 -- bs, 32, 121 -- bs, 32, 11, 11
        context = self.conv_out1(context) #bs, 32, 11, 11

        x = torch.cat([x, context], dim=1) #bs, 96, 11, 11
        x = self.conv_out2(x) #bs, 32, 11, 11
        x = self.conv_out3(x) #bs, 32, 11, 11
        # print(f'x:{x.shape}')
        out = self.conv_out4(x) #bs, 1, 11, 11
        out = out + map #bs, 1, 11, 11
        # print(f'out:{out.shape}')
        return x, out

六、整体网络结构

class UACANet(nn.Module):
    # res2net based encoder decoder
    def __init__(self, channels=256, output_stride=16, pretrained=True):
        super(UACANet, self).__init__()
        self.resnet = res2net50_v1b_26w_4s(pretrained=pretrained, output_stride=output_stride)

        self.context2 = PAA_e(512, channels)
        self.context3 = PAA_e(1024, channels)
        self.context4 = PAA_e(2048, channels)

        self.decoder = PAA_d(channels)

        self.attention2 = UACA(channels * 2, channels)
        self.attention3 = UACA(channels * 2, channels)
        self.attention4 = UACA(channels * 2, channels)

        self.loss_fn = bce_iou_loss

        self.ret = lambda x, target: F.interpolate(x, size=target.shape[-2:], mode='bilinear', align_corners=False)
        self.res = lambda x, size: F.interpolate(x, size=size, mode='bilinear', align_corners=False)

    def forward(self, sample):
        x = sample['image']
        if 'gt' in sample.keys():
            y = sample['gt']
        else:
            y = None
            
        base_size = x.shape[-2:] # 352, 352
                                 # 输入为 bs, 3, 352, 352
        x = self.resnet.conv1(x) # bs, 64, 176, 176
        x = self.resnet.bn1(x)
        x = self.resnet.relu(x)
        x = self.resnet.maxpool(x) # bs, 64, 88, 88

        x1 = self.resnet.layer1(x) # bs, 256, 88, 88
        x2 = self.resnet.layer2(x1) # bs, 512, 44, 44
        x3 = self.resnet.layer3(x2) # bs, 1024, 22, 22
        x4 = self.resnet.layer4(x3) # bs, 2048, 11, 11

        x2 = self.context2(x2) # bs, 512, 44, 44 -- bs, 32, 44, 44
        x3 = self.context3(x3) # bs, 1024, 22, 22 -- bs, 32, 22, 22
        x4 = self.context4(x4) # bs, 2048, 11, 11 -- bs, 32, 11, 11

        f5, a5 = self.decoder(x4, x3, x2) # f5:bs, 32, 44, 44   a5:bs, 1, 44, 44
        out5 = self.res(a5, base_size) # bs, 1, 352, 352

        f4, a4 = self.attention4(torch.cat([x4, self.ret(f5, x4)], dim=1), a5)  # f4:bs, 32, 11, 11   a4:bs, 1, 11, 11
        out4 = self.res(a4, base_size)  # bs, 1, 352, 352

        f3, a3 = self.attention3(torch.cat([x3, self.ret(f4, x3)], dim=1), a4)   # f4:bs, 32, 22, 22   a4:bs, 1, 22, 22
        out3 = self.res(a3, base_size)  # bs, 1, 352, 352

        _, a2 = self.attention2(torch.cat([x2, self.ret(f3, x2)], dim=1), a3)   # a4:bs, 1, 44, 44
        out2 = self.res(a2, base_size)  # bs, 1, 352, 352


        if y is not None:
            loss5 = self.loss_fn(out5, y)
            loss4 = self.loss_fn(out4, y)
            loss3 = self.loss_fn(out3, y)
            loss2 = self.loss_fn(out2, y)

            loss = loss2 + loss3 + loss4 + loss5
            debug = [out5, out4, out3]
        else:
            loss = 0
            debug = []

        return {'pred': out2, 'loss': loss, 'debug': debug}

 

有温度的AI
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
UACANet: Uncertainty Augmented Context Attention for Polyp Segmentation代码补充
qq_43733107的博客
10-31 576
UACANet代码补充
探索精准医疗的未来：UACANet在结肠息肉分割中的突破
gitblog_00046的博客
06-19 443
探索精准医疗的未来：UACANet在结肠息肉分割中的突破 项目地址:https://gitcode.com/plemeri/UACANet 在医学图像处理领域，精确的结肠息肉分割是诊断和治疗的关键。今天，我们要向您推荐一个前沿的开源项目——UACANet（不确定性增强上下文注意力网络），该技术专为解决这一挑战而设计。UACANet凭借其创新的架构，在结肠息肉的分割上达到了业界领先水平，它的表现已经...
UACANet: Uncertainty Augmented Context Attention for Polyp Segmentation
qq_43733107的博客
10-28 2310
不确定性用于医学图像分割
UACANet: Uncertainty Augmented Context Attention for Polyp Segmentation代码
qq_43733107的博客
10-30 738
不确定度用于医学图像分割
【最强ResNet改进系列】Res2Net：一种新的多尺度网络结构，性能提升显著
热门推荐
深度学习技术前沿
08-08 1万+
点击上方，选择星标或置顶，不定期资源大放送！阅读大概需要15分钟Follow小博主，每天更新前沿干货【导读】2020年，在各大CV顶会上又出现了许多基于ResNet改进的工作，比如:Re...
不确定性语义分割论文、代码汇总
如果想成为中心，那么就到中心去吧。
03-26 6484
文章目录2017What Uncertainties Do We Need in Bayesian Deep Learning for Computer Vision?2020An Uncertainty-Driven GCN Refinement Strategy for Organ Segmentation2021Is segmentation uncertainty useful? 2017 What Uncertainties Do We Need in Bayesian Deep Learning
计算机视觉论文-2021-07-07
中科院AI算法工程师的博客
07-08 1803
本专栏是计算机视觉方向论文收集积累，时间：2021年7月7日，来源：paper digest 欢迎关注原创公众号【计算机视觉联盟】，回复【西瓜书手推笔记】可获取我的机器学习纯手推笔记！ 直达笔记地址：机器学习手推笔记（GitHub地址） 1, TITLE:Morphological Classification of Galaxies in S-PLUS Using An Ensemble of Convolutional Networks AUTHORS: N. M. CARDOSO...
基于级联注意解码的医学图像分割
6222基于级联注意解码的医学图像分割Md Mostafijur Rahman Radu Marculescu德克萨斯大学奥斯汀{mostafijur.rahman，radum} @ utexas.edu摘要变形金刚在医学图像分割中表现出了巨大的潜力，因为它们能够通过自我关注...
基于计算机视觉的图书推荐应用【AI编程实录】
新缸中之脑
08-26 944
我酝酿这个想法已经很多年了——一个只需拍照就能推荐书籍的应用程序。正如所说，我通常忙于客户项目。但在最新AI工具的帮助下，我决定试一试。事情并不总是一帆风顺的——计算机视觉和文本识别给我带来了一些意外。但令我惊讶的是，我设法以比我预期快得多的速度得到了一个好的原型。即使在你不是专家的领域，人工智能也能帮助将想法变成现实，这真是太神奇了。这段旅程既令人谦卑又令人兴奋，我迫不及待地想看看它会带来什么。宣传语如下：“想象一下，你走进一家书店，你真的想买一本书，但买哪一本呢？
＜数据集＞安全背心识别数据集＜目标检测＞
qq_53332949的博客
08-29 79
YOLO与VOC格式的安全背心识别数据集，适用于YOLO系列、Faster Rcnn、SSD等模型训练，共2个类别：vest、no-vest，4185张图片
VLM 系列——phi3.5-Vision——论文解读
TigerZ*的博客
08-29 166
是一系列大型语言模型（LLM） & 多模态大型语言模型（MLLM）。其中LLM包括phi-3-mini 3.8B、phi-3-small 7B、phi-3-medium 14B，phi-3-mini可以轻松地在现代手机上本地进行推理；多模态模型包括phi-3-vision（基于phi-3-mini & CLIP ViT-L/14） 4.2B。本文重点介绍多模态的phi-3-mini模型，该模型能够处理包括文本、图像在内的多种数据类型，具备图片描述、单图文问答、 多图问对话、视频理解对话 、json格式、高清
Python实现分水岭图像分割算法
qq_42568323的博客
08-24 363
图像分割是计算机视觉领域中的重要技术，用于将图像分割成多个具有相似特征的区域。分水岭算法是一种强大的图像分割工具，尤其适用于处理复杂结构的图像。通过合理的图像预处理和标记操作，可以有效改善分水岭算法的分割效果。梯度图在边缘处具有高值，在平坦区域具有低值，这样有助于分水岭算法找到图像中的边界。尽管分水岭算法在图像分割中具有良好的效果，但它也存在一些挑战，如过度分割、对噪声敏感等。通过本文的介绍和Python代码示例，相信读者已经对分水岭算法有了深入的理解，并能在自己的项目中应用这一算法来解决实际问题。
机器学习算法五之 目标检测评价指标 IOU 准确率 召回率等
yohnyang的博客
08-29 475
机器学习算法五之 目标检测评价指标 IOU 准确率 召回率等
图像数据处理25
最新发布
2301_80400361的博客
08-29 394
设定一个阙值，计算每个候选像素的灰度值与已生长区域像素的平均灰度值之间的差的绝对值，要是这个值小于阙值，则认为相似程度高，将其合并到生长区域像素中去，反之则不进行合并。可以理解成先选择一个像素区域，然后将其邻接区域中相似程度高的像素合并进去，直到找不到可以合并的像素为止。其的主要优点是能够较为精准地将具有相同特征的联通区域分割出来。
【YOLO系列】YOLO算法改进史
qq_51366016的博客
08-25 940
目标检测YOLO系列算法改进史
去雾去雨算法
weixin_71113035的博客
08-19 1139
去雾去雨算法
【目标检测】YOLOV2
qq_1532145264的博客
08-26 987
YOLO9000: Better, Faster, Stronger
【OpenCV】不变矩
TeamLee的博客
08-29 578
本文介绍了空间矩、中心矩和Hu不变矩在图像中的应用和原理
[数据集][目标检测]管道漏水泄漏破损检测数据集VOC+YOLO格式2614张4类
FL1623863129的博客
08-25 327
数据集格式：Pascal VOC格式+YOLO格式(不包含分割路径的txt文件，仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件)特别声明：本数据集不对训练的模型或者权重文件精度作任何保证，数据集只提供准确且合理标注。标注类别名称:["crack","leak","no leak","water"]重要说明：数据集有部分增强图片，请仔细查看图片谨慎下载。图片数量(jpg文件个数)：2614。标注数量(xml文件个数)：2614。标注数量(txt文件个数)：2614。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值