（大佬）睿智的目标检测29——Keras搭建YoloV4目标检测平台

朱雀 2023-02-23 08:23 93阅读 0赞

原文链接：[https://blog.csdn.net/weixin\_44791964/article/details/106014717][https_blog.csdn.net_weixin_44791964_article_details_106014717]

### 睿智的目标检测29——Keras搭建YoloV4目标检测平台 ###

*  学习前言
 *  什么是YOLOV4
 *  代码下载
 *  YOLOV4改进的部分（不完全）
 *  YOLOV4结构解析
 *   *  1、主干特征提取网络Backbone
     *  2、特征金字塔
     *  3、YoloHead利用获得到的特征进行预测
     *  4、预测结果的解码
     *  5、在原图上进行绘制
 *  YOLOV4的训练
 *   *  1、YOLOV4的改进训练技巧
     *   *  a)、Mosaic数据增强
         *  b)、Label Smoothing平滑
         *  c)、CIOU
         *  d)、学习率余弦退火衰减
     *  2、loss组成
     *   *  a)、计算loss所需参数
         *  b)、y\_pre是什么
         *  c)、y\_true是什么。
         *  d)、loss的计算过程
 *  训练自己的YOLOV4模型

# 学习前言 #

哈哈哈我最喜欢的YOLO更新了！  
![在这里插入图片描述][20190723165901974.jpg_pic_center]

# 什么是YOLOV4 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center]  
YOLOV4是YOLOV3的改进版，**在YOLOV3的基础上结合了非常多的小Tricks。**  
尽管没有目标检测上革命性的改变，但是YOLOV4依然很好的结合了速度与精度。  
根据上图也可以看出来，**YOLOV4在YOLOV3的基础上，在FPS不下降的情况下，mAP达到了44，提高非常明显。**

YOLOV4整体上的检测思路和YOLOV3相比相差并不大，都是使用三个特征层进行分类与回归预测。

**请注意！**

**强烈建议在学习YOLOV4之前学习YOLOV3，因为YOLOV4确实可以看作是YOLOV3结合一系列改进的版本！**

（重要的事情说三遍！）

