• fluid.optimizer
    • Adadelta
    • Adagrad
    • AdagradOptimizer
    • Adam
    • Adamax
    • AdamaxOptimizer
    • AdamOptimizer
    • DecayedAdagrad
    • DecayedAdagradOptimizer
    • DGCMomentumOptimizer
    • ExponentialMovingAverage
    • Ftrl
    • FtrlOptimizer
    • LambOptimizer
    • LarsMomentum
    • LarsMomentumOptimizer
    • ModelAverage
    • Momentum
    • MomentumOptimizer
    • PipelineOptimizer
    • RMSPropOptimizer
    • SGD
    • SGDOptimizer

    fluid.optimizer

    SourceEnglish

    Adadelta

    SourceEnglish

    • paddle.fluid.optimizer.Adadelta
    • AdadeltaOptimizer 的别名

    Adagrad

    SourceEnglish

    • paddle.fluid.optimizer.Adagrad
    • AdagradOptimizer 的别名

    AdagradOptimizer

    SourceEnglish

    • class paddle.fluid.optimizer.AdagradOptimizer(learning_rate, epsilon=1e-06, regularization=None, name=None, initial_accumulator_value=0.0)
    • Adaptive Gradient Algorithm(Adagrad)

    更新如下：

    fluid.optimizer - 图1

    原始论文（http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf）没有epsilon属性。在我们的实现中也作了如下更新：http://cs231n.github.io/neural-networks-3/#ada 用于维持数值稳定性，避免除数为0的错误发生。

    • 参数：
      • learning_rate (float|Variable)-学习率，用于更新参数。作为数据参数，可以是一个浮点类型值或者有一个浮点类型值的变量
      • epsilon (float) - 维持数值稳定性的短浮点型值
      • regularization - 规则化函数，例如fluid.regularizer.L2DecayRegularizer
      • name - 名称前缀（可选）
      • initial_accumulator_value (float) - moment累加器的初始值。代码示例：
    1. import paddle.fluid as fluid
    2. import numpy as np
    3.  
    4. np_inp = np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)
    5. inp = fluid.layers.data(
    6.     name="inp", shape=[2, 2], append_batch_size=False)
    7. out = fluid.layers.fc(inp, size=3)
    8. out = fluid.layers.reduce_sum(out)
    9. optimizer = fluid.optimizer.Adagrad(learning_rate=0.2)
    10. optimizer.minimize(out)
    11.  
    12. exe = fluid.Executor(fluid.CPUPlace())
    13. exe.run(fluid.default_startup_program())
    14. exe.run(
    15.     feed={"inp": np_inp},
    16.     fetch_list=[out.name])

    Adam

    SourceEnglish

    • paddle.fluid.optimizer.Adam
    • AdamOptimizer 的别名

    Adamax

    SourceEnglish

    • paddle.fluid.optimizer.Adamax
    • AdamaxOptimizer 的别名

    AdamaxOptimizer

    SourceEnglish

    • class paddle.fluid.optimizer.AdamaxOptimizer(learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-08, regularization=None, name=None)
    • 我们参考Adam论文第7节中的Adamax优化: https://arxiv.org/abs/1412.6980 ， Adamax是基于无穷大范数的Adam算法的一个变种。

    Adamax 更新规则:

    fluid.optimizer - 图2

    fluid.optimizer - 图3

    fluid.optimizer - 图4

    fluid.optimizer - 图5

    fluid.optimizer - 图6

    论文中没有 epsilon 参数。但是，为了数值稳定性， 防止除0错误， 增加了这个参数

    代码示例：

    1. import paddle.fluid as fluid
    2. import numpy
    3.  
    4. # First create the Executor.
    5. place = fluid.CPUPlace() # fluid.CUDAPlace(0)
    6. exe = fluid.Executor(place)
    7.  
    8. train_program = fluid.Program()
    9. startup_program = fluid.Program()
    10. with fluid.program_guard(train_program, startup_program):
    11.     data = fluid.layers.data(name='X', shape=[1], dtype='float32')
    12.     hidden = fluid.layers.fc(input=data, size=10)
    13.     loss = fluid.layers.mean(hidden)
    14.     adam = fluid.optimizer.Adamax(learning_rate=0.2)
    15.     adam.minimize(loss)
    16.  
    17. # Run the startup program once and only once.
    18. exe.run(startup_program)
    19.  
    20. x = numpy.random.random(size=(10, 1)).astype('float32')
    21. outs = exe.run(program=train_program,
    22.               feed={'X': x},
    23.                fetch_list=[loss.name])
    • 参数:
      • learning_rate (float|Variable) - 用于更新参数的学习率。可以是浮点值，也可以是具有一个浮点值作为数据元素的变量。
      • beta1 (float) - 第1阶段估计的指数衰减率
      • beta2 (float) - 第2阶段估计的指数衰减率。
      • epsilon (float) -非常小的浮点值，为了数值的稳定性质
      • regularization - 正则化器，例如 fluid.regularizer.L2DecayRegularizer
      • name - 可选的名称前缀。

    注解

    目前 AdamaxOptimizer 不支持 sparse parameter optimization.

    AdamOptimizer

    SourceEnglish

    • class paddle.fluid.optimizer.AdamOptimizer(learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-08, regularization=None, name=None, lazy_mode=False)
    • 该函数实现了自适应矩估计优化器，介绍自 Adam论文 的第二节。Adam是一阶基于梯度下降的算法，基于自适应低阶矩估计。Adam更新如下：

    fluid.optimizer - 图7

    • 参数:
      • learning_rate (float|Variable)-学习率，用于更新参数。作为数据参数，可以是一个浮点类型值或有一个浮点类型值的变量
      • beta1 (float)-一阶矩估计的指数衰减率
      • beta2 (float)-二阶矩估计的指数衰减率
      • epsilon (float)-保持数值稳定性的短浮点类型值
      • regularization - 规则化函数，例如’‘fluid.regularizer.L2DecayRegularizer
      • name - 可选名称前缀
      • lazy_mode （bool: false） - 官方Adam算法有两个移动平均累加器（moving-average accumulators）。累加器在每一步都会更新。在密集模式和稀疏模式下，两条移动平均线的每个元素都会更新。如果参数非常大，那么更新可能很慢。 lazy mode仅更新当前具有梯度的元素，所以它会更快。但是这种模式与原始的算法有不同的描述，可能会导致不同的结果。代码示例：
    1. import paddle
    2. import paddle.fluid as fluid
    3.  
    4. place = fluid.CPUPlace()
    5. main = fluid.Program()
    6. with fluid.program_guard(main):
    7.     x = fluid.layers.data(name='x', shape=[13], dtype='float32')
    8.     y = fluid.layers.data(name='y', shape=[1], dtype='float32')
    9.     y_predict = fluid.layers.fc(input=x, size=1, act=None)
    10.     cost = fluid.layers.square_error_cost(input=y_predict, label=y)
    11.     avg_cost = fluid.layers.mean(cost)
    12.     adam_optimizer = fluid.optimizer.AdamOptimizer(0.01)
    13.     adam_optimizer.minimize(avg_cost)
    14.  
    15.     fetch_list = [avg_cost]
    16.     train_reader = paddle.batch(
    17.         paddle.dataset.uci_housing.train(), batch_size=1)
    18.     feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
    19.     exe = fluid.Executor(place)
    20.     exe.run(fluid.default_startup_program())
    21.     for data in train_reader():
    22.         exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list)

    DecayedAdagrad

    SourceEnglish

    • paddle.fluid.optimizer.DecayedAdagrad
    • DecayedAdagradOptimizer 的别名

    DecayedAdagradOptimizer

    SourceEnglish

    • class paddle.fluid.optimizer.DecayedAdagradOptimizer(learning_rate, decay=0.95, epsilon=1e-06, regularization=None, name=None)
    • Decayed Adagrad Optimizer

    原始论文

    原始论文： http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf 中没有 epsilon 参数。但是，为了数值稳定性， 防止除0错误， 增加了这个参数

    fluid.optimizer - 图8

    fluid.optimizer - 图9

    • 参数:
      • learning_rate (float|Variable) - 用于更新参数的学习率。可以是浮点值，也可以是具有一个浮点值作为数据元素的变量。
      • decay (float) – 衰减率
      • regularization - 一个正则化器，例如 fluid.regularizer.L2DecayRegularizer
      • epsilon (float) - 非常小的浮点值，为了数值稳定性
      • name — 可选的名称前缀。代码示例
    1. import paddle.fluid as fluid
    2. import paddle.fluid.layers as layers
    3. from paddle.fluid.optimizer import DecayedAdagrad
    4.  
    5. x = layers.data( name='x', shape=[-1, 10], dtype='float32' )
    6. trans = layers.fc( x, 100 )
    7. cost = layers.reduce_mean( trans )
    8. optimizer = fluid.optimizer.DecayedAdagrad(learning_rate=0.2)
    9. optimizer.minimize(cost)

    注解

    当前， DecayedAdagradOptimizer 不支持 sparse parameter optimization

    DGCMomentumOptimizer

    SourceEnglish

    • class paddle.fluid.optimizer.DGCMomentumOptimizer(learning_rate, momentum, rampup_begin_step, rampup_step=1, sparsity=[0.999], use_nesterov=False, local_grad_clip_norm=None, num_trainers=None, regularization=None, name=None)
    • 原始论文: https://arxiv.org/abs/1712.01887

    DGC通过仅发送重要梯度（稀疏更新）来减少通信带宽：仅发送大于给定阈值的梯度。

    为避免丢失信息，DGC在本地累积其余梯度。最终，这些梯度会积累到足够大，从而可以传输。

    因此，DGC即时发送相对较大的梯度，但最终随时间积累而发送所有梯度。

    此外，为了确保不损失精度，DGC在梯度稀疏化之上采用动量修正和局部梯度修剪(clip)来维持模型性能。

    DGC还使用动量因子掩藏(momentum factor masking)和预训练(warm-up)来克服由于reduced通讯而导致的数据陈旧性(staleness)问题。

    这个优化器会执行如下操作：

    • 通过从张量获取前TopK个导入值来压缩梯度，并将其用于allreduce以减少网络带宽。
    • 调用momentum来降低cost。
    • 参数:
      • learning_rate （float | Variable） - 用于更新参数的学习率。可以是浮点值或由一个浮点型数据组成的Variable。
      • momentum （float） - 动量因子。
      • rampup_begin_step （int） - 进行梯度压缩的起步点。
      • rampup_step （int） - 使用稀疏期的时间。默认值为1.例如：如果稀疏度为[0.75,0.9375,0.984375,0.996,0.999]，并且rampup_step为5，则在0步时使用0.75，在1步时使用0.9375，依此类推。当达到sparsity数组末尾时，它此后延续使用0.999。
      • sparsity （list [float]） - 从梯度张量中获取较为重要的元素，比率为（1-当前稀疏度）。
      • use_nesterov （bool） - 启用Nesterov momentum。 True意味着使用nesterov。
      • local_grad_clip_norm （float） - 如果需要，clip norm值。
      • num_trainers - 训练节点的数量。
      • regularization - 正则器，如fluid.regularizer.L2DecayRegularizer。
      • name - 可选的名称前缀。代码示例
    1. import paddle.fluid as fluid
    2. optimizer = fluid.optimizer.DGCMomentumOptimizer(
    3.                                     learning_rate=0.0001,
    4.                                     momentum=0.9,
    5.                                     rampup_step=1000,
    6.                                     rampup_begin_step=1252,
    7.                                     sparsity=[0.999, 0.999])

    ExponentialMovingAverage

    SourceEnglish

    • class paddle.fluid.optimizer.ExponentialMovingAverage(decay=0.999, thres_steps=None, name=None)
    • 用指数衰减计算参数的移动平均值。给出参数

    fluid.optimizer - 图10 ，它的指数移动平均值(exponential moving average, EMA)为

    fluid.optimizer - 图11

    用 update() 方法计算出的平均结果将保存在由对象创建和维护的临时变量中，并且可以通过调用 apply() 方法把结果应用于当前模型的参数。另外，restore() 方法用于恢复参数。

    偏差教正。 所有的EMAs均初始化为

    fluid.optimizer - 图12 ，因此它们将为零偏差，可以通过除以因子fluid.optimizer - 图13 来校正，即在调用 apply() 方法时应用于参数的真实EMAs将为：

    fluid.optimizer - 图14

    衰减率调度。 一个非常接近于1的很大的衰减率将会导致平均值移动得很慢。更优的策略是，一开始就设置一个相对较小的衰减率。参数thres_steps允许用户传递一个变量以设置衰减率，在这种情况下，真实的衰减率变为 ：

    fluid.optimizer - 图15

    通常thres_steps可以是全局训练steps。

    • 参数：
      • decay (float) – 指数衰减率，通常接近1，如0.999，0.9999，……
      • thres_steps (Variable|None) – 如果不为None，指定衰减率。
      • name (str|None) – 名字前缀（可选项）。代码示例
    1. import numpy
    2. import paddle
    3. import paddle.fluid as fluid
    4.  
    5. data = fluid.layers.data(name='x', shape=[5], dtype='float32')
    6. hidden = fluid.layers.fc(input=data, size=10)
    7. cost = fluid.layers.mean(hidden)
    8.  
    9. test_program = fluid.default_main_program().clone(for_test=True)
    10.  
    11. optimizer = fluid.optimizer.Adam(learning_rate=0.001)
    12. optimizer.minimize(cost)
    13.  
    14. global_steps = fluid.layers.learning_rate_scheduler._decay_step_counter()
    15. ema = fluid.optimizer.ExponentialMovingAverage(0.999, thres_steps=global_steps)
    16. ema.update()
    17.  
    18. place = fluid.CPUPlace()
    19. exe = fluid.Executor(place)
    20. exe.run(fluid.default_startup_program())
    21.  
    22. for pass_id in range(3):
    23.     for batch_id in range(6):
    24.         data = numpy.random.random(size=(10, 5)).astype('float32')
    25.         exe.run(program=fluid.default_main_program(),
    26.             feed={'x': data},
    27.             fetch_list=[cost.name])
    28.  
    29.     # usage 1
    30.     with ema.apply(exe):
    31.         data = numpy.random.random(size=(10, 5)).astype('float32')
    32.         exe.run(program=test_program,
    33.                 feed={'x': data},
    34.                 fetch_list=[hidden.name])
    35.  
    36.  
    37.      # usage 2
    38.     with ema.apply(exe, need_restore=False):
    39.         data = numpy.random.random(size=(10, 5)).astype('float32')
    40.         exe.run(program=test_program,
    41.                 feed={'x': data},
    42.                 fetch_list=[hidden.name])
    43.     ema.restore(exe)
    • update()

    • 更新指数滑动平均。仅在训练程序中调用此方法。

    • apply(executor, need_restore=True)

    • 参数：
      • executor (Executor) – 执行应用的执行引擎。
      • need_restore (bool) –是否在应用后恢复参数。
    • restore(executor)
    • 参数：
      • executor (Executor) – 执行存储的执行引擎。

    Ftrl

    SourceEnglish

    • paddle.fluid.optimizer.Ftrl
    • FtrlOptimizer 的别名

    FtrlOptimizer

    SourceEnglish

    • class paddle.fluid.optimizer.FtrlOptimizer(learning_rate, l1=0.0, l2=0.0, lr_power=-0.5, regularization=None, name=None)
    • FTRL (Follow The Regularized Leader) Optimizer.

    FTRL 原始论文: ( https://www.eecs.tufts.edu/~dsculley/papers/ad-click-prediction.pdf)

    fluid.optimizer - 图16

    • 参数:
      • learning_rate (float|Variable)-全局学习率。
      • l1 (float) - L1 regularization strength.
      • l2 (float) - L2 regularization strength.
      • lr_power (float) - 学习率降低指数
      • regularization - 正则化器，例如 fluid.regularizer.L2DecayRegularizer
      • name — 可选的名称前缀
    • 抛出异常：
      • ValueError - 如果 learning_rate , rho , epsilon , momentum 为 None.代码示例
    1. import paddle
    2. import paddle.fluid as fluid
    3. import numpy as np
    4.  
    5. place = fluid.CPUPlace()
    6. main = fluid.Program()
    7. with fluid.program_guard(main):
    8.     x = fluid.layers.data(name='x', shape=[13], dtype='float32')
    9.     y = fluid.layers.data(name='y', shape=[1], dtype='float32')
    10.     y_predict = fluid.layers.fc(input=x, size=1, act=None)
    11.     cost = fluid.layers.square_error_cost(input=y_predict, label=y)
    12.     avg_cost = fluid.layers.mean(cost)
    13.  
    14.     ftrl_optimizer = fluid.optimizer.Ftrl(learning_rate=0.1)
    15.     ftrl_optimizer.minimize(avg_cost)
    16.  
    17.     fetch_list = [avg_cost]
    18.     train_reader = paddle.batch(
    19.         paddle.dataset.uci_housing.train(), batch_size=1)
    20.     feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
    21.     exe = fluid.Executor(place)
    22.     exe.run(fluid.default_startup_program())
    23.     for data in train_reader():
    24.         exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list)

    注解

    目前, FtrlOptimizer 不支持 sparse parameter optimization

    LambOptimizer

    SourceEnglish

    • class paddle.fluid.optimizer.LambOptimizer(learning_rate=0.001, lamb_weight_decay=0.01, beta1=0.9, beta2=0.999, epsilon=1e-06, regularization=None, exclude_from_weight_decay_fn=None, name=None)
    • LAMB（Layer-wise Adaptive Moments optimizer for Batching training）优化器LAMB优化器旨在不降低准确性的条件下扩大训练的批量大小，支持自适应元素更新和精确的分层校正。 更多信息请参考 Large Batch Optimization forDeep Learning: Training BERT in 76 minutes 。参数更新如下：

    fluid.optimizer - 图17

    其中

    fluid.optimizer - 图18 为第一个时刻，fluid.optimizer - 图19 为第二个时刻，fluid.optimizer - 图20 为学习率，fluid.optimizer - 图21 为LAMB权重衰减率。

    • 参数：
      • learning_rate (float|Variable) – 用于更新参数的学习速率。可以是浮点值或具有一个作为数据元素的浮点值的变量。
      • lamb_weight_decay (float) – LAMB权重衰减率。
      • beta1 (float) – 第一个时刻估计的指数衰减率。
      • beta2 (float) – 第二个时刻估计的指数衰减率。
      • epsilon (float) – 一个小的浮点值，目的是维持数值稳定性。
      • regularization (Regularizer) – 一个正则化器，如fluid.regularizer.L1DecayRegularizer。
      • exclude_from_weight_decay_fn (function) – 当返回值为True时从权重衰减中去除某个参数。
      • name (str|None) – 名字前缀（可选项）。代码示例
    1. import paddle.fluid as fluid
    2.  
    3. data = fluid.layers.data(name='x', shape=[5], dtype='float32')
    4. hidden = fluid.layers.fc(input=data, size=10)
    5. cost = fluid.layers.mean(hidden)
    6.  
    7. def exclude_fn(param):
    8.     return param.name.endswith('.b_0')
    9.  
    10. optimizer = fluid.optimizer.Lamb(learning_rate=0.002,
    11.                                  exclude_from_weight_decay_fn=exclude_fn)
    12. optimizer.minimize(cost)

    LarsMomentum

    SourceEnglish

    • paddle.fluid.optimizer.LarsMomentum
    • fluid.optimizer.LarsMomentumOptimizer 的别名

    LarsMomentumOptimizer

    SourceEnglish

    • class paddle.fluid.optimizer.LarsMomentumOptimizer(learning_rate, momentum, lars_coeff=0.001, lars_weight_decay=0.0005, regularization=None, name=None)
    • LARS支持的Momentum优化器

    公式作如下更新：

    fluid.optimizer - 图22

    • 参数：
      • learning_rate (float|Variable) - 学习率，用于参数更新。作为数据参数，可以是浮点型值或含有一个浮点型值的变量
      • momentum (float) - 动量因子
      • lars_coeff (float) - 定义LARS本地学习率的权重
      • lars_weight_decay (float) - 使用LARS进行衰减的权重衰减系数
      • regularization - 正则化函数，例如 fluid.regularizer.L2DecayRegularizer
      • name - 名称前缀，可选代码示例：
    1. import paddle.fluid as fluid
    2. optimizer = fluid.optimizer.LarsMomentum(learning_rate=0.2, momentum=0.1, lars_weight_decay=0.001)
    3. optimizer.minimize(cost)

    ModelAverage

    SourceEnglish

    • class paddle.fluid.optimizer.ModelAverage(average_window_rate, min_average_window=10000, max_average_window=10000, regularization=None, name=None)
    • 在滑动窗口中累积参数的平均值。平均结果将保存在临时变量中，通过调用 apply() 方法可应用于当前模型的参数变量。使用 restore() 方法恢复当前模型的参数值。

    平均窗口的大小由 average_window_rate ， min_average_window ， max_average_window 以及当前更新次数决定。

    • 参数:
      • average_window_rate – 窗口平均速率
      • min_average_window – 平均窗口大小的最小值
      • max_average_window – 平均窗口大小的最大值
      • regularization – 正则化器，例如 fluid.regularizer.L2DecayRegularizer
      • name – 可选的名称前缀代码示例
    1. import paddle.fluid as fluid
    2. import numpy
    3.  
    4. # 首先创建执行引擎
    5. place = fluid.CPUPlace()  # fluid.CUDAPlace(0)
    6. exe = fluid.Executor(place)
    7.  
    8. train_program = fluid.Program()
    9. startup_program = fluid.Program()
    10. with fluid.program_guard(train_program, startup_program):
    11.     # 构建net
    12.     data = fluid.layers.data(name='X', shape=[1], dtype='float32')
    13.     hidden = fluid.layers.fc(input=data, size=10)
    14.     loss = fluid.layers.mean(hidden)
    15.     optimizer = fluid.optimizer.Momentum(learning_rate=0.2, momentum=0.1)
    16.     optimizer.minimize(loss)
    17.  
    18.     # 构建ModelAverage优化器
    19.     model_average = fluid.optimizer.ModelAverage(0.15,
    20.                                       min_average_window=10000,
    21.                                       max_average_window=20000)
    22.     exe.run(startup_program)
    23.     x = numpy.random.random(size=(10, 1)).astype('float32')
    24.     outs = exe.run(program=train_program,
    25.                    feed={'X': x},
    26.                    fetch_list=[loss.name])
    27.    # 应用ModelAverage
    28.     with model_average.apply(exe):
    29.          x = numpy.random.random(size=(10, 1)).astype('float32')
    30.          exe.run(program=train_program,
    31.                 feed={'X': x},
    32.                 fetch_list=[loss.name])
    • apply(executor, need_restore=True)

    • 将平均值应用于当前模型的参数。

    • 参数：

      • executor (fluid.Executor) – 当前的执行引擎。
      • need_restore (bool) – 如果您最后需要实现恢复，将其设为True。默认值True。
    • restore(executor)

    • 恢复当前模型的参数值

    • 参数：

      • executor (fluid.Executor) – 当前的执行引擎。

    Momentum

    SourceEnglish

    • paddle.fluid.optimizer.Momentum
    • MomentumOptimizer 的别名

    MomentumOptimizer

    SourceEnglish

    • class paddle.fluid.optimizer.MomentumOptimizer(learning_rate, momentum, use_nesterov=False, regularization=None, name=None)
    • 含有速度状态的Simple Momentum 优化器

    该优化器含有牛顿动量标志，公式更新如下：

    fluid.optimizer - 图23

    • 参数：
      • learning_rate (float|Variable) - 学习率，用于参数更新。作为数据参数，可以是浮点型值或含有一个浮点型值的变量
      • momentum (float) - 动量因子
      • use_nesterov (bool) - 赋能牛顿动量
      • regularization - 正则化函数，比如fluid.regularizer.L2DecayRegularizer
      • name - 名称前缀（可选）代码示例：
    1. import paddle
    2. import paddle.fluid as fluid
    3. import numpy as np
    4.  
    5. place = fluid.CPUPlace()
    6. main = fluid.Program()
    7. with fluid.program_guard(main):
    8.     x = fluid.layers.data(name='x', shape=[13], dtype='float32')
    9.     y = fluid.layers.data(name='y', shape=[1], dtype='float32')
    10.     y_predict = fluid.layers.fc(input=x, size=1, act=None)
    11.     cost = fluid.layers.square_error_cost(input=y_predict, label=y)
    12.     avg_cost = fluid.layers.mean(cost)
    13.  
    14.     moment_optimizer = fluid.optimizer.MomentumOptimizer(learning_rate=0.001, momentum=0.9)
    15.     moment_optimizer.minimize(avg_cost)
    16.  
    17.     fetch_list = [avg_cost]
    18.     train_reader = paddle.batch(
    19.         paddle.dataset.uci_housing.train(), batch_size=1)
    20.     feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
    21.     exe = fluid.Executor(place)
    22.     exe.run(fluid.default_startup_program())
    23.     for data in train_reader():
    24.         exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list)

    PipelineOptimizer

    SourceEnglish

    • class paddle.fluid.optimizer.PipelineOptimizer(optimizer, cut_list=None, place_list=None, concurrency_list=None, queue_size=30, sync_steps=1, start_cpu_core_id=0)
    • 使用流水线模式进行训练。Program会根据切分列表cut_list进行分割。如果cut_list的长度是k，则整个program（包括反向部分）将被分割为2k-1个section。 所以place_list和concurrency_list的长度也必须是2k-1。

    注解

    虽然我们在流水线训练模式中采用异步更新的方式来加速，但最终的效果会依赖于每条流水线的训练进程。我们将在未来尝试同步模式。

    • 参数:
      • optimizer (Optimizer) - 基础优化器，如SGD
      • cut_list (list of Variable list) - main_program的cut变量列表
      • place_list (list of Place) - 对应section运行所在的place
      • concurrency_list (list of int) - 指定每个section的并发度列表
      • queue_size (int) - 每个section都会消费其输入队列(in-scope queue)中的scope，并向输出队列(out-scope queue)产出scope。 此参数的作用就是指定队列的大小。 可选，默认值：30
      • sync_steps (int) - 不同显卡之间的同步周期数。可选，默认值：1
      • start_cpu_core_id (int) - 指定所使用的第一个CPU核的id。可选，默认值：0代码示例
    1. import paddle.fluid as fluid
    2. import paddle.fluid.layers as layers
    3. x = fluid.layers.data(name='x', shape=[1], dtype='int64', lod_level=0)
    4. y = fluid.layers.data(name='y', shape=[1], dtype='int64', lod_level=0)
    5. emb_x = layers.embedding(input=x, param_attr=fluid.ParamAttr(name="embx"), size=[10,2], is_sparse=False)
    6. emb_y = layers.embedding(input=y, param_attr=fluid.ParamAttr(name="emby",learning_rate=0.9), size=[10,2], is_sparse=False)
    7. concat = layers.concat([emb_x, emb_y], axis=1)
    8. fc = layers.fc(input=concat, name="fc", size=1, num_flatten_dims=1, bias_attr=False)
    9. loss = layers.reduce_mean(fc)
    10. optimizer = fluid.optimizer.SGD(learning_rate=0.5)
    11. optimizer = fluid.optimizer.PipelineOptimizer(optimizer,
    12.         cut_list=[[emb_x, emb_y], [loss]],
    13.         place_list=[fluid.CPUPlace(), fluid.CUDAPlace(0), fluid.CPUPlace()],
    14.         concurrency_list=[1, 1, 4],
    15.         queue_size=2,
    16.         sync_steps=1,
    17.         )
    18. optimizer.minimize(loss)
    19. place = fluid.CPUPlace()
    20. exe = fluid.Executor(place)
    21. exe.run(fluid.default_startup_program())
    22. filelist = [] # you should set your own filelist, e.g. filelist = ["dataA.txt"]
    23. dataset = fluid.DatasetFactory().create_dataset("FileInstantDataset")
    24. dataset.set_use_var([x,y])
    25. dataset.set_batch_size(batch_size)
    26. dataset.set_filelist(filelist)
    27. exe.train_from_dataset(
    28.             fluid.default_main_program(),
    29.             dataset,
    30.             thread=2,
    31.             debug=False,
    32.             fetch_list=[],
    33.             fetch_info=[],
    34.             print_period=1)

    RMSPropOptimizer

    SourceEnglish

    • class paddle.fluid.optimizer.RMSPropOptimizer(learning_rate, rho=0.95, epsilon=1e-06, momentum=0.0, centered=False, regularization=None, name=None)
    • 均方根传播（RMSProp）法是一种未发表的,自适应学习率的方法。原演示幻灯片中提出了RMSProp：[http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf]中的第29张。等式如下所示：

    fluid.optimizer - 图24

    第一个等式计算每个权重平方梯度的移动平均值，然后将梯度除以

    fluid.optimizer - 图25 。

    fluid.optimizer - 图26

    如果居中为真：

    fluid.optimizer - 图27

    其中，

    fluid.optimizer - 图28 是超参数，典型值为0.9,0.95等。fluid.optimizer - 图29 是动量术语。fluid.optimizer - 图30 是一个平滑项，用于避免除零，通常设置在1e-4到1e-8的范围内。

    • 参数：
      • learning_rate （float） - 全局学习率。
      • rho （float） - rho是等式中的fluid.optimizer - 图31，默认设置为0.95。
      • epsilon （float） - 等式中的epsilon是平滑项，避免被零除，默认设置为1e-6。
      • momentum （float） - 方程中的β是动量项，默认设置为0.0。
      • centered （bool） - 如果为True，则通过梯度的估计方差,对梯度进行归一化；如果False，则由未centered的第二个moment归一化。将此设置为True有助于模型训练，但会消耗额外计算和内存资源。默认为False。
      • regularization - 正则器项，如 fluid.regularizer.L2DecayRegularizer 。
      • name - 可选的名称前缀。
    • 抛出异常:
      • ValueError -如果 learning_rate ， rho ， epsilon ， momentum 为None。示例代码
    1. import paddle
    2. import paddle.fluid as fluid
    3. import numpy as np
    4.  
    5. place = fluid.CPUPlace()
    6. main = fluid.Program()
    7. with fluid.program_guard(main):
    8.     x = fluid.layers.data(name='x', shape=[13], dtype='float32')
    9.     y = fluid.layers.data(name='y', shape=[1], dtype='float32')
    10.     y_predict = fluid.layers.fc(input=x, size=1, act=None)
    11.     cost = fluid.layers.square_error_cost(input=y_predict, label=y)
    12.     avg_cost = fluid.layers.mean(cost)
    13.  
    14.     rms_optimizer = fluid.optimizer.RMSProp(learning_rate=0.1)
    15.     rms_optimizer.minimize(avg_cost)
    16.  
    17.     fetch_list = [avg_cost]
    18.     train_reader = paddle.batch(
    19.         paddle.dataset.uci_housing.train(), batch_size=1)
    20.     feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
    21.     exe = fluid.Executor(place)
    22.     exe.run(fluid.default_startup_program())
    23.     for data in train_reader():
    24.         exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list)

    SGD

    SourceEnglish

    • paddle.fluid.optimizer.SGD
    • SGDOptimizer 的别名

    SGDOptimizer

    SourceEnglish

    • class paddle.fluid.optimizer.SGDOptimizer(learning_rate, regularization=None, name=None)
    • 随机梯度下降算法的优化器

    fluid.optimizer - 图32

    • 参数:
      • learning_rate (float|Variable) - 用于更新参数的学习率。可以是浮点值，也可以是具有一个浮点值作为数据元素的变量。
      • regularization - 一个正则化器，例如 fluid.regularizer.L2DecayRegularizer
      • name - 可选的名称前缀。代码示例
    1. import paddle
    2. import paddle.fluid as fluid
    3. import numpy as np
    4.  
    5. place = fluid.CPUPlace()
    6. main = fluid.Program()
    7. with fluid.program_guard(main):
    8.     x = fluid.layers.data(name='x', shape=[13], dtype='float32')
    9.     y = fluid.layers.data(name='y', shape=[1], dtype='float32')
    10.     y_predict = fluid.layers.fc(input=x, size=1, act=None)
    11.     cost = fluid.layers.square_error_cost(input=y_predict, label=y)
    12.     avg_cost = fluid.layers.mean(cost)
    13.  
    14.     sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.001)
    15.     sgd_optimizer.minimize(avg_cost)
    16.  
    17.     fetch_list = [avg_cost]
    18.     train_reader = paddle.batch(
    19.         paddle.dataset.uci_housing.train(), batch_size=1)
    20.     feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
    21.     exe = fluid.Executor(place)
    22.     exe.run(fluid.default_startup_program())
    23.     for data in train_reader():
    24.         exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list)