Keras搭建yolo3目标检测平台

源码下载
- yolo3实现思路
- - 一、预测部分
  - 二、训练部分
训练自己的yolo3模型

参考原文出处点击进入https://blog.csdn.net/weixin_44791964/article/details/103276106

源码下载

https://github.com/bubbliiiing/yolo3-keras

yolo3实现思路

一、预测部分

1、主题网络darknet53介绍

YoloV3所使用的主干特征提取网络为Darknet53，它具有两个重要特点：
1、Darknet53具有一个重要特点是使用了残差网络Residual，Darknet53中的残差卷积就是首先进行一次卷积核大小为3X3、步长为2的卷积，该卷积会压缩输入进来的特征层的宽和高，此时我们可以获得一个特征层，我们将该特征层命名为layer。之后我们再对该特征层进行一次1X1的卷积和一次3X3的卷积，并把这个结果加上layer，此时我们便构成了残差结构。通过不断的1X1卷积和3X3卷积以及残差边的叠加，我们便大幅度的加深了网络。残差网络的特点是容易优化，并且能够通过增加相当的深度来提高准确率。其内部的残差块使用了跳跃连接，缓解了在深度神经网络中增加深度带来的梯度消失问题。

2、Darknet53的每一个卷积部分使用了特有的DarknetConv2D结构，每一次卷积的时候进行l2正则化，完成卷积后进行BatchNormalization标准化与LeakyReLU。普通的ReLU是将所有的负值都设为零，Leaky ReLU则是给所有负值赋予一个非零斜率。以数学的方式我们可以表示为：

实现代码为：

from functools import wraps
from keras.layers import Conv2D, Add, ZeroPadding2D, UpSampling2D, Concatenate, MaxPooling2D
from keras.layers.advanced_activations import LeakyReLU
from keras.layers.normalization import BatchNormalization
from keras.regularizers import l2
from utils.utils import compose#--------------------------------------------------#
#   单次卷积
#--------------------------------------------------#
@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 + LeakyReLU
#---------------------------------------------------#
def DarknetConv2D_BN_Leaky(*args, **kwargs):no_bias_kwargs = {'use_bias': False}no_bias_kwargs.update(kwargs)return compose( DarknetConv2D(*args, **no_bias_kwargs),BatchNormalization(),LeakyReLU(alpha=0.1))#---------------------------------------------------#
#   卷积块
#   DarknetConv2D + BatchNormalization + LeakyReLU
#---------------------------------------------------#
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#---------------------------------------------------#
#   darknet53 的主体部分
#---------------------------------------------------#
def darknet_body(x):x = DarknetConv2D_BN_Leaky(32, (3,3))(x)x = resblock_body(x, 64, 1)x = resblock_body(x, 128, 2)x = resblock_body(x, 256, 8)feat1 = xx = resblock_body(x, 512, 8)feat2 = xx = resblock_body(x, 1024, 4)feat3 = xreturn feat1,feat2,feat3

2、从特征获取预测结果

从特征获取预测结果的过程可以分为两个部分，分别是：

构建FPN特征金字塔进行加强特征提取。
利用Yolo Head对三个有效特征层进行预测。
a、构建FPN特征金字塔进行加强特征提取
在特征利用部分，YoloV3提取多特征层进行目标检测，一共提取三个特征层。
三个特征层位于主干部分Darknet53的不同位置，分别位于中间层，中下层，底层，三个特征层的shape分别为(52,52,256)、(26,26,512)、(13,13,1024)。

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

13x13x1024的特征层进行5次卷积处理，处理完后利用YoloHead获得预测结果，一部分用于进行上采样UmSampling2d后与26x26x512特征层进行结合，结合特征层的shape为(26,26,768)。
结合特征层再次进行5次卷积处理，处理完后利用YoloHead获得预测结果，一部分用于进行上采样UmSampling2d后与52x52x256特征层进行结合，结合特征层的shape为(52,52,384)。
结合特征层再次进行5次卷积处理，处理完后利用YoloHead获得预测结果。
特征金字塔可以将不同shape的特征层进行特征融合，有利于提取出更好的特征。

b、利用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个先验框的位置。

实现代码如下：

