devbox
煮酒与君饮
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

pytorch 分布式训练

作者：煮酒与君饮 | 2024-08-21 12:17:32

赞

踩

分布式训练

目录

一、DistributedDataParallel内部机制

二、普通单卡训练

三、分布式训练

四、混合精度训练（采用apex）

五、可能会遇到的问题

1.问题：报错显示两个数据不在同一个 device 上

2.问题：dataloader 接收数据的问题

3.问题：NCCL invalid usage 问题

4.问题：进程初始化问题

5.注意：“shuffle=True” 和 “sampler”不能同时存在

6.进程初始化部分的代码

六、分布式完整代码

七、参考

        神经网络训练加速的最简单方法是使用GPU，对弈神经网络中常规操作（矩阵乘法和加法）GPU运算速度要倍超于CPU。随着模型或数据集越来越大，一个GPU很快就会变得不足。例如，BERT和GPT-2等大型语言模型是在数百个GPU上训练的。对于多GPU训练，需要一种在不同GPU之间对模型和数据进行切分和调度的方法。

        PyTorch是非常流行的深度学习框架，它在主流框架中对于灵活性和易用性的平衡最好。Pytorch有两种方法可以在多个GPU上切分模型和数据：nn.DataParallel 和nn.distributedataparallel 。DataParallel更易于使用（只需简单包装单GPU模型）。然而，由于它使用一个进程来计算模型权重，然后在每个批处理期间将分发到每个GPU，因此通信很快成为一个瓶颈，GPU利用率通常很低。而且，nn.DataParallel 要求所有的GPU都在同一个节点上（不支持分布式），而且不能使用Apex进行混合精度训练。nn.DataParallel 和nn.distributedataparallel 的主要差异可以总结为以下几点（译者注）：

  • DistributedDataParallel 支持模型并行，而DataParallel 并不支持，这意味如果模型太大单卡显存不足时只能使用前者；
  • DataParallel 是单进程多线程的，只用于单卡情况，而 DistributedDataParallel 是多进程的，适用于单机和多机情况，真正实现分布式训练；
  • DistributedDataParallel 的训练更高效，因为每个进程都是独立的Python解释器，避免GIL问题，而且通信成本低其训练速度更快，基本上DataParallel已经被弃用；
  • 必须要说明的是 DistributedDataParallel 中每个进程都有独立的优化器，执行自己的更新过程，但是梯度通过通信传递到每个进程，所有执行的内容是相同的；

        总的来说，Pytorch文档是相当完备和清晰的，尤其是在1.0x版本后。但是关于 DistributedDataParallel 的介绍却较少，主要的文档有以下三个：

        这篇教程将通过一个MNISI例子讲述如何使用PyTorch的分布式训练，这里将一段段代码进行解释，而且也包括任何使用apex进行混合精度训练。

一、DistributedDataParallel内部机制

        DistributedDataParallel 通过多进程在多个GPUs间复制模型，每个GPU都由一个进程控制（当然可以让每个进程控制多个GPU，但这显然比每个进程有一个GPU要慢；也可以多个进程在一个GPU上运行）。GPU可以都在同一个节点上，也可以分布在多个节点上。每个进程都执行相同的任务，并且每个进程都与所有其他进程通信。进程或者说GPU之间只传递梯度，这样网络通信就不再是瓶颈。

        在训练过程中，每个进程从磁盘加载batch数据，并将它们传递到其GPU。每一个GPU都有自己的前向过程，然后梯度在各个GPUs间进行All-Reduce。每一层的梯度不依赖于前一层，所以梯度的All-Reduce和后向过程同时计算，以进一步缓解网络瓶颈。在后向过程的最后，每个节点都得到了平均梯度，这样模型参数保持同步。

        这都要求多个进程（可能在多个节点上）同步并通信。Pytorch通过 distributed.init_process_group 函数来实现这一点。他需要知道进程0位置以便所有进程都可以同步，以及预期的进程总数。每个进程都需要知道进程总数及其在进程中的顺序，以及使用哪个GPU。通常将进程总数称为 world_size。Pytorch 提供了nn.utils.data.DistributedSampler来为各个进程切分数据，以保证训练数据不重叠。

