Skip to content

F
FluidDoc

PaddlePaddle / FluidDoc

通知 5
Star 2
Fork 0
F
FluidDoc
提交 bf87c5c0 编写于 作者: H Hao Wang 提交者： Cheerego
浏览文件
操作

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

* break up layers and change index of layers

* prettify script
上级 3b6e71ba
隐藏空白更改
内联 并排
Showing with 15168 addition and 15124 deletion
doc/fluid/api_cn/layers-breakdown.py 0 → 100644
浏览文件 @ bf87c5c0
#!/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.rst
浏览文件 @ bf87c5c0
因为 它太大了无法显示 source diff 。你可以改为 查看blob。
doc/fluid/api_cn/layers_cn/control_flow_cn.rst 0 → 100644
浏览文件 @ bf87c5c0
=================
control_flow
=================
.. _cn_api_fluid_layers_array_length:
array_length
-------------------------------
.. py:function:: paddle.fluid.layers.array_length(array)
**得到输入LoDTensorArray的长度**
此功能用于查找输入数组LOD_TENSOR_ARRAY的长度。
相关API:
- :ref:`cn_api_fluid_layers_array_read`
- :ref:`cn_api_fluid_layers_array_write`
- :ref:`cn_api_fluid_layers_While`
参数：
- **array** (LOD_TENSOR_ARRAY)-输入数组，用来计算数组长度
返回：输入数组LoDTensorArray的长度
返回类型：变量（Variable）
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
tmp = fluid.layers.zeros(shape=[10], dtype='int32')
i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=10)
arr = fluid.layers.array_write(tmp, i=i)
arr_len = fluid.layers.array_length(arr)
.. _cn_api_fluid_layers_array_read:
array_read
-------------------------------
.. py:function:: paddle.fluid.layers.array_read(array,i)
此函数用于读取数据，数据以LOD_TENSOR_ARRAY数组的形式读入
::
Given:
array = [0.6,0.1,0.3,0.1]
And:
I=2
Then:
output = 0.3
参数：
- **array** (Variable|list)-输入张量，存储要读的数据
- **i** (Variable|list)-输入数组中数据的索引
返回：张量类型的变量，已有数据写入
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
array = fluid.layers.create_array(dtype='float32')
i = fluid.layers.fill_constant(shape=[1],dtype='int64',value=10)
item = fluid.layers.array_read(array, i)
.. _cn_api_fluid_layers_array_write:
array_write
-------------------------------
.. py:function:: paddle.fluid.layers.array_write(x, i, array=None)
该函数将给定的输入变量（即 ``x`` ）写入一个作为输出的 ``LOD_TENSOR_ARRAY`` 变量的某一指定位置中，
这一位置由数组下标(即 ``i`` )指明。 如果 ``LOD_TENSOR_ARRAY`` (即 ``array`` )未指定（即为None值）， 一个新的 ``LOD_TENSOR_ARRAY`` 将会被创建并作为结果返回。
参数:
- **x** (Variable|list) – 待从中读取数据的输入张量(tensor)
- **i** (Variable|list) – 输出结果 ``LOD_TENSOR_ARRAY`` 的下标, 该下标指向输入张量 ``x`` 写入输出数组的位置
- **array** (Variable|list) – 会被输入张量 ``x`` 写入的输出结果 ``LOD_TENSOR_ARRAY`` 。如果该项值为None， 一个新的 ``LOD_TENSOR_ARRAY`` 将会被创建并作为结果返回
返回: 输入张量 ``x`` 所写入的输出结果 ``LOD_TENSOR_ARRAY``
返回类型: 变量（Variable）
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
tmp = fluid.layers.zeros(shape=[10], dtype='int32')
i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=10)
arr = fluid.layers.array_write(tmp, i=i)
.. _cn_api_fluid_layers_create_array:
create_array
-------------------------------
.. py:function:: paddle.fluid.layers.create_array(dtype)
创建LoDTensorArray数组。它主要用于实现RNN与array_write, array_read和While。
参数:
- **dtype** (int |float) — lod_tensor_array中存储元素的数据类型。
返回: lod_tensor_array， 元素数据类型为dtype。
返回类型: Variable。
**代码示例**
.. code-block:: python
data = fluid.layers.create_array(dtype='float32')
.. _cn_api_fluid_layers_DynamicRNN:
DynamicRNN
-------------------------------
.. py:class:: paddle.fluid.layers.DynamicRNN(name=None)
动态RNN可以处理一批序列数据,每个样本序列的长度可以不同。这个API自动批量处理它们。
必须设置输入lod，请参考 ``lod_tensor``
动态RNN将按照timesteps展开开序列。用户需要在with block中定义如何处理处理每个timestep。
memory用于缓存分段数据。memory的初始值可以是零，也可以是其他变量。
动态RNN可以将多个变量标记为其输出。使用drnn()获得输出序列。
.. note::
目前不支持在DynamicRNN中任何层上配置 is_sparse = True
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
sentence = fluid.layers.data(name='sentence', shape=[1], dtype='int64', lod_level=1)
embedding = fluid.layers.embedding(input=sentence, size=[65536, 32], is_sparse=True)
drnn = fluid.layers.DynamicRNN()
with drnn.block():
word = drnn.step_input(embedding)
prev = drnn.memory(shape=[200])
hidden = fluid.layers.fc(input=[word, prev], size=200, act='relu')
drnn.update_memory(prev, hidden) # set prev to hidden
drnn.output(hidden)
# 获得上一个timestep的rnn，该值是一个编码后的结果
rnn_output = drnn()
last = fluid.layers.sequence_last_step(rnn_output)
.. py:method:: step_input(x, level=0)
将序列标记为动态RNN输入。
参数:
- **x** (Variable) - 含lod信息的输入序列
- **level** (int) - 用于拆分步骤的LOD层级，默认值0
返回:当前的输入序列中的timestep。
.. py:method:: static_input(x)
将变量标记为RNN输入。输入不会分散到timestep中。为可选项。
参数:
- **x** (Variable) - 输入序列
返回:可以访问的RNN的输入变量。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
sentence = fluid.layers.data(name='sentence', dtype='float32', shape=[32], lod_level=1)
encoder_proj = fluid.layers.data(name='encoder_proj', dtype='float32', shape=[32], lod_level=1)
decoder_boot = fluid.layers.data(name='boot', dtype='float32', shape=[10], lod_level=1)
drnn = fluid.layers.DynamicRNN()
with drnn.block():
current_word = drnn.step_input(sentence)
encoder_word = drnn.static_input(encoder_proj)
hidden_mem = drnn.memory(init=decoder_boot, need_reorder=True)
fc_1 = fluid.layers.fc(input=encoder_word, size=30, bias_attr=False)
fc_2 = fluid.layers.fc(input=current_word, size=30, bias_attr=False)
decoder_inputs = fc_1 + fc_2
h, _, _ = fluid.layers.gru_unit(input=decoder_inputs, hidden=hidden_mem, size=30)
drnn.update_memory(hidden_mem, h)
out = fluid.layers.fc(input=h, size=10, bias_attr=True, act='softmax')
drnn.output(out)
rnn_output = drnn()
.. py:method:: block()
用户在RNN中定义operators的block。
.. py:method:: memory(init=None, shape=None, value=0.0, need_reorder=False, dtype='float32')
为动态rnn创建一个memory 变量。
如果 ``init`` 不是None， ``memory`` 将由这个变量初始化。参数 ``need_reorder`` 用于将memory重新排序作为输入变量。当memory初始化依赖于输入样本时，应该将其设置为True。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
sentence = fluid.layers.data(name='sentence', shape=[32], dtype='float32', lod_level=1)
boot_memory = fluid.layers.data(name='boot', shape=[10], dtype='float32', lod_level=1)
drnn = fluid.layers.DynamicRNN()
with drnn.block():
word = drnn.step_input(sentence)
memory = drnn.memory(init=boot_memory, need_reorder=True)
hidden = fluid.layers.fc(input=[word, memory], size=10, act='tanh')
drnn.update_memory(ex_mem=memory, new_mem=hidden)
drnn.output(hidden)
rnn_output = drnn()
否则，如果已经设置 ``shape`` 、 ``value`` 、 ``dtype`` ，memory将被 ``value`` 初始化
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
sentence = fluid.layers.data(name='sentence', dtype='float32', shape=[32], lod_level=1)
drnn = fluid.layers.DynamicRNN()
with drnn.block():
word = drnn.step_input(sentence)
memory = drnn.memory(shape=[10], dtype='float32', value=0)
hidden = fluid.layers.fc(input=[word, memory], size=10, act='tanh')
drnn.update_memory(ex_mem=memory, new_mem=hidden)
drnn.output(hidden)
rnn_output = drnn()
参数：
- **init** (Variable|None) – 初始化的Variable
- **shape** (list|tuple) – memory shape，形状不包含batch_size
- **value** (float) – 初始化的值
- **need_reorder** (bool) – memory初始化依赖于输入样本时设置为True
- **dtype** (str|numpy.dtype) – 初始化memory的数据类型
返回：memory Variable
.. py:method:: update_memory(ex_mem, new_mem)
将内存从 ``ex_mem`` 更新到 ``new_mem`` 。注意， ``ex_mem`` 和 ``new_mem`` 的 ``shape`` 和数据类型必须相同。
参数：
- **ex_mem** （memory Variable）- memory 变量（Variable）
- **new_mem** （memory Variable）- RNN块中生成的平坦变量（plain variable）
返回：None
.. py:method:: output(*outputs)
标记RNN输出变量。
参数:
- **\*outputs** - 输出变量。
返回:None
.. _cn_api_fluid_layers_equal:
equal
-------------------------------
.. py:function:: paddle.fluid.layers.equal(x,y,cond=None)
**equal**
该层返回 :math:`x==y` 按逐元素运算而得的真值。
参数：
- **x** (Variable)-equal的第一个操作数
- **y** (Variable)-equal的第二个操作数
- **cond** (Variable|None)-输出变量（可选），用来存储equal的结果
返回：张量类型的变量，存储equal的输出结果
返回类型：变量（Variable）
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
label = fluid.layers.data(name="label", shape=[3,10,32,32], dtype="float32")
limit = fluid.layers.data(name="limit", shape=[3,10,32,32], dtype="float32")
less = fluid.layers.equal(x=label,y=limit)
.. _cn_api_fluid_layers_greater_equal:
greater_equal
-------------------------------
.. py:function:: paddle.fluid.layers.greater_equal(x, y, cond=None)
该层逐元素地返回 :math:`x >= y` 的逻辑值，和重载算子 `>=` 相同。
参数：
- **x** (Variable) - *greater_equal* 的第一个操作数
- **y** (Variable) - *greater_equal* 的第二个操作数
- **cond** (Variable|None) - 可选的输出变量，存储 *greater_equal* 的结果
返回：存储 *greater_equal* 的输出的张量变量。
返回类型：变量（Variable）
**代码示例**:
.. code-block:: python
out = fluid.layers.greater_equal(x=label, y=limit)
.. _cn_api_fluid_layers_greater_than:
greater_than
-------------------------------
.. py:function:: paddle.fluid.layers.greater_than(x, y, cond=None)
该层逐元素地返回 :math:`x > y` 的逻辑值，和重载算子 `>` 相同。
参数：
- **x** (Variable) - *greater_than* 的第一个操作数
- **y** (Variable) - *greater_than* 的第二个操作数
- **cond** (Variable|None) - 可选的输出变量，存储 *greater_than* 的结果
返回：存储 *greater_than* 的输出的张量变量。
返回类型：变量（Variable）
**代码示例**:
.. code-block:: python
out = fluid.layers.greater_than(x=label, y=limit)
.. _cn_api_fluid_layers_IfElse:
IfElse
-------------------------------
.. py:class:: paddle.fluid.layers.IfElse(cond, name=None)
if-else控制流。
参数：
- **cond** (Variable)-用于比较的条件
- **Name** (str,默认为空（None）)-该层名称
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
image = fluid.layers.data(name="X", shape=[2, 5, 5], dtype='float32')
label = fluid.layers.data(name='label', shape=[1], dtype='int64')
limit = fluid.layers.fill_constant_batch_size_like(
input=label, dtype='int64', shape=[1], value=5.0)
cond = fluid.layers.less_than(x=label, y=limit)
ie = fluid.layers.IfElse(cond)
with ie.true_block():
true_image = ie.input(image)
hidden = fluid.layers.fc(input=true_image, size=100, act='tanh')
prob = fluid.layers.fc(input=hidden, size=10, act='softmax')
ie.output(prob)
with ie.false_block():
false_image = ie.input(image)
hidden = fluid.layers.fc(
input=false_image, size=200, act='tanh')
prob = fluid.layers.fc(input=hidden, size=10, act='softmax')
ie.output(prob)
prob = ie()
.. _cn_api_fluid_layers_increment:
increment
-------------------------------
.. py:function:: paddle.fluid.layers.increment(x, value=1.0, in_place=True)
该函数为输入 ``x`` 增加 ``value`` 大小, ``value`` 即函数中待传入的参数。该函数默认直接在原变量 ``x`` 上进行运算。
.. note::
``x`` 中元素个数必须为1
参数:
- **x** (Variable|list) – 含有输入值的张量(tensor)
- **value** (float) – 需要增加在 ``x`` 变量上的值
- **in_place** (bool) – 判断是否在x变量本身执行操作，True原地执行，False时，返回增加后的副本
返回： 每个元素增加后的对象
返回类型：变量(variable)
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.data(name='data', shape=[1], dtype='float32',
append_batch_size=False)
data = fluid.layers.increment(x=data, value=3.0, in_place=True)
.. _cn_api_fluid_layers_is_empty:
is_empty
-------------------------------
.. py:function:: paddle.fluid.layers.is_empty(x, cond=None)
测试变量是否为空
参数：
- **x** (Variable)-测试的变量
- **cond** (Variable|None)-输出参数。返回给定x的测试结果，默认为空（None）
返回：布尔类型的标量。如果变量x为空则值为真
返回类型：变量（Variable）
抛出异常：``TypeError``-如果input不是变量或cond类型不是变量
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
input = fluid.layers.data(name="input", shape=[4, 32, 32], dtype="float32")
res = fluid.layers.is_empty(x=input)
# or:
# fluid.layers.is_empty(x=input, cond=res)
.. _cn_api_fluid_layers_less_equal:
less_equal
-------------------------------
.. py:function:: paddle.fluid.layers.less_equal(x, y, cond=None)
该层逐元素地返回 :math:`x <= y` 的逻辑值，和重载算子 `<=` 相同。
参数：
- **x** (Variable) - *less_equal* 的第一个操作数
- **y** (Variable) - *less_equal* 的第二个操作数
- **cond** (Variable|None) - 可选的输出变量，存储 *less_equal* 的结果
返回：存储 *less_equal* 的输出的张量变量。
返回类型：变量（Variable）
**代码示例**:
.. code-block:: python
out = fluid.layers.less_equal(x=label, y=limit)
.. _cn_api_fluid_layers_less_than:
less_than
-------------------------------
.. py:function:: paddle.fluid.layers.less_than(x, y, force_cpu=None, cond=None)
该函数按元素出现顺序依次在X,Y上操作，并返回 ``Out`` ，它们三个都是n维tensor（张量）。
其中，X、Y可以是任何类型的tensor，Out张量的各个元素可以通过 :math:`Out=X<Y` 计算得出。
参数：
- **x** (Variable) – ``less_than`` 运算的左操作数
- **y** (Variable) – ``less_than`` 运算的右操作数
- **force_cpu** (BOOLEAN) – 值True则强制将输出变量写入CPU内存中。否则，将其写入目前所在的运算设备上。默认为True
- **cond** (Variable|None) – 可选的用于存储 ``less_than`` 输出结果的变量，为None则由函数自动生成Out变量
返回： n维bool型tensor，其中各个元素可以通过 *Out=X<Y* 计算得出
**代码示例**:
.. code-block:: python
label = fluid.layers.data(name='y', shape=[1], dtype='int64')
limit = fluid.layers.fill_constant(shape=[1], dtype='int64', value=5)
cond = fluid.layers.less_than(x=label, y=limit)
.. _cn_api_fluid_layers_not_equal:
not_equal
-------------------------------
.. py:function:: paddle.fluid.layers.not_equal(x, y, cond=None)
该层逐元素地返回 :math:`x != y` 的逻辑值，和重载算子 `!=` 相同。
参数：
- **x** (Variable) - *not_equal* 的第一个操作数
- **y** (Variable) - *not_equal* 的第二个操作数
- **cond** (Variable|None) - 可选的输出变量，存储 *not_equal* 的结果
返回：存储 *not_equal* 的输出的张量变量。
返回类型：变量（Variable）
**代码示例**:
.. code-block:: python
out = fluid.layers.not_equal(x=label, y=limit)
.. _cn_api_fluid_layers_Print:
Print
-------------------------------
.. py:function:: paddle.fluid.layers.Print(input, first_n=-1, message=None, summarize=-1, print_tensor_name=True, print_tensor_type=True, print_tensor_shape=True, print_tensor_lod=True, print_phase='both')
**Print操作命令**
该操作命令创建一个打印操作，打印正在访问的张量。
封装传入的张量，以便无论何时访问张量，都会打印信息message和张量的当前值。
参数：
- **input** (Variable)-将要打印的张量
- **summarize** (int)-打印张量中的元素数目，如果值为-1则打印所有元素
- **message** (str)-字符串类型消息，作为前缀打印
- **first_n** (int)-只记录first_n次数
- **print_tensor_name** (bool)-打印张量名称
- **print_tensor_type** (bool)-打印张量类型
- **print_tensor_shape** (bool)-打印张量维度
- **print_tensor_lod** (bool)-打印张量lod
- **print_phase** (str)-打印的阶段，包括 ``forward`` , ``backward`` 和 ``both`` .若设置为 ``backward`` 或者 ``both`` ,则打印输入张量的梯度。
返回：输出张量
返回类型：变量（Variable）
.. note::
输入和输出是两个不同的变量，在接下来的过程中，你应该使用输出变量而非输入变量，否则打印层将失去输出层前的信息。
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
input = fluid.layers.data(name="input", shape=[4, 32, 32], dtype="float32")
input = fluid.layers.Print(input, message = "The content of input layer:")
# value = some_layer(...)
# Print(value, summarize=10,
# message="The content of some_layer: ")
.. _cn_api_fluid_layers_reorder_lod_tensor_by_rank:
reorder_lod_tensor_by_rank
-------------------------------
.. py:function:: paddle.fluid.layers.reorder_lod_tensor_by_rank(x, rank_table)
函数参数 ``X`` 是由多个序列(sequence)组成的的一个数据批(batch）。``rank_table`` 存储着batch中序列的重新排列规则。
该算子(operator）根据 ``rank_table`` 中提供的规则信息来实现对 ``X`` 的重新排列。
::
例如:
假设在 RankTable 中存储的序列索引为 [3,0,2,1]， X 将会被这样被重新排列：
X 中的第四个序列（即索引为3的序列，后面以此类推）会变成排列后的batch中的第一个，紧接着就是原来batch中的第一个元素，第三个元素，和第二个元素。
简言之，若有原batch：X = [Seq0, Seq1, Seq2, Seq3] 且 RankTable 中的索引为 [3,0,2,1]，那么输出即为 Out = [Seq3, Seq0, Seq2, Seq1] ，它携带着新的LoD信息。
如果 X 的LoD信息是空的，这表明 X 不是序列型数据。这和由多个定长为1的序列组成的batch是相同的情况。此时，该函数将对 X 中的切片（slice） 在第一轴(axis)上按 rank_table 里的规则加以排列。
例如，现有 X = [Slice0, Slice1, Slice2, Slice3] ，并且它LoD信息为空，在 RankTable 索引为[3, 0, 2, 1]。则 Out = [Slice3, Slice0, Slice2, Slice1] ，并且不在其中追加LoD信息。
注意，该operator对 ``X`` 进行的排序所依据的 ``LoDRankTable`` 不一定是在 ``X`` 的基础上得出来的。它可以由其他不同的序列得出，并由该operator依据这个 ``LoDRankTable`` 来对 ``X`` 排序。
参数：
- **x(Variable)** - (LoDTensor)，待根据提供的 ``RankTable`` 进行排序的LoD tensor
- **rank_table(Variable)** - 变量
返回： 重新排列后的LoDTensor
返回类型: out(Variable)
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
data_desc = (['input', [9], 0], ['ref', [5], 1])
data = fluid.layers.data(name=data_desc[0][0], shape=data_desc[0][1])
rank_data = fluid.layers.data(name=data_desc[1][0], shape=data_desc[1][1])
table = fluid.layers.control_flow.lod_rank_table(rank_data)
new_data = fluid.layers.reorder_lod_tensor_by_rank(
x=data, rank_table=table)
.. _cn_api_fluid_layers_StaticRNN:
StaticRNN
-------------------------------
.. py:class:: paddle.fluid.layers.StaticRNN(name=None)
StaticRNN可以处理一批序列数据。每个样本序列的长度必须相等。StaticRNN将拥有自己的参数，如输入、输出和存储器等。请注意，输入的第一个维度表示序列长度，且输入的所有序列长度必须相同。并且输入和输出的每个轴的含义是相同的。
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
import paddle.fluid.layers as layers
vocab_size, hidden_size=10000, 200
x = layers.data(name="x", shape=[-1, 1, 1], dtype='int64')
x_emb = layers.embedding(
input=x,
size=[vocab_size, hidden_size],
dtype='float32',
is_sparse=False)
x_emb = layers.transpose(x_emb, perm=[1, 0, 2])
rnn = fluid.layers.StaticRNN()
with rnn.step():
word = rnn.step_input(x_emb)
prev = rnn.memory(shape=[-1, hidden_size], batch_ref = word)
hidden = fluid.layers.fc(input=[word, prev], size=hidden_size, act='relu')
rnn.update_memory(prev, hidden) # set prev to hidden
rnn.step_output(hidden)
result = rnn()
StaticRNN将序列展开为时间步长。用户需要定义如何在with步骤中处理每个时间步长。
内存用作在time step之间缓存数据。内存的初始值可以是填充常量值的变量或指定变量。
StaticRNN可以将多个变量标记为其输出。使用rnn()获取输出序列。
.. py:method:: step()
用户在该代码块中定义RNN中的operators。
.. py:method:: memory(init=None, shape=None, batch_ref=None, init_value=0.0, init_batch_dim_idx=0, ref_batch_dim_idx=1)
为静态RNN创建一个内存变量。
如果init不为None，则此变量将初始化内存。 如果init为None，则必须设置shape和batch_ref，并且此函数将初始化init变量。
参数：
- **init** (Variable|None) - 初始化过的变量，如果没有设置，则必须提供shape和batch_ref，默认值None
- **shape** (list|tuple) - boot memory的形状，注意其不包括batch_size，默认值None
- **batch_ref** (Variable|None) - batch引用变量，默认值None
- **init_value** (float) - boot memory的初始化值，默认值0.0
- **init_batch_dim_idx** (int) - init变量的batch_size轴，默认值0
- **ref_batch_dim_idx** (int) - batch_ref变量的batch_size轴
返回：内存变量
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
import paddle.fluid.layers as layers
vocab_size, hidden_size=10000, 200
x = layers.data(name="x", shape=[-1, 1, 1], dtype='int64')
x_emb = layers.embedding(
input=x,
size=[vocab_size, hidden_size],
dtype='float32',
is_sparse=False)
x_emb = layers.transpose(x_emb, perm=[1, 0, 2])
rnn = fluid.layers.StaticRNN()
with rnn.step():
word = rnn.step_input(x_emb)
prev = rnn.memory(shape=[-1, hidden_size], batch_ref = word)
hidden = fluid.layers.fc(input=[word, prev], size=hidden_size, act='relu')
rnn.update_memory(prev, hidden)
.. py:method:: step_input(x)
标记作为StaticRNN输入的序列。
参数：
- **x** (Variable) – 输入序列，x的形状应为[seq_len, ...]。
返回：输入序列中的当前时间步长。
.. py:method:: step_output(o)
标记作为StaticRNN输出的序列。
参数：
-**o** (Variable) – 输出序列
返回：None
.. py:method:: output(*outputs)
标记StaticRNN输出变量。
参数：
-**outputs** – 输出变量
返回：None
.. py:method:: update_memory(mem, var)
将内存从ex_mem更新为new_mem。请注意，ex_mem和new_mem的形状和数据类型必须相同。
参数：
- **mem** (Variable) – 内存变量
- **var** (Variable) – RNN块中产生的普通变量
返回：None
.. _cn_api_fluid_layers_Switch:
Switch
-------------------------------
.. py:class:: paddle.fluid.layers.Switch (name=None)
Switch类实现的功能十分类似if-elif-else。它可以在学习率调度器(learning rate scheduler)中调整学习率。
::
语义上，
1. switch控制流挨个检查cases
2. 各个case的条件是一个布尔值(boolean)，它是一个标量(scalar)变量
3. 它将执行第一个匹配的case后面的分支，如果没有匹配的case，但若存在一个default case,则会执行default case后面的语句
4. 一旦匹配了一个case,它降会执行这个case所对应的分支，且仅此分支。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
lr = fluid.layers.create_global_var(
shape=[1],
value=0.0,
dtype='float32',
persistable=True,
name="learning_rate")
zero_var = fluid.layers.fill_constant(
shape=[1], dtype='float32', value=0.0)
one_var = fluid.layers.fill_constant(
shape=[1], dtype='float32', value=1.0)
two_var = fluid.layers.fill_constant(
shape=[1], dtype='float32', value=2.0)
global_step = fluid.layers.autoincreased_step_counter(
counter_name='@LR_DECAY_COUNTER@', begin=0, step=1)
with fluid.layers.control_flow.Switch() as switch:
with switch.case(global_step == zero_var):
fluid.layers.assign(input=one_var, output=lr)
with switch.default():
fluid.layers.assign(input=two_var, output=lr)
.. _cn_api_fluid_layers_While:
While
-------------------------------
.. py:class:: paddle.fluid.layers.While (cond, is_test=False, name=None)
该类用于实现while循环控制功能。
参数：
- **cond** (Variable) – 用于比较的条件
- **is_test** (bool) – 用于表明是不是在测试阶段执行
- **name** (str) - 该层的命名
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=0)
d0 = fluid.layers.data("d0", shape=[10], dtype='float32')
data_array = fluid.layers.array_write(x=d0, i=i)
array_len = fluid.layers.fill_constant(shape=[1],dtype='int64', value=3)
cond = fluid.layers.less_than(x=i, y=array_len)
while_op = fluid.layers.While(cond=cond)
with while_op.block():
d = fluid.layers.array_read(array=data_array, i=i)
i = fluid.layers.increment(x=i, value=1, in_place=True)
fluid.layers.less_than(x=i, y=array_len, cond=cond)
doc/fluid/api_cn/layers_cn/detection_cn.rst 0 → 100644
浏览文件 @ bf87c5c0
==============
detection
==============
.. _cn_api_fluid_layers_anchor_generator:
anchor_generator
-------------------------------
.. py:function:: paddle.fluid.layers.anchor_generator(input, anchor_sizes=None, aspect_ratios=None, variance=[0.1, 0.1, 0.2, 0.2], stride=None, offset=0.5, name=None)
**Anchor generator operator**
为Faster RCNN算法生成anchor，输入的每一位产生N个anchor，N=size(anchor_sizes)*size(aspect_ratios)。生成anchor的顺序首先是aspect_ratios循环，然后是anchor_sizes循环。
参数：
- **input** (Variable) - 输入特征图，格式为NCHW
- **anchor_sizes** (list|tuple|float) - 生成anchor的anchor大小，以绝对像素的形式表示，例如：[64.,128.,256.,512.]。若anchor的大小为64，则意味着这个anchor的面积等于64**2。
- **aspect_ratios** (list|tuple|float) - 生成anchor的高宽比，例如[0.5,1.0,2.0]
- **variance** (list|tuple) - 变量，在框回归delta中使用。默认：[0.1,0.1,0.2,0.2]
- **stride** (list|tuple) - anchor在宽度和高度方向上的步长，比如[16.0,16.0]
- **offset** (float) - 先验框的中心位移。默认：0.5
- **name** (str) - 先验框操作符名称。默认：None
返回：
- Anchors(Varibale): 输出anchor，布局[H,W,num_anchors,4] , ``H`` 是输入的高度， ``W`` 是输入的宽度， ``num_priors`` 是输入每位的框数,每个anchor格式（未归一化）为(xmin,ymin,xmax,ymax)
- Variances(Variable): anchor的扩展变量布局为 [H,W,num_priors,4]。 ``H`` 是输入的高度， ``W`` 是输入的宽度， ``num_priors`` 是输入每个位置的框数,每个变量的格式为(xcenter,ycenter,w,h)。
返回类型：Anchors(Variable),Variances(Variable)
**代码示例**：
.. code-block:: python
conv1 = fluid.layers.data(name='conv1', shape=[48, 16, 16], dtype='float32')
anchor, var = fluid.layers.anchor_generator(
input=conv1,
anchor_sizes=[64, 128, 256, 512],
aspect_ratios=[0.5, 1.0, 2.0],
variance=[0.1, 0.1, 0.2, 0.2],
stride=[16.0, 16.0],
offset=0.5)
.. _cn_api_fluid_layers_bipartite_match:
bipartite_match
-------------------------------
.. py:function:: paddle.fluid.layers.bipartite_match(dist_matrix, match_type=None, dist_threshold=None, name=None)
该算子实现了贪心二分匹配算法，该算法用于根据输入距离矩阵获得与最大距离的匹配。对于输入二维矩阵，二分匹配算法可以找到每一行的匹配列（匹配意味着最大距离），也可以找到每列的匹配行。此算子仅计算列到行的匹配索引。对于每个实例，匹配索引的数量是输入距离矩阵的列号。
它有两个输出，匹配的索引和距离。简单的描述是该算法将最佳（最大距离）行实体与列实体匹配，并且匹配的索引在ColToRowMatchIndices的每一行中不重复。如果列实体与任何行实体不匹配，则ColToRowMatchIndices设置为-1。
注意：输入距离矩阵可以是LoDTensor（带有LoD）或Tensor。如果LoDTensor带有LoD，则ColToRowMatchIndices的高度是批量大小。如果是Tensor，则ColToRowMatchIndices的高度为1。
注意：此API是一个非常低级别的API。它由 ``ssd_loss`` 层使用。请考虑使用 ``ssd_loss`` 。
参数：
- **dist_matrix** （变量）- 该输入是具有形状[K，M]的2-D LoDTensor。它是由每行和每列来表示实体之间的成对距离矩阵。例如，假设一个实体是具有形状[K]的A，另一个实体是具有形状[M]的B. dist_matrix [i] [j]是A[i]和B[j]之间的距离。距离越大，匹配越好。
注意：此张量可以包含LoD信息以表示一批输入。该批次的一个实例可以包含不同数量的实体。
- **match_type** （string | None）- 匹配方法的类型，应为'bipartite'或'per_prediction'。[默认'二分']。
- **dist_threshold** （float | None）- 如果match_type为'per_prediction'，则此阈值用于根据最大距离确定额外匹配的bbox，默认值为0.5。
返回： 返回一个包含两个元素的元组。第一个是匹配的索引（matched_indices），第二个是匹配的距离（matched_distance）。
**matched_indices** 是一个2-D Tensor，int类型的形状为[N，M]。 N是批量大小。如果match_indices[i][j]为-1，则表示B[j]与第i个实例中的任何实体都不匹配。否则，这意味着在第i个实例中B[j]与行match_indices[i][j]匹配。第i个实例的行号保存在match_indices[i][j]中。
**matched_distance** 是一个2-D Tensor，浮点型的形状为[N，M]。 N是批量大小。如果match_indices[i][j]为-1，则match_distance[i][j]也为-1.0。否则，假设match_distance[i][j]=d，并且每个实例的行偏移称为LoD。然后match_distance[i][j]=dist_matrix[d]+ LoD[i]][j]。
返回类型： 元组(tuple)
**代码示例**
.. code-block:: python
x = fluid.layers.data(name='x', shape=[4], dtype='float32')
y = fluid.layers.data(name='y', shape=[4], dtype='float32')
iou = fluid.layers.iou_similarity(x=x, y=y)
matched_indices, matched_dist = fluid.layers.bipartite_match(iou)
.. _cn_api_fluid_layers_box_clip:
box_clip
-------------------------------
.. py:function:: paddle.fluid.layers.box_clip(input, im_info, name=None)
将box框剪切为 ``im_info`` 给出的大小。对于每个输入框，公式如下：
::
xmin = max(min(xmin, im_w - 1), 0)
ymin = max(min(ymin, im_h - 1), 0)
xmax = max(min(xmax, im_w - 1), 0)
ymax = max(min(ymax, im_h - 1), 0)
其中im_w和im_h是从im_info计算的：
::
im_h = round(height / scale)
im_w = round(weight / scale)
参数：
- **input (variable)** – 输入框，最后一个维度为4
- **im_info (variable)** – 具有（高度height，宽度width，比例scale）排列的形为[N，3]的图像的信息。高度和宽度是输入大小，比例是输入大小和原始大小的比率
- **name (str)** – 该层的名称。 为可选项
返回：剪切后的tensor
返回类型： Variable
**代码示例**
.. code-block:: python
boxes = fluid.layers.data(
name='boxes', shape=[8, 4], dtype='float32', lod_level=1)
im_info = fluid.layers.data(name='im_info', shape=[3])
out = fluid.layers.box_clip(
input=boxes, im_info=im_info, inplace=True)
.. _cn_api_fluid_layers_box_coder:
box_coder
-------------------------------
.. py:function:: paddle.fluid.layers.box_coder(prior_box, prior_box_var, target_box, code_type='encode_center_size', box_normalized=True, name=None, axis=0)
Bounding Box Coder
编码/解码带有先验框信息的目标边界框
编码规则描述如下：
.. math::
ox &= (tx - px)/pw/pxv
oy &= (ty - py)/ph/pyv
ow &= log(abs(tw/pw))/pwv
oh &= log(abs(th/ph))/phv
解码规则描述如下：
.. math::
ox &= (pw * pxv * tx * + px ) - tw/2
oy &= (ph * pyv * ty * + py ) - th/2
ow &= exp(pwv * tw ) * pw + tw/2
oh &= exp(phv * th ) * ph + th/2
其中tx，ty，tw，th分别表示目标框的中心坐标、宽度和高度。同样地，px，py，pw，ph表示先验框地中心坐标、宽度和高度。pxv，pyv，pwv，phv表示先验框变量，ox，oy，ow，oh表示编码/解码坐标、宽度和高度。
在Box Decoding期间，支持两种broadcast模式。 假设目标框具有形状[N，M，4]，并且prior框的形状可以是[N，4]或[M，4]。 然后，prior框将沿指定的轴broadcast到目标框。
参数：
- **prior_box** (Variable) - 张量，默认float类型的张量。先验框是二维张量，维度为[M,4]，存储M个框，每个框代表[xmin，ymin，xmax，ymax]，[xmin，ymin]是先验框的左顶点坐标，如果输入数图像特征图，则接近坐标原点。[xmax,ymax]是先验框的右底点坐标
- **prior_box_var** (Variable|list|None) - 支持两种输入类型，一是二维张量，维度为[M,4]，存储M个prior box。另外是一个含有4个元素的list，所有prior box共用这个list。
- **target_box** (Variable) - LoDTensor或者Tensor，当code_type为‘encode_center_size’，输入可以是二维LoDTensor，维度为[N,4]。当code_type为‘decode_center_size’输入可以为三维张量，维度为[N,M,4]。每个框代表[xmin,ymin,xmax,ymax]，[xmin,ymin]是先验框的左顶点坐标，如果输入数图像特征图，则接近坐标原点。[xmax,ymax]是先验框的右底点坐标。该张量包含LoD信息，代表一批输入。批的一个实例可以包含不同的实体数。
- **code_type** (string，默认encode_center_size) - 编码类型用目标框，可以是encode_center_size或decode_center_size
- **box_normalized** (boolean，默认true) - 是否将先验框作为正则框
- **name** (string) – box编码器的名称
- **axis** (int) – 在PriorBox中为axis指定的轴broadcast以进行框解码，例如，如果axis为0且TargetBox具有形状[N，M，4]且PriorBox具有形状[M，4]，则PriorBox将broadcast到[N，M，4]用于解码。 它仅在code_type为decode_center_size时有效。 默认设置为0。
返回：
- ``code_type`` 为 ``‘encode_center_size’`` 时，形为[N,M,4]的输出张量代表N目标框的结果，目标框用M先验框和变量编码。
- ``code_type`` 为 ``‘decode_center_size’`` 时，N代表batch大小，M代表解码框数
返回类型：output_box（Variable）
**代码示例**
.. code-block:: python
prior_box = fluid.layers.data(name='prior_box',
shape=[512, 4],
dtype='float32',
append_batch_size=False)
target_box = fluid.layers.data(name='target_box',
shape=[512,81,4],
dtype='float32',
append_batch_size=False)
output = fluid.layers.box_coder(prior_box=prior_box,
prior_box_var=[0.1,0.1,0.2,0.2],
target_box=target_box,
code_type="decode_center_size",
box_normalized=False,
axis=1)
.. _cn_api_fluid_layers_box_decoder_and_assign:
box_decoder_and_assign
-------------------------------
.. py:function:: paddle.fluid.layers.box_decoder_and_assign(prior_box, prior_box_var, target_box, box_score, box_clip, name=None)
边界框编码器。
根据prior_box来解码目标边界框。
解码方案为：
.. math::
ox &= (pw \times pxv \times tx + px) - \frac{tw}{2}\\
oy &= (ph \times pyv \times ty + py) - \frac{th}{2}\\
ow &= \exp (pwv \times tw) \times pw + \frac{tw}{2}\\
oh &= \exp (phv \times th) \times ph + \frac{th}{2}
其中tx，ty，tw，th分别表示目标框的中心坐标，宽度和高度。 类似地，px，py，pw，ph表示prior_box（anchor）的中心坐标，宽度和高度。 pxv，pyv，pwv，phv表示prior_box的variance，ox，oy，ow，oh表示decode_box中的解码坐标，宽度和高度。
box decode过程得出decode_box，然后分配方案如下所述：
对于每个prior_box，使用最佳non-background（非背景）类的解码值来更新prior_box位置并获取output_assign_box。 因此，output_assign_box的形状与PriorBox相同。
参数：
- **prior_box** （Variable） - （Tensor，默认Tensor <float>）框列表PriorBox是一个二维张量，形状为[N，4]，它包含N个框，每个框表示为[xmin，ymin，xmax，ymax]， [xmin，ymin]是anchor框的左上坐标，如果输入是图像特征图，则它们接近坐标系的原点。 [xmax，ymax]是anchor框的右下坐标
- **prior_box_var** （Variable） - （Tensor，默认Tensor <float>，可选）PriorBoxVar是一个二维张量，形状为[N，4]，它包含N组variance。 PriorBoxVar默认将所有元素设置为1
- **target_box** （Variable） - （LoDTensor或Tensor）此输入可以是形状为[N，classnum * 4]的2-D LoDTensor。它拥有N个框的N个目标
- **box_score** （变量） - （LoDTensor或Tensor）此输入可以是具有形状[N，classnum]的2-D LoDTensor，每个框表示为[classnum]，其中含有各分类概率值
- **box_clip** （FLOAT） - （float，默认4.135，np.log（1000. / 16.））裁剪框以防止溢出
- **name** （str | None） - 此算子的自定义名称
返回：两个变量：
- decode_box（Variable）:( LoDTensor或Tensor）op的输出张量，形为[N，classnum * 4]，表示用M个prior_box解码的N个目标框的结果，以及每个类上的variance
- output_assign_box（Variable）:( LoDTensor或Tensor）op的输出张量，形为[N，4]，表示使用M个prior_box解码的N个目标框的结果和BoxScore的最佳非背景类的方差
返回类型： decode_box(Variable), output_assign_box(Variable)
**代码示例**
.. code-block:: python
pb = fluid.layers.data(
name='prior_box', shape=[4], dtype='float32')
pbv = fluid.layers.data(
name='prior_box_var', shape=[4], dtype='float32', append_batch_size=False))
loc = fluid.layers.data(
name='target_box', shape=[4*81], dtype='float32')
scores = fluid.layers.data(
name='scores', shape=[81], dtype='float32')
decoded_box, output_assign_box = fluid.layers.box_decoder_and_assign(
pb, pbv, loc, scores, 4.135)
.. _cn_api_fluid_layers_collect_fpn_proposals:
collect_fpn_proposals
-------------------------------
.. py:function:: paddle.fluid.layers.collect_fpn_proposals(multi_rois, multi_scores, min_level, max_level, post_nms_top_n, name=None)
连接多级RoIs（感兴趣区域）并依据multi_scores选择N个RoIs。此操作执行以下步骤：
1、选择num_level个RoIs和scores作为输入：num_level = max_level - min_level
2、连接num_level个RoIs和scores。
3、整理scores并选择post_nms_top_n个scores。
4、通过scores中的选定指数收集RoIs。
5、通过对应的batch_id重新整理RoIs。
参数：
- **multi_ros** (list) – 要收集的RoIs列表
- **multi_scores** (list) - 要收集的FPN层的最低级
- **max_level** (int) – 要收集的FPN层的最高级
- **post_nms_top_n** (int) – 所选RoIs的数目
- **name** (str|None) – 该层的名称（可选项）
返回：选定RoIs的输出变量
返回类型：变量(Variable)
**代码示例**
.. code-block:: python
multi_rois = []
multi_scores = []
for i in range(4):
multi_rois.append(fluid.layers.data(
name='roi_'+str(i), shape=[4], dtype='float32', lod_level=1))
for i in range(4):
multi_scores.append(fluid.layers.data(
name='score_'+str(i), shape=[1], dtype='float32', lod_level=1))
fpn_rois = fluid.layers.collect_fpn_proposals(
multi_rois=multi_rois,
multi_scores=multi_scores,
min_level=2,
max_level=5,
post_nms_top_n=2000)
.. _cn_api_fluid_layers_density_prior_box:
density_prior_box
-------------------------------
.. py:function:: paddle.fluid.layers.density_prior_box(input, image, densities=None, fixed_sizes=None, fixed_ratios=None, variance=[0.1, 0.1, 0.2, 0.2], clip=False, steps=[0.0, 0.0], offset=0.5, flatten_to_2d=False, name=None)
**Density Prior Box Operator**
为SSD算法(Single Shot MultiBox Detector)生成density prior box。
每个input的位置产生N个prior box，其中，N通过densities, fixed_sizes and fixed_ratios
的量来决定。在每个input位置附近的box center格点，通过此op生成。格点坐标由densities决定，
density prior box的量由fixed_sizes and fixed_ratios决定。显然地，fixed_sizes
和densities相等。对于densities中的densities_i：
.. math::
N\_density\_prior\_box =sum(N\_fixed\_ratios * {densities\_i}^2)
参数：
- **input** (Variable) - 输入变量，格式为NCHW
- **image** (Variable) - PriorBoxOp的输入图像数据，格式为NCHW
- **densities** (list|tuple|None) - 被生成的density prior boxes的densities，此属性应该是一个整数列表或数组。默认值为None
- **fixed_sizes** (list|tuple|None) - 被生成的density prior boxes的固定大小，此属性应该为和 :attr:`densities` 有同样长度的列表或数组。默认值为None
- **fixed_ratios** (list|tuple|None) - 被生成的density prior boxes的固定长度，如果该属性未被设置，同时 :attr:`densities` 和 :attr:`fix_sizes` 被设置，则 :attr:`aspect_ratios` 被用于生成 density prior boxes
- **variance** (list|tuple) - 将被用于density prior boxes编码的方差，默认值为:[0.1, 0.1, 0.2, 0.2]
- **clip(bool)** - 是否clip超出范围的box。默认值：False
- **step** (list|turple) - Prior boxes在宽度和高度的步长，如果step[0] == 0.0/step[1] == 0.0, input的the density prior boxes的高度/宽度的步长将被自动计算。默认值：Default: [0., 0.]
- **offset** (float) - Prior boxes中心补偿值，默认为：0.5
- **flatten_to_2d** (bool) - 是否将output prior boxes和方差 ``flatten`` 至2维形状，第二个dim为4。默认值：False
- **name(str)** - density prior box op的名字，默认值: None
返回：
tuple: 有两个变量的数组 (boxes, variances)
boxes: PriorBox的输出density prior boxes
当flatten_to_2d为False时，形式为[H, W, num_priors, 4]
当flatten_to_2d为True时，形式为[H * W * num_priors, 4]
H是输入的高度，W是输入的宽度
num_priors是输入中每个位置的总box count
variances: PriorBox的expanded variance
当flatten_to_2d为False时，形式为[H, W, num_priors, 4]
当flatten_to_2d为True时，形式为[H * W * num_priors, 4]
H是输入的高度，W是输入的宽度
num_priors是输入中每个位置的总box count
**代码示例**
.. code-block:: python
input = fluid.layers.data(name="input", shape=[3,6,9])
images = fluid.layers.data(name="images", shape=[3,9,12])
box, var = fluid.layers.density_prior_box(
input=input,
image=images,
densities=[4, 2, 1],
fixed_sizes=[32.0, 64.0, 128.0],
fixed_ratios=[1.],
clip=True,
flatten_to_2d=True)
.. _cn_api_fluid_layers_detection_map:
detection_map
-------------------------------
.. py:function:: paddle.fluid.layers.detection_map(detect_res, label, class_num, background_label=0, overlap_threshold=0.3, evaluate_difficult=True, has_state=None, input_states=None, out_states=None, ap_version='integral')
检测mAP评估算子。一般步骤如下：首先，根据检测输入和标签计算TP（true positive）和FP（false positive），然后计算mAP评估值。支持'11 point'和积分mAP算法。请从以下文章中获取更多信息：
https://sanchom.wordpress.com/tag/average-precision/
https://arxiv.org/abs/1512.02325
参数：
- **detect_res** （LoDTensor）- 用具有形状[M，6]的2-D LoDTensor来表示检测。每行有6个值：[label，confidence，xmin，ymin，xmax，ymax]，M是此小批量中检测结果的总数。对于每个实例，第一维中的偏移称为LoD，偏移量为N+1，如果LoD[i+1]-LoD[i]== 0，则表示没有检测到数据。
- **label** （LoDTensor）- 2-D LoDTensor用来带有标签的真实数据。每行有6个值：[label，xmin，ymin，xmax，ymax，is_difficult]或5个值：[label，xmin，ymin，xmax，ymax]，其中N是此小批量中真实数据的总数。对于每个实例，第一维中的偏移称为LoD，偏移量为N + 1，如果LoD [i + 1] - LoD [i] == 0，则表示没有真实数据。
- **class_num** （int）- 类的数目。
- **background_label** （int，defalut：0）- background标签的索引，background标签将被忽略。如果设置为-1，则将考虑所有类别。
- **overlap_threshold** （float）- 检测输出和真实数据下限的重叠阈值。
- **evaluate_difficult** （bool，默认为true）- 通过切换来控制是否对difficult-data进行评估。
- **has_state** （Tensor <int>）- 是shape[1]的张量，0表示忽略输入状态，包括PosCount，TruePos，FalsePos。
- **input_states** - 如果不是None，它包含3个元素：
1、pos_count（Tensor）是一个shape为[Ncls，1]的张量，存储每类的输入正例的数量，Ncls是输入分类的数量。此输入用于在执行多个小批量累积计算时传递最初小批量生成的AccumPosCount。当输入（PosCount）为空时，不执行累积计算，仅计算当前小批量的结果。
2、true_pos（LoDTensor）是一个shape为[Ntp，2]的2-D LoDTensor，存储每个类输入的正实例。此输入用于在执行多个小批量累积计算时传递最初小批量生成的AccumPosCount。
3、false_pos（LoDTensor）是一个shape为[Nfp，2]的2-D LoDTensor，存储每个类输入的负实例。此输入用于在执行多个小批量累积计算时传递最初小批量生成的AccumPosCount。
- **out_states** - 如果不是None，它包含3个元素：
1、accum_pos_count（Tensor）是一个shape为[Ncls，1]的Tensor，存储每个类的实例数。它结合了输入（PosCount）和从输入中的（Detection）和（label）计算的正例数。
2、accum_true_pos（LoDTensor）是一个shape为[Ntp'，2]的LoDTensor，存储每个类的正实例。它结合了输入（TruePos）和从输入中（Detection）和（label）计算的正实例数。 。
3、accum_false_pos（LoDTensor）是一个shape为[Nfp'，2]的LoDTensor，存储每个类的负实例。它结合了输入（FalsePos）和从输入中（Detection）和（label）计算的负实例数。
- **ap_version** （string，默认'integral'）- AP算法类型，'integral'或'11 point'。
返回： 具有形状[1]的（Tensor），存储mAP的检测评估结果。
**代码示例**
.. code-block:: python
detect_res = fluid.layers.data(
name='detect_res',
shape=[10, 6],
append_batch_size=False,
dtype='float32')
label = fluid.layers.data(
name='label',
shape=[10, 6],
append_batch_size=False,
dtype='float32')
map_out = fluid.layers.detection_map(detect_res, label, 21)
.. _cn_api_fluid_layers_detection_output:
detection_output
-------------------------------
.. py:function:: paddle.fluid.layers.detection_output(loc, scores, prior_box, prior_box_var, background_label=0, nms_threshold=0.3, nms_top_k=400, keep_top_k=200, score_threshold=0.01, nms_eta=1.0)
Detection Output Layer for Single Shot Multibox Detector(SSD)
该操作符用于获得检测结果，执行步骤如下：
1.根据prior box框解码输入边界框（bounding box）预测
2.通过运用多类非极大值抑制(NMS)获得最终检测结果
请注意，该操作符不将最终输出边界框剪切至图像窗口。
参数：
- **loc** (Variable) - 一个三维张量（Tensor），维度为[N,M,4]，代表M个bounding bboxes的预测位置。N是批尺寸，每个边界框（boungding box）有四个坐标值，布局为[xmin,ymin,xmax,ymax]
- **scores** (Variable) - 一个三维张量（Tensor），维度为[N,M,C]，代表预测置信预测。N是批尺寸，C是类别数，M是边界框数。对每类一共M个分数，对应M个边界框
- **prior_box** (Variable) - 一个二维张量（Tensor),维度为[M,4]，存储M个框，每个框代表[xmin,ymin,xmax,ymax]，[xmin,ymin]是anchor box的左上坐标，如果输入是图像特征图，靠近坐标系统的原点。[xmax,ymax]是anchor box的右下坐标
- **prior_box_var** (Variable) - 一个二维张量（Tensor），维度为[M,4]，存有M变量群
- **background_label** (float) - 背景标签索引，背景标签将会忽略。若设为-1，将考虑所有类别
- **nms_threshold** (int) - 用于NMS的临界值（threshold）
- **nms_top_k** (int) - 基于score_threshold过滤检测后，根据置信数维持的最大检测数
- **keep_top_k** (int) - NMS步后，每一图像要维持的总bbox数
- **score_threshold** (float) - 临界函数（Threshold），用来过滤带有低置信数的边界框（bounding box）。若未提供，则考虑所有框
- **nms_eta** (float) - 适应NMS的参数
返回：
输出一个LoDTensor，形为[No,6]。每行有6个值：[label,confidence,xmin,ymin,xmax,ymax]。No是该mini-batch的总检测数。对每个实例，第一维偏移称为LoD，偏移数为N+1，N是batch size。第i个图像有LoD[i+1]-LoD[i]检测结果。如果为0，第i个图像无检测结果。如果所有图像都没有检测结果，LoD会被设置为{1}，并且输出张量只包含一个值-1。（1.3版本后对于没有检测结果的boxes, LoD的值由之前的{0}调整为{1}）
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
pb = fluid.layers.data(name='prior_box', shape=[10, 4],
append_batch_size=False, dtype='float32')
pbv = fluid.layers.data(name='prior_box_var', shape=[10, 4],
append_batch_size=False, dtype='float32')
loc = fluid.layers.data(name='target_box', shape=[2, 21, 4],
append_batch_size=False, dtype='float32')
scores = fluid.layers.data(name='scores', shape=[2, 21, 10],
append_batch_size=False, dtype='float32')
nmsed_outs = fluid.layers.detection_output(scores=scores,
loc=loc,
prior_box=pb,
prior_box_var=pbv)
.. _cn_api_fluid_layers_distribute_fpn_proposals:
distribute_fpn_proposals
-------------------------------
.. py:function:: paddle.fluid.layers.distribute_fpn_proposals(fpn_rois, min_level, max_level, refer_level, refer_scale, name=None)
在 Feature Pyramid Networks（FPN）模型中，需要将所有proposal分配到不同的FPN级别，包括proposal的比例，引用比例和引用级别。 此外，为了恢复proposals的顺序，我们返回一个数组，该数组表示当前proposals中的原始RoIs索引。 要计算每个RoI的FPN级别，公式如下：
.. math::
roi\_scale &= \sqrt{BBoxArea(fpn\_roi)}\\
level = floor(&\log(\frac{roi\_scale}{refer\_scale}) + refer\_level)
其中BBoxArea方法用来计算每个RoI的区域。
参数：
- **fpn_rois** （variable） - 输入fpn_rois，第二个维度为4。
- **min_level** （int） - 产生proposal最低级别FPN层。
- **max_level** （int） - 产生proposal最高级别FPN层。
- **refer_level** （int） - 具有指定比例的FPN层的引用级别。
- **refer_scale** （int） - 具有指定级别的FPN层的引用比例。
- **name** （str | None） - 此算子的名称。
返回：返回一个元组（multi_rois，restore_ind）。 multi_rois是分段张量变量的列表。 restore_ind是具有形状[N，1]的2D张量，N是总rois的数量。 它用于恢复fpn_rois的顺序。
返回类型： tuple
**代码示例**：
.. code-block:: python
fpn_rois = fluid.layers.data(
name='data', shape=[4], dtype='float32', lod_level=1)
multi_rois, restore_ind = fluid.layers.distribute_fpn_proposals(
fpn_rois=fpn_rois,
min_level=2,
max_level=5,
refer_level=4,
refer_scale=224)
.. _cn_api_fluid_layers_generate_mask_labels:
generate_mask_labels
-------------------------------
.. py:function:: paddle.fluid.layers.generate_mask_labels(im_info, gt_classes, is_crowd, gt_segms, rois, labels_int32, num_classes, resolution)
**为Mask-RCNN生成mask标签**
对于给定的 RoI (Regions of Interest) 和相应的标签，该算子可以对前景RoI进行采样。 该mask branch对每个前景RoI还具有 :math:`K*M^{2}` 维输出目标，用于编码分辨率为M×M的K个二进制mask，K个种类中的各种类分别对应一个这样的二进制mask。 此mask输出目标用于计算掩码分支的损失。
请注意groud-truth（真实值，下简称GT）分段的数据格式。假设分段如下， 第一个实例有两个GT对象。 第二个实例有一个GT对象，该对象有两个GT分段。
::
#[
# [[[229.14, 370.9, 229.14, 370.9, ...]],
# [[343.7, 139.85, 349.01, 138.46, ...]]], # 第0个实例对象
# [[[500.0, 390.62, ...],[115.48, 187.86, ...]]] # 第1个实例对象
#]
batch_masks = []
for semgs in batch_semgs:
gt_masks = []
for semg in semgs:
gt_segm = []
for polys in semg:
gt_segm.append(np.array(polys).reshape(-1, 2))
gt_masks.append(gt_segm)
batch_masks.append(gt_masks)
place = fluid.CPUPlace()
feeder = fluid.DataFeeder(place=place, feed_list=feeds)
feeder.feed(batch_masks)
参数：
- **im_info** (Variable) – 具有形状[N，3]的2-D张量。 N是批量大小，其每个元素是图像的[高度，宽度，比例]，对应第二维中的3。图像比例是 :math:`\frac{target\_size}{original\_size}` 。
- **gt_classes** (Variable) – 形为[M，1]的2-D LoDTensor。 M是真实值的总数，其每个元素都是一个类标签，对应第二维中的1。
- **is_crowd** (Variable) – 一个形为 ``gt_classes`` 的2-D LoDTensor，每个元素都是一个标志，指示一个groundtruth是否为crowd（群）。
- **gt_segms** (Variable) – 这个输入是一个形状为[S，2]的2D LoDTensor，它的LoD级别为3。通常用户不需要理解LoD，但用户应该在Reader中返回正确的数据格式。LoD [0]表示每个实例中GT对象的数目。 LoD [1]表示每个对象的分段数。 LoD [2]表示每个分段的多边形(polygon)数。S为多边形坐标点的总数。每个元素是（x，y）坐标点。
- **rois** (Variable) – 形为[R，4]的2-D LoDTensor。 R是RoI的总数，其中每个元素是在原始图像范围内具有（xmin，ymin，xmax，ymax）格式的边界框(bounding box)。
- **labels_int32** (Variable) – 形为[R，1]且类型为int32的2-D LoDTensor。 R与rois中的R含义相同。每个元素都反映了RoI的一个类标签。
- **num_classes** (int) – 种类数目
- **resolution** (int) – mask预测的分辨率
返回：
- 形为[P，4]的2D LoDTensor。 P是采样出的RoI总数。每个元素都是在原始图像大小范围内具有[xmin，ymin，xmax，ymax]格式的边界框(bounding box)。
- mask_rois_has_mask_int32（Variable）：形状为[P，1]的2D LoDTensor，其中每个元素为对于输入的RoI进行输出的mask RoI 索引
- mask_int32（Variable）：形状为[P，K * M * M]的2D LoDTensor，K为种类数，M为mask预测的分辨率，每个元素都是二进制目标mask值。
返回类型：mask_rois (Variable)
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
im_info = fluid.layers.data(name="im_info", shape=[3],
dtype="float32")
gt_classes = fluid.layers.data(name="gt_classes", shape=[1],
dtype="float32", lod_level=1)
is_crowd = fluid.layers.data(name="is_crowd", shape=[1],
dtype="float32", lod_level=1)
gt_masks = fluid.layers.data(name="gt_masks", shape=[2],
dtype="float32", lod_level=3)
# rois, roi_labels 可以是fluid.layers.generate_proposal_labels的输出
rois = fluid.layers.data(name="rois", shape=[4],
dtype="float32", lod_level=1)
roi_labels = fluid.layers.data(name="roi_labels", shape=[1],
dtype="int32", lod_level=1)
mask_rois, mask_index, mask_int32 = fluid.layers.generate_mask_labels(
im_info=im_info,
gt_classes=gt_classes,
is_crowd=is_crowd,
gt_segms=gt_masks,
rois=rois,
labels_int32=roi_labels,
num_classes=81,
resolution=14)
.. _cn_api_fluid_layers_generate_proposal_labels:
generate_proposal_labels
-------------------------------
.. py:function:: paddle.fluid.layers.generate_proposal_labels(rpn_rois, gt_classes, is_crowd, gt_boxes, im_info, batch_size_per_im=256, fg_fraction=0.25, fg_thresh=0.25, bg_thresh_hi=0.5, bg_thresh_lo=0.0, bbox_reg_weights=[0.1, 0.1, 0.2, 0.2], class_nums=None, use_random=True, is_cls_agnostic=False, is_cascade_rcnn=False)
**该函数可以应用于 Faster-RCNN 网络，生成建议标签。**
该函数可以根据 ``GenerateProposals`` 的输出结果，即bounding boxes（区域框），groundtruth（正确标记数据）来对foreground boxes和background boxes进行采样，并计算loss值。
RpnRois 是RPN的输出box， 并由 ``GenerateProposals`` 来进一步处理, 这些box将与groundtruth boxes合并， 并根据 ``batch_size_per_im`` 和 ``fg_fraction`` 进行采样。
如果一个实例具有大于 ``fg_thresh`` (前景重叠阀值)的正确标记重叠，那么它会被认定为一个前景样本。
如果一个实例具有的正确标记重叠大于 ``bg_thresh_lo`` 且小于 ``bg_thresh_hi`` (详见参数说明)，那么它将被认定为一个背景样本。
在所有前景、背景框（即Rois regions of interest 直译：有意义的区域）被选择后，我们接着采用随机采样的方法来确保前景框数量不多于 batch_size_per_im * fg_fraction 。
对Rois中的每个box, 我们给它分配类标签和回归目标(box label)。最后 ``bboxInsideWeights`` 和 ``BboxOutsideWeights`` 用来指明是否它将影响训练loss值。
参数:
- **rpn_rois** (Variable) – 形为[N, 4]的二维LoDTensor。 N 为 ``GenerateProposals`` 的输出结果, 其中各元素为 :math:`[x_{min}, y_{min}, x_{max}, y_{max}]` 格式的边界框
- **gt_classes** (Variable) – 形为[M, 1]的二维LoDTensor。 M 为正确标记数据数目, 其中各元素为正确标记数据的类别标签
- **is_crowd** (Variable) – 形为[M, 1]的二维LoDTensor。M 为正确标记数据数目, 其中各元素为一个标志位，表明一个正确标记数据是不是crowd
- **gt_boxes** (Variable) – 形为[M, 4]的二维LoDTensor。M 为正确标记数据数目, 其中各元素为 :math:`[x_{min}, y_{min}, x_{max}, y_{max}]` 格式的边界框
- **im_info** (Variable) – 形为[B, 3]的二维LoDTensor。B 为输入图片的数目, 各元素由 im_height, im_width, im_scale 组成.
- **batch_size_per_im** (int) – 每张图片的Rois batch数目
- **fg_fraction** (float) – Foreground前景在 ``batch_size_per_im`` 中所占比例
- **fg_thresh** (float) – 前景重叠阀值，用于选择foreground前景样本
- **bg_thresh_hi** (float) – 背景重叠阀值的上界，用于筛选背景样本
- **bg_thresh_lo** (float) – 背景重叠阀值的下界，用于筛选背景样本O
- **bbox_reg_weights** (list|tuple) – Box 回归权重
- **class_nums** (int) – 种类数目
- **use_random** (bool) – 是否使用随机采样来选择foreground（前景）和background（背景） boxes（框）
- **is_cls_agnostic** （bool）- 未知类别的bounding box回归，仅标识前景和背景框
- **is_cascade_rcnn** （bool）- 是否为 cascade RCNN 模型，为True时采样策略发生变化
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
rpn_rois = fluid.layers.data(name='rpn_rois', shape=[2, 4],
append_batch_size=False, dtype='float32')
gt_classes = fluid.layers.data(name='gt_classes', shape=[8, 1],
append_batch_size=False, dtype='float32')
is_crowd = fluid.layers.data(name='is_crowd', shape=[8, 1],
append_batch_size=False, dtype='float32')
gt_boxes = fluid.layers.data(name='gt_boxes', shape=[8, 4],
append_batch_size=False, dtype='float32')
im_info = fluid.layers.data(name='im_info', shape=[10, 3],
append_batch_size=False, dtype='float32')
rois, labels_int32, bbox_targets, bbox_inside_weights,
bbox_outside_weights = fluid.layers.generate_proposal_labels(
rpn_rois, gt_classes, is_crowd, gt_boxes, im_info,
class_nums=10)
.. _cn_api_fluid_layers_generate_proposals:
generate_proposals
-------------------------------
.. py:function:: paddle.fluid.layers.generate_proposals(scores, bbox_deltas, im_info, anchors, variances, pre_nms_top_n=6000, post_nms_top_n=1000, nms_thresh=0.5, min_size=0.1, eta=1.0, name=None)
生成proposal的Faster-RCNN
该操作根据每个框为foreground（前景）对象的概率，并且通过anchors来计算这些框，进而提出RoI。Bbox_deltais和一个objects的分数作为是RPN的输出。最终 ``proposals`` 可用于训练检测网络。
为了生成 ``proposals`` ，此操作执行以下步骤：
1、转置和调整bbox_deltas的分数和大小为（H * W * A，1）和（H * W * A，4）。
2、计算方框位置作为 ``proposals`` 候选框。
3、剪辑框图像。
4、删除小面积的预测框。
5、应用NMS以获得最终 ``proposals`` 作为输出。
参数：
- **scores** (Variable)- 是一个shape为[N，A，H，W]的4-D张量，表示每个框成为object的概率。N是批量大小，A是anchor数，H和W是feature map的高度和宽度。
- **bbox_deltas** （Variable）- 是一个shape为[N，4 * A，H，W]的4-D张量，表示预测框位置和anchor位置之间的差异。
- **im_info** （Variable）- 是一个shape为[N，3]的2-D张量，表示N个批次原始图像的信息。信息包含原始图像大小和 ``feature map`` 的大小之间高度，宽度和比例。
- **anchors** （Variable）- 是一个shape为[H，W，A，4]的4-D Tensor。H和W是 ``feature map`` 的高度和宽度，
- **num_anchors** - 是每个位置的框的数量。每个anchor都是以非标准化格式（xmin，ymin，xmax，ymax）定义的。
- **variances** （Variable）- anchor的方差，shape为[H，W，num_priors，4]。每个方差都是（xcenter，ycenter，w，h）这样的格式。
- **pre_nms_top_n** （float）- 每个图在NMS之前要保留的总框数。默认为6000。
- **post_nms_top_n** （float）- 每个图在NMS后要保留的总框数。默认为1000。
- **nms_thresh** （float）- NMS中的阈值，默认为0.5。
- **min_size** （float）- 删除高度或宽度小于min_size的预测框。默认为0.1。
- **eta** （float）- 在自适应NMS中应用，如果自适应阈值> 0.5，则在每次迭代中使用adaptive_threshold = adaptive_treshold * eta。
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
scores = fluid.layers.data(name='scores', shape=[2, 4, 5, 5],
append_batch_size=False, dtype='float32')
bbox_deltas = fluid.layers.data(name='bbox_deltas', shape=[2, 16, 5, 5],
append_batch_size=False, dtype='float32')
im_info = fluid.layers.data(name='im_info', shape=[2, 3],
append_batch_size=False, dtype='float32')
anchors = fluid.layers.data(name='anchors', shape=[5, 5, 4, 4],
append_batch_size=False, dtype='float32')
variances = fluid.layers.data(name='variances', shape=[5, 5, 10, 4],
append_batch_size=False, dtype='float32')
rois, roi_probs = fluid.layers.generate_proposals(scores, bbox_deltas,
im_info, anchors, variances)
.. _cn_api_fluid_layers_iou_similarity:
iou_similarity
-------------------------------
.. py:function:: paddle.fluid.layers.iou_similarity(x, y, name=None)
**IOU Similarity Operator**
计算两个框列表的intersection-over-union(IOU)。框列表‘X’应为LoDTensor，‘Y’是普通张量，X成批输入的所有实例共享‘Y’中的框。给定框A和框B，IOU的运算如下：
.. math::
IOU(A, B) = \frac{area(A\cap B)}{area(A)+area(B)-area(A\cap B)}
参数：
- **x** (Variable,默认LoDTensor,float类型) - 框列表X是二维LoDTensor，shape为[N,4],存有N个框，每个框代表[xmin,ymin,xmax,ymax],X的shape为[N,4]。如果输入是图像特征图,[xmin,ymin]市框的左上角坐标，接近坐标轴的原点。[xmax,ymax]是框的右下角坐标。张量可以包含代表一批输入的LoD信息。该批的一个实例能容纳不同的项数
- **y** (Variable,张量，默认float类型的张量) - 框列表Y存有M个框，每个框代表[xmin,ymin,xmax,ymax],X的shape为[N,4]。如果输入是图像特征图,[xmin,ymin]市框的左上角坐标，接近坐标轴的原点。[xmax,ymax]是框的右下角坐标。张量可以包含代表一批输入的LoD信息。
返回：iou_similarity操作符的输出，shape为[N,M]的张量，代表一对iou分数
返回类型：out(Variable)
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[4], dtype='float32')
y = fluid.layers.data(name='y', shape=[4], dtype='float32')
iou = fluid.layers.iou_similarity(x=x, y=y)
.. _cn_api_fluid_layers_multi_box_head:
multi_box_head
-------------------------------
.. py:function:: paddle.fluid.layers.multi_box_head(inputs, image, base_size, num_classes, aspect_ratios, min_ratio=None, max_ratio=None, min_sizes=None, max_sizes=None, steps=None, step_w=None, step_h=None, offset=0.5, variance=[0.1, 0.1, 0.2, 0.2], flip=True, clip=False, kernel_size=1, pad=0, stride=1, name=None, min_max_aspect_ratios_order=False)
生成SSD（Single Shot MultiBox Detector）算法的候选框。有关此算法的详细信息，请参阅SSD论文 `SSD：Single Shot MultiBox Detector <https://arxiv.org/abs/1512.02325>`_ 的2.2节。
参数：
- **inputs** （list | tuple）- 输入变量列表，所有变量的格式为NCHW。
- **image** （Variable）- PriorBoxOp的输入图像数据，布局为NCHW。
- **base_size** （int）- base_size用于根据 ``min_ratio`` 和 ``max_ratio`` 来获取 ``min_size`` 和 ``max_size`` 。
- **num_classes** （int）- 类的数量。
- **aspect_ratios** （list | tuple）- 生成候选框的宽高比。 ``input`` 和 ``aspect_ratios`` 的长度必须相等。
- **min_ratio** （int）- 生成候选框的最小比率。
- **max_ratio** （int）- 生成候选框的最大比率。
- **min_sizes** （list | tuple | None）- 如果len（输入）<= 2，则必须设置 ``min_sizes`` ，并且 ``min_sizes`` 的长度应等于输入的长度。默认值：无。
- **max_sizes** （list | tuple | None）- 如果len（输入）<= 2，则必须设置 ``max_sizes`` ，并且 ``min_sizes`` 的长度应等于输入的长度。默认值：无。
- **steps** （list | tuple）- 如果step_w和step_h相同，则step_w和step_h可以被steps替换。
- **step_w** （list | tuple）- 候选框跨越宽度。如果step_w [i] == 0.0，将自动计算输跨越入[i]宽度。默认值：无。
- **step_h** （list | tuple）- 候选框跨越高度，如果step_h [i] == 0.0，将自动计算跨越输入[i]高度。默认值：无。
- **offset** （float）- 候选框中心偏移。默认值：0.5
- **variance** （list | tuple）- 在候选框编码的方差。默认值：[0.1,0.1,0.2,0.2]。
- **flip** （bool）- 是否翻转宽高比。默认值：false。
- **clip** （bool）- 是否剪切超出边界的框。默认值：False。
- **kernel_size** （int）- conv2d的内核大小。默认值：1。
- **pad** （int | list | tuple）- conv2d的填充。默认值：0。
- **stride** （int | list | tuple）- conv2d的步长。默认值：1，
- **name** （str）- 候选框的名称。默认值：无。
- **min_max_aspect_ratios_order** （bool）- 如果设置为True，则输出候选框的顺序为[min，max，aspect_ratios]，这与Caffe一致。请注意，此顺序会影响卷积层后面的权重顺序，但不会影响最终检测结果。默认值：False。
返回：一个带有四个变量的元组，（mbox_loc，mbox_conf，boxes, variances）:
- **mbox_loc** ：预测框的输入位置。布局为[N，H * W * Priors，4]。其中 ``Priors`` 是每个输位置的预测框数。
- **mbox_conf** ：预测框对输入的置信度。布局为[N，H * W * Priors，C]。其中 ``Priors`` 是每个输入位置的预测框数，C是类的数量。
- **boxes** ： ``PriorBox`` 的输出候选框。布局是[num_priors，4]。 ``num_priors`` 是每个输入位置的总框数。
- **variances** ： ``PriorBox`` 的方差。布局是[num_priors，4]。 ``num_priors`` 是每个输入位置的总窗口数。
返回类型：元组（tuple）
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
images = fluid.layers.data(name='data', shape=[3, 300, 300], dtype='float32')
conv1 = fluid.layers.data(name='conv1', shape=[512, 19, 19], dtype='float32')
conv2 = fluid.layers.data(name='conv2', shape=[1024, 10, 10], dtype='float32')
conv3 = fluid.layers.data(name='conv3', shape=[512, 5, 5], dtype='float32')
conv4 = fluid.layers.data(name='conv4', shape=[256, 3, 3], dtype='float32')
conv5 = fluid.layers.data(name='conv5', shape=[256, 2, 2], dtype='float32')
conv6 = fluid.layers.data(name='conv6', shape=[128, 1, 1], dtype='float32')
mbox_locs, mbox_confs, box, var = fluid.layers.multi_box_head(
inputs=[conv1, conv2, conv3, conv4, conv5, conv6],
image=images,
num_classes=21,
min_ratio=20,
max_ratio=90,
aspect_ratios=[[2.], [2., 3.], [2., 3.], [2., 3.], [2.], [2.]],
base_size=300,
offset=0.5,
flip=True,
clip=True)
.. _cn_api_fluid_layers_multiclass_nms:
multiclass_nms
-------------------------------
.. py:function:: paddle.fluid.layers.multiclass_nms(bboxes, scores, score_threshold, nms_top_k, keep_top_k, nms_threshold=0.3, normalized=True, nms_eta=1.0, background_label=0, name=None)
**多分类NMS**
该运算用于对边界框（bounding box）和评分进行多类非极大值抑制（NMS）。
在NMS中，如果提供 ``score_threshold`` 阈值，则此算子贪婪地选择具有高于 ``score_threshold`` 的高分数的检测边界框（bounding box）的子集，然后如果nms_top_k大于-1，则选择最大的nms_top_k置信度分数。 接着，该算子基于 ``nms_threshold`` 和 ``nms_eta`` 参数，通过自适应阈值NMS移去与已经选择的框具有高IOU（intersection over union）重叠的框。
在NMS步骤后，如果keep_top_k大于-1，则每个图像最多保留keep_top_k个总bbox数。
参数：
- **bboxes** (Variable) – 支持两种类型的bbox（bounding box）:
1. （Tensor）具有形[N，M，4]或[8 16 24 32]的3-D张量表示M个边界bbox的预测位置， N是批大小batch size。当边界框(bounding box)大小等于4时，每个边界框有四个坐标值，布局为[xmin，ymin，xmax，ymax]。
2. （LoDTensor）形状为[M，C，4] M的三维张量是边界框的数量，C是种类数量
- **scores** (Variable) – 支持两种类型的分数：
1. （tensor）具有形状[N，C，M]的3-D张量表示预测的置信度。 N是批量大小 batch size，C是种类数目，M是边界框bounding box的数量。对于每个类别，存在对应于M个边界框的总M个分数。请注意，M等于bboxes的第二维。
2. （LoDTensor）具有形状[M，C]的2-D LoDTensor。 M是bbox的数量，C是种类数目。在这种情况下，输入bboxes应该是形为[M，C，4]的第二种情况。
- **background_label** (int) – 背景标签（类别）的索引，背景标签（类别）将被忽略。如果设置为-1，则将考虑所有类别。默认值：0
- **score_threshold** (float) – 过滤掉低置信度分数的边界框的阈值。如果没有提供，请考虑所有边界框。
- **nms_top_k** (int) – 根据通过score_threshold的过滤后而得的检测(detection)的置信度，所需要保留的最大检测数。
- **nms_threshold** (float) – 在NMS中使用的阈值。默认值：0.3 。
- **nms_eta** (float) – 在NMS中使用的阈值。默认值：1.0 。
- **keep_top_k** (int) – NMS步骤后每个图像要保留的总bbox数。 -1表示在NMS步骤之后保留所有bbox。
- **normalized** (bool) – 检测是否已经经过正则化。默认值：True 。
- **name** (str) – 多类nms op(此op)的名称，用于自定义op在网络中的命名。默认值：None 。
返回：形为[No，6]的2-D LoDTensor，表示检测(detections)结果。每行有6个值：[标签label，置信度confidence，xmin，ymin，xmax，ymax]。或形为[No，10]的2-D LoDTensor，用来表示检测结果。 每行有10个值：[标签label，置信度confidence，x1，y1，x2，y2，x3，y3，x4，y4]。 No是检测的总数。 如果对所有图像都没有检测到的box，则lod将设置为{1}，而Out仅包含一个值-1。 （1.3版本之后，当未检测到box时，lod从{0}更改为{1}）
返回类型：Out
**代码示例**
.. code-block:: python
boxes = fluid.layers.data(name='bboxes', shape=[81, 4],
dtype='float32', lod_level=1)
scores = fluid.layers.data(name='scores', shape=[81],
dtype='float32', lod_level=1)
out = fluid.layers.multiclass_nms(bboxes=boxes,
scores=scores,
background_label=0,
score_threshold=0.5,
nms_top_k=400,
nms_threshold=0.3,
keep_top_k=200,
normalized=False)
.. _cn_api_fluid_layers_polygon_box_transform:
polygon_box_transform
-------------------------------
.. py:function:: paddle.fluid.layers.polygon_box_transform(input, name=None)
PolygonBoxTransform 算子。
该算子用于将偏移坐标转变为真正的坐标。
输入是检测网络的最终几何输出。我们使用 2*n 个数来表示从 polygon_box 中的 n 个顶点(vertice)到像素位置的偏移。由于每个距离偏移包含两个数字 :math:`(x_i, y_i)` ，所以何输出包含 2*n 个通道。
参数：
- **input** （Variable） - shape 为[batch_size，geometry_channels，height，width]的张量
返回：与输入 shape 相同
返回类型：output（Variable）
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
input = fluid.layers.data(name='input', shape=[4, 10, 5, 5],
append_batch_size=False, dtype='float32')
out = fluid.layers.polygon_box_transform(input)
.. _cn_api_fluid_layers_prior_box:
prior_box
-------------------------------
.. py:function:: paddle.fluid.layers.prior_box(input,image,min_sizes=None,max_sizes=None,aspect_ratios=[1.0],variance=[0.1,0.1,0.2,0.2],flip=False,clip=False,steps=[0.0,0.0],offset=0.5,name=None,min_max_aspect_ratios_order=False)
**Prior Box操作符**
为SSD(Single Shot MultiBox Detector)算法生成先验框。输入的每个位产生N个先验框，N由min_sizes,max_sizes和aspect_ratios的数目决定，先验框的尺寸在(min_size,max_size)之间，该尺寸根据aspect_ratios在序列中生成。
参数：
- **input** (Variable)-输入变量，格式为NCHW
- **image** (Variable)-PriorBoxOp的输入图像数据，布局为NCHW
- **min_sizes** (list|tuple|float值)-生成的先验框的最小尺寸
- **max_sizes** (list|tuple|None)-生成的先验框的最大尺寸。默认：None
- **aspect_ratios** (list|tuple|float值)-生成的先验框的纵横比。默认：[1.]
- **variance** (list|tuple)-先验框中的变量，会被解码。默认：[0.1,0.1,0.2,0.2]
- **flip** (bool)-是否忽略纵横比。默认：False。
- **clip** (bool)-是否修建溢界框。默认：False。
- **step** (list|tuple)-先验框在width和height上的步长。如果step[0] == 0.0/step[1] == 0.0，则自动计算先验框在宽度和高度上的步长。默认：[0.,0.]
- **offset** (float)-先验框中心位移。默认：0.5
- **name** (str)-先验框操作符名称。默认：None
- **min_max_aspect_ratios_order** (bool)-若设为True,先验框的输出以[min,max,aspect_ratios]的顺序，和Caffe保持一致。请注意，该顺序会影响后面卷基层的权重顺序，但不影响最后的检测结果。默认：False。
返回：
含有两个变量的元组(boxes,variances)
boxes:PriorBox的输出先验框。布局是[H,W,num_priors,4]。H是输入的高度，W是输入的宽度，num_priors是输入每位的总框数
variances:PriorBox的扩展变量。布局上[H,W,num_priors,4]。H是输入的高度，W是输入的宽度，num_priors是输入每位的总框数
返回类型：元组
**代码示例**：
.. code-block:: python
input = fluid.layers.data(name="input", shape=[3,6,9])
images = fluid.layers.data(name="images", shape=[3,9,12])
box, var = fluid.layers.prior_box(
input=input,
image=images,
min_sizes=[100.],
flip=True,
clip=True)
.. _cn_api_fluid_layers_retinanet_detection_output:
retinanet_detection_output
-------------------------------
.. py:function:: paddle.fluid.layers.retinanet_detection_output(bboxes, scores, anchors, im_info, score_threshold=0.05, nms_top_k=1000, keep_top_k=100, nms_threshold=0.3, nms_eta=1.0)
**Retinanet的检测输出层**
此操作通过执行以下步骤获取检测结果：
1. 根据anchor框解码每个FPN级别的最高得分边界框预测。
2. 合并所有级别的顶级预测并对其应用多级非最大抑制（NMS）以获得最终检测。
参数：
- **bboxes** (List) – 来自多个FPN级别的张量列表。每个元素都是一个三维张量，形状[N，Mi，4]代表Mi边界框的预测位置。N是batch大小，Mi是第i个FPN级别的边界框数，每个边界框有四个坐标值，布局为[xmin，ymin，xmax，ymax]。
- **scores** (List) – 来自多个FPN级别的张量列表。每个元素都是一个三维张量，各张量形状为[N，Mi，C]，代表预测的置信度预测。 N是batch大小，C是类编号（不包括背景），Mi是第i个FPN级别的边界框数。对于每个边界框，总共有C个评分。
- **anchors** (List) – 具有形状[Mi，4]的2-D Tensor表示来自所有FPN级别的Mi anchor框的位置。每个边界框有四个坐标值，布局为[xmin，ymin，xmax，ymax]。
- **im_info** (Variable) – 形状为[N，3]的2-D LoDTensor表示图像信息。 N是batch大小，每个图像信息包括高度，宽度和缩放比例。
- **score_threshold** (float) – 用置信度分数剔除边界框的过滤阈值。
- **nms_top_k** (int) – 根据NMS之前的置信度保留每个FPN层的最大检测数。
- **keep_top_k** (int) – NMS步骤后每个图像要保留的总边界框数。 -1表示在NMS步骤之后保留所有边界框。
- **nms_threshold** (float) – NMS中使用的阈值.
- **nms_eta** (float) – adaptive NMS的参数.
返回：
检测输出是具有形状[No，6]的LoDTensor。 每行有六个值：[标签，置信度，xmin，ymin，xmax，ymax]。 No是此mini batch中的检测总数。 对于每个实例，第一维中的偏移称为LoD，偏移值为N + 1，N是batch大小。 第i个图像具有LoD [i + 1] - LoD [i]检测结果，如果为0，则第i个图像没有检测到结果。 如果所有图像都没有检测到结果，则LoD将设置为0，输出张量为空（None）。
返回类型：变量（Variable）
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
bboxes = layers.data(name='bboxes', shape=[1, 21, 4],
append_batch_size=False, dtype='float32')
scores = layers.data(name='scores', shape=[1, 21, 10],
append_batch_size=False, dtype='float32')
anchors = layers.data(name='anchors', shape=[21, 4],
append_batch_size=False, dtype='float32')
im_info = layers.data(name="im_info", shape=[1, 3],
append_batch_size=False, dtype='float32')
nmsed_outs = fluid.layers.retinanet_detection_output(
bboxes=[bboxes, bboxes],
scores=[scores, scores],
anchors=[anchors, anchors],
im_info=im_info,
score_threshold=0.05,
nms_top_k=1000,
keep_top_k=100,
nms_threshold=0.3,
nms_eta=1.)
.. _cn_api_fluid_layers_retinanet_target_assign:
retinanet_target_assign
-------------------------------
.. py:function:: paddle.fluid.layers.retinanet_target_assign(bbox_pred, cls_logits, anchor_box, anchor_var, gt_boxes, gt_labels, is_crowd, im_info, num_classes=1, positive_overlap=0.5, negative_overlap=0.4)
**Retinanet的目标分配层**
对于给定anchors和真实(ground-truth)框之间的Intersection-over-Union（IoU）重叠，该层可以为每个anchor分配分类和回归目标，同时这些目标标签用于训练Retinanet。每个anchor都分配有长度为num_classes的一个one-hot分类目标向量，以及一个4向量的框回归目标。分配规则如下：
1.在以下情况下，anchor被分配到真实框：
（i）它与真实框具有最高的IoU重叠，或者（ii）与任何真实框具有高于positive_overlap（0.5）的IoU重叠。
2.对于所有真实框，当其IoU比率低于negative_overlap（0.4）时，将anchor点分配给背景。
当为锚点分配了第i个类别的真实框时，其C向量目标中的第i项设置为1，所有其他条目设置为0.当anchor被分配支背景时，所有项都设置为0。未被分配的锚点不会影响训练目标。回归目标是与指定anchor相关联的已编码真实框。
参数：
- **bbox_pred** (Variable) – 具有形状[N，M，4]的3-D张量表示M个边界框(bounding box)的预测位置。 N是batch大小，每个边界框有四个坐标值，为[xmin，ymin，xmax，ymax]。
- **cls_logits** (Variable) – 具有形状[N，M，C]的3-D张量，表示预测的置信度。 N是batch大小，C是类别的数量（不包括背景），M是边界框的数量。
- **anchor_box** (Variable) – 具有形状[M，4]的2-D张量，存有M个框，每个框表示为[xmin，ymin，xmax，ymax]，[xmin，ymin]是anchor的左上顶部坐标，如果输入是图像特征图，则它们接近坐标系的原点。 [xmax，ymax]是anchor的右下坐标。
- **anchor_var** (Variable) – 具有形状[M，4]的2-D张量，存有anchor的扩展方差。
- **gt_boxes** (Variable) – 真实框是具有形状[Ng，4]的2D LoDTensor，Ng是mini batch中真实框的总数。
- **gt_labels** (variable) – 真实值标签是具有形状[Ng，1]的2D LoDTensor，Ng是mini batch输入真实值标签的总数。
- **is_crowd** (Variable) – 1-D LoDTensor，标志真实值是聚群。
- **im_info** (Variable) – 具有形状[N，3]的2-D LoDTensor。 N是batch大小，3分别为高度，宽度和比例。
- **num_classes** (int32) – 种类数量。
- **positive_overlap** (float) – 判定（anchor，gt框）对是一个正例的anchor和真实框之间最小重叠阀值。
- **negative_overlap** (float) – （锚点，gt框）对是负例时anchor和真实框之间允许的最大重叠阈值。
返回：
返回元组（predict_scores，predict_location，target_label，target_bbox，bbox_inside_weight，fg_num）。 predict_scores和predict_location是Retinanet的预测结果。target_label和target_bbox为真实值。 predict_location是形为[F，4]的2D张量，target_bbox的形状与predict_location的形状相同，F是前景anchor的数量。 predict_scores是具有形状[F + B，C]的2D张量，target_label的形状是[F + B，1]，B是背景anchor的数量，F和B取决于此算子的输入。 Bbox_inside_weight标志预测位置是否为假前景，形状为[F，4]。 Fg_num是focal loss所需的前景数（包括假前景）。
返回类型：tuple
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
bbox_pred = layers.data(name='bbox_pred', shape=[1, 100, 4],
append_batch_size=False, dtype='float32')
cls_logits = layers.data(name='cls_logits', shape=[1, 100, 10],
append_batch_size=False, dtype='float32')
anchor_box = layers.data(name='anchor_box', shape=[100, 4],
append_batch_size=False, dtype='float32')
anchor_var = layers.data(name='anchor_var', shape=[100, 4],
append_batch_size=False, dtype='float32')
gt_boxes = layers.data(name='gt_boxes', shape=[10, 4],
append_batch_size=False, dtype='float32')
gt_labels = layers.data(name='gt_labels', shape=[10, 1],
append_batch_size=False, dtype='float32')
is_crowd = fluid.layers.data(name='is_crowd', shape=[1],
append_batch_size=False, dtype='float32')
im_info = fluid.layers.data(name='im_infoss', shape=[1, 3],
append_batch_size=False, dtype='float32')
loc_pred, score_pred, loc_target, score_target, bbox_inside_weight, fg_num =
fluid.layers.retinanet_target_assign(bbox_pred, cls_logits, anchor_box,
anchor_var, gt_boxes, gt_labels, is_crowd, im_info, 10)
.. _cn_api_fluid_layers_roi_perspective_transform:
roi_perspective_transform
-------------------------------
.. py:function:: paddle.fluid.layers.roi_perspective_transform(input, rois, transformed_height, transformed_width, spatial_scale=1.0)
**ROI perspective transform操作符**
参数：
- **input** (Variable) - ROI Perspective TransformOp的输入。输入张量的形式为NCHW。N是批尺寸，C是输入通道数，H是特征高度，W是特征宽度
- **rois** (Variable) - 用来处理的ROIs，应该是shape的二维LoDTensor(num_rois,8)。给定[[x1,y1,x2,y2,x3,y3,x4,y4],...],(x1,y1)是左上角坐标，(x2,y2)是右上角坐标，(x3,y3)是右下角坐标，(x4,y4)是左下角坐标
- **transformed_height** (integer) - 输出的高度
- **transformed_width** (integer) – 输出的宽度
- **spatial_scale** (float) - 空间尺度因子，用于缩放ROI坐标，默认：1.0。
返回：
``ROIPerspectiveTransformOp`` 的输出，它是一个4维张量，形为 (num_rois,channels,transformed_h,transformed_w)
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[256, 28, 28], dtype='float32')
rois = fluid.layers.data(name='rois', shape=[8], lod_level=1, dtype='float32')
out = fluid.layers.roi_perspective_transform(x, rois, 7, 7, 1.0)
.. _cn_api_fluid_layers_rpn_target_assign:
rpn_target_assign
-------------------------------
.. py:function:: paddle.fluid.layers.rpn_target_assign(bbox_pred, cls_logits, anchor_box, anchor_var, gt_boxes, is_crowd, im_info, rpn_batch_size_per_im=256, rpn_straddle_thresh=0.0, rpn_fg_fraction=0.5, rpn_positive_overlap=0.7, rpn_negative_overlap=0.3, use_random=True)
在Faster-RCNN检测中为区域检测网络（RPN）分配目标层。
对于给定anchors和真实框之间的IoU重叠，该层可以为每个anchors做分类和回归，这些target labels用于训练RPN。classification targets是二进制的类标签（是或不是对象）。根据Faster-RCNN的论文，positive labels有两种anchors：
(i) anchor/anchors与真实框具有最高IoU重叠；
(ii) 具有IoU重叠的anchors高于带有任何真实框（ground-truth box）的rpn_positive_overlap0（0.7）。
请注意，单个真实框（ground-truth box）可以为多个anchors分配正标签。对于所有真实框（ground-truth box），非正向anchor是指其IoU比率低于rpn_negative_overlap（0.3）。既不是正也不是负的anchors对训练目标没有价值。回归目标是与positive anchors相关联而编码的图片真实框。
参数：
- **bbox_pred** （Variable）- 是一个shape为[N，M，4]的3-D Tensor，表示M个边界框的预测位置。N是批量大小，每个边界框有四个坐标值，即[xmin，ymin，xmax，ymax]。
- **cls_logits** （Variable）- 是一个shape为[N，M，1]的3-D Tensor，表示预测的置信度。N是批量大小，1是frontground和background的sigmoid，M是边界框的数量。
- **anchor_box** （Variable）- 是一个shape为[M，4]的2-D Tensor，它拥有M个框，每个框可表示为[xmin，ymin，xmax，ymax]，[xmin，ymin]是anchor框的左上部坐标，如果输入是图像特征图，则它们接近坐标系的原点。 [xmax，ymax]是anchor框的右下部坐标。
- **anchor_var** （Variable）- 是一个shape为[M，4]的2-D Tensor，它拥有anchor的expand方差。
- **gt_boxes** （Variable）- 真实边界框是一个shape为[Ng，4]的2D LoDTensor，Ng是小批量输入的真实框（bbox）总数。
- **is_crowd** （Variable）- 1-D LoDTensor，表示（groud-truth）是密集的。
- **im_info** （Variable）- 是一个形为[N，3]的2-D LoDTensor。N是batch大小，第二维上的3维分别代表高度，宽度和比例(scale)
- **rpn_batch_size_per_im** （int）- 每个图像中RPN示例总数。
- **rpn_straddle_thresh** （float）- 通过straddle_thresh像素删除出现在图像外部的RPN anchor。
- **rpn_fg_fraction** （float）- 为foreground（即class> 0）RoI小批量而标记的目标分数，第0类是background。
- **rpn_positive_overlap** （float）- 对于一个正例的（anchor, gt box）对，是允许anchors和所有真实框之间最小重叠的。
- **rpn_negative_overlap** （float）- 对于一个反例的（anchor, gt box）对，是允许anchors和所有真实框之间最大重叠的。
返回:
返回元组 (predicted_scores, predicted_location, target_label, target_bbox, bbox_inside_weight) :
- **predicted_scores** 和 **predicted_location** 是RPN的预测结果。 **target_label** 和 **target_bbox** 分别是真实准确数据(ground-truth)。
- **predicted_location** 是一个形为[F，4]的2D Tensor， **target_bbox** 的形与 **predicted_location** 相同，F是foreground anchors的数量。
- **predicted_scores** 是一个shape为[F + B，1]的2D Tensor， **target_label** 的形与 **predict_scores** 的形相同，B是background anchors的数量，F和B取决于此算子的输入。
- **Bbox_inside_weight** 标志着predicted_loction是否为fake_fg（假前景），其形为[F,4]。
返回类型： 元组(tuple)
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
bbox_pred = fluid.layers.data(name=’bbox_pred’, shape=[100, 4],
append_batch_size=False, dtype=’float32’)
cls_logits = fluid.layers.data(name=’cls_logits’, shape=[100, 1],
append_batch_size=False, dtype=’float32’)
anchor_box = fluid.layers.data(name=’anchor_box’, shape=[20, 4],
append_batch_size=False, dtype=’float32’)
gt_boxes = fluid.layers.data(name=’gt_boxes’, shape=[10, 4],
append_batch_size=False, dtype=’float32’)
is_crowd = fluid.layers.data(name='is_crowd', shape=[1],
append_batch_size=False, dtype='float32')
im_info = fluid.layers.data(name='im_infoss', shape=[1, 3],
append_batch_size=False, dtype='float32')
loc_pred, score_pred, loc_target, score_target, bbox_inside_weight=
fluid.layers.rpn_target_assign(bbox_pred, cls_logits,
anchor_box, anchor_var, gt_boxes, is_crowd, im_info)
.. _cn_api_fluid_layers_sigmoid_focal_loss:
sigmoid_focal_loss
-------------------------------
.. py:function:: paddle.fluid.layers.sigmoid_focal_loss(x, label, fg_num, gamma=2, alpha=0.25)
**Sigmoid Focal loss损失计算**
focal损失用于解决在one-stage探测器的训练阶段存在的前景 - 背景类不平衡问题。 此运算符计算输入张量中每个元素的sigmoid值，然后计算focal损失。
focal损失计算过程：
.. math::
loss_j = (-label_j * alpha * {(1 - \sigma(x_j))}^{gamma} * \log(\sigma(x_j)) -
(1 - labels_j) * (1 - alpha) * {(\sigma(x_j)}^{ gamma} * \log(1 - \sigma(x_j)))
/ fg\_num, j = 1,...,K
其中，已知：
.. math::
\sigma(x_j) = \frac{1}{1 + \exp(-x_j)}
参数：
- **x** (Variable) – 具有形状[N，D]的2-D张量，其中N是batch大小，D是类的数量（不包括背景）。 此输入是由前一个运算符计算出的logits张量。
- **label** (Variable) – 形状为[N，1]的二维张量，是所有可能的标签。
- **fg_num** (Variable) – 具有形状[1]的1-D张量，是前景的数量。
- **gamma** (float) – 用于平衡简单和复杂实例的超参数。 默认值设置为2.0。
- **alpha** (float) – 用于平衡正面和负面实例的超参数。 默认值设置为0.25。
返回： 具有形状[N，D]的2-D张量，即focal损失。
返回类型： out(Variable)
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
input = fluid.layers.data(
name='data', shape=[10,80], append_batch_size=False, dtype='float32')
label = fluid.layers.data(
name='label', shape=[10,1], append_batch_size=False, dtype='int32')
fg_num = fluid.layers.data(
name='fg_num', shape=[1], append_batch_size=False, dtype='int32')
loss = fluid.layers.sigmoid_focal_loss(x=input,
label=label,
fg_num=fg_num,
gamma=2.,
alpha=0.25)
.. _cn_api_fluid_layers_ssd_loss:
ssd_loss
-------------------------------
.. py:function:: paddle.fluid.layers.ssd_loss(location, confidence, gt_box, gt_label, prior_box, prior_box_var=None, background_label=0, overlap_threshold=0.5, neg_pos_ratio=3.0, neg_overlap=0.5, loc_loss_weight=1.0, conf_loss_weight=1.0, match_type='per_prediction', mining_type='max_negative', normalize=True, sample_size=None)
用于SSD的对象检测算法的多窗口损失层
该层用于计算SSD的损失，给定位置偏移预测，置信度预测，候选框和真实框标签，以及实例挖掘的类型。通过执行以下步骤，返回的损失是本地化损失（或回归损失）和置信度损失（或分类损失）的加权和：
1、通过二分匹配算法查找匹配的边界框。
1.1、计算真实框与先验框之间的IOU相似度。
1.2、通过二分匹配算法计算匹配的边界框。
2、计算难分样本的置信度
2.1、根据匹配的索引获取目标标签。
2.2、计算置信度损失。
3、应用实例挖掘来获取负示例索引并更新匹配的索引。
4、分配分类和回归目标
4.1、根据前面的框编码bbox。
4.2、分配回归目标。
4.3、分配分类目标。
5、计算总体客观损失。
5.1计算置信度损失。
5.1计算本地化损失。
5.3计算总体加权损失。
参数：
- **location** （Variable）- 位置预测是具有形状[N，Np，4]的3D张量，N是批量大小，Np是每个实例的预测总数。 4是坐标值的数量，布局是[xmin，ymin，xmax，ymax]。
- **confidence** (Variable) - 置信度预测是具有形状[N，Np，C]，N和Np的3D张量，它们与位置相同，C是类号。
- **gt_box** （Variable）- 真实框（bbox）是具有形状[Ng，4]的2D LoDTensor，Ng是小批量输入的真实框（bbox）的总数。
- **gt_label** （Variable）- ground-truth标签是具有形状[Ng，1]的2D LoDTensor。
- **prior_box** （Variable）- 候选框是具有形状[Np，4]的2D张量。
- **prior_box_var** （Variable）- 候选框的方差是具有形状[Np，4]的2D张量。
- **background_label** （int）- background标签的索引，默认为0。
- **overlap_threshold** （float）- 当找到匹配的框，如果 ``match_type`` 为'per_prediction'，请使用 ``overlap_threshold`` 确定额外匹配的bbox。默认为0.5。
- **neg_pos_ratio** （float）- 负框与正框的比率，仅在 ``mining_type`` 为'max_negative'时使用，3.0由defalut使用。
- **neg_overlap** （float）- 不匹配预测的负重叠上限。仅当mining_type为'max_negative'时使用，默认为0.5。
- **loc_loss_weight** （float）- 本地化丢失的权重，默认为1.0。
- **conf_loss_weight** （float）- 置信度损失的权重，默认为1.0。
- **match_type** （str）- 训练期间匹配方法的类型应为'bipartite'或'per_prediction'，'per_prediction'由defalut提供。
- **mining_type** （str）- 硬示例挖掘类型应该是'hard_example'或'max_negative'，现在只支持max_negative。
- **normalize** （bool）- 是否通过输出位置的总数将SSD丢失标准化，默认为True。
- **sample_size** （int）- 负框的最大样本大小，仅在 ``mining_type`` 为'hard_example'时使用。
返回： 具有形状[N * Np，1]，N和Np的定位损失和置信度损失的加权和与它们在位置上的相同。
抛出异常： ``ValueError`` - 如果 ``mining_type`` 是'hard_example'，现在只支持 ``max_negative`` 的挖掘类型。
**代码示例**
.. code-block:: python
pb = fluid.layers.data(
name='prior_box',
shape=[10, 4],
append_batch_size=False,
dtype='float32')
pbv = fluid.layers.data(
name='prior_box_var',
shape=[10, 4],
append_batch_size=False,
dtype='float32')
loc = fluid.layers.data(name='target_box', shape=[10, 4], dtype='float32')
scores = fluid.layers.data(name='scores', shape=[10, 21], dtype='float32')
gt_box = fluid.layers.data(
name='gt_box', shape=[4], lod_level=1, dtype='float32')
gt_label = fluid.layers.data(
name='gt_label', shape=[1], lod_level=1, dtype='float32')
loss = fluid.layers.ssd_loss(loc, scores, gt_box, gt_label, pb, pbv)
.. _cn_api_fluid_layers_target_assign:
target_assign
-------------------------------
.. py:function:: paddle.fluid.layers.target_assign(input, matched_indices, negative_indices=None, mismatch_value=None, name=None)
对于给定的目标边界框（bounding box）和标签（label），该操作符对每个预测赋予分类和逻辑回归目标函数以及预测权重。权重具体表示哪个预测无需贡献训练误差。
对于每个实例，根据 ``match_indices`` 和 ``negative_indices`` 赋予输入 ``out`` 和 ``out_weight``。将定输入中每个实例的行偏移称为lod，该操作符执行分类或回归目标函数，执行步骤如下：
1.根据match_indices分配所有输入
.. code-block:: text
If id = match_indices[i][j] > 0,
out[i][j][0 : K] = X[lod[i] + id][j % P][0 : K]
out_weight[i][j] = 1.
Otherwise,
out[j][j][0 : K] = {mismatch_value, mismatch_value, ...}
out_weight[i][j] = 0.
2.如果提供neg_indices，根据neg_indices分配out_weight：
假设neg_indices中每个实例的行偏移称为neg_lod，该实例中第i个实例和neg_indices的每个id如下：
.. code-block:: text
out[i][id][0 : K] = {mismatch_value, mismatch_value, ...}
out_weight[i][id] = 1.0
参数：
- **inputs** (Variable) - 输入为三维LoDTensor，维度为[M,P,K]
- **matched_indices** (Variable) - 张量（Tensor），整型，输入匹配索引为二维张量（Tensor），类型为整型32位，维度为[N,P]，如果MatchIndices[i][j]为-1，在第i个实例中第j列项不匹配任何行项。
- **negative_indices** (Variable) - 输入负例索引，可选输入，维度为[Neg,1]，类型为整型32，Neg为负例索引的总数
- **mismatch_value** (float32) - 为未匹配的位置填充值
返回：返回一个元组（out,out_weight）。out是三维张量，维度为[N,P,K],N和P与neg_indices中的N和P一致，K和输入X中的K一致。如果match_indices[i][j]存在，out_weight是输出权重，维度为[N,P,1]。
返回类型：元组（tuple）
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(
name='x',
shape=[4, 20, 4],
dtype='float',
lod_level=1,
append_batch_size=False)
matched_id = fluid.layers.data(
name='indices',
shape=[8, 20],
dtype='int32',
append_batch_size=False)
trg, trg_weight = fluid.layers.target_assign(
x,
matched_id,
mismatch_value=0)
.. _cn_api_fluid_layers_yolo_box:
yolo_box
-------------------------------
.. py:function:: paddle.fluid.layers.yolo_box(x, img_size, anchors, class_num, conf_thresh, downsample_ratio, name=None)
该运算符从YOLOv3网络的输出生成YOLO检测框。
先前网络的输出形状为[N，C，H，W]，而H和W应相同，用来指定网格大小。对每个网格点预测给定的数目的框，这个数目记为S，由anchor的数量指定。 在第二维（通道维度）中，C应该等于S *（5 + class_num），class_num是源数据集中对象类别数目（例如coco数据集中的80），此外第二个（通道）维度中还有4个框位置坐标x，y，w，h，以及anchor box的one-hot key的置信度得分。
假设4个位置坐标是 :math:`t_x` ，:math:`t_y` ，:math:`t_w` ， :math:`t_h`
，则框的预测算法为：
.. math::
b_x &= \sigma(t_x) + c_x\\
b_y &= \sigma(t_y) + c_y\\
b_w &= p_w e^{t_w}\\
b_h &= p_h e^{t_h}\\
在上面的等式中， :math:`c_x` ， :math:`c_x` 是当前网格的左上角顶点坐标。 :math:`p_w` ， :math:`p_h` 由anchors指定。
每个anchor预测框的第五通道的逻辑回归值表示每个预测框的置信度得分，并且每个anchor预测框的最后class_num通道的逻辑回归值表示分类得分。 应忽略置信度低于conf_thresh的框。另外，框最终得分是置信度得分和分类得分的乘积。
.. math::
score_{pred} = score_{conf} * score_{class}
参数：
- **x** （Variable） - YoloBox算子的输入张量是一个4-D张量，形状为[N，C，H，W]。第二维（C）存储每个anchor box位置坐标，每个anchor box的置信度分数和one hot key。通常，X应该是YOLOv3网络的输出
- **img_size** （Variable） - YoloBox算子的图像大小张量，这是一个形状为[N，2]的二维张量。该张量保持每个输入图像的高度和宽度，用于对输出图像按输入图像比例调整输出框的大小
- **anchors** （list | tuple） - anchor的宽度和高度，它将逐对解析
- **class_num** （int） - 要预测的类数
- **conf_thresh** （float） - 检测框的置信度得分阈值。置信度得分低于阈值的框应该被忽略
- **downsample_ratio** （int） - 从网络输入到YoloBox操作输入的下采样率，因此应依次为第一个，第二个和第三个YoloBox运算设置该值为32,16,8
- **name** （string） - yolo box层的名称。默认None。
返回: 具有形状[N，M，4]的三维张量；框的坐标；以及具有形状[N，M，class_num]的三维张量；框的分类得分；
返回类型: 变量（Variable）
抛出异常:
- TypeError - yolov_box的输入x必须是Variable
- TypeError - yolo框的anchors参数必须是list或tuple
- TypeError - yolo box的class_num参数必须是整数
- TypeError - yolo框的conf_thresh参数必须是一个浮点数
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[255, 13, 13], dtype='float32')
anchors = [10, 13, 16, 30, 33, 23]
loss = fluid.layers.yolo_box(x=x, img_size=608, class_num=80, anchors=anchors,
conf_thresh=0.01, downsample_ratio=32)
.. _cn_api_fluid_layers_yolov3_loss:
yolov3_loss
-------------------------------
.. py:function:: paddle.fluid.layers.yolov3_loss(x, gt_box, gt_label, anchors, anchor_mask, class_num, ignore_thresh, downsample_ratio, gt_score=None, use_label_smooth=True, name=None)
该运算通过给定的预测结果和真实框生成yolov3损失。
之前的网络的输出形状为[N，C，H，W]，而H和W应该相同，用来指定网格(grid)大小。每个网格点预测给定的数目的边界框(bounding boxes)，这个给定的数字由每个尺度中 ``anchors`` 簇的个数指定，我们将它记为S。在第二维（表示通道的维度）中，C的值应为S *（class_num + 5），class_num是源数据集的对象种类数（如coco中为80），另外，除了存储4个边界框位置坐标x，y，w，h，还包括边界框以及每个anchor框的one-hot关键字的置信度得分。
假设有四个表征位置的坐标为 :math:`t_x, t_y, t_w, t_h` ,那么边界框的预测将会如下定义:
$$
b_x = \\sigma(t_x) + c_x
$$
$$
b_y = \\sigma(t_y) + c_y
$$
$$
b_w = p_w e^{t_w}
$$
$$
b_h = p_h e^{t_h}
$$
在上面的等式中， :math:`c_x, c_y` 是当前网格的左上角, :math:`p_w, p_h` 由anchors指定。
至于置信度得分，它是anchor框和真实框之间的IoU的逻辑回归值，anchor框的得分最高为1，此时该anchor框对应着最大IoU。
如果anchor框之间的IoU大于忽略阀值ignore_thresh，则该anchor框的置信度评分损失将会被忽略。
因此，yolov3损失包括三个主要部分，框位置损失，目标性损失，分类损失。L1损失用于
框坐标（w，h），同时，sigmoid交叉熵损失用于框坐标（x，y），目标性损失和分类损失。
每个真实框在所有anchor中找到最匹配的anchor，预测各anchor框都将会产生所有三种损失的计算，但是没有匹配GT box(ground truth box真实框)的anchor的预测只会产生目标性损失。
为了权衡大框(box)和小(box)之间的框坐标损失，框坐标损失将与比例权重相乘而得。即：
$$
weight_{box} = 2.0 - t_w * t_h
$$
最后的loss值将如下计算:
$$
loss = (loss_{xy} + loss_{wh}) * weight_{box} + loss_{conf} + loss_{class}
$$
当 ``use_label_smooth`` 设置为 ``True`` 时，在计算分类损失时将平滑分类目标，将正样本的目标平滑到1.0-1.0 / class_num，并将负样本的目标平滑到1.0 / class_num。
如果给出了 ``GTScore`` 表示真实框的mixup得分，那么真实框所产生的所有损失将乘以其混合得分。
参数：
- **x** (Variable) – YOLOv3损失运算的输入张量，这是一个形状为[N，C，H，W]的四维张量。H和W应该相同，第二维（C）存储框的位置信息，以及每个anchor box的置信度得分和one-hot分类
- **gt_box** (Variable) – 真实框，应该是[N，B，4]的形状。第三维用来承载x、y、w、h，其中 x, y是真实框的中心坐标，w, h是框的宽度和高度，且x、y、w、h将除以输入图片的尺寸，缩放到[0,1]区间内。 N是batch size，B是图像中所含有的的最多的box数目
- **gt_label** (Variable) – 真实框的类id，应该形为[N，B]。
- **anchors** (list|tuple) – 指定anchor框的宽度和高度，它们将逐对进行解析
- **anchor_mask** (list|tuple) – 当前YOLOv3损失计算中使用的anchor的mask索引
- **class_num** (int) – 要预测的类数
- **ignore_thresh** (float) – 一定条件下忽略某框置信度损失的忽略阈值
- **downsample_ratio** (int) – 从网络输入到YOLOv3 loss输入的下采样率，因此应为第一，第二和第三个YOLOv3损失运算设置32,16,8
- **name** (string) – yolov3损失层的命名
- **gt_score** （Variable） - 真实框的混合得分，形为[N，B]。 默认None。
- **use_label_smooth** (bool） - 是否使用平滑标签。 默认为True
返回: 具有形状[N]的1-D张量，yolov3损失的值
返回类型: 变量（Variable）
抛出异常:
- ``TypeError`` – yolov3_loss的输入x必须是Variable
- ``TypeError`` – 输入yolov3_loss的gtbox必须是Variable
- ``TypeError`` – 输入yolov3_loss的gtlabel必须是None或Variable
- ``TypeError`` – 输入yolov3_loss的gtscore必须是Variable
- ``TypeError`` – 输入yolov3_loss的anchors必须是list或tuple
- ``TypeError`` – 输入yolov3_loss的class_num必须是整数integer类型
- ``TypeError`` – 输入yolov3_loss的ignore_thresh必须是一个浮点数float类型
- ``TypeError`` – 输入yolov3_loss的use_label_smooth必须是bool型
**代码示例**
.. code-block:: python
x = fluid.layers.data(name='x', shape=[255, 13, 13], dtype='float32')
gt_box = fluid.layers.data(name='gtbox', shape=[6, 4], dtype='float32')
gt_label = fluid.layers.data(name='gtlabel', shape=[6], dtype='int32')
gt_score = fluid.layers.data(name='gtscore', shape=[6], dtype='float32')
anchors = [10, 13, 16, 30, 33, 23, 30, 61, 62, 45, 59, 119, 116, 90, 156, 198, 373, 326]
anchor_mask = [0, 1, 2]
loss = fluid.layers.yolov3_loss(x=x, gt_box=gt_box, gt_label=gt_label,
gt_score=gt_score, anchors=anchors,
anchor_mask=anchor_mask, class_num=80,
ignore_thresh=0.7, downsample_ratio=32)
doc/fluid/api_cn/layers_cn/io_cn.rst 0 → 100644
浏览文件 @ bf87c5c0
=======
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 0 → 100644
浏览文件 @ bf87c5c0
============================
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 0 → 100644
浏览文件 @ bf87c5c0
==============
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/nn_cn.rst 0 → 100644
浏览文件 @ bf87c5c0
因为 它太大了无法显示 source diff 。你可以改为 查看blob。
doc/fluid/api_cn/layers_cn/ops_cn.rst 0 → 100644
浏览文件 @ bf87c5c0
========
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])
doc/fluid/api_cn/layers_cn/tensor_cn.rst 0 → 100644
浏览文件 @ bf87c5c0
===========
tensor
===========
.. _cn_api_fluid_layers_argmax:
argmax
-------------------------------
.. py:function:: paddle.fluid.layers.argmax(x,axis=0)
**argmax**
该功能计算输入张量元素中最大元素的索引，张量的元素在提供的轴上。
参数：
- **x** (Variable)-用于计算最大元素索引的输入
- **axis** (int)-用于计算索引的轴
返回：存储在输出中的张量
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
x = fluid.layers.data(name="x", shape=[3, 4], dtype="float32")
out = fluid.layers.argmax(x=in, axis=0)
out = fluid.layers.argmax(x=in, axis=-1)
.. _cn_api_fluid_layers_argmin:
argmin
-------------------------------
.. py:function:: paddle.fluid.layers.argmin(x,axis=0)
**argmin**
该功能计算输入张量元素中最小元素的索引，张量元素在提供的轴上。
参数：
- **x** (Variable)-计算最小元素索引的输入
- **axis** (int)-计算索引的轴
返回：存储在输出中的张量
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
x = fluid.layers.data(name="x", shape=[3, 4], dtype="float32")
out = fluid.layers.argmin(x=in, axis=0)
out = fluid.layers.argmin(x=in, axis=-1)
.. _cn_api_fluid_layers_argsort:
argsort
-------------------------------
.. py:function:: paddle.fluid.layers.argsort(input,axis=-1,name=None)
对输入变量沿给定轴进行排序，输出排序好的数据和相应的索引，其维度和输入相同
.. code-block:: text
例如：
给定 input 并指定 axis=-1
input = [[0.15849551, 0.45865775, 0.8563702 ],
[0.12070083, 0.28766365, 0.18776911]],
执行argsort操作后，得到排序数据：
out = [[0.15849551, 0.45865775, 0.8563702 ],
[0.12070083, 0.18776911, 0.28766365]],
根据指定axis排序后的数据indices变为:
indices = [[0, 1, 2],
[0, 2, 1]]
参数：
- **input** (Variable)-用于排序的输入变量
- **axis** (int)- 沿该参数指定的轴对输入进行排序。当axis<0,实际的轴为axis+rank(input)。默认为-1，即最后一维。
- **name** (str|None)-（可选）该层名称。如果设为空，则自动为该层命名。
返回：一组已排序的数据变量和索引
返回类型：元组
**代码示例**：
.. code-block:: python
x = fluid.layers.data(name="x", shape=[3, 4], dtype="float32")
out, indices = fluid.layers.argsort(input=x, axis=0)
.. _cn_api_fluid_layers_assign:
assign
-------------------------------
.. py:function:: paddle.fluid.layers.assign(input,output=None)
该函数将输入变量复制到输出变量
参数：
- **input** (Variable|numpy.ndarray)-源变量
- **output** (Variable|None)-目标变量
返回：作为输出的目标变量
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.data(name="data", shape=[3, 32, 32], dtype="float32")
out = fluid.layers.create_tensor(dtype='float32')
hidden = fluid.layers.fc(input=data, size=10)
fluid.layers.assign(hidden, out)
.. _cn_api_fluid_layers_cast:
cast
-------------------------------
.. py:function:: paddle.fluid.layers.cast(x,dtype)
该层传入变量x, 并用x.dtype将x转换成dtype类型，作为输出。如果输出的dtype和输入的dtype相同，则使用cast是没有意义的，但如果真的这么做了也不会报错。
参数：
- **x** (Variable)-转换函数的输入变量
- **dtype** (np.dtype|core.VarDesc.VarType|str)-输出变量的数据类型
返回：转换后的输出变量
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
data = fluid.layers.data(name='x', shape=[13], dtype='float32')
result = fluid.layers.cast(x=data, dtype='float64')
.. _cn_api_fluid_layers_concat:
concat
-------------------------------
.. py:function:: paddle.fluid.layers.concat(input,axis=0,name=None)
**Concat**
这个函数将输入连接在前面提到的轴上，并将其作为输出返回。
参数：
- **input** (list)-将要联结的张量列表
- **axis** (int)-数据类型为整型的轴，其上的张量将被联结
- **name** (str|None)-该层名称（可选）。如果设为空，则自动为该层命名。
返回：输出的联结变量
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
a = fluid.layers.data(name='a', shape=[2, 13], dtype='float32')
b = fluid.layers.data(name='b', shape=[2, 3], dtype='float32')
c = fluid.layers.data(name='c', shape=[2, 2], dtype='float32')
d = fluid.layers.data(name='d', shape=[2, 5], dtype='float32')
out = fluid.layers.concat(input=[Efirst, Esecond, Ethird, Efourth])
.. _cn_api_fluid_layers_create_global_var:
create_global_var
-------------------------------
.. py:function:: paddle.fluid.layers.create_global_var(shape,value,dtype,persistable=False,force_cpu=False,name=None)
在全局块中创建一个新的带有 ``value`` 的张量。
参数：
- **shape** (list[int])-变量的维度
- **value** (float)-变量的值。填充新创建的变量
- **dtype** (string)-变量的数据类型
- **persistable** (bool)-如果是永久变量。默认：False
- **force_cpu** (bool)-将该变量压入CPU。默认：False
- **name** (str|None)-变量名。如果设为空，则自动创建变量名。默认：None.
返回：创建的变量
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
import paddle.fluid.layers as layers
var = layers.create_global_var(shape=[2,3], value=1.0, dtype='float32',
persistable=True, force_cpu=True, name='new_var')
.. _cn_api_fluid_layers_create_parameter:
create_parameter
-------------------------------
.. py:function:: paddle.fluid.layers.create_parameter(shape,dtype,name=None,attr=None,is_bias=False,default_initializer=None)
创建一个参数。该参数是一个可学习的变量，拥有梯度并且可优化。
注：这是一个低级别的API。如果您希望自己创建新的op，这个API将非常有用，无需使用layers。
参数：
- **shape** (list[int])-参数的维度
- **dtype** (string)-参数的元素类型
- **attr** (ParamAttr)-参数的属性
- **is_bias** (bool)-当default_initializer为空，该值会对选择哪个默认初始化程序产生影响。如果is_bias为真，则使用initializer.Constant(0.0)，否则使用Xavier()。
- **default_initializer** (Initializer)-参数的初始化程序
返回：创建的参数
**代码示例**：
.. code-block:: python
import paddle.fluid.layers as layers
W = fluid.layers.create_parameter(shape=[784, 200], dtype='float32')
.. _cn_api_fluid_layers_create_tensor:
create_tensor
-------------------------------
.. py:function:: paddle.fluid.layers.create_tensor(dtype,name=None,persistable=False)
创建一个变量，存储数据类型为dtype的LoDTensor。
参数：
- **dtype** (string)-“float32”|“int32”|..., 创建张量的数据类型。
- **name** (string)-创建张量的名称。如果未设置，则随机取一个唯一的名称。
- **persistable** (bool)-是否将创建的张量设置为 persistable
返回：一个张量，存储着创建的张量
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
tensor = fluid.layers.create_tensor(dtype='float32')
.. _cn_api_fluid_layers_diag:
diag
-------------------------------
.. py:function:: paddle.fluid.layers.diag(diagonal)
该功能创建一个方阵，含有diagonal指定的对角线值。
参数：
- **diagonal** (Variable|numpy.ndarray) - 指定对角线值的输入张量，其秩应为1。
返回：存储着方阵的张量变量
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
# [3, 0, 0]
# [0, 4, 0]
# [0, 0, 5]
data = fluid.layers.diag(np.arange(3, 6))
.. _cn_api_fluid_layers_fill_constant:
fill_constant
-------------------------------
.. py:function:: paddle.fluid.layers.fill_constant(shape,dtype,value,force_cpu=False,out=None)
该功能创建一个张量，含有具体的shape,dtype和batch尺寸。并用 ``value`` 中提供的常量初始化该张量。
创建张量的属性stop_gradient设为True。
参数：
- **shape** (tuple|list|None)-输出张量的形状
- **dtype** (np.dtype|core.VarDesc.VarType|str)-输出张量的数据类型
- **value** (float)-用于初始化输出张量的常量值
- **out** (Variable)-输出张量
- **force_cpu** (True|False)-若设为true,数据必须在CPU上
返回：存储着输出的张量
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.fill_constant(shape=[1], value=0, dtype='int64')
.. _cn_api_fluid_layers_fill_constant_batch_size_like:
fill_constant_batch_size_like
-------------------------------
.. py:function:: paddle.fluid.layers.fill_constant_batch_size_like(input,shape,dtype,value,input_dim_idx=0,output_dim_idx=0)
该功能创建一个张量，含有具体的shape,dtype和batch尺寸。并用 ``Value`` 中提供的常量初始化该张量。该批尺寸从输入张量中获取。它还将stop_gradient设置为True.
参数：
- **input** (Variable)-张量，其第input_dim_idx维可指定batch_size
- **shape** (INTS)-输出的形状
- **dtype** (INT)-可以为numpy.dtype。输出数据类型。默认为float32
- **value** (FLOAT)-默认为0.将要被填充的值
- **input_dim_idx** (INT)-默认为0.输入批尺寸维的索引
- **output_dim_idx** (INT)-默认为0.输出批尺寸维的索引
返回：具有特定形状和值的张量
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
like = fluid.layers.data(name='like', shape=[1], dtype='float32')
data = fluid.layers.fill_constant_batch_size_like(
input=like, shape=[1], value=0, dtype='int64')
.. _cn_api_fluid_layers_has_inf:
has_inf
-------------------------------
.. py:function:: paddle.fluid.layers.has_inf(x)
测试x是否包括一个无穷数
参数：
- **x(variable)** - 用于被检查的Tensor/LoDTensor
返回： tensor变量存储输出值，包含一个bool型数值
返回类型：Variable
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.data(name="input", shape=[4, 32, 32], dtype="float32")
res = fluid.layers.has_inf(data)
.. _cn_api_fluid_layers_has_nan:
has_nan
-------------------------------
.. py:function:: paddle.fluid.layers.has_nan(x)
测试x是否包含NAN
参数：
- **x(variable)** - 用于被检查的Tensor/LoDTensor
返回： tensor变量存储输出值，包含一个bool型数值
返回类型：Variable
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.data(name="input", shape=[4, 32, 32], dtype="float32")
res = fluid.layers.has_nan(data)
.. _cn_api_fluid_layers_isfinite:
isfinite
-------------------------------
.. py:function:: paddle.fluid.layers.isfinite(x)
测试x是否包含无穷大/NAN值，如果所有元素都是有穷数，返回Ture,否则返回False
参数：
- **x(variable)** - 用于被检查的Tensor/LoDTensor
返回: Variable: tensor变量存储输出值，包含一个bool型数值
返回类型：Variable
**代码示例**：
.. code-block:: python
var = fluid.layers.data(name="data",
shape=(4, 6),
dtype="float32")
out = fluid.layers.isfinite(v)
.. _cn_api_fluid_layers_linspace:
linspace
-------------------------------
.. py:function:: paddle.fluid.layers.linspace(start, stop, num, dtype)
在给定区间内返回固定数目的均匀间隔的值。
第一个entry是start，最后一个entry是stop。在Num为1的情况下，仅返回start。类似numpy的linspace功能。
参数：
- **start** (float|Variable)-序列中的第一个entry。 它是一个浮点标量，或是一个数据类型为'float32'|'float64'、形状为[1]的张量。
- **stop** (float|Variable)-序列中的最后一个entry。 它是一个浮点标量，或是一个数据类型为'float32'|'float64'、形状为[1]的张量。
- **num** (int|Variable)-序列中的entry数。 它是一个整型标量，或是一个数据类型为int32、形状为[1]的张量。
- **dtype** (string)-‘float32’|’float64’，输出张量的数据类型。
返回：存储一维张量的张量变量
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
data = fluid.layers.linspace(0, 10, 5, 'float32') # [0.0, 2.5, 5.0, 7.5, 10.0]
data = fluid.layers.linspace(0, 10, 1, 'float32') # [0.0]
.. _cn_api_fluid_layers_ones:
ones
-------------------------------
.. py:function:: paddle.fluid.layers.ones(shape,dtype,force_cpu=False)
**ones**
该功能创建一个张量，有具体的维度和dtype，初始值为1。
也将stop_gradient设置为True。
参数：
- **shape** (tuple|list)-输出张量的维
- **dtype** (np.dtype|core.VarDesc.VarType|str)-输出张量的数据类型
返回：存储在输出中的张量
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.ones(shape=[1], dtype='int64')
.. _cn_api_fluid_layers_range:
range
-------------------------------
.. py:function:: paddle.fluid.layers.range(start, end, step, dtype)
均匀分隔给定数值区间，并返回该分隔结果。
返回值在半开区间[start，stop)内生成（即包括起点start但不包括终点stop的区间）。
参数：
- **start** （int | float | Variable） - 区间起点，且区间包括此值。
- **end** （int | float | Variable） - 区间终点，通常区间不包括此值。但当step不是整数，且浮点数取整会影响out的长度时例外。
- **step** （int | float | Variable） - 返回结果中数值之间的间距（步长）。 对于任何输出变量out，step是两个相邻值之间的距离，即out [i + 1] - out [i]。 默认为1。
- **dtype** （string） - 'float32'|'int32'| ...，输出张量的数据类型。
返回：均匀分割给定数值区间后得到的值组
**代码示例**：
.. code-block:: python
data = fluid.layers.range(0, 10, 2, 'int32')
.. _cn_api_fluid_layers_reverse:
reverse
-------------------------------
.. py:function:: paddle.fluid.layers.reverse(x,axis)
**reverse**
该功能将给定轴上的输入‘x’逆序
参数：
- **x** (Variable)-预逆序的输入
- **axis** (int|tuple|list) - 元素逆序排列的轴。如果该参数是一个元组或列表，则对该参数中每个元素值所指定的轴上进行逆序运算。
返回：逆序的张量
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.data(name="data", shape=[4, 8], dtype="float32")
out = fluid.layers.reverse(x=data, axis=0)
# or:
out = fluid.layers.reverse(x=data, axis=[0,1])
.. _cn_api_fluid_layers_sums:
sums
-------------------------------
.. py:function:: paddle.fluid.layers.sums(input,out=None)
该函数对输入进行求和，并返回求和结果作为输出。
参数：
- **input** (Variable|list)-输入张量，有需要求和的元素
- **out** (Variable|None)-输出参数。求和结果。默认：None
返回：输入的求和。和参数'out'等同
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
# sum of several tensors
a0 = fluid.layers.fill_constant(shape=[1], dtype='int64', value=1)
a1 = fluid.layers.fill_constant(shape=[1], dtype='int64', value=2)
a2 = fluid.layers.fill_constant(shape=[1], dtype='int64', value=3)
sums = fluid.layers.sums(input=[a0, a1, a2])
# sum of a tensor array
array = fluid.layers.create_array('int64')
i = fluid.layers.zeros(shape=[1], dtype='int64', force_cpu=True)
fluid.layers.array_write(a0, array=array, i=i)
i = fluid.layers.increment(x=i)
fluid.layers.array_write(a1, array=array, i=i)
i = fluid.layers.increment(x=i)
fluid.layers.array_write(a2, array=array, i=i)
sums = fluid.layers.sums(input=array)
.. _cn_api_fluid_layers_tensor_array_to_tensor:
tensor_array_to_tensor
-------------------------------
.. py:function:: paddle.fluid.layers.tensor_array_to_tensor(input, axis=1, name=None)
此函数在指定轴上连接LodTensorArray中的元素，并将其作为输出返回。
简单示例如下：
.. code-block:: text
Given:
input.data = {[[0.6, 0.1, 0.3],
[0.5, 0.3, 0.2]],
[[1.3],
[1.8]],
[[2.3, 2.1],
[2.5, 2.4]]}
axis = 1
Then:
output.data = [[0.6, 0.1, 0.3, 1.3, 2.3, 2.1],
[0.5, 0.3, 0.2, 1.8, 2.5, 2.4]]
output_index.data = [3, 1, 2]
参数：
- **input** (list) - 输入的LodTensorArray
- **axis** (int) - 整数轴，tensor将会和它连接在一起
- **name** (str|None) - 该layer的名字，可选。如果设置为none，layer将会被自动命名
返回：
Variable: 连接的输出变量,输入LodTensorArray沿指定axis连接。
返回类型： Variable
**代码示例：**
.. code-block:: python
import paddle.fluid as fluid
tensor_array = fluid.layers.create_parameter(shape=[784, 200], dtype='float32')
output, output_index = fluid.layers.tensor_array_to_tensor(input=tensor_array)
.. _cn_api_fluid_layers_zeros:
zeros
-------------------------------
.. py:function:: paddle.fluid.layers.zeros(shape,dtype,force_cpu=False)
**zeros**
该函数创建一个张量，含有具体的维度和dtype，初始值为0.
也将stop_gradient设置为True。
参数：
- **shape** (tuple|list|None)-输出张量的维
- **dtype** (np.dtype|core.VarDesc.VarType|str)-输出张量的数据类型
- **force_cpu** (bool,default False)-是否将输出保留在CPU上
返回：存储在输出中的张量
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.zeros(shape=[1], dtype='int64')
.. _cn_api_fluid_layers_zeros_like:
zeros_like
-------------------------------
.. py:function:: paddle.fluid.layers.zeros_like(x, out=None)
**zeros_like**
该函数创建一个和x具有相同的形状和数据类型的全零张量
参数：
- **x** (Variable)-指定形状和数据类型的输入张量
- **out** (Variable)-输出张量
返回：存储输出的张量变量
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
x = fluid.layers.data(name='x', dtype='float32', shape=[3], append_batch_size=False)
data = fluid.layers.zeros_like(x) # [0.0, 0.0, 0.0]
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或