当前位置：首页 > news >正文

YOLO系列正传（四）YOLOv3论文精解(下)——损失函数推导与其他优化项

news 来源：原创 2025/5/25 18:51:14

系列文章

YOLO系列基础

YOLO系列基础合集——小白也看得懂的论文精解-CSDN博客

YOLO系列正传

YOLO系列正传（一）类别损失与MSE损失函数、交叉熵损失函数-CSDN博客

YOLO系列正传（二）YOLOv3论文精解(上)——从FPN到darknet-53-CSDN博客

YOLO系列正传（三）神经网络的反向传播（back propagation）与公式推导-CSDN博客

系列文章

YOLO系列基础

YOLO系列正传

背景

从YOLOv1的损失函数出发

YOLOv3损失函数loss代码详解

1. lbox部分损失函数详解

1.1 代码背景

1.2 CIOU公式

lbox的数学公式

2. lobj部分损失函数详解

2.1 lobj 的数学公式分析

2.1 lobj 计算步骤

2.3 lobj 损失函数的数学公式

3.lcls 部分损失函数详解

3.1 lcls 的数学公式分析

3.2 lcls 计算步骤

3.3 lcls 损失的数学公式

4. 最终的总损失公式

背景

随着YOLOv11版本的发布，YOLO算法在视觉检测领域独领风骚，本系列旨在从小白出发，给大家讲解清楚视觉检测算法的前世今生，并讲清楚YOLOv11版本算法的所有模块功能！

在YOLO系列基础中，我们对所有的基础知识进行了讲解和说明。

在上上篇内容中，我们详解了YOLOv3模型结构和FPN相关知识，本篇我们继续YOLOv3的论文详解！

从YOLOv1的损失函数出发

YOLOv1的论文精解如下，感兴趣的大家可以去看下。

YOLO系列基础（六）YOLOv1论文原理详解，清晰明了！-CSDN博客

其中YOLOv1的损失函数给出：

可以看到，YOLOv1大多采用了均方差损失函数的形式。损失函数主要包括以下几项：

存在物体时的检测框中心点坐标损失
存在物体时的检测框检测框长宽损失
存在物体时候的检测框置信度损失
不存在物体时的检测框置信度损失
存在物体时的cell各个类别损失

分别对应上面的1-5行。

有关于损失函数的详情解释可以查看以下博客：

YOLO系列基础（六）YOLOv1论文原理详解，清晰明了！-CSDN博客

YOLOv3损失函数loss代码详解

YOLOv3在YOLOv1的基础上作出了长足的进步！

主要有：

交叉熵损失函数的引入

有关于交叉熵损失函数可以查看以下内容：

YOLO系列正传（一）类别损失与MSE损失函数、交叉熵损失函数-CSDN博客

类别损失与box绑定

以下是YOLOv3官方损失函数计算代码，增设了中文注释的部分。

