ResNet 18 网络结构

最新推荐文章于 2025-03-10 10:58:20 发布
最新推荐文章于 2025-03-10 10:58:20 发布
阅读量1.7w 收藏 23
点赞数 8
分类专栏： 神经网络 python Pytorch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/S20144144/article/details/101372879
版权 
import torch
from torchvision import models

resnet = models.resnet18(pretrained=True)
print(resnet)

"""
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)
  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
  (layer1): Sequential(
    (0): BasicBlock(
      (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)
      (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)
    )
    (1): BasicBlock(
      (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)
      (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)
    )
  )
  (layer2): Sequential(
    (0): BasicBlock(
      (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)
      (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): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (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)
      (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)
    )
  )
  (layer3): Sequential(
    (0): BasicBlock(
      (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)
      (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): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (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)
      (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)
    )
  )
  (layer4): Sequential(
    (0): BasicBlock(
      (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)
      (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): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (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)
      (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)
    )
  )
  (avgpool): AvgPool2d(kernel_size=7, stride=1, padding=0)
  (fc): Linear(in_features=512, out_features=1000, bias=True)
)
"""

# 修改前resnet18最后一层名字叫fc,是1000个输出（1000类），下面修改为100类

resnet.fc = torch.nn.Linear(resnet.fc.in_features, 100)
print(resnet)

"""
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)
  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
  (layer1): Sequential(
    (0): BasicBlock(
      (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)
      (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)
    )
    (1): BasicBlock(
      (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)
      (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)
    )
  )
  (layer2): Sequential(
    (0): BasicBlock(
      (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)
      (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): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (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)
      (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)
    )
  )
  (layer3): Sequential(
    (0): BasicBlock(
      (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)
      (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): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (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)
      (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)
    )
  )
  (layer4): Sequential(
    (0): BasicBlock(
      (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)
      (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): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (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)
      (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)
    )
  )
  (avgpool): AvgPool2d(kernel_size=7, stride=1, padding=0)
  (fc): Linear(in_features=512, out_features=100, bias=True)
)
"""

# 之后采用torchviz模块，对网络结构进行可视化
from torchviz import make_dot
x = torch.randn(10, 3, 224, 224).requires_grad_(True)
y = resnet(x)
vis_graph = make_dot(y, params=dict(list(resnet.named_parameters()) + [('x', x)]))
vise_graph.view()

之后会生成一个pdf，内容如下所示：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
～’’(- _ -)’'～pdf导入到markdown实在是太麻烦了，就放几个截图意思意思啦。resnet_18_structure.pdf文件已经传到资源上啦，但是竟然需要5积分/C币!!!小白还不知道怎么修改成免费的，所以也就凑合着看看吧^ _ ^

