YOLOv5/v7 添加注意力机制，30多种模块分析⑦，CCN模块，GAMAttention模块

- 一、注意力机制介绍
- - 1、什么是注意力机制？
  - 2、注意力机制的分类
  - 3、注意力机制的核心
- 二、CCN模块
- - 1、CCN模块的原理
  - 2、实验结果
  - 3、应用示例
- 三、GAMAttention模块
- - 1、GAMAttention模块的原理
  - 2、实验结果
  - 3、应用示例

大家好，我是哪吒。

🏆本文收录于，目标检测YOLO改进指南。

本专栏均为全网独家首发，内附代码，可直接使用，改进的方法均是2023年最近的模型、方法和注意力机制。每一篇都做了实验，并附有实验结果分析，模型对比。

在机器学习和自然语言处理领域，随着数据的不断增长和任务的复杂性提高，传统的模型在处理长序列或大型输入时面临一些困难。传统模型无法有效地区分每个输入的重要性，导致模型难以捕捉到与当前任务相关的关键信息。为了解决这个问题，注意力机制（Attention Mechanism）应运而生。

一、注意力机制介绍

1、什么是注意力机制？

注意力机制（Attention Mechanism）是一种在机器学习和自然语言处理领域中广泛应用的重要概念。它的出现解决了模型在处理长序列或大型输入时的困难，使得模型能够更加关注与当前任务相关的信息，从而提高模型的性能和效果。

本文将详细介绍注意力机制的原理、应用示例以及应用示例。

2、注意力机制的分类

类别	描述
全局注意力机制（Global Attention）	在计算注意力权重时，考虑输入序列中的所有位置或元素，适用于需要全局信息的任务。
局部注意力机制（Local Attention）	在计算注意力权重时，只考虑输入序列中的局部区域或邻近元素，适用于需要关注局部信息的任务。
自注意力机制（Self Attention）	在计算注意力权重时，根据输入序列内部的关系来决定每个位置的注意力权重，适用于序列中元素之间存在依赖关系的任务。
Bahdanau 注意力机制	全局注意力机制的一种变体，通过引入可学习的对齐模型，对输入序列的每个位置计算注意力权重。
Luong 注意力机制	全局注意力机制的另一种变体，通过引入不同的计算方式，对输入序列的每个位置计算注意力权重。
Transformer 注意力机制	自注意力机制在Transformer模型中的具体实现，用于对输入序列中的元素进行关联建模和特征提取。

3、注意力机制的核心

注意力机制的核心思想是根据输入的上下文信息来动态地计算每个输入的权重。这个过程可以分为三个关键步骤：计算注意力权重、对输入进行加权和输出。首先，计算注意力权重是通过将输入与模型的当前状态进行比较，从而得到每个输入的注意力分数。这些注意力分数反映了每个输入对当前任务的重要性。对输入进行加权是将每个输入乘以其对应的注意力分数，从而根据其重要性对输入进行加权。最后，将加权后的输入进行求和或者拼接，得到最终的输出。注意力机制的关键之处在于它允许模型在不同的时间步或位置上关注不同的输入，从而捕捉到与任务相关的信息。

🏆YOLOv5/v7 添加注意力机制，30多种模块分析①，SE模块，SK模块

🏆YOLOv5/v7 添加注意力机制，30多种模块分析②，BAM模块，CBAM模块

🏆YOLOv5/v7 添加注意力机制，30多种模块分析③，GCN模块，DAN模块

🏆YOLOv5/v7 添加注意力机制，30多种模块分析④，CA模块，ECA模块

🏆YOLOv5/v7 添加注意力机制，30多种模块分析⑤，SOCA模块，SimAM模块

🏆YOLOv5/v7 添加注意力机制，30多种模块分析⑥，S2-MLPv2模块，NAM模块

二、CCN模块

1、CCN模块的原理

在这里插入图片描述
两种基于注意力的上下文聚合方法的图示：

