API - Operations¶

Deep learning and Reinforcement learning library for Researchers and Engineers

`get_tensor_shape`(x)	Get the shape of tensor
`zeros`(shape[, dtype, device])	Creates a tensor with all elements set to zero.
`zeros_like`(x[, dtype])	This OP returns a Tensor filled with the value 0, with the same shape and data type (use dtype if dtype is not None) as x.
`ones`(shape[, dtype, device])	Creates a tensor with all elements set to ones.
`ones_like`(x[, dtype])	This OP returns a Tensor filled with the value 1, with the same shape and data type (use dtype if dtype is not None) as x.
`constant`(value[, dtype, shape, device])	Creates a constant tensor from a tensor-like object.
`random_uniform`(shape[, minval, maxval, …])	Outputs random values from a uniform distribution.
`random_normal`(shape[, mean, stddev, dtype, seed])	Outputs random values from a normal distribution.
`truncated_normal`(shape[, mean, stddev, …])	Outputs random values from a truncated normal distribution.
`he_normal`(shape[, a, mode, nonlinearity, …])	He normal initializer.
`xavier_normal`(shape[, gain, dtype, seed])	Xavier normal.
`xavier_uniform`(shape[, gain, dtype, seed])	Xavier uniform.
`Variable`(initial_value, name[, trainable, …])	Creates a new variable with value initial_value.
`abs`(x)	Computes the absolute value of a tensor.
`acos`(x)	Computes acos of x element-wise.
`acosh`(x)	Computes inverse hyperbolic cosine of x element-wise.
`add`(value, bias)	Returns x + y element-wise.
`angle`(x)	Returns the element-wise argument of a complex (or real) tensor.
`argmax`(x[, axis, keepdim, dtype])	Returns the index with the largest value across axes of a tensor.
`argmin`(x[, axis, dtype])	Returns the index with the smallest value across axes of a tensor.
`asin`(x)	Returns the index with the smallest value across axes of a tensor.
`asinh`(x)	Computes inverse hyperbolic sine of x element-wise.
`atan`(x)	Computes the trignometric inverse tangent of x element-wise.
`atanh`(x)	Computes inverse hyperbolic tangent of x element-wise.
`arange`(start[, limit, delta, dtype])	Creates a sequence of numbers.
`ceil`	Return the ceiling of x as an Integral.
`cos`(x)	Computes cos of x element-wise.
`cosh`(x)	Computes hyperbolic cosine of x element-wise.
`count_nonzero`(x[, axis, keepdims, dtype])	Computes number of nonzero elements across dimensions of a tensor.
`cumprod`(x[, axis, exclusive, reverse])	Compute the cumulative product of the tensor x along axis.
`cumsum`(x[, axis, exclusive, reverse])	Compute the cumulative sum of the tensor x along axis.
`divide`(x, y)	Computes Python style division of x by y.
`equal`(x, y)	Returns the truth value of (x == y) element-wise.
`exp`(x)	Computes exponential of x element-wise.
`floor`	Return the floor of x as an Integral.
`floordiv`(x, y)	Divides x / y elementwise, rounding toward the most negative integer.
`floormod`(x, y)	Returns element-wise remainder of division.
`greater`(x, y)	Returns the truth value of (x >= y) element-wise.
`greater_equal`(x, y)	Returns the truth value of (x >= y) element-wise.
`is_inf`(x)	Returns which elements of x are Inf.
`is_nan`(x)	Returns which elements of x are NaN.
`l2_normalize`(x[, axis, eps])	Normalizes along dimension axis using an L2 norm.
`less`(x, y)	Returns the truth value of (x < y) element-wise.
`less_equal`(x, y)	Returns the truth value of (x <= y) element-wise.
`log`(x)	Computes natural logarithm of x element-wise.
`log_sigmoid`(x)	Computes log sigmoid of x element-wise.
`maximum`(x, y)	Returns the max of x and y (i.e.
`minimum`(x, y)	Returns the min of x and y (i.e.
`multiply`(x, y)	Returns an element-wise x * y.
`negative`(x)	Computes numerical negative value element-wise.
`not_equal`(x, y)	Returns the truth value of (x != y) element-wise.
`pow`(x, y)	Computes the power of one value to another.
`real`(x)	Computes numerical negative value element-wise.
`reciprocal`(x)	Computes the reciprocal of x element-wise.
`reshape`(tensor, shape)	Reshapes a tensor.
`concat`(values, axis)	Concatenates tensors along one dimension.
`convert_to_tensor`(value[, dtype, device])	Converts the given value to a Tensor.
`convert_to_numpy`(value)	Converts the given Tensor to a numpy.
`reduce_max`(x[, axis, keepdims])	Computes the maximum of elements across dimensions of a tensor.
`reduce_mean`(input_tensor[, axis, keepdims])	Computes the mean of elements across dimensions of a tensor.
`reduce_min`(x[, axis, keepdims])	Computes the minimum of elements across dimensions of a tensor.
`reduce_prod`(x[, axis, keepdims])	Computes the multiply of elements across dimensions of a tensor.
`reduce_std`(x[, axis, keepdims])	Computes the standard deviation of elements across dimensions of a tensor.
`reduce_sum`(x[, axis, keepdims])	Computes the standard deviation of elements across dimensions of a tensor.
`reduce_variance`(x[, axis, keepdims])	Computes the variance of elements across dimensions of a tensor.
`round`(x)	Rounds the values of a tensor to the nearest integer, element-wise.
`rsqrt`(x)	Computes reciprocal of square root of x element-wise.
`segment_max`(x, segment_ids)	Computes the maximum along segments of a tensor.
`segment_mean`(x, segment_ids)	Computes the mean along segments of a tensor.
`segment_min`(x, segment_ids)	Computes the minimum along segments of a tensor.
`segment_prod`(x, segment_ids)	Computes the product along segments of a tensor.
`segment_sum`(x, segment_ids)	Computes the sum along segments of a tensor.
`sigmoid`(x)	Computes sigmoid of x element-wise.
`sign`(x)	Computes sign of a tensor element-wise.
`sin`(x)	Computes sine of a tensor element-wise.
`sinh`(x)	Computes hyperbolic sine of a tensor element-wise.
`softplus`(x)	Computes softplus of a tensor element-wise.
`sqrt`(x)	Computes square root of a tensor element-wise.
`square`(x)	Computes square of a tensor element-wise.
`squared_difference`(x, y)	Computes difference and square between tensor x and tensor y.
`subtract`(x, y)	Returns x - y element-wise.
`tan`(x)	Computes tan of a tensor element-wise.
`tanh`(x)	Computes hyperbolic tangent of a tensor element-wise.
`any`(x[, axis, keepdims])	Computes logical_or of a tensor element-wise.
`all`(x[, axis, keepdims])	Computes logical_and of a tensor element-wise.
`logical_and`(x, y)	Returns the truth value of x AND y element-wise.
`logical_not`(x)	Returns the truth value of NOT x element-wise.
`logical_or`(x, y)	Returns the truth value of x OR y element-wise.
`logical_xor`(x, y)	Returns the truth value of NOT x element-wise.
`argsort`(x[, axis, descending])	Returns the indices of a tensor that give its sorted order along an axis.
`bmm`(x, y)	Applies batched matrix multiplication to two tensors.
`matmul`(a, b[, transpose_a, transpose_b])	Multiplies matrix a by matrix b, producing a * b.
`triu`(x[, diagonal])	This op returns the upper triangular part of a matrix (2-D tensor) or batch of matrices x, the other elements of the result tensor are set to 0.
`tril`(x[, diagonal])	This op returns the lower triangular part of a matrix (2-D tensor) or batch of matrices x, the other elements of the result tensor are set to 0.
`tile`(input, multiples)	Constructs a tensor by tiling a given tensor.
`where`(condition, x, y)	Return a tensor of elements selected from either x or y, depending on condition.
`stack`(values[, axis])	Stacks a list of rank-R tensors into one rank-(R+1) tensor.
`split`(value, num_or_size_splits[, axis])	Splits a tensor into sub tensors.
`squeeze`(x[, axis])	Removes dimensions of size 1 from the shape of a tensor.
`expand_dims`(input, axis)	Inserts a dimension of 1 into a tensor’s shape.
`gather`(params, indices[, axis])	Gather slices from params axis axis according to indices.
`unsorted_segment_sum`(x, segment_ids, …)	Computes the sum along segments of a tensor.
`unsorted_segment_mean`(x, segment_ids, …)	Computes the mean along segments of a tensor.
`unsorted_segment_min`(x, segment_ids, …)	Computes the min along segments of a tensor.
`unsorted_segment_max`(x, segment_ids, …)	Computes the max along segments of a tensor.
`set_seed`(seed)	param seed: The random seed to set.
`is_tensor`(x)	param x: A python object to check.
`tensor_scatter_nd_update`(tensor, indices, …)	param tensor: tensor to update.
`scatter_update`(tensor, indices, updates)	Applies sparse updates to a variable
`diag`(input[, diagonal])	param input: the input tensor.
`mask_select`(x, mask[, axis])	param x: N-D Tensor.
`eye`(n[, m, dtype])	param n: the number of rows
`einsum`(equation, *operands)	Sums the product of the elements of the input operands along dimensions specified using a notation based on the Einstein summation convention.
`set_device`([device, id])	This function can specify the global device which the OP will run.
`get_device`()	This function can get the specified global device.
`to_device`(tensor[, device, id])	Returns a copy of Tensor in specified device.
`roll`(input, shifts[, dims])	Roll the tensor input along the given dimension(s).
`logsoftmax`(input[, dim])	Applies a softmax followed by a logarithm.
`topk`(input, k[, dim, largest, sorted])	Returns the k largest elements of the given input tensor along a given dimension.
`numel`(input)	Returns the total number of elements in the input tensor.

TensorLayerX Tensor Operations¶

get_tensor_shape¶

tensorlayerx.get_tensor_shape(x)[source]¶

Get the shape of tensor

Parameters:: x (tensor) – type float16, float32, float64, int32, complex64, complex128.
Returns:
Return type:: list.

Examples

>>> import tensorlayerx as tlx
>>> x_in = tlx.layers.Input((32, 3, 3, 32))
>>> x_shape = tlx.ops.get_tensor_shape(x_in)

zeros¶

tensorlayerx.zeros(shape, dtype='float32', device=None)[source]¶

Creates a tensor with all elements set to zero.

Parameters:

shape (A list of integers) – a tuple of integers, or a 1-D Tensor of type int32.
dtype (tensor or str) – The DType of an element in the resulting Tensor
device (str or None) – create a tensor on ‘cpu’ or ‘gpu’, defautl is None.

Returns:

Return type:

A Tensor with all elements set to zero.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.zeros((32, 3, 3, 32), dtype=tlx.int32)
>>> y = tlx.ops.zeros((10, 25, 25, 10), dtype='float32')

ones¶

tensorlayerx.ones(shape, dtype='float32', device=None)[source]¶

Creates a tensor with all elements set to ones.

Parameters:

shape (A list of integers) – a tuple of integers, or a 1-D Tensor of type int32.
dtype (tensor or str) – The DType of an element in the resulting Tensor
device (str or None) – create a tensor on ‘cpu’ or ‘gpu’, defautl is None.

Returns:

Return type:

A Tensor with all elements set to zero.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.ones((32, 3, 3, 32), dtype=tlx.int32)
>>> y = tlx.ops.ones((10, 25, 25, 10), dtype='float32')

constant¶

tensorlayerx.constant(value, dtype='float32', shape=None, device=None)[source]¶

Creates a constant tensor from a tensor-like object.

Parameters:

value (list) – A constant value (or list) of output type dtype.
dtype (tensor or str) – The type of the elements of the resulting tensor.
shape (tuple) – Optional dimensions of resulting tensor.
device (str or None) – create a tensor on ‘cpu’ or ‘gpu’, defautl is None.

Returns:

Return type:

A Constant Tensor.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(0.5, (32, 3, 3, 32), dtype=tlx.int32)
>>> y = tlx.ops.constant(0.5, (10, 25, 25, 10), dtype='float32')

random_uniform¶

tensorlayerx.random_uniform(shape, minval=0, maxval=None, dtype='float32', seed=None)[source]¶

Outputs random values from a uniform distribution.

Parameters:

shape (tuple) – A 1-D integer Tensor or Python array. The shape of the output tensor.
minval (float) – The lower bound on the range of random values to generate (inclusive). Defaults to 0.
maxval (float) – The upper bound on the range of random values to generate (exclusive). Defaults to 1 if dtype is floating point.
dtype (tensor or str) – The type of the output: float16, float32, float64, int32, or int64.
seed (int) – Used in combination with tf.random.set_seed to create a reproducible sequence of tensors across multiple calls.

Returns:

Return type:

A tensor of the specified shape filled with random uniform values.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.random_uniform((32, 3, 3, 32), maxval=1.0, dtype=tlx.int32)
>>> y = tlx.ops.random_uniform((10, 25, 25, 10), maxval=1.0, dtype='float32')

random_normal¶

tensorlayerx.random_normal(shape, mean=0.0, stddev=1.0, dtype='float32', seed=None)[source]¶

Outputs random values from a normal distribution.

Parameters:

shape (tuple) – A 1-D integer Tensor or Python array. The shape of the output tensor.
mean (float) – The mean of the normal distribution
stddev (float) – The standard deviation of the normal distribution.
dtype (tensor or str) – The type of the output.
seed (A Python integer) – Used to create a random seed for the distribution

Returns:

Return type:

A tensor of the specified shape filled with random normal values.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.random_normal((32, 3, 3, 32), dtype=tlx.int32)
>>> y = tlx.ops.random_normal((10, 25, 25, 10), dtype='float32')

truncated_normal¶

tensorlayerx.truncated_normal(shape, mean=0.0, stddev=1.0, dtype='float32', seed=None)[source]¶

Outputs random values from a truncated normal distribution.

Parameters:

shape (tuple) – A 1-D integer Tensor or Python array. The shape of the output tensor.
mean (float) – The mean of the normal distribution
stddev (float) – The standard deviation of the normal distribution.
dtype (tensor or str) – The type of the output.
seed (A Python integer) – Used to create a random seed for the distribution

Returns:

Return type:

A tensor of the specified shape filled with random truncated normal values.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.truncated_normal((32, 3, 3, 32), dtype=tlx.int32)
>>> y = tlx.ops.truncated_normal((10, 25, 25, 10), dtype='float32')

he_normal¶

tensorlayerx.he_normal(shape, a=0, mode='fan_in', nonlinearity='leaky_relu', dtype='float32', seed=None)[source]¶

He normal initializer.

Parameters:

seed (A Python integer.) – Used to seed the random generator.
shape (tuple) – A 1-D integer Tensor or Python array. The shape of the output tensor.
dtype (tensor or str) – The type of the output.

Returns:

Return type:

A tensor of the specified shape filled with he normal values.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.he_normal((32, 3, 3, 32), dtype=tlx.int32)
>>> y = tlx.ops.he_normal((10, 25, 25, 10), dtype='float32')

xavier_normal¶

tensorlayerx.xavier_normal(shape, gain=1.0, dtype='float32', seed=None)[source]¶

Xavier normal.

Parameters:

seed (A Python integer.) – Used to seed the random generator.
shape (tuple) – A 1-D integer Tensor or Python array. The shape of the output tensor.
dtype (tensor or str) – The type of the output.

Returns:

Return type:

A tensor of the specified shape filled with xavier normal values.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.xavier_normal((32, 3, 3, 32), dtype=tlx.int32)
>>> y = tlx.ops.xavier_normal((10, 25, 25, 10), dtype='float32')

xavier_uniform¶

tensorlayerx.xavier_uniform(shape, gain=1.0, dtype='float32', seed=None)[source]¶

Xavier uniform.

Parameters:

seed (A Python integer.) – Used to seed the random generator.
shape (tuple) – A 1-D integer Tensor or Python array. The shape of the output tensor.
dtype (tensor or str) – The type of the output.

Returns:

Return type:

A tensor of the specified shape filled with xavier uniform values.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.xavier_uniform((32, 3, 3, 32), dtype=tlx.int32)
>>> y = tlx.ops.xavier_uniform((10, 25, 25, 10), dtype='float32')

Variable¶

tensorlayerx.Variable(initial_value, name, trainable=True, device=None)[source]¶

Creates a new variable with value initial_value.

Parameters:

initial_value (tensor) – A Tensor, or Python object convertible to a Tensor
name (str) – Optional name for the variable. Defaults to ‘Variable’ and gets uniquified automatically.
device (str or None) – create a tensor on ‘cpu’ or ‘gpu’, defautl is None.

Returns:

Return type:

Variable

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.Variable(tlx.ops.ones(shape=(10, 20)), name='w')

abs¶

tensorlayerx.abs(x)[source]¶

Computes the absolute value of a tensor.

Parameters:: x (tensor) – A Tensor or SparseTensor of type float16, float32, float64, int32, int64, complex64 or complex128.
Returns:
Return type:: A Tensor or SparseTensor of the same size, type and sparsity as x, with absolute values.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.layers.Input((32, 3, 3, 32))
>>> y = tlx.ops.abs(x)

acos¶

tensorlayerx.acos(x)[source]¶

Computes acos of x element-wise.

Parameters:: x (tensor) – Must be one of the following types: bfloat16, half, float32, float64, uint8, int8, int16, int32, int64, complex64, complex128, string.
Returns:
Return type:: A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.layers.Input((32, 3, 3, 32))
>>> y = tlx.ops.acos(x)

acosh¶

tensorlayerx.acosh(x)[source]¶

Computes inverse hyperbolic cosine of x element-wise.

Parameters:: x (tensor) – A Tensor. Must be one of the following types: bfloat16, half, float32, float64, complex64, complex128.
Returns:
Return type:: A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.layers.Input((32, 3, 3, 32))
>>> y = tlx.ops.acosh(x)

add¶

tensorlayerx.add(value, bias)[source]¶

Returns x + y element-wise.

Parameters:

value (tensor.) – Must be one of the following types: bfloat16, half, float32, float64, uint8, int8, int16, int32, int64, complex64, complex128, string.
bias (tensor) – Must have the same type as a

Returns:

Return type:

A Tensor. Has the same type as a.

Examples

>>> import tensorlayerx as tlx
>>> value = tlx.ones(shape=(10, 20))
>>> bias = tlx.ones(shape=(20))
>>> x = tlx.ops.add(value, bias)

angle¶

tensorlayerx.angle(x)[source]¶

Returns the element-wise argument of a complex (or real) tensor.

Parameters:: x (tensor) – A Tensor. Must be one of the following types: float, double, complex64, complex128.
Returns:
Return type:: A Tensor of type float32 or float64.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[2.15 + 3.57j, 3.89 + 6.54j])
>>> y = tlx.ops.angle(x)

argmax¶

tensorlayerx.argmax(x, axis=None, keepdim=False, dtype='int64')[source]¶

Returns the index with the largest value across axes of a tensor.

Parameters:

x (tensor) – A Tensor
axis (int) – An integer, the axis to reduce across. Default to 0.
dtype (tensor or str) – An optional output dtype (nt32 or int64). Defaults to int64.

Returns:

Return type:

A Tensor of type output_type.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[10, 20, 5, 6, 15])
>>> y = tlx.ops.argmax(x)

