tensor¶

argmax

This function computes the indices of the max elements of the input tensor’s element along the provided axis.

Parameters

• x (Variable) – The input to compute the indices of the max elements.

• axis (int) – Axis to compute indices along.

Returns

The tensor variable storing the output

Return type

Variable

Examples

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

This function computes the indices of the min elements of the input tensor’s element along the provided axis.

Parameters

• x (Variable) – The input to compute the indices of the min elements.

• axis (int) – Axis to compute indices along.

Returns

The tensor variable storing the output

Return type

Variable

Examples

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)

Performs sorting on the input Variable along the given axis, and outputs sorted data Varibale and its corresponding index Variable with the same shape as input.

For example, the given axis is -1 and the input Variable

    input = [[0.15849551, 0.45865775, 0.8563702 ],
             [0.12070083, 0.28766365, 0.18776911]],

after argsort, the sorted Vairable becomes

    out = [[0.15849551, 0.45865775, 0.8563702 ],
           [0.12070083, 0.18776911, 0.28766365]],

and the sorted indices along the given axis turn outs to be

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

Parameters

• input (Variable) – The input Variable for sorting.

• axis (int) – The axis along which to sort the input Variable. When axis < 0, the actual axis will be axis + rank(input). Default -1, the last dimension.

• name (str|None) – (optional) A name for this layer. If set None, the layer will be named automatically.

Returns

A tuple of sorted data Variable and the sorted indices.

Return type

tuple

Examples

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

This function copies the input Variable to the output Variable.

Parameters

• input (Variable|numpy.ndarray) – The source variable

• output (Variable|None) – The destination variable

Returns

The destination variable that was supplied as the output.

Return type

Variable

Examples

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)

This layer takes in the Variable x with x.dtype and casts it to the output with dtype. It’s meaningless if the output dtype equals the input dtype, but it’s fine if you do so.

Parameters

• x (Variable) – The input Variable for casting.

• dtype (np.dtype|core.VarDesc.VarType|str) – Data type of the output Variable.

Returns

The output Variable after casting.

Return type

Variable

Examples

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

Concat

This function concatenates the input along the axis mentioned and returns that as the output.

Parameters

• input (list) – List of tensors to be concatenated

• axis (int) – Integer axis along which the tensors will be concatenated

• name (str|None) – A name for this layer(optional). If set None, the layer will be named automatically.

Returns

Output variable of the concatenation

Return type

Variable

Examples

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 a new tensor variable with value in the global block(block 0).

Parameters

• shape (list[int]) – shape of the variable

• value (float) – the value of the variable. The new created variable will be filled with it.

• dtype (string) – data type of the variable

• persistable (bool) – if this variable is persistable. Default: False

• force_cpu (bool) – force this variable to be on CPU. Default: False

• name (str|None) – The name of the variable. If set to None the variable name will be generated automatically. Default: None

Returns

the created Variable

Return type

Variable

Examples

import paddle.fluid as fluid
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')

Create a parameter. The parameter is a learnable variable, which can have gradient, and can be optimized.

NOTE: this is a very low-level API. This API is useful when you create operator by your self. instead of using layers.

Parameters

• shape (list[int]) – shape of the parameter

• dtype (string) – element type of the parameter

• attr (ParamAttr) – attributes of the parameter

• is_bias (bool) – This can affect which default initializer is chosen when default_initializer is None. If is_bias, initializer.Constant(0.0) will be used. Otherwise, Xavier() will be used.

• default_initializer (Initializer) – initializer for the parameter

Returns

the created parameter.

Examples

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

Create an variable, which will hold a LoDTensor with data type dtype.

Parameters

• dtype (string) – ‘float32’|’int32’|…, the data type of the created tensor.

• name (string) – The name of the created tensor, if not set, the name will be a random unique one.

• persistable (bool) – Set the persistable flag of the create tensor.

Returns

The tensor variable storing the created tensor.

Return type

Variable

Examples

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

diag

This function creates a square matrix which has diagonal values specified by diagonal.

Parameters

diagonal (Variable|numpy.ndarray) – The input tensor specifying diagonal values, should be of rank 1.

Returns

The tensor variable storing the square matrix.

Return type

Variable

Examples

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

fill_constant

This function creates a tensor with specified shape and dtype, and initializes it with a constant specifed by value.

The attribute stop_gradient of the created tensor is set to True.

Parameters

• shape (tuple|list|None) – Shape of the output tensor.

• dtype (np.dtype|core.VarDesc.VarType|str) – Data type of the output tensor.

• value (float) – The constant value used to initialize the output tensor.

• out (Variable) – The output tensor.

• force_cpu (True|False) – data should be on CPU if set true.

Returns

The tensor variable storing the output.

Return type

Variable

Examples

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

This function creates a tensor of specified shape, dtype and batch size, and initializes this with a constant supplied in value. The batch size is obtained from the input tensor.

