(大佬)睿智的目标检测16——Keras搭建SSD目标检测平台

你的名字 2022-12-02 15:20 244阅读 0赞

原文链接：[https://blog.csdn.net/weixin\_44791964/article/details/104107271?ops\_request\_misc=%257B%2522request%255Fid%2522%253A%2522159887794019725254051093%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request\_id=159887794019725254051093&biz\_id=0&utm\_medium=distribute.pc\_search\_result.none-task-blog-2blogfirst\_rank\_v1~rank\_blog\_v1-1-104107271.pc\_v1\_rank\_blog\_v1&utm\_term=ssd&spm=1018.2118.3001.4187][https_blog.csdn.net_weixin_44791964_article_details_104107271_ops_request_misc_257B_2522request_255Fid_2522_253A_2522159887794019725254051093_2522_252C_2522scm_2522_253A_252220140713.130102334.pc_255Fblog._2522_257D_request_id_159887794019725254051093_biz_id_0_utm_medium_distribute.pc_search_result.none-task-blog-2blogfirst_rank_v1_rank_blog_v1-1-104107271.pc_v1_rank_blog_v1_utm_term_ssd_spm_1018.2118.3001.4187]

### 睿智的目标检测16—Keras搭建SSD目标检测平台 ###

*  学习前言
 *  什么是SSD目标检测算法
 *  源码下载
 *  SSD实现思路
 *   *  一、预测部分
     *   *  1、主干网络介绍
         *  2、从特征获取预测结果
         *  3、预测结果的解码
         *  4、在原图上进行绘制
     *  二、训练部分
     *   *  1、真实框的处理
         *  2、利用处理完的真实框与对应图片的预测结果计算loss
 *  训练自己的ssd模型

# 学习前言 #

一起来看看SSD的keras实现吧，顺便训练一下自己的数据。  
![在这里插入图片描述][20190723165901974.jpg_pic_center]

# 什么是SSD目标检测算法 #

SSD是一种非常优秀的one-stage目标检测方法，one-stage算法就是目标检测和分类是同时完成的，**其主要思路是利用CNN提取特征后，均匀地在图片的不同位置进行密集抽样，抽样时可以采用不同尺度和长宽比，物体分类与预测框的回归同时进行，整个过程只需要一步，所以其优势是速度快**。  
但是均匀的密集采样的一个重要缺点是训练比较困难，这主要是因为正样本与负样本（背景）极其不均衡（参见Focal Loss），导致模型准确度稍低。  
**SSD的英文全名是Single Shot MultiBox Detector，Single shot说明SSD算法属于one-stage方法，MultiBox说明SSD算法基于多框预测。**

# 源码下载 #

[https://github.com/bubbliiiing/ssd-keras][https_github.com_bubbliiiing_ssd-keras]  
喜欢的可以点个star噢。

# SSD实现思路 #

## 一、预测部分 ##

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70]  
SSD采用的主干网络是VGG网络，关于VGG的介绍大家可以看我的另外一篇博客[https://blog.csdn.net/weixin\_44791964/article/details/102779878][https_blog.csdn.net_weixin_44791964_article_details_102779878]，这里的VGG网络相比普通的VGG网络有一定的修改，主要修改的地方就是：  
**1、将VGG16的FC6和FC7层转化为卷积层。  
2、去掉所有的Dropout层和FC8层；  
3、新增了Conv6、Conv7、Conv8、Conv9。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70 1]  
如图所示，输入的图片经过了**改进的VGG网络**（Conv1->fc7）和几个另加的卷积层（Conv6->Conv9），进行特征提取：  
**a、输入一张图片后，被resize到300x300的shape**

**b、conv1，经过两次\[3,3\]卷积网络，输出的特征层为64，输出为(300,300,64)，再2X2最大池化，输出net为(150,150,64)。**

**c、conv2，经过两次\[3,3\]卷积网络，输出的特征层为128，输出net为(150,150,128)，再2X2最大池化，输出net为(75,75,128)。**

**d、conv3，经过三次\[3,3\]卷积网络，输出的特征层为256，输出net为(75,75,256)，再2X2最大池化，输出net为(38,38,256)。**

**e、conv4，经过三次\[3,3\]卷积网络，输出的特征层为512，输出net为(38,38,512)，再2X2最大池化，输出net为(19,19,512)。**

**f、conv5，经过三次\[3,3\]卷积网络，输出的特征层为512，输出net为(19,19,512)，再3X3最大池化，输出net为(19,19,512)。**

**g、利用卷积代替全连接层，进行了一次\[3,3\]卷积网络和一次\[1,1\]卷积网络，输出的特征层为1024，因此输出的net为(19,19,1024)。**（从这里往前都是VGG的结构）

**h、conv6，经过一次\[1,1\]卷积网络，调整通道数，一次步长为2的\[3,3\]卷积网络，输出的特征层为512，因此输出的net为(10,10,512)。**

**i、conv7，经过一次\[1,1\]卷积网络，调整通道数，一次步长为2的\[3,3\]卷积网络，输出的特征层为256，因此输出的net为(5,5,256)。**

**j、conv8，经过一次\[1,1\]卷积网络，调整通道数，一次padding为valid的\[3,3\]卷积网络，输出的特征层为256，因此输出的net为(3,3,256)。**

**k、conv9，经过一次\[1,1\]卷积网络，调整通道数，一次padding为valid的\[3,3\]卷积网络，输出的特征层为256，因此输出的net为(1,1,256)。**

实现代码：

import keras.backend as K
    from keras.layers import Activation
    from keras.layers import Conv2D
    from keras.layers import Dense
    from keras.layers import Flatten
    from keras.layers import GlobalAveragePooling2D
    from keras.layers import Input
    from keras.layers import MaxPooling2D
    from keras.layers import merge, concatenate
    from keras.layers import Reshape
    from keras.layers import ZeroPadding2D
    from keras.models import Model

def VGG16(input\_tensor):  
\#----------------------------主干特征提取网络开始---------------------------\#  
\# SSD结构,net字典  
net = \{ \}  
\# Block 1  
net\[‘input’\] = input\_tensor  
\# 300,300,3 -> 150,150,64  
net\[‘conv1\_1’\] = Conv2D(64, kernel\_size=(3,3),  
activation=‘relu’,  
padding=‘same’,  
name=‘conv1\_1’)(net\[‘input’\])  
net\[‘conv1\_2’\] = Conv2D(64, kernel\_size=(3,3),  
activation=‘relu’,  
padding=‘same’,  
name=‘conv1\_2’)(net\[‘conv1\_1’\])  
net\[‘pool1’\] = MaxPooling2D((2, 2), strides=(2, 2), padding=‘same’,  
name=‘pool1’)(net\[‘conv1\_2’\])

# Block 2
 # 150,150,64 -> 75,75,128
 net['conv2_1'] = Conv2D(128, kernel_size=(3,3),
 activation='relu',
 padding='same',
 name='conv2_1')(net['pool1'])
 net['conv2_2'] = Conv2D(128, kernel_size=(3,3),
 activation='relu',
 padding='same',
 name='conv2_2')(net['conv2_1'])
 net['pool2'] = MaxPooling2D((2, 2), strides=(2, 2), padding='same',
 name='pool2')(net['conv2_2'])
 # Block 3
 # 75,75,128 -> 38,38,256
 net['conv3_1'] = Conv2D(256, kernel_size=(3,3),
 activation='relu',
 padding='same',
 name='conv3_1')(net['pool2'])
 net['conv3_2'] = Conv2D(256, kernel_size=(3,3),
 activation='relu',
 padding='same',
 name='conv3_2')(net['conv3_1'])
 net['conv3_3'] = Conv2D(256, kernel_size=(3,3),
 activation='relu',
 padding='same',
 name='conv3_3')(net['conv3_2'])
 net['pool3'] = MaxPooling2D((2, 2), strides=(2, 2), padding='same',
 name='pool3')(net['conv3_3'])
 # Block 4
 # 38,38,256 -> 19,19,512
 net['conv4_1'] = Conv2D(512, kernel_size=(3,3),
 activation='relu',
 padding='same',
 name='conv4_1')(net['pool3'])
 net['conv4_2'] = Conv2D(512, kernel_size=(3,3),
 activation='relu',
 padding='same',
 name='conv4_2')(net['conv4_1'])
 net['conv4_3'] = Conv2D(512, kernel_size=(3,3),
 activation='relu',
 padding='same',
 name='conv4_3')(net['conv4_2'])
 net['pool4'] = MaxPooling2D((2, 2), strides=(2, 2), padding='same',
 name='pool4')(net['conv4_3'])
 # Block 5
 # 19,19,512 -> 19,19,512
 net['conv5_1'] = Conv2D(512, kernel_size=(3,3),
 activation='relu',
 padding='same',
 name='conv5_1')(net['pool4'])
 net['conv5_2'] = Conv2D(512, kernel_size=(3,3),
 activation='relu',
 padding='same',
 name='conv5_2')(net['conv5_1'])
 net['conv5_3'] = Conv2D(512, kernel_size=(3,3),
 activation='relu',
 padding='same',
 name='conv5_3')(net['conv5_2'])
 net['pool5'] = MaxPooling2D((3, 3), strides=(1, 1), padding='same',
 name='pool5')(net['conv5_3'])
 # FC6
 # 19,19,512 -> 19,19,1024
 net['fc6'] = Conv2D(1024, kernel_size=(3,3), dilation_rate=(6, 6),
 activation='relu', padding='same',
 name='fc6')(net['pool5'])
 
 # x = Dropout(0.5, name='drop6')(x)
 # FC7
 # 19,19,1024 -> 19,19,1024
 net['fc7'] = Conv2D(1024, kernel_size=(1,1), activation='relu',
 padding='same', name='fc7')(net['fc6'])
 
 # x = Dropout(0.5, name='drop7')(x)
 # Block 6
 # 19,19,512 -> 10,10,512
 net['conv6_1'] = Conv2D(256, kernel_size=(1,1), activation='relu',
 padding='same',
 name='conv6_1')(net['fc7'])
 net['conv6_2'] = ZeroPadding2D(padding=((1, 1), (1, 1)), name='conv6_padding')(net['conv6_1'])
 net['conv6_2'] = Conv2D(512, kernel_size=(3,3), strides=(2, 2),
 activation='relu',
 name='conv6_2')(net['conv6_2'])
 
 # Block 7
 # 10,10,512 -> 5,5,256
 net['conv7_1'] = Conv2D(128, kernel_size=(1,1), activation='relu',
 padding='same', 
 name='conv7_1')(net['conv6_2'])
 net['conv7_2'] = ZeroPadding2D(padding=((1, 1), (1, 1)), name='conv7_padding')(net['conv7_1'])
 net['conv7_2'] = Conv2D(256, kernel_size=(3,3), strides=(2, 2),
 activation='relu', padding='valid',
 name='conv7_2')(net['conv7_2'])
 # Block 8
 # 5,5,256 -> 3,3,256
 net['conv8_1'] = Conv2D(128, kernel_size=(1,1), activation='relu',
 padding='same',
 name='conv8_1')(net['conv7_2'])
 net['conv8_2'] = Conv2D(256, kernel_size=(3,3), strides=(1, 1),
 activation='relu', padding='valid',
 name='conv8_2')(net['conv8_1'])
 
 # Block 9
 # 3,3,256 -> 1,1,256
 net['conv9_1'] = Conv2D(128, kernel_size=(1,1), activation='relu',
 padding='same',
 name='conv9_1')(net['conv8_2'])
 net['conv9_2'] = Conv2D(256, kernel_size=(3,3), strides=(1, 1),
 activation='relu', padding='valid',
 name='conv9_2')(net['conv9_1'])
 #----------------------------主干特征提取网络结束---------------------------#
 return net

*  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
 *  138
 *  139
 *  140
 *  141
 *  142
 *  143

### 2、从特征获取预测结果 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70]  
由上图我们可以知道，我们分别取**conv4的第三次卷积的特征、fc7的特征、conv6的第二次卷积的特征、conv7的第二次卷积的特征、conv8的第二次卷积的特征、conv9的第二次卷积的特征**，为了和普通特征层区分，我们称之为**有效特征层**，来获取预测结果。

对获取到的**每一个有效特征层，我们分别对其进行一次num\_priors x 4的卷积、一次num\_priors x num\_classes的卷积、并需要计算每一个有效特征层对应的先验框。而num\_priors指的是该特征层所拥有的先验框数量。**

其中：  
**num\_priors x 4的卷积** 用于预测 **该特征层上** **每一个网格点上 每一个先验框**的变化情况。**（为什么说是变化情况呢，这是因为ssd的预测结果需要结合先验框获得预测框，预测结果就是先验框的变化情况。）**

**num\_priors x num\_classes的卷积** 用于预测 **该特征层上** **每一个网格点上** **每一个预测框**对应的种类。

每一个有效特征层对应的先验框对应着**该特征层上** **每一个网格点上 预先设定好的多个框。**

所有的特征层对应的预测结果的shape如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center]  
实现代码为：

