object detection[YOLO]

这部分,我们来聊聊YOLO.
YOLO:You Only Look Once,顾名思义,就是希望网络在训练过程中,一张图片只要看一次就行,不需要去多次观察,比如滑框啥的,从而从底层原理上就减少了很多的计算量。

0 - 扯扯


图1.YOLOv1检测过程
上图为YOLOv1的检测过程(其实第二版在整体框架上也大同小异,细节自然不同),模型都会统一将输入图片resize到448*448,然后建立CNN模型,在最后的全连接层上对应最后的输出结果。在流程上,模型就是一个整体,所以相对更容易优化,而且也减少了分离模型之间信息传递的缺失,直接就是从像素级别到预测类别和框位置的这么一个结果
Yolo是将对象检测看成一个回归问题(空间上对象框的预测和对应的类别概率)(待后面看到目标函数才知精彩)。
作者认为YOLO的优势有
1 - 因为其他模型需要先滑框或者基于当前位置框,用分类器分类当前框内是否有对象,然后接着对当前框进行微调等复杂的组成,这里就一个模型,所以快。
2 - 不同于滑框和基于锚点(就是提前定几个不同大小的框)等技术,YOLO基于全图进行训练所以,它能够编码潜在的图片中检测到的类别上下文信息(作者在v2版本就用了锚点)。所以相对Fast R-CNN来说,YOLO能够更少的得到假阳性(也就是把背景框出来了)。
3 - YOLO能学到更广泛的对象表征,所以在自然场景下训练比如COCO,然后在艺术风格图片上预测,效果也好于R-CNN系列。

1 - YOLO框架


图2.YOLO的网络结构
该结构有24个卷积层2个全连接层,其中用1x1的卷积层来减少特征空间参数。作者是先将该网络在imagenet上以224*224先做分类预训练,然后留待后面检测。


图3.YOLO的目标函数
个人觉得yolov1中最出彩的就是这个目标函数了。这里我们一一解释:
如图2所示,最后会得到一个\(7*7*30\)的张量,而如何将这个\(7*7*30\)的张量对应到既要分类又要目标的框坐标预测,那就有意思了。首先看下图:

图4.模型
网格划分:YOLO的思想是先将图片划分成不同的网格,然后假如狗这个对象的中心是在第5行第2列(左上为原点),那么cell[5,2]就负责整个对象的检测。比如图4中划分成了\(S*S\)个网格,其中S就是对应着最后的7,也就是这张图片一共分成了\(7*7\)个网格,所以最后的张量中\(7*7*30\)中的30 就是针对当前网格所需要干的其他事情了。

框预测:基于每个网格,会预测需要的B个框(也就是担心预测的一个框不准,所以多预测几个),作者这里选择2个,即\(B=2\),在框预测阶段,需要每个框给出5个值,分别是\(x,y,w,h,confidence\)。其中
i)\(x,y\)表示基于当前网格中心为参照得到的预测框的中心坐标;
ii)\(w,h\)表示预测框相对于整个图的width和height;
iii)\(confidence = P_{object}*IOU_{pred}^{truth}\)。这里IOU的想法是来自文档检索领域的,这里就不细说了,\(IOU=\frac{真实框\bigcap 预测框}{真实框 \bigcup 预测框}\).这里的置信度就是当前区域是否有对象的概率乘以IOU的值,可以看出如果当前区域没对象,那么该置信度就是为0.
iv)因为作者采用的是voc数据集,里面一共有20个类别,所以one-hot就是20维,所以上面的30对应的就是(2*5+20)。

回顾目标函数:基于上面的网格划分和框预测,我们知道最后的\(7*7*30\)是会在每个网格上都计算一次,这里我们省去目标函数中的\(S^2\)那个求和,即基于某一个网格I来分析(下面将\(1_{Ij}^{obj}\)缩写成\(1_{j}^{obj}\)):

