深度学习模型的训练

前言
1.模型的保存与加载
- 方法一：同时保存模型和参数
- 方法二：仅保存参数（数据量小，推荐！）
2.断点的保存与加载
3.预训练模型的使用
4.模型的冻结
- 方法一：设置requires_grad为False
- 方法二：使用 with torch.no_grad()
- 总结
5.模型的特殊加载方式和加载技巧
- 例1：加载预训练模型,并去除需要再次训练的层
- 例2：固定部分参数
- 例3：训练部分参数
- 例4：检查部分参数是否固定
6.单GPU训练与多GPU训练
- Pytorch 使用单GPU训练
- - 方法一 .cuda()
  - 方法二 .to(device)
- 单机多卡与多机多卡

前言

在我们训练模型时，会经常使用一些小技巧，包括：模型的保存与加载、断点的保存与加载、模型的冻结与预热、模型的预训练与加载、单GPU训练与多GPU训练。这些在我们训练网络的过程中会经常遇到。

1.模型的保存与加载

方法一：同时保存模型和参数

# 保存（vgg16是模型，vgg16_methond1.pth是保存的名称）
torch.save(vgg16,"vgg16_methond1.pth")
# 加载
model = torch.load("vgg16_methond1.pth")

方法二：仅保存参数（数据量小，推荐！）

# 保存
torch.save(vgg16.state_dict(),"vgg16_methond2.pth")
# 加载
model2= vgg16(classes=2019)                  # 初始化网络结构
vgg16_dict = torch.load("vgg16_methond2.pth")# 加载参数
model2.load_state_dict(vgg16_dict )          # 将参数加载到网络中去

注意：加载模型权重时，我们需要先实例化模型类，因为该类定义了网络的结构。

2.断点的保存与加载

如果模型的训练时间非常长，而这中间发生了一点小意外，使得模型终止训练，而下次训练时为了节省时间，让模型从断点处继续训练，这就需要在模型训练的过程中保存一些信息，使得模型发生意外后再次训练能从断点处继续训练。所以在模型训练过程中记录信息（checkpoint）是非常重要的一点。模型训练的五个过程：数据、损失函数、模型、优化器、迭代训练。这五个步骤中数据和损失函数是没法改变的，而在迭代训练的过程中模型的一些可学习参数和优化器中的一些缓存是会变的，所以需要保留这些信息，另外还需要保留迭代的次数和学习率。

# 在模型训练时，每隔5个epoch保存模型信息
if (epoch+1) % 5== 0:checkpoint = {"net": model.state_dict(),'optimizer': optimizer.state_dict(),"epoch": epoch,'lr_schedule': lr_schedule.state_dict()}path_checkpoint = "./checkpoint.pkl"torch.save(checkpoint, path_checkpoint)# 加载断点
path_checkpoint = "./checkpoint_4_epoch.pkl"
checkpoint = torch.load(path_checkpoint)             # 加载断点
net.load_state_dict(checkpoint['model'])            # 加载模型可学习参数
optimizer.load_state_dict(checkpoint['optimizer'])      # 加载优化器参数
start_epoch = checkpoint['epoch']                      # 设置开始的epoch
lr_schedule.load_state_dict(checkpoint['lr_schedule'])#加载lr_scheduler
scheduler.last_epoch = start_epoch

在运行推理之前，必须调用model.eval()以将 dropout 和批量标准化层设置为评估模式。不这样做会产生不一致的推理结果。如果是像希望恢复训练，就调用model.train()以确保这些层处于训练模式。

3.预训练模型的使用

pytorch自带有一些高级的复杂模型，有两种使用的方式；
方法一：用torchvision.models函数调用，例如torchvision.models.densenet169(pretrained=True)就调用了densenet169的预训练模型。先来看看这个模块涵盖了哪些模型：见https://pytorch.org/vision/stable/models.html获取详细信息。像resnet50

from torchvision.io import read_image
from torchvision.models.quantization import resnet50, ResNet50_QuantizedWeights
resnet50(weights=ResNet50_Weights.DEFAULT)# Strings are also supported
resnet50(weights="IMAGENET1K_V2")# No weights - random initialization
resnet50(weights=None)

方法二：下载训练好了的参数：
在网站中下载好参数，然后直接加载进网络。

网站还是上面的那个网站，往下翻就能找到。而且不仅仅是分类的模型，语义分割、量化、对象检测、实例分割和人物关键点检测等等。在这里都能找到

4.模型的冻结

在迁移学习或训练新的复杂模型时，加载部分模型是常见的情况。利用训练好的参数，有助于热启动训练过程,并希望帮助你的模型比从头开始训练能够更快地收敛。

