部分参考：z.defying https://zhuanlan.zhihu.com/p/76459295
贡献地址：https://github.com/zxdefying/pytorch_tricks
1.numpy array 转 torch tensor：
troch.from_numpy() 共享内存，但是不能resize
torch.tensor(array) 重新创建
- device
torch.tensor(device = device)
torch.tensor().to(device)此种方式会阻断梯度的传播
3.梯度清零
model.zero_grad()
optimizer.zero_grad()#当optimizer=optim.Optimizer(model.parameters())时，两者等效
Variable.grad.data.zero_() #某一变量梯度清空
- dataloader类
它需要实现的最基本的方法是： init(self)：它采取任何参数需要建立一个元组列表-它可能是一个名称的CSV文件，将加载和处理;它可以是两个张量，一个代表特征，另一个代表标签;或者其他的，取决于手头的任务。
不需要在构造函数方法中加载整个数据集。如果数据集很大(例如，成千上万的图像文件)，立即加载它将是内存效率不高的。建议按需加载它们(无论何时调用了get_item_)。
get_item_(self, index):它允许数据集被索引，因此它可以像列表一样工作(dataset)——它必须返回与请求的数据点对应的元组(特性，标签)。我们可以返回预先加载的数据集或张量的相应切片，或者，如前所述，按需加载它们(如本例中所示)。
len(self):它应该简单地返回整个数据集的大小，这样，无论什么时候采样它，它的索引都被限制在实际大小。
from torch.utils.data import Dataset, TensorDataset
class CustomDataset(Dataset):
def __init__(self, x_tensor, y_tensor):
self.x = x_tensor
self.y = y_tensor
def __getitem__(self, index):
return (self.x[index], self.y[index])
def __len__(self):
return len(self.x)
# Wait, is this a CPU tensor now? Why? Where is .to(device)?
x_train_tensor = torch.from_numpy(x_train).float()
y_train_tensor = torch.from_numpy(y_train).float()
train_data = CustomDataset(x_train_tensor, y_train_tensor)
print(train_data[0])
train_data = TensorDataset(x_train_tensor, y_train_tensor)
print(train_data[0])
from torch.utils.data import DataLoader
#iterator
train_loader = DataLoader(dataset=train_data, batch_size=16, shuffle=True)
next(iter(train_loader))
# split
from torch.utils.data.dataset import random_split
dataset = TensorDataset(x_tensor, y_tensor)
train_dataset, val_dataset = random_split(dataset, [80, 20])
train_loader = DataLoader(dataset=train_dataset, batch_size=16)
val_loader = DataLoader(dataset=val_dataset, batch_size=20)
5.评估
torch.no_grad() 停止了梯度更新，model.eval()调整到了eval模式（dropout等操作会有相应调整）
with c:
for x_val, y_val in val_loader:
x_val = x_val.to(device)
y_val = y_val.to(device)
model.eval()
yhat = model(x_val)
val_loss = loss_fn(y_val, yhat)
val_losses.append(val_loss.item())
6.clone()函数： 会回传梯度，但在原先的变量上；之后的变量不再有梯度
7.调整学习率的方法：http://www.spytensor.com/index.php/archives/32/
pytorch_tricks
目录：
- 指定GPU编号
- 查看模型每层输出详情
- 梯度裁剪
- 扩展单张图片维度
- 独热编码
- 防止验证模型时爆显存
- 学习率衰减
- 冻结某些层的参数
- 对不同层使用不同学习率
- 模型相关操作
- Pytorch内置one hot函数
- 网络参数初始化
- 动态更新dataloader
1、指定GPU编号
- 设置当前使用的GPU设备仅为0号设备，设备名称为
/gpu:0：os.environ["CUDA_VISIBLE_DEVICES"] = "0" - 设置当前使用的GPU设备为0,1号两个设备，名称依次为
/gpu:0、/gpu:1：os.environ["CUDA_VISIBLE_DEVICES"] = "0,1"，根据顺序表示优先使用0号设备,然后使用1号设备。
指定GPU的命令需要放在和神经网络相关的一系列操作的前面。
2、查看模型每层输出详情
Keras有一个简洁的API来查看模型的每一层输出尺寸，这在调试网络时非常有用。现在在PyTorch中也可以实现这个功能。
使用很简单，如下用法：
from torchsummary import summary
summary(your_model, input_size=(channels, H, W))
input_size 是根据你自己的网络模型的输入尺寸进行设置。
pytorch-summary
3、梯度裁剪（Gradient Clipping）
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
知乎用户 不椭的椭圆 提出：梯度裁剪在某些任务上会额外消耗大量的计算时间，可移步评论区查看详情。
4、扩展单张图片维度
因为在训练时的数据维度一般都是 (batch_size, c, h, w)，而在测试时只输入一张图片，所以需要扩展维度，扩展维度有多个方法：
import cv2
import torch
image = cv2.imread(img_path)
image = torch.tensor(image)
print(image.size())
img = image.view(1, *image.size())
print(img.size())
# output:
# torch.Size([h, w, c])
# torch.Size([1, h, w, c])
或
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)
或（感谢知乎用户 coldleaf 的补充）
import cv2
import torch
image = cv2.imread(img_path)
image = torch.tensor(image)
print(image.size())
img = image.unsqueeze(dim=0)
print(img.size())
img = img.squeeze(dim=0)
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中使用交叉熵损失函数的时候会自动把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(one_hot(label))
# output:
[[0. 0. 0. 1. 0. 0. 0. 0.]
[0. 0. 0. 0. 1. 0. 0. 0.]
[0. 0. 1. 0. 0. 0. 0. 0.]
[0. 1. 0. 0. 0. 0. 0. 0.]]
Convert int into one-hot format
注：第11条有更简单的方法。
6、防止验证模型时爆显存
验证模型时不需要求导，即不需要梯度计算，关闭autograd，可以提高速度，节约内存。如果不关闭可能会爆显存。
with torch.no_grad():
# 使用model进行预测的代码
pass
感谢知乎用户zhaz 的提醒，我把 torch.cuda.empty_cache() 的使用原因更新一下。
这是原回答：
Pytorch 训练时无用的临时变量可能会越来越多，导致
out of memory，可以使用下面语句来清理这些不需要的变量。
官网 上的解释为：
Releases all unoccupied cached memory currently held by the caching allocator so that those can be used in other GPU application and visible innvidia-smi.
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)
# 训练过程中
for n in n_epoch:
scheduler.step()
...
关键语句为lr_scheduler.StepLR(optimizer, 10, 0.1)，表示每过10个epoch，学习率乘以0.1。
8、冻结某些层的参数
参考：Pytorch 冻结预训练模型的某一层
在加载预训练模型的时候，我们有时想冻结前面几层，使其参数在训练过程中不发生变化。
我们需要先知道每一层的名字，通过如下代码打印：
net = Network() # 获取自定义网络结构
for name, value in net.named_parameters():
print('name: {0},\t grad: {1}'.format(name, value.requires_grad))
假设前几层信息如下：
name: cnn.VGG_16.convolution1_1.weight, grad: True
name: cnn.VGG_16.convolution1_1.bias, grad: True
name: cnn.VGG_16.convolution1_2.weight, grad: True
name: cnn.VGG_16.convolution1_2.bias, grad: True
name: cnn.VGG_16.convolution2_1.weight, grad: True
name: cnn.VGG_16.convolution2_1.bias, grad: True
name: cnn.VGG_16.convolution2_2.weight, grad: True
name: cnn.VGG_16.convolution2_2.bias, grad: True
后面的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 = Net.CTPN() # 获取网络结构
for name, value in net.named_parameters():
if name in no_grad:
value.requires_grad = False
else:
value.requires_grad = True
冻结后我们再打印每层的信息：
name: cnn.VGG_16.convolution1_1.weight, grad: False
name: cnn.VGG_16.convolution1_1.bias, grad: False
name: cnn.VGG_16.convolution1_2.weight, grad: False
name: cnn.VGG_16.convolution1_2.bias, grad: False
name: cnn.VGG_16.convolution2_1.weight, grad: True
name: cnn.VGG_16.convolution2_1.bias, grad: True
name: cnn.VGG_16.convolution2_2.weight, grad: True
name: cnn.VGG_16.convolution2_2.bias, 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。
也可以在列表外设置一个全局学习率，当各部分字典里设置了局部学习率时，就使用该学习率，否则就使用列表外的全局学习率。
10、模型相关操作
这个内容比较多，我就写成了一篇文章。
PyTorch 中模型的使用
11、Pytorch内置one_hot函数
感谢 yangyangyang 补充：Pytorch 1.1后，one_hot可以直接用 torch.nn.functional.one_hot。
然后我将Pytorch升级到1.2版本，试用了下 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)
# 输出：
# tensor([[1, 0, 0],
# [0, 1, 0],
# [0, 0, 1],
# [1, 0, 0],
# [0, 1, 0]])
F.one_hot 会自己检测不同类别个数，生成对应独热编码。我们也可以自己指定类别数：
tensor = torch.arange(0, 5) % 3 # tensor([0, 1, 2, 0, 1])
one_hot = F.one_hot(tensor, num_classes=5)
# 输出：
# tensor([[1, 0, 0, 0, 0],
# [0, 1, 0, 0, 0],
# [0, 0, 1, 0, 0],
# [1, 0, 0, 0, 0],
# [0, 1, 0, 0, 0]])
升级 Pytorch (cpu版本)的命令：conda install pytorch torchvision -c pytorch
（希望Pytorch升级不会影响项目代码）
12、网络参数初始化
神经网络的初始化是训练流程的重要基础环节，会对模型的性能、收敛性、收敛速度等产生重要的影响。
以下介绍两种常用的初始化操作。
(1) 使用pytorch内置的torch.nn.init方法。
常用的初始化操作，例如正态分布、均匀分布、xavier初始化、kaiming初始化等都已经实现，可以直接使用。
具体详见PyTorch 中 torch.nn.init 中文文档。
init.xavier_uniform(net1[0].weight)
(2) 对于一些更加灵活的初始化方法，可以借助numpy。
对于自定义的初始化方法，有时tensor的功能不如numpy强大灵活，故可以借助numpy实现初始化方法，再转换
到tensor上使用。
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 的正态分布
13 动态更新dataloader
https://zhuanlan.zhihu.com/p/115171078?utm_source=wechat_session&utm_medium=social&utm_oi=605509389998886912