睿智的目标检测11——Keras搭建yolo3目标检测平台

比眉伴天荒 2023-06-17 04:54 370阅读 0赞

睿智的目标检测11——Keras搭建yolo3目标检测平台

  • 学习前言
  • 源码下载
  • YoloV3实现思路
    • 一、整体结构解析
    • 二、网络结构解析
      • 1、主干网络Darknet53介绍
      • 2、构建FPN特征金字塔进行加强特征提取
      • 3、利用Yolo Head获得预测结果
    • 三、预测结果的解码
      • 1、什么是先验框
      • 2、获得先验框后做什么
      • 3、得分筛选与非极大抑制
    • 四、训练部分
      • 1、计算loss所需参数
      • 2、y_pre是什么
      • 3、y_true是什么。
      • 4、loss的计算过程
  • 训练自己的YoloV3模型
    • 一、数据集的准备
    • 二、数据集的处理
    • 三、开始网络训练
    • 四、训练结果预测

学习前言

一起来看看yolo3的keras实现吧，顺便训练一下自己的数据。
在这里插入图片描述

源码下载

https://github.com/bubbliiiing/yolo3-keras
喜欢的可以点个star噢。

YoloV3实现思路

一、整体结构解析

在这里插入图片描述
在学习YoloV3之前，我们需要对YoloV3所作的工作有一定的了解，这有助于我们后面去了解网络的细节。

整个YoloV3可以分为三个部分，分别是Darknet53，FPN以及Yolo Head。

Darknet53可以被称作YoloV3的主干特征提取网络，输入的图片首先会在Darknet53里面进行特征提取，提取到的特征可以被称作特征层，是输入图片的特征集合。在主干部分，我们获取了三个特征层进行下一步网络的构建，这三个特征层我称它为有效特征层。

FPN可以被称作YoloV3的加强特征提取网络，在主干部分获得的三个有效特征层会在这一部分进行特征融合，特征融合的目的是结合不同尺度的特征信息。在FPN部分，已经获得的有效特征层被用于继续提取特征。

Yolo Head是YoloV3的分类器与回归器，通过Darknet53和FPN，我们已经可以获得三个加强过的有效特征层，他们的shape分别为(52,52,128)，(26,26,256)，(13,13,512)。每一个特征层都有宽、高和通道数，此时我们可以将特征图看作一个又一个特征点的集合，每一个特征点都有通道数个特征。Yolo Head实际上所做的工作就是对特征点进行判断，判断特征点是否有物体与其对应。

因此，整个YoloV3网络所作的工作就是 特征提取-特征加强-预测特征点对应的物体情况。

二、网络结构解析

1、主干网络Darknet53介绍

