add_api_cn (#437)

doc/fluid/api_cn/api_guides/high_low_level_api.md

+## High/Low-level API简介
+
+Paddle目前有2套API接口：
+
+- Low-level（底层） API：
+	
+	- 灵活性强并且已经相对成熟，使用它训练的模型，能直接支持C++预测上线。
+	- 提供了大量的模型作为使用示例，包括[Book](https://github.com/PaddlePaddle/book)中的第7和8章，以及[models](https://github.com/PaddlePaddle/models)中的所有章节。
+	- 适用人群：对深度学习有一定了解，需要自定义网络进行训练/预测/上线部署的用户。
+
+- High-level（高层）API：
+	
+	- 使用简单，[Book](https://github.com/PaddlePaddle/book)中前六章提供了示例。
+	- 尚未成熟，接口暂时在[paddle.fluid.contrib](https://github.com/PaddlePaddle/Paddle/tree/develop/python/paddle/fluid/contrib)下面。
+	- 适用人群：想通过Book课程进行深度学习基础知识学习的初级用户。

doc/fluid/api_cn/api_guides/index.rst

+===========
+API使用指南
+===========
+
+..  toctree::
+    :titlesonly: 
+
+    high_low_level_api.md
+    low_level/layers/index.rst
+    low_level/executor.rst
+    low_level/optimizer.rst
+    low_level/metrics.rst
+    low_level/model_save_reader.rst
+    low_level/inference.rst
+    low_level/distributed/index.rst

doc/fluid/api_cn/api_guides/low_level/cluster/cluster_train_data_cn.rst

+..  _api_guide_cluster_train_data:
+
+####################
+分布式训练reader准备
+####################
+
+一个数据并行的分布式训练任务通常会含有多个训练进程，每个训练进程处理整个数据集中的一部分，根据当前进程的唯一序号(trainer_id)以及训练进程总数(trainers)可以决定当前训练进程应该读取哪一部分数据。
+
+实现 cluster_reader 来读取分布式训练数据集
+----------------------------------------
+
+比较通用的方法，可以实现一个 cluster_reader, 根据训练进程数量以及进程序号决定读取哪些 example:
+
+    .. code-block:: python
+        
+        def cluster_reader(reader, trainers, trainer_id):
+            def reader_creator():
+                for idx, data in enumerate(reader()):
+                    if idx % trainers == trainer_id:
+                        yield data
+            return reader
+
+        trainers = int(os.getenv("PADDLE_TRAINERS", "1"))
+        trainer_id = int(os.getenv("PADDLE_TRAINER_ID", "0"))
+        train_reader = cluster_reader(paddle.dataset.mnist.train(), trainers, trainer_id)
+
+上述代码中，`trainers` 和 `trainer_id` 分别是训练进程总数和当前训练进程的序号，可以通过环境变量或者参数的方式传递给 Python 程序。
+
+预先切分训练文件
+-----------------
+
+由于使用 `cluster_reader` 依然会读取全量数据，对于训练进程比较多的任务，会造成IO资源的浪费、影响训练性能。另一种方法是可以将训练数据切分成多个小文件，每个进程处理其中的一部分文件,
+例如在 Linux 系统中可以使用 `split <http://man7.org/linux/man-pages/man1/split.1.html>`_ 命令将训练数据切分成多个小文件：
+
+  .. code-block:: bash
+    $ split -d -a 4 -d -l 100 housing.data cluster/housing.data.
+    $ find ./cluster
+    cluster/
+    cluster/housing.data.0002
+    cluster/housing.data.0003
+    cluster/housing.data.0004
+    cluster/housing.data.0000
+    cluster/housing.data.0001
+    cluster/housing.data.0005
+
+数据切分好以后, 可以实现一个 file_dispatcher 函数，根据训练进程数量以及序号决定需要读取哪些文件：
+
+    .. code-block:: python
+
+        def file_dispatcher(files_pattern, trainers, trainer_id):
+            file_list = glob.glob(files_pattern)
+            ret_list = []
+            for idx, f in enumerate(file_list):
+                if (idx + trainers) % trainers == trainer_id:
+                    ret_list.append(f)
+            return ret_list
+        
+        trainers = int(os.getenv("PADDLE_TRAINERS", "1"))
+        trainer_id = int(os.getenv("PADDLE_TRAINER_ID", "0"))
+        files_pattern = "cluster/housing.data.*"
+
+        my_files = file_dispatcher(files_pattern, triners, trainer_id)
+
+在上述例子中，`files_pattern` 是训练文件的 `glob 表达式 <https://docs.python.org/2.7/library/glob.html>`_，一般可以用通配符来表示。

doc/fluid/api_cn/api_guides/low_level/distributed/async_training.rst

+.. _api_guide_async_training:
+
+############
+分布式异步训练
+############
+
+Fluid支持数据并行的分布式异步训练，API使用 :code:`DistributedTranspiler` 将单机网络配置转换成可以多机执行的
+:code:`pserver` 端程序和 :code:`trainer` 端程序。用户在不同的节点执行相同的一段代码，根据环境变量或启动参数，
+可以执行对应的 :code:`pserver` 或 :code:`trainer` 角色。Fluid异步训练只支持pserver模式，异步训练和 `同步训练 <../distributed/sync_training.html>`_ 的主要差异在于：异步训练每个trainer的梯度是单独更新到参数上的，
+而同步训练是所有trainer的梯度合并之后统一更新到参数上，因此，同步训练和异步训练的超参数需要分别调节。
+
+pserver模式分布式异步训练
+======================
+
+API详细使用方法参考 :ref: `api_fluid_DistributeTranspiler` ，简单示例用法：
+
+.. code-block:: python
+
+    config = fluid.DistributedTranspilerConfig()
+    # 配置策略config
+    config.slice_var_up = False
+    t = fluid.DistributedTranspiler(config=config)
+    t.transpile(trainer_id, 
+                program=main_program,
+                pservers="192.168.0.1:6174,192.168.0.2:6174",
+                trainers=1,
+                sync_mode=False)
+
+以上参数说明请参考`同步训练 <../distributed/sync_training.html>`_ 
+
+需要注意的是：进行异步训练时，请修改 :code:`sync_mode` 的值
+
+- :code:`sync_mode` ： 是否是同步训练模式，默认为True，不传此参数也默认是同步训练模式，设置为False则为异步训练

doc/fluid/api_cn/api_guides/low_level/distributed/cpu_train_best_practice.rst

+.. _api_guide_cpu_training_best_practice:
+
+##################
+分布式CPU训练最佳实践
+##################
+
+提高CPU分布式训练的训练速度，主要要从两个方面来考虑：
+1）提高训练速度，主要是提高CPU的使用率；2）提高通信速度，主要是减少通信传输的数据量。
+
+提高CPU的使用率
+=============
+
+提高CPU使用率主要依赖 :code:`ParallelExecutor`，可以充分利用多个CPU的计算能力来加速计算。
+
+API详细使用方法参考 :ref:`api_fluid_ParallelExecutor` ，简单实例用法：
+
+.. code-block:: python
+
+    # 配置执行策略，主要是设置线程数
+    exec_strategy = fluid.ExecutionStrategy()
+    exec_strategy.num_threads = 8
+
+    # 配置构图策略，对于CPU训练而言，应该使用Reduce模式进行训练
+    build_strategy = fluid.BuildStrategy()
+    if int(os.getenv("CPU_NUM")) > 1:
+        build_strategy.reduce_strategy = fluid.BuildStrategy.ReduceStrategy.Reduce
+
+    pe = fluid.ParallelExecutor(
+        use_cuda=False,
+        loss_name=avg_cost.name,
+        main_program=main_program,
+        build_strategy=build_strategy,
+        exec_strategy=exec_strategy)
+
+以上参数中：
+
+- :code:`num_threads` ： 模型训练使用的线程数，最好和训练所在机器的物理CPU核数接近
+- :code:`reduce_strategy` ： 对于CPU训练而言，应该选择 fluid.BuildStrategy.ReduceStrategy.Reduce
+
+
+通用环境变量配置：
+
+- :code:`CPU_NUM` ：模型副本replica的个数，最好和num_threads一致
+
+
+提高通信速度
+==========
+
+要减少通信数据量，提高通信速度，主要是使用稀疏更新 ，目前支持 `稀疏更新 <../distributed/sparse_update.html>`_  的主要是  :ref:`api_fluid_layers_embedding` 。
+
+.. code-block:: python
+
+    data = fluid.layers.data(name='ids', shape=[1], dtype='int64')
+    fc = fluid.layers.embedding(input=data, size=[dict_size, 16], is_sparse=True)
+
+以上参数中：
+
+- :code:`is_sparse` ： 配置embedding使用稀疏更新，如果embedding的dict_size很大，而每次数据data很少，建议使用sparse更新方式。

doc/fluid/api_cn/api_guides/low_level/distributed/index.rst

+=============
+分布式训练
+=============
+
+..  toctree::
+    :maxdepth: 1
+
+    async_training.rst
+    cpu_train_best_practice.rst
+    large_scale_sparse_feature_training.rst
+

doc/fluid/api_cn/api_guides/low_level/distributed/large_scale_sparse_feature_training.rst

+.. _api_guide_large_scale_sparse_feature_training:
+
+###################
+大规模稀疏特征模型训练
+###################
+
+
+模型配置和训练
+=============
+
+embedding被广泛应用在各种网络结构中，尤其是文本处理相关的模型。在某些场景，例如推荐系统或者搜索引擎中，
+embedding的feature id可能会非常多，当feature id达到一定数量时，embedding参数会变得很大，
+会带来两个问题：
+1）单机内存由于无法存放如此巨大的embedding参数，导致无法训练；
+2）普通的训练模式每一轮迭代都需要同步完整的参数，参数太大会让通信变得非常慢，进而影响训练速度。
+
+Fluid支持千亿量级超大规模稀疏特征embedding的训练，embedding参数只会保存在parameter server上，通过
+参数prefetch和梯度稀疏更新的方法，大大减少通信量，提高通信速度。
+
+该功能只对分布式训练有效，单机无法使用。
+需要配合 `稀疏更新 <../distributed/sparse_update.html>`_ 一起使用。
+
+使用方法：在配置embedding的时候，加上参数 :code:`is_distributed=True` 以及 :code:`is_sparse=True` 即可。
+参数 :code:`dict_size` 定义数据中总的id的数量，id可以是int64范围内的任意值，只要总id个数小于等于dict_size就可以支持。
+所以配置之前需要预估一下数据中总的feature id的数量。
+
+.. code-block:: python
+
+  emb = fluid.layers.embedding(
+      is_distributed=True,
+      input=input,
+      size=[dict_size, embedding_width],
+      is_sparse=True,
+      is_distributed=True)
+
+
+模型存储和预测
+=============
+
+当特征数量达到千亿的时候，参数量很大，单机已经无法存下，所以模型的存储和加载都和普通模式不同：
+1）普通模式下，参数是在trainer端保存和加载的；
+2）分布式模式下，参数的保存和加载，都是在pserver端进行，每个pserver只保存和加载该pserver自身对应部分的参数

doc/fluid/api_cn/api_guides/low_level/distributed/sync_training.rst

+.. _api_guide_sync_training:
+
+############
+分布式同步训练
+############
+
+Fluid支持数据并行的分布式同步训练，API使用 :code:`DistributedTranspiler` 将单机网络配置转换成可以多机执行的
+:code:`pserver` 端程序和 :code:`trainer` 端程序。用户在不同的节点执行相同的一段代码，根据环境变量或启动参数，
+可以执行对应的 :code:`pserver` 或 :code:`trainer` 角色。Fluid分布式同步训练同时支持pserver模式和NCCL2模式，
+在API使用上有差别，需要注意。
+
+pserver模式分布式训练
+===================
+
+API详细使用方法参考 :ref:`DistributeTranspiler` ，简单实例用法：
+
+.. code-block:: python
+
+    config = fluid.DistributedTranspilerConfig()
+    # 配置策略config
+    config.slice_var_up = False
+    t = fluid.DistributedTranspiler(config=config)
+    t.transpile(trainer_id, 
+                program=main_program,
+                pservers="192.168.0.1:6174,192.168.0.2:6174",
+                trainers=1,
+                sync_mode=True)
+
+以上参数中：
+
+- :code:`trainer_id` ： trainer节点的id，从0到n-1，n为当前训练任务中trainer节点的个数
+- :code:`program` ： 被转换的 :code:`program` 默认使用 :code:`fluid.default_main_program()`
+- :code:`pservers` ： 当前训练任务中pserver节点的IP端口列表
+- :code:`trainers` ： int类型，当前训练任务中trainer节点的个数。注意：
+    * pserver模式下，trainer节点个数可以和pserver节点个数不一致，比如使用20个pserver和50个trainer。在实际训练任务中，您可以通过调整pserver节点和trainer节点个数找到最佳性能
+    * NCCL2模式中，此项参数是字符串，指定trainer节点的IP端口列表
+- :code:`sync_mode` ： 是否是同步训练模式，默认为True，不传此参数也默认是同步训练模式
+
+
+其中，支持的config包括：
+
+- :code:`slice_var_up` ： 配置是否切分一个参数到多个pserver上进行优化，默认开启。此选项适用于模型参数个数少，但需要使用大量节点的场景，有利于提升pserver端计算并行度
+- :code:`split_method` ： 配置transpiler分配参数（或参数的切片）到多个pserver的方式，默认为"RoundRobin"，也可以使用"HashName"
+- :code:`min_block_size` ： 如果配置了参数切分，指定最小Tensor的切分大小，防止RPC请求包过小，默认为8192，一般情况不需要调整此项参数
+- :code:`enable_dc_asgd` ： 是否开启 :code:`DC-ASGD` 此选项在异步训练中生效，启用异步训练补偿算法
+- :code:`mode` : 可以选择"pserver"或"nccl2"，指定使用pserver模式或NCCL2模式分布式训练
+- :code:`print_log` ： 是否开启transpiler debug日志，此项为开发调试使用
+
+通用环境变量配置：
+
+- :code:`FLAGS_rpc_send_thread_num` ：int，指定RPC通信发送时线程的个数
+- :code:`FLAGS_rpc_get_thread_num` ： int，指定RPC通信接受时线程的个数
+- :code:`FLAGS_rpc_prefetch_thread_num` ： int，分布式lookup table执行RPC通信时，prefetch线程的个数
+- :code:`FLAGS_rpc_deadline` ： int，RPC通信最长等待时间，单位为毫秒，默认180000
+
+
+NCCL2模式分布式训练
+=================
+
+基于NCCL2 (Collective Communication) 的多机同步训练模式，仅支持在GPU集群下进行。
+此部分详细API说明可以参考 :ref:`DistributeTranspiler` 。
+
+注意：NCCL2模式下，集群不需要启动pserver，只需要启动多个trainer节点即可。
+
+使用以下代码，将当前 :code:`Program` 转化成适用于NCCL2分布式计算的Fluid :code:`Program` ：
+
+.. code-block:: python
+
+    config = fluid.DistributeTranspilerConfig()
+    config.mode = "nccl2"
+    t = fluid.DistributedTranspiler(config=config)
+    t.transpile(trainer_id, 
+                program=main_program,
+                startup_program=startup_program,
+                trainers="192.168.0.1:6174,192.168.0.2:6174",
+                current_endpoint="192.168.0.1:6174")
+
+其中：
+
+- :code:`trainer_id` : trainer节点的id，从0到n-1，n为当前训练任务中trainer节点的个数
+- :code:`program` 和 :code:`startup_program` : 分别为Fluid 模型的主配置program和初始化startup_program
+- :code:`trainers` : 字符串类型，指定当前任务所有trainer的IP和端口号，仅用于NCCL2初始化（pserver模式中，此参数为int，指定trainer节点的个数）
+- :code:`current_endpoint` : 当前任务的当前节点的IP和端口号

doc/fluid/api_cn/api_guides/low_level/executor.rst

+..  _api_guide_executor:
+
+##########
+执行引擎
+##########
+
+:code:`Executor` 即 :code:`执行器` 。PaddlePaddle Fluid中有两种执行器可以选择。
+:code:`Executor` 实现了一个简易的执行器，所有Operator会被顺序执行。用户可以使用
+Python脚本驱动 :code:`Executor` 执行。默认情况下 :code:`Executor` 是单线程的，如果
+想使用数据并行，请参考另一个执行器， :ref:`api_guide_parallel_executor` 。
+
+:code:`Executor` 的代码逻辑非常简单。建议用户在调试过程中，先使用
+:code:`Executor` 跑通模型，再切换到多设备计算，甚至多机计算。
+
+:code:`Executor` 在构造的时候接受一个 :code:`Place`， 它们可以是 :ref:`api_fluid_CPUPlace`
+或 :ref:`api_fluid_CUDAPlace` 。 :code:`Executor` 在执行的时候可以选择执行的
+:ref:`api_guide_low_level_program` 。
+
+简单的使用方法，请参考 `quick_start_fit_a_line <http://paddlepaddle.org/documentation/docs/zh/1.1/beginners_guide/quick_start/fit_a_line/README.cn.html>`_ , API Reference 请参考
+:ref:`api_fluid_Executor` 。

doc/fluid/api_cn/api_guides/low_level/inference.rst

+..  _api_guide_inference:
+
+#########
+预测引擎
+#########
+
+预测引擎提供了存储预测模型 :ref:`api_fluid_io_save_inference_model` 和加载预测模型 :ref:`api_fluid_io_load_inference_model` 两个接口。
+
+预测模型的存储格式
+=================
+
+预测模型的存储格式有两种，由上述两个接口中的 :code:`model_filename` 和 :code:`params_filename` 变量控制：
+
+- 参数保存到各个独立的文件，如设置 :code:`model_filename` 为 :code:`None` 、:code:`params_filename` 为 :code:`None`
+
+  .. code-block:: bash
+
+      ls recognize_digits_conv.inference.model/*
+      __model__ conv2d_1.w_0 conv2d_2.w_0 fc_1.w_0 conv2d_1.b_0 conv2d_2.b_0 fc_1.b_0
+
+- 参数保存到同一个文件，如设置 :code:`model_filename` 为 :code:`None` 、:code:`params_filename` 为 :code:`__params__`
+
+  .. code-block:: bash
+
+      ls recognize_digits_conv.inference.model/*
+      __model__ __params__
+
+存储预测模型
+===========
+
+.. code-block:: python
+
+    exe = fluid.Executor(fluid.CPUPlace())
+    path = "./infer_model"
+    fluid.io.save_inference_model(dirname=path, feeded_var_names=['img'], 
+        target_vars=[predict_var], executor=exe)
+
+在这个示例中，:code:`fluid.io.save_inference_model` 接口对默认的 :code:`fluid.Program` 进行裁剪，只保留预测 :code:`predict_var` 所需部分。
+裁剪后的 :code:`program` 会保存在 :code:`./infer_model/__model__` 下，参数会保存到 :code:`./infer_model` 下的各个独立文件。
+
+加载预测模型
+===========
+
+.. code-block:: python
+
+    exe = fluid.Executor(fluid.CPUPlace())
+    path = "./infer_model"
+    [inference_program, feed_target_names, fetch_targets] = 
+        fluid.io.load_inference_model(dirname=path, executor=exe)
+    results = exe.run(inference_program,
+                  feed={feed_target_names[0]: tensor_img},
+                  fetch_list=fetch_targets)
+
+在这个示例中，首先调用 :code:`fluid.io.load_inference_model` 接口，获得预测的 :code:`program` 、输入数据的 :code:`variable` 名称和输出结果的 :code:`variable` ;
+然后调用 :code:`executor` 执行预测的 :code:`program` 获得预测结果。

doc/fluid/api_cn/api_guides/low_level/layers/activations.rst

+.. _api_guide_activations:
+
+####
+激活函数
+#### 
+
+激活函数将非线性的特性引入到神经网络当中。
+
+PaddlePaddle Fluid 对大部分的激活函数进行了支持，其中有:        
+
+:ref:`api_fluid_layers_relu`, :ref:`api_fluid_layers_tanh`, :ref:`api_fluid_layers_sigmoid`, :ref:`api_fluid_layers_elu`, :ref:`api_fluid_layers_relu6`, :ref:`api_fluid_layers_pow`, :ref:`api_fluid_layers_stanh`, :ref:`api_fluid_layers_hard_sigmoid`, :ref:`api_fluid_layers_swish`, :ref:`api_fluid_layers_prelu`, :ref:`api_fluid_layers_brelu`, :ref:`api_fluid_layers_leaky_relu`, :ref:`api_fluid_layers_soft_relu`, :ref:`api_fluid_layers_thresholded_relu`, :ref:`api_fluid_layers_maxout`, :ref:`api_fluid_layers_logsigmoid`, :ref:`api_fluid_layers_hard_shrink`, :ref:`api_fluid_layers_softsign`, :ref:`api_fluid_layers_softplus`, :ref:`api_fluid_layers_tanh_shrink`, :ref:`api_fluid_layers_softshrink`, :ref:`api_fluid_layers_exp`。
+ 
+
+**Fluid提供了两种使用激活函数的方式：**
+
+- 如果一个层的接口提供了 :code:`act` 变量（默认值为None），我们可以通过该变量指定该层的激活函数类型。该方式支持常见的激活函数: :code:`relu`, :code:`tanh`, :code:`sigmoid`, :code:`identity`。
+
+.. code-block:: python
+
+	conv2d = fluid.layers.conv2d(input=data, num_filters=2, filter_size=3, act="relu")
+
+
+- Fluid为每个Activation提供了接口，我们可以显式的对它们进行调用。
+
+.. code-block:: python
+
+	conv2d = fluid.layers.conv2d(input=data, num_filters=2, filter_size=3)
+	relu1 = fluid.layers.relu(conv2d)

doc/fluid/api_cn/api_guides/low_level/layers/control_flow.rst

+.. api_guide_control_flow:
+
+######
+控制流
+######
+
+在程序语言中，控制流(control flow)决定了语句的执行顺序，常见的控制流包括顺序执行、分支和循环等。PaddlePaddle Fluid继承了这一概念，提供了多种控制流API, 以控制深度学习模型在训练或者预测过程中的执行逻辑。
+
+IfElse
+======
+
+条件分支，允许对同一个batch的输入，根据给定的条件，分别选择 :code:`true_block` 或 :code:`false_block` 中的逻辑进行执行，执行完成之后再将两个分支的输出合并为同一个输出。通常，条件表达式可由 :ref:`api_fluid_layers_less_than`, :ref:`api_fluid_layers_equal` 等逻辑比较 API 产生。
+
+请参考 :ref:`api_fluid_layers_IfElse`            
+
+
+Switch
+======
+
+多分支选择结构，如同程序语言中常见的 :code:`switch-case` 声明, 其根据输入表达式的取值不同，选择不同的分支执行。具体来说，Fluid 所定义的 :code:`Switch` 控制流有如下特性：
+
+* case的条件是个bool类型的值，即在Program中是一个张量类型的Variable；
+* 依次检查逐个case，选择第一个满足条件的case执行，完成执行后即退出所属的block；
+* 如果所有case均不满足条件，会选择默认的case进行执行。
+
+请参考 :ref:`api_fluid_layers_Switch`
+
+While
+=====
+
+While 循环，当条件判断为真时，循环执行 :code:`While` 控制流所属 :code:`block` 内的逻辑，条件判断为假时退出循环。与之相关的API有
+
+* :ref:`api_fluid_layers_increment` ：累加API，通常用于对循环次数进行计数；
+* :ref:`api_fluid_layers_array_read` ：从 :code:`LOD_TENSOR_ARRAY` 中指定的位置读入Variable，进行计算；
+* :ref:`api_fluid_layers_array_write` ：将 Variable 写回到 :code:`LOD_TENSOR_ARRAY` 指定的位置，存储计算结果。
+
+请参考 :ref:`api_fluid_layers_While`
+
+DynamicRNN
+==========
+
+即动态RNN，可处理一个batch不等长的序列数据，其接受 :code:`lod_level=1` 的 Variable 作为输入，在 :code:`DynamicRNN` 的 :code:`block` 内，用户需自定义RNN的单步计算逻辑。在每一个时间步，用户可将需记忆的状态写入到 :code:`DynamicRNN` 的 :code:`memory` 中，并将需要的输出写出到其 :code:`output` 中。
+
+:ref:`api_fluid_layers_sequence_last_step` 可获取 :code:`DynamicRNN` 最后一个时间步的输出。
+
+请参考 :ref:`api_fluid_layers_DynamicRNN`
+
+StaticRNN
+=========
+
+即静态RNN，只能处理固定长度的序列数据，接受 :code:`lod_level=0` 的 Variable 作为输入。与 :code:`DynamicRNN` 类似，在RNN的每单个时间步，用户需自定义计算逻辑，并可将状态和输出写出。
+
+请参考 :ref:`api_fluid_layers_StaticRNN`

doc/fluid/api_cn/api_guides/low_level/layers/conv.rst

+.. _api_guide_conv:
+
+#####
+卷积
+#####
+
+卷积有两组输入：特征图和卷积核，依据输入特征和卷积核的形状、Layout不同、计算方式的不同，在Fluid里，有针对变长序列特征的一维卷积，有针对定长图像特征的二维(2D Conv)、三维卷积(3D Conv)，同时也有卷积计算的逆向过程，下面先介绍Fluid里的2D/3D卷积，再来介绍序列卷积。
+
+
+2D/3D卷积
+==============
+
+1. 卷积输入参数：
+---------------------
+
+卷积需要依据滑动步长(stride)、填充长度(padding)、卷积核窗口大小(filter size)、分组数(groups)、扩张系数(dilation rate)来决定如何计算。groups最早在 `AlexNet <https://www.nvidia.cn/content/tesla/pdf/machine-learning/imagenet-classification-with-deep-convolutional-nn.pdf>`_ 中引入, 可以理解为将原始的卷积分为独立若干组卷积计算。
+  
+  **注意**: 同cuDNN的方式，Fluid目前只支持在特征图上下填充相同的长度，左右也是。
+
+- 输入输出Layout: 
+
+  2D卷积输入特征的Layout为[N, C, H, W]或[N, H, W, C], N即batch size，C是通道数，H、W是特征的高度和宽度，输出特征和输入特征的Layout一致。(相应的3D卷积输入特征的Layout为[N, C, D, H, W]或[N, D, H, W, C]，但**注意**，Fluid的卷积当前只支持[N, C, H, W]，[N, C, D, H, W]。)
+   
+- 卷积核的Layout: 
+  
+  Fluid中2D卷积的卷积核(也称权重)的Layout为[C_o, C_in / groups, f_h, f_w]，C_o、C_in表示输出、输入通道数，f_h、f_w表示卷积核窗口的高度和宽度，按行序存储。(相应的2D卷积的卷积核Layout为[C_o, C_in / groups, f_d, f_h, d_w]，同样按行序存储。)
+  
+- 深度可分离卷积(depthwise separable convolution): 
+   
+  在深度可分离卷积中包括depthwise convolution和pointwise convolution两组，这两个卷积的接口和上述普通卷积接口相同。前者可以通过给普通卷积设置groups来做，后者通过设置卷积核filters的大小为1x1，深度可分离卷积减少参数的同时减少了计算量。
+  
+  对于depthwise convolution，可以设置groups等于输入通道数，此时，2D卷积的卷积核形状为[C_o, 1, f_h, f_w]。
+  对于pointwise convolution，卷积核的形状为[C_o, C_in, 1, 1]。
+  
+  **注意**：Fluid针对depthwise convolution的GPU计算做了高度优化，您可以通过在 :code:`fluid.layers.conv2d`接口设置 :code:`use_cudnn=False`来使用Fluid自身优化的CUDA程序。
+   
+- 空洞卷积(dilated convolution):
+  
+  空洞卷积相比普通卷积而言，卷积核在特征图上取值时不在连续，而是间隔的，这个间隔数称作dilation，等于1时，即为普通卷积，空洞卷积相比普通卷积的感受野更大。
+  
+- API汇总:
+ - :ref:`api_fluid_layers_conv2d`
+ - :ref:`api_fluid_layers_conv3d`
+ - :ref:`api_fluid_layers_conv2d_transpose`
+ - :ref:`api_fluid_layers_conv3d_transpose`
+
+
+1D序列卷积
+==============
+
+Fluid可以表示变长的序列结构，这里的变长是指不同样本的时间步(step)数不一样，通常是一个2D的Tensor和一个能够区分的样本长度的辅助结构来表示。假定，2D的Tensor的形状是shape，shape[0]是所有样本的总时间步数，shape[1]是序列特征的大小。
+
+基于此数据结构的卷积在Fluid里称作序列卷积，也表示一维卷积。同图像卷积，序列卷积的输入参数有卷积核大小、填充大小、滑动步长，但与2D卷积不同的是，这些参数个数都为1。**注意**，目前仅支持stride为1的情况，输出序列的时间步数和输入序列相同。 
+
+假如：输入序列形状为(T, N)， T即该序列的时间步数，N是序列特征大小；卷积核的上下文步长为K，输出序列长度为M，则卷积核权重形状为(K * N, M），输出序列形状为(T, M)。
+  
+另外，参考DeepSpeech，Fluid实现了行卷积row convolution, 或称
+`look ahead convolution <http://www.cs.cmu.edu/~dyogatam/papers/wang+etal.iclrworkshop2016.pdf>`_ ，
+该卷积相比上述普通序列卷积可以减少参数。
+ 
+
+- API汇总:
+ - :ref:`api_fluid_layers_sequence_conv`
+ - :ref:`api_fluid_layers_row_conv`

doc/fluid/api_cn/api_guides/low_level/layers/data_feeder.rst

+..  _api_guide_data_feeder:
+
+使用DataFeeder传入训练/预测数据
+###################################
+
+Fluid提供 :code:`DataFeeder` 类，将numpy array等数据转换为 :code:`LoDTensor` 类型传入训练/预测网络。
+
+用户创建 :code:`DataFeeder` 对象的方式为：
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+
+    image = fluid.layers.data(name='image', shape=[-1, 3, 224, 224], dtype='float32')
+    label = fluid.layers.data(name='label', shape=[-1, 1], dtype='int64')
+    place = fluid.CUDAPlace(0) if fluid.core.is_compiled_with_cuda() else fluid.CPUPlace()
+    feeder = fluid.DataFeeder(feed_list=[image, label], place=place)
+
+其中，:code:`feed_list` 参数为变量列表，这些变量由 :code:`fluid.layers.data()` 创建，
+:code:`place` 参数表示应将Python端传入的numpy array等数据转换为GPU端或是CPU端的 :code:`LoDTensor` 。
+创建 :code:`DataFeeder` 对象后，用户可调用其 :code:`feed(iterable)` 方法将用户传入的
+:code:`iterable` 数据转换为 :code:`LoDTensor`。
+
+:code:`iterable` 应为Python List或Tuple类型对象，且 :code:`iterable` 的每个元素均为长度为N的
+Python List或Tuple类型对象，其中N为创建 :code:`DataFeeder` 对象时传入的 :code:`feed_list` 变量个数。
+
+:code:`iterable` 的具体格式为：
+
+.. code-block:: python
+
+    iterable = [
+        (image_1, label_1),
+        (image_2, label_2),
+        ...
+        (image_n, label_n)
+    ]
+
+其中，:code:`image_i` 与 :code:`label_i` 均为numpy array类型数据。若传入数据的维度为[1]，如 :code:`label_i`,
+则可传入Python int、float等类型数据。 :code:`image_i` 与 :code:`label_i` 的数据类型和维度不必
+与 :code:`fluid.layers.data()` 创建时指定的 :code:`dtype` 和 :code:`shape` 完全一致，:code:`DataFeeder` 内部
+会完成数据类型和维度的转换。若 :code:`feed_list` 中的变量的 :code:`lod_level` 不为零，则Fluid会将经过维度转换后的
+:code:`iterable` 中每行数据的第0维作为返回结果的 :code:`LoD`。
+
+具体使用方法请参见 :ref:`api_fluid_DataFeeder` 。
\ No newline at end of file

doc/fluid/api_cn/api_guides/low_level/layers/data_in_out.rst

+..  _api_guide_data_in_out:
+
+数据输入输出
+###############
+
+
+数据输入
+-------------
+
+Fluid支持两种数据输入方式，包括：
+
+1. Python Reader: 纯Python的Reader。用户在Python端定义 :code:`fluid.layers.data` 层构建网络，并通过
+:code:`executor.run(feed=...)` 的方式读入数据。数据读取和模型训练/预测的过程是同步进行的。
+
+2. PyReader: 高效灵活的C++ Reader接口。PyReader内部维护容量为 :code:`capacity` 的队列（队列容量由
+:code:`fluid.layers.py_reader` 接口中的 :code:`capacity` 参数设置），Python端调用队列的 :code:`push`
+方法送入训练/预测数据，C++端的训练/预测程序调用队列的 :code:`pop` 方法取出Python端送入的数据。PyReader可与
+:code:`double_buffer` 配合使用，实现数据读取和训练/预测的异步执行。
+
+具体使用方法请参考 :ref:`api_fluid_layers_py_reader`。
+
+
+数据输出
+------------
+
+Fluid支持在训练/预测阶段获取当前batch的数据。
+
+用户可通过 :code:`executor.run(fetch_list=[...], return_numpy=...)` 的方式
+fetch期望的输出变量，通过设置 :code:`return_numpy` 参数设置是否将输出数据转为numpy array。
+若 :code:`return_numpy` 为 :code:`False` ，则返回 :code:`LoDTensor` 类型数据。
+
+具体使用方式请参考相关API文档 :ref:`api_fluid_executor_Executor` 和
+:ref:`api_fluid_ParallelExecutor`。
\ No newline at end of file

doc/fluid/api_cn/api_guides/low_level/layers/detection.rst

+..  _api_guide_detection:
+
+
+图像检测
+#########
+
+PaddlePaddle Fluid在图像检测任务中实现了多个特有的操作。以下分模型介绍各个api：
+
+通用操作
+-------------
+
+图像检测中的一些通用操作，是对检测框的一系列操作，其中包括：
+
+* 对检测框的编码，解码（box_coder）：实现两种框之间编码和解码的转换。例如训练阶段对先验框和真实框进行编码得到训练目标值。API Reference 请参考 :ref:`api_fluid_layers_box_coder`
+
+* 比较两个检测框并进行匹配：
+
+  * iou_similarity：计算两组框的IOU值。API Reference 请参考 :ref:`api_fluid_layers_iou_similarity`
+
+  * bipartite_match：通过贪心二分匹配算法得到每一列中距离最大的一行。API Reference 请参考 :ref:`api_fluid_layers_bipartite_match`
+
+* 根据检测框和标签得到分类和回归目标值（target_assign）：通过匹配索引和非匹配索引得到目标值和对应权重。API Reference 请参考 :ref:`api_fluid_layers_target_assign`
+
+
+Faster RCNN
+-------------
+
+`Faster RCNN <https://arxiv.org/abs/1506.01497>`_ 是典型的两阶段目标检测器，相较于传统提取区域的方法，Faster RCNN中RPN网络通过共享卷积层参数大幅提高提取区域的效率，并提出高质量的候选区域。RPN网络需要对输入anchor和真实值进行比较生成初选候选框，并对初选候选框分配分类和回归值，>需要如下四个特有api：
+
+* rpn_target_assign：通过anchor和真实框为anchor分配RPN网络的分类和回归目标值。API Reference 请参考 :ref:`api_fluid_layers_rpn_target_assign`
+
+* anchor_generator：为每个位置生成一系列anchor。API Reference 请参考 :ref:`api_fluid_layers_anchor_generator`
+
+* generate_proposal_labels: 通过generate_proposals得到的候选框和真实框得到RCNN部分的分类和回归的目标值。API Reference 请参考 :ref:`api_fluid_layers_generate_proposal_labels`
+
+* generate_proposals: 对RPN网络输出box解码并筛选得到新的候选框。API Reference 请参考 :ref:`api_fluid_layers_generate_proposals`
+
+
+SSD
+----------------
+
+`SSD <https://arxiv.org/abs/1512.02325>`_ 全称Single Shot MultiBox Detector，是目标检测领域较新且效果较好的检测算法之一，具有检测速度快且检测精度高的特点。与两阶段的检测方法不同，单阶段目标检测并不进行区域推荐，而是直接从特征图回归出目标的边界框和分类概率。SSD网络对六个尺度特>征图计算损失，进行预测，需要如下五种特有api：
+
+* Prior Box：根据不同参数为每个输入位置生成一系列候选框。API Reference 请参考 :ref:`api_fluid_layers_prior_box`
+
+* multi_box_head ：得到不同prior box的位置和置信度。API Reference 请参考 :ref:`api_fluid_layers_multi_box_head`
+
+* detection_output：对prioir box解码，通过多分类NMS得到检测结果。API Reference 请参考 :ref:`api_fluid_layers_detection_output`
+
+* ssd_loss：通过位置偏移预测值，置信度，检测框位置和真实框位置和标签计算损失。API Reference 请参考 :ref:`api_fluid_layers_ssd_loss`
+
+* detection map: 利用mAP评估SSD网络模型。API Reference 请参考 :ref:`api_fluid_layers_detection_map`
+
+OCR
+---------
+
+场景文字识别是在图像背景复杂、分辨率低下、字体多样、分布随意等情况下，将图像信息转化为文字序列的过程，可认为是一种特别的翻译过程：将图像输入翻译为自然语言输出。OCR任务中需要对检测框进行不规则变换，其中需要如下两个api：
+
+* roi_perspective_transform：对输入roi做透视变换。API Reference 请参考 :ref:`api_fluid_layers_roi_perspective_transform`
+
+* polygon_box_transform：对不规则检测框进行坐标变换。API Reference 请参考 :ref:`api_fluid_layers_polygon_box_transform`
+
+

doc/fluid/api_cn/api_guides/low_level/layers/index.rst

+=============
+神经网络层
+=============
+
+..  toctree::
+    :maxdepth: 1
+
+    conv.rst
+    pooling.rst
+    detection.rst
+    sequence.rst
+    math.rst
+    activations.rst
+    loss_function.rst
+    data_in_out.rst
+    control_flow.rst
+    sparse_update.rst
+    

doc/fluid/api_cn/api_guides/low_level/layers/learning_rate_scheduler.rst

+.. _api_guide_learning_rate_scheduler:
+
+############
+学习率调度器
+############
+
+当我们使用诸如梯度下降法等方式来训练模型时，一般会兼顾训练速度和损失(loss)来选择相对合适的学习率。但若在训练过程中一直使用一个学习率，训练集的损失下降到一定程度后便不再继续下降，而是在一定范围内震荡。其震荡原理如下图所示，即当损失函数收敛到局部极小值附近时，会由于学习率过大导致更新步幅过大，每步参数更新会反复越过极小值而出现震荡。
+
+.. image:: ../../../../images/learning_rate_scheduler.png
+    :scale: 80 %
+    :align: center
+
+
+学习率调度器定义了常用的学习率衰减策略来动态生成学习率，学习率衰减函数以epoch或step为参数，返回一个随训练逐渐减小的学习率，从而兼顾降低训练时间和在局部极小值能更好寻优两个方面。
+
+下面介绍学习率调度器中相关的Api：
+
+======
+
+* :code:`noam_decay`: 诺姆衰减，相关算法请参考 `《Attention Is All You Need》 <https://arxiv.org/pdf/1706.03762.pdf>`_ 。
+  相关API Reference请参考 :ref:`api_fluid_layers_noam_decay`
+
+* :code:`exponential_decay`: 指数衰减，即每次将当前学习率乘以给定的衰减率得到下一个学习率。
+  相关API Reference请参考 :ref:`api_fluid_layers_exponential_decay`
+
+* :code:`natural_exp_decay`: 自然指数衰减，即每次将当前学习率乘以给定的衰减率的自然指数得到下一个学习率。
+  相关API Reference请参考 :ref:`api_fluid_layers_natural_exp_decay`
+
+* :code:`inverse_time_decay`: 逆时间衰减，即得到的学习率与当前衰减次数成反比。
+  相关API Reference请参考 :ref:`api_fluid_layers_inverse_time_decay`
+
+* :code:`polynomial_decay`: 多项式衰减，即得到的学习率为初始学习率和给定最终学习之间由多项式计算权重定比分点的插值。
+  相关API Reference请参考 :ref:`api_fluid_layers_polynomial_decay`
+
+* :code:`piecewise_decay`: 分段衰减，即由给定step数分段呈阶梯状衰减，每段内学习率相同。
+  相关API Reference请参考 :ref:`api_fluid_layers_piecewise_decay`
+
+* :code:`append_LARS`: 通过Layer-wise Adaptive Rate Scaling算法获得学习率，相关算法请参考 `《Train Feedfoward Neural Network with Layer-wise Adaptive Rate via Approximating Back-matching Propagation》 <https://arxiv.org/abs/1802.09750>`_ 。
+  相关API Reference请参考 :ref:`api_fluid_layers_append_LARS`
+

doc/fluid/api_cn/api_guides/low_level/layers/loss_function.rst

+..  _api_guide_loss_function:
+
+#######
+损失函数
+#######
+
+损失函数定义了拟合结果和真实结果之间的差异，作为优化的目标直接关系模型训练的好坏，很多研究工作的内容也集中在损失函数的设计优化上。
+Paddle Fluid 中提供了面向多种任务的多种类型的损失函数，以下列出了一些 Paddle Fluid 中包含的较为常用的损失函数。
+
+回归
+====
+
+平方误差损失（squared error loss）使用预测值和真实值之间误差的平方作为样本损失，是回归问题中最为基本的损失函数。
+API Reference 请参考 :ref:`api_fluid_layers_square_error_cost`。
+
+平滑 L1 损失（smooth_l1 loss）是一种分段的损失函数，较平方误差损失其对异常点相对不敏感，因而更为鲁棒。
+API Reference 请参考 :ref:`api_fluid_layers_smooth_l1`。
+
+
+分类
+====
+
+`交叉熵（cross entropy） <https://en.wikipedia.org/wiki/Cross_entropy>`_ 是分类问题中使用最为广泛的损失函数，Paddle Fluid 中提供了接受归一化概率值和非归一化分值输入的两种交叉熵损失函数的接口，并支持 soft label 和 hard label 两种样本类别标签。
+API Reference 请参考 :ref:`api_fluid_layers_cross_entropy` 和 :ref:`api_fluid_layers_softmax_with_cross_entropy`。
+
+多标签分类
+---------
+对于多标签分类问题，如一篇文章同属于政治、科技等多个类别的情况，需要将各类别作为独立的二分类问题计算损失，Paddle Fluid 中为此提供了 sigmoid_cross_entropy_with_logits 损失函数，
+API Reference 请参考 :ref:`api_fluid_layers_sigmoid_cross_entropy_with_logits`。
+
+大规模分类
+---------
+对于大规模分类问题，通常需要特殊的方法及相应的损失函数以加速训练，常用的方法有 `噪声对比估计（Noise-contrastive estimation，NCE） <http://proceedings.mlr.press/v9/gutmann10a/gutmann10a.pdf>`_ 和 `层级 sigmoid <http://www.iro.umontreal.ca/~lisa/pointeurs/hierarchical-nnlm-aistats05.pdf>`_ 。
+
+* 噪声对比估计通过将多分类问题转化为学习分类器来判别数据来自真实分布和噪声分布的二分类问题，基于二分类来进行极大似然估计，避免在全类别空间计算归一化因子从而降低了计算复杂度。
+* 层级 sigmoid 通过二叉树进行层级的二分类来实现多分类，每个样本的损失对应了编码路径上各节点二分类交叉熵的和，避免了归一化因子的计算从而降低了计算复杂度。
+这两种方法对应的损失函数在 Paddle Fluid 中均有提供，API Reference 请参考 :ref:`api_fluid_layers_nce` 和 :ref:`api_fluid_layers_hsigmoid`。
+
+序列分类
+-------
+序列分类可以分为以下三种：
+
+* 序列分类（Sequence Classification）问题，整个序列对应一个预测标签，如文本分类。这种即是普通的分类问题，可以使用 cross entropy 作为损失函数。
+* 序列片段分类（Segment Classification）问题，序列中的各个片段对应有自己的类别标签，如命名实体识别。对于这种序列标注问题，`（线性链）条件随机场（Conditional Random Field，CRF） <http://www.cs.columbia.edu/~mcollins/fb.pdf>`_ 是一种常用的模型方法，其使用句子级别的似然概率，序列中不同位置的标签不再是条件独立，能够有效解决标记偏置问题。Paddle Fluid 中提供了 CRF 对应损失函数的支持，API Reference 请参考 :ref:`api_fluid_layers_linear_chain_crf`。
+* 时序分类（Temporal Classification）问题，需要对未分割的序列进行标注，如语音识别。对于这种时序分类问题，`CTC（Connectionist Temporal Classification） <http://people.idsia.ch/~santiago/papers/icml2006.pdf>`_ 损失函数不需要对齐输入数据及标签，可以进行端到端的训练，Paddle Fluid 提供了 warpctc 的接口来计算相应的损失，API Reference 请参考 :ref:`api_fluid_layers_warpctc`。
+
+排序
+====
+
+`排序问题 <https://en.wikipedia.org/wiki/Learning_to_rank>`_ 可以使用 Pointwise、Pairwise 和 Listwise 的学习方法，不同的方法需要使用不同的损失函数：
+
+* Pointwise 的方法通过近似为回归问题解决排序问题，可以使用回归问题的损失函数。
+* Pairwise 的方法需要特殊设计的损失函数，其通过近似为分类问题解决排序问题，使用两篇文档与 query 的相关性得分以偏序作为二分类标签来计算损失。Paddle Fluid 中提供了两种常用的 Pairwise 方法的损失函数，API Reference 请参考 :ref:`api_fluid_layers_rank_loss` 和 :ref:`api_fluid_layers_margin_rank_loss`。
+
+更多
+====
+
+对于一些较为复杂的损失函数，可以尝试使用其他损失函数组合实现；Paddle Fluid 中提供的用于图像分割任务的 :ref:`api_fluid_layers_dice_loss` 即是使用其他 OP 组合（计算各像素位置似然概率的均值）而成；多目标损失函数也可看作这样的情况，如 Faster RCNN 就使用 cross entropy 和 smooth_l1 loss 的加权和作为损失函数。
+
+**注意**，在定义损失函数之后为能够使用 :ref:`api_guide_optimizer` 进行优化，通常需要使用 :ref:`api_fluid_layers_mean` 或其他操作将损失函数返回的高维 Tensor 转换为 Scalar 值。
\ No newline at end of file

doc/fluid/api_cn/api_guides/low_level/layers/math.rst

+..  _api_guide_math:
+
+
+数学操作
+#########
+
+Paddle提供了丰富的数学操作，以下列出的数学操作都是对目标张量进行逐元素的操作。其中，如果二元操作的两个输入有不同形状，会先进行 :code:`broadcast`. 部分数学操作还支持数学操作符，比如： :code:`+`,  :code:`-`, :code:`*`, :code:`/` 等。数学操作符不仅支持张量，还支持标量。
+
+
+一元操作
+==================
+
+exp
+------------------
+
+对输入 :code:`Tensor` 逐元素做 :code:`exp` 操作。
+
+API Reference 请参考 :ref:`api_fluid_layers_exp`
+
+tanh
+------------------
+
+对输入 :code:`Tensor` 逐元素取正切。
+
+API Reference 请参考 :ref:`api_fluid_layers_tanh`
+
+sqrt
+------------------
+
+对输入 :code:`Tensor` 逐元素取平方根。
+
+API Reference 请参考 :ref:`api_fluid_layers_sqrt`
+
+abs
+------------------
+
+对输入 :code:`Tensor` 逐元素取绝对值。
+
+API Reference 请参考 :ref:`api_fluid_layers_abs`
+
+ceil
+------------------
+
+对输入 :code:`Tensor` 逐元素向上取整。
+
+API Reference 请参考 :ref:`api_fluid_layers_ceil`
+
+floor
+------------------
+
+对输入 :code:`Tensor` 逐元素向下取整。
+
+API Reference 请参考 :ref:`api_fluid_layers_floor`
+
+sin
+------------------
+
+对输入 :code:`Tensor` 逐元素取正玄。
+
+API Reference 请参考 :ref:`api_fluid_layers_sin`
+
+cos
+------------------
+
+对输入 :code:`Tensor` 逐元素取余玄。
+
+API Reference 请参考 :ref:`api_fluid_layers_cos`
+
+round
+------------------
+
+对输入 :code:`Tensor` 逐元素四舍五入取整。
+
+API Reference 请参考 :ref:`api_fluid_layers_round`
+
+square
+------------------
+
+对输入 :code:`Tensor` 逐元素取平方。
+
+API Reference 请参考 :ref:`api_fluid_layers_square`
+
+reciprocal
+------------------
+
+对输入 :code:`Tensor` 逐元素取倒数。
+
+API Reference 请参考 :ref:`api_fluid_layers_reciprocal`
+
+
+reduce
+------------------
+
+对输入 :code:`Tensor` 在指定的若干轴上做reduce操作，包括：min, max, sum, mean, product
+
+API Reference 请参考:
+:ref:`api_fluid_layers_reduce_min`
+:ref:`api_fluid_layers_reduce_max`
+:ref:`api_fluid_layers_reduce_sum`
+:ref:`api_fluid_layers_reduce_mean`
+:ref:`api_fluid_layers_reduce_prod`
+
+
+二元操作
+==================
+
+elementwise_add
+------------------
+
+对两个 :code:`Tensor` 逐元素相加，对应的数学操作符为 :code:`+`
+
+API Reference 请参考 :ref:`api_fluid_layers_elementwise_add`
+
+elementwise_sub
+------------------
+
+对两个 :code:`Tensor` 逐元素相减，对应数学操作符 :code:`-`
+
+API Reference 请参考 :ref:`api_fluid_layers_elementwise_sub`
+
+elementwise_mul
+------------------
+
+对两个 :code:`Tensor` 逐元素相乘， 对应数学操作符 :code:`*`
+
+API Reference 请参考 :ref:`api_fluid_layers_elementwise_mul`
+
+elementwise_div
+------------------
+
+对两个 :code:`Tensor` 逐元素相除， 对应数学操作符 :code:`/` 或 :code:`//`
+
+API Reference 请参考 :ref:`api_fluid_layers_elementwise_div`
+
+
+elementwise_pow
+------------------
+
+对两个 :code:`Tensor` 逐元素做次幂操作， 对应数学操作符 :code:`**`
+
+API Reference 请参考 :ref:`api_fluid_layers_elementwise_pow`
+
+equal
+------------------
+
+对两个 :code:`Tensor` 逐元素判断是否相等， 对应数学操作符 :code:`==`
+
+API Reference 请参考 :ref:`api_fluid_layers_equal`
+
+not_equal
+------------------
+
+对两个 :code:`Tensor` 逐元素判断是否不等， 对应数学操作符 :code:`!=`
+
+API Reference 请参考 :ref:`api_fluid_layers_elementwise_not_equal`
+
+less_than
+------------------
+
+对两个 :code:`Tensor` 逐元素判断是否满足小于关系， 对应数学操作符 :code:`<`
+
+API Reference 请参考 :ref:`api_fluid_layers_less_than`
+
+less_equal
+------------------
+
+对两个 :code:`Tensor` 逐元素判断是否满足小于或等于关系， 对应数学操作符 :code:`<=`
+
+API Reference 请参考 :ref:`api_fluid_layers_less_equal`
+
+greater_than
+------------------
+
+对两个 :code:`Tensor` 逐元素判断是否满足大于关系， 对应数学操作符 :code:`>`
+
+API Reference 请参考 :ref:`api_fluid_layers_greater_than`
+
+greater_equal
+------------------
+
+对两个 :code:`Tensor` 逐元素判断是否满足大于或等于关系， 对应数学操作符 :code:`>=`
+
+API Reference 请参考 :ref:`api_fluid_layers_greater_equal`
+
+sum
+------------------
+
+对两个 :code:`Tensor` 逐元素相加。
+
+API Reference 请参考 :ref:`api_fluid_layers_sum`
+
+min
+------------------
+
+对两个 :code:`Tensor` 逐元素进行 :code:`min(x, y)` 操作。
+
+API Reference 请参考 :ref:`api_fluid_layers_min`
+
+max
+------------------
+
+对两个 :code:`Tensor` 逐元素进行 :code:`max(x, y)` 操作。
+
+API Reference 请参考 :ref:`api_fluid_layers_max`
+
+matmul
+------------------
+
+对两个 :code:`Tensor` 进行矩阵乘操作。
+
+API Reference 请参考 :ref:`api_fluid_layers_matmul`

doc/fluid/api_cn/api_guides/low_level/layers/pooling.rst

+.. _api_guide_pool:
+
+#####
+池化
+#####
+
+池化的作用是对输入特征做下采样和降低过拟合。降低过拟合是减小输出大小的结果，它同样也减少了后续层中的参数的数量。
+
+池化通常只需要将前一层的特征图作为输入，此外需要一些参数来确定池化具体的操作。在PaddlePaddle中我们同样通过设定池化的大小，方式，步长，是否是全局池化，是否使用cudnn，是否使用ceil函数计算输出等参数来选择具体池化的方式。
+PaddlePaddle中有针对定长图像特征的二维(pool2d)、三维卷积(pool3d)，RoI池化(roi_pool)，以及针对序列的序列池化(sequence_pool)，同时也有池化计算的反向过程，下面先介绍2D/3D池化，以及RoI池化，再来介绍序列池化。
+
+--------------
+
+1. pool2d/pool3d
+------------------------
+
+-  ``input`` : 池化操作接收任何符合layout是：\ ``N（batch size）* C(channel size) * H(height) * W(width)``\ 格式的\ ``Tensor``\ 类型作为输入。
+
+-  ``pool_size``\ : 用来确定池化\ ``filter``\ 的大小，即将多大范围内的数据池化为一个值。
+
+-  ``num_channels``\ : 用来确定输入的\ ``channel``\ 数量，如果未设置参数或设置为\ ``None``\ ，其实际值将自动设置为输入的\ ``channel``\ 数量。
+
+-  ``pooling_type``\ : 接收\ ``avg``\ 和\ ``max``\ 2种类型之一作为pooling的方式，默认值为\ ``max``\ 。其中\ ``max``\ 意为最大池化，即计算池化\ ``filter``\ 区域内的数据的最大值作为输出；而\ ``avg``\ 意为平均池化，即计算池化\ ``filter``\ 区域内的数据的平均值作为输出。
+
+-  ``pool_stride``\ : 意为池化的\ ``filter``\ 在输入特征图上移动的步长。
+
+-  ``pool_padding``\ : 用来确定池化中\ ``padding``\ 的大小，\ ``padding``\ 的使用是为了对于特征图边缘的特征进行池化，选择不同的\ ``pool_padding``\ 大小确定了在特征图边缘增加多大区域的补零。从而决定边缘特征被池化的程度。
+
+-  ``global_pooling``\ : 意为是否使用全局池化，全局池化是指使用和特征图大小相同的\ ``filter``\ 来进行池化，同样这个过程也可以使用平均池化或者最大池化来做为池化的方式，全局池化通常会用来替换全连接层以大量减少参数防止过拟合。
+
+-  ``use_cudnn``\ : 选项可以来选择是否使用cudnn来优化计算池化速度。
+
+-  ``ceil_mode``\ : 是否使用ceil函数计算输出高度和宽度。\ ``ceil mode``\ 意为天花板模式，是指会把特征图中不足\ ``filter size``\ 的边给保留下来，单独另算，或者也可以理解为在原来的数据上补充了值为-NAN的边。而floor模式则是直接把不足\ ``filter size``\ 的边给舍弃了。具体计算公式如下：
+    
+    -  非\ ``ceil_mode``\ 下:\ ``输出大小 = (输入大小 - filter size + 2 * padding) / stride（步长） + 1``
+    
+    -  ``ceil_mode``\ 下:\ ``输出大小 = (输入大小 - filter size + 2 * padding + stride - 1) / stride + 1``
+    	
+
+
+api汇总：
+
+- :ref:`api_fluid_layers_pool2d`
+- :ref:`api_fluid_layers_pool3d`
+
+
+2. roi_pool
+------------------
+
+``roi_pool``\ 一般用于检测网络中，将输入特征图依据候选框池化到特定的大小。
+
+-  ``rois``\ : 接收\ ``LoDTensor``\ 类型来表示需要池化的 Regions of Interest，关于RoI的解释请参考\ `论文 <https://arxiv.org/abs/1506.01497>`__
+
+-  ``pooled_height`` 和 ``pooled_width``\ : 这里可以接受非正方的池化窗口大小
+
+-  ``spatial_scale``\ : 用作设定缩放RoI和原图缩放的比例，注意，这里的设定需要用户自行计算RoI和原图的实际缩放比例。
+ 
+
+api汇总：
+
+- :ref:`api_fluid_layers_roi_pool`
+
+
+3. sequence_pool
+--------------------
+
+``sequence_pool``\ 是一个用作对于不等长序列进行池化的接口，它将每一个实例的全部时间步的特征进行池化，它同样支持
+``average``, ``sum``, ``sqrt`` 和\ ``max``\ 4种类型之一作为pooling的方式。 其中:
+
+-  ``average``\ 是对于每一个时间步内的数据求和后分别取平均值做为池化的结果。
+
+-  ``sum``\ 则是对每一个时间步内的数据分别求和作为池化的结果。
+
+-  ``sqrt``\ 则是对每一个时间步内的数据分别求和再分别取平方根作为池化的结果。
+
+-  ``max``\ 则是对每一个时间步内的数据分别求取最大值作为池化的结果。
+
+api汇总：
+
+- :ref:`api_fluid_layers_sequence_pool`
\ No newline at end of file

doc/fluid/api_cn/api_guides/low_level/layers/sequence.rst

+..  _api_guide_sequence:
+
+########
+序列
+########
+
+在深度学习领域许多问题涉及到对 `序列（sequence） <https://en.wikipedia.org/wiki/Sequence>`_ 的处理。
+从Wiki上的释义可知，序列可以表征多种物理意义，但在深度学习中，最常见的仍然是"时间序列"——一个序列包含多个时间步的信息。
+
+在Paddle Fluid中，我们将序列表示为 :ref:`api_fluid_LoDTensor` 。
+因为一般进行神经网络计算时都是一个batch一个batch地计算，所以我们用一个LoDTensor来存储一个mini batch的序列。
+一个LoDTensor的第0维包含该mini batch中所有序列的所有时间步，并且用LoD来记录各个序列的长度，区分不同序列。
+而在运算时，还需要根据LoD信息将LoDTensor中一个mini batch的第0维拆开成多个序列。（具体请参考上述LoD相关的文档。）
+所以，对这类LoDTensor第0维的操作不能简单地使用一般的layer来进行，针对这一维的操作必须要结合LoD的信息。
+(例如，你不能用 :code:`layers.reshape` 来对一个序列的第0维进行reshape)。
+
+为了实行各类针对序列的操作，我们设计了一系列序列相关的API，专门用于正确处理序列相关的操作。
+实践中，由于一个LoDTensor包括一个mini batch的序列，同一个mini batch中不同的序列通常属于多个sample，它们彼此之间不会也不应该发生相互作用。
+因此，若一个layer以两个（或多个）LoDTensor为输入（或者以一个list的LoDTensor为输入），每一个LoDTensor代表一个mini batch的序列，则第一个LoDTensor中的第一个序列只会和第二个LoDTensor中的第一个序列发生计算，
+第一个LoDTensor中的第二个序列只会和第二个LoDTensor中的第二个序列发生计算，第一个LoDTensor中的第i个序列只会和第二个LoDTensor中第i个序列发生计算，依此类推。
+
+**总而言之，一个LoDTensor存储一个mini batch的多个序列，其中的序列个数为batch size；多个LoDTensor间发生计算时，每个LoDTensor中的第i个序列只会和其他LoDTensor中第i个序列发生计算。理解这一点对于理解接下来序列相关的操作会至关重要。**
+
+1. sequence_softmax
+-------------------
+这个layer以一个mini batch的序列为输入，在每个序列内做softmax操作。其输出为一个mini batch相同shape的序列，但在序列内是经softmax归一化过的。
+这个layer往往用于在每个sequence内做softmax归一化。
+
+API Reference 请参考 :ref:`api_fluid_layers_sequence_softmax`
+
+
+2. sequence_concat
+------------------
+这个layer以一个list为输入，该list中可以含有多个LoDTensor，每个LoDTensor为一个mini batch的序列。
+该layer会将每个batch中第i个序列在时间维度上拼接成一个新序列，作为返回的batch中的第i个序列。
+理所当然地，list中每个LoDTensor的序列必须有相同的batch size。
+
+API Reference 请参考 :ref:`api_fluid_layers_sequence_concat`
+
+
+3. sequence_first_step
+----------------------
+这个layer以一个LoDTensor作为输入，会取出每个序列中的第一个元素（即第一个时间步的元素），并作为返回值。
+
+API Reference 请参考 :ref:`api_fluid_layers_sequence_first_step`
+
+
+4. sequence_last_step
+---------------------
+同 :code:`sequence_first_step` ，除了本layer是取每个序列中最后一个元素（即最后一个时间步）作为返回值。
+
+API Reference 请参考 :ref:`api_fluid_layers_sequence_last_step`
+
+
+5. sequence_expand
+------------------
+这个layer有两个LoDTensor的序列作为输入，并按照第二个LoDTensor中序列的LoD信息来扩展第一个batch中的序列。
+通常用来将只有一个时间步的序列（例如 :code:`sequence_first_step` 的返回结果）延展成有多个时间步的序列，以此方便与有多个时间步的序列进行运算。
+
+API Reference 请参考 :ref:`api_fluid_layers_sequence_expand`
+
+
+6. sequence_expand_as
+---------------------
+这个layer需要两个LoDTensor的序列作为输入，然后将第一个Tensor序列中的每一个序列延展成和第二个Tensor中对应序列等长的序列。
+不同于 :code:`sequence_expand` ，这个layer会将第一个LoDTensor中的序列严格延展为和第二个LoDTensor中的序列等长。
+如果无法延展成等长的（例如第二个batch中的序列长度不是第一个batch中序列长度的整数倍），则会报错。
+
+API Reference 请参考 :ref:`api_fluid_layers_sequence_expand_as`
+
+
+7. sequence_enumerate
+---------------------
+这个layer需要一个LoDTensor的序列作为输入，同时需要指定一个 :code:`win_size` 的长度。这个layer将依次取所有序列中长度为 :code:`win_size` 的子序列，并组合成新的序列。
+
+API Reference 请参考 :ref:`api_fluid_layers_sequence_enumerate`
+
+
+8. sequence_reshape
+-------------------
+这个layer需要一个LoDTensor的序列作为输入，同时需要指定一个 :code:`new_dim` 作为新的序列的维度。
+该layer会将mini batch内每个序列reshape为new_dim给定的维度。注意，每个序列的长度会改变（因此LoD信息也会变），以适应新的形状。
+
+API Reference 请参考 :ref:`api_fluid_layers_sequence_reshape`
+
+
+9. sequence_scatter
+-------------------
+这个layer可以将一个序列的数据scatter到另一个tensor上。这个layer有三个input，一个要被scatter的目标tensor :code:`input`；
+一个是序列的数据 :code:`update` ，一个是目标tensor的上坐标 :code:`index` 。Output为scatter后的tensor，形状和 :code:`input` 相同。
+
+API Reference 请参考 :ref:`api_fluid_layers_sequence_scatter`
+
+
+10. sequence_pad
+----------------
+这个layer可以将不等长的序列补齐成等长序列。使用这个layer需要提供一个 :code:`PadValue` 和一个 :code:`padded_length`。
+前者是用来补齐序列的元素，可以是一个数也可以是一个tensor；后者是序列补齐的目标长度。
+这个layer会返回补齐后的序列，以及一个记录补齐前各个序列长度的tensor :code:`Length`。
+
+API Reference 请参考 :ref:`api_fluid_layers_sequence_pad`
+
+
+11. sequence_mask
+-----------------
+这个layer会根据 :code:`input` 生成一个mask，:code:`input` 是一个记录了每个序列长度的tensor。
+此外这个layer还需要一个参数 :code:`maxlen` 用于指定序列中最长的序列长度。
+通常这个layer用于生成一个mask，将被pad后的序列中pad的部分过滤掉。
+:code:`input` 的长度tensor通常可以直接用 :code:`sequence_pad` 返回的 :code:`Length`。
+
+API Reference 请参考 :ref:`api_fluid_layers_sequence_mask`
+

doc/fluid/api_cn/api_guides/low_level/layers/sparse_update.rst

+.. _api_guide_sparse_update:
+
+#####
+稀疏更新
+#####
+
+Fluid的 :ref:`api_fluid_layers_embedding`  层在单机训练和分布式训练时，均可以支持“稀疏更新”，即梯度以sparse tensor 结构存储，只保存梯度不为0的行。
+在分布式训练中，对于较大的embedding层，开启稀疏更新有助于减少通信数据量，提升训练速度。
+
+在paddle内部，我们用lookup_table来实现embedding。下边这张图说明了embedding在正向和反向计算的过程：
+
+如图所示：一个Tensor中有两行不为0，正向计算的过程中，我们使用ids存储不为0的行，并使用对应的两行数据来进行计算；反向更新的过程也只更新这两行。
+
+.. image:: ../../../../images/lookup_table_training.png
+   :scale: 50 %
+
+embedding使用例子:
+---------------------
+
+API详细使用方法参考 :ref:`api_fluid_layers_embedding` ，以下是一个简单的例子：
+
+.. code-block:: python
+
+   DICT_SIZE = 10000 * 10
+   EMBED_SIZE = 64
+   IS_SPARSE = False
+   def word_emb(word, dict_size=DICT_SIZE, embed_size=EMBED_SIZE):
+       embed = fluid.layers.embedding(
+           input=word,
+           size=[dict_size, embed_size],
+           dtype='float32',
+           param_attr=fluid.ParamAttr(
+               initializer=fluid.initializer.Normal(scale=1/math.sqrt(dict_size))),
+           is_sparse=IS_SPARSE,
+           is_distributed=False)
+       return embed
+
+以上参数中：
+
+- :code:`is_sparse` ： 反向计算的时候梯度是否为sparse tensor。如果不设置，梯度是一个 `LodTensor <https://github.com/PaddlePaddle/FluidDoc/blob/develop/doc/fluid/user_guides/howto/prepare_data/lod_tensor.md>`_  。默认为False。
+
+- :code:`is_distributed` ： 标志是否是用在分布式的场景下。一般大规模稀疏更新（embedding的第0维维度很大，比如几百万以上）才需要设置。具体可以参考大规模稀疏的API guide  :ref:`api_guide_async_training`  。默认为False。
+
+- API汇总:
+ - :ref:`api_fluid_layers_embedding`

doc/fluid/api_cn/api_guides/low_level/layers/tensor.rst

+..  _api_guide_tensor:
+
+########
+张量
+########
+
+Fluid 中使用两种数据结构来承载数据，分别是 `Tensor 和 LoD_Tensor <../../../../user_guides/howto/prepare_data/lod_tensor.html>`_ 。 其中 LoD-Tensor 是 Fluid 的特有概念，它在 Tensor 基础上附加了序列信息。框架中可传输的数据包括：输入、输出、网络中的可学习参数，全部统一使用 LoD-Tensor 表示，Tensor 可以看作是一种特殊的 LoD-Tensor。
+
+下面介绍这两种数据的相关操作。
+
+Tensor
+=======
+
+1. create_tensor
+---------------------
+Tensor用于在框架中承载数据，使用 :code:`create_tensor` 可以创建一个指定数据类型的Lod-Tensor变量，
+
+API reference 请参考： :ref:`api_fluid_layers_create_tensor`
+
+
+2. create_parameter
+---------------------
+神经网络的训练过程是一个对参数的学习过程，Fluid 使用 :code:`create_parameter` 创建一个可学习的参数。该参数的值可以被operator改变。
+
+API reference 请参考：:ref:`api_fluid_layers_create_parameter`
+
+
+
+3. create_global_var
+---------------------
+Fluid 使用 :code:`create_global_var` 创建一个全局tensor，通过此 API 可以指定被创建 Tensor 变量的数据类型、形状和值。
+
+API reference 请参考：:ref:`api_fluid_layers_create_global_var`
+
+
+4. cast
+---------------
+
+Fluid 使用 :code:`cast` 将数据转换为指定类型。
+
+API reference 请参考：:ref:`api_fluid_layers_cast`
+
+
+5. concat
+----------------
+
+Fluid 使用 :code:`concat` 将输入数据沿指定维度连接。
+
+API reference 请参考：:ref:`api_fluid_layers_concat`
+
+
+6. sums
+----------------
+
+Fluid 使用 :code:`sums` 执行对输入数据的加和。
+
+API reference 请参考：:ref:`api_fluid_layers_sums`
+
+
+7. fill_constant_batch_size_like
+---------------------------------
+
+Fluid 使用 :code:`fill_constant_batch_size_like` 创建一个具有特定形状、类型和 batch_size 的 Tensor。并且该Tensor的初始值可以被指定为任意常数。其中 batch_size 信息由该tensor的 :code:`input_dim_idx` 和 :code:`output_dim_idx` 确定。
+
+API reference 请参考：:ref:`api_fluid_layers_fill_constant_batch_size_like`
+
+8. fill_constant
+-----------------
+
+Fluid 使用 :code:`fill_constant` 创建一个具有特定形状和类型的 Tensor。可以通过 :code:`value` 设置该变量的初始值。
+
+API reference 请参考： :ref:`api_fluid_layers_fill_constant`
+
+9. assign
+---------------
+
+Fluid 使用 :code:`assign` 复制一个变量。
+
+API reference 请参考：:ref:`api_fluid_layers_assign`
+
+10. argmin
+--------------
+
+Fluid 使用 :code:`argmin` 计算输入 Tensor 指定轴上最小元素的索引。
+
+API reference 请参考：:ref:`api_fluid_layers_assign`
+
+11. argmax
+-----------
+
+Fluid 使用 :code:`argmax` 计算输入 Tensor 指定轴上最大元素的索引。
+
+API reference 请参考：:ref:`api_fluid_layers_argmax`
+
+12. argsort
+------------
+
+Fluid 使用 :code:`argsort` 对输入 Tensor 在指定轴上进行排序，并返回排序后的数据变量及其对应的索引值。
+
+API reference 请参考： :ref:`api_fluid_layers_argsort`
+
+13. ones
+-------------
+
+Fluid 使用 :code:`ones` 创建一个指定大小和数据类型的Tensor，且初始值为1。
+
+API reference 请参考： :ref:`api_fluid_layers_ones`
+
+14. zeros
+---------------
+
+Fluid 使用 :code:`zeros` 创建一个指定大小和数据类型的Tensor，且初始值为0。
+
+API reference 请参考： :ref:`api_fluid_layers_zeros`
+
+15. reverse
+-------------------
+
+Fluid 使用 :code:`reverse` 沿指定轴反转 Tensor。
+
+API reference 请参考： :ref:`api_fluid_layers_reverse`
+
+
+
+LoD-Tensor
+============
+
+LoD-Tensor非常适用于序列数据，相关知识可以参考阅读 `LoD_Tensor <../../../../user_guides/howto/prepare_data/lod_tensor.html>`_ 。
+
+1. create_lod_tensor
+-----------------------
+
+Fluid 使用 :code:`create_lod_tensor` 基于numpy数组、列表或现有 LoD_Tensor 创建拥有新的层级信息的 LoD_Tensor。
+
+API reference 请参考： :ref:`api_fluid_create_lod_tensor`
+
+2. create_random_int_lodtensor
+----------------------------------
+
+Fluid 使用 :code:`create_random_int_lodtensor` 创建一个由随机整数组成的 LoD_Tensor。
+
+API reference 请参考： :ref:`api_fluid_create_random_int_lodtensor`
+
+3. reorder_lod_tensor_by_rank
+---------------------------------
+
+Fluid 使用 :code:`reorder_lod_tensor_by_rank` 对输入 LoD_Tensor 的序列信息按指定顺序重拍。
+
+API reference 请参考：:ref:`api_fluid_layers_reorder_lod_tensor_by_rank`
\ No newline at end of file

doc/fluid/api_cn/api_guides/low_level/memory_optimize.rst

+.. _api_guide_memory_optimize:
+
+#####
+显存优化
+#####
+
+显存优化是通过分析、复用 :code:`Program` 中 :code:`Varaible` 使用的显存，从而降低 :code:`Program` 执行时显存消耗的方法。用户可以通过Python脚本调用 :code:`memory_optimize` 接口进行显存优化，显存优化的执行策略如下：
+
+- 首先根据 :code:`Program` 中 :code:`Operator` 之间的关系对 :code:`Variable` 的最后存活时间进行分析，得到每个 :code:`Variable` 的最后存活时间;
+- 其次根据每个 :code:`Variable` 的最后存活时间，我们将到达存活时间、不再存活的 :code:`Variable` 所占用的显存提供给后来的 :code:`Variable` 使用。
+
+.. code-block:: python
+
+    z = fluid.layers.sum([x, y])
+    m = fluid.layers.matmul(y, z)
+
+在这个示例中，:code:`x` 的存活时间到 :code:`fluid.layers.sum` 操作为止，所以它的显存可以被 :code:`m` 复用。
+
+针对特定部分禁用显存优化
+===========
+
+:code:`memory_optimize` 支持针对特定部分禁用显存优化，用户可以通过传入 :code:`Variable` 名字的集合来指定哪些 :code:`Variable` 所使用的显存不会被复用;
+与此同时，:code:`memory_optimize` 能够针对网络的反向部分禁用显存优化，用户可以通过传入 :code:`skip_grads` 参数来开启这个功能。
+
+.. code-block:: python
+
+    fluid.memory_optimize(fluid.default_main_program(),
+        skip_opt_set=("fc"), skip_grads=True)
+
+在这个示例中，:code:`fluid.memory_optimize` 接口对默认的 :code:`Program` 进行了 :code:`Variable` 最后存活时间的分析，并跳过了名字为 :code:`fc` 的 :code:`Variable` 以及网络反向部分的所有 :code:`Variable` 。
+这部分 :code:`Variable` 的显存都不会被别的 :code:`Varaible` 再次使用。
+
+指定显存优化等级
+===========
+
+:code:`memory_optimize` 支持打印显存复用的信息以方便用户进行调试，用户可以通过指定 :code:`print_log=True` 来开启显存复用的调试信息;
+
+:code:`memory_optimize` 支持两种显存优化的等级，:code:`0` 或者 :code:`1` :
+
+- 优化等级为 :code:`0` 时： :code:`memory_optimize` 在分析完 :code:`Variable` 的最后生存时间后，会判断 :code:`Variable` 的 :code:`shape` ，只有 :code:`shape` 相同的 :code:`Variable` 才会进行显存复用；
+- 优化等级为 :code:`1` 时： :code:`memory_optimize` 会尽可能地进行显存复用，在分析完 :code:`Variable` 的最后生存时间后，即使是 :code:`shape` 不同的 :code:`Variable` 也会进行最大程度的显存复用。
+
+.. code-block:: python
+
+    fluid.memory_optimize(fluid.default_main_program(),
+        level=0, print_log=True)
+
+在这个示例中，:code:`fluid.memory_optimize` 接口对默认的 :code:`Program` 进行了 :code:`Variable` 最后存活时间的分析。
+只有 :code:`shape` 完全相同的 :code:`Variable` 才会进行显存复用，并且在分析结束后，会打印出所有显存复用相关的调试信息。

doc/fluid/api_cn/api_guides/low_level/metrics.rst

+..  _api_guide_metrics:
+
+
+评价指标
+#########
+在神经网络训练过程中或者训练完成后，需要评价模型的训练效果。评价的方法一般是计算全体预测值和全体真值(label)之间的距离，不同类型的任务会使用不同的评价方法，或者综合使用多个评价方法。在具体的任务中，可以选用一种或者多种评价方法。下面对常用的评价方法按照任务类型做介绍。
+
+分类任务评价
+------------------
+分类任务中最常用的是二分类，而多分类任务也可以转化为多个二分类任务的组合，二分类任务常用的评价指标有准确率、正确率、召回率、AUC和平均准确度。
+
+- 准确率: :code:`Precision` ，用来衡量二分类中召回真值和召回值的比例。
+
+  API Reference 请参考 :ref:`api_fluid_metrics_Precision` 
+
+- 正确率: :code:`Accuracy` ，用来衡量二分类中召回真值和总样本数的比例。需要注意的是，准确率和正确率的定义是不同的，可以类比于误差分析中的 :code:`Variance` 和 :code:`Bias` 。
+
+  API Reference 请参考 :ref:`api_fluid_metrics_Accuracy` 
+
+
+- 召回率: :code:`Recall` ，用来衡量二分类中召回值和总样本数的比例。准确率和召回率的选取相互制约，实际模型中需要进行权衡，可以参考文档 `Precision_and_recall <https://en.wikipedia.org/wiki/Precision_and_recall>`_ 。
+
+  API Reference 请参考 :ref:`api_fluid_metrics_Recall` 
+
+- AUC: :code:`Area Under Curve`， 适用于二分类的分类模型评估，用来计算 `ROC曲线的累积面积 <https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve>`_。:code:`Auc` 通过python计算实现，如果关注性能，可以使用 :code:`fluid.layers.auc` 代替。
+
+  API Reference 请参考 :ref:`api_fluid_metrics_Auc` 
+
+- 平均准确度: :code:`Average Precision` ，常用在Faster R-CNN和SSD等物体检测任务中。在不同召回条件下，计算了准确率的平均值，具体可以参考文档 `Average-precision <https://sanchom.wordpress.com/tag/average-precision/>`_ 和 `SSD: Single Shot MultiBox Detector <https://arxiv.org/abs/1512.02325>`_。
+
+  API Reference 请参考 :ref:`api_fluid_metrics_DetectionMAP`
+
+
+
+序列标注任务评价
+------------------
+序列标注任务中，token的分组称为语块(chunk)，模型会同时将输入的token分组和分类，常用的评估方法是语块评估方法。
+
+- 语块评估方法: :code:`ChunkEvaluator` ，接收 :code:`chunk_eval` 接口的输出，累积每一个minibatch的语块统计值，最后计算准确率、召回率和F1值。:code:`ChunkEvaluator` 支持IOB, IOE, IOBES和IO四种标注模式。可以参考文档 `Chunking with Support Vector Machines <https://aclanthology.info/pdf/N/N01/N01-1025.pdf>`_ 。
+
+  API Reference 请参考 :ref:`api_fluid_metrics_ChunkEvaluator`
+
+
+生成任务评价
+------------------
+生成任务会依据输入直接产生输出。对应NLP任务中(比如语音识别)，则生成新字符串。评估生成字符串和目标字符串之间距离的方法也有多种，比如多分类评估方法，而另外一种常用的方法叫做编辑距离。
+
+- 编辑距离: :code:`EditDistance` ，用来衡量两个字符串的相似度。可以参考文档 `Edit_distance <https://en.wikipedia.org/wiki/Edit_distance>`_。
+
+  API Reference 请参考 :ref:`api_fluid_metrics_EditDistance`
+

doc/fluid/api_cn/api_guides/low_level/model_save_reader.rst

+..  _api_guide_model_save_reader:
+
+#########
+模型保存与加载
+#########
+
+模型的保存与加载主要涉及到如下八个API：
+:code:`fluid.io.save_vars`、:code:`fluid.io.save_params`、:code:`fluid.io.save_persistables`、:code:`fluid.io.save_inference_model`、:code:`fluid.io.load_vars`、:code:`fluid.io.load_params`、:code:`fluid.io.load_persistables` 和 :code:`fluid.io.load_inference_model`。
+
+变量、持久性变量和参数
+====================
+
+在 :code:`Paddle` 中，算子(:code:`Operator`)的每一个输入和输出都是一个变量（:code:`Variable`），而参数（:code:`Parameter`）是变量（:code:`Variable`）的子类。持久性变量（:code:`Persistables`）是一种在每次迭代结束后均不会被删除的变量。参数是一种持久性变量，其在每次迭代后都会被优化器（:ref:`api_guide_optimizer`）更新。训练神经网络本质上就是在更新参数。
+
+模型保存API介绍
+====================
+
+- :code:`fluid.io.save_vars`：通过执行器（:ref:`api_guide_executor`）保存变量到指定的目录中。保存变量的方式有两种：
+
+  1）通过接口中的 :code:`vars` 指定需要保存的变量列表。
+
+  2）将一个已经存在的程序（:code:`Program`）赋值给接口中的 :code:`main_program`，然后这个程序中的所有变量都将被保存下来。
+
+  第一种保存方式的优先级要高于第二种。
+
+  API Reference 请参考 :ref:`api_fluid_io_save_vars`。
+
+- :code:`fluid.io.save_params`：通过接口中的 :code:`main_program` 指定好程序（:code:`Program`），该接口会将所指定程序中的全部参数（:code:`Parameter`）过滤出来，并将它们保存到 :code:`dirname` 指定的文件夹或 :code:`filename` 指定的文件中。
+
+  API Reference 请参考 :ref:`api_fluid_io_save_params`。
+
+- :code:`fluid.io.save_persistables`：通过接口中的 :code:`main_program` 指定好程序（:code:`Program`），该接口会将所指定程序中的全部持久性变量（:code:`persistable==True`）过滤出来，并将它们保存到 :code:`dirname` 指定的文件夹或 :code:`filename` 指定的文件中。
+
+  API Reference 请参考 :ref:`api_fluid_io_save_persistables`。
+
+- :code:`fluid.io.save_inference_model`：请参考  :ref:`api_guide_inference`。  
+
+模型加载API介绍
+====================
+
+- :code:`fluid.io.load_vars`：通过执行器（:code:`Executor`）加载指定目录中的变量。加载变量的方式有两种：
+  
+  1）通过接口中的 :code:`vars` 指定需要加载的变量列表。
+  
+  2）将一个已经存在的程序（:code:`Program`）赋值给接口中的 :code:`main_program`，然后这个程序中的所有变量都将被加载。
+
+  第一种加载方式的优先级要高于第二种。
+
+  API Reference 请参考 :ref:`api_fluid_io_load_vars`。
+
+- :code:`fluid.io.load_params`：该接口从 :code:`main_program` 指定的程序中过滤出全部参数（:code:`Parameter`），并试图从 :code:`dirname` 指定的文件夹或 :code:`filename` 指定的文件中加载这些参数。
+
+  API Reference 请参考 :ref:`api_fluid_io_load_params`。
+
+- :code:`fluid.io.load_persistables`：该接口从 :code:`main_program` 指定的程序中过滤出全部持久性变量（:code:`persistable==True`），并试图从 :code:`dirname` 指定的文件夹或 :code:`filename` 指定的文件中加载这些持久性变量。
+
+  API Reference 请参考 :ref:`api_fluid_io_load_persistables`。
+
+-  :code:`fluid.io.load_inference_model`：请参考  :ref:`api_guide_inference`。

doc/fluid/api_cn/api_guides/low_level/nets.rst

+..  _api_guide_nets:
+
+###########
+复杂网络
+###########
+
+在处理复杂功能时，我们通常需要写大量的代码来构建复杂的 `神经网络 <https://zh.wikipedia.org/wiki/人工神经网络>`_ 。
+因此，为了方便用户更加容易地搭建复杂网络模型，我们提供了一些比较常用的基本函数模块，以此来简化用户的代码量，从而降低开发成本。
+这些模块通常是由细粒度的函数根据一定的逻辑拼接组合而成，实现代码请参考 `nets.py <https://github.com/PaddlePaddle/Paddle/blob/develop/python/paddle/fluid/nets.py>`_ 。
+
+1.simple_img_conv_pool
+----------------------
+
+:code:`simple_img_conv_pool` 是由 :ref:`api_fluid_layers_conv2d` 与 :ref:`api_fluid_layers_pool2d` 串联而成。
+该模块在图像分类模型中广泛使用，比如应用在 `MNIST <https://en.wikipedia.org/wiki/MNIST_database>`_ 数字分类的问题。
+
+API Reference 请参考 :ref:`api_fluid_nets_simple_img_conv_pool`
+
+
+2.img_conv_group
+----------------
+
+:code:`img_conv_group` 是由 :ref:`api_fluid_layers_conv2d` , :ref:`api_fluid_layers_batch_norm`, :ref:`api_fluid_layers_dropout` 和 :ref:`api_fluid_layers_pool2d` 组成。
+该模块可以实现多个 :ref:`api_fluid_layers_conv2d` , :ref:`api_fluid_layers_batch_norm` 和 :ref:`api_fluid_layers_dropout` 的串联单元与一个 :ref:`api_fluid_layers_pool2d` 的组合。
+其中， :ref:`api_fluid_layers_conv2d` , :ref:`api_fluid_layers_batch_norm` 和 :ref:`api_fluid_layers_dropout` 的数量都可以分别控制，从而得到多样的组合。
+该模块广泛使用在比较复杂的图像分类任务中，比如 `VGG <https://arxiv.org/pdf/1409.1556.pdf>`_ 。
+
+API Reference 请参考 :ref:`api_fluid_nets_img_conv_group`
+
+
+3.sequence_conv_pool
+--------------------
+
+:code:`sequence_conv_pool` 是由 :ref:`api_fluid_layers_sequence_conv` 与 :ref:`api_fluid_layers_sequence_pool` 串联而成。
+该模块在 `自然语言处理 <https://zh.wikipedia.org/wiki/自然语言处理>`_ 以及 `语音识别 <https://zh.wikipedia.org/wiki/语音识别>`_ 等领域均有广泛应用，
+比如 `文本分类模型 <https://github.com/PaddlePaddle/models/blob/develop/fluid/PaddleNLP/text_classification/nets.py>`_ , 
+`TagSpace <https://github.com/PaddlePaddle/models/blob/develop/fluid/PaddleRec/tagspace/train.py>`_  以及 `Multi-view Simnet <https://github.com/PaddlePaddle/models/blob/develop/fluid/PaddleRec/multiview_simnet/nets.py>`_ 等模型。
+
+API Reference 请参考 :ref:`api_fluid_nets_sequence_conv_pool`
+
+
+4.glu
+-----
+:code:`glu` 全称 Gated Linear Units， 来源于论文 `Language Modeling with Gated Convolutional Networks <https://arxiv.org/pdf/1612.08083.pdf>`_ ，由 :ref:`api_fluid_layers_split` ， :ref:`api_fluid_layers_sigmoid` 和 :ref:`api_fluid_layers_elementwise_mul` 组成。
+它会把输入数据均分为2等份，并对第二部分求 `Sigmoid <https://en.wikipedia.org/wiki/Sigmoid_function>`_ , 然后再与第一部分数据求点乘得到输出。
+
+API Reference 请参考 :ref:`api_fluid_nets_glu`
+
+
+5.scaled_dot_product_attention
+------------------------------
+:code:`scaled_dot_product_attention` 来源于论文 `Attention Is All You Need <https://arxiv.org/pdf/1706.03762.pdf>`_ ，主要是由 :ref:`api_fluid_layers_fc` 和 :ref:`api_fluid_layers_softmax` 组成。
+对于输入数据 :code:`Queries` , :code:`Key` 和 :code:`Values` 按照如下公式求出 :code:`Attention` 。
+
+.. math::
+ Attention(Q, K, V)= softmax(QK^\mathrm{T})V
+
+该模块广泛使用在 `机器翻译 <https://zh.wikipedia.org/zh/机器翻译>`_ 的模型中，比如 `Transformer <https://github.com/PaddlePaddle/models/tree/develop/fluid/PaddleNLP/neural_machine_translation/transformer>`_ 。
+
+API Reference 请参考 :ref:`api_fluid_nets_scaled_dot_product_attention`
+

doc/fluid/api_cn/api_guides/low_level/optimizer.rst

+..  _api_guide_optimizer:
+
+###########
+优化器
+###########
+
+神经网络最终是一个 `最优化问题 <https://en.wikipedia.org/wiki/Optimization_problem>`_ ，
+在经过 `前向计算和反向传播 <https://zh.wikipedia.org/zh-hans/反向传播算法>`_ 后，
+:code:`Optimizer` 使用反向传播梯度，优化神经网络中的参数。
+
+1.SGD/SGDOptimizer
+------------------
+
+:code:`SGD` 是实现 `随机梯度下降 <https://arxiv.org/pdf/1609.04747.pdf>`_ 的一个 :code:`Optimizer` 子类，是 `梯度下降 <https://zh.wikipedia.org/zh-hans/梯度下降法>`_ 大类中的一种方法。
+当需要训练大量样本的时候，往往选择 :code:`SGD` 来使损失函数更快的收敛。  
+
+API Reference 请参考 :ref:`api_fluid_optimizer_SGDOptimizer`
+
+
+2.Momentum/MomentumOptimizer
+----------------------------
+
+:code:`Momentum` 优化器在 :code:`SGD` 基础上引入动量，减少了随机梯度下降过程中存在的噪声问题。
+用户在使用时可以将 :code:`ues_nesterov` 参数设置为False或True，分别对应传统 `Momentum(论文4.1节)
+<https://arxiv.org/pdf/1609.04747.pdf>`_  算法和 `Nesterov accelerated gradient(论文4.2节)
+<https://arxiv.org/pdf/1609.04747.pdf>`_ 算法。
+
+API Reference 请参考 :ref:`api_fluid_optimizer_MomentumOptimizer`
+
+
+3. Adagrad/AdagradOptimizer
+---------------------------
+`Adagrad <http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf>`_ 优化器可以针对不同参数样本数不平均的问题，自适应地为各个参数分配不同的学习率。
+
+API Reference 请参考 :ref:`api_fluid_optimizer_AdagradOptimizer`
+
+
+4.RMSPropOptimizer
+------------------
+`RMSProp优化器 <http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf>`_ ，是一种自适应调整学习率的方法，
+主要解决使用Adagrad后，模型训练中后期学习率急剧下降的问题。
+
+API Reference 请参考 :ref:`api_fluid_optimizer_RMSPropOptimizer`
+
+
+
+5.Adam/AdamOptimizer
+--------------------
+`Adam <https://arxiv.org/abs/1412.6980>`_ 的优化器是一种自适应调整学习率的方法，
+适用于大多非 `凸优化 <https://zh.wikipedia.org/zh/凸優化>`_ 、大数据集和高维空间的场景。在实际应用中，:code:`Adam` 是最为常用的一种优化方法。
+
+API Reference 请参考 :ref:`api_fluid_optimizer_AdamOptimizer`
+
+
+
+6.Adamax/AdamaxOptimizer
+------------------------
+
+`Adamax <https://arxiv.org/abs/1412.6980>`_ 是 :code:`Adam` 算法的一个变体，对学习率的上限提供了一个更简单的范围，使学习率的边界范围更简单。
+
+API Reference 请参考 :ref:`api_fluid_optimizer_AdamaxOptimizer`
+
+
+
+7.DecayedAdagrad/ DecayedAdagradOptimizer
+-------------------------------------------
+
+`DecayedAdagrad <http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf>`_ 优化器，可以看做是引入了衰减速率的 :code:`Adagrad` 算法，解决使用Adagrad后，模型训练中后期学习率急剧下降的问题。
+
+API Reference 请参考 :ref:`api_fluid_optimizer_DecayedAdagrad`
+
+
+
+
+8. Ftrl/FtrlOptimizer
+----------------------
+
+`FtrlOptimizer <https://www.eecs.tufts.edu/~dsculley/papers/ad-click-prediction.pdf>`_ 优化器结合了 `FOBOS算法 <https://stanford.edu/~jduchi/projects/DuchiSi09b.pdf>`_ 的高精度与 `RDA算法
+<http://www1.se.cuhk.edu.hk/~sqma/SEEM5121_Spring2015/dual-averaging.pdf>`_ 的稀疏性，是目前效果非常好的一种 `Online Learning <https://en.wikipedia.org/wiki/Online_machine_learning>`_ 算法。
+
+API Reference 请参考 :ref:`api_fluid_optimizer_FtrlOptimizer`
+
+
+
+9.ModelAverage
+-----------------
+
+:code:`ModelAverage` 优化器，在训练中通过窗口来累计历史 parameter，在预测时使用取平均值后的paramet，整体提高预测的精度。
+
+API Reference 请参考 :ref:`api_fluid_optimizer_ModelAverage`
+
+

doc/fluid/api_cn/api_guides/low_level/parallel_executor.rst

+.. _api_guide_parallel_executor:
+
+#####
+数据并行执行引擎
+#####
+
+
+:code:`ParallelExecutor` 是以数据并行的方式在多个节点上分别执行 :code:`Program` 的执行器。用户可以通过Python脚本驱动 :code:`ParallelExecutor` 执行， :code:`ParallelExecutor` 的执行过程：
+
+- 首先根据 :code:`Program` 、 :code:`GPU` 卡的数目（或者 :code:`CPU` 的核数）以及 :ref:`api_fluid_BuildStrategy` 构建 :code:`SSA Graph` 和一个线程池;
+- 执行过程中，根据Op的输入是否Ready决定是否执行该Op，这样可以使没有相互依赖的多个Op可在线程池中并行执行；
+
+:code:`ParallelExecutor` 在构造时需要指定当前 :code:`Program` 的设备类型， :code:`GPU` 或者 :code:`CPU` ：
+
+* 使用 :code:`GPU` 执行： :code:`ParallelExecutor` 会自动检测当前机器可以使用 :code:`GPU` 的个数，并在每个 :code:`GPU` 上分别执行 :code:`Program` ，用户也可以通过设置 :code:`CUDA_VISIBLE_DEVICES` 环境变量来指定执行器可使用的 :code:`GPU` ；
+* 使用 :code:`CPU` 多线程执行：:code:`ParallelExecutor` 会自动检测当前机器可利用的 :code:`CPU` 核数，并将 :code:`CPU` 核数作为执行器中线程的个数，每个线程分别执行 :code:`Program` ，用户也可以通过设置 :code:`CPU_NUM` 环境变量来指定当前训练使用的线程个数。
+
+:code:`ParallelExecutor` 支持模型训练和模型预测：
+
+* 模型训练： :code:`ParallelExecutor` 在执行过程中对多个节点上的参数梯度进行聚合，然后进行参数的更新；
+* 模型预测： :code:`ParallelExecutor` 在执行过程中各个节点独立运行当前的  :code:`Program` ；
+
+:code:`ParallelExecutor` 在模型训练时支持两种模式的梯度聚合, :code:`AllReduce` 和 :code:`Reduce` ：
+
+* :code:`AllReduce` 模式下， :code:`ParallelExecutor` 调用AllReduce操作使多个节点上参数梯度完全相等，然后各个节点独立进行参数的更新；
+* :code:`Reduce` 模式下， :code:`ParallelExecutor` 会预先将所有参数的更新分派到不同的节点上，在执行过程中 :code:`ParallelExecutor` 调用Reduce操作将参数梯度在预先指定的节点上进行聚合，并进行参数更新，最后调用Broadcast操作将更新后的参数发送到其他节点。
+
+这两种模式通过 :code:`build_strategy` 来指定，使用方法，请参考 :ref:`api_fluid_BuildStrategy` 。
+
+**注意** ：如果在Reduce模式下使用 :code:`CPU` 多线程执行 :code:`Program` ， :code:`Program` 的参数在多个线程间是共享的，在某些模型上，Reduce模式可以大幅节省内存。
+
+由于模型的执行速度与模型结构和执行器的执行策略相关， :code:`ParallelExecutor` 允许用户修改执行器的相关参数，如：线程池大小（ :code:`num_threads` ）、多少次迭代之后清理一次临时变量 :code:`num_iteration_per_drop_scope` 等，更多信息请参考 :ref:`api_fluid_ExecutionStrategy` >。
+
+- 相关API汇总:
+ - :ref:`api_fluid_ParallelExecutor`
+ - :ref:`api_fluid_BuildStrategy`
+ - :ref:`api_fluid_ExecutionStrategy`
\ No newline at end of file

doc/fluid/api_cn/api_guides/low_level/parameter.rst

+..  _api_guide_parameter:
+
+#########
+模型参数
+#########
+
+模型参数为模型中的weight和bias统称，在fluid中对应fluid.Parameter类，继承自fluid.Variable，是一种可持久化的variable。模型的训练就是不断学习更新模型参数的过程。模型参数相关的属性可以通过 :ref:`api_fluid_param_attr_ParamAttr` 来配置，可配置内容有：
+
+- 初始化方式
+- 正则化
+- 梯度剪切
+- 模型平均
+
+初始化方式
+=================
+
+fluid通过设置 :code:`ParamAttr` 的 :code:`initializer` 属性为单个parameter设置初始化方式。
+示例如下：
+
+  .. code-block:: python
+
+      param_attrs = fluid.ParamAttr(name="fc_weight",
+                                initializer=fluid.initializer.ConstantInitializer(1.0))
+      y_predict = fluid.layers.fc(input=x, size=10, param_attr=param_attrs)
+
+
+以下为fluid支持的初始化方式：
+
+1. BilinearInitializer
+-----------------------
+
+线性初始化方法。用该方法初始化的反卷积操作可当做线性插值操作使用。
+
+可用别名：Bilinear
+
+API请参考：:ref:`api_fluid_initializer_BilinearInitializer`
+
+2. ConstantInitializer
+----------------------
+
+常数初始化方式，将parameter初始化为指定的数值。
+
+可用别名：Constant
+
+API请参考：:ref:`api_fluid_initializer_ConstantInitializer`
+
+3. MSRAInitializer
+------------------
+
+该初始化方法参考论文: https://arxiv.org/abs/1502.01852
+
+可用别名：MSRA
+
+API请参考：:ref:`api_fluid_initializer_MSRAInitializer`
+
+4. NormalInitializer
+---------------------
+
+随机高斯分布初始化方法。
+
+可用别名：Normal
+
+API请参考：:ref:`api_fluid_initializer_NormalInitializer`
+
+5. TruncatedNormalInitializer
+-----------------------------
+
+随机截断高斯分布初始化方法。
+
+可用别名：TruncatedNormal
+
+API请参考：:ref:`api_fluid_initializer_TruncatedNormalInitializer`
+
+6. UniformInitializer
+--------------------
+
+随机均匀分布初始化方式。
+
+可用别名：Uniform
+
+API请参考：:ref:`api_fluid_initializer_UniformInitializer`
+
+7. XavierInitializer
+--------------------
+
+该初始化方式参考论文: http://proceedings.mlr.press/v9/glorot10a/glorot10a.pdf
+
+可用别名：Xavier
+
+API请参考：:ref:`api_fluid_initializer_XavierInitializer`
+
+正则化方式
+=============
+
+fluid通过设置 :code:`ParamAttr` 的 :code:`regularizer` 属性为单个parameter设置正则化。
+
+  .. code-block:: python
+
+      param_attrs = fluid.ParamAttr(name="fc_weight",
+                                regularizer=fluid.regularizer.L1DecayRegularizer(0.1))
+      y_predict = fluid.layers.fc(input=x, size=10, param_attr=param_attrs)
+
+以下为fluid支持的正则化方式：
+
+- :ref:`api_fluid_regularizer_L1DecayRegularizer` (别名：L1Decay)
+- :ref:`api_fluid_regularizer_L2DecayRegularizer` (别名：L2Decay)
+
+Clipping
+==========
+
+fluid通过设置 :code:`ParamAttr` 的 :code:`gradient_clip` 属性为单个parameter设置clipping方式。
+
+  .. code-block:: python
+
+      param_attrs = fluid.ParamAttr(name="fc_weight",
+                                regularizer=fluid.regularizer.L1DecayRegularizer(0.1))
+      y_predict = fluid.layers.fc(input=x, size=10, param_attr=param_attrs)
+
+
+以下为fluid支持的clipping方式：
+
+1. ErrorClipByValue
+-------------------
+
+用来将一个tensor的值clipping到指定范围。
+
+API请参考：:ref:`api_fluid_clip_ErrorClipByValue`
+
+2. GradientClipByGlobalNorm
+---------------------------
+
+用来将多个Tensor的global-norm限制在 :code:`clip_norm` 以内。
+
+API请参考：:ref:`api_fluid_clip_GradientClipByGlobalNorm`
+
+3. GradientClipByNorm
+---------------------
+
+将Tensor的l2-norm限制在 :code:`max_norm` 以内。如果Tensor的l2-norm超过了 :code:`max_norm` ，
+会将计算出一个 :code:`scale` ，该Tensor的所有值乘上计算出来的 :code:`scale` .
+
+API请参考：:ref:`api_fluid_clip_GradientClipByNorm`
+
+4. GradientClipByValue
+----------------------
+
+将parameter对应的gradient的值限制在[min, max]范围内。
+
+API请参考：:ref:`api_fluid_clip_GradientClipByValue`
+
+模型平均
+========
+
+fluid通过 :code:`ParamAttr` 的 :code:`do_model_average` 属性设置单个parameter是否进行平均优化。
+示例如下：
+
+  .. code-block:: python
+
+      param_attrs = fluid.ParamAttr(name="fc_weight",
+                                do_model_average=true)
+      y_predict = fluid.layers.fc(input=x, size=10, param_attr=param_attrs)
+
+在miniBatch训练过程中，每个batch过后，都会更新一次parameters，模型平均做的就是平均最近k次更新产生的parameters。
+
+平均后的parameters只是被用来进行测试和预测，其并不参与实际的训练过程。
+
+具体API请参考：:ref:`api_fluid_optimizer_ModelAverage`

doc/fluid/api_cn/average_cn.rst

+
+#################
+ fluid.average
+#################
+
+
+
+.. _cn_api_fluid_average_WeightedAverage:
+
+WeightedAverage
+>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.average.WeightedAverage
+
+计算加权平均值。
+
+平均计算完全通过Python完成。它们不会改变Paddle的程序，也不会修改NN模型的配置。它们完全是Python函数的包装器。
+
+**示例代码**
+
+.. code-block:: python
+
+            avg = fluid.average.WeightedAverage()
+            avg.add(value=2.0, weight=1)
+            avg.add(value=4.0, weight=2)
+            avg.eval()
+            # 结果为 3.333333333.
+            # 因为 (2.0 * 1 + 4.0 * 2) / (1 + 2) = 3.333333333
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_average_WeightedAverage` 
+

doc/fluid/api_cn/backward_cn.rst

+
+#################
+ fluid.backward
+#################
+
+
+
+.. _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`` 追加 ``backward`` 。
+
+完整的神经网络训练由前向和反向传播组成。但是当我们配置网络时，我们只需要指定其前向部分。通过该功能，根据前向部分自动生成反向部分。
+
+在大多数情况下，用户无需手动调用此功能。它将由优化程序的最小化函数自动调用。
+
+参数：
+    - **loss** （Variable）- 网络的损失变量。
+    - **parameter_list** （list [string] | None）- 优化器需要更新的参数名称。如果为None，则将更新所有参数。默认值：None。
+    - **no_grad_set** （set | None）- ``block`` 0中变量的梯度应该被忽略。所有 ``block`` 中带有 ``step_gradient = True`` 的所有变量都将自动添加到此集合中。默认值：None。
+    - **callbacks** （list [callable object] | None）- 回调用于在反向传播构建中执行一些自定义作业。每次将新的梯度运算符添加到程序中时，将调用其中的所有可调用对象。可调用对象必须有两个输入参数： ``block`` 和 ``context`` 。 ``block`` 是将被添加到新梯度算子的块。 ``context`` 是一个映射，其键是梯度变量名，值是对应的原始变量。除此之外， ``context`` 还有另一个特殊的键值对：键是字符串 ``__ current_op_desc__`` ，值是刚刚触发可调用对象的梯度运算符的 ``op_desc`` 。
+
+返回：   成对参数及其相应的梯度。键是参数，值是梯度变量。
+
+返回类型：   	list[(Variable,Variable)]
+
+抛出：     
+    - ``AssertionError`` - 如果loss不是Variable的实例。
+
+**示例代码**
+
+..  code-block:: python
+
+        # 网络配置
+        # ...
+        avg_loss = fluid.layers.mean(loss)
+        param_grad_list = fluid.backward.append_backward(loss=avg_loss)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_backward_append_backward` 
+

doc/fluid/api_cn/clip_cn.rst

+
+#################
+ fluid.clip
+#################
+
+
+
+.. _cn_api_fluid_clip_ErrorClipByValue:
+
+ErrorClipByValue
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.clip.ErrorClipByValue(max, min=None)
+
+将张量值的范围压缩到 [min, max]。
+
+
+给定一个张量 ``t`` ，该操作将它的值压缩到 ``min`` 和 ``max``  之间
+
+- 任何小于最小值的值都被设置为最小值
+
+- 任何大于max的值都被设置为max
+
+参数:
+ - **max** (foat) - 要修剪的最大值。
+ - **min** (float) - 要修剪的最小值。如果用户没有设置，将被 ``framework`` 设置为 ``-max`` 
+  
+**代码示例**
+ 
+.. code-block:: python
+        
+     var = fluid.framework.Variable(..., error_clip=ErrorClipByValue(max=5.0), ...)
+
+
+
+
+英文版API文档: :ref:`api_fluid_clip_ErrorClipByValue` 
+
+.. _cn_api_fluid_clip_GradientClipByGlobalNorm:
+
+GradientClipByGlobalNorm
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.clip.GradientClipByGlobalNorm(clip_norm, group_name='default_group')
+ 
+通过多个张量的范数之和的比率来剪切（clip）多个张量。
+
+给定一个张量列表 :math:`t\_list` 和一个剪切比率 ``clip_norm`` ，返回一个被剪切的张量列表list_clipped和 :math:`t\_list` 中所有张量的全局范数(global_norm)。
+
+剪切过程如下：
+
+.. math::
+            \\t\_list[i]=t\_list[i]∗\frac{clip\_norm}{max(global\_norm,clip\_norm)}\\
+            
+其中：
+
+.. math::            
+            \\global\_norm=\sqrt{\sum_{i=0}^{n-1}(l2norm(t\_list[i]))^2}\\
+
+
+如果 :math:`clip\_norm>global\_norm` ， :math:`t\_list` 中的张量保持不变，否则它们都会按照全局比率缩减。
+
+
+参数:
+ - **clip_norm** (float) - 范数最大值
+ - **group_name** (str, optional) - 剪切的组名
+  
+**代码示例**
+ 
+.. code-block:: python
+        
+    p_g_clip = fluid.backward.append_backward(loss=avg_cost_clip)
+
+    with fluid.program_guard(main_program=prog_clip):
+         fluid.clip.set_gradient_clip(
+                               fluid.clip.GradientClipByGlobalNorm(clip_norm=2.0))
+         p_g_clip = fluid.clip.append_gradient_clip_ops(p_g_clip)
+
+
+
+英文版API文档: :ref:`api_fluid_clip_GradientClipByGlobalNorm` 
+
+.. _cn_api_fluid_clip_GradientClipByNorm:
+
+GradientClipByNorm
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.clip.GradientClipByNorm(clip_norm)
+
+将张量转换为L2范数不超过 ``clip_norm`` 的张量
+
+该operator 限制了 输入张量 :math:`X` 的L2范数不会超过 :math:`max\_norm` 。如果 :math:`X` 的 ``L2`` 范数小于或等于 :math:`max\_norm` ,输出和 :math:`X` 一样，如果 :math:`X` 的L2范数大于 :math:`max\_norm` , :math:`X` 将被线性缩放到L2范数等于 :math:`max\_norm` ,如以下公式所示:
+
+.. math::
+            \\Out = \frac{max\_norm∗X}{norm(X)}\\
+
+其中 :math:`norm（X）` 代表 :math:`X` 的 L2 范数
+
+
+参数:
+ - **clip_norm** (float) - 二范数最大值
+
+  
+**代码示例**
+ 
+.. code-block:: python
+        
+    w_param_attrs = ParamAttr(name=None,
+                              initializer=UniformInitializer(low=-1.0, high=1.0, seed=0),
+                              learning_rate=1.0,
+                              regularizer=L1Decay(1.0),
+                              trainable=True,
+                              clip=GradientClipByNorm(clip_norm=2.0))
+    y_predict = fluid.layers.fc(input=x, size=1, param_attr=w_param_attrs)
+
+
+
+
+英文版API文档: :ref:`api_fluid_clip_GradientClipByNorm` 
+
+.. _cn_api_fluid_clip_GradientClipByValue:
+
+GradientClipByValue
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.clip.GradientClipByValue(max, min=None)
+
+将梯度值(gradient values)的范围压缩到 [min, max]。
+
+
+给定一个张量 ``t`` ，该操作将它的值压缩到 ``min`` 和 ``max`` 之间
+
+- 任何小于最小值的值都被设置为最小值
+
+- 任何大于max的值都被设置为max
+
+参数:
+ - **max** (foat) - 要修剪的最大值。
+ - **min** (float，optional) - 要修剪的最小值。如果用户没有设置，将被 ``framework`` 设置为 ``-max`` 。
+  
+**代码示例**
+ 
+.. code-block:: python
+        
+     w_param_attrs = ParamAttr(name=None,
+                               initializer=UniformInitializer(low=-1.0, high=1.0, seed=0),
+                               learning_rate=1.0,
+                               regularizer=L1Decay(1.0),
+                               trainable=True,
+                               clip=GradientClipByValue(-1.0, 1.0))
+     y_predict = fluid.layers.fc(input=x, size=1, param_attr=w_param_attrs)
+     
+
+
+英文版API文档: :ref:`api_fluid_clip_GradientClipByValue` 
+

doc/fluid/api_cn/data_feeder_cn.rst

+
+#################
+fluid.data_feeder
+#################
+
+
+
+.. _cn_api_fluid_data_feeder_DataFeeder:
+
+DataFeeder
+>>>>>>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.data_feeder.DataFeeder(feed_list, place, program=None)
+
+
+
+``DataFeeder`` 负责将reader(读取器)返回的数据转成一种特殊的数据结构，使它们可以输入到 ``Executor`` 和 ``ParallelExecutor`` 中。
+reader通常返回一个minibatch条目列表。在列表中每一条目都是一个样本（sample）,它是由具有一至多个特征的列表或元组组成的。
+
+
+以下是简单用法：
+
+..  code-block:: python
+	
+	place = fluid.CPUPlace()
+	img = fluid.layers.data(name='image', shape=[1, 28, 28])
+	label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+	feeder = fluid.DataFeeder([img, label], fluid.CPUPlace())
+	result = feeder.feed([([0] * 784, [9]), ([1] * 784, [1])])
+	
+在多GPU模型训练时，如果需要提前分别向各GPU输入数据，可以使用 ``decorate_reader`` 函数。
+
+..  code-block:: python
+
+	place=fluid.CUDAPlace(0)
+	feeder = fluid.DataFeeder(place=place, feed_list=[data, label])
+	reader = feeder.decorate_reader(
+    		paddle.batch(flowers.train(), batch_size=16))
+
+
+
+参数：  
+	- **feed_list** (list) – 向模型输入的变量表或者变量表名
+	- **place** (Place) – place表明是向GPU还是CPU中输入数据。如果想向GPU中输入数据, 请使用 ``fluid.CUDAPlace(i)`` (i 代表 the GPU id)；如果向CPU中输入数据, 请使用  ``fluid.CPUPlace()``
+    	- **program** (Program) – 需要向其中输入数据的Program。如果为None, 会默认使用 ``default_main_program()``。 缺省值为None
+
+
+弹出异常:	  ``ValueError``  – 如果一些变量不在此 Program 中
+
+
+**代码示例**
+
+..  code-block:: python
+
+	# ...
+	place = fluid.CPUPlace()
+	feed_list = [
+    		main_program.global_block().var(var_name) for var_name in feed_vars_name
+	] # feed_vars_name 是一个由变量名组成的列表
+	feeder = fluid.DataFeeder(feed_list, place)
+	for data in reader():
+    		outs = exe.run(program=main_program,
+               		       feed=feeder.feed(data))
+			       
+			       
+.. py:method:: feed(iterable)
+
+
+根据feed_list（数据输入表）和iterable（可遍历的数据）提供的信息，将输入数据转成一种特殊的数据结构，使它们可以输入到 ``Executor`` 和 ``ParallelExecutor`` 中。
+
+参数:	
+	- **iterable** (list|tuple) – 要输入的数据
+
+返回：  转换结果
+
+返回类型:	dict
+
+
+.. py:method:: feed_parallel(iterable, num_places=None)
+
+
+该方法获取的多个minibatch，并把每个minibatch提前输入进各个设备中。
+
+参数:	
+    - **iterable** (list|tuple) – 要输入的数据
+    - **num_places** (int) – 设备数目。默认为None。
+
+返回: 转换结果
+
+返回类型: dict
+
+.. note::
+   设备（CPU或GPU）的数目必须等于minibatch的数目
+
+
+
+.. py:method::  decorate_reader(reader, multi_devices, num_places=None, drop_last=True)
+
+
+  
+将reader返回的输入数据batch转换为多个mini-batch，之后每个mini-batch都会被输入进各个设备（CPU或GPU）中。
+    
+参数：
+        - **reader** (fun) – 待输入的数据
+        - **multi_devices** (bool) – 执行场所的数目，默认为None
+        - **num_places** (int) – 执行场所的数目，默认为None
+        - **drop_last** (bool) – 舍弃数目匹配不上的batch或设备
+
+返回：转换结果
+
+返回类型: dict
+    
+弹出异常： ValueError – 如果 ``drop_last`` 值为False并且reader返回的minibatch数目与设备数目不相等时，产生此异常
+
+
+        
+
+
+
+英文版API文档: :ref:`api_fluid_data_feeder_DataFeeder` 
+

doc/fluid/api_cn/executor_cn.rst

+
+#################
+ fluid.executor
+#################
+
+
+
+.. _cn_api_fluid_executor:
+
+Executor
+>>>>>>>>>>>>>>>>>>>>>
+
+
+.. py:class:: paddle.fluid.executor.Executor (place)
+
+
+
+
+执行引擎（Executor）使用python脚本驱动，仅支持在单GPU环境下运行。多卡环境下请参考 ``ParallelExecutor`` 。
+Python Executor可以接收传入的program,并根据feed map(输入映射表)和fetch_list(结果获取表)
+向program中添加feed operators(数据输入算子)和fetch operators（结果获取算子)。
+feed map为该program提供输入数据。fetch_list提供program训练结束后用户预期的变量（或识别类场景中的命名）。
+
+应注意，执行器会执行program中的所有算子而不仅仅是依赖于fetch_list的那部分。
+
+Executor将全局变量存储到全局作用域中，并为临时变量创建局部作用域。
+当每一mini-batch上的前向/反向运算完成后，局部作用域的内容将被废弃，
+但全局作用域中的变量将在Executor的不同执行过程中一直存在。
+
+program中所有的算子会按顺序执行。
+
+参数:	
+    - **place** (core.CPUPlace|core.CUDAPlace(n)) – 指明了 ``Executor`` 的执行场所
+
+
+
+提示：你可以用Executor来调试基于并行GPU实现的复杂网络，他们有完全一样的参数也会产生相同的结果。
+
+
+.. py:method:: close()
+
+
+关闭这个执行器(Executor)。调用这个方法后不可以再使用这个执行器。 对于分布式训练, 该函数会释放在PServers上涉及到目前训练器的资源。
+   
+**示例代码**
+
+..  code-block:: python
+    
+    cpu = core.CPUPlace()
+    exe = Executor(cpu)
+    ...
+    exe.close()
+
+
+.. py:method:: run(program=None, feed=None, fetch_list=None, feed_var_name='feed', fetch_var_name='fetch', scope=None, return_numpy=True,use_program_cache=False)
+
+
+调用该执行器对象的此方法可以执行program。通过feed map提供待学习数据，以及借助fetch_list得到相应的结果。
+Python执行器(Executor)可以接收传入的program,并根据输入映射表(feed map)和结果获取表(fetch_list)
+向program中添加数据输入算子(feed operators)和结果获取算子（fetch operators)。
+feed map为该program提供输入数据。fetch_list提供program训练结束后用户预期的变量（或识别类场景中的命名）。
+
+应注意，执行器会执行program中的所有算子而不仅仅是依赖于fetch_list的那部分。
+
+参数：  
+	- **program** (Program) – 需要执行的program,如果没有给定那么默认使用default_main_program
+	- **feed** (dict) – 前向输入的变量，数据,词典dict类型, 例如 {“image”: ImageData, “label”: LableData}
+	- **fetch_list** (list) – 用户想得到的变量或者命名的列表, run会根据这个列表给与结果
+	- **feed_var_name** (str) – 前向算子(feed operator)变量的名称
+	- **fetch_var_name** (str) – 结果获取算子(fetch operator)的输出变量名称
+	- **scope** (Scope) – 执行这个program的域，用户可以指定不同的域。缺省为全局域
+	- **return_numpy** (bool) – 如果为True,则将结果张量（fetched tensor）转化为numpy
+	- **use_program_cache** (bool) – 当program较上次比没有改动则将其置为True
+	
+返回:	根据fetch_list来获取结果
+
+返回类型:	list(numpy.array)
+
+
+**示例代码**
+
+..  code-block:: python
+
+
+	data = layers.data(name='X', shape=[1], dtype='float32')
+	hidden = layers.fc(input=data, size=10)
+	layers.assign(hidden, out)
+	loss = layers.mean(out)
+	adam = fluid.optimizer.Adam()
+	adam.minimize(loss)
+
+
+..  code-block:: python
+	
+	
+	cpu = core.CPUPlace()
+	exe = Executor(cpu)
+	exe.run(default_startup_program())
+	
+..  code-block:: python
+	
+	x = numpy.random.random(size=(10, 1)).astype('float32')
+	outs = exe.run(
+		feed={'X': x},
+		fetch_list=[loss.name])
+	
+
+
+
+英文版API文档: :ref:`api_fluid_executor` 
+

doc/fluid/api_cn/fluid_cn.rst

+
+#################
+fluid
+#################
+
+
+
+.. _cn_api_fluid_AsyncExecutor:
+
+AsyncExecutor
+>>>>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.AsyncExecutor(place=None)
+
+Python中的异步执行器。AsyncExecutor利用多核处理器和数据排队的强大功能，使数据读取和融合解耦，每个线程并行运行。
+
+AsyncExecutor不是在python端读取数据，而是接受一个训练文件列表，该列表将在c++中检索，然后训练输入将被读取、解析并在c++代码中提供给训练网络。
+
+AsyncExecutor正在积极开发，API可能在不久的将来会发生变化。
+
+参数：
+	- **place** (fluid.CPUPlace|None) - 指示 executor 将在哪个设备上运行。目前仅支持CPU
+
+**代码示例：**
+
+.. code-block:: python
+
+    data_feed = fluid.DataFeedDesc('data.proto')
+    startup_program = fluid.default_startup_program()
+    main_program = fluid.default_main_program()
+    filelist = ["train_data/part-%d" % i for i in range(100)]
+    thread_num = len(filelist) / 4
+    place = fluid.CPUPlace()
+    async_executor = fluid.AsyncExecutor(place)
+    async_executor.run_startup_program(startup_program)
+    epoch = 10
+    for i in range(epoch):
+        async_executor.run(main_program,
+                           data_feed,
+                           filelist,
+                           thread_num,
+                           [acc],
+                           debug=False)
+
+.. note::
+
+	对于并行gpu调试复杂网络，您可以在executor上测试。他们有完全相同的参数，并可以得到相同的结果。
+
+	目前仅支持CPU
+
+
+
+英文版API文档: :ref:`api_fluid_AsyncExecutor` 
+
+.. _cn_api_fluid_BuildStrategy:
+
+BuildStrategy
+>>>>>>>>>>>>>>>>>>
+
+.. py:class::  paddle.fluid.BuildStrategy
+
+``BuildStrategy`` 使用户更精准地控制 ``ParallelExecutor`` 中SSA图的建造方法。可通过设置 ``ParallelExecutor`` 中的 ``BuildStrategy`` 成员来实现此功能。
+
+**代码示例**
+
+..  code-block:: python
+
+    build_strategy = fluid.BuildStrategy()
+    build_strategy.reduce_strategy = fluid.BuildStrategy.ReduceStrategy.Reduce
+
+    train_exe = fluid.ParallelExecutor(use_cuda=True,
+                                       loss_name=loss.name,
+                                       build_strategy=build_strategy)
+
+    train_loss, = train_exe.run([loss.name], feed=feed_dict)
+
+
+
+.. py:attribute:: debug_graphviz_path
+
+str类型。它表明了以graphviz格式向文件中写入SSA图的路径，有利于调试。 默认值为""。
+
+
+
+.. py:attribute:: fuse_elewise_add_act_ops
+
+bool类型。它表明了是否融合（fuse）elementwise_add_op和activation_op。这会使整体执行过程更快一些。默认为False。
+
+
+
+.. py:attribute:: gradient_scale_strategy
+
+str类型。在 ``ParallelExecutor`` 中，存在三种定义 *loss@grad* 的方式，分别为 ``CoeffNumDevice``, ``One`` 与 ``Customized``。默认情况下， ``ParallelExecutor`` 根据设备数目来设置 *loss@grad* 。如果你想自定义 *loss@grad* ，你可以选择 ``Customized`` 方法。默认为 ``CoeffNumDevice`` 。
+
+
+
+.. py:attribute:: reduce_strategy
+
+str类型。在 ``ParallelExecutor`` 中，存在两种减少策略（reduce strategy），即 ``AllReduce`` 和 ``Reduce`` 。如果你需要在所有执行场所上独立地进行参数优化，可以使用 ``AllReduce`` 。反之，如果使用 ``Reduce`` 策略，所有参数的优化将均匀地分配给不同的执行场所，随之将优化后的参数广播给其他执行场所。在一些模型中， ``Reduce`` 策略执行速度更快一些。默认值为 ``AllReduce`` 。
+
+
+
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_BuildStrategy` 
+
+.. _cn_api_fluid_CPUPlace:
+
+CPUPlace
+>>>>>>>>>>>>>>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.CPUPlace
+
+
+
+
+英文版API文档: :ref:`api_fluid_CPUPlace` 
+
+.. _cn_api_fluid_create_lod_tensor:
+
+
+create_lod_tensor
+>>>>>>>>>>>>>>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.create_lod_tensor(data, recursive_seq_lens, place) 
+
+
+该函数从一个numpy数组，列表或者已经存在的lod tensor中创建一个lod tensor。
+通过一下几步实现:
+	1. 检查length-based level of detail (LoD,长度为基准的细节层次)，或称recursive_sequence_lengths(递归序列长度)的正确性
+	2. 将recursive_sequence_lengths转化为offset-based LoD(偏移量为基准的LoD)
+        3. 把提供的numpy数组，列表或者已经存在的lod tensor复制到CPU或GPU中(依据执行场所确定)
+        4. 利用offset-based LoD来设置LoD
+例如：
+         假如我们想用LoD Tensor来承载一词序列的数据，其中每个词由一个整数来表示。现在，我们意图创建一个LoD Tensor来代表两个句子，其中一个句子有两个词，另外一个句子有三个。
+     	 那么数据可以是一个numpy数组，形状为（5,1）。同时， ``recursive_seq_lens`` 为 [[2, 3]]，表明各个句子的长度。这个长度为基准的 ``recursive_seq_lens`` 将在函数中会被转化为以偏移量为基准的 LoD [[0, 2, 5]]。
+
+参数:
+	- **data** (numpy.ndarray|list|LoDTensor) – 容纳着待复制数据的一个numpy数组、列表或LoD Tensor
+	- **recursive_seq_lens** (list) – 一组列表的列表， 表明了由用户指明的length-based level of detail信息
+	- **place** (Place) – CPU或GPU。 指明返回的新LoD Tensor存储地点
+
+返回: 一个fluid LoDTensor对象，包含数据和 ``recursive_seq_lens`` 信息
+
+
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_create_lod_tensor` 
+
+.. _cn_api_fluid_create_random_int_lodtensor:
+
+
+create_random_int_lodtensor
+>>>>>>>>>>>>>>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.create_random_int_lodtensor(recursive_seq_lens, base_shape, place, low, high)
+
+
+
+该函数创建一个存储多个随机整数的LoD Tensor。
+
+该函数是经常在书中出现的案例，所以我们根据新的API： ``create_lod_tensor`` 更改它然后放在LoD Tensor板块里来简化代码。
+
+该函数实现以下功能：
+
+    1. 根据用户输入的length-based ``recursive_seq_lens`` （基于长度的递归序列长）和在 ``basic_shape`` 中的基本元素形状计算LoDTensor的整体形状
+    2. 由此形状，建立numpy数组
+    3. 使用API： ``create_lod_tensor`` 建立LoDTensor
+
+
+假如我们想用LoD Tensor来承载一词序列，其中每个词由一个整数来表示。现在，我们意图创建一个LoD Tensor来代表两个句子，其中一个句子有两个词，另外一个句子有三个。那么 ``base_shape`` 为[1], 输入的length-based ``recursive_seq_lens`` 是 [[2, 3]]。那么LoDTensor的整体形状应为[5, 1]，并且为两个句子存储5个词。
+
+参数:	
+    - **recursive_seq_lens** (list) – 一组列表的列表， 表明了由用户指明的length-based level of detail信息
+    - **base_shape** (list) – LoDTensor所容纳的基本元素的形状
+    - **place** (Place) –  CPU或GPU。 指明返回的新LoD Tensor存储地点
+    - **low** (int) – 随机数下限
+    - **high** (int) – 随机数上限
+
+返回:	一个fluid LoDTensor对象，包含数据和 ``recursive_seq_lens`` 信息
+
+
+
+
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_create_random_int_lodtensor` 
+
+.. _cn_api_fluid_CUDAPinnedPlace:
+
+CUDAPinnedPlace
+>>>>>>>>>>>>>>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.CUDAPinnedPlace
+
+
+
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_CUDAPinnedPlace` 
+
+.. _cn_api_fluid_CUDAPlace:
+
+CUDAPlace
+>>>>>>>>>>>>>>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.CUDAPlace
+
+
+
+
+英文版API文档: :ref:`api_fluid_CUDAPlace` 
+
+.. _cn_api_fluid_DataFeedDesc:
+
+DataFeedDesc
+>>>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.DataFeedDesc(proto_file)
+
+数据描述符，描述输入训练数据格式。
+
+这个类目前只用于AsyncExecutor(有关类AsyncExecutor的简要介绍，请参阅注释)
+
+DataFeedDesc应由来自磁盘的有效protobuf消息初始化:
+
+.. code-block:: python
+
+	data_feed = fluid.DataFeedDesc('data.proto')
+
+可以参考 :code:`paddle/fluid/framework/data_feed.proto` 查看我们如何定义message
+
+一段典型的message可能是这样的：
+
+.. code-block:: text
+
+    name: "MultiSlotDataFeed"
+    batch_size: 2
+    multi_slot_desc {
+        slots {
+            name: "words"
+            type: "uint64"
+            is_dense: false
+            is_used: true
+        }
+        slots {
+            name: "label"
+            type: "uint64"
+            is_dense: false
+            is_used: true
+        }
+    }
+
+但是，用户通常不应该关心消息格式;相反，我们鼓励他们在将原始日志文件转换为AsyncExecutor可以接受的训练文件的过程中，使用 :code:`Data Generator` 生成有效数据描述。
+
+DataFeedDesc也可以在运行时更改。一旦你熟悉了每个字段的含义，您可以修改它以更好地满足您的需要。例如:
+
+.. code-block:: text
+
+    data_feed.set_batch_size(128)
+    data_feed.set_dense_slots('wd')  # The slot named 'wd' will be dense
+    data_feed.set_use_slots('wd')    # The slot named 'wd' will be used
+    
+    #Finally, the content can be dumped out for debugging purpose:
+    
+    print(data_feed.desc())
+
+参数：
+	- **proto_file** (string) - 包含数据feed中描述的磁盘文件
+
+
+.. py:method:: set_batch_size(self, batch_size)
+
+设置batch size，训练期间有效
+
+
+参数：
+	- batch_size：batch size
+
+**代码示例：**
+
+.. code-block:: python
+	
+	data_feed = fluid.DataFeedDesc('data.proto')
+	data_feed.set_batch_size(128)
+
+.. py:method:: set_dense_slots(self, dense_slots_name)
+
+指定slot经过设置后将变成密集的slot，仅在训练期间有效。
+
+密集slot的特征将被输入一个Tensor，而稀疏slot的特征将被输入一个lodTensor
+
+
+参数：
+	- **dense_slots_name** : slot名称的列表，这些slot将被设置为密集的
+
+**代码示例：**
+
+.. code-block:: python
+	
+	data_feed = fluid.DataFeedDesc('data.proto')
+	data_feed.set_dense_slots(['words'])
+
+.. note:: 
+
+	默认情况下，所有slot都是稀疏的
+
+.. py:method:: set_use_slots(self, use_slots_name)
+
+
+设置一个特定的slot是否用于训练。一个数据集包含了很多特征，通过这个函数可以选择哪些特征将用于指定的模型。
+
+参数：
+	- **use_slots_name** :将在训练中使用的slot名列表
+
+**代码示例：**
+
+.. code-block:: python
+
+	data_feed = fluid.DataFeedDesc('data.proto')
+	data_feed.set_use_slots(['words'])
+
+.. note::
+	
+	默认值不用于所有slot
+
+
+.. py:method:: desc(self)
+
+返回此DataFeedDesc的protobuf信息
+
+返回：一个message字符串
+
+**代码示例：**
+
+.. code-block:: python
+
+	data_feed = fluid.DataFeedDesc('data.proto')
+	print(data_feed.desc())
+
+
+英文版API文档: :ref:`api_fluid_DataFeedDesc` 
+
+.. _cn_api_fluid_DataFeeder:
+
+DataFeeder
+>>>>>>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.DataFeeder(feed_list, place, program=None)
+
+
+
+``DataFeeder`` 负责将reader(读取器)返回的数据转成一种特殊的数据结构，使它们可以输入到 ``Executor`` 和 ``ParallelExecutor`` 中。
+reader通常返回一个minibatch条目列表。在列表中每一条目都是一个样本（sample）,它是由具有一至多个特征的列表或元组组成的。
+
+
+以下是简单用法：
+
+..  code-block:: python
+	
+	place = fluid.CPUPlace()
+	img = fluid.layers.data(name='image', shape=[1, 28, 28])
+	label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+	feeder = fluid.DataFeeder([img, label], fluid.CPUPlace())
+	result = feeder.feed([([0] * 784, [9]), ([1] * 784, [1])])
+	
+在多GPU模型训练时，如果需要提前分别向各GPU输入数据，可以使用 ``decorate_reader`` 函数。
+
+..  code-block:: python
+
+	place=fluid.CUDAPlace(0)
+	feeder = fluid.DataFeeder(place=place, feed_list=[data, label])
+	reader = feeder.decorate_reader(
+    		paddle.batch(flowers.train(), batch_size=16))
+
+
+
+参数：  
+	- **feed_list** (list) – 向模型输入的变量表或者变量表名
+	- **place** (Place) – place表明是向GPU还是CPU中输入数据。如果想向GPU中输入数据, 请使用 ``fluid.CUDAPlace(i)`` (i 代表 the GPU id)；如果向CPU中输入数据, 请使用  ``fluid.CPUPlace()``
+    	- **program** (Program) – 需要向其中输入数据的Program。如果为None, 会默认使用 ``default_main_program()``。 缺省值为None
+
+
+弹出异常:	  ``ValueError``  – 如果一些变量不在此 Program 中
+
+
+**代码示例**
+
+..  code-block:: python
+
+	# ...
+	place = fluid.CPUPlace()
+	feed_list = [
+    		main_program.global_block().var(var_name) for var_name in feed_vars_name
+	] # feed_vars_name 是一个由变量名组成的列表
+	feeder = fluid.DataFeeder(feed_list, place)
+	for data in reader():
+    		outs = exe.run(program=main_program,
+               		       feed=feeder.feed(data))
+			       
+			       
+.. py:method:: feed(iterable)
+
+
+根据feed_list（数据输入表）和iterable（可遍历的数据）提供的信息，将输入数据转成一种特殊的数据结构，使它们可以输入到 ``Executor`` 和 ``ParallelExecutor`` 中。
+
+参数:	
+	- **iterable** (list|tuple) – 要输入的数据
+
+返回：  转换结果
+
+返回类型:	dict
+
+
+.. py:method:: feed_parallel(iterable, num_places=None)
+
+
+该方法获取的多个minibatch，并把每个minibatch提前输入进各个设备中。
+
+参数:	
+    - **iterable** (list|tuple) – 要输入的数据
+    - **num_places** (int) – 设备数目。默认为None。
+
+返回: 转换结果
+
+返回类型: dict
+
+**特别注意：** 设备（CPU或GPU）的数目必须等于minibatch的数目
+
+
+
+.. py:method::  decorate_reader(reader, multi_devices, num_places=None, drop_last=True)
+
+
+  
+将reader返回的输入数据batch转换为多个mini-batch，之后每个mini-batch都会被输入进各个设备（CPU或GPU）中。
+    
+参数：
+        - **reader** (fun) – 待输入的数据
+        - **multi_devices** (bool) – 执行场所的数目，默认为None
+        - **num_places** (int) – 执行场所的数目，默认为None
+        - **drop_last** (bool) – 舍弃数目匹配不上的batch或设备
+
+返回：转换结果
+
+返回类型: dict
+    
+弹出异常： ``ValueError`` – 如果 ``drop_last`` 值为False并且reader返回的minibatch数目与设备数目不相等时，产生此异常
+
+
+        
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_DataFeeder` 
+
+.. _cn_api_fluid_default_main_program:
+
+default_main_program
+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.default_main_program()
+
+
+
+
+
+此函数用于获取默认或全局main program(主程序)。该主程序用于训练和测试模型。
+
+``fluid.layers`` 中的所有layer函数可以向 ``default_main_program`` 中添加operators（算子）和variables（变量）。
+
+``default_main_program`` 是fluid的许多编程接口（API）的Program参数的缺省值。例如,当用户program没有传入的时候，
+``Executor.run()`` 会默认执行 ``default_main_program`` 。
+
+
+返回：	main program
+
+返回类型:	Program
+
+
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_default_main_program` 
+
+.. _cn_api_fluid_default_startup_program:
+
+
+
+
+default_startup_program
+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.default_startup_program()
+
+
+
+该函数可以获取默认/全局 startup program (启动程序)。
+
+``fluid.layers`` 中的layer函数会新建参数、readers(读取器)、NCCL句柄作为全局变量。 
+
+startup_program会使用内在的operators（算子）去初始化他们，并由layer函数将这些operators追加到startup program中。
+
+该函数将返回默认的或当前的startup_program。用户可以使用 ``fluid.program_guard`` 去切换program。
+
+返回:	startup program
+
+返回类型:	Program
+
+
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_default_startup_program` 
+
+.. _cn_api_fluid_DistributeTranspiler:
+
+DistributeTranspiler
+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.DistributeTranspiler (config=None)
+
+
+该类可以把fluid program转变为分布式数据并行计算程序（distributed data-parallelism programs）,可以有Pserver和NCCL2两种模式。
+当program在Pserver（全称：parameter server）模式下， ``main_program`` (主程序)转为使用一架远程parameter server(即pserver,参数服务器)来进行参数优化，并且优化图会被输入到一个pserver program中。
+在NCCL2模式下，transpiler会在 ``startup_program`` 中附加一个 ``NCCL_ID`` 广播算子（broadcasting operators）来实现在该集群中所有工作结点共享 ``NCCL_ID`` 。
+调用 ``transpile_nccl2`` 后， 你 **必须** 将 ``trainer_id`` , ``num_trainers`` 参数提供给 ``ParallelExecutor`` 来启动NCCL2分布式模式。 
+
+
+
+
+**代码示例**
+
+..  code-block:: python
+
+	#pserver模式下
+	pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
+	trainer_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
+	current_endpoint = "192.168.0.1:6174"
+	trainer_id = 0
+	trainers = 4
+	role = os.getenv("PADDLE_TRAINING_ROLE")
+
+	t = fluid.DistributeTranspiler()
+	t.transpile(
+     	     trainer_id, pservers=pserver_endpoints, trainers=trainers)
+	if role == "PSERVER":
+     	     pserver_program = t.get_pserver_program(current_endpoint)
+             pserver_startup_program = t.get_startup_program(current_endpoint,
+                                                     pserver_program)
+	elif role == "TRAINER":
+             trainer_program = t.get_trainer_program()
+
+	# nccl2模式下
+	config = fluid.DistributeTranspilerConfig()
+	config.mode = "nccl2"
+	t = fluid.DistributeTranspiler(config=config)
+	t.transpile(trainer_id, workers=workers, current_endpoint=curr_ep)
+	exe = fluid.ParallelExecutor(
+    	    use_cuda,
+            loss_name=loss_var.name,
+            num_trainers=len(trainers.split(",)),
+            trainer_id=trainer_id
+	)
+
+
+
+.. py:method:: transpile(trainer_id, program=None, pservers='127.0.0.1:6174', trainers=1, sync_mode=True, startup_program=None, current_endpoint='127.0.0.1:6174')
+
+该方法可以运行该transpiler（转译器）。
+
+参数:	
+	- **trainer_id** (int) – 当前Trainer worker的id, 如果有n个Trainer worker, id 取值范围为0 ~ n-1
+	- **program** (Program|None) – 待transpile（转译）的program, 缺省为 ``fluid.default_main_program()`` 
+	- **pservers** (str) – 内容为Pserver列表的字符串，格式为：按逗号区分不同的Pserver，每个Pserver的格式为 *ip地址:端口号* 
+	- **trainers** (int|str) – 在Pserver模式下，该参数指Trainer机的个数；在nccl2模式下，它是一个内容为Trainer终端列表的字符串
+	- **sync_mode** (bool) – 是否做同步训练(synchronous training), 默认为True
+ 	- **startup_program** (Program|None) – 待transpile（转译）的startup_program，默认为 ``fluid.default_main_program()``
+	- **current_endpoint** (str) – 当需要把program转译（transpile）至NCCL2模式下时，需要将当前endpoint（终端）传入该参数。Pserver模式不使用该参数
+
+.. py:method:: get_trainer_program(wait_port=True)
+
+
+该方法可以得到Trainer侧的program。
+
+返回:	Trainer侧的program
+
+返回类型:	Program
+
+
+
+.. py:method:: get_pserver_program(endpoint)
+
+
+该方法可以得到Pserver（参数服务器）侧的程序
+ 
+参数:	
+	- **endpoint** (str) – 当前Pserver终端
+ 
+返回:	当前Pserver需要执行的program
+
+返回类型:	Program
+
+
+.. py:method:: get_pserver_programs(endpoint)
+
+
+该方法可以得到Pserver侧用于分布式训练的 ``main_program`` 和 ``startup_program`` 。
+
+参数:	
+	- **endpoint** (str) – 当前Pserver终端
+
+返回:	(main_program, startup_program), “Program”类型的元组
+
+返回类型:	tuple 
+ 
+ 
+.. py:method:: get_startup_program(endpoint, pserver_program=None, startup_program=None)
+
+
+**该函数已停止使用**
+获取当前Pserver的startup_program，如果有多个被分散到不同blocks的变量，则修改operator的输入变量。
+
+参数:	
+	- **endpoint** (str) – 当前Pserver终端
+	- **pserver_program** (Program) – 已停止使用。 先调用get_pserver_program
+ 	- **startup_program** (Program) – 已停止使用。应在初始化时传入startup_program
+
+返回:	Pserver侧的startup_program
+
+返回类型:	Program
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_DistributeTranspiler` 
+
+.. _cn_api_fluid_DistributeTranspilerConfig:
+
+DistributeTranspilerConfig
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.DistributeTranspilerConfig
+
+
+.. py:attribute:: slice_var_up (bool)
+
+为多个Pserver（parameter server）将tensor切片, 默认为True。
+
+.. py:attribute:: split_method (PSDispatcher)
+
+可使用 RoundRobin 或者 HashName。
+
+注意: 尝试选择最佳方法来达到Pserver间负载均衡。
+
+.. py:attribute:: min_block_size (int)
+
+最小数据块的大小
+
+注意: 根据：`issuecomment-369912156 <https://github.com/PaddlePaddle/Paddle/issues/8638#issuecomment-369912156>`_ , 当数据块大小超过2MB时，我们可以有效地使用带宽。如果你想更改它，请详细查看 ``slice_variable`` 函数。
+
+
+
+英文版API文档: :ref:`api_fluid_DistributeTranspilerConfig` 
+
+.. _cn_api_fluid_ExecutionStrategy:
+
+ExecutionStrategy
+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.ExecutionStrategy
+
+``ExecutionStrategy`` 允许用户更加精准地控制program在 ``ParallelExecutor`` 中的运行方式。可以通过在 ``ParallelExecutor`` 中设置本成员来实现。
+
+**代码示例**
+
+..  code-block:: python
+
+  exec_strategy = fluid.ExecutionStrategy()
+  exec_strategy.num_threads = 4
+
+  train_exe = fluid.ParallelExecutor(use_cuda=True,
+                                     loss_name=loss.name,
+                                     exec_strategy=exec_strategy)
+
+  train_loss, = train_exe.run([loss.name], feed=feed_dict)
+
+
+
+.. py:attribute:: allow_op_delay
+   
+这是一个bool类型成员，表示是否推迟communication operators(交流运算)的执行，这样做会使整体执行过程更快一些。但是在一些模型中，allow_op_delay会导致程序中断。默认为False。
+  
+
+
+.. py:attribute:: num_iteration_per_drop_scope
+  
+int型成员。它表明了清空执行时产生的临时变量需要的程序执行重复次数。因为临时变量的形可能在两次重复过程中保持一致，所以它会使整体执行过程更快。默认值为100。
+
+.. note::
+  1. 如果在调用 ``run`` 方法时获取结果数据，``ParallelExecutor`` 会在当前程序重复执行尾部清空临时变量
+  
+  2. 在一些NLP模型里，该成员会致使GPU内存不足。此时，你应减少 ``num_iteration_per_drop_scope`` 的值
+
+
+
+.. py:attribute:: num_threads
+
+int型成员。它代表了线程池(thread pool)的大小。这些线程会被用来执行当前 ``ParallelExecutor`` 的program中的operator（算子，运算）。如果 :math:`num\_threads=1` ，则所有的operator将一个接一个地执行，但在不同的程序重复周期(iterations)中执行顺序可能不同。如果该成员没有被设置，则在 ``ParallelExecutor`` 中，它会依据设备类型(device type)、设备数目(device count)而设置为相应值。对GPU，:math:`num\_threads=device\_count∗4` ；对CPU， :math:`num\_threads=CPU\_NUM∗4` 。在 ``ParallelExecutor`` 中有关于 :math:`CPU\_NUM` 的详细解释。如果没有设置 :math:`CPU\_NUM` ， ``ParallelExecutor`` 可以通过调用 ``multiprocessing.cpu_count()`` 获取CPU数目(cpu count)。默认值为0。
+
+
+
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_ExecutionStrategy` 
+
+.. _cn_api_fluid_executor:
+
+Executor
+>>>>>>>>>>>>>>>>>>>>>
+
+
+.. py:class:: paddle.fluid.Executor (place)
+
+
+
+
+执行引擎（Executor）使用python脚本驱动，仅支持在单GPU环境下运行。多卡环境下请参考 ``ParallelExecutor`` 。
+Python Executor可以接收传入的program,并根据feed map(输入映射表)和fetch_list(结果获取表)
+向program中添加feed operators(数据输入算子)和fetch operators（结果获取算子)。
+feed map为该program提供输入数据。fetch_list提供program训练结束后用户预期的变量（或识别类场景中的命名）。
+
+应注意，执行器会执行program中的所有算子而不仅仅是依赖于fetch_list的那部分。
+
+Executor将全局变量存储到全局作用域中，并为临时变量创建局部作用域。
+当每一mini-batch上的前向/反向运算完成后，局部作用域的内容将被废弃，
+但全局作用域中的变量将在Executor的不同执行过程中一直存在。
+
+program中所有的算子会按顺序执行。
+
+参数:	
+    - **place** (core.CPUPlace|core.CUDAPlace(n)) – 指明了 ``Executor`` 的执行场所
+
+
+
+提示：你可以用 ``Executor`` 来调试基于并行GPU实现的复杂网络，他们有完全一样的参数也会产生相同的结果。
+
+
+.. py:method:: close()
+
+
+关闭这个执行器(Executor)。调用这个方法后不可以再使用这个执行器。 对于分布式训练, 该函数会释放在PServers上涉及到目前训练器的资源。
+   
+**示例代码**
+
+..  code-block:: python
+    
+    cpu = core.CPUPlace()
+    exe = Executor(cpu)
+    ...
+    exe.close()
+
+
+.. py:method:: run(program=None, feed=None, fetch_list=None, feed_var_name='feed', fetch_var_name='fetch', scope=None, return_numpy=True,use_program_cache=False)
+
+
+调用该执行器对象的此方法可以执行program。通过feed map提供待学习数据，以及借助fetch_list得到相应的结果。
+Python执行器(Executor)可以接收传入的program,并根据输入映射表(feed map)和结果获取表(fetch_list)
+向program中添加数据输入算子(feed operators)和结果获取算子（fetch operators)。
+feed map为该program提供输入数据。fetch_list提供program训练结束后用户预期的变量（或识别类场景中的命名）。
+
+应注意，执行器会执行program中的所有算子而不仅仅是依赖于fetch_list的那部分。
+
+参数：  
+	- **program** (Program) – 需要执行的program,如果没有给定那么默认使用default_main_program
+	- **feed** (dict) – 前向输入的变量，数据,词典dict类型, 例如 {“image”: ImageData, “label”: LableData}
+	- **fetch_list** (list) – 用户想得到的变量或者命名的列表, run会根据这个列表给与结果
+	- **feed_var_name** (str) – 前向算子(feed operator)变量的名称
+	- **fetch_var_name** (str) – 结果获取算子(fetch operator)的输出变量名称
+	- **scope** (Scope) – 执行这个program的域，用户可以指定不同的域。缺省为全局域
+	- **return_numpy** (bool) – 如果为True,则将结果张量（fetched tensor）转化为numpy
+	- **use_program_cache** (bool) – 当program较上次比没有改动则将其置为True
+	
+返回:	根据fetch_list来获取结果
+
+返回类型:	list(numpy.array)
+
+
+**示例代码**
+
+..  code-block:: python
+
+
+	data = layers.data(name='X', shape=[1], dtype='float32')
+	hidden = layers.fc(input=data, size=10)
+	layers.assign(hidden, out)
+	loss = layers.mean(out)
+	adam = fluid.optimizer.Adam()
+	adam.minimize(loss)
+
+
+..  code-block:: python
+	
+	
+	cpu = core.CPUPlace()
+	exe = Executor(cpu)
+	exe.run(default_startup_program())
+	
+..  code-block:: python
+	
+	x = numpy.random.random(size=(10, 1)).astype('float32')
+	outs = exe.run(
+		feed={'X': x},
+		fetch_list=[loss.name])
+	
+
+
+
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_executor` 
+
+.. _cn_api_fluid_fluid_Tensor:
+
+Tensor
+>>>>>>>>>>>>>>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.Tensor
+
+    ``LoDTensor`` 的别名
+
+
+
+
+英文版API文档: :ref:`api_fluid_fluid_Tensor` 
+
+.. _cn_api_fluid_global_scope:
+
+global_scope
+>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.global_scope()
+
+
+获取全局/默认作用域实例。很多api使用默认 ``global_scope`` ，例如 ``Executor.run`` 。
+
+返回：全局/默认作用域实例
+
+返回类型：Scope
+
+
+
+英文版API文档: :ref:`api_fluid_global_scope` 
+
+.. _cn_api_fluid_LoDTensor:
+
+LoDTensor
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.LoDTensor
+
+
+LoDTensor是一个具有LoD信息的张量(Tensor)
+
+ ``np.array(lod_tensor)`` 可以将LoDTensor转换为numpy array。 ``lod_tensor.lod()`` 可以获得LoD信息。
+LoD是多层序列（Level of Details）的缩写，通常用于不同长度的序列。如果您不需要了解LoD信息，可以跳过下面的注解。
+
+举例:
+
+X 为 LoDTensor，它包含两个序列。第一个长度是2，第二个长度是3。
+
+从Lod中可以计算出X的第一维度为5， 因为5=2+3， 说明X中有5个序列。在X中的每个序列中的每个元素有2列，因此X的shape为[5,2]。
+
+::
+
+	x.lod  =  [[2, 3]] 
+	x.data = [[1, 2], [3, 4], // seq 1
+
+		  [5, 6], [7, 8], [9, 10]] // seq 2
+
+	x.shape = [5, 2]
+
+
+LoD可以有多个level(例如，一个段落可以有多个句子，一个句子可以有多个单词)。下面的例子中，Y为LoDTensor ，lod_level为2。表示有2个序列，第一个序列的长度是2(有2个子序列)，第二个序列的长度是1。第一序列的两个子序列长度分别为2和2。第二个序列的子序列的长度是3。
+
+
+::
+
+	y.lod = [[2 1], [2 2 3]] y.shape = [2+2+3, ...]
+
+
+.. note::
+
+	在上面的描述中，LoD是基于长度的。在paddle内部实现中，lod是基于偏移的。因此,在内部,y.lod表示为[[0,2,3]，[0,2,4,7]](基于长度的Lod表示为为[[2-0,3-2]，[2-0,4-2,7-4]])。
+
+	可以将LoD理解为recursive_sequence_length（递归序列长度）。此时，LoD必须是基于长度的。由于历史原因。当LoD在API中被称为lod时，它可能是基于偏移的。用户应该注意。
+
+
+
+
+.. py:method::	has_valid_recursive_sequence_lengths(self: paddle.fluid.core.LoDTensor) → bool
+
+.. py:method::	lod(self: paddle.fluid.core.LoDTensor) → List[List[int]]
+
+.. py:method::	recursive_sequence_lengths(self: paddle.fluid.core.LoDTensor) → List[List[int]]
+
+.. py:method::	set_lod(self: paddle.fluid.core.LoDTensor, arg0: List[List[int]]) → None
+
+.. py:method::	set_recursive_sequence_lengths(self: paddle.fluid.core.LoDTensor, arg0: List[List[int]]) → None
+
+
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_LoDTensor` 
+
+.. _cn_api_fluid_LoDTensorArray:
+
+LoDTensorArray
+>>>>>>>>>>>>>>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.LoDTensorArray
+
+.. py:method:: append(self: paddle.fluid.core.LoDTensorArray, arg0: paddle.fluid.core.LoDTensor) → None
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_LoDTensorArray` 
+
+.. _cn_api_fluid_memory_optimize:
+
+memory_optimize
+>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.memory_optimize(input_program, skip_opt_set=None, print_log=False, level=0, skip_grads=False)
+
+
+通过重用var内存来优化内存。
+
+注意:它不支持block中嵌套子block。
+
+参数:
+	- **input_program** (str) – 输入Program。
+	- **skip_opt_set** (set) – set中的vars将不被内存优化。
+	- **print_log** (bool) – 是否打印debug日志。
+	- **level** (int)  如果 level=0 并且shape是完全相等，则重用。
+	
+返回: None
+
+
+
+
+英文版API文档: :ref:`api_fluid_memory_optimize` 
+
+.. _cn_api_fluid_name_scope:
+
+name_scope
+>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.name_scope(*args, **kwds)
+
+
+为operators生成层次名称前缀
+
+注意： 这个函数只能用于调试和可视化。不要将其用于分析，比如graph/program转换。
+
+参数： 
+	- **prefix** (str) - 前缀
+
+**示例代码**
+
+.. code-block:: python
+          
+	  with name_scope("encoder"):
+             ...
+          with name_scope("decoder"):
+             ...
+             with name_scope("attention"):
+                ...
+
+
+
+英文版API文档: :ref:`api_fluid_name_scope` 
+
+.. _cn_api_fluid_ParallelExecutor:
+
+ParallelExecutor
+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+.. 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`` 专门设计用来实现数据并行计算，着力于向不同结点(node)分配数据，并行地在不同结点中对数据进行操作。如果在GPU上使用该类运行程序，node则用来指代GPU， ``ParallelExecutor`` 也将自动获取在当前机器上可用的GPU资源。如果在CPU上进行操作，node则指代CPU，同时你也可以通过添加环境变量 ``CPU_NUM`` 来设置CPU设备的个数。例如，``CPU_NUM=4``。但是如果没有设置该环境变量，该类会调用 ``multiprocessing.cpu_count`` 来获取当前系统中CPU的个数。
+
+
+
+
+参数: 
+    - **use_cuda** (bool) – 是否使用CUDA
+    - **loss_name** (str) – 在训练阶段，必须提供loss function名称。默认为None
+    - **main_program** (Program) – 需要执行的program。如果未提供， 那么将使用 ``default_main_program``。 默认为None
+    - **share_vars_from** (ParallelExecutor) – 如果提供了该参数， 则该 ``ParallelExecutor`` 与指定的 ``ParallelExecutor`` 共享变量。默          认为空
+    - **exec_strategy** (ExecutionStrategy) – ``exec_strategy`` 用于调控program在 ``ParallelExecutor`` 中的执行方式，例如，执行该program需要的线程数, 释放在执行过程中产生的临时变量需要的重复(iterations)次数。 请参考 ``fluid.ExecutionStrategy`` 获取详细介绍。该参数默认为 None
+    - **build_strategy** (BuildStrategy) – 设置成员 ``build_strategy`` 可以控制在 ``ParallelExecutor`` 中搭建SSA Graph的方式，例如， ``reduce_strategy`` ， ``gradient_scale_strategy`` 。 请参考 ``fluid.BuildStrategy`` 获取详细介绍。 该参数默认为None
+    - **num_trainers** (int) – 如果该值大于1， NCCL将会通过多层级node的方式来初始化。每个node应有相同的GPU数目。 随之会启用分布式训练。该参数默认为1
+    - **trainer_id** (int) – 必须与 ``num_trainers`` 参数同时使用。``trainer_id`` 是当前所在node的 “rank”（层级），从0开始计数。该参数默认为0
+    - **scope** (Scope) – 指定执行program所在的作用域， 默认使用 ``fluid.global_scope()``
+
+返回：初始化后的 ``ParallelExecutor`` 对象
+
+返回类型:	ParallelExecutor
+
+弹出异常：``TypeError`` - 如果提供的参数 ``share_vars_from`` 不是 ``ParallelExecutor`` 类型的，将会弹出此异常
+
+**代码示例**
+
+..  code-block:: python
+
+  train_exe = fluid.ParallelExecutor(use_cuda=True, loss_name=loss.name)
+  test_exe = fluid.ParallelExecutor(use_cuda=True,
+                                    main_program=test_program,
+                                    share_vars_from=train_exe)
+
+  train_loss, = train_exe.run([loss.name], feed=feed_dict)
+  test_loss, = test_exe.run([loss.name], feed=feed_dict)
+
+
+
+.. py:method::  run(fetch_list, feed=None, feed_dict=None, return_numpy=True)
+
+使用 ``fetch_list`` 执行一个 ``ParallelExecutor`` 对象。
+
+参数 ``feed`` 可以是 ``dict`` 或者 ``list`` 类型变量。如果该参数是 ``dict`` 类型，feed中的数据将会被分割(split)并分送给多个设备（CPU/GPU）。
+反之，如果它是 ``list`` ，则列表中的各个元素都会直接分别被拷贝到各设备中。
+
+例如，如果 ``feed`` 是个 ``dict`` 类型变量，则有
+
+..  code-block:: python
+    
+    exe = ParallelExecutor()
+    # 图像会被split到设备中。假设有两个设备，那么每个设备将会处理形为 (24, 1, 28, 28)的图像
+    exe.run(feed={'image': numpy.random.random(size=(48, 1, 28, 28))})
+  
+如果 ``feed`` 是个 ``list`` 类型变量，则有
+
+..  code-block:: python
+
+    exe = ParallelExecutor()
+    # 各设备挨个处理列表中的每个元素
+    # 第一个设备处理形为 (48, 1, 28, 28) 的图像
+    # 第二个设备处理形为 (32, 1, 28, 28) 的图像
+    #
+    # 使用 exe.device_count 得到设备数目
+    exe.run(feed=[{"image": numpy.random.random(size=(48, 1, 28, 28))},
+                  {"image": numpy.random.random(size=(32, 1, 28, 28))},
+                  ])
+
+参数： 
+    - **fetch_list** (list) – 获取的变量名列表
+    - **feed** (list|dict|None) – feed变量。 如果该参数是 ``dict`` 类型，feed中的数据将会被分割(split)并分送给多个设备（CPU/GPU）。反之，如果它是 ``list`` ，则列表中的各个元素都直接分别被拷贝到各设备中。默认为None
+    - **feed_dict** – 该参数已经停止使用。feed参数的别名, 为向后兼容而立。默认为None
+    - **return_numpy** (bool) – 是否将fetched tensor转换为numpy。默认为True
+
+返回： 获取的结果列表
+
+返回类型：List
+
+弹出异常： 
+         ``ValueError`` - 如果feed参数是list类型，但是它的长度不等于可用设备（执行场所）的数目，再或者给定的feed不是dict类型，弹出此异常
+         
+         ``TypeError`` - 如果feed参数是list类型，但是它里面的元素不是dict类型时，弹出此异常
+
+额外注意：
+     1.如果feed参数为dict类型，那么传入 ``ParallelExecutor`` 的数据量 *必须* 大于可用的执行场所数目。否则，C++端将会弹出异常。应额外注意核对数据集的最后一个batch是否比可用执行场所数目大。
+    
+     2.如果可用执行场所大于一个，则为每个变量最后获取的结果都是list类型，且这个list中的每个元素都是各个可用执行场所的变量
+
+**代码示例**
+
+..  code-block:: python
+
+        pe = fluid.ParallelExecutor(use_cuda=use_cuda,
+                                    loss_name=avg_cost.name,
+                                    main_program=fluid.default_main_program())
+        loss = pe.run(feed=feeder.feed(cur_batch),
+                      fetch_list=[avg_cost.name]))
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_ParallelExecutor` 
+
+.. _cn_api_fluid_ParamAttr:
+
+ 
+ParamAttr
+>>>>>>>>>>>>>>>>>>>>>>>>>
+
+
+.. py:class:: paddle.fluid.ParamAttr(name=None, initializer=None, learning_rate=1.0, regularizer=None, trainable=True, gradient_clip=None, do_model_average=False)
+
+该类代表了参数的各种属性。 为了使神经网络训练过程更加流畅，用户可以根据需要调整参数属性。比如learning rate（学习率）, regularization（正则化）, trainable（可训练性）, do_model_average(平均化模型)和参数初始化方法.
+
+参数:	
+    - **name** (str) – 参数名。默认为None。
+    - **initializer** (Initializer) – 初始化该参数的方法。 默认为None
+    - **learning_rate** (float) – 参数的学习率。计算方法为 :math:`global\_lr*parameter\_lr∗scheduler\_factor` 。 默认为1.0
+    - **regularizer** (WeightDecayRegularizer) – 正则因子. 默认为None
+    - **trainable** (bool) – 该参数是否可训练。默认为True
+    - **gradient_clip** (BaseGradientClipAttr) – 减少参数梯度的方法。默认为None
+    - **do_model_average** (bool) – 该参数是否服从模型平均值。默认为False
+    
+**代码示例**
+
+..  code-block:: python
+
+   w_param_attrs = fluid.ParamAttr(name="fc_weight",
+                                   learning_rate=0.5,
+                                   regularizer=fluid.L2Decay(1.0),
+                                   trainable=True)
+   y_predict = fluid.layers.fc(input=x, size=10, param_attr=w_param_attrs)
+
+
+
+
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_ParamAttr` 
+
+.. _cn_api_fluid_Program:
+
+Program
+>>>>>>>>>>>>
+
+.. py:function::  paddle.fluid.Program
+
+
+创建python program， 在paddleFluid内部会被转换为ProgramDesc描述语言，是被用来创建c++ Program。Program像容器一样也是一种独立的程序语言。Program包括至少一个块（Block），控制流比如conditional_block包括while_op，该Program将会含有嵌套块（nested block）。详情请参阅framework.proto。
+
+注意：默认情况下，paddleFluid内部默认含有 ``default_startup_program`` 和 ``default_main_program`` ，它们将共享参数。 ``default_startup_program`` 只运行一次来初始化参数， ``default_main_program`` 在每个mini batch中运行并调整权重。
+
+返回： empty program
+
+**代码示例**
+
+..  code-block:: python
+
+  main_program = fluid.Program()
+  startup_program = fluid.Program()
+  with fluid.program_guard(main_program=main_program, startup_program=startup_program):
+        fluid.layers.data(name="x", shape=[-1, 784], dtype='float32')
+        fluid.layers.data(name="y", shape=[-1, 1], dtype='int32')
+        fluid.layers.fc(name="fc", shape=[10], dtype='float32', act="relu")
+
+
+
+.. py:attribute:: op_role
+
+operator的角色，值只能是枚举变量{Forward, Backward, Optimize}。
+
+注意：这是一个底层API。它仅用于 ``ParallelExecutor`` 复制或调度operator到设备。
+
+例如，Forward operator应该在每个设备上执行。Backward operator在每个设备上执行，并将后向传播的参数梯度(使用 ``op_role_var`` 获得该变量)合并到一个设备上。Optimize operator只在一个设备上执行，并向其他设备广播新的参数，
+
+
+
+.. py:attribute:: set_op_role
+
+operator的角色，值只能是枚举变量{Forward, Backward, Optimize}。
+
+注意：这是一个底层API。它仅用于 ``ParallelExecutor`` 复制或调度operator到设备上执行。
+
+例如，Forward operator应该在每个设备上执行。Backward operato应该在每个设备上执行，并将后向传播的参数梯度(使用op_role_var获得该变量)合并到一个设备上。Optimize operator只在一个设备上执行，并向其他设备广播新的参数
+
+
+
+.. py:attribute:: op_role_var
+
+``op_role`` 的辅助变量。
+
+参考: ``Program.op_role`` 文档。
+
+注意:这是一个底层API，用户不应该直接使用它。
+
+
+
+.. py:attribute:: set_op_role_var
+
+``op_role`` 的辅助变量。
+
+参考: ``Program.op_role`` 文档。
+
+注意:这是一个底层API。用户不应该直接使用它。
+
+
+
+.. py:method:: to_string(throw_on_error, with_details=False)
+
+用于debug
+
+参数：  
+	- **throw_on_error** (bool): 没有设置任何必需的字段时，抛出值错误。
+	- **with_details** (bool): 值为true时，打印更多关于变量和参数的信息，如trainable, optimize_attr等
+
+返回：(str): debug 字符串
+
+抛出异常： ``ValueError`` - 当 ``throw_on_error == true`` ，但没有设置任何必需的字段时，抛出 ``ValueError`` 。
+
+
+
+.. py:method:: clone(for_test=False)
+
+创建一个新的、相同的Program。
+
+有些operator，在训练和测试之间的行为是不同的，比如batch_norm。它们有一个属性is_test来控制行为。当for_test=True时，此方法将把它们的is_test属性更改为True。
+
+- 克隆Program，该Program用于训练时，将 ``for_test`` 设置为False。
+- 克隆Program，该Program用于测试时，将 ``for_test`` 设置为True。
+
+注意:此API不会删除任何操作符。请在backward和optimization之前使用clone(for_test=True)。
+
+**代码示例**
+
+..  code-block:: python
+
+  test_program = fluid.default_main_program().clone(for_test=True)
+  optimizer = fluid.optimizer.Momentum(learning_rate=0.01, momentum=0.9)
+  optimizer.minimize()
+
+参数：
+	- **for_test** (bool) – 取值为True时，clone方法内部会把operator的属性 ``is_test`` 设置为 True
+
+返回：一个新的、相同的Program
+
+返回类型:Program
+
+**代码示例**
+
+1.克隆一个Program，示例代码如下：
+
+..  code-block:: python
+
+  train_program = fluid.Program()
+  startup_program = fluid.Program()
+  with fluid.program_guard(train_program, startup_program):
+        img = fluid.layers.data(name='image', shape=[784])
+        hidden = fluid.layers.fc(input=img, size=200, act='relu')
+        hidden = fluid.layers.dropout(hidden, dropout_prob=0.5)
+        loss = fluid.layers.cross_entropy(
+                     input=fluid.layers.fc(hidden, size=10, act='softmax'),
+                     label=fluid.layers.data(name='label', shape=[1], dtype='int64'))
+  test_program = train_program.clone(for_test=True)
+  sgd = fluid.optimizer.SGD(learning_rate=1e-3)
+  with fluid.program_guard(train_program, startup_program):
+        sgd.minimize(loss)    
+	
+2.如果分别运行 train Program 和 test Program，则可以不使用clone。
+
+..  code-block:: python
+
+	import paddle.fluid as fluid
+
+ 	def network(is_test):
+	     img = fluid.layers.data(name='image', shape=[784])
+	     hidden = fluid.layers.fc(input=img, size=200, act='relu')
+	     hidden = fluid.layers.dropout(hidden, dropout_prob=0.5, is_test=is_test)
+	     loss = fluid.layers.cross_entropy(
+			 input=fluid.layers.fc(hidden, size=10, act='softmax'),
+			 label=fluid.layers.data(name='label', shape=[1], dtype='int64'))
+	     return loss
+
+	 train_program = fluid.Program()
+	 startup_program = fluid.Program()
+	 test_program = fluid.Program()
+
+	 with fluid.program_guard(train_program, startup_program):
+	     with fluid.unique_name.guard():
+		 loss = network(is_test=False)
+		 sgd = fluid.optimizer.SGD(learning_rate=1e-3)
+		 sgd.minimize(loss)
+
+	 # 不使用测试阶段的startup program
+	 with fluid.program_guard(test_program, fluid.Program()):
+	     with fluid.unique_name.guard():
+		 loss = network(is_test=True)
+
+上边两个代码片段生成的Program是一样的。
+
+.. py:staticmethod:: parse_from_string(binary_str)
+
+反序列化protobuf，转换成program
+
+注意:在序列化和反序列化之后，所有关于参数的信息都会丢失。
+
+参数:	
+    - **binary_str_type** (str) – prootbuf二进制字符串
+
+返回:	反序列化后的ProgramDesc
+
+返回类型：Program
+
+.. py:attribute:: num_blocks
+
+该program中的block的个数
+
+.. py:attribute:: random_seed
+
+
+程序中随机运算符的默认随机种子。0意味着从随机设备中获取随机种子。
+
+注意：必须在operator被添加之前设置。
+
+.. py:method:: global_block()
+
+获取该program的第一个block。
+
+.. py:method:: block(index)
+
+返回该program中 ， ``index`` 指定的block。 ``index`` 类型为int
+
+返回：index对应的block
+
+返回类型：Block
+
+.. py:method:: current_block()
+
+获取当前block。当前block是用来添加operators。
+
+.. py:method:: list_vars()
+
+获取当前program中所有变量。返回值是一个可迭代对象（iterable object)。
+
+返回：generator 会yield每个Program中的变量
+
+返回类型：iterable
+	
+
+
+
+英文版API文档: :ref:`api_fluid_Program` 
+
+.. _cn_api_fluid_program_guard:
+
+program_guard
+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.program_guard(*args, **kwds)
+
+
+
+该函数应配合使用python的“with”语句来改变全局主程序(main program)和启动程序(startup program)。
+
+“with”语句块中的layer函数将在新的main program（主程序）中添加operators（算子）和variables（变量）。
+
+**代码示例**
+
+..  code-block:: python
+
+	import paddle.fluid as fluid
+	main_program = fluid.Program()
+	startup_program = fluid.Program()
+	with fluid.program_guard(main_program, startup_program):
+		data = fluid.layers.data(...)
+ 		hidden = fluid.layers.fc(...)
+
+需要注意的是，如果用户不需要构建自己的启动程序或者主程序，一个临时的program将会发挥作用。
+
+**代码示例**
+
+..  code-block:: python
+
+	import paddle.fluid as fluid
+	main_program = fluid.Program()
+	# 如果您不需要关心startup program,传入一个临时值即可
+	with fluid.program_guard(main_program, fluid.Program()):
+		data = ...
+
+
+参数：  
+		- **main_program** (Program) – “with”语句中将使用的新的main program。
+		- **startup_program** (Program) – “with”语句中将使用的新的startup program。若传入 ``None`` 则不改变当前的启动程序。
+
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_program_guard` 
+
+.. _cn_api_fluid_release_memory:
+
+release_memory
+>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.release_memory(input_program, skip_opt_set=None) 
+
+
+该函数可以调整输入program，插入 ``delete_op`` 删除算子，提前删除不需要的变量。
+改动是在变量本身上进行的。
+
+**提醒**: 该API还在试验阶段，会在后期版本中删除。不建议用户使用。
+
+参数:	
+    - **input_program** (Program) – 在此program中插入 ``delete_op`` 
+    - **skip_opt_set** (set) – 在内存优化时跳过的变量的集合
+
+返回: None
+
+
+
+
+
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_release_memory` 
+
+.. _cn_api_fluid_Scope:
+
+Scope
+>>>>>>>>>>>>>>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.scope(scope)
+
+.. py:method:: drop_kids(self: paddle.fluid.core.Scope) → None
+.. py:method:: find_var(self: paddle.fluid.core.Scope, arg0: unicode) → paddle.fluid.core.Variable
+.. py:method:: new_scope(self: paddle.fluid.core.Scope) → paddle.fluid.core.Scope
+.. py:method:: var(self: paddle.fluid.core.Scope, arg0: unicode) → paddle.fluid.core.Variable   
+
+
+
+
+英文版API文档: :ref:`api_fluid_Scope` 
+
+.. _cn_api_fluid_scope_guard:
+
+scope_guard
+>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.scope_guard(*args, **kwds)()
+
+
+修改全局/默认作用域（scope）,  运行时中的所有变量都将分配给新的scope。
+
+参数：
+	- **scope** - 新的全局/默认 scope。
+
+**代码示例**
+
+..  code-block:: python
+
+	import paddle.fluid as fluid
+	
+	new_scope = fluid.Scope()
+	with fluid.scope_guard(new_scope):
+		...
+
+
+
+
+英文版API文档: :ref:`api_fluid_scope_guard` 
+
+.. _cn_api_fluid_switch_scope:
+
+_switch_scope
+>>>>>>>>>>>>>>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid._switch_scope(scope)
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_switch_scope` 
+
+.. _cn_api_fluid_WeightNormParamAttr:
+
+WeightNormParamAttr
+>>>>>>>>>>>>>>>>>>>>>>
+
+.. 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)
+
+
+权重归一化。权重归一化是将权重向量的长度与其方向解耦。`Weight Normalization: A Simple Reparameterization to Accelerate Training of Deep Neural Networks <https://arxiv.org/pdf/1602.07868.pdf>`_ 这篇paper中讨论了权重归一化的实现
+
+参数:
+	- **dim** (list) - 参数的名称。默认None。
+	- **name** (str) - 参数的名称。默认None。
+	- **initializer** （initializer) - 初始化参数的方法。默认None。
+	- **learning_rate** (float) - 学习率。优化时学习速率 :math:`global\_lr∗parameter\_lr∗scheduler\_factor` 。默认1.0。
+	- **regularizer** (WeightDecayRegularizer) - 正则化因子。默认None。
+	- **trainable** (bool) - 参数是否可训练。默认True。
+	- **gradient_clip** (BaseGradientClipAttr) - 梯度下降裁剪（Gradient Clipping）的方法。默认None。
+	- **do_model_average** (bool) - 参数是否应该model average。默认False。
+
+返回： empty program
+
+**代码示例**
+
+..  code-block:: python
+
+	data = fluid.layers.data(name="data", shape=[3, 32, 32], dtype="float32")
+	fc = fluid.layers.fc(input=data,
+			     size=1000,
+			     param_attr=WeightNormParamAttr(
+				  dim=None,
+				  name='weight_norm_param'))
+
+
+
+
+英文版API文档: :ref:`api_fluid_WeightNormParamAttr` 
+

doc/fluid/api_cn/gen_index.py

+import os.path, time
+import exceptions
+import glob
+import os
+if __name__ == '__main__':
+    
+    file_object = open('index_cn.rst', 'w')
+    file_object.write('''=============
+API Reference
+=============
+
+..  toctree::
+    :maxdepth: 1
+
+''')
+    file_object.write('    api_guides/index.rst'+'\n')
+    file_object.write('    fluid_cn.rst'+'\n')
+    for file_name in sorted(glob.glob("*.rst")):
+        if file_name != ('index_cn.rst' and 'fluid_cn.rst'):
+            file_object.write('    '+file_name + "\n")
+    file_object.close( )

doc/fluid/api_cn/index_cn.rst

+=============
+API Reference
+=============
+
+..  toctree::
+    :maxdepth: 1
+
+    api_guides/index.rst
+    fluid_cn.rst
+    average_cn.rst
+    backward_cn.rst
+    clip_cn.rst
+    data_feeder_cn.rst
+    executor_cn.rst
+    index_cn.rst
+    initializer_cn.rst
+    io_cn.rst
+    layers_cn.rst
+    metrics_cn.rst
+    net_cn.rst
+    optimizer_cn.rst
+    param_attr_cn.rst
+    profiler_cn.rst
+    regularizer_cn.rst
+    transpliter_cn.rst

doc/fluid/api_cn/initializer_cn.rst

+
+#################
+ fluid.initializer
+#################
+
+
+.. _cn_api_fluid_initializer_Bilinear:
+
+Bilinear
+>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.initializer.Bilinear
+
+ ``BilinearInitializer``的别名
+
+
+.. _cn_api_fluid_initializer_BilinearInitializer:
+
+BilinearInitializer
+>>>>>>>>>>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.initializer.BilinearInitializer
+
+该初始化函数用于转置卷积函数，进行上采样。用户通过任意整型因子放大shape为(B，C，H，W)的特征图。用法如下：
+
+**代码示例**:
+
+.. code-block:: python
+
+    factor = 2
+    w_attr = ParamAttr(learning_rate=0., regularizer=L2Decay(0.),
+                   initializer=Bilinear())
+    conv_up = fluid.layers.conv2d_transpose(
+        input,
+        num_filters=C,
+        output_size=None,
+        filter_size=2 * factor - factor % 2,
+        padding=ceil((factor - 1) / 2.),
+        stride=factor,
+        groups=C,
+        param_attr=w_attr,
+        bias_attr=False)
+
+num_filters = C和groups = C 表示这是按通道转置的卷积函数。滤波器shape为(C,1,K,K)，K为filter_size。该初始化函数为滤波器的每个通道设置(K,K)插值核。输出特征图的最终输出shape为(B,C,factor*H,factor*W)。注意学习率和权重衰减设为0，以便在训练过程中双线性插值的系数值保持不变
+
+
+
+英文版API文档: :ref:`api_fluid_initializer_BilinearInitializer` 
+
+.. _cn_api_fluid_initializer_Constant:
+
+Constant
+>>>>>>>>>>
+
+.. py:function:: paddle.fluid.initializer.Constant
+
+ ``ConstantInitializer``的别名
+
+
+.. _cn_api_fluid_initializer_ConstantInitializer:
+
+ConstantInitializer
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.initializer.ConstantInitializer(value=0.0, force_cpu=False)
+
+常量初始器
+
+参数：
+        - **value** (float) - 用常量初始化变量
+
+**代码示例**
+
+.. code-block:: python
+        
+        fc = fluid.layers.fc(input=x, size=10,
+            param_attr=fluid.initializer.Constant(value=2.0))
+
+
+
+英文版API文档: :ref:`api_fluid_initializer_ConstantInitializer` 
+
+
+
+.. _cn_api_fluid_initializer_force_init_on_cpu:
+
+force_init_on_cpu
+>>>>>>>>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.initializer.force_init_on_cpu()
+
+标志位，是否强制在CPU上进行变量初始化。
+
+返回：状态，是否应强制在CPU上强制进行变量初始化
+
+返回类型：bool
+
+**代码示例**：
+
+.. code-block:: python
+
+    if force_init_on_cpu():
+        create_op('force_cpu': force_init_on_cpu())
+
+
+英文版API文档: :ref:`api_fluid_initializer_force_init_on_cpu`
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_initializer_init_on_cpu:
+
+init_on_cpu
+>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.initializer.init_on_cpu(*args, **kwds)
+
+强制变量在 cpu 上初始化。
+
+**代码示例**
+
+.. code-block:: python
+        
+        with init_on_cpu():
+                step = layers.create_global_var()
+
+
+
+英文版API文档: :ref:`api_fluid_initializer_init_on_cpu` 
+
+
+.. _cn_api_fluid_initializer_MSRA:
+
+MSRA
+>>>>>>
+
+.. py:function:: paddle.fluid.initializer.MSRA
+
+ ``MSRAInitializer``的别名
+
+.. _cn_api_fluid_initializer_MSRAInitializer:
+
+MSRAInitializer
+>>>>>>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.initializer.MSRAInitializer(uniform=True, fan_in=None, seed=0)
+
+实现MSRA初始化（a.k.a. Kaiming初始化）
+
+该类实现权重初始化方法，方法来自Kaiming He，Xiangyu Zhang，Shaoqing Ren 和 Jian Sun所写的论文: `Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification <https://arxiv.org/abs/1502.01852>`_ 。这是一个鲁棒性特别强的初始化方法，并且适应了非线性激活函数（rectifier nonlinearities）。
+
+在均匀分布中，范围为[-x,x]，其中：
+
+.. math::
+
+	x = \sqrt{\frac{6.0}{fan\_in}}
+
+在正态分布中，均值为0，标准差为：
+
+.. math::
+
+    \sqrt{\frac{2.0}{fan\_in}}
+
+参数：
+    - **uniform** (bool) - 是否用均匀分布或正态分布
+    - **fan_in** (float) - MSRAInitializer的fan_in。如果为None，fan_in沿伸自变量
+    - **seed** (int) - 随机种子
+
+.. note:: 
+
+    在大多数情况下推荐设置fan_in为None
+
+**代码示例**：
+
+.. code-block:: python
+
+    fc = fluid.layers.fc(
+        input=queries, size=10,
+        param_attr=fluid.initializer.MSRA(uniform=False))
+
+
+
+英文版API文档: :ref:`api_fluid_initializer_MSRAInitializer` 
+
+
+.. _cn_api_fluid_initializer_Normal:
+
+Normal
+>>>>>>>>
+
+.. py:function:: paddle.fluid.initializer.Normal
+
+ ``NormalInitializer``的别名
+
+
+.. _cn_api_fluid_initializer_NormalInitializer:
+
+NormalInitializer
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.initializer.NormalInitializer(loc=0.0, scale=1.0, seed=0)
+
+随机正态（高斯）分布初始化器
+
+参数：
+        - **loc** （float） - 正态分布的平均值
+        - **scale** （float） - 正态分布的标准差
+        - **seed** （int） - 随机种子
+
+**代码示例**
+
+.. code-block:: python
+
+        fc = fluid.layers.fc(input=x, size=10,
+            param_attr=fluid.initializer.Normal(loc=0.0, scale=2.0)
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_initializer_NormalInitializer` 
+
+.. _cn_api_fluid_initializer_TruncatedNormal:
+
+TruncatedNormal
+>>>>>>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.initializer.TruncatedNormal
+
+ ``TruncatedNormalInitializer``的别名
+
+
+.. _cn_api_fluid_initializer_TruncatedNormalInitializer:
+
+TruncatedNormalInitializer
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.initializer.TruncatedNormalInitializer(loc=0.0, scale=1.0, seed=0)
+
+Random Truncated Normal（高斯）分布初始化器
+
+参数：
+        - **loc** （float） - 正态分布的平均值
+        - **scale** （float） - 正态分布的标准差
+        - **seed** （int） - 随机种子
+
+**代码示例**
+
+.. code-block:: python
+
+        fc = fluid.layers.fc(input=x, size=10,
+            param_attr=fluid.initializer.TruncatedNormal(loc=0.0, scale=2.0))
+
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_initializer_TruncatedNormalInitializer` 
+
+
+.. _cn_api_fluid_initializer_Uniform:
+
+Uniform
+>>>>>>>>>
+
+.. _cn_api_fluid_initializer_UniformInitializer:
+
+.. py:class:: paddle.fluid.initializer.Uniform
+
+ ``UniformInitializer``的别名
+
+
+UniformInitializer
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.initializer.UniformInitializer(low=-1.0, high=1.0, seed=0) 
+
+随机均匀分布初始化器
+
+参数：
+        - **low** (float) - 下界 
+        - **high** (float) - 上界
+        - **seed** (float) - 随机种子
+
+**代码示例**
+
+.. code-block:: python
+        
+       fc = fluid.layers.fc(input=x, size=10,
+            param_attr=fluid.initializer.Uniform(low=-0.5, high=0.5))
+ 
+
+
+
+英文版API文档: :ref:`api_fluid_initializer_UniformInitializer` 
+
+.. _api_fluid_initializer_Xavier:
+
+Xavier
+>>>>>>>>>
+
+.. py:function:: paddle.fluid.initializer.Xavier
+
+ ``XavierInitializer``的别名
+
+.. _cn_api_fluid_initializer_XavierInitializer:
+
+XavierInitializer
+>>>>>>>>>>>>>>>>>>>
+.. py:class:: paddle.fluid.initializer.XavierInitializer(uniform=True, fan_in=None, fan_out=None, seed=0)
+
+该类实现Xavier权重初始化方法（ Xavier weight initializer），Xavier权重初始化方法出自Xavier Glorot和Yoshua Bengio的论文 `Understanding the difficulty of training deep feedforward neural networks <http://proceedings.mlr.press/v9/glorot10a/glorot10a.pdf>`_
+
+该初始化函数用于保持所有层的梯度尺度几乎一致。
+
+在均匀分布的情况下，取值范围为[-x,x]，其中：
+
+.. math::
+
+    x = \sqrt{\frac{6.0}{fan\_in+fan\_out}}
+
+正态分布的情况下，均值为0，标准差为：
+
+.. math::
+    
+    x = \sqrt{\frac{2.0}{fan\_in+fan\_out}}
+
+参数：
+    - **uniform** (bool) - 是否用均匀分布或者正态分布
+    - **fan_in** (float) - 用于Xavier初始化的fan_in。如果为None，fan_in沿伸自变量
+    - **fan_out** (float) - 用于Xavier初始化的fan_out。如果为None，fan_out沿伸自变量
+    - **seed** (int) - 随机种子
+
+.. note::
+
+    在大多数情况下推荐将fan_in和fan_out设置为None
+
+**代码示例**：
+
+.. code-block:: python
+
+    fc = fluid.layers.fc(
+        input=queries, size=10,
+        param_attr=fluid.initializer.Xavier(uniform=False))
+
+
+
+
+英文版API文档: :ref:`api_fluid_initializer_XavierInitializer` 
+

doc/fluid/api_cn/io_cn.rst

+
+#################
+ fluid.io
+#################
+
+
+
+.. _cn_api_fluid_io_load_inference_model:
+
+load_inference_model
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.io.load_inference_model(dirname, executor, model_filename=None, params_filename=None, pserver_endpoints=None)
+
+从指定目录中加载 推理model(inference model)
+
+参数:
+  - **dirname** (str) – model的路径
+  - **executor** (Executor) – 运行 inference model的 ``executor``
+  - **model_filename** (str|None) –  推理 Program 的文件名称。如果设置为None，将使用默认的文件名为： ``__model__``
+  - **params_filename** (str|None) –  加载所有相关参数的文件名称。如果设置为None，则参数将保存在单独的文件中。
+  - **pserver_endpoints** (list|None) – 只有在分布式推理时需要用到。 当在训练时使用分布式 look up table , 需要这个参数. 该参数是 pserver endpoints 的列表 
+
+返回: 这个函数的返回有三个元素的元组(Program，feed_target_names, fetch_targets)。Program 是一个 ``Program`` ，它是推理 ``Program``。  ``feed_target_names`` 是一个str列表，它包含需要在推理 ``Program`` 中提供数据的变量的名称。` `fetch_targets`` 是一个 ``Variable`` 列表，从中我们可以得到推断结果。
+
+返回类型：元组(tuple)
+
+抛出异常：
+   - ``ValueError`` – 如果 ``dirname`` 非法 
+
+..  code-block:: python
+
+    exe = fluid.Executor(fluid.CPUPlace())
+    path = "./infer_model"
+    endpoints = ["127.0.0.1:2023","127.0.0.1:2024"]
+    [inference_program, feed_target_names, fetch_targets] =
+        fluid.io.load_inference_model(dirname=path, executor=exe)
+    results = exe.run(inference_program,
+                  feed={feed_target_names[0]: tensor_img},
+                  fetch_list=fetch_targets)
+    # 在这个示例中，inference program 保存在 ./infer_model/__model__”中
+    # 参数保存在./infer_mode 单独的若干文件中
+    # 加载 inference program 后， executor 使用 fetch_targets 和 feed_target_names 执行Program， 得到推理结果
+
+
+
+英文版API文档: :ref:`api_fluid_io_load_inference_model` 
+
+.. _cn_api_fluid_io_load_params:
+
+load_params
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.io.load_params(executor, dirname, main_program=None, filename=None)
+
+该函数过滤掉 给定 ``main_program`` 中所有参数，然后将它们加载保存在到目录 ``dirname`` 中或文件中的参数。
+
+``dirname`` 用于指定保存变量的目录。如果变量保存在指定目录的若干文件中，设置文件名 None; 如果所有变量保存在一个文件中，请使用filename来指定它
+
+注意:有些变量不是参数，但它们对于训练是必要的。因此，您不能仅通过 ``save_params()`` 和 ``load_params()`` 保存并之后继续训练。可以使用 ``save_persistables()`` 和 ``load_persistables()`` 代替这两个函数
+
+参数:
+ - **executor**  (Executor) – 加载变量的 executor
+ - **dirname**  (str) – 目录路径
+ - **main_program**  (Program|None) – 需要加载变量的 Program。如果为 None，则使用 default_main_Program 。默认值: None
+ - **filename**  (str|None) – 保存变量的文件。如果想分开保存变量，设置 filename=None. 默认值: None
+
+返回: None
+  
+**代码示例**
+
+..  code-block:: python
+    
+    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)
+                        
+
+
+英文版API文档: :ref:`api_fluid_io_load_params` 
+
+.. _cn_api_fluid_io_load_persistables:
+
+load_persistables
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.io.load_persistables(executor, dirname, main_program=None, filename=None)
+
+该函数过滤掉 给定 ``main_program`` 中所有参数，然后将它们加载保存在到目录 ``dirname`` 中或文件中的参数。
+
+``dirname`` 用于指定保存变量的目录。如果变量保存在指定目录的若干文件中，设置文件名 None; 如果所有变量保存在一个文件中，请使用filename来指定它
+
+参数:
+    - **executor**  (Executor) – 加载变量的 executor
+    - **dirname**  (str) – 目录路径
+    - **main_program**  (Program|None) – 需要加载变量的 Program。如果为 None，则使用 default_main_Program 。默认值: None
+    - **filename**  (str|None) – 保存变量的文件。如果想分开保存变量，设置 filename=None. 默认值: None
+
+返回: None
+  
+**代码示例**
+
+..  code-block:: python
+
+    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)
+ 
+
+
+英文版API文档: :ref:`api_fluid_io_load_persistables` 
+
+.. _cn_api_fluid_io_load_vars:
+
+load_vars
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.io.load_vars(executor, dirname, main_program=None, vars=None, predicate=None, filename=None)
+
+``executor`` 从指定目录加载变量。
+
+有两种方法来加载变量:方法一，``vars`` 为变量的列表。方法二，将已存在的 ``Program`` 赋值给 ``main_program`` ，然后将加载 ``Program`` 中的所有变量。第一种方法优先级更高。如果指定了 vars，那么忽略 ``main_program`` 和 ``predicate`` 。
+
+``dirname`` 用于指定加载变量的目录。如果变量保存在指定目录的若干文件中，设置文件名 None; 如果所有变量保存在一个文件中，请使用 ``filename`` 来指定它
+
+参数:
+ - **executor**  (Executor) – 加载变量的 executor
+ - **dirname**  (str) – 目录路径
+ - **main_program**  (Program|None) – 需要加载变量的 Program。如果为 None，则使用 default_main_Program 。默认值: None
+ - **vars**  (list[Variable]|None) –  要加载的变量的列表。 优先级高于main_program。默认值: None
+ - **predicate**  (function|None) – 如果不等于None，当指定main_program， 那么只有 predicate(variable)==True 时，main_program中的变量会被加载。
+ - **filename**  (str|None) – 保存变量的文件。如果想分开保存变量，设置 filename=None. 默认值: None
+
+抛出异常：
+  - ``TypeError`` - 如果参数 ``main_program`` 为 None 或为一个非 ``Program`` 的实例
+   
+返回: None
+  
+**代码示例**
+
+..  code-block:: python
+    
+    exe = fluid.Executor(fluid.CPUPlace())
+    param_path = "./my_paddle_model"
+
+    # 第一种使用方式 使用 main_program 指定变量
+    def name_has_fc(var):
+        res = "fc" in var.name
+        return res
+
+    prog = fluid.default_main_program()
+    fluid.io.load_vars(executor=exe, dirname=path, main_program=prog,
+                       vars=None)
+
+
+    # The second usage: using `vars` to specify variables
+    var_list = [var_a, var_b, var_c]
+    fluid.io.load_vars(executor=exe, dirname=path, vars=var_list,
+                       filename="vars_file")
+    # var_a, var_b and var_c will be loaded. And they are supposed to haven
+    # been saved in the same file named 'var_file' in the path "./my_paddle_model".
+ 
+
+
+英文版API文档: :ref:`api_fluid_io_load_vars` 
+
+.. _cn_api_fluid_io_save_inference_model:
+
+save_inference_model
+>>>>>>>>>>>>
+
+.. py:class:: 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)
+
+修改指定的 ``main_program`` ，构建一个专门用于推理的 ``Program``，然后  ``executor`` 把它和所有相关参数保存到 ``dirname`` 中
+
+``dirname`` 用于指定保存变量的目录。如果变量保存在指定目录的若干文件中，设置文件名 None; 如果所有变量保存在一个文件中，请使用filename来指定它
+
+参数:
+  - **dirname** (str) – 保存推理model的路径
+  - **feeded_var_names** (list[str]) – 推理（inference）需要 feed 的数据
+  - **target_vars** (list[Variable]) – 保存推理（inference）结果的 Variables
+  - **executor** (Executor) –  executor 保存  inference model
+  - **main_program** (Program|None) – 使用 ``main_program`` ，构建一个专门用于推理的 ``Program`` （inference model）. 如果为None, 使用   ``default main program``   默认: None.
+  - **model_filename** (str|None) – 保存 推理P rogram 的文件名称。如果设置为None，将使用默认的文件名为： ``__model__``
+  - **params_filename** (str|None) – 保存所有相关参数的文件名称。如果设置为None，则参数将保存在单独的文件中。
+  - **export_for_deployment** (bool) – 如果为真，Program将被修改为只支持直接推理部署的Program。否则，将存储更多的信息，方便优化和再训练。目前只支持True。
+
+返回: None
+
+抛出异常：
+ - ``ValueError`` – 如果 ``feed_var_names`` 不是字符串列表
+ - ``ValueError`` – 如果 ``target_vars`` 不是 ``Variable`` 列表
+
+**代码示例**
+
+..  code-block:: python
+
+    exe = fluid.Executor(fluid.CPUPlace())
+    path = "./infer_model"
+    fluid.io.save_inference_model(dirname=path, feeded_var_names=['img'],
+                 target_vars=[predict_var], executor=exe)
+
+    # 在这个示例中，函数将修改默认的主程序让它适合于推断‘predict_var’。修改的
+    # 推理Program 将被保存在 ./infer_model/__model__”中。
+    # 和参数将保存在文件夹下的单独文件中 ./infer_mode
+
+
+
+
+英文版API文档: :ref:`api_fluid_io_save_inference_model` 
+
+.. _cn_api_fluid_io_save_params:
+
+save_params
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.io.save_params(executor, dirname, main_program=None, filename=None)
+
+该函数过滤掉 给定 ``main_program`` 中所有参数，然后将它们保存到目录 ``dirname`` 中或文件中。
+
+``dirname`` 用于指定保存变量的目录。如果想将变量保存到指定目录的若干文件中，设置文件名 None; 如果想将所有变量保存在一个文件中，请使用filename来指定它
+
+注意:有些变量不是参数，但它们对于训练是必要的。因此，您不能仅通过 ``save_params()`` 和 ``load_params()`` 保存并之后继续训练。可以使用 ``save_persistables()`` 和 ``load_persistables()`` 代替这两个函数
+
+
+参数:
+ - **executor**  (Executor) – 保存变量的 executor
+ - **dirname**  (str) – 目录路径
+ - **main_program**  (Program|None) – 需要保存变量的 Program。如果为 None，则使用 default_main_Program 。默认值: None
+ - **vars**  (list[Variable]|None) –  要保存的所有变量的列表。 优先级高于main_program。默认值: None
+ - **filename**  (str|None) – 保存变量的文件。如果想分开保存变量，设置 filename=None. 默认值: None
+ 
+返回: None
+  
+**代码示例**
+
+..  code-block:: python
+    
+    exe = fluid.Executor(fluid.CPUPlace())
+    param_path = "./my_paddle_model"
+    prog = fluid.default_main_program()
+    fluid.io.save_params(executor=exe, dirname=param_path,
+                         main_program=None)
+                         
+
+
+英文版API文档: :ref:`api_fluid_io_save_params` 
+
+.. _cn_api_fluid_io_save_persistables:
+
+save_persistables
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.io.save_persistables(executor, dirname, main_program=None, filename=None)
+
+该函数过滤掉 给定 ``main_program`` 中所有参数，然后将它们保存到目录 ``dirname`` 中或文件中。
+
+``dirname`` 用于指定保存变量的目录。如果想将变量保存到指定目录的若干文件中，设置 ``filename=None`` ; 如果想将所有变量保存在一个文件中，请使用 ``filename`` 来指定它
+
+参数:
+ - **executor**  (Executor) – 保存变量的 executor
+ - **dirname**  (str) – 目录路径
+ - **main_program**  (Program|None) – 需要保存变量的 Program。如果为 None，则使用 default_main_Program 。默认值: None
+ - **predicate**  (function|None) – 如果不等于None，当指定main_program， 那么只有 predicate(variable)==True 时，main_program中的变量
+ - **vars**  (list[Variable]|None) –  要保存的所有变量的列表。 优先级高于main_program。默认值: None
+ - **filename**  (str|None) – 保存变量的文件。如果想分开保存变量，设置 filename=None. 默认值: None
+ 
+返回: None
+  
+**代码示例**
+
+..  code-block:: python
+    
+    exe = fluid.Executor(fluid.CPUPlace())
+    param_path = "./my_paddle_model"
+    prog = fluid.default_main_program()
+    fluid.io.save_persistables(executor=exe, dirname=param_path,
+                               main_program=None)
+    
+    
+
+
+英文版API文档: :ref:`api_fluid_io_save_persistables` 
+
+
+
+.. _cn_api_fluid_io_save_vars:
+
+save_vars
+>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.io.save_vars(executor, dirname, main_program=None, vars=None, predicate=None, filename=None)
+
+通过 ``Executor`` ,此函数将变量保存到指定目录下。
+
+有两种方法可以指定要保存的变量：第一种方法，在列表中列出变量并将其传给 ``vars`` 参数。第二种方法是，将现有程序分配给 ``main_program`` ，它会保存program中的所有变量。第一种方式具有更高的优先级。换句话说，如果分配了变量，则将忽略 ``main_program`` 和 ``predicate`` 。
+
+``dirname`` 用于指定保存变量的文件夹。如果您希望将变量分别保存在文件夹目录的多个单独文件中，请设置 ``filename`` 为无；如果您希望将所有变量保存在单个文件中，请使用 ``filename`` 指定它。
+
+参数：
+      - **executor** （Executor）- 为保存变量而运行的执行器。
+      - **dirname** （str）- 目录路径。
+      - **main_program** （Program | None）- 保存变量的程序。如果为None，将自动使用默认主程序。默认值：None。
+      - **vars** （list [Variable] | None）- 包含要保存的所有变量的列表。它的优先级高于 ``main_program`` 。默认值：None。
+      - **predicate** （function | None）- 如果它不是None，则只保存 ``main_program`` 中使 :math:`predicate(variable)== True` 的变量。它仅在我们使用 ``main_program`` 指定变量时才起作用（换句话说，vars为None）。默认值：None。
+      - **filename** （str | None）- 保存所有变量的文件。如果您希望单独保存变量，请将其设置为None。默认值：None。
+
+返回：     None
+
+抛出异常：    
+    - ``TypeError`` - 如果main_program不是Program的实例，也不是None。
+
+**代码示例**
+
+..  code-block:: python
+
+      exe = fluid.Executor(fluid.CPUPlace())
+      param_path = "./my_paddle_model"
+
+      # 第一种用法:用main_program来指定变量。
+      def name_has_fc(var):
+          res = "fc" in var.name
+          return res
+
+      prog = fluid.default_main_program()
+      fluid.io.save_vars(executor=exe, dirname=path, main_program=prog,
+                         vars=None)
+      # 将main_program中名中包含“fc”的的所有变量保存。
+      # 变量将分开保存。
+
+
+      # 第二种用法: 用vars来指定变量。
+      var_list = [var_a, var_b, var_c]
+      fluid.io.save_vars(executor=exe, dirname=path, vars=var_list,
+                         filename="vars_file")
+      # var_a，var_b和var_c将被保存。 他们将使用同一文件，名为“var_file”，保存在路径“./my_paddle_model”下。
+
+
+
+英文版API文档: :ref:`api_fluid_io_save_vars` 
+

doc/fluid/api_cn/metrics_cn.rst

+
+#################
+ fluid.metrics
+#################
+
+
+
+.. _cn_api_fluid_merics_Auc:
+
+Auc
+>>>>
+
+.. py:class:: paddle.fluid.metrics.Auc(name, curve='ROC', num_thresholds=4095)
+
+Auc度量适用于二分类。参考 https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve  。需要注意auc度量本身是用Python计算值。如果关心速度，请用fluid.layers.auc。
+
+auc函数创建四个局部变量true_positives, true_negatives, false_positives和false_negatives，用于计算AUC。对于离散化AUC曲线，临界值线性间隔设置以便计算召回率和准确率的值，用false positive率的召回值高度计算ROC曲线面积，用recall的准确值高度计算PR曲线面积。
+
+参数：
+    - **name** - 度量名
+    - **curve** - 将要计算的曲线名的详情，曲线包括ROC（默认）或者PR（Precision-Recall-curve）。
+
+注：目前只用Python实现ROC曲线
+
+**代码示例**：
+
+.. code-block:: python
+
+    pred = fluid.layers.fc(input=data, size=1000, act="tanh")
+    metric = fluid.metrics.Auc()
+    for data in train_reader():
+        loss, preds, labels = exe.run(fetch_list=[cost, preds, labels])
+        metric.update(preds, labels)
+        numpy_auc = metric.eval()
+
+
+
+
+
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_merics_Auc` 
+
+.. _cn_api_fluid_merics_MetricBase:
+
+MetricBase
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.metrics.MetricBase(name)
+
+所有Metrics的基类。MetricBase为模型估计方法定义一组接口。Metrics累积连续的两个minibatch之间的度量状态，对每个minibatch用最新接口将当前minibatch值添加到全局状态。用eval函数来计算last reset()或者scratch on()中累积的度量值。如果需要定制一个新的metric，请继承自MetricBase和自定义实现类。
+
+参数：
+    - **name** (str) - metric实例名。例如准确率（accuracy）。如果想区分一个模型里不同的metrics，则需要实例名。
+
+.. py:method:: reset()
+
+        reset()清除度量（metric）的状态（state）。默认情况下，状态（state）包含没有 ``_`` 前缀的metric。reset将这些状态设置为初始状态。如果不想使用隐式命名规则，请自定义reset接口。
+
+.. py:method:: get_config()
+
+获取度量（metric)状态和当前状态。状态（state）包含没有 ``_`` 前缀的成员。
+        
+参数：**None**
+
+返回：metric对应到state的字典
+
+返回类型：字典（dict）
+
+
+.. py:method:: update(preds,labels)
+
+更新每个minibatch的度量状态（metric states），用户可通过Python或者C++操作符计算minibatch度量值（metric）。
+
+参数：
+     - **preds** (numpy.array) - 当前minibatch的预测
+     - **labels** (numpy.array) - 当前minibatch的标签，如果标签为one-hot或者soft-label，应该自定义相应的更新规则。
+
+.. py:method:: eval()
+
+基于累积状态（accumulated states）评估当前度量（current metric）。
+
+返回：metrics（Python中）
+
+返回类型：float|list(float)|numpy.array
+
+
+
+英文版API文档: :ref:`api_fluid_merics_MetricBase` 
+
+.. _cn_api_fluid_metrics_Accuracy:
+
+Accuracy
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.metrics.Accuracy(name=None)
+
+累加mini-batch正确率，计算每次pass的平均准确率。https://en.wikipedia.org/wiki/Accuracy_and_precision
+
+参数:
+    - **name** — 度量标准的名称
+
+**代码示例**
+
+.. code-block:: python
+
+    labels = fluid.layers.data(name="data", shape=[1], dtype="int32")
+    data = fluid.layers.data(name="data", shape=[32, 32], dtype="int32")
+    pred = fluid.layers.fc(input=data, size=1000, act="tanh")
+    minibatch_accuracy = fluid.layers.accuracy(pred, label)
+    accuracy_evaluator = fluid.metrics.Accuracy()
+    for pass in range(PASSES):
+        accuracy_evaluator.reset()
+        for data in train_reader():
+            batch_size = data[0]
+            loss = exe.run(fetch_list=[cost, minibatch_accuracy])
+        accuracy_evaluator.update(value=minibatch_accuracy, weight=batch_size)
+        numpy_acc = accuracy_evaluator.eval()
+
+
+.. py:method:: update(value, weight)
+
+更新mini batch的状态.
+
+参数：	
+    - **value** (float|numpy.array) – 每个mini batch的正确率
+    - **weight** (int|float) – batch 大小
+
+
+
+英文版API文档: :ref:`api_fluid_metrics_Accuracy` 
+
+.. _cn_api_fluid_metrics_ChunkEvaluator:
+
+ChunkEvaluator
+>>>>>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.metrics.ChunkEvaluator(name=None)
+
+用mini-batch的chunk_eval累计counter numbers，用累积的counter numbers计算准确率、召回率和F1值。对于chunking的基础知识，请参考 .. _Chunking with Support Vector Machines: https://aclanthology.info/pdf/N/N01/N01-1025.pdf 。ChunkEvalEvaluator计算块检测（chunk detection）的准确率，召回率和F1值，支持IOB, IOE, IOBES和IO标注方案。
+
+**代码示例**：
+
+.. code-block:: python
+
+        labels = fluid.layers.data(name="data", shape=[1], dtype="int32")
+        data = fluid.layers.data(name="data", shape=[32, 32], dtype="int32")
+        pred = fluid.layers.fc(input=data, size=1000, act="tanh")
+        precision, recall, f1_score, num_infer_chunks, num_label_chunks, num_correct_chunks = layers.chunk_eval(
+        input=pred,
+        label=label)
+        metric = fluid.metrics.ChunkEvaluator()
+        for data in train_reader():
+            loss, preds, labels = exe.run(fetch_list=[cost, preds, labels])
+            metric.update(num_infer_chunks, num_label_chunks, num_correct_chunks)
+            numpy_precision, numpy_recall, numpy_f1 = metric.eval()
+    
+.. py:method:: update(num_infer_chunks, num_label_chunks, num_correct_chunks)
+
+基于layers.chunk_eval()输出更新状态（state)输出
+
+参数:
+    - **num_infer_chunks** (int|numpy.array): 给定minibatch的Interface块数。
+    - **num_label_chunks** (int|numpy.array): 给定minibatch的Label块数。
+    - **num_correct_chunks** （int|numpy.array）: 给定minibatch的Interface和Label的块数
+
+
+
+英文版API文档: :ref:`api_fluid_metrics_ChunkEvaluator` 
+
+.. _cn_api_fluid_metrics_CompositeMetric:
+
+CompositeMetric
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.metrics.CompositeMetric(name=None)
+
+在一个实例中组合多个指标。例如，将F1、准确率、召回率合并为一个指标。
+
+**代码示例**
+
+.. code-block:: python
+
+        labels = fluid.layers.data(name="data", shape=[1], dtype="int32")
+        data = fluid.layers.data(name="data", shape=[32, 32], dtype="int32")
+        pred = fluid.layers.fc(input=data, size=1000, act="tanh")
+        comp = fluid.metrics.CompositeMetric()
+        acc = fluid.metrics.Precision()
+        recall = fluid.metrics.Recall()
+        comp.add_metric(acc)
+        comp.add_metric(recall)
+        for pass in range(PASSES):
+        comp.reset()
+        for data in train_reader():
+            loss, preds, labels = exe.run(fetch_list=[cost, preds, labels])
+        comp.update(preds=preds, labels=labels)
+        numpy_acc, numpy_recall = comp.eval()
+
+
+.. py:method:: add_metric(metric)
+
+向CompositeMetric添加一个度量指标
+
+参数:
+    - **metric** –  MetricBase的一个实例。
+
+
+
+.. py:method:: update(preds, labels)
+
+更新序列中的每个指标。
+
+参数:
+    - **preds**  (numpy.array) - 当前mini batch的预测
+    - **labels**  (numpy.array) - 当前minibatch的label，如果标签是one-hot或soft-laebl 编码，应该自定义相应的更新规则。
+
+.. py:method:: eval()
+
+按顺序评估每个指标。
+
+
+返回：Python中的度量值列表。
+
+返回类型：list（float | numpy.array）
+
+
+
+
+英文版API文档: :ref:`api_fluid_metrics_CompositeMetric` 
+
+.. _cn_api_fluid_metrics_DetectionMAP:
+
+DetectionMAP
+>>>>>>>>>>>>
+
+.. py:class:: class paddle.fluid.metrics.DetectionMAP(name=None)
+
+计算 detection 平均精度（mAP）。 mAP是衡量object detectors精度的指标，比如 Faster R-CNN,SSD等。它不同于召回率，它是最大精度的平均值。 请从以下文章中获取更多信息：
+
+https://sanchom.wordpress.com/tag/average-precision/
+
+https://arxiv.org/abs/1512.02325
+
+通常步骤如下：
+
+1. 根据detectors中的输入和label，计算  true positive 和 false positive
+2. 计算map，支持 ‘11 point’ and ‘integral’
+    
+
+**代码示例**
+
+.. code-block:: python
+
+        pred = fluid.layers.fc(input=data, size=1000, act="tanh")
+        batch_map = layers.detection_map(
+            input,
+            label,
+            class_num,
+            background_label,
+            overlap_threshold=overlap_threshold,
+            evaluate_difficult=evaluate_difficult,
+            ap_version=ap_version)
+        
+        metric = fluid.metrics.DetectionMAP()
+        for data in train_reader():
+            loss, preds, labels = exe.run(fetch_list=[cost, batch_map])
+            batch_size = data[0]
+            metric.update(value=batch_map, weight=batch_size)
+            numpy_map = metric.eval()
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_metrics_DetectionMAP` 
+
+.. _cn_api_fluid_metrics_EditDistance:
+
+EditDistance
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.metrics.EditDistance(name)
+
+编辑距离是通过计算将一个字符串转换为另一个字符串所需的最小操作数来量化两个字符串(例如单词)之间的差异的一种方法。参考 https://en.wikipedia.org/wiki/Edit_distance
+从mini batch中累计编辑距离和序列号，计算所有batch的平均编辑距离和实例错误。
+
+参数:
+    - **name** - 度量标准名称
+
+**代码示例**
+
+.. code-block:: python
+
+    distances, seq_num = fluid.layers.edit_distance(input, label)
+    distance_evaluator = fluid.metrics.EditDistance()
+    for epoch in PASS_NUM:
+        distance_evaluator.reset()
+        for data in batches:
+            loss = exe.run(fetch_list=[cost] + list(edit_distance_metrics))
+        distance_evaluator.update(distances, seq_num)
+        distance, instance_error = distance_evaluator.eval()
+
+在上面的例子中：'distance'是一个pass中的编辑距离的平均值。 'instance_error'是一个pass中的实例的错误率。
+
+
+
+英文版API文档: :ref:`api_fluid_metrics_EditDistance` 
+
+.. _cn_api_fluid_metrics_Precision:
+
+Precision
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.metrics.Precision(name=None)
+
+Precision(也称为 positive predictive value,正预测值)是被预测为正样例中实际为正的比例。https://en.wikipedia.org/wiki/Evaluation_of_binary_classifiers
+注:二分类中，Precision与Accuracy不同,
+
+.. math::
+    Accuracy  & = \frac{true \quad positive}{total \quad instances(所有样例)}  \\\\
+    Precision & = \frac{true \quad positive}{all \quad positive \quad instances(所有正样例)}
+
+
+**代码示例**
+
+.. code-block:: python
+
+    metric = fluid.metrics.Precision() 
+    
+    for pass in range(PASSES):
+        metric.reset() 
+        for data in train_reader():
+        loss, preds, labels = exe.run(fetch_list=[cost, preds, labels])
+         metric.update(preds=preds, labels=labels) 
+        numpy_precision = metric.eval()
+
+
+
+英文版API文档: :ref:`api_fluid_metrics_Precision` 
+
+.. _cn_api_fluid_metrics_Recall:
+
+Recall
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.metrics.Recall(name=None)
+
+召回率（也称为敏感度）是度量有多个正例被分为正例
+
+https://en.wikipedia.org/wiki/Precision_and_recall
+
+**代码示例**
+
+.. code-block:: python
+
+        metric = fluid.metrics.Recall() 
+        
+        for pass in range(PASSES):
+            metric.reset() 
+            for data in train_reader():
+                loss, preds, labels = exe.run(fetch_list=[cost, preds, labels])
+                metric.update(preds=preds, labels=labels) 
+                numpy_recall = metric.eval()
+
+
+
+
+英文版API文档: :ref:`api_fluid_metrics_Recall` 
+

doc/fluid/api_cn/net_cn.rst

+
+#################
+ fluid.nets
+#################
+
+
+
+.. _cn_api_fluid_nets_glu:
+
+glu
+>>>>
+.. py:function:: paddle.fluid.nets.glu(input, dim=-1)
+T
+he Gated Linear Units(GLU)由切分（split），sigmoid激活函数和按元素相乘组成。沿着给定维将input拆分成两个大小相同的部分，a和b，计算如下：
+
+.. math::
+
+    GLU(a,b) = a\bigotimes \sigma (b)
+
+参考论文: `Language Modeling with Gated Convolutional Networks <https://arxiv.org/pdf/1612.08083.pdf>`_
+
+参数：
+    - **input** (Variable) - 输入变量，张量或者LoDTensor
+    - **dim** (int) - 拆分的维度。如果 :math:`dim<0`，拆分的维为 :math:`rank(input)+dim`。默认为-1
+
+返回：变量 —— 变量的大小为输入的一半
+
+返回类型：变量（Variable）
+
+**代码示例：**
+
+.. code-block:: python
+
+    data = fluid.layers.data(name="words", shape=[3, 6, 9], dtype="float32")
+    output = fluid.nets.glu(input=data, dim=1)  # shape of output: [3, 3, 9]
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_nets_glu` 
+
+.. _cn_api_fluid_nets_img_conv_group:
+
+img_conv_group
+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.nets.img_conv_group(input, conv_num_filter, pool_size, conv_padding=1, conv_filter_size=3, conv_act=None, param_attr=None, conv_with_batchnorm=False, conv_batchnorm_drop_rate=0.0, pool_stride=1, pool_type='max', use_cudnn=True)
+
+Image Convolution Group由Convolution2d，BatchNorm，DropOut和Pool2d组成。根据输入参数，img_conv_group将使用Convolution2d，BatchNorm，DropOut对Input进行连续计算，并将最后一个结果传递给Pool2d。
+
+参数：
+       - **input** （Variable） - 具有[N，C，H，W]格式的输入图像。
+       - **conv_num_filter** （list | tuple） - 表示该组的过滤器数。
+       - **pool_size** （int | list | tuple） -  ``Pool2d Layer`` 池的大小。如果pool_size是列表或元组，则它必须包含两个整数（pool_size_H，pool_size_W）。否则，pool_size_H = pool_size_W = pool_size。
+       - **conv_padding** （int | list | tuple） - Conv2d Layer的 ``padding`` 大小。如果 ``padding`` 是列表或元组，则其长度必须等于 ``conv_num_filter`` 的长度。否则，所有Conv2d图层的 ``conv_padding`` 都是相同的。默认1。
+       - **conv_filter_size** （int | list | tuple） - 过滤器大小。如果filter_size是列表或元组，则其长度必须等于 ``conv_num_filter`` 的长度。否则，所有Conv2d图层的 ``conv_filter_size`` 都是相同的。默认3。
+       - **conv_act** （str） -  ``Conv2d Layer`` 的激活类型， ``BatchNorm`` 后面没有。默认值：无。
+       - **param_attr** （ParamAttr） - Conv2d层的参数。默认值：无
+       - **conv_with_batchnorm** （bool | list） - 表示在 ``Conv2d Layer`` 之后是否使用 ``BatchNorm`` 。如果 ``conv_with_batchnorm`` 是一个列表，则其长度必须等于 ``conv_num_filter`` 的长度。否则， ``conv_with_batchnorm`` 指示是否所有Conv2d层都遵循 ``BatchNorm``。默认为False。
+       - **conv_batchnorm_drop_rate** （float | list） - 表示 ``BatchNorm`` 之后的 ``Dropout Layer`` 的 ``rop_rate`` 。如果 ``conv_batchnorm_drop_rate`` 是一个列表，则其长度必须等于 ``conv_num_filter`` 的长度。否则，所有 ``Dropout Layers`` 的 ``drop_rate`` 都是   ``conv_batchnorm_drop_rate`` 。默认值为0.0。
+       - **pool_stride** （int | list | tuple） -  ``Pool2d`` 层的汇集步幅。如果 ``pool_stride`` 是列表或元组，则它必须包含两个整数（pooling_stride_H，pooling_stride_W）。否则，pooling_stride_H = pooling_stride_W = pool_stride。默认1。
+       - **pool_type** （str） - 池化类型可以是最大池化的 ``max`` 和平均池化的 ``avg`` 。默认max。
+       - **use_cudnn** （bool） - 是否使用cudnn内核，仅在安装cudnn库时才有效。默认值：True
+       
+返回：  使用Convolution2d进行串行计算后的最终结果，BatchNorm，DropOut和Pool2d。
+
+返回类型：  变量（Variable）。
+
+**代码示例**
+
+..  code-block:: python
+
+          img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
+          conv_pool = fluid.nets.img_conv_group(input=img,
+                                                num_channels=3,
+                                                conv_padding=1,
+                                                conv_num_filter=[3, 3],
+                                                conv_filter_size=3,
+                                                conv_act="relu",
+                                                pool_size=2,
+                                                pool_stride=2)
+
+
+
+英文版API文档: :ref:`api_fluid_nets_img_conv_group` 
+
+.. _cn_api_fluid_nets_scaled_dot_product_attention:
+
+scaled_dot_product_attention
+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.nets.scaled_dot_product_attention(queries, keys, values, num_heads=1, dropout_rate=0.0)
+
+点乘attention运算。
+
+attention运算机制可以被视为将查询和一组键值对映射到输出。 将输出计算为值的加权和，其中分配给每个值的权重由查询的兼容性函数（此处的点积）与对应的密钥计算。
+
+可以通过（batch）矩阵乘法实现点积attention运算，如下所示：
+
+.. math::
+      Attention(Q, K, V)= softmax(QK^\mathrm{T})V
+
+请参阅 `Attention Is All You Need <https://arxiv.org/pdf/1706.03762.pdf>`_ 
+
+参数：
+         - **queries** （Variable） - 输入变量，应为3-D Tensor。
+         - **keys** （Variable） - 输入变量，应为3-D Tensor。
+         - **values** （Variable） - 输入变量，应为3-D Tensor。
+         - **num_heads** （int） - 计算缩放点积attention运算的head数。默认值：1。
+         - **dropout_rate** （float） - 降低attention的dropout率。默认值：0.0。
+
+返回：   通过multi-head来缩放点积attention运算的三维张量。
+
+返回类型：  变量（Variable）。
+
+抛出异常:    
+    - ``ValueError`` - 如果输入查询键，值不是3-D Tensor会报错。
+
+.. note::
+    当num_heads> 1时，分别学习三个线性投影，以将输入查询，键和值映射到查询'，键'和值'。 查询'，键'和值'与查询，键和值具有相同的形状。
+    当num_heads == 1时，scaled_dot_product_attention没有可学习的参数。
+
+**代码示例**
+
+..  code-block:: python
+
+          queries = fluid.layers.data(name="queries",
+                                      shape=[3, 5, 9],
+                                      dtype="float32",
+                                      append_batch_size=False)
+          queries.stop_gradient = False
+          keys = fluid.layers.data(name="keys",
+                                   shape=[3, 6, 9],
+                                   dtype="float32",
+                                   append_batch_size=False)
+          keys.stop_gradient = False
+          values = fluid.layers.data(name="values",
+                                     shape=[3, 6, 10],
+                                     dtype="float32",
+                                     append_batch_size=False)
+          values.stop_gradient = False
+          contexts = fluid.nets.scaled_dot_product_attention(queries, keys, values)
+          contexts.shape  # [3, 5, 10]
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_nets_scaled_dot_product_attention` 
+
+.. _cn_api_fluid_nets_sequence_conv_pool:
+
+sequence_conv_pool
+>>>>>>>>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.nets.sequence_conv_pool(input, num_filters, filter_size, param_attr=None, act='sigmoid', pool_type='max')
+
+sequence_conv_pool由序列卷积和池化组成
+
+参数：
+    - **input** (Variable) - sequence_conv的输入，支持变量时间长度输入序列。当前输入为shape为（T，N）的矩阵，T是mini-batch中的总时间步数，N是input_hidden_size
+    - **num_filters** （int）- 滤波器数
+    - **filter_size** （int）- 滤波器大小
+    - **param_attr** （ParamAttr) - Sequence_conv层的参数。默认：None
+    - **act** （str） - Sequence_conv层的激活函数类型。默认：sigmoid
+    - **pool_type** （str）- 池化类型。可以是max-pooling的max，average-pooling的average，sum-pooling的sum，sqrt-pooling的sqrt。默认max
+
+返回：序列卷积（Sequence Convolution）和池化（Pooling）的结果
+
+
+返回类型：变量（Variable）
+
+**代码示例**：
+
+.. code-block:: python
+
+    input_dim = len(word_dict)
+    emb_dim = 128
+    hid_dim = 512
+    data = fluid.layers.data( ame="words", shape=[1], dtype="int64", lod_level=1)
+    emb = fluid.layers.embedding(input=data, size=[input_dim, emb_dim], is_sparse=True)
+    seq_conv = fluid.nets.sequence_conv_pool(input=emb,
+                                         num_filters=hid_dim,
+                                         filter_size=3,
+                                         act="tanh",
+                                         pool_type="sqrt")
+
+
+
+
+英文版API文档: :ref:`api_fluid_nets_sequence_conv_pool` 
+
+.. _cn_api_fluid_nets_simple_img_conv_pool:
+
+simple_img_conv_pool
+>>>>>>>>>>>>>>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.nets.simple_img_conv_pool(input, num_filters, filter_size, pool_size, pool_stride, pool_padding=0, pool_type='max', global_pooling=False, conv_stride=1, conv_padding=0, conv_dilation=1, conv_groups=1, param_attr=None, bias_attr=None, act=None, use_cudnn=True)
+
+ ``simple_img_conv_pool`` 由一个Convolution2d和一个Pool2d组成。
+
+参数：
+    - **input** （Variable） - 输入图像的格式为[N，C，H，W]。
+    - **num_filters** （int） - ``filter`` 的数量。它与输出的通道相同。
+    - **filter_size** （int | list | tuple） - 过滤器大小。如果 ``filter_size`` 是列表或元组，则它必须包含两个整数（filter_size_H，filter_size_W）。否则，filter_size_H = filter_size_W = filter_size。
+    - **pool_size** （int | list | tuple） - Pool2d池化层大小。如果pool_size是列表或元组，则它必须包含两个整数（pool_size_H，pool_size_W）。否则，pool_size_H = pool_size_W = pool_size。
+    - **pool_stride** （int | list | tuple） - Pool2d池化层步长。如果pool_stride是列表或元组，则它必须包含两个整数（pooling_stride_H，pooling_stride_W）。否则，pooling_stride_H = pooling_stride_W = pool_stride。
+    - **pool_padding** （int | list | tuple） - Pool2d池化层的padding。如果pool_padding是列表或元组，则它必须包含两个整数（pool_padding_H，pool_padding_W）。否则，pool_padding_H = pool_padding_W = pool_padding。默认值为0。
+    - **pool_type** （str） - 池化类型可以是 ``max-pooling`` 的 ``max`` 和平均池的 ``avg`` 。默认 ``max`` 。
+    - **global_pooling** （bool）- 是否使用全局池。如果global_pooling = true，则忽略pool_size和pool_padding。默认为False
+    - **conv_stride** （int | list | tuple） - conv2d Layer的步长。如果stride是列表或元组，则它必须包含两个整数，（conv_stride_H，conv_stride_W）。否则，conv_stride_H = conv_stride_W = conv_stride。默认值：conv_stride = 1。
+    - **conv_padding** （int | list | tuple） - conv2d Layer的padding大小。如果padding是列表或元组，则它必须包含两个整数（conv_padding_H，conv_padding_W）。否则，conv_padding_H = conv_padding_W = conv_padding。默认值：conv_padding = 0。
+    - **conv_dilation** （int | list | tuple） - conv2d Layer的dilation大小。如果dilation是列表或元组，则它必须包含两个整数（conv_dilation_H，conv_dilation_W）。否则，conv_dilation_H = conv_dilation_W = conv_dilation。默认值：conv_dilation = 1。
+    - **conv_groups** （int） - conv2d Layer的组数。根据Alex Krizhevsky的Deep CNN论文中的分组卷积：当group = 2时，前半部分滤波器仅连接到输入通道的前半部分，而后半部分滤波器仅连接到后半部分输入通道。默认值：groups = 1。
+    - **param_attr** （ParamAttr | None） - 可学习参数的参数属性或conv2d权重。如果将其设置为None或ParamAttr的一个属性，则conv2d将创建ParamAttr作为param_attr。如果未设置param_attr的初始化，则使用 :math:`Normal（0.0，std）` 初始化参数，并且 ``std`` 为 :math:`(\frac{2.0 }{filter\_elem\_num})^{0.5}` 。默认值:None
+    - **bias_attr** （ParamAttr | bool | None） - conv2d的bias参数属性。如果设置为False，则不会向输出单元添加bias。如果将其设置为None或ParamAttr的一个属性，则conv2d将创建ParamAttr作为bias_attr。如果未设置bias_attr的初始化程序，则将偏差初始化为零。默认值：None
+    - **act** （str） - conv2d的激活类型，如果设置为None，则不附加激活。默认值：无。
+    - **use_cudnn** （bool） - 是否使用cudnn内核，仅在安装cudnn库时才有效。默认值：True。
+
+返回： Convolution2d和Pool2d之后输入的结果。
+
+返回类型：  变量（Variable）
+
+**示例代码**
+
+..  code-block:: python
+
+    img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
+    conv_pool = fluid.nets.simple_img_conv_pool(input=img,
+                                            filter_size=5,
+                                            num_filters=20,
+                                            pool_size=2,
+                                            pool_stride=2,
+                                            act="relu")
+
+
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_nets_simple_img_conv_pool` 
+

doc/fluid/api_cn/optimizer_cn.rst

+
+#################
+ fluid.optimizer
+#################
+
+
+
+.. _cn_api_fluid_optimizer_AdagradOptimizer:
+
+AdagradOptimizer
+>>>>>>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.optimizer.AdagradOptimizer(learning_rate, epsilon=1e-06, regularization=None, name=None)
+
+**Adaptive Gradient Algorithm(Adagrad)**
+
+更新如下：
+
+.. math::
+
+	moment\_out &= moment + grad * grad\\param\_out 
+	&= param - \frac{learning\_rate * grad}{\sqrt{moment\_out} + \epsilon}
+
+原始论文（http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf）没有epsilon属性。在我们的实现中也作了如下更新：
+http://cs231n.github.io/neural-networks-3/#ada 用于维持数值稳定性，避免除数为0的错误发生。
+
+参数：
+    - **learning_rate** (float|Variable)-学习率，用于更新参数。作为数据参数，可以是一个浮点类型值或者有一个浮点类型值的变量
+    - **epsilon** (float) - 维持数值稳定性的短浮点型值
+    - **regularization** - 规则化函数，例如fluid.regularizer.L2DecayRegularizer
+    - **name** - 名称前缀（可选）
+
+**代码示例**：
+
+.. code-block:: python:
+
+    optimizer = fluid.optimizer.Adagrad(learning_rate=0.2)
+    optimizer.minimize(cost)
+
+AdamOptimizer
+>>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.optimizer. AdamOptimizer(learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-08, regularization=None, name=None)
+
+该函数实现了自适应矩估计优化器，介绍自Adam论文:https://arxiv.org/abs/1412.6980的第二节。Adam是一阶基于梯度下降的算法，基于自适应低阶矩估计。
+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}
+
+参数: 
+    - **learning_rate** (float|Variable)-学习率，用于更新参数。作为数据参数，可以是一个浮点类型值或有一个浮点类型值的变量
+    - **beta1** (float)-一阶矩估计的指数衰减率
+    - **beta2** (float)-二阶矩估计的指数衰减率
+    - **epsilon** (float)-保持数值稳定性的短浮点类型值
+    - **regularization** - 规则化函数，例如''fluid.regularizer.L2DecayRegularizer
+    - **name** - 可选名称前缀
+
+**代码示例**：
+
+.. code-block:: python:
+
+    optimizer = fluid.optimizer.Adam(learning_rate=0.2)
+    optimizer.minimize(cost)
+
+.. note::
+
+	目前，AdamaxOptimizer不支持稀疏参数优化
+
+
+
+英文版API文档: :ref:`api_fluid_optimizer_AdagradOptimizer` 
+
+.. _cn_api_fluid_optimizer_AdamaxOptimizer:
+
+AdamaxOptimizer
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.optimizer.AdamaxOptimizer(learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-08, regularization=None, name=None)
+
+我们参考Adam论文第7节中的Adamax优化: https://arxiv.org/abs/1412.6980 ， Adamax是基于无穷大范数的Adam算法的一个变种。
+
+
+Adamax 更新规则:
+
+.. math::
+    \\t = t + 1
+.. math::
+    moment\_out=\beta_1∗moment+(1−\beta_1)∗grad
+.. math::
+    inf\_norm\_out=\max{(\beta_2∗inf\_norm+ϵ, \left|grad\right|)}
+.. math::
+    learning\_rate=\frac{learning\_rate}{1-\beta_1^t}
+.. math::
+    param\_out=param−learning\_rate*\frac{moment\_out}{inf\_norm\_out}\\
+
+
+论文中没有 ``epsilon`` 参数。但是，为了数值稳定性， 防止除0错误， 增加了这个参数
+
+参数:
+  - **learning_rate**  (float|Variable) - 用于更新参数的学习率。可以是浮点值，也可以是具有一个浮点值作为数据元素的变量。
+  - **beta1** (float) - 第1阶段估计的指数衰减率
+  - **beta2** (float) - 第2阶段估计的指数衰减率。
+  - **epsilon** (float) -非常小的浮点值，为了数值的稳定性质
+  - **regularization** - 正则化器，例如 ``fluid.regularizer.L2DecayRegularizer`` 
+  - **name** - 可选的名称前缀。
+
+**代码示例**
+ 
+.. code-block:: python
+        
+     optimizer = fluid.optimizer.Adamax(learning_rate=0.2)
+     optimizer.minimize(cost)
+
+.. note::
+    目前 ``AdamaxOptimizer`` 不支持  sparse gradient
+
+  
+
+
+英文版API文档: :ref:`api_fluid_optimizer_AdamaxOptimizer` 
+
+.. _cn_api_fluid_optimizer_DecayedAdagradOptimizer:
+
+DecayedAdagradOptimizer
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.optimizer.DecayedAdagradOptimizer(learning_rate, decay=0.95, epsilon=1e-06, regularization=None, name=None)
+
+Decayed Adagrad Optimizer
+
+`原始论文 <http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf>`_
+
+原始论文： `http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf <http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf>`_  中没有 ``epsilon`` 参数。但是，为了数值稳定性， 防止除0错误， 增加了这个参数
+
+.. math::
+    moment\_out = decay*moment+(1-decay)*grad*grad
+.. math::
+    param\_out=param-\frac{learning\_rate*grad}{\sqrt{moment\_out+\epsilon }}
+    
+参数:
+  - **learning_rate** (float|Variable) - 用于更新参数的学习率。可以是浮点值，也可以是具有一个浮点值作为数据元素的变量。
+  - **decay** (float) – 衰减率
+  - **regularization** - 一个正则化器，例如 ``fluid.regularizer.L2DecayRegularizer`` 
+  - **epsilon** (float) - 非常小的浮点值，为了数值稳定性
+  - **name** — 可选的名称前缀。
+
+  
+**代码示例**
+ 
+.. code-block:: python
+        
+  optimizer = fluid.optimizer.DecayedAdagrad(learning_rate=0.2)
+  optimizer.minimize(cost)
+
+.. note::
+  ``DecayedAdagradOptimizer`` 不支持 sparse gradient
+
+
+
+
+英文版API文档: :ref:`api_fluid_optimizer_DecayedAdagradOptimizer` 
+
+.. _cn_api_fluid_optimizer_FtrlOptimizer:
+
+FtrlOptimizer
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.optimizer.FtrlOptimizer(learning_rate, l1=0.0, l2=0.0, lr_power=-0.5,regularization=None, name=None)
+ 
+FTRL (Follow The Regularized Leader) Optimizer.
+
+TFRTL 原始论文: ( `https://www.eecs.tufts.edu/~dsculley/papers/ad-click-prediction.pdf <https://www.eecs.tufts.edu/~dsculley/papers/ad-click-prediction.pdf>`_)
+
+
+.. math::
+           &\qquad new\_accum=squared\_accum+grad^2\\\\
+           &\qquad if(lr\_power==−0.5):\\
+           &\qquad \qquad linear\_accum+=grad-\frac{\sqrt{new\_accum}-\sqrt{squared\_accum}}{learning\_rate*param}\\
+           &\qquad else:\\
+           &\qquad \qquad linear\_accum+=grad-\frac{new\_accum^{-lr\_power}-accum^{-lr\_power}}{learning\_rate*param}\\\\
+           &\qquad x=l1*sign(linear\_accum)−linear\_accum\\\\
+           &\qquad if(lr\_power==−0.5):\\
+           &\qquad \qquad y=\frac{\sqrt{new\_accum}}{learning\_rate}+(2*l2)\\
+           &\qquad \qquad pre\_shrink=\frac{x}{y}\\
+           &\qquad \qquad param=(abs(linear\_accum)>l1).select(pre\_shrink,0.0)\\
+           &\qquad else:\\
+           &\qquad \qquad y=\frac{new\_accum^{-lr\_power}}{learning\_rate}+(2*l2)\\
+           &\qquad \qquad pre\_shrink=\frac{x}{y}\\
+           &\qquad \qquad param=(abs(linear\_accum)>l1).select(pre\_shrink,0.0)\\\\
+           &\qquad squared\_accum+=grad^2
+
+
+参数:
+  - **learning_rate** (float|Variable)-全局学习率。
+  - **l1** (float)
+  - **l2** (float)
+  - **lr_power** (float)
+  - **regularization** - 正则化器，例如 ``fluid.regularizer.L2DecayRegularizer`` 
+  - **name** — 可选的名称前缀
+
+抛出异常：
+  - ``ValueError`` - 如果 ``learning_rate`` , ``rho`` ,  ``epsilon`` , ``momentum``  为 None.
+
+**代码示例**
+
+.. code-block:: python
+        
+   optimizer = fluid.optimizer.Ftrl(0.0001)
+   _, params_grads = optimizer.minimize(cost)
+
+.. note::
+目前, FtrlOptimizer 不支持 sparse gradient
+
+
+
+
+英文版API文档: :ref:`api_fluid_optimizer_FtrlOptimizer` 
+
+.. _cn_api_fluid_optimizer_LarsMomentum:
+
+LarsMomentum
+>>>>>>>>>>>>>>
+
+:code:`fluid.optimizer.LarsMomentumOptimizer` 的别名
+
+
+
+
+英文版API文档: :ref:`api_fluid_optimizer_LarsMomentum` 
+
+.. _cn_api_fluid_optimizer_LarsMomentumOptimizer:
+
+LarsMomentumOptimizer
+>>>>>>>>>>>>>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.optimizer.LarsMomentumOptimizer(learning_rate, momentum, lars_coeff=0.001, lars_weight_decay=0.0005, regularization=None, name=None)
+
+LARS支持的Momentum优化器
+
+公式作如下更新：
+
+.. math::
+
+  & local\_learning\_rate = learning\_rate * lars\_coeff * \
+  \frac{||param||}{||gradient|| + lars\_weight\_decay * ||param||}\\
+  & velocity = mu * velocity + local\_learning\_rate * (gradient + lars\_weight\_decay * param)\\
+  & param = param - velocity
+
+参数：
+  - **learning_rate** (float|Variable) - 学习率，用于参数更新。作为数据参数，可以是浮点型值或含有一个浮点型值的变量
+  - **momentum** (float) - 动量因子
+  - **lars_coeff** (float) - 定义LARS本地学习率的权重
+  - **lars_weight_decay** (float) - 使用LARS进行衰减的权重衰减系数
+  - **regularization** - 正则化函数，例如 :code:`fluid.regularizer.L2DecayRegularizer`
+  - **name** - 名称前缀，可选
+
+**代码示例：**
+
+.. code-block:: python
+
+    optimizer = fluid.optimizer.LarsMomentum(learning_rate=0.2, momentum=0.1, lars_weight_decay=0.001)
+    optimizer.minimize(cost)
+
+
+
+英文版API文档: :ref:`api_fluid_optimizer_LarsMomentumOptimizer` 
+
+.. _cn_api_fluid_optimizer_ModelAverage:
+
+ModelAverage
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.optimizer.ModelAverage(average_window_rate, min_average_window=10000, max_average_window=10000, regularization=None, name=None)
+
+在滑动窗口中累积参数的平均值。平均结果将保存在临时变量中，通过调用 ``apply()`` 方法可应用于当前模型的参数变量。使用 ``restore()`` 方法恢复当前模型的参数值。
+
+平均窗口的大小由 ``average_window_rate`` ， ``min_average_window`` ， ``max_average_window`` 以及当前更新次数决定。
+
+ 
+参数:
+  - **average_window_rate** – 窗口平均速率
+  - **min_average_window** – 平均窗口大小的最小值
+  - **max_average_window** – 平均窗口大小的最大值
+  - **regularization** – 正则化器，例如 ``fluid.regularizer.L2DecayRegularizer`` 
+  - **name** – 可选的名称前缀
+
+**代码示例**
+
+.. code-block:: python
+        
+  optimizer = fluid.optimizer.Momentum()
+  optimizer.minimize(cost)
+  model_average = fluid.optimizer.ModelAverage(0.15,
+                                          min_average_window=10000,
+                                          max_average_window=20000)
+  for pass_id in range(args.pass_num):
+      for data in train_reader():
+          exe.run(fluid.default_main_program()...)
+
+      with model_average.apply(exe):
+          for data in test_reader():
+              exe.run(inference_program...)
+
+
+.. py:method:: apply(*args, **kwds)
+
+将平均值应用于当前模型的参数。
+
+.. py:method:: restore(executor)
+
+恢复当前模型的参数值
+
+
+
+
+英文版API文档: :ref:`api_fluid_optimizer_ModelAverage` 
+
+.. _cn_api_fluid_optimizer_MomentumOptimizer:
+
+MomentumOptimizer
+>>>>>>>>>>>>>>>>>>
+
+.. py:class::  paddle.fluid.optimizer.MomentumOptimizer(learning_rate, momentum, use_nesterov=False, regularization=None, name=None)
+
+含有速度状态的Simple Momentum 优化器
+
+该优化器含有牛顿动量标志，公式更新如下：
+
+.. math::
+	& velocity = mu * velocity + gradient\\
+	& if (use\_nesterov):\
+	\&\quad   param = param - (gradient + mu * velocity) * learning\_rate\\
+	& else:\\&\quad   param = param - learning\_rate * velocity
+参数：
+    - **learning_rate** (float|Variable) - 学习率，用于参数更新。作为数据参数，可以是浮点型值或含有一个浮点型值的变量
+    - **momentum** (float) - 动量因子
+    - **use_nesterov** (bool) - 赋能牛顿动量
+    - **regularization** - 正则化函数，比如fluid.regularizer.L2DecayRegularizer
+    - **name** - 名称前缀（可选）
+
+**代码示例**：
+
+.. code-block:: python
+
+    optimizer = fluid.optimizer.Momentum(learning_rate=0.2, momentum=0.1)
+    optimizer.minimize(cost)
+
+
+
+英文版API文档: :ref:`api_fluid_optimizer_MomentumOptimizer` 
+
+.. _cn_api_fluid_optimizer_RMSPropOptimizer:
+
+RMSPropOptimizer
+>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.optimizer.RMSPropOptimizer(learning_rate, rho=0.95, epsilon=1e-06, momentum=0.0, centered=False, regularization=None, name=None)
+
+均方根平均传播（RMSProp）法是一种未发表的,自适应学习率的方法。原始slides提出了RMSProp：[http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf]中的第29张slide。等式如下所示：
+
+.. math::
+    r(w, t) & = \rho r(w, t-1) + (1 - \rho)(\nabla Q_{i}(w))^2\\
+    w & = w - \frac{\eta} {\sqrt{r(w,t) + \epsilon}} \nabla Q_{i}(w)
+    
+第一个等式计算每个权重平方梯度的移动平均值，然后将梯度除以 :math:`sqrtv（w，t）` 。
+  
+.. math::
+   r(w, t) & = \rho r(w, t-1) + (1 - \rho)(\nabla Q_{i}(w))^2\\
+   v(w, t) & = \beta v(w, t-1) +\frac{\eta} {\sqrt{r(w,t) +\epsilon}} \nabla Q_{i}(w)\\
+         w & = w - v(w, t)
+
+如果居中为真：
+  
+.. math::
+      r(w, t) & = \rho r(w, t-1) + (1 - \rho)(\nabla Q_{i}(w))^2\\
+      g(w, t) & = \rho g(w, t-1) + (1 -\rho)\nabla Q_{i}(w)\\
+      v(w, t) & = \beta v(w, t-1) + \frac{\eta} {\sqrt{r(w,t) - (g(w, t))^2 +\epsilon}} \nabla Q_{i}(w)\\
+            w & = w - v(w, t)
+      
+其中， :math:`ρ` 是超参数，典型值为0.9,0.95等。 :math:`beta` 是动量术语。  :math:`epsilon` 是一个平滑项，用于避免除零，通常设置在1e-4到1e-8的范围内。
+      
+参数：
+    - **learning_rate** （float） - 全球学习率。
+    - **rho** （float） - rho是等式中的 :math:`rho` ，默认设置为0.95。
+    - **epsilon** （float） - 等式中的epsilon是平滑项，避免被零除，默认设置为1e-6。
+    - **momentum** （float） - 方程中的β是动量项，默认设置为0.0。
+    - **centered** （bool） - 如果为True，则通过梯度估计方差对梯度进行归一化；如果false，则由未centered的第二个moment归一化。将此设置为True有助于培训，但在计算和内存方面稍微昂贵一些。默认为False。
+    - **regularization**  - 正则器项，如 ``fluid.regularizer.L2DecayRegularizer`` 。
+    - **name**  - 可选的名称前缀。
+    
+抛出异常:
+    - ``ValueError`` -如果 ``learning_rate`` ， ``rho`` ， ``epsilon`` ， ``momentum`` 为None。
+
+**示例代码**
+
+..  code-block:: python
+
+        optimizer = fluid.optimizer.RMSProp(0.0001)
+        _, params_grads = optimizer.minimize(cost)
+
+
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_optimizer_RMSPropOptimizer` 
+
+.. _cn_api_fluid_optimizer_SGDOptimizer:
+
+SGDOptimizer
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.optimizer.SGDOptimizer(learning_rate, regularization=None, name=None)
+
+随机梯度下降算法的优化器
+
+.. math::
+            \\param\_out=param-learning\_rate*grad\\
+
+
+参数:
+  - **learning_rate** (float|Variable) - 用于更新参数的学习率。可以是浮点值，也可以是具有一个浮点值作为数据元素的变量。
+  - **regularization** - 一个正则化器，例如 ``fluid.regularizer.L2DecayRegularizer`` 
+  - **name** - 可选的名称前缀。
+  
+  
+**代码示例**
+ 
+.. code-block:: python
+        
+     sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.2)
+     sgd_optimizer.minimize(cost)
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_optimizer_SGDOptimizer` 
+

doc/fluid/api_cn/param_attr_cn.rst

+
+#################
+ fluid.param_attr
+#################
+
+
+
+.. _cn_api_fluid_param_attr_WeightNormParamAttr:
+
+WeightNormParamAttr
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.param_attr.WeightNormParamAttr(dim=None, name=None, initializer=None, learning_rate=1.0, regularizer=None, trainable=True, gradient_clip=None, do_model_average=False)
+  
+权重归一化。权范数是神经网络中权向量的再参数化，它将权向量的长度与其方向解耦。该paper对权值归一化的实现进行了讨论： `Weight Normalization: A Simple Reparameterization to Accelerate Training of Deep Neural Networks <https://arxiv.org/pdf/1602.07868.pdf>`_ 
+
+参数:
+  - **dim**  (list) – 参数维度. Default None.
+  - **name** (str) – 参数名称. Default None.
+  - **initializer**  (Initializer) – 初始化参数的方法. Default None.
+  - **learning_rate**  (float) – 参数的学习率. 优化的参数学习率为 :math:`global\_lr*parameter\_lr*scheduler\_factor` . Default 1.0
+  - **regularizer**  (WeightDecayRegularizer) – 正则化因子. Default None.
+  - **trainable**  (bool) – 参数是否可训练. Default True.
+  - **gradient_clip**  (BaseGradientClipAttr) – 修剪这个参数的梯度的方法. Default None.
+  - **do_model_average**  (bool) – 这个参数是否应该做模型平均. Default False.
+
+
+**代码示例**
+
+
+..  code-block:: python
+  
+    data = fluid.layers.data(name="data", shape=[3, 32, 32], dtype="float32")
+    fc = fluid.layers.fc(input=data,
+                          size=1000,
+                          param_attr=WeightNormParamAttr(
+                          dim=None,
+                          name='weight_norm_param'))
+                          
+             
+
+
+
+英文版API文档: :ref:`api_fluid_param_attr_WeightNormParamAttr` 
+
+.. _cn_api_fluid_ParamAttr:
+
+ 
+ParamAttr
+>>>>>>>>>>>>>>>>>>>>>>>>>
+
+
+.. py:class:: paddle.fluid.param_attr.ParamAttr(name=None, initializer=None, learning_rate=1.0, regularizer=None, trainable=True, gradient_clip=None, do_model_average=False)
+
+该类代表了参数的各种属性。 为了使神经网络训练过程更加流畅，用户可以根据需要调整参数属性。比如learning rate（学习率）, regularization（正则化）, trainable（可训练性）, do_model_average(平均化模型)和参数初始化方法.
+
+参数:	
+    - **name** (str) – 参数名。默认为None。
+    - **initializer** (Initializer) – 初始化该参数的方法。 默认为None
+    - **learning_rate** (float) – 参数的学习率。计算方法为 global_lr*parameter_lr∗scheduler_factor。 默认为1.0
+    - **regularizer** (WeightDecayRegularizer) – 正则因子. 默认为None
+    - **trainable** (bool) – 该参数是否可训练。默认为True
+    - **gradient_clip** (BaseGradientClipAttr) – 减少参数梯度的方法。默认为None
+    - **do_model_average** (bool) – 该参数是否服从模型平均值。默认为False
+    
+**代码示例**
+
+..  code-block:: python
+
+   w_param_attrs = fluid.ParamAttr(name="fc_weight",
+                                   learning_rate=0.5,
+                                   regularizer=fluid.L2Decay(1.0),
+                                   trainable=True)
+   y_predict = fluid.layers.fc(input=x, size=10, param_attr=w_param_attrs)
+
+
+
+英文版API文档: :ref:`api_fluid_ParamAttr` 
+

doc/fluid/api_cn/profiler_cn.rst

+
+#################
+ fluid.profiler
+#################
+
+
+
+.. _cn_api_fluid_profiler_cuda_profiler:
+
+cuda_profiler
+>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.profiler.cuda_profiler(*args, **kwds)
+
+
+CUDA分析器。通过CUDA运行时应用程序编程接口对CUDA程序进行性能分析。分析结果将以键-值对格式或逗号分隔的格式写入output_file。用户可以通过output_mode参数设置输出模式，并通过配置参数设置计数器/选项。默认配置是[' gpustarttimestamp '， ' gpustarttimestamp '， ' gridsize3d '， ' threadblocksize '， ' streamid '， ' enableonstart 0 '， ' conckerneltrace ']。然后，用户可使用 `NVIDIA Visual Profiler <https://developer.nvidia.com/nvidia-visualprofiler>`_ 工具来加载这个输出文件以可视化结果。
+
+
+参数:
+  - **output_file** (string) – 输出文件名称, 输出结果将会写入该文件
+  - **output_mode** (string) – 输出格式是有 key-value 键值对 和 逗号的分割的格式。格式应该是' kvp '或' csv '
+  - **config** (list of string) – 参考“Compute Command Line Profiler User Guide” 查阅 profiler options 和 counter相关信息
+
+抛出异常:
+    - ``ValueError`` -  如果 ``output_mode`` 不在 [‘kvp’, ‘csv’] 中
+
+
+**代码示例**
+
+
+..  code-block:: python
+  
+    import paddle.fluid as fluid
+    import paddle.fluid.profiler as profiler
+
+    epoc = 8
+    dshape = [4, 3, 28, 28]
+    data = fluid.layers.data(name='data', shape=[3, 28, 28], dtype='float32')
+    conv = fluid.layers.conv2d(data, 20, 3, stride=[1, 1], padding=[1, 1])
+
+    place = fluid.CUDAPlace(0)
+    exe = fluid.Executor(place)
+    exe.run(fluid.default_startup_program())
+
+    output_file = 'cuda_profiler.txt'
+    with profiler.cuda_profiler(output_file, 'csv') as nvprof:
+        for i in range(epoc):
+            input = np.random.random(dshape).astype('float32')
+            exe.run(fluid.default_main_program(), feed={'data': input})
+            
+    # 之后可以使用 NVIDIA Visual Profile 可视化结果
+
+
+
+
+
+英文版API文档: :ref:`api_fluid_profiler_cuda_profiler` 
+
+.. _cn_api_fluid_profiler_profiler:
+
+profiler
+>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.profiler.profiler(*args, **kwds)
+
+profile interface 。与cuda_profiler不同，此profiler可用于分析CPU和GPU程序。默认情况下，它记录CPU和GPU kernel，如果想分析其他程序，可以参考教程来在c++代码中添加更多代码。
+
+
+如果 state== ' All '，在profile_path 中写入文件 profile proto 。该文件记录执行期间的时间顺序信息。然后用户可以看到这个文件的时间轴，请参考 `https://github.com/PaddlePaddle/Paddle/blob/develop/doc/fluid/howto/optimization/timeline.md <https://github.com/PaddlePaddle/Paddle/blob/develop/doc/fluid/howto/optimization/timeline.md>`_ 
+
+参数:
+  - **state** (string) –  profiling state, 取值为 ‘CPU’ 或 ‘GPU’,  profiler 使用 CPU timer 或GPU timer 进行 profiling. 虽然用户可能在开始时指定了执行位置(CPUPlace/CUDAPlace)，但是为了灵活性，profiler不会使用这个位置。
+  - **sorted_key** (string) – 如果为None，prfile的结果将按照事件的第一次结束时间顺序打印。否则，结果将按标志排序。标志取值为“call”、“total”、“max”、“min” “ave”之一，根据调用着的数量进行排序。total表示按总执行时间排序，max 表示按最大执行时间排序。min 表示按最小执行时间排序。ave表示按平均执行时间排序。
+  - **profile_path** (string) –  如果 state == ‘All’, 结果将写入文件 profile proto.
+  
+抛出异常：
+  - ``ValueError`` – 如果state 取值不在 [‘CPU’, ‘GPU’, ‘All’]中. 如果 sorted_key 取值不在 [‘calls’, ‘total’, ‘max’, ‘min’, ‘ave’]
+  
+**代码示例**
+
+..  code-block:: python
+    
+    import paddle.fluid.profiler as profiler
+
+    with profiler.profiler('All', 'total', '/tmp/profile') as prof:
+        for pass_id in range(pass_num):
+            for batch_id, data in enumerate(train_reader()):
+                exe.run(fluid.default_main_program(),
+                        feed=feeder.feed(data),
+                        fetch_list=[],
+                        use_program_cache=True)
+                # ...
+
+
+
+英文版API文档: :ref:`api_fluid_profiler_profiler` 
+
+.. _cn_api_fluid_profiler_reset_profiler:
+
+reset_profiler
+>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.profiler.reset_profiler()
+
+清除之前的时间记录。此接口不适用于 ``fluid.profiler.cuda_profiler`` ，它只适用于 ``fluid.profiler.start_profiler`` , ``fluid.profiler.stop_profiler`` , ``fluid.profiler.profiler`` 。
+
+**代码示例**
+
+..  code-block:: python
+  
+    import paddle.fluid.profiler as profiler
+    with profiler.profiler(state, 'total', '/tmp/profile'):
+    for iter in range(10):
+        if iter == 2:
+            profiler.reset_profiler()
+        # ...
+
+
+
+
+英文版API文档: :ref:`api_fluid_profiler_reset_profiler` 
+
+.. _cn_api_fluid_profiler_start_profiler:
+
+start_profiler
+>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.profiler.start_profiler(state)
+
+激活使用 profiler， 用户可以使用 ``fluid.profiler.start_profiler`` 和 ``fluid.profiler.stop_profiler`` 插入代码
+不能使用 ``fluid.profiler.profiler`` 
+
+
+如果 state== ' All '，在profile_path 中写入文件 profile proto 。该文件记录执行期间的时间顺序信息。然后用户可以看到这个文件的时间轴，请参考 `https://github.com/PaddlePaddle/Paddle/blob/develop/doc/fluid/howto/optimization/timeline.md <https://github.com/PaddlePaddle/Paddle/blob/develop/doc/fluid/howto/optimization/timeline.md>`_ 
+
+参数:
+  - **state** (string) – profiling state, 取值为 ‘CPU’ 或 ‘GPU’ 或 ‘All’, ‘CPU’ 代表只分析 cpu. ‘GPU’ 代表只分析 GPU . ‘All’ 会产生 timeline.
+
+抛出异常:
+  - ``ValueError`` – 如果state 取值不在 [‘CPU’, ‘GPU’, ‘All’]中
+
+**代码示例**
+
+..  code-block:: python
+    
+    import paddle.fluid.profiler as profiler
+
+    profiler.start_profiler('GPU')
+    for iter in range(10):
+        if iter == 2:
+            profiler.reset_profiler()
+        # except each iteration
+    profiler.stop_profiler('total', '/tmp/profile')
+
+                # ...
+
+
+
+
+英文版API文档: :ref:`api_fluid_profiler_start_profiler` 
+
+.. _cn_api_fluid_profiler_stop_profiler:
+
+stop_profiler
+>>>>>>>>>>>>
+
+.. py:function::paddle.fluid.profiler.stop_profiler(sorted_key=None, profile_path='/tmp/profile')
+
+停止 profiler， 用户可以使用 ``fluid.profiler.start_profiler`` 和 ``fluid.profiler.stop_profiler`` 插入代码
+不能使用 fluid.profiler.profiler`` 
+
+参数:
+  - **sorted_key** (string) – 如果为None，prfile的结果将按照事件的第一次结束时间顺序打印。否则，结果将按标志排序。标志取值为“call”、“total”、“max”、“min” “ave”之一，根据调用着的数量进行排序。total表示按总执行时间排序，max 表示按最大执行时间排序。min 表示按最小执行时间排序。ave表示按平均执行时间排序。
+  - **profile_path** (string) - 如果 state == ‘All’, 结果将写入文件 profile proto.
+  
+
+抛出异常:
+  - ``ValueError`` – 如果state 取值不在 [‘CPU’, ‘GPU’, ‘All’]中
+
+**代码示例**
+
+..  code-block:: python
+    
+    import paddle.fluid.profiler as profiler
+
+    profiler.start_profiler('GPU')
+    for iter in range(10):
+        if iter == 2:
+            profiler.reset_profiler()
+            # except each iteration
+    profiler.stop_profiler('total', '/tmp/profile')
+
+
+
+英文版API文档: :ref:`api_fluid_profiler_stop_profiler` 
+

doc/fluid/api_cn/regularizer_cn.rst

+
+#################
+ fluid.regularizer
+#################
+
+
+
+.. _cn_api_fluid_regularizer_L1DecayRegularizer:
+
+L1DecayRegularizer
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.regularizer.L1DecayRegularizer(regularization_coeff=0.0)
+
+实现 L1 权重衰减正则化。
+
+L1正则将会稀疏化权重矩阵。
+
+
+.. math::
+            \\L1WeightDecay=reg\_coeff∗sign(parameter)\\
+
+参数:
+  - **regularization_coeff** (float) – 正则化系数
+  
+**代码示例**
+
+..  code-block:: python
+    
+    ioptimizer = fluid.optimizer.Adagrad(
+                            learning_rate=1e-4,
+                            regularization=fluid.regularizer.L1DecayRegularizer(
+                             regularization_coeff=0.1))
+    optimizer.minimize(avg_cost)
+    
+  
+  
+
+
+英文版API文档: :ref:`api_fluid_regularizer_L1DecayRegularizer` 
+
+.. _cn_api_fluid_regularizer_L2DecayRegularizer:
+
+L2DecayRegularizer
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.regularizer.L2DecayRegularizer(regularization_coeff=0.0)
+
+实现L2 权重衰减正则化。 
+
+较小的 L2 的有助于防止对训练数据的过度拟合。
+
+.. math::
+            \\L2WeightDecay=reg\_coeff*parameter\\
+
+参数:
+  - **regularization_coeff** (float) – 正则化系数
+  
+**代码示例**
+
+..  code-block:: python
+    
+   optimizer = fluid.optimizer.Adagrad(
+                            learning_rate=1e-4,
+                            regularization=fluid.regularizer.L2DecayRegularizer(
+                            regularization_coeff=0.1))
+    optimizer.minimize(avg_cost)
+
+
+
+英文版API文档: :ref:`api_fluid_regularizer_L2DecayRegularizer` 
+

doc/fluid/api_cn/transpliter_cn.rst

+
+#################
+ fluid.transpiler
+#################
+
+
+
+
+
+
+.. _cn_api_fluid_DistributeTranspiler:
+
+DistributeTranspiler
+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.transpiler.DistributeTranspiler (config=None)
+
+
+该类可以把fluid program转变为分布式数据并行计算程序（distributed data-parallelism programs）,可以有Pserver和NCCL2两种模式。
+当program在Pserver（全称：parameter server）模式下， ``main_program`` (主程序)转为使用一架远程parameter server(即pserver,参数服务器)来进行参数优化，并且优化图会被输入到一个pserver program中。
+在NCCL2模式下，transpiler会在 ``startup_program`` 中附加一个 ``NCCL_ID`` 广播算子（broadcasting operators）来实现在该集群中所有工作结点共享``NCCL_ID`` 。
+调用 ``transpile_nccl2`` 后， 你 **必须** 将 ``trainer_id`` , ``num_trainers`` 参数提供给 ``ParallelExecutor`` 来启动NCCL2分布式模式。 
+
+
+
+
+**代码示例**
+
+..  code-block:: python
+
+	# for pserver mode
+	pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
+	trainer_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
+	current_endpoint = "192.168.0.1:6174"
+	trainer_id = 0
+	trainers = 4
+	role = os.getenv("PADDLE_TRAINING_ROLE")
+
+	t = fluid.DistributeTranspiler()
+	t.transpile(
+     	     trainer_id, pservers=pserver_endpoints, trainers=trainers)
+	if role == "PSERVER":
+     	     pserver_program = t.get_pserver_program(current_endpoint)
+             pserver_startup_program = t.get_startup_program(current_endpoint,
+                                                     pserver_program)
+	elif role == "TRAINER":
+             trainer_program = t.get_trainer_program()
+
+	# for nccl2 mode
+	config = fluid.DistributeTranspilerConfig()
+	config.mode = "nccl2"
+	t = fluid.DistributeTranspiler(config=config)
+	t.transpile(trainer_id, workers=workers, current_endpoint=curr_ep)
+	exe = fluid.ParallelExecutor(
+    	    use_cuda,
+            loss_name=loss_var.name,
+            num_trainers=len(trainers.split(",)),
+            trainer_id=trainer_id
+	)
+
+
+
+.. py:method:: transpile(trainer_id, program=None, pservers='127.0.0.1:6174', trainers=1, sync_mode=True, startup_program=None, current_endpoint='127.0.0.1:6174')
+
+该方法可以运行该transpiler（转译器）。
+
+参数:	
+	- **trainer_id** (int) – 当前Trainer worker的id, 如果有n个Trainer worker, id 取值范围为0 ~ n-1
+	- **program** (Program|None) – 待transpile（转译）的program, 缺省为 ``fluid.default_main_program()`` 
+	- **pservers** (str) – 内容为Pserver列表的字符串，格式为：按逗号区分不同的Pserver，每个Pserver的格式为 *ip地址:端口号* 
+	- **trainers** (int|str) – 在Pserver模式下，该参数指Trainer机的个数；在nccl2模式下，它是一个内容为Trainer终端列表的字符串
+	- **sync_mode** (bool) – 是否做同步训练(synchronous training), 默认为True
+ 	- **startup_program** (Program|None) – 待transpile（转译）的startup_program，默认为 ``fluid.default_main_program()``
+	- **current_endpoint** (str) – 当需要把program转译（transpile）至NCCL2模式下时，需要将当前endpoint（终端）传入该参数。Pserver模式不使用该参数
+
+.. py:method:: get_trainer_program(wait_port=True)
+
+
+该方法可以得到Trainer侧的program。
+
+返回:	Trainer侧的program
+
+返回类型:	Program
+
+
+
+.. py:method:: get_pserver_program(endpoint)
+
+
+该方法可以得到Pserver（参数服务器）侧的程序
+ 
+参数:	
+	- **endpoint** (str) – 当前Pserver终端
+ 
+返回:	当前Pserver需要执行的program
+
+返回类型:	Program
+
+
+.. py:method:: get_pserver_programs(endpoint)
+
+
+该方法可以得到Pserver侧用于分布式训练的 ``main_program`` 和 ``startup_program`` 。
+
+参数:	
+	- **endpoint** (str) – 当前Pserver终端
+
+返回:	(main_program, startup_program), “Program”类型的元组
+
+返回类型:	tuple 
+ 
+ 
+.. py:method:: get_startup_program(endpoint, pserver_program=None, startup_program=None)
+
+
+**该函数已停止使用**
+获取当前Pserver的startup_program，如果有多个被分散到不同blocks的变量，则修改operator的输入变量。
+
+参数:	
+	- **endpoint** (str) – 当前Pserver终端
+	- **pserver_program** (Program) – 已停止使用。 先调用get_pserver_program
+ 	- **startup_program** (Program) – 已停止使用。应在初始化时传入startup_program
+
+返回:	Pserver侧的startup_program
+
+返回类型:	Program
+
+
+
+英文版API文档: :ref:`api_fluid_DistributeTranspiler` 
+
+.. _cn_api_fluid_transpiler_DistributeTranspilerConfig:
+
+DistributeTranspilerConfig
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.transpiler.DistributeTranspilerConfig
+
+.. py:method:: slice_var_up (bool)
+
+为Pserver将张量切片, 默认为True
+
+.. py:method:: split_method (PSDispatcher)
+
+可使用 RoundRobin 或者 HashName
+
+注意: 尝试选择最佳方法来达到负载均衡。
+
+
+.. py:attribute:: min_block_size (int)
+
+最小数据块的大小
+
+注意: 根据：https：//github.com/PaddlePaddle/Paddle/issues/8638#issuecomment-369912156, 当数据块大小超过2MB时，我们可以有效地使用带宽。如果你想更改它，请详细查看slice_variable函数。
+
+
+
+英文版API文档: :ref:`api_fluid_transpiler_DistributeTranspilerConfig` 
+
+.. _cn_api_fluid_transpiler_HashName:
+
+HashName
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.transpiler.HashName(pserver_endpoints)
+
+使用 python ``Hash()`` 函数将变量名散列到多个pserver终端。
+
+参数:
+  - **pserver_endpoints** (list) - endpoint （ip:port）的 list 
+
+
+
+
+英文版API文档: :ref:`api_fluid_transpiler_HashName` 
+
+.. _cn_api_fluid_transpiler_memory_optimize:
+
+memory_optimize
+>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.transpiler.memory_optimize(input_program, skip_opt_set=None, print_log=False, level=0, skip_grads=False)
+
+通过重用var内存来优化内存。
+
+注意:它不支持block中嵌套子block。
+
+参数:
+  - **input_program** (str) – 输入Program。
+  - **skip_opt_set** (set) – set中的vars将不被内存优化。
+  - **print_log** (bool) – 是否打印debug日志。
+  - **level** (int) - 如果 level=0 并且shape是完全相等，则重用。
+
+返回: None
+
+英文版API文档: :ref:`api_fluid_transpiler_memory_optimize` 
+
+
+
+
+.. _cn_api_fluid_transpiler_release_memory:
+
+release_memory
+>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+.. py:function:: paddle.fluid.transpiler.release_memory(input_program, skip_opt_set=None) 
+
+
+该函数可以调整输入program，插入 ``delete_op`` 删除算子，提前删除不需要的变量。
+改动是在变量本身上进行的。
+
+.. note::
+  该API还在试验阶段，会在后期版本中删除。不建议用户使用。
+
+参数:
+    - **input_program** (Program) – 在此program中插入 ``delete_op`` 
+    - **skip_opt_set** (set) – 在内存优化时跳过的变量的集合
+
+返回: None
+
+英文版API文档: :ref:`api_fluid_transpiler_release_memory` 
+
+
+
+
+.. _cn_api_fluid_transpiler_RoundRobin:
+
+RoundRobin
+>>>>>>>>>>>>
+
+.. py:class:: paddle.fluid.transpiler.RoundRobin(pserver_endpoints)
+
+使用 ``RondRobin`` 方法将变量分配给服务器端点。
+
+`RondRobin <https://en.wikipedia.org/wiki/Round-robin_scheduling>`_
+
+参数:
+  - **pserver_endpoints** (list) - endpoint （ip:port）的 list 
+ 
+ 
+
+
+英文版API文档: :ref:`api_fluid_transpiler_RoundRobin` 
+

doc/fluid/index_cn.rst

@@ -14,5 +14,5 @@
     beginners_guide/index.rst
     user_guides/index.rst
     advanced_usage/index.rst
-    api/index_cn.rst
+    api_cn/index_cn.rst
     release_note.rst