YOLOV3可参考该博客：  
[https://blog.csdn.net/weixin\_44791964/article/details/103276106][https_blog.csdn.net_weixin_44791964_article_details_103276106]

# 代码下载 #

[https://github.com/bubbliiiing/yolov4-keras][https_github.com_bubbliiiing_yolov4-keras]  
喜欢的可以给个star噢！

哔哩哔哩视频地址：  
[https://www.bilibili.com/video/BV1kt4y117G6][https_www.bilibili.com_video_BV1kt4y117G6]

# YOLOV4改进的部分（不完全） #

**1、主干特征提取网络：DarkNet53 => CSPDarkNet53**

**2、特征金字塔：SPP，PAN**

**3、分类回归层：YOLOv3（未改变）**

**4、训练用到的小技巧：Mosaic数据增强、Label Smoothing平滑、CIOU、学习率余弦退火衰减**

**5、激活函数：使用Mish激活函数**

**以上并非全部的改进部分，还存在一些其它的改进，由于YOLOV4使用的改进实在太多了，很难完全实现与列出来，这里只列出来了一些我比较感兴趣，而且非常有效的改进。**

整篇BLOG会结合YOLOV3与YOLOV4的差别进行解析

# YOLOV4结构解析 #

## 1、主干特征提取网络Backbone ##

如果大家对YOLOV3比较熟悉的话，应该知道Darknet53的结构，其由一系列残差网络结构构成。在Darknet53中，其存在如下**resblock\_body模块**，其由一次**下采样**和**多次残差结构的堆叠**构成，Darknet53便是由**resblock\_body模块组合而成**。

def resblock_body(x, num_filters, num_blocks):
        x = ZeroPadding2D(((1,0),(1,0)))(x)
        x = DarknetConv2D_BN_Leaky(num_filters, (3,3), strides=(2,2))(x)
        for i in range(num_blocks):
            y = DarknetConv2D_BN_Leaky(num_filters//2, (1,1))(x)
            y = DarknetConv2D_BN_Leaky(num_filters, (3,3))(y)
            x = Add()([x,y])
        return x
    
       
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8

而在YOLOV4中，其对该部分进行了一定的修改。  
1、其一是**将DarknetConv2D的激活函数由LeakyReLU修改成了Mish**，卷积块由**DarknetConv2D\_BN\_Leaky变成了DarknetConv2D\_BN\_Mish**。  
Mish函数的公式与图像如下：  
 M i s h = x × t a n h ( l n ( 1 + e x ) ) M i s h = x × t a n h ( l n ( 1 + e x ) ) M i s h = x × t a n h ( l n ( 1 + e x ) ) Mish=x×tanh(ln(1+ex))Mish=x×tanh(ln(1+ex)) Mish=x \\times tanh(ln(1+e^x)) Mish=x×tanh(ln(1\+ex))Mish=x×tanh(ln(1\+ex))Mish=x×tanh(ln(1\+ex))Mish=x×tanh(ln(1\+ex))  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 1]  
2、其二是将resblock\_body的结构进行修改，**使用了CSPnet结构。此时YOLOV4当中的Darknet53被修改成了CSPDarknet53**。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 2]  
CSPnet结构并不算复杂，就是将原来的残差块的堆叠进行了一个拆分，拆成左右两部分：  
**主干部分继续进行原来的残差块的堆叠**；  
**另一部分则像一个残差边一样，经过少量处理直接连接到最后。**  
因此可以认为**CSP中存在一个大的残差边。**

#---------------------------------------------------#
 # CSPdarknet的结构块
 # 存在一个大残差边
 # 这个大残差边绕过了很多的残差结构
 #---------------------------------------------------#
 def resblock_body(x, num_filters, num_blocks, all_narrow=True):
 # 进行长和宽的压缩
 preconv1 = ZeroPadding2D(((1,0),(1,0)))(x)
 preconv1 = DarknetConv2D_BN_Mish(num_filters, (3,3), strides=(2,2))(preconv1)
 # 生成一个大的残差边 
 shortconv = DarknetConv2D_BN_Mish(num_filters//2 if all_narrow else num_filters, (1,1))(preconv1)
 
 # 主干部分的卷积
 mainconv = DarknetConv2D_BN_Mish(num_filters//2 if all_narrow else num_filters, (1,1))(preconv1)
 # 1x1卷积对通道数进行整合->3x3卷积提取特征，使用残差结构
 for i in range(num_blocks):
 y = compose(
 DarknetConv2D_BN_Mish(num_filters//2, (1,1)),
 DarknetConv2D_BN_Mish(num_filters//2 if all_narrow else num_filters, (3,3)))(mainconv)
 mainconv = Add()([mainconv,y])
 # 1x1卷积后和残差边堆叠
 postconv = DarknetConv2D_BN_Mish(num_filters//2 if all_narrow else num_filters, (1,1))(mainconv)
 route = Concatenate()([postconv, shortconv])
 
 # 最后对通道数进行整合
 return DarknetConv2D_BN_Mish(num_filters, (1,1))(route)

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27

全部实现代码为：

from functools import wraps
    from keras import backend as K
    from keras.layers import Conv2D, Add, ZeroPadding2D, UpSampling2D, Concatenate, MaxPooling2D, Layer
    from keras.layers.advanced_activations import LeakyReLU
    from keras.layers.normalization import BatchNormalization
    from keras.regularizers import l2
    from utils.utils import compose

class Mish(Layer):  
def **init**(self, kwargs):  
super(Mish, self).**init**(kwargs)  
self.supports\_masking = True

def call(self, inputs):
 return inputs * K.tanh(K.softplus(inputs))
 
 def get_config(self):
 config = super(Mish, self).get_config()
 return config
 
 def compute_output_shape(self, input_shape):
 return input_shape

\#--------------------------------------------------\#  
\# 单次卷积  
\#--------------------------------------------------\#  
@wraps(Conv2D)  
def DarknetConv2D(args, \*\*kwargs):  
darknet\_conv\_kwargs = \{ ‘kernel\_regularizer’: l2(5e\-4)\}  
darknet\_conv\_kwargs\[‘padding’\] = ‘valid’ if kwargs.get(‘strides’)==(2,2) else ‘same’  
darknet\_conv\_kwargs.update(kwargs)  
return Conv2D(args, \*\*darknet\_conv\_kwargs)

\#---------------------------------------------------\#  
\# 卷积块  
\# DarknetConv2D + BatchNormalization + Mish  
\#---------------------------------------------------\#  
def DarknetConv2D\_BN\_Mish(args, \*\*kwargs):  
no\_bias\_kwargs = \{ ‘use\_bias’: False\}  
no\_bias\_kwargs.update(kwargs)  
return compose(  
DarknetConv2D(args, \*\*no\_bias\_kwargs),  
BatchNormalization(),  
Mish())

\#---------------------------------------------------\#  
\# CSPdarknet的结构块  
\# 存在一个大残差边  
\# 这个大残差边绕过了很多的残差结构  
\#---------------------------------------------------\#  
def resblock\_body(x, num\_filters, num\_blocks, all\_narrow=True):  
\# 进行长和宽的压缩  
preconv1 = ZeroPadding2D(((1,0),(1,0)))(x)  
preconv1 = DarknetConv2D\_BN\_Mish(num\_filters, (3,3), strides=(2,2))(preconv1)

# 生成一个大的残差边 
 shortconv = DarknetConv2D_BN_Mish(num_filters//2 if all_narrow else num_filters, (1,1))(preconv1)
 
 # 主干部分的卷积
 mainconv = DarknetConv2D_BN_Mish(num_filters//2 if all_narrow else num_filters, (1,1))(preconv1)
 # 1x1卷积对通道数进行整合->3x3卷积提取特征，使用残差结构
 for i in range(num_blocks):
 y = compose(
 DarknetConv2D_BN_Mish(num_filters//2, (1,1)),
 DarknetConv2D_BN_Mish(num_filters//2 if all_narrow else num_filters, (3,3)))(mainconv)
 mainconv = Add()([mainconv,y])
 # 1x1卷积后和残差边堆叠
 postconv = DarknetConv2D_BN_Mish(num_filters//2 if all_narrow else num_filters, (1,1))(mainconv)
 route = Concatenate()([postconv, shortconv])
 
 # 最后对通道数进行整合
 return DarknetConv2D_BN_Mish(num_filters, (1,1))(route)

\#---------------------------------------------------\#  
\# CSPdarknet53 的主体部分  
\#---------------------------------------------------\#  
def darknet\_body(x):  
x = DarknetConv2D\_BN\_Mish(32, (3,3))(x)  
x = resblock\_body(x, 64, 1, False)  
x = resblock\_body(x, 128, 2)  
x = resblock\_body(x, 256, 8)  
feat1 = x  
x = resblock\_body(x, 512, 8)  
feat2 = x  
x = resblock\_body(x, 1024, 4)  
feat3 = x  
return feat1,feat2,feat3

## 2、特征金字塔 ##

当输入是416x416时，特征结构如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_cneter]  
当输入是608x608时，特征结构如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_cneter 1]  
在特征金字塔部分，YOLOV4结合了两种改进:  
**a).使用了SPP结构。  
b).使用了PANet结构。**  
如上图所示，除去CSPDarknet53和Yolo Head的结构外，都是特征金字塔的结构。  
1、SPP结构参杂在**对CSPdarknet53的最后一个特征层的卷积里**，在**对CSPdarknet53的最后一个特征层进行三次DarknetConv2D\_BN\_Leaky卷积后**，**分别利用四个不同尺度的最大池化进行处理**，最大池化的**池化核大小分别为13x13、9x9、5x5、1x1（1x1即无处理）**

# 使用了SPP结构，即不同尺度的最大池化后堆叠。
    maxpool1 = MaxPooling2D(pool_size=(13,13), strides=(1,1), padding='same')(P5)
    maxpool2 = MaxPooling2D(pool_size=(9,9), strides=(1,1), padding='same')(P5)
    maxpool3 = MaxPooling2D(pool_size=(5,5), strides=(1,1), padding='same')(P5)
    P5 = Concatenate()([maxpool1, maxpool2, maxpool3, P5])
    
     
      
     
      
       1
       2
       3
       4
       5

其可以**它能够极大地增加感受野，分离出最显著的上下文特征**。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 3]  
2、PANet是2018的一种实例分割算法，其具体结构由反复提升特征的意思。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 4]  
上图为原始的PANet的结构，可以看出来其具有**一个非常重要的特点就是特征的反复提取**。  
在（a）里面是传统的特征金字塔结构，在完成特征金字塔从**下到上的特征提取后**，还需要**实现（b）中从上到下的特征提取。**

而在YOLOV4当中，其主要是在**三个有效特征层上使用了PANet结构。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 5]  
实现代码如下：

#---------------------------------------------------#
 # 特征层->最后的输出
 #---------------------------------------------------#
 def yolo_body(inputs, num_anchors, num_classes):
 # 生成darknet53的主干模型
 feat1,feat2,feat3 = darknet_body(inputs)
 P5 = DarknetConv2D_BN_Leaky(512, (1,1))(feat3)
 P5 = DarknetConv2D_BN_Leaky(1024, (3,3))(P5)
 P5 = DarknetConv2D_BN_Leaky(512, (1,1))(P5)
 # 使用了SPP结构，即不同尺度的最大池化后堆叠。
 maxpool1 = MaxPooling2D(pool_size=(13,13), strides=(1,1), padding='same')(P5)
 maxpool2 = MaxPooling2D(pool_size=(9,9), strides=(1,1), padding='same')(P5)
 maxpool3 = MaxPooling2D(pool_size=(5,5), strides=(1,1), padding='same')(P5)
 P5 = Concatenate()([maxpool1, maxpool2, maxpool3, P5])
 P5 = DarknetConv2D_BN_Leaky(512, (1,1))(P5)
 P5 = DarknetConv2D_BN_Leaky(1024, (3,3))(P5)
 P5 = DarknetConv2D_BN_Leaky(512, (1,1))(P5)
 
 P5_upsample = compose(DarknetConv2D_BN_Leaky(256, (1,1)), UpSampling2D(2))(P5)
 
 P4 = DarknetConv2D_BN_Leaky(256, (1,1))(feat2)
 P4 = Concatenate()([P4, P5_upsample])
 P4 = make_five_convs(P4,256)
 
 P4_upsample = compose(DarknetConv2D_BN_Leaky(128, (1,1)), UpSampling2D(2))(P4)
 
 P3 = DarknetConv2D_BN_Leaky(128, (1,1))(feat1)
 P3 = Concatenate()([P3, P4_upsample])
 P3 = make_five_convs(P3,128)
 
 # 76x76的out
 P3_output = DarknetConv2D_BN_Leaky(256, (3,3))(P3)
 P3_output = DarknetConv2D(num_anchors*(num_classes+5), (1,1))(P3_output)
 
 P3_downsample = ZeroPadding2D(((1,0),(1,0)))(P3)
 P3_downsample = DarknetConv2D_BN_Leaky(256, (3,3), strides=(2,2))(P3_downsample)
 P4 = Concatenate()([P3_downsample, P4])
 P4 = make_five_convs(P4,256)
 
 # 38x38的out
 P4_output = DarknetConv2D_BN_Leaky(512, (3,3))(P4)
 P4_output = DarknetConv2D(num_anchors*(num_classes+5), (1,1))(P4_output)
 
 
 P4_downsample = ZeroPadding2D(((1,0),(1,0)))(P4)
 P4_downsample = DarknetConv2D_BN_Leaky(512, (3,3), strides=(2,2))(P4_downsample)
 P5 = Concatenate()([P4_downsample, P5])
 P5 = make_five_convs(P5,512)
 
 # 19x19的out
 P5_output = DarknetConv2D_BN_Leaky(1024, (3,3))(P5)
 P5_output = DarknetConv2D(num_anchors*(num_classes+5), (1,1))(P5_output)
 
 return Model(inputs, [P5_output, P4_output, P3_output])

## 3、YoloHead利用获得到的特征进行预测 ##

2、输出层的shape分别为(**19,19,75**)，(**38,38,75**)，(**76,76,75**)，**最后一个维度为75是因为该图是基于voc数据集的，它的类为20种，YoloV4只有针对每一个特征层存在3个先验框，所以最后维度为3x25；  
如果使用的是coco训练集，类则为80种，最后的维度应该为255 = 3x85**，三个特征层的shape为(**19,19,255**)，(**38,38,255**)，(**76,76,255**)

实现代码如下：

#---------------------------------------------------#
 # 特征层->最后的输出
 #---------------------------------------------------#
 def yolo_body(inputs, num_anchors, num_classes):
 # 省略了一部分，只看最后的head部分
 P3_output = DarknetConv2D_BN_Leaky(256, (3,3))(P3)
 P3_output = DarknetConv2D(num_anchors*(num_classes+5), (1,1))(P3_output)
 P4_output = DarknetConv2D_BN_Leaky(512, (3,3))(P4)
 P4_output = DarknetConv2D(num_anchors*(num_classes+5), (1,1))(P4_output)
 
 P5_output = DarknetConv2D_BN_Leaky(1024, (3,3))(P5)
 P5_output = DarknetConv2D(num_anchors*(num_classes+5), (1,1))(P5_output)

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13

## 4、预测结果的解码 ##

由第二步我们可以获得三个特征层的预测结果，shape分别为(**N,19,19,255**)，(**N,38,38,255**)，(**N,76,76,255**)的数据，对应每个图分为19x19、38x38、76x76的网格上3个预测框的位置。

但是这个预测结果并不对应着最终的预测框在图片上的位置，还需要解码才可以完成。

此处要讲一下yolo3的预测原理，yolo3的3个特征层分别将整幅图分为19x19、38x38、76x76的网格，每个网络点负责一个区域的检测。

我们知道特征层的预测结果对应着三个预测框的位置，我们先将其reshape一下，其结果为(**N,19,19,3,85**)，(**N,38,38,3,85**)，(**N,76,76,3,85**)。

最后一个维度中的85包含了4+1+80，**分别代表x\_offset、y\_offset、h和w、置信度、分类结果。**

yolo3的解码过程就是**将每个网格点加上它对应的x\_offset和y\_offset**，加完后的结果就是**预测框的中心**，然后**再利用 先验框和h、w结合 计算出预测框的长和宽**。这样就能得到整个预测框的位置了。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 6]  
当然得到最终的预测结构后还要进行得分排序与非极大抑制筛选  
这一部分基本上是所有目标检测通用的部分。不过该项目的处理方式与其它项目不同。其对于每一个类进行判别。  
**1、取出每一类得分大于self.obj\_threshold的框和得分。  
2、利用框的位置和得分进行非极大抑制。**

实现代码如下，当调用yolo\_eval时，就会对每个特征层进行解码：

#---------------------------------------------------#
 # 将预测值的每个特征层调成真实值
 #---------------------------------------------------#
 def yolo_head(feats, anchors, num_classes, input_shape, calc_loss=False):
 num_anchors = len(anchors)
 # [1, 1, 1, num_anchors, 2]
 anchors_tensor = K.reshape(K.constant(anchors), [1, 1, 1, num_anchors, 2])
 # 获得x，y的网格
 # (19, 19, 1, 2)
 grid_shape = K.shape(feats)[1:3] # height, width
 grid_y = K.tile(K.reshape(K.arange(0, stop=grid_shape[0]), [-1, 1, 1, 1]),
 [1, grid_shape[1], 1, 1])
 grid_x = K.tile(K.reshape(K.arange(0, stop=grid_shape[1]), [1, -1, 1, 1]),
 [grid_shape[0], 1, 1, 1])
 grid = K.concatenate([grid_x, grid_y])
 grid = K.cast(grid, K.dtype(feats))
 
 # (batch_size,19,19,3,85)
 feats = K.reshape(feats, [-1, grid_shape[0], grid_shape[1], num_anchors, num_classes + 5])
 
 # 将预测值调成真实值
 # box_xy对应框的中心点
 # box_wh对应框的宽和高
 box_xy = (K.sigmoid(feats[..., :2]) + grid) / K.cast(grid_shape[::-1], K.dtype(feats))
 box_wh = K.exp(feats[..., 2:4]) * anchors_tensor / K.cast(input_shape[::-1], K.dtype(feats))
 box_confidence = K.sigmoid(feats[..., 4:5])
 box_class_probs = K.sigmoid(feats[..., 5:])
 
 # 在计算loss的时候返回如下参数
 if calc_loss == True:
 return grid, feats, box_xy, box_wh
 return box_xy, box_wh, box_confidence, box_class_probs

\#---------------------------------------------------\#  
\# 对box进行调整，使其符合真实图片的样子  
\#---------------------------------------------------\#  
def yolo\_correct\_boxes(box\_xy, box\_wh, input\_shape, image\_shape):  
box\_yx = box\_xy\[..., ::\-1\]  
box\_hw = box\_wh\[..., ::\-1\]

input_shape = K.cast(input_shape, K.dtype(box_yx))
 image_shape = K.cast(image_shape, K.dtype(box_yx))
 
 new_shape = K.round(image_shape * K.min(input_shape/image_shape))
 offset = (input_shape-new_shape)/2./input_shape
 scale = input_shape/new_shape
 
 box_yx = (box_yx - offset) * scale
 box_hw *= scale
 
 box_mins = box_yx - (box_hw / 2.)
 box_maxes = box_yx + (box_hw / 2.)
 boxes = K.concatenate([
 box_mins[..., 0:1], # y_min
 box_mins[..., 1:2], # x_min
 box_maxes[..., 0:1], # y_max
 box_maxes[..., 1:2] # x_max
 ])
 
 boxes *= K.concatenate([image_shape, image_shape])
 return boxes

\#---------------------------------------------------\#  
\# 获取每个box和它的得分  
\#---------------------------------------------------\#  
def yolo\_boxes\_and\_scores(feats, anchors, num\_classes, input\_shape, image\_shape):  
\# 将预测值调成真实值  
\# box\_xy对应框的中心点  
\# box\_wh对应框的宽和高  
\# -1,19,19,3,2; -1,19,19,3,2; -1,19,19,3,1; -1,19,19,3,80  
box\_xy, box\_wh, box\_confidence, box\_class\_probs = yolo\_head(feats, anchors, num\_classes, input\_shape)  
\# 将box\_xy、和box\_wh调节成y\_min,y\_max,xmin,xmax  
boxes = yolo\_correct\_boxes(box\_xy, box\_wh, input\_shape, image\_shape)  
\# 获得得分和box  
boxes = K.reshape(boxes, \[\-1, 4\])  
box\_scores = box\_confidence \* box\_class\_probs  
box\_scores = K.reshape(box\_scores, \[\-1, num\_classes\])  
return boxes, box\_scores

\#---------------------------------------------------\#  
\# 图片预测  
\#---------------------------------------------------\#  
def yolo\_eval(yolo\_outputs,  
anchors,  
num\_classes,  
image\_shape,  
max\_boxes=20,  
score\_threshold=.6,  
iou\_threshold=.5):  
\# 获得特征层的数量  
num\_layers = len(yolo\_outputs)  
\# 特征层1对应的anchor是678  
\# 特征层2对应的anchor是345  
\# 特征层3对应的anchor是012  
anchor\_mask = \[\[6,7,8\], \[3,4,5\], \[0,1,2\]\]

input_shape = K.shape(yolo_outputs[0])[1:3] * 32
 boxes = []
 box_scores = []
 # 对每个特征层进行处理
 for l in range(num_layers):
 _boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l], anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
 boxes.append(_boxes)
 box_scores.append(_box_scores)
 # 将每个特征层的结果进行堆叠
 boxes = K.concatenate(boxes, axis=0)
 box_scores = K.concatenate(box_scores, axis=0)
 
 mask = box_scores >= score_threshold
 max_boxes_tensor = K.constant(max_boxes, dtype='int32')
 boxes_ = []
 scores_ = []
 classes_ = []
 for c in range(num_classes):
 # 取出所有box_scores >= score_threshold的框，和成绩
 class_boxes = tf.boolean_mask(boxes, mask[:, c])
 class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
 
 # 非极大抑制，去掉box重合程度高的那一些
 nms_index = tf.image.non_max_suppression(
 class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
 
 # 获取非极大抑制后的结果
 # 下列三个分别是
 # 框的位置，得分与种类
 class_boxes = K.gather(class_boxes, nms_index)
 class_box_scores = K.gather(class_box_scores, nms_index)
 classes = K.ones_like(class_box_scores, 'int32') * c
 boxes_.append(class_boxes)
 scores_.append(class_box_scores)
 classes_.append(classes)
 boxes_ = K.concatenate(boxes_, axis=0)
 scores_ = K.concatenate(scores_, axis=0)
 classes_ = K.concatenate(classes_, axis=0)
 
 return boxes_, scores_, classes_

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37
 *  38
 *  39
 *  40
 *  41
 *  42
 *  43
 *  44
 *  45
 *  46
 *  47
 *  48
 *  49
 *  50
 *  51
 *  52
 *  53
 *  54
 *  55
 *  56
 *  57
 *  58
 *  59
 *  60
 *  61
 *  62
 *  63
 *  64
 *  65
 *  66
 *  67
 *  68
 *  69
 *  70
 *  71
 *  72
 *  73
 *  74
 *  75
 *  76
 *  77
 *  78
 *  79
 *  80
 *  81
 *  82
 *  83
 *  84
 *  85
 *  86
 *  87
 *  88
 *  89
 *  90
 *  91
 *  92
 *  93
 *  94
 *  95
 *  96
 *  97
 *  98
 *  99
 *  100
 *  101
 *  102
 *  103
 *  104
 *  105
 *  106
 *  107
 *  108
 *  109
 *  110
 *  111
 *  112
 *  113
 *  114
 *  115
 *  116
 *  117
 *  118
 *  119
 *  120
 *  121
 *  122
 *  123
 *  124
 *  125
 *  126
 *  127
 *  128
 *  129
 *  130
 *  131
 *  132
 *  133
 *  134
 *  135
 *  136
 *  137

## 5、在原图上进行绘制 ##

通过第四步，我们可以获得预测框在原图上的位置，而且这些预测框都是经过筛选的。这些筛选后的框可以直接绘制在图片上，就可以获得结果了。

# YOLOV4的训练 #

## 1、YOLOV4的改进训练技巧 ##

### a)、Mosaic数据增强 ###

Yolov4的mosaic数据增强参考了CutMix数据增强方式，理论上具有一定的相似性！  
**CutMix数据增强方式利用两张图片进行拼接。**  
![在这里插入图片描述][20200508145223449.png_pic_center]  
但是mosaic利用了四张图片，**根据论文所说其拥有一个巨大的优点是丰富检测物体的背景！且在BN计算的时候一下子会计算四张图片的数据！**  
就像下图这样：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 7]  
实现思路如下：  
1、每次读取四张图片。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 8]  
![在这里插入图片描述][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 11]  
2、分别对四张图片进行翻转、缩放、色域变化等，并且按照四个方向位置摆好。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 12]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 13]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 14]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 15]  
3、进行图片的组合和框的组合  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 16]

