nn

adaptive_pool2d

• paddle.fluid.layers.adaptivepool2d(_input, pool_size, pool_type='max', require_index=False, name=None)
• pooling2d操作根据输入 input ， pool_size ， pool_type 参数计算输出。 输入（X）和输出（Out）采用NCHW格式，其中N是批大小batch size，C是通道数，H是feature(特征)的高度，W是feature（特征）的宽度。 参数 pool_size 由两个元素构成, 这两个元素分别代表高度和宽度。 输出（Out）的H和W维与 pool_size 大小相同。

对于平均adaptive pool2d:

• 参数：
• • input （Variable） - 池化操作的输入张量。 输入张量的格式为NCHW，其中N是batch大小，C是通道数，H是特征的高度，W是特征的宽度。
  • pool_size （int | list | tuple） - 池化核大小。 如果池化核大小是元组或列表，则它必须包含两个整数（pool_size_Height，pool_size_Width）。
  • pool_type （string）- 池化类型，可输入“max”代表max-pooling，或者“avg”代表average-pooling。
  • require_index （bool） - 如果为true，则输出中带有最大池化点所在的索引。 如果pool_type为avg,该项不可被设置为true。
  • name （str | None） - 此层的名称（可选）。 如果设置为None，则将自动命名该层。返回： 池化结果

返回类型: Variable

抛出异常:

• ValueError – pool_type 不是 ‘max’ 或 ‘avg’
• ValueError – 当 pool_type 是 ‘avg’ 时，错误地设置 ‘require_index’ 为true .
• ValueError – pool_size 应为一个长度为2的列表或元组

# 假设输入形为[N, C, H, W], `pool_size` 为 [m, n],
# 输出形为 [N, C, m, n], adaptive pool 将输入的 H 和 W 维度
# 平均分割为 m * n 个栅格(grid) ，然后为每个栅格进行池化得到输出
# adaptive average pool 进行如下操作
#
#     for i in range(m):
#         for j in range(n):
#             hstart = floor(i * H / m)
#             hend = ceil((i + 1) * H / m)
#             wstart = floor(i * W / n)
#             wend = ceil((i + 1) * W / n)
#             output[:, :, i, j] = avg(input[:, :, hstart: hend, wstart: wend])
#
import paddle.fluid as fluid
data = fluid.layers.data(
    name='data', shape=[3, 32, 32], dtype='float32')
pool_out = fluid.layers.adaptive_pool2d(
                  input=data,
                  pool_size=[3, 3],
                  pool_type='avg')

adaptive_pool3d

• paddle.fluid.layers.adaptivepool3d(_input, pool_size, pool_type='max', require_index=False, name=None)
• pooling3d操作根据输入 input ，pool_size ， pool_type 参数计算输出。 输入（X）和输出（输出）采用NCDHW格式，其中N是批大小batch size，C是通道数，D是特征(feature)的深度，H是特征的高度，W是特征的宽度。 参数 pool_size 由三个元素组成。 这三个元素分别代表深度，高度和宽度。输出（Out）的D,H,W维与 pool_size 相同。

对于平均adaptive pool3d:

• 参数：
• • input （Variable） - 池化操作的输入张量。 输入张量的格式为NCDHW，其中N是batch大小，C是通道数，D为特征的深度，H是特征的高度，W是特征的宽度。
  • pool_size （int | list | tuple） - 池化核大小。 如果池化核大小是元组或列表，则它必须包含三个整数（Depth, Height, Width）。
  • pool_type （string）- 池化类型，可输入“max”代表max-pooling，或者“avg”代表average-pooling。
  • require_index （bool） - 如果为true，则输出中带有最大池化点所在的索引。 如果pool_type为avg,该项不可被设置为true。
  • name （str | None） - 此层的名称（可选）。 如果设置为None，则将自动命名该层。返回： 池化结果

返回类型: Variable

抛出异常:

• ValueError – pool_type 不是 ‘max’ 或 ‘avg’
• ValueError – 当 pool_type 是 ‘avg’ 时，错误地设置 ‘require_index’ 为true .
• ValueError – pool_size 应为一个长度为3的列表或元组

# 假设输入形为[N, C, D, H, W], `pool_size` 为 [l, m, n],
# 输出形为 [N, C, l, m, n], adaptive pool 将输入的D, H 和 W 维度
# 平均分割为 l * m * n 个栅格(grid) ，然后为每个栅格进行池化得到输出
# adaptive average pool 进行如下操作
#
#     for i in range(l):
#         for j in range(m):
#             for k in range(n):
#                 dstart = floor(i * D / l)
#                 dend = ceil((i + 1) * D / l)
#                 hstart = floor(j * H / m)
#                 hend = ceil((j + 1) * H / m)
#                 wstart = floor(k * W / n)
#                 wend = ceil((k + 1) * W / n)
#                 output[:, :, i, j, k] =
#                     avg(input[:, :, dstart:dend, hstart: hend, wstart: wend])
#
 
import paddle.fluid as fluid
 
data = fluid.layers.data(
name='data', shape=[3, 32, 32, 32], dtype='float32')
pool_out, mask = fluid.layers.adaptive_pool3d(
                  input=data,
                  pool_size=[3, 3, 3],
                  pool_type='avg')

add_position_encoding

• paddle.fluid.layers.addposition_encoding(_input, alpha, beta, name=None)
• 添加位置编码层

接受形状为[N×M×P]的三维输入张量，并返回一个形为[N×M×P]的输出张量，且输出张量具有位置编码值。

可参考论文: Attention Is All You Need

• 其中:
• • PE(pos, 2i): 偶数位置上数字的增量
  • PE(pos, 2i + 1): 奇数位置上数字的增量
• 参数:
• • input (Variable) – 形状为[N x M x P]的三维输入张量
  • alpha (float) – 输入张量的倍数
  • beta (float) – 位置编码张量Positional Encoding Tensor的倍数
  • name (string) – 位置编码层的名称返回: 具有位置编码的三维形状张量[N×M×P]

返回类型: Variable

代码示例：

import paddle.fluid as fluid
 
tensor = fluid.layers.data(
      name='tensor',
      shape=[32, 64, 512],
      dtype='float32',
      append_batch_size=False)
position_tensor = fluid.layers.add_position_encoding(
      input=tensor, alpha=1.0, beta=1.0)

affine_channel

• paddle.fluid.layers.affinechannel(_x, scale=None, bias=None, data_layout='NCHW', name=None, act=None)
• 对输入的每个 channel 应用单独的仿射变换。用于将空间批处理范数替换为其等价的固定变换。

输入也可以是二维张量，并在二维应用仿射变换。

• 参数：
• • x (Variable):特征图输入可以是一个具有NCHW阶或NHWC阶的4D张量。它也可以是二维张量和应用于第二维度的仿射变换。
  • scale (Variable): 形状为(C)的一维输入，第C个元素为输入的第C通道仿射变换的尺度因子。
  • bias (Variable):形状为(C)的一维输入，第C个元素是输入的第C个通道的仿射变换的偏置。
  • data_layout (string, default NCHW): NCHW 或 NHWC，如果输入是一个2D张量，可以忽略该参数
  • name (str, default None): 此层的名称
  • act (str, default None): 应用于该层输出的激活函数返回： out (Variable): 与x具有相同形状和数据布局的张量。

代码示例：

import paddle.fluid as fluid
data = fluid.layers.data(name='data', shape=[3, 32, 32],
                         dtype='float32')
input_scale = fluid.layers.create_parameter(shape=[3],
                         dtype="float32")
input_bias = fluid.layers.create_parameter(shape=[3],
                         dtype="float32")
out = fluid.layers.affine_channel(data,scale=input_scale,
                         bias=input_bias)

affine_grid

• paddle.fluid.layers.affinegrid(_theta, out_shape, name=None)
• 它使用仿射变换的参数生成(x,y)坐标的网格，这些参数对应于一组点，在这些点上，输入特征映射应该被采样以生成转换后的输出特征映射。

* 例 1:
  给定:
      theta = [[[x_11, x_12, x_13]
                [x_14, x_15, x_16]]
               [[x_21, x_22, x_23]
                [x_24, x_25, x_26]]]
      out_shape = [2, 3, 5, 5]
 
  Step 1:
 
      根据out_shape生成标准化坐标
 
      归一化坐标的值在-1和1之间
 
      归一化坐标的形状为[2,H, W]，如下所示:
 
      C = [[[-1.  -1.  -1.  -1.  -1. ]
            [-0.5 -0.5 -0.5 -0.5 -0.5]
            [ 0.   0.   0.   0.   0. ]
            [ 0.5  0.5  0.5  0.5  0.5]
            [ 1.   1.   1.   1.   1. ]]
           [[-1.  -0.5  0.   0.5  1. ]
            [-1.  -0.5  0.   0.5  1. ]
            [-1.  -0.5  0.   0.5  1. ]
            [-1.  -0.5  0.   0.5  1. ]
            [-1.  -0.5  0.   0.5  1. ]]]
 
      C[0]是高轴坐标，C[1]是宽轴坐标。
 
  Step2:
 
      将C转换并重组成形为[H * W, 2]的张量,并追加到最后一个维度
 
      我们得到:
 
      C_ = [[-1.  -1.   1. ]
            [-0.5 -1.   1. ]
            [ 0.  -1.   1. ]
            [ 0.5 -1.   1. ]
            [ 1.  -1.   1. ]
            [-1.  -0.5  1. ]
            [-0.5 -0.5  1. ]
            [ 0.  -0.5  1. ]
            [ 0.5 -0.5  1. ]
            [ 1.  -0.5  1. ]
            [-1.   0.   1. ]
            [-0.5  0.   1. ]
            [ 0.   0.   1. ]
            [ 0.5  0.   1. ]
            [ 1.   0.   1. ]
            [-1.   0.5  1. ]
            [-0.5  0.5  1. ]
            [ 0.   0.5  1. ]
            [ 0.5  0.5  1. ]
            [ 1.   0.5  1. ]
            [-1.   1.   1. ]
            [-0.5  1.   1. ]
            [ 0.   1.   1. ]
            [ 0.5  1.   1. ]
            [ 1.   1.   1. ]]
  Step3:
      按下列公式计算输出

• 参数：
• • theta (Variable)： 一类具有形状为[N, 2, 3]的仿射变换参数
  • out_shape (Variable | list | tuple)：具有格式[N, C, H, W]的目标输出的shape，out_shape可以是变量、列表或元组。
  • name (str|None): 此层的名称(可选)。如果没有设置，将自动命名。返回： Variable: 形为[N, H, W, 2]的输出。

抛出异常： ValueError: 如果输入了不支持的参数类型

代码示例：

import paddle.fluid as fluid
theta = fluid.layers.data(name="x", shape=[2, 3], dtype="float32")
out_shape = fluid.layers.data(name="y", shape=[-1], dtype="float32")
data = fluid.layers.affine_grid(theta, out_shape)
# or
data = fluid.layers.affine_grid(theta, [5, 3, 28, 28])

autoincreased_step_counter

• paddle.fluid.layers.autoincreasedstep_counter(_counter_name=None, begin=1, step=1)

• 创建一个自增变量，每个mini-batch返回主函数运行次数，变量自动加1，默认初始值为1.

• 参数：

• • counter_name (str)-计数名称，默认为 @STEP_COUNTER@
  • begin (int)-开始计数
  • step (int)-执行之间增加的步数返回：全局运行步数

返回类型：变量（Variable）

代码示例：