class ComputeLoss:"""计算YOLO模型的总损失，包括分类损失、边框回归损失和目标置信度损失。"""sort_obj_iou = False  # 是否根据IoU排序目标的置信度def __init__(self, model, autobalance=False):"""初始化ComputeLoss，获取模型设备和超参数，并设置是否自动平衡。"""device = next(model.parameters()).device  # 获取模型参数所在的设备（CPU或GPU）h = model.hyp  # 获取模型的超参数字典# 定义损失函数BCEcls = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([h["cls_pw"]], device=device))  # 分类损失函数BCEobj = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([h["obj_pw"]], device=device))  # 目标置信度损失函数# 标签平滑（Label Smoothing），参考：https://arxiv.org/pdf/1902.04103.pdfself.cp, self.cn = smooth_BCE(eps=h.get("label_smoothing", 0.0))  # positive和negative标签的BCE目标# 焦点损失（Focal Loss）g = h["fl_gamma"]  # 焦点损失的gamma值if g > 0:BCEcls, BCEobj = FocalLoss(BCEcls, g), FocalLoss(BCEobj, g)  # 应用焦点损失m = de_parallel(model).model[-1]  # 获取模型的最后一层（检测模块）# 根据网络的层数（P3-P7）调整损失平衡因子self.balance = {3: [4.0, 1.0, 0.4]}.get(m.nl, [4.0, 1.0, 0.25, 0.06, 0.02])  # P3-P7的损失平衡self.ssi = list(m.stride).index(16) if autobalance else 0  # 如果自动平衡，获取stride为16的层的索引self.BCEcls, self.BCEobj, self.gr, self.hyp, self.autobalance = BCEcls, BCEobj, 1.0, h, autobalance  # 初始化其他参数self.na = m.na  # 锚框的数量self.nc = m.nc  # 类别的数量self.nl = m.nl  # 网络层数self.anchors = m.anchors  # 锚框self.device = device  # 模型设备（CPU或GPU）def __call__(self, p, targets):"""计算损失，给定预测和目标，返回类别损失、边框损失和目标损失。"""lcls = torch.zeros(1, device=self.device)  # 类别损失初始化为0lbox = torch.zeros(1, device=self.device)  # 边框损失初始化为0lobj = torch.zeros(1, device=self.device)  # 目标置信度损失初始化为0tcls, tbox, indices, anchors = self.build_targets(p, targets)  # 根据预测和目标构建目标信息# 计算各类损失for i, pi in enumerate(p):  # 遍历每一层的预测（检测头的每一层）b, a, gj, gi = indices[i]  # 获取每个目标的图像索引、锚框索引、网格的纵横坐标tobj = torch.zeros(pi.shape[:4], dtype=pi.dtype, device=self.device)  # 目标置信度初始化为0n = b.shape[0]  # 当前batch中的目标数量if n:# 获取目标的坐标和类别（只提取有效部分）pxy, pwh, _, pcls = pi[b, a, gj, gi].split((2, 2, 1, self.nc), 1)  # 提取位置和类别信息# 回归损失（位置和大小）pxy = pxy.sigmoid() * 2 - 0.5  # Sigmoid激活函数计算xy坐标pwh = (pwh.sigmoid() * 2) ** 2 * anchors[i]  # 计算宽高，并根据锚框进行调整pbox = torch.cat((pxy, pwh), 1)  # 合并位置和宽高，得到预测框iou = bbox_iou(pbox, tbox[i], CIoU=True).squeeze()  # 计算预测框与真实框的IoUlbox += (1.0 - iou).mean()  # IoU损失（1 - IoU均值）# 目标置信度损失iou = iou.detach().clamp(0).type(tobj.dtype)  # 计算IoU后，进行一些预处理if self.sort_obj_iou:j = iou.argsort()  # 如果启用排序，按IoU从大到小排序b, a, gj, gi, iou = b[j], a[j], gj[j], gi[j], iou[j]if self.gr < 1:iou = (1.0 - self.gr) + self.gr * iou  # 目标平衡tobj[b, a, gj, gi] = iou  # 设置目标的IoU为目标置信度# 分类损失if self.nc > 1:  # 如果类别数大于1，则计算分类损失t = torch.full_like(pcls, self.cn, device=self.device)  # 初始化目标标签t[range(n), tcls[i]] = self.cp  # 将目标类别对应的标签设置为正例lcls += self.BCEcls(pcls, t)  # 计算并累加分类损失# 目标置信度损失obji = self.BCEobj(pi[..., 4], tobj)  # 计算目标置信度损失lobj += obji * self.balance[i]  # 按照损失平衡因子加权if self.autobalance:self.balance[i] = self.balance[i] * 0.9999 + 0.0001 / obji.detach().item()  # 自动平衡损失# 自动平衡：根据stride为16的层调整其他层的平衡因子if self.autobalance:self.balance = [x / self.balance[self.ssi] for x in self.balance]# 根据超参数缩放损失lbox *= self.hyp["box"]lobj *= self.hyp["obj"]lcls *= self.hyp["cls"]bs = tobj.shape[0]  # 获取batch sizereturn (lbox + lobj + lcls) * bs, torch.cat((lbox, lobj, lcls)).detach()  # 返回总损失和各类损失

