目标检测之YOLOv2，最详细的代码解析

 

一、前言

最近一直在研究深度学习在目标检测的应用，看完了YOLOv2的paper和YAD2K的实现源码，来总结一下自己的收获，以便于加深理解。

二、关于目标检测

目标检测可简单划分成两个任务，一个是分类，一个是确定bounding boxes。目前目标检测领域的深度学习方法主要分为两类：two stage的目标检测算法；one stage的目标检测算法。前者是先由算法生成一系列作为样本的候选框，再通过卷积神经网络进行样本分类；后者则不用产生候选框，直接将目标边框定位的问题转化为回归问题处理。正是由于两种方法的差异，在性能上也有不同，前者在检测准确率和定位精度上占优，后者在算法速度上占优。YOLO（You Only Look Once ）则是一种one stage的目标检测算法，目前已经迭代发布了三个版本YOLOv1、YOLOv2、YOLOv3。本文着重介绍的是YOLOv2。

三、YOLOv2的改进

作者在论文中主要总结了关于YOLOv2的三个方面改进：Better、Faster、Stronger。这不是本片文章我想分享的主要内容，因为有太多博主已经写的很透彻了，所以这部分我就只是很简单的稍微叙述了作者的思想，公式比较难编辑也基本没写。可以看下我黑体字的概括，如果想要了解更多的细节，可以搜搜别的博客看看。

 

YOLOv2的改进

 

1、Better

• （1）batch Normalization
  每个卷积层后均使用batch Normalization
  采用Batch Normalization可以提升模型收敛速度，而且可以起到一定正则化效果，降低模型的过拟合。在YOLOv2中，每个卷积层后面都添加了Batch Normalization层，并且不再使用droput。使用Batch Normalization后，YOLOv2的mAP提升了2.4%。

   

  

  Bacth_Normalizing

   

• （2）High ResolutionClassifier
  预训练分类模型采用了更高分辨率的图片
  YOLOv1先在ImageNet（224x224）分类数据集上预训练模型的主体部分（大部分目标检测算法），获得较好的分类效果，然后再训练网络的时候将网络的输入从224x224增加为448x448。但是直接切换分辨率，检测模型可能难以快速适应高分辨率。所以YOLOv2增加了在ImageNet数据集上使用448x448的输入来finetune分类网络这一中间过程（10 epochs），这可以使得模型在检测数据集上finetune之前已经适用高分辨率输入。使用高分辨率分类器后，YOLOv2的mAP提升了约4%。

   

  

  YOLOv2训练的三个阶段

   

• （3）Convolutional With Anchor Boxes
  使用了anchor boxes去预测bounding boxes，去掉了最后的全连接层，网络仅采用了卷积层和池化层
  在YOLOv1中，输入图片最终被划分为7x7的gird cell，每个单元格预测2个边界框。YOLOv1最后采用的是全连接层直接对边界框进行预测，其中边界框的宽与高是相对整张图片大小的，而由于各个图片中存在不同尺度和长宽比（scales and ratios）的物体，YOLOv1在训练过程中学习适应不同物体的形状是比较困难的，这也导致YOLOv1在精确定位方面表现较差。YOLOv2则引入了一个anchor boxes的概念，这样做的目的就是得到更高的召回率，yolov1只有98个边界框，yolov2可以达到1000多个（论文中的实现是845个）。还去除了全连接层，保留一定空间结构信息，网络仅由卷积层和池化层构成。输入由448x448变为416x416，下采样32倍，输出为13x13x5x25。采用奇数的gird cell 是因为大图像的中心往往位于图像中间，为了避免四个gird cell参与预测，我们更希望用一个gird cell去预测。结果mAP由69.5下降到69.2，下降了0.3，召回率由81%提升到88%，提升7%。尽管mAP下降，但召回率的上升意味着我们的模型有更大的提升空间。

