在整理经典卷积神经网络时，才注意到这个group参数，因为它可以很方便地实现深度可分离卷积，所以在此记录一下。

nn.Conv2d的groups参数

官方文档对该参数的解释为：

groups: 控制输入和输出之间的连接： group=1，输出是所有的输入的卷积；group=2，此时相当于有并排的两个卷积层，每个卷积层计算输入通道的一半，并且产生的输出是输出通道的一半，随后将这两个输出连接起来。

即当group=1时，输出特征图的某个通道是卷了所有输入特征图，当group=2，输入和输出都被划为两组，输出的某组的某个特征图只卷一半的输入特征图，因此也要求group必须为输入和输出通道数整除。实际测试一下：

# 输入全为1
X = torch.ones(1, 2, 4, 4)
# net1 groups为1， 权重参数初始化为1
net1 = nn.Conv2d(2, 4, 3, 1, 1, groups=1, bias=False)
nn.init.constant_(net1.weight, val=1)
print('net1_output', net1(X))
# net2 groups为2， 权重参数初始化为1
net2 = nn.Conv2d(2, 4, 3, 1, 1, groups=2, bias=False)
nn.init.constant_(net2.weight, val=1)
print('net2_output', net2(X))

观察输出，可以验证上述描述：

net1_output tensor([[[[ 8., 12., 12.,  8.],
          [12., 18., 18., 12.],
          [12., 18., 18., 12.],
          [ 8., 12., 12.,  8.]],

         [[ 8., 12., 12.,  8.],
          [12., 18., 18., 12.],
          [12., 18., 18., 12.],
          [ 8., 12., 12.,  8.]],

         [[ 8., 12., 12.,  8.],
          [12., 18., 18., 12.],
          [12., 18., 18., 12.],
          [ 8., 12., 12.,  8.]],

         [[ 8., 12., 12.,  8.],
          [12., 18., 18., 12.],
          [12., 18., 18., 12.],
          [ 8., 12., 12.,  8.]]]], grad_fn=<MkldnnConvolutionBackward>)
net2_output tensor([[[[4., 6., 6., 4.],
          [6., 9., 9., 6.],
          [6., 9., 9., 6.],
          [4., 6., 6., 4.]],

         [[4., 6., 6., 4.],
          [6., 9., 9., 6.],
          [6., 9., 9., 6.],
          [4., 6., 6., 4.]],

         [[4., 6., 6., 4.],
          [6., 9., 9., 6.],
          [6., 9., 9., 6.],
          [4., 6., 6., 4.]],

         [[4., 6., 6., 4.],
          [6., 9., 9., 6.],
          [6., 9., 9., 6.],
          [4., 6., 6., 4.]]]], grad_fn=<MkldnnConvolutionBackward>)

MobileNet的深度可分离卷积

mobilenet实现了网络的轻量化，其核心的深度可分离卷积将传统的卷积分解为一个深度卷积（depthwise convolution）+ 一个 1×1的卷积（pointwise convolution。

传统卷积

$N\times C_{in}\times H\times W$的特征输入经过$in\_channel\times out\_channel$的卷积核$k\times k$之后变为$N\times C_{out}\times H^{{}^{\prime }}\times W^{{}^{\prime }}$的特征图，图示如下：

途中输入的灰色部分为padding，输出的每个特征图都是由输入与$i{n}_{c}hannel$个卷积核卷积之后相加得到的，即可以拆分成如下形式

深度可分离卷积

对上述过程不再赘述，深度可分离卷积将第二图中的kernel部分与add部分做了改动，先放图如下

传统卷积操作每个输出特征图都来自于in_channel个卷积核对每个输入特征图做卷积操作，然后将每个输出相加得到；而深度可分离卷积则首先将每个输入特征图用in_channel个卷积核进行操作，然后将每个卷积后的in_channel个特征图用out_channel个1X1卷积按不同权重相加。

• 优点

