学习资源站

YOLOv11改进-特殊场景改进篇-单阶段盲真实图像去噪网络RIDNet辅助YOLOv11图像去噪（全网独家首发）

一、本文介绍

本文给大家带来的改进机制是 单阶段 盲真实 图像去噪 网络RIDNet，RIDNet（Real Image Denoising with Feature Attention）是一个用于真实图像去噪的卷积神经网络（ CNN ），旨在解决现有去噪方法在处理真实噪声图像时 性能 受限的问题。通过单阶段结构和特征注意机制，RIDNet在多种数据集上展示了其优越性，下面的图片为其效果图片包括和其它图像图像网络的对比图。

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

二、RIDNet 网络的原理和机制

​

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

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

RIDNet（Real Image Denoising with Feature Attention ）是一个用于真实图像去噪的 卷积神经网络 （CNN），旨在解决现有去噪方法在处理真实噪声图像时性能受限的问题。通过单阶段结构和特征注意机制，RIDNet在多种数据集上展示了其优越性。 RIDNet由三个主要模块组成：

1. 特征提取模块（Feature Extraction Module）： 该模块包含一个卷积层，旨在从输入的噪声图像中提取初始特征。

2. 特征学习模块（Feature Learning Module）： 核心部分是增强注意模块（Enhanced Attention Module，EAM），使用残差在残差结构（Residual on Residual）和特征注意机制来增强特征学习能力。 EAM包括两个主要部分：

（1）特征提取子模块：通过两个膨胀卷积层和一个合并卷积层提取和学习特征。

（2）特征注意子模块：使用全局平均池化和自门控机制生成特征注意力，调整每个通道的特征权重，以突出重要特征。

3. 重建模块（Reconstruction Module）： 包含一个卷积层，将学习到的特征重建为去噪后的图像。

结论: RIDNet在多个合成和真实噪声数据集上进行了广泛的实验，展示了其在定量指标（如PSNR）和视觉质量上的优越性。与现有最先进的算法相比，RIDNet在处理合成噪声和真实噪声图像时均表现出色。RIDNet通过引入特征注意机制和残差在残差结构，实现了对真实图像去噪的有效处理。其单阶段结构、跳跃连接和特征注意机制确保了高效的特征学习和信息传递，使其在多个数据集上均取得了优异的性能。

三、核心代码

