【Bug已解决】How to use groups parameter in PyTorch conv2d function 解决方案问题标签PyTorch、Conv2d、groups参数、分组卷积、深度可分离卷积适用版本PyTorch 1.0 ~ 2.x难度等级⭐⭐⭐中等一、问题描述在 PyTorch 的nn.Conv2d中groups参数是一个经常被忽视但非常重要的参数。很多开发者不清楚它的含义和用法导致无法理解 MobileNet、ResNeXt 等模型中的分组卷积设置错误的groups值导致运行时错误不知道如何利用groups减少参数量和计算量核心问题nn.Conv2d的groups参数是什么含义如何正确使用它二、错误复现场景设置不兼容的 groups 值import torch import torch.nn as nn # 场景 1: in_channels 不能被 groups 整除 try: conv nn.Conv2d(in_channels3, out_channels64, kernel_size3, groups2) # 3 不能被 2 整除 except ValueError as e: print(f错误 1: {e}) # 场景 2: out_channels 不能被 groups 整除 try: conv nn.Conv2d(in_channels16, out_channels32, kernel_size3, groups3) # 32 不能被 3 整除 except ValueError as e: print(f错误 2: {e}) # 场景 3: groups in_channels try: conv nn.Conv2d(in_channels4, out_channels8, kernel_size3, groups8) # groups 不能大于 in_channels except ValueError as e: print(f错误 3: {e})典型错误输出错误 1: in_channels must be divisible by groups (3 vs 2) 错误 2: out_channels must be divisible by groups (32 vs 3) 错误 3: in_channels must be divisible by groups (4 vs 8)三、根因分析3.1 groups 参数的含义groups参数控制分组卷积Grouped Convolution的行为groups1默认标准卷积所有输入通道与所有输出通道全连接groupsG将输入通道分成 G 组每组独立卷积输出通道也分成 G 组groupsin_channels深度卷积Depthwise Convolution每个输入通道单独卷积3.2 分组卷积的数学原理标准卷积groups1输入: (N, C_in, H, W) 权重: (C_out, C_in, kH, kW) 输出: (N, C_out, H_out, W_out) 每个输出通道 Σ(所有输入通道 × 对应权重) 参数量: C_out × C_in × kH × kW分组卷积groupsG输入: (N, C_in, H, W) → 分成 G 组每组 C_in/G 个通道 权重: (C_out, C_in/G, kH, kW) → 分成 G 组每组 C_out/G 个输出通道 输出: (N, C_out, H_out, W_out) → G 组输出拼接 每组输出 Σ(该组输入通道 × 对应权重) 参数量: C_out × (C_in/G) × kH × kW 标准卷积参数量 / G3.3 参数量与计算量对比卷积类型groups参数量计算量说明标准卷积1C_out × C_in × k²C_out × C_in × k² × H × W全连接分组卷积GC_out × (C_in/G) × k²C_out × (C_in/G) × k² × H × W参数减少 G 倍深度卷积C_inC_in × k²C_in × k² × H × W每通道独立逐点卷积1C_out × C_in × 1²C_out × C_in × H × W1×1 卷积3.4 约束条件1. in_channels 必须能被 groups 整除 2. out_channels 必须能被 groups 整除 3. groups ≤ min(in_channels, out_channels)四、解决方案方案一标准卷积groups1import torch import torch.nn as nn # 标准卷积所有输入通道与所有输出通道全连接 conv_standard nn.Conv2d( in_channels3, out_channels64, kernel_size3, padding1, groups1 # 默认值可省略 ) x torch.randn(1, 3, 224, 224) out conv_standard(x) print(f标准卷积: {x.shape} → {out.shape}) print(f参数量: {sum(p.numel() for p in conv_standard.parameters())}) # 参数量 64 × 3 × 3 × 3 64(bias) 1792方案二分组卷积groupsG# 分组卷积将通道分组减少参数量和计算量 conv_grouped nn.Conv2d( in_channels64, out_channels64, kernel_size3, padding1, groups4 # 分成 4 组每组 16 个输入通道 → 16 个输出通道 ) x torch.randn(1, 64, 224, 224) out conv_grouped(x) print(f分组卷积 (groups4): {x.shape} → {out.shape}) print(f参数量: {sum(p.numel() for p in conv_grouped.parameters())}) # 参数量 64 × (64/4) × 3 × 3 64(bias) 9280 # 对比标准卷积: 64 × 64 × 3 × 3 64 36928减少了 4 倍方案三深度可分离卷积Depthwise Separable ConvolutionMobileNet 的核心组件将标准卷积拆分为深度卷积 逐点卷积。import torch import torch.nn as nn class DepthwiseSeparableConv(nn.Module): 深度可分离卷积 Depthwise Pointwise def __init__(self, in_channels, out_channels, kernel_size3, stride1, padding1): super().__init__() # 深度卷积每个输入通道单独卷积groupsin_channels self.depthwise nn.Conv2d( in_channelsin_channels, out_channelsin_channels, # 输出通道 输入通道 kernel_sizekernel_size, stridestride, paddingpadding, groupsin_channels, # 每个通道独立卷积 biasFalse ) # 逐点卷积1×1 卷积通道间信息融合 self.pointwise nn.Conv2d( in_channelsin_channels, out_channelsout_channels, kernel_size1, # 1×1 卷积 stride1, padding0, groups1, biasFalse ) self.bn1 nn.BatchNorm2d(in_channels) self.bn2 nn.BatchNorm2d(out_channels) self.relu nn.ReLU6(inplaceTrue) def forward(self, x): x self.depthwise(x) x self.bn1(x) x self.relu(x) x self.pointwise(x) x self.bn2(x) x self.relu(x) return x # 对比标准卷积和深度可分离卷积 in_ch, out_ch 64, 128 x torch.randn(1, 64, 224, 224) # 标准卷积 standard_conv nn.Conv2d(in_ch, out_ch, kernel_size3, padding1, biasFalse) standard_params sum(p.numel() for p in standard_conv.parameters()) # 深度可分离卷积 ds_conv DepthwiseSeparableConv(in_ch, out_ch, kernel_size3, padding1) ds_params sum(p.numel() for p in ds_conv.parameters()) print(f标准卷积参数量: {standard_params:,}) print(f深度可分离卷积参数量: {ds_params:,}) print(f参数减少: {100*(1 - ds_params/standard_params):.1f}%) # 前向传播 out_standard standard_conv(x) out_ds ds_conv(x) print(f标准卷积输出: {out_standard.shape}) print(f深度可分离卷积输出: {out_ds.shape})方案四ResNeXt 分组卷积ResNeXt 使用分组卷积来增加模型宽度而不显著增加参数量。import torch import torch.nn as nn class ResNeXtBlock(nn.Module): ResNeXt 基本块使用分组卷积 def __init__(self, in_channels, out_channels, cardinality32, bottleneck_width4, stride1): super().__init__() # cardinality groups分组数 # 每组宽度 bottleneck_width D cardinality * bottleneck_width # 中间层通道数 self.conv1 nn.Conv2d(in_channels, D, kernel_size1, biasFalse) self.bn1 nn.BatchNorm2d(D) # 分组卷积 self.conv2 nn.Conv2d( D, D, kernel_size3, stridestride, padding1, groupscardinality, # 关键分组卷积 biasFalse ) self.bn2 nn.BatchNorm2d(D) self.conv3 nn.Conv2d(D, out_channels, kernel_size1, biasFalse) self.bn3 nn.BatchNorm2d(out_channels) self.relu nn.ReLU(inplaceTrue) # 残差连接 self.shortcut nn.Sequential() if stride ! 1 or in_channels ! out_channels: self.shortcut nn.Sequential( nn.Conv2d(in_channels, out_channels, kernel_size1, stridestride, biasFalse), nn.BatchNorm2d(out_channels) ) def forward(self, x): residual self.shortcut(x) out self.relu(self.bn1(self.conv1(x))) out self.relu(self.bn2(self.conv2(out))) out self.bn3(self.conv3(out)) out residual out self.relu(out) return out # 测试 block ResNeXtBlock(in_channels256, out_channels256, cardinality32, bottleneck_width4) x torch.randn(1, 256, 56, 56) out block(x) print(fResNeXt Block: {x.shape} → {out.shape}) print(f参数量: {sum(p.numel() for p in block.parameters()):,})五、完整修复代码import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import DataLoader, TensorDataset # 分组卷积工具类 class GroupedConvUtils: 分组卷积工具类 staticmethod def validate_groups(in_channels, out_channels, groups): 验证 groups 参数是否合法 if groups 1: raise ValueError(fgroups 必须 1得到 {groups}) if in_channels % groups ! 0: raise ValueError( fin_channels ({in_channels}) 必须能被 groups ({groups}) 整除 ) if out_channels % groups ! 0: raise ValueError( fout_channels ({out_channels}) 必须能被 groups ({groups}) 整除 ) if groups in_channels: raise ValueError( fgroups ({groups}) 不能大于 in_channels ({in_channels}) ) return True staticmethod def count_parameters(conv): 计算卷积层参数量 return sum(p.numel() for p in conv.parameters()) staticmethod def compare_convolutions(in_channels, out_channels, kernel_size3, groups_listNone): 对比不同 groups 的参数量 if groups_list is None: # 自动生成合法的 groups 列表 groups_list [] for g in range(1, min(in_channels, out_channels) 1): if in_channels % g 0 and out_channels % g 0: groups_list.append(g) print(f{groups:8} {参数量:12} {相比标准:12} {每组输入:10} {每组输出:10}) print(- * 60) base_params None for g in groups_list: conv nn.Conv2d(in_channels, out_channels, kernel_size, groupsg, biasFalse) params GroupedConvUtils.count_parameters(conv) if base_params is None: base_params params ratio params / base_params per_in in_channels // g per_out out_channels // g print(f{g:8} {params:12,} {ratio:11.2f}x {per_in:10} {per_out:10}) # MobileNet 简化版 class MobileNetV1Block(nn.Module): MobileNet V1 基本块深度可分离卷积 def __init__(self, in_channels, out_channels, stride1): super().__init__() self.depthwise nn.Conv2d( in_channels, in_channels, kernel_size3, stridestride, padding1, groupsin_channels, biasFalse ) self.pointwise nn.Conv2d( in_channels, out_channels, kernel_size1, stride1, padding0, biasFalse ) self.bn1 nn.BatchNorm2d(in_channels) self.bn2 nn.BatchNorm2d(out_channels) self.relu nn.ReLU6(inplaceTrue) def forward(self, x): x self.relu(self.bn1(self.depthwise(x))) x self.relu(self.bn2(self.pointwise(x))) return x class SimpleMobileNet(nn.Module): 简化版 MobileNet def __init__(self, num_classes10): super().__init__() self.features nn.Sequential( # 初始标准卷积 nn.Conv2d(3, 32, kernel_size3, stride2, padding1, biasFalse), nn.BatchNorm2d(32), nn.ReLU6(inplaceTrue), # 深度可分离卷积块 MobileNetV1Block(32, 64, stride1), MobileNetV1Block(64, 128, stride2), MobileNetV1Block(128, 128, stride1), MobileNetV1Block(128, 256, stride2), MobileNetV1Block(256, 256, stride1), MobileNetV1Block(256, 512, stride2), # 全局平均池化 nn.AdaptiveAvgPool2d((1, 1)), ) self.classifier nn.Linear(512, num_classes) def forward(self, x): x self.features(x) x x.view(x.size(0), -1) x self.classifier(x) return x # 完整训练示例 def train_with_grouped_convolution(): 使用分组卷积的完整训练示例 device torch.device(cuda if torch.cuda.is_available() else cpu) print(f使用设备: {device}) # 创建模拟数据 X torch.randn(200, 3, 32, 32) y torch.randint(0, 10, (200,)) dataset TensorDataset(X, y) dataloader DataLoader(dataset, batch_size16, shuffleTrue) # 创建模型 model SimpleMobileNet(num_classes10).to(device) # 统计参数 total_params sum(p.numel() for p in model.parameters()) print(fMobileNet 总参数量: {total_params:,}) # 对比标准 CNN standard_cnn nn.Sequential( nn.Conv2d(3, 32, 3, stride2, padding1), nn.BatchNorm2d(32), nn.ReLU6(inplaceTrue), nn.Conv2d(32, 64, 3, stride1, padding1), nn.BatchNorm2d(64), nn.ReLU6(inplaceTrue), nn.Conv2d(64, 128, 3, stride2, padding1), nn.BatchNorm2d(128), nn.ReLU6(inplaceTrue), nn.AdaptiveAvgPool2d((1, 1)), nn.Flatten(), nn.Linear(128, 10), ) standard_params sum(p.numel() for p in standard_cnn.parameters()) print(f标准 CNN 参数量: {standard_params:,}) print(f参数减少: {100*(1 - total_params/standard_params):.1f}%) # 训练 optimizer optim.Adam(model.parameters(), lr0.001) criterion nn.CrossEntropyLoss() for epoch in range(5): model.train() total_loss 0 correct 0 total 0 for inputs, labels in dataloader: inputs, labels inputs.to(device), labels.to(device) optimizer.zero_grad() outputs model(inputs) loss criterion(outputs, labels) loss.backward() optimizer.step() total_loss loss.item() _, predicted outputs.max(1) total labels.size(0) correct predicted.eq(labels).sum().item() print(fEpoch [{epoch1}/5] Loss: {total_loss/len(dataloader):.4f}, fAcc: {100.*correct/total:.2f}%) # 运行 if __name__ __main__: print( * 60) print(分组卷积参数对比) print( * 60) GroupedConvUtils.compare_convolutions(64, 64, kernel_size3) print() GroupedConvUtils.compare_convolutions(128, 256, kernel_size3) print() print( * 60) print(训练示例) print( * 60) train_with_grouped_convolution()六、常见陷阱与注意事项陷阱 1groups 与通道数不匹配import torch.nn as nn # ❌ in_channels10 不能被 groups3 整除 # conv nn.Conv2d(10, 30, 3, groups3) # ValueError! # ✓ 确保 in_channels 和 out_channels 都能被 groups 整除 conv nn.Conv2d(12, 24, 3, groups3) # 12/34, 24/38 ✓陷阱 2深度卷积后忘记逐点卷积# ❌ 仅用深度卷积通道间无信息交流 depthwise_only nn.Conv2d(64, 64, 3, groups64, padding1) # 输出每个通道只依赖输入对应通道无法学习通道间关系 # ✓ 深度卷积 逐点卷积 depthwise nn.Conv2d(64, 64, 3, groups64, padding1) # 空间特征 pointwise nn.Conv2d(64, 128, 1) # 通道融合陷阱 3混淆 groups 和 dilation# groups: 分组卷积减少参数量 conv_grouped nn.Conv2d(64, 64, 3, groups8, padding1) # dilation: 空洞卷积扩大感受野不增加参数量 conv_dilated nn.Conv2d(64, 64, 3, dilation2, padding2) # 两者可以同时使用 conv_both nn.Conv2d(64, 64, 3, groups8, dilation2, padding2)陷阱 4分组卷积的权重形状理解错误import torch.nn as nn # 标准卷积权重形状: (out_channels, in_channels, kH, kW) conv_std nn.Conv2d(64, 128, 3, groups1) print(f标准卷积权重: {conv_std.weight.shape}) # (128, 64, 3, 3) # 分组卷积权重形状: (out_channels, in_channels/groups, kH, kW) conv_grp nn.Conv2d(64, 128, 3, groups4) print(f分组卷积权重: {conv_grp.weight.shape}) # (128, 16, 3, 3) ← in_channels/groups 64/4 16 # 深度卷积权重形状: (in_channels, 1, kH, kW) conv_dw nn.Conv2d(64, 64, 3, groups64) print(f深度卷积权重: {conv_dw.weight.shape}) # (64, 1, 3, 3)陷阱 5groups 过大导致性能下降# groups 过大接近 in_channels时通道间信息交流过少 # 可能导致模型性能下降 # ❌ 对于小通道数使用过大 groups # conv nn.Conv2d(16, 16, 3, groups16) # 每组只有 1 个通道信息交流为零 # ✓ 合理的 groups 设置 # conv nn.Conv2d(64, 64, 3, groups4) # 每组 16 个通道七、总结groups 值卷积类型参数量典型应用1标准卷积C_out × C_in × k²ResNet, VGGG (1 G C_in)分组卷积C_out × (C_in/G) × k²ResNeXtC_in深度卷积C_in × k²MobileNetC_in 1×1 conv深度可分离C_in × k² C_out × C_inMobileNet, EfficientNetgroups 参数速查groups1 → 标准卷积全连接 groupsG → 分组卷积参数减少 G 倍 groupsin_channels → 深度卷积每通道独立 约束: in_channels % groups 0 out_channels % groups 0 groups ≤ in_channels选择建议场景推荐 groups原因追求精度1全连接信息交流最充分追求效率移动端in_channels 1×1深度可分离参数最少平衡精度和效率4~32ResNeXt 策略大通道数通道数的 1/4 ~ 1/8保持每组有足够通道核心原则groups参数是控制卷积层参数量和通道间信息交流程度的旋钮。groups1信息交流最充分但参数最多groupsin_channels参数最少但无通道间交流。深度可分离卷积深度卷积 逐点卷积是移动端部署的最佳实践。通过合理使用groups参数可以在模型精度和效率之间找到最佳平衡点这对于在资源受限设备上部署深度学习模型至关重要。