当前位置： 首页 > article >正文

【Block总结】MDCR，多尺度深度可分离卷积，捕捉不同感受野范围的空间特征

article 2025/2/6 10:46:56

论文信息

HCF-Net（Hierarchical Context Fusion Network）是一种新提出的深度学习模型，专门用于红外小目标检测。该论文于2024年3月16日发布，作者包括Shibiao Xu、ShuChen Zheng等，主要研究机构为北京邮电大学。该模型旨在提高红外图像中微小目标的识别和定位能力，尤其是在复杂背景下。

  • 论文链接：https://arxiv.org/pdf/2403.10778
  • 官方GitHub代码：https://github.com/zhengshuchen/HCFNet

在这里插入图片描述

创新点

HCF-Net的主要创新包括：

  • 并行化补丁感知注意力（PPA）模块：通过多分支特征提取策略，捕获不同尺度和层次的特征信息，增强小目标的表示能力。

  • 维度感知选择性融合（DASI）模块：实现自适应的通道选择和融合，优化特征信息的整合，提高模型的灵活性和准确性。

  • 多膨胀通道细化器（MDCR）模块：通过多层深度可分离卷积捕捉不同感受野范围的空间特征，增强对小目标的定位能力。

这些模块的结合使得HCF-Net在处理红外小目标检测时，能够有效应对小目标丢失和背景复杂度高的问题。

方法

HCF-Net采用了一种升级版的U-Net架构，主要由三个关键模块组成：

  1. PPA模块：

    • 采用多分支特征提取策略，分别提取局部和全局特征。
    • 通过注意力机制增强特征表示，确保在多次下采样过程中保留关键信息。

  2. DASI模块：

    • 通过自适应选择和融合高维与低维特征，增强小目标的显著性。
    • 采用通道分割选择机制，根据目标的大小和特征自适应选择合适的特征进行融合。

  3. MDCR模块：

    • 引入多个深度可分离卷积层，捕捉不同感受野范围的空间特征。
    • 通过通道分割和重组增强特征表示，提升小目标的辨识能力。
      在这里插入图片描述

MDCR模块解读

概述

MDCR（Multi-Dilated Channel Refiner）模块是HCF-Net中的关键组成部分，旨在通过多种扩张率的深度可分离卷积层来捕捉不同感受野大小下的空间特征，从而增强对红外小目标的辨识能力。该模块通过细致建模目标与背景之间的差异，提升了小目标的检测性能。

主要功能

  1. 多感受野特征提取：

    • MDCR模块通过引入多个具有不同膨胀率的深度可分离卷积层，能够在不同的感受野范围内提取空间特征。这种设计使得网络能够更好地理解红外图像中目标的上下文和细节。

  2. 通道分割与重组：

    • 输入特征首先沿通道维度被划分为多个头部（通常为四个），每个头部对应特定的特征集合。每个头部独立进行深度可分离卷积，生成不同的特征表示。随后，这些特征被交错排列，以增强多尺度特征的多样性。

  3. 轻量级高效聚合：

    • MDCR模块通过逐点卷积实现组内和组间信息的融合，最终生成输出特征。这种聚合方式不仅提高了特征表示的有效性，还保持了计算的高效性。

具体实现

  • 输入特征划分：
    输入特征 F a ∈ R H × W × C \mathbf{F}_a \in \mathbb{R}^{H \times W \times C} Fa​∈RH×W×C 被分割成四个部分，生成 a i ∈ R H × W × C 4 \mathbf{a}_i \in \mathbb{R}^{H \times W \times \frac{C}{4}} ai​∈RH×W×4C​，其中 i i i 从1到4。

  • 深度可分离卷积：
    每个头部应用不同的膨胀率进行深度可分离卷积，得到特征 a i ′ \mathbf{a}^{\prime}_i ai′​。这些卷积的膨胀率分别标记为 d 1 , d 2 , d 3 , d 4 d_1, d_2, d_3, d_4 d1​,d2​,d3​,d4​。

  • 特征增强与输出：
    通过对各个头部的特征进行处理，MDCR模块最终生成输出特征 F o ∈ R H × W × C \mathbf{F}_o \in \mathbb{R}^{H \times W \times C} Fo​∈RH×W×C，实现轻量级且高效的特征聚合。

MDCR模块通过多膨胀率的深度可分离卷积和通道分割重组策略，增强了HCF-Net在红外小目标检测中的特征表示能力。其设计不仅提高了小目标的检测精度，还确保了计算效率，为红外图像处理提供了强有力的支持。

效果

HCF-Net在SIRST红外单帧图像数据集上的实验结果表明，该模型在红外小目标检测任务中表现优异，超越了其他传统和深度学习模型。具体而言，HCF-Net在小目标的识别和定位上具有显著的优势，能够有效减少小目标在复杂背景下的丢失率。

实验结果

  • 数据集: HCF-Net在SIRST数据集上进行评估。
  • 性能指标: HCF-Net在IoU（Intersection over Union）和nIoU（normalized IoU）上分别达到80.09%和78.31%，显著优于其他方法。
  • 对比实验: 与传统方法和其他深度学习模型相比，HCF-Net在多个指标上均表现出色，验证了其设计的有效性和实用性。

总结

HCF-Net通过创新的模块设计和深度学习方法，显著提升了红外小目标检测的性能。其在处理小目标丢失和背景复杂度高的问题上展现了良好的能力，为未来的研究和应用提供了新的思路和方向。该模型的成功应用不仅推动了红外图像处理技术的发展，也为相关领域的实际应用提供了强有力的支持。