(a) 对于每个位置（例如蓝色），非局部模块[9]生成一个密集的注意力图，其中有N个权重（绿色）。

(b) 对于每个位置（例如蓝色），十字交叉注意力模块生成一个稀疏的注意力图，其中只有大约2√N个权重。在经过循环操作后，最终输出特征映射中的每个位置（例如红色）都可以从所有像素中收集信息。出于清晰展示的目的，残差连接被忽略。

CCNet语义分割概述：

在这里插入图片描述

细节交叉注意模块：

在这里插入图片描述

2、实验结果

在这里插入图片描述
在ADE20K验证集上展示了使用/不使用分类一致性损失（CCL）的可视化示例。

与其他注意力模块比较：

在这里插入图片描述

3、应用示例

以下使用CCN模块的应用示例：

import torch.nn as nn

class CCN(nn.Module):
    def __init__(self, c1, c2, k=3, s=1, g=1, e=False):
        super().__init__()
        self.cv1 = nn.Conv2d(c1, c2, k, s, k//2, groups=g, bias=False)
        self.bn1 = nn.BatchNorm2d(c2)
        self.act = nn.LeakyReLU(0.1, inplace=True)
        self.e = nn.Conv2d(c2, c1, 1, 1, 0) if e else None

    def forward(self, x):
        y = self.act(self.bn1(self.cv1(x)))
        return x + self.e(y) if self.e else x + y

这段代码定义了一个名为CCN的类，其中包含了一个卷积层、一个批归一化层和一个LeakyReLU激活函数。该模块可以接收输入张量x，并返回经过CCN处理后的输出张量。通过组卷积，CCN模块可以在不增加参数数量的情况下增强网络的表达能力。同时，该模块可以学习权重以适应不同尺度的特征。在YOLOv5中，通过堆叠多个CCN模块来构建主干网络。

三、GAMAttention模块

1、GAMAttention模块的原理

在这里插入图片描述

GAMAttention（Global Attention with Multi-head）是一种注意力机制模块，用于处理序列数据中的关系建模和特征融合问题。其原理基于transformer中的self-attention机制。

GAMAttention包含三个主要部分：全局池化、多头注意力和残差连接。全局池化将输入序列转换为一个全局表示，以便在后续的计算中进行使用。多头注意力机制使用多个不同的权重矩阵对全局表示进行线性变换，生成多个query、key和value向量。这些向量被输入到每个注意力头中，并通过Softmax函数计算相关性得分，以便对信息进行加权聚合。最后，利用残差连接将注意力输出与输入序列进行融合。

在这里插入图片描述

2、实验结果

在这里插入图片描述

3、应用示例

以下使用GAMAttention模块的应用示例：

import torch.nn as nn

class GAMAttention(nn.Module):
    def __init__(self, in_channels):
        super(GAMAttention, self).__init__()
        self.conv = nn.Conv2d(in_channels, in_channels, kernel_size=1, stride=1)
        self.bn = nn.BatchNorm2d(in_channels)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        avg_pool = nn.AdaptiveAvgPool2d(1)(x)
        x = self.conv(avg_pool)
        x = self.bn(x)
        x = self.sigmoid(x)
        return x * x

在YOLOv5中，GAMAttention模块被应用于残差块中的第二个卷积层。例如，在YOLOv5s模型中，一个标准的残差块如下所示：

class ResBlock(nn.Module):
    def __init__(self, channels, hidden_channels=None):
        super().__init__()
        if hidden_channels is None:
            hidden_channels = channels
        self.block = nn.Sequential(
            Focus(channels, hidden_channels, 1),
            nn.Conv2d(hidden_channels, channels, 3, 1, 1, bias=False),
            nn.BatchNorm2d(channels),
            nn.ReLU(inplace=True),
            GAMAttention(channels), # 在第二个卷积层应用GAMAttention模块
            nn.Conv2d(channels, channels, 1, 1, bias=False),
            nn.BatchNorm2d(channels),
        )

    def forward(self, x):
        return x + self.block(x)