使用PyTorch搭建ResNet101、ResNet152网络

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

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

参照我的ResNet50的搭建，由于50层以上几乎相同，叠加卷积单元数即可，所以没有写注释。
ResNet101和152的搭建注释可以参照我的ResNet50搭建中的注释
ResNet101和152的训练可以参照我的ResNet18搭建中的训练部分

ResNet101和152可以依旧参照ResNet50的网络图片：
在这里插入图片描述

上代码：

ResNet101的model.py模型：

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


class DownSample(nn.Module):
    def __init__(self, in_channel, out_channel, stride):
        super(DownSample, self).__init__()
        self.down = nn.Sequential(
            nn.Conv2d(in_channel, out_channel, kernel_size=1, stride=stride, padding=0, bias=False),
            nn.BatchNorm2d(out_channel),
            nn.ReLU(inplace=True)
        )

    def forward(self, x):
        out = self.down(x)
        return out


class ResNet101(nn.Module):
    def __init__(self, classes_num):            # 指定分类数
        super(ResNet101, self).__init__()
        self.pre = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        )
        # --------------------------------------------------------------------
        self.layer1_first = nn.Sequential(
            nn.Conv2d(64, 64, kernel_size=1, stride=1, padding=0, bias=False),
            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),
            nn.BatchNorm2d(256)
        )
        self.layer1_next = nn.Sequential(
            nn.Conv2d(256, 64, kernel_size=1, stride=1, padding=0, bias=False),
            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),
            nn.BatchNorm2d(256)
        )
        # --------------------------------------------------------------------
        self.layer2_first = nn.Sequential(
            nn.Conv2d(256, 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=2, 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.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))
        self.fc = nn.Sequential(
            nn.Dropout(p=0.5),
            nn.Linear(2048 * 1 * 1, 1000),
            nn.ReLU(inplace=True),
            nn.Dropout(p=0.5),
            nn.Linear(1000, classes_num)
        )

    def forward(self, x):
        out = self.pre(x)
        # --------------------------------------------------------------------
        layer1_shortcut = DownSample(64, 256, 1)
        layer1_shortcut.to('cuda:0')
        layer1_identity = layer1_shortcut(out)
        out = self.layer1_first(out)
        out = F.relu(out + layer1_identity, inplace=True)

        for i in range(2):
            identity = out
            out = self.layer1_next(out)
            out = F.relu(out + identity, inplace=True)
        # --------------------------------------------------------------------
        layer2_shortcut = DownSample(256, 512, 2)
        layer2_shortcut.to('cuda:0')
        layer2_identity = layer2_shortcut(out)
        out = self.layer2_first(out)
        out = F.relu(out + layer2_identity, inplace=True)

        for i in range(3):
            identity = out
            out = self.layer2_next(out)
            out = F.relu(out + identity, inplace=True)
        # --------------------------------------------------------------------
        layer3_shortcut = DownSample(512, 1024, 2)
        layer3_shortcut.to('cuda:0')
        layer3_identity = layer3_shortcut(out)
        out = self.layer3_first(out)
        out = F.relu(out + layer3_identity, inplace=True)

        for i in range(22):
            identity = out
            out = self.layer3_next(out)
            out = F.relu(out + identity, inplace=True)
        # --------------------------------------------------------------------
        layer4_shortcut = DownSample(1024, 2048, 2)
        layer4_shortcut.to('cuda:0')
        layer4_identity = layer4_shortcut(out)
        out = self.layer4_first(out)
        out = F.relu(out + layer4_identity, inplace=True)

        for i in range(2):
            identity = out
            out = self.layer4_next(out)
            out = F.relu(out + identity, inplace=True)
        # --------------------------------------------------------------------
        out = self.avg_pool(out)
        out = out.reshape(out.size(0), -1)
        out = self.fc(out)

        return out

ResNet152的model.py模型：

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


class DownSample(nn.Module):
    def __init__(self, in_channel, out_channel, stride):
        super(DownSample, self).__init__()
        self.down = nn.Sequential(
            nn.Conv2d(in_channel, out_channel, kernel_size=1, stride=stride, padding=0, bias=False),
            nn.BatchNorm2d(out_channel),
            nn.ReLU(inplace=True)
        )
        
    def forward(self, x):
        out = self.down(x)
        return out


