尝试在UNet的不同位置添加SE模块

已于 2023-05-28 17:34:59 修改
阅读量3.7k 收藏 85
点赞数 8
文章标签： 深度学习 神经网络 人工智能
于 2023-05-28 01:04:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45981086/article/details/130905607
版权

目录

（1）se-unet01（在卷积后，下采样前，添加SE模块）

（2）se-unet02（在卷积后，上采样前，添加SE模块）

（3）se-unet03（在每两个卷积之后，加上SE模块）

（4）se-unet04（只在最后的输出卷积后，添加SE模块）

数据集：refuge视盘数据集

训练轮次：50

评价指标：dice coefficient、mean IOU

Architecture
dice coefficientmean IOU
unet0.98961.1
se-unet010.98963.3
se-unet020.98860.5
se-unet030.98867.3
se-unet040.98967.2

（1）在卷积后，下采样前，添加SE模块

模型改动代码：

from typing import Dict
import torch
import torch.nn as nn
import torch.nn.functional as F

'''-------------一、SE模块-----------------------------'''
#全局平均池化+1*1卷积核+ReLu+1*1卷积核+Sigmoid
class SE_Block(nn.Module):
    def __init__(self, inchannel, ratio=16):
        super(SE_Block, self).__init__()
        # 全局平均池化(Fsq操作)
        self.gap = nn.AdaptiveAvgPool2d((1, 1))
        # 两个全连接层(Fex操作)
        self.fc = nn.Sequential(
            nn.Linear(inchannel, inchannel // ratio, bias=False),  # 从 c -> c/r
            nn.ReLU(),
            nn.Linear(inchannel // ratio, inchannel, bias=False),  # 从 c/r -> c
            nn.Sigmoid()
        )

    def forward(self, x):
            # 读取批数据图片数量及通道数
            b, c, h, w = x.size()
            # Fsq操作：经池化后输出b*c的矩阵
            y = self.gap(x).view(b, c)
            # Fex操作：经全连接层输出（b，c，1，1）矩阵
            y = self.fc(y).view(b, c, 1, 1)
            # Fscale操作：将得到的权重乘以原来的特征图x
            return x * y.expand_as(x)

# 卷积，在uent中卷积一般成对使用
class DoubleConv(nn.Sequential):
    # 输入通道数， 输出通道数， mid_channels为成对卷积中第一个卷积层的输出通道数
    def __init__(self, in_channels, out_channels, mid_channels=None):
        if mid_channels is None:
            mid_channels = out_channels
        super(DoubleConv, self).__init__(
            # 3*3卷积，填充为1，卷积之后输入输出的特征图大小一致
            nn.Conv2d(in_channels, mid_channels, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(mid_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True)
        )

# 下采样
class Down(nn.Sequential):
    def __init__(self, in_channels, out_channels):
        super(Down, self).__init__(
            # 1.最大池化的窗口大小为2， 步长为2
            nn.MaxPool2d(2, stride=2),
            # 2.两个卷积
            DoubleConv(in_channels, out_channels)
        )

# 上采样
class Up(nn.Module):
    # bilinear是否采用双线性插值
    def __init__(self, in_channels, out_channels, bilinear=True):
        super(Up, self).__init__()
        if bilinear:
            # 使用双线性插值上采样
            # 上采样率为2，双线性插值模式
            self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
            self.conv = DoubleConv(in_channels, out_channels, in_channels // 2)
        else:
            # 使用转置卷积上采样
            self.up = nn.ConvTranspose2d(in_channels, in_channels // 2, kernel_size=2, stride=2)
            self.conv = DoubleConv(in_channels, out_channels)

    def forward(self, x1: torch.Tensor, x2: torch.Tensor) -> torch.Tensor:
        x1 = self.up(x1)
        # [N, C, H, W]
        # 上采样之后的特征图与要拼接的特征图，高度方向的差值
        diff_y = x2.size()[2] - x1.size()[2]
        # 上采样之后的特征图与要拼接的特征图，宽度方向的差值
        diff_x = x2.size()[3] - x1.size()[3]

        # padding_left, padding_right, padding_top, padding_bottom
        # 1.填充差值
        x1 = F.pad(x1, [diff_x // 2, diff_x - diff_x // 2,
                        diff_y // 2, diff_y - diff_y // 2])

        # 2.拼接
        x = torch.cat([x2, x1], dim=1)
        # 3.卷积，两次卷积
        x = self.conv(x)
        return x

# 最后的1*1输出卷积
class OutConv(nn.Sequential):
    def __init__(self, in_channels, num_classes):
        super(OutConv, self).__init__(
            nn.Conv2d(in_channels, num_classes, kernel_size=1)
        )


class UNet(nn.Module):
    # 参数: 输入通道数， 分割任务个数， 是否使用双线插值， 网络中第一个卷积通道个数
    def __init__(self,
                 in_channels: int = 1,
                 num_classes: int = 2,
                 bilinear: bool = True,
                 base_c: int = 64):
        super(UNet, self).__init__()
        self.in_channels = in_channels
        self.num_classes = num_classes
        self.bilinear = bilinear

        self.in_conv = DoubleConv(in_channels, base_c)
        # SE模块
        self.SE1 = SE_Block(base_c)
        self.SE2 = SE_Block(base_c * 2)
        self.SE3 = SE_Block(base_c * 4)
        self.SE4 = SE_Block(base_c * 8)

        # 下采样，参数:输入通道,输出通道
        self.down1 = Down(base_c, base_c * 2)
        self.down2 = Down(base_c * 2, base_c * 4)
        self.down3 = Down(base_c * 4, base_c * 8)


        # 如果采用双线插值上采样为 2，采用转置矩阵上采样为 1
        factor = 2 if bilinear else 1
        # 最后一个下采样，如果是双线插值则输出通道为512，否则为1024
        self.down4 = Down(base_c * 8, base_c * 16 // factor)

        self.SE5 = SE_Block(base_c * 16 // factor)
        # 上采样，参数:输入通道,输出通道
        self.up1 = Up(base_c * 16, base_c * 8 // factor, bilinear)
        self.up2 = Up(base_c * 8, base_c * 4 // factor, bilinear)
        self.up3 = Up(base_c * 4, base_c * 2 // factor, bilinear)
        self.up4 = Up(base_c * 2, base_c, bilinear)
        # 最后的1*1输出卷积
        self.out_conv = OutConv(base_c, num_classes)

    # 正向传播过程
    def forward(self, x: torch.Tensor) -> Dict[str, torch.Tensor]:
        # 1. 定义最开始的两个卷积层
        x1 = self.in_conv(x)
        x1 = self.SE1(x1)
        # 2. contracting path（收缩路径）
        x2 = self.down1(x1)
        x2 = self.SE2(x2)
        x3 = self.down2(x2)
        x3 = self.SE3(x3)
        x4 = self.down3(x3)
        x4 = self.SE4(x4)
        x5 = self.down4(x4)
        x5 = self.SE5(x5)
        # 3. expanding path（扩展路径）
        x = self.up1(x5, x4)
        x = self.up2(x, x3)
        x = self.up3(x, x2)
        x = self.up4(x, x1)
        # 4. 最后1*1输出卷积
        logits = self.out_conv(x)

        return {"out": logits}

（2）在卷积后，上采样前，添加SE模块

 模型改动代码：

from typing import Dict
import torch
import torch.nn as nn
import torch.nn.functional as F

# se-unet02
'''-------------一、SE模块-----------------------------'''
#全局平均池化+1*1卷积核+ReLu+1*1卷积核+Sigmoid
class SE_Block(nn.Module):
    def __init__(self, inchannel, ratio=16):
        super(SE_Block, self).__init__()
        # 全局平均池化(Fsq操作)
        self.gap = nn.AdaptiveAvgPool2d((1, 1))
        # 两个全连接层(Fex操作)
        self.fc = nn.Sequential(
            nn.Linear(inchannel, inchannel // ratio, bias=False),  # 从 c -> c/r
            nn.ReLU(),
            nn.Linear(inchannel // ratio, inchannel, bias=False),  # 从 c/r -> c
            nn.Sigmoid()
        )

    def forward(self, x):
            # 读取批数据图片数量及通道数
            b, c, h, w = x.size()
            # Fsq操作：经池化后输出b*c的矩阵
            y = self.gap(x).view(b, c)
            # Fex操作：经全连接层输出（b，c，1，1）矩阵
            y = self.fc(y).view(b, c, 1, 1)
            # Fscale操作：将得到的权重乘以原来的特征图x
            return x * y.expand_as(x)

# 卷积，在uent中卷积一般成对使用
class DoubleConv(nn.Sequential):
    # 输入通道数， 输出通道数， mid_channels为成对卷积中第一个卷积层的输出通道数
    def __init__(self, in_channels, out_channels, mid_channels=None):
        if mid_channels is None:
            mid_channels = out_channels
        super(DoubleConv, self).__init__(
            # 3*3卷积，填充为1，卷积之后输入输出的特征图大小一致
            nn.Conv2d(in_channels, mid_channels, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(mid_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True)
        )

# 下采样
class Down(nn.Sequential):
    def __init__(self, in_channels, out_channels):
        super(Down, self).__init__(
            # 1.最大池化的窗口大小为2， 步长为2
            nn.MaxPool2d(2, stride=2),
            # 2.两个卷积
            DoubleConv(in_channels, out_channels)
        )

# 上采样
class Up(nn.Module):
    # bilinear是否采用双线性插值
    def __init__(self, in_channels, out_channels, bilinear=True):
        super(Up, self).__init__()
        if bilinear:
            # 使用双线性插值上采样
            # 上采样率为2，双线性插值模式
            self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
            self.conv = DoubleConv(in_channels, out_channels, in_channels // 2)
        else:
            # 使用转置卷积上采样
            self.up = nn.ConvTranspose2d(in_channels, in_channels // 2, kernel_size=2, stride=2)
            self.conv = DoubleConv(in_channels, out_channels)

    def forward(self, x1: torch.Tensor, x2: torch.Tensor) -> torch.Tensor:
        x1 = self.up(x1)
        # [N, C, H, W]
        # 上采样之后的特征图与要拼接的特征图，高度方向的差值
        diff_y = x2.size()[2] - x1.size()[2]
        # 上采样之后的特征图与要拼接的特征图，宽度方向的差值
        diff_x = x2.size()[3] - x1.size()[3]

        # padding_left, padding_right, padding_top, padding_bottom
        # 1.填充差值
        x1 = F.pad(x1, [diff_x // 2, diff_x - diff_x // 2,
                        diff_y // 2, diff_y - diff_y // 2])

        # 2.拼接
        x = torch.cat([x2, x1], dim=1)
        # 3.卷积，两次卷积
        x = self.conv(x)
        return x

# 最后的1*1输出卷积
class OutConv(nn.Sequential):
    def __init__(self, in_channels, num_classes):
        super(OutConv, self).__init__(
            nn.Conv2d(in_channels, num_classes, kernel_size=1)
        )


class UNet(nn.Module):
    # 参数: 输入通道数， 分割任务个数， 是否使用双线插值， 网络中第一个卷积通道个数
    def __init__(self,
                 in_channels: int = 1,
                 num_classes: int = 2,
                 bilinear: bool = True,
                 base_c: int = 64):
        super(UNet, self).__init__()
        self.in_channels = in_channels
        self.num_classes = num_classes
        self.bilinear = bilinear

        self.in_conv = DoubleConv(in_channels, base_c)


        # 下采样，参数:输入通道,输出通道
        self.down1 = Down(base_c, base_c * 2)
        self.down2 = Down(base_c * 2, base_c * 4)
        self.down3 = Down(base_c * 4, base_c * 8)


        # 如果采用双线插值上采样为 2，采用转置矩阵上采样为 1
        factor = 2 if bilinear else 1
        # 最后一个下采样，如果是双线插值则输出通道为512，否则为1024
        self.down4 = Down(base_c * 8, base_c * 16 // factor)


        # 上采样，参数:输入通道,输出通道
        self.up1 = Up(base_c * 16, base_c * 8 // factor, bilinear)
        self.up2 = Up(base_c * 8, base_c * 4 // factor, bilinear)
        self.up3 = Up(base_c * 4, base_c * 2 // factor, bilinear)
        self.up4 = Up(base_c * 2, base_c, bilinear)
        # 最后的1*1输出卷积
        self.out_conv = OutConv(base_c, num_classes)

        # SE模块
        self.SE1 = SE_Block(base_c * 16 // factor)
        self.SE2 = SE_Block(base_c * 8 // factor)
        self.SE3 = SE_Block(base_c * 4 // factor)
        self.SE4 = SE_Block(base_c * 2 // factor)

    # 正向传播过程
    def forward(self, x: torch.Tensor) -> Dict[str, torch.Tensor]:
        # 1. 定义最开始的两个卷积层
        x1 = self.in_conv(x)

        # 2. contracting path（收缩路径）
        x2 = self.down1(x1)
        x3 = self.down2(x2)

        x4 = self.down3(x3)

        x5 = self.down4(x4)
        x5 = self.SE1(x5)
        # 3. expanding path（扩展路径）
        x = self.up1(x5, x4)
        x = self.SE2(x)
        x = self.up2(x, x3)
        x = self.SE3(x)
        x = self.up3(x, x2)
        x = self.SE4(x)
        x = self.up4(x, x1)
        # 4. 最后1*1输出卷积
        logits = self.out_conv(x)

        return {"out": logits}

（3）在每两个卷积之后，加上SE模块

 

模型改动代码：

from typing import Dict
import torch
import torch.nn as nn
import torch.nn.functional as F

# se-unet03
'''-------------一、SE模块-----------------------------'''
#全局平均池化+1*1卷积核+ReLu+1*1卷积核+Sigmoid
class SE_Block(nn.Module):
    def __init__(self, inchannel, ratio=16):
        super(SE_Block, self).__init__()
        # 全局平均池化(Fsq操作)
        self.gap = nn.AdaptiveAvgPool2d((1, 1))
        # 两个全连接层(Fex操作)
        self.fc = nn.Sequential(
            nn.Linear(inchannel, inchannel // ratio, bias=False),  # 从 c -> c/r
            nn.ReLU(),
            nn.Linear(inchannel // ratio, inchannel, bias=False),  # 从 c/r -> c
            nn.Sigmoid()
        )

    def forward(self, x):
            # 读取批数据图片数量及通道数
            b, c, h, w = x.size()
            # Fsq操作：经池化后输出b*c的矩阵
            y = self.gap(x).view(b, c)
            # Fex操作：经全连接层输出（b，c，1，1）矩阵
            y = self.fc(y).view(b, c, 1, 1)
            # Fscale操作：将得到的权重乘以原来的特征图x
            return x * y.expand_as(x)

# 卷积，在uent中卷积一般成对使用
class DoubleConv(nn.Sequential):
    # 输入通道数， 输出通道数， mid_channels为成对卷积中第一个卷积层的输出通道数
    def __init__(self, in_channels, out_channels, mid_channels=None):
        if mid_channels is None:
            mid_channels = out_channels
        super(DoubleConv, self).__init__(
            # 3*3卷积，填充为1，卷积之后输入输出的特征图大小一致
            nn.Conv2d(in_channels, mid_channels, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(mid_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True)
        )

# 下采样
class Down(nn.Sequential):
    def __init__(self, in_channels, out_channels):
        super(Down, self).__init__(
            # 1.最大池化的窗口大小为2， 步长为2
            nn.MaxPool2d(2, stride=2),
            # 2.两个卷积
            DoubleConv(in_channels, out_channels)
        )

# 上采样
class Up(nn.Module):
    # bilinear是否采用双线性插值
    def __init__(self, in_channels, out_channels, bilinear=True):
        super(Up, self).__init__()
        if bilinear:
            # 使用双线性插值上采样
            # 上采样率为2，双线性插值模式
            self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
            self.conv = DoubleConv(in_channels, out_channels, in_channels // 2)
        else:
            # 使用转置卷积上采样
            self.up = nn.ConvTranspose2d(in_channels, in_channels // 2, kernel_size=2, stride=2)
            self.conv = DoubleConv(in_channels, out_channels)

    def forward(self, x1: torch.Tensor, x2: torch.Tensor) -> torch.Tensor:
        x1 = self.up(x1)
        # [N, C, H, W]
        # 上采样之后的特征图与要拼接的特征图，高度方向的差值
        diff_y = x2.size()[2] - x1.size()[2]
        # 上采样之后的特征图与要拼接的特征图，宽度方向的差值
        diff_x = x2.size()[3] - x1.size()[3]

        # padding_left, padding_right, padding_top, padding_bottom
        # 1.填充差值
        x1 = F.pad(x1, [diff_x // 2, diff_x - diff_x // 2,
                        diff_y // 2, diff_y - diff_y // 2])

        # 2.拼接
        x = torch.cat([x2, x1], dim=1)
        # 3.卷积，两次卷积
        x = self.conv(x)
        return x

# 最后的1*1输出卷积
class OutConv(nn.Sequential):
    def __init__(self, in_channels, num_classes):
        super(OutConv, self).__init__(
            nn.Conv2d(in_channels, num_classes, kernel_size=1)
        )


class UNet(nn.Module):
    # 参数: 输入通道数， 分割任务个数， 是否使用双线插值， 网络中第一个卷积通道个数
    def __init__(self,
                 in_channels: int = 1,
                 num_classes: int = 2,
                 bilinear: bool = True,
                 base_c: int = 64):
        super(UNet, self).__init__()
        self.in_channels = in_channels
        self.num_classes = num_classes
        self.bilinear = bilinear

        self.in_conv = DoubleConv(in_channels, base_c)


        # 下采样，参数:输入通道,输出通道
        self.down1 = Down(base_c, base_c * 2)
        self.down2 = Down(base_c * 2, base_c * 4)
        self.down3 = Down(base_c * 4, base_c * 8)


        # 如果采用双线插值上采样为 2，采用转置矩阵上采样为 1
        factor = 2 if bilinear else 1
        # 最后一个下采样，如果是双线插值则输出通道为512，否则为1024
        self.down4 = Down(base_c * 8, base_c * 16 // factor)


        # 上采样，参数:输入通道,输出通道
        self.up1 = Up(base_c * 16, base_c * 8 // factor, bilinear)
        self.up2 = Up(base_c * 8, base_c * 4 // factor, bilinear)
        self.up3 = Up(base_c * 4, base_c * 2 // factor, bilinear)
        self.up4 = Up(base_c * 2, base_c, bilinear)
        # 最后的1*1输出卷积
        self.out_conv = OutConv(base_c, num_classes)

        # SE模块
        self.SE1 = SE_Block(base_c)
        self.SE2 = SE_Block(base_c * 2)
        self.SE3 = SE_Block(base_c * 4)
        self.SE4 = SE_Block(base_c * 8)
        self.SE5 = SE_Block(base_c * 16 // factor)
        self.SE6 = SE_Block(base_c * 8 // factor)
        self.SE7 = SE_Block(base_c * 4 // factor)
        self.SE8 = SE_Block(base_c * 2 // factor)

    # 正向传播过程
    def forward(self, x: torch.Tensor) -> Dict[str, torch.Tensor]:
        # 1. 定义最开始的两个卷积层
        x1 = self.in_conv(x)
        x1 = self.SE1(x1)
        # 2. contracting path（收缩路径）
        x2 = self.down1(x1)
        x2 = self.SE2(x2)
        x3 = self.down2(x2)
        x3 = self.SE3(x3)
        x4 = self.down3(x3)
        x4 = self.SE4(x4)
        x5 = self.down4(x4)
        x5 = self.SE5(x5)
        # 3. expanding path（扩展路径）
        x = self.up1(x5, x4)
        x = self.SE6(x)
        x = self.up2(x, x3)
        x = self.SE7(x)
        x = self.up3(x, x2)
        x = self.SE8(x)
        x = self.up4(x, x1)
        # 4. 最后1*1输出卷积
        logits = self.out_conv(x)

        return {"out": logits}

（4）只在最后的输出卷积前，添加SE模块

 

 模型修改代码：

from typing import Dict
import torch
import torch.nn as nn
import torch.nn.functional as F

# se-unet04
'''-------------一、SE模块-----------------------------'''
#全局平均池化+1*1卷积核+ReLu+1*1卷积核+Sigmoid
class SE_Block(nn.Module):
    def __init__(self, inchannel, ratio=16):
        super(SE_Block, self).__init__()
        # 全局平均池化(Fsq操作)
        self.gap = nn.AdaptiveAvgPool2d((1, 1))
        # 两个全连接层(Fex操作)
        self.fc = nn.Sequential(
            nn.Linear(inchannel, inchannel // ratio, bias=False),  # 从 c -> c/r
            nn.ReLU(),
            nn.Linear(inchannel // ratio, inchannel, bias=False),  # 从 c/r -> c
            nn.Sigmoid()
        )

    def forward(self, x):
            # 读取批数据图片数量及通道数
            b, c, h, w = x.size()
            # Fsq操作：经池化后输出b*c的矩阵
            y = self.gap(x).view(b, c)
            # Fex操作：经全连接层输出（b，c，1，1）矩阵
            y = self.fc(y).view(b, c, 1, 1)
            # Fscale操作：将得到的权重乘以原来的特征图x
            return x * y.expand_as(x)

# 卷积，在uent中卷积一般成对使用
class DoubleConv(nn.Sequential):
    # 输入通道数， 输出通道数， mid_channels为成对卷积中第一个卷积层的输出通道数
    def __init__(self, in_channels, out_channels, mid_channels=None):
        if mid_channels is None:
            mid_channels = out_channels
        super(DoubleConv, self).__init__(
            # 3*3卷积，填充为1，卷积之后输入输出的特征图大小一致
            nn.Conv2d(in_channels, mid_channels, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(mid_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True)
        )

# 下采样
class Down(nn.Sequential):
    def __init__(self, in_channels, out_channels):
        super(Down, self).__init__(
            # 1.最大池化的窗口大小为2， 步长为2
            nn.MaxPool2d(2, stride=2),
            # 2.两个卷积
            DoubleConv(in_channels, out_channels)
        )

# 上采样
class Up(nn.Module):
    # bilinear是否采用双线性插值
    def __init__(self, in_channels, out_channels, bilinear=True):
        super(Up, self).__init__()
        if bilinear:
            # 使用双线性插值上采样
            # 上采样率为2，双线性插值模式
            self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
            self.conv = DoubleConv(in_channels, out_channels, in_channels // 2)
        else:
            # 使用转置卷积上采样
            self.up = nn.ConvTranspose2d(in_channels, in_channels // 2, kernel_size=2, stride=2)
            self.conv = DoubleConv(in_channels, out_channels)

    def forward(self, x1: torch.Tensor, x2: torch.Tensor) -> torch.Tensor:
        x1 = self.up(x1)
        # [N, C, H, W]
        # 上采样之后的特征图与要拼接的特征图，高度方向的差值
        diff_y = x2.size()[2] - x1.size()[2]
        # 上采样之后的特征图与要拼接的特征图，宽度方向的差值
        diff_x = x2.size()[3] - x1.size()[3]

        # padding_left, padding_right, padding_top, padding_bottom
        # 1.填充差值
        x1 = F.pad(x1, [diff_x // 2, diff_x - diff_x // 2,
                        diff_y // 2, diff_y - diff_y // 2])

        # 2.拼接
        x = torch.cat([x2, x1], dim=1)
        # 3.卷积，两次卷积
        x = self.conv(x)
        return x

# 最后的1*1输出卷积
class OutConv(nn.Sequential):
    def __init__(self, in_channels, num_classes):
        super(OutConv, self).__init__(
            nn.Conv2d(in_channels, num_classes, kernel_size=1)
        )


class UNet(nn.Module):
    # 参数: 输入通道数， 分割任务个数， 是否使用双线插值， 网络中第一个卷积通道个数
    def __init__(self,
                 in_channels: int = 1,
                 num_classes: int = 2,
                 bilinear: bool = True,
                 base_c: int = 64):
        super(UNet, self).__init__()
        self.in_channels = in_channels
        self.num_classes = num_classes
        self.bilinear = bilinear

        self.in_conv = DoubleConv(in_channels, base_c)


        # 下采样，参数:输入通道,输出通道
        self.down1 = Down(base_c, base_c * 2)
        self.down2 = Down(base_c * 2, base_c * 4)
        self.down3 = Down(base_c * 4, base_c * 8)


        # 如果采用双线插值上采样为 2，采用转置矩阵上采样为 1
        factor = 2 if bilinear else 1
        # 最后一个下采样，如果是双线插值则输出通道为512，否则为1024
        self.down4 = Down(base_c * 8, base_c * 16 // factor)


        # 上采样，参数:输入通道,输出通道
        self.up1 = Up(base_c * 16, base_c * 8 // factor, bilinear)
        self.up2 = Up(base_c * 8, base_c * 4 // factor, bilinear)
        self.up3 = Up(base_c * 4, base_c * 2 // factor, bilinear)
        self.up4 = Up(base_c * 2, base_c, bilinear)
        # 最后的1*1输出卷积
        self.out_conv = OutConv(base_c, num_classes)

        # SE模块
        self.SE4 = SE_Block(base_c)

    # 正向传播过程
    def forward(self, x: torch.Tensor) -> Dict[str, torch.Tensor]:
        # 1. 定义最开始的两个卷积层
        x1 = self.in_conv(x)

        # 2. contracting path（收缩路径）
        x2 = self.down1(x1)
        x3 = self.down2(x2)

        x4 = self.down3(x3)

        x5 = self.down4(x4)
        # 3. expanding path（扩展路径）
        x = self.up1(x5, x4)
        x = self.up2(x, x3)
        x = self.up3(x, x2)
        x = self.up4(x, x1)
        x = self.SE4(x)
        # 4. 最后1*1输出卷积
        logits = self.out_conv(x)


        return {"out": logits}

向岸看
关注
  • 8
    点赞
  • 踩
  • 85
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 14
    评论
U-Net网络模型改进（添加通道与空间注意力机制）---亲测有效，指标提升
weixin_42367888的博客
12-05 8031
U-Net网络模型改进（添加通道与空间注意力机制）---亲测有效，指标提升
结合创新！通道注意力+UNet，实现高精度分割
最新发布
学姐带你玩AI的博客
05-10 1430
具体点说是在U-Net的卷积层之后添加一个通道注意力模块，这样这个模块可以学习不同通道之间的权重，并根据这些权重对通道进行加权，从而增强重要通道的特征表示。这种对比传统模型，更能捕获图像中的关键信息，并，在面对新的、未见过的图像时也能保持较高的性能。这也是为什么它本文挑选了，可借鉴的方法和创新点做了简单提炼，原文和已开源的代码都整理了，方便同学们学习和复现。
unet各模块内容的理解（包含注意力机制、残差、以及数据维度的变化）
m0_52985451的博客
03-17 2582
对unet的各模块内容进行梳理，包括各模块的设计，以及数据流的整个处理流程，以及其维度的变化
基于强化空间注意力的视网膜网络（ESA-Unet)
m0_61356812的博客
07-19 3486
ESA-Unet
多模态融合的高分遥感图像语义分割方法
嗑研狗的日常
01-05 3945
多模态融合的高分遥感图像语义分割方法(python) 论文地址：http://www.cnki.com.cn/Article/CJFDTotal-ZNZK202004012.htm 1、SE-UNet 网络模型 2、SE-UNet的具体设计方案 3、SE-UNet的pytorch复现 import torch.nn as nn import torch.utils.model_zoo as model_zoo from torch.nn import functional as F import tor
SE
03-16
东南
随笔记录：关于SE模块插入位置的总结
tangshopping的博客
08-05 6201
SE模块的插入位置探讨
“SAR-U-Net: Squeeze-and-excitation block and atrous spatial pyramidpooling based residual U-Net”
weixin_43944009的博客
03-24 283
本文仅对所读论文进行总结仅供参考，原文请谷歌学术搜索。
SE模块的理解
weixin_47032489的博客
03-08 2768
之前对SE模块的两个全连接层的作用和设置有疑问，于是和实验室同学讨论学习了一下，以下是我自己的理解，如果有不准确的地方请批评指正。 1、压缩（Squeeze） 进行的操作是 全局平均池化（global average pooling） 特征图被压缩为1×1×C向量 2、激励（Excitation） 两个全连接层。 两个FC组成一个可训练的函数，用来学习通道注意力。（所以FC激活函数不是线性的就行） 两个FC构成了bottleneck结构：（SERatio是一个缩放参数） 第一个FC把神经元数量减少了 1.
尝试在UNet添加SK模块和CBAM模块
qq_45981086的博客
05-28 4339
尝试在UNet添加SK模块和CBAM模块
基于resnet+unet的皮肤病变分割
02-25
该工程使用resnet50/101+hypercolumn+scse+unet算法实现对皮肤病变的分割
Unity5网络模块UNet介绍.docx
01-09
Unity5 网络模块 UNet 介绍 UNet 是 Unity 5 中的网络模块，提供了一个基于客户端-服务器架构的网络解决方案。以下是 UNet 的重要概念和组件介绍： 1. Spawn：Spawn 是一种网络动作，服务器上有一个 GameObject，...
yolo，unet在C#上的部署
04-26
【标题】：“yolo，unet在C#上的部署”涉及到的是在C#编程环境中集成并运行两种深度学习模型——YOLO（You Only Look Once）和U-Net。YOLO是一种实时目标检测系统，而U-Net则常用于图像分割任务。 【YOLO】：YOLO，...
Unet实现对数据集进行图片重建和去噪
03-28
Image_denoising_using_UNET 本教程包括使用Unet架构的图像去噪技术。...在训练模型后，我发现当将干净图像与带噪图像和预测图像进行比较时，PSNR和SSIM值略有增加。 在代码中，您还可以看到干净和预测图像的MSE。
Unet训练和部署代码
08-06
Unet是一种深度学习模型，最初在图像分割领域得到广泛应用，特别是在医学影像分析中，用于识别和分割出感兴趣的区域。这个“Unet训练和libtorch部署代码”资源包含了一个完整的流程，从模型训练到使用libtorch...
UNet语义分割实战：使用UNet实现对人物的抠图.zip
04-06
今天这篇文章讲解如何使用UNet实现图像的二分类分割。 关于二分类一般有两种做法： 第一种输出是单通道，即网络的输出 output 为 [batch_size, 1, height, width] 形状。其中 batch_szie 为批量大小，1 表示输出一...
SE-ResUNet论文解读
lianghe77的博客
01-14 6644
《Deep Learning Prediction of Incoming Rainfalls：An Operational Service for the City of Beijing China》论文解读 这是一篇通过扩展FCN结构来预测降水的文章。文章提出的服务主要运用于北京区域。它能对未来两小时内的降水进行预测，时间和空间分辨率分别为1km和6分钟。该神经网络模型结合了已知的U-Net，ResNet，Sqeeze-and-Excitation和注意力机制模块。这种方法得到的结果要好于传统方法，且
YOLOv5中添加SE模块详解——原理+代码
python_plus的博客
03-10 6452
本文详细讲解了SENet的原理，并提供了将SENet加入YOLOv5的代码
unet添加注意力机制代码位置
03-28
在UNet模型中添加注意力机制的代码通常放在模型的构建部分。具体来说，可以在UNet的编码器和解码器之间添加注意力模块，以便在特定部分增强模型的分割性能。 以下是一个示例代码片段，其中添加了注意力机制： ``` import torch import torch.nn as nn class Attention(nn.Module): def __init__(self, in_channels): super(Attention, self).__init__() self.conv = nn.Conv2d(in_channels=in_channels, out_channels=1, kernel_size=1) self.sigmoid = nn.Sigmoid() def forward(self, x): x = self.conv(x) x = self.sigmoid(x) return x class UNet(nn.Module): def __init__(self, in_channels=3, out_channels=1, features=[64, 128, 256, 512]): super(UNet, self).__init__() self.encoder = nn.ModuleList() self.decoder = nn.ModuleList() self.pool = nn.MaxPool2d(kernel_size=2, stride=2) # Encoder for feature in features: self.encoder.append( nn.Sequential( nn.Conv2d(in_channels, feature, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(feature, feature, kernel_size=3, padding=1), nn.ReLU(inplace=True) ) ) in_channels = feature # Attention self.attention = Attention(features[-1]) # Decoder for feature in reversed(features): self.decoder.append( nn.Sequential( nn.Conv2d(feature*2, feature, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(feature, feature, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.ConvTranspose2d(feature, feature//2, kernel_size=2, stride=2), ) ) self.decoder.append( nn.Sequential( nn.Conv2d(feature, feature//2, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(feature//2, feature//2, kernel_size=3, padding=1), nn.ReLU(inplace=True), ) ) feature //= 2 # Output self.output = nn.Conv2d(64, out_channels, kernel_size=1) def forward(self, x): skip_connections = [] # Encoder for encoder in self.encoder: x = encoder(x) skip_connections.append(x) x = self.pool(x) # Attention x = self.attention(x) # Decoder for i in range(0, len(self.decoder), 2): decoder = self.decoder[i] skip_connection = skip_connections[-(i//2+2)] x = decoder(x) x = torch.cat([x, skip_connection], dim=1) x = self.decoder[i+1](x) # Output x = self.output(x) return x ``` 在这个例子中，注意力模块被添加到UNet模型的最后一个编码器之后。具体来说，我们定义了一个名为Attention的新模块，并在UNet的初始化函数中创建了一个实例。在前向传递中，我们将编码器输出传递给Attention模块，并将其输出乘以编码器的最终输出。这样，注意力机制可以集中模型的注意力在最相关的特征图上，从而提高分割性能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

向岸看

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值