pytorch 实现冻结部分参数训练另一部分

1)添加下面一句话到模型中

for p in self.parameters():
 p.requires_grad = False

比如加载了resnet预训练模型之后,在resenet的基础上连接了新的模快,resenet模块那部分可以先暂时冻结不更新,只更新其他部分的参数,那么可以在下面加入上面那句话

class RESNET_MF(nn.Module):
 def __init__(self, model, pretrained):
  super(RESNET_MF, self).__init__()
  self.resnet = model(pretrained)
  for p in self.parameters():
   p.requires_grad = False #预训练模型加载进来后全部设置为不更新参数,然后再后面加层
  self.f = SpectralNorm(nn.Conv2d(2048, 512, 1))
  self.g = SpectralNorm(nn.Conv2d(2048, 512, 1))
  self.h = SpectralNorm(nn.Conv2d(2048, 2048, 1))
  ...

同时在优化器中添加:

filter(lambda p: p.requires_grad, model.parameters())
optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=0.001, \
 betas=(0.9, 0.999), eps=1e-08, weight_decay=1e-5)

2) 参数保存在有序的字典中,那么可以通过查找参数的名字对应的id值,进行冻结

查看每一层的代码:

model_dict = torch.load('net.pth.tar').state_dict()
dict_name = list(model_dict)
for i, p in enumerate(dict_name):
 print(i, p)

打印一下这个文件,可以看到大致是这个样子的:

0 gamma
1 resnet.conv1.weight
2 resnet.bn1.weight
3 resnet.bn1.bias
4 resnet.bn1.running_mean
5 resnet.bn1.running_var
6 resnet.layer1.0.conv1.weight
7 resnet.layer1.0.bn1.weight
8 resnet.layer1.0.bn1.bias
9 resnet.layer1.0.bn1.running_mean
....

同样在模型中添加这样的代码:

for i,p in enumerate(net.parameters()):
 if i < 165:
  p.requires_grad = False

在优化器中添加上面的那句话可以实现参数的屏蔽

补充:pytorch 加载预训练模型 + 断点恢复 + 冻结训练(避坑版本)

1、 预训练模型网络结构 = 你要加载模型的网络结构

那么直接 套用

path="你的 .pt文件路径"
model = "你的网络"
checkpoint = torch.load(path, map_location=device)
model.load_state_dict(checkpoint)

2、 预训练模型网络结构 与你的网络结构不一致

当你直接套用上面公式,会出现类似unexpected key module.xxx.weight问题

这种情况下,需要具体分析一下网络信息,再决定如何加载。

