【即插即用涨点模块】CAA上下文锚点注意力机制：有效捕捉全局信息，助力高效涨点【附源码+注释】

《------往期经典推荐------》

一、AI应用软件开发实战专栏【链接】

二、机器学习实战专栏【链接】，已更新31期，欢迎关注，持续更新中~~
三、深度学习【Pytorch】专栏【链接】
四、【Stable Diffusion绘画系列】专栏【链接】
五、YOLOv8改进专栏【链接】，持续更新中~~
六、YOLO性能对比专栏【链接】，持续更新中~

《------正文------》

论文地址：https://arxiv.org/pdf/2403.06258
代码地址：https://github.com/NUST-Machine-Intelligence-Laboratory/PKINet

摘要

本文提出了一种名为**Poly Kernel Inception Network (PKINet)的轻量级特征提取网络，用于解决遥感图像中目标检测面临的挑战，特别是目标尺度变化大和上下文信息多样的问题。PKINet通过并行使用不同尺度的卷积核来提取多尺度的目标特征，并结合Context Anchor Attention (CAA)**模块来捕获长距离的上下文信息。实验表明，PKINet在四个遥感目标检测基准数据集（DOTA-v1.0、DOTA-v1.5、HRSC2016和DIOR-R）上均取得了优异的性能。

创新点

1. 多尺度卷积核设计：PKINet采用了Inception风格的卷积模块，并行使用不同尺度的卷积核（无空洞卷积）来提取多尺度的纹理特征，避免了传统大卷积核引入的背景噪声和空洞卷积导致的特征稀疏问题。
   

2. Context Anchor Attention (CAA)模块：引入CAA模块，通过全局平均池化和1D条状卷积来捕获长距离的上下文信息，增强中心区域的特征表示。

3. 轻量级设计：通过使用深度可分离卷积和1D卷积，PKINet在保持高性能的同时，显著减少了模型的计算量和参数量。

方法总结

PKINet由四个阶段组成，每个阶段采用Cross-Stage Partial (CSP)**结构，输入特征被分为两部分，分别通过一个简单的**Feed-Forward Network (FFN)**和一系列**PKI Block进行处理。每个PKI Block包含一个PKI Module和一个CAA Module：

1. PKI Module：通过并行的小卷积核和深度可分离卷积提取多尺度的局部特征，并通过1x1卷积进行通道融合，生成具有丰富上下文信息的特征。
2. CAA Module：通过全局平均池化和1D条状卷积捕获长距离的上下文信息，生成注意力权重，用于增强PKI Module的输出特征。

CAA模块的作用

CAA模块的主要作用是捕获长距离的上下文信息，增强中心区域的特征表示。具体来说：

1. 全局平均池化：首先对输入特征进行全局平均池化，提取全局上下文信息。
2. 1D条状卷积：通过水平和垂直方向的1D卷积，近似模拟大卷积核的效果，捕获长距离的像素关系。
3. 注意力机制：通过Sigmoid函数生成注意力权重，用于增强PKI Module的输出特征，从而提升模型对长距离上下文信息的感知能力。
   

通过PKI Module和CAA Module的协同工作，PKINet能够有效地提取具有局部和全局上下文信息的自适应特征，显著提升了遥感目标检测的性能。

CAA源码与注释

# 论文：Poly Kernel Inception Network for Remote Sensing Detection(CVPR 2024)
# 论文地址：https://arxiv.org/pdf/2403.06258
# 代码地址：https://github.com/NUST-Machine-Intelligence-Laboratory/PKINet
# Context Anchor Attention (CAA) module

from typing import Optional
import torch.nn as nn
import torch

