使用PyTorch搭建ResNet50网络

已于 2022-02-25 00:39:11 修改
阅读量5.7k 收藏 49
点赞数 4
分类专栏： 经典神经网络模型 PyTorch 文章标签： pytorch 网络 深度学习
于 2022-02-25 00:26:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TTTSEP9TH2244/article/details/123123067
版权

ResNet18的搭建请移步：使用PyTorch搭建ResNet18网络并使用CIFAR10数据集训练测试
ResNet34的搭建请移步：使用PyTorch搭建ResNet34网络
ResNet101、ResNet152的搭建请移步：使用PyTorch搭建ResNet101、ResNet152网络

看过我之前ResNet18和ResNet34搭建的朋友可能想着可不可以把搭建18和34层的方法直接用在50层以上的ResNet的搭建中，我也尝试过。但是ResNet50以上的网络搭建不像是18到34层只要简单修改卷积单元数目就可以完成，ResNet50以上的三种网络都是一个样子，只是层数不同，所以完全可以将34到50层作为一个搭建分水岭。
加上我初学PyTorch和深度神经网络，对于采用BasicBlock和BottleNeck的高效率构建还不是很懂，所以这里给出了类似前两种ResNet的简单暴力堆叠网络层的构建方法

ResNet50网络结构

所有不同层数的ResNet：
在这里插入图片描述

这里给出了我认为比较详细的ResNet50网络具体参数和执行流程图：
在这里插入图片描述
直接上代码

model.py模型部分：

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

"""
这里的ResNet50的搭建是暴力形式，直接累加完成搭建，没采用BasicBlock和BottleNeck
第一个DownSample类，用于定义shortcut的模型函数，完成两个layer之间虚线的shortcut，负责layer1虚线的升4倍channel以及其他layer虚线的升2倍channel
观察每一个layer的虚线处升channel仅仅是升channel前后的数量不同以及stride不同，对于kernel_size和padding都分别是1和0，不作为DownSample网络类的模型参数
参数in_channel即是升之前的通道数, out_channel即是升之后的通道数, stride即是每一次升channel不同的stride步长，对于layer1升通道的stride=1，其他layer升通道的stride=2，注意不同
"""
"""
运行时一定要注意：
本网络中的ResNet50类中forward函数里面：layer1_shortcut1.to('cuda:0')；layer2_shortcut1.to('cuda:0')等语句，是将实例化的DownSample
网络模型放到train.py训练脚本中定义的GPU同一环境下，不加此句一般会如下报错：
Input type (torch.cuda.FloatTensor) and weight type (torch.FloatTensor) should be the same
"""


class DownSample(nn.Module):

    def __init__(self, in_channel, out_channel, stride):            # 传入下采样的前后channel数以及stride步长
        super(DownSample, self).__init__()                          # 继承父类
        self.down = nn.Sequential(                                  # 定义一个模型容器down
            nn.Conv2d(in_channel, out_channel, kernel_size=1, stride=stride, padding=0, bias=False),    # 负责虚线shortcut的唯一且重要的一次卷积
            nn.BatchNorm2d(out_channel),                            # 在卷积和ReLU非线性激活之间，添加BatchNormalization
            nn.ReLU(inplace=True)                                   # shortcut最后加入一个激活函数，置inplace=True原地操作，节省内存
        )

    def forward(self, x):
        out = self.down(x)                                          # 前向传播函数仅仅完成down这个容器的操作
        return out


"""
第一个ResNet50类，不使用BottleNeck单元完成ResNet50层以上的搭建，直接使用forward再加上前面的DownSample模型类函数，指定ResNet50所有参数构建模型
"""


