mindspore.ops.lp_pool1d

mindspore.ops.lp_pool1d(x, norm_type, kernel_size, stride=None, ceil_mode=False)[source]

Applies a 1D power lp pooling over an input signal composed of several input planes.

Typically the input is of shape \((N, C, L_{in})\) or \((C, L_{in})\), the output is of shape \((N, C, L_{in})\) or \((C, L_{in})\), with the same shape as input, the operation is as follows.

\[f(X) = \sqrt[p]{\sum_{x \in X} x^{p}}\]
Parameters

  • x (Tensor) – Tensor of shape \((N, C, L_{in})\) or \((C, L_{in})\).

  • norm_type (Union[int, float]) –

    Type of normalization, represents p in the formula, can not be 0,

    • if p = 1, one gets Sum Pooling (which is proportional to Average Pooling),

    • if p = \(\infty\), one gets Max Pooling.

  • kernel_size (int) – The size of kernel window.

  • stride (int) – The distance of kernel moving, an int number that represents the width of movement is stride, if the value is None, the default value kernel_size is used;

  • ceil_mode (bool) – Whether to use ceil or floor to calculate output shape. Default: False.

Returns

  • output (Tensor) - LPPool1d result, with shape \((N, C, L_{in})\) or \((C, L_{in})\), It has the same data type as x.

Raises

  • TypeError – If x is not an Tensor.

  • TypeError – If kernel_size or stride is not an int.

  • TypeError – If ceil_mode is not a bool.

  • TypeError – If norm_type is neither float nor int.

  • ValueError – If norm_type is equal to 0.

  • ValueError – If kernel_size or stride is less than 1.

  • ValueError – If length of shape of x is not equal to 2 or 3.

Supported Platforms:

Ascend GPU CPU

Examples

>>> import mindspore as ms
>>> import mindspore.ops as ops
>>> from mindspore import Tensor
>>> import numpy as np
>>> x = Tensor(np.arange(2 * 3 * 4).reshape((2, 3, 4)), dtype=ms.float32)
>>> out = ops.lp_pool1d(x, norm_type=1, kernel_size=3, stride=1, ceil_mode=False)
>>> print(out)
[[[ 3.  6.]
  [15. 18.]
  [27. 30.]]
 [[39. 42.]
  [51. 54.]
  [63. 66.]]]