Add dynamic/static learning rate doc for the api2.0

Add dynamic/static learning rate doc for the api2.0

doc/fluid/api/optimizer.rst

-===============
+======================
 paddle.optimizer
-===============
+======================
 
 ..  toctree::
     :maxdepth: 1
@@ -32,3 +32,15 @@ paddle.optimizer
     optimizer/RMSPropOptimizer.rst
     optimizer/SGD.rst
     optimizer/SGDOptimizer.rst
+    optimizer/NoamLR.rst
+    optimizer/PiecewiseLR.rst
+    optimizer/NaturalExpLR.rst
+    optimizer/InverseTimeLR.rst
+    optimizer/PolynomialLR.rst
+    optimizer/LinearLrWarmup.rst
+    optimizer/ExponentialLR.rst
+    optimizer/MultiStepLR.rst
+    optimizer/StepLR.rst
+    optimizer/LambdaLR.rst
+    optimizer/ReduceLROnPlateau.rst
+    optimizer/CosineAnnealingLR.rst
\ No newline at end of file

doc/fluid/api/optimizer/CosineAnnealingLR.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+.. _api_optimizer_CosineAnnealingLR:
+
+CosineAnnealingLR
+-------------------
+
+..  autoclass:: paddle.optimizer.CosineAnnealingLR
+    :members:
+    :inherited-members:
+    :exclude-members: set_dict, set_state_dict, state_dict
+    :noindex:
+

doc/fluid/api/optimizer/ExponentialLR.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+.. _api_optimizer_ExponentialLR:
+
+ExponentialLR
+-------------------
+
+..  autoclass:: paddle.optimizer.ExponentialLR
+    :members:
+    :inherited-members:
+    :exclude-members: set_dict, set_state_dict, state_dict
+    :noindex:
+

doc/fluid/api/optimizer/InverseTimeLR.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+.. _api_optimizer_InverseTimeLR:
+
+InverseTimeLR
+-------------------
+
+..  autoclass:: paddle.optimizer.InverseTimeLR
+    :members:
+    :inherited-members:
+    :exclude-members: set_dict, set_state_dict, state_dict
+    :noindex:
+

doc/fluid/api/optimizer/LambdaLR.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+.. _api_optimizer_LambdaLR:
+
+LambdaLR
+-------------------
+
+..  autoclass:: paddle.optimizer.LambdaLR
+    :members:
+    :inherited-members:
+    :exclude-members: set_dict, set_state_dict, state_dict
+    :noindex:
+

doc/fluid/api/optimizer/LinearLrWarmup.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+.. _api_optimizer_LinearLrWarmup:
+
+LinearLrWarmup
+-------------------
+
+..  autoclass:: paddle.optimizer.LinearLrWarmup
+    :members:
+    :inherited-members:
+    :exclude-members: set_dict, set_state_dict, state_dict
+    :noindex:
+

doc/fluid/api/optimizer/MultiStepLR.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+.. _api_optimizer_MultiStepLR:
+
+MultiStepLR
+-------------------
+
+..  autoclass:: paddle.optimizer.MultiStepLR
+    :members:
+    :inherited-members:
+    :exclude-members: set_dict, set_state_dict, state_dict
+    :noindex:
+

doc/fluid/api/optimizer/NaturalExpLR.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+.. _api_optimizer_NaturalExpLR:
+
+NaturalExpLR
+-------------------
+
+..  autoclass:: paddle.optimizer.NaturalExpLR
+    :members:
+    :inherited-members:
+    :exclude-members: set_dict, set_state_dict, state_dict
+    :noindex:
+

doc/fluid/api/optimizer/NoamLR.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+.. _api_optimizer_NoamLR:
+
+NoamLR
+-------------------
+
+..  autoclass:: paddle.optimizer.NoamLR
+    :members:
+    :inherited-members:
+    :exclude-members: set_dict, set_state_dict, state_dict
+    :noindex:
+

doc/fluid/api/optimizer/PiecewiseLR.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+.. _api_optimizer_PiecewiseLR:
+
+PiecewiseLR
+-------------------
+
+..  autoclass:: paddle.optimizer.PiecewiseLR
+    :members:
+    :inherited-members:
+    :exclude-members: set_dict, set_state_dict, state_dict
+    :noindex:
+

doc/fluid/api/optimizer/PolynomialLR.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+.. _api_optimizer_PolynomialLR:
+
+PolynomialLR
+-------------------
+
+..  autoclass:: paddle.optimizer.PolynomialLR
+    :members:
+    :inherited-members:
+    :exclude-members: set_dict, set_state_dict, state_dict
+    :noindex:
+

doc/fluid/api/optimizer/ReduceLROnPlateau.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+.. _api_optimizer_ReduceLROnPlateau:
+
+ReduceLROnPlateau
+-------------------
+
+..  autoclass:: paddle.optimizer.ReduceLROnPlateau
+    :members:
+    :inherited-members:
+    :exclude-members: set_dict, set_state_dict, state_dict
+    :noindex:
+

doc/fluid/api/optimizer/StepLR.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+.. _api_optimizer_StepLR:
+
+StepLR
+-------------------
+
+..  autoclass:: paddle.optimizer.StepLR
+    :members:
+    :inherited-members:
+    :exclude-members: set_dict, set_state_dict, state_dict
+    :noindex:
+

doc/fluid/api_cn/optimizer_cn.rst

@@ -35,3 +35,15 @@ paddle.optimizer
     optimizer_cn/RMSPropOptimizer_cn.rst
     optimizer_cn/SGD_cn.rst
     optimizer_cn/SGDOptimizer_cn.rst
+    optimizer_cn/lr_scheduler_cn/CosineAnnealingLR_cn.rst
+    optimizer_cn/lr_scheduler_cn/ExponentialLR_cn.rst
+    optimizer_cn/lr_scheduler_cn/InverseTimeLR_cn.rst
+    optimizer_cn/lr_scheduler_cn/LambdaLR_cn.rst
+    optimizer_cn/lr_scheduler_cn/MultiStepLR_cn.rst
+    optimizer_cn/lr_scheduler_cn/NaturalExpLR_cn.rst
+    optimizer_cn/lr_scheduler_cn/NoamLR_cn.rst
+    optimizer_cn/lr_scheduler_cn/PiecewiseLR_cn.rst
+    optimizer_cn/lr_scheduler_cn/PolynomiaLR_cn.rst
+    optimizer_cn/lr_scheduler_cn/ReduceLROnPlateauLR_cn.rst
+    optimizer_cn/lr_scheduler_cn/StepLR_cn.rst
+    optimizer_cn/lr_scheduler_cn/LinearLrWarmup_cn.rst

doc/fluid/api_cn/optimizer_cn/lr_scheduler_cn/CosineAnnealingLR_cn.rst

