update optimizer cn to 1.5 en official (#1062)

doc/fluid/api_cn/layers_cn/StaticRNN_cn.rst

@@ -7,7 +7,7 @@ StaticRNN
 
 StaticRNN可以处理一批序列数据。每个样本序列的长度必须相等。StaticRNN将拥有自己的参数，如输入、输出和存储器等。请注意，输入的第一个维度表示序列长度，且输入的所有序列长度必须相同。并且输入和输出的每个轴的含义是相同的。
 
-**代码示例**：
+**代码示例**
 
 .. code-block:: python
 
@@ -42,88 +42,88 @@ StaticRNN可以将多个变量标记为其输出。使用rnn()获取输出序列
 
 .. py:method:: step()
 
-  用户在该代码块中定义RNN中的operators。
+用户在该代码块中定义RNN中的operators。
 
 
 .. py:method:: memory(init=None, shape=None, batch_ref=None, init_value=0.0, init_batch_dim_idx=0, ref_batch_dim_idx=1)
  
-  为静态RNN创建一个内存变量。
-  如果init不为None，则此变量将初始化内存。 如果init为None，则必须设置shape和batch_ref，并且此函数将初始化init变量。
+为静态RNN创建一个内存变量。
+如果init不为None，则此变量将初始化内存。 如果init为None，则必须设置shape和batch_ref，并且此函数将初始化init变量。
 
-  参数：
-    - **init** (Variable|None) - 初始化过的变量，如果没有设置，则必须提供shape和batch_ref，默认值None
-    - **shape** (list|tuple) - boot memory的形状，注意其不包括batch_size，默认值None
-    - **batch_ref** (Variable|None) - batch引用变量，默认值None
-    - **init_value** (float) - boot memory的初始化值，默认值0.0
-    - **init_batch_dim_idx** (int) - init变量的batch_size轴，默认值0
-    - **ref_batch_dim_idx** (int) - batch_ref变量的batch_size轴
+参数：
+  - **init** (Variable|None) - 初始化过的变量，如果没有设置，则必须提供shape和batch_ref，默认值None
+  - **shape** (list|tuple) - boot memory的形状，注意其不包括batch_size，默认值None
+  - **batch_ref** (Variable|None) - batch引用变量，默认值None
+  - **init_value** (float) - boot memory的初始化值，默认值0.0
+  - **init_batch_dim_idx** (int) - init变量的batch_size轴，默认值0
+  - **ref_batch_dim_idx** (int) - batch_ref变量的batch_size轴
 
-  返回：内存变量
+返回：内存变量
 
 
-  **代码示例**：
+**代码示例**
 
-  .. code-block:: python
-
-        import paddle.fluid as fluid
-        import paddle.fluid.layers as layers
-
-        vocab_size, hidden_size=10000, 200
-        x = layers.data(name="x", shape=[-1, 1, 1], dtype='int64')
-        x_emb = layers.embedding(
-            input=x,
-            size=[vocab_size, hidden_size],
-            dtype='float32',
-            is_sparse=False)
-        x_emb = layers.transpose(x_emb, perm=[1, 0, 2])
+.. code-block:: python
 
-        rnn = fluid.layers.StaticRNN()
-        with rnn.step():
-            word = rnn.step_input(x_emb)
-            prev = rnn.memory(shape=[-1, hidden_size], batch_ref = word)
-            hidden = fluid.layers.fc(input=[word, prev], size=hidden_size, act='relu')
-            rnn.update_memory(prev, hidden)
+      import paddle.fluid as fluid
+      import paddle.fluid.layers as layers
+
+      vocab_size, hidden_size=10000, 200
+      x = layers.data(name="x", shape=[-1, 1, 1], dtype='int64')
+      x_emb = layers.embedding(
+          input=x,
+          size=[vocab_size, hidden_size],
+          dtype='float32',
+          is_sparse=False)
+      x_emb = layers.transpose(x_emb, perm=[1, 0, 2])
+
+      rnn = fluid.layers.StaticRNN()
+      with rnn.step():
+          word = rnn.step_input(x_emb)
+          prev = rnn.memory(shape=[-1, hidden_size], batch_ref = word)
+          hidden = fluid.layers.fc(input=[word, prev], size=hidden_size, act='relu')
+          rnn.update_memory(prev, hidden)
 
 .. py:method:: step_input(x)
 
-  标记作为StaticRNN输入的序列。
+标记作为StaticRNN输入的序列。
 
-  参数：
-    - **x** (Variable) – 输入序列，x的形状应为[seq_len, ...]。
+参数：
+  - **x** (Variable) – 输入序列，x的形状应为[seq_len, ...]。
 
-  返回：输入序列中的当前时间步长。
+返回：输入序列中的当前时间步长。
 
 
 
 .. py:method:: step_output(o)
 
-  标记作为StaticRNN输出的序列。
+标记作为StaticRNN输出的序列。
 
-  参数：
-    -**o** (Variable) – 输出序列
+参数：
+  -**o** (Variable) – 输出序列
 
-  返回：None
+返回：None
 
 
 .. py:method:: output(*outputs)
 
-  标记StaticRNN输出变量。
+标记StaticRNN输出变量。
 
-  参数：
-    -**outputs** – 输出变量
+参数：
+  -**outputs** – 输出变量
 
-  返回：None
+返回：None
 
 
 .. py:method:: update_memory(mem, var)
 
-  将内存从ex_mem更新为new_mem。请注意，ex_mem和new_mem的形状和数据类型必须相同。
+将内存从ex_mem更新为new_mem。请注意，ex_mem和new_mem的形状和数据类型必须相同。
 
-  参数：    
-    - **mem** (Variable) – 内存变量
-    - **var** (Variable) – RNN块中产生的普通变量
+参数：    
+  - **mem** (Variable) – 内存变量
+  - **var** (Variable) – RNN块中产生的普通变量
 
-  返回：None
+返回：None
 
 
 

doc/fluid/api_cn/optimizer_cn/AdagradOptimizer_cn.rst

@@ -24,9 +24,9 @@ http://cs231n.github.io/neural-networks-3/#ada 用于维持数值稳定性，避
     - **name** - 名称前缀（可选）
     - **initial_accumulator_value** (float) - moment累加器的初始值。
 
-**代码示例**：
+**代码示例**
 
-.. code-block:: python:
+.. code-block:: python
 
     import paddle.fluid as fluid
     import numpy as np
@@ -45,6 +45,161 @@ http://cs231n.github.io/neural-networks-3/#ada 用于维持数值稳定性，避
         feed={"inp": np_inp},
         fetch_list=[out.name])
 
