探究图像输入的大小与模型测试时的关系

最新推荐文章于 2024-04-24 11:45:53 发布
最新推荐文章于 2024-04-24 11:45:53 发布
阅读量1k 收藏 1
点赞数 3
分类专栏： 计算机视觉 文章标签： 卷积神经网络 计算机视觉 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flyawayl/article/details/113998692
版权

问题

当我们使用pytorch中torchvision中的resnet50作为分类模型进行测试时，为什么不同的图像大小都可以输入到网络中进行测试呢？

关键

首先列出resnet50的模型结构：

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): Bottleneck(
      (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=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)
      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (downsample): Sequential(
        (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): Bottleneck(
      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=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)
      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (2): Bottleneck(
      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=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)
      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
  )
  (layer2): Sequential(
    (0): Bottleneck(
      (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=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): Bottleneck(
      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=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)
      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (2): Bottleneck(
      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=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)
      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (3): Bottleneck(
      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=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)
      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
  )
  (layer3): Sequential(
    (0): Bottleneck(
      (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (downsample): Sequential(
        (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): Bottleneck(
      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=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)
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (2): Bottleneck(
      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=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)
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (3): Bottleneck(
      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=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)
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (4): Bottleneck(
      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=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)
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (5): Bottleneck(
      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=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)
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
  )
  (layer4): Sequential(
    (0): Bottleneck(
      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (downsample): Sequential(
        (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): Bottleneck(
      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=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)
      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (2): Bottleneck(
      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=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)
      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
  (fc): Linear(in_features=2048, out_features=1000, bias=True)
)

大概看一下，发现除了最后有一个全连接层，其他都是卷积层和池化层。而卷积层是有参数的，但是与图像的输入无关，池化层没参数。

 (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
 (fc): Linear(in_features=2048, out_features=1000, bias=True)

只有全连接层的参数和输入图像的大小有关，因此要使得图像的输入具有任意性，resnet50中在fc层之前加入了一个AdaptiveAvgPool2d层，使得fc层的输入大小变得固定下来。AdaptiveAvgPool2d层的作用如下：
在这里插入图片描述

优点

这样设计网络结构，有3个优点：

  1. 输入图像的大小并不固定
  2. fc层的第一个参数不需要特意去计算
  3. 池化层没有参数，不会让网络结构变大
flyawayl
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
探究电流与电压电阻的关系+flashppt课件.ppt
11-11
探究电流与电压电阻的关系+flashppt课件.ppt
谈谈探究实验中的数据作图与图像分析.doc
11-29
谈谈探究实验中的数据作图与图像分析.doc
【深度学习】图像输入大小固定与不固定的一些想法
q742971636的博客
07-07 2378
图像任务中，传入到模型的图像尺寸往往是固定的，十万个为什么由此发问：1 那为什么是固定的？ 模型网络中含有全连接层的时候，输入尺寸只能固定大小，因为全连接网络的输入feature尺寸是固定的。一些模型网络就不一定需要尺寸固定，比如FCN网络中全是卷积网络而没有连接网络。（yolov5比较特殊，输入图像宽高得是采样值32的倍数，这种特例就特别看待）2 实际大小图像为了能输入到模型运行要做什么改变？ （1）选择resize到固定尺寸： a 原始图的宽高比太大，resize之后图像就变形得非常严重。如果你训练数据
pytorch模型输入自动调整大小-pad
蜕变之路的博客
01-10 1748
在网络中经常使用编译码与UNet网络，需要图像是符合2的倍数。 由于真实图像中存在不符合输入的情况，因此在网络中使用torch自带的pad函数，在模型输入前补充大小为0的元素填充形状，输出前用索引得到原始输入一样的大小。 pad(input, pad, mode=‘constant’, value=0) from torch import nn import torch.nn.functional as f class pretransition(nn.Module): def __init__
输入图片的大小对卷积神经网络结构的影响
qq_43232545的博客
05-19 8109
直接影响最终的全连接层中的输入参数的大小。 1.当输入图片的大小与预训练模型中的不同时： 需经过卷积、池化及全连接层的计算公式得出最终全连接层输入层数的大小。 2.当输入图片的大小与预训练模型中的相同时： （1）若分类数与预训练模型相同则无需做任何更改。 （2）若分类数与预训练模型中的不同，则更改全连接层中的输出值。 ...
为什么深度学习图像分类里的图片的输入大小都是224*224呢？
Mr_zhuo_的博客
10-22 1万+
在论文中进行各类方法的比较时，要求使用同样的数据集。而为了公平的比较，网络的输入大小通常都是224*224的大小，那为什么呢？ 我们都知道，一个图像分类模型，在图像中经历了下面的流程。 从输入image->卷积和池化->最后一层的feature map->全连接层->损失函数层softmax loss 从输入到最后一个卷积特征feature map，就是进行信息抽象的过程，然后就经过全连接层/全局池化层的变换进行分类了，这个feature map的大小，可以是3*3，5*5
图片尺寸对分类迭代次数和准确率的影响
staple
03-10 1822
(0, 2)---(n*n)*30*2---(1,0)(0,1) 做一个网络来分类mnist的0和2,用间隔取点的办法把图片边长n化成n=5，7，9，…，27。共12个不同的值，让网络的收敛误差δ=1e-4，每个收敛误差收敛199次，统计平均值。 得到表格 0*2 f2[0] f2[1] 迭代次数n ..
模型大小 与参数量计算
热门推荐
Leo_whj的博客
11-12 2万+
1.model size 就是模型的大小，我们一般使用参数量parameter来衡量，注意，它的单位是个。但是由于很多模型参数量太大，所以一般取一个更方便的单位：兆(M)来衡量。比如ResNet-152的参数量可以达到60 million = 0.0006M。有些时候，model size在实际计算时除了包含参数量以外，还包括网络架构信息和优化器信息等。比如存储一个一般的CNN模型(ImageNet训练)需要大于300MB。 M和MB的换算关系： 比如说我有一个模型参数量是1M，在一般的深度学习框架.
探究计算机模拟与数学建模之间的关系.doc
11-29
探究计算机模拟与数学建模之间的关系.doc
基于黑盒测试与白盒测试的比较探究.pdf
10-20
白盒测试实验报告
深度学习——卷积神经网络CNN
qq_46132949的博客
08-17 216
这两天看了不少讲卷积神经网络的文章和视频，由于我本人才疏学浅，在学习过程中基本上是一头雾水，导致的结果就是不过幸好，在快要绝望的时候，我在知乎上发现了一篇宝藏文章卷积神经网络CNN完全指南终极版这篇文章非常通俗易懂，用“说人话”的方法讲解了卷积神经网络，虽然有一些小错误，但是整体上非常适合新手小白， 我的这篇博客只是进行了一些补充，理解以下内容的前提是已经读懂了以上推荐的文章。 卷积层 首先，大多数输入图像都有3个RGB通道，我们可以把不同通道看成观察图片的不同视角，不同的视角或许会忽略某些特征，但也一定
神经网络训练数据集大小,神经网络输入图片大小
Supermen333的博客
09-16 2887
卷积神经网络有以下几种应用可供研究：1、基于卷积网络的形状识别物体的形状是人的视觉系统分析和识别物体的基础，几何形状是物体的本质特征的表现，并具有平移、缩放和旋转不变等特点，所以在模式识别领域，对于形状的分析和识别具有十分重要的意义，而二维图像作为三维图像的特例以及组成部分，因此二维图像的识别是三维图像识别的基础。另外是输入的问题，图象一般会先提取特征，再将特征作为输入。然而，这些特征的提取太过依赖人的经验和主观意识，提取到的特征的不同对分类性能影响很大，甚至提取的特征的顺序也会影响最后的分类性能。
一个小问题：深度学习模型如何处理大小可变的输入
zenRRan的博客
06-08 2144
点击下面卡片，关注我呀，每天给你送来AI技术干货！来自：SimpleAI对于大小可变的输入，深度学习模型如何处理？前几天在学习花书的时候，和小伙伴们讨论了“CNN如何处理可变大小的输入”这...
openvino系列 2. 修改模型的输入尺寸
破浪会有时的博客
04-27 773
除了修改图像大小以适应模型，openvino还支持修改模型输入尺寸以适应图像。
【CV】当输入图像尺寸变为 2 倍，CNN 的参数数量变为几倍？为什么？
学无止境、积少成多、厚积薄发
12-17 928
对于面试者来说，这是一个非常误导人的问题，因为大多数人会把注意力放在 CNN 参数的数量会增加多少倍的问题上。然而，让我们来看看 CNN 的架构： 我们可以看到，CNN 模型的参数数量取决于滤波器的数量和大小，而不是输入图像。因此，将图像的大小加倍并不会改变模型的参数数量。 参考 https://mp.weixin.qq.com/s/L-hF2OIcV9kbzOavjBhMqw[12 个不容错过的深度学习面试题] ...
深度学习中为什么模型输入大多是正方形图像？
dlhlSC的博客
06-16 6532
导语 大多数深度学习模型（例如VGG，ResNet等）都需要正方形图像作为输入，通常像素大小为224x224。 输入的长宽必须相等是有原因的吗？还是可以建立一个100x200输入的卷积神经网络模型？更大的像素尺寸（例如512x512）会带来更多好处吗？ 01 出于实用性的折衷 卷积神经网络不需要特定的像素尺寸即可正常运行。选择这些值是出于实用的原因：例如图像分辨率与参数数量和所需的训练集大小之间的折衷。毕竟，输入图像尺寸越大，模型的参数或者计算量也会随之上升。 02 方便获取ROI（感兴趣目标）
图形预处理工具_CogAffineTransformTool
最新发布
weixin_45788237的博客
04-24 382
CogAffineTransformTool工具能够对图像中仿射矩形内的区域进行变换，产生一个矩形的输出图像。这个工具能够消除仿射矩形的旋转和倾斜的影响，并且能够设置一个比例参数，以使能够放大或缩小矩形区域内的特征。并则可以指定其他缩放系数。当感兴趣的对象可以从一个图像旋转到下一个图像时，可以使用仿射变换工具来调整输入图像的区域，使用不能容忍太多旋转的视觉工具来分析图像。例如，下图显示了受检查对象周围的仿射矩形以及仿射变换工具生成的输出图像。
多元线性回归探究电动车数量与充电桩数量类型位置的关系
06-02
多元线性回归是一种统计分析方法，用于探究多个自变量与一个因变量之间的关系。在这个问题中，我们想要探究电动车数量与充电桩数量、类型、位置等自变量之间的关系，因此可以使用多元线性回归来进行分析。 以下是一...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值