学习资源站

YOLOv11改进-特殊场景改进篇-一种基于注意力机制的图像去噪网络ADNet融合yolov11（全网独家首发改进）

一、本文介绍

本文给大家带来的改进机制是 Attention-guided Denoising Convolutional Neural Network (ADNet) 是一种专为 图像去噪 设计的 深度学习 模型，旨在解决合成噪声图像、真实噪声图像和盲去噪的挑战。它通过注意力机制提升 性能 ，聚焦于相关特征，抑制无关噪声。其主要由四个模块组 稀疏块（Sparse Block, SB）、 特征增强块（Feature Enhancement Block, FEB） 、 注意力块（Attention Block, AB） 、 重建块（Reconstruction Block, RB） 。 本文内容为包含代码加解释加添加教程以及运行记录！

欢迎大家订阅我的专栏一起学习YOLO！

二、ADNet网络介绍

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

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

ADNet 介绍

Attention-guided Denoising Convolutional Neural Network (ADNet) 是一种专为图像去噪设计的深度学习模型，旨在解决合成噪声图像、真实噪声图像和盲去噪的挑战。它通过注意力机制提升性能，聚焦于相关特征，抑制无关噪声。

ADNet 的架构

ADNet 的架构由四个主要模块组成：

1. 稀疏块（SB）

稀疏块旨在平衡性能和效率。它结合了膨胀卷积和普通卷积，有效去除噪声的同时保持计算效率。膨胀卷积有助于扩展感受野，不显著增加计算负载，这对于捕捉更多上下文信息至关重要。

2. 特征增强块（FEB）

特征增强块通过长路径整合全局和局部特征，增强模型的表达能力。通过捕捉局部细节和全局上下文，FEB 提高了模型从噪声输入中重建干净图像的能力。这种整合使得模型能够更好地理解和处理图像结构，从而提高去噪性能。

3. 注意力块（AB）

注意力块是 ADNet 处理复杂噪声图像的核心。它细致地提取复杂背景中隐藏的噪声信息，使其特别适用于真实噪声图像和盲去噪任务。注意力机制使得模型能够聚焦于图像的最相关部分，减少噪声的影响，提高去噪图像的整体质量。

4. 重建块（RB）

重建块旨在通过结合获取的噪声映射和给定的噪声图像来构建干净图像。它通过利用前几个模块增强的特征，生成去噪输出。此模块确保最终输出在去除噪声的同时保持原始图像的结构。

性能与评估

ADNet 在三项主要任务中进行了评估：合成噪声图像、真实噪声图像和盲去噪。综合实验结果表明，ADNet 在定量和定性评估中表现出色。

1. 合成噪声图像： ADNet 在去除人工添加噪声方面表现出色，通常优于传统方法和其他基于 CNN 的模型。
2. 真实噪声图像： 该模型在处理真实场景中的复杂噪声模式方面特别有效。
3. 盲去噪： ADNet 处理盲去噪的能力使其在各种噪声特性未知的应用中表现出色。

ADNet 的主要优势

增强的表达能力：通过 FEB 整合全局和局部特征，提升模型捕捉重要细节和上下文的能力。
注意力机制：通过使用注意力块，模型能够聚焦于相关特征，显著提高去噪性能，特别是在复杂场景中。
效率与性能平衡：稀疏块确保模型在保持去噪效果的同时，保持计算效率。
稳健的重建能力：重建块确保最终输出为高质量的干净图像，噪声伪影最小。

三、ADNet核心代码