方法一：设置requires_grad为False

这种方法的效果是：被冻结的层可以前向传播，也可以反向传播，只是自己这一层的参数不更新，其他未冻结层的参数正常更新。要注意优化器要加上filter： （别的文章都说需要加，但是我用代码测试发现不加好像也可以）

optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, perception.parameters()), lr=learning_rate)

还要注意的是：构造optimizer对象的位置要放在冻结图层操作之后。

设置requires_grad为False有两种方法：
①： x.requires_grad_(False)
②：x.requires_grad = False
两种效果相同。

直接看例子：

import torch
import numpy as np
from torch import nn
from torch.optim import lr_scheduler
# 检查GPU是否可用
device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Using {device} device")# 首先建立一个卷积的神经网络
class Bulk(nn.Module):def __init__(self,in_channels,out_channels):super(Bulk, self).__init__()self.bulk_6 = nn.Sequential(nn.Conv2d(in_channels,in_channels*2, kernel_size=3, padding=1),nn.ReLU(),nn.BatchNorm2d(in_channels*2),nn.Conv2d(in_channels*2, out_channels, kernel_size=3, padding=1),nn.ReLU(),nn.BatchNorm2d(out_channels))def forward(self, x):logits = self.bulk_6(x)return logitsclass module(nn.Module):def __init__(self,in_C, hid1, hid2, out_C):super(module, self).__init__()self.bulk1 = Bulk(in_C,hid1)self.bulk2 = Bulk(hid1, hid2)self.bulk3 = Bulk(hid2, out_C)def forward(self, x):x1 = self.bulk1(x)x2 = self.bulk2(x1)y = self.bulk3(x2)return ydef save_breakpoint(model, lr_schedule):if (epoch + 1) % 5 == 0:checkpoint = {"net": model.state_dict(),'optimizer': optimizer.state_dict(),"epoch": epoch,'lr_schedule': lr_schedule.state_dict()}path_checkpoint = "./checkpoint.pkl"torch.save(checkpoint, path_checkpoint)# 模型实例化
module_1 = module(1, 2, 2, 1)# 创建输入输出数据
X = np.random.normal(1, 0.5, (32, 32))
Y = X*3+np.random.normal(0, 0.1, (32,32))
x = torch.tensor(X, dtype=torch.float32).unsqueeze(0).unsqueeze(0)
y = torch.tensor(Y, dtype=torch.float32).unsqueeze(0).unsqueeze(0)
loss_fn = torch.nn.MSELoss(reduction='mean')
optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, module_1.parameters()), lr=1e-2)epochs=2for epoch in range(epochs):# 模型冻结if epoch == 0:for k, v in module_1.named_parameters():if any(x in k.split('.') for x in ['0']):print('unfreezing %s' % k)v.requires_grad_(True)else:for k, v in module_1.named_parameters():if any(x in k.split('.') for x in ['0']):print('freezing %s' % k)v.requires_grad_(False)# 查看参数for k, v in module_1.bulk1.bulk_6.named_parameters():if any(x in k.split('.') for x in ['0']):print(k,v)y_pred = module_1(x)                     # 预测loss = loss_fn(y_pred, y)                # 损失函数optimizer.zero_grad()                    # 清空梯度loss.backward()                          # 反向传播计算梯度optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, module_1.parameters()), lr=1e-2)scheduler = lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.995)optimizer.step()                         # 更新参数scheduler.step()                         # 一次epoch进行一次scheduler.step()，进行学习率更新save_breakpoint(module_1, scheduler)     # 保存断点# print('lr={0}, Loss={1}'.format(optimizer.state_dict()['param_groups'][0]['lr'], loss.item()))for k, v in module_1.bulk1.bulk_6.named_parameters():  # 查看参数if any(x in k.split('.') for x in ['0']):print(k,v)torch.save(module_1.state_dict(),"freezing.pth")

梯度正常更新时，所有层都参与训练，下面是bulk6.0层训练前后的变化：
梯度停止更新时， bulk6.0层不参与训练，下面是bulk6.0层训练前后的变化：

方法二：使用 with torch.no_grad()

该方法的性质：
这种方式只需要在网络定义中的forward方法中，将需要冻结的层放在 with torch.no_grad()下。
放入with torch.no_grad()中的网络层，可以前向传播，但反向传播被阻断，自己这层（如self.layer2）和前面的所有与之相关的层（如self.layer1）的参数都会被冻结，不会被更新。但如果前面的层除了和self.layer2相关外，还与其他层有联系，则与其他层联系的部分正常更新。
还是直接看例子：

