YOLOv8改进 | 注意力机制 | 反向残差注意力机制【内含创新技巧思维】

kay_5452024-08-04 9:31

秋招面试专栏推荐 ：深度学习算法工程师面试问题总结【百面算法工程师】------点击即可跳转

💡💡💡 本专栏所有程序均经过测试，可成功执行💡💡💡

专栏目录 ：《YOLOv8改进有效涨点》专栏介绍 & 专栏目录 | 目前已有80+篇内容，内含各种Head检测头、损失函数Loss、Backbone、Neck、NMS等创新点改进------点击即可跳转

本文介绍一种专注于开发现代、高效、轻量级的密集预测模型 ，在参数、FLOPs和性能之间进行权衡。倒置残差块（IRB）作为轻量级CNN的基础设施，但在基于注意力的研究中还没有相对应的识别。从高效IRB和Transformer的有效组件的统一视角重新思考轻量级基础设施，将基于CNN的IRB扩展到基于注意力的模型，并抽象出一个一残差元移动块（MMB）用于轻量级模型设计。遵循简单但有效的设计准则，推导出现代化的倒置残差移动块（iRMB），并仅用iRMB构建了类似ResNet的高效模型（EMO）用于下游任务。文章在介绍主要的原理后，将手把手教学如何进行模块的代码添加和修改，并将修改后的完整代码放在文章的最后，方便大家一键运行，小白也可轻松上手实践。以帮助您更好地学习深度学习目标检测YOLO系列的挑战。

专栏地址：YOLOv8改进------更新各种有效涨点方法------点击即可跳转 订阅学习不迷路

目录

1.原理

