yolov5优化之改变损失函数

### YOLOv10分类损失函数解析 #### 分类损失函数概述 YOLOv10引入并优化了几种先进的分类损失函数，旨在提高模型在不同场景下的表现。这些损失函数不仅增强了模型处理复杂背景的能力，还提升了对小物体检测的效果。 #### Slide Loss Slide Loss通过调整预测类别概率分布的方式，使得模型更加关注难以区分的对象。该方法通过对样本权重进行动态调整，在训练过程中逐步聚焦于难分样本，从而改善整体性能[^1]。 ```python def slide_loss(pred, target): # 计算滑动窗口内的交叉熵损失 loss = F.cross_entropy(pred, target, reduction='none') # 动态调整样本权重 weights = adjust_weights_based_on_difficulty(target) return (loss * weights).mean() ``` #### VariFocal Loss VariFocal Loss是一种针对密集场景设计的新型损失函数，特别适合解决大量目标聚集的情况。此算法能够自适应地改变焦点区域大小，并根据实例密度自动调节惩罚力度，有效解决了传统方法中存在的正负样本不平衡问题[^2]。 ```python import torch.nn.functional as F def varifocal_loss(pred, gt_score, beta=2.0, alpha=0.25): pred_sigmoid = pred.sigmoid() pt = (1 - pred_sigmoid) * gt_score + pred_sigmoid * (1 - gt_score) focal_weight = (alpha * gt_score + (1 - alpha) * (1 - gt_score)) * pt.pow(beta) bce_loss = F.binary_cross_entropy_with_logits( pred, gt_score, reduction='none') loss = focal_weight * bce_loss return loss.mean() ``` #### VFLoss 和 FocalLoss 的区别与联系 VFLoss（Variants of Focal Loss）是在经典Focal Loss基础上发展而来的变体之一。两者都致力于缓解极端类别不均衡带来的挑战；然而,VariFocal进一步考虑到了局部特征的重要性以及对象间相互作用的影响，因此更适合应用于现代视觉识别任务中。