from functools import wrapsimport numpy as np
import tensorflow as tf
from keras import backend as K
from keras.layers import Conv2D, Add, ZeroPadding2D, UpSampling2D, Concatenate, MaxPooling2D
from keras.layers.advanced_activations import LeakyReLU
from keras.layers.normalization import BatchNormalization
from keras.models import Model
from keras.regularizers import l2
from nets.darknet53 import darknet_body
from utils.utils import compose#--------------------------------------------------#
#   单次卷积
#--------------------------------------------------#
@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 + LeakyReLU
#---------------------------------------------------#
def DarknetConv2D_BN_Leaky(*args, **kwargs):no_bias_kwargs = {'use_bias': False}no_bias_kwargs.update(kwargs)return compose( DarknetConv2D(*args, **no_bias_kwargs),BatchNormalization(),LeakyReLU(alpha=0.1))#---------------------------------------------------#
#   特征层->最后的输出
#---------------------------------------------------#
def make_last_layers(x, num_filters, out_filters):# 五次卷积x = DarknetConv2D_BN_Leaky(num_filters, (1,1))(x)x = DarknetConv2D_BN_Leaky(num_filters*2, (3,3))(x)x = DarknetConv2D_BN_Leaky(num_filters, (1,1))(x)x = DarknetConv2D_BN_Leaky(num_filters*2, (3,3))(x)x = DarknetConv2D_BN_Leaky(num_filters, (1,1))(x)# 将最后的通道数调整为outfiltery = DarknetConv2D_BN_Leaky(num_filters*2, (3,3))(x)y = DarknetConv2D(out_filters, (1,1))(y)return x, y#---------------------------------------------------#
#   特征层->最后的输出
#---------------------------------------------------#
def yolo_body(inputs, num_anchors, num_classes):# 生成darknet53的主干模型feat1,feat2,feat3 = darknet_body(inputs)darknet = Model(inputs, feat3)# 第一个特征层# y1=(batch_size,13,13,3,85)x, y1 = make_last_layers(darknet.output, 512, num_anchors*(num_classes+5))x = compose(DarknetConv2D_BN_Leaky(256, (1,1)),UpSampling2D(2))(x)x = Concatenate()([x,feat2])# 第二个特征层# y2=(batch_size,26,26,3,85)x, y2 = make_last_layers(x, 256, num_anchors*(num_classes+5))x = compose(DarknetConv2D_BN_Leaky(128, (1,1)),UpSampling2D(2))(x)x = Concatenate()([x,feat1])# 第三个特征层# y3=(batch_size,52,52,3,85)x, y3 = make_last_layers(x, 128, num_anchors*(num_classes+5))return Model(inputs, [y1,y2,y3])

3、预测结果的解码
由第二步我们可以获得三个特征层的预测结果，shape分别为：

(N,13,13,255)
(N,26,26,255)
(N,52,52,255)
在这里我们简单了解一下每个有效特征层到底做了什么：
每一个有效特征层将整个图片分成与其长宽对应的网格，如(N,13,13,255)的特征层就是将整个图像分成13x13个网格；然后从每个网格中心建立多个先验框，这些框是网络预先设定好的框，网络的预测结果会判断这些框内是否包含物体，以及这个物体的种类。

由于每一个网格点都具有三个先验框，所以上述的预测结果可以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结合计算出预测框的宽高。这样就能得到整个预测框的位置了。

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

