Pytorch | GPU | 将代码加载到GPU上运行

Pytorch | GPU | 将代码加载到GPU上运行


“I think if you do something and it turns out pretty good, then you should go do something else wonderful, not dwell on it for too long. Just figure out what’s next.”
——Steve Jobs


❤️流程

  • 声明用GPU(指定具体的卡)
  • 将模型(model)加载到GPU上
  • 把数据和标签放到GPU上

使用GPU的过程中离不开torch.device()

什么是torch.device()?

A torch.device is an object representing the device on which a torch.Tensor is or will be allocated. 就是装torch.Tensor的一个地方。

声明用GPU(指定具体的卡)

device=torch.device('cuda' if torch.cuda.is_available() else 'cpu')

'cuda' 这里如果没有指定具体的卡号,那么系统默认cuda:0
或者:
如果使用pycharm,程序的运行路径填的就是服务器上的路径,默认torch.cuda.is_available() = Ture,那么就可以省略后面的判断语句。下面的例子是使用了2号卡(从0开始计数)。

device = torch.device('cuda:2')

将模型(model)加载到GPU上

model = resnet19()	#例子中,采用resnet模型
model.to(device)

把数据和标签放到GPU上

data, target = data.to(device), target.to(device)

❤️在多卡上并行计算

  • 方法1:torch.nn.DataParallel()
    torch.nn.DataParallel()具体的过程:大体就是将模型加载的每个卡上,数据平均分到每个卡上,原则上保证batch_size大于卡的数目就行。

      device = torch.device('cuda:2') #device = torch.device("cuda:1" if use_cuda else "cpu")  
      model = resnet19()  
      if torch.cuda.device_count() > 1: #10 
          print(torch.cuda.device_count())  
          model = nn.DataParallel(model, device_ids = [2,3,4])
      model.to(device)   
    

    这段代码运行之后占用的GPU是:0,2,3,4。为什么会占用0??我感到很神奇!!!原来:The parallelized module must have its parameters and buffers on device_ids[0] before running this DataParallel module. 就是说,即使我指定的卡没有0卡,他也会在0卡里面放参数和缓存。
    如何避免这种现象呢?
    改变默认的device_ids[0]指向的卡。默认device_ids[0]指向的就是0卡,只需要通过环境变量,让device_ids[0]指向其他卡片即可。

    os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
    os.environ["CUDA_VISIBLE_DEVICES"] = "2, 3, 4"	#仅有2,3,4(物理上)卡对程序可见,对应的逻辑上的卡号就算0,1,2
    	    ......
    device = torch.device('cuda') #device = torch.device("cuda:1" if use_cuda else "cpu")  
    model = resnet19()  
    if torch.cuda.device_count() > 1: #10 
        print(torch.cuda.device_count())  
        model = nn.DataParallel(model, device_ids = [0,1,2])
    model.to(device)   
    
  • distributedDataparallel
    没有用过,之后学习一下。 参考

参考

参考1
参考2

  • 9
    点赞
  • 38
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
### 回答1: 可以参考PyTorch官方文档给出的多GPU示例,例如下面的代码:import torch#CUDA device 0 device = torch.device("cuda:0")#Create two random tensors x = torch.randn(3,3).to(device) y = torch.randn(3,3).to(device)#Multiply two random tensors z = x * y#Print the result print(z) ### 回答2: 使用torch运行多个GPU可以通过以下代码示例完成: import torch import torch.nn as nn import torch.distributed as dist from torch.nn.parallel import DistributedDataParallel as DDP # 初始化多个GPU设备 device_ids = [0, 1, 2] device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # 定义模型 class MyModel(nn.Module): def __init__(self): super(MyModel, self).__init__() self.fc = nn.Linear(10, 2) def forward(self, x): x = self.fc(x) return x model = MyModel().to(device) # 初始化分布式环境 dist.init_process_group(backend="nccl") # 使用torch.nn.parallel.DistributedDataParallel包裹模型,实现多GPU并行化 model = DDP(model, device_ids=device_ids, output_device=device_ids[0]) # 定义输入数据 input_data = torch.randn(128, 10).to(device) # 在多个GPU上进行前向传播 output_data = model(input_data) # 打印输出结果 print(output_data): 这段代码首先初始化了多个GPU设备,然后定义了一个简单的模型,模型包含一个全连接层。接下来,使用torch.nn.parallel.DistributedDataParallel将模型包裹起来,实现多GPU的并行计算。在初始化分布式环境后,将模型移到指定的设备上,并用DDP包裹。然后,定义了一个输入数据,并将其移到指定的设备上。最后,通过对模型进行前向传播来计算输出结果,并将结果打印出来。 ### 回答3: 下面是一个torch多GPU运行代码示例: ```python import torch import torch.nn as nn import torch.optim as optim import torch.distributed as dist import torch.multiprocessing as mp from torch.nn.parallel import DistributedDataParallel as DDP def train(model, device, train_loader, optimizer, criterion): model.train() for batch_idx, (data, target) in enumerate(train_loader): data, target = data.to(device), target.to(device) optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() def main(rank, world_size): # 初始化进程组 dist.init_process_group(backend='nccl', init_method='env://', world_size=world_size, rank=rank) # 创建模型和优化器 model = Net().to(rank) ddp_model = DDP(model, device_ids=[rank]) optimizer = optim.SGD(ddp_model.parameters(), lr=0.01) # 分布式数据加载器 train_dataset = ... train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, sampler=train_sampler) # 训练模型 num_epochs = 10 for epoch in range(num_epochs): train(ddp_model, rank, train_loader, optimizer) train_sampler.set_epoch(epoch) dist.destroy_process_group() if __name__ == '__main__': # 启动多个进程进行分布式训练 world_size = torch.cuda.device_count() mp.spawn(main, args=(world_size, ), nprocs=world_size) ``` 上述代码示例中,我们使用了torch的`DistributedDataParallel`模块来实现多GPU训练。首先使用`torch.multiprocessing.spawn`方法启动多个进程,并在每个进程中调用`main`函数。在`main`函数中,我们首先使用`dist.init_process_group`初始化进程组,然后创建模型和优化器,并将模型放在指定的GPU设备上。接着,我们使用`torch.utils.data.distributed.DistributedSampler`和`torch.utils.data.DataLoader`创建分布式数据加载器。最后,我们迭代进行训练,并在每个epoch结束时调用`train_sampler.set_epoch(epoch)`来确保每个进程使用不同的数据划分。训练完成后,我们使用`dist.destroy_process_group`结束进程组。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 7
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值