fixed some errors and added two links. (#1081)

* fixed one error

* fixed op error

* fixed five errors of api_cn.

* fixed one error of api_cn

* fixed some errors of api_cn

* fixed two links.

* fixed one link.

* fixed one error.

doc/fluid/api_cn/layers_cn/io_cn.rst

@@ -362,30 +362,33 @@ py_reader
 
   def network(image, label):
     # 用户自定义网络，此处以softmax回归为例
-    predict = fluid.layers.fc(input=image, size=10, act='softmax')
-  return fluid.layers.cross_entropy(input=predict, label=label)
+      predict = fluid.layers.fc(input=image, size=10, act='softmax')
+      return fluid.layers.cross_entropy(input=predict, label=label)
          
   reader = fluid.layers.py_reader(capacity=64,
-          shapes=[(-1,1, 28, 28), (-1,1)],
-          dtypes=['float32', 'int64'])
+                                  shapes=[(-1,1, 28, 28), (-1,1)],
+                                  dtypes=['float32', 'int64'])
   reader.decorate_paddle_reader(
-      paddle.reader.shuffle(paddle.batch(mnist.train(), batch_size=5),buf_size=1000))
+      paddle.reader.shuffle(paddle.batch(mnist.train(), batch_size=5),
+                            buf_size=1000))
 
   img, label = fluid.layers.read_file(reader)
   loss = network(img, label) # 一些网络定义
 
   fluid.Executor(fluid.CUDAPlace(0)).run(fluid.default_startup_program())
-
   exe = fluid.ParallelExecutor(use_cuda=True, loss_name=loss.name)
   for epoch_id in range(10):
       reader.start()
-      try:
-    while True:
-        exe.run(fetch_list=[loss.name])
-      except fluid.core.EOFException:
-    reader.reset()
+          try:
+              while True:
+                  exe.run(fetch_list=[loss.name])
+          except fluid.core.EOFException:
+              reader.reset()
 
-    fluid.io.save_inference_model(dirname='./model', feeded_var_names=[img.name, label.name],target_vars=[loss], executor=fluid.Executor(fluid.CUDAPlace(0)))
+  fluid.io.save_inference_model(dirname='./model', 
+                                feeded_var_names=[img.name, label.name],
+                                target_vars=[loss], 
+                                executor=fluid.Executor(fluid.CUDAPlace(0)))
 
 
 2.训练和测试应使用不同的名称创建两个不同的py_reader，例如：
@@ -397,35 +400,41 @@ py_reader
   import paddle.dataset.mnist as mnist
 
   def network(reader):
-    img, label = fluid.layers.read_file(reader)
+      img, label = fluid.layers.read_file(reader)
     # 用户自定义网络，此处以softmax回归为例
-    predict = fluid.layers.fc(input=img, size=10, act='softmax')
-
-    loss = fluid.layers.cross_entropy(input=predict, label=label)
-        
-    return fluid.layers.mean(loss)
+      predict = fluid.layers.fc(input=img, size=10, act='softmax')
+      loss = fluid.layers.cross_entropy(input=predict, label=label)        
+      return fluid.layers.mean(loss)
 
   # 新建 train_main_prog 和 train_startup_prog
   train_main_prog = fluid.Program()
   train_startup_prog = fluid.Program()
   with fluid.program_guard(train_main_prog, train_startup_prog):
