学习资源站

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

一、本文介绍

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

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

二、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
  10. inplace = True
  12. __all__ = ['EMO_1M', 'EMO_2M', 'EMO_5M', 'EMO_6M']
  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.         )
  42.         self.fc = nn.Sequential(
  43.             nn.Linear(in_channel // self.reduction * self.cardinality, in_channel, bias=False),
  44.             nn.Sigmoid()
  45.         )
  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)
  57.         return x * y_ex_dim.expand_as(x)
  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]
  70. class LayerNorm2d(nn.Module):
  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)
  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
  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]
  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))
  108.     def forward(self, x):
  109.         return x.mul_(self.gamma) if self.inplace else x * self.gamma
  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))
  118.     def forward(self, x):
  119.         return x.mul_(self.gamma) if self.inplace else x * self.gamma
  122. class ConvNormAct(nn.Module):
  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()
  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
  144. # ========== Multi-Scale Populations, for down-sampling and inductive bias ==========
  145. class MSPatchEmb(nn.Module):
  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)))
  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):
  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)
  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()
  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)
  248.         x = x + self.se(self.conv_local(x)) if self.has_skip else self.se(self.conv_local(x))
  250.         x = self.proj_drop(x)
  251.         x = self.proj(x)
  253.         x = (shortcut + self.drop_path(x)) if self.has_skip else x
  254.         return x
  257. class EMO(nn.Module):
  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))
  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)
  325.     @torch.jit.ignore
  326.     def no_weight_decay(self):
  327.         return {'token'}
  329.     @torch.jit.ignore
  330.     def no_weight_decay_keywords(self):
  331.         return {'alpha', 'gamma', 'beta'}
  333.     @torch.jit.ignore
  334.     def no_ft_keywords(self):
  335.         # return {'head.weight', 'head.bias'}
  336.         return {}
  338.     @torch.jit.ignore
  339.     def ft_head_keywords(self):
  340.         return {'head.weight', 'head.bias'}, self.num_classes
  342.     def get_classifier(self):
  343.         return self.head
  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()
  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)
  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
  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
  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
  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
  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
  423. if __name__ == "__main__":
  426.     # Generating Sample image
  427.     image_size = (1, 3, 640, 640)
  428.     image = torch.rand(*image_size)
  430.     # Model
  431.     model = EMO_6M()
  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
  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
  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
  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. # 我提供了版本分别是对应是 ['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
  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
  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)
  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)
  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)
  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
  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分，后期我会根据各种最新的前沿顶会进行论文复现，也会对一些老的改进机制进行补充 ， 如果大家觉得本文帮助到你了，订阅本专栏，关注后续更多的更新~

​​