update_1.2 (#487)

* update layers_nn * Update layers_cn.rst * Update layers_cn.rst * update api_cn except layers * update fluid_cn.rst * Update metrics_cn.rst * update_ciwhl * update_2nd * fix_3rd * fix_deadlinks (#476) * [infer][rl_note]develop=1.2 (#480) * update_infer_toctree * add_fluid * Update release_note.rst * update_install_doc * update layers_cn_by_wh * Fix some typo 1211 (#483) * fix some typo * Update nets_cn.rst * update_version * refine info of whl (#485) * refine info of whl * fix link for release-whls * remove fast install info (#486) * refine info of whl * fix link for release-whls * remove fast install info

update_1.2 (#487)
* update layers_nn * Update layers_cn.rst * Update layers_cn.rst * update api_cn except layers * update fluid_cn.rst * Update metrics_cn.rst * update_ciwhl * update_2nd * fix_3rd * fix_deadlinks (#476) * [infer][rl_note]develop=1.2 (#480) * update_infer_toctree * add_fluid * Update release_note.rst * update_install_doc * update layers_cn_by_wh * Fix some typo 1211 (#483) * fix some typo * Update nets_cn.rst * update_version * refine info of whl (#485) * refine info of whl * fix link for release-whls * remove fast install info (#486) * refine info of whl * fix link for release-whls * remove fast install info
64609673 · Cheerego · GitHub · 6e512429 · 64609673 · 64609673
8 changed file
--- a/doc/fluid/api_cn/layers_cn.rst
+++ b/doc/fluid/api_cn/layers_cn.rst
@@ -20,11 +20,12 @@ array_length
 此功能用于查找输入数组LOD_TENSOR_ARRAY的长度。  

 相关API:
-    - :ref:`api_fluid_layers_array_read`
-    - :ref:`api_fluid_layers_array_write`
-    - :ref:`api_fluid_layers_While`
+    - :ref:`cn_api_fluid_layers_array_read`
+    - :ref:`cn_api_fluid_layers_array_write`
+    - :ref:`cn_api_fluid_layers_While`

-参数：**array** (LOD_TENSOR_ARRAY)-输入数组，用来计算数组长度
+参数：
+    - **array** (LOD_TENSOR_ARRAY)-输入数组，用来计算数组长度

 返回：输入数组LoDTensorArray的长度

@@ -201,6 +202,9 @@ memory用于缓存分段数据。memory的初始值可以是零，也可以是

 动态RNN可以将多个变量标记为其输出。使用drnn()获得输出序列。

+.. note::
+    目前不支持在DynamicRNN中任何层上配置 is_sparse = True
+
 .. py:method:: step_input(x)
  
    将序列标记为动态RNN输入。
@@ -396,12 +400,15 @@ increment
 .. py:function:: paddle.fluid.layers.increment(x, value=1.0, in_place=True)

   
-该函数为输入 ``x`` 中的每一个值增加 ``value`` 大小, ``value`` 即函数中待传入的参数。该函数默认直接在原变量 ``x`` 上进行运算。
+该函数为输入 ``x`` 增加 ``value`` 大小, ``value`` 即函数中待传入的参数。该函数默认直接在原变量 ``x`` 上进行运算。
+
+.. note::
+    ``x`` 中元素个数必须为1

 参数:
    - **x** (Variable|list) – 含有输入值的张量(tensor)
    - **value** (float) – 需要增加在 ``x`` 变量上的值
-    - **in_place** (bool) – 是否在 ``x`` 变量本身进行增加操作，而非返回其增加后的一个副本而本身不改变。默认为True, 即在其本身进行操作。
+    - **in_place** (bool) – 判断是否在x变量本身执行操作，True原地执行，False时，返回增加后的副本

 返回： 每个元素增加后的对象

@@ -411,7 +418,8 @@ increment

 ..  code-block:: python
  
-    data = fluid.layers.data(name='data', shape=[32, 32], dtype='float32')
+    data = fluid.layers.data(name='data', shape=[1], dtype='float32',
+                         append_batch_size=False)
    data = fluid.layers.increment(x=data, value=3.0, in_place=True)
 
 
@@ -850,7 +858,7 @@ data
        2.如果维度shape包含-1，比如shape=[-1,1],
        “append_batch_size则为False（表示无效）”

-    - **dtype** (int|float)-数据类型：float32,float_16,int等
+    - **dtype** (basestring)-数据类型：float32,float_16,int等
    - **type** (VarType)-输出类型。默认为LOD_TENSOR
    - **lod_level** (int)-LoD层。0表示输入数据不是一个序列
    - **stop_gradient** (bool)-布尔类型，提示是否应该停止计算梯度
@@ -1214,7 +1222,7 @@ read_file
 reader也是变量。可以为由fluid.layers.open_files()生成的原始reader或者由fluid.layers.double_buffer()生成的装饰变量，等等。

 参数：
-    **reader** (Variable)-将要执行的reader
+    - **reader** (Variable)-将要执行的reader

 返回：从给定的reader中读取数据

@@ -1246,13 +1254,14 @@ shuffle

 .. py:function:: paddle.fluid.layers.shuffle(reader, buffer_size)

-使用python装饰器用shuffle 装饰 reader
+创建一个特殊的数据读取器，它的输出数据会被重洗(shuffle)。由原始读取器创建的迭代器得到的输出将会被暂存到shuffle缓存区，其后
+会对其进行重洗运算。shuffle缓存区的大小由参数 ``buffer_size`` 决定。

 参数:
    - **reader** (Variable) – 用shuffle装饰的reader
    - **buffer_size** (int) – reader中buffer的大小

-返回:用shuffle装饰后的reader
+返回:其输出会被重洗的一个reader（读取器）

 返回类型:Variable

@@ -2002,7 +2011,7 @@ conv2d_transpose
 其中：
    -  :math:`X` : 输入张量，具有 ``NCHW`` 格式

-    -  :math:`W` : 滤波器张量，，具有 ``NCHW`` 格式
+    -  :math:`W` : 滤波器张量，具有 ``NCHW`` 格式

    -  :math:`*` : 卷积操作

@@ -2492,16 +2501,15 @@ ctc_greedy_decoder
 .. py:function:: paddle.fluid.layers.ctc_greedy_decoder(input, blank, name=None)

 此op用于贪婪策略解码序列，步骤如下:
+    1. 获取输入中的每一行的最大值索引，也就是numpy.argmax(input, axis=0)。
+    2. 对于step1结果中的每个序列，在两个空格之间合并重复部分（即合并重复的上一步中的到的索引值）并删除所有空格。

-    1. 获取输入中的每一行的最大值索引。又名numpy.argmax(input, axis=0)。
-    2. 对于step1结果中的每个序列，在两个空格之间合并重复token并删除所有空格。

+简单举一个例子，

-A simple example as below:
-
-  ::
+::

-        Given:
+        已知：

        input.data = [[0.6, 0.1, 0.3, 0.1],
                      [0.3, 0.2, 0.4, 0.1],
@@ -2515,7 +2523,14 @@ A simple example as below:

        input.lod = [[4, 4]]

-        Then:
+        计算过程：
+
+        1. 将argmax的运算结果应用于输入的第一个序列，即 input.data[0:4] 。
+           则得出的结果为[[0], [2], [1], [0]]
+        2. 合并重复的索引值部分，删除空格，即为0的值。
+           则第一个输入序列对应的输出为：[[2], [1]]
+
+        最后

        output.data = [[2],
                       [1],
@@ -2529,7 +2544,7 @@ A simple example as below:
        - **blank** (int) — Connectionist Temporal Classification (CTC) loss空白标签索引,  属于半开区间[0,num_classes + 1）。
        - **name** (str) — 此层的名称。可选。
   
-返回： CTC贪婪解码结果。如果结果中的所有序列都为空，则LoDTensor 为[-1]，其中LoD[[]] dims[1,1]。
+返回： CTC贪婪解码结果是一个形为(Lp,1)的二维张量，其中Lp是所有输出序列的长度之和。如果结果中的所有序列都为空，则输出LoDTensor 为[-1]，其中LoD[[]] 形为[1,1]。

 返回类型： 变量（Variable）
    
@@ -2606,23 +2621,30 @@ dropout操作
 丢弃或者保持x的每个元素独立。Dropout是一种正则化技术，通过在训练过程中阻止神经元节点间的联合适应性来减少过拟合。根据给定的丢弃概率dropout操作符随机将一些神经元输出设置为0，其他的仍保持不变。

 参数：
-    - **x** Variable）-输入张量
+    - **x** (Variable)-输入张量
    - **dropout_prob** (float)-设置为0的单元的概率
    - **is_test** (bool)-显示是否进行测试用语的标记
    - **seed** (int)-Python整型，用于创建随机种子。如果该参数设为None，则使用随机种子。注：如果给定一个整型种子，始终丢弃相同的输出单元。训练过程中勿用固定不变的种子。
    - **name** (str|None)-该层名称（可选）。如果设置为None,则自动为该层命名
-    - **dropout_implementation** (string)-[‘downgrade_in_infer’(defauld)|’upscale_in_train’] 
+    - **dropout_implementation** (string) -   [‘downgrade_in_infer’(defauld)|’upscale_in_train’] 
+      其中:
      1.downgrade_in_infer(default), 在预测时减小输出结果 
+
        train: out = input * mask 

        inference: out = input * dropout_prob 
-            (mask是一个张量，维度和输入维度相同，值为0或1，值为0的比例即为dropout_prob)
+
+        (mask是一个张量，维度和输入维度相同，值为0或1，值为0的比例即为 ``dropout_prob`` )
+        
      2.upscale_in_train, 增加训练时的结果
+
        train: out = input * mask / ( 1.0 - dropout_prob )

        inference: out = input 
-	    (make是一个张量，维度和输入维度相同，值为0或1，值为0的比例即为dropout_prob）
-            dropout操作符可以从程序中移除，程序变得高效。
+
+        (make是一个张量，维度和输入维度相同，值为0或1，值为0的比例即为 ``dropout_prob`` ）
+
+dropout操作符可以从程序中移除，程序变得高效。

 返回：带有x维的张量

@@ -2706,7 +2728,7 @@ dynamic_gru
    emb = fluid.layers.embedding(input=data, size=[dict_dim, emb_dim])
    hidden_dim = 512
    x = fluid.layers.fc(input=emb, size=hidden_dim * 3)
-    hidden = fluid.layers.dynamic_gru(input=x, dim=hidden_dim)
+    hidden = fluid.layers.dynamic_gru(input=x, size=hidden_dim)



@@ -2959,8 +2981,8 @@ edit_distance

 .. code-block:: python

-    x = fluid.layers.data(name='x', shape=[8], dtype='float32')
-    y = fluid.layers.data(name='y', shape=[7], dtype='float32')
+    x = fluid.layers.data(name='x', shape=[1], dtype='float32')
+    y = fluid.layers.data(name='y', shape=[1], dtype='float32')
    cost = fluid.layers.edit_distance(input=x,label=y)


@@ -3968,8 +3990,10 @@ sigmoid的分段线性逼近(https://arxiv.org/abs/1603.00391)，比sigmoid快

 **代码示例：**

+
 .. code-block:: python

+
    x = fluid.layers.data(name="x", shape=[3,10,32,32], dtype="float32")
    y = fluid.layers.hard_sigmoid(x, slope=0.3, offset=0.8)

@@ -4056,23 +4080,41 @@ hash
 hsigmoid
 -------------------------------

-.. py:function:: paddle.fluid.layers.hsigmoid(input, label, num_functiones, param_attr=None, bias_attr=None, name=None)
+.. py:function:: paddle.fluid.layers.hsigmoid(input, label, num_functiones, param_attr=None, bias_attr=None, name=None, path_table=None, path_code=None, is_custom=False, is_sparse=False)
+
+层次sigmod（ hierarchical sigmoid ）加速语言模型的训练过程。这个operator将类别组织成一个完全二叉树，也可以使用 ``is_custom`` 参数来传入自定义的树结构来实现层次化。 
+
+树中每个叶节点表示一个类(一个单词)，每个内部节点进行一个二分类。对于每个单词，都有一个从根到它的叶子节点的唯一路径，hsigmoid计算路径上每个内部节点的损失（cost），并将它们相加得到总损失（cost）。
+
+hsigmoid可以把时间复杂度 :math:`O(N)` 优化到 :math:`O(logN)` ,其中 :math:`N` 表示单词字典的大小。
+
+使用默认树结构，请参考 `Hierarchical Probabilistic Neural Network Language Model <http://www.iro.umontreal.ca/~lisa/pointeurs/hierarchical-nnlm-aistats05.pdf>`_ 。
+
+若要使用自定义树结构，请设置 ``is_custom`` 值为True。但在此之前，请完成以下几步部署：

-层次sigmod（ hierarchical sigmoid ）加速语言模型的训练过程。这个operator将类别组织成一个完整的二叉树，每个叶节点表示一个类(一个单词)，每个内部节点进行一个二分类。对于每个单词，都有一个从根到它的叶子节点的唯一路径，hsigmoid计算路径上每个内部节点的损失（cost），并将它们相加得到总损失（cost）。hsigmoid可以把时间复杂度 :math:`O(N)` 优化到 :math:`O(logN)` ,其中 :math:`N` 表示单词字典的大小。
+1.使用自定义词典来建立二叉树，每个叶结点都应该是词典中的单词

-`请参考 Hierarchical Probabilistic Neural Network Language Model <http://www.iro.umontreal.ca/~lisa/pointeurs/hierarchical-nnlm-aistats05.pdf>`_
+2.建立一个dict类型数据结构，来存储 **单词id -> 该单词叶结点至根节点路径** 的映射，称之为路径表 ``path_table`` 参数
+
+3.建立一个dict类型数据结构，来存储 **单词id -> 该单词叶结点至根节点路径的编码(code)** 的映射。 编码code是指每次二分类的标签，1为真，0为假
+
+4.现在我们的每个单词都已经有自己的路径和路径编码，当对于同一批输入进行操作时，你可以同时传入一批路径和路径编码进行运算。

 参数:
    - **input** (Variable) - 输入张量，shape为 ``[N×D]`` ,其中 ``N`` 是minibatch的大小，D是特征大小。
    - **label** (Variable) - 训练数据的标签。该tensor的shape为 ``[N×1]``   
-    - **num_classes** (int) - 类别的数量不能少于2
+    - **num_classes** (int) - 类别的数量不能少于2。若使用默认树结构，该参数必须用户设置。当 ``is_custom=False`` 时，该项绝不能为None。反之，如果 ``is_custom=True`` ，它取值应为非叶节点的个数，来指明二分类实用的类别数目。
    - **param_attr** (ParamAttr|None) - 可学习参数/ hsigmoid权重的参数属性。如果将其设置为ParamAttr的一个属性或None，则将ParamAttr设置为param_attr。如果没有设置param_attr的初始化器，那么使用用Xavier初始化。默认值:没None。
    - **bias_attr** (ParamAttr|bool|None) - hsigmoid偏置的参数属性。如果设置为False，则不会向输出添加偏置。如果将其设置ParamAttr的一个属性或None，则将ParamAttr设置为bias_attr。如果没有设置bias_attr的初始化器，偏置将初始化为零。默认值:None。
    - **name** (str|None) - 该layer的名称(可选)。如果设置为None，该层将被自动命名。默认值:None。
+    - **path_table** (Variable|None) – 存储每一批样本从词到根节点的路径。路径应为从叶至根方向。 ``path_table`` 和 ``path_code`` 应具有相同的形, 对于每个样本 i ，path_table[i]为一个类似np.array的结构，该数组内的每个元素都是其双亲结点权重矩阵的索引
+    - **path_code** (Variable|None) – 存储每批样本的路径编码，仍然是按从叶至根方向。各样本路径编码批都由其各祖先结点的路径编码组成
+    - **is_custom** (bool|False) – 使用用户自定义二叉树取代默认二叉树结构，如果该项为真， 请务必设置 ``path_table`` , ``path_code`` , ``num_classes`` , 否则就需要设置 num_classes 
+    - **is_sparse** (bool|False) – 使用稀疏更新方式，而非密集更新。如果为真， W的梯度和输入梯度将会变得稀疏

-    返回:  (Tensor) 层次sigmod（ hierarchical sigmoid） 。shape[N, 1]
+返回:  (LoDTensor) 层次sigmod（ hierarchical sigmoid） 。shape[N, 1]
    
-    返回类型:  Out
+返回类型:  Out


 **代码示例**
@@ -4185,7 +4227,7 @@ im2sequence
 image_resize
 -------------------------------

-.. py:function:: paddle.fluid.layers.image_resize(input, out_shape=None, scale=None, name=None, resample='BILINEAR')
+.. py:function:: paddle.fluid.layers.image_resize(input, out_shape=None, scale=None, name=None, resample='BILINEAR', actual_shape=None)

 调整一批图片的大小
    
@@ -4790,6 +4832,7 @@ logical_or算子

 .. code-block:: python

+
    left = fluid.layers.data(
        name='left', shape=[1], dtype='int32')
    right = fluid.layers.data(
@@ -5408,7 +5451,7 @@ multiplex
 nce
 -------------------------------

-.. py:function:: paddle.fluid.layers.nce(input, label, num_total_functiones, sample_weight=None, param_attr=None, bias_attr=None, num_neg_samples=None, name=None)
+.. py:function:: paddle.fluid.layers.nce(input, label, num_total_functiones, sample_weight=None, param_attr=None, bias_attr=None, num_neg_samples=None, name=None, sampler='uniform', custom_dist=None, seed=0, is_sparse=False)

 计算并返回噪音对比估计（ noise-contrastive estimation training loss）。
 `请参考 See Noise-contrastive estimation: A new estimation principle for unnormalized statistical models 
@@ -5416,14 +5459,18 @@ nce
 该operator默认使用均匀分布进行抽样。

 参数:
-	- **input** (Variable) -  特征
+    - **input** (Variable) -  输入变量
    - **label** (Variable) -  标签
    - **num_total_classes** (int) - 所有样本中的类别的总数
    - **sample_weight** (Variable|None) - 存储每个样本权重，shape为[batch_size, 1]存储每个样本的权重。每个样本的默认权重为1.0
-    	- **param_attr** (ParamAttr|None) - 可学习参数/ nce权重的参数属性。如果它没有被设置为ParamAttr的一个属性，nce将创建ParamAttr为param_attr。如没有设置param_attr的初始化器，那么参数将用Xavier初始化。默认值:None
+    - **param_attr** (ParamAttr|None) - :math:`可学习参数/nce权重` 的参数属性。如果它没有被设置为ParamAttr的一个属性，nce将创建ParamAttr为param_attr。如没有设置param_attr的初始化器，那么参数将用Xavier初始化。默认值:None
    - **bias_attr** (ParamAttr|bool|None) -  nce偏置的参数属性。如果设置为False，则不会向输出添加偏置（bias）。如果值为None或ParamAttr的一个属性，则bias_attr=ParamAtt。如果没有设置bias_attr的初始化器，偏置将被初始化为零。默认值:None
    - **num_neg_samples** (int) - 负样例的数量。默认值是10
    - **name** (str|None) - 该layer的名称(可选)。如果设置为None，该层将被自动命名
+    - **sampler** (str) – 取样器，用于从负类别中进行取样。可以是 ‘uniform’, ‘log_uniform’ 或 ‘custom_dist’。 默认 ‘uniform’
+    - **custom_dist** (float[]) – 一个 float[] 并且它的长度为 ``num_total_classes`` 。  如果取样器类别为‘custom_dist’，则使用此参数。 custom_dist[i] 是第i个类别被取样的概率。默认为 None
+    - **seed** (int) – 取样器使用的seed。默认为0
+    - **is_sparse** (bool) – 标志位，指明是否使用稀疏更新,  :math:`weight@GRAD` 和 :math:`bias@GRAD` 会变为 SelectedRows

 返回：	nce loss

@@ -5457,6 +5504,15 @@ nce
 					  num_total_classes=dict_size, param_attr='nce.w',
 					  bias_attr='nce.b')

+		#使用custom distribution
+		dist = fluid.layers.assign(input=np.array([0.05,0.5,0.1,0.3,0.05]).astype("float32"))
+		loss = layers.nce(input=embs, label=words[label_word],
+					  num_total_classes=5, param_attr='nce.w',
+					  bias_attr='nce.b',
+					  num_neg_samples=3,
+					  sampler="custom_dist",
+					  custom_dist=dist)
+



@@ -5691,7 +5747,7 @@ pad_constant_like
 pool2d
 -------------------------------

-.. py:function:: paddle.fluid.layers.pool2d(input, pool_size=-1, pool_type='max', pool_stride=1, pool_padding=0, global_pooling=False, use_cudnn=True, ceil_mode=False, name=None)
+.. py:function:: paddle.fluid.layers.pool2d(input, pool_size=-1, pool_type='max', pool_stride=1, pool_padding=0, global_pooling=False, use_cudnn=True, ceil_mode=False, name=None, exclusive=True)

 pooling2d操作符根据 ``input`` ， 池化类型 ``pool_type`` ， 池化核大小 ``pool_size`` , 步长 ``pool_stride`` ，填充 ``pool_padding`` 这些参数得到输出。

@@ -5702,10 +5758,10 @@ pooling2d操作符根据 ``input`` ， 池化类型 ``pool_type`` ， 池化核
 例如：

 输入：
-    X shape：:math:`\left ( N,C_{in},H_{in},W_{in} \right )`
+    X shape：:math:`\left ( N,C,H_{in},W_{in} \right )`

 输出：
-    Out shape：:math:`\left ( N,C_{out},H_{out},W_{out} \right )`
+    Out shape：:math:`\left ( N,C,H_{out},W_{out} \right )`

 如果 ``ceil_mode`` = false：

@@ -5738,21 +5794,22 @@ pooling2d操作符根据 ``input`` ， 池化类型 ``pool_type`` ， 池化核
    hstart &= max(0, i * strides[0] - paddings[0])\\
    hend &= min(H, hstart + ksize[0]) \\
    wstart &= max(0, j * strides[1] - paddings[1]) \\
-    wend & = min(W, wstart + ksize[1]) Output(i ,j) \\
-         & = \frac{sum(Input[hstart:hend, wstart:wend])}{(hend - hstart) * (wend - wstart)}
+    wend & = min(W, wstart + ksize[1]) \\
+    Output(i ,j) & = \frac{sum(Input[hstart:hend, wstart:wend])}{(hend - hstart) * (wend - wstart)}



 参数：
    - **input** (Variable) - 池化操作的输入张量。输入张量格式为NCHW，N为批尺寸，C是通道数，H是特征高度，W是特征宽度
-    - **pool_size** (int) - 池化窗口的边长。如果它是一个元组或列表，它必须包含两个整数值， (pool_size_Height, pool_size_Width)。否则它应是一个整数的平方值。
+    - **pool_size** (int|list|tuple)  - 池化窗口的大小。如果它是一个元组或列表，它必须包含两个整数值， (pool_size_Height, pool_size_Width)。否则它应是一个整数的平方值。
    - **pool_type** (string) - 池化类型，可以是“max”对应max-pooling，“avg”对应average-pooling
-    - **pool_stride** (int) - 池化层的步长。如果它是一个元组或列表，它将包含两个整数，(pool_stride_Height, pool_stride_Width)。否则它是一个整数的平方值。
-    - **pool_padding** (int) - 填充大小。如果它是一个元组或列表，它必须包含两个整数值，(pool_padding_on_Height, pool_padding_on_Width)。否则它是一个整数的平方值。
-    - **global_pooling** （bool，默认false）- 是否用全局池化。如果global_pooling = true，ksize和填充（padding）则被忽略
+    - **pool_stride** (int|list|tuple)  - 池化层的步长。如果它是一个元组或列表，它将包含两个整数，(pool_stride_Height, pool_stride_Width)。否则它是一个整数的平方值。
+    - **pool_padding** (int|list|tuple) - 填充大小。如果它是一个元组或列表，它必须包含两个整数值，(pool_padding_on_Height, pool_padding_on_Width)。否则它是一个整数的平方值。
+    - **global_pooling** （bool，默认false）- 是否用全局池化。如果global_pooling = true， ``pool_size`` 和 ``pool_padding`` 将被忽略。
    - **use_cudnn** （bool，默认false）- 只在cudnn核中用，需要下载cudnn
    - **ceil_mode** （bool，默认false）- 是否用ceil函数计算输出高度和宽度。默认False。如果设为False，则使用floor函数
    - **name** （str|None） - 该层名称（可选）。若设为None，则自动为该层命名。
+    - **exclusive** (bool) - 是否在平均池化模式忽略填充值。默认为True。

 返回：池化结果

@@ -5789,20 +5846,21 @@ pooling2d操作符根据 ``input`` ， 池化类型 ``pool_type`` ， 池化核
 pool3d
 -------------------------------

-.. py:function:: paddle.fluid.layers.pool3d(input, pool_size=-1, pool_type='max', pool_stride=1, pool_padding=0, global_pooling=False, use_cudnn=True, ceil_mode=False, name=None)
+.. py:function:: paddle.fluid.layers.pool3d(input, pool_size=-1, pool_type='max', pool_stride=1, pool_padding=0, global_pooling=False, use_cudnn=True, ceil_mode=False, name=None， exclusive=True)

 函数使用上述输入参数的池化配置，为三维空间添加池化操作

 参数：
-    - **input** (Vairable) - 池化的输入张量。输入张量的格式为NCHW, N是批尺寸，C是通道数，N是特征高度，W是特征宽度。
-    - **pool_size** (int) - 池化窗口的边长。所有对池化窗口都是正方形，边长为pool_size。
-    - **pool_type** (str) - 池化类型，``ma``对应max-pooling,``avg``对应average-pooling。
-    - **pool_stride** (int) - 跨越步长
-    - **pool_padding** (int) - 填充大小
-    - **global_pooling** (bool) - 是否使用全局池化。如果global_pooling = true,ksize and paddings将被忽略。
-    - **use_cudnn** (bool) - 是否用cudnn核，只有在cudnn库安装时有效
+    - **input** (Vairable) - 池化运算的输入张量。输入张量的格式为NCDHW, N是批尺寸，C是通道数，D是特征深度，H是特征高度，W是特征宽度。
+    - **pool_size** (int|list|tuple) - 池化窗口的大小。如果为元组类型，那么它应该是由三个整数组成：深度，高度，宽度。如果是int类型，它应该是一个整数的立方。
+    - **pool_type** (str) - 池化类型， "max" 对应max-pooling, "avg" 对应average-pooling。
+    - **pool_stride** (int|list|tuple) - 池化跨越步长。如果为元组类型，那么它应该是由三个整数组成：深度，高度，宽度。如果是int类型，它应该是一个整数的立方。
+    - **pool_padding** (int|list|tuple) - 填充大小。如果为元组类型，那么它应该是由三个整数组成：深度，高度，宽度。如果是int类型，它应该是一个整数的立方。
+    - **global_pooling** (bool) - 是否使用全局池化。如果global_pooling = true, ``pool_size`` 和 ``pool_padding`` 将被忽略。
+    - **use_cudnn** (bool) - 是否用cudnn核，只有在cudnn库安装时有效。
    - **ceil_mode** (bool) - 是否用ceil函数计算输出高度和宽度。默认False。如果设为False，则使用floor函数。
    - **name** (str) - 该层名称（可选）。若为空，则自动为该层命名。
+    - **exclusive** (bool) - 是否在平均池化模式忽略填充值。默认为True。

 返回：pool3d层的输出

@@ -6346,7 +6404,9 @@ reshape
 resize_bilinear
 -------------------------------

-.. py:function:: paddle.fluid.layers.resize_bilinear(input, out_shape=None, scale=None, name=None)
+.. py:function:: paddle.fluid.layers.resize_bilinear(input, out_shape=None, scale=None, name=None, actual_shape=None)
+
+根据指定的out_shape执行双线性插值调整输入大小，输出形状按优先级由actual_shape、out_shape和scale指定。

 根据指定的out_shape执行双线性插值调整输入大小，输出形状按优先级由actual_shape、out_shape和scale指定。

@@ -7087,7 +7147,7 @@ sequence_mask
 sequence_pad
 -------------------------------

-.. py:function:: paddle.fluid.layers.sequence_pad(x,pad_value,maxlen=None)
+.. py:function:: paddle.fluid.layers.sequence_pad(x,pad_value,maxlen=None,name=None)

 序列填充操作符（Sequence Pad Operator）

@@ -7097,7 +7157,6 @@ sequence_pad

 ::

-
    例1:

    给定 1-level LoDTensor
@@ -7114,6 +7173,8 @@ sequence_pad
        Out.data = [[a,b,0,0],[c,d,e,0]]
        Length.data = [[2],[3]]

+::
+
    例2:
    
    给定 1-level LoDTensor
@@ -7130,6 +7191,9 @@ sequence_pad
        Out.data = [[[a1,a2],[b1,b2],[0,0]],[[c1,c2],[d1,d2],[e1,e2]]]
        Length.data = [[2],[3]]

+
+::
+
    例3:
    
    给定 1-level LoDTensor
@@ -7146,12 +7210,14 @@ sequence_pad
        Out.data = [[[a1,a2],[b1,b2],[p1,p2]],[[c1,c2],[d1,d2],[e1,e2]]]
        Length.data = [[2],[3]]

+
 参数：
    - **x** (Vairable) - 输入变量，应包含lod信息
    - **pad_value** (Variable) - 变量，存有放入填充步的值。可以是标量或tensor,维度和序列的时间步长相等。如果是标量,则自动广播到时间步长的维度
    - **maxlen** (int,默认None) - 填充序列的长度。可以为空或者任意正整数。当为空时，以序列中最长序列的长度为准，其他所有序列填充至该长度。当是某个特定的正整数，最大长度必须大于最长初始序列的长度
+    - **name** (str|None) – 该层的命名(可选项)。 如果为 None, 则自动命名

-返回：填充序列批（batch）和填充前的初始长度。所有序列的长度相等
+返回：填充序列批（batch）和填充前的初始长度。所有输出序列的长度相等

 返回类型：变量（Variable）

@@ -7163,7 +7229,8 @@ sequence_pad

    x = fluid.layers.data(name='y', shape=[10, 5],
                     dtype='float32', lod_level=1)
-    pad_value = fluid.layers.assign(input=numpy.array([0]))
+    pad_value = fluid.layers.assign(
+        input=numpy.array([0.0], dtype=numpy.float32))
    out = fluid.layers.sequence_pad(x=x, pad_value=pad_value)


@@ -7179,7 +7246,7 @@ sequence_pad
 sequence_pool 
 -------------------------------

-.. py:function:: paddle.fluid.layers.sequence_pool(input, pool_type)
+.. py:function:: paddle.fluid.layers.sequence_pool(input, pool_type, is_test=False)

 该函数为序列的池化添加操作符。将每个实例的所有时间步数特征池化，并用参数中提到的pool_type将特征运用到输入到首部。

@@ -7212,6 +7279,7 @@ sequence_pool
 参数：
    - **input** (variable) - 输入变量，为LoDTensor
    - **pool_type** (string) - 池化类型。支持average,sum,sqrt和max
+    - **is_test** (bool, 默认为 False) - 用于区分训练模式和测试评分模式

 返回：sequence pooling 变量，类型为张量（Tensor)

@@ -7906,7 +7974,7 @@ softmax操作符计算k维向量输入中所有其他维的指数和指数值的
 softmax_with_cross_entropy
 -------------------------------

-.. py:function:: paddle.fluid.layers.softmax_with_cross_entropy(logits, label, soft_label=False, ignore_index=-100)
+.. py:function:: paddle.fluid.layers.softmax_with_cross_entropy(logits, label, soft_label=False, ignore_index=-100, numeric_stable_mode=False, return_softmax=False)

 使用softmax的交叉熵在输出层已被广泛使用。该函数计算输入张量每一行的softmax标准化值，而后计算交叉熵。通过此种方式，可以得到更具数字稳定性的梯度值。

@@ -7926,16 +7994,27 @@ softmax_with_cross_entropy
 .. math::
   loss_j =  -\sum_{i=0}^{K}\text{label}_i\left(\text{logit}_i - \log\left(\sum_{i=0}^{K}\exp(\text{logit}_i)\right)\right), j = 1,...,K

+3.如果 ``numeric_stable_mode`` 为真，在通过softmax和标签计算交叉熵损失前， softmax 首先经由下式计算得出：
+
+.. math::
+    max_j           &= \max_{i=0}^{K}{\text{logit}_i} \\
+    log\_max\_sum_j &= \log\sum_{i=0}^{K}\exp(logit_i - max_j)\\
+    softmax_j &= \exp(logit_j - max_j - {log\_max\_sum}_j)
+

 参数:
  - **logits** (Variable) - 未标准化(unscaled)的log概率,一个形为 N X K 的二维张量。 N是batch大小，K是类别总数
  - **label** (Variable) - 2-D 张量，代表了正确标注（ground truth）, 如果 ``soft_label`` 为  False，则该参数是一个形为 N X 1 的Tensor<int64> 。如果 ``soft_label`` 为 True，它是 Tensor<float/double> ，形为 N X K
  - **soft_label** (bool) - 是否将输入标签当作软标签。默认为False
  - **ignore_index** (int) - 指明要无视的目标值，使之不对输入梯度有贡献。仅在 ``soft_label`` 为False时有效，默认为-100 
+  - **numeric_stable_mode** (bool) – 标志位，指明是否使用一个具有更佳数学稳定性的算法。仅在 ``soft_label`` 为 False的GPU模式下生效. 若 ``soft_label`` 为 True 或者执行场所为CPU, 算法一直具有数学稳定性。 注意使用稳定算法时速度可能会变慢。默认为 False
+  - **return_softmax** (bool) – 标志位，指明是否额外返回一个softmax值， 同时返回交叉熵计算结果。默认为False

-返回： 交叉熵，一个形为[N x 1]的二维张量
+返回: 
+  - 如果 ``return_softmax`` 为 False， 则返回交叉熵，一个形为[N x 1]的二维张量
+  - 如果 ``return_softmax`` 为 True，则返回元组 (loss, softmax) ，其中交叉熵loss为形为[N x 1]的二维张量，softmax为[N x K]的二维张量

-返回类型:	Variable
+返回类型:变量或者两个变量组成的元组


 **代码示例**
@@ -8360,7 +8439,10 @@ transpose

 .. code-block:: python

-    x = fluid.layers.data(name='x', shape=[5, 10, 15], dtype='float32')
+    # 请使用 append_batch_size=False 来避免
+    # 在数据张量中添加多余的batch大小维度
+    x = fluid.layers.data(name='x', shape=[5, 10, 15],
+                    dtype='float32', append_batch_size=False)
    x_transposed = layers.transpose(x, perm=[1, 0, 2])


@@ -9590,21 +9672,21 @@ reverse

 .. py:function:: paddle.fluid.layers.reverse(x,axis)

-    **reverse**
+**reverse**

-    该功能将给定轴上的输入‘x’逆序
+该功能将给定轴上的输入‘x’逆序

-    参数：
+参数：
  - **x** (Variable)-预逆序到输入
  - **axis** (int|tuple|list)-其上元素逆序排列的轴。

-    返回：逆序的张量
+返回：逆序的张量

-    返回类型：变量（Variable）
+返回类型：变量（Variable）

-    **代码示例**：
+**代码示例**：

-    .. code-block:: python
+.. code-block:: python

        out = fluid.layers.reverse(x=in, axis=0)
        # or:
@@ -9734,6 +9816,7 @@ zeros
 **代码示例**：

 .. code-block:: python
+
    data = fluid.layers.zeros(shape=[1], dtype='int64')


@@ -9760,12 +9843,7 @@ append_LARS

 对每一层的学习率运用LARS(LAYER-WISE ADAPTIVE RATE SCALING)

-.. code-block python

-    .. math::
-
-        learning_rate*=local_gw_ratio * sqrt(sumsq(param))
-            / (sqrt(sumsq(gradient))+ weight_decay * sqrt(sumsq(param)))

 参数：
    - **learning_rate** -变量学习率。LARS的全局学习率。
@@ -9773,7 +9851,12 @@ append_LARS

 返回： 衰减的学习率

+**代码示例** :

+.. code-block:: python
+
+        learning_rate*=local_gw_ratio * sqrt(sumsq(param))
+            / (sqrt(sumsq(gradient))+ weight_decay * sqrt(sumsq(param)))



@@ -10455,9 +10538,9 @@ generate_proposals

 .. py:function:: paddle.fluid.layers.generate_proposals(scores, bbox_deltas, im_info, anchors, variances, pre_nms_top_n=6000, post_nms_top_n=1000, nms_thresh=0.5, min_size=0.1, eta=1.0, name=None) 

-生成proposal标签的Faster-RCNN
+生成proposal的Faster-RCNN

-该操作根据每个框的概率为foreground对象，并且可以通过锚（anchors）来计算框来产生RoI。Bbox_deltais和一个objects的分数作为是RPN的输出。最终 ``proposals`` 可用于训练检测网络。
+该操作根据每个框为foreground（前景）对象的概率，并且通过锚（anchors）来计算这些框，进而提出RoI。Bbox_deltais和一个objects的分数作为是RPN的输出。最终 ``proposals`` 可用于训练检测网络。

 为了生成 ``proposals`` ，此操作执行以下步骤：

@@ -10506,7 +10589,6 @@ iou_similarity
 计算两个框列表的intersection-over-union(IOU)。框列表‘X’应为LoDTensor，‘Y’是普通张量，X成批输入的所有实例共享‘Y’中的框。给定框A和框B，IOU的运算如下：

 .. math::
-
    IOU(A, B) = \frac{area(A\cap B)}{area(A)+area(B)-area(A\cap B)}

 参数：
@@ -10729,11 +10811,11 @@ rpn_target_assign

 对于给定anchors和真实框之间的IoU重叠，该层可以为每个anchors做分类和回归，这些target labels用于训练RPN。classification targets是二进制的类标签（是或不是对象）。根据Faster-RCNN的论文，positive labels有两种anchors：

-        （i）anchor/anchors与真实框具有最高IoU重叠；
+(i) anchor/anchors与真实框具有最高IoU重叠；

-        （ii）具有IoU重叠的anchors高于带有任何真实框（ground-truth box）的rpn_positive_overlap0（0.7）。
+(ii) 具有IoU重叠的anchors高于带有任何真实框（ground-truth box）的rpn_positive_overlap0（0.7）。

-        请注意，单个真实框（ground-truth box）可以为多个anchors分配正标签。对于所有真实框（ground-truth box），非正向锚是指其IoU比率低于rpn_negative_overlap（0.3）。既不是正也不是负的anchors对训练目标没有价值。回归目标是与positive anchors相关联而编码的图片真实框。
+请注意，单个真实框（ground-truth box）可以为多个anchors分配正标签。对于所有真实框（ground-truth box），非正向锚是指其IoU比率低于rpn_negative_overlap（0.3）。既不是正也不是负的anchors对训练目标没有价值。回归目标是与positive anchors相关联而编码的图片真实框。

 参数：
        - **bbox_pred** （Variable）- 是一个shape为[N，M，4]的3-D Tensor，表示M个边界框的预测位置。N是批量大小，每个边界框有四个坐标值，即[xmin，ymin，xmax，ymax]。
@@ -10749,7 +10831,13 @@ rpn_target_assign
        - **rpn_positive_overlap** （float）- 对于一个正例的（anchor, gt box）对，是允许anchors和所有真实框之间最小重叠的。
        - **rpn_negative_overlap** （float）- 对于一个反例的（anchor, gt box）对，是允许anchors和所有真实框之间最大重叠的。

-返回：        返回元组（predict_scores，predict_location，target_label，target_bbox）。predict_scores和predict_location是RPN的预测结果。 target_label和target_bbox分别是ground-truth。 predict_location是一个shape为[F，4]的2D Tensor， ``target_bbox`` 的shape与 ``predict_location`` 的shape相同，F是foreground anchors的数量。 ``predict_scores`` 是一个shape为[F + B，1]的2D Tensor， ``target_label`` 的shape与 ``predict_scores`` 的shape相同，B是background anchors的数量，F和B取决于此算子的输入。
+返回:
+
+返回元组 (predicted_scores, predicted_location, target_label, target_bbox, bbox_inside_weight) : 
+   - **predicted_scores** 和 **predicted_location** 是RPN的预测结果。 **target_label** 和 **target_bbox** 分别是真实准确数据(ground-truth)。 
+   - **predicted_location** 是一个形为[F，4]的2D Tensor， **target_bbox** 的形与 **predicted_location** 相同，F是foreground anchors的数量。 
+   - **predicted_scores** 是一个shape为[F + B，1]的2D Tensor， **target_label** 的形与 **predict_scores** 的形相同，B是background anchors的数量，F和B取决于此算子的输入。 
+   - **Bbox_inside_weight** 标志着predicted_loction是否为fake_fg（假前景），其形为[F,4]。

 返回类型：        元组(tuple)

@@ -10766,7 +10854,7 @@ rpn_target_assign
                append_batch_size=False, dtype=’float32’)
        gt_boxes = layers.data(name=’gt_boxes’, shape=[10, 4],
                append_batch_size=False, dtype=’float32’)
-        loc_pred, score_pred, loc_target, score_target =
+        loc_pred, score_pred, loc_target, score_target, bbox_inside_weight=
                fluid.layers.rpn_target_assign(bbox_pred=bbox_pred,
                        cls_logits=cls_logits, anchor_box=anchor_box, gt_boxes=gt_boxes)
        
@@ -11000,8 +11088,9 @@ auc

 有两种可能的曲线：

-    1. ROC:受试者工作特征曲线
-    2. PR:准确率召回率曲线
+1. ROC:受试者工作特征曲线
+
+2. PR:准确率召回率曲线

 参数：
    - **input** (Variable) - 浮点二维变量，值的范围为[0,1]。每一行降序排列。输入应为topk的输出。该变量显示了每个标签的概率。
@@ -11019,7 +11108,7 @@ auc

 .. code-block:: python

-    # network is a binary classification model and label the ground truth
+    #  network为二分类模型, label为ground truth（正确标记）
    prediction = network(image, is_infer=True)
    auc_out=fluid.layers.auc(input=prediction, label=label)


--- a/doc/fluid/api_cn/metrics_cn.rst
+++ b/doc/fluid/api_cn/metrics_cn.rst
@@ -196,7 +196,7 @@ CompositeMetric
 DetectionMAP
 -------------------------------

-.. py:class:: paddle.fluid.metrics.DetectionMAP(name=None)
+.. py:class:: paddle.fluid.metrics.DetectionMAP(input, gt_label, gt_box, gt_difficult=None, class_num=None, background_label=0, overlap_threshold=0.5, evaluate_difficult=True, ap_version='integral')

 计算 detection 平均精度（mAP）。 mAP是衡量object detectors精度的指标，比如 Faster R-CNN,SSD等。它不同于召回率，它是最大精度的平均值。 请从以下文章中获取更多信息：


--- a/doc/fluid/api_cn/nets_cn.rst
+++ b/doc/fluid/api_cn/nets_cn.rst
@@ -159,7 +159,7 @@ attention运算机制可以被视为将查询和一组键值对映射到输出
 sequence_conv_pool
 -------------------------------

-.. py:function:: paddle.fluid.nets.sequence_conv_pool(input, num_filters, filter_size, param_attr=None, act='sigmoid', pool_type='max')
+.. py:function:: paddle.fluid.nets.sequence_conv_pool(input, num_filters, filter_size, param_attr=None, act='sigmoid', pool_type='max', bias_attr=None)

 sequence_conv_pool由序列卷积和池化组成


--- a/doc/fluid/beginners_guide/install/Tables.md
+++ b/doc/fluid/beginners_guide/install/Tables.md
@@ -363,7 +363,8 @@ PaddePaddle通过编译时指定路径来实现引用各种BLAS/CUDA/cuDNN库。

 <a name="ciwhls-release"></a>
 </br></br>
-## **多版本whl包列表-v1.2**
+
+## **多版本whl包列表-Release**

 <p align="center">
 <table>

--- a/doc/fluid/beginners_guide/install/index_cn.rst
+++ b/doc/fluid/beginners_guide/install/index_cn.rst
 ==========
 安装说明
 ==========
-本说明将指导您在64位台式机或笔记本电脑上, 使用Python2.7或者Python3.5编译和安装PaddlePaddle，目前PaddlePaddle支持以下环境：
+本说明将指导您在64位台式机或笔记本电脑上编译和安装PaddlePaddle
+
+PaddlePaddle目前支持的Python版本包括：Python 2.7-3.7
+
+PaddlePaddle目前支持以下环境：

 * *Ubuntu 14.04 /16.04 /18.04*
 * *CentOS 7 / 6*

--- a/doc/fluid/beginners_guide/install/install_CentOS.md
+++ b/doc/fluid/beginners_guide/install/install_CentOS.md
@@ -6,7 +6,7 @@



-请注意：在其他系统上的尝试可能会导致安装失败。请确保您的环境满足以上条件，我们默认提供的安装同时需要您的计算机处理器支持AVX指令集，否则请选择[多版本whl包安装列表](Tables.html/#ciwhls)中`no_avx`的版本。
+请注意：在其他系统上的尝试可能会导致安装失败。请确保您的环境满足以上条件，我们默认提供的安装同时需要您的计算机处理器支持AVX指令集，否则请选择[[最新Release安装包列表](./Tables.html/#ciwhls-release)中`no_avx`的版本。

 CentOS系统下您可以使用`cat /proc/cpuinfo | grep avx`来检测您的处理器是否支持AVX指令集

@@ -48,17 +48,6 @@ CentOS系统下您可以使用`cat /proc/cpuinfo | grep avx`来检测您的处
 <br/><br/>
 ### ***使用pip安装PaddlePaddle***

-您可以直接粘贴以下命令到命令行来安装PaddlePaddle(适用于CentOS7安装CPU-ONLY的版本)，如果出现问题，您可以参照后面的解释对命令作出适应您系统的更改：
-
-Python2.7：
-		
-	yum update && yum install -y epel-release && yum install -y python-devel python-pip && pip install paddlepaddle     
-	    
-	
-Python3.5、3.6、3.7: (由于在CentOS下安装Python3的方法较为复杂，我们提供默认您已经正确安装python3.5+以及pip3之后的安装命令）
-	
-	yum update && yum install -y epel-release && pip3 install paddlepaddle     
-	

 首先，我们使用以下指令来**检测本机的环境**是否适合安装PaddlePaddle：

@@ -101,7 +90,7 @@ Python3.5、3.6、3.7: (由于在CentOS下安装Python3的方法较为复杂，

 	* 对于有**其他要求**的用户：`pip install paddlepaddle==[版本号]`  或 `pip3 install paddlepaddle==[版本号]`

-	> `版本号`参见[安装包列表](./Tables.html/#whls)或者您如果需要获取并安装**最新的PaddlePaddle开发分支**，可以从[多版本whl包列表](./Tables.html/#ciwhls)或者我们的[CI系统](https://paddleci.ngrok.io/project.html?projectId=Manylinux1&tab=projectOverview) 中下载最新的whl安装包和c-api开发包并安装。如需登录，请点击“Log in as guest”。
+	> `版本号`参见[最新Release安装包列表](./Tables.html/#whls)或者您如果需要获取并安装**最新的PaddlePaddle开发分支**，可以从[[最新dev安装包列表](./Tables.html/#ciwhls)或者我们的[CI系统](https://paddleci.ngrok.io/project.html?projectId=Manylinux1&tab=projectOverview) 中下载最新的whl安装包和c-api开发包并安装。如需登录，请点击“Log in as guest”。



@@ -131,7 +120,7 @@ Python3.5、3.6、3.7: (由于在CentOS下安装Python3的方法较为复杂，

 	* 对于需要**CPU版本的PaddlePaddle**的用户请使用以下指令拉取我们为您预安装好*PaddlePaddle For CPU*的镜像：

-		`docker pull hub.baidubce.com/paddlepaddle/paddle:1.1`       
+		`docker pull hub.baidubce.com/paddlepaddle/paddle:1.2`

 	* 您也可以通过以下指令拉取任意的我们提供的Docker镜像：


--- a/doc/fluid/beginners_guide/install/install_MacOS.md
+++ b/doc/fluid/beginners_guide/install/install_MacOS.md
@@ -59,7 +59,7 @@

 	* 对于有**其他要求**的用户：`pip install paddlepaddle==[版本号]`  或 `pip3 install paddlepaddle==[版本号]`

-	> `版本号`参见[安装包列表](./Tables.html/#whls)或者您如果需要获取并安装**最新的PaddlePaddle开发分支**，可以从[多版本whl包列表](./Tables.html/#ciwhls)或者我们的[CI系统](https://paddleci.ngrok.io/project.html?projectId=Manylinux1&tab=projectOverview) 中下载最新的whl安装包和c-api开发包并安装。如需登录，请点击“Log in as guest”。
+	> `版本号`参见[最新Release安装包列表](./Tables.html/#ciwhls-release)或者您如果需要获取并安装**最新的PaddlePaddle开发分支**，可以从[CI系统](https://paddleci.ngrok.io/project.html?projectId=Manylinux1&tab=projectOverview) 中下载最新的whl安装包和c-api开发包并安装。如需登录，请点击“Log in as guest”。



@@ -84,7 +84,7 @@

 	* 对于需要**CPU版本的PaddlePaddle**的用户请使用以下指令拉取我们为您预安装好*PaddlePaddle For CPU*的镜像：

-		`docker pull hub.baidubce.com/paddlepaddle/paddle:1.1`
+		`docker pull hub.baidubce.com/paddlepaddle/paddle:1.2`

 	* 您也可以通过以下指令拉取任意的我们提供的Docker镜像：


--- a/doc/fluid/beginners_guide/install/install_Ubuntu.md
+++ b/doc/fluid/beginners_guide/install/install_Ubuntu.md
@@ -6,7 +6,7 @@



-请注意：在其他系统上的尝试可能会导致安装失败。请确保您的环境满足以上条件，我们默认提供的安装同时需要您的计算机处理器支持AVX指令集，否则请选择[多版本whl包安装列表](Tables.html/#ciwhls)中`no_avx`的版本。
+请注意：在其他系统上的尝试可能会导致安装失败。请确保您的环境满足以上条件，我们默认提供的安装同时需要您的计算机处理器支持AVX指令集，否则请选择[最新Release安装包列表](./Tables.html/#ciwhls-release)中`no_avx`的版本。

 Ubuntu系统下您可以使用`cat /proc/cpuinfo | grep avx`来检测您的处理器是否支持AVX指令集

@@ -47,25 +47,7 @@ Ubuntu系统下您可以使用`cat /proc/cpuinfo | grep avx`来检测您的处
 <br/><br/>
 ### ***使用pip安装***

-#### ****直接安装****

-您可以直接粘贴以下命令到命令行来安装PaddlePaddle(适用于ubuntu16.04及以上安装CPU-ONLY的版本)，如果出现问题，您可以参照后面的解释对命令作出适应您系统的更改：
-
-Python2.7：
-
-	apt update && apt install -y python-dev python-pip && pip install paddlepaddle
-
-Python3.5（该指令适用于本机未安装python2的用户，否则，请卸载python2之后再使用本指令）： 
-  
-  apt-get udpate && apt-get install -y software-properties-common && add-apt-repository ppa:deadsnakes/ppa && apt-get install -y curl python3.5 python3.5-dev wget vim git && curl https://bootstrap.pypa.io/get-pip.py -o - | python3.5 && easy_install pip && pip3 install paddlepaddle
-	
-Python3.6、Python3.7：（由于版本相对较新，在不同Ubuntu版本上安装差异较大，不一一描述其安装过程，执行以下命令前，我们认为您已经准备好python3.6或3.7的环境，并安装了对应版本的python3-dev以及pip3）
-    
-    apt update && pip3 install paddlepaddle
-
-<br/>
-
-#### ****分步安装****
 首先，我们使用以下指令来**检测本机的环境**是否适合安装PaddlePaddle：

    uname -m && cat /etc/*release
@@ -108,7 +90,7 @@ Python3.6、Python3.7：（由于版本相对较新，在不同Ubuntu版本上

 	* 对于有**其他要求**的用户：`pip install paddlepaddle==[版本号]` 或 `pip3 install paddlepaddle==[版本号]`

-	> `版本号`参见[安装包列表](./Tables.html/#whls)或者您如果需要获取并安装**最新的PaddlePaddle开发分支**，可以从我们的[CI系统](https://paddleci.ngrok.io/project.html?projectId=Manylinux1&tab=projectOverview) 中下载最新的whl安装包和c-api开发包并安装。如需登录，请点击“Log in as guest”。
+	> `版本号`参见[最新Release安装包列表](./Tables.html/#whls)或者您如果需要获取并安装**最新的PaddlePaddle开发分支**，可以从[最新dev安装包列表](./Tables.html/#ciwhls)或者我们的[CI系统](https://paddleci.ngrok.io/project.html?projectId=Manylinux1&tab=projectOverview) 中下载最新的whl安装包和c-api开发包并安装。如需登录，请点击“Log in as guest”。



@@ -136,11 +118,11 @@ Python3.6、Python3.7：（由于版本相对较新，在不同Ubuntu版本上

 	* 对于需要**CPU版本的PaddlePaddle**的用户请使用以下指令拉取我们为您预安装好*PaddlePaddle For CPU*的镜像：

-		`docker pull hub.baidubce.com/paddlepaddle/paddle:1.1`
+		`docker pull hub.baidubce.com/paddlepaddle/paddle:1.2`

 	* 对于需要**GPU版本的PaddlePaddle**的用户请使用以下指令拉取我们为您预安装好*PaddlePaddle For GPU*的镜像：

-		`docker pull hub.baidubce.com/paddlepaddle/paddle:1.1-gpu-cuda9.0-cudnn7`
+		`docker pull hub.baidubce.com/paddlepaddle/paddle:1.2-gpu-cuda9.0-cudnn7`

 	* 您也可以通过以下指令拉取任意的我们提供的Docker镜像：