tensor¶

argmax¶

`paddle.fluid.layers.``argmax`(x, axis=0)[源代码]

argmax

• x (Variable)-用于计算最大元素索引的输入
• axis (int)-用于计算索引的轴

```import paddle.fluid as fluid
x = fluid.layers.data(name="x", shape=[3, 4], dtype="float32")
out = fluid.layers.argmax(x, axis=0)
out = fluid.layers.argmax(x, axis=-1)
```

argmin¶

`paddle.fluid.layers.``argmin`(x, axis=0)[源代码]

argmin

• x (Variable)-计算最小元素索引的输入
• axis (int)-计算索引的轴

```import paddle.fluid as fluid
x = fluid.layers.data(name="x", shape=[3, 4], dtype="float32")
out = fluid.layers.argmin(x, axis=0)
out = fluid.layers.argmin(x, axis=-1)
```

argsort¶

`paddle.fluid.layers.``argsort`(input, axis=-1, name=None)[源代码]

```  例如：

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]],

indices = [[0, 1, 2],
[0, 2, 1]]
```

• input (Variable)-用于排序的输入变量
• axis (int)- 沿该参数指定的轴对输入进行排序。当axis<0,实际的轴为axis+rank(input)。默认为-1，即最后一维。
• name (str|None)-（可选）该层名称。如果设为空，则自动为该层命名。

```import paddle.fluid as fluid
x = fluid.layers.data(name="x", shape=[3, 4], dtype="float32")
out, indices = fluid.layers.argsort(input=x, axis=0)
```

assign¶

`paddle.fluid.layers.``assign`(input, output=None)[源代码]

• input (Variable|numpy.ndarray)-源变量
• output (Variable|None)-目标变量

```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)
```

cast¶

`paddle.fluid.layers.``cast`(x, dtype)[源代码]

• x (Variable)-转换函数的输入变量
• dtype (np.dtype|core.VarDesc.VarType|str)-输出变量的数据类型

```import paddle.fluid as fluid
data = fluid.layers.data(name='x', shape=[13], dtype='float32')
result = fluid.layers.cast(x=data, dtype='float64')
```

concat¶

`paddle.fluid.layers.``concat`(input, axis=0, name=None)[源代码]

Concat

• input (list)-将要联结的张量列表
• axis (int)-数据类型为整型的轴，其上的张量将被联结
• name (str|None)-该层名称（可选）。如果设为空，则自动为该层命名。

```import paddle.fluid as fluid
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=[a, b, c, d], axis=2)
```

create_global_var¶

`paddle.fluid.layers.``create_global_var`(shape, value, dtype, persistable=False, force_cpu=False, name=None)[源代码]

• shape (list[int])-变量的维度
• value (float)-变量的值。填充新创建的变量
• dtype (string)-变量的数据类型
• persistable (bool)-如果是永久变量。默认：False
• force_cpu (bool)-将该变量压入CPU。默认：False
• name (str|None)-变量名。如果设为空，则自动创建变量名。默认：None.

```import paddle.fluid as fluid
var = layers.create_global_var(shape=[2,3], value=1.0, dtype='float32',
persistable=True, force_cpu=True, name='new_var')
```

create_parameter¶

`paddle.fluid.layers.``create_parameter`(shape, dtype, name=None, attr=None, is_bias=False, default_initializer=None)[源代码]

• shape (list[int])-参数的维度
• dtype (string)-参数的元素类型
• attr (ParamAttr)-参数的属性
• is_bias (bool)-当default_initializer为空，该值会对选择哪个默认初始化程序产生影响。如果is_bias为真，则使用initializer.Constant(0.0)，否则使用Xavier()。
• default_initializer (Initializer)-参数的初始化程序

```import paddle.fluid as fluid
W = layers.create_parameter(shape=[784, 200], dtype='float32')
```

create_tensor¶

`paddle.fluid.layers.``create_tensor`(dtype, name=None, persistable=False)[源代码]

• dtype (string)-“float32”|“int32”|..., 创建张量的数据类型。
• name (string)-创建张量的名称。如果未设置，则随机取一个唯一的名称。
• persistable (bool)-是否将创建的张量设置为 persistable

```import paddle.fluid as fluid
tensor = fluid.layers.create_tensor(dtype='float32')
```

diag¶

`paddle.fluid.layers.``diag`(diagonal)[源代码]

• diagonal (Variable|numpy.ndarray) - 指定对角线值的输入张量，其秩应为1。

```#  [3, 0, 0]
#  [0, 4, 0]
#  [0, 0, 5]
data = fluid.layers.diag(np.arange(3, 6))
```