• （4）Dimension Clusters（关于anchor boxes的第一个问题：如何确定尺寸）
  利用Kmeans聚类，解决了anchor boxes的尺寸选择问题
  在Faster R-CNN和SSD中，先验框的维度（长和宽）都是手动设定的，带有一定的主观性。如果选取的先验框维度比较合适，那么模型更容易学习，从而做出更好的预测。因此，YOLOv2采用k-means聚类方法对训练集中的边界框做了聚类分析。比较了复杂度和精确度后，选用了K值为5。因为设置先验框的主要目的是为了使得预测框与ground truth的IOU更好，所以聚类分析时选用box与聚类中心box之间的IOU值作为距离指标：

   

  

  距离公式
   

  

  Dimension_Clusters.png

   

• （5）Direction locationprediction（关于anchor boxes的第二个问题：如何确定位置）
  引入Sigmoid函数预测offset，解决了anchor boxes的预测位置问题，采用了新的损失函数
  作者借鉴了RPN网络使用的anchor boxes去预测bounding boxes相对于图片分辨率的offset，通过(x,y,w,h)四个维度去确定anchor boxes的位置，但是这样在早期迭代中x,y会非常不稳定，因为RPN是一个区域预测一次，但是YOLO中是169个gird cell一起预测，处于A gird cell 的x,y可能会跑到B gird cell中，到处乱跑，导致不稳定。作者巧妙的引用了sigmoid函数来规约x,y的值在（0,1）轻松解决了这个offset的问题。关于w,h的也改进了YOLOv1中平方差的差的平方的方法，用了RPN中的log函数。

• （6）Fine-Grained Features
  采用了passthrough层，去捕捉更细粒度的特征
  YOLOv2提出了一种passthrough层来利用更精细的特征图，Fine-Grained Features之后YOLOv2的性能有1%的提升。

• （7）Multi-Scale Training
  采用不同尺寸的图片训练，提高鲁棒性
  由于YOLOv2模型中只有卷积层和池化层，所以YOLOv2的输入可以不限于416x416大小的图片。为了增强模型的鲁棒性，YOLOv2采用了多尺度输入训练策略，具体来说就是在训练过程中每间隔一定的iterations之后改变模型的输入图片大小。由于YOLOv2的下采样总步长为32，输入图片大小选择一系列为32倍数的值：{320,352,384,...,608}，输入图片最小为320x320，此时对应的特征图大小为10x10（不是奇数了，确实有点尴尬），而输入图片最大为 608x608，对应的特征图大小为19x19。在训练过程，每隔10个iterations随机选择一种输入图片大小，然后只需要修改对最后检测层的处理就可以重新训练。采用Multi-Scale Training策略，YOLOv2可以适应不同大小的图片，并且预测出很好的结果。

2、Faster

 

 

大多数检测框架依赖于VGG-16作为的基本特征提取器。VGG-16是一个强大的，准确的分类网络，但它是不必要的复杂。在单张图像224×224分辨率的情况下VGG-16的卷积层运行一次前馈传播需要306.90亿次浮点运算。YOLO框架使用基于Googlenet架构的自定义网络。这个网络比VGG-16更快，一次前馈传播只有85.2亿次的操作。然而，它的准确性比VGG-16略差。在ImageNet上，对于单张裁剪图像，224×224分辨率下的top-5准确率，YOLO的自定义模型获得了88.0%，而VGG-16则为90.0%。YOLOv2使用Darknet-19网络，有19个卷积层和5个最大池化层。相比YOLOv1的24个卷积层和2个全连接层精简了网络。

 

YOLOv2网络图.png

3、Stronger

 

 

这里作者的想法也很新颖，解决了2个不同数据集相互排斥(mutualy exclusive)的问题。作者提出了WordTree，使用该树形结构成功的解决了不同数据集中的排斥问题。使用该树形结构进行分层的预测分类，在某个阈值处结束或者最终达到叶子节点处结束。下面这副图将有助于WordTree这个概念的理解。

 

word_tree

四、YAD2K代码解析

YAD2K用了90%的Keras和10%Tensorflow实现的YOLOv2。下面主要分析一下/yad2k/models/keras_yolo.py这个文件里的代码。
提示：其实boxes的坐标是[y,x,h,w]而不是[x,y,w,h]。
流程：数据先经过preprocess_true_boxes（）函数处理，然后做一些处理输入到模型，损失函数是yolo_loss（），网络最后一个卷积层的输出作为函数yolo_head（）的输入，然后再使用函数yolo_eval（），得到结果。

