SK

论文地址：.06586.pdf

代码地址：

1.是什么？

SK-net网络是一种增加模块嵌入到一些网络中的注意力机制，它可以嵌入和Resnet中进行补强，嵌入和方法和Se-net类似。SKNet的全称是“Selective Kernel Network”，它和SENet都是一个团队提出来的。SENet是对通道执行注意力机制，而SKNet则是对卷积核执行注意力机制，即让网络自己选择合适的卷积核。SKNet的核心模块包括多分支卷积网络、组卷积、空洞卷积以及注意力机制。在该模块中，作者使用了多尺寸的卷积核，让网络自己选择合适的尺度。SK-net网络的优点是可以提高网络的准确性和泛化能力，同时减少了网络的参数数量和计算量。

2.为什么？

SKNet的设计在以下几个方面具有优势：

多尺度信息融合
通过选择性地应用不同尺度的卷积核，SKNet能够有效地融合多尺度的特征信息。这有助于网络捕捉不同层次的视觉特征，提高了特征的表征能力。

自适应性
选择模块使网络能够自适应地选择卷积核的尺度，从而适应不同任务和图像的特点。这种自适应性能够使网络在各种场景下都能表现出色。

减少计算成本
尽管引入了多尺度卷积核，但由于选择模块的存在，SKNet只会选择一部分卷积核进行计算，从而减少了计算成本，保持了网络的高效性。
 

3.怎么样？

3.1网络模型

SK-net的整个流程如下：
（1）Split划分
    首先使用不同的卷积核获得两个不同的特征图。
（2）Fuse融合
    融合两个不同的特征图，然后将它们通过全局平均池化的方式提取出每一个通道的融合值。再通过线性层进行通过压缩，这里和Se-net的通道注意力是一样的。
（3）Select选择
    在通过一个Softmax层进行选择，后续的操作和Se-net是一样的，得到通过挑选的特征图。这里的特征图可以看到每一个通道所使用的卷积核是不一样的，也是通过学习得到的。

3.2 网络结构

3.3 代码实现

SKConv

import torch.nn as nn
import torchclass 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 = Mself.features = featuresself.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 = feaelse: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 = vectorelse: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 fea_vif __name__ == "__main__":t = torch.ones((32, 256, 24,24))sk = SKConv(256,WH=1,M=2,G=1,r=2)out = sk(t)print(out.shape)

SKNet

