最近跑的模型都比较大，尤其是Bert， 这真的是难为我 1080ti 了， 在Bert的Example中，官方提供了一些 Trick 来帮助我们加速训练，很良心， 但感觉还不够，于是花费一些时间整理出一个 Trick 集合，来帮助我们在显存不足的时候来嘿嘿嘿。

本文分为两大部分，第一部分引入一个主题：如何估计模型所需显存， 第二个主题：GPU显存不足时的各种 Trick 。

监控 GPU

监控GPU最常用的当然是 nvidia-smi ，但有一个工具能够更好的展示信息：gpustat 。

nvidia-smi
watch --color -n1 gpustat -cpu   # 动态事实监控GPU
推荐在配置文件中配置别名，反正我每次 gpu 一下，信息就全出来了，很方便。
 
下面有同学推荐nvtop， 我简单试了试，的确挺好的，展现出现的信息很丰富 ， 推荐试一试。
 
如何估计模型显存 [1]
 首先，思考一个问题： 模型中的哪些东西占据了我的显存，咋就动不动就 out of memory？
 
其实一个模型所占用的显存主要包含两部分： 模型自身的参数， 优化器参数， 模型每层的输入输出。
 
模型自身参数
 
模型自身的参数指的就是各个网络层的 Weight 和Bias，这部分显存在模型加载完成之后就会被占用， 注意到的是，有些层是有参数的，如CNN， RNN； 而有些层是无参数的， 如激活层， 池化层等。
 
从Pytorch 的角度来说，当你执行 model.to(device) 是， 你的模型就加载完毕，此时你的模型就已经加载完成了。
 
对于Pytorch来说，模型参数存储在 model.parameters() 中，因此，我们不需要自己计算，完全可以通过Pytorh来直接打印：
 
print('Model {} : params: {:4f}M'.format(model._get_name()， para * type_size / 1000 / 1000))
优化器参数
 
优化器参数指的是模型在优化过程即反向传播中所产生的参数， 这部分参数主要指的就是 dw， 即梯度，在SGD中， 其大小与参数一样， 因此在优化期间， 模型的参数所占用的显存会翻倍。
 
值得注意的是，不同的优化器其所需保存的优化参数不同， 对于 Adam， 由于其还需要保存其余参数， 模型的参数量会在优化区间翻 4 倍。
 
模型每层的输入输出
 
首先，第一点是输入数据所占用的显存， 这部分所占用的显存其实并不大，这是因为我们往往采用迭代器的方式读取数据，这意味着我们其实并不是一次性的将所有数据读入显存，而这保证每次输入所占用的显存与整个网络参数来比是微不足道的。
 
然后，在模型进行前向传播与反向传播时， 一个很重要的事情就是计算并保存每一层的输出以及其对应的梯度， 这意味着，这也占据了很大一部分显存。
 
最后， 模型输出的显存占用可以总结为：
 
每一层的输出(多维数组)， 其对应的梯度， 值得注意的是，模型输出不需要存储相应的动量信息（即此处如果使用Adam， 模型输出的参数量依旧是2倍而不是4倍， 我也不知道为啥？？求大佬指教）
输出的显存占用与 batch size 成正比
 
那么有没有办法通过Pytorch来计算这部分参数量呢？ 答案是有的，我们可以假设一个batch的样本，然后通过 model.modules() 来对每一层进行遍历，获得每一层的输出shape， 然后就能够获得一个batch的数据的输出参数量。[2]
 
所有的显存占用计算
 
显存占用 = 模型自身参数 × n + batch size × 输出参数量 × 2 + 一个batch的输入数据（往往忽略）
其中，n是根据优化算法来定的，如果选用SGD， 则 n = 2， 如果选择Adam， 则 n = 4.
 
一个很棒的实现如下， 我懒得再重新写了，你可以根据这个改一改，问题不大。
 