import paddle.fluid as fluid
global_step = fluid.layers.autoincreased_step_counter(
    counter_name='@LR_DECAY_COUNTER@', begin=0, step=1)

batch_norm

• paddle.fluid.layers.batchnorm(_input, act=None, is_test=False, momentum=0.9, epsilon=1e-05, param_attr=None, bias_attr=None, data_layout='NCHW', in_place=False, name=None, moving_mean_name=None, moving_variance_name=None, do_model_average_for_mean_and_var=False, fuse_with_relu=False, use_global_stats=False)
• 批正则化层（Batch Normalization Layer）

可用作conv2d和全链接操作的正则化函数。该层需要的数据格式如下：

1.NHWC[batch,in_height,in_width,in_channels]2.NCHW[batch,in_channels,in_height,in_width]

更多详情请参考 : Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift

input 是mini-batch的输入特征。

当use_global_stats = True时，

和 不是一个minibatch的统计数据。 它们是全局（或运行）统计数据。 （它通常来自预先训练好的模型。）训练和测试（或预测）具有相同的行为：

• 参数：
• • input (Variable) - 输入变量的排序，可以为 2, 3, 4, 5
  • act （string，默认None）- 激活函数类型，linear|relu|prelu|…
  • is_test （bool,默认False） - 指示它是否在测试阶段。
  • momentum （float，默认0.9）- 此值用于计算 moving_mean 和 moving_var。更新公式为:，， 默认值0.9.
  • epsilon （float，默认1e-05）- 加在分母上为了数值稳定的值。默认值为1e-5。
  • param_attr （ParamAttr|None） - batch_norm参数范围的属性，如果设为None或者是ParamAttr的一个属性，batch_norm创建ParamAttr为param_attr。如果没有设置param_attr的初始化函数，参数初始化为Xavier。默认：None
  • bias_attr （ParamAttr|None） - batch_norm bias参数的属性，如果设为None或者是ParamAttr的一个属性，batch_norm创建ParamAttr为bias_attr。如果没有设置bias_attr的初始化函数，参数初始化为0。默认：None
  • data_layout （string,默认NCHW) - NCHW|NHWC
  • in_place （bool，默认False）- 得出batch norm可复用记忆的输入和输出
  • name （string，默认None）- 该层名称（可选）。若设为None，则自动为该层命名
  • moving_mean_name （string，默认None）- moving_mean的名称，存储全局Mean。如果将其设置为None, batch_norm 将随机命名全局平均值；否则， batch_norm 将命名全局平均值为 moving_mean_name
  • moving_variance_name （string，默认None）- moving_variance的名称，存储全局变量。如果将其设置为None, batch_norm 将随机命名全局方差；否则， batch_norm 将命名全局方差为 moving_variance_name
  • do_model_average_for_mean_and_var （bool，默认False）- 是否为mean和variance做模型均值
  • fuse_with_relu （bool）- 如果为True，batch norm后该操作符执行relu
  • use_global_stats （bool, Default False） – 是否使用全局均值和方差。 在预测或测试模式下，将use_global_stats设置为true或将is_test设置为true，并且行为是等效的。 在训练模式中，当设置use_global_stats为True时，在训练期间也使用全局均值和方差。返回： 张量，在输入中运用批正则后的结果

返回类型：变量（Variable）

代码示例：

import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[3, 7, 3, 7], dtype='float32', append_batch_size=False)
hidden1 = fluid.layers.fc(input=x, size=200, param_attr='fc1.w')
hidden2 = fluid.layers.batch_norm(input=hidden1)

beam_search

• paddle.fluid.layers.beamsearch(_pre_ids, pre_scores, ids, scores, beam_size, end_id, level=0, is_accumulated=True, name=None, return_parent_idx=False)
• 在机器翻译任务中，束搜索(Beam search)是选择候选词的一种经典算法

更多细节参考 Beam Search

该层在一时间步中按束进行搜索。具体而言，根据候选词使用于源句子所得的 scores , 从候选词 ids 中选择当前步骤的 top-K （最佳K）候选词的id，其中 K 是 beam_size ， ids ， scores 是计算单元的预测结果。如果没有提供 ids ，则将会根据 scores 计算得出。 另外， pre_id 和 pre_scores 是上一步中 beam_search 的输出，用于特殊处理翻译的结束边界。

注意，如果 is_accumulated 为 True，传入的 scores 应该是累积分数。反之，scores 会被认为为直接得分(straightforward scores)， 并且会被转化为log值并且在此运算中会被累积到 pre_scores 中。在计算累积分数之前应该使用额外的 operators 进行长度惩罚。

有关束搜索用法演示，请参阅以下示例：

fluid/tests/book/test_machine_translation.py

• 参数:

• • pre_ids （Variable） - LodTensor变量，它是上一步 beam_search 的输出。在第一步中。它应该是LodTensor，shape为，

  • pre_scores （Variable） - LodTensor变量，它是上一步中beam_search的输出

  • ids （Variable） - 包含候选ID的LodTensor变量。shape为，其中 K 应该是 beam_size
  • scores （Variable） - 与 ids 及其shape对应的累积分数的LodTensor变量, 与 ids 的shape相同。
  • beam_size （int） - 束搜索中的束宽度。
  • end_id （int） - 结束标记的id。
  • level （int，default 0） - 可忽略，当前不能更改 。它表示lod的源级别，解释如下。 ids 的 lod 级别应为2.第一级是源级别， 描述每个源句子（beam）的前缀（分支）的数量，第二级是描述这些候选者属于前缀的句子级别的方式。链接前缀和所选候选者的路径信息保存在lod中。
  • is_accumulated （bool，默认为True） - 输入分数是否为累计分数。
  • name （str | None） - 该层的名称（可选）。如果设置为None，则自动命名该层。
  • return_parent_idx （bool） - 是否返回一个额外的Tensor变量，在输出的pre_ids中保留selected_ids的双亲indice，可用于在下一个时间步收集单元状态。返回：LodTensor元组。包含所选的id和与其相应的分数。 如果return_parent_idx为True，则包含一个保留selected_ids的双亲indice的额外Tensor变量。

返回类型：Variable

代码示例

import paddle.fluid as fluid
 
# 假设 `probs` 包含计算神经元所得的预测结果
# `pre_ids` 和 `pre_scores` 为beam_search之前时间步的输出
beam_size = 4
end_id = 1
pre_ids = fluid.layers.data(
    name='pre_id', shape=[1], lod_level=2, dtype='int64')
pre_scores = fluid.layers.data(
    name='pre_scores', shape=[1], lod_level=2, dtype='float32')
probs = fluid.layers.data(
    name='probs', shape=[10000], dtype='float32')
topk_scores, topk_indices = fluid.layers.topk(probs, k=beam_size)
accu_scores = fluid.layers.elementwise_add(
                                      x=fluid.layers.log(x=topk_scores)),
                                      y=fluid.layers.reshape(
                                          pre_scores, shape=[-1]),
                                      axis=0)
selected_ids, selected_scores = fluid.layers.beam_search(
                                      pre_ids=pre_ids,
                                      pre_scores=pre_scores,
                                      ids=topk_indices,
                                      scores=accu_scores,
                                      beam_size=beam_size,
                                      end_id=end_id)

beam_search_decode

• paddle.fluid.layers.beamsearch_decode(_ids, scores, beam_size, end_id, name=None)
• 束搜索层（Beam Search Decode Layer）通过回溯LoDTensorArray ids，为每个源语句构建完整假设，LoDTensorArray ids 的lod可用于恢复束搜索树中的路径。请参阅下面的demo中的束搜索使用示例：

fluid/tests/book/test_machine_translation.py

• 参数:
• • id (Variable) - LodTensorArray，包含所有回溯步骤重中所需的ids。
  • score (Variable) - LodTensorArra，包含所有回溯步骤对应的score。
  • beam_size (int) - 束搜索中波束的宽度。
  • end_id (int) - 结束token的id。
  • name (str|None) - 该层的名称(可选)。如果设置为None，该层将被自动命名。返回： LodTensor 对（pair）， 由生成的id序列和相应的score序列组成。两个LodTensor的shape和lod是相同的。lod的level=2，这两个level分别表示每个源句有多少个假设，每个假设有多少个id。

返回类型: 变量（variable）

代码示例

import paddle.fluid as fluid
 
# 假设 `ids` 和 `scores` 为 LodTensorArray变量，它们保留了
# 选择出的所有时间步的id和score
ids = fluid.layers.create_array(dtype='int64')
scores = fluid.layers.create_array(dtype='float32')
finished_ids, finished_scores = fluid.layers.beam_search_decode(
         ids, scores, beam_size=5, end_id=0)

bilinear_tensor_product

• paddle.fluid.layers.bilineartensor_product(_x, y, size, act=None, name=None, param_attr=None, bias_attr=None)
• 该层对两个输入执行双线性张量积。

例如:

• 在这个公式中：
• • : 第一个输入，包含M个元素，形状为[batch_size, M]
  • : 第二个输入，包含N个元素，形状为[batch_size, N]
  • : 第i个被学习的权重，形状是[M, N]
  • : out的第i个元素，形状是[batch_size, size]
  • :的转置
• 参数：
• • x (Variable): 2-D 输入张量，形状为 [batch_size, M]
  • y (Variable): 2-D 输入张量，形状为 [batch_size, N]
  • size (int): 此层的维度，
  • act (str, default None): 应用到该层输出的激活函数
  • name (str, default None): 该层的名称
  • param_attr (ParamAttr, default None): 可学习参数/权重（w） 的参数属性
  • bias_attr (ParamAttr, default None): 偏差的参数属性，如果设置为False，则不会向输出单元添加偏差。如果设置为零，偏差初始化为零。默认值:None返回： Variable: 一个形为[batch_size, size]的2-D张量

代码示例：

import paddle.fluid as fluid
layer1 = fluid.layers.data("t1", shape=[-1, 5], dtype="float32")
layer2 = fluid.layers.data("t2", shape=[-1, 4], dtype="float32")
tensor = fluid.layers.bilinear_tensor_product(x=layer1, y=layer2, size=1000)

bpr_loss

• paddle.fluid.layers.bprloss(_input, label, name=None)
• 贝叶斯个性化排序损失计算（Bayesian Personalized Ranking Loss Operator ）

该算子属于pairwise的排序类型，其标签是期望物品。在某次会话中某一给定点的损失值由下式计算而得:

]

更多细节请参考 Session Based Recommendations with Recurrent Neural Networks_

• 参数:
• • input (Variable|list) - 一个形为[N x D]的2-D tensor , 其中 N 为批大小batch size ，D 为种类的数量。该输入为logits而非概率。
  • label (Variable|list) - 2-D tensor 类型的真实值, 形为[N x 1]
  • name (str|None) - （可选）该层的命名。 如果为None, 则自动为该层命名。 默认为None.返回: 形为[N x 1]的2D张量，即bpr损失

代码示例：

import paddle.fluid as fluid
 
neg_size = 10
label = fluid.layers.data(
          name="label", shape=[1], dtype="int64")
predict = fluid.layers.data(
          name="predict", shape=[neg_size + 1], dtype="float32")
cost = fluid.layers.bpr_loss(input=predict, label=label)

brelu

• paddle.fluid.layers.brelu(x, t_min=0.0, t_max=24.0, name=None)
• BRelu 激活函数

