【YOLO改进】换遍IoU损失函数之GIoU Loss（基于MMYOLO）

最新推荐文章于 2024-07-09 20:07:16 发布
最新推荐文章于 2024-07-09 20:07:16 发布
阅读量753 收藏 10
点赞数 13
分类专栏： YOLO改进 文章标签： YOLO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Vlone_pp/article/details/138270256
版权
本文介绍了GIoU损失函数，一种改进的IoU损失，用于解决目标检测模型中边界框不重叠时梯度问题。在MMYOLO中，通过修改配置文件将CIoU损失替换为GIoU损失，以提高边界框预测精度。
摘要由CSDN通过智能技术生成

GIoU损失函数

论文链接:https://arxiv.org/pdf/1902.09630

GIoU（Generalized Intersection over Union）损失函数是一种用于改善目标检测模型中边界框回归的方法。它是基于传统的IoU（交并比）损失的一个改进版本，解决了IoU在某些情况下无法提供有效梯度的问题，特别是当两个边界框不重叠时。

IoU损失的局限性

IoU是评估两个边界框重叠程度的一种标准度量方法，定义为两个边界框交集与并集的比例。然而，IoU损失有一个明显的缺点：当两个边界框没有任何重叠时，IoU为0，此时无法提供有关如何调整边界框以改善预测的梯度信息。

GIoU损失的定义

GIoU损失通过引入一个额外的度量来解决这个问题，即最小封闭框（minimum enclosing box）的概念。GIoU的计算不仅考虑了交集和并集，还包括了两个框之间的空间关系。

计算步骤如下：

  1. 计算IoU：首先，计算两个边界框A和B的交集与并集的比例，即IoU。
  2. 确定最小封闭框：找到能同时包含A和B的最小边界框C。
  3. 计算正则项：计算最小封闭框C与并集U之间的区域差异，并用这个差异来调整IoU值。

公式表示为：

\text{IoU} = \frac{\text{Area of Intersection}}{\text{Area of Union}}

\text{GIoU} = \text{IoU} - \frac{\text{Area of the smallest enclosing box} - \text{Area of Union}}{\text{Area of the smallest enclosing box}}

替换GIoU损失函数(基于MMYOLO)

由于MMYOLO中已经实现了GIoU Loss的计算，所以我们想使用GIoU损失函数替换CIoU损失函数只需要修改配置文件即可：

        # 修改此处实现IoU损失函数的替换
        loss_bbox=dict(
            type='IoULoss',
            iou_mode='giou',
            bbox_format='xywh',
            eps=1e-7,
            reduction='mean',
            loss_weight=loss_bbox_weight * (3 / num_det_layers),
            return_iou=True),

修改后的配置文件（以configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py为例）

_base_ = ['../_base_/default_runtime.py', '../_base_/det_p5_tta.py']

# ========================Frequently modified parameters======================
# -----data related-----
data_root = 'data/coco/'  # Root path of data
# Path of train annotation file
train_ann_file = 'annotations/instances_train2017.json'
train_data_prefix = 'train2017/'  # Prefix of train image path
# Path of val annotation file
val_ann_file = 'annotations/instances_val2017.json'
val_data_prefix = 'val2017/'  # Prefix of val image path

num_classes = 80  # Number of classes for classification
# Batch size of a single GPU during training
train_batch_size_per_gpu = 16
# Worker to pre-fetch data for each single GPU during training
train_num_workers = 8
# persistent_workers must be False if num_workers is 0
persistent_workers = True

# -----model related-----
# Basic size of multi-scale prior box
anchors = [
    [(10, 13), (16, 30), (33, 23)],  # P3/8
    [(30, 61), (62, 45), (59, 119)],  # P4/16
    [(116, 90), (156, 198), (373, 326)]  # P5/32
]

# -----train val related-----
# Base learning rate for optim_wrapper. Corresponding to 8xb16=128 bs
base_lr = 0.01
max_epochs = 300  # Maximum training epochs

model_test_cfg = dict(
    # The config of multi-label for multi-class prediction.
    multi_label=True,
    # The number of boxes before NMS
    nms_pre=30000,
    score_thr=0.001,  # Threshold to filter out boxes.
    nms=dict(type='nms', iou_threshold=0.65),  # NMS type and threshold
    max_per_img=300)  # Max number of detections of each image

# ========================Possible modified parameters========================
# -----data related-----
img_scale = (640, 640)  # width, height
# Dataset type, this will be used to define the dataset
dataset_type = 'YOLOv5CocoDataset'
# Batch size of a single GPU during validation
val_batch_size_per_gpu = 1
# Worker to pre-fetch data for each single GPU during validation
val_num_workers = 2

