PyTorch进阶训练技巧

一，Pytorch进阶训练技巧

1.1 自定义损失函数

PyTorch在torch.nn模块提供了常用的损失函数，比如：MSELoss，L1Loss，BCELoss…。但是假如说，我们需要用到自己设计的非通用的损失函数呢？就需要我们自己进行定义。
一般情况下，通过以下两种方式进行定义：

1.1.1函数方式

从本质上，损失函数是一个函数，因此使用函数定义的方式，例如下：

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

1.1.2以类的方式

相较于函数的简单，类的方式的定义更加常用。使用类定义损失函数时，Loss函数部分继承自_Loss,部分继承自_WeightedLoss, 而_WeightedLoss继承自_loss， _loss继承自 nn.Module。因此我们可以当作神经网络中的一层，损失函数需要继承nn.Module类。
Dice Loss是一种在图像分割领域常见的损失函数：

实现代码如下：

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)

除此之外，常见的损失函数还有BCE-Dice Loss，Jaccard/Intersection over Union (IoU) Loss，Focal Loss等。
注：定义损失函数时，最好全程使用Pytorch提供的张量计算接口，这样方便实现自动求导功能和直接调用cuda，比使用numpy方便。

1.2动态调整学习率

学习率的选择是模型训练的重要问题，学习速率设置过小，会极大降低收敛速度，增加训练时间；学习率太大，可能导致参数在最优解两侧来回振荡。
当选定了一个合适的学习率后，经过许多轮的训练后，可能会出现准确率震荡或loss不再下降等情况，说明当前学习率已不能满足模型调优的需求。此时我们就可以通过一个适当的学习率衰减策略来改善这种现象，提高我们的精度。这种设置方式在PyTorch中被称为scheduler。
官方API：PyTorch已经在torch.optim.lr_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

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

# 选择一种优化器
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()

自定义scheduler:自定义函数adjust_learning_rate来改变param_group中lr的值,叙述如下：
假设我们现在正在做实验，需要学习率每30轮下降为原来的1/10，假设已有的官方API中没有符合我们需求的，那就需要自定义函数来实现学习率的改变。

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)

1.3模型微调-torchvision

模型微调的目的：1，大模型小数据的过拟合；2，数据集的数据量有限
迁移学习：将从源数据集学到的知识迁移到目标数据集上。
模型微调：找到同类训练好的模型，换成自己的数据，通过训练调整参数。

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

常见模型结构：
实例化网络：

import torchvision.models as models
resnet18 = models.resnet18()
# resnet18 = models.resnet18(pretrained=False)  等价于与上面的表达式
alexnet = models.alexnet()
vgg16 = models.vgg16()
squeezenet = models.squeezenet1_0()
densenet = models.densenet161()
inception = models.inception_v3()
googlenet = models.googlenet()
shufflenet = models.shufflenet_v2_x1_0()
mobilenet_v2 = models.mobilenet_v2()
mobilenet_v3_large = models.mobilenet_v3_large()
mobilenet_v3_small = models.mobilenet_v3_small()
resnext50_32x4d = models.resnext50_32x4d()
wide_resnet50_2 = models.wide_resnet50_2()
mnasnet = models.mnasnet1_0()

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