+.. _cn_api_paddle_optimizer_CosineAnnealingLR:
+
+CosineAnnealingLR
+-----------------------------------
+
+.. py:class:: paddle.optimizer.lr_scheduler.CosineAnnealingLR(learning_rate, T_max, eta_min=0, last_epoch=-1, verbose=False) 
+
+该接口使用 ``cosine annealing`` 方式来动态调整学习率。
+
+.. math::
+        \begin{aligned}
+            \eta_t & = \eta_{min} + \frac{1}{2}(\eta_{max} - \eta_{min})\left(1
+            + \cos\left(\frac{T_{cur}}{T_{max}}\pi\right)\right),
+            & T_{cur} \neq (2k+1)T_{max}; \\
+            \eta_{t+1} & = \eta_{t} + \frac{1}{2}(\eta_{max} - \eta_{min})
+            \left(1 - \cos\left(\frac{1}{T_{max}}\pi\right)\right),
+            & T_{cur} = (2k+1)T_{max}.
+        \end{aligned}
+
+
+:math:`\eta_{max}` 的初始值为 ``learning_rate``, :math:`T_{cur}` 是SGDR（重启训练SGD）训练过程中的当前训练轮数。SGDR的训练方法可以参考文档 `SGDR: Stochastic Gradient Descent with Warm Restarts <https://arxiv.org/abs/1608.03983>`_.
+这里只是实现了 ``cosine annealing`` 动态学习率，热启训练部分没有实现。 
+
+
+参数
+:::::::::
+    - **learning_rate** （float）：初始学习率，可以是Python的float。
+    - **T_max** （float|int）：训练的上限轮数，是学习率衰减周期的一半。
+    - **eta_min** （float|int, 可选）：学习率的下限，即公式中的 :math:`\eta_{min}` 。默认值为0。 
+    - **last_epoch** （int，可选）: 上一轮的轮数，重启训练时设置为上一轮的epoch数。默认值为 -1，则为初始学习率。
+    - **verbose** （bool，可选）：如果是 `True` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+
+返回
+:::::::::
+    返回计算CosineAnnealingLR的可调用对象。
+
+代码示例
+:::::::::
+
+.. code-block:: python
+
+    import paddle
+    import numpy as np
+
+    # train on default imperative mode
+    paddle.disable_static()
+    x = np.random.uniform(-1, 1, [10, 10]).astype("float32")
+    linear = paddle.nn.Linear(10, 10)
+    scheduler = paddle.optimizer.lr_scheduler.CosineAnnealingLR(learning_rate=0.5, T_max=10, verbose=True)
+    sgd = paddle.optimizer.SGD(learning_rate=scheduler, parameter_list=linear.parameters())
+    for epoch in range(20):
+        for batch_id in range(2):
+            x = paddle.to_tensor(x)
+            out = linear(x)
+            loss = paddle.reduce_mean(out)
+            loss.backward()
+            sgd.minimize(loss)
+            linear.clear_gradients()
+        scheduler.step()
+
+    # train on static mode
+    paddle.enable_static()
+    main_prog = paddle.static.Program()
+    start_prog = paddle.static.Program()
+    with paddle.static.program_guard(main_prog, start_prog):
+        x = paddle.static.data(name='x', shape=[None, 4, 5])
+        y = paddle.static.data(name='y', shape=[None, 4, 5])
+        z = paddle.static.nn.fc(x, 100)
+        loss = paddle.mean(z)
+        scheduler = paddle.optimizer.lr_scheduler.CosineAnnealingLR(learning_rate=0.5, T_max=10, verbose=True)
+        sgd = paddle.optimizer.SGD(learning_rate=scheduler)
+        sgd.minimize(loss)
+
+    exe = paddle.static.Executor()
+    exe.run(start_prog)
+    for epoch in range(20):
+        for batch_id in range(2):
+            out = exe.run(
+                main_prog,
+                feed={
+                    'x': np.random.randn(3, 4, 5).astype('float32'),
+                    'y': np.random.randn(3, 4, 5).astype('float32')
+                },
+                fetch_list=loss.name)
+        scheduler.step()
+
+.. py:method:: step(epoch=None)
+
+step函数需要在优化器的 `step()` 函数之后调用，调用之后将会根据epoch数来更新学习率，更新之后的学习率将会在优化器下一轮更新参数时使用。
+
+参数：
+  - **epoch** （int，可选）- 指定具体的epoch数。默认值None，此时将会从-1自动累加 ``epoch`` 数。
+
+返回：
+  无。
+
+**代码示例** ：
+
+  参照上述示例代码。
+

doc/fluid/api_cn/optimizer_cn/lr_scheduler_cn/ExponentialLR_cn.rst

+.. _cn_api_paddle_optimizer_ExponentialLR:
+
+ExponentialLR
+-----------------------------------
+
+.. py:class:: paddle.optimizer.lr_scheduler.ExponentialLR(learning_rate, gamma, last_epoch=-1, verbose=False)
+
+该接口提供一种学习率按指数函数衰减的功能。
+
+衰减函数可以用以下公式表示：
+
+.. math::
+
+  new\_learning\_rate = last\_learning\_rate * gamma
+
+参数
+:::::::::
+    - **learning_rate** （float） - 初始学习率，数据类型为Python float。
+    - **gamma** （float）：衰减率，new_lr = origin_lr * gamma。
+    - **last_epoch** （int，可选）: 上一轮的轮数，重启训练时设置为上一轮的epoch数。默认值为 -1，则为初始学习率 。
+    - **verbose** （bool，可选）：如果是 `True` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+
+返回
+:::::::::
+返回计算ExponentialLR的可调用对象。
+
+代码示例
+:::::::::
+
+.. code-block:: python
+
+    import paddle
+    import numpy as np
+
+    # train on default dygraph mode
+    paddle.disable_static()
+    x = np.random.uniform(-1, 1, [10, 10]).astype("float32")
+    linear = paddle.nn.Linear(10, 10)
+    scheduler = paddle.optimizer.lr_scheduler.ExponentialLR(learning_rate=0.5, gamma=0.9, verbose=True)
+    sgd = paddle.optimizer.SGD(learning_rate=scheduler, parameter_list=linear.parameters())
+    for epoch in range(20):
+        for batch_id in range(2):
+            x = paddle.to_tensor(x)
+            out = linear(x)
+            loss = paddle.reduce_mean(out)
+            loss.backward()
+            sgd.minimize(loss)
+            linear.clear_gradients()
+        scheduler.step()
+
+    # train on static mode
+    paddle.enable_static()
+    main_prog = paddle.static.Program()
+    start_prog = paddle.static.Program()
+    with paddle.static.program_guard(main_prog, start_prog):
+        x = paddle.static.data(name='x', shape=[None, 4, 5])
+        y = paddle.static.data(name='y', shape=[None, 4, 5])
+        z = paddle.static.nn.fc(x, 100)
+        loss = paddle.mean(z)
+        scheduler = paddle.optimizer.lr_scheduler.ExponentialLR(learning_rate=0.5, gamma=0.9, verbose=True)
+        sgd = paddle.optimizer.SGD(learning_rate=scheduler)
+        sgd.minimize(loss)
+
+    exe = paddle.static.Executor()
+    exe.run(start_prog)
+    for epoch in range(20):
+        for batch_id in range(2):
+            out = exe.run(
+                main_prog,
+                feed={
+                    'x': np.random.randn(3, 4, 5).astype('float32'),
+                    'y': np.random.randn(3, 4, 5).astype('float32')
+                },
+                fetch_list=loss.name)
+        scheduler.step()
+
+
+.. py:method:: step(epoch=None)
+
+step函数需要在优化器的 `step()` 函数之后调用，调用之后将会根据epoch数来更新学习率，更新之后的学习率将会在优化器下一轮更新参数时使用。
+
+参数：
+  - **epoch** （int，可选）- 指定具体的epoch数。默认值None，此时将会从-1自动累加 ``epoch`` 数。
+
+返回：
+  无。
+
+**代码示例** ：
+
+  参照上述示例代码。
+
+