这里通过一个MNIST实例来讲解，我们先将其改成分布式训练，然后增加混合精度训练。

二、普通单卡训练

首先，导入所需要的库：

  1. import os
  2. from datetime import datetime
  3. import argparse
  4. import torch.multiprocessing as mp
  5. import torchvision
  6. import torchvision.transforms as transforms
  7. import torch
  8. import torch.nn as nn
  9. import torch.distributed as dist
  10. from apex.parallel import DistributedDataParallel as DDP
  11. from apex import amp

然后我们定义一个简单的 CNN 模型处理 MNIST 数据：

  1. class ConvNet(nn.Module):
  2.     def __init__(self, num_classes=10):
  3.         super(ConvNet, self).__init__()
  4.         self.layer1 = nn.Sequential(
  5.             nn.Conv2d(1, 16, kernel_size=5, stride=1, padding=2),
  6.             nn.BatchNorm2d(16),
  7.             nn.ReLU(),
  8.             nn.MaxPool2d(kernel_size=2, stride=2))
  9.         self.layer2 = nn.Sequential(
  10.             nn.Conv2d(16, 32, kernel_size=5, stride=1, padding=2),
  11.             nn.BatchNorm2d(32),
  12.             nn.ReLU(),
  13.             nn.MaxPool2d(kernel_size=2, stride=2))
  14.         self.fc = nn.Linear(7*7*32, num_classes)
  15.  
  16.     def forward(self, x):
  17.         out = self.layer1(x)
  18.         out = self.layer2(out)
  19.         out = out.reshape(out.size(0), -1)
  20.         out = self.fc(out)
  21.         return out

主函数 main() 接受参数，执行训练：

  1. def main():
  2.     parser = argparse.ArgumentParser()
  3.     parser.add_argument('-n', '--nodes', default=1, type=int, metavar='N')
  4.     parser.add_argument('-g', '--gpus', default=1, type=int,
  5.                         help='number of gpus per node')
  6.     parser.add_argument('-nr', '--nr', default=0, type=int,
  7.                         help='ranking within the nodes')
  8.     parser.add_argument('--epochs', default=2, type=int, metavar='N',
  9.                         help='number of total epochs to run')
  10.     args = parser.parse_args()
  11.     train(0, args)

其中训练部分主函数为：

  1. def train(gpu, args):
  2. 	torch.manual_seed(0)
  3.     model = ConvNet()
  4.     torch.cuda.set_device(gpu)
  5.     model.cuda(gpu)
  6.     batch_size = 100
  7.     # define loss function (criterion) and optimizer
  8.     criterion = nn.CrossEntropyLoss().cuda(gpu)
  9.     optimizer = torch.optim.SGD(model.parameters(), 1e-4)
  10.     # Data loading code
  11.     train_dataset = torchvision.datasets.MNIST(root='./data',
  12.                                                train=True,
  13.                                                transform=transforms.ToTensor(),
  14.                                                download=True)
  15.     train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
  16.                                                batch_size=batch_size,
  17.                                                shuffle=True,
  18.                                                num_workers=0,
  19.                                                pin_memory=True)
  20.  
  21.     start = datetime.now()
  22.     total_step = len(train_loader)
  23.     for epoch in range(args.epochs):
  24.         for i, (images, labels) in enumerate(train_loader):
  25.             images = images.cuda(non_blocking=True)
  26.             labels = labels.cuda(non_blocking=True)
  27.             # Forward pass
  28.             outputs = model(images)
  29.             loss = criterion(outputs, labels)
  30.  
  31.             # Backward and optimize
  32.             optimizer.zero_grad()
  33.             loss.backward()
  34.             optimizer.step()
  35.             if (i + 1) % 100 == 0 and gpu == 0:
  36.                 print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format(
  37.                     epoch + 1, 
  38.                     args.epochs, 
  39.                     i + 1, 
  40.                     total_step,
  41.                     loss.item())
  42.                    )
  43.     if gpu == 0:
  44.         print("Training complete in: " + str(datetime.now() - start))

