在上一篇中学习了yolov3中的darknet53模型，在这一篇中我们继续来分析yolov3的源代码。
需要说明的是，我学习的这个yolov3的源码出自这里malin9402
这次我们要分析的是yolov3.py的源码。下面开始吧。
下面先了解一下文件开头的一些参数
#yolov3能够检测到的类别的数目
NUM_CLASS = len(utils.read_class_names(cfg.YOLO.CLASSES))
#yolov3中3个尺度的3个先验框的大小
ANCHORS = utils.get_anchors(cfg.YOLO.ANCHORS)
#yolov3中3个尺度的步长
STRIDES = np.array(cfg.YOLO.STRIDES)
#IOU的阈值
IOU_LOSS_THRESH = cfg.YOLO.IOU_LOSS_THRESH
接下来看yolov3模型
def YOLOv3(input_layer):
route_1, route_2, conv = backbone.darknet53(input_layer)
#[bs,13,13,1024] => [bs,13,13,512]
conv = common.convolutional(conv, (1, 1, 1024, 512))
#[bs,13,13,512] => [bs,13,13,1024]
conv = common.convolutional(conv, (3, 3, 512, 1024))
#[bs,13,13,1024] => [bs,13,13,512]
conv = common.convolutional(conv, (1, 1, 1024, 512))
#[bs,13,13,512] => [bs,13,13,1024]
conv = common.convolutional(conv, (3, 3, 512, 1024))
#[bs,13,13,1024] => [bs,13,13,512]
conv = common.convolutional(conv, (1, 1, 1024, 512))
#[bs,13,13,512] => [bs,13,13,1024]
conv_lobj_branch = common.convolutional(conv, (3, 3, 512, 1024))
#[bs,13,13,1024] => [bs,13,13,255]
conv_lbbox = common.convolutional(conv_lobj_branch, (1, 1, 1024, 3*(NUM_CLASS + 5)), activate=False, bn=False)
#[bs,13,13,512] => [bs,13,13,256]
conv = common.convolutional(conv, (1, 1, 512, 256))
#[bs,13,13,256] => [bs,26,26,256]
conv = common.upsample(conv)
#[bs,26,26,256] + [bs,26,26,512] => [bs,26,26,768]
conv = tf.concat([conv, route_2], axis=-1)
#[bs,26,26,768] => [bs,26,26,256]
conv = common.convolutional(conv, (1, 1, 768, 256))
#[bs,26,26,256] => [bs,26,26,512]
conv = common.convolutional(conv, (3, 3, 256, 512))
#[bs,26,26,512] => [bs,26,26,256]
conv = common.convolutional(conv, (1, 1, 512, 256))
#[bs,26,26,256] => [bs,26,26,512]
conv = common.convolutional(conv, (3, 3, 256, 512))
#[bs,26,26,512] => [bs,26,26,256]
conv = common.convolutional(conv, (1, 1, 512, 256))
#[bs,26,26,256] => [bs,26,26,512]
conv_mobj_branch = common.convolutional(conv, (3, 3, 256, 512))
#[bs,26,26,512] => [bs,26,26,255]
conv_mbbox = common.convolutional(conv_mobj_branch, (1, 1, 512, 3*(NUM_CLASS + 5)), activate=False, bn=False)
#[bs,26,26,256] => [bs,26,26,128]
conv = common.convolutional(conv, (1, 1, 256, 128))
#[bs,26,26,128] => [bs,52,52,128]
conv = common.upsample(conv)
#[bs,52,52,128] + [bs,52,52,256] => [bs,52,52,384]
conv = tf.concat([conv, route_1], axis=-1)
#[bs,52,52,384] => [bs,52,52,128]
conv = common.convolutional(conv, (1, 1, 384, 128))
#[bs,52,52,128] => [bs,52,52,256]
conv = common.convolutional(conv, (3, 3, 128, 256))
#[bs,52,52,256] => [bs,52,52,128]
conv = common.convolutional(conv, (1, 1, 256, 128))
#[bs,52,52,128] => [bs,52,52,256]
conv = common.convolutional(conv, (3, 3, 128, 256))
#[bs,52,52,256] => [bs,52,52,128]
conv = common.convolutional(conv, (1, 1, 256, 128))
#[bs,52,52,128] => [bs,52,52,256]
conv_sobj_branch = common.convolutional(conv, (3, 3, 128, 256))
#[bs,52,52,256] => [bs,52,52,255]
conv_sbbox = common.convolutional(conv_sobj_branch, (1, 1, 256, 3*(NUM_CLASS +5)), activate=False, bn=False)
return [conv_sbbox, conv_mbbox, conv_lbbox]
从上面的代码可以看到，输入图片首先通过darknet53模块得到3个尺度的特征，然后通过多个卷积层对这3个尺度的特征进行操作，最终得到小尺度的特征输出conv_sbbox，中尺度的特征输出conv_mbbox，大尺度的特征输出conv_lbbox。
下面再详细介绍一下这些特征图：
1.conv_sbbox：小尺度特征图，shape=[bs,52,52,255]，主要用来检测图片中的小尺寸物体。这个尺度可以这样理解，它把图片分成了52x52的网格图片，每个网格有3个预测框，每个预测框有85(5+80)个信息，5的意思是它包含(x,y,w,h, confidence)5个基本参数，80的意思是它有80个类别的检测概率。
2. conv_mbbox:：中尺度特征图，shape=[bs,26,26,255]，主要用来检测图片中的中尺寸物体，它把图片分成了26x26的网格图片，每个网格有3个预测框，每个预测框有85(5+80)个信息，理解意思与conv_sbbox相似。
3. conv_lbbox：大尺度特征图，shape=[bs,13,13,255]，主要用来检测图片中的大尺寸物体，它把图片分成了13x13的网格图片，每个网格有3个预测框，每个预测框有85(5+80)个信息，理解意思与conv_sbbox相似。
下面重点关注一下(x,y,w,h, confidence)5个基本参数:
- x: 预测框的中心横坐标的偏移量。
- y: 预测框的中心纵坐标的偏移量。
- w: 预测框的宽度的偏移量。
- h: 预测框的高度的偏移量。
- confidence: 预测框中检测到物体的概率。
了解了yolov3的输出后，接着来看decode方法，它的主要功能是把yolov3的输出解码出来，方便后续计算损失值。
在看代码之前，我们先了解一下decode方法的计算流程：
- 假设输入的形状为[4,52,52,255]，这里的4是指每次训练4张图片，52是指特征图的高宽大小，可以理解为特征图把原始图片划分成了52x52的格子，每个格子中255个通道。
2.将这个输入的形状改变为[4,52,52,3,85]，3是指每个格子有3个预测框，85是指每个预测框有4个位置信息(2个中心位置的偏移量+2个高宽的偏移量+1个置信度+80个类别的概率)
3.将2个中心位置的偏移量，2个高宽的偏移量，1个置信度，80个类别的概率都提取出来。 - 计算每个预测框的绝对坐标和高宽。
- 计算预测框的置信值和分类值。
我们看一下先验框和预测框的示意图。
先验框和预测框示意图
- bh 和 bw 分别表示预测框的高宽
- bx 和 by 分别表示预测框中心位置的横坐标和纵坐标。
- ph 和 pw 分别表示先验框的高宽
- cx 和 cy 分别表示预测框左上角的坐标
- th 和 tw 分别表示预测框高宽的偏移量
- tx 和 ty 分别表示预测框中心位置距离左上角位置的偏移量
下面我们在代码中看具体实现流程。
def decode(conv_output, i=0):
"""
return tensor of shape [batch_size, output_size, output_size, anchor_per_scale, 5 + num_classes]
contains (x, y, w, h, score, probability)
"""
conv_shape = tf.shape(conv_output)
batch_size = conv_shape[0]#样本数
output_size = conv_shape[1]#输出特征图的高宽
conv_output = tf.reshape(conv_output, (batch_size, output_size, output_size, 3, 5 + NUM_CLASS))
conv_raw_dxdy = conv_output[:, :, :, :, 0:2]#预测框中心位置的偏移量
conv_raw_dwdh = conv_output[:, :, :, :, 2:4]#预测框高宽的偏移量
conv_raw_conf = conv_output[:, :, :, :, 4:5]#预测框检测到物体的置信度
conv_raw_prob = conv_output[:, :, :, :, 5: ]#预测框的类别的概率
# 1.对每个先验框生成在特征图上的相对坐标，以左上角为基准，其坐标单位为格子，即数值表示是第几个格子
y = tf.tile(tf.range(output_size, dtype=tf.int32)[:, tf.newaxis], [1, output_size]) # shape = [52,52]
x = tf.tile(tf.range(output_size, dtype=tf.int32)[tf.newaxis, :], [output_size, 1]) # shape = [52,52]
xy_grid = tf.concat([x[:, :, tf.newaxis], y[:, :, tf.newaxis]], axis=-1) # shape = [52,52,2]
xy_grid = tf.tile(xy_grid[tf.newaxis, :, :, tf.newaxis, :], [batch_size, 1, 1, 3, 1]) # shape = [batch_size, 52,52,3,2]
xy_grid = tf.cast(xy_grid, tf.float32)
# 2.计算预测框的绝对坐标和高宽度
# 根据上图公式计算预测框的中心位置
pred_xy = (tf.sigmoid(conv_raw_dxdy) + xy_grid) * STRIDES[i] # xy_grid表示特征图上左上角的位置，即是第几行第几列格子，STRIDES表示格子的长度，即特征图上的一个格子在原图上的长度
# 根据上图公式计算预测框的高宽
pred_wh = (tf.exp(conv_raw_dwdh) * ANCHORS[i]) * STRIDES[i] # ANCHORS[i]) * STRIDES[i] 表示先验框在原图上的大小
pred_xywh = tf.concat([pred_xy, pred_wh], axis=-1)
# 3. 计算预测框的置信度和分类值
pred_conf = tf.sigmoid(conv_raw_conf)
pred_prob = tf.sigmoid(conv_raw_prob)
return tf.concat([pred_xywh, pred_conf, pred_prob], axis=-1)
bbox_iou
bbox_iou 函数用来计算两个预测框之间的距离，在utils.py文件中有bboxes_iou方法也实现了类似的功能，它们之间的区别是输入的预测框的参数不同。
bbox_iou：参数是预测框的中心坐标+预测框的高宽
bboxes_iou：参数是预测框的左上角坐标+预测框的右下角坐标
iou值实际上就是两个框的交集面积除以并集面积，这个值越大，两个框的距离就越近。如下图所示：
两个预测框的交集面积和并集面积
下面我们具体看一下代码是如何实现的。
def bbox_iou(boxes1, boxes2):
boxes1_area = boxes1[..., 2] * boxes1[..., 3]#第一个框的面积
boxes2_area = boxes2[..., 2] * boxes2[..., 3]#第二个框的面积
boxes1 = tf.concat([boxes1[..., :2] - boxes1[..., 2:] * 0.5,
boxes1[..., :2] + boxes1[..., 2:] * 0.5], axis=-1)#将第一个框由中心坐标+高宽的形式转换为左上角坐标+右下角坐标的形式
boxes2 = tf.concat([boxes2[..., :2] - boxes2[..., 2:] * 0.5,
boxes2[..., :2] + boxes2[..., 2:] * 0.5], axis=-1)#将第二个框由中心坐标+高宽的形式转换为左上角坐标+右下角坐标的形式
left_up = tf.maximum(boxes1[..., :2], boxes2[..., :2])#计算两个框的交集的左上角坐标，上图中是(xmin2,ymin2)
right_down = tf.minimum(boxes1[..., 2:], boxes2[..., 2:])#计算两个框的交集的右下角坐标，上图中是(xmax1,ymax1)
inter_section = tf.maximum(right_down - left_up, 0.0)
inter_area = inter_section[..., 0] * inter_section[..., 1]#计算两个框的交集面积
union_area = boxes1_area + boxes2_area - inter_area#计算两个框的并集面积
return 1.0 * inter_area / union_area#最后交集面积/并集面积
bbox_giou
bbox_giou的功能也是用来计算两个预测框之间的距离，按理说，上面的bbox_iou已经可以计算两个框的面积了，为啥还要重要再弄一个方法呢，
这是因为使用bbox_iou来度量预测框的距离时存在两个严重的问题：
1:如果两个预测框之间没有重合，那么iou的值就为0，这样就会导致计算损失函数时梯度为0，无法进行优化。
2:因为iou的计算方法是交集面积除以并集面积，这样就会导致同一个iou值会有多种不同的形态，如下图所示：
相同的iou值对应不同的形态
上面三幅图中的iou = 0.33，但是giou值分别是0.33,0.24,-0.1，这表明如果两个框重叠和对齐得越好，那么giou值就会越高。
因此，基于iou存在的问题，yolov3使用了giou作为预测框的损失函数，其计算方式为:
giou计算方法
其中C代表A和B的最小外接矩形的面积，通过这种度量方式，两个预测框之间没有相交时，也能计算距离。
下面看具体代码实现。同样用下图举例。
giou计算示意图.jpg
def bbox_giou(boxes1, boxes2):
boxes1 = tf.concat([boxes1[..., :2] - boxes1[..., 2:] * 0.5,
boxes1[..., :2] + boxes1[..., 2:] * 0.5], axis=-1)#把第一个预测框从中心坐标+高宽的形式转换为左上角坐标+右下角坐标的形式
boxes2 = tf.concat([boxes2[..., :2] - boxes2[..., 2:] * 0.5,
boxes2[..., :2] + boxes2[..., 2:] * 0.5], axis=-1)#把第二个预测框从中心坐标+高宽的形式转换为左上角坐标+右下角坐标的形式
boxes1 = tf.concat([tf.minimum(boxes1[..., :2], boxes1[..., 2:]),
tf.maximum(boxes1[..., :2], boxes1[..., 2:])], axis=-1)#重新整理一下预测框的坐标
boxes2 = tf.concat([tf.minimum(boxes2[..., :2], boxes2[..., 2:]),
tf.maximum(boxes2[..., :2], boxes2[..., 2:])], axis=-1)
boxes1_area = (boxes1[..., 2] - boxes1[..., 0]) * (boxes1[..., 3] - boxes1[..., 1])#计算第一个预测框的面积
boxes2_area = (boxes2[..., 2] - boxes2[..., 0]) * (boxes2[..., 3] - boxes2[..., 1])#计算第二个预测框的面积
left_up = tf.maximum(boxes1[..., :2], boxes2[..., :2])#计算两个框的交集的左上角坐标，在上图中是(xmin2，ymin2)
right_down = tf.minimum(boxes1[..., 2:], boxes2[..., 2:])#计算两个框的交集的右下角坐标，在上图中是(xmax1,ymax1)
inter_section = tf.maximum(right_down - left_up, 0.0)
inter_area = inter_section[..., 0] * inter_section[..., 1]#计算交集的面积
union_area = boxes1_area + boxes2_area - inter_area#计算并集的面积
iou = inter_area / union_area#计算iou值
enclose_left_up = tf.minimum(boxes1[..., :2], boxes2[..., :2])#计算最小外接矩形的左上角坐标，在上图中是(xmin1,ymin1)
enclose_right_down = tf.maximum(boxes1[..., 2:], boxes2[..., 2:])#计算最小外接矩形的右下角坐标，在上图中是(xmax2,ymax2)
enclose = tf.maximum(enclose_right_down - enclose_left_up, 0.0)
enclose_area = enclose[..., 0] * enclose[..., 1]#计算最小外接矩形的面积
giou = iou - 1.0 * (enclose_area - union_area) / enclose_area#根据上面的公式计算giou值
return giou
compute_loss
compute_loss 函数被用来计算损失。
损失分为3类：框回归损失，置信度损失和分类损失。
框回归损失
计算过程：
- 获得置信度respond_bbox。
- 计算bbox_loss_scale = 2.0 - （真实框的面积）/（输入原图的面积）
- 损失 giou_loss = respond_bbox * bbox_loss_scale * (1-giou)
置信度损失
计算过程：
- 对所有预测框求出它和所有真实框的iou值。
- 然后找出每个预测框的iou值中的最大的一个值。
- 如果每个预测框找出的这个最大iou值小于指定的阈值，那么认为这个预测框不包含物体，为背景框（负样本），否则这个框是前景框（正样本）。还有一种是这个iou值大于指定的阈值，但是这个预测框没有包含物体的情况。这种情况不需要参与损失函数的计算，在代码中被巧妙的处理掉了。
- 计算正样本误差和负样本误差，最后相加。
分类损失
对于分类损失，同样只考虑正样本误差，使用交叉熵损失函数计算误差。
输入：
pred: 经过decode解码后的检测框，即原图上的检测框。
conv: 没有经过解码的检测框，即特征图上的检测框。
label: 标签的格式为 [batch_size, output_size, output_size, anchor_per_scale, 85=(2个中心坐标xy+2个形状wh+1个置信值+80个类别)]；
bboxes: 每个尺度的真实框集合，里面存放的是真实框的4个参数(2个中心点坐标+2个高宽长度)
i: 表示第几个尺度上的特征图（总共有3个尺度）。
搞清楚了损失函数的计算流程和参数后，我们看看代码是如何实现的。
def compute_loss(pred, conv, label, bboxes, i=0):
conv_shape = tf.shape(conv)#特征图形状
batch_size = conv_shape[0]#处理的图片数量
output_size = conv_shape[1]#特征图的大小
input_size = STRIDES[i] * output_size#原图的大小
conv = tf.reshape(conv, (batch_size, output_size, output_size, 3, 5 + NUM_CLASS))#将特征图转换形式
conv_raw_conf = conv[:, :, :, :, 4:5]#特征图的置信度
conv_raw_prob = conv[:, :, :, :, 5:]#特征图中类别的概率
pred_xywh = pred[:, :, :, :, 0:4]#预测框在原图上的坐标和高宽
pred_conf = pred[:, :, :, :, 4:5]#预测框处理后的置信度
label_xywh = label[:, :, :, :, 0:4]#真实框的坐标和高宽
respond_bbox = label[:, :, :, :, 4:5]#真实框的置信度，有目标的为1，没目标的为0
label_prob = label[:, :, :, :, 5:]#真实框的类别概率
# 1.框回归损失
# 计算预测框和真实框的giou值
giou = tf.expand_dims(bbox_giou(pred_xywh, label_xywh), axis=-1)
input_size = tf.cast(input_size, tf.float32)
# bbox_loss_scale 制衡误差
bbox_loss_scale = 2.0 - 1.0 * label_xywh[:, :, :, :, 2:3] * label_xywh[:, :, :, :, 3:4] / (input_size ** 2)
# 计算giou_loss
giou_loss = respond_bbox * bbox_loss_scale * (1- giou)
# 2.置信度损失
# 计算所有预测框和真实框的iou值
iou = bbox_iou(pred_xywh[:, :, :, :, np.newaxis, :], bboxes[:, np.newaxis, np.newaxis, np.newaxis, :, :])
# 找出每个预测框的最大iou值
max_iou = tf.expand_dims(tf.reduce_max(iou, axis=-1), axis=-1)
# respond_bgd 形状为 [batch_size, output_size, output_size, anchor_per_scale, x]，当无目标且小于阈值时x为1，否则为0
respond_bgd = (1.0 - respond_bbox) * tf.cast( max_iou < IOU_LOSS_THRESH, tf.float32 )
conf_focal = tf.pow(respond_bbox - pred_conf, 2)
conf_loss = conf_focal * (
# 正样本误差
respond_bbox * tf.nn.sigmoid_cross_entropy_with_logits(labels=respond_bbox, logits=conv_raw_conf)
+
# 负样本误差
respond_bgd * tf.nn.sigmoid_cross_entropy_with_logits(labels=respond_bbox, logits=conv_raw_conf)
)
# 3.分类损失
使用交叉熵损失计算损失值
prob_loss = respond_bbox * tf.nn.sigmoid_cross_entropy_with_logits(labels=label_prob, logits=conv_raw_prob)
# 误差平均
giou_loss = tf.reduce_mean(tf.reduce_sum(giou_loss, axis=[1,2,3,4]))
conf_loss = tf.reduce_mean(tf.reduce_sum(conf_loss, axis=[1,2,3,4]))
prob_loss = tf.reduce_mean(tf.reduce_sum(prob_loss, axis=[1,2,3,4]))
return giou_loss, conf_loss, prob_loss
yolov3的损失函数看起来比较明白易懂，但这可能是经过原作者多次试验后得出来的最优解，我虽然看懂了代码，但是对于代码中损失函数为什么要这样计算还不是很懂，看来还需要更加深入的学习。
这次yolov3模型以及损失函数的计算分享就结束了，下篇文章我们进行数据集制作代码的分析。