def rand(a=0, b=1):
        return np.random.rand()*(b-a) + a

def merge\_bboxes(bboxes, cutx, cuty):

merge_bbox = []
 for i in range(len(bboxes)):
 for box in bboxes[i]:
 tmp_box = []
 x1,y1,x2,y2 = box[0], box[1], box[2], box[3]
 
 if i == 0:
 if y1 > cuty or x1 > cutx:
 continue
 if y2 >= cuty and y1 <= cuty:
 y2 = cuty
 if y2-y1 < 5:
 continue
 if x2 >= cutx and x1 <= cutx:
 x2 = cutx
 if x2-x1 < 5:
 continue
 
 if i == 1:
 if y2 < cuty or x1 > cutx:
 continue
 
 if y2 >= cuty and y1 <= cuty:
 y1 = cuty
 if y2-y1 < 5:
 continue
 
 if x2 >= cutx and x1 <= cutx:
 x2 = cutx
 if x2-x1 < 5:
 continue
 
 if i == 2:
 if y2 < cuty or x2 < cutx:
 continue
 
 if y2 >= cuty and y1 <= cuty:
 y1 = cuty
 if y2-y1 < 5:
 continue
 
 if x2 >= cutx and x1 <= cutx:
 x1 = cutx
 if x2-x1 < 5:
 continue
 
 if i == 3:
 if y1 > cuty or x2 < cutx:
 continue
 
 if y2 >= cuty and y1 <= cuty:
 y2 = cuty
 if y2-y1 < 5:
 continue
 
 if x2 >= cutx and x1 <= cutx:
 x1 = cutx
 if x2-x1 < 5:
 continue
 
 tmp_box.append(x1)
 tmp_box.append(y1)
 tmp_box.append(x2)
 tmp_box.append(y2)
 tmp_box.append(box[-1])
 merge_bbox.append(tmp_box)
 return merge_bbox