doc/fluid/api_cn/optimizer_cn/lr_scheduler_cn/InverseTimeLR_cn.rst

+.. _cn_api_paddle_optimizer_InverseTimeLR:
+
+InverseTimeLR
+-------------------------------
+
+
+.. py:class:: paddle.optimizer.lr_scheduler.InverseTimeLR(learning_rate, gamma, last_epoch=-1, verbose=False)
+
+
+该接口提供反时限学习率衰减的功能。
+
+反时限学习率衰减计算方式如下。
+
+当staircase为False时，计算公式为：
+
+.. math::
+
+   new\_learning\_rate = \\frac{learning\_rate}{1 + gamma * epoch}
+
+
+参数
+:::::::::
+    - **learning_rate** （float） - 初始学习率，数据类型为Python float。
+    - **gamma** （float）：衰减率，new_lr = origin_lr * gamma。
+    - **last_epoch** （int，可选）: 上一轮的轮数，重启训练时设置为上一轮的epoch数。默认值为 -1，则为初始学习率。
+    - **verbose** （bool，可选）：如果是 `True` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+
+返回
+:::::::::
+返回计算InverseTimeLR的可调用对象。
+
+代码示例
+:::::::::
+
+.. code-block:: python
+
+    import paddle
+    import numpy as np
+
+    # train on default dygraph mode
+    paddle.disable_static()
+    x = np.random.uniform(-1, 1, [10, 10]).astype("float32")
+    linear = paddle.nn.Linear(10, 10)
+    scheduler = paddle.optimizer.lr_scheduler.InverseTimeLR(learning_rate=0.5, gamma=0.1, verbose=True)
+    sgd = paddle.optimizer.SGD(learning_rate=scheduler, parameter_list=linear.parameters())
+    for epoch in range(20):
+        for batch_id in range(2):
+            x = paddle.to_tensor(x)
+            out = linear(x)
+            loss = paddle.reduce_mean(out)
+            loss.backward()
+            sgd.minimize(loss)
+            linear.clear_gradients()
+        scheduler.step()
+
+    # train on static mode
+    paddle.enable_static()
+    main_prog = paddle.static.Program()
+    start_prog = paddle.static.Program()
+    with paddle.static.program_guard(main_prog, start_prog):
+        x = paddle.static.data(name='x', shape=[None, 4, 5])
+        y = paddle.static.data(name='y', shape=[None, 4, 5])
+        z = paddle.static.nn.fc(x, 100)
+        loss = paddle.mean(z)
+        scheduler = paddle.optimizer.lr_scheduler.InverseTimeLR(learning_rate=0.5, gamma=0.1, verbose=True)
+        sgd = paddle.optimizer.SGD(learning_rate=scheduler)
+        sgd.minimize(loss)
+
+    exe = paddle.static.Executor()
+    exe.run(start_prog)
+    for epoch in range(20):
+        for batch_id in range(2):
+            out = exe.run(
+                main_prog,
+                feed={
+                    'x': np.random.randn(3, 4, 5).astype('float32'),
+                    'y': np.random.randn(3, 4, 5).astype('float32')
+                },
+                fetch_list=loss.name)
+        scheduler.step()
+
+.. py:method:: step(epoch=None)
+
+step函数需要在优化器的 `step()` 函数之后调用，调用之后将会根据epoch数来更新学习率，更新之后的学习率将会在优化器下一轮更新参数时使用。
+
+参数：
+  - **epoch** （int，可选）- 指定具体的epoch数。默认值None，此时将会从-1自动累加 ``epoch`` 数。
+
+返回：
+  无。
+
+**代码示例** ：
+
+  参照上述示例代码。

doc/fluid/api_cn/optimizer_cn/lr_scheduler_cn/LambdaLR_cn.rst

+.. _cn_api_paddle_optimizer_LambdaLR:
+
+LambdaLR
+-----------------------------------
+
+.. py:class:: paddle.optimizer.lr_scheduler.LambdaLR(learning_rate, lr_lambda, last_epoch=-1, verbose=False)
+
+该接口提供 ``lambda`` 函数设置学习率的功能。 ``lr_lambda`` 为一个 ``lambda`` 函数，其通过 ``epoch`` 计算出一个因子，该因子会乘以初始学习率。。
+
+衰减过程可以参考以下代码：
+
+.. code-block:: python
+
+    learning_rate = 0.5        # init learning_rate
+    lr_lambda = lambda epoch: 0.95 ** epoch
+    learning_rate = 0.5        # epoch 0
+    learning_rate = 0.475      # epoch 1
+    learning_rate = 0.45125    # epoch 2
+
+
+参数
+:::::::::
+    - **learning_rate** （float） - 初始学习率，数据类型为Python float。
+    - **lr_lambda** （function）：lr_lambda 为一个lambda函数，其通过 epoch 计算出一个因子，该因子会乘以初始学习率。
+    - **last_epoch** （int，可选）: 上一轮的轮数，重启训练时设置为上一轮的epoch数。默认值为 -1，则为初始学习率 。
+    - **verbose** （bool，可选）：如果是 `True` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+
+返回
+:::::::::
+    返回计算LambdaLR的可调用对象。
+
+代码示例
+:::::::::
+
+.. code-block:: python
+
+    import paddle
+    import numpy as np
+
+    # train on default dygraph mode
+    paddle.disable_static()
+    x = np.random.uniform(-1, 1, [10, 10]).astype("float32")
+    linear = paddle.nn.Linear(10, 10)
+    scheduler = paddle.optimizer.lr_scheduler.LambdaLR(learning_rate=0.5, lr_lambda=lambda x:0.95**x, verbose=True)
+    sgd = paddle.optimizer.SGD(learning_rate=scheduler, parameter_list=linear.parameters())
+    for epoch in range(20):
+        for batch_id in range(2):
+            x = paddle.to_tensor(x)
+            out = linear(x)
+            loss = paddle.reduce_mean(out)
+            loss.backward()
+            sgd.minimize(loss)
+            linear.clear_gradients()
+        scheduler.step()
+
+    # train on static mode
+    paddle.enable_static()
+    main_prog = paddle.static.Program()
+    start_prog = paddle.static.Program()
+    with paddle.static.program_guard(main_prog, start_prog):
+        x = paddle.static.data(name='x', shape=[None, 4, 5])
+        y = paddle.static.data(name='y', shape=[None, 4, 5])
+        z = paddle.static.nn.fc(x, 100)
+        loss = paddle.mean(z)
+        scheduler = paddle.optimizer.lr_scheduler.LambdaLR(learning_rate=0.5, lr_lambda=lambda x:0.95**x, verbose=True)
+        sgd = paddle.optimizer.SGD(learning_rate=scheduler)
+        sgd.minimize(loss)
+
+    exe = paddle.static.Executor()
+    exe.run(start_prog)
+    for epoch in range(20):
+        for batch_id in range(2):
+            out = exe.run(
+                main_prog,
+                feed={
+                    'x': np.random.randn(3, 4, 5).astype('float32'),
+                    'y': np.random.randn(3, 4, 5).astype('float32')
+                },
+                fetch_list=loss.name)
+        scheduler.step()
+
+.. py:method:: step(epoch=None)
+
+step函数需要在优化器的 `step()` 函数之后调用，调用之后将会根据epoch数来更新学习率，更新之后的学习率将会在优化器下一轮更新参数时使用。
+
+参数：
+  - **epoch** （int，可选）- 指定具体的epoch数。默认值None，此时将会从-1自动累加 ``epoch`` 数。
+
+返回：
+  无。
+
+**代码示例** ：
+
+  参照上述示例代码。
+

