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('./image/cat.jpg')
image = torch.tensor(image)
print(image.size())    # torch.Size([300, 400, 3])

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

# 或者
img2 = image.unsqueeze(dim=0) 
print(img2.size())     # torch.Size([1, 300, 400, 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)

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

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

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

        [[0, 0, 0, 0, 0, 1, 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

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

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

还有其他：torch.optim.lr_scheduler 中提供了基于多种epoch数目调整学习率的方法。

详见这篇博客：https://www.cnblogs.com/douzujun/p/13326362.html#autoid-3-0-0

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)

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.1 pytorch内置的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/