# Config of batch shapes. Only on val.
# It means not used if batch_shapes_cfg is None.
batch_shapes_cfg = dict(
    type='BatchShapePolicy',
    batch_size=val_batch_size_per_gpu,
    img_size=img_scale[0],
    # The image scale of padding should be divided by pad_size_divisor
    size_divisor=32,
    # Additional paddings for pixel scale
    extra_pad_ratio=0.5)

# -----model related-----
# The scaling factor that controls the depth of the network structure
deepen_factor = 0.33
# The scaling factor that controls the width of the network structure
widen_factor = 0.5
# Strides of multi-scale prior box
strides = [8, 16, 32]
num_det_layers = 3  # The number of model output scales
norm_cfg = dict(type='BN', momentum=0.03, eps=0.001)  # Normalization config

# -----train val related-----
affine_scale = 0.5  # YOLOv5RandomAffine scaling ratio
loss_cls_weight = 0.5
loss_bbox_weight = 0.05
loss_obj_weight = 1.0
prior_match_thr = 4.  # Priori box matching threshold
# The obj loss weights of the three output layers
obj_level_weights = [4., 1., 0.4]
lr_factor = 0.01  # Learning rate scaling factor
weight_decay = 0.0005
# Save model checkpoint and validation intervals
save_checkpoint_intervals = 10
# The maximum checkpoints to keep.
max_keep_ckpts = 3
# Single-scale training is recommended to
# be turned on, which can speed up training.
env_cfg = dict(cudnn_benchmark=True)

# ===============================Unmodified in most cases====================
model = dict(
    type='YOLODetector',
    data_preprocessor=dict(
        type='mmdet.DetDataPreprocessor',
        mean=[0., 0., 0.],
        std=[255., 255., 255.],
        bgr_to_rgb=True),
    backbone=dict(
        ##使用YOLOv8的主干网络

        type='YOLOv8CSPDarknet',
        deepen_factor=deepen_factor,
        widen_factor=widen_factor,
        norm_cfg=norm_cfg,
        act_cfg=dict(type='SiLU', inplace=True)

    ),
    neck=dict(
        type='YOLOv5PAFPN',
        deepen_factor=deepen_factor,
        widen_factor=widen_factor,
        in_channels=[256, 512, 1024],
        out_channels=[256, 512, 1024],
        num_csp_blocks=3,
        norm_cfg=norm_cfg,
        act_cfg=dict(type='SiLU', inplace=True)),
    bbox_head=dict(
        type='YOLOv5Head',
        head_module=dict(
            type='YOLOv5HeadModule',
            num_classes=num_classes,
            in_channels=[256, 512, 1024],
            widen_factor=widen_factor,
            featmap_strides=strides,
            num_base_priors=3),
        prior_generator=dict(
            type='mmdet.YOLOAnchorGenerator',
            base_sizes=anchors,
            strides=strides),
        # scaled based on number of detection layers
        loss_cls=dict(
            type='mmdet.CrossEntropyLoss',
            use_sigmoid=True,
            reduction='mean',
            loss_weight=loss_cls_weight *
            (num_classes / 80 * 3 / num_det_layers)),
        # 修改此处实现IoU损失函数的替换
        loss_bbox=dict(
            type='IoULoss',
            iou_mode='giou',
            bbox_format='xywh',
            eps=1e-7,
            reduction='mean',
            loss_weight=loss_bbox_weight * (3 / num_det_layers),
            return_iou=True),
        loss_obj=dict(
            type='mmdet.CrossEntropyLoss',
            use_sigmoid=True,
            reduction='mean',
            loss_weight=loss_obj_weight *
            ((img_scale[0] / 640)**2 * 3 / num_det_layers)),
        prior_match_thr=prior_match_thr,
        obj_level_weights=obj_level_weights),
    test_cfg=model_test_cfg)

albu_train_transforms = [
    dict(type='Blur', p=0.01),
    dict(type='MedianBlur', p=0.01),
    dict(type='ToGray', p=0.01),
    dict(type='CLAHE', p=0.01)
]

pre_transform = [
    dict(type='LoadImageFromFile', file_client_args=_base_.file_client_args),
    dict(type='LoadAnnotations', with_bbox=True)
]