def SSD300(input_shape, num_classes=21):
 # 300,300,3
 input_tensor = Input(shape=input_shape)
 img_size = (input_shape[1], input_shape[0])
 # SSD结构,net字典
 net = VGG16(input_tensor)
 #-----------------------将提取到的主干特征进行处理---------------------------#
 # 对conv4_3进行处理 38,38,512
 net['conv4_3_norm'] = Normalize(20, name='conv4_3_norm')(net['conv4_3'])
 num_priors = 4
 # 预测框的处理
 # num_priors表示每个网格点先验框的数量，4是x,y,h,w的调整
 net['conv4_3_norm_mbox_loc'] = Conv2D(num_priors * 4, kernel_size=(3,3), padding='same', name='conv4_3_norm_mbox_loc')(net['conv4_3_norm'])
 net['conv4_3_norm_mbox_loc_flat'] = Flatten(name='conv4_3_norm_mbox_loc_flat')(net['conv4_3_norm_mbox_loc'])
 # num_priors表示每个网格点先验框的数量，num_classes是所分的类
 net['conv4_3_norm_mbox_conf'] = Conv2D(num_priors * num_classes, kernel_size=(3,3), padding='same',name='conv4_3_norm_mbox_conf')(net['conv4_3_norm'])
 net['conv4_3_norm_mbox_conf_flat'] = Flatten(name='conv4_3_norm_mbox_conf_flat')(net['conv4_3_norm_mbox_conf'])
 priorbox = PriorBox(img_size, 30.0,max_size = 60.0, aspect_ratios=[2],
 variances=[0.1, 0.1, 0.2, 0.2],
 name='conv4_3_norm_mbox_priorbox')
 net['conv4_3_norm_mbox_priorbox'] = priorbox(net['conv4_3_norm'])
 
 # 对fc7层进行处理 
 num_priors = 6
 # 预测框的处理
 # num_priors表示每个网格点先验框的数量，4是x,y,h,w的调整
 net['fc7_mbox_loc'] = Conv2D(num_priors * 4, kernel_size=(3,3),padding='same',name='fc7_mbox_loc')(net['fc7'])
 net['fc7_mbox_loc_flat'] = Flatten(name='fc7_mbox_loc_flat')(net['fc7_mbox_loc'])
 # num_priors表示每个网格点先验框的数量，num_classes是所分的类
 net['fc7_mbox_conf'] = Conv2D(num_priors * num_classes, kernel_size=(3,3),padding='same',name='fc7_mbox_conf')(net['fc7'])
 net['fc7_mbox_conf_flat'] = Flatten(name='fc7_mbox_conf_flat')(net['fc7_mbox_conf'])
 
 priorbox = PriorBox(img_size, 60.0, max_size=111.0, aspect_ratios=[2, 3],
 variances=[0.1, 0.1, 0.2, 0.2],
 name='fc7_mbox_priorbox')
 net['fc7_mbox_priorbox'] = priorbox(net['fc7'])
 
 # 对conv6_2进行处理
 num_priors = 6
 # 预测框的处理
 # num_priors表示每个网格点先验框的数量，4是x,y,h,w的调整
 x = Conv2D(num_priors * 4, kernel_size=(3,3), padding='same',name='conv6_2_mbox_loc')(net['conv6_2'])
 net['conv6_2_mbox_loc'] = x
 net['conv6_2_mbox_loc_flat'] = Flatten(name='conv6_2_mbox_loc_flat')(net['conv6_2_mbox_loc'])
 # num_priors表示每个网格点先验框的数量，num_classes是所分的类
 x = Conv2D(num_priors * num_classes, kernel_size=(3,3), padding='same',name='conv6_2_mbox_conf')(net['conv6_2'])
 net['conv6_2_mbox_conf'] = x
 net['conv6_2_mbox_conf_flat'] = Flatten(name='conv6_2_mbox_conf_flat')(net['conv6_2_mbox_conf'])
 
 priorbox = PriorBox(img_size, 111.0, max_size=162.0, aspect_ratios=[2, 3],
 variances=[0.1, 0.1, 0.2, 0.2],
 name='conv6_2_mbox_priorbox')
 net['conv6_2_mbox_priorbox'] = priorbox(net['conv6_2'])
 
 # 对conv7_2进行处理
 num_priors = 6
 # 预测框的处理
 # num_priors表示每个网格点先验框的数量，4是x,y,h,w的调整
 x = Conv2D(num_priors * 4, kernel_size=(3,3), padding='same',name='conv7_2_mbox_loc')(net['conv7_2'])
 net['conv7_2_mbox_loc'] = x
 net['conv7_2_mbox_loc_flat'] = Flatten(name='conv7_2_mbox_loc_flat')(net['conv7_2_mbox_loc'])
 # num_priors表示每个网格点先验框的数量，num_classes是所分的类
 x = Conv2D(num_priors * num_classes, kernel_size=(3,3), padding='same',name='conv7_2_mbox_conf')(net['conv7_2'])
 net['conv7_2_mbox_conf'] = x
 net['conv7_2_mbox_conf_flat'] = Flatten(name='conv7_2_mbox_conf_flat')(net['conv7_2_mbox_conf'])
 
 priorbox = PriorBox(img_size, 162.0, max_size=213.0, aspect_ratios=[2, 3],
 variances=[0.1, 0.1, 0.2, 0.2],
 name='conv7_2_mbox_priorbox')
 net['conv7_2_mbox_priorbox'] = priorbox(net['conv7_2'])
 
 # 对conv8_2进行处理
 num_priors = 4
 # 预测框的处理
 # num_priors表示每个网格点先验框的数量，4是x,y,h,w的调整
 x = Conv2D(num_priors * 4, kernel_size=(3,3), padding='same',name='conv8_2_mbox_loc')(net['conv8_2'])
 net['conv8_2_mbox_loc'] = x
 net['conv8_2_mbox_loc_flat'] = Flatten(name='conv8_2_mbox_loc_flat')(net['conv8_2_mbox_loc'])
 # num_priors表示每个网格点先验框的数量，num_classes是所分的类
 x = Conv2D(num_priors * num_classes, kernel_size=(3,3), padding='same',name='conv8_2_mbox_conf')(net['conv8_2'])
 net['conv8_2_mbox_conf'] = x
 net['conv8_2_mbox_conf_flat'] = Flatten(name='conv8_2_mbox_conf_flat')(net['conv8_2_mbox_conf'])
 
 priorbox = PriorBox(img_size, 213.0, max_size=264.0, aspect_ratios=[2],
 variances=[0.1, 0.1, 0.2, 0.2],
 name='conv8_2_mbox_priorbox')
 net['conv8_2_mbox_priorbox'] = priorbox(net['conv8_2'])
 
 # 对conv9_2进行处理
 num_priors = 4
 # 预测框的处理
 # num_priors表示每个网格点先验框的数量，4是x,y,h,w的调整
 x = Conv2D(num_priors * 4, kernel_size=(3,3), padding='same',name='conv9_2_mbox_loc')(net['conv9_2'])
 net['conv9_2_mbox_loc'] = x
 net['conv9_2_mbox_loc_flat'] = Flatten(name='conv9_2_mbox_loc_flat')(net['conv9_2_mbox_loc'])
 # num_priors表示每个网格点先验框的数量，num_classes是所分的类
 x = Conv2D(num_priors * num_classes, kernel_size=(3,3), padding='same',name='conv9_2_mbox_conf')(net['conv9_2'])
 net['conv9_2_mbox_conf'] = x
 net['conv9_2_mbox_conf_flat'] = Flatten(name='conv9_2_mbox_conf_flat')(net['conv9_2_mbox_conf'])
 
 priorbox = PriorBox(img_size, 264.0, max_size=315.0, aspect_ratios=[2],
 variances=[0.1, 0.1, 0.2, 0.2],
 name='conv9_2_mbox_priorbox')
 
 net['conv9_2_mbox_priorbox'] = priorbox(net['conv9_2'])
 
 # 将所有结果进行堆叠
 net['mbox_loc'] = concatenate([net['conv4_3_norm_mbox_loc_flat'],
 net['fc7_mbox_loc_flat'],
 net['conv6_2_mbox_loc_flat'],
 net['conv7_2_mbox_loc_flat'],
 net['conv8_2_mbox_loc_flat'],
 net['conv9_2_mbox_loc_flat']],
 axis=1, name='mbox_loc')
 net['mbox_conf'] = concatenate([net['conv4_3_norm_mbox_conf_flat'],
 net['fc7_mbox_conf_flat'],
 net['conv6_2_mbox_conf_flat'],
 net['conv7_2_mbox_conf_flat'],
 net['conv8_2_mbox_conf_flat'],
 net['conv9_2_mbox_conf_flat']],
 axis=1, name='mbox_conf')
 net['mbox_priorbox'] = concatenate([net['conv4_3_norm_mbox_priorbox'],
 net['fc7_mbox_priorbox'],
 net['conv6_2_mbox_priorbox'],
 net['conv7_2_mbox_priorbox'],
 net['conv8_2_mbox_priorbox'],
 net['conv9_2_mbox_priorbox']],
 axis=1, name='mbox_priorbox')
 
 if hasattr(net['mbox_loc'], '_keras_shape'):
 num_boxes = net['mbox_loc']._keras_shape[-1] // 4
 elif hasattr(net['mbox_loc'], 'int_shape'):
 num_boxes = K.int_shape(net['mbox_loc'])[-1] // 4
 # 8732,4
 net['mbox_loc'] = Reshape((num_boxes, 4),name='mbox_loc_final')(net['mbox_loc'])
 # 8732,21
 net['mbox_conf'] = Reshape((num_boxes, num_classes),name='mbox_conf_logits')(net['mbox_conf'])
 net['mbox_conf'] = Activation('softmax',name='mbox_conf_final')(net['mbox_conf'])
 
 net['predictions'] = concatenate([net['mbox_loc'],
 net['mbox_conf'],
 net['mbox_priorbox']],
 axis=2, name='predictions')
 print(net['predictions'])
 model = Model(net['input'], net['predictions'])
 return model

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

