U-Net论文笔记

U-Net论文精读

1 前人工作

• 卷积神经网络的流行
• 现阶段的卷积只用于分类功能，然而在生物学图像处理中，我们需要位置信息，将分类标签关联到每一个像素

​ 这个网络的上下文使用以及定位准确性之间存在着权衡问题。较大的补丁时需要较大的Pool,这使得定位准确率下降，而较小的补丁又会使得网络的上下文联系减弱。

2 网络结构

U-Net:

Contracting path + Expensive path

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-n3uTT5gE-1678623012325)(C:\Users\yufeixie\AppData\Roaming\Typora\typora-user-images\image-20230312172841213.png)]

U-Net：一种全卷积网络，修改了FCN的结构，采用连续的卷积进行下采样，池化算子用上采样替代，从而提高输出的分辨率，最后，将高解析特征和上采样的输出进行拼接，从而实现更精确的输出。

设定如下：

1. 网络上采样部分依然有大量的通道，从而允许网络将上下文信息传递到更高层的分辨率
2. 为了预测图像边界区域中的像素，通过镜像输入图像来推断缺失的上下文。这种平铺策略对于将网络应用于大图像很重要，否则分辨率会受到 GPU 内存的限制
3. 数据增强对学习不变性有帮助
4. 使用加权损失，使得网络在分离背景处获得更大的损失函数权重

训练策略:

• 采用随机梯度下降来训练网络
• 对于未填充的卷积，输出图像小于输入
• 使用高动量：0.09,使得先看到的训练样本决定当前的优化更新

3 创新点

Overlap-tile stategy:

为了能够预测到黄色框所示的位置，使用镜像来推断图像的上下文，这种平铺策略有助于对大图像的处理

weighted loss：

利用距离表示形态学边界信息权重，从而来平衡类别出现的频率：
$$w(x)=w_c(x)+w_0\ast exp(-\frac{(d_1(x)+d_1(x){)}^2}{2{\sigma }^2})$$
$d_1：表示最近的细胞边界，d_2：表示第二近的细胞边界$

4 代码实现

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

# 连续卷积，设置中间输出通道接口
class DoubleConv(nn.Sequential):
    def __init__(self, in_channels, out_channels, mid_channels=None):
        if mid_channels is None:
            mid_channels = out_channels
        super(DoubleConv, self).__init__(
            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)
        )

# 下采样：双线性插值或者转置卷积，如果是双线性插值，那么在进行上采样时就需要在原输入通道的基础上除以4
class Down(nn.Sequential):
    def __init__(self, in_channels, out_channels):
        super(Down, self).__init__(
            nn.MaxPool2d(2, stride=2),
            DoubleConv(in_channels, out_channels)
        )


class Up(nn.Module):
    def __init__(self, in_channels, out_channels, bilinear=True):
        super(Up, self).__init__()
        if bilinear:
            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]

        # 避免由于向下取整带来的特征图大小不匹配现象
        x1 = F.pad(x1, [diff_x // 2, diff_x - diff_x // 2,
                        diff_y // 2, diff_y - diff_y // 2])

        x = torch.cat([x2, x1], dim=1)
        x = self.conv(x)
        return x


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)
        factor = 2 if bilinear else 1
        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)
        self.out_conv = OutConv(base_c, num_classes)

    def forward(self, x: torch.Tensor) -> Dict[str, torch.Tensor]:
        x1 = self.in_conv(x)
        x2 = self.down1(x1)
        x3 = self.down2(x2)
        x4 = self.down3(x3)
        x5 = self.down4(x4)
        x = self.up1(x5, x4)
        x = self.up2(x, x3)
        x = self.up3(x, x2)
        x = self.up4(x, x1)
        logits = self.out_conv(x)

        return {"out": logits}

5 总结

U-Net 架构在非常不同的生物医学分割应用中取得了良好的性能。由于数据增强算法的使用，使得很少数据的图像就可以实现较好的分割效果。