-    # 使用 fluid.unique_name.guard() 实现与test program的参数共享
-    with fluid.unique_name.guard():
-      train_reader = fluid.layers.py_reader(capacity=64, shapes=[(-1, 1, 28, 28), (-1, 1)], dtypes=['float32', 'int64'], name='train_reader')
-      train_reader.decorate_paddle_reader(
-        paddle.reader.shuffle(paddle.batch(mnist.train(), batch_size=5), buf_size=500))
-    train_loss = network(train_reader) # 一些网络定义
-    adam = fluid.optimizer.Adam(learning_rate=0.01)
-    adam.minimize(train_loss)
+      # 使用 fluid.unique_name.guard() 实现与test program的参数共享
+      with fluid.unique_name.guard():
+          train_reader = fluid.layers.py_reader(capacity=64, 
+                                                shapes=[(-1, 1, 28, 28), (-1, 1)], 
+                                                dtypes=['float32', 'int64'], 
+                                                name='train_reader')
+          train_reader.decorate_paddle_reader(
+          paddle.reader.shuffle(paddle.batch(mnist.train(), 
+                                batch_size=5), 
+                                buf_size=500))
+          train_loss = network(train_reader) # 一些网络定义
+          adam = fluid.optimizer.Adam(learning_rate=0.01)
+          adam.minimize(train_loss)
 
   # Create test_main_prog and test_startup_prog
   test_main_prog = fluid.Program()
   test_startup_prog = fluid.Program()
   with fluid.program_guard(test_main_prog, test_startup_prog):
-    # 使用 fluid.unique_name.guard() 实现与train program的参数共享
-    with fluid.unique_name.guard():
-      test_reader = fluid.layers.py_reader(capacity=32, shapes=[(-1, 1, 28, 28), (-1, 1)], dtypes=['float32', 'int64'], name='test_reader')
-                test_reader.decorate_paddle_reader(paddle.batch(mnist.test(), 512))
+      # 使用 fluid.unique_name.guard() 实现与train program的参数共享
+      with fluid.unique_name.guard():
+      test_reader = fluid.layers.py_reader(capacity=32, 
+                                           shapes=[(-1, 1, 28, 28), (-1, 1)], 
+                                           dtypes=['float32', 'int64'], 
+                                           name='test_reader')
+      test_reader.decorate_paddle_reader(paddle.batch(mnist.test(), 512))
     
       test_loss = network(test_reader)
 
@@ -439,17 +448,17 @@ py_reader
   for epoch_id in range(10):
       train_reader.start()
       try:
-    while True:
-        train_exe.run(fetch_list=[train_loss.name])
-      except fluid.core.EOFException:
-    train_reader.reset()
-
-      test_reader.start()
-      try:
-    while True:
-        test_exe.run(fetch_list=[test_loss.name])
+          while True:
+              train_exe.run(fetch_list=[train_loss.name])
       except fluid.core.EOFException:
-    test_reader.reset()
+          train_reader.reset()
+
+  test_reader.start()
+  try:
+      while True:
+          test_exe.run(fetch_list=[test_loss.name])
+  except fluid.core.EOFException:
+      test_reader.reset()
 
 
 

doc/fluid/api_cn/layers_cn/nn_cn.rst

@@ -3711,10 +3711,13 @@ GRU单元层。GRU执行步骤基于如下等式：
 `Learning Phrase Representations using RNN Encoder Decoder for Statistical Machine Translation <https://arxiv.org/pdf/1406.1078.pdf>`_ 。
 
 .. math::
-    u_t & = act_g(W_{ux}x_{t} + W_{uh}h_{t-1} + b_u)\\
-    r_t & = act_g(W_{rx}x_{t} + W_{rh}h_{t-1} + b_r)\\
-    \tilde{h_t} & = act_c(W_{cx}x_{t} + W_{ch}(r_t \odot h_{t-1}) + b_c)\\
-    h_t & = u_t \odot h_{t-1} + (1-u_t) \odot \tilde{h_t}
+    u_t=actGate(xu_t+W_{u}h_{t-1}+b_u)
+.. math::
+    r_t=actGate(xr_t+W_{r}h_{t-1}+b_r)
+.. math::
+    m_t=actNode(xm_t+W_{c}dot(r_t,h_{t-1})+b_m)
+.. math::
+    h_t=dot(u_t,m_t)+dot((1-u_t),h_{t-1})
 
 
 GRU单元的输入包括 :math:`z_t` ， :math:`h_{t-1}` 。在上述等式中， :math:`z_t` 会被分割成三部分： :math:`xu_t` 、 :math:`xr_t` 和 :math:`xm_t`  。
@@ -6460,7 +6463,7 @@ reduce_all
 
 参数：
           - **input** （Variable）：输入变量为Tensor或LoDTensor。