这一部分基本上是所有目标检测通用的部分。其对于每一个类进行判别：
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的网格#   (13, 13, 1, 2)#---------------------------------------------------#grid_shape = K.shape(feats)[1:3]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,13,13,3,85)#   85可拆分成4 + 1 + 80#   4代表的是中心宽高的调整参数#   1代表的是框的置信度#   80代表的是种类的置信度#---------------------------------------------------#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的时候返回grid, feats, box_xy, box_wh#   在预测的时候返回box_xy, box_wh, box_confidence, box_class_probs#---------------------------------------------------------------------#if calc_loss == True:return grid, feats, box_xy, box_whreturn box_xy, box_wh, box_confidence, box_class_probs#---------------------------------------------------#
#   对box进行调整，使其符合真实图片的样子
#---------------------------------------------------#
def yolo_correct_boxes(box_xy, box_wh, input_shape, image_shape):#-----------------------------------------------------------------##   把y轴放前面是因为方便预测框和图像的宽高进行相乘#-----------------------------------------------------------------#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是图像有效区域相对于图像左上角的偏移情况#   new_shape指的是宽高缩放情况#-----------------------------------------------------------------#offset = (input_shape-new_shape)/2./input_shapescale = input_shape/new_shapebox_yx = (box_yx - offset) * scalebox_hw *= scalebox_mins = box_yx - (box_hw / 2.)box_maxes = box_yx + (box_hw / 2.)boxes =  K.concatenate([box_mins[..., 0:1],  # y_minbox_mins[..., 1:2],  # x_minbox_maxes[..., 0:1],  # y_maxbox_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, letterbox_image):#-----------------------------------------------------------------##   将预测值调成真实值#   box_xy : -1,13,13,3,2; #   box_wh : -1,13,13,3,2; #   box_confidence : -1,13,13,3,1; #   box_class_probs : -1,13,13,3,80;#-----------------------------------------------------------------#box_xy, box_wh, box_confidence, box_class_probs = yolo_head(feats, anchors, num_classes, input_shape)#-----------------------------------------------------------------##   在图像传入网络预测前会进行letterbox_image给图像周围添加灰条#   因此生成的box_xy, box_wh是相对于有灰条的图像的#   我们需要对齐进行修改，去除灰条的部分。#   将box_xy、和box_wh调节成y_min,y_max,xmin,xmax#-----------------------------------------------------------------#if letterbox_image:boxes = yolo_correct_boxes(box_xy, box_wh, input_shape, image_shape)else:box_yx = box_xy[..., ::-1]box_hw = box_wh[..., ::-1]box_mins = box_yx - (box_hw / 2.)box_maxes = box_yx + (box_hw / 2.)input_shape = K.cast(input_shape, K.dtype(box_yx))image_shape = K.cast(image_shape, K.dtype(box_yx))boxes =  K.concatenate([box_mins[..., 0:1] * image_shape[0],  # y_minbox_mins[..., 1:2] * image_shape[1],  # x_minbox_maxes[..., 0:1] * image_shape[0],  # y_maxbox_maxes[..., 1:2] * image_shape[1]  # x_max])#-----------------------------------------------------------------##   获得最终得分和框的位置#-----------------------------------------------------------------#boxes = K.reshape(boxes, [-1, 4])box_scores = box_confidence * box_class_probsbox_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,letterbox_image=True):#---------------------------------------------------##   获得特征层的数量，有效特征层的数量为3#---------------------------------------------------#num_layers = len(yolo_outputs)#-----------------------------------------------------------##   13x13的特征层对应的anchor是[116,90],[156,198],[373,326]#   26x26的特征层对应的anchor是[30,61],[62,45],[59,119]#   52x52的特征层对应的anchor是[10,13],[16,30],[33,23]#-----------------------------------------------------------#anchor_mask = [[6,7,8], [3,4,5], [0,1,2]]#-----------------------------------------------------------##   这里获得的是输入图片的大小，一般是416x416#-----------------------------------------------------------#input_shape = K.shape(yolo_outputs[0])[1:3] * 32boxes = []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, letterbox_image)boxes.append(_boxes)box_scores.append(_box_scores)#-----------------------------------------------------------##   将每个特征层的结果进行堆叠#-----------------------------------------------------------#boxes = K.concatenate(boxes, axis=0)box_scores = K.concatenate(box_scores, axis=0)#-----------------------------------------------------------##   判断得分是否大于score_threshold#-----------------------------------------------------------#mask = box_scores >= score_thresholdmax_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])#-----------------------------------------------------------##   非极大抑制#   保留一定区域内得分最大的框#-----------------------------------------------------------#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') * cboxes_.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_

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

二、训练部分

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是什么
对于yolo3的模型来说，网络最后输出的内容就是三个特征层每个网格点对应的预测框及其种类，即三个特征层分别对应着图片被分为不同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的结构一致
在yolo3中，其使用了一个专门的函数用于处理读取进来的图片的框的真实情况。

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中将内容进行保存。

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

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