class ResNet50(nn.Module):

    def __init__(self, classes_num):                                # ResNet50仅传一个分类数目，将涉及的所有数据写死，具体数据可以参考下面的图片
        super(ResNet50, self).__init__()
        # 在进入layer1234之间先进行预处理，主要是一次卷积一次池化，从[batch, 3, 224, 224] => [batch, 64, 56, 56]
        self.pre = nn.Sequential(
            # 卷积channel从原始数据的3通道，采用64个卷积核，升到64个channel，卷积核大小、步长、padding均固定
            nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False),
            nn.BatchNorm2d(64),                                     # 卷积后紧接一次BatchNormalization
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1)        # 预处理最后的一次最大池化操作，数据固定
        )
        """
        每一个layer的操作分为使用一次的first，和使用多次的next组成，first负责每个layer的第一个单元（有虚线）的三次卷积，next负责剩下单元（直连）的三次卷积
        """
        # --------------------------------------------------------------
        self.layer1_first = nn.Sequential(
            nn.Conv2d(64, 64, kernel_size=1, stride=1, padding=0, bias=False),      # layer1_first第一次卷积保持channel不变，和其他layer的first区别
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1, bias=False),      # layer1_first第二次卷积stride和其他layer_first的stride不同
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 256, kernel_size=1, stride=1, padding=0, bias=False),     # layer1_first第三次卷积和其他layer一样，channel升4倍
            nn.BatchNorm2d(256)                                         # 注意最后一次卷积结束不加ReLU激活函数
        )
        self.layer1_next = nn.Sequential(
            nn.Conv2d(256, 64, kernel_size=1, stride=1, padding=0, bias=False),     # layer1_next的第一次卷积负责将channel减少，减少训练参数量
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 256, kernel_size=1, stride=1, padding=0, bias=False),     # layer1_next的最后一次卷积负责将channel增加至可以与shortcut相加
            nn.BatchNorm2d(256)
        )
        # --------------------------------------------------------------    # layer234操作基本相同，这里仅介绍layer2
        self.layer2_first = nn.Sequential(
            nn.Conv2d(256, 128, kernel_size=1, stride=1, padding=0, bias=False),    # 与layer1_first第一次卷积不同，需要降channel至1/2
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            nn.Conv2d(128, 128, kernel_size=3, stride=2, padding=1, bias=False),    # 注意这里的stride=2与layer34相同，与layer1区别
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            nn.Conv2d(128, 512, kernel_size=1, stride=1, padding=0, bias=False),    # 再次升channel
            nn.BatchNorm2d(512)
        )
        self.layer2_next = nn.Sequential(
            nn.Conv2d(512, 128, kernel_size=1, stride=1, padding=0, bias=False),    # 负责循环普通的操作
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            nn.Conv2d(128, 512, kernel_size=1, stride=1, padding=0, bias=False),
            nn.BatchNorm2d(512)
        )
        # --------------------------------------------------------------
        self.layer3_first = nn.Sequential(
            nn.Conv2d(512, 256, kernel_size=1, stride=1, padding=0, bias=False),
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, stride=2, padding=1, bias=False),
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 1024, kernel_size=1, stride=1, padding=0, bias=False),
            nn.BatchNorm2d(1024)
        )
        self.layer3_next = nn.Sequential(
            nn.Conv2d(1024, 256, kernel_size=1, stride=1, padding=0, bias=False),
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 1024, kernel_size=1, stride=1, padding=0, bias=False),
            nn.BatchNorm2d(1024)
        )
        # --------------------------------------------------------------
        self.layer4_first = nn.Sequential(
            nn.Conv2d(1024, 512, kernel_size=1, stride=1, padding=0, bias=False),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, stride=2, padding=1, bias=False),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 2048, kernel_size=1, stride=1, padding=0, bias=False),
            nn.BatchNorm2d(2048)
        )
        self.layer4_next = nn.Sequential(
            nn.Conv2d(2048, 512, kernel_size=1, stride=1, padding=0, bias=False),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 2048, kernel_size=1, stride=1, padding=0, bias=False),
            nn.BatchNorm2d(2048)
        )
        self.avg_pool = nn.AdaptiveAvgPool2d((1, 1))     # 经过最后的自适应均值池化为[batch, 2048, 1, 1]
        # 定义最后的全连接层
        self.fc = nn.Sequential(
            nn.Dropout(p=0.5),                  # 以0.5的概率失活神经元
            nn.Linear(2048 * 1 * 1, 1024),      # 第一个全连接层
            nn.ReLU(inplace=True),
            nn.Dropout(p=0.5),
            nn.Linear(1024, classes_num)        # 第二个全连接层，输出类结果
        )

    """
    forward()前向传播函数负责将ResNet类中定义的网络层复用，再与上面的DownSample类完美组合
    """
    def forward(self, x):
        out = self.pre(x)                                       # 对输入预处理，输出out = [batch, 64, 56, 56]
        """
        每一层layer操作由两个部分组成，第一个是带有虚线的卷积单元，其他的是循环完成普通的shortcut为直连的卷积单元
        """
        layer1_shortcut1 = DownSample(64, 256, 1)               # 使用DownSample实例化一个网络模型layer1_shortcut1，参数即是虚线处升channel数据，注意stride=1
        layer1_shortcut1.to('cuda:0')
        layer1_identity1 = layer1_shortcut1(out)                # 调用layer1_shortcut1对卷积单元输入out计算虚线处的identity，用于后面与卷积单元输出相加
        out = self.layer1_first(out)                            # 调用layer1_first完成layer1的第一个特殊的卷积单元
        out = F.relu(out + layer1_identity1, inplace=True)      # 将identity与卷积单元输出相加，经过relu激活函数

        for i in range(2):                                      # 使用循环完成后面几个相同输入输出相同操作的卷积单元
            layer_identity = out                                # 直接直连identity等于输入
            out = self.layer1_next(out)                         # 输入经过普通卷积单元
            out = F.relu(out + layer_identity, inplace=True)    # 两路结果相加，再经过激活函数
        # --------------------------------------------------------------后面layer234都是类似的，这里仅介绍layer2
        
        layer2_shortcut1 = DownSample(256, 512, 2)              # 注意后面layer234输入输出channel不同，stride=2都是如此
        layer2_shortcut1.to('cuda:0')
        layer2_identity1 = layer2_shortcut1(out)
        out = self.layer2_first(out)
        out = F.relu(out + layer2_identity1, inplace=True)      # 完成layer2的第一个卷积单元
        
        for i in range(3):                                      # 循环执行layer2剩下的其他卷积单元
            layer_identity = out
            out = self.layer2_next(out)
            out = F.relu(out + layer_identity, inplace=True)
        # --------------------------------------------------------------

        layer3_shortcut1 = DownSample(512, 1024, 2)
        layer3_shortcut1.to('cuda:0')
        layer3_identity1 = layer3_shortcut1(out)
        out = self.layer3_first(out)
        out = F.relu(out + layer3_identity1, inplace=True)

        for i in range(5):
            layer_identity = out
            out = self.layer3_next(out)
            out = F.relu(out + layer_identity, inplace=True)
        # --------------------------------------------------------------

        layer4_shortcut1 = DownSample(1024, 2048, 2)
        layer4_shortcut1.to('cuda:0')
        layer4_identity1 = layer4_shortcut1(out)
        out = self.layer4_first(out)
        out = F.relu(out + layer4_identity1, inplace=True)

        for i in range(2):
            layer_identity = out
            out = self.layer4_next(out)
            out = F.relu(out + layer_identity, inplace=True)
        # 最后一个全连接层
        out = self.avg_pool(out)                # 经过最后的自适应均值池化为[batch, 2048, 1, 1]
        out = out.reshape(out.size(0), -1)      # 将卷积输入[batch, 2048, 1, 1]展平为[batch, 2048*1*1]
        out = self.fc(out)                  # 经过最后一个全连接单元，输出分类out

        return out

