ResNeXt

🍨 本文为🔗365天深度学习训练营中的学习记录博客
🍖 原作者：K同学啊# 前言

前言

前面已经学习了resnet家族已经inception卷积网络，还简单了解了SE注意力机制，今天学习resnet和inception的组合ResNeXt。

简介

ResNeXt是一种深度神经网络结构，它是ResNet（残差网络）和Inception（启发式卷积神经网络）的结合体。ResNeXt的主要思想是在神经网络中引入一种称为“分组卷积”的操作，从而实现更好的特征提取。相比于传统的卷积操作，分组卷积可以更好地利用GPU的并行计算能力，从而提高模型的运行速度和效率。

ResNeXt的核心组成部分是“简化Inception”模块，该模块通过对输入数据进行split、transform和merge操作，可以在多个分支上进行特征提取。与传统的Inception模块相比，简化Inception的主要优势在于，它的各个分支采用了相同的拓扑结构，从而避免了复杂的手动调整过程。这使得ResNeXt具有更少的超参数，更容易实现优化。

在ResNeXt中，分组卷积的操作是通过控制“基数”参数来实现的。通过调整基数，我们可以控制分组的数量，从而在普通卷积和深度可分离卷积之间找到一种折中的解决方案。这种方法能够在保持模型性能的同时，有效地减少模型的参数量。

ResNeXt的另一个关键特性是其“短路结构”，这是一种用于连接网络层的简单机制。通过引入短路结构，ResNeXt能够更好地处理不同尺度的特征，并且能够提高模型的泛化能力。

ResNeXt是一种高效、易用的深度神经网络结构，它通过引入分组卷积和简化Inception模块，实现了更好的特征提取和更快的运行速度。尽管ResNeXt在某些方面可能不如InceptionV4（例如，在某些任务中InceptionV4可能会有更好的效果），但它仍然是一种非常实用的网络结构，广泛应用于各种计算机视觉任务中。
在这里插入图片描述

网络实现

import torch.nn.functional as F
from collections import OrderedDict
import torch
import torch.nn as nn

class BN_Conv2d(nn.Module):
    """
    BN_CONV_RELU
    """

    def __init__(self, in_channels, out_channels, kernel_size, stride, padding, dilation=1, groups=1, bias=False):
        super(BN_Conv2d, self).__init__()
        self.seq = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride,
                      padding=padding, dilation=dilation, groups=groups, bias=bias),
            nn.BatchNorm2d(out_channels)
        )

    def forward(self, x):
        return F.relu(self.seq(x))


class ResNeXt_Block(nn.Module):
    """
    ResNeXt block with group convolutions
    """

    def __init__(self, in_chnls, cardinality, group_depth, stride):
        super(ResNeXt_Block, self).__init__()
        self.group_chnls = cardinality * group_depth
        self.conv1 = BN_Conv2d(in_chnls, self.group_chnls, 1, stride=1, padding=0)
        self.conv2 = BN_Conv2d(self.group_chnls, self.group_chnls, 3, stride=stride, padding=1, groups=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):
    """
    ResNeXt builder
    """

    def __init__(self, layers: object, cardinality, group_depth, num_classes) -> object:
        super(ResNeXt, self).__init__()
        self.cardinality = cardinality
        self.channels = 64
        self.conv1 = BN_Conv2d(3, self.channels, 7, stride=2, padding=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(ResNeXt_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