UNet、AttentionUNet网络学习

已于 2024-12-13 19:35:42 修改
阅读量419 收藏
点赞数 2
CC 4.0 BY-SA版权
文章标签： 学习
于 2024-12-11 19:30:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45987837/article/details/144408194

1、图像分割（Image Segmentation）
1）定义：图像中的每个对象创建一个像素级掩码。目的是通过对每个像素进行分类来识别图像中不同对象的位置和形状。
2）度量标准：
（1）Binary cross-entropy：二分类的交叉熵损失。

  • 在图像分割中，每个像素点都被视为一个独立的二分类问题（即目标类或背景类）。
  • BCE计算预测值与真实标签之间的差异，并试图最小化这个差异。
    在这里插入图片描述

（2）Dice coefficient：是预测值与之间之间的重叠的通用度量标准。

  • 计算公式：2 * 预测值和真实值之间重叠面积 / 预测的和真实的相加的总面积。
  • 此指标的范围是0到1，其中1表示完美和完全重叠。

在这里插入图片描述
（3）Intersection over Union：一个简单的度量标准，

  • 计算公式：预测的和真实值之间的重叠区域 / 并集的区域。

  • 此度量范围为0到1，其中0表示无重叠，而1表示预测的和地面真实情况之间的完全重叠。
    在这里插入图片描述
    2、UNet网络架构实现
    U-Net网络常用于自然图像的分割。
    在这里插入图片描述

import torch
import torch.nn as nn
import torchvision.transforms.functional as TF

class DoubleConv(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(DoubleConv,self).__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(in_channels,out_channels,3,1,1,bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_channels,out_channels,3,1,1,bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True)
        )
    def forward(self,x):
        return self.conv(x)
    
class UNet(nn.Module):
    # 设置了in_channels=3, out_channels=1默认参数值
    # 如果实例化有参数传进来则会覆盖默认参数值
    def __init__(self, in_channels=3, out_channels=1,features=[64,128,256,512]):
        super(UNet,self).__init__()
        # 往上走
        self.ups = nn.ModuleList()
        # 往下走
        self.downs = nn.ModuleList()
        self.pool = nn.MaxPool2d(kernel_size=2,stride=2)
        # 从上往下走
        for feature in features:
            # 3-64 64-128 128-256 256-512 
            self.downs.append(DoubleConv(in_channels,feature))
            in_channels = feature

        # Down to Up part
        for feature in reversed(features):
            # 1024-512 拼接 1024-512  最后是64 
            self.ups.append(nn.ConvTranspose2d(feature*2,feature,kernel_size=2,stride=2))
            self.ups.append(DoubleConv(feature*2,feature))

        # 最下面的512-1024
        self.bottleneck = DoubleConv(features[-1],features[-1]*2)
        # 输出的64-1
        self.final_conv = nn.Conv2d(features[0],out_channels,kernel_size=1)
    
    def forward(self,x):
        skip_connections = []
        # 从上往下走
        for down in self.downs:
            x = down(x)
            skip_connections.append(x)
            x = self.pool(x)
        # 最底部的层
        x = self.bottleneck(x)
        # 将skip_connections列表中的元素顺序反转
        # 开始 结束 步长-1表示从后往前取元素
        skip_connections = skip_connections[::-1]

        # 从下往上走
        for idx in range(0,len(self.ups),2):
            x = self.ups[idx](x)
            skip_connection = skip_connections[idx//2]

            if x.shape != skip_connection.shape:
                # [2:]表示从索引2开始到序列末尾的所有元素
                # 形状为[batch_size, channels, height, width]
                # resize支持多种插值方法，默认情况下使用双线性插值
                x = TF.resize(x,size=skip_connection.shape[2:])
    
            concat_skip = torch.cat((skip_connection,x),dim=1)
            x = self.ups[idx+1](concat_skip)
        
        return self.final_conv(x)
        
def test():
    x = torch.randn((3,1,160,160))
    model = UNet(in_channels=1,out_channels=1)
    preds = model(x)
    print(preds.shape)
    print(x.shape)
    assert preds.shape == x.shape
    
if __name__ == "__main__":
    test()

3、AttentionUNet网络架构实现
通俗易懂来讲就是：在原网络的基础上，在原特征图和上采样特征图进行拼接前，对下采样特征图和上采样特征图增加了一个Attention Gate网络结构的处理，处理完成之后，再进行拼接操作，其他结构是一样的。
在这里插入图片描述

import torch
import torch.nn as nn
import torchvision.transforms.functional as TF

class DoubleConv(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(DoubleConv, self).__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, 3, 1, 1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_channels, out_channels, 3, 1, 1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True)
        )

    def forward(self, x):
        return self.conv(x)

