深度学习入门（三十八）计算性能——多GPU训练

前言

核心内容来自博客链接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
  1
  2
  3
  4
  5

  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')
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28

  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
  1
  2
  3
  4
  5

  通过将模型参数复制到一个GPU。

  new_params = get_params(params, d2l.try_gpu(0))
  print('b1 权重:', new_params[1])
  print('b1 梯度:', new_params[1].grad)
  1
  2
  3

  输出：

  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
  1
  2
  3

  由于还没有进行任何计算，因此权重参数的梯度仍然为零。 假设现在有一个向量分布在多个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)
  1
  2
  3
  4
  5

  通过在不同设备上创建具有不同值的向量并聚合它们。

  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])
  1
  2
  3
  4

  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')
  1
  2
  3
  4
  5
  6

  5 数据分发

  我们需要一个简单的工具函数，将一个小批量数据均匀地分布在多个GPU上。 例如，有两个GPU时，我们希望每个GPU可以复制一半的数据。 因为深度学习框架的内置函数编写代码更方便、更简洁，所以在$4\times 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)
  1
  2
  3
  4
  5
  6

  输出：

  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'))
  1
  2
  3
  4
  5
  6
  7
  8

  为了方便以后复用，我们定义了可以同时拆分数据和标签的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))
  1
  2
  3
  4
  5

  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的所有梯度相加，并将其广播到所有GPU
      with 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]) # 在这里，我们使用全尺寸的小批量
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

  现在，我们可以定义训练函数。 与前几章中略有不同：训练函数需要分配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个GPU
      device_params = [get_params(params, d) for d in devices]
      num_epochs = 10
      animator = 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)}')
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20

  让我们看看在单个GPU上运行效果得有多好。 首先使用的批量大小是256，学习率是0.2。

  train(num_gpus=1, batch_size=256, lr=0.2)
  1

  输出

  测试精度：0.80，2.7秒/轮，在[device(type='cuda', index=0)]
  1

  

  保持批量大小和学习率不变，并增加为2个GPU，我们可以看到测试精度与之前的实验基本相同。 不同的GPU个数在算法寻优方面是相同的。 不幸的是，这里没有任何有意义的加速：模型实在太小了；而且数据集也太小了，在这个数据集中，我们实现的多GPU训练的简单方法受到了巨大的Python开销的影响。 在未来，我们将遇到更复杂的模型和更复杂的并行化方法。 尽管如此，让我们看看Fashion-MNIST数据集上会发生什么。

  train(num_gpus=2, batch_size=256, lr=0.2)
  1

  输出

  测试精度：0.84，2.8秒/轮，在[device(type='cuda', index=0), device(type='cuda', index=1)]
  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
  2
  3

  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
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27

  2 网络初始化

  我们将在训练回路中初始化网络。

  net = resnet18(10)
  # 获取GPU列表
  devices = d2l.try_all_gpus()
  # 我们将在训练代码实现中初始化网络
  1
  2
  3
  4

  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(), 10
      animator = 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)}')
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26

  让我们看看这在实践中是如何运作的。我们先在单个GPU上训练网络进行预热。

  train(net, num_gpus=1, batch_size=256, lr=0.1)
  1

  输出：

  测试精度：0.92，13.7秒/轮，在[device(type='cuda', index=0)]
  1

  
  接下来我们使用2个GPU进行训练。与上文中评估的LeNet相比，ResNet-18的模型要复杂得多。这就是显示并行化优势的地方，计算所需时间明显大于同步参数需要的时间。因为并行化开销的相关性较小，因此这种操作提高了模型的可伸缩性。

  train(net, num_gpus=2, batch_size=512, lr=0.2)
  1

  输出：

  测试精度：0.89，8.4秒/轮，在[device(type='cuda', index=0), device(type='cuda', index=1)]
  1

  

  4 小结

  1、神经网络可以在（可找到数据的）单GPU上进行自动评估。
  2、每台设备上的网络需要先初始化，然后再尝试访问该设备上的参数，否则会遇到错误。
  3、优化算法在多个GPU上自动聚合。