文章目录

1.网络简介

​ ResNet网络是在2015年由微软实验室何凯明等人提出的，斩获当年ImageNet竞赛中分类任务第一名，目标检测第一名。获得COCO数据集中目标检测第一名，图像分割第一名。各项名誉加身，引领了深度学习发展潮流。

​ 在ResNet网络提出之前，传统的卷积神经网络都是通过将一系列卷积层与下采样层进行堆叠得到的。但是当堆叠到一定网络深度时，就会出现两个问题。1）梯度消失或梯度爆炸。 2）退化问题(degradation problem)。在ResNet论文中说通过数据的预处理以及在网络中使用BN（Batch Normalization）层能够解决梯度消失或者梯度爆炸问题。但是对于退化问题（并没有很好的解决办法。

​ ResNet论文提出了residual结构（残差结构）来减轻退化问题。

​ 亮点：

（1）解决深度网络退化问题：

  • 随着神经网络深度的增加，传统的网络结构会出现训练误差增大、性能下降的问题，这被称为深度网络退化。ResNet 的核心思想是引入了残差学习（residual learning）来解决这个问题。
  • 残差学习的基本思想是让网络学习输入和输出之间的残差，而不是直接学习输出。这样可以使网络更容易优化，即使网络非常深，也能有效地训练。

（2）残差块结构：

  • ResNet 的基本构建块是残差块（residual block）。一个典型的残差块由两部分组成：
    • 主路径（identity path）：也称为直连路径，直接将输入传递到输出。这部分通常包含一些卷积层和批量归一化层（Batch Normalization），用于提取特征。
    • 残差路径（residual path）：由几个卷积层和批量归一化层组成，用于学习输入和输出之间的残差。残差路径的输出与主路径的输入相加，得到最终的输出。
  • 这种结构使得网络可以更容易地学习输入和输出之间的微小变化，从而提高了网络的性能和训练效率。

​ 下面是网络的整体结构：

在这里插入图片描述

2.网络搭建

网络包含两种残差结构，较浅层的网络采用两个3x3卷积模块和一个residual分支，此浅层模块定义为BasicBlock。

注意，此结构的conv1和conv2 stride的区别，conv2_x上s=1，但是后面的conv3_x,4_x,5_x上的两个3x3卷积，第一个3x3卷积s=2。

在这里插入图片描述

# 18，34基础残差块
class BasicBlock(nn.Module):
    expansion = 1  # 18，34层第一层卷积核个数是一样的，更深层的卷积核个数不一样,对应expansion=4

    def __init__(self, in_channel, out_channel, stride=1, downsample=None):
        super(BasicBlock, self).__init__()
        # 第一层卷积输入输出维度一样，由于采取了BN，故不需要bias
        self.conv1 = nn.Conv2d(in_channels=in_channel, out_channels=out_channel,
                               kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_channel)
        self.relu = nn.ReLU()

        self.conv2 = nn.Conv2d(in_channels=out_channel, out_channels=out_channel,
                               kernel_size=3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channel)                       
        self.downsample = downsample  # 下采样操作，如果输入输出通道数不同，需要下采样调整

    def forward(self, x):
        identity = x  # 跳层连接
        if self.downsample is not None:
            identity = self.downsample(x)

        out = self.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out)) # 这层与捷径分支相加后，再relu
        out += identity
        out = self.relu(out)

        return out

针对ResNet50/101/152的残差结构，如下图所示，在该残差结构当中，主分支使用了三个卷积层，第一个是1x1的卷积层用来压缩channel维度，第二个是3x3的卷积层，第三个是1x1的卷积层用来还原channel维度（注意主分支上第一层卷积层和第二层卷积层所使用的卷积核个数是相同的，第三层是第一层的4倍）。该残差结构所对应的虚线残差结构如下图右侧所示，同样在捷径分支上有一层1x1的卷积层，它的卷积核个数与主分支上的第三层卷积层卷积核个数相同，注意每个卷积层的步距。（注意：原论文中，在下图右侧虚线残差结构的主分支中，第一个1x1卷积层的步距是2，第二个3x3卷积层步距是1。但在pytorch官方实现过程中是第一个1x1卷积层的步距是1，第二个3x3卷积层步距是2，这么做的好处是能够在top1上提升大概0.5%的准确率。

在这里插入图片描述

此结构定义为Bottleneck:

# 50,101,152层残差块
class Bottleneck(nn.Module):
    expansion = 4  # 第3层卷积核个数是前面层的4倍
    
    def __init__(self, in_channel, out_channel, stride=1, downsample=None):
        super(Bottleneck, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=in_channel, out_channels=out_channel,
                               kernel_size=1, stride=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_channel)
        self.relu = nn.ReLU(inplace=True)
        self.conv2 = nn.Conv2d(in_channels=out_channel, out_channels=out_channel,
                               kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channel)
        self.conv3 = nn.Conv2d(in_channels=out_channel, out_channels=out_channel*self.expansion,
                               kernel_size=1, stride=1, bias=False)
        self.bn3 = nn.BatchNorm2d(out_channel*self.expansion)
        self.downsample = downsample
        
    def forward(self, x):
        identity = x
        if self.downsample is not None:
            identity = self.downsample(x)
        
        out = self.relu(self.bn1(self.conv1(x)))
        
        out = self.relu(self.bn2(self.conv2(out)))
        out = self.bn3(self.conv3(out))
        out += identity
        out = self.relu(out)
        
        return out

