Cherrypick2v1.5 (#972)

* add retinanet_target_assign + focal_loss (#969)

* break up layers and change index of layers (#970)

* break up layers and change index of layers

* prettify script

doc/fluid/api_cn/layers-breakdown.py

+#!/usr/bin/env python2
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Jun 25 21:36:04 2019
+
+
+break down layers_cn to its sub categories
+
+@author: haowang101779990
+"""
+
+import sys
+import os
+import re
+
+stdi,stdo,stde=sys.stdin,sys.stdout,sys.stderr 
+reload(sys)
+sys.stdin,sys.stdout,sys.stderr=stdi,stdo,stde 
+sys.setdefaultencoding('utf-8')
+
+srcfile=open("layers_cn.rst",'r')
+srclines=srcfile.readlines()
+srcfile.close()
+
+titles={}
+
+i=0
+while i <len(srclines):
+
+    if re.match(r'^=+$', srclines[i])!=None:
+
+        title=""
+        base_idx=i+1
+
+        for j in range(base_idx,len(srclines)):
+
+            if re.match(r'^=+$', srclines[j])!=None:
+                title="".join(srclines[base_idx:j])
+                title=title.strip().replace('\n','')
+                titles[title]=(i,j)
+                i=j+1
+                break
+
+    else:
+        i+=1
+
+titlines=titles.values()
+titlines.sort()
+
+if not os.path.isdir("./layers_cn"):
+    os.mkdir("layers_cn")
+
+for i in range(0,len(titlines)):
+    for key in titles.keys():
+        if(titles[key]==titlines[i]):
+
+            keyf=open("layers_cn/"+key+"_cn.rst",'w')
+            
+            #title for this file
+            for _ in range(0,len(key)+5):
+                keyf.write("=")
+            keyf.write("\n"+key+"\n")
+            for _ in range(0,len(key)+5):
+                keyf.write("=")
+            keyf.write("\n")
+
+            #write into file
+            if i==len(titlines)-1:
+                keyf.write("".join(srclines[titlines[i][1]+1:]))
+            else:     
+                keyf.write("".join(srclines[titlines[i][1]+1:titlines[i+1][0]]))
+            
+            keyf.close()

doc/fluid/api_cn/layers_cn/io_cn.rst

+=======
+io
+=======
+
+
+.. _cn_api_fluid_layers_batch:
+
+batch
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.batch(reader, batch_size)
+
+该层是一个reader装饰器。接受一个reader变量并添加``batching``装饰。读取装饰的reader，输出数据自动组织成batch的形式。
+
+参数：
+    - **reader** (Variable)-装饰有“batching”的reader变量
+    - **batch_size** (int)-批尺寸
+
+返回：装饰有``batching``的reader变量
+
+返回类型：变量(Variable)
+
+**代码示例**：
+
+.. code-block:: python
+
+    raw_reader = fluid.layers.io.open_files(filenames=['./data1.recordio',
+                                               './data2.recordio'],
+                                        shapes=[(3,224,224), (1,)],
+                                        lod_levels=[0, 0],
+                                        dtypes=['float32', 'int64'],
+                                        thread_num=2,
+                                        buffer_size=2)
+    batch_reader = fluid.layers.batch(reader=raw_reader, batch_size=5)
+
+    # 如果用raw_reader读取数据：
+    #     data = fluid.layers.read_file(raw_reader)
+    # 只能得到数据实例。
+    #
+    # 但如果用batch_reader读取数据：
+    #     data = fluid.layers.read_file(batch_reader)
+    # 每5个相邻的实例自动连接成一个batch。因此get('data')得到的是一个batch数据而不是一个实例。
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_create_py_reader_by_data:
+
+create_py_reader_by_data
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.create_py_reader_by_data(capacity,feed_list,name=None,use_double_buffer=True)
+
+创建一个 Python reader用于在python中提供数据,该函数将返回一个 ``reader`` 变量。
+
+它的工作方式与 ``py_reader`` 非常相似，除了它的输入是一个 feed_list 而不是 ``shapes``、 ``dtypes`` 和 ``lod_level``
+
+参数：
+  - **capacity** (int) - 缓冲区容量由 :code:`py_reader` 维护
+  - **feed_list** (list(Variable)) - 传输数据列表
+  - **name** (basestring) - 前缀Python队列名称和 reader 名称。不定义时将自动生成名称。
+  - **use_double_buffer** (bool) - 是否使用 double buffer
+
+返回： Variable: 一种reader，我们可以从中获得输入数据。
+
+**代码示例：**
+
+ :code:`py_reader` 的基本用法如下所示：
+
+.. code-block:: python
+    
+    import paddle
+    import paddle.fluid as fluid
+    import paddle.dataset.mnist as mnist
+
+    def network(img, label):
+        # 用户自定义网络。此处以一个简单的线性回归作为示例。
+        predict = fluid.layers.fc(input=img, size=10, act='softmax')
+        loss = fluid.layers.cross_entropy(input=predict, label=label)
+        return fluid.layers.mean(loss)
+    
+    image = fluid.layers.data(name='image', shape=[1, 28, 28], dtypes='float32')
+    label = fluid.layers.data(name='label', shape=[1], dtypes='int64')
+    reader = fluid.layers.create_py_reader_by_data(capacity=64,
+                                                   feed_list=[image, label])
+    reader.decorate_paddle_reader(
+        paddle.reader.shuffle(paddle.batch(mnist.train(), batch_size=5), buf_size=500))
+    img, label = fluid.layers.read_file(reader)
+    loss = network(img, label) # 一些网络定义
+
+    fluid.Executor(fluid.CUDAPlace(0)).run(fluid.default_startup_program())
+
+    exe = fluid.ParallelExecutor(use_cuda=True, loss_name=loss.name)
+    for epoch_id in range(10):
+        reader.start()
+        try:
+            while True:
+                exe.run(fetch_list=[loss.name])
+        except fluid.core.EOFException:
+            reader.reset()
+
+
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_data:
+
+data
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.data(name, shape, append_batch_size=True, dtype='float32', lod_level=0, type=VarType.LOD_TENSOR, stop_gradient=True)
+
+数据层(Data Layer)
+
+该功能接受输入数据，判断是否需要以minibatch方式返回数据，然后使用辅助函数创建全局变量。该全局变量可由计算图中的所有operator访问。
+
+这个函数的所有输入变量都作为本地变量传递给LayerHelper构造函数。
+
+请注意，paddle在编译期间仅使用shape来推断网络中以下变量的形状。在运行期间，paddle不会检查所需数据的形状是否与此函数中的形状设置相匹配。
+
+参数：
+    - **name** (str)-函数名或函数别名
+    - **shape** (list)-声明维度信息的list。如果 ``append_batch_size`` 为True且内部没有维度值为-1，则应将其视为每个样本的形状。 否则，应将其视为batch数据的形状。
+    - **append_batch_size** (bool)-
+
+        1.如果为真，则在维度shape的开头插入-1。
+        例如，如果shape=[1],则输出shape为[-1,1]。这对在运行期间设置不同的batch大小很有用。
+
+        2.如果维度shape包含-1，比如shape=[-1,1]。
+        append_batch_size会强制变为为False（表示无效），因为PaddlePaddle不能在shape上设置一个以上的未知数。
+
+    - **dtype** (np.dtype|VarType|str)-数据类型：float32,float_16,int等
+    - **type** (VarType)-输出类型。默认为LOD_TENSOR
+    - **lod_level** (int)-LoD层。0表示输入数据不是一个序列
+    - **stop_gradient** (bool)-布尔类型，提示是否应该停止计算梯度
+
+返回：全局变量，可进行数据访问
+
+返回类型：变量(Variable)
+
+**代码示例**：
+
+.. code-block:: python
+
+    data = fluid.layers.data(name='x', shape=[784], dtype='float32')
+
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_double_buffer:
+
+double_buffer
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.double_buffer(reader, place=None, name=None)
+
+
+生成一个双缓冲队列reader. 数据将复制到具有双缓冲队列的位置（由place指定），如果 ``place=none`` 则将使用executor执行的位置。
+
+参数:
+  - **reader** (Variable) – 需要wrap的reader
+  - **place** (Place) – 目标数据的位置. 默认是executor执行样本的位置.
+  - **name** (str) – Variable 的名字. 默认为None，不关心名称时也可以设置为None
+
+
+返回： 双缓冲队列的reader
+
+
+**代码示例**
+
+..  code-block:: python
+
+  import paddle.fluid as fluid
+  reader = fluid.layers.open_files(filenames=['mnist.recordio'],
+           shapes=[[-1, 784], [-1, 1]],
+           dtypes=['float32', 'int64'])
+  reader = fluid.layers.double_buffer(reader)
+  img, label = fluid.layers.read_file(reader)
+
+
+
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_load:
+
+load
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.load(out, file_path, load_as_fp16=None)
+
+Load操作命令将从磁盘文件中加载LoDTensor/SelectedRows变量。
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    tmp_tensor = fluid.layers.create_tensor(dtype='float32')
+    fluid.layers.load(tmp_tensor, "./tmp_tensor.bin")
+
+参数：
+    - **out** (Variable)-需要加载的LoDTensor或SelectedRows
+    - **file_path** (STRING)-预从“file_path”中加载的变量Variable
+    - **load_as_fp16** (BOOLEAN)-如果为真，张量首先进行加载然后类型转换成float16。如果为假，张量将直接加载，不需要进行数据类型转换。默认为false。
+
+返回：None
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_open_files:
+
+open_files
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.open_files(filenames, shapes, lod_levels, dtypes, thread_num=None, buffer_size=None, pass_num=1, is_test=None)
+
+打开文件(Open files)
+
+该函数获取需要读取的文件列表，并返回Reader变量。通过Reader变量，我们可以从给定的文件中获取数据。所有文件必须有名称后缀来表示它们的格式，例如，``*.recordio``。
+
+参数：
+    - **filenames** (list)-文件名列表
+    - **shape** (list)-元组类型值列表，声明数据维度
+    - **lod_levels** (list)-整形值列表，声明数据的lod层级
+    - **dtypes** (list)-字符串类型值列表，声明数据类型
+    - **thread_num** (None)-用于读文件的线程数。默认：min(len(filenames),cpu_number)
+    - **buffer_size** (None)-reader的缓冲区大小。默认：3*thread_num
+    - **pass_num** (int)-用于运行的传递数量
+    - **is_test** (bool|None)-open_files是否用于测试。如果用于测试，生成的数据顺序和文件顺序一致。反之，无法保证每一epoch之间的数据顺序是一致的
+
+返回：一个Reader变量，通过该变量获取文件数据
+
+返回类型：变量(Variable)
+
+**代码示例**：
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    reader = fluid.layers.io.open_files(filenames=['./data1.recordio',
+                                            './data2.recordio'],
+                                    shapes=[(3,224,224), (1,)],
+                                    lod_levels=[0, 0],
+                                    dtypes=['float32', 'int64'])
+
+    # 通过reader, 可使用''read_file''层获取数据:
+    image, label = fluid.layers.io.read_file(reader)
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_Preprocessor:
+
+Preprocessor
+-------------------------------
+
+.. py:class:: class paddle.fluid.layers.Preprocessor(reader, name=None)
+
+reader变量中数据预处理块。
+
+参数：
+    - **reader** (Variable)-reader变量
+    - **name** (str,默认None)-reader的名称
+
+**代码示例**:
+
+.. code-block:: python
+
+    reader = fluid.layers.io.open_files(
+        filenames=['./data1.recordio', './data2.recordio'],
+        shapes=[(3, 224, 224), (1, )],
+        lod_levels=[0, 0],
+        dtypes=['float32', 'int64'])
+
+    preprocessor = fluid.layers.io.Preprocessor(reader=reader)
+    with preprocessor.block():
+        img, lbl = preprocessor.inputs()
+        img_out = img / 2
+        lbl_out = lbl + 1
+        preprocessor.outputs(img_out, lbl_out)
+    data_file = fluid.layers.io.double_buffer(preprocessor())
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_py_reader:
+
+py_reader
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.py_reader(capacity, shapes, dtypes, lod_levels=None, name=None, use_double_buffer=True)
+
+
+创建一个由在Python端提供数据的reader
+
+该layer返回一个Reader Variable。reader提供了 ``decorate_paddle_reader()`` 和 ``decorate_tensor_provider()`` 来设置Python generator作为数据源。更多细节请参考异步数据读取:ref:`user_guide_use_py_reader`，在c++端调用 ``Executor::Run()`` 时，来自generator的数据将被自动读取。与 ``DataFeeder.feed()`` 不同，数据读取进程和  ``Executor::Run()`` 进程可以使用 ``py_reader`` 并行运行。reader的 ``start()`` 方法应该在每次数据传递开始时调用，在传递结束和抛出  ``fluid.core.EOFException`` 后执行 ``reset()`` 方法。注意， ``Program.clone()`` 方法不能克隆 ``py_reader`` 。
+
+参数:
+  - **capacity** (int) –  ``py_reader`` 维护的缓冲区容量
+  - **shapes** (list|tuple) –数据形状的元组或列表
+  - **dtypes** (list|tuple) –  ``shapes`` 对应元素的数据类型
+  - **lod_levels** (list|tuple) – lod_level的整型列表或元组
+  - **name** (basestring) – python 队列的前缀名称和Reader 名称。不会自动生成。
+  - **use_double_buffer** (bool) – 是否使用双缓冲
+
+返回:    reader，从reader中可以获取feed的数据
+
+返回类型: Variable
+
+
+
+**代码示例**
+
+1.py_reader 基本用法如下
+
+..  code-block:: python
+
+  import paddle
+  import paddle.fluid as fluid
+  import paddle.dataset.mnist as mnist
+
+  def network(image, label):
+    # 用户自定义网络，此处以softmax回归为例
+    predict = fluid.layers.fc(input=image, size=10, act='softmax')
+  return fluid.layers.cross_entropy(input=predict, label=label)
+         
+  reader = fluid.layers.py_reader(capacity=64,
+          shapes=[(-1,1, 28, 28), (-1,1)],
+          dtypes=['float32', 'int64'])
+  reader.decorate_paddle_reader(
+      paddle.reader.shuffle(paddle.batch(mnist.train(), batch_size=5),buf_size=1000))
+
+  img, label = fluid.layers.read_file(reader)
+  loss = network(img, label) # 一些网络定义
+
+  fluid.Executor(fluid.CUDAPlace(0)).run(fluid.default_startup_program())
+
+  exe = fluid.ParallelExecutor(use_cuda=True, loss_name=loss.name)
+  for epoch_id in range(10):
+      reader.start()
+      try:
+    while True:
+        exe.run(fetch_list=[loss.name])
+      except fluid.core.EOFException:
+    reader.reset()
+
+    fluid.io.save_inference_model(dirname='./model', feeded_var_names=[img.name, label.name],target_vars=[loss], executor=fluid.Executor(fluid.CUDAPlace(0)))
+
+
+2.训练和测试应使用不同的名称创建两个不同的py_reader，例如：
+
+..  code-block:: python
+
+  import paddle
+  import paddle.fluid as fluid
+  import paddle.dataset.mnist as mnist
+
+  def network(reader):
+    img, label = fluid.layers.read_file(reader)
+    # 用户自定义网络，此处以softmax回归为例
+    predict = fluid.layers.fc(input=img, size=10, act='softmax')
+
+    loss = fluid.layers.cross_entropy(input=predict, label=label)
+        
+    return fluid.layers.mean(loss)
+
+  # 新建 train_main_prog 和 train_startup_prog
+  train_main_prog = fluid.Program()
+  train_startup_prog = fluid.Program()
+  with fluid.program_guard(train_main_prog, train_startup_prog):
+    # 使用 fluid.unique_name.guard() 实现与test program的参数共享
+    with fluid.unique_name.guard():
+      train_reader = fluid.layers.py_reader(capacity=64, shapes=[(-1, 1, 28, 28), (-1, 1)], dtypes=['float32', 'int64'], name='train_reader')
+      train_reader.decorate_paddle_reader(
+        paddle.reader.shuffle(paddle.batch(mnist.train(), batch_size=5), buf_size=500))
+    train_loss = network(train_reader) # 一些网络定义
+    adam = fluid.optimizer.Adam(learning_rate=0.01)
+    adam.minimize(train_loss)
+
+  # Create test_main_prog and test_startup_prog
+  test_main_prog = fluid.Program()
+  test_startup_prog = fluid.Program()
+  with fluid.program_guard(test_main_prog, test_startup_prog):
+    # 使用 fluid.unique_name.guard() 实现与train program的参数共享
+    with fluid.unique_name.guard():
+      test_reader = fluid.layers.py_reader(capacity=32, shapes=[(-1, 1, 28, 28), (-1, 1)], dtypes=['float32', 'int64'], name='test_reader')
+                test_reader.decorate_paddle_reader(paddle.batch(mnist.test(), 512))
+    
+      test_loss = network(test_reader)
+
+  fluid.Executor(fluid.CUDAPlace(0)).run(train_startup_prog)
+  fluid.Executor(fluid.CUDAPlace(0)).run(test_startup_prog)
+
+  train_exe = fluid.ParallelExecutor(use_cuda=True,
+      loss_name=train_loss.name, main_program=train_main_prog)
+  test_exe = fluid.ParallelExecutor(use_cuda=True,
+      loss_name=test_loss.name, main_program=test_main_prog)
+  for epoch_id in range(10):
+      train_reader.start()
+      try:
+    while True:
+        train_exe.run(fetch_list=[train_loss.name])
+      except fluid.core.EOFException:
+    train_reader.reset()
+
+      test_reader.start()
+      try:
+    while True:
+        test_exe.run(fetch_list=[test_loss.name])
+      except fluid.core.EOFException:
+    test_reader.reset()
+
+
+
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_random_data_generator:
+
+random_data_generator
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.random_data_generator(low, high, shapes, lod_levels, for_parallel=True)
+
+创建一个均匀分布随机数据生成器.
+
+该层返回一个Reader变量。该Reader变量不是用于打开文件读取数据，而是自生成float类型的均匀分布随机数。该变量可作为一个虚拟reader来测试网络，而不需要打开一个真实的文件。
+
+参数：
+    - **low** (float)--数据均匀分布的下界
+    - **high** (float)-数据均匀分布的上界
+    - **shapes** (list)-元组数列表，声明数据维度
+    - **lod_levels** (list)-整形数列表，声明数据
+    - **for_parallel** (Bool)-若要运行一系列操作命令则将其设置为True
+
+返回：Reader变量，可从中获取随机数据
+
+返回类型：变量(Variable)
+
+**代码示例**：
+
+.. code-block:: python
+
+    reader = fluid.layers.random_data_generator(
+                                 low=0.0,
+                                 high=1.0,
+                                 shapes=[[3,224,224], [1]],
+                                 lod_levels=[0, 0])
+    # 通过reader, 可以用'read_file'层获取数据:
+    image, label = fluid.layers.read_file(reader)
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_read_file:
+
+read_file
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.read_file(reader)
+
+执行给定的reader变量并从中获取数据
+
+reader也是变量。可以为由fluid.layers.open_files()生成的原始reader或者由fluid.layers.double_buffer()生成的装饰变量，等等。
+
+参数：
+    - **reader** (Variable)-将要执行的reader
+
+返回：从给定的reader中读取数据
+
+返回类型: tuple（元组）
+
+**代码示例**：
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    data_file = fluid.layers.open_files(
+        filenames=['mnist.recordio'],
+        shapes=[(-1, 748), (-1, 1)],
+        lod_levels=[0, 0],
+        dtypes=["float32", "int64"])
+    data_file = fluid.layers.double_buffer(
+        fluid.layers.batch(data_file, batch_size=64))
+    input, label = fluid.layers.read_file(data_file)
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_shuffle:
+
+shuffle
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.shuffle(reader, buffer_size)
+
+创建一个特殊的数据读取器，它的输出数据会被重洗(shuffle)。由原始读取器创建的迭代器得到的输出将会被暂存到shuffle缓存区，其后
+会对其进行重洗运算。shuffle缓存区的大小由参数 ``buffer_size`` 决定。
+
+参数:
+    - **reader** (callable) – 输出会被shuffle的原始reader
+    - **buffer_size** (int) – 进行shuffle的buffer的大小
+
+返回:其输出会被shuffle的一个reader（读取器）
+
+返回类型:callable
+
+**代码示例**：
+
+.. code-block:: python
+
+    raw_reader = fluid.layers.io.open_files(filenames=['./data1.recordio',
+                                                   './data2.recordio'],
+                                            shapes=[(3,224,224), (1,)],
+                                            lod_levels=[0, 0],
+                                            dtypes=['float32', 'int64'],
+                                            thread_num=2,
+                                            buffer_size=2)
+    batch_reader = fluid.layers.batch(reader=raw_reader, batch_size=5)
+    shuffle_reader = fluid.layers.shuffle(reader=batch_reader, buffer_size=5000)
+
+
+
+
+
+
+
+

doc/fluid/api_cn/layers_cn/learning_rate_scheduler_cn.rst

+============================
+learning_rate_scheduler
+============================
+
+.. _cn_api_fluid_layers_cosine_decay:
+
+cosine_decay
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.cosine_decay(learning_rate, step_each_epoch, epochs)
+
+使用 cosine decay 的衰减方式进行学习率调整。
+
+在训练模型时，建议一边进行训练一边降低学习率。 通过使用此方法，学习速率将通过如下cosine衰减策略进行衰减：
+
+.. math::
+    decayed\_lr = learning\_rate * 0.5 * (cos(epoch * math.pi / epochs) + 1)
+
+
+参数：
+    - **learning_rate** （Variable | float） - 初始学习率。
+    - **step_each_epoch** （int） - 一次迭代中的步数。
+    - **epochs**  - 总迭代次数。
+
+
+
+
+**代码示例**
+
+.. code-block:: python
+
+    base_lr = 0.1
+    lr = fluid.layers.cosine_decay( learning_rate = base_lr, step_each_epoch=10000, epochs=120)
+
+
+
+.. _cn_api_fluid_layers_exponential_decay:
+
+exponential_decay
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.exponential_decay(learning_rate,decay_steps,decay_rate,staircase=False)
+
+在学习率上运用指数衰减。
+训练模型时，在训练过程中通常推荐降低学习率。每次 ``decay_steps`` 步骤中用 ``decay_rate`` 衰减学习率。
+
+.. code-block:: text
+
+    if staircase == True:
+        decayed_learning_rate = learning_rate * decay_rate ^ floor(global_step / decay_steps)
+    else:
+        decayed_learning_rate = learning_rate * decay_rate ^ (global_step / decay_steps)
+
+参数：
+    - **learning_rate** (Variable|float)-初始学习率
+    - **decay_steps** (int)-见以上衰减运算
+    - **decay_rate** (float)-衰减率。见以上衰减运算
+    - **staircase** (Boolean)-若为True,按离散区间衰减学习率。默认：False
+
+返回：衰减的学习率
+
+返回类型：变量（Variable）
+
+**代码示例**：
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    base_lr = 0.1
+    sgd_optimizer = fluid.optimizer.SGD(
+        learning_rate=fluid.layers.exponential_decay(
+            learning_rate=base_lr,
+            decay_steps=10000,
+            decay_rate=0.5,
+            staircase=True))
+
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_inverse_time_decay:
+
+inverse_time_decay
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.inverse_time_decay(learning_rate, decay_steps, decay_rate, staircase=False)
+
+在初始学习率上运用逆时衰减。
+
+训练模型时，在训练过程中通常推荐降低学习率。通过执行该函数，将对初始学习率运用逆向衰减函数。
+
+.. code-block:: python
+
+    if staircase == True:
+         decayed_learning_rate = learning_rate / (1 + decay_rate * floor(global_step / decay_step))
+     else:
+         decayed_learning_rate = learning_rate / (1 + decay_rate * global_step / decay_step)
+
+参数：
+    - **learning_rate** (Variable|float)-初始学习率
+    - **decay_steps** (int)-见以上衰减运算
+    - **decay_rate** (float)-衰减率。见以上衰减运算
+    - **staircase** (Boolean)-若为True，按间隔区间衰减学习率。默认：False
+
+返回：衰减的学习率
+
+返回类型：变量（Variable）
+
+**示例代码：**
+
+.. code-block:: python
+
+        import paddle.fluid as fluid
+        base_lr = 0.1
+        sgd_optimizer = fluid.optimizer.SGD(
+            learning_rate=fluid.layers.natural_exp_decay(
+                learning_rate=base_lr,
+                decay_steps=10000,
+                decay_rate=0.5,
+                staircase=True))
+        sgd_optimizer.minimize(avg_cost)
+
+
+
+
+.. _cn_api_fluid_layers_linear_lr_warmup:
+
+linear_lr_warmup
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.linear_lr_warmup(learning_rate, warmup_steps, start_lr, end_lr)
+
+在正常学习率调整之前先应用线性学习率热身(warm up)进行初步调整。
+
+.. code-block:: text
+
+    if global_step < warmup_steps:
+        linear_step = end_lr - start_lr
+        lr = start_lr + linear_step * (global_step / warmup_steps)
+
+参数：
+    - **learning_rate** （float | Variable） - 学习率，类型为float值或变量。
+    - **warmup_steps** （int） - 进行warm up过程的步数。
+    - **start_lr** （float） - warm up的起始学习率
+    - **end_lr** （float） - warm up的最终学习率。
+
+返回：进行热身衰减后的学习率。
+
+
+**示例代码**
+
+.. code-block:: python
+
+        boundaries = [100, 200]
+        lr_steps = [0.1, 0.01, 0.001]
+        warmup_steps = 50
+        start_lr = 1. / 3.
+        end_lr = 0.1
+        decayed_lr = fluid.layers.linear_lr_warmup(
+            fluid.layers.piecewise_decay(boundaries, lr_steps),
+            warmup_steps, start_lr, end_lr)
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_natural_exp_decay:
+
+natural_exp_decay
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.natural_exp_decay(learning_rate, decay_steps, decay_rate, staircase=False)
+
+将自然指数衰减运用到初始学习率上。
+
+.. code-block:: python
+
+    if not staircase:
+        decayed_learning_rate = learning_rate * exp(- decay_rate * (global_step / decay_steps))
+    else:
+        decayed_learning_rate = learning_rate * exp(- decay_rate * (global_step / decay_steps))
+
+参数：
+    - **learning_rate** - 标量float32值或变量。是训练过程中的初始学习率。
+    - **decay_steps** - Python int32数
+    - **decay_rate** - Python float数
+    - **staircase** - Boolean.若设为true，每个decay_steps衰减学习率
+
+返回：衰减的学习率
+
+**示例代码：**
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    base_lr = 0.1
+    sgd_optimizer = fluid.optimizer.SGD(
+        learning_rate=fluid.layers.natural_exp_decay(
+              learning_rate=base_lr,
+              decay_steps=10000,
+              decay_rate=0.5,
+              staircase=True))
+
+
+
+
+
+
+.. _cn_api_fluid_layers_noam_decay:
+
+noam_decay
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.noam_decay(d_model,warmup_steps)
+
+Noam衰减方法。noam衰减的numpy实现如下。
+
+.. code-block:: python
+
+    import numpy as np
+    # 设置超参数
+    d_model = 2
+    current_steps = 20
+    warmup_steps = 200
+    # 计算
+    lr_value = np.power(d_model, -0.5) * np.min([
+                           np.power(current_steps, -0.5),
+                           np.power(warmup_steps, -1.5) * current_steps])
+
+请参照 `attention is all you need <https://arxiv.org/pdf/1706.03762.pdf>`_
+
+参数：
+    - **d_model** (Variable)-模型的输入和输出维度
+    - **warmup_steps** (Variable)-超参数
+
+返回：衰减的学习率
+
+**代码示例**：
+
+.. code-block:: python
+
+        import padde.fluid as fluid
+        warmup_steps = 100
+        learning_rate = 0.01
+        lr = fluid.layers.learning_rate_scheduler.noam_decay(
+                       1/(warmup_steps *(learning_rate ** 2)),
+                       warmup_steps)
+
+
+
+
+
+
+.. _cn_api_fluid_layers_piecewise_decay:
+
+piecewise_decay
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.piecewise_decay(boundaries,values)
+
+对初始学习率进行分段衰减。
+
+该算法可用如下代码描述。
+
+.. code-block:: text
+
+    boundaries = [10000, 20000]
+    values = [1.0, 0.5, 0.1]
+    if step < 10000:
+        learning_rate = 1.0
+    elif 10000 <= step < 20000:
+        learning_rate = 0.5
+    else:
+        learning_rate = 0.1
+
+参数：
+    - **boundaries** -一列代表步数的数字
+    - **values** -一列学习率的值，从不同的步边界中挑选
+
+返回：衰减的学习率
+
+**代码示例**：
+
+.. code-block:: python
+
+        import paddle.fluid as fluid
+        boundaries = [10000, 20000]
+        values = [1.0, 0.5, 0.1]
+        optimizer = fluid.optimizer.Momentum(
+            momentum=0.9,
+            learning_rate=fluid.layers.piecewise_decay(boundaries=boundaries, values=values),
+            regularization=fluid.regularizer.L2Decay(1e-4))
+
+
+
+
+
+
+.. _cn_api_fluid_layers_polynomial_decay:
+
+polynomial_decay
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.polynomial_decay(learning_rate,decay_steps,end_learning_rate=0.0001,power=1.0,cycle=False)
+
+对初始学习率使用多项式衰减
+
+.. code-block:: text
+
+    if cycle:
+        decay_steps = decay_steps * ceil(global_step / decay_steps)
+    else:
+        global_step = min(global_step, decay_steps)
+        decayed_learning_rate = (learning_rate - end_learning_rate) *
+            (1 - global_step / decay_steps) ^ power + end_learning_rate
+
+参数：
+    - **learning_rate** (Variable|float32)-标量float32值或变量。是训练过程中的初始学习率。
+    - **decay_steps** (int32)-Python int32数
+    - **end_learning_rate** (float)-Python float数
+    - **power** (float)-Python float数
+    - **cycle** (bool)-若设为true，每decay_steps衰减学习率
+
+返回：衰减的学习率
+
+返回类型：变量（Variable）
+
+**代码示例**：
+
+.. code-block:: python
+
+        import paddle.fluid as fluid
+        start_lr = 0.01
+        total_step = 5000
+        end_lr = 0
+        lr = fluid.layers.polynomial_decay(
+            start_lr, total_step, end_lr, power=1)
+
+
+
+
+
+
+
+

doc/fluid/api_cn/layers_cn/metric_op_cn.rst

+==============
+metric_op
+==============
+
+
+.. _cn_api_fluid_layers_accuracy:
+
+accuracy
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.accuracy(input, label, k=1, correct=None, total=None)
+
+accuracy layer。 参考 https://en.wikipedia.org/wiki/Precision_and_recall
+
+使用输入和标签计算准确率。 每个类别中top k 中正确预测的个数。注意：准确率的 dtype 由输入决定。 输入和标签 dtype 可以不同。
+
+参数：
+    - **input** (Variable)-该层的输入，即网络的预测。支持 Carry LoD。
+    - **label** (Variable)-数据集的标签。
+    - **k** (int) - 每个类别的 top k
+    - **correct** (Variable)-正确的预测个数。
+    - **total** (Variable)-总共的样本数。
+
+返回: 正确率
+
+返回类型: 变量（Variable）
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    data = fluid.layers.data(name="data", shape=[-1, 32, 32], dtype="float32")
+    label = fluid.layers.data(name="label", shape=[-1,1], dtype="int32")
+    predict = fluid.layers.fc(input=data, size=10)
+    accuracy_out = fluid.layers.accuracy(input=predict, label=label, k=5)
+
+
+
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_auc:
+
+auc
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.auc(input, label, curve='ROC', num_thresholds=4095, topk=1, slide_steps=1)
+
+**Area Under the Curve(AUC) Layer**
+
+该层根据前向输出和标签计算AUC，在二分类(binary classification)估计中广泛使用。
+
+注：如果输入标注包含一种值，只有0或1两种情况，数据类型则强制转换成布尔值。相关定义可以在这里: https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve 找到
+
+有两种可能的曲线：
+
+1. ROC:受试者工作特征曲线
+
+2. PR:准确率召回率曲线
+
+参数：
+    - **input** (Variable) - 浮点二维变量，值的范围为[0,1]。每一行降序排列。输入应为topk的输出。该变量显示了每个标签的概率。
+    - **label** (Variable) - 二维整型变量，表示训练数据的标注。批尺寸的高度和宽度始终为1.
+    - **curve** (str) - 曲线类型，可以为 ``ROC`` 或 ``PR``，默认 ``ROC``。
+    - **num_thresholds** (int) - 将roc曲线离散化时使用的临界值数。默认200
+    - **topk** (int) - 只有预测输出的topk数才被用于auc
+    - **slide_steps** - 计算批auc时，不仅用当前步也用先前步。slide_steps=1，表示用当前步；slide_steps = 3表示用当前步和前两步；slide_steps = 0，则用所有步
+
+返回：代表当前AUC的scalar
+
+返回类型：变量（Variable）
+
+**代码示例**：
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    data = fluid.layers.data(name="data", shape=[32, 32], dtype="float32")
+    label = fluid.layers.data(name="label", shape=[1], dtype="int32")
+    predict = fluid.layers.fc(input=data, size=2)
+    auc_out=fluid.layers.auc(input=prediction, label=label)
+
+
+
+
+
+
+
+

doc/fluid/api_cn/layers_cn/ops_cn.rst

+========
+ops
+========
+
+
+.. _cn_api_fluid_layers_abs:
+
+abs
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.abs(x, name=None)
+
+绝对值激活函数。
+
+.. math::
+    out = |x|
+
+参数:
+
+    - **x** - abs算子的输入
+    - **use_cudnn** (BOOLEAN) – （bool，默认为false）是否仅用于cudnn核，需要安装cudnn
+
+返回：        abs算子的输出。
+
+**代码示例**：
+
+.. code-block:: python
+
+        data = fluid.layers.data(name="input", shape=[32, 784])
+        result = fluid.layers.abs(data)
+
+
+.. _cn_api_fluid_layers_acos:
+
+acos
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.acos(x, name=None)
+
+arccosine激活函数。
+
+.. math::
+    out = cos^{-1}(x)
+
+参数:
+    - **x** - acos算子的输入
+
+返回：        acos算子的输出。
+
+**代码示例**：
+
+.. code-block:: python
+
+        data = fluid.layers.data(name="input", shape=[32, 784])
+        result = fluid.layers.acos(data)
+
+
+.. _cn_api_fluid_layers_asin:
+
+asin
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.asin(x, name=None)
+
+arcsine激活函数。
+
+.. math::
+    out = sin^{-1}(x)
+
+参数:
+    - **x** - asin算子的输入
+
+返回：        asin算子的输出。
+
+**代码示例**：
+
+.. code-block:: python
+
+        data = fluid.layers.data(name="input", shape=[32, 784])
+        result = fluid.layers.asin(data)
+
+
+
+.. _cn_api_fluid_layers_atan:
+
+atan
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.atan(x, name=None)
+
+arctanh激活函数。
+
+.. math::
+    out = tanh^{-1}(x)
+
+参数:
+    - **x** - atan算子的输入
+
+返回：       atan算子的输出。
+
+**代码示例**：
+
+.. code-block:: python
+
+        data = fluid.layers.data(name="input", shape=[32, 784])
+        result = fluid.layers.atan(data)
+
+
+
+
+
+.. _cn_api_fluid_layers_ceil:
+
+ceil
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.ceil(x, name=None)
+
+向上取整运算激活函数。
+
+.. math::
+    out = \left \lceil x \right \rceil
+
+
+
+参数:
+
+    - **x** - Ceil算子的输入
+    - **use_cudnn** (BOOLEAN) – （bool，默认为false）是否仅用于cudnn核，需要安装cudnn
+
+返回：        Ceil算子的输出。
+
+**代码示例**：
+
+.. code-block:: python
+
+        data = fluid.layers.data(name="input", shape=[32, 784])
+        result = fluid.layers.ceil(data)
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_cos:
+
+cos
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.cos(x, name=None)
+
+Cosine余弦激活函数。
+
+.. math::
+
+    out = cos(x)
+
+
+
+参数:
+
+    - **x** - cos算子的输入
+    - **use_cudnn** (BOOLEAN) – （bool，默认为false）是否仅用于cudnn核，需要安装cudnn
+
+
+返回：        Cos算子的输出
+
+**代码示例**：
+
+.. code-block:: python
+
+        data = fluid.layers.data(name="input", shape=[32, 784])
+        result = fluid.layers.cos(data)
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_cumsum:
+
+cumsum
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.cumsum(x,axis=None,exclusive=None,reverse=None)
+
+沿给定轴的元素的累加和。默认结果的第一个元素和输入的第一个元素一致。如果exlusive为真，结果的第一个元素则为0。
+
+参数：
+    - **x** -累加操作符的输入
+    - **axis** (INT)-需要累加的维。-1代表最后一维。[默认 -1]。
+    - **exclusive** (BOOLEAN)-是否执行exclusive累加。[默认false]。
+    - **reverse** (BOOLEAN)-若为true,则以相反顺序执行累加。[默认 false]。
+
+返回：累加器的输出
+
+**代码示例**：
+
+.. code-block:: python
+
+    data = fluid.layers.data(name="input", shape=[32, 784])
+    result = fluid.layers.cumsum(data, axis=0)
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_exp:
+
+exp
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.exp(x, name=None)
+
+Exp激活函数(Exp指以自然常数e为底的指数运算)。
+
+.. math::
+    out = e^x
+
+参数:
+
+    - **x** - Exp算子的输入
+    - **use_cudnn** (BOOLEAN) – （bool，默认为false）是否仅用于cudnn核，需要安装cudnn
+
+
+返回：       Exp算子的输出
+
+**代码示例**：
+
+.. code-block:: python
+
+        data = fluid.layers.data(name="input", shape=[32, 784])
+        result = fluid.layers.exp(data)
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_floor:
+
+floor
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.floor(x, name=None)
+
+
+向下取整运算激活函数。
+
+.. math::
+    out = \left \lfloor x \right \rfloor
+
+
+参数:
+
+    - **x** - Floor算子的输入
+    - **use_cudnn** (BOOLEAN) – （bool，默认为false）是否仅用于cudnn核，需要安装cudnn
+
+
+返回：        Floor算子的输出。
+
+**代码示例**：
+
+.. code-block:: python
+
+        data = fluid.layers.data(name="input", shape=[32, 784])
+        result = fluid.layers.floor(data)
+
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_hard_shrink:
+
+hard_shrink
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.hard_shrink(x,threshold=None)
+
+HardShrink激活函数(HardShrink activation operator)
+
+
+.. math::
+
+  out = \begin{cases}
+        x, \text{if } x > \lambda \\
+        x, \text{if } x < -\lambda \\
+        0,  \text{otherwise}
+      \end{cases}
+
+参数：
+    - **x** - HardShrink激活函数的输入
+    - **threshold** (FLOAT)-HardShrink激活函数的threshold值。[默认：0.5]
+
+返回：HardShrink激活函数的输出
+
+**代码示例**：
+
+.. code-block:: python
+
+    data = fluid.layers.data(name="input", shape=[784])
+    result = fluid.layers.hard_shrink(x=data, threshold=0.3)
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_logsigmoid:
+
+logsigmoid
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.logsigmoid(x, name=None)
+
+Logsigmoid激活函数。
+
+
+.. math::
+
+    out = \log \frac{1}{1 + e^{-x}}
+
+
+参数:
+    - **x** - LogSigmoid算子的输入
+    - **use_cudnn** (BOOLEAN) – （bool，默认为false）是否仅用于cudnn核，需要安装cudnn
+
+返回：        LogSigmoid算子的输出
+
+**代码示例**：
+
+.. code-block:: python
+
+        data = fluid.layers.data(name="input", shape=[32, 784])
+        result = fluid.layers.logsigmoid(data)
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_reciprocal:
+
+reciprocal
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.reciprocal(x, name=None)
+
+Reciprocal（取倒数）激活函数
+
+
+.. math::
+    out = \frac{1}{x}
+
+参数:
+
+    - **x** - reciprocal算子的输入
+    - **use_cudnn** (BOOLEAN) – （bool，默认为false）是否仅用于cudnn核，需要安装cudnn
+
+返回：        Reciprocal算子的输出。
+
+**代码示例**：
+
+.. code-block:: python
+
+        data = fluid.layers.data(name="input", shape=[32, 784])
+        result = fluid.layers.reciprocal(data)
+
+
+
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_round:
+
+round
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.round(x, name=None)
+
+Round取整激活函数。
+
+
+.. math::
+     out = [x]
+
+
+参数:
+
+    - **x** - round算子的输入
+    - **use_cudnn** (BOOLEAN) – （bool，默认为false）是否仅用于cudnn核，需要安装cudnn
+
+返回：        Round算子的输出。
+
+**代码示例**：
+
+.. code-block:: python
+
+        data = fluid.layers.data(name="input", shape=[32, 784])
+        result = fluid.layers.round(data)
+
+
+
+.. _cn_api_fluid_layers_rsqrt:
+
+rsqrt
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.rsqrt(x, name=None)
+
+rsqrt激活函数
+
+请确保输入合法以免出现数字错误。
+
+.. math::
+    out = \frac{1}{\sqrt{x}}
+
+
+参数:
+
+    - **x** - rsqrt算子的输入 
+    - **use_cudnn** (BOOLEAN) – （bool，默认为false）是否仅用于cudnn核，需要安装cudnn
+
+返回：     rsqrt运算输出
+
+**代码示例**：
+
+.. code-block:: python
+
+        data = fluid.layers.data(name="input", shape=[32, 784])
+        result = fluid.layers.rsqrt(data)
+
+
+
+.. _cn_api_fluid_layers_sigmoid:
+
+sigmoid
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.sigmoid(x, name=None)
+
+sigmoid激活函数
+
+.. math::
+    out = \frac{1}{1 + e^{-x}}
+
+
+参数:
+
+    - **x** - Sigmoid算子的输入
+    - **use_cudnn** (BOOLEAN) – （bool，默认为false）是否仅用于cudnn核，需要安装cudnn
+
+返回：     Sigmoid运算输出.
+
+**代码示例**：
+
+.. code-block:: python
+
+        data = fluid.layers.data(name="input", shape=[32, 784])
+        result = fluid.layers.sigmoid(data)
+
+
+
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_sin:
+
+sin
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.sin(x, name=None)
+
+正弦sine激活函数。
+
+.. math::
+     out = sin(x)
+
+
+参数:
+
+    - **x** - sin算子的输入
+    - **use_cudnn** (BOOLEAN) – （bool，默认为false）是否仅用于cudnn核，需要安装cudnn
+
+
+返回：        Sin算子的输出。
+
+**代码示例**：
+
+.. code-block:: python
+
+        data = fluid.layers.data(name="input", shape=[32, 784])
+        result = fluid.layers.sin(data)
+
+
+
+
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_softplus:
+
+softplus
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.softplus(x,name=None)
+
+softplus激活函数。
+
+.. math::
+    out = \ln(1 + e^{x})
+
+参数：
+    - **x** - Softplus操作符的输入
+    - **use_cudnn** (BOOLEAN) – （bool，默认为false）是否仅用于cudnn核，需要安装cudnn
+
+返回：Softplus操作后的结果
+
+**代码示例**：
+
+.. code-block:: python
+
+        data = fluid.layers.data(name="input", shape=[32, 784])
+        result = fluid.layers.softplus(data)
+
+
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_softshrink:
+
+softshrink
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.softshrink(x, name=None)
+
+Softshrink激活算子
+
+.. math::
+        out = \begin{cases}
+                    x - \lambda, \text{if } x > \lambda \\
+                    x + \lambda, \text{if } x < -\lambda \\
+                    0,  \text{otherwise}
+              \end{cases}
+
+参数：
+        - **x** - Softshrink算子的输入
+        - **lambda** （FLOAT）- 非负偏移量。
+
+返回：       Softshrink算子的输出
+
+**代码示例**：
+
+.. code-block:: python
+
+        data = fluid.layers.data(name="input", shape=[32, 784])
+        result = fluid.layers.softshrink(data)
+
+
+
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_softsign:
+
+softsign
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.softsign(x,name=None)
+
+
+softsign激活函数。
+
+.. math::
+    out = \frac{x}{1 + |x|}
+
+参数：
+    - **x** : Softsign操作符的输入
+    - **use_cudnn** (BOOLEAN) – （bool，默认为false）是否仅用于cudnn核，需要安装cudnn
+
+
+返回：Softsign操作后的结果
+
+**代码示例**：
+
+.. code-block:: python
+
+        data = fluid.layers.data(name="input", shape=[32, 784])
+        result = fluid.layers.softsign(data)
+
+
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_sqrt:
+
+sqrt
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.sqrt(x, name=None)
+
+算数平方根激活函数。
+
+请确保输入是非负数。有些训练当中，会出现输入为接近零的负值，此时应加上一个小值epsilon（1e-12）将其变为正数从而正确运算并进行后续的操作。
+
+
+.. math::
+    out = \sqrt{x}
+
+参数:
+
+    - **x** - Sqrt算子的输入
+    - **use_cudnn** (BOOLEAN) – （bool，默认为false）是否仅用于cudnn核，需要安装cudnn
+
+返回：       Sqrt算子的输出。
+
+**代码示例**：
+
+.. code-block:: python
+
+        data = fluid.layers.data(name="input", shape=[32, 784])
+        result = fluid.layers.sqrt(data)
+
+
+
+
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_square:
+
+square
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.square(x,name=None)
+
+取平方激活函数。
+
+.. math::
+    out = x^2
+
+参数:
+    - **x** : 平方操作符的输入
+    - **use_cudnn** (BOOLEAN) – （bool，默认为false）是否仅用于cudnn核，需要安装cudnn
+
+返回：平方后的结果
+
+**代码示例**：
+
+.. code-block:: python
+
+        data = fluid.layers.data(name="input", shape=[32, 784])
+        result = fluid.layers.square(data)
+
+
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_tanh:
+
+tanh
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.tanh(x, name=None)
+
+
+
+
+tanh 激活函数。
+
+.. math::
+    out = \frac{e^{x} - e^{-x}}{e^{x} + e^{-x}}
+
+
+参数:
+
+    - **x** - Tanh算子的输入
+    - **use_cudnn** (BOOLEAN) – （bool，默认为false）是否仅用于cudnn核，需要安装cudnn
+
+返回：     Tanh算子的输出。
+
+**代码示例**：
+
+.. code-block:: python
+
+        data = fluid.layers.data(name="input", shape=[32, 784])
+        result = fluid.layers.tanh(data)
+
+
+
+
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_tanh_shrink:
+
+tanh_shrink
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.tanh_shrink(x, name=None)
+
+tanh_shrink激活函数。
+
+.. math::
+    out = x - \frac{e^{x} - e^{-x}}{e^{x} + e^{-x}}
+
+参数:
+
+    - **x** - TanhShrink算子的输入
+    - **use_cudnn** (BOOLEAN) – （bool，默认为false）是否仅用于cudnn核，需要安装cudnn
+
+返回：     tanh_shrink算子的输出
+
+**代码示例**：
+
+.. code-block:: python
+
+        data = fluid.layers.data(name="input", shape=[32, 784])
+        result = fluid.layers.tanh_shrink(data)
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_thresholded_relu:
+
+thresholded_relu
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.thresholded_relu(x,threshold=None)
+
+ThresholdedRelu激活函数
+
+.. math::
+
+  out = \left\{\begin{matrix}
+      x, &if x > threshold\\
+      0, &otherwise
+      \end{matrix}\right.
+
+参数：
+- **x** -ThresholdedRelu激活函数的输入
+- **threshold** (FLOAT)-激活函数threshold的位置。[默认1.0]。
+
+返回：ThresholdedRelu激活函数的输出
+
+**代码示例**：
+
+.. code-block:: python
+
+  data = fluid.layers.data(name="input", shape=[1])
+  result = fluid.layers.thresholded_relu(data, threshold=0.4)
+
+
+
+
+
+
+
+
+
+.. _cn_api_fluid_layers_uniform_random:
+
+uniform_random
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.uniform_random(shape, dtype='float32', min=-1.0, max=1.0, seed=0)
+该操作符初始化一个张量，该张量的值是从均匀分布中抽样的随机值
+
+参数：
+    - **shape** (LONGS)-输出张量的维
+    - **dtype** (np.dtype|core.VarDesc.VarType|str) – 数据的类型, 例如float32, float64。 默认: float32.
+    - **min** (FLOAT)-均匀随机分布的最小值。[默认 -1.0]
+    - **max** (FLOAT)-均匀随机分布的最大值。[默认 1.0]
+    - **seed** (INT)-随机种子，用于生成样本。0表示使用系统生成的种子。注意如果种子不为0，该操作符每次都生成同样的随机数。[默认 0]
+
+
+**代码示例**：
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    result = fluid.layers.uniform_random(shape=[32, 784])
+
+
+
+
+
+
+
+
+
+
+