1、preprocess_true_boxes（）

这个函数是得到detectors_mask（最佳预测的anchor boxes，每一个true boxes都对应一个anchor boxes），matching_true_boxes（用于后面和pred_boxes做差求loss）代码后都给了比较详细的注释

def preprocess_true_boxes(true_boxes, anchors, image_size): """ 参数 -------------- true_boxes : 实际框的位置和类别，我们的输入。二个维度： 第一个维度：一张图片中有几个实际框 第二个维度： [x, y, w, h, class]，x,y 是框中心点坐标，w,h 是框的宽度和高度。x,y,w,h 均是除以图片 分辨率得到的[0,1]范围的比值。 anchors : 实际anchor boxes 的值，论文中使用了五个。[w,h]，都是相对于gird cell 的比值。二个维度： 第一个维度：anchor boxes的数量，这里是5 第二个维度：[w,h]，w,h,都是相对于gird cell长宽的比值。 [1.08, 1.19], [3.42, 4.41], [6.63, 11.38], [9.42, 5.11], [16.62, 10.52] image_size : 图片的实际尺寸。这里是416x416。 Returns -------------- detectors_mask : 取值是0或者1，这里的shape是[13,13,5,1]，四个维度。 第一个维度：true_boxes的中心位于第几行（y方向上属于第几个gird cell） 第二个维度：true_boxes的中心位于第几列（x方向上属于第几个gird cell） 第三个维度：哪个anchor box 第四个维度：0/1。1的就是用于预测改true boxes 的 anchor boxes matching_true_boxes: 这里的shape是[13,13,5,5]，四个维度。 第一个维度：true_boxes的中心位于第几行（y方向上属于第几个gird cel） 第二个维度：true_boxes的中心位于第几列（x方向上属于第几个gird cel） 第三个维度：第几个anchor box 第四个维度：[x,y,w,h,class]。这里的x，y表示offset，是相当于gird cell的，w,h是取了log函数的， class是属于第几类。后面的代码会详细看到 """ height, width = image_size num_anchors = len(anchors) assert height % 32 == 0, '输入的图片的高度必须是32的倍数，不然会报错。' assert width % 32 == 0, '输入的图片的宽度必须是32的倍数，不然会报错。' conv_height = height // 32 '进行gird cell划分' conv_width = width // 32 '进行gird cell划分' num_box_params = true_boxes.shape[1] detectors_mask = np.zeros( (conv_height, conv_width, num_anchors, 1), dtype=np.float32) matching_true_boxes = np.zeros( (conv_height, conv_width, num_anchors, num_box_params), dtype=np.float32) '确定detectors_mask和matching_true_boxes的维度，用0填充' for box in true_boxes: '遍历实际框' box_class = box[4:5] '提取类别信息，属于哪类' box = box[0:4] * np.array( [conv_width, conv_height, conv_width, conv_height]) '换算成相对于gird cell的值' i = np.floor(box[1]).astype('int') '（y方向上属于第几个gird cell）' j = np.floor(box[0]).astype('int') '（x方向上属于第几个gird cell）' best_iou = 0 best_anchor = 0 '计算anchor boxes 和 true boxes的iou，找到最佳预测的一个anchor boxes' for k, anchor in enumerate(anchors): # Find IOU between box shifted to origin and anchor box. box_maxes = box[2:4] / 2. box_mins = -box_maxes anchor_maxes = (anchor / 2.) anchor_mins = -anchor_maxes 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 = box[2] * box[3] anchor_area = anchor[0] * anchor[1] iou = intersect_area / (box_area + anchor_area - intersect_area) if iou > best_iou: best_iou = iou best_anchor = k if best_iou > 0: detectors_mask[i, j, best_anchor] = 1 '找到最佳预测anchor boxes' adjusted_box = np.array( [ box[0] - j, box[1] - i, 'x,y都是相对于gird cell的位置，左上角[0,0]，右下角[1,1]' np.log(box[2] / anchors[best_anchor][0]), '对应实际框w,h和anchor boxes w,h的比值取log函数' np.log(box[3] / anchors[best_anchor][1]), box_class 'class实际框的物体是属于第几类' ], dtype=np.float32) matching_true_boxes[i, j, best_anchor] = adjusted_box return detectors_mask, matching_true_boxes 