import torch.nn as nn
import torch
from functools import reduce
class SKConv(nn.Module):def __init__(self,in_channels,out_channels,stride=1,M=2,r=16,L=32):''':param in_channels:  输入通道维度:param out_channels: 输出通道维度   原论文中 输入输出通道维度相同:param stride:  步长，默认为1:param M:  分支数:param r: 特征Z的长度，计算其维度d 时所需的比率（论文中 特征S->Z 是降维，故需要规定 降维的下界）:param L:  论文中规定特征Z的下界，默认为32'''super(SKConv,self).__init__()d=max(in_channels//r,L)   # 计算向量Z 的长度dself.M=Mself.out_channels=out_channelsself.conv=nn.ModuleList()  # 根据分支数量 添加 不同核的卷积操作for i in range(M):# 为提高效率，原论文中 扩张卷积5x5为 （3X3，dilation=2）来代替。 且论文中建议组卷积G=32self.conv.append(nn.Sequential(nn.Conv2d(in_channels,out_channels,3,stride,padding=1+i,dilation=1+i,groups=32,bias=False),nn.BatchNorm2d(out_channels),nn.ReLU(inplace=True)))self.global_pool=nn.AdaptiveAvgPool2d(1) # 自适应pool到指定维度    这里指定为1，实现 GAPself.fc1=nn.Sequential(nn.Conv2d(out_channels,d,1,bias=False),nn.BatchNorm2d(d),nn.ReLU(inplace=True))   # 降维self.fc2=nn.Conv2d(d,out_channels*M,1,1,bias=False)  # 升维self.softmax=nn.Softmax(dim=1) # 指定dim=1  使得两个全连接层对应位置进行softmax,保证 对应位置a+b+..=1def forward(self, input):batch_size=input.size(0)output=[]#the part of splitfor i,conv in enumerate(self.conv):#print(i,conv(input).size())output.append(conv(input))#the part of fusionU=reduce(lambda x,y:x+y,output) # 逐元素相加生成 混合特征Us=self.global_pool(U)z=self.fc1(s)  # S->Z降维a_b=self.fc2(z) # Z->a，b 升维  论文使用conv 1x1表示全连接。结果中前一半通道值为a,后一半为ba_b=a_b.reshape(batch_size,self.M,self.out_channels,-1) #调整形状，变为 两个全连接层的值a_b=self.softmax(a_b) # 使得两个全连接层对应位置进行softmax#the part of selectiona_b=list(a_b.chunk(self.M,dim=1))#split to a and b   chunk为pytorch方法，将tensor按照指定维度切分成 几个tensor块a_b=list(map(lambda x:x.reshape(batch_size,self.out_channels,1,1),a_b)) # 将所有分块  调整形状，即扩展两维V=list(map(lambda x,y:x*y,output,a_b)) # 权重与对应  不同卷积核输出的U 逐元素相乘V=reduce(lambda x,y:x+y,V) # 两个加权后的特征 逐元素相加return V
class SKBlock(nn.Module):'''基于Res Block构造的SK BlockResNeXt有  1x1Conv（通道数：x） +  SKConv（通道数：x）  + 1x1Conv（通道数：2x） 构成'''expansion=2 #指 每个block中 通道数增大指定倍数def __init__(self,inplanes,planes,stride=1,downsample=None):super(SKBlock,self).__init__()self.conv1=nn.Sequential(nn.Conv2d(inplanes,planes,1,1,0,bias=False),nn.BatchNorm2d(planes),nn.ReLU(inplace=True))self.conv2=SKConv(planes,planes,stride)self.conv3=nn.Sequential(nn.Conv2d(planes,planes*self.expansion,1,1,0,bias=False),nn.BatchNorm2d(planes*self.expansion))self.relu=nn.ReLU(inplace=True)self.downsample=downsampledef forward(self, input):shortcut=inputoutput=self.conv1(input)output=self.conv2(output)output=self.conv3(output)if self.downsample is not None:shortcut=self.downsample(input)output+=shortcutreturn self.relu(output)
class SKNet(nn.Module):'''参考 论文Table.1 进行构造'''def __init__(self,nums_class=1000,block=SKBlock,nums_block_list=[3, 4, 6, 3]):super(SKNet,self).__init__()self.inplanes=64# in_channel=3  out_channel=64  kernel=7x7 stride=2 padding=3self.conv=nn.Sequential(nn.Conv2d(3,64,7,2,3,bias=False),nn.BatchNorm2d(64),nn.ReLU(inplace=True))self.maxpool=nn.MaxPool2d(3,2,1) # kernel=3x3 stride=2 padding=1self.layer1=self._make_layer(block,128,nums_block_list[0],stride=1) # 构建表中 每个[] 的部分self.layer2=self._make_layer(block,256,nums_block_list[1],stride=2)self.layer3=self._make_layer(block,512,nums_block_list[2],stride=2)self.layer4=self._make_layer(block,1024,nums_block_list[3],stride=2)self.avgpool=nn.AdaptiveAvgPool2d(1) # GAP全局平均池化self.fc=nn.Linear(1024*block.expansion,nums_class) # 通道 2048 -> 1000self.softmax=nn.Softmax(-1) # 对最后一维进行softmaxdef forward(self, input):output=self.conv(input)output=self.maxpool(output)output=self.layer1(output)output=self.layer2(output)output=self.layer3(output)output=self.layer4(output)output=self.avgpool(output)output=output.squeeze(-1).squeeze(-1)output=self.fc(output)output=self.softmax(output)return outputdef _make_layer(self,block,planes,nums_block,stride=1):downsample=Noneif stride!=1 or self.inplanes!=planes*block.expansion:downsample=nn.Sequential(nn.Conv2d(self.inplanes,planes*block.expansion,1,stride,bias=False),nn.BatchNorm2d(planes*block.expansion))layers=[]layers.append(block(self.inplanes,planes,stride,downsample))self.inplanes=planes*block.expansionfor _ in range(1,nums_block):layers.append(block(self.inplanes,planes))return nn.Sequential(*layers)
def SKNet50(nums_class=1000):return SKNet(nums_class,SKBlock,[3, 4, 6, 3]) # 论文通过[3, 4, 6, 3]搭配出SKNet50
def SKNet101(nums_class=1000):return SKNet(nums_class,SKBlock,[3, 4, 23, 3])
if __name__=='__main__':x = torch.rand(2, 3, 224, 224)model=SKNet50()y=model(x)print(y) # shape [2,1000]

参考：SKNet学习和使用-pytorch

【深度学习注意力机制系列】—— SKNet注意力机制（附pytorch实现）