# 模型显存占用监测函数
# model：输入的模型
# input：实际中需要输入的Tensor变量
# type_size 默认为 4 默认类型为 float32 
def modelsize(model, input, type_size=4):
    para = sum([np.prod(list(p.size())) for p in model.parameters()])
    print('Model {} : params: {:4f}M'.format(model._get_name(), para * type_size / 1000 / 1000))
    input_ = input.clone()
    input_.requires_grad_(requires_grad=False)
    mods = list(model.modules())
    out_sizes = []
    for i in range(1, len(mods)):
        m = mods[i]
        if isinstance(m, nn.ReLU):
            if m.inplace:
                continue
        out = m(input_)
        out_sizes.append(np.array(out.size()))
        input_ = out
    total_nums = 0
    for i in range(len(out_sizes)):
        s = out_sizes[i]
        nums = np.prod(np.array(s))
        total_nums += nums
    print('Model {} : intermedite variables: {:3f} M (without backward)'
          .format(model._get_name(), total_nums * type_size / 1000 / 1000))
    print('Model {} : intermedite variables: {:3f} M (with backward)'
          .format(model._get_name(), total_nums * type_size*2 / 1000 / 1000))
GPU 显存不足时的Trick [2]
 
此处不讨论多GPU， 分布式计算等情况，只讨论一些常规的 Trick， 会不定时进行更新。
 
降低batch size
 
这应该很好理解，适当降低batch size， 则模型每层的输入输出就会成线性减少， 效果相当明显。这里需要注意的一点是, dev batch size 的调整也有助于降低显存, 同时,不要将 dev 或 test 的batch size 设置为样本集长度, 我最近就干了这个傻事，害的我调试了一天才调出来是这个问题。
 
选择更小的数据类型
 
一般默认情况下， 整个网络中采用的是32位的浮点数，如果切换到 16位的浮点数，其显存占用量将接近呈倍数递减。
 
在设计模型时，适当的精简模型，如原来两层的LSTM转为一层； 原来使用LSTM， 现在使用GRU； 减少卷积核数量； 尽量少的使用 Linear 等。
 
对于文本数据来说，长序列所带来的参数量是呈线性增加的， 适当的缩小序列长度可以极大的降低参数量。
 
total_loss
 
考虑到 loss 本身是一个包含梯度信息的 tensor， 因此，正确的求损失和的方式为：
 
total_loss += loss.item()
释放不需要的张量和变量
 
采用del释放你不再需要的张量和变量，这也要求我们在写模型的时候注意变量的使用，不要随心所欲，漫天飞舞。
 
Relu 的 inplace 参数
 
激活函数 Relu() 有一个默认参数 inplace ，默认为Flase， 当设置为True的时候，我们在通过relu() 计算得到的新值不会占用新的空间而是直接覆盖原来的值，这表示设为True， 可以节省一部分显存。
 
首先， 要了解一些Pytorch的基本知识：
 
在Pytorch 中，当我们执行 loss.backward() 时， 会为每个参数计算梯度，并将其存储在 paramter.grad 中， 注意到， paramter.grad 是一个张量， 其会累加每次计算得到的梯度。
在 Pytorch 中， 只有调用 optimizer.step()时才会进行梯度下降更新网络参数。
 
我们知道， batch size 与占用显存息息相关，但有时候我们的batch size 又不能设置的太小，这咋办呢？ 答案就是梯度累加。
 
我们先来看看传统训练：
 
for i,(feature,target) in enumerate(train_loader):
    outputs = model(feature)  # 前向传播
    loss = criterion(outputs,target)  # 计算损失
    optimizer.zero_grad()   # 清空梯度
    loss.backward()  # 计算梯度
    optimizer.step()  # 反向传播， 更新网络参数
而加入梯度累加之后，代码是这样的：
 
for i,(features,target) in enumerate(train_loader):
    outputs = model(images)  # 前向传播
    loss = criterion(outputs,target)  # 计算损失
    loss = loss/accumulation_steps   # 可选，如果损失要在训练样本上取平均
    loss.backward()  # 计算梯度
    if((i+1)%accumulation_steps)==0:
        optimizer.step()        # 反向传播，更新网络参数
        optimizer.zero_grad()   # 清空梯度
比较来看， 我们发现，梯度累加本质上就是累加 accumulation_steps 个batch 的梯度， 再根据累加的梯度来更新网络参数，以达到类似batch_size 为 accumulation_steps * batch_size 的效果。在使用时，需要注意适当的扩大学习率。
 
更详细来说， 我们假设 batch size = 32， accumulation steps = 8 ， 梯度积累首先在前向传播的时候讲 batch 分为 accumulation steps 份， 然后得到 size=4 的小份batch ， 每次就以小 batch 来计算梯度，但是不更新参数，将梯度积累下来，直到我们计算了 accumulation steps 个小 batch， 我们再更新参数。
 