[2. 将IRMB添加到YOLOv8中](#2. 将IRMB添加到YOLOv8中)

[2.1 IRMB的代码实现](#2.1 IRMB的代码实现)

[2.2 更改init.py文件](#2.2 更改init.py文件)

[2.3 添加yaml文件](#2.3 添加yaml文件)

[2.4 注册模块](#2.4 注册模块)

[2.5 执行程序](#2.5 执行程序)

[3. 完整代码分享](#3. 完整代码分享)

[4. GFLOPs](#4. GFLOPs)

[5. 进阶](#5. 进阶)

[6. 总结](#6. 总结)

1.原理

论文地址： Rethinking Mobile Block for Efficient Attention-based Models------点击即可跳转

官方代码： 官方代码仓库------点击即可跳转

在提供的文档中，介绍的关键概念是倒置残差移动块 (iRMB) ，它是轻量级 CNN 中使用的**倒置残差块 (IRB)**的现代改编，旨在提高基于注意力的模型的效率。下面是对 IRMB 背后主要原理的简化解释，无需深入研究复杂的公式：

倒置残差移动块 (IRMB) 的关键原理：

计算效率：

  • 深度卷积 (DW-Conv)：与标准卷积相比，这种技术显著减少了参数数量和计算复杂度。它分别对每个输入通道进行操作，使其更加高效。

  • 改进的多头自注意力 (EW-MHSA)：MHSA 的增强版本有助于更有效地捕获数据中远距离元素之间的依赖关系，这对于基于注意力的模型至关重要。

简单和统一：

  • 简单设计：IRMB 避免使用复杂的结构或运算符，使其易于实现和优化各种应用。

  • 统一核心模块：通过使用尽可能少的核心模块，IRMB 降低了整体模型复杂性，便于更轻松地部署和更快地计算。

多功能性和性能：

  • 元移动块 (MMB)：此块是一个多功能构建块，可用于构建不同的模块，包括 IRB、MHSA 和前馈网络。它确保在各种任务中保持一致和高效的性能。

  • 类似 ResNet 的架构 (EMO)：使用 IRMB 构建的高效模型 (EMO) 利用类似 ResNet 的 4 阶段架构，这对短距离和长距离依赖关系都有效，从而提高了整体模型性能。

实际结果：

  • 基准性能：大量实验表明，使用 IRMB（例如 EMO-1M、EMO-2M 和 EMO-5M）构建的模型在准确性、效率（以 FLOP 衡量）和速度方面优于许多最先进的轻量级模型。

IRMB 优势总结：

  • 提高效率：通过结合 DW-Conv 和改进的 MHSA，IRMB 实现了更高的计算效率。

  • 简化设计：使用简单统一的设计使模型易于实现和部署。

  • 提高性能：基于 IRMB 的模型在各种基准测试中表现出色，在参数、效率和准确性之间表现出更好的权衡。

这些原则使倒置残差移动块 (IRMB) 成为开发轻量级高效模型的强大框架，用于基于注意力的系统中进行密集预测。

2. 将IRMB添加到YOLOv8中

2.1 IRMB的代码实现

关键步骤一: 将下面代码粘贴到在/ultralytics/ultralytics/nn/modules/block.py中，并在该文件的__all__中添加"iRMB"

python 复制代码 
class iRMB(nn.Module):
 
    def __init__(self, dim_in, dim_out, norm_in=True, has_skip=True, exp_ratio=1.0, norm_layer='bn_2d',
                 act_layer='relu', v_proj=True, dw_ks=3, stride=1, dilation=1, se_ratio=0.0, dim_head=8, window_size=7,
                 attn_s=True, qkv_bias=False, attn_drop=0., drop=0., drop_path=0., v_group=False, attn_pre=False):
        super().__init__()
        self.norm = get_norm(norm_layer)(dim_in) if norm_in else nn.Identity()
        dim_mid = int(dim_in * exp_ratio)
        self.has_skip = (dim_in == dim_out and stride == 1) and has_skip
        self.attn_s = attn_s
        if self.attn_s:
            assert dim_in % dim_head == 0, 'dim should be divisible by num_heads'
            self.dim_head = dim_head
            self.window_size = window_size
            self.num_head = dim_in // dim_head
            self.scale = self.dim_head ** -0.5
            self.attn_pre = attn_pre
            self.qk = ConvNormAct(dim_in, int(dim_in * 2), kernel_size=1, bias=qkv_bias, norm_layer='none',
                                  act_layer='none')
            self.v = ConvNormAct(dim_in, dim_mid, kernel_size=1, groups=self.num_head if v_group else 1, bias=qkv_bias,
                                 norm_layer='none', act_layer=act_layer, inplace=inplace)
            self.attn_drop = nn.Dropout(attn_drop)
        else:
            if v_proj:
                self.v = ConvNormAct(dim_in, dim_mid, kernel_size=1, bias=qkv_bias, norm_layer='none',
                                     act_layer=act_layer, inplace=inplace)
            else:
                self.v = nn.Identity()
        self.conv_local = ConvNormAct(dim_mid, dim_mid, kernel_size=dw_ks, stride=stride, dilation=dilation,
                                      groups=dim_mid, norm_layer='bn_2d', act_layer='silu', inplace=inplace)
        self.se = SqueezeExcite(dim_mid, rd_ratio=se_ratio, act_layer=get_act(act_layer)) if se_ratio > 0.0 else nn.Identity()
 
        self.proj_drop = nn.Dropout(drop)
        self.proj = ConvNormAct(dim_mid, dim_out, kernel_size=1, norm_layer='none', act_layer='none', inplace=inplace)
        self.drop_path = DropPath(drop_path) if drop_path else nn.Identity()
 
    def forward(self, x):
        shortcut = x
        x = self.norm(x)
        B, C, H, W = x.shape
        if self.attn_s:
            # padding
            if self.window_size <= 0:
                window_size_W, window_size_H = W, H
            else:
                window_size_W, window_size_H = self.window_size, self.window_size
            pad_l, pad_t = 0, 0
            pad_r = (window_size_W - W % window_size_W) % window_size_W
            pad_b = (window_size_H - H % window_size_H) % window_size_H
            x = F.pad(x, (pad_l, pad_r, pad_t, pad_b, 0, 0,))
            n1, n2 = (H + pad_b) // window_size_H, (W + pad_r) // window_size_W
            x = rearrange(x, 'b c (h1 n1) (w1 n2) -> (b n1 n2) c h1 w1', n1=n1, n2=n2).contiguous()
            # attention
            b, c, h, w = x.shape
            qk = self.qk(x)
            qk = rearrange(qk, 'b (qk heads dim_head) h w -> qk b heads (h w) dim_head', qk=2, heads=self.num_head,
                           dim_head=self.dim_head).contiguous()
            q, k = qk[0], qk[1]
            attn_spa = (q @ k.transpose(-2, -1)) * self.scale
            attn_spa = attn_spa.softmax(dim=-1)
            attn_spa = self.attn_drop(attn_spa)
            if self.attn_pre:
                x = rearrange(x, 'b (heads dim_head) h w -> b heads (h w) dim_head', heads=self.num_head).contiguous()
                x_spa = attn_spa @ x
                x_spa = rearrange(x_spa, 'b heads (h w) dim_head -> b (heads dim_head) h w', heads=self.num_head, h=h,
                                  w=w).contiguous()
                x_spa = self.v(x_spa)
            else:
                v = self.v(x)
                v = rearrange(v, 'b (heads dim_head) h w -> b heads (h w) dim_head', heads=self.num_head).contiguous()
                x_spa = attn_spa @ v
                x_spa = rearrange(x_spa, 'b heads (h w) dim_head -> b (heads dim_head) h w', heads=self.num_head, h=h,
                                  w=w).contiguous()
            # unpadding
            x = rearrange(x_spa, '(b n1 n2) c h1 w1 -> b c (h1 n1) (w1 n2)', n1=n1, n2=n2).contiguous()
            if pad_r > 0 or pad_b > 0:
                x = x[:, :, :H, :W].contiguous()
        else:
            x = self.v(x)
 
        x = x + self.se(self.conv_local(x)) if self.has_skip else self.se(self.conv_local(x))
 
        x = self.proj_drop(x)
        x = self.proj(x)
 
        x = (shortcut + self.drop_path(x)) if self.has_skip else x
        return x
 
 
def autopad(k, p=None, d=1):  # kernel, padding, dilation
    """Pad to 'same' shape outputs."""
    if d > 1:
        k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k]  # actual kernel-size
    if p is None:
        p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-pad
    return p
 
 
class Conv(nn.Module):
    """Standard convolution with args(ch_in, ch_out, kernel, stride, padding, groups, dilation, activation)."""
    default_act = nn.SiLU()  # default activation
 
    def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
        """Initialize Conv layer with given arguments including activation."""
        super().__init__()
        self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p, d), groups=g, dilation=d, bias=False)
        self.bn = nn.BatchNorm2d(c2)
        self.act = self.default_act if act is True else act if isinstance(act, nn.Module) else nn.Identity()
 
    def forward(self, x):
        """Apply convolution, batch normalization and activation to input tensor."""
        return self.act(self.bn(self.conv(x)))
 
    def forward_fuse(self, x):
        """Perform transposed convolution of 2D data."""
        return self.act(self.conv(x))
 
 
class Bottleneck(nn.Module):
    """Standard bottleneck."""
 
    def __init__(self, c1, c2, shortcut=True, g=1, k=(3, 3), e=0.5):
        """Initializes a bottleneck module with given input/output channels, shortcut option, group, kernels, and
        expansion.
        """
        super().__init__()
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, k[0], 1)
        self.cv2 = Conv(c_, c2, k[1], 1, g=g)
        self.add = shortcut and c1 == c2
        self.iRMB = iRMB(c2, c2)
 
    def forward(self, x):
        """'forward()' applies the YOLO FPN to input data."""
        return x + self.iRMB(self.cv2(self.cv1(x))) if self.add else self.iRMB(self.cv2(self.cv1(x)))
 
 
class C2f_iRMB(nn.Module):
    """Faster Implementation of CSP Bottleneck with 2 convolutions."""
 
    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
        """Initialize CSP bottleneck layer with two convolutions with arguments ch_in, ch_out, number, shortcut, groups,
        expansion.
        """
        super().__init__()
        self.c = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, 2 * self.c, 1, 1)
        self.cv2 = Conv((2 + n) * self.c, c2, 1)  # optional act=FReLU(c2)
        self.m = nn.ModuleList(Bottleneck(self.c, self.c, shortcut, g, k=((3, 3), (3, 3)), e=1.0) for _ in range(n))
 
    def forward(self, x):
        """Forward pass through C2f layer."""
        y = list(self.cv1(x).chunk(2, 1))
        y.extend(m(y[-1]) for m in self.m)
        return self.cv2(torch.cat(y, 1))
 
    def forward_split(self, x):
        """Forward pass using split() instead of chunk()."""
        y = list(self.cv1(x).split((self.c, self.c), 1))
        y.extend(m(y[-1]) for m in self.m)
        return self.cv2(torch.cat(y, 1))

在处理图像的背景下，倒置残差移动块 (iRMB) 遵循结构化方法以实现高效准确的结果。以下是 iRMB 应用于图像处理时的主要流程概述：

iRMB 在图像处理中的主要流程

输入图像：

  • 该过程从需要处理的输入图像开始。此图像通常表示为像素值的多维数组。

初始卷积：

  • 1x1 卷积：输入图像首先经过逐点 1x1 卷积层。此层减少了输入图像中的通道数（或特征），使后续的深度卷积更加高效。

深度卷积 (DW-Conv)：

  • 3x3 深度卷积：然后通过深度卷积处理 1x1 卷积层的输出。与跨所有通道运行的传统卷积不同，深度卷积对每个输入通道应用单个卷积滤波器。这显著减少了计算负荷和参数数量。

  • 深度卷积在保持计算效率的同时捕获图像中的空间特征。

逐点卷积：

  • 1x1 卷积：在深度卷积之后，应用另一个 1x1 卷积层。该层负责跨通道组合深度卷积的输出，从而有效地增加输出特征的维度。

多头自注意力 (MHSA)：

  • 然后使用增强的多头自注意力机制处理逐点卷积的输出。MHSA 通过计算注意力分数并动态加权输入的不同部分，帮助模型关注图像的重要部分。

  • 此步骤对于捕获图像中的长距离依赖关系和上下文信息至关重要。

前馈网络 (FFN)：

  • FFN 模块：注意力增强特征通过前馈网络传递，通常由两个线性变换组成，中间有一个 ReLU 激活。这有助于进一步细化和组合前几层提取的特征。

残差连接：

  • 在整个 iRMB 中，残差连接用于将块的输入直接添加到其输出。这有助于保留来自初始层的信息，并允许在训练期间实现更好的梯度流。

输出特征图：

  • iRMB 的最终输出是一个特征图，该特征图经过深度卷积、点卷积和自注意力机制的有效处理。然后，此特征图可用于各种下游任务，如图像分类、对象检测或分割。

iRMB 处理流程摘要：

  • 高效卷积操作：1x1 和深度卷积的组合减少了参数数量和计算成本。

  • 增强特征提取：多头自注意力捕获长距离依赖关系和重要的上下文信息。

  • 残差连接：这些连接有助于保存信息和稳定训练。

  • 前馈网络：细化特征以提高下游任务的性能。

通过遵循这种结构化方法，iRMB 可以有效地处理图像，平衡效率和准确性，使其适用于需要轻量级和高性能模型的应用程序。

2.2 更改init.py文件

**关键步骤二：**修改modules文件夹下的__init__.py文件，先导入函数

然后在下面的__all__中声明函数

2.3 添加yaml文件

**关键步骤三：**在/ultralytics/ultralytics/cfg/models/v8下面新建文件yolov8_iRMB.yaml文件，粘贴下面的内容

  • OD【目标检测】
python 复制代码 
# Ultralytics YOLO 🚀, AGPL-3.0 license
# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect

# Parameters
nc: 80  # number of classes
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
  # [depth, width, max_channels]
  n: [0.33, 0.25, 1024]  # YOLOv8n summary: 225 layers,  3157200 parameters,  3157184 gradients,   8.9 GFLOPs
  s: [0.33, 0.50, 1024]  # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients,  28.8 GFLOPs
  m: [0.67, 0.75, 768]   # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients,  79.3 GFLOPs
  l: [1.00, 1.00, 512]   # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
  x: [1.00, 1.25, 512]   # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOP

# YOLOv8.0n backbone
backbone:
  # [from, repeats, module, args]
  - [-1, 1, Conv, [64, 3, 2]]  # 0-P1/2
  - [-1, 1, Conv, [128, 3, 2]]  # 1-P2/4
  - [-1, 3, C2f, [128, True]]
  - [-1, 1, Conv, [256, 3, 2]]  # 3-P3/8
  - [-1, 6, C2f, [256, True]]
  - [-1, 1, Conv, [512, 3, 2]]  # 5-P4/16
  - [-1, 6, C2f, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]]  # 7-P5/32
  - [-1, 3, C2f, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]]  # 9

# YOLOv8.0n head
head:
  - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
  - [[-1, 6], 1, Concat, [1]]  # cat backbone P4
  - [-1, 3, C2f, [512]]  # 12

  - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
  - [[-1, 4], 1, Concat, [1]]  # cat backbone P3
  - [-1, 3, C2f, [256]]  # 15 (P3/8-small)
  - [-1, 1, iRMB, []]  # 16

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 12], 1, Concat, [1]]  # cat head P4
  - [-1, 3, C2f, [512]]  # 19 (P4/16-medium)
  - [-1, 1, iRMB, []]  # 20

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 9], 1, Concat, [1]]  # cat head P5
  - [-1, 3, C2f, [1024]]  # 23 (P5/32-large)
  - [-1, 1, iRMB, []]  # 24

  - [[16, 20, 24], 1, Detect, [nc]]  # Detect(P3, P4, P5)
  • Seg【语义分割】
