深度学习基础：7.模型的保存与加载/学习率调度

Posted 2022-07-15 zstar-_

模型的保存与加载

模型的保存和加载，本质上都是针对模型的参数。

模型参数

在Pytorch中，可以使用state_dict()查看模型的参数信息。
例如：
输入

model.state_dict()

输出

OrderedDict([('linear1.weight',
              tensor([[ 0.2365, -0.1118, -0.3801,  0.0275,  0.4168],
                      [-0.1995, -0.1456,  0.3497, -0.0622, -0.1708],
                      [-0.0901,  0.0164, -0.3643, -0.1278,  0.4336],
                      [-0.0959,  0.4073, -0.1746, -0.1799, -0.1333]])),
             ('linear1.bias', tensor([-0.3999, -0.2694,  0.2703, -0.3355])),
             ('normalize1.weight', tensor([1., 1., 1., 1.])),
             ('normalize1.bias', tensor([0., 0., 0., 0.])),
             ('normalize1.running_mean', tensor([0., 0., 0., 0.])),
             ('normalize1.running_var', tensor([1., 1., 1., 1.])),
             ('normalize1.num_batches_tracked', tensor(0)),
             ('linear2.weight',
              tensor([[ 0.1708,  0.4704, -0.0635,  0.2187],
                      [ 0.2336, -0.3569, -0.1928, -0.1566],
                      [ 0.4825, -0.4463,  0.3027,  0.4696],
                      [ 0.3953,  0.2131,  0.2226, -0.0267]])),
             ('linear2.bias', tensor([ 0.2516,  0.4558, -0.1608,  0.4831])),
             ('normalize2.weight', tensor([1., 1., 1., 1.])),
             ('normalize2.bias', tensor([0., 0., 0., 0.])),
             ('normalize2.running_mean', tensor([0., 0., 0., 0.])),
             ('normalize2.running_var', tensor([1., 1., 1., 1.])),
             ('normalize2.num_batches_tracked', tensor(0)),
             ('linear3.weight',
              tensor([[ 0.0795, -0.3507, -0.3589,  0.1764]])),
             ('linear3.bias', tensor([-0.0705]))])

模型保存

torch.save(tanh_model1.state_dict(), 'best_model.pt')

• 参数1：模型参数
• 参数2：保存名称

模型加载

model.load_state_dict('best_model.pt')

学习率调度

学习率调度指的是在模型训练的过程中，动态调整学习率。我们可以通过调用Pytorch中optim模块下的lr_scheduler相关函数，来实现优化器中学习率的动态调整。

假设，优化器中的lr伴随模型迭代相应调整的方法如下：
$$lr=lr\_lambda(epoch)\ast initial\_lr$$

并且，第一次实例化LambdaLR时epoch取值为0时，因此此时优化器的lr计算结果如下：$$l{r}_0=0.5^0\ast 0.05=0.05$$

构造动态调整规则：

lr_lambda = lambda epoch: 0.5 ** epoch

完整使用实例：在第四节构造的模型上进行添加

import torch
import torch.nn as nn
import torch.optim as optim
from torch.nn import functional as F
from torch.optim import lr_scheduler

lr_lambda = lambda epoch: 0.5 ** epoch

torch.manual_seed(103)
X = torch.rand((500,20),dtype=torch.float32) * 100
y = torch.randint(low=0,high=3,size=(500,),dtype=torch.float32)
lr = 0.1  # 学习率
gamma = 0.9 # 动量
class Model(nn.Module):
    def __init__(self,in_features=10,out_features=2):
        super(Model,self).__init__() 
        self.linear1 = nn.Linear(in_features,13,bias=True) 
        self.linear2 = nn.Linear(13,8,bias=True)
        self.output = nn.Linear(8,out_features,bias=True)
        
    def forward(self, x):
        sigma1 = torch.relu(self.linear1(x))
        sigma2 = torch.sigmoid(self.linear2(sigma1))
        zhat = self.output(sigma2)
        return zhat
    
input_ = X.shape[1] #特征的数目
output_ = len(y.unique()) #分类的数目
net = Model(in_features=input_, out_features=output_) #实例化网络
criterion = nn.CrossEntropyLoss() #定义损失函数
optimizer = torch.optim.SGD(net.parameters(), lr=0.05) # 创建优化器
scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda) # 创建学习率调度器
yhat = net.forward(X) 
loss = criterion(yhat, y.long()) #计算损失函数
loss.backward()
optimizer.step() #走一步，更新权重w，更新动量v
optimizer.zero_grad() #清除原来储存好的，基于上一个坐标点计算的梯度，为下一次计算梯度腾出空间
scheduler.step()