fill_constant¶

`paddle.fluid.layers.``fill_constant`(shape, dtype, value, force_cpu=False, out=None)[源代码]

• shape (tuple|list|None)-输出张量的形状
• dtype (np.dtype|core.VarDesc.VarType|str)-输出张量的数据类型
• value (float)-用于初始化输出张量的常量值
• out (Variable)-输出张量
• force_cpu (True|False)-若设为true,数据必须在CPU上

```import paddle.fluid as fluid
data = fluid.layers.fill_constant(shape=[1], value=0, dtype='int64')
```

fill_constant_batch_size_like¶

`paddle.fluid.layers.``fill_constant_batch_size_like`(input, shape, dtype, value, input_dim_idx=0, output_dim_idx=0)[源代码]

• 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.输出批尺寸维的索引

```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')
```

has_inf¶

`paddle.fluid.layers.``has_inf`(x)[源代码]

• x(variable) - 用于被检查的Tensor/LoDTensor

```import paddle.fluid as fluid
data = fluid.layers.data(name="input", shape=[4, 32, 32], dtype="float32")
res = fluid.layers.has_inf(data)
```

has_nan¶

`paddle.fluid.layers.``has_nan`(x)[源代码]

• x(variable) - 用于被检查的Tensor/LoDTensor

```import paddle.fluid as fluid
data = fluid.layers.data(name="input", shape=[4, 32, 32], dtype="float32")
res = fluid.layers.has_nan(data)
```

isfinite¶

`paddle.fluid.layers.``isfinite`(x)[源代码]

• x(variable) - 用于被检查的Tensor/LoDTensor

```import paddle.fluid as fluid
var = fluid.layers.data(name="data",
shape=(4, 6),
dtype="float32")
out = fluid.layers.isfinite(v)
```

linspace¶

`paddle.fluid.layers.``linspace`(start, stop, num, dtype)[源代码]

• start (float|Variable)-序列中的第一个entry。 它是一个浮点标量，或是一个数据类型为'float32'|'float64'、形状为[1]的张量。
• stop (float|Variable)-序列中的最后一个entry。 它是一个浮点标量，或是一个数据类型为'float32'|'float64'、形状为[1]的张量。
• num (int|Variable)-序列中的entry数。 它是一个整型标量，或是一个数据类型为int32、形状为[1]的张量。
• dtype (string)-‘float32’|’float64’，输出张量的数据类型。

```import paddle.fluid as fluid
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]
```

ones¶

`paddle.fluid.layers.``ones`(shape, dtype, force_cpu=False)[源代码]

ones

• shape (tuple|list)-输出张量的维
• dtype (np.dtype|core.VarDesc.VarType|str)-输出张量的数据类型

```import paddle.fluid as fluid
data = fluid.layers.ones(shape=[1], dtype='int64')
```

range¶

`paddle.fluid.layers.``range`(start, end, step, dtype)[源代码]

• 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'| ...，输出张量的数据类型。

```import paddle.fluid as fluid
data = fluid.layers.range(0, 10, 2, 'int32')
```

reverse¶

`paddle.fluid.layers.``reverse`(x, axis)[源代码]

reverse

• x (Variable)-预逆序的输入
• axis (int|tuple|list) - 元素逆序排列的轴。如果该参数是一个元组或列表，则对该参数中每个元素值所指定的轴上进行逆序运算。

```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])
```

sums¶

`paddle.fluid.layers.``sums`(input, out=None)[源代码]

• input (Variable|list)-输入张量，有需要求和的元素
• out (Variable|None)-输出参数。求和结果。默认：None

```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)
```

tensor_array_to_tensor¶

`paddle.fluid.layers.``tensor_array_to_tensor`(input, axis=1, name=None)[源代码]

```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连接。

```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)
```

zeros¶

`paddle.fluid.layers.``zeros`(shape, dtype, force_cpu=False)[源代码]

zeros

• shape (tuple|list|None)-输出张量的维
• dtype (np.dtype|core.VarDesc.VarType|str)-输出张量的数据类型
• force_cpu (bool,default False)-是否将输出保留在CPU上

```import paddle.fluid as fluid
data = fluid.layers.zeros(shape=[1], dtype='int64')
```

zeros_like¶

`paddle.fluid.layers.``zeros_like`(x, out=None)[源代码]

zeros_like

• x (Variable)-指定形状和数据类型的输入张量
• out (Variable)-输出张量

```import paddle.fluid as fluid
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]
```