Polish the Chinese API documentation of AdamOptimizer (#1213)

* polish adam optimizer zh api doc

* polish details

doc/fluid/api_cn/optimizer_cn/AdamOptimizer_cn.rst

@@ -5,8 +5,9 @@ AdamOptimizer
 
 .. py:class:: paddle.fluid.optimizer.AdamOptimizer(learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-08, regularization=None, name=None, lazy_mode=False)
 
-该函数实现了自适应矩估计优化器，介绍自 `Adam论文 <https://arxiv.org/abs/1412.6980>`_ 的第二节。Adam是一阶基于梯度下降的算法，基于自适应低阶矩估计。
-Adam更新如下：
+Adam优化器出自 `Adam论文 <https://arxiv.org/abs/1412.6980>`_ 的第二节，能够利用梯度的一阶矩估计和二阶矩估计动态调整每个参数的学习率。
+
+其参数更新的计算公式如下：
 
 .. math::
     \\t = t + 1
@@ -19,14 +20,16 @@ Adam更新如下：
 .. math::
     param\_out=param-learning\_rate*\frac{moment\_1}{\sqrt{moment\_2}+\epsilon}\\
 
+相关论文：`Adam: A Method for Stochastic Optimization <https://arxiv.org/abs/1412.6980>`_ 
+
 参数: 
-    - **learning_rate** (float|Variable)-学习率，用于更新参数。作为数据参数，可以是一个浮点类型值或有一个浮点类型值的变量
-    - **beta1** (float)-一阶矩估计的指数衰减率
-    - **beta2** (float)-二阶矩估计的指数衰减率
-    - **epsilon** (float)-保持数值稳定性的短浮点类型值
-    - **regularization** - 规则化函数，例如''fluid.regularizer.L2DecayRegularizer
-    - **name** - 可选名称前缀
-    - **lazy_mode** （bool: false） - 官方Adam算法有两个移动平均累加器（moving-average accumulators）。累加器在每一步都会更新。在密集模式和稀疏模式下，两条移动平均线的每个元素都会更新。如果参数非常大，那么更新可能很慢。 lazy mode仅更新当前具有梯度的元素，所以它会更快。但是这种模式与原始的算法有不同的描述，可能会导致不同的结果。
+    - **learning_rate** (float|Variable，可选) - 学习率，用于参数更新的计算。可以是一个浮点型值或者一个值为浮点型的Variable，默认值为0.001
+    - **beta1** (float, 可选) - 一阶矩估计的指数衰减率，默认值为0.9
+    - **beta2** (float, 可选) - 二阶矩估计的指数衰减率，默认值为0.999
+    - **epsilon** (float, 可选) - 保持数值稳定性的短浮点类型值，默认值为1e-08
+    - **regularization** (WeightDecayRegularizer, 可选) - 正则化函数，用于减少泛化误差。例如可以是 :ref:`cn_api_fluid_regularizer_L2DecayRegularizer` ，默认值为None
+    - **name** (str, 可选)- 该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` ，默认值为None
+    - **lazy_mode** （bool, 可选） - 设为True时，仅更新当前具有梯度的元素。官方Adam算法有两个移动平均累加器（moving-average accumulators）。累加器在每一步都会更新。在密集模式和稀疏模式下，两条移动平均线的每个元素都会更新。如果参数非常大，那么更新可能很慢。 lazy mode仅更新当前具有梯度的元素，所以它会更快。但是这种模式与原始的算法有不同的描述，可能会导致不同的结果，默认为False
 
 
 **代码示例**：
@@ -57,142 +60,6 @@ Adam更新如下：
             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中的Parameters，最小化网络损失值loss。