这个代码基础版本原先有1000+GFLOPs，我将其Block层数优化了一些，并将通道数减少了一部分将参数量降低到了20+。 

  1. import math
  2. import torch
  3. import torch.nn as nn
  4. import torch.nn.functional as F
  7. def default_conv(in_channels, out_channels, kernel_size, bias=True):
  8.     return nn.Conv2d(
  9.         in_channels, out_channels, kernel_size,
  10.         padding=(kernel_size//2), bias=bias)
  13. class MeanShift(nn.Conv2d):
  14.     def __init__(self, rgb_range, rgb_mean, rgb_std, sign=-1):
  15.         super(MeanShift, self).__init__(3, 3, kernel_size=1)
  16.         std = torch.Tensor(rgb_std)
  17.         self.weight.data = torch.eye(3).view(3, 3, 1, 1)
  18.         self.weight.data.div_(std.view(3, 1, 1, 1))
  19.         self.bias.data = sign * rgb_range * torch.Tensor(rgb_mean)
  20.         self.bias.data.div_(std)
  21.         self.requires_grad = False
  24. def init_weights(modules):
  25.     pass
  29. class Merge_Run(nn.Module):
  30.     def __init__(self,
  31.                  in_channels, out_channels,
  32.                  ksize=3, stride=1, pad=1, dilation=1):
  33.         super(Merge_Run, self).__init__()
  35.         self.body1 = nn.Sequential(
  36.             nn.Conv2d(in_channels, out_channels, ksize, stride, pad),
  37.             nn.ReLU(inplace=True)
  38.         )
  39.         self.body2 = nn.Sequential(
  40.             nn.Conv2d(in_channels, out_channels, ksize, stride, 2, 2),
  41.             nn.ReLU(inplace=True)
  42.         )
  44.         self.body3 = nn.Sequential(
  45.             nn.Conv2d(in_channels * 2, out_channels, ksize, stride, pad),
  46.             nn.ReLU(inplace=True)
  47.         )
  48.         init_weights(self.modules)
  50.     def forward(self, x):
  51.         out1 = self.body1(x)
  52.         out2 = self.body2(x)
  53.         c = torch.cat([out1, out2], dim=1)
  54.         c_out = self.body3(c)
  55.         out = c_out + x
  56.         return out
  59. class Merge_Run_dual(nn.Module):
  60.     def __init__(self,
  61.                  in_channels, out_channels,
  62.                  ksize=3, stride=1, pad=1, dilation=1):
  63.         super(Merge_Run_dual, self).__init__()
  65.         self.body1 = nn.Sequential(
  66.             nn.Conv2d(in_channels, out_channels, ksize, stride, pad),
  67.             nn.ReLU(inplace=True),
  68.             nn.Conv2d(in_channels, out_channels, ksize, stride, 2, 2),
  69.             nn.ReLU(inplace=True)
  70.         )
  71.         self.body2 = nn.Sequential(
  72.             nn.Conv2d(in_channels, out_channels, ksize, stride, 3, 3),
  73.             nn.ReLU(inplace=True),
  74.             nn.Conv2d(in_channels, out_channels, ksize, stride, 4, 4),
  75.             nn.ReLU(inplace=True)
  76.         )
  78.         self.body3 = nn.Sequential(
  79.             nn.Conv2d(in_channels * 2, out_channels, ksize, stride, pad),
  80.             nn.ReLU(inplace=True)
  81.         )
  82.         init_weights(self.modules)
  84.     def forward(self, x):
  85.         out1 = self.body1(x)
  86.         out2 = self.body2(x)
  87.         c = torch.cat([out1, out2], dim=1)
  88.         c_out = self.body3(c)
  89.         out = c_out + x
  90.         return out
  93. class BasicBlock(nn.Module):
  94.     def __init__(self,
  95.                  in_channels, out_channels,
  96.                  ksize=3, stride=1, pad=1):
  97.         super(BasicBlock, self).__init__()
  99.         self.body = nn.Sequential(
  100.             nn.Conv2d(in_channels, out_channels, ksize, stride, pad),
  101.             nn.ReLU(inplace=True)
  102.         )
  104.         init_weights(self.modules)
  106.     def forward(self, x):
  107.         out = self.body(x)
  108.         return out
  111. class BasicBlockSig(nn.Module):
  112.     def __init__(self,
  113.                  in_channels, out_channels,
  114.                  ksize=3, stride=1, pad=1):
  115.         super(BasicBlockSig, self).__init__()
  117.         self.body = nn.Sequential(
  118.             nn.Conv2d(in_channels, out_channels, ksize, stride, pad),
  119.             nn.Sigmoid()
  120.         )
  122.         init_weights(self.modules)
  124.     def forward(self, x):
  125.         out = self.body(x)
  126.         return out
  129. class ResidualBlock(nn.Module):
  130.     def __init__(self,
  131.                  in_channels, out_channels):
  132.         super(ResidualBlock, self).__init__()
  134.         self.body = nn.Sequential(
  135.             nn.Conv2d(in_channels, out_channels, 3, 1, 1),
  136.             nn.ReLU(inplace=True),
  137.             nn.Conv2d(out_channels, out_channels, 3, 1, 1),
  138.         )
  140.         init_weights(self.modules)
  142.     def forward(self, x):
  143.         out = self.body(x)
  144.         out = F.relu(out + x)
  145.         return out
  148. class EResidualBlock(nn.Module):
  149.     def __init__(self,
  150.                  in_channels, out_channels,
  151.                  group=1):
  152.         super(EResidualBlock, self).__init__()
  154.         self.body = nn.Sequential(
  155.             nn.Conv2d(in_channels, out_channels, 3, 1, 1, groups=group),
  156.             nn.ReLU(inplace=True),
  157.             nn.Conv2d(out_channels, out_channels, 3, 1, 1, groups=group),
  158.             nn.ReLU(inplace=True),
  159.             nn.Conv2d(out_channels, out_channels, 1, 1, 0),
  160.         )
  162.         init_weights(self.modules)
  164.     def forward(self, x):
  165.         out = self.body(x)
  166.         out = F.relu(out + x)
  167.         return out
  173. class CALayer(nn.Module):
  174.     def __init__(self, channel, reduction=16):
  175.         super(CALayer, self).__init__()
  177.         self.avg_pool = nn.AdaptiveAvgPool2d(1)
  179.         self.c1 = BasicBlock(channel, channel // reduction, 1, 1, 0)
  180.         self.c2 = BasicBlockSig(channel // reduction, channel, 1, 1, 0)
  182.     def forward(self, x):
  183.         y = self.avg_pool(x)
  184.         y1 = self.c1(y)
  185.         y2 = self.c2(y1)
  186.         return x * y2
  189. class Block(nn.Module):
  190.     def __init__(self, in_channels, out_channels, group=1):
  191.         super(Block, self).__init__()
  193.         self.r1 = Merge_Run_dual(in_channels, out_channels)
  194.         self.r2 = ResidualBlock(in_channels, out_channels)
  195.         self.r3 = EResidualBlock(in_channels, out_channels)
  196.         # self.g = ops.BasicBlock(in_channels, out_channels, 1, 1, 0)
  197.         self.ca = CALayer(in_channels)
  199.     def forward(self, x):
  200.         r1 = self.r1(x)
  201.         r2 = self.r2(r1)
  202.         r3 = self.r3(r2)
  203.         # g = self.g(r3)
  204.         out = self.ca(r3)
  206.         return out
  209. class RIDNET(nn.Module):
  210.     def __init__(self, args):
  211.         super(RIDNET, self).__init__()
  213.         n_feats = 16
  214.         kernel_size = 3
  215.         rgb_range = 255
  216.         mean = (0.4488, 0.4371, 0.4040)
  217.         std = (1.0, 1.0, 1.0)
  219.         self.sub_mean = MeanShift(rgb_range, mean, std)
  220.         self.add_mean = MeanShift(rgb_range, mean, std, 1)
  222.         self.head = BasicBlock(3, n_feats, kernel_size, 1, 1)
  224.         self.b1 = Block(n_feats, n_feats)
  225.         self.b2 = Block(n_feats, n_feats)
  226.         self.b3 = Block(n_feats, n_feats)
  227.         self.b4 = Block(n_feats, n_feats)
  229.         self.tail = nn.Conv2d(n_feats, 3, kernel_size, 1, 1, 1)
  231.     def forward(self, x):
  232.         s = self.sub_mean(x)
  233.         h = self.head(s)
  235.         # b1 = self.b1(h)
  236.         # b2 = self.b2(b1)
  237.         # b3 = self.b3(b2)
  238.         b_out = self.b4(h)
  240.         res = self.tail(b_out)
  241.         out = self.add_mean(res)
  242.         f_out = out + x
  244.         return f_out
  248. if __name__ == "__main__":
  250.     # Generating Sample image
  251.     image_size = (1, 3, 640, 640)
  252.     image = torch.rand(*image_size)
  254.     # Model
  255.     model = RIDNET(3)
  257.     out = model(image)
  258.     print(out.size())

四、手把手教你添加RIDNet

4.1 修改一

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

​

4.2 修改二

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

​

4.3 修改三

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

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

​​

4.4 修改四

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

​

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

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

5.1 RIDNet 的yaml文件

此版本训练信息：YOLO11-RIDNet summary: 475 layers, 2,685,742 parameters, 2,685,726 gradients, 26.2 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, RIDNET, []] # 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 RIDNet 的训练过程截图

​

五、本文总结

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

​