Rate this Page
★ ★ ★ ★ ★

LPPool3d#

class torch.nn.LPPool3d(norm_type, kernel_size, stride=None, ceil_mode=False)[source]#

Applies a 3D power-average pooling over an input signal composed of several input planes.

On each window, the function computed is:

f(X)=∑x∈Xxppf(X) = \sqrt[p]{\sum_{x \in X} x^{p}}
  • At p = ∞\infty, one gets Max Pooling over absolute values

  • At p = 1, one gets Sum Pooling (which is proportional to average pooling)

The parameters kernel_size, stride can either be:

  • a single int – in which case the same value is used for the height, width and depth dimension

  • a tuple of three ints – in which case, the first int is used for the depth dimension, the second int for the height dimension and the third int for the width dimension

Note

If the sum to the power of p is zero, the gradient of this function is not defined. This implementation will set the gradient to zero in this case.

Parameters:
  • norm_type (int or float) – the power pp used to compute pooling. Must be non-zero; positive and negative infinity are supported.

  • kernel_size (int or tuple of int) – the size of the window.

  • stride (int or tuple of int, optional) – the stride of the window. Default: kernel_size.

  • ceil_mode (bool, optional) – when True, use ceil instead of floor to compute the output shape. Default: False.

Note

When ceil_mode is True, sliding windows may go off-bounds if they start within the left padding or the input. Sliding windows that would start in the right padded region are ignored.

Shape:
  • Input: (N,C,Din,Hin,Win)(N, C, D_{in}, H_{in}, W_{in}) or (C,Din,Hin,Win)(C, D_{in}, H_{in}, W_{in}).

  • Output: (N,C,Dout,Hout,Wout)(N, C, D_{out}, H_{out}, W_{out}) or (C,Dout,Hout,Wout)(C, D_{out}, H_{out}, W_{out}), where

    Dout=⌊Din−kernel_size[0]stride[0]+1⌋D_{out} = \left\lfloor\frac{D_{in} - \text{kernel\_size}[0]}{\text{stride}[0]} + 1\right\rfloor
    Hout=⌊Hin−kernel_size[1]stride[1]+1⌋H_{out} = \left\lfloor\frac{H_{in} - \text{kernel\_size}[1]}{\text{stride}[1]} + 1\right\rfloor
    Wout=⌊Win−kernel_size[2]stride[2]+1⌋W_{out} = \left\lfloor\frac{W_{in} - \text{kernel\_size}[2]}{\text{stride}[2]} + 1\right\rfloor

Examples:

>>> # power-2 pool of square window of size=3, stride=2
>>> m = nn.LPPool3d(2, 3, stride=2)
>>> # pool of non-square window of power 1.2
>>> m = nn.LPPool3d(1.2, (3, 2, 2), stride=(2, 1, 2))
>>> input = torch.randn(20, 16, 50, 44, 31)
>>> output = m(input)
forward(input)[source]#

Runs the forward pass.

Return type:

Tensor