梯度积累能很大程度上缓解GPU显存不足的问题，推荐使用。
 
在Bert的仓库中，就使用了这个Trick，十分实用，简直是我们这种乞丐实验室的良心Trick。
 
梯度检查点
 
这个Trick我没用过，毕竟模型还没有那么那么大。
 
等我用过再更新吧，先把坑挖下。
 
哎， 如果你看完了这篇文章，就说明了一件事情： **小伙子，你卡也不够啊。**哎， 乞丐实验室不配深度学习，哭了。
 
Reference
 
[1]科普帖：深度学习中GPU和显存分析
 
[2]如何在Pytorch中精细化利用显存
 
[3]GPU捉襟见肘还想训练大批量模型？谁说不可以
 
[4]PyTorch中在反向传播前为什么要手动将梯度清零？
 
[5]From zero to research — An introduction to Meta-learning
 
[6]Training Neural Nets on Larger Batches: Practical Tips for 1-GPU, Multi-GPU & Distributed setups
                    前言最近跑的模型都比较大，尤其是Bert， 这真的是难为我 1080ti 了， 在Bert的Example中，官方提供了一些 Trick 来帮助我们加速训练，很良心， 但感觉还不够，于是花费一些时间整理出一个 Trick 集合，来帮助我们在显存不足的时候来嘿嘿嘿。本文分为两大部分，第一部分引入一个主题：如何估计模型所需显存， 第二个主题：GPU显存不足时的各种 Trick 。监控 GPU监...
				
训练模型主要分为五个模块：启动器、自定义数据加载器、网络模型、学习率/损失率调整以及训练可视化。
启动器是项目的入口，通过对启动器参数的设置，可以进行很多灵活的启动方式，下图为部分启动器参数设置。
任何一个深度学习的模型训练都是离不开数据集的，根据多种多样的数据集，我们应该使用一个方式将数据集用一种通用的结构返回，方便网络模型的加载处理。
这里使用了残差网络Resnet-34，代码中还提供了Resnet-18、Resnet-50、Resnet-101以及Resnet-152。残差结构是通过一个快捷连接，极大的减少了参数数量，降低了内存使用。
以下为残差网络的基本结构和Resnet-34 部分网络结构图。
除了最开始看到的train-val图表、Top-、Top-5的error记录表以外，在训练过程中，使用进度条打印当前训练的进度、训练精度等信息。打印时机可以通过上边提到的 启动器 优雅地配置。




    

				
最近用GoogleNet （inception-v3）做fine-tune训练时，遇到了一个问题。当我选择单个GPU训练时候，服务器中所有的GPU显存都会被占满，如下图所示：
    出现以上问题的原因是tensorflow在训练时默认占用所有GPU的显存。
    可以通过以下方式解决该问题：
1、在构造tf.Session()时候通过传递tf.GPUOptions作为可选配置参数
				
跑深度学习时tensorflow-gpu不够使用如何解决
今天跑一个深度学习代码时遇到一个问题：
Hint: If you want to see a list of allocated tensors when OOM happen
百度了之后发现是gpu内存不够使用
两个解决方案
1.制定第二块GPU可用
import os
os.environ["CUDA_VISIBLE_DEVICES"] = "2"
2.调整batch_size的大小
400张训练集，我的batch_size原本为8，跑50次出
				
在tensorflow中，使用GPU训练模型会默认占有所有的显存，因此需要添加一些限制条件，使显存不会被全部占用。
1.分配GPU的显存
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.7)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
				
欢迎转载，但请务必注明原文出处及作者信息。@author: huangyongye  
@creat_date: 2017-03-09 前言:  根据我本人学习 TensorFlow 实现 LSTM 的经历，发现网上虽然也有不少教程，其中很多都是根据官方给出的例子，用多层 LSTM 来实现 PTBModel 语言模型，比如：  
 tensorflow笔记：多层LSTM代码分析 
但是感觉这些例子还
				