2、yolo_head（）

这个函数是输入yolo的输出层的特征，转化成相对于gird cell坐标的x,y，相对于gird cell长宽的w,h，pred_confidence是判断否存在物体的概率，pred_class_prob是sofrmax后各个类别分别的概率。返回值x,y,w,h在loss function中计算iou，然后计算iou损失。然后和pred_confidence计算confidence_loss，pred_class_prob用于计算classification_loss。

def yolo_head(feats, anchors, num_classes): """Convert final layer features to bounding box parameters. 参数 ---------- feats : 神经网络最后一层的输出，shape：[-1,13,13,125] anchors : 实际anchor boxes 的值，论文中使用了五个。[w,h]，都是相对于gird cell 长宽的比值。二个维度： 第一个维度：anchor boxes的数量，这里是5 第二个维度：[w,h]，w,h,都是相对于gird cell 长宽的比值。 [1.08, 1.19], [3.42, 4.41], [6.63, 11.38], [9.42, 5.11], [16.62, 10.52] num_classes : 类别个数（有多少类） 返回值 ------- box_xy : 每张图片的每个gird cell中的每个pred_boxes中心点x,y相对于其所在gird cell的坐标值，左上顶点为[0,0],右下顶点为[1,1]。 有五个维度，shape:[-1,13,13,5,2]. 第一个维度：图片张数 第二个维度：每组x,y在pred_boxes的行坐标信息（y方向上属于第几个gird cell） 第三个维度：每组x,y在pred_boxes的列坐标信息（x方向上属于第几个gird cell） 第四个维度：每组x,y的anchor box信息（使用第几个anchor boxes） 第五个维度：[x,y],中心点x,y相对于gird cell的坐标值 box_wh : 每张图片的每个gird cell中的每个pred_boxes的w,h都是相对于gird cell的比值 有五个维度，shape:[-1,13,13,5,2]. 第一个维度：图片张数 第二个维度：每组w,h对应的x,y在pred_boxes的行坐标信息（y方向上属于第几个gird cell） 第三个维度：每组w,h对应的x,y在pred_boxes的列坐标信息（x方向上属于第几个gird cell） 第四个维度：每组w,h对应的x,y的anchor box信息（使用第几个anchor boxes） 第五个维度：[w,h],w,h都是相对于gird cell的比值 box_confidence : 每张图片的每个gird cell中的每个pred_boxes的，判断是否存在可检测物体的概率。五个维度，shape:[-1,13,13,5,1]。各维度信息同上。 box_class_pred : 每张图片的每个gird cell中的每个pred_boxes所框起来的各个类别分别的概率(经过了softmax)。shape:[-1,13,13,5,20] """ num_anchors = len(anchors) # Reshape to batch, height, width, num_anchors, box_params. anchors_tensor = K.reshape(K.variable(anchors), [1, 1, 1, num_anchors, 2]) conv_dims = K.shape(feats)[1:3] '用多少个gird cell划分图片，这里是13x13' # In YOLO the height index is the inner most iteration. conv_height_index = K.arange(0, stop=conv_dims[0]) conv_width_index = K.arange(0, stop=conv_dims[1]) conv_height_index = K.tile(conv_height_index, [conv_dims[1]]) conv_width_index = K.tile( K.expand_dims(conv_width_index, 0), [conv_dims[0], 1]) conv_width_index = K.flatten(K.transpose(conv_width_index)) conv_index = K.transpose(K.stack([conv_height_index, conv_width_index])) conv_index = K.reshape(conv_index, [1, conv_dims[0], conv_dims[1], 1, 2]) 'shape:[1，13，13，1，2]' conv_index = K.cast(conv_index, K.dtype(feats)) ' tile（）：平移， expand_dims（）：增加维度 transpose（）：转置 flatten（）：降成一维 stack（）：堆积，增加一个维度 conv_index:[0,0],[0,1],...,[0,12],[1,0],[1,1],...,[12,12]（大概是这个样子） ' feats = K.reshape( feats, [-1, conv_dims[0], conv_dims[1], num_anchors, num_classes + 5]) conv_dims = K.cast(K.reshape(conv_dims, [1, 1, 1, 1, 2]), K.dtype(feats)) box_xy = K.sigmoid(feats[..., :2]) box_wh = K.exp(feats[..., 2:4]) box_confidence = K.sigmoid(feats[..., 4:5]) box_class_probs = K.softmax(feats[..., 5:]) # Adjust preditions to each spatial grid point and anchor size. # Note: YOLO iterates over height index before width index. box_xy = (box_xy + conv_index) / conv_dims box_wh = box_wh * anchors_tensor / conv_dims return box_xy, box_wh, box_confidence, box_class_probs 

