【Block总结】自适应矩形卷积，即插即用|CVPR2025

论文信息

• 标题: Adaptive Rectangular Convolution for Remote Sensing Pansharpening
• 年份: 2025年
• 会议: CVPR
• 论文地址: arXiv
• 代码地址: GitHub
• 任务: 遥感图像融合（Pansharpening）

创新点

本论文提出了一种新颖的自适应矩形卷积模块（ARConv），其主要创新点包括：

1. 自适应卷积核设计: ARConv能够根据图像中不同物体的大小自适应地调整卷积核的高度和宽度，克服了传统卷积核在形状和采样点数量上的固定限制。
2. 动态采样点调整: 根据学习到的卷积核特征，动态调整采样点的数量，以有效捕捉不同尺度的特征。
3. ARNet架构: 基于U-net架构，提出ARNet网络，利用ARConv模块在不同深度自适应地提取特征，生成高分辨率多光谱图像。
   

方法

论文中提出的ARConv模块的工作流程如下：

1. 卷积核高度和宽度学习: 通过两个子网络分别预测卷积核的高度和宽度特征图。每个子网络由共享特征提取器和高度/宽度学习器组成，最后通过Sigmoid函数和调制因子约束高度和宽度的范围。
2. 采样点数量选择: 根据高度和宽度特征图的均值水平，确定卷积核在垂直和水平方向上的采样点数量，并选择奇数个采样点以避免过多参数。
3. 生成采样图: 利用标准卷积的采样网格和ARConv的偏移矩阵，结合插值方法，生成最终的采样图。
4. 卷积实现: 对采样图进行卷积操作，并引入仿射变换以增强空间适应性。

ARNet网络结构基于U-net架构，将标准卷积层替换为ARConv模块，通过下采样和上采样步骤，结合ARConv在不同深度自适应地提取特征，最终将学习到的细节注入到低分辨率多光谱图像中，生成高分辨率多光谱图像。

效果

在多个数据集（如WorldView3、QuickBird和GaoFen-2）上进行了广泛评估，使用的评估指标包括SAM、ERGAS、Q8、Dλ、Ds和HQNR。实验结果表明：

1. 性能提升: ARConv在提升融合性能方面优于以往技术，尤其在不同卷积核高度和宽度学习范围的影响实验中，ARNet的性能表现出先提升后下降的趋势，表明适当的卷积核范围对性能至关重要。
2. 消融实验: 通过移除ARConv中的不同模块，验证了各模块的有效性，结果显示移除任一模块都会导致性能下降，尤其在未采用仿射变换时，性能急剧下降，说明仿射变换对增强空间适应性至关重要。
3. 通用性验证: 将ARConv集成到其他融合网络（如FusionNet、LAGNet、CANNet）中，显著提升了这些网络的性能，证明了ARConv的通用性和有效性。

总结

本论文提出的自适应矩形卷积（ARConv）通过自适应学习卷积核的高度和宽度，并根据学习到的尺度动态调整采样点数量，为遥感图像融合任务提供了一种新颖有效的解决方案。ARNet在多个数据集上表现出色，且可视化研究表明卷积核能够根据物体大小和形状有效调整其高度和宽度，充分验证了该方法的有效性和创新性。

代码

