这9个用Pytorch训练快速神经网络的技巧，学到就是赚到

Pytorch-Lighting

Lightning是基于Pytorch的一个光包装器，它可以帮助研究人员自动训练模型，但关键的模型部件还是由研究人员完全控制。

DataLoader中的进程数

加快速度的第二个秘诀在于允许批量并行加载。所以，你可以一次加载许多批量，而不是一次加载一个。
# slow
loader = DataLoader(dataset, batch_size=32, shuffle=True)
# fast (use 10 workers)
loader = DataLoader(dataset, batch_size=32, shuffle=True, num_workers=10)

Batch size 批量大小

在开始下一步优化步骤之前，将批量大小调高到CPU内存或GPU内存允许的最大值。
接下来的部分将着重于减少内存占用，这样就可以继续增加批尺寸。记住，你很可能需要再次更新学习率。如果将批尺寸增加一倍，最好将学习速度也提高一倍。

累积梯度

假如已经最大限度地使用了计算资源，而批尺寸仍然太低(假设为8)，那我们则需为梯度下降模拟更大的批尺寸，以供精准估计。
假设想让批尺寸达到128。然后，在执行单个优化器步骤前，将执行16次前向和后向传播（批量大小为8）。

个人理解为，可以在显存不足的情况下模拟大批量大小。

clear last step
optimizer.zero_grad()
# 16 accumulated gradient steps
scaled_loss = 0
for accumulated_step_i in range(16):
out = model.forward()
loss = some_loss(out,y)
loss.backward()
scaled_loss += loss.item()
# update weights after 8 steps. effective batch = 8*16
optimizer.step()
# loss is now scaled up by the number of accumulated batches
actual_loss = scaled_loss / 16
而在Lightning中，这些已经自动执行了。
trainer = Trainer(accumulate_grad_batches=16)
trainer.fit(model)

保留计算图

撑爆内存很简单，只要不释放指向计算图形的指针，比如……为记录日志保存loss。
losses = []
…
losses.append(loss)
print(f’current loss: {torch.mean(losses)’})
上述的问题在于，loss仍然有一个图形副本。在这种情况中，可用.item()来释放它。
# bad
losses.append(loss)
# good
losses.append(loss.item())
Lightning会特别注意，让其无法保留图形副本

单GPU训练

一旦完成了前面的步骤，就可以进入GPU训练了。GPU的训练将对许多GPU核心上的数学计算进行并行处理。能加速多少取决于使用的GPU类型
刚开始你可能会觉得压力很大，但其实只需做两件事: 1)将你的模型移动到GPU上，2)在用其运行数据时，把数据导至GPU中。
# put model on GPU
model.cuda(0)
# put data on gpu (cuda on a variable returns a cuda copy)
x = x.cuda(0)
# runs on GPU now
model(x)
如果使用Lightning，则不需要对代码做任何操作。只需设置标记：
# ask lightning to use gpu 0 for training
trainer = Trainer(gpus=[0])
trainer.fit(model)
在GPU进行训练时，要注意限制CPU和GPU之间的传输量。
# expensive
x = x.cuda(0)
# very expensive
x = x.cpu()
x = x.cuda(0)
例如，如果耗尽了内存，不要为了省内存，将数据移回CPU。尝试用其他方式优化代码，或者在用这种方法之前先跨GPUs分配代码。
此外还要注意进行强制GPUs同步的操作。例如清除内存缓存。
# really bad idea.Stops all the GPUs until they all catch up
torch.cuda.empty_cache()

多GPU训练

有3种(也许更多?)方式训练多GPU。

  • 分批量训练

A)在每个GPU上复制模型；B)给每个GPU分配一部分批量。
第一种方法叫做分批量训练。这一策略将模型复制到每个GPU上，而每个GPU会分到该批量的一部分。
# copy model on each GPU and give a fourth of the batch to each
model = DataParallel(model, devices=[0, 1, 2 ,3])
# out has 4 outputs (one for each gpu)
out = model(x.cuda(0))

  • 分模型训练

将模型的不同部分分配给不同的GPU，按顺序分配批量
有时模型可能太大，内存不足以支撑。比如，带有编码器和解码器的Sequence to Sequence模型在生成输出时可能会占用20gb的内存。在这种情况下，我们希望把编码器和解码器放在单独的GPU上。
# each model is sooo big we can’t fit both in memory
encoder_rnn.cuda(0)
decoder_rnn.cuda(1)
# run input through encoder on GPU 0
out = encoder_rnn(x.cuda(0))
# run output through decoder on the next GPU
out = decoder_rnn(x.cuda(1))
# normally we want to bring all outputs back to GPU 0
out = out.cuda(0)

上述两种方式使用Lighting能方便实现，详情见文章。

  • 使用多GPUs时需注意的事项

· 如果该设备上已存在model.cuda()，那么它不会完成任何操作。
· 始终输入到设备列表中的第一个设备上。
· 跨设备传输数据非常昂贵，不到万不得已不要这样做。
· 优化器和梯度将存储在GPU 0上。因此，GPU 0使用的内存很可能比其他处理器大得多。使用多GPUs时需注意的事项

多节点GPU训练

每台机器上的各GPU都可获取一份模型的副本。每台机器分得一部分数据，并仅针对该部分数据进行训练。各机器彼此同步梯度。
做到了这一步，就可以在几分钟内训练Imagenet数据集了! 这没有想象中那么难，但需要更多有关计算集群的知识。这些指令假定你正在集群上使用SLURM。
Pytorch在各个GPU上跨节点复制模型并同步梯度，从而实现多节点训练。因此，每个模型都是在各GPU上独立初始化的，本质上是在数据的一个分区上独立训练的，只是它们都接收来自所有模型的梯度更新。

此处节点指的是机器？

Pytorch团队对此有一份详细的实用教程。
然而，在Lightning中，这是一个自带功能。只需设定节点数标志，其余的交给Lightning处理就好。
# train on 1024 gpus across 128 nodes
trainer = Trainer(nb_gpu_nodes=128, gpus=[0, 1, 2, 3, 4, 5, 6, 7])

福利！更快的多GPU单节点训练

貌似就是单机多卡的意思

事实证明，分布式数据并行处理要比数据并行快得多，因为其唯一的通信是梯度同步。因此，最好用分布式数据并行处理替换数据并行，即使只是在做单机训练。
在Lightning中，通过将distributed_backend设置为ddp（分布式数据并行处理）并设置GPU的数量，这可以很容易实现。
# train on 4 gpus on the same machine MUCH faster than DataParallel
trainer = Trainer(distributed_backend=’ddp’, gpus=[0, 1, 2, 3])

有关模型加速的思考和技巧

如何通过寻找瓶颈来思考问题？可以把模型分成几个部分：
首先，确保数据加载中没有瓶颈。为此，可以使用上述的现有数据加载方案，但是如果没有适合你的方案，你可以把离线处理及超高速缓存作为高性能数据储存，就像h5py一样。
接下来看看在训练过程中该怎么做。确保快速转发，避免多余的计算，并将CPU和GPU之间的数据传输最小化。最后，避免降低GPU的速度(在本指南中有介绍)。
接下来，最大化批尺寸，通常来说，GPU的内存大小会限制批量大小。自此看来，这其实就是跨GPU分布，但要最小化延迟，有效使用大批次（例如在数据集中，可能会在多个GPUs上获得8000+的有效批量大小）。
但是需要小心处理大批次。根据具体问题查阅文献，学习一下别人是如何处理的！