源码解读YOLO v3 训练 - 05 损失函数loss

Posted 2021-02-21 monologuesmw

摘要

　　在损失函数计算的过程中，需要对模型的输出即 feats进行相关信息的计算。 ---- 在yolo_head中

　　当前小网格相对于大网格的位置（也可以理解为是相对于特征图的位置）

　　loss的计算时每一层结果均与真值进行误差的累加计算。

　　YOLO v3的损失函数与v1 的损失函数略有不同。损失函数的计算是在对应特征图上的，而不是将其转化至416,416的图上，或者转化到原图上。

　　YOLO v3使用多目标的方式进行分类，而不是使用softmax。

　　一张图像的输出其最终对应的输出尺寸为1×(3×(13×13+26×26+52×52)) × (5+k) = 1×10647 × (5+k)

　　那其实根据真值篇所述，"正样本只要IOU最大的，而不是超过某一阈值的都是正样本"，置信度正负样本比例高达1:10647， 也就是说，在10647中，正样本只有一个。所以计算损失时使用的是SSE计算，而不是平均，因为平均损失会接近于0。

代码解读

损失层

　　在模型的训练过程中，不断调整网络中的参数，优化损失函数loss的值达到最小，完成模型的训练。在YOLO v3中，损失函数yolo_loss封装在自定义Lambda的损失层中，作为模型的最后一层，参于训练。损失层Lambda的输入是已有模型的输出model_body.output和真值y_true，输出是1个值，即损失值。

1 model_loss = Lambda(yolo_loss, output_shape=(1,), name=‘yolo_loss‘,
2     arguments={‘anchors‘: anchors, ‘num_classes‘: num_classes, ‘ignore_thresh‘: 0.5})(
3     [*model_body.output, *y_true])
4 
5 model = Model([model_body.input, *y_true], model_loss)

　　生成一个损失层。

  

　　进入yolo_loss内部：

1 def yolo_loss(args, anchors, num_classes, ignore_thresh=.5, print_loss=False):

　　参数含义：

• args是Lambda层的输入，即model_body.output和y_true的组合；
• anchors是二维数组，结构是(9, 2)，即9个anchor box；
• num_classes是类别数；
• ignore_thresh是过滤阈值；
• print_loss是打印损失函数的开关；

　　前三个是预测值model_body.output，后三个是真实值y_true。

  

　　预测值和真实值分离：

1 num_layers = len(anchors)//3   # default setting 输出层神经元的个数（三个下采样尺度）
2 yolo_outputs = args[:num_layers]   # 预测值
3 y_true = args[num_layers:]   # 真实值   预测与真实分离， 前三个是真实值，后三个是预测值

　　输入的维度、网格的维度：

1 anchor_mask = [[6,7,8], [3,4,5], [0,1,2]] if num_layers == 3 else [[3,4,5], [1,2,3]]  # 先验框分组
2 input_shape = K.cast(K.shape(yolo_outputs[0])[1:3] * 32, K.dtype(y_true[0]))    # 13*13 的宽高回归416*416
3 grid_shapes = [K.cast(K.shape(yolo_outputs[l])[1:3], K.dtype(y_true[0])) for l in range(num_layers)]  # 三种尺度的shape
4 loss = 0

　　模型的batch_size

1 m = K.shape(yolo_outputs[0])[0] # 输入模型的图片总量 
2 batch_size mf = K.cast(m, K.dtype(yolo_outputs[0])) # 调整类型

　　对于每一种尺度进行循环：

• 提取置信度信息
• 提取分类信息

1 for l in range(num_layers):
2     object_mask = y_true[l][..., 4:5]
3     true_class_probs = y_true[l][..., 5:]  

　　通过最后一层的输出，构建pred_box。（?,?,?,3,2 + ?,?,?,3,2 -> ?,?,?,6,2(pred_box)）

1 grid, raw_pred, pred_xy, pred_wh = yolo_head(yolo_outputs[l],
2      anchors[anchor_mask[l]], num_classes, input_shape, calc_loss=True)
3 pred_box = K.concatenate([pred_xy, pred_wh])  # 组合成预测框pred_box

其中，yolo_head的作用是将最后一层的特征转换为b-box的信息，其中，会包含b-box特征的计算：

