Pytorch trick集锦

1.查看模型每层输出详情

from torchsummary import summary
summary(your_model, input_size=(channels, H, W))

input_size是根据你自己的网络模型的输入尺寸进行设置。

2.梯度裁剪

import torch.nn as nn

outputs = model(data)
loss= loss_fn(outputs, target)
optimizer.zero_grad()
loss.backward()
nn.utils.clip_grad_norm_(model.parameters(), max_norm=20, norm_type=2)
optimizer.step()

nn.utils.clip_grad_norm_的参数：

• parameters – 一个基于变量的迭代器，会进行梯度归一化
• max_norm – 梯度的最大范数
• norm_type – 规定范数的类型，默认为L2

3.扩展单张图片维度

因为在训练时的数据维度一般都是 (batch_size, c, h, w)，而在测试时只输入一张图片，所以需要扩展维度，扩展维度有多个方法：

import cv2
import torch

image = cv2.imread('1.png')
image = torch.tensor(image)
print(image.size())                     #torch.Size([296, 790, 3])

img1 = image.view(1, *image.size())
print(img1.size())                      #torch.Size([1, 296, 790, 3])

#或者
img2 = image.unsqueeze(dim=0)  
print(img2.size())                      #torch.Size([1, 296, 790, 3])

4.独热编码

在PyTorch中使用交叉熵损失函数的时候会自动把label转化成onehot，所以不用手动转化，而使用MSE需要手动转化成onehot编码。

import torch
import torch.nn.functional as F

class_num = 8
batch_size = 4

def one_hot(label):
    """
    将一维列表转换为独热编码
    """
    label = label.resize_(batch_size, 1)
    m_zeros = torch.zeros(batch_size, class_num)
    # 从 value 中取值，然后根据 dim 和 index 给相应位置赋值
    onehot = m_zeros.scatter_(1, label, 1)       # (dim,index,value)

    return onehot.numpy()  # Tensor -> Numpy

label = torch.LongTensor(batch_size) % class_num  # 对随机数取余
print(label)
print(one_hot(label))

#或者
encode = F.one_hot(label, num_classes = class_num)
print(encode)

Tip：使用F.onehot函数时第一个参数是tensor类型

运行结果：

tensor([5, 3, 3, 2])
[[0. 0. 0. 0. 0. 1. 0. 0.]
 [0. 0. 0. 1. 0. 0. 0. 0.]
 [0. 0. 0. 1. 0. 0. 0. 0.]
 [0. 0. 1. 0. 0. 0. 0. 0.]]
tensor([[[0, 0, 0, 0, 0, 1, 0, 0]],

        [[0, 0, 0, 1, 0, 0, 0, 0]],

        [[0, 0, 0, 1, 0, 0, 0, 0]],

        [[0, 0, 1, 0, 0, 0, 0, 0]]])

Tip：torch.nn.functional.one_hot函数返回的是Tensor类型

5.防止验证模型时爆显存

验证模型时不需要求导，即不需要梯度计算，关闭autograd，可以提高速度，节约内存。

with torch.no_grad():
    # 使用model进行预测的代码
    pass

6.学习率衰减

import torch.optim as optim
from torch.optim import lr_scheduler

# 训练前的初始化
optimizer = optim.Adam(net.parameters(), lr=0.001)
scheduler = lr_scheduler.StepLR(optimizer, 10, 0.1)       # 每过10个epoch，学习率乘以0.1

# 训练过程中
for n in n_epoch:
    scheduler.step()
    ...

可以随时查看学习率的值：optimizer.param_groups[0]['lr']

还有其他：torch.optim.lr_scheduler 中提供了基于多种epoch数目调整学习率的方法。详见之前的博客：https://www.cnblogs.com/cxq1126/p/13289364.html#_label3

7.冻结某些层的参数，使其参数在训练过程中不发生变化

首先知道每一层的名字，这几层的grad都是True。

net = Network()                    # 获取自定义网络结构
for name, value in net.named_parameters():
    print('name: {0},\t grad: {1}'.format(name, value.requires_grad))

定义一个要冻结的层列表：

no_grad = [
    'cnn.VGG_16.convolution1_1.weight',
    'cnn.VGG_16.convolution1_1.bias',
    'cnn.VGG_16.convolution1_2.weight',
    'cnn.VGG_16.convolution1_2.bias'
]

冻结方法如下：

for name, value in net.named_parameters():
    if name in no_grad:
        value.requires_grad = False
    else:
        value.requires_grad = True

前两层的weight和bias的requires_grad都为False，表示它们不可训练。最后在定义优化器时，只对requires_grad为True的层的参数进行更新。

optimizer = optim.Adam(filter(lambda p: p.requires_grad, net.parameters()), lr=0.01)

使用情况，比如模型A的forward里面使用了已经训练好的模型B，模型A训练时不希望训练模型B，则可将模型B的参数冻结。

8.对不同层使用不同学习率

net = Network()  # 获取自定义网络结构
for name, value in net.named_parameters():
    print('name: {}'.format(name))

#对 convolution1 和 convolution2 设置不同的学习率，首先将它们分开，即放到不同的列表里
conv1_params = []
conv2_params = []

for name, parms in net.named_parameters():
    if "convolution1" in name:
        conv1_params += [parms]
    else:
        conv2_params += [parms]

# 然后在优化器中进行如下操作：
optimizer = optim.Adam(
    [
        {"params": conv1_params, 'lr': 0.01},
        {"params": conv2_params, 'lr': 0.001},
    ],
    weight_decay=1e-3,
)

9.网络参数初始化

9.1pytorch内置的torch.nn.init方法。常用的初始化操作，例如正态分布、均匀分布、xavier初始化、kaiming初始化等都已经实现，可以直接使用。

init.xavier_uniform(net1[0].weight)

9.2自定义方法

for layer in net1.modules():
    if isinstance(layer, nn.Linear): # 判断是否是线性层
        param_shape = layer.weight.shape
        layer.weight.data = torch.from_numpy(np.random.normal(0, 0.5, size=param_shape)) 
        # 定义为均值为 0，方差为 0.5 的正态分布

10.加载内置预训练模型

torchvision.models模块的子模块中包含以下模型：

• AlexNet
• VGG
• ResNet
• SqueezeNet
• DenseNet

导入模型方法：

import torchvision.models as models
resnet18 = models.resnet18(pretrained=True)
alexnet = models.alexnet(pretrained=True)
vgg16 = models.vgg16(pretrained=True)

Tip：参数为pretrained，默认为False，表示只导入模型的结构，其中的权重是随机初始化的。如果pretrained 为 True，表示导入的是在ImageNet数据集上预训练的模型。

其他Pytorch模型：https://zhuanlan.zhihu.com/p/73893187

https://pytorch-cn.readthedocs.io/zh/latest/torchvision/torchvision-models/