• 参数:
• • x (Variable) - BReluoperator的输入
  • t_min (FLOAT|0.0) - BRelu的最小值
  • t_max (FLOAT|24.0) - BRelu的最大值
  • name (str|None) - 该层的名称(可选)。如果设置为None，该层将被自动命名代码示例：

import paddle.fluid as fluid
x = fluid.layers.data(name="x", shape=[2,3,16,16], dtype=”float32”)
y = fluid.layers.brelu(x, t_min=1.0, t_max=20.0)

chunk_eval

• paddle.fluid.layers.chunkeval(_input, label, chunk_scheme, num_chunk_types, excluded_chunk_types=None)
• 块估计（Chunk Evaluator）

该功能计算并输出块检测（chunk detection）的准确率、召回率和F1值。

chunking的一些基础请参考 Chunking with Support Vector Machines

ChunkEvalOp计算块检测（chunk detection）的准确率、召回率和F1值，并支持IOB，IOE，IOBES和IO标注方案。以下是这些标注方案的命名实体（NER）标注例子：

====== ====== ======  =====  ==  ============   =====  ===== =====  ==  =========
       Li     Ming    works  at  Agricultural   Bank   of    China  in  Beijing.
====== ====== ======  =====  ==  ============   =====  ===== =====  ==  =========
IO     I-PER  I-PER   O      O   I-ORG          I-ORG  I-ORG I-ORG  O   I-LOC
IOB    B-PER  I-PER   O      O   B-ORG          I-ORG  I-ORG I-ORG  O   B-LOC
IOE    I-PER  E-PER   O      O   I-ORG          I-ORG  I-ORG E-ORG  O   E-LOC
IOBES  B-PER  E-PER   O      O   I-ORG          I-ORG  I-ORG E-ORG  O   S-LOC
====== ====== ======  =====  ==  ============   =====  ===== =====  ==  =========

有三种块类别（命名实体类型），包括PER（人名），ORG（机构名）和LOC（地名），标签形式为标注类型（tag type）-块类型（chunk type）。

由于计算实际上用的是标签id而不是标签，需要额外注意将标签映射到相应的id，这样CheckEvalOp才可运行。关键在于id必须在列出的等式中有效。

tag_type = label % num_tag_type
chunk_type = label / num_tag_type

num_tag_type是标注规则中的标签类型数，num_chunk_type是块类型数，tag_type从下面的表格中获取值。

Scheme Begin Inside End   Single
plain   0     -      -     -
IOB     0     1      -     -
IOE     -     0      1     -
IOBES   0     1      2     3

仍以NER为例，假设标注规则是IOB块类型为ORG，PER和LOC。为了满足以上等式，标签图如下：

B-ORG  0
I-ORG  1
B-PER  2
I-PER  3
B-LOC  4
I-LOC  5
O      6

不难证明等式的块类型数为3，IOB规则中的标签类型数为2.例如I-LOC的标签id为5，I-LOC的标签类型id为1，I-LOC的块类型id为2，与等式的结果一致。

• 参数：
• • input (Variable) - 网络的输出预测
  • label (Variable) - 测试数据集的标签
  • chunk_scheme (str) - 标注规则，表示如何解码块。必须数IOB，IOE，IOBES或者plain。详情见描述
  • num_chunk_types (int) - 块类型数。详情见描述
  • excluded_chunk_types (list) - 列表包含块类型id，表示不在计数内的块类型。详情见描述返回：元组（tuple），包含precision, recall, f1_score, num_infer_chunks, num_label_chunks, num_correct_chunks

返回类型：tuple（元组）

代码示例：

import paddle.fluid as fluid
 
dict_size = 10000
label_dict_len = 7
sequence = fluid.layers.data(
    name='id', shape=[1], lod_level=1, dtype='int64')
embedding = fluid.layers.embedding(
    input=sequence, size=[dict_size, 512])
hidden = fluid.layers.fc(input=embedding, size=512)
label = fluid.layers.data(
    name='label', shape=[1], lod_level=1, dtype='int32')
crf = fluid.layers.linear_chain_crf(
    input=hidden, label=label, param_attr=fluid.ParamAttr(name="crfw"))
crf_decode = fluid.layers.crf_decoding(
    input=hidden, param_attr=fluid.ParamAttr(name="crfw"))
fluid.layers.chunk_eval(
    input=crf_decode,
    label=label,
    chunk_scheme="IOB",
    num_chunk_types=(label_dict_len - 1) / 2)

clip

• paddle.fluid.layers.clip(x, min, max, name=None)
• clip算子

clip算子限制给定输入的值在一个区间内。间隔使用参数”min”和”max”来指定：公式为

• 参数：
• • x （Variable）- （Tensor）clip运算的输入，维数必须在[1,9]之间。
  • min （FLOAT）- （float）最小值，小于该值的元素由min代替。
  • max （FLOAT）- （float）最大值，大于该值的元素由max替换。
  • name （basestring | None）- 输出的名称。返回： （Tensor）clip操作后的输出和输入（X）具有形状（shape）

返回类型： 输出（Variable）。

代码示例：

import paddle.fluid as fluid
input = fluid.layers.data(
    name='data', shape=[1], dtype='float32')
reward = fluid.layers.clip(x=input, min=-1.0, max=1.0)

clip_by_norm

• paddle.fluid.layers.clipby_norm(_x, max_norm, name=None)
• ClipByNorm算子

此算子将输入 X 的L2范数限制在 max_norm 内。如果 X 的L2范数小于或等于 max_norm ，则输出（Out）将与 X 相同。如果X的L2范数大于 max_norm ，则 X 将被线性缩放，使得输出（Out）的L2范数等于 max_norm ，如下面的公式所示：

其中，

代表 x 的L2范数。

• 参数：
• • x (Variable)- (Tensor) clip_by_norm运算的输入，维数必须在[1,9]之间。
  • max_norm (float)- 最大范数值。
  • name (basestring | None)- 输出的名称。返回： (Tensor)clip_by_norm操作后的输出和输入(X)具有形状(shape).

返回类型： Variable

代码示例：

import paddle.fluid as fluid
input = fluid.layers.data(
    name='data', shape=[1], dtype='float32')
reward = fluid.layers.clip_by_norm(x=input, max_norm=1.0)

continuous_value_model

• paddle.fluid.layers.continuousvalue_model(_input, cvm, use_cvm=True)
• continuous_value_model层

现在，continuous value model(cvm)仅考虑CTR项目中的展示和点击值。我们假设输入是一个含cvm_feature的词向量，其形状为[N D]（D为2 + 嵌入维度）。如果use_cvm=True，它会计算log(cvm_feature)，且输出的形状为[N D]。如果use_cvm=False，它会从输入中移除cvm_feature，且输出的形状为[N * (D - 2)]。

该层接受一个名为input的张量，嵌入后成为ID层(lod level为1)， cvm为一个show_click info。

• 参数：
• • input (Variable)-一个N x D的二维LodTensor， N为batch size， D为2 + 嵌入维度， lod level = 1。
  • cvm (Variable)-一个N x 2的二维Tensor， N为batch size，2为展示和点击值。
  • use_cvm (bool)-分使用/不使用cvm两种情况。如果使用cvm，输出维度和输入相等；如果不使用cvm，输出维度为输入-2（移除展示和点击值)。（cvm op是一个自定义的op，其输入是一个含embed_with_cvm默认值的序列，因此我们需要一个名为cvm的op来决定是否使用cvm。）返回：变量，一个N x D的二维LodTensor，如果使用cvm，D等于输入的维度，否则D等于输入的维度-2。

返回类型：变量（Variable）

代码示例:

import paddle.fluid as fluid
input = fluid.layers.data(name="input", shape=[-1, 1], lod_level=1, append_batch_size=False, dtype="int64")#, stop_gradient=False)
label = fluid.layers.data(name="label", shape=[-1, 1], append_batch_size=False, dtype="int64")
embed = fluid.layers.embedding(
                        input=input,
                        size=[100, 11],
                        dtype='float32')
ones = fluid.layers.fill_constant_batch_size_like(input=label, shape=[-1, 1], dtype="int64", value=1)
show_clk = fluid.layers.cast(fluid.layers.concat([ones, label], axis=1), dtype='float32')
show_clk.stop_gradient = True
input_with_cvm = fluid.layers.continuous_value_model(embed, show_clk, True)

conv2d

• paddle.fluid.layers.conv2d(input, num_filters, filter_size, stride=1, padding=0, dilation=1, groups=None, param_attr=None, bias_attr=None, use_cudnn=True, act=None, name=None)
• 卷积二维层（convolution2D layer）根据输入、滤波器（filter）、步长（stride）、填充（padding）、dilations、一组参数计算输出。输入和输出是NCHW格式，N是批尺寸，C是通道数，H是特征高度，W是特征宽度。滤波器是MCHW格式，M是输出图像通道数，C是输入图像通道数，H是滤波器高度，W是滤波器宽度。如果组数大于1，C等于输入图像通道数除以组数的结果。详情请参考UFLDL’s : 卷积 。如果提供了bias属性和激活函数类型，bias会添加到卷积（convolution）的结果中相应的激活函数会作用在最终结果上。

对每个输入X，有等式：

• 其中：
• • ：输入值，NCHW格式的张量（Tensor）
  • ：滤波器值，MCHW格式的张量（Tensor）
  • ： 卷积操作
  • ：Bias值，二维张量（Tensor），shape为 [M,1]
  • ：激活函数
  • ：输出值，Out 和 X 的shape可能不同示例

• 输入：

输入shape：

滤波器shape：

• 输出：

输出shape：

其中

• 参数：
• • input (Variable) - 格式为[N,C,H,W]格式的输入图像
  • num_fliters (int) - 滤波器数。和输出图像通道相同
  • filter_size (int|tuple|None) - 滤波器大小。如果filter_size是一个元组，则必须包含两个整型数，（filter_size，filter_size_W）。否则，滤波器为square
  • stride (int|tuple) - 步长(stride)大小。如果步长（stride）为元组，则必须包含两个整型数，（stride_H,stride_W）。否则，stride_H = stride_W = stride。默认：stride = 1
  • padding (int|tuple) - 填充（padding）大小。如果填充（padding）为元组，则必须包含两个整型数，（padding_H,padding_W)。否则，padding_H = padding_W = padding。默认：padding = 0
  • dilation (int|tuple) - 膨胀（dilation）大小。如果膨胀（dialation）为元组，则必须包含两个整型数，（dilation_H,dilation_W）。否则，dilation_H = dilation_W = dilation。默认：dilation = 1
  • groups (int) - 卷积二维层（Conv2D Layer）的组数。根据Alex Krizhevsky的深度卷积神经网络（CNN）论文中的成组卷积：当group=2，滤波器的前一半仅和输入通道的前一半连接。滤波器的后一半仅和输入通道的后一半连接。默认：groups = 1
  • param_attr (ParamAttr|None) - conv2d的可学习参数/权重的参数属性。如果设为None或者ParamAttr的一个属性，conv2d创建ParamAttr为param_attr。如果param_attr的初始化函数未设置，参数则初始化为，并且std为。默认为None
  • bias_attr (ParamAttr|bool|None) - conv2d bias的参数属性。如果设为False，则没有bias加到输出。如果设为None或者ParamAttr的一个属性，conv2d创建ParamAttr为bias_attr。如果bias_attr的初始化函数未设置，bias初始化为0.默认为None
  • use_cudnn （bool） - 是否用cudnn核，仅当下载cudnn库才有效。默认：True
  • act (str) - 激活函数类型，如果设为None，则未添加激活函数。默认：None
  • name (str|None) - 该层名称（可选）。若设为None，则自动为该层命名。返回：张量，存储卷积和非线性激活结果