python 复制代码 
# Ultralytics YOLO 🚀, AGPL-3.0 license
# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect

# Parameters
nc: 80  # number of classes
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
  # [depth, width, max_channels]
  n: [0.33, 0.25, 1024]  # YOLOv8n summary: 225 layers,  3157200 parameters,  3157184 gradients,   8.9 GFLOPs
  s: [0.33, 0.50, 1024]  # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients,  28.8 GFLOPs
  m: [0.67, 0.75, 768]   # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients,  79.3 GFLOPs
  l: [1.00, 1.00, 512]   # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
  x: [1.00, 1.25, 512]   # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOP

# YOLOv8.0n backbone
backbone:
  # [from, repeats, module, args]
  - [-1, 1, Conv, [64, 3, 2]]  # 0-P1/2
  - [-1, 1, Conv, [128, 3, 2]]  # 1-P2/4
  - [-1, 3, C2f, [128, True]]
  - [-1, 1, Conv, [256, 3, 2]]  # 3-P3/8
  - [-1, 6, C2f, [256, True]]
  - [-1, 1, Conv, [512, 3, 2]]  # 5-P4/16
  - [-1, 6, C2f, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]]  # 7-P5/32
  - [-1, 3, C2f, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]]  # 9

# YOLOv8.0n head
head:
  - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
  - [[-1, 6], 1, Concat, [1]]  # cat backbone P4
  - [-1, 3, C2f, [512]]  # 12

  - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
  - [[-1, 4], 1, Concat, [1]]  # cat backbone P3
  - [-1, 3, C2f, [256]]  # 15 (P3/8-small)
  - [-1, 1, iRMB, []]  # 16

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 12], 1, Concat, [1]]  # cat head P4
  - [-1, 3, C2f, [512]]  # 19 (P4/16-medium)
  - [-1, 1, iRMB, []]  # 20

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 9], 1, Concat, [1]]  # cat head P5
  - [-1, 3, C2f, [1024]]  # 23 (P5/32-large)
  - [-1, 1, iRMB, []]  # 24

  - [[16, 20, 24], 1, Segment, [nc, 32, 256]] # Segment(P3, P4, P5)

