YOLOv8改进算法之添加CA注意力机制

1. ca注意力机制

ca（coordinate attention）注意力机制是一种用于加强深度学习模型对输入数据的空间结构理解的注意力机制。ca 注意力机制的核心思想是引入坐标信息，以便模型可以更好地理解不同位置之间的关系。如下图：

1. 输入特征： ca 注意力机制的输入通常是一个特征图，它通常是卷积神经网络（cnn）中的某一层的输出，具有以下形状：[c, h, w]，其中：

• c 是通道数，表示特征图中的不同特征通道。
• h 是高度，表示特征图的垂直维度。
• w 是宽度，表示特征图的水平维度。

2. 全局平均池化： ca 注意力机制首先对输入特征图进行两次全局平均池化，一次在宽度方向上，一次在高度方向上。这两次操作分别得到两个特征映射：

• 在宽度方向上的平均池化得到特征映射 [c, h, 1]。
• 在高度方向上的平均池化得到特征映射 [c, 1, w]。

这两个特征映射分别捕捉了在宽度和高度方向上的全局特征。

3. 合并宽高特征： 将上述两个特征映射合并，通常通过简单的堆叠操作，得到一个新的特征层，形状为 [c, 1, h + w]，其中 h + w 表示在宽度和高度两个方向上的维度合并在一起。

4. 卷积+标准化+激活函数： 对合并后的特征层进行卷积操作，通常是 1x1 卷积，以捕捉宽度和高度维度之间的关系。然后，通常会应用标准化（如批量标准化）和激活函数（如relu）来进一步处理特征，得到一个更加丰富的表示。

5. 再次分开： 分别从上述特征层中分离出宽度和高度方向的特征：

• 一个分支得到特征层 [c, 1, h]。
• 另一个分支得到特征层 [c, 1, w]。

6. 转置： 对分开的两个特征层进行转置操作，以恢复宽度和高度的维度，得到两个特征层分别为 [c, h, 1] 和 [c, 1, w]。

7. 通道调整和 sigmoid： 对两个分开的特征层分别应用 1x1 卷积，以调整通道数，使其适应注意力计算。然后，应用 sigmoid 激活函数，得到在宽度和高度维度上的注意力分数。这些分数用于指示不同位置的重要性。

8. 应用注意力： 将原始输入特征图与宽度和高度方向上的注意力分数相乘，得到 ca 注意力机制的输出。

2. yolov8添加ca注意力机制

加入注意力机制，在ultralytics包中的nn包的modules里添加ca注意力模块，我这里选择在conv.py文件中添加ca注意力机制。

ca注意力机制代码如下:

import torch
import torch.nn as nn
import torch.nn.functional as f


class h_sigmoid(nn.module):
    def __init__(self, inplace=true):
        super(h_sigmoid, self).__init__()
        self.relu = nn.relu6(inplace=inplace)

    def forward(self, x):
        return self.relu(x + 3) / 6


class h_swish(nn.module):
    def __init__(self, inplace=true):
        super(h_swish, self).__init__()
        self.sigmoid = h_sigmoid(inplace=inplace)

    def forward(self, x):
        return x * self.sigmoid(x)


class coordatt(nn.module):
    def __init__(self, inp, reduction=32):
        super(coordatt, self).__init__()
        self.pool_h = nn.adaptiveavgpool2d((none, 1))
        self.pool_w = nn.adaptiveavgpool2d((1, none))

        mip = max(8, inp // reduction)

        self.conv1 = nn.conv2d(inp, mip, kernel_size=1, stride=1, padding=0)
        self.bn1 = nn.batchnorm2d(mip)
        self.act = h_swish()

        self.conv_h = nn.conv2d(mip, inp, kernel_size=1, stride=1, padding=0)
        self.conv_w = nn.conv2d(mip, inp, kernel_size=1, stride=1, padding=0)

    def forward(self, x):
        identity = x

        n, c, h, w = x.size()
        x_h = self.pool_h(x)
        x_w = self.pool_w(x).permute(0, 1, 3, 2)

        y = torch.cat([x_h, x_w], dim=2)
        y = self.conv1(y)
        y = self.bn1(y)
        y = self.act(y)

        x_h, x_w = torch.split(y, [h, w], dim=2)
        x_w = x_w.permute(0, 1, 3, 2)

        a_h = self.conv_h(x_h).sigmoid()
        a_w = self.conv_w(x_w).sigmoid()

        out = identity * a_w * a_h

        return out

ca注意力机制的注册和引用如下：

 ultralytics/nn/modules/_init_.py文件中：

  ultralytics/nn/tasks.py文件夹中：

 在tasks.py中的parse_model中添加如下代码：

        elif m in {coordatt}:
            args=[ch[f],*args]

新建相应的yolov8s-ca.yaml文件，代码如下：

# 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 gflops

# 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,coordatt,[]]
  - [-1, 1, conv, [512, 3, 2]]  # 5-p4/16
  - [-1, 6, c2f, [512, true]]
  - [-1,1,coordatt,[]]
  - [-1, 1, conv, [1024, 3, 2]]  # 7-p5/32
  - [-1, 3, c2f, [1024, true]]
  - [-1,1,coordatt,[]]
  - [-1, 1, sppf, [1024, 5]]  # 9

# yolov8.0n head
head:
  - [-1, 1, nn.upsample, [none, 2, 'nearest']]
  - [[-1, 8], 1, concat, [1]]  # cat backbone p4
  - [-1, 3, c2f, [512]]  # 12

  - [-1, 1, nn.upsample, [none, 2, 'nearest']]
  - [[-1, 5], 1, concat, [1]]  # cat backbone p3
  - [-1, 3, c2f, [256]]  # 15 (p3/8-small)

  - [-1, 1, conv, [256, 3, 2]]
  - [[-1, 15], 1, concat, [1]]  # cat head p4
  - [-1, 3, c2f, [512]]  # 18 (p4/16-medium)

  - [-1, 1, conv, [512, 3, 2]]
  - [[-1, 12], 1, concat, [1]]  # cat head p5
  - [-1, 3, c2f, [1024]]  # 21 (p5/32-large)

  - [[18, 21, 24], 1, detect, [nc]]  # detect(p3, p4, p5)

在main.py文件中进行训练：

if __name__ == '__main__':

    # 使用yaml配置文件来创建模型,并导入预训练权重.
    model = yolo('ultralytics/cfg/models/v8/yolov8s-ca.yaml')
    # model.load('yolov8n.pt')
    model.train(**{'cfg': 'ultralytics/cfg/default.yaml', 'data': 'dataset/data.yaml'})