我们通过对每一个特征层的处理，可以获得三个内容，分别是：

**num\_priors x 4的卷积** 用于预测 **该特征层上** **每一个网格点上 每一个先验框**的变化情况。\*\*

**num\_priors x num\_classes的卷积** 用于预测 **该特征层上** **每一个网格点上** **每一个预测框**对应的种类。

每一个有效特征层对应的先验框对应着**该特征层上** **每一个网格点上 预先设定好的多个框。**

我们利用 **num\_priors x 4的卷积** 与 **每一个有效特征层对应的先验框** 获得框的真实位置。

每一个有效特征层对应的先验框就是，如图所示的作用：  
每一个有效特征层将整个图片分成与其长宽对应的网格，**如conv4-3的特征层就是将整个图像分成38x38个网格；然后从每个网格中心建立多个先验框，如conv4-3的特征层就是建立了4个先验框；对于conv4-3的特征层来讲，整个图片被分成38x38个网格，每个网格中心对应4个先验框，一共包含了，38x38x4个，5776个先验框。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 1]  
先验框虽然可以代表一定的**框的位置信息与框的大小信息**，但是其是有限的，无法表示任意情况，因此还需要调整，ssd利用**num\_priors x 4的卷积**的结果对先验框进行调整。

**num\_priors x 4中的num\_priors表示了这个网格点所包含的先验框数量，其中的4表示了x\_offset、y\_offset、h和w的调整情况。**

