学习资源站

YOLOv11改进-独家创新篇-结合iRMB和EMA形成全新的iEMA机制（全网独家创新，教你如何二次创新）

一、本文介绍

本文给大家带来的最新改进机制是 二次创新 的机制，二次创新是我们发表论文中关键的一环，为什么这么说，从去年的三月份开始对于图像领域的论文发表其实是变难的了，在那之前大家可能搭搭积木的情况下就可以简单的发表一篇论文，但是从去年开始单纯的搭积木其实发表论文变得越来越难，所以这个时候就需要二次创新，以此来迷惑审稿人，彰显大家的工作量，所以二次创新是非常重要的一点，因为二次创新出来的模块其实基本上就可以算作一个全新的模块了， 本文内容经过YOLOv8专栏很多读者反应效果很好， 同时本文含如何二次创新的思路。

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

二、如何进行二次创新

这里给大家介绍以下如何进行二次创新。

我的视频中说过二次创新主要分为两种，本文介绍的是另外一种。

组合为： 一种全新的结构 + 其他模块(可以是 卷积 ，也可以是注意力机制，也可以是重参数化模块)

iRMB主要提出了一种倒置残差的结构，然后其中涉及到一种 Transformer 注意力机制 ，因为创新注意力机制是十分困难的事情大家都是炼丹师所以这肯定不现实，但是借鉴其中的结构还是一个比较容易的事情，所以我们借鉴了iRMB其中倒置残差结构结合一种即插即用的EMA注意力机制 (也可以替换其它的注意力机制) ，形成一个新的模块iEMA也是一种创新对于写论文来说，总比你单用iRMB或者EMA要好对吧？最起码工作量的方面我们是堆叠上去了。

三、iEMA的核心代码