ResNet50的训练可以参照我的ResNet18搭建中的训练和测试部分：
使用PyTorch搭建ResNet18网络并使用CIFAR10数据集训练测试

经过手写ResNet50网络模型的暴力搭建，我认识到了要想把ResNet及其其他复杂网络的搭建，前提必须要把模型整个流程环节全部弄清楚
例如，ResNet50里面每一次的shortcut里面的升维操作的in_channel,out_channel,kernel_size,stride,padding的参数大小变化
每一个卷积单元具体参数都是什么样的，如何才能最大化简化代码；
还有就是搭建复杂的网络模型中，一定要做到步步为营，一步步搭建并检验，每一步都要理解有理有据，最后才能将整个网络搭建起来
还有一个意外收获就是在训练过程中，发现了这样的报错：
Input type (torch.cuda.FloatTensor) and weight type (torch.FloatTensor) should be the same
原来是因为输入的数据类型为torch.cuda.FloatTensor，说明输入数据在GPU中。模型参数的数据类型为torch.FloatTensor，说明模型还在CPU
故在ResNet50的forward()函数中对实例化的DownSample网络添加到和train.py对ResNet50实例化的网络模型的同一个GPU下，解决了错误

爱吃苹果的派大星
关注
  • 4
    点赞
  • 踩
  • 49
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
基于Pytorch的Resnet深度学习神经网络CIFAR10识别分类训练测试实现
05-04
本程序实现了对CIFAR10数据集的下载，处理，以及数据增强，并将其分解为训练集和测试集，并完整搭建好Resent网络，实现模型的训练和测试，并得到测试准曲率结果，适合基于Pytorch的Resnet深度学习网络分类识别的功能...
使用pytorch搭建AlexNet操作(微调预训练模型及手动搭建)
12-23
在PyTorch中，搭建AlexNet网络模型是一个常见的任务，特别是在迁移学习的场景下。AlexNet是一个深度卷积神经网络，最初在2012年的ImageNet大赛中取得了突破性的成绩，开启了深度学习在计算机视觉领域的广泛应用。在...
使用pytorch构建ResNet50模型训练猫狗数据集
最新发布
jingshi123456的博客
05-29 624
【代码】使用pytorch构建ResNet50模型训练猫狗数据集。
pytorch逐行搭建CNN系列（三）ResNet50
nszzzzdr的博客
03-22 1640
在这里插入图片描述](https://img-blog.csdnimg.cn/cda0a32ed5ec48d1a1b58a8377783483.png。提出Batch Normalization 加速训练（丢弃dropout）:将一批数据的feature map转化为满足均值=0，方差=1的分布。提出了残差网络块（Residual）：人为地让神经网络某些层跳过下一层神经元的连接，隔层相连，弱化每层之间的强联系。利用summary()函数打印网络结构和参数。使用了一种shortcut的跳跃连接方式。
第11周：ResNet-50算法实战与解析（Pytorch实现）
weixin_46620278的博客
05-24 1310
🍨 本文为[🔗365天深度学习训练营](https://mp.weixin.qq.com/s/0dvHCaOoFnW8SCp3JpzKxg) 中的学习记录博客🍖 原作者：[K同学啊](https://mtyjkh.blog.csdn.net/)说在前面本周学习目标：了解残差结构，根据原始的Tensorflow代码、编写出响应的Pytorch代码解决问题：识别小鸟的种类我的环境：Python3.8、Pycharm2020、torch1.12.1+cu113。
使用pytorch搭建resnet50
zzpl139的博客
02-10 1571
使用pytorch搭建resnet50
pytorch实现resnet50（训练+测试+模型转换）
gm_Ergou的博客
07-05 1万+
本章使用pytorch训练resnet50，使用cifar数据集。 数据集： 代码工程： 1.train.py import torch from torch import nn, optim import torchvision.transforms as transforms from torchvision import datasets from torch.utils.data import DataLoader from resnet50 import ResNet5
pytorch resnet50_用Pytorch手工实现ResNet50
weixin_39926613的博客
11-21 406
《吴恩达深度学习课程》第四课第二周的作业是：使用Keras和Tensorflow编写ResNet50，用程序实现题目中描述的网络结构。由于程序填空提供了不少示例，做完后仍感觉理解不透彻，又使用Pytorch实现了一遍。ResNet50包含49个卷积层和1个全连接层，属于较大型的网络，实现起来略有难度。对于理解数据流、卷积层、残差、瓶颈层，以及对大型网络的编写和调试都有很大帮助。使用的数据仍是第四课...
【深度学习】如何用PyTorch构建一个ResNet50网络？（附代码）
fengdu78的博客
03-21 1248
ResNet（Residual Network）是一种深度卷积神经网络，具有非常深的网络结构，并在ImageNet图像分类比赛中取得了很好的成绩。ResNet的一个关键点是增加了残差块（residual block），使网络更容易训练。ResNet引入了“跳跃连接”或“shortcut connections”，使网络可以从较浅的层直接跳到深层的层，这样可以解决深度网络中的梯度消失和梯度爆炸问题，...
VGG卷积神经网络图像分类训练Pytorch代码 使用Cifar100数据集
01-28
# VGG卷积神经网络图像分类训练Pytorch代码 使用Cifar100数据集 1. VGG网络模型的Pytorch实现代码，包含特征提取器features和分类器classifier两部分，简明易懂； 2. 使用Cifar100数据集进行图像分类训练，初次训练...
pytorch-resnet18和resnet50官方预训练模型
08-22
pytroch官网提供的预训练模型：resnet18：resnet18-5c106cde.pth和resnet50：resnet50-19c8e357.pth（两个文件打包在一起）
pytorch搭建的各种常见分类网络的工程，如googlenet、squeezenet、resnet等
09-05
pytorch搭建的各种常见分类网络的工程，如attention56、attention92、densenet121、densenet169、densenet201、densenet161、googlenet、inceptionv3、inceptionv4、mobilenet、mobilenetv2、nasnet、preactresnet18...
卷积神经网络学习—Resnet50（论文精读+pytorch代码复现）
热门推荐
ZhengrongYue的博客
07-04 3万+
卷积神经网络学习—Resnet50（论文精读+pytorch代码复现）
从零手写Resnet50实战——利用 torch 识别出了虎猫和萨摩耶
AI与算法都要通俗易懂
04-21 462
大家好啊，我是董董灿。自从前几天手写了一个慢速卷积之后（从零手写Resnet50实战—手写龟速卷积），我便一口气将 Resnet50 中剩下的算法都写完了。然后，暴力的，按照 Resnet50 的结构，将手写的算法一层层地连接了起来。算法的手写和网络的搭建，没有调用任何第三方库，这也是这个项目的初衷。相关代码都已经上传至：项目根目录/python/inference.py，项目地址在文章末尾。
Pytorch迁移学习使用Resnet50进行模型训练预测猫狗二分类
weixin_46414659的博客
07-23 356
深度学习在图像分类、目标检测、语音识别等领域取得了重大突破，但是随着网络层数的增加，梯度消失和梯度爆炸问题逐渐凸显。随着层数的增加，梯度信息在反向传播过程中逐渐变小，导致网络难以收敛。同时，梯度爆炸问题也会导致网络的参数更新过大，无法正常收敛。为了解决这些问题，ResNet提出了一个创新的思路：引入残差块（Residual Block）。残差块的设计允许网络学习残差映射，从而减轻了梯度消失问题，使得网络更容易训练。下图是一个基本残差块。
PyTorch实现ResNet50,训练数据：CIFAR-10
weixin_36979214的博客
09-30 5377
ResNet网络结构 基本块 ResNet50代码实现 resnet50.py import torch import torch.nn as nn from torch.nn import functional as F class ResNet50BasicBlock(nn.Module): def __init__(self, in_channel, outs, kernerl_size, stride, padding): super(ResNet50BasicBl
Pytorch深度学习基础 实战天气图片识别（基于ResNet50预训练模型，超详细）
mengxianglong123的博客
10-15 1万+
🔥本项目使用Pytroch，并基于ResNet50模型，实现了对天气图片的识别，过程详细，十分适合基础阶段的同学阅读。项目目录结构核心步骤数据处理准备配置文件构建自定义DataSet及Dataloader构建模型训练模型编写预测模块效果展示。
构建ResNet-50模型 CIFAR-10 数据训练
weixin_41733381的博客
05-28 347
【代码】构建ResNet-50模型 CIFAR-10 数据训练。
PyTorch搭建ResNet18
06-10
这是一个标准的 ResNet18 的 PyTorch 实现，其中包括了 `BasicBlock` 和 `ResNet` 两个类，以及 `resnet18` 函数，用于构建 ResNet18 模型。你可以在 `ResNet` 类中自定义层数和其他参数，如 `num_classes`（分类...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值