返回类型：变量（Variable）

• 抛出异常:
• • ValueError - 如果输入shape和filter_size，stride,padding和group不匹配。代码示例：

import paddle.fluid as fluid
data = fluid.layers.data(name='data', shape=[3, 32, 32], dtype='float32')
conv2d = fluid.layers.conv2d(input=data, num_filters=2, filter_size=3, act="relu")

conv2d_transpose

• paddle.fluid.layers.conv2dtranspose(_input, num_filters, output_size=None, filter_size=None, padding=0, stride=1, dilation=1, groups=None, param_attr=None, bias_attr=None, use_cudnn=True, act=None, name=None)
• 2-D卷积转置层（Convlution2D transpose layer）

该层根据 输入（input）、滤波器（filter）和卷积核膨胀（dilations）、步长（stride）、填充（padding）来计算输出。输入(Input)和输出(Output)为NCHW格式，其中 N 为batch大小， C 为通道数（channel），H 为特征高度， W 为特征宽度。参数(膨胀、步长、填充)分别都包含两个元素。这两个元素分别表示高度和宽度。欲了解卷积转置层细节，请参考下面的说明和 参考文献 。如果参数 bias_attr 和 act 不为 None，则在卷积的输出中加入偏置，并对最终结果应用相应的激活函数。

输入

和输出 函数关系如下：

• 其中：
• • : 输入张量，具有 NCHW 格式
  • : 滤波器张量，具有 NCHW 格式
  • : 卷积操作
  • : 偏置（bias），二维张量，shape为 [M,1]
  • : 激活函数
  • : 输出值，Out和 X 的 shape 可能不一样样例：

输入：

输出：

其中

• 参数:
• • input （Variable）- 输入张量，格式为[N, C, H, W]
  • num_filters (int) - 滤波器（卷积核）的个数，与输出的图片的通道数（ channel ）相同
  • output_size (int|tuple|None) - 输出图片的大小。如果output_size是一个元组（tuple），则该元形式为（image_H,image_W),这两个值必须为整型。如果output_size=None,则内部会使用filter_size、padding和stride来计算output_size。如果output_size和filter_size是同时指定的，那么它们应满足上面的公式。
  • filter_size (int|tuple|None) - 滤波器大小。如果filter_size是一个tuple，则形式为(filter_size_H, filter_size_W)。否则，滤波器将是一个方阵。如果filter_size=None，则内部会计算输出大小。
  • padding (int|tuple) - 填充大小。如果padding是一个元组，它必须包含两个整数(padding_H、padding_W)。否则，padding_H = padding_W = padding。默认:padding = 0。
  • stride (int|tuple) - 步长大小。如果stride是一个元组，那么元组的形式为(stride_H、stride_W)。否则，stride_H = stride_W = stride。默认:stride = 1。
  • dilation (int|元组) - 膨胀(dilation)大小。如果dilation是一个元组，那么元组的形式为(dilation_H, dilation_W)。否则，dilation_H = dilation_W = dilation_W。默认:dilation= 1。
  • groups (int) - Conv2d转置层的groups个数。从Alex Krizhevsky的CNN Deep论文中的群卷积中受到启发，当group=2时，前半部分滤波器只连接到输入通道的前半部分，而后半部分滤波器只连接到输入通道的后半部分。默认值:group = 1。
  • param_attr (ParamAttr|None) - conv2d_transfer中可学习参数/权重的属性。如果param_attr值为None或ParamAttr的一个属性，conv2d_transfer使用ParamAttrs作为param_attr的值。如果没有设置的param_attr初始化器，那么使用Xavier初始化。默认值:None。
  • bias_attr (ParamAttr|bool|None) - conv2d_tran_bias中的bias属性。如果设置为False，则不会向输出单元添加偏置。如果param_attr值为None或ParamAttr的一个属性，将conv2d_transfer使用ParamAttrs作为，bias_attr。如果没有设置bias_attr的初始化器，bias将初始化为零。默认值:None。
  • use_cudnn (bool) - 是否使用cudnn内核，只有已安装cudnn库时才有效。默认值:True。
  • act (str) - 激活函数类型，如果设置为None，则不使用激活函数。默认值:None。
  • name (str|None) - 该layer的名称(可选)。如果设置为None， 将自动命名该layer。默认值:True。返回： 存储卷积转置结果的张量。

返回类型: 变量（variable）

• 抛出异常:
• • ValueError : 如果输入的shape、filter_size、stride、padding和groups不匹配，抛出ValueError代码示例

import paddle.fluid as fluid
data = fluid.layers.data(name='data', shape=[3, 32, 32], dtype='float32')
conv2d_transpose = fluid.layers.conv2d_transpose(input=data, num_filters=2, filter_size=3)

conv3d

• paddle.fluid.layers.conv3d(input, num_filters, filter_size, stride=1, padding=0, dilation=1, groups=None, param_attr=None, bias_attr=None, use_cudnn=True, act=None, name=None)
• 3D卷积层（convolution3D layer）根据输入、滤波器（filter）、步长（stride）、填充（padding）、膨胀（dilations）、组数参数计算得到输出。输入和输出是NCHW格式，N是批尺寸，C是通道数，H是特征高度，W是特征宽度。卷积三维（Convlution3D）和卷积二维（Convlution2D）相似，但多了一维深度（depth）。如果提供了bias属性和激活函数类型，bias会添加到卷积（convolution）的结果中相应的激活函数会作用在最终结果上。

对每个输入X，有等式：

• 其中：
• • ：输入值，NCDHW格式的张量（Tensor）
  • ：滤波器值，MCDHW格式的张量（Tensor）
  • ： 卷积操作
  • ：Bias值，二维张量（Tensor），形为 [M,1]
  • ：激活函数
  • ：输出值, 和 X 的形状可能不同示例
• • 输入：
  • 输入shape：

滤波器shape：

• • 输出：
  • 输出shape：

其中

• 参数：
• • input (Variable) - 格式为[N,C,D,H,W]格式的输入图像
  • num_fliters (int) - 滤波器数。和输出图像通道相同
  • filter_size (int|tuple|None) - 滤波器大小。如果filter_size是一个元组，则必须包含三个整型数，(filter_size_D, filter_size_H, filter_size_W)。否则，滤波器为棱长为int的立方体形。
  • stride (int|tuple) - 步长(stride)大小。如果步长（stride）为元组，则必须包含三个整型数， (stride_D, stride_H, stride_W)。否则，stride_D = stride_H = stride_W = stride。默认：stride = 1
  • padding (int|tuple) - 填充（padding）大小。如果填充（padding）为元组，则必须包含三个整型数，(padding_D, padding_H, padding_W)。否则， padding_D = padding_H = padding_W = padding。默认：padding = 0
  • dilation (int|tuple) - 膨胀（dilation）大小。如果膨胀（dialation）为元组，则必须包含两个整型数， (dilation_D, dilation_H, dilation_W)。否则，dilation_D = dilation_H = dilation_W = dilation。默认：dilation = 1
  • groups (int) - 卷积二维层（Conv2D Layer）的组数。根据Alex Krizhevsky的深度卷积神经网络（CNN）论文中的成组卷积：当group=2，滤波器的前一半仅和输入通道的前一半连接。滤波器的后一半仅和输入通道的后一半连接。默认：groups = 1
  • param_attr (ParamAttr|None) - conv2d的可学习参数/权重的参数属性。如果设为None或者ParamAttr的一个属性，conv2d创建ParamAttr为param_attr。如果param_attr的初始化函数未设置，参数则初始化为，并且std为。默认为None
  • bias_attr (ParamAttr|bool|None) - conv2d bias的参数属性。如果设为False，则没有bias加到输出。如果设为None或者ParamAttr的一个属性，conv2d创建ParamAttr为bias_attr。如果bias_attr的初始化函数未设置，bias初始化为0.默认为None
  • use_cudnn （bool） - 是否用cudnn核，仅当下载cudnn库才有效。默认：True
  • act (str) - 激活函数类型，如果设为None，则未添加激活函数。默认：None
  • name (str|None) - 该层名称（可选）。若设为None，则自动为该层命名。返回：张量，存储卷积和非线性激活结果

返回类型：变量（Variable）

• 抛出异常：
• • ValueError - 如果 input 的形和 filter_size ， stride , padding 和 group 不匹配。代码示例：

import paddle.fluid as fluid
data = fluid.layers.data(name='data', shape=[3, 12, 32, 32], dtype='float32')
conv3d = fluid.layers.conv3d(input=data, num_filters=2, filter_size=3, act="relu")

conv3d_transpose

• paddle.fluid.layers.conv3dtranspose(_input, num_filters, output_size=None, filter_size=None, padding=0, stride=1, dilation=1, groups=None, param_attr=None, bias_attr=None, use_cudnn=True, act=None, name=None)
• 3-D卷积转置层（Convlution3D transpose layer)

该层根据 输入（input）、滤波器（filter）和卷积核膨胀（dilations）、步长（stride）、填充来计算输出。输入(Input)和输出(Output)为NCDHW格式。其中 N 为batch大小， C 为通道数（channel）, D 为特征深度, H 为特征高度， W 为特征宽度。参数(膨胀、步长、填充)分别包含两个元素。这两个元素分别表示高度和宽度。欲了解卷积转置层细节，请参考下面的说明和 参考文献 。如果参数 bias_attr 和 act 不为None，则在卷积的输出中加入偏置，并对最终结果应用相应的激活函数

输入X和输出Out函数关系X，有等式如下：

• 其中：
• • : 输入张量，具有 NCDHW 格式
  • : 滤波器张量，，具有 NCDHW 格式
  • : 卷积操作
  • : 偏置（bias），二维张量，shape为 [M,1]
  • : 激活函数
  • : 输出值， Out 和 X 的 shape可能不一样样例

输入:

输出:

其中：

• 参数:
• • input （Variable）- 输入张量，格式为[N, C, D, H, W]
  • num_filters (int) - 滤波器（卷积核）的个数，与输出的图片的通道数（channel）相同
  • output_size (int|tuple|None) - 输出图片的大小。如果 output_size 是一个元组（tuple），则该元形式为（image_H,image_W),这两个值必须为整型。如果 output_size=None ,则内部会使用filter_size、padding和stride来计算output_size。如果 output_size 和 filter_size 是同时指定的，那么它们应满足上面的公式。
  • filter_size (int|tuple|None) - 滤波器大小。如果 filter_size 是一个tuple，则形式为(filter_size_H, filter_size_W)。否则，滤波器将是一个方阵。如果 filter_size=None ，则内部会计算输出大小。
  • padding (int|tuple) - 填充大小。如果 padding 是一个元组，它必须包含两个整数(padding_H、padding_W)。否则，padding_H = padding_W = padding。默认:padding = 0。
  • stride (int|tuple) - 步长大小。如果 stride 是一个元组，那么元组的形式为(stride_H、stride_W)。否则，stride_H = stride_W = stride。默认:stride = 1。
  • dilation (int|元组) - 膨胀大小。如果 dilation 是一个元组，那么元组的形式为(dilation_H, dilation_W)。否则，dilation_H = dilation_W = dilation_W。默认:dilation= 1。
  • groups (int) - Conv2d转置层的groups个数。从Alex Krizhevsky的CNN Deep论文中的群卷积中受到启发，当group=2时，前半部分滤波器只连接到输入通道的前半部分，而后半部分滤波器只连接到输入通道的后半部分。默认值:group = 1。
  • param_attr (ParamAttr|None) - conv2d_transfer中可学习参数/权重的属性。如果param_attr值为None或ParamAttr的一个属性，conv2d_transfer使用ParamAttrs作为param_attr的值。如果没有设置的param_attr初始化器，那么使用Xavier初始化。默认值:None。
  • bias_attr (ParamAttr|bool|None) - conv2d_tran_bias中的bias属性。如果设置为False，则不会向输出单元添加偏置。如果param_attr值为None或ParamAttr的一个属性，将conv2d_transfer使用ParamAttrs作为，bias_attr。如果没有设置bias_attr的初始化器，bias将初始化为零。默认值:None。
  • use_cudnn (bool) - 是否使用cudnn内核，只有已安装cudnn库时才有效。默认值:True。
  • act (str) - 激活函数类型，如果设置为None，则不使用激活函数。默认值:None。
  • name (str|None) - 该layer的名称(可选)。如果设置为None， 将自动命名该layer。默认值:True。返回： 存储卷积转置结果的张量。

