YOLOv11改进 | 主干/Backbone篇 | 反向残差块目标检测网络EMO一种轻量级的CNN架构（支持yolov11全系列轻量化）

一、本文介绍

本文给大家带来的改进机制是 反向残差块网络EMO ，其的构成块iRMB在之前我已经发过了，同时进行了二次创新，本文的网络就是由iRMB组成的网络EMO，所以我们二次创新之后的iEMA也可以用于这个网络中，再次形成二次创新，同时本文的主干网络为一种 轻量级 的CNN架构，在开始之前给大家推荐一下我的专栏，本专栏每周更新3-10篇最新前沿机制 | 包括二次创新全网无重复，以及融合改进， 本文支持yolov11的全系列模型放缩，也就是nsmlx五个版本， 本文内容为个人独家创新，抄袭必究。

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

目录

一、本文介绍

二、EMO模型原理

三、EMO的核心代码

四、手把手教你添加EMO

4.1 修改一

4.2 修改二

4.3 修改三

4.4 修改四

4.5 修改五

4.6 修改六

4.7 修改七

4.8 修改八

注意！！！ 额外的修改！

打印计算量问题解决方案

注意事项！！！

五、EMO的yaml文件

5.1 EMO的yaml文件

5.2 训练文件的代码

六、成功运行记录

七、本文总结

二、EMO 模型 原理

论文地址： 官方论文地址

代码地址： 官方代码地址

Efficient MOdel (EMO) 模型基于 反向残差块（Inverted Residual Block, IRB） ，这是一种轻量级 CNN 的基础架构，同时融合了 Transformer的有效组件 。通过这种结合，EMO实现了一个统一的视角来处理轻量级模型的设计，创新地将CNN和注意力机制相结合。此外，EMO模型在各种基准测试中展示出优越的性能，特别是在ImageNet-1K、COCO2017和ADE20K等数据集上的表现。该模型不仅在效率和精度方面取得了平衡，而且在轻量级设计方面实现了突破。

EMO的 基本原理 可以分为以下几个要点：

1. 反向残差块（IRB）的应用： IRB作为轻量级CNN的基础架构，EMO将其扩展到基于注意力的模型。

2. 元移动块（MMB）的抽象化： EMO提出了一种新的轻量级设计方法，即单残差的元移动块（MMB），这是从IRB和 Transformer 的有效 组件 中抽象出的。

3. 现代反向残差移动块（iRMB）的构建： 基于简单但有效的设计标准，EMO推导出了iRMB，并以此构建了类似于ResNet的高效模型（EMO）。

在下面这个图中，我们可以看到 EMO模型的结构细节：

左侧 是一个抽象统一的元移动块（Meta-Mobile Block），它融合了多头自注意力机制（Multi-Head Self-Attention）、前馈网络（Feed-Forward Network）和反向 残差块 （Inverted Residual Block）。这个复合模块通过不同的扩展比率和高效的操作符进行具体化。

右侧 展示了一个类似于ResNet的 EMO模型架构 ，它完全由推导出的iRMB组成。图中突出了EMO模型中微操作组合（如深度可分卷积、窗口Transformer等）和不同尺度的网络层次，这些都是用于分类（CLS）、检测（Det）和分割（Seg）任务的。这种设计强调了EMO模型在处理不同下游任务时的灵活性和效率。

三、EMO的核心代码