\[\begin{split}\\ & &\lambda_{coord}\sum_{j=0}^B1_{j}^{obj}[(x_I-\hat x_I)^2+(y_I-\hat y_I)^2]\\ &+&\lambda_{coord}\sum_{j=0}^B1_{j}^{obj}[(\sqrt{w_I}-\sqrt{\hat w_I})^2+(\sqrt{h_I}-\sqrt{\hat h_I})^2]\\ &+&\sum_{j=0}^B1_{j}^{obj}(C_I-\hat C_I)^2\\ &+& \lambda_{noobj}\sum_{j=0}^{B}1_{j}^{noobj}(C_I-\hat C_I)^2\\ &+& 1_{I}^{obj}\sum_{c \in classes}(p_I(c)-\hat p_I(c))^2 \end{split}\]

其中\(1_{i}^{obj}\)表示第i个网格是否有对象的真值函数,即满足则为1,否则为0;而\(1_{ij}^{obj}\)表示在第i个网格中第j个预测候选框负责预测。I
在实现时,获取当前网格的30维度向量基础上,前面5位为一个预测候选框的值:d[:2]为\(x,y\), d[2:4]为\(w,h\); d[4]为置信度;剩下的d[10:30]为类别对象预测

那么就2种情况,当前网格有对象和没有对象。而且作者是这样说的,只惩罚当该网格中有对象的时候的分类错误,即如果不存在对象,那么分类上就不惩罚了;而且只惩罚负责预测当前对象的那个候选框,置于这个框怎么选,就是选取候选框中IOU最大的那个:
1 - 没有对象。则\(1_{I}^{obj}\)=0,从而该网格计算的损失函数值为\(\lambda_{noobj}\sum_{j=0}^B1_{j}^{noobj}(C_i-\hat C_i)^2\)
2 - 有对象。则开始计算损失值,首先计算B个预测候选框与真实框的IOU,然后只在那个最大IOU的候选框上计算\(x,y,w,h\),和置信度。
其中\(C\)就是置信度,而\((C_I-\hat C_I)^2\)就是表示预测的置信度减去真实的置信度,因\(confidence = P_{object}*IOU_{pred}^{truth}\),所以IOU一开始并无法给出,其中\(C_I\)就是模型给出的一个值,而\(\hat C_I\)是在训练过程中才能给出的值。(置信度等于出现对象概率乘以IOU,因对象概率在目标函数其他地方就已存在,我们剥离对象概率,所以就是预测IOU的值等于真实IOU的值。即当模型在test的时候,该值能告知当前预测框的置信度)
结合github上hizhangp的代码理解