#---------------------------------------------------#
#   读入xml文件，并输出y_true
#---------------------------------------------------#
def preprocess_true_boxes(true_boxes, input_shape, anchors, num_classes):assert (true_boxes[..., 4]<num_classes).all(), 'class id must be less than num_classes'# 一共有三个特征层数num_layers = len(anchors)//3#-----------------------------------------------------------##   13x13的特征层对应的anchor是[116,90],[156,198],[373,326]#   26x26的特征层对应的anchor是[30,61],[62,45],[59,119]#   52x52的特征层对应的anchor是[10,13],[16,30],[33,23]#-----------------------------------------------------------#anchor_mask = [[6,7,8], [3,4,5], [0,1,2]]#-----------------------------------------------------------##   获得框的坐标和图片的大小#-----------------------------------------------------------#true_boxes = np.array(true_boxes, dtype='float32')input_shape = np.array(input_shape, dtype='int32')#-----------------------------------------------------------##   通过计算获得真实框的中心和宽高#   中心点(m,n,2) 宽高(m,n,2)#-----------------------------------------------------------#boxes_xy = (true_boxes[..., 0:2] + true_boxes[..., 2:4]) // 2boxes_wh = true_boxes[..., 2:4] - true_boxes[..., 0:2]#-----------------------------------------------------------##   将真实框归一化到小数形式#-----------------------------------------------------------#true_boxes[..., 0:2] = boxes_xy/input_shape[::-1]true_boxes[..., 2:4] = boxes_wh/input_shape[::-1]# m为图片数量，grid_shapes为网格的shapem = true_boxes.shape[0]grid_shapes = [input_shape//{0:32, 1:16, 2:8}[l] for l in range(num_layers)]#-----------------------------------------------------------##   y_true的格式为(m,13,13,3,85)(m,26,26,3,85)(m,52,52,3,85)#-----------------------------------------------------------#y_true = [np.zeros((m,grid_shapes[l][0],grid_shapes[l][1],len(anchor_mask[l]),5+num_classes),dtype='float32') for l in range(num_layers)]#-----------------------------------------------------------##   [9,2] -> [1,9,2]#-----------------------------------------------------------#anchors = np.expand_dims(anchors, 0)anchor_maxes = anchors / 2.anchor_mins = -anchor_maxes#-----------------------------------------------------------##   长宽要大于0才有效#-----------------------------------------------------------#valid_mask = boxes_wh[..., 0]>0for b in range(m):# 对每一张图进行处理wh = boxes_wh[b, valid_mask[b]]if len(wh)==0: continue#-----------------------------------------------------------##   [n,2] -> [n,1,2]#-----------------------------------------------------------#wh = np.expand_dims(wh, -2)box_maxes = wh / 2.box_mins = -box_maxes#-----------------------------------------------------------##   计算所有真实框和先验框的交并比#   intersect_area  [n,9]#   box_area        [n,1]#   anchor_area     [1,9]#   iou             [n,9]#-----------------------------------------------------------#intersect_mins = np.maximum(box_mins, anchor_mins)intersect_maxes = np.minimum(box_maxes, anchor_maxes)intersect_wh = np.maximum(intersect_maxes - intersect_mins, 0.)intersect_area = intersect_wh[..., 0] * intersect_wh[..., 1]box_area = wh[..., 0] * wh[..., 1]anchor_area = anchors[..., 0] * anchors[..., 1]iou = intersect_area / (box_area + anchor_area - intersect_area)#-----------------------------------------------------------##   维度是[n,] 感谢 消尽不死鸟 的提醒#-----------------------------------------------------------#best_anchor = np.argmax(iou, axis=-1)for t, n in enumerate(best_anchor):#-----------------------------------------------------------##   找到每个真实框所属的特征层#-----------------------------------------------------------#for l in range(num_layers):if n in anchor_mask[l]:#-----------------------------------------------------------##   floor用于向下取整，找到真实框所属的特征层对应的x、y轴坐标#-----------------------------------------------------------#i = np.floor(true_boxes[b,t,0] * grid_shapes[l][1]).astype('int32')j = np.floor(true_boxes[b,t,1] * grid_shapes[l][0]).astype('int32')#-----------------------------------------------------------##   k指的的当前这个特征点的第k个先验框#-----------------------------------------------------------#k = anchor_mask[l].index(n)#-----------------------------------------------------------##   c指的是当前这个真实框的种类#-----------------------------------------------------------#c = true_boxes[b, t, 4].astype('int32')#-----------------------------------------------------------##   y_true的shape为(m,13,13,3,85)(m,26,26,3,85)(m,52,52,3,85)#   最后的85可以拆分成4+1+80，4代表的是框的中心与宽高、#   1代表的是置信度、80代表的是种类#-----------------------------------------------------------#y_true[l][b, j, i, k, 0:4] = true_boxes[b, t, 0:4]y_true[l][b, j, i, k, 4] = 1y_true[l][b, j, i, k, 5+c] = 1return 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值：