可以看出Loss是由三部分组成：

lbox：检测框损失
lobj：目标物体损失
lcls：类别损失

1. lbox部分损失函数详解

1.1 代码背景

在 ComputeLoss 类中的 __call__ 方法，lbox 是通过以下方式计算的：

# 计算回归损失（位置和大小）
pxy = pxy.sigmoid() * 2 - 0.5  # 归一化的中心坐标，范围[-0.5, 0.5]
pwh = (pwh.sigmoid() * 2) ** 2 * anchors[i]  # 归一化的宽高，和锚框大小相乘
pbox = torch.cat((pxy, pwh), 1)  # 合并位置和宽高，得到预测框
iou = bbox_iou(pbox, tbox[i], CIoU=True).squeeze()  # 计算预测框与真实框的IoU
lbox += (1.0 - iou).mean()  # IoU损失（1 - IoU均值）

pxy 是预测框的中心坐标 (, )，经过 Sigmoid 激活后映射到 [-0.5, 0.5] 区间。
pwh 是预测框的宽度和高度 (, )，也经过 Sigmoid 激活后映射到 [0, 1] 区间，并乘以锚框大小进行调整。
tbox[i] 是目标框的坐标和宽高 (, , , )。
bbox_iou(pbox, tbox[i], CIoU=True) 计算了预测框与目标框之间的 CIOU（Complete IoU）。

1.2 CIOU公式

CIOU（Complete Intersection over Union）是对 IoU 的扩展，考虑了框的中心点距离、宽高比损失和最小外接矩形对角线的惩罚。其公式如下：

$CIOU = IoU - \frac{\rho^2(b, b^{gt})}{c^2} - \alpha v$

其中：

$IoU$ 是传统的交并比（Intersection over Union），衡量预测框和目标框的重叠程度。
$\rho^2(b, b^{gt})$ 是预测框和目标框中心点之间的欧氏距离的平方，表示框中心的距离

$\rho(b, b^{gt}) = \sqrt{(x_p - x_t)^2 + (y_p - y_t)^2}$

其中 $(x_p, y_p)$ 是预测框的中心， $(x_t, y_t)$ 是目标框的中心。

$c$ 是包含预测框和目标框的最小外接矩形的对角线长度，计算公式为：

$c = \sqrt{(x_{\text{max}} - x_{\text{min}})^2 + (y_{\text{max}} - y_{\text{min}})^2}$

其中 $(x_{\text{max}}, y_{\text{max}})$ 和 $(x_{\text{min}}, y_{\text{min}})$ 分别是包含预测框和目标框的最小外接矩形的两个对角点。

$\alpha$ 是宽高比的惩罚系数，通常计算为

$\alpha = \frac{v}{(1 - IoU + v)}$

其中 $v$ 是宽高比损失，计算公式为：

$v = 4 \cdot \left( \frac{\text{arctan}(w_t / h_t) - \text{arctan}(w_p / h_p)}{\pi} \right)^2$

其中 $w_p, h_p$ 是预测框的宽度和高度， $w_t, h_t$ 是目标框的宽度和高度。

lbox的数学公式

在代码中，lbox 是通过以下方式计算的：

lbox += (1.0 - iou).mean()  # 计算损失为(1 - IoU)的均值

其中 iou 是通过 CIOU 计算得到的，那么 lbox 的计算公式可以表示为：

$lbox = \text{mean}(1.0 - IoU)$

其中，CIOU 是通过以下步骤计算的：

计算预测框和目标框的中心点距离：

$\rho(b, b^{gt}) = \sqrt{(x_p - x_t)^2 + (y_p - y_t)^2}$

计算最小外接矩形的对角线长度：

$c = \sqrt{(x_{\text{max}} - x_{\text{min}})^2 + (y_{\text{max}} - y_{\text{min}})^2}$

