python实现GPU分布式训练

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接: https://blog.csdn.net/zwqjoy/article/details/89415933

[深度学习] 分布式Tensorflow介绍(二)

[深度学习] 分布式Pytorch 1.0介绍(三)

[深度学习] 分布式Horovod介绍(四)



为什么需要分布式

众所周知,深度神经网络发展到现阶段,离不开GPU和数据。经过这么多年的积累,GPU的计算能力越来越强,数据也积累的越来越多,大家会发现在现有的单机单卡或者单机多卡上很难高效地复现模型,甚至对于有些新的数据集来讲,单机训练简直就是噩梦。

DatasetImages MS COCO115,000  Open Image dataset v4 1,740,000

为什么单机8卡也会是噩梦呢?我们拿COCO和Google最近Release出来的Open Image dataset v4来做比较,训练一个resnet152的检测模型,在COCO上大概需要40个小时,而在OIDV4上大概需要40天,这还是在各种超参数正确的情况下,如果加上调试的时间,可能一个模型调完就该过年了吧。

所以这个时候我们需要分布式。

Pytorch 分布式简介

PyTorch 1.0稳定版终于正式发布了!新版本增加了JIT编译器、全新的分布式包、C++ 前端,以及Torch Hub等新功能,支持AWS、谷歌云、微软Azure等云平台。

torch.distributed软件包和torch.nn.parallel.DistributedDataParallel模块由全新的、重新设计的分布式库提供支持。

新的库的主要亮点有:

  • 新的 torch.distributed 是性能驱动的,并且对所有后端 (Gloo,NCCL 和 MPI) 完全异步操作
  • 显着的分布式数据并行性能改进,尤其适用于网络较慢的主机,如基于以太网的主机
  • 为torch.distributed  package中的所有分布式集合操作添加异步支持
  • 在Gloo后端添加以下CPU操作:send,recv,reduce,all_gather,gather,scatter
  • 在NCCL后端添加barrier操作
  • 为NCCL后端添加new_group支持

 

1.0的多机多卡的计算模型并没有采用主流的Parameter Server结构,而是直接用了Uber Horovod的形式,也是百度开源的RingAllReduce算法。

采用PS计算模型的分布式,通常会遇到网络的问题,随着worker数量的增加,其加速比会迅速的恶化,例如resnet50这样的模型,目前的TF在10几台机器的时候,加速比已经开始恶化的不可接受了。因此,经常要上RDMA、InfiniBand等技术,并且还带来了一波网卡的升级,有些大厂直接上了100GBs的网卡,有钱任性。而Uber的Horovod,采用的RingAllReduce的计算方案,其特点是网络通信量不随着worker(GPU)的增加而增加,是一个恒定值。简单看下图理解下,GPU 集群被组织成一个逻辑环,每个GPU有一个左邻居、一个右邻居,每个GPU只从左邻居接受数据、并发送数据给右邻居。即每次梯度每个gpu只获得部分梯度更新,等一个完整的Ring完成,每个GPU都获得了完整的参数。

 

这里引入了一个新的函数model = torch.nn.parallel.DistributedDataParallel(model)为的就是支持分布式模式

不同于原来在multiprocessing中的model = torch.nn.DataParallel(model,device_ids=[0,1,2,3]).cuda()函数,这个函数只是实现了在单机上的多GPU训练,根据官方文档的说法,甚至在单机多卡的模式下,新函数表现也会优于这个旧函数。

这里要提到两个问题:

  • 每个进程都有自己的Optimizer同时每个迭代中都进行完整的优化步骤,虽然这可能看起来是多余的,但由于梯度已经聚集在一起并跨进程平均,因此对于每个进程都是相同的,这意味着不需要参数广播步骤,从而减少了在节点之间传输张量tensor所花费的时间。
  • 另外一个问题是Python解释器的,每个进程都包含一个独立的Python解释器,消除了来自单个Python进程中的多个执行线程,模型副本或GPU的额外解释器开销和“GIL-thrashing”。 这对于大量使用Python运行时的模型尤其重要。

初始化

torch.distributed.init_process_group(backend, init_method='env://', **kwargs)

 

