从pytorch神经网络入门到参数冻结与模型保存

最新推荐文章于 2024-02-24 21:33:11 发布

weixin_44933854

最新推荐文章于 2024-02-24 21:33:11 发布

阅读量2k

点赞数

文章标签： pytorch 神经网络深度学习

本文链接：https://blog.csdn.net/weixin_44933854/article/details/129590062

版权

1 从pytorch入门到参数冻结

1.1 python基础

1.1.1 super()用法

以下是 super() 方法的语法:
super(type[, object-or-type])
参数：

type – 类。
object-or-type – 类，一般是 self

Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx
注：这里的class是子类自己。

1.1.2 super().init()用法

何时要使用super.init():
当需要继承父类构造函数中的内容，且子类需要在父类的基础上补充时，使用super().init()方法。

1.2 pytorch深度学习基础

参考教程：PyTorch深度学习：60分钟入门(Translation)

1.2.1 训练过程

一个典型的神经网络的训练过程是这样的：

定义一个有着可学习的参数（或者权重）的神经网络
对着一个输入的数据集进行迭代:
用神经网络对输入进行处理
计算代价值 (对输出值的修正到底有多少)
将梯度传播回神经网络的参数中
更新网络中的权重
通常使用简单的更新规则: weight = weight + learning_rate * gradient

1.2.2 定义神经网络

import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 6, 5) # 1 input image channel, 6 output channels, 5x5 square convolution kernel
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1   = nn.Linear(16*5*5, 120) # an affine operation: y = Wx + b
        self.fc2   = nn.Linear(120, 84)
        self.fc3   = nn.Linear(84, 10)

    def forward(self, x):
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2)) # Max pooling over a (2, 2) window
        x = F.max_pool2d(F.relu(self.conv2(x)), 2) # If the size is a square you can only specify a single number
        x = x.view(-1, self.num_flat_features(x))
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x
    
    def num_flat_features(self, x):
        size = x.size()[1:] # all dimensions except the batch dimension
        num_features = 1
        for s in size:
            num_features *= s
        return num_features

net = Net()
net

'''神经网络的输出结果是这样的
Net (
  (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
  (fc1): Linear (400 -> 120)
  (fc2): Linear (120 -> 84)
  (fc3): Linear (84 -> 10)
)
'''

仅仅需要定义一个forward函数就可以了，backward会自动地生成。
你可以在forward函数中使用所有的Tensor中的操作。

模型中可学习的参数会由net.parameters()返回。

params = list(net.parameters())
print(len(params))
print(params[0].size()) # conv1's .weight

input = Variable(torch.randn(1, 1, 32, 32))
out = net(input)
'''out 的输出结果如下
Variable containing:
-0.0158 -0.0682 -0.1239 -0.0136 -0.0645  0.0107 -0.0230 -0.0085  0.1172 -0.0393
[torch.FloatTensor of size 1x10]
'''

net.zero_grad() # 对所有的参数的梯度缓冲区进行归零
out.backward(torch.randn(1, 10)) # 使用随机的梯度进行反向传播

1.2.3 代价函数计算

一个简单的代价函数：nn.MSELoss计算输入和目标之间的均方误差。
举个例子:

output = net(input)
target = Variable(torch.range(1, 10))  # a dummy target, for example
criterion = nn.MSELoss()
loss = criterion(output, target)
'''loss的值如下
Variable containing:
 38.5849
[torch.FloatTensor of size 1]
'''

现在，如果你跟随loss从后往前看，使用.creator属性你可以看到这样的一个计算流程图：

input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d  
      -> view -> linear -> relu -> linear -> relu -> linear 
      -> MSELoss
      -> loss

因此当我们调用loss.backward()时整个图通过代价来进行区分，图中所有的变量都会以.grad来累积梯度。

1.2.4 反向传播更新权重

最简单的更新的规则是随机梯度下降法(SGD):
weight = weight - learning_rate * gradient

我们可以用简单的python来表示:

learning_rate = 0.01
for f in net.parameters():
    f.data.sub_(f.grad.data * learning_rate)