class ConvModule(nn.Module):
    def __init__(
            self,
            in_channels: int,
            out_channels: int,
            kernel_size: int,
            stride: int = 1,
            padding: int = 0,
            groups: int = 1,
            norm_cfg: Optional[dict] = None,
            act_cfg: Optional[dict] = None):
        super().__init__()
        layers = []
        # 添加卷积层
        layers.append(nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, groups=groups, bias=(norm_cfg is None)))
        # 添加归一化层（如果配置了）
        if norm_cfg:
            norm_layer = self._get_norm_layer(out_channels, norm_cfg)
            layers.append(norm_layer)
        # 添加激活层（如果配置了）
        if act_cfg:
            act_layer = self._get_act_layer(act_cfg)
            layers.append(act_layer)
        # 将所有层组合成一个顺序容器
        self.block = nn.Sequential(*layers)

    def forward(self, x):
        # 前向传播
        return self.block(x)

    def _get_norm_layer(self, num_features, norm_cfg):
        # 根据配置获取归一化层
        if norm_cfg['type'] == 'BN':
            return nn.BatchNorm2d(num_features, momentum=norm_cfg.get('momentum', 0.1), eps=norm_cfg.get('eps', 1e-5))
        # 如果需要，可以添加更多归一化类型
        raise NotImplementedError(f"Normalization layer '{norm_cfg['type']}' is not implemented.")

    def _get_act_layer(self, act_cfg):
        # 根据配置获取激活层
        if act_cfg['type'] == 'ReLU':
            return nn.ReLU(inplace=True)
        if act_cfg['type'] == 'SiLU':
            return nn.SiLU(inplace=True)
        # 如果需要，可以添加更多激活类型
        raise NotImplementedError(f"Activation layer '{act_cfg['type']}' is not implemented.")

class CAA(nn.Module):
    """Context Anchor Attention"""
    def __init__(
            self,
            channels: int,
            h_kernel_size: int = 11,
            v_kernel_size: int = 11,
            norm_cfg: Optional[dict] = dict(type='BN', momentum=0.03, eps=0.001),
            act_cfg: Optional[dict] = dict(type='SiLU')):
        super().__init__()
        # 平均池化层，用于提取上下文信息
        self.avg_pool = nn.AvgPool2d(7, 1, 3)
        # 第一个卷积模块
        self.conv1 = ConvModule(channels, channels, 1, 1, 0, norm_cfg=norm_cfg, act_cfg=act_cfg)
        # 水平方向的深度可分离卷积模块
        self.h_conv = ConvModule(channels, channels, (1, h_kernel_size), 1, (0, h_kernel_size // 2), groups=channels, norm_cfg=None, act_cfg=None)
        # 垂直方向的深度可分离卷积模块
        self.v_conv = ConvModule(channels, channels, (v_kernel_size, 1), 1, (v_kernel_size // 2, 0), groups=channels, norm_cfg=None, act_cfg=None)
        # 第二个卷积模块
        self.conv2 = ConvModule(channels, channels, 1, 1, 0, norm_cfg=norm_cfg, act_cfg=act_cfg)
        # Sigmoid激活函数，用于生成注意力权重
        self.act = nn.Sigmoid()

    def forward(self, x):
        # 前向传播过程
        # 1. 通过平均池化层提取上下文信息
        # 2. 通过conv1卷积模块
        # 3. 通过h_conv进行水平方向的深度可分离卷积
        # 4. 通过v_conv进行垂直方向的深度可分离卷积
        # 5. 通过conv2卷积模块
        # 6. 通过Sigmoid激活函数生成注意力权重
        attn_factor = self.act(self.conv2(self.v_conv(self.h_conv(self.conv1(self.avg_pool(x))))))
        return attn_factor

# 示例用法，打印输入和输出的形状
if __name__ == "__main__":
    input = torch.randn(1, 64, 128, 128) # 输入 B C H W
    block = CAA(64)
    output = block(input)
    print(input.size())
    print(output.size())

好了，这篇文章就介绍到这里，喜欢的小伙伴感谢给点个赞和关注，更多精彩内容持续更新~~
关于本篇文章大家有任何建议或意见，欢迎在评论区留言交流！