温馨提示：因为本文只是对yolov8基础上添加模块，如果要对yolov8n/l/m/x进行添加则只需要指定对应的depth_multiple 和 width_multiple。

python 复制代码 
# YOLOv8n
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.25  # layer channel multiple
max_channels: 1024 # max_channels
 
# YOLOv8s
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.50  # layer channel multiple
max_channels: 1024 # max_channels
 
# YOLOv8l 
depth_multiple: 1.0  # model depth multiple
width_multiple: 1.0  # layer channel multiple
max_channels: 512 # max_channels
 
# YOLOv8m
depth_multiple: 0.67  # model depth multiple
width_multiple: 0.75  # layer channel multiple
max_channels: 768 # max_channels
 
# YOLOv8x
depth_multiple: 1.33  # model depth multiple
width_multiple: 1.25  # layer channel multiple
max_channels: 512 # max_channels

2.4 注册模块

**关键步骤四：**在task.py的parse_model函数iRMB"

2.5 执行程序

在train.py中，将model的参数路径设置为yolov8_iRMB.yaml的路径

建议大家写绝对路径，确保一定能找到

python 复制代码 
from ultralytics import YOLO
 
# Load a model
# model = YOLO('yolov8n.yaml')  # build a new model from YAML
# model = YOLO('yolov8n.pt')  # load a pretrained model (recommended for training)
 
