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

已于 2023-05-28 17:34:59 修改
阅读量3.8k 收藏 86
点赞数 9
文章标签： 深度学习 神经网络 人工智能
于 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}

向岸看
关注
  • 9
    点赞
  • 踩
  • 86
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 14
    评论
Unity5网络模块UNet介绍.docx
01-09
Unity5 网络模块 UNet 介绍 UNet 是 Unity 5 中的网络模块，提供了一个基于客户端-服务器架构的网络解决方案。以下是 UNet 的重要概念和组件介绍： 1. Spawn：Spawn 是一种网络动作，服务器上有一个 GameObject，...
U-Net网络模型改进（添加通道与空间注意力机制）---亲测有效，指标提升
weixin_42367888的博客
12-05 8263
U-Net网络模型改进（添加通道与空间注意力机制）---亲测有效，指标提升
结合创新！通道注意力+UNet，实现高精度分割
最新发布
学姐带你玩AI的博客
05-10 1473
具体点说是在U-Net的卷积层之后添加一个通道注意力模块，这样这个模块可以学习不同通道之间的权重，并根据这些权重对通道进行加权，从而增强重要通道的特征表示。这种对比传统模型，更能捕获图像中的关键信息，并，在面对新的、未见过的图像时也能保持较高的性能。这也是为什么它本文挑选了，可借鉴的方法和创新点做了简单提炼，原文和已开源的代码都整理了，方便同学们学习和复现。
unet各模块内容的理解（包含注意力机制、残差、以及数据维度的变化）
m0_52985451的博客
03-17 2659
对unet的各模块内容进行梳理，包括各模块的设计，以及数据流的整个处理流程，以及其维度的变化
多模态融合的高分遥感图像语义分割方法
嗑研狗的日常
01-05 3956
多模态融合的高分遥感图像语义分割方法(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模块的理解
weixin_47032489的博客
03-08 2770
之前对SE模块的两个全连接层的作用和设置有疑问，于是和实验室同学讨论学习了一下，以下是我自己的理解，如果有不准确的地方请批评指正。 1、压缩（Squeeze） 进行的操作是 全局平均池化（global average pooling） 特征图被压缩为1×1×C向量 2、激励（Excitation） 两个全连接层。 两个FC组成一个可训练的函数，用来学习通道注意力。（所以FC激活函数不是线性的就行） 两个FC构成了bottleneck结构：（SERatio是一个缩放参数） 第一个FC把神经元数量减少了 1.
“SAR-U-Net: Squeeze-and-excitation block and atrous spatial pyramidpooling based residual U-Net”
weixin_43944009的博客
03-24 285
本文仅对所读论文进行总结仅供参考，原文请谷歌学术搜索。
16、佛罗里达理工学院提出：seUNet:自动化医学图像分割领域极致的个人英雄主义
mantoudamahou的博客
12-12 1359
论文由美国佛罗里达理工学院三位学生于2023年11月10日，在arXiv的《Electrical Engineering and Systems Science》期刊中发表。三位作者鉴于自动化医学图像分割诊断对现代临床医学的实践变得愈发的重要，也鉴于目前机器学习算法的进步，共同提出seUNet：一种简单而有效的医学图像分割UNet-Transformer模型。
随笔记录：关于SE模块插入位置的总结
tangshopping的博客
08-05 6254
SE模块的插入位置探讨
尝试在UNet添加SK模块和CBAM模块
qq_45981086的博客
05-28 4413
尝试在UNet添加SK模块和CBAM模块
PyTorch-SE-Segmentation
05-08
PyTorch中带有SE块的语义分割 这是我们正在进行的PyTorch实施，用于 我们提出的方法和基准网络的结果。 （a）b1000图像（b）ADC映射（c）DenseNet（d）SE-DenseNet（e）UNet（f）SE-UNet（g）地面真相。 我们在原始激励操作中用1x1卷积层替换了完全连接的层，并观察到16的激励衰减比更好。 您可以参考 先决条件 2.7 > = 0.2.0 数据集 您必须为数据集构造合适的数据加载器。 例如，我们为以下数据结构生成数据加载器。 数据| --- ADC |---train |---val |---test |---b1000 |---train |---val |---test |---mask |---train
yolo，unet在C#上的部署
04-26
【标题】：“yolo，unet在C#上的部署”涉及到的是在C#编程环境中集成并运行两种深度学习模型——YOLO（You Only Look Once）和U-Net。YOLO是一种实时目标检测系统，而U-Net则常用于图像分割任务。 【YOLO】：YOLO，...
Unet训练和部署代码
08-06
Unet是一种深度学习模型，最初在图像分割领域得到广泛应用，特别是在医学影像分析中，用于识别和分割出感兴趣的区域。这个“Unet训练和libtorch部署代码”资源包含了一个完整的流程，从模型训练到使用libtorch...
Unet实现对数据集进行图片重建和去噪
03-28
Image_denoising_using_UNET 本教程包括使用Unet架构的图像去噪技术。...在训练模型后，我发现当将干净图像与带噪图像和预测图像进行比较时，PSNR和SSIM值略有增加。 在代码中，您还可以看到干净和预测图像的MSE。
UNet语义分割实战：使用UNet实现对人物的抠图.zip
04-06
今天这篇文章讲解如何使用UNet实现图像的二分类分割。 关于二分类一般有两种做法： 第一种输出是单通道，即网络的输出 output 为 [batch_size, 1, height, width] 形状。其中 batch_szie 为批量大小，1 表示输出一...
【图像分割】Unet系列深度讲解（FCN、UNET、UNET++）
Danger的博客
03-20 5875
【图像分割】Unet系列深度讲解（FCN、UNET、UNET++）
基于强化空间注意力的视网膜网络（ESA-Unet)
m0_61356812的博客
07-19 3504
ESA-Unet
Unet系列+Resnet模型（Pytorch)
热门推荐
weixin_54255111的博客
07-05 1万+
Resnet+Unet系列
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、付费专栏及课程。

余额充值