学习资源站

YOLOv11改进-特殊场景检测篇-最新的多尺度特征提取DICAM（全网独家首发，增强水下图像的质量）

一、本文介绍

本文给大家带来的最新改进机制是 多尺度特征 提取和通道注意力机制DICAM， 深度Inception和通道注意力模块（DICAM） 主要用于用于增强水下图像的质量、对比度和色偏。所提出的DICAM模型考虑了水下图像的比例退化和不均匀色偏，从而提高图像的质量。通过在两个公开的水下图像增强数据集上的广泛实验，验证了提出的模型在全参考和无参考图像质量评估指标方面。

欢迎大家订阅我的专栏一起学习YOLO，购买专栏读者联系读者入群获取进阶项目文件！

一、本文介绍

二、原理介绍

三、核心代码

四、添加教程

4.1 修改一

4.2 修改二

4.3 修改三

4.4 修改四

五、正式训练

5.1 yaml文件1

5.2 训练代码

5.3 训练过程截图

五、本文总结

二、原理介绍

官方代码地址： 官方论文地址点击此处即可跳转-阅读需要购买.

官方论文地址： 官方代码地址点击此处即可跳转

DICAM (Deep Inception and Channel-wise Attention Modules) 是一种基于深度学习的水下图像增强方法，旨在解决水下图像中常见的两大问题： 比例退化 和 不均匀光衰减 。该方法通过多层次的特征提取与自适应融合策略，显著提高水下图像的质量、对比度和色彩丰富度。下面是DICAM的核心机制和工作流程：

1. 多尺度通道特征提取（Inception模块） ：

  • 目标 ：提取图像中每个颜色通道的特征，并同时处理与距离相关的比例退化、色彩丢失和色彩丰富度问题。

  • 方法 ：使用 Inception模块 ，该模块在不同尺度上提取图像特征，从而捕捉到图像中不同区域的色彩和内容退化信息。通过这种方式，DICAM能够适应水下图像中由于距离引起的不同退化率。

2. 通道注意力模块（CAM） ：

  • 目标 ：对提取的特征进行加权，以突出不同通道和区域的关键特征，尤其是那些受比例退化和光衰减影响较大的部分。

  • 方法 ： CAM 根据图像各个通道和区域的退化比例，调整其重要性，使得颜色和内容信息能够得到有效恢复和增强。

3. 自适应融合与增强 ：

  • 目标 ：通过自适应的方式融合不同通道和尺度的特征，进一步优化图像的色彩分布和对比度。

  • 方法 ：将提取的多尺度特征图通过CAM加权融合，改善水下图像的色彩均衡性和亮度，最终生成一个色彩丰富、视觉效果自然的增强图像。

4. 色彩修正阶段 ：

  • 目标 ：在色彩修正阶段，通过特定的色彩校正策略进一步提高图像的色彩表现，确保增强后的图像在视觉上更加自然和真实。

  • 方法 ：利用CAM对色彩进行优化，确保图像在水下环境中的色彩偏差得到有效修复，增强图像的视觉效果。

结论：DICAM模型通过多尺度通道特征提取与通道注意力机制相结合，能够有效地提升水下图像的质量，特别是在颜色丰富度、对比度和色彩偏差修正方面。实验结果表明，DICAM在水下图像增强方面表现出了明显的优越性，尤其是在改善水下图像的颜色分布和细节恢复上。

以上内容均为论文提取，作者不对其真实性负责！

三、核心代码