argmin¶

tensorlayerx.argmin(x, axis=None, dtype='int64')[source]¶

Returns the index with the smallest value across axes of a tensor.

Parameters:

x (tensor) – A Tensor
axis (int) – An integer, the axis to reduce across. Default to 0.
dtype (tensor or str) – An optional output dtype (nt32 or int64). Defaults to int64.

Returns:

Return type:

A Tensor of type output_type.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[10, 20, 5, 6, 15])
>>> y = tlx.ops.argmin(x)

asin¶

tensorlayerx.asin(x)[source]¶

Returns the index with the smallest value across axes of a tensor.

Parameters:: x (tensor) – Must be one of the following types: bfloat16, half, float32, float64, int8, int16, int32, int64, complex64, complex128.
Returns:
Return type:: A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[10, 20, 5, 6, 15])
>>> y = tlx.ops.asin(x)

asinh¶

tensorlayerx.asinh(x)[source]¶

Computes inverse hyperbolic sine of x element-wise.

Parameters:: x (tensor) – Must be one of the following types: bfloat16, half, float32, float64, complex64, complex128.
Returns:
Return type:: A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[0.9142202  0.72091234])
>>> y = tlx.ops.asinh(x)

atan¶

tensorlayerx.atan(x)[source]¶

Computes the trignometric inverse tangent of x element-wise.