class ResNet152(nn.Module):
    def __init__(self, classes_num):            # 指定了分类数目
        super(ResNet152, self).__init__()
        self.pre = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        )
        # -----------------------------------------------------------------------
        self.layer1_first = nn.Sequential(
            nn.Conv2d(64, 64, kernel_size=1, stride=1, padding=0, bias=False),
            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),
            nn.BatchNorm2d(256)
        )
        self.layer1_next = nn.Sequential(
            nn.Conv2d(256, 64, kernel_size=1, stride=1, padding=0, bias=False),
            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),
            nn.BatchNorm2d(256)
        )
        # -----------------------------------------------------------------------
        self.layer2_first = nn.Sequential(
            nn.Conv2d(256, 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=2, 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.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))
        self.fc = nn.Sequential(
            nn.Dropout(p=0.5),
            nn.Linear(2048 * 1 * 1, 1000),
            nn.ReLU(inplace=True),
            nn.Dropout(p=0.5),
            nn.Linear(1000, classes_num)
        )

    def forward(self, x):
        out = self.pre(x)
        # -----------------------------------------------------------------------
        layer1_shortcut = DownSample(64, 256, 1)
        # layer1_shortcut.to('cuda:0')
        layer1_identity = layer1_shortcut(out)
        out = self.layer1_first(out)
        out = F.relu(out + layer1_identity, inplace=True)

        for i in range(2):
            identity = out
            out = self.layer1_next(out)
            out = F.relu(out + identity, inplace=True)
        # -----------------------------------------------------------------------
        layer2_shortcut = DownSample(256, 512, 2)
        # layer2_shortcut.to('cuda:0')
        layer2_identity = layer2_shortcut(out)
        out = self.layer2_first(out)
        out = F.relu(out + layer2_identity, inplace=True)

        for i in range(7):
            identity = out
            out = self.layer2_next(out)
            out = F.relu(out + identity, inplace=True)
        # -----------------------------------------------------------------------
        layer3_shortcut = DownSample(512, 1024, 2)
        # layer3_shortcut.to('cuda:0')
        layer3_identity = layer3_shortcut(out)
        out = self.layer3_first(out)
        out = F.relu(out + layer3_identity, inplace=True)

        for i in range(35):
            identity = out
            out = self.layer3_next(out)
            out = F.relu(out + identity, inplace=True)
        # -----------------------------------------------------------------------
        layer4_shortcut = DownSample(1024, 2048, 2)
        # layer4_shortcut.to('cuda:0')
        layer4_identity = layer4_shortcut(out)
        out = self.layer4_first(out)
        out = F.relu(out + layer4_identity, inplace=True)

        for i in range(2):
            identity = out
            out = self.layer4_next(out)
            out = F.relu(out + identity, inplace=True)
        # -----------------------------------------------------------------------
        out = self.avg_pool(out)
        out = out.reshape(out.size(0), -1)
        out = self.fc(out)

        return out