model = YOLO(r'/projects/ultralytics/ultralytics/cfg/models/v8/yolov8_iRMB.yaml')  # build from YAML and transfer weights
 
# Train the model
model.train()

🚀运行程序，如果出现下面的内容则说明添加成功🚀

python 复制代码 
                   from  n    params  module                                       arguments
  0                  -1  1       464  ultralytics.nn.modules.conv.Conv             [3, 16, 3, 2]
  1                  -1  1      4672  ultralytics.nn.modules.conv.Conv             [16, 32, 3, 2]
  2                  -1  1      8592  ultralytics.nn.modules.block.C2f             [32, 32, 1, True]
  3                  -1  1     18560  ultralytics.nn.modules.conv.Conv             [32, 64, 3, 2]
  4                  -1  2     58688  ultralytics.nn.modules.block.C2f             [64, 64, 2, True]
  5                  -1  1     73984  ultralytics.nn.modules.conv.Conv             [64, 128, 3, 2]
  6                  -1  2    232064  ultralytics.nn.modules.block.C2f             [128, 128, 2, True]
  7                  -1  1    295424  ultralytics.nn.modules.conv.Conv             [128, 256, 3, 2]
  8                  -1  1    527488  ultralytics.nn.modules.block.C2f             [256, 256, 1, True]
  9                  -1  1    164608  ultralytics.nn.modules.block.SPPF            [256, 256, 5]
 10                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']
 11             [-1, 6]  1         0  ultralytics.nn.modules.conv.Concat           [1]
 12                  -1  1    165440  ultralytics.nn.modules.block.C2f             [384, 128, 1]
 13                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']
 14             [-1, 4]  1         0  ultralytics.nn.modules.conv.Concat           [1]
 15                  -1  1     41760  ultralytics.nn.modules.block.C2f             [192, 64, 1]
 16                  -1  1     17216  ultralytics.nn.modules.block.iRMB            [64, 64]
 17                  -1  1     36992  ultralytics.nn.modules.conv.Conv             [64, 64, 3, 2]
 18            [-1, 12]  1         0  ultralytics.nn.modules.conv.Concat           [1]
 19                  -1  1    140864  ultralytics.nn.modules.block.C2f             [192, 128, 1]
 20                  -1  1     67200  ultralytics.nn.modules.block.iRMB            [128, 128]
 21                  -1  1    147712  ultralytics.nn.modules.conv.Conv             [128, 128, 3, 2]
 22             [-1, 9]  1         0  ultralytics.nn.modules.conv.Concat           [1]
 23                  -1  1    560256  ultralytics.nn.modules.block.C2f             [384, 256, 1]
 24                  -1  1    265472  ultralytics.nn.modules.block.iRMB            [256, 256]
 25        [16, 20, 24]  1    897664  ultralytics.nn.modules.head.Detect           [80, [64, 128, 256]]