返回类型: 变量（variable）

• 抛出异常:
• • ValueError : 如果输入的shape、filter_size、stride、padding和groups不匹配，抛出ValueError代码示例

import paddle.fluid as fluid
data = fluid.layers.data(name='data', shape=[3, 12, 32, 32], dtype='float32')
conv3d_transpose = fluid.layers.conv3d_transpose(input=data, num_filters=2, filter_size=3)

cos_sim

• paddle.fluid.layers.cossim(_X, Y)
• 余弦相似度算子（Cosine Similarity Operator）

输入X和Y必须具有相同的shape，除非输入Y的第一维为1(不同于输入X)，在计算它们的余弦相似度之前，Y的第一维会被broadcasted，以匹配输入X的shape。

输入X和Y都携带或者都不携带LoD(Level of Detail)信息。但输出仅采用输入X的LoD信息。

• 参数：
• • X (Variable) - cos_sim操作函数的一个输入
  • Y (Variable) - cos_sim操作函数的第二个输入返回：cosine(X,Y)的输出

返回类型：变量（Variable)

代码示例

import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[3, 7], dtype='float32', append_batch_size=False)
y = fluid.layers.data(name='y', shape=[1, 7], dtype='float32', append_batch_size=False)
out = fluid.layers.cos_sim(x, y)

crf_decoding

• paddle.fluid.layers.crfdecoding(_input, param_attr, label=None)
• 该函数读取由 linear_chain_crf 学习的emission feature weights（发射状态特征的权重）和 transition feature weights(转移特征的权重)。本函数实现了Viterbi算法，可以动态地寻找隐藏状态最可能的序列，该序列也被称为Viterbi路径（Viterbi path），从而得出的标注(tags)序列。

这个运算的结果会随着 Label 参数的有无而改变：

1. Label 非None的情况，在实际训练中时常发生。此时本函数会协同 chunk_eval 工作。本函数会返回一行形为[N X 1]的向量，其中值为0的部分代表该label不适合作为对应结点的标注，值为1的部分则反之。此类型的输出可以直接作为 chunk_eval 算子的输入
2. 当没有 Label 时，该函数会执行标准decoding过程

（没有 Label 时）该运算返回一个形为 [N X 1]的向量，其中元素取值范围为 0 ~ 最大标注个数-1，分别为预测出的标注（tag）所在的索引。

• 参数：
• • input (Variable)(LoDTensor，默认类型为 LoDTensor) — 一个形为 [N x D] 的LoDTensor，其中 N 是mini-batch的大小，D是标注（tag) 的总数。 该输入是 linear_chain_crf 的 unscaled emission weight matrix （未标准化的发射权重矩阵）
  • param_attr (ParamAttr) — 参与训练的参数的属性
  • label (Variable)(LoDTensor，默认类型为 LoDTensor) — 形为[N x 1]的正确标注（ground truth）。 该项可选择传入。 有关该参数的更多信息，请详见上述描述返回：(LoDTensor, LoDTensor<int64_t>)decoding结果。具体内容根据 Label 参数是否提供而定。请参照函数介绍来详细了解。

返回类型： Variable

代码示例

import paddle.fluid as fluid
images = fluid.layers.data(name='pixel', shape=[784], dtype='float32')
label = fluid.layers.data(name='label', shape=[1], dtype='int32')
hidden = fluid.layers.fc(input=images, size=2)
crf = fluid.layers.linear_chain_crf(input=hidden, label=label,
        param_attr=fluid.ParamAttr(name="crfw"))
crf_decode = fluid.layers.crf_decoding(input=hidden,
        param_attr=fluid.ParamAttr(name="crfw"))

crop

• paddle.fluid.layers.crop(x, shape=None, offsets=None, name=None)
• 根据偏移量（offsets）和形状（shape），裁剪输入张量。

样例：

* Case 1:
    Given
        X = [[0, 1, 2, 0, 0]
             [0, 3, 4, 0, 0]
             [0, 0, 0, 0, 0]],
    and
        shape = [2, 2],
        offsets = [0, 1],
    output is:
        Out = [[1, 2],
               [3, 4]].
* Case 2:
    Given
        X = [[0, 1, 2, 5, 0]
             [0, 3, 4, 6, 0]
             [0, 0, 0, 0, 0]],
    and shape is tensor
        shape = [[0, 0, 0]
                 [0, 0, 0]]
    and
        offsets = [0, 1],
 
    output is:
        Out = [[1, 2, 5],
               [3, 4, 6]].

• 参数:
• • x (Variable): 输入张量。
  • shape (Variable|list/tuple of integer) - 输出张量的形状由参数shape指定，它可以是一个变量/整数的列表/整数元组。如果是张量变量，它的秩必须与x相同。该方式适可用于每次迭代时候需要改变输出形状的情况。如果是整数列表/tupe，则其长度必须与x的秩相同
  • offsets (Variable|list/tuple of integer|None) - 指定每个维度上的裁剪的偏移量。它可以是一个Variable，或者一个整数list/tupe。如果是一个tensor variable，它的rank必须与x相同，这种方法适用于每次迭代的偏移量（offset）都可能改变的情况。如果是一个整数list/tupe，则长度必须与x的rank的相同，如果shape=None，则每个维度的偏移量为0。
  • name (str|None) - 该层的名称(可选)。如果设置为None，该层将被自动命名。返回: 裁剪张量。

返回类型: 变量（Variable）

抛出异常: 如果形状不是列表、元组或变量，抛出ValueError

代码示例:

import paddle.fluid as fluid
x = fluid.layers.data(name="x", shape=[3, 5], dtype="float32")
y = fluid.layers.data(name="y", shape=[2, 3], dtype="float32")
crop = fluid.layers.crop(x, shape=y)
 
 
## or
z = fluid.layers.data(name="z", shape=[3, 5], dtype="float32")
crop = fluid.layers.crop(z, shape=[2, 3])

cross_entropy

• paddle.fluid.layers.crossentropy(_input, label, soft_label=False, ignore_index=-100)
• 该函数定义了输入和标签之间的cross entropy(交叉熵)层。该函数支持standard cross-entropy computation（标准交叉熵损失计算）以及soft-label cross-entropy computation（软标签交叉熵损失计算）

1. One-hot cross-entropy算法

   soft_label = False, Label[i, 0] 指明样本i的类别所具的索引:

   

2. Soft-label cross-entropy算法

   soft_label = True, Label[i, j] 表明样本i对应类别j的soft label(软标签):

   

   请确保采用此算法时识别为各软标签的概率总和为1

3. One-hot cross-entropy with vecterized label（使用向量化标签的One-hot）算法

   作为 2 的特殊情况，当软类标签内部只有一个非零概率元素，且它的值为1，那么 2 算法降级为一种仅有one-hot标签的one-hot交叉熵

• 参数：
• • input (Variable|list) – 一个形为[N x D]的二维tensor，其中N是batch大小，D是类别（class）数目。 这是由之前的operator计算出的概率，绝大多数情况下是由softmax operator得出的结果
  • label (Variable|list) – 一个二维tensor组成的正确标记的数据集(ground truth)。 当 soft_label 为False时，label为形为[N x 1]的tensor。 soft_label 为True时, label是形为 [N x D]的 tensor
  • soft_label (bool) – 标志位，指明是否需要把给定的标签列表认定为软标签。默认为False。
  • ignore_index (int) – 指定一个被无视的目标值，并且这个值不影响输入梯度。仅在 soft_label 为False时生效。 默认值: kIgnoreIndex返回： 一个形为[N x 1]的二维tensor，承载了交叉熵损失

弹出异常： ValueError

1. 当 input 的第一维和 label 的第一维不相等时，弹出异常
2. 当 soft_label 值为True， 且 input 的第二维和 label 的第二维不相等时，弹出异常
3. 当 soft_label 值为False，且 label 的第二维不是1时，弹出异常

代码示例

import paddle.fluid as fluid
classdim = 7
x = fluid.layers.data(name='x', shape=[3, 7], dtype='float32', append_batch_size=False)
label = fluid.layers.data(name='label', shape=[3, 1], dtype='float32', append_batch_size=False)
predict = fluid.layers.fc(input=x, size=classdim, act='softmax')
cost = fluid.layers.cross_entropy(input=predict, label=label)

ctc_greedy_decoder

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

已知：
 
input.data = [[0.6, 0.1, 0.3, 0.1],
              [0.3, 0.2, 0.4, 0.1],
              [0.1, 0.5, 0.1, 0.3],
              [0.5, 0.1, 0.3, 0.1],
 
              [0.5, 0.1, 0.3, 0.1],
              [0.2, 0.2, 0.2, 0.4],
              [0.2, 0.2, 0.1, 0.5],
              [0.5, 0.1, 0.3, 0.1]]
 
input.lod = [[4, 4]]
 
计算过程：
 
1. 将argmax的运算结果应用于输入的第一个序列，即 input.data[0:4] 。
   则得出的结果为[[0], [2], [1], [0]]
2. 合并重复的索引值部分，删除空格，即为0的值。
   则第一个输入序列对应的输出为：[[2], [1]]
 
最后
 
output.data = [[2],
               [1],
               [3]]
 
output.lod = [[2, 1]]

• 参数:
• • input (Variable) — (LoDTensor)，变长序列的概率，它是一个具有LoD信息的二维张量。它的形状是[Lp, num_classes + 1]，其中Lp是所有输入序列长度的和，num_classes是真正的类别。(不包括空白标签)。
  • blank (int) — Connectionist Temporal Classification (CTC) loss空白标签索引, 属于半开区间[0,num_classes + 1）。
  • name (str) — 此层的名称。可选。返回： CTC贪婪解码结果是一个形为(Lp,1)的二维张量，其中Lp是所有输出序列的长度之和。如果结果中的所有序列都为空，则输出LoDTensor 为[-1]，其中LoD[[]] 形为[1,1]。

返回类型： 变量（Variable）

代码示例

import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[8], dtype='float32')
 
cost = fluid.layers.ctc_greedy_decoder(input=x, blank=0)

data_norm

• paddle.fluid.layers.datanorm(_input, act=None, epsilon=1e-05, param_attr=None, data_layout='NCHW', in_place=False, name=None, moving_mean_name=None, moving_variance_name=None, do_model_average_for_mean_and_var=False)
• 数据正则化层

可用作conv2d和fully_connected操作的正则化函数。 此层所需的数据格式为以下之一：

