深入浅出pytorch笔记——第六章

第六章

6.1 自定义损失函数

在自定义损失函数时，涉及到数学运算时，我们最好全程使用PyTorch提供的张量计算接口，这样就不需要我们实现自动求导功能并且我们可以直接调用cuda
使用numpy或者scipy的数学运算时，操作会有些麻烦

以函数方式定义

def my_loss(output, target):
    loss = torch.mean((output - target)**2)
    return loss

以类方式定义

损失函数类需要继承自nn.Module类

class DiceLoss(nn.Module):
    def __init__(self,weight=None,size_average=True):
        super(DiceLoss,self).__init__()
        
    def forward(self,inputs,targets,smooth=1):
        inputs = F.sigmoid(inputs)       
        inputs = inputs.view(-1)
        targets = targets.view(-1)
        intersection = (inputs * targets).sum()                   
        dice = (2.*intersection + smooth)/(inputs.sum() + targets.sum() + smooth)  
        return 1 - dice
# 使用方法（记得先实例化！！！）
criterion = DiceLoss()
loss = criterion(input,targets)

6.2 动态调整学习率

通过一个适当的学习率衰减策略来改善这种现象，提高我们的精度。这种设置方式在PyTorch中被称为scheduler

使用官方scheduler

• lr_scheduler.LambdaLR
• lr_scheduler.MultiplicativeLR
• lr_scheduler.StepLR
• lr_scheduler.MultiStepLR
• lr_scheduler.ExponentialLR
• lr_scheduler.CosineAnnealingLR
• lr_scheduler.ReduceLROnPlateau
• lr_scheduler.CyclicLR
• lr_scheduler.OneCycleLR
• lr_scheduler.CosineAnnealingWarmRestarts
  关于如何使用这些动态调整学习率的策略，PyTorch官方也很人性化的给出了使用实例代码帮助大家理解，我们也将结合官方给出的代码来进行解释。

# 选择一种优化器
optimizer = torch.optim.Adam(...) 
# 选择上面提到的一种或多种动态调整学习率的方法
scheduler1 = torch.optim.lr_scheduler.... 
scheduler2 = torch.optim.lr_scheduler....
...
schedulern = torch.optim.lr_scheduler....
# 进行训练
for epoch in range(100):
    train(...)
    validate(...)
    optimizer.step()
    # 需要在优化器参数更新之后再动态调整学习率
	scheduler1.step() 
	...
    schedulern.step()

我们在使用官方给出的torch.optim.lr_scheduler时，需要将scheduler.step()放在optimizer.step()后面进行使用

自定义scheduler

自己定义学习率调整，使用自定义函数adjust_learning_rate来改变param_group中lr的值，在下面的叙述中会给出一个简单的实现。