doc/fluid/api_cn/optimizer_cn/lr_scheduler_cn/LinearLrWarmup_cn.rst

+.. _cn_api_paddle_optimizer_LinearLrWarmup:
+
+LinearLrWarmup
+-----------------------------------
+
+.. py:class:: paddle.optimizer.lr_scheduler.LinearLrWarmup(learing_rate, warmup_steps, start_lr, end_lr, last_epoch=-1, verbose=False)
+
+该接口提供一种学习率优化策略-线性学习率热身(warm up)对学习率进行初步调整。在正常调整学习率之前，先逐步增大学习率。
+
+当训练步数小于热身步数（warmup_steps）时，学习率lr按如下方式更新：
+
+.. code-block:: text
+
+    linear_step = end_lr - start_lr
+    lr = start_lr + linear_step * (epoch / warmup_steps)
+
+当训练步数大于等于热身步数（warmup_steps）时，学习率lr为：
+
+.. code-block:: text
+
+    lr = learning_rate
+
+其中learning_rate为热身之后的学习率。
+
+参数
+:::::::::
+    - **learning rate** （float|_LRScheduler）：热启训练之后的学习率，可以是Python的float或_LRScheduler子类。
+    - **warmup_steps** （int）：进行warm up过程的步数。
+    - **start_lr** （float）：warm up的起始学习率。
+    - **end_lr** （float）：warm up的最终学习率。
+    - **last_epoch** （int，可选）: 上一轮的轮数，重启训练时设置为上一轮的epoch数。默认值为 -1，则为初始学习率 。
+    - **verbose** （bool，可选）：如果是 `True` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+
+
+返回
+:::::::::
+返回计算LinearLrWarmup的可调用对象。
+
+代码示例
+:::::::::
+
+.. code-block:: python
+
+     import paddle
+     import numpy as np
+
+     # train on default dygraph mode
+     paddle.disable_static()
+     x = np.random.uniform(-1, 1, [10, 10]).astype("float32")
+     linear = paddle.nn.Linear(10, 10)
+     scheduler = paddle.optimizer.LinearLrWarmup(
+             learning_rate=0.5, warmup_steps=20, start_lr=0, end_lr=0.5, verbose=True)
+     sgd = paddle.optimizer.SGD(learning_rate=scheduler, parameter_list=linear.parameters())
+     for epoch in range(20):
+         for batch_id in range(2):
+             x = paddle.to_tensor(x)
+             out = linear(x)
+             loss = paddle.reduce_mean(out)
+             loss.backward()
+             sgd.minimize(loss)
+             linear.clear_gradients()
+         scheduler.step()
+
+     # train on static mode
+     paddle.enable_static()
+     main_prog = paddle.static.Program()
+     start_prog = paddle.static.Program()
+     with paddle.static.program_guard(main_prog, start_prog):
+         x = paddle.static.data(name='x', shape=[None, 4, 5])
+         y = paddle.static.data(name='y', shape=[None, 4, 5])
+         z = paddle.static.nn.fc(x, 100)
+         loss = paddle.mean(z)
+         scheduler = paddle.optimizer.lr_scheduler.LinearLrWarmup(
+             learning_rate=0.5, warmup_steps=20, start_lr=0, end_lr=0.5, verbose=True)
+         sgd = paddle.optimizer.SGD(learning_rate=scheduler)
+         sgd.minimize(loss)
+
+     exe = paddle.static.Executor()
+     exe.run(start_prog)
+     for epoch in range(20):
+         for batch_id in range(2):
+             out = exe.run(
+                 main_prog,
+                 feed={
+                     'x': np.random.randn(3, 4, 5).astype('float32'),
+                     'y': np.random.randn(3, 4, 5).astype('float32')
+                 },
+                 fetch_list=loss.name)
+         scheduler.step()      
+
+.. py:method:: step(epoch=None)
+
+step函数需要在优化器的 `step()` 函数之后调用，调用之后将会根据epoch数来更新学习率，更新之后的学习率将会在优化器下一轮更新参数时使用。
+
+参数：
+  - **epoch** （int，可选）- 指定具体的epoch数。默认值None，此时将会从-1自动累加 ``epoch`` 数。
+
+返回：
+  无。
+
+**代码示例** ：
+
+  参照上述示例代码。
+
+

doc/fluid/api_cn/optimizer_cn/lr_scheduler_cn/MultiStepLR_cn.rst

