PyTorch经验指南：技巧与陷阱

原文链接：PyTorch经验指南：技巧与陷阱

PyTorch 的构建者表明，PyTorch 的哲学是解决当务之急，也就是说即时构建和运行计算图。目前，PyTorch 也已经借助这种即时运行的概念成为最受欢迎的框架之一，开发者能快速构建模型与验证想法，并通过神经网络交换格式 ONNX 在多个框架之间快速迁移。本文从基本概念开始介绍了 PyTorch 的使用方法、训练经验与技巧，并展示了可能出现的问题与解决方案。
PyTorch 是一种灵活的深度学习框架，它允许通过动态神经网络（例如利用动态控流——如 if 语句或 while 循环的网络）进行自动微分。它还支持 GPU 加速、分布式训练以及各类优化任务，同时还拥有许多更简洁的特性。以下是作者关于如何利用 PyTorch 的一些说明，里面虽然没有包含该库的所有细节或最优方法，但可能会对大家有所帮助。

神经网络是计算图的一个子类。计算图接收输入数据，数据被路由到对数据执行处理的节点，并可能被这些节点转换。在深度学习中，神经网络中的神经元（节点）通常利用参数或可微函数转换数据，这样可以优化参数以通过梯度下降将损失最小化。更广泛地说，函数是随机的，图结构可以是动态的。所以说，虽然神经网络可能非常适合数据流式编程，但PyTorch的API却更关注命令的编程 - 一种编程更常考虑的形式。这令读代代和推断复杂程序变得简单，而无需损耗不必要的性能; PyTorch速度很快，且拥有大量优化，作为终端用户你毫无后顾之忧。< BR >本文其余部分写的是关于所著的Grokking PyTorch的内容，都是基于MINIST官网实例，应该要在学习完官网初学者教程后再查看。为便于阅读，代码以块状形式呈现，并带有注释，因此不会像纯模块化代码一 样被分割成不同的函数或文件。< BR > < BR >

## * Pytorch基础* PyTorch使用一种称之为势在必行/渴望的范式，即每一行代码都要求构建一个图，以定义完整计算图的一个部分。即使完整的计算图还没有构建好，我们也可以地执行这些作为组件的小计算图，这种动态计算图被称为「定义，通过运行」方法。！[ ] （

https://user-gold-cdn.xitu.io/2018/8/29/16584bda8a8e6aa9?w=640&h=360&f=gif&s=54740)

PyTorch 张量

正如 PyTorch 文档所说，如果我们熟悉 NumPy 的数组，那么 Torch 张量的很多操作我们能轻易地掌握。PyTorch 提供了 CPU 张量和 GPU 张量，并且极大地加速了计算的速度。从张量的构建与运行就能体会，相比 TensorFLow，在 PyTorch 中声明张量、初始化张量要简洁地多。例如，使用 torch.Tensor(5, 3) 语句就能随机初始化一个 5×3 的二维张量，因为 PyTorch 是一种动态图，所以它声明和真实赋值是同时进行的。

在PyTorch中，torch.Tensor是一种矩阵，其中每个元素都是单一的数据类型，且该构造函数默认为torch.FloatTensor。以下是具体的张量类型：


除了直接定义维度，一般我们还可以从Python列表或NumPy数组中创建张量。而且根据使用Python列表和元组等数据结构的习惯，我们可以使用相似的索引方式进行取值或赋值.PyTorch同样支持广播（Broadcasting）操作，一般它会隐式地把一个数组的异常维度调整到与另一个算子相匹配的维度，以实现维度兼容。

自动微分模块

TensorFlow，Caffe和CNTK等大多数框架都使用静态计算图，开发者必须建立或定义一个神经网络，并重复使用相同的结构来执行模型训练。改变网络的模式就意味着我们必须从头开始设计并定义相关的模块。但PyTorch使用的技术为自动微分（自动微分）。在这种机制下，系统会有一个记录来记录我们执行的运算，然后再反向计算对应的梯度。这种技术在构建神经网络的过程中十分强大，因为我们可以通过计算前向传播过程中参数的微分来节省时间。从概念上来说，Autograd会维护一个图并记录对变量执行的所有运算。这会产生一个有向无环图，其中叶结点为输入向量，根结点为输出向量。通过从根结点到叶结点追踪图的路径，我们可以轻易地使用链式法则自动计算梯度。