通过启动主函数来开始训练：

  1. if __name__ == '__main__':
  2.     main()

你可能注意到有些参数是多余的，但是对后面的分布式训练是有用的。我们通过执行以下语句就可以在单机单卡上训练：

python src/mnist.py -n 1 -g 1 -nr 0

三、分布式训练

        使用多进程进行分布式训练，我们需要为每个GPU启动一个进程。每个进程需要知道自己运行在哪个GPU上，以及自身在所有进程中的序号。对于多节点，我们需要在每个节点启动脚本。

        首先，我们要配置基本的参数：

  1. def main():
  2.     parser = argparse.ArgumentParser()
  3.     parser.add_argument('-n', '--nodes', default=1,
  4.                         type=int, metavar='N')
  5.     parser.add_argument('-g', '--gpus', default=1, type=int,
  6.                         help='number of gpus per node')
  7.     parser.add_argument('-nr', '--nr', default=0, type=int,
  8.                         help='ranking within the nodes')
  9.     parser.add_argument('--epochs', default=2, type=int, 
  10.                         metavar='N',
  11.                         help='number of total epochs to run')
  12.     args = parser.parse_args()
  13.     #########################################################
  14.     args.world_size = args.gpus * args.nodes                #
  15.     os.environ['MASTER_ADDR'] = '10.57.23.164'              #
  16.     os.environ['MASTER_PORT'] = '8888'                      #
  17.     mp.spawn(train, nprocs=args.gpus, args=(args,))         #
  18.     #########################################################
  19.

        其中 args.nodes 是节点总数，而 args.gpus 是每个节点的GPU总数（每个节点GPU数是一样的），而 args.nr 是当前节点在所有节点的序号。节点总数乘以每个节点的GPU数可以得到 world_size ，也即进程总数。所有的进程需要知道进程0的IP地址以及端口，这样所有进程可以在开始时同步，一般情况下称进程0是master进程，比如我们会在进程0中打印信息或者保存模型。PyTorch提供了 mp.spawn 来在一个节点启动该节点所有进程，每个进程运行 train(i, args) ，其中 i 从 0 到 args.gpus - 1 。

        同样，我们要修改训练函数：

  1. def train(gpu, args):
  2.     ############################################################
  3.     rank = args.nr * args.gpus + gpu	                          
  4.     dist.init_process_group(                                   
  5.     	backend='nccl',                                         
  6.    		init_method='env://',                                   
  7.     	world_size=args.world_size,                              
  8.     	rank=rank                                               
  9.     )                                                          
  10.     ############################################################
  11.     
  12.     torch.manual_seed(0)
  13.     model = ConvNet()
  14.     torch.cuda.set_device(gpu)
  15.     model.cuda(gpu)
  16.     batch_size = 100
  17.     # define loss function (criterion) and optimizer
  18.     criterion = nn.CrossEntropyLoss().cuda(gpu)
  19.     optimizer = torch.optim.SGD(model.parameters(), 1e-4)
  20.     
  21.     ###############################################################
  22.     # Wrap the model
  23.     model = nn.parallel.DistributedDataParallel(model,
  24.                                                 device_ids=[gpu])
  25.     ###############################################################
  26.  
  27.     # Data loading code
  28.     train_dataset = torchvision.datasets.MNIST(
  29.         root='./data',
  30.         train=True,
  31.         transform=transforms.ToTensor(),
  32.         download=True
  33.     )                                               
  34.     ################################################################
  35.     train_sampler = torch.utils.data.distributed.DistributedSampler(
  36.     	train_dataset,
  37.     	num_replicas=args.world_size,
  38.     	rank=rank
  39.     )
  40.     ################################################################
  41.  
  42.     train_loader = torch.utils.data.DataLoader(
  43.     	dataset=train_dataset,
  44.        batch_size=batch_size,
  45.     ##############################
  46.        shuffle=False,            #
  47.     ##############################
  48.        num_workers=0,
  49.        pin_memory=True,
  50.     #############################
  51.       sampler=train_sampler)    # 
  52.     #############################
  53.     ...

        这里我们首先计算出当前进程序号：rank = args.nr * args.gpus + gpu，然后就是通过 dist.init_process_group 初始化分布式环境，其中 backend 参数指定通信后端，包括 mpi, gloo, nccl ，这里选择 nccl ，这是Nvidia提供的官方多卡通信框架，相对比较高效。mpi 也是高性能计算常用的通信协议，不过你需要自己安装MPI实现框架，比如OpenMPI。 gloo 倒是内置通信后端，但是不够高效。init_method 指的是如何初始化，以完成刚开始的进程同步；这里我们设置的是 env:// ，指的是环境变量初始化方式，需要在环境变量中配置4个参数：MASTER_PORT，MASTER_ADDR，WORLD_SIZE，RANK，前面两个参数我们已经配置，后面两个参数也可以通过 dist.init_process_group 函数中 world_size 和 rank 参数配置。其它的初始化方式还包括共享文件系统以及TCP，比如 init_method='tcp://10.1.1.20:23456' ，其实也是要提供master的IP地址和端口。注意这个调用是阻塞的，必须等待所有进程来同步，如果任何一个进程出错，就会失败。

        对于模型侧，我们只需要用 DistributedDataParallel 包装一下原来的model即可，在背后它会支持梯度的 All-Reduce 操作。对于数据侧，我们 nn.utils.data.DistributedSampler 来给各个进程切分数据，只需要在 dataloader 中使用这个 sampler 就好，值得注意的一点是你要训练循环过程的每个epoch开始时调用 train_sampler.set_epoch(epoch) ，（主要是为了保证每个epoch的划分是不同的）其它的训练代码都保持不变。

        最后就可以执行代码了，比如我们是4节点，每个节点是8卡，那么需要在4个节点分别执行：