• NHWC [batch, in_height, in_width, in_channels]
• NCHW [batch, in_channels, in_height, in_width]

为一个mini-batch上的特征:

• 参数:
• • input （variable） - 输入变量，它是一个LoDTensor。
  • act （string，默认None） - 激活函数类型，线性| relu | prelu | …
  • epsilon （float，默认1e-05） -
  • param_attr （ParamAttr） - 参数比例的参数属性。
  • data_layout （string，默认NCHW） - NCHW | NHWC
  • in_place （bool，默认值False） - 使data_norm的输入和输出复用同一块内存。
  • name （string，默认None） - 此层的名称（可选）。 如果设置为None，则将自动命名该层。
  • moving_mean_name （string，Default None） - 存储全局Mean的moving_mean的名称。
  • moving_variance_name （string，默认None） - 存储全局Variance的moving_variance的名称。
  • do_model_average_for_mean_and_var （bool，默认值为false） - 是否为mean和variance进行模型平均。返回: 张量变量，是对输入数据进行正则化后的结果。

返回类型: Variable

代码示例

import paddle.fluid as fluid
 
hidden1 = fluid.layers.data(name="hidden1", shape=[200])
hidden2 = fluid.layers.data_norm(name="hidden2", input=hidden1)

deformable_conv

• paddle.fluid.layers.deformableconv(_input, offset, mask, num_filters, filter_size, stride=1, padding=0, dilation=1, groups=None, deformable_groups=None, im2col_step=None, param_attr=None, bias_attr=None, name=None)
• 可变形卷积层

在4-D输入上计算2-D可变形卷积。给定输入图像x，输出特征图y，可变形卷积操作如下所示：[y(p) = sum_{k=1}^{K}{w_k x(p + p_k + Delta p_k) Delta m_k}]其中(Delta p_k) 和 (Delta m_k) 分别为第k个位置的可学习偏移和调制标量。参考可变形卷积网络v2：可变形程度越高，结果越好。

示例

• 输入：
• 输入形状： ((N, C{in}, H{in}, W{in}))卷积核形状： ((C{out}, C{in}, H_f, W_f))偏移形状： ((N, 2 deformable_groups H_f * H_w, H{in}, W{in}))掩膜形状： ((N, deformable_groups H_f H_w, H{in}, W_{in}))
• 输出：
• 输出形状： ((N, C{out}, H{out}, W_{out}))
• 其中
• [begin{split}H{out}&= frac{(H{in} + 2 paddings[0] - (dilations[0] (Hf - 1) + 1))}{strides[0]} + 1 \W{out}&= frac{(W_{in} + 2 paddings[1] - (dilations[1] (W_f - 1) + 1))}{strides[1]} + 1end{split}]
• 参数：
• • input (Variable) - 形式为[N, C, H, W]的输入图像。
  • offset (Variable) – 可变形卷积层的输入坐标偏移。
  • Mask (Variable) – 可变形卷积层的输入掩膜。
  • num_filters (int) – 卷积核数。和输出图像通道数相同。
  • filter_size (int|tuple|None) – 卷积核大小。如果filter_size为元组，则必须包含两个整数(filter_size_H, filter_size_W)。否则卷积核将为方形。
  • stride (int|tuple) – 步长大小。如果stride为元组，则必须包含两个整数(stride_H, stride_W)。否则stride_H = stride_W = stride。默认stride = 1。
  • padding (int|tuple) – padding大小。如果padding为元组，则必须包含两个整数(padding_H, padding_W)。否则padding_H = padding_W = padding。默认padding = 0。
  • dilation (int|tuple) – dilation大小。如果dilation为元组，则必须包含两个整数(dilation_H, dilation_W)。否则dilation_H = dilation_W = dilation。默认dilation = 1。
  • groups (int) – 可变形卷积层的群组数。依据Alex Krizhevsky的Deep CNN论文中的分组卷积，有：当group=2时，前一半卷积核只和前一半输入通道有关，而后一半卷积核只和后一半输入通道有关。默认groups=1。
  • deformable_groups (int) – 可变形群组分区数。默认deformable_groups = 1。
  • im2col_step (int) – 每个im2col计算的最大图像数。总batch大小应该可以被该值整除或小于该值。如果您面临内存问题，可以尝试在此处使用一个更小的值。默认im2col_step = 64。
  • param_attr (ParamAttr|None) – 可变形卷积的可学习参数/权重的参数属性。如果将其设置为None或ParamAttr的一个属性，可变形卷积将创建ParamAttr作为param_attr。如果没有设置此param_attr的Initializer，该参数将被(Normal(0.0, std))初始化，且其中的(std) 为 ((frac{2.0 }{filter_elem_num})^{0.5})。默认值None。
  • bias_attr (ParamAttr|bool|None) – 可变形卷积层的偏置的参数属性。如果设为False，则输出单元不会加偏置。如果设为None或者ParamAttr的一个属性，conv2d会创建ParamAttr作为bias_attr。如果不设置bias_attr的Initializer，偏置会被初始化为0。默认值None。
  • name (str|None) – 该层的名字（可选项）。如果设为None，该层将会被自动命名。默认值None。返回：储存可变形卷积结果的张量变量。

返回类型：变量(Variable)

抛出：ValueError – 如果input, filter_size, stride, padding和groups的大小不匹配。

代码示例

import paddle.fluid as fluid
data = fluid.layers.data(name='data', shape=[3, 32, 32], dtype='float32')
offset = fluid.layers.data(name='offset', shape=[18, 32, 32], dtype='float32')
mask = fluid.layers.data(name='mask', shape=[9, 32, 32], dtype='float32')
out = fluid.layers.deformable_conv(input=data, offset=offset, mask=mask, num_filters=2, filter_size=3, padding=1)

deformable_roi_pooling

• paddle.fluid.layers.deformableroi_pooling(_input, rois, trans, no_trans=False, spatial_scale=1.0, group_size=[1, 1], pooled_height=1, pooled_width=1, part_size=None, sample_per_part=1, trans_std=0.1, position_sensitive=False, name=None)

• 可变形PSROI池层

• 参数:

• • input (Variable) - 可变形PSROI池层的输入。输入张量的形状为[N，C，H，W]。其中N是批量大小，C是输入通道的数量，H是特征的高度，W是特征的宽度。
  • rois （Variable）- 将池化的ROIs（感兴趣区域）。应为一个形状为(num_rois, 4)的2-D LoDTensor，且lod level为1。给出[[x1, y1, x2, y2], …]，(x1, y1)为左上角坐标，(x2, y2)为右下角坐标。
  • trans （Variable）- 池化时ROIs上的特征偏移。格式为NCHW，其中N是ROIs的数量，C是通道的数量，指示x和y方向上的偏移距离，H是池化的高度，W是池化的宽度。
  • no_trans （bool）- roi池化阶段是否加入偏移以获取新值。取True或False。默认为False。
  • spatial_scale (float) - 输入特征图的高度（或宽度）与原始图像高度（或宽度）的比率。等于卷积图层中总步长的倒数，默认为1.0。
  • group_size （list|tuple）- 输入通道划分成的组数（例如，输入通道的数量是k1 k2 [](https://www.paddlepaddle.org.cn/documentation/docs/zh/1.5/api_cn/layers_cn/#id5)（C + 1），其中k1和k2是组宽度和高度，C + 1是输出通道的数量。如（ 4,6）中4是组的高度，6是组的宽度）。默认为[1,1]。
  • pooled_height （integer）- 池化后输出的高度。
  • pooled_width （integer）- 池化后输出的宽度。
  • part_size （list|tuple）- 偏移高度和宽度，如(4, 6)代表高度为4、宽度为6，默认为None，此时默认值[pooled_height, pooled_width]。
  • sample_per_part （integer）- 每个bin中的样本数量，默认为1。
  • trans_std （float）- 偏移系数，默认为0.1。
  • position_sensitive （bool）- 是否选择可变形psroi池化模式，默认为False。
  • name （str）- 层名，默认为None。返回: 存储可变形psroi池层的张量变量

返回类型: 变量(Variable)

代码示例

import paddle.fluid as fluid
input = fluid.layers.data(name="input",
                          shape=[2, 192, 64, 64],
                          dtype='float32',
                          append_batch_size=False)
rois = fluid.layers.data(name="rois",
                         shape=[4],
                         dtype='float32',
                         lod_level=1)
trans = fluid.layers.data(name="trans",
                          shape=[2, 384, 64, 64],
                          dtype='float32',
                          append_batch_size=False)
x = fluid.layers.nn.deformable_roi_pooling(input=input,
                                             rois=rois,
                                             trans=trans,
                                             no_trans=False,
                                             spatial_scale=1.0,
                                             group_size=(1, 1),
                                             pooled_height=8,
                                             pooled_width=8,
                                             part_size=(8, 8),
                                             sample_per_part=4,
                                             trans_std=0.1,
                                             position_sensitive=False)

dice_loss

• paddle.fluid.layers.diceloss(_input, label, epsilon=1e-05)
• dice_loss是比较两批数据相似度，通常用于二值图像分割，即标签为二值。

dice_loss定义为:

• 参数:
• • input (Variable) - rank>=2的预测。第一个维度是batch大小，最后一个维度是类编号。
  • label （Variable）- 与输入tensor rank相同的正确的标注数据（groud truth）。第一个维度是batch大小，最后一个维度是1。
  • epsilon (float) - 将会加到分子和分母上。如果输入和标签都为空，则确保dice为1。默认值:0.00001返回: dice_loss shape为[1]。

返回类型: dice_loss(Variable)

代码示例

import paddle.fluid as fluid
x = fluid.layers.data(name='data', shape = [3, 224, 224, 2], dtype='float32')
label = fluid.layers.data(name='label', shape=[3, 224, 224, 1], dtype='float32')
predictions = fluid.layers.softmax(x)
loss = fluid.layers.dice_loss(input=predictions, label=label)

dropout

• paddle.fluid.layers.dropout(x, dropout_prob, is_test=False, seed=None, name=None, dropout_implementation='downgrade_in_infer')
• dropout操作

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

dropout op可以从Program中删除，提高执行效率。

• 参数：

• • x (Variable)-输入张量

  • dropout_prob (float)-设置为0的单元的概率

  • is_test (bool)-显示是否进行测试用语的标记

  • seed (int)-Python整型，用于创建随机种子。如果该参数设为None，则使用随机种子。注：如果给定一个整型种子，始终丢弃相同的输出单元。训练过程中勿用固定不变的种子。

  • name (str|None)-该层名称（可选）。如果设置为None,则自动为该层命名

  • dropout_implementation (string) -

[‘downgrade_in_infer’(default)|’upscale_in_train’] 其中:

- 

downgrade_in_infer(default), 在预测时减小输出结果

  - train: out = input * mask
  - inference: out = input * (1.0 - dropout_prob)

(mask是一个张量，维度和输入维度相同，值为0或1，值为0的比例即为 dropout_prob )

- 

upscale_in_train, 增加训练时的结果

  - train: out = input * mask / ( 1.0 - dropout_prob )
  - inference: out = input

(mask是一个张量，维度和输入维度相同，值为0或1，值为0的比例即为 dropout_prob ）

dropout操作符可以从程序中移除，程序变得高效。

返回：与输入X，shape相同的张量

返回类型：变量

代码示例：

import paddle.fluid as fluid
x = fluid.layers.data(name="data", shape=[32, 32], dtype="float32")
droped = fluid.layers.dropout(x, dropout_prob=0.5)

dynamic_gru

• paddle.fluid.layers.dynamicgru(_input, size, param_attr=None, bias_attr=None, is_reverse=False, gate_activation='sigmoid', candidate_activation='tanh', h_0=None, origin_mode=False)
• 实现了Gated Recurrent Unit层。

如果origin_mode为False，那么gru运算公式来自论文 Empirical Evaluation of Gated Recurrent Neural Networks on Sequence Modeling 。

公式如下：

如果origin_mode为True，那么运算公式来自于 Learning Phrase Representations using RNN Encoder Decoder for Statistical Machine Translation

公式如下:

其中，

为按元素将向量相乘。 是更新门（update gate）和重置门（reset gate）的激励函数(activation)， 常为 函数。 是candidate hidden state(候选隐藏状态)的激励函数，常为 。

注意

这些在 input 上的操作不包括在该运算中。用户可以选择性地在GRU层之前使用FC层来进行这一操作。

• 参数:

• • input (Variable) – dynamic_gru层的输入, 支持variable time length input sequence（可变时长输入序列）。 本变量底层的tensor是一个(T×3D)矩阵， 其中T是该mini-batch中总时间步数， D是隐藏状态的规模（hidden size）。

  • size (int) – GRU cell的维度

  • param_attr (ParamAttr|None) – 可学习的隐藏层权重矩阵的参数属性。注意：

• 该矩阵为一个（T X 3D）矩阵。其中D为隐藏状态的规模（hidden size）
• 该矩阵的所有元素由两部分组成。一是update gate和reset gate的权重，形为（D X 2D)，二是候选隐藏状态（candidate hidden state）的权重，形为 (D X D)

如果该函数参数被设为None或者 ParamAttr 类的属性之一，则会生成一个 ParamAttr 类的对象作为param_attr。如果param_attr未被初始化（即其构造函数未被设置），Xavier会负责初始化它。 默认值为None。

• bias_attr (ParamAttr|bool|None) - GRU层bias的参数属性。该（1 X 3D）形的bias变量将会连结（concatenate）在update gate（更新门）、reset gate（重置门）、candidate calculations（候选隐藏状态计算）后。如果值为False，将没有bias会应用到上述三个过程中。如果该函数参数被设为None或者 ParamAttr 类的属性之一， dynamic_gru 会生成一个 ParamAttr 类的对象作为param_attr。如果bias_attr未被初始化（即其构造函数未被设置），则它会被初始化为0。默认值为None。

• is_reverse (bool) –是否计算反GRU(reversed GRU)，默认为False

• gate_activation (str) – update gate 和 reset gate的激励函数（activation）。 可选择[“sigmoid”, “tanh”, “relu”, “identity”]其一, 默认为 “sigmoid”

• candidate_activation (str) – candidate hidden state（候选隐藏状态）计算所需的激励函数（activation）。 可从[“sigmoid”, “tanh”, “relu”, “identity”]中选择, 默认为 “tanh”

• h_0 (Variable) – 该函数参数为初始隐藏状态。若未赋值，则默认为0。它是一个 (N x D) tensor, 其中 N 为输入mini-batch的总时间步数， D 为 隐藏状态规模(hidden size)

返回： GRU的隐藏状态(hidden state)。形为（T X D），序列长度和输入相同。

返回类型: 变量（variable）

代码示例

import paddle.fluid as fluid
 
dict_dim, emb_dim = 128, 64
data = fluid.layers.data(name='sequence', shape=[1],
                         dtype='int32', lod_level=1)
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, size=hidden_dim)