import argparse
import torch
from torch import nn, optim
from torch.nn import functional as F
从进口torch.utils.data的DataLoader 
从torchvision进口数据集，变换```
除了用于计算机视觉问题的torchvision模块外，这些都是标准化导入。<BR> <BR> ### **设置** ``` parser = argparse.ArgumentParser（ description ='PyTorch MNIST示例'）parser.add_argument（' -  batch-size'，type = int，default = 64，metavar ='N'，help ='输入培训批量大小（默认值：64）'）解析器。 add_argument（' -  epochs'，type = int，default = 10，metavar ='N'，help ='要训练的纪元数（默认值：10）'）parser.add_argument（' -  lr'，type = float ，default = 0.01，metavar ='LR'，help ='学习率（默认值：0.01）'）parser.add_argument（' -  momentum'，type = float，default = 0.5，metavar ='M'，help = 'SGD动量（默认值：0.5）'）parser.add_argument（'--no-cuda'，action ='store_true'，默认= False， help ='禁用CUDA培训'）
parser.add_argument（' -  seed'，type = int，default = 1，metavar ='S'，
help ='random seed（默认值：1）'）
parser.add_argument（' -  save-interval'，type = int，default = 10，metavar ='N'，
help ='在检查点之前要等待多少批次'）
parser.add_argument（' -  resume'，action ='store_true'，default = False，
help ='resume training from checkpoint'）
args = parser.parse_args（）use_cuda = torch.cuda.is_available（）而不是args.no_cuda device = torch.device（'cuda'if use_cuda else'cpu'）torch.manual_seed（args.seed）if use_cuda ：torch.cuda.manual_seed（args.seed）

argparse是在Python的中处理命令行参数的一种标准方式。

编写与设备无关的代码（可用时受益于GPU加速，不可用时会倒退回CPU）时，选择并保存适当的torch.device，不失为一种好方法，它可用于确定存储张量的位置。关于与设备无关代码的更多内容请参阅官网文件.PyTorch的方法是使用户能控制设备，这对简单示例来说有些麻烦，但是可以更容易地找出张量所在的位置 - 这对于a）调试很有用，并且b）可有效地使用手动化设备。对于可重复实验，有必要为使用随机数生成的任何数据设置随机种子（如果也使用随机数，则包括随机或numpy）。要注意，cuDNN用的是非确定算法，可以通过语句torch.backends.cudnn.enabled = False将其禁用。

 transforms.ToTensor(),
 transforms.Normalize((0.1307,), (0.3081,))]))
test_data = datasets.MNIST('data', train=False, transform=transforms.Compose([
 transforms.ToTensor(),
 transforms.Normalize((0.1307,), (0.3081,))]))

train_loader = DataLoader(train_data, batch_size=args.batch_size,
 shuffle=True, num_workers=4, pin_memory=True)
test_loader = DataLoader(test_data, batch_size=args.batch_size,
 num_workers=4, pin_memory=True)

torchvision.transforms对于单张图像有非常多便利的转换工具，例如裁剪和归一化等.DataLoader

包含非常多的参数，除了batch_size和shuffle，num_workers和pin_memory对于高效加载数据同样非常重要。例如配置num_workers> 0将使用子进程异步加载数据，而不是使用一个主进程块加载数据。参数pin_memory使用固定RAM以加速RAM到GPU的转换，且仅仅使用CPU时不会做任何运算。

模型

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 = self.fc2(x)
 return F.log_softmax(x, dim=1)

model = Net().to(device)
optimiser = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum)

if args.resume:
 model.load_state_dict(torch.load('model.pth'))
 optimiser.load_state_dict(torch.load('optimiser.pth'))

神经网络初始化一般包括变量，包含可训练参数的层级，可能的可训练参数和不可训练的缓存器。随后前向传播将这些初始化参数与F中的函数结合，其中该函数为不包含参数的纯函数。有些开发者喜欢使用完全函数化的网络（如保持所有参数**，使用F.conv2d而不是nn.Conv2d），或者完全由layers函数构成的网络（如使用nn.ReLU而不是F.relu ）。

在将设备设置为GPU时，.to（设备）是一种将设备参数（和缓存器）发送到GPU的便捷方式，且在将设备设置为CPU时不会做任何处理。在将网络参数传递给优化器之前，把它们传递给适当的设备非常重要，不然的话优化器不能正确地追踪参数。神经网络（nn.Module）和优化器（optim.Optimizer）都能保存和加载它们的内部状态，而.load_state_dict（state_dict）是完成这一操作的推荐方法，我们可以从以前保存的状态字典中加载两者的状态并恢复训练。此外，保存整个对象可能会出错。这里没讨论的一些注意事项即前向传播可以使用控制流，例如一个成员变量或数据本身能决定if语句的执行。此外，在前向传播的过程中打印张量也是可行的，这令调试加加简单。最后，前向传播可以使用多个参数以下使用间断的代码块展示这一点：

