diy一个ResNet18网络

于 2023-09-15 16:48:45 发布
阅读量124 收藏
点赞数 1
文章标签： 网络 python 开发语言 pytorch 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Holy_cow/article/details/132907400
版权

一、网络结构

1.1 残差结构

在这里插入图片描述
代码如下：

class ResidualBlock(nn.Module):
    def __init__(self, in_channels, out_channels, stride=1):
        super(ResidualBlock, self).__init__()
        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)

        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels)

        self.downsample = nn.Sequential()
        if stride != 1 or in_channels != out_channels:
            self.downsample = nn.Sequential(
                nn.Conv2d(in_channels, out_channels, stride=stride, kernel_size=1, bias=False))

    def forward(self, x):
        identity = x
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)

        out = self.conv2(out)
        out = self.bn2(out)

        out += self.downsample(identity)
        out = self.relu(out)

        return out

1.2 ResNet18网络结构

在这里插入图片描述
代码如下：

class ResNet(nn.Module):
    def __init__(self, num_classes=1000):
        super(ResNet, self).__init__()
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        self.layer1 = self.maker_layer(64, 64, blocks=2, stride=1)
        self.layer2 = self.maker_layer(64, 128, blocks=2, stride=2)
        self.layer3 = self.maker_layer(128, 256, blocks=2, stride=2)
        self.layer4 = self.maker_layer(256, 512, blocks=2, stride=2)
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(512, num_classes)

    def maker_layer(self, in_channels, out_channels, blocks, stride=1):
        layer = []
        layer.append(ResidualBlock(in_channels, out_channels, stride))
        for _ in range(1, blocks):
            layer.append(ResidualBlock(out_channels, out_channels))
        return nn.Sequential(*layer)

    def forward(self, x):
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
        out = self.maxpool(out)

        out = self.layer1(out)
        out = self.layer2(out)
        out = self.layer3(out)
        out = self.layer4(out)

        out = self.avgpool(out)
        out = torch.flatten(out, 1)
        out = self.fc(out)

        return out

二、运行结果：

