文章目录

  • 1.查看GPU状态
  • 2.指定GPU
  • 3.张量与GPU
  • 4.神经网络指定GPU设备运行
  • 5.多GPU训练
  • 5.1 模型并行
  • 5.2 数据并行
  • 5.3 简单版数据并行
  • 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的数量

    def try_gpu(i=0):  #@save
        """如果存在,则返回gpu(i),否则返回cpu()"""
        if torch.cuda.device_count() >= i + 1:
            return torch.device(f'cuda:{i}')
        return torch.device('cpu')
    
    def try_all_gpus():  #@save
        """返回所有可用的GPU,如果没有GPU,则返回[cpu(),]"""
        devices = [torch.device(f'cuda:{i}')
                 for i in range(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的Z
    print(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]
    
    # 定义模型
    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')
    
    # 向多个设备分发参数并附加梯度
    def get_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。 请注意,我们需要将数据复制到累积结果的设备,才能使函数正常工作。

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

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

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

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

    def train_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 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]) # 在这里,我们使用全尺寸的小批量
    
    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)
    
    测试精度: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
    
    #@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上设置模型 (新版: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 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)}')
    
    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这么大,可能会抖动等
    

    来源:紫色银杏树

    物联沃分享整理
    物联沃-IOTWORD物联网 » pytorch使用GPU

    发表评论