憨批的语义分割重制版7——Tensorflow2 搭建自己的Unet语义分割平台

青旅半醒 2022-12-28 11:26 181阅读 0赞

### 憨批的语义分割重制版7——Tensorflow2 搭建自己的Unet语义分割平台 ###

*  注意事项
 *  学习前言
 *  什么是Unet模型
 *  代码下载
 *  Unet实现思路
 *   *  一、预测部分
     *   *  1、主干网络介绍
         *  2、加强特征提取结构
         *  3、利用特征获得预测结果
     *  二、训练部分
     *   *  1、训练文件详解
         *  2、LOSS解析
 *  训练自己的Unet模型

# 注意事项 #

**这是重新构建了的Unet语义分割网络，主要是文件框架上的构建，还有代码的实现，和之前的语义分割网络相比，更加完整也更清晰一些。建议还是学习这个版本的Unet。**

# 学习前言 #

还是快乐的tensorflow人。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center]

# 什么是Unet模型 #

Unet是一个优秀的语义分割模型，其主要执行过程与其它语义分割模型类似。

Unet可以分为三个部分，如下图所示：

第一部分是**主干特征提取部分**，我们可以**利用主干部分**获得一个又一个的**特征层**，Unet的主干特征提取部分与VGG相似，为卷积和最大池化的堆叠。**利用主干特征提取部分我们可以获得五个初步有效特征层**，在第二步中，我们会利用这五个有效特征层可以进行特征融合。

第二部分是**加强特征提取部分**，我们可以利用主干部分获取到的**五个初步有效特征层**进行上采样，并且进行特征融合，获得一个最终的，融合了**所有特征的有效特征层**。

第三部分是**预测部分**，我们会利用**最终获得的最后一个有效特征层**对每一个特征点进行分类，相当于对每一个像素点进行分类。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 1]

# 代码下载 #

Github源码下载地址为：  
https://github.com/bubbliiiing/unet-tf2

# Unet实现思路 #

## 一、预测部分 ##

### 1、主干网络介绍 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 1]  
Unet的主干特征提取部分由卷积+最大池化组成，整体结构与VGG类似。

本文所采用的主干特征提取网络为VGG16，这样也方便使用imagnet上的预训练权重。

VGG是由Simonyan 和Zisserman在文献《Very Deep Convolutional Networks for Large Scale Image Recognition》中提出卷积神经网络模型，其名称来源于作者所在的牛津大学视觉几何组(Visual Geometry Group)的缩写。

该模型参加2014年的 ImageNet图像分类与定位挑战赛，取得了优异成绩：在分类任务上排名第二，在定位任务上排名第一。  
它的结构如下图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 2]  
这是一个VGG16被用到烂的图，但确实很好的反应了VGG16的结构。

当我们使用VGG16作为**主干特征提取网络**的时候，我们只会用到两种类型的层，分别是**卷积层**和**最大池化层**。

当输入的图像大小为512x512x3的时候，具体执行方式如下：  
**1、conv1：进行两次\[3,3\]的64通道的卷积，获得一个\[512,512,64\]的初步有效特征层，再进行2X2最大池化，获得一个\[256,256,64\]的特征层。  
2、conv2：进行两次\[3,3\]的128通道的卷积，获得一个\[256,256,128\]的初步有效特征层，再进行2X2最大池化，获得一个\[128,128,128\]的特征层。  
3、conv3：进行三次\[3,3\]的256通道的卷积，获得一个\[128,128,256\]的初步有效特征层，再进行2X2最大池化，获得一个\[64,64,256\]的特征层。  
4、conv4：进行三次\[3,3\]的512通道的卷积，获得一个\[64,64,512\]的初步有效特征层，再进行2X2最大池化，获得一个\[32,32,512\]的特征层。  
5、conv5：进行三次\[3,3\]的512通道的卷积，获得一个\[32,32,512\]的初步有效特征层。**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 3]