### YOLOv5 中集成 OTA 损失函数的方法 OTA（Optimal Transport Assignment）是一种优化目标检测任务中正负样本分配策略的技术，其核心思想是通过最优传输理论来计算更合理的匹配代价矩阵，并以此指导损失函数的设计。为了在 YOLOv5 中实现 OTA 损失函数，可以按照以下方式操作。 #### 1. 修改损失函数模块 YOLOv5 的损失函数定义位于 `models/yolo.py` 文件中的 `ComputeLoss` 类。该类负责处理边界框回归、类别预测和置信度预测的损失计算。要引入 OTA 损失函数，需替换默认的匹配逻辑并重新设计损失权重。 以下是修改后的代码示例： ```python import torch from utils.metrics import bbox_iou class ComputeOTALoss: def __init__(self, model): super(ComputeOTALoss, self).__init__() device = next(model.parameters()).device # get model device h = model.hyp # hyperparameters # Define criteria BCEcls = torch.nn.BCEWithLogitsLoss(pos_weight=torch.tensor([h['cls_pw']], device=device)) BCEobj = torch.nn.BCEWithLogitsLoss(pos_weight=torch.tensor([h['obj_pw']], device=device)) # Class label smoothing https://arxiv.org/pdf/1902.04103.pdf self.cp, self.cn = smooth_BCE(eps=h.get('label_smoothing', 0.0)) # positive, negative BCE targets # Focal loss g = h['fl_gamma'] # focal loss gamma if g > 0: BCEcls, BCEobj = FocalLoss(BCEcls, g), FocalLoss(BCEobj, g) det = model.module.model[-1] if hasattr(model, 'module') else model.model[-1] # Detect() module self.balance = {3: [4.0, 1.0, 0.4]}.get(det.nl, [4.0, 1.0, 0.25, 0.06, .02]) # P3-P7 self.ssi = list(det.stride).index(16) if autobalance else 0 # stride 16 index self.BCEcls, self.BCEobj, self.gr, self.hyp, self.autobalance = BCEcls, BCEobj, model.gr, h, autobalance for k in 'na', 'nc', 'nl', 'anchors': setattr(self, k, getattr(det, k)) def build_targets(self, p, targets): """ Build targets for compute_loss(), input targets(image,class,x,y,w,h) """ na, nt = self.na, targets.shape[0] # number of anchors, targets tcls, tbox, indices, anch = [], [], [], [] gain = torch.ones(7, device=targets.device) # normalized to gridspace gain ai = torch.arange(na, device=targets.device).float().view(na, 1) # anchor indices shape=(na,1) targets = torch.cat((targets.repeat(na, 1, 1), ai[:, :, None]), 2) # append anchor indices g = 0.5 # bias off = torch.tensor([[0, 0], [1, 0], [0, 1], [-1, 0], [0, -1]], device=targets.device).float() * g # offsets for i in range(self.nl): anchors = self.anchors[i] gain[2:6] = torch.tensor(p[i].shape)[[3, 2, 3, 2]] # xyxy gain # Match targets to anchors t = targets * gain if nt: r = t[:, :, 4:6] / anchors[:, None] # wh ratio j = torch.max(r, 1. / r).max(2)[0] < self.hyp['anchor_t'] # compare # Filter matches by aspect ratio and scale thresholds t = t[j] # Offsets gxy = t[:, 2:4] # grid xy gxi = gain[[2, 3]] - gxy # inverse j, k = ((gxy % 1. < g) & (gxy > 1.)).T l, m = ((gxi % 1. < g) & (gxi > 1.)).T t = torch.cat((t, t[j], t[k], t[l], t[m])) # update targets with additional offsets # Define b, c = t[:, :2].long().T # image, class gxy = t[:, 2:4] # grid xy gwh = t[:, 4:6] # grid wh gij = (gxy - offset).long() gi, gj = gij.T # grid xy indices # Append indices.append((b, a, gj.clamp_(0, gain[3] - 1), gi.clamp_(0, gain[2] - 1))) # image, anchor, grid indices tbox.append(torch.cat((gxy - gij, gwh), 1)) # box anch.append(anchors[a]) # anchors tcls.append(c) # class return tcls, tbox, indices, anch def forward(self, p, targets): """ Forward pass through the OTALoss function """ device = targets.device lcls, lbox, lobj = torch.zeros(1, device=device), torch.zeros(1, device=device), torch.zeros(1, device=device) tcls, tbox, indices, anchors = self.build_targets(p, targets) # Losses for i, pi in enumerate(p): # layer index, layer predictions b, a, gj, gi = indices[i] # image, anchor, gridy, gridx tobj = torch.zeros_like(pi[..., 0], device=device) # target obj n = b.shape[0] # number of targets if n: ps = pi[b, a, gj, gi] # prediction subset relevant to targets # Regression pxy = ps[:, :2].sigmoid() * 2 - 0.5 pwh = (ps[:, 2:4].sigmoid() * 2) ** 2 * anchors[i] pbox = torch.cat((pxy, pwh), 1) # predicted box iou = bbox_iou(pbox.T, tbox[i], x1y1x2y2=False, CIoU=True) # IoU lbox += (1.0 - iou).mean() # Classification if self.nc > 1: # cls loss (only if multiple classes) t = torch.full_like(ps[:, 5:], self.cn, device=device) # targets t[range(n), tcls[i]] = self.cp lcls += self.BCEcls(ps[:, 5:], t) # BCE # Objectness tobj[b, a, gj, gi] = iou.detach().clamp(0).type(tobj.dtype) # iou ratio lobj += self.BCEobj(pi[..., 4], tobj) # obj loss s = 3 / self.nl # output count scaling lbox *= self.hyp['box'] * s lobj *= self.hyp['obj'] * s * (1.4 if selfautobalance else 1.) lcls *= self.hyp['cls'] * s bs = tobj.shape[0] # batch size return (lbox + lobj + lcls) * bs, torch.cat((lbox, lobj, lcls)).detach() ``` 上述代码实现了基于 OTA 的损失函数构建过程[^1]。具体来说，`build_targets` 方法被重写以支持最优传输算法的目标分配机制，而 `forward` 函数则完成了最终的损失计算。 --- #### 2. 替换原始损失函数 将原项目中的 `ComputeLoss` 替换为自定义的 `ComputeOTALoss` 实现。这可以通过编辑 `train.py` 或其他训练脚本来完成。 --- #### 3. 调整超参数 由于 OTA 改变了样本匹配的方式，可能需要调整一些超参数，例如锚框阈值 (`hyp['anchor_t']`) 和学习率调度器设置。 --- #### 4. 测试与验证 运行标准训练流程以测试新实现的效果。如果一切正常，则应观察到更高的 AP 值或其他性能指标提升。 --- ###