文章目录问题描述参考链接
2020-07-20 10:48:49.753261: W tensorflow/core/common_runtime/bfc_allocator.cc:439] ****************************************___**____***************************************____________
2020-07-20 10:48:49.753329: W tensorflow/core/framewor
其实一个模型所占用的显存主要包含两部分： 模型自身的参数， 优化器参数， 模型每层的输入输出。
其实一个模型所占用的显存主要包含两部分： 模型自身的参数， 优化器参数， 模型每层的输入输出。
1、模型自身参数
模型自身的参数指的就是各个网络层的 Weight 和Bias，这部分显存在模型加载完成之后就会被占用， 注意到的是，有些层是有参数的，如CNN， RNN； 而有些层是无参数的， 如激活层， 池化层等。
从Pytorch 的角度来说，当你执行 model.to(device) 是， 你的模型就
一、单卡加载大型网络
1.1 梯度累加Gradient Accumulation
单卡加载大型网络，一般受限于大量的网络参数，训练时只能使用很小的batch_size或者很小的Seq_len。这里可以使用梯度累加，进行N次前向反向更新一次参数，相当于扩大了N倍的batch_size。
				
本文是“[PPoPP18] SuperNeurons:Dynamic GPU Memory Management for Training Deep Neural Networks”的论文阅读笔记，论文、talk视频PPT等详见作者主页：https://linnanwang.github.io/ 
参考资料： 
https://linnanwang.github.io/ 
How to Optim...
				
### 回答1：
Halcon是一种功能强大的计算机视觉软件库，它为用户提供了各种用于图像处理和分析的功能。Halcon深度学习是其最新的功能之一，它利用了深度神经网络来帮助解决图像识别和分类等任务。
深度学习是一种计算密集型的任务，它需要大量的计算资源来训练和运行神经网络模型。而GPU（图形处理单元）是一种专门用于高性能计算的硬件，它在并行计算方面表现出色。相比之下，传统的中央处理单元（CPU）在深度学习任务上的计算速度较慢。
Halcon深度学习需要GPU来加速深度学习任务的推理过程，即将训练好的神经网络模型应用于实际的图像处理任务中。使用GPU可以显著提高深度学习任务的运行速度，从而实现更高效的图像识别和分类。
值得注意的是，Halcon深度学习对GPU的要求并不是非常高，一般来说，拥有一块较新的中高端GPU即可满足大部分的深度学习应用需求。因此，使用Halcon深度学习时，如果想要获得更好的性能和效果，建议配备一块支持CUDA或OpenCL的独立显卡。  
### 回答2：
Halcon深度学习需要GPU的原因是为了加快深度学习模型的训练和推理过程。深度学习模型具有复杂的网络架构和大量的参数，普通的CPU无法满足其计算需求，而GPU具备更强大的并行计算能力，可以加速模型训练和推理的速度。
在Halcon深度学习中，GPU可以提供高效的并行计算，同时支持更大规模的模型和数据集。通过利用GPU的并行计算能力，可以加速神经网络中复杂的矩阵运算、卷积操作等计算过程，并提高模型在大规模数据集上的训练速度。
此外，Halcon深度学习使用GPU还能够提供更好的实时性能。在很多实时应用场景中，需要在短时间内对大量数据进行处理和分析，使用GPU可以在保证准确性的同时提高处理速度，从而满足实时性要求。
综上所述，Halcon深度学习需要GPU是为了提高模型训练和推理速度，支持更大规模的模型和数据集，以及满足实时应用的要求。  
### 回答3：
Halcon深度学习需要使用GPU是因为深度学习任务通常需要大量的计算资源来处理复杂的神经网络模型和海量的数据。相比于传统的中央处理器（CPU），图形处理器（GPU）具有更优异的并行计算能力，可以同时进行大量的计算操作，提高深度学习任务的处理效率。
使用GPU可以加速深度学习任务的训练和推理过程。在训练神经网络模型时，通过并行计算，GPU可以更快地进行矩阵运算、张量操作和梯度更新等关键计算步骤，加快模型的训练速度。在推理过程中，GPU可以高效地进行神经网络的前向计算，实时地对输入数据进行处理和分析。
此外，由于深度学习任务的数据量通常较大，需要在GPU的高速内存中进行存储和处理，以支持高效的数据并行计算。GPU的高速内存带宽和容量可以提供良好的数据访问速度和存储能力，以满足深度学习任务的需求。
综上所述，使用GPU可以显著提高Halcon深度学习任务的处理效率和性能，加速训练和推理过程。然而，需要注意的是，使用GPU进行深度学习任务需要相应的硬件设备和软件支持，这也可能增加一定的成本和配置要求。