def loss_layer(self, predicts, labels, scope='loss_layer'):
   with tf.variable_scope(scope):
       #从预测的向量中取出对应的部分
       predict_classes = tf.reshape(predicts[:, :self.boundary1], [self.batch_size, self.cell_size, self.cell_size, self.num_class])
       predict_scales = tf.reshape(predicts[:, self.boundary1:self.boundary2], [self.batch_size, self.cell_size, self.cell_size, self.boxes_per_cell])
       predict_boxes = tf.reshape(predicts[:, self.boundary2:], [self.batch_size, self.cell_size, self.cell_size, self.boxes_per_cell, 4])

       #从label中计算并生成,response表示某个对象的中心是否落在当前cell中
       response = tf.reshape(labels[:, :, :, 0], [self.batch_size, self.cell_size, self.cell_size, 1])
       #从label中计算当前对象的坐标信息
       boxes = tf.reshape(labels[:, :, :, 1:5], [self.batch_size, self.cell_size, self.cell_size, 1, 4])
       boxes = tf.tile(boxes, [1, 1, 1, self.boxes_per_cell, 1]) / self.image_size
       #因为是label,所以box就一个,从5:25都是20类的类别信息
       classes = labels[:, :, :, 5:]

       offset = tf.constant(self.offset, dtype=tf.float32)
       offset = tf.reshape(offset, [1, self.cell_size, self.cell_size, self.boxes_per_cell])
       offset = tf.tile(offset, [self.batch_size, 1, 1, 1])
       predict_boxes_tran = tf.stack([(predict_boxes[:, :, :, :, 0] + offset) / self.cell_size,
                                           (predict_boxes[:, :, :, :, 1] + tf.transpose(offset, (0, 2, 1, 3))) / self.cell_size,
                                           tf.square(predict_boxes[:, :, :, :, 2]),
                                           tf.square(predict_boxes[:, :, :, :, 3])])
       predict_boxes_tran = tf.transpose(predict_boxes_tran, [1, 2, 3, 4, 0])
       #计算预测出来的box与真实box的IOU
       iou_predict_truth = self.calc_iou(predict_boxes_tran, boxes)
       
        # calculate I tensor [BATCH_SIZE, CELL_SIZE, CELL_SIZE, BOXES_PER_CELL]
       #选择IOU最大的那个候选框作为预测框
       object_mask = tf.reduce_max(iou_predict_truth, 3, keep_dims=True)
       object_mask = tf.cast((iou_predict_truth >= object_mask), tf.float32) * response

        # calculate no_I tensor [CELL_SIZE, CELL_SIZE, BOXES_PER_CELL]
       noobject_mask = tf.ones_like(object_mask, dtype=tf.float32) - object_mask

       boxes_tran = tf.stack([boxes[:, :, :, :, 0] * self.cell_size - offset,
                                   boxes[:, :, :, :, 1] * self.cell_size - tf.transpose(offset, (0, 2, 1, 3)),
                                   tf.sqrt(boxes[:, :, :, :, 2]),
                                   tf.sqrt(boxes[:, :, :, :, 3])])
       boxes_tran = tf.transpose(boxes_tran, [1, 2, 3, 4, 0])

            # class_loss
       #当response为1,则表示当前cell有对象,否则当前cell的分类loss为0
       class_delta = response * (predict_classes - classes)
       class_loss = tf.reduce_mean(tf.reduce_sum(tf.square(class_delta), axis=[1, 2, 3]), name='class_loss') * self.class_scale

        # object_loss
       #选取最大那个IOU作为预测框,然后计算置信度的损失,这里predict_scales是网络预测出的值,iou_predict_truth是当前预测框与真实框的IOU
       object_delta = object_mask * (predict_scales - iou_predict_truth)
       object_loss = tf.reduce_mean(tf.reduce_sum(tf.square(object_delta), axis=[1, 2, 3]), name='object_loss') * self.object_scale

            # noobject_loss
       noobject_delta = noobject_mask * predict_scales
       noobject_loss = tf.reduce_mean(tf.reduce_sum(tf.square(noobject_delta), axis=[1, 2, 3]), name='noobject_loss') * self.noobject_scale

            # coord_loss
       coord_mask = tf.expand_dims(object_mask, 4)
       boxes_delta = coord_mask * (predict_boxes - boxes_tran)
       coord_loss = tf.reduce_mean(tf.reduce_sum(tf.square(boxes_delta), axis=[1, 2, 3, 4]), name='coord_loss') * self.coord_scale

       tf.losses.add_loss(class_loss)
       tf.losses.add_loss(object_loss)
       tf.losses.add_loss(noobject_loss)
       tf.losses.add_loss(coord_loss)

2 - 训练过程

1 - 预训练

在设计出图2的网络结构基础上,需要先基于imagenet的一个预训练,从而找到较好的初始值作为后面的对象检测。所以作者先将图2的前20层卷积层后面部分全部删除,然后加个平均池化层和一个全连接层。作者在imagenet 2012 上训练了1个礼拜,并在验证集上获得了top5 88%准确度。

2 - 将模型用于检测

在得到上述训练好的模型基础上,将后面的平均池化层和全连接层扔掉,接上4个卷积层和2个全连接层(权重都是随机初始化),然后将图片输入大小从224224调整到448448。为了好计算,所以只使用了平方函数,然后为了使得分类导致的惩罚和定位导致的惩罚程度有所不同,增加有对象基础上的定位误差,减少无对象的置信度;并且在大对象上的框误差的严重程度远小于小对象上的框误差程度,所以接着在\(w,h\)上使用了开根号。

posted @ 2017-08-22 14:46  仙守  阅读(806)  评论(0编辑  收藏  举报