　　x, y, 物体置信度以类别置信度部分均经过 Sigmoid 函数激活, 然后采用SSE 计算最终损失。

1 box_xy = (K.sigmoid(feats[..., :2]) + grid) / K.cast(grid_shape[::-1], K.dtype(feats))
2 box_wh = K.exp(feats[..., 2:4]) * anchors_tensor / K.cast(input_shape[::-1], K.dtype(feats))
3 box_confidence = K.sigmoid(feats[..., 4:5])  # 框置信度
4 box_class_probs = K.sigmoid(feats[..., 5:])   # 类别置信度

　　box_xy的计算过程为 将feats中x，y相关的信息sigmoid后（将feats映射到(0,1)）， 与所在网格位置加和 再归一化。

　　grid 相当于是Cx和Cy，即目标中心点所在网格左上角距最左上角相差的格子数。虽然实际过程中，grid是0~12等差分布的(13,13,1,2)的张量，但可以实现上述的需求。（当前的feats为13*13中的）

　　同理，宽高wh：将feats中w，h的值，经过exp正值化，再乘以anchors_tensor的anchor box，再除以图片宽高，（归一化）；

　　因此，返回的box_xy和box_wh是相对于当前小网格相对于大网格的位置。（相对于特征图的位置）

　　由于在真值的设计中，位置参数是相对于规范化后图片的位置。此时是相对于小网格的位置，所以后续在loss计算中，应该会有尺度的缩放。

  

　　由于此时是用于计算损失函数，返回值为

• 网格grid：结构是(13, 13, 1, 2)，数值为0~12的全遍历二元组， 包含x和y两层；
• 预测值feats：经过reshape变换，将18维数据分离出3维anchors，结构是(?, 13, 13, 3, 6)
• box_xy和box_wh归一化的起始点xy和宽高wh，xy的结构是(?, 13, 13, 3, 2)，wh的结构是(?, 13, 13, 3, 2)；box_xy的范围是(0~1)，box_wh的范围是(0~1)；即bx、by、bw、bh计算完成之后，再进行归一化。 （只有一个类别的情况下 -- 6=5+1）

1 if calc_loss == True:
2     return grid, feats, box_xy, box_wh  

　　有了预测值，便可以进行损失函数的计算。

　　循环计算每1层的损失值，累加到一起。

1 for l in range(num_layers):
2     ...
3     loss += xy_loss + wh_loss + confidence_loss + class_loss

　　...部分：

• 生成真实数据
• 根据置信度 生成 二值向量
• 损失的计算

1. 生成真实数据

1 raw_true_xy = y_true[l][..., :2]*grid_shapes[l][::-1] - grid
2 raw_true_wh = K.log(y_true[l][..., 2:4] / anchors[anchor_mask[l]] * input_shape[::-1])
3 raw_true_wh = K.switch(object_mask, raw_true_wh, K.zeros_like(raw_true_wh)) # avoid log(0)=-inf
4 box_loss_scale = 2 - y_true[l][..., 2:3]*y_true[l][..., 3:4] # 2-box_ares）避免大框的误差对loss 比小框误差对loss影响大

　　真实框尺度缩放到尺度下的方式。

　　代码第4行，有w*h越小，则box_loss_scale 越大；

　　同时w*h越小，其面积（w*h就是面积）就越小，面积越小，在和anchor做比较的时候，iou必然就小，导致"存在物体"的置信度就越小。也就是object_mask越小。

　　于是，object_mask * box_loss_scale在这里形成了一个制衡条件，这也就是我把box_loss_scale看做一个制衡值的原因。

　　损失函数的计算是在特征图上的，而不是将其转化至416,416的图上，或者转化到原图上。

　　# raw_true_xy：在网格中的中心点xy，偏移数据，值的范围是0~1 （相对于一个小格子而言）；

　　果然，在这里会有真实数据的尺度缩放，转化为对于小格子而言的。

　　# y_true的第0和1位是中心点xy的相对于规范化图片的位置，范围是0~1；

　　# raw_true_wh：在网络中的wh相对于anchors的比例，再转换为log形式，范围是有正有负；

　　# y_true的第2和3位是宽高wh的相对于规范化图片的位置，范围是0~1；

