recover_api_doc_v1.1 (#529)

* recover_apidoc_v1.1

* delete_DS

doc/fluid/api_cn/CMakeLists.txt

+# configured documentation tools and intermediate build results
+set(BINARY_BUILD_DIR_EN "${CMAKE_CURRENT_BINARY_DIR}/en/_build")
+
+# Sphinx cache with pickled ReST documents
+set(SPHINX_CACHE_DIR_EN "${CMAKE_CURRENT_BINARY_DIR}/en/_doctrees")
+
+# HTML output director
+set(SPHINX_HTML_DIR_EN "${CMAKE_CURRENT_BINARY_DIR}/en/html")
+
+set(IMPORT_PADDLE_STRING "import paddle")
+set(IMPORT_PADDLEV2_STRING "import paddle.v2")
+
+configure_file(
+    "${CMAKE_CURRENT_SOURCE_DIR}/../../templates/conf.py.en.in"
+    "${BINARY_BUILD_DIR_EN}/conf.py"
+    @ONLY)
+
+sphinx_add_target(paddle_fluid_apis
+                  html
+                  ${BINARY_BUILD_DIR_EN}
+                  ${SPHINX_CACHE_DIR_EN}
+                  ${CMAKE_CURRENT_SOURCE_DIR}
+                  ${SPHINX_HTML_DIR_EN})
+
+add_dependencies(paddle_fluid_apis  gen_proto_py framework_py_proto copy_paddle_pybind paddle_python)

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
+  
+  

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_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:`user_guide_use_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
+    

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`
+
+
+less_than
+------------------
+
+对两个 :code:`Tensor` 逐元素判断是否满足小于关系， 对应数学操作符 :code:`<`
+
+API Reference 请参考 :ref:`api_fluid_layers_less_than`
+
+
+sum
+------------------
+
+对两个 :code:`Tensor` 逐元素相加。
+
+API Reference 请参考 :ref:`api_fluid_layers_sum`
+
+elementwise_min
+------------------
+
+对两个 :code:`Tensor` 逐元素进行 :code:`elementwise_min(x, y)` 操作。
+
+API Reference 请参考 :ref:`api_fluid_layers_elementwise_min`
+
+elementwise_max
+------------------
+
+对两个 :code:`Tensor` 逐元素进行 :code:`elementwise_max(x, y)` 操作。
+
+API Reference 请参考 :ref:`api_fluid_layers_elementwise_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/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/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/average.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+=============
+fluid.average
+=============
+
+.. _api_fluid_average_WeightedAverage:
+
+WeightedAverage
+---------------
+
+..  autoclass:: paddle.fluid.average.WeightedAverage
+    :members:
+    :noindex:
+

doc/fluid/api_cn/backward.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+==============
+fluid.backward
+==============
+
+.. _api_fluid_backward_append_backward:
+
+append_backward
+---------------
+
+..  autofunction:: paddle.fluid.backward.append_backward
+    :noindex:
+

doc/fluid/api_cn/clip.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+==========
+fluid.clip
+==========
+
+.. _api_fluid_clip_ErrorClipByValue:
+
+ErrorClipByValue
+----------------
+
+..  autoclass:: paddle.fluid.clip.ErrorClipByValue
+    :members:
+    :noindex:
+
+.. _api_fluid_clip_GradientClipByGlobalNorm:
+
+GradientClipByGlobalNorm
+------------------------
+
+..  autoclass:: paddle.fluid.clip.GradientClipByGlobalNorm
+    :members:
+    :noindex:
+
+.. _api_fluid_clip_GradientClipByNorm:
+
+GradientClipByNorm
+------------------
+
+..  autoclass:: paddle.fluid.clip.GradientClipByNorm
+    :members:
+    :noindex:
+
+.. _api_fluid_clip_GradientClipByValue:
+
+GradientClipByValue
+-------------------
+
+..  autoclass:: paddle.fluid.clip.GradientClipByValue
+    :members:
+    :noindex:
+

doc/fluid/api_cn/data/data_reader.rst

+=====================
+Data Reader Interface
+=====================
+
+
+DataTypes
+=========
+
+..  autofunction:: paddle.v2.data_type.dense_array
+    :noindex:
+
+..  autofunction:: paddle.v2.data_type.integer_value
+    :noindex:
+
+..  autofunction:: paddle.v2.data_type.integer_value_sequence
+    :noindex:
+
+..  autofunction:: paddle.v2.data_type.integer_value_sub_sequence
+    :noindex:
+
+..  autofunction:: paddle.v2.data_type.sparse_binary_vector
+    :noindex:
+
+..  autofunction:: paddle.v2.data_type.sparse_binary_vector_sequence
+    :noindex:
+
+..  autofunction:: paddle.v2.data_type.sparse_binary_vector_sub_sequence
+    :noindex:
+
+..  autofunction:: paddle.v2.data_type.sparse_float_vector
+    :noindex:
+
+..  autofunction:: paddle.v2.data_type.sparse_float_vector_sequence
+    :noindex:
+
+..  autofunction:: paddle.v2.data_type.sparse_float_vector_sub_sequence
+    :noindex:
+
+..  autofunction:: paddle.v2.data_type.sparse_non_value_slot
+    :noindex:
+
+..  autofunction:: paddle.v2.data_type.sparse_value_slot
+    :noindex:
+
+..  autoclass:: paddle.v2.data_type.InputType
+    :members:
+    :noindex:
+
+DataFeeder
+==========
+
+..  automodule:: paddle.v2.data_feeder
+    :members:
+    :noindex:
+
+Reader
+======
+
+..  automodule:: paddle.reader
+    :members:
+    :noindex:
+
+..  automodule:: paddle.reader.creator
+    :members:
+    :noindex:
+
+minibatch
+=========
+
+..  automodule:: paddle.v2.minibatch
+    :members:
+    :noindex:

doc/fluid/api_cn/data/dataset.rst

+Dataset
+=======
+
+..  automodule:: paddle.dataset
+    :members:
+    :noindex:
+
+mnist
++++++
+
+..  automodule:: paddle.dataset.mnist
+    :members:
+    :noindex:
+
+cifar
++++++
+
+..  automodule:: paddle.dataset.cifar
+    :members:
+    :noindex:
+
+conll05
++++++++
+
+..  automodule:: paddle.dataset.conll05
+    :members: get_dict,get_embedding,test
+    :noindex:
+
+imdb
+++++
+
+..  automodule:: paddle.dataset.imdb
+    :members:
+    :noindex:
+
+imikolov
+++++++++
+
+..  automodule:: paddle.dataset.imikolov
+    :members:
+    :noindex:
+
+movielens
++++++++++
+
+..  automodule:: paddle.dataset.movielens
+    :members:
+    :noindex:
+
+..  autoclass:: paddle.dataset.movielens.MovieInfo
+    :noindex:
+
+..  autoclass:: paddle.dataset.movielens.UserInfo
+    :noindex:
+
+sentiment
++++++++++
+
+..  automodule:: paddle.dataset.sentiment
+    :members:
+    :noindex:
+
+uci_housing
++++++++++++
+
+..  automodule:: paddle.dataset.uci_housing
+    :members:
+    :noindex:
+
+wmt14
++++++
+
+..  automodule:: paddle.dataset.wmt14
+    :members:
+    :noindex:
+
+wmt16
++++++
+
+..  automodule:: paddle.dataset.wmt16
+    :members:
+    :noindex:

doc/fluid/api_cn/data/image.rst

+Image Interface
+===============
+
+..  automodule:: paddle.v2.image
+    :members:

doc/fluid/api_cn/data_feeder.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+=================
+fluid.data_feeder
+=================
+
+.. _api_fluid_data_feeder_DataFeeder:
+
+DataFeeder
+----------
+
+..  autoclass:: paddle.fluid.data_feeder.DataFeeder
+    :members:
+    :noindex:
+

doc/fluid/api_cn/executor.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+==============
+fluid.executor
+==============
+
+.. _api_fluid_executor__switch_scope:
+
+_switch_scope
+-------------
+
+..  autofunction:: paddle.fluid.executor._switch_scope
+    :noindex:
+
+.. _api_fluid_executor_Executor:
+
+Executor
+--------
+
+..  autoclass:: paddle.fluid.executor.Executor
+    :members:
+    :noindex:
+
+.. _api_fluid_executor_global_scope:
+
+global_scope
+------------
+
+..  autofunction:: paddle.fluid.executor.global_scope
+    :noindex:
+
+.. _api_fluid_executor_scope_guard:
+
+scope_guard
+-----------
+
+..  autofunction:: paddle.fluid.executor.scope_guard
+    :noindex:
+

doc/fluid/api_cn/fluid.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+=====
+fluid
+=====
+
+.. _api_fluid__switch_scope:
+
+_switch_scope
+-------------
+
+..  autofunction:: paddle.fluid._switch_scope
+    :noindex:
+
+.. _api_fluid_BuildStrategy:
+
+BuildStrategy
+-------------
+
+..  autoclass:: paddle.fluid.BuildStrategy
+    :members:
+    :noindex:
+
+.. _api_fluid_CPUPlace:
+
+CPUPlace
+--------
+
+..  autoclass:: paddle.fluid.CPUPlace
+    :members:
+    :noindex:
+
+.. _api_fluid_create_lod_tensor:
+
+create_lod_tensor
+-----------------
+
+..  autofunction:: paddle.fluid.create_lod_tensor
+    :noindex:
+
+.. _api_fluid_create_random_int_lodtensor:
+
+create_random_int_lodtensor
+---------------------------
+
+..  autofunction:: paddle.fluid.create_random_int_lodtensor
+    :noindex:
+
+.. _api_fluid_CUDAPinnedPlace:
+
+CUDAPinnedPlace
+---------------
+
+..  autoclass:: paddle.fluid.CUDAPinnedPlace
+    :members:
+    :noindex:
+
+.. _api_fluid_CUDAPlace:
+
+CUDAPlace
+---------
+
+..  autoclass:: paddle.fluid.CUDAPlace
+    :members:
+    :noindex:
+
+.. _api_fluid_DataFeeder:
+
+DataFeeder
+----------
+
+..  autoclass:: paddle.fluid.DataFeeder
+    :members:
+    :noindex:
+
+.. _api_fluid_default_main_program:
+
+default_main_program
+--------------------
+
+..  autofunction:: paddle.fluid.default_main_program
+    :noindex:
+
+.. _api_fluid_default_startup_program:
+
+default_startup_program
+-----------------------
+
+..  autofunction:: paddle.fluid.default_startup_program
+    :noindex:
+
+.. _api_fluid_DistributeTranspiler:
+
+DistributeTranspiler
+--------------------
+
+..  autoclass:: paddle.fluid.DistributeTranspiler
+    :members:
+    :noindex:
+
+.. _api_fluid_DistributeTranspilerConfig:
+
+DistributeTranspilerConfig
+--------------------------
+
+..  autoclass:: paddle.fluid.DistributeTranspilerConfig
+    :members:
+    :noindex:
+
+.. _api_fluid_ExecutionStrategy:
+
+ExecutionStrategy
+-----------------
+
+..  autoclass:: paddle.fluid.ExecutionStrategy
+    :members:
+    :noindex:
+
+.. _api_fluid_Executor:
+
+Executor
+--------
+
+..  autoclass:: paddle.fluid.Executor
+    :members:
+    :noindex:
+
+.. _api_fluid_global_scope:
+
+global_scope
+------------
+
+..  autofunction:: paddle.fluid.global_scope
+    :noindex:
+
+.. _api_fluid_LoDTensor:
+
+LoDTensor
+---------
+
+..  autoclass:: paddle.fluid.LoDTensor
+    :members:
+    :noindex:
+
+.. _api_fluid_LoDTensorArray:
+
+LoDTensorArray
+--------------
+
+..  autoclass:: paddle.fluid.LoDTensorArray
+    :members:
+    :noindex:
+
+.. _api_fluid_memory_optimize:
+
+memory_optimize
+---------------
+
+..  autofunction:: paddle.fluid.memory_optimize
+    :noindex:
+
+.. _api_fluid_name_scope:
+
+name_scope
+----------
+
+..  autofunction:: paddle.fluid.name_scope
+    :noindex:
+
+.. _api_fluid_ParallelExecutor:
+
+ParallelExecutor
+----------------
+
+..  autoclass:: paddle.fluid.ParallelExecutor
+    :members:
+    :noindex:
+
+.. _api_fluid_ParamAttr:
+
+ParamAttr
+---------
+
+..  autoclass:: paddle.fluid.ParamAttr
+    :members:
+    :noindex:
+
+.. _api_fluid_Program:
+
+Program
+-------
+
+..  autoclass:: paddle.fluid.Program
+    :members:
+    :noindex:
+
+.. _api_fluid_program_guard:
+
+program_guard
+-------------
+
+..  autofunction:: paddle.fluid.program_guard
+    :noindex:
+
+.. _api_fluid_release_memory:
+
+release_memory
+--------------
+
+..  autofunction:: paddle.fluid.release_memory
+    :noindex:
+
+.. _api_fluid_Scope:
+
+Scope
+-----
+
+..  autoclass:: paddle.fluid.Scope
+    :members:
+    :noindex:
+
+.. _api_fluid_scope_guard:
+
+scope_guard
+-----------
+
+..  autofunction:: paddle.fluid.scope_guard
+    :noindex:
+
+.. _api_fluid_Tensor:
+
+Tensor
+------
+
+..  autoclass:: paddle.fluid.Tensor
+    :members:
+    :noindex:
+
+.. _api_fluid_WeightNormParamAttr:
+
+WeightNormParamAttr
+-------------------
+
+..  autoclass:: paddle.fluid.WeightNormParamAttr
+    :members:
+    :noindex:
+

doc/fluid/api_cn/gen_doc.py

+#   Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+import argparse
+import sys
+import types
+
+import paddle.fluid as fluid
+
+
+def parse_arg():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--submodules', nargs="*")
+    parser.add_argument(
+        'module', type=str, help='Generate the documentation of which module')
+    return parser.parse_args()
+
+
+class DocGenerator(object):
+    def __init__(self, module_name=None, stream=sys.stdout):
+        if module_name == "":
+            module_name = None
+        self.stream = stream
+        if module_name is None:
+            self.module_name = "fluid"
+        else:
+            self.module_name = "fluid." + module_name
+        if module_name is None:
+            self.module = fluid
+        else:
+            if not hasattr(fluid, module_name):
+                raise ValueError("Cannot find fluid.{0}".format(module_name))
+            else:
+                self.module = getattr(fluid, module_name)
+        self.stream.write('''..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+''')
+
+        self._print_header_(self.module_name, dot='=', is_title=True)
+
+    def print_submodule(self, submodule_name):
+        submodule = getattr(self.module, submodule_name)
+        if submodule is None:
+            raise ValueError("Cannot find submodule {0}".format(submodule_name))
+        self.print_section(submodule_name)
+
+        for item in sorted(submodule.__all__,key=str.lower):
+            self.print_item(item)
+
+    def print_current_module(self):
+        for item in sorted(self.module.__all__,key=str.lower):
+            self.print_item(item)
+
+    def print_section(self, name):
+        self._print_header_(name, dot='=', is_title=False)
+
+    def print_item(self, name):
+        item = getattr(self.module, name, None)
+        if item is None:
+            return
+        if isinstance(item, types.TypeType):
+            self.print_class(name)
+        elif isinstance(item, types.FunctionType):
+            self.print_method(name)
+        else:
+            pass
+
+    def print_class(self, name):
+        self._print_ref_(name)
+        self._print_header_(name, dot='-', is_title=False)
+        self.stream.write('''..  autoclass:: paddle.{0}.{1}
+    :members:
+    :noindex:
+
+'''.format(self.module_name, name))
+
+    def print_method(self, name):
+        self._print_ref_(name)
+        self._print_header_(name, dot='-', is_title=False)
+        self.stream.write('''..  autofunction:: paddle.{0}.{1}
+    :noindex:
+
+'''.format(self.module_name, name))
+
+    def _print_header_(self, name, dot, is_title):
+        dot_line = dot * len(name)
+        if is_title:
+            self.stream.write(dot_line)
+            self.stream.write('\n')
+        self.stream.write(name)
+        self.stream.write('\n')
+        self.stream.write(dot_line)
+        self.stream.write('\n')
+        self.stream.write('\n')
+
+    def _print_ref_(self, name):
+        self.stream.write(".. _api_{0}_{1}:\n\n".format("_".join(
+            self.module_name.split(".")), name))
+
+
+def main():
+    args = parse_arg()
+    gen = DocGenerator(args.module)
+    if args.submodules is None:
+        gen.print_current_module()
+    else:
+        for submodule_name in args.submodules:
+            gen.print_submodule(submodule_name)
+
+
+if __name__ == '__main__':
+    main()

doc/fluid/api_cn/gen_doc.sh

+#!/bin/bash
+python gen_doc.py layers --submodules control_flow device io nn ops tensor learning_rate_scheduler detection metric_op > layers.rst
+
+for module in data_feeder clip metrics executor initializer io nets optimizer param_attr profiler regularizer transpiler  backward average profiler
+do
+  python gen_doc.py ${module} > ${module}.rst
+done
+
+python gen_doc.py "" > fluid.rst

doc/fluid/api_cn/gen_index.py

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

doc/fluid/api_cn/index_cn.rst

+=============
+API
+=============
+
+..  toctree::
+    :maxdepth: 1
+
+    api_guides/index.rst
+    fluid.rst
+    average.rst
+    backward.rst
+    clip.rst
+    data.rst
+    data_feeder.rst
+    executor.rst
+    initializer.rst
+    io.rst
+    layers.rst
+    metrics.rst
+    nets.rst
+    optimizer.rst
+    param_attr.rst
+    profiler.rst
+    regularizer.rst
+    transpiler.rst
+

doc/fluid/api_cn/initializer.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+=================
+fluid.initializer
+=================
+
+.. _api_fluid_initializer_Bilinear:
+
+Bilinear
+--------
+
+..  autoclass:: paddle.fluid.initializer.Bilinear
+    :members:
+    :noindex:
+
+.. _api_fluid_initializer_BilinearInitializer:
+
+BilinearInitializer
+-------------------
+
+..  autoclass:: paddle.fluid.initializer.BilinearInitializer
+    :members:
+    :noindex:
+
+.. _api_fluid_initializer_Constant:
+
+Constant
+--------
+
+..  autoclass:: paddle.fluid.initializer.Constant
+    :members:
+    :noindex:
+
+.. _api_fluid_initializer_ConstantInitializer:
+
+ConstantInitializer
+-------------------
+
+..  autoclass:: paddle.fluid.initializer.ConstantInitializer
+    :members:
+    :noindex:
+
+.. _api_fluid_initializer_force_init_on_cpu:
+
+force_init_on_cpu
+-----------------
+
+..  autofunction:: paddle.fluid.initializer.force_init_on_cpu
+    :noindex:
+
+.. _api_fluid_initializer_init_on_cpu:
+
+init_on_cpu
+-----------
+
+..  autofunction:: paddle.fluid.initializer.init_on_cpu
+    :noindex:
+
+.. _api_fluid_initializer_MSRA:
+
+MSRA
+----
+
+..  autoclass:: paddle.fluid.initializer.MSRA
+    :members:
+    :noindex:
+
+.. _api_fluid_initializer_MSRAInitializer:
+
+MSRAInitializer
+---------------
+
+..  autoclass:: paddle.fluid.initializer.MSRAInitializer
+    :members:
+    :noindex:
+
+.. _api_fluid_initializer_Normal:
+
+Normal
+------
+
+..  autoclass:: paddle.fluid.initializer.Normal
+    :members:
+    :noindex:
+
+.. _api_fluid_initializer_NormalInitializer:
+
+NormalInitializer
+-----------------
+
+..  autoclass:: paddle.fluid.initializer.NormalInitializer
+    :members:
+    :noindex:
+
+.. _api_fluid_initializer_TruncatedNormal:
+
+TruncatedNormal
+---------------
+
+..  autoclass:: paddle.fluid.initializer.TruncatedNormal
+    :members:
+    :noindex:
+
+.. _api_fluid_initializer_TruncatedNormalInitializer:
+
+TruncatedNormalInitializer
+--------------------------
+
+..  autoclass:: paddle.fluid.initializer.TruncatedNormalInitializer
+    :members:
+    :noindex:
+
+.. _api_fluid_initializer_Uniform:
+
+Uniform
+-------
+
+..  autoclass:: paddle.fluid.initializer.Uniform
+    :members:
+    :noindex:
+
+.. _api_fluid_initializer_UniformInitializer:
+
+UniformInitializer
+------------------
+
+..  autoclass:: paddle.fluid.initializer.UniformInitializer
+    :members:
+    :noindex:
+
+.. _api_fluid_initializer_Xavier:
+
+Xavier
+------
+
+..  autoclass:: paddle.fluid.initializer.Xavier
+    :members:
+    :noindex:
+
+.. _api_fluid_initializer_XavierInitializer:
+
+XavierInitializer
+-----------------
+
+..  autoclass:: paddle.fluid.initializer.XavierInitializer
+    :members:
+    :noindex:
+

doc/fluid/api_cn/io.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+========
+fluid.io
+========
+
+.. _api_fluid_io_load_inference_model:
+
+load_inference_model
+--------------------
+
+..  autofunction:: paddle.fluid.io.load_inference_model
+    :noindex:
+
+.. _api_fluid_io_load_params:
+
+load_params
+-----------
+
+..  autofunction:: paddle.fluid.io.load_params
+    :noindex:
+
+.. _api_fluid_io_load_persistables:
+
+load_persistables
+-----------------
+
+..  autofunction:: paddle.fluid.io.load_persistables
+    :noindex:
+
+.. _api_fluid_io_load_vars:
+
+load_vars
+---------
+
+..  autofunction:: paddle.fluid.io.load_vars
+    :noindex:
+
+.. _api_fluid_io_save_inference_model:
+
+save_inference_model
+--------------------
+
+..  autofunction:: paddle.fluid.io.save_inference_model
+    :noindex:
+
+.. _api_fluid_io_save_params:
+
+save_params
+-----------
+
+..  autofunction:: paddle.fluid.io.save_params
+    :noindex:
+
+.. _api_fluid_io_save_persistables:
+
+save_persistables
+-----------------
+
+..  autofunction:: paddle.fluid.io.save_persistables
+    :noindex:
+
+.. _api_fluid_io_save_vars:
+
+save_vars
+---------
+
+..  autofunction:: paddle.fluid.io.save_vars
+    :noindex:
+

doc/fluid/api_cn/menu.json

+{
+    "sections": [
+        {
+            "sections": [
+                {
+                    "link": {
+                        "zh": "api_guides/high_low_level_api.md"
+                    }, 
+                    "title": {
+                        "zh": "High/Low-level API\u7b80\u4ecb"
+                    }
+                }, 
+                {
+                    "sections": [
+                        {
+                            "link": {
+                                "zh": "api_guides/low_level/layers/conv.rst"
+                            }, 
+                            "title": {
+                                "zh": "\u5377\u79ef"
+                            }
+                        }, 
+                        {
+                            "link": {
+                                "zh": "api_guides/low_level/layers/pooling.rst"
+                            }, 
+                            "title": {
+                                "zh": "\u6c60\u5316"
+                            }
+                        }, 
+                        {
+                            "link": {
+                                "zh": "api_guides/low_level/layers/detection.rst"
+                            }, 
+                            "title": {
+                                "zh": "\u56fe\u50cf\u68c0\u6d4b"
+                            }
+                        }, 
+                        {
+                            "link": {
+                                "zh": "api_guides/low_level/layers/sequence.rst"
+                            }, 
+                            "title": {
+                                "zh": "\u5e8f\u5217"
+                            }
+                        }, 
+                        {
+                            "link": {
+                                "zh": "api_guides/low_level/layers/math.rst"
+                            }, 
+                            "title": {
+                                "zh": "\u6570\u5b66\u64cd\u4f5c"
+                            }
+                        }, 
+                        {
+                            "link": {
+                                "zh": "api_guides/low_level/layers/activations.rst"
+                            }, 
+                            "title": {
+                                "zh": "\u6fc0\u6d3b\u51fd\u6570"
+                            }
+                        }, 
+                        {
+                            "link": {
+                                "zh": "api_guides/low_level/layers/loss_function.rst"
+                            }, 
+                            "title": {
+                                "zh": "\u635f\u5931\u51fd\u6570"
+                            }
+                        }, 
+                        {
+                            "link": {
+                                "zh": "api_guides/low_level/layers/data_in_out.rst"
+                            }, 
+                            "title": {
+                                "zh": "\u6570\u636e\u8f93\u5165\u8f93\u51fa"
+                            }
+                        }, 
+                        {
+                            "link": {
+                                "zh": "api_guides/low_level/layers/control_flow.rst"
+                            }, 
+                            "title": {
+                                "zh": "\u63a7\u5236\u6d41"
+                            }
+                        }
+                    ], 
+                    "title": {
+                        "zh": "\u795e\u7ecf\u7f51\u7edc\u5c42"
+                    }
+                }, 
+                {
+                    "link": {
+                        "zh": "api_guides/low_level/executor.rst"
+                    }, 
+                    "title": {
+                        "zh": "\u6267\u884c\u5f15\u64ce"
+                    }
+                }, 
+                {
+                    "link": {
+                        "zh": "api_guides/low_level/optimizer.rst"
+                    }, 
+                    "title": {
+                        "zh": "\u4f18\u5316\u5668"
+                    }
+                }, 
+                {
+                    "link": {
+                        "zh": "api_guides/low_level/metrics.rst"
+                    }, 
+                    "title": {
+                        "zh": "\u8bc4\u4ef7\u6307\u6807"
+                    }
+                }, 
+                {
+                    "link": {
+                        "zh": "api_guides/low_level/model_save_reader.rst"
+                    }, 
+                    "title": {
+                        "zh": "\u6a21\u578b\u4fdd\u5b58\u4e0e\u52a0\u8f7d"
+                    }
+                }, 
+                {
+                    "link": {
+                        "zh": "api_guides/low_level/inference.rst"
+                    }, 
+                    "title": {
+                        "zh": "\u9884\u6d4b\u5f15\u64ce"
+                    }
+                }
+            ], 
+            "title": {
+                "zh": "API\u4f7f\u7528\u6307\u5357"
+            }
+        }, 
+        {
+            "link": {
+                "zh": "fluid.rst"
+            }, 
+            "title": {
+                "zh": "fluid"
+            }
+        }, 
+        {
+            "link": {
+                "zh": "average.rst"
+            }, 
+            "title": {
+                "zh": "fluid.average"
+            }
+        }, 
+        {
+            "link": {
+                "zh": "backward.rst"
+            }, 
+            "title": {
+                "zh": "fluid.backward"
+            }
+        }, 
+        {
+            "link": {
+                "zh": "clip.rst"
+            }, 
+            "title": {
+                "zh": "fluid.clip"
+            }
+        }, 
+        {
+            "link": {
+                "zh": "data_feeder.rst"
+            }, 
+            "title": {
+                "zh": "fluid.data_feeder"
+            }
+        }, 
+        {
+            "link": {
+                "zh": "executor.rst"
+            }, 
+            "title": {
+                "zh": "fluid.executor"
+            }
+        }, 
+        {
+            "link": {
+                "zh": "initializer.rst"
+            }, 
+            "title": {
+                "zh": "fluid.initializer"
+            }
+        }, 
+        {
+            "link": {
+                "zh": "io.rst"
+            }, 
+            "title": {
+                "zh": "fluid.io"
+            }
+        }, 
+        {
+            "link": {
+                "zh": "layers.rst"
+            }, 
+            "title": {
+                "zh": "fluid.layers"
+            }
+        }, 
+        {
+            "link": {
+                "zh": "metrics.rst"
+            }, 
+            "title": {
+                "zh": "fluid.metrics"
+            }
+        }, 
+        {
+            "link": {
+                "zh": "nets.rst"
+            }, 
+            "title": {
+                "zh": "fluid.nets"
+            }
+        }, 
+        {
+            "link": {
+                "zh": "optimizer.rst"
+            }, 
+            "title": {
+                "zh": "fluid.optimizer"
+            }
+        }, 
+        {
+            "link": {
+                "zh": "param_attr.rst"
+            }, 
+            "title": {
+                "zh": "fluid.param_attr"
+            }
+        }, 
+        {
+            "link": {
+                "zh": "profiler.rst"
+            }, 
+            "title": {
+                "zh": "fluid.profiler"
+            }
+        }, 
+        {
+            "link": {
+                "zh": "regularizer.rst"
+            }, 
+            "title": {
+                "zh": "fluid.regularizer"
+            }
+        }, 
+        {
+            "link": {
+                "zh": "transpiler.rst"
+            }, 
+            "title": {
+                "zh": "fluid.transpiler"
+            }
+        }
+    ]
+}
\ No newline at end of file

doc/fluid/api_cn/metrics.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+=============
+fluid.metrics
+=============
+
+.. _api_fluid_metrics_Accuracy:
+
+Accuracy
+--------
+
+..  autoclass:: paddle.fluid.metrics.Accuracy
+    :members:
+    :noindex:
+
+.. _api_fluid_metrics_Auc:
+
+Auc
+---
+
+..  autoclass:: paddle.fluid.metrics.Auc
+    :members:
+    :noindex:
+
+.. _api_fluid_metrics_ChunkEvaluator:
+
+ChunkEvaluator
+--------------
+
+..  autoclass:: paddle.fluid.metrics.ChunkEvaluator
+    :members:
+    :noindex:
+
+.. _api_fluid_metrics_CompositeMetric:
+
+CompositeMetric
+---------------
+
+..  autoclass:: paddle.fluid.metrics.CompositeMetric
+    :members:
+    :noindex:
+
+.. _api_fluid_metrics_DetectionMAP:
+
+DetectionMAP
+------------
+
+..  autoclass:: paddle.fluid.metrics.DetectionMAP
+    :members:
+    :noindex:
+
+.. _api_fluid_metrics_EditDistance:
+
+EditDistance
+------------
+
+..  autoclass:: paddle.fluid.metrics.EditDistance
+    :members:
+    :noindex:
+
+.. _api_fluid_metrics_MetricBase:
+
+MetricBase
+----------
+
+..  autoclass:: paddle.fluid.metrics.MetricBase
+    :members:
+    :noindex:
+
+.. _api_fluid_metrics_Precision:
+
+Precision
+---------
+
+..  autoclass:: paddle.fluid.metrics.Precision
+    :members:
+    :noindex:
+
+.. _api_fluid_metrics_Recall:
+
+Recall
+------
+
+..  autoclass:: paddle.fluid.metrics.Recall
+    :members:
+    :noindex:
+

doc/fluid/api_cn/nets.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+==========
+fluid.nets
+==========
+
+.. _api_fluid_nets_glu:
+
+glu
+---
+
+..  autofunction:: paddle.fluid.nets.glu
+    :noindex:
+
+.. _api_fluid_nets_img_conv_group:
+
+img_conv_group
+--------------
+
+..  autofunction:: paddle.fluid.nets.img_conv_group
+    :noindex:
+
+.. _api_fluid_nets_scaled_dot_product_attention:
+
+scaled_dot_product_attention
+----------------------------
+
+..  autofunction:: paddle.fluid.nets.scaled_dot_product_attention
+    :noindex:
+
+.. _api_fluid_nets_sequence_conv_pool:
+
+sequence_conv_pool
+------------------
+
+..  autofunction:: paddle.fluid.nets.sequence_conv_pool
+    :noindex:
+
+.. _api_fluid_nets_simple_img_conv_pool:
+
+simple_img_conv_pool
+--------------------
+
+..  autofunction:: paddle.fluid.nets.simple_img_conv_pool
+    :noindex:
+

doc/fluid/api_cn/optimizer.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+===============
+fluid.optimizer
+===============
+
+.. _api_fluid_optimizer_Adadelta:
+
+Adadelta
+--------
+
+..  autoclass:: paddle.fluid.optimizer.Adadelta
+    :members:
+    :noindex:
+
+.. _api_fluid_optimizer_Adagrad:
+
+Adagrad
+-------
+
+..  autoclass:: paddle.fluid.optimizer.Adagrad
+    :members:
+    :noindex:
+
+.. _api_fluid_optimizer_AdagradOptimizer:
+
+AdagradOptimizer
+----------------
+
+..  autoclass:: paddle.fluid.optimizer.AdagradOptimizer
+    :members:
+    :noindex:
+
+.. _api_fluid_optimizer_Adam:
+
+Adam
+----
+
+..  autoclass:: paddle.fluid.optimizer.Adam
+    :members:
+    :noindex:
+
+.. _api_fluid_optimizer_Adamax:
+
+Adamax
+------
+
+..  autoclass:: paddle.fluid.optimizer.Adamax
+    :members:
+    :noindex:
+
+.. _api_fluid_optimizer_AdamaxOptimizer:
+
+AdamaxOptimizer
+---------------
+
+..  autoclass:: paddle.fluid.optimizer.AdamaxOptimizer
+    :members:
+    :noindex:
+
+.. _api_fluid_optimizer_AdamOptimizer:
+
+AdamOptimizer
+-------------
+
+..  autoclass:: paddle.fluid.optimizer.AdamOptimizer
+    :members:
+    :noindex:
+
+.. _api_fluid_optimizer_DecayedAdagrad:
+
+DecayedAdagrad
+--------------
+
+..  autoclass:: paddle.fluid.optimizer.DecayedAdagrad
+    :members:
+    :noindex:
+
+.. _api_fluid_optimizer_DecayedAdagradOptimizer:
+
+DecayedAdagradOptimizer
+-----------------------
+
+..  autoclass:: paddle.fluid.optimizer.DecayedAdagradOptimizer
+    :members:
+    :noindex:
+
+.. _api_fluid_optimizer_Ftrl:
+
+Ftrl
+----
+
+..  autoclass:: paddle.fluid.optimizer.Ftrl
+    :members:
+    :noindex:
+
+.. _api_fluid_optimizer_FtrlOptimizer:
+
+FtrlOptimizer
+-------------
+
+..  autoclass:: paddle.fluid.optimizer.FtrlOptimizer
+    :members:
+    :noindex:
+
+.. _api_fluid_optimizer_ModelAverage:
+
+ModelAverage
+------------
+
+..  autoclass:: paddle.fluid.optimizer.ModelAverage
+    :members:
+    :noindex:
+
+.. _api_fluid_optimizer_Momentum:
+
+Momentum
+--------
+
+..  autoclass:: paddle.fluid.optimizer.Momentum
+    :members:
+    :noindex:
+
+.. _api_fluid_optimizer_MomentumOptimizer:
+
+MomentumOptimizer
+-----------------
+
+..  autoclass:: paddle.fluid.optimizer.MomentumOptimizer
+    :members:
+    :noindex:
+
+.. _api_fluid_optimizer_RMSPropOptimizer:
+
+RMSPropOptimizer
+----------------
+
+..  autoclass:: paddle.fluid.optimizer.RMSPropOptimizer
+    :members:
+    :noindex:
+
+.. _api_fluid_optimizer_RMSPropOptimizer:
+
+RMSPropOptimizer
+----------------
+
+..  autoclass:: paddle.fluid.optimizer.RMSPropOptimizer
+    :members:
+    :noindex:
+
+.. _api_fluid_optimizer_SGD:
+
+SGD
+---
+
+..  autoclass:: paddle.fluid.optimizer.SGD
+    :members:
+    :noindex:
+
+.. _api_fluid_optimizer_SGDOptimizer:
+
+SGDOptimizer
+------------
+
+..  autoclass:: paddle.fluid.optimizer.SGDOptimizer
+    :members:
+    :noindex:
+

doc/fluid/api_cn/param_attr.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+================
+fluid.param_attr
+================
+
+.. _api_fluid_param_attr_ParamAttr:
+
+ParamAttr
+---------
+
+..  autoclass:: paddle.fluid.param_attr.ParamAttr
+    :members:
+    :noindex:
+
+.. _api_fluid_param_attr_WeightNormParamAttr:
+
+WeightNormParamAttr
+-------------------
+
+..  autoclass:: paddle.fluid.param_attr.WeightNormParamAttr
+    :members:
+    :noindex:
+

doc/fluid/api_cn/profiler.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+==============
+fluid.profiler
+==============
+
+.. _api_fluid_profiler_cuda_profiler:
+
+cuda_profiler
+-------------
+
+..  autofunction:: paddle.fluid.profiler.cuda_profiler
+    :noindex:
+
+.. _api_fluid_profiler_profiler:
+
+profiler
+--------
+
+..  autofunction:: paddle.fluid.profiler.profiler
+    :noindex:
+
+.. _api_fluid_profiler_reset_profiler:
+
+reset_profiler
+--------------
+
+..  autofunction:: paddle.fluid.profiler.reset_profiler
+    :noindex:
+
+.. _api_fluid_profiler_start_profiler:
+
+start_profiler
+--------------
+
+..  autofunction:: paddle.fluid.profiler.start_profiler
+    :noindex:
+
+.. _api_fluid_profiler_stop_profiler:
+
+stop_profiler
+-------------
+
+..  autofunction:: paddle.fluid.profiler.stop_profiler
+    :noindex:
+

doc/fluid/api_cn/regularizer.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+=================
+fluid.regularizer
+=================
+
+.. _api_fluid_regularizer_L1Decay:
+
+L1Decay
+-------
+
+..  autoclass:: paddle.fluid.regularizer.L1Decay
+    :members:
+    :noindex:
+
+.. _api_fluid_regularizer_L1DecayRegularizer:
+
+L1DecayRegularizer
+------------------
+
+..  autoclass:: paddle.fluid.regularizer.L1DecayRegularizer
+    :members:
+    :noindex:
+
+.. _api_fluid_regularizer_L2Decay:
+
+L2Decay
+-------
+
+..  autoclass:: paddle.fluid.regularizer.L2Decay
+    :members:
+    :noindex:
+
+.. _api_fluid_regularizer_L2DecayRegularizer:
+
+L2DecayRegularizer
+------------------
+
+..  autoclass:: paddle.fluid.regularizer.L2DecayRegularizer
+    :members:
+    :noindex:
+

doc/fluid/api_cn/transpiler.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+================
+fluid.transpiler
+================
+
+.. _api_fluid_transpiler_DistributeTranspiler:
+
+DistributeTranspiler
+--------------------
+
+..  autoclass:: paddle.fluid.transpiler.DistributeTranspiler
+    :members:
+    :noindex:
+
+.. _api_fluid_transpiler_DistributeTranspilerConfig:
+
+DistributeTranspilerConfig
+--------------------------
+
+..  autoclass:: paddle.fluid.transpiler.DistributeTranspilerConfig
+    :members:
+    :noindex:
+
+.. _api_fluid_transpiler_HashName:
+
+HashName
+--------
+
+..  autoclass:: paddle.fluid.transpiler.HashName
+    :members:
+    :noindex:
+
+.. _api_fluid_transpiler_memory_optimize:
+
+memory_optimize
+---------------
+
+..  autofunction:: paddle.fluid.transpiler.memory_optimize
+    :noindex:
+
+.. _api_fluid_transpiler_release_memory:
+
+release_memory
+--------------
+
+..  autofunction:: paddle.fluid.transpiler.release_memory
+    :noindex:
+
+.. _api_fluid_transpiler_RoundRobin:
+
+RoundRobin
+----------
+
+..  autoclass:: paddle.fluid.transpiler.RoundRobin
+    :members:
+    :noindex:
+

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