# 首先建立一个卷积的神经网络
class Bulk(nn.Module):def __init__(self,in_channels,out_channels):super(Bulk, self).__init__()self.bulk_6 = nn.Sequential(nn.Conv2d(in_channels,in_channels*2, kernel_size=3, padding=1),nn.ReLU(),nn.BatchNorm2d(in_channels*2),nn.Conv2d(in_channels*2, out_channels, kernel_size=3, padding=1),nn.ReLU(),nn.BatchNorm2d(out_channels))def forward(self, x):logits = self.bulk_6(x)return logitsclass module(nn.Module):def __init__(self,in_C, hid1, hid2, out_C):super(module, self).__init__()self.bulk1 = Bulk(in_C,hid1)self.bulk2 = Bulk(hid1, hid2)self.bulk3 = Bulk(hid2, out_C)def forward(self, x):with torch.no_grad():x1 = self.bulk1(x)x2 = self.bulk2(x1)y = self.bulk3(x2)return y# 模型实例化
module_1 = module(1, 2, 2, 1)# 创建输入输出数据
X = np.random.normal(1, 0.5, (32, 32))
Y = X*3+np.random.normal(0, 0.1, (32,32))
x = torch.tensor(X, dtype=torch.float32).unsqueeze(0).unsqueeze(0)
y = torch.tensor(Y, dtype=torch.float32).unsqueeze(0).unsqueeze(0)
loss_fn = torch.nn.MSELoss(reduction='mean')
optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, module_1.parameters()), lr=1e-2)epochs=2for epoch in range(epochs):# 查看参数for k, v in module_1.bulk1.bulk_6.named_parameters():if any(x in k.split('.') for x in ['0']):print(k,v)y_pred = module_1(x)                     # 预测loss = loss_fn(y_pred, y)                # 损失函数optimizer.zero_grad()                    # 清空梯度loss.backward()                          # 反向传播计算梯度optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, module_1.parameters()), lr=1e-2)scheduler = lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.995)optimizer.step()                         # 更新参数scheduler.step()                         # 一次epoch进行一次scheduler.step()，进行学习率更新# print('lr={0}, Loss={1}'.format(optimizer.state_dict()['param_groups'][0]['lr'], loss.item()))for k, v in module_1.bulk1.bulk_6.named_parameters():  # 查看参数if any(x in k.split('.') for x in ['0']):print(k,v)

例子中的模型是由三个网络块构成，其中bulk1被with torch.no_grad()屏蔽，不参与参数更新。实验结果如下：bulk1中的网络层在运行了一个epoch后权重没变。

总结

方法一：比较灵活，但是写起来麻烦。
方法二：不能单独屏蔽某一个epoch，但是使用起来简单便捷，大多数的情况下其实都是够用的。

这里我再推荐一篇文章【pytorch】筛选冻结部分网络层参数同时设置有参数组的时候该怎么办？

5.模型的特殊加载方式和加载技巧

例1：加载预训练模型,并去除需要再次训练的层

注意：需要重新训练的层的名字要和之前的不同。

model=resnet()#自己构建的模型，以resnet为例
model_dict = model.state_dict()
pretrained_dict = torch.load('xxx.pkl')
pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict}
model_dict.update(pretrained_dict)
model.load_state_dict(model_dict)

例2：固定部分参数

#k是可训练参数的名字，v是包含可训练参数的一个实体
#可以先print（k）,找到自己想进行调整的层，并将该层的名字加入到if语句中：
for k,v in model.named_parameters():if k!='xxx.weight' and k!='xxx.bias' :v.requires_grad=False#固定参数

例3：训练部分参数

#将要训练的参数放入优化器
optimizer2=torch.optim.Adam(params=[model.xxx.weight，model.xxx.bias],lr=learning_rate,betas=(0.9,0.999),weight_decay=1e-5)

例4：检查部分参数是否固定

for k,v in model.named_parameters():if k!='xxx.weight' and k!='xxx.bias' :print(v.requires_grad)#理想状态下，所有值都是False

需要注意的是，如果操作失误，loss函数几乎不会发生变化，一直处于最开始的状态，这很可能是因为所有参数都被固定了。

6.单GPU训练与多GPU训练

GPU处理大规模的矩阵数据的速度可以比CPU快50-100倍，所以用GPU来跑算法是很有必要的。

Pytorch 使用单GPU训练

使用 GPU 训练只需要在原来的代码中修改几处就可以了。只需要将需要在GPU上运行的模型和数据都搬过去，剩下的就和在CPU上运行的程序是一样的了，我们有两种方式实现代码在 GPU 上进行训练，

