python

关注公众号 jb51net

关闭
首页 > 脚本专栏 > python > torch.cuda.amp自动混合精度训练之节省显存并加快推理速度

解读torch.cuda.amp自动混合精度训练之节省显存并加快推理速度

作者:Code_demon

这篇文章主要介绍了torch.cuda.amp自动混合精度训练之节省显存并加快推理速度问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教

1、什么是amp?

amp:Automatic mixed precision,自动混合精度,可以在神经网络推理过程中,针对不同的层,采用不同的数据精度进行计算,从而实现节省显存和加快速度的目的。

自动混合精度的关键词有两个:自动、混合精度。

这是由PyTorch 1.6的torch.cuda.amp模块带来的:

from torch.cuda import amp

混合精度预示着有不止一种精度的Tensor,那在PyTorch的AMP模块里是几种呢?

2种:torch.FloatTensor(浮点型 32位)和torch.HalfTensor(半精度浮点型 16位);

自动预示着Tensor的dtype类型会自动变化,也就是框架按需自动调整tensor的dtype(其实不是完全自动,有些地方还是需要手工干预);

注意

2、为什么需要自动混合精度(amp)?

也可以这么问:为什么需要自动混合精度,也就是torch.FloatTensortorch.HalfTensor的混合,而不全是torch.FloatTensor?或者全是torch.HalfTensor

原因:

在某些上下文中torch.FloatTensor有优势,在某些上下文中torch.HalfTensor有优势。

torch.HalfTensor

可见,当有优势的时候就用torch.HalfTensor,而为了消除torch.HalfTensor的劣势,我们带来了两种解决方案:

3、如何在PyTorch中使用自动混合精度?

答案是 autocast + GradScaler

3.1 autocast

使用torch.cuda.amp模块中的autocast 类。

from torch.cuda import amp
# 创建model,默认是torch.FloatTensor
model = Net().cuda()
optimizer = optim.SGD(model.parameters(), ...)
# 判断能否使用自动混合精度
enable_amp = True if "cuda" in device.type else False
for input, target in data:
    optimizer.zero_grad()
    # 前向过程(model + loss)开启 autocast
    with amp.autocast(enabled=enable_amp):
        output = model(input)
        loss = loss_fn(output, target)
    # 反向传播在autocast上下文之外
    loss.backward()
    optimizer.step()

注意

3.2、GradScaler

这里GradScaler就是第二小节中提到的梯度scaler模块,需要在训练最开始之前使用amp.GradScaler实例化一个GradScaler对象。

from torch.cuda import amp
# 创建model,默认是torch.FloatTensor
model = Net().cuda()
optimizer = optim.SGD(model.parameters(), ...)
# 判断能否使用自动混合精度
enable_amp = True if "cuda" in device.type else False
# 在训练最开始之前实例化一个GradScaler对象
scaler = amp.GradScaler(enabled=enable_amp)
for epoch in epochs:
    for input, target in data:
        optimizer.zero_grad()
        # 前向过程(model + loss)开启 autocast
        with amp.autocast(enabled=enable_amp):
            output = model(input)
            loss = loss_fn(output, target)
        # 1、Scales loss.  先将梯度放大 防止梯度消失
        scaler.scale(loss).backward()
        # 2、scaler.step()   再把梯度的值unscale回来.
        # 如果梯度的值不是 infs 或者 NaNs, 那么调用optimizer.step()来更新权重,
        # 否则,忽略step调用,从而保证权重不更新(不被破坏)
        scaler.step(optimizer)
        # 3、准备着,看是否要增大scaler
        scaler.update()
        # 正常更新权重
        optimizer.zero_grad()

scaler的大小在每次迭代中动态的估计,为了尽可能的减少梯度underflow,scaler应该更大;但是如果太大的话,半精度浮点型的tensor又容易overflow(变成inf或者NaN)。

所以动态估计的原理就是在不出现inf或者NaN梯度值的情况下尽可能的增大scaler的值——在每次scaler.step(optimizer)中,都会检查是否又inf或NaN的梯度出现:

注意

再强调一点,amp只能在GPU环境下使用,因为一来amp是写在torch.cuda中的函数,而且amp的中的 amp.GradScaleramp.autocast函数构造是这样的:

amp.GradScaler

    def __init__(self,
                 init_scale=2.**16,
                 growth_factor=2.0,
                 backoff_factor=0.5,
                 growth_interval=2000,
                 enabled=True):
        if enabled and not torch.cuda.is_available():
            warnings.warn("torch.cuda.amp.GradScaler is enabled, but CUDA is not available.  Disabling.")
            self._enabled = False
        else:
            self._enabled = enabled

amp.autocast

 def __init__(self, enabled=True):
        if enabled and not torch.cuda.is_available():
            warnings.warn("torch.cuda.amp.autocast only affects CUDA ops, but CUDA is not available.  Disabling.")
            self._enabled = False
        else:
            self._enabled = enabled

4、多GPU训练

单卡训练的话上面的代码已经够了。

要是想多卡跑的话仅仅这样还不够,会发现在forward里面的每个结果都还是float32的,怎么办?

class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
    def forward(self, input_data_c1):
    	with autocast():
    		# code
    	return

只要把model中的forward里面的代码用autocast代码块方式运行就好了。

总结

以上为个人经验,希望能给大家一个参考,也希望大家多多支持脚本之家。

您可能感兴趣的文章:
阅读全文