-          - **dim** （list | int | None）：与逻辑运算的维度。如果为None，则计算所有元素的与逻辑并返回包含单个元素的Tensor变量，否则必须在  :math:`[−rank(input),rank(input)]` 范围内。如果 :math:`dim [i] <0` ，则维度将减小为 :math:`rank+dim[i]` 。
+          - **dim** （list | int | None）：与逻辑运算的维度。如果为None，则计算所有元素的与逻辑并返回包含单个元素的Tensor变量，否则必须在  :math:`[−rank(input),rank(input))` 范围内。如果 :math:`dim [i] <0` ，则维度将减小为 :math:`rank+dim[i]` 。
           - **keep_dim** （bool | False）：是否在输出Tensor中保留减小的维度。除非 ``keep_dim`` 为true，否则结果张量的维度将比输入张量小。
           - **name** （str | None）：这一层的名称（可选）。如果设置为None，则将自动命名这一层。
 
@@ -6497,7 +6500,7 @@ reduce_any
 
 参数：
           - **input** （Variable）：输入变量为Tensor或LoDTensor。
-          - **dim** （list | int | None）：或逻辑运算的维度。如果为None，则计算所有元素的或逻辑并返回仅包含单个元素的Tensor变量，否则必须在  :math:`[−rank(input),rank(input)]` 范围内。如果 :math:`dim [i] <0` ，则维度将减小为 :math:`rank+dim[i]` 。
+          - **dim** （list | int | None）：或逻辑运算的维度。如果为None，则计算所有元素的或逻辑并返回仅包含单个元素的Tensor变量，否则必须在  :math:`[−rank(input),rank(input))` 范围内。如果 :math:`dim [i] <0` ，则维度将减小为 :math:`rank+dim[i]` 。
           - **keep_dim** （bool | False）：是否在输出Tensor中保留减小的维度。除非 ``keep_dim`` 为true，否则结果张量的维度将比输入张量小。
           - **name** （str | None）：这一层的名称（可选）。如果设置为None，则将自动命名这一层。
 
@@ -6539,7 +6542,7 @@ reduce_max
 
 参数：
           - **input** （Variable）：输入变量为Tensor或LoDTensor。
-          - **dim** （list | int | None）：函数运算的维度。如果为None，则计算所有元素中的最大值并返回单个元素的Tensor变量，否则必须在  :math:`[−rank(input),rank(input)]` 范围内。如果 :math:`dim [i] <0` ，则维度将减小为 :math:`rank+dim[i]` 。
+          - **dim** （list | int | None）：函数运算的维度。如果为None，则计算所有元素中的最大值并返回单个元素的Tensor变量，否则必须在  :math:`[−rank(input),rank(input))` 范围内。如果 :math:`dim [i] <0` ，则维度将减小为 :math:`rank+dim[i]` 。
           - **keep_dim** （bool | False）：是否在输出Tensor中保留减小的维度。除非 ``keep_dim`` 为true，否则结果张量将比输入少一个维度。
           - **name** （str | None）：这一层的名称（可选）。如果设置为None，则将自动命名这一层。
 
@@ -6590,7 +6593,7 @@ reduce_mean
 
 参数：
           - **input** （Variable）：输入变量为Tensor或LoDTensor。
-          - **dim** （list | int | None）：函数运算的维度。如果为None，则对输入的所有元素求平均值并返回单个元素的Tensor变量，否则必须在  :math:`[−rank(input),rank(input)]` 范围内。如果 :math:`dim [i] <0` ，则维度将减小为 :math:`rank+dim[i]` 。
+          - **dim** （list | int | None）：函数运算的维度。如果为None，则对输入的所有元素求平均值并返回单个元素的Tensor变量，否则必须在  :math:`[−rank(input),rank(input))` 范围内。如果 :math:`dim [i] <0` ，则维度将减小为 :math:`rank+dim[i]` 。
           - **keep_dim** （bool | False）：是否在输出Tensor中保留减小的维度。除非 ``keep_dim`` 为true，否则结果张量将比输入少一个维度。
           - **name** （str | None）：这一层的名称（可选）。如果设置为None，则将自动命名这一层。
 