方法一 .cuda()

我们可以通过对网络模型，数据，损失函数这三种变量调用 .cuda() 来在GPU上进行训练

# 实例化网络模型和损失函数
model = Model()
loss_fn = nn.CrossEntropyLoss()
# 将网络模型和损失函数放在gpu上训练
if torch.cuda.is_available():# 检测是否有可用的GPUmodel = model.cuda() loss_fn = loss_fn.cuda()# 数据放在gpu上训练
for data in dataloader:                        imgs, targets = dataif torch.cuda.is_available():imgs = imgs.cuda()targets = targets.cuda()

方法二 .to(device)

方法和上面差不多，就不过多赘述了，直接上代码。

# 指定训练的设备
device = torch.device("cpu") # 使用cpu训练
device = torch.device("cuda")    # 使用gpu训练
device = torch.device("cuda:0")  # 当电脑中有多张显卡时，使用第一张显卡
device = torch.device("cuda:1")  # 当电脑中有多张显卡时，使用第二张显卡device = torch.device("cuda" if torch.cuda.is_available() else "cpu")# 使用 GPU 训练
model = model.to(device)
loss_fn = loss_fn.to(device)
for data in train_dataloader:imgs, targets = dataimgs = imgs.to(device)targets = targets.to(device)

单机多卡与多机多卡

这一部分由于设备问题无法实现，就不写了。我推荐一篇我感觉这块儿写的很不错的文章，有需要的小伙伴可以跳过去看看。
《超全Pytorch多GPU训练》：https://blog.csdn.net/Ema1997/article/details/106284407

深度学习模型的训练（大总结）相关推荐

可视化深度学习模型的训练误差和验证误差
可视化深度学习模型的训练误差和验证误差 #导入基础包和库 # Load libraries import numpy as np from keras.datasets import imdb fro ...
深度学习模型实战-深度学习模型在各大公司实际生产环境的应用讲解文章
仓库地址:https://github.com/DA-southampton/Tech_Aarticle/edit/master/README.md 建这个仓库的是因为工作之后发现生产环境中应用的模型 ...
【深度学习模型的训练与评估】一个实例：Iris多分类
文章目录: 1 评估深度学习模型1.1 自动评估1.2 手动评估1.3 k折交叉验证 2 在Keras中使用Sklearn 3 深度学习模型调参数 4 Iris多分类4.1 数据集分析4.2 代码 1 ...
深度学习模型在训练集上很好而在测试集表现得不好而拟合次数并不多_机器学习中的过拟合，欠拟合和偏倚方差折衷...
过度拟合在机器学习中很重要. 很直观的解释过拟合:假设我们现在让机器学习考试做题,想象一种情况,机器逐字记住每个问题的答案(拟合非常好-完美).然后,我们可以在练习题上得分很高:我们这样做是基于希望实 ...
加载tf模型正确率很低_深度学习模型训练全流程！
↑↑↑关注后"星标"Datawhale 每日干货 & 每月组队学习,不错过 Datawhale干货作者:黄星源.奉现,Datawhale优秀学习者本文从构建数据验证集. ...
深度学习模型训练的一般方法（以DSSM为例）
向AI转型的程序员都关注了这个号???????????? 机器学习AI算法工程公众号:datayx 本文主要用于记录DSSM模型学习期间遇到的问题及分析.处理经验.先统领性地提出深度学习模型训练 ...
该如何训练好深度学习模型？
博主不是专业搞竞赛出生,仅依赖博主为数有限的工程经验,从工程实践的方面讨论如何把深度学习模型训练好.如果写的不好,欢迎各位大佬在评论区留言互动.训练好深度学习模型与训练深度学习模型差别还是很大的,训练 ...
喜马拉雅基于阿里云机器学习平台PAI-HybridBackend的深度学习模型训练优化实践
喜马拉雅作者:李超.陶云.许晨昱.胡文俊.张争光.赵云鹏.张玉静喜马拉雅AI云借助阿里云提供的HybridBackend开源框架,实现了其推荐模型在 GPU 上的高效训练. 业务介绍推荐场景是喜马 ...
除了网络搜索(NAS)，AutoML对深度学习模型优化还有哪些贡献？
文/编辑 | 言有三自从Google提出AutoML技术以来,已经过去了好几年了,如今在学术界和工业界都是热点.AutoML在网络结构的搜索上已经取得了非常多的突破,相关的文章,技术博客都已经广为流 ...

深度学习模型的训练（大总结）