Parameters:: x (tensor) – Must be one of the following types: bfloat16, half, float32, float64, int8, int16, int32, int64, complex64, complex128.
Returns:
Return type:: A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[0.9142202  0.72091234])
>>> y = tlx.ops.atan(x)

atanh¶

tensorlayerx.atanh(x)[source]¶

Computes inverse hyperbolic tangent of x element-wise.

Parameters:: x (tensor) – Must be one of the following types: bfloat16, half, float32, float64, complex64, complex128.
Returns:
Return type:: A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[0.9142202  0.72091234])
>>> y = tlx.ops.atanh(x)

arange¶

tensorlayerx.arange(start, limit=None, delta=1, dtype=None)[source]¶

Creates a sequence of numbers.

Parameters:

start (tensor) – A 0-D Tensor (scalar). Acts as first entry in the range if limit is not None; otherwise, acts as range limit and first entry defaults to 0.
limit (tensor) – A 0-D Tensor (scalar). Upper limit of sequence, exclusive. If None, defaults to the value of start while the first entry of the range defaults to 0.
delta (tensor) – A 0-D Tensor (scalar). Number that increments start. Defaults to 1.
dtype (type) – The type of the elements of the resulting tensor.

Returns:

Return type:

An 1-D Tensor of type dtype.

ceil¶

tensorlayerx.ceil()¶

Return the ceiling of x as an Integral.

This is the smallest integer >= x.

cos¶

tensorlayerx.cos(x)[source]¶

Computes cos of x element-wise.

Parameters:: x (tensor) – Must be one of the following types: bfloat16, half, float32, float64, complex64, complex128.
Returns:
Return type:: A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[0.9142202  0.72091234])
>>> y = tlx.ops.cos(x)

cosh¶

tensorlayerx.cosh(x)[source]¶

Computes hyperbolic cosine of x element-wise.

Parameters:: x (tensor) – Must be one of the following types: bfloat16, half, float32, float64, complex64, complex128.
Returns:
Return type:: A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[0.9142202  0.72091234])
>>> y = tlx.ops.cosh(x)

count_nonzero¶

tensorlayerx.count_nonzero(x, axis=None, keepdims=None, dtype='int64')[source]¶

Computes number of nonzero elements across dimensions of a tensor.

Parameters:

x (tensor) – The tensor to reduce. Should be of numeric type, bool, or string.
axis (int) – The dimensions to reduce. If None (the default), reduces all dimensions. Must be in the range [-rank(input), rank(input)).
keepdims (bool) – If true, retains reduced dimensions with length 1.
dtype (tensor or str) – The output dtype; defaults to tf.int64.

Returns:

Return type:

The reduced tensor (number of nonzero values)

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=["", "a", "c", "b", " "])
>>> y = tlx.ops.count_nonzero(x)

cumprod¶

tensorlayerx.cumprod(x, axis=0, exclusive=False, reverse=False)[source]¶

Compute the cumulative product of the tensor x along axis.

Parameters:

x (tensor) –

Must be one of the following types: float32, float64, int64, int32, uint8, uint16, int16, int8,
complex64, complex128, qint8, quint8, qint32, half.
axis (int) – A Tensor of type int32 (default: 0). Must be in the range [-rank(x), rank(x)).
exclusive (bool) – If True, perform exclusive cumprod.
reverse (bool) – A bool (default: False).

Returns:

Return type:

A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[3, 2, 1])
>>> y = tlx.ops.cumprod(x)
>>> y = tlx.ops.cumprod(x, exclusive=True, reverse=True)

cumsum¶

tensorlayerx.cumsum(x, axis=0, exclusive=False, reverse=False)[source]¶

Compute the cumulative sum of the tensor x along axis.

Parameters:

x (tensor) –

Must be one of the following types: float32, float64, int64, int32, uint8, uint16, int16, int8,
complex64, complex128, qint8, quint8, qint32, half.
axis (int) – A Tensor of type int32 (default: 0). Must be in the range [-rank(x), rank(x)).
exclusive (bool) – If True, perform exclusive cumprod.
reverse (bool) – A bool (default: False).

Returns:

Return type:

A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[1, 2, 3])
>>> y = tlx.ops.cumsum(x)
>>> y = tlx.ops.cumsum(x, exclusive=True, reverse=True)

divide¶

tensorlayerx.divide(x, y)[source]¶

Computes Python style division of x by y.

Parameters:

x (tensor) – A Tensor
y (tensor) – A Tensor

Returns:

Return type:

A Tensor with same shape as input

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[0.9142202  0.72091234])
>>> y = tlx.ops.divide(x, x)

equal¶

tensorlayerx.equal(x, y)[source]¶

Returns the truth value of (x == y) element-wise.

Parameters:

x (tensor) – A Tensor or SparseTensor or IndexedSlices.
y (tensor) – A Tensor or SparseTensor or IndexedSlices.

Returns:

Return type:

A Tensor of type bool with the same size as that of x or y.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[1, 2, 3])
>>> y = tlx.ops.equal(x, x)

exp¶

tensorlayerx.exp(x)[source]¶

Computes exponential of x element-wise.

Parameters:: x (tensor) – Must be one of the following types: bfloat16, half, float32, float64, complex64, complex128.
Returns:
Return type:: A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[1, 2, 3])
>>> y = tlx.ops.exp(x)

floor¶

tensorlayerx.floor()¶

Return the floor of x as an Integral.

This is the largest integer <= x.

floordiv¶

tensorlayerx.floordiv(x, y)[source]¶

Divides x / y elementwise, rounding toward the most negative integer.

Parameters:

x (tensor) – Tensor numerator of real numeric type.
y (tensor) – Tensor denominator of real numeric type.

Returns:

Return type:

x / y rounded toward -infinity.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[1, 2, 3])
>>> y = tlx.ops.floordiv(x, x)

floormod¶

tensorlayerx.floormod(x, y)[source]¶

Returns element-wise remainder of division. When x < 0 xor y < 0 is true, this follows Python semantics in that the result here is consistent with a flooring divide. E.g. floor(x / y) * y + mod(x, y) = x.

Parameters:

x (tensor) – Must be one of the following types: int8, int16, int32, int64, uint8, uint16, uint32, uint64, bfloat16, half, float32, float64.
y (tensor) – A Tensor. Must have the same type as x.

Returns:

Return type:

A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[1, 2, 3])
>>> y = tlx.ops.floormod(x, x)

greater¶

tensorlayerx.greater(x, y)[source]¶

Returns the truth value of (x >= y) element-wise.

Parameters:

x (tensor) – Must be one of the following types: float32, float64, int32, uint8, int16, int8, int64, bfloat16, uint16, half, uint32, uint64.
y (tensor) – A Tensor. Must have the same type as x.

Returns:

Return type:

A Tensor of type bool.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[1, 2, 3])
>>> y = tlx.ops.greater(x, x)

greater_equal¶

tensorlayerx.greater_equal(x, y)[source]¶

Returns the truth value of (x >= y) element-wise.

Parameters:

x (tensor) – Must be one of the following types: float32, float64, int32, uint8, int16, int8, int64, bfloat16, uint16, half, uint32, uint64.
y (tensor) – A Tensor. Must have the same type as x.

Returns:

Return type:

A Tensor of type bool.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[1, 2, 3])
>>> y = tlx.ops.greater_equal(x, x)

is_inf¶

tensorlayerx.is_inf(x)[source]¶

Returns which elements of x are Inf.

Parameters:: x (tensor) – A Tensor. Must be one of the following types: bfloat16, half, float32, float64.
Returns:
Return type:: A Tensor of type bool.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.constant(value=[1, 2, 3, np.inf])
>>> y = tlx.ops.is_inf(x)

is_nan¶

tensorlayerx.is_nan(x)[source]¶

Returns which elements of x are NaN.

Parameters:: x (tensor) – A Tensor. Must be one of the following types: bfloat16, half, float32, float64.
Returns:
Return type:: A Tensor of type bool.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.constant(value=[1, 2, 3, np.nan])
>>> y = tlx.ops.is_nan(x)

l2_normalize¶

tensorlayerx.l2_normalize(x, axis=None, eps=1e-12)[source]¶

Normalizes along dimension axis using an L2 norm. For a 1-D tensor with axis = 0, computes output = x / sqrt(max(sum(x**2), epsilon))

Parameters:

x (tensor) – A Tensor
axis (int) – Dimension along which to normalize. A scalar or a vector of integers.
eps (float) – A lower bound value for the norm. Will use sqrt(epsilon) as the divisor if norm < sqrt(epsilon).

Returns:

Return type:

A Tensor with the same shape as x.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.constant(value=[1, 2, 3, np.nan])
>>> y = tlx.ops.l2_normalize(x)

less¶

tensorlayerx.less(x, y)[source]¶

Returns the truth value of (x < y) element-wise.

Parameters:

x (tensor) – Must be one of the following types: float32, float64, int32, uint8, int16, int8, int64, bfloat16, uint16, half, uint32, uint64.
y (tensor) – A Tensor. Must have the same type as x.

Returns:

Return type:

A Tensor of type bool.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[1, 2, 3])
>>> y = tlx.ops.less(x, x)

less_equal¶

tensorlayerx.less_equal(x, y)[source]¶

Returns the truth value of (x <= y) element-wise.

Parameters:

x (tensor) – Must be one of the following types: float32, float64, int32, uint8, int16, int8, int64, bfloat16, uint16, half, uint32, uint64.
y (tensor) – A Tensor. Must have the same type as x.

Returns:

Return type:

A Tensor of type bool.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[1, 2, 3])
>>> y = tlx.ops.less_equal(x, x)

log¶

tensorlayerx.log(x)[source]¶

Computes natural logarithm of x element-wise.

Parameters:: x (tensor) – Must be one of the following types: bfloat16, half, float32, float64, complex64, complex128.
Returns:
Return type:: A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[1, 2, 3])
>>> y = tlx.ops.log(x)

log_sigmoid¶

tensorlayerx.log_sigmoid(x)[source]¶

Computes log sigmoid of x element-wise.

Parameters:: x (tensor) – A Tensor with type float32 or float64.
Returns:
Return type:: A Tensor with the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[1, 2, 3])
>>> y = tlx.ops.log_sigmoid(x)

maximum¶

tensorlayerx.maximum(x, y)[source]¶

Returns the max of x and y (i.e. x > y ? x : y) element-wise.

Parameters:

x (tensor) – Must be one of the following types: float32, float64, int32, uint8, int16, int8, int64, bfloat16, uint16, half, uint32, uint64.
y (tensor) – A Tensor. Must have the same type as x.

Returns:

Return type:

A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[1, 2, 3])
>>> y = tlx.ops.maximum(x, x)

minimum¶

tensorlayerx.minimum(x, y)[source]¶

Returns the min of x and y (i.e. x < y ? x : y) element-wise.

Parameters:

x (tensor.) – Must be one of the following types: bfloat16, half, float32, float64, int32, int64.
y (A Tensor.) – Must have the same type as x.

Returns:

Return type:

A Tensor. Has the same type as x

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant([0., 0., 0., 0.])
>>> y = tlx.ops.constant([-5., -2., 0., 3.])
>>> z = tlx.ops.minimum(x, y)

multiply¶

tensorlayerx.multiply(x, y)[source]¶

Returns an element-wise x * y.

Parameters:

x (tensor) – Must be one of the following types: bfloat16, half, float32, float64, uint8, int8, uint16, int16, int32, int64, complex64, complex128.
y (tensor) – A Tensor. Must have the same type as x.

Returns:

Return type:

A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[0.9142202  0.72091234])
>>> y = tlx.ops.multiply(x, x)

negative¶

tensorlayerx.negative(x)[source]¶

Computes numerical negative value element-wise.

Parameters:

x (tensor) – Must be one of the following types: bfloat16, half, float32, float64, int8, int16, int32, int64, complex64, complex128.

Returns:

A Tensor. Has the same type as x.
If x is a SparseTensor, returns SparseTensor(x.indices, tf.math.negative(x.values, …), x.dense_shape)

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[1, 2, 3])
>>> y = tlx.ops.negative(x)

not_equal¶

tensorlayerx.not_equal(x, y)[source]¶

Returns the truth value of (x != y) element-wise.

Parameters:

x (tensor) – A Tensor or SparseTensor or IndexedSlices.
y (tensor) – A Tensor or SparseTensor or IndexedSlices.

Returns:

Return type:

A Tensor of type bool with the same size as that of x or y.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[1, 2, 3])
>>> y = tlx.ops.constant(value=[1, 3, 5])
>>> x = tlx.ops.not_equal(x, y)

pow¶

tensorlayerx.pow(x, y)[source]¶

Computes the power of one value to another.

Parameters:

x (tensor) – A Tensor of type float16, float32, float64, int32, int64, complex64, or complex128.
y (tensor) – A Tensor of type float16, float32, float64, int32, int64, complex64, or complex128.

Returns:

Return type:

A Tensor.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[1, 2, 3])
>>> y = tlx.ops.constant(value=[1, 3, 5])
>>> x = tlx.ops.pow(x, y)

real¶

tensorlayerx.real(x)[source]¶

Computes numerical negative value element-wise.

Parameters:: x (tensor) – A Tensor. Must have numeric type.
Returns:
Return type:: A Tensor of type float32 or float64.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[-2.25 + 4.75j, 3.25 + 5.75j])
>>> y = tlx.ops.real(x)

reciprocal¶

tensorlayerx.reciprocal(x)[source]¶

Computes the reciprocal of x element-wise.

Parameters:: x (tensor) – A Tensor. Must be one of the following types: bfloat16, half, float32, float64, int8, int16, int32, int64, complex64, complex128.
Returns:
Return type:: A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant(value=[-2.25, 3.25])
>>> y = tlx.ops.reciprocal(x)

reshape¶

tensorlayerx.reshape(tensor, shape)[source]¶

Reshapes a tensor.

Parameters:

tensor (tensor) – A Tensor.
shape (tensor) – Defines the shape of the output tensor.

Returns:

Return type:

A Tensor. Has the same type as tensor

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant([0., 1., 2., 3.])
>>> z = tlx.ops.reshape(x, [2, 2])

concat¶

tensorlayerx.concat(values, axis)[source]¶

Concatenates tensors along one dimension.

Parameters:

values (list) – A list of Tensor objects or a single Tensor
axis (int) – 0-D int32 Tensor. Dimension along which to concatenate

Returns:

Return type:

A Tensor resulting from concatenation of the input tensors.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant([0., 0., 0., 0.])
>>> y = tlx.ops.constant([-5., -2., 0., 3.])
>>> z = tlx.ops.concat([x, y], 0)

convert_to_tensor¶

tensorlayerx.convert_to_tensor(value, dtype=None, device=None)[source]¶

Converts the given value to a Tensor.

Parameters:

value (object) – An object whose type has a registered Tensor conversion function.
dtype (optional) – Optional element type for the returned tensor. If missing, the type is inferred from the type of value.
device (str or None) – create a tensor on ‘cpu’ or ‘gpu’, defautl is None.

Returns:

Return type:

A Tensor based on value.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = np.ones(shape=(10, 10))
>>> y = tlx.ops.convert_to_tensor(x)

convert_to_numpy¶

tensorlayerx.convert_to_numpy(value)[source]¶

Converts the given Tensor to a numpy.

Parameters:: value (object) – An object whose type has a registered Tensor conversion function.
Returns:
Return type:: A value based on tensor.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.ones(shape=(10, 10))
>>> y = tlx.ops.convert_to_numpy(x)

reduce_max¶

tensorlayerx.reduce_max(x, axis=None, keepdims=False)[source]¶

Computes the maximum of elements across dimensions of a tensor.

Parameters:

x (tensor) – The tensor to reduce. Should have real numeric type.
axis (int) – The dimensions to reduce. If None (the default), reduces all dimensions. Must be in the range [-rank(x), rank(x)).
keepdims (boolean) – If true, keep these reduced dimensions and the length is 1. If false, don’t keep these dimensions. Default : False, don’t keep these reduced dimensions.

Returns:

Return type:

The reduced tensor.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.random.randn(3, 4))
>>> x1 = tlx.ops.reduce_max(x, axis=1, keepdims=False)
>>> x2 = tlx.ops.reduce_max(x, axis=1, keepdims=True)

reduce_mean¶

tensorlayerx.reduce_mean(input_tensor, axis=None, keepdims=False)[source]¶

Computes the mean of elements across dimensions of a tensor.

Parameters:

x (tensor) – The tensor to reduce. Should have numeric type.
axis (list) – The dimensions to reduce. If None (the default), reduces all dimensions. Must be in the range [-rank(x), rank(x)).
keepdims (boolean) – If true, keep these reduced dimensions and the length is 1. If false, don’t keep these dimensions. Default : False, don’t keep these reduced dimensions.

Returns:

Return type:

The reduced tensor.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.random.randn(3, 4))
>>> x1 = tlx.ops.reduce_mean(x, axis=1, keepdims=False)
>>> x2 = tlx.ops.reduce_mean(x, axis=1, keepdims=True)

reduce_min¶

tensorlayerx.reduce_min(x, axis=None, keepdims=False)[source]¶

Computes the minimum of elements across dimensions of a tensor.

Parameters:

x (tensor) – The tensor to reduce. Should have real numeric type.
axis (int) – The dimensions to reduce. If None (the default), reduces all dimensions. Must be in the range [-rank(x), rank(x)).
keepdims (boolean) – If true, keep these reduced dimensions and the length is 1. If false, don’t keep these dimensions. Default : False, don’t keep these reduced dimensions.

Returns:

Return type:

The reduced tensor.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.random.randn(3, 4))
>>> x1 = tlx.ops.reduce_min(x, axis=1, keepdims=False)
>>> x2 = tlx.ops.reduce_min(x, axis=1, keepdims=True)

reduce_prod¶

tensorlayerx.reduce_prod(x, axis=None, keepdims=False)[source]¶

Computes the multiply of elements across dimensions of a tensor.

Parameters:

x (tensor) – The tensor to reduce. Should have real numeric type.
axis (int) – The dimensions to reduce. If None (the default), reduces all dimensions. Must be in the range [-rank(x), rank(x)).
keepdims (boolean) – If true, keep these reduced dimensions and the length is 1. If false, don’t keep these dimensions. Default : False, don’t keep these reduced dimensions.

Returns:

Return type:

The reduced tensor.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.random.randn(3, 4))
>>> x1 = tlx.ops.reduce_prod(x, axis=1, keepdims=False)
>>> x2 = tlx.ops.reduce_prod(x, axis=1, keepdims=True)

reduce_std¶

tensorlayerx.reduce_std(x, axis=None, keepdims=False)[source]¶

Computes the standard deviation of elements across dimensions of a tensor.

Parameters:

x (tensor) – The tensor to reduce. Should have real numeric type.
axis (int) – The dimensions to reduce. If None (the default), reduces all dimensions. Must be in the range [-rank(x), rank(x)).
keepdims (boolean) – If true, keep these reduced dimensions and the length is 1. If false, don’t keep these dimensions. Default : False, don’t keep these reduced dimensions.

Returns:

Return type:

The reduced tensor.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.random.randn(3, 4))
>>> x1 = tlx.ops.reduce_std(x, axis=1, keepdims=False)
>>> x2 = tlx.ops.reduce_std(x, axis=1, keepdims=True)

reduce_sum¶

tensorlayerx.reduce_sum(x, axis=None, keepdims=False)[source]¶

Computes the standard deviation of elements across dimensions of a tensor.

Parameters:

x (tensor) – The tensor to reduce. Should have real numeric type.
axis (int) – The dimensions to reduce. If None (the default), reduces all dimensions. Must be in the range [-rank(x), rank(x)).
keepdims (boolean) – If true, keep these reduced dimensions and the length is 1. If false, don’t keep these dimensions. Default : False, don’t keep these reduced dimensions.

Returns:

Return type:

The reduced tensor.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.random.randn(3, 4))
>>> x1 = tlx.ops.reduce_sum(x, axis=1, keepdims=False)
>>> x2 = tlx.ops.reduce_sum(x, axis=1, keepdims=True)

reduce_variance¶

tensorlayerx.reduce_variance(x, axis=None, keepdims=False)[source]¶

Computes the variance of elements across dimensions of a tensor.

Parameters:

x (tensor) – The tensor to reduce. Should have real numeric type.
axis (int) – The dimensions to reduce. If None (the default), reduces all dimensions. Must be in the range [-rank(x), rank(x)).
keepdims (boolean) – If true, keep these reduced dimensions and the length is 1. If false, don’t keep these dimensions. Default : False, don’t keep these reduced dimensions.

Returns:

Return type:

The reduced tensor.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.random.randn(3, 4))
>>> x1 = tlx.ops.reduce_variance(x, axis=1, keepdims=False)
>>> x2 = tlx.ops.reduce_variance(x, axis=1, keepdims=True)

round¶

tensorlayerx.round(x)[source]¶

Rounds the values of a tensor to the nearest integer, element-wise.

Parameters:: x (tensor) – The tensor to round. Should have real numeric type.
Returns:
Return type:: A Tensor of same shape and type as x.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.array([0.9, 2.5, 2.3, 1.5, -4.5]))
>>> x = tlx.ops.round(x)

rsqrt¶

tensorlayerx.rsqrt(x)[source]¶

Computes reciprocal of square root of x element-wise.

Parameters:: x (tensor) – The tensor to rsqrt. Should have real numeric type.
Returns:
Return type:: A Tensor of same shape and type as x.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.array([0.9, 2.5, 2.3, 1.5]))
>>> x = tlx.ops.rsqrt(x)

segment_max¶

tensorlayerx.segment_max(x, segment_ids)[source]¶

Computes the maximum along segments of a tensor.

Parameters:

x (tensor) – The tensor to segment_max. Should have real numeric type.
segment_ids (tensor) – A 1-D tensor whose size is equal to the size of data’s first dimension. Values should be sorted and can be repeated.

Returns:

Return type:

A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.array([[1,2,3,4], [4, 3, 2, 1], [5,6,7,8]]))
>>> id = tlx.ops.convert_to_tensor([0, 0, 1])
>>> x = tlx.ops.segment_max(x, id)
>>> print(x)
>>> [[4, 3, 3, 4],
>>> [5, 6, 7, 8]]

segment_mean¶

tensorlayerx.segment_mean(x, segment_ids)[source]¶

Computes the mean along segments of a tensor.

Parameters:

x (tensor) – The tensor to segment_mean. Should have real numeric type.
segment_ids (tensor) – A 1-D tensor whose size is equal to the size of data’s first dimension. Values should be sorted and can be repeated.

Returns:

Return type:

A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.array([[1.0 , 2, 3, 4], [4, 3, 2, 1], [5, 6, 7, 8]]))
>>> id = tlx.ops.convert_to_tensor([0, 0, 1])
>>> x = tlx.ops.segment_mean(x, id)
>>> print(x)
>>> [[2.5, 2.5, 2.5, 2.5],
>>> [5, 6, 7, 8]]

segment_min¶

tensorlayerx.segment_min(x, segment_ids)[source]¶

Computes the minimum along segments of a tensor.

Parameters:

x (tensor) – The tensor to segment_minimum. Should have real numeric type.
segment_ids (tensor) – A 1-D tensor whose size is equal to the size of data’s first dimension. Values should be sorted and can be repeated.

Returns:

Return type:

A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.array([[1, 2, 3, 4], [4, 3, 2, 1], [5, 6, 7, 8]]))
>>> id = tlx.ops.convert_to_tensor([0, 0, 1])
>>> x = tlx.ops.segment_minimum(x, id)
>>> print(x)
>>> [[1, 2, 2, 1],
>>> [5, 6, 7, 8]]

segment_prod¶

tensorlayerx.segment_prod(x, segment_ids)[source]¶

Computes the product along segments of a tensor.

Parameters:

x (tensor) – The tensor to segment_prod. Should have real numeric type.
segment_ids (tensor) – A 1-D tensor whose size is equal to the size of data’s first dimension. Values should be sorted and can be repeated.

Returns:

Return type:

A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.array([[1, 2, 3, 4], [4, 3, 2, 1], [5, 6, 7, 8]]))
>>> id = tlx.ops.convert_to_tensor([0, 0, 1])
>>> x = tlx.ops.segment_prod(x, id)
>>> print(x)
>>> [[4, 6, 6, 4],
>>> [5, 6, 7, 8]]

segment_sum¶

tensorlayerx.segment_sum(x, segment_ids)[source]¶

Computes the sum along segments of a tensor.

Parameters:

x (tensor) – The tensor to segment_sum. Should have real numeric type.
segment_ids (tensor) – A 1-D tensor whose size is equal to the size of data’s first dimension. Values should be sorted and can be repeated.

Returns:

Return type:

A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.array([[1, 2, 3, 4], [4, 3, 2, 1], [5, 6, 7, 8]]))
>>> id = tlx.ops.convert_to_tensor([0, 0, 1])
>>> x = tlx.ops.segment_sum(x, id)
>>> print(x)
>>> [[5, 5, 5, 5],
>>> [5, 6, 7, 8]]

sigmoid¶

tensorlayerx.sigmoid(x)[source]¶