**x\_offset与y\_offset代表了真实框距离先验框中心的xy轴偏移情况。  
h和w代表了真实框的宽与高相对于先验框的变化情况。**

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

**当然得到最终的预测结构后还要进行得分排序与非极大抑制筛选这一部分基本上是所有目标检测通用的部分。  
1、取出每一类得分大于self.obj\_threshold的框和得分。  
2、利用框的位置和得分进行非极大抑制。**  
实现代码如下：

def decode_boxes(self, mbox_loc, mbox_priorbox, variances):
 # 获得先验框的宽与高
 prior_width = mbox_priorbox[:, 2] - mbox_priorbox[:, 0]
 prior_height = mbox_priorbox[:, 3] - mbox_priorbox[:, 1]
 # 获得先验框的中心点
 prior_center_x = 0.5 * (mbox_priorbox[:, 2] + mbox_priorbox[:, 0])
 prior_center_y = 0.5 * (mbox_priorbox[:, 3] + mbox_priorbox[:, 1])
 # 真实框距离先验框中心的xy轴偏移情况
 decode_bbox_center_x = mbox_loc[:, 0] * prior_width * variances[:, 0]
 decode_bbox_center_x += prior_center_x
 decode_bbox_center_y = mbox_loc[:, 1] * prior_height * variances[:, 1]
 decode_bbox_center_y += prior_center_y
 
 # 真实框的宽与高的求取
 decode_bbox_width = np.exp(mbox_loc[:, 2] * variances[:, 2])
 decode_bbox_width *= prior_width
 decode_bbox_height = np.exp(mbox_loc[:, 3] * variances[:, 3])
 decode_bbox_height *= prior_height
 
 # 获取真实框的左上角与右下角
 decode_bbox_xmin = decode_bbox_center_x - 0.5 * decode_bbox_width
 decode_bbox_ymin = decode_bbox_center_y - 0.5 * decode_bbox_height
 decode_bbox_xmax = decode_bbox_center_x + 0.5 * decode_bbox_width
 decode_bbox_ymax = decode_bbox_center_y + 0.5 * decode_bbox_height
 
 # 真实框的左上角与右下角进行堆叠
 decode_bbox = np.concatenate((decode_bbox_xmin[:, None],
 decode_bbox_ymin[:, None],
 decode_bbox_xmax[:, None],
 decode_bbox_ymax[:, None]), axis=-1)
 # 防止超出0与1
 decode_bbox = np.minimum(np.maximum(decode_bbox, 0.0), 1.0)
 return decode_bbox