import numpy as np
import tensorflow as tf
from keras import backend as K#---------------------------------------------------#
#   将预测值的每个特征层调成真实值
#---------------------------------------------------#
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的网格# (13, 13, 1, 2)grid_shape = K.shape(feats)[1:3] # height, widthgrid_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,13,13,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_whreturn box_xy, box_wh, box_confidence, box_class_probs#---------------------------------------------------#
#   用于计算每个预测框与真实框的iou
#---------------------------------------------------#
def box_iou(b1, b2):# 13,13,3,1,4# 计算左上角的坐标和右下角的坐标b1 = K.expand_dims(b1, -2)b1_xy = b1[..., :2]b1_wh = b1[..., 2:4]b1_wh_half = b1_wh/2.b1_mins = b1_xy - b1_wh_halfb1_maxes = b1_xy + b1_wh_half# 1,n,4# 计算左上角和右下角的坐标b2 = K.expand_dims(b2, 0)b2_xy = b2[..., :2]b2_wh = b2[..., 2:4]b2_wh_half = b2_wh/2.b2_mins = b2_xy - b2_wh_halfb2_maxes = b2_xy + b2_wh_half# 计算重合面积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]iou = intersect_area / (b1_area + b2_area - intersect_area)return iou#---------------------------------------------------#
#   loss值计算
#---------------------------------------------------#
def yolo_loss(args, anchors, num_classes, ignore_thresh=.5, print_loss=False, normalize=True):# 一共有三个特征层num_layers = len(anchors)//3 #---------------------------------------------------------------------------------------------------##   将预测结果和实际ground truth分开，args是[*model_body.output, *y_true]#   y_true是一个列表，包含三个特征层，shape分别为(m,13,13,3,85),(m,26,26,3,85),(m,52,52,3,85)。#   yolo_outputs是一个列表，包含三个特征层，shape分别为(m,13,13,3,85),(m,26,26,3,85),(m,52,52,3,85)。#---------------------------------------------------------------------------------------------------#y_true = args[num_layers:]yolo_outputs = args[:num_layers]#-----------------------------------------------------------##   13x13的特征层对应的anchor是[116,90],[156,198],[373,326]#   26x26的特征层对应的anchor是[30,61],[62,45],[59,119]#   52x52的特征层对应的anchor是[10,13],[16,30],[33,23]#-----------------------------------------------------------#anchor_mask = [[6,7,8], [3,4,5], [0,1,2]]# 得到input_shpae为416,416 input_shape = K.cast(K.shape(yolo_outputs[0])[1:3] * 32, K.dtype(y_true[0]))#-----------------------------------------------------------##   得到网格的shape为[13,13]; [26,26]; [52,52]#-----------------------------------------------------------#grid_shapes = [K.cast(K.shape(yolo_outputs[l])[1:3], K.dtype(y_true[0])) for l in range(num_layers)]loss = 0num_pos = 0#-----------------------------------------------------------##   取出每一张图片#   m的值就是batch_size#-----------------------------------------------------------#m = K.shape(yolo_outputs[0])[0]mf = K.cast(m, K.dtype(yolo_outputs[0]))#---------------------------------------------------------------------------------------------------##   y_true是一个列表，包含三个特征层，shape分别为(m,13,13,3,85),(m,26,26,3,85),(m,52,52,3,85)。#   yolo_outputs是一个列表，包含三个特征层，shape分别为(m,13,13,3,85),(m,26,26,3,85),(m,52,52,3,85)。#---------------------------------------------------------------------------------------------------#for l in range(num_layers):#-----------------------------------------------------------##   以第一个特征层(m,13,13,3,85)为例子#   取出该特征层中存在目标的点的位置。(m,13,13,3,1)#-----------------------------------------------------------#object_mask = y_true[l][..., 4:5]#-----------------------------------------------------------##   取出其对应的种类(m,13,13,3,80)#-----------------------------------------------------------#true_class_probs = y_true[l][..., 5:]#-----------------------------------------------------------##   将yolo_outputs的特征层输出进行处理、获得四个返回值#   其中：#   grid        (13,13,1,2) 网格坐标#   raw_pred    (m,13,13,3,85) 尚未处理的预测结果#   pred_xy     (m,13,13,3,2) 解码后的中心坐标#   pred_wh     (m,13,13,3,2) 解码后的宽高坐标#-----------------------------------------------------------#grid, raw_pred, pred_xy, pred_wh = yolo_head(yolo_outputs[l],anchors[anchor_mask[l]], num_classes, input_shape, calc_loss=True)#-----------------------------------------------------------##   pred_box是解码后的预测的box的位置#   (m,13,13,3,4)#-----------------------------------------------------------#pred_box = K.concatenate([pred_xy, pred_wh])#-----------------------------------------------------------##   找到负样本群组，第一步是创建一个数组，[]#-----------------------------------------------------------#ignore_mask = tf.TensorArray(K.dtype(y_true[0]), size=1, dynamic_size=True)object_mask_bool = K.cast(object_mask, 'bool')#-----------------------------------------------------------##   对每一张图片计算ignore_mask#-----------------------------------------------------------#def loop_body(b, ignore_mask):#-----------------------------------------------------------##   取出n个真实框：n,4#-----------------------------------------------------------#true_box = tf.boolean_mask(y_true[l][b,...,0:4], object_mask_bool[b,...,0])#-----------------------------------------------------------##   计算预测框与真实框的iou#   pred_box    13,13,3,4 预测框的坐标#   true_box    n,4 真实框的坐标#   iou         13,13,3,n 预测框和真实框的iou#-----------------------------------------------------------#iou = box_iou(pred_box[b], true_box)#-----------------------------------------------------------##   best_iou    13,13,3 每个特征点与真实框的最大重合程度#-----------------------------------------------------------#best_iou = K.max(iou, axis=-1)#-----------------------------------------------------------##   判断预测框和真实框的最大iou小于ignore_thresh#   则认为该预测框没有与之对应的真实框#   该操作的目的是：#   忽略预测结果与真实框非常对应特征点，因为这些框已经比较准了#   不适合当作负样本，所以忽略掉。#-----------------------------------------------------------#ignore_mask = ignore_mask.write(b, K.cast(best_iou<ignore_thresh, K.dtype(true_box)))return b+1, ignore_mask#-----------------------------------------------------------##   在这个地方进行一个循环、循环是对每一张图片进行的#-----------------------------------------------------------#_, ignore_mask = K.control_flow_ops.while_loop(lambda b,*args: b < m, loop_body, [0, ignore_mask])#-----------------------------------------------------------##   ignore_mask用于提取出作为负样本的特征点#   (m,13,13,3)#-----------------------------------------------------------#ignore_mask = ignore_mask.stack()#   (m,13,13,3,1)ignore_mask = K.expand_dims(ignore_mask, -1)#-----------------------------------------------------------##   将真实框进行编码，使其格式与预测的相同，后面用于计算loss#-----------------------------------------------------------#raw_true_xy = y_true[l][..., :2] * grid_shapes[l][:] - gridraw_true_wh = K.log(y_true[l][..., 2:4] / anchors[anchor_mask[l]] * input_shape[::-1])#-----------------------------------------------------------##   object_mask如果真实存在目标则保存其wh值#   switch接口，就是一个if/else条件判断语句#-----------------------------------------------------------#raw_true_wh = K.switch(object_mask, raw_true_wh, K.zeros_like(raw_true_wh))#-----------------------------------------------------------##   真实框越大，比重越小，小框的比重更大。#-----------------------------------------------------------#box_loss_scale = 2 - y_true[l][...,2:3]*y_true[l][...,3:4]#-----------------------------------------------------------##   利用binary_crossentropy计算中心点偏移情况，效果更好#-----------------------------------------------------------#xy_loss = object_mask * box_loss_scale * K.binary_crossentropy(raw_true_xy, raw_pred[...,0:2], from_logits=True)#-----------------------------------------------------------##   wh_loss用于计算宽高损失#-----------------------------------------------------------#wh_loss = object_mask * box_loss_scale * 0.5 * K.square(raw_true_wh-raw_pred[...,2:4])#------------------------------------------------------------------------------##   如果该位置本来有框，那么计算1与置信度的交叉熵#   如果该位置本来没有框，那么计算0与置信度的交叉熵#   在这其中会忽略一部分样本，这些被忽略的样本满足条件best_iou<ignore_thresh#   该操作的目的是：#   忽略预测结果与真实框非常对应特征点，因为这些框已经比较准了#   不适合当作负样本，所以忽略掉。#------------------------------------------------------------------------------#confidence_loss = object_mask * K.binary_crossentropy(object_mask, raw_pred[...,4:5], from_logits=True) + \(1-object_mask) * K.binary_crossentropy(object_mask, raw_pred[...,4:5], from_logits=True) * ignore_maskclass_loss = object_mask * K.binary_crossentropy(true_class_probs, raw_pred[...,5:], from_logits=True)#-----------------------------------------------------------##   将所有损失求和#-----------------------------------------------------------#xy_loss = K.sum(xy_loss)wh_loss = K.sum(wh_loss)confidence_loss = K.sum(confidence_loss)class_loss = K.sum(class_loss)#-----------------------------------------------------------##   计算正样本数量#-----------------------------------------------------------#num_pos += tf.maximum(K.sum(K.cast(object_mask, tf.float32)), 1)loss += xy_loss + wh_loss + confidence_loss + class_lossif print_loss:loss = tf.Print(loss, [loss, xy_loss, wh_loss, confidence_loss, class_loss, tf.shape(ignore_mask)], summarize=100, message='loss: ')if normalize:loss = loss / num_poselse:loss = loss / mfreturn loss