Computes sigmoid of x element-wise.

Parameters:: x (tensor) – A Tensor with type float16, float32, float64, complex64, or complex128.
Returns:
Return type:: A Tensor with the same type as x.

sign¶

tensorlayerx.sign(x)[source]¶

Computes sign of a tensor element-wise.

Parameters:: x (tensor) – The tensor to sign. y = sign(x) = -1 if x < 0; 0 if x == 0; 1 if x > 0.
Returns:
Return type:: A Tensor with the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.array([-128.0, 0.0, 128.0]), dtype='float32')
>>> x = tlx.ops.sign(x)
>>> print(x)
>>> [-1., 0., 1.]

sin¶

tensorlayerx.sin(x)[source]¶

Computes sine of a tensor element-wise.

Parameters:: x (tensor) – The tensor to sin. Input range is (-inf, inf) and output range is [-1,1].
Returns:
Return type:: A Tensor with the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.array([-1.0, 0.0, 1.0]), dtype='float32')
>>> x = tlx.ops.sin(x)
>>> print(x)
>>> [-0.84147096, 0., 0.84147096]

sinh¶

tensorlayerx.sinh(x)[source]¶

Computes hyperbolic sine of a tensor element-wise.

Parameters:: x (tensor) – The tensor to hyperbolic sin. Input range is (-inf, inf) and output range is [-inf,inf].
Returns:
Return type:: A Tensor with the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.array([-1.0, 0.0, 1.0]), dtype='float32')
>>> x = tlx.ops.sinh(x)
>>> print(x)
>>> [-1.1752012, 0., 1.1752012]

softplus¶

tensorlayerx.softplus(x)[source]¶

Computes softplus of a tensor element-wise.

Parameters:: x (tensor) – The tensor to softplus. softplus(x) = log(exp(x) + 1).
Returns:
Return type:: A Tensor with the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.array([-1.0, 0.0, 1.0]), dtype='float32')
>>> x = tlx.ops.softplus(x)
>>> print(x)
>>> [0.3132617, 0.6931472, 1.3132616]

sqrt¶

tensorlayerx.sqrt(x)[source]¶

Computes square root of a tensor element-wise.

Parameters:: x (tensor) – Must be one of the following types: bfloat16, half, float32, float64, complex64, complex128.
Returns:
Return type:: A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.array([0.0, 1.0, 4.0]), dtype=tlx.float32)
>>> x = tlx.ops.sqrt(x)
>>> print(x)
>>> [0.0, 1.0, 2.0]

square¶

tensorlayerx.square(x)[source]¶

Computes square of a tensor element-wise.

Parameters:: x (tensor) – The tensor to square.
Returns:
Return type:: A Tensor with the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.array([-1.0, 0.0, 1.0]), dtype='float32')
>>> x = tlx.ops.square(x)
>>> print(x)
>>> [1.0, 0.0, 1.0]

squared_difference¶

tensorlayerx.squared_difference(x, y)[source]¶

Computes difference and square between tensor x and tensor y. return square(x - y)

Parameters:

x (tensor) – A Tensor.
y (tensor) – A Tensor. Must have the same type as x.

Returns:

Return type:

A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.array([[1,0,1], [2,3,4]]), dtype='float32')
>>> y = tlx.ops.convert_to_tensor(np.array([[-1,0,1], [2,3,4]]), dtype='float32')
>>> res = tlx.ops.squared_difference(x, y)
>>> print(res)
>>> [[4.0, 0.0, 0.0],
>>> [0.0, 0.0, 0.0]]

subtract¶

tensorlayerx.subtract(x, y)[source]¶

Returns x - y element-wise.

Parameters:

x (tensor) – A tensor.
y (tensor) – A Tensor. Must have the same type as x.

Returns:

Return type:

A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.array([[1,0,1], [2,3,4]]), dtype='float32')
>>> y = tlx.ops.convert_to_tensor(np.array([[-1,0,1], [2,3,4]]), dtype='float32')
>>> res = tlx.ops.subtract(x, y)
>>> print(res)
>>> [[-2.0, 0.0, 0.0],
>>> [0.0, 0.0, 0.0]]

tan¶

tensorlayerx.tan(x)[source]¶

Computes tan of a tensor element-wise.

Parameters:: x (tensor) – The tensor to tan.
Returns:
Return type:: A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.array([1,0,1]), dtype='float32')
>>> res = tlx.ops.tan(x)
>>> print(res)
>>> [-1.5574077, 0.0, 1.5574077]

tanh¶

tensorlayerx.tanh(x)[source]¶

Computes hyperbolic tangent of a tensor element-wise.

Parameters:: x (tensor) – The tensor to tanh.
Returns:
Return type:: A Tensor. Has the same type as x.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.array([1,0,1]), dtype="float32")
>>> res = tlx.ops.tanh(x)
>>> print(res)
>>> [-0.7615942, 0.0, 0.7615942]

any¶

tensorlayerx.any(x, axis=None, keepdims=False)[source]¶

Computes logical_or of a tensor element-wise.

Parameters:

x (tensor) – The boolean tensor to reduce.
axis (int or None) – The dimensions to reduce. If None (the default), reduces all dimensions. Must be in the range [-rank(x),rank(x)).
keepdims (boolean) – If true, retains reduced dimensions with length 1.

Returns:

Return type:

The reduced tensor.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.array([1,0,1]), dtype='bool')
>>> res = tlx.ops.any(x, axis = None, keepdims = False)
>>> print(res)
>>> True

all¶

tensorlayerx.all(x, axis=None, keepdims=False)[source]¶

Computes logical_and of a tensor element-wise.

Parameters:

x (tensor) – The boolean tensor to reduce.
axis (int or None) – The dimensions to reduce. If None (the default), reduces all dimensions. Must be in the range [-rank(x),rank(x)).
keepdims (boolean) – If true, retains reduced dimensions with length 1.

Returns:

Return type:

The reduced tensor.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.array([1,0,1]), dtype='bool')
>>> res = tlx.ops.all(x, axis = None, keepdims = False)
>>> print(res)
>>> False

logical_and¶

tensorlayerx.logical_and(x, y)[source]¶

Returns the truth value of x AND y element-wise.

Parameters:

x (tensor) – A tf.Tensor of type bool.
y (tensor) – A tf.Tensor of type bool.

Returns:

Return type:

A Tensor of type bool.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.constant([False, False, True, True])
>>> y = tlx.constant([False, True, False, True])
>>> res = tlx.ops.logical_and(x, y)
>>> print(res)
>>> [False, False, False, True]

logical_not¶

tensorlayerx.logical_not(x)[source]¶

Returns the truth value of NOT x element-wise.

Parameters:: x (tensor) – A tf.Tensor of type bool.
Returns:
Return type:: A Tensor of type bool.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.constant([False, False, True, True])
>>> res = tlx.ops.logical_not(x, y)
>>> print(res)
>>> [True, True, False, False]

logical_or¶

tensorlayerx.logical_or(x, y)[source]¶

Returns the truth value of x OR y element-wise.

Parameters:

x (tensor) – A tf.Tensor of type bool.
y (tensor) – A tf.Tensor of type bool.

Returns:

Return type:

A Tensor of type bool.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.constant([False, False, True, True])
>>> y = tlx.constant([False, True, False, True])
>>> res = tlx.ops.logical_or(x, y)
>>> print(res)
>>> [False, True, True, True]

logical_xor¶

tensorlayerx.logical_xor(x, y)[source]¶

Returns the truth value of NOT x element-wise. x ^ y = (x | y) & ~(x & y)

Parameters:: x (tensor) – A tf.Tensor of type bool.
Returns:
Return type:: A Tensor of type bool.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.constant([False, False, True, True])
>>> y = tlx.constant([False, True, False, True])
>>> res = tlx.ops.logical_xor(x, y)
>>> print(res)
>>> [False, True, True, False]

argsort¶

tensorlayerx.argsort(x, axis=-1, descending=False)[source]¶

Returns the indices of a tensor that give its sorted order along an axis.

Parameters:

x (tensor) – An input N-D Tensor
axis (int or None) – The axis along which to sort. The default is -1, which sorts the last axis.
descending (boolean) – Descending is a flag, if set to true, algorithm will sort by descending order, else sort by ascending order. Default is false.

Returns:

Return type:

A Tensor with the same shape as values.

Examples

>>> import tensorlayerx as tlx
>>> x = [1, 10, 26.9, 2.8, 166.32, 62.3]
>>> y = tlx.ops.argsort(x, descending = False)
>>> print(y)
>>> [0, 3, 1, 2, 5, 4]

bmm¶

tensorlayerx.bmm(x, y)[source]¶

Applies batched matrix multiplication to two tensors. Both of the two input tensors must be three-dementional and share the same batch size. if x is a (b, m, k) tensor, y is a (b, k, n) tensor, the output will be a (b, m, n) tensor.

Parameters:

x (tensor) – The input Tensor.
y (tensor) – The input Tensor.

Returns:

Return type:

The product Tensor.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.convert_to_tensor([[[1.0, 1.0, 1.0],[2.0, 2.0, 2.0]],[[3.0, 3.0, 3.0],[4.0, 4.0, 4.0]]])
>>> y = tlx.convert_to_tensor([[[1.0, 1.0],[2.0, 2.0],[3.0, 3.0]],[[4.0, 4.0],[5.0, 5.0],[6.0, 6.0]]])
>>> res = tlx.ops.bmm(x, y)
>>> print(res)
>>> [[[6. , 6. ],
>>> [12., 12.]],
>>> [[45., 45.],
>>> [60., 60.]]]

matmul¶

tensorlayerx.matmul(a, b, transpose_a=False, transpose_b=False)[source]¶

Multiplies matrix a by matrix b, producing a * b.

Parameters:

a (tensor) – type float16, float32, float64, int32, complex64, complex128 and rank > 1.
b (tensor) – with same type and rank as a.
transpose_a (boolean) – If True, a is transposed before multiplication.
transpose_b (boolean) – If True, b is transposed before multiplication.

Returns:

Return type:

A Tensor of the same type as a and b

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.convert_to_tensor(np.random.random([2,3,2]), dtype="float32")
>>> y = tlx.convert_to_tensor(np.random.random([2,2,3]), dtype="float32")
>>> z = tlx.ops.matmul(x, y)
>>> print(z.shape)
>>> [2,3,3]

triu¶

tensorlayerx.triu(x, diagonal=0)[source]¶

This op returns the upper triangular part of a matrix (2-D tensor) or batch of matrices x, the other elements of the result tensor are set to 0. The upper triangular part of the matrix is defined as the elements on and above the diagonal.

Parameters:

x (tensor) – The tensor to triu.
diagonal (int) – The diagonal to consider, default value is 0. If diagonal = 0, all elements on and above the main diagonal are retained. A positive value excludes just as many diagonals above the main diagonal, and similarly a negative value includes just as many diagonals below the main diagonal.

Returns:

Return type:

Results of upper triangular operation by the specified diagonal of input tensor x, it’s data type is the same as x’s Tensor.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.convert_to_tensor(np.arange(1, 10, dtype="int32").reshape(3,-1))
>>> y = tlx.ops.triu(x, diagonal=1)
>>> print(y)
>>> [[0, 2, 3],
>>> [ 0, 0, 6],
>>> [ 0, 0, 0]]

tril¶

tensorlayerx.tril(x, diagonal=0)[source]¶

This op returns the lower triangular part of a matrix (2-D tensor) or batch of matrices x, the other elements of the result tensor are set to 0. The lower triangular part of the matrix is defined as the elements on and below the diagonal.

Parameters:

x (tensor) – The tensor to tril.
diagonal (int) – The diagonal to consider, default value is 0. If diagonal = 0, all elements on and below the main diagonal are retained. A positive value includes just as many diagonals above the main diagonal, and similarly a negative value excludes just as many diagonals below the main diagonal.

Returns:

Return type:

Results of lower triangular operation by the specified diagonal of input tensor x, it’s data type is the same as x’s Tensor.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.convert_to_tensor(np.arange(1, 10, dtype="int32").reshape(3,-1))
>>> y = tlx.ops.tril(x, diagonal=1)
>>> print(y)
>>> [[0, 0, 0],
>>> [ 4, 0, 0],
>>> [ 7, 8, 0]]

tile¶

tensorlayerx.tile(input, multiples)[source]¶

Constructs a tensor by tiling a given tensor.

Parameters:

input (tensor) – A Tensor. 1-D or higher.
multiples (tensor or tuple or list) – The number of repeating times. If repeat_times is a list or tuple, all its elements should be integers or 1-D Tensors with the data type int32. If repeat_times is a Tensor, it should be an 1-D Tensor with the data type int32. Length must be the same as the number of dimensions in input.

Returns:

Return type:

A Tensor. Has the same type as input.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant([[1,2,3],[1,2,3]])
>>> y = tlx.ops.tile(x, [2, 1])
>>> [[1, 2, 3],
>>>  [1, 2, 3],
>>>  [1, 2, 3],
>>>  [1, 2, 3]]

where¶

tensorlayerx.where(condition, x, y)[source]¶

Return a tensor of elements selected from either x or y, depending on condition.

Parameters:

condition (tensor of bool) – When True (nonzero), yield x, otherwise yield y
x (tensor) – values selected at indices where condition is True
y (tensor) – values selected at indices where condition is False

Returns:

Return type:

A tensor of shape equal to the broadcasted shape of condition, x, y

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.convert_to_tensor([0.9, 0.1, 3.2, 1.2])
>>> y = tlx.convert_to_tensor([1.0, 1.0, 1.0, 1.0])
>>> res = tlx.ops.where(x>1, x, y)
>>> print(res)
>>> [1.0, 1.0, 3.2, 1.2]

ones_like¶

tensorlayerx.ones_like(x, dtype=None)[source]¶

This OP returns a Tensor filled with the value 1, with the same shape and data type (use dtype if dtype is not None) as x.

Parameters:

x (tensor) – The input tensor which specifies shape and dtype.
dtype (str) – A type for the returned Tensor.If dtype is None, the data type is the same as x. Default is None.

Returns:

Return type:

A Tensor filled with the value 1, with the same shape and data type (use dtype if dtype is not None) as x.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.convert_to_tensor([0.9, 0.1, 3.2, 1.2])
>>> res = tlx.ops.ones_like(x, dtype="int32")
>>> print(res)
>>> [1, 1, 1, 1]

zeros_like¶

tensorlayerx.zeros_like(x, dtype=None)[source]¶

This OP returns a Tensor filled with the value 0, with the same shape and data type (use dtype if dtype is not None) as x.

Parameters:

x (tensor) – The input tensor which specifies shape and dtype.
dtype (str) – A type for the returned Tensor.If dtype is None, the data type is the same as x. Default is None.

Returns:

Return type:

A Tensor filled with the value 0, with the same shape and data type (use dtype if dtype is not None) as x.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.convert_to_tensor([0.9, 0.1, 3.2, 1.2])
>>> res = tlx.ops.zeros_like(x, dtype="int32")
>>> print(res)
>>> [0, 0, 0, 0]

stack¶

tensorlayerx.stack(values, axis=0)[source]¶

Stacks a list of rank-R tensors into one rank-(R+1) tensor.

Parameters:

values (list) – A list of Tensor objects with the same shape and type.
axis (int) – An int. The axis to stack along. Defaults to the first dimension. Negative values wrap around, so the valid range is [-(R+1), R+1).

Returns:

Return type:

A stacked Tensor with the same type as values.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant([1,2,3])
>>> y = tlx.ops.constant([1,2,3])
>>> res = tlx.ops.stack([x, y])
>>> [[1, 2, 3],
>>>  [1, 2, 3]]

split¶

tensorlayerx.split(value, num_or_size_splits, axis=0)[source]¶

Splits a tensor into sub tensors.

Parameters:

value (tensor) – The Tensor to split.
num_or_size_splits (int or list) – Either an integer indicating the number of splits along split_dim or a 1-D integer Tensor or Python list containing the sizes of each output tensor along split_dim.
axis (int) – The dimension along which to split. Must be in the range [-rank(value), rank(value)). Defaults to 0.

Returns:

Return type:

Tensor objects resulting from splitting value.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.ones([3, 9, 5])
>>> y1, y2, y3 = tlx.ops.split(x, 3, axis=1)
>>> y1, y2, y3 = tlx.ops.split(x, [1,3,5], axis=1)

squeeze¶

tensorlayerx.squeeze(x, axis=None)[source]¶

Removes dimensions of size 1 from the shape of a tensor.

Parameters:

x (tensor) – The input Tensor.
axis (int or list or tuple) – An integer or list/tuple of integers, indicating the dimensions to be squeezed. Default is None. The range of axis is [−ndim(x),ndim(x)). If axis is negative, axis=axis+ndim(x). If axis is None, all the dimensions of x of size 1 will be removed.

Returns:

Return type:

Squeezed Tensor with the same data type as input Tensor.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.ones(shape=[1,2,3])
>>> res = tlx.ops.squeeze(x, axis=0)
>>> print(res.shape)
>>> [2, 3]

expand_dims¶

tensorlayerx.expand_dims(input, axis)[source]¶

Inserts a dimension of 1 into a tensor’s shape.

Parameters:

input (tensor) – A Tensor.
axis (int) – 0-D (scalar). Specifies the dimension index at which to expand the shape of input. Must be in the range [-rank(input) - 1, rank(input)].

Returns:

Return type:

A Tensor with the same data as input, but its shape has an additional dimension of size 1 added.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.ones([1,2,3])
>>> res = tlx.ops.expand_dims(x, axis=0)
>>> print(res.shape)
>>>  [1, 1, 2, 3]

unsorted_segment_sum¶

tensorlayerx.unsorted_segment_sum(x, segment_ids, num_segments)[source]¶

Computes the sum along segments of a tensor.

Parameters:

x (tensor) – A Tensor.
segment_ids (Tensor or list or tuple) – Must be one of the following types: int32, int64.
num_segments (int or tensor) – should equal the number of distinct segment IDs.

Returns:

Return type:

A Tensor. Has the same type as data.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant([1,2,3])
>>> res = tlx.ops.unsorted_segment_sum(x, (0, 0, 1), num_segments=2)
>>> print(res)
>>> [2, 3]

unsorted_segment_mean¶

tensorlayerx.unsorted_segment_mean(x, segment_ids, num_segments)[source]¶