python src/mnist-distributed.py -n 4 -g 8 -nr i

        要注意的是，此时的有效batch_size其实是 batch_size_per_gpu * world_size，对于有BN的模型还可以采用同步BN获取更好的效果：

model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(model)

        上述讲述的是分布式训练过程，其实同样适用于评估或者测试过程，比如我们把数据划分到不同的进程中进行预测，这样可以加速预测过程。实现代码和上述过程完全一样，不过我们想计算某个指标，那就需要从各个进程的统计结果进行 All-Reduce，因为每个进程仅是计算的部分数据的内容。比如我们要计算分类准确度，我们可以统计每个进程的数据总数 total 和分类正确的数量 count ，然后进行聚合。这里要提的一点，当用 dist.init_process_group 初始化分布式环境时，其实就是建立一个默认的分布式进程组（ distributed process group ），这个 group 同时会初始化Pytorch的 torch.distributed 包。这样我们可以直接用 torch.distributed 的API就可以进行分布式基本操作了，下面是具体实现：

  1. # define tensor on GPU, count and total is the result at each GPU
  2. t = torch.tensor([count, total], dtype=torch.float64, device='cuda')
  3. dist.barrier()  # synchronizes all processes
  4. dist.all_reduce(t, op=torch.distributed.ReduceOp.SUM,)  # Reduces the tensor data across all machines in such a way that all get the final result.
  5. t = t.tolist()
  6. all_count = int(t[0])
  7. all_total = int(t[1])
  8. acc = all_count / all_total