然而在你使用神经网络的时候你想要使用不同种类的方法诸如：SGD, Nesterov-SGD, Adam, RMSProp, etc.

我们构建了一个小的包torch.optim来实现这个功能，其中包含着所有的这些方法。用起来也非常简单:

import torch.optim as optim
# create your optimizer
optimizer = optim.SGD(net.parameters(), lr = 0.01)

# in your training loop:
optimizer.zero_grad() # zero the gradient buffers
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step() # Does the update

1.2.5 loss.backward()和optimizer.step()

理解Pytorch的loss.backward()和optimizer.step()
loss.backward()将loss计算进行反向传播，计算出所有的梯度，然后存储下来，供后面使用。
optimizer.step()使用反向传播的梯度，对权重值进行更新。

1.3 模型保存与加载

参考博客： Pytorch 保存模型与加载模型

1.3.1 保存模型与加载

简单的保存与加载方法：

保存整个网络(没有参数)这两行一起写

torch.save(net, PATH)

保存网络中的参数, 速度快，占空间少

torch.save(net.state_dict(),PATH)
#--------------------------------------------------
#针对上面一般的保存方法，加载的方法分别是：
model_dict=torch.load(PATH)

# 保存网络中的参数, 速度快，占空间少

model_dict=model.load_state_dict(torch.load(PATH))

2. 保存更多的信息：
	```python
	torch.save({'epoch': epochID + 1, 
		'state_dict': model.state_dict(), 'best_loss': lossMIN,
        'optimizer': optimizer.state_dict(),'alpha': loss.alpha, 
        'gamma': loss.gamma},
        checkpoint_path + '/m-' + launchTimestamp
         + '-' + str("%.4f" % lossMIN) + '.pth.tar')
	```
	
	以上包含的信息有，epochID, state_dict, min loss, optimizer, 自定义损失函数的两个参数；格式以字典的格式存储。
	加载的方式：