+.. py:method:: apply_gradients(params_grads)
+
+为给定的params_grads对附加优化算子，为minimize过程的第二步
+
+参数：
+    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    loss = network()
+    optimizer = fluid.optimizer.SGD(learning_rate=0.1)
+    params_grads = optimizer.backward(loss)
+    # you may append operations for params_grads here
+    # ...
+    optimizer.apply_gradients(params_grads)
+
+
+.. py:method:: apply_optimize(loss, startup_program, params_grads)
+
+为给定的params_grads对附加优化算子，为minimize过程的第二步。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+.. py:method:: backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)
+
+自动做diff来向当前program附加反向算子，为minimize过程的第一步。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **parameter_list** (list) – 待更新的Variables组成的列表
+    - **no_grad_set** (set|None) – 应该被无视的Variables集合
+    - **callbacks** (list|None) – 当为某参数附加反向算子时所要运行的callables组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+**代码示例**
+
+详见apply_gradients的示例
+
+
+.. py:method:: load(stat_dict)
+
+在dygraph模式下，附带学习率衰减来加载优化器。
+
+参数：
+    - **stat_dict** – load_persistable方法加载的dict
+
+**代码示例**
+
+.. code-block:: python
+
+    from __future__ import print_function
+    import numpy as np
+    import paddle
+    import paddle.fluid as fluid
+    from paddle.fluid.optimizer import SGDOptimizer
+    from paddle.fluid.dygraph.nn import FC
+    from paddle.fluid.dygraph.base import to_variable
+
+    class MLP(fluid.Layer):
+        def __init__(self, name_scope):
+            super(MLP, self).__init__(name_scope)
+
+            self._fc1 = FC(self.full_name(), 10)
+            self._fc2 = FC(self.full_name(), 10)
+
+        def forward(self, inputs):
+            y = self._fc1(inputs)
+            y = self._fc2(y)
+            return y
+
+    with fluid.dygraph.guard():
+        mlp = MLP('mlp')
+        optimizer2 = SGDOptimizer(
+            learning_rate=fluid.layers.natural_exp_decay(
+            learning_rate=0.1,
+            decay_steps=10000,
+            decay_rate=0.5,
+            staircase=True))
+
+        train_reader = paddle.batch(
+                paddle.dataset.mnist.train(), batch_size=128, drop_last=True)
+
+        for batch_id, data in enumerate(train_reader()):
+            dy_x_data = np.array(
+                    [x[0].reshape(1, 28, 28) for x in data]).astype('float32')
+
+            y_data = np.array([x[1] for x in data]).astype('int64').reshape(
+                    128, 1)
+
+            img = to_variable(dy_x_data)
+            label = to_variable(y_data)
+            label._stop_gradient = True
+            cost = mlp(img)
+            avg_loss = fluid.layers.reduce_mean(cost)
+            avg_loss.backward()
+            optimizer.minimize(avg_loss)
+            mlp.clear_gradients()
+            fluid.dygraph.save_persistables(
+                    mlp.state_dict(), [optimizer, optimizer2], "save_dir_2")
+            if batch_id == 2:
+                    break
+
+    with fluid.dygraph.guard():
+        mlp_load = MLP('mlp')
+        optimizer_load2 = SGDOptimizer(
+                learning_rate=fluid.layers.natural_exp_decay(
+                learning_rate=0.1,
+                decay_steps=10000,
+                decay_rate=0.5,
+                staircase=True))
+        parameters, optimizers = fluid.dygraph.load_persistables(
+            "save_dir_2")
+        mlp_load.load_dict(parameters)
+        optimizer_load2.load(optimizers)
+    self.assertTrue(optimizer2._learning_rate.__dict__ == optimizer_load2._learning_rate.__dict__)
+
+
+.. py:method:: minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)
+
+
+通过更新parameter_list来添加操作，进而使损失最小化。
+
+该算子相当于backward()和apply_gradients()功能的合体。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **parameter_list** (list) – 待更新的Variables组成的列表
+    - **no_grad_set** (set|None) – 应该被无视的Variables集合
+    - **grad_clip** (GradClipBase|None) – 梯度裁剪的策略
+
+返回： (optimize_ops, params_grads)，分别为附加的算子列表；一个由(param, grad) 变量对组成的列表，用于优化
+
+返回类型：   tuple
+
+
+
 
 
 

doc/fluid/api_cn/optimizer_cn/AdamOptimizer_cn.rst

@@ -24,7 +24,7 @@ Adam更新如下：
 
 **代码示例**：
 
-.. code-block:: python:
+.. code-block:: python
 
     import paddle
     import paddle.fluid as fluid
@@ -51,6 +51,161 @@ Adam更新如下：
 
 
 
+.. py:method:: apply_gradients(params_grads)
+
+为给定的params_grads对附加优化算子，为minimize过程的第二步
+
+参数：
+    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    loss = network()
+    optimizer = fluid.optimizer.SGD(learning_rate=0.1)
+    params_grads = optimizer.backward(loss)
+    # you may append operations for params_grads here
+    # ...
+    optimizer.apply_gradients(params_grads)
+
+
+.. py:method:: apply_optimize(loss, startup_program, params_grads)
+
+为给定的params_grads对附加优化算子，为minimize过程的第二步。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+.. py:method:: backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)
+
+自动做diff来向当前program附加反向算子，为minimize过程的第一步。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **parameter_list** (list) – 待更新的Variables组成的列表
+    - **no_grad_set** (set|None) – 应该被无视的Variables集合
+    - **callbacks** (list|None) – 当为某参数附加反向算子时所要运行的callables组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+**代码示例**
+
+详见apply_gradients的示例
+
+
+.. py:method:: load(stat_dict)
+
+在dygraph模式下，附带学习率衰减来加载优化器。
+
+参数：
+    - **stat_dict** – load_persistable方法加载的dict
+
+**代码示例**
+
+.. code-block:: python
+
+    from __future__ import print_function
+    import numpy as np
+    import paddle
+    import paddle.fluid as fluid
+    from paddle.fluid.optimizer import SGDOptimizer
+    from paddle.fluid.dygraph.nn import FC
+    from paddle.fluid.dygraph.base import to_variable
+
+    class MLP(fluid.Layer):
+        def __init__(self, name_scope):
+            super(MLP, self).__init__(name_scope)
+
+            self._fc1 = FC(self.full_name(), 10)
+            self._fc2 = FC(self.full_name(), 10)
+
+        def forward(self, inputs):
+            y = self._fc1(inputs)
+            y = self._fc2(y)
+            return y
+
+    with fluid.dygraph.guard():
+        mlp = MLP('mlp')
+        optimizer2 = SGDOptimizer(
+            learning_rate=fluid.layers.natural_exp_decay(
+            learning_rate=0.1,
+            decay_steps=10000,
+            decay_rate=0.5,
+            staircase=True))
+
+        train_reader = paddle.batch(
+                paddle.dataset.mnist.train(), batch_size=128, drop_last=True)
+
+        for batch_id, data in enumerate(train_reader()):
+            dy_x_data = np.array(
+                    [x[0].reshape(1, 28, 28) for x in data]).astype('float32')
+
+            y_data = np.array([x[1] for x in data]).astype('int64').reshape(
+                    128, 1)
+
+            img = to_variable(dy_x_data)
+            label = to_variable(y_data)
+            label._stop_gradient = True
+            cost = mlp(img)
+            avg_loss = fluid.layers.reduce_mean(cost)
+            avg_loss.backward()
+            optimizer.minimize(avg_loss)
+            mlp.clear_gradients()
+            fluid.dygraph.save_persistables(
+                    mlp.state_dict(), [optimizer, optimizer2], "save_dir_2")
+            if batch_id == 2:
+                    break
+
+    with fluid.dygraph.guard():
+        mlp_load = MLP('mlp')
+        optimizer_load2 = SGDOptimizer(
+                learning_rate=fluid.layers.natural_exp_decay(
+                learning_rate=0.1,
+                decay_steps=10000,
+                decay_rate=0.5,
+                staircase=True))
+        parameters, optimizers = fluid.dygraph.load_persistables(
+            "save_dir_2")
+        mlp_load.load_dict(parameters)
+        optimizer_load2.load(optimizers)
+    self.assertTrue(optimizer2._learning_rate.__dict__ == optimizer_load2._learning_rate.__dict__)
+
+
+.. py:method:: minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)
+
+
+通过更新parameter_list来添加操作，进而使损失最小化。
+
+该算子相当于backward()和apply_gradients()功能的合体。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **parameter_list** (list) – 待更新的Variables组成的列表
+    - **no_grad_set** (set|None) – 应该被无视的Variables集合
+    - **grad_clip** (GradClipBase|None) – 梯度裁剪的策略
+
+返回： (optimize_ops, params_grads)，分别为附加的算子列表；一个由(param, grad) 变量对组成的列表，用于优化
+
+返回类型：   tuple
+
+
+
 
 
 