最大的优点就是大大减少参数量（毕竟为移动端而生）
以上图的2X4X4输入（输入为2个通道），卷积核3X3， 输出4X4X4（输出4个通道）为例，第一个图中的传统卷积操作需要参数量为$3\times 3\times 2\times 4$，使用深度可分离卷积后的参数量为$3\times 3\times 2+1\times 1\times 4$，当实际网络中大量通道运算时，可想而知网络的参数量大大减少。

深度可分离卷积是如何减少参数量的

那参数量是怎么减少的呢，或者说从哪里刨除的参数呢？

传统卷积计算某个输出通道上的某点时，先使用in_channel个卷积核对输入特征图进行卷积可得到in_channel个值，然后按权重为1相加即为某输出特征图上某点的值，当计算另外一个输出通道上的某点时，则需使用新的in_channel个卷积核对输入特征图进行卷积得到in_channel个值，然后按权重为1相加，也就是说每个输出特征图都是被不同组的in_channel个卷积核处理的。

而深度可分离卷积上计算某输出通道上的某点时，先使用in_channel个卷积核对输入特征图进行卷积可得到in_channel个值，然后按不同权重相加即为某输出特征图上某点的值，当计算另外一个输出通道上的某点时，还是使用那IN_channel个卷积核先处理，然后按新的权重相加。

• 缺点

减少的那部分参数是不值真的没用呢？深度可分离卷积不同输出通道上某点，在输入特征图上感受野范围内的像素的权重分布是相同的（因为所有输出通道都是被相同卷积核处理的），而传统卷积则可以有着更多的变化。

Pytorch的 MobileNetV2 实现(含深度可分离卷积)

arch = ((1, 16, 1, 1),
        (6, 24, 2, 2),
        (6, 32, 3, 2),
        (6, 64, 4, 2),
        (6, 96, 3, 1),
        (6, 160, 3, 2),
        (6, 320, 1, 1))
        
class ConvBNReLU(nn.Sequential):
    def __init__(self, in_channel, out_channel, kernel_size=3, stride=1, groups=1):
        padding = (kernel_size - 1) // 2
        super(ConvBNReLU, self).__init__(
            nn.Conv2d(in_channel, out_channel, kernel_size, stride, padding, groups=groups, bias=False),
            nn.BatchNorm2d(out_channel),
            nn.ReLU6(inplace=True)
        )

class InvertedResidual(nn.Module):
    def __init__(self, in_channel, out_channel, stride, expand_ratio):
        super(InvertedResidual, self).__init__()
        self.use_res_connect = stride == 1 and in_channel == out_channel
        blk = []
        if expand_ratio != 1:
            blk.append(ConvBNReLU(in_channel, in_channel*expand_ratio, 1, 1))
            
        # 这里设置group为输入通道大小，下面紧接着是输出通道数的1X1卷积
        blk.append(ConvBNReLU(in_channel*expand_ratio, in_channel*expand_ratio, 3, stride, groups=in_channel*expand_ratio))
        blk.append(nn.Conv2d(in_channel*expand_ratio, out_channel, 1, 1, bias=False))
        blk.append(nn.BatchNorm2d(out_channel))
        self.conv = nn.Sequential(*blk)
    def forward(self, X):
        if self.use_res_connect:
            return X + self.conv(X)
        else:
            return self.conv(X)
    
class MobileNetV2(nn.Module):
    def __init__(self, arch=arch):
        super(MobileNetV2, self).__init__()
        block = []
        block.append(ConvBNReLU(3, 32, 3, 2))
        in_channel = 32
        for i, (t, c, n, s) in enumerate(arch):
            for j in range(n):
                stride = s if j == 0 else 1
                block.append(InvertedResidual(in_channel, c, stride, t))
                in_channel = c
        block.append(ConvBNReLU(320, 1280, 1, 1))
        self.features = nn.Sequential(*block)
        self.classifier = nn.Sequential(nn.Dropout(),
                                        nn.Linear(1280, 1000))
        
    def forward(self, X):
        X = self.features(X)
        X = F.adaptive_avg_pool2d(X, 1)
        X = self.classifier(X.view(X.shape[0], -1))
        return X

参考：

[1] pytorch中文文档

[2] pytorch源码