论文信息
标题: Poly Kernel Inception Network for Remote Sensing Detection
作者: Xinhao Cai, Qiuxia Lai, Yuwei Wang, Wenguan Wang, Zeren Sun, Yazhou Yao
论文链接：https://arxiv.org/pdf/2403.06258
代码链接：https://github.com/NUST-Machine-Intelligence-Laboratory/PKINet
创新点
Poly Kernel Inception Network (PKINet) 的主要创新在于其设计的卷积结构，旨在解决遥感图像目标检测中的几个关键挑战：
-
多尺度特征提取: PKINet采用无膨胀的多尺度卷积核，能够有效提取不同尺度的目标特征，避免了传统大核卷积带来的背景噪声问题。
-
上下文锚定注意力机制: 引入了上下文锚定注意（CAA）模块，以捕获远程上下文信息，增强特征提取的能力。
-
轻量化设计: 通过并行使用深度卷积和1×1卷积，PKINet在保持高性能的同时，显著降低了模型的复杂性和计算成本。
方法
PKINet的核心方法包括以下几个方面：
-
无膨胀多尺度卷积: 通过使用不同大小的卷积核，PKINet能够在不同的感受野中提取丰富的纹理特征，而不依赖于膨胀卷积。
-
上下文锚定注意力模块: CAA模块通过全局平均池化和一维卷积，捕获远程像素之间的关系，增强了中心特征的表达能力。
-
自适应特征融合: 通过通道维度的自适应融合，PKINet能够有效整合局部和全局上下文信息，从而提高目标检测的准确性。
无膨胀多尺度卷积PKI 模块详解
Poly Kernel Inception Network (PKINet) 中的 PKI Module 是其核心组成部分，旨在有效提取遥感图像中的多尺度特征。以下是对 PKI Module 的详细解读，包括其设计理念、结构、功能和实验结果。
设计理念
PKI 模块的设计旨在解决遥感图像目标检测中面临的挑战，尤其是目标尺度的巨大变化和复杂背景。与传统方法不同，PKI 模块采用无膨胀的多尺度卷积核，以避免引入背景噪声，同时有效捕获局部上下文信息。
结构
PKI 模块主要由以下几个部分组成：
-
小卷积核:
- 使用小卷积核（如 3 × 3 3 \times 3 3×3）提取局部特征，能够有效捕捉细节信息。
-
深度可分离卷积:
- 采用一系列并行的深度可分离卷积（Depth-wise Convolutions），以捕获不同尺度的上下文信息。这种设计不仅减少了计算复杂度，还提高了特征提取的效率。
-
多尺度特征提取:
- PKI 模块通过组合不同大小的卷积核（如 3 × 3 3 \times 3 3×3, 5 × 5 5 \times 5 5×5, 7 × 7 7 \times 7 7×7 等），实现对多尺度特征的提取，增强了模型对不同尺寸目标的适应能力。
功能
PKI 模块的主要功能包括：
-
多尺度特征提取: 通过不同大小的卷积核，PKI 模块能够有效提取不同尺度的目标特征，适应遥感图像中目标的多样性。
-
上下文信息捕获: 通过深度可分离卷积，PKI 模块能够捕获局部上下文信息，增强特征的表达能力。
-
避免背景噪声: 由于不使用膨胀卷积，PKI 模块能够避免过于稀疏的特征表示，从而提高检测精度。
PKI 模块是 PKINet 的核心组件，通过创新的多尺度卷积设计和深度可分离卷积结构，有效提升了遥感图像目标检测的性能。其在特征提取和上下文信息捕获方面的优势，使得 PKINet 在多个基准数据集上取得了优异的表现，展示了其在实际应用中的潜力。
效果
在多个遥感目标检测基准数据集上进行的实验表明，PKINet在性能上优于传统方法，尤其是在处理目标尺度变化和复杂背景时表现突出。具体来说，PKINet在以下数据集上取得了显著的检测效果：
- DOTA-v1.0
- DOTA-v1.5
- HRSC2016
- DIOR-R
这些实验结果表明，PKINet不仅提高了检测精度，还在处理速度上也有良好的表现。
实验结果
实验中，PKINet在多个标准数据集上进行了广泛的评估，结果显示：
-
检测精度: PKINet在各个数据集上均表现出色，尤其是在小目标和复杂背景下的检测能力显著提升。
-
模型效率: 由于其轻量化设计，PKINet在计算资源的使用上更为高效，适合实际应用场景。
-
对比分析: 与传统的目标检测模型相比，PKINet在多个指标上均有明显的优势，尤其是在处理多样化的上下文环境时。
总结
Poly Kernel Inception Network (PKINet) 通过创新的卷积结构和上下文注意力机制，成功应对了遥感图像目标检测中的多种挑战。其在特征提取和上下文信息捕获方面的优势，使得PKINet在多个基准数据集上取得了优异的性能，展示了其在实际应用中的潜力。未来的研究可以进一步探索PKINet在其他计算机视觉任务中的应用，以及如何进一步优化其结构以提升性能。
代码
import torch
import torch.nn as nn
from mmcv.cnn import ConvModule
from mmengine.model import BaseModule
from typing import Optional, Union, Sequence
import math
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
def make_divisible(x, divisor):
# Returns nearest x divisible by divisor
if isinstance(divisor, torch.Tensor):
divisor = int(divisor.max()) # to int
return math.ceil(x / divisor) * divisor
class GSiLU(BaseModule):
"""Global Sigmoid-Gated Linear Unit, reproduced from paper <SIMPLE CNN FOR VISION>"""
def __init__(self):
super().__init__()
self.adpool = nn.AdaptiveAvgPool2d(1)
def forward(self, x):
return x * torch.sigmoid(self.adpool(x))
class CAA(BaseModule):
"""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'),
init_cfg: Optional[dict] = None,
):
super().__init__(init_cfg)
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)
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 x*attn_factor
class InceptionBottleneck(BaseModule):
"""Bottleneck with Inception module"""
def __init__(
self,
in_channels: int,
out_channels: Optional[int] = None,
kernel_sizes: Sequence[int] = (3, 5, 7, 9, 11),
dilations: Sequence[int] = (1, 1, 1, 1, 1),
expansion: float = 1.0,
add_identity: bool = True,
with_caa: bool = True,
caa_kernel_size: int = 11,
norm_cfg: Optional[dict] = dict(type='BN', momentum=0.03, eps=0.001),
act_cfg: Optional[dict] = dict(type='SiLU'),
init_cfg: Optional[dict] = None,
):
super().__init__(init_cfg)
out_channels = out_channels or in_channels
hidden_channels = make_divisible(int(out_channels * expansion), 8)
self.pre_conv = ConvModule(in_channels, hidden_channels, 1, 1, 0, 1,
norm_cfg=norm_cfg, act_cfg=act_cfg)
self.dw_conv = ConvModule(hidden_channels, hidden_channels, kernel_sizes[0], 1,
autopad(kernel_sizes[0], None, dilations[0]), dilations[0],
groups=hidden_channels, norm_cfg=None, act_cfg=None)
self.dw_conv1 = ConvModule(hidden_channels, hidden_channels, kernel_sizes[1], 1,
autopad(kernel_sizes[1], None, dilations[1]), dilations[1],
groups=hidden_channels, norm_cfg=None, act_cfg=None)
self.dw_conv2 = ConvModule(hidden_channels, hidden_channels, kernel_sizes[2], 1,
autopad(kernel_sizes[2], None, dilations[2]), dilations[2],
groups=hidden_channels, norm_cfg=None, act_cfg=None)
self.dw_conv3 = ConvModule(hidden_channels, hidden_channels, kernel_sizes[3], 1,
autopad(kernel_sizes[3], None, dilations[3]), dilations[3],
groups=hidden_channels, norm_cfg=None, act_cfg=None)
self.dw_conv4 = ConvModule(hidden_channels, hidden_channels, kernel_sizes[4], 1,
autopad(kernel_sizes[4], None, dilations[4]), dilations[4],
groups=hidden_channels, norm_cfg=None, act_cfg=None)
self.pw_conv = ConvModule(hidden_channels, hidden_channels, 1, 1, 0, 1,
norm_cfg=norm_cfg, act_cfg=act_cfg)
if with_caa:
self.caa_factor = CAA(hidden_channels, caa_kernel_size, caa_kernel_size, None, None)
else:
self.caa_factor = None
self.add_identity = add_identity and in_channels == out_channels
self.post_conv = ConvModule(hidden_channels, out_channels, 1, 1, 0, 1,
norm_cfg=norm_cfg, act_cfg=act_cfg)
def forward(self, x):
x = self.pre_conv(x)
y = x # if there is an inplace operation of x, use y = x.clone() instead of y = x
x = self.dw_conv(x)
x = x + self.dw_conv1(x) + self.dw_conv2(x) + self.dw_conv3(x) + self.dw_conv4(x)
x = self.pw_conv(x)
if self.caa_factor is not None:
y = self.caa_factor(y)
if self.add_identity:
y = x * y
x = x + y
else:
x = x * y
x = self.post_conv(x)
return x
if __name__ == "__main__":
# 如果GPU可用，将模块移动到 GPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# 输入张量 (batch_size, height, width,channels)
x = torch.randn(1,32,40,40).to(device)
# 初始化 HWD 模块
dim=32
block = InceptionBottleneck(32)
print(block)
block = block.to(device)
# 前向传播
output = block(x)
print("输入:", x.shape)
print("输出:", output.shape)
输出结果：
![[OO ALV] OO ALV 基础显示](https://i-blog.csdnimg.cn/direct/0ac31bfd2d26460eb4c242694dbd30d4.png)