参数说明:

  • backend(str): 后端选择,包括上面那几种 gloo,nccl,mpi
  • init_method(str,optional): 用来初始化包的URL, 我理解是一个用来做并发控制的共享方式
  • world_size(int, optional): 参与这个工作的进程数
  • rank(int,optional): 当前进程的rank
  • group_name(str,optional): 用来标记这组进程名的

Backends

 

Backends that come with PyTorch

PyTorch distributed currently only supports Linux. By default, the Gloo and NCCL backends are built and included in PyTorch distributed (NCCL only when building with CUDA). MPI is an optional backend that can only be included if you build PyTorch from source. (e.g. building PyTorch on a host that has MPI installed.)

Which backend to use?

In the past, we were often asked: “which backend should I use?”.

  • Rule of thumb
    • Use the NCCL backend for distributed GPU training
    • Use the Gloo backend for distributed CPU training.

 

init_method分析

‘init_method’支持三种方式:

1. TCP initialization

tcp:// IP组播(要求所有进程都在同一个网络中)比较好理解,   以TCP协议的方式进行不同分布式进程之间的数据交流,需要设置一个端口,不同进程之间公用这一个端口,并且设置host的级别和host的数量。设计两个参数rank和world_size。其中rank为host的编号,默认0为主机,端口应该位于该主机上。world_size为分布式主机的个数。

用该方式,运行上面的代码可以使用如下指令:

在主机01上:

python mnsit.py --init-method tcp://10.172.1.2:22225 --rank 0 --world-size 2

 

在主机02上:

python mnsit.py --init-method tcp://10.172.1.2:22225 --rank 1 --world-size 2

 

这里没有设置backend参数,所以默认是gloo。22225是端口号,用一个没有没占用的就行。这两句指令的先后顺序没有要求,只有两条指令都输入,程序才会运行起来。

2. Shared file-system initialization

file:// 共享文件系统(要求所有进程可以访问单个文件系统)有共享文件系统可以选择 

提供的第二种方式是文件共享,机器有共享的文件系统,故可以采用这种方式,也避免了基于TCP的网络传输。这里使用方式是使用绝对路径在指定一个共享文件系统下不存在的文件。

在主机01上:

python mnsit.py --init-method file://PathToShareFile/MultiNode --rank 0 --world-size 2

 

在主机02上:

python mnsit.py --init-method file://PathToShareFile/MultiNode --rank 1 --world-size 2

 

这里相比于TCP的方式麻烦一点的是运行完一次必须更换共享的文件名,或者删除之前的共享文件,不然第二次运行会报错。

 

3. Environment variable initialization

env:// 环境变量(需要您手动分配等级并知道所有进程可访问节点的地址)默认是这个


 
  1. MASTER_PORT - required; has to be a free port on machine with rank 0
  2. MASTER_ADDR - required ( except for rank 0); address of rank 0 node
  3. WORLD_SIZE - required; can be set either here, or in a call to init function
  4. RANK - required; can be set either here, or in a call to init function

但是前两个并没有在init_process_group的参数里。这里有一个官方文档中的用例:


 
  1. Node 1: ( IP: 192.168. 1.1, and has a free port: 1234)
  2. >>> python -m torch.distributed.launch --nproc_per_node=NUM_GPUS_YOU_HAVE
  3. --nnodes= 2 --node_rank= 0 --master_addr= "192.168.1.1"
  4. --master_port= 1234 YOUR_TRAINING_SCRIPT.py (--arg1 --arg2 --arg3
  5. and all other arguments of your training script)
  6. Node 2:
  7. >>> python -m torch.distributed.launch --nproc_per_node=NUM_GPUS_YOU_HAVE
  8. --nnodes= 2 --node_rank= 1 --master_addr= "192.168.1.1"
  9. --master_port= 1234 YOUR_TRAINING_SCRIPT.py (--arg1 --arg2 --arg3
  10. and all other arguments of your training script)

 

需要注意的点

  • 一定要加rank, world_size参数

  • train_dataset最好不要用自己写的sampler,否则还需要再实现一遍分布式的数据划分方式

Dataloader中的参数

如果你的选项刚好是最坏情况,优化这个有可能达到2倍左右的性能提升(经验值哈)

