devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

UNet++学习/实现笔记

作者：你好赵伟 | 2024-06-26 22:21:39

赞

踩

unet++

原理：

UNet++解读 + 它是如何对UNet改进 + 作者的研究态度和方式 - 知乎 (zhihu.com)

实现方法有两种：

①跳跃连接改为直接连接

②深度监督方式对于每个子网络输出端加一个1x1的卷积核，相当于监督了每个子网络

Keras实现

语义分割（三）Unet++_unet++网络结构-CSDN博客

拿L2子网络作为例子解释一下结构：

  1.     ## l2
  2.     pool10_20 = MaxPool2D(pool_size=(2, 2))(conv1_0)
  3.     conv2_0 = conv_drop(inputs=pool10_20, filters=filters[2])
  4.     up20_11 = upsampling(inputs=conv2_0, filters=filters[1])
  5.     concat2_1 = concatenate([up20_11, conv1_0], axis=3)
  6.     conv1_1 = conv_drop(inputs=concat2_1, filters=filters[1])
  7.     up11_02 = upsampling(inputs=conv1_1, filters=filters[0])
  8.     concat2_2 = concatenate([up11_02, conv0_0, conv0_1], axis=3)
  9.     conv0_2 = conv_drop(inputs=concat2_2, filters=filters[0])

 pool10_20 为从 x1,0 到 x2,0 的池化结果， 再对池化结果进行卷积得到 x2, 0的卷积结果 conv2_0

 

将 x2,0 的卷积结果 上采样得到 x2,0 到 x1,1 的上采样结果 up20_11，并连接 conv1_0 ，再对连接后的结果进行一次卷积得到conv1_1的结果

同理可得conv0_2的结果

总结起来是：

每一步下采样为先池化后卷积。

每一步上采样为 左下角结构的反卷积 连接 正左所有结构的卷积，将连接结果再做一次卷积。