YOLOv8_iRMB summary: 564 layers, 3725120 parameters, 3725104 gradients, 25.6 GFLOPs

3. 完整代码分享

python 复制代码 
https://pan.baidu.com/s/1YurvdKZzyj50geyBOG-Qjw?pwd=16wu

提取码: 16wu

4. GFLOPs

关于GFLOPs的计算方式可以查看：百面算法工程师 | 卷积基础知识------Convolution

未改进的YOLOv8nGFLOPs

改进后的GFLOPs

现在手上没有卡了，等过段时候有卡了把这补上，需要的同学自己测一下

5. 进阶

可以与其他模块或者损失函数等结合，进一步提升检测效果

6. 总结

  • 可以看出iRAM的创新只是加了一个反向残差，所以大家在改模块的时候也可以进行类似的缝合，起一个新意的名字既可发论文了。
  • 倒置残差移动块 (iRMB) 是一种专门为高效高性能图像处理而设计的架构框架，结合了深度卷积、点卷积和多头自注意力机制。iRMB 的核心原理在于通过使用 1x1 点卷积来压缩和扩展特征维度，并结合在每个输入通道上独立运行的 3x3 深度卷积，来降低计算复杂度和参数数量。此设置可有效捕获空间特征。此外，还采用多头自注意力 (MHSA) 机制来关注图像的重要部分，捕获长距离依赖关系和上下文信息。残差连接集成在整个块中，以确保更好的梯度流并保留来自初始层的信息。这种组合使 iRMB 能够以效率和准确性的平衡来处理图像，使其成为轻量级和高性能图像处理任务的理想选择。
