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

【Block总结】Conv2Former的Block,结合卷积网络和Transformer的优点|即插即用

article 2025/1/15 17:25:14

背景与动机

Conv2Former是一种新型的卷积神经网络（ConvNet），旨在结合卷积网络和Transformer的优点，以提升视觉识别任务的性能。传统的卷积神经网络在处理局部特征提取方面表现优异，但在建模全局信息和长距离依赖关系时存在局限。随着视觉Transformer（ViTs）的发展，研究者们开始探索如何将卷积操作与Transformer的自注意力机制相结合，以克服这些局限性。
在这里插入图片描述

架构与核心模块

Conv2Former的设计采用了金字塔结构，包含多个阶段（Stage），每个阶段处理不同分辨率的特征。其核心在于卷积调制模块，该模块通过卷积操作模拟自注意力机制，从而有效降低计算复杂度并提高处理高分辨率图像的效率。具体而言，卷积调制模块利用深度卷积和Hadamard乘积操作，将大内核卷积的输出与值表示进行调制，实现对空间信息的有效编码。

卷积调制模块的具体工作原理

卷积调制模块是Conv2Former架构的核心组件，旨在通过卷积操作简化自注意力机制，从而提高视觉识别任务的效率和性能。该模块通过利用深度卷积和Hadamard乘积来实现对空间信息的有效编码，特别是在处理高分辨率图像时表现出色。如下图：
在这里插入图片描述

工作原理

卷积特征生成：
卷积调制模块首先使用深度卷积生成特征图。这些特征图包含了输入图像的局部信息，并通过卷积核的滑动窗口机制提取特征。与传统的自注意力机制不同，卷积操作的计算复杂度相对较低，适合处理高分辨率图像。
Hadamard乘积：
在生成卷积特征后，模块通过Hadamard乘积将这些特征与值表示进行调制。具体来说，给定输入特征图，模块会计算出一个权重矩阵，并将其应用于值表示。这一过程可以表示为：
$\odot V$
其中， $A$ 是通过卷积生成的权重矩阵， $V$ 是值表示， $Z$ 是最终输出。
空间信息编码：
通过这种方式，卷积调制模块能够将每个空间位置的特征与其周围的像素相关联，从而有效捕捉到空间上下文信息。这种方法不仅减少了计算量，还提高了模型的性能，尤其是在处理复杂图像时。
模块结构：
卷积调制模块的结构通常包括以下几个部分：
- 归一化层：对输入特征进行归一化处理，以提高模型的稳定性。
- 卷积层：用于生成权重矩阵和调制值表示的深度卷积层。
- 线性层：用于通道间的信息聚合，进一步增强特征表达能力。

优势

计算效率：与传统的自注意力机制相比，卷积调制模块在计算复杂度上具有明显优势，尤其是在处理高分辨率图像时，能够有效降低内存占用。
性能提升：实验表明，卷积调制模块在多个视觉识别任务上均表现出色，能够显著提升模型的性能和泛化能力[1][2][3][5][6]。

通过这种创新的设计，卷积调制模块不仅保留了卷积网络的高效性，还引入了Transformer的建模能力，为视觉识别任务提供了新的解决方案。

实验结果

在多个基准数据集上的实验表明，Conv2Former在ImageNet分类、目标检测和语义分割等任务上均取得了优异的表现。与传统的卷积网络（如ConvNeXt）和基于Transformer的模型（如Swin Transformer）相比，Conv2Former在处理高分辨率图像时展现出更高的计算效率和更好的性能[2][5][10]。

实际应用

Conv2Former的优异性能使其在多个实际应用场景中具有广泛的潜力。例如，在自动驾驶领域，Conv2Former可以用于车辆检测、行人识别和道路场景理解等任务。在医疗影像分析中，它可用于病灶检测和病变区域分割，辅助医生进行精准诊断和治疗[5][9][10]。

结论

Conv2Former通过创新的卷积调制模块和金字塔架构，实现了对全局和局部信息的有效整合，显著提升了视觉识别任务的性能。随着研究的深入和技术的不断迭代，Conv2Former有望在计算机视觉领域带来新的突破和发展。代码：

import torch
import torch.nn as nn
import torch.nn.functional as F
from timm.models.layers import DropPath