ADNet的使用方式看章节四！ 

  1. import torch
  2. import torch.nn as nn
  5. class ADNet(nn.Module):
  6.     def __init__(self, channels, num_of_layers=16):
  7.         super(ADNet, self).__init__()
  8.         kernel_size = 3
  9.         padding = 1
  10.         features = num_of_layers
  11.         groups =1
  12.         layers = []
  13.         kernel_size1 = 1
  14.         self.conv1_1 = nn.Sequential(nn.Conv2d(in_channels=channels,out_channels=features,kernel_size=kernel_size,padding=padding,groups=groups,bias=False),nn.BatchNorm2d(features),nn.ReLU(inplace=True))
  15.         self.conv1_2 = nn.Sequential(nn.Conv2d(in_channels=features,out_channels=features,kernel_size=kernel_size,padding=2,groups=groups,bias=False,dilation=2),nn.BatchNorm2d(features),nn.ReLU(inplace=True))
  16.         self.conv1_3 = nn.Sequential(nn.Conv2d(in_channels=features,out_channels=features,kernel_size=kernel_size,padding=1,groups=groups,bias=False),nn.BatchNorm2d(features),nn.ReLU(inplace=True))
  17.         self.conv1_4 = nn.Sequential(nn.Conv2d(in_channels=features,out_channels=features,kernel_size=kernel_size,padding=1,groups=groups,bias=False),nn.BatchNorm2d(features),nn.ReLU(inplace=True))
  18.         self.conv1_5 = nn.Sequential(nn.Conv2d(in_channels=features,out_channels=features,kernel_size=kernel_size,padding=2,groups=groups,bias=False,dilation=2),nn.BatchNorm2d(features),nn.ReLU(inplace=True))
  19.         self.conv1_6 = nn.Sequential(nn.Conv2d(in_channels=features,out_channels=features,kernel_size=kernel_size,padding=1,groups=groups,bias=False),nn.BatchNorm2d(features),nn.ReLU(inplace=True))
  20.         self.conv1_7 = nn.Sequential(nn.Conv2d(in_channels=features,out_channels=features,kernel_size=kernel_size,padding=padding,groups=groups,bias=False),nn.BatchNorm2d(features),nn.ReLU(inplace=True))
  21.         self.conv1_8 = nn.Sequential(nn.Conv2d(in_channels=features,out_channels=features,kernel_size=kernel_size,padding=1,groups=groups,bias=False),nn.BatchNorm2d(features),nn.ReLU(inplace=True))
  22.         self.conv1_9 = nn.Sequential(nn.Conv2d(in_channels=features,out_channels=features,kernel_size=kernel_size,padding=2,groups=groups,bias=False,dilation=2),nn.BatchNorm2d(features),nn.ReLU(inplace=True))
  23.         self.conv1_10 = nn.Sequential(nn.Conv2d(in_channels=features,out_channels=features,kernel_size=kernel_size,padding=1,groups=groups,bias=False),nn.BatchNorm2d(features),nn.ReLU(inplace=True))
  24.         self.conv1_11 = nn.Sequential(nn.Conv2d(in_channels=features,out_channels=features,kernel_size=kernel_size,padding=1,groups=groups,bias=False),nn.BatchNorm2d(features),nn.ReLU(inplace=True))
  25.         self.conv1_12 = nn.Sequential(nn.Conv2d(in_channels=features,out_channels=features,kernel_size=kernel_size,padding=2,groups=groups,bias=False,dilation=2),nn.BatchNorm2d(features),nn.ReLU(inplace=True))
  26.         self.conv1_13 = nn.Sequential(nn.Conv2d(in_channels=features,out_channels=features,kernel_size=kernel_size,padding=padding,groups=groups,bias=False),nn.BatchNorm2d(features),nn.ReLU(inplace=True))
  27.         self.conv1_14 = nn.Sequential(nn.Conv2d(in_channels=features,out_channels=features,kernel_size=kernel_size,padding=padding,groups=groups,bias=False),nn.BatchNorm2d(features),nn.ReLU(inplace=True))
  28.         self.conv1_15 = nn.Sequential(nn.Conv2d(in_channels=features,out_channels=features,kernel_size=kernel_size,padding=1,groups=groups,bias=False),nn.BatchNorm2d(features),nn.ReLU(inplace=True))
  29.         self.conv1_16 = nn.Conv2d(in_channels=features,out_channels=3,kernel_size=kernel_size,padding=1,groups=groups,bias=False)
  30.         self.conv3 = nn.Conv2d(in_channels=6,out_channels=3,kernel_size=1,stride=1,padding=0,groups=1,bias=True)
  31.         self.ReLU = nn.ReLU(inplace=True)
  32.         self.Tanh= nn.Tanh()
  33.         self.sigmoid = nn.Sigmoid()
  34.         for m in self.modules():
  35.             if isinstance(m, nn.Conv2d):
  36.                 # n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
  37.                 m.weight.data.normal_(0, (2 / (9.0 * 64)) ** 0.5)
  38.             if isinstance(m, nn.BatchNorm2d):
  39.                 m.weight.data.normal_(0, (2 / (9.0 * 64)) ** 0.5)
  40.                 clip_b = 0.025
  41.                 w = m.weight.data.shape[0]
  42.                 for j in range(w):
  43.                     if m.weight.data[j] >= 0 and m.weight.data[j] < clip_b:
  44.                         m.weight.data[j] = clip_b
  45.                     elif m.weight.data[j] > -clip_b and m.weight.data[j] < 0:
  46.                         m.weight.data[j] = -clip_b
  47.                 m.running_var.fill_(0.01)
  49.     def _make_layers(self, block,features, kernel_size, num_of_layers, padding=1, groups=1, bias=False):
  50.         layers = []
  51.         for _ in range(num_of_layers):
  52.             layers.append(block(in_channels=features, out_channels=features, kernel_size=kernel_size, padding=padding, groups=groups, bias=bias))
  53.         return nn.Sequential(*layers)
  55.     def forward(self, x):
  56.         input = x
  57.         x1 = self.conv1_1(x)
  58.         x1 = self.conv1_2(x1)
  59.         x1 = self.conv1_3(x1)
  60.         x1 = self.conv1_4(x1)
  61.         x1 = self.conv1_5(x1)
  62.         x1 = self.conv1_6(x1)
  63.         x1 = self.conv1_7(x1)
  64.         x1t = self.conv1_8(x1)
  65.         x1 = self.conv1_9(x1t)
  66.         x1 = self.conv1_10(x1)
  67.         x1 = self.conv1_11(x1)
  68.         x1 = self.conv1_12(x1)
  69.         x1 = self.conv1_13(x1)
  70.         x1 = self.conv1_14(x1)
  71.         x1 = self.conv1_15(x1)
  72.         x1 = self.conv1_16(x1)
  73.         out = torch.cat([x,x1],1)
  74.         out= self.Tanh(out)
  75.         out = self.conv3(out)
  76.         out = out*x1
  77.         out2 = x - out
  78.         return out2
  81. if __name__ == "__main__":
  82.     # Generating Sample image
  83.     image_size = (1, 3, 640, 640)
  84.     image = torch.rand(*image_size)
  86.     # Model
  87.     model = ADNet(3)
  89.     out = model(image)
  90.     print(out.size())