import torch
import torch.nn as nnclass ARConv(nn.Module):def __init__(self, inc, outc, kernel_size=3, padding=1, stride=1, l_max=9, w_max=9, flag=False, modulation=True):super(ARConv, self).__init__()self.lmax = l_maxself.wmax = w_maxself.inc = incself.outc = outcself.kernel_size = kernel_sizeself.padding = paddingself.stride = strideself.zero_padding = nn.ZeroPad2d(padding)self.flag = flagself.modulation = modulationself.i_list = [33, 35, 53, 37, 73, 55, 57, 75, 77]self.convs = nn.ModuleList([nn.Conv2d(inc, outc, kernel_size=(i // 10, i % 10), stride=(i // 10, i % 10), padding=0)for i in self.i_list])self.m_conv = nn.Sequential(nn.Conv2d(inc, outc, kernel_size=3, padding=1, stride=stride),nn.LeakyReLU(),nn.Dropout2d(0.3),nn.Conv2d(outc, outc, kernel_size=3, padding=1, stride=stride),nn.LeakyReLU(),nn.Dropout2d(0.3),nn.Conv2d(outc, outc, kernel_size=3, padding=1, stride=stride),nn.Tanh())self.b_conv = nn.Sequential(nn.Conv2d(inc, outc, kernel_size=3, padding=1, stride=stride),nn.LeakyReLU(),nn.Dropout2d(0.3),nn.Conv2d(outc, outc, kernel_size=3, padding=1, stride=stride),nn.LeakyReLU(),nn.Dropout2d(0.3),nn.Conv2d(outc, outc, kernel_size=3, padding=1, stride=stride))self.p_conv = nn.Sequential(nn.Conv2d(inc, inc, kernel_size=3, padding=1, stride=stride),nn.BatchNorm2d(inc),nn.LeakyReLU(),nn.Dropout2d(0),nn.Conv2d(inc, inc, kernel_size=3, padding=1, stride=stride),nn.BatchNorm2d(inc),nn.LeakyReLU(),)self.l_conv = nn.Sequential(nn.Conv2d(inc, 1, kernel_size=3, padding=1, stride=stride),nn.BatchNorm2d(1),nn.LeakyReLU(),nn.Dropout2d(0),nn.Conv2d(1, 1, 1),nn.BatchNorm2d(1),nn.Sigmoid())self.w_conv = nn.Sequential(nn.Conv2d(inc, 1, kernel_size=3, padding=1, stride=stride),nn.BatchNorm2d(1),nn.LeakyReLU(),nn.Dropout2d(0),nn.Conv2d(1, 1, 1),nn.BatchNorm2d(1),nn.Sigmoid())self.dropout1 = nn.Dropout(0.3)self.dropout2 = nn.Dropout2d(0.3)self.hook_handles = []self.hook_handles.append(self.m_conv[0].register_full_backward_hook(self._set_lr))self.hook_handles.append(self.m_conv[1].register_full_backward_hook(self._set_lr))self.hook_handles.append(self.b_conv[0].register_full_backward_hook(self._set_lr))self.hook_handles.append(self.b_conv[1].register_full_backward_hook(self._set_lr))self.hook_handles.append(self.p_conv[0].register_full_backward_hook(self._set_lr))self.hook_handles.append(self.p_conv[1].register_full_backward_hook(self._set_lr))self.hook_handles.append(self.l_conv[0].register_full_backward_hook(self._set_lr))self.hook_handles.append(self.l_conv[1].register_full_backward_hook(self._set_lr))self.hook_handles.append(self.w_conv[0].register_full_backward_hook(self._set_lr))self.hook_handles.append(self.w_conv[1].register_full_backward_hook(self._set_lr))self.reserved_NXY = nn.Parameter(torch.tensor([3, 3], dtype=torch.int32), requires_grad=False)@staticmethoddef _set_lr(module, grad_input, grad_output):grad_input = tuple(g * 0.1 if g is not None else None for g in grad_input)grad_output = tuple(g * 0.1 if g is not None else None for g in grad_output)return grad_inputdef remove_hooks(self):for handle in self.hook_handles:handle.remove()  # 移除钩子函数self.hook_handles.clear()  # 清空句柄列表def forward(self, x, epoch, hw_range):assert isinstance(hw_range, list) and len(hw_range) == 2, "hw_range should be a list with 2 elements, represent the range of h w"scale = hw_range[1] // 9if hw_range[0] == 1 and hw_range[1] == 3:scale = 1m = self.m_conv(x)bias = self.b_conv(x)offset = self.p_conv(x * 100)l = self.l_conv(offset) * (hw_range[1] - 1) + 1  # b, 1, h, ww = self.w_conv(offset) * (hw_range[1] - 1) + 1  # b, 1, h, wif epoch <= 100:mean_l = l.mean(dim=0).mean(dim=1).mean(dim=1)mean_w = w.mean(dim=0).mean(dim=1).mean(dim=1)N_X = int(mean_l // scale)N_Y = int(mean_w // scale)def phi(x):if x % 2 == 0:x -= 1return xN_X, N_Y = phi(N_X), phi(N_Y)N_X, N_Y = max(N_X, 3), max(N_Y, 3)N_X, N_Y = min(N_X, 7), min(N_Y, 7)if epoch == 100:self.reserved_NXY = self.reserved_NXY = nn.Parameter(torch.tensor([N_X, N_Y], dtype=torch.int32, device=x.device),requires_grad=False)else:N_X = self.reserved_NXY[0]N_Y = self.reserved_NXY[1]N = N_X * N_Y# print(N_X, N_Y)l = l.repeat([1, N, 1, 1])w = w.repeat([1, N, 1, 1])offset = torch.cat((l, w), dim=1)dtype = offset.data.type()if self.padding:x = self.zero_padding(x)p = self._get_p(offset, dtype, N_X, N_Y)  # (b, 2*N, h, w)p = p.contiguous().permute(0, 2, 3, 1)  # (b, h, w, 2*N)q_lt = p.detach().floor()q_rb = q_lt + 1q_lt = torch.cat([torch.clamp(q_lt[..., :N], 0, x.size(2) - 1),torch.clamp(q_lt[..., N:], 0, x.size(3) - 1),],dim=-1,).long()q_rb = torch.cat([torch.clamp(q_rb[..., :N], 0, x.size(2) - 1),torch.clamp(q_rb[..., N:], 0, x.size(3) - 1),],dim=-1,).long()q_lb = torch.cat([q_lt[..., :N], q_rb[..., N:]], dim=-1)q_rt = torch.cat([q_rb[..., :N], q_lt[..., N:]], dim=-1)# clip pp = torch.cat([torch.clamp(p[..., :N], 0, x.size(2) - 1),torch.clamp(p[..., N:], 0, x.size(3) - 1),],dim=-1,)# bilinear kernel (b, h, w, N)g_lt = (1 + (q_lt[..., :N].type_as(p) - p[..., :N])) * (1 + (q_lt[..., N:].type_as(p) - p[..., N:]))g_rb = (1 - (q_rb[..., :N].type_as(p) - p[..., :N])) * (1 - (q_rb[..., N:].type_as(p) - p[..., N:]))g_lb = (1 + (q_lb[..., :N].type_as(p) - p[..., :N])) * (1 - (q_lb[..., N:].type_as(p) - p[..., N:]))g_rt = (1 - (q_rt[..., :N].type_as(p) - p[..., :N])) * (1 + (q_rt[..., N:].type_as(p) - p[..., N:]))# (b, c, h, w, N)x_q_lt = self._get_x_q(x, q_lt, N)x_q_rb = self._get_x_q(x, q_rb, N)x_q_lb = self._get_x_q(x, q_lb, N)x_q_rt = self._get_x_q(x, q_rt, N)# (b, c, h, w, N)x_offset = (g_lt.unsqueeze(dim=1) * x_q_lt+ g_rb.unsqueeze(dim=1) * x_q_rb+ g_lb.unsqueeze(dim=1) * x_q_lb+ g_rt.unsqueeze(dim=1) * x_q_rt)x_offset = self._reshape_x_offset(x_offset, N_X, N_Y)x_offset = self.dropout2(x_offset)x_offset = self.convs[self.i_list.index(N_X * 10 + N_Y)](x_offset)out = x_offset * m + biasreturn outdef _get_p_n(self, N, dtype, n_x, n_y):p_n_x, p_n_y = torch.meshgrid(torch.arange(-(n_x - 1) // 2, (n_x - 1) // 2 + 1),torch.arange(-(n_y - 1) // 2, (n_y - 1) // 2 + 1),)p_n = torch.cat([torch.flatten(p_n_x), torch.flatten(p_n_y)], 0)p_n = p_n.view(1, 2 * N, 1, 1).type(dtype)return p_ndef _get_p_0(self, h, w, N, dtype):p_0_x, p_0_y = torch.meshgrid(torch.arange(1, h * self.stride + 1, self.stride),torch.arange(1, w * self.stride + 1, self.stride),)p_0_x = torch.flatten(p_0_x).view(1, 1, h, w).repeat(1, N, 1, 1)p_0_y = torch.flatten(p_0_y).view(1, 1, h, w).repeat(1, N, 1, 1)p_0 = torch.cat([p_0_x, p_0_y], 1).type(dtype)return p_0def _get_p(self, offset, dtype, n_x, n_y):N, h, w = offset.size(1) // 2, offset.size(2), offset.size(3)L, W = offset.split([N, N], dim=1)L = L / n_xW = W / n_yoffsett = torch.cat([L, W], dim=1)p_n = self._get_p_n(N, dtype, n_x, n_y)p_n = p_n.repeat([1, 1, h, w])p_0 = self._get_p_0(h, w, N, dtype)p = p_0 + offsett * p_nreturn pdef _get_x_q(self, x, q, N):b, h, w, _ = q.size()padded_w = x.size(3)c = x.size(1)x = x.contiguous().view(b, c, -1)index = q[..., :N] * padded_w + q[..., N:]index = (index.contiguous().unsqueeze(dim=1).expand(-1, c, -1, -1, -1).contiguous().view(b, c, -1))x_offset = x.gather(dim=-1, index=index).contiguous().view(b, c, h, w, N)return x_offset@staticmethoddef _reshape_x_offset(x_offset, n_x, n_y):b, c, h, w, N = x_offset.size()x_offset = torch.cat([x_offset[..., s:s + n_y].contiguous().view(b, c, h, w * n_y) for s in range(0, N, n_y)],dim=-1)x_offset = x_offset.contiguous().view(b, c, h * n_x, w * n_y)return x_offsetif __name__ == "__main__":# 定义输入张量大小（Batch、Channel、Height、Wight）B, C, H, W = 16, 512, 40, 40input_tensor = torch.randn(B,C,H,W)  # 随机生成输入张量dim=C# 创建 ARConv 实例block = ARConv(inc=dim,outc=dim)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,50,[0,18])# 打印输入和输出的形状print(f"Input: {input_tensor.shape}")print(f"Output: {output.shape}")

代码详解

1. 核心结构解析

1.1 初始化部分 (__init__)

• 多尺度卷积层 (self.convs):

  • 包含9种不同尺寸的卷积核（如3x3,5x5等），通过i_list中的两位数编码（十位和个位分别表示高度和宽度的尺寸）。
  • 例如，i=33对应kernel_size=(3,3)，stride=(3,3)。

• 调制网络 (m_conv):

  • 由三个卷积层组成，输出通过Tanh激活，生成调制因子m，用于调整特征权重。

• 偏置网络 (b_conv):

  • 生成偏置项bias，与调制后的特征相加。

• 位置偏移网络 (p_conv):

  • 生成基础偏移量，输入被放大100倍以增强位置敏感性。

• 长宽预测网络 (l_conv, w_conv):

  • 预测每个位置的长宽偏移量l和w，通过Sigmoid映射到[0,1]后缩放至指定范围。

• 梯度调整钩子:

  • 注册反向传播钩子，将特定层的梯度缩小到0.1倍，稳定训练过程。

1.2 前向传播 (forward)

• 动态核尺寸选择:

  • 根据当前训练轮数(epoch)动态确定N_X和N_Y（卷积核分块数）。
  • 前100轮计算平均偏移确定分块数，之后固定。确保核尺寸为奇数（phi函数处理）。

• 可变形采样:

  • 使用预测的偏移量生成采样网格§，通过双线性插值获取变形后的特征(x_offset)。

• 多尺度卷积处理:

  • 根据N_X和N_Y选择对应的卷积层处理变形后的特征，结合调制因子和偏置输出最终特征。

2. 关键机制

• 动态核适应: 根据输入特征动态调整卷积核的分布区域，增强模型对不同尺度特征的捕捉能力。
• 可变形卷积: 通过预测的偏移量实现非规则采样，突破传统卷积的固定几何结构限制。
• 梯度控制: 使用自定义梯度缩放策略（0.1倍），防止调制网络训练不稳定。

3. 数据流动示例

输入尺寸: (16,512,40,40)
输出尺寸: (16,512,40,40)
处理过程:

1. 偏移预测网络生成40x40网格的偏移量
2. 双线性插值生成变形特征图
3. 根据动态选择的核尺寸(如3x3)进行分块卷积
4. 调制网络调整特征权重，偏置网络添加位置偏置

4. 潜在优化点

• 核尺寸选择策略: 当前基于平均偏移的启发式方法可能不够鲁棒，可探索可学习的自动选择机制。
• 计算效率: 多尺度卷积组的并行计算可能带来内存压力，可考虑动态生成卷积参数。
• 梯度控制: 固定0.1倍的梯度缩放可能不够灵活，可尝试自适应梯度裁剪。

5. 应用场景建议

该模块特别适用于以下场景：

• 细粒度视觉识别（如医学图像分析）
• 不规则形状目标检测
• 多尺度特征融合层
• 视频动作识别中的时空特征建模

# 典型使用示例
class ARNet(nn.Module):def __init__(self):super().__init__()self.conv1 = ARConv(512, 512)def forward(self, x, epoch):# 假设hw_range根据网络深度动态调整hw = [0, 18] if epoch < 50 else [9, 27]  return self.conv1(x, epoch, hw)# 训练时需传入当前epoch
for epoch in range(100):output = model(input, epoch=epoch, hw_range=[0,18])