相关推荐
ZachOn1y3 分钟前
计算机网络：计算机网络概述 —— 描述计算机网络的参数
网络·tcp/ip·计算机网络·考研必备
我命由我123455 分钟前
SSL 协议（HTTPS 协议的关键）
网络·经验分享·笔记·学习·https·ssl·学习方法
不写八个14 分钟前
Python办公自动化教程（005）：Word添加段落
开发语言·python·word
肖遥Janic16 分钟前
Stable Diffusion绘画 | 插件-Deforum：动态视频生成（上篇）
人工智能·ai·ai作画·stable diffusion
robinfang201923 分钟前
AI在医学领域：Arges框架在溃疡性结肠炎上的应用
人工智能
给自己一个 smile27 分钟前
如何高效使用Prompt与AI大模型对话
人工智能·ai·prompt
_.Switch31 分钟前
Python机器学习框架介绍和入门案例：Scikit-learn、TensorFlow与Keras、PyTorch
python·机器学习·架构·tensorflow·keras·scikit-learn
赵荏苒43 分钟前
Python小白之Pandas1
开发语言·python
两点王爷1 小时前
使用WebClient 快速发起请求（不使用WebClientUtils工具类）
java·网络
魔力之心1 小时前
人工智能与机器学习原理精解【30】
人工智能·机器学习
热门推荐
01【经验分享】Ubuntu22.04安装微信(linux官方版)02安卓系列机型永久去除data分区加密 详细步骤解析032024年高教社杯数学建模国赛C题超详细解题思路分析04组基轨迹建模 GBTM的介绍与实现（Stata 或 R）05RAG 实践- Ollama+RagFlow 部署本地知识库06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07分享几个惊艳的 Three.js 个人站点08苍穹外卖面试总结09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文102024CCPC网络预选赛 I. 找行李 【DP】