YOLOv10改进 | 主干网络 |模糊图像/恶劣天气下的目标检测改进

kay_545

于 2024-07-19 17:45:00 发布

阅读量371

点赞数 21

分类专栏： YOLOv10入门 + 改进涨点文章标签： YOLO 目标检测人工智能计算机视觉面试 yolov10改进网络

本文链接：https://blog.csdn.net/m0_67647321/article/details/140541459

版权

YOLOv10入门 + 改进涨点专栏收录该内容

16 篇文章 17 订阅

订阅专栏

💡💡💡本专栏所有程序均经过测试，可成功执行💡💡💡

专栏目录：《YOLOv8改进有效涨点》专栏介绍 & 专栏目录 | 目前已有50+篇内容，内含各种Head检测头、损失函数Loss、Backbone、Neck、NMS等创新点改进——点击即可跳转

尽管基于深度学习的目标检测方法在传统数据集上取得了令人鼓舞的结果，但在恶劣天气条件下捕获的低质量图像中定位目标仍然具有挑战性。现有方法在平衡图像增强和目标检测任务方面存在困难，或者常常忽略对检测有益的潜在信息。为了缓解这个问题，我们提出了一个新颖的图像自适应YOLO（IA-YOLO）框架，其中每张图像都可以自适应地增强以获得更好的检测性能。具体来说，我们呈现了一个可微分图像处理（DIP）模块，以考虑YOLO检测器的不利天气条件，其参数由一个小型卷积神经网络（CNN-PP）预测。我们以端到端的方式联合学习CNN-PP和YOLO，这确保了CNN-PP可以在弱监督的方式下学习适当DIP来增强图像以进行检测。文章在介绍主要的原理后，将手把手教学如何进行模块的代码添加和修改，并将修改后的完整代码放在文章的最后，方便大家一键运行，小白也可轻松上手实践。对于学有余力的同学，可以挑战进阶模块。文章内容丰富，可以帮助您更好地面对深度学习目标检测YOLO系列的挑战。

专栏地址：YOLOv10入门 + 涨点——持续更新各种涨点方法

1. 原理

2. 将unfog_net添加到YOLOv8中

1. 原理

论文地址：Image-Adaptive YOLO for Object Detection in Adverse Weather Conditions——点击即可跳转

官方代码：官方代码仓库——点击即可跳转

文中提到的去雾算法主要包括以下几个部分：

1. 大气散射模型 (Atmospheric Scattering Model)

该模型将雾霾图像的形成过程表示为： $I(x) = J(x) \cdot t(x) + A \cdot (1 - t(x))$ 其中：

( I(x) ) 是雾霾图像。
( J(x) ) 是场景辐射 (即无雾图像)。
( A ) 是大气光。
( t(x) ) 是传输图。

为了恢复清晰图像 ( J(x) )，关键在于获取大气光 ( A ) 和传输图 ( t(x) )。

2. 暗通道先验 (Dark Channel Prior)

该方法基于以下假设：在无雾图像的某些区域，其至少一个颜色通道具有很低的强度值。公式为： $J{\text{dark}}(x) = \min_C \left( \min{y \in \Omega(x)} J_C(y) \right) = 0$ 其中 $\Omega(x)$ 是位置 ( x ) 附近的一个小补丁，( C ) 是颜色通道。

通过对雾霾图像进行相似的最小化操作，可以估计传输图： $t(x) = 1 - \min_C \left( \min_{y \in \Omega(x)} \frac{I_C(y)}{A_C} \right)$

3. 可学习参数 ( \omega )

为了控制去雾的程度，引入了一个参数 ( \omega )，其计算公式为： $t(x, \omega) = 1 - \omega \min_C \left( \min_{y \in \Omega(x)} \frac{I_C(y)}{A_C} \right)$

由于上述操作是可微的，因此可以通过反向传播来优化 $\omega$ ，使去雾滤波器更有利于雾霾图像检测。

4. CNN-PP 模块

在摄像机图像信号处理 (ISP) 管道中，通常使用一些可调滤波器来增强图像。本文提出了使用一个小型卷积神经网络 (CNN) 作为参数预测器，以高效地估计超参数。CNN-PP 网络由五个卷积块和两层全连接层组成，用于预测 DIP 模块的参数，从而在去雾时揭示更多的图像细节，有助于后续的检测任务。

2. 将unfog_net添加到YOLOv8中

2.1 unfog_net的代码实现

关键步骤一: 在/ultralytics/ultralytics/nn/modules/下面新建文件unfog.py，粘贴下面的代码

import torch
import torch.nn as nn
import math