Computes the mean along segments of a tensor.

Parameters:

x (tensor) – A Tensor.
segment_ids (Tensor or list or tuple) – Must be one of the following types: int32, int64.
num_segments (int or tensor) – should equal the number of distinct segment IDs.

Returns:

Return type:

A Tensor. Has the same type as data.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant([1.,2.,3.])
>>> res = tlx.ops.unsorted_segment_mean(x, (0, 0, 1), num_segments=2)
>>> print(res)
>>> [1.5, 3]

unsorted_segment_min¶

tensorlayerx.unsorted_segment_min(x, segment_ids, num_segments)[source]¶

Computes the min along segments of a tensor.

Parameters:

x (tensor) – A Tensor.
segment_ids (Tensor or list or tuple) – Must be one of the following types: int32, int64.
num_segments (int or tensor) – should equal the number of distinct segment IDs.

Returns:

Return type:

A Tensor. Has the same type as data.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant([1.,2.,3.])
>>> res = tlx.ops.unsorted_segment_min(x, (0, 0, 1), num_segments=2)
>>> print(res)
>>> [1, 3]

unsorted_segment_max¶

tensorlayerx.unsorted_segment_max(x, segment_ids, num_segments)[source]¶

Computes the max along segments of a tensor.

Parameters:

x (tensor) – A Tensor.
segment_ids (Tensor or list or tuple) – Must be one of the following types: int32, int64.
num_segments (int or tensor) – should equal the number of distinct segment IDs.

Returns:

Return type:

A Tensor. Has the same type as data.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.constant([1.,2.,3.])
>>> res = tlx.ops.unsorted_segment_max(x, (0, 0, 1), num_segments=2)
>>> print(res)
>>> [2, 3]

set_seed¶

tensorlayerx.set_seed(seed)[source]¶

Parameters:: seed (int) – The random seed to set.

Examples

>>> import tensorlayerx as tlx
>>> tlx.ops.set_seed(42)

is_tensor¶

tensorlayerx.is_tensor(x)[source]¶

Parameters:: x (input) – A python object to check.
Returns:
Return type:: a bool Value. if x is tensor return True, else return False.

Examples

>>> import tensorlayerx as tlx
>>> tlx.ops.is_tensor(a)

tensor_scatter_nd_update¶

tensorlayerx.tensor_scatter_nd_update(tensor, indices, updates)[source]¶

Parameters:

tensor (Tensor) – tensor to update.
indices (list) – indices to update.
updates (Tensor) – value to apply at the indices

Returns:

Return type:

updated Tensor.

Examples

>>> import tensorlayerx as tlx
>>> tensor = tlx.ops.ones(shape=(5,3))
>>> indices = [[0],[ 4],[ 2]]
>>> updates = tlx.ops.convert_to_tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> new_tensor = tlx.ops.tensor_scatter_nd_update(tensor, indices, updates)
>>>  [[1. 2. 3.]
>>>  [1. 1. 1.]
>>>  [7. 8. 9.]
>>>  [1. 1. 1.]
>>>  [4. 5. 6.]]

scatter_update¶

tensorlayerx.scatter_update(tensor, indices, updates)[source]¶

Applies sparse updates to a variable

Parameters:

tensor (Tensor) – A Tensor. The dim of tensor must be 1.
indices (Tensor) – Indices into the tensor.
updates (Tensor) – Updated values

Returns:

Return type:

Tensor after updated.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.ones((5,))
>>> indices = tlx.ops.convert_to_tensor([0,  4,  2])
>>> updates = tlx.ops.convert_to_tensor([1., 4., 7.])
>>> res = tlx.ops.scatter_update(x, indices, updates)
>>> [1. 1. 7. 1. 4.]

diag¶

tensorlayerx.diag(input, diagonal=0)[source]¶

Parameters:

input (Tensor) – the input tensor.
diagonal (int) – the diagonal to consider. Defualt is 0.

Returns:

Return type:

the output tensor.

Examples

>>> import tensorlayerx as tlx
>>> tensor = tlx.ops.convert_to_tensor([[1,2,3],[4,5,6],[7,8,9]]))
>>> new_tensor = tlx.ops.diag(tensor)
>>> [1, 5, 9]

mask_select¶

tensorlayerx.mask_select(x, mask, axis=0)[source]¶

Parameters:

x (Tensor) – N-D Tensor.
mask (Tensor) – N-D boolean Tensor or 1-D boolean Tensor
axis – the axis in tensor to mask from. By default, axis is 0.

Returns:

Return type:

the output tensor.

Examples

>>> import tensorlayerx as tlx
>>> tensor = tlx.ops.convert_to_tensor([[1,2,3],[4,5,6],[7,8,9]]))
>>> mask = tlx.ops.convert_to_tensor(np.array([True, False, True]), dtype=tlx.bool)
>>> new_tensor = tlx.ops.mask_select(tensor, mask)
>>> [[1, 2, 3],[7, 8, 9]]

eye¶

tensorlayerx.eye(n, m=None, dtype=None)[source]¶

Parameters:

n (int) – the number of rows
m (int or None) – the number of columns with default being n
dtype (str or None) – the desired data type of returned tensor. Default: if None, use float32

Returns:

Return type:

A 2-D tensor with ones on the diagonal and zeros elsewhere

Examples

>>> import tensorlayerx as tlx
>>> tlx.ops.eye(2)
>>> [[1,0],
>>> [0,1]]

einsum¶

tensorlayerx.einsum(equation, *operands)[source]¶

Sums the product of the elements of the input operands along dimensions specified using a notation based on the Einstein summation convention.

Parameters:

equation (An attribute) – represent the operation you want to do. the value can contain only letters([a-z][A-Z]), commas(,), ellipsis(…), and arrow(->). the letters represent inputs’s tensor dimension, commas(,)represent separate tensors, ellipsis(…) indicates the tensor dimension that you do not care about, the left of the arrow(->) indicates the input tensors, and the right of it indicates the desired output dimension.
operands (list) – input tensor used for calculation. the data type of the tensor must be the same.

Returns:

Return type:

Tensor, the shape of it can be obtained from the equation, and the data type is the same as input tensors.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.nn.Input((5,))
>>> y = tlx.nn.Input((4,))
>>> out = tlx.ops.einsum('i,j->ij', x, y)
>>> cal_enisum = tlx.ops.Einsum('i,j->ij')
>>> out = cal_enisum(x, y)

set_device¶

tensorlayerx.set_device(device='GPU', id=0)[source]¶

This function can specify the global device which the OP will run.

Parameters:

device (str) – Specific running device. It can be ‘CPU’, ‘GPU’ and ‘Ascend’(In mindspore backend).
id (int) – Device id.

get_device¶

tensorlayerx.get_device()[source]¶

This function can get the specified global device.

Returns:
Return type:: The global device.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.get_device()
>>> "CPU"

to_device¶

tensorlayerx.to_device(tensor, device='GPU', id=0)[source]¶

Returns a copy of Tensor in specified device.

Parameters:

tensor (Tensor) – A tensor.
device (str) – The specified device. Support ‘GPU’ and ‘CPU’. Default is ‘GPU’.
id (int) – The id of specified device. Default is 0.

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.ones((5,))
>>> x = tlx.ops.to_device(x, device="GPU", id=0)

roll¶

tensorlayerx.roll(input, shifts, dims=None)[source]¶

Roll the tensor input along the given dimension(s). Elements that are shifted beyond the last position are re-introduced at the first position. If dims is None, the tensor will be flattened before rolling and then restored to the original shape.

Parameters:

input (tensor) – the input tensor.
shifts (int or tuple) – The number of places by which the elements of the tensor are shifted. If shifts is a tuple, dims must be a tuple of the same size, and each dimension will be rolled by the corresponding value
dims (int or tuple) – Axis along which to roll

Examples

>>> import tensorlayerx as tlx
>>> x = tlx.ops.ones((5,6))
>>> x = tlx.ops.roll(x, shifts=2)

logsoftmax¶

tensorlayerx.logsoftmax(input, dim=None)[source]¶

Applies a softmax followed by a logarithm.

Parameters:

input (Tensor) – the input tensor.
dim (int) – A dimension along which LogSoftmax will be computed.

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.random.random((3,4)))
>>> x = tlx.ops.logsoftmax(x, dim=1)

topk¶

tensorlayerx.topk(input, k, dim=None, largest=True, sorted=True)[source]¶

Returns the k largest elements of the given input tensor along a given dimension.

A namedtuple of (values, indices) is returned, where the indices are the indices of the elements in the original input tensor.

Parameters:

input (Tensor) – the input tensor.
k (int) – the k in “top-k”
dim (int) – the dimension to sort along. If dim is not given, the last dimension of the input is chosen.
largest (bool) – controls whether to return largest or smallest elements
sorted (bool) – controls whether to return the elements in sorted order

Returns:

out – return the values and indices.

Return type:

tuple

Examples

>>> import tensorlayerx as tlx
>>> import numpy as np
>>> x = tlx.ops.convert_to_tensor(np.random.random((3,4)))
>>> x = tlx.ops.topk(x, 2)

numel¶

tensorlayerx.numel(input)[source]¶

Returns the total number of elements in the input tensor.

Parameters:: input (tensor) – the input tensor.