ResNet(
  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (relu): ReLU(inplace=True)
  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
  (layer1): Sequential(
    (0): ResidualBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential()
    )
    (1): ResidualBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential()
    )
  )
  (layer2): Sequential(
    (0): ResidualBlock(
      (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)
      )
    )
    (1): ResidualBlock(
      (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential()
    )
  )
  (layer3): Sequential(
    (0): ResidualBlock(
      (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)
      )
    )
    (1): ResidualBlock(
      (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential()
    )
  )
  (layer4): Sequential(
    (0): ResidualBlock(
      (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
      )
    )
    (1): ResidualBlock(
      (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential()
    )
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
  (fc): Linear(in_features=512, out_features=1000, bias=True)
)
----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1         [-1, 64, 112, 112]           9,408
       BatchNorm2d-2         [-1, 64, 112, 112]             128
              ReLU-3         [-1, 64, 112, 112]               0
         MaxPool2d-4           [-1, 64, 56, 56]               0
            Conv2d-5           [-1, 64, 56, 56]          36,864
       BatchNorm2d-6           [-1, 64, 56, 56]             128
              ReLU-7           [-1, 64, 56, 56]               0
            Conv2d-8           [-1, 64, 56, 56]          36,864
       BatchNorm2d-9           [-1, 64, 56, 56]             128
             ReLU-10           [-1, 64, 56, 56]               0
    ResidualBlock-11           [-1, 64, 56, 56]               0
           Conv2d-12           [-1, 64, 56, 56]          36,864
      BatchNorm2d-13           [-1, 64, 56, 56]             128
             ReLU-14           [-1, 64, 56, 56]               0
           Conv2d-15           [-1, 64, 56, 56]          36,864
      BatchNorm2d-16           [-1, 64, 56, 56]             128
             ReLU-17           [-1, 64, 56, 56]               0
    ResidualBlock-18           [-1, 64, 56, 56]               0
           Conv2d-19          [-1, 128, 28, 28]          73,728
      BatchNorm2d-20          [-1, 128, 28, 28]             256
             ReLU-21          [-1, 128, 28, 28]               0
           Conv2d-22          [-1, 128, 28, 28]         147,456
      BatchNorm2d-23          [-1, 128, 28, 28]             256
           Conv2d-24          [-1, 128, 28, 28]           8,192
             ReLU-25          [-1, 128, 28, 28]               0
    ResidualBlock-26          [-1, 128, 28, 28]               0
           Conv2d-27          [-1, 128, 28, 28]         147,456
      BatchNorm2d-28          [-1, 128, 28, 28]             256
             ReLU-29          [-1, 128, 28, 28]               0
           Conv2d-30          [-1, 128, 28, 28]         147,456
      BatchNorm2d-31          [-1, 128, 28, 28]             256
             ReLU-32          [-1, 128, 28, 28]               0
    ResidualBlock-33          [-1, 128, 28, 28]               0
           Conv2d-34          [-1, 256, 14, 14]         294,912
      BatchNorm2d-35          [-1, 256, 14, 14]             512
             ReLU-36          [-1, 256, 14, 14]               0
           Conv2d-37          [-1, 256, 14, 14]         589,824
      BatchNorm2d-38          [-1, 256, 14, 14]             512
           Conv2d-39          [-1, 256, 14, 14]          32,768
             ReLU-40          [-1, 256, 14, 14]               0
    ResidualBlock-41          [-1, 256, 14, 14]               0
           Conv2d-42          [-1, 256, 14, 14]         589,824
      BatchNorm2d-43          [-1, 256, 14, 14]             512
             ReLU-44          [-1, 256, 14, 14]               0
           Conv2d-45          [-1, 256, 14, 14]         589,824
      BatchNorm2d-46          [-1, 256, 14, 14]             512
             ReLU-47          [-1, 256, 14, 14]               0
    ResidualBlock-48          [-1, 256, 14, 14]               0
           Conv2d-49            [-1, 512, 7, 7]       1,179,648
      BatchNorm2d-50            [-1, 512, 7, 7]           1,024
             ReLU-51            [-1, 512, 7, 7]               0
           Conv2d-52            [-1, 512, 7, 7]       2,359,296
      BatchNorm2d-53            [-1, 512, 7, 7]           1,024
           Conv2d-54            [-1, 512, 7, 7]         131,072
             ReLU-55            [-1, 512, 7, 7]               0
    ResidualBlock-56            [-1, 512, 7, 7]               0
           Conv2d-57            [-1, 512, 7, 7]       2,359,296
      BatchNorm2d-58            [-1, 512, 7, 7]           1,024
             ReLU-59            [-1, 512, 7, 7]               0
           Conv2d-60            [-1, 512, 7, 7]       2,359,296
      BatchNorm2d-61            [-1, 512, 7, 7]           1,024
             ReLU-62            [-1, 512, 7, 7]               0
    ResidualBlock-63            [-1, 512, 7, 7]               0
AdaptiveAvgPool2d-64            [-1, 512, 1, 1]               0
           Linear-65                 [-1, 1000]         513,000
================================================================
Total params: 11,687,720
Trainable params: 11,687,720
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.57
Forward/backward pass size (MB): 61.45
Params size (MB): 44.59
Estimated Total Size (MB): 106.61
----------------------------------------------------------------

进程已结束,退出代码0

附录：

import torch
import torch.nn as nn
from torchsummary import summary


class ResidualBlock(nn.Module):
    def __init__(self, in_channels, out_channels, stride=1):
        super(ResidualBlock, self).__init__()
        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)

        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels)

        self.downsample = nn.Sequential()
        if stride != 1 or in_channels != out_channels:
            self.downsample = nn.Sequential(
                nn.Conv2d(in_channels, out_channels, stride=stride, kernel_size=1, bias=False))

    def forward(self, x):
        identity = x
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)

        out = self.conv2(out)
        out = self.bn2(out)

        out += self.downsample(identity)
        out = self.relu(out)

        return out