train_pipeline = [
    *pre_transform,
    dict(
        type='Mosaic',
        img_scale=img_scale,
        pad_val=114.0,
        pre_transform=pre_transform),
    dict(
        type='YOLOv5RandomAffine',
        max_rotate_degree=0.0,
        max_shear_degree=0.0,
        scaling_ratio_range=(1 - affine_scale, 1 + affine_scale),
        # img_scale is (width, height)
        border=(-img_scale[0] // 2, -img_scale[1] // 2),
        border_val=(114, 114, 114)),
    dict(
        type='mmdet.Albu',
        transforms=albu_train_transforms,
        bbox_params=dict(
            type='BboxParams',
            format='pascal_voc',
            label_fields=['gt_bboxes_labels', 'gt_ignore_flags']),
        keymap={
            'img': 'image',
            'gt_bboxes': 'bboxes'
        }),
    dict(type='YOLOv5HSVRandomAug'),
    dict(type='mmdet.RandomFlip', prob=0.5),
    dict(
        type='mmdet.PackDetInputs',
        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip',
                   'flip_direction'))
]

train_dataloader = dict(
    batch_size=train_batch_size_per_gpu,
    num_workers=train_num_workers,
    persistent_workers=persistent_workers,
    pin_memory=True,
    sampler=dict(type='DefaultSampler', shuffle=True),
    dataset=dict(
        type=dataset_type,
        data_root=data_root,
        ann_file=train_ann_file,
        data_prefix=dict(img=train_data_prefix),
        filter_cfg=dict(filter_empty_gt=False, min_size=32),
        pipeline=train_pipeline))

test_pipeline = [
    dict(type='LoadImageFromFile', file_client_args=_base_.file_client_args),
    dict(type='YOLOv5KeepRatioResize', scale=img_scale),
    dict(
        type='LetterResize',
        scale=img_scale,
        allow_scale_up=False,
        pad_val=dict(img=114)),
    dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'),
    dict(
        type='mmdet.PackDetInputs',
        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
                   'scale_factor', 'pad_param'))
]

val_dataloader = dict(
    batch_size=val_batch_size_per_gpu,
    num_workers=val_num_workers,
    persistent_workers=persistent_workers,
    pin_memory=True,
    drop_last=False,
    sampler=dict(type='DefaultSampler', shuffle=False),
    dataset=dict(
        type=dataset_type,
        data_root=data_root,
        test_mode=True,
        data_prefix=dict(img=val_data_prefix),
        ann_file=val_ann_file,
        pipeline=test_pipeline,
        batch_shapes_cfg=batch_shapes_cfg))

test_dataloader = val_dataloader

param_scheduler = None
optim_wrapper = dict(
    type='OptimWrapper',
    optimizer=dict(
        type='SGD',
        lr=base_lr,
        momentum=0.937,
        weight_decay=weight_decay,
        nesterov=True,
        batch_size_per_gpu=train_batch_size_per_gpu),
    constructor='YOLOv5OptimizerConstructor')

default_hooks = dict(
    param_scheduler=dict(
        type='YOLOv5ParamSchedulerHook',
        scheduler_type='linear',
        lr_factor=lr_factor,
        max_epochs=max_epochs),
    checkpoint=dict(
        type='CheckpointHook',
        interval=save_checkpoint_intervals,
        save_best='auto',
        max_keep_ckpts=max_keep_ckpts))

custom_hooks = [
    dict(
        type='EMAHook',
        ema_type='ExpMomentumEMA',
        momentum=0.0001,
        update_buffers=True,
        strict_load=False,
        priority=49)
]

val_evaluator = dict(
    type='mmdet.CocoMetric',
    proposal_nums=(100, 1, 10),
    ann_file=data_root + val_ann_file,
    metric='bbox')
test_evaluator = val_evaluator

train_cfg = dict(
    type='EpochBasedTrainLoop',
    max_epochs=max_epochs,
    val_interval=save_checkpoint_intervals)
val_cfg = dict(type='ValLoop')
test_cfg = dict(type='TestLoop')

