8.4. 多GPU计算

本节中我们将展示如何使用多块GPU计算，例如，使用多块GPU训练同一个模型。正如所期望的那样，运行本节中的程序需要至少2块GPU。事实上，一台机器上安装多块GPU很常见，这是因为主板上通常会有多个PCIe插槽。如果正确安装了NVIDIA驱动，我们可以通过nvidia-smi命令来查看当前计算机上的全部GPU。

  1. In [1]:
  1. !nvidia-smi
  1. Mon May 13 00:33:22 2019
  2. +-----------------------------------------------------------------------------+
  3. | NVIDIA-SMI 410.48                 Driver Version: 410.48                    |
  4. |-------------------------------+----------------------+----------------------+
  5. | GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
  6. | Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
  7. |===============================+======================+======================|
  8. |   0  Tesla V100-SXM2...  On   | 00000000:00:1B.0 Off |                    0 |
  9. | N/A   59C    P0    44W / 300W |      0MiB / 16130MiB |      0%      Default |
  10. +-------------------------------+----------------------+----------------------+
  11. |   1  Tesla V100-SXM2...  On   | 00000000:00:1C.0 Off |                    0 |
  12. | N/A   52C    P0    72W / 300W |      0MiB / 16130MiB |      0%      Default |
  13. +-------------------------------+----------------------+----------------------+
  14. |   2  Tesla V100-SXM2...  On   | 00000000:00:1D.0 Off |                    0 |
  15. | N/A   43C    P0    43W / 300W |      0MiB / 16130MiB |      0%      Default |
  16. +-------------------------------+----------------------+----------------------+
  17. |   3  Tesla V100-SXM2...  On   | 00000000:00:1E.0 Off |                    0 |
  18. | N/A   42C    P0    41W / 300W |      0MiB / 16130MiB |      0%      Default |
  19. +-------------------------------+----------------------+----------------------+
  20.  
  21. +-----------------------------------------------------------------------------+
  22. | Processes:                                                       GPU Memory |
  23. |  GPU       PID   Type   Process name                             Usage      |
  24. |=============================================================================|
  25. |  No running processes found                                                 |
  26. +-----------------------------------------------------------------------------+

“自动并行计算”一节介绍过，大部分运算可以使用所有的CPU的全部计算资源，或者单块GPU的全部计算资源。但如果使用多块GPU训练模型，我们仍然需要实现相应的算法。这些算法中最常用的叫作数据并行。

8.4.1. 数据并行

数据并行目前是深度学习里使用最广泛的将模型训练任务划分到多块GPU的方法。回忆一下我们在“小批量随机梯度下降”一节中介绍的使用优化算法训练模型的过程。下面我们就以小批量随机梯度下降为例来介绍数据并行是如何工作的。

假设一台机器上有

8.4. 多GPU计算 - 图1 块GPU。给定需要训练的模型，每块GPU及其相应的显存将分别独立维护一份完整的模型参数。在模型训练的任意一次迭代中，给定一个随机小批量，我们将该批量中的样本划分成 8.4. 多GPU计算 - 图2 份并分给每块显卡的显存一份。然后，每块GPU将根据相应显存所分到的小批量子集和所维护的模型参数分别计算模型参数的本地梯度。接下来，我们把 8.4. 多GPU计算 - 图3 块显卡的显存上的本地梯度相加，便得到当前的小批量随机梯度。之后，每块GPU都使用这个小批量随机梯度分别更新相应显存所维护的那一份完整的模型参数。图8.1描绘了使用2块GPU的数据并行下的小批量随机梯度的计算。

使用2块GPU的数据并行下的小批量随机梯度的计算 图 8.1 使用2块GPU的数据并行下的小批量随机梯度的计算

为了从零开始实现多GPU训练中的数据并行，让我们先导入需要的包或模块。

  1. In [2]:
  1. import d2lzh as d2l
  2. import mxnet as mx
  3. from mxnet import autograd, nd
  4. from mxnet.gluon import loss as gloss
  5. import time

8.4.2. 定义模型