解释一下DataLoader中其中两个参数:

  • num_worker:
    数据集加载的时候,控制用于同时加载数据的线程数(默认为0,即在主线程读取) 存在最优值,你会看到运行的时候pytorch会新建恰等于这个值的数据读取线程,我猜,线程多于必要的时候,数据读取线程返回到主线程反而会因为线程间通信减慢数据。因此大了不好小了也不好。建议把模型,loss,优化器全注释了只跑一下数据流速度,确定最优值
  • pin_memory:
    是否提前申请CUDA内存(默认为False,但有说法除非数据集很小,否则在N卡上推荐总是打开)在MNIST这样的小数据集上好像是关闭比较好,到底多小算小说不清楚,建议自己试一下。

pin_memory就是锁页内存,创建DataLoader时,设置pin_memory=True,则意味着生成的Tensor数据最开始是属于内存中的锁页内存,这样将内存的Tensor转义到GPU的显存就会更快一些。
主机中的内存,有两种存在方式,一是锁页,二是不锁页,锁页内存存放的内容在任何情况下都不会与主机的虚拟内存进行交换(注:虚拟内存就是硬盘),而不锁页内存在主机内存不足时,数据会存放在虚拟内存中。显卡中的显存全部是锁页内存,当计算机的内存充足的时候,可以设置pin_memory=True。当系统卡住,或者交换内存使用过多的时候,设置pin_memory=False。因为pin_memory与电脑硬件性能有关,pytorch开发者不能确保每一个炼丹玩家都有高端设备,因此pin_memory默认为False。

如果机子的内存比较大,建议开启pin_memory=Ture,如果开启后发现有卡顿现象或者内存占用过高,此时建议关闭。

总之官方的默认值很有可能不是最好的,建议自己多试试。在MNIST这样的小数据集上,pin_memory关闭比较好。而且,num_workers需要调节,除了默认情况外,最快和最慢是有一定差距的,建议在自己的代码上只跑数据读取这一块,确定这两个参数的最优值。

 

 

分布式 Hello World

 

启动辅助工具 Launch utility

torch.distributed.launch 例子

torch.distributed包提供了一个启动实用程序torch.distributed.launch,此帮助程序可用于为每个节点启动多个进程以进行分布式训练,它在每个训练节点上产生多个分布式训练进程。

这个工具可以用作CPU或者GPU,如果被用于GPU,每个GPU产生一个进程Process

该工具既可以用来做单节点多GPU训练,也可用于多节点多GPU训练。如果是单节点多GPU,将会在单个GPU上运行一个分布式进程,据称可以非常好地改进单节点训练性能。如果用于多节点分布式训练,则通过在每个节点上产生多个进程来获得更好的多节点分布式训练性能。如果有Infiniband接口则加速比会更高。

在单节点分布式训练或多节点分布式训练的两种情况下,该工具将为每个节点启动给定数量的进程(--nproc_per_node)。如果用于GPU培训,则此数字需要小于或等于当前系统上的GPU数量(nproc_per_node),并且每个进程将在从GPU 0到GPU(nproc_per_node - 1)的单个GPU上运行。

  1. Single-Node multi-process distributed training

 
  1. python -m torch.distributed.launch --nproc_per_node=NUM_GPUS_YOU_HAVE
  2. YOUR_TRAINING_SCRIPT.py (--arg1 --arg2 --arg3 and all other
  3. arguments of your training script)
  1. Multi-Node multi-process distributed training: (e.g. two nodes)

Node 1: (IP: 192.168.1.1, and has a free port: 1234)


 
  1. python -m torch.distributed.launch --nproc_per_node=NUM_GPUS_YOU_HAVE
  2. --nnodes= 2 --node_rank= 0 --master_addr= "192.168.1.1"
  3. --master_port= 1234 YOUR_TRAINING_SCRIPT.py (--arg1 --arg2 --arg3
  4. and all other arguments of your training script)

Node 2:


 
  1. python -m torch.distributed.launch --nproc_per_node=NUM_GPUS_YOU_HAVE
  2. --nnodes= 2 --node_rank= 1 --master_addr= "192.168.1.1"
  3. --master_port= 1234 YOUR_TRAINING_SCRIPT.py (--arg1 --arg2 --arg3
  4. and all other arguments of your training script)