doc/fluid/api_cn/optimizer_cn/AdamaxOptimizer_cn.rst

@@ -26,7 +26,7 @@ Adamax 更新规则:
 
 **代码示例**：
 
-.. code-block:: python:
+.. code-block:: python
 
     import paddle.fluid as fluid
     import numpy
@@ -63,7 +63,160 @@ Adamax 更新规则:
 .. note::
     目前 ``AdamaxOptimizer`` 不支持  sparse parameter optimization.
 
-  
+
+
+.. py:method:: apply_gradients(params_grads)
+
+为给定的params_grads对附加优化算子，为minimize过程的第二步
+
+参数：
+    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    loss = network()
+    optimizer = fluid.optimizer.SGD(learning_rate=0.1)
+    params_grads = optimizer.backward(loss)
+    # you may append operations for params_grads here
+    # ...
+    optimizer.apply_gradients(params_grads)
+
+
+.. py:method:: apply_optimize(loss, startup_program, params_grads)
+
+为给定的params_grads对附加优化算子，为minimize过程的第二步。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+.. py:method:: backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)
+
+自动做diff来向当前program附加反向算子，为minimize过程的第一步。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **parameter_list** (list) – 待更新的Variables组成的列表
+    - **no_grad_set** (set|None) – 应该被无视的Variables集合
+    - **callbacks** (list|None) – 当为某参数附加反向算子时所要运行的callables组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+**代码示例**
+
+详见apply_gradients的示例
+
+
+.. py:method:: load(stat_dict)
+
+在dygraph模式下，附带学习率衰减来加载优化器。
+
+参数：
+    - **stat_dict** – load_persistable方法加载的dict
+
+**代码示例**
+
+.. code-block:: python
+
+    from __future__ import print_function
+    import numpy as np
+    import paddle
+    import paddle.fluid as fluid
+    from paddle.fluid.optimizer import SGDOptimizer
+    from paddle.fluid.dygraph.nn import FC
+    from paddle.fluid.dygraph.base import to_variable
+
+    class MLP(fluid.Layer):
+        def __init__(self, name_scope):
+            super(MLP, self).__init__(name_scope)
+
+            self._fc1 = FC(self.full_name(), 10)
+            self._fc2 = FC(self.full_name(), 10)
+
+        def forward(self, inputs):
+            y = self._fc1(inputs)
+            y = self._fc2(y)
+            return y
+
+    with fluid.dygraph.guard():
+        mlp = MLP('mlp')
+        optimizer2 = SGDOptimizer(
+            learning_rate=fluid.layers.natural_exp_decay(
+            learning_rate=0.1,
+            decay_steps=10000,
+            decay_rate=0.5,
+            staircase=True))
+
+        train_reader = paddle.batch(
+                paddle.dataset.mnist.train(), batch_size=128, drop_last=True)
+
+        for batch_id, data in enumerate(train_reader()):
+            dy_x_data = np.array(
+                    [x[0].reshape(1, 28, 28) for x in data]).astype('float32')
+
+            y_data = np.array([x[1] for x in data]).astype('int64').reshape(
+                    128, 1)
+
+            img = to_variable(dy_x_data)
+            label = to_variable(y_data)
+            label._stop_gradient = True
+            cost = mlp(img)
+            avg_loss = fluid.layers.reduce_mean(cost)
+            avg_loss.backward()
+            optimizer.minimize(avg_loss)
+            mlp.clear_gradients()
+            fluid.dygraph.save_persistables(
+                    mlp.state_dict(), [optimizer, optimizer2], "save_dir_2")
+            if batch_id == 2:
+                    break
+
+    with fluid.dygraph.guard():
+        mlp_load = MLP('mlp')
+        optimizer_load2 = SGDOptimizer(
+                learning_rate=fluid.layers.natural_exp_decay(
+                learning_rate=0.1,
+                decay_steps=10000,
+                decay_rate=0.5,
+                staircase=True))
+        parameters, optimizers = fluid.dygraph.load_persistables(
+            "save_dir_2")
+        mlp_load.load_dict(parameters)
+        optimizer_load2.load(optimizers)
+    self.assertTrue(optimizer2._learning_rate.__dict__ == optimizer_load2._learning_rate.__dict__)
+
+
+.. py:method:: minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)
+
+
+通过更新parameter_list来添加操作，进而使损失最小化。
+
+该算子相当于backward()和apply_gradients()功能的合体。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **parameter_list** (list) – 待更新的Variables组成的列表
+    - **no_grad_set** (set|None) – 应该被无视的Variables集合
+    - **grad_clip** (GradClipBase|None) – 梯度裁剪的策略
+
+返回： (optimize_ops, params_grads)，分别为附加的算子列表；一个由(param, grad) 变量对组成的列表，用于优化
+
+返回类型：   tuple
 
 
 

doc/fluid/api_cn/optimizer_cn/DGCMomentumOptimizer_cn.rst

@@ -48,3 +48,157 @@ DGC还使用动量因子掩藏(momentum factor masking)和预训练(warm-up)来
 
 
 
+
+.. py:method:: apply_gradients(params_grads)
+
+为给定的params_grads对附加优化算子，为minimize过程的第二步
+
+参数：
+    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    loss = network()
+    optimizer = fluid.optimizer.SGD(learning_rate=0.1)
+    params_grads = optimizer.backward(loss)
+    # you may append operations for params_grads here
+    # ...
+    optimizer.apply_gradients(params_grads)
+
+
+.. py:method:: apply_optimize(loss, startup_program, params_grads)
+
+为给定的params_grads对附加优化算子，为minimize过程的第二步。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+.. py:method:: backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)
+
+自动做diff来向当前program附加反向算子，为minimize过程的第一步。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **parameter_list** (list) – 待更新的Variables组成的列表
+    - **no_grad_set** (set|None) – 应该被无视的Variables集合
+    - **callbacks** (list|None) – 当为某参数附加反向算子时所要运行的callables组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+**代码示例**
+
+详见apply_gradients的示例
+
+
+.. py:method:: load(stat_dict)
+
+在dygraph模式下，附带学习率衰减来加载优化器。
+
+参数：
+    - **stat_dict** – load_persistable方法加载的dict
+
+**代码示例**
+
+.. code-block:: python
+
+    from __future__ import print_function
+    import numpy as np
+    import paddle
+    import paddle.fluid as fluid
+    from paddle.fluid.optimizer import SGDOptimizer
+    from paddle.fluid.dygraph.nn import FC
+    from paddle.fluid.dygraph.base import to_variable
+
+    class MLP(fluid.Layer):
+        def __init__(self, name_scope):
+            super(MLP, self).__init__(name_scope)
+
+            self._fc1 = FC(self.full_name(), 10)
+            self._fc2 = FC(self.full_name(), 10)
+
+        def forward(self, inputs):
+            y = self._fc1(inputs)
+            y = self._fc2(y)
+            return y
+
+    with fluid.dygraph.guard():
+        mlp = MLP('mlp')
+        optimizer2 = SGDOptimizer(
+            learning_rate=fluid.layers.natural_exp_decay(
+            learning_rate=0.1,
+            decay_steps=10000,
+            decay_rate=0.5,
+            staircase=True))
+
+        train_reader = paddle.batch(
+                paddle.dataset.mnist.train(), batch_size=128, drop_last=True)
+
+        for batch_id, data in enumerate(train_reader()):
+            dy_x_data = np.array(
+                    [x[0].reshape(1, 28, 28) for x in data]).astype('float32')
+
+            y_data = np.array([x[1] for x in data]).astype('int64').reshape(
+                    128, 1)
+
+            img = to_variable(dy_x_data)
+            label = to_variable(y_data)
+            label._stop_gradient = True
+            cost = mlp(img)
+            avg_loss = fluid.layers.reduce_mean(cost)
+            avg_loss.backward()
+            optimizer.minimize(avg_loss)
+            mlp.clear_gradients()
+            fluid.dygraph.save_persistables(
+                    mlp.state_dict(), [optimizer, optimizer2], "save_dir_2")
+            if batch_id == 2:
+                    break
+
+    with fluid.dygraph.guard():
+        mlp_load = MLP('mlp')
+        optimizer_load2 = SGDOptimizer(
+                learning_rate=fluid.layers.natural_exp_decay(
+                learning_rate=0.1,
+                decay_steps=10000,
+                decay_rate=0.5,
+                staircase=True))
+        parameters, optimizers = fluid.dygraph.load_persistables(
+            "save_dir_2")
+        mlp_load.load_dict(parameters)
+        optimizer_load2.load(optimizers)
+    self.assertTrue(optimizer2._learning_rate.__dict__ == optimizer_load2._learning_rate.__dict__)
+
+
+.. py:method:: minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)
+
+
+通过更新parameter_list来添加操作，进而使损失最小化。
+
+该算子相当于backward()和apply_gradients()功能的合体。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **parameter_list** (list) – 待更新的Variables组成的列表
+    - **no_grad_set** (set|None) – 应该被无视的Variables集合
+    - **grad_clip** (GradClipBase|None) – 梯度裁剪的策略
+
+返回： (optimize_ops, params_grads)，分别为附加的算子列表；一个由(param, grad) 变量对组成的列表，用于优化
+
+返回类型：   tuple
+