+.. _cn_api_paddle_optimizer_MultiStepLR:
+
+MultiStepLR
+-----------------------------------
+
+.. py:class:: paddle.optimizer.lr_scheduler.MultiStepLR(learning_rate, milestones, gamma=0.1, last_epoch=-1, verbose=False)
+
+该接口提供一种学习率按指定轮数衰减的功能。
+
+衰减过程可以参考以下代码：
+
+.. code-block:: text 
+
+      learning_rate = 0.5
+      milestones = [30, 50]
+      gamma = 0.1
+      if epoch < 30:
+          learning_rate = 0.5
+      elif epoch < 50:
+          learning_rate = 0.05  # 0.5 * 0.1
+      else:
+          learning_rate = 0.005 # 0.05 * 0.1
+
+参数
+:::::::::
+    - **learning_rate** （float） - 初始学习率，数据类型为Python float。
+    - **milestones** ：（list）：轮数下标列表。必须递增。
+    - **gamma** （float，可选）：衰减率，new_lr = origin_lr * gamma, 衰减率必须小于等于1.0，默认值为0.1。
+    - **last_epoch** （int，可选）: 上一轮的轮数，重启训练时设置为上一轮的epoch数。默认值为 -1，则为初始学习率 。
+    - **verbose** （bool，可选）：如果是 `True` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+
+
+返回
+:::::::::
+返回计算MultiStepLR的可调用对象。
+
+代码示例
+:::::::::
+
+.. code-block:: python
+
+    import paddle
+    import numpy as np
+
+    # train on default dygraph mode
+    paddle.disable_static()
+    x = np.random.uniform(-1, 1, [10, 10]).astype("float32")
+    linear = paddle.nn.Linear(10, 10)
+    scheduler = paddle.optimizer.lr_scheduler.MultiStepLR(learning_rate=0.5, milestones=[2, 4, 6], gamma=0.8, verbose=True)
+    sgd = paddle.optimizer.SGD(learning_rate=scheduler, parameter_list=linear.parameters())
+    for epoch in range(20):
+        for batch_id in range(2):
+            x = paddle.to_tensor(x)
+            out = linear(x)
+            loss = paddle.reduce_mean(out)
+            loss.backward()
+            sgd.minimize(loss)
+            linear.clear_gradients()
+        scheduler.step()
+
+    # train on static mode
+    paddle.enable_static()
+    main_prog = paddle.static.Program()
+    start_prog = paddle.static.Program()
+    with paddle.static.program_guard(main_prog, start_prog):
+        x = paddle.static.data(name='x', shape=[None, 4, 5])
+        y = paddle.static.data(name='y', shape=[None, 4, 5])
+        z = paddle.static.nn.fc(x, 100)
+        loss = paddle.mean(z)
+        scheduler = paddle.optimizer.lr_scheduler.MultiStepLR(learning_rate=0.5, milestones=[2, 4, 6], gamma=0.8, verbose=True)
+        sgd = paddle.optimizer.SGD(learning_rate=scheduler)
+        sgd.minimize(loss)
+
+    exe = paddle.static.Executor()
+    exe.run(start_prog)
+    for epoch in range(20):
+        for batch_id in range(2):
+            out = exe.run(
+                main_prog,
+                feed={
+                    'x': np.random.randn(3, 4, 5).astype('float32'),
+                    'y': np.random.randn(3, 4, 5).astype('float32')
+                },
+                fetch_list=loss.name)
+        scheduler.step()
+
+.. py:method:: step(epoch=None)
+
+step函数需要在优化器的 `step()` 函数之后调用，调用之后将会根据epoch数来更新学习率，更新之后的学习率将会在优化器下一轮更新参数时使用。
+
+参数：
+  - **epoch** （int，可选）- 指定具体的epoch数。默认值None，此时将会从-1自动累加 ``epoch`` 数。
+
+返回：
+  无。
+
+**代码示例** ：
+
+  参照上述示例代码。
+

doc/fluid/api_cn/optimizer_cn/lr_scheduler_cn/NaturalExpLR_cn.rst

+.. _cn_api_paddle_optimizer_NaturalExpLR:
+
+NaturalExpLR
+-------------------------------
+
+
+.. py:class:: paddle.optimizer.lr_scheduler.NaturalExpLR(learning_rate, gama, last_epoch=-1, verbose=False)
+
+该接口提供按自然指数衰减学习率的功能。
+
+自然指数衰减的计算方式如下。
+
+.. math::
+
+    decayed\_learning\_rate = learning\_rate * e^{y} 
+
+参数
+:::::::::
+    - **learning_rate** （float） - 初始学习率，数据类型为Python float。
+    - **gamma** （float）：衰减率。
+    - **last_epoch** （int，可选）: 上一轮的轮数，重启训练时设置为上一轮的epoch数。默认值为 -1，则为初始学习率。
+    - **verbose** （bool，可选）：如果是 `True` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+
+返回
+:::::::::
+返回计算NaturalExpLR的可调用对象。
+
+代码示例
+:::::::::
+
+.. code-block:: python
+
+    import paddle
+    import numpy as np
+
+    # train on default dygraph mode
+    paddle.disable_static()
+    x = np.random.uniform(-1, 1, [10, 10]).astype("float32")
+    linear = paddle.nn.Linear(10, 10)
+    scheduler = paddle.optimizer.lr_scheduler.NaturalExpLR(learning_rate=0.5, gamma=0.1, verbose=True)
+    sgd = paddle.optimizer.SGD(learning_rate=scheduler, parameter_list=linear.parameters())
+    for epoch in range(20):
+        for batch_id in range(2):
+            x = paddle.to_tensor(x)
+            out = linear(x)
+            loss = paddle.reduce_mean(out)
+            loss.backward()
+            sgd.minimize(loss)
+            linear.clear_gradients()
+        scheduler.step()
+
+    # train on static mode
+    paddle.enable_static()
+    main_prog = paddle.static.Program()
+    start_prog = paddle.static.Program()
+    with paddle.static.program_guard(main_prog, start_prog):
+        x = paddle.static.data(name='x', shape=[None, 4, 5])
+        y = paddle.static.data(name='y', shape=[None, 4, 5])
+        z = paddle.static.nn.fc(x, 100)
+        loss = paddle.mean(z)
+        scheduler = paddle.optimizer.lr_scheduler.NaturalExpLR(learning_rate=0.5, gamma=0.1, verbose=True)
+        sgd = paddle.optimizer.SGD(learning_rate=scheduler)
+        sgd.minimize(loss)
+
+    exe = paddle.static.Executor()
+    exe.run(start_prog)
+    for epoch in range(20):
+        for batch_id in range(2):
+            out = exe.run(
+                main_prog,
+                feed={
+                    'x': np.random.randn(3, 4, 5).astype('float32'),
+                    'y': np.random.randn(3, 4, 5).astype('float32')
+                },
+                fetch_list=loss.name)
+        scheduler.step()
+
+.. py:method:: step(epoch=None)
+
+step函数需要在优化器的 `step()` 函数之后调用，调用之后将会根据epoch数来更新学习率，更新之后的学习率将会在优化器下一轮更新参数时使用。
+
+参数：
+  - **epoch** （int，可选）- 指定具体的epoch数。默认值None，此时将会从-1自动累加 ``epoch`` 数。
+
+返回：
+  无。
+
+**代码示例** ：
+
+  参照上述示例代码。
+

doc/fluid/api_cn/optimizer_cn/lr_scheduler_cn/NoamLR_cn.rst

