YOLO11改进|注意力机制篇|引入上下文锚注意力机制CAA

如果能为勤奋颁奖

于 2024-10-06 11:24:32 发布

阅读量373

点赞数 5

分类专栏： YOLO11改进专栏文章标签：深度学习人工智能 YOLO

本文链接：https://blog.csdn.net/A1983Z/article/details/142724520

版权

YOLO11改进专栏专栏收录该内容

16 篇文章 1 订阅

订阅专栏

在这里插入图片描述

一、【CAA】注意力机制

1.1【CAA】注意力介绍

在这里插入图片描述

CAA注意力机制的结构图如下，下面根据其结构分析处理过程与优势

处理过程
输入：CAA模块接收来自上一个阶段的特征图 𝑋𝑙−1,𝑛(2)，并将其进行处理。图中显示了如果 𝑛=0，则输入是 𝑋𝑙−1,𝑛(2)，而如果 𝑛≠0，输入将会是分割后沿通道维度的特征。
池化层 (AvgPool)：首先，特征图通过一个全局平均池化层
AvgPool，其作用是通过全局空间信息来减少特征图的空间维度，这能够提取出全局上下文信息。
1x1卷积 (Conv 1x1)：池化后的特征图通过1x1卷积层。1x1卷积通常用于降维或融合特征，它可以改变通道数量并用于生成空间相关性。
深度可分离卷积 (DWConv)：模块使用了 (11+2𝑛)×1和 1×(11+2𝑛)的深度可分离卷积 (Depthwise Convolution, DWConv)。这种卷积操作是一种计算量较少的卷积方法，它能够保留每个通道的特征，同时减少参数量。11+2n 的内核大小表明随着网络层的加深，卷积的感受野会增大，逐步捕捉更大的上下文信息。
Sigmoid激活函数：卷积操作后的特征图经过Sigmoid激活函数，将结果限制在0到1之间，用于生成特征图的注意力权重。
输出：最终，生成的注意力图 𝐴𝑙−1,𝑛 将与特征图进行加权融合，调整不同区域的重要性，输出调整后的特征图。
优势
跨层特征融合：CAA模块通过池化、卷积和Sigmoid等操作，生成了一个加权注意力图，使得特征图中的不同区域能够根据其全局上下文信息进行加权，从而对不同重要性的特征进行选择性加强或抑制。
增强感受野：通过 11+2𝑛大小的卷积核，CAA模块能够有效扩大卷积操作的感受野，从而捕捉更大范围的上下文信息。这种特性使得它在处理包含大量局部与全局信息的任务中表现良好。
计算效率：使用深度可分离卷积（DWConv）代替传统的标准卷积，大幅减少了计算复杂度和参数量，同时保持了良好的特征提取能力。通过将卷积操作分解为深度卷积和点卷积，这种方式能够在较低的计算成本下获得较大的感受野和丰富的特征表达能力。
灵活的通道操作：CAA模块使用了多个卷积层和通道级的操作，这有助于模型在不同层次上对特征进行调整，从而增加模型在通道维度上的表达能力。

在这里插入图片描述

1.2【CAA】核心代码

import torch.nn as nn
import torch
 
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 CAA(nn.Module):
    def __init__(self, ch, h_kernel_size=11, v_kernel_size=11) -> None:
        super().__init__()
 
        self.avg_pool = nn.AvgPool2d(7, 1, 3)
        self.conv1 = Conv(ch, ch)
        self.h_conv = nn.Conv2d(ch, ch, (1, h_kernel_size), 1, (0, h_kernel_size // 2), 1, ch)
        self.v_conv = nn.Conv2d(ch, ch, (v_kernel_size, 1), 1, (v_kernel_size // 2, 0), 1, ch)
        self.conv2 = Conv(ch, ch)
        self.act = nn.Sigmoid()
 
    def forward(self, x):
        attn_factor = self.act(self.conv2(self.v_conv(self.h_conv(self.conv1(self.avg_pool(x))))))
        return attn_factor * 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
 
    def forward(self, x):
        """'forward()' applies the YOLO FPN to input data."""
        return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))
 
 
 
class C2f_CAA(nn.Module):
    """CSP Bottleneck with 2 convolutions followed by CAA attention."""
 
    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
        """Initialize CSP bottleneck layer with two convolutions with CAA attention."""
        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))
        self.caa = CAA(c2)
 
    def forward(self, x):
        """Forward pass through C2f layer followed by CAA attention."""
        y = list(self.cv1(x).chunk(2, 1))
        y.extend(m(y[-1]) for m in self.m)
        out = self.cv2(torch.cat(y, 1))
        return self.caa(out)
 
    def forward_split(self, x):
        """Forward pass using split() instead of chunk() followed by CAA attention."""
        y = list(self.cv1(x).split((self.c, self.c), 1))
        y.extend(m(y[-1]) for m in self.m)
        out = self.cv2(torch.cat(y, 1))
        return self.caa(out)

二、添加【CAA】注意力机制

2.1STEP1

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

2.2STEP2

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

2.3STEP3

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

2.4STEP4

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

在这里插入图片描述

三、yaml文件与运行

3.1yaml文件

以下是添加【CAA】注意力机制在小目标检测中的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, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  - [-1, 2, C3k2, [512, False]] # 13

  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  - [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)
  - [-1,1,CAA,[]]

  - [-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)



  - [[17, 20, 23], 1, Detect, [nc]] # Detect(P3, P4, P5)