diff --git a/doc/fluid/api_cn/fluid_cn/DistributeTranspiler_cn.rst b/doc/fluid/api_cn/fluid_cn/DistributeTranspiler_cn.rst index 151949d16d89bb46d8bab3ee2330ad31d215bc71..8876419cd8271936283b7a45cd2aa2858941bdb6 100644 --- a/doc/fluid/api_cn/fluid_cn/DistributeTranspiler_cn.rst +++ b/doc/fluid/api_cn/fluid_cn/DistributeTranspiler_cn.rst @@ -1,4 +1,4 @@ -.. _cn_api_fluid_DistributeTranspiler: +.. _cn_api_fluid_transpiler_DistributeTranspiler: DistributeTranspiler ------------------------------- @@ -6,80 +6,89 @@ DistributeTranspiler .. py:class:: paddle.fluid.DistributeTranspiler (config=None) -该类可以把fluid program转变为分布式数据并行计算程序（distributed data-parallelism programs）,可以有Pserver和NCCL2两种模式。 -当program在Pserver（全称：parameter server）模式下， ``main_program`` (主程序)转为使用一架远程parameter server(即pserver,参数服务器)来进行参数优化，并且优化图会被输入到一个pserver program中。 -在NCCL2模式下，transpiler会在 ``startup_program`` 中附加一个 ``NCCL_ID`` 广播算子（broadcasting operators）来实现在该集群中所有工作结点共享 ``NCCL_ID`` 。 -调用 ``transpile_nccl2`` 后， 你 **必须** 将 ``trainer_id`` , ``num_trainers`` 参数提供给 ``ParallelExecutor`` 来启动NCCL2分布式模式。 +该类可以把fluid program转变为分布式数据并行计算的program, 有PServer和NCCL2两种模式。 +在Pserver（全称：parameter server）模式下， 通过 ``transpile`` 将用于单机训练的 ``program`` 转译为可用于parameter server的分布式架构(即PServer,参数服务器)来进行训练的program。 +在NCCL2模式下, 通过 ``transpile`` 将用于单机训练的 ``program`` 转译为可用于NCCL2的分布式架构来进行训练的program。在NCCL2模式下，transpiler会在 ``startup_program`` 中附加一个 ``NCCL_ID`` 广播 +算子（broadcasting operators）来实现在该集群中所有工作结点共享``NCCL_ID`` 。 调用 ``transpile_nccl2`` 后， 你 **必须** 将 ``trainer_id`` , ``num_trainers`` 参数提供给 ``Executor`` 来启动NCCL2分布式模式。 +参数： + - **config** （DistributeTranspilerConfig） DistributeTranspiler属性配置实例，定义了program转变所需要的属性, 请参考：`DistributeTranspilerConfig` 相关文档。 + +返回：初始化后的DistributeTranspiler实例 + +返回类型：实例（DistributeTranspiler） **代码示例** .. code-block:: python - import paddle.fluid as fluid - x = fluid.layers.data(name='x', shape=[13], dtype='float32') - y = fluid.layers.data(name='y', shape=[1], dtype='float32') - y_predict = fluid.layers.fc(input=x, size=1, act=None) - - cost = fluid.layers.square_error_cost(input=y_predict, label=y) - avg_loss = fluid.layers.mean(cost) - - sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.001) - sgd_optimizer.minimize(avg_loss) - - #pserver模式下 - pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174" - trainer_endpoints = "192.168.0.1:6174,192.168.0.2:6174" - current_endpoint = "192.168.0.1:6174" - trainer_id = 0 - trainers = 4 - role = "PSERVER" - - t = fluid.DistributeTranspiler() - t.transpile(trainer_id, pservers=pserver_endpoints, trainers=trainers) - if role == "PSERVER": - pserver_program = t.get_pserver_program(current_endpoint) - pserver_startup_program = t.get_startup_program(current_endpoint, pserver_program) - elif role == "TRAINER": - trainer_program = t.get_trainer_program() - - # nccl2模式下 - trainer_num = 2 - trainer_id = 0 - config = fluid.DistributeTranspilerConfig() - config.mode = "nccl2" - trainer_endpoints = "192.168.0.1:6174,192.168.0.2:6174" - t = fluid.DistributeTranspiler(config=config) - t.transpile(trainer_id=trainer_id, trainers=trainer_endpoints, current_endpoint="192.168.0.1:6174") - exe = fluid.ParallelExecutor( - loss_name=avg_loss.name, - num_trainers=len(trainer_num, - trainer_id=trainer_id - ) + x = fluid.layers.data(name='x', shape=[13], dtype='float32') + y = fluid.layers.data(name='y', shape=[1], dtype='float32') + y_predict = fluid.layers.fc(input=x, size=1, act=None) + + cost = fluid.layers.square_error_cost(input=y_predict, label=y) + avg_loss = fluid.layers.mean(cost) + + sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.001) + sgd_optimizer.minimize(avg_loss) + + # pserver 模式下 + pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174" + trainer_endpoints = "192.168.0.1:6174,192.168.0.2:6174" + current_endpoint = "192.168.0.1:6174" + trainer_id = 0 + trainers = 4 + role = "PSERVER" + t = fluid.DistributeTranspiler() + t.transpile( + trainer_id, pservers=pserver_endpoints, trainers=trainers) + if role == "PSERVER": + pserver_program = t.get_pserver_program(current_endpoint) + pserver_startup_program = t.get_startup_program(current_endpoint, + pserver_program) + elif role == "TRAINER": + trainer_program = t.get_trainer_program() + + # nccl2 模式下 + trainer_num = 2 + trainer_id = 0 + config = fluid.DistributeTranspilerConfig() + config.mode = "nccl2" + trainer_endpoints = "192.168.0.1:6174,192.168.0.2:6174" + t = fluid.DistributeTranspiler(config=config) + t.transpile(trainer_id=trainer_id, trainers=trainer_endpoints, current_endpoint="192.168.0.1:6174") + exe = fluid.ParallelExecutor( + use_cuda=True, + loss_name=avg_loss.name, + num_trainers=trainer_num, + trainer_id=trainer_id + ) .. py:method:: transpile(trainer_id, program=None, pservers='127.0.0.1:6174', trainers=1, sync_mode=True, startup_program=None, current_endpoint='127.0.0.1:6174') -该方法可以运行该transpiler（转译器）。转译输入程序。 +通过此方法，可根据用户配置将单机的program转换为当前节点可用的数据并行的分布式program。 参数: - - **trainer_id** (int) – 当前Trainer worker的id, 如果有n个Trainer worker, id 取值范围为0 ~ n-1 - - **program** (Program|None) – 待transpile（转译）的program, 缺省为 ``fluid.default_main_program()`` - - **startup_program** (Program|None) - 要转译的 ``startup_program`` ,默认为 ``fluid.default_startup_program()`` - - **pservers** (str) – 内容为Pserver列表的字符串，格式为：按逗号区分不同的Pserver，每个Pserver的格式为 *ip地址:端口号* - - **trainers** (int|str) – 在Pserver模式下，该参数指Trainer机的个数；在nccl2模式下，它是一个内容为Trainer终端列表的字符串 - - **sync_mode** (bool) – 是否做同步训练(synchronous training), 默认为True - - **startup_program** (Program|None) – 待transpile（转译）的startup_program，默认为 ``fluid.default_main_program()`` - - **current_endpoint** (str) – 当需要把program转译（transpile）至NCCL2模式下时，需要将当前endpoint（终端）传入该参数。Pserver模式不使用该参数 + - **trainer_id** (int) – 当前Trainer worker的id, 如果有n个Trainer worker, id 取值范围为0 ~ n-1 + - **program** (Program|None) – 待transpile（转译）的program, 缺省为 ``fluid.default_main_program()`` + - **startup_program** (Program|None) - 要转译的 ``startup_program`` ,默认为 ``fluid.default_startup_program()`` + - **pservers** (str) – 内容为Pserver列表的字符串，格式为：按逗号区分不同的Pserver，每个Pserver的格式为 *ip地址:端口号* + - **trainers** (int|str) – 在Pserver模式下，该参数指Trainer机的个数；在nccl2模式下，它是一个内容为Trainer终端列表的字符串 + - **sync_mode** (bool) – 是否做同步训练(synchronous training), 默认为True + - **startup_program** (Program|None) – 待transpile（转译）的startup_program，默认为 ``fluid.default_main_program()`` + - **current_endpoint** (str) – 当需要把program转译（transpile）至NCCL2模式下时，需要将当前endpoint（终端）传入该参数。PServer模型下，当用户需要使用增量训练时，必须要指定该参数。 + +返回：None + **代码示例** .. code-block:: python - import paddle.fluid as fluid transpiler = fluid.DistributeTranspiler() t.transpile( trainer_id=0, @@ -89,28 +98,27 @@ DistributeTranspiler current_endpoint="127.0.0.1:7000") - .. py:method:: get_trainer_program(wait_port=True) 该方法可以得到Trainer侧的program。 -返回: Trainer侧的program +返回: Trainer侧的program -返回类型: Program +返回类型: Program **代码示例** .. code-block:: python - import paddle.fluid as fluid - #this is an example, find available endpoints in your case - pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174" - trainer_id = 0 - trainers = 4 - t = fluid.DistributeTranspiler() - t.transpile(trainer_id, trainers=trainers, pservers=pserver_endpoints) - trainer_program = t.get_trainer_program() + import paddle.fluid as fluid + # 这是一个示例，请根据你的情况更改endpoint + pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174" + trainer_id = 0 + trainers = 4 + t = fluid.DistributeTranspiler() + t.transpile(trainer_id, trainers=trainers, pservers=pserver_endpoints) + trainer_program = t.get_trainer_program() .. py:method:: get_pserver_program(endpoint) @@ -119,26 +127,26 @@ DistributeTranspiler 该方法可以得到Pserver（参数服务器）侧的程序 参数: - - **endpoint** (str) – 当前Pserver终端 + - **endpoint** (str) – 当前Pserver终端 -返回: 当前Pserver需要执行的program +返回: 当前Pserver需要执行的program -返回类型: Program +返回类型: Program **代码示例** .. code-block:: python - import paddle.fluid as fluid - #this is an example, find available endpoints in your case - pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174" - current_endpoint = "192.168.0.1:6174" - trainer_id = 0 - trainers = 4 - t = fluid.DistributeTranspiler() - t.transpile( - trainer_id, pservers=pserver_endpoints, trainers=trainers) - pserver_program = t.get_pserver_program(current_endpoint) + import paddle.fluid as fluid + # 这是一个示例，请根据你的情况更改endpoint + pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174" + current_endpoint = "192.168.0.1:6174" + trainer_id = 0 + trainers = 4 + t = fluid.DistributeTranspiler() + t.transpile( + trainer_id, pservers=pserver_endpoints, trainers=trainers) + pserver_program = t.get_pserver_program(current_endpoint) .. py:method:: get_pserver_programs(endpoint) @@ -147,27 +155,27 @@ DistributeTranspiler 该方法可以得到Pserver侧用于分布式训练的 ``main_program`` 和 ``startup_program`` 。 参数: - - **endpoint** (str) – 当前Pserver终端 + - **endpoint** (str) – 当前Pserver终端 -返回: (main_program, startup_program), “Program”类型的元组 +返回: (main_program, startup_program), “Program”类型的元组 + +返回类型: tuple -返回类型: tuple **代码示例** .. code-block:: python - import paddle.fluid as fluid - #this is an example, find available endpoints in your case - pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174" - current_endpoint = "192.168.0.1:6174" - trainer_id = 0 - trainers = 4 - t = fluid.DistributeTranspiler() - t.transpile( - trainer_id, pservers=pserver_endpoints, trainers=trainers) - pserver_program, pserver_startup_program = t.get_pserver_programs(current_endpoint) - + import paddle.fluid as fluid + # 这是一个示例，请根据你的情况更改endpoint + pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174" + current_endpoint = "192.168.0.1:6174" + trainer_id = 0 + trainers = 4 + t = fluid.DistributeTranspiler() + t.transpile( + trainer_id, pservers=pserver_endpoints, trainers=trainers) + pserver_program, pserver_startup_program = t.get_pserver_programs(current_endpoint) .. py:method:: get_startup_program(endpoint, pserver_program=None, startup_program=None) @@ -177,33 +185,29 @@ DistributeTranspiler 获取当前Pserver的startup_program，如果有多个被分散到不同blocks的变量，则修改operator的输入变量。 参数: - - **endpoint** (str) – 当前Pserver终端 - - **pserver_program** (Program) – 已停止使用。 先调用get_pserver_program - - **startup_program** (Program) – 已停止使用。应在初始化时传入startup_program + - **endpoint** (str) – 当前Pserver终端 + - **pserver_program** (Program) – 已停止使用。 先调用get_pserver_program + - **startup_program** (Program) – 已停止使用。应在初始化时传入startup_program -返回: Pserver侧的startup_program +返回: Pserver侧的startup_program -返回类型: Program +返回类型: Program **代码示例** .. code-block:: python - import paddle.fluid as fluid - pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174" - trainer_endpoints = "192.168.0.1:6174,192.168.0.2:6174" - current_endpoint = "192.168.0.1:6174" - trainer_id = 0 - trainers = 4 - - t = fluid.DistributeTranspiler() - t.transpile(trainer_id, pservers=pserver_endpoints, trainers=trainers) - pserver_program = t.get_pserver_program(current_endpoint) - pserver_startup_program = t.get_startup_program(current_endpoint, - pserver_program) - - - + pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174" + trainer_endpoints = "192.168.0.1:6174,192.168.0.2:6174" + current_endpoint = "192.168.0.1:6174" + trainer_id = 0 + trainers = 4 + + t = fluid.DistributeTranspiler() + t.transpile(trainer_id, pservers=pserver_endpoints, trainers=trainers) + pserver_program = t.get_pserver_program(current_endpoint) + pserver_startup_program = t.get_startup_program(current_endpoint, + pserver_program) diff --git a/doc/fluid/api_cn/fluid_cn/ExecutionStrategy_cn.rst b/doc/fluid/api_cn/fluid_cn/ExecutionStrategy_cn.rst index d901675c6870327e6faed05438fc33a044320db2..108f81210f20e810bd32cabe395efc76e336f310 100644 --- a/doc/fluid/api_cn/fluid_cn/ExecutionStrategy_cn.rst +++ b/doc/fluid/api_cn/fluid_cn/ExecutionStrategy_cn.rst @@ -5,7 +5,11 @@ ExecutionStrategy .. py:class:: paddle.fluid.ExecutionStrategy -``ExecutionStrategy`` 允许用户更加精准地控制program在 ``ParallelExecutor`` 中的运行方式。可以通过在 ``ParallelExecutor`` 中设置本成员来实现。 +通过设置 ``ExecutionStrategy`` 中的选项，用户可以对执行器的执行配置进行调整，比如设置执行器中线程池的大小等。 + +返回：初始化后的ExecutionStrategy的实例 + +返回类型：ExecutionStrategy **代码示例** @@ -30,28 +34,18 @@ ExecutionStrategy exec_strategy=exec_strategy) - -.. py:attribute:: allow_op_delay - -这是一个bool类型成员，表示是否推迟communication operators(交流运算)的执行，这样做会使整体执行过程更快一些。此选项现在已经失效，在下个版本中将会被移除。默认为False。 - - - .. py:attribute:: num_iteration_per_drop_scope -int型成员。它表明了清空执行时产生的临时变量需要的程序执行迭代次数。因为临时变量的形状可能在两次重复过程中保持一致，所以它会使整体执行过程更快。默认值为1。 +int型成员。该选项表示间隔多少次迭代之后清理一次临时变量。模型运行过程中，生成的中间临时变量将被放到local execution scope中，为了避免对临时变量频繁的申请与释放，通常将其设为较大的值（比如10或者100）。默认值为100。 -.. note:: - 1. 如果在调用 ``run`` 方法时获取结果数据，``ParallelExecutor`` 会在当前程序重复执行尾部清空临时变量 - - 2. 在一些NLP模型里，该成员会致使GPU内存不足。此时，你应减少 ``num_iteration_per_drop_scope`` 的值 .. py:attribute:: num_iteration_per_run -它配置了当用户在python脚本中调用pe.run()时执行器会执行的迭代次数。 + +int型成员。它配置了当用户在python脚本中调用pe.run()时执行器会执行的迭代次数。Executor每次调用，会进行num_iteration_per_run次训练，它会使整体执行过程更快。 .. py:attribute:: num_threads -int型成员。它代表了线程池(thread pool)的大小。这些线程会被用来执行当前 ``ParallelExecutor`` 的program中的operator（算子，运算）。如果 :math:`num\_threads=1` ，则所有的operator将一个接一个地执行，但在不同的程序重复周期(iterations)中执行顺序可能不同。如果该成员没有被设置，则在 ``ParallelExecutor`` 中，它会依据设备类型(device type)、设备数目(device count)而设置为相应值。对GPU，:math:`num\_threads=device\_count∗4` ；对CPU， :math:`num\_threads=CPU\_NUM∗4` 。在 ``ParallelExecutor`` 中有关于 :math:`CPU\_NUM` 的详细解释。如果没有设置 :math:`CPU\_NUM` ， ``ParallelExecutor`` 可以通过调用 ``multiprocessing.cpu_count()`` 获取CPU数目(cpu count)。默认值为0。 +int型成员。该选项表示当前 ``Executor`` 的线程池(thread pool)的大小, 此线程池可用来并发执行program中的operator（算子，运算）。如果 :math:`num\_threads=1` ，则所有的operator将一个接一个地执行，但在不同的program重复周期(iterations)中执行顺序可能不同。如果该选项没有被设置，则在 ``Executor`` 中，它会依据设备类型(device type)、设备数目(device count)而设置为相应值。对GPU，:math:`num\_threads=device\_count∗4` ；对CPU， :math:`num\_threads=CPU\_NUM∗4` 。在 ``Executor`` 中有关于 :math:`CPU\_NUM` 的详细解释。如果没有设置 :math:`CPU\_NUM` ，则设置默认值为1， 并提示用户进行 :math:`CPU\_NUM` 的设置。 diff --git a/doc/fluid/api_cn/layers_cn/sampling_id_cn.rst b/doc/fluid/api_cn/layers_cn/sampling_id_cn.rst index dc444fb1aacccc3e35fd4bcb8ec06a29d33eff35..637ba97be936623f912f8e1cb3d994bb7198ea01 100644 --- a/doc/fluid/api_cn/layers_cn/sampling_id_cn.rst +++ b/doc/fluid/api_cn/layers_cn/sampling_id_cn.rst @@ -11,12 +11,12 @@ sampling_id - **x** （Variable）- 输入Tensor。一个形如[batch_size，input_feature_dimensions]的2-D Tensor。 - **min** （Float）- 随机的最小值。默认值为为0.0。 - **max** （Float）- 随机的最大值。默认值为1.0。 - - **seed** （int）- 随机种子。0表示使用系统生成的种子。请注意，如果seed不为0，则此算子将始终每次生成相同的随机数。默认值为0 + - **seed** （int）- 随机种子。0表示使用系统生成的种子, 默认值为0。请注意，如果seed不为0，则此算子每次调用将生成相同的随机数。 - **dtype** （np.dtype | core.VarDesc.VarType | str）- 指定输出数据的类型。 -返回：采样的数据Tensor +返回：采样的数据张量（Tensor） -返回类型：Variable +返回类型：变量（Variable） **代码示例：** diff --git a/doc/fluid/api_cn/transpiler_cn/DistributeTranspilerConfig_cn.rst b/doc/fluid/api_cn/transpiler_cn/DistributeTranspilerConfig_cn.rst index 280b40fe3c1c7b71be6c2d496d85ea85a3091790..d27a83e502e7223661c307292534346bf3491795 100644 --- a/doc/fluid/api_cn/transpiler_cn/DistributeTranspilerConfig_cn.rst +++ b/doc/fluid/api_cn/transpiler_cn/DistributeTranspilerConfig_cn.rst @@ -5,13 +5,16 @@ DistributeTranspilerConfig .. py:class:: paddle.fluid.transpiler.DistributeTranspilerConfig -单机任务切换为分布式任务的配置类，其中较为重要的几个配置参数如下所示： +单机任务切换为分布式任务的配置类，用户可根据需求进行配置，如指定同步/异步训练，指定节点个数及模型切分逻辑。 -.. py:method:: slice_var_up (bool) +返回：None -是否为Pserver将张量切片， 默认为True +.. py:attribute:: slice_var_up (bool) -.. py:method:: split_method (PSDispatcher) +是否为Pserver将张量切片， 默认为True, bool类型属性， 默认为True。该参数将指定是否将参数/梯度切分后均匀分布于多个PServer上。slice_var_up为True的情况下，会将参数均匀切分后分布于多个PServer端，使每个PServer的负载相对均衡。 + + +.. py:attribute:: split_method (PSDispatcher) 参数分发的方式，当前支持的方法包括 :ref:`cn_api_fluid_transpiler_RoundRobin` 和 :ref:`cn_api_fluid_transpiler_HashName` 两种， 默认为RoundRobin。 diff --git a/doc/fluid/api_cn/transpiler_cn/DistributeTranspiler_cn.rst b/doc/fluid/api_cn/transpiler_cn/DistributeTranspiler_cn.rst index b8389cd393476a7e2e067f66b14b73d658cdecbe..bac6d389cc11377193a50a64576a211e6e807a02 100644 --- a/doc/fluid/api_cn/transpiler_cn/DistributeTranspiler_cn.rst +++ b/doc/fluid/api_cn/transpiler_cn/DistributeTranspiler_cn.rst @@ -6,12 +6,17 @@ DistributeTranspiler .. py:class:: paddle.fluid.transpiler.DistributeTranspiler (config=None) -该类可以把fluid program转变为分布式数据并行计算程序（distributed data-parallelism programs）,可以有Pserver和NCCL2两种模式。 -当program在Pserver（全称：parameter server）模式下， ``main_program`` (主程序)转为使用一架远程parameter server(即pserver,参数服务器)来进行参数优化，并且优化图会被输入到一个pserver program中。 -在NCCL2模式下，transpiler会在 ``startup_program`` 中附加一个 ``NCCL_ID`` 广播算子（broadcasting operators）来实现在该集群中所有工作结点共享``NCCL_ID`` 。 -调用 ``transpile_nccl2`` 后， 你 **必须** 将 ``trainer_id`` , ``num_trainers`` 参数提供给 ``ParallelExecutor`` 来启动NCCL2分布式模式。 +该类可以把fluid program转变为分布式数据并行计算的program, 有PServer和NCCL2两种模式。 +在Pserver（全称：parameter server）模式下， 通过 ``transpile`` 将用于单机训练的 ``program`` 转译为可用于parameter server的分布式架构(即PServer,参数服务器)来进行训练的program。 +在NCCL2模式下, 通过 ``transpile`` 将用于单机训练的 ``program`` 转译为可用于NCCL2的分布式架构来进行训练的program。在NCCL2模式下，transpiler会在 ``startup_program`` 中附加一个 ``NCCL_ID`` 广播算子（broadcasting operators）来实现在该集群中所有工作结点共享``NCCL_ID`` 。 调用 ``transpile_nccl2`` 后， 你 **必须** 将 ``trainer_id`` , ``num_trainers`` 参数提供给 ``Executor`` 来启动NCCL2分布式模式。 +参数： + - **config** （DistributeTranspilerConfig） DistributeTranspiler属性配置实例，定义了program转变所需要的属性, 请参考：`DistributeTranspilerConfig` 相关文档。 + +返回：初始化后的DistributeTranspiler实例 + +返回类型：实例（DistributeTranspiler） **代码示例** @@ -64,17 +69,19 @@ DistributeTranspiler .. py:method:: transpile(trainer_id, program=None, pservers='127.0.0.1:6174', trainers=1, sync_mode=True, startup_program=None, current_endpoint='127.0.0.1:6174') -该方法可以运行该transpiler（转译器）。转译输入程序。 +通过此方法，可根据用户配置将单机的program转换为当前节点可用的数据并行的分布式program。 参数: - **trainer_id** (int) – 当前Trainer worker的id, 如果有n个Trainer worker, id 取值范围为0 ~ n-1 - - **program** (Program|None) – 待transpile（转译）的program, 缺省为 ``fluid.default_main_program()`` - - **startup_program** (Program|None) - 要转译的 ``startup_program`` ,默认为 ``fluid.default_startup_program()`` + - **program** (Program|None) – 待transpile（转译）的main program, 默认为 ``fluid.default_main_program()`` - **pservers** (str) – 内容为Pserver列表的字符串，格式为：按逗号区分不同的Pserver，每个Pserver的格式为 *ip地址:端口号* - **trainers** (int|str) – 在Pserver模式下，该参数指Trainer机的个数；在nccl2模式下，它是一个内容为Trainer终端列表的字符串 - **sync_mode** (bool) – 是否做同步训练(synchronous training), 默认为True - - **startup_program** (Program|None) – 待transpile（转译）的startup_program，默认为 ``fluid.default_main_program()`` - - **current_endpoint** (str) – 当需要把program转译（transpile）至NCCL2模式下时，需要将当前endpoint（终端）传入该参数。Pserver模式不使用该参数 + - **startup_program** (Program|None) – 待transpile（转译）的startup program，默认为 ``fluid.default_startup_program()`` + - **current_endpoint** (str) – 当需要把program转译（transpile）至NCCL2模式时，需要将当前endpoint（终端）传入该参数。PServer模型下，当用户需要使用增量训练时，必须要指定该参数。 + +返回：None + **代码示例** diff --git a/doc/fluid/api_cn/transpiler_cn/HashName_cn.rst b/doc/fluid/api_cn/transpiler_cn/HashName_cn.rst index 38806eeee0149bb3b460c7704ab1d6ebb88180d1..95b91d59df9857bdd985ddf8cf4dfdf4cc48ffe4 100644 --- a/doc/fluid/api_cn/transpiler_cn/HashName_cn.rst +++ b/doc/fluid/api_cn/transpiler_cn/HashName_cn.rst @@ -5,20 +5,41 @@ HashName .. py:class:: paddle.fluid.transpiler.HashName(pserver_endpoints) -使用 python ``Hash()`` 函数将变量名散列到多个pserver终端。 +该方法使用 python ``Hash()`` 函数将变量散列到多个parameter server节点。 参数: - **pserver_endpoints** (list) - endpoint （ip:port）的 list +返回：实例化后的HashName的对象 + +返回类型：HashName + **代码示例** .. code-block:: python + import paddle.fluid.transpiler.HashName as HashName + pserver_endpoints = [“127.0.0.1:6007”, “127.0.0.1:6008”] vars = [“var1”,”var2”,”var3”,”var4”,”var5”] - rr = RoundRobin(pserver_endpoints) + rr = HashName(pserver_endpoints) rr.dispatch(vars) +.. py:method:: reset() + +该方法将重置HashName内置的计数， 计数将重置为0。 + +返回：无。 + +**代码示例** + +.. code-block:: python + import paddle.fluid.transpiler.HashName as HashName + + pserver_endpoints = [“127.0.0.1:6007”, “127.0.0.1:6008”] + vars = [“var1”,”var2”,”var3”,”var4”,”var5”] + rr = HashName(pserver_endpoints) + rr.reset() diff --git a/doc/fluid/api_cn/transpiler_cn/RoundRobin_cn.rst b/doc/fluid/api_cn/transpiler_cn/RoundRobin_cn.rst index b0adc05ed1670580bc0a0910f80b6a808d88db82..fd4ad3a1ac9192081b6582155e973d99a05b4442 100644 --- a/doc/fluid/api_cn/transpiler_cn/RoundRobin_cn.rst +++ b/doc/fluid/api_cn/transpiler_cn/RoundRobin_cn.rst @@ -5,13 +5,40 @@ RoundRobin .. py:class:: paddle.fluid.transpiler.RoundRobin(pserver_endpoints) -使用 ``RondRobin`` 方法将变量分配给服务器端点。 +该方法使用 ``RoundRobin`` 的方式将变量散列到多个parameter server终端。 `RondRobin `_ 参数: - **pserver_endpoints** (list) - endpoint （ip:port）的 list - + +返回：实例化后的RoundRobin的对象 + +返回类型：RoundRobin + +**代码示例** + +.. code-block:: python + + import paddle.fluid.transpiler.RoundRobin as RoundRobin + + pserver_endpoints = [“127.0.0.1:6007”, “127.0.0.1:6008”] + vars = [“var1”,”var2”,”var3”,”var4”,”var5”] + rr = RoundRobin(pserver_endpoints) + rr.dispatch(vars) + + +.. py:method:: dispatch(varlist) + +该方法使用RoundRobin的方式将多个参数散列到多个parameter Server终端。 + +参数: + - **varlist** (list) - 参数 (var1, var2, var3) 的 list + +返回：基于varlist中var的顺序，返回参数服务器(ip:port)的列表， 列表中的数据量和varlist的数据量一致。 + +返回类型：list + **代码示例** .. code-block:: python @@ -22,5 +49,19 @@ RoundRobin rr.dispatch(vars) +.. py:method:: reset() + +该方法将重置RoundRobin内置的计数， 计数将重置为0。 + +返回：无。 + +**代码示例** + +.. code-block:: python + + pserver_endpoints = [“127.0.0.1:6007”, “127.0.0.1:6008”] + vars = [“var1”,”var2”,”var3”,”var4”,”var5”] + rr = RoundRobin(pserver_endpoints) + rr.reset()