class ResNet(nn.Module):
    def __init__(self, num_classes=1000):
        super(ResNet, self).__init__()
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        self.layer1 = self.maker_layer(64, 64, blocks=2, stride=1)
        self.layer2 = self.maker_layer(64, 128, blocks=2, stride=2)
        self.layer3 = self.maker_layer(128, 256, blocks=2, stride=2)
        self.layer4 = self.maker_layer(256, 512, blocks=2, stride=2)
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(512, num_classes)

    def maker_layer(self, in_channels, out_channels, blocks, stride=1):
        layer = []
        layer.append(ResidualBlock(in_channels, out_channels, stride))
        for _ in range(1, blocks):
            layer.append(ResidualBlock(out_channels, out_channels))
        return nn.Sequential(*layer)

    def forward(self, x):
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
        out = self.maxpool(out)

        out = self.layer1(out)
        out = self.layer2(out)
        out = self.layer3(out)
        out = self.layer4(out)

        out = self.avgpool(out)
        out = torch.flatten(out, 1)
        out = self.fc(out)

        return out


device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = ResNet().to(device)
print(model)
summary(model, (3, 224, 224))
Holy_cow
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
利用pytorch搭建ResNet18网络训练CIFAR100数据集
MarkAssassin的博客
11-10 2504
使用ResNet18网络训练CIFAR100数据集，并进行了优化使准确率得到提高
【ResNet】Pytorch从零构建ResNet18
热门推荐
通过图灵测试的人类的博客_CSDN_PYTHON_DeepLearning_数据挖掘
05-21 3万+
Pytorch从零构建ResNet18 ResNet 目前是应用很广的网络基础框架，所以有必要了解一下.本文从简单的ResNet18开始，详细分析了ResNet18的网络结构，并研究BasicBlock的结构。， 使得整个结构非常清晰，再之后手工构建ResNet18网络就没有那么困难了。
残差网络ResNet
weixin_42324577的博客
04-15 692
在VGG中，卷积网络达到了19层，在GoogLeNet中，网络史无前例的达到了22层。那么，网络的精度会随着网络的层数增多而增多吗？在深度学习中，网络层数增多一般会伴着下面几个问题 计算资源的消耗 模型容易过拟合 梯度消失/梯度爆炸问题的产生 问题1可以通过GPU集群来解决，对于一个企业资源并不是很大的问题；问题2的过拟合通过采集海量数据，并配合Dropout正则化等方法也可以有效避免；问题3通过Batch Normalization也可以避免。貌似我们只要无脑的增加网络的层数，我们就能从此获益，但实验数据
pytorch 手动顺序搭建resnet18、附带训练代码、测试代码、个人记录，若有错误，你可以去别处参考
雪剑封心
01-09 5627
文件名：mode_resnet18。
Resnet-18的搭建
DIECTOR_YUAN的博客
05-10 791
在Cifar10数据集上面搭建Resnet18 import tensorflow as tf import os import numpy as np from matplotlib import pyplot as plt from tensorflow.keras.layers import Conv2D, BatchNormalization, Activation, MaxPool2D, Dropout, Flatten, Dense from tensorflow.keras import Mo
ResNet18_resnet18_resnet18网络_
10-02
自己搭建了一个ResNet18网路，以供大家参考和学习，希望有用。
实际项目-基于LibTorch实现ResNet18网络推理过程c++源码(可编译).zip
06-25
实际项目-基于LibTorch实现ResNet18网络推理过程c++源码(可编译).zip实际项目-基于LibTorch实现ResNet18网络推理过程c++源码(可编译).zip实际项目-基于LibTorch实现ResNet18网络推理过程c++源码(可编译).zip实际项目...
resnet18.zip
07-08
利用resnet18预训练模型训练自己的数据集，代码包括了模型训练和利用新模型对数据进行分类的代码。
（python源码）基于ResNet18网络的图像分类算法实现分类
最新发布
05-15
基于ResNet18网络的图像分类算法是一种深度学习中的图像分类方法，它利用了ResNet18这一特定的卷积神经网络结构来实现对图像的分类。 ResNet18的名称来源于其网络中包含的18个卷积层（包括卷积操作和残差块中的卷...
将matlab神经网络工具箱代码导出-Resnet18:Resnet18
06-12
是一个卷积神经网络，它在来自 ImageNet 数据库的超过一百万张图像上进行了训练。 结果，网络已经为各种图像学习了丰富的特征表示。 该网络可以将图像分为 1000 个对象类别，例如键盘、鼠标、铅笔和许多动物。 该...
resnet_18_structure.pdf
09-25
resnet 18 网络结构（摘要需要大于50个字节，所以请自动忽略这个括号。。。）
来亲自手搭一个ResNet18网络
qq_41387508的博客
08-02 1114
在何大佬的文章中，提出了下面两种残差块： 残差块 左边的称为building block，右边的称为bottleneck building block。 左边的输入和输出都是64个channel的，四四方方的，像个建筑物；右边的就好像通过了一个瓶颈一样，输入残差块的网络通道数会先从256变成64，然后最终再升到256，其中降维和升维使用的是1x1的卷积，可以减少参数量； 代码 Building Block，就是之前写的（换了激活函数）: class ResidualBlock(nn.Modul.
【Pytorch】ResNet-18实现Cifar-10图像分类
AMG_GT的博客
04-23 2万+
一、ResNet-18网络结构 ResNet全名Residual Network残差网络。Kaiming He 的《Deep Residual Learning for Image Recognition》获得了CVPR最佳论文。他提出的深度残差网络在2015年可以说是洗刷了图像方面的各大比赛，以绝对优势取得了多个比赛的冠军。而且它在保证网络精度的前提下，将网络的深度达到了1...
ResNet网络构建过程详细分析
Joker的博客
08-06 2156
ResNet网络的构建过程   构建ResNet网络是通过ResNet类进行的，ResNet类继承了Pytorch网络的基类：torch.nn.Module，然后重写了 _init_ 方法和 forward 方法，__init__方法用来定义一些参数，forward方法用来定义数据在层之间的流动顺序。   构建ResNet网络时，在函数中一般是调用torchvision.model中的resnet50()/resnet18()/resnet101()等函数完成的，调用resnet50()/resnet1.
利用pytorch训练网络---垃圾分类，（resnet18）
YANGJINCHAHAHA的博客
07-09 1万+
数据集包含6种垃圾，分别为cardboard(纸箱)，glass(玻璃)、metal(金属）、paper(纸）、plastic(塑料）、其他废品(trash),数据数量较小，仅供学习。 数据集标准备工作，包括将数据集分为训练集和测试集，制作标签文件。代码utils.py import os import shutil import json path="e://dataset//Garb...
搭建ResNet18神经网络对cifar10数据集进行训练
weixin_44753371的博客
12-27 2240
搭建ResNet18神经网络对cifar10数据集进行训练 本博客以pytorch1.3框架搭建ResNet18层网络结构进行cifar10数据集训练。 1、ResNet18网络结构的说明 如图1所示：蓝色方框表示18层ResNet网络结构 用流程图来看更加直观，如图二所示： 由图2可知：每两层卷积层有一个shotrcut层，相当于一个短路链接，当下面的卷积层达不到更好的效果时，可以保证目前已...
使用PyTorch搭建ResNet18网络并使用CIFAR10数据集训练测试
TTTSEP9TH2244的博客
02-25 8588
ResNet18网络结构 具体ResNet原理细节这里不多做描述，直接上代码 这里并未采用BasicBlock和BottleNeck复现ResNet18 model.py网络模型部分： import torch import torch.nn as nn from torch.nn import functional as F """ 把ResNet18的残差卷积单元作为一个Block，这里分为两种：一种是CommonBlock，另一种是SpecialBlock，最后由ResNet18统筹调度 其中S
ResNet18的基本原理及TensorFlow 2.0实现
Peaceful Tree 的博客
02-17 4811
注：阅读本博客之前，你需要先掌握：全连接神经网络，卷积神经网络的基本原理。 背景介绍 随着LeNet-5，AlexNet，VGG等神经网络结构的出现，卷积神经网络逐渐从单纯的只拥有卷积操作和下采样的神经网络发展为具有max pooling、dropout以及非线性函数的神经网络。在网络结构变得不断复杂的同时，人们发现，神经网络的效率并没有预期得到提升，反而容易出现梯度消失等情况，因而导致loss难...
经典网络结构：resnet18结构
BigCowPeking
10-14 2万+
Resnet 网络结构： layer { name: "res2c" type: "Eltwise" bottom: "res2b" bottom: "res2c_branch2c" top: "res2c" } layer { name: "res2c_relu" type: "ReLU" bottom: "res2c&q
写一个resnet18网络
02-11
super(ResNet18, self).__init__() self.in_channels = 64 self.conv = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1) self.bn = nn.BatchNorm2d(64) self.relu = nn.ReLU(inplace=True) self.layer1...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值