def forward(self, x, hx, drop=False):
 hx2 = self.rnn(x, hx)
 print(hx.mean().item(), hx.var().item())
 if hx.max.item() > 10 or self.can_drop and drop:
 return hx
 else:
 return hx2

训练

model.train()
train_losses = []

for i, (data, target) in enumerate(train_loader):
 data, target = data.to(device), target.to(device)
 optimiser.zero_grad()
 output = model(data)
 loss = F.nll_loss(output, target)
 loss.backward()
 train_losses.append(loss.item())
 optimiser.step()

 if i % 10 == 0:
 print(i, loss.item())
 torch.save(model.state_dict(), 'model.pth')
 torch.save(optimiser.state_dict(), 'optimiser.pth')
 torch.save(train_losses, 'train_losses.pth')

网络模块默认设置为训练模式，这影响了某些模块的工作方式，最明显的是 dropout 和批归一化。最好用.train() 对其进行手动设置，这样可以把训练标记向下传播到所有子模块。在使用 loss.backward() 收集一系列新的梯度以及用 optimiser.step() 做反向传播之前，有必要手动地将由 optimiser.zero_grad() 优化的参数梯度归零。默认情况下，PyTorch 会累加梯度，在单次迭代中没有足够资源来计算所有需要的梯度时，这种做法非常便利。

PyTorch 使用一种基于 tape 的自动化梯度（autograd）系统，它收集按顺序在张量上执行的运算，然后反向重放它们来执行反向模式微分。这正是为什么 PyTorch 如此灵活并允许执行任意计算图的原因。如果没有张量需要做梯度更新（当你需要为该过程构建一个张量时，你必须设置 requires_grad=True），则不需要保存任何图。然而，网络倾向于包含需要梯度更新的参数，因此任何网络输出过程中执行的计算都将保存在图中。因此如果想保存在该过程中得到的数据，你将需要手动禁止梯度更新，或者，更常见的做法是将其保存为一个 Python 数（通过一个 Python 标量上的.item()）或者 NumPy 数组。更多关于 autograd 的细节详见官网文件。

截取计算图的一种方式是使用.detach()，当通过沿时间的截断反向传播训练 RNN 时，数据流传递到一个隐藏状态可能会应用这个函数。当对损失函数求微分（其中一个成分是另一个网络的输出）时，也会很方便。但另一个网络不应该用「loss - examples」的模式进行优化，包括在 GAN 训练中从生成器的输出训练判别器，或使用价值函数作为基线（例如 A2C）训练 actor-critic 算法的策略。另一种在 GAN 训练（从判别器训练生成器）中能高效阻止梯度计算的方法是在整个网络参数上建立循环，并设置 param.requires_grad=False，这在微调中也很常用。

除了在控制台/日志文件里记录结果以外，检查模型参数（以及优化器状态）也是很重要的。你还可以使用 torch.save() 来保存一般的 Python 对象，但其它标准选择还包括内建的 pickle。

测试

test_loss, correct = 0, 0

with torch.no_grad():
 for data, target in test_loader:
 data, target = data.to(device), target.to(device)
 output = model(data)
 test_loss += F.nll_loss(output, target, size_average=False).item()
 pred = output.argmax(1, keepdim=True)
 correct += pred.eq(target.view_as(pred)).sum().item()

test_loss /= len(test_data)
acc = correct / len(test_data)
print(acc, test_loss)

为了早点响应.train（），应利用.eval（）将网络明确地设置为评估模式。

正如前文所述，计算图通常会在使用网络时生成。通过与torch.no_grad（）使用no_grad上下文管理器，可以防止这种情况发生。

LAUNCH _ BLOCKING = 1将使CUDA内核同步启动，从而提供更详细的错误信息.torch.multiprocessing，甚至只是一次运行多个PyTorch脚本的注意事项。因为PyTorch使用多线程BLAS库来加速CPU上的线性代数计算，所以它通常需要使用多个内核。如果你想一次运行多个任务，在具有多进程或多个脚本的情况下，通过将环境变量OMP _ NUM _ THREADS设置为1或另一个较小的数字来手动减少线程，这样做减少了CPU thrashing的可能性。官网文件还有一些其它注意事项，尤其是关于多进程。