```python
	def load_checkpoint(model, checkpoint_PATH, optimizer):
		if checkpoint != None:
			model_CKPT = torch.load(checkpoint_PATH)
			model.load_state_dict(model_CKPT['state_dict'])
			print('loading checkpoint!')
			optimizer.load_state_dict(model_CKPT['optimizer'])
		return model, optimizer

此处再参考：
pytorch 保存和加载 Checkpoint 模型，实现断点训练

 #保存
# 模型类必须在此之前被定义
model = torch.load(PATH)
model.eval()
torch.save({
'epoch': epoch,
'model_state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'loss': loss,
...
}, PATH)
#加载
model = TheModelClass(*args, **kwargs)
optimizer = TheOptimizerClass(*args, **kwargs)
checkpoint = torch.load(PATH)
model.load_state_dict(checkpoint['model_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
epoch = checkpoint['epoch']
loss = checkpoint['loss']
model.eval()
# - or -
model.train()

model_state_dict这种名字自己起，只是字典的key值，load的时候对应好即可。
想存什么存什么，比如epoch等

1.3.2 修改删除网络后，过滤这些参数加载：

我们可能修改了一部分网络，比如加了一些，删除一些，等等，那么需要过滤这些参数，加载方式：

	def load_checkpoint(model, checkpoint, optimizer, loadOptimizer):
		if checkpoint != 'No':
			print("loading checkpoint...")
			model_dict = model.state_dict()
			modelCheckpoint = torch.load(checkpoint)
			pretrained_dict = modelCheckpoint['state_dict']
			# 过滤操作
			new_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict.keys()}
			model_dict.update(new_dict)
			# 打印出来，更新了多少的参数
			print('Total : {}, update: {}'.format(len(pretrained_dict), len(new_dict)))
			model.load_state_dict(model_dict)
			print("loaded finished!")
			# 如果不需要更新优化器那么设置为false
			if loadOptimizer == True:
				optimizer.load_state_dict(modelCheckpoint['optimizer'])
				print('loaded! optimizer')
			else:
				print('not loaded optimizer')
		else:
			print('No checkpoint is included')
		return model, optimizer

详细再看
PyTorch专栏（七）:模型保存与加载那些事

1.3.3 冻结部分参数，训练另一部分参数

方法一：
添加下面一句话到模型中

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)

方法二：
参数保存在有序的字典中，那么可以通过查找参数的名字对应的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

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

我们的需求：屏蔽除了中间某几个结构其他所有层
首先打印出所有的self.state_dict()，然后放入到下面第二行的list中进行过滤，这些不更新。
这些代码放到模型net的def init(self):中

for i,p in enumerate(self.state_dict()):
	if i in [12,13]:
		print(i, p," 不更新")
for i,p in enumerate(self.parameters()):
	if i in [12,13]:
		p.requires_grad = False

查看是否真的屏蔽正确

for name, param in net.named_parameters():
    if param.requires_grad:
        print("requires_grad: True ", name)
    else:
        print("requires_grad: False ", name)

1.4 参数冻结

参考博客: 使用PyTorch加载模型部分参数方法
在深度学习领域，经常需要使用其他人已训练好的模型进行改进或微调，这个时候我们通常会希望加载预训练模型文件的参数，如果网络结构不变，只需要使用load_state_dict方法即可。而当我们改动网络结构后，由于load_state_dict方法要求读入的state_dict的key和net.state_dict()的key对应相等，如果有缺少就会报错。这个时候我们通常希望加载未改动部分结构的参数用来初始化网络。

直接使用load_state_dict提供的参数strict=False，网络结构名字一致的会被导入，不一致的会被舍弃：
net.load_state_dict(checkpoint[‘net’], strict=False)
Optimizer的加载
在加载优化器时，需要注意如果改动了网络结构后，优化器中的参数长度可能会对应不上，这时候就会报错，例如"param ‘initial_lr’ is not specified in param_groups[*] when resuming an optimizer"。
而优化器的load_state_dict方法没有参数strict，此时可以选择只加载优化器的基本信息，例如初始学习率initial_lr。
optimizer_net= torch.optim.Adam([{‘params’: net.parameters(), ‘initial_lr’: 0.002}], lr=2.0e-3, betas=(0.5, 0.999))

参考博客：pytorch冻结部分参数训练另一部分
加载了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 学习pytorch进阶：Pytorch-Lightning

参考博客：Pytorch Lighting 完全攻略

2.1 Crucial

Pytorch-Lighting 的一大特点是把模型和系统分开来看。模型是像Resnet18， RNN之类的纯模型，而系统定义了一组模型如何相互交互，如GAN（生成器网络与判别器网络）、Seq2Seq（Encoder与Decoder网络）和Bert。同时，有时候问题只涉及一个模型，那么这个系统则可以是一个通用的系统，用于描述模型如何使用，并可以被复用到很多其他项目。
Pytorch-Lighting 的核心设计思想是“自给自足”。每个网络也同时包含了如何训练、如何测试、优化器定义等内容。

2.2 Hydra 库使用

【Python】Hydra 库使用记录
首先从这里我们可以看到hydra运行时，会自动建立一个输出文件夹，包含日期和时间信息，然后还会直接将路径调到里面去，以方便保存脚本内的各种东西。这就是初步测试，全部都在这一行：配置的路径在"config"，配置的文件名为"config":

@hydra.main(config_path="config", config_name="config")

import hydra
from omegaconf import DictConfig, OmegaConf
from pathlib import Path

@hydra.main(config_path="config", config_name="config")

def main(config):
    running_dir = str(hydra.utils.get_original_cwd())
    working_dir = str(Path.cwd())
    print(f"The current running directory is {running_dir}")
    print(f"The current working directory is {working_dir}")

    # To access elements of the config
    print(f"The batch size is {config.batch_size}")
    print(f"The learning rate is {config['lr']}")

if __name__ == "__main__":
    main()

### config/config.yaml
batch_size: 10
lr: 1e-4

2.2.1 函数装饰器

参考使用Hydra库管理超参数

import hydra
from omegaconf import DictConfig, OmegaConf

@hydra.main(version_base=None, config_path="conf", config_name="config")
def my_app(cfg : DictConfig) -> None:
    print(OmegaConf.to_yaml(cfg))

if __name__ == "__main__":
    my_app()

这段程序最终输出的是 ./conf/config.yaml 文件中的配置信息

按照菜鸟教程中的说法，Python中的装饰器 (Decorators) 是用于修改其他函数功能的函数，帮助让代码更加简洁。对函数装饰器最简单的理解即——将函数作为参数传给另一个函数，如下面这个例子

def hi():
    return "hi yasoob!"
 
def doSomethingBeforeHi(func):
    print("I am doing some boring work before executing hi()")
    print(func())
 
doSomethingBeforeHi(hi)
#outputs:I am doing some boring work before executing hi()
#        hi yasoob!

这里函数 doSomethingBeforeHi() 其实就可以看作是函数 hi() 的装饰器，在运行过程中，首先在 doSomethingBeforeHi 函数内部添加一些额外内容（在添加这部分内容的部分可以看作是对于原函数功能的修改/补充），之后运行/返回作为参数的 hi 函数

更加直观的例子来自于该博客，如下代码段所示，这一例子也能很好地体现函数装饰器对于已有函数功能的完善作用。

2.2.2 python 冒号

见过一个大佬写的代码是这样的：

user: User = User.objects.filter(id=data.get('uid')).first()

变量名后面的冒号是：类型注解，3.6以后加入的，冒号右边是类型，仅仅是注释，有些鸡肋

变量注释的语法：注释变量类型,明确指出变量类型，方便帮助复杂案例中的类型推断。

var: type = value 其实本质上就是 var = value # type就是var期望的类型

类型注释只是一种提示，并非强制的，Python解释器不会去校验value的类型是否真的是type

2.2.3 使用Hydra构建实例对象

Hydra 提供hydra.utils.instantiate()（及其别名hydra.utils.call()）用于实例化对象和调用函数。更喜欢instantiate创建对象和call调用函数。

传递给这些函数的配置必须有一个名为_target_的键，其值为完全限定的类名、类方法、静态方法或callable。为方便起见，Noneconfig 结果是一个None对象。
onepose代码中的栗子

model:
  _target_: src.lightning_model.OnePosePlus_lightning_model.PL_OnePosePlus
  pretrained_ckpt: "weight/epoch=3-v1.ckpt"

  OnePosePlus:
    loftr_backbone:

命名参数：配置字段（保留字段除外，如_target_）作为命名参数传递给目标。可以通过在call-site中传递具有相同名称的命名参数来覆盖配置中的命名参数instantiate()。

位置参数：配置可能包含一个_args_字段，表示要传递给目标的位置参数。instantiate()可以通过在call-site中传递位置参数来一起覆盖位置参数。

附录

第一章节全部代码

import torchvision
import torchvision.transforms as transforms
import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
import torch.optim
import matplotlib.pyplot as plt
import numpy as np
from torch.autograd import Variable

mode = 'train'
model_path = './model/weight1.ckpt'

# torchvision数据集的输出是在[0, 1]范围内的PILImage图片。
# 我们此处使用归一化的方法将其转化为Tensor，数据范围为[-1, 1]

transform=transforms.Compose([transforms.ToTensor(),
                              transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
                             ])
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, 
                                          shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4, 
                                          shuffle=False, num_workers=2)
classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
# functions to show an image

def imshow(img):
    img = img / 2 + 0.5 # unnormalize
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1,2,0)))

# # show some random training images
# dataiter = iter(trainloader)
# images, labels = dataiter.next()

# # print images
# imshow(torchvision.utils.make_grid(images))
# # print labels
# print(' '.join('%5s'%classes[labels[j]] for j in range(4)))

#  定义一个卷积神经网络
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool  = nn.MaxPool2d(2,2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1   = nn.Linear(16*5*5, 120)
        self.fc9   = nn.Linear(120, 84)
        self.fc2_1   = nn.Linear(84, 42)
        self.fc2_2   = nn.Linear(42, 84)
        self.fc3   = nn.Linear(84, 10)
        for i,p in enumerate(self.state_dict()):
            if i in [12,13]:
                print(i, p," 不更新")
        for i,p in enumerate(self.parameters()):
            if i < 10:
                p.requires_grad = False
                

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16*5*5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc9(x))
        # x = F.relu(self.fc2_1(x))
        # x = F.relu(self.fc2_2(x))
        x = self.fc3(x)
        return x

net = Net()
# 定义代价函数和优化器
criterion = nn.CrossEntropyLoss() # use a Classification Cross-Entropy loss
# optimizer = torch.optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

for name, param in net.named_parameters():
    if param.requires_grad:
        print("requires_grad: True ", name)
    else:
        print("requires_grad: False ", name)

optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad, net.parameters()), lr=0.001, momentum=0.9)


# 加载模型
checkpoint=torch.load(model_path)
model_dict = net.state_dict()  # 这个权重字典都是初始值
pretrained_dict = checkpoint['state_dict']  # 获取权重文件的权重字典，为了后面更新初始值权重字典
new_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict.keys()}  # 过滤掉新增加的或者修改的或者删除的，防止更新的时候对应不上
model_dict.update(new_dict)  # 更新初始权重字典(没有的都是初始值)

print('Total : {}, update: {}'.format(len(pretrained_dict), len(new_dict)))
net.load_state_dict(model_dict)  # 更新网络参数

optimizer.load_state_dict(checkpoint['optimizer'])
print('loaded! optimizer')
print("loaded finished!")




if mode == 'train':
    # 训练网络
    for epoch in range(1): # loop over the dataset multiple times
        
        running_loss = 0.0
        for i, data in enumerate(trainloader, 0):
            # get the inputs
            inputs, labels = data
            
            # wrap them in Variable
            inputs, labels = Variable(inputs), Variable(labels)
            
            # zero the parameter gradients
            optimizer.zero_grad()
            
            # forward + backward + optimize
            outputs = net(inputs)
            loss = criterion(outputs, labels)
            loss.backward()        
            optimizer.step()
            
            # print statistics
            running_loss += loss.data
            if i % 2000 == 1999: # print every 2000 mini-batches
                print('[%d, %5d] loss: %.3f' % (epoch+1, i+1, running_loss / 2000))
                running_loss = 0.0
    # 方式一
    # torch.save(net,model_path)
    # 方式二
    torch.save({
		'state_dict': net.state_dict(),
        'optimizer': optimizer.state_dict()},
        model_path)
    print('Finished Training')
    
    

# 模型保存与加载
else :
    # 正常加载
    # checkpoint=torch.load(model_path)
    
    # net.load_state_dict(checkpoint['state_dict'])
    # optimizer.load_state_dict(checkpoint['optimizer'])

    # 修改网络后加载
    checkpoint=torch.load(model_path)
    model_dict = net.state_dict()  # 这个权重字典都是初始值
    pretrained_dict = checkpoint['state_dict']  # 获取权重文件的权重字典，为了后面更新初始值权重字典
    new_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict.keys()}  # 过滤掉新增加的或者修改的或者删除的，防止更新的时候对应不上
    model_dict.update(new_dict)  # 更新初始权重字典(没有的都是初始值)
    
    print('Total : {}, update: {}'.format(len(pretrained_dict), len(new_dict)))
    net.load_state_dict(model_dict)  # 更新网络参数
    print("loaded finished!")
    
    
    # for i,p in enumerate(net.state_dict()):
    #     print(i, p)
    # print(checkpoint)


# 展示几张照片
dataiter = iter(testloader)
images, labels = dataiter.next()

# print images
imshow(torchvision.utils.make_grid(images))
print('GroundTruth: ', ' '.join('%5s'%classes[labels[j]] for j in range(4)))

# 推理
correct = 0
total = 0
for data in testloader:
    images, labels = data
    outputs = net(Variable(images))
    _, predicted = torch.max(outputs.data, 1)
    total += labels.size(0)
    correct += (predicted == labels).sum()

print('Accuracy of the network on the 10000 test images: %d %%' % (100 * correct / total))