需要注意的地方:

  • 后端最好用“NCCL”,才能获取最好的分布式性能
  • 训练代码必须从命令行解析--local_rank=LOCAL_PROCESS_RANK

 
  1. import argparse
  2. parser = argparse.ArgumentParser()
  3. parser.add_argument( "--local_rank", type= int)
  4. args = parser.parse_args()
  5. torch.cuda.set_device(arg.local_rank)
  • torch.distributed初始化方式

 
  1. torch.distributed.init_process_group(backend= 'nccl',
  2. init_method= 'env://')
  • model

 
  1. model = torch.nn.parallel.DistributedDataParallel(model,
  2. device_ids=[arg.local_rank],
  3. output_device=arg.local_rank)

其他地方一般就不用修改了,真的顺滑

我们的训练代码中这样写(省略多余代码,只保留核心代码):


 
  1. import torch.distributed as dist
  2. # 这个参数是torch.distributed.launch传递过来的,我们设置位置参数来接受,local_rank代表当前程序进程使用的GPU标号
  3. parser.add_argument( "--local_rank", type=int, default= 0)
  4. def synchronize():
  5. """
  6. Helper function to synchronize (barrier) among all processes when
  7. using distributed training
  8. """
  9. if not dist.is_available():
  10. return
  11. if not dist.is_initialized():
  12. return
  13. world_size = dist.get_world_size()
  14. if world_size == 1:
  15. return
  16. dist.barrier()
  17. ## WORLD_SIZE 由torch.distributed.launch.py产生 具体数值为 nproc_per_node*node(主机数,这里为1)
  18. num_gpus = int(os.environ[ "WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1
  19. is_distributed = num_gpus > 1
  20. if is_distributed:
  21. torch.cuda.set_device(args.local_rank) # 这里设定每一个进程使用的GPU是一定的
  22. torch.distributed.init_process_group(
  23. backend= "nccl", init_method= "env://"
  24. )
  25. synchronize()
  26. # 将模型移至到DistributedDataParallel中,此时就可以进行训练了
  27. if is_distributed:
  28. model = torch.nn.parallel.DistributedDataParallel(
  29. model, device_ids=[args.local_rank], output_device=args.local_rank,
  30. # this should be removed if we update BatchNorm stats
  31. broadcast_buffers= False,
  32. )
  33. # 注意,在测试的时候需要执行 model = model.module

 

 

 

WRITING DISTRIBUTED APPLICATIONS WITH PYTORCH

https://github.com/pytorch/examples/tree/master/imagenet 
这里,常规的操作就不多叙述了,主要讲一下和分布式相关的代码部分。


 
  1. parser.add_argument( '--world-size', default= 2, type= int, help= 'number of distributed processes')
  2. parser.add_argument( '--dist-url', default= 'tcp://172.16.1.186:2222', type=str, help= 'url used to set up distributed training')
  3. parser.add_argument( '--dist-backend', default= 'gloo', type=str, help= 'distributed backend')
  4. parser.add_argument( '--dist-rank', default= 0, type= int, help= 'rank of distributed processes')

这几个是必要的参数设置,其中最后一个是官网没有的


 
  1. if args.distributed:
  2. dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url,world_size=args.world_size,rank=args.dist_rank)

这个是分布式的初始化,同样,最后添加一个rank


 
  1. model.cuda()
  2. model = torch.nn.parallel.DistributedDataParallel(model)

这里,把我们平时使用的单机多卡,数据并行的API

model = torch.nn.DataParallel(model).cuda()

 

换掉即可。


 
  1. if args.distributed:
  2. train_sampler = torch.utils. data.distributed.DistributedSampler(train_dataset)

最后使用这个官方给的划分方法,把数据集划分即可。

MNIST 分布式例子

MNIST 分布式 (2台 GPU机器,每台一张GPU)

 GPU1:   python mnist_dist.py --init-method=file:///home/workspace/share/1 --rank=0 --world-size=2

 GPU2:   python mnist_dist.py --init-method=file:///home/workspace/share/1 --rank=1 --world-size=2


 
  1. from __future__ import print_function
  2. import argparse
  3. import time
  4. import torch
  5. import torch.nn as nn
  6. import torch.nn.functional as F
  7. import torch.optim as optim
  8. from torchvision import datasets, transforms
  9. import torch.distributed as dist
  10. import torch.utils.data
  11. import torch.utils.data.distributed
  12. class Net(nn.Module):
  13. def __init__(self):
  14. super(Net, self).__init__()
  15. self.conv1 = nn.Conv2d( 1, 20, 5, 1)
  16. self.conv2 = nn.Conv2d( 20, 50, 5, 1)
  17. self.fc1 = nn.Linear( 4 * 4 * 50, 500)
  18. self.fc2 = nn.Linear( 500, 10)
  19. def forward(self, x):
  20. x = F.relu(self.conv1(x))
  21. x = F.max_pool2d(x, 2, 2)
  22. x = F.relu(self.conv2(x))
  23. x = F.max_pool2d(x, 2, 2)
  24. x = x.view( -1, 4 * 4 * 50)
  25. x = F.relu(self.fc1(x))
  26. x = self.fc2(x)
  27. return F.log_softmax(x)
  28. def train(args, model, device, train_loader, optimizer, epoch):
  29. model.train()
  30. for batch_idx, (data, target) in enumerate(train_loader):
  31. data, target = data.to(device), target.to(device)
  32. optimizer.zero_grad()
  33. output = model(data)
  34. loss = F.nll_loss(output, target)
  35. loss.backward()
  36. optimizer.step()
  37. if batch_idx % args.log_interval == 0:
  38. print( 'Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
  39. epoch, batch_idx * len(data), len(train_loader.dataset),
  40. 100. * batch_idx / len(train_loader), loss.item()))
  41. def test(args, model, device, test_loader):
  42. model.eval()
  43. test_loss = 0
  44. correct = 0
  45. for data, target in test_loader:
  46. data, target = data.to(device), target.to(device)
  47. output = model(data)
  48. test_loss += F.nll_loss(output, target, size_average= False).item() # sum up batch loss
  49. pred = output.data.max( 1, keepdim= True)[ 1] # get the index of the max log-probability
  50. correct += pred.eq(target.data.view_as(pred)).cpu().sum()
  51. test_loss /= len(test_loader.dataset)
  52. print( '\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
  53. test_loss, correct, len(test_loader.dataset),
  54. 100. * correct / len(test_loader.dataset)))
  55. def main():
  56. # Training settings
  57. parser = argparse.ArgumentParser(description= 'PyTorch MNIST Example')
  58. parser.add_argument( '--batch-size', type=int, default= 64, metavar= 'N',
  59. help= 'input batch size for training (default: 64)')
  60. parser.add_argument( '--test-batch-size', type=int, default= 1000, metavar= 'N',
  61. help= 'input batch size for testing (default: 1000)')
  62. parser.add_argument( '--epochs', type=int, default= 10, metavar= 'N',
  63. help= 'number of epochs to train (default: 10)')
  64. parser.add_argument( '--lr', type=float, default= 0.01, metavar= 'LR',
  65. help= 'learning rate (default: 0.01)')
  66. parser.add_argument( '--momentum', type=float, default= 0.5, metavar= 'M',
  67. help= 'SGD momentum (default: 0.5)')
  68. parser.add_argument( '--no-cuda', action= 'store_true',
  69. help= 'disables CUDA training')
  70. parser.add_argument( '--seed', type=int, default= 1, metavar= 'S',
  71. help= 'random seed (default: 1)')
  72. parser.add_argument( '--log-interval', type=int, default= 500, metavar= 'N',
  73. help= 'how many batches to wait before logging training status')
  74. parser.add_argument( '--init-method', type=str, default= 'tcp://127.0.0.1:23456')
  75. parser.add_argument( '--rank', type=int)
  76. parser.add_argument( '--world-size', type=int)
  77. args = parser.parse_args()
  78. use_cuda = not args.no_cuda and torch.cuda.is_available()
  79. print(args)
  80. # 初始化
  81. dist.init_process_group(init_method=args.init_method, backend= "gloo", world_size=args.world_size, rank=args.rank,
  82. group_name= "pytorch_test")
  83. torch.manual_seed(args.seed)
  84. if use_cuda:
  85. torch.cuda.manual_seed(args.seed)
  86. train_dataset = datasets.MNIST( './data', train= True, download= False,
  87. transform=transforms.Compose([
  88. transforms.ToTensor(),
  89. transforms.Normalize(( 0.1307,), ( 0.3081,))
  90. ]))
  91. # 分发数据
  92. train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset)
  93. kwargs = { 'num_workers': 5, 'pin_memory': True} if use_cuda else {}
  94. train_loader = torch.utils.data.DataLoader(train_dataset,
  95. batch_size=args.batch_size, shuffle= True, **kwargs)
  96. test_loader = torch.utils.data.DataLoader(
  97. datasets.MNIST( 'data', train= False, transform=transforms.Compose([
  98. transforms.ToTensor(),
  99. transforms.Normalize(( 0.1307,), ( 0.3081,))
  100. ])),
  101. batch_size=args.test_batch_size, shuffle= True, **kwargs)
  102. device = torch.device( "cuda" if use_cuda else "cpu")
  103. print(device)
  104. model = Net().to(device)
  105. if use_cuda:
  106. model = torch.nn.parallel.DistributedDataParallel(
  107. model) if use_cuda else torch.nn.parallel.DistributedDataParallelCPU(model)
  108. optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum)
  109. total_time = 0
  110. for epoch in range( 1, args.epochs + 1):
  111. # 设置epoch位置,这应该是个为了同步所做的工作
  112. train_sampler.set_epoch(epoch)
  113. start_cpu_secs = time.time()
  114. train(args, model, device, train_loader, optimizer, epoch)
  115. end_cpu_secs = time.time()
  116. print( "Epoch {} of {} took {:.3f}s".format(
  117. epoch, args.epochs, end_cpu_secs - start_cpu_secs))
  118. total_time += end_cpu_secs - start_cpu_secs
  119. test(args, model, device, test_loader)
  120. print( "Total time= {:.3f}s".format(total_time))
  121. if __name__ == '__main__':
  122. main()

 

 