五山一胖
关注
  • 13
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
目标检测（损失函数）：目标定位损失—GIoU
牛顿爱吃香蕉的博客
08-28 7522
目标检测（损失函数）：目标定位损失—GIoU1、提出问题2、解决方案 CVPR 2019CVPR~2019CVPR 2019 有一篇介绍目标检测定位损失函数的 paperpaperpaper： 论文链接：Generalized Intersection over Union: A Metric and A Loss for Bounding Box Regression 1、提...
GIOU损失函数
qq_35674193的博客
12-11 2306
1、问题：giou为什么要加IOU？ 这是因为-号两边的部分，在A和B重合前后只有一个生效，另一个是0. 2、Lgiou 式子中为什么要用1减？ 为了将式子变成减函数，方便梯度下降。
YOLO损失函数——SIoU和Focal Lossr损失函数解析
知来者逆的博客
05-15 1484
在深度学习的目标检测领域，损失函数扮演着至关重要的角色，它们不仅衡量模型预测与实际标注之间的差异，还引导模型参数的优化方向。SIoU (Shape-Aware IoU) 损失是一种用于边界框回归的先进损失函数，它综合考虑了形状、距离和纵横比的对齐，以提升模型的收敛速度和预测准确性。SIoU损失通过结合角度成本、距离成本、形状成本和IoU成本，优化了边界框的定位精度。
loss盘点: GIoU loss (拆 PaddleDetection 轮子)
先说一下，就简单地写点儿氵文，不是博客，只是我的笔记本
01-11 566
.
GIoU Loss 损失函数浅析
热门推荐
WalkingSoul的博客
09-26 1万+
GIoU Loss 参考文献：Generalized Intersection over Union: A Metric and A Loss for Bounding Box Regression GIoU是源自IoU的一种边框预测的损失计算方法，在目标检测等领域，需要对预测边框（pre BBox）与实际标注边框（ground truth BBox）进行对比，计算损失。在Yolo算法中，给定预测...
【GIoU loss】GIoU loss损失函数理解
计算机视觉方面的点点滴滴，欢迎一起讨论
05-22 7517
文章目录1 引言2 问题分析3 GIoU Loss计算过程4 IoU和GIoU对比分析5 感谢链接 1 引言 目标检测任务的损失函数由Classificition Loss和Bounding Box Regeression Loss两部分构成。 Bounding Box Regression Loss Function的演进路线是： Smooth L1 Loss --> IoU Loss --> GIoU Loss --> DIoU Loss --> CIoU Loss 之前写到了
GIoU DIoU CIoU loss 损失函数
不佛的博客
12-01 1万+
目标检测任务中，Bounding Box的评估指标是IoU，IoU范围在(0,1)(0,1)(0,1)之间，具有尺度不变性，而且可以衡量各种形状的匹配程度。我们自然会考虑能否将IoU设计为一个损失函数。 IoU loss 最简单的，直接将1-IoU定义为损失，我自己在简单的目标检测项目中尝试过，基本没有办法学习，主要原因是：当预测框和目标框不相交时，IoU始终为0，损失函数不可导，无法优化。 另外这种损失定义方式无法区分IoU的各种情况，同样的IoU值，重叠形状可以有许多种，它们在效果上是有差异的，因此
目标检测中的损失函数：IOU_Loss、GIOU_Loss、DIOU_Loss和CIOU_Loss
JulyLi2019的博客
12-04 2458
之前在项目中存在目标检测框内嵌的情况（目标检测框存在内嵌情况分析与解决），正好趁这个机会记录下目标检测中常用的几种IOU_loss函数。IOU_Loss作为传统的衡量标准，为我们提供了一个基础,而GIOU_Loss、DIOU_Loss和CIOU_Loss则在其基础上引入了更多的信息，如目标框的形状和相对位置等，从而使得模型更加准确地学习目标的位置和形状。！！2023年12月4日20:03:02。
ssd算法及相关算法改进
01-08
或者采用更有效的定位损失函数，如GIoU（Generalized IoU）和DIoU（Distance IoU），改善框的回归精度。 5. **Post-processing技巧**：NMS（Non-Maximum Suppression）是常用的后处理方法，用于去除重叠的预测框，...
基于yolov5第七版本农业旋转体目标检测
02-29
3. **损失函数**：引入了更优的损失函数设计，如CIoU（Complete IoU）和GIoU（Generalized IoU），提升了边界框预测的精度。 4. **训练策略**：采用了更灵活的训练策略，如动态学习率调度、早停策略，以及更合理的...
这是一套基于 YOLOV5 模型的安全区域检测代码
02-21
3. Loss函数改进：YOLOV5使用了更复杂的损失函数，如GIoU（Generalized IoU）、DIoU（Distance IoU）和CIoU（Complete IoU），以更好地衡量预测框与真实框的匹配程度。 4. 快速训练：YOLOV5利用了PyTorch框架的并行...
Wheat_det
02-21
GIOU Loss $ [1]}＃由IOU引起的梯度消失的交易对于非重叠而言为零 与GIOU相结合的回归 失去信心 二元交叉熵很难找到正负号TT [x]骰子损失[2] 希望能帮助解决班级失衡 不如预期的好 非最大抑制 硬网管 软...
yolov5轻量级目标检测框架.rar
05-21
3. **Loss函数优化**：YOLOv5采用了更加适合目标检测的损失函数，如GIOU（Generalized Intersection over Union）和DIoU（Distance IoU），这些损失函数能更好地衡量预测边界框与真实边界框的匹配程度。 4. **权重...
IoU、GIoU、DIoU、CIoU损失函数
吴建明wujianming_110117
05-31 4438
IoU、GIoU、DIoU、CIoU损失函数 目标检测任务的损失函数由Classificition Loss和Bounding Box Regeression Loss两部分构成。目标检测任务中近几年来Bounding Box Regression Loss Function的演进过程，其演进路线是 一、IOU(Intersection over Union) 特性(优点) IoU就是我们所说的交并比，是目标检测中最常用的指标，在anchor-based的方法。作用不仅用来确定正样本和负样本，还可以用
GIoU损失论文笔记
weixin_39558227的博客
12-09 655
文章目录 Generalized Intersection over Union: A Metric and A Loss for Bounding Box Regression 代码 Giou能够优化那些完全没有相交的框（IOU损失做不到） l2损失的缺点 如上图a所示 三者的l2损失相同，但是iou相差巨大，因为如果利用的是l2损失，bbox的信息其实就是用左上角和右下角坐标信息来代表的。...
IoU的进化之路——IoU、GIoU、DIoU、CIoU四种损失函数总结
chase
08-06 6357
IoU、GIoU、DIoU、CIoU四种损失函数总结
GIOU LOSS
qq_43586192的博客
03-29 302
1、解决具有相同重叠面积，损失相同的问题 2、解决不相交的情况，损失都为0 def Giou(rec1,rec2): #分别是第一个矩形左右上下的坐标 x1,x2,y1,y2 = rec1 x3,x4,y3,y4 = rec2 iou = Iou(rec1,rec2) area_C = (max(x1,x2,x3,x4)-min(x1,x2,x3,x4))*(max(y1,y2,y3,y4)-min(y1,y2,y3,y4)) area_1 = (x2-x1
GIOU loss
TEDDY的博客
02-23 3135
IOU IOU在0~1之间，两个框完全重合为1，所以 为0时没有重合，即值越低 IOU效果越差 IOU loss = 1 - IOU，loss 越小，效果越好，这是 IOU loss 和 IOU 的区别 GIoU 目标检测中的IOU&升级版GIOU - 知乎 IoU的局限性 预测框和真实框之间没有重合时，IoU 值为 0， 导致优化损失函数时梯度也为 0，意味着无法优化。 当IOU=0时：https://www.zhihu.com/equation?tex=GIOU%3D-1%2
实战 | YOLOv8使用TensorRT加速推理教程（步骤 + 代码）
最新发布
Color Space的博客
07-09 40
这一步主要是安装根据自己的硬件安装GPU驱动，下载CUDNN等，以往的文章已经介绍过多次，可以点击下面的图片跳转到对应文章查看(点击图片跳转)。DeepSparse：专为稀疏模型设计的CPU推理运行时，可以有效加速基于WSL2的Windows环境下的推理。OpenVINO：Intel的推理工具套件，用于CPU上的模型优化和加速，支持量化和多种硬件加速。可以使用官网下载的模型也可以使用自己训练好的模型。保持框架最新：确保使用的深度学习框架版本是最新的，以获得最新的优化和bug修复。
yolo改进损失函数
01-11
Yolo改进损失函数主要包括两个方面的改进：分类损失和回归损失。 1. 分类损失改进： Yolo v5和v8都使用了二元交叉熵（BCE）作为分类损失函数。在v5中，对于每个类别的判断，只输出“是否为此类”的置信度分数，并取最大值作为置信度。而在v8中，去掉了对象损失，直接输出各个类别的置信度分数，并对其求最大值作为anchor框的置信度。这样的改进提高了模型权重的利用率，并通过存在状态与分类状态的强关联，得标签能更好地指导模型对类别区分能力的学习。 2. 回归损失改进： Yolo v5和v8使用了CIOU（Complete Intersection over Union）作为回归损失函数。CIOU是一种改进的IoU计算方法，它考虑了目标框的位置、大小和形状等因素，能够更准确地评估目标框的匹配程度。通过使用CIOU作为回归损失函数，可以提高目标框的定位精度。 综上所述，Yolo v5和v8在分类损失和回归损失上都进行了改进，提高了模型的性能和准确度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值