+.. _cn_api_paddle_optimizer_NoamLR:
+
+NoamLR
+-------------------------------
+
+
+.. py:class:: paddle.optimizer.lr_scheduler.NoamLR(d_model, warmup_steps, learning_rate=1.0, last_epoch=-1, verbose=False)
+
+
+该接口提供Noam衰减学习率的功能。
+
+Noam衰减的计算方式如下。
+
+.. math::
+
+    decayed\_learning\_rate = learning\_rate * d_{model}^{-0.5} * min(epoch^{-0.5}, epoch * warmup\_steps^{-1.5})
+
+关于Noam衰减的更多细节请参考 `attention is all you need <https://arxiv.org/pdf/1706.03762.pdf>`_
+
+参数
+:::::::::
+    - **d$_{model}$**  （int） - 模型的输入、输出向量特征维度，为超参数。数据类型为Python int。
+    - **warmup_steps** （int） - 预热步数，为超参数。数据类型为Python int。
+    - **learning_rate** （float） - 初始学习率，数据类型为Python float。默认值为1.0。
+    - **last_epoch** （int，可选）: 上一轮的轮数，重启训练时设置为上一轮的epoch数。默认值为 -1，则为初始学习率。
+    - **verbose** （bool，可选）：如果是 `True` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+
+返回
+:::::::::
+返回计算NoamLR的可调用对象。
+
+代码示例
+:::::::::
+
+.. code-block:: python
+
+   import paddle
+   import numpy as np
+
+   # train on default dygraph mode
+   paddle.disable_static()
+   x = np.random.uniform(-1, 1, [10, 10]).astype("float32")
+   linear = paddle.nn.Linear(10, 10)
+   scheduler = paddle.optimizer.lr_scheduler.NoamLR(d_model=0.01, warmup_steps=100, verbose=True)
+   sgd = paddle.optimizer.SGD(learning_rate=scheduler, parameter_list=linear.parameters())
+   for epoch in range(20):
+       for batch_id in range(2):
+           x = paddle.to_tensor(x)
+           out = linear(x)
+           loss = paddle.reduce_mean(out)
+           loss.backward()
+           sgd.minimize(loss)
+           linear.clear_gradients()
+       scheduler.step()
+
+   # train on static mode
+   paddle.enable_static()
+   main_prog = paddle.static.Program()
+   start_prog = paddle.static.Program()
+   with paddle.static.program_guard(main_prog, start_prog):
+       x = paddle.static.data(name='x', shape=[None, 4, 5])
+       y = paddle.static.data(name='y', shape=[None, 4, 5])
+       z = paddle.static.nn.fc(x, 100)
+       loss = paddle.mean(z)
+       scheduler = paddle.optimizer.lr_scheduler.NoamLR(d_model=0.01, warmup_steps=100, verbose=True)
+       sgd = paddle.optimizer.SGD(learning_rate=scheduler)
+       sgd.minimize(loss)
+
+   exe = paddle.static.Executor()
+   exe.run(start_prog)
+   for epoch in range(20):
+       for batch_id in range(2):
+           out = exe.run(
+               main_prog,
+               feed={
+                   'x': np.random.randn(3, 4, 5).astype('float32'),
+                   'y': np.random.randn(3, 4, 5).astype('float32')
+               },
+               fetch_list=loss.name)
+       scheduler.step()
+
+
+
+.. py:method:: step(epoch=None)
+
+step函数需要在优化器的 `step()` 函数之后调用，调用之后将会根据epoch数来更新学习率，更新之后的学习率将会在优化器下一轮更新参数时使用。
+
+参数：
+  - **epoch** （int，可选）- 指定具体的epoch数。默认值None，此时将会从-1自动累加 ``epoch`` 数。
+
+返回：
+  无。
+
+**代码示例** ：
+
+  参照上述示例代码。
+
+

doc/fluid/api_cn/optimizer_cn/lr_scheduler_cn/PiecewiseLR_cn.rst

+.. _cn_api_paddle_optimizer_PiecewiseLR:
+
+PiecewiseLR
+-------------------------------
+
+
+.. py:class:: paddle.optimizer.lr_scheduler.PiecewiseLR(boundaries, values, last_epoch=-1, verbose=False)
+
+
+该接口提供对初始学习率进行分段(piecewise)常数衰减的功能。
+
+分段常数衰减的过程举例描述如下。
+
+.. code-block:: text
+
+    例如，设定的boundaries列表为[100, 200]，候选学习率常量列表values为[1.0, 0.5, 0.1]，则：
+    1、在当前训练步数epoch小于100步，学习率值为1.0。
+    2、在当前训练步数epoch大于或等于100步，并且小于200步时，学习率值为0.5。
+    3、在当前训练步数epoch大于或等于200步时，学习率值为0.1。
+
+
+参数
+:::::::::
+    - **boundaries** （list）：指定衰减的步数边界。列表的数据元素为Python int类型。
+    - **values** （list） ：备选学习率列表。数据元素类型为Python float的列表。与边界值列表有对应的关系。
+    - **last_epoch** （int，可选）：上一轮的轮数，重启训练时设置为上一轮的epoch数。默认值为 -1，则为初始学习率 。
+    - **verbose** （bool，可选）：如果是 `True` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+
+返回
+:::::::::
+返回计算PiecewiseLR的可调用对象。
+
+代码示例
+:::::::::
+
+.. code-block:: python
+
+    import paddle
+    import numpy as np
+
+    # train on default dygraph mode
+    paddle.disable_static()
+    x = np.random.uniform(-1, 1, [10, 10]).astype("float32")
+    linear = paddle.nn.Linear(10, 10)
+    scheduler = paddle.optimizer.lr_scheduler.PiecewiseLR(boundaries=[3, 6, 9], values=[0.1, 0.2, 0.3, 0.4], verbose=True)
+    sgd = paddle.optimizer.SGD(learning_rate=scheduler, parameter_list=linear.parameters())
+    for epoch in range(20):
+        for batch_id in range(2):
+            x = paddle.to_tensor(x)
+            out = linear(x)
+            loss = paddle.reduce_mean(out)
+            loss.backward()
+            sgd.minimize(loss)
+            linear.clear_gradients()
+        scheduler.step()
+
+    # train on static mode
+    paddle.enable_static()
+    main_prog = paddle.static.Program()
+    start_prog = paddle.static.Program()
+    with paddle.static.program_guard(main_prog, start_prog):
+        x = paddle.static.data(name='x', shape=[None, 4, 5])
+        y = paddle.static.data(name='y', shape=[None, 4, 5])
+        z = paddle.static.nn.fc(x, 100)
+        loss = paddle.mean(z)
+        scheduler = paddle.optimizer.lr_scheduler.PiecewiseLR(boundaries=[3, 6, 9], values=[0.1, 0.2, 0.3, 0.4], verbose=True)
+        sgd = paddle.optimizer.SGD(learning_rate=scheduler)
+        sgd.minimize(loss)
+
+    exe = paddle.static.Executor()
+    exe.run(start_prog)
+    for epoch in range(20):
+        for batch_id in range(2):
+            out = exe.run(
+                main_prog,
+                feed={
+                    'x': np.random.randn(3, 4, 5).astype('float32'),
+                    'y': np.random.randn(3, 4, 5).astype('float32')
+                },
+                fetch_list=loss.name)
+        scheduler.step()
+
+.. py:method:: step(epoch=None)
+
+step函数需要在优化器的 `step()` 函数之后调用，调用之后将会根据epoch数来更新学习率，更新之后的学习率将会在优化器下一轮更新参数时使用。
+
+参数：
+  - **epoch** （int，可选）- 指定具体的epoch数。默认值None，此时将会从-1自动累加 ``epoch`` 数。
+
+返回：
+  无。
+
+**代码示例** ：
+
+  参照上述示例代码。

doc/fluid/api_cn/optimizer_cn/lr_scheduler_cn/PolynomiaLR_cn.rst