总代码： 

  1. ###########################
  2. # Unet++ loss              #
  3. ###########################
  4. from keras import *
  5. from keras.src.layers import Conv2D, UpSampling2D, concatenate, Reshape, Activation
  6. from keras.src.losses import binary_crossentropy
  7. from keras.src.optimizers import Adam
  8. from tensorflow.python.keras.layers import MaxPool2D
  9.  
  10. ############################
  11. # Dice系数，用于评估图像分割任务中预测结果和真实标签之间的相似度指标
  12. ############################
  13. def dice_coef(y_true, y_pred):
  14.     smooth = 1. # 平滑项，避免分母为零
  15.     y_true_f = K.flatten(y_true)
  16.     y_pred_f = K.flatten(y_pred)
  17.     intersection = K.sum(y_true_f * y_pred_f) # 表示预测结果和真实标签的交集（即正确预测的正样本）
  18.     return (2. * intersection + smooth) / (K.sum(y_true_f) + K.sum(y_pred_f) + smooth)
  19.  
  20. # 二进制交叉熵损失和Dice系数之间的线性组合
  21. def bce_dice_loss(y_true, y_pred):
  22.     return 0.5 * binary_crossentropy(y_true, y_pred) - dice_coef(y_true, y_pred)
  23.     # return 0.5 * categorical_crossentropy(y_true, y_pred) - dice_coef(y_true, y_pred)
  24.  
  25.  
  26. #############################
  27. # Unet++ conv and upsampling #
  28. #############################
  29. # 下采样：两个3x3卷积
  30. def conv_drop(inputs, filters):
  31.     conv1 = Conv2D(filters=filters, kernel_size=3, padding='same', activation='relu',
  32.                    kernel_initializer='he_normal')(inputs)
  33.     # drop1 = Dropout(rate=0.5)(conv1)
  34.     conv2 = Conv2D(filters=filters, kernel_size=3, padding='same', activation='relu',
  35.                    kernel_initializer='he_normal')(conv1)
  36.     # drop2 = Dropout(rate=0.5)(conv2)
  37.     return conv2
  38.  
  39. # 上采样：进行2倍上采样，然后进行一个2x2的卷积
  40. def upsampling(inputs, filters):
  41.     up = UpSampling2D(size=(2, 2))(inputs)
  42.     conv = Conv2D(filters=filters, kernel_size=2, activation='relu', padding='same',
  43.                   kernel_initializer='he_normal')(up)
  44.     return conv
  45.  
  46.  
  47. ###############################
  48. # Unet++                      #
  49. ###############################
  50. def Unet_plusplus(input_size=(224, 224, 1), n_class=2, filters=(32, 64, 128, 256, 512), re_shape=False):
  51.     inputs = Input(shape=input_size)
  52.     ## l1
  53.     conv0_0 = conv_drop(inputs=inputs, filters=filters[0])
  54.     pool00_10 = MaxPool2D(pool_size=(2, 2))(conv0_0)
  55.     conv1_0 = conv_drop(inputs=pool00_10, filters=filters[1])
  56.     up10_01 = upsampling(inputs=conv1_0, filters=filters[0])
  57.     concat1_1 = concatenate([up10_01, conv0_0], axis=3)
  58.     conv0_1 = conv_drop(inputs=concat1_1, filters=filters[0])
  59.     ## l2
  60.     pool10_20 = MaxPool2D(pool_size=(2, 2))(conv1_0)
  61.     conv2_0 = conv_drop(inputs=pool10_20, filters=filters[2])
  62.     up20_11 = upsampling(inputs=conv2_0, filters=filters[1])
  63.     concat2_1 = concatenate([up20_11, conv1_0], axis=3)
  64.     conv1_1 = conv_drop(inputs=concat2_1, filters=filters[1])
  65.     up11_02 = upsampling(inputs=conv1_1, filters=filters[0])
  66.     concat2_2 = concatenate([up11_02, conv0_0, conv0_1], axis=3)
  67.     conv0_2 = conv_drop(inputs=concat2_2, filters=filters[0])
  68.     ##l3
  69.     pool20_30 = MaxPool2D(pool_size=(2, 2))(conv2_0)
  70.     conv3_0 = conv_drop(inputs=pool20_30, filters=filters[3])
  71.     up30_21 = upsampling(inputs=conv3_0, filters=filters[2])
  72.     concat3_1 = concatenate([up30_21, conv2_0], axis=3)
  73.     conv2_1 = conv_drop(inputs=concat3_1, filters=filters[2])
  74.     up21_12 = upsampling(inputs=conv2_1, filters=filters[1])
  75.     concat3_2 = concatenate([up21_12, conv1_0, conv1_1], axis=3)
  76.     conv1_2 = conv_drop(inputs=concat3_2, filters=filters[1])
  77.     up12_03 = upsampling(inputs=conv1_2, filters=filters[0])
  78.     concat3_3 = concatenate([up12_03, conv0_0, conv0_1, conv0_2], axis=3)
  79.     conv0_3 = conv_drop(inputs=concat3_3, filters=filters[0])
  80.     ## l4
  81.     pool30_40 = MaxPool2D(pool_size=(2, 2))(conv3_0)
  82.     conv4_0 = conv_drop(inputs=pool30_40, filters=filters[4])
  83.     up40_31 = upsampling(inputs=conv4_0, filters=filters[3])
  84.     concat4_1 = concatenate([up40_31, conv3_0], axis=3)
  85.     conv3_1 = conv_drop(inputs=concat4_1, filters=filters[3])
  86.     up31_22 = upsampling(inputs=conv3_1, filters=filters[2])
  87.     concat4_2 = concatenate([up31_22, conv2_0, conv2_1], axis=3)
  88.     conv2_2 = conv_drop(inputs=concat4_2, filters=filters[2])
  89.     up22_13 = upsampling(inputs=conv2_2, filters=filters[1])
  90.     concat4_3 = concatenate([up22_13, conv1_0, conv1_1, conv1_2], axis=3)
  91.     conv1_3 = conv_drop(inputs=concat4_3, filters=filters[1])
  92.     up13_04 = upsampling(inputs=conv1_3, filters=filters[0])
  93.     concat4_4 = concatenate([up13_04, conv0_0, conv0_1, conv0_2, conv0_3], axis=3)
  94.     conv0_4 = conv_drop(inputs=concat4_4, filters=filters[0])
  95.     ## output
  96.     l1_conv_out = Conv2D(filters=n_class, kernel_size=1, padding='same', kernel_initializer='he_normal')(conv0_1)
  97.     l2_conv_out = Conv2D(filters=n_class, kernel_size=1, padding='same', kernel_initializer='he_normal')(conv0_2)
  98.     l3_conv_out = Conv2D(filters=n_class, kernel_size=1, padding='same', kernel_initializer='he_normal')(conv0_3)
  99.     l4_conv_out = Conv2D(filters=n_class, kernel_size=1, padding='same', kernel_initializer='he_normal')(conv0_4)
  100.  
  101.     if re_shape == True:
  102.         l1_conv_out = Reshape((input_size[0] * input_size[1], n_class))(l1_conv_out)
  103.         l2_conv_out = Reshape((input_size[0] * input_size[1], n_class))(l2_conv_out)
  104.         l3_conv_out = Reshape((input_size[0] * input_size[1], n_class))(l3_conv_out)
  105.         l4_conv_out = Reshape((input_size[0] * input_size[1], n_class))(l4_conv_out)
  106.  
  107.     l1_out = Activation('sigmoid', name='l1_out')(l1_conv_out)
  108.     l2_out = Activation('sigmoid', name='l2_out')(l2_conv_out)
  109.     l3_out = Activation('sigmoid', name='l3_out')(l3_conv_out)
  110.     l4_out = Activation('sigmoid', name='l4_out')(l4_conv_out)
  111.  
  112.     model = Model(input=inputs, output=[l1_out, l2_out, l3_out, l4_out])
  113.     # model = Model(input=inputs, output=l4_out)
  114.     model.summary()
  115.     losses = {
  116.         'l1_out': bce_dice_loss,
  117.         'l2_out': bce_dice_loss,
  118.         'l3_out': bce_dice_loss,
  119.         'l4_out': bce_dice_loss,
  120.     }
  121.     model.compile(optimizer=Adam(lr=1e-4), loss=losses, metrics=['accuracy'])
  122.     return model

 pytorch实现