class unfog_net(nn.Module):

    def __init__(self):
        super().__init__()

        self.relu = nn.ReLU(inplace=True)

        self.e_conv1 = nn.Conv2d(3, 3, 1, 1, 0, bias=True)
        self.e_conv2 = nn.Conv2d(3, 3, 3, 1, 1, bias=True)
        self.e_conv3 = nn.Conv2d(6, 3, 5, 1, 2, bias=True)
        self.e_conv4 = nn.Conv2d(6, 3, 7, 1, 3, bias=True)
        self.e_conv5 = nn.Conv2d(12, 3, 3, 1, 1, bias=True)

    def forward(self, x):

        x1 = self.relu(self.e_conv1(x))
        x2 = self.relu(self.e_conv2(x1))

        concat1 = torch.cat((x1, x2), 1)
        x3 = self.relu(self.e_conv3(concat1))

        concat2 = torch.cat((x2, x3), 1)
        x4 = self.relu(self.e_conv4(concat2))

        concat3 = torch.cat((x1, x2, x3, x4), 1)
        x5 = self.relu(self.e_conv5(concat3))

        clean_image = self.relu((x5 * x) - x5 + 1)

        return clean_image


if __name__ == "__main__":
    # Generating Sample image
    image_size = (1, 3, 640, 640)
    image = torch.rand(*image_size)

    out = unfog_net()
    out = out(image)
    print(out.size())

在IA-YOLO框架中，CNN-PP的主要作用是预测DIP（可微图像处理）模块的超参数，以根据输入图像的亮度、颜色、色调和天气特定信息自适应地调整图像处理。以下是CNN-PP处理图像的主要流程：

输入图像预处理：
- 将任意分辨率的输入图像通过双线性插值缩小到256×256的分辨率。这样可以显著节省计算成本。
CNN-PP网络结构：
- CNN-PP网络由五个卷积块和两个全连接层组成。每个卷积块包括一个3×3卷积层（步长为2）和一个Leaky ReLU激活函数。
- 五个卷积层的输出通道数分别是16、32、32、32和32。
- 最后的全连接层输出DIP模块的超参数。整个CNN-PP模型包含约165K个参数。
预测DIP参数：
- 根据图像的全局内容（如亮度、颜色、色调以及雾霾程度）来预测DIP的参数。这样，经过CNN-PP预测出的超参数可以应用于DIP模块，从而增强图像的可检测性。
DIP模块处理：
- DIP模块由六个可微滤波器组成，包括去雾（Defog）、白平衡（White Balance, WB）、伽马校正（Gamma）、对比度（Contrast）、色调（Tone）和锐化（Sharpen）滤波器。
- 这些滤波器的设计符合可微分性和分辨率独立性的原则。DIP模块应用于原始分辨率的图像以提升YOLO的检测性能。

整个流程通过端到端的混合数据训练方案进行优化，使得CNN-PP能够在弱监督的情况下学习适当的DIP来增强图像，从而在恶劣天气条件下提高目标检测性能。

2.2 更改init.py文件

关键步骤二：修改modules文件夹下的__init__.py文件，先导入函数

然后在下面的__all__中声明函数

2.3 添加yaml文件

关键步骤三：在/ultralytics/ultralytics/cfg/models/v10下面新建文件yolov10_unfog.yaml文件，粘贴下面的内容

# Ultralytics YOLO 🚀, AGPL-3.0 license
# YOLOv10 object detection model. For Usage examples see https://docs.ultralytics.com/tasks/detect

# Parameters
nc: 80 # number of classes
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
  # [depth, width, max_channels]
  l: [1.00, 1.00, 512]

backbone:
  # [from, repeats, module, args]
  - [-1, 1, unfog_net, []] # 0-P1/2
  - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
  - [-1, 3, C2f, [128, True]]
  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  - [-1, 6, C2f, [256, True]]
  - [-1, 1, SCDown, [512, 3, 2]] # 5-P4/16
  - [-1, 6, C2f, [512, True]]
  - [-1, 1, SCDown, [1024, 3, 2]] # 7-P5/32
  - [-1, 3, C2fCIB, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]] # 9
  - [-1, 1, PSA, [1024]] # 10

# YOLOv8.0n head
head:
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  - [-1, 3, C2fCIB, [512, True]] # 13

  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  - [-1, 3, C2f, [256]] # 16 (P3/8-small)

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 13], 1, Concat, [1]] # cat head P4
  - [-1, 3, C2fCIB, [512, True]] # 19 (P4/16-medium)

  - [-1, 1, SCDown, [512, 3, 2]]
  - [[-1, 10], 1, Concat, [1]] # cat head P5
  - [-1, 3, C2fCIB, [1024, True]] # 22 (P5/32-large)

  - [[16, 19, 22], 1, v10Detect, [nc]] # Detect(P3, P4, P5)

温馨提示：因为本文只是对yolov10l基础上添加模块，如果要对yolov10n/l/m/x进行添加则只需要指定对应的depth_multiple 和 width_multiple。