It also sets stop_gradient to True.

Parameters

• input (Variable) – Tensor whose input_dim_idx’th dimension specifies the batch_size.

• shape (INTS) – The shape of the output.

• dtype (INT) – It could be numpy.dtype. Output data type. Default is float32.

• value (FLOAT) – default 0. The value to be filled.

• input_dim_idx (INT) – default 0. The index of input’s batch size dimension.

• output_dim_idx (INT) – default 0. The index of output’s batch size dimension.

Returns

Tensor of specified shape will be filled with the specified value.

Examples

import paddle.fluid as fluid
like = fluid.layers.data(name='like', shape=[1], dtype='float32')
data = fluid.lgyers.fill_constant_batch_size_like(
            input=like, shape=[1], value=0, dtype='int64')

Test if any of x contains an infinity number

Parameters

x (variable) – The Tensor/LoDTensor to be checked.

Returns

The tensor variable storing the output, only a bool value.

Return type

Variable

Examples

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

Test if any of x contains a NAN

Parameters

x (variable) – The Tensor/LoDTensor to be checked.

Returns

The tensor variable storing the output, only a bool value.

Return type

Variable

Examples

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

Test if any of x contains an infinity/NAN number. If all the elements are finite, returns true, else false.

Parameters

x (variable) – The Tensor/LoDTensor to be checked.

Returns

The tensor variable storing the output, contains a bool value.

Return type

Variable

Examples

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

Return fixed number of evenly spaced values within a given interval.

First entry is start, and last entry is stop. In the case when Num is 1, only Start is returned. Like linspace function of numpy.

Parameters

• start (float|Variable) – First entry in the sequence. It is a float scalar, or a tensor of shape [1] with type ‘float32’|’float64’.

• stop (float|Variable) – Last entry in the sequence. It is a float scalar, or a tensor of shape [1] with type ‘float32’|’float64’.

• num (int|Variable) – Number of entry in the sequence. It is an int scalar, or a tensor of shape [1] with type int32.

• dtype (string) – ‘float32’|’float64’, the data type of the output tensor.

Returns

The tensor variable storing a 1-D tensor.

Return type

Variable

Examples

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

This function creates a tensor of specified shape and dtype, and initializes this with 1.

It also sets stop_gradient to True.

Parameters

• shape (tuple|list) – Shape of output tensor

• dtype (np.dtype|core.VarDesc.VarType|str) – Data type of output tensor

Returns

The tensor variable storing the output

Return type

Variable

Examples

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

Return evenly spaced values within a given interval.

Values are generated within the half-open interval [start, stop) (in other words, the interval including start but excluding stop).

Parameters

• start (int|float|Variable) – Start of interval. The interval includes this value.

• end (int|float|Variable) – End of interval. The interval does not include this value, except in some cases where step is not an integer and floating point round-off affects the length of out.

• step (int|float|Variable) – Spacing between values. For any output out, this is the distance between two adjacent values, out[i+1] - out[i]. The default step size is 1.

• dtype (string) – ‘float32’|’int32’|…, the data type of the output tensor.

Returns

Evenly spaced values within a given interval.

Examples

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

reverse

This function reverse the input ‘x’ along given axises.

Parameters

• x (Vairbale) – the input to be reversed.

• axis (int|tuple|list) – Axis that along which order of elements is reversed. If it is a tuple or a list, reversing will be apply on each axis in the tuple or list.

Returns

The reversed tensor.

Return type

Variable

Examples

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

This function performs the sum operation on the input and returns the result as the output.

Parameters

• input (Variable|list) – The input tensor that has the elements that need to be summed up.

• out (Variable|None) – Output parameter. The sum result. Default: None

Returns

the sum of input. The same as the argument ‘out’

Return type

Variable

Examples

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)

This function concatenates the input LodTensorArray along the axis mentioned and returns that as the output.

A simple example as below:

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]

Parameters

• input (list) – Input LodTensorArray

• axis (int) – Integer axis along which the tensors will be concatenated

• name (str|None) – A name for this layer(optional). If set None, the layer will be named automatically.

Returns

Output variable of the concatenation Variable: The input LodTensorArray items’ dims along the axis

Return type

Variable

Examples

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

This function creates a tensor of specified shape and dtype, and initializes this with 0.

It also sets stop_gradient to True.

Parameters

• shape (tuple|list|None) – Shape of output tensor.

• dtype (np.dtype|core.VarDesc.VarType|str) – Data type of output tensor.

• force_cpu (bool, default False) – Whether to make output stay on CPU.

Returns

The tensor variable storing the output.

Return type

Variable

Examples

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

zeros_like

This function creates a zeros tensor which has identical shape and dtype with x.

Parameters

• x (Variable) – The input tensor which specifies shape and dtype.

• out (Variable) – The output tensor.

Returns

The tensor variable storing the output.

Return type

Variable

Examples

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]