def get\_random\_data(annotation\_line, input\_shape, random=True, hue=.1, sat=1.5, val=1.5, proc\_img=True):  
‘’‘random preprocessing for real-time data augmentation’’’  
h, w = input\_shape  
min\_offset\_x = 0.4  
min\_offset\_y = 0.4  
scale\_low = 1\-min(min\_offset\_x,min\_offset\_y)  
scale\_high = scale\_low\+0.2

image_datas = [] 
 box_datas = []
 index = 0
 
 place_x = [0,0,int(w*min_offset_x),int(w*min_offset_x)]
 place_y = [0,int(h*min_offset_y),int(w*min_offset_y),0]
 for line in annotation_line:
 # 每一行进行分割
 line_content = line.split()
 # 打开图片
 image = Image.open(line_content[0])
 image = image.convert("RGB") 
 # 图片的大小
 iw, ih = image.size
 # 保存框的位置
 box = np.array([np.array(list(map(int,box.split(',')))) for box in line_content[1:]])
 
 # image.save(str(index)+".jpg")
 # 是否翻转图片
 flip = rand()<.5
 if flip and len(box)>0:
 image = image.transpose(Image.FLIP_LEFT_RIGHT)
 box[:, [0,2]] = iw - box[:, [2,0]]
 
 # 对输入进来的图片进行缩放
 new_ar = w/h
 scale = rand(scale_low, scale_high)
 if new_ar < 1:
 nh = int(scale*h)
 nw = int(nh*new_ar)
 else:
 nw = int(scale*w)
 nh = int(nw/new_ar)
 image = image.resize((nw,nh), Image.BICUBIC)
 
 # 进行色域变换
 hue = rand(-hue, hue)
 sat = rand(1, sat) if rand()<.5 else 1/rand(1, sat)
 val = rand(1, val) if rand()<.5 else 1/rand(1, val)
 x = rgb_to_hsv(np.array(image)/255.)
 x[..., 0] += hue
 x[..., 0][x[..., 0]>1] -= 1
 x[..., 0][x[..., 0]<0] += 1
 x[..., 1] *= sat
 x[..., 2] *= val
 x[x>1] = 1
 x[x<0] = 0
 image = hsv_to_rgb(x)
 
 image = Image.fromarray((image*255).astype(np.uint8))
 # 将图片进行放置，分别对应四张分割图片的位置
 dx = place_x[index]
 dy = place_y[index]
 new_image = Image.new('RGB', (w,h), (128,128,128))
 new_image.paste(image, (dx, dy))
 image_data = np.array(new_image)/255
 
 # Image.fromarray((image_data*255).astype(np.uint8)).save(str(index)+"distort.jpg")
 
 index = index + 1
 box_data = []
 # 对box进行重新处理
 if len(box)>0:
 np.random.shuffle(box)
 box[:, [0,2]] = box[:, [0,2]]*nw/iw + dx
 box[:, [1,3]] = box[:, [1,3]]*nh/ih + dy
 box[:, 0:2][box[:, 0:2]<0] = 0
 box[:, 2][box[:, 2]>w] = w
 box[:, 3][box[:, 3]>h] = h
 box_w = box[:, 2] - box[:, 0]
 box_h = box[:, 3] - box[:, 1]
 box = box[np.logical_and(box_w>1, box_h>1)]
 box_data = np.zeros((len(box),5))
 box_data[:len(box)] = box
 
 image_datas.append(image_data)
 box_datas.append(box_data)
 
 img = Image.fromarray((image_data*255).astype(np.uint8))
 for j in range(len(box_data)):
 thickness = 3
 left, top, right, bottom = box_data[j][0:4]
 draw = ImageDraw.Draw(img)
 for i in range(thickness):
 draw.rectangle([left + i, top + i, right - i, bottom - i],outline=(255,255,255))
 img.show()
 
 
 # 将图片分割，放在一起
 cutx = np.random.randint(int(w*min_offset_x), int(w*(1 - min_offset_x)))
 cuty = np.random.randint(int(h*min_offset_y), int(h*(1 - min_offset_y)))
 
 new_image = np.zeros([h,w,3])
 new_image[:cuty, :cutx, :] = image_datas[0][:cuty, :cutx, :]
 new_image[cuty:, :cutx, :] = image_datas[1][cuty:, :cutx, :]
 new_image[cuty:, cutx:, :] = image_datas[2][cuty:, cutx:, :]
 new_image[:cuty, cutx:, :] = image_datas[3][:cuty, cutx:, :]
 
 # 对框进行进一步的处理
 new_boxes = merge_bboxes(box_datas, cutx, cuty)
 
 return new_image, new_boxes

