9个用Pytorch训练快速神经网络的方法
事实上，你的模型可能还停留在石器时代的水平。估计你还在用32位精度或*gasp（一般活动仿真语言）*训练，甚至可能只在单gpu上训练。如果市面上有99个加速指南，但你可能只看过1个？（没错，就是这样）。但这份终极指南，会一步步教你清除模型中所有的（gp模型）。
不要让你的神经网络变成这样。
这份指南的介绍从简单到复杂，一直介绍到你可以完成的大多数pita修改，以充分利用你的网络。例子中会包括一些pytorch代码和相关标记，可以在 pytorch-lightning训练器中用，以防大家不想自己敲码！
这份指南针对的是谁？ 任何用pytorch研究非琐碎的深度学习模型的人，比如工业研究人员、博士生、学者等等……这些模型可能要花费几天，甚至几周、几个月的时间来训练。
指南（从易到难）
1. 使用dataloader。
2. dataloader中的进程数。
3. 批尺寸。
4. 累积梯度。
5. 保留计算图。
6. 转至单gpu。
7. 16位混合精度训练。
8. 转至多gpu（模型复制）。
9. 转至多gpu节点（8+gpus）。
10. 有关模型加速的思考和技巧
pytorch-lightning
文中讨论的各种优化，都可以在名为pytorch-lightning 的pytorch图书馆中找到。
lightning是基于pytorch的一个光包装器，它可以帮助研究人员自动训练模型，但关键的模型部件还是由研究人员完全控制。
参照此篇教程，获得更有力的范例。
lightning采用最新、最尖端的方法，将犯错的可能性降到最低。
mnist定义的lightning模型，可适用于训练器。
from pytorch-lightning import trainer
model = lightningmodule（…）
trainer = trainer（）
trainer.fit（model）
1. dataloader
这可能是最容易提速的地方。靠保存h5py或numpy文件来加速数据加载的日子已经一去不复返了。用 pytorch dataloader 加载图像数据非常简单。
dataset = mnist（root=self.hparams.data_root， train=train， download=true）
loader = dataloader（dataset， batch_size=32， shuffle=true）
for batch in loader：
x， y = batch
model.training_step（x， y）
...
在lightning中，你无需指定一个训练循环，只需定义dataloaders，训练器便会在 需要时调用它们。
2. dataloaders中的进程数
加快速度的第二个秘诀在于允许批量并行加载。所以，你可以一次加载许多批量，而不是一次加载一个。
# slow
loader = dataloader（dataset， batch_size=32， shuffle=true）
# fast （use 10 workers）
loader = dataloader（dataset， batch_size=32， shuffle=true， num_workers=10）
3. 批量大小（batch size）
在开始下一步优化步骤之前，将批量大小调高到cpu内存或gpu内存允许的最大值。
接下来的部分将着重于减少内存占用，这样就可以继续增加批尺寸。
记住，你很可能需要再次更新学习率。如果将批尺寸增加一倍，最好将学习速度也提高一倍。
4. 累积梯度
假如已经最大限度地使用了计算资源，而批尺寸仍然太低（假设为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）
5. 保留计算图
撑爆内存很简单，只要不释放指向计算图形的指针，比如……为记录日志保存loss。
losses = ［］
...
losses.append（loss）
print（f‘current loss： {torch.mean（losses）’}）
上述的问题在于，loss仍然有一个图形副本。在这种情况中，可用.item（）来释放它。
# bad
losses.append（loss）
# good
losses.append（loss.item（））
lightning会特别注意，让其无法保留图形副本
6. 单gpu训练
一旦完成了前面的步骤，就可以进入gpu训练了。gpu的训练将对许多gpu核心上的数学计算进行并行处理。能加速多少取决于使用的gpu类型。个人使用的话，推荐使用2080ti，公司使用的话可用v100。
刚开始你可能会觉得压力很大，但其实只需做两件事： 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（）
但是如果使用lightning，那么只有在定义lightning模块时可能会出现这种问题。lightning特别注意避免此类错误。
7. 16位精度
16位精度可以有效地削减一半的内存占用。大多数模型都是用32位精度数进行训练的。然而最近的研究发现，使用16位精度，模型也可以很好地工作。混合精度指的是，用16位训练一些特定的模型，而权值类的用32位训练。
要想在pytorch中用16位精度，先从nvidia中安装 apex 图书馆 并对你的模型进行这些更改。
# enable 16-bit on the model and the optimizer
model， optimizers = amp.initialize（model， optimizers， opt_level=‘o2’）
# when doing .backward， let amp do it so it can scale the loss
with amp.scale_loss（loss， optimizer） as scaled_loss：
scaled_loss.backward（）
amp包会处理大部分事情。如果梯度爆炸或趋于零，它甚至会扩大loss。
在lightning中， 使用16位很简单，不需对你的模型做任何修改，也不用完成上述操作。
trainer = trainer（amp_level=’o2‘， use_amp=false）
trainer.fit（model）
8. 移至多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））
在lightning中，可以直接指示训练器增加gpu数量，而无需完成上述任何操作。
# ask lightning to use 4 gpus for training
trainer = trainer（gpus=［0， 1， 2， 3］）
trainer.fit（model）
分模型训练
将模型的不同部分分配给不同的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）
对于这种类型的训练，无需将lightning训练器分到任何gpu上。与之相反，只要把自己的模块导入正确的gpu的lightning模块中：
class mymodule（lightningmodule）：
def __init__（）：
self.encoder = rnn（。..）
self.decoder = rnn（。..）
def forward（x）：
# models won‘t be moved after the first forward because
# they are already on the correct gpus
self.encoder.cuda（0）
self.decoder.cuda（1）
out = self.encoder（x）
out = self.decoder（out.cuda（1））
# don’t pass gpus to trainer
model = mymodule（）
trainer = trainer（）
trainer.fit（model）
混合两种训练方法
在上面的例子中，编码器和解码器仍然可以从并行化每个操作中获益。我们现在可以更具创造力了。
# change these lines
self.encoder = rnn（。..）
self.decoder = rnn（。..）
# to these
# now each rnn is based on a different gpu set
self.encoder = dataparallel（self.encoder， devices=［0， 1， 2， 3］）
self.decoder = dataparallel（self.encoder， devices=［4， 5， 6， 7］）
# in forward.。.
out = self.encoder（x.cuda（0））
# notice inputs on first gpu in device
sout = self.decoder（out.cuda（4）） # 《--- the 4 here
使用多gpus时需注意的事项
· 如果该设备上已存在model.cuda（），那么它不会完成任何操作。
· 始终输入到设备列表中的第一个设备上。
· 跨设备传输数据非常昂贵，不到万不得已不要这样做。
· 优化器和梯度将存储在gpu 0上。因此，gpu 0使用的内存很可能比其他处理器大得多。
9. 多节点gpu训练
每台机器上的各gpu都可获取一份模型的副本。每台机器分得一部分数据，并仅针对该部分数据进行训练。各机器彼此同步梯度。
做到了这一步，就可以在几分钟内训练imagenet数据集了！ 这没有想象中那么难，但需要更多有关计算集群的知识。这些指令假定你正在集群上使用slurm。
pytorch在各个gpu上跨节点复制模型并同步梯度，从而实现多节点训练。因此，每个模型都是在各gpu上独立初始化的，本质上是在数据的一个分区上独立训练的，只是它们都接收来自所有模型的梯度更新。
高级阶段：
1. 在各gpu上初始化一个模型的副本（确保设置好种子，使每个模型初始化到相同的权值，否则操作会失效。）
2. 将数据集分成子集。每个gpu只在自己的子集上训练。
3. on .backward（） 所有副本都会接收各模型梯度的副本。只有此时，模型之间才会相互通信。
pytorch有一个很好的抽象概念，叫做分布式数据并行处理，它可以为你完成这一操作。要使用ddp（分布式数据并行处理），需要做4件事：
def tng_dataloader（）：
d = mnist（）
# 4： add distributed sampler
# sampler sends a portion of tng data to each machine
dist_sampler = distributedsampler（dataset）
dataloader = dataloader（d， shuffle=false， sampler=dist_sampler）
def main_process_entrypoint（gpu_nb）：
# 2： set up connections between all gpus across all machines
# all gpus connect to a single gpu “root”
# the default uses env://
world = nb_gpus * nb_nodes
dist.init_process_group（“nccl”， rank=gpu_nb， world_size=world）
# 3： wrap model in dpp
torch.cuda.set_device（gpu_nb）
model.cuda（gpu_nb）
model = distributeddataparallel（model， device_ids=［gpu_nb］）
# train your model now.。.
if __name__ == ‘__main__’：
# 1： spawn number of processes
# your cluster will call main for each machine
mp.spawn（main_process_entrypoint， nprocs=8）
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］）
lightning还附带了一个slurmcluster管理器，可助你简单地提交slurm任务的正确细节
10. 福利！更快的多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+的有效批量大小）。
但是需要小心处理大批次。根据具体问题查阅文献，学习一下别人是如何处理的！
边界扫描测试解决方案的原理及应用分析
Socionext发布支持8K/4K的多媒体播放机,搭载了8K HEVC解码芯片
压力表选择时需要遵守哪些原则
Maxim推出离线式LED驱动器MAX16841
物联网智能硬件和共享经济有着很多的相似点
9个用Pytorch训练快速神经网络的方法
一加4跳票，一加手机新旗舰曝光
大唐软件荣获中国通信标准化协会科学技术奖
可编程逻辑控制器的负载点电源设计方案
环形器和隔离器概述
聚英才 “数”未来 软通动力数字人才伙伴大会成功举办
FPGA学习笔记：PLL IP核的使用方法
苹果APP Store 2020年营收超700亿美元
人工智能逐步取代目前世界50%的工作,那能帮你妈妈织毛衣吗？
灿瑞科技上半年营收净利均大幅下滑
绕线式异步电动机的转子接线图
努比亚Z50 Ultra体验报告：强悍硬朗，旗舰风采
德国反垄断机构已对亚马逊和苹果可能存在的反竞争展开了调查
单片机的输入 / 输出（ I/O ）口
led显示屏驱动电路
不要让你的神经网络变成这样。
这份指南的介绍从简单到复杂，一直介绍到你可以完成的大多数pita修改，以充分利用你的网络。例子中会包括一些pytorch代码和相关标记，可以在 pytorch-lightning训练器中用，以防大家不想自己敲码！
这份指南针对的是谁？ 任何用pytorch研究非琐碎的深度学习模型的人，比如工业研究人员、博士生、学者等等……这些模型可能要花费几天，甚至几周、几个月的时间来训练。
指南（从易到难）
1. 使用dataloader。
2. dataloader中的进程数。
3. 批尺寸。
4. 累积梯度。
5. 保留计算图。
6. 转至单gpu。
7. 16位混合精度训练。
8. 转至多gpu（模型复制）。
9. 转至多gpu节点（8+gpus）。
10. 有关模型加速的思考和技巧
pytorch-lightning
文中讨论的各种优化，都可以在名为pytorch-lightning 的pytorch图书馆中找到。
lightning是基于pytorch的一个光包装器，它可以帮助研究人员自动训练模型，但关键的模型部件还是由研究人员完全控制。
参照此篇教程，获得更有力的范例。
lightning采用最新、最尖端的方法，将犯错的可能性降到最低。
mnist定义的lightning模型，可适用于训练器。
from pytorch-lightning import trainer
model = lightningmodule（…）
trainer = trainer（）
trainer.fit（model）
1. dataloader
这可能是最容易提速的地方。靠保存h5py或numpy文件来加速数据加载的日子已经一去不复返了。用 pytorch dataloader 加载图像数据非常简单。
dataset = mnist（root=self.hparams.data_root， train=train， download=true）
loader = dataloader（dataset， batch_size=32， shuffle=true）
for batch in loader：
x， y = batch
model.training_step（x， y）
...
在lightning中，你无需指定一个训练循环，只需定义dataloaders，训练器便会在 需要时调用它们。
2. dataloaders中的进程数
加快速度的第二个秘诀在于允许批量并行加载。所以，你可以一次加载许多批量，而不是一次加载一个。
# slow
loader = dataloader（dataset， batch_size=32， shuffle=true）
# fast （use 10 workers）
loader = dataloader（dataset， batch_size=32， shuffle=true， num_workers=10）
3. 批量大小（batch size）
在开始下一步优化步骤之前，将批量大小调高到cpu内存或gpu内存允许的最大值。
接下来的部分将着重于减少内存占用，这样就可以继续增加批尺寸。
记住，你很可能需要再次更新学习率。如果将批尺寸增加一倍，最好将学习速度也提高一倍。
4. 累积梯度
假如已经最大限度地使用了计算资源，而批尺寸仍然太低（假设为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）
5. 保留计算图
撑爆内存很简单，只要不释放指向计算图形的指针，比如……为记录日志保存loss。
losses = ［］
...
losses.append（loss）
print（f‘current loss： {torch.mean（losses）’}）
上述的问题在于，loss仍然有一个图形副本。在这种情况中，可用.item（）来释放它。
# bad
losses.append（loss）
# good
losses.append（loss.item（））
lightning会特别注意，让其无法保留图形副本
6. 单gpu训练
一旦完成了前面的步骤，就可以进入gpu训练了。gpu的训练将对许多gpu核心上的数学计算进行并行处理。能加速多少取决于使用的gpu类型。个人使用的话，推荐使用2080ti，公司使用的话可用v100。
刚开始你可能会觉得压力很大，但其实只需做两件事： 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（）
但是如果使用lightning，那么只有在定义lightning模块时可能会出现这种问题。lightning特别注意避免此类错误。
7. 16位精度
16位精度可以有效地削减一半的内存占用。大多数模型都是用32位精度数进行训练的。然而最近的研究发现，使用16位精度，模型也可以很好地工作。混合精度指的是，用16位训练一些特定的模型，而权值类的用32位训练。
要想在pytorch中用16位精度，先从nvidia中安装 apex 图书馆 并对你的模型进行这些更改。
# enable 16-bit on the model and the optimizer
model， optimizers = amp.initialize（model， optimizers， opt_level=‘o2’）
# when doing .backward， let amp do it so it can scale the loss
with amp.scale_loss（loss， optimizer） as scaled_loss：
scaled_loss.backward（）
amp包会处理大部分事情。如果梯度爆炸或趋于零，它甚至会扩大loss。
在lightning中， 使用16位很简单，不需对你的模型做任何修改，也不用完成上述操作。
trainer = trainer（amp_level=’o2‘， use_amp=false）
trainer.fit（model）
8. 移至多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））
在lightning中，可以直接指示训练器增加gpu数量，而无需完成上述任何操作。
# ask lightning to use 4 gpus for training
trainer = trainer（gpus=［0， 1， 2， 3］）
trainer.fit（model）
分模型训练
将模型的不同部分分配给不同的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）
对于这种类型的训练，无需将lightning训练器分到任何gpu上。与之相反，只要把自己的模块导入正确的gpu的lightning模块中：
class mymodule（lightningmodule）：
def __init__（）：
self.encoder = rnn（。..）
self.decoder = rnn（。..）
def forward（x）：
# models won‘t be moved after the first forward because
# they are already on the correct gpus
self.encoder.cuda（0）
self.decoder.cuda（1）
out = self.encoder（x）
out = self.decoder（out.cuda（1））
# don’t pass gpus to trainer
model = mymodule（）
trainer = trainer（）
trainer.fit（model）
混合两种训练方法
在上面的例子中，编码器和解码器仍然可以从并行化每个操作中获益。我们现在可以更具创造力了。
# change these lines
self.encoder = rnn（。..）
self.decoder = rnn（。..）
# to these
# now each rnn is based on a different gpu set
self.encoder = dataparallel（self.encoder， devices=［0， 1， 2， 3］）
self.decoder = dataparallel（self.encoder， devices=［4， 5， 6， 7］）
# in forward.。.
out = self.encoder（x.cuda（0））
# notice inputs on first gpu in device
sout = self.decoder（out.cuda（4）） # 《--- the 4 here
使用多gpus时需注意的事项
· 如果该设备上已存在model.cuda（），那么它不会完成任何操作。
· 始终输入到设备列表中的第一个设备上。
· 跨设备传输数据非常昂贵，不到万不得已不要这样做。
· 优化器和梯度将存储在gpu 0上。因此，gpu 0使用的内存很可能比其他处理器大得多。
9. 多节点gpu训练
每台机器上的各gpu都可获取一份模型的副本。每台机器分得一部分数据，并仅针对该部分数据进行训练。各机器彼此同步梯度。
做到了这一步，就可以在几分钟内训练imagenet数据集了！ 这没有想象中那么难，但需要更多有关计算集群的知识。这些指令假定你正在集群上使用slurm。
pytorch在各个gpu上跨节点复制模型并同步梯度，从而实现多节点训练。因此，每个模型都是在各gpu上独立初始化的，本质上是在数据的一个分区上独立训练的，只是它们都接收来自所有模型的梯度更新。
高级阶段：
1. 在各gpu上初始化一个模型的副本（确保设置好种子，使每个模型初始化到相同的权值，否则操作会失效。）
2. 将数据集分成子集。每个gpu只在自己的子集上训练。
3. on .backward（） 所有副本都会接收各模型梯度的副本。只有此时，模型之间才会相互通信。
pytorch有一个很好的抽象概念，叫做分布式数据并行处理，它可以为你完成这一操作。要使用ddp（分布式数据并行处理），需要做4件事：
def tng_dataloader（）：
d = mnist（）
# 4： add distributed sampler
# sampler sends a portion of tng data to each machine
dist_sampler = distributedsampler（dataset）
dataloader = dataloader（d， shuffle=false， sampler=dist_sampler）
def main_process_entrypoint（gpu_nb）：
# 2： set up connections between all gpus across all machines
# all gpus connect to a single gpu “root”
# the default uses env://
world = nb_gpus * nb_nodes
dist.init_process_group（“nccl”， rank=gpu_nb， world_size=world）
# 3： wrap model in dpp
torch.cuda.set_device（gpu_nb）
model.cuda（gpu_nb）
model = distributeddataparallel（model， device_ids=［gpu_nb］）
# train your model now.。.
if __name__ == ‘__main__’：
# 1： spawn number of processes
# your cluster will call main for each machine
mp.spawn（main_process_entrypoint， nprocs=8）
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］）
lightning还附带了一个slurmcluster管理器，可助你简单地提交slurm任务的正确细节
10. 福利！更快的多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+的有效批量大小）。
但是需要小心处理大批次。根据具体问题查阅文献，学习一下别人是如何处理的！
边界扫描测试解决方案的原理及应用分析
Socionext发布支持8K/4K的多媒体播放机,搭载了8K HEVC解码芯片
压力表选择时需要遵守哪些原则
Maxim推出离线式LED驱动器MAX16841
物联网智能硬件和共享经济有着很多的相似点
9个用Pytorch训练快速神经网络的方法
一加4跳票，一加手机新旗舰曝光
大唐软件荣获中国通信标准化协会科学技术奖
可编程逻辑控制器的负载点电源设计方案
环形器和隔离器概述
聚英才 “数”未来 软通动力数字人才伙伴大会成功举办
FPGA学习笔记：PLL IP核的使用方法
苹果APP Store 2020年营收超700亿美元
人工智能逐步取代目前世界50%的工作,那能帮你妈妈织毛衣吗？
灿瑞科技上半年营收净利均大幅下滑
绕线式异步电动机的转子接线图
努比亚Z50 Ultra体验报告：强悍硬朗，旗舰风采
德国反垄断机构已对亚马逊和苹果可能存在的反竞争展开了调查
单片机的输入 / 输出（ I/O ）口
led显示屏驱动电路