+.. _cn_api_paddle_optimizer_PolynomialLR:
+
+PolynomialLR
+-------------------------------
+
+
+.. py:class:: paddle.optimizer.lr_scheduler.PolynomialLR(learning_rate, decay_steps, end_lr=0.0001, power=1.0, cycle=False, last_epoch=-1, verbose=False)
+
+
+该接口提供学习率按多项式衰减的功能。通过多项式衰减函数，使得学习率值逐步从初始的 ``learning_rate``，衰减到 ``end_learning_rate`` 。
+
+计算方式如下。
+
+若cycle为True，则计算公式为：
+
+.. math::
+
+    decay\_steps &= decay\_steps * math.ceil(\frac{epoch}{decay\_steps})  \\
+    decayed\_learning\_rate &= (learning\_rate-end\_learning\_rate)*(1-\frac{epoch}{decay\_steps})^{power}+end\_learning\_rate
+
+若cycle为False，则计算公式为：
+
+.. math::
+
+    epoch &= min(epoch, decay\_steps) \\
+    decayed\_learning\_rate &= (learning\_rate-end\_learning\_rate)*(1-\frac{epoch}{decay\_steps})^{power}+end\_learning\_rate
+
+
+参数
+:::::::::
+    - **learning_rate** （float） - 初始学习率，数据类型为Python float。
+    - **decay_steps** （int）：进行衰减的步长，这个决定了衰减周期。
+    - **end_lr** （float，可选）- 最小的最终学习率。默认值为0.0001。
+    - **power** （float，可选）- 多项式的幂。默认值为1.0。
+    - **cycle** （bool，可选）- 学习率下降后是否重新上升。若为True，则学习率衰减到最低学习率值时，会出现上升。若为False，则学习率曲线则单调递减。默认值为False。
+    - **last_epoch** （int，可选）: 上一轮的轮数，重启训练时设置为上一轮的epoch数。默认值为 -1，则为初始学习率。
+    - **verbose** （bool，可选）：如果是 `True` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+
+返回
+:::::::::
+返回计算PolynomialLR的可调用对象。
+
+
+代码示例
+:::::::::
+
+.. code-block:: python
+
+    import paddle
+    import numpy as np
+
+    # train on default dygraph mode
+    paddle.disable_static()
+    x = np.random.uniform(-1, 1, [10, 10]).astype("float32")
+    linear = paddle.nn.Linear(10, 10)
+    scheduler = paddle.optimizer.lr_scheduler.PolynomialLR(learning_rate=0.5, decay_steps=20, verbose=True)
+    sgd = paddle.optimizer.SGD(learning_rate=scheduler, parameter_list=linear.parameters())
+    for epoch in range(20):
+        for batch_id in range(2):
+            x = paddle.to_tensor(x)
+            out = linear(x)
+            loss = paddle.reduce_mean(out)
+            loss.backward()
+            sgd.minimize(loss)
+            linear.clear_gradients()
+        scheduler.step()
+
+    # train on static mode
+    paddle.enable_static()
+    main_prog = paddle.static.Program()
+    start_prog = paddle.static.Program()
+    with paddle.static.program_guard(main_prog, start_prog):
+        x = paddle.static.data(name='x', shape=[None, 4, 5])
+        y = paddle.static.data(name='y', shape=[None, 4, 5])
+        z = paddle.static.nn.fc(x, 100)
+        loss = paddle.mean(z)
+        scheduler = paddle.optimizer.lr_scheduler.PolynomialLR(learning_rate=0.5, decay_steps=20, verbose=True)
+        sgd = paddle.optimizer.SGD(learning_rate=scheduler)
+        sgd.minimize(loss)
+
+    exe = paddle.static.Executor()
+    exe.run(start_prog)
+    for epoch in range(20):
+        for batch_id in range(2):
+            out = exe.run(
+                main_prog,
+                feed={
+                    'x': np.random.randn(3, 4, 5).astype('float32'),
+                    'y': np.random.randn(3, 4, 5).astype('float32')
+                },
+                fetch_list=loss.name)
+        scheduler.step()
+
+.. py:method:: step(epoch=None)
+
+step函数需要在优化器的 `step()` 函数之后调用，调用之后将会根据epoch数来更新学习率，更新之后的学习率将会在优化器下一轮更新参数时使用。
+
+参数：
+  - **epoch** （int，可选）- 指定具体的epoch数。默认值None，此时将会从-1自动累加 ``epoch`` 数。
+
+返回：
+  无。
+
+**代码示例** ：
+
+  参照上述示例代码。
+

doc/fluid/api_cn/optimizer_cn/lr_scheduler_cn/ReduceLROnPlateauLR_cn.rst