四、混合精度训练（采用apex）

        混合精度训练（混合FP32和FP16训练）可以适用更大的batch_size，而且可以利用NVIDIA Tensor Cores加速计算。采用NVIDIA的apex进行混合精度训练非常简单，只需要修改部分代码

  1.  rank = args.nr * args.gpus + gpu
  2.     dist.init_process_group(
  3.         backend='nccl',
  4.         init_method='env://',
  5.         world_size=args.world_size,
  6.         rank=rank)
  7.         
  8. 	torch.manual_seed(0)
  9.     model = ConvNet()
  10.     torch.cuda.set_device(gpu)
  11.     model.cuda(gpu)
  12.     batch_size = 100
  13.     # define loss function (criterion) and optimizer
  14.     criterion = nn.CrossEntropyLoss().cuda(gpu)
  15.     optimizer = torch.optim.SGD(model.parameters(), 1e-4)
  16.     # Wrap the model
  17.     ##############################################################
  18.     model, optimizer = amp.initialize(model, optimizer, 
  19.                                       opt_level='O2')
  20.     model = DDP(model)
  21.     ##############################################################
  22.     # Data loading code
  23. 	...
  24.     start = datetime.now()
  25.     total_step = len(train_loader)
  26.     for epoch in range(args.epochs):
  27.         for i, (images, labels) in enumerate(train_loader):
  28.             images = images.cuda(non_blocking=True)
  29.             labels = labels.cuda(non_blocking=True)
  30.             # Forward pass
  31.             outputs = model(images)
  32.             loss = criterion(outputs, labels)
  33.  
  34.             # Backward and optimize
  35.             optimizer.zero_grad()
  36.     ##############################################################
  37.             with amp.scale_loss(loss, optimizer) as scaled_loss:
  38.                 scaled_loss.backward()
  39.     ##############################################################
  40.             optimizer.step()
  41.      ...
  42.

        其实就两处变化，首先是采用 amp.initialize 来包装 model 和 optimizer 以支持混合精度训练，其中 opt_level 指的是优化级别，如果为O0或者O3不是真正的混合精度，但是可以用来确定模型效果和速度的 baseline ，而 O1 和 O2 是混合精度的两种设置，可以选择某个进行混合精度训练。另外一处是在进行根据梯度更新参数前，要先通过 amp.scale_loss 对梯度进行scale以防止梯度下溢（underflowing）。此外，你还可以用 apex.parallel.DistributedDataParallel 替换 nn.DistributedDataParallel。

五、可能会遇到的问题

1.问题：报错显示两个数据不在同一个 device 上

RuntimeError: Expected all tensors to be on the same device, but found at least two devices, cuda:1 and cuda:0!

原因：

解决：检查代码，将数据移到 cuda 上 ， non_blocking 表示非阻塞

2.问题：dataloader 接收数据的问题

ValueError: Dataloader with Iterableataset: expected unspecified sampler option, but got sampler-torchutils data.distributed.Distributedsampler obiect
at 0x7ffoafe6da30>

原因：dataloader 接收了一个经过 sampler包装的 Iterableataset

解决： 如果train_data本身就是个可迭代对象，则不需要用 sampler 包装，注释掉 “train_sampler” 这一行。但是在对其他项目做分布式训练时 ，不设置 DistributedSampler 无法实现真正的并行（运行效率没有提高）。

3.问题：NCCL invalid usage 问题

RuntimeError: NCCL error in: ../torch/csrc/distributed/c10d/ProcessGroupiNcCl.cpp:957, invalid usage, NCCL version 21.0.3
ncclInvalidlsage: This usually reflects invalid usage of wol library (such as too mary async ops, to many collectives at once, mixing streams in a group,
etc)

原因：nccl 安装成功，版本也没有问题，问题是没有被正确使用，从报错位置上我们可以看出，问题出在 model = DistributedDataParallel(model,device_ids=[rank])