构建网络：

# 残差网络
class ResNet(nn.Module):
    def __init__(self, block, blocks_num, num_classes=1000, include_top=True):
        """
        构建网络
        :param block: 哪种类型的block
        :param blocks_num: 每个stage中的block数量
        :param num_classes: 分类数，用于全连接层
        :param include_top: 是否需要头部全连接部分，如果不需要，可以用来做backbone
        """
        super(ResNet, self).__init__()
        self.include_top = include_top
        self.in_channel = 64

        # 第一层卷积，用于初始特征提取
        self.conv1 = nn.Conv2d(3, self.in_channel, kernel_size=7, stride=2, padding=3, bias=False)
        self.bn1 = nn.BatchNorm2d(self.in_channel)
        self.relu = nn.ReLU(inplace=True)
        # 最大池化层，用于缩小特征图尺寸
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        # 构建四个ResNet层，每个层由多个相同配置的block组成
        self.layer1 = self._make_layer(block, 64, blocks_num[0])
        self.layer2 = self._make_layer(block, 128, blocks_num[1], stride=2)
        self.layer3 = self._make_layer(block, 256, blocks_num[2], stride=2)
        self.layer4 = self._make_layer(block, 512, blocks_num[3], stride=2)
        # 如果包含顶部全连接层，则初始化平均池化层和全连接层
        if self.include_top:
            self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
            self.fc = nn.Linear(512 * block.expansion, num_classes)
                
        # 权重初始化，使用Kaiming初始化方法    
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
        
    def _make_layer(self, block, channel, block_num, stride=1):
        """
        构建layer，包含多个block
        block: 卷积块的类型，如BasicBlock或BottleneckBlock
        channel: 卷积块中的通道数
        block_num: 每个layer中包含的卷积块数量
        stride: 卷积块的步长，默认为1
        """
        downsample = None
        # 下采样操作
        if stride != 1 or self.in_channel != channel * block.expansion:
            downsample = nn.Sequential(
                nn.Conv2d(self.in_channel, channel * block.expansion, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(channel * block.expansion)
            )
            
        layers = []
        layers.append(block(self.in_channel, channel, downsample=downsample, stride=stride))
        self.in_channel = channel * block.expansion
        
        for _ in range(1, block_num):
            layers.append(block(self.in_channel, channel))
            
        return nn.Sequential(*layers)
    
    def forward(self, x):
        x = self.relu(self.bn1(self.conv1(x)))
        x = self.maxpool(x)
        
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)
        
        if self.include_top:
            x = self.avgpool(x)
            x = torch.flatten(x, 1)
            x = self.fc(x)
        
        return x

3.网络测试

训练环境和参数：

  • 数据集：花分类数据，包含daisy dandelion roses sunflowers tuilps五个类别，共4000多张，训练集占比70%
  • epochs:100
  • batch-size:32
    在这里插入图片描述

resnet18测试结果:
在这里插入图片描述

在这里插入图片描述

resnet50测试结果：

在这里插入图片描述

在这里插入图片描述

resnet18模型大小为42.72MB，resnet50模型大小为90.02MB，虽说参数量翻倍，但是模型F1 Score在任何类别上都没提升，感觉是训练轮次太少的原因。当我将训练轮次调到300后，有提升了

在这里插入图片描述

# 深度学习 # 人工智能
Logo
DAMO开发者矩阵

DAMO开发者矩阵，由阿里巴巴达摩院和中国互联网协会联合发起，致力于探讨最前沿的技术趋势与应用成果，搭建高质量的交流与分享平台，推动技术创新与产业应用链接，围绕“人工智能与新型计算”构建开放共享的开发者生态。

更多推荐

cover

Isaac 0.5：感知的缩放控制（上）

avatar DAMO开发者矩阵
cover

RoboTTT

avatar DAMO开发者矩阵

微信AI客服全自动回复实测：多模态读图+语音转写+精准报价，7天免费体验，白黑名单群聊智能过滤，拟人化话术秒回客户微客AI助手，电商门店私域流量获客神器真实测评

很多做生意的朋友都有过这样的无奈时刻：正忙着打包发货，手机叮叮咚咚响个不停，全是问“多少钱”“有没有货”的；等好不容易腾出手回消息，客户早就因为等不及去了别家。晚上想早点休息，可偏偏深夜还有客户来咨询，第二天醒来才发现错失了不少单子。请个专职客服吧，工资成本高不说，还很难保证每个人都能像老板自己那样熟悉产品、语气自然。其实，现在的技术已经能帮我们把这部分重复又耗时的接待工作自动化了。不是那种只会发

avatar DAMO开发者矩阵