计算宽高比损失 $v$ 和参数 $\alpha$ ：

$v = 4 \cdot \left( \frac{\text{arctan}(w_t / h_t) - \text{arctan}(w_p / h_p)}{\pi} \right)^2$

$\alpha = \frac{v}{(1 - IoU + v)}$

计算最终的CIOU：

$CIOU = IoU - \frac{\rho^2(b, b^{gt})}{c^2} - \alpha v$

lbox 损失：

$lbox = \text{mean}(1.0 - CIOU)= \text{mean}(1.0 - \left( IoU - \frac{\rho^2(b, b^{gt})}{c^2} - \alpha v \right))$

这个公式表示的是通过 CIOU 衡量预测框和目标框之间的匹配程度，损失值越小，表示预测框和目标框越接近，反之损失值越大。

2. lobj部分损失函数详解

`2.1 lobj` 的数学公式分析

在 ComputeLoss 类中的 __call__ 方法，lobj 是通过以下方式计算的：

# 计算目标框的物体存在性损失（即objectness loss）
tobj = torch.zeros(pi.shape[:4], dtype=pi.dtype, device=self.device)  # 初始化目标框物体存在性损失
iou = bbox_iou(pbox, tbox[i], CIoU=True).detach().clamp(0).type(tobj.dtype)  # 计算IoU并将其限制在[0,1]之间
tobj[b, a, gj, gi] = iou  # 将IoU赋值给目标框的物体存在性
obji = self.BCEobj(pi[..., 4], tobj)  # 计算物体存在性损失
lobj += obji * self.balance[i]  # 加权物体存在性损失

lobj 是目标框的物体存在性损失，它的计算是基于预测框与目标框之间的 IoU，即物体是否存在的置信度。

`2.1 lobj` 计算步骤

我们逐步分析这一部分的计算过程：

物体存在性目标 (tobj):

在计算 lobj 时，首先会计算每个预测框的物体存在性目标，即预测框与目标框之间的 IoU。tobj 用来存储这些目标值，表示每个位置上预测框是否包含物体：
```
tobj = torch.zeros(pi.shape[:4], dtype=pi.dtype, device=self.device)  # 初始化目标框的物体存在性
```
计算物体存在性目标值 (tobj[b, a, gj, gi] = iou):

对于每一个预测框和目标框，计算它们的 CIOU 值，这里使用了 bbox_iou(pbox, tbox[i], CIoU=True) 进行计算。计算出的 IoU 之后会被映射为目标框 tobj 的物体存在性标签。这些标签在物体存在时接近 1，在物体不存在时接近 0。
```
iou = bbox_iou(pbox, tbox[i], CIoU=True).detach().clamp(0).type(tobj.dtype)  # 计算物体存在性（IoU）
```
计算物体存在性损失 (obji):

使用 BCEWithLogitsLoss（带有 sigmoid 的二元交叉熵损失）计算预测的物体存在性与目标存在性之间的损失。具体地，对于每个预测框的物体存在性输出（pi[..., 4]），与目标值 tobj 计算交叉熵损失：
```
obji = self.BCEobj(pi[..., 4], tobj)  # 计算物体存在性损失
```
其中：
- pi[..., 4] 是预测框的物体存在性预测值，通常是通过 sigmoid 激活得到的一个值，表示该位置是否有物体的概率。
- tobj 是目标值（物体存在的标签），是通过计算 IoU 得到的值，通常会在物体存在时接近 1，而物体不存在时接近 0。
加权物体存在性损失:

最后，将计算出的物体存在性损失 obji 加权并累加到 lobj 中。这里的加权是通过 self.balance[i] 实现的，不同的层（对应不同尺度的预测框）可能有不同的加权策略。
```
lobj += obji * self.balance[i]  # 加权物体存在性损失
```

`2.3 lobj` 损失函数的数学公式

从上述代码可以总结出，lobj 损失的计算步骤大致如下：

计算预测框与目标框的 IoU