def detection\_out(self, predictions, background\_label\_id=0, keep\_top\_k=200,  
confidence\_threshold=0.5):  
\# 网络预测的结果  
mbox\_loc = predictions\[:, :, :4\]  
\# 0.1，0.1，0.2，0.2  
variances = predictions\[:, :, \-4:\]  
\# 先验框  
mbox\_priorbox = predictions\[:, :, \-8:\-4\]  
\# 置信度  
mbox\_conf = predictions\[:, :, 4:\-8\]  
results = \[\]  
\# 对每一个特征层进行处理  
for i in range(len(mbox\_loc)):  
results.append(\[\])  
decode\_bbox = self.decode\_boxes(mbox\_loc\[i\], mbox\_priorbox\[i\], variances\[i\])

for c in range(self.num_classes):
 if c == background_label_id:
 continue
 c_confs = mbox_conf[i, :, c]
 c_confs_m = c_confs > confidence_threshold
 if len(c_confs[c_confs_m]) > 0:
 # 取出得分高于confidence_threshold的框
 boxes_to_process = decode_bbox[c_confs_m]
 confs_to_process = c_confs[c_confs_m]
 # 进行iou的非极大抑制
 feed_dict = {self.boxes: boxes_to_process,
 self.scores: confs_to_process}
 idx = self.sess.run(self.nms, feed_dict=feed_dict)
 # 取出在非极大抑制中效果较好的内容
 good_boxes = boxes_to_process[idx]
 confs = confs_to_process[idx][:, None]
 # 将label、置信度、框的位置进行堆叠。
 labels = c * np.ones((len(idx), 1))
 c_pred = np.concatenate((labels, confs, good_boxes),
 axis=1)
 # 添加进result里
 results[-1].extend(c_pred)
 if len(results[-1]) > 0:
 # 按照置信度进行排序
 results[-1] = np.array(results[-1])
 argsort = np.argsort(results[-1][:, 1])[::-1]
 results[-1] = results[-1][argsort]
 # 选出置信度最大的keep_top_k个
 results[-1] = results[-1][:keep_top_k]
 return results

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

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

