一 多GPU训练

下面详细介绍如何从零开始并行地训练网络，这里需要运用小批量随机梯度下降算法。后面我还讲介绍如何使用高级API并行训练网络。

我们从一个简单的计算机视觉问题和一个稍稍过时的网络开始。这个网络有多个卷积层和汇聚层，最后可能 有几个全连接的层，看起来非常类似于LeNet (LeCun et al., 1998)或AlexNet (Krizhevsky et al., 2012)。假设我们有多个GPU（如果是桌面服务器则有2个，AWS g4dn.12xlarge上有4个，p3.16xlarge上有8个，p2.16xlarge上 有16个）。我们希望以一种方式对训练进行拆分，为实现良好的加速比，还能同时受益于简单且可重复的设计 选择。毕竟，多个GPU同时增加了内存和计算能力。简而言之，对于需要分类的小批量训练数据，我们有以下选择。

第一种方法，在多个GPU之间拆分网络。也就是说，每个GPU将流入特定层的数据作为输入，跨多个后续层 对数据进行处理，然后将数据发送到下一个GPU。与单个GPU所能处理的数据相比，我们可以用更大的网络 处理数据。此外，每个GPU占用的显存（memory footprint）可以得到很好的控制，虽然它只是整个网络显 存的一小部分。

第二种方法，拆分层内的工作。例如，将问题分散到4个GPU，每个GPU生成16个通道的数据，而不是在单 个GPU上计算64个通道。对于全连接的层，同样可以拆分输出单元的数量。其策略用于处理显存非常小（当时为2GB）的GPU。当通道或单元的数量不太小时，使计算性能有良好的提升。此外，由于可用的显存呈线性扩展，多个GPU能够处理不断变大的网络。

假设一台机器有k个GPU。给定需要训练的模型，虽然每个GPU上的参数值都是相同且同步的，但是每个GPU都 将独立地维护一组完整的模型参数。

一般来说，k个GPU并行训练过程如下：

• 在任何一次训练迭代中，给定的随机的小批量样本都将被分成k个部分，并均匀地分配到GPU上；
• 每个GPU根据分配给它的小批量子集，计算模型参数的损失和梯度；
• 将k个GPU中的局部梯度聚合，以获得当前小批量的随机梯度；
• 聚合梯度被重新分发到每个GPU中；
• 每个GPU使用这个小批量随机梯度，来更新它所维护的完整的模型参数集。

1.1 简单网络

在实践中请注意，当在k个GPU上训练时，需要扩大小批量的大小为k的倍数，这样每个GPU都有相同的工作量，就像只在单个GPU上训练一样。因此，在16‐GPU服务器上可以显著地增加小批量数据量的大小，同时可 能还需要相应地提高学习率。

%matplotlib inline
import torch
from torch import nn
from torch.nn import functional as F
from d2l import torch as d2l

我们使用 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 数据同步

对于高效的多GPU训练，我们需要两个基本操作。首先，我们需要向多个设备分发参数并附加梯度 （get_params）。如果没有参数，就不可能在GPU上评估网络。第二，需要跨多个设备对参数求和，也就是说，需要一个allreduce函数。

def get_params(params, device):
    new_params = [p.to(device) for p in params]
    for p in params:
        p.requires_grad_()
    return new_params

new_params = get_params(params, d2l.try_gpu(0))
print(f'b1 权重：{new_params[1]}')
print(f'b1 梯度：{new_params[1].grad}')

由于还没有进行任何计算，因此权重参数的梯度仍然为零。假设现在有一个向量分布在多个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(f'allreduce 之前：\n', data[0], '\n', data[1])
allreduce(data)
print('allreduce 之后：\n', data[0], '\n', data[1])

1.3 数据分发

我们需要一个简单的工具函数，将一个小批量数据均匀地分布在多个GPU上。例如，有两个GPU时，我们希望每个GPU可以复制一半的数据。因为深度学习框架的内置函数编写代码更方便、更简洁，所以在4 × 5矩阵 上使用它进行尝试。

data = torch.arange(20).reshape(4, 5)
devices = [torch.device('cuda:0'), torch.device('cuda:0')]
split = nn.parallel.scatter(data, devices)
print('input:', data)
print('load into:', device)
print('output:', split)

为了方便以后复用，我们定义了可以同时拆分数据和标签的split_batch函数。

#@save
def split_batch(X, y, devices):
    assert X.shape[0] == y.shape[0]
    return (nn.parallel.scatter(x, devices),
           nn.parallel.scatter(y, devices))

1.4 执行训练

现在我们可以在一个小批量上实现多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]) # 在这里，我们使用全尺寸的小批量

现在，我们可以定义训练函数。与前几章中略有不同：训练函数需要分配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)}')

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

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

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

小结：

• 有多种方法可以在多个GPU上拆分深度网络的训练。拆分可以在层之间、跨层或跨数据上实现。前两者需要对数据传输过程进行严格编排，而最后一种则是最简单的策略。
• 数据并行训练本身是不复杂的，它 通过增加有效的小批量数据量的大小提高了训练效率。
• 在数据并行中，数据需要跨多个GPU拆分，其中每个GPU执行自己的前向传播和反向传播，随后所有的 梯度被聚合为一，之后聚合结果向所有的GPU广播。
• 小批量数据量更大时，学习率也需要稍微提高一些。

二 多GPU的简洁实现

每个新模型的并行计算都从零开始实现是无趣的。此外，优化同步工具以获得高性能也是有好处的。下面我 们将展示如何使用深度学习框架的高级API来实现这一点。

import torch
from torch import nn
from d2l import torch as d2l

它依然能够容易地和快速地训练。我们选择的是 (He et al., 2016)中的ResNet‐18。因为输入的图像很小，所以稍微修改了一下。我们在开始时使用了更小的卷积核、步长和填充，而且删除了最大汇聚层。

#@save
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

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

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

如前所述，用于训练的代码需要执行几个基本功能才能实现高效并行：

• 需要在所有设备上初始化网络参数；
• 在数据集上迭代时，要将小批量数据分配到所有设备上；
• 跨设备并行计算损失及其梯度；
• 聚合梯度，并相应地更新参数。 最后，并行地计算精确度和发布网络的最终性能。除了需要拆分和聚合数据外，训练代码与前几章的实现非 常相似。

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)}')

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

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

接下来我们使用2个GPU进行训练。

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

小结：

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

三 多机训练

新的挑战出现在多台机器上进行分布式训练：我们 需要服务器之间相互通信，而这些服务器又只通过相对较低的带宽结构连接，在某些情况下这种连接的速度可能会慢一个数量级，因此跨设备同步是个棘手的问题。 毕竟，在不同机器上运行训练代码的速度会有细微的差别，因此如果想使用分布式优化的同步算法就需要同 步（synchronize）这些机器。

1. 在每台机器上读取一组（不同的）批量数据，在多个GPU之间分割数据并传输到GPU的显存中。基于每个GPU上的批量数据分别计算预测和梯度。
2. 来自一台机器上的所有的本地GPU的梯度聚合在一个GPU上（或者在不同的GPU上聚合梯度的某些部 分）。
3. 每台机器的梯度被发送到其本地CPU中。
4. 所有的CPU将梯度发送到中央参数服务器中，由该服务器聚合所有梯度。
5. 然后使用聚合后的梯度来更新参数，并将更新后的参数广播回各个CPU中。
6. 更新后的参数信息发送到本地一个（或多个）GPU中。
7. 所有GPU上的参数更新完成。