import torchvision.models as models
resnet18 = models.resnet18(pretrained=True)
alexnet = models.alexnet(pretrained=True)
squeezenet = models.squeezenet1_0(pretrained=True)
vgg16 = models.vgg16(pretrained=True)
densenet = models.densenet161(pretrained=True)
inception = models.inception_v3(pretrained=True)
googlenet = models.googlenet(pretrained=True)
shufflenet = models.shufflenet_v2_x1_0(pretrained=True)
mobilenet_v2 = models.mobilenet_v2(pretrained=True)
mobilenet_v3_large = models.mobilenet_v3_large(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

1.3模型微调-timm

除了使用torchvision.models进行预训练以外，还有一个常见的预训练模型库，叫做timm。
查看预训练模型种类：timm提供的预训练模型已经达到了592个，我们可以通过timm.list_models()方法查看timm提供的预训练模型。

import timm
avail_pretrained_models = timm.list_models(pretrained=True)
len(avail_pretrained_models)

使用和修改预训练模型：得到我们想要使用的预训练模型后，我们可以通过timm.create_model()的方法来进行模型的创建，我们可以通过传入参数pretrained=True，来使用预训练模型。同样的，我们也可以使用跟torchvision里面的模型一样的方法查看模型的参数类型。

import timm
import torch

model = timm.create_model('resnet34',pretrained=True)
x = torch.randn(1,3,224,224)
output = model(x)
output.shape

模型的保存：imm库所创建的模型是torch.model的子类，我们可以直接使用torch库中内置的模型参数保存和加载的方法，具体操作如下方代码所示

torch.save(model.state_dict(),'./checkpoint/timm_model.pth')
model.load_state_dict(torch.load('./checkpoint/timm_model.pth'))

详细参考资料：
https://www.aiuai.cn/aifarm1967.html
https://towardsdatascience.com/getting-started-with-pytorch-image-models-timm-a-practitioners-guide-4e77b4bf9055
https://chowdera.com/2022/03/202203170834122729.html

1.4半精度训练

硬件设备GPU，也就是“显卡”。GPU的性能主要分为两部分：算力和显存，前者决定了显卡计算的速度，后者则决定了显卡可以同时放入多少数据用于计算。
使用的显存数量一定的情况下，每次训练能够加载的数据更多（也就是batch size更大），则也可以提高训练效率。

PyTorch默认的浮点数存储方式用的是torch.float32，小数点后位数更多固然能保证数据的精确性，但绝大多数场景其实并不需要这么精确，只保留一半的信息也不会影响结果，也就是使用torch.float16格式。由于数位减了一半，因此被称为“半精度”

通过半精度来减少显存的占用，使显卡能够加载更多的数据。

半精度训练主要适用于数据本身的size比较大（比如说3D图像、视频等）。当数据本身的size并不大时（比如手写数字MNIST数据集的图片尺寸只有28*28），使用半精度训练则可能不会带来显著的提升
半精度训练的设置：使用autocast配置半精度训练，分为以下三个步骤：

1-导入：

from torch.cuda.amp import autocast

2-模型设置：在模型定义中，使用python的装饰器方法，用autocast装饰模型中的forward函数。

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

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

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

1.5数据增强-imgaug

为克服部分场景中无法获得大量数据，使用数据增强提高训练集的大小和质量。
imgaug:计算机视觉任务中常用的一个数据增强的包，相比于torchvision.transforms，它提供了更多的数据增强方法。
链接：https://github.com/aleju/imgaug
https://github.com/aleju/imgaug-doc/tree/master/notebooks
使用方法：imgaug仅仅提供了图像增强的一些方法，但是并未提供图像的IO操作。
1-单张图片处理：

import imageio
import imgaug as ia
%matplotlib inline

# 图片的读取
img = imageio.imread("./Lenna.jpg")

# 使用Image进行读取
# img = Image.open("./Lenna.jpg")
# image = np.array(img)
# ia.imshow(image)

# 可视化图片
ia.imshow(img)

# imgaug包含了许多从Augmenter继承的数据增强的操作。在这里我们以Affine为例子。
from imgaug import augmenters as iaa

# 设置随机数种子
ia.seed(4)

# 实例化方法
rotate = iaa.Affine(rotate=(-4,45))
img_aug = rotate(image=img)
ia.imshow(img_aug)

对一张图片做多种数据增强处理：利用imgaug.augmenters.Sequential()来构造我们数据增强的pipline，该方法与torchvison.transforms.Compose()相类似

iaa.Sequential(children=None, # Augmenter集合
               random_order=False, # 是否对每个batch使用不同顺序的Augmenter list
               name=None,
               deterministic=False,
               random_state=None)
# 构建处理序列
aug_seq = iaa.Sequential([
    iaa.Affine(rotate=(-25,25)),
    iaa.AdditiveGaussianNoise(scale=(10,60)),
    iaa.Crop(percent=(0,0.2))
])
# 对图片进行处理，image不可以省略，也不能写成images
image_aug = aug_seq(image=img)
ia.imshow(image_aug)

2-对批次图片处理：需要处理更多份的图像数据。此时，可以将图形数据按照NHWC的形式或者由列表组成的HWC的形式对批量的图像进行处理。主要分为以下两部分，对批次的图片以同一种方式处理和对批次的图片进行分部分处理。
对批次的图片以同一种方式处理：将待处理的图片放在一个list中，并将image改为image即可进行数据增强操作。

images = [img,img,img,img,]
images_aug = rotate(images=images)
ia.imshow(np.hstack(images_aug))

仅对图片进行了仿射变换，同样的，我们也可以对批次的图片使用多种增强方法，与单张图片的方法类似，我们同样需要借助Sequential来构造数据增强的pipline。

aug_seq = iaa.Sequential([
    iaa.Affine(rotate=(-25, 25)),
    iaa.AdditiveGaussianNoise(scale=(10, 60)),
    iaa.Crop(percent=(0, 0.2))
])

# 传入时需要指明是images参数
images_aug = aug_seq.augment_images(images = images)
#images_aug = aug_seq(images = images) 
ia.imshow(np.hstack(images_aug))

对批次的图片分部分处理：
imgaug相较于其他的数据增强的库，有一个很有意思的特性，即就是我们可以通过imgaug.augmenters.Sometimes()对batch中的一部分图片应用一部分Augmenters,剩下的图片应用另外的Augmenters。

iaa.Sometimes(p=0.5,  # 代表划分比例
              then_list=None,  # Augmenter集合。p概率的图片进行变换的Augmenters。
              else_list=None,  #1-p概率的图片会被进行变换的Augmenters。注意变换的图片应用的Augmenter只能是then_list或者else_list中的一个。
              name=None,
              deterministic=False,
              random_state=None)

对不同大小的图片进行处理：

# 构建pipline
seq = iaa.Sequential([
    iaa.CropAndPad(percent=(-0.2, 0.2), pad_mode="edge"),  # crop and pad images
    iaa.AddToHueAndSaturation((-60, 60)),  # change their color
    iaa.ElasticTransformation(alpha=90, sigma=9),  # water-like effect
    iaa.Cutout()  # replace one squared area within the image by a constant intensity value
], random_order=True)

# 加载不同大小的图片
images_different_sizes = [
    imageio.imread("https://upload.wikimedia.org/wikipedia/commons/e/ed/BRACHYLAGUS_IDAHOENSIS.jpg"),
    imageio.imread("https://upload.wikimedia.org/wikipedia/commons/c/c9/Southern_swamp_rabbit_baby.jpg"),
    imageio.imread("https://upload.wikimedia.org/wikipedia/commons/9/9f/Lower_Keys_marsh_rabbit.jpg")
]

# 对图片进行增强
images_aug = seq(images=images_different_sizes)

# 可视化结果
print("Image 0 (input shape: %s, output shape: %s)" % (images_different_sizes[0].shape, images_aug[0].shape))
ia.imshow(np.hstack([images_different_sizes[0], images_aug[0]]))

print("Image 1 (input shape: %s, output shape: %s)" % (images_different_sizes[1].shape, images_aug[1].shape))
ia.imshow(np.hstack([images_different_sizes[1], images_aug[1]]))

print("Image 2 (input shape: %s, output shape: %s)" % (images_different_sizes[2].shape, images_aug[2].shape))
ia.imshow(np.hstack([images_different_sizes[2], images_aug[2]]))

1.6使用argparse进行调参

为了更方便的修改超参数，有一个库或者函数可以解析我们输入的命令行参数再传入模型的超参数中。这个就是 Python 标准库的一部分：Argparse。

argparse的使用：
1，创建ArgumentParser()对象
2，调用add_argument()方法添加参数
3，使用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后，我们就必须传入该参数，否则就会报错。

链接：
https://geek-docs.com/python/python-tutorial/python-argparse.html
https://docs.python.org/3/library/argparse.html

1.7pytorch项目实战-基于U-Net模型的模型训练实践

请参考下篇文章：基于U-Net模型的模型训练实践（待填坑！）

本文主要参考DataWhale-深入浅出pytorch课程学习。