Tensor¶
- class paddle. Tensor [source]
-
-
abs
(
name=None
)
[source]
abs¶
-
Abs Operator. Perform elementwise abs for input X.
\[out = |x|\]- Parameters
-
x (Tensor) – The input tensor of abs op.
out (Tensor) – The output tensor of abs op.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
Examples
import paddle x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3]) out = paddle.abs(x) print(out) # [0.4 0.2 0.1 0.3]
-
acos
(
name=None
)
[source]
acos¶
-
Acos Activation Operator.
\[out = cos^{-1}(x)\]- Parameters
-
x (Tensor) – Input of Acos operator, an N-D Tensor, with data type float32, float64 or float16.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor. Output of Acos operator, a Tensor with shape same as input.
Examples
import paddle x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3]) out = paddle.acos(x) print(out) # [1.98231317 1.77215425 1.47062891 1.26610367]
-
acosh
(
name=None
)
[source]
acosh¶
-
Acosh Activation Operator.
\[out = acosh(x)\]- Parameters
-
x (Tensor) – Input of Acosh operator, an N-D Tensor, with data type float32, float64 or float16.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor. Output of Acosh operator, a Tensor with shape same as input.
Examples
import paddle x = paddle.to_tensor([1., 3., 4., 5.]) out = paddle.acosh(x) print(out) # [0. , 1.76274729, 2.06343699, 2.29243159]
-
add
(
y,
name=None
)
[source]
add¶
-
Elementwise Add Operator. Add two tensors element-wise The equation is:
\[Out=X+Y\]$X$ the tensor of any dimension. $Y$ the tensor whose dimensions must be less than or equal to the dimensions of $X$.
There are two cases for this operator:
The shape of $Y$ is the same with $X$.
The shape of $Y$ is a continuous subsequence of $X$.
For case 2:
Broadcast $Y$ to match the shape of $X$, where axis is the start dimension index for broadcasting $Y$ onto $X$.
If $axis$ is -1 (default), $axis$=rank($X$)-rank($Y$).
The trailing dimensions of size 1 for $Y$ will be ignored for the consideration of subsequence, such as shape($Y$) = (2, 1) => (2).
For example:
shape(X) = (2, 3, 4, 5), shape(Y) = (,) shape(X) = (2, 3, 4, 5), shape(Y) = (5,) shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2 shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1 shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0 shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0
- Parameters
-
x (Tensor) – Tensor or LoDTensor of any dimensions. Its dtype should be int32, int64, float32, float64.
y (Tensor) – Tensor or LoDTensor of any dimensions. Its dtype should be int32, int64, float32, float64.
name (string, optional) – For details, please refer to Name. Generally, no setting is required. Default: None.
- Returns
-
N-D Tensor. A location into which the result is stored. It’s dimension equals with x.
Examples
import paddle x = paddle.to_tensor([2, 3, 4], 'float64') y = paddle.to_tensor([1, 5, 2], 'float64') z = paddle.add(x, y) print(z) # [3., 8., 6. ]
-
add_
(
y,
name=None
)
add_¶
-
Inplace version of
add
API, the output Tensor will be inplaced with inputx
. Please refer to api_tensor_add.
-
add_n
(
name=None
)
[source]
add_n¶
-
Sum one or more Tensor of the input.
For example:
Case 1: Input: input.shape = [2, 3] input = [[1, 2, 3], [4, 5, 6]] Output: output.shape = [2, 3] output = [[1, 2, 3], [4, 5, 6]] Case 2: Input: First input: input1.shape = [2, 3] Input1 = [[1, 2, 3], [4, 5, 6]] The second input: input2.shape = [2, 3] input2 = [[7, 8, 9], [10, 11, 12]] Output: output.shape = [2, 3] output = [[8, 10, 12], [14, 16, 18]]
- Parameters
-
inputs (Tensor|list[Tensor]|tuple[Tensor]) – A Tensor or a list/tuple of Tensors. The shape and data type of the list/tuple elements should be consistent. Input can be multi-dimensional Tensor, and data types can be: float32, float64, int32, int64.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, the sum of input \(inputs\) , its shape and data types are consistent with \(inputs\).
Examples
import paddle input0 = paddle.to_tensor([[1, 2, 3], [4, 5, 6]], dtype='float32') input1 = paddle.to_tensor([[7, 8, 9], [10, 11, 12]], dtype='float32') output = paddle.add_n([input0, input1]) # [[8., 10., 12.], # [14., 16., 18.]]
-
addmm
(
x,
y,
beta=1.0,
alpha=1.0,
name=None
)
[source]
addmm¶
-
addmm
Perform matrix multiplication for input $x$ and $y$. $input$ is added to the final result. The equation is:
\[Out = alpha * x * y + beta * input\]$Input$, $x$ and $y$ can carry the LoD (Level of Details) information, or not. But the output only shares the LoD information with input $input$.
- Parameters
-
input (Tensor) – The input Tensor to be added to the final result.
x (Tensor) – The first input Tensor for matrix multiplication.
y (Tensor) – The second input Tensor for matrix multiplication.
beta (float, optional) – Coefficient of $input$, default is 1.
alpha (float, optional) – Coefficient of $x*y$, default is 1.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
The output Tensor of addmm.
- Return type
-
Tensor
Examples
import paddle x = paddle.ones([2,2]) y = paddle.ones([2,2]) input = paddle.ones([2,2]) out = paddle.addmm( input=input, x=x, y=y, beta=0.5, alpha=5.0 ) print(out) # [[10.5 10.5] # [10.5 10.5]]
-
all
(
axis=None,
keepdim=False,
name=None
)
[source]
all¶
-
Computes the
logical and
of tensor elements over the given dimension.- Parameters
-
x (Tensor) – An N-D Tensor, the input data type should be bool.
axis (int|list|tuple, optional) – The dimensions along which the
logical and
is compute. IfNone
, and all elements ofx
and return a Tensor with a single element, otherwise must be in the range \([-rank(x), rank(x))\). If \(axis[i] < 0\), the dimension to reduce is \(rank + axis[i]\).keepdim (bool, optional) – Whether to reserve the reduced dimension in the output Tensor. The result Tensor will have one fewer dimension than the
x
unlesskeepdim
is true, default value is False.name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Results the
logical and
on the specified axis of input Tensor x, it’s data type is bool. - Return type
-
Tensor
Examples
import paddle # x is a bool Tensor with following elements: # [[True, False] # [True, True]] x = paddle.to_tensor([[1, 0], [1, 1]], dtype='int32') print(x) x = paddle.cast(x, 'bool') # out1 should be False out1 = paddle.all(x) # False print(out1) # out2 should be [True, False] out2 = paddle.all(x, axis=0) # [True, False] print(out2) # keepdim=False, out3 should be [False, True], out.shape should be (2,) out3 = paddle.all(x, axis=-1) # [False, True] print(out3) # keepdim=True, out4 should be [[False], [True]], out.shape should be (2,1) out4 = paddle.all(x, axis=1, keepdim=True) # [[False], [True]] print(out4)
-
allclose
(
y,
rtol=1e-05,
atol=1e-08,
equal_nan=False,
name=None
)
[source]
allclose¶
-
Check if all \(x\) and \(y\) satisfy the condition:
\[\left| x - y \right| \leq atol + rtol \times \left| y \right|\]elementwise, for all elements of \(x\) and \(y\). This is analogous to \(numpy.allclose\), namely that it returns \(True\) if two tensors are elementwise equal within a tolerance.
- Parameters
-
x (Tensor) – The input tensor, it’s data type should be float16, float32, float64..
y (Tensor) – The input tensor, it’s data type should be float16, float32, float64..
rtol (rtoltype, optional) – The relative tolerance. Default: \(1e-5\) .
atol (atoltype, optional) – The absolute tolerance. Default: \(1e-8\) .
equal_nan (equalnantype, optional) – (bool), attribute 2 for allclose op.
name (str, optional) – Name for the operation. For more information, please refer to Name. Default: None.
- Returns
-
The output tensor, it’s data type is bool.
- Return type
-
Tensor
Examples
import paddle x = paddle.to_tensor([10000., 1e-07]) y = paddle.to_tensor([10000.1, 1e-08]) result1 = paddle.allclose(x, y, rtol=1e-05, atol=1e-08, equal_nan=False, name="ignore_nan") # False result2 = paddle.allclose(x, y, rtol=1e-05, atol=1e-08, equal_nan=True, name="equal_nan") # False x = paddle.to_tensor([1.0, float('nan')]) y = paddle.to_tensor([1.0, float('nan')]) result1 = paddle.allclose(x, y, rtol=1e-05, atol=1e-08, equal_nan=False, name="ignore_nan") # False result2 = paddle.allclose(x, y, rtol=1e-05, atol=1e-08, equal_nan=True, name="equal_nan") # True
-
amax
(
axis=None,
keepdim=False,
name=None
)
[source]
amax¶
-
Computes the maximum of tensor elements over the given axis.
Note
The difference between max and amax is: If there are multiple maximum elements, amax evenly distributes gradient between these equal values, while max propagates gradient to all of them.
- Parameters
-
x (Tensor) – A tensor, the data type is float32, float64, int32, int64, the dimension is no more than 4.
axis (int|list|tuple, optional) – The axis along which the maximum is computed. If
None
, compute the maximum over all elements of x and return a Tensor with a single element, otherwise must be in the range \([-x.ndim(x), x.ndim(x))\). If \(axis[i] < 0\), the axis to reduce is \(x.ndim + axis[i]\).keepdim (bool, optional) – Whether to reserve the reduced dimension in the output Tensor. The result tensor will have one fewer dimension than the x unless
keepdim
is true, default value is False.name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, results of maximum on the specified axis of input tensor, it’s data type is the same as x.
Examples
import paddle # data_x is a Tensor with shape [2, 4] with multiple maximum elements # the axis is a int element x = paddle.to_tensor([[0.1, 0.9, 0.9, 0.9], [0.9, 0.9, 0.6, 0.7]], dtype='float64', stop_gradient=False) # There are 5 maximum elements: # 1) amax evenly distributes gradient between these equal values, # thus the corresponding gradients are 1/5=0.2; # 2) while max propagates gradient to all of them, # thus the corresponding gradient are 1. result1 = paddle.amax(x) result1.backward() print(result1, x.grad) # 0.9, [[0., 0.2, 0.2, 0.2], [0.2, 0.2, 0., 0.]] x.clear_grad() result1_max = paddle.max(x) result1_max.backward() print(result1_max, x.grad) # 0.9, [[0., 1.0, 1.0, 1.0], [1.0, 1.0, 0., 0.]] ############################### x.clear_grad() result2 = paddle.amax(x, axis=0) result2.backward() print(result2, x.grad) #[0.9, 0.9, 0.9, 0.9], [[0., 0.5, 1., 1.], [1., 0.5, 0., 0.]] x.clear_grad() result3 = paddle.amax(x, axis=-1) result3.backward() print(result3, x.grad) #[0.9, 0.9], [[0., 0.3333, 0.3333, 0.3333], [0.5, 0.5, 0., 0.]] x.clear_grad() result4 = paddle.amax(x, axis=1, keepdim=True) result4.backward() print(result4, x.grad) #[[0.9], [0.9]], [[0., 0.3333, 0.3333, 0.3333.], [0.5, 0.5, 0., 0.]] # data_y is a Tensor with shape [2, 2, 2] # the axis is list y = paddle.to_tensor([[[0.1, 0.9], [0.9, 0.9]], [[0.9, 0.9], [0.6, 0.7]]], dtype='float64', stop_gradient=False) result5 = paddle.amax(y, axis=[1, 2]) result5.backward() print(result5, y.grad) #[0.9., 0.9], [[[0., 0.3333], [0.3333, 0.3333]], [[0.5, 0.5], [0., 1.]]] y.clear_grad() result6 = paddle.amax(y, axis=[0, 1]) result6.backward() print(result6, y.grad) #[0.9., 0.9], [[[0., 0.3333], [0.5, 0.3333]], [[0.5, 0.3333], [1., 1.]]]
-
amin
(
axis=None,
keepdim=False,
name=None
)
[source]
amin¶
-
Computes the minimum of tensor elements over the given axis
Note
The difference between min and amin is: If there are multiple minimum elements, amin evenly distributes gradient between these equal values, while min propagates gradient to all of them.
- Parameters
-
x (Tensor) – A tensor, the data type is float32, float64, int32, int64, the dimension is no more than 4.
axis (int|list|tuple, optional) – The axis along which the minimum is computed. If
None
, compute the minimum over all elements of x and return a Tensor with a single element, otherwise must be in the range \([-x.ndim, x.ndim)\). If \(axis[i] < 0\), the axis to reduce is \(x.ndim + axis[i]\).keepdim (bool, optional) – Whether to reserve the reduced dimension in the output Tensor. The result tensor will have one fewer dimension than the x unless
keepdim
is true, default value is False.name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, results of minimum on the specified axis of input tensor, it’s data type is the same as input’s Tensor.
Examples
import paddle # data_x is a Tensor with shape [2, 4] with multiple minimum elements # the axis is a int element x = paddle.to_tensor([[0.2, 0.1, 0.1, 0.1], [0.1, 0.1, 0.6, 0.7]], dtype='float64', stop_gradient=False) # There are 5 minimum elements: # 1) amin evenly distributes gradient between these equal values, # thus the corresponding gradients are 1/5=0.2; # 2) while min propagates gradient to all of them, # thus the corresponding gradient are 1. result1 = paddle.amin(x) result1.backward() print(result1, x.grad) # 0.1, [[0., 0.2, 0.2, 0.2], [0.2, 0.2, 0., 0.]] x.clear_grad() result1_min = paddle.min(x) result1_min.backward() print(result1_min, x.grad) # 0.1, [[0., 1.0, 1.0, 1.0], [1.0, 1.0, 0., 0.]] ############################### x.clear_grad() result2 = paddle.amin(x, axis=0) result2.backward() print(result2, x.grad) #[0.1, 0.1, 0.1, 0.1], [[0., 0.5, 1., 1.], [1., 0.5, 0., 0.]] x.clear_grad() result3 = paddle.amin(x, axis=-1) result3.backward() print(result3, x.grad) #[0.1, 0.1], [[0., 0.3333, 0.3333, 0.3333], [0.5, 0.5, 0., 0.]] x.clear_grad() result4 = paddle.amin(x, axis=1, keepdim=True) result4.backward() print(result4, x.grad) #[[0.1], [0.1]], [[0., 0.3333, 0.3333, 0.3333.], [0.5, 0.5, 0., 0.]] # data_y is a Tensor with shape [2, 2, 2] # the axis is list y = paddle.to_tensor([[[0.2, 0.1], [0.1, 0.1]], [[0.1, 0.1], [0.6, 0.7]]], dtype='float64', stop_gradient=False) result5 = paddle.amin(y, axis=[1, 2]) result5.backward() print(result5, y.grad) #[0.1., 0.1], [[[0., 0.3333], [0.3333, 0.3333]], [[0.5, 0.5], [0., 1.]]] y.clear_grad() result6 = paddle.amin(y, axis=[0, 1]) result6.backward() print(result6, y.grad) #[0.1., 0.1], [[[0., 0.3333], [0.5, 0.3333]], [[0.5, 0.3333], [1., 1.]]]
-
angle
(
name=None
)
[source]
angle¶
-
Element-wise angle of complex numbers. For non-negative real numbers, the angle is 0 while for negative real numbers, the angle is \(\pi\).
- Equation:
-
\[angle(x)=arctan2(x.imag, x.real)\]
- Parameters
-
x (Tensor) – An N-D Tensor, the data type is complex64, complex128, or float32, float64 .
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
An N-D Tensor of real data type with the same precision as that of x’s data type.
- Return type
-
Tensor
Examples
import paddle x = paddle.to_tensor([-2, -1, 0, 1]).unsqueeze(-1).astype('float32') y = paddle.to_tensor([-2, -1, 0, 1]).astype('float32') z = x + 1j * y print(z) # Tensor(shape=[4, 4], dtype=complex64, place=Place(cpu), stop_gradient=True, # [[(-2-2j), (-2-1j), (-2+0j), (-2+1j)], # [(-1-2j), (-1-1j), (-1+0j), (-1+1j)], # [-2j , -1j , 0j , 1j ], # [ (1-2j), (1-1j), (1+0j), (1+1j)]]) theta = paddle.angle(z) print(theta) # Tensor(shape=[4, 4], dtype=float32, place=Place(cpu), stop_gradient=True, # [[-2.35619450, -2.67794514, 3.14159274, 2.67794514], # [-2.03444386, -2.35619450, 3.14159274, 2.35619450], # [-1.57079637, -1.57079637, 0. , 1.57079637], # [-1.10714877, -0.78539819, 0. , 0.78539819]])
-
any
(
axis=None,
keepdim=False,
name=None
)
[source]
any¶
-
Computes the
logical or
of tensor elements over the given dimension, and return the result.- Parameters
-
x (Tensor) – An N-D Tensor, the input data type should be bool.
axis (int|list|tuple, optional) – The dimensions along which the
logical or
is compute. IfNone
, and all elements ofx
and return a Tensor with a single element, otherwise must be in the range \([-rank(x), rank(x))\). If \(axis[i] < 0\), the dimension to reduce is \(rank + axis[i]\).keepdim (bool, optional) – Whether to reserve the reduced dimension in the output Tensor. The result Tensor will have one fewer dimension than the
x
unlesskeepdim
is true, default value is False.name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Results the
logical or
on the specified axis of input Tensor x, it’s data type is bool. - Return type
-
Tensor
Examples
import paddle x = paddle.to_tensor([[1, 0], [1, 1]], dtype='int32') x = paddle.assign(x) print(x) x = paddle.cast(x, 'bool') # x is a bool Tensor with following elements: # [[True, False] # [True, True]] # out1 should be True out1 = paddle.any(x) # True print(out1) # out2 should be [True, True] out2 = paddle.any(x, axis=0) # [True, True] print(out2) # keepdim=False, out3 should be [True, True], out.shape should be (2,) out3 = paddle.any(x, axis=-1) # [True, True] print(out3) # keepdim=True, result should be [[True], [True]], out.shape should be (2,1) out4 = paddle.any(x, axis=1, keepdim=True) # [[True], [True]] print(out4)
-
argmax
(
axis=None,
keepdim=False,
dtype='int64',
name=None
)
[source]
argmax¶
-
Computes the indices of the max elements of the input tensor’s element along the provided axis.
- Parameters
-
x (Tensor) – An input N-D Tensor with type float16, float32, float64, int16, int32, int64, uint8.
axis (int, optional) – Axis to compute indices along. The effective range is [-R, R), where R is x.ndim. when axis < 0, it works the same way as axis + R. Default is None, the input x will be into the flatten tensor, and selecting the min value index.
keepdim (bool, optional) – Whether to keep the given axis in output. If it is True, the dimensions will be same as input x and with size one in the axis. Otherwise the output dimentions is one fewer than x since the axis is squeezed. Default is False.
dtype (str|np.dtype, optional) – Data type of the output tensor which can be int32, int64. The default value is
int64
, and it will return the int64 indices.name (str, optional) – For details, please refer to Name. Generally, no setting is required. Default: None.
- Returns
-
Tensor, return the tensor of int32 if set
dtype
is int32, otherwise return the tensor of int64.
Examples
import paddle x = paddle.to_tensor([[5,8,9,5], [0,0,1,7], [6,9,2,4]]) out1 = paddle.argmax(x) print(out1) # 2 out2 = paddle.argmax(x, axis=0) print(out2) # [2, 2, 0, 1] out3 = paddle.argmax(x, axis=-1) print(out3) # [2, 3, 1] out4 = paddle.argmax(x, axis=0, keepdim=True) print(out4) # [[2, 2, 0, 1]]
-
argmin
(
axis=None,
keepdim=False,
dtype='int64',
name=None
)
[source]
argmin¶
-
Computes the indices of the min elements of the input tensor’s element along the provided axis.
- Parameters
-
x (Tensor) – An input N-D Tensor with type float16, float32, float64, int16, int32, int64, uint8.
axis (int, optional) – Axis to compute indices along. The effective range is [-R, R), where R is x.ndim. when axis < 0, it works the same way as axis + R. Default is None, the input x will be into the flatten tensor, and selecting the min value index.
keepdim (bool, optional) – Whether to keep the given axis in output. If it is True, the dimensions will be same as input x and with size one in the axis. Otherwise the output dimentions is one fewer than x since the axis is squeezed. Default is False.
dtype (str, optional) – Data type of the output tensor which can be int32, int64. The default value is ‘int64’, and it will return the int64 indices.
name (str, optional) – For details, please refer to Name. Generally, no setting is required. Default: None.
- Returns
-
Tensor, return the tensor of int32 if set
dtype
is int32, otherwise return the tensor of int64.
Examples
import paddle x = paddle.to_tensor([[5,8,9,5], [0,0,1,7], [6,9,2,4]]) out1 = paddle.argmin(x) print(out1) # 4 out2 = paddle.argmin(x, axis=0) print(out2) # [1, 1, 1, 2] out3 = paddle.argmin(x, axis=-1) print(out3) # [0, 0, 2] out4 = paddle.argmin(x, axis=0, keepdim=True) print(out4) # [[1, 1, 1, 2]]
-
argsort
(
axis=- 1,
descending=False,
name=None
)
[source]
argsort¶
-
Sorts the input along the given axis, and returns the corresponding index tensor for the sorted output values. The default sort algorithm is ascending, if you want the sort algorithm to be descending, you must set the
descending
as True.- Parameters
-
x (Tensor) – An input N-D Tensor with type float16, float32, float64, int16, int32, int64, uint8.
axis (int, optional) – Axis to compute indices along. The effective range is [-R, R), where R is Rank(x). when axis<0, it works the same way as axis+R. Default is -1.
descending (bool, optional) – Descending is a flag, if set to true, algorithm will sort by descending order, else sort by ascending order. Default is false.
name (str, optional) – For details, please refer to Name. Generally, no setting is required. Default: None.
- Returns
-
sorted indices(with the same shape as
x
and with data type int64). - Return type
-
Tensor
Examples
import paddle x = paddle.to_tensor([[[5,8,9,5], [0,0,1,7], [6,9,2,4]], [[5,2,4,2], [4,7,7,9], [1,7,0,6]]], dtype='float32') out1 = paddle.argsort(x, axis=-1) out2 = paddle.argsort(x, axis=0) out3 = paddle.argsort(x, axis=1) print(out1) #[[[0 3 1 2] # [0 1 2 3] # [2 3 0 1]] # [[1 3 2 0] # [0 1 2 3] # [2 0 3 1]]] print(out2) #[[[0 1 1 1] # [0 0 0 0] # [1 1 1 0]] # [[1 0 0 0] # [1 1 1 1] # [0 0 0 1]]] print(out3) #[[[1 1 1 2] # [0 0 2 0] # [2 2 0 1]] # [[2 0 2 0] # [1 1 0 2] # [0 2 1 1]]]
-
as_complex
(
name=None
)
[source]
as_complex¶
-
Transform a real tensor to a complex tensor.
The data type of the input tensor is ‘float32’ or ‘float64’, and the data type of the returned tensor is ‘complex64’ or ‘complex128’, respectively.
The shape of the input tensor is
(* ,2)
, (*
means arbitary shape), i.e. the size of the last axis shoule be 2, which represent the real and imag part of a complex number. The shape of the returned tensor is(*,)
.- Parameters
-
x (Tensor) – The input tensor. Data type is ‘float32’ or ‘float64’.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, The output. Data type is ‘complex64’ or ‘complex128’, with the same precision as the input.
Examples
import paddle x = paddle.arange(12, dtype=paddle.float32).reshape([2, 3, 2]) y = paddle.as_complex(x) print(y) # Tensor(shape=[2, 3], dtype=complex64, place=Place(gpu:0), stop_gradient=True, # [[1j , (2+3j) , (4+5j) ], # [(6+7j) , (8+9j) , (10+11j)]])
-
as_real
(
name=None
)
[source]
as_real¶
-
Transform a complex tensor to a real tensor.
The data type of the input tensor is ‘complex64’ or ‘complex128’, and the data type of the returned tensor is ‘float32’ or ‘float64’, respectively.
When the shape of the input tensor is
(*, )
, (*
means arbitary shape), the shape of the output tensor is(*, 2)
, i.e. the shape of the output is the shape of the input appended by an extra2
.- Parameters
-
x (Tensor) – The input tensor. Data type is ‘complex64’ or ‘complex128’.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, The output. Data type is ‘float32’ or ‘float64’, with the same precision as the input.
Examples
import paddle x = paddle.arange(12, dtype=paddle.float32).reshape([2, 3, 2]) y = paddle.as_complex(x) z = paddle.as_real(y) print(z) # Tensor(shape=[2, 3, 2], dtype=float32, place=Place(gpu:0), stop_gradient=True, # [[[0. , 1. ], # [2. , 3. ], # [4. , 5. ]], # [[6. , 7. ], # [8. , 9. ], # [10., 11.]]])
-
asin
(
name=None
)
[source]
asin¶
-
Arcsine Operator.
\[out = sin^{-1}(x)\]- Parameters
-
x (Tensor) – Input of Asin operator, an N-D Tensor, with data type float32, float64 or float16.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor. Same shape and dtype as input.
Examples
import paddle x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3]) out = paddle.asin(x) print(out) # [-0.41151685 -0.20135792 0.10016742 0.30469265]
-
asinh
(
name=None
)
[source]
asinh¶
-
Asinh Activation Operator.
\[out = asinh(x)\]- Parameters
-
x (Tensor) – Input of Asinh operator, an N-D Tensor, with data type float32, float64 or float16.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor. Output of Asinh operator, a Tensor with shape same as input.
Examples
import paddle x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3]) out = paddle.asinh(x) print(out) # [-0.39003533, -0.19869010, 0.09983408, 0.29567307]
-
astype
(
dtype
)
astype¶
-
Cast a Tensor to a specified data type.
- Parameters
-
dtype – The target data type.
- Returns
-
a new Tensor with target dtype
- Return type
-
Tensor
Examples
import paddle import numpy as np original_tensor = paddle.ones([2, 2]) print("original tensor's dtype is: {}".format(original_tensor.dtype)) new_tensor = original_tensor.astype('float32') print("new tensor's dtype is: {}".format(new_tensor.dtype))
-
atan
(
name=None
)
[source]
atan¶
-
Arctangent Operator.
\[out = tan^{-1}(x)\]- Parameters
-
x (Tensor) – Input of Atan operator, an N-D Tensor, with data type float32, float64 or float16.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor. Same shape and dtype as input x.
Examples
import paddle x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3]) out = paddle.atan(x) print(out) # [-0.38050638 -0.19739556 0.09966865 0.29145679]
-
atanh
(
name=None
)
[source]
atanh¶
-
Atanh Activation Operator.
\[out = atanh(x)\]- Parameters
-
x (Tensor) – Input of Atan operator, an N-D Tensor, with data type float32, float64 or float16.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor. Output of Atanh operator, a Tensor with shape same as input.
Examples
import paddle x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3]) out = paddle.atanh(x) print(out) # [-0.42364895, -0.20273256, 0.10033535, 0.30951962]
-
backward
(
grad_tensor=None,
retain_graph=False
)
backward¶
-
Run backward of current Graph which starts from current Tensor.
The new gradient will accumulate on previous gradient.
You can clear gradient by
Tensor.clear_grad()
.- Parameters
-
grad_tensor (Tensor, optional) – initial gradient values of the current Tensor. If grad_tensor is None,
1.0; (the initial gradient values of the current Tensor would be Tensor filled with) –
None (if grad_tensor is not) –
Tensor. (it must have the same length as the current) –
None. (The default value is) –
retain_graph (bool, optional) – If False, the graph used to compute grads will be freed. If you would like to add more ops to the built graph after calling this method(
backward
), set the parameterretain_graph
to True, then the grads will be retained. Thus, setting it to False is much more memory-efficient. Defaults to False.
- Returns
-
None
- Return type
-
NoneType
Examples
import paddle x = paddle.to_tensor(5., stop_gradient=False) for i in range(5): y = paddle.pow(x, 4.0) y.backward() print("{}: {}".format(i, x.grad)) # 0: [500.] # 1: [1000.] # 2: [1500.] # 3: [2000.] # 4: [2500.] x.clear_grad() print("{}".format(x.grad)) # 0. grad_tensor=paddle.to_tensor(2.) for i in range(5): y = paddle.pow(x, 4.0) y.backward(grad_tensor) print("{}: {}".format(i, x.grad)) # 0: [1000.] # 1: [2000.] # 2: [3000.] # 3: [4000.] # 4: [5000.]
-
bincount
(
weights=None,
minlength=0,
name=None
)
[source]
bincount¶
-
Computes frequency of each value in the input tensor.
- Parameters
-
x (Tensor) – A Tensor with non-negative integer. Should be 1-D tensor.
weights (Tensor, optional) – Weight for each value in the input tensor. Should have the same shape as input. Default is None.
minlength (int, optional) – Minimum number of bins. Should be non-negative integer. Default is 0.
name (str, optional) – The default value is None. Normally there is no need for user to set this property. For more information, please refer to Name.
- Returns
-
The tensor of frequency.
- Return type
-
Tensor
Examples
import paddle x = paddle.to_tensor([1, 2, 1, 4, 5]) result1 = paddle.bincount(x) print(result1) # [0, 2, 1, 0, 1, 1] w = paddle.to_tensor([2.1, 0.4, 0.1, 0.5, 0.5]) result2 = paddle.bincount(x, weights=w) print(result2) # [0., 2.19999981, 0.40000001, 0., 0.50000000, 0.50000000]
-
bitwise_and
(
y,
out=None,
name=None
)
[source]
bitwise_and¶
-
Apply
bitwise_and
on TensorX
andY
.\[Out = X \& Y\]Note
paddle.bitwise_and
supports broadcasting. If you want know more about broadcasting, please refer to please refer to `Introduction to Tensor`_ .- Parameters
-
x (Tensor) – Input Tensor of
bitwise_and
. It is a N-D Tensor of bool, uint8, int8, int16, int32, int64.y (Tensor) – Input Tensor of
bitwise_and
. It is a N-D Tensor of bool, uint8, int8, int16, int32, int64.out (Tensor) – Result of
bitwise_and
. It is a N-D Tensor with the same data type of input Tensor.
- Returns
-
Result of
bitwise_and
. It is a N-D Tensor with the same data type of input Tensor. - Return type
-
Tensor
Examples
import paddle x = paddle.to_tensor([-5, -1, 1]) y = paddle.to_tensor([4, 2, -3]) res = paddle.bitwise_and(x, y) print(res) # [0, 2, 1]
-
bitwise_not
(
out=None,
name=None
)
[source]
bitwise_not¶
-
Apply
bitwise_not
on TensorX
.\[Out = \sim X\]Note
paddle.bitwise_not
supports broadcasting. If you want know more about broadcasting, please refer to please refer to `Introduction to Tensor`_ .- Parameters
-
x (Tensor) – Input Tensor of
bitwise_not
. It is a N-D Tensor of bool, uint8, int8, int16, int32, int64.out (Tensor) – Result of
bitwise_not
. It is a N-D Tensor with the same data type of input Tensor.
- Returns
-
Result of
bitwise_not
. It is a N-D Tensor with the same data type of input Tensor. - Return type
-
Tensor
Examples
import paddle x = paddle.to_tensor([-5, -1, 1]) res = paddle.bitwise_not(x) print(res) # [4, 0, -2]
-
bitwise_or
(
y,
out=None,
name=None
)
[source]
bitwise_or¶
-
Apply
bitwise_or
on TensorX
andY
.\[Out = X | Y\]Note
paddle.bitwise_or
supports broadcasting. If you want know more about broadcasting, please refer to please refer to `Introduction to Tensor`_ .- Parameters
-
x (Tensor) – Input Tensor of
bitwise_or
. It is a N-D Tensor of bool, uint8, int8, int16, int32, int64.y (Tensor) – Input Tensor of
bitwise_or
. It is a N-D Tensor of bool, uint8, int8, int16, int32, int64.out (Tensor) – Result of
bitwise_or
. It is a N-D Tensor with the same data type of input Tensor.
- Returns
-
Result of
bitwise_or
. It is a N-D Tensor with the same data type of input Tensor. - Return type
-
Tensor
Examples
import paddle x = paddle.to_tensor([-5, -1, 1]) y = paddle.to_tensor([4, 2, -3]) res = paddle.bitwise_or(x, y) print(res) # [-1, -1, -3]
-
bitwise_xor
(
y,
out=None,
name=None
)
[source]
bitwise_xor¶
-
Apply
bitwise_xor
on TensorX
andY
.\[Out = X ^\wedge Y\]Note
paddle.bitwise_xor
supports broadcasting. If you want know more about broadcasting, please refer to please refer to `Introduction to Tensor`_ .- Parameters
-
x (Tensor) – Input Tensor of
bitwise_xor
. It is a N-D Tensor of bool, uint8, int8, int16, int32, int64.y (Tensor) – Input Tensor of
bitwise_xor
. It is a N-D Tensor of bool, uint8, int8, int16, int32, int64.out (Tensor) – Result of
bitwise_xor
. It is a N-D Tensor with the same data type of input Tensor.
- Returns
-
Result of
bitwise_xor
. It is a N-D Tensor with the same data type of input Tensor. - Return type
-
Tensor
Examples
import paddle x = paddle.to_tensor([-5, -1, 1]) y = paddle.to_tensor([4, 2, -3]) res = paddle.bitwise_xor(x, y) print(res) # [-1, -3, -4]
-
bmm
(
y,
name=None
)
[source]
bmm¶
-
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.
name (str|None) – A name for this layer(optional). If set None, the layer will be named automatically.
- Returns
-
The product Tensor.
- Return type
-
Tensor
Examples
import paddle # In imperative mode: # size x: (2, 2, 3) and y: (2, 3, 2) x = paddle.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 = paddle.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]]]) out = paddle.bmm(x, y) # Tensor(shape=[2, 2, 2], dtype=float32, place=Place(cpu), stop_gradient=True, # [[[6. , 6. ], # [12., 12.]], # [[45., 45.], # [60., 60.]]])
-
broadcast_shape
(
y_shape
)
[source]
broadcast_shape¶
-
The function returns the shape of doing operation with broadcasting on tensors of x_shape and y_shape.
Note
If you want know more about broadcasting, please refer to `Introduction to Tensor`_ .
- Parameters
-
x_shape (list[int]|tuple[int]) – A shape of tensor.
y_shape (list[int]|tuple[int]) – A shape of tensor.
- Returns
-
list[int], the result shape.
Examples
import paddle shape = paddle.broadcast_shape([2, 1, 3], [1, 3, 1]) # [2, 3, 3] # shape = paddle.broadcast_shape([2, 1, 3], [3, 3, 1]) # ValueError (terminated with error message).
-
broadcast_tensors
(
name=None
)
[source]
broadcast_tensors¶
-
Broadcast a list of tensors following broadcast semantics
Note
If you want know more about broadcasting, please refer to `Introduction to Tensor`_ .
- Parameters
-
input (list|tuple) –
input
is a Tensor list or Tensor tuple which is with data type bool, float16, float32, float64, int32, int64. All the Tensors ininput
must have same data type. Currently we only support tensors with rank no greater than 5.name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
list(Tensor), The list of broadcasted tensors following the same order as
input
.
Examples
import paddle x1 = paddle.rand([1, 2, 3, 4]).astype('float32') x2 = paddle.rand([1, 2, 1, 4]).astype('float32') x3 = paddle.rand([1, 1, 3, 1]).astype('float32') out1, out2, out3 = paddle.broadcast_tensors(input=[x1, x2, x3]) # out1, out2, out3: tensors broadcasted from x1, x2, x3 with shape [1,2,3,4]
-
broadcast_to
(
shape,
name=None
)
[source]
broadcast_to¶
-
Broadcast the input tensor to a given shape.
Both the number of dimensions of
x
and the number of elements inshape
should be less than or equal to 6. The dimension to broadcast to must have a value 0.- Parameters
-
x (Tensor) – The input tensor, its data type is bool, float16, float32, float64, int32 or int64.
shape (list|tuple|Tensor) – The result shape after broadcasting. The data type is int32. If shape is a list or tuple, all its elements should be integers or 0-D or 1-D Tensors with the data type int32. If shape is a Tensor, it should be an 1-D Tensor with the data type int32. The value -1 in shape means keeping the corresponding dimension unchanged.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
N-D Tensor, A Tensor with the given shape. The data type is the same as
x
.
Examples
import paddle data = paddle.to_tensor([1, 2, 3], dtype='int32') out = paddle.broadcast_to(data, shape=[2, 3]) print(out) # [[1, 2, 3], [1, 2, 3]]
-
bucketize
(
sorted_sequence,
out_int32=False,
right=False,
name=None
)
[source]
bucketize¶
-
This API is used to find the index of the corresponding 1D tensor sorted_sequence in the innermost dimension based on the given x.
- Parameters
-
x (Tensor) – An input N-D tensor value with type int32, int64, float32, float64.
sorted_sequence (Tensor) – An input 1-D tensor with type int32, int64, float32, float64. The value of the tensor monotonically increases in the innermost dimension.
out_int32 (bool, optional) – Data type of the output tensor which can be int32, int64. The default value is False, and it indicates that the output data type is int64.
right (bool, optional) – Find the upper or lower bounds of the sorted_sequence range in the innermost dimension based on the given x. If the value of the sorted_sequence is nan or inf, return the size of the innermost dimension. The default value is False and it shows the lower bounds.
name (str, optional) – The default value is None. Normally there is no need for user to set this property. For more information, please refer to Name.
- Returns
-
Tensor (the same sizes of the x), return the tensor of int32 if set
out_int32
is True, otherwise return the tensor of int64.
Examples
import paddle sorted_sequence = paddle.to_tensor([2, 4, 8, 16], dtype='int32') x = paddle.to_tensor([[0, 8, 4, 16], [-1, 2, 8, 4]], dtype='int32') out1 = paddle.bucketize(x, sorted_sequence) print(out1) # Tensor(shape=[2, 4], dtype=int64, place=CPUPlace, stop_gradient=True, # [[0, 2, 1, 3], # [0, 0, 2, 1]]) out2 = paddle.bucketize(x, sorted_sequence, right=True) print(out2) # Tensor(shape=[2, 4], dtype=int64, place=CPUPlace, stop_gradient=True, # [[0, 3, 2, 4], # [0, 1, 3, 2]]) out3 = x.bucketize(sorted_sequence) print(out3) # Tensor(shape=[2, 4], dtype=int64, place=CPUPlace, stop_gradient=True, # [[0, 2, 1, 3], # [0, 0, 2, 1]]) out4 = x.bucketize(sorted_sequence, right=True) print(out4) # Tensor(shape=[2, 4], dtype=int64, place=CPUPlace, stop_gradient=True, # [[0, 3, 2, 4], # [0, 1, 3, 2]])
-
cast
(
dtype
)
[source]
cast¶
-
Take in the Tensor
x
withx.dtype
and cast it to the output withdtype
. It’s meaningless if the output dtype equals the input dtype, but it’s fine if you do so.- Parameters
-
x (Tensor) – An input N-D Tensor with data type bool, float16, float32, float64, int32, int64, uint8.
dtype (np.dtype|str) – Data type of the output: bool, float16, float32, float64, int8, int32, int64, uint8.
- Returns
-
Tensor, A Tensor with the same shape as input’s.
Examples
import paddle x = paddle.to_tensor([2, 3, 4], 'float64') y = paddle.cast(x, 'uint8')
-
cdist
(
y,
p=2.0,
compute_mode='use_mm_for_euclid_dist_if_necessary',
name=None
)
[source]
cdist¶
-
Compute the p-norm distance between each pair of the two collections of inputs.
This function is equivalent to scipy.spatial.distance.cdist(input,’minkowski’, p=p) if \(p \in (0, \infty)\). When \(p = 0\) it is equivalent to scipy.spatial.distance.cdist(input, ‘hamming’) * M. When \(p = \infty\), the closest scipy function is scipy.spatial.distance.cdist(xn, lambda x, y: np.abs(x - y).max()).
- Parameters
-
x (Tensor) – A tensor with shape \(B \times P \times M\).
y (Tensor) – A tensor with shape \(B \times R \times M\).
p (float, optional) – The value for the p-norm distance to calculate between each vector pair. Default: \(2.0\).
compute_mode (str, optional) –
The mode for compute distance.
use_mm_for_euclid_dist_if_necessary
, for p = 2.0 and (P > 25 or R > 25), it will use matrix multiplication to calculate euclid distance if possible.use_mm_for_euclid_dist
, for p = 2.0, it will use matrix multiplication to calculate euclid distance.donot_use_mm_for_euclid_dist
, it will not use matrix multiplication to calculate euclid distance.
Default:
use_mm_for_euclid_dist_if_necessary
.name (str, optional) – For details, please refer to Name. Generally, no setting is required. Default: None.
- Returns
-
Tensor, the dtype is same as input tensor.
If x has shape \(B \times P \times M\) and y has shape \(B \times R \times M\) then the output will have shape \(B \times P \times R\).
Examples
import paddle x = paddle.to_tensor([[0.9041, 0.0196], [-0.3108, -2.4423], [-0.4821, 1.059]], dtype=paddle.float32) y = paddle.to_tensor([[-2.1763, -0.4713], [-0.6986, 1.3702]], dtype=paddle.float32) distance = paddle.cdist(x, y) print(distance) # Tensor(shape=[3, 2], dtype=float32, place=Place(gpu:0), stop_gradient=True, # [[3.1193, 2.0959], [2.7138, 3.8322], [2.2830, 0.3791]])
-
ceil
(
name=None
)
[source]
ceil¶
-
Ceil Operator. Computes ceil of x element-wise.
\[out = \left \lceil x \right \rceil\]- Parameters
-
x (Tensor) – Input of Ceil operator, an N-D Tensor, with data type float32, float64 or float16.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor. Output of Ceil operator, a Tensor with shape same as input.
Examples
import paddle x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3]) out = paddle.ceil(x) print(out) # [-0. -0. 1. 1.]
-
ceil_
(
name=None
)
ceil_¶
-
Inplace version of
ceil
API, the output Tensor will be inplaced with inputx
. Please refer to api_fluid_layers_ceil.
-
cholesky
(
upper=False,
name=None
)
[source]
cholesky¶
-
Computes the Cholesky decomposition of one symmetric positive-definite matrix or batches of symmetric positive-definite matrice.
If upper is True, the decomposition has the form \(A = U^{T}U\) , and the returned matrix \(U\) is upper-triangular. Otherwise, the decomposition has the form \(A = LL^{T}\) , and the returned matrix \(L\) is lower-triangular.
- Parameters
-
x (Tensor) – The input tensor. Its shape should be [*, M, M], where * is zero or more batch dimensions, and matrices on the inner-most 2 dimensions all should be symmetric positive-definite. Its data type should be float32 or float64.
upper (bool) – The flag indicating whether to return upper or lower triangular matrices. Default: False.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, A Tensor with same shape and data type as x. It represents triangular matrices generated by Cholesky decomposition.
Examples
import paddle a = paddle.rand([3, 3], dtype="float32") a_t = paddle.transpose(a, [1, 0]) x = paddle.matmul(a, a_t) + 1e-03 out = paddle.linalg.cholesky(x, upper=False) print(out)
-
cholesky_solve
(
y,
upper=False,
name=None
)
cholesky_solve¶
-
Solves a linear system of equations A @ X = B, given A’s Cholesky factor matrix u and matrix B.
Input x and y is 2D matrices or batches of 2D matrices. If the inputs are batches, the outputs is also batches.
- Parameters
-
x (Tensor) – The input matrix which is upper or lower triangular Cholesky factor of square matrix A. Its shape should be [*, M, M], where * is zero or more batch dimensions. Its data type should be float32 or float64.
y (Tensor) – Multiple right-hand sides of system of equations. Its shape should be [*, M, K], where * is zero or more batch dimensions. Its data type should be float32 or float64.
upper (bool, optional) – whether to consider the Cholesky factor as a lower or upper triangular matrix. Default: False.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
The solution of the system of equations. Its data type is the same as that of x.
- Return type
-
Tensor
Examples
import paddle u = paddle.to_tensor([[1, 1, 1], [0, 2, 1], [0, 0,-1]], dtype="float64") b = paddle.to_tensor([[0], [-9], [5]], dtype="float64") out = paddle.linalg.cholesky_solve(b, u, upper=True) print(out) # [-2.5, -7, 9.5]
-
chunk
(
chunks,
axis=0,
name=None
)
[source]
chunk¶
-
Split the input tensor into multiple sub-Tensors.
- Parameters
-
x (Tensor) – A N-D Tensor. The data type is bool, float16, float32, float64, int32 or int64.
chunks (int) – The number of tensor to be split along the certain axis.
axis (int|Tensor, optional) – The axis along which to split, it can be a integer or a
0-D Tensor
with shape [] and data typeint32
orint64
. If :math::axis < 0, the axis to split along is \(rank(x) + axis\). Default is 0.name (str, optional) – The default value is None. Normally there is no need for user to set this property. For more information, please refer to Name .
- Returns
-
list(Tensor), The list of segmented Tensors.
Examples
import paddle x = paddle.rand([3, 9, 5]) out0, out1, out2 = paddle.chunk(x, chunks=3, axis=1) # out0.shape [3, 3, 5] # out1.shape [3, 3, 5] # out2.shape [3, 3, 5] # axis is negative, the real axis is (rank(x) + axis) which real # value is 1. out0, out1, out2 = paddle.chunk(x, chunks=3, axis=-2) # out0.shape [3, 3, 5] # out1.shape [3, 3, 5] # out2.shape [3, 3, 5]
-
clear_grad
(
)
clear_grad¶
-
The alias of clear_gradient().
-
clip
(
min=None,
max=None,
name=None
)
[source]
clip¶
-
This operator clip all elements in input into the range [ min, max ] and return a resulting tensor as the following equation:
\[Out = MIN(MAX(x, min), max)\]- Parameters
-
x (Tensor) – An N-D Tensor with data type float16, float32, float64, int32 or int64.
min (float|int|Tensor, optional) – The lower bound with type
float
,int
or a0-D Tensor
with shape [] and typeint32
,float16
,float32
,float64
.max (float|int|Tensor, optional) – The upper bound with type
float
,int
or a0-D Tensor
with shape [] and typeint32
,float16
,float32
,float64
.name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
A Tensor with the same data type and data shape as input.
- Return type
-
Tensor
Examples
import paddle x1 = paddle.to_tensor([[1.2, 3.5], [4.5, 6.4]], 'float32') out1 = paddle.clip(x1, min=3.5, max=5.0) out2 = paddle.clip(x1, min=2.5) print(out1) # [[3.5, 3.5] # [4.5, 5.0]] print(out2) # [[2.5, 3.5] # [[4.5, 6.4]
-
clip_
(
min=None,
max=None,
name=None
)
clip_¶
-
Inplace version of
clip
API, the output Tensor will be inplaced with inputx
. Please refer to api_tensor_clip.
-
concat
(
axis=0,
name=None
)
[source]
concat¶
-
Concatenates the input along the axis. It doesn’t support 0-D Tensor because it requires a certain axis, and 0-D Tensor doesn’t have any axis.
- Parameters
-
x (list|tuple) –
x
is a Tensor list or Tensor tuple which is with data type bool, float16, float32, float64, int32, int64, int8, uint8. All the Tensors inx
must have same data type.axis (int|Tensor, optional) – Specify the axis to operate on the input Tensors. Tt should be integer or 0-D int Tensor with shape []. The effective range is [-R, R), where R is Rank(x). When
axis < 0
, it works the same way asaxis+R
. Default is 0.name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, A Tensor with the same data type as
x
.
Examples
import paddle x1 = paddle.to_tensor([[1, 2, 3], [4, 5, 6]]) x2 = paddle.to_tensor([[11, 12, 13], [14, 15, 16]]) x3 = paddle.to_tensor([[21, 22], [23, 24]]) zero = paddle.full(shape=[1], dtype='int32', fill_value=0) # When the axis is negative, the real axis is (axis + Rank(x)) # As follow, axis is -1, Rank(x) is 2, the real axis is 1 out1 = paddle.concat(x=[x1, x2, x3], axis=-1) out2 = paddle.concat(x=[x1, x2], axis=0) out3 = paddle.concat(x=[x1, x2], axis=zero) # out1 # [[ 1 2 3 11 12 13 21 22] # [ 4 5 6 14 15 16 23 24]] # out2 out3 # [[ 1 2 3] # [ 4 5 6] # [11 12 13] # [14 15 16]]
-
cond
(
p=None,
name=None
)
cond¶
-
Computes the condition number of a matrix or batches of matrices with respect to a matrix norm
p
.- Parameters
-
x (Tensor) – The input tensor could be tensor of shape
(*, m, n)
where*
is zero or more batch dimensions forp
in(2, -2)
, or of shape(*, n, n)
where every matrix is invertible for any supportedp
. And the input data type could befloat32
orfloat64
.p (float|string, optional) – Order of the norm. Supported values are fro, nuc, 1, -1, 2, -2, inf, -inf. Default value is None, meaning that the order of the norm is 2.
name (str, optional) – The default value is None. Normally there is no need for user to set this property. For more information, please refer to Name.
- Returns
-
computing results of condition number, its data type is the same as input Tensor
x
. - Return type
-
Tensor
Examples
import paddle x = paddle.to_tensor([[1., 0, -1], [0, 1, 0], [1, 0, 1]]) # compute conditional number when p is None out = paddle.linalg.cond(x) # Tensor(shape=[], dtype=float32, place=Place(gpu:0), stop_gradient=True, # 1.41421342) # compute conditional number when order of the norm is 'fro' out_fro = paddle.linalg.cond(x, p='fro') # Tensor(shape=[], dtype=float32, place=Place(gpu:0), stop_gradient=True, # 3.16227770) # compute conditional number when order of the norm is 'nuc' out_nuc = paddle.linalg.cond(x, p='nuc') # Tensor(shape=[], dtype=float32, place=Place(gpu:0), stop_gradient=True, # 9.24263859) # compute conditional number when order of the norm is 1 out_1 = paddle.linalg.cond(x, p=1) # Tensor(shape=[], dtype=float32, place=Place(gpu:0), stop_gradient=True, # 2.) # compute conditional number when order of the norm is -1 out_minus_1 = paddle.linalg.cond(x, p=-1) # Tensor(shape=[], dtype=float32, place=Place(gpu:0), stop_gradient=True, # 1.) # compute conditional number when order of the norm is 2 out_2 = paddle.linalg.cond(x, p=2) # Tensor(shape=[], dtype=float32, place=Place(gpu:0), stop_gradient=True, # 1.41421342) # compute conditional number when order of the norm is -1 out_minus_2 = paddle.linalg.cond(x, p=-2) # Tensor(shape=[], dtype=float32, place=Place(gpu:0), stop_gradient=True, # 0.70710683) # compute conditional number when order of the norm is inf out_inf = paddle.linalg.cond(x, p=float("inf")) # Tensor(shape=[], dtype=float32, place=Place(gpu:0), stop_gradient=True, # 2.) # compute conditional number when order of the norm is -inf out_minus_inf = paddle.linalg.cond(x, p=-float("inf")) # Tensor(shape=[], dtype=float32, place=Place(gpu:0), stop_gradient=True, # 1.) a = paddle.randn([2, 4, 4]) # Tensor(shape=[2, 4, 4], dtype=float32, place=Place(gpu:0), stop_gradient=True, # [[[-0.06784091, -0.07095790, 1.31792855, -0.58959651], # [ 0.20818676, -0.85640615, -0.89998871, -1.47439921], # [-0.49132481, 0.42250812, -0.77383220, -2.19794774], # [-0.33551720, -1.70003879, -1.09795380, -0.63737559]], # [[ 1.12026262, -0.16119350, -1.21157813, 2.74383283], # [-0.15999718, 0.18798758, -0.69392562, 1.35720372], # [-0.53013402, -2.26304483, 1.40843511, -1.02288902], # [ 0.69533503, 2.05261683, -0.02251151, -1.43127477]]]) a_cond_fro = paddle.linalg.cond(a, p='fro') # Tensor(shape=[2], dtype=float32, place=Place(gpu:0), stop_gradient=True, # [8.86691189 , 75.23817444]) b = paddle.randn([2, 3, 4]) # Tensor(shape=[2, 3, 4], dtype=float32, place=Place(gpu:0), stop_gradient=True, # [[[-0.43754861, 1.80796063, -0.78729683, -1.82264030], # [-0.27670753, 0.06620564, 0.29072434, -0.31155765], # [ 0.34123746, -0.05444612, 0.05001324, -1.46877074]], # [[-0.64331555, -1.51103854, -1.26277697, -0.68024760], # [ 2.59375715, -1.06665540, 0.96575671, -0.73330832], # [-0.47064447, -0.23945692, -0.95150250, -1.07125998]]]) b_cond_2 = paddle.linalg.cond(b, p=2) # Tensor(shape=[2], dtype=float32, place=Place(gpu:0), stop_gradient=True, # [6.64228773, 3.89068866])
-
conj
(
name=None
)
[source]
conj¶
-
This function computes the conjugate of the Tensor elementwisely.
- Parameters
-
x (Tensor) – The input Tensor which hold the complex numbers. Optional data types are:float16, complex64, complex128, float32, float64, int32 or int64.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
The conjugate of input. The shape and data type is the same with input. If the elements of tensor is real type such as float32, float64, int32 or int64, the out is the same with input.
- Return type
-
out (Tensor)
Examples
import paddle data=paddle.to_tensor([[1+1j, 2+2j, 3+3j], [4+4j, 5+5j, 6+6j]]) #Tensor(shape=[2, 3], dtype=complex64, place=CUDAPlace(0), stop_gradient=True, # [[(1+1j), (2+2j), (3+3j)], # [(4+4j), (5+5j), (6+6j)]]) conj_data=paddle.conj(data) #Tensor(shape=[2, 3], dtype=complex64, place=CUDAPlace(0), stop_gradient=True, # [[(1-1j), (2-2j), (3-3j)], # [(4-4j), (5-5j), (6-6j)]])
-
corrcoef
(
rowvar=True,
name=None
)
corrcoef¶
-
A correlation coefficient matrix indicate the correlation of each pair variables in the input matrix. For example, for an N-dimensional samples X=[x1,x2,…xN]T, then the correlation coefficient matrix element Rij is the correlation of xi and xj. The element Rii is the covariance of xi itself.
The relationship between the correlation coefficient matrix R and the covariance matrix C, is
\[R_{ij} = \frac{ C_{ij} } { \sqrt{ C_{ii} * C_{jj} } }\]The values of R are between -1 and 1.
- Parameters
-
x (Tensor) – A N-D(N<=2) Tensor containing multiple variables and observations. By default, each row of x represents a variable. Also see rowvar below.
rowvar (Bool, optional) – If rowvar is True (default), then each row represents a variable, with observations in the columns. Default: True.
name (str, optional) – Name of the output. Default is None. It’s used to print debug info for developers. Details: Name.
- Returns
-
The correlation coefficient matrix of the variables.
Examples
import paddle xt = paddle.rand((3,4)) print(paddle.linalg.corrcoef(xt)) # Tensor(shape=[3, 3], dtype=float32, place=Place(cpu), stop_gradient=True, # [[ 1. , -0.73702252, 0.66228950], # [-0.73702258, 1. , -0.77104872], # [ 0.66228974, -0.77104825, 1. ]])
-
cos
(
name=None
)
[source]
cos¶
-
Cosine Operator. Computes cosine of x element-wise.
Input range is (-inf, inf) and output range is [-1,1].
\[out = cos(x)\]- Parameters
-
x (Tensor) – Input of Cos operator, an N-D Tensor, with data type float32, float64 or float16.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor. Output of Cos operator, a Tensor with shape same as input.
Examples
import paddle x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3]) out = paddle.cos(x) print(out) # [0.92106099 0.98006658 0.99500417 0.95533649]
-
cosh
(
name=None
)
[source]
cosh¶
-
Cosh Activation Operator.
Input range (-inf, inf), output range (1, inf).
\[out = \frac{exp(x)+exp(-x)}{2}\]- Parameters
-
x (Tensor) – Input of Cosh operator, an N-D Tensor, with data type float32, float64 or float16.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor. Output of Cosh operator, a Tensor with shape same as input.
Examples
import paddle x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3]) out = paddle.cosh(x) print(out) # [1.08107237 1.02006676 1.00500417 1.04533851]
-
count_nonzero
(
axis=None,
keepdim=False,
name=None
)
[source]
count_nonzero¶
-
Counts the number of non-zero values in the tensor x along the specified axis.
- Parameters
-
x (Tensor) – An N-D Tensor, the data type is bool, float16, float32, float64, int32 or int64.
axis (int|list|tuple, optional) – The dimensions along which the sum is performed. If
None
, sum all elements ofx
and return a Tensor with a single element, otherwise must be in the range \([-rank(x), rank(x))\). If \(axis[i] < 0\), the dimension to reduce is \(rank + axis[i]\).keepdim (bool, optional) – Whether to reserve the reduced dimension in the output Tensor. The result Tensor will have one fewer dimension than the
x
unlesskeepdim
is true, default value is False.name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Results of count operation on the specified axis of input Tensor x, it’s data type is ‘int64’.
- Return type
-
Tensor
Examples
import paddle # x is a 2-D Tensor: x = paddle.to_tensor([[0., 1.1, 1.2], [0., 0., 1.3], [0., 0., 0.]]) out1 = paddle.count_nonzero(x) # 3 out2 = paddle.count_nonzero(x, axis=0) # [0, 1, 2] out3 = paddle.count_nonzero(x, axis=0, keepdim=True) # [[0, 1, 2]] out4 = paddle.count_nonzero(x, axis=1) # [2, 1, 0] out5 = paddle.count_nonzero(x, axis=1, keepdim=True) #[[2], # [1], # [0]] # y is a 3-D Tensor: y = paddle.to_tensor([[[0., 1.1, 1.2], [0., 0., 1.3], [0., 0., 0.]], [[0., 2.5, 2.6], [0., 0., 2.4], [2.1, 2.2, 2.3]]]) out6 = paddle.count_nonzero(y, axis=[1, 2]) # [3, 6] out7 = paddle.count_nonzero(y, axis=[0, 1]) # [1, 3, 5]
-
cov
(
rowvar=True,
ddof=True,
fweights=None,
aweights=None,
name=None
)
cov¶
-
Estimate the covariance matrix of the input variables, given data and weights.
A covariance matrix is a square matrix, indicate the covariance of each pair variables in the input matrix. For example, for an N-dimensional samples X=[x1,x2,…xN]T, then the covariance matrix element Cij is the covariance of xi and xj. The element Cii is the variance of xi itself.
- Parameters
-
x (Tensor) – A N-D(N<=2) Tensor containing multiple variables and observations. By default, each row of x represents a variable. Also see rowvar below.
rowvar (Bool, optional) – If rowvar is True (default), then each row represents a variable, with observations in the columns. Default: True
ddof (Bool, optional) – If ddof=True will return the unbiased estimate, and ddof=False will return the simple average. Default: True
fweights (Tensor, optional) – 1-D Tensor of integer frequency weights; The number of times each observation vector should be repeated. Default: None
aweights (Tensor, optional) – 1-D Tensor of observation vector weights. How important of the observation vector, larger data means this element is more important. Default: None
name (str, optional) – Name of the output. Default is None. It’s used to print debug info for developers. Details: Name
- Returns
-
The covariance matrix Tensor of the variables.
- Return type
-
Tensor
Examples:
import paddle xt = paddle.rand((3, 4)) paddle.linalg.cov(xt) ''' Tensor(shape=[3, 3], dtype=float64, place=CUDAPlace(0), stop_gradient=True, [[0.07918842, 0.06127326, 0.01493049], [0.06127326, 0.06166256, 0.00302668], [0.01493049, 0.00302668, 0.01632146]]) '''
-
create_parameter
(
dtype,
name=None,
attr=None,
is_bias=False,
default_initializer=None
)
[source]
create_parameter¶
-
This function creates 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 of int) – Shape of the parameter
dtype (str) – Data type of the parameter
name (str, optional) – For detailed information, please refer to Name . Usually name is no need to set and None by default.
attr (ParamAttr, optional) – Attributes of the parameter
is_bias (bool, optional) – 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, optional) – Initializer for the parameter
- Returns
-
The created parameter.
Examples
import paddle paddle.enable_static() W = paddle.create_parameter(shape=[784, 200], dtype='float32')
-
create_tensor
(
name=None,
persistable=False
)
create_tensor¶
-
Create a variable, which will hold a Tensor with data type dtype.
- Parameters
-
dtype (string|numpy.dtype) – the data type of Tensor to be created, the data type is bool, float16, float32, float64, int8, int16, int32 and int64.
name (string, optional) – The default value is None. Normally there is no need for user to set this property. For more information, please refer to Name
persistable (bool) – Set the persistable flag of the create tensor. default value is False.
- Returns
-
The tensor to be created according to dtype.
- Return type
-
Variable
Examples
import paddle tensor = paddle.tensor.create_tensor(dtype='float32')
-
cross
(
y,
axis=9,
name=None
)
[source]
cross¶
-
Computes the cross product between two tensors along an axis.
Inputs must have the same shape, and the length of their axes should be equal to 3. If axis is not given, it defaults to the first axis found with the length 3.
- Parameters
-
x (Tensor) – The first input tensor, the data type is float16, float32, float64, int32, int64.
y (Tensor) – The second input tensor, the data type is float16, float32, float64, int32, int64.
axis (int, optional) – The axis along which to compute the cross product. It defaults to be 9 which indicates using the first axis found with the length 3.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor. A Tensor with same data type as x.
Examples
import paddle x = paddle.to_tensor([[1.0, 1.0, 1.0], [2.0, 2.0, 2.0], [3.0, 3.0, 3.0]]) y = paddle.to_tensor([[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]]) z1 = paddle.cross(x, y) # [[-1. -1. -1.] # [ 2. 2. 2.] # [-1. -1. -1.]] z2 = paddle.cross(x, y, axis=1) # [[0. 0. 0.] # [0. 0. 0.] # [0. 0. 0.]]
-
cumprod
(
dim=None,
dtype=None,
name=None
)
[source]
cumprod¶
-
Compute the cumulative product of the input tensor x along a given dimension dim.
Note
The first element of the result is the same as the first element of the input.
- Parameters
-
x (Tensor) – the input tensor need to be cumproded.
dim (int, optional) – the dimension along which the input tensor will be accumulated. It need to be in the range of [-x.rank, x.rank), where x.rank means the dimensions of the input tensor x and -1 means the last dimension.
dtype (str, optional) – The data type of the output tensor, can be float32, float64, int32, int64, complex64, complex128. If specified, the input tensor is casted to dtype before the operation is performed. This is useful for preventing data type overflows. The default value is None.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, the result of cumprod operator.
Examples
import paddle data = paddle.arange(12) data = paddle.reshape(data, (3, 4)) # [[ 0 1 2 3 ] # [ 4 5 6 7 ] # [ 8 9 10 11]] y = paddle.cumprod(data, dim=0) # [[ 0 1 2 3] # [ 0 5 12 21] # [ 0 45 120 231]] y = paddle.cumprod(data, dim=-1) # [[ 0 0 0 0] # [ 4 20 120 840] # [ 8 72 720 7920]] y = paddle.cumprod(data, dim=1, dtype='float64') # [[ 0. 0. 0. 0.] # [ 4. 20. 120. 840.] # [ 8. 72. 720. 7920.]] print(y.dtype) # paddle.float64
-
cumsum
(
axis=None,
dtype=None,
name=None
)
[source]
cumsum¶
-
The cumulative sum of the elements along a given axis.
Note
The first element of the result is the same as the first element of the input.
- Parameters
-
x (Tensor) – The input tensor needed to be cumsumed.
axis (int, optional) – The dimension to accumulate along. -1 means the last dimension. The default (None) is to compute the cumsum over the flattened array.
dtype (str, optional) – The data type of the output tensor, can be float16, float32, float64, int32, int64. If specified, the input tensor is casted to dtype before the operation is performed. This is useful for preventing data type overflows. The default value is None.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, the result of cumsum operator.
Examples
import paddle data = paddle.arange(12) data = paddle.reshape(data, (3, 4)) y = paddle.cumsum(data) # [ 0 1 3 6 10 15 21 28 36 45 55 66] y = paddle.cumsum(data, axis=0) # [[ 0 1 2 3] # [ 4 6 8 10] # [12 15 18 21]] y = paddle.cumsum(data, axis=-1) # [[ 0 1 3 6] # [ 4 9 15 22] # [ 8 17 27 38]] y = paddle.cumsum(data, dtype='float64') print(y.dtype) # paddle.float64
-
cumulative_trapezoid
(
x=None,
dx=None,
axis=- 1,
name=None
)
[source]
cumulative_trapezoid¶
-
Integrate along the given axis using the composite trapezoidal rule. Use the cumsum method
- Parameters
-
y (Tensor) – Input tensor to integrate. It’s data type should be float16, float32, float64.
x (Tensor, optional) – The sample points corresponding to the
y
values, the same type asy
. It is known that the size ofy
is [d_1, d_2, … , d_n] and \(axis=k\), then the size ofx
can only be [d_k] or [d_1, d_2, … , d_n ]. Ifx
is None, the sample points are assumed to be evenly spaceddx
apart. The default is None.dx (float, optional) – The spacing between sample points when
x
is None. If neitherx
nordx
is provided then the default is \(dx = 1\).axis (int, optional) – The axis along which to integrate. The default is -1.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, Definite integral of
y
is N-D tensor as approximated along a single axis by the trapezoidal rule. The result is an N-D tensor.
Examples
import paddle y = paddle.to_tensor([4, 5, 6], dtype='float32') print(paddle.cumulative_trapezoid(y)) # Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, # [4.50000000, 10. ]) print(paddle.cumulative_trapezoid(y, dx=2.)) # Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, # [9. , 20.]) y = paddle.to_tensor([4, 5, 6], dtype='float32') x = paddle.to_tensor([1, 2, 3], dtype='float32') print(paddle.cumulative_trapezoid(y, x)) # Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, # [4.50000000, 10. ]) y = paddle.to_tensor([1, 2, 3], dtype='float64') x = paddle.to_tensor([8, 6, 4], dtype='float64') print(paddle.cumulative_trapezoid(y, x)) # Tensor(shape=[2], dtype=float64, place=Place(cpu), stop_gradient=True, # [-3., -8.]) y = paddle.arange(6).reshape((2, 3)).astype('float32') print(paddle.cumulative_trapezoid(y, axis=0)) # Tensor(shape=[1, 3], dtype=float32, place=Place(cpu), stop_gradient=True, # [[1.50000000, 2.50000000, 3.50000000]]) print(paddle.cumulative_trapezoid(y, axis=1)) # Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=True, # [[0.50000000, 2. ], # [3.50000000, 8. ]])
-
deg2rad
(
name=None
)
[source]
deg2rad¶
-
Convert each of the elements of input x from degrees to angles in radians.
\[deg2rad(x)=\pi * x / 180\]- Parameters
-
x (Tensor) – An N-D Tensor, the data type is float32, float64, int32, int64.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
An N-D Tensor, the shape and data type is the same with input (The output data type is float32 when the input data type is int).
- Return type
-
out (Tensor)
Examples
import paddle x1 = paddle.to_tensor([180.0, -180.0, 360.0, -360.0, 90.0, -90.0]) result1 = paddle.deg2rad(x1) print(result1) # Tensor(shape=[6], dtype=float32, place=CUDAPlace(0), stop_gradient=True, # [3.14159274, -3.14159274, 6.28318548, -6.28318548, 1.57079637, # -1.57079637]) x2 = paddle.to_tensor(180) result2 = paddle.deg2rad(x2) print(result2) # Tensor(shape=[], dtype=float32, place=CUDAPlace(0), stop_gradient=True, # 3.14159274)
-
diagonal
(
offset=0,
axis1=0,
axis2=1,
name=None
)
[source]
diagonal¶
-
Computes the diagonals of the input tensor x.
If
x
is 2D, returns the diagonal. Ifx
has larger dimensions, diagonals be taken from the 2D planes specified by axis1 and axis2. By default, the 2D planes formed by the first and second axis of the input tensor x.The argument
offset
determines where diagonals are taken from input tensor x:If offset = 0, it is the main diagonal.
If offset > 0, it is above the main diagonal.
If offset < 0, it is below the main diagonal.
- Parameters
-
x (Tensor) – The input tensor x. Must be at least 2-dimensional. The input data type should be bool, int32, int64, float16, float32, float64.
offset (int, optional) – Which diagonals in input tensor x will be taken. Default: 0 (main diagonals).
axis1 (int, optional) – The first axis with respect to take diagonal. Default: 0.
axis2 (int, optional) – The second axis with respect to take diagonal. Default: 1.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
a partial view of input tensor in specify two dimensions, the output data type is the same as input data type.
- Return type
-
Tensor
Examples
import paddle x = paddle.rand([2,2,3],'float32') print(x) # Tensor(shape=[2, 2, 3], dtype=float32, place=CUDAPlace(0), stop_gradient=True, # [[[0.45661032, 0.03751532, 0.90191704], # [0.43760979, 0.86177313, 0.65221709]], # [[0.17020577, 0.00259554, 0.28954273], # [0.51795638, 0.27325270, 0.18117726]]]) out1 = paddle.diagonal(x) print(out1) #Tensor(shape=[3, 2], dtype=float32, place=CUDAPlace(0), stop_gradient=True, # [[0.45661032, 0.51795638], # [0.03751532, 0.27325270], # [0.90191704, 0.18117726]]) out2 = paddle.diagonal(x, offset=0, axis1=2, axis2=1) print(out2) #Tensor(shape=[2, 2], dtype=float32, place=CUDAPlace(0), stop_gradient=True, # [[0.45661032, 0.86177313], # [0.17020577, 0.27325270]]) out3 = paddle.diagonal(x, offset=1, axis1=0, axis2=1) print(out3) #Tensor(shape=[3, 1], dtype=float32, place=CUDAPlace(0), stop_gradient=True, # [[0.43760979], # [0.86177313], # [0.65221709]]) out4 = paddle.diagonal(x, offset=0, axis1=1, axis2=2) print(out4) #Tensor(shape=[2, 2], dtype=float32, place=CUDAPlace(0), stop_gradient=True, # [[0.45661032, 0.86177313], # [0.17020577, 0.27325270]])
-
diff
(
n=1,
axis=- 1,
prepend=None,
append=None,
name=None
)
[source]
diff¶
-
Computes the n-th forward difference along the given axis. The first-order differences is computed by using the following formula:
\[out[i] = x[i+1] - x[i]\]Higher-order differences are computed by using paddle.diff() recursively. Only n=1 is currently supported.
- Parameters
-
x (Tensor) – The input tensor to compute the forward difference on, the data type is float16, float32, float64, bool, int32, int64.
n (int, optional) – The number of times to recursively compute the difference. Only support n=1. Default:1
axis (int, optional) – The axis to compute the difference along. Default:-1
prepend (Tensor, optional) – The tensor to prepend to input along axis before computing the difference. It’s dimensions must be equivalent to that of x, and its shapes must match x’s shape except on axis.
append (Tensor, optional) – The tensor to append to input along axis before computing the difference, It’s dimensions must be equivalent to that of x, and its shapes must match x’s shape except on axis.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
The output tensor with same dtype with x.
- Return type
-
Tensor
Examples
import paddle x = paddle.to_tensor([1, 4, 5, 2]) out = paddle.diff(x) print(out) # out: # [3, 1, -3] y = paddle.to_tensor([7, 9]) out = paddle.diff(x, append=y) print(out) # out: # [3, 1, -3, 5, 2] z = paddle.to_tensor([[1, 2, 3], [4, 5, 6]]) out = paddle.diff(z, axis=0) print(out) # out: # [[3, 3, 3]] out = paddle.diff(z, axis=1) print(out) # out: # [[1, 1], [1, 1]]
-
digamma
(
name=None
)
[source]
digamma¶
-
Calculates the digamma of the given input tensor, element-wise.
\[Out = \Psi(x) = \frac{ \Gamma^{'}(x) }{ \Gamma(x) }\]- Parameters
-
x (Tensor) – Input Tensor. Must be one of the following types: float32, float64.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, the digamma of the input Tensor, the shape and data type is the same with input.
Examples
import paddle data = paddle.to_tensor([[1, 1.5], [0, -2.2]], dtype='float32') res = paddle.digamma(data) print(res) # Tensor(shape=[2, 2], dtype=float32, place=CUDAPlace(0), stop_gradient=True, # [[-0.57721591, 0.03648996], # [ nan , 5.32286835]])
-
dist
(
y,
p=2,
name=None
)
[source]
dist¶
-
Returns the p-norm of (x - y). It is not a norm in a strict sense, only as a measure of distance. The shapes of x and y must be broadcastable. The definition is as follows, for details, please refer to the Introduction to Tensor:
Each input has at least one dimension.
Match the two input dimensions from back to front, the dimension sizes must either be equal, one of them is 1, or one of them does not exist.
Where, z = x - y, the shapes of x and y are broadcastable, then the shape of z can be obtained as follows:
1. If the number of dimensions of x and y are not equal, prepend 1 to the dimensions of the tensor with fewer dimensions.
For example, The shape of x is [8, 1, 6, 1], the shape of y is [7, 1, 5], prepend 1 to the dimension of y.
x (4-D Tensor): 8 x 1 x 6 x 1
y (4-D Tensor): 1 x 7 x 1 x 5
2. Determine the size of each dimension of the output z: choose the maximum value from the two input dimensions.
z (4-D Tensor): 8 x 7 x 6 x 5
If the number of dimensions of the two inputs are the same, the size of the output can be directly determined in step 2. When p takes different values, the norm formula is as follows:
When p = 0, defining $0^0=0$, the zero-norm of z is simply the number of non-zero elements of z.
\[\begin{split}||z||_{0}=\lim_{p \\rightarrow 0}\sum_{i=1}^{m}|z_i|^{p}\end{split}\]When p = inf, the inf-norm of z is the maximum element of the absolute value of z.
\[||z||_\infty=\max_i |z_i|\]When p = -inf, the negative-inf-norm of z is the minimum element of the absolute value of z.
\[||z||_{-\infty}=\min_i |z_i|\]Otherwise, the p-norm of z follows the formula,
\[\begin{split}||z||_{p}=(\sum_{i=1}^{m}|z_i|^p)^{\\frac{1}{p}}\end{split}\]- Parameters
-
x (Tensor) – 1-D to 6-D Tensor, its data type is float32 or float64.
y (Tensor) – 1-D to 6-D Tensor, its data type is float32 or float64.
p (float, optional) – The norm to be computed, its data type is float32 or float64. Default: 2.
name (str, optional) – The default value is None. Normally there is no need for user to set this property. For more information, please refer to Name.
- Returns
-
Tensor that is the p-norm of (x - y).
- Return type
-
Tensor
Examples
import paddle x = paddle.to_tensor([[3, 3],[3, 3]], dtype="float32") y = paddle.to_tensor([[3, 3],[3, 1]], dtype="float32") out = paddle.dist(x, y, 0) print(out) # out = 1. out = paddle.dist(x, y, 2) print(out) # out = 2. out = paddle.dist(x, y, float("inf")) print(out) # out = 2. out = paddle.dist(x, y, float("-inf")) print(out) # out = 0.
-
divide
(
y,
name=None
)
[source]
divide¶
-
Divide two tensors element-wise. The equation is:
\[out = x / y\]Note
paddle.divide
supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ .- Parameters
-
x (Tensor) – the input tensor, it’s data type should be float32, float64, int32, int64.
y (Tensor) – the input tensor, it’s data type should be float32, float64, int32, int64.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
N-D Tensor. A location into which the result is stored. If x, y have different shapes and are “broadcastable”, the resulting tensor shape is the shape of x and y after broadcasting. If x, y have the same shape, its shape is the same as x and y.
Examples
import paddle x = paddle.to_tensor([2, 3, 4], dtype='float64') y = paddle.to_tensor([1, 5, 2], dtype='float64') z = paddle.divide(x, y) print(z) # [2., 0.6, 2.]
-
dot
(
y,
name=None
)
[source]
dot¶
-
This operator calculates inner product for vectors.
Note
Support 1-d and 2-d Tensor. When it is 2d, the first dimension of this matrix is the batch dimension, which means that the vectors of multiple batches are dotted.
- Parameters
-
x (Tensor) – 1-D or 2-D
Tensor
. Its dtype should befloat32
,float64
,int32
,int64
y (Tensor) – 1-D or 2-D
Tensor
. Its dtype soulde befloat32
,float64
,int32
,int64
name (str, optional) – Name of the output. Default is None. It’s used to print debug info for developers. Details: Name
- Returns
-
the calculated result Tensor.
- Return type
-
Tensor
Examples:
import paddle # 1-D Tensor * 1-D Tensor x = paddle.to_tensor([1, 2, 3]) y = paddle.to_tensor([4, 5, 6]) z = paddle.dot(x, y) print(z) # 32 # 2-D Tensor * 2-D Tensor x = paddle.to_tensor([[1, 2, 3], [2, 4, 6]]) y = paddle.to_tensor([[4, 5, 6], [4, 5, 6]]) z = paddle.dot(x, y) print(z) # [32, 64]
-
eig
(
name=None
)
eig¶
-
Performs the eigenvalue decomposition of a square matrix or a batch of square matrices.
Note
If the matrix is a Hermitian or a real symmetric matrix, please use paddle.linalg.eigh instead, which is much faster.
If only eigenvalues is needed, please use paddle.linalg.eigvals instead.
If the matrix is of any shape, please use paddle.linalg.svd.
This API is only supported on CPU device.
The output datatype is always complex for both real and complex input.
- Parameters
-
x (Tensor) – A tensor with shape math:[*, N, N], The data type of the x should be one of
float32
,float64
,compplex64
orcomplex128
.name (str, optional) – The default value is None. Normally there is no need for user to set this property. For more information, please refer to Name.
- Returns
-
A tensor with shape math:[*, N] refers to the eigen values. Eigenvectors(Tensors): A tensor with shape math:[*, N, N] refers to the eigen vectors.
- Return type
-
Eigenvalues(Tensors)
Examples
import paddle paddle.device.set_device("cpu") x = paddle.to_tensor([[1.6707249, 7.2249975, 6.5045543], [9.956216, 8.749598, 6.066444 ], [4.4251957, 1.7983172, 0.370647 ]]) w, v = paddle.linalg.eig(x) print(v) # Tensor(shape=[3, 3], dtype=complex128, place=CPUPlace, stop_gradient=False, # [[(-0.5061363550800655+0j) , (-0.7971760990842826+0j) , # (0.18518077798279986+0j)], # [(-0.8308237755993192+0j) , (0.3463813401919749+0j) , # (-0.6837005269141947+0j) ], # [(-0.23142567697893396+0j), (0.4944999840400175+0j) , # (0.7058765252952796+0j) ]]) print(w) # Tensor(shape=[3], dtype=complex128, place=CPUPlace, stop_gradient=False, # [ (16.50471283351188+0j) , (-5.5034820550763515+0j) , # (-0.21026087843552282+0j)])
-
eigvals
(
name=None
)
eigvals¶
-
Compute the eigenvalues of one or more general matrices.
Warning
The gradient kernel of this operator does not yet developed. If you need back propagation through this operator, please replace it with paddle.linalg.eig.
- Parameters
-
x (Tensor) – A square matrix or a batch of square matrices whose eigenvalues will be computed. Its shape should be [*, M, M], where * is zero or more batch dimensions. Its data type should be float32, float64, complex64, or complex128.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, A tensor containing the unsorted eigenvalues which has the same batch dimensions with x. The eigenvalues are complex-valued even when x is real.
Examples
import paddle paddle.set_device("cpu") paddle.seed(1234) x = paddle.rand(shape=[3, 3], dtype='float64') # [[0.02773777, 0.93004224, 0.06911496], # [0.24831591, 0.45733623, 0.07717843], # [0.48016702, 0.14235102, 0.42620817]]) print(paddle.linalg.eigvals(x)) # [(-0.27078833542132674+0j), (0.29962280156230725+0j), (0.8824477020120244+0j)] #complex128
-
eigvalsh
(
UPLO='L',
name=None
)
[source]
eigvalsh¶
-
Computes the eigenvalues of a complex Hermitian (conjugate symmetric) or a real symmetric matrix.
- Parameters
-
x (Tensor) – A tensor with shape \([*, M, M]\) , where * is zero or greater batch dimension. The data type of the input Tensor x should be one of float32, float64, complex64, complex128.
UPLO (str, optional) – Lower triangular part of a (‘L’, default) or the upper triangular part (‘U’).
name (str, optional) – The default value is None. Normally there is no need for user to set this property. For more information, please refer to Name.
- Returns
-
The tensor eigenvalues in ascending order.
- Return type
-
Tensor
Examples
import paddle x = paddle.to_tensor([[1, -2j], [2j, 5]]) out_value = paddle.eigvalsh(x, UPLO='L') print(out_value) # Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, # [0.17157286, 5.82842731])
-
equal
(
y,
name=None
)
[source]
equal¶
-
This layer returns the truth value of \(x == y\) elementwise.
Note
The output has no gradient.
- Parameters
-
x (Tensor) – Tensor, data type is bool, float16, float32, float64, int32, int64.
y (Tensor) – Tensor, data type is bool, float16, float32, float64, int32, int64.
name (str, optional) – The default value is None. Normally there is no need for user to set this property. For more information, please refer to Name.
- Returns
-
output Tensor, it’s shape is the same as the input’s Tensor, and the data type is bool. The result of this op is stop_gradient.
- Return type
-
Tensor
Examples
import paddle x = paddle.to_tensor([1, 2, 3]) y = paddle.to_tensor([1, 3, 2]) result1 = paddle.equal(x, y) print(result1) # result1 = [True False False]
-
equal_all
(
y,
name=None
)
[source]
equal_all¶
-
Returns the truth value of \(x == y\). True if two inputs have the same elements, False otherwise.
Note
The output has no gradient.
- Parameters
-
x (Tensor) – Tensor, data type is bool, float32, float64, int32, int64.
y (Tensor) – Tensor, data type is bool, float32, float64, int32, int64.
name (str, optional) – The default value is None. Normally there is no need for user to set this property. For more information, please refer to Name.
- Returns
-
output Tensor, data type is bool, value is [False] or [True].
- Return type
-
Tensor
Examples
import paddle x = paddle.to_tensor([1, 2, 3]) y = paddle.to_tensor([1, 2, 3]) z = paddle.to_tensor([1, 4, 3]) result1 = paddle.equal_all(x, y) print(result1) # result1 = True result2 = paddle.equal_all(x, z) print(result2) # result2 = False
-
erf
(
name=None
)
[source]
erf¶
-
Erf Operator For more details, see Error function.
- Equation:
-
\[out = \frac{2}{\sqrt{\pi}} \int_{0}^{x}e^{- \eta^{2}}d\eta\]
- Parameters
-
x (Tensor) – The input tensor, it’s data type should be float32, float64.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
The output of Erf, dtype: float32 or float64, the same as the input, shape: the same as the input.
- Return type
-
Tensor
Examples
import paddle x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3]) out = paddle.erf(x) print(out) # [-0.42839236 -0.22270259 0.11246292 0.32862676]
-
erfinv
(
name=None
)
[source]
erfinv¶
-
The inverse error function of x. Please refer to erf
\[erfinv(erf(x)) = x.\]- Parameters
-
x (Tensor) – An N-D Tensor, the data type is float32, float64.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
out (Tensor), an N-D Tensor, the shape and data type is the same with input.
Example
import paddle x = paddle.to_tensor([0, 0.5, -1.], dtype="float32") out = paddle.erfinv(x) # out: [0, 0.4769, -inf]
-
erfinv_
(
name=None
)
erfinv_¶
-
Inplace version of
erfinv
API, the output Tensor will be inplaced with inputx
. Please refer to api_tensor_erfinv.
-
exp
(
name=None
)
[source]
exp¶
-
Computes exp of x element-wise with a natural number e as the base.
\[out = e^x\]- Parameters
-
x (Tensor) – Input of Exp operator, an N-D Tensor, with data type float32, float64 or float16.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor. Output of Exp operator, a Tensor with shape same as input.
Examples
import paddle x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3]) out = paddle.exp(x) print(out) # [0.67032005 0.81873075 1.10517092 1.34985881]
-
exp_
(
name=None
)
exp_¶
-
Inplace version of
exp
API, the output Tensor will be inplaced with inputx
. Please refer to api_fluid_layers_exp.
-
expand
(
shape,
name=None
)
[source]
expand¶
-
Expand the input tensor to a given shape.
Both the number of dimensions of
x
and the number of elements inshape
should be less than or equal to 6. And the number of dimensions ofx
should be less than the number of elements inshape
. The dimension to expand must have a value 0.- Parameters
-
x (Tensor) – The input Tensor, its data type is bool, float32, float64, int32 or int64.
shape (list|tuple|Tensor) – The result shape after expanding. The data type is int32. If shape is a list or tuple, all its elements should be integers or 0-D or 1-D Tensors with the data type int32. If shape is a Tensor, it should be an 1-D Tensor with the data type int32. The value -1 in shape means keeping the corresponding dimension unchanged.
name (str, optional) – The default value is None. Normally there is no need for user to set this property. For more information, please refer to Name .
- Returns
-
N-D Tensor, A Tensor with the given shape. The data type is the same as
x
.
Examples
import paddle data = paddle.to_tensor([1, 2, 3], dtype='int32') out = paddle.expand(data, shape=[2, 3]) print(out) # [[1, 2, 3], [1, 2, 3]]
-
expand_as
(
y,
name=None
)
[source]
expand_as¶
-
Expand the input tensor
x
to the same shape as the input tensory
.Both the number of dimensions of
x
andy
must be less than or equal to 6, and the number of dimensions ofy
must be greather than or equal to that ofx
. The dimension to expand must have a value of 0.- Parameters
-
x (Tensor) – The input tensor, its data type is bool, float32, float64, int32 or int64.
y (Tensor) – The input tensor that gives the shape to expand to.
name (str, optional) – The default value is None. Normally there is no need for user to set this property. For more information, please refer to Name.
- Returns
-
N-D Tensor, A Tensor with the same shape as
y
. The data type is the same asx
.
Examples
import paddle data_x = paddle.to_tensor([1, 2, 3], 'int32') data_y = paddle.to_tensor([[1, 2, 3], [4, 5, 6]], 'int32') out = paddle.expand_as(data_x, data_y) print(out) # Tensor(shape=[2, 3], dtype=int32, place=Place(gpu:0), stop_gradient=True, # [[1, 2, 3], # [1, 2, 3]])
-
expm1
(
name=None
)
[source]
expm1¶
-
Expm1 Operator. Computes expm1 of x element-wise with a natural number \(e\) as the base.
\[out = e^x - 1\]- Parameters
-
x (Tensor) – Input of Expm1 operator, an N-D Tensor, with data type float32, float64 or float16.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor. Output of Expm1 operator, a Tensor with shape same as input.
Examples
import paddle x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3]) out = paddle.expm1(x) print(out) # [-0.32967997, -0.18126924, 0.10517092, 0.34985882]
-
exponential_
(
lam=1.0,
name=None
)
exponential_¶
-
This inplace OP fill input Tensor
x
with random number from a Exponential Distribution.lam
is \(\lambda\) parameter of Exponential Distribution.\[f(x) = \lambda e^{-\lambda x}\]- Parameters
-
x (Tensor) – Input tensor. The data type should be float32, float64.
lam (float, optional) – \(\lambda\) parameter of Exponential Distribution. Default, 1.0.
name (str, optional) – The default value is None. Normally there is no need for user to set this property. For more information, please refer to Name.
- Returns
-
Input Tensor
x
. - Return type
-
Tensor
Examples
import paddle paddle.set_device('cpu') paddle.seed(100) x = paddle.empty([2,3]) x.exponential_() # [[0.80643415, 0.23211166, 0.01169797], # [0.72520673, 0.45208144, 0.30234432]]
-
fill_
(
value
)
fill_¶
-
- Notes:
-
This API is ONLY available in Dygraph mode
This function fill the Tensor with value inplace.
- Parameters
-
x (Tensor) –
x
is the Tensor we want to filled data inplacevalue (Scale) –
value
is the value to be filled in x
- Returns
-
x(Tensor), Tensor x filled with value inplace
Examples
import paddle tensor = paddle.to_tensor([0, 1, 2, 3, 4]) tensor.fill_(0) print(tensor.tolist()) #[0, 0, 0, 0, 0]
-
fill_diagonal_
(
value,
offset=0,
wrap=False,
name=None
)
fill_diagonal_¶
-
Note
This API is ONLY available in Dygraph mode.
This function fill the value into the x Tensor’s diagonal inplace.
- Parameters
-
x (Tensor) –
x
is the original Tensorvalue (Scale) –
value
is the value to filled in xoffset (int,optional) – the offset to the main diagonal. Default: 0 (main diagonal).
wrap (bool,optional) – the diagonal ‘wrapped’ after N columns for tall matrices.
name (str,optional) – Name for the operation (optional, default is None)
- Returns
-
Tensor, Tensor with diagonal filled with value.
Examples
-
fill_diagonal_tensor
(
y,
offset=0,
dim1=0,
dim2=1,
name=None
)
fill_diagonal_tensor¶
-
This function fill the source Tensor y into the x Tensor’s diagonal.
- Parameters
-
x (Tensor) –
x
is the original Tensory (Tensor) –
y
is the Tensor to filled in xdim1 (int,optional) – first dimension with respect to which to fill diagonal. Default: 0.
dim2 (int,optional) – second dimension with respect to which to fill diagonal. Default: 1.
offset (int,optional) – the offset to the main diagonal. Default: 0 (main diagonal).
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, Tensor with diagonal filled with y.
Examples
import paddle x = paddle.ones((4, 3)) * 2 y = paddle.ones((3,)) nx = x.fill_diagonal_tensor(y) print(nx.tolist()) #[[1.0, 2.0, 2.0], [2.0, 1.0, 2.0], [2.0, 2.0, 1.0], [2.0, 2.0, 2.0]]
-
fill_diagonal_tensor_
(
y,
offset=0,
dim1=0,
dim2=1,
name=None
)
fill_diagonal_tensor_¶
-
Note
This API is ONLY available in Dygraph mode.
This function fill the source Tensor y into the x Tensor’s diagonal inplace.
- Parameters
-
x (Tensor) –
x
is the original Tensory (Tensor) –
y
is the Tensor to filled in xdim1 (int,optional) – first dimension with respect to which to fill diagonal. Default: 0.
dim2 (int,optional) – second dimension with respect to which to fill diagonal. Default: 1.
offset (int,optional) – the offset to the main diagonal. Default: 0 (main diagonal).
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, Tensor with diagonal filled with y.
Examples
import paddle x = paddle.ones((4, 3)) * 2 y = paddle.ones((3,)) x.fill_diagonal_tensor_(y) print(x.tolist()) #[[1.0, 2.0, 2.0], [2.0, 1.0, 2.0], [2.0, 2.0, 1.0], [2.0, 2.0, 2.0]]
-
flatten
(
start_axis=0,
stop_axis=- 1,
name=None
)
[source]
flatten¶
-
Flattens a contiguous range of axes in a tensor according to start_axis and stop_axis.
Note
The output Tensor will share data with origin Tensor and doesn’t have a Tensor copy in
dygraph
mode. If you want to use the Tensor copy version, please use Tensor.clone likeflatten_clone_x = x.flatten().clone()
.For Example:
Case 1: Given X.shape = (3, 100, 100, 4) and start_axis = 1 end_axis = 2 We get: Out.shape = (3, 1000 * 100, 2) Case 2: Given X.shape = (3, 100, 100, 4) and start_axis = 0 stop_axis = -1 We get: Out.shape = (3 * 100 * 100 * 4)
- Parameters
-
x (Tensor) – A tensor of number of dimentions >= axis. A tensor with data type float16, float32, float64, int8, int32, int64, uint8.
start_axis (int) – the start axis to flatten
stop_axis (int) – the stop axis to flatten
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
- Tensor, A tensor with the contents of the input tensor, with input
-
axes flattened by indicated start axis and end axis. A Tensor with data type same as input x.
Examples
import paddle image_shape=(2, 3, 4, 4) x = paddle.arange(end=image_shape[0] * image_shape[1] * image_shape[2] * image_shape[3]) img = paddle.reshape(x, image_shape) out = paddle.flatten(img, start_axis=1, stop_axis=2) # out shape is [2, 12, 4] # out shares data with img in dygraph mode img[0, 0, 0, 0] = -1 print(out[0, 0, 0]) # [-1]
-
flatten_
(
start_axis=0,
stop_axis=- 1,
name=None
)
flatten_¶
-
Inplace version of
flatten
API, the output Tensor will be inplaced with inputx
. Please refer to api_tensor_flatten.
-
flip
(
axis,
name=None
)
[source]
flip¶
-
Reverse the order of a n-D tensor along given axis in axis.
- Parameters
-
x (Tensor) – A Tensor(or LoDTensor) with shape \([N_1, N_2,..., N_k]\) . The data type of the input Tensor x should be float32, float64, int32, int64, bool.
axis (list|tuple|int) – The axis(axes) to flip on. Negative indices for indexing from the end are accepted.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, Tensor or LoDTensor calculated by flip layer. The data type is same with input x.
Examples
import paddle image_shape=(3, 2, 2) img = paddle.arange(image_shape[0] * image_shape[1] * image_shape[2]).reshape(image_shape) tmp = paddle.flip(img, [0,1]) print(tmp) # [[[10,11],[8, 9]], [[6, 7],[4, 5]], [[2, 3],[0, 1]]] out = paddle.flip(tmp,-1) print(out) # [[[11,10],[9, 8]], [[7, 6],[5, 4]], [[3, 2],[1, 0]]]
-
floor
(
name=None
)
[source]
floor¶
-
Floor Activation Operator. Computes floor of x element-wise.
\[out = \lfloor x \rfloor\]- Parameters
-
x (Tensor) – Input of Floor operator, an N-D Tensor, with data type float32, float64 or float16.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor. Output of Floor operator, a Tensor with shape same as input.
Examples
import paddle x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3]) out = paddle.floor(x) print(out) # [-1. -1. 0. 0.]
-
floor_
(
name=None
)
floor_¶
-
Inplace version of
floor
API, the output Tensor will be inplaced with inputx
. Please refer to api_fluid_layers_floor.
-
floor_divide
(
y,
name=None
)
[source]
floor_divide¶
-
Floor divide two tensors element-wise and rounds the quotinents to the nearest integer toward zero. The equation is:
\[out = trunc(x / y)\]\(x\): Multidimensional Tensor.
\(y\): Multidimensional Tensor.
Note
paddle.floor_divide
supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ .Also note that the name
floor_divide
can be misleading, as the quotinents are actually rounded toward zero, not toward negative infinite.- Parameters
-
x (Tensor) – the input tensor, it’s data type should be uint8, int8, int32, int64, float32, float64, float16, bfloat16.
y (Tensor) – the input tensor, it’s data type should be uint8, int8, int32, int64, float32, float64, float16, bfloat16.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
N-D Tensor. A location into which the result is stored. It’s dimension equals with $x$.
Examples
import paddle x = paddle.to_tensor([2, 3, 8, 7]) y = paddle.to_tensor([1, 5, 3, 3]) z = paddle.floor_divide(x, y) print(z) # [2, 0, 2, 2]
-
floor_mod
(
y,
name=None
)
[source]
floor_mod¶
-
Mod two tensors element-wise. The equation is:
\[out = x \% y\]Note
paddle.remainder
supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ .- Parameters
-
x (Tensor) – the input tensor, it’s data type should be float16, float32, float64, int32, int64.
y (Tensor) – the input tensor, it’s data type should be float16, float32, float64, int32, int64.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
N-D Tensor. A location into which the result is stored. If x, y have different shapes and are “broadcastable”, the resulting tensor shape is the shape of x and y after broadcasting. If x, y have the same shape, its shape is the same as x and y.
Examples
import paddle x = paddle.to_tensor([2, 3, 8, 7]) y = paddle.to_tensor([1, 5, 3, 3]) z = paddle.remainder(x, y) print(z) # [0, 3, 2, 1]
-
fmax
(
y,
name=None
)
[source]
fmax¶
-
Compares the elements at the corresponding positions of the two tensors and returns a new tensor containing the maximum value of the element. If one of them is a nan value, the other value is directly returned, if both are nan values, then the first nan value is returned. The equation is:
\[out = fmax(x, y)\]Note
paddle.fmax
supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ .- Parameters
-
x (Tensor) – the input tensor, it’s data type should be float16, float32, float64, int32, int64.
y (Tensor) – the input tensor, it’s data type should be float16, float32, float64, int32, int64.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
N-D Tensor. A location into which the result is stored. If x, y have different shapes and are “broadcastable”, the resulting tensor shape is the shape of x and y after broadcasting. If x, y have the same shape, its shape is the same as x and y.
Examples
import paddle x = paddle.to_tensor([[1, 2], [7, 8]]) y = paddle.to_tensor([[3, 4], [5, 6]]) res = paddle.fmax(x, y) print(res) # Tensor(shape=[2, 2], dtype=int64, place=Place(cpu), stop_gradient=True, # [[3, 4], # [7, 8]]) x = paddle.to_tensor([[1, 2, 3], [1, 2, 3]]) y = paddle.to_tensor([3, 0, 4]) res = paddle.fmax(x, y) print(res) # Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, # [[3, 2, 4], # [3, 2, 4]]) x = paddle.to_tensor([2, 3, 5], dtype='float32') y = paddle.to_tensor([1, float("nan"), float("nan")], dtype='float32') res = paddle.fmax(x, y) print(res) # Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, # [2., 3., 5.]) x = paddle.to_tensor([5, 3, float("inf")], dtype='float32') y = paddle.to_tensor([1, -float("inf"), 5], dtype='float32') res = paddle.fmax(x, y) print(res) # Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, # [5. , 3. , inf.])
-
fmin
(
y,
name=None
)
[source]
fmin¶
-
Compares the elements at the corresponding positions of the two tensors and returns a new tensor containing the minimum value of the element. If one of them is a nan value, the other value is directly returned, if both are nan values, then the first nan value is returned. The equation is:
\[out = fmin(x, y)\]Note
paddle.fmin
supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ .- Parameters
-
x (Tensor) – the input tensor, it’s data type should be float16, float32, float64, int32, int64.
y (Tensor) – the input tensor, it’s data type should be float16, float32, float64, int32, int64.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
N-D Tensor. A location into which the result is stored. If x, y have different shapes and are “broadcastable”, the resulting tensor shape is the shape of x and y after broadcasting. If x, y have the same shape, its shape is the same as x and y.
Examples
import paddle x = paddle.to_tensor([[1, 2], [7, 8]]) y = paddle.to_tensor([[3, 4], [5, 6]]) res = paddle.fmin(x, y) print(res) # Tensor(shape=[2, 2], dtype=int64, place=Place(cpu), stop_gradient=True, # [[1, 2], # [5, 6]]) x = paddle.to_tensor([[[1, 2, 3], [1, 2, 3]]]) y = paddle.to_tensor([3, 0, 4]) res = paddle.fmin(x, y) print(res) # Tensor(shape=[1, 2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, # [[[1, 0, 3], # [1, 0, 3]]]) x = paddle.to_tensor([2, 3, 5], dtype='float32') y = paddle.to_tensor([1, float("nan"), float("nan")], dtype='float32') res = paddle.fmin(x, y) print(res) # Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, # [1., 3., 5.]) x = paddle.to_tensor([5, 3, float("inf")], dtype='float64') y = paddle.to_tensor([1, -float("inf"), 5], dtype='float64') res = paddle.fmin(x, y) print(res) # Tensor(shape=[3], dtype=float64, place=Place(cpu), stop_gradient=True, # [ 1. , -inf., 5. ])
-
frac
(
name=None
)
[source]
frac¶
-
This API is used to return the fractional portion of each element in input.
- Parameters
-
x (Tensor) – The input tensor, which data type should be int32, int64, float32, float64.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
The output Tensor of frac.
- Return type
-
Tensor
Examples
import paddle input = paddle.to_tensor([[12.22000003, -1.02999997], [-0.54999995, 0.66000003]]) output = paddle.frac(input) print(output) # Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=True, # [[ 0.22000003, -0.02999997], # [-0.54999995, 0.66000003]])
-
frexp
(
name=None
)
[source]
frexp¶
-
The function used to decompose a floating point number into mantissa and exponent.
- Parameters
-
x (Tensor) – The input tensor, it’s data type should be float32, float64.
name (str, optional) – For details, please refer to Name. Generally, no setting is required. Default: None.
- Returns
-
-
- mantissa (Tensor), A mantissa Tensor. The shape and data type of mantissa tensor and exponential tensor are
-
the same as those of input.
-
- exponent (Tensor), A exponent Tensor. The shape and data type of mantissa tensor and exponential tensor are
-
the same as those of input.
-
Examples
import paddle x = paddle.to_tensor([[1, 2, 3, 4]], dtype="float32") print(paddle.tensor.math.frexp(x)) # (Tensor(shape=[1, 4], dtype=float32, place=Place(cpu), stop_gradient=True,[[0.50000000, 0.50000000, 0.75000000, 0.50000000]]), # Tensor(shape=[1, 4], dtype=float32, place=Place(cpu), stop_gradient=True,[[1., 2., 2., 3.]]))
-
gather
(
index,
axis=None,
name=None
)
[source]
gather¶
-
Output is obtained by gathering entries of
axis
ofx
indexed byindex
and concatenate them together.Given: x = [[1, 2], [3, 4], [5, 6]] index = [1, 2] axis=[0] Then: out = [[3, 4], [5, 6]]
- Parameters
-
x (Tensor) – The source input tensor with rank>=1. Supported data type is int32, int64, float32, float64 and uint8 (only for CPU), float16 (only for GPU).
index (Tensor) – The index input tensor with rank=0 or rank=1. Data type is int32 or int64.
axis (Tensor|int, optional) – The axis of input to be gathered, it’s can be int or a Tensor with data type is int32 or int64. The default value is None, if None, the
axis
is 0.name (str, optional) – The default value is None. Normally there is no need for user to set this property. For more information, please refer to Name .
- Returns
-
output (Tensor), If the index is a 1-D tensor, the output is a tensor with the same shape as
x
. If the index is a 0-D tensor, the output will reduce the dimension where the axis pointing.
Examples
import paddle input = paddle.to_tensor([[1,2],[3,4],[5,6]]) index = paddle.to_tensor([0,1]) output = paddle.gather(input, index, axis=0) # expected output: [[1,2],[3,4]]
-
gather_nd
(
index,
name=None
)
[source]
gather_nd¶
-
This function is actually a high-dimensional extension of
gather
and supports for simultaneous indexing by multiple axes.index
is a K-dimensional integer tensor, which is regarded as a (K-1)-dimensional tensor ofindex
intoinput
, where each element defines a slice of params:\[output[(i_0, ..., i_{K-2})] = input[index[(i_0, ..., i_{K-2})]]\]Obviously,
index.shape[-1] <= input.rank
. And, the output tensor has shapeindex.shape[:-1] + input.shape[index.shape[-1]:]
.Given: x = [[[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]], [[12, 13, 14, 15], [16, 17, 18, 19], [20, 21, 22, 23]]] x.shape = (2, 3, 4) * Case 1: index = [[1]] gather_nd(x, index) = [x[1, :, :]] = [[12, 13, 14, 15], [16, 17, 18, 19], [20, 21, 22, 23]] * Case 2: index = [[0,2]] gather_nd(x, index) = [x[0, 2, :]] = [8, 9, 10, 11] * Case 3: index = [[1, 2, 3]] gather_nd(x, index) = [x[1, 2, 3]] = [23]
- Parameters
-
x (Tensor) – The input Tensor which it’s data type should be bool, float16, float32, float64, int32, int64.
index (Tensor) – The index input with rank > 1, index.shape[-1] <= input.rank. Its dtype should be int32, int64.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
-1] + input.shape[index.shape[-1]:]
- Return type
-
output (Tensor), A tensor with the shape index.shape[
Examples
import paddle x = paddle.to_tensor([[[1, 2], [3, 4], [5, 6]], [[7, 8], [9, 10], [11, 12]]]) index = paddle.to_tensor([[0, 1]]) output = paddle.gather_nd(x, index) #[[3, 4]]
-
gcd
(
y,
name=None
)
[source]
gcd¶
-
Computes the element-wise greatest common divisor (GCD) of input |x| and |y|. Both x and y must have integer types.
Note
gcd(0,0)=0, gcd(0, y)=|y|
If x.shape != y.shape, they must be broadcastable to a common shape (which becomes the shape of the output).
- Parameters
-
x (Tensor) – An N-D Tensor, the data type is int32, int64.
y (Tensor) – An N-D Tensor, the data type is int32, int64.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
An N-D Tensor, the data type is the same with input.
- Return type
-
out (Tensor)
Examples
import paddle x1 = paddle.to_tensor(12) x2 = paddle.to_tensor(20) paddle.gcd(x1, x2) # Tensor(shape=[], dtype=int64, place=CUDAPlace(0), stop_gradient=True, # 4) x3 = paddle.arange(6) paddle.gcd(x3, x2) # Tensor(shape=[6], dtype=int64, place=CUDAPlace(0), stop_gradient=True, # [20, 1 , 2 , 1 , 4 , 5]) x4 = paddle.to_tensor(0) paddle.gcd(x4, x2) # Tensor(shape=[], dtype=int64, place=CUDAPlace(0), stop_gradient=True, # 20) paddle.gcd(x4, x4) # Tensor(shape=[], dtype=int64, place=CUDAPlace(0), stop_gradient=True, # 0) x5 = paddle.to_tensor(-20) paddle.gcd(x1, x5) # Tensor(shape=[], dtype=int64, place=CUDAPlace(0), stop_gradient=True, # 4)
-
gradient
(
)
gradient¶
-
Warning
This API will be deprecated in the future, it is recommended to use
x.grad
which returns the tensor value of the gradient.Get the Gradient of Current Tensor.
- Returns
-
Numpy value of the gradient of current Tensor
- Return type
-
ndarray
Examples
import paddle x = paddle.to_tensor(5., stop_gradient=False) y = paddle.pow(x, 4.0) y.backward() print("grad of x: {}".format(x.gradient())) # [500.]
-
greater_equal
(
y,
name=None
)
[source]
greater_equal¶
-
Returns the truth value of \(x >= y\) elementwise, which is equivalent function to the overloaded operator >=.
Note
The output has no gradient.
- Parameters
-
x (Tensor) – First input to compare which is N-D tensor. The input data type should be bool, float16, float32, float64, int32, int64.
y (Tensor) – Second input to compare which is N-D tensor. The input data type should be bool, float16, float32, float64, int32, int64.
name (str, optional) – The default value is None. Normally there is no need for user to set this property. For more information, please refer to Name.
- Returns
-
The output shape is same as input
x
. The output data type is bool. - Return type
-
Tensor
Examples
import paddle x = paddle.to_tensor([1, 2, 3]) y = paddle.to_tensor([1, 3, 2]) result1 = paddle.greater_equal(x, y) print(result1) # result1 = [True False True]
-
greater_than
(
y,
name=None
)
[source]
greater_than¶
-
Returns the truth value of \(x > y\) elementwise, which is equivalent function to the overloaded operator >.
Note
The output has no gradient.
- Parameters
-
x (Tensor) – First input to compare which is N-D tensor. The input data type should be bool, float16, float32, float64, int32, int64.
y (Tensor) – Second input to compare which is N-D tensor. The input data type should be bool, float16, float32, float64, int32, int64.
name (str, optional) – The default value is None. Normally there is no need for user to set this property. For more information, please refer to Name.
- Returns
-
The output shape is same as input
x
. The output data type is bool. - Return type
-
Tensor
Examples
import paddle x = paddle.to_tensor([1, 2, 3]) y = paddle.to_tensor([1, 3, 2]) result1 = paddle.greater_than(x, y) print(result1) # result1 = [False False True]
-
heaviside
(
y,
name=None
)
[source]
heaviside¶
-
Computes the Heaviside step function determined by corresponding element in y for each element in x. The equation is
\[\begin{split}heaviside(x, y)= \left\{ \begin{array}{lcl} 0,& &\text{if} \ x < 0, \\ y,& &\text{if} \ x = 0, \\ 1,& &\text{if} \ x > 0. \end{array} \right.\end{split}\]Note
paddle.heaviside
supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ .- Parameters
-
x (Tensor) – The input tensor of Heaviside step function, it’s data type should be float16, float32, float64, int32 or int64.
y (Tensor) – The tensor that determines a Heaviside step function, it’s data type should be float16, float32, float64, int32 or int64.
name (str, optional) – Name for the operation (optional, default is None). Normally there is no need for user to set this property. For more information, please refer to Name.
- Returns
-
N-D Tensor. A location into which the result is stored. If x and y have different shapes and are broadcastable, the resulting tensor shape is the shape of x and y after broadcasting. If x, y have the same shape, its shape is the same as x and y.
Examples
import paddle x = paddle.to_tensor([-0.5, 0, 0.5]) y = paddle.to_tensor([0.1]) paddle.heaviside(x, y) # [0. , 0.10000000, 1. ] x = paddle.to_tensor([[-0.5, 0, 0.5], [-0.5, 0.5, 0]]) y = paddle.to_tensor([0.1, 0.2, 0.3]) paddle.heaviside(x, y) # [[0. , 0.20000000, 1. ], # [0. , 1. , 0.30000001]]
-
histogram
(
bins=100,
min=0,
max=0,
name=None
)
[source]
histogram¶
-
Computes the histogram of a tensor. The elements are sorted into equal width bins between min and max. If min and max are both zero, the minimum and maximum values of the data are used.
- Parameters
-
input (Tensor) – A Tensor(or LoDTensor) with shape \([N_1, N_2,..., N_k]\) . The data type of the input Tensor should be float32, float64, int32, int64.
bins (int, optional) – number of histogram bins.
min (int, optional) – lower end of the range (inclusive).
max (int, optional) – upper end of the range (inclusive).
name (str, optional) – For details, please refer to Name. Generally, no setting is required. Default: None.
- Returns
-
data type is int64, shape is (nbins,).
- Return type
-
Tensor
Examples
import paddle inputs = paddle.to_tensor([1, 2, 1]) result = paddle.histogram(inputs, bins=4, min=0, max=3) print(result) # [0, 2, 1, 0]
-
i0
(
name=None
)
[source]
i0¶
-
The function used to calculate modified bessel function of order 0.
- Equation:
-
\[I_0(x) = \sum^{\infty}_{k=0}\frac{(x^2/4)^k}{(k!)^2}\]
- Parameters
-
x (Tensor) – The input tensor, it’s data type should be float32, float64.
name (str, optional) – For details, please refer to Name. Generally, no setting is required. Default: None.
- Returns
-
out (Tensor), A Tensor. the value of the modified bessel function of order 0 at x.
Examples
import paddle x = paddle.to_tensor([0, 1, 2, 3, 4], dtype="float32") print(paddle.i0(x)) # (Tensor(shape=[5], dtype=float32, place=Place(cpu), stop_gradient=True, [0.99999994 , 1.26606596 , 2.27958512 , 4.88079262 , 11.30192089]),
-
i0e
(
name=None
)
[source]
i0e¶
-
The function used to calculate exponentially scaled modified Bessel function of order 0.
- Equation:
-
\[\begin{split}I_0(x) = \sum^{\infty}_{k=0}\frac{(x^2/4)^k}{(k!)^2} \\ I_{0e}(x) = e^{-|x|}I_0(x)\end{split}\]
- Parameters
-
x (Tensor) – The input tensor, it’s data type should be float32, float64.
name (str, optional) – For details, please refer to Name. Generally, no setting is required. Default: None.
- Returns
-
out (Tensor), A Tensor. the value of the exponentially scaled modified Bessel function of order 0 at x.
Examples
import paddle x = paddle.to_tensor([0, 1, 2, 3, 4], dtype="float32") print(paddle.i0e(x)) # (Tensor(shape=[5], dtype=float32, place=Place(cpu), stop_gradient=True, [1., 0.46575961, 0.30850832, 0.24300035, 0.20700192]),
-
i1
(
name=None
)
[source]
i1¶
-
The function is used to calculate modified bessel function of order 1.
- Parameters
-
x (Tensor) – The input tensor, it’s data type should be float32, float64.
name (str, optional) – For details, please refer to Name. Generally, no setting is required. Default: None.
- Returns
-
out (Tensor), A Tensor. the value of the modified bessel function of order 1 at x.
Examples
import paddle x = paddle.to_tensor([0, 1, 2, 3, 4], dtype="float32") print(paddle.i1(x)) # (Tensor(shape=[5], dtype=float32, place=Place(cpu), stop_gradient=True, [0., 0.5651591 , 1.59063685 , 3.95337022 , 9.75946515]),
-
i1e
(
name=None
)
[source]
i1e¶
-
The function is used to calculate exponentially scaled modified Bessel function of order 1.
- Parameters
-
x (Tensor) – The input tensor, it’s data type should be float32, float64.
name (str, optional) – For details, please refer to Name. Generally, no setting is required. Default: None.
- Returns
-
out (Tensor), A Tensor. the value of the exponentially scaled modified Bessel function of order 1 at x.
Examples
import paddle x = paddle.to_tensor([0, 1, 2, 3, 4], dtype="float32") print(paddle.i1e(x)) # (Tensor(shape=[5], dtype=float32, place=Place(cpu), stop_gradient=True, [0., 0.20791042, 0.21526929, 0.24300035, 0.17875084]),
-
imag
(
name=None
)
[source]
imag¶
-
Returns a new tensor containing imaginary values of input tensor.
- Parameters
-
x (Tensor) – the input tensor, its data type could be complex64 or complex128.
name (str, optional) – The default value is None. Normally there is no need for user to set this property. For more information, please refer to Name .
- Returns
-
a tensor containing imaginary values of the input tensor.
- Return type
-
Tensor
Examples
import paddle x = paddle.to_tensor( [[1 + 6j, 2 + 5j, 3 + 4j], [4 + 3j, 5 + 2j, 6 + 1j]]) # Tensor(shape=[2, 3], dtype=complex64, place=CUDAPlace(0), stop_gradient=True, # [[(1+6j), (2+5j), (3+4j)], # [(4+3j), (5+2j), (6+1j)]]) imag_res = paddle.imag(x) # Tensor(shape=[2, 3], dtype=float32, place=CUDAPlace(0), stop_gradient=True, # [[6., 5., 4.], # [3., 2., 1.]]) imag_t = x.imag() # Tensor(shape=[2, 3], dtype=float32, place=CUDAPlace(0), stop_gradient=True, # [[6., 5., 4.], # [3., 2., 1.]])
-
increment
(
value=1.0,
name=None
)
[source]
increment¶
-
The API is usually used for control flow to increment the data of
x
by an amountvalue
. Notice that the number of elements inx
must be equal to 1.- Parameters
-
x (Tensor) – A tensor that must always contain only one element, its data type supports float32, float64, int32 and int64.
value (float, optional) – The amount to increment the data of
x
. Default: 1.0.name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, the elementwise-incremented tensor with the same shape and data type as
x
.
Examples
import paddle data = paddle.zeros(shape=[1], dtype='float32') counter = paddle.increment(data) # [1.]
-
index_add
(
index,
axis,
value,
name=None
)
[source]
index_add¶
-
Adds the elements of the input tensor with value tensor by selecting the indices in the order given in index.
- Parameters
-
x (Tensor) – The Destination Tensor. Supported data types are int32, int64, float16, float32, float64.
index (Tensor) – The 1-D Tensor containing the indices to index. The data type of
index
must be int32 or int64.axis (int) – The dimension in which we index.
value (Tensor) – The tensor used to add the elements along the target axis.
name (str, optional) – For details, please refer to Name. Generally, no setting is required. Default: None.
- Returns
-
Tensor, same dimention and dtype with x.
Examples
# required: gpu import paddle input_tensor = paddle.to_tensor(paddle.ones((3, 3)), dtype="float32") index = paddle.to_tensor([0, 2], dtype="int32") value = paddle.to_tensor([[1, 1, 1], [1, 1, 1]], dtype="float32") outplace_res = paddle.index_add(input_tensor, index, 0, value) print(outplace_res) # Tensor(shape=[3, 3], dtype=float32, place=Place(gpu:0), stop_gradient=True, # [[2., 2., 2.], # [1., 1., 1.], # [2., 2., 2.]])
-
index_add_
(
index,
axis,
value,
name=None
)
[source]
index_add_¶
-
Inplace version of
index_add
API, the output Tensor will be inplaced with inputx
. Please refer to index_add.Examples
# required: gpu import paddle input_tensor = paddle.to_tensor(paddle.ones((3, 3)), dtype="float32") index = paddle.to_tensor([0, 2], dtype="int32") value = paddle.to_tensor([[1, 1], [1, 1], [1, 1]], dtype="float32") inplace_res = paddle.index_add_(input_tensor, index, 1, value) print(inplace_res) # Tensor(shape=[3, 3], dtype=float32, place=Place(gpu:0), stop_gradient=True, # [[2., 1., 2.], # [2., 1., 2.], # [2., 1., 2.]])
-
index_put
(
indices,
value,
accumulate=False,
name=None
)
[source]
index_put¶
-
Outplace version of
index_put_
API, the output Tensor will be inplaced with inputx
. Please refer to index_put.Examples
import paddle x = paddle.zeros([3, 3]) value = paddle.ones([3]) ix1 = paddle.to_tensor([0,1,2]) ix2 = paddle.to_tensor([1,2,1]) indices=(ix1,ix2) out = paddle.index_put(x,indices,value) print(x) # Tensor(shape=[3, 3], dtype=float32, place=Place(gpu:0), stop_gradient=True, # [[0., 0., 0.], # [0., 0., 0.], # [0., 0., 0.]]) print(out) # Tensor(shape=[3, 3], dtype=float32, place=Place(gpu:0), stop_gradient=True, # [[0., 1., 0.], # [0., 0., 1.], # [0., 1., 0.]])
-
index_put_
(
indices,
value,
accumulate=False,
name=None
)
[source]
index_put_¶
-
Puts values from the tensor values into the tensor x using the indices specified in indices (which is a tuple of Tensors). The expression paddle.index_put_(x, indices, values) is equivalent to tensor[indices] = values. Returns x. If accumulate is True, the elements in values are added to x. If accumulate is False, the behavior is undefined if indices contain duplicate elements.
- Parameters
-
x (Tensor) – The Source Tensor. Supported data types are int32, int64, float16, float32, float64, bool.
indices (Tuple of Tensor) – The tuple of Tensor containing the indices to index. The data type of
tensor in indices
must be int32, int64 or bool.value (Tensor) – The tensor used to be assigned to x.
accummulate (Bool, optional) – Whether the elements in values are added to x. Default: False.
name (str, optional) – For details, please refer to Name. Generally, no setting is required. Default: None.
- Returns
-
Tensor, same dimention and dtype with x.
Examples
import paddle x = paddle.zeros([3, 3]) value = paddle.ones([3]) ix1 = paddle.to_tensor([0,1,2]) ix2 = paddle.to_tensor([1,2,1]) indices=(ix1,ix2) out = paddle.index_put_(x,indices,value) print(x) # Tensor(shape=[3, 3], dtype=float32, place=Place(gpu:0), stop_gradient=True, # [[0., 1., 0.], # [0., 0., 1.], # [0., 1., 0.]]) print(out) # Tensor(shape=[3, 3], dtype=float32, place=Place(gpu:0), stop_gradient=True, # [[0., 1., 0.], # [0., 0., 1.], # [0., 1., 0.]])
-
index_sample
(
index
)
[source]
index_sample¶
-
IndexSample Layer
IndexSample OP returns the element of the specified location of X, and the location is specified by Index.
Given: X = [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]] Index = [[0, 1, 3], [0, 2, 4]] Then: Out = [[1, 2, 4], [6, 8, 10]]
- Parameters
-
x (Tensor) – The source input tensor with 2-D shape. Supported data type is int32, int64, bfloat16, float16, float32, float64.
index (Tensor) – The index input tensor with 2-D shape, first dimension should be same with X. Data type is int32 or int64.
- Returns
-
The output is a tensor with the same shape as index.
- Return type
-
output (Tensor)
Examples
import paddle x = paddle.to_tensor([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0], [9.0, 10.0, 11.0, 12.0]], dtype='float32') index = paddle.to_tensor([[0, 1, 2], [1, 2, 3], [0, 0, 0]], dtype='int32') target = paddle.to_tensor([[100, 200, 300, 400], [500, 600, 700, 800], [900, 1000, 1100, 1200]], dtype='int32') out_z1 = paddle.index_sample(x, index) print(out_z1) #[[1. 2. 3.] # [6. 7. 8.] # [9. 9. 9.]] # Use the index of the maximum value by topk op # get the value of the element of the corresponding index in other tensors top_value, top_index = paddle.topk(x, k=2) out_z2 = paddle.index_sample(target, top_index) print(top_value) #[[ 4. 3.] # [ 8. 7.] # [12. 11.]] print(top_index) #[[3 2] # [3 2] # [3 2]] print(out_z2) #[[ 400 300] # [ 800 700] # [1200 1100]]
-
index_select
(
index,
axis=0,
name=None
)
[source]
index_select¶
-
Returns a new tensor which indexes the
input
tensor along dimensionaxis
using the entries inindex
which is a Tensor. The returned tensor has the same number of dimensions as the originalx
tensor. The dim-th dimension has the same size as the length ofindex
; other dimensions have the same size as in thex
tensor.- Parameters
-
x (Tensor) – The input Tensor to be operated. The data of
x
can be one of float16, float32, float64, int32, int64.index (Tensor) – The 1-D Tensor containing the indices to index. The data type of
index
must be int32 or int64.axis (int, optional) – The dimension in which we index. Default: if None, the
axis
is 0.name (str, optional) – For details, please refer to Name. Generally, no setting is required. Default: None.
- Returns
-
A Tensor with same data type as
x
. - Return type
-
Tensor
Examples
import paddle x = paddle.to_tensor([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0], [9.0, 10.0, 11.0, 12.0]]) index = paddle.to_tensor([0, 1, 1], dtype='int32') out_z1 = paddle.index_select(x=x, index=index) #[[1. 2. 3. 4.] # [5. 6. 7. 8.] # [5. 6. 7. 8.]] out_z2 = paddle.index_select(x=x, index=index, axis=1) #[[ 1. 2. 2.] # [ 5. 6. 6.] # [ 9. 10. 10.]]
-
inner
(
y,
name=None
)
[source]
inner¶
-
Inner product of two input Tensor.
Ordinary inner product for 1-D Tensors, in higher dimensions a sum product over the last axes.
- Parameters
-
x (Tensor) – An N-D Tensor or a Scalar Tensor. If its not a scalar Tensor, its last dimensions must match y’s.
y (Tensor) – An N-D Tensor or a Scalar Tensor. If its not a scalar Tensor, its last dimensions must match x’s.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
The inner-product Tensor, the output shape is x.shape[:-1] + y.shape[:-1].
- Return type
-
Tensor
Examples
import paddle x = paddle.arange(1, 7).reshape((2, 3)).astype('float32') y = paddle.arange(1, 10).reshape((3, 3)).astype('float32') out = paddle.inner(x, y) print(out) # ([[14, 32, 50], # [32, 77, 122]])
- property inplace_version
-
The inplace version of current Tensor. The version number is incremented whenever the current Tensor is modified through an inplace operation.
Notes: This is a read-only property
Examples
import paddle var = paddle.ones(shape=[4, 2, 3], dtype="float32") print(var.inplace_version) # 0 var[1] = 2.2 print(var.inplace_version) # 1
-
inverse
(
name=None
)
[source]
inverse¶
-
Takes the inverse of the square matrix. A square matrix is a matrix with the same number of rows and columns. The input can be a square matrix (2-D Tensor) or batches of square matrices.
- Parameters
-
x (Tensor) – The input tensor. The last two dimensions should be equal. When the number of dimensions is greater than 2, it is treated as batches of square matrix. The data type can be float32 and float64.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
- A Tensor holds the inverse of x. The shape and data type
-
is the same as x.
- Return type
-
Tensor
Examples
import paddle mat = paddle.to_tensor([[2, 0], [0, 2]], dtype='float32') inv = paddle.inverse(mat) print(inv) # [[0.5, 0], [0, 0.5]]
-
is_complex
(
)
[source]
is_complex¶
-
Return whether x is a tensor of complex data type(complex64 or complex128).
- Parameters
-
x (Tensor) – The input tensor.
- Returns
-
True if the data type of the input is complex data type, otherwise false.
- Return type
-
bool
Examples
import paddle x = paddle.to_tensor([1 + 2j, 3 + 4j]) print(paddle.is_complex(x)) # True x = paddle.to_tensor([1.1, 1.2]) print(paddle.is_complex(x)) # False x = paddle.to_tensor([1, 2, 3]) print(paddle.is_complex(x)) # False
-
is_empty
(
name=None
)
[source]
is_empty¶
-
Test whether a Tensor is empty.
- Parameters
-
x (Tensor) – The Tensor to be tested.
name (str, optional) – The default value is
None
. Normally users don’t have to set this parameter. For more information, please refer to Name .
- Returns
-
A bool scalar Tensor. True if ‘x’ is an empty Tensor.
- Return type
-
Tensor
Examples
import paddle input = paddle.rand(shape=[4, 32, 32], dtype='float32') res = paddle.is_empty(x=input) # res: Tensor(shape=[], dtype=bool, place=Place(cpu), stop_gradient=True, # False)
-
is_floating_point
(
)
[source]
is_floating_point¶
-
Returns whether the dtype of x is one of paddle.float64, paddle.float32, paddle.float16, and paddle.bfloat16.
- Parameters
-
x (Tensor) – The input tensor.
- Returns
-
True if the dtype of x is floating type, otherwise false.
- Return type
-
bool
Examples
import paddle x = paddle.arange(1., 5., dtype='float32') y = paddle.arange(1, 5, dtype='int32') print(paddle.is_floating_point(x)) # True print(paddle.is_floating_point(y)) # False
-
is_integer
(
)
[source]
is_integer¶
-
Return whether x is a tensor of integeral data type.
- Parameters
-
x (Tensor) – The input tensor.
- Returns
-
True if the data type of the input is integer data type, otherwise false.
- Return type
-
bool
Examples
import paddle x = paddle.to_tensor([1 + 2j, 3 + 4j]) print(paddle.is_integer(x)) # False x = paddle.to_tensor([1.1, 1.2]) print(paddle.is_integer(x)) # False x = paddle.to_tensor([1, 2, 3]) print(paddle.is_integer(x)) # True
-
is_tensor
(
)
[source]
is_tensor¶
-
Tests whether input object is a paddle.Tensor.
- Parameters
-
x (object) – Object to test.
- Returns
-
A boolean value. True if
x
is a paddle.Tensor, otherwise False.
Examples
import paddle input1 = paddle.rand(shape=[2, 3, 5], dtype='float32') check = paddle.is_tensor(input1) print(check) #True input3 = [1, 4] check = paddle.is_tensor(input3) print(check) #False
-
isclose
(
y,
rtol=1e-05,
atol=1e-08,
equal_nan=False,
name=None
)
[source]
isclose¶
-
Check if all \(x\) and \(y\) satisfy the condition:
\[\left| x - y \right| \leq atol + rtol \times \left| y \right|\]elementwise, for all elements of \(x\) and \(y\). The behaviour of this operator is analogous to \(numpy.isclose\), namely that it returns \(True\) if two tensors are elementwise equal within a tolerance.
- Parameters
-
x (Tensor) – The input tensor, it’s data type should be float16, float32, float64.
y (Tensor) – The input tensor, it’s data type should be float16, float32, float64.
rtol (rtoltype, optional) – The relative tolerance. Default: \(1e-5\) .
atol (atoltype, optional) – The absolute tolerance. Default: \(1e-8\) .
equal_nan (equalnantype, optional) – If \(True\) , then two \(NaNs\) will be compared as equal. Default: \(False\) .
name (str, optional) – Name for the operation. For more information, please refer to Name. Default: None.
- Returns
-
The output tensor, it’s data type is bool.
- Return type
-
Tensor
Examples
import paddle x = paddle.to_tensor([10000., 1e-07]) y = paddle.to_tensor([10000.1, 1e-08]) result1 = paddle.isclose(x, y, rtol=1e-05, atol=1e-08, equal_nan=False, name="ignore_nan") # [True, False] result2 = paddle.isclose(x, y, rtol=1e-05, atol=1e-08, equal_nan=True, name="equal_nan") # [True, False] x = paddle.to_tensor([1.0, float('nan')]) y = paddle.to_tensor([1.0, float('nan')]) result1 = paddle.isclose(x, y, rtol=1e-05, atol=1e-08, equal_nan=False, name="ignore_nan") # [True, False] result2 = paddle.isclose(x, y, rtol=1e-05, atol=1e-08, equal_nan=True, name="equal_nan") # [True, True]
-
isfinite
(
name=None
)
[source]
isfinite¶
-
Return whether every element of input tensor is finite number or not.
- Parameters
-
x (Tensor) – The input tensor, it’s data type should be float16, float32, float64, int32, int64.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, the bool result which shows every element of x whether it is finite number or not.
Examples
import paddle x = paddle.to_tensor([float('-inf'), -2, 3.6, float('inf'), 0, float('-nan'), float('nan')]) out = paddle.isfinite(x) print(out) # [False True True False True False False]
-
isinf
(
name=None
)
[source]
isinf¶
-
Return whether every element of input tensor is +/-INF or not.
- Parameters
-
x (Tensor) – The input tensor, it’s data type should be float16, float32, float64, int32, int64.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, the bool result which shows every element of x whether it is +/-INF or not.
Examples
import paddle x = paddle.to_tensor([float('-inf'), -2, 3.6, float('inf'), 0, float('-nan'), float('nan')]) out = paddle.isinf(x) print(out) # [ True False False True False False False]
-
isnan
(
name=None
)
[source]
isnan¶
-
Return whether every element of input tensor is NaN or not.
- Parameters
-
x (Tensor) – The input tensor, it’s data type should be float16, float32, float64, int32, int64.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, the bool result which shows every element of x whether it is NaN or not.
Examples
import paddle x = paddle.to_tensor([float('-inf'), -2, 3.6, float('inf'), 0, float('-nan'), float('nan')]) out = paddle.isnan(x) print(out) # [False False False False False True True]
-
item
(
*args
)
item¶
-
Convert element at specific position in Tensor into Python scalars. If the position is not specified, the Tensor must be a single-element Tensor.
- Parameters
-
*args (int) – The input coordinates. If it’s single int, the data in the corresponding order of flattened Tensor will be returned. Default: None, and it must be in the case where Tensor has only one element.
Returns(Python scalar): A Python scalar, whose dtype is corresponds to the dtype of Tensor.
- Raises
-
ValueError – If the Tensor has more than one element, there must be coordinates.
Examples
import paddle x = paddle.to_tensor(1) print(x.item()) #1 print(type(x.item())) #<class 'int'> x = paddle.to_tensor(1.0) print(x.item()) #1.0 print(type(x.item())) #<class 'float'> x = paddle.to_tensor(True) print(x.item()) #True print(type(x.item())) #<class 'bool'> x = paddle.to_tensor(1+1j) print(x.item()) #(1+1j) print(type(x.item())) #<class 'complex'> x = paddle.to_tensor([[1.1, 2.2, 3.3]]) print(x.item(2)) #3.3 print(x.item(0, 2)) #3.3
-
kron
(
y,
name=None
)
[source]
kron¶
-
Compute the Kronecker product of two tensors, a composite tensor made of blocks of the second tensor scaled by the first. Assume that the rank of the two tensors, $X$ and $Y$ are the same, if necessary prepending the smallest with ones. If the shape of $X$ is [$r_0$, $r_1$, …, $r_N$] and the shape of $Y$ is [$s_0$, $s_1$, …, $s_N$], then the shape of the output tensor is [$r_{0}s_{0}$, $r_{1}s_{1}$, …, $r_{N}s_{N}$]. The elements are products of elements from $X$ and $Y$. The equation is: $$ output[k_{0}, k_{1}, …, k_{N}] = X[i_{0}, i_{1}, …, i_{N}] * Y[j_{0}, j_{1}, …, j_{N}] $$ where $$ k_{t} = i_{t} * s_{t} + j_{t}, t = 0, 1, …, N $$
- Parameters
-
x (Tensor) – the fist operand of kron op, data type: float16, float32, float64, int32 or int64.
y (Tensor) – the second operand of kron op, data type: float16, float32, float64, int32 or int64. Its data type should be the same with x.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
The output of kron, data type: float16, float32, float64, int32 or int64. Its data is the same with x.
- Return type
-
Tensor
Examples
import paddle x = paddle.to_tensor([[1, 2], [3, 4]], dtype='int64') y = paddle.to_tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype='int64') out = paddle.kron(x, y) print(out) # [[1, 2, 3, 2, 4, 6], # [ 4, 5, 6, 8, 10, 12], # [ 7, 8, 9, 14, 16, 18], # [ 3, 6, 9, 4, 8, 12], # [12, 15, 18, 16, 20, 24], # [21, 24, 27, 28, 32, 36]])
-
kthvalue
(
k,
axis=None,
keepdim=False,
name=None
)
[source]
kthvalue¶
-
Find values and indices of the k-th smallest at the axis.
- Parameters
-
x (Tensor) – A N-D Tensor with type float16, float32, float64, int32, int64.
k (int) – The k for the k-th smallest number to look for along the axis.
axis (int, optional) – Axis to compute indices along. The effective range is [-R, R), where R is x.ndim. when axis < 0, it works the same way as axis + R. The default is None. And if the axis is None, it will computed as -1 by default.
keepdim (bool, optional) – Whether to keep the given axis in output. If it is True, the dimensions will be same as input x and with size one in the axis. Otherwise the output dimentions is one fewer than x since the axis is squeezed. Default is False.
name (str, optional) – For details, please refer to Name. Generally, no setting is required. Default: None.
- Returns
-
tuple(Tensor), return the values and indices. The value data type is the same as the input x. The indices data type is int64.
Examples
import paddle x = paddle.randn((2,3,2)) # Tensor(shape=[2, 3, 2], dtype=float32, place=CUDAPlace(0), stop_gradient=True, # [[[ 0.22954939, -0.01296274], # [ 1.17135799, -0.34493217], # [-0.19550551, -0.17573971]], # # [[ 0.15104349, -0.93965352], # [ 0.14745511, 0.98209465], # [ 0.10732264, -0.55859774]]]) y = paddle.kthvalue(x, 2, 1) # (Tensor(shape=[2, 2], dtype=float32, place=CUDAPlace(0), stop_gradient=True, # [[ 0.22954939, -0.17573971], # [ 0.14745511, -0.55859774]]), Tensor(shape=[2, 2], dtype=int64, place=CUDAPlace(0), stop_gradient=True, # [[0, 2], # [1, 2]]))
-
lcm
(
y,
name=None
)
[source]
lcm¶
-
Computes the element-wise least common multiple (LCM) of input |x| and |y|. Both x and y must have integer types.
Note
lcm(0,0)=0, lcm(0, y)=0
If x.shape != y.shape, they must be broadcastable to a common shape (which becomes the shape of the output).
- Parameters
-
x (Tensor) – An N-D Tensor, the data type is int32, int64.
y (Tensor) – An N-D Tensor, the data type is int32, int64.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
An N-D Tensor, the data type is the same with input.
- Return type
-
out (Tensor)
Examples
import paddle x1 = paddle.to_tensor(12) x2 = paddle.to_tensor(20) paddle.lcm(x1, x2) # Tensor(shape=[], dtype=int64, place=CUDAPlace(0), stop_gradient=True, # 60) x3 = paddle.arange(6) paddle.lcm(x3, x2) # Tensor(shape=[6], dtype=int64, place=CUDAPlace(0), stop_gradient=True, # [0, 20, 20, 60, 20, 20]) x4 = paddle.to_tensor(0) paddle.lcm(x4, x2) # Tensor(shape=[], dtype=int64, place=CUDAPlace(0), stop_gradient=True, # 0) paddle.lcm(x4, x4) # Tensor(shape=[], dtype=int64, place=CUDAPlace(0), stop_gradient=True, # 0) x5 = paddle.to_tensor(-20) paddle.lcm(x1, x5) # Tensor(shape=[], dtype=int64, place=CUDAPlace(0), stop_gradient=True, # 60)
-
ldexp
(
y,
name=None
)
[source]
ldexp¶
-
Compute the result of multiplying x by 2 to the power of y. The equation is:
\[out = x * 2^{y}\]- Parameters
-
x (Tensor) – The input Tensor, the data type is float32, float64, int32 or int64.
y (Tensor) – A Tensor of exponents, typically integers.
name (str, optional) – Name for the operation (optional, default is None).For more information, please refer to Name.
- Returns
-
An N-D Tensor. If x, y have different shapes and are “broadcastable”, the resulting tensor shape is the shape of x and y after broadcasting. If x, y have the same shape, its shape is the same as x and y. And the data type is float32 or float64.
- Return type
-
out (Tensor)
Examples
import paddle #example1 x = paddle.to_tensor([1, 2, 3], dtype='float32') y = paddle.to_tensor([2, 3, 4], dtype='int32') res = paddle.ldexp(x, y) print(res) # Tensor(shape=[3], dtype=float32, place=CUDAPlace(0), stop_gradient=True, # [4., 16., 48.]) #example2 x = paddle.to_tensor([1, 2, 3], dtype='float32') y = paddle.to_tensor([2], dtype='int32') res = paddle.ldexp(x, y) print(res) # Tensor(shape=[3], dtype=float32, place=CUDAPlace(0), stop_gradient=True, # [4., 8., 12.])
-
lerp
(
y,
weight,
name=None
)
[source]
lerp¶
-
Does a linear interpolation between x and y based on weight.
- Equation:
-
\[lerp(x, y, weight) = x + weight * (y - x).\]
- Parameters
-
x (Tensor) – An N-D Tensor with starting points, the data type is float16, float32, float64.
y (Tensor) – An N-D Tensor with ending points, the data type is float16, float32, float64.
weight (float|Tensor) – The weight for the interpolation formula. When weight is Tensor, the data type is float16, float32, float64.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
An N-D Tensor, the shape and data type is the same with input.
- Return type
-
out (Tensor)
Example
import paddle x = paddle.arange(1., 5., dtype='float32') y = paddle.empty([4], dtype='float32') y.fill_(10.) out = paddle.lerp(x, y, 0.5) # out: [5.5, 6., 6.5, 7.]
-
lerp_
(
y,
weight,
name=None
)
lerp_¶
-
Inplace version of
lerp
API, the output Tensor will be inplaced with inputx
. Please refer to api_tensor_lerp.
-
less_equal
(
y,
name=None
)
[source]
less_equal¶
-
Returns the truth value of \(x <= y\) elementwise, which is equivalent function to the overloaded operator <=.
Note
The output has no gradient.
- Parameters
-
x (Tensor) – First input to compare which is N-D tensor. The input data type should be bool, float16, float32, float64, int32, int64.
y (Tensor) – Second input to compare which is N-D tensor. The input data type should be bool, float16, float32, float64, int32, int64.
name (str, optional) – The default value is None. Normally there is no need for user to set this property. For more information, please refer to Name.
- Returns
-
The output shape is same as input
x
. The output data type is bool. - Return type
-
Tensor
Examples
import paddle x = paddle.to_tensor([1, 2, 3]) y = paddle.to_tensor([1, 3, 2]) result1 = paddle.less_equal(x, y) print(result1) # result1 = [True True False]
-
less_than
(
y,
name=None
)
[source]
less_than¶
-
Returns the truth value of \(x < y\) elementwise, which is equivalent function to the overloaded operator <.
Note
The output has no gradient.
- Parameters
-
x (Tensor) – First input to compare which is N-D tensor. The input data type should be bool, float16, float32, float64, int32, int64.
y (Tensor) – Second input to compare which is N-D tensor. The input data type should be bool, float16, float32, float64, int32, int64.
name (str, optional) – The default value is None. Normally there is no need for user to set this property. For more information, please refer to Name.
- Returns
-
The output shape is same as input
x
. The output data type is bool. - Return type
-
Tensor
Examples
import paddle x = paddle.to_tensor([1, 2, 3]) y = paddle.to_tensor([1, 3, 2]) result1 = paddle.less_than(x, y) print(result1) # result1 = [False True False]
-
lgamma
(
name=None
)
[source]
lgamma¶
-
Calculates the lgamma of the given input tensor, element-wise.
This operator performs elementwise lgamma for input $X$. \(out = log\Gamma(x)\)
- Parameters
-
x (Tensor) – Input Tensor. Must be one of the following types: float16, float32, float64, uint16.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, the lgamma of the input Tensor, the shape and data type is the same with input.
Examples
import paddle x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3]) out = paddle.lgamma(x) print(out) # [1.31452441, 1.76149750, 2.25271273, 1.09579802]
-
log
(
name=None
)
[source]
log¶
-
Calculates the natural log of the given input Tensor, element-wise.
\[Out = \ln(x)\]- Parameters
-
x (Tensor) – Input Tensor. Must be one of the following types: float16, float32, float64.
name (str|None) – The default value is None. Normally there is no need for user to set this property. For more information, please refer to Name
- Returns
-
The natural log of the input Tensor computed element-wise.
- Return type
-
Tensor
Examples
import paddle x = [[2,3,4], [7,8,9]] x = paddle.to_tensor(x, dtype='float32') res = paddle.log(x) # [[0.693147, 1.09861, 1.38629], [1.94591, 2.07944, 2.19722]]
-
log10
(
name=None
)
[source]
log10¶
-
Calculates the log to the base 10 of the given input tensor, element-wise.
\[Out = \log_10_x\]- Parameters
-
x (Tensor) – Input tensor must be one of the following types: float32, float64.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
The log to the base 10 of the input Tensor computed element-wise.
- Return type
-
Tensor
Examples
import paddle # example 1: x is a float x_i = paddle.to_tensor([[1.0], [10.0]]) res = paddle.log10(x_i) # [[0.], [1.0]] # example 2: x is float32 x_i = paddle.full(shape=[1], fill_value=10, dtype='float32') paddle.to_tensor(x_i) res = paddle.log10(x_i) print(res) # [1.0] # example 3: x is float64 x_i = paddle.full(shape=[1], fill_value=10, dtype='float64') paddle.to_tensor(x_i) res = paddle.log10(x_i) print(res) # [1.0]
-
log1p
(
name=None
)
[source]
log1p¶
-
Calculates the natural log of the given input tensor, element-wise.
\[Out = \ln(x+1)\]- Parameters
-
x (Tensor) – Input Tensor. Must be one of the following types: float16, float32, float64.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, the natural log of the input Tensor computed element-wise.
Examples
import paddle data = paddle.to_tensor([[0], [1]], dtype='float32') res = paddle.log1p(data) # [[0.], [0.6931472]]
-
log2
(
name=None
)
[source]
log2¶
-
Calculates the log to the base 2 of the given input tensor, element-wise.
\[Out = \log_2x\]- Parameters
-
x (Tensor) – Input tensor must be one of the following types: float32, float64.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
The log to the base 2 of the input Tensor computed element-wise.
- Return type
-
Tensor
Examples
import paddle # example 1: x is a float x_i = paddle.to_tensor([[1.0], [2.0]]) res = paddle.log2(x_i) # [[0.], [1.0]] # example 2: x is float32 x_i = paddle.full(shape=[1], fill_value=2, dtype='float32') paddle.to_tensor(x_i) res = paddle.log2(x_i) print(res) # [1.0] # example 3: x is float64 x_i = paddle.full(shape=[1], fill_value=2, dtype='float64') paddle.to_tensor(x_i) res = paddle.log2(x_i) print(res) # [1.0]
-
logaddexp
(
y,
name=None
)
[source]
logaddexp¶
-
Elementwise LogAddExp Operator. Add of exponentiations of the inputs The equation is:
\[Out=log(X.exp()+Y.exp())\]$X$ the tensor of any dimension. $Y$ the tensor whose dimensions must be less than or equal to the dimensions of $X$.
There are two cases for this operator:
The shape of $Y$ is the same with $X$.
The shape of $Y$ is a continuous subsequence of $X$.
For case 2:
Broadcast $Y$ to match the shape of $X$, where axis is the start dimension index for broadcasting $Y$ onto $X$.
If $axis$ is -1 (default), $axis$=rank($X$)-rank($Y$).
The trailing dimensions of size 1 for $Y$ will be ignored for the consideration of subsequence, such as shape($Y$) = (2, 1) => (2).
For example:
shape(X) = (2, 3, 4, 5), shape(Y) = (,) shape(X) = (2, 3, 4, 5), shape(Y) = (5,) shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2 shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1 shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0 shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0
- Parameters
-
x (Tensor) – Tensor or LoDTensor of any dimensions. Its dtype should be float32, float64, float16.
y (Tensor) – Tensor or LoDTensor of any dimensions. Its dtype should be float32, float64, float16.
name (string, optional) – For details, please refer to Name. Generally, no setting is required. Default: None.
- Returns
-
N-D Tensor. A location into which the result is stored. It’s dimension equals with x.
Examples
import paddle x = paddle.to_tensor([-1, -2, -3], 'float64') y = paddle.to_tensor([-1], 'float64') z = paddle.logaddexp(x, y) print(z) # [-0.30685282, -0.68673831, -0.87307199]
-
logcumsumexp
(
axis=None,
dtype=None,
name=None
)
[source]
logcumsumexp¶
-
The logarithm of the cumulative summation of the exponentiation of the elements along a given axis.
For summation index j given by axis and other indices i, the result is
\[logcumsumexp(x)_{ij} = log \sum_{i=0}^{j}exp(x_{ij})\]Note
The first element of the result is the same as the first element of the input.
- Parameters
-
x (Tensor) – The input tensor.
axis (int, optional) – The dimension to do the operation along. -1 means the last dimension. The default (None) is to compute the cumsum over the flattened array.
dtype (str, optional) – The data type of the output tensor, can be float16, float32, float64. If specified, the input tensor is casted to dtype before the operation is performed. This is useful for preventing data type overflows. The default value is None.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, the result of logcumsumexp operator.
Examples
import paddle data = paddle.arange(12, dtype='float64') data = paddle.reshape(data, (3, 4)) y = paddle.logcumsumexp(data) # [ 0. 1.3132617 2.4076061 3.4401898 4.4519143 5.4561934 # 6.4577627 7.4583397 8.458551 9.45863 10.458658 11.458669 ] y = paddle.logcumsumexp(data, axis=0) # [[ 0. 1. 2. 3. ] # [ 4.01815 5.01815 6.01815 7.01815 ] # [ 8.018479 9.018479 10.018479 11.018479]] y = paddle.logcumsumexp(data, axis=-1) # [[ 0. 1.3132617 2.4076061 3.4401898] # [ 4. 5.3132615 6.407606 7.44019 ] # [ 8. 9.313262 10.407606 11.440189 ]] y = paddle.logcumsumexp(data, dtype='float64') print(y.dtype) # paddle.float64
-
logical_and
(
y,
out=None,
name=None
)
[source]
logical_and¶
-
Compute element-wise logical AND on
x
andy
, and returnout
.out
is N-dim booleanTensor
. Each element ofout
is calculated by\[out = x \&\& y\]Note
paddle.logical_and
supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ .- Parameters
-
x (Tensor) – the input tensor, it’s data type should be one of bool, int8, int16, in32, in64, float16, float32, float64.
y (Tensor) – the input tensor, it’s data type should be one of bool, int8, int16, in32, in64, float16, float32, float64.
out (Tensor, optional) – The
Tensor
that specifies the output of the operator, which can be anyTensor
that has been created in the program. The default value is None, and a newTensor
will be created to save the output.name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
N-D Tensor. A location into which the result is stored. It’s dimension equals with
x
.
Examples
import paddle x = paddle.to_tensor([True]) y = paddle.to_tensor([True, False, True, False]) res = paddle.logical_and(x, y) print(res) # [True False True False]
-
logical_not
(
out=None,
name=None
)
[source]
logical_not¶
-
logical_not
operator computes element-wise logical NOT onx
, and returnsout
.out
is N-dim booleanVariable
. Each element ofout
is calculated by\[out = !x\]Note
paddle.logical_not
supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ .- Parameters
-
x (Tensor) – Operand of logical_not operator. Must be a Tensor of type bool, int8, int16, in32, in64, float16, float32, or float64.
out (Tensor) – The
Tensor
that specifies the output of the operator, which can be anyTensor
that has been created in the program. The default value is None, and a new ``Tensor` will be created to save the output.name (str|None) – The default value is None. Normally there is no need for users to set this property. For more information, please refer to Name.
- Returns
-
N-D Tensor. A location into which the result is stored. It’s dimension equals with
x
.
Examples
import paddle x = paddle.to_tensor([True, False, True, False]) res = paddle.logical_not(x) print(res) # [False True False True]
-
logical_or
(
y,
out=None,
name=None
)
[source]
logical_or¶
-
logical_or
operator computes element-wise logical OR onx
andy
, and returnsout
.out
is N-dim booleanTensor
. Each element ofout
is calculated by\[out = x || y\]Note
paddle.logical_or
supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ .- Parameters
-
x (Tensor) – the input tensor, it’s data type should be one of bool, int8, int16, in32, in64, float16, float32, float64.
y (Tensor) – the input tensor, it’s data type should be one of bool, int8, int16, in32, in64, float16, float32, float64.
out (Tensor) – The
Variable
that specifies the output of the operator, which can be anyTensor
that has been created in the program. The default value is None, and a newTensor
will be created to save the output.name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
N-D Tensor. A location into which the result is stored. It’s dimension equals with
x
.
Examples
import paddle x = paddle.to_tensor([True, False], dtype="bool").reshape([2, 1]) y = paddle.to_tensor([True, False, True, False], dtype="bool").reshape([2, 2]) res = paddle.logical_or(x, y) print(res) # Tensor(shape=[2, 2], dtype=bool, place=Place(cpu), stop_gradient=True, # [[True , True ], # [True , False]])
-
logical_xor
(
y,
out=None,
name=None
)
[source]
logical_xor¶
-
logical_xor
operator computes element-wise logical XOR onx
andy
, and returnsout
.out
is N-dim booleanTensor
. Each element ofout
is calculated by\[out = (x || y) \&\& !(x \&\& y)\]Note
paddle.logical_xor
supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ .- Parameters
-
x (Tensor) – the input tensor, it’s data type should be one of bool, int8, int16, in32, in64, float16, float32, float64.
y (Tensor) – the input tensor, it’s data type should be one of bool, int8, int16, in32, in64, float16, float32, float64.
out (Tensor) – The
Tensor
that specifies the output of the operator, which can be anyTensor
that has been created in the program. The default value is None, and a newTensor
will be created to save the output.name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
N-D Tensor. A location into which the result is stored. It’s dimension equals with
x
.
Examples
import paddle x = paddle.to_tensor([True, False], dtype="bool").reshape([2, 1]) y = paddle.to_tensor([True, False, True, False], dtype="bool").reshape([2, 2]) res = paddle.logical_xor(x, y) print(res) # Tensor(shape=[2, 2], dtype=bool, place=Place(cpu), stop_gradient=True, # [[False, True ], # [True , False]])
-
logit
(
eps=None,
name=None
)
[source]
logit¶
-
This function generates a new tensor with the logit of the elements of input x. x is clamped to [eps, 1-eps] when eps is not zero. When eps is zero and x < 0 or x > 1, the function will yields NaN.
\[logit(x) = ln(\frac{x}{1 - x})\]where
\[\begin{split}x_i= \left\{\begin{array}{rcl} x_i & &\text{if } eps == Default \\ eps & &\text{if } x_i < eps \\ x_i & &\text{if } eps <= x_i <= 1-eps \\ 1-eps & &\text{if } x_i > 1-eps \end{array}\right.\end{split}\]- Parameters
-
x (Tensor) – The input Tensor with data type float32, float64.
eps (float, optional) – the epsilon for input clamp bound. Default is None.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
A Tensor with the same data type and shape as
x
. - Return type
-
out(Tensor)
Examples
import paddle x = paddle.to_tensor([0.2635, 0.0106, 0.2780, 0.2097, 0.8095]) out1 = paddle.logit(x) print(out1) # [-1.0277, -4.5365, -0.9544, -1.3269, 1.4468]
-
logsumexp
(
axis=None,
keepdim=False,
name=None
)
[source]
logsumexp¶
-
Calculates the log of the sum of exponentials of
x
alongaxis
.\[logsumexp(x) = \log\sum exp(x)\]- Parameters
-
x (Tensor) – The input Tensor with data type float16, float32 or float64, which have no more than 4 dimensions.
axis (int|list|tuple, optional) – The axis along which to perform logsumexp calculations.
axis
should be int, list(int) or tuple(int). Ifaxis
is a list/tuple of dimension(s), logsumexp is calculated along all element(s) ofaxis
.axis
or element(s) ofaxis
should be in range [-D, D), where D is the dimensions ofx
. Ifaxis
or element(s) ofaxis
is less than 0, it works the same way as \(axis + D\) . Ifaxis
is None, logsumexp is calculated along all elements ofx
. Default is None.keepdim (bool, optional) – Whether to reserve the reduced dimension(s) in the output Tensor. If
keep_dim
is True, the dimensions of the output Tensor is the same asx
except in the reduced dimensions(it is of size 1 in this case). Otherwise, the shape of the output Tensor is squeezed inaxis
. Default is False.name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, results of logsumexp along
axis
ofx
, with the same data type asx
.
Examples:
import paddle x = paddle.to_tensor([[-1.5, 0., 2.], [3., 1.2, -2.4]]) out1 = paddle.logsumexp(x) # 3.4691226 out2 = paddle.logsumexp(x, 1) # [2.15317821, 3.15684602]
-
lstsq
(
y,
rcond=None,
driver=None,
name=None
)
lstsq¶
-
Computes a solution to the least squares problem of a system of linear equations.
- Parameters
-
x (Tensor) – A tensor with shape
(*, M, N)
, the data type of the input Tensorx
should be one of float32, float64.y (Tensor) – A tensor with shape
(*, M, K)
, the data type of the input Tensory
should be one of float32, float64.rcond (float, optional) – The default value is None. A float pointing number used to determine the effective rank of
x
. Ifrcond
is None, it will be set to max(M, N) times the machine precision of x_dtype.driver (str, optional) – The default value is None. The name of LAPACK method to be used. For CPU inputs the valid values are ‘gels’, ‘gelsy’, ‘gelsd, ‘gelss’. For CUDA input, the only valid driver is ‘gels’. If
driver
is None, ‘gelsy’ is used for CPU inputs and ‘gels’ for CUDA inputs.name (str, optional) – The default value is None. Normally there is no need for user to set this property. For more information, please refer to Name.
- Returns
-
A tuple of 4 Tensors which is (
solution
,residuals
,rank
,singular_values
).solution
is a tensor with shape(*, N, K)
, meaning the least squares solution.residuals
is a tensor with shape(*, K)
, meaning the squared residuals of the solutions, which is computed when M > N and every matrix inx
is full-rank, otherwise return an empty tensor.rank
is a tensor with shape(*)
, meaning the ranks of the matrices inx
, which is computed whendriver
in (‘gelsy’, ‘gelsd’, ‘gelss’), otherwise return an empty tensor.singular_values
is a tensor with shape(*, min(M, N))
, meaning singular values of the matrices inx
, which is computed whendriver
in (‘gelsd’, ‘gelss’), otherwise return an empty tensor. - Return type
-
Tuple
Examples
import paddle paddle.set_device("cpu") x = paddle.to_tensor([[1, 3], [3, 2], [5, 6.]]) y = paddle.to_tensor([[3, 4, 6], [5, 3, 4], [1, 2, 1.]]) results = paddle.linalg.lstsq(x, y, driver="gelsd") print(results[0]) # [[ 0.78350395, -0.22165027, -0.62371236], # [-0.11340097, 0.78866047, 1.14948535]] print(results[1]) # [19.81443405, 10.43814468, 30.56185532]) print(results[2]) # 2 print(results[3]) # [9.03455734, 1.54167950] x = paddle.to_tensor([[10, 2, 3], [3, 10, 5], [5, 6, 12.]]) y = paddle.to_tensor([[4, 2, 9], [2, 0, 3], [2, 5, 3.]]) results = paddle.linalg.lstsq(x, y, driver="gels") print(results[0]) # [[ 0.39386186, 0.10230173, 0.93606132], # [ 0.10741687, -0.29028133, 0.11892585], # [-0.05115091, 0.51918161, -0.19948854]] print(results[1]) # []
-
lu
(
pivot=True,
get_infos=False,
name=None
)
lu¶
-
Computes the LU factorization of an N-D(N>=2) matrix x.
Returns the LU factorization(inplace x) and Pivots. low triangular matrix L and upper triangular matrix U are combined to a single LU matrix.
Pivoting is done if pivot is set to True. P mat can be get by pivots:
- Parameters
-
X (Tensor) – the tensor to factor of N-dimensions(N>=2).
pivot (bool, optional) – controls whether pivoting is done. Default: True.
get_infos (bool, optional) – if set to True, returns an info IntTensor. Default: False.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
factorization (Tensor), LU matrix, the factorization of input X.
pivots (IntTensor), the pivots of size(∗(N-2), min(m,n)). pivots stores all the intermediate transpositions of rows. The final permutation perm could be reconstructed by this, details refer to upper example.
infos (IntTensor, optional), if get_infos is True, this is a tensor of size (∗(N-2)) where non-zero values indicate whether factorization for the matrix or each minibatch has succeeded or failed.
Examples
import paddle x = paddle.to_tensor([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]).astype('float64') lu,p,info = paddle.linalg.lu(x, get_infos=True) # >>> lu: # Tensor(shape=[3, 2], dtype=float64, place=CUDAPlace(0), stop_gradient=True, # [[5. , 6. ], # [0.20000000, 0.80000000], # [0.60000000, 0.50000000]]) # >>> p # Tensor(shape=[2], dtype=int32, place=CUDAPlace(0), stop_gradient=True, # [3, 3]) # >>> info # Tensor(shape=[], dtype=int32, place=CUDAPlace(0), stop_gradient=True, # 0) P,L,U = paddle.linalg.lu_unpack(lu,p) # >>> P # (Tensor(shape=[3, 3], dtype=float64, place=CUDAPlace(0), stop_gradient=True, # [[0., 1., 0.], # [0., 0., 1.], # [1., 0., 0.]]), # >>> L # Tensor(shape=[3, 2], dtype=float64, place=CUDAPlace(0), stop_gradient=True, # [[1. , 0. ], # [0.20000000, 1. ], # [0.60000000, 0.50000000]]), # >>> U # Tensor(shape=[2, 2], dtype=float64, place=CUDAPlace(0), stop_gradient=True, # [[5. , 6. ], # [0. , 0.80000000]])) # one can verify : X = P @ L @ U ;
-
lu_unpack
(
y,
unpack_ludata=True,
unpack_pivots=True,
name=None
)
lu_unpack¶
-
Unpack L U and P to single matrix tensor . unpack L and U matrix from LU, unpack permutation matrix P from Pivtos .
P mat can be get by pivots:
- Parameters
-
x (Tensor) – The LU tensor get from paddle.linalg.lu, which is combined by L and U.
y (Tensor) – Pivots get from paddle.linalg.lu.
unpack_ludata (bool,optional) – whether to unpack L and U from x. Default: True.
unpack_pivots (bool, optional) – whether to unpack permutation matrix P from Pivtos. Default: True.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
P (Tensor), Permutation matrix P of lu factorization.
L (Tensor), The lower triangular matrix tensor of lu factorization.
U (Tensor), The upper triangular matrix tensor of lu factorization.
Examples
import paddle x = paddle.to_tensor([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]).astype('float64') lu,p,info = paddle.linalg.lu(x, get_infos=True) # >>> lu: # Tensor(shape=[3, 2], dtype=float64, place=CUDAPlace(0), stop_gradient=True, # [[5. , 6. ], # [0.20000000, 0.80000000], # [0.60000000, 0.50000000]]) # >>> p # Tensor(shape=[2], dtype=int32, place=CUDAPlace(0), stop_gradient=True, # [3, 3]) # >>> info # Tensor(shape=[], dtype=int32, place=CUDAPlace(0), stop_gradient=True, # 0) P,L,U = paddle.linalg.lu_unpack(lu,p) # >>> P # (Tensor(shape=[3, 3], dtype=float64, place=CUDAPlace(0), stop_gradient=True, # [[0., 1., 0.], # [0., 0., 1.], # [1., 0., 0.]]), # >>> L # Tensor(shape=[3, 2], dtype=float64, place=CUDAPlace(0), stop_gradient=True, # [[1. , 0. ], # [0.20000000, 1. ], # [0.60000000, 0.50000000]]), # >>> U # Tensor(shape=[2, 2], dtype=float64, place=CUDAPlace(0), stop_gradient=True, # [[5. , 6. ], # [0. , 0.80000000]])) # one can verify : X = P @ L @ U ;
-
masked_select
(
mask,
name=None
)
[source]
masked_select¶
-
Returns a new 1-D tensor which indexes the input tensor according to the
mask
which is a tensor with data type of bool.- Parameters
-
x (Tensor) – The input Tensor, the data type can be int32, int64, uint16, float16, float32, float64.
mask (Tensor) – The Tensor containing the binary mask to index with, it’s data type is bool.
name (str, optional) – For details, please refer to Name. Generally, no setting is required. Default: None.
- Returns
-
A 1-D Tensor which is the same data type as
x
.
Examples
import paddle x = paddle.to_tensor([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0], [9.0, 10.0, 11.0, 12.0]]) mask = paddle.to_tensor([[True, False, False, False], [True, True, False, False], [True, False, False, False]]) out = paddle.masked_select(x, mask) #[1.0 5.0 6.0 9.0]
-
matmul
(
y,
transpose_x=False,
transpose_y=False,
name=None
)
[source]
matmul¶
-
Applies matrix multiplication to two tensors. matmul follows the complete broadcast rules, and its behavior is consistent with np.matmul.
Currently, the input tensors’ number of dimensions can be any, matmul can be used to achieve the dot, matmul and batchmatmul.
The actual behavior depends on the shapes of \(x\), \(y\) and the flag values of
transpose_x
,transpose_y
. Specifically:If a transpose flag is specified, the last two dimensions of the tensor are transposed. If the tensor is ndim-1 of shape, the transpose is invalid. If the tensor is ndim-1 of shape \([D]\), then for \(x\) it is treated as \([1, D]\), whereas for \(y\) it is the opposite: It is treated as \([D, 1]\).
The multiplication behavior depends on the dimensions of x and y. Specifically:
If both tensors are 1-dimensional, the dot product result is obtained.
If both tensors are 2-dimensional, the matrix-matrix product is obtained.
If the x is 1-dimensional and the y is 2-dimensional, a 1 is prepended to its dimension in order to conduct the matrix multiply. After the matrix multiply, the prepended dimension is removed.
If the x is 2-dimensional and y is 1-dimensional, the matrix-vector product is obtained.
If both arguments are at least 1-dimensional and at least one argument is N-dimensional (where N > 2), then a batched matrix multiply is obtained. If the first argument is 1-dimensional, a 1 is prepended to its dimension in order to conduct the batched matrix multiply and removed after. If the second argument is 1-dimensional, a 1 is appended to its dimension for the purpose of the batched matrix multiple and removed after. The non-matrix (exclude the last two dimensions) dimensions are broadcasted according the broadcast rule. For example, if input is a (j, 1, n, m) tensor and the other is a (k, m, p) tensor, out will be a (j, k, n, p) tensor.
- Parameters
-
x (Tensor) – The input tensor which is a Tensor.
y (Tensor) – The input tensor which is a Tensor.
transpose_x (bool, optional) – Whether to transpose \(x\) before multiplication.
transpose_y (bool, optional) – Whether to transpose \(y\) before multiplication.
name (str, optional) – A name for this layer(optional). If set None, the layer will be named automatically.
- Returns
-
The output Tensor.
- Return type
-
Tensor
Examples
import paddle # vector * vector x = paddle.rand([10]) y = paddle.rand([10]) z = paddle.matmul(x, y) print(z.shape) # () # matrix * vector x = paddle.rand([10, 5]) y = paddle.rand([5]) z = paddle.matmul(x, y) print(z.shape) # (10,) # batched matrix * broadcasted vector x = paddle.rand([10, 5, 2]) y = paddle.rand([2]) z = paddle.matmul(x, y) print(z.shape) # (10, 5) # batched matrix * batched matrix x = paddle.rand([10, 5, 2]) y = paddle.rand([10, 2, 5]) z = paddle.matmul(x, y) print(z.shape) # (10, 5, 5) # batched matrix * broadcasted matrix x = paddle.rand([10, 1, 5, 2]) y = paddle.rand([1, 3, 2, 5]) z = paddle.matmul(x, y) print(z.shape) # (10, 3, 5, 5)
-
matrix_power
(
n,
name=None
)
matrix_power¶
-
Computes the n-th power of a square matrix or a batch of square matrices.
Let \(X\) be a sqaure matrix or a batch of square matrices, \(n\) be an exponent, the equation should be:
\[Out = X ^ {n}\]Specifically,
If n > 0, it returns the matrix or a batch of matrices raised to the power of n.
If n = 0, it returns the identity matrix or a batch of identity matrices.
If n < 0, it returns the inverse of each matrix (if invertible) raised to the power of abs(n).
- Parameters
-
x (Tensor) – A square matrix or a batch of square matrices to be raised to power n. Its shape should be [*, M, M], where * is zero or more batch dimensions. Its data type should be float32 or float64.
n (int) – The exponent. It can be any positive, negative integer or zero.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, The n-th power of the matrix (or the batch of matrices) x. Its data type should be the same as that of x.
Examples
import paddle x = paddle.to_tensor([[1, 2, 3], [1, 4, 9], [1, 8, 27]], dtype='float64') print(paddle.linalg.matrix_power(x, 2)) # [[6. , 34. , 102.], # [14. , 90. , 282.], # [36. , 250., 804.]] print(paddle.linalg.matrix_power(x, 0)) # [[1., 0., 0.], # [0., 1., 0.], # [0., 0., 1.]] print(paddle.linalg.matrix_power(x, -2)) # [[ 12.91666667, -12.75000000, 2.83333333 ], # [-7.66666667 , 8. , -1.83333333 ], # [ 1.80555556 , -1.91666667 , 0.44444444 ]]
-
max
(
axis=None,
keepdim=False,
name=None
)
[source]
max¶
-
Computes the maximum of tensor elements over the given axis.
Note
The difference between max and amax is: If there are multiple maximum elements, amax evenly distributes gradient between these equal values, while max propagates gradient to all of them.
- Parameters
-
x (Tensor) – A tensor, the data type is float32, float64, int32, int64.
axis (int|list|tuple, optional) – The axis along which the maximum is computed. If
None
, compute the maximum over all elements of x and return a Tensor with a single element, otherwise must be in the range \([-x.ndim(x), x.ndim(x))\). If \(axis[i] < 0\), the axis to reduce is \(x.ndim + axis[i]\).keepdim (bool, optional) – Whether to reserve the reduced dimension in the output Tensor. The result tensor will have one fewer dimension than the x unless
keepdim
is true, default value is False.name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, results of maximum on the specified axis of input tensor, it’s data type is the same as x.
Examples
import paddle # data_x is a Tensor with shape [2, 4] # the axis is a int element x = paddle.to_tensor([[0.2, 0.3, 0.5, 0.9], [0.1, 0.2, 0.6, 0.7]], dtype='float64', stop_gradient=False) result1 = paddle.max(x) result1.backward() print(result1, x.grad) # 0.9, [[0., 0., 0., 1.], [0., 0., 0., 0.]] x.clear_grad() result2 = paddle.max(x, axis=0) result2.backward() print(result2, x.grad) #[0.2, 0.3, 0.6, 0.9], [[1., 1., 0., 1.], [0., 0., 1., 0.]] x.clear_grad() result3 = paddle.max(x, axis=-1) result3.backward() print(result3, x.grad) #[0.9, 0.7], [[0., 0., 0., 1.], [0., 0., 0., 1.]] x.clear_grad() result4 = paddle.max(x, axis=1, keepdim=True) result4.backward() print(result4, x.grad) #[[0.9], [0.7]], [[0., 0., 0., 1.], [0., 0., 0., 1.]] # data_y is a Tensor with shape [2, 2, 2] # the axis is list y = paddle.to_tensor([[[1.0, 2.0], [3.0, 4.0]], [[5.0, 6.0], [7.0, 8.0]]], dtype='float64', stop_gradient=False) result5 = paddle.max(y, axis=[1, 2]) result5.backward() print(result5, y.grad) #[4., 8.], [[[0., 0.], [0., 1.]], [[0., 0.], [0., 1.]]] y.clear_grad() result6 = paddle.max(y, axis=[0, 1]) result6.backward() print(result6, y.grad) #[7., 8.], [[[0., 0.], [0., 0.]], [[0., 0.], [1., 1.]]]
-
maximum
(
y,
name=None
)
[source]
maximum¶
-
Compare two tensors and returns a new tensor containing the element-wise maxima. The equation is:
\[out = max(x, y)\]Note
paddle.maximum
supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ .- Parameters
-
x (Tensor) – the input tensor, it’s data type should be float32, float64, int32, int64.
y (Tensor) – the input tensor, it’s data type should be float32, float64, int32, int64.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
N-D Tensor. A location into which the result is stored. If x, y have different shapes and are “broadcastable”, the resulting tensor shape is the shape of x and y after broadcasting. If x, y have the same shape, its shape is the same as x and y.
Examples
import paddle x = paddle.to_tensor([[1, 2], [7, 8]]) y = paddle.to_tensor([[3, 4], [5, 6]]) res = paddle.maximum(x, y) print(res) # Tensor(shape=[2, 2], dtype=int64, place=Place(cpu), stop_gradient=True, # [[3, 4], # [7, 8]]) x = paddle.to_tensor([[1, 2, 3], [1, 2, 3]]) y = paddle.to_tensor([3, 0, 4]) res = paddle.maximum(x, y) print(res) # Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, # [[3, 2, 4], # [3, 2, 4]]) x = paddle.to_tensor([2, 3, 5], dtype='float32') y = paddle.to_tensor([1, float("nan"), float("nan")], dtype='float32') res = paddle.maximum(x, y) print(res) # Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, # [2. , nan, nan]) x = paddle.to_tensor([5, 3, float("inf")], dtype='float32') y = paddle.to_tensor([1, -float("inf"), 5], dtype='float32') res = paddle.maximum(x, y) print(res) # Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, # [5. , 3. , inf.])
-
mean
(
axis=None,
keepdim=False,
name=None
)
[source]
mean¶
-
Computes the mean of the input tensor’s elements along
axis
.- Parameters
-
x (Tensor) – The input Tensor with data type float32, float64.
axis (int|list|tuple, optional) – The axis along which to perform mean calculations.
axis
should be int, list(int) or tuple(int). Ifaxis
is a list/tuple of dimension(s), mean is calculated along all element(s) ofaxis
.axis
or element(s) ofaxis
should be in range [-D, D), where D is the dimensions ofx
. Ifaxis
or element(s) ofaxis
is less than 0, it works the same way as \(axis + D\) . Ifaxis
is None, mean is calculated over all elements ofx
. Default is None.keepdim (bool, optional) – Whether to reserve the reduced dimension(s) in the output Tensor. If
keepdim
is True, the dimensions of the output Tensor is the same asx
except in the reduced dimensions(it is of size 1 in this case). Otherwise, the shape of the output Tensor is squeezed inaxis
. Default is False.name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, results of average along
axis
ofx
, with the same data type asx
.
Examples
import paddle x = paddle.to_tensor([[[1., 2., 3., 4.], [5., 6., 7., 8.], [9., 10., 11., 12.]], [[13., 14., 15., 16.], [17., 18., 19., 20.], [21., 22., 23., 24.]]]) out1 = paddle.mean(x) # 12.5 out2 = paddle.mean(x, axis=-1) # [[ 2.5 6.5 10.5] # [14.5 18.5 22.5]] out3 = paddle.mean(x, axis=-1, keepdim=True) # [[[ 2.5] # [ 6.5] # [10.5]] # [[14.5] # [18.5] # [22.5]]] out4 = paddle.mean(x, axis=[0, 2]) # [ 8.5 12.5 16.5]
-
median
(
axis=None,
keepdim=False,
name=None
)
[source]
median¶
-
Compute the median along the specified axis.
- Parameters
-
x (Tensor) – The input Tensor, it’s data type can be bool, float16, float32, float64, int32, int64.
axis (int, optional) – The axis along which to perform median calculations
axis
should be int.axis
should be in range [-D, D), where D is the dimensions ofx
. Ifaxis
is less than 0, it works the same way as \(axis + D\). Ifaxis
is None, median is calculated over all elements ofx
. Default is None.keepdim (bool, optional) – Whether to reserve the reduced dimension(s) in the output Tensor. If
keepdim
is True, the dimensions of the output Tensor is the same asx
except in the reduced dimensions(it is of size 1 in this case). Otherwise, the shape of the output Tensor is squeezed inaxis
. Default is False.name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, results of median along
axis
ofx
. If data type ofx
is float64, data type of results will be float64, otherwise data type will be float32.
Examples
import paddle x = paddle.arange(12).reshape([3, 4]) # Tensor(shape=[3, 4], dtype=int64, place=Place(cpu), stop_gradient=True, # [[0 , 1 , 2 , 3 ], # [4 , 5 , 6 , 7 ], # [8 , 9 , 10, 11]]) y1 = paddle.median(x) # Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, # 5.50000000) y2 = paddle.median(x, axis=0) # Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, # [4., 5., 6., 7.]) y3 = paddle.median(x, axis=1) # Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, # [1.50000000, 5.50000000, 9.50000000]) y4 = paddle.median(x, axis=0, keepdim=True) # Tensor(shape=[1, 4], dtype=float32, place=Place(cpu), stop_gradient=True, # [[4., 5., 6., 7.]])
-
min
(
axis=None,
keepdim=False,
name=None
)
[source]
min¶
-
Computes the minimum of tensor elements over the given axis
Note
The difference between min and amin is: If there are multiple minimum elements, amin evenly distributes gradient between these equal values, while min propagates gradient to all of them.
- Parameters
-
x (Tensor) – A tensor, the data type is float32, float64, int32, int64.
axis (int|list|tuple, optional) – The axis along which the minimum is computed. If
None
, compute the minimum over all elements of x and return a Tensor with a single element, otherwise must be in the range \([-x.ndim, x.ndim)\). If \(axis[i] < 0\), the axis to reduce is \(x.ndim + axis[i]\).keepdim (bool, optional) – Whether to reserve the reduced dimension in the output Tensor. The result tensor will have one fewer dimension than the x unless
keepdim
is true, default value is False.name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor, results of minimum on the specified axis of input tensor, it’s data type is the same as input’s Tensor.
Examples
import paddle # data_x is a Tensor with shape [2, 4] # the axis is a int element x = paddle.to_tensor([[0.2, 0.3, 0.5, 0.9], [0.1, 0.2, 0.6, 0.7]], dtype='float64', stop_gradient=False) result1 = paddle.min(x) result1.backward() print(result1, x.grad) # 0.1, [[0., 0., 0., 0.], [1., 0., 0., 0.]] x.clear_grad() result2 = paddle.min(x, axis=0) result2.backward() print(result2, x.grad) #[0.1, 0.2, 0.5, 0.7], [[0., 0., 1., 0.], [1., 1., 0., 1.]] x.clear_grad() result3 = paddle.min(x, axis=-1) result3.backward() print(result3, x.grad) #[0.2, 0.1], [[1., 0., 0., 0.], [1., 0., 0., 0.]] x.clear_grad() result4 = paddle.min(x, axis=1, keepdim=True) result4.backward() print(result4, x.grad) #[[0.2], [0.1]], [[1., 0., 0., 0.], [1., 0., 0., 0.]] # data_y is a Tensor with shape [2, 2, 2] # the axis is list y = paddle.to_tensor([[[1.0, 2.0], [3.0, 4.0]], [[5.0, 6.0], [7.0, 8.0]]], dtype='float64', stop_gradient=False) result5 = paddle.min(y, axis=[1, 2]) result5.backward() print(result5, y.grad) #[1., 5.], [[[1., 0.], [0., 0.]], [[1., 0.], [0., 0.]]] y.clear_grad() result6 = paddle.min(y, axis=[0, 1]) result6.backward() print(result6, y.grad) #[1., 2.], [[[1., 1.], [0., 0.]], [[0., 0.], [0., 0.]]]
-
minimum
(
y,
name=None
)
[source]
minimum¶
-
Compare two tensors and return a new tensor containing the element-wise minima. The equation is:
\[out = min(x, y)\]Note
paddle.minimum
supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ .- Parameters
-
x (Tensor) – the input tensor, it’s data type should be float32, float64, int32, int64.
y (Tensor) – the input tensor, it’s data type should be float32, float64, int32, int64.
name (str, optional) – Name for the operation (optional, default is None). For more information, please refer to Name.
- Returns
-
Tensor. If x, y have different shapes and are “broadcastable”, the resulting tensor shape is the shape of x and y after broadcasting. If x, y have the same shape, its shape is the same as x and y.
Examples
import paddle x = paddle.to_tensor([[1, 2], [7, 8]]) y = paddle.to_tensor([[3, 4], [5, 6]]) res = paddle.minimum(x, y) print(res) # Tensor(shape=[2, 2], dtype=int64, place=Place(cpu), stop_gradient=True, # [[1, 2], # [5, 6]]) x = paddle.to_tensor([[[1, 2, 3], [1, 2, 3]]]) y = paddle.to_tensor([3, 0, 4]) res = paddle.minimum(x, y)
-
abs
(
name=None
)
[source]