+.. _cn_api_paddle_optimizer_ReduceLROnPlateau:
+
+ReduceLROnPlateau
+-----------------------------------
+
+.. py:class:: paddle.optimizer.lr_scheduler.ReduceLROnPlateau(learning_rate, mode='min', factor=0.1, patience=10, threshold=1e-4, threshold_mode='rel', cooldown=0, min_lr=0, epsilon=1e-8, verbose=False)
+
+该API为 ``loss`` 自适应的学习率衰减策略。默认情况下，当 ``loss`` 停止下降时，降低学习率（如果将 mode 设置为 'max' ，此时判断逻辑相反，loss 停止上升时降低学习率）。其思想是：一旦模型表现不再提升，将学习率降低2-10倍对模型的训练往往有益。
+loss 是传入到该类方法 ``step`` 中的参数，其必须是shape为[1]的1-D Tensor。 如果 loss 停止下降（mode 为 min 时）超过 ``patience`` 个epoch，学习率将会减小为 learning_rate * factor。
+此外，每降低一次学习率后，将会进入一个时长为 cooldown 个epoch的冷静期，在冷静期内，将不会监控 loss 的变化情况，也不会衰减。 在冷静期之后，会继续监控 loss 的上升或下降。
+
+
+参数
+:::::::::
+    - **learning_rate** （float） - 初始学习率，数据类型为Python float。
+    - **mode** （str，可选）'min' 和 'max' 之一。通常情况下，为 'min' ，此时当 loss 停止下降时学习率将减小。默认：'min' 。 （注意：仅在特殊用法时，可以将其设置为 'max' ，此时判断逻辑相反， loss 停止上升学习率才减小）
+    - **factor** （float，可选） - 学习率衰减的比例。new_lr = origin_lr * factor，它是值小于1.0的float型数字，默认: 0.1。
+    - **patience** （int，可选）- 当 loss 连续 patience 个epoch没有下降(mode: 'min')或上升(mode: 'max')时，学习率才会减小。默认：10。
+    - **threshold** （float，可选）- threshold 和 threshold_mode 两个参数将会决定 loss 最小变化的阈值。小于该阈值的变化 将会被忽视。默认：1e-4。
+    - **threshold_mode** （str，可选）- 'rel' 和 'abs' 之一。在 'rel' 模式下， loss 最小变化的阈值是 last_loss * threshold ， 其中 last_loss 是 loss 在上个epoch的值。在 'abs' 模式下，loss 最小变化的阈值是 threshold 。 默认：'rel'。
+   - **cooldown** （int，可选）- 在学习速率每次减小之后，会进入时长为 ``cooldown`` 个 step 的冷静期。默认：0。
+   - **min_lr** （float，可选） - 最小的学习率。减小后的学习率最低下界限。默认：0。
+   - **epsilon** （float，可选）- 如果新旧学习率间的差异小于epsilon ，则不会更新。默认值:1e-8。
+    - **verbose** （bool，可选）：如果是 `True` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+
+返回
+:::::::::
+    返回计算ReduceLROnPlateau的可调用对象。
+
+代码示例
+:::::::::
+
+.. code-block:: python
+
+    import paddle
+    import numpy as np
+
+    # train on default dygraph mode
+    paddle.disable_static()
+    x = np.random.uniform(-1, 1, [10, 10]).astype("float32")
+    linear = paddle.nn.Linear(10, 10)
+    scheduler = paddle.optimizer.lr_scheduler.ReduceLROnPlateau(learning_rate=1.0, factor=0.5, patience=5, verbose=True)
+    sgd = paddle.optimizer.SGD(learning_rate=scheduler, parameter_list=linear.parameters())
+    for epoch in range(20):
+        for batch_id in range(2):
+            x = paddle.to_tensor(x)
+            out = linear(x)
+            loss = paddle.reduce_mean(out)
+            loss.backward()
+            sgd.minimize(loss)
+            linear.clear_gradients()
+        scheduler.step(loss)
+
+    # train on static mode
+    paddle.enable_static()
+    main_prog = paddle.static.Program()
+    start_prog = paddle.static.Program()
+    with paddle.static.program_guard(main_prog, start_prog):
+        x = paddle.static.data(name='x', shape=[None, 4, 5])
+        y = paddle.static.data(name='y', shape=[None, 4, 5])
+        z = paddle.static.nn.fc(x, 100)
+        loss = paddle.mean(z)
+        scheduler = paddle.optimizer.lr_scheduler.ReduceLROnPlateau(learning_rate=1.0, factor=0.5, patience=5, verbose=True)
+        sgd = paddle.optimizer.SGD(learning_rate=scheduler)
+        sgd.minimize(loss)
+
+    exe = paddle.static.Executor()
+    exe.run(start_prog)
+    for epoch in range(20):
+        for batch_id in range(2):
+            out = exe.run(
+                main_prog,
+                feed={
+                    'x': np.random.randn(3, 4, 5).astype('float32'),
+                    'y': np.random.randn(3, 4, 5).astype('float32')
+                },
+                fetch_list=loss.name)
+        scheduler.step(out[0])
+
+
+.. py:method:: step(metrics, epoch=None) 
+
+step函数需要在优化器的 `step()` 函数之后调用，其根据传入的 metrics 调整optimizer中的学习率，调整后的学习率将会在下一个 ``step`` 时生效。
+
+参数：
+    metrics （Tensor|numpy.ndarray|float）-用来判断是否需要降低学习率。如果 loss 连续 patience 个 ``steps`` 没有下降， 将会降低学习率。可以是Tensor或者numpy.array，但是shape必须为[1] 。
+  - **epoch** （int，可选）- 指定具体的epoch数。默认值None，此时将会从-1自动累加 ``epoch`` 数。
+
+返回：
+    无
+
+**代码示例**:
+
+    参照上述示例代码。

doc/fluid/api_cn/optimizer_cn/lr_scheduler_cn/StepLR_cn.rst

+.. _cn_api_paddle_optimizer_StepLR:
+
+StepLR
+-----------------------------------
+
+.. py:class:: paddle.optimizer.lr_scheduler.StepLR(learning_rate, step_size, gamma=0.1, last_epoch=-1, verbose=False)
+
+该接口提供一种学习率按指定 `间隔` 轮数衰减的功能。
+
+衰减过程可以参考以下代码：
+
+.. code-block:: text 
+
+     learning_rate = 0.5
+     step_size = 30
+     gamma = 0.1
+     if epoch < 30:
+         learning_rate = 0.5
+     elif epoch < 60:
+         learning_rate = 0.05 # 0.5 * 0.1
+     else:
+         learning_rate = 0.005 # 0.05 * 0.1
+
+参数
+:::::::::
+    - **learning_rate** （float） - 初始学习率，数据类型为Python float。
+    - **step_size** ：（int）：学习率衰减轮数间隔。
+    - **gamma** （float, 可选）：衰减率，new_lr = origin_lr * gamma, 衰减率必须小于等于1.0，默认值为0.1。
+    - **last_epoch** （int，可选）: 上一轮的轮数，重启训练时设置为上一轮的epoch数。默认值为 -1，则为初始学习率 。
+    - **verbose** （bool，可选）：如果是 `True` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+
+
+返回
+:::::::::
+返回计算StepLR的可调用对象。
+
+代码示例
+:::::::::
+
+.. code-block:: python
+
+    import paddle
+    import numpy as np
+
+    # train on default dygraph mode
+    paddle.disable_static()
+    x = np.random.uniform(-1, 1, [10, 10]).astype("float32")
+    linear = paddle.nn.Linear(10, 10)
+    scheduler = paddle.optimizer.lr_scheduler.StepLR(learning_rate=0.5, step_size=5, gamma=0.8, verbose=True)
+    sgd = paddle.optimizer.SGD(learning_rate=scheduler, parameter_list=linear.parameters())
+    for epoch in range(20):
+        for batch_id in range(2):
+            x = paddle.to_tensor(x)
+            out = linear(x)
+            loss = paddle.reduce_mean(out)
+            loss.backward()
+            sgd.minimize(loss)
+            linear.clear_gradients()
+        scheduler.step()
+
+    # train on static mode
+    paddle.enable_static()
+    main_prog = paddle.static.Program()
+    start_prog = paddle.static.Program()
+    with paddle.static.program_guard(main_prog, start_prog):
+        x = paddle.static.data(name='x', shape=[None, 4, 5])
+        y = paddle.static.data(name='y', shape=[None, 4, 5])
+        z = paddle.static.nn.fc(x, 100)
+        loss = paddle.mean(z)
+        scheduler = paddle.optimizer.lr_scheduler.StepLR(learning_rate=0.5, step_size=5, gamma=0.8, verbose=True)
+        sgd = paddle.optimizer.SGD(learning_rate=scheduler)
+        sgd.minimize(loss)
+
+    exe = paddle.static.Executor()
+    exe.run(start_prog)
+    for epoch in range(20):
+        for batch_id in range(2):
+            out = exe.run(
+                main_prog,
+                feed={
+                    'x': np.random.randn(3, 4, 5).astype('float32'),
+                    'y': np.random.randn(3, 4, 5).astype('float32')
+                },
+                fetch_list=loss.name)
+        scheduler.step()
+
+.. py:method:: step(epoch=None)
+
+step函数需要在优化器的 `step()` 函数之后调用，调用之后将会根据epoch数来更新学习率，更新之后的学习率将会在优化器下一轮更新参数时使用。
+
+参数：
+  - **epoch** （int，可选）- 指定具体的epoch数。默认值None，此时将会从-1自动累加 ``epoch`` 数。
+
+返回：
+  无。
+
+**代码示例** ：
+
+  参照上述示例代码。
+