　　# box_loss_scale：计算wh权重，取值范围(1~2)；  

2. 根据置信度生成二值向量

　　接着，根据IoU忽略阈值生成ignore_mask，将预测框pred_box和真值框true_box计算IoU

　　抑制不需要的anchor框的值，即IoU小于最大阈值的anchor框。

　　ignore_mask的shape是(?, ?, ?, 3, 1)，第0位是批次数，第1~2位是特征图尺寸。

　　并且找一个最大的负责预测该物体

 1 ignore_mask = tf.TensorArray(K.dtype(y_true[0]), size=1, dynamic_size=True)
 2 object_mask_bool = K.cast(object_mask, ‘bool‘)
 3 
 4 def loop_body(b, ignore_mask):
 5     true_box = tf.boolean_mask(y_true[l][b,...,0:4], object_mask_bool[b,...,0])   # 抑制不需要的anchor框
 6     iou = box_iou(pred_box[b], true_box)  # 计算了iou
 7     best_iou = K.max(iou, axis=-1)  # 找一个 iou最大的
 8     ignore_mask = ignore_mask.write(b, K.cast(best_iou<ignore_thresh, K.dtype(true_box)))   #当iou小于阈值时记录，即认为这个预测框不包含物体
 9     return b+1, ignore_mask
10 
11 _, ignore_mask = K.control_flow_ops.while_loop(lambda b,*args: b<m, loop_body, [0, ignore_mask])   #传入loop_body函数初值为b=0，ignore_mask
12 ignore_mask = ignore_mask.stack() 
13 ignore_mask = K.expand_dims(ignore_mask, -1)   # 扩展维度用于计算loss

　　此处box_iou的计算时带中心点坐标的计算，即包含位置的计算，而不是像Kmeans中那样拼在一起的计算。

3. 损失的计算

　　上述Loss的关于损失的描述应该是最为直接恰当的， 但和代码对比 好像有些不一样。

　　可以看出，YOLO v3中主要包含三种损失，即坐标的损失，置信度的损失、分类的损失。λobj表示当前的网格中是否存在物体，存在为1，不存在为0。误差采用SSE计算。

1 xy_loss = object_mask * box_loss_scale * K.binary_crossentropy(raw_true_xy, raw_pred[...,0:2], from_logits=True)
2 wh_loss = object_mask * box_loss_scale * 0.5 * K.square(raw_true_wh-raw_pred[...,2:4])
3 confidence_loss = object_mask * K.binary_crossentropy(object_mask, raw_pred[...,4:5], from_logits=True)+ 4     (1-object_mask) * K.binary_crossentropy(object_mask, raw_pred[...,4:5], from_logits=True) * ignore_mask
5 class_loss = object_mask * K.binary_crossentropy(true_class_probs, raw_pred[...,5:], from_logits=True)

　　binary_crossentropy和sigmoid的应用（体现在K.binary_crossentropy(raw_true_xy, raw_pred [...,0:2], from_logits=True)），算是非常大胆的了。因为二分类是得到比较"绝对"的输出，非黑即白，非0即1，在链式结构中，非常容易造成"一失足成千古恨"的结果。比如：每次预测值都是0.9，十次以后（0.9的10次方）就非常非常小了。

　　当真实输出与期望输出接近时，代价函数接近于0.  

　　为了实现多标签分类，模型不再使用softmax函数作为最终的分类器，而是使用logistic作为分类器，使用 binary cross-entropy作为损失函数。

　　从 Sigmoid 函数的导数图像 (图 6)可以看到, 当神经网络的输出较大时, 会变得非常小, 此时使用平方误差得到的误差值很小, 导致网络收敛很慢, 出现误差越大收敛越慢, 也就是梯度消失的情况。（梯度消失看的是导数的曲线）。 应对该问题，一般会采用交叉熵（从代码中可以看出，使用sigmoid计算的xy, 物体置信度、类别置信度中均使用了交叉熵）  

　　模型最终的损失（取均值）

1 xy_loss = K.sum(xy_loss) / mf
2 wh_loss = K.sum(wh_loss) / mf
3 confidence_loss = K.sum(confidence_loss) / mf
4 class_loss = K.sum(class_loss) / mf
5 loss += xy_loss + wh_loss + confidence_loss + class_loss