深度学习入门(三十八)计算性能——多GPU训练
深度学习入门(三十八)计算性能——多GPU训练
- 前言
- 计算性能——多GPU训练
- 课件
- 多GPU并行
- 数据并行VS模型并行
- 数据并行
- 总结
- 教材
- 1 问题拆分
- 2 数据并行性
- 3 简单网络
- 4 数据同步
- 5 数据分发
- 6 训练
- 7 小结
- 多GPU的简洁实现
- 1 简单网络
- 2 网络初始化
- 3 训练
- 4 小结
前言
核心内容来自博客链接1博客连接2希望大家多多支持作者
本文记录用,防止遗忘
计算性能——多GPU训练
课件
多GPU并行
一台机器可以安装多个GPU (1-16)
在训练和预测时,我们将一个小批量计算切分到多个GPU上来达到加速目的
常用切分方案有
- 数据并行
- 模型并行
- 通道并行(数据+模型并行)
数据并行VS模型并行
数据并行:将小批量分成n块,每个GPU拿到完整参数计算—块数据的梯度
- 通常性能更好
- 模型并行:将模型分成n块,每个GPU拿到一块模型计算它的前向和方向结果
- 通常用于模型大到单GPU放不下
数据并行
总结
1、当一个模型能用单卡计算时,通常使用数据并行拓展到多卡上
2、模型并行则用在超大模型上教材
到目前为止,我们讨论了如何在CPU和GPU上高效地训练模型,同时在自动并行节中展示了深度学习框架如何在CPU和GPU之间自动地并行化计算和通信,还在GPU节中展示了如何使用nvidia-smi命令列出计算机上所有可用的GPU。 但是我们没有讨论如何真正实现深度学习训练的并行化。 是否存在一种方法,以某种方式分割数据到多个设备上,并使其能够正常工作呢? 本节将详细介绍如何从零开始并行地训练网络, 这里需要运用小批量随机梯度下降算法。
1 问题拆分
我们从一个简单的计算机视觉问题和一个稍稍过时的网络开始。 这个网络有多个卷积层和汇聚层,最后可能有几个全连接的层,看起来非常类似于LeNet或AlexNet。 假设我们有多个GPU。 我们希望以一种方式对训练进行拆分,为实现良好的加速比,还能同时受益于简单且可重复的设计选择。 毕竟,多个GPU同时增加了内存和计算能力。 简而言之,对于需要分类的小批量训练数据,我们有以下选择。
不推荐
第一种方法,在多个GPU之间拆分网络。 也就是说,每个GPU将流入特定层的数据作为输入,跨多个后续层对数据进行处理,然后将数据发送到下一个GPU。 与单个GPU所能处理的数据相比,我们可以用更大的网络处理数据。 此外,每个GPU占用的显存(memory footprint)可以得到很好的控制,虽然它只是整个网络显存的一小部分。然而,GPU的接口之间需要的密集同步可能是很难办的,特别是层之间计算的工作负载不能正确匹配的时候, 还有层之间的接口需要大量的数据传输的时候(例如:激活值和梯度,数据量可能会超出GPU总线的带宽)。 此外,计算密集型操作的顺序对于拆分来说也是非常重要的,其本质仍然是一个困难的问题,目前还不清楚研究是否能在特定问题上实现良好的线性缩放。 综上所述,除非存框架或操作系统本身支持将多个GPU连接在一起,否则不建议这种方法。
不推荐
第二种方法,拆分层内的工作。 例如,将问题分散到4个GPU,每个GPU生成16个通道的数据,而不是在单个GPU上计算64个通道。 对于全连接的层,同样可以拆分输出单元的数量。 下图描述了这种设计,其策略用于处理显存非常小(当时为2GB)的GPU。 当通道或单元的数量不太小时,使计算性能有良好的提升。 此外,由于可用的显存呈线性扩展,多个GPU能够处理不断变大的网络。
然而,我们需要大量的同步或屏障操作(barrier operation),因为每一层都依赖于所有其他层的结果。 此外,需要传输的数据量也可能比跨GPU拆分层时还要大。 因此,基于带宽的成本和复杂性,我们同样不推荐这种方法。最后一种方法,跨多个GPU对数据进行拆分。 这种方式下,所有GPU尽管有不同的观测结果,但是执行着相同类型的工作。 在完成每个小批量数据的训练之后,梯度在GPU上聚合。 这种方法最简单,并可以应用于任何情况,同步只需要在每个小批量数据处理之后进行。 也就是说,当其他梯度参数仍在计算时,完成计算的梯度参数就可以开始交换。 而且,GPU的数量越多,小批量包含的数据量就越大,从而就能提高训练效率。 但是,添加更多的GPU并不能让我们训练更大的模型。
上图比较了多个GPU上不同的并行方式。 总体而言,只要GPU的显存足够大,数据并行是最方便的。
2 数据并行性
假设一台机器有k个GPU。 给定需要训练的模型,虽然每个GPU上的参数值都是相同且同步的,但是每个GPU都将独立地维护一组完整的模型参数。 例如,下图演示了在k=2时基于数据并行方法训练模型。
一般来说,k个GPU并行训练过程如下:- 在任何一次训练迭代中,给定的随机的小批量样本都将被分成k个部分,并均匀地分配到GPU上。
- 每个GPU根据分配给它的小批量子集,计算模型参数的损失和梯度。
- 将k个GPU中的局部梯度聚合,以获得当前小批量的随机梯度。
- 聚合梯度被重新分发到每个GPU中。
- 每个GPU使用这个小批量随机梯度,来更新它所维护的完整的模型参数集。
在实践中请注意,当在k个GPU上训练时,需要扩大小批量的大小为k的倍数,这样每个GPU都有相同的工作量,就像只在单个GPU上训练一样。 因此,在16-GPU服务器上可以显著地增加小批量数据量的大小,同时可能还需要相应地提高学习率。
下面我们将使用一个简单网络来演示多GPU训练。
%matplotlib inline import torch from torch import nn from torch.nn import functional as F from d2l import torch as d2l
3 简单网络
我们使用之前的(稍加修改的)LeNet, 从零开始定义它,从而详细说明参数交换和同步
# 初始化模型参数 scale = 0.01 W1 = torch.randn(size=(20, 1, 3, 3)) * scale b1 = torch.zeros(20) W2 = torch.randn(size=(50, 20, 5, 5)) * scale b2 = torch.zeros(50) W3 = torch.randn(size=(800, 128)) * scale b3 = torch.zeros(128) W4 = torch.randn(size=(128, 10)) * scale b4 = torch.zeros(10) params = [W1, b1, W2, b2, W3, b3, W4, b4]# 定义模型 def lenet(X, params):h1_conv = F.conv2d(input=X, weight=params[0], bias=params[1])h1_activation = F.relu(h1_conv)h1 = F.avg_pool2d(input=h1_activation, kernel_size=(2, 2), stride=(2, 2))h2_conv = F.conv2d(input=h1, weight=params[2], bias=params[3])h2_activation = F.relu(h2_conv)h2 = F.avg_pool2d(input=h2_activation, kernel_size=(2, 2), stride=(2, 2))h2 = h2.reshape(h2.shape[0], -1)h3_linear = torch.mm(h2, params[4]) + params[5]h3 = F.relu(h3_linear)y_hat = torch.mm(h3, params[6]) + params[7]return y_hat# 交叉熵损失函数 loss = nn.CrossEntropyLoss(reduction='none')
4 数据同步
对于高效的多GPU训练,我们需要两个基本操作。 首先,我们需要向多个设备分发参数并附加梯度(
get_params
)。 如果没有参数,就不可能在GPU上评估网络。 第二,需要跨多个设备对参数求和,也就是说,需要一个allreduce
函数。def get_params(params, device):new_params = [p.to(device) for p in params]for p in new_params:p.requires_grad_()return new_params
通过将模型参数复制到一个GPU。
new_params = get_params(params, d2l.try_gpu(0)) print('b1 权重:', new_params[1]) print('b1 梯度:', new_params[1].grad)
输出:
b1 权重: tensor([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],device='cuda:0', requires_grad=True) b1 梯度: None
由于还没有进行任何计算,因此权重参数的梯度仍然为零。 假设现在有一个向量分布在多个GPU上,下面的
allreduce
函数将所有向量相加,并将结果广播给所有GPU。 请注意,我们需要将数据复制到累积结果的设备,才能使函数正常工作。def allreduce(data):for i in range(1, len(data)):data[0][:] += data[i].to(data[0].device)for i in range(1, len(data)):data[i][:] = data[0].to(data[i].device)
通过在不同设备上创建具有不同值的向量并聚合它们。
data = [torch.ones((1, 2), device=d2l.try_gpu(i)) * (i + 1) for i in range(2)] print('allreduce之前:\n', data[0], '\n', data[1]) allreduce(data) print('allreduce之后:\n', data[0], '\n', data[1])
allreduce之前:tensor([[1., 1.]], device='cuda:0')tensor([[2., 2.]], device='cuda:1') allreduce之后:tensor([[3., 3.]], device='cuda:0')tensor([[3., 3.]], device='cuda:1')
5 数据分发
我们需要一个简单的工具函数,将一个小批量数据均匀地分布在多个GPU上。 例如,有两个GPU时,我们希望每个GPU可以复制一半的数据。 因为深度学习框架的内置函数编写代码更方便、更简洁,所以在 4 × 5 4 \times 5 4×5矩阵上使用它进行尝试。
data = torch.arange(20).reshape(4, 5) devices = [torch.device('cuda:0'), torch.device('cuda:1')] split = nn.parallel.scatter(data, devices) print('input :', data) print('load into', devices) print('output:', split)
输出:
input : tensor([[ 0, 1, 2, 3, 4],[ 5, 6, 7, 8, 9],[10, 11, 12, 13, 14],[15, 16, 17, 18, 19]]) load into [device(type='cuda', index=0), device(type='cuda', index=1)] output: (tensor([[0, 1, 2, 3, 4],[5, 6, 7, 8, 9]], device='cuda:0'), tensor([[10, 11, 12, 13, 14],[15, 16, 17, 18, 19]], device='cuda:1'))
为了方便以后复用,我们定义了可以同时拆分数据和标签的
split_batch
函数。def split_batch(X, y, devices):"""将X和y拆分到多个设备上"""assert X.shape[0] == y.shape[0]return (nn.parallel.scatter(X, devices),nn.parallel.scatter(y, devices))
6 训练
现在我们可以在一个小批量上实现多GPU训练。 在多个GPU之间同步数据将使用刚才讨论的辅助函数
allreduce
和split_and_load
。 我们不需要编写任何特定的代码来实现并行性。 因为计算图在小批量内的设备之间没有任何依赖关系,因此它是“自动地”并行执行。def train_batch(X, y, device_params, devices, lr):X_shards, y_shards = split_batch(X, y, devices)# 在每个GPU上分别计算损失ls = [loss(lenet(X_shard, device_W), y_shard).sum()for X_shard, y_shard, device_W in zip(X_shards, y_shards, device_params)]for l in ls: # 反向传播在每个GPU上分别执行l.backward()# 将每个GPU的所有梯度相加,并将其广播到所有GPUwith torch.no_grad():for i in range(len(device_params[0])):allreduce([device_params[c][i].grad for c in range(len(devices))])# 在每个GPU上分别更新模型参数for param in device_params:d2l.sgd(param, lr, X.shape[0]) # 在这里,我们使用全尺寸的小批量
现在,我们可以定义训练函数。 与前几章中略有不同:训练函数需要分配GPU并将所有模型参数复制到所有设备。 显然,每个小批量都是使用
train_batch
函数来处理多个GPU。 我们只在一个GPU上计算模型的精确度,而让其他GPU保持空闲,尽管这是相对低效的,但是使用方便且代码简洁。def train(num_gpus, batch_size, lr):train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)devices = [d2l.try_gpu(i) for i in range(num_gpus)]# 将模型参数复制到num_gpus个GPUdevice_params = [get_params(params, d) for d in devices]num_epochs = 10animator = d2l.Animator('epoch', 'test acc', xlim=[1, num_epochs])timer = d2l.Timer()for epoch in range(num_epochs):timer.start()for X, y in train_iter:# 为单个小批量执行多GPU训练train_batch(X, y, device_params, devices, lr)torch.cuda.synchronize()timer.stop()# 在GPU0上评估模型animator.add(epoch + 1, (d2l.evaluate_accuracy_gpu(lambda x: lenet(x, device_params[0]), test_iter, devices[0]),))print(f'测试精度:{animator.Y[0][-1]:.2f},{timer.avg():.1f}秒/轮,'f'在{str(devices)}')
让我们看看在单个GPU上运行效果得有多好。 首先使用的批量大小是256,学习率是0.2。
train(num_gpus=1, batch_size=256, lr=0.2)
输出
测试精度:0.80,2.7秒/轮,在[device(type='cuda', index=0)]
保持批量大小和学习率不变,并增加为2个GPU,我们可以看到测试精度与之前的实验基本相同。 不同的GPU个数在算法寻优方面是相同的。 不幸的是,这里没有任何有意义的加速:模型实在太小了;而且数据集也太小了,在这个数据集中,我们实现的多GPU训练的简单方法受到了巨大的Python开销的影响。 在未来,我们将遇到更复杂的模型和更复杂的并行化方法。 尽管如此,让我们看看Fashion-MNIST数据集上会发生什么。
train(num_gpus=2, batch_size=256, lr=0.2)
输出
测试精度:0.84,2.8秒/轮,在[device(type='cuda', index=0), device(type='cuda', index=1)]
7 小结
1、有多种方法可以在多个GPU上拆分深度网络的训练。拆分可以在层之间、跨层或跨数据上实现。前两者需要对数据传输过程进行严格编排,而最后一种则是最简单的策略。
2、数据并行训练本身是不复杂的,它通过增加有效的小批量数据量的大小提高了训练效率。
3、在数据并行中,数据需要跨多个GPU拆分,其中每个GPU执行自己的前向传播和反向传播,随后所有的梯度被聚合为一,之后聚合结果向所有的GPU广播。
4、小批量数据量更大时,学习率也需要稍微提高一些。多GPU的简洁实现
每个新模型的并行计算都从零开始实现是无趣的。此外,优化同步工具以获得高性能也是有好处的。下面我们将展示如何使用深度学习框架的高级API来实现这一点。数学和算法与上面的相同。不出所料,你至少需要两个GPU来运行代码。
import torch from torch import nn from d2l import torch as d2l
1 简单网络
让我们使用一个比LeNet更有意义的网络,它依然能够容易地和快速地训练。我们选择的是ResNet-18。因为输入的图像很小,所以稍微修改了一下。与之前的区别在于,我们在开始时使用了更小的卷积核、步长和填充,而且删除了最大汇聚层。
def resnet18(num_classes, in_channels=1):"""稍加修改的ResNet-18模型"""def resnet_block(in_channels, out_channels, num_residuals,first_block=False):blk = []for i in range(num_residuals):if i == 0 and not first_block:blk.append(d2l.Residual(in_channels, out_channels,use_1x1conv=True, strides=2))else:blk.append(d2l.Residual(out_channels, out_channels))return nn.Sequential(*blk)# 该模型使用了更小的卷积核、步长和填充,而且删除了最大汇聚层net = nn.Sequential(nn.Conv2d(in_channels, 64, kernel_size=3, stride=1, padding=1),nn.BatchNorm2d(64),nn.ReLU())net.add_module("resnet_block1", resnet_block(64, 64, 2, first_block=True))net.add_module("resnet_block2", resnet_block(64, 128, 2))net.add_module("resnet_block3", resnet_block(128, 256, 2))net.add_module("resnet_block4", resnet_block(256, 512, 2))net.add_module("global_avg_pool", nn.AdaptiveAvgPool2d((1,1)))net.add_module("fc", nn.Sequential(nn.Flatten(),nn.Linear(512, num_classes)))return net
2 网络初始化
我们将在训练回路中初始化网络。
net = resnet18(10) # 获取GPU列表 devices = d2l.try_all_gpus() # 我们将在训练代码实现中初始化网络
3 训练
如前所述,用于训练的代码需要执行几个基本功能才能实现高效并行:
1、需要在所有设备上初始化网络参数。
2、在数据集上迭代时,要将小批量数据分配到所有设备上。
3、跨设备并行计算损失及其梯度。
4、聚合梯度,并相应地更新参数。
最后,并行地计算精确度和发布网络的最终性能。除了需要拆分和聚合数据外,训练代码与前几章的实现非常相似。
def train(net, num_gpus, batch_size, lr):train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)devices = [d2l.try_gpu(i) for i in range(num_gpus)]def init_weights(m):if type(m) in [nn.Linear, nn.Conv2d]:nn.init.normal_(m.weight, std=0.01)net.apply(init_weights)# 在多个GPU上设置模型net = nn.DataParallel(net, device_ids=devices)trainer = torch.optim.SGD(net.parameters(), lr)loss = nn.CrossEntropyLoss()timer, num_epochs = d2l.Timer(), 10animator = d2l.Animator('epoch', 'test acc', xlim=[1, num_epochs])for epoch in range(num_epochs):net.train()timer.start()for X, y in train_iter:trainer.zero_grad()X, y = X.to(devices[0]), y.to(devices[0])l = loss(net(X), y)l.backward()trainer.step()timer.stop()animator.add(epoch + 1, (d2l.evaluate_accuracy_gpu(net, test_iter),))print(f'测试精度:{animator.Y[0][-1]:.2f},{timer.avg():.1f}秒/轮,'f'在{str(devices)}')
让我们看看这在实践中是如何运作的。我们先在单个GPU上训练网络进行预热。
train(net, num_gpus=1, batch_size=256, lr=0.1)
输出:
测试精度:0.92,13.7秒/轮,在[device(type='cuda', index=0)]
接下来我们使用2个GPU进行训练。与上文中评估的LeNet相比,ResNet-18的模型要复杂得多。这就是显示并行化优势的地方,计算所需时间明显大于同步参数需要的时间。因为并行化开销的相关性较小,因此这种操作提高了模型的可伸缩性。train(net, num_gpus=2, batch_size=512, lr=0.2)
输出:
测试精度:0.89,8.4秒/轮,在[device(type='cuda', index=0), device(type='cuda', index=1)]
4 小结
1、神经网络可以在(可找到数据的)单GPU上进行自动评估。
2、每台设备上的网络需要先初始化,然后再尝试访问该设备上的参数,否则会遇到错误。
3、优化算法在多个GPU上自动聚合。
深度学习入门(三十八)计算性能——多GPU训练相关推荐
- 系统学习深度学习(三十八)--深度确定性策略梯度(DDPG)
转自:https://www.cnblogs.com/pinard/p/10345762.html 1. 从随机策略到确定性策略 从DDPG这个名字看,它是由D(Deep)+D(Determinist ...
- 深度学习(三十八)——深度强化学习(1)教程
教程 http://incompleteideas.net/sutton/book/the-book-2nd.html <Reinforcement Learning: An Introduct ...
- 深度学习(三十八)初识DL在自然语言序列标注中的应用-未完待续
初识DL在自然语言中的应用 原文地址: 作者: 一.自然语言序列标注 虽然之前自己对于HMM.CRF.Word2vec.Attention机制.Encode-Decode等,在自然语言领域的应用已经比 ...
- 深度学习(三十八)卷积神经网络入门学习(2.0)
- 深度学习入门笔记(八):深层网络的原理
欢迎关注WX公众号:[程序员管小亮] 专栏--深度学习入门笔记 声明 1)该文章整理自网上的大牛和机器学习专家无私奉献的资料,具体引用的资料请看参考文献. 2)本文仅供学术交流,非商用.所以每一部分具 ...
- JavaScript学习(三十八)—面向过程与面向对象
JavaScript学习(三十八)-面向过程与面向对象 一.程序设计语言中的两大编程思想:面向对象.面向过程 (一).面向过程 就是指完成某个需求的时候,先分析出完成该需求时所需要经历的步骤有哪些,然 ...
- 深度学习入门计划第八周
深度学习入门计划第八周 学习时间 入门第八周:2023.6.26-2023.7.2 本周进度 完成项目套餐模块的开发 复习<动手学深度学习Pytorch版>第十章 遇到问题 对于开发的内容 ...
- 深度学习(三十九)LSTM、GRU网络入门学习-未完待续
LSTM入门学习 原文地址:http://blog.csdn.net/hjimce/article/details/51234311 作者:hjimce 一.相关理论 本篇博文主要讲解LSTM.GRU ...
- 深度学习(三十九)——深度强化学习(2)概述, Deep Q-learning Network(1)
概述 上图是深度强化学习的脉络图,参考文献中还有该领域的关键论文列表. 原图地址: http://louiskirsch.com/maps/reinforcement-learning 参考: htt ...
- 深度学习(三十二)——AlphaGo, AlphaStar
AlphaGo 樊麾讲解AlphaGo与李世石的五番棋: https://deepmind.com/research/alphago/alphago-games-simplified-chinese/ ...
最新文章
- 【重复制造精讲】Backflush 倒冲介绍
- C#反射基础理解1(转)
- HTML学习笔记:让div在屏幕居中,图片在div里居中
- Hibernate4实战 之 第二部分:Hibernate的基本配置
- 适用于苹果Mac的 4 个好用的 CAD 软件
- Arcgis3_地图符号制作与地图数据符号化
- 我java启蒙老师 郝斌老师
- 计算机桌面软件图标没了,手把手教你电脑桌面图标都不见了怎么办
- UFS Power Management 介绍
- 小米路由器mini刷linux,xiaomi mini路由器安装breed和openwrt固件
- Css3中align-content,css align-content属性怎么用
- 计算机集成牌照,车牌识别+证件识别嵌入式识别系统集成
- 关于vue项目中移动端实现用户选择照片、照片裁剪、一次上传多张图片功能。
- zoc for mac注册码
- 最多只需三步,彻底解决VB6中不能加载MSCOMCTL.OCX的提示
- 使用vue报错Cannot use ‘in‘ operator to search for
- networkx 画图中文方块
- 信息技术快速上手教程
- 使用运动控制卡,卡顿、蓝屏了怎么办?优易控提供更高级的解决方案
- warning: LF will be replaced by CRLF in 解决办法
热门文章
- 数学分析 重积分(第21章)1 二重积分,格林公式,曲线积分与路线无关性,三重积分
- 盘点一下国内外优秀的“低代码”开发平台
- converge和gtsuite联合仿真
- enzyme的三种渲染方式
- Spock单元测试踩坑
- 基础设施建设推动 Web3 未来
- 字节内部标配的鼠标垫火遍了编程圈,我粉丝每人包邮送1块!
- 哈利波特火了,伏地魔“活了“,网易游戏还是“千年老二“
- webpack中常见loader的作用和使用方法
- 大话西游2服务器维护多长时间,大话西游2所有服务器的开区时间要#17