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

快来打我* 2022-12-11 07:45 199阅读 0赞

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

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

# 注意事项 #

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

# 学习前言 #

重置一下我最喜欢的Unet。  
![在这里插入图片描述][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-keras][https_github.com_bubbliiiing_unet-keras]

# 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 keras import layers
    
    def VGG16(img_input):
        # Block 1
        x = layers.Conv2D(64, (3, 3),
                          activation='relu',
                          padding='same',
                          name='block1_conv1')(img_input)
        x = layers.Conv2D(64, (3, 3),
                          activation='relu',
                          padding='same',
                          name='block1_conv2')(x)
        feat1 = x
        x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x)
    
        # Block 2
        x = layers.Conv2D(128, (3, 3),
                          activation='relu',
                          padding='same',
                          name='block2_conv1')(x)
        x = layers.Conv2D(128, (3, 3),
                          activation='relu',
                          padding='same',
                          name='block2_conv2')(x)
        feat2 = x
        x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x)
    
    
        # Block 3
        x = layers.Conv2D(256, (3, 3),
                          activation='relu',
                          padding='same',
                          name='block3_conv1')(x)
        x = layers.Conv2D(256, (3, 3),
                          activation='relu',
                          padding='same',
                          name='block3_conv2')(x)
        x = layers.Conv2D(256, (3, 3),
                          activation='relu',
                          padding='same',
                          name='block3_conv3')(x)
        feat3 = x
        x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(x)
    
        # Block 4
        x = layers.Conv2D(512, (3, 3),
                          activation='relu',
                          padding='same',
                          name='block4_conv1')(x)
        x = layers.Conv2D(512, (3, 3),
                          activation='relu',
                          padding='same',
                          name='block4_conv2')(x)
        x = layers.Conv2D(512, (3, 3),
                          activation='relu',
                          padding='same',
                          name='block4_conv3')(x)
        feat4 = x
    
        x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(x)
    
        # Block 5
        x = layers.Conv2D(512, (3, 3),
                          activation='relu',
                          padding='same',
                          name='block5_conv1')(x)
        x = layers.Conv2D(512, (3, 3),
                          activation='relu',
                          padding='same',
                          name='block5_conv2')(x)
        x = layers.Conv2D(512, (3, 3),
                          activation='relu',
                          padding='same',
                          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]

import numpy as np
    from keras.models import *
    from keras.layers import *
    from nets.vgg16 import VGG16
    
    def Unet(input_shape=(256,256,3), num_classes=21):
        inputs = Input(input_shape)
        feat1, feat2, feat3, feat4, feat5 = VGG16(inputs) 
          
        channels = [64, 128, 256, 512]
    
        P5_up = UpSampling2D(size=(2, 2))(feat5)
        P4 = Concatenate(axis=3)([feat4, P5_up])
        P4 = Conv2D(channels[3], 3, activation='relu', padding='same', kernel_initializer='he_normal')(P4)
        P4 = Conv2D(channels[3], 3, activation='relu', padding='same', kernel_initializer='he_normal')(P4)
    
        P4_up = UpSampling2D(size=(2, 2))(P4)
        P3 = Concatenate(axis=3)([feat3, P4_up])
        P3 = Conv2D(channels[2], 3, activation='relu', padding='same', kernel_initializer='he_normal')(P3)
        P3 = Conv2D(channels[2], 3, activation='relu', padding='same', kernel_initializer='he_normal')(P3)
    
        P3_up = UpSampling2D(size=(2, 2))(P3)
        P2 = Concatenate(axis=3)([feat2, P3_up])
        P2 = Conv2D(channels[1], 3, activation='relu', padding='same', kernel_initializer='he_normal')(P2)
        P2 = Conv2D(channels[1], 3, activation='relu', padding='same', kernel_initializer='he_normal')(P2)
    
        P2_up = UpSampling2D(size=(2, 2))(P2)
        P1 = Concatenate(axis=3)([feat1, P2_up])
        P1 = Conv2D(channels[0], 3, activation='relu', padding='same', kernel_initializer='he_normal')(P1)
        P1 = Conv2D(channels[0], 3, activation='relu', padding='same', kernel_initializer='he_normal')(P1)
    
        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, alpha = 0.25, gamma=2.0, threhold=0.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, focal_loss])
            return CE_loss + dice_loss
        return _dice_loss_with_CE

# 训练自己的Unet模型 #

整个Unet的文件构架为：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 8]  
在训练模型之前，我们需要首先准备好数据集。  
**大家可以下载我上传的voc数据集，也可以根据voc数据集格式进行数据集制作。**  
![在这里插入图片描述][2020062909023523.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]  
之后就可以开始训练了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 10]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/095192b842cb43209a1f9f7f7b014b8a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/407f8863469546008a941e43a6aad6be.png
[https_github.com_bubbliiiing_unet-keras]: https://github.com/bubbliiiing/unet-keras
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/40e6762e398a4cf68c321eb3d433d68c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/33171f0020fc4ea0bb11e0dd630c7aca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/2c06e59dcd9e4d778446eeddc6bc2d71.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/4dea60572fe744118c7bd289cf644573.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221123/d9d9d24f0acd402e897a8d867d72a6e3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221123/6dfb07c08d7c4354b95c0b29888e1809.png
[20200624002412801.png_pic_center]: /images/20221123/7b504b1e838442f88707c954f437c565.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221123/c26ff43c4401471bb670aef6ae187139.png
[2020062909023523.png_pic_center]: /images/20221123/08f1d29c83fa4b7cba1c0f6b5cda3ee1.png
[20200629090456544.png_pic_center]: /images/20221123/66765d68bd1340e298edc9ad0b451132.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221123/ca9a2ec9f3e0476196c0c3e7ea387535.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20221123/18c5dfc863db4bd0866c544916ccd98e.png