深度学习论文: Selective Kernel Networks及其PyTorch实现

Selective Kernel Networks
PDF:​​​https://arxiv.org/pdf/1903.06586.pdf​​​

PyTorch: ​​https://github.com/implus/SKNet​​

1 概述

SENet是对特征图的通道注意力机制的研究，之前的CBAM提到了对特征图空间注意力机制的研究。这里SKNet针对卷积核的注意力机制研究。

SKNet提出了一种机制，即卷积核的重要性，即不同的图像能够得到具有不同重要性的卷积核。

SKNet对不同图像使用的卷积核权重不同，即一种针对不同尺度的图像动态生成卷积核。

2 Selective Kernel Convolution

网络主要由Split、Fuse、Select三部分组成

Split: 对原特征图经过不同大小的卷积核部分进行卷积

文中分为了两个卷积，分别是 3∗3 和 5∗5 的卷积。且对于 5∗5的卷积，可以采用膨胀因子是 2 的 3∗3的空洞卷积；

Fuse: 计算每个卷积核权重的部分
a. 各个分支的特征进行元素间的相加
b.全局平均池化来获得提特征的全局信息
c. 生成一个压缩后的特征向量

Select: 根据不同权重卷积核计算后得到的新的特征图

PyTorch实现:

class SKConv(nn.Module):
    def __init__(self, features, WH, M, G, r, stride=1, L=32):
        super(SKConv, self).__init__()
        d = max(int(features / r), L)
        self.M = M
        self.features = features
        self.convs = nn.ModuleList([])
        for i in range(M):
            # 使用不同kernel size的卷积
            self.convs.append(
                nn.Sequential(
                    nn.Conv2d(features,
                              features,
                              kernel_size=3 + i * 2,
                              stride=stride,
                              padding=1 + i,
                              groups=G), nn.BatchNorm2d(features),
                    nn.ReLU(inplace=False)))
            
        self.fc = nn.Linear(features, d)
        self.fcs = nn.ModuleList([])
        for i in range(M):
            self.fcs.append(nn.Linear(d, features))
        self.softmax = nn.Softmax(dim=1)

    def forward(self, x):
        for i, conv in enumerate(self.convs):
            fea = conv(x).unsqueeze_(dim=1)
            if i == 0:
                feas = fea
            else:
                feas = torch.cat([feas, fea], dim=1)
        fea_U = torch.sum(feas, dim=1)
        fea_s = fea_U.mean(-1).mean(-1)
        fea_z = self.fc(fea_s)
        for i, fc in enumerate(self.fcs):
            print(i, fea_z.shape)
            vector = fc(fea_z).unsqueeze_(dim=1)
            print(i, vector.shape)
            if i == 0:
                attention_vectors = vector
            else:
                attention_vectors = torch.cat([attention_vectors, vector],
                                              dim=1)
        attention_vectors = self.softmax(attention_vectors)
        attention_vectors = attention_vectors.unsqueeze(-1).unsqueeze(-1)
        fea_v = (feas * attention_vectors).sum(dim=1)
        return

3 Network Architecture

4 思维导图

图片来自: ​​【Deep Learning】SKNet : Selective Kernel Networks 学习​​