核心代码的使用方式看章节四！ 

  1. import torch.nn as nn
  2. import torch
  5. __all__ = ['DICAM']
  7. class Inc(nn.Module):
  8.     def __init__(self, in_channels, filters):
  9.         super(Inc, self).__init__()
  10.         self.branch1 = nn.Sequential(
  11.             nn.Conv2d(in_channels=in_channels, out_channels=filters, kernel_size=(1, 1), stride=(1, 1), dilation=1,
  12.                       padding=(1 - 1) // 2),
  13.             nn.LeakyReLU(),
  14.             nn.Conv2d(in_channels=filters, out_channels=filters, kernel_size=(3, 3), stride=(1, 1), dilation=1,
  15.                       padding=(3 - 1) // 2),
  16.             nn.LeakyReLU(),
  17.         )
  18.         self.branch2 = nn.Sequential(
  19.             nn.Conv2d(in_channels=in_channels, out_channels=filters, kernel_size=(1, 1), stride=(1, 1), dilation=1,
  20.                       padding=(1 - 1) // 2),
  21.             nn.LeakyReLU(),
  22.             nn.Conv2d(in_channels=filters, out_channels=filters, kernel_size=(5, 5), stride=(1, 1), dilation=1,
  23.                       padding=(5 - 1) // 2),
  24.             nn.LeakyReLU(),
  25.         )
  26.         self.branch3 = nn.Sequential(
  27.             nn.MaxPool2d(kernel_size=(3, 3), stride=(1, 1), padding=1),
  28.             nn.Conv2d(in_channels=in_channels, out_channels=filters, kernel_size=(1, 1), stride=(1, 1), dilation=1),
  29.             nn.LeakyReLU(),
  31.         )
  32.         self.branch4 = nn.Sequential(
  33.             nn.Conv2d(in_channels=in_channels, out_channels=filters, kernel_size=(1, 1), stride=(1, 1), dilation=1),
  34.             nn.LeakyReLU(),
  35.         )
  37.     def forward(self, input):
  38.         o1 = self.branch1(input)
  39.         o2 = self.branch2(input)
  40.         o3 = self.branch3(input)
  41.         o4 = self.branch4(input)
  42.         return torch.cat([o1, o2, o3, o4], dim=1)
  45. class Flatten(nn.Module):
  46.     def forward(self, inp):
  47.         return inp.view(inp.size(0), -1)
  50. class CAM(nn.Module):
  51.     def __init__(self, in_channels, reduction_ratio):
  52.         super(CAM, self).__init__()
  53.         self.module = nn.Sequential(
  54.             nn.AdaptiveAvgPool2d((1, 1)),
  55.             Flatten(),
  56.             nn.Linear(in_channels, in_channels // reduction_ratio),
  57.             nn.Softsign(),
  58.             nn.Linear(in_channels // reduction_ratio, in_channels),
  59.             nn.Softsign()
  60.         )
  62.     def forward(self, input):
  63.         return input * self.module(input).unsqueeze(2).unsqueeze(3).expand_as(input)
  66. class DICAM(nn.Module):
  67.     def __init__(self, x): # 输入必须是三通道.
  68.         super(DICAM, self).__init__()
  69.         self.layer_1_r = Inc(in_channels=1, filters=64)
  70.         self.layer_1_g = Inc(in_channels=1, filters=64)
  71.         self.layer_1_b = Inc(in_channels=1, filters=64)
  73.         self.layer_2_r = CAM(256, 4)
  74.         self.layer_2_g = CAM(256, 4)
  75.         self.layer_2_b = CAM(256, 4)
  77.         self.layer_3 = Inc(768, 64)
  78.         self.layer_4 = CAM(256, 4)
  80.         self.layer_tail = nn.Sequential(
  81.             nn.Conv2d(in_channels=256, out_channels=24, kernel_size=(3, 3), stride=(1, 1), padding=(3 - 1) // 2),
  82.             nn.LeakyReLU(),
  83.             nn.Conv2d(in_channels=24, out_channels=3, kernel_size=(1, 1), stride=(1, 1), padding=(1 - 1) // 2),
  84.             nn.Sigmoid()
  86.         )
  88.     def forward(self, input):
  89.         input_r = torch.unsqueeze(input[:, 0, :, :], dim=1)
  90.         input_g = torch.unsqueeze(input[:, 1, :, :], dim=1)
  91.         input_b = torch.unsqueeze(input[:, 2, :, :], dim=1)
  93.         layer_1_r = self.layer_1_r(input_r)
  94.         layer_1_g = self.layer_1_g(input_g)
  95.         layer_1_b = self.layer_1_b(input_b)
  97.         layer_2_r = self.layer_2_r(layer_1_r)
  98.         layer_2_g = self.layer_2_g(layer_1_g)
  99.         layer_2_b = self.layer_2_b(layer_1_b)
  101.         layer_concat = torch.cat([layer_2_r, layer_2_g, layer_2_b], dim=1)
  103.         layer_3 = self.layer_3(layer_concat)
  104.         layer_4 = self.layer_4(layer_3)
  106.         output = self.layer_tail(layer_4)
  107.         return output
  110. if __name__ == '__main__':
  111.     from thop import profile, clever_format
  112.     inp1= torch.rand(1,64,256,256)
  113.     model = DICAM()
  114.     out = model(inp1)
  115.     print(out.shape)

四、添加教程

4.1 修改一

第一还是建立文件，我们找到如下ultralytics/nn文件夹下建立一个目录名字呢就是'Addmodules'文件夹( 用群内的文件的话已经有了无需新建) ！然后在其内部建立一个新的py文件将核心代码复制粘贴进去即可。

​

4.2 修改二

第二步我们在该目录下创建一个新的py文件名字为'__init__.py'( 用群内的文件的话已经有了无需新建) ，然后在其内部导入我们的检测头如下图所示。

​

4.3 修改三

第三步找到如下文件'ultralytics/nn/tasks.py'进行导入和注册我们的模块( 用群内的文件的话已经有了无需重新导入直接开始第四步即可) ！

​

4.4 修改四

找到文件到如下文件'ultralytics/nn/tasks.py'，在其中的parse_model方法中添加即可。

​

到此就修改完成了，大家可以复制下面的yaml文件运行,

如果不会添加可联系作者入群观看视频教程。

五、正式训练

5.1 yaml文件1

训练信息：YOLO11-DICAM summary: 429 layers, 2,654,165 parameters, 2,654,149 gradients, 51.1 GFLOPs

# 我发现最近这个图像增强的算法不配合loss确实难有效果，后面我会把yolo的loss分开计算不过需要一些设计的时间. 

  1. # Ultralytics YOLO 🚀, AGPL-3.0 license
  2. # YOLO11 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
  4. # Parameters
  5. nc: 80 # number of classes
  6. scales: # model compound scaling constants, i.e. 'model=yolo11n.yaml' will call yolo11.yaml with scale 'n'
  7.   # [depth, width, max_channels]
  8.   n: [0.50, 0.25, 1024] # summary: 319 layers, 2624080 parameters, 2624064 gradients, 6.6 GFLOPs
  9.   s: [0.50, 0.50, 1024] # summary: 319 layers, 9458752 parameters, 9458736 gradients, 21.7 GFLOPs
  10.   m: [0.50, 1.00, 512] # summary: 409 layers, 20114688 parameters, 20114672 gradients, 68.5 GFLOPs
  11.   l: [1.00, 1.00, 512] # summary: 631 layers, 25372160 parameters, 25372144 gradients, 87.6 GFLOPs
  12.   x: [1.00, 1.50, 512] # summary: 631 layers, 56966176 parameters, 56966160 gradients, 196.0 GFLOPs
  14. # YOLO11n backbone
  15. backbone:
  16.   # [from, repeats, module, args]
  17.   - [-1, 1, DICAM, []] # 0-P1/2
  18.   - [-1, 1, Conv, [64, 3, 2]] # 1-P1/2
  19.   - [-1, 1, Conv, [128, 3, 2]] # 2-P2/4
  20.   - [-1, 2, C3k2, [256, False, 0.25]]
  21.   - [-1, 1, Conv, [256, 3, 2]] # 4-P3/8
  22.   - [-1, 2, C3k2, [512, False, 0.25]]
  23.   - [-1, 1, Conv, [512, 3, 2]] # 6-P4/16
  24.   - [-1, 2, C3k2, [512, True]]
  25.   - [-1, 1, Conv, [1024, 3, 2]] # 8-P5/32
  26.   - [-1, 2, C3k2, [1024, True]]
  27.   - [-1, 1, SPPF, [1024, 5]] # 10
  28.   - [-1, 2, C2PSA, [1024]] # 11
  30. # YOLO11n head
  31. head:
  32.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  33.   - [[-1, 7], 1, Concat, [1]] # cat backbone P4
  34.   - [-1, 2, C3k2, [512, False]] # 14
  36.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  37.   - [[-1, 5], 1, Concat, [1]] # cat backbone P3
  38.   - [-1, 2, C3k2, [256, False]] # 17 (P3/8-small)
  40.   - [-1, 1, Conv, [256, 3, 2]]
  41.   - [[-1, 14], 1, Concat, [1]] # cat head P4
  42.   - [-1, 2, C3k2, [512, False]] # 20 (P4/16-medium)
  44.   - [-1, 1, Conv, [512, 3, 2]]
  45.   - [[-1, 11], 1, Concat, [1]] # cat head P5
  46.   - [-1, 2, C3k2, [1024, True]] # 23 (P5/32-large)
  48.   - [[17, 20, 23], 1, Detect, [nc]] # Detect(P3, P4, P5)

5.2 训练代码

大家可以创建一个py文件将我给的代码复制粘贴进去，配置好自己的文件路径即可运行。 

  1. import warnings
  2. warnings.filterwarnings('ignore')
  3. from ultralytics import YOLO
  5. if __name__ == '__main__':
  6.     model = YOLO('替换你的模型配置文件yaml文件地址')
  7.     # 如何切换模型版本, 上面的ymal文件可以改为 yolov11s.yaml就是使用的v11s,
  8.     # 类似某个改进的yaml文件名称为yolov11-XXX.yaml那么如果想使用其它版本就把上面的名称改为yolov11l-XXX.yaml即可（改的是上面YOLO中间的名字不是配置文件的）！
  9.     # model.load('yolo11n.pt') # 是否加载预训练权重,科研不建议大家加载否则很难提升精度
  10.     model.train(data=r"替换你的数据集配置文件地址",
  11.                 # 如果大家任务是其它的'ultralytics/cfg/default.yaml'找到这里修改task可以改成detect, segment, classify, pose
  12.                 cache=False,
  13.                 imgsz=640,
  14.                 epochs=150,
  15.                 single_cls=False,  # 是否是单类别检测
  16.                 batch=16,
  17.                 close_mosaic=0,
  18.                 workers=0,
  19.                 device='0',
  20.                 optimizer='SGD', # using SGD
  21.                 # resume='runs/train/exp21/weights/last.pt', # 如过想续训就设置last.pt的地址
  22.                 amp=False,  # 如果出现训练损失为Nan可以关闭amp
  23.                 project='runs/train',
  24.                 name='exp',
  25.                 )

5.3 训练过程截图

五、本文总结

到此本文的正式分享内容就结束了，在这里给大家推荐我的YOLOv11改进有效涨点专栏，本专栏目前为新开的平均质量分98分，后期我会根据各种最新的前沿顶会进行论文复现，也会对一些老的改进机制进行补充，如果大家觉得本文帮助到你了，订阅本专栏，关注后续更多的更新~