pytorch使用GPU

文章目录

1.查看GPU状态

# jupyter
!nvidia-smi

一个GPU一共16130M显存，0号GPU已使用3446M显存，一般GPU的利用率低于50%，往往这个模型可能有问题，或者batch_size太小。

本机CUDA版本，在安装驱动时应该注意选择对应版本的驱动。

2.指定GPU

import torch
from torch import nn

torch.device('gpu'), torch.cuda.device('cuda'), torch.cuda.device('cuda:1')

指定计算设备为GPU，使用多个GPU，本代码指定了第0号和第1号GPU设备

torch.cuda.device_count()

查询GPU的数量

deftry_gpu(i=0):#@save"""如果存在，则返回gpu(i)，否则返回cpu()"""if torch.cuda.device_count()>= i +1:return torch.device(f'cuda:{i}')return torch.device('cpu')deftry_all_gpus():#@save"""返回所有可用的GPU，如果没有GPU，则返回[cpu(),]"""
    devices =[torch.device(f'cuda:{i}')for i inrange(torch.cuda.device_count())]return devices if devices else[torch.device('cpu')]# 0号GPU是否存在，10号GPU是否存在
try_gpu(), try_gpu(10), try_all_gpus()

3.张量与GPU

两个在不在同一个GPU的张量需要将这两个张量放在同一个GPU上运算，否则会发生异常。

# 创建一个张量Y在1号GPU
Y = torch.rand(2,3, device=try_gpu(1))

Z = X.cuda(1)# 将X的内容复制在1号GPU的Zprint(X)print(Z)

tensor([[1.,1.,1.],[1.,1.,1.]], device='cuda:0')
tensor([[1.,1.,1.],[1.,1.,1.]], device='cuda:1')

4.神经网络指定GPU设备运行

net = nn.Sequential(nn.Linear(3,1))
net = net.to(device=try_gpu(2))# 指定2号GPU运行

net1 = nn.Sequential(nn.Linear(3,1))
net1 = net1.to(device=try_gpu(3))# 指定3号GPU运行

确认模型参数存储在同一个GPU上。

net[0].weight.data.device

小结：

• 当显存不够时，可以将模型参数变小，降低模型层数，还可以将数据预处理等部分在CPU运行，在数据输入模型之前再把数据放到GPU中，进行前向计算反向传播。
• 当GPU性能提升不明显时，可能是GPU配置没有成功，或者是数据在CPU和GPU之间移动太频繁，batch_size等。

5.多GPU训练

5.1 模型并行

方法一：在多个GPU之间拆分网络
比如将网络模型的前半部分和后半部分放在两块不同的GPU上运算，两个部分的数据可跨GPU传输。
局限：层之间计算的工作负载不能正确匹配的时候， 还有层之间的接口需要大量的数据传输的时候（例如：激活值和梯度，数据量可能会超出GPU总线的带宽），除非存在框架或操作系统本身支持将多个GPU连接在一起，否则不建议这种方法。

** 方法二：拆分层内的工作**

5.2 数据并行

将小批量分成n块，每个GPU拿到完整参数计算一块数据的梯度。

%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]# 定义模型deflenet(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')# 向多个设备分发参数并附加梯度defget_params(params, device):
    new_params =[p.to(device)for p in params]for p in new_params:
        p.requires_grad_()return new_params

# 将模型参数复制个GPU0
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上，下面的allreduce函数将所有向量相加，并将结果广播给所有GPU。 请注意，我们需要将数据复制到累积结果的设备，才能使函数正常工作。

defallreduce(data):# 将除GPU0外的所有GPU上的向量全部加到GPU0，GPU0中有所有向量之和for i inrange(1,len(data)):
        data[0][:]+= data[i].to(data[0].device)# 将GPU0中的向量复制到其他GPU中，因此每个GPU都有所有的向量for i inrange(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 inrange(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')]
split = nn.parallel.scatter(data, devices)print('input :', data)print('load into', devices)print('output:', split)

同时拆分数据和标签的split_batch函数

#@savedefsplit_batch(X, y, devices):"""将X和y拆分到多个设备上"""assert X.shape[0]== y.shape[0]return(nn.parallel.scatter(X, devices),
            nn.parallel.scatter(y, devices))

模型训练
看起来是串行运行的，但是如果框架在背后能帮我们做并发运行的话，还是并发运行的。

deftrain_batch(X, y, device_params, devices, lr):# 拆分数据和标签到每个GPU
    X_shards, y_shards = split_batch(X, y, devices)# 在每个GPU上分别计算损失
    ls =[loss(lenet(X_shard, device_W), y_shard).sum()# loss求和for X_shard, y_shard, device_W inzip(
              X_shards, y_shards, device_params)]for l in ls:# 反向传播在每个GPU上分别执行
        l.backward()# 将每个GPU的所有梯度相加，并将其广播到所有GPUwith torch.no_grad():for i inrange(len(device_params[0])):
            allreduce([device_params[c][i].grad for c inrange(len(devices))])# 在每个GPU上分别更新模型参数for param in device_params:
        d2l.sgd(param, lr, X.shape[0])# 在这里，我们使用全尺寸的小批量

deftrain(num_gpus, batch_size, lr):
    train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
    devices =[d2l.try_gpu(i)for i inrange(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 inrange(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)

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

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

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

当增加GPU并行数量时，精度和速度可能不会增加，或者不会增加很多甚至会减少，为什么呢。一方面是GPU增加了，但是batch_size没有增加，反而每个GPU处理的样本数减少到了原来的一半，batch_size减少，GPU效率变低，每个GPU性能没有完全发挥，因此精度和速度可能会变低。为了缓解这一现象，将每个GPU的batch_size放大一倍，但是结果可能也不会很好，再将学习率发大1.5倍，结果稍有好转。

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

但是这样精度和速度没有比一个GPU的情况好很多，老师总结的原因是pytorch这样裸手写的方式对并行加速的优化不够好，第二个可能是lenet网络性能不够好。

5.3 简单版数据并行

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

#@savedefresnet18(num_classes, in_channels=1):"""稍加修改的ResNet-18模型"""defresnet_block(in_channels, out_channels, num_residuals,
                     first_block=False):
        blk =[]for i inrange(num_residuals):if i ==0andnot 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()# 我们将在训练代码实现中初始化网络deftrain(net, num_gpus, batch_size, lr):
    train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
    devices =[d2l.try_gpu(i)for i inrange(num_gpus)]definit_weights(m):iftype(m)in[nn.Linear, nn.Conv2d]:
            nn.init.normal_(m.weight, std=0.01)
    net.apply(init_weights)# 在多个GPU上设置模型 （新版：DistributuedDataParallel()可去官方文档学习）
    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 inrange(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)}')

train(net, num_gpus=1, batch_size=256, lr=0.1)# train(net, num_gpus=2, batch_size=512, lr=0.2)# 在很多情况下多GPU可能并不一定比单个GPU好，还需要经过多次调参以合理的使用GPU资源。# 数据集较少的情况下，batch_size不应该设为512这么大,可能会抖动等