经典网络结构：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网络结构
qq_43620727的博客
01-24 889
import torch import torch.nn as nn # 定义一个Residual模块 class Residual(nn.Module): def __init__(self,in_channels,out_channels,stride=1): super(Residual, self).__init__() self.stride = stride self.conv1 = nn.Conv2d(in_channels,out..
resnet_18_structure.pdf
09-25
resnet 18 网络结构（摘要需要大于50个字节，所以请自动忽略这个括号。。。）
ResNet 经典网络详解：深度学习中的革命性突破（含代码）
murphymeng2001的博客
03-10 3759
如果你对 ResNet 还有更深入的兴趣，可以尝试 ResNet-50、ResNet-101 这些更深层次的变体，或者结合 Transformer、注意力机制等技术进行优化！在深度学习的发展历程中，ResNet（残差网络）是一个重要的突破。它成功解决了深层神经网络训练中的梯度消失问题，使得深度模型能够达到更好的性能。ResNet-18 是深度学习领域中最经典的网络之一，尤其在图像分类任务上表现优异。为例，详细解析其网络结构、关键技术，并探讨其实际应用。，避免梯度消失，并帮助网络学习更深层次的特征。
图像识别-ResNet-18网络结构图示及解读
算法之美
05-22 4万+
图像识别-ResNet-18网络结构图示及解读
Resnet 18网络模型
Chenzhinan1219的博客
12-20 6万+
1. 残差网络：（Resnet） 残差块： 让我们聚焦于神经网络局部：如图左侧所示，假设我们的原始输入为x，而希望学出的理想映射为f(x)（作为上方激活函数的输入）。左图虚线框中的部分需要直接拟合出该映射f(x)，而右图虚线框中的部分则需要拟合出残差映射f(x)−x。 残差映射在现实中往往更容易优化。 以本节开头提到的恒等映射作为我们希望学出的理想映射f(x)，我们只需将右图虚线框内上方的加权运算（如仿射）的权重和偏置参数设成0，那么f(x)即为恒等映射。 实际中，当理想映射f(x)极接近于恒等映..
ResNet-18結構
gesshoo的博客
02-27 6024
残差块⾥⾸先有 2 个有相同输出通道数的 3 × 3 卷积层。每 个卷积层后接⼀个批量归⼀化层和 ReLU 激活函数。然后我们通过跨层数据通路，跳过这 2 个卷积运算，将输⼊直接加在最后的 ReLU 激活函数前。这样的设计要求 2 个卷积层的输出与输⼊形状⼀样，从而可以相加。 如 果想改变通道数，就需要引⼊⼀个额外的 1 × 1 卷积层来将输⼊变换成需要的形状后再做相加运算。 import torch from torch import nn from torch....
初始PyTorch（六+）：ResNet18的网络结构
sleepinghm的博客
03-27 5377
使用ResNet18网络结构，为了更好适配Cifar-10数据集【h*w=32*32】，所以不是完全按照renset18的参数写的。 下图是ResNet18的内部结构图。 先写内部结构：有两层的weight layer。 class ResBlk(nn.Module): def __init__(self, ch_in, ch_out, stride=1): s...
深度学习带有ECA模块的ResNet18网络结构实现：卷积神经网络中的注意力机制应用与图像分类任务优化
最新发布
04-07
最后定义了ResNet类，通过堆叠多个BasicBlock构建不同深度的残差网络，并实现了ResNet18的具体实例。此外还展示了如何测试网络的连通性。 适合人群：有一定深度学习基础，特别是熟悉PyTorch框架的开发者或研究人员。...
ResNet18_resnet18_resnet18网络_
10-02
`ResNet18结构1.png`和`ResNet结构2.png`文件可能是ResNet18网络结构的可视化图，帮助理解模型的布局。通常，这些图会展示每个残差块的连接方式，以及全局的网络架构，包括输入层、卷积层、池化层和全连接层的位置。...
ResNet18网络的具体构成
daweq的博客
10-26 5万+
ResNet18的基本含义是，网络的基本架构是ResNet，网络的深度是18层。但是这里的网络深度指的是网络的权重层，也就是包括池化，激活，线性层。3，步长为1，padding为1。这个卷积层的卷积核的大小为7。7，步长为2，padding为3，输出通道为64。也就是说这个池化不改变数据的通道数量，而会减半数据的大小。224，也就是3个通道，每个通道的大小为224*224。也就是将输出通道翻倍，输出数据大小全部减半。也就是将输出通道翻倍，输出数据大小全部减半。54，也就是这一层不改变数据的大小和通道数。
ResNet结构图（ResNet18、ResNet50）
Drug discovery
09-09 7354
ResNet18中的"18"指的是网络中的加权层数量。具体来说，它包含了18个卷积层和全连接层。
ResNet网络结构分析
开飞机的小毛驴儿
10-25 5787
转载自：https://zhuanlan.zhihu.com/p/79378841，本文只做个人记录学习使用，版权归原作者所有。 今天回顾了ResNet的论文Deep Residual Learning for Image Recognition，又结合PyTorch官方代码，整理一遍ResNet的结构，在这里写个总结。 首先，ResNet在PyTorch的官方代码中共有5种不同深度的结构，深度分别为18、34、50、101、152（各种网络的深度指的是“需要通过训练更新参数”的层数，如卷积层，全.
经典CNN网络：Resnet18网络结构输入和输出
weixin_43999691的博客
06-15 9万+
前言 每当看到一个新的网络，总会思考，这个网络提出来有什么意义，解决了什么问题？Resnet18的提出，解决
ResNet网络结构
WitsMakeMen的专栏
04-26 1159
转自：https://www.cnblogs.com/mtcnn/p/9411742.html MSRA（微软亚洲研究院）何凯明团队的深度残差网络（Deep Residual Network）在2015年的ImageNet上取得冠军，该网络简称为ResNet（由算法Residual命名），层数达到了152层，top-5错误率降到了3.57，而2014年冠军GoogLeNet的错误率是6.7。（何凯...
ResNet 18 的结构解读
热门推荐
wchzh2015的博客
06-27 14万+
现在很多网络结构都是一个命名+数字，比如（ResNet18），数字代表的是网络的深度，也就是说ResNet18 网络就是18层的吗？其实这里的18指定的是带有权重的 18层，包括卷积层和全连接层，不包括池化层和BN层。下面先贴出ResNet论文中给出的结构列表。 对 Pytorch 中ResNet18网络的源码分析（这里），我画出了大致的网络结构图。可以看出，数字 18 = 17 个...
NNDL 实验六 卷积神经网络（4）ResNet18实现MNIST
zhenjiteng的博客
11-01 990
这我还是写的很细，并且感觉这次用到了好多上一个实验的东西，遇到了一个问题研究好长时间，感觉解决的不是很好，请个老师和各位大佬多教教我首先，我这次同样写的很细，但是，我那个解决问题的方法感觉并不是很好，所以希望，各老师和各位大佬多教教我。
ResNet-18超详细介绍！！！！
m0_64799972的博客
09-08 11万+
残差神经网络(ResNet)是由微软研究院的何恺明、张祥雨、任少卿、孙剑等人提出的。ResNet 在2015 年的ILSVRC（ImageNet Large Scale Visual Recognition Challenge）中取得了冠军。残差神经网络的主要贡献是发现了“退化现象（Degradation）”，并针对退化现象发明了 “快捷连接（Shortcut connection）”，极大的消除了深度过大的神经网络训练困难问题。下面我将一步步引出退化现象和快捷连接。
ResNet18
03-08
### ResNet18 深度学习模型架构与实现 #### 架构概述 ResNet18 是一种基于残差网络 (Residual Network) 的卷积神经网络，具有18层深度。该模型通过引入跳跃连接解决了深层网络中的梯度消失问题，使得训练更加稳定有效[^2]。 #### 主要组件 - **输入层**: 接收图像数据作为输入。 - **卷积层**: 使用多个3×3的小型滤波器来提取特征图谱。 - **批标准化(Batch Normalization)**: 加速收敛并减少内部协变量偏移。 - **激活函数(ReLU)**: 增加非线性表达能力。 - **池化操作(Max Pooling & Average Pooling)**: 下采样以降低维度。 - **全连接层(Fully Connected Layer)**: 将最后一个卷积层输出映射到分类标签空间。 - **Softmax 层**: 输出概率分布用于多类别分类任务。 #### 特殊设计 - 跳跃连接(Skip Connection) ResNet的核心创新在于其独特的跳过链接机制，允许信息绕过多层传递而不必经过每一步计算。这种结构有助于缓解非常深的网络中存在的退化问题，并促进更深层次的学习效率提升。 #### PyTorch 实现示例 以下是使用PyTorch框架构建ResNet18的一个简单例子： ```python import torch.nn as nn import torchvision.models as models class ResNet18(nn.Module): def __init__(self, num_classes=1000): super().__init__() self.model = models.resnet18(pretrained=True) # 修改最后一层适应新的分类数量 self.model.fc = nn.Linear(self.model.fc.in_features, num_classes) def forward(self, x): return self.model(x) if __name__ == "__main__": net = ResNet18(num_classes=10).cuda() print(net) ``` 此代码片段展示了如何利用预训练权重初始化一个针对特定任务调整过的ResNet18实例。`num_classes` 参数指定了最终分类的数量；对于不同的应用场景可以相应修改这个值。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值