class MLP(nn.Module):
    def __init__(self, dim, mlp_ratio=4):
        super().__init__()
        self.norm = LayerNorm(dim, eps=1e-6, data_format="channels_first")
        self.fc1 = nn.Conv2d(dim, dim * mlp_ratio, 1)
        self.pos = nn.Conv2d(dim * mlp_ratio, dim * mlp_ratio, 3, padding=1, groups=dim * mlp_ratio)
        self.fc2 = nn.Conv2d(dim * mlp_ratio, dim, 1)
        self.act = nn.GELU()

    def forward(self, x):
        x = self.norm(x)
        x = self.fc1(x)
        x = self.act(x)
        x = x + self.act(self.pos(x))
        x = self.fc2(x)

        return x


class SpatialAttention(nn.Module):
    def __init__(self, dim, kernel_size, expand_ratio=2):
        super().__init__()
        self.norm = LayerNorm(dim, eps=1e-6, data_format="channels_first")
        self.att = nn.Sequential(
            nn.Conv2d(dim, dim, 1),
            nn.GELU(),
            nn.Conv2d(dim, dim, kernel_size=kernel_size, padding=kernel_size // 2, groups=dim)
        )
        self.v = nn.Conv2d(dim, dim, 1)
        self.proj = nn.Conv2d(dim, dim, 1)

    def forward(self, x):
        x = self.norm(x)
        x = self.att(x) * self.v(x)
        x = self.proj(x)
        return x


class Block(nn.Module):
    def __init__(self, dim, kernel_size, mlp_ratio=4., drop_path=0.):
        super().__init__()
        self.attn = SpatialAttention(dim, kernel_size)
        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
        self.mlp = MLP(dim, mlp_ratio)
        layer_scale_init_value = 1e-6
        self.layer_scale_1 = nn.Parameter(
            layer_scale_init_value * torch.ones((dim)), requires_grad=True)
        self.layer_scale_2 = nn.Parameter(
            layer_scale_init_value * torch.ones((dim)), requires_grad=True)

    def forward(self, x):
        x = x + self.drop_path(self.layer_scale_1.unsqueeze(-1).unsqueeze(-1) * self.attn(x))
        x = x + self.drop_path(self.layer_scale_2.unsqueeze(-1).unsqueeze(-1) * self.mlp(x))
        return x


class LayerNorm(nn.Module):
    r""" LayerNorm that supports two data formats: channels_last (default) or channels_first.
    The ordering of the dimensions in the inputs. channels_last corresponds to inputs with
    shape (batch_size, height, width, channels) while channels_first corresponds to inputs
    with shape (batch_size, channels, height, width).
    """

    def __init__(self, normalized_shape, eps=1e-6, data_format="channels_last"):
        super().__init__()
        self.weight = nn.Parameter(torch.ones(normalized_shape))
        self.bias = nn.Parameter(torch.zeros(normalized_shape))
        self.eps = eps
        self.data_format = data_format
        if self.data_format not in ["channels_last", "channels_first"]:
            raise NotImplementedError
        self.normalized_shape = (normalized_shape,)

    def forward(self, x):
        if self.data_format == "channels_last":
            return F.layer_norm(x, self.normalized_shape, self.weight, self.bias, self.eps)
        elif self.data_format == "channels_first":
            u = x.mean(1, keepdim=True)
            s = (x - u).pow(2).mean(1, keepdim=True)
            x = (x - u) / torch.sqrt(s + self.eps)
            x = self.weight[:, None, None] * x + self.bias[:, None, None]
            return x



if __name__ == '__main__':
    # 定义输入张量大小（Batch、Channel、Height、Wight）
    B, C, H, W = 1, 64, 640, 480
    input_tensor = torch.randn(B, C, H, W)  # 随机生成输入张量
    # 初始化 CBlock
    dim = C  # 输入和输出通道数
    # 创建 CBlock 实例
    block = Block(dim=dim,kernel_size=7,mlp_ratio=4,drop_path=0.1)
    # 如果GPU可用将模块移动到 GPU
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    sablock = block.to(device)
    print(sablock)
    input_tensor = input_tensor.to(device)
    # 执行前向传播
    output = sablock(input_tensor)
    # 打印输入和输出的形状
    print(f"Input: {input_tensor.shape}")
    print(f"Output: {output.shape}")