from tensorflow.keras import layers
    from tensorflow.keras.initializers import RandomNormal
    
    
    def VGG16(img_input):
        # Block 1
        # 512,512,3 -> 512,512,64
        x = layers.Conv2D(64, (3, 3),
                          activation='relu',
                          padding='same',
                          kernel_initializer = RandomNormal(stddev=0.02), 
                          name='block1_conv1')(img_input)
        x = layers.Conv2D(64, (3, 3),
                          activation='relu',
                          padding='same',
                          kernel_initializer = RandomNormal(stddev=0.02), 
                          name='block1_conv2')(x)
        feat1 = x
        # 512,512,64 -> 256,256,64
        x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x)
    
        # Block 2
        # 256,256,64 -> 256,256,128
        x = layers.Conv2D(128, (3, 3),
                          activation='relu',
                          padding='same',
                          kernel_initializer = RandomNormal(stddev=0.02), 
                          name='block2_conv1')(x)
        x = layers.Conv2D(128, (3, 3),
                          activation='relu',
                          padding='same',
                          kernel_initializer = RandomNormal(stddev=0.02), 
                          name='block2_conv2')(x)
        feat2 = x
        # 256,256,128 -> 128,128,128
        x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x)
    
    
        # Block 3
        # 128,128,128 -> 128,128,256
        x = layers.Conv2D(256, (3, 3),
                          activation='relu',
                          padding='same',
                          kernel_initializer = RandomNormal(stddev=0.02), 
                          name='block3_conv1')(x)
        x = layers.Conv2D(256, (3, 3),
                          activation='relu',
                          padding='same',
                          kernel_initializer = RandomNormal(stddev=0.02), 
                          name='block3_conv2')(x)
        x = layers.Conv2D(256, (3, 3),
                          activation='relu',
                          padding='same',
                          kernel_initializer = RandomNormal(stddev=0.02), 
                          name='block3_conv3')(x)
        feat3 = x
        # 128,128,256 -> 64,64,256
        x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(x)
    
        # Block 4
        # 64,64,256 -> 64,64,512
        x = layers.Conv2D(512, (3, 3),
                          activation='relu',
                          padding='same',
                          kernel_initializer = RandomNormal(stddev=0.02), 
                          name='block4_conv1')(x)
        x = layers.Conv2D(512, (3, 3),
                          activation='relu',
                          padding='same',
                          kernel_initializer = RandomNormal(stddev=0.02), 
                          name='block4_conv2')(x)
        x = layers.Conv2D(512, (3, 3),
                          activation='relu',
                          padding='same',
                          kernel_initializer = RandomNormal(stddev=0.02), 
                          name='block4_conv3')(x)
        feat4 = x
        # 64,64,512 -> 32,32,512
        x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(x)
    
        # Block 5
        # 32,32,512 -> 32,32,512
        x = layers.Conv2D(512, (3, 3),
                          activation='relu',
                          padding='same',
                          kernel_initializer = RandomNormal(stddev=0.02), 
                          name='block5_conv1')(x)
        x = layers.Conv2D(512, (3, 3),
                          activation='relu',
                          padding='same',
                          kernel_initializer = RandomNormal(stddev=0.02), 
                          name='block5_conv2')(x)
        x = layers.Conv2D(512, (3, 3),
                          activation='relu',
                          padding='same',
                          kernel_initializer = RandomNormal(stddev=0.02), 
                          name='block5_conv3')(x)
        feat5 = x
        return feat1, feat2, feat3, feat4, feat5

### 2、加强特征提取结构 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 1]  
Unet所使用的**加强特征提取网络是一个U的形状。**

利用第一步我们可以获得**五个初步的有效特征层**，在加强特征提取网络这里，我们会利用这五个**初步的有效特征层进行特征融合**，**特征融合的方式**就是**对特征层进行上采样并且进行堆叠**。

为了方便网络的构建与更好的通用性，我们的Unet和上图的Unet结构有些许不同，在**上采样时直接进行两倍上采样再进行特征融合**，最终获得的特征层和输入图片的高宽相同。

具体示意图如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 4]