class AttentionGate(nn.Module):
    """
        F_g: 上采样路径特征图的通道数
        F_l: 跳跃连接特征图的通道数
        F_int: 注意力机制内部特征图的通道数
    """
    def __init__(self, F_g, F_l, F_int):
        super(AttentionGate, self).__init__()
        # W_g是用于处理来自上采样路径的特征图g的1x1卷积层
        self.W_g = nn.Sequential(
            nn.Conv2d(F_g, F_int, kernel_size=1, stride=1, padding=0, bias=True),
            nn.BatchNorm2d(F_int)
        )
        
        # W_x是用于处理来自跳跃连接的特征图x的1x1卷积层
        self.W_x = nn.Sequential(
            nn.Conv2d(F_l, F_int, kernel_size=1, stride=1, padding=0, bias=True),
            nn.BatchNorm2d(F_int)
        )

        # psi是用于生成注意力权重的1x1卷积层，后面跟着BatchNorm和Sigmoid激活函数
        self.psi = nn.Sequential(
            nn.Conv2d(F_int, 1, kernel_size=1, stride=1, padding=0, bias=True),
            nn.BatchNorm2d(1),
            nn.Sigmoid()
        )
        
        # ReLU 激活函数用于计算W_g(g) + W_x(x)之后的非线性变换
        self.relu = nn.ReLU(inplace=True)

    def forward(self, g, x):
        """
            g: 上采样路径中的特征图 ( gating signal )
            x: 来自跳跃连接的特征图 ( skip connection )
            return: 应用注意力机制后的加权特征图
        """
        # 对gating signal应用1x1卷积和batchnorm
        g1 = self.W_g(g)
        # 对skip connection特征图应用1x1卷积和batchnorm
        x1 = self.W_x(x)

        # 如果两个特征图的空间尺寸不同，则调整g1到与x1相同的空间尺寸
        # antialias=False 参数指定了是否应用抗锯齿处理
        # 当antialias设置为 False 时，表示不应用抗锯齿处理
        # [2:]这个切片操作提取了形状元组的后两个元素，即高度和宽度 (H, W)
        if g1.shape[2:] != x1.shape[2:]:
            g1 = TF.resize(g1, size=x1.shape[2:], antialias=False)

        # 将两个特征图相加，并通过ReLU激活
        psi = self.relu(g1 + x1)

        # 生成注意力权重并调整尺寸以匹配x的尺寸
        psi = self.psi(psi)

        # 如果psi的空间尺寸不等于x的空间尺寸，则调整psi
        if psi.shape[2:] != x.shape[2:]:
            psi = TF.resize(psi, size=x.shape[2:], antialias=False)

        # 返回经过注意力权重加权后的特征图
        # *运算符进行的是逐元素乘法
        return x * psi

