mindspore.nn.MaxPool3d

class mindspore.nn.MaxPool3d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)[source]

3D max pooling operation.

Applies a 3D max pooling over an input Tensor which can be regarded as a composition of 3D planes.

Typically the input is of shape \((N_{in}, C_{in}, D_{in}, H_{in}, W_{in})\), MaxPool outputs regional maximum in the \((D_{in}, H_{in}, W_{in})\)-dimension. Given kernel size is \(ks = (d_{ker}, h_{ker}, w_{ker})\) and stride is \(s = (s_0, s_1, s_2)\), the operation is as follows.

\[\text{output}(N_i, C_j, d, h, w) = \max_{l=0, \ldots, d_{ker}-1} \max_{m=0, \ldots, h_{ker}-1} \max_{n=0, \ldots, w_{ker}-1} \text{input}(N_i, C_j, s_0 \times d + l, s_1 \times h + m, s_2 \times w + n)\]
Parameters

  • kernel_size (Union[int, tuple[int]]) – The size of kernel used to take the maximum value, is an int number that represents depth, height and width of the kernel, or a tuple of three int numbers that represent depth, height and width respectively. The value must be a positive integer.

  • stride (Union[int, tuple[int]]) – The moving stride of pooling operation, an int number that represents the moving stride of pooling kernel in the directions of depth, height and the width, or a tuple of three int numbers that represent depth, height and width of movement respectively. The value must be a positive integer. If the value is None, the default value kernel_size is used.

  • padding (Union[int, tuple[int]]) – Pooling padding length. An int number that represents the depth, height and width of movement are both stride, or a tuple of three int numbers that represent depth, height and width of movement respectively. The value cannot be negative. Default: 0.

  • dilation (Union[int, tuple[int]]) – Control the spacing of elements in the pooling kernel. Default: 1.

  • return_indices (bool) – If True, output is a Tuple of 2 Tensors, representing the maxpool result and where the max values are generated. Otherwise, only the maxpool result is returned. Default: False.

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

Inputs:

  • x (Tensor) - Tensor of shape \((N_{in}, C_{in}, D_{in}, H_{in}, W_{in})\) or \((C_{in}, D_{in}, H_{in}, W_{in})\) with data type of int8, int16, int32, int64, uint8, uint16, uint32, uint64, float16, float32 or float64.

Outputs:

If return_indices is False, output is a Tensor, with shape \((N, C, D_{out}, H_{out}, W_{out})\), or \((C_{out}, D_{out}, H_{out}, W_{out})\). It has the same data type as x.

If return_indices is True, output is a Tuple of 2 Tensors, representing the maxpool result and where the max values are generated.

  • output (Tensor) - Maxpooling result, with shape \((N_{out}, C_{out}, D_{out}, H_{out}, W_{out})\) or \((C_{out}, D_{out}, H_{out}, W_{out})\). It has the same data type as x.

  • argmax (Tensor) - Index corresponding to the maximum value. Data type is int64.

Raises

  • TypeError – If x is not a Tensor.

  • ValueError – If length of shape of x is not equal to 5.

  • TypeError – If kernel_size , stride , padding or dilation is neither an int nor a tuple.

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

  • ValueError – If padding is less than 0.

Supported Platforms:

GPU

Examples

>>> import mindspore as ms
>>> import mindspore.nn as nn
>>> import numpy as np
>>> pool1 = nn.MaxPool3d(kernel_size=3, stride=1, padding=1)
>>> pool2 = nn.MaxPool3d(kernel_size=3, stride=1, padding=1, return_indices=True)
>>> x = ms.Tensor(np.random.randint(0, 10, [1, 2, 2, 2, 2]), ms.float32)
>>> output1 = pool1(x)
>>> print(output1)
[[[[[8. 8.]
    [8. 8.]]
   [[8. 8.]
    [8. 8.]]]
  [[[9. 9.]
    [9. 9.]]
   [[9. 9.]
    [9. 9.]]]]]
>>> output2 = pool2(x)
>>> print(output2)
(Tensor(shape=[1, 2, 2, 2, 2], dtype=Float32, value=
[[[[[8.00000000e+000, 8.00000000e+000],
    [8.00000000e+000, 8.00000000e+000]],
   [[8.00000000e+000, 8.00000000e+000],
    [8.00000000e+000, 8.00000000e+000]]],
  [[[9.00000000e+000, 9.00000000e+000],
    [9.00000000e+000, 9.00000000e+000]],
   [[9.00000000e+000, 9.00000000e+000],
    [9.00000000e+000, 9.00000000e+000]]]]]), Tensor(shape=[1, 2, 2, 2, 2], dtype=Int64, value=
[[[[[7, 7],
    [7, 7]],
   [[7, 7],
    [7, 7]]],
  [[[2, 2],
    [2, 2]],
   [[2, 2],
    [2, 2]]]]]))