Hey there! Let's tackle your two questions and walk through how to build the adaptive convolution layer you're looking for.

1. 如何在PyTorch的Conv2d中动态改变卷积核尺寸？ #

PyTorch原生的nn.Conv2d是固定卷积核尺寸的——一旦初始化，核的大小就没法直接修改了。但结合你的需求（输入图像尺寸固定，初始化后无需再改核尺寸），我们有两种实用思路：

• 初始化前预计算核尺寸：因为输入尺寸固定，你可以先根据图像偏心度计算好所需的核参数，在网络初始化阶段直接创建对应尺寸的卷积层，完全不用动态修改。
• 动态替换卷积层（训练中调整）：如果需要在训练过程中临时切换核尺寸，可以重新定义新的nn.Conv2d层，把旧权重通过插值（比如torch.nn.functional.interpolate）或裁剪的方式迁移到新核上，替换掉原来的卷积层。这种方法适合核尺寸变化不频繁的场景。

2. 基于图像偏心度的可变尺寸/步长圆形卷积核——完全可以实现！ #

你的需求（中心区域高分辨率、外围逐步降分辨率，搭配圆形卷积核）是可行的，核心是自定义一个自适应卷积模块，提前根据偏心度（像素到图像中心的距离）预计算每个位置的核尺寸、步长和圆形核权重。下面是具体的实现思路和简化代码：

核心思路拆解 #

1. 预计算偏心度映射：因为输入图像尺寸固定，初始化时就可以计算每个像素到图像中心的距离，划分不同的区域（比如中心区、近外围、远外围），给每个区域分配对应的核尺寸（如3x3、5x5、7x7）和步长（如1、2、4）。
2. 生成圆形卷积核：对每个尺寸的方形核，生成圆形掩码——计算核内每个位置到核中心的距离，把超出圆形范围的权重设为0，模拟圆形卷积的效果。
3. 分区域自适应卷积：针对不同区域，用对应的核尺寸和步长做卷积，最后把各区域的输出拼接或融合成完整特征图；或者用unfold操作逐位置处理邻域，匹配对应的核进行计算。

简化代码示例 #

import torch
import torch.nn as nn
import torch.nn.functional as F
import math

class AdaptiveCircularConv2d(nn.Module):
    def __init__(self, in_channels, out_channels, img_size=(256,256), kernel_levels=[3,5,7], stride_levels=[1,2,4]):
        super().__init__()
        self.in_channels = in_channels
        self.out_channels = out_channels
        self.img_h, self.img_w = img_size
        self.kernel_levels = kernel_levels
        self.stride_levels = stride_levels

        # 1. 预计算每个位置的偏心度对应的核级别
        self.pos_kernel_idx = self._compute_eccentricity_map()

        # 2. 为每个核级别创建带圆形掩码的卷积核权重
        self.kernels = nn.ParameterList()
        for k in kernel_levels:
            # 初始化方形核
            kernel = nn.Parameter(torch.randn(out_channels, in_channels, k, k))
            # 生成圆形掩码并应用
            mask = self._create_circular_mask(k)
            kernel.data *= mask
            self.kernels.append(kernel)

    def _compute_eccentricity_map(self):
        # 计算每个像素到中心的距离，划分核级别
        center_h, center_w = self.img_h//2, self.img_w//2
        y_grid, x_grid = torch.meshgrid(torch.arange(self.img_h), torch.arange(self.img_w), indexing='ij')
        dist = torch.sqrt((y_grid - center_h)**2 + (x_grid - center_w)**2)
        # 根据距离划分3个级别（可根据需求调整）
        max_dist = max(center_h, center_w)
        thresholds = [max_dist/3, max_dist*2/3]
        idx_map = torch.zeros_like(dist, dtype=torch.long)
        idx_map[(dist > thresholds[0]) & (dist <= thresholds[1])] = 1
        idx_map[dist > thresholds[1]] = 2
        return idx_map.to('cuda' if torch.cuda.is_available() else 'cpu')

    def _create_circular_mask(self, kernel_size):
        # 创建k x k的圆形掩码
        k = kernel_size
        center = k//2
        y_grid, x_grid = torch.meshgrid(torch.arange(k), torch.arange(k), indexing='ij')
        dist = torch.sqrt((y_grid - center)**2 + (x_grid - center)**2)
        mask = (dist <= center).float()
        mask = mask.unsqueeze(0).unsqueeze(0)  # 适配卷积核维度
        return mask.to('cuda' if torch.cuda.is_available() else 'cpu')

    def forward(self, x):
        batch_size = x.shape[0]
        output = torch.zeros(batch_size, self.out_channels, self.img_h, self.img_w).to(x.device)

        # 处理中心区域：3x3核，步长1
        center_mask = (self.pos_kernel_idx == 0)
        padded_x = F.pad(x, (1,1,1,1), mode='reflect')
        unfolded = F.unfold(padded_x, kernel_size=3, stride=1)
        center_unfolded = unfolded[:, :, center_mask.flatten()]
        center_out = self.kernels[0].view(self.out_channels, -1) @ center_unfolded
        output[:, :, center_mask] = center_out.view(batch_size, self.out_channels, -1)

        # 处理近外围区域：5x5核，步长2
        outer1_mask = (self.pos_kernel_idx == 1)
        padded_x_5 = F.pad(x, (2,2,2,2), mode='reflect')
        unfolded_5 = F.unfold(padded_x_5, kernel_size=5, stride=2)
        outer1_out = self.kernels[1].view(self.out_channels, -1) @ unfolded_5
        outer1_out = F.interpolate(outer1_out.view(batch_size, self.out_channels, self.img_h//2, self.img_w//2), 
                                   size=(self.img_h, self.img_w), mode='nearest')
        output[:, :, outer1_mask] = outer1_out[:, :, outer1_mask]

        # 处理远外围区域：7x7核，步长4
        outer2_mask = (self.pos_kernel_idx == 2)
        padded_x_7 = F.pad(x, (3,3,3,3), mode='reflect')
        unfolded_7 = F.unfold(padded_x_7, kernel_size=7, stride=4)
        outer2_out = self.kernels[2].view(self.out_channels, -1) @ unfolded_7
        outer2_out = F.interpolate(outer2_out.view(batch_size, self.out_channels, self.img_h//4, self.img_w//4), 
                                   size=(self.img_h, self.img_w), mode='nearest')
        output[:, :, outer2_mask] = outer2_out[:, :, outer2_mask]

        return output

注意事项 #

• 上述代码是简化版，你可以根据实际需求调整偏心度的划分逻辑、核尺寸的数量、步长的匹配规则。
• 圆形卷积核的掩码可以固定形状，也可以设置为可学习参数（通常固定形状更符合你的需求）。
• 如果需要更高性能，可以考虑合并区域卷积逻辑，或者编写CUDA自定义算子，但纯PyTorch代码已经能满足基本需求。

内容的提问来源于stack exchange，提问作者Andre