解决：这里的问题比较多样，我的问题是 “在 torch.cuda.set_device(rank) 之前，模型多次被重复放到 cuda 上”，所以我检查了一下，在将模型放到 cuda 上之前是否有重复操作而引起冲突。所以我的处理方式是删掉了 torch.cuda.set_device(rank) 之前的 “to.device()”

4.问题：进程初始化问题

-- Process 1 terminated with the following error:
Traceback (most recent call last):
  File "/root/anaconda3/envs/diffusion1/lib/python3.8/site-packages/torch/multiprocessing/spawn.py", line 59, in _wrap
    fn(i, *args)
  File "/root/train.py", line 425, in train
    model = tDistributedDataParallel(model, device_ids=[rank])
  File "/root/anaconda3/envs/diffusion1/lib/python3.8/site-packages/torch/nn/parallel/distributed.py", line 530, in __init__
    self.process_group = _get_default_group()
  File "/root/anaconda3/envs/diffusion1/lib/python3.8/site-packages/torch/distributed/distributed_c10d.py", line 410, in _get_default_group
    raise RuntimeError(
RuntimeError: Default process group has not been initialized, please make sure to call init_process_group.

原因：进程没有被初始化，我在进程初始化前加了只初始化主进程的代码，故报此错。

解决：“删掉 if rank == 0：”，有的博主说，只需要初始化主进程，但是我这样处理却报错了，不知为何，但是我的两个进程都初始化就不会报错

5.注意：“shuffle=True” 和 “sampler”不能同时存在

6.进程初始化部分的代码

  1. os.environ['MASTER_ADDR'] = 'localhost'
  2. os.environ['MASTER_PORT'] = '8888'
  3. os.environ['NCCL_DEBUG'] = 'INFO' # nccl log 日志
  4.  
  5. dist_backend = 'nccl' if torch.cuda.is_available() else 'gloo'
  6. dist_init_method = f'tcp://localhost:22222'
  7.  
  8. # Initialize the process group
  9. dist.init_process_group(
  10.     backend=dist_backend,
  11.     init_method=dist_init_method,
  12.     world_size=torch.cuda.device_count(),
  13.     rank=rank
  14. )

六、分布式完整代码

  1. import os
  2. from datetime import datetime
  3. import argparse
  4. import torch.multiprocessing as mp
  5. import torchvision
  6. import torchvision.transforms as transforms
  7. import torch
  8. import torch.nn as nn
  9. import torch.distributed as dist
  10. # from apex.parallel import DistributedDataParallel as DDP
  11. # from apex import amp
  12.  
  13.  
  14. class ConvNet(nn.Module):
  15.     def __init__(self, num_classes=10):
  16.         super(ConvNet, self).__init__()
  17.         self.layer1 = nn.Sequential(
  18.             nn.Conv2d(1, 16, kernel_size=5, stride=1, padding=2),
  19.             nn.BatchNorm2d(16),
  20.             nn.ReLU(),
  21.             nn.MaxPool2d(kernel_size=2, stride=2))
  22.         self.layer2 = nn.Sequential(
  23.             nn.Conv2d(16, 32, kernel_size=5, stride=1, padding=2),
  24.             nn.BatchNorm2d(32),
  25.             nn.ReLU(),
  26.             nn.MaxPool2d(kernel_size=2, stride=2))
  27.         self.fc = nn.Linear(7*7*32, num_classes)
  28.  
  29.     def forward(self, x):
  30.         out = self.layer1(x)
  31.         out = self.layer2(out)
  32.         out = out.reshape(out.size(0), -1)
  33.         out = self.fc(out)
  34.         return out
  35.  
  36.  
  37. def train(gpu, args):
  38.     ############################################################
  39.     rank = args.nr * args.gpus + gpu	                          
  40.     dist.init_process_group(                                   
  41.     	backend='nccl',                                         
  42.    		init_method='tcp://localhost:22222',                                   
  43.     	world_size=args.world_size,                              
  44.     	rank=rank                                               
  45.     )                                                          
  46.     ############################################################
  47.     print(f'1111111')
  48.     print(f'2222222')
  49.     print(f'在GPU{rank}上初始化进程组')
  50.     torch.manual_seed(0)
  51.     model = ConvNet()
  52.     torch.cuda.set_device(gpu)
  53.     model.cuda(gpu)
  54.     batch_size = 100
  55.     # define loss function (criterion) and optimizer
  56.     criterion = nn.CrossEntropyLoss().cuda(gpu)
  57.     optimizer = torch.optim.SGD(model.parameters(), 1e-4)
  58.     
  59.     ###############################################################
  60.     # Wrap the model
  61.     model = nn.parallel.DistributedDataParallel(model,
  62.                                                 device_ids=[gpu])
  63.     ###############################################################
  64.  
  65.     # Data loading code
  66.     train_dataset = torchvision.datasets.MNIST(
  67.         root='./data',
  68.         train=True,
  69.         transform=transforms.ToTensor(),
  70.         download=True
  71.     )
  72.     import collections
  73.     print(f'是否是可迭代对象：{isinstance(train_dataset, collections.Iterable)}')                                               
  74.     ################################################################
  75.     train_sampler = torch.utils.data.distributed.DistributedSampler(
  76.     	train_dataset,
  77.     	num_replicas=args.world_size,
  78.     	rank=rank
  79.     )
  80.     ################################################################
  81.     print(f'{train_dataset}')
  82.     train_loader = torch.utils.data.DataLoader(
  83.     	dataset=train_dataset,
  84.        batch_size=batch_size,
  85.        shuffle=False,          
  86.        num_workers=0,
  87.        pin_memory=True,
  88.       sampler=train_sampler)   
  89.     print(f'train_iterator"{train_loader}') 
  90.     start = datetime.now()
  91.     total_step = len(train_loader)
  92.     for epoch in range(args.epochs):
  93.         for i, (images, labels) in enumerate(train_loader):
  94.             images = images.cuda(non_blocking=True)
  95.             labels = labels.cuda(non_blocking=True)
  96.             # Forward pass
  97.             outputs = model(images)
  98.             loss = criterion(outputs, labels)
  99.  
  100.             # Backward and optimize
  101.             optimizer.zero_grad()
  102.             loss.backward()
  103.             optimizer.step()
  104.             if (i + 1) % 100 == 0 and gpu == 0:
  105.                 print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format(
  106.                     epoch + 1, 
  107.                     args.epochs, 
  108.                     i + 1, 
  109.                     total_step,
  110.                     loss.item())
  111.                    )
  112.     if gpu == 0:
  113.         print("Training complete in: " + str(datetime.now() - start))
  114.  
  115.  
  116. def main():
  117.     parser = argparse.ArgumentParser()
  118.     parser.add_argument('-n', '--nodes', default=1,
  119.                         type=int, metavar='N')
  120.     parser.add_argument('-g', '--gpus', default=1, type=int,
  121.                         help='number of gpus per node')
  122.     parser.add_argument('-nr', '--nr', default=0, type=int,
  123.                         help='ranking within the nodes')
  124.     parser.add_argument('--epochs', default=200, type=int, 
  125.                         metavar='N',
  126.                         help='number of total epochs to run')
  127.     args = parser.parse_args()
  128.     #########################################################
  129.     args.world_size = args.gpus * args.nodes                #
  130.     os.environ['MASTER_ADDR'] = 'localhost'              #
  131.     os.environ['MASTER_PORT'] = '8888'                      #
  132.     mp.spawn(train, nprocs=args.gpus, args=(args,))         #
  133.     #########################################################
  134.       
  135.  
  136.  
  137. if __name__ == '__main__':
  138.     main()

七、参考

PyTorch分布式训练简明教程

Distributed data parallel training in Pytorch

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/煮酒与君饮/article/detail/1011730
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号