使用方式看章节四！ 

  1. import math
  2. import torch
  3. import torch.nn as nn
  4. from functools import partial
  5. from einops import rearrange
  6. from timm.models._efficientnet_blocks import SqueezeExcite
  7. from timm.models.layers import DropPath
  10. __all__ = ['iEMA', 'C2PSAiEMA']
  13. class EMA(nn.Module):
  14.     def __init__(self, channels, factor=32):
  15.         super(EMA, self).__init__()
  16.         self.groups = factor
  17.         assert channels // self.groups > 0
  18.         self.softmax = nn.Softmax(-1)
  19.         self.agp = nn.AdaptiveAvgPool2d((1, 1))
  20.         self.pool_h = nn.AdaptiveAvgPool2d((None, 1))
  21.         self.pool_w = nn.AdaptiveAvgPool2d((1, None))
  22.         self.gn = nn.GroupNorm(channels // self.groups, channels // self.groups)
  23.         self.conv1x1 = nn.Conv2d(channels // self.groups, channels // self.groups, kernel_size=1, stride=1, padding=0)
  24.         self.conv3x3 = nn.Conv2d(channels // self.groups, channels // self.groups, kernel_size=3, stride=1, padding=1)
  26.     def forward(self, x):
  27.         b, c, h, w = x.size()
  28.         group_x = x.reshape(b * self.groups, -1, h, w)  # b*g,c//g,h,w
  29.         x_h = self.pool_h(group_x)
  30.         x_w = self.pool_w(group_x).permute(0, 1, 3, 2)
  31.         hw = self.conv1x1(torch.cat([x_h, x_w], dim=2))
  32.         x_h, x_w = torch.split(hw, [h, w], dim=2)
  33.         x1 = self.gn(group_x * x_h.sigmoid() * x_w.permute(0, 1, 3, 2).sigmoid())
  34.         x2 = self.conv3x3(group_x)
  35.         x11 = self.softmax(self.agp(x1).reshape(b * self.groups, -1, 1).permute(0, 2, 1))
  36.         x12 = x2.reshape(b * self.groups, c // self.groups, -1)  # b*g, c//g, hw
  37.         x21 = self.softmax(self.agp(x2).reshape(b * self.groups, -1, 1).permute(0, 2, 1))
  38.         x22 = x1.reshape(b * self.groups, c // self.groups, -1)  # b*g, c//g, hw
  39.         weights = (torch.matmul(x11, x12) + torch.matmul(x21, x22)).reshape(b * self.groups, 1, h, w)
  40.         return (group_x * weights.sigmoid()).reshape(b, c, h, w)
  43. inplace = True
  45. class LayerNorm2d(nn.Module):
  47.     def __init__(self, normalized_shape, eps=1e-6, elementwise_affine=True):
  48.         super().__init__()
  49.         self.norm = nn.LayerNorm(normalized_shape, eps, elementwise_affine)
  51.     def forward(self, x):
  52.         x = rearrange(x, 'b c h w -> b h w c').contiguous()
  53.         x = self.norm(x)
  54.         x = rearrange(x, 'b h w c -> b c h w').contiguous()
  55.         return x
  58. def get_norm(norm_layer='in_1d'):
  59.     eps = 1e-6
  60.     norm_dict = {
  61.         'none': nn.Identity,
  62.         'in_1d': partial(nn.InstanceNorm1d, eps=eps),
  63.         'in_2d': partial(nn.InstanceNorm2d, eps=eps),
  64.         'in_3d': partial(nn.InstanceNorm3d, eps=eps),
  65.         'bn_1d': partial(nn.BatchNorm1d, eps=eps),
  66.         'bn_2d': partial(nn.BatchNorm2d, eps=eps),
  67.         # 'bn_2d': partial(nn.SyncBatchNorm, eps=eps),
  68.         'bn_3d': partial(nn.BatchNorm3d, eps=eps),
  69.         'gn': partial(nn.GroupNorm, eps=eps),
  70.         'ln_1d': partial(nn.LayerNorm, eps=eps),
  71.         'ln_2d': partial(LayerNorm2d, eps=eps),
  72.     }
  73.     return norm_dict[norm_layer]
  76. def get_act(act_layer='relu'):
  77.     act_dict = {
  78.         'none': nn.Identity,
  79.         'relu': nn.ReLU,
  80.         'relu6': nn.ReLU6,
  81.         'silu': nn.SiLU
  82.     }
  83.     return act_dict[act_layer]
  86. class ConvNormAct(nn.Module):
  88.     def __init__(self, dim_in, dim_out, kernel_size, stride=1, dilation=1, groups=1, bias=False,
  89.                  skip=False, norm_layer='bn_2d', act_layer='relu', inplace=True, drop_path_rate=0.):
  90.         super(ConvNormAct, self).__init__()
  91.         self.has_skip = skip and dim_in == dim_out
  92.         padding = math.ceil((kernel_size - stride) / 2)
  93.         self.conv = nn.Conv2d(dim_in, dim_out, kernel_size, stride, padding, dilation, groups, bias)
  94.         self.norm = get_norm(norm_layer)(dim_out)
  95.         self.act = get_act(act_layer)(inplace=inplace)
  96.         self.drop_path = DropPath(drop_path_rate) if drop_path_rate else nn.Identity()
  98.     def forward(self, x):
  99.         shortcut = x
  100.         x = self.conv(x)
  101.         x = self.norm(x)
  102.         x = self.act(x)
  103.         if self.has_skip:
  104.             x = self.drop_path(x) + shortcut
  105.         return x
  109. class iEMA(nn.Module):
  111.     def __init__(self, dim_in, norm_in=True, has_skip=True, exp_ratio=1.0, norm_layer='bn_2d',
  112.                  act_layer='relu', v_proj=True, dw_ks=3, stride=1, dilation=1, se_ratio=0.0,
  113.                  attn_s=True, qkv_bias=False,  drop=0., drop_path=0.):
  114.         super().__init__()
  115.         dim_out = dim_in
  116.         self.norm = get_norm(norm_layer)(dim_in) if norm_in else nn.Identity()
  117.         dim_mid = int(dim_in * exp_ratio)
  118.         self.has_skip = (dim_in == dim_out and stride == 1) and has_skip
  119.         self.attn_s = attn_s
  120.         if self.attn_s:
  121.             self.ema = EMA(dim_in)
  122.         else:
  123.             if v_proj:
  124.                 self.v = ConvNormAct(dim_in, dim_mid, kernel_size=1, bias=qkv_bias, norm_layer='none',
  125.                                      act_layer=act_layer, inplace=inplace)
  126.             else:
  127.                 self.v = nn.Identity()
  128.         self.conv_local = ConvNormAct(dim_mid, dim_mid, kernel_size=dw_ks, stride=stride, dilation=dilation,
  129.                                       groups=dim_mid, norm_layer='bn_2d', act_layer='silu', inplace=inplace)
  130.         self.se = SqueezeExcite(dim_mid, rd_ratio=se_ratio, act_layer=get_act(act_layer)) if se_ratio > 0.0 else nn.Identity()
  132.         self.proj_drop = nn.Dropout(drop)
  133.         self.proj = ConvNormAct(dim_mid, dim_out, kernel_size=1, norm_layer='none', act_layer='none', inplace=inplace)
  134.         self.drop_path = DropPath(drop_path) if drop_path else nn.Identity()
  136.     def forward(self, x):
  137.         shortcut = x
  138.         x = self.norm(x)
  139.         if self.attn_s:
  140.             x = self.ema(x)
  141.         else:
  142.             x = self.v(x)
  144.         x = x + self.se(self.conv_local(x)) if self.has_skip else self.se(self.conv_local(x))
  146.         x = self.proj_drop(x)
  147.         x = self.proj(x)
  149.         x = (shortcut + self.drop_path(x)) if self.has_skip else x
  150.         return x
  153. def autopad(k, p=None, d=1):  # kernel, padding, dilation
  154.     """Pad to 'same' shape outputs."""
  155.     if d > 1:
  156.         k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k]  # actual kernel-size
  157.     if p is None:
  158.         p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-pad
  159.     return p
  162. class Conv(nn.Module):
  163.     """Standard convolution with args(ch_in, ch_out, kernel, stride, padding, groups, dilation, activation)."""
  165.     default_act = nn.SiLU()  # default activation
  167.     def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
  168.         """Initialize Conv layer with given arguments including activation."""
  169.         super().__init__()
  170.         self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p, d), groups=g, dilation=d, bias=False)
  171.         self.bn = nn.BatchNorm2d(c2)
  172.         self.act = self.default_act if act is True else act if isinstance(act, nn.Module) else nn.Identity()
  174.     def forward(self, x):
  175.         """Apply convolution, batch normalization and activation to input tensor."""
  176.         return self.act(self.bn(self.conv(x)))
  178.     def forward_fuse(self, x):
  179.         """Perform transposed convolution of 2D data."""
  180.         return self.act(self.conv(x))
  182. class PSABlock(nn.Module):
  183.     """
  184.     PSABlock class implementing a Position-Sensitive Attention block for neural networks.
  186.     This class encapsulates the functionality for applying multi-head attention and feed-forward neural network layers
  187.     with optional shortcut connections.
  189.     Attributes:
  190.         attn (Attention): Multi-head attention module.
  191.         ffn (nn.Sequential): Feed-forward neural network module.
  192.         add (bool): Flag indicating whether to add shortcut connections.
  194.     Methods:
  195.         forward: Performs a forward pass through the PSABlock, applying attention and feed-forward layers.
  197.     Examples:
  198.         Create a PSABlock and perform a forward pass
  199.     """
  201.     def __init__(self, c, attn_ratio=0.5, num_heads=4, shortcut=True) -> None:
  202.         """Initializes the PSABlock with attention and feed-forward layers for enhanced feature extraction."""
  203.         super().__init__()
  205.         self.attn = iEMA(c)
  206.         self.ffn = nn.Sequential(Conv(c, c * 2, 1), Conv(c * 2, c, 1, act=False))
  207.         self.add = shortcut
  209.     def forward(self, x):
  210.         """Executes a forward pass through PSABlock, applying attention and feed-forward layers to the input tensor."""
  211.         x = x + self.attn(x) if self.add else self.attn(x)
  212.         x = x + self.ffn(x) if self.add else self.ffn(x)
  213.         return x
  216. class C2PSAiEMA(nn.Module):
  217.     """
  218.     C2PSA module with attention mechanism for enhanced feature extraction and processing.
  220.     This module implements a convolutional block with attention mechanisms to enhance feature extraction and processing
  221.     capabilities. It includes a series of PSABlock modules for self-attention and feed-forward operations.
  223.     Attributes:
  224.         c (int): Number of hidden channels.
  225.         cv1 (Conv): 1x1 convolution layer to reduce the number of input channels to 2*c.
  226.         cv2 (Conv): 1x1 convolution layer to reduce the number of output channels to c.
  227.         m (nn.Sequential): Sequential container of PSABlock modules for attention and feed-forward operations.
  229.     Methods:
  230.         forward: Performs a forward pass through the C2PSA module, applying attention and feed-forward operations.
  232.     Notes:
  233.         This module essentially is the same as PSA module, but refactored to allow stacking more PSABlock modules.
  235.     Examples:
  237.     """
  239.     def __init__(self, c1, c2, n=1, e=0.5):
  240.         """Initializes the C2PSA module with specified input/output channels, number of layers, and expansion ratio."""
  241.         super().__init__()
  242.         assert c1 == c2
  243.         self.c = int(c1 * e)
  244.         self.cv1 = Conv(c1, 2 * self.c, 1, 1)
  245.         self.cv2 = Conv(2 * self.c, c1, 1)
  247.         self.m = nn.Sequential(*(PSABlock(self.c, attn_ratio=0.5, num_heads=self.c // 64) for _ in range(n)))
  249.     def forward(self, x):
  250.         """Processes the input tensor 'x' through a series of PSA blocks and returns the transformed tensor."""
  251.         a, b = self.cv1(x).split((self.c, self.c), dim=1)
  252.         b = self.m(b)
  253.         return self.cv2(torch.cat((a, b), 1))
  256. if __name__ == "__main__":
  259.     # Generating Sample image
  260.     image_size = (1, 64, 640, 640)
  261.     image = torch.rand(*image_size)
  263.     # Model
  264.     model = C2PSAiEMA(64, 64)
  266.     out = model(image)
  267.     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文件运行。

五、正式训练

5.1 yaml文件1

训练信息：YOLO11-C2PSA-iEMA summary: 330 layers, 2,556,931 parameters, 2,556,915 gradients, 6.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, Conv, [64, 3, 2]] # 0-P1/2
  18.   - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
  19.   - [-1, 2, C3k2, [256, False, 0.25]]
  20.   - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  21.   - [-1, 2, C3k2, [512, False, 0.25]]
  22.   - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  23.   - [-1, 2, C3k2, [512, True]]
  24.   - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  25.   - [-1, 2, C3k2, [1024, True]]
  26.   - [-1, 1, SPPF, [1024, 5]] # 9
  27.   - [-1, 2, C2PSAiEMA, [1024]] # 10
  29. # YOLO11n head
  30. head:
  31.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  32.   - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  33.   - [-1, 2, C3k2, [512, False]] # 13
  35.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  36.   - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  37.   - [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)
  39.   - [-1, 1, Conv, [256, 3, 2]]
  40.   - [[-1, 13], 1, Concat, [1]] # cat head P4
  41.   - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)
  43.   - [-1, 1, Conv, [512, 3, 2]]
  44.   - [[-1, 10], 1, Concat, [1]] # cat head P5
  45.   - [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)
  47.   - [[16, 19, 22], 1, Detect, [nc]] # Detect(P3, P4, P5)

5.2 yaml文件2

训练信息：YOLO11-iEMA summary: 388 layers, 2,682,771 parameters, 2,682,755 gradients, 6.7 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, Conv, [64, 3, 2]] # 0-P1/2
  18.   - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
  19.   - [-1, 2, C3k2, [256, False, 0.25]]
  20.   - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  21.   - [-1, 2, C3k2, [512, False, 0.25]]
  22.   - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  23.   - [-1, 2, C3k2, [512, True]]
  24.   - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  25.   - [-1, 2, C3k2, [1024, True]]
  26.   - [-1, 1, SPPF, [1024, 5]] # 9
  27.   - [-1, 2, C2PSA, [1024]] # 10
  29. # YOLO11n head
  30. head:
  31.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  32.   - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  33.   - [-1, 2, C3k2, [512, False]] # 13
  35.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  36.   - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  37.   - [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)
  38.   - [-1, 1, iEMA, []] # 17 (P3/8-small)  小目标检测层输出位置增加注意力机制
  40.   - [-1, 1, Conv, [256, 3, 2]]
  41.   - [[-1, 13], 1, Concat, [1]] # cat head P4
  42.   - [-1, 2, C3k2, [512, False]] # 20 (P4/16-medium)
  43.   - [-1, 1, iEMA, []] # 21 (P4/16-medium) 中目标检测层输出位置增加注意力机制
  45.   - [-1, 1, Conv, [512, 3, 2]]
  46.   - [[-1, 10], 1, Concat, [1]] # cat head P5
  47.   - [-1, 2, C3k2, [1024, True]] # 24 (P5/32-large)
  48.   - [-1, 1, iEMA, []] # 25 (P5/32-large) 大目标检测层输出位置增加注意力机制
  50.   # 注意力机制我这里其实是添加了三个但是实际一般生效就只添加一个就可以了，所以大家可以自行注释来尝试, 上面三个仅建议大家保留一个， 但是from位置要对齐.
  51.   # 具体在那一层用注意力机制可以根据自己的数据集场景进行选择。
  52.   # 如果你自己配置注意力位置注意from[17, 21, 25]位置要对应上对应的检测层！
  53.   - [[17, 21, 25], 1, Detect, [nc]] # Detect(P3, P4, P5)

5.3 训练代码

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

  1. import warnings
  2. warnings.filterwarnings('ignore')
  3. from ultralytics import YOLO
  5. if __name__ == '__main__':
  6.     model = YOLO('模型配置文件')
  7.     # 如何切换模型版本, 上面的ymal文件可以改为 yolov8s.yaml就是使用的v8s,
  8.     # 类似某个改进的yaml文件名称为yolov8-XXX.yaml那么如果想使用其它版本就把上面的名称改为yolov8l-XXX.yaml即可（改的是上面YOLO中间的名字不是配置文件的）！
  9.     # model.load('yolov8n.pt') # 是否加载预训练权重,科研不建议大家加载否则很难提升精度
  10.     model.train(data=r"C:\Users\Administrator\PycharmProjects\yolov5-master\yolov5-master\Construction Site Safety.v30-raw-images_latestversion.yolov8\data.yaml",
  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=True,  # 如果出现训练损失为Nan可以关闭amp
  23.                 project='runs/train',
  24.                 name='exp',
  25.                 )

5.4 训练过程截图

​

五、本文总结

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