PyTorch(14)---使用现有的模型及其修改

已于 2022-10-01 21:41:54 修改
阅读量1.2k 收藏 3
点赞数
分类专栏： PyTorch_learn 文章标签： pytorch 深度学习 人工智能
于 2022-07-29 10:43:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45703331/article/details/126050185
版权
本文介绍了如何使用PyTorch调整VGG16模型，以解决从1000分类问题到10分类问题。首先，我们展示了如何在预训练模型基础上修改最后一层线性层，以及在未训练模型上新增线性层的方法。通过实例演示了CIFAR10数据集的应用，详细说明了两种不同的修改策略。
摘要由CSDN通过智能技术生成

PyTorch给我们提供的一些分类模型

在这里插入图片描述

修改VGG16

VGG16最后一层线性层：输入为4096，输出为1000(解决的是1000分类问题)，VGG16是在ImgNet进行训练的。
修改模型让VGG16解决10分类问题
print打印查看VGG16的模型是什么：

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)
  )
)

可以选择：
①训练好参数的模型

vgg16_t=torchvision.models.vgg16(pretrained=True,progress=True)

pretrained=True代表训练好参数的模型。
运行后开始下载模型，这时发现模型下载在C盘！！！！
修改模型下载的地址：
在环境变量里添加路径
在这里插入图片描述
运行后：下载至D盘。
在这里插入图片描述
复制下载链接在迅雷下载，下载完成后将模型复制到路径下。
②未经训练的模型
未经训练的模型不用下载。

vgg16_f=torchvision.models.vgg16(pretrained=False,progress=True)

修改模型将其变成10分类问题

第一种方式：在最后面再加一个线性层

输入为1000，输出为10

第二种方式：直接修改最后一个线性层

直接修改输出为10

import torchvision
from torch import nn

'''
pretrained=False:参数没有经过预训练
pretrained=True:参数经过预训练
progress=True:显示进度条
'''
vgg16_f=torchvision.models.vgg16(pretrained=False,progress=True)
vgg16_t=torchvision.models.vgg16(pretrained=True,progress=True)
print(vgg16_f)
print("----------------------------------------------------------")
print(vgg16_t)
print("----------------------------------------------------------")
'''
vgg16网络模型将图片分成1000类，CIFAR10分成10类
1、将线性层最后1000直接改成10
2、在最后一层再加一层线性层，输入是1000，输出是10
'''
train_data=torchvision.datasets.CIFAR10(root="dataset_CIFAR10",train=True,
                                        transform=torchvision.transforms.ToTensor(),
                                        download=True)

'''给vgg16_f后面classifier里再加一层线性层'''
vgg16_f.classifier.add_module("7",nn.Linear(1000,10))
print(vgg16_f) #不需要返回值，直接改好了
print("----------------------------------------------------------------")
'''直接改vgg16_t后面classifier里的线性层'''
vgg16_t.classifier[6]=nn.Linear(4096,10)
print(vgg16_t)


'''结果'''
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)
    (7): 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=10, bias=True)
  )
)

残差网络修改最后面的分类，只能在模块内部修改，最后的分类才会生效。
测试以下VGG将最后一层线性层，加模块外面是否生效。

'''加到网络的最外层'''
vgg16_t.add_module("add",nn.Linear(1000,10))
print('线性层加到网络的最外层:{}'.format(vgg16_t))
#测试
input=torch.randint(10,size=(1,3,200,200),dtype=torch.float32)
output=vgg16_t(input)
print('======================================')
print(input)
print(type(input))
print('=============================================')
print(output)
print(type(output))
print(output.shape)

在这里插入图片描述
生效！！