## 二、训练部分 ##

### 1、真实框的处理 ###

从预测部分我们知道，每个特征层的预测结果，**num\_priors x 4的卷积** 用于预测 **该特征层上** **每一个网格点上 每一个先验框**的变化情况。

也就是说，**我们直接利用ssd网络预测到的结果，并不是预测框在图片上的真实位置，需要解码才能得到真实位置。**

而在训练的时候，**我们需要计算loss函数，这个loss函数是相对于ssd网络的预测结果的**。我们需要把图片输入**到当前的ssd网络中，得到预测结果；同时还需要把真实框的信息，进行编码**，这个编码是把**真实框的位置信息格式转化为ssd预测结果的格式信息**。

也就是，我们需要找到 **每一张用于训练的图片**的**每一个真实框对应的先验框**，并求出**如果想要得到这样一个真实框，我们的预测结果应该是怎么样的。**

**从预测结果获得真实框的过程被称作解码，而从真实框获得预测结果的过程就是编码的过程。**

因此我们只需要将**解码过程逆过来就是编码过程了。**

实现代码如下：

def encode_box(self, box, return_iou=True):
 iou = self.iou(box)
 encoded_box = np.zeros((self.num_priors, 4 + return_iou))
 # 找到每一个真实框，重合程度较高的先验框
 assign_mask = iou > self.overlap_threshold
 if not assign_mask.any():
 assign_mask[iou.argmax()] = True
 if return_iou:
 encoded_box[:, -1][assign_mask] = iou[assign_mask]
 
 # 找到对应的先验框
 assigned_priors = self.priors[assign_mask]
 # 逆向编码，将真实框转化为ssd预测结果的格式
 
 # 先计算真实框的中心与长宽
 box_center = 0.5 * (box[:2] + box[2:])
 box_wh = box[2:] - box[:2]
 # 再计算重合度较高的先验框的中心与长宽
 assigned_priors_center = 0.5 * (assigned_priors[:, :2] +
 assigned_priors[:, 2:4])
 assigned_priors_wh = (assigned_priors[:, 2:4] -
 assigned_priors[:, :2])
 
 # 逆向求取ssd应该有的预测结果
 encoded_box[:, :2][assign_mask] = box_center - assigned_priors_center
 encoded_box[:, :2][assign_mask] /= assigned_priors_wh
 # 除以0.1
 encoded_box[:, :2][assign_mask] /= assigned_priors[:, -4:-2]
 
 encoded_box[:, 2:4][assign_mask] = np.log(box_wh / assigned_priors_wh)
 # 除以0.2
 encoded_box[:, 2:4][assign_mask] /= assigned_priors[:, -2:]
 return encoded_box.ravel()

*  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

