update optimizer_cn to release 1.5 (#1063)

doc/fluid/api_cn/layers_cn/control_flow_cn.rst

@@ -748,7 +748,7 @@ StaticRNN
 
 StaticRNN可以处理一批序列数据。每个样本序列的长度必须相等。StaticRNN将拥有自己的参数，如输入、输出和存储器等。请注意，输入的第一个维度表示序列长度，且输入的所有序列长度必须相同。并且输入和输出的每个轴的含义是相同的。
 
-**代码示例**：
+**代码示例**
 
 .. code-block:: python
 
@@ -787,84 +787,84 @@ StaticRNN可以将多个变量标记为其输出。使用rnn()获取输出序列
 
 
 .. 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变量。
-
-  参数：
-    - **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轴
 
-  返回：内存变量
+为静态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轴
 
-  **代码示例**：
+返回：内存变量
 
-  .. 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.rst

@@ -54,9 +54,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
@@ -75,6 +75,158 @@ 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
 
 
 
@@ -133,9 +285,9 @@ Adamax 更新规则:
 
 论文中没有 ``epsilon`` 参数。但是，为了数值稳定性， 防止除0错误， 增加了这个参数
 
-**代码示例**：
+**代码示例**
 
-.. code-block:: python:
+.. code-block:: python
 
     import paddle.fluid as fluid
     import numpy
@@ -173,6 +325,158 @@ Adamax 更新规则:
     目前 ``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
 
 
 
@@ -207,9 +511,9 @@ Adam更新如下：
     - **lazy_mode** （bool: false） - 官方Adam算法有两个移动平均累加器（moving-average accumulators）。累加器在每一步都会更新。在密集模式和稀疏模式下，两条移动平均线的每个元素都会更新。如果参数非常大，那么更新可能很慢。 lazy mode仅更新当前具有梯度的元素，所以它会更快。但是这种模式与原始的算法有不同的描述，可能会导致不同的结果。
 
 
-**代码示例**：
+**代码示例**
 
-.. code-block:: python:
+.. code-block:: python
 
     import paddle
     import paddle.fluid as fluid
@@ -234,6 +538,158 @@ Adam更新如下：
         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
 
 
 
@@ -297,6 +753,158 @@ Decayed Adagrad Optimizer
 .. note::
   当前， ``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
 
 
 
@@ -348,6 +956,158 @@ DGC还使用动量因子掩藏(momentum factor masking)和预训练(warm-up)来
                                         rampup_begin_step=1252,
                                         sparsity=[0.999, 0.999])
 
+.. 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
 
 
 .. _cn_api_fluid_optimizer_ExponentialMovingAverage:
@@ -539,29 +1299,181 @@ FTRL 原始论文: ( `https://www.eecs.tufts.edu/~dsculley/papers/ad-click-predi
 .. note::
      目前, FtrlOptimizer 不支持 sparse parameter optimization
 
+.. py:method:: apply_gradients(params_grads)
+
+为给定的params_grads对附加优化算子，为minimize过程的第二步
 
+参数：
+    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
 
+返回：  附加在当前Program的算子组成的列表
 
-.. _cn_api_fluid_optimizer_LambOptimizer:
+返回类型：  list
 
-LambOptimizer
--------------------------------
+**代码示例**
 
-.. py:class:: paddle.fluid.optimizer.LambOptimizer(learning_rate=0.001, lamb_weight_decay=0.01, beta1=0.9, beta2=0.999, epsilon=1e-06, regularization=None, exclude_from_weight_decay_fn=None, name=None)
+.. code-block:: python
 
-LAMB（Layer-wise Adaptive Moments optimizer for Batching training）优化器
-LAMB优化器旨在不降低准确性的条件下扩大训练的批量大小，支持自适应元素更新和精确的分层校正。 更多信息请参考 `Large Batch Optimization for
-Deep Learning: Training BERT in 76 minutes <https://arxiv.org/pdf/1904.00962.pdf>`_ 。
-参数更新如下：
+    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)
 
-.. math::
 
-    \begin{align}\begin{aligned}m_t &= \beta_1 m_{t - 1}+ (1 - \beta_1)g_t \\\v_t &= \beta_2 v_{t - 1}  + (1 - \beta_2)g_t^2 \\\r_t &= \frac{m_t}{\sqrt{v_t}+\epsilon} \\\w_t &= w_{t-1} -\eta_t \frac{\left \| w_{t-1}\right \|}{\left \| r_t + \lambda w_{t-1}\right \|} (r_t + \lambda w_{t-1})\end{aligned}\end{align}
+.. py:method:: apply_optimize(loss, startup_program, params_grads)
 
-其中 :math:`m` 为第一个时刻，:math:`v` 为第二个时刻，:math:`\eta` 为学习率，:math:`\lambda` 为LAMB权重衰减率。
+为给定的params_grads对附加优化算子，为minimize过程的第二步。
 
 参数：
-    - **learning_rate** (float|Variable) – 用于更新参数的学习速率。可以是浮点值或具有一个作为数据元素的浮点值的变量。
+    - **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
+
+
+
+.. _cn_api_fluid_optimizer_LambOptimizer:
+
+LambOptimizer
+-------------------------------
+
+.. py:class:: paddle.fluid.optimizer.LambOptimizer(learning_rate=0.001, lamb_weight_decay=0.01, beta1=0.9, beta2=0.999, epsilon=1e-06, regularization=None, exclude_from_weight_decay_fn=None, name=None)
+
+LAMB（Layer-wise Adaptive Moments optimizer for Batching training）优化器
+LAMB优化器旨在不降低准确性的条件下扩大训练的批量大小，支持自适应元素更新和精确的分层校正。 更多信息请参考 `Large Batch Optimization for
+Deep Learning: Training BERT in 76 minutes <https://arxiv.org/pdf/1904.00962.pdf>`_ 。
+参数更新如下：
+
+.. math::
+
+    \begin{align}\begin{aligned}m_t &= \beta_1 m_{t - 1}+ (1 - \beta_1)g_t \\\v_t &= \beta_2 v_{t - 1}  + (1 - \beta_2)g_t^2 \\\r_t &= \frac{m_t}{\sqrt{v_t}+\epsilon} \\\w_t &= w_{t-1} -\eta_t \frac{\left \| w_{t-1}\right \|}{\left \| r_t + \lambda w_{t-1}\right \|} (r_t + \lambda w_{t-1})\end{aligned}\end{align}
+
+其中 :math:`m` 为第一个时刻，:math:`v` 为第二个时刻，:math:`\eta` 为学习率，:math:`\lambda` 为LAMB权重衰减率。
+
+参数：
+    - **learning_rate** (float|Variable) – 用于更新参数的学习速率。可以是浮点值或具有一个作为数据元素的浮点值的变量。
     - **lamb_weight_decay** (float) – LAMB权重衰减率。
     - **beta1** (float) – 第一个时刻估计的指数衰减率。
     - **beta2** (float) – 第二个时刻估计的指数衰减率。
@@ -587,6 +1499,158 @@ Deep Learning: Training BERT in 76 minutes <https://arxiv.org/pdf/1904.00962.pdf
                                      exclude_from_weight_decay_fn=exclude_fn)
     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
 
 
 .. _cn_api_fluid_optimizer_LarsMomentum:
@@ -636,6 +1700,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
 
 
 
@@ -715,6 +1931,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
 
 
 
@@ -784,6 +2152,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
 
 
 
@@ -927,6 +2447,158 @@ RMSPropOptimizer
 
 
 
+.. 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
 
 
 
@@ -998,6 +2670,158 @@ SGDOptimizer
 
 
 
+.. 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