ResNeSt

paper：ResNeSt: Split-Attention Networks

official implementation：https://github.com/zhanghang1989/ResNeSt

third-party implementation：https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/resnest.py

ResNeXt（具体介绍见https://blog.csdn.net/ooooocj/article/details/122394742）引入了"cardinality"超参，将特征图沿通道分为多个cardinal group，具体实现时对应组卷积的group数。本文又引入了一个"radix"超参，即在每个cardinal group内又将特征图进一步split成多个radix group，下图是ResNeSt block和SE-Net block以及SK-Net block的对比，关于这两篇文章的介绍见https://blog.csdn.net/ooooocj/article/details/122485342、https://blog.csdn.net/ooooocj/article/details/122683493。其中各个网络的split attention的具体实现方式不同。

下图是一个cardinal group内的split attention，首先通过卷积将特征图沿通道划分为多个splits，然后相加并进行全局平均池化，经过两个dense linear层并取softmax后每个radix split得到一个对应的权重，然后加权相加后得到最终输出。这样看起来其实和SENet比较像，区别在于SENet对整个输入特征图进行操作，然后特征图的每个通道得到一个对应的权重。而ResNeSt将特征图先分成多个cardinal group然后又将每个cardinal group划分成多个radix group，然后split attention是在每个cardinal group内进行的，最后每个cardinal group得到一个对应的权重。 

ResNeXt有三种等价的实现方式，其中组卷积的实现最简洁。这里为了实现简便，作者也将原始的先cardinal group后radix group的方式等价转换成了下图的方式，其中将不同cardinal group中同一radix索引的group放到一起，变成了先radix后cardinal的分组形式，这样就可以通过组卷积来实现。

这里以timm中的实现为例，对照代码和图4讲解下具体实现。模型选择"resnest50d_4s2x40d"，即cardinality=2，radix=4。输入大小为(1, 3, 224, 224)。 

首先看ResNestBottleneck类的forward函数，这里经过前面的stem处理后输入shape=(1, 64, 56, 56)。其中self.conv1为Conv2d(64, 80, kernel_size=(1, 1), stride=(1, 1), bias=False)，对应的就是图4每个radix group里第一个1x1卷积，按照图4实际应该有2x4=8列，即8个输出通道数为80/2/4=10的1x1卷积，这里将8个卷积合并到一起了。

接下来self.conv2就是split attention，代码如下。forward函数中self.conv对应的是图4中第二行蓝框的3x3卷积，这里每个卷积的输出通道数为c'/k=80/2=40，这里也是通过组卷积将8个卷积合并到一起了。然后当radix>1时先reshape将radix维度分离出来，然后沿radix维度相加，对应图4中间那个+。然后x_gap.mean就是global pooling。self.fc1和self.fc2对应两个dense层，具体通过groups=k=2的1x1组卷积实现。然后通过radixsoftmax沿radix维度取softmax，这样每个radix group都得到一个对应的权重，最后x * x_attn加权求和得到split attention的最终输出。

class RadixSoftmax(nn.Module):
    def __init__(self, radix, cardinality):
        super(RadixSoftmax, self).__init__()
        self.radix = radix  # 2
        self.cardinality = cardinality  # 1

    def forward(self, x):  # (1,320,1,1)
        batch = x.size(0)
        if self.radix > 1:
            x = x.view(batch, self.cardinality, self.radix, -1).transpose(1, 2)  # (1,2,4,40)->(1,4,2,40)
            x = F.softmax(x, dim=1)
            x = x.reshape(batch, -1)  # (1,320)
        else:
            x = torch.sigmoid(x)
        return x


class SplitAttn(nn.Module):
    """Split-Attention (aka Splat)
    """
    def __init__(self, in_channels, out_channels=None, kernel_size=3, stride=1, padding=None,
                 dilation=1, groups=1, bias=False, radix=2, rd_ratio=0.25, rd_channels=None, rd_divisor=8,
                 act_layer=nn.ReLU, norm_layer=None, drop_layer=None, **kwargs):
        super(SplitAttn, self).__init__()
        out_channels = out_channels or in_channels  # 80
        self.radix = radix
        mid_chs = out_channels * radix  # 80*4=320
        if rd_channels is None:  # None
            attn_chs = make_divisible(in_channels * radix * rd_ratio, min_value=32, divisor=rd_divisor)  # 80*4*0.25, 8; 80
        else:
            attn_chs = rd_channels * radix

        padding = kernel_size // 2 if padding is None else padding
        self.conv = nn.Conv2d(
            in_channels, mid_chs, kernel_size, stride, padding, dilation,
            groups=groups * radix, bias=bias, **kwargs)  # 2*4
        self.bn0 = norm_layer(mid_chs) if norm_layer else nn.Identity()
        self.drop = drop_layer() if drop_layer is not None else nn.Identity()
        self.act0 = act_layer(inplace=True)
        self.fc1 = nn.Conv2d(out_channels, attn_chs, 1, groups=groups)  # 80,80,2
        self.bn1 = norm_layer(attn_chs) if norm_layer else nn.Identity()
        self.act1 = act_layer(inplace=True)
        self.fc2 = nn.Conv2d(attn_chs, mid_chs, 1, groups=groups)  # 80,320,2
        self.rsoftmax = RadixSoftmax(radix, groups)  # 4,2

    def forward(self, x):  # (1,80,56,56)
        # Conv2d(80, 320, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=8, bias=False)
        x = self.conv(x)  # (1,320,56,56), c'/k=80/2=40, 这里通过group=8的组卷积每组的输入输出为c'/k=40
        x = self.bn0(x)
        x = self.drop(x)
        x = self.act0(x)

        B, RC, H, W = x.shape  # 320
        if self.radix > 1:
            x = x.reshape((B, self.radix, RC // self.radix, H, W))  # (1,4,80,56,56)
            x_gap = x.sum(dim=1)  # (1,80,56,56)
        else:
            x_gap = x
        x_gap = x_gap.mean((2, 3), keepdim=True)  # (1,80,1,1), c'=80
        # Conv2d(80, 80, kernel_size=(1, 1), stride=(1, 1), groups=2)
        x_gap = self.fc1(x_gap)  # (1,80,1,1), c''=80
        x_gap = self.bn1(x_gap)
        x_gap = self.act1(x_gap)
        # Conv2d(80, 320, kernel_size=(1, 1), stride=(1, 1), groups=2)
        x_attn = self.fc2(x_gap)  # (1,320,1,1), c'r=80x4=320

        x_attn = self.rsoftmax(x_attn).view(B, -1, 1, 1)  # (1,320)->(1,320,1,1)
        if self.radix > 1:
            out = (x * x_attn.reshape((B, self.radix, RC // self.radix, 1, 1))).sum(dim=1)  # (1,4,80,56,56)*(1,4,80,1,1)->(1,4,80,56,56)->(1,80,56,56)
        else:
            out = x * x_attn
        return out.contiguous()