小土堆pytorch教程学习笔记P25

已于 2022-04-18 09:17:18 修改
阅读量153 收藏
点赞数
分类专栏： 小土堆pytorch教程学习笔记 文章标签： pytorch
于 2022-04-03 17:44:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kchenlyee/article/details/123939993
版权
该段代码展示了如何在PyTorch中使用torchvision库加载预训练的VGG16模型。当设置pretrained为True时，模型将加载ImageNet上的预训练权重。同时，通过classifier模块的修改，将最后一层线性层的输出节点数改为10，以适应如CIFAR10等不同分类任务的需求。此外，还展示了如何下载和加载CIFAR10数据集。
摘要由CSDN通过智能技术生成

P25.现有网络模型的使用及修改（VGG16）

torchvision.models.vgg16(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.vgg.VGG

Parameters

  • pretrained (bool) – If True, returns a model pre-trained on ImageNet

  • progress (bool) – If True, displays a progress bar of the download to stderr显示下载进度条

class torchvision.datasets.ImageNet(root: str, split: str = 'train', **kwargs: Any)

Parameters

  • root (string) – Root directory of the ImageNet Dataset.

  • split (string, optional) – The dataset split, supports train, or val.

  • transform (callable, optional) – A function/transform that takes in an PIL image and returns a transformed version. E.g, transforms.RandomCrop

  • target_transform (callable, optional) – A function/transform that takes in the target and transforms it.

  • loader – A function to load an image given its path.

import torchvision

# train_data = torchvision.datasets.ImageNet("data_image_net", split='train', download=True,
#                                            transform=torchvision.transforms.ToTensor())
from torch import nn

vgg16_false = torchvision.models.vgg16(pretrained=False)
vgg16_true = torchvision.models.vgg16(pretrained=True)

print(vgg16_true)

train_data = torchvision.datasets.CIFAR10('dataset', train=True, transform=torchvision.transforms.ToTensor(),
                                          download=True)

vgg16_true.classifier.add_module('add_linear', nn.Linear(1000, 10))
print(vgg16_true)

print(vgg16_false)
vgg16_false.classifier[6] = nn.Linear(4096, 10)
print(vgg16_false)

VGG(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU(inplace=True)
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU(inplace=True)
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (6): ReLU(inplace=True)
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): ReLU(inplace=True)
    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (13): ReLU(inplace=True)
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): ReLU(inplace=True)
    (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (18): ReLU(inplace=True)
    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (20): ReLU(inplace=True)
    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (22): ReLU(inplace=True)
    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (25): ReLU(inplace=True)
    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (27): ReLU(inplace=True)
    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (29): ReLU(inplace=True)
    (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
  (classifier): Sequential(
    (0): Linear(in_features=25088, out_features=4096, bias=True)
    (1): ReLU(inplace=True)
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=4096, out_features=4096, bias=True)
    (4): ReLU(inplace=True)
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
  )
)
Files already downloaded and verified
VGG(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU(inplace=True)
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU(inplace=True)
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (6): ReLU(inplace=True)
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): ReLU(inplace=True)
    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (13): ReLU(inplace=True)
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): ReLU(inplace=True)
    (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (18): ReLU(inplace=True)
    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (20): ReLU(inplace=True)
    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (22): ReLU(inplace=True)
    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (25): ReLU(inplace=True)
    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (27): ReLU(inplace=True)
    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (29): ReLU(inplace=True)
    (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
  (classifier): Sequential(
    (0): Linear(in_features=25088, out_features=4096, bias=True)
    (1): ReLU(inplace=True)
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=4096, out_features=4096, bias=True)
    (4): ReLU(inplace=True)
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
    (add_linear): Linear(in_features=1000, out_features=10, bias=True)
  )
)
VGG(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU(inplace=True)
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU(inplace=True)
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (6): ReLU(inplace=True)
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): ReLU(inplace=True)
    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (13): ReLU(inplace=True)
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): ReLU(inplace=True)
    (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (18): ReLU(inplace=True)
    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (20): ReLU(inplace=True)
    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (22): ReLU(inplace=True)
    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (25): ReLU(inplace=True)
    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (27): ReLU(inplace=True)
    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (29): ReLU(inplace=True)
    (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
  (classifier): Sequential(
    (0): Linear(in_features=25088, out_features=4096, bias=True)
    (1): ReLU(inplace=True)
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=4096, out_features=4096, bias=True)
    (4): ReLU(inplace=True)
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
  )
)
VGG(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU(inplace=True)
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU(inplace=True)
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (6): ReLU(inplace=True)
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): ReLU(inplace=True)
    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (13): ReLU(inplace=True)
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): ReLU(inplace=True)
    (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (18): ReLU(inplace=True)
    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (20): ReLU(inplace=True)
    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (22): ReLU(inplace=True)
    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (25): ReLU(inplace=True)
    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (27): ReLU(inplace=True)
    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (29): ReLU(inplace=True)
    (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
  (classifier): Sequential(
    (0): Linear(in_features=25088, out_features=4096, bias=True)
    (1): ReLU(inplace=True)
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=4096, out_features=4096, bias=True)
    (4): ReLU(inplace=True)
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=4096, out_features=10, bias=True)
  )
)