我们使用“卷积神经网络（LeNet）”一节里介绍的LeNet来作为本节的样例模型。这里的模型实现部分只用到了NDArray。

  1. In [3]:
  1. # 初始化模型参数
  2. scale = 0.01
  3. W1 = nd.random.normal(scale=scale, shape=(20, 1, 3, 3))
  4. b1 = nd.zeros(shape=20)
  5. W2 = nd.random.normal(scale=scale, shape=(50, 20, 5, 5))
  6. b2 = nd.zeros(shape=50)
  7. W3 = nd.random.normal(scale=scale, shape=(800, 128))
  8. b3 = nd.zeros(shape=128)
  9. W4 = nd.random.normal(scale=scale, shape=(128, 10))
  10. b4 = nd.zeros(shape=10)
  11. params = [W1, b1, W2, b2, W3, b3, W4, b4]
  12.  
  13. # 定义模型
  14. def lenet(X, params):
  15.     h1_conv = nd.Convolution(data=X, weight=params[0], bias=params[1],
  16.                              kernel=(3, 3), num_filter=20)
  17.     h1_activation = nd.relu(h1_conv)
  18.     h1 = nd.Pooling(data=h1_activation, pool_type='avg', kernel=(2, 2),
  19.                     stride=(2, 2))
  20.     h2_conv = nd.Convolution(data=h1, weight=params[2], bias=params[3],
  21.                              kernel=(5, 5), num_filter=50)
  22.     h2_activation = nd.relu(h2_conv)
  23.     h2 = nd.Pooling(data=h2_activation, pool_type='avg', kernel=(2, 2),
  24.                     stride=(2, 2))
  25.     h2 = nd.flatten(h2)
  26.     h3_linear = nd.dot(h2, params[4]) + params[5]
  27.     h3 = nd.relu(h3_linear)
  28.     y_hat = nd.dot(h3, params[6]) + params[7]
  29.     return y_hat
  30.  
  31. # 交叉熵损失函数
  32. loss = gloss.SoftmaxCrossEntropyLoss()

8.4.3. 多GPU之间同步数据

我们需要实现一些多GPU之间同步数据的辅助函数。下面的get_params函数将模型参数复制到某块显卡的显存并初始化梯度。

  1. In [4]:
  1. def get_params(params, ctx):
  2.     new_params = [p.copyto(ctx) for p in params]
  3.     for p in new_params:
  4.         p.attach_grad()
  5.     return new_params