# model_dict 是一个字典,保存网络 各层名称和参数,
model_dict = model.state_dict()
print(model_dict.keys()
# 这里打印出 网络 各层名称
checkpoint = torch.load(path,map_location=device)
for k, v in checkpoint.items():
 print("keys:".k)
# 这里打印出 预训练模型网络 各层名称, 是字典 【键】显示的另一种方式。

然后,对比两者网络结构参数 的异同,

若各层网络名称 基本不一致,那这个预训练模型基本就没法用了,直接换模型吧

若两者网络参数有很多 类似的地方,但又不完全一致,那可以采取如下方式。

(1) 部分网络关键字 ---- 完全匹配的情况

model.load_state_dict(checkpoint, strict=True)

load_state_dict 函数添加 参数 strict=True, 它直接忽略那些没有的dict,有相同的就复制,没有就直接放弃赋值!他要求预训练模型的关键字必须确切地严格地和 网络的 state_dict() 函数返回的关键字相匹配才能赋值。

strict 也不是很智能,适用于那些 网络关键字 基本能够匹配的情况。否则即使加载成功,网络参数也是空的。

(2)大部分网络关键字 ---- 部分匹配 (不完全相同,但类似),例如

网络关键字: backbone.stage0.rbr_dense.conv.weight

预训练模型 关键字:stage0.rbr_dense.conv.weight

可以看到,网络关键字 比预训练模型 多了一个前缀,其它完全一致,这种情况下,可以把 预训练模型的 stage0.rbr_dense.conv.weight 读入 网络的 backbone.stage0.rbr_dense.conv.weight 中。

# 对于 字典而言,in 或 not in 运算符都是基于 key 来判断的
model_dict = model.state_dict()
checkpoint = torch.load(path,map_location=device)
# k 是预训练模型的一个关键字, ss是 网络的有一个关键字
for k, v in checkpoint.items():
 flag = False
 for ss in model_dict.keys():
 if k in ss: # 在每一个元素内部匹配
 s = ss; flag = True; break
 else:
 continue
 if flag:
 checkpoint[k] = model_dict[s]

3、断点恢复

我感觉这个和常规【模型保存加载】方法的区别主要是 epoch的恢复

# 模型保存
state = {
 'epoch': epoch,
 'state_dict': model.state_dict(),
 'optimizer': optimizer.state_dict(),
  ... # 有其他希望保存的内容,也可自定义
 }
 torch.save(state, filepath)
# 加载模型,恢复训练
 model.load_state_dict(state['state_dict'])
 optimizer.load_state_dict(state['optimizer'])
 start_epoch = checkpoint['epoch'] + 1

4、冻结训练

一般冻结训练都是针对【backbone】来说的,较多应用于【迁移学习】

例如,0-49 Epoch:冻结 backbone进行训练;50-99:不冻结训练。

Init_Epoch = 0
Freeze_Epoch = 50
Unfreeze_Epoch =100
#------------------------------------#
# 冻结一定部分训练
#------------------------------------#
for param in model.backbone.parameters():
 param.requires_grad = False
for epoch in range(Init_Epoch,Freeze_Epoch):
 # I`m Freeze-training !!
 pass
#------------------------------------#
# 解冻后训练
#------------------------------------#
for param in model.backbone.parameters():
 param.requires_grad = True
for epoch in range(Freeze_Epoch,Unfreeze_Epoch):
 # I`m unfreeze-training !!
 pass

以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。如有错误或未考虑完全的地方,望不吝赐教。

(0)

相关推荐

  • 在pytorch中查看可训练参数的例子

    pytorch中我们有时候可能需要设定某些变量是参与训练的,这时候就需要查看哪些是可训练参数,以确定这些设置是成功的. pytorch中model.parameters()函数定义如下: def parameters(self): r"""Returns an iterator over module parameters. This is typically passed to an optimizer. Yields: Parameter: module paramete

  • pytorch 固定部分参数训练的方法

    需要自己过滤 optimizer.SGD(filter(lambda p: p.requires_grad, model.parameters()), lr=1e-3) 另外,如果是Variable,则可以初始化时指定 j = Variable(torch.randn(5,5), requires_grad=True) 但是如果是 m = nn.Linear(10,10) 是没有requires_grad传入的 m.requires_grad也没有 需要 for i in m.parameter

  • Pytorch加载部分预训练模型的参数实例

    前言 自从从深度学习框架caffe转到Pytorch之后,感觉Pytorch的优点妙不可言,各种设计简洁,方便研究网络结构修改,容易上手,比TensorFlow的臃肿好多了.对于深度学习的初学者,Pytorch值得推荐.今天主要主要谈谈Pytorch是如何加载预训练模型的参数以及代码的实现过程. 直接加载预选脸模型 如果我们使用的模型和预训练模型完全一样,那么我们就可以直接加载别人的模型,还有一种情况,我们在训练自己模型的过程中,突然中断了,但只要我们保存了之前的模型的参数也可以使用下面的代码直

  • pytorch 在网络中添加可训练参数,修改预训练权重文件的方法

    实践中,针对不同的任务需求,我们经常会在现成的网络结构上做一定的修改来实现特定的目的. 假如我们现在有一个简单的两层感知机网络: # -*- coding: utf-8 -*- import torch from torch.autograd import Variable import torch.optim as optim x = Variable(torch.FloatTensor([1, 2, 3])).cuda() y = Variable(torch.FloatTensor([4,

  • pytorch 实现冻结部分参数训练另一部分

    1)添加下面一句话到模型中 for p in self.parameters(): p.requires_grad = False 比如加载了resnet预训练模型之后,在resenet的基础上连接了新的模快,resenet模块那部分可以先暂时冻结不更新,只更新其他部分的参数,那么可以在下面加入上面那句话 class RESNET_MF(nn.Module): def __init__(self, model, pretrained): super(RESNET_MF, self).__init

  • Pytorch 实现冻结指定卷积层的参数

    python代码 for i, para in enumerate(self._net.module.features.parameters()): if i < 16: para.requires_grad = False else: para.requires_grad = True # Solver. # self._solver = torch.optim.SGD( # self._net.parameters(), lr=self._options['base_lr'], # mome

  • pytorch VGG11识别cifar10数据集(训练+预测单张输入图片操作)

    首先这是VGG的结构图,VGG11则是红色框里的结构,共分五个block,如红框中的VGG11第一个block就是一个conv3-64卷积层: 一,写VGG代码时,首先定义一个 vgg_block(n,in,out)方法,用来构建VGG中每个block中的卷积核和池化层: n是这个block中卷积层的数目,in是输入的通道数,out是输出的通道数 有了block以后,我们还需要一个方法把形成的block叠在一起,我们定义这个方法叫vgg_stack: def vgg_stack(num_conv

  • pytorch使用horovod多gpu训练的实现

    pytorch在Horovod上训练步骤分为以下几步: import torch import horovod.torch as hvd # Initialize Horovod 初始化horovod hvd.init() # Pin GPU to be used to process local rank (one GPU per process) 分配到每个gpu上 torch.cuda.set_device(hvd.local_rank()) # Define dataset... 定义d

  • 画pytorch模型图,以及参数计算的方法

    刚入pytorch的坑,代码还没看太懂.之前用keras用习惯了,第一次使用pytorch还有些不适应,希望广大老司机多多指教. 首先说说,我们如何可视化模型.在keras中就一句话,keras.summary(),或者plot_model(),就可以把模型展现的淋漓尽致. 但是pytorch中好像没有这样一个api让我们直观的看到模型的样子.但是有网友提供了一段代码,可以把模型画出来,对我来说简直就是如有神助啊. 话不多说,上代码吧. import torch from torch.autog

  • tensorflow 固定部分参数训练,只训练部分参数的实例

    在使用tensorflow来训练一个模型的时候,有时候需要依靠验证集来判断模型是否已经过拟合,是否需要停止训练. 1.首先想到的是用tf.placeholder()载入不同的数据来进行计算,比如 def inference(input_): """ this is where you put your graph. the following is just an example. """ conv1 = tf.layers.conv2d(inp

  • pytorch forward两个参数实例

    以channel Attention Block为例子 class CAB(nn.Module): def __init__(self, in_channels, out_channels): super(CAB, self).__init__() self.global_pooling = nn.AdaptiveAvgPool2d(output_size=1) self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=1, st

  • 基于python介绍pytorch保存和恢复参数

    目录 一.读写文件 1.加载和保存张量 2.加载和保存模型 一.读写文件 1.加载和保存张量 import torch from torch import nn from torch.nn import functional as F import os path = os.path.join(os.getcwd(), "") x = torch.arange(4) torch.save(x, path + "x-file") 现在我们可以将存储在文件中的数据读回内

  • pytorch如何冻结某层参数的实现

    在迁移学习finetune时我们通常需要冻结前几层的参数不参与训练,在Pytorch中的实现如下: class Model(nn.Module): def __init__(self): super(Transfer_model, self).__init__() self.linear1 = nn.Linear(20, 50) self.linear2 = nn.Linear(50, 20) self.linear3 = nn.Linear(20, 2) def forward(self, x

随机推荐