一、网络结构

（图源来自网络）

这个结构的思想其实就是先对图像进行卷积+池化，进行特征提取，也就是U型的左半部分，然后对图像拼接+上采样，进行特征融合。?

（一）左半部分（特征提取部分）

两个3x3的卷积层（ReLU）+ 一个2x2的maxpooling层构成一个下采样的模块，由下采样模块反复组成。每经过一次下采样，通道数翻倍。论文中用的是valid卷积（当filter全部在image里面的时候才开始进行卷积运算），因此每做一次valid卷积，由于没有padding，feature map的height和width会分别减少3-1=2个像素。

（二）右半部分（特征融合部分）

一个2x2的上采样卷积层（ReLU）+Concatenation（先crop对应左半部分输出的feature map然后与右半部分上采样结果相加）+2个3x3的卷积层（ReLU）反复构成，最后一层通过一个1x1卷积将通道数变成期望的类别数（论文中的channel2分别为前景和背景的mask，医学中就是细胞区域和黑色背景区域）。每一次上采样转置卷积之后，height和width都加倍，同时channel减半，用于和左侧的浅层feature map进行合并拼接。Unet相比更早提出的FCN网络，使用通道拼接来作为特征图的融合方式。主要好处是，浅层卷积关注纹理特征，深层网络关注更深更本质的特征，将浅层网络提取的特征和深层网络提取的特征融合可以使得特征“厚且广”，还有一个原因我认为是下采样操作会导致高频信息丢失，从而导致边缘的特征丢失，而上采样虽然能够获得更大的特征图，但是并不能对进行过下采样的特征图进行恢复，因此是缺少信息的，通过这种特征拼接多少可以找回一些丢失的边缘信息。

（三）代码实现

import torch
import torch.nn as nn
import torch.nn.functional as F

class double_conv2d_bn(nn.Module):
    def __init__(self,in_channels,out_channels,kernel_size=3,strides=1,padding=1):
        super(double_conv2d_bn,self).__init__()
        self.conv1 = nn.Conv2d(in_channels,out_channels,kernel_size=kernel_size,
                                stride = strides,padding = padding ,bias =True)
        self.conv2 = nn.Conv2d(out_channels,out_channels,kernel_size = kernel_size,
                                stride = strides,padding = padding, bias = True)

        self.bn1 = nn.BatchNorm2d(out_channels)
        self.bn2 = nn.BatchNorm2d(out_channels)

    def forward(self,x):
        out = F.relu(self.bn1(self.conv1(x)))
        out = F.relu(self.bn2(self.conv2(out)))
        return out

class deconv2d_bn(nn.Module):
    def __init__(self,in_channels,out_channels,kernel_size=2,strides=2):
        super(deconv2d_bn,self).__init__()
        self.conv1 = nn.ConvTranspose2d(in_channels,out_channels,
                                        kernel_size= kernel_size,
                                        stride = strides,bias = True)
        self.bn1 = nn.BatchNorm2d(out_channels)

    def forward(self,x):
        out = F.relu(self.bn1(self.conv1(x)))
        return out

class Unet(nn.Module):
    def __init__(self):
        super(Unet,self).__init__()
        self.layer1_conv = double_conv2d_bn(1,8)
        self.layer2_conv = double_conv2d_bn(8,16)
        self.layer3_conv = double_conv2d_bn(16,32)
        self.layer4_conv = double_conv2d_bn(32,64)
        self.layer5_conv = double_conv2d_bn(64,128)
        self.layer6_conv = double_conv2d_bn(128,64)
        self.layer7_conv = double_conv2d_bn(64,32)
        self.layer8_conv = double_conv2d_bn(32,16)
        self.layer9_conv = double_conv2d_bn(16,8)
        self.layer10_conv = nn.Conv2d(8,1,kernel_size=3,
                                        stride = 1,padding =1,bias = True)
        
        self.deconv1 = deconv2d_bn(128,64)
        self.deconv2 = deconv2d_bn(64,32)
        self.deconv3 = deconv2d_bn(32,16)
        self.deconv4 = deconv2d_bn(16,8)

        self.sigmoid = nn.Sigmoid()

    def forward(self,x):
        #print(x.shape) [10, 1, 224, 224]
        conv1 = self.layer1_conv(x)
        print(conv1.shape)
        pool1 = F.max_pool2d(conv1,2)

        conv2 = self.layer2_conv(pool1)
        pool2 = F.max_pool2d(conv2,2)

        conv3 = self.layer3_conv(pool2)
        pool3 = F.max_pool2d(conv3,2)

        conv4 = self.layer4_conv(pool3)
        pool4 = F.max_pool2d(conv4,2)

        conv5 = self.layer5_conv(pool4)
        #print(conv5.shape) ([10, 128, 14, 14])
        convt1 = self.deconv1(conv5)
        concat1 = torch.cat([convt1,conv4],dim=1)
        conv6 = self.layer6_conv(concat1)

        convt2 = self.deconv2(conv6)
        concat2 = torch.cat([convt2,conv3],dim=1)
        conv7 = self.layer7_conv(concat2)

        convt3 = self.deconv3(conv7)
        concat3 = torch.cat([convt3,conv2],dim=1)
        conv8 = self.layer8_conv(concat3)

        convt4 = self.deconv4(conv8)
        concat4 = torch.cat([convt4,conv1],dim=1)
        conv9 = self.layer9_conv(concat4)
        outp = self.layer10_conv(conv9)
        outp = self.sigmoid(outp)

        return outp

model = Unet()
inp = torch.rand(10,1,224,224)
outp = model(inp)

（二）重叠平铺策略

该策略的思想是：对图像的某一块像素点（黄框内）进行预测时，需要该图像块周围的像素点（细蓝色框内）提供上下文信息，以获得更准确的预测。但是图像边界的图像块（黄色框内）没有周围像素，因此作者对周围像素采用了镜像扩充（比如粗蓝色框内的图像可以看出来是经过白线镜像对称得到的）。这样，边界图像块也能得到准确的预测。