3、yolo_loss（）

YOLOv2的损失函数较YOLOv1也有比较大的改变，主要分为三大部分的损失，IOU损失，分类损失，坐标损失。IOU损失分为了no_objects_loss和objects_loss，两者相比对objects_loss的惩罚更大。下面简单介绍一下和YOLOv1的区别。

3.1、confidence_loss：

YOLOv2中，总共有845个anchor_boxes，与true_boxes匹配的用于预测pred_boxes，未与true_boxes匹配的anchor_boxes用于预测background。

• objects_loss（true_boxes所匹配的anchor_boxes）
  与true_boxes所匹配的anchor_boxes去和预测的pred_boxes计算objects_loss。
• no_objects_loss（true_boxes未匹配的anchor_boxes）
  1、未与true_boxes所匹配的anchor_boxes中，若与true_boxes的IOU>0.6，则无需计算loss。
  2、未与true_boxes所匹配的anchor_boxes中，若与true_boxes的IOU<0.6，则计算no_objects_loss。

这里疑惑点比较多，也比较绕，不太好理解，自己当时也理解错了。后来自己理解：confidence是为了衡量anchor_boxes是否有物体的置信度，对于负责预测前景（pred_boxes）的anchors_boxes来说，我们必须计算objects_loss；对于负责预测背景（background）的anchors_boxes来说，若与true_boxes的IOU<0.6，我们需要计算no_objects_loss。这两条都好理解，因为都是各干各的活。但若与true_boxes的IOU>0.6时，则不需要计算no_objects_loss。这是为什么呢？因为它给了我们惊喜，我们不忍苛责它。一个负责预测背景的anchor_boxes居然和true_boxes的IOU>0.6，框的甚至比那些本来就负责预测前景的anchors要准，吃的是草，挤的是奶，怎么能再惩罚它呢？好了言归正传，我个人觉得是因为被true_boxes的中心点可能在附近的gird cell里，但是true_boxes又比较大，导致它和附近gird cell里的anchors_boxes的IOU很大，那么这部分造成的损失可以不进行计算，毕竟它确实框的也准。就像faster rcnn中0.3<IOU<0.7的anchors一样不造成损失，因为这部分并不是重点需要优化的对象。
与YOLOv1不同的是修正系数的改变，YOLOv1中no_objects_loss和objects_loss分别是0.5和1，而YOLOv2中则是1和5。

3.2、classification_loss：

这部分和YOLOv1基本一致，就是经过softmax（）后，20维向量（数据集中分类种类为20种）的均方误差。

3.3、coordinates_loss：

这里较YOLOv1的改动较大，计算x,y的误差由相对于整个图像（416x416）的offset坐标误差的均方改变为相对于gird cell的offset（这个offset是取sigmoid函数得到的处于（0,1）的值）坐标误差的均方。也将修正系数由5改为了1 。计算w,h的误差由w,h平方根的差的均方误差变为了，w,h与对true_boxes匹配的anchor_boxes的长宽的比值取log函数，和YOLOv1的想法一样，对于相等的误差值，降低对大物体误差的惩罚，加大对小物体误差的惩罚。同时也将修正系数由5改为了1。