dynamic_lstm

• paddle.fluid.layers.dynamiclstm(_input, size, h_0=None, c_0=None, param_attr=None, bias_attr=None, use_peepholes=True, is_reverse=False, gate_activation='sigmoid', cell_activation='tanh', candidate_activation='tanh', dtype='float32', name=None)
• LSTM，即Long-Short Term Memory(长短期记忆)运算。

默认实现方式为diagonal/peephole连接(https://arxiv.org/pdf/1402.1128.pdf)，公式如下：

W 代表了权重矩阵(weight matrix)，例如

是从输入门（input gate）到输入的权重矩阵, ， ， 是对角权重矩阵(diagonal weight matrix)，用于peephole连接。在此实现方式中，我们使用向量来代表这些对角权重矩阵。

• 其中：
• • 表示bias向量（是输入门的bias向量）
  • 是非线性激励函数（non-linear activations），比如逻辑sigmoid函数
  • ，，和分别为输入门(input gate)，遗忘门(forget gate)，输出门（output gate）,以及神经元激励向量（cell activation vector）这些向量和神经元输出激励向量（cell output activation vector）有相同的大小。
  • 意为按元素将两向量相乘
  • ,分别为神经元(cell)输入、输出的激励函数(activation)。常常使用tanh函数。
  • 也被称为候选隐藏状态(candidate hidden state)。可根据当前输入和之前的隐藏状态计算而得将 use_peepholes 设为False来禁用 peephole 连接方法。 公式等详细信息请参考 http://www.bioinf.jku.at/publications/older/2604.pdf 。

注意，

这些在输入 上的操作不包括在此运算中。用户可以在LSTM operator之前选择使用全连接运算。

• 参数:

• • input (Variable) (LoDTensor) - LodTensor类型，支持variable time length input sequence（时长可变的输入序列）。 该LoDTensor中底层的tensor是一个形为(T X 4D)的矩阵，其中T为此mini-batch上的总共时间步数。D为隐藏层的大小、规模(hidden size)

  • size (int) – 4 * 隐藏层大小

  • h_0 (Variable) – 最初的隐藏状态（hidden state），可选项。默认值为0。它是一个(N x D)张量，其中N是batch大小，D是隐藏层大小。

  • c_0 (Variable) – 最初的神经元状态（cell state）， 可选项。 默认值0。它是一个(N x D)张量, 其中N是batch大小。h_0和c_0仅可以同时为None，不能只其中一个为None。

  • param_attr (ParamAttr|None) – 可学习的隐藏层权重的参数属性。注意：

• Weights =
  
• 形为(D x 4D), 其中D是hidden size（隐藏层规模）

如果它被设为None或者 ParamAttr 属性之一, dynamic_lstm会创建 ParamAttr 对象作为param_attr。如果没有对param_attr初始化（即构造函数没有被设置）， Xavier会负责初始化参数。默认为None。

• bias_attr (ParamAttr|None) – 可学习的bias权重的属性, 包含两部分，input-hidden bias weights（输入隐藏层的bias权重）和 peephole connections weights（peephole连接权重）。如果 use_peepholes 值为 True ， 则意为使用peephole连接的权重。另外：

• use_peepholes = False - Biases =
  
  - 形为(1 x 4D)。
• use_peepholes = True - Biases =
  
  - 形为 (1 x 7D)。

如果它被设为None或 ParamAttr 的属性之一， dynamic_lstm 会创建一个 ParamAttr 对象作为bias_attr。 如果没有对bias_attr初始化（即构造函数没有被设置），bias会被初始化为0。默认值为None。

• use_peepholes (bool) – （默认: True） 是否使用diagonal/peephole连接方式

• is_reverse (bool) – （默认: False） 是否计算反LSTM(reversed LSTM)

• gate_activation (str) – （默认: “sigmoid”）应用于input gate（输入门），forget gate（遗忘门）和 output gate（输出门）的激励函数（activation），默认为sigmoid

• cell_activation (str) – （默认: tanh）用于神经元输出的激励函数(activation), 默认为tanh

• candidate_activation (str) – （默认: tanh）candidate hidden state（候选隐藏状态）的激励函数(activation), 默认为tanh

• dtype (str) – 即 Data type（数据类型）。 可以选择 [“float32”, “float64”]，默认为“float32”

• name (str|None) – 该层的命名，可选项。如果值为None, 将会自动对该层命名

返回：隐藏状态（hidden state），LSTM的神经元状态。两者都是（T x D）形，且LoD保持与输入一致

返回类型: 元组（tuple）

代码示例

import paddle.fluid as fluid
emb_dim = 256
vocab_size = 10000
hidden_dim = 512
 
data = fluid.layers.data(name='x', shape=[1],
               dtype='int32', lod_level=1)
emb = fluid.layers.embedding(input=data, size=[vocab_size, emb_dim], is_sparse=True)
 
forward_proj = fluid.layers.fc(input=emb, size=hidden_dim * 4,
                               bias_attr=False)
forward, _ = fluid.layers.dynamic_lstm(
    input=forward_proj, size=hidden_dim * 4, use_peepholes=False)

dynamic_lstmp

• paddle.fluid.layers.dynamiclstmp(_input, size, proj_size, param_attr=None, bias_attr=None, use_peepholes=True, is_reverse=False, gate_activation='sigmoid', cell_activation='tanh', candidate_activation='tanh', proj_activation='tanh', dtype='float32', name=None, h_0=None, c_0=None, cell_clip=None, proj_clip=None)
• 动态LSTMP层(Dynamic LSTMP Layer)

LSTMP层(具有循环映射的LSTM)在LSTM层后有一个分离的映射层，从原始隐藏状态映射到较低维的状态，用来减少参数总数，减少LSTM计算复杂度，特别是输出单元相对较大的情况下。 Long Short-Term Memory Recurrent Neural Network Architectures for Large Scale Acoustic Modeling

公式如下：

• 在以上公式中：
• • : 代表权重矩阵（例如是输入门道输入的权重矩阵）
  • ,,: peephole connections的对角权重矩阵。在我们的实现中，外面用向量代表这些对角权重矩阵
  • : 代表偏差向量（例如是输入偏差向量）
  • : 激活函数，比如逻辑回归函数
  • 和:分别代表输入门，遗忘门,输出门和cell激活函数向量，四者的大小和cell输出激活函数向量的四者大小相等
  • : 隐藏状态
  • : 隐藏状态的循环映射
  • : 候选隐藏状态
  • : 向量的元素状态生成

  • 和: cell输入和cell输出激活函数，通常使用

  • : 映射输出的激活函数，通常用或等同的

将 use_peepholes 设置为False，断开窥视孔连接（peephole connection）。在此省略公式，详情请参照论文 LONG SHORT-TERM MEMORY 。

注意输入

中的 不在此操作符中。用户选择在LSTMP层之前使用全链接层。

• 参数：

• • input (Variable) - dynamic_lstmp层的输入，支持输入序列长度为变量的倍数。该变量的张量为一个矩阵，维度为（T X 4D），T为mini-batch的总时间步长，D是隐藏大小。

  • size (int) - 4*隐藏状态大小（hidden size）

  • proj_size (int) - 投影输出的大小

  • param_attr (ParamAttr|None) - 可学习hidden-hidden权重和投影权重的参数属性。说明:

• Hidden-hidden （隐藏状态到隐藏状态）权重 =
  
• hidden-hidden权重的权重矩阵为（P4D），P是投影大小，D是隐藏大小。
• 投影（Projection）权重 =
  
• 投影权重的shape为（DP）

如果设为None或者ParamAttr的一个属性，dynamic_lstm将创建ParamAttr为param_attr。如果param_attr的初始函数未设置，参数则初始化为Xavier。默认:None。

• bias_attr (ParamAttr|None) - 可学习bias权重的bias属性，包含输入隐藏的bias权重和窥视孔连接权重（peephole connection）,前提是use_peepholes设为True。

  • 说明:
  • • 1.use_peepholes = False
    • • Biases = {}.
      • 维度为（1*4D）
    • 2.use_peepholes = True
    • • Biases = {}
      • 维度为（1*7D）如果设置为None或者ParamAttr的一个属性，dynamic_lstm将创建ParamAttr为bias_attr。bias_attr的初始函数未设置，bias则初始化为0.默认：None。

• use_peepholes (bool) - 是否开启诊断/窥视孔链接，默认为True。

• is_reverse (bool) - 是否计算反向LSTM，默认为False。

• gate_activation (bool) - 输入门（input gate）、遗忘门（forget gate）和输出门（output gate）的激活函数。Choices = [“sigmoid”，“tanh”，“relu”，“identity”]，默认“sigmoid”。

• cell_activation (str) - cell输出的激活函数。Choices = [“sigmoid”，“tanh”，“relu”，“identity”]，默认“tanh”。

• candidate_activation (str) - 候选隐藏状态（candidate hidden state）的激活状态。Choices = [“sigmoid”，“tanh”，“relu”，“identity”]，默认“tanh”。

• proj_activation (str) - 投影输出的激活函数。Choices = [“sigmoid”，“tanh”，“relu”，“identity”]，默认“tanh”。

• dtype (str) - 数据类型。Choices = [“float32”，“float64”]，默认“float32”。

• name (str|None) - 该层名称（可选）。若设为None，则自动为该层命名。

• h_0 (Variable) - 初始隐藏状态是可选输入，默认为0。这是一个具有形状的张量(N x D)，其中N是批大小，D是投影大小。

• c_0 (Variable) - 初始cell状态是可选输入，默认为0。这是一个具有形状(N x D)的张量，其中N是批大小。h_0和c_0可以为空，但只能同时为空。

• cell_clip (float) - 如果提供该参数，则在单元输出激活之前，单元状态将被此值剪裁。

• proj_clip (float) - 如果 num_proj > 0 并且 proj_clip 被提供,那么将投影值沿元素方向剪切到[-proj_clip，proj_clip]内

返回：含有两个输出变量的元组，隐藏状态（hidden state）的投影和LSTMP的cell状态。投影的shape为（TP），cell state的shape为（TD），两者的LoD和输入相同。

返回类型：元组(tuple)

代码示例：

import paddle.fluid as fluid
dict_dim, emb_dim = 128, 64
data = fluid.layers.data(name='sequence', shape=[1],
                     dtype='int32', lod_level=1)
emb = fluid.layers.embedding(input=data, size=[dict_dim, emb_dim])
hidden_dim, proj_dim = 512, 256
fc_out = fluid.layers.fc(input=emb, size=hidden_dim * 4,
                     act=None, bias_attr=None)
proj_out, _ = fluid.layers.dynamic_lstmp(input=fc_out,
                                     size=hidden_dim * 4,
                                     proj_size=proj_dim,
                                     use_peepholes=False,
                                     is_reverse=True,
                                     cell_activation="tanh",
                                     proj_activation="tanh")

edit_distance

• paddle.fluid.layers.editdistance(_input, label, normalized=True, ignored_tokens=None)
• 编辑距离算子

计算一批给定字符串及其参照字符串间的编辑距离。编辑距离也称Levenshtein距离，通过计算从一个字符串变成另一个字符串所需的最少操作步骤来衡量两个字符串的相异度。这里的操作包括插入、删除和替换。

比如给定假设字符串A=“kitten”和参照字符串B=“sitting”，从A变换成B编辑距离为3，至少需要两次替换和一次插入：

“kitten”->“sitten”->“sittn”->“sitting”

输入为LoDTensor,包含假设字符串（带有表示批尺寸的总数）和分离信息（具体为LoD信息）。并且批尺寸大小的参照字符串和输入LoDTensor的顺序保持一致。

输出包含批尺寸大小的结果，代表一对字符串中每个字符串的编辑距离。如果Attr(normalized)为真，编辑距离则处以参照字符串的长度。

• 参数：
• • input (Variable)-假设字符串的索引
  • label (Variable)-参照字符串的索引
  • normalized (bool,默认为True)-表示是否用参照字符串的长度进行归一化
  • ignored_tokens (list,默认为None)-计算编辑距离前需要移除的token
  • name (str)-该层名称，可选返回：[batch_size,1]中序列到序列到编辑距离

返回类型：变量

代码示例：

import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[1], dtype='int64')
y = fluid.layers.data(name='y', shape=[1], dtype='int64')
cost, _ = fluid.layers.edit_distance(input=x,label=y)
 