### b)、Label Smoothing平滑 ###

标签平滑的思想很简单，具体公式如下：

new_onehot_labels = onehot_labels * (1 - label_smoothing) + label_smoothing / num_classes
    
     
      
     
      
       1

当label\_smoothing的值为0.01得时候，公式变成如下所示：

new_onehot_labels = y * (1 - 0.01) + 0.01 / num_classes
    
     
      
     
      
       1

其实Label Smoothing平滑就是将标签进行一个平滑，原始的标签是0、1，在平滑后变成0.005(如果是二分类)、0.995，**也就是说对分类准确做了一点惩罚，让模型不可以分类的太准确，太准确容易过拟合。**

实现代码如下：

#---------------------------------------------------#
    # 平滑标签
    #---------------------------------------------------#
    def _smooth_labels(y_true, label_smoothing):
        num_classes = K.shape(y_true)[-1],
        label_smoothing = K.constant(label_smoothing, dtype=K.floatx())
        return y_true * (1.0 - label_smoothing) + label_smoothing / num_classes
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7

### c)、CIOU ###

IoU是比值的概念，对目标物体的scale是不敏感的。**然而常用的BBox的回归损失优化和IoU优化不是完全等价的，寻常的IoU无法直接优化没有重叠的部分。**

于是有人提出直接使用IOU作为回归优化loss，CIOU是其中非常优秀的一种想法。