# YOLOv10n
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.25  # layer channel multiple
max_channels: 1024 # max_channels
 
# YOLOv10s
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.50  # layer channel multiple
max_channels: 1024 # max_channels
 
# YOLOv10l 
depth_multiple: 1.0  # model depth multiple
width_multiple: 1.0  # layer channel multiple
max_channels: 512 # max_channels
 
# YOLOv10m
depth_multiple: 0.67  # model depth multiple
width_multiple: 0.75  # layer channel multiple
max_channels: 768 # max_channels
 
# YOLOv10x
depth_multiple: 1.33  # model depth multiple
width_multiple: 1.25  # layer channel multiple
max_channels: 512 # max_channels

2.4执行程序

关键步骤五：在ultralytics文件中新建train.py，将model的参数路径设置为yolov10_unfog.yaml的路径即可

from ultralytics import YOLO
 
# Load a model
# model = YOLO('yolov8n.yaml')  # build a new model from YAML
# model = YOLO('yolov8n.pt')  # load a pretrained model (recommended for training)
 
model = YOLO(r'/projects/ultralytics/ultralytics/cfg/models/v10/yolov10_unfog.yaml')  # build from YAML and transfer weights
 
# Train the model
model.train(batch=16)

🚀运行程序，如果出现下面的内容则说明添加成功🚀

             from  n    params  module                                       arguments                     
  0                  -1  1      1761  ultralytics.nn.modules.unfog.unfog_net       []                            
  1                  -1  1      3712  ultralytics.nn.modules.conv.Conv             [3, 128, 3, 2]                
  2                  -1  3    279808  ultralytics.nn.modules.block.C2f             [128, 128, 3, True]           
  3                  -1  1    295424  ultralytics.nn.modules.conv.Conv             [128, 256, 3, 2]              
  4                  -1  6   2101248  ultralytics.nn.modules.block.C2f             [256, 256, 6, True]           
  5                  -1  1    137728  ultralytics.nn.modules.block.SCDown          [256, 512, 3, 2]              
  6                  -1  6   8396800  ultralytics.nn.modules.block.C2f             [512, 512, 6, True]           
  7                  -1  1    537600  ultralytics.nn.modules.block.SCDown          [512, 1024, 3, 2]             
  8                  -1  3   6896640  ultralytics.nn.modules.block.C2fCIB          [1024, 1024, 3, True]         
  9                  -1  1   2624512  ultralytics.nn.modules.block.SPPF            [1024, 1024, 5]               
 10                  -1  1   3948032  ultralytics.nn.modules.block.PSA             [1024, 1024]                  
 11                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 12             [-1, 6]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 13                  -1  3   2268672  ultralytics.nn.modules.block.C2fCIB          [1536, 512, 3, True]          
 14                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 15             [-1, 4]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 16                  -1  3   1247744  ultralytics.nn.modules.block.C2f             [768, 256, 3]                 
 17                  -1  1    590336  ultralytics.nn.modules.conv.Conv             [256, 256, 3, 2]              
 18            [-1, 13]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 19                  -1  3   1875456  ultralytics.nn.modules.block.C2fCIB          [768, 512, 3, True]           
 20                  -1  1    268800  ultralytics.nn.modules.block.SCDown          [512, 512, 3, 2]              
 21            [-1, 10]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 22                  -1  3   7420928  ultralytics.nn.modules.block.C2fCIB          [1536, 1024, 3, True]         
 23        [16, 19, 22]  1   3686806  ultralytics.nn.modules.head.v10Detect        [1, [256, 512, 1024]]         
YOLOv10_unfog summary: 632 layers, 42,582,007 parameters, 42,581,991 gradients, 553.4 GFLOPs

3. 完整代码分享

https://pan.baidu.com/s/1YiDstUQtGHKjLKs9wl95tg?pwd=pg5q

提取码：pg5q

4. GFLOPs

关于GFLOPs的计算方式可以查看：百面算法工程师 | 卷积基础知识——Convolution

未改进的YOLOv10lGFLOPs

改进后的GFLOPs

5. 进阶

可以结合损失函数或者卷积模块进行多重改进

6. 总结

去雾算法的主要原理基于大气散射模型，通过估计场景辐射（无雾图像）、大气光和传输图来恢复清晰图像。暗通道先验假设无雾图像的某些区域至少有一个颜色通道的强度值很低，利用此假设可以估计传输图。为了控制去雾程度，引入了可学习参数，使去雾滤波器更适合检测任务。CNN-PP模块通过五个卷积块和两个全连接层，预测DIP模块的超参数，使图像处理自适应图像的亮度、颜色和雾霾程度。最终，处理后的图像被输入YOLOv10检测网络，通过多尺度特征图进行预测，提高目标检测的精度，特别是在恶劣天气条件下。