cpu = fluid.core.CPUPlace()
exe = fluid.Executor(cpu)
exe.run(fluid.default_startup_program())
 
import numpy
x_ = numpy.random.randint(5, size=(2, 1)).astype('int64')
y_ = numpy.random.randint(5, size=(2, 1)).astype('int64')
 
print(x_)
print(y_)
 
x = fluid.create_lod_tensor(x_, [[2]], cpu)
y = fluid.create_lod_tensor(y_, [[2]], cpu)
 
outs = exe.run(feed={'x':x, 'y':y}, fetch_list=[cost.name])
 
print(outs)

elementwise_add

• paddle.fluid.layers.elementwiseadd(_x, y, axis=-1, act=None, name=None)
• 逐元素相加算子

等式为：

• ：任意维度的张量（Tensor）.
• ：一个维度必须小于等于X维度的张量（Tensor）。
• 对于这个运算算子有2种情况：
• • 的形状（shape）与相同。
  • 的形状（shape）是的连续子序列。
• 对于情况2:
• • 用匹配的形状（shape），则 axis 为传到上的起始维度索引。
  • 如果 axis 为-1（默认值），则。
  • 考虑到子序列，的大小为1的尾部维度将被忽略，例如shape（Y）=（2,1）=>（2）。例如：

shape(X) = (2, 3, 4, 5), shape(Y) = (,)
shape(X) = (2, 3, 4, 5), shape(Y) = (5,)
shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2
shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1
shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0
shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0

输入

和 可以携带不同的LoD信息。但输出仅与输入 共享LoD信息。

• 参数：
• • x （Tensor）- 第一个输入张量（Tensor）。
  • y （Tensor）- 第二个输入张量（Tensor）。
  • axis （INT）- （int，默认-1）。将Y传到X上的起始维度索引。
  • act （basestring | None）- 激活函数名称，应用于输出。
  • name （basestring | None）- 输出的名称。返回： 元素运算的输出。

代码示例

import paddle.fluid as fluid
# 例1: shape(x) = (2, 3, 4, 5), shape(y) = (2, 3, 4, 5)
x0 = fluid.layers.data(name="x0", shape=[2, 3, 4, 5], dtype='float32')
y0 = fluid.layers.data(name="y0", shape=[2, 3, 4, 5], dtype='float32')
z0 = fluid.layers.elementwise_add(x0, y0)
 
# 例2: shape(X) = (2, 3, 4, 5), shape(Y) = (5)
x1 = fluid.layers.data(name="x1", shape=[2, 3, 4, 5], dtype='float32')
y1 = fluid.layers.data(name="y1", shape=[5], dtype='float32')
z1 = fluid.layers.elementwise_add(x1, y1)
 
# 例3: shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2
x2 = fluid.layers.data(name="x2", shape=[2, 3, 4, 5], dtype='float32')
y2 = fluid.layers.data(name="y2", shape=[4, 5], dtype='float32')
z2 = fluid.layers.elementwise_add(x2, y2, axis=2)
 
# 例4: shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1
x3 = fluid.layers.data(name="x3", shape=[2, 3, 4, 5], dtype='float32')
y3 = fluid.layers.data(name="y3", shape=[3, 4], dtype='float32')
z3 = fluid.layers.elementwise_add(x3, y3, axis=1)
 
# 例5: shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0
x4 = fluid.layers.data(name="x4", shape=[2, 3, 4, 5], dtype='float32')
y4 = fluid.layers.data(name="y4", shape=[2], dtype='float32')
z4 = fluid.layers.elementwise_add(x4, y4, axis=0)
 
# 例6: shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0
x5 = fluid.layers.data(name="x5", shape=[2, 3, 4, 5], dtype='float32')
y5 = fluid.layers.data(name="y5", shape=[2], dtype='float32')
z5 = fluid.layers.elementwise_add(x5, y5, axis=0)

elementwise_div

• paddle.fluid.layers.elementwisediv(_x, y, axis=-1, act=None, name=None)
• 逐元素相除算子

等式是：

• ：任何维度的张量（Tensor）。
• ：维度必须小于或等于X维度的张量（Tensor）。
• 此运算算子有两种情况：
• • 的形状（shape）与相同。
  • 的形状（shape）是的连续子序列。
• 对于情况2：
• • 用匹配的形状（shape），其中 axis 将是传到上的起始维度索引。
  • 如果 axis 为-1（默认值），则。
  • 考虑到子序列，的大小为1的尾部维度将被忽略，例如shape（Y）=（2,1）=>（2）。例如：

shape(X) = (2, 3, 4, 5), shape(Y) = (,)
shape(X) = (2, 3, 4, 5), shape(Y) = (5,)
shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2
shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1
shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0
shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0

输入

和 可以携带不同的LoD信息。但输出仅与输入 共享LoD信息。

• 参数：
• • x （Tensor）- 第一个输入张量（Tensor）。
  • y （Tensor）- 第二个输入张量（Tensor）。
  • axis （INT）- （int，默认-1）。将Y传到X上的起始维度索引。
  • act （basestring | None）- 激活函数名称，应用于输出。
  • name （basestring | None）- 输出的名称。返回： 元素运算的输出。

代码示例

import paddle.fluid as fluid
# 例1: shape(x) = (2, 3, 4, 5), shape(y) = (2, 3, 4, 5)
x0 = fluid.layers.data(name="x0", shape=[2, 3, 4, 5], dtype='float32')
y0 = fluid.layers.data(name="y0", shape=[2, 3, 4, 5], dtype='float32')
z0 = fluid.layers.elementwise_div(x0, y0)
 
# 例2: shape(X) = (2, 3, 4, 5), shape(Y) = (5)
x1 = fluid.layers.data(name="x1", shape=[2, 3, 4, 5], dtype='float32')
y1 = fluid.layers.data(name="y1", shape=[5], dtype='float32')
z1 = fluid.layers.elementwise_div(x1, y1)
 
# 例3: shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2
x2 = fluid.layers.data(name="x2", shape=[2, 3, 4, 5], dtype='float32')
y2 = fluid.layers.data(name="y2", shape=[4, 5], dtype='float32')
z2 = fluid.layers.elementwise_div(x2, y2, axis=2)
 
# 例4: shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1
x3 = fluid.layers.data(name="x3", shape=[2, 3, 4, 5], dtype='float32')
y3 = fluid.layers.data(name="y3", shape=[3, 4], dtype='float32')
z3 = fluid.layers.elementwise_div(x3, y3, axis=1)
 
# 例5: shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0
x4 = fluid.layers.data(name="x4", shape=[2, 3, 4, 5], dtype='float32')
y4 = fluid.layers.data(name="y4", shape=[2], dtype='float32')
z4 = fluid.layers.elementwise_div(x4, y4, axis=0)
 
# 例6: shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0
x5 = fluid.layers.data(name="x5", shape=[2, 3, 4, 5], dtype='float32')
y5 = fluid.layers.data(name="y5", shape=[2], dtype='float32')
z5 = fluid.layers.elementwise_div(x5, y5, axis=0)