单机例子(一台GPU机器一张GPU卡)

python mnist_no_dist.py 


 
  1. from __future__ import print_function
  2. import argparse
  3. import time
  4. import torch
  5. import torch.nn as nn
  6. import torch.nn.functional as F
  7. import torch.optim as optim
  8. from torchvision import datasets, transforms
  9. class Net(nn.Module):
  10. def __init__(self):
  11. super(Net, self).__init__()
  12. self.conv1 = nn.Conv2d( 1, 20, 5, 1)
  13. self.conv2 = nn.Conv2d( 20, 50, 5, 1)
  14. self.fc1 = nn.Linear( 4 * 4 * 50, 500)
  15. self.fc2 = nn.Linear( 500, 10)
  16. def forward(self, x):
  17. x = F.relu(self.conv1(x))
  18. x = F.max_pool2d(x, 2, 2)
  19. x = F.relu(self.conv2(x))
  20. x = F.max_pool2d(x, 2, 2)
  21. x = x.view( -1, 4 * 4 * 50)
  22. x = F.relu(self.fc1(x))
  23. x = self.fc2(x)
  24. return F.log_softmax(x, dim= 1)
  25. def train(args, model, device, train_loader, optimizer, epoch):
  26. model.train()
  27. for batch_idx, (data, target) in enumerate(train_loader):
  28. data, target = data.to(device), target.to(device)
  29. optimizer.zero_grad()
  30. output = model(data)
  31. loss = F.nll_loss(output, target)
  32. loss.backward()
  33. optimizer.step()
  34. if batch_idx % args.log_interval == 0:
  35. print( 'Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
  36. epoch, batch_idx * len(data), len(train_loader.dataset),
  37. 100. * batch_idx / len(train_loader), loss.item()))
  38. def test(args, model, device, test_loader):
  39. model.eval()
  40. test_loss = 0
  41. correct = 0
  42. with torch.no_grad():
  43. for data, target in test_loader:
  44. data, target = data.to(device), target.to(device)
  45. output = model(data)
  46. test_loss += F.nll_loss(output, target, reduction= 'sum').item() # sum up batch loss
  47. pred = output.argmax(dim= 1, keepdim= True) # get the index of the max log-probability
  48. correct += pred.eq(target.view_as(pred)).sum().item()
  49. test_loss /= len(test_loader.dataset)
  50. print( '\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
  51. test_loss, correct, len(test_loader.dataset),
  52. 100. * correct / len(test_loader.dataset)))
  53. def main():
  54. # Training settings
  55. parser = argparse.ArgumentParser(description= 'PyTorch MNIST Example')
  56. parser.add_argument( '--batch-size', type=int, default= 64, metavar= 'N',
  57. help= 'input batch size for training (default: 64)')
  58. parser.add_argument( '--test-batch-size', type=int, default= 1000, metavar= 'N',
  59. help= 'input batch size for testing (default: 1000)')
  60. parser.add_argument( '--epochs', type=int, default= 10, metavar= 'N',
  61. help= 'number of epochs to train (default: 10)')
  62. parser.add_argument( '--lr', type=float, default= 0.01, metavar= 'LR',
  63. help= 'learning rate (default: 0.01)')
  64. parser.add_argument( '--momentum', type=float, default= 0.5, metavar= 'M',
  65. help= 'SGD momentum (default: 0.5)')
  66. parser.add_argument( '--no-cuda', action= 'store_true', default= False,
  67. help= 'disables CUDA training')
  68. parser.add_argument( '--seed', type=int, default= 1, metavar= 'S',
  69. help= 'random seed (default: 1)')
  70. parser.add_argument( '--log-interval', type=int, default= 500, metavar= 'N',
  71. help= 'how many batches to wait before logging training status')
  72. # parser.add_argument('--save-model', action='store_true', default=False,
  73. # help='For Saving the current Model')
  74. args = parser.parse_args()
  75. print(args)
  76. use_cuda = not args.no_cuda and torch.cuda.is_available()
  77. torch.manual_seed(args.seed)
  78. kwargs = { 'num_workers': 5, 'pin_memory': True} if use_cuda else {}
  79. train_loader = torch.utils.data.DataLoader(
  80. datasets.MNIST( './data', train= True, download= True,
  81. transform=transforms.Compose([
  82. transforms.ToTensor(),
  83. transforms.Normalize(( 0.1307,), ( 0.3081,))
  84. ])),
  85. batch_size=args.batch_size, shuffle= True, **kwargs)
  86. test_loader = torch.utils.data.DataLoader(
  87. datasets.MNIST( './data', train= False, transform=transforms.Compose([
  88. transforms.ToTensor(),
  89. transforms.Normalize(( 0.1307,), ( 0.3081,))
  90. ])),
  91. batch_size=args.test_batch_size, shuffle= True, **kwargs)
  92. device = torch.device( "cuda" if use_cuda else "cpu")
  93. print(device)
  94. model = Net().to(device)
  95. optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum)
  96. total_time = 0
  97. for epoch in range( 1, args.epochs + 1):
  98. start_cpu_secs = time.time()
  99. train(args, model, device, train_loader, optimizer, epoch)
  100. end_cpu_secs = time.time()
  101. print( "Epoch {} of {} took {:.3f}s".format(
  102. epoch, args.epochs, end_cpu_secs - start_cpu_secs))
  103. total_time += end_cpu_secs - start_cpu_secs
  104. test(args, model, device, test_loader)
  105. # print("Total time= {:.3f}s".format(total_time))
  106. # if (args.save_model):
  107. # torch.save(model.state_dict(), "mnist_cnn.pt")
  108. if __name__ == '__main__':
  109. main()

 

 

参考:

  1. PyTorch 1.0 中文官方教程:使用 Amazon AWS 进行分布式训练
  2. https://pytorch.org/docs/stable/distributed.html#initialization
  3. pytorch 分布式训练 distributed parallel 笔记
  4. 使用PyTorch编写分布式应用程序

     

  • 0
    点赞
  • 2
    收藏
  • 0
    评论

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:大白 设计师:CSDN官方博客 返回首页
评论
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值