训练自己的yolo3模型

目标检测学习————Keras搭建yolo3目标检测平台相关推荐

（大佬）睿智的目标检测13——Keras搭建mtcnn人脸检测平台
原文链接:https://blog.csdn.net/weixin_44791964/article/details/103530206 睿智的目标检测13--Keras搭建mtcnn人脸检测平台学 ...
睿智的目标检测18——Keras搭建Faster-RCNN目标检测平台
睿智的目标检测18--Keras搭建FasterRCNN目标检测平台学习前言什么是FasterRCNN目标检测算法源码下载 Faster-RCNN实现思路一.预测部分 1.主干网络介绍 2.获 ...
睿智的目标检测33——Keras搭建Efficientdet目标检测平台
睿智的目标检测33--Keras搭建Efficientdet目标检测平台学习前言什么是Efficientdet目标检测算法源码下载 Efficientdet实现思路一.预测部分 1.主干网络介 ...
睿智的目标检测25——Keras搭建M2Det目标检测平台
睿智的目标检测25--Keras搭建M2Det目标检测平台学习前言什么是M2det目标检测算法源码下载 M2det实现思路一.预测部分 1.主干网络介绍 2.FFM1特征初步融合 3.细化U型 ...
睿智的目标检测62——Keras搭建YoloV7目标检测平台
睿智的目标检测62--Keras搭建YoloV7目标检测平台学习前言源码下载 YoloV7改进的部分(不完全) YoloV7实现思路一.整体结构解析二.网络结构解析 1.主干网络Backbon ...
睿智的目标检测17——Keras搭建Retinanet目标检测平台
睿智的目标检测17--Keras搭建Retinanet目标检测平台学习前言什么是Retinanet目标检测算法源码下载 Retinanet实现思路一.预测部分 1.主干网络介绍 2.从特征获取 ...
睿智的目标检测41——Pytorch搭建Retinanet目标检测平台
睿智的目标检测41--Keras搭建Retinanet目标检测平台学习前言什么是Retinanet目标检测算法源码下载 Retinanet实现思路一.预测部分 1.主干网络介绍 2.从特征获取 ...
睿智的目标检测30——Pytorch搭建YoloV4目标检测平台
睿智的目标检测30--Pytorch搭建YoloV4目标检测平台学习前言什么是YOLOV4 代码下载 YOLOV4改进的部分(不完全) YOLOV4结构解析 1.主干特征提取网络Backbone ...
睿智的目标检测32——TF2搭建YoloV4目标检测平台（tensorflow2）
睿智的目标检测32--TF2搭建YoloV4目标检测平台(tensorflow2) 学习前言什么是YOLOV4 代码下载 YOLOV4改进的部分(不完全) YOLOV4结构解析 1.主干特征提取网络 ...

目标检测学习————Keras搭建yolo3目标检测平台