论文学习——U-Net: Convolutional Networks for Biomedical Image Segmentation

UNet的特点

  • 采用端到端的结构,通过FCN(最后一层仍然是通过卷积完成),最后输出图像。
  • 通过编码(下采样)-解码(上采样)形成一个“U”型结构。每次下采样时,先进行两次卷积(通道数不变),然后通过一次池化层(也可以通过卷积)处理(长宽减半,通道数加倍);在每次上采样时,同样先进行两次卷积操作,再通过反卷积函数进行上采样(长宽加倍,通道不变),然后与编码过程中对应层进行拼接(通道加倍)。到最后一层时,通过1x1的卷积核修改通道数,最后输出目标图像。编码操作逐层提取图像特征,解码操作则逐层恢复图像信息。
  • 通过跳跃连接,将编码器结构中的底层信息与解码器结构中的高层信息融合,从而提高了分割精度。

网络结构如图所示:
在这里插入图片描述
代码实现(基于pytorch):
相关包的引入:

from math import sqrt
import torch
from torch import nn
import torch.nn.functional as F

定义卷积块:
定义了两个卷积操作,分别使用大小为3x3的卷积核进行卷积,步长为1,并且对卷积后的输出进行批量归一化(批量归一化的作用),激活函数采用ReLU。使用卷积模块时,需要指明输入通道数(in_channel)和输出通道数(out_channel)。

class Conv_Block(nn.Module):
    def __init__(self, in_channel, out_channel):
        super(Conv_Block, self).__init__()
        self.conv1 = nn.Sequential(
            nn.Conv2d(in_channel, out_channel, 3, 1, 1),
            nn.BatchNorm2d(out_channel),
            nn.ReLU(inplace=True)
        )
        self.conv2 = nn.Sequential(
            nn.Conv2d(out_channel, out_channel, 3, 1, 1),
            nn.BatchNorm2d(out_channel),
            nn.ReLU(inplace=True)
        )

    def forward(self, input):
        outputs = self.conv1(input)
        outputs = self.conv2(outputs)
        return outputs

编码操作(下采样):将卷积模块的输出进行池化处理。

class UnetDown(nn.Module):
    def __init__(self, in_channel, out_channel):
        super(UnetDown, self).__init__()
        self.conv = Conv_Block(in_channel, out_channel)
        self.down = nn.MaxPool2d(2, 2, ceil_mode=True)

    def forward(self, inputs):
        outputs = self.conv(inputs)
        outputs = self.down(outputs)
        return outputs

解码操作(上采样):这里的上采样操作提出了两种——ConvTranspose2d和UpsamplingBilinear2d,两者的区别见这里。另外,由于要进行拼接操作,所以在拼接前对上采样的输出进行填充,避免拼接出错。
(ps:代码里面的解码操作是先进行上采样,然后拼接数据,最后进行卷积的,但是在UnetModel中的最后一个编码操作后,单独进行了一次卷积操作,最后的网络结构还是没有变的。)

class UnetUp(nn.Module):
    def __init__(self, in_channel, out_channel, is_deconv=True):
        super(UnetUp, self).__init__()
        self.conv = Conv_Block(in_channel, out_channel)

        if is_deconv:
            self.up = nn.ConvTranspose2d(in_channel, out_channel, kernel_size=2, stride=2)
        else:
            self.up = nn.UpsamplingBilinear2d(scale_factor=2)

    def forward(self, inputs1, inputs2):
        outputs2 = self.up(inputs2)
        offset1 = (outputs2.size()[2] - inputs1.size()[2])
        offset2 = (outputs2.size()[3] - inputs1.size()[3])
        # pad传入四个元素时,指的是左填充,右填充,上填充,下填充;前两个元素作用在第一四维,后两个元素作用在第三维
        padding = [offset2 // 2, (offset2 + 1) // 2, offset1 // 2, (offset1 + 1) // 2]
        # Skip and concatenate
        outputs1 = F.pad(inputs1, padding)
        return self.conv(torch.cat([outputs1, outputs2], 1))

最后定义整个UNet模块:将代码和网络结构的图结合起来看就很容易理解了。

class UnetModel(nn.Module):
    def __init__(self, n_classes, in_channels, is_deconv):
        super(UnetModel, self).__init__()
        self.is_deconv = is_deconv
        self.in_channels = in_channels
        self.n_classes = n_classes

        filters = [64, 128, 256, 512, 1024]

        self.down1 = UnetDown(self.in_channels, filters[0])
        self.down2 = UnetDown(filters[0], filters[1])
        self.down3 = UnetDown(filters[1], filters[2])
        self.down4 = UnetDown(filters[2], filters[3])
        self.center = Conv_Block(filters[3], filters[4])
        self.up4 = UnetUp(filters[4], filters[3], self.is_deconv)
        self.up3 = UnetUp(filters[3], filters[2], self.is_deconv)
        self.up2 = UnetUp(filters[2], filters[1], self.is_deconv)
        self.up1 = UnetUp(filters[1], filters[0], self.is_deconv)
        self.final = nn.Conv2d(filters[0], self.n_classes, 1)

    def forward(self, inputs, label_dsp_dim):
        down1 = self.down1(inputs)
        down2 = self.down2(down1)
        down3 = self.down3(down2)
        down4 = self.down4(down3)
        center = self.center(down4)
        up4 = self.up1(down4, center)
        up3 = self.up2(down3, up4)
        up2 = self.up3(down2, up3)
        up1 = self.up4(down1, up2)
        up1 = up1[:, :, 1:1 + label_dsp_dim[0], 1:1 + label_dsp_dim[1]].contiguous()
        return self.final(up1)

    # Initialization of parameters
    def _initialize_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
                m.weight.data.normal_(0, sqrt(2. / n))
                if m.bias is not None:
                    m.bias.data.zero_()
            elif isinstance(m, nn.BatchNorm2d):
                m.weight.data.fill_(1)
                m.bias.data.zero_()
            elif isinstance(m, nn.ConvTranspose2d):
                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
                m.weight.data.normal_(0, sqrt(2. / n))
                if m.bias is not None:
                    m.bias.data.zero_()

总结:UNet 是一种经典的图像分割网络,它通过编码器-解码器结构、跳跃连接和多尺度特征融合等设计,能够在图像分割任务中取得优秀的性能。基于UNet还衍生出了很多网络,例如 U-Net++, ResUNet, Dense U-Net等,接下来就学习它的衍生网络吧,学习大佬是怎么魔改网络的~另外,刚开始写深度学习的代码时,我不知道从何下手,通过学习大佬实现代码的过程,我发现结合两点就能轻松实现代码:1)写代码时结合网络结构的图片,2)百度相关操作的函数。

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值