Pytorch深度学习-----现有网络模型的使用及修改（VGG16模型）
LGL
08-09 848
指定要加载的预训练权重。可以是None（默认值）表示不加载预训练权重，或是指定为预定义的某个预训练权重标识符。从上述运行结果可知：VGG16网络是由13层卷积层和3层全连接层组成，最后网络输出一共有1000个分类结果。由上述可以知道，add_linear是在classifier外面的，如果要在classifier里面，可以将。其它可选参数，传递给VGG-16模型的基类torchvision.models.VGG。指示下载进度条的显示设置，默认为True显示下载进度条。VGG-16是一种具有。
Pytorch深度学习-----完整神经网络模型训练套路
LGL
08-12 1242
定义适当的损失函数来计算模型预测结果于真实标签之间的差异。选择适当的优化器算法来更新模型参数，如随机梯度下降（SGD）、Adam等。使用torchvision库加载CIFAR10数据集。将训练集和测试集分别存放在train_data和test_data中。引用model.py文件，在其中创建名为"Lgl"的模型。定义损失函数为交叉熵损失（nn.CrossEntropyLoss）。定义优化器为随机梯度下降（SGD）优化器，并将模型参数传递给优化器。
保存和加载模型
吴建明wujianming_110117
02-07 746
保存和加载模型 当保存和加载模型时，需要熟悉三个核心功能： torch.save：将序列化对象保存到磁盘。此函数使用Python的pickle模块进行序列化。使用此函数可以保存如模型、tensor、字典等各种对象。 torch.load：使用pickle的unpickling功能，将pickle对象文件反序列化到内存。此功能还可以有助于设备加载数据。 torch.nn.Module.load_state_dict：使用反序列化函数 state_dict 来加载模型的参数字典。 什么是状态字典：state_
Pytorch修改模型参数的方法
mmmmmm儒丶的博客
10-08 1454
https://blog.csdn.net/lppfwl/article/details/120055302
Pytorch网络模型参数修改
u011231598的博客
04-06 3521
最近在研究HRank的论文和代码，发现里面的模型结构化剪枝后，模型大小没有变小，打印最终训练完后的网络模型中的参数，发现它只是把一些channel的参数全部稀疏化为0，并没有把channel的个数裁剪下来。 于是想自己写代码重新构建裁剪channel后的小网络，然后把通道稀疏化（也就是裁剪）后的网络参数直接给到小网络中，这样做就可以用小网络模型做一模一样的推理了。关于为什么可以直接用小网络获取大网络稀疏化通道裁剪后的网络参数作推理，其实原因很简单的，后续再写HRank论文的总结...
PyTorch如何修改模型（魔改）
自己在学习过程中的总结
04-29 2408
对模型缝缝补补、修修改改，是我们必须要掌握的技能，本文详细介绍了如何修改PyTorch模型？也就是我们经常说的如何魔改。PyTorch 的模型是一个 torch.nn.Module 的某个子类的对象，修改模型实际就等价于修改某个类，对面向对象熟悉的同学应该知道，对类做修改有两个经典的方法：组合和继承。1.修改模型层(模型框架⭐)1.1通过继承修改模型1.2通过组合修改模型(重点学👀)1.3通过猴子补丁修改模型2.添加外部输入3.添加额外输出。
Pytorch训练过程中改变模型参数 requires_grad 属性
01-20
如果模型只在一块GPU上跑，该过程非常简单，只需要训练中途迭代model的 parameters，然后改变各个param的requires_grad 属性即可： for name, param in model.named_parameters(): logger.info('parameter of %s'%name) logger.info('before requires_grad is : %s'%param.requires_grad) param.requires_grad = True logger.info('after requires_gr
pytorch入门17：现有模型的使用和修改
qq_42360017的博客
03-28 389
import ssl """ 这一节主要是学会怎么在现有模型上进行修改模型结构 """ import torchvision # ssl._create_default_https_context = ssl._create_unverified_context # 全局取消证书验证 # dataset = torchvision.datasets.ImageNet('../imagenet_data',split='train',download=True,transform=torchvision.
Pytorch深度学习-----神经网络模型的保存与加载(VGG16模型)
LGL
08-09 1179
torch.load()是PyTorch中用于加载保存的对象的函数，可以加载之前使用torch.save()保存的模型、张量、字典等。可以指定要加载的文件路径或文件对象，并可选地指定加载到的设备、反序列化模块等参数。
【PyTorch】微调修改预训练模型权重参数
weixin_43796433的博客
07-13 3237
pytorch模型结构获取以及修改
pytorch 基本CNN模型使用
singlesmile的博客
05-08 333
pytorch 基本CNN模型使用
PyTorch（六）优化模型参数
最新发布
qq_45031509的博客
07-02 580
c 目的 优化的目的已经拥有了一个「模型」和「数据」，是时候通过「优化模型参数」来训练、验证和测试模型。#d 迭代训练训练模型是一个迭代过程；在每次迭代中，模型对输出做出猜测，计算其猜测的误差（损失），收集误差相对于其参数的导数，并使用「梯度下降」来优化这些参数。
pytorch模型训练使用（以FashionMNIST为例）
sgfsfgs的博客
02-21 1011
本文采用fashion_mnist数据集进行训练，手写一个网络模型，在测试集上的准确率达到。本文实现了fashion_mnist的数据集模型搭建和测试，因为只是记录一下pytorch搭建网络的一个大体过程，所以很多地方没有进行解释和注释，有不懂的欢迎大家在评论区或私信对我提问。
动手学PyTorch | (46) PyTorch中模型的使用
sdu_hao的博客
11-27 470
神经网络训练后我们需要将模型进行保存，要用的时候将保存的模型进行加载，PyTorch 中保存和加载模型主要分为两类：保存加载整个模型和只保存加载模型参数。 目录 1. 保存加载模型基本用法 2. 保存加载自定义模型 3. 跨设备保存加载模型 4. CUDA的用法 1. 保存加载模型基本用法 保存加载整个模型 保存整个网络模型（网络结构+权重参数）。 torch.save(mode...
9-pytorch-现有模型使用及修改
weixin_45743760的博客
02-22 813
b站小土堆pytorch教程学习笔记。
Pytorch深度学习-----完整的模型验证套路
LGL
12-31 1188
return xLgl类定义了一个CNN，包含三个卷积层，接着是最大池化、展平操作以及两个线性层。该模型设计用于图像分类。
PyTorch模型定义和相关使用
1ncludeSteven
09-18 943
主要介绍PyTorch模型定义的方式（Sequential，ModuleList、ModuleDict）及它们的优缺点，然后介绍如何基于模块（模型块，通常是事先定义好的多个层组成的部分）快速搭建大型复杂网络，接着介绍如何修改已有的模型（修改模型输出，添加额外输入，添加额外输出），最后介绍模型的保存和读取（结合单卡和多卡介绍）
PyTorch现有网络模型的使用和修改
Victory_gx的博客
01-30 1790
PyTorch现有网络模型的使用和修改 import torchvision # train_data = torchvision.datasets.ImageNet("dataset", split = 'train', download = True, # transform = torchvision.transforms.ToTensor()) from torch import nn vgg16_false
pytorch现有模型的使用和修改
qq_42202395的博客
07-14 218
pytorch现有模型的使用和修改
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

莫听穿林打叶声@

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值