目录
单机多卡并行
- 一台机器可以安装多个GPU（1~16个）
- 在训练和预测时，我们将一个小批量计算切分大多个GPU来达到加速目的
- 常用切分方案有
- 数据并行
- 模型并行
- 通道并行（数据 + 模型并行）
数据并行 VS 模型并行
-
数据并行：将小批量分成 n 份，每个GPU拿到完整参数计算的一小块数据的梯度
-
通常性能非常好
-
假如一个样本有 128 个数据，2 个GPU，每个GPU拿到 64 个样本，来计算这 64 个数据的梯度。每个GPU计算完这一块数据的梯度加起来，就会完成整个小批量数据的梯度计算
-
模型并行：将模型分成 n 快，每个GPU拿到一块模型计算它的前向和方向结果
-
通常用于模型大到单GPU放不下
-
假如模型有 100 层，2 块GPU，每个GPU拿到50层。第一个GPU算完把数据拿给第二个GPU算。BUG 就是性能难优化，基本就是第 0 个GPU在运行的时候第 1 个GPU就会空着
总结
-
当一个模型能用单卡计算时，通常使用数据并行拓展到多卡上
-
模型并行则用在超大模型上
-
有多种方法可以在多个GPU上拆分深度网络的训练。拆分可以在层之间、跨层或跨数据上实现。前两者需要对数据传输过程进行严格编排，而最后一种则是最简单的策略。
-
数据并行训练本身是不复杂的，它通过增加有效的小批量数据量的大小提高了训练效率。
-
在数据并行中，数据需要跨多个GPU拆分，其中每个GPU执行自己的前向传播和反向传播，随后所有的梯度被聚合为一，之后聚合结果向所有的GPU广播。
-
小批量数据量更大时，学习率也需要稍微提高一些。
代码实现
从零开始实现
%matplotlib inline
import torch
from torch import nn
from torch.nn import functional as F
from d2l imoort 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')向多个设备分发参数
对于高效的多GPU训练，我们需要两个基本操作。
- 我们需要向多个设备分发参数并附加梯度（
get_params）。 如果没有参数，就不可能在GPU上评估网络。 - 需要跨多个设备对参数求和，也就是说，需要一个
allreduce函数。
# （参数， 要存放参数的GPU）
def get_params(params, device):
# 新的参数就是把老参数clone（这里隐去，因为如果直接to，CPU to CPU不会有任何操作，但是clone的话就会有复制。），然后复制到GPU上
new_params = [p.to(device) for p in params]
for p in new_params:
p.requires_grad_() # 对每一个p都需要设定参数
return new_params
new_params = get_params(params, d2l.try_gpu(0))
print('b1 权重:', new_params[1])
print('b1 梯度:', new_params[1].grad) # 因为还没有做计算，所以grad应该是None
allreduce函数
将所有向量相加，并将其结果广播给所有GPU。请注意，我们需要将数据复制到累积结果的设备，才能使函数正常工作。
# data 是一个 list，有几个GPU，list就有几个元素
def allreduce(data):
for i in range(1, len(data)):
data[0][:] += data[i].to(data[0].device) # 先把数据复制到GPU0，然后相加
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])
将一个小批量数据均匀地分布在多个GPU上
我们需要一个简单的工具函数，将一个小批量数据均匀地分布在多个GPU上。 例如，有两个GPU时，我们希望每个GPU可以复制一半的数据。 因为深度学习框架的内置函数编写代码更方便、更简洁，所以在4×5矩阵上使用它进行尝试。
data = torch.arange(20).reshape(4, 5)
devices = [torch.device('cuda:0'), torch.device('cuda:1')]
split = nn.parallel.scatter(data, devices) # 用了API
print('input :', data)
print('load into', devices)
print('output:', split)
为了方便以后复用，我们定义了可以同时拆分数据和标签的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))训练
现在我们可以在一个小批量上实现多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( # w是完整的，x、y只是一块
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( # 对每一层的每个GPU，把梯度拿出来做 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]) # 在这里，我们使用全尺寸的小批量计算起来有一定的串联性，这时候就要看框架是否会帮你做自动并行了，如果框架好的话，这段代码是可以自动并行的（MXNet、Tensorflow是没问题的）
现在，我们可以定义训练函数。 与之前略有不同：训练函数需要分配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，刚开始每个GPU的梯度都是一样的（同步SGD思路）
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)}')简洁实现
import torch
from torch import nn
from d2l import torch as d2l让我们使用一个比从头实现的 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训练
主要API：nn.DataParallel(net, GPU_LIST)
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上设置模型 DataParallel用处是：返回的新net会被用于每个GPU（用来替换我们上面收订把每个参数发配到不同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)}')
扫一扫
1179
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
