spawn

paddle.distributed.spawn ( func, args=(), nprocs=- 1, join=True, daemon=False, \*options* ) [源代码]

使用 spawn 方法启动多进程任务。

注解

spawn 目前仅支持 GPU collective模式.

参数

  • func (function) - 由 spawn 方法启动的进程所调用的目标函数。该目标函数需要能够被 pickled (序列化)，所以目标函数必须定义为模块的一级函数，不能是内部子函数或者类方法。

  • args (tuple, 可选) - 传入目标函数 func 的参数。

  • nprocs (int, 可选) - 启动进程的数目。默认值为-1。当 nproc 为-1时，模型执行时将会从环境变量中获取当前可用的所有设备进行使用：如果使用GPU执行任务，将会从环境变量 CUDA_VISIBLE_DEVICES 中获取当前所有可用的设备ID；如果使用CPU执行任务，将会从环境变量 CPU_NUM 中获取当前可用的CPU设备数，例如，可以通过指令 export CPU_NUM=4 配置默认可用CPU设备数，如果此环境变量没有设置，将会默认设置该环境变量的值为1。

  • join (bool, 可选) - 对所有启动的进程执行阻塞的 join ，等待进程执行结束。默认为True。

  • daemon (bool, 可选) - 配置启动进程的 daemon 属性。默认为False。

  • **options (dict, 可选) - 其他初始化并行执行环境的配置选项。目前支持以下选项： (1) start_method (string) - 启动子进程的方法。进程的启动方法可以是 spawn ， fork , forkserver 。 因为CUDA运行时环境不支持 fork 方法，当在子进程中使用CUDA时，需要使用 spawn 或者 forkserver 方法启动进程。默认方法为 spawn ； (2) gpus (string) - 指定训练使用的GPU ID, 例如 “0,1,2,3” ， 默认值为None ； (3) ips (string) - 运行集群的节点（机器）IP，例如 “192.168.0.16,192.168.0.17” ，默认值为 “127.0.0.1” 。

返回

MultiprocessContext 对象，持有创建的多个进程。

代码示例

  1. from __future__ import print_function
  3. import paddle
  4. import paddle.nn as nn
  5. import paddle.optimizer as opt
  6. import paddle.distributed as dist
  8. class LinearNet(nn.Layer):
  9.     def __init__(self):
  10.         super(LinearNet, self).__init__()
  11.         self._linear1 = nn.Linear(10, 10)
  12.         self._linear2 = nn.Linear(10, 1)
  14.     def forward(self, x):
  15.         return self._linear2(self._linear1(x))
  17. def train(print_result=False):
  18.     # 1. initialize parallel environment
  19.     dist.init_parallel_env()
  21.     # 2. create data parallel layer & optimizer
  22.     layer = LinearNet()
  23.     dp_layer = paddle.DataParallel(layer)
  25.     loss_fn = nn.MSELoss()
  26.     adam = opt.Adam(
  27.         learning_rate=0.001, parameters=dp_layer.parameters())
  29.     # 3. run layer
  30.     inputs = paddle.randn([10, 10], 'float32')
  31.     outputs = dp_layer(inputs)
  32.     labels = paddle.randn([10, 1], 'float32')
  33.     loss = loss_fn(outputs, labels)
  35.     if print_result is True:
  36.         print("loss:", loss.numpy())
  38.     loss.backward()
  40.     adam.step()
  41.     adam.clear_grad()
  43. # Usage 1: only pass function.
  44. # If your training method no need any argument, and
  45. # use all visible devices for parallel training.
  46. if __name__ == '__main__':
  47.     dist.spawn(train)
  49. # Usage 2: pass function and arguments.
  50. # If your training method need some arguments, and
  51. # use all visible devices for parallel training.
  52. if __name__ == '__main__':
  53.     dist.spawn(train, args=(True,))
  55. # Usage 3: pass function, arguments and nprocs.
  56. # If your training method need some arguments, and
  57. # only use part of visible devices for parallel training.
  58. # If your machine hold 8 cards {0,1,2,3,4,5,6,7},
  59. # this case will use cards {0,1}; If you set
  60. # CUDA_VISIBLE_DEVICES=4,5,6,7, this case will use
  61. # cards {4,5}
  62. if __name__ == '__main__':
  63.     dist.spawn(train, args=(True,), nprocs=2)
  65. # Usage 4: pass function, arguments, nprocs and gpus.
  66. # If your training method need some arguments, and
  67. # only use part of visible devices for parallel training,
  68. # but you can't set your machine's environment variable
  69. # CUDA_VISIBLE_DEVICES, such as it is None or all cards
  70. # {0,1,2,3,4,5,6,7}, you can pass `gpus` to
  71. # select the GPU cards you want to use. For example,
  72. # this case will use cards {4,5} if your machine hold 8 cards.
  73. if __name__ == '__main__':
  74.     dist.spawn(train, args=(True,), nprocs=2, gpus='4,5')