class AttentionUNet(nn.Module):
    def __init__(self, in_channels=3, out_channels=1, features=[64, 128, 256, 512]):
        super(AttentionUNet, self).__init__()
        self.ups = nn.ModuleList()
        self.downs = nn.ModuleList()
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.attentions = nn.ModuleList()

        for feature in features:
            self.downs.append(DoubleConv(in_channels, feature))
            in_channels = feature

        self.bottleneck = DoubleConv(features[-1], features[-1] * 2)

        for feature in reversed(features):
            self.ups.append(nn.ConvTranspose2d(feature * 2, feature, kernel_size=2, stride=2))   
            self.ups.append(DoubleConv(feature * 2, feature))
            # 注意力门，应用于跳跃连接前的特征图，所以输入和输出都是 feature 个通道
            self.attentions.append(AttentionGate(feature, feature, feature // 2))

        self.final_conv = nn.Conv2d(features[0], out_channels, kernel_size=1)

    def forward(self, x):
        skip_connections = []
        for down in self.downs:
            x = down(x)
            skip_connections.append(x)
            x = self.pool(x)

        x = self.bottleneck(x)
        skip_connections = skip_connections[::-1]

        for idx in range(0, len(self.ups), 2):
            x = self.ups[idx](x)
            # idx // 2 将两个数相除后,返回结果的整数部分,舍弃小数部分
            skip_connection = skip_connections[idx // 2]
            
            if x.shape != skip_connection.shape:
                x = TF.resize(x, size=skip_connection.shape[2:])
            
            # Apply attention gate before concatenation
            # AttentionGate的forward方法，并传入了两个参数
            skip_connection = self.attentions[idx // 2](g=x, x=skip_connection)

            concat_skip = torch.cat((skip_connection, x), dim=1)
            x = self.ups[idx + 1](concat_skip)

        return self.final_conv(x)

if __name__ == "__main__":
    x = torch.randn((3,1,160,160))
    model = AttentionUNet(in_channels=1,out_channels=1)
    preds = model(x)

    print(preds.shape)
    print(x.shape)
    assert preds.shape == x.shape
    # model = AttentionUNet(in_channels=3, out_channels=1)
    # print(model)
钟屿
关注
UNet网络
qq_39076073的博客
04-16 1920
Unet模型 首先利用卷积进行下采样，然后提取出一层又一层的特征，利用这一层又一层的特征，其再进行上采样，最后得出一个每个像素点对应其种类的图像 segnet只选了一个hw压缩了四次的特征层进行三次上采样得到最后的结果。 unet利用到了压缩了二、三、四次的特征层，最后输出图像分割的结果 网络结构 图像大小变化 将hw被压缩了四次的f4进行一次上采样后与f3进行concatenate，然后再进行一次上采样与f2进行concatenate，然后再进行一次上采样（这里可以选择是否与f1进行concaten
Unet
03-20
Unet网络 model.py包含网络结构result1 / result代表不同的模型读取文件，一个是基于自然图像的模型读取，文件格式[224,224,3]，一个是医学图像[512,512,1] train.py训练文件
UNet - unet网络
Henry的博客
11-15 1万+
Unet网络是医学图像分割领域常用的分割网络，因为网络的结构很像个U，所以称为UnetUnet 网络是针对像素点的分类，之前介绍的LeNet、ResNet等等都是图像分类，最后分的是整幅图像的类别，而Unet是对像素点输出的是前景还是背景的分类注：因为Unet 具体的网络框架均有所不同，例如有的连续卷积后会改变图像的size，有的上采样用的是线性插值的方法。这里只介绍same卷积和上采样用的转置卷积Unet网络是个U型结构，左边是Encoder，右边为Decoder。
UNet模型深度学习训练数据集使用指南
weixin_35364187的博客
06-07 1044
在现代计算机视觉和图像分析领域，UNet结构因其强大的图像分割能力而广受欢迎。本章将探讨UNet的诞生背景、核心特点，以及其在图像分割任务中的卓越表现。数据增强是一种提高模型泛化能力的策略，通过对训练数据应用一系列随机变化，来增加数据集的多样性。常见的图像增强技术包括旋转、缩放、裁剪、颜色调整等。旋转可以模拟不同的视角，缩放可以模拟物体距离的变化，裁剪可以提供不同大小的目标区域，而颜色调整可以模拟不同的光照条件。
Unet网络
lee0921921的博客
04-20 2555
即卷积pad=0,这使得图像进行一次卷积会失去边界（图像一周）像素点。
各种用于图像分割的Unet模型的实现-Unet，RCNN-Unet，Attention Unet，RCNN-Attention Unet，嵌套Unet-Python开发
05-25
各种Unet模型用于图像分割的实现-Unet，RCNN-Unet，注意力Unet，RCNN-Attention Unet，嵌套式Unet细分Unet细分-Pytorch-Nest-of-Unets各种Unet模型用于图像分割的实现UNet- U-Net：用于生物医学图像分割的卷积网络...
Unet、AttentionUnet、R2Unet、R2AUet，可运行，包含数据集
03-24
在IT领域，尤其是在计算机视觉和图像处理中，Unet、AttentionUnet、R2Unet以及R2AUet是常见的深度学习模型，用于图像分割任务。这些模型在医疗影像分析，特别是皮肤病诊断方面表现优秀。这里我们将深入探讨这些模型...
深度学习基于UNet与Simplicial Attention的图像分割模型设计：医学影像分析中的应用
最新发布
07-14
本文集中探讨了基于UNet神经网络模型及其结合Simplicial Attention机制的改进型图像分割模型在医学影像分析中的应用。 UNet模型是一种广泛应用于医学图像分割的卷积神经网络，其独特之处在于对称的编码器-解码器...
unet网络实现图像分割.zip
06-10
在实际应用中，Unet网络可以与其他技术结合，例如多尺度特征融合、Attention机制、或者是更复杂的网络结构如ResNet、DenseNet等作为基础网络，以进一步提升性能。此外，对于特定任务，可能还需要调整超参数，如学习...
优质项目实战-基于Pytorch实现的图像分割算法之UNet+R2UNet+Attention-UNet
10-20
其中，R2UNet是对UNet的一种扩展，它引入了残差连接（Residual Connections），这种连接可以有效地缓解深层网络训练过程中的梯度消失问题，进一步提高网络的学习能力和分割精度。R2UNet通过添加残差模块，允许网络层...
UNet
luc0852的博客
10-18 521
UNet 是一种用于图像分割的深度学习架构。UNet和FPN的区别是什么？介绍一下UNet的分割原理。推荐一些关于UNet的论文。
UNet系列网络
ReaFly的博客
01-18 2218
1.UNet
UNet网络制作
田乐蒙的博客
09-25 641
代码参考，根据该UP主的代码，加上我的个人整理和理解。（这个UP主的代码感觉很好，很规范UNet网络由三部分组成：卷积块，下采样层，上采样层。
UNet网络结构
热门推荐
lianghe77的博客
03-01 2万+
UNet是医学图像处理方面著名的图像分割网络，过程是这样的：输入是一幅图，输出是目标的分割结果。继续简化就是，一幅图，编码，或者说降采样，然后解码，也就是升采样，然后输出一个分割结果。根据结果和真实分割的差异，反向传播来训练这个分割网络。其网络结构如下： 可以看出，该网络结构主要分为三部分：下采样，上采样以及跳跃连接。首先将该网络分为左右部分来分析，左边是压缩的过程，即Encoder。通过卷积和...
unet attention
01-14
UNet 是一种常用于医学图像分割任务的卷积神经网络架构。该架构由两个主要部分组成：收缩路径（编码器）和扩展路径（解码器）。通过跳跃连接将低层特征图传递到高层，从而保留空间信息并提高分割精度。 #### 注意力...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值