def yolo_loss(args, anchors, num_classes, rescore_confidence=False, print_loss=False): """ 参数 ---------- yolo_output : 神经网络最后一层的输出，shape:[batch_size,13,13,125] true_boxes : 实际框的位置和类别，我们的输入。三个维度： 第一个维度：图片张数 第二个维度：一张图片中有几个实际框 第三个维度： [x, y, w, h, class]，x,y 是实际框的中心点坐标，w,h 是框的宽度和高度。x,y,w,h 均是除以图片分辨率得到的[0,1]范围的值。 detectors_mask : 取值是0或者1，这里的shape是[ batch_size，13,13,5,1]，其值可参考函数preprocess_true_boxes（）的输出，五个维度： 第一个维度：图片张数 第二个维度：true_boxes的中心位于第几行（y方向上属于第几个gird cell） 第三个维度：true_boxes的中心位于第几列（x方向上属于第几个gird cell） 第四个维度：哪个anchor box 第五个维度：0/1。1的就是用于预测改true boxes 的 anchor boxes matching_true_boxes :这里的shape是[-1,13,13,5,5]，其值可参考函数preprocess_true_boxes（）的输出，五个维度： 第一个维度：图片张数 第二个维度：true_boxes的中心位于第几行（y方向上属于第几个gird cel） 第三个维度：true_boxes的中心位于第几列（x方向上属于第几个gird cel） 第四个维度：第几个anchor box 第五个维度：[x,y,w,h,class]。这里的x，y表示offset，是相当于gird cell的坐标，w,h是取了log函数的，class是属于第几类。 anchors : 实际anchor boxes 的值，论文中使用了五个。[w,h]，都是相对于gird cell 长宽的比值。二个维度： 第一个维度：anchor boxes的数量，这里是5 第二个维度：[w,h]，w,h,都是相对于gird cell 长宽的比值。 [1.08, 1.19], [3.42, 4.41], [6.63, 11.38], [9.42, 5.11], [16.62, 10.52] num_classes :类别个数（有多少类） rescore_confidence : bool值，False和True计算confidence_loss的objects_loss不同，后面代码可以看到。 print_loss : bool值，是否打印损失，包括总损失，IOU损失，分类损失，坐标损失 返回值 ------- total_loss : float，总损失 """ (yolo_output, true_boxes, detectors_mask, matching_true_boxes) = args num_anchors = len(anchors) object_scale = 5 '物体位于gird cell时计算置信度的修正系数' no_object_scale = 1 '物体位于gird cell时计算置信度的修正系数' class_scale = 1 '计算分类损失的修正系数' coordinates_scale = 1 '计算坐标损失的修正系数' pred_xy, pred_wh, pred_confidence, pred_class_prob = yolo_head( yolo_output, anchors, num_classes) yolo_output_shape = K.shape(yolo_output) feats = K.reshape(yolo_output, [ -1, yolo_output_shape[1], yolo_output_shape[2], num_anchors, num_classes + 5]) 'shape:[-1,13,13,5,25]' pred_boxes = K.concatenate( (K.sigmoid(feats[..., 0:2]), feats[..., 2:4]), axis=-1) '合并得到pred_boxes的x,y,w,h，用于和matching_true_boxes计算坐标损失,shape:[-1,13,13,5,4]' # Expand pred x,y,w,h to allow comparison with ground truth. # batch, conv_height, conv_width, num_anchors, num_true_boxes, box_params pred_xy = K.expand_dims(pred_xy, 4) '增加一个维度由[-1,13,13,5,2]变成[-1,13,13,5,1,2]' pred_wh = K.expand_dims(pred_wh, 4) '增加一个维度由[-1,13,13,5,2]变成[-1,13,13,5,1,2]' pred_wh_half = pred_wh / 2. pred_mins = pred_xy - pred_wh_half pred_maxes = pred_xy + pred_wh_half '计算pred_boxes左上顶点和右下顶点的坐标' true_boxes_shape = K.shape(true_boxes) true_boxes = K.reshape(true_boxes, [true_boxes_shape[0], 1, 1, 1, true_boxes_shape[1], true_boxes_shape[2]]) 'shape:[-1,1,1,1,-1,5],batch, conv_height, conv_width, num_anchors, num_true_boxes, box_params' true_xy = true_boxes[..., 0:2] true_wh = true_boxes[..., 2:4] true_wh_half = true_wh / 2. true_mins = true_xy - true_wh_half true_maxes = true_xy + true_wh_half '计算true_boxes左上顶点和右下顶点的坐标' intersect_mins = K.maximum(pred_mins, true_mins) intersect_maxes = K.minimum(pred_maxes, true_maxes) intersect_wh = K.maximum(intersect_maxes - intersect_mins, 0.) intersect_areas = intersect_wh[..., 0] * intersect_wh[..., 1] pred_areas = pred_wh[..., 0] * pred_wh[..., 1] true_areas = true_wh[..., 0] * true_wh[..., 1] union_areas = pred_areas + true_areas - intersect_areas iou_scores = intersect_areas / union_areas '计算出所有anchor boxes（这里是一张图片845个）和true_boxes的IOU，shape:[-1,13,13,5,2,1]' best_ious = K.max(iou_scores, axis=4) '这里很有意思，若两个true_boxes落在同一个gird cell里，我只取iou最大的那一个， 因为best_iou这个值只关心在这个gird cell中最大的那个iou，不关心来自于哪个true_boxes。' best_ious = K.expand_dims(best_ious) 'shape:[1,-1,13,13,5,1]' object_detections = K.cast(best_ious > 0.6, K.dtype(best_ious)) '选出IOU大于0.6的，不关注其损失。cast（）函数，第一个参数是bool值，dtype是int，就会转换成0,1' no_object_weights = (no_object_scale * (1 - object_detections) * (1 - detectors_mask)) no_objects_loss = no_object_weights * K.square(-pred_confidence) if rescore_confidence: objects_loss = (object_scale * detectors_mask * K.square(best_ious - pred_confidence)) else: objects_loss = (object_scale * detectors_mask * K.square(1 - pred_confidence)) confidence_loss = objects_loss + no_objects_loss '计算confidence_loss，no_objects_loss是计算background的误差， objects_loss是计算与true_box匹配的anchor_boxes的误差，相比较no_objects_loss更关注这部分误差，其修正系数为5' matching_classes = K.cast(matching_true_boxes[..., 4], 'int32') matching_classes = K.one_hot(matching_classes, num_classes) classification_loss = (class_scale * detectors_mask * K.square(matching_classes - pred_class_prob)) '计算classification_loss，20维向量的差' matching_boxes = matching_true_boxes[..., 0:4] coordinates_loss = (coordinates_scale * detectors_mask * K.square(matching_boxes - pred_boxes)) '计算coordinates_loss， x,y都是offset的均方损失，w,h是取了对数的均方损失，与YOLOv1中的平方根的差的均方类似，效果比其略好一点' confidence_loss_sum = K.sum(confidence_loss) classification_loss_sum = K.sum(classification_loss) coordinates_loss_sum = K.sum(coordinates_loss) total_loss = 0.5 * ( confidence_loss_sum + classification_loss_sum + coordinates_loss_sum) if print_loss: total_loss = tf.Print( total_loss, [ total_loss, confidence_loss_sum, classification_loss_sum, coordinates_loss_sum ], message='yolo_loss, conf_loss, class_loss, box_coord_loss:') return total_loss 