在这里插入图片描述
YoloV3所使用的主干特征提取网络为Darknet53，它具有两个重要特点：
1、使用了残差网络Residual，Darknet53中的残差卷积可以分为两个部分，主干部分是一次1X1的卷积和一次3X3的卷积；残差边部分不做任何处理，直接将主干的输入与输出结合。整个YoloV3的主干部分都由残差卷积构成，上述所示的YoloV3整体结构里，Resblock_body后面的x几就代表在这个特征层部分，残差结构重复了几次。Resblock_body的代码如下，for训练里的就是残差结构：

  1. #---------------------------------------------------#
  2. #   卷积块
  3. #   DarknetConv2D + BatchNormalization + LeakyReLU
  4. #---------------------------------------------------#
  5. def resblock_body(x, num_filters, num_blocks):
  6.     x = ZeroPadding2D(((1,0),(1,0)))(x)
  7.     x = DarknetConv2D_BN_Leaky(num_filters, (3,3), strides=(2,2))(x)
  8.     for i in range(num_blocks):
  9.         y = DarknetConv2D_BN_Leaky(num_filters//2, (1,1))(x)
  10.         y = DarknetConv2D_BN_Leaky(num_filters, (3,3))(y)
  11.         x = Add()([x,y])
  12.     return x

在这里插入图片描述
残差网络的特点是容易优化，并且能够通过增加相当的深度来提高准确率。其内部的残差块使用了跳跃连接，缓解了在深度神经网络中增加深度带来的梯度消失问题。

2、Darknet53的每一个DarknetConv2D后面都紧跟了BatchNormalization标准化与LeakyReLU部分。普通的ReLU是将所有的负值都设为零，Leaky ReLU则是给所有负值赋予一个非零斜率。以数学的方式我们可以表示为**：
在这里插入图片描述
DarknetConv2D_BN_Leaky的实现代码如下

  1. #---------------------------------------------------#
  2. #   卷积块 -> 卷积 + 标准化 + 激活函数
  3. #   DarknetConv2D + BatchNormalization + LeakyReLU
  4. #---------------------------------------------------#
  5. def DarknetConv2D_BN_Leaky(*args, **kwargs):
  6.     no_bias_kwargs = {
  7.     'use_bias': False}
  8.     no_bias_kwargs.update(kwargs)
  9.     return compose( 
  10.         DarknetConv2D(*args, **no_bias_kwargs),
  11.         BatchNormalization(),
  12.         LeakyReLU(alpha=0.1))

整个主干实现代码为：

  1. from functools import wraps
  3. from keras.initializers import random_normal
  4. from keras.layers import (Add, BatchNormalization, Conv2D, LeakyReLU,
  5.                           ZeroPadding2D)
  6. from keras.regularizers import l2
  7. from utils.utils import compose
  10. #---------------------------------------------------#
  11. #   单次卷积
  12. #   DarknetConv2D
  13. #---------------------------------------------------#
  14. @wraps(Conv2D)
  15. def DarknetConv2D(*args, **kwargs):
  16.     darknet_conv_kwargs = {
  17.     'kernel_initializer' : random_normal(stddev=0.02), 'kernel_regularizer': l2(5e-4)}
  18.     darknet_conv_kwargs['padding'] = 'valid' if kwargs.get('strides')==(2,2) else 'same'
  19.     darknet_conv_kwargs.update(kwargs)
  20.     return Conv2D(*args, **darknet_conv_kwargs)
  22. #---------------------------------------------------#
  23. #   卷积块 -> 卷积 + 标准化 + 激活函数
  24. #   DarknetConv2D + BatchNormalization + LeakyReLU
  25. #---------------------------------------------------#
  26. def DarknetConv2D_BN_Leaky(*args, **kwargs):
  27.     no_bias_kwargs = {
  28.     'use_bias': False}
  29.     no_bias_kwargs.update(kwargs)
  30.     return compose( 
  31.         DarknetConv2D(*args, **no_bias_kwargs),
  32.         BatchNormalization(),
  33.         LeakyReLU(alpha=0.1))
  35. #---------------------------------------------------------------------#
  36. #   残差结构
  37. #   首先利用ZeroPadding2D和一个步长为2x2的卷积块进行高和宽的压缩
  38. #   然后对num_blocks进行循环，循环内部是残差结构。
  39. #---------------------------------------------------------------------#
  40. def resblock_body(x, num_filters, num_blocks):
  41.     x = ZeroPadding2D(((1,0),(1,0)))(x)
  42.     x = DarknetConv2D_BN_Leaky(num_filters, (3,3), strides=(2,2))(x)
  43.     for i in range(num_blocks):
  44.         y = DarknetConv2D_BN_Leaky(num_filters//2, (1,1))(x)
  45.         y = DarknetConv2D_BN_Leaky(num_filters, (3,3))(y)
  46.         x = Add()([x,y])
  47.     return x
  49. #---------------------------------------------------#
  50. #   darknet53 的主体部分
  51. #   输入为一张416x416x3的图片
  52. #   输出为三个有效特征层
  53. #---------------------------------------------------#
  54. def darknet_body(x):
  55.     # 416,416,3 -> 416,416,32
  56.     x = DarknetConv2D_BN_Leaky(32, (3,3))(x)
  57.     # 416,416,32 -> 208,208,64
  58.     x = resblock_body(x, 64, 1)
  59.     # 208,208,64 -> 104,104,128
  60.     x = resblock_body(x, 128, 2)
  61.     # 104,104,128 -> 52,52,256
  62.     x = resblock_body(x, 256, 8)
  63.     feat1 = x
  64.     # 52,52,256 -> 26,26,512
  65.     x = resblock_body(x, 512, 8)
  66.     feat2 = x
  67.     # 26,26,512 -> 13,13,1024
  68.     x = resblock_body(x, 1024, 4)
  69.     feat3 = x
  70.     return feat1, feat2, feat3

2、构建FPN特征金字塔进行加强特征提取

在这里插入图片描述
在特征利用部分，YoloV3提取多特征层进行目标检测，一共提取三个特征层。
三个特征层位于主干部分Darknet53的不同位置，分别位于中间层，中下层，底层，三个特征层的shape分别为(52,52,256)、(26,26,512)、(13,13,1024)。

在获得三个有效特征层后，我们利用这三个有效特征层进行FPN层的构建，构建方式为：

  1. 13x13x1024的特征层进行5次卷积处理，处理完后利用YoloHead获得预测结果，一部分用于进行上采样UmSampling2d后与26x26x512特征层进行结合，结合特征层的shape为(26,26,768)。
  2. 结合特征层再次进行5次卷积处理，处理完后利用YoloHead获得预测结果，一部分用于进行上采样UmSampling2d后与52x52x256特征层进行结合，结合特征层的shape为(52,52,384)。
  3. 结合特征层再次进行5次卷积处理，处理完后利用YoloHead获得预测结果。

特征金字塔可以将不同shape的特征层进行特征融合，有利于提取出更好的特征。

  1. from keras.layers import Concatenate, Input, Lambda, UpSampling2D
  2. from keras.models import Model
  3. from utils.utils import compose
  5. from nets.darknet import DarknetConv2D, DarknetConv2D_BN_Leaky, darknet_body
  6. from nets.yolo_training import yolo_loss
  8. #---------------------------------------------------#
  9. #   特征层->最后的输出
  10. #---------------------------------------------------#
  11. def make_five_conv(x, num_filters):
  12.     x = DarknetConv2D_BN_Leaky(num_filters, (1,1))(x)
  13.     x = DarknetConv2D_BN_Leaky(num_filters*2, (3,3))(x)
  14.     x = DarknetConv2D_BN_Leaky(num_filters, (1,1))(x)
  15.     x = DarknetConv2D_BN_Leaky(num_filters*2, (3,3))(x)
  16.     x = DarknetConv2D_BN_Leaky(num_filters, (1,1))(x)
  17.     return x
  19. def make_yolo_head(x, num_filters, out_filters):
  20.     y = DarknetConv2D_BN_Leaky(num_filters*2, (3,3))(x)
  21.     y = DarknetConv2D(out_filters, (1,1))(y)
  22.     return y
  24. #---------------------------------------------------#
  25. #   FPN网络的构建，并且获得预测结果
  26. #---------------------------------------------------#
  27. def yolo_body(input_shape, anchors_mask, num_classes):
  28.     inputs      = Input(input_shape)
  29.     #---------------------------------------------------#   
  30.     #   生成darknet53的主干模型
  31.     #   获得三个有效特征层，他们的shape分别是：
  32.     #   C3 为 52,52,256
  33.     #   C4 为 26,26,512
  34.     #   C5 为 13,13,1024
  35.     #---------------------------------------------------#
  36.     C3, C4, C5  = darknet_body(inputs)
  38.     #---------------------------------------------------#
  39.     #   第一个特征层
  40.     #   y1=(batch_size,13,13,3,85)
  41.     #---------------------------------------------------#
  42.     # 13,13,1024 -> 13,13,512 -> 13,13,1024 -> 13,13,512 -> 13,13,1024 -> 13,13,512
  43.     x   = make_five_conv(C5, 512)
  44.     P5  = make_yolo_head(x, 512, len(anchors_mask[0]) * (num_classes+5))
  46.     # 13,13,512 -> 13,13,256 -> 26,26,256
  47.     x   = compose(DarknetConv2D_BN_Leaky(256, (1,1)), UpSampling2D(2))(x)
  49.     # 26,26,256 + 26,26,512 -> 26,26,768
  50.     x   = Concatenate()([x, C4])
  51.     #---------------------------------------------------#
  52.     #   第二个特征层
  53.     #   y2=(batch_size,26,26,3,85)
  54.     #---------------------------------------------------#
  55.     # 26,26,768 -> 26,26,256 -> 26,26,512 -> 26,26,256 -> 26,26,512 -> 26,26,256
  56.     x   = make_five_conv(x, 256)
  57.     P4  = make_yolo_head(x, 256, len(anchors_mask[1]) * (num_classes+5))
  59.     # 26,26,256 -> 26,26,128 -> 52,52,128
  60.     x   = compose(DarknetConv2D_BN_Leaky(128, (1,1)), UpSampling2D(2))(x)
  61.     # 52,52,128 + 52,52,256 -> 52,52,384
  62.     x   = Concatenate()([x, C3])
  63.     #---------------------------------------------------#
  64.     #   第三个特征层
  65.     #   y3=(batch_size,52,52,3,85)
  66.     #---------------------------------------------------#
  67.     # 52,52,384 -> 52,52,128 -> 52,52,256 -> 52,52,128 -> 52,52,256 -> 52,52,128
  68.     x   = make_five_conv(x, 128)
  69.     P3  = make_yolo_head(x, 128, len(anchors_mask[2]) * (num_classes+5))
  70.     return Model(inputs, [P5, P4, P3])

3、利用Yolo Head获得预测结果

在这里插入图片描述
利用FPN特征金字塔，我们可以获得三个加强特征，这三个加强特征的shape分别为(13,13,512)、(26,26,256)、(52,52,128)，然后我们利用这三个shape的特征层传入Yolo Head获得预测结果。

Yolo Head本质上是一次3x3卷积加上一次1x1卷积，3x3卷积的作用是特征整合，1x1卷积的作用是调整通道数。

对三个特征层分别进行处理，假设我们预测是的VOC数据集，我们的输出层的shape分别为(13,13,75)，(26,26,75)，(52,52,75)，最后一个维度为75是因为该图是基于voc数据集的，它的类为20种，YoloV3针对每一个特征层的每一个特征点存在3个先验框，所以预测结果的通道数为3x25；
如果使用的是coco训练集，类则为80种，最后的维度应该为255 = 3x85，三个特征层的shape为(13,13,255)，(26,26,255)，(52,52,255)

其实际情况就是，输入N张416x416的图片，在经过多层的运算后，会输出三个shape分别为(N,13,13,255)，(N,26,26,255)，(N,52,52,255)的数据，对应每个图分为13x13、26x26、52x52的网格上3个先验框的位置。

实现代码如下：

  1. from keras.layers import Concatenate, Input, Lambda, UpSampling2D
  2. from keras.models import Model
  3. from utils.utils import compose
  5. from nets.darknet import DarknetConv2D, DarknetConv2D_BN_Leaky, darknet_body
  6. from nets.yolo_training import yolo_loss
  8. #---------------------------------------------------#
  9. #   特征层->最后的输出
  10. #---------------------------------------------------#
  11. def make_five_conv(x, num_filters):
  12.     x = DarknetConv2D_BN_Leaky(num_filters, (1,1))(x)
  13.     x = DarknetConv2D_BN_Leaky(num_filters*2, (3,3))(x)
  14.     x = DarknetConv2D_BN_Leaky(num_filters, (1,1))(x)
  15.     x = DarknetConv2D_BN_Leaky(num_filters*2, (3,3))(x)
  16.     x = DarknetConv2D_BN_Leaky(num_filters, (1,1))(x)
  17.     return x
  19. def make_yolo_head(x, num_filters, out_filters):
  20.     y = DarknetConv2D_BN_Leaky(num_filters*2, (3,3))(x)
  21.     y = DarknetConv2D(out_filters, (1,1))(y)
  22.     return y
  24. #---------------------------------------------------#
  25. #   FPN网络的构建，并且获得预测结果
  26. #---------------------------------------------------#
  27. def yolo_body(input_shape, anchors_mask, num_classes):
  28.     inputs      = Input(input_shape)
  29.     #---------------------------------------------------#   
  30.     #   生成darknet53的主干模型
  31.     #   获得三个有效特征层，他们的shape分别是：
  32.     #   C3 为 52,52,256
  33.     #   C4 为 26,26,512
  34.     #   C5 为 13,13,1024
  35.     #---------------------------------------------------#
  36.     C3, C4, C5  = darknet_body(inputs)
  38.     #---------------------------------------------------#
  39.     #   第一个特征层
  40.     #   y1=(batch_size,13,13,3,85)
  41.     #---------------------------------------------------#
  42.     # 13,13,1024 -> 13,13,512 -> 13,13,1024 -> 13,13,512 -> 13,13,1024 -> 13,13,512
  43.     x   = make_five_conv(C5, 512)
  44.     P5  = make_yolo_head(x, 512, len(anchors_mask[0]) * (num_classes+5))
  46.     # 13,13,512 -> 13,13,256 -> 26,26,256
  47.     x   = compose(DarknetConv2D_BN_Leaky(256, (1,1)), UpSampling2D(2))(x)
  49.     # 26,26,256 + 26,26,512 -> 26,26,768
  50.     x   = Concatenate()([x, C4])
  51.     #---------------------------------------------------#
  52.     #   第二个特征层
  53.     #   y2=(batch_size,26,26,3,85)
  54.     #---------------------------------------------------#
  55.     # 26,26,768 -> 26,26,256 -> 26,26,512 -> 26,26,256 -> 26,26,512 -> 26,26,256
  56.     x   = make_five_conv(x, 256)
  57.     P4  = make_yolo_head(x, 256, len(anchors_mask[1]) * (num_classes+5))
  59.     # 26,26,256 -> 26,26,128 -> 52,52,128
  60.     x   = compose(DarknetConv2D_BN_Leaky(128, (1,1)), UpSampling2D(2))(x)
  61.     # 52,52,128 + 52,52,256 -> 52,52,384
  62.     x   = Concatenate()([x, C3])
  63.     #---------------------------------------------------#
  64.     #   第三个特征层
  65.     #   y3=(batch_size,52,52,3,85)
  66.     #---------------------------------------------------#
  67.     # 52,52,384 -> 52,52,128 -> 52,52,256 -> 52,52,128 -> 52,52,256 -> 52,52,128
  68.     x   = make_five_conv(x, 128)
  69.     P3  = make_yolo_head(x, 128, len(anchors_mask[2]) * (num_classes+5))
  70.     return Model(inputs, [P5, P4, P3])

三、预测结果的解码

1、什么是先验框

由网络我们可以获得三个特征层的预测结果，shape分别为：

  • (N,13,13,255)
  • (N,26,26,255)
  • (N,52,52,255)

N代表的是batch_size，就是输入图片的数量，我们可以忽略，但是后面的(52,52,255)、(26,26,255)、(13,13,255)，就不可以忽略了。

每一个预测结果都有宽、高和通道数，宽、高里面是一个又一个特征点，那此时我们便可以想办法利用这些特征点，和原图进行结合。

我们再看看预测结果的特点，13X13，26X26，52X52，它是不是非常像三个等分的网格？如果我们将原图划分成对应13X13，26X26，52X52的部分，是不是整个特征层就以某种形式映射在原图上了。

事实上yolo系列就是这么做的，每一个有效特征层将整个图片分成与其长宽对应的网格，仔细看看这幅图，原图被划分成13x13的网格；然后从每个网格中心建立多个先验框，典型值是一个特征点三个先验框，这些框是网络预先设定好的框，网络的预测结果会判断这些框内是否包含物体，以及这个物体的种类。

在这里插入图片描述

2、获得先验框后做什么

由网络我们可以获得三个特征层的预测结果，shape分别为：

  • (N,13,13,255)
  • (N,26,26,255)
  • (N,52,52,255)
    由于每一个网格点都具有三个先验框，所以上述的预测结果可以reshape为：
  • (N,13,13,3,85)
  • (N,26,26,3,85)
  • (N,52,52,3,85)

其中的85可以拆分为4+1+80，其中的4代表先验框的调整参数，1代表先验框内是否包含物体，80代表的是这个先验框的种类，由于coco分了80类，所以这里是80。如果YoloV3只检测两类物体，那么这个85就变为了4+1+2 = 7。

即85包含了4+1+80，分别代表x_offset、y_offset、h和w、置信度、分类结果。

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

YoloV3的解码过程分为两步：

  • 先将每个网格点加上它对应的x_offset和y_offset，加完后的结果就是预测框的中心。
  • 然后再利用 先验框和h、w结合 计算出预测框的宽高。这样就能得到整个预测框的位置了。

下图展示了YoloV3解码的过程：
在这里插入图片描述
实现代码如下，当调用DecodeBox时，就会进行解码：

  1. import tensorflow as tf
  2. from keras import backend as K
  5. #---------------------------------------------------#
  6. #   对box进行调整，使其符合真实图片的样子
  7. #---------------------------------------------------#
  8. def yolo_correct_boxes(box_xy, box_wh, input_shape, image_shape, letterbox_image):
  9.     #-----------------------------------------------------------------#
  10.     #   把y轴放前面是因为方便预测框和图像的宽高进行相乘
  11.     #-----------------------------------------------------------------#
  12.     box_yx = box_xy[..., ::-1]
  13.     box_hw = box_wh[..., ::-1]
  14.     input_shape = K.cast(input_shape, K.dtype(box_yx))
  15.     image_shape = K.cast(image_shape, K.dtype(box_yx))
  17.     if letterbox_image:
  18.         #-----------------------------------------------------------------#
  19.         #   这里求出来的offset是图像有效区域相对于图像左上角的偏移情况
  20.         #   new_shape指的是宽高缩放情况
  21.         #-----------------------------------------------------------------#
  22.         new_shape = K.round(image_shape * K.min(input_shape/image_shape))
  23.         offset  = (input_shape - new_shape)/2./input_shape
  24.         scale   = input_shape/new_shape
  26.         box_yx  = (box_yx - offset) * scale
  27.         box_hw *= scale
  29.     box_mins    = box_yx - (box_hw / 2.)
  30.     box_maxes   = box_yx + (box_hw / 2.)
  31.     boxes  = K.concatenate([box_mins[..., 0:1], box_mins[..., 1:2], box_maxes[..., 0:1], box_maxes[..., 1:2]])
  32.     boxes *= K.concatenate([image_shape, image_shape])
  33.     return boxes
  35. #---------------------------------------------------#
  36. #   将预测值的每个特征层调成真实值
  37. #---------------------------------------------------#
  38. def get_anchors_and_decode(feats, anchors, num_classes, input_shape, calc_loss=False):
  39.     num_anchors = len(anchors)
  40.     #------------------------------------------#
  41.     #   grid_shape指的是特征层的高和宽
  42.     #------------------------------------------#
  43.     grid_shape = K.shape(feats)[1:3]
  44.     #--------------------------------------------------------------------#
  45.     #   获得各个特征点的坐标信息。生成的shape为(13, 13, num_anchors, 2)
  46.     #--------------------------------------------------------------------#
  47.     grid_x  = K.tile(K.reshape(K.arange(0, stop=grid_shape[1]), [1, -1, 1, 1]), [grid_shape[0], 1, num_anchors, 1])
  48.     grid_y  = K.tile(K.reshape(K.arange(0, stop=grid_shape[0]), [-1, 1, 1, 1]), [1, grid_shape[1], num_anchors, 1])
  49.     grid    = K.cast(K.concatenate([grid_x, grid_y]), K.dtype(feats))
  50.     #---------------------------------------------------------------#
  51.     #   将先验框进行拓展，生成的shape为(13, 13, num_anchors, 2)
  52.     #---------------------------------------------------------------#
  53.     anchors_tensor = K.reshape(K.constant(anchors), [1, 1, num_anchors, 2])
  54.     anchors_tensor = K.tile(anchors_tensor, [grid_shape[0], grid_shape[1], 1, 1])
  56.     #---------------------------------------------------#
  57.     #   将预测结果调整成(batch_size,13,13,3,85)
  58.     #   85可拆分成4 + 1 + 80
  59.     #   4代表的是中心宽高的调整参数
  60.     #   1代表的是框的置信度
  61.     #   80代表的是种类的置信度
  62.     #---------------------------------------------------#
  63.     feats           = K.reshape(feats, [-1, grid_shape[0], grid_shape[1], num_anchors, num_classes + 5])
  64.     #------------------------------------------#
  65.     #   对先验框进行解码，并进行归一化
  66.     #------------------------------------------#
  67.     box_xy          = (K.sigmoid(feats[..., :2]) + grid) / K.cast(grid_shape[::-1], K.dtype(feats))
  68.     box_wh          = K.exp(feats[..., 2:4]) * anchors_tensor / K.cast(input_shape[::-1], K.dtype(feats))
  69.     #------------------------------------------#
  70.     #   获得预测框的置信度
  71.     #------------------------------------------#
  72.     box_confidence  = K.sigmoid(feats[..., 4:5])
  73.     box_class_probs = K.sigmoid(feats[..., 5:])
  75.     #---------------------------------------------------------------------#
  76.     #   在计算loss的时候返回grid, feats, box_xy, box_wh
  77.     #   在预测的时候返回box_xy, box_wh, box_confidence, box_class_probs
  78.     #---------------------------------------------------------------------#
  79.     if calc_loss == True:
  80.         return grid, feats, box_xy, box_wh
  81.     return box_xy, box_wh, box_confidence, box_class_probs
  83. #---------------------------------------------------#
  84. #   图片预测
  85. #---------------------------------------------------#
  86. def DecodeBox(outputs,
  87.             anchors,
  88.             num_classes,
  89.             image_shape,
  90.             input_shape,
  91.             #-----------------------------------------------------------#
  92.             #   13x13的特征层对应的anchor是[116,90],[156,198],[373,326]
  93.             #   26x26的特征层对应的anchor是[30,61],[62,45],[59,119]
  94.             #   52x52的特征层对应的anchor是[10,13],[16,30],[33,23]
  95.             #-----------------------------------------------------------#
  96.             anchor_mask     = [[6, 7, 8], [3, 4, 5], [0, 1, 2]],
  97.             max_boxes       = 100,
  98.             confidence      = 0.5,
  99.             nms_iou         = 0.3,
  100.             letterbox_image = True):
  102.     box_xy = []
  103.     box_wh = []
  104.     box_confidence  = []
  105.     box_class_probs = []
  106.     for i in range(len(outputs)):
  107.         sub_box_xy, sub_box_wh, sub_box_confidence, sub_box_class_probs = \
  108.             get_anchors_and_decode(outputs[i], anchors[anchor_mask[i]], num_classes, input_shape)
  109.         box_xy.append(K.reshape(sub_box_xy, [-1, 2]))
  110.         box_wh.append(K.reshape(sub_box_wh, [-1, 2]))
  111.         box_confidence.append(K.reshape(sub_box_confidence, [-1, 1]))
  112.         box_class_probs.append(K.reshape(sub_box_class_probs, [-1, num_classes]))
  113.     box_xy          = K.concatenate(box_xy, axis = 0)
  114.     box_wh          = K.concatenate(box_wh, axis = 0)
  115.     box_confidence  = K.concatenate(box_confidence, axis = 0)
  116.     box_class_probs = K.concatenate(box_class_probs, axis = 0)
  118.     #------------------------------------------------------------------------------------------------------------#
  119.     #   在图像传入网络预测前会进行letterbox_image给图像周围添加灰条，因此生成的box_xy, box_wh是相对于有灰条的图像的
  120.     #   我们需要对其进行修改，去除灰条的部分。 将box_xy、和box_wh调节成y_min,y_max,xmin,xmax
  121.     #   如果没有使用letterbox_image也需要将归一化后的box_xy, box_wh调整成相对于原图大小的
  122.     #------------------------------------------------------------------------------------------------------------#
  123.     boxes       = yolo_correct_boxes(box_xy, box_wh, input_shape, image_shape, letterbox_image)

3、得分筛选与非极大抑制

得到最终的预测结果后还要进行得分排序与非极大抑制筛选。

得分筛选就是筛选出得分满足confidence置信度的预测框。
非极大抑制就是筛选出一定区域内属于同一种类得分最大的框。

得分筛选与非极大抑制的过程可以概括如下：
1、找出该图片中得分大于门限函数的框。在进行重合框筛选前就进行得分的筛选可以大幅度减少框的数量。
2、对种类进行循环，非极大抑制的作用是筛选出一定区域内属于同一种类得分最大的框，对种类进行循环可以帮助我们对每一个类分别进行非极大抑制。
3、根据得分对该种类进行从大到小排序。
4、每次取出得分最大的框，计算其与其它所有预测框的重合程度，重合程度过大的则剔除。

得分筛选与非极大抑制后的结果就可以用于绘制预测框了。

下图是经过非极大抑制的。
在这里插入图片描述
下图是未经过非极大抑制的。
在这里插入图片描述
实现代码为：

  1. box_scores  = box_confidence * box_class_probs
  3. #-----------------------------------------------------------#
  4. #   判断得分是否大于score_threshold
  5. #-----------------------------------------------------------#
  6. mask             = box_scores >= confidence
  7. max_boxes_tensor = K.constant(max_boxes, dtype='int32')
  8. boxes_out   = []
  9. scores_out  = []
  10. classes_out = []
  11. for c in range(num_classes):
  12.     #-----------------------------------------------------------#
  13.     #   取出所有box_scores >= score_threshold的框，和成绩
  14.     #-----------------------------------------------------------#
  15.     class_boxes      = tf.boolean_mask(boxes, mask[:, c])
  16.     class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
  18.     #-----------------------------------------------------------#
  19.     #   非极大抑制
  20.     #   保留一定区域内得分最大的框
  21.     #-----------------------------------------------------------#
  22.     nms_index = tf.image.non_max_suppression(class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=nms_iou)
  24.     #-----------------------------------------------------------#
  25.     #   获取非极大抑制后的结果
  26.     #   下列三个分别是：框的位置，得分与种类
  27.     #-----------------------------------------------------------#
  28.     class_boxes         = K.gather(class_boxes, nms_index)
  29.     class_box_scores    = K.gather(class_box_scores, nms_index)
  30.     classes             = K.ones_like(class_box_scores, 'int32') * c
  32.     boxes_out.append(class_boxes)
  33.     scores_out.append(class_box_scores)
  34.     classes_out.append(classes)
  35. boxes_out      = K.concatenate(boxes_out, axis=0)
  36. scores_out     = K.concatenate(scores_out, axis=0)
  37. classes_out    = K.concatenate(classes_out, axis=0)

四、训练部分

1、计算loss所需参数

在计算loss的时候，实际上是y_pre和y_true之间的对比：
y_pre就是一幅图像经过网络之后的输出，内部含有三个特征层的内容；其需要解码才能够在图上作画
y_true就是一个真实图像中，它的每个真实框对应的(13,13)、(26,26)、(52,52)网格上的偏移位置、长宽与种类。其仍需要编码才能与y_pred的结构一致
实际上y_pre和y_true内容的shape都是
(batch_size,13,13,3,85)
(batch_size,26,26,3,85)
(batch_size,52,52,3,85)

2、y_pre是什么

对于YoloV3的模型来说，网络最后输出的内容就是三个特征层每个网格点对应的预测框及其种类，即三个特征层分别对应着图片被分为不同size的网格后，每个网格点上三个先验框对应的位置、置信度及其种类。
对于输出的y1、y2、y3而言，[…, : 2]指的是相对于每个网格点的偏移量，[…, 2: 4]指的是宽和高，[…, 4: 5]指的是该框的置信度，[…, 5: ]指的是每个种类的预测概率。
现在的y_pre还是没有解码的，解码了之后才是真实图像上的情况。

3、y_true是什么。

y_true就是一个真实图像中，它的每个真实框对应的(13,13)、(26,26)、(52,52)网格上的偏移位置、长宽与种类。其仍需要编码才能与y_pred的结构一致
在YoloV3中，其使用了一个专门的函数用于处理读取进来的图片的框的真实情况。

  1. def preprocess_true_boxes(true_boxes, input_shape, anchors, num_classes):

其输入为：
true_boxes：shape为(m, T, 5)代表m张图T个框的x_min、y_min、x_max、y_max、class_id。
input_shape：输入的形状，此处为416、416
anchors：代表9个先验框的大小
num_classes：种类的数量。
其实对真实框的处理是将真实框转化成图片中相对网格的xyhw，步骤如下：
1、取框的真实值，获取其框的中心及其宽高，除去input_shape变成比例的模式。
2、建立全为0的y_true，y_true是一个列表，包含三个特征层，shape分别为(m,13,13,3,85),(m,26,26,3,85),(m,52,52,3,85)。
3、对每一张图片处理，将每一张图片中的真实框的wh和先验框的wh对比，计算IOU值，选取其中IOU最高的一个，得到其所属特征层及其网格点的位置，在对应的y_true中将内容进行保存。

  1. for t, n in enumerate(best_anchor):
  2.     for l in range(num_layers):
  3.         if n in anchor_mask[l]:
  5.             # 计算该目标在第l个特征层所处网格的位置
  6.             i = np.floor(true_boxes[b,t,0]*grid_shapes[l][1]).astype('int32')
  7.             j = np.floor(true_boxes[b,t,1]*grid_shapes[l][0]).astype('int32')
  9.             # 找到best_anchor索引的索引
  10.             k = anchor_mask[l].index(n)
  11.             c = true_boxes[b,t, 4].astype('int32')
  13.             # 保存到y_true中
  14.             y_true[l][b, j, i, k, 0:4] = true_boxes[b,t, 0:4]
  15.             y_true[l][b, j, i, k, 4] = 1
  16.             y_true[l][b, j, i, k, 5+c] = 1

对于最后输出的y_true而言，只有每个图里每个框最对应的位置有数据，其它的地方都为0。
preprocess_true_boxes全部的代码如下：

  1. def preprocess_true_boxes(self, true_boxes, input_shape, anchors, num_classes):
  2.     assert (true_boxes[..., 4]<num_classes).all(), 'class id must be less than num_classes'
  3.     #-----------------------------------------------------------#
  4.     #   获得框的坐标和图片的大小
  5.     #-----------------------------------------------------------#
  6.     true_boxes  = np.array(true_boxes, dtype='float32')
  7.     input_shape = np.array(input_shape, dtype='int32')
  9.     #-----------------------------------------------------------#
  10.     #   一共有三个特征层数
  11.     #-----------------------------------------------------------#
  12.     num_layers  = len(self.anchors_mask)
  13.     #-----------------------------------------------------------#
  14.     #   m为图片数量，grid_shapes为网格的shape
  15.     #-----------------------------------------------------------#
  16.     m           = true_boxes.shape[0]
  17.     grid_shapes = [input_shape // {
  18.     0:32, 1:16, 2:8}[l] for l in range(num_layers)]
  19.     #-----------------------------------------------------------#
  20.     #   y_true的格式为(m,13,13,3,85)(m,26,26,3,85)(m,52,52,3,85)
  21.     #-----------------------------------------------------------#
  22.     y_true = [np.zeros((m, grid_shapes[l][0], grid_shapes[l][1], len(self.anchors_mask[l]), 5 + num_classes),
  23.                 dtype='float32') for l in range(num_layers)]
  25.     #-----------------------------------------------------------#
  26.     #   通过计算获得真实框的中心和宽高
  27.     #   中心点(m,n,2) 宽高(m,n,2)
  28.     #-----------------------------------------------------------#
  29.     boxes_xy = (true_boxes[..., 0:2] + true_boxes[..., 2:4]) // 2
  30.     boxes_wh =  true_boxes[..., 2:4] - true_boxes[..., 0:2]
  31.     #-----------------------------------------------------------#
  32.     #   将真实框归一化到小数形式
  33.     #-----------------------------------------------------------#
  34.     true_boxes[..., 0:2] = boxes_xy / input_shape[::-1]
  35.     true_boxes[..., 2:4] = boxes_wh / input_shape[::-1]
  37.     #-----------------------------------------------------------#
  38.     #   [9,2] -> [1,9,2]
  39.     #-----------------------------------------------------------#
  40.     anchors         = np.expand_dims(anchors, 0)
  41.     anchor_maxes    = anchors / 2.
  42.     anchor_mins     = -anchor_maxes
  44.     #-----------------------------------------------------------#
  45.     #   长宽要大于0才有效
  46.     #-----------------------------------------------------------#
  47.     valid_mask = boxes_wh[..., 0]>0
  49.     for b in range(m):
  50.         #-----------------------------------------------------------#
  51.         #   对每一张图进行处理
  52.         #-----------------------------------------------------------#
  53.         wh = boxes_wh[b, valid_mask[b]]
  54.         if len(wh) == 0: continue
  55.         #-----------------------------------------------------------#
  56.         #   [n,2] -> [n,1,2]
  57.         #-----------------------------------------------------------#
  58.         wh          = np.expand_dims(wh, -2)
  59.         box_maxes   = wh / 2.
  60.         box_mins    = - box_maxes
  62.         #-----------------------------------------------------------#
  63.         #   计算所有真实框和先验框的交并比
  64.         #   intersect_area  [n,9]
  65.         #   box_area        [n,1]
  66.         #   anchor_area     [1,9]
  67.         #   iou             [n,9]
  68.         #-----------------------------------------------------------#
  69.         intersect_mins  = np.maximum(box_mins, anchor_mins)
  70.         intersect_maxes = np.minimum(box_maxes, anchor_maxes)
  71.         intersect_wh    = np.maximum(intersect_maxes - intersect_mins, 0.)
  72.         intersect_area  = intersect_wh[..., 0] * intersect_wh[..., 1]
  74.         box_area    = wh[..., 0] * wh[..., 1]
  75.         anchor_area = anchors[..., 0] * anchors[..., 1]
  77.         iou = intersect_area / (box_area + anchor_area - intersect_area)
  78.         #-----------------------------------------------------------#
  79.         #   维度是[n,] 感谢 消尽不死鸟 的提醒
  80.         #-----------------------------------------------------------#
  81.         best_anchor = np.argmax(iou, axis=-1)
  83.         for t, n in enumerate(best_anchor):
  84.             #-----------------------------------------------------------#
  85.             #   找到每个真实框所属的特征层
  86.             #-----------------------------------------------------------#
  87.             for l in range(num_layers):
  88.                 if n in self.anchors_mask[l]:
  89.                     #-----------------------------------------------------------#
  90.                     #   floor用于向下取整，找到真实框所属的特征层对应的x、y轴坐标
  91.                     #-----------------------------------------------------------#
  92.                     i = np.floor(true_boxes[b,t,0] * grid_shapes[l][1]).astype('int32')
  93.                     j = np.floor(true_boxes[b,t,1] * grid_shapes[l][0]).astype('int32')
  94.                     #-----------------------------------------------------------#
  95.                     #   k指的的当前这个特征点的第k个先验框
  96.                     #-----------------------------------------------------------#
  97.                     k = self.anchors_mask[l].index(n)
  98.                     #-----------------------------------------------------------#
  99.                     #   c指的是当前这个真实框的种类
  100.                     #-----------------------------------------------------------#
  101.                     c = true_boxes[b, t, 4].astype('int32')
  102.                     #-----------------------------------------------------------#
  103.                     #   y_true的shape为(m,13,13,3,85)(m,26,26,3,85)(m,52,52,3,85)
  104.                     #   最后的85可以拆分成4+1+80，4代表的是框的中心与宽高、
  105.                     #   1代表的是置信度、80代表的是种类
  106.                     #-----------------------------------------------------------#
  107.                     y_true[l][b, j, i, k, 0:4] = true_boxes[b, t, 0:4]
  108.                     y_true[l][b, j, i, k, 4] = 1
  109.                     y_true[l][b, j, i, k, 5+c] = 1
  111.     return y_true

4、loss的计算过程

在得到了y_pre和y_true后怎么对比呢？不是简单的减一下就可以的呢。
loss值需要对三个特征层进行处理，这里以最小的特征层为例。
1、利用y_true取出该特征层中真实存在目标的点的位置(m,13,13,3,1)及其对应的种类(m,13,13,3,80)。
2、将yolo_outputs的预测值输出进行处理，得到reshape后的预测值y_pre，shape分别为(m,13,13,3,85),(m,26,26,3,85),(m,52,52,3,85)。还有解码后的xy，wh。
3、获取真实框编码后的值，后面用于计算loss，编码后的值其含义与y_pre相同，可用于计算loss。
4、对于每一幅图，计算其中所有真实框与预测框的IOU，取出每个网络点中IOU最大的先验框，如果这个最大的IOU都小于ignore_thresh，则保留，一般来说ignore_thresh取0.5，该步的目的是为了平衡负样本。
5、计算xy和wh上的loss，其计算的是实际上存在目标的，利用第三步真实框编码后的的结果和未处理的预测结果进行对比得到loss。
6、计算置信度的loss，其有两部分构成，第一部分是实际上存在目标的，预测结果中置信度的值与1对比；第二部分是实际上不存在目标的，在第四步中得到其最大IOU的值与0对比。
7、计算预测种类的loss，其计算的是实际上存在目标的，预测类与真实类的差距。
其实际上计算的总的loss是三个loss的和，这三个loss分别是：

  • 实际存在的框，编码后的长宽与xy轴偏移量与预测值的差距。
  • 实际存在的框，预测结果中置信度的值与1对比；实际不存在的框，在上述步骤中，在第四步中得到其最大IOU的值与0对比。
  • 实际存在的框，种类预测结果与实际结果的对比。

其实际代码如下，使用yolo_loss就可以获得loss值：

  1. import tensorflow as tf
  2. from tensorflow.keras import backend as K
  3. from utils.utils_bbox import decode_anchors, get_grid_anchors
  6. #---------------------------------------------------#
  7. #   用于计算每个预测框与真实框的iou
  8. #---------------------------------------------------#
  9. def box_iou(b1, b2):
  10.     #---------------------------------------------------#
  11.     #   num_anchor,1,4
  12.     #   计算左上角的坐标和右下角的坐标
  13.     #---------------------------------------------------#
  14.     b1          = K.expand_dims(b1, -2)
  15.     b1_xy       = b1[..., :2]
  16.     b1_wh       = b1[..., 2:4]
  17.     b1_wh_half  = b1_wh/2.
  18.     b1_mins     = b1_xy - b1_wh_half
  19.     b1_maxes    = b1_xy + b1_wh_half
  21.     #---------------------------------------------------#
  22.     #   1,n,4
  23.     #   计算左上角和右下角的坐标
  24.     #---------------------------------------------------#
  25.     b2          = K.expand_dims(b2, 0)
  26.     b2_xy       = b2[..., :2]
  27.     b2_wh       = b2[..., 2:4]
  28.     b2_wh_half  = b2_wh/2.
  29.     b2_mins     = b2_xy - b2_wh_half
  30.     b2_maxes    = b2_xy + b2_wh_half
  32.     #---------------------------------------------------#
  33.     #   计算重合面积
  34.     #---------------------------------------------------#
  35.     intersect_mins  = K.maximum(b1_mins, b2_mins)
  36.     intersect_maxes = K.minimum(b1_maxes, b2_maxes)
  37.     intersect_wh    = K.maximum(intersect_maxes - intersect_mins, 0.)
  38.     intersect_area  = intersect_wh[..., 0] * intersect_wh[..., 1]
  39.     b1_area         = b1_wh[..., 0] * b1_wh[..., 1]
  40.     b2_area         = b2_wh[..., 0] * b2_wh[..., 1]
  41.     iou             = intersect_area / (b1_area + b2_area - intersect_area)
  43.     return iou
  45. #---------------------------------------------------#
  46. #   loss值计算
  47. #---------------------------------------------------#
  48. def yolo_loss(args, input_shape, anchors, anchors_mask, num_classes, ignore_thresh=.5, print_loss=False):
  49.     num_layers = len(anchors_mask)
  50.     #---------------------------------------------------------------------------------------------------#
  51.     #   将预测结果和实际ground truth分开，args是[*model_body.output, *y_true]
  52.     #   y_true是一个列表，包含三个特征层，shape分别为:
  53.     #   (m,13,13,3,85)
  54.     #   (m,26,26,3,85)
  55.     #   (m,52,52,3,85)
  56.     #   yolo_outputs是一个列表，包含三个特征层，shape分别为:
  57.     #   (m,13,13,3,85)
  58.     #   (m,26,26,3,85)
  59.     #   (m,52,52,3,85)
  60.     #---------------------------------------------------------------------------------------------------#
  61.     y_true          = args[num_layers:]
  62.     yolo_outputs    = args[:num_layers]
  64.     #-----------------------------------------------------------#
  65.     #   得到input_shpae为416,416 
  66.     #-----------------------------------------------------------#
  67.     input_shape = K.cast(input_shape, K.dtype(y_true[0]))
  68.     batch_size  = K.cast(K.shape(yolo_outputs[0])[0], K.dtype(y_true[0]))
  71.     #-----------------------------------------------------------#
  72.     #   取出每一张图片
  73.     #   m的值就是batch_size
  74.     #-----------------------------------------------------------#
  75.     m = K.shape(yolo_outputs[0])[0]
  77.     #-----------------------------------------------------------#
  78.     #   对特征层进行循环
  79.     #   grid_anchors    代表每一个特征层所对应的先验框
  80.     #   grid_whs        代表每一个特征层所对应的宽高
  81.     #   reshape_outputs 代表YOLO网络的输出
  82.     #   reshape_y_true  代表真实框的情况
  83.     #-----------------------------------------------------------#
  84.     grid_anchors    = []
  85.     grid_whs        = []
  86.     reshape_outputs = []
  87.     reshape_y_true  = []
  88.     for l in range(len(anchors_mask)):
  89.         grid_anchor, grid_wh = get_grid_anchors(yolo_outputs[l], anchors[anchors_mask[l]])
  90.         grid_anchors.append(grid_anchor)
  91.         grid_whs.append(grid_wh)
  93.         reshape_outputs.append(K.reshape(yolo_outputs[l], [batch_size, -1, num_classes + 5]))
  94.         reshape_y_true.append(K.reshape(y_true[l], [batch_size, -1, num_classes + 5]))
  96.     grid_anchors    = K.concatenate(grid_anchors, axis = 0)
  97.     grid_whs        = K.concatenate(grid_whs, axis = 0)
  98.     reshape_outputs = K.concatenate(reshape_outputs, axis = 1)
  99.     reshape_y_true  = K.concatenate(reshape_y_true, axis = 1)
  101.     #----------------------------------------------------------#
  102.     #   取出该特征层中存在目标的点的位置。(m,num_anchor,1)
  103.     #-----------------------------------------------------------#
  104.     object_mask      = reshape_y_true[..., 4:5]
  105.     #-----------------------------------------------------------#
  106.     #   取出其对应的种类(m,num_anchor,80)
  107.     #-----------------------------------------------------------#
  108.     true_class_probs = reshape_y_true[..., 5:]
  109.     #-----------------------------------------------------------#
  110.     #   将yolo_outputs的特征层输出进行处理，对先验框进行解码！
  111.     #   pred_xy     (m,num_anchor,2) 解码后的中心坐标
  112.     #   pred_wh     (m,num_anchor,2) 解码后的宽高坐标
  113.     #-----------------------------------------------------------#
  114.     box_xy, box_wh, _, _ = decode_anchors(reshape_outputs, grid_anchors, grid_whs, input_shape)
  115.     #-----------------------------------------------------------#
  116.     #   pred_box是解码后的预测的box的位置 (m,num_anchor,4)
  117.     #-----------------------------------------------------------#
  118.     pred_box = K.concatenate([box_xy, box_wh])
  119.     #-----------------------------------------------------------#
  120.     #   找到负样本群组，第一步是创建一个数组，[]
  121.     #-----------------------------------------------------------#
  122.     ignore_mask         = tf.TensorArray(K.dtype(y_true[0]), size = 1, dynamic_size = True)
  123.     object_mask_bool    = K.cast(object_mask, 'bool')
  124.     #-----------------------------------------------------------#
  125.     #   对每一张图片计算ignore_mask
  126.     #-----------------------------------------------------------#
  127.     def loop_body(b, ignore_mask):
  128.         #-----------------------------------------------------------#
  129.         #   取出n个真实框：n,4
  130.         #-----------------------------------------------------------#
  131.         true_box = tf.boolean_mask(reshape_y_true[b, ..., 0:4], object_mask_bool[b, ..., 0])
  132.         #-----------------------------------------------------------#
  133.         #   计算预测框与真实框的iou
  134.         #   pred_box    (num_anchor,4) 预测框的坐标
  135.         #   true_box    (n,4)          真实框的坐标
  136.         #   iou         (num_anchor,n) 预测框和真实框的iou
  137.         #-----------------------------------------------------------#
  138.         iou = box_iou(pred_box[b], true_box)
  140.         #-----------------------------------------------------------#
  141.         #   best_iou    (num_anchor,) 每个特征点与真实框的最大重合程度
  142.         #-----------------------------------------------------------#
  143.         best_iou = K.max(iou, axis=-1)
  145.         #-----------------------------------------------------------#
  146.         #   将与真实框重合度小于0.5以下的预测框对应的先验框作为负样本
  147.         #   当预测框和真实框重合度较大时，不宜作为负样本。
  148.         #   因为这些框已经预测的比较准确了
  149.         #-----------------------------------------------------------#
  150.         ignore_mask = ignore_mask.write(b, K.cast(best_iou < ignore_thresh, K.dtype(true_box)))
  151.         return b + 1, ignore_mask
  153.     #-----------------------------------------------------------#
  154.     #   在这个地方进行一个循环、循环是对每一张图片进行的
  155.     #-----------------------------------------------------------#
  156.     _, ignore_mask = tf.while_loop(lambda b,*args: b<m, loop_body, [0, ignore_mask])
  158.     #-----------------------------------------------------------#
  159.     #   ignore_mask用于提取出作为负样本的特征点
  160.     #   (m,num_anchor)
  161.     #-----------------------------------------------------------#
  162.     ignore_mask = ignore_mask.stack()
  163.     #   (m,num_anchor,1)
  164.     ignore_mask = K.expand_dims(ignore_mask, -1)
  165.     #-----------------------------------------------------------#
  166.     #   将真实框进行编码，使其格式与预测的相同，后面用于计算loss
  167.     #-----------------------------------------------------------#
  168.     raw_true_xy = reshape_y_true[..., :2] * grid_whs - grid_anchors[..., :2]
  169.     raw_true_wh = K.log(reshape_y_true[..., 2:4] / grid_anchors[..., 2:] * input_shape[::-1])
  170.     #-----------------------------------------------------------#
  171.     #   object_mask如果真实存在目标则保存其wh值
  172.     #   switch接口，就是一个if/else条件判断语句
  173.     #-----------------------------------------------------------#
  174.     raw_true_wh = K.switch(object_mask, raw_true_wh, K.zeros_like(raw_true_wh))
  175.     #-----------------------------------------------------------#
  176.     #   reshape_y_true[...,2:3]和reshape_y_true[...,3:4]
  177.     #   表示真实框的宽高，二者均在0-1之间
  178.     #   真实框越大，比重越小，小框的比重更大。
  179.     #-----------------------------------------------------------#
  180.     box_loss_scale = 2 - reshape_y_true[...,2:3] * reshape_y_true[...,3:4]
  181.     #-----------------------------------------------------------#
  182.     #   利用binary_crossentropy计算中心点偏移情况，效果更好
  183.     #-----------------------------------------------------------#
  184.     xy_loss = object_mask * box_loss_scale * K.binary_crossentropy(raw_true_xy, reshape_outputs[...,0:2], from_logits=True)
  185.     #-----------------------------------------------------------#
  186.     #   wh_loss用于计算宽高损失
  187.     #-----------------------------------------------------------#
  188.     wh_loss = object_mask * box_loss_scale * 0.5 * K.square(raw_true_wh - reshape_outputs[...,2:4])
  190.     #------------------------------------------------------------------------------#
  191.     #   如果该位置本来有框，那么计算1与置信度的交叉熵
  192.     #   如果该位置本来没有框，那么计算0与置信度的交叉熵
  193.     #   在这其中会忽略一部分样本，这些被忽略的样本满足条件best_iou<ignore_thresh
  194.     #   该操作的目的是：
  195.     #   忽略预测结果与真实框非常对应特征点，因为这些框已经比较准了
  196.     #   不适合当作负样本，所以忽略掉。
  197.     #------------------------------------------------------------------------------#
  198.     confidence_loss = object_mask * K.binary_crossentropy(object_mask, reshape_outputs[...,4:5], from_logits=True) + \
  199.                 (1 - object_mask) * K.binary_crossentropy(object_mask, reshape_outputs[...,4:5], from_logits=True) * ignore_mask
  201.     class_loss      = object_mask * K.binary_crossentropy(true_class_probs, reshape_outputs[...,5:], from_logits=True)
  203.     #-----------------------------------------------------------#
  204.     #   将所有损失求和
  205.     #-----------------------------------------------------------#
  206.     xy_loss         = K.sum(xy_loss)
  207.     wh_loss         = K.sum(wh_loss)
  208.     confidence_loss = K.sum(confidence_loss)
  209.     class_loss      = K.sum(class_loss)
  210.     #-----------------------------------------------------------#
  211.     #   计算正样本数量
  212.     #-----------------------------------------------------------#
  213.     num_pos = tf.maximum(K.sum(K.cast(object_mask, tf.float32)), 1)
  214.     loss    = xy_loss + wh_loss + confidence_loss + class_loss
  215.     if print_loss:
  216.         loss = tf.Print(loss, [loss, xy_loss, wh_loss, confidence_loss, class_loss, tf.shape(ignore_mask)], summarize=100, message='loss: ')
  217.     loss = loss / num_pos
  218.     return loss

训练自己的YoloV3模型

首先前往Github下载对应的仓库，下载完后利用解压软件解压，之后用编程软件打开文件夹。
注意打开的根目录必须正确，否则相对目录不正确的情况下，代码将无法运行。
一定要注意打开后的根目录是文件存放的目录。
在这里插入图片描述

一、数据集的准备

本文使用VOC格式进行训练，训练前需要自己制作好数据集，如果没有自己的数据集，可以通过Github连接下载VOC12+07的数据集尝试下。
训练前将标签文件放在VOCdevkit文件夹下的VOC2007文件夹下的Annotation中。
在这里插入图片描述
训练前将图片文件放在VOCdevkit文件夹下的VOC2007文件夹下的JPEGImages中。
在这里插入图片描述
此时数据集的摆放已经结束。

二、数据集的处理

在完成数据集的摆放之后，我们需要对数据集进行下一步的处理，目的是获得训练用的2007_train.txt以及2007_val.txt，需要用到根目录下的voc_annotation.py。

voc_annotation.py里面有一些参数需要设置。
分别是annotation_mode、classes_path、trainval_percent、train_percent、VOCdevkit_path，第一次训练可以仅修改classes_path

  1. '''
  2. annotation_mode用于指定该文件运行时计算的内容
  3. annotation_mode为0代表整个标签处理过程，包括获得VOCdevkit/VOC2007/ImageSets里面的txt以及训练用的2007_train.txt、2007_val.txt
  4. annotation_mode为1代表获得VOCdevkit/VOC2007/ImageSets里面的txt
  5. annotation_mode为2代表获得训练用的2007_train.txt、2007_val.txt
  6. '''
  7. annotation_mode     = 0
  8. '''
  9. 必须要修改，用于生成2007_train.txt、2007_val.txt的目标信息
  10. 与训练和预测所用的classes_path一致即可
  11. 如果生成的2007_train.txt里面没有目标信息
  12. 那么就是因为classes没有设定正确
  13. 仅在annotation_mode为0和2的时候有效
  14. '''
  15. classes_path        = 'model_data/voc_classes.txt'
  16. '''
  17. trainval_percent用于指定(训练集+验证集)与测试集的比例，默认情况下 (训练集+验证集):测试集 = 9:1
  18. train_percent用于指定(训练集+验证集)中训练集与验证集的比例，默认情况下 训练集:验证集 = 9:1
  19. 仅在annotation_mode为0和1的时候有效
  20. '''
  21. trainval_percent    = 0.9
  22. train_percent       = 0.9
  23. '''
  24. 指向VOC数据集所在的文件夹
  25. 默认指向根目录下的VOC数据集
  26. '''
  27. VOCdevkit_path  = 'VOCdevkit'

classes_path用于指向检测类别所对应的txt，以voc数据集为例，我们用的txt为：
在这里插入图片描述
训练自己的数据集时，可以自己建立一个cls_classes.txt，里面写自己所需要区分的类别。

三、开始网络训练

通过voc_annotation.py我们已经生成了2007_train.txt以及2007_val.txt，此时我们可以开始训练了。
训练的参数较多，大家可以在下载库后仔细看注释，其中最重要的部分依然是train.py里的classes_path。

classes_path用于指向检测类别所对应的txt，这个txt和voc_annotation.py里面的txt一样！训练自己的数据集必须要修改！
在这里插入图片描述
修改完classes_path后就可以运行train.py开始训练了，在训练多个epoch后，权值会生成在logs文件夹中。
其它参数的作用如下：

  1. '''
  2. 是否使用eager模式训练
  3. '''
  4. eager = False
  5. '''
  6. 训练前一定要修改classes_path，使其对应自己的数据集
  7. '''
  8. classes_path    = 'model_data/voc_classes.txt'
  9. '''
  10. anchors_path代表先验框对应的txt文件，一般不修改。
  11. anchors_mask用于帮助代码找到对应的先验框，一般不修改。
  12. '''
  13. anchors_path    = 'model_data/yolo_anchors.txt'
  14. anchors_mask    = [[6, 7, 8], [3, 4, 5], [0, 1, 2]]
  15. '''
  16. 权值文件请看README，百度网盘下载
  17. 训练自己的数据集时提示维度不匹配正常，预测的东西都不一样了自然维度不匹配
  18. 预训练权重对于99%的情况都必须要用，不用的话权值太过随机，特征提取效果不明显
  19. 网络训练的结果也不会好，数据的预训练权重对不同数据集是通用的，因为特征是通用的
  20. '''
  21. model_path      = 'model_data/yolo_weight.h5'
  22. '''
  23. 输入的shape大小，一定要是32的倍数
  24. '''
  25. input_shape     = [416, 416]
  26. '''
  27. 训练分为两个阶段，分别是冻结阶段和解冻阶段
  28. 冻结阶段训练参数
  29. 此时模型的主干被冻结了，特征提取网络不发生改变
  30. 占用的显存较小，仅对网络进行微调
  31. '''
  32. Init_Epoch          = 0
  33. Freeze_Epoch        = 50
  34. Freeze_batch_size   = 8
  35. Freeze_lr           = 1e-3
  36. '''
  37. 解冻阶段训练参数
  38. 此时模型的主干不被冻结了，特征提取网络会发生改变
  39. 占用的显存较大，网络所有的参数都会发生改变
  40. '''
  41. UnFreeze_Epoch      = 100
  42. Unfreeze_batch_size = 4
  43. Unfreeze_lr         = 1e-4
  44. '''
  45. 是否进行冻结训练，默认先冻结主干训练后解冻训练。
  46. '''
  47. Freeze_Train        = True
  48. '''
  49. 用于设置是否使用多线程读取数据，0代表关闭多线程
  50. 开启后会加快数据读取速度，但是会占用更多内存
  51. keras里开启多线程有些时候速度反而慢了许多
  52. 在IO为瓶颈的时候再开启多线程，即GPU运算速度远大于读取图片的速度。
  53. '''
  54. num_workers         = 0
  55. '''
  56. 获得图片路径和标签
  57. '''
  58. train_annotation_path   = '2007_train.txt'
  59. val_annotation_path     = '2007_val.txt'

四、训练结果预测

训练结果预测需要用到两个文件，分别是yolo.py和predict.py。
我们首先需要去yolo.py里面修改model_path以及classes_path，这两个参数必须要修改。

model_path指向训练好的权值文件，在logs文件夹里。
classes_path指向检测类别所对应的txt。
在这里插入图片描述
完成修改后就可以运行predict.py进行检测了。运行后输入图片路径即可检测。

发表评论

表情：
评论列表 （有 0 条评论，370人围观）

还没有评论，来说两句吧...

相关阅读