add API tags for static/dynamic graph only API (#1786)

doc/fluid/api_cn/backward_cn/append_backward_cn.rst

-.. _cn_api_fluid_backward_append_backward:
-
-append_backward
--------------------------------
-
-.. py:function:: paddle.fluid.backward.append_backward(loss, parameter_list=None, no_grad_set=None, callbacks=None)
-
-该接口将向主程序（``main_program``）追加反向部分 。
-
-完整的神经网络训练由前向和反向传播组成。但是当我们配置网络时，我们只需要指定其前向部分。
-该接口使用链式法则，能够根据前向部分自动生成反向部分。
-
-在大多数情况下，用户无需手动调用此接口，它将由优化器（``Optimizer``）的 ``minimize`` 函数自动调用。
-
-参数：
-    - **loss** ( :ref:`api_guide_Variable` ) - 网络的损失变量。
-    - **parameter_list** （list [Variable|str]，可选）- 指定优化器需要更新的参数或参数名称列表。如果为 ``None`` ，则将更新所有参数。默认值为 ``None``。
-    - **no_grad_set** （set [Variable|str]，可选）-  在 `block0` ( :ref:`api_guide_Block` ) 中要忽略梯度的 :ref:`api_guide_Variable` 的名字的集合。所有的 :ref:`api_guide_Block` 中带有 ``stop_gradient = True`` 的所有 :ref:`api_guide_Variable` 的名字都会被自动添加到此集合中。如果该参数不为 ``None``，则会将该参数集合的内容添加到默认的集合中。默认值为 ``None``。
-    - **callbacks** （list [callable object]，可选）- 回调函数列表。用于在反向传播构建中执行一些自定义作业。每次将新的梯度OP添加到程序中时，将调用其中的所有可调用对象。可调用对象必须有两个输入参数： :ref:`api_guide_Block` 和 ``context`` 。 :ref:`api_guide_Block` 是将被添加到新梯度算子的块。 ``context`` 是一个映射，其键是梯度 :ref:`api_guide_Variable` 名，值是对应的原始 :ref:`api_guide_Variable` 。除此之外， ``context`` 还有另一个特殊的键值对：键是字符串 ``__ current_op_desc__`` ，值是刚刚触发可调用对象的梯度OP的 ``op_desc`` 。默认值为 ``None``。
-
-返回：   参数及其梯度 :ref:`api_guide_Variable` 的元组的列表。元组的第一个值为参数，第二个值为该参数的梯度 :ref:`api_guide_Variable` 。
-
-返回类型：       list[( :ref:`api_guide_Variable` , :ref:`api_guide_Variable` )]
-
-抛出：     
-    - ``AssertionError`` - 如果 loss 不是 :ref:`api_guide_Variable` 的实例。
-
-**示例代码**
-
-.. code-block:: python
-
-        import paddle.fluid as fluid
-
-        x = fluid.data(name='x', shape=[None, 13], dtype='int64')
-        y = fluid.data(name='y', shape=[None, 1], dtype='float32')
-        x_emb = fluid.embedding(x, size=[100, 256])
-        y_predict = fluid.layers.fc(input=x_emb, size=1, act=None, name='my_fc')
-        loss = fluid.layers.square_error_cost(input=y_predict, label=y)
-        avg_loss = fluid.layers.mean(loss)
-
-        # 获取main_program中所有weight参数, 不包括bias.
-        all_weights = [param for param in fluid.default_main_program().block(0).all_parameters() if 'w_' in param.name]
-        all_weights_name = [w.name for w in all_weights]
-
-        # 若parameter_list为默认值(None), 则返回包含所有param_grad的list
-        p_g_list1 = fluid.backward.append_backward(loss=avg_loss)
-        # output: [(embedding_0.w_0, embedding_0.w_0@GRAD), (my_fc.w_0, my_fc.w_0@GRAD), (my_fc.b_0, my_fc.b_0@GRAD)]
-
-        # 返回与传入parameter_list对应的param_grad的list, 传入的parameter_list可以是 param(Variable类型)的list
-        p_g_list2 = fluid.backward.append_backward(loss=avg_loss, parameter_list=all_weights)
-        # output: [(embedding_0.w_0, embedding_0.w_0@GRAD), (my_fc.w_0, my_fc.w_0@GRAD)]
-
-        # 传入的parameter_list也可以是值为param.name(str类型)的list
-        p_g_list3 = fluid.backward.append_backward(loss=avg_loss, parameter_list=all_weights_name)
-        # output: [(embedding_0.w_0, embedding_0.w_0@GRAD), (my_fc.w_0, my_fc.w_0@GRAD)]
-
-        # no_grad_set可以是set[Variables]类型，表示梯度将在这些Variables处截断
-        p_g_list4 = fluid.backward.append_backward(loss=avg_loss, no_grad_set=set([x_emb]))
-        # output: [(my_fc.w_0, my_fc.w_0@GRAD), (my_fc.b_0, my_fc.b_0@GRAD)]
-
-        # no_grad_set也可以是set[Variable.names]类型。当参数Variable是在layers内部创建，且不方便显式地指定时，可以使用set[Variable.names]
-        p_g_list5 = fluid.backward.append_backward(loss=avg_loss, no_grad_set=set(['my_fc.b_0']))
-        # output: [(embedding_0.w_0, embedding_0.w_0@GRAD), (my_fc.w_0, my_fc.w_0@GRAD)]
-
-        # 返回为[], 因为所有的param_grad均被传入的no_grad_set过滤掉了
-        p_g_list6 = fluid.backward.append_backward(loss=avg_loss, parameter_list=all_weights, no_grad_set=set(all_weights))
-
-
-
+.. _cn_api_fluid_backward_append_backward:
+
+append_backward
+-------------------------------
+
+**注意：该API仅支持【静态图】模式**
+
+.. py:function:: paddle.fluid.backward.append_backward(loss, parameter_list=None, no_grad_set=None, callbacks=None)
+
+该接口将向主程序（``main_program``）追加反向部分 。
+
+完整的神经网络训练由前向和反向传播组成。但是当我们配置网络时，我们只需要指定其前向部分。
+该接口使用链式法则，能够根据前向部分自动生成反向部分。
+
+在大多数情况下，用户无需手动调用此接口，它将由优化器（``Optimizer``）的 ``minimize`` 函数自动调用。
+
+参数：
+    - **loss** ( :ref:`api_guide_Variable` ) - 网络的损失变量。
+    - **parameter_list** （list [Variable|str]，可选）- 指定优化器需要更新的参数或参数名称列表。如果为 ``None`` ，则将更新所有参数。默认值为 ``None``。
+    - **no_grad_set** （set [Variable|str]，可选）-  在 `block0` ( :ref:`api_guide_Block` ) 中要忽略梯度的 :ref:`api_guide_Variable` 的名字的集合。所有的 :ref:`api_guide_Block` 中带有 ``stop_gradient = True`` 的所有 :ref:`api_guide_Variable` 的名字都会被自动添加到此集合中。如果该参数不为 ``None``，则会将该参数集合的内容添加到默认的集合中。默认值为 ``None``。
+    - **callbacks** （list [callable object]，可选）- 回调函数列表。用于在反向传播构建中执行一些自定义作业。每次将新的梯度OP添加到程序中时，将调用其中的所有可调用对象。可调用对象必须有两个输入参数： :ref:`api_guide_Block` 和 ``context`` 。 :ref:`api_guide_Block` 是将被添加到新梯度算子的块。 ``context`` 是一个映射，其键是梯度 :ref:`api_guide_Variable` 名，值是对应的原始 :ref:`api_guide_Variable` 。除此之外， ``context`` 还有另一个特殊的键值对：键是字符串 ``__ current_op_desc__`` ，值是刚刚触发可调用对象的梯度OP的 ``op_desc`` 。默认值为 ``None``。
+
+返回：   参数及其梯度 :ref:`api_guide_Variable` 的元组的列表。元组的第一个值为参数，第二个值为该参数的梯度 :ref:`api_guide_Variable` 。
+
+返回类型：       list[( :ref:`api_guide_Variable` , :ref:`api_guide_Variable` )]
+
+抛出：     
+    - ``AssertionError`` - 如果 loss 不是 :ref:`api_guide_Variable` 的实例。
+
+**示例代码**
+
+.. code-block:: python
+
+        import paddle.fluid as fluid
+
+        x = fluid.data(name='x', shape=[None, 13], dtype='int64')
+        y = fluid.data(name='y', shape=[None, 1], dtype='float32')
+        x_emb = fluid.embedding(x, size=[100, 256])
+        y_predict = fluid.layers.fc(input=x_emb, size=1, act=None, name='my_fc')
+        loss = fluid.layers.square_error_cost(input=y_predict, label=y)
+        avg_loss = fluid.layers.mean(loss)
+
+        # 获取main_program中所有weight参数, 不包括bias.
+        all_weights = [param for param in fluid.default_main_program().block(0).all_parameters() if 'w_' in param.name]
+        all_weights_name = [w.name for w in all_weights]
+
+        # 若parameter_list为默认值(None), 则返回包含所有param_grad的list
+        p_g_list1 = fluid.backward.append_backward(loss=avg_loss)
+        # output: [(embedding_0.w_0, embedding_0.w_0@GRAD), (my_fc.w_0, my_fc.w_0@GRAD), (my_fc.b_0, my_fc.b_0@GRAD)]
+
+        # 返回与传入parameter_list对应的param_grad的list, 传入的parameter_list可以是 param(Variable类型)的list
+        p_g_list2 = fluid.backward.append_backward(loss=avg_loss, parameter_list=all_weights)
+        # output: [(embedding_0.w_0, embedding_0.w_0@GRAD), (my_fc.w_0, my_fc.w_0@GRAD)]
+
+        # 传入的parameter_list也可以是值为param.name(str类型)的list
+        p_g_list3 = fluid.backward.append_backward(loss=avg_loss, parameter_list=all_weights_name)
+        # output: [(embedding_0.w_0, embedding_0.w_0@GRAD), (my_fc.w_0, my_fc.w_0@GRAD)]
+
+        # no_grad_set可以是set[Variables]类型，表示梯度将在这些Variables处截断
+        p_g_list4 = fluid.backward.append_backward(loss=avg_loss, no_grad_set=set([x_emb]))
+        # output: [(my_fc.w_0, my_fc.w_0@GRAD), (my_fc.b_0, my_fc.b_0@GRAD)]
+
+        # no_grad_set也可以是set[Variable.names]类型。当参数Variable是在layers内部创建，且不方便显式地指定时，可以使用set[Variable.names]
+        p_g_list5 = fluid.backward.append_backward(loss=avg_loss, no_grad_set=set(['my_fc.b_0']))
+        # output: [(embedding_0.w_0, embedding_0.w_0@GRAD), (my_fc.w_0, my_fc.w_0@GRAD)]
+
+        # 返回为[], 因为所有的param_grad均被传入的no_grad_set过滤掉了
+        p_g_list6 = fluid.backward.append_backward(loss=avg_loss, parameter_list=all_weights, no_grad_set=set(all_weights))
+
+
+

doc/fluid/api_cn/backward_cn/gradients_cn.rst

-.. _cn_api_fluid_backward_gradients:
-
-gradients
--------------------------------
-
-.. py:function:: paddle.fluid.backward.gradients(targets, inputs, target_gradients=None, no_grad_set=None)
-
-将目标梯度反向传播到输入。
-
-参数：  
-  - **targets** (Variable|list[Variable]) – 目标变量
-  - **inputs** (Variable|list[Variable]) – 输入变量
-  - **target_gradients** (Variable|list[Variable]，可选) – 目标的梯度变量，应与目标变量形状相同；如果设置为None，则以1初始化所有梯度变量
-  - **no_grad_set** (set[Variable|str]，可选) – 在 `block0` ( :ref:`api_guide_Block` ) 中要忽略梯度的 :ref:`api_guide_Variable` 的名字的集合。所有的 :ref:`api_guide_Block` 中带有 ``stop_gradient = True`` 的所有 :ref:`api_guide_Variable` 的名字都会被自动添加到此集合中。如果该参数不为 ``None``，则会将该参数集合的内容添加到默认的集合中。默认值为 ``None``。
-
-
-返回：数组，包含与输入对应的梯度。如果一个输入不影响目标函数，则对应的梯度变量为None
-
-返回类型：(list[Variable])
-
-**示例代码**
-
-.. code-block:: python
-
-            import paddle.fluid as fluid
-
-            x = fluid.data(name='x', shape=[None,2,8,8], dtype='float32')
-            x.stop_gradient=False
-            y = fluid.layers.conv2d(x, 4, 1, bias_attr=False)
-            y = fluid.layers.relu(y)
-            y = fluid.layers.conv2d(y, 4, 1, bias_attr=False)
-            y = fluid.layers.relu(y)
-            z = fluid.gradients([y], x)
+.. _cn_api_fluid_backward_gradients:
+
+gradients
+-------------------------------
+
+**注意：该API仅支持【静态图】模式**
+
+.. py:function:: paddle.fluid.backward.gradients(targets, inputs, target_gradients=None, no_grad_set=None)
+
+将目标梯度反向传播到输入。
+
+参数：  
+  - **targets** (Variable|list[Variable]) – 目标变量
+  - **inputs** (Variable|list[Variable]) – 输入变量
+  - **target_gradients** (Variable|list[Variable]，可选) – 目标的梯度变量，应与目标变量形状相同；如果设置为None，则以1初始化所有梯度变量
+  - **no_grad_set** (set[Variable|str]，可选) – 在 `block0` ( :ref:`api_guide_Block` ) 中要忽略梯度的 :ref:`api_guide_Variable` 的名字的集合。所有的 :ref:`api_guide_Block` 中带有 ``stop_gradient = True`` 的所有 :ref:`api_guide_Variable` 的名字都会被自动添加到此集合中。如果该参数不为 ``None``，则会将该参数集合的内容添加到默认的集合中。默认值为 ``None``。
+
+
+返回：数组，包含与输入对应的梯度。如果一个输入不影响目标函数，则对应的梯度变量为None
+
+返回类型：(list[Variable])
+
+**示例代码**
+
+.. code-block:: python
+
+            import paddle.fluid as fluid
+
+            x = fluid.data(name='x', shape=[None,2,8,8], dtype='float32')
+            x.stop_gradient=False
+            y = fluid.layers.conv2d(x, 4, 1, bias_attr=False)
+            y = fluid.layers.relu(y)
+            y = fluid.layers.conv2d(y, 4, 1, bias_attr=False)
+            y = fluid.layers.relu(y)
+            z = fluid.gradients([y], x)
             print(z)
\ No newline at end of file

doc/fluid/api_cn/clip_cn/set_gradient_clip_cn.rst

@@ -3,6 +3,8 @@
 set_gradient_clip
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.clip.set_gradient_clip(clip, param_list=None, program=None)
 
 给指定参数做梯度裁剪。

doc/fluid/api_cn/dygraph_cn/BackwardStrategy_cn.rst

@@ -3,6 +3,8 @@
 BackwardStrategy
 -------------------------------
 
+**注意：该API仅支持【动态图】模式**
+
 .. py:class:: paddle.fluid.dygraph.BackwardStrategy
 
 **注意：该API只在动态图下生效**

doc/fluid/api_cn/dygraph_cn/CosineDecay_cn.rst

@@ -3,6 +3,8 @@
 CosineDecay
 -------------------------------
 
+**注意：该API仅支持【动态图】模式**
+
 .. py:class:: paddle.fluid.dygraph.CosineDecay(learning_rate, step_each_epoch, epochs, begin=0, step=1, dtype='float32')
 
 该接口提供按余弦函数衰减学习率的功能。

doc/fluid/api_cn/dygraph_cn/ExponentialDecay_cn.rst

@@ -3,6 +3,8 @@
 ExponentialDecay
 -------------------------------
 
+**注意：该API仅支持【动态图】模式**
+
 .. py:class:: paddle.fluid.dygraph.ExponentialDecay(learning_rate, decay_steps, decay_rate, staircase=False, begin=0, step=1, dtype=’float32‘)
 
 该接口提供一种学习率按指数函数衰减的功能。

doc/fluid/api_cn/dygraph_cn/FC_cn.rst

@@ -3,6 +3,8 @@
 FC
 -------------------------------
 
+**注意：该API仅支持【动态图】模式**
+
 .. py:class:: paddle.fluid.dygraph.FC(name_scope, size, num_flatten_dims=1, param_attr=None, bias_attr=None, act=None, is_test=False, dtype='float32')
 
 

doc/fluid/api_cn/dygraph_cn/InverseTimeDecay_cn.rst

@@ -3,6 +3,8 @@
 InverseTimeDecay
 -------------------------------
 
+**注意：该API仅支持【动态图】模式**
+
 .. py:class:: paddle.fluid.dygraph.InverseTimeDecay(learning_rate, decay_steps, decay_rate, staircase=False, begin=0, step=1, dtype='float32')
 
 该接口提供反时限学习率衰减的功能。

doc/fluid/api_cn/dygraph_cn/NaturalExpDecay_cn.rst

@@ -3,6 +3,8 @@
 NaturalExpDecay
 -------------------------------
 
+**注意：该API仅支持【动态图】模式**
+
 .. py:class:: paddle.fluid.dygraph.NaturalExpDecay(learning_rate, decay_steps, decay_rate, staircase=False, begin=0, step=1, dtype='float32')
 
 该接口提供按自然指数衰减学习率的功能。

doc/fluid/api_cn/dygraph_cn/NoamDecay_cn.rst

@@ -3,6 +3,8 @@
 NoamDecay
 -------------------------------
 
+**注意：该API仅支持【动态图】模式**
+
 .. py:class:: paddle.fluid.dygraph.NoamDecay(d_model, warmup_steps, begin=1, step=1, dtype='float32')
 
 该接口提供Noam衰减学习率的功能。

doc/fluid/api_cn/dygraph_cn/PiecewiseDecay_cn.rst

@@ -3,6 +3,8 @@
 PiecewiseDecay
 -------------------------------
 
+**注意：该API仅支持【动态图】模式**
+
 .. py:class:: paddle.fluid.dygraph.PiecewiseDecay(boundaries, values, begin, step=1, dtype='float32')
 
 该接口提供对初始学习率进行分段(piecewise)常数衰减的功能。

doc/fluid/api_cn/dygraph_cn/PolynomialDecay_cn.rst

@@ -3,6 +3,8 @@
 PolynomialDecay
 -------------------------------
 
+**注意：该API仅支持【动态图】模式**
+
 .. py:class:: paddle.fluid.dygraph.PolynomialDecay(learning_rate, decay_steps, end_learning_rate=0.0001, power=1.0, cycle=False, begin=0, step=1, dtype='float32')
 
 该接口提供学习率按多项式衰减的功能。通过多项式衰减函数，使得学习率值逐步从初始的 ``learning_rate``，衰减到 ``end_learning_rate`` 。

doc/fluid/api_cn/dygraph_cn/TracedLayer_cn.rst

@@ -3,6 +3,8 @@
 TracedLayer
 -------------------------------
 
+**注意：该API仅支持【动态图】模式**
+
 .. py:class:: paddle.fluid.dygraph.TracedLayer(program, parameters, feed_names, fetch_names)
 
 TracedLayer用于将前向动态图模型转换为静态图模型，主要用于将动态图保存后做在线C++预测。除此以外，用户也可使用转换后的静态图模型在Python端做预测，通常比原先的动态图性能更好。

doc/fluid/api_cn/dygraph_cn/guard_cn.rst

@@ -3,6 +3,8 @@
 guard
 -------------------------------
 
+**注意：该API仅支持【动态图】模式**
+
 .. py:function:: paddle.fluid.dygraph.guard(place=None)
 
 通过with语句创建一个dygraph运行的context，执行context代码。

doc/fluid/api_cn/dygraph_cn/load_dygraph_cn.rst

@@ -3,6 +3,8 @@
 load_dygraph
 -------------------------------
 
+**注意：该API仅支持【动态图】模式**
+
 .. py:function:: paddle.fluid.dygraph.load_dygraph(model_path)
 
 该接口尝试从磁盘中加载参数或优化器的 ``dict`` 。

doc/fluid/api_cn/dygraph_cn/save_dygraph_cn.rst

@@ -3,6 +3,8 @@
 save_dygraph
 -------------------------------
 
+**注意：该API仅支持【动态图】模式**
+
 .. py:function:: paddle.fluid.dygraph.save_dygraph(state_dict, model_path)
 
 该接口将传入的参数或优化器的 ``dict`` 保存到磁盘上。

doc/fluid/api_cn/dygraph_cn/to_variable_cn.rst

@@ -3,6 +3,8 @@
 to_variable
 -------------------------------
 
+**注意：该API仅支持【动态图】模式**
+
 .. py:function:: paddle.fluid.dygraph.to_variable(value, name=None, zero_copy=None)
 
 该函数实现从numpy\.ndarray对象或者Variable对象创建一个 ``Variable`` 类型的对象。

doc/fluid/api_cn/executor_cn/Executor_cn.rst

@@ -3,6 +3,8 @@
 Executor
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:class:: paddle.fluid.executor.Executor (place)
 
 Executor支持单GPU、多GPU以及CPU运行。在Executor构造时，需要传入设备。

doc/fluid/api_cn/executor_cn/global_scope_cn.rst

@@ -3,6 +3,8 @@
 global_scope
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.global_scope()
 
 获取全局/默认作用域实例。很多API使用默认 ``global_scope`` ，例如 ``Executor.run`` 等。

doc/fluid/api_cn/executor_cn/scope_guard_cn.rst

@@ -3,6 +3,8 @@
 scope_guard
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.executor.scope_guard (scope)
 
 

doc/fluid/api_cn/fluid_cn/BuildStrategy_cn.rst

@@ -3,6 +3,8 @@
 BuildStrategy
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:class:: paddle.fluid.BuildStrategy
 
 ``BuildStrategy`` 使用户更方便地控制[ ``ParallelExecutor`` ](../fluid_cn.html\#parallelexecutor)中计算图的建造方法，可通过设置 ``ParallelExecutor`` 中的 ``BuildStrategy`` 成员来实现此功能。

doc/fluid/api_cn/fluid_cn/CompiledProgram_cn.rst

@@ -3,6 +3,8 @@
 CompiledProgram
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:class:: paddle.fluid.CompiledProgram(program_or_graph, build_strategy=None)
 
 CompiledProgram根据 `build_strategy` 的配置将输入的Program或Graph进行转换和优化，例如：计算图中算子融合、计算图执行过程中开启内存/显存优化等，关于build_strategy更多信息。请参阅  ``fluid.BuildStrategy`` 。

doc/fluid/api_cn/fluid_cn/DataFeedDesc_cn.rst

@@ -3,6 +3,8 @@
 DataFeedDesc
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:class:: paddle.fluid.DataFeedDesc(proto_file)
 
 描述训练数据的格式。输入是一个文件路径名，其内容是protobuf message。

doc/fluid/api_cn/fluid_cn/DataFeeder_cn.rst

@@ -3,6 +3,8 @@
 DataFeeder
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:class:: paddle.fluid.DataFeeder(feed_list, place, program=None)
 
 

doc/fluid/api_cn/fluid_cn/ExecutionStrategy_cn.rst

@@ -3,6 +3,8 @@
 ExecutionStrategy
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:class:: paddle.fluid.ExecutionStrategy
 
 通过设置 ``ExecutionStrategy`` 中的选项，用户可以对执行器的执行配置进行调整，比如设置执行器中线程池的大小等。

doc/fluid/api_cn/fluid_cn/Executor_cn.rst

@@ -4,6 +4,8 @@ Executor
 -------------------------------
 
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:class:: paddle.fluid.Executor (place)
 
 Executor支持单GPU、多GPU以及CPU运行。在Executor构造时，需要传入设备。

doc/fluid/api_cn/fluid_cn/ParallelExecutor_cn.rst

@@ -3,6 +3,8 @@
 ParallelExecutor
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:class:: paddle.fluid.ParallelExecutor(use_cuda, loss_name=None, main_program=None, share_vars_from=None, exec_strategy=None, build_strategy=None, num_trainers=1, trainer_id=0, scope=None)
 
 ``ParallelExecutor`` 是 ``Executor`` 的一个升级版本，可以支持基于数据并行的多节点模型训练和测试。如果采用数据并行模式， ``ParallelExecutor`` 在构造时会将参数分发到不同的节点上，并将输入的 ``Program`` 拷贝到不同的节点，在执行过程中，各个节点独立运行模型，将模型反向计算得到的参数梯度在多个节点之间进行聚合，之后各个节点独立的进行参数的更新。如果使用GPU运行模型，即 ``use_cuda=True`` ，节点指代GPU， ``ParallelExecutor`` 将自动获取在当前机器上可用的GPU资源，用户也可以通过在环境变量设置可用的GPU资源，例如：希望使用GPU0、GPU1计算，export CUDA_VISIBLEDEVICES=0,1；如果在CPU上进行操作，即 ``use_cuda=False`` ，节点指代CPU，**注意：此时需要用户在环境变量中手动添加 CPU_NUM ，并将该值设置为CPU设备的个数，例如：export CPU_NUM=4，如果没有设置该环境变量，执行器会在环境变量中添加该变量，并将其值设为1**。

doc/fluid/api_cn/fluid_cn/WeightNormParamAttr_cn.rst

@@ -3,6 +3,8 @@
 WeightNormParamAttr
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:class:: paddle.fluid.WeightNormParamAttr(dim=None, name=None, initializer=None, learning_rate=1.0, regularizer=None, trainable=True, gradient_clip=None, do_model_average=False)
 
 

doc/fluid/api_cn/fluid_cn/create_random_int_lodtensor_cn.rst

@@ -4,6 +4,8 @@
 create_random_int_lodtensor
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.create_random_int_lodtensor(recursive_seq_lens, base_shape, place, low, high)
 
 创建一个包含随机整数的LoDTensor。

doc/fluid/api_cn/fluid_cn/data_cn.rst

@@ -3,6 +3,8 @@
 data
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.data(name, shape, dtype='float32', lod_level=0)
 
 该OP会在全局block中创建变量（Variable），该全局变量可被计算图中的算子（operator）访问。该变量可作为占位符用于数据输入。例如用执行器（Executor）feed数据进该变量

doc/fluid/api_cn/fluid_cn/embedding_cn.rst

@@ -3,6 +3,8 @@
 embedding
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.embedding(input, size, is_sparse=False, is_distributed=False, padding_idx=None, param_attr=None, dtype='float32')
 
 该OP根据input中的id信息从embedding矩阵中查询对应embedding信息，函数会根据输入的size (vocab_size, emb_size)和dtype自动构造一个二维embedding矩阵。

doc/fluid/api_cn/fluid_cn/global_scope_cn.rst

@@ -3,6 +3,8 @@
 global_scope
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.global_scope()
 
 获取全局/默认作用域实例。很多API使用默认 ``global_scope`` ，例如 ``Executor.run`` 等。

doc/fluid/api_cn/fluid_cn/gradients_cn.rst

@@ -3,6 +3,8 @@
 gradients
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.gradients(targets, inputs, target_gradients=None, no_grad_set=None)
 
 将目标梯度反向传播到输入。

doc/fluid/api_cn/fluid_cn/memory_optimize_cn.rst

@@ -3,6 +3,8 @@
 memory_optimize
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.memory_optimize(input_program, skip_opt_set=None, print_log=False, level=0, skip_grads=True)
 
 **从1.6版本开始此接口不再推荐使用，请不要在新写的代码中使用它，1.6+版本已默认开启更优的存储优化策略**

doc/fluid/api_cn/fluid_cn/name_scope_cn.rst

@@ -3,6 +3,8 @@
 name_scope
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.name_scope(prefix=None)
 
 

doc/fluid/api_cn/fluid_cn/program_guard_cn.rst

@@ -3,6 +3,8 @@
 program_guard
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.program_guard(main_program, startup_program=None)
 
 该接口应配合使用python的 ``with`` 语句来将 ``with`` block 里的算子和变量添加进指定的全局主程序（main program）和启动程序（startup program）。

doc/fluid/api_cn/fluid_cn/release_memory_cn.rst

@@ -3,6 +3,8 @@
 release_memory
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.release_memory(input_program, skip_opt_set=None)
 
 **从1.6版本开始此接口不再推荐使用，请不要在新写的代码中使用它，1.6+版本已默认开启更优的存储优化策略**

doc/fluid/api_cn/fluid_cn/scope_guard_cn.rst

@@ -3,6 +3,8 @@
 scope_guard
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.scope_guard(scope)
 
 

doc/fluid/api_cn/io_cn/load_cn.rst

@@ -3,6 +3,8 @@
 load
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.io.load(program, model_path)
 
 该接口从Program中过滤出参数和优化器信息，然后从文件中获取相应的值。

doc/fluid/api_cn/io_cn/load_inference_model_cn.rst

-.. _cn_api_fluid_io_load_inference_model:
-
-load_inference_model
--------------------------------
-
-.. py:function:: paddle.fluid.io.load_inference_model(dirname, executor, model_filename=None, params_filename=None, pserver_endpoints=None)
-
-从指定文件路径中加载预测模型(Inference Model)，即调用该接口可获得模型结构（Inference Program）和模型参数。若只想加载预训练后的模型参数，请使用 :ref:`cn_api_fluid_io_load_params` 接口。更多细节请参考 :ref:`api_guide_model_save_reader` 。
-
-参数：
-  - **dirname** (str) – 待加载模型的存储路径。
-  - **executor** (Executor) – 运行 Inference Model 的 ``executor`` ，详见 :ref:`api_guide_executor` 。
-  - **model_filename** (str，可选) –  存储Inference Program结构的文件名称。如果设置为None，则使用 ``__model__`` 作为默认的文件名。默认值为None。
-  - **params_filename** (str，可选) –  存储所有模型参数的文件名称。当且仅当所有模型参数被保存在一个单独的二进制文件中，它才需要被指定。如果模型参数是存储在各自分离的文件中，设置它的值为None。默认值为None。
-  - **pserver_endpoints** (list，可选) – 只有在分布式预测时才需要用到。当训练过程中使用分布式查找表(distributed lookup table)时, 预测时需要指定pserver_endpoints的值。它是 pserver endpoints 的列表，默认值为None。
-
-返回：该接口返回一个包含三个元素的列表(program，feed_target_names, fetch_targets)。它们的含义描述如下：
-  - **program** （Program）– ``Program`` （详见 :ref:`api_guide_Program` ）类的实例。此处它被用于预测，因此可被称为Inference Program。
-  - **feed_target_names** （list）– 字符串列表，包含着Inference Program预测时所需提供数据的所有变量名称（即所有输入变量的名称）。
-  - **fetch_targets** （list）– ``Variable`` （详见 :ref:`api_guide_Program` ）类型列表，包含着模型的所有输出变量。通过这些输出变量即可得到模型的预测结果。
-
-**返回类型：** 列表（list）
-
-抛出异常：
-  - ``ValueError`` – 如果接口参数 ``dirname`` 指向一个不存在的文件路径，则抛出异常。
-
-**代码示例**
-
-.. code-block:: python
-
-        import paddle.fluid as fluid
-        import numpy as np
-
-        # 构建模型
-        main_prog = fluid.Program()
-        startup_prog = fluid.Program()
-        with fluid.program_guard(main_prog, startup_prog):
-            data = fluid.layers.data(name="img", shape=[64, 784], append_batch_size=False)
-            w = fluid.layers.create_parameter(shape=[784, 200], dtype='float32')
-            b = fluid.layers.create_parameter(shape=[200], dtype='float32')
-            hidden_w = fluid.layers.matmul(x=data, y=w)
-            hidden_b = fluid.layers.elementwise_add(hidden_w, b)
-        place = fluid.CPUPlace()
-        exe = fluid.Executor(place)
-        exe.run(startup_prog)
-
-        # 保存预测模型
-        path = "./infer_model"
-        fluid.io.save_inference_model(dirname=path, feeded_var_names=['img'],target_vars=[hidden_b], executor=exe, main_program=main_prog)
-
-        # 示例一: 不需要指定分布式查找表的模型加载示例，即训练时未用到distributed lookup table。
-        [inference_program, feed_target_names, fetch_targets] = (fluid.io.load_inference_model(dirname=path, executor=exe))
-        tensor_img = np.array(np.random.random((1, 64, 784)), dtype=np.float32)
-        results = exe.run(inference_program,
-                  feed={feed_target_names[0]: tensor_img},
-                  fetch_list=fetch_targets)
-
-        # 示例二: 若训练时使用了distributed lookup table，则模型加载时需要通过endpoints参数指定pserver服务器结点列表。
-        # pserver服务器结点列表主要用于分布式查找表进行ID查找时使用。下面的["127.0.0.1:2023","127.0.0.1:2024"]仅为一个样例。
-        endpoints = ["127.0.0.1:2023","127.0.0.1:2024"]
-        [dist_inference_program, dist_feed_target_names, dist_fetch_targets] = (
-            fluid.io.load_inference_model(dirname=path,
-                                          executor=exe,
-                                          pserver_endpoints=endpoints))
-
-        # 在上述示例中，inference program 被保存在“ ./infer_model/__model__”文件内，
-        # 参数保存在“./infer_mode ”单独的若干文件内。
-        # 加载 inference program 后， executor可使用 fetch_targets 和 feed_target_names 执行Program，并得到预测结果。
-
-
-
-
-
-
-
+.. _cn_api_fluid_io_load_inference_model:
+
+load_inference_model
+-------------------------------
+
+**注意：该API仅支持【静态图】模式**
+
+.. py:function:: paddle.fluid.io.load_inference_model(dirname, executor, model_filename=None, params_filename=None, pserver_endpoints=None)
+
+从指定文件路径中加载预测模型(Inference Model)，即调用该接口可获得模型结构（Inference Program）和模型参数。若只想加载预训练后的模型参数，请使用 :ref:`cn_api_fluid_io_load_params` 接口。更多细节请参考 :ref:`api_guide_model_save_reader` 。
+
+参数：
+  - **dirname** (str) – 待加载模型的存储路径。
+  - **executor** (Executor) – 运行 Inference Model 的 ``executor`` ，详见 :ref:`api_guide_executor` 。
+  - **model_filename** (str，可选) –  存储Inference Program结构的文件名称。如果设置为None，则使用 ``__model__`` 作为默认的文件名。默认值为None。
+  - **params_filename** (str，可选) –  存储所有模型参数的文件名称。当且仅当所有模型参数被保存在一个单独的二进制文件中，它才需要被指定。如果模型参数是存储在各自分离的文件中，设置它的值为None。默认值为None。
+  - **pserver_endpoints** (list，可选) – 只有在分布式预测时才需要用到。当训练过程中使用分布式查找表(distributed lookup table)时, 预测时需要指定pserver_endpoints的值。它是 pserver endpoints 的列表，默认值为None。
+
+返回：该接口返回一个包含三个元素的列表(program，feed_target_names, fetch_targets)。它们的含义描述如下：
+  - **program** （Program）– ``Program`` （详见 :ref:`api_guide_Program` ）类的实例。此处它被用于预测，因此可被称为Inference Program。
+  - **feed_target_names** （list）– 字符串列表，包含着Inference Program预测时所需提供数据的所有变量名称（即所有输入变量的名称）。
+  - **fetch_targets** （list）– ``Variable`` （详见 :ref:`api_guide_Program` ）类型列表，包含着模型的所有输出变量。通过这些输出变量即可得到模型的预测结果。
+
+**返回类型：** 列表（list）
+
+抛出异常：
+  - ``ValueError`` – 如果接口参数 ``dirname`` 指向一个不存在的文件路径，则抛出异常。
+
+**代码示例**
+
+.. code-block:: python
+
+        import paddle.fluid as fluid
+        import numpy as np
+
+        # 构建模型
+        main_prog = fluid.Program()
+        startup_prog = fluid.Program()
+        with fluid.program_guard(main_prog, startup_prog):
+            data = fluid.layers.data(name="img", shape=[64, 784], append_batch_size=False)
+            w = fluid.layers.create_parameter(shape=[784, 200], dtype='float32')
+            b = fluid.layers.create_parameter(shape=[200], dtype='float32')
+            hidden_w = fluid.layers.matmul(x=data, y=w)
+            hidden_b = fluid.layers.elementwise_add(hidden_w, b)
+        place = fluid.CPUPlace()
+        exe = fluid.Executor(place)
+        exe.run(startup_prog)
+
+        # 保存预测模型
+        path = "./infer_model"
+        fluid.io.save_inference_model(dirname=path, feeded_var_names=['img'],target_vars=[hidden_b], executor=exe, main_program=main_prog)
+
+        # 示例一: 不需要指定分布式查找表的模型加载示例，即训练时未用到distributed lookup table。
+        [inference_program, feed_target_names, fetch_targets] = (fluid.io.load_inference_model(dirname=path, executor=exe))
+        tensor_img = np.array(np.random.random((1, 64, 784)), dtype=np.float32)
+        results = exe.run(inference_program,
+                  feed={feed_target_names[0]: tensor_img},
+                  fetch_list=fetch_targets)
+
+        # 示例二: 若训练时使用了distributed lookup table，则模型加载时需要通过endpoints参数指定pserver服务器结点列表。
+        # pserver服务器结点列表主要用于分布式查找表进行ID查找时使用。下面的["127.0.0.1:2023","127.0.0.1:2024"]仅为一个样例。
+        endpoints = ["127.0.0.1:2023","127.0.0.1:2024"]
+        [dist_inference_program, dist_feed_target_names, dist_fetch_targets] = (
+            fluid.io.load_inference_model(dirname=path,
+                                          executor=exe,
+                                          pserver_endpoints=endpoints))
+
+        # 在上述示例中，inference program 被保存在“ ./infer_model/__model__”文件内，
+        # 参数保存在“./infer_mode ”单独的若干文件内。
+        # 加载 inference program 后， executor可使用 fetch_targets 和 feed_target_names 执行Program，并得到预测结果。
+
+
+
+
+
+
+

doc/fluid/api_cn/io_cn/load_params_cn.rst

-.. _cn_api_fluid_io_load_params:
-
-load_params
--------------------------------
-
-.. py:function:: paddle.fluid.io.load_params(executor, dirname, main_program=None, filename=None)
-
-该接口从指定的 ``main_program`` 中筛选出所有模型参数变量，并根据目录 ``dirname``  或 ``filename`` 提供的参数文件对这些模型参数进行赋值。
-
-使用 ``dirname`` 指定模型参数的存储路径。若模型参数变量以分离文件的形式存储在 ``dirname`` 指定的目录下，则设置 ``filename`` 值为None；若所有模型参数存储在一个单独的二进制文件中，则使用 ``filename`` 来指明这个二进制文件。
-
-注意：
-  - 有些变量不是参数，如学习率、全局训练步数（global step）等，但它们之于训练却是必要的。因此，调用 :ref:`cn_api_fluid_io_save_params` 和 :ref:`cn_api_fluid_io_load_params` 来保存和加载参数对于断点训练是不够的，这种情况下可以使用 :ref:`cn_api_fluid_io_save_persistables` 和 :ref:`cn_api_fluid_io_load_persistables` 来保存和加载训练过程的检查点（checkpoint）。
-  - 若希望同时加载预训练后的模型结构和模型参数以用于预测过程，则可使用 :ref:`cn_api_fluid_io_load_inference_model` 接口。更多细节请参考 :ref:`api_guide_model_save_reader` 。
-
-参数:
-    - **executor**  (Executor) – 加载模型参数的 ``executor`` （详见 :ref:`api_guide_executor` ） 。
-    - **dirname**  (str) – 模型参数的存储路径。
-    - **main_program**  (Program，可选) – 筛选模型参数变量所依据的 ``Program`` （详见 :ref:`api_guide_Program` ）。若为None, 则使用全局默认的  ``default_main_program`` 。默认值为None。
-    - **filename**  (str，可选) – 若模型参数是以若干文件形式存储在 ``dirname`` 指定的目录下，则设置 ``filename`` 值为None。反之，需要通过 ``filename`` 来指明单一模型参数存储文件的名称。 默认值为None。
-
-**返回:** 无
-
-**代码示例**
-
-.. code-block:: python
-
-    import paddle.fluid as fluid
-
-    exe = fluid.Executor(fluid.CPUPlace())
-    param_path = "./my_paddle_model"
-    prog = fluid.default_main_program()
-    fluid.io.load_params(executor=exe, dirname=param_path,
-                        main_program=None)
-
-
-
-
-
-
-
+.. _cn_api_fluid_io_load_params:
+
+load_params
+-------------------------------
+
+**注意：该API仅支持【静态图】模式**
+
+.. py:function:: paddle.fluid.io.load_params(executor, dirname, main_program=None, filename=None)
+
+该接口从指定的 ``main_program`` 中筛选出所有模型参数变量，并根据目录 ``dirname``  或 ``filename`` 提供的参数文件对这些模型参数进行赋值。
+
+使用 ``dirname`` 指定模型参数的存储路径。若模型参数变量以分离文件的形式存储在 ``dirname`` 指定的目录下，则设置 ``filename`` 值为None；若所有模型参数存储在一个单独的二进制文件中，则使用 ``filename`` 来指明这个二进制文件。
+
+注意：
+  - 有些变量不是参数，如学习率、全局训练步数（global step）等，但它们之于训练却是必要的。因此，调用 :ref:`cn_api_fluid_io_save_params` 和 :ref:`cn_api_fluid_io_load_params` 来保存和加载参数对于断点训练是不够的，这种情况下可以使用 :ref:`cn_api_fluid_io_save_persistables` 和 :ref:`cn_api_fluid_io_load_persistables` 来保存和加载训练过程的检查点（checkpoint）。
+  - 若希望同时加载预训练后的模型结构和模型参数以用于预测过程，则可使用 :ref:`cn_api_fluid_io_load_inference_model` 接口。更多细节请参考 :ref:`api_guide_model_save_reader` 。
+
+参数:
+    - **executor**  (Executor) – 加载模型参数的 ``executor`` （详见 :ref:`api_guide_executor` ） 。
+    - **dirname**  (str) – 模型参数的存储路径。
+    - **main_program**  (Program，可选) – 筛选模型参数变量所依据的 ``Program`` （详见 :ref:`api_guide_Program` ）。若为None, 则使用全局默认的  ``default_main_program`` 。默认值为None。
+    - **filename**  (str，可选) – 若模型参数是以若干文件形式存储在 ``dirname`` 指定的目录下，则设置 ``filename`` 值为None。反之，需要通过 ``filename`` 来指明单一模型参数存储文件的名称。 默认值为None。
+
+**返回:** 无
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+
+    exe = fluid.Executor(fluid.CPUPlace())
+    param_path = "./my_paddle_model"
+    prog = fluid.default_main_program()
+    fluid.io.load_params(executor=exe, dirname=param_path,
+                        main_program=None)
+
+
+
+
+
+
+

doc/fluid/api_cn/io_cn/load_persistables_cn.rst

-.. _cn_api_fluid_io_load_persistables:
-
-load_persistables
--------------------------------
-
-.. py:function:: paddle.fluid.io.load_persistables(executor, dirname, main_program=None, filename=None)
-
-该接口从给定的 ``main_program`` 中取出所有 ``persistable==True`` 的变量（即持久性变量，详见 :ref:`api_guide_model_save_reader` ），并根据目录 ``dirname``  或 ``filename`` 提供的参数文件对这些持久性变量进行赋值。
-
-使用 ``dirname`` 指定持久性变量的存储路径。若持久性变量以分离文件的形式保存在 ``dirname`` 指定的目录下，则设置 ``filename`` 值为None；若所有持久性变量保存在一个单独的二进制文件中，则使用 ``filename`` 来指明这个二进制文件。
-
-参数:
-    - **executor**  (Executor) – 加载持久性变量的 ``executor`` （详见 :ref:`api_guide_executor` ） 。
-    - **dirname**  (str) – 持久性变量的存储路径。
-    - **main_program**  (Program，可选) – 筛选模型中持久性变量所依据的 ``Program`` （详见 :ref:`api_guide_Program` ）。若为None, 则使用全局默认的  ``default_main_program`` 。默认值为None。
-    - **filename**  (str，可选) – 若模型中的持久性变量是以若干文件形式存储在 ``dirname`` 指定的目录下，则设置 ``filename`` 值为None。反之，需要通过 ``filename`` 来指明单一模型持久性变量存储文件的名称。 默认值为None。
-
-**返回：** 无
-  
-**代码示例**
-
-.. code-block:: python
-
-    import paddle.fluid as fluid
-
-    exe = fluid.Executor(fluid.CPUPlace())
-    param_path = "./my_paddle_model"
-    prog = fluid.default_main_program()
-    fluid.io.load_persistables(executor=exe, dirname=param_path,
-                               main_program=None)
- 
-
-
-
-
-
-
+.. _cn_api_fluid_io_load_persistables:
+
+load_persistables
+-------------------------------
+
+**注意：该API仅支持【静态图】模式**
+
+.. py:function:: paddle.fluid.io.load_persistables(executor, dirname, main_program=None, filename=None)
+
+该接口从给定的 ``main_program`` 中取出所有 ``persistable==True`` 的变量（即持久性变量，详见 :ref:`api_guide_model_save_reader` ），并根据目录 ``dirname``  或 ``filename`` 提供的参数文件对这些持久性变量进行赋值。
+
+使用 ``dirname`` 指定持久性变量的存储路径。若持久性变量以分离文件的形式保存在 ``dirname`` 指定的目录下，则设置 ``filename`` 值为None；若所有持久性变量保存在一个单独的二进制文件中，则使用 ``filename`` 来指明这个二进制文件。
+
+参数:
+    - **executor**  (Executor) – 加载持久性变量的 ``executor`` （详见 :ref:`api_guide_executor` ） 。
+    - **dirname**  (str) – 持久性变量的存储路径。
+    - **main_program**  (Program，可选) – 筛选模型中持久性变量所依据的 ``Program`` （详见 :ref:`api_guide_Program` ）。若为None, 则使用全局默认的  ``default_main_program`` 。默认值为None。
+    - **filename**  (str，可选) – 若模型中的持久性变量是以若干文件形式存储在 ``dirname`` 指定的目录下，则设置 ``filename`` 值为None。反之，需要通过 ``filename`` 来指明单一模型持久性变量存储文件的名称。 默认值为None。
+
+**返回：** 无
+  
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+
+    exe = fluid.Executor(fluid.CPUPlace())
+    param_path = "./my_paddle_model"
+    prog = fluid.default_main_program()
+    fluid.io.load_persistables(executor=exe, dirname=param_path,
+                               main_program=None)
+ 
+
+
+
+
+
+

doc/fluid/api_cn/io_cn/save_cn.rst

@@ -3,6 +3,8 @@
 save
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.io.save(program, model_path)
 
 该接口将传入的参数、优化器信息和网络描述保存到 ``model_path`` 。

doc/fluid/api_cn/io_cn/save_inference_model_cn.rst

-.. _cn_api_fluid_io_save_inference_model:
-
-save_inference_model
--------------------------------
-
-.. py:function:: paddle.fluid.io.save_inference_model(dirname, feeded_var_names, target_vars, executor, main_program=None, model_filename=None, params_filename=None, export_for_deployment=True,  program_only=False)
-
-修剪指定的 ``main_program`` 以构建一个专门用于预测的 ``Inference Program`` （ ``Program`` 含义详见 :ref:`api_guide_Program` ）。 所得到的 ``Inference Program`` 及其对应的所有相关参数均被保存到 ``dirname`` 指定的目录中。若只想保存训练后的模型参数，请使用 :ref:`cn_api_fluid_io_save_params` 接口。更多细节请参考 :ref:`api_guide_model_save_reader` 。
-
-**注意：dirname用于指定保存预测模型结构和参数的目录。若需要将模型参数保存在指定目录的若干文件中，请设置params_filename的值为None; 若需要将所有模型参数保存在一个单独的二进制文件中，请使用params_filename来指定该二进制文件的名称。**
-
-参数:
-  - **dirname** (str) – 指定保存预测模型结构和参数的文件目录。
-  - **feeded_var_names** (list[str]) – 字符串列表，包含着Inference Program预测时所需提供数据的所有变量名称（即所有输入变量的名称）。
-  - **target_vars** (list[Variable]) – ``Variable`` （详见 :ref:`api_guide_Program` ）类型列表，包含着模型的所有输出变量。通过这些输出变量即可得到模型的预测结果。
-  - **executor** (Executor) –  用于保存预测模型的 ``executor`` ，详见 :ref:`api_guide_executor` 。
-  - **main_program** (Program，可选) – 通过该参数指定的 ``main_program`` 可构建一个专门用于预测的 ``Inference Program`` 。 若为None, 则使用全局默认的  ``_main_program_`` 。默认值为None。
-  - **model_filename** (str，可选) – 保存预测模型结构 ``Inference Program`` 的文件名称。若设置为None，则使用 ``__model__`` 作为默认的文件名。
-  - **params_filename** (str，可选) – 保存预测模型所有相关参数的文件名称。若设置为None，则模型参数被保存在单独的文件中。
-  - **export_for_deployment** (bool，可选) – 若为True，则 ``main_program`` 指定的Program将被修改为只支持直接预测部署的Program。否则，将存储更多的信息，方便优化和再训练。目前只支持设置为True，且默认值为True。
-  - **program_only** (bool，可选) – 若为True，则只保存预测模型的网络结构，而不保存预测模型的网络参数。默认值为False。
-
-
-**返回：** 用于获取模型预测结果的所有输出变量的名称列表。
-
-**返回类型：** 列表（list）
-
-抛出异常：
- - ``ValueError`` – 若 ``feed_var_names`` 不是字符串列表，则抛出异常。
- - ``ValueError`` – 若 ``target_vars`` 不是 ``Variable`` 类型列表，则抛出异常。
-
-**代码示例**
-
-.. code-block:: python
-
-    import paddle.fluid as fluid
-
-    path = "./infer_model"
-
-    # 用户定义网络，此处以softmax回归为例
-    image = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
-    label = fluid.layers.data(name='label', shape=[1], dtype='int64')
-    feeder = fluid.DataFeeder(feed_list=[image, label], place=fluid.CPUPlace())
-    predict = fluid.layers.fc(input=image, size=10, act='softmax')
-
-    loss = fluid.layers.cross_entropy(input=predict, label=label)
-    avg_loss = fluid.layers.mean(loss)
-
-    exe = fluid.Executor(fluid.CPUPlace())
-    exe.run(fluid.default_startup_program())
-
-    # 数据输入及训练过程
-
-    # 保存预测模型。注意，用于预测的模型网络结构不需要保存标签和损失。
-    fluid.io.save_inference_model(dirname=path, feeded_var_names=['img'], target_vars=[predict], executor=exe)
-
-    # 在这个示例中，save_inference_mode接口将根据网络的输入结点（img）和输出结点（predict）修剪默认的主程序（_main_program_）。
-    # 修剪得到的Inference Program将被保存在 “./infer_model/__model__”文件中，
-    # 模型参数将被保存在“./infer_model/”文件夹下以各自名称命名的单独文件中。
-
-
-
-
-
-
-
-
+.. _cn_api_fluid_io_save_inference_model:
+
+save_inference_model
+-------------------------------
+
+**注意：该API仅支持【静态图】模式**
+
+.. py:function:: paddle.fluid.io.save_inference_model(dirname, feeded_var_names, target_vars, executor, main_program=None, model_filename=None, params_filename=None, export_for_deployment=True,  program_only=False)
+
+修剪指定的 ``main_program`` 以构建一个专门用于预测的 ``Inference Program`` （ ``Program`` 含义详见 :ref:`api_guide_Program` ）。 所得到的 ``Inference Program`` 及其对应的所有相关参数均被保存到 ``dirname`` 指定的目录中。若只想保存训练后的模型参数，请使用 :ref:`cn_api_fluid_io_save_params` 接口。更多细节请参考 :ref:`api_guide_model_save_reader` 。
+
+**注意：dirname用于指定保存预测模型结构和参数的目录。若需要将模型参数保存在指定目录的若干文件中，请设置params_filename的值为None; 若需要将所有模型参数保存在一个单独的二进制文件中，请使用params_filename来指定该二进制文件的名称。**
+
+参数:
+  - **dirname** (str) – 指定保存预测模型结构和参数的文件目录。
+  - **feeded_var_names** (list[str]) – 字符串列表，包含着Inference Program预测时所需提供数据的所有变量名称（即所有输入变量的名称）。
+  - **target_vars** (list[Variable]) – ``Variable`` （详见 :ref:`api_guide_Program` ）类型列表，包含着模型的所有输出变量。通过这些输出变量即可得到模型的预测结果。
+  - **executor** (Executor) –  用于保存预测模型的 ``executor`` ，详见 :ref:`api_guide_executor` 。
+  - **main_program** (Program，可选) – 通过该参数指定的 ``main_program`` 可构建一个专门用于预测的 ``Inference Program`` 。 若为None, 则使用全局默认的  ``_main_program_`` 。默认值为None。
+  - **model_filename** (str，可选) – 保存预测模型结构 ``Inference Program`` 的文件名称。若设置为None，则使用 ``__model__`` 作为默认的文件名。
+  - **params_filename** (str，可选) – 保存预测模型所有相关参数的文件名称。若设置为None，则模型参数被保存在单独的文件中。
+  - **export_for_deployment** (bool，可选) – 若为True，则 ``main_program`` 指定的Program将被修改为只支持直接预测部署的Program。否则，将存储更多的信息，方便优化和再训练。目前只支持设置为True，且默认值为True。
+  - **program_only** (bool，可选) – 若为True，则只保存预测模型的网络结构，而不保存预测模型的网络参数。默认值为False。
+
+
+**返回：** 用于获取模型预测结果的所有输出变量的名称列表。
+
+**返回类型：** 列表（list）
+
+抛出异常：
+ - ``ValueError`` – 若 ``feed_var_names`` 不是字符串列表，则抛出异常。
+ - ``ValueError`` – 若 ``target_vars`` 不是 ``Variable`` 类型列表，则抛出异常。
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+
+    path = "./infer_model"
+
+    # 用户定义网络，此处以softmax回归为例
+    image = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
+    label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+    feeder = fluid.DataFeeder(feed_list=[image, label], place=fluid.CPUPlace())
+    predict = fluid.layers.fc(input=image, size=10, act='softmax')
+
+    loss = fluid.layers.cross_entropy(input=predict, label=label)
+    avg_loss = fluid.layers.mean(loss)
+
+    exe = fluid.Executor(fluid.CPUPlace())
+    exe.run(fluid.default_startup_program())
+
+    # 数据输入及训练过程
+
+    # 保存预测模型。注意，用于预测的模型网络结构不需要保存标签和损失。
+    fluid.io.save_inference_model(dirname=path, feeded_var_names=['img'], target_vars=[predict], executor=exe)
+
+    # 在这个示例中，save_inference_mode接口将根据网络的输入结点（img）和输出结点（predict）修剪默认的主程序（_main_program_）。
+    # 修剪得到的Inference Program将被保存在 “./infer_model/__model__”文件中，
+    # 模型参数将被保存在“./infer_model/”文件夹下以各自名称命名的单独文件中。
+
+
+
+
+
+
+
+

doc/fluid/api_cn/io_cn/save_params_cn.rst

-.. _cn_api_fluid_io_save_params:
-
-save_params
--------------------------------
-
-.. py:function:: paddle.fluid.io.save_params(executor, dirname, main_program=None, filename=None)
-
-该OP从 ``main_program`` 中取出所有参数，然后将它们保存到 ``dirname`` 目录下或名为 ``filename`` 的文件中。
-
-``dirname`` 用于指定保存参数的目标路径。若想将参数保存到多个独立文件中，设置 ``filename=None`` ； 若想将所有参数保存在单个文件中，请设置 ``filename`` 来指定该文件的名称。
-
-注意：
-   - 有些变量不是参数，如学习率，全局训练步数（global step）等，但它们对于训练却是必要的。因此，调用 :ref:`cn_api_fluid_io_save_params` 和 :ref:`cn_api_fluid_io_load_params` 来保存和加载参数对于断点训练是不够的，这种情况下可以使用 :ref:`cn_api_fluid_io_save_persistables` 和 :ref:`cn_api_fluid_io_load_persistables` 来保存和加载训练过程中的检查点（checkpoint）。
-   - 如果您想要储存您的模型用于预测，请使用 :ref:`cn_api_fluid_io_save_inference_model` 。更多细节请参考 :ref:`api_guide_model_save_reader` 
-
-参数:
- - **executor**  (Executor) – 用于保存参数的 ``executor`` ，详见 :ref:`api_guide_executor` 。
- - **dirname**  (str) – 指定保存参数的文件目录。
- - **main_program**  (Program，可选) – 需要保存参数的Program（ ``Program`` 含义详见 :ref:`api_guide_Program` ）。如果为None，则使用default_main_Program 。默认值为None。
- - **filename**  (str，可选) – 保存参数的文件名称。若需要将参数保存到多个独立的文件中，请设置 ``filename=None`` 。默认值为None。
- 
-返回: 无
-  
-**代码示例**
-
-.. code-block:: python
-    
-    import paddle.fluid as fluid
-    
-    params_path = "./my_paddle_model"
-    image = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
-    label = fluid.layers.data(name='label', shape=[1], dtype='int64')
-    feeder = fluid.DataFeeder(feed_list=[image, label], place=fluid.CPUPlace())
-    predict = fluid.layers.fc(input=image, size=10, act='softmax')
-
-    loss = fluid.layers.cross_entropy(input=predict, label=label)
-    avg_loss = fluid.layers.mean(loss)
-
-    exe = fluid.Executor(fluid.CPUPlace())
-    exe.run(fluid.default_startup_program())
-    fluid.io.save_params(executor=exe, dirname=params_path)
-    # 网络中fc层的参数weight和bias将会分别存储在"./my_paddle_model"路径下。                    
-
+.. _cn_api_fluid_io_save_params:
+
+save_params
+-------------------------------
+
+**注意：该API仅支持【静态图】模式**
+
+.. py:function:: paddle.fluid.io.save_params(executor, dirname, main_program=None, filename=None)
+
+该OP从 ``main_program`` 中取出所有参数，然后将它们保存到 ``dirname`` 目录下或名为 ``filename`` 的文件中。
+
+``dirname`` 用于指定保存参数的目标路径。若想将参数保存到多个独立文件中，设置 ``filename=None`` ； 若想将所有参数保存在单个文件中，请设置 ``filename`` 来指定该文件的名称。
+
+注意：
+   - 有些变量不是参数，如学习率，全局训练步数（global step）等，但它们对于训练却是必要的。因此，调用 :ref:`cn_api_fluid_io_save_params` 和 :ref:`cn_api_fluid_io_load_params` 来保存和加载参数对于断点训练是不够的，这种情况下可以使用 :ref:`cn_api_fluid_io_save_persistables` 和 :ref:`cn_api_fluid_io_load_persistables` 来保存和加载训练过程中的检查点（checkpoint）。
+   - 如果您想要储存您的模型用于预测，请使用 :ref:`cn_api_fluid_io_save_inference_model` 。更多细节请参考 :ref:`api_guide_model_save_reader` 
+
+参数:
+ - **executor**  (Executor) – 用于保存参数的 ``executor`` ，详见 :ref:`api_guide_executor` 。
+ - **dirname**  (str) – 指定保存参数的文件目录。
+ - **main_program**  (Program，可选) – 需要保存参数的Program（ ``Program`` 含义详见 :ref:`api_guide_Program` ）。如果为None，则使用default_main_Program 。默认值为None。
+ - **filename**  (str，可选) – 保存参数的文件名称。若需要将参数保存到多个独立的文件中，请设置 ``filename=None`` 。默认值为None。
+ 
+返回: 无
+  
+**代码示例**
+
+.. code-block:: python
+    
+    import paddle.fluid as fluid
+    
+    params_path = "./my_paddle_model"
+    image = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
+    label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+    feeder = fluid.DataFeeder(feed_list=[image, label], place=fluid.CPUPlace())
+    predict = fluid.layers.fc(input=image, size=10, act='softmax')
+
+    loss = fluid.layers.cross_entropy(input=predict, label=label)
+    avg_loss = fluid.layers.mean(loss)
+
+    exe = fluid.Executor(fluid.CPUPlace())
+    exe.run(fluid.default_startup_program())
+    fluid.io.save_params(executor=exe, dirname=params_path)
+    # 网络中fc层的参数weight和bias将会分别存储在"./my_paddle_model"路径下。                    
+

doc/fluid/api_cn/io_cn/save_persistables_cn.rst

-.. _cn_api_fluid_io_save_persistables:
-
-save_persistables
--------------------------------
-
-.. py:function:: paddle.fluid.io.save_persistables(executor, dirname, main_program=None, filename=None)
-
-该OP从给定 ``main_program`` 中取出所有持久性变量（详见 :ref:`api_guide_model_save_reader` ），然后将它们保存到目录 ``dirname`` 中或 ``filename`` 指定的文件中。
-
-``dirname`` 用于指定保存持久性变量的目录。如果想将持久性变量保存到指定目录的若干文件中，请设置 ``filename=None`` ; 若想将所有持久性变量保存在同一个文件中，请设置 ``filename`` 来指定文件的名称。
-
-参数:
- - **executor**  (Executor) – 用于保存持久性变量的 ``executor`` ，详见 :ref:`api_guide_executor` 。
- - **dirname**  (str) – 用于储存持久性变量的文件目录。
- - **main_program**  (Program，可选) – 需要保存持久性变量的Program（ ``Program`` 含义详见 :ref:`api_guide_Program` ）。如果为None，则使用default_main_Program 。默认值为None。
- - **filename**  (str，可选) – 保存持久性变量的文件名称。若想分开保存变量，设置 ``filename=None`` 。 默认值为None。
- 
-返回: 无
-  
-**代码示例**
-
-.. code-block:: python
-    
-    import paddle.fluid as fluid
-
-    dir_path = "./my_paddle_model"
-    file_name = "persistables"
-    image = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
-    label = fluid.layers.data(name='label', shape=[1], dtype='int64')
-    feeder = fluid.DataFeeder(feed_list=[image, label], place=fluid.CPUPlace())
-    predict = fluid.layers.fc(input=image, size=10, act='softmax')
-
-    loss = fluid.layers.cross_entropy(input=predict, label=label)
-    avg_loss = fluid.layers.mean(loss)
-
-    exe = fluid.Executor(fluid.CPUPlace())
-    exe.run(fluid.default_startup_program())
-    fluid.io.save_persistables(executor=exe, dirname=dir_path, filename=file_name)
-    # 网络中fc层中的持久性变量weight和bia将会保存在路径“./my_paddle_model”下名为"persistables"的文件中。
-    
-
-
-
-
-
-
+.. _cn_api_fluid_io_save_persistables:
+
+save_persistables
+-------------------------------
+
+**注意：该API仅支持【静态图】模式**
+
+.. py:function:: paddle.fluid.io.save_persistables(executor, dirname, main_program=None, filename=None)
+
+该OP从给定 ``main_program`` 中取出所有持久性变量（详见 :ref:`api_guide_model_save_reader` ），然后将它们保存到目录 ``dirname`` 中或 ``filename`` 指定的文件中。
+
+``dirname`` 用于指定保存持久性变量的目录。如果想将持久性变量保存到指定目录的若干文件中，请设置 ``filename=None`` ; 若想将所有持久性变量保存在同一个文件中，请设置 ``filename`` 来指定文件的名称。
+
+参数:
+ - **executor**  (Executor) – 用于保存持久性变量的 ``executor`` ，详见 :ref:`api_guide_executor` 。
+ - **dirname**  (str) – 用于储存持久性变量的文件目录。
+ - **main_program**  (Program，可选) – 需要保存持久性变量的Program（ ``Program`` 含义详见 :ref:`api_guide_Program` ）。如果为None，则使用default_main_Program 。默认值为None。
+ - **filename**  (str，可选) – 保存持久性变量的文件名称。若想分开保存变量，设置 ``filename=None`` 。 默认值为None。
+ 
+返回: 无
+  
+**代码示例**
+
+.. code-block:: python
+    
+    import paddle.fluid as fluid
+
+    dir_path = "./my_paddle_model"
+    file_name = "persistables"
+    image = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
+    label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+    feeder = fluid.DataFeeder(feed_list=[image, label], place=fluid.CPUPlace())
+    predict = fluid.layers.fc(input=image, size=10, act='softmax')
+
+    loss = fluid.layers.cross_entropy(input=predict, label=label)
+    avg_loss = fluid.layers.mean(loss)
+
+    exe = fluid.Executor(fluid.CPUPlace())
+    exe.run(fluid.default_startup_program())
+    fluid.io.save_persistables(executor=exe, dirname=dir_path, filename=file_name)
+    # 网络中fc层中的持久性变量weight和bia将会保存在路径“./my_paddle_model”下名为"persistables"的文件中。
+    
+
+
+
+
+
+

doc/fluid/api_cn/io_cn/save_vars_cn.rst

-.. _cn_api_fluid_io_save_vars:
-
-save_vars
--------------------------------
-
-.. py:function:: paddle.fluid.io.save_vars(executor, dirname, main_program=None, vars=None, predicate=None, filename=None)
-
-该接口将 ``Program`` 的变量保存到文件中。
-
-通过 ``vars`` 指定需要保存的变量，或者通过 ``predicate`` 筛选需要保存的变量， ``vars`` 和 ``predicate`` 不能同时为None。
-
-参数：
-      - **executor** （Executor）- 运行的执行器，执行器的介绍请参考 :ref:`api_guide_model_save_reader` 。
-      - **dirname** （str）- 保存变量的目录路径。
-      - **main_program** （Program，可选）- 需要保存变量的 ``Program`` ， ``Program`` 的介绍请参考 :ref:`api_guide_Program` 。如果 ``main_program`` 为None，则使用默认的主程序。默认值为None。
-      - **vars** （list [Variable]，可选）- 通过该列表指定需要保存的变量。默认值为None。
-      - **predicate** （function，可选）- 通过该函数筛选 :math:`predicate(variable)== True` 的变量进行保存。如果通过 ``vars`` 指定了需要保存的变量，则该参数无效。默认值为None。
-      - **filename** （str，可选）- 保存所有变量的文件。如果设置为None，所有变量会按照变量名称单独保存成文件；如果设置为非None，所有变量会保存成一个文件名为该设置值的文件。默认值为None。
-
-返回：无    
-
-抛出异常：
-    - ``TypeError`` - 如果main_program不是Program的实例，也不是None。
-
-**代码示例**
-
-.. code-block:: python
-      
-      import paddle.fluid as fluid
-      main_prog = fluid.Program()
-      startup_prog = fluid.Program()
-      with fluid.program_guard(main_prog, startup_prog):
-          data = fluid.layers.data(name="img", shape=[64, 784], append_batch_size=False)
-          w = fluid.layers.create_parameter(shape=[784, 200], dtype='float32', name='fc_w')
-          b = fluid.layers.create_parameter(shape=[200], dtype='float32', name='fc_b')
-          hidden_w = fluid.layers.matmul(x=data, y=w)
-          hidden_b = fluid.layers.elementwise_add(hidden_w, b)
-      place = fluid.CPUPlace()
-      exe = fluid.Executor(place)
-      exe.run(startup_prog)
-     
-      # 示例一：用vars来指定变量。
-      var_list = [w, b]
-      path = "./my_paddle_vars"
-      fluid.io.save_vars(executor=exe, dirname=path, vars=var_list,
-                         filename="vars_file")
-      # w, b 将被保存，使用同一文件名“var_file”，保存在路径“./my_paddle_vars”下。
-
-      # 示例二：通过predicate筛选变量。
-      def name_has_fc(var):
-          res = "fc" in var.name
-          return res
-
-      param_path = "./my_paddle_model"
-      fluid.io.save_vars(executor=exe, dirname=param_path, main_program=main_prog, vars=None, predicate = name_has_fc)
-      # 将main_program中名中包含“fc”的的所有变量保存。
-      # 变量将分开保存。
-
-
-
-
-
+.. _cn_api_fluid_io_save_vars:
+
+save_vars
+-------------------------------
+
+**注意：该API仅支持【静态图】模式**
+
+.. py:function:: paddle.fluid.io.save_vars(executor, dirname, main_program=None, vars=None, predicate=None, filename=None)
+
+该接口将 ``Program`` 的变量保存到文件中。
+
+通过 ``vars`` 指定需要保存的变量，或者通过 ``predicate`` 筛选需要保存的变量， ``vars`` 和 ``predicate`` 不能同时为None。
+
+参数：
+      - **executor** （Executor）- 运行的执行器，执行器的介绍请参考 :ref:`api_guide_model_save_reader` 。
+      - **dirname** （str）- 保存变量的目录路径。
+      - **main_program** （Program，可选）- 需要保存变量的 ``Program`` ， ``Program`` 的介绍请参考 :ref:`api_guide_Program` 。如果 ``main_program`` 为None，则使用默认的主程序。默认值为None。
+      - **vars** （list [Variable]，可选）- 通过该列表指定需要保存的变量。默认值为None。
+      - **predicate** （function，可选）- 通过该函数筛选 :math:`predicate(variable)== True` 的变量进行保存。如果通过 ``vars`` 指定了需要保存的变量，则该参数无效。默认值为None。
+      - **filename** （str，可选）- 保存所有变量的文件。如果设置为None，所有变量会按照变量名称单独保存成文件；如果设置为非None，所有变量会保存成一个文件名为该设置值的文件。默认值为None。
+
+返回：无    
+
+抛出异常：
+    - ``TypeError`` - 如果main_program不是Program的实例，也不是None。
+
+**代码示例**
+
+.. code-block:: python
+      
+      import paddle.fluid as fluid
+      main_prog = fluid.Program()
+      startup_prog = fluid.Program()
+      with fluid.program_guard(main_prog, startup_prog):
+          data = fluid.layers.data(name="img", shape=[64, 784], append_batch_size=False)
+          w = fluid.layers.create_parameter(shape=[784, 200], dtype='float32', name='fc_w')
+          b = fluid.layers.create_parameter(shape=[200], dtype='float32', name='fc_b')
+          hidden_w = fluid.layers.matmul(x=data, y=w)
+          hidden_b = fluid.layers.elementwise_add(hidden_w, b)
+      place = fluid.CPUPlace()
+      exe = fluid.Executor(place)
+      exe.run(startup_prog)
+     
+      # 示例一：用vars来指定变量。
+      var_list = [w, b]
+      path = "./my_paddle_vars"
+      fluid.io.save_vars(executor=exe, dirname=path, vars=var_list,
+                         filename="vars_file")
+      # w, b 将被保存，使用同一文件名“var_file”，保存在路径“./my_paddle_vars”下。
+
+      # 示例二：通过predicate筛选变量。
+      def name_has_fc(var):
+          res = "fc" in var.name
+          return res
+
+      param_path = "./my_paddle_model"
+      fluid.io.save_vars(executor=exe, dirname=param_path, main_program=main_prog, vars=None, predicate = name_has_fc)
+      # 将main_program中名中包含“fc”的的所有变量保存。
+      # 变量将分开保存。
+
+
+
+
+

doc/fluid/api_cn/layers_cn/BeamSearchDecoder_cn.rst

@@ -4,6 +4,8 @@ BeamSearchDecoder
 -------------------------------
 
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:class:: paddle.fluid.layers.BeamSearchDecoder(cell, start_token, end_token, beam_size, embedding_fn=None, output_fn=None)
     
 带beam search解码策略的解码器。该接口包装一个cell来计算概率，然后执行一个beam search步骤计算得分，并为每个解码步骤选择候选输出。更多详细信息请参阅 `Beam search <https://en.wikipedia.org/wiki/Beam_search>`_

doc/fluid/api_cn/layers_cn/Decoder_cn.rst

@@ -4,6 +4,8 @@ Decoder
 -------------------------------
 
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:class:: paddle.fluid.layers.Decoder()
 
     

doc/fluid/api_cn/layers_cn/DynamicRNN_cn.rst

@@ -3,6 +3,8 @@
 DynamicRNN
 ===================
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:class:: paddle.fluid.layers.DynamicRNN(name=None)
 
 **注意：该类型的输入仅支持LoDTensor，如果您需要处理的输入数据是Tensor类型，

doc/fluid/api_cn/layers_cn/GRUCell_cn.rst

@@ -3,6 +3,8 @@
 GRUCell
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:class:: paddle.fluid.layers.GRUCell(hidden_size, param_attr=None, bias_attr=None, gate_activation=None, activation=None, dtype="float32", name="GRUCell")
     
 门控循环单元（Gated Recurrent Unit）。通过对 :code:`fluid.contrib.layers.rnn_impl.BasicGRUUnit` 包装，来让它可以应用于RNNCell。

doc/fluid/api_cn/layers_cn/IfElse_cn.rst

@@ -3,6 +3,8 @@
 IfElse
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:class:: paddle.fluid.layers.IfElse(cond, name=None)
 
 该类用于实现IfElse分支控制功能， IfElse包含两个Block，true_block，false_block，IfElse会将满足True或False条件的数据分别放入不同的block运行。    

doc/fluid/api_cn/layers_cn/LSTMCell_cn.rst

@@ -4,6 +4,8 @@ LSTMCell
 -------------------------------
 
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:class:: paddle.fluid.layers.LSTMCell(hidden_size, param_attr=None, bias_attr=None, gate_activation=None, activation=None, forget_bias=1.0, dtype="float32", name="LSTMCell")
     
 长短期记忆单元（Long-Short Term Memory）。通过对 :code:`fluid.contrib.layers.rnn_impl.BasicLSTMUnit` 包装，来让它可以应用于RNNCell。    

doc/fluid/api_cn/layers_cn/Print_cn.rst

@@ -3,6 +3,8 @@
 Print
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.Print(input, first_n=-1, message=None, summarize=20, print_tensor_name=True, print_tensor_type=True, print_tensor_shape=True, print_tensor_lod=True, print_phase='both')
 
 **Print操作命令**

doc/fluid/api_cn/layers_cn/RNNCell_cn.rst

@@ -4,6 +4,8 @@ RNNCell
 -------------------------------
 
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:class:: paddle.fluid.layers.RNNCell(name=None)
 RNNCell是抽象的基类，代表将输入和状态映射到输出和新状态的计算，主要用于RNN。
 

doc/fluid/api_cn/layers_cn/StaticRNN_cn.rst

@@ -3,6 +3,8 @@
 StaticRNN
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:class:: paddle.fluid.layers.StaticRNN(name=None)
 
 该OP用来处理一批序列数据，其中每个样本序列的长度必须相等。StaticRNN将序列按照时间步长展开，用户需要定义每个时间步中的处理逻辑。

doc/fluid/api_cn/layers_cn/Switch_cn.rst

@@ -3,6 +3,8 @@
 Switch
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:class:: paddle.fluid.layers.Switch (name=None)
 
 该类用于实现Switch分支控制功能。Switch分支包含多个case分支和一个default分支，Switch控制流会依次检查各case分支条件是否满足，并仅执行第一个满足条件的case分支后面的语句。若不存在满足条件的case分支，则仅执行default分支后面的语句。

doc/fluid/api_cn/layers_cn/While_cn.rst

@@ -3,6 +3,8 @@
 While
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:class:: paddle.fluid.layers.While (cond, is_test=False, name=None)
 
 

doc/fluid/api_cn/layers_cn/autoincreased_step_counter_cn.rst

@@ -3,6 +3,8 @@
 autoincreased_step_counter
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.autoincreased_step_counter(counter_name=None, begin=1, step=1)
 
 创建一个自增变量，每个迭代累加一次，默认首次返回值为 1，默认累加步长为 1。

doc/fluid/api_cn/layers_cn/batch_norm_cn.rst

@@ -3,6 +3,8 @@
 batch_norm
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.batch_norm(input, act=None, is_test=False, momentum=0.9, epsilon=1e-05, param_attr=None, bias_attr=None, data_layout='NCHW', in_place=False, name=None, moving_mean_name=None, moving_variance_name=None, do_model_average_for_mean_and_var=False, use_global_stats=False)
 
 批正则化层（Batch Normalization Layer）

doc/fluid/api_cn/layers_cn/bilinear_tensor_product_cn.rst

@@ -3,6 +3,8 @@
 bilinear_tensor_product
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.bilinear_tensor_product(x, y, size, act=None, name=None, param_attr=None, bias_attr=None)
 
 该层对两个输入执行双线性张量积。

doc/fluid/api_cn/layers_cn/case_cn.rst

@@ -3,6 +3,8 @@
 case
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.case(pred_fn_pairs, default=None, name=None)
 
 该OP的运行方式类似于python的if-elif-elif-else。

doc/fluid/api_cn/layers_cn/center_loss_cn.rst

@@ -3,6 +3,8 @@
 center_loss
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.center_loss(input, label, num_classes, alpha, param_attr, update_center=True)
 
 该OP接收一个来自于最后一个隐藏层的输出和目标标签作为输入，返回损失值。为每一个类别提供一个类别中心，计算mini-batch中每个样本与对应类别中心的距离的平均值作为center loss。

doc/fluid/api_cn/layers_cn/cond_cn.rst

@@ -3,6 +3,8 @@
 cond
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.cond(pred, true_fn=None, false_fn=None, name=None)
 
 如果 ``pred`` 是 ``True`` ，该API返回 ``true_fn()`` ，否则返回 ``false_fn()`` 。

doc/fluid/api_cn/layers_cn/conv2d_cn.rst

@@ -3,6 +3,8 @@
 conv2d
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.conv2d(input, num_filters, filter_size, stride=1, padding=0, dilation=1, groups=None, param_attr=None, bias_attr=None, use_cudnn=True, act=None, name=None, data_format="NCHW")
 
 该OP是二维卷积层（convolution2D layer），根据输入、滤波器、步长（stride）、填充（padding）、膨胀比例（dilations）一组参数计算输出特征层大小。输入和输出是NCHW或NHWC格式，其中N是批尺寸，C是通道数，H是特征高度，W是特征宽度。滤波器是MCHW格式，M是输出图像通道数，C是输入图像通道数，H是滤波器高度，W是滤波器宽度。如果组数(groups)大于1，C等于输入图像通道数除以组数的结果。详情请参考UFLDL's : `卷积 <http://ufldl.stanford.edu/tutorial/supervised/FeatureExtractionUsingConvolution/>`_ 。如果bias_attr不为False，卷积计算会添加偏置项。如果指定了激活函数类型，相应的激活函数会作用在最终结果上。

doc/fluid/api_cn/layers_cn/conv2d_transpose_cn.rst

@@ -3,6 +3,8 @@
 conv2d_transpose
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.conv2d_transpose(input, num_filters, output_size=None, filter_size=None, padding=0, stride=1, dilation=1, groups=None, param_attr=None, bias_attr=None, use_cudnn=True, act=None, name=None, data_format='NCHW')
 
 二维转置卷积层（Convlution2D transpose layer）

doc/fluid/api_cn/layers_cn/conv3d_cn.rst

@@ -3,6 +3,8 @@
 conv3d
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.conv3d(input, num_filters, filter_size, stride=1, padding=0, dilation=1, groups=None, param_attr=None, bias_attr=None, use_cudnn=True, act=None, name=None, data_format="NCDHW")
 
 该OP是三维卷积层（convolution3D layer），根据输入、滤波器、步长（stride）、填充（padding）、膨胀比例（dilations）一组参数计算得到输出特征层大小。输入和输出是NCDHW或NDWHC格式，其中N是批尺寸，C是通道数，D是特征层深度，H是特征层高度，W是特征层宽度。三维卷积（Convlution3D）和二维卷积（Convlution2D）相似，但多了一维深度信息（depth）。如果bias_attr不为False，卷积计算会添加偏置项。如果指定了激活函数类型，相应的激活函数会作用在最终结果上。

doc/fluid/api_cn/layers_cn/conv3d_transpose_cn.rst

@@ -3,6 +3,8 @@
 conv3d_transpose
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.conv3d_transpose(input, num_filters, output_size=None, filter_size=None, padding=0, stride=1, dilation=1, groups=None, param_attr=None, bias_attr=None, use_cudnn=True, act=None, name=None, data_format='NCDHW')
 
 三维转置卷积层（Convlution3D transpose layer)

doc/fluid/api_cn/layers_cn/create_parameter_cn.rst

@@ -3,6 +3,8 @@
 create_parameter
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.create_parameter(shape,dtype,name=None,attr=None,is_bias=False,default_initializer=None)
 
 该OP创建一个参数。该参数是一个可学习的变量, 拥有梯度并且可优化。

doc/fluid/api_cn/layers_cn/create_py_reader_by_data_cn.rst

@@ -3,6 +3,8 @@
 create_py_reader_by_data
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.create_py_reader_by_data(capacity,feed_list,name=None,use_double_buffer=True)
 
 创建一个Python端提供数据的reader。该OP与 :ref:`cn_api_fluid_layers_py_reader` 类似，不同点在于它能够从feed变量列表读取数据。

doc/fluid/api_cn/layers_cn/crf_decoding_cn.rst

@@ -3,6 +3,8 @@
 crf_decoding
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function::  paddle.fluid.layers.crf_decoding(input, param_attr, label=None, length=None)
 
 

doc/fluid/api_cn/layers_cn/data_cn.rst

@@ -3,6 +3,8 @@
 data
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.data(name, shape, append_batch_size=True, dtype='float32', lod_level=0, type=VarType.LOD_TENSOR, stop_gradient=True)
 
 该OP会在全局block中创建变量（Variable），该全局变量可被计算图中的算子（operator）访问。

doc/fluid/api_cn/layers_cn/data_norm_cn.rst

@@ -3,6 +3,8 @@
 data_norm
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.data_norm(input, act=None, epsilon=1e-05, param_attr=None, data_layout='NCHW', in_place=False, name=None, moving_mean_name=None, moving_variance_name=None, do_model_average_for_mean_and_var=False)
 
 **数据正则化层**

doc/fluid/api_cn/layers_cn/deformable_conv_cn.rst

@@ -3,6 +3,8 @@
 deformable_conv
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.deformable_conv(input, offset, mask, num_filters, filter_size, stride=1, padding=0, dilation=1, groups=None, deformable_groups=None, im2col_step=None, param_attr=None, bias_attr=None, modulated=True, name=None)
 
 **可变形卷积算子**

doc/fluid/api_cn/layers_cn/dynamic_gru_cn.rst

@@ -3,6 +3,8 @@
 dynamic_gru
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function::  paddle.fluid.layers.dynamic_gru(input, size, param_attr=None, bias_attr=None, is_reverse=False, gate_activation='sigmoid', candidate_activation='tanh', h_0=None, origin_mode=False)
 
 

doc/fluid/api_cn/layers_cn/dynamic_lstm_cn.rst

@@ -3,6 +3,8 @@
 dynamic_lstm
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function::  paddle.fluid.layers.dynamic_lstm(input, size, h_0=None, c_0=None, param_attr=None, bias_attr=None, use_peepholes=True, is_reverse=False, gate_activation='sigmoid', cell_activation='tanh', candidate_activation='tanh', dtype='float32', name=None)
 
 该OP实现了 LSTM，即 Long-Short Term Memory（长短期记忆）运算 - `Hochreiter, S., & Schmidhuber, J. (1997) <http://deeplearning.cs.cmu.edu/pdfs/Hochreiter97_lstm.pdf>`_。

doc/fluid/api_cn/layers_cn/dynamic_lstmp_cn.rst

@@ -2,6 +2,8 @@
 
 dynamic_lstmp
 -------------------------------
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.dynamic_lstmp(input, size, proj_size, param_attr=None, bias_attr=None, use_peepholes=True, is_reverse=False, gate_activation='sigmoid', cell_activation='tanh', candidate_activation='tanh', proj_activation='tanh', dtype='float32', name=None, h_0=None, c_0=None, cell_clip=None, proj_clip=None)
 
 .. note::

doc/fluid/api_cn/layers_cn/embedding_cn.rst

@@ -3,6 +3,8 @@
 embedding
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.embedding(input, size, is_sparse=False, is_distributed=False, padding_idx=None, param_attr=None, dtype='float32')
 
 嵌入层(Embedding Layer)

doc/fluid/api_cn/layers_cn/fc_cn.rst

@@ -3,6 +3,8 @@
 fc
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function::  paddle.fluid.layers.fc(input, size, num_flatten_dims=1, param_attr=None, bias_attr=None, act=None, name=None)
 
 

doc/fluid/api_cn/layers_cn/group_norm_cn.rst

@@ -3,6 +3,8 @@
 group_norm
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function::  paddle.fluid.layers.group_norm(input, groups, epsilon=1e-05, param_attr=None, bias_attr=None, act=None, data_layout='NCHW', name=None)
 
 参考论文： `Group Normalization <https://arxiv.org/abs/1803.08494>`_

doc/fluid/api_cn/layers_cn/gru_unit_cn.rst

@@ -3,6 +3,8 @@
 gru_unit
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.gru_unit(input, hidden, size, param_attr=None, bias_attr=None, activation='tanh', gate_activation='sigmoid', origin_mode=False)
 
 Gated Recurrent Unit（GRU）循环神经网络计算单元。该OP用于完成单个时间步内GRU的计算，支持以下两种计算方式：

doc/fluid/api_cn/layers_cn/hsigmoid_cn.rst

@@ -3,6 +3,8 @@
 hsigmoid
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.hsigmoid(input, label, num_classes, param_attr=None, bias_attr=None, name=None, path_table=None, path_code=None, is_custom=False, is_sparse=False)
 
 层次sigmoid（hierarchical sigmoid），该OP通过构建一个分类二叉树来降低计算复杂度，主要用于加速语言模型的训练过程。

doc/fluid/api_cn/layers_cn/im2sequence_cn.rst

@@ -3,6 +3,8 @@
 im2sequence
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.im2sequence(input, filter_size=1, stride=1, padding=0, input_image_size=None, out_stride=1, name=None)
 
 该OP使用 `filter` 扫描输入的Tensor并将输入Tensor转换成序列，返回值的 `shape={input.batch_size * output_height * output_width, filter_size_height* filter_size_width * input.channels}` 。返回值的timestep的个数为 `output_height * output_width` ， 每个timestep的维度是 `filter_size_height* filter_size_width * input.channels` 。其中 `output_height` 和 `output_width` 由以下式计算:

doc/fluid/api_cn/layers_cn/instance_norm_cn.rst

@@ -3,6 +3,8 @@
 instance_norm
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.instance_norm(input, epsilon=1e-05, param_attr=None, bias_attr=None, name=None)
 
 

doc/fluid/api_cn/layers_cn/layer_norm_cn.rst

@@ -3,6 +3,8 @@
 layer_norm
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.layer_norm(input, scale=True, shift=True, begin_norm_axis=1, epsilon=1e-05, param_attr=None, bias_attr=None, act=None, name=None)
 
 该OP实现了层归一化层（Layer Normalization Layer），其可以应用于小批量输入数据。更多详情请参考：`Layer Normalization <https://arxiv.org/pdf/1607.06450v1.pdf>`_

doc/fluid/api_cn/layers_cn/linear_chain_crf_cn.rst

@@ -3,6 +3,8 @@
 linear_chain_crf
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.linear_chain_crf(input, label, param_attr=None, length=None)
 
 线性链条件随机场（Linear Chain CRF）

doc/fluid/api_cn/layers_cn/lstm_cn.rst

@@ -3,6 +3,8 @@
 lstm
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function::  paddle.fluid.layers.lstm(input, init_h, init_c, max_len, hidden_size, num_layers, dropout_prob=0.0, is_bidirec=False, is_test=False, name=None, default_initializer=None, seed=-1)
 
 .. note::

doc/fluid/api_cn/layers_cn/lstm_unit_cn.rst

@@ -3,6 +3,8 @@
 lstm_unit
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.lstm_unit(x_t, hidden_t_prev, cell_t_prev, forget_bias=0.0, param_attr=None, bias_attr=None, name=None)
 
 

doc/fluid/api_cn/layers_cn/multi_box_head_cn.rst

@@ -3,6 +3,8 @@
 multi_box_head
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.multi_box_head(inputs, image, base_size, num_classes, aspect_ratios, min_ratio=None, max_ratio=None, min_sizes=None, max_sizes=None, steps=None, step_w=None, step_h=None, offset=0.5, variance=[0.1, 0.1, 0.2, 0.2], flip=True, clip=False, kernel_size=1, pad=0, stride=1, name=None, min_max_aspect_ratios_order=False)
 
 基于SSD（Single Shot MultiBox Detector）算法，在不同层输入特征上提取先验框、计算回归的坐标位置和分类的置信度，并合并到一起作为输出，具体参数解释和输出格式参考下面说明。更详细信息，请参阅SSD论文 `SSD：Single Shot MultiBox Detector <https://arxiv.org/abs/1512.02325>`_ 的2.2节。

doc/fluid/api_cn/layers_cn/nce_cn.rst

@@ -3,6 +3,8 @@
 nce
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.nce(input, label, num_total_classes, sample_weight=None, param_attr=None, bias_attr=None, num_neg_samples=None, name=None, sampler='uniform', custom_dist=None, seed=0, is_sparse=False)
 
 计算并返回噪音对比估计损失值（ noise-contrastive estimation training loss）。

doc/fluid/api_cn/layers_cn/prelu_cn.rst

@@ -3,6 +3,8 @@
 prelu
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.prelu(x, mode, param_attr=None, name=None)
 
 等式：

doc/fluid/api_cn/layers_cn/py_func_cn.rst

@@ -3,6 +3,8 @@
 py_func
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.py_func(func, x, out, backward_func=None, skip_vars_in_backward_input=None)
 
 PaddlePaddle Fluid通过py_func在Python端注册OP。py_func的设计原理在于Paddle中的LodTensor与numpy数组可以方便的互相转换，从而可使用Python中的numpy API来自定义一个Python OP。

doc/fluid/api_cn/layers_cn/py_reader_cn.rst

@@ -3,6 +3,8 @@
 py_reader
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.py_reader(capacity, shapes, dtypes, lod_levels=None, name=None, use_double_buffer=True)
 
 

doc/fluid/api_cn/layers_cn/read_file_cn.rst

@@ -3,6 +3,8 @@
 read_file
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.read_file(reader)
 
 从给定的reader中读取数据

doc/fluid/api_cn/layers_cn/row_conv_cn.rst

@@ -3,6 +3,8 @@
 row_conv
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.row_conv(input, future_context_size, param_attr=None, act=None)
 
 该接口为行卷积（Row-convolution operator）或称之为超前卷积（lookahead convolution），最早介绍于DeepSpeech2论文中，论文链接：

doc/fluid/api_cn/layers_cn/sequence_concat_cn.rst

@@ -3,6 +3,8 @@
 sequence_concat
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.sequence_concat(input, name=None)
 
 **注意：该OP的输入只能是LoDTensor，如果您需要处理的输入是Tensor类型，请使用concat函数（fluid.layers.** :ref:`cn_api_fluid_layers_concat` **）。**

doc/fluid/api_cn/layers_cn/sequence_conv_cn.rst

@@ -3,6 +3,8 @@
 sequence_conv
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.sequence_conv(input, num_filters, filter_size=3, filter_stride=1, padding=True, padding_start=None, bias_attr=None, param_attr=None, act=None, name=None)
 
 **注意：该OP的输入只能是LoDTensor，如果您需要处理的输入是Tensor类型，请使用conv2d函数（fluid.layers.** :ref:`cn_api_fluid_layers_conv2d` **）。**

doc/fluid/api_cn/layers_cn/sequence_enumerate_cn.rst

@@ -3,6 +3,8 @@
 sequence_enumerate
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.sequence_enumerate(input, win_size, pad_value=0, name=None)
 
 枚举形状为 ``[d_1, 1]`` 的输入序列所有长度为 ``win_size`` 的子序列，生成一个形状为 ``[d_1, win_size]`` 的新序列，需要时以 ``pad_value`` 填充。

doc/fluid/api_cn/layers_cn/sequence_expand_as_cn.rst

@@ -3,6 +3,8 @@
 sequence_expand_as
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.sequence_expand_as(x, y, name=None)
 
 Sequence Expand As Layer，该OP根据输入 ``y`` 的第0级lod对输入 ``x`` 进行扩展。当前实现要求 ``y`` 的lod层数（level）必须为1，且 ``x`` 的第一维必须和 ``y`` 的第0层lod大小相同，所以扩展后的LodTensor具有和 ``y`` 相同的lod。扩展结果与输入 ``x`` 的lod无关，所以无需考虑 ``x`` 的lod。

doc/fluid/api_cn/layers_cn/sequence_expand_cn.rst

@@ -3,6 +3,8 @@
 sequence_expand
 -------------------------------
 
+**注意：该API仅支持【静态图】模式**
+
 .. py:function:: paddle.fluid.layers.sequence_expand(x, y, ref_level=-1, name=None)
 
 序列扩张层（Sequence Expand Layer)，根据输入 ``y`` 的第 ``ref_level`` 层lod对输入 ``x`` 进行扩展。 ``x`` 的lod level最多为1，若 ``x`` 的lod level为1，则 ``x`` 的lod大小必须与 ``y`` 的第 ``ref_level`` 层lod大小相等；若 ``x`` 的lod level为0，则 ``x`` 的第一维大小必须与 ``y`` 第 ``ref_level`` 层大小相等。 ``x`` 的秩最少为2，当 ``x`` 的秩大于2时，将被当作是一个二维张量处理。