$CIOU = IoU - \frac{\rho^2(b, b^{gt})}{c^2} - \alpha v$

其中 IoU 计算的是预测框与目标框之间的重叠区域（交集）与它们的并集的比例。

计算物体存在性目标 (tobj):

根据代码中的逻辑，tobj 是基于 CIOU 计算的物体存在性标签：

$t_{obj}(b, a, gj, gi) = \text{CIoU}(b, b^{gt})$

其中 $b$ 表示预测框，表示目标框。

BCEWithLogitsLoss 计算物体存在性损失:

使用 BCEWithLogitsLoss 计算预测框物体存在性概率与目标之间的损失，损失函数的公式为：

$L_{obj} = -\left[ t_{obj} \log(\sigma(p_{obj})) + (1 - t_{obj}) \log(1 - \sigma(p_{obj})) \right]$

        其中：

         $\sigma(p_{obj})$ 是预测框的物体存在性概率，通过 sigmoid 激活得到。

         $t_{obj}$ 是目标值，表示物体存在性（通过 IoU 计算得到）。

加权物体存在性损失:

最后，物体存在性损失会根据每一层的不同尺度加权：

$L_{obj} = \sum_i L_{obj} \cdot \text{balance}[i]$

其中 balance[i] 是加权系数，通常是针对不同预测尺度（例如 P3 到 P7）的不同权重，用来平衡各个尺度上的损失。

因此，lobj 损失的公式可以总结为：

$L_{obj} = \\ \sum_{i} \left( -\left[ t_{obj} \log(\sigma(p_{obj})) + (1 - t_{obj}) \log(1 - \sigma(p_{obj})) \right] \right) \cdot \text{balance}[i]$

其中：

tobjt_{obj} 是通过 CIOU 计算得到的物体存在性目标（IoU值）。
pobjp_{obj} 是预测框的物体存在性概率。
balance[i] 是层加权系数。

这个损失项的目标是使得预测框的物体存在性概率 $p_{obj}$ 更准确地与目标框的物体存在性标签 $t_{obj}$ 匹配，进而提高检测精度。

`3.lcls` 部分损失函数详解

`3.1 lcls` 的数学公式分析

在 ComputeLoss 类中的 __call__ 方法，lcls 是通过以下方式计算的：

# 计算分类损失（即 lcls）
if self.nc > 1:  # 如果类别数大于 1，则进行分类损失计算t = torch.full_like(pcls, self.cn, device=self.device)  # 初始化目标分类标签t[range(n), tcls[i]] = self.cp  # 将目标类别位置标记为正类标签lcls += self.BCEcls(pcls, t)  # 计算分类损失并累加

lcls 是基于预测的类别概率与目标类别之间的 BCE（Binary Cross-Entropy）损失，即分类损失。具体来说，对于每个预测框的类别概率与目标类别进行比较，计算其交叉熵损失。

`3.2 lcls` 计算步骤

我们逐步分析这一部分的计算过程：

初始化目标分类标签 (t):

首先，代码会创建一个与预测类别概率 pcls 相同形状的张量 t，并初始化为负类别标签（self.cn）。self.cn 是负类标签的概率（通常为0，除非使用了标签平滑）。
```
t = torch.full_like(pcls, self.cn, device=self.device)  # 初始化目标分类标签
```
将目标类别位置标记为正类标签:

对于每个目标框 tcls[i]，将目标类别的标签位置设置为正类标签 self.cp（self.cp 是正类标签的概率，通常为1）。
```
t[range(n), tcls[i]] = self.cp  # 将目标类别位置标记为正类标签
```
这里 tcls[i] 是目标类别的索引，n 是当前批次中目标框的数量。t 是目标的类别标签矩阵，其中 self.cp 是目标类别的正类标签（通常是1），其余部分是负类标签。
计算分类损失:

然后，使用 BCEWithLogitsLoss（带有 sigmoid 激活函数的二元交叉熵损失）计算预测框的类别概率与目标类别标签之间的损失：
```
lcls += self.BCEcls(pcls, t)  # 计算分类损失并累加
```
其中：
- pcls 是预测的类别概率
- t 是目标类别标签
换句话说，lcls 是通过二元交叉熵损失来衡量每个类别预测的概率与目标类别之间的差异。

`3.3 lcls` 损失的数学公式

从上述代码可以总结出，lcls 损失的计算步骤大致如下：

初始化目标类别标签 t:

对于每个目标框，将目标类别的标签位置设置为正类标签，其他位置为负类标签。设定目标标签矩阵 t：

$t_{ij} = \begin{cases} \text{cp} & \text{if } j = tcls[i] \\ \text{cn} & \text{if } j \neq tcls[i] \end{cases}$

其中，tcls[i] 是目标框的类别索引，cp 是正类标签（通常为 1），cn 是负类标签（通常为 0）。

二元交叉熵损失（BCE Loss）：

对于每个预测框的类别概率 pcls 和目标标签 t，计算交叉熵损失。分类损失的公式为：

$L_{cls} = -\sum_{i} \left[ t_i \log(\sigma(p_i)) + (1 - t_i) \log(1 - \sigma(p_i)) \right]$

其中

$p_i$ 是预测的类别概率，表示预测框属于某个类别的概率。
$t_i$ 是目标类别标签，表示实际类别（1 或 0）。

注意：这个损失函数是 BCEWithLogitsLoss，即在计算之前先对预测的类别概率进行 sigmoid 激活。

因此，lcls 损失的公式可以总结为

$L_{cls} = \sum_i \left( -\left[ t_i \log(\sigma(p_i)) + (1 - t_i) \log(1 - \sigma(p_i)) \right] \right)$

其中

$p_i$ 是预测的类别概率，表示预测框属于某个类别的概率。
$t_i$ 是目标类别标签，表示实际类别（1 或 0）。

这个损失项的目标是使得预测框的类别概率 $p_i$ 更准确地与目标框的真实类别 $t_i$ 匹配，从而提高分类准确性。

4. 最终的总损失公式

其中YOLOv3代码如下

lbox *= self.hyp["box"]
lobj *= self.hyp["obj"]
lcls *= self.hyp["cls"]
bs = tobj.shape[0]  # batch sizereturn (lbox + lobj + lcls) * bs, torch.cat((lbox, lobj, lcls)).detach()

将这三个部分的损失加权合并，得到总损失：

$L_{\text{total}} = \left( L_{box} \cdot \text{hyp}[\text{box}] \right) + \left( L_{obj} \cdot \text{hyp}[\text{obj}] \right) + \left( L_{cls} \cdot \text{hyp}[\text{cls}] \right)$

其中：

$hyp[box], hyp[obj], hyp[cls]$ 是预定义的超参数，用来控制不同损失项的权重。
$L_{box}, L_{obj}, L_{cls}$ 分别是边界框回归损失、物体存在性损失和分类损失。

在YOLOv3 train.py文件中给出如下代码

            # Forwardwith torch.cuda.amp.autocast(amp):pred = model(imgs)  # forwardloss, loss_items = compute_loss(pred, targets.to(device))  # loss scaled by batch_sizeif RANK != -1:loss *= WORLD_SIZE  # gradient averaged between devices in DDP modeif opt.quad:loss *= 4.0# Backwardscaler.scale(loss).backward()

故还有如下工作：

在分布式训练中（RANK != -1），需要对损失进行缩放：

$L_{\text{total}} = L_{\text{total}} \times \text{WORDSIZE}$

如果 opt.quad 为真，损失会乘以 4.0：

$L_{\text{total}} = L_{\text{total}} \times 4.0$

事实上，在查阅很对资料的时候，博主发现很多其他博主or文章资料给出的公式，但是说实话，网上没有一个非常权威的公式（作者自己也没在论文中写）。

本博主自身能力也有限，给不了打包票的保证就一定不会错。但是上诉的公式均是博主自己查阅作者的官方代码一点点写出来的！最后还是求个赞吧！