doc/fluid/api_cn/optimizer_cn/DecayedAdagradOptimizer_cn.rst

@@ -42,5 +42,156 @@ Decayed Adagrad Optimizer
   当前， ``DecayedAdagradOptimizer`` 不支持 sparse parameter optimization
 
 
+.. py:method:: apply_gradients(params_grads)
 
+为给定的params_grads对附加优化算子，为minimize过程的第二步
+
+参数：
+    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    loss = network()
+    optimizer = fluid.optimizer.SGD(learning_rate=0.1)
+    params_grads = optimizer.backward(loss)
+    # you may append operations for params_grads here
+    # ...
+    optimizer.apply_gradients(params_grads)
+
+
+.. py:method:: apply_optimize(loss, startup_program, params_grads)
+
+为给定的params_grads对附加优化算子，为minimize过程的第二步。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+.. py:method:: backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)
+
+自动做diff来向当前program附加反向算子，为minimize过程的第一步。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **parameter_list** (list) – 待更新的Variables组成的列表
+    - **no_grad_set** (set|None) – 应该被无视的Variables集合
+    - **callbacks** (list|None) – 当为某参数附加反向算子时所要运行的callables组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+**代码示例**
+
+详见apply_gradients的示例
+
+
+.. py:method:: load(stat_dict)
+
+在dygraph模式下，附带学习率衰减来加载优化器。
+
+参数：
+    - **stat_dict** – load_persistable方法加载的dict
+
+**代码示例**
+
+.. code-block:: python
+
+    from __future__ import print_function
+    import numpy as np
+    import paddle
+    import paddle.fluid as fluid
+    from paddle.fluid.optimizer import SGDOptimizer
+    from paddle.fluid.dygraph.nn import FC
+    from paddle.fluid.dygraph.base import to_variable
+
+    class MLP(fluid.Layer):
+        def __init__(self, name_scope):
+            super(MLP, self).__init__(name_scope)
+
+            self._fc1 = FC(self.full_name(), 10)
+            self._fc2 = FC(self.full_name(), 10)
+
+        def forward(self, inputs):
+            y = self._fc1(inputs)
+            y = self._fc2(y)
+            return y
+
+    with fluid.dygraph.guard():
+        mlp = MLP('mlp')
+        optimizer2 = SGDOptimizer(
+            learning_rate=fluid.layers.natural_exp_decay(
+            learning_rate=0.1,
+            decay_steps=10000,
+            decay_rate=0.5,
+            staircase=True))
+
+        train_reader = paddle.batch(
+                paddle.dataset.mnist.train(), batch_size=128, drop_last=True)
+
+        for batch_id, data in enumerate(train_reader()):
+            dy_x_data = np.array(
+                    [x[0].reshape(1, 28, 28) for x in data]).astype('float32')
+
+            y_data = np.array([x[1] for x in data]).astype('int64').reshape(
+                    128, 1)
+
+            img = to_variable(dy_x_data)
+            label = to_variable(y_data)
+            label._stop_gradient = True
+            cost = mlp(img)
+            avg_loss = fluid.layers.reduce_mean(cost)
+            avg_loss.backward()
+            optimizer.minimize(avg_loss)
+            mlp.clear_gradients()
+            fluid.dygraph.save_persistables(
+                    mlp.state_dict(), [optimizer, optimizer2], "save_dir_2")
+            if batch_id == 2:
+                    break
+
+    with fluid.dygraph.guard():
+        mlp_load = MLP('mlp')
+        optimizer_load2 = SGDOptimizer(
+                learning_rate=fluid.layers.natural_exp_decay(
+                learning_rate=0.1,
+                decay_steps=10000,
+                decay_rate=0.5,
+                staircase=True))
+        parameters, optimizers = fluid.dygraph.load_persistables(
+            "save_dir_2")
+        mlp_load.load_dict(parameters)
+        optimizer_load2.load(optimizers)
+    self.assertTrue(optimizer2._learning_rate.__dict__ == optimizer_load2._learning_rate.__dict__)
+
+
+.. py:method:: minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)
+
+
+通过更新parameter_list来添加操作，进而使损失最小化。
+
+该算子相当于backward()和apply_gradients()功能的合体。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **parameter_list** (list) – 待更新的Variables组成的列表
+    - **no_grad_set** (set|None) – 应该被无视的Variables集合
+    - **grad_clip** (GradClipBase|None) – 梯度裁剪的策略
+
+返回： (optimize_ops, params_grads)，分别为附加的算子列表；一个由(param, grad) 变量对组成的列表，用于优化
+
+返回类型：   tuple
 

doc/fluid/api_cn/optimizer_cn/FtrlOptimizer_cn.rst

