YOLO11改进|上采样篇|引入CARAFE上采样模块

在这里插入图片描述

一、CARAFE上采样模块

1.1CARAFE上采样模块介绍

在这里插入图片描述

CARAFE 的主要思想：将特征图的上采样运算看做是特征重组的过程。对于输出特征图中的每个像素点 L’，我们都可以找到它在输入特征图中的对应位置 L，L’ 这个点的值可以表示成以输入特征图中以 L 为中心的一个邻域内的像素和一个上采样核的点积（加权和）。以双线性上采样为例，输出特征图中每个像素可以看作是一个 2x2 的上采样核和输入特征图中一个 2x2 的邻域的点积。
主要模块功能与优势如下

Kernel Prediction Module
Channel Compressor：首先对输入特征图 𝑋X进行通道压缩，生成低维表示 𝑋𝑚 ，该压缩操作减少了计算量，并保留了关键信息。Content Encoder：随后通过内容编码器对压缩后的特征进行编码，生成对应的动态核。这个核的大小取决于 𝑘𝑢𝑝，是为特定位置动态生成的。Kernel Normalizer：最后，生成的核会经过归一化处理，确保在不同位置上具有一致的行为，避免出现偏差。
优势：这个模块的动态核生成机制能够根据输入特征自适应地调整过滤器，在不同的输入特征下自动优化特征提取过程，使得模型更具灵活性和适应性，特别是对于非均匀特征和复杂的纹理模式。
Content-aware Reassembly Module
Reassembly Operation：该模块的核心是内容感知重组操作。在这里，输入的特征图 𝑋会与之前预测的动态核进行交互，生成局部区域的卷积结果。对于每个输入特征，都会生成一个新的重组特征。Reassembly 操作会结合不同位置的信息，并通过特定的核进行特征融合，从而生成一个新的特征图 𝑋′，这个特征图拥有更丰富的局部和全局特征。
优势：内容感知重组模块可以根据输入特征的内容自适应地调整不同位置的特征表示。这样不仅能够捕捉到更多局部细节，同时还能够整合不同位置的上下文信息，增强模型对复杂场景和细微变化的感知能力。
结构图如下：

在这里插入图片描述

1.2CARAFE核心代码

import torch
import torch.nn as nn
from ultralytics.nn.modules import Conv
 
 
class CARAFE(nn.Module):
    def __init__(self, c, k_enc=3, k_up=5, c_mid=64, scale=2):
        """ The unofficial implementation of the CARAFE module.
        The details are in "https://arxiv.org/abs/1905.02188".
        Args:
            c: The channel number of the input and the output.
            c_mid: The channel number after compression.
            scale: The expected upsample scale.
            k_up: The size of the reassembly kernel.
            k_enc: The kernel size of the encoder.
        Returns:
            X: The upsampled feature map.
        """
        super(CARAFE, self).__init__()
        self.scale = scale
 
        self.comp = Conv(c, c_mid)
        self.enc = Conv(c_mid, (scale * k_up) ** 2, k=k_enc, act=False)
        self.pix_shf = nn.PixelShuffle(scale)
 
        self.upsmp = nn.Upsample(scale_factor=scale, mode='nearest')
        self.unfold = nn.Unfold(kernel_size=k_up, dilation=scale,
                                padding=k_up // 2 * scale)
 
    def forward(self, X):
        b, c, h, w = X.size()
        h_, w_ = h * self.scale, w * self.scale
 
        W = self.comp(X)  # b * m * h * w
        W = self.enc(W)  # b * 100 * h * w
        W = self.pix_shf(W)  # b * 25 * h_ * w_
        W = torch.softmax(W, dim=1)  # b * 25 * h_ * w_
 
        X = self.upsmp(X)  # b * c * h_ * w_
        X = self.unfold(X)  # b * 25c * h_ * w_
        X = X.view(b, c, -1, h_, w_)  # b * 25 * c * h_ * w_
 
        X = torch.einsum('bkhw,bckhw->bchw', [W, X])  # b * c * h_ * w_
        return X

五、添加MLCA注意力机制

5.1STEP1

首先找到ultralytics/nn文件路径下新建一个Add-module的python文件包【这里注意一定是python文件包，新建后会自动生成_init_.py】，如果已经跟着我的教程建立过一次了可以省略此步骤，随后新建一个CARAFE.py文件并将上文中提到的注意力机制的代码全部粘贴到此文件中，如下图所示在这里插入图片描述

5.2STEP2

在STEP1中新建的_init_.py文件中导入增加改进模块的代码包如下图所示在这里插入图片描述

5.3STEP3

找到ultralytics/nn文件夹中的task.py文件，在其中按照下图添加在这里插入图片描述

5.4STEP4

定位到ultralytics/nn文件夹中的task.py文件中的def parse_model(d, ch, verbose=True): # model_dict, input_channels(3)函数添加如图代码,【如果不好定位可以直接ctrl+f搜索定位】

在这里插入图片描述

        elif m is CARAFE:
            c1, c2 = ch[f], args[0]
            if c2 != nc:
                c2 = make_divisible(min(c2, max_channels) * width, 8)
            args = [c1, c2, *args[1:]]

六、yaml文件与运行

6.1yaml文件

以下是添加CARAFE的yaml文件，大家可以注释自行调节，效果以自己的数据集结果为准

# Ultralytics YOLO 🚀, AGPL-3.0 license
# YOLO11 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=yolo11n.yaml' will call yolo11.yaml with scale 'n'
  # [depth, width, max_channels]
  n: [0.50, 0.25, 1024] # summary: 319 layers, 2624080 parameters, 2624064 gradients, 6.6 GFLOPs
  s: [0.50, 0.50, 1024] # summary: 319 layers, 9458752 parameters, 9458736 gradients, 21.7 GFLOPs
  m: [0.50, 1.00, 512] # summary: 409 layers, 20114688 parameters, 20114672 gradients, 68.5 GFLOPs
  l: [1.00, 1.00, 512] # summary: 631 layers, 25372160 parameters, 25372144 gradients, 87.6 GFLOPs
  x: [1.00, 1.50, 512] # summary: 631 layers, 56966176 parameters, 56966160 gradients, 196.0 GFLOPs

# YOLO11n 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, 2, C3k2, [256, False, 0.25]]
  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  - [-1, 2, C3k2, [512, False, 0.25]]
  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  - [-1, 2, C3k2, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  - [-1, 2, C3k2, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]] # 9
  - [-1, 2, C2PSA, [1024]] # 10

# YOLO11n head
head:
  - [-1, 1, CARAFE, [1024,3,2]]
  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  - [-1, 2, C3k2, [512, False]] # 13

  - [-1, 1, CARAFE ,[512,3,2]]
  - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  - [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 13], 1, Concat, [1]] # cat head P4
  - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 10], 1, Concat, [1]] # cat head P5
  - [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)

  - [[16, 19, 22], 1, Detect, [nc]] # Detect(P3, P4, P5)