目标检测算法-YOLO-V1训练代码详解

YOLO-V1网络结构由24个卷积层与2个全连接层构成，网络入口为448×448×3，输出维度：S×S×(B×5+C)，S为划分网格数，B为每个网格负责目标个数，C为类别个数。

YOLO-V1是将一副图像分成S×S个网格，如果某个object的中心落在这个网格中，则这个网格就负责预测这个object，每个网格要预测B个bounding box，每个bounding box要预测一个confidence值，这个confidence代表了所预测的bounding box中含有object的置信度和这个bounding box预测的有多准这两个重要信息。

Pr(Object)∗IoUpredtruth​

如果有object落在一个网格中，公式第一项取1，否则取0，第二项是bounding box和真实框的IOU的值(confidence针对每个bounding box，框中有没有网格包含object中心点。YOLO-V1中每个网格有两个bounding box，对于每个bounding box有5个预测值，x,y,w,h,confidence,每一个网格还要预测C条件类别的概率，即在一个网格包含一个object的前提下，它属于某个类别的概率。(x,y)表示bounding box相对于网格单元的边界的offset，归一化到(0,1)范围之内，而w,h表示相对于整个图片的预测宽和高，也被归一化到(0,1)范围内。c代表的是object在某个bounding box的confidence。confidence计算如下：

 Pr(Classi​∣Object)∗Pr(Object)∗IoUpredtruth​=Pr(Classi​)∗IoUpredtruth​

下面说明如何将预测坐标的x,y用相对于对应网格的offset归一化到0-1和w,h是如何利用图像的宽高归一化到0-1之间。每个单元格预测的B个(x,y,w,h,confidence)向量，假设图片为S×S个网格，S=7，图片宽为w​i高为hi 。

下面引用一张我看过的感觉讲解很详细的一张图片：

 

1.(x,y)是bbox的中心相对于单元格的offset对应于上图中的蓝色单元格，坐标为(xc​ol=1,yr​ow=4),加射它的预测输出是红色框bbox，设bbox的中心坐标为(xc,yc),那么最终预测出来的(x,y)是经过归一化处理的，表示的是相对于单元格的offset，公式为：x=wi​ / xc ​​∗ S−xcol​，y=hi / ​yc ∗ S−yrow​

 2.(w,h)是bbox相对于整个图片的比例预测的bbox的宽高为wb,hb,(w,h)表示的是bbox相对于整张图片的占比，公式为:w=wi​ / wb​​,h=hi / ​hb​​

YOLO-V1中需要的参数

 

---

 

 

def __init__(self):
    self.classes = ["aeroplane", "bicycle", "bird", "boat", "bottle",
                    "bus", "car", "cat", "chair", "cow", "diningtable",
                    "dog", "horse", "motorbike", "person", "pottedplant",
                    "sheep", "sofa", "train", "tvmonitor"]
    #计算坐标用的
    self.x_offset = np.transpose(np.reshape(np.array([np.arange(7)] * 7 * 2, dtype=np.float32), [2, 7, 7]), [1, 2, 0])
    self.y_offset = np.transpose(self.x_offset, [1, 0, 2])
    #输入图片大小
    self.img_size = (448, 448)
    #阈值
    self.iou_threshold = 0.5
    self.batch_size = 45
    #计算loss需要的参数
    self.class_scale = 2.0
    self.object_scale = 1.0
    self.noobject_scale = 1.0
    self.coord_scale = 5.0

 

---

网络部分开始

---

 

def _build_net(self):
    x = tf.placeholder(tf.float32, [None, 448, 448, 3])
    with tf.variable_scope('yolo'):
        net = self.conv_layer(x, 64, 7, 2, 'conv_2')
        net = self.max_pool_layer(net, 2, 2)
        net = self.conv_layer(net, 192, 3, 1, 'conv_4')
        net = self.max_pool_layer(net, 2, 2)
        net = self.conv_layer(net, 128, 1, 1, 'conv_6')
        net = self.conv_layer(net, 256, 3, 1, 'conv_7')
        net = self.conv_layer(net, 256, 1, 1, 'conv_8')
        net = self.conv_layer(net, 512, 3, 1, 'conv_9')
        net = self.max_pool_layer(net, 2, 2)
        net = self.conv_layer(net, 256, 1, 1, 'conv_11')
        net = self.conv_layer(net, 512, 3, 1, 'conv_12')
        net = self.conv_layer(net, 256, 1, 1, 'conv_13')
        net = self.conv_layer(net, 512, 3, 1, 'conv_14')
        net = self.conv_layer(net, 256, 1, 1, 'conv_15')
        net = self.conv_layer(net, 512, 3, 1, 'conv_16')
        net = self.conv_layer(net, 256, 1, 1, 'conv_17')
        net = self.conv_layer(net, 512, 3, 1, 'conv_18')
        net = self.conv_layer(net, 512, 1, 1, 'conv_19')
        net = self.conv_layer(net, 1024, 3, 1, 'conv_20')
        net = self.max_pool_layer(net, 2, 2)
        net = self.conv_layer(net, 512, 1, 1, 'conv_22')
        net = self.conv_layer(net, 1024, 3, 1, 'conv_23')
        net = self.conv_layer(net, 512, 1, 1, 'conv_24')
        net = self.conv_layer(net, 1024, 3, 1, 'conv_25')
        net = self.conv_layer(net, 1024, 3, 1, 'conv_26')
        net = self.conv_layer(net, 1024, 3, 2, 'conv_28')
        net = self.conv_layer(net, 1024, 3, 1, 'conv_29')
        net = self.conv_layer(net, 1024, 3, 1, 'conv_30')
        net = self.flatten_layer(net)
        net = self.dense_layer(net, 512, activation=self.Leaky_Relu, scope='fc_33')
        net = self.dense_layer(net, 4096, activation=self.Leaky_Relu, scope='fc_34')
        net = self.dense_layer(net, 7 * 7 * 30, scope='fc_36')
    return net

 

需要的一些层

# 激活函数使用Leaky
def Leaky_Relu(self, x):
    return tf.maximum(x * 0.1, x)
# 卷积层
def conv_layer(self, x, filter, kernel_size, stride, scope):
    channel = x.get_shape().as_list()[-1]
    weight = tf.Variable(tf.truncated_normal(shape=[kernel_size, kernel_size, channel, filter], stddev=0.1),
                         name="weights")
    bias = tf.Variable(tf.zeros([filter, ]), name="biases")
    pad_size = kernel_size // 2
    x = tf.pad(x, paddings=[[0, 0], [pad_size, pad_size], [pad_size, pad_size], [0, 0]])

    conv = tf.nn.conv2d(x, weight, strides=[1, stride, stride, 1], padding="VALID", name=scope)
    output = self.Leaky_Relu(tf.nn.bias_add(conv, bias))
    return output
# 最大池化层
def max_pool_layer(self, x, pool_size, stride):
    return tf.nn.max_pool(x, [1, pool_size, pool_size, 1], strides=[1, stride, stride, 1], padding="SAME")
# 全连接层
def dense_layer(self, x, filter, activation=None, scope=None):
    channel = x.get_shape().as_list()[-1]
    weight = tf.Variable(tf.truncated_normal(shape=[channel, filter], stddev=0.1), name="weights")
    bias = tf.Variable(tf.zeros([filter, ]), name="biases")
    output = tf.nn.xw_plus_b(x, weight, bias, name=scope)
    if activation:
        output = activation(output)
    return output
# flatten层
def flatten_layer(self, x):
    x = tf.transpose(x, [0, 3, 1, 2])
    shape = x.get_shape().as_list()[1:]
    nums = np.product(shape)
    return tf.reshape(x, [-1, nums])

网络部分结束

---

 

 

 

损失函数部分

YOLO-V1损失函数：

 

 

 

(1)只有当某个网格中有object的时候才对类别预测进行惩罚。

(2)只有当某个bounding box对某个真实框负责的时候，才会对box的坐标预测进行惩罚，而对哪个真实框负责就看其bounding box和真实框的IOU是不是在那个网格中的所有box中最大。

 

为什么公式中对w,h开根号呢？

黑的框为bounding box，红色的框跟绿色的框为真实标注框，如果w，h没有平方根，那么bounding box跟两个真实标注的位置loss是相同的，但是从面积来看黑色的框是绿色的25倍，红色的框是黑色的81/25倍，黑色框跟绿色框的大小偏差更大，

不应该得到相同的loss，如果w和h加上平方根，那么才更加符合我们的实际判断。

计算IOU的函数

def calc_iou(self, bboxes1, bboxes2):
    # 计算两个box的交集：交集左上角的点取两个box的max，交集右下角的点取两个box的min
    int_ymin = np.maximum(bboxes1[..., 0], bboxes2[..., 0])
    int_xmin = np.maximum(bboxes1[..., 1], bboxes2[..., 1])
    int_ymax = np.minimum(bboxes1[..., 2], bboxes2[..., 2])
    int_xmax = np.minimum(bboxes1[..., 3], bboxes2[..., 3])

    # 计算两个box交集的wh：如果两个box没有交集，那么wh为0(按照计算方式wh为负数，跟0比较取最大值)
    int_h = np.maximum(int_ymax - int_ymin, 0.)
    int_w = np.maximum(int_xmax - int_xmin, 0.)

    # 计算IOU
    int_vol = int_h * int_w  # 交集面积
    vol1 = (bboxes1[..., 2] - bboxes1[..., 0]) * (bboxes1[..., 3] - bboxes1[..., 1])  # bboxes1面积
    vol2 = (bboxes2[..., 2] - bboxes2[..., 0]) * (bboxes2[..., 3] - bboxes2[..., 1])  # bboxes2面积
    iou = int_vol / (vol1 + vol2 - int_vol)  # IOU=交集/并集
    return iou

def loss_layer(self, predicts, labels, scope='loss_layer'):
    # label为（(batch_size,7,7,25)）  5个为盒子信息  (x,y,w,h,c)  后20个为类别
    with tf.variable_scope(scope):
        # 预测值
        # class-20
        #网络输出是(batch_size,1470)
        predict_classes = tf.reshape(
            predicts[:, :7 * 7 * 20],
            [self.batch_size, 7, 7, 20])
        # confidence-2
        predict_confidence = tf.reshape(
            predicts[:, 7 * 7 * 20:7 * 7 * 20 + 7 * 7 * 2],
            [self.batch_size, 7, 7, 2])
        # bounding box-2*4
        predict_boxes = tf.reshape(
            predicts[:, 7 * 7 * 20 + 7 * 7 * 2:],
            [self.batch_size, 7, 7, 2, 4])

        # 实际值
        # shape(45,7,7,1)
        # response中的值为0或者1.对应的网格中存在目标为1，不存在目标为0.
        # 存在目标指的是存在目标的中心点，并不是说存在目标的一部分。所以，目标的中心点所在的cell其对应的值才为1，其余的值均为0
        response = tf.reshape(
            labels[..., 0],
            [self.batch_size, 7, 7, 1])
        # shape(45,7,7,1,4)
        boxes = tf.reshape(
            labels[..., 1:5],
            [self.batch_size, 7, 7, 1, 4])
        # shape(45,7,7,2,4),boxes的四个值，取值范围为0~1
        boxes = tf.tile(
            boxes, [1, 1, 1, 2, 1]) / self.img_shape[0]
        # shape(45,7,7,20)
        classes = labels[..., 5:]

        # self.offset shape(7,7,2)
        # offset shape(1,7,7,2)

        # shape(45,7,7,2)
        x_offset = tf.tile(self.x_offset, [self.batch_size, 1, 1, 1])  # (45,7,7,2)
        # shape(45,7,7,2)
        y_offset = tf.transpose(x_offset, (0, 2, 1, 3))


        # shape(45,7,7,2,4)  ->(x,y,w,h)
        predict_boxes_tran = tf.stack(
            [(predict_boxes[..., 0] + x_offset) / 7,
             (predict_boxes[..., 1] + y_offset) / 7,
             tf.square(predict_boxes[..., 2]),
             tf.square(predict_boxes[..., 3])], axis=-1)

        # 预测box与真实box的IOU,shape(45,7,7,2)
        iou_predict_truth = self.calc_iou(predict_boxes_tran, boxes)

        # shape(45,7,7,1)
        # 在训练时，如果该单元格内确实存在目标，那么只选择IOU最大的那个边界框来负责预测该目标，而其它边界框认为不存在目标
        object_mask = tf.reduce_max(iou_predict_truth, axis=3, keep_dims=True)
        # object_mask shape(45,7,7,2)
        object_mask = tf.cast(
            (iou_predict_truth >= object_mask), tf.float32) * response

        # noobject confidence(45,7,7,2)
        #单元格内没有物体的地方为1有物体的地方为0
        noobject_probs = tf.ones_like(
            object_mask, dtype=tf.float32) - object_mask

        # shape(45,7,7,2,4)，对boxes的四个值进行规整，xy为相对于网格左上角，wh为取根号后的值，范围0~1
        boxes_tran = tf.stack(
            [boxes[..., 0] * 7 - x_offset,
             boxes[..., 1] * 7 - y_offset,
             tf.sqrt(boxes[..., 2]),
             tf.sqrt(boxes[..., 3])], axis=-1)

        # class_loss shape(45,7,7,20)
        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  confidence=iou*p(object)
        # p(object)的值为1或0
        object_delta = object_mask * (predict_confidence - 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  p(object)的值为0
        noobject_delta = noobject_probs * predict_confidence
        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

        return class_loss + object_loss + noobject_loss + coord_loss

损失函数部分结束

---

YOLO_V1缺点
1.每个网格只对应2个bounding box，当物体的长宽比不常见(也就是训练数据覆盖不到时)，效果较差。

2.原始图片只划分为7×7的网格，当两个物体考的很近时，效果比较差。

3.最终每个网格只对应一个类别，容易出现漏检(物体没有被识别到) eg：两个物体中心点相同

4.对于图片中比较小的物体，效果比较差。

​