%matplotlib inline
import torch
from torch import nn
from torch.nn import functional as F
from d2l import torch as d2l
简单网络
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):'''使用functional定义LeNet'''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)# torch.mm 数学矩阵乘法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')
向多个设备分发参数
def get_params(params, device):'''将参数都放到指定设备上,并要求新设备上的参数计算梯度'''# 参数原来就在gpu上,没有clone() ,不会做任何操作# new_params = [p.clone().to(device) for p in params]new_params = [p.to(device) for p in params]# 需要对每个参数求梯度for p in new_params:# !重要,要求新设备上的参数计算梯度p.requires_grad_()return new_params#
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
def allreduce(data):'''map-reduce:param data 梯度列表 不同设备得出的梯度'''# 将所有数据累加到第0个数据上for i in range(1, len(data)):# 相加到同一个gpu上data[0][:] += data[i].to(data[0].device)# 将累加结果广播给原数据所在gpu,并将原变量赋值为累加结果值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')
将一个小批量数据均匀地分布在多个GPU上
data = torch.arange(20).reshape(4, 5)
devices = [torch.device('cuda:0'), torch.device('cuda:1')]
# 并行 分散器 样本均匀切开,余数放到最后1个gpu上
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'))
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训练
def train_batch(X, y, device_params, devices, lr):# 将X和y拆分到多个设备上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:l.backward()# 梯度# 累加不同设备上的梯度,并将结果广播给所有GPU# 进入with,自动进入with后的部分(__entor__())# 退出with,自动退出with后的部分(__exit__())with torch.no_grad():for i in range(len(device_params[0])):allreduce([device_params[c][i].grad for c in range(len(devices))])# 优化函数# 对不同设备上的参数,调用相同的优化函数for param in device_params:d2l.sgd(param, lr, X.shape[0])
定义训练函数
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)]# 参数device_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:train_batch(X, y, device_params, devices, lr)# 同步 等待torch.cuda.synchronize()timer.stop()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个GPU上运行
train(num_gpus=1, batch_size=256, lr=0.2)
测试精度:0.84,2.7秒/轮,在[device(type='cuda', index=0)]
在2个GPU上运行
# 多gpu数据并行训练,速度没有变快
# 原因1:数据IO时间>>计算时间
# 原因2:小批量被切成数据块,每个gpu处理的数据变少,不能充分利用gpu的计算能力。
# 处理2:还是保证每个gpu拿到相同大小的mini_batch_size,加大lr
# 原因3:从0开始写的代码,pytorch 不能很好的多gpu
# 原因4:LeNet网络模型容量小,复杂度不够
train(num_gpus=2, batch_size=256*2, lr=0.2)
测试精度:0.78,4.3秒/轮,在[device(type='cuda', index=0), device(type='cuda', index=1)]
总结
单设备训练
- 数据
- 模型
- 参数
- 超参数
- 损失函数
- 优化函数
- 训练
– 前向传播
– 后向传播
多设备训练
- 数据
- 设备,设备数量
- 模型,模型相同
- 参数,参数相同,将参数放到不同设备上
- 超参数
- 损失函数
- 优化函数
- 训练,小批量数据切分到不同设备上
– 前向传播,不同数据,相同参数,相同模型,在不同设备上运行
– 后向传播,不同数据,相同参数,相同模型,在不同设备上运行
– 累加不同设备上计算出来的梯度,并将累加结果广播给不同设备
多设备训练过程:
- 获取数据
- 获取设备
- 将相同参数放到不同设备上
- 将小批量数据分出不同数据块放到不同设备上
- 在不同设备上使用相同模型,相同参数,不同数据块计算损失函数值,获取多个损失函数值
- 在不同设备上计算损失的梯度,获取多个梯度值
- 累加不同设备上计算出来的梯度,并将累加结果广播给不同设备
- 在不同设备上调用相同优化函数优化相同的参数
- goto 4