from tensorflow.keras.initializers import RandomNormal
    from tensorflow.keras.layers import *
    from tensorflow.keras.models import *
    
    from nets.vgg16 import VGG16
    
    def Unet(input_shape=(256,256,3), num_classes=21):
        inputs = Input(input_shape)
        #-------------------------------#
        #   获得五个有效特征层
        #   feat1   512,512,64
        #   feat2   256,256,128
        #   feat3   128,128,256
        #   feat4   64,64,512
        #   feat5   32,32,512
        #-------------------------------#
        feat1, feat2, feat3, feat4, feat5 = VGG16(inputs) 
          
        channels = [64, 128, 256, 512]
    
        # 32, 32, 512 -> 64, 64, 512
        P5_up = UpSampling2D(size=(2, 2))(feat5)
        # 64, 64, 512 + 64, 64, 512 -> 64, 64, 1024
        P4 = Concatenate(axis=3)([feat4, P5_up])
        # 64, 64, 1024 -> 64, 64, 512
        P4 = Conv2D(channels[3], 3, activation='relu', padding='same', kernel_initializer = RandomNormal(stddev=0.02))(P4)
        P4 = Conv2D(channels[3], 3, activation='relu', padding='same', kernel_initializer = RandomNormal(stddev=0.02))(P4)
    
        # 64, 64, 512 -> 128, 128, 512
        P4_up = UpSampling2D(size=(2, 2))(P4)
        # 128, 128, 256 + 128, 128, 512 -> 128, 128, 768
        P3 = Concatenate(axis=3)([feat3, P4_up])
        # 128, 128, 768 -> 128, 128, 256
        P3 = Conv2D(channels[2], 3, activation='relu', padding='same', kernel_initializer = RandomNormal(stddev=0.02))(P3)
        P3 = Conv2D(channels[2], 3, activation='relu', padding='same', kernel_initializer = RandomNormal(stddev=0.02))(P3)
    
        # 128, 128, 256 -> 256, 256, 256
        P3_up = UpSampling2D(size=(2, 2))(P3)
        # 256, 256, 256 + 256, 256, 128 -> 256, 256, 384
        P2 = Concatenate(axis=3)([feat2, P3_up])
        # 256, 256, 384 -> 256, 256, 128
        P2 = Conv2D(channels[1], 3, activation='relu', padding='same', kernel_initializer = RandomNormal(stddev=0.02))(P2)
        P2 = Conv2D(channels[1], 3, activation='relu', padding='same', kernel_initializer = RandomNormal(stddev=0.02))(P2)
    
        # 256, 256, 128 -> 512, 512, 128
        P2_up = UpSampling2D(size=(2, 2))(P2)
        # 512, 512, 128 + 512, 512, 64 -> 512, 512, 192
        P1 = Concatenate(axis=3)([feat1, P2_up])
        # 512, 512, 192 -> 512, 512, 64
        P1 = Conv2D(channels[0], 3, activation='relu', padding='same', kernel_initializer = RandomNormal(stddev=0.02))(P1)
        P1 = Conv2D(channels[0], 3, activation='relu', padding='same', kernel_initializer = RandomNormal(stddev=0.02))(P1)
    
        # 512, 512, 64 -> 512, 512, num_classes
        P1 = Conv2D(num_classes, 1, activation="softmax")(P1)
    
        model = Model(inputs=inputs, outputs=P1)
        return model

### 3、利用特征获得预测结果 ###

利用1、2步，我们可以获取输入进来的图片的特征，此时，我们需要利用特征获得预测结果。

利用特征获得预测结果的过程为：  
**利用一个1x1卷积进行通道调整，将最终特征层的通道数调整成num\_classes。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 5]

## 二、训练部分 ##

### 1、训练文件详解 ###

我们使用的训练文件采用VOC的格式。  
语义分割模型训练的文件分为两部分。  
第一部分是原图，像这样：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 6]  
第二部分标签，像这样：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 7]  
原图就是普通的RGB图像，标签就是灰度图或者8位彩色图。

**原图的shape为\[height, width, 3\]，标签的shape就是\[height, width\]，对于标签而言，每个像素点的内容是一个数字，比如0、1、2、3、4、5……，代表这个像素点所属的类别。**

语义分割的工作就是对原始的图片的每一个像素点进行分类，**所以通过预测结果中每个像素点属于每个类别的概率与标签对比，可以对网络进行训练。**

### 2、LOSS解析 ###

本文所使用的LOSS由两部分组成：  
**1、Cross Entropy Loss。  
2、Dice Loss。**