利用上述代码我们可以获得，**真实框对应的所有的iou较大先验框**，并计算了**真实框对应的所有iou较大的先验框应该有的预测结果。**

在训练的时候我们**只需要选择iou最大的先验框就行了，这个iou最大的先验框就是我们用来预测这个真实框所用的先验框。**

因此我们还要经过一次筛选，将上述代码获得的**真实框对应的所有的iou较大先验框的预测结果**中，iou最大的那个筛选出来。

通过assign\_boxes我们就获得了，输入进来的这张图片，应该有的预测结果是什么样子的。

实现代码如下：

def assign_boxes(self, boxes):
 assignment = np.zeros((self.num_priors, 4 + self.num_classes + 8))
 assignment[:, 4] = 1.0
 if len(boxes) == 0:
 return assignment
 # 对每一个真实框都进行iou计算
 encoded_boxes = np.apply_along_axis(self.encode_box, 1, boxes[:, :4])
 # 每一个真实框的编码后的值，和iou
 encoded_boxes = encoded_boxes.reshape(-1, self.num_priors, 5)
 # 取重合程度最大的先验框，并且获取这个先验框的index
 best_iou = encoded_boxes[:, :, -1].max(axis=0)
 best_iou_idx = encoded_boxes[:, :, -1].argmax(axis=0)
 best_iou_mask = best_iou > 0
 best_iou_idx = best_iou_idx[best_iou_mask]
 
 assign_num = len(best_iou_idx)
 # 保留重合程度最大的先验框的应该有的预测结果
 encoded_boxes = encoded_boxes[:, best_iou_mask, :]
 assignment[:, :4][best_iou_mask] = encoded_boxes[best_iou_idx,np.arange(assign_num),:4]
 # 4代表为背景的概率，为0
 assignment[:, 4][best_iou_mask] = 0
 assignment[:, 5:-8][best_iou_mask] = boxes[best_iou_idx, 4:]
 assignment[:, -8][best_iou_mask] = 1
 # 通过assign_boxes我们就获得了，输入进来的这张图片，应该有的预测结果是什么样子的
 return assignment

*  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

### 2、利用处理完的真实框与对应图片的预测结果计算loss ###

loss的计算分为三个部分：  
1、获取所有正标签的框的预测结果的回归loss。  
2、获取所有正标签的种类的预测结果的交叉熵loss。  
3、获取一定负标签的种类的预测结果的交叉熵loss。

由于在ssd的训练过程中，**正负样本极其不平衡，即 存在对应真实框的先验框可能只有2~3个，但是不存在对应真实框的负样本却有几千个，这就会导致负样本的loss值极大**，因此**我们可以考虑减少负样本的选取，对于ssd的训练来讲，常见的情况是取三倍正样本数量的负样本用于训练**。这个三倍呢，也可以修改，调整成自己喜欢的数字。

实现代码如下：

class MultiboxLoss(object):
 def __init__(self, num_classes, alpha=1.0, neg_pos_ratio=3.0,
 background_label_id=0, negatives_for_hard=100.0):
 self.num_classes = num_classes
 self.alpha = alpha
 self.neg_pos_ratio = neg_pos_ratio
 if background_label_id != 0:
 raise Exception('Only 0 as background label id is supported')
 self.background_label_id = background_label_id
 self.negatives_for_hard = negatives_for_hard
 def _l1_smooth_loss(self, y_true, y_pred):
 abs_loss = tf.abs(y_true - y_pred)
 sq_loss = 0.5 * (y_true - y_pred)**2
 l1_loss = tf.where(tf.less(abs_loss, 1.0), sq_loss, abs_loss - 0.5)
 return tf.reduce_sum(l1_loss, -1)
 
 def _softmax_loss(self, y_true, y_pred):
 y_pred = tf.maximum(tf.minimum(y_pred, 1 - 1e-15), 1e-15)
 softmax_loss = -tf.reduce_sum(y_true * tf.log(y_pred),
 axis=-1)
 return softmax_loss
 
 def compute_loss(self, y_true, y_pred):
 batch_size = tf.shape(y_true)[0]
 num_boxes = tf.to_float(tf.shape(y_true)[1])
 
 # 计算所有的loss
 # 分类的loss
 # batch_size,8732,21 -> batch_size,8732
 conf_loss = self._softmax_loss(y_true[:, :, 4:-8],
 y_pred[:, :, 4:-8])
 # 框的位置的loss
 # batch_size,8732,4 -> batch_size,8732
 loc_loss = self._l1_smooth_loss(y_true[:, :, :4],
 y_pred[:, :, :4])
 
 # 获取所有的正标签的loss
 # 每一张图的pos的个数
 num_pos = tf.reduce_sum(y_true[:, :, -8], axis=-1)
 # 每一张图的pos_loc_loss
 pos_loc_loss = tf.reduce_sum(loc_loss * y_true[:, :, -8],
 axis=1)
 # 每一张图的pos_conf_loss
 pos_conf_loss = tf.reduce_sum(conf_loss * y_true[:, :, -8],
 axis=1)
 
 # 获取一定的负样本
 num_neg = tf.minimum(self.neg_pos_ratio * num_pos,
 num_boxes - num_pos)
 
 # 找到了哪些值是大于0的
 pos_num_neg_mask = tf.greater(num_neg, 0)
 # 获得一个1.0
 has_min = tf.to_float(tf.reduce_any(pos_num_neg_mask))
 num_neg = tf.concat( axis=0,values=[num_neg,
 [(1 - has_min) * self.negatives_for_hard]])
 # 求平均每个图片要取多少个负样本
 num_neg_batch = tf.reduce_mean(tf.boolean_mask(num_neg,
 tf.greater(num_neg, 0)))
 num_neg_batch = tf.to_int32(num_neg_batch)
 
 # conf的起始
 confs_start = 4 + self.background_label_id + 1
 # conf的结束
 confs_end = confs_start + self.num_classes - 1
 
 # 找到实际上在该位置不应该有预测结果的框，求他们最大的置信度。
 max_confs = tf.reduce_max(y_pred[:, :, confs_start:confs_end],
 axis=2)
 
 # 取top_k个置信度，作为负样本
 _, indices = tf.nn.top_k(max_confs * (1 - y_true[:, :, -8]),
 k=num_neg_batch)
 
 # 找到其在1维上的索引
 batch_idx = tf.expand_dims(tf.range(0, batch_size), 1)
 batch_idx = tf.tile(batch_idx, (1, num_neg_batch))
 full_indices = (tf.reshape(batch_idx, [-1]) * tf.to_int32(num_boxes) +
 tf.reshape(indices, [-1]))
 
 
 neg_conf_loss = tf.gather(tf.reshape(conf_loss, [-1]),
 full_indices)
 neg_conf_loss = tf.reshape(neg_conf_loss,
 [batch_size, num_neg_batch])
 neg_conf_loss = tf.reduce_sum(neg_conf_loss, axis=1)
 
 # 求loss总和
 total_loss = K.sum(pos_conf_loss + neg_conf_loss)/K.cast(batch_size,K.dtype(pos_conf_loss))
 
 total_loss += K.sum(self.alpha * pos_loc_loss)/K.cast(batch_size,K.dtype(pos_loc_loss))
 return total_loss

