目录
1. 指定GPU编号
2. 查看模型每层的输出情况
3. 梯度裁剪
4. 扩展单张图片的维度
5. 独热编码
6. 防止验证模型时爆显存
7. 学习率衰减
8. 冻结某些层的参数
9. 对不同层使用不同的学习率
1. 指定GPU编号
- 方式1
设置当前使用的GPU为0号设备：
os.environ["CUDA_VISIBLE_DEVICES"] = "0"设置当前使用的GPU为0,1,2,3号设备：
os.environ["CUDA_VISIBLE_DEVICES"] = "0,1,2,3"根据顺序表示优先使用0号设备,然后再使用1，2，3号设备。
指定GPU的命令放在.py文件的头部，神经网络相关的一系列操作的前面。
- 方式2
可以在命令行运行程序的时候指定：
CUDA_VISIBLE_DEVICES = 0,1,2,3 python train.pyCUDA_VISIBLE_DEVICES=0,3,5 nohup python -u train.py > zdz.log 2>&1 & #后台运行 并输出日志查看GPU使用状态：
nvidia-smi关于Python程序后台运行输出日志更详细的内容，可以查看我的另一篇博客
2. 查看模型每层的输出情况
Keras有一个简洁的API来查看模型的每一层输出尺寸，这在调试网络时非常有用。现在在PyTorch中也可以实现这个功能。
from torchsummary import summary
summary(my_model,input_size=(channel,height,width) #不包含batch_sizeinput_size根据自己模型的输入大小来设置。
例如：
#!pip install torchsummary
import torch
import torch.nn as nn
import torch.nn.functional as F
from torchsummary import summary
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
self.conv2_drop = nn.Dropout2d()
self.fc1 = nn.Linear(320, 50)
self.fc2 = nn.Linear(50, 10)
def forward(self, x):
x = F.relu(F.max_pool2d(self.conv1(x), 2))
x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
x = x.view(-1, 320)
x = F.relu(self.fc1(x))
x = F.dropout(x, training=self.training)
x = self.fc2(x)
return F.log_softmax(x, dim=1)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # PyTorch v0.4.0
model = Net().to(device)
summary(model, (1, 28, 28)) #（channel, height,width）不包含batch_size
import torch
from torchvision import models
from torchsummary import summary
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
vgg = models.vgg16().to(device)
summary(vgg, (3, 224, 224))
#多输入
import torch
import torch.nn as nn
from torchsummary import summary
class SimpleConv(nn.Module):
def __init__(self):
super(SimpleConv, self).__init__()
self.features = nn.Sequential(
nn.Conv2d(1, 1, kernel_size=3, stride=1, padding=1),
nn.ReLU(),
)
def forward(self, x, y):
x1 = self.features(x)
x2 = self.features(y)
return x1, x2
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = SimpleConv().to(device)
summary(model, [(1, 16, 16), (1, 28, 28)])
3. 梯度裁剪
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
具体过程：把模型所有的参数拉伸为一个大的向量，计算这个向量的范数，max_norm比上计算的向量范数，如果大于等于1，不进行梯度裁剪，使用原来计算的梯度更新参数；小于1时，让这个比值乘以原来计算的梯度，进行裁剪，再用裁剪后的参数梯度更新参数。
梯度裁剪在某些任务上会额外消耗大量的计算时间，一般在RNN中比较常用。防止梯度爆炸。
4. 扩展单张图片的维度
因为在训练时的数据维度一般都是 (batch_size, c, h, w)，而在测试时只输入一张图片，所以需要扩展维度，扩展维度有多个方法：
- 方法1
import cv2
import torch
image = cv2.imread(img_path)
image = torch.tensor(image)
print(image.size())
img = image.view(1, *image.size()) #可变长度参数 *+列表或元组
#img = image.view(1,image.size()[0],image.size()[1],image.size()[2])
#img = image.view(1,image.size(0),image.size(1),image.size(2))
#也可以使用shape
print(img.size())
# output:
# torch.Size([h, w, c])
# torch.Size([1, h, w, c])- 方法2
import cv2
import numpy as np
image = cv2.imread(img_path)
print(image.shape)
img = image[np.newaxis, :, :, :]
print(img.shape)
# output:
# (h, w, c)
# (1, h, w, c)- 方法3
import cv2
import torch
image = cv2.imread(img_path)
image = torch.tensor(image)
print(image.size())
img = image.unsqueeze(dim=0) #在第0维加一个size=1的轴
print(img.size())
img = img.squeeze(dim=0)#压缩第0维的size=1的轴
print(img.size())
# output:
# torch.Size([(h, w, c)])
# torch.Size([1, h, w, c])
# torch.Size([h, w, c])tensor.unsqueeze(dim)：扩展维度，dim指定扩展哪个维度。
tensor.squeeze(dim)：去除dim指定的且size为1的维度，维度大于1时，squeeze()不起作用，不指定dim时，去除所有size为1的维度。
5. 独热编码
在PyTorch中使用交叉熵损失函数（内置了softmax激活函数和把label 转换为one-hot形式的函数）的时候会自动把label转化成onehot，所以不用手动转化，而使用MSE需要手动转化成onehot编码。
import torch
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).random_() % class_num # 对随机数取余
print(label)
print(one_hot(label))Pytorch 1.1后，one_hot可以直接用torch.nn.functional.one_hot。
import torch.nn.functional as F
import torch
tensor = torch.arange(0, 5) % 3 # tensor([0, 1, 2, 0, 1])
one_hot = F.one_hot(tensor)
one_hot
F.one_hot会自己检测不同类别个数，生成对应独热编码。我们也可以自己指定类别数：
tensor = torch.arange(0, 5) % 3 # tensor([0, 1, 2, 0, 1])
one_hot = F.one_hot(tensor,num_classes=6)
one_hot
升级 Pytorch (cpu版本)的命令：conda install pytorch torchvision -c pytorch
6. 防止验证模型时爆显存
验证/测试/预测模型时不需要求导，即不需要梯度计算，关闭autograd，可以提高速度，节约内存。如果不关闭可能会爆显存（不关闭autograd的话，前向传播会缓存中间计算结果和参数值，方便反向传播的计算）。
with torch.no_grad():
# 使用model进行预测的代码
passPytorch 训练时无用的临时变量可能会越来越多，导致 out of memory ，可以使用下面语句来清理这些不需要的变量。
torch.cuda.empty_cache()PyTorch的缓存分配器会事先分配一些固定的显存，即使实际上tensors并没有使用完这些显存，这些显存也不能被其他应用使用。这个分配过程由第一次CUDA内存访问触发的。
而 torch.cuda.empty_cache() 的作用就是释放缓存分配器当前持有的且未占用的缓存显存，以便这些显存可以被其他GPU应用程序使用，并且通过 nvidia-smi命令可见。注意使用此命令不会释放tensors占用的显存。
对于不用的数据变量，Pytorch 可以自动进行回收从而释放相应的显存。
更详细的优化可以查看 优化显存使用 和 显存利用问题。
7. 学习率衰减
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()
pass
8. 冻结某些层的参数
在加载预训练模型的时候，我们有时想冻结前面几层，使其参数在训练过程中不发生变化。
我们需要先知道每一层的名字，通过如下代码打印：
net = Network() # 获取自定义网络结构
for name, value in net.named_parameters():
print('name: {0},\t grad: {1}'.format(name, value.requires_grad))
后面的True表示该层的参数可训练，然后我们定义一个要冻结的层的列表：
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'
]net = Network() # 获取网络结构
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)
9. 对不同层使用不同的学习率
我们对模型的不同层使用不同的学习率。
net = Network() # 获取自定义网络结构
for name, value in net.named_parameters():
print('name: {}'.format(name))
# 输出：
# name: cnn.VGG_16.convolution1_1.weight
# name: cnn.VGG_16.convolution1_1.bias
# name: cnn.VGG_16.convolution1_2.weight
# name: cnn.VGG_16.convolution1_2.bias
# name: cnn.VGG_16.convolution2_1.weight
# name: cnn.VGG_16.convolution2_1.bias
# name: cnn.VGG_16.convolution2_2.weight
# name: cnn.VGG_16.convolution2_2.bias对 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, #正则化
)我们将模型划分为两部分，存放到一个列表里，每部分就对应上面的一个字典，在字典里设置不同的学习率。当这两部分有相同的其他参数时，就将该参数放到列表外面作为全局参数，如上面的`weight_decay`（两部分参数使用相同的正则化）。
也可以在列表外设置一个全局学习率，当各部分字典里设置了局部学习率时，就使用该学习率，否则就使用列表外的全局学习率。