代码

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



class conv_block(nn.Module):
    def __init__(self,
                 in_features,
                 out_features,
                 kernel_size=(3, 3),
                 stride=(1, 1),
                 padding=(1, 1),
                 dilation=(1, 1),
                 norm_type='bn',
                 activation=True,
                 use_bias=True,
                 groups = 1
                 ):
        super().__init__()
        self.conv = nn.Conv2d(in_channels=in_features,
                              out_channels=out_features,
                              kernel_size=kernel_size,
                              stride=stride,
                              padding=padding,
                              dilation=dilation,
                              bias=use_bias,
                              groups = groups)

        self.norm_type = norm_type
        self.act = activation

        if self.norm_type == 'gn':
            self.norm = nn.GroupNorm(32 if out_features >= 32 else out_features, out_features)
        if self.norm_type == 'bn':
            self.norm = nn.BatchNorm2d(out_features)
        if self.act:
            # self.relu = nn.GELU()
            self.relu = nn.ReLU(inplace=False)


    def forward(self, x):
        x = self.conv(x)
        if self.norm_type is not None:
            x = self.norm(x)
        if self.act:
            x = self.relu(x)
        return x




class MDCR(nn.Module):
    def __init__(self, in_features, out_features, norm_type='bn', activation=True, rate=[1, 4, 8, 16]):
        super().__init__()

        self.block1 = conv_block(
            in_features=in_features//4,
            out_features=out_features//4,
            padding=rate[0],
            dilation=rate[0],
            norm_type=norm_type,
            activation=activation,
            groups = 128
            )
        self.block2 = conv_block(
            in_features=in_features//4,
            out_features=out_features//4,
            padding=rate[1],
            dilation=rate[1],
            norm_type=norm_type,
            activation=activation,
            groups=128
            )
        self.block3 = conv_block(
            in_features=in_features//4,
            out_features=out_features//4,
            padding=rate[2],
            dilation=rate[2],
            norm_type=norm_type,
            activation=activation,
            groups=128
            )
        self.block4 = conv_block(
            in_features=in_features//4,
            out_features=out_features//4,
            padding=rate[3],
            dilation=rate[3],
            norm_type=norm_type,
            activation=activation,
            groups=128
            )
        self.out_s = conv_block(
            in_features=4,
            out_features=4,
            kernel_size=(1, 1),
            padding=(0, 0),
            norm_type=norm_type,
            activation=activation,
        )
        self.out = conv_block(
            in_features=out_features,
            out_features=out_features,
            kernel_size=(1, 1),
            padding=(0, 0),
            norm_type=norm_type,
            activation=activation,
            )

    def forward(self, x):
        split_tensors = []
        x = torch.chunk(x, 4, dim=1)
        x1 = self.block1(x[0])
        x2 = self.block2(x[1])
        x3 = self.block3(x[2])
        x4 = self.block4(x[3])
        for channel in range(x1.size(1)):
            channel_tensors = [tensor[:, channel:channel + 1, :, :] for tensor in [x1, x2, x3, x4]]
            concatenated_channel = self.out_s(torch.cat(channel_tensors, dim=1))  # 拼接在 batch_size 维度上
            split_tensors.append(concatenated_channel)
        x = torch.cat(split_tensors, dim=1)
        x = self.out(x)
        return x


if __name__ == "__main__":
    dim=512
    # 如果GPU可用，将模块移动到 GPU
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    # 输入张量 (batch_size, channels,height, width)
    x = torch.randn(2,dim,40,40).to(device)
    # 初始化 Sea_Attention 模块

    block = MDCR(dim,dim) # kernel_size为height或者width
    print(block)
    block = block.to(device)
    # 前向传播
    output = block(x)
    print("输入:", x.shape)
    print("输出:", output.shape)

输出结果：
在这里插入图片描述


http://www.kler.cn/a/533574.html

相关文章：

  • C++资源管理
  • Deepseek本地部署（ollama+open-webui）
  • 前端 | 浅拷贝深拷贝
  • PAT甲级1052、Linked LIst Sorting
  • 寒假刷题Day19
  • java项目验证码登录
  • LabVIEW图像采集与应变场测量系统
  • 【算法】动态规划专题③ ——二维DP python
  • 【PromptCoder + Bolt.new】Cascade模式自动生成页面和对应的路由
  • 10.单例模式 (Singleton Pattern)
  • 防火墙策略
  • react的antd表格数据回显在form表单中
  • 2024 TCSVT: LS2T2NN
  • 深入解析 Chrome 浏览器的多进程架构：标签页是进程还是线程？（中英双语）
  • 20250205——Windows系统基于ollama的DeepSeek-R1本地安装
  • 备战蓝桥杯-并查集
  • 【力扣】54.螺旋矩阵
  • PyQt6/PySide6 的 QMainWindow 类
  • 数据传输-工作习惯问题
  • CNN的各种知识点（五）：平均精度均值（mean Average Precision, mAP）
  • GaussDB安全配置建议
  • 本地安装部署deepseek
  • 使用 Swift 完成FFmpeg音频录制、播放和视频格式转换应用
  • RabbitMQ 从入门到精通：从工作模式到集群部署实战（一）
  • 【OpenCV实战】基于 OpenCV 的多尺度与模板匹配目标跟踪设计与实现
  • 简易C语言矩阵运算库