# 训练自己的ssd模型 #

ssd整体的文件夹构架如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 2]  
本文使用VOC格式进行训练。  
训练前将标签文件放在VOCdevkit文件夹下的VOC2007文件夹下的Annotation中。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 3]  
训练前将图片文件放在VOCdevkit文件夹下的VOC2007文件夹下的JPEGImages中。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 4]  
在训练前利用voc2ssd.py文件生成对应的txt。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 5]  
再运行根目录下的voc\_annotation.py，运行前需要将classes改成你自己的classes。

classes = ["aeroplane", "bicycle", "bird", "boat", "bottle", "bus", "car", "cat", "chair", "cow", "diningtable", "dog", "horse", "motorbike", "person", "pottedplant", "sheep", "sofa", "train", "tvmonitor"]
    
     
      
     
      
       1

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 6]  
就会生成对应的2007\_train.txt，每一行对应其图片位置及其真实框的位置。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 7]  
在训练前需要修改model\_data里面的voc\_classes.txt文件，需要将classes改成你自己的classes。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 8]  
运行train.py即可开始训练。  
![在这里插入图片描述][20200130154118227.png_pic_center]

</div><div data-report-view="{"mod":"1585297308_001","dest":"https://blog.csdn.net/weixin_44791964/article/details/104107271","extend1":"pc","ab":"new"}"><div></div></div>
 <link href="https://csdnimg.cn/release/phoenix/mdeditor/markdown_views-ff98e99283.css" rel="stylesheet">
 </div>

[https_blog.csdn.net_weixin_44791964_article_details_104107271_ops_request_misc_257B_2522request_255Fid_2522_253A_2522159887794019725254051093_2522_252C_2522scm_2522_253A_252220140713.130102334.pc_255Fblog._2522_257D_request_id_159887794019725254051093_biz_id_0_utm_medium_distribute.pc_search_result.none-task-blog-2blogfirst_rank_v1_rank_blog_v1-1-104107271.pc_v1_rank_blog_v1_utm_term_ssd_spm_1018.2118.3001.4187]: https://blog.csdn.net/weixin_44791964/article/details/104107271?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522159887794019725254051093%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=159887794019725254051093&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_v1~rank_blog_v1-1-104107271.pc_v1_rank_blog_v1&utm_term=ssd&spm=1018.2118.3001.4187
[20190723165901974.jpg_pic_center]: /images/20221123/c568a586981b4e79a8e2943ca48c5afd.png
[https_github.com_bubbliiiing_ssd-keras]: https://github.com/bubbliiiing/ssd-keras
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70]: /images/20221123/65e043d275294b7fa570e0d73001793f.png
[https_blog.csdn.net_weixin_44791964_article_details_102779878]: https://blog.csdn.net/weixin_44791964/article/details/102779878
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70 1]: /images/20221123/1594863478d44254bc158add4c6d0b12.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/d9e36a7137ec4104a992355c7864a8c8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/d984e226366142d7a372e11f68fb97f4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/3027e6cc8da847a3b6de5063cc226650.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/888dd5ad176b404d90865d316608db7b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/a13aa6fef1894a5f8a690626998f3228.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/922108c7e0bf4844a1728830001a9b54.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221123/7e3bc4c93a5042619fe3955af1c4a0e6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221123/b8cb04f050da4b308678acdb56b20719.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221123/84f8681f3f444f6b923a9adf86955f19.png
[20200130154118227.png_pic_center]: /images/20221123/e1eab808a0de47e39775032a277ce182.png