Happy_Cabbage
关注
专栏目录
vgg网络结构
qq_40107571的博客
09-30 442
vgg网络结构
PyTorch深度学习快速入门教程【小土堆】 学习笔记
竦貊的博客
05-27 1万+
目录学习视频地址 —— B站1 pyTorch安装和配置已经测试，速度很慢，30kB/s已经测试，最有效的办法，速度最快,3MB/s2 python 编辑器的安装pyCharm 安装注意事项pyCharm 配置检测是否正常运行新环境中安装jupyterjupyter 使用指南3 为什么 返回 false4 pyhton 学习中的两个 法宝函数 学习视频地址 —— B站 PyTorch深度学习快速入门教程（绝对通俗易懂！）【小土堆】 1 pyTorch安装和配置 anaconda 安装路径：D:\anac
VGG网络架构
weixin_43732424的博客
12-17 3218
VGG 学习目标 知道VGG网络结构的特点 能够利用VGG完成图像分类 2014年，牛津大学计算机视觉组（Visual Geometry Group）和Google DeepMind公司的研究员一起研发出了新的深度卷积神经网络：VGGNet，并取得了ILSVRC2014比赛分类项目的第二名，主要贡献是使用很小的卷积核(3×3)构建卷积神经网络结构，能够取得较好的识别精度，常用来提取图像特征的VGG-16和VGG-19。 1.VGG的网络架构 VGG可以看成是加深版的AlexNet，整个网络由卷积层和全连
【深度学习经典网络架构—3】：VGG（附Keras实现）
王乐予的博客
12-16 4982
目录一、网络简介二、网络结构2.1 网络配置2.2 网络立体图结构2.3 网络平面图结构三、网络特点四、Keras实现4.1 程序编写4.2 打印模型信息五、总结 一、网络简介 VGG网络是由牛津大学计算机视觉组和谷歌DeepMind公司共同设计的。 VGG网络并且在2014年在ILSVRC大赛上获得了定位项目的第一名和分类项目的第二名。 作者通过VGG论证了一个非常重要的结论：CNN的深度与小卷积核的使用对图像识别与分类有很大影响！ 论文链接：Very Deep Convolutional Network
深度学习 Pytorch 小土堆笔记
02-02
小土堆Pytorch笔记
Python-Pytorch入门学习笔记（小土堆视频）
02-20
Python pytorch学习笔记 ***from的是一个个的包（package)*** ***import 的是一个个的py文件(file.py)*** ***所使用的一般是文件中的类(.class)*** ***第一步实例化所使用的类,然后调用类中的方法（def)*** 包含...
Pytorch入门实战学习笔记
04-24
### PyTorch 入门实战学习笔记 #### 一、PyTorch简介 PyTorch 是一个基于 Torch 的机器学习库，它支持动态计算图，主要用于应用程序中的深度神经网络研究。PyTorch 提供了丰富的功能，如自动梯度计算、GPU 加速...
最全面的 深度学习 笔记【土堆 Pytorch】【李沐 动手学深度学习】【吴恩达 深度学习】
最新发布
05-16
土堆是一个广受欢迎的深度学习资源提供者，其Pytorch教程以其深入浅出的讲解和丰富的实战案例受到学习者的喜爱。土堆的Pytorch教程主要包括以下内容： 1. **基础知识**：从最基础的张量操作开始，介绍Pytorch的核心...
【学习笔记】VGG 网络结构
Eniac0的博客
06-04 8840
跟着大佬学图像分类系列，→ 传送门 ← 前言 图像分类是学习目标检测的“量变”内容，那么，废话不多说，开搞！ 一、VGG 是什么？         VGG 网络是14年被牛津大学的著名研究组 VGG（Visual Geometry Group）提出，斩获该年 ImageNet 竞赛中 Localization Task（定位任务）第一名和 Classification Task（分类任务）第二名。 二、网络结构 （VG
VGG 网络结构
hankerbit的博客
04-13 9223
从图中可以看出VGG结构由5层卷积层、3层全连接层、softmax输出层构成，层与层之间使用max-pooling（最大池化）分开，所有隐层的激活单元都采用ReLU函数。VGG最大的贡献就是证明了卷积神经网络的深度增加和小卷积核的使用对网络的最终分类识别效果有很大的作用。 卷积层部分尺度没有变化（3*3的卷积核，stride为1，padding为1），只有通过max pooling层时尺度缩...
VGG网络结构
junjian Li
08-08 635
下面就VGG模型进行一下简要介绍。 VGG有多个版本，我这里使用的VGG16来介绍的。 下图是VGG16的网络模型，其中一共有13个卷积层，加上3个全连接层，卷积层用来提取特征，而全连接用来输出分类结结果。 使用torchvision来调用VGG16模型： import torchvision model = torchvision.models.vgg16(pretrained=False) ...
【网络结构】VGG
可乐大牛的博客
08-02 1094
VGG的一个核心思想就是使用多个较小的卷积代替较大的卷积并且保证感受野相同。这样的操作可以去的一个比较好结果的原因如下：1、相同感受野的情况下，多个小卷积的叠加，加深了网络，当然核心是引入了更多的非线性，模型的表征能力增强。2、参数更少。一个5x5的卷积的参数是5∗5∗C5*5*C5∗5∗C，而两个3x3卷积的参数是2∗3∗3∗C2*3*3*C2∗3∗3∗C。.........
VGG网络模型
qq_41286360的博客
04-04 1531
VGG是一个经典的深度卷积神经网络模型，它的简单统一的网络结构和深度的网络层次使得它在图像分类任务上取得了优秀的性能。虽然VGG模型的参数较多，计算量较大，但它为深度卷积神经网络的发展和应用奠定了坚实的基础。VGG和AlexNet都是在ImageNet大规模视觉识别挑战赛（ILSVRC）中取得突破性成果的深度卷积神经网络模型。VGG和AlexNet都是深度学习在计算机视觉领域的重要里程碑，它们共同推动了深度学习在图像分类、物体检测和物体定位等任务上的快速发展。
VGG网络结构详解
xiaofeixia002X的博客
12-08 1648
VGG网络结构详解
VGG网络结构分析
热门推荐
Double_V的博客
01-17 4万+
一：VGG详解 本节主要对VGG网络结构做一个详细的解读，并针对它所在Alexnet上做出的改动做详解的分析。 首先，附上一张VGG的网络结构图： 由上图所知，VGG一共有五段卷积，每段卷积之后紧接着最大池化层，作者一共实验了6种网络结构。分别是VGG-11，VGG-13,VGG-16,VGG-19，网络的输入是224*224大小的图像，输出是图像分类结果（本文只针对网络在图像分类任务上
【图像分类】经典网络架构 VGG
曦瓜
10-13 758
因本人刚开始写博客，学识经验有限，如有不正之处望读者指正，不胜感激；也望借此平台留下学习笔记以温故而知新。这一篇文章介绍的是图像分类中的经典的卷积神经网络架构—VGG的学习笔记。 1 VGG 网络架构 2 VGG16 网络架构 最大的特点 ：VGG 网络的结构非常一致，从头到尾全部使用的是 3x3 的卷积和2x2 的 的 max pooling 。 与 Alex...
小土堆pytorch学习笔记
09-27
根据提供的引用内容，小土堆是一位在B站上分享关于PyTorch深度学习的快速入门教程的博主。他的学习笔记和代码整合可以在视频链接...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值