尝试把模型参数params复制到gpu(0)上。

  1. In [5]:
  1. new_params = get_params(params, mx.gpu(0))
  2. print('b1 weight:', new_params[1])
  3. print('b1 grad:', new_params[1].grad)
  1. b1 weight:
  2. [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
  3. <NDArray 20 @gpu(0)>
  4. b1 grad:
  5. [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
  6. <NDArray 20 @gpu(0)>

给定分布在多块显卡的显存之间的数据。下面的allreduce函数可以把各块显卡的显存上的数据加起来，然后再广播到所有的显存上。

  1. In [6]:
  1. def allreduce(data):
  2.     for i in range(1, len(data)):
  3.         data[0][:] += data[i].copyto(data[0].context)
  4.     for i in range(1, len(data)):
  5.         data[0].copyto(data[i])

简单测试一下allreduce函数。

  1. In [7]:
  1. data = [nd.ones((1, 2), ctx=mx.gpu(i)) * (i + 1) for i in range(2)]
  2. print('before allreduce:', data)
  3. allreduce(data)
  4. print('after allreduce:', data)
  1. before allreduce: [
  2. [[1. 1.]]
  3. <NDArray 1x2 @gpu(0)>,
  4. [[2. 2.]]
  5. <NDArray 1x2 @gpu(1)>]
  6. after allreduce: [
  7. [[3. 3.]]
  8. <NDArray 1x2 @gpu(0)>,
  9. [[3. 3.]]
  10. <NDArray 1x2 @gpu(1)>]

给定一个批量的数据样本，下面的split_and_load函数可以将其划分并复制到各块显卡的显存上。

  1. In [8]:
  1. def split_and_load(data, ctx):
  2.     n, k = data.shape[0], len(ctx)
  3.     m = n // k  # 简单起见，假设可以整除
  4.     assert m * k == n, '# examples is not divided by # devices.'
  5.     return [data[i * m: (i + 1) * m].as_in_context(ctx[i]) for i in range(k)]

让我们试着用split_and_load函数将6个数据样本平均分给2块显卡的显存。

  1. In [9]:
  1. batch = nd.arange(24).reshape((6, 4))
  2. ctx = [mx.gpu(0), mx.gpu(1)]
  3. splitted = split_and_load(batch, ctx)
  4. print('input: ', batch)
  5. print('load into', ctx)
  6. print('output:', splitted)
  1. input:
  2. [[ 0.  1.  2.  3.]
  3.  [ 4.  5.  6.  7.]
  4.  [ 8.  9. 10. 11.]
  5.  [12. 13. 14. 15.]
  6.  [16. 17. 18. 19.]
  7.  [20. 21. 22. 23.]]
  8. <NDArray 6x4 @cpu(0)>
  9. load into [gpu(0), gpu(1)]
  10. output: [
  11. [[ 0.  1.  2.  3.]
  12.  [ 4.  5.  6.  7.]
  13.  [ 8.  9. 10. 11.]]
  14. <NDArray 3x4 @gpu(0)>,
  15. [[12. 13. 14. 15.]
  16.  [16. 17. 18. 19.]
  17.  [20. 21. 22. 23.]]
  18. <NDArray 3x4 @gpu(1)>]

8.4.4. 单个小批量上的多GPU训练

现在我们可以实现单个小批量上的多GPU训练了。它的实现主要依据本节介绍的数据并行方法。我们将使用刚刚定义的多GPU之间同步数据的辅助函数allreduce和split_and_load。

  1. In [10]:
  1. def train_batch(X, y, gpu_params, ctx, lr):
  2.     # 当ctx包含多块GPU及相应的显存时，将小批量数据样本划分并复制到各个显存上
  3.     gpu_Xs, gpu_ys = split_and_load(X, ctx), split_and_load(y, ctx)
  4.     with autograd.record():  # 在各块GPU上分别计算损失
  5.         ls = [loss(lenet(gpu_X, gpu_W), gpu_y)
  6.               for gpu_X, gpu_y, gpu_W in zip(gpu_Xs, gpu_ys, gpu_params)]
  7.     for l in ls:  # 在各块GPU上分别反向传播
  8.         l.backward()
  9.     # 把各块显卡的显存上的梯度加起来，然后广播到所有显存上
  10.     for i in range(len(gpu_params[0])):
  11.         allreduce([gpu_params[c][i].grad for c in range(len(ctx))])
  12.     for param in gpu_params:  # 在各块显卡的显存上分别更新模型参数
  13.         d2l.sgd(param, lr, X.shape[0])  # 这里使用了完整批量大小

8.4.5. 定义训练函数

现在我们可以定义训练函数了。这里的训练函数和“softmax回归的从零开始实现”一节定义的训练函数train_ch3有所不同。值得强调的是，在这里我们需要依据数据并行将完整的模型参数复制到多块显卡的显存上，并在每次迭代时对单个小批量进行多GPU训练。

  1. In [11]:
  1. def train(num_gpus, batch_size, lr):
  2.     train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
  3.     ctx = [mx.gpu(i) for i in range(num_gpus)]
  4.     print('running on:', ctx)
  5.     # 将模型参数复制到num_gpus块显卡的显存上
  6.     gpu_params = [get_params(params, c) for c in ctx]
  7.     for epoch in range(4):
  8.         start = time.time()
  9.         for X, y in train_iter:
  10.             # 对单个小批量进行多GPU训练
  11.             train_batch(X, y, gpu_params, ctx, lr)
  12.             nd.waitall()
  13.         train_time = time.time() - start
  14.  
  15.         def net(x):  # 在gpu(0)上验证模型
  16.             return lenet(x, gpu_params[0])
  17.  
  18.         test_acc = d2l.evaluate_accuracy(test_iter, net, ctx[0])
  19.         print('epoch %d, time %.1f sec, test acc %.2f'
  20.               % (epoch + 1, train_time, test_acc))

8.4.6. 多GPU训练实验

让我们先从单GPU训练开始。设批量大小为256，学习率为0.2。

  1. In [12]:
  1. train(num_gpus=1, batch_size=256, lr=0.2)
  1. running on: [gpu(0)]
  2. epoch 1, time 1.6 sec, test acc 0.10
  3. epoch 2, time 1.5 sec, test acc 0.70
  4. epoch 3, time 1.4 sec, test acc 0.73
  5. epoch 4, time 1.4 sec, test acc 0.78

保持批量大小和学习率不变，将使用的GPU数量改为2。可以看到，测试精度的提升同上一个实验中的结果大体相当。因为有额外的通信开销，所以我们并没有看到训练时间的显著降低。因此，我们将在下一节实验计算更加复杂的模型。

  1. In [13]:
  1. train(num_gpus=2, batch_size=256, lr=0.2)
  1. running on: [gpu(0), gpu(1)]
  2. epoch 1, time 2.6 sec, test acc 0.10
  3. epoch 2, time 2.4 sec, test acc 0.61
  4. epoch 3, time 2.3 sec, test acc 0.75
  5. epoch 4, time 2.3 sec, test acc 0.75

8.4.7. 小结

  • 可以使用数据并行更充分地利用多块GPU的计算资源，实现多GPU训练模型。
  • 给定超参数的情况下，改变GPU数量时模型的训练精度大体相当。

8.4.8. 练习

  • 在多GPU训练实验中，使用2块GPU训练并将batch_size翻倍至512，训练时间有何变化？如果希望测试精度与单GPU训练中的结果相当，学习率应如何调节？
  • 将实验的模型预测部分改为用多GPU预测。