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

微信交流群：https://732903.hlcode.cn/?id=NK1fWUR

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

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

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

专栏地址：YOLOv8改进——更新各种有效涨点方法——点击即可跳转

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())

2.2 更改init.py文件

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

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

2.3 添加yaml文件

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

# Ultralytics YOLO 🚀, AGPL-3.0 license
# YOLOv8 object detection model with P3-P5 outputs. 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]
  n: [0.33, 0.25, 1024]  # YOLOv8n summary: 225 layers,  3157200 parameters,  3157184 gradients,   8.9 GFLOPs
  s: [0.33, 0.50, 1024]  # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients,  28.8 GFLOPs
  m: [0.67, 0.75, 768]   # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients,  79.3 GFLOPs
  l: [1.00, 1.00, 512]   # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
  x: [1.00, 1.25, 512]   # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs

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

# YOLOv8.0n head
head:
  - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
  - [[-1, 7], 1, Concat, [1]]  # cat backbone P4
  - [-1, 3, C2f, [512]]  # 13

  - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
  - [[-1, 5], 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, C2f, [512]]  # 19 (P4/16-medium)

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

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

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

# YOLOv8n
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.25  # layer channel multiple
max_channels: 1024 # max_channels
 
# YOLOv8s
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.50  # layer channel multiple
max_channels: 1024 # max_channels
 
# YOLOv8l 
depth_multiple: 1.0  # model depth multiple
width_multiple: 1.0  # layer channel multiple
max_channels: 512 # max_channels
 
# YOLOv8m
depth_multiple: 0.67  # model depth multiple
width_multiple: 0.75  # layer channel multiple
max_channels: 768 # max_channels
 
# YOLOv8x
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的参数路径设置为yolov8_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/v8/yolov8_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       464  ultralytics.nn.modules.conv.Conv             [3, 16, 3, 2]                 
  2                  -1  1      4672  ultralytics.nn.modules.conv.Conv             [16, 32, 3, 2]                
  3                  -1  1      7360  ultralytics.nn.modules.block.C2f             [32, 32, 1, True]             
  4                  -1  1     18560  ultralytics.nn.modules.conv.Conv             [32, 64, 3, 2]                
  5                  -1  2     49664  ultralytics.nn.modules.block.C2f             [64, 64, 2, True]             
  6                  -1  1     73984  ultralytics.nn.modules.conv.Conv             [64, 128, 3, 2]               
  7                  -1  2    197632  ultralytics.nn.modules.block.C2f             [128, 128, 2, True]           
  8                  -1  1    295424  ultralytics.nn.modules.conv.Conv             [128, 256, 3, 2]              
  9                  -1  1    460288  ultralytics.nn.modules.block.C2f             [256, 256, 1, True]           
 10                  -1  1    164608  ultralytics.nn.modules.block.SPPF            [256, 256, 5]                 
 11                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 12             [-1, 7]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 13                  -1  1    148224  ultralytics.nn.modules.block.C2f             [384, 128, 1]                 
 14                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 15             [-1, 5]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 16                  -1  1     37248  ultralytics.nn.modules.block.C2f             [192, 64, 1]                  
 17                  -1  1     36992  ultralytics.nn.modules.conv.Conv             [64, 64, 3, 2]                
 18            [-1, 13]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 19                  -1  1    123648  ultralytics.nn.modules.block.C2f             [192, 128, 1]                 
 20                  -1  1    147712  ultralytics.nn.modules.conv.Conv             [128, 128, 3, 2]              
 21            [-1, 10]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 22                  -1  1    493056  ultralytics.nn.modules.block.C2f             [384, 256, 1]                 
 23        [16, 19, 22]  1    751507  ultralytics.nn.modules.head.Detect           [1, [64, 128, 256]]           
YOLOv8_unfog summary: 232 layers, 3,012,804 parameters, 3,012,788 gradients, 9.6 GFLOPs

3. 完整代码分享

https://pan.baidu.com/s/1rllteHxV2b8myqeuGYzOkg?pwd=yrp2

提取码: yrp2

4. GFLOPs

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

未改进的YOLOv8n GFLOPs

改进后的GFLOPs

5. 进阶

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

6. 总结

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

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

1. 原理

2. 将unfog_net添加到YOLOv8中

2.1 unfog_net的代码实现

2.2 更改init.py文件

2.3 添加yaml文件

2.4执行程序

3. 完整代码分享

4. GFLOPs

5. 进阶

6. 总结

网站公告

今日签到

热门文章

最新发布