爱吃苹果的派大星
关注
  • 9
    点赞
  • 踩
  • 83
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
PyTorch实现ResNet50、ResNet101和ResNet152示例
09-18
今天小编就为大家分享一篇PyTorch实现ResNet50、ResNet101和ResNet152示例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Pytorch搭建ResNet
x1027105273的博客
03-13 3882
Pytorch搭建ResNet 1、网络架构 ResNet的网络架构这里就不做过多解释，论文原文网络结构如下图，详细可以参照你必须要知道CNN模型：ResNet 2、环境搭建 pytorch版本：1.10.2 python版本：3.6.15 pytorch的安装教程可以参照pytorch的安装和入门使用 3、模型搭建 3.1 定义ResNet[18,34]基础残差块BasicBlock expension用来区分残差结构中不同层卷积核的个数，（50，101，152）的残差块中的第三层卷积和个数时是第
PyTorch图像分类实战：模型训练与验证（迁学习篇）
最新发布
bishedaima_com_q的博客
06-10 38
说完卷积层，在说一下全连接层，必须要注意不管卷积层选A还是B，全连接层都是要更新的，原因在于，别人模型进行图像分类可能是进行1000个分类，而你只进行100或者999个分类，那么全连接层的参数肯定是不同的。，此时在初始化自己模型权重（就是卷积层，池化层和全连接层的参数）时，可以用人家训练好的模型参数（如果不这样就需要随机初始化模型权重），这样做可以节省大量寻找最优参数的时间，又可以保证参数的准确。冻结卷积层网络又分几种情况。：看下图最大的红框，表示卷积层，当用别人的模型时，对卷积层的两种处理方式。
Pytorch-预训练网络
qq_59711487的博客
12-30 1099
我们可以把预训练的神经网络看作一个接收输入并生成输出的程序，该程序的行为是由神经网络的结构以及它在训练过程中所看到的样本所决定的，即期望的输入-输出对，或者期望输出应该满足的特性。我们可以在Pytorch中加载和运行这些预训练好的模型。
【深度学习】ResNet网络详解
1900的博客
10-16 2万+
ResNet
PyTorch——调用ResNet的预训练模型做图片分类
qq_45828494的博客
04-26 4822
import torch from torchvision import models from PIL import Image from torchvision import transforms dir(models) img=Image.open("C:/Users/Dell/Desktop/446598877159358796.jpg") #img.show() preprocess=transforms.Compose([ transforms.Resize(256), tr.
Resnet152对102种花朵图像分类（PyTorch，迁移学习）
人工智能方向，计算机视觉
08-03 5296
PyTorch框架构建花朵识别模型（Resnet网络，迁移学习）
使用pytorch搭建ResNet并基于迁移学习训练
断言的博客
01-22 2487
文章目录model.pytrain.pypredict.py ResNet网络参数列表 model.py train.py predict.py
人工智能-深度学习-ResNet网络-使用Pytorch实现ResNet50进行跨年龄人脸识别-Pytorch
03-16
本主题聚焦于“人工智能”的一个分支——“深度学习”，特别是关于ResNet网络的使用。ResNet（残差神经网络）是深度学习领域的一个重要模型，由Kaiming He等人在2015年提出，解决了深度神经网络训练时的梯度消失问题...
pytorch 实现resnet模型 细节讲解
01-07
残差神经网络 (ResNet)也是需要掌握的模型，需要自己手动实现理解细节。本文就是对代码的细节讲解，话不多说，开始了。 首先你需要了解它的结构，本文以resnet50围绕讲解，网络的输入照片大小是224×224的经过conv1...
Python-DeepLabResNet101COCOStuff10k的PyTorch实现
08-11
DeepLab (ResNet-101) COCO-Stuff 10k的PyTorch实现
ResNet-101-model.caffemodel
05-22
ResNet101模型，from Kaiming He大神。可以用来训练模型。
Pytorch搭建ResNet（附完整代码）
u013310820的博客
12-20 4596
卷积神经网络逐渐取代传统算法，成为处理计算机视觉任务的核心，ResNet[1]的提出更是CNN图像史上一件里程碑事件。当网络深度增加时，网络准确度出现饱和甚至下降，残差学习的提出解决了网络退化的问题。ResNet通过shortcut的方法让信息跨层传播，被跨越的层拟合的就是shortcut连接的两层之间的残差。
ResNet详细解读
热门推荐
花有重开日 人无再少年
10-22 8万+
这篇文章是Deep Residual Learning for Image Recognition 的翻译，精简部分内容的同时补充了相关的概念，如有错误，敬请指正。
ResNet 的 PyTorch 实现
FortiLZ的博客
06-29 1万+
ResNet 的文章有两篇：Deep Residual Learning for Image Recognition 和 Identity Mappings in Deep Residual Networks。这里仅仅关注三个问题：ResNet 解决了机器学习中的什么问题；ResNet 的代码怎么写的；ResNet 怎么用。至于文章中的性能研究和试验结果，就不做讨论了。 Deep Resid...
resnet18到resnet152模型pytorch实现
jameschen9051的博客
03-09 2896
resnet在深度学习领域的重要性不言而喻，自从15年resnet提出后，被各种深度学习模型大量引用。得益于其残差结构的设计，使得深度学习模型可以训练更深层的网络。常见的resnet有resnet18、resnet34、resnet50、resnet101、resnet152几种结构，resnet残差网络由一个卷积块和四个残差块组成，每个残差块包含多个残差结构。从残差结构上看，resnet18和resnet34结构近似，使用相同的残差结构，仅在残差结构数量上有区别，都是使用两个卷积层加一个残...
python tk 在图片上添加文字
06-08
要在Tkinter窗口中的图片上添加文字，可以使用Python的Pillow库和Tkinter库。以下是一个示例代码： ```python from PIL import Image, ImageDraw, ImageFont import tkinter as tk from tkinter import filedialog def add_text(image, text): # 创建一个Draw对象 draw = ImageDraw.Draw(image) # 设置字体 font = ImageFont.truetype("arial.ttf", 36) # 添加文字 draw.text((50, 50), text, font=font, fill=(255, 255, 255)) def open_image(): # 打开文件选择框 filename = filedialog.askopenfilename() # 打开图片 image = Image.open(filename) # 在图片上添加文字 add_text(image, "Hello, World!") # 显示图片 tkimage = ImageTk.PhotoImage(image) label.config(image=tkimage) label.image = tkimage # 创建主窗口 root = tk.Tk() # 创建标签用来显示图片 label = tk.Label(root) label.pack() # 创建按钮用来打开图片 button = tk.Button(root, text="Open Image", command=open_image) button.pack() # 进入主循环 root.mainloop() ``` 这个示例代码使用了Tkinter的filedialog模块来打开文件选择框，让用户选择要处理的图片。处理图片的代码与之前的示例相同，只是在添加文字后，将图片显示在Tkinter窗口中。需要注意的是，在Tkinter窗口中显示图片需要使用ImageTk库中的PhotoImage类。最后，通过创建一个按钮来触发打开图片的操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值