精华内容
下载资源
问答
  • Data Parallel

    2020-12-01 14:56:06
    It looks like you have tried to use <code>nn.DataParallel</code> but didn't quite include it in there. Can you tell me your experience with it? <p>For some reason, the loss kept increasing when I...
  • DataParallel

    2020-11-26 01:26:19
    <div><ol> <p>if I use model.to(device) , one TPU or...<p>DataParallel(model, device_ids=devices) ,the code does not continue! </li></ol>该提问来源于开源项目:pytorch/xla</p></div>
  • Using data parallel

    2020-11-22 11:27:40
    <div><p>I tried to use data parallel to process the data. However, the training speed haven't go faster. I think the reason is that the LSTM and Linear layer is not suitable for data parallel. ...
  • pytorch 多GPU训练总结(DataParallel的使用)

    万次阅读 多人点赞 2019-02-28 18:35:52
    这里记录用pytorch 多GPU训练 踩过的许多坑 仅针对单服务器多gpu 数据并行 而不是 多机器分布式训练 一、官方思路包装模型 这是pytorch 官方的原理图 按照这个官方的原理...上文也用dataParallel 包装了optimize...

    这里记录用pytorch 多GPU训练 踩过的许多坑   仅针对单服务器多gpu 数据并行 而不是 多机器分布式训练

    一、官方思路包装模型

    官方原理图

    这是pytorch 官方的原理图  按照这个官方的原理图  修改应该参照

    https://blog.csdn.net/qq_19598705/article/details/80396325

    上文也用dataParallel 包装了optimizer, 对照官方原理图中第二行第二个,将梯度分发出去,将每个模型上的梯度更新(第二行第三个),然后再将更新完梯度的模型参数合并到主gpu(第二行最后一个步骤)

    其实完全没必要,因为每次前向传播的时候都会分发模型,用不着反向传播时将梯度loss分发到各个GPU,单独计算梯度,再合并模型。可以就在主GPU 上根据总loss 更新模型的梯度,不用再同步其他GPU上的模型,因为前向传播的时候会分发模型。

    所以 上述链接里 不用 dataParallel 包装 optimizer。       

    DataParallel并行计算只存在在前向传播

    总结步骤:

    import os
    import torch
    args.gpu_id="2,7" ; #指定gpu id
    args.cuda = not args.no_cuda and torch.cuda.is_available() #作为是否使用cpu的判定
    #配置环境  也可以在运行时临时指定 CUDA_VISIBLE_DEVICES='2,7' Python train.py
    os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu_id #这里的赋值必须是字符串,list会报错
    device_ids=range(torch.cuda.device_count())  #torch.cuda.device_count()=2
    #device_ids=[0,1] 这里的0 就是上述指定 2,是主gpu,  1就是7,模型和数据由主gpu分发
    
    if arg.cuda:
        model=model.cuda()  #这里将模型复制到gpu ,默认是cuda('0'),即转到第一个GPU 2
    if len(device_id)>1:
        model=torch.nn.DaraParallel(model);#前提是model已经.cuda() 了
    
    #前向传播时数据也要cuda(),即复制到主gpu里
    for batch_idx, (data, label) in pbar:   
        if args.cuda:
            data,label= data.cuda(),label.cuda();
        data_v = Variable(data)
        target_var = Variable(label)
        prediction= model(data_v,target_var,args)
        #这里的prediction 预测结果是由两个gpu合并过的,并行计算只存在在前向传播里
        #前向传播每个gpu计算量为 batch_size/len(device_ids),等前向传播完了将结果和到主gpu里
        #prediction length=batch_size
    
        criterion = nn.CrossEntropyLoss()
        loss = criterion(prediction,target_var) #计算loss
        optimizer.zero_grad()
        loss.backward()  
        optimizer.step()
    

    之后调用model里的函数 继承的函数可以直接调用 例如 model.state_dict() ,model.load_state_dict(torch.load(model_path)......不受影响。但是自己写的函数 要加上.module才行  model.module.forward_getfeature(x)。自己写的函数 不可以并行运算 ,只能在主gpu中运算。DataParallel并行计算仅存在在前向传播。但可以换个思路 写进forward 里或者被forward调用,多返回几个参数不就得了 return feature,predict

    二、解决多GPU 负载不均衡的问题

    我的经历是主gpu 显存爆了,而其他gpu显存只用了1/5,负载不均衡到不能忍,无法再加大batch_size

    参考:https://discuss.pytorch.org/t/dataparallel-imbalanced-memory-usage/22551/20(看了半天的英文才看懂。。。)

    负载不均衡的原因是     loss = criterion(prediction,target_var)  计算loss 占用了大量的内存,如果我们让每个gpu单独计算loss,再返回即可解决这个问题  即 prediction,loss=model(data,target)  (#如果后边不用prediction,连prediction也不用返回,只返回loss)。每个gpu返回一个loss,合到主gpu就是一个list,要loss.mean() 或loss.sum(),推荐mean.

    这样以来,所有可以在其他gpu中单独计算的都可以写进forward 里,返回结果即可。但要注意 tensor类型的数组 合并len会增加,例如prediction lenth=batchsize,但是loss这种具体的数字,合并就是list了[loss1.loss2]

    效果:主GPU 会稍微高一点。多个几百M,  但是基本实现了负载均衡

    例子:

      #model 里的forward 的函数
     def forward(self,x,target_var,args):
            feature512=self.forward_GetFeature(x)
            if target_var is None:
                return feature512;
            classifyResult = self.classifier(feature512)
            # 如果用DataParallel,forward返回feature 是返回多个GPU合并的结果
            # 每个GPU 返回 batchsize/n 个样本,n为GPU数
    
    
            #计算loss 
            center_loss = self.get_center_loss(feature512, target_var,args)
            criterion = nn.CrossEntropyLoss()
            cross_entropy_loss = criterion(classifyResult, target_var)
            #CrossEntropyLoss  已经求了softmax  分类结果直接输进去即可
    
            loss = args.center_loss_weight * center_loss + cross_entropy_loss
            prec = accuracy(classifyResult.data, target_var, topk=(1,))
            
            # 如果是返回的标量的话,那返回过去就是list,是n个GPU的结果
            # 要loss.mean() 之后 在loss.backward()
             return prec[0],loss

    三、全部代码:

    github地址:  face-recognition-supervised-by-center-loss

    这里介绍我训练的人脸识别模型,放到了github上,各位看官路过的可以点个star

    模型部分在model.py文件,即本文代码全部出自model.py。不过注释被我删掉了或者改成英文的了。

    评论区里有童鞋说我本文第一部分理解错了,可能吧,哈哈哈,不过代码应该是没错的,就是如何理解上的问题,我训练的结果是没有什么问题的。可放心食用。因为我现在不用pytorch也不做算法了,所以我就不仔细看了哈。

    展开全文
  • About Dataparallel

    2021-01-08 22:06:26
    (custom)dataparallel', is there anything that I have to know about its property when I want to add or remove some layers to the code? (multi GPU usage case) <p>Could you explain the following ...
  • DataParallel使用

    千次阅读 2019-06-08 15:46:00
    DataParallel' object has no attribute https://github.com/yysijie/st-gcn/issues/83 self.model.extract_feature -> self.model.module.extract_feature pytorch 多GPU训练总结(DataParallel的使用) ...

    DataParallel' object has no attribute

    https://github.com/yysijie/st-gcn/issues/83

    self.model.extract_feature -> self.model.module.extract_feature

    pytorch 多GPU训练总结(DataParallel的使用)

    https://blog.csdn.net/weixin_40087578/article/details/87186613

    if arg.cuda:
        model=model.cuda()  #这里将模型复制到gpu ,默认是cuda('0'),即转到第一个GPU 2
    if len(device_id)>1:
        model=torch.nn.DaraParallel(model);#前提是model已经.cuda() 了
    
    

     

    展开全文
  • 这里是改进了pytorch的DataParallel,使用了平衡第一个GPU的显存使用量 本代码来自transformer-XL: : 代码不是本人写的,但是感觉很好用,就分享一下。 怎么使用: 这个BalancedDataParallel类使用起来和Data...
  • DataParallel 笔记

    2020-09-25 23:41:41
    DataParallel if arg.cuda: model=model.cuda() #这里将模型复制到gpu ,默认是cuda('0'),即转到第一个GPU 2 if len(device_id)>1: model=torch.nn.DaraParallel(model);#前提是model已经....

    单GPU:

    import os
    os.environ["CUDA_VISIBLE_DEVICES"] = "0"

    多GPU:

    device_ids = [0,1,2,3]

    model = model.cuda(device_ids[0])
    model = nn.DataParallel(model, device_ids=device_ids)

    optimizer = optim.SGD(model.parameters(), lr=learning_rate, momentum=0.9, weight_decay=0.001)
    optimizer = nn.DataParallel(optimizer, device_ids=device_ids)

    optimizer.module.step()

    for param_lr in optimizer.module.param_groups:  # 同样是要加module
            #     param_lr['lr'] = param_lr['lr'] * 0.999


    加载多GPU预训练模型

    model = ft_net()
    pretained_model = torch.load('./model/all/8_model.pkl')
    pretained_dict = pretained_model.module.state_dict()
    model = ft_net()
    model.load_state_dict(pretained_dict)

    if torch.cuda.device_count() > 1:#判断是不是有多个GPU
        print("Let's use", torch.cuda.device_count(), "GPUs!")
        # 就这一行
        model = nn.DataParallel(model,device_ids=range(torch.cuda.device_count()))

     

    DataParallel 源码:

    1. if arg.cuda:

    2. model=model.cuda() #这里将模型复制到gpu ,默认是cuda('0'),即转到第一个GPU 2

    3. if len(device_id)>1:

    4. model=torch.nn.DaraParallel(model);#前提是model已经.cuda() 了

     

    在 pytorch 多GPU训练下,存储 整个模型 ( 而不是model.state_dict() )后再调用模型可能会遇到下面的情况:

    AttributeError: ‘DataParallel’ object has no attribute ‘xxxx’
    
    • 1

    解决的方法是:

    model = torch.load('path/to/model')
    if isinstance(model,torch.nn.DataParallel):
    		model = model.module
    
    #下面就可以正常使用了
    model.eval()
    展开全文
  • Pytorch DataParallel and DistributedDataParallel 最近试着使用Pytorch跑单机多卡训练,遇到了不少问题,做个总结和教程方便未来观看。我自己也是一个新手,很多东西总结的不好,有问题请多多指教,不懂的地方可以...

    Pytorch DataParallel and DistributedDataParallel

    最近试着使用Pytorch跑单机多卡训练,遇到了不少问题,做个总结和教程方便未来观看。我自己也是一个新手,很多东西总结的不好,有问题请多多指教,不懂的地方可以看参考文档,很多东西写的比我详细(本文只针对单机多卡训练,多机多卡训练未经过验证,请酌情观看)
    环境:
    python 3.7
    pytorch 1.4.0

    DataParallel

    DataParallel是官方最早提供的一个库,使用非常简单,一行就够了

    import torch.nn as nn
    
    device = torch.device("cuda")
    model = model.to(device)
    model = nn.DataParallel(model)
    

    DataParallel的缺点也很明显,只能在单台计算机上使用,而且速度很慢(相较于其他几种加速方式来说),最大的问题在于DataParallel采用了数据分布,但是loss是在某一块卡上计算的,这必然导致会出现比较严重的负载不均衡问题,其他卡用了很少的显存而主卡的显存使用很多,batch size稍微大一点主卡的显存就会炸了,因此更推荐使用其他的方式进行并行计算。

    DistributedDataParallel

    DistributedDataParallel(DDP)也是官方提供的一个并行计算库,相比于前者,该方式可以更好地进行多机多卡运算,更好的进行并行计算,负载均衡,运行效率也更高,支持的库和方法也更多,虽然使用起来较为麻烦,但对于追求性能来讲是一个更好的选择。

    DDP会自动将库分配给n个进程并在n个gpu上运行,loss的计算也是在各个gpu上进行的,很大程度上解决了分配不均衡的问题。

    模型设置

    • 调用init设置通信后端
      用于指定通信后端,一般设置nccl就可以,这是nvidia的GPU的参数设定,更具体的设定请参考官方文档。
    torch.distributed.init_process_group(backend='nccl')
    
    • 添加local_rank参数
      local rank是为了DDP运行的时候进行节点进程制定,这个参数设定进去就可以,我们在自己进行计算时不需要人为给定参数,调用启动器的时候会自动设置
    parser = argparse.ArgumentParser()
    parser.add_argument('--local_rank', default=-1, type=int,
                        help='node rank for distributed training')
    args = parser.parse_args()
    
    • 对dataloader设置sampler
      数据传递的时候需要将数据分发给不同的GPU,需要在dataloader里指定sampler进行分发,注意制定了sampler的话shuffle就没用了,不要赋值
    train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset)
    
    train_loader = torch.utils.data.DataLoader(train_dataset, ...your args..., sampler=train_sampler)
    
    • 模型包装
      最后使用模型把数据加载到GPU中,进行反向传播
    model = Yourmodel(...)
    model.cuda()
    model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.local_rank], output_device=[args.local_rank])
    

    其余部分的使用和正常的网络训练过程是一样的,正常设置输入输出,optimizer,计算loss。loss部分会自动根据GPU进行分发计算,正常调用loss.backward()即可,不需要额外指定loss的parallel。

    模型保存加载

    这部分挺坑的,之前在网上找了一些代码,但是在自己的电脑上用的时候都用问题,这里最后用的是官方的一份代码,需要用到cpu进行一些转载,但是没什么bug

    • 模型保存
      模型的保存和正常的有点区别,在用DDP(DataParallel也是一样)进行封装后,原有的模型已经被封装起来了,在运行的时候进行分发,模型保存在model.module模块,一种比较方便的办法是保存这部分原始模型,这里列举了只保存参数的方法,保存网络的方法,也是同理的,去掉state_dict()即可
    model_without_ddp = model.module
    checkpoint = torch.save(model_without_ddp.state_dict(),PATH)
    
    • 模型加载

      • 多卡加载
        多卡加载一般用于模型训练中断了以后重训练的方式,需要使用map_location这一参数指定网络模型的加载情况,一些教程推荐使用cuda的方式加载,但我在实验的时候总会出现进程上的错误,这里我采用了官方的一种cpu加载方式。
        这里的加载方式是保存时保存原始模型,加载时也加载原始模型,通过修改DDP模型中的module模块使得网络的模型被赋值,免去了在GPU上加载的问题。
      model = Yourmodel(...)
      model.cuda()
      model = nn.parallel.DistributedDataParallel(model, device_ids=[args.local_rank], output_device=[args.local_rank])
      # save checkpoint
      model_without_ddp = model.module
      checkpoint = torch.save({'model_state_dict':model_without_ddp.state_dict()},PATH)
      
      #load checkpoint with multiple GPUs
      if args.resume == True:
          resume_file = torch.load('checkpoint.pth.tar', map_location="cpu")
          model_without_ddp.load_state_dict(resume_file['model_state_dict'])
      
      • 单卡加载
        单卡加载一般用于进行测试的时候只需要用一块卡测试,这时候我们就需要制定用某一块卡进行数据加载了,其实理论上是差不多的,只是修改一点参数
      model = Yourmodel(...)
      model.cuda()
      model = nn.parallel.DistributedDataParallel(model, device_ids=[args.local_rank], output_device=[args.local_rank])
      
      # save checkpoint
      model_without_ddp = model.module
      checkpoint = torch.save({'model_state_dict':model_without_ddp.state_dict()},PATH)
      
      #load checkpoint with single GPU
      if args.test == True:
          model_test = Yourmodel(...) #notice that your model don't need parallel here
          model_test.eval()
          model_test.cuda()
          resume_file = torch.load('checkpoint.pth.tar', map_location="cuda:0")
          model_test.load_state_dict(resume_file['model_state_dict'])
      

    代码运行

    代码运行过程中,需要调用DDP对应的启动器,nproc_per_node一般设置为你用于训练的节点数量即可,有4块卡就设置为4

    python -m torch.distributed.launch --nproc_per_node=YOUR_GPU_NUM yourscript.py
    

    参考文档

    1.pytorch官方的一个教程以及其部分中文翻译
    2.本文的部分行文逻辑来源及其他几种数据并行方法的说明
    3.pytorch官方的segmentation文档,内部使用了DDP(直接搜索args.resume)
    4.并行原理解释,也有代码,介绍的很详细
    5.简明教程,里面也有官方的一些链接,可以参考
    6.介绍了一些其他的部分,可以适当参考

    展开全文
  • nn.DataParallel(actor_critic.act(Variable(rollouts.states[step], volatile=True))) File "/home/ajay/anaconda3/envs/py35_pytorch/lib/python3.5/site-packages/torch/nn/parallel/data_parallel.py...
  • DataParallel(model)的相关研究 前提/已知:DataParallel用于多GPU并行计算, 问题:那如果先用2个GPU来 training DataParallel(model)并保存权重,再load该权重到使用4个GPU来 training 的 DataParallel(model) 上...
  • is torchmeta compatible with dataparallel? I have troubles training a MetaModule wrapped by dataparallel. It seems get_subdict has problems with the layer names starting with "module." Thanks ...
  • 1. 报错PyTorch DataParallel RuntimeError: expected device cuda:1 but got device cuda:0 原因是直接使用了DataParallel作为神经网络。 # 可能报错的写法 model = DataParallel(Res_Net()) out = model(input) #...
  • distributed dataparallel need at least 1.6TB. am i right? i have only 512GB ram. so i need to use data parallel. in same code dataparallel without apex works normally. also distribued dataparallel ...
  • Pytorch的nn.DataParallel

    千次阅读 2020-08-23 19:10:04
    在多卡的GPU服务器,当我们在上面跑程序的时候,当迭代次数或者epoch足够大的时候,我们通常会使用nn.DataParallel函数来用多个GPU来加速训练。一般我们会在代码中加入以下这句: device_ids = [0, 1] ...
  • 1. 如何使模型在多个卡上进行运算 ... Model = torch.nn.Dataparallel( Model, [0,1,2,3]) # [0,1,2,3] 是可使用的gpu id 2. Dataparallel的原理 ① 将模型的参数拷贝至多个显卡 ②将数据按照batch平均分给各
  • Data Parallel for PWC-Net

    2020-12-28 20:19:28
    However, presently I am trying to use your model into my work, and I found this network cannot be warped in the data parallel module. Therefore, it can not profit multi-GPUs. I think the error is ...
  • 1.DataParallel DataParallel更易于使用(只需简单包装单GPU模型)。然而,由于它使用一个进程来计算模型权重,然后在每个批处理期间将分发到每个GPU,因此通信很快成为一个瓶颈,GPU利用率通常很低。 nn.Data...
  • 仅作为记录,大佬请跳过。 DataParallel便于gpu并行进行。 引入模型采用: image = Variable(images[:, j, :, :].unsqueeze(0).cuda()) output = model(image.cuda()) print(output)
  • 之前对Pytorch 1.0 的Dataparallel的使用方法一直似懂非懂,总是会碰到各种莫名其妙的问题,今天就好好从源头梳理一下,更好地理解它的原理或者说说下步骤。 源码地址: ...
  • PyTorch数据并行nn.DataParallel

    万次阅读 2019-08-29 14:38:24
    仅使用nn.DataParallel,gpu0和gpu1、gpu0和gpu2、gpu0和gpu3等包含gpu0的组合都是可以的,其余组合不行,报错RuntimeError: module must have its parameters and buffers on device cuda:1 (device_ids[0]) but ...
  • 经过实验,DataParallel和cuda的使用没有固定顺序,不管是先DataParallel还是先cuda都ok,但是这两句话都不能少
  • pytorch DataParallel 多GPU训练

    千次阅读 2018-11-01 10:48:43
    当一台服务器有多张GPU时,运行程序默认在一张GPU上运行...from torch.nn import DataParallel num_gpu = torch.cuda.device_count() net = DataParallel(net, device_ides=range(num_gpu)) device_ides默认情况下...
  • 模型用DataParallel包装一下: device_ids = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # 10卡机 model = torch.nn.DataParallel(model, device_ids=device_ids) # 指定要用到的设备 model = model.cuda(device=device_ids[0...
  • 文章目录开始使用DISTRIBUTED DATA PARALLELComparison between `DataParallel` and `DistributedDataParallel`Basic Use CaseSkewed Processing SpeedsSave and Load CheckpointsCombine DDP with Model ...
  • : Can you give any leads on how to load DataParallel GPU model on CPU? As per pytorch docs tried following but still raises above RuntimeError <pre><code>python device = torch.device('cpu'...
  • <div><p>I used mynn.DataParallel during inference but found it costs lots of cpu. <p>How can I do inference without mynn.DataParallel?</p><p>该提问来源于开源项目:roytseng-tw/Detectron.pytorch...
  • pytorch单机多卡:从DataParallel到distributedDataParallel

    千次阅读 多人点赞 2020-03-22 04:09:44
    pytorch单机多卡:从DataParallel到distributedDataParallel 最近想做的实验比较多,于是稍微学习了一下和pytorch相关的加速方式。本人之前一直在使用DataParalle

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,353
精华内容 3,741
关键字:

dataparallel