@@ -6641,7 +6644,7 @@ reduce_min
 
 参数：
           - **input** （Variable）：输入变量为Tensor或LoDTensor。
-          - **dim** （list | int | None）：函数运算的维度。如果为None，则对输入的所有元素做差并返回单个元素的Tensor变量，否则必须在  :math:`[−rank(input),rank(input)]` 范围内。如果 :math:`dim [i] <0` ，则维度将减小为 :math:`rank+dim[i]` 。
+          - **dim** （list | int | None）：函数运算的维度。如果为None，则对输入的所有元素求最小值并返回单个元素的Tensor变量，否则必须在  :math:`[−rank(input),rank(input))` 范围内。如果 :math:`dim [i] <0` ，则维度将减小为 :math:`rank+dim[i]` 。
           - **keep_dim** （bool | False）：是否在输出Tensor中保留减小的维度。除非 ``keep_dim`` 为true，否则结果张量将比输入少一个维度。
           - **name** （str | None）：这一层的名称（可选）。如果设置为None，则将自动命名这一层。
 
@@ -6692,7 +6695,7 @@ reduce_prod
 
 参数：
           - **input** （Variable）：输入变量为Tensor或LoDTensor。
-          - **dim** （list | int | None）：函数运算的维度。如果为None，则将输入的所有元素相乘并返回单个元素的Tensor变量，否则必须在  :math:`[−rank(input),rank(input)]` 范围内。如果 :math:`dim [i] <0` ，则维度将减小为 :math:`rank+dim[i]` 。
+          - **dim** （list | int | None）：函数运算的维度。如果为None，则将输入的所有元素相乘并返回单个元素的Tensor变量，否则必须在  :math:`[−rank(input),rank(input))` 范围内。如果 :math:`dim [i] <0` ，则维度将减小为 :math:`rank+dim[i]` 。
           - **keep_dim** （bool | False）：是否在输出Tensor中保留减小的维度。除非 ``keep_dim`` 为true，否则结果张量将比输入少一个维度。
           - **name** （str | None）：这一层的名称（可选）。如果设置为None，则将自动命名这一层。
 
@@ -6744,7 +6747,7 @@ reduce_sum
 
 参数：
           - **input** （Variable）- 输入变量为Tensor或LoDTensor。
-          - **dim** （list | int | None）- 求和运算的维度。如果为None，则对输入的所有元素求和并返回单个元素的Tensor变量，否则必须在  :math:`[−rank(input),rank(input)]` 范围内。如果 :math:`dim [i] <0` ，则维度将减小为 :math:`rank+dim[i]` 。
+          - **dim** （list | int | None）- 求和运算的维度。如果为None，则对输入的所有元素求和并返回单个元素的Tensor变量，否则必须在  :math:`[−rank(input),rank(input))` 范围内。如果 :math:`dim [i] <0` ，则维度将减小为 :math:`rank+dim[i]` 。
           - **keep_dim** （bool | False）- 是否在输出Tensor中保留减小的维度。除非 ``keep_dim`` 为true，否则结果张量将比输入少一个维度。
           - **name** （str | None）- 这一层的名称（可选）。如果设置为None，则将自动命名这一层。
 

doc/fluid/api_cn/optimizer_cn.rst

@@ -274,13 +274,13 @@ Adamax 更新规则:
 .. math::
     \\t = t + 1
 .. math::
-    moment\_out=\beta_1∗moment+(1−\beta_1)∗grad
+    moment\_1\_out = {\beta}_1 * moment\_1 + (1 - {\beta}_1) * grad
 .. math::
-    inf\_norm\_out=\max{(\beta_2∗inf\_norm+ϵ, \left|grad\right|)}
+    moment\_2\_out = {\beta}_2 * moment\_2 + (1 - {\beta}_2) * grad * grad
 .. math::
-    learning\_rate=\frac{learning\_rate}{1-\beta_1^t}
+    learning\_rate = learning\_rate * \frac{\sqrt{1 - {\beta}_2^t}}{1 - {\beta}_1^t}
 .. math::