**Cross Entropy Loss就是普通的交叉熵损失，当语义分割平台利用Softmax对像素点进行分类的时候，进行使用。**

Dice loss将语义分割的评价指标作为Loss，**Dice系数是一种集合相似度度量函数，通常用于计算两个样本的相似度，取值范围在\[0,1\]。**

计算公式如下：  
![在这里插入图片描述][20200624002412801.png_pic_center]  
就是**预测结果和真实结果的交乘上2**，除上**预测结果加上真实结果**。其值在0-1之间。越大表示预测结果和真实结果重合度越大。**所以Dice系数是越大越好。**

如果作为LOSS的话是越小越好，所以使得Dice loss = 1 - Dice，就可以将Loss作为语义分割的损失了。  
实现代码如下：

def dice_loss_with_CE(beta=1, smooth = 1e-5):
        def _dice_loss_with_CE(y_true, y_pred):
            y_pred = K.clip(y_pred, K.epsilon(), 1.0 - K.epsilon())
    
            CE_loss = - y_true[...,:-1] * K.log(y_pred)
            CE_loss = K.mean(K.sum(CE_loss, axis = -1))
    
            tp = K.sum(y_true[...,:-1] * y_pred, axis=[0,1,2])
            fp = K.sum(y_pred         , axis=[0,1,2]) - tp
            fn = K.sum(y_true[...,:-1], axis=[0,1,2]) - tp
    
            score = ((1 + beta ** 2) * tp + smooth) / ((1 + beta ** 2) * tp + beta ** 2 * fn + fp + smooth)
            score = tf.reduce_mean(score)
            dice_loss = 1 - score
            # dice_loss = tf.Print(dice_loss, [dice_loss, CE_loss])
            return CE_loss + dice_loss
        return _dice_loss_with_CE
    
    def CE():
        def _CE(y_true, y_pred):
            y_pred = K.clip(y_pred, K.epsilon(), 1.0 - K.epsilon())
    
            CE_loss = - y_true[...,:-1] * K.log(y_pred)
            CE_loss = K.mean(K.sum(CE_loss, axis = -1))
            # dice_loss = tf.Print(CE_loss, [CE_loss])
            return CE_loss
        return _CE

# 训练自己的Unet模型 #

整个Unet的文件构架为：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 8]  
在训练模型之前，我们需要首先准备好数据集。  
**大家可以下载我上传的voc数据集，也可以根据voc数据集格式进行数据集制作。**  
![在这里插入图片描述][20200929135357289.png_pic_center]  
如果大家下载的是我上传的voc数据集，那么就不需要运行VOCdevkit文件夹下面的voc2unet.py。  
**如果是自己制作的数据集，那么需要运行VOCdevkit文件夹下面的voc2unet.py，从而生成train.txt和val.txt。**  
![在这里插入图片描述][20200629090456544.png_pic_center]  
生成完成后。  
修改train.py文件下的num\_classes，使其为分的类的个数+1。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 9]  
之后就可以开始训练了。  
![在这里插入图片描述][20200929140325120.png_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/e608fe6c029046b09213f07bdd6da467.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/d387d974ad394748bd3e310d3d6e325e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/d400adb1025e4bc8bb5bed273da6e79d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221120/4499942581054f669aa27b119186a8d6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221120/1ebe3b0ab3854ea1a141841803665eca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221120/b2ac53c53dd046a392b065439b668e43.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221120/2a7cbc92f6a643c28c5353a71acb05c2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221120/f44be74384ac4d359596b400d83394d1.png
[20200624002412801.png_pic_center]: /images/20221120/3677031c4c994d9490cececd4204325d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221120/e40203187f414fe9a79673da57ca9d2f.png
[20200929135357289.png_pic_center]: /images/20221120/0876e982df3542bfae5e76fd8c68819e.png
[20200629090456544.png_pic_center]: /images/20221120/cc5ae074d69e4ff3acd942e1cb0d3b9b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221120/f2b4759aab764c6ca0c263eafb08d869.png
[20200929140325120.png_pic_center]: https://img-blog.csdnimg.cn/20200929140325120.png#pic_center