欢迎您访问 最编程 本站为您分享编程语言代码，编程技术文章！

热门搜索/Hot Search

您现在的位置是： 首页

PyTorch加速小贴士：提升训练效率的几种常用方法

最编程 2024-08-10 18:22:41
...

网络异常，图片无法展示
|
文中讨论的各种优化，都可以在Pytorch-Lightning找到：github.com/williamFalc…


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


参照此篇教程，获得更有力的范例：github.com/williamFalc…


Lightning采用最新、最尖端的方法，将犯错的可能性降到最低。


MNIST定义的Lightning模型可适用于训练器：github.com/williamFalc…


**

from pytorch-lightning import Trainer
model = LightningModule(…)
trainer = Trainer()
trainer.fit(model)

1. DataLoader

这可能是最容易提速的地方。靠保存h5py或numpy文件来加速数据加载的日子已经一去不复返了。用 Pytorch dataloader 加载图像数据非常简单：pytorch.org/tutorials/b…

关于NLP数据，请参照TorchText：torchtext.readthedocs.io/en/latest/d…


**

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 / 16properties

而在Lightning中，这些已经自动执行了。只需设置标记：

trainer = Trainer(accumulate_grad_batches=16)
trainer.fit(model)



5. 保留计算图

撑爆内存很简单，只要不释放指向计算图形的指针，比如……为记录日志保存loss。

losses = []

...
losses.append(loss)

print(f'current loss: )

上述的问题在于，loss仍然有一个图形副本。在这种情况中，可用.item()来释放它。

# bad
losses.append(loss)

# good
losses.append(loss.item())


Lightning会特别注意，让其无法保留图形副本。示例：github.com/williamFalc…



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。


  • 分批量训练

image.png


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)

image.png


将模型的不同部分分配给不同的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训练

image.png



每台机器上的各GPU都可获取一份模型的副本。每台机器分得一部分数据，并仅针对该部分数据进行训练。各机器彼此同步梯度。


做到了这一步，就可以在几分钟内训练Imagenet数据集了! 这没有想象中那么难，但需要更多有关计算集群的知识。这些指令假定你正在集群上使用SLURM。

上一篇： TK加速器：让你轻松畅享Tiktok的最佳体验！一键连接，无速度烦恼！

下一篇： 怎样测验硬盘的读写速度呢？

推荐阅读