#每30轮下降为原来的1/10
def adjust_learning_rate(optimizer, epoch):
    lr = args.lr * (0.1 ** (epoch // 30))
    for param_group in optimizer.param_groups:
        param_group['lr'] = lr

有了adjust_learning_rate函数的定义，在训练的过程就可以调用我们的函数来实现学习率的动态变化

def adjust_learning_rate(optimizer,...):
    ...
optimizer = torch.optim.SGD(model.parameters(),lr = args.lr,momentum = 0.9)
for epoch in range(10):
    train(...)
    validate(...)
    adjust_learning_rate(optimizer,epoch)

6.3模型微调

TIMM

除了使用torchvision.models进行预训练以外，还有一个常见的预训练模型库，叫做timm

• Github链接：https://github.com/rwightman/pytorch-image-models
• 官网链接：https://fastai.github.io/timmdocs/
  https://rwightman.github.io/pytorch-image-models/

模型微调-torchvision

数据集太少，从头开始训练具有几千万参数的大型神经网络是不现实的，因为越大的模型对数据量的要求越大，过拟合无法避免。收集更多的数据或者应用应用迁移学习，迁移学习的一大应用场景是模型微调（finetune），先找到一个同类的别人训练好的模型，把别人现成的训练好了的模型拿过来，换成自己的数据，通过训练调整一下参数

流程

1. 在源数据集(如ImageNet数据集)上预训练一个神经网络模型，即源模型
2. 创建一个新的神经网络模型，即目标模型。它复制了源模型上除了输出层外的所有模型设计及其参数。我们假设这些模型参数包含了源数据集上学习到的知识，且这些知识同样适用于目标数据集。我们还假设源模型的输出层跟源数据集的标签紧密相关，因此在目标模型中不予采用
3. 为目标模型添加一个输出⼤小为⽬标数据集类别个数的输出层，并随机初始化该层的模型参数
4. 在目标数据集上训练目标模型。我们将从头训练输出层，而其余层的参数都是基于源模型的参数微调得到的

使用已有模型结构

通过True或者False来决定是否使用预训练好的权重
在默认状态下pretrained = False，意味着我们不使用预训练得到的权重
当pretrained = True，意味着我们将使用在一些数据集上预训练得到的权重

import torchvision.models as models
vgg16 = models.vgg16(pretrained=True)
googlenet = models.googlenet(pretrained=True)
mobilenet_v3_small = models.mobilenet_v3_small(pretrained=True)
resnext50_32x4d = models.resnext50_32x4d(pretrained=True)
wide_resnet50_2 = models.wide_resnet50_2(pretrained=True)
mnasnet = models.mnasnet1_0(pretrained=True)

1. 通常PyTorch模型的扩展为.pt或.pth，程序运行时会首先检查默认路径中是否有已经下载的模型权重，一旦权重被下载，下次加载就不需要下载了。
2. 一般情况下预训练模型的下载会比较慢，我们可以直接通过迅雷或者其他方式去 这里 查看自己的模型里面model_urls，然后手动下载，预训练模型的权重在Linux和Mac的默认下载路径是用户根目录下的.cache文件夹。在Windows下就是C:\Users\\.cache\torch\hub\checkpoint。我们可以通过使用 torch.utils.model_zoo.load_url()设置权重的下载地址。
3. 如果觉得麻烦，还可以将自己的权重下载下来放到同文件夹下，然后再将参数加载网络。

   self.model = models.resnet50(pretrained=False)
   self.model.load_state_dict(torch.load('./model/resnet50-19c8e357.pth'))

4. 如果中途强行停止下载的话，一定要去对应路径下将权重文件删除干净，要不然可能会报错。

训练特定层

在默认情况下，参数的属性.requires_grad = True，如果我们从头开始训练或微调不需要注意这里
但如果我们正在提取特征并且只想为新初始化的层计算梯度，其他参数不进行改变那我们就需要通过设置requires_grad = False来冻结部分层

def set_parameter_requires_grad(model, feature_extracting):
    if feature_extracting:
        for param in model.parameters():
            param.requires_grad = False

在下面我们使用resnet18为例的将1000类改为4类，但是仅改变最后一层的模型参数，不改变特征提取的模型参数；注意我们先冻结模型参数的梯度，再对模型输出部分的全连接层进行修改，这样修改后的全连接层的参数就是可计算梯度的。

import torchvision.models as models
# 冻结参数的梯度
feature_extract = True
model = models.resnet18(pretrained=True)
set_parameter_requires_grad(model, feature_extract)
# 修改模型
num_ftrs = model.fc.in_features
model.fc = nn.Linear(in_features=num_ftrs, out_features=4, bias=True)

之后在训练过程中，model仍会进行梯度回传，但是参数更新则只会发生在fc层。通过设定参数的requires_grad属性，我们完成了指定训练模型的特定层的目标，这对实现模型微调非常重要

6.4 半精度训练

GPU，也就是“卡”。GPU的性能主要分为两部分：算力和显存，前者决定了显卡计算的速度，后者则决定了显卡可以同时放入多少数据用于计算
在可以使用的显存数量一定的情况下，每次训练能够加载的数据更多（也就是batch size更大），则也可以提高训练效率。有时候数据本身比较大（比如3D图像、视频等），显存较小的情况下可能甚至batch size为1的情况都无法实现。因此，合理使用显存也就显得十分重要
我们观察PyTorch默认的浮点数存储方式用的是torch.float32，小数点后位数更多固然能保证数据的精确性，但绝大多数场景其实并不需要这么精确，只保留一半的信息也不会影响结果，也就是使用torch.float16格式。由于数位减了一半，因此被称为“半精度”

半精度训练的设置

在PyTorch中使用autocast配置半精度训练，同时需要在下面三处加以设置：

import autocast

from torch.cuda.amp import autocast

模型设置

在模型定义中，使用python的装饰器方法，用autocast装饰模型中的forward函数。关于装饰器的使用，可以参考这里：

@autocast()   
def forward(self, x):
    ...
    return x

训练过程

在训练过程中，只需在将数据输入模型及其之后的部分放入“with autocast():“即可：

 for x in train_loader:
	x = x.cuda()
	with autocast():
        output = model(x)
        ...

半精度训练主要适用于数据本身的size比较大（比如说3D图像、视频等）。
当数据本身的size并不大时（比如手写数字MNIST数据集的图片尺寸只有28乘28），使用半精度训练则可能不会带来显著的提升

6.5 数据增强imgaug

使用argparse进行调参

总的来说，我们可以将argparse的使用归纳为以下三个步骤

• 创建ArgumentParser()对象
• 调用add_argument()方法添加参数
• 使用parse_args()解析参数
  在接下来的内容中，我们将以实际操作来学习argparse的使用方法。

# demo.py
import argparse

# 创建ArgumentParser()对象
parser = argparse.ArgumentParser()

# 添加参数
parser.add_argument('-o', '--output', action='store_true', 
    help="shows output")
# action = `store_true` 会将output参数记录为True
# type 规定了参数的格式
# default 规定了默认值
parser.add_argument('--lr', type=float, default=3e-5, help='select the learning rate, default=1e-3') 
parser.add_argument('--batch_size', type=int, required=True, help='input batch size') 

# 使用parse_args()解析函数
args = parser.parse_args()
if args.output:
    print("This is some output")
    print(f"learning rate:{args.lr} ")

我们在命令行使用python demo.py --lr 3e-4 --batch_size 32，就可以看到以下的输出

This is some output
learning rate: 3e-4

参数

argparse的参数主要可以分为可选参数和必选参数。可选参数就跟我们的lr参数相类似，未输入的情况下会设置为默认值。必选参数就跟我们的batch_size参数相类似，当我们给参数设置required =True后，我们就必须传入该参数，否则就会报错

使用

将有关超参数的操作写在config.py，然后在train.py或者其他文件导入就可以
具体的config.py可以参考如下内容：

import argparse

# 创建ArgumentParser()对象
def get_options(parser=argparse.ArgumentParser()): 

    # 添加参数
    parser.add_argument('--workers', type=int, default=0,  
                        help='number of data loading workers, you had better put it ' '4 times of your gpu')  
    parser.add_argument('--batch_size', type=int, default=4, help='input batch size, default=64')  
    parser.add_argument('--niter', type=int, default=10, help='number of epochs to train for, default=10')  
    parser.add_argument('--lr', type=float, default=3e-5, help='select the learning rate, default=1e-3')  
    parser.add_argument('--seed', type=int, default=118, help="random seed")  
    parser.add_argument('--cuda', action='store_true', default=True, help='enables cuda')  
    parser.add_argument('--checkpoint_path',type=str,default='',  
                        help='Path to load a previous trained model if not empty (default empty)')  
    parser.add_argument('--output',action='store_true',default=True,help="shows output")  
    
    # 使用parse_args()解析函数
    opt = parser.parse_args()  
    if opt.output:  
        print(f'num_workers: {opt.workers}')  
        print(f'batch_size: {opt.batch_size}')  
        print(f'epochs (niters) : {opt.niter}')  
        print(f'learning rate : {opt.lr}')  
        print(f'manual_seed: {opt.seed}')  
        print(f'cuda enable: {opt.cuda}')  
        print(f'checkpoint_path: {opt.checkpoint_path}')  
    return opt  
if __name__ == '__main__':  
    opt = get_options()

这是输出

$ python config.py
num_workers: 0
batch_size: 4
epochs (niters) : 10
learning rate : 3e-05
manual_seed: 118
cuda enable: True
checkpoint_path:

随后在train.py等其他文件，我们就可以使用下面的这样的结构来调用参数

# 导入必要库
...
import config
#opt是解析的超参数
opt = config.get_options()

manual_seed = opt.seed
num_workers = opt.workers
batch_size = opt.batch_size
lr = opt.lr
niters = opt.niters
checkpoint_path = opt.checkpoint_path

# 随机数的设置，保证复现结果
def set_seed(seed):
    torch.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)
    random.seed(seed)
    np.random.seed(seed)
    torch.backends.cudnn.benchmark = False
    torch.backends.cudnn.deterministic = True
...
if __name__ == '__main__':
	set_seed(manual_seed)
	for epoch in range(niters):
		train(model,lr,batch_size,num_workers,checkpoint_path)
		val(model,lr,batch_size,num_workers,checkpoint_path)

STUffT&夏日回音