365天深度学习训练营-第J6周：ResNeXt-50实战解析

 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
🍖 参考原作者：K同学啊|接辅导、项目定制

一、模型结构

使用ResNeXt-50算法完成猴痘病识别

ResNeXt-50算法特点：将前面卷积输出的特征图按channel分组卷积，以达到减少参数量的目的。

算法结构如下：

        ResNeXt中采用的分组卷机简单来说就是将特征图分为不同的组，再对每组特征图分别进行卷积，这个操作可以有效的降低计算量。
        在分组卷积中，每个卷积核只处理部分通道，比如下图中，红色卷积核只处理红色的通道，绿色卷积核只处理绿色通道，黄色卷积核只处理黄色通道.此时每个卷积核有2个通道，每个卷积核生成一张特征图。

二、复现模型

class Conv(nn.Module):
    def __init__(self, c1, c2, k, s, p, d=1, g=1):
        super().__init__()
        self.conv = nn.Conv2d(c1, c2, k, s, p, d, g, bias=False)
        self.bn = nn.BatchNorm2d(c2)
        self.act = nn.ReLU()

    def forward(self, x):
        return self.act(self.bn(self.conv(x)))

class Conv_Block(nn.Module):
    def __init__(self, in_chnls, cardinality, group_depth, stride):
        super(Conv_Block, self).__init__()
        self.group_chnls = cardinality * group_depth
        self.conv1 = Conv(in_chnls, self.group_chnls, 1, s=1, p=0)
        self.conv2 = Conv(self.group_chnls, self.group_chnls, 3, s=stride, p=1, g=cardinality)
        self.conv3 = nn.Conv2d(self.group_chnls, self.group_chnls * 2, 1, stride=1, padding=0)
        self.bn = nn.BatchNorm2d(self.group_chnls * 2)
        self.short_cut = nn.Sequential(
            nn.Conv2d(in_chnls, self.group_chnls * 2, 1, stride, 0, bias=False),
            nn.BatchNorm2d(self.group_chnls * 2)
        )

    def forward(self, x):
        out = self.conv1(x)
        out = self.conv2(out)
        out = self.bn(self.conv3(out))
        out += self.short_cut(x)
        return F.relu(out)

class ResNeXt(nn.Module):
    def __init__(self, layers, cardinality, group_depth, num_classes):
        super(ResNeXt, self).__init__()
        self.cardinality = cardinality
        self.channels = 64
        self.conv1 = Conv(3, self.channels, 7, s=2, p=3)
        d1 = group_depth
        self.conv2 = self._make_layers(d1, layers[0], stride=1)
        d2 = d1 * 2
        self.conv3 = self._make_layers(d2, layers[1], stride=2)
        d3 = d2 * 2
        self.conv4 = self._make_layers(d3, layers[2], stride=2)
        d4 = d3 * 2
        self.conv5 = self._make_layers(d4, layers[3], stride=2)
        self.fc = nn.Linear(self.channels, num_classes)  # 224x224 input size

    def _make_layers(self, d, blocks, stride):
        strides = [stride] + [1] * (blocks - 1)
        layers = []
        for stride in strides:
            layers.append(Conv_Block(self.channels, self.cardinality, d, stride))
            self.channels = self.cardinality * d * 2
        return nn.Sequential(*layers)

    def forward(self, x):
        out = self.conv1(x)
        out = F.max_pool2d(out, 3, 2, 1)
        out = self.conv2(out)
        out = self.conv3(out)
        out = self.conv4(out)
        out = self.conv5(out)
        out = F.avg_pool2d(out, 7)
        out = out.view(out.size(0), -1)
        out = F.softmax(self.fc(out), dim=1)
        return out

 三、结果