语义分割系列6-Unet++（pytorch实现）-CSDN博客

  1. import torch
  2. import torch.nn as nn
  3.  
  4.  
  5. class ContinusParalleConv(nn.Module):
  6.     # 一个连续的卷积模块，包含BatchNorm 在前 和 在后 两种模式
  7.     def __init__(self, in_channels, out_channels, pre_Batch_Norm=True):
  8.         super(ContinusParalleConv, self).__init__()
  9.         self.in_channels = in_channels
  10.         self.out_channels = out_channels
  11.  
  12.         if pre_Batch_Norm:
  13.             self.Conv_forward = nn.Sequential(
  14.                 nn.BatchNorm2d(self.in_channels),
  15.                 nn.ReLU(),
  16.                 nn.Conv2d(self.in_channels, self.out_channels, 3, padding=1),
  17.                 nn.BatchNorm2d(out_channels),
  18.                 nn.ReLU(),
  19.                 nn.Conv2d(self.out_channels, self.out_channels, 3, padding=1))
  20.  
  21.         else:
  22.             self.Conv_forward = nn.Sequential(
  23.                 nn.Conv2d(self.in_channels, self.out_channels, 3, padding=1),
  24.                 nn.BatchNorm2d(out_channels),
  25.                 nn.ReLU(),
  26.                 nn.Conv2d(self.out_channels, self.out_channels, 3, padding=1),
  27.                 nn.BatchNorm2d(self.out_channels),
  28.                 nn.ReLU())
  29.  
  30.     def forward(self, x):
  31.         x = self.Conv_forward(x)
  32.         return x
  33.  
  34.  
  35. class UnetPlusPlus(nn.Module):
  36.     def __init__(self, num_classes, deep_supervision=False):
  37.         super(UnetPlusPlus, self).__init__()
  38.         self.num_classes = num_classes
  39.         self.deep_supervision = deep_supervision
  40.         self.filters = [64, 128, 256, 512, 1024]
  41.  
  42.         self.CONV3_1 = ContinusParalleConv(512 * 2, 512, pre_Batch_Norm=True)
  43.  
  44.         self.CONV2_2 = ContinusParalleConv(256 * 3, 256, pre_Batch_Norm=True)
  45.         self.CONV2_1 = ContinusParalleConv(256 * 2, 256, pre_Batch_Norm=True)
  46.  
  47.         self.CONV1_1 = ContinusParalleConv(128 * 2, 128, pre_Batch_Norm=True)
  48.         self.CONV1_2 = ContinusParalleConv(128 * 3, 128, pre_Batch_Norm=True)
  49.         self.CONV1_3 = ContinusParalleConv(128 * 4, 128, pre_Batch_Norm=True)
  50.  
  51.         self.CONV0_1 = ContinusParalleConv(64 * 2, 64, pre_Batch_Norm=True)
  52.         self.CONV0_2 = ContinusParalleConv(64 * 3, 64, pre_Batch_Norm=True)
  53.         self.CONV0_3 = ContinusParalleConv(64 * 4, 64, pre_Batch_Norm=True)
  54.         self.CONV0_4 = ContinusParalleConv(64 * 5, 64, pre_Batch_Norm=True)
  55.  
  56.         self.stage_0 = ContinusParalleConv(3, 64, pre_Batch_Norm=False)
  57.         self.stage_1 = ContinusParalleConv(64, 128, pre_Batch_Norm=False)
  58.         self.stage_2 = ContinusParalleConv(128, 256, pre_Batch_Norm=False)
  59.         self.stage_3 = ContinusParalleConv(256, 512, pre_Batch_Norm=False)
  60.         self.stage_4 = ContinusParalleConv(512, 1024, pre_Batch_Norm=False)
  61.  
  62.         self.pool = nn.MaxPool2d(2)
  63.  
  64.         self.upsample_3_1 = nn.ConvTranspose2d(in_channels=1024, out_channels=512, kernel_size=4, stride=2, padding=1)
  65.  
  66.         self.upsample_2_1 = nn.ConvTranspose2d(in_channels=512, out_channels=256, kernel_size=4, stride=2, padding=1)
  67.         self.upsample_2_2 = nn.ConvTranspose2d(in_channels=512, out_channels=256, kernel_size=4, stride=2, padding=1)
  68.  
  69.         self.upsample_1_1 = nn.ConvTranspose2d(in_channels=256, out_channels=128, kernel_size=4, stride=2, padding=1)
  70.         self.upsample_1_2 = nn.ConvTranspose2d(in_channels=256, out_channels=128, kernel_size=4, stride=2, padding=1)
  71.         self.upsample_1_3 = nn.ConvTranspose2d(in_channels=256, out_channels=128, kernel_size=4, stride=2, padding=1)
  72.  
  73.         self.upsample_0_1 = nn.ConvTranspose2d(in_channels=128, out_channels=64, kernel_size=4, stride=2, padding=1)
  74.         self.upsample_0_2 = nn.ConvTranspose2d(in_channels=128, out_channels=64, kernel_size=4, stride=2, padding=1)
  75.         self.upsample_0_3 = nn.ConvTranspose2d(in_channels=128, out_channels=64, kernel_size=4, stride=2, padding=1)
  76.         self.upsample_0_4 = nn.ConvTranspose2d(in_channels=128, out_channels=64, kernel_size=4, stride=2, padding=1)
  77.  
  78.         # 分割头
  79.         self.final_super_0_1 = nn.Sequential(
  80.             nn.BatchNorm2d(64),
  81.             nn.ReLU(),
  82.             nn.Conv2d(64, self.num_classes, 3, padding=1),
  83.         )
  84.         self.final_super_0_2 = nn.Sequential(
  85.             nn.BatchNorm2d(64),
  86.             nn.ReLU(),
  87.             nn.Conv2d(64, self.num_classes, 3, padding=1),
  88.         )
  89.         self.final_super_0_3 = nn.Sequential(
  90.             nn.BatchNorm2d(64),
  91.             nn.ReLU(),
  92.             nn.Conv2d(64, self.num_classes, 3, padding=1),
  93.         )
  94.         self.final_super_0_4 = nn.Sequential(
  95.             nn.BatchNorm2d(64),
  96.             nn.ReLU(),
  97.             nn.Conv2d(64, self.num_classes, 3, padding=1),
  98.         )
  99.  
  100.     def forward(self, x):
  101.         x_0_0 = self.stage_0(x)
  102.         x_1_0 = self.stage_1(self.pool(x_0_0))
  103.         x_2_0 = self.stage_2(self.pool(x_1_0))
  104.         x_3_0 = self.stage_3(self.pool(x_2_0))
  105.         x_4_0 = self.stage_4(self.pool(x_3_0))
  106.  
  107.         x_0_1 = torch.cat([self.upsample_0_1(x_1_0), x_0_0], 1)
  108.         x_0_1 = self.CONV0_1(x_0_1)
  109.  
  110.         x_1_1 = torch.cat([self.upsample_1_1(x_2_0), x_1_0], 1)
  111.         x_1_1 = self.CONV1_1(x_1_1)
  112.  
  113.         x_2_1 = torch.cat([self.upsample_2_1(x_3_0), x_2_0], 1)
  114.         x_2_1 = self.CONV2_1(x_2_1)
  115.  
  116.         x_3_1 = torch.cat([self.upsample_3_1(x_4_0), x_3_0], 1)
  117.         x_3_1 = self.CONV3_1(x_3_1)
  118.  
  119.         x_2_2 = torch.cat([self.upsample_2_2(x_3_1), x_2_0, x_2_1], 1)
  120.         x_2_2 = self.CONV2_2(x_2_2)
  121.  
  122.         x_1_2 = torch.cat([self.upsample_1_2(x_2_1), x_1_0, x_1_1], 1)
  123.         x_1_2 = self.CONV1_2(x_1_2)
  124.  
  125.         x_1_3 = torch.cat([self.upsample_1_3(x_2_2), x_1_0, x_1_1, x_1_2], 1)
  126.         x_1_3 = self.CONV1_3(x_1_3)
  127.  
  128.         x_0_2 = torch.cat([self.upsample_0_2(x_1_1), x_0_0, x_0_1], 1)
  129.         x_0_2 = self.CONV0_2(x_0_2)
  130.  
  131.         x_0_3 = torch.cat([self.upsample_0_3(x_1_2), x_0_0, x_0_1, x_0_2], 1)
  132.         x_0_3 = self.CONV0_3(x_0_3)
  133.  
  134.         x_0_4 = torch.cat([self.upsample_0_4(x_1_3), x_0_0, x_0_1, x_0_2, x_0_3], 1)
  135.         x_0_4 = self.CONV0_4(x_0_4)
  136.  
  137.         if self.deep_supervision:
  138.             out_put1 = self.final_super_0_1(x_0_1)
  139.             out_put2 = self.final_super_0_2(x_0_2)
  140.             out_put3 = self.final_super_0_3(x_0_3)
  141.             out_put4 = self.final_super_0_4(x_0_4)
  142.             return [out_put1, out_put2, out_put3, out_put4]
  143.         else:
  144.             return self.final_super_0_4(x_0_4)
  145.  
  146.  
  147. if __name__ == "__main__":
  148.     print("deep_supervision: False")
  149.     deep_supervision = False
  150.     device = torch.device('cpu')
  151.     inputs = torch.randn((1, 3, 224, 224)).to(device)
  152.     model = UnetPlusPlus(num_classes=3, deep_supervision=deep_supervision).to(device)
  153.     outputs = model(inputs)
  154.     print(outputs.shape)
  155.  
  156.     print("deep_supervision: True")
  157.     deep_supervision = True
  158.     model = UnetPlusPlus(num_classes=3, deep_supervision=deep_supervision).to(device)
  159.     outputs = model(inputs)
  160.     for out in outputs:
  161.         print(out.shape)
  162.
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/760625
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号