@@ -74,4 +74,157 @@ FTRL 原始论文: ( `https://www.eecs.tufts.edu/~dsculley/papers/ad-click-predi
 
 
 
+.. py:method:: apply_gradients(params_grads)
+
+为给定的params_grads对附加优化算子，为minimize过程的第二步
+
+参数：
+    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    loss = network()
+    optimizer = fluid.optimizer.SGD(learning_rate=0.1)
+    params_grads = optimizer.backward(loss)
+    # you may append operations for params_grads here
+    # ...
+    optimizer.apply_gradients(params_grads)
+
+
+.. py:method:: apply_optimize(loss, startup_program, params_grads)
+
+为给定的params_grads对附加优化算子，为minimize过程的第二步。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+.. py:method:: backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)
+
+自动做diff来向当前program附加反向算子，为minimize过程的第一步。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **parameter_list** (list) – 待更新的Variables组成的列表
+    - **no_grad_set** (set|None) – 应该被无视的Variables集合
+    - **callbacks** (list|None) – 当为某参数附加反向算子时所要运行的callables组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+**代码示例**
+
+详见apply_gradients的示例
+
+
+.. py:method:: load(stat_dict)
+
+在dygraph模式下，附带学习率衰减来加载优化器。
+
+参数：
+    - **stat_dict** – load_persistable方法加载的dict
+
+**代码示例**
+
+.. code-block:: python
+
+    from __future__ import print_function
+    import numpy as np
+    import paddle
+    import paddle.fluid as fluid
+    from paddle.fluid.optimizer import SGDOptimizer
+    from paddle.fluid.dygraph.nn import FC
+    from paddle.fluid.dygraph.base import to_variable
+
+    class MLP(fluid.Layer):
+        def __init__(self, name_scope):
+            super(MLP, self).__init__(name_scope)
+
+            self._fc1 = FC(self.full_name(), 10)
+            self._fc2 = FC(self.full_name(), 10)
+
+        def forward(self, inputs):
+            y = self._fc1(inputs)
+            y = self._fc2(y)
+            return y
+
+    with fluid.dygraph.guard():
+        mlp = MLP('mlp')
+        optimizer2 = SGDOptimizer(
+            learning_rate=fluid.layers.natural_exp_decay(
+            learning_rate=0.1,
+            decay_steps=10000,
+            decay_rate=0.5,
+            staircase=True))
+
+        train_reader = paddle.batch(
+                paddle.dataset.mnist.train(), batch_size=128, drop_last=True)
+
+        for batch_id, data in enumerate(train_reader()):
+            dy_x_data = np.array(
+                    [x[0].reshape(1, 28, 28) for x in data]).astype('float32')
+
+            y_data = np.array([x[1] for x in data]).astype('int64').reshape(
+                    128, 1)
+
+            img = to_variable(dy_x_data)
+            label = to_variable(y_data)
+            label._stop_gradient = True
+            cost = mlp(img)
+            avg_loss = fluid.layers.reduce_mean(cost)
+            avg_loss.backward()
+            optimizer.minimize(avg_loss)
+            mlp.clear_gradients()
+            fluid.dygraph.save_persistables(
+                    mlp.state_dict(), [optimizer, optimizer2], "save_dir_2")
+            if batch_id == 2:
+                    break
+
+    with fluid.dygraph.guard():
+        mlp_load = MLP('mlp')
+        optimizer_load2 = SGDOptimizer(
+                learning_rate=fluid.layers.natural_exp_decay(
+                learning_rate=0.1,
+                decay_steps=10000,
+                decay_rate=0.5,
+                staircase=True))
+        parameters, optimizers = fluid.dygraph.load_persistables(
+            "save_dir_2")
+        mlp_load.load_dict(parameters)
+        optimizer_load2.load(optimizers)
+    self.assertTrue(optimizer2._learning_rate.__dict__ == optimizer_load2._learning_rate.__dict__)
+
+
+.. py:method:: minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)
+
+
+通过更新parameter_list来添加操作，进而使损失最小化。
+
+该算子相当于backward()和apply_gradients()功能的合体。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **parameter_list** (list) – 待更新的Variables组成的列表
+    - **no_grad_set** (set|None) – 应该被无视的Variables集合
+    - **grad_clip** (GradClipBase|None) – 梯度裁剪的策略
+
+返回： (optimize_ops, params_grads)，分别为附加的算子列表；一个由(param, grad) 变量对组成的列表，用于优化
+
+返回类型：   tuple
+
 

doc/fluid/api_cn/optimizer_cn/LambOptimizer_cn.rst

@@ -44,4 +44,155 @@ Deep Learning: Training BERT in 76 minutes <https://arxiv.org/pdf/1904.00962.pdf
     optimizer.minimize(cost)
 
 
+.. py:method:: apply_gradients(params_grads)
 
+为给定的params_grads对附加优化算子，为minimize过程的第二步
+
+参数：
+    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    loss = network()
+    optimizer = fluid.optimizer.SGD(learning_rate=0.1)
+    params_grads = optimizer.backward(loss)
+    # you may append operations for params_grads here
+    # ...
+    optimizer.apply_gradients(params_grads)
+
+
+.. py:method:: apply_optimize(loss, startup_program, params_grads)
+
+为给定的params_grads对附加优化算子，为minimize过程的第二步。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+.. py:method:: backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)
+
+自动做diff来向当前program附加反向算子，为minimize过程的第一步。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **parameter_list** (list) – 待更新的Variables组成的列表
+    - **no_grad_set** (set|None) – 应该被无视的Variables集合
+    - **callbacks** (list|None) – 当为某参数附加反向算子时所要运行的callables组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+**代码示例**
+
+详见apply_gradients的示例
+
+
+.. py:method:: load(stat_dict)
+
+在dygraph模式下，附带学习率衰减来加载优化器。
+
+参数：
+    - **stat_dict** – load_persistable方法加载的dict
+
+**代码示例**
+
+.. code-block:: python
+
+    from __future__ import print_function
+    import numpy as np
+    import paddle
+    import paddle.fluid as fluid
+    from paddle.fluid.optimizer import SGDOptimizer
+    from paddle.fluid.dygraph.nn import FC
+    from paddle.fluid.dygraph.base import to_variable
+
+    class MLP(fluid.Layer):
+        def __init__(self, name_scope):
+            super(MLP, self).__init__(name_scope)
+
+            self._fc1 = FC(self.full_name(), 10)
+            self._fc2 = FC(self.full_name(), 10)
+
+        def forward(self, inputs):
+            y = self._fc1(inputs)
+            y = self._fc2(y)
+            return y
+
+    with fluid.dygraph.guard():
+        mlp = MLP('mlp')
+        optimizer2 = SGDOptimizer(
+            learning_rate=fluid.layers.natural_exp_decay(
+            learning_rate=0.1,
+            decay_steps=10000,
+            decay_rate=0.5,
+            staircase=True))
+
+        train_reader = paddle.batch(
+                paddle.dataset.mnist.train(), batch_size=128, drop_last=True)
+
+        for batch_id, data in enumerate(train_reader()):
+            dy_x_data = np.array(
+                    [x[0].reshape(1, 28, 28) for x in data]).astype('float32')
+
+            y_data = np.array([x[1] for x in data]).astype('int64').reshape(
+                    128, 1)
+
+            img = to_variable(dy_x_data)
+            label = to_variable(y_data)
+            label._stop_gradient = True
+            cost = mlp(img)
+            avg_loss = fluid.layers.reduce_mean(cost)
+            avg_loss.backward()
+            optimizer.minimize(avg_loss)
+            mlp.clear_gradients()
+            fluid.dygraph.save_persistables(
+                    mlp.state_dict(), [optimizer, optimizer2], "save_dir_2")
+            if batch_id == 2:
+                    break
+
+    with fluid.dygraph.guard():
+        mlp_load = MLP('mlp')
+        optimizer_load2 = SGDOptimizer(
+                learning_rate=fluid.layers.natural_exp_decay(
+                learning_rate=0.1,
+                decay_steps=10000,
+                decay_rate=0.5,
+                staircase=True))
+        parameters, optimizers = fluid.dygraph.load_persistables(
+            "save_dir_2")
+        mlp_load.load_dict(parameters)
+        optimizer_load2.load(optimizers)
+    self.assertTrue(optimizer2._learning_rate.__dict__ == optimizer_load2._learning_rate.__dict__)
+
+
+.. py:method:: minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)
+
+
+通过更新parameter_list来添加操作，进而使损失最小化。
+
+该算子相当于backward()和apply_gradients()功能的合体。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **parameter_list** (list) – 待更新的Variables组成的列表
+    - **no_grad_set** (set|None) – 应该被无视的Variables集合
+    - **grad_clip** (GradClipBase|None) – 梯度裁剪的策略
+
+返回： (optimize_ops, params_grads)，分别为附加的算子列表；一个由(param, grad) 变量对组成的列表，用于优化
+
+返回类型：   tuple

doc/fluid/api_cn/optimizer_cn/LarsMomentumOptimizer_cn.rst

@@ -24,7 +24,7 @@ LARS支持的Momentum优化器
   - **regularization** - 正则化函数，例如 :code:`fluid.regularizer.L2DecayRegularizer`
   - **name** - 名称前缀，可选
 
-**代码示例：**
+**代码示例**
 
 .. code-block:: python
 
@@ -32,7 +32,158 @@ LARS支持的Momentum优化器
     optimizer = fluid.optimizer.LarsMomentum(learning_rate=0.2, momentum=0.1, lars_weight_decay=0.001)
     optimizer.minimize(cost)
 
+.. py:method:: apply_gradients(params_grads)
 
+为给定的params_grads对附加优化算子，为minimize过程的第二步
+
+参数：
+    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    loss = network()
+    optimizer = fluid.optimizer.SGD(learning_rate=0.1)
+    params_grads = optimizer.backward(loss)
+    # you may append operations for params_grads here
+    # ...
+    optimizer.apply_gradients(params_grads)
+
+
+.. py:method:: apply_optimize(loss, startup_program, params_grads)
+
+为给定的params_grads对附加优化算子，为minimize过程的第二步。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+.. py:method:: backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)
+
+自动做diff来向当前program附加反向算子，为minimize过程的第一步。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **parameter_list** (list) – 待更新的Variables组成的列表
+    - **no_grad_set** (set|None) – 应该被无视的Variables集合
+    - **callbacks** (list|None) – 当为某参数附加反向算子时所要运行的callables组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+**代码示例**
+
+详见apply_gradients的示例
+
+
+.. py:method:: load(stat_dict)
+
+在dygraph模式下，附带学习率衰减来加载优化器。
+
+参数：
+    - **stat_dict** – load_persistable方法加载的dict
+
+**代码示例**
+
+.. code-block:: python
+
+    from __future__ import print_function
+    import numpy as np
+    import paddle
+    import paddle.fluid as fluid
+    from paddle.fluid.optimizer import SGDOptimizer
+    from paddle.fluid.dygraph.nn import FC
+    from paddle.fluid.dygraph.base import to_variable
+
+    class MLP(fluid.Layer):
+        def __init__(self, name_scope):
+            super(MLP, self).__init__(name_scope)
+
+            self._fc1 = FC(self.full_name(), 10)
+            self._fc2 = FC(self.full_name(), 10)
+
+        def forward(self, inputs):
+            y = self._fc1(inputs)
+            y = self._fc2(y)
+            return y
+
+    with fluid.dygraph.guard():
+        mlp = MLP('mlp')
+        optimizer2 = SGDOptimizer(
+            learning_rate=fluid.layers.natural_exp_decay(
+            learning_rate=0.1,
+            decay_steps=10000,
+            decay_rate=0.5,
+            staircase=True))
+
+        train_reader = paddle.batch(
+                paddle.dataset.mnist.train(), batch_size=128, drop_last=True)
+
+        for batch_id, data in enumerate(train_reader()):
+            dy_x_data = np.array(
+                    [x[0].reshape(1, 28, 28) for x in data]).astype('float32')
+
+            y_data = np.array([x[1] for x in data]).astype('int64').reshape(
+                    128, 1)
+
+            img = to_variable(dy_x_data)
+            label = to_variable(y_data)
+            label._stop_gradient = True
+            cost = mlp(img)
+            avg_loss = fluid.layers.reduce_mean(cost)
+            avg_loss.backward()
+            optimizer.minimize(avg_loss)
+            mlp.clear_gradients()
+            fluid.dygraph.save_persistables(
+                    mlp.state_dict(), [optimizer, optimizer2], "save_dir_2")
+            if batch_id == 2:
+                    break
+
+    with fluid.dygraph.guard():
+        mlp_load = MLP('mlp')
+        optimizer_load2 = SGDOptimizer(
+                learning_rate=fluid.layers.natural_exp_decay(
+                learning_rate=0.1,
+                decay_steps=10000,
+                decay_rate=0.5,
+                staircase=True))
+        parameters, optimizers = fluid.dygraph.load_persistables(
+            "save_dir_2")
+        mlp_load.load_dict(parameters)
+        optimizer_load2.load(optimizers)
+    self.assertTrue(optimizer2._learning_rate.__dict__ == optimizer_load2._learning_rate.__dict__)
+
+
+.. py:method:: minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)
+
+
+通过更新parameter_list来添加操作，进而使损失最小化。
+
+该算子相当于backward()和apply_gradients()功能的合体。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **parameter_list** (list) – 待更新的Variables组成的列表
+    - **no_grad_set** (set|None) – 应该被无视的Variables集合
+    - **grad_clip** (GradClipBase|None) – 梯度裁剪的策略
+
+返回： (optimize_ops, params_grads)，分别为附加的算子列表；一个由(param, grad) 变量对组成的列表，用于优化
+
+返回类型：   tuple
 
 
 

doc/fluid/api_cn/optimizer_cn/ModelAverage_cn.rst

@@ -72,7 +72,158 @@ ModelAverage
     - **executor** (fluid.Executor) – 当前的执行引擎。
 
 
+.. py:method:: apply_gradients(params_grads)
 
+为给定的params_grads对附加优化算子，为minimize过程的第二步
+
+参数：
+    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    loss = network()
+    optimizer = fluid.optimizer.SGD(learning_rate=0.1)
+    params_grads = optimizer.backward(loss)
+    # you may append operations for params_grads here
+    # ...
+    optimizer.apply_gradients(params_grads)
+
+
+.. py:method:: apply_optimize(loss, startup_program, params_grads)
+
+为给定的params_grads对附加优化算子，为minimize过程的第二步。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+.. py:method:: backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)
+
+自动做diff来向当前program附加反向算子，为minimize过程的第一步。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **parameter_list** (list) – 待更新的Variables组成的列表
+    - **no_grad_set** (set|None) – 应该被无视的Variables集合
+    - **callbacks** (list|None) – 当为某参数附加反向算子时所要运行的callables组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+**代码示例**
+
+详见apply_gradients的示例
+
+
+.. py:method:: load(stat_dict)
+
+在dygraph模式下，附带学习率衰减来加载优化器。
+
+参数：
+    - **stat_dict** – load_persistable方法加载的dict
+
+**代码示例**
+
+.. code-block:: python
+
+    from __future__ import print_function
+    import numpy as np
+    import paddle
+    import paddle.fluid as fluid
+    from paddle.fluid.optimizer import SGDOptimizer
+    from paddle.fluid.dygraph.nn import FC
+    from paddle.fluid.dygraph.base import to_variable
+
+    class MLP(fluid.Layer):
+        def __init__(self, name_scope):
+            super(MLP, self).__init__(name_scope)
+
+            self._fc1 = FC(self.full_name(), 10)
+            self._fc2 = FC(self.full_name(), 10)
+
+        def forward(self, inputs):
+            y = self._fc1(inputs)
+            y = self._fc2(y)
+            return y
+
+    with fluid.dygraph.guard():
+        mlp = MLP('mlp')
+        optimizer2 = SGDOptimizer(
+            learning_rate=fluid.layers.natural_exp_decay(
+            learning_rate=0.1,
+            decay_steps=10000,
+            decay_rate=0.5,
+            staircase=True))
+
+        train_reader = paddle.batch(
+                paddle.dataset.mnist.train(), batch_size=128, drop_last=True)
+
+        for batch_id, data in enumerate(train_reader()):
+            dy_x_data = np.array(
+                    [x[0].reshape(1, 28, 28) for x in data]).astype('float32')
+
+            y_data = np.array([x[1] for x in data]).astype('int64').reshape(
+                    128, 1)
+
+            img = to_variable(dy_x_data)
+            label = to_variable(y_data)
+            label._stop_gradient = True
+            cost = mlp(img)
+            avg_loss = fluid.layers.reduce_mean(cost)
+            avg_loss.backward()
+            optimizer.minimize(avg_loss)
+            mlp.clear_gradients()
+            fluid.dygraph.save_persistables(
+                    mlp.state_dict(), [optimizer, optimizer2], "save_dir_2")
+            if batch_id == 2:
+                    break
+
+    with fluid.dygraph.guard():
+        mlp_load = MLP('mlp')
+        optimizer_load2 = SGDOptimizer(
+                learning_rate=fluid.layers.natural_exp_decay(
+                learning_rate=0.1,
+                decay_steps=10000,
+                decay_rate=0.5,
+                staircase=True))
+        parameters, optimizers = fluid.dygraph.load_persistables(
+            "save_dir_2")
+        mlp_load.load_dict(parameters)
+        optimizer_load2.load(optimizers)
+    self.assertTrue(optimizer2._learning_rate.__dict__ == optimizer_load2._learning_rate.__dict__)
+
+
+.. py:method:: minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)
+
+
+通过更新parameter_list来添加操作，进而使损失最小化。
+
+该算子相当于backward()和apply_gradients()功能的合体。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **parameter_list** (list) – 待更新的Variables组成的列表
+    - **no_grad_set** (set|None) – 应该被无视的Variables集合
+    - **grad_clip** (GradClipBase|None) – 梯度裁剪的策略
+
+返回： (optimize_ops, params_grads)，分别为附加的算子列表；一个由(param, grad) 变量对组成的列表，用于优化
+
+返回类型：   tuple
 
 
 

doc/fluid/api_cn/optimizer_cn/MomentumOptimizer_cn.rst

@@ -17,10 +17,10 @@ MomentumOptimizer
 
 参数：
     - **learning_rate** (float|Variable) - 学习率，用于参数更新。作为数据参数，可以是浮点型值或含有一个浮点型值的变量
-    - **momentum** (float) - 动量因子
+    - **momentum** (float) - 动量因子
     - **use_nesterov** (bool) - 赋能牛顿动量
-    - **regularization** - 正则化函数，比如fluid.regularizer.L2DecayRegularizer
-    - **name** - 名称前缀（可选）
+    - **regularization** - 正则化函数，比如fluid.regularizer.L2DecayRegularizer
+    - **name** - 名称前缀（可选）
 
 **代码示例**：
 
@@ -51,7 +51,158 @@ MomentumOptimizer
         for data in train_reader():
             exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list)
 
+.. py:method:: apply_gradients(params_grads)
 
+为给定的params_grads对附加优化算子，为minimize过程的第二步
+
+参数：
+    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    loss = network()
+    optimizer = fluid.optimizer.SGD(learning_rate=0.1)
+    params_grads = optimizer.backward(loss)
+    # you may append operations for params_grads here
+    # ...
+    optimizer.apply_gradients(params_grads)
+
+
+.. py:method:: apply_optimize(loss, startup_program, params_grads)
+
+为给定的params_grads对附加优化算子，为minimize过程的第二步。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+.. py:method:: backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)
+
+自动做diff来向当前program附加反向算子，为minimize过程的第一步。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **parameter_list** (list) – 待更新的Variables组成的列表
+    - **no_grad_set** (set|None) – 应该被无视的Variables集合
+    - **callbacks** (list|None) – 当为某参数附加反向算子时所要运行的callables组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+**代码示例**
+
+详见apply_gradients的示例
+
+
+.. py:method:: load(stat_dict)
+
+在dygraph模式下，附带学习率衰减来加载优化器。
+
+参数：
+    - **stat_dict** – load_persistable方法加载的dict
+
+**代码示例**
+
+.. code-block:: python
+
+    from __future__ import print_function
+    import numpy as np
+    import paddle
+    import paddle.fluid as fluid
+    from paddle.fluid.optimizer import SGDOptimizer
+    from paddle.fluid.dygraph.nn import FC
+    from paddle.fluid.dygraph.base import to_variable
+
+    class MLP(fluid.Layer):
+        def __init__(self, name_scope):
+            super(MLP, self).__init__(name_scope)
+
+            self._fc1 = FC(self.full_name(), 10)
+            self._fc2 = FC(self.full_name(), 10)
+
+        def forward(self, inputs):
+            y = self._fc1(inputs)
+            y = self._fc2(y)
+            return y
+
+    with fluid.dygraph.guard():
+        mlp = MLP('mlp')
+        optimizer2 = SGDOptimizer(
+            learning_rate=fluid.layers.natural_exp_decay(
+            learning_rate=0.1,
+            decay_steps=10000,
+            decay_rate=0.5,
+            staircase=True))
+
+        train_reader = paddle.batch(
+                paddle.dataset.mnist.train(), batch_size=128, drop_last=True)
+
+        for batch_id, data in enumerate(train_reader()):
+            dy_x_data = np.array(
+                    [x[0].reshape(1, 28, 28) for x in data]).astype('float32')
+
+            y_data = np.array([x[1] for x in data]).astype('int64').reshape(
+                    128, 1)
+
+            img = to_variable(dy_x_data)
+            label = to_variable(y_data)
+            label._stop_gradient = True
+            cost = mlp(img)
+            avg_loss = fluid.layers.reduce_mean(cost)
+            avg_loss.backward()
+            optimizer.minimize(avg_loss)
+            mlp.clear_gradients()
+            fluid.dygraph.save_persistables(
+                    mlp.state_dict(), [optimizer, optimizer2], "save_dir_2")
+            if batch_id == 2:
+                    break
+
+    with fluid.dygraph.guard():
+        mlp_load = MLP('mlp')
+        optimizer_load2 = SGDOptimizer(
+                learning_rate=fluid.layers.natural_exp_decay(
+                learning_rate=0.1,
+                decay_steps=10000,
+                decay_rate=0.5,
+                staircase=True))
+        parameters, optimizers = fluid.dygraph.load_persistables(
+            "save_dir_2")
+        mlp_load.load_dict(parameters)
+        optimizer_load2.load(optimizers)
+    self.assertTrue(optimizer2._learning_rate.__dict__ == optimizer_load2._learning_rate.__dict__)
+
+
+.. py:method:: minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)
+
+
+通过更新parameter_list来添加操作，进而使损失最小化。
+
+该算子相当于backward()和apply_gradients()功能的合体。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **parameter_list** (list) – 待更新的Variables组成的列表
+    - **no_grad_set** (set|None) – 应该被无视的Variables集合
+    - **grad_clip** (GradClipBase|None) – 梯度裁剪的策略
+
+返回： (optimize_ops, params_grads)，分别为附加的算子列表；一个由(param, grad) 变量对组成的列表，用于优化
+
+返回类型：   tuple
 
 
 

doc/fluid/api_cn/optimizer_cn/RMSPropOptimizer_cn.rst

@@ -69,7 +69,158 @@ RMSPropOptimizer
         for data in train_reader():
             exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list)
 
+.. py:method:: apply_gradients(params_grads)
 
+为给定的params_grads对附加优化算子，为minimize过程的第二步
+
+参数：
+    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    loss = network()
+    optimizer = fluid.optimizer.SGD(learning_rate=0.1)
+    params_grads = optimizer.backward(loss)
+    # you may append operations for params_grads here
+    # ...
+    optimizer.apply_gradients(params_grads)
+
+
+.. py:method:: apply_optimize(loss, startup_program, params_grads)
+
+为给定的params_grads对附加优化算子，为minimize过程的第二步。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+.. py:method:: backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)
+
+自动做diff来向当前program附加反向算子，为minimize过程的第一步。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **parameter_list** (list) – 待更新的Variables组成的列表
+    - **no_grad_set** (set|None) – 应该被无视的Variables集合
+    - **callbacks** (list|None) – 当为某参数附加反向算子时所要运行的callables组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+**代码示例**
+
+详见apply_gradients的示例
+
+
+.. py:method:: load(stat_dict)
+
+在dygraph模式下，附带学习率衰减来加载优化器。
+
+参数：
+    - **stat_dict** – load_persistable方法加载的dict
+
+**代码示例**
+
+.. code-block:: python
+
+    from __future__ import print_function
+    import numpy as np
+    import paddle
+    import paddle.fluid as fluid
+    from paddle.fluid.optimizer import SGDOptimizer
+    from paddle.fluid.dygraph.nn import FC
+    from paddle.fluid.dygraph.base import to_variable
+
+    class MLP(fluid.Layer):
+        def __init__(self, name_scope):
+            super(MLP, self).__init__(name_scope)
+
+            self._fc1 = FC(self.full_name(), 10)
+            self._fc2 = FC(self.full_name(), 10)
+
+        def forward(self, inputs):
+            y = self._fc1(inputs)
+            y = self._fc2(y)
+            return y
+
+    with fluid.dygraph.guard():
+        mlp = MLP('mlp')
+        optimizer2 = SGDOptimizer(
+            learning_rate=fluid.layers.natural_exp_decay(
+            learning_rate=0.1,
+            decay_steps=10000,
+            decay_rate=0.5,
+            staircase=True))
+
+        train_reader = paddle.batch(
+                paddle.dataset.mnist.train(), batch_size=128, drop_last=True)
+
+        for batch_id, data in enumerate(train_reader()):
+            dy_x_data = np.array(
+                    [x[0].reshape(1, 28, 28) for x in data]).astype('float32')
+
+            y_data = np.array([x[1] for x in data]).astype('int64').reshape(
+                    128, 1)
+
+            img = to_variable(dy_x_data)
+            label = to_variable(y_data)
+            label._stop_gradient = True
+            cost = mlp(img)
+            avg_loss = fluid.layers.reduce_mean(cost)
+            avg_loss.backward()
+            optimizer.minimize(avg_loss)
+            mlp.clear_gradients()
+            fluid.dygraph.save_persistables(
+                    mlp.state_dict(), [optimizer, optimizer2], "save_dir_2")
+            if batch_id == 2:
+                    break
+
+    with fluid.dygraph.guard():
+        mlp_load = MLP('mlp')
+        optimizer_load2 = SGDOptimizer(
+                learning_rate=fluid.layers.natural_exp_decay(
+                learning_rate=0.1,
+                decay_steps=10000,
+                decay_rate=0.5,
+                staircase=True))
+        parameters, optimizers = fluid.dygraph.load_persistables(
+            "save_dir_2")
+        mlp_load.load_dict(parameters)
+        optimizer_load2.load(optimizers)
+    self.assertTrue(optimizer2._learning_rate.__dict__ == optimizer_load2._learning_rate.__dict__)
+
+
+.. py:method:: minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)
+
+
+通过更新parameter_list来添加操作，进而使损失最小化。
+
+该算子相当于backward()和apply_gradients()功能的合体。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **parameter_list** (list) – 待更新的Variables组成的列表
+    - **no_grad_set** (set|None) – 应该被无视的Variables集合
+    - **grad_clip** (GradClipBase|None) – 梯度裁剪的策略
+
+返回： (optimize_ops, params_grads)，分别为附加的算子列表；一个由(param, grad) 变量对组成的列表，用于优化
+
+返回类型：   tuple
 
 
 

doc/fluid/api_cn/optimizer_cn/SGDOptimizer_cn.rst

@@ -47,9 +47,158 @@ SGDOptimizer
             exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list)
 
 
+.. py:method:: apply_gradients(params_grads)
 
+为给定的params_grads对附加优化算子，为minimize过程的第二步
 
+参数：
+    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
 
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    loss = network()
+    optimizer = fluid.optimizer.SGD(learning_rate=0.1)
+    params_grads = optimizer.backward(loss)
+    # you may append operations for params_grads here
+    # ...
+    optimizer.apply_gradients(params_grads)
+
+
+.. py:method:: apply_optimize(loss, startup_program, params_grads)
+
+为给定的params_grads对附加优化算子，为minimize过程的第二步。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+.. py:method:: backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)
+
+自动做diff来向当前program附加反向算子，为minimize过程的第一步。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **parameter_list** (list) – 待更新的Variables组成的列表
+    - **no_grad_set** (set|None) – 应该被无视的Variables集合
+    - **callbacks** (list|None) – 当为某参数附加反向算子时所要运行的callables组成的列表
+
+返回：  附加在当前Program的算子组成的列表
+
+返回类型：  list
+
+**代码示例**
+
+详见apply_gradients的示例
+
+
+.. py:method:: load(stat_dict)
+
+在dygraph模式下，附带学习率衰减来加载优化器。
+
+参数：
+    - **stat_dict** – load_persistable方法加载的dict
+
+**代码示例**
+
+.. code-block:: python
+
+    from __future__ import print_function
+    import numpy as np
+    import paddle
+    import paddle.fluid as fluid
+    from paddle.fluid.optimizer import SGDOptimizer
+    from paddle.fluid.dygraph.nn import FC
+    from paddle.fluid.dygraph.base import to_variable
+
+    class MLP(fluid.Layer):
+        def __init__(self, name_scope):
+            super(MLP, self).__init__(name_scope)
+
+            self._fc1 = FC(self.full_name(), 10)
+            self._fc2 = FC(self.full_name(), 10)
+
+        def forward(self, inputs):
+            y = self._fc1(inputs)
+            y = self._fc2(y)
+            return y
+
+    with fluid.dygraph.guard():
+        mlp = MLP('mlp')
+        optimizer2 = SGDOptimizer(
+            learning_rate=fluid.layers.natural_exp_decay(
+            learning_rate=0.1,
+            decay_steps=10000,
+            decay_rate=0.5,
+            staircase=True))
+
+        train_reader = paddle.batch(
+                paddle.dataset.mnist.train(), batch_size=128, drop_last=True)
+
+        for batch_id, data in enumerate(train_reader()):
+            dy_x_data = np.array(
+                    [x[0].reshape(1, 28, 28) for x in data]).astype('float32')
+
+            y_data = np.array([x[1] for x in data]).astype('int64').reshape(
+                    128, 1)
+
+            img = to_variable(dy_x_data)
+            label = to_variable(y_data)
+            label._stop_gradient = True
+            cost = mlp(img)
+            avg_loss = fluid.layers.reduce_mean(cost)
+            avg_loss.backward()
+            optimizer.minimize(avg_loss)
+            mlp.clear_gradients()
+            fluid.dygraph.save_persistables(
+                    mlp.state_dict(), [optimizer, optimizer2], "save_dir_2")
+            if batch_id == 2:
+                    break
+
+    with fluid.dygraph.guard():
+        mlp_load = MLP('mlp')
+        optimizer_load2 = SGDOptimizer(
+                learning_rate=fluid.layers.natural_exp_decay(
+                learning_rate=0.1,
+                decay_steps=10000,
+                decay_rate=0.5,
+                staircase=True))
+        parameters, optimizers = fluid.dygraph.load_persistables(
+            "save_dir_2")
+        mlp_load.load_dict(parameters)
+        optimizer_load2.load(optimizers)
+    self.assertTrue(optimizer2._learning_rate.__dict__ == optimizer_load2._learning_rate.__dict__)
+
+
+.. py:method:: minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)
+
+
+通过更新parameter_list来添加操作，进而使损失最小化。
+
+该算子相当于backward()和apply_gradients()功能的合体。
+
+参数：
+    - **loss** (Variable) – 用于优化过程的损失值变量
+    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
+    - **parameter_list** (list) – 待更新的Variables组成的列表
+    - **no_grad_set** (set|None) – 应该被无视的Variables集合
+    - **grad_clip** (GradClipBase|None) – 梯度裁剪的策略
+
+返回： (optimize_ops, params_grads)，分别为附加的算子列表；一个由(param, grad) 变量对组成的列表，用于优化
+
+返回类型：   tuple