-    param\_out=param−learning\_rate*\frac{moment\_out}{inf\_norm\_out}\\
+    param\_out = param - learning\_rate * \frac{moment\_1}{\sqrt{moment\_2} + \epsilon}\\
 
 
 论文中没有 ``epsilon`` 参数。但是，为了数值稳定性， 防止除0错误， 增加了这个参数
@@ -498,8 +498,15 @@ AdamOptimizer
 Adam更新如下：
 
 .. math::
-
-    t & = t + 1\\moment\_out & = {\beta}_1 * moment + (1 - {\beta}_1) * grad\\inf\_norm\_out & = max({\beta}_2 * inf\_norm + \epsilon, |grad|)\\learning\_rate & = \frac{learning\_rate}{1 - {\beta}_1^t}\\param\_out & = param - learning\_rate * \frac{moment\_out}{inf\_norm\_out}
+    \\t = t + 1
+.. math::
+    moment\_1\_out=\beta_1∗moment\_1+(1−\beta_1)∗grad
+.. math::
+    moment\_2\_out=\beta_2∗moment\_2+(1−\beta_2)∗grad*grad
+.. math::
+    learning\_rate=\frac{learning\_rate}{1-\beta_1^t}
+.. math::
+    param\_out=param−learning\_rate*\frac{moment\_out}{inf\_norm\_out}\\
 
 参数: 
     - **learning_rate** (float|Variable)-学习率，用于更新参数。作为数据参数，可以是一个浮点类型值或有一个浮点类型值的变量
@@ -726,7 +733,7 @@ Decayed Adagrad Optimizer
 .. math::
     moment\_out = decay*moment+(1-decay)*grad*grad
 .. math::
-    param\_out=param-\frac{learning\_rate*grad}{\sqrt{moment\_out+\epsilon }}
+    param\_out = param-\frac{learning\_rate*grad}{\sqrt{moment\_out}+\epsilon }
     
 参数:
   - **learning_rate** (float|Variable) - 用于更新参数的学习率。可以是浮点值，也可以是具有一个浮点值作为数据元素的变量。

doc/fluid/api_guides/low_level/program.rst

@@ -19,7 +19,7 @@ Program
 
 * :code:`Block` 中的计算由顺序执行、条件选择或者循环执行三种方式组合，构成复杂的计算逻辑；
 
-* :code:`Block` 中包含对计算和计算对象的描述。计算的描述称之为 Operator；计算作用的对象（或者说 Operator 的输入和输出）被统一为 Tensor，在Fluid中，Tensor 用层级为0的 `LoD-Tensor <http://paddlepaddle.org/documentation/docs/zh/1.2/user_guides/howto/prepare_data/lod_tensor.html#permalink-4-lod-tensor>`_ 表示。
+* :code:`Block` 中包含对计算和计算对象的描述。计算的描述称之为 Operator；计算作用的对象（或者说 Operator 的输入和输出）被统一为 Tensor，在Fluid中，Tensor 用层级为0的 :ref:`Lod_Tensor <cn_user_guide_lod_tensor>` 表示。
 
 
 
@@ -61,7 +61,7 @@ Operator
 Variable
 =========
 
-Fluid 中的 :code:`Variable` 可以包含任何类型的值———在大多数情况下是一个 LoD-Tensor。
+Fluid 中的 :code:`Variable` 可以包含任何类型的值———在大多数情况下是一个 :ref:`Lod_Tensor <cn_user_guide_lod_tensor>` 。
 
 模型中所有的可学习参数都以 :code:`Variable` 的形式保留在内存空间中，您在绝大多数情况下都不需要自己来创建网络中的可学习参数， Fluid 为几乎常见的神经网络基本计算模块都提供了封装。以最简单的全连接模型为例，调用 :code:`fluid.layers.fc` 会直接为全连接层创建连接权值( W )和偏置（ bias ）两个可学习参数，无需显示地调用 :code:`variable` 相关接口创建可学习参数。
 

doc/fluid/user_guides/howto/basic_concept/lod_tensor.rst

+.. _cn_user_guide_lod_tensor:
+
 ##################
 LoD-Tensor使用说明
 ##################