EMO的核心代码如下，使用方法看章节四！ 

  1. from timm.models.layers import  trunc_normal_
  2. import math
  3. import torch
  4. import torch.nn as nn
  5. import torch.nn.functional as F
  6. from functools import partial
  7. from einops import rearrange, reduce
  8. from timm.models.layers import DropPath
  9.  
  10. inplace = True
  11.  
  12. __all__ = ['EMO_1M', 'EMO_2M', 'EMO_5M', 'EMO_6M']
  13.  
  14. class SELayerV2(nn.Module):
  15.     def __init__(self, in_channel, reduction=1):
  16.         super(SELayerV2, self).__init__()
  17.         assert in_channel >= reduction and in_channel % reduction == 0, 'invalid in_channel in SaElayer'
  18.         self.reduction = reduction
  19.         self.cardinality = 4
  20.         self.avg_pool = nn.AdaptiveAvgPool2d(1)
  21.         # cardinality 1
  22.         self.fc1 = nn.Sequential(
  23.             nn.Linear(in_channel, in_channel // self.reduction, bias=False),
  24.             nn.ReLU(inplace=True)
  25.         )
  26.         # cardinality 2
  27.         self.fc2 = nn.Sequential(
  28.             nn.Linear(in_channel, in_channel // self.reduction, bias=False),
  29.             nn.ReLU(inplace=True)
  30.         )
  31.         # cardinality 3
  32.         self.fc3 = nn.Sequential(
  33.             nn.Linear(in_channel, in_channel // self.reduction, bias=False),
  34.             nn.ReLU(inplace=True)
  35.         )
  36.         # cardinality 4
  37.         self.fc4 = nn.Sequential(
  38.             nn.Linear(in_channel, in_channel // self.reduction, bias=False),
  39.             nn.ReLU(inplace=True)
  40.         )
  41.  
  42.         self.fc = nn.Sequential(
  43.             nn.Linear(in_channel // self.reduction * self.cardinality, in_channel, bias=False),
  44.             nn.Sigmoid()
  45.         )
  46.  
  47.     def forward(self, x):
  48.         b, c, _, _ = x.size()
  49.         y = self.avg_pool(x).view(b, c)
  50.         y1 = self.fc1(y)
  51.         y2 = self.fc2(y)
  52.         y3 = self.fc3(y)
  53.         y4 = self.fc4(y)
  54.         y_concate = torch.cat([y1, y2, y3, y4], dim=1)
  55.         y_ex_dim = self.fc(y_concate).view(b, c, 1, 1)
  56.  
  57.         return x * y_ex_dim.expand_as(x)
  58.  
  59. def get_act(act_layer='relu'):
  60.     act_dict = {
  61.         'none': nn.Identity,
  62.         'relu': nn.ReLU,
  63.         'relu6': nn.ReLU6,
  64.         'silu': nn.SiLU,
  65.         'gelu': nn.GELU
  66.     }
  67.     return act_dict[act_layer]
  68.  
  69.  
  70. class LayerNorm2d(nn.Module):
  71.  
  72.     def __init__(self, normalized_shape, eps=1e-6, elementwise_affine=True):
  73.         super().__init__()
  74.         self.norm = nn.LayerNorm(normalized_shape, eps, elementwise_affine)
  75.  
  76.     def forward(self, x):
  77.         x = rearrange(x, 'b c h w -> b h w c').contiguous()
  78.         x = self.norm(x)
  79.         x = rearrange(x, 'b h w c -> b c h w').contiguous()
  80.         return x
  81.  
  82.  
  83. def get_norm(norm_layer='in_1d'):
  84.     eps = 1e-6
  85.     norm_dict = {
  86.         'none': nn.Identity,
  87.         'in_1d': partial(nn.InstanceNorm1d, eps=eps),
  88.         'in_2d': partial(nn.InstanceNorm2d, eps=eps),
  89.         'in_3d': partial(nn.InstanceNorm3d, eps=eps),
  90.         'bn_1d': partial(nn.BatchNorm1d, eps=eps),
  91.         'bn_2d': partial(nn.BatchNorm2d, eps=eps),
  92.         # 'bn_2d': partial(nn.SyncBatchNorm, eps=eps),
  93.         'bn_3d': partial(nn.BatchNorm3d, eps=eps),
  94.         'gn': partial(nn.GroupNorm, eps=eps),
  95.         'ln_1d': partial(nn.LayerNorm, eps=eps),
  96.         'ln_2d': partial(LayerNorm2d, eps=eps),
  97.     }
  98.     return norm_dict[norm_layer]
  99.  
  100.  
  101.  
  102. class LayerScale(nn.Module):
  103.     def __init__(self, dim, init_values=1e-5, inplace=True):
  104.         super().__init__()
  105.         self.inplace = inplace
  106.         self.gamma = nn.Parameter(init_values * torch.ones(1, 1, dim))
  107.  
  108.     def forward(self, x):
  109.         return x.mul_(self.gamma) if self.inplace else x * self.gamma
  110.  
  111.  
  112. class LayerScale2D(nn.Module):
  113.     def __init__(self, dim, init_values=1e-5, inplace=True):
  114.         super().__init__()
  115.         self.inplace = inplace
  116.         self.gamma = nn.Parameter(init_values * torch.ones(1, dim, 1, 1))
  117.  
  118.     def forward(self, x):
  119.         return x.mul_(self.gamma) if self.inplace else x * self.gamma
  120.  
  121.  
  122. class ConvNormAct(nn.Module):
  123.  
  124.     def __init__(self, dim_in, dim_out, kernel_size, stride=1, dilation=1, groups=1, bias=False,
  125.                  skip=False, norm_layer='bn_2d', act_layer='relu', inplace=True, drop_path_rate=0.):
  126.         super(ConvNormAct, self).__init__()
  127.         self.has_skip = skip and dim_in == dim_out
  128.         padding = math.ceil((kernel_size - stride) / 2)
  129.         self.conv = nn.Conv2d(dim_in, dim_out, kernel_size, stride, padding, dilation, groups, bias)
  130.         self.norm = get_norm(norm_layer)(dim_out)
  131.         self.act = nn.GELU()
  132.         self.drop_path = DropPath(drop_path_rate) if drop_path_rate else nn.Identity()
  133.  
  134.     def forward(self, x):
  135.         shortcut = x
  136.         x = self.conv(x)
  137.         x = self.norm(x)
  138.         x = self.act(x)
  139.         if self.has_skip:
  140.             x = self.drop_path(x) + shortcut
  141.         return x
  142.  
  143.  
  144. # ========== Multi-Scale Populations, for down-sampling and inductive bias ==========
  145. class MSPatchEmb(nn.Module):
  146.  
  147.     def __init__(self, dim_in, emb_dim, kernel_size=2, c_group=-1, stride=1, dilations=[1, 2, 3],
  148.                  norm_layer='bn_2d', act_layer='silu'):
  149.         super().__init__()
  150.         self.dilation_num = len(dilations)
  151.         assert dim_in % c_group == 0
  152.         c_group = math.gcd(dim_in, emb_dim) if c_group == -1 else c_group
  153.         self.convs = nn.ModuleList()
  154.         for i in range(len(dilations)):
  155.             padding = math.ceil(((kernel_size - 1) * dilations[i] + 1 - stride) / 2)
  156.             self.convs.append(nn.Sequential(
  157.                 nn.Conv2d(dim_in, emb_dim, kernel_size, stride, padding, dilations[i], groups=c_group),
  158.                 get_norm(norm_layer)(emb_dim),
  159.                 get_act(act_layer)(emb_dim)))
  160.  
  161.     def forward(self, x):
  162.         if self.dilation_num == 1:
  163.             x = self.convs[0](x)
  164.         else:
  165.             x = torch.cat([self.convs[i](x).unsqueeze(dim=-1) for i in range(self.dilation_num)], dim=-1)
  166.             x = reduce(x, 'b c h w n -> b c h w', 'mean').contiguous()
  167.         return x
  168. class iRMB(nn.Module):
  169.  
  170.     def __init__(self, dim_in, dim_out, norm_in=True, has_skip=True, exp_ratio=1.0, norm_layer='bn_2d',
  171.                  act_layer='relu', v_proj=True, dw_ks=3, stride=1, dilation=1, se_ratio=0.0, dim_head=64, window_size=7,
  172.                  attn_s=True, qkv_bias=False, attn_drop=0., drop=0., drop_path=0., v_group=False, attn_pre=False):
  173.         super().__init__()
  174.         self.norm = get_norm(norm_layer)(dim_in) if norm_in else nn.Identity()
  175.         dim_mid = int(dim_in * exp_ratio)
  176.         self.has_skip = (dim_in == dim_out and stride == 1) and has_skip
  177.         self.attn_s = attn_s
  178.         if self.attn_s:
  179.             assert dim_in % dim_head == 0, 'dim should be divisible by num_heads'
  180.             self.dim_head = dim_head
  181.             self.window_size = window_size
  182.             self.num_head = dim_in // dim_head
  183.             self.scale = self.dim_head ** -0.5
  184.             self.attn_pre = attn_pre
  185.             self.qk = ConvNormAct(dim_in, int(dim_in * 2), kernel_size=1, bias=qkv_bias, norm_layer='none',
  186.                                   act_layer='none')
  187.             self.v = ConvNormAct(dim_in, dim_mid, kernel_size=1, groups=self.num_head if v_group else 1, bias=qkv_bias,
  188.                                  norm_layer='none', act_layer=act_layer, inplace=inplace)
  189.             self.attn_drop = nn.Dropout(attn_drop)
  190.         else:
  191.             if v_proj:
  192.                 self.v = ConvNormAct(dim_in, dim_mid, kernel_size=1, bias=qkv_bias, norm_layer='none',
  193.                                      act_layer=act_layer, inplace=inplace)
  194.             else:
  195.                 self.v = nn.Identity()
  196.         self.conv_local = ConvNormAct(dim_mid, dim_mid, kernel_size=dw_ks, stride=stride, dilation=dilation,
  197.                                       groups=dim_mid, norm_layer='bn_2d', act_layer='silu', inplace=inplace)
  198.         self.se = SELayerV2(dim_mid)
  199.  
  200.         self.proj_drop = nn.Dropout(drop)
  201.         self.proj = ConvNormAct(dim_mid, dim_out, kernel_size=1, norm_layer='none', act_layer='none', inplace=inplace)
  202.         self.drop_path = DropPath(drop_path) if drop_path else nn.Identity()
  203.  
  204.     def forward(self, x):
  205.         shortcut = x
  206.         x = self.norm(x)
  207.         B, C, H, W = x.shape
  208.         if self.attn_s:
  209.             # padding
  210.             if self.window_size <= 0:
  211.                 window_size_W, window_size_H = W, H
  212.             else:
  213.                 window_size_W, window_size_H = self.window_size, self.window_size
  214.             pad_l, pad_t = 0, 0
  215.             pad_r = (window_size_W - W % window_size_W) % window_size_W
  216.             pad_b = (window_size_H - H % window_size_H) % window_size_H
  217.             x = F.pad(x, (pad_l, pad_r, pad_t, pad_b, 0, 0,))
  218.             n1, n2 = (H + pad_b) // window_size_H, (W + pad_r) // window_size_W
  219.             x = rearrange(x, 'b c (h1 n1) (w1 n2) -> (b n1 n2) c h1 w1', n1=n1, n2=n2).contiguous()
  220.             # attention
  221.             b, c, h, w = x.shape
  222.             qk = self.qk(x)
  223.             qk = rearrange(qk, 'b (qk heads dim_head) h w -> qk b heads (h w) dim_head', qk=2, heads=self.num_head,
  224.                            dim_head=self.dim_head).contiguous()
  225.             q, k = qk[0], qk[1]
  226.             attn_spa = (q @ k.transpose(-2, -1)) * self.scale
  227.             attn_spa = attn_spa.softmax(dim=-1)
  228.             attn_spa = self.attn_drop(attn_spa)
  229.             if self.attn_pre:
  230.                 x = rearrange(x, 'b (heads dim_head) h w -> b heads (h w) dim_head', heads=self.num_head).contiguous()
  231.                 x_spa = attn_spa @ x
  232.                 x_spa = rearrange(x_spa, 'b heads (h w) dim_head -> b (heads dim_head) h w', heads=self.num_head, h=h,
  233.                                   w=w).contiguous()
  234.                 x_spa = self.v(x_spa)
  235.             else:
  236.                 v = self.v(x)
  237.                 v = rearrange(v, 'b (heads dim_head) h w -> b heads (h w) dim_head', heads=self.num_head).contiguous()
  238.                 x_spa = attn_spa @ v
  239.                 x_spa = rearrange(x_spa, 'b heads (h w) dim_head -> b (heads dim_head) h w', heads=self.num_head, h=h,
  240.                                   w=w).contiguous()
  241.             # unpadding
  242.             x = rearrange(x_spa, '(b n1 n2) c h1 w1 -> b c (h1 n1) (w1 n2)', n1=n1, n2=n2).contiguous()
  243.             if pad_r > 0 or pad_b > 0:
  244.                 x = x[:, :, :H, :W].contiguous()
  245.         else:
  246.             x = self.v(x)
  247.  
  248.         x = x + self.se(self.conv_local(x)) if self.has_skip else self.se(self.conv_local(x))
  249.  
  250.         x = self.proj_drop(x)
  251.         x = self.proj(x)
  252.  
  253.         x = (shortcut + self.drop_path(x)) if self.has_skip else x
  254.         return x
  255.  
  256.  
  257. class EMO(nn.Module):
  258.  
  259.     def __init__(self, dim_in=3,factor=1,
  260.                  depths=[1, 2, 4, 2], stem_dim=16, embed_dims=[64, 128, 256, 512], exp_ratios=[4., 4., 4., 4.],
  261.                  norm_layers=['bn_2d', 'bn_2d', 'bn_2d', 'bn_2d'], act_layers=['relu', 'relu', 'relu', 'relu'],
  262.                  dw_kss=[3, 3, 5, 5], se_ratios=[0.0, 0.0, 0.0, 0.0], dim_heads=[32, 32, 32, 32],
  263.                  window_sizes=[7, 7, 7, 7], attn_ss=[False, False, True, True], qkv_bias=True,
  264.                  attn_drop=0., drop=0., drop_path=0., v_group=False, attn_pre=False, pre_dim=0):
  265.         super().__init__()
  266.         # 放缩系数
  267.         scale_factor = factor  # 比如放大 1.5 倍
  268.         # exp_ratios放缩比例不缩放
  269.         # 放缩后的 embed_dims，每个元素都被乘以 scale_factor 并转化为整形
  270.         embed_dims = [int(dim * scale_factor) for dim in embed_dims]
  271.         dprs = [x.item() for x in torch.linspace(0, drop_path, sum(depths))]
  272.         self.stage0 = nn.ModuleList([
  273.             MSPatchEmb(  # down to 112
  274.                 dim_in, stem_dim, kernel_size=dw_kss[0], c_group=1, stride=2, dilations=[1],
  275.                 norm_layer=norm_layers[0], act_layer='none'),
  276.             iRMB(  # ds
  277.                 stem_dim, stem_dim, norm_in=False, has_skip=False, exp_ratio=1,
  278.                 norm_layer=norm_layers[0], act_layer=act_layers[0], v_proj=False, dw_ks=dw_kss[0],
  279.                 stride=1, dilation=1, se_ratio=1,
  280.                 dim_head=dim_heads[0], window_size=window_sizes[0], attn_s=False,
  281.                 qkv_bias=qkv_bias, attn_drop=attn_drop, drop=drop, drop_path=0.,
  282.                 attn_pre=attn_pre
  283.             )
  284.         ])
  285.         emb_dim_pre = stem_dim
  286.         for i in range(len(depths)):
  287.             layers = []
  288.             dpr = dprs[sum(depths[:i]):sum(depths[:i + 1])]
  289.             for j in range(depths[i]):
  290.                 if j == 0:
  291.                     stride, has_skip, attn_s, exp_ratio = 2, False, False, exp_ratios[i] * 2
  292.                 else:
  293.                     stride, has_skip, attn_s, exp_ratio = 1, True, attn_ss[i], exp_ratios[i]
  294.                 layers.append(iRMB(
  295.                     emb_dim_pre, embed_dims[i], norm_in=True, has_skip=has_skip, exp_ratio=exp_ratio,
  296.                     norm_layer=norm_layers[i], act_layer=act_layers[i], v_proj=True, dw_ks=dw_kss[i],
  297.                     stride=stride, dilation=1, se_ratio=se_ratios[i],
  298.                     dim_head=dim_heads[i], window_size=window_sizes[i], attn_s=attn_s,
  299.                     qkv_bias=qkv_bias, attn_drop=attn_drop, drop=drop, drop_path=dpr[j], v_group=v_group,
  300.                     attn_pre=attn_pre
  301.                 ))
  302.                 emb_dim_pre = embed_dims[i]
  303.             self.__setattr__(f'stage{i + 1}', nn.ModuleList(layers))
  304.  
  305.         self.norm = get_norm(norm_layers[-1])(embed_dims[-1])
  306.         if pre_dim > 0:
  307.             self.pre_head = nn.Sequential(nn.Linear(embed_dims[-1], pre_dim), get_act(act_layers[-1])(inplace=inplace))
  308.             self.pre_dim = pre_dim
  309.         else:
  310.             self.pre_head = nn.Identity()
  311.             self.pre_dim = embed_dims[-1]
  312.         self.apply(self._init_weights)
  313.         self.width_list = [i.size(1) for i in self.forward(torch.randn(1, 3, 640, 640))]
  314.     def _init_weights(self, m):
  315.         if isinstance(m, nn.Linear):
  316.             trunc_normal_(m.weight, std=.02)
  317.             if m.bias is not None:
  318.                 nn.init.zeros_(m.bias)
  319.         elif isinstance(m, (nn.LayerNorm, nn.GroupNorm,
  320.                             nn.BatchNorm1d, nn.BatchNorm2d, nn.BatchNorm3d,
  321.                             nn.InstanceNorm1d, nn.InstanceNorm2d, nn.InstanceNorm3d)):
  322.             nn.init.zeros_(m.bias)
  323.             nn.init.ones_(m.weight)
  324.  
  325.     @torch.jit.ignore
  326.     def no_weight_decay(self):
  327.         return {'token'}
  328.  
  329.     @torch.jit.ignore
  330.     def no_weight_decay_keywords(self):
  331.         return {'alpha', 'gamma', 'beta'}
  332.  
  333.     @torch.jit.ignore
  334.     def no_ft_keywords(self):
  335.         # return {'head.weight', 'head.bias'}
  336.         return {}
  337.  
  338.     @torch.jit.ignore
  339.     def ft_head_keywords(self):
  340.         return {'head.weight', 'head.bias'}, self.num_classes
  341.  
  342.     def get_classifier(self):
  343.         return self.head
  344.  
  345.     def reset_classifier(self, num_classes):
  346.         self.num_classes = num_classes
  347.         self.head = nn.Linear(self.pre_dim, num_classes) if num_classes > 0 else nn.Identity()
  348.  
  349.     def check_bn(self):
  350.         for name, m in self.named_modules():
  351.             if isinstance(m, nn.modules.batchnorm._NormBase):
  352.                 m.running_mean = torch.nan_to_num(m.running_mean, nan=0, posinf=1, neginf=-1)
  353.                 m.running_var = torch.nan_to_num(m.running_var, nan=0, posinf=1, neginf=-1)
  354.  
  355.     def forward(self, x):
  356.         unique_tensors = {}
  357.         for blk in self.stage0:
  358.             x = blk(x)
  359.             width, height = x.shape[2], x.shape[3]
  360.             unique_tensors[(width, height)] = x
  361.         for blk in self.stage1:
  362.             x = blk(x)
  363.             width, height = x.shape[2], x.shape[3]
  364.             unique_tensors[(width, height)] = x
  365.         for blk in self.stage2:
  366.             x = blk(x)
  367.             width, height = x.shape[2], x.shape[3]
  368.             unique_tensors[(width, height)] = x
  369.         for blk in self.stage3:
  370.             x = blk(x)
  371.             width, height = x.shape[2], x.shape[3]
  372.             unique_tensors[(width, height)] = x
  373.         for blk in self.stage4:
  374.             x = blk(x)
  375.             width, height = x.shape[2], x.shape[3]
  376.             unique_tensors[(width, height)] = x
  377.         result_list = list(unique_tensors.values())[-4:]
  378.         return result_list
  379.  
  380.  
  381.  
  382.  
  383. def EMO_1M(factor=1):
  384.     model = EMO(
  385.         factor=factor,
  386.         depths=[2, 2, 8, 3], stem_dim=24, embed_dims=[32, 48, 80, 168], exp_ratios=[2., 2.5, 3.0, 3.5],
  387.         norm_layers=['bn_2d', 'bn_2d', 'ln_2d', 'ln_2d'], act_layers=['silu', 'silu', 'gelu', 'gelu'],
  388.         dw_kss=[3, 3, 5, 5], dim_heads=[16, 16, 20, 21], window_sizes=[7, 7, 7, 7], attn_ss=[False, False, True, True],
  389.         qkv_bias=True, attn_drop=0., drop=0., drop_path=0.04036, v_group=False, attn_pre=True, pre_dim=0)
  390.     return model
  391.  
  392.  
  393. def EMO_2M(factor=1):
  394.     model = EMO(
  395.         factor=factor,
  396.         depths=[3, 3, 9, 3], stem_dim=24, embed_dims=[32, 48, 120, 200], exp_ratios=[2., 2.5, 3.0, 3.5],
  397.         norm_layers=['bn_2d', 'bn_2d', 'ln_2d', 'ln_2d'], act_layers=['silu', 'silu', 'gelu', 'gelu'],
  398.         dw_kss=[3, 3, 5, 5], dim_heads=[16, 16, 20, 20], window_sizes=[7, 7, 7, 7], attn_ss=[False, False, True, True],
  399.         qkv_bias=True, attn_drop=0., drop=0., drop_path=0.05, v_group=False, attn_pre=True, pre_dim=0)
  400.     return model
  401.  
  402.  
  403. def EMO_5M(factor=1):
  404.     model = EMO(
  405.         factor=factor,
  406.         depths=[3, 3, 9, 3], stem_dim=24, embed_dims=[48, 72, 160, 288], exp_ratios=[2., 3., 4., 4.],
  407.         norm_layers=['bn_2d', 'bn_2d', 'ln_2d', 'ln_2d'], act_layers=['silu', 'silu', 'gelu', 'gelu'],
  408.         dw_kss=[3, 3, 5, 5], dim_heads=[24, 24, 32, 32], window_sizes=[7, 7, 7, 7], attn_ss=[False, False, True, True],
  409.         qkv_bias=True, attn_drop=0., drop=0., drop_path=0.05, v_group=False, attn_pre=True, pre_dim=0)
  410.     return model
  411.  
  412.  
  413. def EMO_6M(factor=1):
  414.     model = EMO(
  415.         factor=factor,
  416.         depths=[3, 3, 9, 3], stem_dim=24, embed_dims=[48, 72, 160, 320], exp_ratios=[2., 3., 4., 5.],
  417.         norm_layers=['bn_2d', 'bn_2d', 'ln_2d', 'ln_2d'], act_layers=['silu', 'silu', 'gelu', 'gelu'],
  418.         dw_kss=[3, 3, 5, 5], dim_heads=[16, 24, 20, 32], window_sizes=[7, 7, 7, 7], attn_ss=[False, False, True, True],
  419.         qkv_bias=True, attn_drop=0., drop=0., drop_path=0.05, v_group=False, attn_pre=True, pre_dim=0)
  420.     return model
  421.  
  422.  
  423. if __name__ == "__main__":
  424.  
  425.  
  426.     # Generating Sample image
  427.     image_size = (1, 3, 640, 640)
  428.     image = torch.rand(*image_size)
  429.  
  430.     # Model
  431.     model = EMO_6M()
  432.  
  433.     out = model(image)
  434.     print(len(out))

四、手把手教你添加EMO

4.1 修改一

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

4.2 修改二

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

4.3 修改三

第三步我门中到如下文件'ultralytics/nn/tasks.py'进行导入和注册我们的模块( ！

4.4 修改四

添加如下两行代码！！！

​

4.5 修改五

找到七百多行大概把具体看图片，按照图片来修改就行，添加红框内的部分，注意没有()只是 函数 名。 

  1.         elif m in {自行添加对应的模型即可，下面都是一样的}:
  2.             m = m(*args)
  3.             c2 = m.width_list  # 返回通道列表
  4.             backbone = True

4.6 修改六

下面的两个红框内都是需要改动的。

​ 

  1.         if isinstance(c2, list):
  2.             m_ = m
  3.             m_.backbone = True
  4.         else:
  5.             m_ = nn.Sequential(*(m(*args) for _ in range(n))) if n > 1 else m(*args)  # module
  6.             t = str(m)[8:-2].replace('__main__.', '')  # module type
  7.  
  8.  
  9.         m.np = sum(x.numel() for x in m_.parameters())  # number params
  10.         m_.i, m_.f, m_.type = i + 4 if backbone else i, f, t  # attach index, 'from' index, type

4.7 修改七

如下的也需要修改，全部按照我的来。

​

代码如下把原先的代码替换了即可。 

  1.         if verbose:
  2.             LOGGER.info(f'{i:>3}{str(f):>20}{n_:>3}{m.np:10.0f}  {t:<45}{str(args):<30}')  # print
  3.  
  4.         save.extend(x % (i + 4 if backbone else i) for x in ([f] if isinstance(f, int) else f) if x != -1)  # append to savelist
  5.         layers.append(m_)
  6.         if i == 0:
  7.             ch = []
  8.         if isinstance(c2, list):
  9.             ch.extend(c2)
  10.             if len(c2) != 5:
  11.                 ch.insert(0, 0)
  12.         else:
  13.             ch.append(c2)

4.8 修改八

修改八和前面的都不太一样，需要修改前向传播中的一个部分， 已经离开了parse_model方法了。

可以在图片中开代码行数，没有离开task.py文件都是同一个文件。 同时这个部分有好几个前向传播都很相似，大家不要看错了， 是70多行左右的！！！，同时我后面提供了代码，大家直接复制粘贴即可，有时间我针对这里会出一个视频。

​​

代码如下-> 

  1.     def _predict_once(self, x, profile=False, visualize=False, embed=None):
  2.         """
  3.         Perform a forward pass through the network.
  5.         Args:
  6.             x (torch.Tensor): The input tensor to the model.
  7.             profile (bool):  Print the computation time of each layer if True, defaults to False.
  8.             visualize (bool): Save the feature maps of the model if True, defaults to False.
  9.             embed (list, optional): A list of feature vectors/embeddings to return.
  11.         Returns:
  12.             (torch.Tensor): The last output of the model.
  13.         """
  14.         y, dt, embeddings = [], [], []  # outputs
  15.         for m in self.model:
  16.             if m.f != -1:  # if not from previous layer
  17.                 x = y[m.f] if isinstance(m.f, int) else [x if j == -1 else y[j] for j in m.f]  # from earlier layers
  18.             if profile:
  19.                 self._profile_one_layer(m, x, dt)
  20.             if hasattr(m, 'backbone'):
  21.                 x = m(x)
  22.                 if len(x) != 5:  # 0 - 5
  23.                     x.insert(0, None)
  24.                 for index, i in enumerate(x):
  25.                     if index in self.save:
  26.                         y.append(i)
  27.                     else:
  28.                         y.append(None)
  29.                 x = x[-1]  # 最后一个输出传给下一层
  30.             else:
  31.                 x = m(x)  # run
  32.                 y.append(x if m.i in self.save else None)  # save output
  33.             if visualize:
  34.                 feature_visualization(x, m.type, m.i, save_dir=visualize)
  35.             if embed and m.i in embed:
  36.                 embeddings.append(nn.functional.adaptive_avg_pool2d(x, (1, 1)).squeeze(-1).squeeze(-1))  # flatten
  37.                 if m.i == max(embed):
  38.                     return torch.unbind(torch.cat(embeddings, 1), dim=0)
  39.         return x

到这里就完成了修改部分，但是这里面细节很多，大家千万要注意不要替换多余的代码，导致报错，也不要拉下任何一部，都会导致运行失败，而且报错很难排查！！！很难排查！！！

注意！！！ 额外的修改！

关注我的其实都知道，我大部分的修改都是一样的，这个网络需要额外的修改一步，就是s一个参数，将下面的s改为640！！！即可完美运行！！

打印计算量问题解决方案

我们找到如下文件'ultralytics/utils/torch_utils.py'按照如下的图片进行修改，否则容易打印不出来计算量。

​

注意事项！！！

如果大家在验证的时候报错形状不匹配的错误可以固定 验证集 的图片尺寸，方法如下 ->

找到下面这个文件ultralytics/ models /yolo/detect/train.py然后其中有一个类是DetectionTrainer class中的build_dataset函数中的一个参数rect=mode == 'val'改为rect=False

五、EMO的yaml文件

5.1 EMO的yaml文件

训练信息：YOLO11-EMO summary: 860 layers, 2,423,567 parameters, 2,423,551 gradients, 6.5 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
  3.  
  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
  13.  
  14. # 我提供了版本分别是对应是 ['EMO_1M', 'EMO_2M', 'EMO_5M', 'EMO_6M']
  15. # 其中n是对应yolo的版本通道放缩 large 和 small 是模型官方本身自带的版本
  16. # YOLO11n backbone
  17. backbone:
  18.   # [from, repeats, module, args]
  19.   - [-1, 1, EMO_1M, [0.25]] # 0-4 P1/2 这里是四层大家不要被yaml文件限制住了思维.
  20.   # 注意args位置的参数对应模型的通道放缩系数width在上面scales位置, 假设你用yolov11n那么可以设置0.25 如果你用yolov11s可以设置0.5
  21.   - [-1, 1, SPPF, [1024, 5]] # 5
  22.   - [-1, 2, C2PSA, [1024]] # 6
  23.  
  24. # YOLO11n head
  25. head:
  26.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  27.   - [[-1, 3], 1, Concat, [1]] # cat backbone P4
  28.   - [-1, 2, C3k2, [512, False]] # 9
  29.  
  30.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  31.   - [[-1, 2], 1, Concat, [1]] # cat backbone P3
  32.   - [-1, 2, C3k2, [256, False]] # 12 (P3/8-small)
  33.  
  34.   - [-1, 1, Conv, [256, 3, 2]]
  35.   - [[-1, 9], 1, Concat, [1]] # cat head P4
  36.   - [-1, 2, C3k2, [512, False]] # 15 (P4/16-medium)
  37.  
  38.   - [-1, 1, Conv, [512, 3, 2]]
  39.   - [[-1, 6], 1, Concat, [1]] # cat head P5
  40.   - [-1, 2, C3k2, [1024, True]] # 18 (P5/32-large)
  41.  
  42.   - [[12, 15, 18], 1, Detect, [nc]] # Detect(P3, P4, P5)

5.2 训练文件的代码

可以复制我的运行文件进行运行。 

  1. import warnings
  2. warnings.filterwarnings('ignore')
  3. from ultralytics import YOLO
  4.  
  5. if __name__ == '__main__':
  6.     model = YOLO('yolov8-MLLA.yaml')
  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.                 )

六、成功运行记录

下面是成功运行的截图，已经完成了有1个epochs的训练，图片太大截不全第2个epochs了。

​

七、本文总结

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

​​