CIOU将目标与anchor之间的距离，重叠率、尺度以及惩罚项都考虑进去，**使得目标框回归变得更加稳定，不会像IoU和GIoU一样出现训练过程中发散等问题。而惩罚因子把预测框长宽比拟合目标框的长宽比考虑进去。**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 17]  
CIOU公式如下  
 C I O U = I O U − ρ 2 ( b , b g t ) c 2 − α v C I O U = I O U − ρ 2 ( b , b g t ) c 2 − α v C I O U = I O U − ρ 2 ( b , b g t ) c 2 − α v CIOU=IOU−ρ2(b,bgt)c2−αvCIOU=IOU−ρ2(b,bgt)c2−αv CIOU = IOU - \\frac\{\\rho^2(b,b^\{gt\})\}\{c^2\} - \\alpha v CIOU=IOU−ρ2(b,bgt)c2−αvCIOU=IOU−ρ2(b,bgt)c2−αvCIOU=IOU−c2ρ2(b,bgt)−αvLOSSCIOU=1−IOU\+c2ρ2(b,bgt)\+αv

def box_ciou(b1, b2):
 """
 输入为：
 ----------
 b1: tensor, shape=(batch, feat_w, feat_h, anchor_num, 4), xywh
 b2: tensor, shape=(batch, feat_w, feat_h, anchor_num, 4), xywh
 返回为：
 -------
 ciou: tensor, shape=(batch, feat_w, feat_h, anchor_num, 1)
 """
 # 求出预测框左上角右下角
 b1_xy = b1[..., :2]
 b1_wh = b1[..., 2:4]
 b1_wh_half = b1_wh/2.
 b1_mins = b1_xy - b1_wh_half
 b1_maxes = b1_xy + b1_wh_half
 # 求出真实框左上角右下角
 b2_xy = b2[..., :2]
 b2_wh = b2[..., 2:4]
 b2_wh_half = b2_wh/2.
 b2_mins = b2_xy - b2_wh_half
 b2_maxes = b2_xy + b2_wh_half
 
 # 求真实框和预测框所有的iou
 intersect_mins = K.maximum(b1_mins, b2_mins)
 intersect_maxes = K.minimum(b1_maxes, b2_maxes)
 intersect_wh = K.maximum(intersect_maxes - intersect_mins, 0.)
 intersect_area = intersect_wh[..., 0] * intersect_wh[..., 1]
 b1_area = b1_wh[..., 0] * b1_wh[..., 1]
 b2_area = b2_wh[..., 0] * b2_wh[..., 1]
 union_area = b1_area + b2_area - intersect_area
 iou = intersect_area / (union_area + K.epsilon())
 
 # 计算中心的差距
 center_distance = K.sum(K.square(b1_xy - b2_xy), axis=-1<span class="token punctuat

[https_blog.csdn.net_weixin_44791964_article_details_106014717]: https://blog.csdn.net/weixin_44791964/article/details/106014717
[20190723165901974.jpg_pic_center]: https://img-blog.csdnimg.cn/20190723165901974.jpg#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20200509111027627.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center
[https_blog.csdn.net_weixin_44791964_article_details_103276106]: https://blog.csdn.net/weixin_44791964/article/details/103276106
[https_github.com_bubbliiiing_yolov4-keras]: https://github.com/bubbliiiing/yolov4-keras
[https_www.bilibili.com_video_BV1kt4y117G6]: https://www.bilibili.com/video/BV1kt4y117G6
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_cneter]: https://img-blog.csdnimg.cn/20200512144007178.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_cneter
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_cneter 1]: https://img-blog.csdnimg.cn/20200509213429592.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_cneter
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20200509115101964.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20200509113651540.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20200509215346310.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/20200509214653559.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 5]: https://img-blog.csdnimg.cn/20200509215322866.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 6]: https://img-blog.csdnimg.cn/20191120215015351.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center
[20200508145223449.png_pic_center]: https://img-blog.csdnimg.cn/20200508145223449.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 7]: https://img-blog.csdnimg.cn/20200508145439305.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 8]: https://img-blog.csdnimg.cn/20200508155913308.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 9]: https://img-blog.csdnimg.cn/20200508155925719.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 10]: https://img-blog.csdnimg.cn/20200508155933988.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 11]: https://img-blog.csdnimg.cn/20200508155946892.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 12]: https://img-blog.csdnimg.cn/20200508160000580.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 13]: https://img-blog.csdnimg.cn/20200508160015434.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 14]: https://img-blog.csdnimg.cn/20200508160028438.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 15]: https://img-blog.csdnimg.cn/20200508160038303.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 16]: https://img-blog.csdnimg.cn/20200508160045845.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 17]: https://img-blog.csdnimg.cn/20200425144646161.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center