四、添加方式

4.1 修改一

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

​

​

4.2 修改二

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

4.3 修改三

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

从今天开始以后的教程就都统一成这个样子了，因为我默认大家用了我群内的文件来进行修改！！

​

4.4 修改四

按照我的添加在parse_model里添加即可。

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

五、ADNet的yaml文件和运行记录

5.1 ADNet的yaml文件

此版本训练信息：YOLO11-ADNet summary: 385 layers, 2,624,436 parameters, 2,624,420 gradients, 34.4 GFLOPs 

  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, ADNet, []] # 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('ultralytics/cfg/models/v8/yolov8-C2f-FasterBlock.yaml')
  7.     # model.load('yolov8n.pt') # loading pretrain weights
  8.     model.train(data=r'替换数据集yaml文件地址',
  9.                 # 如果大家任务是其它的'ultralytics/cfg/default.yaml'找到这里修改task可以改成detect, segment, classify, pose
  10.                 cache=False,
  11.                 imgsz=640,
  12.                 epochs=150,
  13.                 single_cls=False,  # 是否是单类别检测
  14.                 batch=4,
  15.                 close_mosaic=10,
  16.                 workers=0,
  17.                 device='0',
  18.                 optimizer='SGD', # using SGD
  19.                 # resume='', # 如过想续训就设置last.pt的地址
  20.                 amp=False,  # 如果出现训练损失为Nan可以关闭amp
  21.                 project='runs/train',
  22.                 name='exp',
  23.                 )

5.3 ADNet的训练过程截图

五、本文总结

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