mindspore.nn.FractionalMaxPool3d

class mindspore.nn.FractionalMaxPool3d(kernel_size, output_size=None, output_ratio=None, return_indices=False, _random_samples=None)[source]

Applies the 3D FractionalMaxPool operatin over input. The output Tensor shape can be determined by either output_size or output_ratio, and the step size is determined by _random_samples. output_size will take effect when output_size and output_ratio are set at the same time. And output_size and output_ratio can not be None at the same time.

Refer to the paper Fractional MaxPooling by Ben Graham for more details.

The input and output data format can be “NCDHW”. N is the batch size, C is the number of channels, D the feature depth, H is the feature height, and W is the feature width.

Parameters

kernel_size (Union[int, tuple[int]]) – The size of kernel used to take the maximum value, is a positive int that represents depth, height and width of the kernel, or a tuple of three positive integers that represent depth, height and width respectively.
output_size (Union[int, tuple[int]], optional) – The shape of the target output_size, is an int number that represents depth, height and width, or a tuple of three positive integers that represents depth, height and width respectively. If None , the shape of the target will be determined by output_ratio. Default: None .
output_ratio (Union[float, tuple[float]], optional) – The ratio of target output shape to input shape. Specifying the size of the output tensor by using a ratio of the input size. Data type : float16, float32, float64, and value is between (0, 1). If None , the shape of the target will be determined by output_size.Default: None .
return_indices (bool, optional) – Whether to return the indices of max value. Default: False .
_random_samples (Tensor, optional) – The random step of FractionalMaxPool3d, which is a 3D tensor. Tensor of data type: float16, float32, double, and value is between [0, 1). Supported shape \((N, C, 3)\) or \((1, C, 3)\) . Default: None, the values of _random_samples will be randomly distributed using uniform distribution over an interval [0,1).

Inputs:

input (Tensor) - The input of FractionalMaxPool3d, which is a 4D or 5D tensor. Tensor of data type : float16, float32, float64. Supported shape \((N, C, D_{in}, H_{in}, W_{in})\) or \((C, D_{in}, H_{in}, W_{in})\).

Outputs:

y (Tensor) - A tensor, the output of FractionalMaxPool3d. Has the same data type with input. Has the shape \((N, C, D_{out}, H_{out}, W_{out})\) or \((C, D_{out}, H_{out}, W_{out})\) , where \((D_{out}, H_{out}, W_{out})\) = output_size or \((D_{out}, H_{out}, W_{out})\) = output_ratio * \((D_{in}, H_{in}, W_{in})\) .
argmax (Tensor) - The indices along with the outputs, which is a Tensor, with the same shape as the y and int32 data type. It will output only when return_indices is True.

Raises

TypeError – If input is not a 4D or 5D tensor.
TypeError – If _random_samples is not a 3D tensor.
TypeError – If data type of imput_x is not float16, float32, float64.
TypeError – If dtype of _random_samples is not float16, float32, float64.
TypeError – If dtype of argmax is not int32, int64.
TypeError – if _random_samples to have the different dtypes as input.
ValueError – If output_size is a tuple and if output_size length is not 3.
ValueError – If kernel_size is a tuple and if kernel_size length is not 3.
ValueError – If numbers in output_size or kernel_size is not positive.
ValueError – if output_size and output_ratio are None at the same time.
ValueError – If the first dimension size of input and _random_samples is not equal.
ValueError – If the second dimension size of input and _random_samples is not equal.
ValueError – If the third dimension size of _random_samples is not 3.

Supported Platforms:: GPU CPU

Examples

>>> import numpy as np
>>> import mindspore as ms
>>> x = ms.Tensor(np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16])
...            .reshape([1, 1, 2, 2, 4]), ms.float32)
>>> _random_samples = ms.Tensor(np.array([0.7, 0.7, 0.7]).reshape([1, 1, 3]), ms.float32)
>>> net = ms.nn.FractionalMaxPool3d(kernel_size=(1, 1, 1), output_size=(1, 1, 3),
...                              _random_samples=_random_samples, return_indices=True)
>>> output, argmax = net(x)
>>> print(output)
[[[[[13. 14. 16.]]]]]
>>> print(argmax)
[[[[[12 13 15]]]]]
>>> net = ms.nn.FractionalMaxPool3d(kernel_size=(1, 1, 1), output_ratio=(0.5, 0.5, 0.5),
...                              _random_samples=_random_samples, return_indices=True)
>>> output, argmax = net(x)
>>> print(output)
[[[[[13. 16.]]]]]
>>> print(argmax)
[[[[[12 15]]]]]