4、 yolo_boxes_to_corners（）

这个函数很简单，就是将yolo_head（）函数输出的的x,y作为输入，求出该boxes的左上顶点和右下顶点，作为yolo_filter_boxes（）的输入，可用于画出bounding box。

def yolo_boxes_to_corners(box_xy, box_wh): box_mins = box_xy - (box_wh / 2.) box_maxes = box_xy + (box_wh / 2.) return K.concatenate([ box_mins[..., 1:2], # y_min box_mins[..., 0:1], # x_min box_maxes[..., 1:2], # y_max box_maxes[..., 0:1] # x_max ]) 

5、yolo_filter_boxes（）

从845个 pred_boxes中选出置信度大于0.6的作为最终的predict bounding boxes，实际训练时取了0.3，返回它的左上顶点和右下顶点坐标，置信度，分类类别。

def yolo_filter_boxes(boxes, box_confidence, box_class_probs, threshold=.6): box_scores = box_confidence * box_class_probs '定义一个box_scores，就是该 bounding boxes的置信度。shape:[-1,13,13,5,20]' box_classes = K.argmax(box_scores, axis=-1) '求出最大box_scores的索引，即属于第几类' box_class_scores = K.max(box_scores, axis=-1) '求出最大box_scores的值，作为bounding boxes的置信度' prediction_mask = box_class_scores >= threshold '选出box_scores大于设定阈值的anchor_boxes，bool值，配合tf.boolean_mask（）函数获取True所在位置的值' boxes = tf.boolean_mask(boxes, prediction_mask) ' 符合要求的bounding boxes' scores = tf.boolean_mask(box_class_scores, prediction_mask) '其对应的置信度' classes = tf.boolean_mask(box_classes, prediction_mask) '其对应的分类结果' return boxes, scores, classes 

6、yolo_eval（）

其中嵌套使用了yolo_boxes_to_corners（）函数和yolo_filter_boxes（）函数，然后对使用了置信度筛选后的bounding boxes使用了非极大值抑制输出 boxes, scores, classes，分别是bounding boxes的左上顶点和右下顶点的坐标，bounding boxes的置信度，bounding boxes的的分类类别。

def yolo_eval(yolo_outputs, image_shape, max_boxes=10, score_threshold=.6, iou_threshold=.5): box_xy, box_wh, box_confidence, box_class_probs = yolo_outputs 'yolo_outputs是yolo_head的输出' boxes = yolo_boxes_to_corners(box_xy, box_wh) boxes, scores, classes = yolo_filter_boxes( boxes, box_confidence, box_class_probs, threshold=score_threshold) 'image_shape,(416x416)' height = image_shape[0] width = image_shape[1] image_dims = K.stack([height, width, height, width]) image_dims = K.reshape(image_dims, [1, 4]) boxes = boxes * image_dims '乘以图片分辨率，得到真实的x,y,w,h' '运行一下NMS，非极大值抑制，iou_threshold默认是0.5，在训练时实际取了0.9，但是这里没有分类别使用，我猜测这也是提高阈值的原因吧' max_boxes_tensor = K.variable(max_boxes, dtype='int32') K.get_session().run(tf.variables_initializer([max_boxes_tensor])) nms_index = tf.image.non_max_suppression( boxes, scores, max_boxes_tensor, iou_threshold=iou_threshold) boxes = K.gather(boxes, nms_index) 'gather()函数，获取索引对应的值' scores = K.gather(scores, nms_index) classes = K.gather(classes, nms_index) return boxes, scores, classes 

五、YOLO的优缺点

不得不感叹作者的创新能力，给我们带来了这么好的YOLO。YOLO算法的优点不言而喻，you only look once，不吃计算资源，在精度保证的情况下，运行速度快。缺点也很明显就是bounding boxes的位置不够准确，对于小物体和密集物体检测效果差，召回率较低，但这也是YOLOv2主要改进的地方。

六、个人问题

同时这里提出一个YOLO的问题，在YAD2K中，如果一张图片中有两个true boxes，然后位于同一个gird cell，最优匹配了同一个anchor boxes，似乎只能预测那个IOU最好的一个true boxes，不知道YOLOv2的源代码是否有这样的问题，也希望有大佬指点一下我。。。

七、总结

写出这篇文章也是自己的总结，看论文啃代码的确实很难熬，但是也让自己更加深刻的理解了YOLO的来龙去脉，领略了作者的思想，收获了更多。接下来我也要去领略一下YOLOv3的魅力了，如果有时间，我也会将YOLOv3的学习过程分享出来。加油！

作者：_从前从前_
链接：https://www.jianshu.com/p/032b1eecb335
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。